summaryrefslogtreecommitdiff
path: root/gruel/src/lib
diff options
context:
space:
mode:
authorTom Rondeau <trondeau@vt.edu>2012-12-20 22:56:56 -0500
committerTom Rondeau <trondeau@vt.edu>2012-12-21 12:43:30 -0500
commit275add3ae70d648dfb0ce14eb7df99b0e9adecbd (patch)
tree43e567446cc81e20627326682b0ec19684678da4 /gruel/src/lib
parentf0bff01c27c793952f41344c62b4ea6a7cb5bdf1 (diff)
gruel: Renaming PMT function to get rid of pmt_ prefix.
Also cleans up Python interface. Removed pmt.print statement from swig but overloaded __repr__ attribute of PMTs for easy printing.
Diffstat (limited to 'gruel/src/lib')
-rw-r--r--gruel/src/lib/pmt/pmt.cc532
-rw-r--r--gruel/src/lib/pmt/pmt_io.cc88
-rw-r--r--gruel/src/lib/pmt/pmt_serialize.cc254
-rw-r--r--gruel/src/lib/pmt/qa_pmt_prims.cc644
-rw-r--r--gruel/src/lib/pmt/unv_qa_template.cc.t24
-rw-r--r--gruel/src/lib/pmt/unv_template.cc.t32
6 files changed, 789 insertions, 785 deletions
diff --git a/gruel/src/lib/pmt/pmt.cc b/gruel/src/lib/pmt/pmt.cc
index 1d1e9ba7c8..bb1866d562 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,29 +380,31 @@ 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 pmt_from_complex(re, im);
+ return from_complex(re, im);
}
-pmt_t pmt_from_complex(double re, double im)
+pmt_t
+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 +413,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 +424,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 +494,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 +502,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 +514,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 +562,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 +584,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 +598,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 +607,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 +617,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 +628,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 +640,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 +653,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 +667,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 +682,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 +698,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 +715,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 +733,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 +749,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 +783,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 &not_found)
+dict_ref(const pmt_t &dict, const pmt_t &key, const pmt_t &not_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 +868,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 +900,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 +934,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 +967,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 +994,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 +1015,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 +1030,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 +1043,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 +1070,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 +1086,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 +1123,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 +1141,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 +1168,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 +1353,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);
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-03-17 21:59:43 +0000