- // nop -- out of line virtual destructor

-exception::exception(const std::string &msg, pmt_t obj)

- : logic_error(msg + ": " + write_string(obj))

-wrong_type::wrong_type(const std::string &msg, pmt_t obj)

- : exception(msg + ": wrong_type ", obj)

-out_of_range::out_of_range(const std::string &msg, pmt_t obj)

- : exception(msg + ": out of range ", obj)

-notimplemented::notimplemented(const std::string &msg, pmt_t obj)

- : exception(msg + ": notimplemented ", obj)

-static pmt_symbol *

-_symbol(pmt_t x)

-{

- return dynamic_cast<pmt_symbol*>(x.get());

-}

-static pmt_integer *

-_integer(pmt_t x)

-{

- return dynamic_cast<pmt_integer*>(x.get());

-}

-static pmt_uint64 *

-_uint64(pmt_t x)

-{

- return dynamic_cast<pmt_uint64*>(x.get());

-}

-static pmt_real *

-_real(pmt_t x)

-{

- return dynamic_cast<pmt_real*>(x.get());

-}

-static pmt_complex *

-_complex(pmt_t x)

-{

- return dynamic_cast<pmt_complex*>(x.get());

-}

-static pmt_pair *

-_pair(pmt_t x)

-{

- return dynamic_cast<pmt_pair*>(x.get());

-}

-static pmt_vector *

-_vector(pmt_t x)

-{

- return dynamic_cast<pmt_vector*>(x.get());

-}

-static pmt_tuple *

-_tuple(pmt_t x)

-{

- return dynamic_cast<pmt_tuple*>(x.get());

-}

-static pmt_uniform_vector *

-_uniform_vector(pmt_t x)

- return dynamic_cast<pmt_uniform_vector*>(x.get());

-static pmt_any *

-_any(pmt_t x)

-{

- return dynamic_cast<pmt_any*>(x.get());

-}

- static pmt_t _NIL = pmt_t(new pmt_null());

- return _NIL;

- static const pmt_t _T = pmt_t(new pmt_bool());

- return _T;

- static const pmt_t _F = pmt_t(new pmt_bool());

- return _F;

- static const pmt_t _EOF = cons(get_PMT_NIL(), get_PMT_NIL());

- return _EOF;

-pmt_bool::pmt_bool(){}

-bool

-is_true(pmt_t obj)

-{

- return obj != PMT_F;

-}

-bool

-is_false(pmt_t obj)

-{

- return obj == PMT_F;

-}

-bool

-is_bool(pmt_t obj)

-{

- return obj->is_bool();

-}

-pmt_t

-from_bool(bool val)

-{

- return val ? PMT_T : PMT_F;

-}

-bool

-to_bool(pmt_t val)

- if (val == PMT_T)

- return true;

- if (val == PMT_F)

- return false;

- throw wrong_type("pmt_to_bool", val);

-static const unsigned int

-get_symbol_hash_table_size()

- static const unsigned int SYMBOL_HASH_TABLE_SIZE = 701;

- return SYMBOL_HASH_TABLE_SIZE;

-static std::vector<pmt_t>*

-get_symbol_hash_table()

- static std::vector<pmt_t> s_symbol_hash_table(get_symbol_hash_table_size());

- return &s_symbol_hash_table;

-pmt_symbol::pmt_symbol(const std::string &name) : d_name(name){}

-static unsigned int

-hash_string(const std::string &s)

- unsigned int h = 0;

- unsigned int g = 0;

- for (std::string::const_iterator p = s.begin(); p != s.end(); ++p){

- h = (h << 4) + (*p & 0xff);

- g = h & 0xf0000000;

- if (g){

- h = h ^ (g >> 24);

- h = h ^ g;

- }

- return h;

-bool

-is_symbol(const pmt_t& obj)

-{

- return obj->is_symbol();

-}

-pmt_t

-string_to_symbol(const std::string &name)

- unsigned hash = hash_string(name) % get_symbol_hash_table_size();

- // Does a symbol with this name already exist?

- for (pmt_t sym = (*get_symbol_hash_table())[hash]; sym; sym = _symbol(sym)->next()){

- if (name == _symbol(sym)->name())

- return sym; // Yes. Return it

- }

- // Lock the table on insert for thread safety:

- static boost::mutex thread_safety;

- boost::mutex::scoped_lock lock(thread_safety);

- // Re-do the search in case another thread inserted this symbol into the table

- // before we got the lock

- for (pmt_t sym = (*get_symbol_hash_table())[hash]; sym; sym = _symbol(sym)->next()){

- if (name == _symbol(sym)->name())

- return sym; // Yes. Return it

- }

- // Nope. Make a new one.

- pmt_t sym = pmt_t(new pmt_symbol(name));

- _symbol(sym)->set_next((*get_symbol_hash_table())[hash]);

- (*get_symbol_hash_table())[hash] = sym;

- return sym;

-pmt_t

-intern(const std::string &name)

-{

- return string_to_symbol(name);

-}

-const std::string

-symbol_to_string(const pmt_t& sym)

- if (!sym->is_symbol())

- throw wrong_type("pmt_symbol_to_string", sym);

- return _symbol(sym)->name();

-

-bool

-is_number(pmt_t x)

-{

- return x->is_number();

-}

-bool

-is_integer(pmt_t x)

-{

- return x->is_integer();

-}

-pmt_t

-from_long(long x)

-{

- return pmt_t(new pmt_integer(x));

-}

-long

-to_long(pmt_t x)

- pmt_integer* i = dynamic_cast<pmt_integer*>(x.get());

- if ( i )

- return i->value();

- throw wrong_type("pmt_to_long", x);

-bool

-is_uint64(pmt_t x)

-{

- return x->is_uint64();

-}

-pmt_t

-from_uint64(uint64_t x)

-{

- return pmt_t(new pmt_uint64(x));

-}

-uint64_t

-to_uint64(pmt_t x)

- if(x->is_uint64())

- return _uint64(x)->value();

- if(x->is_integer())

- {

- long tmp = _integer(x)->value();

- if(tmp >= 0)

- return (uint64_t) tmp;

- throw wrong_type("pmt_to_uint64", x);

-bool

-is_real(pmt_t x)

-{

- return x->is_real();

-}

-pmt_t

-from_double(double x)

-{

- return pmt_t(new pmt_real(x));

-}

-pmt_t

-from_float(float x)

-{

- return pmt_t(new pmt_real(x));

-}

-double

-to_double(pmt_t x)

- if (x->is_real())

- return _real(x)->value();

- if (x->is_integer())

- return _integer(x)->value();

- throw wrong_type("pmt_to_double", x);

-float

-to_float(pmt_t x)

-{

- return float(to_double(x));

-}

-bool

-is_complex(pmt_t x)

-{

- return x->is_complex();

-}

-pmt_t

-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);

-}

- return pmt_t(new pmt_complex(std::complex<double>(re, im)));

-pmt_t

-from_complex(const std::complex<double> &z)

-{

- return pmt_t(new pmt_complex(z));

-}

-std::complex<double>

-to_complex(pmt_t x)

- if (x->is_complex())

- return _complex(x)->value();

- if (x->is_real())

- return _real(x)->value();

- if (x->is_integer())

- return _integer(x)->value();

- throw wrong_type("pmt_to_complex", x);

-bool

-is_null(const pmt_t& x)

-{

- return x == PMT_NIL;

-}

-bool

-is_pair(const pmt_t& obj)

-{

- return obj->is_pair();

-}

-pmt_t

-cons(const pmt_t& x, const pmt_t& y)

-{

- return pmt_t(new pmt_pair(x, y));

-}

-pmt_t

-car(const pmt_t& pair)

- pmt_pair* p = dynamic_cast<pmt_pair*>(pair.get());

- if ( p )

- return p->car();

- throw wrong_type("pmt_car", pair);

-pmt_t

-cdr(const pmt_t& pair)

- pmt_pair* p = dynamic_cast<pmt_pair*>(pair.get());

- if ( p )

- return p->cdr();

- throw wrong_type("pmt_cdr", pair);

-void

-set_car(pmt_t pair, pmt_t obj)

- if (pair->is_pair())

- _pair(pair)->set_car(obj);

- else

- throw wrong_type("pmt_set_car", pair);

-void

-set_cdr(pmt_t pair, pmt_t obj)

- if (pair->is_pair())

- _pair(pair)->set_cdr(obj);

- else

- throw wrong_type("pmt_set_cdr", pair);

-pmt_vector::pmt_vector(size_t len, pmt_t fill)

- : d_v(len)

- for (size_t i = 0; i < len; i++)

- d_v[i] = fill;

-pmt_t

-pmt_vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_vector::set(size_t k, pmt_t obj)

- if (k >= length())

- throw out_of_range("pmt_vector_set", from_long(k));

- d_v[k] = obj;

-void

-pmt_vector::fill(pmt_t obj)

- for (size_t i = 0; i < length(); i++)

- d_v[i] = obj;

-bool

-is_vector(pmt_t obj)

-{

- return obj->is_vector();

-}

-pmt_t

-make_vector(size_t k, pmt_t fill)

-{

- return pmt_t(new pmt_vector(k, fill));

-}

-pmt_t

-vector_ref(pmt_t vector, size_t k)

- if (!vector->is_vector())

- throw wrong_type("pmt_vector_ref", vector);

- return _vector(vector)->ref(k);

-void

-vector_set(pmt_t vector, size_t k, pmt_t obj)

- if (!vector->is_vector())

- throw wrong_type("pmt_vector_set", vector);

- _vector(vector)->set(k, obj);

-void

-vector_fill(pmt_t vector, pmt_t obj)

- if (!vector->is_vector())

- throw wrong_type("pmt_vector_set", vector);

- _vector(vector)->fill(obj);

-pmt_tuple::pmt_tuple(size_t len)

- : d_v(len)

-{

-}

-pmt_t

-pmt_tuple::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_tuple_ref", from_long(k));

- return d_v[k];

-bool

-is_tuple(pmt_t obj)

-{

- return obj->is_tuple();

-}

-pmt_t

-tuple_ref(const pmt_t &tuple, size_t k)

- if (!tuple->is_tuple())

- throw wrong_type("pmt_tuple_ref", tuple);

- return _tuple(tuple)->ref(k);

-pmt_t

-make_tuple()

-{

- return pmt_t(new pmt_tuple(0));

-}

-

-pmt_t

-make_tuple(const pmt_t &e0)

-{

- pmt_tuple *t = new pmt_tuple(1);

- t->_set(0, e0);

- return pmt_t(t);

-}

-

-pmt_t

-make_tuple(const pmt_t &e0, const pmt_t &e1)

-{

- pmt_tuple *t = new pmt_tuple(2);

- t->_set(0, e0);

- t->_set(1, e1);

- return pmt_t(t);

-}

-

-pmt_t

-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);

- t->_set(1, e1);

- t->_set(2, e2);

- return pmt_t(t);

-}

-

-pmt_t

-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);

- t->_set(1, e1);

- t->_set(2, e2);

- t->_set(3, e3);

- return pmt_t(t);

-}

-

-pmt_t

-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);

- t->_set(1, e1);

- t->_set(2, e2);

- t->_set(3, e3);

- t->_set(4, e4);

- return pmt_t(t);

-}

-

-pmt_t

-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);

- t->_set(1, e1);

- t->_set(2, e2);

- t->_set(3, e3);

- t->_set(4, e4);

- t->_set(5, e5);

- return pmt_t(t);

-}

-

-pmt_t

-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);

- t->_set(1, e1);

- t->_set(2, e2);

- t->_set(3, e3);

- t->_set(4, e4);

- t->_set(5, e5);

- t->_set(6, e6);

- return pmt_t(t);

-}

-

-pmt_t

-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);

- t->_set(1, e1);

- t->_set(2, e2);

- t->_set(3, e3);

- t->_set(4, e4);

- t->_set(5, e5);

- t->_set(6, e6);

- t->_set(7, e7);

- return pmt_t(t);

-}

-pmt_t

-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);

- t->_set(1, e1);

- t->_set(2, e2);

- t->_set(3, e3);

- t->_set(4, e4);

- t->_set(5, e5);

- t->_set(6, e6);

- t->_set(7, e7);

- t->_set(8, e8);

- return pmt_t(t);

