-like "pmt::pmt_from_<type>". Similarly, when getting data out of a

-PMT, we use a call like "pmt::pmt_to_<type>". For example:

-pmt::pmt_t pmt_a = pmt::pmt_from_double(a);

-double b = pmt::pmt_to_double(pmt_a);

-pmt::pmt_t pmt_c = pmt::pmt_from_long(c);

-int d = pmt::pmt_to_long(pmt_c);

-pmt::pmt_t pmt_a = pmt::pmt_make_rectangular(a.real(), b.imag());

-std::complex<double> b = pmt::pmt_to_complex(pmt_a);

-function, pmt::pmt_intern, is simply an alias of the first.

-pmt::pmt_t str0 = pmt::pmt_string_to_symbol(std::string("some string"));

-pmt::pmt_t str1 = pmt::pmt_intern(std::string("some string"));

-std::string s = pmt::pmt_symbol_to_string(str0);

-"pmt::pmt_is_<type>". We can use these to test the PMT before trying

-pmt::pmt_t str0 = pmt::pmt_string_to_symbol(std::string("some string"));

-if(pmt::pmt_is_symbol(str0))

- std::string s = pmt::pmt_symbol_to_string(str0);

-pmt::pmt_t pmt_a = pmt::pmt_from_double(a);

-if(pmt::pmt_is_double(pmt_a))

- double b = pmt::pmt_to_double(pmt_a);

-pmt::pmt_t pmt_c = pmt::pmt_from_long(c);

-if(pmt::pmt_is_long(pmt_a))

- int d = pmt::pmt_to_long(pmt_c);

-if(pmt::pmt_is_double(pmt_a))

- double d = pmt::pmt_to_double(pmt_c);

-- bool pmt::pmt_is_dict(const pmt_t &obj)

-- pmt_t pmt::pmt_make_dict()

-- pmt_t pmt::pmt_dict_add(const pmt_t &dict, const pmt_t &key, const pmt_t &value)

-- pmt_t pmt::pmt_dict_delete(const pmt_t &dict, const pmt_t &key)

-- bool pmt::pmt_dict_has_key(const pmt_t &dict, const pmt_t &key)

-- pmt_t pmt::pmt_dict_ref(const pmt_t &dict, const pmt_t &key, const pmt_t &not_found)

-- pmt_t pmt::pmt_dict_items(pmt_t dict)

-- pmt_t pmt::pmt_dict_keys(pmt_t dict)

-- pmt_t pmt::pmt_dict_values(pmt_t dict)

-key0 = pmt.pmt_intern("int")

-val0 = pmt.pmt_from_long(123)

-val1 = pmt.pmt_from_long(234)

-key1 = pmt.pmt_intern("double")

-val2 = pmt.pmt_from_double(5.4321)

-a = pmt.pmt_make_dict()

-a = pmt.pmt_dict_add(a, key0, val0)

-pmt.pmt_print(a)

-a = pmt.pmt_dict_add(a, key0, val1)

-pmt.pmt_print(a)

-a = pmt.pmt_dict_add(a, key1, val2)

-pmt.pmt_print(a)

-print pmt.pmt_dict_has_key(a, key1)

-a = pmt.pmt_dict_delete(a, key1)

-print pmt.pmt_dict_has_key(a, key1)

-ref = pmt.pmt_dict_ref(a, key0, pmt.PMT_NIL)

-pmt.pmt_print(ref)

-if(pmt.pmt_dict_has_key(a, key0) and pmt.pmt_eq(ref, pmt.PMT_NIL)):

-pmt::pmt_length.

-- bool pmt::pmt_is_vector(pmt_t x)

-- pmt_t pmt::pmt_make_vector(size_t k, pmt_t fill)

-- pmt_t pmt::pmt_vector_ref(pmt_t vector, size_t k)

-- void pmt::pmt_vector_set(pmt_t vector, size_t k, pmt_t obj)

-- void pmt::pmt_vector_fill(pmt_t vector, pmt_t fill)

-- bool pmt::pmt_is_(dtype)vector(pmt_t x)

-- pmt_t pmt::pmt_make_(dtype)vector(size_t k, (dtype) fill)

-- pmt_t pmt::pmt_init_(dtype)vector(size_t k, const (dtype*) data)

-- pmt_t pmt::pmt_init_(dtype)vector(size_t k, const std::vector<dtype> data)

-- pmt_t pmt::pmt_(dtype)vector_ref(pmt_t vector, size_t k)

-- void pmt::pmt_(dtype)vector_set(pmt_t vector, size_t k, (dtype) x)

-- const dtype* pmt::pmt_(dtype)vector_elements(pmt_t vector, size_t &len)

-- dtype* pmt::pmt_(dtype)vector_writable_elements(pmt_t vector, size_t &len)

-- bool pmt::pmt_is_pair (const pmt_t &obj): Return true if obj is a pair, else false

-- pmt_t pmt::pmt_cons(const pmt_t &x, const pmt_t &y): construct new pair

-- pmt_t pmt::pmt_car(const pmt_t &pair): get the car of the pair (first object)

-- pmt_t pmt::pmt_cdr(const pmt_t &pair): get the cdr of the pair (second object)

-- void pmt::pmt_set_car(pmt_t pair, pmt_t value): Stores value in the car field

-- void pmt::pmt_set_cdr(pmt_t pair, pmt_t value): Stores value in the cdr field

-- bool pmt::pmt_serialize(pmt_t obj, std::streambuf &sink)

-- std::string pmt::pmt_serialize_str(pmt_t obj)

-- pmt_t pmt::pmt_deserialize(std::streambuf &source)

-- pmt_t pmt::pmt_deserialize_str(std::string str)

-key0 = pmt.pmt_intern("int")

-val0 = pmt.pmt_from_long(123)

-key1 = pmt.pmt_intern("double")

-val1 = pmt.pmt_from_double(5.4321)

-a = pmt.pmt_make_dict()

-a = pmt.pmt_dict_add(a, key0, val0)

-a = pmt.pmt_dict_add(a, key1, val1)

-pmt.pmt_print(a)

-ser_str = pmt.pmt_serialize_str(a)

-b = pmt.pmt_deserialize_str(ser_str)

-pmt.pmt_print(b)

-We have used the pmt::pmt_print function in these examples to nicely

-print the contents of a PMT. Another way to print the contents is

-using the overloaded "<<" operator with a stream buffer object. In

-C++, we can inline print the contents of a PMT like:

-pmt::pmt_t a pmt::pmt_from_double(1.0);

- pmt::pmt_t srcid = pmt::pmt_string_to_symbol(str.str());

- pmt::pmt_t key = pmt::pmt_string_to_symbol("seq");

- pmt::pmt_t value = pmt::pmt_from_uint64(d_tag_counter++);

- pmt::pmt_t srcid = pmt::pmt_string_to_symbol(str.str());

- pmt::pmt_t key = pmt::pmt_string_to_symbol("seq");

- pmt::pmt_t value = pmt::pmt_from_uint64(d_tag_counter++);

- tag.srcid = pmt::pmt_intern(name());

- d_true_key = pmt::pmt_string_to_symbol("burst");

- d_false_key = pmt::pmt_string_to_symbol("burst");

- d_id = pmt::pmt_string_to_symbol(str.str());

- d_true_key = pmt::pmt_string_to_symbol(key);

- d_false_key = pmt::pmt_string_to_symbol(key);

- pmt::pmt_make_c32vector(0,-2),

- pmt::pmt_make_c32vector(0,2),

- pmt::pmt_make_c32vector(0,0),

- pmt::pmt_make_c32vector(0,-2),

- pmt::pmt_make_c32vector(0,2),

- pmt::pmt_make_c32vector(0,0),

- << std::setw(10) << "Source: " << (pmt::pmt_is_symbol(d_tags_itr->srcid) ? pmt::pmt_symbol_to_string(d_tags_itr->srcid) : "n/a")

- << std::setw(10) << "Key: " << pmt::pmt_symbol_to_string(d_tags_itr->key)

- d_me = pmt::pmt_string_to_symbol(id.str());

- d_me = pmt::pmt_string_to_symbol(id.str());

- pmt::pmt_string_to_symbol("tx_eob"),

- pmt::pmt_from_bool(1),

- pmt::pmt_string_to_symbol("tx_sob"),

- pmt::pmt_from_bool(1),

- pmt::pmt_print(msg);

- pmt::pmt_t meta = pmt::pmt_car(msg);

- pmt::pmt_t vector = pmt::pmt_cdr(msg);

- pmt::pmt_print(meta);

- size_t len = pmt::pmt_length(vector);

- const uint8_t* d = (const uint8_t*) pmt_uniform_vector_elements(vector, offset);

- return pmt::pmt_is_u8vector(v);

- return pmt::pmt_is_f32vector(v);

- return pmt::pmt_is_c32vector(v);

- return pmt::pmt_init_u8vector(items, buf);

- return pmt::pmt_init_f32vector(items, (const float*)buf);

- return pmt::pmt_init_c32vector(items, (const gr_complex*)buf);

- if(pmt_is_u8vector(vector))

- if(pmt_is_f32vector(vector))

- if(pmt_is_c32vector(vector))

