diff options
39 files changed, 303 insertions, 309 deletions
diff --git a/gnuradio-core/src/lib/general/gr_annotator_1to1.cc b/gnuradio-core/src/lib/general/gr_annotator_1to1.cc index 963af9202a..1178bdc34f 100644 --- a/gnuradio-core/src/lib/general/gr_annotator_1to1.cc +++ b/gnuradio-core/src/lib/general/gr_annotator_1to1.cc @@ -79,8 +79,8 @@ gr_annotator_1to1::work (int noutput_items, } // Storing the current noutput_items as the value to the "noutput_items" key - pmt::pmt_t srcid = pmt::pmt_string_to_symbol(str.str()); - pmt::pmt_t key = pmt::pmt_string_to_symbol("seq"); + pmt::pmt_t srcid = pmt::string_to_symbol(str.str()); + pmt::pmt_t key = pmt::string_to_symbol("seq"); // Work does nothing to the data stream; just copy all inputs to outputs // Adds a new tag when the number of items read is a multiple of d_when @@ -92,7 +92,7 @@ gr_annotator_1to1::work (int noutput_items, // the 1-to-1 propagation policy. for(int i = 0; i < std::min(noutputs, ninputs); i++) { if(abs_N % d_when == 0) { - pmt::pmt_t value = pmt::pmt_from_uint64(d_tag_counter++); + pmt::pmt_t value = pmt::from_uint64(d_tag_counter++); add_item_tag(i, abs_N, key, value, srcid); } diff --git a/gnuradio-core/src/lib/general/gr_annotator_alltoall.cc b/gnuradio-core/src/lib/general/gr_annotator_alltoall.cc index 01bdd30644..d8b7e2db7e 100644 --- a/gnuradio-core/src/lib/general/gr_annotator_alltoall.cc +++ b/gnuradio-core/src/lib/general/gr_annotator_alltoall.cc @@ -80,8 +80,8 @@ gr_annotator_alltoall::work (int noutput_items, } // Source ID and key for any tag that might get applied from this block - pmt::pmt_t srcid = pmt::pmt_string_to_symbol(str.str()); - pmt::pmt_t key = pmt::pmt_string_to_symbol("seq"); + pmt::pmt_t srcid = pmt::string_to_symbol(str.str()); + pmt::pmt_t key = pmt::string_to_symbol("seq"); // Work does nothing to the data stream; just copy all inputs to outputs // Adds a new tag when the number of items read is a multiple of d_when @@ -91,7 +91,7 @@ gr_annotator_alltoall::work (int noutput_items, for(int j = 0; j < noutput_items; j++) { for(int i = 0; i < noutputs; i++) { if(abs_N % d_when == 0) { - pmt::pmt_t value = pmt::pmt_from_uint64(d_tag_counter++); + pmt::pmt_t value = pmt::from_uint64(d_tag_counter++); add_item_tag(i, abs_N, key, value, srcid); } diff --git a/gnuradio-core/src/lib/general/gr_annotator_raw.cc b/gnuradio-core/src/lib/general/gr_annotator_raw.cc index d3dcce73af..c3aecdd938 100644 --- a/gnuradio-core/src/lib/general/gr_annotator_raw.cc +++ b/gnuradio-core/src/lib/general/gr_annotator_raw.cc @@ -55,7 +55,7 @@ void gr_annotator_raw::add_tag(uint64_t offset, pmt_t key, pmt_t val) gruel::scoped_lock l(d_mutex); gr_tag_t tag; - tag.srcid = pmt::pmt_intern(name()); + tag.srcid = pmt::intern(name()); tag.key = key; tag.value = val; tag.offset = offset; diff --git a/gnuradio-core/src/lib/general/gr_burst_tagger.cc b/gnuradio-core/src/lib/general/gr_burst_tagger.cc index 83e84bfa09..72924109bf 100644 --- a/gnuradio-core/src/lib/general/gr_burst_tagger.cc +++ b/gnuradio-core/src/lib/general/gr_burst_tagger.cc @@ -43,19 +43,19 @@ gr_burst_tagger::gr_burst_tagger(size_t itemsize) std::stringstream str; str << name() << unique_id(); - d_true_key = pmt::pmt_string_to_symbol("burst"); + d_true_key = pmt::string_to_symbol("burst"); d_true_value = pmt::PMT_T; - d_false_key = pmt::pmt_string_to_symbol("burst"); + d_false_key = pmt::string_to_symbol("burst"); d_false_value = pmt::PMT_F; - d_id = pmt::pmt_string_to_symbol(str.str()); + d_id = pmt::string_to_symbol(str.str()); } void gr_burst_tagger::set_true_tag (const std::string &key, bool value) { - d_true_key = pmt::pmt_string_to_symbol(key); + d_true_key = pmt::string_to_symbol(key); if(value == true) { d_true_value = pmt::PMT_T; } @@ -67,7 +67,7 @@ gr_burst_tagger::set_true_tag (const std::string &key, bool value) void gr_burst_tagger::set_false_tag (const std::string &key, bool value) { - d_false_key = pmt::pmt_string_to_symbol(key); + d_false_key = pmt::string_to_symbol(key); if(value == true) { d_false_value = pmt::PMT_T; } diff --git a/gnuradio-core/src/lib/general/gr_ctrlport_probe2_c.cc b/gnuradio-core/src/lib/general/gr_ctrlport_probe2_c.cc index 5d6abd2ee5..453f55ef4d 100644 --- a/gnuradio-core/src/lib/general/gr_ctrlport_probe2_c.cc +++ b/gnuradio-core/src/lib/general/gr_ctrlport_probe2_c.cc @@ -42,9 +42,9 @@ gr_ctrlport_probe2_c::gr_ctrlport_probe2_c(const std::string &id, gr_make_io_signature(0, 0, 0)), d_len(len), d_const_rpc(d_name, id.c_str(), this, unique_id(), &gr_ctrlport_probe2_c::get, - pmt::pmt_make_c32vector(0,-2), - pmt::pmt_make_c32vector(0,2), - pmt::pmt_make_c32vector(0,0), + pmt::make_c32vector(0,-2), + pmt::make_c32vector(0,2), + pmt::make_c32vector(0,0), "volts", desc.c_str(), RPC_PRIVLVL_MIN, DISPXYSCATTER), d_len_get_rpc(d_name, "length", this, unique_id(), &gr_ctrlport_probe2_c::length, pmt::mp(1), pmt::mp(10*len), pmt::mp(len), diff --git a/gnuradio-core/src/lib/general/gr_ctrlport_probe_c.cc b/gnuradio-core/src/lib/general/gr_ctrlport_probe_c.cc index 017a1fdcf7..7ad7bd6bce 100644 --- a/gnuradio-core/src/lib/general/gr_ctrlport_probe_c.cc +++ b/gnuradio-core/src/lib/general/gr_ctrlport_probe_c.cc @@ -43,9 +43,9 @@ gr_ctrlport_probe_c::gr_ctrlport_probe_c(const std::string &id, gr_make_io_signature(0, 0, 0)), d_ptr(NULL), d_ptrLen(0), d_const_rpc(d_name, id.c_str(), this, unique_id(), &gr_ctrlport_probe_c::get, - pmt::pmt_make_c32vector(0,-2), - pmt::pmt_make_c32vector(0,2), - pmt::pmt_make_c32vector(0,0), + pmt::make_c32vector(0,-2), + pmt::make_c32vector(0,2), + pmt::make_c32vector(0,0), "volts", desc.c_str(), RPC_PRIVLVL_MIN, DISPXYSCATTER) { } diff --git a/gnuradio-core/src/lib/general/gr_tag_debug.cc b/gnuradio-core/src/lib/general/gr_tag_debug.cc index ecf1b65e1f..9c66e890af 100644 --- a/gnuradio-core/src/lib/general/gr_tag_debug.cc +++ b/gnuradio-core/src/lib/general/gr_tag_debug.cc @@ -84,8 +84,8 @@ gr_tag_debug::work(int noutput_items, sout << "Input Stream: " << std::setw(2) << std::setfill('0') << i << std::setfill(' ') << std::endl; for(d_tags_itr = d_tags.begin(); d_tags_itr != d_tags.end(); d_tags_itr++) { sout << std::setw(10) << "Offset: " << d_tags_itr->offset - << 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) + << std::setw(10) << "Source: " << (pmt::is_symbol(d_tags_itr->srcid) ? pmt::symbol_to_string(d_tags_itr->srcid) : "n/a") + << std::setw(10) << "Key: " << pmt::symbol_to_string(d_tags_itr->key) << std::setw(10) << "Value: "; sout << d_tags_itr->value << std::endl; } diff --git a/gnuradio-core/src/lib/io/gr_message_burst_source.cc b/gnuradio-core/src/lib/io/gr_message_burst_source.cc index e9e2dfd4dc..968df6ec38 100644 --- a/gnuradio-core/src/lib/io/gr_message_burst_source.cc +++ b/gnuradio-core/src/lib/io/gr_message_burst_source.cc @@ -58,7 +58,7 @@ gr_message_burst_source::gr_message_burst_source (size_t itemsize, int msgq_limi { std::stringstream id; id << name() << unique_id(); - d_me = pmt::pmt_string_to_symbol(id.str()); + d_me = pmt::string_to_symbol(id.str()); } gr_message_burst_source::gr_message_burst_source (size_t itemsize, gr_msg_queue_sptr msgq) @@ -69,7 +69,7 @@ gr_message_burst_source::gr_message_burst_source (size_t itemsize, gr_msg_queue_ { std::stringstream id; id << name() << unique_id(); - d_me = pmt::pmt_string_to_symbol(id.str()); + d_me = pmt::string_to_symbol(id.str()); } gr_message_burst_source::~gr_message_burst_source() @@ -107,8 +107,8 @@ gr_message_burst_source::work(int noutput_items, //tag end of burst add_item_tag(0, //stream ID abs_sample_count+nn-1, //sample number - pmt::pmt_string_to_symbol("tx_eob"), - pmt::pmt_from_bool(1), + pmt::string_to_symbol("tx_eob"), + pmt::from_bool(1), d_me //block src id ); } @@ -129,8 +129,8 @@ gr_message_burst_source::work(int noutput_items, //tag start of burst add_item_tag(0, //stream ID abs_sample_count+nn, //sample number - pmt::pmt_string_to_symbol("tx_sob"), - pmt::pmt_from_bool(1), + pmt::string_to_symbol("tx_sob"), + pmt::from_bool(1), d_me //block src id ); diff --git a/gnuradio-core/src/lib/io/gr_message_debug.cc b/gnuradio-core/src/lib/io/gr_message_debug.cc index 27f4c65fdc..a0abf4d093 100644 --- a/gnuradio-core/src/lib/io/gr_message_debug.cc +++ b/gnuradio-core/src/lib/io/gr_message_debug.cc @@ -47,7 +47,7 @@ void gr_message_debug::print(pmt::pmt_t msg) { std::cout << "******* MESSAGE DEBUG PRINT ********\n"; - pmt::pmt_print(msg); + pmt::print(msg); std::cout << "************************************\n"; } @@ -61,15 +61,15 @@ gr_message_debug::store(pmt::pmt_t msg) void gr_message_debug::print_verbose(pmt::pmt_t msg) { - pmt::pmt_t meta = pmt::pmt_car(msg); - pmt::pmt_t vector = pmt::pmt_cdr(msg); + pmt::pmt_t meta = pmt::car(msg); + pmt::pmt_t vector = pmt::cdr(msg); std::cout << "* MESSAGE DEBUG PRINT PDU VERBOSE *\n"; - pmt::pmt_print(meta); - size_t len = pmt::pmt_length(vector); + pmt::print(meta); + size_t len = pmt::length(vector); std::cout << "pdu_length = " << len << std::endl; std::cout << "contents = " << std::endl; size_t offset(0); - const uint8_t* d = (const uint8_t*) pmt_uniform_vector_elements(vector, offset); + const uint8_t* d = (const uint8_t*) uniform_vector_elements(vector, offset); for(size_t i=0; i<len; i+=16){ printf("%04x: ", i); for(size_t j=i; j<std::min(i+16,len); j++){ diff --git a/gnuradio-core/src/lib/io/gr_pdu.cc b/gnuradio-core/src/lib/io/gr_pdu.cc index b2757c307e..c9202647d0 100644 --- a/gnuradio-core/src/lib/io/gr_pdu.cc +++ b/gnuradio-core/src/lib/io/gr_pdu.cc @@ -44,11 +44,11 @@ bool gr_pdu_type_matches(gr_pdu_vector_type type, pmt::pmt_t v){ switch(type){ case BYTE: - return pmt::pmt_is_u8vector(v); + return pmt::is_u8vector(v); case FLOAT: - return pmt::pmt_is_f32vector(v); + return pmt::is_f32vector(v); case COMPLEX: - return pmt::pmt_is_c32vector(v); + return pmt::is_c32vector(v); default: throw std::runtime_error("bad type!"); } @@ -58,22 +58,22 @@ pmt::pmt_t gr_pdu_make_vector(gr_pdu_vector_type type, const uint8_t* buf, size_t items){ switch(type){ case BYTE: - return pmt::pmt_init_u8vector(items, buf); + return pmt::init_u8vector(items, buf); case FLOAT: - return pmt::pmt_init_f32vector(items, (const float*)buf); + return pmt::init_f32vector(items, (const float*)buf); case COMPLEX: - return pmt::pmt_init_c32vector(items, (const gr_complex*)buf); + return pmt::init_c32vector(items, (const gr_complex*)buf); default: throw std::runtime_error("bad type!"); } } gr_pdu_vector_type type_from_pmt(pmt::pmt_t vector){ - if(pmt_is_u8vector(vector)) + if(is_u8vector(vector)) return BYTE; - if(pmt_is_f32vector(vector)) + if(is_f32vector(vector)) return FLOAT; - if(pmt_is_c32vector(vector)) + if(is_c32vector(vector)) return COMPLEX; throw std::runtime_error("bad type!"); } diff --git a/gnuradio-core/src/lib/io/gr_pdu_to_tagged_stream.cc b/gnuradio-core/src/lib/io/gr_pdu_to_tagged_stream.cc index 5c319dc39d..9354a1366d 100644 --- a/gnuradio-core/src/lib/io/gr_pdu_to_tagged_stream.cc +++ b/gnuradio-core/src/lib/io/gr_pdu_to_tagged_stream.cc @@ -84,46 +84,46 @@ gr_pdu_to_tagged_stream::work(int noutput_items, } // make sure type is valid - if(!pmt::pmt_is_pair(msg)){ + if(!pmt::is_pair(msg)){ throw std::runtime_error("received a malformed pdu message!"); } // printf("got a msg\n"); -// pmt::pmt_print(msg); +// pmt::print(msg); // grab the components of the pdu message - 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? + pmt::pmt_t meta(pmt::car(msg)); // make sure this is NIL || Dict ? + pmt::pmt_t vect(pmt::cdr(msg)); // make sure this is a vector? // compute offset for output tag uint64_t offset = nitems_written(0) + nout; // add a tag for pdu length - add_item_tag(0, offset, pdu_length_tag, pmt::pmt_from_long( pmt::pmt_length(vect) ), pmt::mp(alias())); + add_item_tag(0, offset, pdu_length_tag, pmt::from_long( pmt::length(vect) ), pmt::mp(alias())); // if we recieved metadata add it as tags - 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)); + if( !eq(meta, pmt::PMT_NIL) ){ + pmt::pmt_t pair(pmt::dict_keys( meta )); + while( !eq(pair, pmt::PMT_NIL) ){ + pmt::pmt_t k(pmt::cdr(pair)); + pmt::pmt_t v(pmt::dict_ref(meta, k, pmt::PMT_NIL)); add_item_tag(0, offset, k, v, pmt::mp(alias())); } } // copy vector output - size_t ncopy = std::min((size_t)noutput_items, (size_t)pmt::pmt_length(vect)); - size_t nsave = pmt::pmt_length(vect) - ncopy; + size_t ncopy = std::min((size_t)noutput_items, (size_t)pmt::length(vect)); + size_t nsave = pmt::length(vect) - ncopy; // copy output size_t io(0); nout += ncopy; - memcpy(out, pmt_uniform_vector_elements(vect,io), ncopy*d_itemsize); + memcpy(out, uniform_vector_elements(vect,io), ncopy*d_itemsize); // save leftover items if needed for next work call if(nsave > 0){ d_remain.resize(nsave*d_itemsize, 0); - memcpy(&d_remain[0], pmt_uniform_vector_elements(vect,ncopy), nsave*d_itemsize); + memcpy(&d_remain[0], uniform_vector_elements(vect,ncopy), nsave*d_itemsize); } } diff --git a/gnuradio-core/src/lib/io/gr_socket_pdu.cc b/gnuradio-core/src/lib/io/gr_socket_pdu.cc index bb374b3006..366ca507bc 100644 --- a/gnuradio-core/src/lib/io/gr_socket_pdu.cc +++ b/gnuradio-core/src/lib/io/gr_socket_pdu.cc @@ -114,8 +114,8 @@ void tcp_connection::handle_read(const boost::system::error_code& error/*error*/ { if(!error) { - 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::init_u8vector(bytes_transferred, (const uint8_t*)&buf[0]); + pmt::pmt_t pdu = pmt::cons( pmt::PMT_NIL, vector); d_block->message_port_pub( pmt::mp("pdus"), pdu ); @@ -131,27 +131,27 @@ void tcp_connection::handle_read(const boost::system::error_code& error/*error*/ void gr_socket_pdu::tcp_server_send(pmt::pmt_t msg){ - pmt::pmt_t vector = pmt::pmt_cdr(msg); + pmt::pmt_t vector = pmt::cdr(msg); for(size_t i=0; i<d_tcp_connections.size(); i++){ d_tcp_connections[i]->send(vector); } } void gr_socket_pdu::tcp_client_send(pmt::pmt_t msg){ - pmt::pmt_t vector = pmt::pmt_cdr(msg); - size_t len = pmt::pmt_length(vector); + pmt::pmt_t vector = pmt::cdr(msg); + size_t len = pmt::length(vector); size_t offset(0); boost::array<char, 10000> txbuf; - memcpy(&txbuf[0], pmt::pmt_uniform_vector_elements(vector, offset), len); + memcpy(&txbuf[0], pmt::uniform_vector_elements(vector, offset), len); _tcp_socket->send(boost::asio::buffer(txbuf,len)); } void gr_socket_pdu::udp_send(pmt::pmt_t msg){ - pmt::pmt_t vector = pmt::pmt_cdr(msg); - size_t len = pmt::pmt_length(vector); + pmt::pmt_t vector = pmt::cdr(msg); + size_t len = pmt::length(vector); size_t offset(0); boost::array<char, 10000> txbuf; - memcpy(&txbuf[0], pmt::pmt_uniform_vector_elements(vector, offset), len); + memcpy(&txbuf[0], pmt::uniform_vector_elements(vector, offset), len); if(_udp_endpoint_other.address().to_string() != "0.0.0.0") _udp_socket->send_to(boost::asio::buffer(txbuf,len), _udp_endpoint_other); } diff --git a/gnuradio-core/src/lib/io/gr_socket_pdu.h b/gnuradio-core/src/lib/io/gr_socket_pdu.h index f554febdc1..4e58006028 100644 --- a/gnuradio-core/src/lib/io/gr_socket_pdu.h +++ b/gnuradio-core/src/lib/io/gr_socket_pdu.h @@ -67,10 +67,10 @@ public: boost::bind(&tcp_connection::handle_read, this, boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)); } void send(pmt::pmt_t vector){ - size_t len = pmt::pmt_length(vector); + size_t len = pmt::length(vector); size_t offset(0); boost::array<char, 10000> txbuf; - memcpy(&txbuf[0], pmt::pmt_uniform_vector_elements(vector, offset), len); + memcpy(&txbuf[0], pmt::uniform_vector_elements(vector, offset), len); boost::asio::async_write(socket_, boost::asio::buffer(txbuf, len), boost::bind(&tcp_connection::handle_write, shared_from_this(), boost::asio::placeholders::error, @@ -160,8 +160,8 @@ class GR_CORE_API gr_socket_pdu : public gr_stream_pdu_base void handle_udp_read(const boost::system::error_code& error/*error*/, size_t bytes_transferred){ if(!error){ - 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::init_u8vector(bytes_transferred, (const uint8_t*)&rxbuf[0]); + pmt::pmt_t pdu = pmt::cons( pmt::PMT_NIL, vector); message_port_pub( pmt::mp("pdus"), pdu ); @@ -177,8 +177,8 @@ class GR_CORE_API gr_socket_pdu : public gr_stream_pdu_base void handle_tcp_read(const boost::system::error_code& error/*error*/, size_t bytes_transferred){ if(!error) { - 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::init_u8vector(bytes_transferred, (const uint8_t*)&rxbuf[0]); + pmt::pmt_t pdu = pmt::cons( pmt::PMT_NIL, vector); message_port_pub( pmt::mp("pdus"), pdu ); diff --git a/gnuradio-core/src/lib/io/gr_stream_pdu_base.cc b/gnuradio-core/src/lib/io/gr_stream_pdu_base.cc index cff7296cba..108424d393 100644 --- a/gnuradio-core/src/lib/io/gr_stream_pdu_base.cc +++ b/gnuradio-core/src/lib/io/gr_stream_pdu_base.cc @@ -73,19 +73,19 @@ void gr_stream_pdu_base::run(){ if(not wait_ready()){ continue; } const int result = read( d_fd, &d_rxbuf[0], d_rxbuf.size() ); if(result <= 0){ throw std::runtime_error("gr_stream_pdu_base, bad socket read!"); } - 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::init_u8vector(result, &d_rxbuf[0]); + pmt::pmt_t pdu = pmt::cons( pmt::PMT_NIL, vector); message_port_pub(rxport, pdu); } } void gr_stream_pdu_base::send(pmt::pmt_t msg){ - pmt::pmt_t vector = pmt::pmt_cdr(msg); + pmt::pmt_t vector = pmt::cdr(msg); size_t offset(0); size_t itemsize(gr_pdu_itemsize(type_from_pmt(vector))); - int len( pmt::pmt_length(vector)*itemsize ); + int len( pmt::length(vector)*itemsize ); - const int rv = write(d_fd, pmt::pmt_uniform_vector_elements(vector, offset), len); + const int rv = write(d_fd, pmt::uniform_vector_elements(vector, offset), len); if(rv != len){ std::cerr << boost::format("WARNING: gr_stream_pdu_base::send(pdu) write failed! (d_fd=%d, len=%d, rv=%d)") % d_fd % len % rv << std::endl; diff --git a/gnuradio-core/src/lib/io/gr_tagged_file_sink.cc b/gnuradio-core/src/lib/io/gr_tagged_file_sink.cc index c9c8407a07..3288fcdd60 100644 --- a/gnuradio-core/src/lib/io/gr_tagged_file_sink.cc +++ b/gnuradio-core/src/lib/io/gr_tagged_file_sink.cc @@ -81,8 +81,8 @@ gr_tagged_file_sink::work (int noutput_items, uint64_t start_N = nitems_read(0); uint64_t end_N = start_N + (uint64_t)(noutput_items); - 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 + pmt::pmt_t bkey = pmt::string_to_symbol("burst"); + pmt::pmt_t tkey = pmt::string_to_symbol("rx_time"); // use gr_tags::key_time std::vector<gr_tag_t> all_tags; get_tags_in_range(all_tags, 0, start_N, end_N); @@ -98,8 +98,8 @@ gr_tagged_file_sink::work (int noutput_items, const gr_tag_t tag = time_tags_outer[0]; uint64_t offset = tag.offset; pmt::pmt_t time = tag.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)); + uint64_t tsecs = pmt::to_uint64(pmt::tuple_ref(time, 0)); + double tfrac = pmt::to_double(pmt::tuple_ref(time, 1)); double delta = (double)offset / d_sample_rate; d_timeval = (double)tsecs + tfrac + delta; d_last_N = offset; @@ -109,8 +109,8 @@ gr_tagged_file_sink::work (int noutput_items, while(idx < noutput_items) { if(d_state == NOT_IN_BURST) { while(vitr != all_tags.end()) { - if((pmt::pmt_eqv((*vitr).key, bkey)) && - pmt::pmt_is_true((*vitr).value)) { + if((pmt::eqv((*vitr).key, bkey)) && + pmt::is_true((*vitr).value)) { uint64_t N = (*vitr).offset; idx = (int)(N - start_N); @@ -130,8 +130,8 @@ gr_tagged_file_sink::work (int noutput_items, // Get time based on last time tag from USRP pmt::pmt_t time = tag.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)); + uint64_t tsecs = pmt::to_uint64(pmt::tuple_ref(time, 0)); + double tfrac = pmt::to_double(pmt::tuple_ref(time, 1)); // Get new time from last time tag + difference in time to when // burst tag occured based on the sample rate @@ -187,8 +187,8 @@ gr_tagged_file_sink::work (int noutput_items, } else { // In burst while(vitr != all_tags.end()) { - if((pmt::pmt_eqv((*vitr).key, bkey)) && - pmt::pmt_is_false((*vitr).value)) { + if((pmt::eqv((*vitr).key, bkey)) && + pmt::is_false((*vitr).value)) { uint64_t N = (*vitr).offset; idx_stop = (int)N - start_N; diff --git a/gnuradio-core/src/lib/io/gr_tagged_stream_to_pdu.cc b/gnuradio-core/src/lib/io/gr_tagged_stream_to_pdu.cc index 8211b7672d..3493f6a389 100644 --- a/gnuradio-core/src/lib/io/gr_tagged_stream_to_pdu.cc +++ b/gnuradio-core/src/lib/io/gr_tagged_stream_to_pdu.cc @@ -70,14 +70,14 @@ gr_tagged_stream_to_pdu::work(int noutput_items, get_tags_in_range(d_tags, 0, abs_N, abs_N+1); bool found_length_tag(false); for(d_tags_itr = d_tags.begin(); (d_tags_itr != d_tags.end()) && (!found_length_tag); d_tags_itr++){ - if( pmt::pmt_equal( (*d_tags_itr).key, pdu_length_tag ) ){ + if( pmt::equal( (*d_tags_itr).key, pdu_length_tag ) ){ if( (*d_tags_itr).offset != abs_N ){ throw std::runtime_error("expected next pdu length tag on a different item..."); } found_length_tag = true; - d_pdu_length = pmt::pmt_to_long( (*d_tags_itr).value ); + d_pdu_length = pmt::to_long( (*d_tags_itr).value ); d_pdu_remain = d_pdu_length; - d_pdu_meta = pmt::pmt_make_dict(); + d_pdu_meta = pmt::make_dict(); break; } // if have length tag } // iter over tags @@ -91,8 +91,8 @@ gr_tagged_stream_to_pdu::work(int noutput_items, // copy any tags in this range into our meta object get_tags_in_range(d_tags, 0, abs_N, abs_N+ncopy); for(d_tags_itr = d_tags.begin(); d_tags_itr != d_tags.end(); d_tags_itr++){ - 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( ! equal( (*d_tags_itr).key, pdu_length_tag ) ){ + d_pdu_meta = dict_add(d_pdu_meta, (*d_tags_itr).key, (*d_tags_itr).value); } } @@ -122,11 +122,11 @@ gr_tagged_stream_to_pdu::work(int noutput_items, void gr_tagged_stream_to_pdu::send_message(){ - if(pmt::pmt_length(d_pdu_vector) != d_pdu_length){ + if(pmt::length(d_pdu_vector) != d_pdu_length){ throw std::runtime_error("msg length not correct"); } - pmt::pmt_t msg = pmt::pmt_cons( d_pdu_meta, d_pdu_vector ); + pmt::pmt_t msg = pmt::cons( d_pdu_meta, d_pdu_vector ); message_port_pub( pdu_port_id, msg ); d_pdu_meta = pmt::PMT_NIL; diff --git a/gnuradio-core/src/lib/runtime/gr_basic_block.cc b/gnuradio-core/src/lib/runtime/gr_basic_block.cc index 6ff57a1d6c..2530391532 100644 --- a/gnuradio-core/src/lib/runtime/gr_basic_block.cc +++ b/gnuradio-core/src/lib/runtime/gr_basic_block.cc @@ -30,8 +30,6 @@ #include <sstream> #include <iostream> -using namespace pmt; - static long s_next_id = 0; static long s_ncurrently_allocated = 0; @@ -51,7 +49,7 @@ gr_basic_block::gr_basic_block(const std::string &name, d_symbolic_id(global_block_registry.block_register(this)), d_symbol_name(global_block_registry.register_symbolic_name(this)), d_color(WHITE), - message_subscribers(pmt::pmt_make_dict()) + message_subscribers(pmt::make_dict()) { s_ncurrently_allocated++; } @@ -80,7 +78,7 @@ gr_basic_block::set_block_alias(std::string name) void gr_basic_block::message_port_register_in(pmt::pmt_t port_id) { - if(!pmt::pmt_is_symbol(port_id)) { + if(!pmt::is_symbol(port_id)) { throw std::runtime_error("message_port_register_in: bad port id"); } msg_queue[port_id] = msg_queue_t(); @@ -90,10 +88,10 @@ gr_basic_block::message_port_register_in(pmt::pmt_t port_id) pmt::pmt_t gr_basic_block::message_ports_in() { - pmt::pmt_t port_names = pmt::pmt_make_vector(msg_queue.size(), pmt::PMT_NIL); + pmt::pmt_t port_names = pmt::make_vector(msg_queue.size(), pmt::PMT_NIL); msg_queue_map_itr itr = msg_queue.begin(); for(size_t i = 0; i < msg_queue.size(); i++) { - pmt::pmt_vector_set(port_names, i, (*itr).first); + pmt::vector_set(port_names, i, (*itr).first); itr++; } return port_names; @@ -103,23 +101,23 @@ gr_basic_block::message_ports_in() void gr_basic_block::message_port_register_out(pmt::pmt_t port_id) { - if(!pmt::pmt_is_symbol(port_id)) { + if(!pmt::is_symbol(port_id)) { throw std::runtime_error("message_port_register_out: bad port id"); } - if(pmt::pmt_dict_has_key(message_subscribers, port_id)) { + if(pmt::dict_has_key(message_subscribers, port_id)) { throw std::runtime_error("message_port_register_out: port already in use"); } - message_subscribers = pmt::pmt_dict_add(message_subscribers, port_id, pmt::PMT_NIL); + message_subscribers = pmt::dict_add(message_subscribers, port_id, pmt::PMT_NIL); } pmt::pmt_t gr_basic_block::message_ports_out() { - 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); + size_t len = pmt::length(message_subscribers); + pmt::pmt_t port_names = pmt::make_vector(len, pmt::PMT_NIL); + pmt::pmt_t keys = pmt::dict_keys(message_subscribers); for(size_t i = 0; i < len; i++) { - pmt::pmt_vector_set(port_names, i, pmt::pmt_nth(i, keys)); + pmt::vector_set(port_names, i, pmt::nth(i, keys)); } return port_names; } @@ -127,19 +125,19 @@ gr_basic_block::message_ports_out() // - publish a message on a message port void gr_basic_block::message_port_pub(pmt::pmt_t port_id, pmt::pmt_t msg) { - if(!pmt::pmt_dict_has_key(message_subscribers, port_id)) { + if(!pmt::dict_has_key(message_subscribers, port_id)) { throw std::runtime_error("port does not exist"); } - pmt::pmt_t currlist = pmt::pmt_dict_ref(message_subscribers, port_id, pmt::PMT_NIL); + pmt::pmt_t currlist = pmt::dict_ref(message_subscribers, port_id, pmt::PMT_NIL); // iterate through subscribers on port - while(pmt::pmt_is_pair(currlist)) { - pmt::pmt_t target = pmt::pmt_car(currlist); + while(pmt::is_pair(currlist)) { + pmt::pmt_t target = pmt::car(currlist); - pmt::pmt_t block = pmt::pmt_car(target); - pmt::pmt_t port = pmt::pmt_cdr(target); + pmt::pmt_t block = pmt::car(target); + pmt::pmt_t port = pmt::cdr(target); - currlist = pmt::pmt_cdr(currlist); + currlist = pmt::cdr(currlist); gr_basic_block_sptr blk = global_block_registry.block_lookup(block); //blk->post(msg); blk->post(port, msg); @@ -149,33 +147,33 @@ void gr_basic_block::message_port_pub(pmt::pmt_t port_id, pmt::pmt_t msg) // - subscribe to a message port void gr_basic_block::message_port_sub(pmt::pmt_t port_id, pmt::pmt_t target){ - if(!pmt::pmt_dict_has_key(message_subscribers, port_id)){ + if(!pmt::dict_has_key(message_subscribers, port_id)){ std::stringstream ss; - ss << "Port does not exist: \"" << pmt::pmt_write_string(port_id) << "\" on block: " << pmt::pmt_write_string(target) << std::endl; + ss << "Port does not exist: \"" << pmt::write_string(port_id) << "\" on block: " << pmt::write_string(target) << std::endl; throw std::runtime_error(ss.str()); } - pmt::pmt_t currlist = pmt::pmt_dict_ref(message_subscribers,port_id,pmt::PMT_NIL); + pmt::pmt_t currlist = pmt::dict_ref(message_subscribers,port_id,pmt::PMT_NIL); // ignore re-adds of the same target - 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::list_has(currlist, target)) + message_subscribers = pmt::dict_add(message_subscribers,port_id,pmt::list_add(currlist,target)); } void gr_basic_block::message_port_unsub(pmt::pmt_t port_id, pmt::pmt_t target){ - if(!pmt::pmt_dict_has_key(message_subscribers, port_id)){ + if(!pmt::dict_has_key(message_subscribers, port_id)){ std::stringstream ss; - ss << "Port does not exist: \"" << pmt::pmt_write_string(port_id) << "\" on block: " << pmt::pmt_write_string(target) << std::endl; + ss << "Port does not exist: \"" << pmt::write_string(port_id) << "\" on block: " << pmt::write_string(target) << std::endl; throw std::runtime_error(ss.str()); } // ignore unsubs of unknown targets - 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)); + pmt::pmt_t currlist = pmt::dict_ref(message_subscribers,port_id,pmt::PMT_NIL); + message_subscribers = pmt::dict_add(message_subscribers,port_id,pmt::list_rm(currlist,target)); } void -gr_basic_block::_post(pmt_t which_port, pmt_t msg) +gr_basic_block::_post(pmt::pmt_t which_port, pmt::pmt_t msg) { insert_tail(which_port, msg); } @@ -186,7 +184,7 @@ gr_basic_block::insert_tail(pmt::pmt_t which_port, pmt::pmt_t msg) gruel::scoped_lock guard(mutex); if( (msg_queue.find(which_port) == msg_queue.end()) || (msg_queue_ready.find(which_port) == msg_queue_ready.end())){ - std::cout << "target port = " << pmt::pmt_symbol_to_string(which_port) << std::endl; + std::cout << "target port = " << pmt::symbol_to_string(which_port) << std::endl; throw std::runtime_error("attempted to insert_tail on invalid queue!"); } @@ -197,7 +195,7 @@ gr_basic_block::insert_tail(pmt::pmt_t which_port, pmt::pmt_t msg) global_block_registry.notify_blk(alias()); } -pmt_t +pmt::pmt_t gr_basic_block::delete_head_nowait(pmt::pmt_t which_port) { gruel::scoped_lock guard(mutex); @@ -206,13 +204,13 @@ gr_basic_block::delete_head_nowait(pmt::pmt_t which_port) return pmt::pmt_t(); } - pmt_t m(msg_queue[which_port].front()); + pmt::pmt_t m(msg_queue[which_port].front()); msg_queue[which_port].pop_front(); return m; } -pmt_t +pmt::pmt_t gr_basic_block::delete_head_blocking(pmt::pmt_t which_port) { gruel::scoped_lock guard(mutex); @@ -221,7 +219,7 @@ gr_basic_block::delete_head_blocking(pmt::pmt_t which_port) msg_queue_ready[which_port]->wait(guard); } - pmt_t m(msg_queue[which_port].front()); + pmt::pmt_t m(msg_queue[which_port].front()); msg_queue[which_port].pop_front(); return m; } diff --git a/gnuradio-core/src/lib/runtime/gr_basic_block.h b/gnuradio-core/src/lib/runtime/gr_basic_block.h index 33528f2b2f..5e00a4f22a 100644 --- a/gnuradio-core/src/lib/runtime/gr_basic_block.h +++ b/gnuradio-core/src/lib/runtime/gr_basic_block.h @@ -72,13 +72,13 @@ class GR_CORE_API gr_basic_block : public gr_msg_accepter, public boost::enable_ }; //msg_handler_t d_msg_handler; - typedef std::map<pmt::pmt_t , msg_handler_t, pmt::pmt_comperator> d_msg_handlers_t; + typedef std::map<pmt::pmt_t , msg_handler_t, pmt::comperator> d_msg_handlers_t; d_msg_handlers_t d_msg_handlers; typedef std::deque<pmt::pmt_t> msg_queue_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; + typedef std::map<pmt::pmt_t, msg_queue_t, pmt::comperator> msg_queue_map_t; + typedef std::map<pmt::pmt_t, msg_queue_t, pmt::comperator>::iterator msg_queue_map_itr; + std::map<pmt::pmt_t, boost::shared_ptr<boost::condition_variable>, pmt::comperator> msg_queue_ready; gruel::mutex mutex; //< protects all vars @@ -138,7 +138,7 @@ class GR_CORE_API gr_basic_block : public gr_msg_accepter, public boost::enable_ gr_basic_block_sptr to_basic_block(); // Needed for Python type coercion bool alias_set() { return !d_symbol_alias.empty(); } std::string alias(){ return alias_set()?d_symbol_alias:symbol_name(); } - pmt::pmt_t alias_pmt(){ return pmt::pmt_intern(alias()); } + pmt::pmt_t alias_pmt(){ return pmt::intern(alias()); } void set_block_alias(std::string name); // ** Message passing interface ** @@ -210,7 +210,7 @@ class GR_CORE_API gr_basic_block : public gr_msg_accepter, public boost::enable_ if(msg_queue.find(which_port) != msg_queue.end()){ return true; } - if(pmt::pmt_dict_has_key(message_subscribers, which_port)){ + if(pmt::dict_has_key(message_subscribers, which_port)){ return true; } return false; diff --git a/gnuradio-core/src/lib/runtime/gr_block_detail.cc b/gnuradio-core/src/lib/runtime/gr_block_detail.cc index 337c9518ef..ebe89d930e 100644 --- a/gnuradio-core/src/lib/runtime/gr_block_detail.cc +++ b/gnuradio-core/src/lib/runtime/gr_block_detail.cc @@ -27,8 +27,6 @@ #include <gr_block_detail.h> #include <gr_buffer.h> -using namespace pmt; - static long s_ncurrently_allocated = 0; long @@ -146,8 +144,8 @@ gr_block_detail::nitems_written(unsigned int which_output) void gr_block_detail::add_item_tag(unsigned int which_output, const gr_tag_t &tag) { - if(!pmt_is_symbol(tag.key)) { - throw pmt_wrong_type("gr_block_detail::add_item_tag key", tag.key); + if(!pmt::is_symbol(tag.key)) { + throw pmt::wrong_type("gr_block_detail::add_item_tag key", tag.key); } else { // Add tag to gr_buffer's deque tags @@ -170,7 +168,7 @@ gr_block_detail::get_tags_in_range(std::vector<gr_tag_t> &v, unsigned int which_input, uint64_t abs_start, uint64_t abs_end, - const pmt_t &key) + const pmt::pmt_t &key) { std::vector<gr_tag_t> found_items; @@ -180,11 +178,11 @@ gr_block_detail::get_tags_in_range(std::vector<gr_tag_t> &v, d_input[which_input]->get_tags_in_range(found_items, abs_start, abs_end); // Filter further by key name - pmt_t itemkey; + pmt::pmt_t itemkey; std::vector<gr_tag_t>::iterator itr; for(itr = found_items.begin(); itr != found_items.end(); itr++) { itemkey = (*itr).key; - if(pmt_eqv(key, itemkey)) { + if(pmt::eqv(key, itemkey)) { v.push_back(*itr); } } diff --git a/gnuradio-core/src/lib/runtime/gr_block_registry.cc b/gnuradio-core/src/lib/runtime/gr_block_registry.cc index ff23d97eb2..eaa770dcaf 100644 --- a/gnuradio-core/src/lib/runtime/gr_block_registry.cc +++ b/gnuradio-core/src/lib/runtime/gr_block_registry.cc @@ -8,7 +8,7 @@ gr_block_registry global_block_registry; gr_block_registry::gr_block_registry(){ - d_ref_map = pmt::pmt_make_dict(); + d_ref_map = pmt::make_dict(); } long gr_block_registry::block_register(gr_basic_block* block){ @@ -29,9 +29,9 @@ long gr_block_registry::block_register(gr_basic_block* block){ void gr_block_registry::block_unregister(gr_basic_block* block){ d_map[block->name()].erase( d_map[block->name()].find(block->symbolic_id())); - d_ref_map = pmt::pmt_dict_delete(d_ref_map, pmt::pmt_intern(block->symbol_name())); + d_ref_map = pmt::dict_delete(d_ref_map, pmt::intern(block->symbol_name())); if(block->alias_set()){ - d_ref_map = pmt::pmt_dict_delete(d_ref_map, pmt::pmt_intern(block->alias())); + d_ref_map = pmt::dict_delete(d_ref_map, pmt::intern(block->alias())); } } @@ -44,18 +44,18 @@ std::string gr_block_registry::register_symbolic_name(gr_basic_block* block){ } void gr_block_registry::register_symbolic_name(gr_basic_block* block, std::string name){ - if(pmt_dict_has_key(d_ref_map, pmt::pmt_intern(name))){ + if(dict_has_key(d_ref_map, pmt::intern(name))){ throw std::runtime_error("symbol already exists, can not re-use!"); } - d_ref_map = pmt_dict_add(d_ref_map, pmt::pmt_intern(name), pmt::pmt_make_any(block)); + d_ref_map = dict_add(d_ref_map, pmt::intern(name), pmt::make_any(block)); } gr_basic_block_sptr gr_block_registry::block_lookup(pmt::pmt_t symbol){ - pmt::pmt_t ref = pmt_dict_ref(d_ref_map, symbol, pmt::PMT_NIL); - if(pmt::pmt_eq(ref, pmt::PMT_NIL)){ + pmt::pmt_t ref = dict_ref(d_ref_map, symbol, pmt::PMT_NIL); + if(pmt::eq(ref, pmt::PMT_NIL)){ throw std::runtime_error("block lookup failed! block not found!"); } - gr_basic_block* blk = boost::any_cast<gr_basic_block*>( pmt::pmt_any_ref(ref) ); + gr_basic_block* blk = boost::any_cast<gr_basic_block*>( pmt::any_ref(ref) ); return blk->shared_from_this(); } diff --git a/gnuradio-core/src/lib/runtime/gr_flat_flowgraph.cc b/gnuradio-core/src/lib/runtime/gr_flat_flowgraph.cc index 9294a5dca2..e7b75d95cd 100644 --- a/gnuradio-core/src/lib/runtime/gr_flat_flowgraph.cc +++ b/gnuradio-core/src/lib/runtime/gr_flat_flowgraph.cc @@ -78,7 +78,7 @@ gr_flat_flowgraph::setup_connections() std::cout << boost::format("flat_fg connecting msg primitives: (%s, %s)->(%s, %s)\n") % i->src().block() % i->src().port() % i->dst().block() % i->dst().port(); - i->src().block()->message_port_sub( i->src().port(), pmt::pmt_cons(i->dst().block()->alias_pmt(), i->dst().port()) ); + i->src().block()->message_port_sub( i->src().port(), pmt::cons(i->dst().block()->alias_pmt(), i->dst().port()) ); } } diff --git a/gnuradio-core/src/lib/runtime/gr_flowgraph.h b/gnuradio-core/src/lib/runtime/gr_flowgraph.h index bef70f626f..3c8cd3cb02 100644 --- a/gnuradio-core/src/lib/runtime/gr_flowgraph.h +++ b/gnuradio-core/src/lib/runtime/gr_flowgraph.h @@ -73,7 +73,7 @@ public: inline bool gr_msg_endpoint::operator==(const gr_msg_endpoint &other) const { return (d_basic_block == other.d_basic_block && - pmt::pmt_equal(d_port, other.d_port)); + pmt::equal(d_port, other.d_port)); } diff --git a/gnuradio-core/src/lib/runtime/gr_hier_block2.cc b/gnuradio-core/src/lib/runtime/gr_hier_block2.cc index 8c2794c63c..9e924fdaf5 100644 --- a/gnuradio-core/src/lib/runtime/gr_hier_block2.cc +++ b/gnuradio-core/src/lib/runtime/gr_hier_block2.cc @@ -86,7 +86,7 @@ void gr_hier_block2::msg_connect(gr_basic_block_sptr src, pmt::pmt_t srcport, gr_basic_block_sptr dst, pmt::pmt_t dstport) { - if(!pmt::pmt_is_symbol(srcport)){throw std::runtime_error("bad port id"); } + if(!pmt::is_symbol(srcport)){throw std::runtime_error("bad port id"); } d_detail->msg_connect(src, srcport, dst, dstport); } @@ -101,7 +101,7 @@ void gr_hier_block2::msg_disconnect(gr_basic_block_sptr src, pmt::pmt_t srcport, gr_basic_block_sptr dst, pmt::pmt_t dstport) { - if(!pmt::pmt_is_symbol(srcport)){throw std::runtime_error("bad port id"); } + if(!pmt::is_symbol(srcport)){throw std::runtime_error("bad port id"); } d_detail->msg_disconnect(src, srcport, dst, dstport); } diff --git a/gnuradio-core/src/lib/runtime/gr_hier_block2.h b/gnuradio-core/src/lib/runtime/gr_hier_block2.h index f80dd73e4b..aa6b180cac 100644 --- a/gnuradio-core/src/lib/runtime/gr_hier_block2.h +++ b/gnuradio-core/src/lib/runtime/gr_hier_block2.h @@ -175,28 +175,28 @@ public: return message_port_is_hier_in(port_id) || message_port_is_hier_out(port_id); } bool message_port_is_hier_in(pmt::pmt_t port_id){ - return pmt::pmt_list_has(hier_message_ports_in, port_id); + return pmt::list_has(hier_message_ports_in, port_id); } bool message_port_is_hier_out(pmt::pmt_t port_id){ - return pmt::pmt_list_has(hier_message_ports_out, port_id); + return pmt::list_has(hier_message_ports_out, port_id); } pmt::pmt_t hier_message_ports_in; pmt::pmt_t hier_message_ports_out; void message_port_register_hier_in(pmt::pmt_t port_id){ - if(pmt::pmt_list_has(hier_message_ports_in, port_id)) + if(pmt::list_has(hier_message_ports_in, port_id)) throw std::invalid_argument("hier msg in port by this name already registered"); if(msg_queue.find(port_id) != msg_queue.end()) throw std::invalid_argument("block already has a primitive input port by this name"); - hier_message_ports_in = pmt::pmt_list_add(hier_message_ports_in, port_id); + hier_message_ports_in = pmt::list_add(hier_message_ports_in, port_id); } void message_port_register_hier_out(pmt::pmt_t port_id){ - if(pmt::pmt_list_has(hier_message_ports_out, port_id)) + if(pmt::list_has(hier_message_ports_out, port_id)) throw std::invalid_argument("hier msg out port by this name already registered"); - if(pmt::pmt_dict_has_key(message_subscribers, port_id)) + if(pmt::dict_has_key(message_subscribers, port_id)) throw std::invalid_argument("block already has a primitive output port by this name"); - hier_message_ports_out = pmt::pmt_list_add(hier_message_ports_out, port_id); + hier_message_ports_out = pmt::list_add(hier_message_ports_out, port_id); } }; diff --git a/gnuradio-core/src/lib/runtime/gr_hier_block2_detail.cc b/gnuradio-core/src/lib/runtime/gr_hier_block2_detail.cc index add6da0248..44475d2ae0 100644 --- a/gnuradio-core/src/lib/runtime/gr_hier_block2_detail.cc +++ b/gnuradio-core/src/lib/runtime/gr_hier_block2_detail.cc @@ -154,7 +154,7 @@ gr_hier_block2_detail::msg_connect(gr_basic_block_sptr src, pmt::pmt_t srcport, // register the subscription // this is done later... -// src->message_port_sub(srcport, pmt::pmt_cons(dst->alias_pmt(), dstport)); +// src->message_port_sub(srcport, pmt::cons(dst->alias_pmt(), dstport)); // add block uniquely to list to internal blocks if (std::find(d_blocks.begin(), d_blocks.end(), dst) == d_blocks.end()){ @@ -196,7 +196,7 @@ gr_hier_block2_detail::msg_disconnect(gr_basic_block_sptr src, pmt::pmt_t srcpor std::cout << "disconnecting message port..." << std::endl; // unregister the subscription - if already subscribed - src->message_port_unsub(srcport, pmt::pmt_cons(dst->alias_pmt(), dstport)); + src->message_port_unsub(srcport, pmt::cons(dst->alias_pmt(), dstport)); // remove edge for this message connection bool hier_out = (d_owner == src.get()) && src->message_port_is_hier_out(srcport);; diff --git a/gnuradio-core/src/lib/runtime/pycallback_object.h b/gnuradio-core/src/lib/runtime/pycallback_object.h index c27bf00508..389a975bd4 100644 --- a/gnuradio-core/src/lib/runtime/pycallback_object.h +++ b/gnuradio-core/src/lib/runtime/pycallback_object.h @@ -60,13 +60,13 @@ public: template<> pmt::pmt_t pmt_assist<std::vector<float> >::make(std::vector<float> _val) { - return pmt::pmt_init_f32vector(_val.size(), &_val[0]); + return pmt::init_f32vector(_val.size(), &_val[0]); } template<> pmt::pmt_t pmt_assist<std::vector<gr_complex> >::make(std::vector<gr_complex> _val) { - return pmt::pmt_init_c32vector(_val.size(), &_val[0]); + return pmt::init_c32vector(_val.size(), &_val[0]); } template <class myType> class pycallback_object diff --git a/gnuradio-core/src/lib/runtime/qa_set_msg_handler.cc b/gnuradio-core/src/lib/runtime/qa_set_msg_handler.cc index c84a219bd1..ac06a3f8bc 100644 --- a/gnuradio-core/src/lib/runtime/qa_set_msg_handler.cc +++ b/gnuradio-core/src/lib/runtime/qa_set_msg_handler.cc @@ -37,8 +37,6 @@ #define VERBOSE 0 -using namespace pmt; - /* * The gr_nop block has been instrumented so that it counts * the number of messages sent to it. We use this feature @@ -65,9 +63,9 @@ void qa_set_msg_handler::t0() tb->start(); // Send them... - pmt_t port(pmt_intern("port")); + pmt::pmt_t port(pmt::intern("port")); for (int i = 0; i < NMSGS; i++){ - send(nop, port, mp(mp("example-msg"), mp(i))); + send(nop, port, pmt::mp(pmt::mp("example-msg"), pmt::mp(i))); } // Give the messages a chance to be processed diff --git a/gnuradio-core/src/lib/runtime/rpcpmtconverters_ice.cc b/gnuradio-core/src/lib/runtime/rpcpmtconverters_ice.cc index 31953fd09c..c5502c7362 100644 --- a/gnuradio-core/src/lib/runtime/rpcpmtconverters_ice.cc +++ b/gnuradio-core/src/lib/runtime/rpcpmtconverters_ice.cc @@ -27,11 +27,11 @@ GNURadio::KnobPtr rpcpmtconverter::from_pmt(const pmt::pmt_t& knob, const Ice::Current& c) { - if(pmt::pmt_is_real(knob)) { - return new GNURadio::KnobD(Ice::Double(pmt::pmt_to_double(knob))); + if(pmt::is_real(knob)) { + return new GNURadio::KnobD(Ice::Double(pmt::to_double(knob))); } - else if(pmt::pmt_is_symbol(knob)) { - std::string stuff = pmt::pmt_symbol_to_string(knob); + else if(pmt::is_symbol(knob)) { + std::string stuff = pmt::symbol_to_string(knob); if(stuff.length() != 1) { return new GNURadio::KnobS(stuff); } @@ -41,24 +41,24 @@ rpcpmtconverter::from_pmt(const pmt::pmt_t& knob, const Ice::Current& c) //TODO: FLOAT!!! } - else if(pmt::pmt_is_integer(knob)) { - return new GNURadio::KnobI(pmt::pmt_to_long(knob)); + else if(pmt::is_integer(knob)) { + return new GNURadio::KnobI(pmt::to_long(knob)); } - else if(pmt::pmt_is_bool(knob)) { - return new GNURadio::KnobB(pmt::pmt_to_bool(knob)); + else if(pmt::is_bool(knob)) { + return new GNURadio::KnobB(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::is_uint64(knob)) { + return new GNURadio::KnobL(pmt::to_uint64(knob)); + //const std::complex<float> *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::is_c32vector(knob)) { // c32 sent as interleaved floats + size_t size(pmt::length(knob)); + const float* start((const float*) pmt::c32vector_elements(knob,size)); return new GNURadio::KnobVecF(std::vector<float>(start,start+size*2)); } - 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)); + else if(pmt::is_f32vector(knob)) { + size_t size(pmt::length(knob)); + const float* start((const float*) pmt::f32vector_elements(knob,size)); return new GNURadio::KnobVecF(std::vector<float>(start,start+size)); } else { @@ -85,7 +85,7 @@ rpcpmtconverter::to_pmt(const GNURadio::KnobPtr& knob, const Ice::Current& c) } else if(id == "KnobS") { GNURadio::KnobSPtr k(GNURadio::KnobSPtr::dynamicCast(knob)); - return pmt::pmt_string_to_symbol(k->value); + return pmt::string_to_symbol(k->value); } else if(id == "KnobB") { GNURadio::KnobBPtr k(GNURadio::KnobBPtr::dynamicCast(knob)); diff --git a/gnuradio-core/src/lib/runtime/rpcregisterhelpers.h b/gnuradio-core/src/lib/runtime/rpcregisterhelpers.h index bbe4f6c7d3..6d5f878d3b 100644 --- a/gnuradio-core/src/lib/runtime/rpcregisterhelpers.h +++ b/gnuradio-core/src/lib/runtime/rpcregisterhelpers.h @@ -104,7 +104,7 @@ public: void post(pmt::pmt_t which_port, pmt::pmt_t msg) { (rpcextractor_base<T,double>::_source->*rpcextractor_base<T,double>::_func) - (pmt::pmt_to_double(msg)); + (pmt::to_double(msg)); } }; @@ -119,7 +119,7 @@ public: void post(pmt::pmt_t which_port, pmt::pmt_t msg) { (rpcextractor_base<T,float>::_source->*rpcextractor_base<T,float>::_func) - (pmt::pmt_to_double(msg)); + (pmt::to_double(msg)); } }; @@ -134,7 +134,7 @@ public: void post(pmt::pmt_t which_port, pmt::pmt_t msg) { (rpcextractor_base<T,long>::_source->*rpcextractor_base<T,long>::_func) - (pmt::pmt_to_long(msg)); + (pmt::to_long(msg)); } }; @@ -149,7 +149,7 @@ public: void post(pmt::pmt_t which_port, pmt::pmt_t msg) { (rpcextractor_base<T,int>::_source->*rpcextractor_base<T,int>::_func) - (pmt::pmt_to_long(msg)); + (pmt::to_long(msg)); } }; @@ -164,7 +164,7 @@ public: void post(pmt::pmt_t which_port, pmt::pmt_t msg) { (rpcextractor_base<T,bool>::_source->*rpcextractor_base<T,bool>::_func) - (pmt::pmt_to_bool(msg)); + (pmt::to_bool(msg)); } }; @@ -180,7 +180,7 @@ public: void post(pmt::pmt_t which_port, pmt::pmt_t msg) { (rpcextractor_base<T,std::complex<double> >:: - _source->*rpcextractor_base<T,std::complex<double> >::_func)(pmt::pmt_to_complex(msg)); + _source->*rpcextractor_base<T,std::complex<double> >::_func)(pmt::to_complex(msg)); } }; @@ -196,7 +196,7 @@ public: void post(pmt::pmt_t which_port, pmt::pmt_t msg) { (rpcextractor_base<T,std::string>:: - _source->*rpcextractor_base<T,std::string>::_func)(pmt::pmt_symbol_to_string(msg)); + _source->*rpcextractor_base<T,std::string>::_func)(pmt::symbol_to_string(msg)); } }; @@ -214,8 +214,8 @@ public: pmt::pmt_t retrieve() { - return pmt::pmt_from_uint64((rpcinserter_base<T,uint64_t>:: - _source->*rpcinserter_base<T,uint64_t>::_func)()); + return pmt::from_uint64((rpcinserter_base<T,uint64_t>:: + _source->*rpcinserter_base<T,uint64_t>::_func)()); } }; @@ -237,7 +237,7 @@ public: std::vector< std::complex<float> > vec((rpcinserter_base<T,std::vector<std::complex<float> > >:: _source->*rpcinserter_base<T,std::vector< std::complex<float> > >::_func)()); - return pmt::pmt_init_c32vector(vec.size(), &vec[0]); + return pmt::init_c32vector(vec.size(), &vec[0]); } }; @@ -258,7 +258,7 @@ public: { std::vector< float > vec((rpcinserter_base<T,std::vector<float> >:: _source->*rpcinserter_base<T,std::vector< float> >::_func)()); - return pmt::pmt_init_f32vector(vec.size(), &vec[0]); + return pmt::init_f32vector(vec.size(), &vec[0]); } }; diff --git a/gr-blocks/lib/file_meta_sink_impl.cc b/gr-blocks/lib/file_meta_sink_impl.cc index ad16e9fcac..4b82ac2b84 100644 --- a/gr-blocks/lib/file_meta_sink_impl.cc +++ b/gr-blocks/lib/file_meta_sink_impl.cc @@ -97,34 +97,34 @@ namespace gr { if(!open(filename)) throw std::runtime_error("file_meta_sink: can't open file\n"); - pmt_t timestamp = pmt_make_tuple(pmt_from_uint64(0), - pmt_from_double(0)); + pmt::pmt_t timestamp = pmt::make_tuple(pmt::from_uint64(0), + pmt::from_double(0)); // handle extra dictionary - d_extra = pmt_make_dict(); + d_extra = pmt::make_dict(); if(extra_dict.size() > 0) { - 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); + pmt::pmt_t extras = pmt::deserialize_str(extra_dict); + pmt::pmt_t keys = pmt::dict_keys(extras); + pmt::pmt_t vals = pmt::dict_values(extras); + size_t nitems = pmt::length(keys); for(size_t i = 0; i < nitems; i++) { - d_extra = pmt_dict_add(d_extra, - pmt_nth(i, keys), - pmt_nth(i, vals)); + 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_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)); + d_header = pmt::make_dict(); + d_header = pmt::dict_add(d_header, pmt::mp("version"), pmt::mp(METADATA_VERSION)); + d_header = pmt::dict_add(d_header, pmt::mp("rx_rate"), pmt::mp(samp_rate)); + d_header = pmt::dict_add(d_header, pmt::mp("rx_time"), timestamp); + d_header = pmt::dict_add(d_header, pmt::mp("size"), pmt::from_long(d_itemsize)); + d_header = pmt::dict_add(d_header, pmt::mp("type"), pmt::from_long(type)); + d_header = pmt::dict_add(d_header, pmt::mp("cplx"), complex ? pmt::PMT_T : pmt::PMT_F); + d_header = pmt::dict_add(d_header, pmt::mp("strt"), pmt::from_uint64(METADATA_HEADER_SIZE+d_extra_size)); + d_header = pmt::dict_add(d_header, mp("bytes"), pmt::from_uint64(0)); do_update(); @@ -237,10 +237,10 @@ namespace gr { } void - file_meta_sink_impl::write_header(FILE *fp, pmt_t header, pmt_t extra) + file_meta_sink_impl::write_header(FILE *fp, pmt::pmt_t header, pmt::pmt_t extra) { - std::string header_str = pmt_serialize_str(header); - std::string extra_str = pmt_serialize_str(extra); + std::string header_str = pmt::serialize_str(header); + std::string extra_str = pmt::serialize_str(extra); if((header_str.size() != METADATA_HEADER_SIZE) && (extra_str.size() != d_extra_size)) throw std::runtime_error("file_meta_sink: header or extras is wrong size.\n"); @@ -271,24 +271,24 @@ namespace gr { } void - file_meta_sink_impl::update_header(pmt_t key, pmt_t value) + file_meta_sink_impl::update_header(pmt::pmt_t key, pmt::pmt_t value) { // Special handling caveat to transform rate from radio source into // the rate at this sink. - 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::eq(key, mp("rx_rate"))) { + d_samp_rate = pmt::to_double(value); + value = pmt::from_double(d_samp_rate*d_relative_rate); } // If the tag is not part of the standard header, we put it into the // extra data, which either updates the current dictionary or adds a // new item. - if(pmt_dict_has_key(d_header, key)) { - d_header = pmt_dict_add(d_header, key, value); + if(pmt::dict_has_key(d_header, key)) { + d_header = pmt::dict_add(d_header, key, value); } else { - d_extra = pmt_dict_add(d_extra, key, value); - d_extra_size = pmt_serialize_str(d_extra).size(); + d_extra = pmt::dict_add(d_extra, key, value); + d_extra_size = pmt::serialize_str(d_extra).size(); } } @@ -307,11 +307,11 @@ namespace gr { // Update the last header info with the number of samples this // block represents. - size_t hdrlen = pmt_to_uint64(pmt_dict_ref(d_header, mp("strt"), PMT_NIL)); + size_t hdrlen = pmt::to_uint64(pmt::dict_ref(d_header, mp("strt"), pmt::PMT_NIL)); size_t seg_size = d_itemsize*d_total_seg_size; - pmt_t s = pmt_from_uint64(seg_size); + pmt::pmt_t s = pmt::from_uint64(seg_size); update_header(mp("bytes"), s); - update_header(mp("strt"), pmt_from_uint64(METADATA_HEADER_SIZE+d_extra_size)); + update_header(mp("strt"), pmt::from_uint64(METADATA_HEADER_SIZE+d_extra_size)); fseek(d_fp, -seg_size-hdrlen, SEEK_CUR); write_header(d_fp, d_header, d_extra); fseek(d_fp, seg_size, SEEK_CUR); @@ -322,11 +322,11 @@ namespace gr { { // Update the last header info with the number of samples this // block represents. - size_t hdrlen = pmt_to_uint64(pmt_dict_ref(d_header, mp("strt"), PMT_NIL)); + size_t hdrlen = pmt::to_uint64(pmt::dict_ref(d_header, mp("strt"), pmt::PMT_NIL)); size_t seg_size = d_itemsize*d_total_seg_size; - pmt_t s = pmt_from_uint64(seg_size); + pmt::pmt_t s = pmt::from_uint64(seg_size); update_header(mp("bytes"), s); - update_header(mp("strt"), pmt_from_uint64(METADATA_HEADER_SIZE+d_extra_size)); + update_header(mp("strt"), pmt::from_uint64(METADATA_HEADER_SIZE+d_extra_size)); fseek(d_hdr_fp, -hdrlen, SEEK_CUR); write_header(d_hdr_fp, d_header, d_extra); } @@ -337,13 +337,13 @@ namespace gr { // New header, so set current size of chunk to 0 and start of chunk // based on current index + header size. //uint64_t loc = get_last_header_loc(); - pmt_t s = pmt_from_uint64(0); + pmt::pmt_t s = pmt::from_uint64(0); update_header(mp("bytes"), s); // If we have multiple tags on the same offset, this makes // sure we just overwrite the same header each time instead // of creating a new header per tag. - s = pmt_from_uint64(METADATA_HEADER_SIZE + d_extra_size); + s = pmt::from_uint64(METADATA_HEADER_SIZE + d_extra_size); update_header(mp("strt"), s); if(d_state == STATE_DETACHED) @@ -355,10 +355,10 @@ namespace gr { void file_meta_sink_impl::update_rx_time() { - 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)); + pmt::pmt_t rx_time = pmt::string_to_symbol("rx_time"); + pmt::pmt_t r = pmt::dict_ref(d_header, rx_time, pmt::PMT_NIL); + uint64_t secs = pmt::to_uint64(pmt::tuple_ref(r, 0)); + double fracs = pmt::to_double(pmt::tuple_ref(r, 1)); double diff = d_total_seg_size / (d_samp_rate*d_relative_rate); //std::cerr << "old secs: " << secs << std::endl; @@ -374,8 +374,8 @@ namespace gr { //std::cerr << "new secs: " << secs << std::endl; //std::cerr << "new fracs: " << fracs << std::endl << std::endl; - r = pmt_make_tuple(pmt_from_uint64(secs), pmt_from_double(fracs)); - d_header = pmt_dict_add(d_header, rx_time, r); + r = pmt::make_tuple(pmt::from_uint64(secs), pmt::from_double(fracs)); + d_header = pmt::dict_add(d_header, rx_time, r); } int diff --git a/gr-blocks/lib/file_meta_source_impl.cc b/gr-blocks/lib/file_meta_source_impl.cc index fb39b205b4..5c22251d2a 100644 --- a/gr-blocks/lib/file_meta_source_impl.cc +++ b/gr-blocks/lib/file_meta_source_impl.cc @@ -92,7 +92,7 @@ namespace gr { do_update(); - pmt_t hdr = PMT_NIL, extras = PMT_NIL; + pmt::pmt_t hdr = pmt::PMT_NIL, extras = pmt::PMT_NIL; if(read_header(hdr, extras)) { parse_header(hdr, 0, d_tags); parse_extras(extras, 0, d_tags); @@ -122,7 +122,7 @@ namespace gr { } bool - file_meta_source_impl::read_header(pmt_t &hdr, pmt_t &extras) + file_meta_source_impl::read_header(pmt::pmt_t &hdr, pmt::pmt_t &extras) { // Select which file handle to read from. FILE *fp; @@ -153,14 +153,14 @@ namespace gr { // Convert to string or the char array gets confused by the \0 str.insert(0, hdr_buffer, METADATA_HEADER_SIZE); - hdr = pmt_deserialize_str(str); + hdr = pmt::deserialize_str(str); delete [] hdr_buffer; uint64_t seg_start, extra_len; - 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); + pmt::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); extra_len = seg_start - METADATA_HEADER_SIZE; } @@ -185,7 +185,7 @@ namespace gr { str.clear(); str.insert(0, hdr_buffer, extra_len); - extras = pmt_deserialize_str(str); + extras = pmt::deserialize_str(str); delete [] hdr_buffer; } @@ -193,16 +193,16 @@ namespace gr { } void - file_meta_source_impl::parse_header(pmt_t hdr, uint64_t offset, + file_meta_source_impl::parse_header(pmt::pmt_t hdr, uint64_t offset, std::vector<gr_tag_t> &tags) { - pmt_t r, key; + pmt::pmt_t r, key; // GET SAMPLE RATE - 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_rate"); + if(pmt::dict_has_key(hdr, key)) { + r = pmt::dict_ref(hdr, key, pmt::PMT_NIL); + d_samp_rate = pmt::to_double(r); gr_tag_t t; t.offset = offset; @@ -216,9 +216,9 @@ namespace gr { } // GET TIME STAMP - key = pmt_string_to_symbol("rx_time"); - if(pmt_dict_has_key(hdr, key)) { - d_time_stamp = pmt_dict_ref(hdr, key, PMT_NIL); + key = pmt::string_to_symbol("rx_time"); + if(pmt::dict_has_key(hdr, key)) { + d_time_stamp = pmt::dict_ref(hdr, key, pmt::PMT_NIL); gr_tag_t t; t.offset = offset; @@ -232,16 +232,16 @@ namespace gr { } // GET ITEM SIZE OF DATA - 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("size"))) { + d_itemsize = pmt::to_long(pmt::dict_ref(hdr, pmt::string_to_symbol("size"), pmt::PMT_NIL)); } else { throw std::runtime_error("file_meta_source: Could not extract item size.\n"); } // GET SEGMENT SIZE - 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)); + 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::PMT_NIL)); // Convert from bytes to items d_seg_size /= d_itemsize; @@ -252,16 +252,16 @@ namespace gr { } void - file_meta_source_impl::parse_extras(pmt_t extras, uint64_t offset, + file_meta_source_impl::parse_extras(pmt::pmt_t extras, uint64_t offset, std::vector<gr_tag_t> &tags) { - pmt_t item, key, val; + pmt::pmt_t item, key, val; - size_t nitems = pmt_length(extras); + size_t nitems = pmt::length(extras); for(size_t i = 0; i < nitems; i++) { - item = pmt_nth(i, extras); - key = pmt_car(item); - val = pmt_cdr(item); + item = pmt::nth(i, extras); + key = pmt::car(item); + val = pmt::cdr(item); gr_tag_t t; t.offset = offset; @@ -367,7 +367,7 @@ namespace gr { // We've reached the end of a segment; parse the next header and get // the new tags to send and set the next segment size. if(d_seg_size == 0) { - pmt_t hdr=PMT_NIL, extras=PMT_NIL; + pmt::pmt_t hdr=pmt::PMT_NIL, extras=pmt::PMT_NIL; if(read_header(hdr, extras)) { parse_header(hdr, nitems_written(0), d_tags); parse_extras(extras, nitems_written(0), d_tags); diff --git a/gr-channels/lib/channel_model_impl.cc b/gr-channels/lib/channel_model_impl.cc index 7ff157a739..9447a17784 100644 --- a/gr-channels/lib/channel_model_impl.cc +++ b/gr-channels/lib/channel_model_impl.cc @@ -167,9 +167,9 @@ namespace gr { rpcbasic_sptr(new rpcbasic_register_get<channel_model_impl, std::vector<gr_complex> >( d_name, "taps", this, unique_id(), &channel_model_impl::taps, - pmt::pmt_make_c32vector(0,-10), - pmt::pmt_make_c32vector(0,10), - pmt::pmt_make_c32vector(0,0), + pmt::make_c32vector(0,-10), + pmt::make_c32vector(0,10), + pmt::make_c32vector(0,0), "", "Multipath taps", RPC_PRIVLVL_MIN, DISPTIMESERIESC))); diff --git a/gr-digital/lib/correlate_access_code_tag_bb_impl.cc b/gr-digital/lib/correlate_access_code_tag_bb_impl.cc index d375daf95c..1ff27f02a5 100644 --- a/gr-digital/lib/correlate_access_code_tag_bb_impl.cc +++ b/gr-digital/lib/correlate_access_code_tag_bb_impl.cc @@ -61,8 +61,8 @@ namespace gr { std::stringstream str; str << name() << unique_id(); - d_me = pmt::pmt_string_to_symbol(str.str()); - d_key = pmt::pmt_string_to_symbol(tag_name); + d_me = pmt::string_to_symbol(str.str()); + d_key = pmt::string_to_symbol(tag_name); } correlate_access_code_tag_bb_impl::~correlate_access_code_tag_bb_impl() diff --git a/gr-digital/lib/mpsk_snr_est_cc_impl.cc b/gr-digital/lib/mpsk_snr_est_cc_impl.cc index efd18ea4f4..621c41b9f0 100644 --- a/gr-digital/lib/mpsk_snr_est_cc_impl.cc +++ b/gr-digital/lib/mpsk_snr_est_cc_impl.cc @@ -61,8 +61,8 @@ namespace gr { std::stringstream str; str << name() << unique_id(); - d_me = pmt::pmt_string_to_symbol(str.str()); - d_key = pmt::pmt_string_to_symbol("snr"); + d_me = pmt::string_to_symbol(str.str()); + d_key = pmt::string_to_symbol("snr"); } mpsk_snr_est_cc_impl::~mpsk_snr_est_cc_impl() @@ -93,7 +93,7 @@ namespace gr { d_snr_est->update(x, &in[index]); // Issue a tag with the SNR data - pmt::pmt_t pmt_snr = pmt::pmt_from_double(d_snr_est->snr()); + pmt::pmt_t pmt_snr = pmt::from_double(d_snr_est->snr()); add_item_tag(0, // stream ID nwritten, // tag's sample number d_key, // snr key diff --git a/gr-digital/lib/probe_mpsk_snr_est_c_impl.cc b/gr-digital/lib/probe_mpsk_snr_est_c_impl.cc index 31de586e05..fb71bdc110 100644 --- a/gr-digital/lib/probe_mpsk_snr_est_c_impl.cc +++ b/gr-digital/lib/probe_mpsk_snr_est_c_impl.cc @@ -59,7 +59,7 @@ namespace gr { // at least 1 estimator has to look back set_history(2); - d_key = pmt::pmt_string_to_symbol("snr"); + d_key = pmt::string_to_symbol("snr"); } probe_mpsk_snr_est_c_impl::~probe_mpsk_snr_est_c_impl() diff --git a/gr-uhd/examples/c++/tag_sink_demo.h b/gr-uhd/examples/c++/tag_sink_demo.h index 5417bd3242..676005e06c 100644 --- a/gr-uhd/examples/c++/tag_sink_demo.h +++ b/gr-uhd/examples/c++/tag_sink_demo.h @@ -47,7 +47,7 @@ public: //grab all "rx time" tags in this work call const uint64_t samp0_count = this->nitems_read(0); std::vector<gr_tag_t> rx_time_tags; - get_tags_in_range(rx_time_tags, 0, samp0_count, samp0_count + ninput_items, pmt::pmt_string_to_symbol("rx_time")); + get_tags_in_range(rx_time_tags, 0, samp0_count, samp0_count + ninput_items, pmt::string_to_symbol("rx_time")); //print all tags BOOST_FOREACH(const gr_tag_t &rx_time_tag, rx_time_tags){ @@ -55,8 +55,8 @@ public: const pmt::pmt_t &value = rx_time_tag.value; std::cout << boost::format("Full seconds %u, Frac seconds %f, abs sample offset %u") - % pmt::pmt_to_uint64(pmt::pmt_tuple_ref(value, 0)) - % pmt::pmt_to_double(pmt::pmt_tuple_ref(value, 1)) + % pmt::to_uint64(pmt::tuple_ref(value, 0)) + % pmt::to_double(pmt::tuple_ref(value, 1)) % offset << std::endl; } diff --git a/gr-uhd/examples/c++/tag_source_demo.h b/gr-uhd/examples/c++/tag_source_demo.h index 7d48502b24..6efe4667e5 100644 --- a/gr-uhd/examples/c++/tag_source_demo.h +++ b/gr-uhd/examples/c++/tag_source_demo.h @@ -53,26 +53,26 @@ public: } void make_time_tag(const uint64_t tag_count){; - 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 key = pmt::string_to_symbol("tx_time"); + const pmt::pmt_t value = pmt::make_tuple( + pmt::from_uint64(_time_secs), + pmt::from_double(_time_fracs) ); - const pmt::pmt_t srcid = pmt::pmt_string_to_symbol(this->name()); + const pmt::pmt_t srcid = pmt::string_to_symbol(this->name()); this->add_item_tag(0/*chan0*/, tag_count, key, value, srcid); } void make_sob_tag(const uint64_t tag_count){ - const pmt::pmt_t key = pmt::pmt_string_to_symbol("tx_sob"); + const pmt::pmt_t key = pmt::string_to_symbol("tx_sob"); const pmt::pmt_t value = pmt::PMT_T; - const pmt::pmt_t srcid = pmt::pmt_string_to_symbol(this->name()); + const pmt::pmt_t srcid = pmt::string_to_symbol(this->name()); this->add_item_tag(0/*chan0*/, tag_count, key, value, srcid); } void make_eob_tag(const uint64_t tag_count){; - const pmt::pmt_t key = pmt::pmt_string_to_symbol("tx_eob"); + const pmt::pmt_t key = pmt::string_to_symbol("tx_eob"); const pmt::pmt_t value = pmt::PMT_T; - const pmt::pmt_t srcid = pmt::pmt_string_to_symbol(this->name()); + const pmt::pmt_t srcid = pmt::string_to_symbol(this->name()); this->add_item_tag(0/*chan0*/, tag_count, key, value, srcid); } diff --git a/gr-uhd/lib/gr_uhd_usrp_sink.cc b/gr-uhd/lib/gr_uhd_usrp_sink.cc index 6216c94a83..3b8fcea405 100644 --- a/gr-uhd/lib/gr_uhd_usrp_sink.cc +++ b/gr-uhd/lib/gr_uhd_usrp_sink.cc @@ -25,9 +25,9 @@ #include <boost/make_shared.hpp> #include "gr_uhd_common.h" -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"); +static const pmt::pmt_t SOB_KEY = pmt::string_to_symbol("tx_sob"); +static const pmt::pmt_t EOB_KEY = pmt::string_to_symbol("tx_eob"); +static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("tx_time"); #include <uhd/convert.hpp> inline gr_io_signature_sptr args_to_io_sig(const uhd::stream_args_t &args){ @@ -374,23 +374,23 @@ public: } //handle end of burst with a mini end of burst packet - else if (pmt::pmt_equal(key, EOB_KEY)){ - _metadata.end_of_burst = pmt::pmt_to_bool(value); + else if (pmt::equal(key, EOB_KEY)){ + _metadata.end_of_burst = pmt::to_bool(value); ninput_items = 1; return; } //set the start of burst flag in the metadata - else if (pmt::pmt_equal(key, SOB_KEY)){ - _metadata.start_of_burst = pmt::pmt_to_bool(value); + else if (pmt::equal(key, SOB_KEY)){ + _metadata.start_of_burst = pmt::to_bool(value); } //set the time specification in the metadata - else if (pmt::pmt_equal(key, TIME_KEY)){ + else if (pmt::equal(key, TIME_KEY)){ _metadata.has_time_spec = true; _metadata.time_spec = uhd::time_spec_t( - pmt::pmt_to_uint64(pmt::pmt_tuple_ref(value, 0)), - pmt::pmt_to_double(pmt::pmt_tuple_ref(value, 1)) + pmt::to_uint64(pmt::tuple_ref(value, 0)), + pmt::to_double(pmt::tuple_ref(value, 1)) ); } } diff --git a/gr-uhd/lib/gr_uhd_usrp_source.cc b/gr-uhd/lib/gr_uhd_usrp_source.cc index 3813673b4b..6403d3d913 100644 --- a/gr-uhd/lib/gr_uhd_usrp_source.cc +++ b/gr-uhd/lib/gr_uhd_usrp_source.cc @@ -28,9 +28,9 @@ #include <boost/make_shared.hpp> #include "gr_uhd_common.h" -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"); +static const pmt::pmt_t TIME_KEY = pmt::string_to_symbol("rx_time"); +static const pmt::pmt_t RATE_KEY = pmt::string_to_symbol("rx_rate"); +static const pmt::pmt_t FREQ_KEY = pmt::string_to_symbol("rx_freq"); #include <uhd/convert.hpp> inline gr_io_signature_sptr args_to_io_sig(const uhd::stream_args_t &args){ @@ -69,7 +69,7 @@ public: if (stream_args.cpu_format == "sc16") _type = boost::make_shared<uhd::io_type_t>(uhd::io_type_t::COMPLEX_INT16); std::stringstream str; str << name() << unique_id(); - _id = pmt::pmt_string_to_symbol(str.str()); + _id = pmt::string_to_symbol(str.str()); _dev = uhd::usrp::multi_usrp::make(device_addr); } @@ -363,15 +363,15 @@ public: if (_tag_now){ _tag_now = false; //create a timestamp pmt for the first sample - 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()) + const pmt::pmt_t val = pmt::make_tuple( + pmt::from_uint64(_metadata.time_spec.get_full_secs()), + pmt::from_double(_metadata.time_spec.get_frac_secs()) ); //create a tag set for each channel for (size_t i = 0; i < _nchan; i++){ this->add_item_tag(i, nitems_written(0), TIME_KEY, val, _id); - 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); + this->add_item_tag(i, nitems_written(0), RATE_KEY, pmt::from_double(_samp_rate), _id); + this->add_item_tag(i, nitems_written(0), FREQ_KEY, pmt::from_double(_center_freq), _id); } } break; |