-}

-

-pmt_t

-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);

- t->_set(1, e1);

- t->_set(2, e2);

- t->_set(3, e3);

- t->_set(4, e4);

- t->_set(5, e5);

- t->_set(6, e6);

- t->_set(7, e7);

- t->_set(8, e8);

- t->_set(9, e9);

- return pmt_t(t);

-}

-

-pmt_t

-to_tuple(const pmt_t &x)

-{

- if (x->is_tuple()) // already one

- return x;

-

- size_t len = length(x);

- pmt_tuple *t = new pmt_tuple(len);

- pmt_t r = pmt_t(t);

-

- if (x->is_vector()){

- for (size_t i = 0; i < len; i++)

- t->_set(i, _vector(x)->ref(i));

- return r;

- }

-

- if (x->is_pair()){

- pmt_t y = x;

- for (size_t i = 0; i < len; i++){

- t->_set(i, car(y));

- y = cdr(y);

- return r;

- }

- throw wrong_type("pmt_to_tuple", x);

-

-bool

-is_uniform_vector(pmt_t x)

-{

- return x->is_uniform_vector();

-}

-size_t

-uniform_vector_itemsize(pmt_t vector)

- if (!vector->is_uniform_vector())

- throw wrong_type("pmt_uniform_vector_itemsize", vector);

- return _uniform_vector(vector)->itemsize();

-const void *

-uniform_vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_uniform_vector())

- throw wrong_type("pmt_uniform_vector_elements", vector);

- return _uniform_vector(vector)->uniform_elements(len);

-void *

-uniform_vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_uniform_vector())

- throw wrong_type("pmt_uniform_vector_writable_elements", vector);

- return _uniform_vector(vector)->uniform_writable_elements(len);

-

-bool

-is_dict(const pmt_t &obj)

-{

- return is_null(obj) || is_pair(obj);

-}

-pmt_t

-make_dict()

-{

- return PMT_NIL;

-}

-pmt_t

-dict_add(const pmt_t &dict, const pmt_t &key, const pmt_t &value)

- if (is_null(dict))

- return acons(key, value, PMT_NIL);

- if (dict_has_key(dict, key))

- return acons(key, value, dict_delete(dict, key));

- return acons(key, value, dict);

-pmt_t

-dict_update(const pmt_t &dict1, const pmt_t &dict2)

- pmt_t d(dict1);

- pmt_t k(dict_keys(dict2));

- while(is_pair(k)){

- d = dict_add(d, car(k), dict_ref(dict2, car(k), PMT_NIL));

- k = cdr(k);

- return d;

-pmt_t

-dict_delete(const pmt_t &dict, const pmt_t &key)

- if (is_null(dict))

- return dict;

- if (eqv(caar(dict), key))

- return cdr(dict);

- return cons(car(dict), dict_delete(cdr(dict), key));

-pmt_t

-dict_ref(const pmt_t &dict, const pmt_t &key, const pmt_t &not_found)

- pmt_t p = assv(key, dict); // look for (key . value) pair

- if (is_pair(p))

- return cdr(p);

- else

- return not_found;

-bool

-dict_has_key(const pmt_t &dict, const pmt_t &key)

- return is_pair(assv(key, dict));

-pmt_t

-dict_items(pmt_t dict)

- if (!is_dict(dict))

- throw wrong_type("pmt_dict_values", dict);

- return dict; // equivalent to dict in the a-list case

-pmt_t

-dict_keys(pmt_t dict)

- if (!is_dict(dict))

- throw wrong_type("pmt_dict_keys", dict);

- return map(car, dict);

-pmt_t

-dict_values(pmt_t dict)

- if (!is_dict(dict))

- throw wrong_type("pmt_dict_keys", dict);

- return map(cdr, dict);

-pmt_any::pmt_any(const boost::any &any) : d_any(any) {}

-bool

-is_any(pmt_t obj)

-{

- return obj->is_any();

-}

-pmt_t

-make_any(const boost::any &any)

-{

- return pmt_t(new pmt_any(any));

-}

-boost::any

-any_ref(pmt_t obj)

- if (!obj->is_any())

- throw wrong_type("pmt_any_ref", obj);

- return _any(obj)->ref();

-void

-any_set(pmt_t obj, const boost::any &any)

- if (!obj->is_any())

- throw wrong_type("pmt_any_set", obj);

- _any(obj)->set(any);

-bool

-is_msg_accepter(const pmt_t &obj)

- if (!is_any(obj))

- return false;

- boost::any r = any_ref(obj);

- return boost::any_cast<gr::messages::msg_accepter_sptr>(&r) != 0;

-pmt_t

-make_msg_accepter(gr::messages::msg_accepter_sptr ma)

-{

- return make_any(ma);

-}

-gr::messages::msg_accepter_sptr

-msg_accepter_ref(const pmt_t &obj)

- try {

- return boost::any_cast<gr::messages::msg_accepter_sptr>(any_ref(obj));

- }

- catch (boost::bad_any_cast &e){

- throw wrong_type("pmt_msg_accepter_ref", obj);

- }

-bool

-is_blob(pmt_t x)

-{

- return is_u8vector(x);

-}

-pmt_t

-make_blob(const void *buf, size_t len_in_bytes)

- return init_u8vector(len_in_bytes, (const uint8_t *) buf);

-const void *

-blob_data(pmt_t blob)

- size_t len;

- return uniform_vector_elements(blob, len);

-size_t

-blob_length(pmt_t blob)

- size_t len;

- uniform_vector_elements(blob, len);

- return len;

-bool

-eq(const pmt_t& x, const pmt_t& y)

-{

- return x == y;

-}

-bool

-eqv(const pmt_t& x, const pmt_t& y)

- if (x == y)

- return true;

- if (x->is_integer() && y->is_integer())

- return _integer(x)->value() == _integer(y)->value();

- if (x->is_uint64() && y->is_uint64())

- return _uint64(x)->value() == _uint64(y)->value();

- if (x->is_real() && y->is_real())

- return _real(x)->value() == _real(y)->value();

- if (x->is_complex() && y->is_complex())

- return _complex(x)->value() == _complex(y)->value();

- return false;

-bool

-equal(const pmt_t& x, const pmt_t& y)

- if (eqv(x, y))

- return true;

- if (x->is_pair() && y->is_pair())

- return equal(car(x), car(y)) && equal(cdr(x), cdr(y));

- if (x->is_vector() && y->is_vector()){

- pmt_vector *xv = _vector(x);

- pmt_vector *yv = _vector(y);

- if (xv->length() != yv->length())

- return false;

- for (unsigned i = 0; i < xv->length(); i++)

- if (!equal(xv->_ref(i), yv->_ref(i)))

- return false;

- return true;

- }

- if (x->is_tuple() && y->is_tuple()){

- pmt_tuple *xv = _tuple(x);

- pmt_tuple *yv = _tuple(y);

- if (xv->length() != yv->length())

- return false;

- for (unsigned i = 0; i < xv->length(); i++)

- if (!equal(xv->_ref(i), yv->_ref(i)))

- return false;

- return true;

- }

- if (x->is_uniform_vector() && y->is_uniform_vector()){

- pmt_uniform_vector *xv = _uniform_vector(x);

- pmt_uniform_vector *yv = _uniform_vector(y);

- if (xv->length() != yv->length())

- return false;

- size_t len_x, len_y;

- const void *x_m = xv->uniform_elements(len_x);

- const void *y_m = yv->uniform_elements(len_y);

- if (memcmp(x_m, y_m, len_x) == 0)

- return true;

- return false;

- }

- // FIXME add other cases here...

- return false;

-size_t

-length(const pmt_t& x)

- if (x->is_vector())

- return _vector(x)->length();

- if (x->is_uniform_vector())

- return _uniform_vector(x)->length();

- if (x->is_tuple())

- return _tuple(x)->length();

- if (x->is_null())

- return 0;

- if (x->is_pair()) {

- size_t length=1;

- pmt_t it = cdr(x);

- while (is_pair(it)){

- length++;

- it = cdr(it);

- }

- if (is_null(it))

- return length;

- // not a proper list

- throw wrong_type("pmt_length", x);

- }

- // FIXME dictionary length (number of entries)

- throw wrong_type("pmt_length", x);

-pmt_t

-assq(pmt_t obj, pmt_t alist)

- while (is_pair(alist)){

- pmt_t p = car(alist);

- if (!is_pair(p)) // malformed alist

- return PMT_F;

- if (eq(obj, car(p)))

- return p;

- alist = cdr(alist);

- }

- return PMT_F;

-pmt_t

-assv(pmt_t obj, pmt_t alist)

- while (is_pair(alist)){

- pmt_t p = car(alist);

- if (!is_pair(p)) // malformed alist

- return PMT_F;

- if (eqv(obj, car(p)))

- return p;

- alist = cdr(alist);

- }

- return PMT_F;

-pmt_t

-assoc(pmt_t obj, pmt_t alist)

- while (is_pair(alist)){

- pmt_t p = car(alist);

- if (!is_pair(p)) // malformed alist

- return PMT_F;

- if (equal(obj, car(p)))

- return p;

- alist = cdr(alist);

- }

- return PMT_F;

-pmt_t

-map(pmt_t proc(const pmt_t&), pmt_t list)

- pmt_t r = PMT_NIL;

- while(is_pair(list)){

- r = cons(proc(car(list)), r);

- list = cdr(list);

- }

- return reverse_x(r);

-pmt_t

-reverse(pmt_t listx)

- pmt_t list = listx;

- pmt_t r = PMT_NIL;

- while(is_pair(list)){

- r = cons(car(list), r);

- list = cdr(list);

- }

- if (is_null(list))

- return r;

- else

- throw wrong_type("pmt_reverse", listx);

-pmt_t

-reverse_x(pmt_t list)

- // FIXME do it destructively

- return reverse(list);

-pmt_t

-nth(size_t n, pmt_t list)

- pmt_t t = nthcdr(n, list);

- if (is_pair(t))

- return car(t);

- else

- return PMT_NIL;

-pmt_t

-nthcdr(size_t n, pmt_t list)

- if (!(is_pair(list) || is_null(list)))

- throw wrong_type("pmt_nthcdr", list);

- while (n > 0){

- if (is_pair(list)){

- list = cdr(list);

- n--;

- continue;

- if (is_null(list))

- return PMT_NIL;

- else

- throw wrong_type("pmt_nthcdr: not a LIST", list);

- }

- return list;

-pmt_t

-memq(pmt_t obj, pmt_t list)

- while (is_pair(list)){

- if (eq(obj, car(list)))

- return list;

- list = cdr(list);

- }

- return PMT_F;

-pmt_t

-memv(pmt_t obj, pmt_t list)

- while (is_pair(list)){

- if (eqv(obj, car(list)))

- return list;

- list = cdr(list);

- }

- return PMT_F;

-pmt_t

-member(pmt_t obj, pmt_t list)

- while (is_pair(list)){

- if (equal(obj, car(list)))

- return list;

- list = cdr(list);

- }

- return PMT_F;

-bool

-subsetp(pmt_t list1, pmt_t list2)

- while (is_pair(list1)){

- pmt_t p = car(list1);

- if (is_false(memv(p, list2)))

- return false;

- list1 = cdr(list1);

- }

- return true;

-pmt_t

-list1(const pmt_t& x1)

-{

- return cons(x1, PMT_NIL);

-}

-pmt_t

-list2(const pmt_t& x1, const pmt_t& x2)

-{

- return cons(x1, cons(x2, PMT_NIL));

-}

-pmt_t

-list3(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3)

- return cons(x1, cons(x2, cons(x3, PMT_NIL)));

-pmt_t

-list4(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4)

- return cons(x1, cons(x2, cons(x3, cons(x4, PMT_NIL))));

-pmt_t

-list5(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5)

- return cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, PMT_NIL)))));

-pmt_t

-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 cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, cons(x6, PMT_NIL))))));

-pmt_t

-list_add(pmt_t list, const pmt_t& item)

- return reverse(cons(item, reverse(list)));

-pmt_t

-list_rm(pmt_t list, const pmt_t& 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));

- return list_rm(right, item);

- return list;

-bool

-list_has(pmt_t list, const pmt_t& item)