- if(!pmt::pmt_is_pair(msg)){

-// pmt::pmt_print(msg);

- pmt::pmt_t meta(pmt::pmt_car(msg)); // make sure this is NIL || Dict ?

- pmt::pmt_t vect(pmt::pmt_cdr(msg)); // make sure this is a vector?

- add_item_tag(0, offset, pdu_length_tag, pmt::pmt_from_long( pmt::pmt_length(vect) ), pmt::mp(alias()));

- if( !pmt_eq(meta, pmt::PMT_NIL) ){

- pmt::pmt_t pair(pmt::pmt_dict_keys( meta ));

- while( !pmt_eq(pair, pmt::PMT_NIL) ){

- pmt::pmt_t k(pmt::pmt_cdr(pair));

- pmt::pmt_t v(pmt::pmt_dict_ref(meta, k, pmt::PMT_NIL));

- size_t ncopy = std::min((size_t)noutput_items, (size_t)pmt::pmt_length(vect));

- size_t nsave = pmt::pmt_length(vect) - ncopy;

- memcpy(out, pmt_uniform_vector_elements(vect,io), ncopy*d_itemsize);

- memcpy(&d_remain[0], pmt_uniform_vector_elements(vect,ncopy), nsave*d_itemsize);

- pmt::pmt_t vector = pmt::pmt_init_u8vector(bytes_transferred, (const uint8_t*)&buf[0]);

- pmt::pmt_t pdu = pmt::pmt_cons( pmt::PMT_NIL, vector);

- pmt::pmt_t vector = pmt::pmt_cdr(msg);

- pmt::pmt_t vector = pmt::pmt_cdr(msg);

- size_t len = pmt::pmt_length(vector);

- memcpy(&txbuf[0], pmt::pmt_uniform_vector_elements(vector, offset), len);

- pmt::pmt_t vector = pmt::pmt_cdr(msg);

- size_t len = pmt::pmt_length(vector);

- memcpy(&txbuf[0], pmt::pmt_uniform_vector_elements(vector, offset), len);

- size_t len = pmt::pmt_length(vector);

- memcpy(&txbuf[0], pmt::pmt_uniform_vector_elements(vector, offset), len);

- pmt::pmt_t vector = pmt::pmt_init_u8vector(bytes_transferred, (const uint8_t*)&rxbuf[0]);

- pmt::pmt_t pdu = pmt::pmt_cons( pmt::PMT_NIL, vector);

- pmt::pmt_t vector = pmt::pmt_init_u8vector(bytes_transferred, (const uint8_t*)&rxbuf[0]);

- pmt::pmt_t pdu = pmt::pmt_cons( pmt::PMT_NIL, vector);

- pmt::pmt_t vector = pmt::pmt_init_u8vector(result, &d_rxbuf[0]);

- pmt::pmt_t pdu = pmt::pmt_cons( pmt::PMT_NIL, vector);

- pmt::pmt_t vector = pmt::pmt_cdr(msg);

- int len( pmt::pmt_length(vector)*itemsize );

- const int rv = write(d_fd, pmt::pmt_uniform_vector_elements(vector, offset), len);

- pmt::pmt_t bkey = pmt::pmt_string_to_symbol("burst");

- pmt::pmt_t tkey = pmt::pmt_string_to_symbol("rx_time"); // use gr_tags::key_time

- uint64_t tsecs = pmt::pmt_to_uint64(pmt::pmt_tuple_ref(time, 0));

- double tfrac = pmt::pmt_to_double(pmt::pmt_tuple_ref(time, 1));

- if((pmt::pmt_eqv((*vitr).key, bkey)) &&

- pmt::pmt_is_true((*vitr).value)) {

- uint64_t tsecs = pmt::pmt_to_uint64(pmt::pmt_tuple_ref(time, 0));

- double tfrac = pmt::pmt_to_double(pmt::pmt_tuple_ref(time, 1));

- if((pmt::pmt_eqv((*vitr).key, bkey)) &&

- pmt::pmt_is_false((*vitr).value)) {

- if( pmt::pmt_equal( (*d_tags_itr).key, pdu_length_tag ) ){

- d_pdu_length = pmt::pmt_to_long( (*d_tags_itr).value );

- d_pdu_meta = pmt::pmt_make_dict();

- if( ! pmt_equal( (*d_tags_itr).key, pdu_length_tag ) ){

- d_pdu_meta = pmt_dict_add(d_pdu_meta, (*d_tags_itr).key, (*d_tags_itr).value);

- if(pmt::pmt_length(d_pdu_vector) != d_pdu_length){

- pmt::pmt_t msg = pmt::pmt_cons( d_pdu_meta, d_pdu_vector );

-using namespace pmt;

-

- message_subscribers(pmt::pmt_make_dict())

- if(!pmt::pmt_is_symbol(port_id)) {

- pmt::pmt_t port_names = pmt::pmt_make_vector(msg_queue.size(), pmt::PMT_NIL);

- pmt::pmt_vector_set(port_names, i, (*itr).first);

- if(!pmt::pmt_is_symbol(port_id)) {

- if(pmt::pmt_dict_has_key(message_subscribers, port_id)) {

- message_subscribers = pmt::pmt_dict_add(message_subscribers, port_id, pmt::PMT_NIL);

- size_t len = pmt::pmt_length(message_subscribers);

- pmt::pmt_t port_names = pmt::pmt_make_vector(len, pmt::PMT_NIL);

- pmt::pmt_t keys = pmt::pmt_dict_keys(message_subscribers);

- pmt::pmt_vector_set(port_names, i, pmt::pmt_nth(i, keys));

- if(!pmt::pmt_dict_has_key(message_subscribers, port_id)) {

- pmt::pmt_t currlist = pmt::pmt_dict_ref(message_subscribers, port_id, pmt::PMT_NIL);

- while(pmt::pmt_is_pair(currlist)) {

- pmt::pmt_t target = pmt::pmt_car(currlist);

- pmt::pmt_t block = pmt::pmt_car(target);

- pmt::pmt_t port = pmt::pmt_cdr(target);

- currlist = pmt::pmt_cdr(currlist);

- if(!pmt::pmt_dict_has_key(message_subscribers, port_id)){

- ss << "Port does not exist: \"" << pmt::pmt_write_string(port_id) << "\" on block: " << pmt::pmt_write_string(target) << std::endl;

- pmt::pmt_t currlist = pmt::pmt_dict_ref(message_subscribers,port_id,pmt::PMT_NIL);

- if(!pmt::pmt_list_has(currlist, target))

- message_subscribers = pmt::pmt_dict_add(message_subscribers,port_id,pmt::pmt_list_add(currlist,target));

- if(!pmt::pmt_dict_has_key(message_subscribers, port_id)){

- ss << "Port does not exist: \"" << pmt::pmt_write_string(port_id) << "\" on block: " << pmt::pmt_write_string(target) << std::endl;

- pmt::pmt_t currlist = pmt::pmt_dict_ref(message_subscribers,port_id,pmt::PMT_NIL);

- message_subscribers = pmt::pmt_dict_add(message_subscribers,port_id,pmt::pmt_list_rm(currlist,target));

-gr_basic_block::_post(pmt_t which_port, pmt_t msg)

- std::cout << "target port = " << pmt::pmt_symbol_to_string(which_port) << std::endl;

-pmt_t

- pmt_t m(msg_queue[which_port].front());

-pmt_t

- pmt_t m(msg_queue[which_port].front());

- typedef std::map<pmt::pmt_t , msg_handler_t, pmt::pmt_comperator> d_msg_handlers_t;

- typedef std::map<pmt::pmt_t, msg_queue_t, pmt::pmt_comperator> msg_queue_map_t;

- typedef std::map<pmt::pmt_t, msg_queue_t, pmt::pmt_comperator>::iterator msg_queue_map_itr;

- std::map<pmt::pmt_t, boost::shared_ptr<boost::condition_variable>, pmt::pmt_comperator> msg_queue_ready;

- pmt::pmt_t alias_pmt(){ return pmt::pmt_intern(alias()); }

- if(pmt::pmt_dict_has_key(message_subscribers, which_port)){

-using namespace pmt;

-

- if(!pmt_is_symbol(tag.key)) {

- throw pmt_wrong_type("gr_block_detail::add_item_tag key", tag.key);

- const pmt_t &key)

- pmt_t itemkey;

- if(pmt_eqv(key, itemkey)) {

- d_ref_map = pmt::pmt_make_dict();

- d_ref_map = pmt::pmt_dict_delete(d_ref_map, pmt::pmt_intern(block->symbol_name()));

- d_ref_map = pmt::pmt_dict_delete(d_ref_map, pmt::pmt_intern(block->alias()));

- if(pmt_dict_has_key(d_ref_map, pmt::pmt_intern(name))){

- d_ref_map = pmt_dict_add(d_ref_map, pmt::pmt_intern(name), pmt::pmt_make_any(block));

- pmt::pmt_t ref = pmt_dict_ref(d_ref_map, symbol, pmt::PMT_NIL);

- if(pmt::pmt_eq(ref, pmt::PMT_NIL)){

- gr_basic_block* blk = boost::any_cast<gr_basic_block*>( pmt::pmt_any_ref(ref) );

- i->src().block()->message_port_sub( i->src().port(), pmt::pmt_cons(i->dst().block()->alias_pmt(), i->dst().port()) );

- pmt::pmt_equal(d_port, other.d_port));

- if(!pmt::pmt_is_symbol(srcport)){throw std::runtime_error("bad port id"); }

- if(!pmt::pmt_is_symbol(srcport)){throw std::runtime_error("bad port id"); }

- return pmt::pmt_list_has(hier_message_ports_in, port_id);

- return pmt::pmt_list_has(hier_message_ports_out, port_id);

- if(pmt::pmt_list_has(hier_message_ports_in, port_id))

- hier_message_ports_in = pmt::pmt_list_add(hier_message_ports_in, port_id);

- if(pmt::pmt_list_has(hier_message_ports_out, port_id))

- if(pmt::pmt_dict_has_key(message_subscribers, port_id))

- hier_message_ports_out = pmt::pmt_list_add(hier_message_ports_out, port_id);

-// src->message_port_sub(srcport, pmt::pmt_cons(dst->alias_pmt(), dstport));

- src->message_port_unsub(srcport, pmt::pmt_cons(dst->alias_pmt(), dstport));

- return pmt::pmt_init_f32vector(_val.size(), &_val[0]);

- return pmt::pmt_init_c32vector(_val.size(), &_val[0]);

-using namespace pmt;

-

- pmt_t port(pmt_intern("port"));

- send(nop, port, mp(mp("example-msg"), mp(i)));

- if(pmt::pmt_is_real(knob)) {

- return new GNURadio::KnobD(Ice::Double(pmt::pmt_to_double(knob)));

- else if(pmt::pmt_is_symbol(knob)) {

- std::string stuff = pmt::pmt_symbol_to_string(knob);

- else if(pmt::pmt_is_integer(knob)) {

- return new GNURadio::KnobI(pmt::pmt_to_long(knob));

- else if(pmt::pmt_is_bool(knob)) {

- return new GNURadio::KnobB(pmt::pmt_to_bool(knob));

- else if(pmt::pmt_is_uint64(knob)) {

- return new GNURadio::KnobL(pmt::pmt_to_uint64(knob));

- //const std::complex<float> *pmt_c32vector_elements(pmt_t v, size_t &len); //< len is in elements

- else if(pmt::pmt_is_c32vector(knob)) { // c32 sent as interleaved floats

- size_t size(pmt::pmt_length(knob));

- const float* start((const float*) pmt::pmt_c32vector_elements(knob,size));

- else if(pmt::pmt_is_f32vector(knob)) {

- size_t size(pmt::pmt_length(knob));

- const float* start((const float*) pmt::pmt_f32vector_elements(knob,size));

- return pmt::pmt_string_to_symbol(k->value);

- (pmt::pmt_to_double(msg));

- (pmt::pmt_to_double(msg));

- (pmt::pmt_to_long(msg));

- (pmt::pmt_to_long(msg));

- (pmt::pmt_to_bool(msg));

- _source->*rpcextractor_base<T,std::complex<double> >::_func)(pmt::pmt_to_complex(msg));

- _source->*rpcextractor_base<T,std::string>::_func)(pmt::pmt_symbol_to_string(msg));

- return pmt::pmt_from_uint64((rpcinserter_base<T,uint64_t>::

- _source->*rpcinserter_base<T,uint64_t>::_func)());

- return pmt::pmt_init_c32vector(vec.size(), &vec[0]);

- return pmt::pmt_init_f32vector(vec.size(), &vec[0]);

- key = pmt.pmt_string_to_symbol("example_key")

- value = pmt.pmt_string_to_symbol("example_value")

- #print pmt.pmt_symbol_to_string(tag.key)

- #print pmt.pmt_symbol_to_string(tag.value)

- self.key = pmt.pmt_symbol_to_string(tag.key)

- self.assertEqual(pmt.pmt_length(pi), 2)

- self.assertEqual(pmt.pmt_length(po), 0)

- self.assertEqual(pmt.pmt_length(pi), 0)

- self.assertEqual(pmt.pmt_length(po), 1)

- #pmt.pmt_print(pi)

- #pmt.pmt_print(po)

- #pmt.pmt_print(pi)

- #pmt.pmt_print(po)

- port = pmt.pmt_intern("pdus")

- msg = pmt.pmt_cons( pmt.PMT_NIL, pmt.pmt_make_u8vector(16, 0xFF) )

- #pmt.pmt_print(port)

- #pmt.pmt_print(msg)

- msg_vec = pmt.pmt_cdr(result_msg)

- pmt.pmt_print(msg_vec)

- msg_data.append(pmt.pmt_u8vector_ref(msg_vec, i))

- pmt_t timestamp = pmt_make_tuple(pmt_from_uint64(0),

- pmt_from_double(0));

- d_extra = pmt_make_dict();

- pmt_t extras = pmt_deserialize_str(extra_dict);

- pmt_t keys = pmt_dict_keys(extras);

- pmt_t vals = pmt_dict_values(extras);

- size_t nitems = pmt_length(keys);

- d_extra = pmt_dict_add(d_extra,

- pmt_nth(i, keys),

- pmt_nth(i, vals));

- d_extra_size = pmt_serialize_str(d_extra).size();

- d_header = pmt_make_dict();

- d_header = pmt_dict_add(d_header, mp("version"), mp(METADATA_VERSION));

- d_header = pmt_dict_add(d_header, mp("rx_rate"), mp(samp_rate));

- d_header = pmt_dict_add(d_header, mp("rx_time"), timestamp);

- d_header = pmt_dict_add(d_header, mp("size"), pmt_from_long(d_itemsize));

- d_header = pmt_dict_add(d_header, mp("type"), pmt_from_long(type));

- d_header = pmt_dict_add(d_header, mp("cplx"), complex ? PMT_T : PMT_F);

- d_header = pmt_dict_add(d_header, mp("strt"), pmt_from_uint64(METADATA_HEADER_SIZE+d_extra_size));

- d_header = pmt_dict_add(d_header, mp("bytes"), pmt_from_uint64(0));

- file_meta_sink_impl::write_header(FILE *fp, pmt_t header, pmt_t extra)

- std::string header_str = pmt_serialize_str(header);

- std::string extra_str = pmt_serialize_str(extra);

- file_meta_sink_impl::update_header(pmt_t key, pmt_t value)

- if(pmt_eq(key, mp("rx_rate"))) {

- d_samp_rate = pmt_to_double(value);

- value = pmt_from_double(d_samp_rate*d_relative_rate);

- if(pmt_dict_has_key(d_header, key)) {

- d_header = pmt_dict_add(d_header, key, value);

- d_extra = pmt_dict_add(d_extra, key, value);

- d_extra_size = pmt_serialize_str(d_extra).size();

- size_t hdrlen = pmt_to_uint64(pmt_dict_ref(d_header, mp("strt"), PMT_NIL));

- pmt_t s = pmt_from_uint64(seg_size);

- update_header(mp("strt"), pmt_from_uint64(METADATA_HEADER_SIZE+d_extra_size));

- size_t hdrlen = pmt_to_uint64(pmt_dict_ref(d_header, mp("strt"), PMT_NIL));

- pmt_t s = pmt_from_uint64(seg_size);

- update_header(mp("strt"), pmt_from_uint64(METADATA_HEADER_SIZE+d_extra_size));

- pmt_t s = pmt_from_uint64(0);

- s = pmt_from_uint64(METADATA_HEADER_SIZE + d_extra_size);

- pmt_t rx_time = pmt_string_to_symbol("rx_time");

- pmt_t r = pmt_dict_ref(d_header, rx_time, PMT_NIL);

- uint64_t secs = pmt_to_uint64(pmt_tuple_ref(r, 0));

- double fracs = pmt_to_double(pmt_tuple_ref(r, 1));

- r = pmt_make_tuple(pmt_from_uint64(secs), pmt_from_double(fracs));

- d_header = pmt_dict_add(d_header, rx_time, r);

- pmt_t hdr = PMT_NIL, extras = PMT_NIL;

- file_meta_source_impl::read_header(pmt_t &hdr, pmt_t &extras)

- hdr = pmt_deserialize_str(str);

- pmt_t r, dump;

- if(pmt_dict_has_key(hdr, pmt_string_to_symbol("strt"))) {

- r = pmt_dict_ref(hdr, pmt_string_to_symbol("strt"), dump);

- seg_start = pmt_to_uint64(r);

- extras = pmt_deserialize_str(str);

- file_meta_source_impl::parse_header(pmt_t hdr, uint64_t offset,

- pmt_t r, key;

- key = pmt_string_to_symbol("rx_rate");

- if(pmt_dict_has_key(hdr, key)) {

- r = pmt_dict_ref(hdr, key, PMT_NIL);

- d_samp_rate = pmt_to_double(r);

- key = pmt_string_to_symbol("rx_time");

- if(pmt_dict_has_key(hdr, key)) {

- d_time_stamp = pmt_dict_ref(hdr, key, PMT_NIL);

- if(pmt_dict_has_key(hdr, pmt_string_to_symbol("size"))) {

- d_itemsize = pmt_to_long(pmt_dict_ref(hdr, pmt_string_to_symbol("size"), PMT_NIL));

- if(pmt_dict_has_key(hdr, pmt_string_to_symbol("bytes"))) {

- d_seg_size = pmt_to_uint64(pmt_dict_ref(hdr, pmt_string_to_symbol("bytes"), PMT_NIL));

- file_meta_source_impl::parse_extras(pmt_t extras, uint64_t offset,

- pmt_t item, key, val;

- size_t nitems = pmt_length(extras);

- item = pmt_nth(i, extras);

- key = pmt_car(item);

- val = pmt_cdr(item);

- pmt_t hdr=PMT_NIL, extras=PMT_NIL;

- if(pmt.pmt_is_dict(p) is False):

- if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("version"))):

- r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("version"), dump)

- version = pmt.pmt_to_long(r)

- if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("rx_rate"))):

- r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("rx_rate"), dump)

- samp_rate = pmt.pmt_to_double(r)

- if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("rx_time"))):

- r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("rx_time"), dump)

- pmt_secs = pmt.pmt_tuple_ref(r, 0)

- pmt_fracs = pmt.pmt_tuple_ref(r, 1)

- secs = float(pmt.pmt_to_uint64(pmt_secs))

- fracs = pmt.pmt_to_double(pmt_fracs)

- if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("size"))):

- r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("size"), dump)

- dsize = pmt.pmt_to_long(r)

- if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("type"))):

- r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("type"), dump)

- dtype = pmt.pmt_to_long(r)

- if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("cplx"))):

- r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("cplx"), dump)

- cplx = pmt.pmt_to_bool(r)

- if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("strt"))):

- r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("strt"), dump)

- seg_start = pmt.pmt_to_uint64(r)

- if(pmt.pmt_dict_has_key(p, pmt.pmt_string_to_symbol("bytes"))):

- r = pmt.pmt_dict_ref(p, pmt.pmt_string_to_symbol("bytes"), dump)

- nbytes = pmt.pmt_to_uint64(r)

- if(pmt.pmt_is_dict(p) is False):

- items = pmt.pmt_dict_items(p)

- nitems = pmt.pmt_length(items)

- item = pmt.pmt_nth(i, items)

- key = pmt.pmt_symbol_to_string(pmt.pmt_car(item))

- val = pmt.pmt_cdr(item)

- print "{0}: ".format(key)

- pmt.pmt_print(val)

- key = pmt.pmt_intern("samp_rate")

- val = pmt.pmt_from_double(samp_rate)

- extras = pmt.pmt_make_dict()

- extras = pmt.pmt_dict_add(extras, key, val)

- extras_str = pmt.pmt_serialize_str(extras)

- header = pmt.pmt_deserialize_str(header_str)

- extra = pmt.pmt_deserialize_str(extra_str)

- self.assertEqual(pmt.pmt_to_double(extra_info['samp_rate']), samp_rate)

- if(pmt.pmt_eq(t.key, pmt.pmt_intern("samp_rate"))):

- self.assertEqual(pmt.pmt_to_double(t.value), samp_rate)

- elif(pmt.pmt_eq(t.key, pmt.pmt_intern("rx_rate"))):

- self.assertEqual(pmt.pmt_to_double(t.value), samp_rate)

- key = pmt.pmt_intern("samp_rate")

- val = pmt.pmt_from_double(samp_rate)

- extras = pmt.pmt_make_dict()

- extras = pmt.pmt_dict_add(extras, key, val)

- extras_str = pmt.pmt_serialize_str(extras)

- header = pmt.pmt_deserialize_str(header_str)

- extra = pmt.pmt_deserialize_str(extra_str)

- self.assertEqual(pmt.pmt_to_double(extra_info['samp_rate']), samp_rate)

- if(pmt.pmt_eq(t.key, pmt.pmt_intern("samp_rate"))):

- self.assertEqual(pmt.pmt_to_double(t.value), samp_rate)

- elif(pmt.pmt_eq(t.key, pmt.pmt_intern("rx_rate"))):

- self.assertEqual(pmt.pmt_to_double(t.value), samp_rate)

- pmt::pmt_make_c32vector(0,-10),

- pmt::pmt_make_c32vector(0,10),

- pmt::pmt_make_c32vector(0,0),

- d_me = pmt::pmt_string_to_symbol(str.str());

- d_key = pmt::pmt_string_to_symbol(tag_name);

- d_me = pmt::pmt_string_to_symbol(str.str());

- d_key = pmt::pmt_string_to_symbol("snr");

- pmt::pmt_t pmt_snr = pmt::pmt_from_double(d_snr_est->snr());

- d_key = pmt::pmt_string_to_symbol("snr");

- get_tags_in_range(rx_time_tags, 0, samp0_count, samp0_count + ninput_items, pmt::pmt_string_to_symbol("rx_time"));

- % pmt::pmt_to_uint64(pmt::pmt_tuple_ref(value, 0))

- % pmt::pmt_to_double(pmt::pmt_tuple_ref(value, 1))

- const pmt::pmt_t key = pmt::pmt_string_to_symbol("tx_time");

- const pmt::pmt_t value = pmt::pmt_make_tuple(

- pmt::pmt_from_uint64(_time_secs),

- pmt::pmt_from_double(_time_fracs)

- const pmt::pmt_t srcid = pmt::pmt_string_to_symbol(this->name());

- const pmt::pmt_t key = pmt::pmt_string_to_symbol("tx_sob");

- const pmt::pmt_t srcid = pmt::pmt_string_to_symbol(this->name());

- const pmt::pmt_t key = pmt::pmt_string_to_symbol("tx_eob");

- const pmt::pmt_t srcid = pmt::pmt_string_to_symbol(this->name());

-static const pmt::pmt_t SOB_KEY = pmt::pmt_string_to_symbol("tx_sob");

-static const pmt::pmt_t EOB_KEY = pmt::pmt_string_to_symbol("tx_eob");

-static const pmt::pmt_t TIME_KEY = pmt::pmt_string_to_symbol("tx_time");

- else if (pmt::pmt_equal(key, EOB_KEY)){

- _metadata.end_of_burst = pmt::pmt_to_bool(value);

- else if (pmt::pmt_equal(key, SOB_KEY)){

- _metadata.start_of_burst = pmt::pmt_to_bool(value);

- else if (pmt::pmt_equal(key, TIME_KEY)){

- pmt::pmt_to_uint64(pmt::pmt_tuple_ref(value, 0)),

- pmt::pmt_to_double(pmt::pmt_tuple_ref(value, 1))

-static const pmt::pmt_t TIME_KEY = pmt::pmt_string_to_symbol("rx_time");

-static const pmt::pmt_t RATE_KEY = pmt::pmt_string_to_symbol("rx_rate");

-static const pmt::pmt_t FREQ_KEY = pmt::pmt_string_to_symbol("rx_freq");

- _id = pmt::pmt_string_to_symbol(str.str());

- const pmt::pmt_t val = pmt::pmt_make_tuple(

- pmt::pmt_from_uint64(_metadata.time_spec.get_full_secs()),

- pmt::pmt_from_double(_metadata.time_spec.get_frac_secs())

- this->add_item_tag(i, nitems_written(0), RATE_KEY, pmt::pmt_from_double(_samp_rate), _id);

- this->add_item_tag(i, nitems_written(0), FREQ_KEY, pmt::pmt_from_double(_center_freq), _id);

- header = pmt.pmt_deserialize_str(header_str)

- extra = pmt.pmt_deserialize_str(extra_str)

- * \param accepter is the target of the send. precond: pmt_is_msg_accepter(accepter)

- return send(pmt_msg_accepter_ref(accepter), which_port, msg);

-class GRUEL_API pmt_exception : public std::logic_error

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

-class GRUEL_API pmt_wrong_type : public pmt_exception

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

-class GRUEL_API pmt_out_of_range : public pmt_exception

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

-class GRUEL_API pmt_notimplemented : public pmt_exception

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

-GRUEL_API bool pmt_is_bool(pmt_t obj);

-GRUEL_API bool pmt_is_true(pmt_t obj);

-GRUEL_API bool pmt_is_false(pmt_t obj);

-GRUEL_API pmt_t pmt_from_bool(bool val);

-//! Return true if val is PMT_T, return false when val is PMT_F,

-GRUEL_API bool pmt_to_bool(pmt_t val);

-GRUEL_API bool pmt_is_symbol(const pmt_t& obj);

-GRUEL_API pmt_t pmt_string_to_symbol(const std::string &s);

-GRUEL_API pmt_t pmt_intern(const std::string &s);

-GRUEL_API const std::string pmt_symbol_to_string(const pmt_t& sym);

-GRUEL_API bool pmt_is_number(pmt_t obj);

-GRUEL_API bool pmt_is_integer(pmt_t x);

-GRUEL_API pmt_t pmt_from_long(long x);

-GRUEL_API long pmt_to_long(pmt_t x);

-GRUEL_API bool pmt_is_uint64(pmt_t x);

-GRUEL_API pmt_t pmt_from_uint64(uint64_t x);

-GRUEL_API uint64_t pmt_to_uint64(pmt_t x);

-GRUEL_API bool pmt_is_real(pmt_t obj);

-GRUEL_API pmt_t pmt_from_double(double x);

-GRUEL_API double pmt_to_double(pmt_t x);

-GRUEL_API bool pmt_is_complex(pmt_t obj);

-GRUEL_API pmt_t pmt_make_rectangular(double re, double im);

-GRUEL_API std::complex<double> pmt_to_complex(pmt_t z);

-GRUEL_API bool pmt_is_null(const pmt_t& x);

-GRUEL_API bool pmt_is_pair(const pmt_t& obj);

-GRUEL_API pmt_t pmt_cons(const pmt_t& x, const pmt_t& y);

-GRUEL_API pmt_t pmt_car(const pmt_t& pair);

-GRUEL_API pmt_t pmt_cdr(const pmt_t& pair);

-GRUEL_API void pmt_set_car(pmt_t pair, pmt_t value);

-GRUEL_API void pmt_set_cdr(pmt_t pair, pmt_t value);

-GRUEL_API pmt_t pmt_caar(pmt_t pair);

-GRUEL_API pmt_t pmt_cadr(pmt_t pair);

-GRUEL_API pmt_t pmt_cdar(pmt_t pair);

-GRUEL_API pmt_t pmt_cddr(pmt_t pair);

-GRUEL_API pmt_t pmt_caddr(pmt_t pair);

-GRUEL_API pmt_t pmt_cadddr(pmt_t pair);

-GRUEL_API bool pmt_is_tuple(pmt_t x);

-GRUEL_API pmt_t pmt_make_tuple();

-GRUEL_API pmt_t pmt_make_tuple(const pmt_t &e0);

-GRUEL_API pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1);

-GRUEL_API pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2);

-GRUEL_API pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3);

-GRUEL_API pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4);

-GRUEL_API pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5);

-GRUEL_API pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6);

-GRUEL_API pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7);

-GRUEL_API pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8);

-GRUEL_API pmt_t pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8, const pmt_t &e9);

-GRUEL_API pmt_t pmt_to_tuple(const pmt_t &x);

-GRUEL_API pmt_t pmt_tuple_ref(const pmt_t &tuple, size_t k);

-GRUEL_API bool pmt_is_vector(pmt_t x);

-GRUEL_API pmt_t pmt_make_vector(size_t k, pmt_t fill);

-GRUEL_API pmt_t pmt_vector_ref(pmt_t vector, size_t k);

-GRUEL_API void pmt_vector_set(pmt_t vector, size_t k, pmt_t obj);

-GRUEL_API void pmt_vector_fill(pmt_t vector, pmt_t fill);

-GRUEL_API bool pmt_is_blob(pmt_t x);

-GRUEL_API pmt_t pmt_make_blob(const void *buf, size_t len);

-GRUEL_API const void *pmt_blob_data(pmt_t blob);

-GRUEL_API size_t pmt_blob_length(pmt_t blob);

-GRUEL_API bool pmt_is_uniform_vector(pmt_t x);

-

-GRUEL_API bool pmt_is_u8vector(pmt_t x);

-GRUEL_API bool pmt_is_s8vector(pmt_t x);

-GRUEL_API bool pmt_is_u16vector(pmt_t x);

-GRUEL_API bool pmt_is_s16vector(pmt_t x);

-GRUEL_API bool pmt_is_u32vector(pmt_t x);

-GRUEL_API bool pmt_is_s32vector(pmt_t x);

-GRUEL_API bool pmt_is_u64vector(pmt_t x);

-GRUEL_API bool pmt_is_s64vector(pmt_t x);

-GRUEL_API bool pmt_is_f32vector(pmt_t x);

-GRUEL_API bool pmt_is_f64vector(pmt_t x);

-GRUEL_API bool pmt_is_c32vector(pmt_t x);

-GRUEL_API bool pmt_is_c64vector(pmt_t x);

-

-GRUEL_API pmt_t pmt_make_u8vector(size_t k, uint8_t fill);

-GRUEL_API pmt_t pmt_make_s8vector(size_t k, int8_t fill);

-GRUEL_API pmt_t pmt_make_u16vector(size_t k, uint16_t fill);

-GRUEL_API pmt_t pmt_make_s16vector(size_t k, int16_t fill);

-GRUEL_API pmt_t pmt_make_u32vector(size_t k, uint32_t fill);

-GRUEL_API pmt_t pmt_make_s32vector(size_t k, int32_t fill);

-GRUEL_API pmt_t pmt_make_u64vector(size_t k, uint64_t fill);

-GRUEL_API pmt_t pmt_make_s64vector(size_t k, int64_t fill);

-GRUEL_API pmt_t pmt_make_f32vector(size_t k, float fill);

-GRUEL_API pmt_t pmt_make_f64vector(size_t k, double fill);

-GRUEL_API pmt_t pmt_make_c32vector(size_t k, std::complex<float> fill);

-GRUEL_API pmt_t pmt_make_c64vector(size_t k, std::complex<double> fill);

-

-GRUEL_API pmt_t pmt_init_u8vector(size_t k, const uint8_t *data);

-GRUEL_API pmt_t pmt_init_u8vector(size_t k, const std::vector<uint8_t> &data);

-GRUEL_API pmt_t pmt_init_s8vector(size_t k, const int8_t *data);

-GRUEL_API pmt_t pmt_init_s8vector(size_t k, const std::vector<int8_t> &data);

-GRUEL_API pmt_t pmt_init_u16vector(size_t k, const uint16_t *data);

-GRUEL_API pmt_t pmt_init_u16vector(size_t k, const std::vector<uint16_t> &data);

-GRUEL_API pmt_t pmt_init_s16vector(size_t k, const int16_t *data);

-GRUEL_API pmt_t pmt_init_s16vector(size_t k, const std::vector<int16_t> &data);

-GRUEL_API pmt_t pmt_init_u32vector(size_t k, const uint32_t *data);

-GRUEL_API pmt_t pmt_init_u32vector(size_t k, const std::vector<uint32_t> &data);

-GRUEL_API pmt_t pmt_init_s32vector(size_t k, const int32_t *data);

-GRUEL_API pmt_t pmt_init_s32vector(size_t k, const std::vector<int32_t> &data);

-GRUEL_API pmt_t pmt_init_u64vector(size_t k, const uint64_t *data);

-GRUEL_API pmt_t pmt_init_u64vector(size_t k, const std::vector<uint64_t> &data);

-GRUEL_API pmt_t pmt_init_s64vector(size_t k, const int64_t *data);

-GRUEL_API pmt_t pmt_init_s64vector(size_t k, const std::vector<int64_t> &data);

-GRUEL_API pmt_t pmt_init_f32vector(size_t k, const float *data);

-GRUEL_API pmt_t pmt_init_f32vector(size_t k, const std::vector<float> &data);

-GRUEL_API pmt_t pmt_init_f64vector(size_t k, const double *data);

-GRUEL_API pmt_t pmt_init_f64vector(size_t k, const std::vector<double> &data);

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

-GRUEL_API pmt_t pmt_init_c32vector(size_t k, const std::vector<std::complex<float> > &data);

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

-GRUEL_API pmt_t pmt_init_c64vector(size_t k, const std::vector<std::complex<double> > &data);

-

-GRUEL_API uint8_t pmt_u8vector_ref(pmt_t v, size_t k);

-GRUEL_API int8_t pmt_s8vector_ref(pmt_t v, size_t k);

-GRUEL_API uint16_t pmt_u16vector_ref(pmt_t v, size_t k);

-GRUEL_API int16_t pmt_s16vector_ref(pmt_t v, size_t k);

-GRUEL_API uint32_t pmt_u32vector_ref(pmt_t v, size_t k);

-GRUEL_API int32_t pmt_s32vector_ref(pmt_t v, size_t k);

-GRUEL_API uint64_t pmt_u64vector_ref(pmt_t v, size_t k);

-GRUEL_API int64_t pmt_s64vector_ref(pmt_t v, size_t k);

-GRUEL_API float pmt_f32vector_ref(pmt_t v, size_t k);

-GRUEL_API double pmt_f64vector_ref(pmt_t v, size_t k);

-GRUEL_API std::complex<float> pmt_c32vector_ref(pmt_t v, size_t k);

-GRUEL_API std::complex<double> pmt_c64vector_ref(pmt_t v, size_t k);

-

-GRUEL_API void pmt_u8vector_set(pmt_t v, size_t k, uint8_t x); //< v[k] = x

-GRUEL_API void pmt_s8vector_set(pmt_t v, size_t k, int8_t x);

-GRUEL_API void pmt_u16vector_set(pmt_t v, size_t k, uint16_t x);

-GRUEL_API void pmt_s16vector_set(pmt_t v, size_t k, int16_t x);

-GRUEL_API void pmt_u32vector_set(pmt_t v, size_t k, uint32_t x);

-GRUEL_API void pmt_s32vector_set(pmt_t v, size_t k, int32_t x);

-GRUEL_API void pmt_u64vector_set(pmt_t v, size_t k, uint64_t x);

-GRUEL_API void pmt_s64vector_set(pmt_t v, size_t k, int64_t x);

-GRUEL_API void pmt_f32vector_set(pmt_t v, size_t k, float x);

-GRUEL_API void pmt_f64vector_set(pmt_t v, size_t k, double x);

-GRUEL_API void pmt_c32vector_set(pmt_t v, size_t k, std::complex<float> x);

-GRUEL_API void pmt_c64vector_set(pmt_t v, size_t k, std::complex<double> x);

-GRUEL_API const void *pmt_uniform_vector_elements(pmt_t v, size_t &len); //< works with any; len is in bytes

-

-GRUEL_API const uint8_t *pmt_u8vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const int8_t *pmt_s8vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const uint16_t *pmt_u16vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const int16_t *pmt_s16vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const uint32_t *pmt_u32vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const int32_t *pmt_s32vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const uint64_t *pmt_u64vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const int64_t *pmt_s64vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const float *pmt_f32vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const double *pmt_f64vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const std::complex<float> *pmt_c32vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API const std::complex<double> *pmt_c64vector_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API void *pmt_uniform_vector_writable_elements(pmt_t v, size_t &len); //< works with any; len is in bytes

-

-GRUEL_API uint8_t *pmt_u8vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API int8_t *pmt_s8vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API uint16_t *pmt_u16vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API int16_t *pmt_s16vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API uint32_t *pmt_u32vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API int32_t *pmt_s32vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API uint64_t *pmt_u64vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API int64_t *pmt_s64vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API float *pmt_f32vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API double *pmt_f64vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API std::complex<float> *pmt_c32vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API std::complex<double> *pmt_c64vector_writable_elements(pmt_t v, size_t &len); //< len is in elements

-GRUEL_API bool pmt_is_dict(const pmt_t &obj);

-GRUEL_API pmt_t pmt_make_dict();

-GRUEL_API pmt_t pmt_dict_add(const pmt_t &dict, const pmt_t &key, const pmt_t &value);

-GRUEL_API pmt_t pmt_dict_delete(const pmt_t &dict, const pmt_t &key);

-GRUEL_API bool pmt_dict_has_key(const pmt_t &dict, const pmt_t &key);

-GRUEL_API pmt_t pmt_dict_ref(const pmt_t &dict, const pmt_t &key, const pmt_t &not_found);

-GRUEL_API pmt_t pmt_dict_items(pmt_t dict);

-GRUEL_API pmt_t pmt_dict_keys(pmt_t dict);

-GRUEL_API pmt_t pmt_dict_values(pmt_t dict);

-GRUEL_API bool pmt_is_any(pmt_t obj);

-GRUEL_API pmt_t pmt_make_any(const boost::any &any);

-GRUEL_API boost::any pmt_any_ref(pmt_t obj);

-GRUEL_API void pmt_any_set(pmt_t obj, const boost::any &any);

-GRUEL_API bool pmt_is_msg_accepter(const pmt_t &obj);

-GRUEL_API pmt_t pmt_make_msg_accepter(boost::shared_ptr<gruel::msg_accepter> ma);

-GRUEL_API boost::shared_ptr<gruel::msg_accepter> pmt_msg_accepter_ref(const pmt_t &obj);

-GRUEL_API bool pmt_eq(const pmt_t& x, const pmt_t& y);

-GRUEL_API bool pmt_eqv(const pmt_t& x, const pmt_t& y);

- * pmt_equal recursively compares the contents of pairs and vectors,

- * applying pmt_eqv on other objects such as numbers and symbols.

- * pmt_equal may fail to terminate if its arguments are circular data

-GRUEL_API bool pmt_equal(const pmt_t& x, const pmt_t& y);

-GRUEL_API size_t pmt_length(const pmt_t& v);

- * Uses pmt_eq to compare \p obj with car fields of the pairs in \p alist.

-GRUEL_API pmt_t pmt_assq(pmt_t obj, pmt_t alist);

- * Uses pmt_eqv to compare \p obj with car fields of the pairs in \p alist.

-GRUEL_API pmt_t pmt_assv(pmt_t obj, pmt_t alist);

- * Uses pmt_equal to compare \p obj with car fields of the pairs in \p alist.

-GRUEL_API pmt_t pmt_assoc(pmt_t obj, pmt_t alist);

-GRUEL_API pmt_t pmt_map(pmt_t proc(const pmt_t&), pmt_t list);

-GRUEL_API pmt_t pmt_reverse(pmt_t list);

-GRUEL_API pmt_t pmt_reverse_x(pmt_t list);

-pmt_acons(pmt_t x, pmt_t y, pmt_t a)

- return pmt_cons(pmt_cons(x, y), a);

-GRUEL_API pmt_t pmt_nth(size_t n, pmt_t list);

-GRUEL_API pmt_t pmt_nthcdr(size_t n, pmt_t list);

- * pmt_memq use pmt_eq to compare \p obj with the elements of \p list.

-GRUEL_API pmt_t pmt_memq(pmt_t obj, pmt_t list);

- * pmt_memv use pmt_eqv to compare \p obj with the elements of \p list.

-GRUEL_API pmt_t pmt_memv(pmt_t obj, pmt_t list);

- * pmt_member use pmt_equal to compare \p obj with the elements of \p list.

-GRUEL_API pmt_t pmt_member(pmt_t obj, pmt_t list);

- * Comparisons are done with pmt_eqv.

-GRUEL_API bool pmt_subsetp(pmt_t list1, pmt_t list2);

-GRUEL_API pmt_t pmt_list1(const pmt_t& x1);

-GRUEL_API pmt_t pmt_list2(const pmt_t& x1, const pmt_t& x2);

-GRUEL_API pmt_t pmt_list3(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3);

-GRUEL_API pmt_t pmt_list4(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4);

-GRUEL_API pmt_t pmt_list5(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5);

-GRUEL_API pmt_t pmt_list6(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5, const pmt_t& x6);

-GRUEL_API pmt_t pmt_list_add(pmt_t list, const pmt_t& item);

-GRUEL_API pmt_t pmt_list_rm(pmt_t list, const pmt_t& item);

-GRUEL_API bool pmt_list_has(pmt_t list, const pmt_t& item);

-GRUEL_API bool pmt_is_eof_object(pmt_t obj);

-GRUEL_API pmt_t pmt_read(std::istream &port);

-GRUEL_API void pmt_write(pmt_t obj, std::ostream &port);

- * This is the same output as would be generated by pmt_write.

-GRUEL_API std::string pmt_write_string(pmt_t obj);

-GRUEL_API void pmt_print(pmt_t v);

-GRUEL_API bool pmt_serialize(pmt_t obj, std::streambuf &sink);

-GRUEL_API pmt_t pmt_deserialize(std::streambuf &source);

-GRUEL_API void pmt_dump_sizeof(); // debugging

-GRUEL_API std::string pmt_serialize_str(pmt_t obj);

-GRUEL_API pmt_t pmt_deserialize_str(std::string str);

-class pmt_comperator {

- { return pmt::pmt_eqv(p1,p2)?false:p1.get()>p2.get(); }

- return pmt_string_to_symbol(s);

- return pmt_string_to_symbol(s);

- return pmt_from_long(x);

- return pmt_from_long(x);

- return pmt_from_long(x);

- return pmt_from_double(x);

- return pmt_make_rectangular(z.real(), z.imag());

- return pmt_make_rectangular(z.real(), z.imag());

- return pmt_make_msg_accepter(ma);

- return pmt_make_blob(data, len_in_bytes);

- return pmt_make_tuple(e0);

- return pmt_make_tuple(e0, e1);

- return pmt_make_tuple(e0, e1, e2);

- return pmt_make_tuple(e0, e1, e2, e3);

- return pmt_make_tuple(e0, e1, e2, e3, e4);

- return pmt_make_tuple(e0, e1, e2, e3, e4, e5);

- return pmt_make_tuple(e0, e1, e2, e3, e4, e5, e6);

- return pmt_make_tuple(e0, e1, e2, e3, e4, e5, e6, e7);

- return pmt_make_tuple(e0, e1, e2, e3, e4, e5, e6, e7, e8);

- return pmt_make_tuple(e0, e1, e2, e3, e4, e5, e6, e7, e8, e9);

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

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

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

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

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

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

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

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

-const pmt_t PMT_T = pmt_t(new pmt_bool()); // singleton

-const pmt_t PMT_F = pmt_t(new pmt_bool()); // singleton

-const pmt_t PMT_NIL = pmt_t(new pmt_null()); // singleton

-const pmt_t PMT_EOF = pmt_cons(PMT_NIL, PMT_NIL); // singleton

-pmt_is_true(pmt_t obj)

-pmt_is_false(pmt_t obj)

-pmt_is_bool(pmt_t obj)

-pmt_from_bool(bool val)

-pmt_to_bool(pmt_t val)

- throw pmt_wrong_type("pmt_to_bool", val);

-pmt_is_symbol(const pmt_t& obj)

-pmt_string_to_symbol(const std::string &name)

-pmt_intern(const std::string &name)

- return pmt_string_to_symbol(name);

-pmt_symbol_to_string(const pmt_t& sym)

- throw pmt_wrong_type("pmt_symbol_to_string", sym);

-pmt_is_number(pmt_t x)

-pmt_is_integer(pmt_t x)

-pmt_from_long(long x)

-pmt_to_long(pmt_t x)

- throw pmt_wrong_type("pmt_to_long", x);

-pmt_is_uint64(pmt_t x)

-pmt_from_uint64(uint64_t x)

-pmt_to_uint64(pmt_t x)

- throw pmt_wrong_type("pmt_to_uint64", x);

-pmt_is_real(pmt_t x)

-pmt_from_double(double x)

-pmt_to_double(pmt_t x)

- throw pmt_wrong_type("pmt_to_double", x);

-pmt_is_complex(pmt_t x)

-pmt_make_rectangular(double re, double im)

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

-pmt_to_complex(pmt_t x)

- throw pmt_wrong_type("pmt_to_complex", x);

-pmt_is_null(const pmt_t& x)

-pmt_is_pair(const pmt_t& obj)

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

-pmt_car(const pmt_t& pair)

- throw pmt_wrong_type("pmt_car", pair);

-pmt_cdr(const pmt_t& pair)

- throw pmt_wrong_type("pmt_cdr", pair);

-pmt_set_car(pmt_t pair, pmt_t obj)

- throw pmt_wrong_type("pmt_set_car", pair);

-pmt_set_cdr(pmt_t pair, pmt_t obj)

- throw pmt_wrong_type("pmt_set_cdr", pair);

- throw pmt_out_of_range("pmt_vector_ref", pmt_from_long(k));

- throw pmt_out_of_range("pmt_vector_set", pmt_from_long(k));

-pmt_is_vector(pmt_t obj)

-pmt_make_vector(size_t k, pmt_t fill)

-pmt_vector_ref(pmt_t vector, size_t k)

- throw pmt_wrong_type("pmt_vector_ref", vector);

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

- throw pmt_wrong_type("pmt_vector_set", vector);

-pmt_vector_fill(pmt_t vector, pmt_t obj)

- throw pmt_wrong_type("pmt_vector_set", vector);

- throw pmt_out_of_range("pmt_tuple_ref", pmt_from_long(k));

-pmt_is_tuple(pmt_t obj)

-pmt_tuple_ref(const pmt_t &tuple, size_t k)

- throw pmt_wrong_type("pmt_tuple_ref", tuple);

-pmt_make_tuple()

-pmt_make_tuple(const pmt_t &e0)

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

-pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2)

-pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3)

-pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4)

-pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5)

-pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6)

-pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7)

-pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8)

-pmt_make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8, const pmt_t &e9)

