diff options
| author | Tom Rondeau <trondeau@vt.edu> | 2013-01-02 13:01:53 -0500 |
|---|---|---|
| committer | Tom Rondeau <trondeau@vt.edu> | 2013-01-02 13:01:53 -0500 |
| commit | 1114f81d59abd87cbb0c10d88ab243935ba9e35f (patch) | |
| tree | d1bfd000c2292af12e5aa96d764ee85c29d9f746 /gruel/src/lib | |
| parent | 69f57364c5b8fc575b6a956468025da37d32b1a6 (diff) | |
| parent | aa4245a69bf6954bf45c51aa7ffec9d049e09edc (diff) | |
Merge branch 'pmt_rename' into next
Conflicts:
gnuradio-core/src/lib/io/gr_pdu.cc
gruel/src/lib/pmt/pmt.cc
gruel/src/lib/pmt/qa_pmt_prims.cc
gruel/src/lib/pmt/unv_template.cc.t
gruel/src/swig/pmt_swig.i
Diffstat (limited to 'gruel/src/lib')
| -rw-r--r-- | gruel/src/lib/pmt/pmt.cc | 533 | ||||
| -rw-r--r-- | gruel/src/lib/pmt/pmt_io.cc | 88 | ||||
| -rw-r--r-- | gruel/src/lib/pmt/pmt_serialize.cc | 254 | ||||
| -rw-r--r-- | gruel/src/lib/pmt/qa_pmt_prims.cc | 644 | ||||
| -rw-r--r-- | gruel/src/lib/pmt/unv_qa_template.cc.t | 24 | ||||
| -rw-r--r-- | gruel/src/lib/pmt/unv_template.cc.t | 32 |
6 files changed, 792 insertions, 783 deletions
diff --git a/gruel/src/lib/pmt/pmt.cc b/gruel/src/lib/pmt/pmt.cc index 1d1e9ba7c8..8ea0e76143 100644 --- a/gruel/src/lib/pmt/pmt.cc +++ b/gruel/src/lib/pmt/pmt.cc @@ -69,23 +69,23 @@ pmt_base::~pmt_base() // Exceptions //////////////////////////////////////////////////////////////////////////// -pmt_exception::pmt_exception(const std::string &msg, pmt_t obj) - : logic_error(msg + ": " + pmt_write_string(obj)) +exception::exception(const std::string &msg, pmt_t obj) + : logic_error(msg + ": " + write_string(obj)) { } -pmt_wrong_type::pmt_wrong_type(const std::string &msg, pmt_t obj) - : pmt_exception(msg + ": wrong_type ", obj) +wrong_type::wrong_type(const std::string &msg, pmt_t obj) + : exception(msg + ": wrong_type ", obj) { } -pmt_out_of_range::pmt_out_of_range(const std::string &msg, pmt_t obj) - : pmt_exception(msg + ": out of range ", obj) +out_of_range::out_of_range(const std::string &msg, pmt_t obj) + : exception(msg + ": out of range ", obj) { } -pmt_notimplemented::pmt_notimplemented(const std::string &msg, pmt_t obj) - : pmt_exception(msg + ": notimplemented ", obj) +notimplemented::notimplemented(const std::string &msg, pmt_t obj) + : exception(msg + ": notimplemented ", obj) { } @@ -157,10 +157,10 @@ _any(pmt_t x) // Globals //////////////////////////////////////////////////////////////////////////// -const pmt_t PMT_T = pmt_t(new pmt_bool()); // singleton -const pmt_t PMT_F = pmt_t(new pmt_bool()); // singleton -const pmt_t PMT_NIL = pmt_t(new pmt_null()); // singleton -const pmt_t PMT_EOF = pmt_cons(PMT_NIL, PMT_NIL); // singleton +const pmt_t PMT_T = pmt_t(new pmt_bool()); // singleton +const pmt_t PMT_F = pmt_t(new pmt_bool()); // singleton +const pmt_t PMT_NIL = pmt_t(new pmt_null()); // singleton +const pmt_t PMT_EOF = cons(PMT_NIL, PMT_NIL); // singleton //////////////////////////////////////////////////////////////////////////// // Booleans @@ -169,37 +169,37 @@ const pmt_t PMT_EOF = pmt_cons(PMT_NIL, PMT_NIL); // singleton pmt_bool::pmt_bool(){} bool -pmt_is_true(pmt_t obj) +is_true(pmt_t obj) { return obj != PMT_F; } bool -pmt_is_false(pmt_t obj) +is_false(pmt_t obj) { return obj == PMT_F; } bool -pmt_is_bool(pmt_t obj) +is_bool(pmt_t obj) { return obj->is_bool(); } pmt_t -pmt_from_bool(bool val) +from_bool(bool val) { return val ? PMT_T : PMT_F; } bool -pmt_to_bool(pmt_t val) +to_bool(pmt_t val) { if (val == PMT_T) return true; if (val == PMT_F) return false; - throw pmt_wrong_type("pmt_to_bool", val); + throw wrong_type("pmt_to_bool", val); } //////////////////////////////////////////////////////////////////////////// @@ -230,13 +230,13 @@ hash_string(const std::string &s) } bool -pmt_is_symbol(const pmt_t& obj) +is_symbol(const pmt_t& obj) { return obj->is_symbol(); } pmt_t -pmt_string_to_symbol(const std::string &name) +string_to_symbol(const std::string &name) { unsigned hash = hash_string(name) % SYMBOL_HASH_TABLE_SIZE; @@ -255,16 +255,16 @@ pmt_string_to_symbol(const std::string &name) // alias... pmt_t -pmt_intern(const std::string &name) +intern(const std::string &name) { - return pmt_string_to_symbol(name); + return string_to_symbol(name); } const std::string -pmt_symbol_to_string(const pmt_t& sym) +symbol_to_string(const pmt_t& sym) { if (!sym->is_symbol()) - throw pmt_wrong_type("pmt_symbol_to_string", sym); + throw wrong_type("pmt_symbol_to_string", sym); return _symbol(sym)->name(); } @@ -276,7 +276,7 @@ pmt_symbol_to_string(const pmt_t& sym) //////////////////////////////////////////////////////////////////////////// bool -pmt_is_number(pmt_t x) +is_number(pmt_t x) { return x->is_number(); } @@ -288,26 +288,26 @@ pmt_is_number(pmt_t x) pmt_integer::pmt_integer(long value) : d_value(value) {} bool -pmt_is_integer(pmt_t x) +is_integer(pmt_t x) { return x->is_integer(); } pmt_t -pmt_from_long(long x) +from_long(long x) { return pmt_t(new pmt_integer(x)); } long -pmt_to_long(pmt_t x) +to_long(pmt_t x) { pmt_integer* i = dynamic_cast<pmt_integer*>(x.get()); if ( i ) return i->value(); - throw pmt_wrong_type("pmt_to_long", x); + throw wrong_type("pmt_to_long", x); } //////////////////////////////////////////////////////////////////////////// @@ -317,20 +317,20 @@ pmt_to_long(pmt_t x) pmt_uint64::pmt_uint64(uint64_t value) : d_value(value) {} bool -pmt_is_uint64(pmt_t x) +is_uint64(pmt_t x) { return x->is_uint64(); } pmt_t -pmt_from_uint64(uint64_t x) +from_uint64(uint64_t x) { return pmt_t(new pmt_uint64(x)); } uint64_t -pmt_to_uint64(pmt_t x) +to_uint64(pmt_t x) { if(x->is_uint64()) return _uint64(x)->value(); @@ -341,7 +341,7 @@ pmt_to_uint64(pmt_t x) return (uint64_t) tmp; } - throw pmt_wrong_type("pmt_to_uint64", x); + throw wrong_type("pmt_to_uint64", x); } //////////////////////////////////////////////////////////////////////////// @@ -351,26 +351,26 @@ pmt_to_uint64(pmt_t x) pmt_real::pmt_real(double value) : d_value(value) {} bool -pmt_is_real(pmt_t x) +is_real(pmt_t x) { return x->is_real(); } pmt_t -pmt_from_double(double x) +from_double(double x) { return pmt_t(new pmt_real(x)); } double -pmt_to_double(pmt_t x) +to_double(pmt_t x) { if (x->is_real()) return _real(x)->value(); if (x->is_integer()) return _integer(x)->value(); - throw pmt_wrong_type("pmt_to_double", x); + throw wrong_type("pmt_to_double", x); } //////////////////////////////////////////////////////////////////////////// @@ -380,13 +380,19 @@ pmt_to_double(pmt_t x) pmt_complex::pmt_complex(std::complex<double> value) : d_value(value) {} bool -pmt_is_complex(pmt_t x) +is_complex(pmt_t x) { return x->is_complex(); } pmt_t -pmt_make_rectangular(double re, double im) +make_rectangular(double re, double im) +{ + return from_complex(re, im); +} + +pmt_t +from_complex(double re, double im) { return pmt_from_complex(re, im); } @@ -396,13 +402,14 @@ pmt_t pmt_from_complex(double re, double im) return pmt_t(new pmt_complex(std::complex<double>(re, im))); } -pmt_t pmt_from_complex(const std::complex<double> &z) +pmt_t +from_complex(const std::complex<double> &z) { return pmt_t(new pmt_complex(z)); } std::complex<double> -pmt_to_complex(pmt_t x) +to_complex(pmt_t x) { if (x->is_complex()) return _complex(x)->value(); @@ -411,7 +418,7 @@ pmt_to_complex(pmt_t x) if (x->is_integer()) return _integer(x)->value(); - throw pmt_wrong_type("pmt_to_complex", x); + throw wrong_type("pmt_to_complex", x); } //////////////////////////////////////////////////////////////////////////// @@ -422,59 +429,59 @@ pmt_null::pmt_null() {} pmt_pair::pmt_pair(const pmt_t& car, const pmt_t& cdr) : d_car(car), d_cdr(cdr) {} bool -pmt_is_null(const pmt_t& x) +is_null(const pmt_t& x) { return x == PMT_NIL; } bool -pmt_is_pair(const pmt_t& obj) +is_pair(const pmt_t& obj) { return obj->is_pair(); } pmt_t -pmt_cons(const pmt_t& x, const pmt_t& y) +cons(const pmt_t& x, const pmt_t& y) { return pmt_t(new pmt_pair(x, y)); } pmt_t -pmt_car(const pmt_t& pair) +car(const pmt_t& pair) { pmt_pair* p = dynamic_cast<pmt_pair*>(pair.get()); if ( p ) return p->car(); - throw pmt_wrong_type("pmt_car", pair); + throw wrong_type("pmt_car", pair); } pmt_t -pmt_cdr(const pmt_t& pair) +cdr(const pmt_t& pair) { pmt_pair* p = dynamic_cast<pmt_pair*>(pair.get()); if ( p ) return p->cdr(); - throw pmt_wrong_type("pmt_cdr", pair); + throw wrong_type("pmt_cdr", pair); } void -pmt_set_car(pmt_t pair, pmt_t obj) +set_car(pmt_t pair, pmt_t obj) { if (pair->is_pair()) _pair(pair)->set_car(obj); else - throw pmt_wrong_type("pmt_set_car", pair); + throw wrong_type("pmt_set_car", pair); } void -pmt_set_cdr(pmt_t pair, pmt_t obj) +set_cdr(pmt_t pair, pmt_t obj) { if (pair->is_pair()) _pair(pair)->set_cdr(obj); else - throw pmt_wrong_type("pmt_set_cdr", pair); + throw wrong_type("pmt_set_cdr", pair); } //////////////////////////////////////////////////////////////////////////// @@ -492,7 +499,7 @@ pmt_t pmt_vector::ref(size_t k) const { if (k >= length()) - throw pmt_out_of_range("pmt_vector_ref", pmt_from_long(k)); + throw out_of_range("pmt_vector_ref", from_long(k)); return d_v[k]; } @@ -500,7 +507,7 @@ void pmt_vector::set(size_t k, pmt_t obj) { if (k >= length()) - throw pmt_out_of_range("pmt_vector_set", pmt_from_long(k)); + throw out_of_range("pmt_vector_set", from_long(k)); d_v[k] = obj; } @@ -512,38 +519,38 @@ pmt_vector::fill(pmt_t obj) } bool -pmt_is_vector(pmt_t obj) +is_vector(pmt_t obj) { return obj->is_vector(); } pmt_t -pmt_make_vector(size_t k, pmt_t fill) +make_vector(size_t k, pmt_t fill) { return pmt_t(new pmt_vector(k, fill)); } pmt_t -pmt_vector_ref(pmt_t vector, size_t k) +vector_ref(pmt_t vector, size_t k) { if (!vector->is_vector()) - throw pmt_wrong_type("pmt_vector_ref", vector); + throw wrong_type("pmt_vector_ref", vector); return _vector(vector)->ref(k); } void -pmt_vector_set(pmt_t vector, size_t k, pmt_t obj) +vector_set(pmt_t vector, size_t k, pmt_t obj) { if (!vector->is_vector()) - throw pmt_wrong_type("pmt_vector_set", vector); + throw wrong_type("pmt_vector_set", vector); _vector(vector)->set(k, obj); } void -pmt_vector_fill(pmt_t vector, pmt_t obj) +vector_fill(pmt_t vector, pmt_t obj) { if (!vector->is_vector()) - throw pmt_wrong_type("pmt_vector_set", vector); + throw wrong_type("pmt_vector_set", vector); _vector(vector)->fill(obj); } @@ -560,21 +567,21 @@ pmt_t pmt_tuple::ref(size_t k) const { if (k >= length()) - throw pmt_out_of_range("pmt_tuple_ref", pmt_from_long(k)); + throw out_of_range("pmt_tuple_ref", from_long(k)); return d_v[k]; } bool -pmt_is_tuple(pmt_t obj) +is_tuple(pmt_t obj) { return obj->is_tuple(); } pmt_t -pmt_tuple_ref(const pmt_t &tuple, size_t k) +tuple_ref(const pmt_t &tuple, size_t k) { if (!tuple->is_tuple()) - throw pmt_wrong_type("pmt_tuple_ref", tuple); + throw wrong_type("pmt_tuple_ref", tuple); return _tuple(tuple)->ref(k); } @@ -582,13 +589,13 @@ pmt_tuple_ref(const pmt_t &tuple, size_t k) // make_constructor() pmt_t -pmt_make_tuple() +make_tuple() { return pmt_t(new pmt_tuple(0)); } pmt_t -pmt_make_tuple(const pmt_t &e0) +make_tuple(const pmt_t &e0) { pmt_tuple *t = new pmt_tuple(1); t->_set(0, e0); @@ -596,7 +603,7 @@ pmt_make_tuple(const pmt_t &e0) } pmt_t -pmt_make_tuple(const pmt_t &e0, const pmt_t &e1) +make_tuple(const pmt_t &e0, const pmt_t &e1) { pmt_tuple *t = new pmt_tuple(2); t->_set(0, e0); @@ -605,7 +612,7 @@ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1) } pmt_t -pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2) +make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2) { pmt_tuple *t = new pmt_tuple(3); t->_set(0, e0); @@ -615,7 +622,7 @@ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2) } pmt_t -pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3) +make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3) { pmt_tuple *t = new pmt_tuple(4); t->_set(0, e0); @@ -626,7 +633,7 @@ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e } pmt_t -pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4) +make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4) { pmt_tuple *t = new pmt_tuple(5); t->_set(0, e0); @@ -638,7 +645,7 @@ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e } pmt_t -pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5) +make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5) { pmt_tuple *t = new pmt_tuple(6); t->_set(0, e0); @@ -651,7 +658,7 @@ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e } pmt_t -pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6) +make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6) { pmt_tuple *t = new pmt_tuple(7); t->_set(0, e0); @@ -665,7 +672,7 @@ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e } pmt_t -pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7) +make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7) { pmt_tuple *t = new pmt_tuple(8); t->_set(0, e0); @@ -680,7 +687,7 @@ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e } pmt_t -pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8) +make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8) { pmt_tuple *t = new pmt_tuple(9); t->_set(0, e0); @@ -696,7 +703,7 @@ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e } pmt_t -pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8, const pmt_t &e9) +make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8, const pmt_t &e9) { pmt_tuple *t = new pmt_tuple(10); t->_set(0, e0); @@ -713,12 +720,12 @@ pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e } pmt_t -pmt_to_tuple(const pmt_t &x) +to_tuple(const pmt_t &x) { if (x->is_tuple()) // already one return x; - size_t len = pmt_length(x); + size_t len = length(x); pmt_tuple *t = new pmt_tuple(len); pmt_t r = pmt_t(t); @@ -731,13 +738,13 @@ pmt_to_tuple(const pmt_t &x) if (x->is_pair()){ pmt_t y = x; for (size_t i = 0; i < len; i++){ - t->_set(i, pmt_car(y)); - y = pmt_cdr(y); + t->_set(i, car(y)); + y = cdr(y); } return r; } - throw pmt_wrong_type("pmt_to_tuple", x); + throw wrong_type("pmt_to_tuple", x); } @@ -747,24 +754,24 @@ pmt_to_tuple(const pmt_t &x) //////////////////////////////////////////////////////////////////////////// bool -pmt_is_uniform_vector(pmt_t x) +is_uniform_vector(pmt_t x) { return x->is_uniform_vector(); } const void * -pmt_uniform_vector_elements(pmt_t vector, size_t &len) +uniform_vector_elements(pmt_t vector, size_t &len) { if (!vector->is_uniform_vector()) - throw pmt_wrong_type("pmt_uniform_vector_elements", vector); + throw wrong_type("pmt_uniform_vector_elements", vector); return _uniform_vector(vector)->uniform_elements(len); } void * -pmt_uniform_vector_writable_elements(pmt_t vector, size_t &len) +uniform_vector_writable_elements(pmt_t vector, size_t &len) { if (!vector->is_uniform_vector()) - throw pmt_wrong_type("pmt_uniform_vector_writable_elements", vector); + throw wrong_type("pmt_uniform_vector_writable_elements", vector); return _uniform_vector(vector)->uniform_writable_elements(len); } @@ -781,82 +788,82 @@ pmt_uniform_vector_writable_elements(pmt_t vector, size_t &len) */ bool -pmt_is_dict(const pmt_t &obj) +is_dict(const pmt_t &obj) { - return pmt_is_null(obj) || pmt_is_pair(obj); + return is_null(obj) || is_pair(obj); } pmt_t -pmt_make_dict() +make_dict() { return PMT_NIL; } pmt_t -pmt_dict_add(const pmt_t &dict, const pmt_t &key, const pmt_t &value) +dict_add(const pmt_t &dict, const pmt_t &key, const pmt_t &value) { - if (pmt_is_null(dict)) - return pmt_acons(key, value, PMT_NIL); + if (is_null(dict)) + return acons(key, value, PMT_NIL); - if (pmt_dict_has_key(dict, key)) - return pmt_acons(key, value, pmt_dict_delete(dict, key)); + if (dict_has_key(dict, key)) + return acons(key, value, dict_delete(dict, key)); - return pmt_acons(key, value, dict); + return acons(key, value, dict); } pmt_t -pmt_dict_delete(const pmt_t &dict, const pmt_t &key) +dict_delete(const pmt_t &dict, const pmt_t &key) { - if (pmt_is_null(dict)) + if (is_null(dict)) return dict; - if (pmt_eqv(pmt_caar(dict), key)) - return pmt_cdr(dict); + if (eqv(caar(dict), key)) + return cdr(dict); - return pmt_cons(pmt_car(dict), pmt_dict_delete(pmt_cdr(dict), key)); + return cons(car(dict), dict_delete(cdr(dict), key)); } pmt_t -pmt_dict_ref(const pmt_t &dict, const pmt_t &key, const pmt_t ¬_found) +dict_ref(const pmt_t &dict, const pmt_t &key, const pmt_t ¬_found) { - pmt_t p = pmt_assv(key, dict); // look for (key . value) pair - if (pmt_is_pair(p)) - return pmt_cdr(p); + pmt_t p = assv(key, dict); // look for (key . value) pair + if (is_pair(p)) + return cdr(p); else return not_found; } bool -pmt_dict_has_key(const pmt_t &dict, const pmt_t &key) +dict_has_key(const pmt_t &dict, const pmt_t &key) { - return pmt_is_pair(pmt_assv(key, dict)); + return is_pair(assv(key, dict)); } pmt_t -pmt_dict_items(pmt_t dict) +dict_items(pmt_t dict) { - if (!pmt_is_dict(dict)) - throw pmt_wrong_type("pmt_dict_values", dict); + if (!is_dict(dict)) + throw wrong_type("pmt_dict_values", dict); return dict; // equivalent to dict in the a-list case } pmt_t -pmt_dict_keys(pmt_t dict) +dict_keys(pmt_t dict) { - if (!pmt_is_dict(dict)) - throw pmt_wrong_type("pmt_dict_keys", dict); + if (!is_dict(dict)) + throw wrong_type("pmt_dict_keys", dict); - return pmt_map(pmt_car, dict); + return map(car, dict); } pmt_t -pmt_dict_values(pmt_t dict) +dict_values(pmt_t dict) { - if (!pmt_is_dict(dict)) - throw pmt_wrong_type("pmt_dict_keys", dict); + if (!is_dict(dict)) + throw wrong_type("pmt_dict_keys", dict); - return pmt_map(pmt_cdr, dict); + return map(cdr, dict); } //////////////////////////////////////////////////////////////////////////// @@ -866,30 +873,30 @@ pmt_dict_values(pmt_t dict) pmt_any::pmt_any(const boost::any &any) : d_any(any) {} bool -pmt_is_any(pmt_t obj) +is_any(pmt_t obj) { return obj->is_any(); } pmt_t -pmt_make_any(const boost::any &any) +make_any(const boost::any &any) { return pmt_t(new pmt_any(any)); } boost::any -pmt_any_ref(pmt_t obj) +any_ref(pmt_t obj) { if (!obj->is_any()) - throw pmt_wrong_type("pmt_any_ref", obj); + throw wrong_type("pmt_any_ref", obj); return _any(obj)->ref(); } void -pmt_any_set(pmt_t obj, const boost::any &any) +any_set(pmt_t obj, const boost::any &any) { if (!obj->is_any()) - throw pmt_wrong_type("pmt_any_set", obj); + throw wrong_type("pmt_any_set", obj); _any(obj)->set(any); } @@ -898,31 +905,31 @@ pmt_any_set(pmt_t obj, const boost::any &any) //////////////////////////////////////////////////////////////////////////// bool -pmt_is_msg_accepter(const pmt_t &obj) +is_msg_accepter(const pmt_t &obj) { - if (!pmt_is_any(obj)) + if (!is_any(obj)) return false; - boost::any r = pmt_any_ref(obj); + boost::any r = any_ref(obj); return boost::any_cast<gruel::msg_accepter_sptr>(&r) != 0; } //! make a msg_accepter pmt_t -pmt_make_msg_accepter(gruel::msg_accepter_sptr ma) +make_msg_accepter(gruel::msg_accepter_sptr ma) { - return pmt_make_any(ma); + return make_any(ma); } //! Return underlying msg_accepter gruel::msg_accepter_sptr -pmt_msg_accepter_ref(const pmt_t &obj) +msg_accepter_ref(const pmt_t &obj) { try { - return boost::any_cast<gruel::msg_accepter_sptr>(pmt_any_ref(obj)); + return boost::any_cast<gruel::msg_accepter_sptr>(any_ref(obj)); } catch (boost::bad_any_cast &e){ - throw pmt_wrong_type("pmt_msg_accepter_ref", obj); + throw wrong_type("pmt_msg_accepter_ref", obj); } } @@ -932,30 +939,30 @@ pmt_msg_accepter_ref(const pmt_t &obj) //////////////////////////////////////////////////////////////////////////// bool -pmt_is_blob(pmt_t x) +is_blob(pmt_t x) { - // return pmt_is_u8vector(x); - return pmt_is_uniform_vector(x); + // return is_u8vector(x); + return is_uniform_vector(x); } pmt_t -pmt_make_blob(const void *buf, size_t len_in_bytes) +make_blob(const void *buf, size_t len_in_bytes) { - return pmt_init_u8vector(len_in_bytes, (const uint8_t *) buf); + return init_u8vector(len_in_bytes, (const uint8_t *) buf); } const void * -pmt_blob_data(pmt_t blob) +blob_data(pmt_t blob) { size_t len; - return pmt_uniform_vector_elements(blob, len); + return uniform_vector_elements(blob, len); } size_t -pmt_blob_length(pmt_t blob) +blob_length(pmt_t blob) { size_t len; - pmt_uniform_vector_elements(blob, len); + uniform_vector_elements(blob, len); return len; } @@ -965,13 +972,13 @@ pmt_blob_length(pmt_t blob) //////////////////////////////////////////////////////////////////////////// bool -pmt_eq(const pmt_t& x, const pmt_t& y) +eq(const pmt_t& x, const pmt_t& y) { return x == y; } bool -pmt_eqv(const pmt_t& x, const pmt_t& y) +eqv(const pmt_t& x, const pmt_t& y) { if (x == y) return true; @@ -992,7 +999,7 @@ pmt_eqv(const pmt_t& x, const pmt_t& y) } bool -pmt_eqv_raw(pmt_base *x, pmt_base *y) +eqv_raw(pmt_base *x, pmt_base *y) { if (x == y) return true; @@ -1013,13 +1020,13 @@ pmt_eqv_raw(pmt_base *x, pmt_base *y) } bool -pmt_equal(const pmt_t& x, const pmt_t& y) +equal(const pmt_t& x, const pmt_t& y) { - if (pmt_eqv(x, y)) + if (eqv(x, y)) return true; if (x->is_pair() && y->is_pair()) - return pmt_equal(pmt_car(x), pmt_car(y)) && pmt_equal(pmt_cdr(x), pmt_cdr(y)); + return equal(car(x), car(y)) && equal(cdr(x), cdr(y)); if (x->is_vector() && y->is_vector()){ pmt_vector *xv = _vector(x); @@ -1028,7 +1035,7 @@ pmt_equal(const pmt_t& x, const pmt_t& y) return false; for (unsigned i = 0; i < xv->length(); i++) - if (!pmt_equal(xv->_ref(i), yv->_ref(i))) + if (!equal(xv->_ref(i), yv->_ref(i))) return false; return true; @@ -1041,7 +1048,7 @@ pmt_equal(const pmt_t& x, const pmt_t& y) return false; for (unsigned i = 0; i < xv->length(); i++) - if (!pmt_equal(xv->_ref(i), yv->_ref(i))) + if (!equal(xv->_ref(i), yv->_ref(i))) return false; return true; @@ -1068,7 +1075,7 @@ pmt_equal(const pmt_t& x, const pmt_t& y) } size_t -pmt_length(const pmt_t& x) +length(const pmt_t& x) { if (x->is_vector()) return _vector(x)->length(); @@ -1084,35 +1091,35 @@ pmt_length(const pmt_t& x) if (x->is_pair()) { size_t length=1; - pmt_t it = pmt_cdr(x); - while (pmt_is_pair(it)){ + pmt_t it = cdr(x); + while (is_pair(it)){ length++; - it = pmt_cdr(it); + it = cdr(it); } - if (pmt_is_null(it)) + if (is_null(it)) return length; // not a proper list - throw pmt_wrong_type("pmt_length", x); + throw wrong_type("pmt_length", x); } // FIXME dictionary length (number of entries) - throw pmt_wrong_type("pmt_length", x); + throw wrong_type("pmt_length", x); } pmt_t -pmt_assq(pmt_t obj, pmt_t alist) +assq(pmt_t obj, pmt_t alist) { - while (pmt_is_pair(alist)){ - pmt_t p = pmt_car(alist); - if (!pmt_is_pair(p)) // malformed alist + while (is_pair(alist)){ + pmt_t p = car(alist); + if (!is_pair(p)) // malformed alist return PMT_F; - if (pmt_eq(obj, pmt_car(p))) + if (eq(obj, car(p))) return p; - alist = pmt_cdr(alist); + alist = cdr(alist); } return PMT_F; } @@ -1121,14 +1128,14 @@ pmt_assq(pmt_t obj, pmt_t alist) * This avoids a bunch of shared_pointer reference count manipulation. */ pmt_t -pmt_assv_raw(pmt_base *obj, pmt_base *alist) +assv_raw(pmt_base *obj, pmt_base *alist) { while (alist->is_pair()){ pmt_base *p = ((pmt_pair *)alist)->d_car.get(); if (!p->is_pair()) // malformed alist return PMT_F; - if (pmt_eqv_raw(obj, ((pmt_pair *)p)->d_car.get())) + if (eqv_raw(obj, ((pmt_pair *)p)->d_car.get())) return ((pmt_pair *)alist)->d_car; alist = (((pmt_pair *)alist)->d_cdr).get(); @@ -1139,25 +1146,25 @@ pmt_assv_raw(pmt_base *obj, pmt_base *alist) #if 1 pmt_t -pmt_assv(pmt_t obj, pmt_t alist) +assv(pmt_t obj, pmt_t alist) { - return pmt_assv_raw(obj.get(), alist.get()); + return assv_raw(obj.get(), alist.get()); } #else pmt_t -pmt_assv(pmt_t obj, pmt_t alist) +assv(pmt_t obj, pmt_t alist) { - while (pmt_is_pair(alist)){ - pmt_t p = pmt_car(alist); - if (!pmt_is_pair(p)) // malformed alist + while (is_pair(alist)){ + pmt_t p = car(alist); + if (!is_pair(p)) // malformed alist return PMT_F; - if (pmt_eqv(obj, pmt_car(p))) + if (eqv(obj, car(p))) return p; - alist = pmt_cdr(alist); + alist = cdr(alist); } return PMT_F; } @@ -1166,184 +1173,184 @@ pmt_assv(pmt_t obj, pmt_t alist) pmt_t -pmt_assoc(pmt_t obj, pmt_t alist) +assoc(pmt_t obj, pmt_t alist) { - while (pmt_is_pair(alist)){ - pmt_t p = pmt_car(alist); - if (!pmt_is_pair(p)) // malformed alist + while (is_pair(alist)){ + pmt_t p = car(alist); + if (!is_pair(p)) // malformed alist return PMT_F; - if (pmt_equal(obj, pmt_car(p))) + if (equal(obj, car(p))) return p; - alist = pmt_cdr(alist); + alist = cdr(alist); } return PMT_F; } pmt_t -pmt_map(pmt_t proc(const pmt_t&), pmt_t list) +map(pmt_t proc(const pmt_t&), pmt_t list) { pmt_t r = PMT_NIL; - while(pmt_is_pair(list)){ - r = pmt_cons(proc(pmt_car(list)), r); - list = pmt_cdr(list); + while(is_pair(list)){ + r = cons(proc(car(list)), r); + list = cdr(list); } - return pmt_reverse_x(r); + return reverse_x(r); } pmt_t -pmt_reverse(pmt_t listx) +reverse(pmt_t listx) { pmt_t list = listx; pmt_t r = PMT_NIL; - while(pmt_is_pair(list)){ - r = pmt_cons(pmt_car(list), r); - list = pmt_cdr(list); + while(is_pair(list)){ + r = cons(car(list), r); + list = cdr(list); } - if (pmt_is_null(list)) + if (is_null(list)) return r; else - throw pmt_wrong_type("pmt_reverse", listx); + throw wrong_type("pmt_reverse", listx); } pmt_t -pmt_reverse_x(pmt_t list) +reverse_x(pmt_t list) { // FIXME do it destructively - return pmt_reverse(list); + return reverse(list); } pmt_t -pmt_nth(size_t n, pmt_t list) +nth(size_t n, pmt_t list) { - pmt_t t = pmt_nthcdr(n, list); - if (pmt_is_pair(t)) - return pmt_car(t); + pmt_t t = nthcdr(n, list); + if (is_pair(t)) + return car(t); else return PMT_NIL; } pmt_t -pmt_nthcdr(size_t n, pmt_t list) +nthcdr(size_t n, pmt_t list) { - if (!(pmt_is_pair(list) || pmt_is_null(list))) - throw pmt_wrong_type("pmt_nthcdr", list); + if (!(is_pair(list) || is_null(list))) + throw wrong_type("pmt_nthcdr", list); while (n > 0){ - if (pmt_is_pair(list)){ - list = pmt_cdr(list); + if (is_pair(list)){ + list = cdr(list); n--; continue; } - if (pmt_is_null(list)) + if (is_null(list)) return PMT_NIL; else - throw pmt_wrong_type("pmt_nthcdr: not a LIST", list); + throw wrong_type("pmt_nthcdr: not a LIST", list); } return list; } pmt_t -pmt_memq(pmt_t obj, pmt_t list) +memq(pmt_t obj, pmt_t list) { - while (pmt_is_pair(list)){ - if (pmt_eq(obj, pmt_car(list))) + while (is_pair(list)){ + if (eq(obj, car(list))) return list; - list = pmt_cdr(list); + list = cdr(list); } return PMT_F; } pmt_t -pmt_memv(pmt_t obj, pmt_t list) +memv(pmt_t obj, pmt_t list) { - while (pmt_is_pair(list)){ - if (pmt_eqv(obj, pmt_car(list))) + while (is_pair(list)){ + if (eqv(obj, car(list))) return list; - list = pmt_cdr(list); + list = cdr(list); } return PMT_F; } pmt_t -pmt_member(pmt_t obj, pmt_t list) +member(pmt_t obj, pmt_t list) { - while (pmt_is_pair(list)){ - if (pmt_equal(obj, pmt_car(list))) + while (is_pair(list)){ + if (equal(obj, car(list))) return list; - list = pmt_cdr(list); + list = cdr(list); } return PMT_F; } bool -pmt_subsetp(pmt_t list1, pmt_t list2) +subsetp(pmt_t list1, pmt_t list2) { - while (pmt_is_pair(list1)){ - pmt_t p = pmt_car(list1); - if (pmt_is_false(pmt_memv(p, list2))) + while (is_pair(list1)){ + pmt_t p = car(list1); + if (is_false(memv(p, list2))) return false; - list1 = pmt_cdr(list1); + list1 = cdr(list1); } return true; } pmt_t -pmt_list1(const pmt_t& x1) +list1(const pmt_t& x1) { - return pmt_cons(x1, PMT_NIL); + return cons(x1, PMT_NIL); } pmt_t -pmt_list2(const pmt_t& x1, const pmt_t& x2) +list2(const pmt_t& x1, const pmt_t& x2) { - return pmt_cons(x1, pmt_cons(x2, PMT_NIL)); + return cons(x1, cons(x2, PMT_NIL)); } pmt_t -pmt_list3(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3) +list3(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3) { - return pmt_cons(x1, pmt_cons(x2, pmt_cons(x3, PMT_NIL))); + return cons(x1, cons(x2, cons(x3, PMT_NIL))); } pmt_t -pmt_list4(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4) +list4(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4) { - return pmt_cons(x1, pmt_cons(x2, pmt_cons(x3, pmt_cons(x4, PMT_NIL)))); + return cons(x1, cons(x2, cons(x3, cons(x4, PMT_NIL)))); } pmt_t -pmt_list5(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5) +list5(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5) { - return pmt_cons(x1, pmt_cons(x2, pmt_cons(x3, pmt_cons(x4, pmt_cons(x5, PMT_NIL))))); + return cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, PMT_NIL))))); } pmt_t -pmt_list6(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5, const pmt_t& x6) +list6(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5, const pmt_t& x6) { - return pmt_cons(x1, pmt_cons(x2, pmt_cons(x3, pmt_cons(x4, pmt_cons(x5, pmt_cons(x6, PMT_NIL)))))); + return cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, cons(x6, PMT_NIL)))))); } pmt_t -pmt_list_add(pmt_t list, const pmt_t& item) +list_add(pmt_t list, const pmt_t& item) { - return pmt_reverse(pmt_cons(item, pmt_reverse(list))); + return reverse(cons(item, reverse(list))); } pmt_t -pmt_list_rm(pmt_t list, const pmt_t& item) +list_rm(pmt_t list, const pmt_t& item) { - if(pmt_is_pair(list)){ - pmt_t left = pmt_car(list); - pmt_t right = pmt_cdr(list); - if(!pmt_equal(left, item)){ - return pmt_cons(left, pmt_list_rm(right, item)); + if(is_pair(list)){ + pmt_t left = car(list); + pmt_t right = cdr(list); + if(!equal(left, item)){ + return cons(left, list_rm(right, item)); } else { - return pmt_list_rm(right, item); + return list_rm(right, item); } } else { return list; @@ -1351,65 +1358,65 @@ pmt_list_rm(pmt_t list, const pmt_t& item) } bool -pmt_list_has(pmt_t list, const pmt_t& item) +list_has(pmt_t list, const pmt_t& item) { - if(pmt_is_pair(list)){ - pmt_t left = pmt_car(list); - pmt_t right = pmt_cdr(list); - if(pmt_equal(left,item)) + if(is_pair(list)){ + pmt_t left = car(list); + pmt_t right = cdr(list); + if(equal(left,item)) return true; - return pmt_list_has(right, item); + return list_has(right, item); } else { - if(pmt_is_null(list)) + if(is_null(list)) return false; throw std::runtime_error("list contains invalid format!"); } } pmt_t -pmt_caar(pmt_t pair) +caar(pmt_t pair) { - return (pmt_car(pmt_car(pair))); + return (car(car(pair))); } pmt_t -pmt_cadr(pmt_t pair) +cadr(pmt_t pair) { - return pmt_car(pmt_cdr(pair)); + return car(cdr(pair)); } pmt_t -pmt_cdar(pmt_t pair) +cdar(pmt_t pair) { - return pmt_cdr(pmt_car(pair)); + return cdr(car(pair)); } pmt_t -pmt_cddr(pmt_t pair) +cddr(pmt_t pair) { - return pmt_cdr(pmt_cdr(pair)); + return cdr(cdr(pair)); } pmt_t -pmt_caddr(pmt_t pair) +caddr(pmt_t pair) { - return pmt_car(pmt_cdr(pmt_cdr(pair))); + return car(cdr(cdr(pair))); } pmt_t -pmt_cadddr(pmt_t pair) +cadddr(pmt_t pair) { - return pmt_car(pmt_cdr(pmt_cdr(pmt_cdr(pair)))); + return car(cdr(cdr(cdr(pair)))); } bool -pmt_is_eof_object(pmt_t obj) +is_eof_object(pmt_t obj) { - return pmt_eq(obj, PMT_EOF); + return eq(obj, PMT_EOF); } void -pmt_dump_sizeof() +dump_sizeof() { printf("sizeof(pmt_t) = %3zd\n", sizeof(pmt_t)); printf("sizeof(pmt_base) = %3zd\n", sizeof(pmt_base)); diff --git a/gruel/src/lib/pmt/pmt_io.cc b/gruel/src/lib/pmt/pmt_io.cc index 4bac4a0ecb..2e853b9147 100644 --- a/gruel/src/lib/pmt/pmt_io.cc +++ b/gruel/src/lib/pmt/pmt_io.cc @@ -31,84 +31,84 @@ namespace pmt { static void -pmt_write_list_tail(pmt_t obj, std::ostream &port) +write_list_tail(pmt_t obj, std::ostream &port) { - pmt_write(pmt_car(obj), port); // write the car - obj = pmt_cdr(obj); // step to cdr + write(car(obj), port); // write the car + obj = cdr(obj); // step to cdr - if (pmt_is_null(obj)) // () + if (is_null(obj)) // () port << ")"; - else if (pmt_is_pair(obj)){ // normal list + else if (is_pair(obj)){ // normal list port << " "; - pmt_write_list_tail(obj, port); + write_list_tail(obj, port); } else { // dotted pair port << " . "; - pmt_write(obj, port); + write(obj, port); port << ")"; } } void -pmt_write(pmt_t obj, std::ostream &port) +write(pmt_t obj, std::ostream &port) { - if (pmt_is_bool(obj)){ - if (pmt_is_true(obj)) + if (is_bool(obj)){ + if (is_true(obj)) port << "#t"; else port << "#f"; } - else if (pmt_is_symbol(obj)){ - port << pmt_symbol_to_string(obj); + else if (is_symbol(obj)){ + port << symbol_to_string(obj); } - else if (pmt_is_number(obj)){ - if (pmt_is_integer(obj)) - port << pmt_to_long(obj); - else if (pmt_is_uint64(obj)) - port << pmt_to_uint64(obj); - else if (pmt_is_real(obj)) - port << pmt_to_double(obj); - else if (pmt_is_complex(obj)){ - std::complex<double> c = pmt_to_complex(obj); + else if (is_number(obj)){ + if (is_integer(obj)) + port << to_long(obj); + else if (is_uint64(obj)) + port << to_uint64(obj); + else if (is_real(obj)) + port << to_double(obj); + else if (is_complex(obj)){ + std::complex<double> c = to_complex(obj); port << c.real() << '+' << c.imag() << 'i'; } else goto error; } - else if (pmt_is_null(obj)){ + else if (is_null(obj)){ port << "()"; } - else if (pmt_is_pair(obj)){ + else if (is_pair(obj)){ port << "("; - pmt_write_list_tail(obj, port); + write_list_tail(obj, port); } - else if (pmt_is_tuple(obj)){ + else if (is_tuple(obj)){ port << "{"; - size_t len = pmt_length(obj); + size_t len = length(obj); if (len > 0){ - port << pmt_tuple_ref(obj, 0); + port << tuple_ref(obj, 0); for (size_t i = 1; i < len; i++) - port << " " << pmt_tuple_ref(obj, i); + port << " " << tuple_ref(obj, i); } port << "}"; } - else if (pmt_is_vector(obj)){ + else if (is_vector(obj)){ port << "#("; - size_t len = pmt_length(obj); + size_t len = length(obj); if (len > 0){ - port << pmt_vector_ref(obj, 0); + port << vector_ref(obj, 0); for (size_t i = 1; i < len; i++) - port << " " << pmt_vector_ref(obj, i); + port << " " << vector_ref(obj, i); } port << ")"; } - else if (pmt_is_dict(obj)){ + else if (is_dict(obj)){ // FIXME // port << "#<dict " << obj << ">"; port << "#<dict>"; } - else if (pmt_is_uniform_vector(obj)){ + else if (is_uniform_vector(obj)){ // FIXME // port << "#<uniform-vector " << obj << ">"; port << "#<uniform-vector>"; @@ -123,12 +123,12 @@ pmt_write(pmt_t obj, std::ostream &port) std::ostream& operator<<(std::ostream &os, pmt_t obj) { - pmt_write(obj, os); + write(obj, os); return os; } std::string -pmt_write_string(pmt_t obj) +write_string(pmt_t obj) { std::ostringstream s; s << obj; @@ -136,33 +136,33 @@ pmt_write_string(pmt_t obj) } pmt_t -pmt_read(std::istream &port) +read(std::istream &port) { - throw pmt_notimplemented("notimplemented: pmt_read", PMT_NIL); + throw notimplemented("notimplemented: pmt::read", PMT_NIL); } void -pmt_serialize(pmt_t obj, std::ostream &sink) +serialize(pmt_t obj, std::ostream &sink) { - throw pmt_notimplemented("notimplemented: pmt_serialize", obj); + throw notimplemented("notimplemented: pmt::serialize", obj); } /*! * \brief Create obj from portable byte-serial representation */ pmt_t -pmt_deserialize(std::istream &source) +deserialize(std::istream &source) { - throw pmt_notimplemented("notimplemented: pmt_deserialize", PMT_NIL); + throw notimplemented("notimplemented: pmt::deserialize", PMT_NIL); } } /* namespace pmt */ void -pmt::pmt_print(pmt_t v) +pmt::print(pmt_t v) { - std::cout << pmt_write_string(v) << std::endl; + std::cout << write_string(v) << std::endl; } diff --git a/gruel/src/lib/pmt/pmt_serialize.cc b/gruel/src/lib/pmt/pmt_serialize.cc index 24be6b772c..2c74f30b01 100644 --- a/gruel/src/lib/pmt/pmt_serialize.cc +++ b/gruel/src/lib/pmt/pmt_serialize.cc @@ -219,15 +219,16 @@ deserialize_tuple(pmt_t *tuple, std::streambuf &sb) uint32_t nitems; bool ok = deserialize_untagged_u32(&nitems, sb); pmt_t list(PMT_NIL); - for(uint32_t i=0; i<nitems; i++){ - pmt_t item = pmt_deserialize( sb ); - if(pmt_eq(list, PMT_NIL)){ - list = pmt_list1(item); - } else { - list = pmt_list_add(list, item); - } + for(uint32_t i=0; i<nitems; i++) { + pmt_t item = deserialize(sb); + if(eq(list, PMT_NIL)) { + list = list1(item); + } + else { + list = list_add(list, item); + } } - (*tuple) = pmt_to_tuple(list); + (*tuple) = to_tuple(list); return ok; } @@ -238,92 +239,93 @@ deserialize_tuple(pmt_t *tuple, std::streambuf &sb) * N.B., Circular structures cause infinite recursion. */ bool -pmt_serialize(pmt_t obj, std::streambuf &sb) +serialize(pmt_t obj, std::streambuf &sb) { bool ok = true; tail_recursion: - if (pmt_is_bool(obj)){ - if (pmt_eq(obj, PMT_T)) + if(is_bool(obj)) { + if(eq(obj, PMT_T)) return serialize_untagged_u8(PST_TRUE, sb); else return serialize_untagged_u8(PST_FALSE, sb); } - if (pmt_is_null(obj)) + if(is_null(obj)) return serialize_untagged_u8(PST_NULL, sb); - if (pmt_is_symbol(obj)){ - const std::string s = pmt_symbol_to_string(obj); + if(is_symbol(obj)) { + const std::string s = symbol_to_string(obj); size_t len = s.size(); ok = serialize_untagged_u8(PST_SYMBOL, sb); ok &= serialize_untagged_u16(len, sb); - for (size_t i = 0; i < len; i++) + for(size_t i = 0; i < len; i++) ok &= serialize_untagged_u8(s[i], sb); return ok; } - if (pmt_is_pair(obj)){ + if(is_pair(obj)) { ok = serialize_untagged_u8(PST_PAIR, sb); - ok &= pmt_serialize(pmt_car(obj), sb); - if (!ok) + ok &= serialize(car(obj), sb); + if(!ok) return false; - obj = pmt_cdr(obj); + obj = cdr(obj); goto tail_recursion; } - if (pmt_is_number(obj)){ + if(is_number(obj)) { - if (pmt_is_uint64(obj)){ - uint64_t i = pmt_to_uint64(obj); + if(is_uint64(obj)) { + uint64_t i = to_uint64(obj); ok = serialize_untagged_u8(PST_UINT64, sb); ok &= serialize_untagged_u64(i, sb); return ok; - } else - if (pmt_is_integer(obj)){ - long i = pmt_to_long(obj); - if (sizeof(long) > 4){ - if (i < -2147483647 || i > 2147483647) - throw pmt_notimplemented("pmt_serialize (64-bit integers)", obj); + } + else { + if(is_integer(obj)) { + long i = to_long(obj); + if(sizeof(long) > 4) { + if(i < -2147483647 || i > 2147483647) + throw notimplemented("pmt::serialize (64-bit integers)", obj); + } + ok = serialize_untagged_u8(PST_INT32, sb); + ok &= serialize_untagged_u32(i, sb); + return ok; } - ok = serialize_untagged_u8(PST_INT32, sb); - ok &= serialize_untagged_u32(i, sb); - return ok; } - if (pmt_is_real(obj)){ - float i = pmt_to_double(obj); + if(is_real(obj)) { + float i = to_double(obj); ok = serialize_untagged_u8(PST_DOUBLE, sb); ok &= serialize_untagged_f64(i, sb); return ok; } - if (pmt_is_complex(obj)){ - std::complex<double> i = pmt_to_complex(obj); + if(is_complex(obj)) { + std::complex<double> i = to_complex(obj); ok = serialize_untagged_u8(PST_COMPLEX, sb); ok &= serialize_untagged_f64(i.real(), sb); ok &= serialize_untagged_f64(i.imag(), sb); return ok; } - } - if (pmt_is_vector(obj)) { - size_t vec_len = pmt::pmt_length(obj); + if(is_vector(obj)) { + size_t vec_len = pmt::length(obj); ok = serialize_untagged_u8(PST_VECTOR, sb); ok &= serialize_untagged_u32(vec_len, sb); for(size_t i=0; i<vec_len; i++) { - ok &= pmt_serialize(pmt_vector_ref(obj, i), sb); + ok &= serialize(vector_ref(obj, i), sb); } return ok; } - if (pmt_is_uniform_vector(obj)) { + if(is_uniform_vector(obj)) { size_t npad = 1; - size_t vec_len = pmt::pmt_length(obj); + size_t vec_len = pmt::length(obj); - if(pmt_is_u8vector(obj)) { + if(is_u8vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_U8, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -332,12 +334,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u8(pmt_u8vector_ref(obj, i), sb); + ok &= serialize_untagged_u8(u8vector_ref(obj, i), sb); } return ok; } - if(pmt_is_s8vector(obj)) { + if(is_s8vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_S8, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -346,12 +348,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u8(pmt_s8vector_ref(obj, i), sb); + ok &= serialize_untagged_u8(s8vector_ref(obj, i), sb); } return ok; } - if(pmt_is_u16vector(obj)) { + if(is_u16vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_U16, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -360,12 +362,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u16(pmt_u16vector_ref(obj, i), sb); + ok &= serialize_untagged_u16(u16vector_ref(obj, i), sb); } return ok; } - if(pmt_is_s16vector(obj)) { + if(is_s16vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_S16, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -374,12 +376,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u16(pmt_s16vector_ref(obj, i), sb); + ok &= serialize_untagged_u16(s16vector_ref(obj, i), sb); } return ok; } - if(pmt_is_u32vector(obj)) { + if(is_u32vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_U32, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -388,12 +390,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u32(pmt_u32vector_ref(obj, i), sb); + ok &= serialize_untagged_u32(u32vector_ref(obj, i), sb); } return ok; } - if(pmt_is_s32vector(obj)) { + if(is_s32vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_S32, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -402,12 +404,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u32(pmt_s32vector_ref(obj, i), sb); + ok &= serialize_untagged_u32(s32vector_ref(obj, i), sb); } return ok; } - if(pmt_is_u64vector(obj)) { + if(is_u64vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_U64, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -416,12 +418,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u64(pmt_u64vector_ref(obj, i), sb); + ok &= serialize_untagged_u64(u64vector_ref(obj, i), sb); } return ok; } - if(pmt_is_s64vector(obj)) { + if(is_s64vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_S64, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -430,12 +432,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u64(pmt_s64vector_ref(obj, i), sb); + ok &= serialize_untagged_u64(s64vector_ref(obj, i), sb); } return ok; } - if(pmt_is_f32vector(obj)) { + if(is_f32vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_F32, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -444,12 +446,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_f64(pmt_f32vector_ref(obj, i), sb); + ok &= serialize_untagged_f64(f32vector_ref(obj, i), sb); } return ok; } - if(pmt_is_f64vector(obj)) { + if(is_f64vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_F64, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -458,12 +460,12 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_f64(pmt_f64vector_ref(obj, i), sb); + ok &= serialize_untagged_f64(f64vector_ref(obj, i), sb); } return ok; } - if(pmt_is_c32vector(obj)) { + if(is_c32vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_C32, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -472,14 +474,14 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - std::complex<float> c = pmt_c32vector_ref(obj, i); + std::complex<float> c = c32vector_ref(obj, i); ok &= serialize_untagged_f64(c.real(), sb); ok &= serialize_untagged_f64(c.imag(), sb); } return ok; } - if(pmt_is_c64vector(obj)) { + if(is_c64vector(obj)) { ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); ok &= serialize_untagged_u8(UVI_C64, sb); ok &= serialize_untagged_u32(vec_len, sb); @@ -488,7 +490,7 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) ok &= serialize_untagged_u8(0, sb); } for(size_t i=0; i<vec_len; i++) { - std::complex<double> c = pmt_c64vector_ref(obj, i); + std::complex<double> c = c64vector_ref(obj, i); ok &= serialize_untagged_f64(c.real(), sb); ok &= serialize_untagged_f64(c.imag(), sb); } @@ -496,21 +498,21 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) } } - if (pmt_is_dict(obj)) - throw pmt_notimplemented("pmt_serialize (dict)", obj); + if (is_dict(obj)) + throw notimplemented("pmt::serialize (dict)", obj); - if (pmt_is_tuple(obj)){ - size_t tuple_len = pmt::pmt_length(obj); + if (is_tuple(obj)){ + size_t tuple_len = pmt::length(obj); ok = serialize_untagged_u8(PST_TUPLE, sb); ok &= serialize_untagged_u32(tuple_len, sb); for(size_t i=0; i<tuple_len; i++){ - ok &= pmt_serialize(pmt_tuple_ref(obj, i), sb); + ok &= serialize(tuple_ref(obj, i), sb); } return ok; } - //throw pmt_notimplemented("pmt_serialize (tuple)", obj); + //throw pmt_notimplemented("pmt::serialize (tuple)", obj); - throw pmt_notimplemented("pmt_serialize (?)", obj); + throw notimplemented("pmt::serialize (?)", obj); } /* @@ -520,7 +522,7 @@ pmt_serialize(pmt_t obj, std::streambuf &sb) * Throws exception on malformed input. */ pmt_t -pmt_deserialize(std::streambuf &sb) +deserialize(std::streambuf &sb) { uint8_t tag; uint8_t u8; @@ -547,21 +549,21 @@ pmt_deserialize(std::streambuf &sb) if (!deserialize_untagged_u16(&u16, sb)) goto error; if (u16 > sizeof(tmpbuf)) - throw pmt_notimplemented("pmt_deserialize: very long symbol", - PMT_F); + throw notimplemented("pmt::deserialize: very long symbol", + PMT_F); if (sb.sgetn(tmpbuf, u16) != u16) goto error; - return pmt_intern(std::string(tmpbuf, u16)); + return intern(std::string(tmpbuf, u16)); case PST_INT32: if (!deserialize_untagged_u32(&u32, sb)) goto error; - return pmt_from_long((int32_t) u32); + return from_long((int32_t) u32); case PST_UINT64: if(!deserialize_untagged_u64(&u64, sb)) goto error; - return pmt_from_uint64(u64); + return from_uint64(u64); case PST_PAIR: return parse_pair(sb); @@ -569,14 +571,14 @@ pmt_deserialize(std::streambuf &sb) case PST_DOUBLE: if(!deserialize_untagged_f64(&f64, sb)) goto error; - return pmt_from_double( f64 ); + return from_double( f64 ); case PST_COMPLEX: { double r,i; if(!deserialize_untagged_f64(&r, sb) && !deserialize_untagged_f64(&i, sb)) goto error; - return pmt_make_rectangular( r,i ); + return make_rectangular( r,i ); } case PST_TUPLE: @@ -593,10 +595,10 @@ pmt_deserialize(std::streambuf &sb) uint32_t nitems; if(!deserialize_untagged_u32(&nitems, sb)) goto error; - pmt_t vec = pmt_make_vector(nitems, PMT_NIL); + pmt_t vec = make_vector(nitems, PMT_NIL); for(uint32_t i=0; i<nitems; i++) { - pmt_t item = pmt_deserialize(sb); - pmt_vector_set(vec, i, item); + pmt_t item = deserialize(sb); + vector_set(vec, i, item); } return vec; } @@ -619,149 +621,150 @@ pmt_deserialize(std::streambuf &sb) switch(utag) { case(UVI_U8): { - pmt_t vec = pmt_make_u8vector(nitems, 0); + pmt_t vec = make_u8vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u8(&u8, sb); - pmt_u8vector_set(vec, i, u8); + u8vector_set(vec, i, u8); } return vec; } case(UVI_S8): { - pmt_t vec = pmt_make_s8vector(nitems, 0); + pmt_t vec = make_s8vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u8(&u8, sb); - pmt_s8vector_set(vec, i, u8); + s8vector_set(vec, i, u8); } return vec; } case(UVI_U16): { - pmt_t vec = pmt_make_u16vector(nitems, 0); + pmt_t vec = make_u16vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u16(&u16, sb); - pmt_u16vector_set(vec, i, u16); + u16vector_set(vec, i, u16); } return vec; } case(UVI_S16): { - pmt_t vec = pmt_make_s16vector(nitems, 0); + pmt_t vec = make_s16vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u16(&u16, sb); - pmt_s16vector_set(vec, i, u16); + s16vector_set(vec, i, u16); } return vec; } case(UVI_U32): { - pmt_t vec = pmt_make_u32vector(nitems, 0); + pmt_t vec = make_u32vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u32(&u32, sb); - pmt_u32vector_set(vec, i, u32); + u32vector_set(vec, i, u32); } return vec; } case(UVI_S32): { - pmt_t vec = pmt_make_s32vector(nitems, 0); + pmt_t vec = make_s32vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u32(&u32, sb); - pmt_s32vector_set(vec, i, u32); + s32vector_set(vec, i, u32); } return vec; } case(UVI_U64): { - pmt_t vec = pmt_make_u64vector(nitems, 0); + pmt_t vec = make_u64vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u64(&u64, sb); - pmt_u64vector_set(vec, i, u64); + u64vector_set(vec, i, u64); } return vec; } case(UVI_S64): { - pmt_t vec = pmt_make_s64vector(nitems, 0); + pmt_t vec = make_s64vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_u64(&u64, sb); - pmt_s64vector_set(vec, i, u64); + s64vector_set(vec, i, u64); } return vec; } case(UVI_F32): { - pmt_t vec = pmt_make_f32vector(nitems, 0); + pmt_t vec = make_f32vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_f64(&f64, sb); - pmt_f32vector_set(vec, i, static_cast<float>(f64)); + f32vector_set(vec, i, static_cast<float>(f64)); } return vec; } case(UVI_F64): { - pmt_t vec = pmt_make_f64vector(nitems, 0); + pmt_t vec = make_f64vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { deserialize_untagged_f64(&f64, sb); - pmt_f64vector_set(vec, i, f64); + f64vector_set(vec, i, f64); } return vec; } case(UVI_C32): { - pmt_t vec = pmt_make_c32vector(nitems, 0); + pmt_t vec = make_c32vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { float re, im; deserialize_untagged_f64(&f64, sb); re = static_cast<float>(f64); deserialize_untagged_f64(&f64, sb); im = static_cast<float>(f64); - pmt_c32vector_set(vec, i, std::complex<float>(re, im)); + c32vector_set(vec, i, std::complex<float>(re, im)); } return vec; } case(UVI_C64): { - pmt_t vec = pmt_make_c64vector(nitems, 0); + pmt_t vec = make_c64vector(nitems, 0); for(uint32_t i=0; i<nitems; i++) { double re, im; deserialize_untagged_f64(&f64, sb); re = f64; deserialize_untagged_f64(&f64, sb); im = f64; - pmt_c64vector_set(vec, i, std::complex<double>(re, im)); + c64vector_set(vec, i, std::complex<double>(re, im)); } return vec; } default: - throw pmt_exception("pmt_deserialize: malformed input stream, tag value = ", - pmt_from_long(tag)); + throw exception("pmt::deserialize: malformed input stream, tag value = ", + from_long(tag)); } } case PST_DICT: case PST_COMMENT: - throw pmt_notimplemented("pmt_deserialize: tag value = ", - pmt_from_long(tag)); + throw notimplemented("pmt::deserialize: tag value = ", + from_long(tag)); default: - throw pmt_exception("pmt_deserialize: malformed input stream, tag value = ", - pmt_from_long(tag)); + throw exception("pmt::deserialize: malformed input stream, tag value = ", + from_long(tag)); } error: - throw pmt_exception("pmt_deserialize: malformed input stream", PMT_F); + throw exception("pmt::deserialize: malformed input stream", PMT_F); } /* * provide a simple string accessor to the serialized pmt form */ -std::string pmt_serialize_str(pmt_t obj){ +std::string +serialize_str(pmt_t obj){ std::stringbuf sb; - pmt_serialize(obj, sb); + serialize(obj, sb); return sb.str(); } @@ -769,9 +772,10 @@ std::string pmt_serialize_str(pmt_t obj){ /* * provide a simple string accessor to the deserialized pmt form */ -pmt_t pmt_deserialize_str(std::string s){ +pmt_t +deserialize_str(std::string s){ std::stringbuf sb(s); - return pmt_deserialize(sb); + return deserialize(sb); } @@ -792,17 +796,17 @@ parse_pair(std::streambuf &sb) // lastnptr = PMT_NIL; while (1){ - expr = pmt_deserialize(sb); // read the car + expr = deserialize(sb); // read the car - nptr = pmt_cons(expr, PMT_NIL); // build new cell - if (pmt_is_null(lastnptr)) + nptr = cons(expr, PMT_NIL); // build new cell + if (is_null(lastnptr)) val = nptr; else - pmt_set_cdr(lastnptr, nptr); + set_cdr(lastnptr, nptr); lastnptr = nptr; if (!deserialize_untagged_u8(&tag, sb)) // get tag of cdr - throw pmt_exception("pmt_deserialize: malformed input stream", PMT_F); + throw exception("pmt::deserialize: malformed input stream", PMT_F); if (tag == PST_PAIR) continue; // keep on looping... @@ -816,14 +820,14 @@ parse_pair(std::streambuf &sb) // default: push tag back and use pmt_deserialize to get the cdr // sb.sungetc(); - expr = pmt_deserialize(sb); + expr = deserialize(sb); break; } // // At this point, expr contains the value of the final cdr in the list. // - pmt_set_cdr(lastnptr, expr); + set_cdr(lastnptr, expr); return val; } diff --git a/gruel/src/lib/pmt/qa_pmt_prims.cc b/gruel/src/lib/pmt/qa_pmt_prims.cc index 3ae4d70b6d..85d29cf78f 100644 --- a/gruel/src/lib/pmt/qa_pmt_prims.cc +++ b/gruel/src/lib/pmt/qa_pmt_prims.cc @@ -28,35 +28,33 @@ #include <cstring> #include <sstream> -using namespace pmt; - void qa_pmt_prims::test_symbols() { - CPPUNIT_ASSERT(!pmt_is_symbol(PMT_T)); - CPPUNIT_ASSERT(!pmt_is_symbol(PMT_F)); - CPPUNIT_ASSERT_THROW(pmt_symbol_to_string(PMT_F), pmt_wrong_type); - - pmt_t sym1 = mp("test"); - CPPUNIT_ASSERT(pmt_is_symbol(sym1)); - CPPUNIT_ASSERT_EQUAL(std::string("test"), pmt_symbol_to_string(sym1)); - CPPUNIT_ASSERT(pmt_is_true(sym1)); - CPPUNIT_ASSERT(!pmt_is_false(sym1)); - - pmt_t sym2 = mp("foo"); - pmt_t sym3 = mp("test"); + CPPUNIT_ASSERT(!pmt::is_symbol(pmt::PMT_T)); + CPPUNIT_ASSERT(!pmt::is_symbol(pmt::PMT_F)); + CPPUNIT_ASSERT_THROW(pmt::symbol_to_string(pmt::PMT_F), pmt::wrong_type); + + pmt::pmt_t sym1 = pmt::mp("test"); + CPPUNIT_ASSERT(pmt::is_symbol(sym1)); + CPPUNIT_ASSERT_EQUAL(std::string("test"), pmt::symbol_to_string(sym1)); + CPPUNIT_ASSERT(pmt::is_true(sym1)); + CPPUNIT_ASSERT(!pmt::is_false(sym1)); + + pmt::pmt_t sym2 = pmt::mp("foo"); + pmt::pmt_t sym3 = pmt::mp("test"); CPPUNIT_ASSERT_EQUAL(sym1, sym3); CPPUNIT_ASSERT(sym1 != sym2); CPPUNIT_ASSERT(sym1 == sym3); static const int N = 2048; - std::vector<pmt_t> v1(N); - std::vector<pmt_t> v2(N); + std::vector<pmt::pmt_t> v1(N); + std::vector<pmt::pmt_t> v2(N); // generate a bunch of symbols for (int i = 0; i < N; i++){ std::string buf = str(boost::format("test-%d") % i); - v1[i] = mp(buf.c_str()); + v1[i] = pmt::mp(buf.c_str()); } // confirm that they are all unique @@ -67,7 +65,7 @@ qa_pmt_prims::test_symbols() // generate the same symbols again for (int i = 0; i < N; i++){ std::string buf = str(boost::format("test-%d") % i); - v2[i] = mp(buf.c_str()); + v2[i] = pmt::mp(buf.c_str()); } // confirm that we get the same ones back @@ -78,355 +76,355 @@ qa_pmt_prims::test_symbols() void qa_pmt_prims::test_booleans() { - pmt_t sym = mp("test"); - CPPUNIT_ASSERT(pmt_is_bool(PMT_T)); - CPPUNIT_ASSERT(pmt_is_bool(PMT_F)); - CPPUNIT_ASSERT(!pmt_is_bool(sym)); - CPPUNIT_ASSERT_EQUAL(pmt_from_bool(false), PMT_F); - CPPUNIT_ASSERT_EQUAL(pmt_from_bool(true), PMT_T); - CPPUNIT_ASSERT_EQUAL(false, pmt_to_bool(PMT_F)); - CPPUNIT_ASSERT_EQUAL(true, pmt_to_bool(PMT_T)); - CPPUNIT_ASSERT_THROW(pmt_to_bool(sym), pmt_wrong_type); + pmt::pmt_t sym = pmt::mp("test"); + CPPUNIT_ASSERT(pmt::is_bool(pmt::PMT_T)); + CPPUNIT_ASSERT(pmt::is_bool(pmt::PMT_F)); + CPPUNIT_ASSERT(!pmt::is_bool(sym)); + CPPUNIT_ASSERT_EQUAL(pmt::from_bool(false), pmt::PMT_F); + CPPUNIT_ASSERT_EQUAL(pmt::from_bool(true), pmt::PMT_T); + CPPUNIT_ASSERT_EQUAL(false, pmt::to_bool(pmt::PMT_F)); + CPPUNIT_ASSERT_EQUAL(true, pmt::to_bool(pmt::PMT_T)); + CPPUNIT_ASSERT_THROW(pmt::to_bool(sym), pmt::wrong_type); } void qa_pmt_prims::test_integers() { - pmt_t p1 = pmt_from_long(1); - pmt_t m1 = pmt_from_long(-1); - CPPUNIT_ASSERT(!pmt_is_integer(PMT_T)); - CPPUNIT_ASSERT(pmt_is_integer(p1)); - CPPUNIT_ASSERT(pmt_is_integer(m1)); - CPPUNIT_ASSERT_THROW(pmt_to_long(PMT_T), pmt_wrong_type); - CPPUNIT_ASSERT_EQUAL(-1L, pmt_to_long(m1)); - CPPUNIT_ASSERT_EQUAL(1L, pmt_to_long(p1)); + pmt::pmt_t p1 = pmt::from_long(1); + pmt::pmt_t m1 = pmt::from_long(-1); + CPPUNIT_ASSERT(!pmt::is_integer(pmt::PMT_T)); + CPPUNIT_ASSERT(pmt::is_integer(p1)); + CPPUNIT_ASSERT(pmt::is_integer(m1)); + CPPUNIT_ASSERT_THROW(pmt::to_long(pmt::PMT_T), pmt::wrong_type); + CPPUNIT_ASSERT_EQUAL(-1L, pmt::to_long(m1)); + CPPUNIT_ASSERT_EQUAL(1L, pmt::to_long(p1)); } void qa_pmt_prims::test_uint64s() { - pmt_t p1 = pmt_from_uint64((uint64_t)1); - pmt_t m1 = pmt_from_uint64((uint64_t)8589934592ULL); - CPPUNIT_ASSERT(!pmt_is_uint64(PMT_T)); - CPPUNIT_ASSERT(pmt_is_uint64(p1)); - CPPUNIT_ASSERT(pmt_is_uint64(m1)); - CPPUNIT_ASSERT_THROW(pmt_to_uint64(PMT_T), pmt_wrong_type); - CPPUNIT_ASSERT_EQUAL((uint64_t)8589934592ULL, (uint64_t)pmt_to_uint64(m1)); - CPPUNIT_ASSERT_EQUAL((uint64_t)1ULL, (uint64_t)pmt_to_uint64(p1)); + pmt::pmt_t p1 = pmt::from_uint64((uint64_t)1); + pmt::pmt_t m1 = pmt::from_uint64((uint64_t)8589934592ULL); + CPPUNIT_ASSERT(!pmt::is_uint64(pmt::PMT_T)); + CPPUNIT_ASSERT(pmt::is_uint64(p1)); + CPPUNIT_ASSERT(pmt::is_uint64(m1)); + CPPUNIT_ASSERT_THROW(pmt::to_uint64(pmt::PMT_T), pmt::wrong_type); + CPPUNIT_ASSERT_EQUAL((uint64_t)8589934592ULL, (uint64_t)pmt::to_uint64(m1)); + CPPUNIT_ASSERT_EQUAL((uint64_t)1ULL, (uint64_t)pmt::to_uint64(p1)); } void qa_pmt_prims::test_reals() { - pmt_t p1 = pmt_from_double(1); - pmt_t m1 = pmt_from_double(-1); - CPPUNIT_ASSERT(!pmt_is_real(PMT_T)); - CPPUNIT_ASSERT(pmt_is_real(p1)); - CPPUNIT_ASSERT(pmt_is_real(m1)); - CPPUNIT_ASSERT_THROW(pmt_to_double(PMT_T), pmt_wrong_type); - CPPUNIT_ASSERT_EQUAL(-1.0, pmt_to_double(m1)); - CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(p1)); - CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(pmt_from_long(1))); + pmt::pmt_t p1 = pmt::from_double(1); + pmt::pmt_t m1 = pmt::from_double(-1); + CPPUNIT_ASSERT(!pmt::is_real(pmt::PMT_T)); + CPPUNIT_ASSERT(pmt::is_real(p1)); + CPPUNIT_ASSERT(pmt::is_real(m1)); + CPPUNIT_ASSERT_THROW(pmt::to_double(pmt::PMT_T), pmt::wrong_type); + CPPUNIT_ASSERT_EQUAL(-1.0, pmt::to_double(m1)); + CPPUNIT_ASSERT_EQUAL(1.0, pmt::to_double(p1)); + CPPUNIT_ASSERT_EQUAL(1.0, pmt::to_double(pmt::from_long(1))); } void qa_pmt_prims::test_complexes() { - pmt_t p1 = pmt_make_rectangular(2, -3); - pmt_t m1 = pmt_make_rectangular(-3, 2); - pmt_t p2 = pmt_from_complex(2, -3); - pmt_t m2 = pmt_from_complex(-3, 2); - pmt_t p3 = pmt_from_complex(std::complex<double>(2, -3)); - pmt_t m3 = pmt_from_complex(std::complex<double>(-3, 2)); - CPPUNIT_ASSERT(!pmt_is_complex(PMT_T)); - CPPUNIT_ASSERT(pmt_is_complex(p1)); - CPPUNIT_ASSERT(pmt_is_complex(m1)); - CPPUNIT_ASSERT(pmt_is_complex(p2)); - CPPUNIT_ASSERT(pmt_is_complex(m2)); - CPPUNIT_ASSERT(pmt_is_complex(p3)); - CPPUNIT_ASSERT(pmt_is_complex(m3)); - CPPUNIT_ASSERT_THROW(pmt_to_complex(PMT_T), pmt_wrong_type); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt_to_complex(p1)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt_to_complex(m1)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt_to_complex(p2)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt_to_complex(m2)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt_to_complex(p3)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt_to_complex(m3)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt_to_complex(pmt_from_long(1))); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt_to_complex(pmt_from_double(1.0))); + pmt::pmt_t p1 = pmt::make_rectangular(2, -3); + pmt::pmt_t m1 = pmt::make_rectangular(-3, 2); + pmt::pmt_t p2 = pmt::from_complex(2, -3); + pmt::pmt_t m2 = pmt::from_complex(-3, 2); + pmt::pmt_t p3 = pmt::from_complex(std::complex<double>(2, -3)); + pmt::pmt_t m3 = pmt::from_complex(std::complex<double>(-3, 2)); + CPPUNIT_ASSERT(!pmt::is_complex(pmt::PMT_T)); + CPPUNIT_ASSERT(pmt::is_complex(p1)); + CPPUNIT_ASSERT(pmt::is_complex(m1)); + CPPUNIT_ASSERT(pmt::is_complex(p2)); + CPPUNIT_ASSERT(pmt::is_complex(m2)); + CPPUNIT_ASSERT(pmt::is_complex(p3)); + CPPUNIT_ASSERT(pmt::is_complex(m3)); + CPPUNIT_ASSERT_THROW(pmt::to_complex(pmt::PMT_T), pmt::wrong_type); + CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p1)); + CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m1)); + CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p2)); + CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m2)); + CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p3)); + CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m3)); + CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt::to_complex(pmt::from_long(1))); + CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt::to_complex(pmt::from_double(1.0))); } void qa_pmt_prims::test_pairs() { - CPPUNIT_ASSERT(pmt_is_null(PMT_NIL)); - CPPUNIT_ASSERT(!pmt_is_pair(PMT_NIL)); - pmt_t s1 = mp("s1"); - pmt_t s2 = mp("s2"); - pmt_t s3 = mp("s3"); - - - CPPUNIT_ASSERT_EQUAL((size_t)0, pmt_length(PMT_NIL)); - CPPUNIT_ASSERT_THROW(pmt_length(s1), pmt_wrong_type); - CPPUNIT_ASSERT_THROW(pmt_length(pmt_from_double(42)), pmt_wrong_type); - - pmt_t c1 = pmt_cons(s1, PMT_NIL); - CPPUNIT_ASSERT(pmt_is_pair(c1)); - CPPUNIT_ASSERT(!pmt_is_pair(s1)); - CPPUNIT_ASSERT_EQUAL(s1, pmt_car(c1)); - CPPUNIT_ASSERT_EQUAL(PMT_NIL, pmt_cdr(c1)); - CPPUNIT_ASSERT_EQUAL((size_t) 1, pmt_length(c1)); - - pmt_t c3 = pmt_cons(s3, PMT_NIL); - pmt_t c2 = pmt_cons(s2, c3); - pmt_set_cdr(c1, c2); - CPPUNIT_ASSERT_EQUAL(c2, pmt_cdr(c1)); - pmt_set_car(c1, s3); - CPPUNIT_ASSERT_EQUAL(s3, pmt_car(c1)); - CPPUNIT_ASSERT_EQUAL((size_t)1, pmt_length(c3)); - CPPUNIT_ASSERT_EQUAL((size_t)2, pmt_length(c2)); - - CPPUNIT_ASSERT_THROW(pmt_cdr(PMT_NIL), pmt_wrong_type); - CPPUNIT_ASSERT_THROW(pmt_car(PMT_NIL), pmt_wrong_type); - CPPUNIT_ASSERT_THROW(pmt_set_car(s1, PMT_NIL), pmt_wrong_type); - CPPUNIT_ASSERT_THROW(pmt_set_cdr(s1, PMT_NIL), pmt_wrong_type); + CPPUNIT_ASSERT(pmt::is_null(pmt::PMT_NIL)); + CPPUNIT_ASSERT(!pmt::is_pair(pmt::PMT_NIL)); + pmt::pmt_t s1 = pmt::mp("s1"); + pmt::pmt_t s2 = pmt::mp("s2"); + pmt::pmt_t s3 = pmt::mp("s3"); + + + CPPUNIT_ASSERT_EQUAL((size_t)0, pmt::length(pmt::PMT_NIL)); + CPPUNIT_ASSERT_THROW(pmt::length(s1), pmt::wrong_type); + CPPUNIT_ASSERT_THROW(pmt::length(pmt::from_double(42)), pmt::wrong_type); + + pmt::pmt_t c1 = pmt::cons(s1, pmt::PMT_NIL); + CPPUNIT_ASSERT(pmt::is_pair(c1)); + CPPUNIT_ASSERT(!pmt::is_pair(s1)); + CPPUNIT_ASSERT_EQUAL(s1, pmt::car(c1)); + CPPUNIT_ASSERT_EQUAL(pmt::PMT_NIL, pmt::cdr(c1)); + CPPUNIT_ASSERT_EQUAL((size_t) 1, pmt::length(c1)); + + pmt::pmt_t c3 = pmt::cons(s3, pmt::PMT_NIL); + pmt::pmt_t c2 = pmt::cons(s2, c3); + pmt::set_cdr(c1, c2); + CPPUNIT_ASSERT_EQUAL(c2, pmt::cdr(c1)); + pmt::set_car(c1, s3); + CPPUNIT_ASSERT_EQUAL(s3, pmt::car(c1)); + CPPUNIT_ASSERT_EQUAL((size_t)1, pmt::length(c3)); + CPPUNIT_ASSERT_EQUAL((size_t)2, pmt::length(c2)); + + CPPUNIT_ASSERT_THROW(pmt::cdr(pmt::PMT_NIL), pmt::wrong_type); + CPPUNIT_ASSERT_THROW(pmt::car(pmt::PMT_NIL), pmt::wrong_type); + CPPUNIT_ASSERT_THROW(pmt::set_car(s1, pmt::PMT_NIL), pmt::wrong_type); + CPPUNIT_ASSERT_THROW(pmt::set_cdr(s1, pmt::PMT_NIL), pmt::wrong_type); } void qa_pmt_prims::test_vectors() { static const size_t N = 3; - pmt_t v1 = pmt_make_vector(N, PMT_NIL); - CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1)); - pmt_t s0 = mp("s0"); - pmt_t s1 = mp("s1"); - pmt_t s2 = mp("s2"); + pmt::pmt_t v1 = pmt::make_vector(N, pmt::PMT_NIL); + CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1)); + pmt::pmt_t s0 = pmt::mp("s0"); + pmt::pmt_t s1 = pmt::mp("s1"); + pmt::pmt_t s2 = pmt::mp("s2"); - pmt_vector_set(v1, 0, s0); - pmt_vector_set(v1, 1, s1); - pmt_vector_set(v1, 2, s2); + pmt::vector_set(v1, 0, s0); + pmt::vector_set(v1, 1, s1); + pmt::vector_set(v1, 2, s2); - CPPUNIT_ASSERT_EQUAL(s0, pmt_vector_ref(v1, 0)); - CPPUNIT_ASSERT_EQUAL(s1, pmt_vector_ref(v1, 1)); - CPPUNIT_ASSERT_EQUAL(s2, pmt_vector_ref(v1, 2)); + CPPUNIT_ASSERT_EQUAL(s0, pmt::vector_ref(v1, 0)); + CPPUNIT_ASSERT_EQUAL(s1, pmt::vector_ref(v1, 1)); + CPPUNIT_ASSERT_EQUAL(s2, pmt::vector_ref(v1, 2)); - CPPUNIT_ASSERT_THROW(pmt_vector_ref(v1, N), pmt_out_of_range); - CPPUNIT_ASSERT_THROW(pmt_vector_set(v1, N, PMT_NIL), pmt_out_of_range); + CPPUNIT_ASSERT_THROW(pmt::vector_ref(v1, N), pmt::out_of_range); + CPPUNIT_ASSERT_THROW(pmt::vector_set(v1, N, pmt::PMT_NIL), pmt::out_of_range); - pmt_vector_fill(v1, s0); + pmt::vector_fill(v1, s0); for (size_t i = 0; i < N; i++) - CPPUNIT_ASSERT_EQUAL(s0, pmt_vector_ref(v1, i)); + CPPUNIT_ASSERT_EQUAL(s0, pmt::vector_ref(v1, i)); } static void -check_tuple(size_t len, const std::vector<pmt_t> &s, pmt_t t) +check_tuple(size_t len, const std::vector<pmt::pmt_t> &s, pmt::pmt_t t) { - CPPUNIT_ASSERT_EQUAL(true, pmt_is_tuple(t)); - CPPUNIT_ASSERT_EQUAL(len, pmt_length(t)); + CPPUNIT_ASSERT_EQUAL(true, pmt::is_tuple(t)); + CPPUNIT_ASSERT_EQUAL(len, pmt::length(t)); for (size_t i = 0; i < len; i++) - CPPUNIT_ASSERT_EQUAL(s[i], pmt_tuple_ref(t, i)); + CPPUNIT_ASSERT_EQUAL(s[i], pmt::tuple_ref(t, i)); } void qa_pmt_prims::test_tuples() { - pmt_t v = pmt_make_vector(10, PMT_NIL); - std::vector<pmt_t> s(10); + pmt::pmt_t v = pmt::make_vector(10, pmt::PMT_NIL); + std::vector<pmt::pmt_t> s(10); for (size_t i = 0; i < 10; i++){ std::ostringstream os; os << "s" << i; - s[i] = mp(os.str()); - pmt_vector_set(v, i, s[i]); + s[i] = pmt::mp(os.str()); + pmt::vector_set(v, i, s[i]); } - pmt_t t; + pmt::pmt_t t; - t = pmt_make_tuple(); + t = pmt::make_tuple(); check_tuple(0, s, t); - t = pmt_make_tuple(s[0]); + t = pmt::make_tuple(s[0]); check_tuple(1, s, t); - CPPUNIT_ASSERT(pmt_is_vector(v)); - CPPUNIT_ASSERT(!pmt_is_tuple(v)); - CPPUNIT_ASSERT(pmt_is_tuple(t)); - CPPUNIT_ASSERT(!pmt_is_vector(t)); + CPPUNIT_ASSERT(pmt::is_vector(v)); + CPPUNIT_ASSERT(!pmt::is_tuple(v)); + CPPUNIT_ASSERT(pmt::is_tuple(t)); + CPPUNIT_ASSERT(!pmt::is_vector(t)); - t = pmt_make_tuple(s[0], s[1]); + t = pmt::make_tuple(s[0], s[1]); check_tuple(2, s, t); - t = pmt_make_tuple(s[0], s[1], s[2]); + t = pmt::make_tuple(s[0], s[1], s[2]); check_tuple(3, s, t); - t = pmt_make_tuple(s[0], s[1], s[2], s[3]); + t = pmt::make_tuple(s[0], s[1], s[2], s[3]); check_tuple(4, s, t); - t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4]); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4]); check_tuple(5, s, t); - t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5]); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5]); check_tuple(6, s, t); - t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6]); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6]); check_tuple(7, s, t); - t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]); check_tuple(8, s, t); - t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8]); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8]); check_tuple(9, s, t); - t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]); check_tuple(10, s, t); - t = pmt_make_tuple(s[0], s[1], s[2]); - CPPUNIT_ASSERT_THROW(pmt_tuple_ref(t, 3), pmt_out_of_range); - CPPUNIT_ASSERT_THROW(pmt_vector_ref(t, 0), pmt_wrong_type); - CPPUNIT_ASSERT_THROW(pmt_tuple_ref(v, 0), pmt_wrong_type); + t = pmt::make_tuple(s[0], s[1], s[2]); + CPPUNIT_ASSERT_THROW(pmt::tuple_ref(t, 3), pmt::out_of_range); + CPPUNIT_ASSERT_THROW(pmt::vector_ref(t, 0), pmt::wrong_type); + CPPUNIT_ASSERT_THROW(pmt::tuple_ref(v, 0), pmt::wrong_type); - t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]); - pmt_t t2 = pmt_to_tuple(v); - CPPUNIT_ASSERT_EQUAL(size_t(10), pmt_length(v)); - CPPUNIT_ASSERT(pmt_equal(t, t2)); + t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]); + pmt::pmt_t t2 = pmt::to_tuple(v); + CPPUNIT_ASSERT_EQUAL(size_t(10), pmt::length(v)); + CPPUNIT_ASSERT(pmt::equal(t, t2)); //std::cout << v << std::endl; //std::cout << t2 << std::endl; - t = pmt_make_tuple(s[0], s[1], s[2]); - pmt_t list0 = pmt_list3(s[0], s[1], s[2]); - CPPUNIT_ASSERT_EQUAL(size_t(3), pmt_length(list0)); - t2 = pmt_to_tuple(list0); - CPPUNIT_ASSERT_EQUAL(size_t(3), pmt_length(t2)); - CPPUNIT_ASSERT(pmt_equal(t, t2)); + t = pmt::make_tuple(s[0], s[1], s[2]); + pmt::pmt_t list0 = pmt::list3(s[0], s[1], s[2]); + CPPUNIT_ASSERT_EQUAL(size_t(3), pmt::length(list0)); + t2 = pmt::to_tuple(list0); + CPPUNIT_ASSERT_EQUAL(size_t(3), pmt::length(t2)); + CPPUNIT_ASSERT(pmt::equal(t, t2)); } void qa_pmt_prims::test_equivalence() { - pmt_t s0 = mp("s0"); - pmt_t s1 = mp("s1"); - pmt_t s2 = mp("s2"); - pmt_t list0 = pmt_cons(s0, pmt_cons(s1, pmt_cons(s2, PMT_NIL))); - pmt_t list1 = pmt_cons(s0, pmt_cons(s1, pmt_cons(s2, PMT_NIL))); - pmt_t i0 = pmt_from_long(42); - pmt_t i1 = pmt_from_long(42); - pmt_t r0 = pmt_from_double(42); - pmt_t r1 = pmt_from_double(42); - pmt_t r2 = pmt_from_double(43); - - CPPUNIT_ASSERT(pmt_eq(s0, s0)); - CPPUNIT_ASSERT(!pmt_eq(s0, s1)); - CPPUNIT_ASSERT(pmt_eqv(s0, s0)); - CPPUNIT_ASSERT(!pmt_eqv(s0, s1)); - - CPPUNIT_ASSERT(pmt_eqv(i0, i1)); - CPPUNIT_ASSERT(pmt_eqv(r0, r1)); - CPPUNIT_ASSERT(!pmt_eqv(r0, r2)); - CPPUNIT_ASSERT(!pmt_eqv(i0, r0)); - - CPPUNIT_ASSERT(!pmt_eq(list0, list1)); - CPPUNIT_ASSERT(!pmt_eqv(list0, list1)); - CPPUNIT_ASSERT(pmt_equal(list0, list1)); - - pmt_t v0 = pmt_make_vector(3, s0); - pmt_t v1 = pmt_make_vector(3, s0); - pmt_t v2 = pmt_make_vector(4, s0); - CPPUNIT_ASSERT(!pmt_eqv(v0, v1)); - CPPUNIT_ASSERT(pmt_equal(v0, v1)); - CPPUNIT_ASSERT(!pmt_equal(v0, v2)); - - pmt_vector_set(v0, 0, list0); - pmt_vector_set(v0, 1, list0); - pmt_vector_set(v1, 0, list1); - pmt_vector_set(v1, 1, list1); - CPPUNIT_ASSERT(pmt_equal(v0, v1)); + pmt::pmt_t s0 = pmt::mp("s0"); + pmt::pmt_t s1 = pmt::mp("s1"); + pmt::pmt_t s2 = pmt::mp("s2"); + pmt::pmt_t list0 = pmt::cons(s0, pmt::cons(s1, pmt::cons(s2, pmt::PMT_NIL))); + pmt::pmt_t list1 = pmt::cons(s0, pmt::cons(s1, pmt::cons(s2, pmt::PMT_NIL))); + pmt::pmt_t i0 = pmt::from_long(42); + pmt::pmt_t i1 = pmt::from_long(42); + pmt::pmt_t r0 = pmt::from_double(42); + pmt::pmt_t r1 = pmt::from_double(42); + pmt::pmt_t r2 = pmt::from_double(43); + + CPPUNIT_ASSERT(pmt::eq(s0, s0)); + CPPUNIT_ASSERT(!pmt::eq(s0, s1)); + CPPUNIT_ASSERT(pmt::eqv(s0, s0)); + CPPUNIT_ASSERT(!pmt::eqv(s0, s1)); + + CPPUNIT_ASSERT(pmt::eqv(i0, i1)); + CPPUNIT_ASSERT(pmt::eqv(r0, r1)); + CPPUNIT_ASSERT(!pmt::eqv(r0, r2)); + CPPUNIT_ASSERT(!pmt::eqv(i0, r0)); + + CPPUNIT_ASSERT(!pmt::eq(list0, list1)); + CPPUNIT_ASSERT(!pmt::eqv(list0, list1)); + CPPUNIT_ASSERT(pmt::equal(list0, list1)); + + pmt::pmt_t v0 = pmt::make_vector(3, s0); + pmt::pmt_t v1 = pmt::make_vector(3, s0); + pmt::pmt_t v2 = pmt::make_vector(4, s0); + CPPUNIT_ASSERT(!pmt::eqv(v0, v1)); + CPPUNIT_ASSERT(pmt::equal(v0, v1)); + CPPUNIT_ASSERT(!pmt::equal(v0, v2)); + + pmt::vector_set(v0, 0, list0); + pmt::vector_set(v0, 1, list0); + pmt::vector_set(v1, 0, list1); + pmt::vector_set(v1, 1, list1); + CPPUNIT_ASSERT(pmt::equal(v0, v1)); } void qa_pmt_prims::test_misc() { - pmt_t k0 = mp("k0"); - pmt_t k1 = mp("k1"); - pmt_t k2 = mp("k2"); - pmt_t k3 = mp("k3"); - pmt_t v0 = mp("v0"); - pmt_t v1 = mp("v1"); - pmt_t v2 = mp("v2"); - pmt_t p0 = pmt_cons(k0, v0); - pmt_t p1 = pmt_cons(k1, v1); - pmt_t p2 = pmt_cons(k2, v2); - - pmt_t alist = pmt_cons(p0, pmt_cons(p1, pmt_cons(p2, PMT_NIL))); - CPPUNIT_ASSERT(pmt_eq(p1, pmt_assv(k1, alist))); - CPPUNIT_ASSERT(pmt_eq(PMT_F, pmt_assv(k3, alist))); - - pmt_t keys = pmt_cons(k0, pmt_cons(k1, pmt_cons(k2, PMT_NIL))); - pmt_t vals = pmt_cons(v0, pmt_cons(v1, pmt_cons(v2, PMT_NIL))); - CPPUNIT_ASSERT(pmt_equal(keys, pmt_map(pmt_car, alist))); - CPPUNIT_ASSERT(pmt_equal(vals, pmt_map(pmt_cdr, alist))); + pmt::pmt_t k0 = pmt::mp("k0"); + pmt::pmt_t k1 = pmt::mp("k1"); + pmt::pmt_t k2 = pmt::mp("k2"); + pmt::pmt_t k3 = pmt::mp("k3"); + pmt::pmt_t v0 = pmt::mp("v0"); + pmt::pmt_t v1 = pmt::mp("v1"); + pmt::pmt_t v2 = pmt::mp("v2"); + pmt::pmt_t p0 = pmt::cons(k0, v0); + pmt::pmt_t p1 = pmt::cons(k1, v1); + pmt::pmt_t p2 = pmt::cons(k2, v2); + + pmt::pmt_t alist = pmt::cons(p0, pmt::cons(p1, pmt::cons(p2, pmt::PMT_NIL))); + CPPUNIT_ASSERT(pmt::eq(p1, pmt::assv(k1, alist))); + CPPUNIT_ASSERT(pmt::eq(pmt::PMT_F, pmt::assv(k3, alist))); + + pmt::pmt_t keys = pmt::cons(k0, pmt::cons(k1, pmt::cons(k2, pmt::PMT_NIL))); + pmt::pmt_t vals = pmt::cons(v0, pmt::cons(v1, pmt::cons(v2, pmt::PMT_NIL))); + CPPUNIT_ASSERT(pmt::equal(keys, pmt::map(pmt::car, alist))); + CPPUNIT_ASSERT(pmt::equal(vals, pmt::map(pmt::cdr, alist))); } void qa_pmt_prims::test_dict() { - pmt_t dict = pmt_make_dict(); - CPPUNIT_ASSERT(pmt_is_dict(dict)); - - pmt_t k0 = mp("k0"); - pmt_t k1 = mp("k1"); - pmt_t k2 = mp("k2"); - pmt_t k3 = mp("k3"); - pmt_t v0 = mp("v0"); - pmt_t v1 = mp("v1"); - pmt_t v2 = mp("v2"); - pmt_t v3 = mp("v3"); - pmt_t not_found = pmt_cons(PMT_NIL, PMT_NIL); - - CPPUNIT_ASSERT(!pmt_dict_has_key(dict, k0)); - dict = pmt_dict_add(dict, k0, v0); - CPPUNIT_ASSERT(pmt_dict_has_key(dict, k0)); - CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k0, not_found), v0)); - CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), not_found)); - dict = pmt_dict_add(dict, k1, v1); - dict = pmt_dict_add(dict, k2, v2); - CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v1)); - dict = pmt_dict_add(dict, k1, v3); - CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v3)); - - pmt_t keys = pmt_list3(k1, k2, k0); - pmt_t vals = pmt_list3(v3, v2, v0); - //std::cout << "pmt_dict_keys: " << pmt_dict_keys(dict) << std::endl; - //std::cout << "pmt_dict_values: " << pmt_dict_values(dict) << std::endl; - CPPUNIT_ASSERT(pmt_equal(keys, pmt_dict_keys(dict))); - CPPUNIT_ASSERT(pmt_equal(vals, pmt_dict_values(dict))); + pmt::pmt_t dict = pmt::make_dict(); + CPPUNIT_ASSERT(pmt::is_dict(dict)); + + pmt::pmt_t k0 = pmt::mp("k0"); + pmt::pmt_t k1 = pmt::mp("k1"); + pmt::pmt_t k2 = pmt::mp("k2"); + pmt::pmt_t k3 = pmt::mp("k3"); + pmt::pmt_t v0 = pmt::mp("v0"); + pmt::pmt_t v1 = pmt::mp("v1"); + pmt::pmt_t v2 = pmt::mp("v2"); + pmt::pmt_t v3 = pmt::mp("v3"); + pmt::pmt_t not_found = pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL); + + CPPUNIT_ASSERT(!pmt::dict_has_key(dict, k0)); + dict = pmt::dict_add(dict, k0, v0); + CPPUNIT_ASSERT(pmt::dict_has_key(dict, k0)); + CPPUNIT_ASSERT(pmt::eqv(pmt::dict_ref(dict, k0, not_found), v0)); + CPPUNIT_ASSERT(pmt::eqv(pmt::dict_ref(dict, k1, not_found), not_found)); + dict = pmt::dict_add(dict, k1, v1); + dict = pmt::dict_add(dict, k2, v2); + CPPUNIT_ASSERT(pmt::eqv(pmt::dict_ref(dict, k1, not_found), v1)); + dict = pmt::dict_add(dict, k1, v3); + CPPUNIT_ASSERT(pmt::eqv(pmt::dict_ref(dict, k1, not_found), v3)); + + pmt::pmt_t keys = pmt::list3(k1, k2, k0); + pmt::pmt_t vals = pmt::list3(v3, v2, v0); + //std::cout << "pmt::dict_keys: " << pmt::dict_keys(dict) << std::endl; + //std::cout << "pmt::dict_values: " << pmt::dict_values(dict) << std::endl; + CPPUNIT_ASSERT(pmt::equal(keys, pmt::dict_keys(dict))); + CPPUNIT_ASSERT(pmt::equal(vals, pmt::dict_values(dict))); } void qa_pmt_prims::test_io() { - pmt_t k0 = mp("k0"); - pmt_t k1 = mp("k1"); - pmt_t k2 = mp("k2"); - pmt_t k3 = mp("k3"); + pmt::pmt_t k0 = pmt::mp("k0"); + pmt::pmt_t k1 = pmt::mp("k1"); + pmt::pmt_t k2 = pmt::mp("k2"); + pmt::pmt_t k3 = pmt::mp("k3"); - CPPUNIT_ASSERT_EQUAL(std::string("k0"), pmt_write_string(k0)); + CPPUNIT_ASSERT_EQUAL(std::string("k0"), pmt::write_string(k0)); } void qa_pmt_prims::test_lists() { - pmt_t s0 = mp("s0"); - pmt_t s1 = mp("s1"); - pmt_t s2 = mp("s2"); - pmt_t s3 = mp("s3"); - - pmt_t l1 = pmt_list4(s0, s1, s2, s3); - pmt_t l2 = pmt_list3(s0, s1, s2); - pmt_t l3 = pmt_list_add(l2, s3); - CPPUNIT_ASSERT(pmt_equal(l1, l3)); + pmt::pmt_t s0 = pmt::mp("s0"); + pmt::pmt_t s1 = pmt::mp("s1"); + pmt::pmt_t s2 = pmt::mp("s2"); + pmt::pmt_t s3 = pmt::mp("s3"); + + pmt::pmt_t l1 = pmt::list4(s0, s1, s2, s3); + pmt::pmt_t l2 = pmt::list3(s0, s1, s2); + pmt::pmt_t l3 = pmt::list_add(l2, s3); + CPPUNIT_ASSERT(pmt::equal(l1, l3)); } // ------------------------------------------------------------------------ @@ -464,18 +462,18 @@ qa_pmt_prims::test_any() a1 = 42; a2 = foo(3.250, 21); - pmt_t p0 = pmt_make_any(a0); - pmt_t p1 = pmt_make_any(a1); - pmt_t p2 = pmt_make_any(a2); + pmt::pmt_t p0 = pmt::make_any(a0); + pmt::pmt_t p1 = pmt::make_any(a1); + pmt::pmt_t p2 = pmt::make_any(a2); CPPUNIT_ASSERT_EQUAL(std::string("Hello!"), - boost::any_cast<std::string>(pmt_any_ref(p0))); + boost::any_cast<std::string>(pmt::any_ref(p0))); CPPUNIT_ASSERT_EQUAL(42, - boost::any_cast<int>(pmt_any_ref(p1))); + boost::any_cast<int>(pmt::any_ref(p1))); CPPUNIT_ASSERT_EQUAL(foo(3.250, 21), - boost::any_cast<foo>(pmt_any_ref(p2))); + boost::any_cast<foo>(pmt::any_ref(p2))); } // ------------------------------------------------------------------------ @@ -484,7 +482,7 @@ class qa_pmt_msg_accepter_nop : public gruel::msg_accepter { public: qa_pmt_msg_accepter_nop(){}; ~qa_pmt_msg_accepter_nop(); - void post(pmt_t,pmt_t){}; + void post(pmt::pmt_t,pmt::pmt_t){}; }; qa_pmt_msg_accepter_nop::~qa_pmt_msg_accepter_nop(){} @@ -492,22 +490,22 @@ qa_pmt_msg_accepter_nop::~qa_pmt_msg_accepter_nop(){} void qa_pmt_prims::test_msg_accepter() { - pmt_t sym = mp("my-symbol"); + pmt::pmt_t sym = pmt::mp("my-symbol"); boost::any a0; a0 = std::string("Hello!"); - pmt_t p0 = pmt_make_any(a0); + pmt::pmt_t p0 = pmt::make_any(a0); gruel::msg_accepter_sptr ma0 = gruel::msg_accepter_sptr(new qa_pmt_msg_accepter_nop()); - pmt_t p1 = pmt_make_msg_accepter(ma0); + pmt::pmt_t p1 = pmt::make_msg_accepter(ma0); - CPPUNIT_ASSERT_EQUAL(ma0.get(), pmt_msg_accepter_ref(p1).get()); + CPPUNIT_ASSERT_EQUAL(ma0.get(), pmt::msg_accepter_ref(p1).get()); - CPPUNIT_ASSERT_THROW(pmt_msg_accepter_ref(sym), pmt_wrong_type); - CPPUNIT_ASSERT_THROW(pmt_msg_accepter_ref(p0), pmt_wrong_type); + CPPUNIT_ASSERT_THROW(pmt::msg_accepter_ref(sym), pmt::wrong_type); + CPPUNIT_ASSERT_THROW(pmt::msg_accepter_ref(p0), pmt::wrong_type); // just confirm interfaces on send are OK - pmt_t port(pmt_intern("port")); + pmt::pmt_t port(pmt::intern("port")); gruel::send(ma0.get(), port, sym); gruel::send(ma0, port, sym); gruel::send(p1, port, sym); @@ -520,43 +518,43 @@ void qa_pmt_prims::test_serialize() { std::stringbuf sb; // fake channel - pmt_t a = mp("a"); - pmt_t b = mp("b"); - pmt_t c = mp("c"); + pmt::pmt_t a = pmt::mp("a"); + pmt::pmt_t b = pmt::mp("b"); + pmt::pmt_t c = pmt::mp("c"); sb.str(""); // reset channel to empty // write stuff to channel - pmt_serialize(PMT_NIL, sb); - pmt_serialize(mp("foobarvia"), sb); - pmt_serialize(pmt_from_long(123456789), sb); - pmt_serialize(pmt_from_long(-123456789), sb); - pmt_serialize(pmt_cons(PMT_NIL, PMT_NIL), sb); - pmt_serialize(pmt_cons(a, b), sb); - pmt_serialize(pmt_list1(a), sb); - pmt_serialize(pmt_list2(a, b), sb); - pmt_serialize(pmt_list3(a, b, c), sb); - pmt_serialize(pmt_list3(a, pmt_list3(c, b, a), c), sb); - pmt_serialize(PMT_T, sb); - pmt_serialize(PMT_F, sb); + pmt::serialize(pmt::PMT_NIL, sb); + pmt::serialize(pmt::mp("foobarvia"), sb); + pmt::serialize(pmt::from_long(123456789), sb); + pmt::serialize(pmt::from_long(-123456789), sb); + pmt::serialize(pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL), sb); + pmt::serialize(pmt::cons(a, b), sb); + pmt::serialize(pmt::list1(a), sb); + pmt::serialize(pmt::list2(a, b), sb); + pmt::serialize(pmt::list3(a, b, c), sb); + pmt::serialize(pmt::list3(a, pmt::list3(c, b, a), c), sb); + pmt::serialize(pmt::PMT_T, sb); + pmt::serialize(pmt::PMT_F, sb); // read it back - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_NIL)); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), mp("foobarvia"))); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_from_long(123456789))); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_from_long(-123456789))); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_cons(PMT_NIL, PMT_NIL))); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_cons(a, b))); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list1(a))); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list2(a, b))); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list3(a, b, c))); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list3(a, pmt_list3(c, b, a), c))); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_T)); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_F)); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::PMT_NIL)); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::mp("foobarvia"))); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::from_long(123456789))); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::from_long(-123456789))); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL))); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::cons(a, b))); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::list1(a))); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::list2(a, b))); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::list3(a, b, c))); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::list3(a, pmt::list3(c, b, a), c))); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::PMT_T)); + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::PMT_F)); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_EOF)); // last item + CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::PMT_EOF)); // last item // FIXME add tests for real, complex, vector, uniform-vector, dict @@ -567,37 +565,37 @@ qa_pmt_prims::test_serialize() void qa_pmt_prims::test_sets() { - pmt_t s1 = mp("s1"); - pmt_t s2 = mp("s2"); - pmt_t s3 = mp("s3"); - - pmt_t l1 = pmt_list1(s1); - pmt_t l2 = pmt_list2(s2,s3); - pmt_t l3 = pmt_list3(s1,s2,s3); - - CPPUNIT_ASSERT(pmt_is_pair(pmt_memq(s1,l1))); - CPPUNIT_ASSERT(pmt_is_false(pmt_memq(s3,l1))); - - CPPUNIT_ASSERT(pmt_subsetp(l1,l3)); - CPPUNIT_ASSERT(pmt_subsetp(l2,l3)); - CPPUNIT_ASSERT(!pmt_subsetp(l1,l2)); - CPPUNIT_ASSERT(!pmt_subsetp(l2,l1)); - CPPUNIT_ASSERT(!pmt_subsetp(l3,l2)); + pmt::pmt_t s1 = pmt::mp("s1"); + pmt::pmt_t s2 = pmt::mp("s2"); + pmt::pmt_t s3 = pmt::mp("s3"); + + pmt::pmt_t l1 = pmt::list1(s1); + pmt::pmt_t l2 = pmt::list2(s2,s3); + pmt::pmt_t l3 = pmt::list3(s1,s2,s3); + + CPPUNIT_ASSERT(pmt::is_pair(pmt::memq(s1,l1))); + CPPUNIT_ASSERT(pmt::is_false(pmt::memq(s3,l1))); + + CPPUNIT_ASSERT(pmt::subsetp(l1,l3)); + CPPUNIT_ASSERT(pmt::subsetp(l2,l3)); + CPPUNIT_ASSERT(!pmt::subsetp(l1,l2)); + CPPUNIT_ASSERT(!pmt::subsetp(l2,l1)); + CPPUNIT_ASSERT(!pmt::subsetp(l3,l2)); } void qa_pmt_prims::test_sugar() { - CPPUNIT_ASSERT(pmt_is_symbol(mp("my-symbol"))); - CPPUNIT_ASSERT_EQUAL((long) 10, pmt_to_long(mp(10))); - CPPUNIT_ASSERT_EQUAL((double) 1e6, pmt_to_double(mp(1e6))); + CPPUNIT_ASSERT(pmt::is_symbol(pmt::mp("my-symbol"))); + CPPUNIT_ASSERT_EQUAL((long) 10, pmt::to_long(pmt::mp(10))); + CPPUNIT_ASSERT_EQUAL((double) 1e6, pmt::to_double(pmt::mp(1e6))); CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, 3), - pmt_to_complex(mp(std::complex<double>(2, 3)))); + pmt::to_complex(pmt::mp(std::complex<double>(2, 3)))); int buf[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; - pmt_t blob = mp(buf, sizeof(buf)); - const void *data = pmt_blob_data(blob); - size_t nbytes = pmt_blob_length(blob); + pmt::pmt_t blob = pmt::mp(buf, sizeof(buf)); + const void *data = pmt::blob_data(blob); + size_t nbytes = pmt::blob_length(blob); CPPUNIT_ASSERT_EQUAL(sizeof(buf), nbytes); CPPUNIT_ASSERT(memcmp(buf, data, nbytes) == 0); } diff --git a/gruel/src/lib/pmt/unv_qa_template.cc.t b/gruel/src/lib/pmt/unv_qa_template.cc.t index 1e2c8e8eb5..a04d532b4e 100644 --- a/gruel/src/lib/pmt/unv_qa_template.cc.t +++ b/gruel/src/lib/pmt/unv_qa_template.cc.t @@ -2,31 +2,31 @@ void qa_pmt_unv::test_@TAG@vector() { static const size_t N = 3; - pmt_t v1 = pmt_make_@TAG@vector(N, 0); - CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1)); + pmt_t v1 = pmt::make_@TAG@vector(N, 0); + CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1)); @TYPE@ s0 = @TYPE@(10); @TYPE@ s1 = @TYPE@(20); @TYPE@ s2 = @TYPE@(30); - pmt_@TAG@vector_set(v1, 0, s0); - pmt_@TAG@vector_set(v1, 1, s1); - pmt_@TAG@vector_set(v1, 2, s2); + pmt::@TAG@vector_set(v1, 0, s0); + pmt::@TAG@vector_set(v1, 1, s1); + pmt::@TAG@vector_set(v1, 2, s2); - CPPUNIT_ASSERT_EQUAL(s0, pmt_@TAG@vector_ref(v1, 0)); - CPPUNIT_ASSERT_EQUAL(s1, pmt_@TAG@vector_ref(v1, 1)); - CPPUNIT_ASSERT_EQUAL(s2, pmt_@TAG@vector_ref(v1, 2)); + CPPUNIT_ASSERT_EQUAL(s0, pmt::@TAG@vector_ref(v1, 0)); + CPPUNIT_ASSERT_EQUAL(s1, pmt::@TAG@vector_ref(v1, 1)); + CPPUNIT_ASSERT_EQUAL(s2, pmt::@TAG@vector_ref(v1, 2)); - CPPUNIT_ASSERT_THROW(pmt_@TAG@vector_ref(v1, N), pmt_out_of_range); - CPPUNIT_ASSERT_THROW(pmt_@TAG@vector_set(v1, N, @TYPE@(0)), pmt_out_of_range); + CPPUNIT_ASSERT_THROW(pmt::@TAG@vector_ref(v1, N), pmt::out_of_range); + CPPUNIT_ASSERT_THROW(pmt::@TAG@vector_set(v1, N, @TYPE@(0)), pmt::out_of_range); size_t len; - const @TYPE@ *rd = pmt_@TAG@vector_elements(v1, len); + const @TYPE@ *rd = pmt::@TAG@vector_elements(v1, len); CPPUNIT_ASSERT_EQUAL(len, N); CPPUNIT_ASSERT_EQUAL(s0, rd[0]); CPPUNIT_ASSERT_EQUAL(s1, rd[1]); CPPUNIT_ASSERT_EQUAL(s2, rd[2]); - @TYPE@ *wr = pmt_@TAG@vector_writable_elements(v1, len); + @TYPE@ *wr = pmt::@TAG@vector_writable_elements(v1, len); CPPUNIT_ASSERT_EQUAL(len, N); wr[0] = @TYPE@(0); CPPUNIT_ASSERT_EQUAL(@TYPE@(0), wr[0]); diff --git a/gruel/src/lib/pmt/unv_template.cc.t b/gruel/src/lib/pmt/unv_template.cc.t index 1ed505e29a..8678894973 100644 --- a/gruel/src/lib/pmt/unv_template.cc.t +++ b/gruel/src/lib/pmt/unv_template.cc.t @@ -29,7 +29,7 @@ pmt_@TAG@vector::pmt_@TAG@vector(size_t k, const @TYPE@ *data) pmt_@TAG@vector::ref(size_t k) const { if (k >= length()) - throw pmt_out_of_range("pmt_@TAG@vector_ref", pmt_from_long(k)); + throw out_of_range("pmt_@TAG@vector_ref", from_long(k)); return d_v[k]; } @@ -37,7 +37,7 @@ void pmt_@TAG@vector::set(size_t k, @TYPE@ x) { if (k >= length()) - throw pmt_out_of_range("pmt_@TAG@vector_set", pmt_from_long(k)); + throw out_of_range("pmt_@TAG@vector_set", from_long(k)); d_v[k] = x; } @@ -70,59 +70,59 @@ pmt_@TAG@vector::uniform_writable_elements(size_t &len) } bool -pmt_is_@TAG@vector(pmt_t obj) +is_@TAG@vector(pmt_t obj) { return obj->is_@TAG@vector(); } pmt_t -pmt_make_@TAG@vector(size_t k, @TYPE@ fill) +make_@TAG@vector(size_t k, @TYPE@ fill) { return pmt_t(new pmt_@TAG@vector(k, fill)); } pmt_t -pmt_init_@TAG@vector(size_t k, const @TYPE@ *data) +init_@TAG@vector(size_t k, const @TYPE@ *data) { return pmt_t(new pmt_@TAG@vector(k, data)); } pmt_t -pmt_init_@TAG@vector(size_t k, const std::vector< @TYPE@ > &data) +init_@TAG@vector(size_t k, const std::vector< @TYPE@ > &data) { return pmt_t(new pmt_@TAG@vector(k, &data[0])); } @TYPE@ -pmt_@TAG@vector_ref(pmt_t vector, size_t k) +@TAG@vector_ref(pmt_t vector, size_t k) { if (!vector->is_@TAG@vector()) - throw pmt_wrong_type("pmt_@TAG@vector_ref", vector); + throw wrong_type("pmt_@TAG@vector_ref", vector); return _@TAG@vector(vector)->ref(k); } void -pmt_@TAG@vector_set(pmt_t vector, size_t k, @TYPE@ obj) +@TAG@vector_set(pmt_t vector, size_t k, @TYPE@ obj) { if (!vector->is_@TAG@vector()) - throw pmt_wrong_type("pmt_@TAG@vector_set", vector); + throw wrong_type("pmt_@TAG@vector_set", vector); _@TAG@vector(vector)->set(k, obj); } const @TYPE@ * -pmt_@TAG@vector_elements(pmt_t vector, size_t &len) +@TAG@vector_elements(pmt_t vector, size_t &len) { if (!vector->is_@TAG@vector()) - throw pmt_wrong_type("pmt_@TAG@vector_elements", vector); + throw wrong_type("pmt_@TAG@vector_elements", vector); return _@TAG@vector(vector)->elements(len); } const std::vector< @TYPE@ > -pmt_@TAG@vector_elements(pmt_t vector) +@TAG@vector_elements(pmt_t vector) { if (!vector->is_@TAG@vector()) - throw pmt_wrong_type("pmt_@TAG@vector_elements", vector); + throw wrong_type("pmt_@TAG@vector_elements", vector); size_t len; const @TYPE@ *array = _@TAG@vector(vector)->elements(len); const std::vector< @TYPE@ > vec(array, array+len); @@ -131,10 +131,10 @@ pmt_@TAG@vector_elements(pmt_t vector) @TYPE@ * -pmt_@TAG@vector_writable_elements(pmt_t vector, size_t &len) +@TAG@vector_writable_elements(pmt_t vector, size_t &len) { if (!vector->is_@TAG@vector()) - throw pmt_wrong_type("pmt_@TAG@vector_writable_elements", vector); + throw wrong_type("pmt_@TAG@vector_writable_elements", vector); return _@TAG@vector(vector)->writable_elements(len); } |