- if(is_pair(list)){

- pmt_t left = car(list);

- pmt_t right = cdr(list);

- if(equal(left,item))

- return true;

- return list_has(right, item);

- } else {

- if(is_null(list))

- return false;

- throw std::runtime_error("list contains invalid format!");

- }

-pmt_t

-caar(pmt_t pair)

-{

- return (car(car(pair)));

-}

-pmt_t

-cadr(pmt_t pair)

-{

- return car(cdr(pair));

-}

-pmt_t

-cdar(pmt_t pair)

-{

- return cdr(car(pair));

-}

-pmt_t

-cddr(pmt_t pair)

-{

- return cdr(cdr(pair));

-}

-pmt_t

-caddr(pmt_t pair)

-{

- return car(cdr(cdr(pair)));

-}

-pmt_t

-cadddr(pmt_t pair)

-{

- return car(cdr(cdr(cdr(pair))));

-}

-bool

-is_eof_object(pmt_t obj)

-{

- return eq(obj, PMT_EOF);

-}

-void

-dump_sizeof()

- printf("sizeof(pmt_t) = %3zd\n", sizeof(pmt_t));

- printf("sizeof(pmt_base) = %3zd\n", sizeof(pmt_base));

- printf("sizeof(pmt_bool) = %3zd\n", sizeof(pmt_bool));

- printf("sizeof(pmt_symbol) = %3zd\n", sizeof(pmt_symbol));

- printf("sizeof(pmt_integer) = %3zd\n", sizeof(pmt_integer));

- printf("sizeof(pmt_uint64) = %3zd\n", sizeof(pmt_uint64));

- printf("sizeof(pmt_real) = %3zd\n", sizeof(pmt_real));

- printf("sizeof(pmt_complex) = %3zd\n", sizeof(pmt_complex));

- printf("sizeof(pmt_null) = %3zd\n", sizeof(pmt_null));

- printf("sizeof(pmt_pair) = %3zd\n", sizeof(pmt_pair));

- printf("sizeof(pmt_vector) = %3zd\n", sizeof(pmt_vector));

- printf("sizeof(pmt_uniform_vector) = %3zd\n", sizeof(pmt_uniform_vector));

- pmt_bool();

- //~pmt_bool(){}

- bool is_bool() const { return true; }

- std::string d_name;

- pmt_t d_next;

- pmt_symbol(const std::string &name);

- //~pmt_symbol(){}

- bool is_symbol() const { return true; }

- const std::string name() { return d_name; }

- pmt_t next() { return d_next; } // symbol table link

- void set_next(pmt_t next) { d_next = next; }

- long d_value;

- pmt_integer(long value);

- //~pmt_integer(){}

- bool is_number() const { return true; }

- bool is_integer() const { return true; }

- long value() const { return d_value; }

- uint64_t d_value;

- pmt_uint64(uint64_t value);

- //~pmt_uint64(){}

- bool is_number() const { return true; }

- bool is_uint64() const { return true; }

- uint64_t value() const { return d_value; }

- double d_value;

- pmt_real(double value);

- //~pmt_real(){}

- bool is_number() const { return true; }

- bool is_real() const { return true; }

- double value() const { return d_value; }

- std::complex<double> d_value;

- pmt_complex(std::complex<double> value);

- //~pmt_complex(){}

- bool is_number() const { return true; }

- bool is_complex() const { return true; }

- std::complex<double> value() const { return d_value; }

-class pmt_null : public pmt_base

- pmt_null();

- //~pmt_null(){}

- bool is_null() const { return true; }

- pmt_t d_car;

- pmt_t d_cdr;

- pmt_pair(const pmt_t& car, const pmt_t& cdr);

- //~pmt_pair(){};

- bool is_pair() const { return true; }

- pmt_t car() const { return d_car; }

- pmt_t cdr() const { return d_cdr; }

- void set_car(pmt_t car) { d_car = car; }

- void set_cdr(pmt_t cdr) { d_cdr = cdr; }

- std::vector<pmt_t> d_v;

- pmt_vector(size_t len, pmt_t fill);

- //~pmt_vector();

- bool is_vector() const { return true; }

- pmt_t ref(size_t k) const;

- void set(size_t k, pmt_t obj);

- void fill(pmt_t fill);

- size_t length() const { return d_v.size(); }

- pmt_t _ref(size_t k) const { return d_v[k]; }

- std::vector<pmt_t> d_v;

- pmt_tuple(size_t len);

- //~pmt_tuple();

- bool is_tuple() const { return true; }

- pmt_t ref(size_t k) const;

- size_t length() const { return d_v.size(); }

- pmt_t _ref(size_t k) const { return d_v[k]; }

- void _set(size_t k, pmt_t v) { d_v[k] = v; }

- boost::any d_any;

- pmt_any(const boost::any &any);

- //~pmt_any();

- bool is_any() const { return true; }

- const boost::any &ref() const { return d_any; }

- void set(const boost::any &any) { d_any = any; }

- bool is_uniform_vector() const { return true; }

- virtual const void *uniform_elements(size_t &len) = 0;

- virtual void *uniform_writable_elements(size_t &len) = 0;

- virtual size_t length() const = 0;

- virtual size_t itemsize() const = 0;

- virtual const std::string string_ref(size_t k) const { return std::string("not implemented"); }

-static void

-write_list_tail(pmt_t obj, std::ostream &port)

- write(car(obj), port); // write the car

- obj = cdr(obj); // step to cdr

-

- if (is_null(obj)) // ()

- port << ")";

-

- else if (is_pair(obj)){ // normal list

- port << " ";

- write_list_tail(obj, port);

- }

- else { // dotted pair

- port << " . ";

- write(obj, port);

- port << ")";

- }

-void

-write(pmt_t obj, std::ostream &port)

- if (is_bool(obj)){

- if (is_true(obj))

- port << "#t";

- else

- port << "#f";

- }

- else if (is_symbol(obj)){

- port << symbol_to_string(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 (is_null(obj)){

- port << "()";

- }

- else if (is_pair(obj)){

- port << "(";

- write_list_tail(obj, port);

- }

- else if (is_tuple(obj)){

- port << "{";

- size_t len = length(obj);

- if (len > 0){

- port << tuple_ref(obj, 0);

- for (size_t i = 1; i < len; i++)

- port << " " << tuple_ref(obj, i);

- }

- port << "}";

- }

- else if (is_vector(obj)){

- port << "#(";

- size_t len = length(obj);

- if (len > 0){

- port << vector_ref(obj, 0);

- for (size_t i = 1; i < len; i++)

- port << " " << vector_ref(obj, i);

- port << ")";

- }

- else if (is_dict(obj)){

- // FIXME

- // port << "#<dict " << obj << ">";

- port << "#<dict>";

- }

- else if (is_uniform_vector(obj)){

- port << "#[";

- size_t len = length(obj);

- if (len)

- {

- pmt_uniform_vector *uv = static_cast<pmt_uniform_vector*>(obj.get());

- port << uv->string_ref(0);

- for (size_t i = 1; i < len; i++)

- port << " " << uv->string_ref(i);

- }

- port << "]";

- }

- else {

- error:

- // FIXME

- // port << "#<" << obj << ">";

- port << "#<unknown>";

- }

-std::ostream& operator<<(std::ostream &os, pmt_t obj)

- write(obj, os);

- return os;

-std::string

-write_string(pmt_t obj)

- std::ostringstream s;

- s << obj;

- return s.str();

-pmt_t

-read(std::istream &port)

- throw notimplemented("notimplemented: pmt::read", PMT_NIL);

-void

-serialize(pmt_t obj, std::ostream &sink)

- throw notimplemented("notimplemented: pmt::serialize", obj);

-pmt_t

-deserialize(std::istream &source)

- throw notimplemented("notimplemented: pmt::deserialize", PMT_NIL);

-void

-pmt::print(pmt_t v)

-{

- std::cout << write_string(v) << std::endl;

-}

-

-

-static inline size_t

-ROUNDUP(size_t x, size_t stride)

- return ((((x) + (stride) - 1)/(stride)) * (stride));

-pmt_pool::pmt_pool(size_t itemsize, size_t alignment,

- size_t allocation_size, size_t max_items)

- : d_itemsize(ROUNDUP(itemsize, alignment)),

- d_alignment(alignment),

- d_allocation_size(std::max(allocation_size, 16 * itemsize)),

- d_max_items(max_items), d_n_items(0),

- d_freelist(0)

- for (unsigned int i = 0; i < d_allocations.size(); i++){

- delete [] d_allocations[i];

- }

-void *

-pmt_pool::malloc()

- scoped_lock guard(d_mutex);

- item *p;

-

- if (d_max_items != 0){

- while (d_n_items >= d_max_items)

- d_cond.wait(guard);

- }

-

- if (d_freelist){ // got something?

- }

-

- // allocate a new chunk

- char *alloc = new char[d_allocation_size + d_alignment - 1];

- d_allocations.push_back(alloc);

-

- // get the alignment we require

- char *start = (char *)(((uintptr_t)alloc + d_alignment-1) & -d_alignment);

- char *end = alloc + d_allocation_size + d_alignment - 1;

- size_t n = (end - start) / d_itemsize;

-

- // link the new items onto the free list.

- p = (item *) start;

- for (size_t i = 0; i < n; i++){

- p->d_next = d_freelist;

- d_freelist = p;

- p = (item *)((char *) p + d_itemsize);

- }

-

- // now return the first one

- p = d_freelist;

- d_freelist = p->d_next;

- d_n_items++;

- return p;

-void

-pmt_pool::free(void *foo)

- if (!foo)

- return;

- scoped_lock guard(d_mutex);

- item *p = (item *) foo;

- p->d_next = d_freelist;

- d_freelist = p;

- d_n_items--;

- if (d_max_items != 0)

- d_cond.notify_one();

-static pmt_t parse_pair(std::streambuf &sb);

-static bool

-serialize_untagged_u8(unsigned int i, std::streambuf &sb)

- return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof();

-static bool

-serialize_untagged_u16(unsigned int i, std::streambuf &sb)

- sb.sputc((i >> 8) & 0xff);

- return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof();

-static bool

-serialize_untagged_u32(unsigned int i, std::streambuf &sb)

- sb.sputc((i >> 24) & 0xff);

- sb.sputc((i >> 16) & 0xff);

- sb.sputc((i >> 8) & 0xff);

- return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof();

-static bool

-serialize_untagged_f64(double i, std::streambuf &sb)

- typedef union {

- double id;

- uint64_t ii;

- } iu_t;

- iu_t iu;

- iu.id = i;

- sb.sputc((iu.ii >> 56) & 0xff);

- sb.sputc((iu.ii >> 48) & 0xff);

- sb.sputc((iu.ii >> 40) & 0xff);

- sb.sputc((iu.ii >> 32) & 0xff);

- sb.sputc((iu.ii >> 24) & 0xff);

- sb.sputc((iu.ii >> 16) & 0xff);

- sb.sputc((iu.ii >> 8) & 0xff);

- return sb.sputc((iu.ii >> 0) & 0xff) != std::streambuf::traits_type::eof();

-static bool

-serialize_untagged_u64(uint64_t i, std::streambuf &sb)

- sb.sputc((i >> 56) & 0xff);

- sb.sputc((i >> 48) & 0xff);

- sb.sputc((i >> 40) & 0xff);

- sb.sputc((i >> 32) & 0xff);

- sb.sputc((i >> 24) & 0xff);

- sb.sputc((i >> 16) & 0xff);

- sb.sputc((i >> 8) & 0xff);

- return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof();

-static bool

-deserialize_untagged_u8(uint8_t *ip, std::streambuf &sb)

- std::streambuf::traits_type::int_type t;

- int i;

- t = sb.sbumpc();

- i = t & 0xff;

- *ip = i;

- return t != std::streambuf::traits_type::eof();

-static bool

-deserialize_untagged_u16(uint16_t *ip, std::streambuf &sb)

- std::streambuf::traits_type::int_type t;

- int i;

- t = sb.sbumpc();

- i = t & 0xff;

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

- *ip = i;

- return t != std::streambuf::traits_type::eof();

-static bool

-deserialize_untagged_u32(uint32_t *ip, std::streambuf &sb)

- std::streambuf::traits_type::int_type t;

- int i;

- t = sb.sbumpc();

- i = t & 0xff;

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

- *ip = i;

- return t != std::streambuf::traits_type::eof();

-static bool

-deserialize_untagged_u64(uint64_t *ip, std::streambuf &sb)

- std::streambuf::traits_type::int_type t;

- uint64_t i;

-

- t = sb.sbumpc();

- i = t & 0xff;

-

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

- t = sb.sbumpc();

- i = (i << 8) | (t & 0xff);

-

- *ip = i;

- return t != std::streambuf::traits_type::eof();

-static bool

-deserialize_untagged_f64(double *ip, std::streambuf &sb)

- std::streambuf::traits_type::int_type t;

-

- typedef union {

- double id;

- uint64_t ii;

- } iu_t;

-

- iu_t iu;

-

- t = sb.sbumpc();

- iu.ii = t & 0xff;

-

- t = sb.sbumpc();

- iu.ii = (iu.ii<<8) | (t & 0xff);

- t = sb.sbumpc();

- iu.ii = (iu.ii<<8) | (t & 0xff);

- t = sb.sbumpc();

- iu.ii = (iu.ii<<8) | (t & 0xff);

- t = sb.sbumpc();

- iu.ii = (iu.ii<<8) | (t & 0xff);

- t = sb.sbumpc();

- iu.ii = (iu.ii<<8) | (t & 0xff);

- t = sb.sbumpc();

- iu.ii = (iu.ii<<8) | (t & 0xff);

- t = sb.sbumpc();

- iu.ii = (iu.ii<<8) | (t & 0xff);

-

- *ip = iu.id;

- return t != std::streambuf::traits_type::eof();

-static bool

-deserialize_tuple(pmt_t *tuple, std::streambuf &sb)

- 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);

- }

-bool

-serialize(pmt_t obj, std::streambuf &sb)

- bool ok = true;

-

- tail_recursion:

-

- 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(is_null(obj))

- return serialize_untagged_u8(PST_NULL, sb);

-

- 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++)