-pmt_to_tuple(const pmt_t &x)

- size_t len = pmt_length(x);

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

- y = pmt_cdr(y);

- throw pmt_wrong_type("pmt_to_tuple", x);

-pmt_is_uniform_vector(pmt_t x)

-pmt_uniform_vector_elements(pmt_t vector, size_t &len)

- throw pmt_wrong_type("pmt_uniform_vector_elements", vector);

-pmt_uniform_vector_writable_elements(pmt_t vector, size_t &len)

- throw pmt_wrong_type("pmt_uniform_vector_writable_elements", vector);

-pmt_is_dict(const pmt_t &obj)

- return pmt_is_null(obj) || pmt_is_pair(obj);

-pmt_make_dict()

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

- if (pmt_is_null(dict))

- return pmt_acons(key, value, PMT_NIL);

- if (pmt_dict_has_key(dict, key))

- return pmt_acons(key, value, pmt_dict_delete(dict, key));

- return pmt_acons(key, value, dict);

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

- if (pmt_is_null(dict))

- if (pmt_eqv(pmt_caar(dict), key))

- return pmt_cdr(dict);

- return pmt_cons(pmt_car(dict), pmt_dict_delete(pmt_cdr(dict), key));

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

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

- if (pmt_is_pair(p))

- return pmt_cdr(p);

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

- return pmt_is_pair(pmt_assv(key, dict));

-pmt_dict_items(pmt_t dict)

- if (!pmt_is_dict(dict))

- throw pmt_wrong_type("pmt_dict_values", dict);

-pmt_dict_keys(pmt_t dict)

- if (!pmt_is_dict(dict))

- throw pmt_wrong_type("pmt_dict_keys", dict);

- return pmt_map(pmt_car, dict);

-pmt_dict_values(pmt_t dict)

- if (!pmt_is_dict(dict))

- throw pmt_wrong_type("pmt_dict_keys", dict);

- return pmt_map(pmt_cdr, dict);

-pmt_is_any(pmt_t obj)

-pmt_make_any(const boost::any &any)

-pmt_any_ref(pmt_t obj)

- throw pmt_wrong_type("pmt_any_ref", obj);

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

- throw pmt_wrong_type("pmt_any_set", obj);

-pmt_is_msg_accepter(const pmt_t &obj)

- if (!pmt_is_any(obj))

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

-pmt_make_msg_accepter(gruel::msg_accepter_sptr ma)

- return pmt_make_any(ma);

-pmt_msg_accepter_ref(const pmt_t &obj)

- return boost::any_cast<gruel::msg_accepter_sptr>(pmt_any_ref(obj));