- ok &= serialize_untagged_u8(s[i], sb);

- return ok;

- }

-

- if(is_pair(obj)) {

- ok = serialize_untagged_u8(PST_PAIR, sb);

- ok &= serialize(car(obj), sb);

- if(!ok)

- return false;

- obj = cdr(obj);

- goto tail_recursion;

- }

-

- if(is_number(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(is_integer(obj)) {

- long i = to_long(obj);

- if((sizeof(long) > 4) && ((i < std::numeric_limits<std::int32_t>::min() || i > std::numeric_limits<std::int32_t>::max()))) {

- // Serializing as 4 bytes won't work for this value, serialize as 8 bytes

- ok = serialize_untagged_u8(PST_INT64, sb);

- ok &= serialize_untagged_u64(i, sb);

- } else {

- ok = serialize_untagged_u8(PST_INT32, sb);

- ok &= serialize_untagged_u32(i, sb);

- }

- }

- if(is_real(obj)) {

- double i = to_double(obj);

- ok = serialize_untagged_u8(PST_DOUBLE, sb);

- ok &= serialize_untagged_f64(i, sb);

- return ok;

- 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(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 &= serialize(vector_ref(obj, i), sb);

- }

- return ok;

- }

-

- if(is_uniform_vector(obj)) {

- size_t npad = 1;

- size_t vec_len = pmt::length(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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- ok &= serialize_untagged_u8(u8vector_ref(obj, i), sb);

- }

- return ok;

- }

- 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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- ok &= serialize_untagged_u8(s8vector_ref(obj, i), sb);

- }

- return ok;

- }

- 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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- ok &= serialize_untagged_u16(u16vector_ref(obj, i), sb);

- }

- return ok;

- }

- 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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- ok &= serialize_untagged_u16(s16vector_ref(obj, i), sb);

- }

- return ok;

- 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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- ok &= serialize_untagged_u32(u32vector_ref(obj, i), sb);

- }

- return ok;

- 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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- ok &= serialize_untagged_u32(s32vector_ref(obj, i), sb);

- }

- return ok;

- }

- 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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- ok &= serialize_untagged_u64(u64vector_ref(obj, i), sb);

- }

- return ok;

- }

- 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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- ok &= serialize_untagged_u64(s64vector_ref(obj, i), sb);

- }

- return ok;

- }

- 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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- ok &= serialize_untagged_f64(f32vector_ref(obj, i), sb);

- }

- return ok;

- }

- 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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- ok &= serialize_untagged_f64(f64vector_ref(obj, i), sb);

- }

- return ok;

- }

- 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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; 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(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);

- ok &= serialize_untagged_u8(npad, sb);

- for(size_t i=0; i<npad; i++) {

- ok &= serialize_untagged_u8(0, sb);

- }

- for(size_t i=0; i<vec_len; i++) {

- std::complex<double> c = c64vector_ref(obj, i);

- ok &= serialize_untagged_f64(c.real(), sb);

- ok &= serialize_untagged_f64(c.imag(), sb);

- }

- return ok;

- }

- if (is_dict(obj))

- throw notimplemented("pmt::serialize (dict)", 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 &= serialize(tuple_ref(obj, i), sb);

- return ok;

- }

- //throw pmt_notimplemented("pmt::serialize (tuple)", obj);

- throw notimplemented("pmt::serialize (?)", obj);

-pmt_t

-deserialize(std::streambuf &sb)

- uint8_t tag;

- uint8_t u8;

- uint16_t u16;

- uint32_t u32;

- uint64_t u64;

- double f64;

- char tmpbuf[1024];

-

- if (!deserialize_untagged_u8(&tag, sb))

- return PMT_EOF;

-

- switch (tag){

- case PST_TRUE:

- return PMT_T;

-

- case PST_FALSE:

- return PMT_F;

-

- case PST_NULL:

- return PMT_NIL;

-

- case PST_SYMBOL:

- if (!deserialize_untagged_u16(&u16, sb))

- goto error;

- if (u16 > sizeof(tmpbuf))

- throw notimplemented("pmt::deserialize: very long symbol",

- PMT_F);

- if (sb.sgetn(tmpbuf, u16) != u16)

- goto error;

- return intern(std::string(tmpbuf, u16));

-

- case PST_INT32:

- if (!deserialize_untagged_u32(&u32, sb))

- goto error;

- return from_long((int32_t) u32);

-

- case PST_UINT64:

- if(!deserialize_untagged_u64(&u64, sb))

- goto error;

- return from_uint64(u64);

-

- case PST_INT64:

- if(!deserialize_untagged_u64(&u64, sb))

- goto error;

- return from_long(u64);

-

- case PST_PAIR:

- return parse_pair(sb);

-

- case PST_DOUBLE:

- if(!deserialize_untagged_f64(&f64, sb))

- goto error;

- return from_double( f64 );

-

- case PST_COMPLEX:

- {

- double r,i;

- if(!deserialize_untagged_f64(&r, sb) || !deserialize_untagged_f64(&i, sb))

- goto error;

- return make_rectangular( r,i );

- case PST_TUPLE:

- {

- pmt_t tuple;

- if(!deserialize_tuple(&tuple, sb)){

- goto error;

- }

- return tuple;

- case PST_VECTOR:

- {

- uint32_t nitems;

- if(!deserialize_untagged_u32(&nitems, sb))

- goto error;

- pmt_t vec = make_vector(nitems, PMT_NIL);

- for(uint32_t i=0; i<nitems; i++) {

- pmt_t item = deserialize(sb);

- vector_set(vec, i, item);

- }

- return vec;

- case PST_UNIFORM_VECTOR:

- {

- uint8_t utag, npad;

- uint32_t nitems;

-

- if(!deserialize_untagged_u8(&utag, sb))

- return PMT_EOF;

-

- if(!deserialize_untagged_u32(&nitems, sb))

- goto error;

-

- deserialize_untagged_u8(&npad, sb);

- for(size_t i = 0; i < npad; i++)

- deserialize_untagged_u8(&u8, sb);

-

- switch(utag) {

- case(UVI_U8):

- {

- pmt_t vec = make_u8vector(nitems, 0);

- for(uint32_t i=0; i<nitems; i++) {

- deserialize_untagged_u8(&u8, sb);

- u8vector_set(vec, i, u8);

- }

- return vec;

- }

- case(UVI_S8):

- {

- pmt_t vec = make_s8vector(nitems, 0);

- for(uint32_t i=0; i<nitems; i++) {

- deserialize_untagged_u8(&u8, sb);

- s8vector_set(vec, i, u8);

- }

- return vec;

- }

- case(UVI_U16):

- {

- pmt_t vec = make_u16vector(nitems, 0);

- for(uint32_t i=0; i<nitems; i++) {

- deserialize_untagged_u16(&u16, sb);

- u16vector_set(vec, i, u16);

- }

- return vec;

- }

- case(UVI_S16):

- {

- pmt_t vec = make_s16vector(nitems, 0);

- for(uint32_t i=0; i<nitems; i++) {

- deserialize_untagged_u16(&u16, sb);

- s16vector_set(vec, i, u16);

- }

- return vec;

- }

- case(UVI_U32):

- {

- pmt_t vec = make_u32vector(nitems, 0);

- for(uint32_t i=0; i<nitems; i++) {

- deserialize_untagged_u32(&u32, sb);

- u32vector_set(vec, i, u32);

- }

- return vec;

- }

- case(UVI_S32):

- {

- pmt_t vec = make_s32vector(nitems, 0);

- for(uint32_t i=0; i<nitems; i++) {

- deserialize_untagged_u32(&u32, sb);

- s32vector_set(vec, i, u32);

- }

- return vec;

- }

- case(UVI_U64):

- {

- pmt_t vec = make_u64vector(nitems, 0);

- for(uint32_t i=0; i<nitems; i++) {

- deserialize_untagged_u64(&u64, sb);

- u64vector_set(vec, i, u64);

- }

- return vec;

- }

- case(UVI_S64):

- {

- pmt_t vec = make_s64vector(nitems, 0);

- for(uint32_t i=0; i<nitems; i++) {

- deserialize_untagged_u64(&u64, sb);

- s64vector_set(vec, i, u64);

- }

- return vec;

- }

- case(UVI_F32):

- {

- pmt_t vec = make_f32vector(nitems, 0);

- for(uint32_t i=0; i<nitems; i++) {

- deserialize_untagged_f64(&f64, sb);

- f32vector_set(vec, i, static_cast<float>(f64));

- }

- return vec;

- }

- case(UVI_F64):

- {

- pmt_t vec = make_f64vector(nitems, 0);

- for(uint32_t i=0; i<nitems; i++) {

- deserialize_untagged_f64(&f64, sb);

- f64vector_set(vec, i, f64);

- }

- return vec;

- }

- case(UVI_C32):

- {

- 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);

- c32vector_set(vec, i, std::complex<float>(re, im));

- }

- return vec;

- }

-

- case(UVI_C64):

- {

- 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;

- c64vector_set(vec, i, std::complex<double>(re, im));

- }

- return vec;

- }

-

- default:

- throw exception("pmt::deserialize: malformed input stream, tag value = ",

- from_long(tag));

- }

- case PST_DICT:

- case PST_COMMENT:

- throw notimplemented("pmt::deserialize: tag value = ",

- from_long(tag));

- default:

- throw exception("pmt::deserialize: malformed input stream, tag value = ",

- from_long(tag));

- }

- error:

- throw exception("pmt::deserialize: malformed input stream", PMT_F);

-std::string

-serialize_str(pmt_t obj){

- std::stringbuf sb;

- serialize(obj, sb);

- return sb.str();

-pmt_t

-deserialize_str(std::string s){

- std::stringbuf sb(s);

- return deserialize(sb);

-pmt_t

-parse_pair(std::streambuf &sb)

- uint8_t tag;

- pmt_t val, expr, lastnptr, nptr;

-

- //

- // Keep appending nodes until we get a non-PAIR cdr.

- //

- lastnptr = PMT_NIL;

- while (1){

- expr = deserialize(sb); // read the car

-

- nptr = cons(expr, PMT_NIL); // build new cell

- if (is_null(lastnptr))

- val = nptr;

- else

- set_cdr(lastnptr, nptr);

- lastnptr = nptr;

-

- if (!deserialize_untagged_u8(&tag, sb)) // get tag of cdr

- throw exception("pmt::deserialize: malformed input stream", PMT_F);

-

- if (tag == PST_PAIR)

- continue; // keep on looping...

-

- if (tag == PST_NULL){

- expr = PMT_NIL;

- break;

- // default: push tag back and use pmt_deserialize to get the cdr

- sb.sungetc();

- expr = deserialize(sb);

- break;

- }

-

- //

- // At this point, expr contains the value of the final cdr in the list.

- //

- set_cdr(lastnptr, expr);

- return val;

-static pmt_u8vector *

-_u8vector(pmt_t x)

-{

- return dynamic_cast<pmt_u8vector*>(x.get());

-}

-pmt_u8vector::pmt_u8vector(size_t k, uint8_t fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_u8vector::pmt_u8vector(size_t k, const uint8_t *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(uint8_t) );

-uint8_t

-pmt_u8vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_u8vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_u8vector::set(size_t k, uint8_t x)

- if (k >= length())

- throw out_of_range("pmt_u8vector_set", from_long(k));

- d_v[k] = x;

-const uint8_t *

-pmt_u8vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-uint8_t *

-pmt_u8vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_u8vector::uniform_elements(size_t &len)

- len = length() * sizeof(uint8_t);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_u8vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(uint8_t);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_u8vector(pmt_t obj)

-{

- return obj->is_u8vector();

-}

-pmt_t

-make_u8vector(size_t k, uint8_t fill)

-{

- return pmt_t(new pmt_u8vector(k, fill));

-}

-pmt_t

-init_u8vector(size_t k, const uint8_t *data)

- return pmt_t(new pmt_u8vector(k, data));

-pmt_t

-init_u8vector(size_t k, const std::vector< uint8_t > &data)

- if(k) {

- return pmt_t(new pmt_u8vector(k, &data[0]));

- }

- return pmt_t(new pmt_u8vector(k, static_cast< uint8_t >(0))); // fills an empty vector with 0

-uint8_t

-u8vector_ref(pmt_t vector, size_t k)

- if (!vector->is_u8vector())

- throw wrong_type("pmt_u8vector_ref", vector);

- return _u8vector(vector)->ref(k);

-void

-u8vector_set(pmt_t vector, size_t k, uint8_t obj)

- if (!vector->is_u8vector())

- throw wrong_type("pmt_u8vector_set", vector);

- _u8vector(vector)->set(k, obj);

-const uint8_t *

-u8vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_u8vector())

- throw wrong_type("pmt_u8vector_elements", vector);

- return _u8vector(vector)->elements(len);

-const std::vector< uint8_t >

-u8vector_elements(pmt_t vector)

- if (!vector->is_u8vector())

- throw wrong_type("pmt_u8vector_elements", vector);

- size_t len;

- const uint8_t *array = _u8vector(vector)->elements(len);

- const std::vector< uint8_t > vec(array, array+len);

- return vec;

-uint8_t *

-u8vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_u8vector())

- throw wrong_type("pmt_u8vector_writable_elements", vector);

- return _u8vector(vector)->writable_elements(len);

-const std::string

-pmt_u8vector::string_ref(size_t k) const

- return boost::lexical_cast< std::string, uint8_t > (ref(k));

-static pmt_s8vector *

-_s8vector(pmt_t x)

-{

- return dynamic_cast<pmt_s8vector*>(x.get());

-}

-pmt_s8vector::pmt_s8vector(size_t k, int8_t fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_s8vector::pmt_s8vector(size_t k, const int8_t *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(int8_t) );

-int8_t

-pmt_s8vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_s8vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_s8vector::set(size_t k, int8_t x)

- if (k >= length())

- throw out_of_range("pmt_s8vector_set", from_long(k));

- d_v[k] = x;

-const int8_t *

-pmt_s8vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-int8_t *

-pmt_s8vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_s8vector::uniform_elements(size_t &len)

- len = length() * sizeof(int8_t);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_s8vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(int8_t);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_s8vector(pmt_t obj)

-{

- return obj->is_s8vector();

-}

-pmt_t

-make_s8vector(size_t k, int8_t fill)

-{

- return pmt_t(new pmt_s8vector(k, fill));

-}

-pmt_t

-init_s8vector(size_t k, const int8_t *data)

- return pmt_t(new pmt_s8vector(k, data));

-pmt_t

-init_s8vector(size_t k, const std::vector< int8_t > &data)

- if(k) {

- return pmt_t(new pmt_s8vector(k, &data[0]));

- }

- return pmt_t(new pmt_s8vector(k, static_cast< int8_t >(0))); // fills an empty vector with 0

-int8_t

-s8vector_ref(pmt_t vector, size_t k)

- if (!vector->is_s8vector())

- throw wrong_type("pmt_s8vector_ref", vector);

- return _s8vector(vector)->ref(k);

-void

-s8vector_set(pmt_t vector, size_t k, int8_t obj)

- if (!vector->is_s8vector())

- throw wrong_type("pmt_s8vector_set", vector);

- _s8vector(vector)->set(k, obj);

-const int8_t *

-s8vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_s8vector())

- throw wrong_type("pmt_s8vector_elements", vector);

- return _s8vector(vector)->elements(len);

-const std::vector< int8_t >

-s8vector_elements(pmt_t vector)

- if (!vector->is_s8vector())

- throw wrong_type("pmt_s8vector_elements", vector);

- size_t len;

- const int8_t *array = _s8vector(vector)->elements(len);

- const std::vector< int8_t > vec(array, array+len);

- return vec;

-int8_t *

-s8vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_s8vector())

- throw wrong_type("pmt_s8vector_writable_elements", vector);

- return _s8vector(vector)->writable_elements(len);

-const std::string

-pmt_s8vector::string_ref(size_t k) const

- return boost::lexical_cast< std::string, int8_t > (ref(k));

-static pmt_u16vector *

-_u16vector(pmt_t x)

- return dynamic_cast<pmt_u16vector*>(x.get());

-pmt_u16vector::pmt_u16vector(size_t k, uint16_t fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_u16vector::pmt_u16vector(size_t k, const uint16_t *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(uint16_t) );

-uint16_t

-pmt_u16vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_u16vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_u16vector::set(size_t k, uint16_t x)

- if (k >= length())

- throw out_of_range("pmt_u16vector_set", from_long(k));

- d_v[k] = x;

-const uint16_t *

-pmt_u16vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-uint16_t *

-pmt_u16vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_u16vector::uniform_elements(size_t &len)

- len = length() * sizeof(uint16_t);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_u16vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(uint16_t);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_u16vector(pmt_t obj)

-{

- return obj->is_u16vector();

-}

-pmt_t

-make_u16vector(size_t k, uint16_t fill)

- return pmt_t(new pmt_u16vector(k, fill));

-pmt_t

-init_u16vector(size_t k, const uint16_t *data)

- return pmt_t(new pmt_u16vector(k, data));

-pmt_t

-init_u16vector(size_t k, const std::vector< uint16_t > &data)

- if(k) {

- return pmt_t(new pmt_u16vector(k, &data[0]));

- }

- return pmt_t(new pmt_u16vector(k, static_cast< uint16_t >(0))); // fills an empty vector with 0

-uint16_t

-u16vector_ref(pmt_t vector, size_t k)

- if (!vector->is_u16vector())

- throw wrong_type("pmt_u16vector_ref", vector);

- return _u16vector(vector)->ref(k);

-void

-u16vector_set(pmt_t vector, size_t k, uint16_t obj)

- if (!vector->is_u16vector())

- throw wrong_type("pmt_u16vector_set", vector);

- _u16vector(vector)->set(k, obj);

-const uint16_t *

-u16vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_u16vector())

- throw wrong_type("pmt_u16vector_elements", vector);

- return _u16vector(vector)->elements(len);

-const std::vector< uint16_t >

-u16vector_elements(pmt_t vector)

- if (!vector->is_u16vector())

- throw wrong_type("pmt_u16vector_elements", vector);

- size_t len;

- const uint16_t *array = _u16vector(vector)->elements(len);

- const std::vector< uint16_t > vec(array, array+len);

- return vec;

-uint16_t *

-u16vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_u16vector())

- throw wrong_type("pmt_u16vector_writable_elements", vector);

- return _u16vector(vector)->writable_elements(len);

-const std::string

-pmt_u16vector::string_ref(size_t k) const

- return std::to_string(ref(k));

-static pmt_s16vector *

-_s16vector(pmt_t x)

- return dynamic_cast<pmt_s16vector*>(x.get());

-pmt_s16vector::pmt_s16vector(size_t k, int16_t fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_s16vector::pmt_s16vector(size_t k, const int16_t *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(int16_t) );

-int16_t

-pmt_s16vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_s16vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_s16vector::set(size_t k, int16_t x)

- if (k >= length())

- throw out_of_range("pmt_s16vector_set", from_long(k));

- d_v[k] = x;

-const int16_t *

-pmt_s16vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-int16_t *

-pmt_s16vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_s16vector::uniform_elements(size_t &len)

- len = length() * sizeof(int16_t);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_s16vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(int16_t);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_s16vector(pmt_t obj)

-{

- return obj->is_s16vector();

-}

-pmt_t

-make_s16vector(size_t k, int16_t fill)

-{

- return pmt_t(new pmt_s16vector(k, fill));

-}

-pmt_t

-init_s16vector(size_t k, const int16_t *data)

- return pmt_t(new pmt_s16vector(k, data));

-pmt_t

-init_s16vector(size_t k, const std::vector< int16_t > &data)

- if(k) {

- return pmt_t(new pmt_s16vector(k, &data[0]));

- }

- return pmt_t(new pmt_s16vector(k, static_cast< int16_t >(0))); // fills an empty vector with 0

-int16_t

-s16vector_ref(pmt_t vector, size_t k)

- if (!vector->is_s16vector())

- throw wrong_type("pmt_s16vector_ref", vector);

- return _s16vector(vector)->ref(k);

-void

-s16vector_set(pmt_t vector, size_t k, int16_t obj)

- if (!vector->is_s16vector())

- throw wrong_type("pmt_s16vector_set", vector);

- _s16vector(vector)->set(k, obj);

-const int16_t *

-s16vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_s16vector())

- throw wrong_type("pmt_s16vector_elements", vector);

- return _s16vector(vector)->elements(len);

-const std::vector< int16_t >

-s16vector_elements(pmt_t vector)

- if (!vector->is_s16vector())

- throw wrong_type("pmt_s16vector_elements", vector);

- size_t len;

- const int16_t *array = _s16vector(vector)->elements(len);

- const std::vector< int16_t > vec(array, array+len);

- return vec;

-int16_t *

-s16vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_s16vector())

- throw wrong_type("pmt_s16vector_writable_elements", vector);

- return _s16vector(vector)->writable_elements(len);

-const std::string

-pmt_s16vector::string_ref(size_t k) const

- return std::to_string(ref(k));

-static pmt_u32vector *

-_u32vector(pmt_t x)

- return dynamic_cast<pmt_u32vector*>(x.get());

-pmt_u32vector::pmt_u32vector(size_t k, uint32_t fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_u32vector::pmt_u32vector(size_t k, const uint32_t *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(uint32_t) );

-uint32_t

-pmt_u32vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_u32vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_u32vector::set(size_t k, uint32_t x)

- if (k >= length())

- throw out_of_range("pmt_u32vector_set", from_long(k));

- d_v[k] = x;

-const uint32_t *

-pmt_u32vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-uint32_t *

-pmt_u32vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_u32vector::uniform_elements(size_t &len)

- len = length() * sizeof(uint32_t);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_u32vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(uint32_t);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_u32vector(pmt_t obj)

-{

- return obj->is_u32vector();

-}

-pmt_t

-make_u32vector(size_t k, uint32_t fill)

- return pmt_t(new pmt_u32vector(k, fill));

-pmt_t

-init_u32vector(size_t k, const uint32_t *data)

- return pmt_t(new pmt_u32vector(k, data));

-pmt_t

-init_u32vector(size_t k, const std::vector< uint32_t > &data)

- if(k) {

- return pmt_t(new pmt_u32vector(k, &data[0]));

- }

- return pmt_t(new pmt_u32vector(k, static_cast< uint32_t >(0))); // fills an empty vector with 0

-uint32_t

-u32vector_ref(pmt_t vector, size_t k)

- if (!vector->is_u32vector())

- throw wrong_type("pmt_u32vector_ref", vector);

- return _u32vector(vector)->ref(k);

-void

-u32vector_set(pmt_t vector, size_t k, uint32_t obj)

- if (!vector->is_u32vector())

- throw wrong_type("pmt_u32vector_set", vector);

- _u32vector(vector)->set(k, obj);

-const uint32_t *

-u32vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_u32vector())