- throw pmt_wrong_type("pmt_msg_accepter_ref", obj);

-pmt_is_blob(pmt_t x)

- // return pmt_is_u8vector(x);

- return pmt_is_uniform_vector(x);

-pmt_make_blob(const void *buf, size_t len_in_bytes)

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

-pmt_blob_data(pmt_t blob)

- return pmt_uniform_vector_elements(blob, len);

-pmt_blob_length(pmt_t blob)

- pmt_uniform_vector_elements(blob, len);

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

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

-pmt_eqv_raw(pmt_base *x, pmt_base *y)

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

- if (pmt_eqv(x, y))

- return pmt_equal(pmt_car(x), pmt_car(y)) && pmt_equal(pmt_cdr(x), pmt_cdr(y));

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

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

-pmt_length(const pmt_t& x)

- pmt_t it = pmt_cdr(x);

- while (pmt_is_pair(it)){

- it = pmt_cdr(it);

- if (pmt_is_null(it))

- throw pmt_wrong_type("pmt_length", x);

- throw pmt_wrong_type("pmt_length", x);

-pmt_assq(pmt_t obj, pmt_t alist)

- while (pmt_is_pair(alist)){

- pmt_t p = pmt_car(alist);

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

- if (pmt_eq(obj, pmt_car(p)))

- alist = pmt_cdr(alist);

-pmt_assv_raw(pmt_base *obj, pmt_base *alist)

- if (pmt_eqv_raw(obj, ((pmt_pair *)p)->d_car.get()))

-pmt_assv(pmt_t obj, pmt_t alist)

- return pmt_assv_raw(obj.get(), alist.get());

-pmt_assv(pmt_t obj, pmt_t alist)

- while (pmt_is_pair(alist)){

- pmt_t p = pmt_car(alist);

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

- if (pmt_eqv(obj, pmt_car(p)))

- alist = pmt_cdr(alist);

-pmt_assoc(pmt_t obj, pmt_t alist)

- while (pmt_is_pair(alist)){

- pmt_t p = pmt_car(alist);

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

- if (pmt_equal(obj, pmt_car(p)))

- alist = pmt_cdr(alist);

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

- while(pmt_is_pair(list)){

- r = pmt_cons(proc(pmt_car(list)), r);

- list = pmt_cdr(list);

- return pmt_reverse_x(r);

-pmt_reverse(pmt_t listx)

- while(pmt_is_pair(list)){

- r = pmt_cons(pmt_car(list), r);

- list = pmt_cdr(list);

- if (pmt_is_null(list))

- throw pmt_wrong_type("pmt_reverse", listx);

-pmt_reverse_x(pmt_t list)

- return pmt_reverse(list);

-pmt_nth(size_t n, pmt_t list)

- pmt_t t = pmt_nthcdr(n, list);

- if (pmt_is_pair(t))

- return pmt_car(t);

-pmt_nthcdr(size_t n, pmt_t list)

- if (!(pmt_is_pair(list) || pmt_is_null(list)))

- throw pmt_wrong_type("pmt_nthcdr", list);

- if (pmt_is_pair(list)){

- list = pmt_cdr(list);

- if (pmt_is_null(list))

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

-pmt_memq(pmt_t obj, pmt_t list)

- while (pmt_is_pair(list)){

- if (pmt_eq(obj, pmt_car(list)))

- list = pmt_cdr(list);

-pmt_memv(pmt_t obj, pmt_t list)

- while (pmt_is_pair(list)){

- if (pmt_eqv(obj, pmt_car(list)))

- list = pmt_cdr(list);

-pmt_member(pmt_t obj, pmt_t list)

- while (pmt_is_pair(list)){

- if (pmt_equal(obj, pmt_car(list)))

- list = pmt_cdr(list);

-pmt_subsetp(pmt_t list1, pmt_t list2)

- while (pmt_is_pair(list1)){

- pmt_t p = pmt_car(list1);

- if (pmt_is_false(pmt_memv(p, list2)))

- list1 = pmt_cdr(list1);

-pmt_list1(const pmt_t& x1)

- return pmt_cons(x1, PMT_NIL);

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

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

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

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

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

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

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

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

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

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

-pmt_list_add(pmt_t list, const pmt_t& item)

- return pmt_reverse(pmt_cons(item, pmt_reverse(list)));

-pmt_list_rm(pmt_t list, const pmt_t& item)

- if(pmt_is_pair(list)){

- pmt_t left = pmt_car(list);

- pmt_t right = pmt_cdr(list);

- if(!pmt_equal(left, item)){

- return pmt_cons(left, pmt_list_rm(right, item));

- return pmt_list_rm(right, item);

-pmt_list_has(pmt_t list, const pmt_t& item)

- if(pmt_is_pair(list)){

- pmt_t left = pmt_car(list);

- pmt_t right = pmt_cdr(list);

- if(pmt_equal(left,item))

- return pmt_list_has(right, item);

- if(pmt_is_null(list))

-pmt_caar(pmt_t pair)

- return (pmt_car(pmt_car(pair)));

-pmt_cadr(pmt_t pair)

- return pmt_car(pmt_cdr(pair));

-pmt_cdar(pmt_t pair)

- return pmt_cdr(pmt_car(pair));

-pmt_cddr(pmt_t pair)

- return pmt_cdr(pmt_cdr(pair));

-pmt_caddr(pmt_t pair)

- return pmt_car(pmt_cdr(pmt_cdr(pair)));

-pmt_cadddr(pmt_t pair)

- return pmt_car(pmt_cdr(pmt_cdr(pmt_cdr(pair))));

-pmt_is_eof_object(pmt_t obj)

- return pmt_eq(obj, PMT_EOF);

-pmt_dump_sizeof()

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

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

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

- if (pmt_is_null(obj)) // ()

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

- pmt_write_list_tail(obj, port);

- pmt_write(obj, port);

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

- if (pmt_is_bool(obj)){

- if (pmt_is_true(obj))

- else if (pmt_is_symbol(obj)){

- port << pmt_symbol_to_string(obj);

- else if (pmt_is_number(obj)){

- if (pmt_is_integer(obj))

- port << pmt_to_long(obj);

- else if (pmt_is_uint64(obj))

- port << pmt_to_uint64(obj);

- else if (pmt_is_real(obj))

- port << pmt_to_double(obj);

- else if (pmt_is_complex(obj)){

- std::complex<double> c = pmt_to_complex(obj);

- else if (pmt_is_null(obj)){

- else if (pmt_is_pair(obj)){

- pmt_write_list_tail(obj, port);

- else if (pmt_is_tuple(obj)){

- size_t len = pmt_length(obj);

- port << pmt_tuple_ref(obj, 0);

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

- else if (pmt_is_vector(obj)){

- size_t len = pmt_length(obj);

- port << pmt_vector_ref(obj, 0);

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

- else if (pmt_is_dict(obj)){

- else if (pmt_is_uniform_vector(obj)){

- pmt_write(obj, os);

-pmt_write_string(pmt_t obj)

-pmt_read(std::istream &port)

- throw pmt_notimplemented("notimplemented: pmt_read", PMT_NIL);

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

- throw pmt_notimplemented("notimplemented: pmt_serialize", obj);

-pmt_deserialize(std::istream &source)

- throw pmt_notimplemented("notimplemented: pmt_deserialize", PMT_NIL);

-pmt::pmt_print(pmt_t v)

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

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

- pmt_t item = pmt_deserialize( sb );

- if(pmt_eq(list, PMT_NIL)){

- list = pmt_list1(item);

- } else {

- list = pmt_list_add(list, item);

- }

- (*tuple) = pmt_to_tuple(list);

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

- if (pmt_is_bool(obj)){

- if (pmt_eq(obj, PMT_T))

- if (pmt_is_null(obj))

- if (pmt_is_symbol(obj)){

- const std::string s = pmt_symbol_to_string(obj);

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

- if (pmt_is_pair(obj)){

- ok &= pmt_serialize(pmt_car(obj), sb);

- if (!ok)

- obj = pmt_cdr(obj);

- if (pmt_is_number(obj)){

- if (pmt_is_uint64(obj)){

- uint64_t i = pmt_to_uint64(obj);

- } else

- if (pmt_is_integer(obj)){

- long i = pmt_to_long(obj);

- if (sizeof(long) > 4){

- if (i < -2147483647 || i > 2147483647)

- throw pmt_notimplemented("pmt_serialize (64-bit integers)", obj);

- ok = serialize_untagged_u8(PST_INT32, sb);

- ok &= serialize_untagged_u32(i, sb);

- return ok;

- if (pmt_is_real(obj)){

- float i = pmt_to_double(obj);

- if (pmt_is_complex(obj)){

- std::complex<double> i = pmt_to_complex(obj);

-

- if (pmt_is_vector(obj)) {

- size_t vec_len = pmt::pmt_length(obj);

- ok &= pmt_serialize(pmt_vector_ref(obj, i), sb);

- if (pmt_is_uniform_vector(obj)) {

- size_t vec_len = pmt::pmt_length(obj);

- if(pmt_is_u8vector(obj)) {

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

- if(pmt_is_s8vector(obj)) {

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

- if(pmt_is_u16vector(obj)) {

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

- if(pmt_is_s16vector(obj)) {

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

- if(pmt_is_u32vector(obj)) {

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

- if(pmt_is_s32vector(obj)) {

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

- if(pmt_is_u64vector(obj)) {

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

- if(pmt_is_s64vector(obj)) {

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

- if(pmt_is_f32vector(obj)) {

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

- if(pmt_is_f64vector(obj)) {

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

- if(pmt_is_c32vector(obj)) {

- std::complex<float> c = pmt_c32vector_ref(obj, i);

- if(pmt_is_c64vector(obj)) {

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

- if (pmt_is_dict(obj))

- throw pmt_notimplemented("pmt_serialize (dict)", obj);

- if (pmt_is_tuple(obj)){

- size_t tuple_len = pmt::pmt_length(obj);

- ok &= pmt_serialize(pmt_tuple_ref(obj, i), sb);

- //throw pmt_notimplemented("pmt_serialize (tuple)", obj);

- throw pmt_notimplemented("pmt_serialize (?)", obj);

-pmt_deserialize(std::streambuf &sb)

- throw pmt_notimplemented("pmt_deserialize: very long symbol",

- PMT_F);

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

- return pmt_from_long((int32_t) u32);

- return pmt_from_uint64(u64);

- return pmt_from_double( f64 );

- return pmt_make_rectangular( r,i );

- pmt_t vec = pmt_make_vector(nitems, PMT_NIL);

- pmt_t item = pmt_deserialize(sb);

- pmt_vector_set(vec, i, item);

- pmt_t vec = pmt_make_u8vector(nitems, 0);

- pmt_u8vector_set(vec, i, u8);

- pmt_t vec = pmt_make_s8vector(nitems, 0);

- pmt_s8vector_set(vec, i, u8);

- pmt_t vec = pmt_make_u16vector(nitems, 0);

- pmt_u16vector_set(vec, i, u16);

- pmt_t vec = pmt_make_s16vector(nitems, 0);

- pmt_s16vector_set(vec, i, u16);

- pmt_t vec = pmt_make_u32vector(nitems, 0);

- pmt_u32vector_set(vec, i, u32);

- pmt_t vec = pmt_make_s32vector(nitems, 0);

- pmt_s32vector_set(vec, i, u32);

- pmt_t vec = pmt_make_u64vector(nitems, 0);

- pmt_u64vector_set(vec, i, u64);

- pmt_t vec = pmt_make_s64vector(nitems, 0);

- pmt_s64vector_set(vec, i, u64);

- pmt_t vec = pmt_make_f32vector(nitems, 0);

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

- pmt_t vec = pmt_make_f64vector(nitems, 0);

- pmt_f64vector_set(vec, i, f64);

- pmt_t vec = pmt_make_c32vector(nitems, 0);

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

- pmt_t vec = pmt_make_c64vector(nitems, 0);

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

- throw pmt_exception("pmt_deserialize: malformed input stream, tag value = ",

- pmt_from_long(tag));

- throw pmt_notimplemented("pmt_deserialize: tag value = ",

- pmt_from_long(tag));

- throw pmt_exception("pmt_deserialize: malformed input stream, tag value = ",

- pmt_from_long(tag));

- throw pmt_exception("pmt_deserialize: malformed input stream", PMT_F);

-std::string pmt_serialize_str(pmt_t obj){

- pmt_serialize(obj, sb);

-pmt_t pmt_deserialize_str(std::string s){

- return pmt_deserialize(sb);

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

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

- if (pmt_is_null(lastnptr))

- pmt_set_cdr(lastnptr, nptr);

- throw pmt_exception("pmt_deserialize: malformed input stream", PMT_F);

- expr = pmt_deserialize(sb);

- pmt_set_cdr(lastnptr, expr);

-using namespace pmt;

-

- CPPUNIT_ASSERT(!pmt_is_symbol(PMT_T));

- CPPUNIT_ASSERT(!pmt_is_symbol(PMT_F));

- CPPUNIT_ASSERT_THROW(pmt_symbol_to_string(PMT_F), pmt_wrong_type);

-

- pmt_t sym1 = mp("test");

- CPPUNIT_ASSERT(pmt_is_symbol(sym1));

- CPPUNIT_ASSERT_EQUAL(std::string("test"), pmt_symbol_to_string(sym1));

- CPPUNIT_ASSERT(pmt_is_true(sym1));

- CPPUNIT_ASSERT(!pmt_is_false(sym1));

-

- pmt_t sym2 = mp("foo");

- pmt_t sym3 = mp("test");

- std::vector<pmt_t> v1(N);

- std::vector<pmt_t> v2(N);

- v1[i] = mp(buf.c_str());

- v2[i] = mp(buf.c_str());

- pmt_t sym = mp("test");

- CPPUNIT_ASSERT(pmt_is_bool(PMT_T));

- CPPUNIT_ASSERT(pmt_is_bool(PMT_F));

- CPPUNIT_ASSERT(!pmt_is_bool(sym));

- CPPUNIT_ASSERT_EQUAL(pmt_from_bool(false), PMT_F);

- CPPUNIT_ASSERT_EQUAL(pmt_from_bool(true), PMT_T);

- CPPUNIT_ASSERT_EQUAL(false, pmt_to_bool(PMT_F));

- CPPUNIT_ASSERT_EQUAL(true, pmt_to_bool(PMT_T));

- CPPUNIT_ASSERT_THROW(pmt_to_bool(sym), pmt_wrong_type);

- pmt_t p1 = pmt_from_long(1);

- pmt_t m1 = pmt_from_long(-1);

- CPPUNIT_ASSERT(!pmt_is_integer(PMT_T));

- CPPUNIT_ASSERT(pmt_is_integer(p1));

- CPPUNIT_ASSERT(pmt_is_integer(m1));

- CPPUNIT_ASSERT_THROW(pmt_to_long(PMT_T), pmt_wrong_type);

- CPPUNIT_ASSERT_EQUAL(-1L, pmt_to_long(m1));

- CPPUNIT_ASSERT_EQUAL(1L, pmt_to_long(p1));

- pmt_t p1 = pmt_from_uint64((uint64_t)1);

- pmt_t m1 = pmt_from_uint64((uint64_t)8589934592ULL);

- CPPUNIT_ASSERT(!pmt_is_uint64(PMT_T));

- CPPUNIT_ASSERT(pmt_is_uint64(p1));

- CPPUNIT_ASSERT(pmt_is_uint64(m1));

- CPPUNIT_ASSERT_THROW(pmt_to_uint64(PMT_T), pmt_wrong_type);

- CPPUNIT_ASSERT_EQUAL((uint64_t)8589934592ULL, (uint64_t)pmt_to_uint64(m1));

- CPPUNIT_ASSERT_EQUAL((uint64_t)1ULL, (uint64_t)pmt_to_uint64(p1));

- pmt_t p1 = pmt_from_double(1);

- pmt_t m1 = pmt_from_double(-1);

- CPPUNIT_ASSERT(!pmt_is_real(PMT_T));

- CPPUNIT_ASSERT(pmt_is_real(p1));

- CPPUNIT_ASSERT(pmt_is_real(m1));

- CPPUNIT_ASSERT_THROW(pmt_to_double(PMT_T), pmt_wrong_type);

- CPPUNIT_ASSERT_EQUAL(-1.0, pmt_to_double(m1));

- CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(p1));

- CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(pmt_from_long(1)));

- pmt_t p1 = pmt_make_rectangular(2, -3);

- pmt_t m1 = pmt_make_rectangular(-3, 2);

- pmt_t p2 = pmt_from_complex(2, -3);

- pmt_t m2 = pmt_from_complex(-3, 2);

- pmt_t p3 = pmt_from_complex(std::complex<double>(2, -3));

- pmt_t m3 = pmt_from_complex(std::complex<double>(-3, 2));

- CPPUNIT_ASSERT(!pmt_is_complex(PMT_T));

- CPPUNIT_ASSERT(pmt_is_complex(p1));

- CPPUNIT_ASSERT(pmt_is_complex(m1));

- CPPUNIT_ASSERT(pmt_is_complex(p2));

- CPPUNIT_ASSERT(pmt_is_complex(m2));

- CPPUNIT_ASSERT(pmt_is_complex(p3));

- CPPUNIT_ASSERT(pmt_is_complex(m3));

- CPPUNIT_ASSERT_THROW(pmt_to_complex(PMT_T), pmt_wrong_type);

- CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt_to_complex(p1));

- CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt_to_complex(m1));

- CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt_to_complex(p2));

- CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt_to_complex(m2));

- CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt_to_complex(p3));

- CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt_to_complex(m3));

- CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt_to_complex(pmt_from_long(1)));

- CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt_to_complex(pmt_from_double(1.0)));

- CPPUNIT_ASSERT(pmt_is_null(PMT_NIL));

- CPPUNIT_ASSERT(!pmt_is_pair(PMT_NIL));

- pmt_t s1 = mp("s1");

- pmt_t s2 = mp("s2");

- pmt_t s3 = mp("s3");

-

-

- CPPUNIT_ASSERT_EQUAL((size_t)0, pmt_length(PMT_NIL));

- CPPUNIT_ASSERT_THROW(pmt_length(s1), pmt_wrong_type);

- CPPUNIT_ASSERT_THROW(pmt_length(pmt_from_double(42)), pmt_wrong_type);

-

- pmt_t c1 = pmt_cons(s1, PMT_NIL);

- CPPUNIT_ASSERT(pmt_is_pair(c1));

- CPPUNIT_ASSERT(!pmt_is_pair(s1));

- CPPUNIT_ASSERT_EQUAL(s1, pmt_car(c1));

- CPPUNIT_ASSERT_EQUAL(PMT_NIL, pmt_cdr(c1));

- CPPUNIT_ASSERT_EQUAL((size_t) 1, pmt_length(c1));

-

- pmt_t c3 = pmt_cons(s3, PMT_NIL);

- pmt_t c2 = pmt_cons(s2, c3);

- pmt_set_cdr(c1, c2);

- CPPUNIT_ASSERT_EQUAL(c2, pmt_cdr(c1));

- pmt_set_car(c1, s3);

- CPPUNIT_ASSERT_EQUAL(s3, pmt_car(c1));

- CPPUNIT_ASSERT_EQUAL((size_t)1, pmt_length(c3));

- CPPUNIT_ASSERT_EQUAL((size_t)2, pmt_length(c2));

-

- CPPUNIT_ASSERT_THROW(pmt_cdr(PMT_NIL), pmt_wrong_type);

- CPPUNIT_ASSERT_THROW(pmt_car(PMT_NIL), pmt_wrong_type);

- CPPUNIT_ASSERT_THROW(pmt_set_car(s1, PMT_NIL), pmt_wrong_type);

- CPPUNIT_ASSERT_THROW(pmt_set_cdr(s1, PMT_NIL), pmt_wrong_type);

- pmt_t v1 = pmt_make_vector(N, PMT_NIL);

- CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));

- pmt_t s0 = mp("s0");

- pmt_t s1 = mp("s1");

- pmt_t s2 = mp("s2");

- pmt_vector_set(v1, 0, s0);

- pmt_vector_set(v1, 1, s1);

- pmt_vector_set(v1, 2, s2);

- CPPUNIT_ASSERT_EQUAL(s0, pmt_vector_ref(v1, 0));

- CPPUNIT_ASSERT_EQUAL(s1, pmt_vector_ref(v1, 1));

- CPPUNIT_ASSERT_EQUAL(s2, pmt_vector_ref(v1, 2));

- CPPUNIT_ASSERT_THROW(pmt_vector_ref(v1, N), pmt_out_of_range);

- CPPUNIT_ASSERT_THROW(pmt_vector_set(v1, N, PMT_NIL), pmt_out_of_range);

- pmt_vector_fill(v1, s0);

- CPPUNIT_ASSERT_EQUAL(s0, pmt_vector_ref(v1, i));

-check_tuple(size_t len, const std::vector<pmt_t> &s, pmt_t t)

- CPPUNIT_ASSERT_EQUAL(true, pmt_is_tuple(t));

- CPPUNIT_ASSERT_EQUAL(len, pmt_length(t));

- CPPUNIT_ASSERT_EQUAL(s[i], pmt_tuple_ref(t, i));

- pmt_t v = pmt_make_vector(10, PMT_NIL);

- std::vector<pmt_t> s(10);

- s[i] = mp(os.str());

- pmt_vector_set(v, i, s[i]);

- pmt_t t;

- t = pmt_make_tuple();

- t = pmt_make_tuple(s[0]);

- CPPUNIT_ASSERT(pmt_is_vector(v));

- CPPUNIT_ASSERT(!pmt_is_tuple(v));

- CPPUNIT_ASSERT(pmt_is_tuple(t));

- CPPUNIT_ASSERT(!pmt_is_vector(t));

- t = pmt_make_tuple(s[0], s[1]);

- t = pmt_make_tuple(s[0], s[1], s[2]);

- t = pmt_make_tuple(s[0], s[1], s[2], s[3]);

- t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4]);

- t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5]);

- t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6]);

- t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]);

- t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8]);

- t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]);

- t = pmt_make_tuple(s[0], s[1], s[2]);

- CPPUNIT_ASSERT_THROW(pmt_tuple_ref(t, 3), pmt_out_of_range);

- CPPUNIT_ASSERT_THROW(pmt_vector_ref(t, 0), pmt_wrong_type);

- CPPUNIT_ASSERT_THROW(pmt_tuple_ref(v, 0), pmt_wrong_type);

- t = pmt_make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]);

- pmt_t t2 = pmt_to_tuple(v);

- CPPUNIT_ASSERT_EQUAL(size_t(10), pmt_length(v));

- CPPUNIT_ASSERT(pmt_equal(t, t2));

- t = pmt_make_tuple(s[0], s[1], s[2]);

- pmt_t list0 = pmt_list3(s[0], s[1], s[2]);

- CPPUNIT_ASSERT_EQUAL(size_t(3), pmt_length(list0));

- t2 = pmt_to_tuple(list0);

- CPPUNIT_ASSERT_EQUAL(size_t(3), pmt_length(t2));

- CPPUNIT_ASSERT(pmt_equal(t, t2));

- pmt_t s0 = mp("s0");

- pmt_t s1 = mp("s1");

- pmt_t s2 = mp("s2");

- pmt_t list0 = pmt_cons(s0, pmt_cons(s1, pmt_cons(s2, PMT_NIL)));

- pmt_t list1 = pmt_cons(s0, pmt_cons(s1, pmt_cons(s2, PMT_NIL)));

- pmt_t i0 = pmt_from_long(42);

- pmt_t i1 = pmt_from_long(42);

- pmt_t r0 = pmt_from_double(42);

- pmt_t r1 = pmt_from_double(42);

- pmt_t r2 = pmt_from_double(43);

-

- CPPUNIT_ASSERT(pmt_eq(s0, s0));

- CPPUNIT_ASSERT(!pmt_eq(s0, s1));

- CPPUNIT_ASSERT(pmt_eqv(s0, s0));

- CPPUNIT_ASSERT(!pmt_eqv(s0, s1));

-

- CPPUNIT_ASSERT(pmt_eqv(i0, i1));

- CPPUNIT_ASSERT(pmt_eqv(r0, r1));

- CPPUNIT_ASSERT(!pmt_eqv(r0, r2));

- CPPUNIT_ASSERT(!pmt_eqv(i0, r0));

-

- CPPUNIT_ASSERT(!pmt_eq(list0, list1));

- CPPUNIT_ASSERT(!pmt_eqv(list0, list1));

- CPPUNIT_ASSERT(pmt_equal(list0, list1));

-

- pmt_t v0 = pmt_make_vector(3, s0);

- pmt_t v1 = pmt_make_vector(3, s0);

- pmt_t v2 = pmt_make_vector(4, s0);

- CPPUNIT_ASSERT(!pmt_eqv(v0, v1));

- CPPUNIT_ASSERT(pmt_equal(v0, v1));

- CPPUNIT_ASSERT(!pmt_equal(v0, v2));

-

- pmt_vector_set(v0, 0, list0);

- pmt_vector_set(v0, 1, list0);

- pmt_vector_set(v1, 0, list1);

- pmt_vector_set(v1, 1, list1);

- CPPUNIT_ASSERT(pmt_equal(v0, v1));

- pmt_t k0 = mp("k0");

- pmt_t k1 = mp("k1");

- pmt_t k2 = mp("k2");

- pmt_t k3 = mp("k3");

- pmt_t v0 = mp("v0");

- pmt_t v1 = mp("v1");

- pmt_t v2 = mp("v2");

- pmt_t p0 = pmt_cons(k0, v0);

- pmt_t p1 = pmt_cons(k1, v1);

- pmt_t p2 = pmt_cons(k2, v2);

-

- pmt_t alist = pmt_cons(p0, pmt_cons(p1, pmt_cons(p2, PMT_NIL)));

- CPPUNIT_ASSERT(pmt_eq(p1, pmt_assv(k1, alist)));

- CPPUNIT_ASSERT(pmt_eq(PMT_F, pmt_assv(k3, alist)));

-

- pmt_t keys = pmt_cons(k0, pmt_cons(k1, pmt_cons(k2, PMT_NIL)));

- pmt_t vals = pmt_cons(v0, pmt_cons(v1, pmt_cons(v2, PMT_NIL)));

- CPPUNIT_ASSERT(pmt_equal(keys, pmt_map(pmt_car, alist)));

- CPPUNIT_ASSERT(pmt_equal(vals, pmt_map(pmt_cdr, alist)));

- pmt_t dict = pmt_make_dict();

- CPPUNIT_ASSERT(pmt_is_dict(dict));

-

- pmt_t k0 = mp("k0");

- pmt_t k1 = mp("k1");

- pmt_t k2 = mp("k2");

- pmt_t k3 = mp("k3");

- pmt_t v0 = mp("v0");

- pmt_t v1 = mp("v1");

- pmt_t v2 = mp("v2");

- pmt_t v3 = mp("v3");

- pmt_t not_found = pmt_cons(PMT_NIL, PMT_NIL);

-

- CPPUNIT_ASSERT(!pmt_dict_has_key(dict, k0));

- dict = pmt_dict_add(dict, k0, v0);

- CPPUNIT_ASSERT(pmt_dict_has_key(dict, k0));

- CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k0, not_found), v0));

- CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), not_found));

- dict = pmt_dict_add(dict, k1, v1);

- dict = pmt_dict_add(dict, k2, v2);

- CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v1));

- dict = pmt_dict_add(dict, k1, v3);

- CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v3));

-

- pmt_t keys = pmt_list3(k1, k2, k0);

- pmt_t vals = pmt_list3(v3, v2, v0);

- //std::cout << "pmt_dict_keys: " << pmt_dict_keys(dict) << std::endl;

- //std::cout << "pmt_dict_values: " << pmt_dict_values(dict) << std::endl;

- CPPUNIT_ASSERT(pmt_equal(keys, pmt_dict_keys(dict)));

- CPPUNIT_ASSERT(pmt_equal(vals, pmt_dict_values(dict)));

- pmt_t k0 = mp("k0");

- pmt_t k1 = mp("k1");

- pmt_t k2 = mp("k2");

- pmt_t k3 = mp("k3");

- CPPUNIT_ASSERT_EQUAL(std::string("k0"), pmt_write_string(k0));

- pmt_t s0 = mp("s0");

- pmt_t s1 = mp("s1");

- pmt_t s2 = mp("s2");

- pmt_t s3 = mp("s3");

-

- pmt_t l1 = pmt_list4(s0, s1, s2, s3);

- pmt_t l2 = pmt_list3(s0, s1, s2);

- pmt_t l3 = pmt_list_add(l2, s3);

- CPPUNIT_ASSERT(pmt_equal(l1, l3));

- pmt_t p0 = pmt_make_any(a0);

- pmt_t p1 = pmt_make_any(a1);

- pmt_t p2 = pmt_make_any(a2);

- boost::any_cast<std::string>(pmt_any_ref(p0)));

- boost::any_cast<int>(pmt_any_ref(p1)));

- boost::any_cast<foo>(pmt_any_ref(p2)));

- void post(pmt_t,pmt_t){};

- pmt_t sym = mp("my-symbol");

- pmt_t p0 = pmt_make_any(a0);

- pmt_t p1 = pmt_make_msg_accepter(ma0);

- CPPUNIT_ASSERT_EQUAL(ma0.get(), pmt_msg_accepter_ref(p1).get());

- CPPUNIT_ASSERT_THROW(pmt_msg_accepter_ref(sym), pmt_wrong_type);

- CPPUNIT_ASSERT_THROW(pmt_msg_accepter_ref(p0), pmt_wrong_type);

- pmt_t port(pmt_intern("port"));

- pmt_t a = mp("a");

- pmt_t b = mp("b");

- pmt_t c = mp("c");

- pmt_serialize(PMT_NIL, sb);

- pmt_serialize(mp("foobarvia"), sb);

- pmt_serialize(pmt_from_long(123456789), sb);

- pmt_serialize(pmt_from_long(-123456789), sb);

- pmt_serialize(pmt_cons(PMT_NIL, PMT_NIL), sb);

- pmt_serialize(pmt_cons(a, b), sb);

- pmt_serialize(pmt_list1(a), sb);

- pmt_serialize(pmt_list2(a, b), sb);

- pmt_serialize(pmt_list3(a, b, c), sb);

- pmt_serialize(pmt_list3(a, pmt_list3(c, b, a), c), sb);

- pmt_serialize(PMT_T, sb);

- pmt_serialize(PMT_F, sb);

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_NIL));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), mp("foobarvia")));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_from_long(123456789)));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_from_long(-123456789)));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_cons(PMT_NIL, PMT_NIL)));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_cons(a, b)));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list1(a)));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list2(a, b)));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list3(a, b, c)));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_list3(a, pmt_list3(c, b, a), c)));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_T));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_F));

- CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_EOF)); // last item

- pmt_t s1 = mp("s1");

- pmt_t s2 = mp("s2");

- pmt_t s3 = mp("s3");

-

- pmt_t l1 = pmt_list1(s1);

- pmt_t l2 = pmt_list2(s2,s3);

- pmt_t l3 = pmt_list3(s1,s2,s3);

-

- CPPUNIT_ASSERT(pmt_is_pair(pmt_memq(s1,l1)));

- CPPUNIT_ASSERT(pmt_is_false(pmt_memq(s3,l1)));

-

- CPPUNIT_ASSERT(pmt_subsetp(l1,l3));

- CPPUNIT_ASSERT(pmt_subsetp(l2,l3));

- CPPUNIT_ASSERT(!pmt_subsetp(l1,l2));

- CPPUNIT_ASSERT(!pmt_subsetp(l2,l1));

- CPPUNIT_ASSERT(!pmt_subsetp(l3,l2));

- CPPUNIT_ASSERT(pmt_is_symbol(mp("my-symbol")));

- CPPUNIT_ASSERT_EQUAL((long) 10, pmt_to_long(mp(10)));

- CPPUNIT_ASSERT_EQUAL((double) 1e6, pmt_to_double(mp(1e6)));

- pmt_to_complex(mp(std::complex<double>(2, 3))));