- throw wrong_type("pmt_u32vector_elements", vector);

- return _u32vector(vector)->elements(len);

-const std::vector< uint32_t >

-u32vector_elements(pmt_t vector)

- if (!vector->is_u32vector())

- throw wrong_type("pmt_u32vector_elements", vector);

- size_t len;

- const uint32_t *array = _u32vector(vector)->elements(len);

- const std::vector< uint32_t > vec(array, array+len);

- return vec;

-uint32_t *

-u32vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_u32vector())

- throw wrong_type("pmt_u32vector_writable_elements", vector);

- return _u32vector(vector)->writable_elements(len);

-const std::string

-pmt_u32vector::string_ref(size_t k) const

- return std::to_string(ref(k));

-static pmt_s32vector *

-_s32vector(pmt_t x)

- return dynamic_cast<pmt_s32vector*>(x.get());

-pmt_s32vector::pmt_s32vector(size_t k, int32_t fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_s32vector::pmt_s32vector(size_t k, const int32_t *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(int32_t) );

-int32_t

-pmt_s32vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_s32vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_s32vector::set(size_t k, int32_t x)

- if (k >= length())

- throw out_of_range("pmt_s32vector_set", from_long(k));

- d_v[k] = x;

-const int32_t *

-pmt_s32vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-int32_t *

-pmt_s32vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_s32vector::uniform_elements(size_t &len)

- len = length() * sizeof(int32_t);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_s32vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(int32_t);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_s32vector(pmt_t obj)

-{

- return obj->is_s32vector();

-}

-pmt_t

-make_s32vector(size_t k, int32_t fill)

-{

- return pmt_t(new pmt_s32vector(k, fill));

-}

-pmt_t

-init_s32vector(size_t k, const int32_t *data)

- return pmt_t(new pmt_s32vector(k, data));

-pmt_t

-init_s32vector(size_t k, const std::vector< int32_t > &data)

- if(k) {

- return pmt_t(new pmt_s32vector(k, &data[0]));

- }

- return pmt_t(new pmt_s32vector(k, static_cast< int32_t >(0))); // fills an empty vector with 0

-int32_t

-s32vector_ref(pmt_t vector, size_t k)

- if (!vector->is_s32vector())

- throw wrong_type("pmt_s32vector_ref", vector);

- return _s32vector(vector)->ref(k);

-void

-s32vector_set(pmt_t vector, size_t k, int32_t obj)

- if (!vector->is_s32vector())

- throw wrong_type("pmt_s32vector_set", vector);

- _s32vector(vector)->set(k, obj);

-const int32_t *

-s32vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_s32vector())

- throw wrong_type("pmt_s32vector_elements", vector);

- return _s32vector(vector)->elements(len);

-const std::vector< int32_t >

-s32vector_elements(pmt_t vector)

- if (!vector->is_s32vector())

- throw wrong_type("pmt_s32vector_elements", vector);

- size_t len;

- const int32_t *array = _s32vector(vector)->elements(len);

- const std::vector< int32_t > vec(array, array+len);

- return vec;

-int32_t *

-s32vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_s32vector())

- throw wrong_type("pmt_s32vector_writable_elements", vector);

- return _s32vector(vector)->writable_elements(len);

-const std::string

-pmt_s32vector::string_ref(size_t k) const

- return std::to_string(ref(k));

-static pmt_u64vector *

-_u64vector(pmt_t x)

- return dynamic_cast<pmt_u64vector*>(x.get());

-pmt_u64vector::pmt_u64vector(size_t k, uint64_t fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_u64vector::pmt_u64vector(size_t k, const uint64_t *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(uint64_t) );

-uint64_t

-pmt_u64vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_u64vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_u64vector::set(size_t k, uint64_t x)

- if (k >= length())

- throw out_of_range("pmt_u64vector_set", from_long(k));

- d_v[k] = x;

-const uint64_t *

-pmt_u64vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-uint64_t *

-pmt_u64vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_u64vector::uniform_elements(size_t &len)

- len = length() * sizeof(uint64_t);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_u64vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(uint64_t);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_u64vector(pmt_t obj)

-{

- return obj->is_u64vector();

-}

-pmt_t

-make_u64vector(size_t k, uint64_t fill)

- return pmt_t(new pmt_u64vector(k, fill));

-pmt_t

-init_u64vector(size_t k, const uint64_t *data)

- return pmt_t(new pmt_u64vector(k, data));

-pmt_t

-init_u64vector(size_t k, const std::vector< uint64_t > &data)

- if(k) {

- return pmt_t(new pmt_u64vector(k, &data[0]));

- }

- return pmt_t(new pmt_u64vector(k, static_cast< uint64_t >(0))); // fills an empty vector with 0

-uint64_t

-u64vector_ref(pmt_t vector, size_t k)

- if (!vector->is_u64vector())

- throw wrong_type("pmt_u64vector_ref", vector);

- return _u64vector(vector)->ref(k);

-void

-u64vector_set(pmt_t vector, size_t k, uint64_t obj)

- if (!vector->is_u64vector())

- throw wrong_type("pmt_u64vector_set", vector);

- _u64vector(vector)->set(k, obj);

-const uint64_t *

-u64vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_u64vector())

- throw wrong_type("pmt_u64vector_elements", vector);

- return _u64vector(vector)->elements(len);

-const std::vector< uint64_t >

-u64vector_elements(pmt_t vector)

- if (!vector->is_u64vector())

- throw wrong_type("pmt_u64vector_elements", vector);

- size_t len;

- const uint64_t *array = _u64vector(vector)->elements(len);

- const std::vector< uint64_t > vec(array, array+len);

- return vec;

-uint64_t *

-u64vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_u64vector())

- throw wrong_type("pmt_u64vector_writable_elements", vector);

- return _u64vector(vector)->writable_elements(len);

-const std::string

-pmt_u64vector::string_ref(size_t k) const

- return std::to_string(ref(k));

-static pmt_s64vector *

-_s64vector(pmt_t x)

- return dynamic_cast<pmt_s64vector*>(x.get());

-pmt_s64vector::pmt_s64vector(size_t k, int64_t fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_s64vector::pmt_s64vector(size_t k, const int64_t *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(int64_t) );

-int64_t

-pmt_s64vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_s64vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_s64vector::set(size_t k, int64_t x)

- if (k >= length())

- throw out_of_range("pmt_s64vector_set", from_long(k));

- d_v[k] = x;

-const int64_t *

-pmt_s64vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-int64_t *

-pmt_s64vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_s64vector::uniform_elements(size_t &len)

- len = length() * sizeof(int64_t);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_s64vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(int64_t);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_s64vector(pmt_t obj)

-{

- return obj->is_s64vector();

-}

-pmt_t

-make_s64vector(size_t k, int64_t fill)

-{

- return pmt_t(new pmt_s64vector(k, fill));

-}

-pmt_t

-init_s64vector(size_t k, const int64_t *data)

- return pmt_t(new pmt_s64vector(k, data));

-pmt_t

-init_s64vector(size_t k, const std::vector< int64_t > &data)

- if(k) {

- return pmt_t(new pmt_s64vector(k, &data[0]));

- }

- return pmt_t(new pmt_s64vector(k, static_cast< int64_t >(0))); // fills an empty vector with 0

-int64_t

-s64vector_ref(pmt_t vector, size_t k)

- if (!vector->is_s64vector())

- throw wrong_type("pmt_s64vector_ref", vector);

- return _s64vector(vector)->ref(k);

-void

-s64vector_set(pmt_t vector, size_t k, int64_t obj)

- if (!vector->is_s64vector())

- throw wrong_type("pmt_s64vector_set", vector);

- _s64vector(vector)->set(k, obj);

-const int64_t *

-s64vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_s64vector())

- throw wrong_type("pmt_s64vector_elements", vector);

- return _s64vector(vector)->elements(len);

-const std::vector< int64_t >

-s64vector_elements(pmt_t vector)

- if (!vector->is_s64vector())

- throw wrong_type("pmt_s64vector_elements", vector);

- size_t len;

- const int64_t *array = _s64vector(vector)->elements(len);

- const std::vector< int64_t > vec(array, array+len);

- return vec;

-int64_t *

-s64vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_s64vector())

- throw wrong_type("pmt_s64vector_writable_elements", vector);

- return _s64vector(vector)->writable_elements(len);

-const std::string

-pmt_s64vector::string_ref(size_t k) const

- return std::to_string(ref(k));

-static pmt_f32vector *

-_f32vector(pmt_t x)

- return dynamic_cast<pmt_f32vector*>(x.get());

-pmt_f32vector::pmt_f32vector(size_t k, float fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_f32vector::pmt_f32vector(size_t k, const float *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(float) );

-float

-pmt_f32vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_f32vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_f32vector::set(size_t k, float x)

- if (k >= length())

- throw out_of_range("pmt_f32vector_set", from_long(k));

- d_v[k] = x;

-const float *

-pmt_f32vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-float *

-pmt_f32vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_f32vector::uniform_elements(size_t &len)

- len = length() * sizeof(float);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_f32vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(float);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_f32vector(pmt_t obj)

-{

- return obj->is_f32vector();

-}

-pmt_t

-make_f32vector(size_t k, float fill)

-{

- return pmt_t(new pmt_f32vector(k, fill));

-}

-pmt_t

-init_f32vector(size_t k, const float *data)

- return pmt_t(new pmt_f32vector(k, data));

-pmt_t

-init_f32vector(size_t k, const std::vector< float > &data)

- if(k) {

- return pmt_t(new pmt_f32vector(k, &data[0]));

- }

- return pmt_t(new pmt_f32vector(k, static_cast< float >(0))); // fills an empty vector with 0

-float

-f32vector_ref(pmt_t vector, size_t k)

- if (!vector->is_f32vector())

- throw wrong_type("pmt_f32vector_ref", vector);

- return _f32vector(vector)->ref(k);

-void

-f32vector_set(pmt_t vector, size_t k, float obj)

- if (!vector->is_f32vector())

- throw wrong_type("pmt_f32vector_set", vector);

- _f32vector(vector)->set(k, obj);

-const float *

-f32vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_f32vector())

- throw wrong_type("pmt_f32vector_elements", vector);

- return _f32vector(vector)->elements(len);

-const std::vector< float >

-f32vector_elements(pmt_t vector)

- if (!vector->is_f32vector())

- throw wrong_type("pmt_f32vector_elements", vector);

- size_t len;

- const float *array = _f32vector(vector)->elements(len);

- const std::vector< float > vec(array, array+len);

- return vec;

-float *

-f32vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_f32vector())

- throw wrong_type("pmt_f32vector_writable_elements", vector);

- return _f32vector(vector)->writable_elements(len);

-const std::string

-pmt_f32vector::string_ref(size_t k) const

- return boost::lexical_cast< std::string, float > (ref(k));

-static pmt_f64vector *

-_f64vector(pmt_t x)

- return dynamic_cast<pmt_f64vector*>(x.get());

-pmt_f64vector::pmt_f64vector(size_t k, double fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_f64vector::pmt_f64vector(size_t k, const double *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(double) );

-double

-pmt_f64vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_f64vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_f64vector::set(size_t k, double x)

- if (k >= length())

- throw out_of_range("pmt_f64vector_set", from_long(k));

- d_v[k] = x;

-const double *

-pmt_f64vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-double *

-pmt_f64vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_f64vector::uniform_elements(size_t &len)

- len = length() * sizeof(double);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_f64vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(double);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_f64vector(pmt_t obj)

-{

- return obj->is_f64vector();

-}

-pmt_t

-make_f64vector(size_t k, double fill)

-{

- return pmt_t(new pmt_f64vector(k, fill));

-}

-pmt_t

-init_f64vector(size_t k, const double *data)

- return pmt_t(new pmt_f64vector(k, data));

-pmt_t

-init_f64vector(size_t k, const std::vector< double > &data)

- if(k) {

- return pmt_t(new pmt_f64vector(k, &data[0]));

- }

- return pmt_t(new pmt_f64vector(k, static_cast< double >(0))); // fills an empty vector with 0

-double

-f64vector_ref(pmt_t vector, size_t k)

- if (!vector->is_f64vector())

- throw wrong_type("pmt_f64vector_ref", vector);

- return _f64vector(vector)->ref(k);

-void

-f64vector_set(pmt_t vector, size_t k, double obj)

- if (!vector->is_f64vector())

- throw wrong_type("pmt_f64vector_set", vector);

- _f64vector(vector)->set(k, obj);

-const double *

-f64vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_f64vector())