- pmt_t blob = mp(buf, sizeof(buf));

- const void *data = pmt_blob_data(blob);

- size_t nbytes = pmt_blob_length(blob);

- pmt_t v1 = pmt_make_@TAG@vector(N, 0);

- CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1));

- pmt_@TAG@vector_set(v1, 0, s0);

- pmt_@TAG@vector_set(v1, 1, s1);

- pmt_@TAG@vector_set(v1, 2, s2);

- CPPUNIT_ASSERT_EQUAL(s0, pmt_@TAG@vector_ref(v1, 0));

- CPPUNIT_ASSERT_EQUAL(s1, pmt_@TAG@vector_ref(v1, 1));

- CPPUNIT_ASSERT_EQUAL(s2, pmt_@TAG@vector_ref(v1, 2));

- CPPUNIT_ASSERT_THROW(pmt_@TAG@vector_ref(v1, N), pmt_out_of_range);

- CPPUNIT_ASSERT_THROW(pmt_@TAG@vector_set(v1, N, @TYPE@(0)), pmt_out_of_range);

- const @TYPE@ *rd = pmt_@TAG@vector_elements(v1, len);

- @TYPE@ *wr = pmt_@TAG@vector_writable_elements(v1, len);

- throw pmt_out_of_range("pmt_@TAG@vector_ref", pmt_from_long(k));