- throw wrong_type("pmt_f64vector_elements", vector);

- return _f64vector(vector)->elements(len);

-const std::vector< double >

-f64vector_elements(pmt_t vector)

- if (!vector->is_f64vector())

- throw wrong_type("pmt_f64vector_elements", vector);

- size_t len;

- const double *array = _f64vector(vector)->elements(len);

- const std::vector< double > vec(array, array+len);

- return vec;

-double *

-f64vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_f64vector())

- throw wrong_type("pmt_f64vector_writable_elements", vector);

- return _f64vector(vector)->writable_elements(len);

-const std::string

-pmt_f64vector::string_ref(size_t k) const

- return boost::lexical_cast< std::string, double > (ref(k));

-static pmt_c32vector *

-_c32vector(pmt_t x)

- return dynamic_cast<pmt_c32vector*>(x.get());

-pmt_c32vector::pmt_c32vector(size_t k, std::complex<float> fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_c32vector::pmt_c32vector(size_t k, const std::complex<float> *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(std::complex<float>) );

-std::complex<float>

-pmt_c32vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_c32vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_c32vector::set(size_t k, std::complex<float> x)

- if (k >= length())

- throw out_of_range("pmt_c32vector_set", from_long(k));

- d_v[k] = x;

-const std::complex<float> *

-pmt_c32vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-std::complex<float> *

-pmt_c32vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_c32vector::uniform_elements(size_t &len)

- len = length() * sizeof(std::complex<float>);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_c32vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(std::complex<float>);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_c32vector(pmt_t obj)

-{

- return obj->is_c32vector();

-}

-pmt_t

-make_c32vector(size_t k, std::complex<float> fill)

- return pmt_t(new pmt_c32vector(k, fill));

-pmt_t

-init_c32vector(size_t k, const std::complex<float> *data)

- return pmt_t(new pmt_c32vector(k, data));

-pmt_t

-init_c32vector(size_t k, const std::vector< std::complex<float> > &data)

- if(k) {

- return pmt_t(new pmt_c32vector(k, &data[0]));

- }

- return pmt_t(new pmt_c32vector(k, static_cast< std::complex<float> >(0))); // fills an empty vector with 0

-std::complex<float>

-c32vector_ref(pmt_t vector, size_t k)

- if (!vector->is_c32vector())

- throw wrong_type("pmt_c32vector_ref", vector);

- return _c32vector(vector)->ref(k);

-void

-c32vector_set(pmt_t vector, size_t k, std::complex<float> obj)

- if (!vector->is_c32vector())

- throw wrong_type("pmt_c32vector_set", vector);

- _c32vector(vector)->set(k, obj);

-const std::complex<float> *

-c32vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_c32vector())

- throw wrong_type("pmt_c32vector_elements", vector);

- return _c32vector(vector)->elements(len);

-const std::vector< std::complex<float> >

-c32vector_elements(pmt_t vector)

- if (!vector->is_c32vector())

- throw wrong_type("pmt_c32vector_elements", vector);

- size_t len;

- const std::complex<float> *array = _c32vector(vector)->elements(len);

- const std::vector< std::complex<float> > vec(array, array+len);

- return vec;

-std::complex<float> *

-c32vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_c32vector())

- throw wrong_type("pmt_c32vector_writable_elements", vector);

- return _c32vector(vector)->writable_elements(len);

-const std::string

-pmt_c32vector::string_ref(size_t k) const

- return boost::lexical_cast< std::string, std::complex<float> > (ref(k));

-static pmt_c64vector *

-_c64vector(pmt_t x)

- return dynamic_cast<pmt_c64vector*>(x.get());

-pmt_c64vector::pmt_c64vector(size_t k, std::complex<double> fill)

- : d_v(k)

- for (size_t i = 0; i < k; i++)

- d_v[i] = fill;

-pmt_c64vector::pmt_c64vector(size_t k, const std::complex<double> *data)

- : d_v(k)

- if(k)

- memcpy( &d_v[0], data, k * sizeof(std::complex<double>) );

-std::complex<double>

-pmt_c64vector::ref(size_t k) const

- if (k >= length())

- throw out_of_range("pmt_c64vector_ref", from_long(k));

- return d_v[k];

-void

-pmt_c64vector::set(size_t k, std::complex<double> x)

- if (k >= length())

- throw out_of_range("pmt_c64vector_set", from_long(k));

- d_v[k] = x;

-const std::complex<double> *

-pmt_c64vector::elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-std::complex<double> *

-pmt_c64vector::writable_elements(size_t &len)

- len = length();

- return len ? &d_v[0] : nullptr;

-const void*

-pmt_c64vector::uniform_elements(size_t &len)

- len = length() * sizeof(std::complex<double>);

- return len ? &d_v[0] : nullptr;

-void*

-pmt_c64vector::uniform_writable_elements(size_t &len)

- len = length() * sizeof(std::complex<double>);

- return len ? (&d_v[0]) : nullptr;

-bool

-is_c64vector(pmt_t obj)

-{

- return obj->is_c64vector();

-}

-pmt_t

-make_c64vector(size_t k, std::complex<double> fill)

- return pmt_t(new pmt_c64vector(k, fill));

-pmt_t

-init_c64vector(size_t k, const std::complex<double> *data)

- return pmt_t(new pmt_c64vector(k, data));

-pmt_t

-init_c64vector(size_t k, const std::vector< std::complex<double> > &data)

- if(k) {

- return pmt_t(new pmt_c64vector(k, &data[0]));

- }

- return pmt_t(new pmt_c64vector(k, static_cast< std::complex<double> >(0))); // fills an empty vector with 0

-std::complex<double>

-c64vector_ref(pmt_t vector, size_t k)

- if (!vector->is_c64vector())

- throw wrong_type("pmt_c64vector_ref", vector);

- return _c64vector(vector)->ref(k);

-void

-c64vector_set(pmt_t vector, size_t k, std::complex<double> obj)

- if (!vector->is_c64vector())

- throw wrong_type("pmt_c64vector_set", vector);

- _c64vector(vector)->set(k, obj);

-const std::complex<double> *

-c64vector_elements(pmt_t vector, size_t &len)

- if (!vector->is_c64vector())

- throw wrong_type("pmt_c64vector_elements", vector);

- return _c64vector(vector)->elements(len);

-const std::vector< std::complex<double> >

-c64vector_elements(pmt_t vector)

- if (!vector->is_c64vector())

- throw wrong_type("pmt_c64vector_elements", vector);

- size_t len;

- const std::complex<double> *array = _c64vector(vector)->elements(len);

- const std::vector< std::complex<double> > vec(array, array+len);

- return vec;

-std::complex<double> *

-c64vector_writable_elements(pmt_t vector, size_t &len)

- if (!vector->is_c64vector())

- throw wrong_type("pmt_c64vector_writable_elements", vector);

- return _c64vector(vector)->writable_elements(len);

-const std::string

-pmt_c64vector::string_ref(size_t k) const

- return boost::lexical_cast< std::string, std::complex<double> > (ref(k));

-namespace pmt{

- std::vector< uint8_t > d_v;

- pmt_u8vector(size_t k, uint8_t fill);

- pmt_u8vector(size_t k, const uint8_t *data);

- // ~pmt_u8vector();

-

- bool is_u8vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(uint8_t); }

- uint8_t ref(size_t k) const;

- void set(size_t k, uint8_t x);

- const uint8_t *elements(size_t &len);

- uint8_t *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< int8_t > d_v;

- pmt_s8vector(size_t k, int8_t fill);

- pmt_s8vector(size_t k, const int8_t *data);

- // ~pmt_s8vector();

-

- bool is_s8vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(int8_t); }

- int8_t ref(size_t k) const;

- void set(size_t k, int8_t x);

- const int8_t *elements(size_t &len);

- int8_t *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< uint16_t > d_v;

- pmt_u16vector(size_t k, uint16_t fill);

- pmt_u16vector(size_t k, const uint16_t *data);

- // ~pmt_u16vector();

-

- bool is_u16vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(uint16_t); }

- uint16_t ref(size_t k) const;

- void set(size_t k, uint16_t x);

- const uint16_t *elements(size_t &len);

- uint16_t *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< int16_t > d_v;

- pmt_s16vector(size_t k, int16_t fill);

- pmt_s16vector(size_t k, const int16_t *data);

- // ~pmt_s16vector();

-

- bool is_s16vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(int16_t); }

- int16_t ref(size_t k) const;

- void set(size_t k, int16_t x);

- const int16_t *elements(size_t &len);

- int16_t *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< uint32_t > d_v;

- pmt_u32vector(size_t k, uint32_t fill);

- pmt_u32vector(size_t k, const uint32_t *data);

- // ~pmt_u32vector();

-

- bool is_u32vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(uint32_t); }

- uint32_t ref(size_t k) const;

- void set(size_t k, uint32_t x);

- const uint32_t *elements(size_t &len);

- uint32_t *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< int32_t > d_v;

- pmt_s32vector(size_t k, int32_t fill);

- pmt_s32vector(size_t k, const int32_t *data);

- // ~pmt_s32vector();

-

- bool is_s32vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(int32_t); }

- int32_t ref(size_t k) const;

- void set(size_t k, int32_t x);

- const int32_t *elements(size_t &len);

- int32_t *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< uint64_t > d_v;

- pmt_u64vector(size_t k, uint64_t fill);

- pmt_u64vector(size_t k, const uint64_t *data);

- // ~pmt_u64vector();

-

- bool is_u64vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(uint64_t); }

- uint64_t ref(size_t k) const;

- void set(size_t k, uint64_t x);

- const uint64_t *elements(size_t &len);

- uint64_t *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< int64_t > d_v;

- pmt_s64vector(size_t k, int64_t fill);

- pmt_s64vector(size_t k, const int64_t *data);

- // ~pmt_s64vector();

-

- bool is_s64vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(int64_t); }

- int64_t ref(size_t k) const;

- void set(size_t k, int64_t x);

- const int64_t *elements(size_t &len);

- int64_t *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< float > d_v;

- pmt_f32vector(size_t k, float fill);

- pmt_f32vector(size_t k, const float *data);

- // ~pmt_f32vector();

-

- bool is_f32vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(float); }

- float ref(size_t k) const;

- void set(size_t k, float x);

- const float *elements(size_t &len);

- float *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< double > d_v;

- pmt_f64vector(size_t k, double fill);

- pmt_f64vector(size_t k, const double *data);

- // ~pmt_f64vector();

-

- bool is_f64vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(double); }

- double ref(size_t k) const;

- void set(size_t k, double x);

- const double *elements(size_t &len);

- double *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< std::complex<float> > d_v;

- pmt_c32vector(size_t k, std::complex<float> fill);

- pmt_c32vector(size_t k, const std::complex<float> *data);

- // ~pmt_c32vector();

-

- bool is_c32vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(std::complex<float>); }

- std::complex<float> ref(size_t k) const;

- void set(size_t k, std::complex<float> x);

- const std::complex<float> *elements(size_t &len);

- std::complex<float> *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

- std::vector< std::complex<double> > d_v;

- pmt_c64vector(size_t k, std::complex<double> fill);

- pmt_c64vector(size_t k, const std::complex<double> *data);

- // ~pmt_c64vector();

-

- bool is_c64vector() const { return true; }

- size_t length() const { return d_v.size(); }

- size_t itemsize() const { return sizeof(std::complex<double>); }

- std::complex<double> ref(size_t k) const;

- void set(size_t k, std::complex<double> x);

- const std::complex<double> *elements(size_t &len);

- std::complex<double> *writable_elements(size_t &len);

- const void *uniform_elements(size_t &len);

- void *uniform_writable_elements(size_t &len);

- virtual const std::string string_ref(size_t k) const;

-BOOST_AUTO_TEST_CASE(test_symbols) {

- BOOST_CHECK(!pmt::is_symbol(pmt::PMT_T));

- BOOST_CHECK(!pmt::is_symbol(pmt::PMT_F));

- BOOST_CHECK_THROW(pmt::symbol_to_string(pmt::PMT_F), pmt::wrong_type);

-

- pmt::pmt_t sym1 = pmt::mp("test");

- BOOST_CHECK(pmt::is_symbol(sym1));

- BOOST_CHECK_EQUAL(std::string("test"), pmt::symbol_to_string(sym1));

- BOOST_CHECK(pmt::is_true(sym1));

- BOOST_CHECK(!pmt::is_false(sym1));

-

- pmt::pmt_t sym2 = pmt::mp("foo");

- pmt::pmt_t sym3 = pmt::mp("test");

- BOOST_CHECK_EQUAL(sym1, sym3);

- BOOST_CHECK(sym1 != sym2);

- BOOST_CHECK(sym1 == sym3);

-

- static const int N = 2048;

- 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] = pmt::mp(buf.c_str());

- }

-

- // confirm that they are all unique

- for (int i = 0; i < N; i++)

- for (int j = i + 1; j < N; j++)

- BOOST_CHECK(v1[i] != v1[j]);

-

- // generate the same symbols again

- for (int i = 0; i < N; i++){

- std::string buf = str(boost::format("test-%d") % i);

- v2[i] = pmt::mp(buf.c_str());

- }

-

- // confirm that we get the same ones back

- for (int i = 0; i < N; i++)

- BOOST_CHECK(v1[i] == v2[i]);

-BOOST_AUTO_TEST_CASE(test_booleans) {

- pmt::pmt_t sym = pmt::mp("test");

- BOOST_CHECK(pmt::is_bool(pmt::PMT_T));

- BOOST_CHECK(pmt::is_bool(pmt::PMT_F));

- BOOST_CHECK(!pmt::is_bool(sym));

- BOOST_CHECK_EQUAL(pmt::from_bool(false), pmt::PMT_F);

- BOOST_CHECK_EQUAL(pmt::from_bool(true), pmt::PMT_T);

- BOOST_CHECK_EQUAL(false, pmt::to_bool(pmt::PMT_F));

- BOOST_CHECK_EQUAL(true, pmt::to_bool(pmt::PMT_T));

- BOOST_CHECK_THROW(pmt::to_bool(sym), pmt::wrong_type);

-BOOST_AUTO_TEST_CASE(test_integers) {

- pmt::pmt_t p1 = pmt::from_long(1);

- pmt::pmt_t m1 = pmt::from_long(-1);

- BOOST_CHECK(!pmt::is_integer(pmt::PMT_T));

- BOOST_CHECK(pmt::is_integer(p1));

- BOOST_CHECK(pmt::is_integer(m1));

- BOOST_CHECK_THROW(pmt::to_long(pmt::PMT_T), pmt::wrong_type);

- BOOST_CHECK_EQUAL(-1L, pmt::to_long(m1));

- BOOST_CHECK_EQUAL(1L, pmt::to_long(p1));

-BOOST_AUTO_TEST_CASE(test_uint64s) {

- pmt::pmt_t p1 = pmt::from_uint64((uint64_t)1);

- pmt::pmt_t m1 = pmt::from_uint64((uint64_t)8589934592ULL);

- BOOST_CHECK(!pmt::is_uint64(pmt::PMT_T));

- BOOST_CHECK(pmt::is_uint64(p1));

- BOOST_CHECK(pmt::is_uint64(m1));

- BOOST_CHECK_THROW(pmt::to_uint64(pmt::PMT_T), pmt::wrong_type);

- BOOST_CHECK_EQUAL((uint64_t)8589934592ULL, (uint64_t)pmt::to_uint64(m1));

- BOOST_CHECK_EQUAL((uint64_t)1ULL, (uint64_t)pmt::to_uint64(p1));

-BOOST_AUTO_TEST_CASE(test_reals) {

- pmt::pmt_t p1 = pmt::from_double(1);

- pmt::pmt_t m1 = pmt::from_double(-1);

- BOOST_CHECK(!pmt::is_real(pmt::PMT_T));

- BOOST_CHECK(pmt::is_real(p1));

- BOOST_CHECK(pmt::is_real(m1));

- BOOST_CHECK_THROW(pmt::to_double(pmt::PMT_T), pmt::wrong_type);

- BOOST_CHECK_EQUAL(-1.0, pmt::to_double(m1));

- BOOST_CHECK_EQUAL(1.0, pmt::to_double(p1));

- BOOST_CHECK_EQUAL(1.0, pmt::to_double(pmt::from_long(1)));

-

- pmt::pmt_t p2 = pmt::from_float(1);

- pmt::pmt_t m2 = pmt::from_float(-1);

- BOOST_CHECK(pmt::is_real(p2));

- BOOST_CHECK(pmt::is_real(m2));

- BOOST_CHECK_THROW(pmt::to_float(pmt::PMT_T), pmt::wrong_type);

- BOOST_CHECK_EQUAL(float(-1.0), pmt::to_float(m2));

- BOOST_CHECK_EQUAL(float(1.0), pmt::to_float(p2));

- BOOST_CHECK_EQUAL(float(1.0), pmt::to_float(pmt::from_long(1)));

-BOOST_AUTO_TEST_CASE(test_complexes) {

- 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));

- BOOST_CHECK(!pmt::is_complex(pmt::PMT_T));

- BOOST_CHECK(pmt::is_complex(p1));

- BOOST_CHECK(pmt::is_complex(m1));

- BOOST_CHECK(pmt::is_complex(p2));

- BOOST_CHECK(pmt::is_complex(m2));

- BOOST_CHECK(pmt::is_complex(p3));

- BOOST_CHECK(pmt::is_complex(m3));

- BOOST_CHECK_THROW(pmt::to_complex(pmt::PMT_T), pmt::wrong_type);

- BOOST_CHECK_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p1));

- BOOST_CHECK_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m1));

- BOOST_CHECK_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p2));

- BOOST_CHECK_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m2));

- BOOST_CHECK_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p3));

- BOOST_CHECK_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m3));

- BOOST_CHECK_EQUAL(std::complex<double>(1.0, 0), pmt::to_complex(pmt::from_long(1)));

- BOOST_CHECK_EQUAL(std::complex<double>(1.0, 0), pmt::to_complex(pmt::from_double(1.0)));

-BOOST_AUTO_TEST_CASE(test_pairs) {

- BOOST_CHECK(pmt::is_null(pmt::PMT_NIL));

- BOOST_CHECK(!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");

-

-

- BOOST_CHECK_EQUAL((size_t)0, pmt::length(pmt::PMT_NIL));

- BOOST_CHECK_THROW(pmt::length(s1), pmt::wrong_type);

- BOOST_CHECK_THROW(pmt::length(pmt::from_double(42)), pmt::wrong_type);

-

- pmt::pmt_t c1 = pmt::cons(s1, pmt::PMT_NIL);

- BOOST_CHECK(pmt::is_pair(c1));

- BOOST_CHECK(!pmt::is_pair(s1));

- BOOST_CHECK_EQUAL(s1, pmt::car(c1));

- BOOST_CHECK_EQUAL(pmt::PMT_NIL, pmt::cdr(c1));

- BOOST_CHECK_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);

- BOOST_CHECK_EQUAL(c2, pmt::cdr(c1));

- pmt::set_car(c1, s3);

- BOOST_CHECK_EQUAL(s3, pmt::car(c1));

- BOOST_CHECK_EQUAL((size_t)1, pmt::length(c3));

- BOOST_CHECK_EQUAL((size_t)2, pmt::length(c2));

-

- BOOST_CHECK_THROW(pmt::cdr(pmt::PMT_NIL), pmt::wrong_type);

- BOOST_CHECK_THROW(pmt::car(pmt::PMT_NIL), pmt::wrong_type);

- BOOST_CHECK_THROW(pmt::set_car(s1, pmt::PMT_NIL), pmt::wrong_type);

- BOOST_CHECK_THROW(pmt::set_cdr(s1, pmt::PMT_NIL), pmt::wrong_type);

-BOOST_AUTO_TEST_CASE(test_vectors) {

- static const size_t N = 3;

- pmt::pmt_t v1 = pmt::make_vector(N, pmt::PMT_NIL);

- BOOST_CHECK_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);

-

- BOOST_CHECK_EQUAL(s0, pmt::vector_ref(v1, 0));

- BOOST_CHECK_EQUAL(s1, pmt::vector_ref(v1, 1));

- BOOST_CHECK_EQUAL(s2, pmt::vector_ref(v1, 2));

-

- BOOST_CHECK_THROW(pmt::vector_ref(v1, N), pmt::out_of_range);

- BOOST_CHECK_THROW(pmt::vector_set(v1, N, pmt::PMT_NIL), pmt::out_of_range);

-

- pmt::vector_fill(v1, s0);

- for (size_t i = 0; i < N; i++)

- BOOST_CHECK_EQUAL(s0, pmt::vector_ref(v1, i));

-static void

-check_tuple(size_t len, const std::vector<pmt::pmt_t> &s, pmt::pmt_t t)

- BOOST_CHECK_EQUAL(true, pmt::is_tuple(t));

- BOOST_CHECK_EQUAL(len, pmt::length(t));

-

- for (size_t i = 0; i < len; i++)

- BOOST_CHECK_EQUAL(s[i], pmt::tuple_ref(t, i));

-BOOST_AUTO_TEST_CASE(test_tuples) {

- 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] = pmt::mp(os.str());

- pmt::vector_set(v, i, s[i]);

- }

- pmt::pmt_t t;

- t = pmt::make_tuple();

- check_tuple(0, s, t);

- t = pmt::make_tuple(s[0]);

- check_tuple(1, s, t);

- BOOST_CHECK(pmt::is_vector(v));

- BOOST_CHECK(!pmt::is_tuple(v));

- BOOST_CHECK(pmt::is_tuple(t));

- BOOST_CHECK(!pmt::is_vector(t));

- t = pmt::make_tuple(s[0], s[1]);

- check_tuple(2, s, t);

- 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]);

- check_tuple(4, s, t);

- 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]);

- check_tuple(6, s, t);

- 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]);

- 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]);

- 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]);

- check_tuple(10, s, t);

- t = pmt::make_tuple(s[0], s[1], s[2]);

- BOOST_CHECK_THROW(pmt::tuple_ref(t, 3), pmt::out_of_range);

- BOOST_CHECK_THROW(pmt::vector_ref(t, 0), pmt::wrong_type);

- BOOST_CHECK_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::pmt_t t2 = pmt::to_tuple(v);

- BOOST_CHECK_EQUAL(size_t(10), pmt::length(v));

- BOOST_CHECK(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::pmt_t list0 = pmt::list3(s[0], s[1], s[2]);

- BOOST_CHECK_EQUAL(size_t(3), pmt::length(list0));

- t2 = pmt::to_tuple(list0);

- BOOST_CHECK_EQUAL(size_t(3), pmt::length(t2));

- BOOST_CHECK(pmt::equal(t, t2));

-BOOST_AUTO_TEST_CASE(test_equivalence) {

- 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);

-

- BOOST_CHECK(pmt::eq(s0, s0));

- BOOST_CHECK(!pmt::eq(s0, s1));

- BOOST_CHECK(pmt::eqv(s0, s0));

- BOOST_CHECK(!pmt::eqv(s0, s1));

-

- BOOST_CHECK(pmt::eqv(i0, i1));

- BOOST_CHECK(pmt::eqv(r0, r1));

- BOOST_CHECK(!pmt::eqv(r0, r2));

- BOOST_CHECK(!pmt::eqv(i0, r0));

-

- BOOST_CHECK(!pmt::eq(list0, list1));

- BOOST_CHECK(!pmt::eqv(list0, list1));

- BOOST_CHECK(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);

- BOOST_CHECK(!pmt::eqv(v0, v1));

- BOOST_CHECK(pmt::equal(v0, v1));

- BOOST_CHECK(!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);

- BOOST_CHECK(pmt::equal(v0, v1));