- throw pmt_out_of_range("pmt_@TAG@vector_set", pmt_from_long(k));

-pmt_is_@TAG@vector(pmt_t obj)

-pmt_make_@TAG@vector(size_t k, @TYPE@ fill)

-pmt_init_@TAG@vector(size_t k, const @TYPE@ *data)

-pmt_init_@TAG@vector(size_t k, const std::vector< @TYPE@ > &data)

-pmt_@TAG@vector_ref(pmt_t vector, size_t k)

- throw pmt_wrong_type("pmt_@TAG@vector_ref", vector);

-pmt_@TAG@vector_set(pmt_t vector, size_t k, @TYPE@ obj)

- throw pmt_wrong_type("pmt_@TAG@vector_set", vector);

-pmt_@TAG@vector_elements(pmt_t vector, size_t &len)

- throw pmt_wrong_type("pmt_@TAG@vector_elements", vector);

-pmt_@TAG@vector_elements(pmt_t vector)

- throw pmt_wrong_type("pmt_@TAG@vector_elements", vector);

-pmt_@TAG@vector_writable_elements(pmt_t vector, size_t &len)

- throw pmt_wrong_type("pmt_@TAG@vector_writable_elements", vector);

- def test01 (self):

- a = pmt.pmt_intern("a")

- b = pmt.pmt_from_double(123765)

- d1 = pmt.pmt_make_dict()

- d2 = pmt.pmt_dict_add(d1, a, b)

- pmt.pmt_print(d2)

- def test02 (self):

- x_pmt = pmt.pmt_from_double(const)

- x_int = pmt.pmt_to_double(x_pmt)

- v = pmt.pmt_init_f32vector(3, [11, -22, 33])

- s = pmt.pmt_serialize_str(v)

- d = pmt.pmt_deserialize_str(s)

- self.assertTrue(pmt.pmt_equal(v, d))

- v = pmt.pmt_init_f64vector(3, [11, -22, 33])

- s = pmt.pmt_serialize_str(v)

- d = pmt.pmt_deserialize_str(s)

- self.assertTrue(pmt.pmt_equal(v, d))

- v = pmt.pmt_init_u8vector(3, [11, 22, 33])

- s = pmt.pmt_serialize_str(v)

- d = pmt.pmt_deserialize_str(s)

- self.assertTrue(pmt.pmt_equal(v, d))

- v = pmt.pmt_init_s8vector(3, [11, -22, 33])

- s = pmt.pmt_serialize_str(v)

- d = pmt.pmt_deserialize_str(s)

- self.assertTrue(pmt.pmt_equal(v, d))

- v = pmt.pmt_init_u16vector(3, [11, 22, 33])

- s = pmt.pmt_serialize_str(v)

- d = pmt.pmt_deserialize_str(s)

- self.assertTrue(pmt.pmt_equal(v, d))

- v = pmt.pmt_init_s16vector(3, [11, -22, 33])

- s = pmt.pmt_serialize_str(v)

- d = pmt.pmt_deserialize_str(s)

- self.assertTrue(pmt.pmt_equal(v, d))

- v = pmt.pmt_init_u32vector(3, [11, 22, 33])

- s = pmt.pmt_serialize_str(v)

- d = pmt.pmt_deserialize_str(s)

- self.assertTrue(pmt.pmt_equal(v, d))

- v = pmt.pmt_init_s32vector(3, [11, -22, 33])

- s = pmt.pmt_serialize_str(v)

- d = pmt.pmt_deserialize_str(s)

- self.assertTrue(pmt.pmt_equal(v, d))

- v = pmt.pmt_init_c32vector(3, [11 + -101j, -22 + 202j, 33 + -303j])

- s = pmt.pmt_serialize_str(v)

- d = pmt.pmt_deserialize_str(s)

- self.assertTrue(pmt.pmt_equal(v, d))

- v = pmt.pmt_init_c64vector(3, [11 + -101j, -22 + 202j, 33 + -303j])

- s = pmt.pmt_serialize_str(v)

- d = pmt.pmt_deserialize_str(s)

- self.assertTrue(pmt.pmt_equal(v, d))

- DESTINATION ${GR_PYTHON_DIR}/gruel/pmt

-typedef boost::intrusive_ptr<pmt_base> pmt_t;

-

-/*

- * ------------------------------------------------------------------------

- * Booleans. Two constants, #t and #f.

- *

- * In predicates, anything that is not #f is considered true.

- * I.e., there is a single false value, #f.

- * ------------------------------------------------------------------------

- */

-extern const pmt_t PMT_T;

-extern const pmt_t PMT_F;

-

-//! Return true if obj is \#t or \#f, else return false.

-bool pmt_is_bool(pmt_t obj);

-

-//! Return false if obj is \#f, else return true.

-bool pmt_is_true(pmt_t obj);

-

-//! Return true if obj is \#f, else return true.

-bool pmt_is_false(pmt_t obj);

-

-//! Return \#f is val is false, else return \#t.

-pmt_t pmt_from_bool(bool val);

-

-//! Return true if val is PMT_T, return false when val is PMT_F,

-// else raise wrong_type exception.

-bool pmt_to_bool(pmt_t val);

-

-/*

- * ------------------------------------------------------------------------

- * Symbols

- * ------------------------------------------------------------------------

- */

-

-//! Return true if obj is a symbol, else false.

-bool pmt_is_symbol(const pmt_t& obj);

-

-//! Return the symbol whose name is \p s.

-pmt_t pmt_string_to_symbol(const std::string &s);

-

-//! Alias for pmt_string_to_symbol

-pmt_t pmt_intern(const std::string &s);

-

-

-/*!

- * If \p is a symbol, return the name of the symbol as a string.

- * Otherwise, raise the wrong_type exception.

- */

-const std::string pmt_symbol_to_string(const pmt_t& sym);

-

-/*

- * ------------------------------------------------------------------------

- * Numbers: we support integer, real and complex

- * ------------------------------------------------------------------------

- */

-

-//! Return true if obj is any kind of number, else false.

-bool pmt_is_number(pmt_t obj);

-

-/*

- * ------------------------------------------------------------------------

- * Integers

- * ------------------------------------------------------------------------

- */

-

-//! Return true if \p x is an integer number, else false

-bool pmt_is_integer(pmt_t x);

-

-//! Return the pmt value that represents the integer \p x.

-pmt_t pmt_from_long(long x);

-

-/*!

- * \brief Convert pmt to long if possible.

- *

- * When \p x represents an exact integer that fits in a long,

- * return that integer. Else raise an exception, either wrong_type

- * when x is not an exact integer, or out_of_range when it doesn't fit.

- */

-long pmt_to_long(pmt_t x);

-

-/*

- * ------------------------------------------------------------------------

- * uint64_t

- * ------------------------------------------------------------------------

- */

-

-//! Return true if \p x is an uint64 number, else false

-bool pmt_is_uint64(pmt_t x);

-

-//! Return the pmt value that represents the uint64 \p x.

-pmt_t pmt_from_uint64(uint64_t x);

-

-/*!

- * \brief Convert pmt to uint64 if possible.

- *

- * When \p x represents an exact integer that fits in a uint64,

- * return that uint64. Else raise an exception, either wrong_type

- * when x is not an exact uint64, or out_of_range when it doesn't fit.

- */

-uint64_t pmt_to_uint64(pmt_t x);

-

-/*

- * ------------------------------------------------------------------------

- * Reals

- * ------------------------------------------------------------------------

- */

-

-/*

- * \brief Return true if \p obj is a real number, else false.

- */

-bool pmt_is_real(pmt_t obj);

-

-//! Return the pmt value that represents double \p x.

-pmt_t pmt_from_double(double x);

-

-/*!

- * \brief Convert pmt to double if possible.

- *

- * Returns the number closest to \p val that is representable

- * as a double. The argument \p val must be a real or integer, otherwise

- * a wrong_type exception is raised.

- */

-double pmt_to_double(pmt_t x);

-

-/*

- * ------------------------------------------------------------------------

- * Complex

- * ------------------------------------------------------------------------

- */

-

-/*!

- * \brief return true if \p obj is a complex number, false otherwise.

- */

-bool pmt_is_complex(pmt_t obj);

-

-//! Return a complex number constructed of the given real and imaginary parts.

-pmt_t pmt_make_rectangular(double re, double im);