From: jcorgan Date: Sun, 26 Jul 2009 20:01:02 +0000 (+0000) Subject: Merged r11491:11494 from jcorgan/pmt into trunk. X-Git-Url: https://git.gag.com/?a=commitdiff_plain;h=2bf2a8f2d2a4477818bfa91cae64fb663fdf88c3;p=debian%2Fgnuradio Merged r11491:11494 from jcorgan/pmt into trunk. Moves pmt types functions into pmt:: from gruel:: Trunk passes distcheck. git-svn-id: http://gnuradio.org/svn/gnuradio/trunk@11495 221aa14e-8319-0410-a670-987f0aec2ac5 --- diff --git a/config/grc_gruel.m4 b/config/grc_gruel.m4 index 01d44fea..ae8fe81a 100644 --- a/config/grc_gruel.m4 +++ b/config/grc_gruel.m4 @@ -42,6 +42,7 @@ AC_DEFUN([GRC_GRUEL],[ gruel/src/include/gruel/Makefile \ gruel/src/include/gruel/inet.h \ gruel/src/lib/Makefile \ + gruel/src/lib/pmt/Makefile \ gruel/src/scheme/Makefile \ gruel/src/scheme/gnuradio/Makefile \ ]) diff --git a/gruel/src/include/gruel/pmt.h b/gruel/src/include/gruel/pmt.h index 6dc4508b..de0998b5 100644 --- a/gruel/src/include/gruel/pmt.h +++ b/gruel/src/include/gruel/pmt.h @@ -39,7 +39,7 @@ * exception that these objects are transparently reference counted. */ -namespace gruel { +namespace pmt { /*! * \brief base class of all pmt types @@ -677,6 +677,6 @@ pmt_t pmt_deserialize(std::streambuf &source); void pmt_dump_sizeof(); // debugging -} /* namespace gruel */ +} /* namespace pmt */ #endif /* INCLUDED_PMT_H */ diff --git a/gruel/src/include/gruel/pmt_pool.h b/gruel/src/include/gruel/pmt_pool.h index 18b498fa..b792523e 100644 --- a/gruel/src/include/gruel/pmt_pool.h +++ b/gruel/src/include/gruel/pmt_pool.h @@ -25,7 +25,7 @@ #include #include -namespace gruel { +namespace pmt { /*! * \brief very simple thread-safe fixed-size allocation pool @@ -67,6 +67,6 @@ public: void free(void *p); }; -} /* namespace gruel */ +} /* namespace pmt */ #endif /* INCLUDED_PMT_POOL_H */ diff --git a/gruel/src/lib/Makefile.am b/gruel/src/lib/Makefile.am index 2a968d25..bf1ae731 100644 --- a/gruel/src/lib/Makefile.am +++ b/gruel/src/lib/Makefile.am @@ -21,9 +21,9 @@ include $(top_srcdir)/Makefile.common -AM_CPPFLAGS = $(DEFINES) $(BOOST_CPPFLAGS) $(CPPUNIT_INCLUDES) $(GRUEL_INCLUDES) $(WITH_INCLUDES) +SUBDIRS = pmt -TESTS = test_pmt +AM_CPPFLAGS = $(DEFINES) $(BOOST_CPPFLAGS) $(CPPUNIT_INCLUDES) $(GRUEL_INCLUDES) $(WITH_INCLUDES) lib_LTLIBRARIES = libgruel.la @@ -31,38 +31,11 @@ lib_LTLIBRARIES = libgruel.la libgruel_la_LDFLAGS = $(NO_UNDEFINED) $(BOOST_LDFLAGS) -version-info 0:0:0 # ---------------------------------------------------------------- -# these scripts generate code - -code_generator = \ - generate_unv.py \ - unv_template.h.t \ - unv_template.cc.t \ - unv_qa_template.cc.t - -GENERATED_H = \ - pmt_unv_int.h \ - qa_pmt_unv.h - -GENERATED_CC = \ - pmt_unv.cc \ - qa_pmt_unv.cc - -python_built_sources = $(GENERATED_H) $(GENERATED_CC) -PMT_SERIAL_TAGS_H = $(abs_top_builddir)/gruel/src/include/gruel/pmt_serial_tags.h -BUILT_SOURCES = $(python_built_sources) $(PMT_SERIAL_TAGS_H) - -EXTRA_DIST = $(code_generator) - -# ---------------------------------------------------------------- +PMT_LIB = pmt/libpmt.la # These are the source files that go into the gruel shared library libgruel_la_SOURCES = \ - pmt.cc \ - pmt_io.cc \ - pmt_pool.cc \ - pmt_serialize.cc \ - pmt_unv.cc \ realtime.cc \ sys_pri.cc \ thread_body_wrapper.cc \ @@ -70,51 +43,7 @@ libgruel_la_SOURCES = \ libgruel_la_LIBADD = \ $(BOOST_THREAD_LIB) \ + $(PMT_LIB) \ -lstdc++ -noinst_HEADERS = \ - $(GENERATED_H) \ - pmt_int.h \ - qa_pmt.h \ - qa_pmt_prims.h - -# Build the qa code into its own library - -noinst_LTLIBRARIES = libpmt-qa.la - -libpmt_qa_la_SOURCES = \ - qa_pmt.cc \ - qa_pmt_prims.cc \ - qa_pmt_unv.cc - -# magic flags -libpmt_qa_la_LDFLAGS = $(NO_UNDEFINED) -avoid version - -libpmt_qa_la_LIBADD = \ - libgruel.la \ - $(CPPUNIT_LIBS) \ - -lstdc++ - -noinst_PROGRAMS = \ - test_pmt - - -LIBGRUEL = libgruel.la -LIBPMTQA = libpmt-qa.la $(LIBGRUEL) - -test_pmt_SOURCES = test_pmt.cc -test_pmt_LDADD = $(LIBPMTQA) - -# Do creation and inclusion of other Makefiles last - -# common way for generating sources from templates when using -# BUILT_SOURCES, using parallel build protection. -gen_sources = $(python_built_sources) -gen_sources_deps = $(core_generator) -par_gen_command = PYTHONPATH=$(top_srcdir)/gruel/src/lib srcdir=$(srcdir) $(PYTHON) $(srcdir)/generate_unv.py -include $(top_srcdir)/Makefile.par.gen -# Rule to create the build header file using GUILE -# Doesn't need parallel protections because there is a single target -$(PMT_SERIAL_TAGS_H): $(srcdir)/../scheme/gnuradio/gen-serial-tags.scm $(srcdir)/../scheme/gnuradio/pmt-serial-tags.scm - $(RUN_GUILE) $(srcdir)/../scheme/gnuradio/gen-serial-tags.scm $(srcdir)/../scheme/gnuradio/pmt-serial-tags.scm $(PMT_SERIAL_TAGS_H) diff --git a/gruel/src/lib/generate_unv.py b/gruel/src/lib/generate_unv.py deleted file mode 100755 index 3a7305b4..00000000 --- a/gruel/src/lib/generate_unv.py +++ /dev/null @@ -1,190 +0,0 @@ -#!/usr/bin/env python -# -# Copyright 2006 Free Software Foundation, Inc. -# -# This file is part of GNU Radio -# -# GNU Radio is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 3, or (at your option) -# any later version. -# -# GNU Radio is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with GNU Radio; see the file COPYING. If not, write to -# the Free Software Foundation, Inc., 51 Franklin Street, -# Boston, MA 02110-1301, USA. -# - -""" -Generate code for uniform numeric vectors -""" - -import re, os, os.path - - -unv_types = ( - ('u8', 'uint8_t'), - ('s8', 'int8_t'), - ('u16', 'uint16_t'), - ('s16', 'int16_t'), - ('u32', 'uint32_t'), - ('s32', 'int32_t'), - ('u64', 'uint64_t'), - ('s64', 'int64_t'), - ('f32', 'float'), - ('f64', 'double'), - ('c32', 'std::complex'), - ('c64', 'std::complex') - ) - -header = """\ -/* -*- c++ -*- */ -/* - * Copyright 2006,2009 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with GNU Radio; see the file COPYING. If not, write to - * the Free Software Foundation, Inc., 51 Franklin Street, - * Boston, MA 02110-1301, USA. - */ -""" - -guard_tail = """ -#endif -""" - -includes = """ -#ifdef HAVE_CONFIG_H -#include -#endif -#include -#include -#include "pmt_int.h" -""" - -qa_includes = """ -#include -#include -#include -#include - -using namespace gruel; -""" - - -# set srcdir to the directory that contains Makefile.am -try: - srcdir = os.environ['srcdir'] -except KeyError, e: - srcdir = "." -srcdir = srcdir + '/' - - -def open_src (name, mode): - global srcdir - return open(os.path.join (srcdir, name), mode) - - -def guard_name(filename): - return 'INCLUDED_' + re.sub('\.', '_', filename.upper()) - -def guard_head(filename): - guard = guard_name(filename) - return """ -#ifndef %s -#define %s -""" % (guard, guard) - - -def do_substitution (d, input, out_file): - def repl (match_obj): - key = match_obj.group (1) - # print key - return d[key] - - out = re.sub (r"@([a-zA-Z0-9_]+)@", repl, input) - out_file.write (out) - - -def generate_h(): - template = open_src('unv_template.h.t', 'r').read() - output_filename = 'pmt_unv_int.h' - output = open(output_filename, 'w') - output.write(header) - output.write(guard_head(output_filename)) - for tag, typ in unv_types: - d = { 'TAG' : tag, 'TYPE' : typ } - do_substitution(d, template, output) - output.write(guard_tail) - -def generate_cc(): - template = open_src('unv_template.cc.t', 'r').read() - output = open('pmt_unv.cc', 'w') - output.write(header) - output.write(includes) - for tag, typ in unv_types: - d = { 'TAG' : tag, 'TYPE' : typ } - do_substitution(d, template, output) - - -def generate_qa_h(): - output_filename = 'qa_pmt_unv.h' - output = open(output_filename, 'w') - output.write(header) - output.write(guard_head(output_filename)) - - output.write(''' -#include -#include - -class qa_pmt_unv : public CppUnit::TestCase { - - CPPUNIT_TEST_SUITE(qa_pmt_unv); -''') - for tag, typ in unv_types: - output.write(' CPPUNIT_TEST(test_%svector);\n' % (tag,)) - output.write('''\ - CPPUNIT_TEST_SUITE_END(); - - private: -''') - for tag, typ in unv_types: - output.write(' void test_%svector();\n' % (tag,)) - output.write('};\n') - output.write(guard_tail) - -def generate_qa_cc(): - template = open_src('unv_qa_template.cc.t', 'r').read() - output = open('qa_pmt_unv.cc', 'w') - output.write(header) - output.write(qa_includes) - for tag, typ in unv_types: - d = { 'TAG' : tag, 'TYPE' : typ } - do_substitution(d, template, output) - - -def main(): - generate_h() - generate_cc() - generate_qa_h() - generate_qa_cc() - -if __name__ == '__main__': - main() diff --git a/gruel/src/lib/pmt.cc b/gruel/src/lib/pmt.cc deleted file mode 100644 index 8e0c0162..00000000 --- a/gruel/src/lib/pmt.cc +++ /dev/null @@ -1,1041 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with GNU Radio; see the file COPYING. If not, write to - * the Free Software Foundation, Inc., 51 Franklin Street, - * Boston, MA 02110-1301, USA. - */ - -#ifdef HAVE_CONFIG_H -#include -#endif -#include -#include -#include "pmt_int.h" -#include -#include -#include - -namespace gruel { - -static const int CACHE_LINE_SIZE = 64; // good guess - -# if (PMT_LOCAL_ALLOCATOR) - -static pmt_pool global_pmt_pool(sizeof(pmt_pair), CACHE_LINE_SIZE); - -void * -pmt_base::operator new(size_t size) -{ - void *p = global_pmt_pool.malloc(); - - // fprintf(stderr, "pmt_base::new p = %p\n", p); - assert((reinterpret_cast(p) & (CACHE_LINE_SIZE - 1)) == 0); - return p; -} - -void -pmt_base::operator delete(void *p, size_t size) -{ - global_pmt_pool.free(p); -} - -#endif - - -pmt_base::~pmt_base() -{ - // nop -- out of line virtual destructor -} - -//////////////////////////////////////////////////////////////////////////// -// Exceptions -//////////////////////////////////////////////////////////////////////////// - -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) -{ -} - -//////////////////////////////////////////////////////////////////////////// -// Dynamic Casts -//////////////////////////////////////////////////////////////////////////// - -static pmt_symbol * -_symbol(pmt_t x) -{ - return dynamic_cast(x.get()); -} - -static pmt_integer * -_integer(pmt_t x) -{ - return dynamic_cast(x.get()); -} - -static pmt_real * -_real(pmt_t x) -{ - return dynamic_cast(x.get()); -} - -static pmt_complex * -_complex(pmt_t x) -{ - return dynamic_cast(x.get()); -} - -static pmt_pair * -_pair(pmt_t x) -{ - return dynamic_cast(x.get()); -} - -static pmt_vector * -_vector(pmt_t x) -{ - return dynamic_cast(x.get()); -} - -static pmt_uniform_vector * -_uniform_vector(pmt_t x) -{ - return dynamic_cast(x.get()); -} - -static pmt_dict * -_dict(pmt_t x) -{ - return dynamic_cast(x.get()); -} - -static pmt_any * -_any(pmt_t x) -{ - return dynamic_cast(x.get()); -} - -//////////////////////////////////////////////////////////////////////////// -// Globals -//////////////////////////////////////////////////////////////////////////// - -const pmt_t PMT_T = pmt_t(new pmt_bool()); // singleton -const pmt_t PMT_F = pmt_t(new pmt_bool()); // singleton -const pmt_t PMT_NIL = pmt_t(new pmt_null()); // singleton -const pmt_t PMT_EOF = pmt_cons(PMT_NIL, PMT_NIL); // singleton - -//////////////////////////////////////////////////////////////////////////// -// Booleans -//////////////////////////////////////////////////////////////////////////// - -pmt_bool::pmt_bool(){} - -bool -pmt_is_true(pmt_t obj) -{ - return obj != PMT_F; -} - -bool -pmt_is_false(pmt_t obj) -{ - return obj == PMT_F; -} - -bool -pmt_is_bool(pmt_t obj) -{ - return obj->is_bool(); -} - -pmt_t -pmt_from_bool(bool val) -{ - return val ? PMT_T : PMT_F; -} - -bool -pmt_to_bool(pmt_t val) -{ - if (val == PMT_T) - return true; - if (val == PMT_F) - return false; - throw pmt_wrong_type("pmt_to_bool", val); -} - -//////////////////////////////////////////////////////////////////////////// -// Symbols -//////////////////////////////////////////////////////////////////////////// - -static const unsigned int SYMBOL_HASH_TABLE_SIZE = 701; -static std::vector s_symbol_hash_table(SYMBOL_HASH_TABLE_SIZE); - -pmt_symbol::pmt_symbol(const std::string &name) : d_name(name){} - - -static unsigned int -hash_string(const std::string &s) -{ - unsigned int h = 0; - unsigned int g = 0; - - for (std::string::const_iterator p = s.begin(); p != s.end(); ++p){ - h = (h << 4) + (*p & 0xff); - g = h & 0xf0000000; - if (g){ - h = h ^ (g >> 24); - h = h ^ g; - } - } - return h; -} - -bool -pmt_is_symbol(const pmt_t& obj) -{ - return obj->is_symbol(); -} - -pmt_t -pmt_string_to_symbol(const std::string &name) -{ - unsigned hash = hash_string(name) % SYMBOL_HASH_TABLE_SIZE; - - // Does a symbol with this name already exist? - for (pmt_t sym = s_symbol_hash_table[hash]; sym; sym = _symbol(sym)->next()){ - if (name == _symbol(sym)->name()) - return sym; // Yes. Return it - } - - // Nope. Make a new one. - pmt_t sym = pmt_t(new pmt_symbol(name)); - _symbol(sym)->set_next(s_symbol_hash_table[hash]); - s_symbol_hash_table[hash] = sym; - return sym; -} - -// alias... -pmt_t -pmt_intern(const std::string &name) -{ - return pmt_string_to_symbol(name); -} - -const std::string -pmt_symbol_to_string(const pmt_t& sym) -{ - if (!sym->is_symbol()) - throw pmt_wrong_type("pmt_symbol_to_string", sym); - - return _symbol(sym)->name(); -} - - - -//////////////////////////////////////////////////////////////////////////// -// Number -//////////////////////////////////////////////////////////////////////////// - -bool -pmt_is_number(pmt_t x) -{ - return x->is_number(); -} - -//////////////////////////////////////////////////////////////////////////// -// Integer -//////////////////////////////////////////////////////////////////////////// - -pmt_integer::pmt_integer(long value) : d_value(value) {} - -bool -pmt_is_integer(pmt_t x) -{ - return x->is_integer(); -} - - -pmt_t -pmt_from_long(long x) -{ - return pmt_t(new pmt_integer(x)); -} - -long -pmt_to_long(pmt_t x) -{ - pmt_integer* i = dynamic_cast(x.get()); - if ( i ) - return i->value(); - - throw pmt_wrong_type("pmt_to_long", x); -} - -//////////////////////////////////////////////////////////////////////////// -// Real -//////////////////////////////////////////////////////////////////////////// - -pmt_real::pmt_real(double value) : d_value(value) {} - -bool -pmt_is_real(pmt_t x) -{ - return x->is_real(); -} - -pmt_t -pmt_from_double(double x) -{ - return pmt_t(new pmt_real(x)); -} - -double -pmt_to_double(pmt_t x) -{ - if (x->is_real()) - return _real(x)->value(); - if (x->is_integer()) - return _integer(x)->value(); - - throw pmt_wrong_type("pmt_to_double", x); -} - -//////////////////////////////////////////////////////////////////////////// -// Complex -//////////////////////////////////////////////////////////////////////////// - -pmt_complex::pmt_complex(std::complex value) : d_value(value) {} - -bool -pmt_is_complex(pmt_t x) -{ - return x->is_complex(); -} - -pmt_t -pmt_make_rectangular(double re, double im) -{ - return pmt_t(new pmt_complex(std::complex(re, im))); -} - -std::complex -pmt_to_complex(pmt_t x) -{ - if (x->is_complex()) - return _complex(x)->value(); - if (x->is_real()) - return _real(x)->value(); - if (x->is_integer()) - return _integer(x)->value(); - - throw pmt_wrong_type("pmt_to_complex", x); -} - -//////////////////////////////////////////////////////////////////////////// -// Pairs -//////////////////////////////////////////////////////////////////////////// - -pmt_null::pmt_null() {} -pmt_pair::pmt_pair(const pmt_t& car, const pmt_t& cdr) : d_car(car), d_cdr(cdr) {} - -bool -pmt_is_null(const pmt_t& x) -{ - return x == PMT_NIL; -} - -bool -pmt_is_pair(const pmt_t& obj) -{ - return obj->is_pair(); -} - -pmt_t -pmt_cons(const pmt_t& x, const pmt_t& y) -{ - return pmt_t(new pmt_pair(x, y)); -} - -pmt_t -pmt_car(const pmt_t& pair) -{ - pmt_pair* p = dynamic_cast(pair.get()); - if ( p ) - return p->car(); - - throw pmt_wrong_type("pmt_car", pair); -} - -pmt_t -pmt_cdr(const pmt_t& pair) -{ - pmt_pair* p = dynamic_cast(pair.get()); - if ( p ) - return p->cdr(); - - throw pmt_wrong_type("pmt_cdr", pair); -} - -void -pmt_set_car(pmt_t pair, pmt_t obj) -{ - if (pair->is_pair()) - _pair(pair)->set_car(obj); - else - throw pmt_wrong_type("pmt_set_car", pair); -} - -void -pmt_set_cdr(pmt_t pair, pmt_t obj) -{ - if (pair->is_pair()) - _pair(pair)->set_cdr(obj); - else - throw pmt_wrong_type("pmt_set_cdr", pair); -} - -//////////////////////////////////////////////////////////////////////////// -// Vectors -//////////////////////////////////////////////////////////////////////////// - -pmt_vector::pmt_vector(size_t len, pmt_t fill) - : d_v(len) -{ - for (size_t i = 0; i < len; i++) - d_v[i] = fill; -} - -pmt_t -pmt_vector::ref(size_t k) const -{ - if (k >= length()) - throw pmt_out_of_range("pmt_vector_ref", pmt_from_long(k)); - return d_v[k]; -} - -void -pmt_vector::set(size_t k, pmt_t obj) -{ - if (k >= length()) - throw pmt_out_of_range("pmt_vector_set", pmt_from_long(k)); - d_v[k] = obj; -} - -void -pmt_vector::fill(pmt_t obj) -{ - for (size_t i = 0; i < length(); i++) - d_v[i] = obj; -} - -bool -pmt_is_vector(pmt_t obj) -{ - return obj->is_vector(); -} - -pmt_t -pmt_make_vector(size_t k, pmt_t fill) -{ - return pmt_t(new pmt_vector(k, fill)); -} - -pmt_t -pmt_vector_ref(pmt_t vector, size_t k) -{ - if (!vector->is_vector()) - throw pmt_wrong_type("pmt_vector_ref", vector); - return _vector(vector)->ref(k); -} - -void -pmt_vector_set(pmt_t vector, size_t k, pmt_t obj) -{ - if (!vector->is_vector()) - throw pmt_wrong_type("pmt_vector_set", vector); - _vector(vector)->set(k, obj); -} - -void -pmt_vector_fill(pmt_t vector, pmt_t obj) -{ - if (!vector->is_vector()) - throw pmt_wrong_type("pmt_vector_set", vector); - _vector(vector)->fill(obj); -} - -//////////////////////////////////////////////////////////////////////////// -// Uniform Numeric Vectors -//////////////////////////////////////////////////////////////////////////// - -bool -pmt_is_uniform_vector(pmt_t x) -{ - return x->is_uniform_vector(); -} - -const void * -pmt_uniform_vector_elements(pmt_t vector, size_t &len) -{ - if (!vector->is_uniform_vector()) - throw pmt_wrong_type("pmt_uniform_vector_elements", vector); - return _uniform_vector(vector)->uniform_elements(len); -} - -void * -pmt_uniform_vector_writable_elements(pmt_t vector, size_t &len) -{ - if (!vector->is_uniform_vector()) - throw pmt_wrong_type("pmt_uniform_vector_writable_elements", vector); - return _uniform_vector(vector)->uniform_writable_elements(len); -} - -//////////////////////////////////////////////////////////////////////////// -// Dictionaries -//////////////////////////////////////////////////////////////////////////// - -pmt_dict::pmt_dict() - : d_alist(PMT_NIL) -{ -} - -void -pmt_dict::set(pmt_t key, pmt_t value) -{ - pmt_t p = pmt_assv(key, d_alist); // look for (key . value) pair - if (pmt_is_pair(p)){ // found existing pair... - pmt_set_cdr(p, value); // overrwrite cdr with new value - } - else { // not in the dict - d_alist = pmt_cons(pmt_cons(key, value), d_alist); // add new (key . value) pair - } -} - -pmt_t -pmt_dict::ref(pmt_t key, pmt_t not_found) const -{ - pmt_t p = pmt_assv(key, d_alist); // look for (key . value) pair - if (pmt_is_pair(p)) - return pmt_cdr(p); - else - return not_found; -} - -bool -pmt_dict::has_key(pmt_t key) const -{ - return pmt_is_pair(pmt_assv(key, d_alist)); -} - -pmt_t -pmt_dict::items() const -{ - return d_alist; -} - -pmt_t -pmt_dict::keys() const -{ - return pmt_map(pmt_car, d_alist); -} - -pmt_t -pmt_dict::values() const -{ - return pmt_map(pmt_cdr, d_alist); -} - -bool -pmt_is_dict(pmt_t obj) -{ - return obj->is_dict(); -} - -pmt_t -pmt_make_dict() -{ - return pmt_t(new pmt_dict()); -} - -void -pmt_dict_set(pmt_t dict, pmt_t key, pmt_t value) -{ - pmt_dict* d = _dict(dict); - if (!d) - throw pmt_wrong_type("pmt_dict_set", dict); - - d->set(key, value); -} - -bool -pmt_dict_has_key(pmt_t dict, pmt_t key) -{ - pmt_dict* d = _dict(dict); - if (!d) - throw pmt_wrong_type("pmt_dict_has_key", dict); - - return d->has_key(key); -} - -pmt_t -pmt_dict_ref(pmt_t dict, pmt_t key, pmt_t not_found) -{ - pmt_dict* d = _dict(dict); - if (!d) - throw pmt_wrong_type("pmt_dict_ref", dict); - - return d->ref(key, not_found); -} - -pmt_t -pmt_dict_items(pmt_t dict) -{ - if (!dict->is_dict()) - throw pmt_wrong_type("pmt_dict_items", dict); - - return _dict(dict)->items(); -} - -pmt_t -pmt_dict_keys(pmt_t dict) -{ - if (!dict->is_dict()) - throw pmt_wrong_type("pmt_dict_keys", dict); - - return _dict(dict)->keys(); -} - -pmt_t -pmt_dict_values(pmt_t dict) -{ - if (!dict->is_dict()) - throw pmt_wrong_type("pmt_dict_values", dict); - - return _dict(dict)->values(); -} - -//////////////////////////////////////////////////////////////////////////// -// Any -//////////////////////////////////////////////////////////////////////////// - -pmt_any::pmt_any(const boost::any &any) : d_any(any) {} - -bool -pmt_is_any(pmt_t obj) -{ - return obj->is_any(); -} - -pmt_t -pmt_make_any(const boost::any &any) -{ - return pmt_t(new pmt_any(any)); -} - -boost::any -pmt_any_ref(pmt_t obj) -{ - if (!obj->is_any()) - throw pmt_wrong_type("pmt_any_ref", obj); - return _any(obj)->ref(); -} - -void -pmt_any_set(pmt_t obj, const boost::any &any) -{ - if (!obj->is_any()) - throw pmt_wrong_type("pmt_any_set", obj); - _any(obj)->set(any); -} - -//////////////////////////////////////////////////////////////////////////// -// General Functions -//////////////////////////////////////////////////////////////////////////// - -bool -pmt_eq(const pmt_t& x, const pmt_t& y) -{ - return x == y; -} - -bool -pmt_eqv(const pmt_t& x, const pmt_t& y) -{ - if (x == y) - return true; - - if (x->is_integer() && y->is_integer()) - return _integer(x)->value() == _integer(y)->value(); - - if (x->is_real() && y->is_real()) - return _real(x)->value() == _real(y)->value(); - - if (x->is_complex() && y->is_complex()) - return _complex(x)->value() == _complex(y)->value(); - - return false; -} - -bool -pmt_equal(const pmt_t& x, const pmt_t& y) -{ - if (pmt_eqv(x, y)) - return true; - - if (x->is_pair() && y->is_pair()) - return pmt_equal(pmt_car(x), pmt_car(y)) && pmt_equal(pmt_cdr(x), pmt_cdr(y)); - - if (x->is_vector() && y->is_vector()){ - pmt_vector *xv = _vector(x); - pmt_vector *yv = _vector(y); - if (xv->length() != yv->length()) - return false; - - for (unsigned i = 0; i < xv->length(); i++) - if (!pmt_equal(xv->_ref(i), yv->_ref(i))) - return false; - - return true; - } - - if (x->is_uniform_vector() && y->is_uniform_vector()){ - pmt_uniform_vector *xv = _uniform_vector(x); - pmt_uniform_vector *yv = _uniform_vector(y); - if (xv->length() != yv->length()) - return false; - - size_t len_x, len_y; - if (memcmp(xv->uniform_elements(len_x), - yv->uniform_elements(len_y), - len_x) == 0) - return true; - - return true; - } - - // FIXME add other cases here... - - return false; -} - -size_t -pmt_length(const pmt_t& x) -{ - if (x->is_vector()) - return _vector(x)->length(); - - if (x->is_uniform_vector()) - return _uniform_vector(x)->length(); - - if (x->is_null()) return 0; - - if (x->is_pair()) { - size_t length=1; - pmt_t it = pmt_cdr(x); - while (pmt_is_pair(it)){ - length++; - it = pmt_cdr(it); - } - if (pmt_is_null(it)) - return length; - - // not a proper list - throw pmt_wrong_type("pmt_length", x); - } - - // FIXME dictionary length (number of entries) - - throw pmt_wrong_type("pmt_length", x); -} - -pmt_t -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 - return PMT_F; - - if (pmt_eq(obj, pmt_car(p))) - return p; - - alist = pmt_cdr(alist); - } - return PMT_F; -} - -pmt_t -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 - return PMT_F; - - if (pmt_eqv(obj, pmt_car(p))) - return p; - - alist = pmt_cdr(alist); - } - return PMT_F; -} - -pmt_t -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 - return PMT_F; - - if (pmt_equal(obj, pmt_car(p))) - return p; - - alist = pmt_cdr(alist); - } - return PMT_F; -} - -pmt_t -pmt_map(pmt_t proc(const pmt_t&), pmt_t list) -{ - pmt_t r = PMT_NIL; - - while(pmt_is_pair(list)){ - r = pmt_cons(proc(pmt_car(list)), r); - list = pmt_cdr(list); - } - - return pmt_reverse_x(r); -} - -pmt_t -pmt_reverse(pmt_t listx) -{ - pmt_t list = listx; - pmt_t r = PMT_NIL; - - while(pmt_is_pair(list)){ - r = pmt_cons(pmt_car(list), r); - list = pmt_cdr(list); - } - if (pmt_is_null(list)) - return r; - else - throw pmt_wrong_type("pmt_reverse", listx); -} - -pmt_t -pmt_reverse_x(pmt_t list) -{ - // FIXME do it destructively - return pmt_reverse(list); -} - -pmt_t -pmt_nth(size_t n, pmt_t list) -{ - pmt_t t = pmt_nthcdr(n, list); - if (pmt_is_pair(t)) - return pmt_car(t); - else - return PMT_NIL; -} - -pmt_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); - - while (n > 0){ - if (pmt_is_pair(list)){ - list = pmt_cdr(list); - n--; - continue; - } - if (pmt_is_null(list)) - return PMT_NIL; - else - throw pmt_wrong_type("pmt_nthcdr: not a LIST", list); - } - return list; -} - -pmt_t -pmt_memq(pmt_t obj, pmt_t list) -{ - while (pmt_is_pair(list)){ - if (pmt_eq(obj, pmt_car(list))) - return list; - list = pmt_cdr(list); - } - return PMT_F; -} - -pmt_t -pmt_memv(pmt_t obj, pmt_t list) -{ - while (pmt_is_pair(list)){ - if (pmt_eqv(obj, pmt_car(list))) - return list; - list = pmt_cdr(list); - } - return PMT_F; -} - -pmt_t -pmt_member(pmt_t obj, pmt_t list) -{ - while (pmt_is_pair(list)){ - if (pmt_equal(obj, pmt_car(list))) - return list; - list = pmt_cdr(list); - } - return PMT_F; -} - -bool -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))) - return false; - list1 = pmt_cdr(list1); - } - return true; -} - -pmt_t -pmt_list1(const pmt_t& x1) -{ - return pmt_cons(x1, PMT_NIL); -} - -pmt_t -pmt_list2(const pmt_t& x1, const pmt_t& x2) -{ - return pmt_cons(x1, pmt_cons(x2, PMT_NIL)); -} - -pmt_t -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_t -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_t -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_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) -{ - return pmt_cons(x1, pmt_cons(x2, pmt_cons(x3, pmt_cons(x4, pmt_cons(x5, pmt_cons(x6, PMT_NIL)))))); -} - -pmt_t -pmt_list_add(pmt_t list, const pmt_t& item) -{ - return pmt_reverse(pmt_cons(item, pmt_reverse(list))); -} - -pmt_t -pmt_caar(pmt_t pair) -{ - return (pmt_car(pmt_car(pair))); -} - -pmt_t -pmt_cadr(pmt_t pair) -{ - return pmt_car(pmt_cdr(pair)); -} - -pmt_t -pmt_cdar(pmt_t pair) -{ - return pmt_cdr(pmt_car(pair)); -} - -pmt_t -pmt_cddr(pmt_t pair) -{ - return pmt_cdr(pmt_cdr(pair)); -} - -pmt_t -pmt_caddr(pmt_t pair) -{ - return pmt_car(pmt_cdr(pmt_cdr(pair))); -} - -pmt_t -pmt_cadddr(pmt_t pair) -{ - return pmt_car(pmt_cdr(pmt_cdr(pmt_cdr(pair)))); -} - -bool -pmt_is_eof_object(pmt_t obj) -{ - return pmt_eq(obj, PMT_EOF); -} - -void -pmt_dump_sizeof() -{ - printf("sizeof(pmt_t) = %3zd\n", sizeof(pmt_t)); - printf("sizeof(pmt_base) = %3zd\n", sizeof(pmt_base)); - printf("sizeof(pmt_bool) = %3zd\n", sizeof(pmt_bool)); - printf("sizeof(pmt_symbol) = %3zd\n", sizeof(pmt_symbol)); - printf("sizeof(pmt_integer) = %3zd\n", sizeof(pmt_integer)); - printf("sizeof(pmt_real) = %3zd\n", sizeof(pmt_real)); - printf("sizeof(pmt_complex) = %3zd\n", sizeof(pmt_complex)); - printf("sizeof(pmt_null) = %3zd\n", sizeof(pmt_null)); - printf("sizeof(pmt_pair) = %3zd\n", sizeof(pmt_pair)); - printf("sizeof(pmt_vector) = %3zd\n", sizeof(pmt_vector)); - printf("sizeof(pmt_dict) = %3zd\n", sizeof(pmt_dict)); - printf("sizeof(pmt_uniform_vector) = %3zd\n", sizeof(pmt_uniform_vector)); -} - -} /* namespace gruel */ diff --git a/gruel/src/lib/pmt/Makefile.am b/gruel/src/lib/pmt/Makefile.am new file mode 100644 index 00000000..5e9f2fac --- /dev/null +++ b/gruel/src/lib/pmt/Makefile.am @@ -0,0 +1,111 @@ +# +# Copyright 2008,2009 Free Software Foundation, Inc. +# +# This file is part of GNU Radio +# +# GNU Radio is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GNU Radio is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + +include $(top_srcdir)/Makefile.common + +AM_CPPFLAGS = $(DEFINES) $(BOOST_CPPFLAGS) $(CPPUNIT_INCLUDES) $(GRUEL_INCLUDES) $(WITH_INCLUDES) + +TESTS = test_pmt + +noinst_LTLIBRARIES = libpmt.la + +# ---------------------------------------------------------------- +# these scripts generate code + +code_generator = \ + generate_unv.py \ + unv_template.h.t \ + unv_template.cc.t \ + unv_qa_template.cc.t + +GENERATED_H = \ + pmt_unv_int.h \ + qa_pmt_unv.h + +GENERATED_CC = \ + pmt_unv.cc \ + qa_pmt_unv.cc + +python_built_sources = $(GENERATED_H) $(GENERATED_CC) + +PMT_SERIAL_TAGS_H = $(abs_top_builddir)/gruel/src/include/gruel/pmt_serial_tags.h +BUILT_SOURCES = $(python_built_sources) $(PMT_SERIAL_TAGS_H) + +EXTRA_DIST = $(code_generator) + +# ---------------------------------------------------------------- + +libpmt_la_SOURCES = \ + pmt.cc \ + pmt_io.cc \ + pmt_pool.cc \ + pmt_serialize.cc \ + pmt_unv.cc + +libpmt_la_LIBADD = \ + $(BOOST_THREAD_LIB) \ + -lstdc++ + +noinst_HEADERS = \ + $(GENERATED_H) \ + pmt_int.h \ + qa_pmt.h \ + qa_pmt_prims.h + +# Build the qa code into its own library + +noinst_LTLIBRARIES += libpmt-qa.la + +libpmt_qa_la_SOURCES = \ + qa_pmt.cc \ + qa_pmt_prims.cc \ + qa_pmt_unv.cc + +# magic flags +libpmt_qa_la_LDFLAGS = $(NO_UNDEFINED) -avoid version + +libpmt_qa_la_LIBADD = \ + libpmt.la \ + $(CPPUNIT_LIBS) \ + -lstdc++ + +noinst_PROGRAMS = \ + test_pmt + + +LIBPMTQA = libpmt-qa.la + +test_pmt_SOURCES = test_pmt.cc +test_pmt_LDADD = $(LIBPMTQA) + +# Do creation and inclusion of other Makefiles last + +# common way for generating sources from templates when using +# BUILT_SOURCES, using parallel build protection. +gen_sources = $(python_built_sources) +gen_sources_deps = $(core_generator) +par_gen_command = PYTHONPATH=$(top_srcdir)/gruel/src/lib/pmt srcdir=$(srcdir) $(PYTHON) $(srcdir)/generate_unv.py +include $(top_srcdir)/Makefile.par.gen + +# Rule to create the build header file using GUILE +# Doesn't need parallel protections because there is a single target +$(PMT_SERIAL_TAGS_H): $(srcdir)/../../scheme/gnuradio/gen-serial-tags.scm $(srcdir)/../../scheme/gnuradio/pmt-serial-tags.scm + $(RUN_GUILE) $(srcdir)/../../scheme/gnuradio/gen-serial-tags.scm $(srcdir)/../../scheme/gnuradio/pmt-serial-tags.scm $(PMT_SERIAL_TAGS_H) diff --git a/gruel/src/lib/pmt/generate_unv.py b/gruel/src/lib/pmt/generate_unv.py new file mode 100755 index 00000000..02aace25 --- /dev/null +++ b/gruel/src/lib/pmt/generate_unv.py @@ -0,0 +1,190 @@ +#!/usr/bin/env python +# +# Copyright 2006,2009 Free Software Foundation, Inc. +# +# This file is part of GNU Radio +# +# GNU Radio is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3, or (at your option) +# any later version. +# +# GNU Radio is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GNU Radio; see the file COPYING. If not, write to +# the Free Software Foundation, Inc., 51 Franklin Street, +# Boston, MA 02110-1301, USA. +# + +""" +Generate code for uniform numeric vectors +""" + +import re, os, os.path + + +unv_types = ( + ('u8', 'uint8_t'), + ('s8', 'int8_t'), + ('u16', 'uint16_t'), + ('s16', 'int16_t'), + ('u32', 'uint32_t'), + ('s32', 'int32_t'), + ('u64', 'uint64_t'), + ('s64', 'int64_t'), + ('f32', 'float'), + ('f64', 'double'), + ('c32', 'std::complex'), + ('c64', 'std::complex') + ) + +header = """\ +/* -*- c++ -*- */ +/* + * Copyright 2006,2009 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ +""" + +guard_tail = """ +#endif +""" + +includes = """ +#ifdef HAVE_CONFIG_H +#include +#endif +#include +#include +#include "pmt_int.h" +""" + +qa_includes = """ +#include +#include +#include +#include + +using namespace pmt; +""" + + +# set srcdir to the directory that contains Makefile.am +try: + srcdir = os.environ['srcdir'] +except KeyError, e: + srcdir = "." +srcdir = srcdir + '/' + + +def open_src (name, mode): + global srcdir + return open(os.path.join (srcdir, name), mode) + + +def guard_name(filename): + return 'INCLUDED_' + re.sub('\.', '_', filename.upper()) + +def guard_head(filename): + guard = guard_name(filename) + return """ +#ifndef %s +#define %s +""" % (guard, guard) + + +def do_substitution (d, input, out_file): + def repl (match_obj): + key = match_obj.group (1) + # print key + return d[key] + + out = re.sub (r"@([a-zA-Z0-9_]+)@", repl, input) + out_file.write (out) + + +def generate_h(): + template = open_src('unv_template.h.t', 'r').read() + output_filename = 'pmt_unv_int.h' + output = open(output_filename, 'w') + output.write(header) + output.write(guard_head(output_filename)) + for tag, typ in unv_types: + d = { 'TAG' : tag, 'TYPE' : typ } + do_substitution(d, template, output) + output.write(guard_tail) + +def generate_cc(): + template = open_src('unv_template.cc.t', 'r').read() + output = open('pmt_unv.cc', 'w') + output.write(header) + output.write(includes) + for tag, typ in unv_types: + d = { 'TAG' : tag, 'TYPE' : typ } + do_substitution(d, template, output) + + +def generate_qa_h(): + output_filename = 'qa_pmt_unv.h' + output = open(output_filename, 'w') + output.write(header) + output.write(guard_head(output_filename)) + + output.write(''' +#include +#include + +class qa_pmt_unv : public CppUnit::TestCase { + + CPPUNIT_TEST_SUITE(qa_pmt_unv); +''') + for tag, typ in unv_types: + output.write(' CPPUNIT_TEST(test_%svector);\n' % (tag,)) + output.write('''\ + CPPUNIT_TEST_SUITE_END(); + + private: +''') + for tag, typ in unv_types: + output.write(' void test_%svector();\n' % (tag,)) + output.write('};\n') + output.write(guard_tail) + +def generate_qa_cc(): + template = open_src('unv_qa_template.cc.t', 'r').read() + output = open('qa_pmt_unv.cc', 'w') + output.write(header) + output.write(qa_includes) + for tag, typ in unv_types: + d = { 'TAG' : tag, 'TYPE' : typ } + do_substitution(d, template, output) + + +def main(): + generate_h() + generate_cc() + generate_qa_h() + generate_qa_cc() + +if __name__ == '__main__': + main() diff --git a/gruel/src/lib/pmt/pmt.cc b/gruel/src/lib/pmt/pmt.cc new file mode 100644 index 00000000..fbf557be --- /dev/null +++ b/gruel/src/lib/pmt/pmt.cc @@ -0,0 +1,1041 @@ +/* -*- c++ -*- */ +/* + * Copyright 2006,2009 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif +#include +#include +#include "pmt_int.h" +#include +#include +#include + +namespace pmt { + +static const int CACHE_LINE_SIZE = 64; // good guess + +# if (PMT_LOCAL_ALLOCATOR) + +static pmt_pool global_pmt_pool(sizeof(pmt_pair), CACHE_LINE_SIZE); + +void * +pmt_base::operator new(size_t size) +{ + void *p = global_pmt_pool.malloc(); + + // fprintf(stderr, "pmt_base::new p = %p\n", p); + assert((reinterpret_cast(p) & (CACHE_LINE_SIZE - 1)) == 0); + return p; +} + +void +pmt_base::operator delete(void *p, size_t size) +{ + global_pmt_pool.free(p); +} + +#endif + + +pmt_base::~pmt_base() +{ + // nop -- out of line virtual destructor +} + +//////////////////////////////////////////////////////////////////////////// +// Exceptions +//////////////////////////////////////////////////////////////////////////// + +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) +{ +} + +//////////////////////////////////////////////////////////////////////////// +// Dynamic Casts +//////////////////////////////////////////////////////////////////////////// + +static pmt_symbol * +_symbol(pmt_t x) +{ + return dynamic_cast(x.get()); +} + +static pmt_integer * +_integer(pmt_t x) +{ + return dynamic_cast(x.get()); +} + +static pmt_real * +_real(pmt_t x) +{ + return dynamic_cast(x.get()); +} + +static pmt_complex * +_complex(pmt_t x) +{ + return dynamic_cast(x.get()); +} + +static pmt_pair * +_pair(pmt_t x) +{ + return dynamic_cast(x.get()); +} + +static pmt_vector * +_vector(pmt_t x) +{ + return dynamic_cast(x.get()); +} + +static pmt_uniform_vector * +_uniform_vector(pmt_t x) +{ + return dynamic_cast(x.get()); +} + +static pmt_dict * +_dict(pmt_t x) +{ + return dynamic_cast(x.get()); +} + +static pmt_any * +_any(pmt_t x) +{ + return dynamic_cast(x.get()); +} + +//////////////////////////////////////////////////////////////////////////// +// Globals +//////////////////////////////////////////////////////////////////////////// + +const pmt_t PMT_T = pmt_t(new pmt_bool()); // singleton +const pmt_t PMT_F = pmt_t(new pmt_bool()); // singleton +const pmt_t PMT_NIL = pmt_t(new pmt_null()); // singleton +const pmt_t PMT_EOF = pmt_cons(PMT_NIL, PMT_NIL); // singleton + +//////////////////////////////////////////////////////////////////////////// +// Booleans +//////////////////////////////////////////////////////////////////////////// + +pmt_bool::pmt_bool(){} + +bool +pmt_is_true(pmt_t obj) +{ + return obj != PMT_F; +} + +bool +pmt_is_false(pmt_t obj) +{ + return obj == PMT_F; +} + +bool +pmt_is_bool(pmt_t obj) +{ + return obj->is_bool(); +} + +pmt_t +pmt_from_bool(bool val) +{ + return val ? PMT_T : PMT_F; +} + +bool +pmt_to_bool(pmt_t val) +{ + if (val == PMT_T) + return true; + if (val == PMT_F) + return false; + throw pmt_wrong_type("pmt_to_bool", val); +} + +//////////////////////////////////////////////////////////////////////////// +// Symbols +//////////////////////////////////////////////////////////////////////////// + +static const unsigned int SYMBOL_HASH_TABLE_SIZE = 701; +static std::vector s_symbol_hash_table(SYMBOL_HASH_TABLE_SIZE); + +pmt_symbol::pmt_symbol(const std::string &name) : d_name(name){} + + +static unsigned int +hash_string(const std::string &s) +{ + unsigned int h = 0; + unsigned int g = 0; + + for (std::string::const_iterator p = s.begin(); p != s.end(); ++p){ + h = (h << 4) + (*p & 0xff); + g = h & 0xf0000000; + if (g){ + h = h ^ (g >> 24); + h = h ^ g; + } + } + return h; +} + +bool +pmt_is_symbol(const pmt_t& obj) +{ + return obj->is_symbol(); +} + +pmt_t +pmt_string_to_symbol(const std::string &name) +{ + unsigned hash = hash_string(name) % SYMBOL_HASH_TABLE_SIZE; + + // Does a symbol with this name already exist? + for (pmt_t sym = s_symbol_hash_table[hash]; sym; sym = _symbol(sym)->next()){ + if (name == _symbol(sym)->name()) + return sym; // Yes. Return it + } + + // Nope. Make a new one. + pmt_t sym = pmt_t(new pmt_symbol(name)); + _symbol(sym)->set_next(s_symbol_hash_table[hash]); + s_symbol_hash_table[hash] = sym; + return sym; +} + +// alias... +pmt_t +pmt_intern(const std::string &name) +{ + return pmt_string_to_symbol(name); +} + +const std::string +pmt_symbol_to_string(const pmt_t& sym) +{ + if (!sym->is_symbol()) + throw pmt_wrong_type("pmt_symbol_to_string", sym); + + return _symbol(sym)->name(); +} + + + +//////////////////////////////////////////////////////////////////////////// +// Number +//////////////////////////////////////////////////////////////////////////// + +bool +pmt_is_number(pmt_t x) +{ + return x->is_number(); +} + +//////////////////////////////////////////////////////////////////////////// +// Integer +//////////////////////////////////////////////////////////////////////////// + +pmt_integer::pmt_integer(long value) : d_value(value) {} + +bool +pmt_is_integer(pmt_t x) +{ + return x->is_integer(); +} + + +pmt_t +pmt_from_long(long x) +{ + return pmt_t(new pmt_integer(x)); +} + +long +pmt_to_long(pmt_t x) +{ + pmt_integer* i = dynamic_cast(x.get()); + if ( i ) + return i->value(); + + throw pmt_wrong_type("pmt_to_long", x); +} + +//////////////////////////////////////////////////////////////////////////// +// Real +//////////////////////////////////////////////////////////////////////////// + +pmt_real::pmt_real(double value) : d_value(value) {} + +bool +pmt_is_real(pmt_t x) +{ + return x->is_real(); +} + +pmt_t +pmt_from_double(double x) +{ + return pmt_t(new pmt_real(x)); +} + +double +pmt_to_double(pmt_t x) +{ + if (x->is_real()) + return _real(x)->value(); + if (x->is_integer()) + return _integer(x)->value(); + + throw pmt_wrong_type("pmt_to_double", x); +} + +//////////////////////////////////////////////////////////////////////////// +// Complex +//////////////////////////////////////////////////////////////////////////// + +pmt_complex::pmt_complex(std::complex value) : d_value(value) {} + +bool +pmt_is_complex(pmt_t x) +{ + return x->is_complex(); +} + +pmt_t +pmt_make_rectangular(double re, double im) +{ + return pmt_t(new pmt_complex(std::complex(re, im))); +} + +std::complex +pmt_to_complex(pmt_t x) +{ + if (x->is_complex()) + return _complex(x)->value(); + if (x->is_real()) + return _real(x)->value(); + if (x->is_integer()) + return _integer(x)->value(); + + throw pmt_wrong_type("pmt_to_complex", x); +} + +//////////////////////////////////////////////////////////////////////////// +// Pairs +//////////////////////////////////////////////////////////////////////////// + +pmt_null::pmt_null() {} +pmt_pair::pmt_pair(const pmt_t& car, const pmt_t& cdr) : d_car(car), d_cdr(cdr) {} + +bool +pmt_is_null(const pmt_t& x) +{ + return x == PMT_NIL; +} + +bool +pmt_is_pair(const pmt_t& obj) +{ + return obj->is_pair(); +} + +pmt_t +pmt_cons(const pmt_t& x, const pmt_t& y) +{ + return pmt_t(new pmt_pair(x, y)); +} + +pmt_t +pmt_car(const pmt_t& pair) +{ + pmt_pair* p = dynamic_cast(pair.get()); + if ( p ) + return p->car(); + + throw pmt_wrong_type("pmt_car", pair); +} + +pmt_t +pmt_cdr(const pmt_t& pair) +{ + pmt_pair* p = dynamic_cast(pair.get()); + if ( p ) + return p->cdr(); + + throw pmt_wrong_type("pmt_cdr", pair); +} + +void +pmt_set_car(pmt_t pair, pmt_t obj) +{ + if (pair->is_pair()) + _pair(pair)->set_car(obj); + else + throw pmt_wrong_type("pmt_set_car", pair); +} + +void +pmt_set_cdr(pmt_t pair, pmt_t obj) +{ + if (pair->is_pair()) + _pair(pair)->set_cdr(obj); + else + throw pmt_wrong_type("pmt_set_cdr", pair); +} + +//////////////////////////////////////////////////////////////////////////// +// Vectors +//////////////////////////////////////////////////////////////////////////// + +pmt_vector::pmt_vector(size_t len, pmt_t fill) + : d_v(len) +{ + for (size_t i = 0; i < len; i++) + d_v[i] = fill; +} + +pmt_t +pmt_vector::ref(size_t k) const +{ + if (k >= length()) + throw pmt_out_of_range("pmt_vector_ref", pmt_from_long(k)); + return d_v[k]; +} + +void +pmt_vector::set(size_t k, pmt_t obj) +{ + if (k >= length()) + throw pmt_out_of_range("pmt_vector_set", pmt_from_long(k)); + d_v[k] = obj; +} + +void +pmt_vector::fill(pmt_t obj) +{ + for (size_t i = 0; i < length(); i++) + d_v[i] = obj; +} + +bool +pmt_is_vector(pmt_t obj) +{ + return obj->is_vector(); +} + +pmt_t +pmt_make_vector(size_t k, pmt_t fill) +{ + return pmt_t(new pmt_vector(k, fill)); +} + +pmt_t +pmt_vector_ref(pmt_t vector, size_t k) +{ + if (!vector->is_vector()) + throw pmt_wrong_type("pmt_vector_ref", vector); + return _vector(vector)->ref(k); +} + +void +pmt_vector_set(pmt_t vector, size_t k, pmt_t obj) +{ + if (!vector->is_vector()) + throw pmt_wrong_type("pmt_vector_set", vector); + _vector(vector)->set(k, obj); +} + +void +pmt_vector_fill(pmt_t vector, pmt_t obj) +{ + if (!vector->is_vector()) + throw pmt_wrong_type("pmt_vector_set", vector); + _vector(vector)->fill(obj); +} + +//////////////////////////////////////////////////////////////////////////// +// Uniform Numeric Vectors +//////////////////////////////////////////////////////////////////////////// + +bool +pmt_is_uniform_vector(pmt_t x) +{ + return x->is_uniform_vector(); +} + +const void * +pmt_uniform_vector_elements(pmt_t vector, size_t &len) +{ + if (!vector->is_uniform_vector()) + throw pmt_wrong_type("pmt_uniform_vector_elements", vector); + return _uniform_vector(vector)->uniform_elements(len); +} + +void * +pmt_uniform_vector_writable_elements(pmt_t vector, size_t &len) +{ + if (!vector->is_uniform_vector()) + throw pmt_wrong_type("pmt_uniform_vector_writable_elements", vector); + return _uniform_vector(vector)->uniform_writable_elements(len); +} + +//////////////////////////////////////////////////////////////////////////// +// Dictionaries +//////////////////////////////////////////////////////////////////////////// + +pmt_dict::pmt_dict() + : d_alist(PMT_NIL) +{ +} + +void +pmt_dict::set(pmt_t key, pmt_t value) +{ + pmt_t p = pmt_assv(key, d_alist); // look for (key . value) pair + if (pmt_is_pair(p)){ // found existing pair... + pmt_set_cdr(p, value); // overrwrite cdr with new value + } + else { // not in the dict + d_alist = pmt_cons(pmt_cons(key, value), d_alist); // add new (key . value) pair + } +} + +pmt_t +pmt_dict::ref(pmt_t key, pmt_t not_found) const +{ + pmt_t p = pmt_assv(key, d_alist); // look for (key . value) pair + if (pmt_is_pair(p)) + return pmt_cdr(p); + else + return not_found; +} + +bool +pmt_dict::has_key(pmt_t key) const +{ + return pmt_is_pair(pmt_assv(key, d_alist)); +} + +pmt_t +pmt_dict::items() const +{ + return d_alist; +} + +pmt_t +pmt_dict::keys() const +{ + return pmt_map(pmt_car, d_alist); +} + +pmt_t +pmt_dict::values() const +{ + return pmt_map(pmt_cdr, d_alist); +} + +bool +pmt_is_dict(pmt_t obj) +{ + return obj->is_dict(); +} + +pmt_t +pmt_make_dict() +{ + return pmt_t(new pmt_dict()); +} + +void +pmt_dict_set(pmt_t dict, pmt_t key, pmt_t value) +{ + pmt_dict* d = _dict(dict); + if (!d) + throw pmt_wrong_type("pmt_dict_set", dict); + + d->set(key, value); +} + +bool +pmt_dict_has_key(pmt_t dict, pmt_t key) +{ + pmt_dict* d = _dict(dict); + if (!d) + throw pmt_wrong_type("pmt_dict_has_key", dict); + + return d->has_key(key); +} + +pmt_t +pmt_dict_ref(pmt_t dict, pmt_t key, pmt_t not_found) +{ + pmt_dict* d = _dict(dict); + if (!d) + throw pmt_wrong_type("pmt_dict_ref", dict); + + return d->ref(key, not_found); +} + +pmt_t +pmt_dict_items(pmt_t dict) +{ + if (!dict->is_dict()) + throw pmt_wrong_type("pmt_dict_items", dict); + + return _dict(dict)->items(); +} + +pmt_t +pmt_dict_keys(pmt_t dict) +{ + if (!dict->is_dict()) + throw pmt_wrong_type("pmt_dict_keys", dict); + + return _dict(dict)->keys(); +} + +pmt_t +pmt_dict_values(pmt_t dict) +{ + if (!dict->is_dict()) + throw pmt_wrong_type("pmt_dict_values", dict); + + return _dict(dict)->values(); +} + +//////////////////////////////////////////////////////////////////////////// +// Any +//////////////////////////////////////////////////////////////////////////// + +pmt_any::pmt_any(const boost::any &any) : d_any(any) {} + +bool +pmt_is_any(pmt_t obj) +{ + return obj->is_any(); +} + +pmt_t +pmt_make_any(const boost::any &any) +{ + return pmt_t(new pmt_any(any)); +} + +boost::any +pmt_any_ref(pmt_t obj) +{ + if (!obj->is_any()) + throw pmt_wrong_type("pmt_any_ref", obj); + return _any(obj)->ref(); +} + +void +pmt_any_set(pmt_t obj, const boost::any &any) +{ + if (!obj->is_any()) + throw pmt_wrong_type("pmt_any_set", obj); + _any(obj)->set(any); +} + +//////////////////////////////////////////////////////////////////////////// +// General Functions +//////////////////////////////////////////////////////////////////////////// + +bool +pmt_eq(const pmt_t& x, const pmt_t& y) +{ + return x == y; +} + +bool +pmt_eqv(const pmt_t& x, const pmt_t& y) +{ + if (x == y) + return true; + + if (x->is_integer() && y->is_integer()) + return _integer(x)->value() == _integer(y)->value(); + + if (x->is_real() && y->is_real()) + return _real(x)->value() == _real(y)->value(); + + if (x->is_complex() && y->is_complex()) + return _complex(x)->value() == _complex(y)->value(); + + return false; +} + +bool +pmt_equal(const pmt_t& x, const pmt_t& y) +{ + if (pmt_eqv(x, y)) + return true; + + if (x->is_pair() && y->is_pair()) + return pmt_equal(pmt_car(x), pmt_car(y)) && pmt_equal(pmt_cdr(x), pmt_cdr(y)); + + if (x->is_vector() && y->is_vector()){ + pmt_vector *xv = _vector(x); + pmt_vector *yv = _vector(y); + if (xv->length() != yv->length()) + return false; + + for (unsigned i = 0; i < xv->length(); i++) + if (!pmt_equal(xv->_ref(i), yv->_ref(i))) + return false; + + return true; + } + + if (x->is_uniform_vector() && y->is_uniform_vector()){ + pmt_uniform_vector *xv = _uniform_vector(x); + pmt_uniform_vector *yv = _uniform_vector(y); + if (xv->length() != yv->length()) + return false; + + size_t len_x, len_y; + if (memcmp(xv->uniform_elements(len_x), + yv->uniform_elements(len_y), + len_x) == 0) + return true; + + return true; + } + + // FIXME add other cases here... + + return false; +} + +size_t +pmt_length(const pmt_t& x) +{ + if (x->is_vector()) + return _vector(x)->length(); + + if (x->is_uniform_vector()) + return _uniform_vector(x)->length(); + + if (x->is_null()) return 0; + + if (x->is_pair()) { + size_t length=1; + pmt_t it = pmt_cdr(x); + while (pmt_is_pair(it)){ + length++; + it = pmt_cdr(it); + } + if (pmt_is_null(it)) + return length; + + // not a proper list + throw pmt_wrong_type("pmt_length", x); + } + + // FIXME dictionary length (number of entries) + + throw pmt_wrong_type("pmt_length", x); +} + +pmt_t +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 + return PMT_F; + + if (pmt_eq(obj, pmt_car(p))) + return p; + + alist = pmt_cdr(alist); + } + return PMT_F; +} + +pmt_t +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 + return PMT_F; + + if (pmt_eqv(obj, pmt_car(p))) + return p; + + alist = pmt_cdr(alist); + } + return PMT_F; +} + +pmt_t +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 + return PMT_F; + + if (pmt_equal(obj, pmt_car(p))) + return p; + + alist = pmt_cdr(alist); + } + return PMT_F; +} + +pmt_t +pmt_map(pmt_t proc(const pmt_t&), pmt_t list) +{ + pmt_t r = PMT_NIL; + + while(pmt_is_pair(list)){ + r = pmt_cons(proc(pmt_car(list)), r); + list = pmt_cdr(list); + } + + return pmt_reverse_x(r); +} + +pmt_t +pmt_reverse(pmt_t listx) +{ + pmt_t list = listx; + pmt_t r = PMT_NIL; + + while(pmt_is_pair(list)){ + r = pmt_cons(pmt_car(list), r); + list = pmt_cdr(list); + } + if (pmt_is_null(list)) + return r; + else + throw pmt_wrong_type("pmt_reverse", listx); +} + +pmt_t +pmt_reverse_x(pmt_t list) +{ + // FIXME do it destructively + return pmt_reverse(list); +} + +pmt_t +pmt_nth(size_t n, pmt_t list) +{ + pmt_t t = pmt_nthcdr(n, list); + if (pmt_is_pair(t)) + return pmt_car(t); + else + return PMT_NIL; +} + +pmt_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); + + while (n > 0){ + if (pmt_is_pair(list)){ + list = pmt_cdr(list); + n--; + continue; + } + if (pmt_is_null(list)) + return PMT_NIL; + else + throw pmt_wrong_type("pmt_nthcdr: not a LIST", list); + } + return list; +} + +pmt_t +pmt_memq(pmt_t obj, pmt_t list) +{ + while (pmt_is_pair(list)){ + if (pmt_eq(obj, pmt_car(list))) + return list; + list = pmt_cdr(list); + } + return PMT_F; +} + +pmt_t +pmt_memv(pmt_t obj, pmt_t list) +{ + while (pmt_is_pair(list)){ + if (pmt_eqv(obj, pmt_car(list))) + return list; + list = pmt_cdr(list); + } + return PMT_F; +} + +pmt_t +pmt_member(pmt_t obj, pmt_t list) +{ + while (pmt_is_pair(list)){ + if (pmt_equal(obj, pmt_car(list))) + return list; + list = pmt_cdr(list); + } + return PMT_F; +} + +bool +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))) + return false; + list1 = pmt_cdr(list1); + } + return true; +} + +pmt_t +pmt_list1(const pmt_t& x1) +{ + return pmt_cons(x1, PMT_NIL); +} + +pmt_t +pmt_list2(const pmt_t& x1, const pmt_t& x2) +{ + return pmt_cons(x1, pmt_cons(x2, PMT_NIL)); +} + +pmt_t +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_t +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_t +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_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) +{ + return pmt_cons(x1, pmt_cons(x2, pmt_cons(x3, pmt_cons(x4, pmt_cons(x5, pmt_cons(x6, PMT_NIL)))))); +} + +pmt_t +pmt_list_add(pmt_t list, const pmt_t& item) +{ + return pmt_reverse(pmt_cons(item, pmt_reverse(list))); +} + +pmt_t +pmt_caar(pmt_t pair) +{ + return (pmt_car(pmt_car(pair))); +} + +pmt_t +pmt_cadr(pmt_t pair) +{ + return pmt_car(pmt_cdr(pair)); +} + +pmt_t +pmt_cdar(pmt_t pair) +{ + return pmt_cdr(pmt_car(pair)); +} + +pmt_t +pmt_cddr(pmt_t pair) +{ + return pmt_cdr(pmt_cdr(pair)); +} + +pmt_t +pmt_caddr(pmt_t pair) +{ + return pmt_car(pmt_cdr(pmt_cdr(pair))); +} + +pmt_t +pmt_cadddr(pmt_t pair) +{ + return pmt_car(pmt_cdr(pmt_cdr(pmt_cdr(pair)))); +} + +bool +pmt_is_eof_object(pmt_t obj) +{ + return pmt_eq(obj, PMT_EOF); +} + +void +pmt_dump_sizeof() +{ + printf("sizeof(pmt_t) = %3zd\n", sizeof(pmt_t)); + printf("sizeof(pmt_base) = %3zd\n", sizeof(pmt_base)); + printf("sizeof(pmt_bool) = %3zd\n", sizeof(pmt_bool)); + printf("sizeof(pmt_symbol) = %3zd\n", sizeof(pmt_symbol)); + printf("sizeof(pmt_integer) = %3zd\n", sizeof(pmt_integer)); + printf("sizeof(pmt_real) = %3zd\n", sizeof(pmt_real)); + printf("sizeof(pmt_complex) = %3zd\n", sizeof(pmt_complex)); + printf("sizeof(pmt_null) = %3zd\n", sizeof(pmt_null)); + printf("sizeof(pmt_pair) = %3zd\n", sizeof(pmt_pair)); + printf("sizeof(pmt_vector) = %3zd\n", sizeof(pmt_vector)); + printf("sizeof(pmt_dict) = %3zd\n", sizeof(pmt_dict)); + printf("sizeof(pmt_uniform_vector) = %3zd\n", sizeof(pmt_uniform_vector)); +} + +} /* namespace pmt */ diff --git a/gruel/src/lib/pmt/pmt_int.h b/gruel/src/lib/pmt/pmt_int.h new file mode 100644 index 00000000..9aac322a --- /dev/null +++ b/gruel/src/lib/pmt/pmt_int.h @@ -0,0 +1,227 @@ +/* -*- c++ -*- */ +/* + * Copyright 2006,2009 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ +#ifndef INCLUDED_PMT_INT_H +#define INCLUDED_PMT_INT_H + +#include +#include + +/* + * EVERYTHING IN THIS FILE IS PRIVATE TO THE IMPLEMENTATION! + * + * See pmt.h for the public interface + */ + +#define PMT_LOCAL_ALLOCATOR 0 // define to 0 or 1 +namespace pmt { + +class pmt_base : boost::noncopyable { +protected: + pmt_base(){}; + virtual ~pmt_base(); + +public: + virtual bool is_bool() const { return false; } + virtual bool is_symbol() const { return false; } + virtual bool is_number() const { return false; } + virtual bool is_integer() const { return false; } + virtual bool is_real() const { return false; } + virtual bool is_complex() const { return false; } + virtual bool is_null() const { return false; } + virtual bool is_pair() const { return false; } + virtual bool is_vector() const { return false; } + virtual bool is_dict() const { return false; } + virtual bool is_any() const { return false; } + + virtual bool is_uniform_vector() const { return false; } + virtual bool is_u8vector() const { return false; } + virtual bool is_s8vector() const { return false; } + virtual bool is_u16vector() const { return false; } + virtual bool is_s16vector() const { return false; } + virtual bool is_u32vector() const { return false; } + virtual bool is_s32vector() const { return false; } + virtual bool is_u64vector() const { return false; } + virtual bool is_s64vector() const { return false; } + virtual bool is_f32vector() const { return false; } + virtual bool is_f64vector() const { return false; } + virtual bool is_c32vector() const { return false; } + virtual bool is_c64vector() const { return false; } + +# if (PMT_LOCAL_ALLOCATOR) + void *operator new(size_t); + void operator delete(void *, size_t); +#endif +}; + +class pmt_bool : public pmt_base +{ +public: + pmt_bool(); + //~pmt_bool(){} + + bool is_bool() const { return true; } +}; + + +class pmt_symbol : public pmt_base +{ + std::string d_name; + pmt_t d_next; + +public: + pmt_symbol(const std::string &name); + //~pmt_symbol(){} + + bool is_symbol() const { return true; } + const std::string name() { return d_name; } + + pmt_t next() { return d_next; } // symbol table link + void set_next(pmt_t next) { d_next = next; } +}; + +class pmt_integer : public pmt_base +{ + long d_value; + +public: + pmt_integer(long value); + //~pmt_integer(){} + + bool is_number() const { return true; } + bool is_integer() const { return true; } + long value() const { return d_value; } +}; + +class pmt_real : public pmt_base +{ + double d_value; + +public: + pmt_real(double value); + //~pmt_real(){} + + bool is_number() const { return true; } + bool is_real() const { return true; } + double value() const { return d_value; } +}; + +class pmt_complex : public pmt_base +{ + std::complex d_value; + +public: + pmt_complex(std::complex value); + //~pmt_complex(){} + + bool is_number() const { return true; } + bool is_complex() const { return true; } + std::complex value() const { return d_value; } +}; + +class pmt_null : public pmt_base +{ +public: + pmt_null(); + //~pmt_null(){} + + bool is_null() const { return true; } +}; + +class pmt_pair : public pmt_base +{ + pmt_t d_car; + pmt_t d_cdr; + +public: + pmt_pair(const pmt_t& car, const pmt_t& cdr); + //~pmt_pair(){}; + + bool is_pair() const { return true; } + pmt_t car() const { return d_car; } + pmt_t cdr() const { return d_cdr; } + + void set_car(pmt_t car) { d_car = car; } + void set_cdr(pmt_t cdr) { d_cdr = cdr; } +}; + +class pmt_vector : public pmt_base +{ + std::vector d_v; + +public: + pmt_vector(size_t len, pmt_t fill); + //~pmt_vector(); + + bool is_vector() const { return true; } + pmt_t ref(size_t k) const; + void set(size_t k, pmt_t obj); + void fill(pmt_t fill); + size_t length() const { return d_v.size(); } + + pmt_t _ref(size_t k) const { return d_v[k]; } +}; + +class pmt_dict : public pmt_base +{ + pmt_t d_alist; // list of (key . value) pairs + +public: + pmt_dict(); + //~pmt_dict(); + + bool is_dict() const { return true; } + void set(pmt_t key, pmt_t value); + pmt_t ref(pmt_t key, pmt_t default_value) const; + bool has_key(pmt_t key) const; + pmt_t items() const; + pmt_t keys() const; + pmt_t values() const; +}; + +class pmt_any : public pmt_base +{ + boost::any d_any; + +public: + pmt_any(const boost::any &any); + //~pmt_any(); + + bool is_any() const { return true; } + const boost::any &ref() const { return d_any; } + void set(const boost::any &any) { d_any = any; } +}; + + +class pmt_uniform_vector : public pmt_base +{ +public: + bool is_uniform_vector() const { return true; } + virtual const void *uniform_elements(size_t &len) = 0; + virtual void *uniform_writable_elements(size_t &len) = 0; + virtual size_t length() const = 0; +}; + +#include "pmt_unv_int.h" + +} /* namespace pmt */ + +#endif /* INCLUDED_PMT_INT_H */ diff --git a/gruel/src/lib/pmt/pmt_io.cc b/gruel/src/lib/pmt/pmt_io.cc new file mode 100644 index 00000000..f5a82de0 --- /dev/null +++ b/gruel/src/lib/pmt/pmt_io.cc @@ -0,0 +1,141 @@ +/* -*- c++ -*- */ +/* + * Copyright 2006,2009 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif +#include +#include +#include "pmt_int.h" +#include + +namespace pmt { + +static void +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)) // () + port << ")"; + + else if (pmt_is_pair(obj)){ // normal list + port << " "; + pmt_write_list_tail(obj, port); + } + else { // dotted pair + port << " . "; + pmt_write(obj, port); + port << ")"; + } +} + +void +pmt_write(pmt_t obj, std::ostream &port) +{ + if (pmt_is_bool(obj)){ + if (pmt_is_true(obj)) + port << "#t"; + else + port << "#f"; + } + 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_real(obj)) + port << pmt_to_double(obj); + else if (pmt_is_complex(obj)){ + std::complex c = pmt_to_complex(obj); + port << c.real() << '+' << c.imag() << 'i'; + } + else + goto error; + } + else if (pmt_is_null(obj)){ + port << "()"; + } + else if (pmt_is_pair(obj)){ + port << "("; + pmt_write_list_tail(obj, port); + } + else if (pmt_is_dict(obj)){ + // FIXME + // port << "#"; + port << "#"; + } + else if (pmt_is_vector(obj)){ + // FIXME + // port << "#"; + port << "#"; + } + else if (pmt_is_uniform_vector(obj)){ + // FIXME + // port << "#"; + port << "#"; + } + else { + error: + // FIXME + // port << "#<" << obj << ">"; + port << "#"; + } +} + +std::ostream& operator<<(std::ostream &os, pmt_t obj) +{ + pmt_write(obj, os); + return os; +} + +std::string +pmt_write_string(pmt_t obj) +{ + std::ostringstream s; + s << obj; + return s.str(); +} + +pmt_t +pmt_read(std::istream &port) +{ + throw pmt_notimplemented("notimplemented: pmt_read", PMT_NIL); +} + +void +pmt_serialize(pmt_t obj, std::ostream &sink) +{ + throw pmt_notimplemented("notimplemented: pmt_serialize", obj); +} + +/*! + * \brief Create obj from portable byte-serial representation + */ +pmt_t +pmt_deserialize(std::istream &source) +{ + throw pmt_notimplemented("notimplemented: pmt_deserialize", PMT_NIL); +} + +} /* namespace pmt */ diff --git a/gruel/src/lib/pmt/pmt_pool.cc b/gruel/src/lib/pmt/pmt_pool.cc new file mode 100644 index 00000000..731d28ca --- /dev/null +++ b/gruel/src/lib/pmt/pmt_pool.cc @@ -0,0 +1,112 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007,2009 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif +#include +#include +#include + +namespace pmt { + +static inline size_t +ROUNDUP(size_t x, size_t stride) +{ + return ((((x) + (stride) - 1)/(stride)) * (stride)); +} + +pmt_pool::pmt_pool(size_t itemsize, size_t alignment, + size_t allocation_size, size_t max_items) + : d_itemsize(ROUNDUP(itemsize, alignment)), + d_alignment(alignment), + d_allocation_size(std::max(allocation_size, 16 * itemsize)), + d_max_items(max_items), d_n_items(0), + d_freelist(0) +{ +} + +pmt_pool::~pmt_pool() +{ + for (unsigned int i = 0; i < d_allocations.size(); i++){ + delete [] d_allocations[i]; + } +} + +void * +pmt_pool::malloc() +{ + scoped_lock guard(d_mutex); + item *p; + + if (d_max_items != 0){ + while (d_n_items >= d_max_items) + d_cond.wait(guard); + } + + if (d_freelist){ // got something? + p = d_freelist; + d_freelist = p->d_next; + d_n_items++; + return p; + } + + // allocate a new chunk + char *alloc = new char[d_allocation_size + d_alignment - 1]; + d_allocations.push_back(alloc); + + // get the alignment we require + char *start = (char *)(((uintptr_t)alloc + d_alignment-1) & -d_alignment); + char *end = alloc + d_allocation_size + d_alignment - 1; + size_t n = (end - start) / d_itemsize; + + // link the new items onto the free list. + p = (item *) start; + for (size_t i = 0; i < n; i++){ + p->d_next = d_freelist; + d_freelist = p; + p = (item *)((char *) p + d_itemsize); + } + + // now return the first one + p = d_freelist; + d_freelist = p->d_next; + d_n_items++; + return p; +} + +void +pmt_pool::free(void *foo) +{ + if (!foo) + return; + + scoped_lock guard(d_mutex); + + item *p = (item *) foo; + p->d_next = d_freelist; + d_freelist = p; + d_n_items--; + if (d_max_items != 0) + d_cond.notify_one(); +} + +} /* namespace pmt */ diff --git a/gruel/src/lib/pmt/pmt_serialize.cc b/gruel/src/lib/pmt/pmt_serialize.cc new file mode 100644 index 00000000..937423a9 --- /dev/null +++ b/gruel/src/lib/pmt/pmt_serialize.cc @@ -0,0 +1,357 @@ +/* -*- c++ -*- */ +/* + * Copyright 2007,2009 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + */ + +#ifdef HAVE_CONFIG_H +#include +#endif +#include +#include +#include "pmt_int.h" +#include "gruel/pmt_serial_tags.h" + +namespace pmt { + +static pmt_t parse_pair(std::streambuf &sb); + +// ---------------------------------------------------------------- +// output primitives +// ---------------------------------------------------------------- + +static bool +serialize_untagged_u8(unsigned int i, std::streambuf &sb) +{ + return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); +} + +// always writes big-endian +static bool +serialize_untagged_u16(unsigned int i, std::streambuf &sb) +{ + sb.sputc((i >> 8) & 0xff); + return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); +} + +// always writes big-endian +static bool +serialize_untagged_u32(unsigned int i, std::streambuf &sb) +{ + sb.sputc((i >> 24) & 0xff); + sb.sputc((i >> 16) & 0xff); + sb.sputc((i >> 8) & 0xff); + return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); +} + +#if 0 +// always writes big-endian +static bool +serialize_untagged_u64(uint64_t i, std::streambuf &sb) +{ + sb.sputc((i >> 56) & 0xff); + sb.sputc((i >> 48) & 0xff); + sb.sputc((i >> 40) & 0xff); + sb.sputc((i >> 32) & 0xff); + sb.sputc((i >> 24) & 0xff); + sb.sputc((i >> 16) & 0xff); + sb.sputc((i >> 8) & 0xff); + return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); +} +#endif + +// ---------------------------------------------------------------- +// input primitives +// ---------------------------------------------------------------- + + +// always reads big-endian +static bool +deserialize_untagged_u8(uint8_t *ip, std::streambuf &sb) +{ + std::streambuf::traits_type::int_type t; + int i; + + t = sb.sbumpc(); + i = t & 0xff; + + *ip = i; + return t != std::streambuf::traits_type::eof(); +} + +// always reads big-endian +static bool +deserialize_untagged_u16(uint16_t *ip, std::streambuf &sb) +{ + std::streambuf::traits_type::int_type t; + int i; + + t = sb.sbumpc(); + i = t & 0xff; + + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + + *ip = i; + return t != std::streambuf::traits_type::eof(); +} + +// always reads big-endian +static bool +deserialize_untagged_u32(uint32_t *ip, std::streambuf &sb) +{ + std::streambuf::traits_type::int_type t; + int i; + + t = sb.sbumpc(); + i = t & 0xff; + + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + + *ip = i; + return t != std::streambuf::traits_type::eof(); +} + +#if 0 +// always reads big-endian +static bool +deserialize_untagged_u64(uint64_t *ip, std::streambuf &sb) +{ + std::streambuf::traits_type::int_type t; + uint64_t i; + + t = sb.sbumpc(); + i = t & 0xff; + + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + t = sb.sbumpc(); + i = (i << 8) | (t & 0xff); + + *ip = i; + return t != std::streambuf::traits_type::eof(); +} +#endif + +/* + * Write portable byte-serial representation of \p obj to \p sb + * + * N.B., Circular structures cause infinite recursion. + */ +bool +pmt_serialize(pmt_t obj, std::streambuf &sb) +{ + bool ok = true; + + tail_recursion: + + if (pmt_is_bool(obj)){ + if (pmt_eq(obj, PMT_T)) + return serialize_untagged_u8(PST_TRUE, sb); + else + return serialize_untagged_u8(PST_FALSE, sb); + } + + if (pmt_is_null(obj)) + return serialize_untagged_u8(PST_NULL, sb); + + if (pmt_is_symbol(obj)){ + const std::string s = pmt_symbol_to_string(obj); + size_t len = s.size(); + ok = serialize_untagged_u8(PST_SYMBOL, sb); + ok &= serialize_untagged_u16(len, sb); + for (size_t i = 0; i < len; i++) + ok &= serialize_untagged_u8(s[i], sb); + return ok; + } + + if (pmt_is_pair(obj)){ + ok = serialize_untagged_u8(PST_PAIR, sb); + ok &= pmt_serialize(pmt_car(obj), sb); + if (!ok) + return false; + obj = pmt_cdr(obj); + goto tail_recursion; + } + + if (pmt_is_number(obj)){ + + 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)) + throw pmt_notimplemented("pmt_serialize (real)", obj); + + if (pmt_is_complex(obj)) + throw pmt_notimplemented("pmt_serialize (complex)", obj); + } + + if (pmt_is_vector(obj)) + throw pmt_notimplemented("pmt_serialize (vector)", obj); + + if (pmt_is_uniform_vector(obj)) + throw pmt_notimplemented("pmt_serialize (uniform-vector)", obj); + + if (pmt_is_dict(obj)) + throw pmt_notimplemented("pmt_serialize (dict)", obj); + + + throw pmt_notimplemented("pmt_serialize (?)", obj); +} + +/* + * Create obj from portable byte-serial representation + * + * Returns next obj from streambuf, or PMT_EOF at end of file. + * Throws exception on malformed input. + */ +pmt_t +pmt_deserialize(std::streambuf &sb) +{ + uint8_t tag; + //uint8_t u8; + uint16_t u16; + uint32_t u32; + //uint32_t u64; + static char tmpbuf[1024]; + + if (!deserialize_untagged_u8(&tag, sb)) + return PMT_EOF; + + switch (tag){ + case PST_TRUE: + return PMT_T; + + case PST_FALSE: + return PMT_F; + + case PST_NULL: + return PMT_NIL; + + case PST_SYMBOL: + if (!deserialize_untagged_u16(&u16, sb)) + goto error; + if (u16 > sizeof(tmpbuf)) + throw pmt_notimplemented("pmt_deserialize: very long symbol", + PMT_F); + if (sb.sgetn(tmpbuf, u16) != u16) + goto error; + return pmt_intern(std::string(tmpbuf, u16)); + + case PST_INT32: + if (!deserialize_untagged_u32(&u32, sb)) + goto error; + return pmt_from_long((int32_t) u32); + + case PST_PAIR: + return parse_pair(sb); + + case PST_DOUBLE: + case PST_COMPLEX: + case PST_VECTOR: + case PST_DICT: + case PST_UNIFORM_VECTOR: + case PST_COMMENT: + throw pmt_notimplemented("pmt_deserialize: tag value = ", + pmt_from_long(tag)); + + default: + throw pmt_exception("pmt_deserialize: malformed input stream, tag value = ", + pmt_from_long(tag)); + } + + error: + throw pmt_exception("pmt_deserialize: malformed input stream", PMT_F); +} + +/* + * This is a mostly non-recursive implementation that allows us to + * deserialize very long lists w/o exhausting the evaluation stack. + * + * On entry we've already eaten the PST_PAIR tag. + */ +pmt_t +parse_pair(std::streambuf &sb) +{ + uint8_t tag; + pmt_t val, expr, lastnptr, nptr; + + // + // Keep appending nodes until we get a non-PAIR cdr. + // + lastnptr = PMT_NIL; + while (1){ + expr = pmt_deserialize(sb); // read the car + + nptr = pmt_cons(expr, PMT_NIL); // build new cell + if (pmt_is_null(lastnptr)) + val = nptr; + else + pmt_set_cdr(lastnptr, nptr); + lastnptr = nptr; + + if (!deserialize_untagged_u8(&tag, sb)) // get tag of cdr + throw pmt_exception("pmt_deserialize: malformed input stream", PMT_F); + + if (tag == PST_PAIR) + continue; // keep on looping... + + if (tag == PST_NULL){ + expr = PMT_NIL; + break; + } + + // + // default: push tag back and use pmt_deserialize to get the cdr + // + sb.sungetc(); + expr = pmt_deserialize(sb); + break; + } + + // + // At this point, expr contains the value of the final cdr in the list. + // + pmt_set_cdr(lastnptr, expr); + return val; +} + +} /* namespace pmt */ diff --git a/gruel/src/lib/pmt/qa_pmt.cc b/gruel/src/lib/pmt/qa_pmt.cc new file mode 100644 index 00000000..250befaf --- /dev/null +++ b/gruel/src/lib/pmt/qa_pmt.cc @@ -0,0 +1,40 @@ +/* + * Copyright 2006 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +/* + * This class gathers together all the test cases for pmt into + * a single test suite. As you create new test cases, add them here. + */ + +#include +#include +#include + +CppUnit::TestSuite * +qa_pmt::suite () +{ + CppUnit::TestSuite *s = new CppUnit::TestSuite ("pmt"); + + s->addTest (qa_pmt_prims::suite ()); + s->addTest (qa_pmt_unv::suite ()); + + return s; +} diff --git a/gruel/src/lib/pmt/qa_pmt.h b/gruel/src/lib/pmt/qa_pmt.h new file mode 100644 index 00000000..43a6dbf6 --- /dev/null +++ b/gruel/src/lib/pmt/qa_pmt.h @@ -0,0 +1,36 @@ +/* -*- c++ -*- */ +/* + * Copyright 2006 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#ifndef INCLUDED_QA_PMT_H +#define INCLUDED_QA_PMT_H + +#include + +//! collect all the tests for pmt + +class qa_pmt { + public: + //! return suite of tests for all of pmt + static CppUnit::TestSuite *suite (); +}; + +#endif /* INCLUDED_QA_PMT_H */ diff --git a/gruel/src/lib/pmt/qa_pmt_prims.cc b/gruel/src/lib/pmt/qa_pmt_prims.cc new file mode 100644 index 00000000..b8135472 --- /dev/null +++ b/gruel/src/lib/pmt/qa_pmt_prims.cc @@ -0,0 +1,438 @@ +/* -*- c++ -*- */ +/* + * Copyright 2006,2009 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#include +#include +#include +#include +#include + +using namespace pmt; + +void +qa_pmt_prims::test_symbols() +{ + CPPUNIT_ASSERT(!pmt_is_symbol(PMT_T)); + CPPUNIT_ASSERT(!pmt_is_symbol(PMT_F)); + CPPUNIT_ASSERT_THROW(pmt_symbol_to_string(PMT_F), pmt_wrong_type); + + pmt_t sym1 = pmt_string_to_symbol("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 = pmt_string_to_symbol("foo"); + pmt_t sym3 = pmt_string_to_symbol("test"); + CPPUNIT_ASSERT_EQUAL(sym1, sym3); + CPPUNIT_ASSERT(sym1 != sym2); + CPPUNIT_ASSERT(sym1 == sym3); + + static const int N = 2048; + std::vector v1(N); + std::vector v2(N); + + // generate a bunch of symbols + for (int i = 0; i < N; i++){ + char buf[100]; + snprintf(buf, sizeof(buf), "test-%d", i); + v1[i] = pmt_string_to_symbol(buf); + } + + // confirm that they are all unique + for (int i = 0; i < N; i++) + for (int j = i + 1; j < N; j++) + CPPUNIT_ASSERT(v1[i] != v1[j]); + + // generate the same symbols again + for (int i = 0; i < N; i++){ + char buf[100]; + snprintf(buf, sizeof(buf), "test-%d", i); + v2[i] = pmt_string_to_symbol(buf); + } + + // confirm that we get the same ones back + for (int i = 0; i < N; i++) + CPPUNIT_ASSERT(v1[i] == v2[i]); +} + +void +qa_pmt_prims::test_booleans() +{ + pmt_t sym = pmt_string_to_symbol("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); +} + +void +qa_pmt_prims::test_integers() +{ + pmt_t p1 = pmt_from_long(1); + pmt_t m1 = pmt_from_long(-1); + CPPUNIT_ASSERT(!pmt_is_integer(PMT_T)); + CPPUNIT_ASSERT(pmt_is_integer(p1)); + CPPUNIT_ASSERT(pmt_is_integer(m1)); + CPPUNIT_ASSERT_THROW(pmt_to_long(PMT_T), pmt_wrong_type); + CPPUNIT_ASSERT_EQUAL(-1L, pmt_to_long(m1)); + CPPUNIT_ASSERT_EQUAL(1L, pmt_to_long(p1)); +} + +void +qa_pmt_prims::test_reals() +{ + pmt_t p1 = pmt_from_double(1); + pmt_t m1 = pmt_from_double(-1); + CPPUNIT_ASSERT(!pmt_is_real(PMT_T)); + CPPUNIT_ASSERT(pmt_is_real(p1)); + CPPUNIT_ASSERT(pmt_is_real(m1)); + CPPUNIT_ASSERT_THROW(pmt_to_double(PMT_T), pmt_wrong_type); + CPPUNIT_ASSERT_EQUAL(-1.0, pmt_to_double(m1)); + CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(p1)); + CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(pmt_from_long(1))); +} + +void +qa_pmt_prims::test_complexes() +{ + pmt_t p1 = pmt_make_rectangular(2, -3); + pmt_t m1 = pmt_make_rectangular(-3, 2); + CPPUNIT_ASSERT(!pmt_is_complex(PMT_T)); + CPPUNIT_ASSERT(pmt_is_complex(p1)); + CPPUNIT_ASSERT(pmt_is_complex(m1)); + CPPUNIT_ASSERT_THROW(pmt_to_complex(PMT_T), pmt_wrong_type); + CPPUNIT_ASSERT_EQUAL(std::complex(2, -3), pmt_to_complex(p1)); + CPPUNIT_ASSERT_EQUAL(std::complex(-3, 2), pmt_to_complex(m1)); + CPPUNIT_ASSERT_EQUAL(std::complex(1.0, 0), pmt_to_complex(pmt_from_long(1))); + CPPUNIT_ASSERT_EQUAL(std::complex(1.0, 0), pmt_to_complex(pmt_from_double(1.0))); +} + +void +qa_pmt_prims::test_pairs() +{ + CPPUNIT_ASSERT(pmt_is_null(PMT_NIL)); + CPPUNIT_ASSERT(!pmt_is_pair(PMT_NIL)); + pmt_t s1 = pmt_string_to_symbol("s1"); + pmt_t s2 = pmt_string_to_symbol("s2"); + pmt_t s3 = pmt_string_to_symbol("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); +} + +void +qa_pmt_prims::test_vectors() +{ + static const size_t N = 3; + pmt_t v1 = pmt_make_vector(N, PMT_NIL); + CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1)); + pmt_t s0 = pmt_string_to_symbol("s0"); + pmt_t s1 = pmt_string_to_symbol("s1"); + pmt_t s2 = pmt_string_to_symbol("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); + for (size_t i = 0; i < N; i++) + CPPUNIT_ASSERT_EQUAL(s0, pmt_vector_ref(v1, i)); +} + +void +qa_pmt_prims::test_equivalence() +{ + pmt_t s0 = pmt_string_to_symbol("s0"); + pmt_t s1 = pmt_string_to_symbol("s1"); + pmt_t s2 = pmt_string_to_symbol("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)); +} + +void +qa_pmt_prims::test_misc() +{ + pmt_t k0 = pmt_string_to_symbol("k0"); + pmt_t k1 = pmt_string_to_symbol("k1"); + pmt_t k2 = pmt_string_to_symbol("k2"); + pmt_t k3 = pmt_string_to_symbol("k3"); + pmt_t v0 = pmt_string_to_symbol("v0"); + pmt_t v1 = pmt_string_to_symbol("v1"); + pmt_t v2 = pmt_string_to_symbol("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))); +} + +void +qa_pmt_prims::test_dict() +{ + pmt_t dict = pmt_make_dict(); + CPPUNIT_ASSERT(pmt_is_dict(dict)); + + pmt_t k0 = pmt_string_to_symbol("k0"); + pmt_t k1 = pmt_string_to_symbol("k1"); + pmt_t k2 = pmt_string_to_symbol("k2"); + pmt_t k3 = pmt_string_to_symbol("k3"); + pmt_t v0 = pmt_string_to_symbol("v0"); + pmt_t v1 = pmt_string_to_symbol("v1"); + pmt_t v2 = pmt_string_to_symbol("v2"); + pmt_t v3 = pmt_string_to_symbol("v3"); + pmt_t not_found = pmt_cons(PMT_NIL, PMT_NIL); + + CPPUNIT_ASSERT(!pmt_dict_has_key(dict, k0)); + pmt_dict_set(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)); + pmt_dict_set(dict, k1, v1); + pmt_dict_set(dict, k2, v2); + CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v1)); + pmt_dict_set(dict, k1, v3); + CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v3)); + + pmt_t keys = pmt_cons(k2, pmt_cons(k1, pmt_cons(k0, PMT_NIL))); + pmt_t vals = pmt_cons(v2, pmt_cons(v3, pmt_cons(v0, PMT_NIL))); + CPPUNIT_ASSERT(pmt_equal(keys, pmt_dict_keys(dict))); + CPPUNIT_ASSERT(pmt_equal(vals, pmt_dict_values(dict))); +} + +void +qa_pmt_prims::test_io() +{ + pmt_t k0 = pmt_string_to_symbol("k0"); + pmt_t k1 = pmt_string_to_symbol("k1"); + pmt_t k2 = pmt_string_to_symbol("k2"); + pmt_t k3 = pmt_string_to_symbol("k3"); + + CPPUNIT_ASSERT_EQUAL(std::string("k0"), pmt_write_string(k0)); +} + +void +qa_pmt_prims::test_lists() +{ + pmt_t s0 = pmt_intern("s0"); + pmt_t s1 = pmt_intern("s1"); + pmt_t s2 = pmt_intern("s2"); + pmt_t s3 = pmt_intern("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)); +} + +// ------------------------------------------------------------------------ + +// class foo is used in test_any below. +// It can't be declared in the scope of test_any because of template +// namespace problems. + +class foo { +public: + double d_double; + int d_int; + foo(double d=0, int i=0) : d_double(d), d_int(i) {} +}; + +bool operator==(const foo &a, const foo &b) +{ + return a.d_double == b.d_double && a.d_int == b.d_int; +} + +std::ostream& operator<<(std::ostream &os, const foo obj) +{ + os << ""; + return os; +} + +void +qa_pmt_prims::test_any() +{ + boost::any a0; + boost::any a1; + boost::any a2; + + a0 = std::string("Hello!"); + a1 = 42; + a2 = foo(3.250, 21); + + pmt_t p0 = pmt_make_any(a0); + pmt_t p1 = pmt_make_any(a1); + pmt_t p2 = pmt_make_any(a2); + + CPPUNIT_ASSERT_EQUAL(std::string("Hello!"), + boost::any_cast(pmt_any_ref(p0))); + + CPPUNIT_ASSERT_EQUAL(42, + boost::any_cast(pmt_any_ref(p1))); + + CPPUNIT_ASSERT_EQUAL(foo(3.250, 21), + boost::any_cast(pmt_any_ref(p2))); +} + +// ------------------------------------------------------------------------ + +void +qa_pmt_prims::test_serialize() +{ + std::stringbuf sb; // fake channel + pmt_t a = pmt_intern("a"); + pmt_t b = pmt_intern("b"); + pmt_t c = pmt_intern("c"); + + sb.str(""); // reset channel to empty + + // write stuff to channel + + pmt_serialize(PMT_NIL, sb); + pmt_serialize(pmt_intern("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); + + // read it back + + CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_NIL)); + CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_intern("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 + + + // FIXME add tests for real, complex, vector, uniform-vector, dict + // FIXME add tests for malformed input too. + +} + +void +qa_pmt_prims::test_sets() +{ + pmt_t s1 = pmt_intern("s1"); + pmt_t s2 = pmt_intern("s2"); + pmt_t s3 = pmt_intern("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)); +} diff --git a/gruel/src/lib/pmt/qa_pmt_prims.h b/gruel/src/lib/pmt/qa_pmt_prims.h new file mode 100644 index 00000000..effb3a09 --- /dev/null +++ b/gruel/src/lib/pmt/qa_pmt_prims.h @@ -0,0 +1,67 @@ +/* -*- c++ -*- */ +/* + * Copyright 2006 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ +#ifndef INCLUDED_QA_PMT_PRIMS_H +#define INCLUDED_QA_PMT_PRIMS_H + +#include +#include + +class qa_pmt_prims : public CppUnit::TestCase { + + CPPUNIT_TEST_SUITE(qa_pmt_prims); + CPPUNIT_TEST(test_symbols); + CPPUNIT_TEST(test_booleans); + CPPUNIT_TEST(test_integers); + CPPUNIT_TEST(test_reals); + CPPUNIT_TEST(test_complexes); + CPPUNIT_TEST(test_pairs); + CPPUNIT_TEST(test_vectors); + CPPUNIT_TEST(test_equivalence); + CPPUNIT_TEST(test_misc); + CPPUNIT_TEST(test_dict); + CPPUNIT_TEST(test_any); + CPPUNIT_TEST(test_io); + CPPUNIT_TEST(test_lists); + CPPUNIT_TEST(test_serialize); + CPPUNIT_TEST(test_sets); + CPPUNIT_TEST_SUITE_END(); + + private: + void test_symbols(); + void test_booleans(); + void test_integers(); + void test_reals(); + void test_complexes(); + void test_pairs(); + void test_vectors(); + void test_equivalence(); + void test_misc(); + void test_dict(); + void test_any(); + void test_io(); + void test_lists(); + void test_serialize(); + void test_sets(); +}; + +#endif /* INCLUDED_QA_PMT_PRIMS_H */ + diff --git a/gruel/src/lib/pmt/test_pmt.cc b/gruel/src/lib/pmt/test_pmt.cc new file mode 100644 index 00000000..034785f4 --- /dev/null +++ b/gruel/src/lib/pmt/test_pmt.cc @@ -0,0 +1,37 @@ +/* -*- c++ -*- */ +/* + * Copyright 2006 Free Software Foundation, Inc. + * + * This file is part of GNU Radio + * + * GNU Radio is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3, or (at your option) + * any later version. + * + * GNU Radio is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with GNU Radio; see the file COPYING. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, + * Boston, MA 02110-1301, USA. + */ + +#include +#include + +int +main(int argc, char **argv) +{ + + CppUnit::TextTestRunner runner; + + runner.addTest(qa_pmt::suite ()); + + bool was_successful = runner.run("", false); + + return was_successful ? 0 : 1; +} diff --git a/gruel/src/lib/pmt/unv_qa_template.cc.t b/gruel/src/lib/pmt/unv_qa_template.cc.t new file mode 100644 index 00000000..1e2c8e8e --- /dev/null +++ b/gruel/src/lib/pmt/unv_qa_template.cc.t @@ -0,0 +1,35 @@ +void +qa_pmt_unv::test_@TAG@vector() +{ + static const size_t N = 3; + pmt_t v1 = pmt_make_@TAG@vector(N, 0); + CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1)); + @TYPE@ s0 = @TYPE@(10); + @TYPE@ s1 = @TYPE@(20); + @TYPE@ s2 = @TYPE@(30); + + pmt_@TAG@vector_set(v1, 0, s0); + pmt_@TAG@vector_set(v1, 1, s1); + pmt_@TAG@vector_set(v1, 2, s2); + + 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); + + size_t len; + const @TYPE@ *rd = pmt_@TAG@vector_elements(v1, len); + CPPUNIT_ASSERT_EQUAL(len, N); + CPPUNIT_ASSERT_EQUAL(s0, rd[0]); + CPPUNIT_ASSERT_EQUAL(s1, rd[1]); + CPPUNIT_ASSERT_EQUAL(s2, rd[2]); + + @TYPE@ *wr = pmt_@TAG@vector_writable_elements(v1, len); + CPPUNIT_ASSERT_EQUAL(len, N); + wr[0] = @TYPE@(0); + CPPUNIT_ASSERT_EQUAL(@TYPE@(0), wr[0]); + CPPUNIT_ASSERT_EQUAL(s1, wr[1]); + CPPUNIT_ASSERT_EQUAL(s2, wr[2]); +} diff --git a/gruel/src/lib/pmt/unv_template.cc.t b/gruel/src/lib/pmt/unv_template.cc.t new file mode 100644 index 00000000..148965c0 --- /dev/null +++ b/gruel/src/lib/pmt/unv_template.cc.t @@ -0,0 +1,122 @@ +//////////////////////////////////////////////////////////////////////////// +// pmt_@TAG@vector +//////////////////////////////////////////////////////////////////////////// + +namespace pmt { + +static pmt_@TAG@vector * +_@TAG@vector(pmt_t x) +{ + return dynamic_cast(x.get()); +} + + +pmt_@TAG@vector::pmt_@TAG@vector(size_t k, @TYPE@ fill) + : d_v(k) +{ + for (size_t i = 0; i < k; i++) + d_v[i] = fill; +} + +pmt_@TAG@vector::pmt_@TAG@vector(size_t k, const @TYPE@ *data) + : d_v(k) +{ + for (size_t i = 0; i < k; i++) + d_v[i] = data[i]; +} + +@TYPE@ +pmt_@TAG@vector::ref(size_t k) const +{ + if (k >= length()) + throw pmt_out_of_range("pmt_@TAG@vector_ref", pmt_from_long(k)); + return d_v[k]; +} + +void +pmt_@TAG@vector::set(size_t k, @TYPE@ x) +{ + if (k >= length()) + throw pmt_out_of_range("pmt_@TAG@vector_set", pmt_from_long(k)); + d_v[k] = x; +} + +const @TYPE@ * +pmt_@TAG@vector::elements(size_t &len) +{ + len = length(); + return &d_v[0]; +} + +@TYPE@ * +pmt_@TAG@vector::writable_elements(size_t &len) +{ + len = length(); + return &d_v[0]; +} + +const void* +pmt_@TAG@vector::uniform_elements(size_t &len) +{ + len = length() * sizeof(@TYPE@); + return &d_v[0]; +} + +void* +pmt_@TAG@vector::uniform_writable_elements(size_t &len) +{ + len = length() * sizeof(@TYPE@); + return &d_v[0]; +} + +bool +pmt_is_@TAG@vector(pmt_t obj) +{ + return obj->is_@TAG@vector(); +} + +pmt_t +pmt_make_@TAG@vector(size_t k, @TYPE@ fill) +{ + return pmt_t(new pmt_@TAG@vector(k, fill)); +} + +pmt_t +pmt_init_@TAG@vector(size_t k, const @TYPE@ *data) +{ + return pmt_t(new pmt_@TAG@vector(k, data)); +} + +@TYPE@ +pmt_@TAG@vector_ref(pmt_t vector, size_t k) +{ + if (!vector->is_@TAG@vector()) + throw pmt_wrong_type("pmt_@TAG@vector_ref", vector); + return _@TAG@vector(vector)->ref(k); +} + +void +pmt_@TAG@vector_set(pmt_t vector, size_t k, @TYPE@ obj) +{ + if (!vector->is_@TAG@vector()) + throw pmt_wrong_type("pmt_@TAG@vector_set", vector); + _@TAG@vector(vector)->set(k, obj); +} + +const @TYPE@ * +pmt_@TAG@vector_elements(pmt_t vector, size_t &len) +{ + if (!vector->is_@TAG@vector()) + throw pmt_wrong_type("pmt_@TAG@vector_elements", vector); + return _@TAG@vector(vector)->elements(len); +} + +@TYPE@ * +pmt_@TAG@vector_writable_elements(pmt_t vector, size_t &len) +{ + if (!vector->is_@TAG@vector()) + throw pmt_wrong_type("pmt_@TAG@vector_writable_elements", vector); + return _@TAG@vector(vector)->writable_elements(len); +} + +} /* namespace pmt */ diff --git a/gruel/src/lib/pmt/unv_template.h.t b/gruel/src/lib/pmt/unv_template.h.t new file mode 100644 index 00000000..83ba0be0 --- /dev/null +++ b/gruel/src/lib/pmt/unv_template.h.t @@ -0,0 +1,23 @@ + +//////////////////////////////////////////////////////////////////////////// +// pmt_@TAG@vector +//////////////////////////////////////////////////////////////////////////// + +class pmt_@TAG@vector : public pmt_uniform_vector +{ + std::vector< @TYPE@ > d_v; + +public: + pmt_@TAG@vector(size_t k, @TYPE@ fill); + pmt_@TAG@vector(size_t k, const @TYPE@ *data); + // ~pmt_@TAG@vector(); + + bool is_@TAG@vector() const { return true; } + size_t length() const { return d_v.size(); } + @TYPE@ ref(size_t k) const; + void set(size_t k, @TYPE@ x); + const @TYPE@ *elements(size_t &len); + @TYPE@ *writable_elements(size_t &len); + const void *uniform_elements(size_t &len); + void *uniform_writable_elements(size_t &len); +}; diff --git a/gruel/src/lib/pmt_int.h b/gruel/src/lib/pmt_int.h deleted file mode 100644 index 03f0e555..00000000 --- a/gruel/src/lib/pmt_int.h +++ /dev/null @@ -1,227 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006,2009 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with GNU Radio; see the file COPYING. If not, write to - * the Free Software Foundation, Inc., 51 Franklin Street, - * Boston, MA 02110-1301, USA. - */ -#ifndef INCLUDED_PMT_INT_H -#define INCLUDED_PMT_INT_H - -#include -#include - -/* - * EVERYTHING IN THIS FILE IS PRIVATE TO THE IMPLEMENTATION! - * - * See pmt.h for the public interface - */ - -#define PMT_LOCAL_ALLOCATOR 0 // define to 0 or 1 -namespace gruel { - -class pmt_base : boost::noncopyable { -protected: - pmt_base(){}; - virtual ~pmt_base(); - -public: - virtual bool is_bool() const { return false; } - virtual bool is_symbol() const { return false; } - virtual bool is_number() const { return false; } - virtual bool is_integer() const { return false; } - virtual bool is_real() const { return false; } - virtual bool is_complex() const { return false; } - virtual bool is_null() const { return false; } - virtual bool is_pair() const { return false; } - virtual bool is_vector() const { return false; } - virtual bool is_dict() const { return false; } - virtual bool is_any() const { return false; } - - virtual bool is_uniform_vector() const { return false; } - virtual bool is_u8vector() const { return false; } - virtual bool is_s8vector() const { return false; } - virtual bool is_u16vector() const { return false; } - virtual bool is_s16vector() const { return false; } - virtual bool is_u32vector() const { return false; } - virtual bool is_s32vector() const { return false; } - virtual bool is_u64vector() const { return false; } - virtual bool is_s64vector() const { return false; } - virtual bool is_f32vector() const { return false; } - virtual bool is_f64vector() const { return false; } - virtual bool is_c32vector() const { return false; } - virtual bool is_c64vector() const { return false; } - -# if (PMT_LOCAL_ALLOCATOR) - void *operator new(size_t); - void operator delete(void *, size_t); -#endif -}; - -class pmt_bool : public pmt_base -{ -public: - pmt_bool(); - //~pmt_bool(){} - - bool is_bool() const { return true; } -}; - - -class pmt_symbol : public pmt_base -{ - std::string d_name; - pmt_t d_next; - -public: - pmt_symbol(const std::string &name); - //~pmt_symbol(){} - - bool is_symbol() const { return true; } - const std::string name() { return d_name; } - - pmt_t next() { return d_next; } // symbol table link - void set_next(pmt_t next) { d_next = next; } -}; - -class pmt_integer : public pmt_base -{ - long d_value; - -public: - pmt_integer(long value); - //~pmt_integer(){} - - bool is_number() const { return true; } - bool is_integer() const { return true; } - long value() const { return d_value; } -}; - -class pmt_real : public pmt_base -{ - double d_value; - -public: - pmt_real(double value); - //~pmt_real(){} - - bool is_number() const { return true; } - bool is_real() const { return true; } - double value() const { return d_value; } -}; - -class pmt_complex : public pmt_base -{ - std::complex d_value; - -public: - pmt_complex(std::complex value); - //~pmt_complex(){} - - bool is_number() const { return true; } - bool is_complex() const { return true; } - std::complex value() const { return d_value; } -}; - -class pmt_null : public pmt_base -{ -public: - pmt_null(); - //~pmt_null(){} - - bool is_null() const { return true; } -}; - -class pmt_pair : public pmt_base -{ - pmt_t d_car; - pmt_t d_cdr; - -public: - pmt_pair(const pmt_t& car, const pmt_t& cdr); - //~pmt_pair(){}; - - bool is_pair() const { return true; } - pmt_t car() const { return d_car; } - pmt_t cdr() const { return d_cdr; } - - void set_car(pmt_t car) { d_car = car; } - void set_cdr(pmt_t cdr) { d_cdr = cdr; } -}; - -class pmt_vector : public pmt_base -{ - std::vector d_v; - -public: - pmt_vector(size_t len, pmt_t fill); - //~pmt_vector(); - - bool is_vector() const { return true; } - pmt_t ref(size_t k) const; - void set(size_t k, pmt_t obj); - void fill(pmt_t fill); - size_t length() const { return d_v.size(); } - - pmt_t _ref(size_t k) const { return d_v[k]; } -}; - -class pmt_dict : public pmt_base -{ - pmt_t d_alist; // list of (key . value) pairs - -public: - pmt_dict(); - //~pmt_dict(); - - bool is_dict() const { return true; } - void set(pmt_t key, pmt_t value); - pmt_t ref(pmt_t key, pmt_t default_value) const; - bool has_key(pmt_t key) const; - pmt_t items() const; - pmt_t keys() const; - pmt_t values() const; -}; - -class pmt_any : public pmt_base -{ - boost::any d_any; - -public: - pmt_any(const boost::any &any); - //~pmt_any(); - - bool is_any() const { return true; } - const boost::any &ref() const { return d_any; } - void set(const boost::any &any) { d_any = any; } -}; - - -class pmt_uniform_vector : public pmt_base -{ -public: - bool is_uniform_vector() const { return true; } - virtual const void *uniform_elements(size_t &len) = 0; - virtual void *uniform_writable_elements(size_t &len) = 0; - virtual size_t length() const = 0; -}; - -#include "pmt_unv_int.h" - -} /* namespace gruel */ - -#endif /* INCLUDED_PMT_INT_H */ diff --git a/gruel/src/lib/pmt_io.cc b/gruel/src/lib/pmt_io.cc deleted file mode 100644 index e10ea781..00000000 --- a/gruel/src/lib/pmt_io.cc +++ /dev/null @@ -1,141 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006,2009 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - */ - -#ifdef HAVE_CONFIG_H -#include -#endif -#include -#include -#include "pmt_int.h" -#include - -namespace gruel { - -static void -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)) // () - port << ")"; - - else if (pmt_is_pair(obj)){ // normal list - port << " "; - pmt_write_list_tail(obj, port); - } - else { // dotted pair - port << " . "; - pmt_write(obj, port); - port << ")"; - } -} - -void -pmt_write(pmt_t obj, std::ostream &port) -{ - if (pmt_is_bool(obj)){ - if (pmt_is_true(obj)) - port << "#t"; - else - port << "#f"; - } - 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_real(obj)) - port << pmt_to_double(obj); - else if (pmt_is_complex(obj)){ - std::complex c = pmt_to_complex(obj); - port << c.real() << '+' << c.imag() << 'i'; - } - else - goto error; - } - else if (pmt_is_null(obj)){ - port << "()"; - } - else if (pmt_is_pair(obj)){ - port << "("; - pmt_write_list_tail(obj, port); - } - else if (pmt_is_dict(obj)){ - // FIXME - // port << "#"; - port << "#"; - } - else if (pmt_is_vector(obj)){ - // FIXME - // port << "#"; - port << "#"; - } - else if (pmt_is_uniform_vector(obj)){ - // FIXME - // port << "#"; - port << "#"; - } - else { - error: - // FIXME - // port << "#<" << obj << ">"; - port << "#"; - } -} - -std::ostream& operator<<(std::ostream &os, pmt_t obj) -{ - pmt_write(obj, os); - return os; -} - -std::string -pmt_write_string(pmt_t obj) -{ - std::ostringstream s; - s << obj; - return s.str(); -} - -pmt_t -pmt_read(std::istream &port) -{ - throw pmt_notimplemented("notimplemented: pmt_read", PMT_NIL); -} - -void -pmt_serialize(pmt_t obj, std::ostream &sink) -{ - throw pmt_notimplemented("notimplemented: pmt_serialize", obj); -} - -/*! - * \brief Create obj from portable byte-serial representation - */ -pmt_t -pmt_deserialize(std::istream &source) -{ - throw pmt_notimplemented("notimplemented: pmt_deserialize", PMT_NIL); -} - -} /* namespace gruel */ diff --git a/gruel/src/lib/pmt_pool.cc b/gruel/src/lib/pmt_pool.cc deleted file mode 100644 index 79a22ea7..00000000 --- a/gruel/src/lib/pmt_pool.cc +++ /dev/null @@ -1,112 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2007,2009 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - */ - -#ifdef HAVE_CONFIG_H -#include -#endif -#include -#include -#include - -namespace gruel { - -static inline size_t -ROUNDUP(size_t x, size_t stride) -{ - return ((((x) + (stride) - 1)/(stride)) * (stride)); -} - -pmt_pool::pmt_pool(size_t itemsize, size_t alignment, - size_t allocation_size, size_t max_items) - : d_itemsize(ROUNDUP(itemsize, alignment)), - d_alignment(alignment), - d_allocation_size(std::max(allocation_size, 16 * itemsize)), - d_max_items(max_items), d_n_items(0), - d_freelist(0) -{ -} - -pmt_pool::~pmt_pool() -{ - for (unsigned int i = 0; i < d_allocations.size(); i++){ - delete [] d_allocations[i]; - } -} - -void * -pmt_pool::malloc() -{ - scoped_lock guard(d_mutex); - item *p; - - if (d_max_items != 0){ - while (d_n_items >= d_max_items) - d_cond.wait(guard); - } - - if (d_freelist){ // got something? - p = d_freelist; - d_freelist = p->d_next; - d_n_items++; - return p; - } - - // allocate a new chunk - char *alloc = new char[d_allocation_size + d_alignment - 1]; - d_allocations.push_back(alloc); - - // get the alignment we require - char *start = (char *)(((uintptr_t)alloc + d_alignment-1) & -d_alignment); - char *end = alloc + d_allocation_size + d_alignment - 1; - size_t n = (end - start) / d_itemsize; - - // link the new items onto the free list. - p = (item *) start; - for (size_t i = 0; i < n; i++){ - p->d_next = d_freelist; - d_freelist = p; - p = (item *)((char *) p + d_itemsize); - } - - // now return the first one - p = d_freelist; - d_freelist = p->d_next; - d_n_items++; - return p; -} - -void -pmt_pool::free(void *foo) -{ - if (!foo) - return; - - scoped_lock guard(d_mutex); - - item *p = (item *) foo; - p->d_next = d_freelist; - d_freelist = p; - d_n_items--; - if (d_max_items != 0) - d_cond.notify_one(); -} - -} /* namespace gruel */ diff --git a/gruel/src/lib/pmt_serialize.cc b/gruel/src/lib/pmt_serialize.cc deleted file mode 100644 index b7193e81..00000000 --- a/gruel/src/lib/pmt_serialize.cc +++ /dev/null @@ -1,357 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2007,2009 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, write to the Free Software Foundation, Inc., - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. - */ - -#ifdef HAVE_CONFIG_H -#include -#endif -#include -#include -#include "pmt_int.h" -#include "gruel/pmt_serial_tags.h" - -namespace gruel { - -static pmt_t parse_pair(std::streambuf &sb); - -// ---------------------------------------------------------------- -// output primitives -// ---------------------------------------------------------------- - -static bool -serialize_untagged_u8(unsigned int i, std::streambuf &sb) -{ - return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); -} - -// always writes big-endian -static bool -serialize_untagged_u16(unsigned int i, std::streambuf &sb) -{ - sb.sputc((i >> 8) & 0xff); - return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); -} - -// always writes big-endian -static bool -serialize_untagged_u32(unsigned int i, std::streambuf &sb) -{ - sb.sputc((i >> 24) & 0xff); - sb.sputc((i >> 16) & 0xff); - sb.sputc((i >> 8) & 0xff); - return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); -} - -#if 0 -// always writes big-endian -static bool -serialize_untagged_u64(uint64_t i, std::streambuf &sb) -{ - sb.sputc((i >> 56) & 0xff); - sb.sputc((i >> 48) & 0xff); - sb.sputc((i >> 40) & 0xff); - sb.sputc((i >> 32) & 0xff); - sb.sputc((i >> 24) & 0xff); - sb.sputc((i >> 16) & 0xff); - sb.sputc((i >> 8) & 0xff); - return sb.sputc((i >> 0) & 0xff) != std::streambuf::traits_type::eof(); -} -#endif - -// ---------------------------------------------------------------- -// input primitives -// ---------------------------------------------------------------- - - -// always reads big-endian -static bool -deserialize_untagged_u8(uint8_t *ip, std::streambuf &sb) -{ - std::streambuf::traits_type::int_type t; - int i; - - t = sb.sbumpc(); - i = t & 0xff; - - *ip = i; - return t != std::streambuf::traits_type::eof(); -} - -// always reads big-endian -static bool -deserialize_untagged_u16(uint16_t *ip, std::streambuf &sb) -{ - std::streambuf::traits_type::int_type t; - int i; - - t = sb.sbumpc(); - i = t & 0xff; - - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - - *ip = i; - return t != std::streambuf::traits_type::eof(); -} - -// always reads big-endian -static bool -deserialize_untagged_u32(uint32_t *ip, std::streambuf &sb) -{ - std::streambuf::traits_type::int_type t; - int i; - - t = sb.sbumpc(); - i = t & 0xff; - - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - - *ip = i; - return t != std::streambuf::traits_type::eof(); -} - -#if 0 -// always reads big-endian -static bool -deserialize_untagged_u64(uint64_t *ip, std::streambuf &sb) -{ - std::streambuf::traits_type::int_type t; - uint64_t i; - - t = sb.sbumpc(); - i = t & 0xff; - - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - t = sb.sbumpc(); - i = (i << 8) | (t & 0xff); - - *ip = i; - return t != std::streambuf::traits_type::eof(); -} -#endif - -/* - * Write portable byte-serial representation of \p obj to \p sb - * - * N.B., Circular structures cause infinite recursion. - */ -bool -pmt_serialize(pmt_t obj, std::streambuf &sb) -{ - bool ok = true; - - tail_recursion: - - if (pmt_is_bool(obj)){ - if (pmt_eq(obj, PMT_T)) - return serialize_untagged_u8(PST_TRUE, sb); - else - return serialize_untagged_u8(PST_FALSE, sb); - } - - if (pmt_is_null(obj)) - return serialize_untagged_u8(PST_NULL, sb); - - if (pmt_is_symbol(obj)){ - const std::string s = pmt_symbol_to_string(obj); - size_t len = s.size(); - ok = serialize_untagged_u8(PST_SYMBOL, sb); - ok &= serialize_untagged_u16(len, sb); - for (size_t i = 0; i < len; i++) - ok &= serialize_untagged_u8(s[i], sb); - return ok; - } - - if (pmt_is_pair(obj)){ - ok = serialize_untagged_u8(PST_PAIR, sb); - ok &= pmt_serialize(pmt_car(obj), sb); - if (!ok) - return false; - obj = pmt_cdr(obj); - goto tail_recursion; - } - - if (pmt_is_number(obj)){ - - 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)) - throw pmt_notimplemented("pmt_serialize (real)", obj); - - if (pmt_is_complex(obj)) - throw pmt_notimplemented("pmt_serialize (complex)", obj); - } - - if (pmt_is_vector(obj)) - throw pmt_notimplemented("pmt_serialize (vector)", obj); - - if (pmt_is_uniform_vector(obj)) - throw pmt_notimplemented("pmt_serialize (uniform-vector)", obj); - - if (pmt_is_dict(obj)) - throw pmt_notimplemented("pmt_serialize (dict)", obj); - - - throw pmt_notimplemented("pmt_serialize (?)", obj); -} - -/* - * Create obj from portable byte-serial representation - * - * Returns next obj from streambuf, or PMT_EOF at end of file. - * Throws exception on malformed input. - */ -pmt_t -pmt_deserialize(std::streambuf &sb) -{ - uint8_t tag; - //uint8_t u8; - uint16_t u16; - uint32_t u32; - //uint32_t u64; - static char tmpbuf[1024]; - - if (!deserialize_untagged_u8(&tag, sb)) - return PMT_EOF; - - switch (tag){ - case PST_TRUE: - return PMT_T; - - case PST_FALSE: - return PMT_F; - - case PST_NULL: - return PMT_NIL; - - case PST_SYMBOL: - if (!deserialize_untagged_u16(&u16, sb)) - goto error; - if (u16 > sizeof(tmpbuf)) - throw pmt_notimplemented("pmt_deserialize: very long symbol", - PMT_F); - if (sb.sgetn(tmpbuf, u16) != u16) - goto error; - return pmt_intern(std::string(tmpbuf, u16)); - - case PST_INT32: - if (!deserialize_untagged_u32(&u32, sb)) - goto error; - return pmt_from_long((int32_t) u32); - - case PST_PAIR: - return parse_pair(sb); - - case PST_DOUBLE: - case PST_COMPLEX: - case PST_VECTOR: - case PST_DICT: - case PST_UNIFORM_VECTOR: - case PST_COMMENT: - throw pmt_notimplemented("pmt_deserialize: tag value = ", - pmt_from_long(tag)); - - default: - throw pmt_exception("pmt_deserialize: malformed input stream, tag value = ", - pmt_from_long(tag)); - } - - error: - throw pmt_exception("pmt_deserialize: malformed input stream", PMT_F); -} - -/* - * This is a mostly non-recursive implementation that allows us to - * deserialize very long lists w/o exhausting the evaluation stack. - * - * On entry we've already eaten the PST_PAIR tag. - */ -pmt_t -parse_pair(std::streambuf &sb) -{ - uint8_t tag; - pmt_t val, expr, lastnptr, nptr; - - // - // Keep appending nodes until we get a non-PAIR cdr. - // - lastnptr = PMT_NIL; - while (1){ - expr = pmt_deserialize(sb); // read the car - - nptr = pmt_cons(expr, PMT_NIL); // build new cell - if (pmt_is_null(lastnptr)) - val = nptr; - else - pmt_set_cdr(lastnptr, nptr); - lastnptr = nptr; - - if (!deserialize_untagged_u8(&tag, sb)) // get tag of cdr - throw pmt_exception("pmt_deserialize: malformed input stream", PMT_F); - - if (tag == PST_PAIR) - continue; // keep on looping... - - if (tag == PST_NULL){ - expr = PMT_NIL; - break; - } - - // - // default: push tag back and use pmt_deserialize to get the cdr - // - sb.sungetc(); - expr = pmt_deserialize(sb); - break; - } - - // - // At this point, expr contains the value of the final cdr in the list. - // - pmt_set_cdr(lastnptr, expr); - return val; -} - -} /* namespace gruel */ diff --git a/gruel/src/lib/qa_pmt.cc b/gruel/src/lib/qa_pmt.cc deleted file mode 100644 index 250befaf..00000000 --- a/gruel/src/lib/qa_pmt.cc +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright 2006 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with GNU Radio; see the file COPYING. If not, write to - * the Free Software Foundation, Inc., 51 Franklin Street, - * Boston, MA 02110-1301, USA. - */ - -/* - * This class gathers together all the test cases for pmt into - * a single test suite. As you create new test cases, add them here. - */ - -#include -#include -#include - -CppUnit::TestSuite * -qa_pmt::suite () -{ - CppUnit::TestSuite *s = new CppUnit::TestSuite ("pmt"); - - s->addTest (qa_pmt_prims::suite ()); - s->addTest (qa_pmt_unv::suite ()); - - return s; -} diff --git a/gruel/src/lib/qa_pmt.h b/gruel/src/lib/qa_pmt.h deleted file mode 100644 index 43a6dbf6..00000000 --- a/gruel/src/lib/qa_pmt.h +++ /dev/null @@ -1,36 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with GNU Radio; see the file COPYING. If not, write to - * the Free Software Foundation, Inc., 51 Franklin Street, - * Boston, MA 02110-1301, USA. - */ - -#ifndef INCLUDED_QA_PMT_H -#define INCLUDED_QA_PMT_H - -#include - -//! collect all the tests for pmt - -class qa_pmt { - public: - //! return suite of tests for all of pmt - static CppUnit::TestSuite *suite (); -}; - -#endif /* INCLUDED_QA_PMT_H */ diff --git a/gruel/src/lib/qa_pmt_prims.cc b/gruel/src/lib/qa_pmt_prims.cc deleted file mode 100644 index ac93f806..00000000 --- a/gruel/src/lib/qa_pmt_prims.cc +++ /dev/null @@ -1,438 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006,2009 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with GNU Radio; see the file COPYING. If not, write to - * the Free Software Foundation, Inc., 51 Franklin Street, - * Boston, MA 02110-1301, USA. - */ - -#include -#include -#include -#include -#include - -using namespace gruel; - -void -qa_pmt_prims::test_symbols() -{ - CPPUNIT_ASSERT(!pmt_is_symbol(PMT_T)); - CPPUNIT_ASSERT(!pmt_is_symbol(PMT_F)); - CPPUNIT_ASSERT_THROW(pmt_symbol_to_string(PMT_F), pmt_wrong_type); - - pmt_t sym1 = pmt_string_to_symbol("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 = pmt_string_to_symbol("foo"); - pmt_t sym3 = pmt_string_to_symbol("test"); - CPPUNIT_ASSERT_EQUAL(sym1, sym3); - CPPUNIT_ASSERT(sym1 != sym2); - CPPUNIT_ASSERT(sym1 == sym3); - - static const int N = 2048; - std::vector v1(N); - std::vector v2(N); - - // generate a bunch of symbols - for (int i = 0; i < N; i++){ - char buf[100]; - snprintf(buf, sizeof(buf), "test-%d", i); - v1[i] = pmt_string_to_symbol(buf); - } - - // confirm that they are all unique - for (int i = 0; i < N; i++) - for (int j = i + 1; j < N; j++) - CPPUNIT_ASSERT(v1[i] != v1[j]); - - // generate the same symbols again - for (int i = 0; i < N; i++){ - char buf[100]; - snprintf(buf, sizeof(buf), "test-%d", i); - v2[i] = pmt_string_to_symbol(buf); - } - - // confirm that we get the same ones back - for (int i = 0; i < N; i++) - CPPUNIT_ASSERT(v1[i] == v2[i]); -} - -void -qa_pmt_prims::test_booleans() -{ - pmt_t sym = pmt_string_to_symbol("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); -} - -void -qa_pmt_prims::test_integers() -{ - pmt_t p1 = pmt_from_long(1); - pmt_t m1 = pmt_from_long(-1); - CPPUNIT_ASSERT(!pmt_is_integer(PMT_T)); - CPPUNIT_ASSERT(pmt_is_integer(p1)); - CPPUNIT_ASSERT(pmt_is_integer(m1)); - CPPUNIT_ASSERT_THROW(pmt_to_long(PMT_T), pmt_wrong_type); - CPPUNIT_ASSERT_EQUAL(-1L, pmt_to_long(m1)); - CPPUNIT_ASSERT_EQUAL(1L, pmt_to_long(p1)); -} - -void -qa_pmt_prims::test_reals() -{ - pmt_t p1 = pmt_from_double(1); - pmt_t m1 = pmt_from_double(-1); - CPPUNIT_ASSERT(!pmt_is_real(PMT_T)); - CPPUNIT_ASSERT(pmt_is_real(p1)); - CPPUNIT_ASSERT(pmt_is_real(m1)); - CPPUNIT_ASSERT_THROW(pmt_to_double(PMT_T), pmt_wrong_type); - CPPUNIT_ASSERT_EQUAL(-1.0, pmt_to_double(m1)); - CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(p1)); - CPPUNIT_ASSERT_EQUAL(1.0, pmt_to_double(pmt_from_long(1))); -} - -void -qa_pmt_prims::test_complexes() -{ - pmt_t p1 = pmt_make_rectangular(2, -3); - pmt_t m1 = pmt_make_rectangular(-3, 2); - CPPUNIT_ASSERT(!pmt_is_complex(PMT_T)); - CPPUNIT_ASSERT(pmt_is_complex(p1)); - CPPUNIT_ASSERT(pmt_is_complex(m1)); - CPPUNIT_ASSERT_THROW(pmt_to_complex(PMT_T), pmt_wrong_type); - CPPUNIT_ASSERT_EQUAL(std::complex(2, -3), pmt_to_complex(p1)); - CPPUNIT_ASSERT_EQUAL(std::complex(-3, 2), pmt_to_complex(m1)); - CPPUNIT_ASSERT_EQUAL(std::complex(1.0, 0), pmt_to_complex(pmt_from_long(1))); - CPPUNIT_ASSERT_EQUAL(std::complex(1.0, 0), pmt_to_complex(pmt_from_double(1.0))); -} - -void -qa_pmt_prims::test_pairs() -{ - CPPUNIT_ASSERT(pmt_is_null(PMT_NIL)); - CPPUNIT_ASSERT(!pmt_is_pair(PMT_NIL)); - pmt_t s1 = pmt_string_to_symbol("s1"); - pmt_t s2 = pmt_string_to_symbol("s2"); - pmt_t s3 = pmt_string_to_symbol("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); -} - -void -qa_pmt_prims::test_vectors() -{ - static const size_t N = 3; - pmt_t v1 = pmt_make_vector(N, PMT_NIL); - CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1)); - pmt_t s0 = pmt_string_to_symbol("s0"); - pmt_t s1 = pmt_string_to_symbol("s1"); - pmt_t s2 = pmt_string_to_symbol("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); - for (size_t i = 0; i < N; i++) - CPPUNIT_ASSERT_EQUAL(s0, pmt_vector_ref(v1, i)); -} - -void -qa_pmt_prims::test_equivalence() -{ - pmt_t s0 = pmt_string_to_symbol("s0"); - pmt_t s1 = pmt_string_to_symbol("s1"); - pmt_t s2 = pmt_string_to_symbol("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)); -} - -void -qa_pmt_prims::test_misc() -{ - pmt_t k0 = pmt_string_to_symbol("k0"); - pmt_t k1 = pmt_string_to_symbol("k1"); - pmt_t k2 = pmt_string_to_symbol("k2"); - pmt_t k3 = pmt_string_to_symbol("k3"); - pmt_t v0 = pmt_string_to_symbol("v0"); - pmt_t v1 = pmt_string_to_symbol("v1"); - pmt_t v2 = pmt_string_to_symbol("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))); -} - -void -qa_pmt_prims::test_dict() -{ - pmt_t dict = pmt_make_dict(); - CPPUNIT_ASSERT(pmt_is_dict(dict)); - - pmt_t k0 = pmt_string_to_symbol("k0"); - pmt_t k1 = pmt_string_to_symbol("k1"); - pmt_t k2 = pmt_string_to_symbol("k2"); - pmt_t k3 = pmt_string_to_symbol("k3"); - pmt_t v0 = pmt_string_to_symbol("v0"); - pmt_t v1 = pmt_string_to_symbol("v1"); - pmt_t v2 = pmt_string_to_symbol("v2"); - pmt_t v3 = pmt_string_to_symbol("v3"); - pmt_t not_found = pmt_cons(PMT_NIL, PMT_NIL); - - CPPUNIT_ASSERT(!pmt_dict_has_key(dict, k0)); - pmt_dict_set(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)); - pmt_dict_set(dict, k1, v1); - pmt_dict_set(dict, k2, v2); - CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v1)); - pmt_dict_set(dict, k1, v3); - CPPUNIT_ASSERT(pmt_eqv(pmt_dict_ref(dict, k1, not_found), v3)); - - pmt_t keys = pmt_cons(k2, pmt_cons(k1, pmt_cons(k0, PMT_NIL))); - pmt_t vals = pmt_cons(v2, pmt_cons(v3, pmt_cons(v0, PMT_NIL))); - CPPUNIT_ASSERT(pmt_equal(keys, pmt_dict_keys(dict))); - CPPUNIT_ASSERT(pmt_equal(vals, pmt_dict_values(dict))); -} - -void -qa_pmt_prims::test_io() -{ - pmt_t k0 = pmt_string_to_symbol("k0"); - pmt_t k1 = pmt_string_to_symbol("k1"); - pmt_t k2 = pmt_string_to_symbol("k2"); - pmt_t k3 = pmt_string_to_symbol("k3"); - - CPPUNIT_ASSERT_EQUAL(std::string("k0"), pmt_write_string(k0)); -} - -void -qa_pmt_prims::test_lists() -{ - pmt_t s0 = pmt_intern("s0"); - pmt_t s1 = pmt_intern("s1"); - pmt_t s2 = pmt_intern("s2"); - pmt_t s3 = pmt_intern("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)); -} - -// ------------------------------------------------------------------------ - -// class foo is used in test_any below. -// It can't be declared in the scope of test_any because of template -// namespace problems. - -class foo { -public: - double d_double; - int d_int; - foo(double d=0, int i=0) : d_double(d), d_int(i) {} -}; - -bool operator==(const foo &a, const foo &b) -{ - return a.d_double == b.d_double && a.d_int == b.d_int; -} - -std::ostream& operator<<(std::ostream &os, const foo obj) -{ - os << ""; - return os; -} - -void -qa_pmt_prims::test_any() -{ - boost::any a0; - boost::any a1; - boost::any a2; - - a0 = std::string("Hello!"); - a1 = 42; - a2 = foo(3.250, 21); - - pmt_t p0 = pmt_make_any(a0); - pmt_t p1 = pmt_make_any(a1); - pmt_t p2 = pmt_make_any(a2); - - CPPUNIT_ASSERT_EQUAL(std::string("Hello!"), - boost::any_cast(pmt_any_ref(p0))); - - CPPUNIT_ASSERT_EQUAL(42, - boost::any_cast(pmt_any_ref(p1))); - - CPPUNIT_ASSERT_EQUAL(foo(3.250, 21), - boost::any_cast(pmt_any_ref(p2))); -} - -// ------------------------------------------------------------------------ - -void -qa_pmt_prims::test_serialize() -{ - std::stringbuf sb; // fake channel - pmt_t a = pmt_intern("a"); - pmt_t b = pmt_intern("b"); - pmt_t c = pmt_intern("c"); - - sb.str(""); // reset channel to empty - - // write stuff to channel - - pmt_serialize(PMT_NIL, sb); - pmt_serialize(pmt_intern("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); - - // read it back - - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), PMT_NIL)); - CPPUNIT_ASSERT(pmt_equal(pmt_deserialize(sb), pmt_intern("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 - - - // FIXME add tests for real, complex, vector, uniform-vector, dict - // FIXME add tests for malformed input too. - -} - -void -qa_pmt_prims::test_sets() -{ - pmt_t s1 = pmt_intern("s1"); - pmt_t s2 = pmt_intern("s2"); - pmt_t s3 = pmt_intern("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)); -} diff --git a/gruel/src/lib/qa_pmt_prims.h b/gruel/src/lib/qa_pmt_prims.h deleted file mode 100644 index effb3a09..00000000 --- a/gruel/src/lib/qa_pmt_prims.h +++ /dev/null @@ -1,67 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with GNU Radio; see the file COPYING. If not, write to - * the Free Software Foundation, Inc., 51 Franklin Street, - * Boston, MA 02110-1301, USA. - */ -#ifndef INCLUDED_QA_PMT_PRIMS_H -#define INCLUDED_QA_PMT_PRIMS_H - -#include -#include - -class qa_pmt_prims : public CppUnit::TestCase { - - CPPUNIT_TEST_SUITE(qa_pmt_prims); - CPPUNIT_TEST(test_symbols); - CPPUNIT_TEST(test_booleans); - CPPUNIT_TEST(test_integers); - CPPUNIT_TEST(test_reals); - CPPUNIT_TEST(test_complexes); - CPPUNIT_TEST(test_pairs); - CPPUNIT_TEST(test_vectors); - CPPUNIT_TEST(test_equivalence); - CPPUNIT_TEST(test_misc); - CPPUNIT_TEST(test_dict); - CPPUNIT_TEST(test_any); - CPPUNIT_TEST(test_io); - CPPUNIT_TEST(test_lists); - CPPUNIT_TEST(test_serialize); - CPPUNIT_TEST(test_sets); - CPPUNIT_TEST_SUITE_END(); - - private: - void test_symbols(); - void test_booleans(); - void test_integers(); - void test_reals(); - void test_complexes(); - void test_pairs(); - void test_vectors(); - void test_equivalence(); - void test_misc(); - void test_dict(); - void test_any(); - void test_io(); - void test_lists(); - void test_serialize(); - void test_sets(); -}; - -#endif /* INCLUDED_QA_PMT_PRIMS_H */ - diff --git a/gruel/src/lib/test_pmt.cc b/gruel/src/lib/test_pmt.cc deleted file mode 100644 index 034785f4..00000000 --- a/gruel/src/lib/test_pmt.cc +++ /dev/null @@ -1,37 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006 Free Software Foundation, Inc. - * - * This file is part of GNU Radio - * - * GNU Radio is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3, or (at your option) - * any later version. - * - * GNU Radio is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with GNU Radio; see the file COPYING. If not, write to - * the Free Software Foundation, Inc., 51 Franklin Street, - * Boston, MA 02110-1301, USA. - */ - -#include -#include - -int -main(int argc, char **argv) -{ - - CppUnit::TextTestRunner runner; - - runner.addTest(qa_pmt::suite ()); - - bool was_successful = runner.run("", false); - - return was_successful ? 0 : 1; -} diff --git a/gruel/src/lib/unv_qa_template.cc.t b/gruel/src/lib/unv_qa_template.cc.t deleted file mode 100644 index 1e2c8e8e..00000000 --- a/gruel/src/lib/unv_qa_template.cc.t +++ /dev/null @@ -1,35 +0,0 @@ -void -qa_pmt_unv::test_@TAG@vector() -{ - static const size_t N = 3; - pmt_t v1 = pmt_make_@TAG@vector(N, 0); - CPPUNIT_ASSERT_EQUAL(N, pmt_length(v1)); - @TYPE@ s0 = @TYPE@(10); - @TYPE@ s1 = @TYPE@(20); - @TYPE@ s2 = @TYPE@(30); - - pmt_@TAG@vector_set(v1, 0, s0); - pmt_@TAG@vector_set(v1, 1, s1); - pmt_@TAG@vector_set(v1, 2, s2); - - 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); - - size_t len; - const @TYPE@ *rd = pmt_@TAG@vector_elements(v1, len); - CPPUNIT_ASSERT_EQUAL(len, N); - CPPUNIT_ASSERT_EQUAL(s0, rd[0]); - CPPUNIT_ASSERT_EQUAL(s1, rd[1]); - CPPUNIT_ASSERT_EQUAL(s2, rd[2]); - - @TYPE@ *wr = pmt_@TAG@vector_writable_elements(v1, len); - CPPUNIT_ASSERT_EQUAL(len, N); - wr[0] = @TYPE@(0); - CPPUNIT_ASSERT_EQUAL(@TYPE@(0), wr[0]); - CPPUNIT_ASSERT_EQUAL(s1, wr[1]); - CPPUNIT_ASSERT_EQUAL(s2, wr[2]); -} diff --git a/gruel/src/lib/unv_template.cc.t b/gruel/src/lib/unv_template.cc.t deleted file mode 100644 index b19e32d2..00000000 --- a/gruel/src/lib/unv_template.cc.t +++ /dev/null @@ -1,122 +0,0 @@ -//////////////////////////////////////////////////////////////////////////// -// pmt_@TAG@vector -//////////////////////////////////////////////////////////////////////////// - -namespace gruel { - -static pmt_@TAG@vector * -_@TAG@vector(pmt_t x) -{ - return dynamic_cast(x.get()); -} - - -pmt_@TAG@vector::pmt_@TAG@vector(size_t k, @TYPE@ fill) - : d_v(k) -{ - for (size_t i = 0; i < k; i++) - d_v[i] = fill; -} - -pmt_@TAG@vector::pmt_@TAG@vector(size_t k, const @TYPE@ *data) - : d_v(k) -{ - for (size_t i = 0; i < k; i++) - d_v[i] = data[i]; -} - -@TYPE@ -pmt_@TAG@vector::ref(size_t k) const -{ - if (k >= length()) - throw pmt_out_of_range("pmt_@TAG@vector_ref", pmt_from_long(k)); - return d_v[k]; -} - -void -pmt_@TAG@vector::set(size_t k, @TYPE@ x) -{ - if (k >= length()) - throw pmt_out_of_range("pmt_@TAG@vector_set", pmt_from_long(k)); - d_v[k] = x; -} - -const @TYPE@ * -pmt_@TAG@vector::elements(size_t &len) -{ - len = length(); - return &d_v[0]; -} - -@TYPE@ * -pmt_@TAG@vector::writable_elements(size_t &len) -{ - len = length(); - return &d_v[0]; -} - -const void* -pmt_@TAG@vector::uniform_elements(size_t &len) -{ - len = length() * sizeof(@TYPE@); - return &d_v[0]; -} - -void* -pmt_@TAG@vector::uniform_writable_elements(size_t &len) -{ - len = length() * sizeof(@TYPE@); - return &d_v[0]; -} - -bool -pmt_is_@TAG@vector(pmt_t obj) -{ - return obj->is_@TAG@vector(); -} - -pmt_t -pmt_make_@TAG@vector(size_t k, @TYPE@ fill) -{ - return pmt_t(new pmt_@TAG@vector(k, fill)); -} - -pmt_t -pmt_init_@TAG@vector(size_t k, const @TYPE@ *data) -{ - return pmt_t(new pmt_@TAG@vector(k, data)); -} - -@TYPE@ -pmt_@TAG@vector_ref(pmt_t vector, size_t k) -{ - if (!vector->is_@TAG@vector()) - throw pmt_wrong_type("pmt_@TAG@vector_ref", vector); - return _@TAG@vector(vector)->ref(k); -} - -void -pmt_@TAG@vector_set(pmt_t vector, size_t k, @TYPE@ obj) -{ - if (!vector->is_@TAG@vector()) - throw pmt_wrong_type("pmt_@TAG@vector_set", vector); - _@TAG@vector(vector)->set(k, obj); -} - -const @TYPE@ * -pmt_@TAG@vector_elements(pmt_t vector, size_t &len) -{ - if (!vector->is_@TAG@vector()) - throw pmt_wrong_type("pmt_@TAG@vector_elements", vector); - return _@TAG@vector(vector)->elements(len); -} - -@TYPE@ * -pmt_@TAG@vector_writable_elements(pmt_t vector, size_t &len) -{ - if (!vector->is_@TAG@vector()) - throw pmt_wrong_type("pmt_@TAG@vector_writable_elements", vector); - return _@TAG@vector(vector)->writable_elements(len); -} - -} /* namespace gruel */ diff --git a/gruel/src/lib/unv_template.h.t b/gruel/src/lib/unv_template.h.t deleted file mode 100644 index 83ba0be0..00000000 --- a/gruel/src/lib/unv_template.h.t +++ /dev/null @@ -1,23 +0,0 @@ - -//////////////////////////////////////////////////////////////////////////// -// pmt_@TAG@vector -//////////////////////////////////////////////////////////////////////////// - -class pmt_@TAG@vector : public pmt_uniform_vector -{ - std::vector< @TYPE@ > d_v; - -public: - pmt_@TAG@vector(size_t k, @TYPE@ fill); - pmt_@TAG@vector(size_t k, const @TYPE@ *data); - // ~pmt_@TAG@vector(); - - bool is_@TAG@vector() const { return true; } - size_t length() const { return d_v.size(); } - @TYPE@ ref(size_t k) const; - void set(size_t k, @TYPE@ x); - const @TYPE@ *elements(size_t &len); - @TYPE@ *writable_elements(size_t &len); - const void *uniform_elements(size_t &len); - void *uniform_writable_elements(size_t &len); -}; diff --git a/mblock/src/include/mblock/class_registry.h b/mblock/src/include/mblock/class_registry.h index 8528b887..e4341f7d 100644 --- a/mblock/src/include/mblock/class_registry.h +++ b/mblock/src/include/mblock/class_registry.h @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2007,2008 Free Software Foundation, Inc. + * Copyright 2007,2008,2009 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -26,7 +26,7 @@ //! conceptually, pointer to constructor typedef mb_mblock_sptr (*mb_mblock_maker_t)(mb_runtime *runtime, const std::string &instance_name, - gruel::pmt_t user_arg); + pmt::pmt_t user_arg); /* * \brief Maintain mapping between mblock class_name and factory (maker) @@ -40,7 +40,7 @@ public: template mb_mblock_sptr mb_mblock_maker(mb_runtime *runtime, const std::string &instance_name, - gruel::pmt_t user_arg) + pmt::pmt_t user_arg) { return mb_mblock_sptr(new mblock(runtime, instance_name, user_arg)); } diff --git a/mblock/src/include/mblock/mblock.h b/mblock/src/include/mblock/mblock.h index 92b0b328..2f036e41 100644 --- a/mblock/src/include/mblock/mblock.h +++ b/mblock/src/include/mblock/mblock.h @@ -72,7 +72,7 @@ protected: * \param user_arg argument passed by user to constructor * (ignored by the mb_mblock base class) */ - mb_mblock(mb_runtime *runtime, const std::string &instance_name, gruel::pmt_t user_arg); + mb_mblock(mb_runtime *runtime, const std::string &instance_name, pmt::pmt_t user_arg); public: /*! @@ -128,7 +128,7 @@ protected: void define_component(const std::string &component_name, const std::string &class_name, - gruel::pmt_t user_arg = gruel::PMT_NIL); + pmt::pmt_t user_arg = pmt::PMT_NIL); /*! * \brief connect endpoint_1 to endpoint_2 @@ -217,7 +217,7 @@ protected: * * runtime->run(...) returns when all blocks have called exit. */ - void shutdown_all(gruel::pmt_t result); + void shutdown_all(pmt::pmt_t result); /*! * \brief main event dispatching loop @@ -259,8 +259,8 @@ public: * * To cancel a pending timeout, call cancel_timeout. */ - gruel::pmt_t - schedule_one_shot_timeout(const mb_time &abs_time, gruel::pmt_t user_data); + pmt::pmt_t + schedule_one_shot_timeout(const mb_time &abs_time, pmt::pmt_t user_data); /*! * \brief Schedule a periodic timeout. @@ -281,10 +281,10 @@ public: * * To cancel a pending timeout, call cancel_timeout. */ - gruel::pmt_t + pmt::pmt_t schedule_periodic_timeout(const mb_time &first_abs_time, const mb_time &delta_time, - gruel::pmt_t user_data); + pmt::pmt_t user_data); /*! * \brief Attempt to cancel a pending timeout. @@ -296,7 +296,7 @@ public: * * \param handle returned from schedule_one_shot_timeout or schedule_periodic_timeout. */ - void cancel_timeout(gruel::pmt_t handle); + void cancel_timeout(pmt::pmt_t handle); /*! * \brief Perform a pre-order depth-first traversal of the hierarchy. diff --git a/mblock/src/include/mblock/message.h b/mblock/src/include/mblock/message.h index 443684fd..4051d0c8 100644 --- a/mblock/src/include/mblock/message.h +++ b/mblock/src/include/mblock/message.h @@ -38,37 +38,37 @@ typedef boost::shared_ptr mb_message_sptr; * \param priority urgency */ mb_message_sptr -mb_make_message(gruel::pmt_t signal, - gruel::pmt_t data = gruel::PMT_NIL, - gruel::pmt_t metadata = gruel::PMT_NIL, +mb_make_message(pmt::pmt_t signal, + pmt::pmt_t data = pmt::PMT_NIL, + pmt::pmt_t metadata = pmt::PMT_NIL, mb_pri_t priority = MB_PRI_DEFAULT); class mb_message { mb_message_sptr d_next; // link field for msg queue - gruel::pmt_t d_signal; - gruel::pmt_t d_data; - gruel::pmt_t d_metadata; + pmt::pmt_t d_signal; + pmt::pmt_t d_data; + pmt::pmt_t d_metadata; mb_pri_t d_priority; - gruel::pmt_t d_port_id; // name of port msg was rcvd on (symbol) + pmt::pmt_t d_port_id; // name of port msg was rcvd on (symbol) friend class mb_msg_queue; friend mb_message_sptr - mb_make_message(gruel::pmt_t signal, gruel::pmt_t data, gruel::pmt_t metadata, mb_pri_t priority); + mb_make_message(pmt::pmt_t signal, pmt::pmt_t data, pmt::pmt_t metadata, mb_pri_t priority); // private constructor - mb_message(gruel::pmt_t signal, gruel::pmt_t data, gruel::pmt_t metadata, mb_pri_t priority); + mb_message(pmt::pmt_t signal, pmt::pmt_t data, pmt::pmt_t metadata, mb_pri_t priority); public: ~mb_message(); - gruel::pmt_t signal() const { return d_signal; } - gruel::pmt_t data() const { return d_data; } - gruel::pmt_t metadata() const { return d_metadata; } + pmt::pmt_t signal() const { return d_signal; } + pmt::pmt_t data() const { return d_data; } + pmt::pmt_t metadata() const { return d_metadata; } mb_pri_t priority() const { return d_priority; } - gruel::pmt_t port_id() const { return d_port_id; } + pmt::pmt_t port_id() const { return d_port_id; } - void set_port_id(gruel::pmt_t port_id){ d_port_id = port_id; } + void set_port_id(pmt::pmt_t port_id){ d_port_id = port_id; } #if (MB_MESSAGE_LOCAL_ALLOCATOR) void *operator new(size_t); diff --git a/mblock/src/include/mblock/msg_accepter.h b/mblock/src/include/mblock/msg_accepter.h index 7ce1705a..7dc1e50c 100644 --- a/mblock/src/include/mblock/msg_accepter.h +++ b/mblock/src/include/mblock/msg_accepter.h @@ -42,7 +42,7 @@ public: mb_msg_accepter(){}; virtual ~mb_msg_accepter(); - virtual void operator()(gruel::pmt_t signal, gruel::pmt_t data, gruel::pmt_t metadata, mb_pri_t priority) = 0; + virtual void operator()(pmt::pmt_t signal, pmt::pmt_t data, pmt::pmt_t metadata, mb_pri_t priority) = 0; }; #endif /* INCLUDED_MB_MSG_ACCEPTER_H */ diff --git a/mblock/src/include/mblock/port.h b/mblock/src/include/mblock/port.h index 02d81d67..1664765d 100644 --- a/mblock/src/include/mblock/port.h +++ b/mblock/src/include/mblock/port.h @@ -40,8 +40,8 @@ public: private: std::string d_port_name; - gruel::pmt_t d_port_symbol; // the port_name as a gruel::pmt symbol - gruel::pmt_t d_protocol_class; + pmt::pmt_t d_port_symbol; // the port_name as a pmt::pmt symbol + pmt::pmt_t d_protocol_class; bool d_conjugated; port_type_t d_port_type; @@ -59,13 +59,13 @@ protected: public: std::string port_name() const { return d_port_name; } - gruel::pmt_t port_symbol() const { return d_port_symbol; } - gruel::pmt_t protocol_class() const { return d_protocol_class; } + pmt::pmt_t port_symbol() const { return d_port_symbol; } + pmt::pmt_t protocol_class() const { return d_protocol_class; } bool conjugated() const { return d_conjugated; } port_type_t port_type() const { return d_port_type; } - gruel::pmt_t incoming_message_set() const; - gruel::pmt_t outgoing_message_set() const; + pmt::pmt_t incoming_message_set() const; + pmt::pmt_t outgoing_message_set() const; virtual ~mb_port(); @@ -78,9 +78,9 @@ public: * \param priority the urgency at which the message is sent */ virtual void - send(gruel::pmt_t signal, - gruel::pmt_t data = gruel::PMT_F, - gruel::pmt_t metadata = gruel::PMT_F, + send(pmt::pmt_t signal, + pmt::pmt_t data = pmt::PMT_F, + pmt::pmt_t metadata = pmt::PMT_F, mb_pri_t priority = MB_PRI_DEFAULT) = 0; /* diff --git a/mblock/src/include/mblock/protocol_class.h b/mblock/src/include/mblock/protocol_class.h index 4267a912..a01e68d8 100644 --- a/mblock/src/include/mblock/protocol_class.h +++ b/mblock/src/include/mblock/protocol_class.h @@ -30,14 +30,14 @@ * \param incoming incoming message set (list of symbols) * \param outgoing outgoing message set (list of symbols) */ -gruel::pmt_t mb_make_protocol_class(gruel::pmt_t name, gruel::pmt_t incoming, gruel::pmt_t outgoing); +pmt::pmt_t mb_make_protocol_class(pmt::pmt_t name, pmt::pmt_t incoming, pmt::pmt_t outgoing); // Accessors -gruel::pmt_t mb_protocol_class_name(gruel::pmt_t pc); //< return name of protocol class -gruel::pmt_t mb_protocol_class_incoming(gruel::pmt_t pc); //< return incoming message set -gruel::pmt_t mb_protocol_class_outgoing(gruel::pmt_t pc); //< return outgoing message set +pmt::pmt_t mb_protocol_class_name(pmt::pmt_t pc); //< return name of protocol class +pmt::pmt_t mb_protocol_class_incoming(pmt::pmt_t pc); //< return incoming message set +pmt::pmt_t mb_protocol_class_outgoing(pmt::pmt_t pc); //< return outgoing message set -gruel::pmt_t mb_protocol_class_lookup(gruel::pmt_t name); //< lookup an existing protocol class by name +pmt::pmt_t mb_protocol_class_lookup(pmt::pmt_t name); //< lookup an existing protocol class by name /*! diff --git a/mblock/src/include/mblock/runtime.h b/mblock/src/include/mblock/runtime.h index 69f49a40..9afc38b7 100644 --- a/mblock/src/include/mblock/runtime.h +++ b/mblock/src/include/mblock/runtime.h @@ -59,8 +59,8 @@ public: */ virtual bool run(const std::string &instance_name, const std::string &class_name, - gruel::pmt_t user_arg, - gruel::pmt_t *result = 0) = 0; + pmt::pmt_t user_arg, + pmt::pmt_t *result = 0) = 0; // QA only... mb_mblock_sptr top() { return d_top; } diff --git a/mblock/src/lib/benchmark_send.cc b/mblock/src/lib/benchmark_send.cc index 7055e785..a02b37c0 100644 --- a/mblock/src/lib/benchmark_send.cc +++ b/mblock/src/lib/benchmark_send.cc @@ -22,7 +22,7 @@ #include #include -using namespace gruel; +using namespace pmt; int main(int argc, char **argv) diff --git a/mblock/src/lib/mb_endpoint.cc b/mblock/src/lib/mb_endpoint.cc index 883ab360..721c66b8 100644 --- a/mblock/src/lib/mb_endpoint.cc +++ b/mblock/src/lib/mb_endpoint.cc @@ -24,13 +24,15 @@ #endif #include +using namespace pmt; + bool mb_endpoint::inside_of_relay_port_p() const { return d_port->port_type() == mb_port::RELAY && d_component_name == "self"; } -gruel::pmt_t +pmt_t mb_endpoint::incoming_message_set() const { if (inside_of_relay_port_p()) // swap incoming and outgoing @@ -39,7 +41,7 @@ mb_endpoint::incoming_message_set() const return port()->incoming_message_set(); } -gruel::pmt_t +pmt_t mb_endpoint::outgoing_message_set() const { if (inside_of_relay_port_p()) // swap incoming and outgoing diff --git a/mblock/src/lib/mb_endpoint.h b/mblock/src/lib/mb_endpoint.h index 96ff0de4..c4d8b611 100644 --- a/mblock/src/lib/mb_endpoint.h +++ b/mblock/src/lib/mb_endpoint.h @@ -51,8 +51,8 @@ public: //! Does this endpoint represent the inside of a relay port bool inside_of_relay_port_p() const; - gruel::pmt_t incoming_message_set() const; - gruel::pmt_t outgoing_message_set() const; + pmt::pmt_t incoming_message_set() const; + pmt::pmt_t outgoing_message_set() const; }; #endif /* INCLUDED_MB_ENDPOINT_H */ diff --git a/mblock/src/lib/mb_mblock.cc b/mblock/src/lib/mb_mblock.cc index 77216ccb..2e77dc4a 100644 --- a/mblock/src/lib/mb_mblock.cc +++ b/mblock/src/lib/mb_mblock.cc @@ -29,9 +29,10 @@ #include #include +using namespace pmt; -static gruel::pmt_t s_sys_port = gruel::pmt_intern("%sys-port"); -static gruel::pmt_t s_halt = gruel::pmt_intern("%halt"); +static pmt_t s_sys_port = pmt_intern("%sys-port"); +static pmt_t s_halt = pmt_intern("%halt"); mb_visitor::~mb_visitor() { @@ -41,7 +42,7 @@ mb_visitor::~mb_visitor() mb_mblock::mb_mblock(mb_runtime *runtime, const std::string &instance_name, - gruel::pmt_t user_arg) + pmt_t user_arg) : d_impl(mb_mblock_impl_sptr( new mb_mblock_impl(dynamic_cast(runtime), this, instance_name))) @@ -82,7 +83,7 @@ mb_mblock::main_loop() handle_message(msg); } } - catch (gruel::pmt_exception e){ + catch (pmt_exception e){ std::cerr << "\nmb_mblock::main_loop: ignored pmt_exception: " << e.what() << "\nin mblock instance \"" << instance_name() @@ -112,7 +113,7 @@ mb_mblock::define_port(const std::string &port_name_string, void mb_mblock::define_component(const std::string &component_name, const std::string &class_name, - gruel::pmt_t user_arg) + pmt_t user_arg) { d_impl->define_component(component_name, class_name, user_arg); @@ -196,23 +197,23 @@ mb_mblock::exit() } void -mb_mblock::shutdown_all(gruel::pmt_t result) +mb_mblock::shutdown_all(pmt_t result) { d_impl->runtime()->request_shutdown(result); } -gruel::pmt_t -mb_mblock::schedule_one_shot_timeout(const mb_time &abs_time, gruel::pmt_t user_data) +pmt_t +mb_mblock::schedule_one_shot_timeout(const mb_time &abs_time, pmt_t user_data) { mb_msg_accepter_sptr accepter = impl()->make_accepter(s_sys_port); return d_impl->runtime()->schedule_one_shot_timeout(abs_time, user_data, accepter); } -gruel::pmt_t +pmt_t mb_mblock::schedule_periodic_timeout(const mb_time &first_abs_time, const mb_time &delta_time, - gruel::pmt_t user_data) + pmt_t user_data) { mb_msg_accepter_sptr accepter = impl()->make_accepter(s_sys_port); return d_impl->runtime()->schedule_periodic_timeout(first_abs_time, @@ -222,7 +223,7 @@ mb_mblock::schedule_periodic_timeout(const mb_time &first_abs_time, } void -mb_mblock::cancel_timeout(gruel::pmt_t handle) +mb_mblock::cancel_timeout(pmt_t handle) { d_impl->runtime()->cancel_timeout(handle); } diff --git a/mblock/src/lib/mb_mblock_impl.cc b/mblock/src/lib/mb_mblock_impl.cc index b57ac5d0..8a1784f4 100644 --- a/mblock/src/lib/mb_mblock_impl.cc +++ b/mblock/src/lib/mb_mblock_impl.cc @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2006,2008 Free Software Foundation, Inc. + * Copyright 2006,2008,2009 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -33,8 +33,9 @@ #include #include +using namespace pmt; -static gruel::pmt_t s_self = gruel::pmt_intern("self"); +static pmt_t s_self = pmt_intern("self"); //////////////////////////////////////////////////////////////////////// @@ -87,7 +88,7 @@ mb_mblock_impl::define_port(const std::string &port_name, void mb_mblock_impl::define_component(const std::string &name, const std::string &class_name, - gruel::pmt_t user_arg) + pmt_t user_arg) { { mbi_runtime_lock l(this); @@ -226,11 +227,11 @@ bool mb_mblock_impl::endpoints_are_compatible(const mb_endpoint &ep0, const mb_endpoint &ep1) { - gruel::pmt_t p0_outgoing = ep0.outgoing_message_set(); - gruel::pmt_t p0_incoming = ep0.incoming_message_set(); + pmt_t p0_outgoing = ep0.outgoing_message_set(); + pmt_t p0_incoming = ep0.incoming_message_set(); - gruel::pmt_t p1_outgoing = ep1.outgoing_message_set(); - gruel::pmt_t p1_incoming = ep1.incoming_message_set(); + pmt_t p1_outgoing = ep1.outgoing_message_set(); + pmt_t p1_incoming = ep1.incoming_message_set(); return (pmt_subsetp(p0_outgoing, p1_incoming) && pmt_subsetp(p1_outgoing, p0_incoming)); @@ -251,7 +252,7 @@ mb_mblock_impl::walk_tree(mb_visitor *visitor) } mb_msg_accepter_sptr -mb_mblock_impl::make_accepter(gruel::pmt_t port_name) +mb_mblock_impl::make_accepter(pmt_t port_name) { // FIXME this should probably use some kind of configurable factory mb_msg_accepter *ma = diff --git a/mblock/src/lib/mb_mblock_impl.h b/mblock/src/lib/mb_mblock_impl.h index fa982cba..f460ecc5 100644 --- a/mblock/src/lib/mb_mblock_impl.h +++ b/mblock/src/lib/mb_mblock_impl.h @@ -87,7 +87,7 @@ public: void define_component(const std::string &component_name, const std::string &class_name, - gruel::pmt_t user_arg); + pmt::pmt_t user_arg); /*! * \brief connect endpoint_1 to endpoint_2 @@ -148,7 +148,7 @@ public: walk_tree(mb_visitor *visitor); mb_msg_accepter_sptr - make_accepter(gruel::pmt_t port_name); + make_accepter(pmt::pmt_t port_name); mb_msg_queue & msgq() { return d_msgq; } @@ -196,9 +196,9 @@ public: * Our implementation methods */ private: - //bool port_is_defined(gruel::pmt_t name); + //bool port_is_defined(pmt::pmt_t name); bool port_is_defined(const std::string &name); - //bool comp_is_defined(gruel::pmt_t name); + //bool comp_is_defined(pmt::pmt_t name); bool comp_is_defined(const std::string &name); mb_endpoint diff --git a/mblock/src/lib/mb_message.cc b/mblock/src/lib/mb_message.cc index 729ff078..4daa3407 100644 --- a/mblock/src/lib/mb_message.cc +++ b/mblock/src/lib/mb_message.cc @@ -26,6 +26,8 @@ #include #include +using namespace pmt; + static const int CACHE_LINE_SIZE = 64; // good guess static const int MAX_MESSAGES = 1024; // KLUDGE max number of messages in sys // 0 -> no limit @@ -54,14 +56,14 @@ mb_message::operator delete(void *p, size_t size) mb_message_sptr -mb_make_message(gruel::pmt_t signal, gruel::pmt_t data, gruel::pmt_t metadata, mb_pri_t priority) +mb_make_message(pmt_t signal, pmt_t data, pmt_t metadata, mb_pri_t priority) { return mb_message_sptr(new mb_message(signal, data, metadata, priority)); } -mb_message::mb_message(gruel::pmt_t signal, gruel::pmt_t data, gruel::pmt_t metadata, mb_pri_t priority) +mb_message::mb_message(pmt_t signal, pmt_t data, pmt_t metadata, mb_pri_t priority) : d_signal(signal), d_data(data), d_metadata(metadata), d_priority(priority), - d_port_id(gruel::PMT_NIL) + d_port_id(PMT_NIL) { } diff --git a/mblock/src/lib/mb_msg_accepter_msgq.cc b/mblock/src/lib/mb_msg_accepter_msgq.cc index e13ec5aa..6c74ac47 100644 --- a/mblock/src/lib/mb_msg_accepter_msgq.cc +++ b/mblock/src/lib/mb_msg_accepter_msgq.cc @@ -25,7 +25,9 @@ #include #include -gruel::pmt_t s_sys_port = gruel::pmt_intern("%sys-port"); +using namespace pmt; + +pmt_t s_sys_port = pmt_intern("%sys-port"); mb_msg_accepter_msgq::mb_msg_accepter_msgq(mb_msg_queue *msgq) : d_msgq(msgq) @@ -37,8 +39,8 @@ mb_msg_accepter_msgq::~mb_msg_accepter_msgq() } void -mb_msg_accepter_msgq::operator()(gruel::pmt_t signal, gruel::pmt_t data, - gruel::pmt_t metadata, mb_pri_t priority) +mb_msg_accepter_msgq::operator()(pmt_t signal, pmt_t data, + pmt_t metadata, mb_pri_t priority) { mb_message_sptr msg = mb_make_message(signal, data, metadata, priority); msg->set_port_id(s_sys_port); diff --git a/mblock/src/lib/mb_msg_accepter_msgq.h b/mblock/src/lib/mb_msg_accepter_msgq.h index e196d49b..f84bca59 100644 --- a/mblock/src/lib/mb_msg_accepter_msgq.h +++ b/mblock/src/lib/mb_msg_accepter_msgq.h @@ -33,7 +33,7 @@ class mb_msg_accepter_msgq : public mb_msg_accepter { public: mb_msg_accepter_msgq(mb_msg_queue *msgq); ~mb_msg_accepter_msgq(); - void operator()(gruel::pmt_t signal, gruel::pmt_t data, gruel::pmt_t metadata, mb_pri_t priority); + void operator()(pmt::pmt_t signal, pmt::pmt_t data, pmt::pmt_t metadata, mb_pri_t priority); }; #endif /* INCLUDED_MB_MSG_ACCEPTER_MSGQ_H */ diff --git a/mblock/src/lib/mb_msg_accepter_smp.cc b/mblock/src/lib/mb_msg_accepter_smp.cc index 5d2872b0..1ec8c5bf 100644 --- a/mblock/src/lib/mb_msg_accepter_smp.cc +++ b/mblock/src/lib/mb_msg_accepter_smp.cc @@ -28,7 +28,9 @@ #include #include -mb_msg_accepter_smp::mb_msg_accepter_smp(mb_mblock_sptr mblock, gruel::pmt_t port_name) +using namespace pmt; + +mb_msg_accepter_smp::mb_msg_accepter_smp(mb_mblock_sptr mblock, pmt_t port_name) : d_mb(mblock), d_port_name(port_name) { } @@ -39,8 +41,8 @@ mb_msg_accepter_smp::~mb_msg_accepter_smp() } void -mb_msg_accepter_smp::operator()(gruel::pmt_t signal, gruel::pmt_t data, - gruel::pmt_t metadata, mb_pri_t priority) +mb_msg_accepter_smp::operator()(pmt_t signal, pmt_t data, + pmt_t metadata, mb_pri_t priority) { mb_message_sptr msg = mb_make_message(signal, data, metadata, priority); msg->set_port_id(d_port_name); diff --git a/mblock/src/lib/mb_msg_accepter_smp.h b/mblock/src/lib/mb_msg_accepter_smp.h index 4e190410..3028484f 100644 --- a/mblock/src/lib/mb_msg_accepter_smp.h +++ b/mblock/src/lib/mb_msg_accepter_smp.h @@ -29,13 +29,13 @@ class mb_msg_accepter_smp : public mb_msg_accepter { mb_mblock_sptr d_mb; - gruel::pmt_t d_port_name; + pmt::pmt_t d_port_name; public: - mb_msg_accepter_smp(mb_mblock_sptr mblock, gruel::pmt_t port_name); + mb_msg_accepter_smp(mb_mblock_sptr mblock, pmt::pmt_t port_name); ~mb_msg_accepter_smp(); - void operator()(gruel::pmt_t signal, gruel::pmt_t data, gruel::pmt_t metadata, mb_pri_t priority); + void operator()(pmt::pmt_t signal, pmt::pmt_t data, pmt::pmt_t metadata, mb_pri_t priority); }; diff --git a/mblock/src/lib/mb_port.cc b/mblock/src/lib/mb_port.cc index abf909fd..a26a2c41 100644 --- a/mblock/src/lib/mb_port.cc +++ b/mblock/src/lib/mb_port.cc @@ -26,16 +26,18 @@ #include #include +using namespace pmt; + mb_port::mb_port(mb_mblock *mblock, const std::string &port_name, const std::string &protocol_class_name, bool conjugated, mb_port::port_type_t port_type) - : d_port_name(port_name), d_port_symbol(gruel::pmt_intern(port_name)), + : d_port_name(port_name), d_port_symbol(pmt_intern(port_name)), d_conjugated(conjugated), d_port_type(port_type), d_mblock(mblock) { - gruel::pmt_t pc = mb_protocol_class_lookup(gruel::pmt_intern(protocol_class_name)); + pmt_t pc = mb_protocol_class_lookup(pmt_intern(protocol_class_name)); if (pmt_is_null(pc)){ throw std::runtime_error("mb_port: unknown protocol class '" + protocol_class_name + "'"); @@ -48,7 +50,7 @@ mb_port::~mb_port() // nop } -gruel::pmt_t +pmt_t mb_port::incoming_message_set() const { if (!conjugated()) @@ -57,7 +59,7 @@ mb_port::incoming_message_set() const return mb_protocol_class_outgoing(protocol_class()); } -gruel::pmt_t +pmt_t mb_port::outgoing_message_set() const { if (!conjugated()) diff --git a/mblock/src/lib/mb_port_simple.cc b/mblock/src/lib/mb_port_simple.cc index 3005932f..235e59de 100644 --- a/mblock/src/lib/mb_port_simple.cc +++ b/mblock/src/lib/mb_port_simple.cc @@ -31,6 +31,7 @@ #include #include +using namespace pmt; mb_port_simple::mb_port_simple(mb_mblock *mblock, const std::string &port_name, @@ -48,7 +49,7 @@ mb_port_simple::~mb_port_simple() } void -mb_port_simple::send(gruel::pmt_t signal, gruel::pmt_t data, gruel::pmt_t metadata, mb_pri_t priority) +mb_port_simple::send(pmt_t signal, pmt_t data, pmt_t metadata, mb_pri_t priority) { if (port_type() == mb_port::RELAY) // Can't send directly to a RELAY port throw mbe_invalid_port_type(mblock(), mblock()->instance_name(), port_name()); diff --git a/mblock/src/lib/mb_port_simple.h b/mblock/src/lib/mb_port_simple.h index a2136ed0..485c809f 100644 --- a/mblock/src/lib/mb_port_simple.h +++ b/mblock/src/lib/mb_port_simple.h @@ -56,9 +56,9 @@ public: * \param priority the urgency at which the message is sent */ void - send(gruel::pmt_t signal, - gruel::pmt_t data = gruel::PMT_NIL, - gruel::pmt_t metadata = gruel::PMT_NIL, + send(pmt::pmt_t signal, + pmt::pmt_t data = pmt::PMT_NIL, + pmt::pmt_t metadata = pmt::PMT_NIL, mb_pri_t priority = MB_PRI_DEFAULT); /* diff --git a/mblock/src/lib/mb_protocol_class.cc b/mblock/src/lib/mb_protocol_class.cc index 6492c155..1c696fb7 100644 --- a/mblock/src/lib/mb_protocol_class.cc +++ b/mblock/src/lib/mb_protocol_class.cc @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2006,2008 Free Software Foundation, Inc. + * Copyright 2006,2008,2009 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -26,60 +26,62 @@ #include #include -static gruel::pmt_t s_ALL_PROTOCOL_CLASSES = gruel::PMT_NIL; +using namespace pmt; -gruel::pmt_t -mb_make_protocol_class(gruel::pmt_t name, gruel::pmt_t incoming, gruel::pmt_t outgoing) +static pmt_t s_ALL_PROTOCOL_CLASSES = PMT_NIL; + +pmt_t +mb_make_protocol_class(pmt_t name, pmt_t incoming, pmt_t outgoing) { // (protocol-class ) - if (!gruel::pmt_is_symbol(name)) - throw gruel::pmt_wrong_type("mb_make_protocol_class: NAME must be symbol", name); - if (!(gruel::pmt_is_pair(incoming) || gruel::pmt_is_null(incoming))) - throw gruel::pmt_wrong_type("mb_make_protocol_class: INCOMING must be a list", name); - if (!(gruel::pmt_is_pair(outgoing) || gruel::pmt_is_null(outgoing))) - throw gruel::pmt_wrong_type("mb_make_protocol_class: OUTGOING must be a list", name); + if (!pmt_is_symbol(name)) + throw pmt_wrong_type("mb_make_protocol_class: NAME must be symbol", name); + if (!(pmt_is_pair(incoming) || pmt_is_null(incoming))) + throw pmt_wrong_type("mb_make_protocol_class: INCOMING must be a list", name); + if (!(pmt_is_pair(outgoing) || pmt_is_null(outgoing))) + throw pmt_wrong_type("mb_make_protocol_class: OUTGOING must be a list", name); - gruel::pmt_t t = gruel::pmt_cons(gruel::pmt_intern("protocol-class"), - gruel::pmt_cons(name, - gruel::pmt_cons(incoming, - gruel::pmt_cons(outgoing, gruel::PMT_NIL)))); + pmt_t t = pmt_cons(pmt_intern("protocol-class"), + pmt_cons(name, + pmt_cons(incoming, + pmt_cons(outgoing, PMT_NIL)))); // Remember this protocol class. - s_ALL_PROTOCOL_CLASSES = gruel::pmt_cons(t, s_ALL_PROTOCOL_CLASSES); + s_ALL_PROTOCOL_CLASSES = pmt_cons(t, s_ALL_PROTOCOL_CLASSES); return t; } -gruel::pmt_t -mb_protocol_class_name(gruel::pmt_t pc) +pmt_t +mb_protocol_class_name(pmt_t pc) { - return gruel::pmt_nth(1, pc); + return pmt_nth(1, pc); } -gruel::pmt_t -mb_protocol_class_incoming(gruel::pmt_t pc) +pmt_t +mb_protocol_class_incoming(pmt_t pc) { - return gruel::pmt_nth(2, pc); + return pmt_nth(2, pc); } -gruel::pmt_t -mb_protocol_class_outgoing(gruel::pmt_t pc) +pmt_t +mb_protocol_class_outgoing(pmt_t pc) { - return gruel::pmt_nth(3, pc); + return pmt_nth(3, pc); } -gruel::pmt_t -mb_protocol_class_lookup(gruel::pmt_t name) +pmt_t +mb_protocol_class_lookup(pmt_t name) { - gruel::pmt_t lst = s_ALL_PROTOCOL_CLASSES; + pmt_t lst = s_ALL_PROTOCOL_CLASSES; - while (gruel::pmt_is_pair(lst)){ - if (gruel::pmt_eq(name, mb_protocol_class_name(gruel::pmt_car(lst)))) - return gruel::pmt_car(lst); - lst = gruel::pmt_cdr(lst); + while (pmt_is_pair(lst)){ + if (pmt_eq(name, mb_protocol_class_name(pmt_car(lst)))) + return pmt_car(lst); + lst = pmt_cdr(lst); } - return gruel::PMT_NIL; + return PMT_NIL; } mb_protocol_class_init::mb_protocol_class_init(const char *data, size_t len) @@ -88,18 +90,18 @@ mb_protocol_class_init::mb_protocol_class_init(const char *data, size_t len) sb.str(std::string(data, len)); while (1){ - gruel::pmt_t obj = gruel::pmt_deserialize(sb); + pmt_t obj = pmt_deserialize(sb); if (0){ - gruel::pmt_write(obj, std::cout); + pmt_write(obj, std::cout); std::cout << std::endl; } - if (gruel::pmt_is_eof_object(obj)) + if (pmt_is_eof_object(obj)) return; - mb_make_protocol_class(gruel::pmt_nth(0, obj), // protocol-class name - gruel::pmt_nth(1, obj), // list of incoming msg names - gruel::pmt_nth(2, obj)); // list of outgoing msg names + mb_make_protocol_class(pmt_nth(0, obj), // protocol-class name + pmt_nth(1, obj), // list of incoming msg names + pmt_nth(2, obj)); // list of outgoing msg names } } diff --git a/mblock/src/lib/mb_runtime_base.cc b/mblock/src/lib/mb_runtime_base.cc index 872cf336..f259a690 100644 --- a/mblock/src/lib/mb_runtime_base.cc +++ b/mblock/src/lib/mb_runtime_base.cc @@ -24,34 +24,36 @@ #endif #include +using namespace pmt; + /* * Default nop implementations... */ void -mb_runtime_base::request_shutdown(gruel::pmt_t result) +mb_runtime_base::request_shutdown(pmt_t result) { } -gruel::pmt_t +pmt_t mb_runtime_base::schedule_one_shot_timeout(const mb_time &abs_time, - gruel::pmt_t user_data, + pmt_t user_data, mb_msg_accepter_sptr accepter) { - return gruel::PMT_F; + return PMT_F; } -gruel::pmt_t +pmt_t mb_runtime_base::schedule_periodic_timeout(const mb_time &first_abs_time, const mb_time &delta_time, - gruel::pmt_t user_data, + pmt_t user_data, mb_msg_accepter_sptr accepter) { - return gruel::PMT_F; + return PMT_F; } void -mb_runtime_base::cancel_timeout(gruel::pmt_t handle) +mb_runtime_base::cancel_timeout(pmt_t handle) { } diff --git a/mblock/src/lib/mb_runtime_base.h b/mblock/src/lib/mb_runtime_base.h index d5ec29c2..78be2922 100644 --- a/mblock/src/lib/mb_runtime_base.h +++ b/mblock/src/lib/mb_runtime_base.h @@ -50,24 +50,24 @@ public: */ inline void unlock() { d_brl.unlock(); } - virtual void request_shutdown(gruel::pmt_t result); + virtual void request_shutdown(pmt::pmt_t result); virtual mb_mblock_sptr create_component(const std::string &instance_name, const std::string &class_name, - gruel::pmt_t user_arg) = 0; + pmt::pmt_t user_arg) = 0; - virtual gruel::pmt_t - schedule_one_shot_timeout(const mb_time &abs_time, gruel::pmt_t user_data, + virtual pmt::pmt_t + schedule_one_shot_timeout(const mb_time &abs_time, pmt::pmt_t user_data, mb_msg_accepter_sptr accepter); - virtual gruel::pmt_t + virtual pmt::pmt_t schedule_periodic_timeout(const mb_time &first_abs_time, const mb_time &delta_time, - gruel::pmt_t user_data, + pmt::pmt_t user_data, mb_msg_accepter_sptr accepter); virtual void - cancel_timeout(gruel::pmt_t handle); + cancel_timeout(pmt::pmt_t handle); mb_msg_accepter_sptr accepter() { return d_accepter; } diff --git a/mblock/src/lib/mb_runtime_nop.cc b/mblock/src/lib/mb_runtime_nop.cc index 3ea6d093..8293e0c2 100644 --- a/mblock/src/lib/mb_runtime_nop.cc +++ b/mblock/src/lib/mb_runtime_nop.cc @@ -27,6 +27,8 @@ #include #include +using namespace pmt; + mb_runtime_sptr mb_make_runtime_nop() { @@ -48,7 +50,7 @@ mb_runtime_nop::~mb_runtime_nop() bool mb_runtime_nop::run(const std::string &instance_name, const std::string &class_name, - gruel::pmt_t user_arg, gruel::pmt_t *result) + pmt_t user_arg, pmt_t *result) { class initial_visitor : public mb_visitor { @@ -63,7 +65,7 @@ mb_runtime_nop::run(const std::string &instance_name, initial_visitor visitor; if (result) - *result = gruel::PMT_T; + *result = PMT_T; d_top = create_component(instance_name, class_name, user_arg); d_top->walk_tree(&visitor); @@ -74,7 +76,7 @@ mb_runtime_nop::run(const std::string &instance_name, mb_mblock_sptr mb_runtime_nop::create_component(const std::string &instance_name, const std::string &class_name, - gruel::pmt_t user_arg) + pmt_t user_arg) { mb_mblock_maker_t maker; if (!mb_class_registry::lookup_maker(class_name, &maker)) diff --git a/mblock/src/lib/mb_runtime_nop.h b/mblock/src/lib/mb_runtime_nop.h index a57d0b60..735c0405 100644 --- a/mblock/src/lib/mb_runtime_nop.h +++ b/mblock/src/lib/mb_runtime_nop.h @@ -39,14 +39,14 @@ public: bool run(const std::string &instance_name, const std::string &class_name, - gruel::pmt_t user_arg, - gruel::pmt_t *result); + pmt::pmt_t user_arg, + pmt::pmt_t *result); protected: mb_mblock_sptr create_component(const std::string &instance_name, const std::string &class_name, - gruel::pmt_t user_arg); + pmt::pmt_t user_arg); }; #endif /* INCLUDED_MB_RUNTIME_NOP_H */ diff --git a/mblock/src/lib/mb_runtime_thread_per_block.cc b/mblock/src/lib/mb_runtime_thread_per_block.cc index f92b98f7..b1600943 100644 --- a/mblock/src/lib/mb_runtime_thread_per_block.cc +++ b/mblock/src/lib/mb_runtime_thread_per_block.cc @@ -32,21 +32,22 @@ #include #include - -static gruel::pmt_t s_halt = gruel::pmt_intern("%halt"); -static gruel::pmt_t s_sys_port = gruel::pmt_intern("%sys-port"); -static gruel::pmt_t s_shutdown = gruel::pmt_intern("%shutdown"); -static gruel::pmt_t s_request_shutdown = gruel::pmt_intern("%request-shutdown"); -static gruel::pmt_t s_worker_state_changed = gruel::pmt_intern("%worker-state-changed"); -static gruel::pmt_t s_timeout = gruel::pmt_intern("%timeout"); -static gruel::pmt_t s_request_timeout = gruel::pmt_intern("%request-timeout"); -static gruel::pmt_t s_cancel_timeout = gruel::pmt_intern("%cancel-timeout"); -static gruel::pmt_t s_send_halt = gruel::pmt_intern("send-halt"); -static gruel::pmt_t s_exit_now = gruel::pmt_intern("exit-now"); +using namespace pmt; + +static pmt_t s_halt = pmt_intern("%halt"); +static pmt_t s_sys_port = pmt_intern("%sys-port"); +static pmt_t s_shutdown = pmt_intern("%shutdown"); +static pmt_t s_request_shutdown = pmt_intern("%request-shutdown"); +static pmt_t s_worker_state_changed = pmt_intern("%worker-state-changed"); +static pmt_t s_timeout = pmt_intern("%timeout"); +static pmt_t s_request_timeout = pmt_intern("%request-timeout"); +static pmt_t s_cancel_timeout = pmt_intern("%cancel-timeout"); +static pmt_t s_send_halt = pmt_intern("send-halt"); +static pmt_t s_exit_now = pmt_intern("exit-now"); static void -send_sys_msg(mb_msg_queue &msgq, gruel::pmt_t signal, - gruel::pmt_t data = gruel::PMT_F, gruel::pmt_t metadata = gruel::PMT_F, +send_sys_msg(mb_msg_queue &msgq, pmt_t signal, + pmt_t data = PMT_F, pmt_t metadata = PMT_F, mb_pri_t priority = MB_PRI_BEST) { mb_message_sptr msg = mb_make_message(signal, data, metadata, priority); @@ -57,7 +58,7 @@ send_sys_msg(mb_msg_queue &msgq, gruel::pmt_t signal, mb_runtime_thread_per_block::mb_runtime_thread_per_block() : d_shutdown_in_progress(false), - d_shutdown_result(gruel::PMT_T) + d_shutdown_result(PMT_T) { d_accepter = mb_msg_accepter_sptr(new mb_msg_accepter_msgq(&d_msgq)); } @@ -72,22 +73,22 @@ mb_runtime_thread_per_block::~mb_runtime_thread_per_block() } void -mb_runtime_thread_per_block::request_shutdown(gruel::pmt_t result) +mb_runtime_thread_per_block::request_shutdown(pmt_t result) { - (*accepter())(s_request_shutdown, result, gruel::PMT_F, MB_PRI_BEST); + (*accepter())(s_request_shutdown, result, PMT_F, MB_PRI_BEST); } bool mb_runtime_thread_per_block::run(const std::string &instance_name, const std::string &class_name, - gruel::pmt_t user_arg, gruel::pmt_t *result) + pmt_t user_arg, pmt_t *result) { if (result) // set it to something now, in case we throw - *result = gruel::PMT_F; + *result = PMT_F; // reset the shutdown state d_shutdown_in_progress = false; - d_shutdown_result = gruel::PMT_T; + d_shutdown_result = PMT_T; assert(d_workers.empty()); @@ -144,15 +145,15 @@ mb_runtime_thread_per_block::run_loop() } } - gruel::pmt_t signal = msg->signal(); + pmt_t signal = msg->signal(); - if (gruel::pmt_eq(signal, s_worker_state_changed)){ // %worker-state-changed + if (pmt_eq(signal, s_worker_state_changed)){ // %worker-state-changed omni_mutex_lock l1(d_workers_mutex); reap_dead_workers(); if (d_workers.empty()) // no work left to do... return; } - else if (gruel::pmt_eq(signal, s_request_shutdown)){ // %request-shutdown + else if (pmt_eq(signal, s_request_shutdown)){ // %request-shutdown if (!d_shutdown_in_progress){ d_shutdown_in_progress = true; d_shutdown_result = msg->data(); @@ -162,23 +163,23 @@ mb_runtime_thread_per_block::run_loop() send_all_sys_msg(s_shutdown); } } - else if (gruel::pmt_eq(signal, s_request_timeout)){ // %request-timeout + else if (pmt_eq(signal, s_request_timeout)){ // %request-timeout mb_timeout_sptr to = - boost::any_cast(gruel::pmt_any_ref(msg->data())); + boost::any_cast(pmt_any_ref(msg->data())); d_timer_queue.push(to); } - else if (gruel::pmt_eq(signal, s_cancel_timeout)){ // %cancel-timeout + else if (pmt_eq(signal, s_cancel_timeout)){ // %cancel-timeout d_timer_queue.cancel(msg->data()); } - else if (gruel::pmt_eq(signal, s_timeout) - && gruel::pmt_eq(msg->data(), s_send_halt)){ // %timeout, send-halt + else if (pmt_eq(signal, s_timeout) + && pmt_eq(msg->data(), s_send_halt)){ // %timeout, send-halt // schedule another timeout for ourselves... schedule_one_shot_timeout(mb_time::time(0.100), s_exit_now, d_accepter); send_all_sys_msg(s_halt); } - else if (gruel::pmt_eq(signal, s_timeout) - && gruel::pmt_eq(msg->data(), s_exit_now)){ // %timeout, exit-now + else if (pmt_eq(signal, s_timeout) + && pmt_eq(msg->data(), s_exit_now)){ // %timeout, exit-now // We only get here if we've sent all workers %shutdown followed // by %halt, and one or more of them is still alive. They must @@ -234,7 +235,7 @@ mb_runtime_thread_per_block::reap_dead_workers() mb_mblock_sptr mb_runtime_thread_per_block::create_component(const std::string &instance_name, const std::string &class_name, - gruel::pmt_t user_arg) + pmt_t user_arg) { mb_mblock_maker_t maker; if (!mb_class_registry::lookup_maker(class_name, &maker)) @@ -293,9 +294,9 @@ mb_runtime_thread_per_block::create_component(const std::string &instance_name, } void -mb_runtime_thread_per_block::send_all_sys_msg(gruel::pmt_t signal, - gruel::pmt_t data, - gruel::pmt_t metadata, +mb_runtime_thread_per_block::send_all_sys_msg(pmt_t signal, + pmt_t data, + pmt_t metadata, mb_pri_t priority) { omni_mutex_lock l1(d_workers_mutex); @@ -310,14 +311,14 @@ mb_runtime_thread_per_block::send_all_sys_msg(gruel::pmt_t signal, // Can be invoked from any thread. // Sends a message to the runtime. // -gruel::pmt_t +pmt_t mb_runtime_thread_per_block::schedule_one_shot_timeout (const mb_time &abs_time, - gruel::pmt_t user_data, + pmt_t user_data, mb_msg_accepter_sptr accepter) { mb_timeout_sptr to(new mb_timeout(abs_time, user_data, accepter)); - (*d_accepter)(s_request_timeout, gruel::pmt_make_any(to), gruel::PMT_F, MB_PRI_BEST); + (*d_accepter)(s_request_timeout, pmt_make_any(to), PMT_F, MB_PRI_BEST); return to->handle(); } @@ -325,16 +326,16 @@ mb_runtime_thread_per_block::schedule_one_shot_timeout // Can be invoked from any thread. // Sends a message to the runtime. // -gruel::pmt_t +pmt_t mb_runtime_thread_per_block::schedule_periodic_timeout (const mb_time &first_abs_time, const mb_time &delta_time, - gruel::pmt_t user_data, + pmt_t user_data, mb_msg_accepter_sptr accepter) { mb_timeout_sptr to(new mb_timeout(first_abs_time, delta_time, user_data, accepter)); - (*d_accepter)(s_request_timeout, gruel::pmt_make_any(to), gruel::PMT_F, MB_PRI_BEST); + (*d_accepter)(s_request_timeout, pmt_make_any(to), PMT_F, MB_PRI_BEST); return to->handle(); } @@ -343,7 +344,7 @@ mb_runtime_thread_per_block::schedule_periodic_timeout // Sends a message to the runtime. // void -mb_runtime_thread_per_block::cancel_timeout(gruel::pmt_t handle) +mb_runtime_thread_per_block::cancel_timeout(pmt_t handle) { - (*d_accepter)(s_cancel_timeout, handle, gruel::PMT_F, MB_PRI_BEST); + (*d_accepter)(s_cancel_timeout, handle, PMT_F, MB_PRI_BEST); } diff --git a/mblock/src/lib/mb_runtime_thread_per_block.h b/mblock/src/lib/mb_runtime_thread_per_block.h index b4486678..74ed6073 100644 --- a/mblock/src/lib/mb_runtime_thread_per_block.h +++ b/mblock/src/lib/mb_runtime_thread_per_block.h @@ -38,7 +38,7 @@ public: omni_mutex d_workers_mutex; // hold while manipulating d_workers std::vector d_workers; bool d_shutdown_in_progress; - gruel::pmt_t d_shutdown_result; + pmt::pmt_t d_shutdown_result; mb_msg_queue d_msgq; mb_timer_queue d_timer_queue; @@ -49,35 +49,35 @@ public: bool run(const std::string &instance_name, const std::string &class_name, - gruel::pmt_t user_arg, - gruel::pmt_t *result); + pmt::pmt_t user_arg, + pmt::pmt_t *result); - void request_shutdown(gruel::pmt_t result); + void request_shutdown(pmt::pmt_t result); protected: mb_mblock_sptr create_component(const std::string &instance_name, const std::string &class_name, - gruel::pmt_t user_arg); + pmt::pmt_t user_arg); - gruel::pmt_t - schedule_one_shot_timeout(const mb_time &abs_time, gruel::pmt_t user_data, + pmt::pmt_t + schedule_one_shot_timeout(const mb_time &abs_time, pmt::pmt_t user_data, mb_msg_accepter_sptr accepter); - gruel::pmt_t + pmt::pmt_t schedule_periodic_timeout(const mb_time &first_abs_time, const mb_time &delta_time, - gruel::pmt_t user_data, + pmt::pmt_t user_data, mb_msg_accepter_sptr accepter); void - cancel_timeout(gruel::pmt_t handle); + cancel_timeout(pmt::pmt_t handle); private: void reap_dead_workers(); void run_loop(); - void send_all_sys_msg(gruel::pmt_t signal, gruel::pmt_t data = gruel::PMT_F, - gruel::pmt_t metadata = gruel::PMT_F, + void send_all_sys_msg(pmt::pmt_t signal, pmt::pmt_t data = pmt::PMT_F, + pmt::pmt_t metadata = pmt::PMT_F, mb_pri_t priority = MB_PRI_BEST); }; diff --git a/mblock/src/lib/mb_timer_queue.cc b/mblock/src/lib/mb_timer_queue.cc index dbdcc4ce..411900c5 100644 --- a/mblock/src/lib/mb_timer_queue.cc +++ b/mblock/src/lib/mb_timer_queue.cc @@ -1,6 +1,6 @@ /* -*- c++ -*- */ /* - * Copyright 2007 Free Software Foundation, Inc. + * Copyright 2007,2009 Free Software Foundation, Inc. * * This file is part of GNU Radio * @@ -24,17 +24,19 @@ #endif #include -static gruel::pmt_t +using namespace pmt; + +static pmt_t make_handle() { static long counter = 0; - gruel::pmt_t n = gruel::pmt_from_long(counter++); - return gruel::pmt_list1(n); // guaranteed to be a unique object + pmt_t n = pmt_from_long(counter++); + return pmt_list1(n); // guaranteed to be a unique object } // one-shot constructor mb_timeout::mb_timeout(const mb_time &abs_time, - gruel::pmt_t user_data, mb_msg_accepter_sptr accepter) + pmt_t user_data, mb_msg_accepter_sptr accepter) : d_when(abs_time), d_is_periodic(false), d_user_data(user_data), d_handle(make_handle()), d_accepter(accepter) { @@ -42,19 +44,19 @@ mb_timeout::mb_timeout(const mb_time &abs_time, // periodic constructor mb_timeout::mb_timeout(const mb_time &first_abs_time, const mb_time &delta_time, - gruel::pmt_t user_data, mb_msg_accepter_sptr accepter) + pmt_t user_data, mb_msg_accepter_sptr accepter) : d_when(first_abs_time), d_delta(delta_time), d_is_periodic(true), d_user_data(user_data), d_handle(make_handle()), d_accepter(accepter) { } void -mb_timer_queue::cancel(gruel::pmt_t handle) +mb_timer_queue::cancel(pmt_t handle) { container_type::iterator it; for (it = c.begin(); it != c.end();){ - if (gruel::pmt_equal((*it)->handle(), handle)) + if (pmt_equal((*it)->handle(), handle)) it = c.erase(it); else ++it; diff --git a/mblock/src/lib/mb_timer_queue.h b/mblock/src/lib/mb_timer_queue.h index 8dcf5338..7a1ad6fa 100644 --- a/mblock/src/lib/mb_timer_queue.h +++ b/mblock/src/lib/mb_timer_queue.h @@ -33,19 +33,19 @@ public: mb_time d_when; // absolute time to fire timeout mb_time d_delta; // if periodic, delta_t to next timeout bool d_is_periodic; // true iff this is a periodic timeout - gruel::pmt_t d_user_data; // data from %timeout msg - gruel::pmt_t d_handle; // handle for cancellation + pmt::pmt_t d_user_data; // data from %timeout msg + pmt::pmt_t d_handle; // handle for cancellation mb_msg_accepter_sptr d_accepter; // where to send the message // one-shot constructor mb_timeout(const mb_time &abs_time, - gruel::pmt_t user_data, mb_msg_accepter_sptr accepter); + pmt::pmt_t user_data, mb_msg_accepter_sptr accepter); // periodic constructor mb_timeout(const mb_time &first_abs_time, const mb_time &delta_time, - gruel::pmt_t user_data, mb_msg_accepter_sptr accepter); + pmt::pmt_t user_data, mb_msg_accepter_sptr accepter); - gruel::pmt_t handle() const { return d_handle; } + pmt::pmt_t handle() const { return d_handle; } }; typedef boost::shared_ptr mb_timeout_sptr; @@ -67,7 +67,7 @@ class mb_timer_queue : public std::priority_queue { public: - void cancel(gruel::pmt_t handle); + void cancel(pmt::pmt_t handle); }; #endif /* INCLUDED_MB_TIMER_QUEUE_H */ diff --git a/mblock/src/lib/mb_worker.cc b/mblock/src/lib/mb_worker.cc index a553198e..7d2896a1 100644 --- a/mblock/src/lib/mb_worker.cc +++ b/mblock/src/lib/mb_worker.cc @@ -36,14 +36,15 @@ #define VERBOSE 0 // define to 0 or 1 +using namespace pmt; -static gruel::pmt_t s_worker_state_changed = gruel::pmt_intern("%worker-state-changed"); +static pmt_t s_worker_state_changed = pmt_intern("%worker-state-changed"); mb_worker::mb_worker(mb_runtime_thread_per_block *runtime, mb_mblock_maker_t maker, const std::string &instance_name, - gruel::pmt_t user_arg) + pmt_t user_arg) : omni_thread((void *) 0, PRIORITY_NORMAL), d_runtime(runtime), d_maker(maker), d_instance_name(instance_name), d_user_arg(user_arg), @@ -95,7 +96,7 @@ mb_worker::set_state(worker_state_t state) } // send msg to runtime, telling it something changed. - (*d_runtime->accepter())(s_worker_state_changed, gruel::PMT_F, gruel::PMT_F, MB_PRI_BEST); + (*d_runtime->accepter())(s_worker_state_changed, PMT_F, PMT_F, MB_PRI_BEST); } void * diff --git a/mblock/src/lib/mb_worker.h b/mblock/src/lib/mb_worker.h index 0bd2fcae..0037d131 100644 --- a/mblock/src/lib/mb_worker.h +++ b/mblock/src/lib/mb_worker.h @@ -62,7 +62,7 @@ public: mb_runtime_thread_per_block *d_runtime; mb_mblock_maker_t d_maker; std::string d_instance_name; - gruel::pmt_t d_user_arg; + pmt::pmt_t d_user_arg; mb_mblock_sptr d_mblock; //< holds pointer to created mblock @@ -80,7 +80,7 @@ public: mb_worker(mb_runtime_thread_per_block *runtime, mb_mblock_maker_t maker, const std::string &instance_name, - gruel::pmt_t user_arg); + pmt::pmt_t user_arg); // ~mb_worker(); diff --git a/mblock/src/lib/qa_bitset.cc b/mblock/src/lib/qa_bitset.cc index 1b472512..7cfd8385 100644 --- a/mblock/src/lib/qa_bitset.cc +++ b/mblock/src/lib/qa_bitset.cc @@ -31,7 +31,7 @@ #include #include -using namespace gruel; +using namespace pmt; static pmt_t s_in = pmt_intern("in"); static pmt_t s_out = pmt_intern("out"); diff --git a/mblock/src/lib/qa_disconnect.cc b/mblock/src/lib/qa_disconnect.cc index 09bdf2e6..c7619bfc 100644 --- a/mblock/src/lib/qa_disconnect.cc +++ b/mblock/src/lib/qa_disconnect.cc @@ -31,7 +31,7 @@ #include #include -using namespace gruel; +using namespace pmt; static pmt_t s_in = pmt_intern("in"); static pmt_t s_out = pmt_intern("out"); diff --git a/mblock/src/lib/qa_mblock_prims.cc b/mblock/src/lib/qa_mblock_prims.cc index 6e0d5531..e49bd60d 100644 --- a/mblock/src/lib/qa_mblock_prims.cc +++ b/mblock/src/lib/qa_mblock_prims.cc @@ -37,7 +37,7 @@ #include #include -using namespace gruel; +using namespace pmt; static pmt_t s_cs = pmt_intern("cs"); static pmt_t s_debug = pmt_intern("debug"); diff --git a/mblock/src/lib/qa_mblock_send.cc b/mblock/src/lib/qa_mblock_send.cc index e9c91499..53f93927 100644 --- a/mblock/src/lib/qa_mblock_send.cc +++ b/mblock/src/lib/qa_mblock_send.cc @@ -38,7 +38,7 @@ #include #include -using namespace gruel; +using namespace pmt; static pmt_t s_data = pmt_intern("data"); static pmt_t s_status = pmt_intern("status"); diff --git a/mblock/src/lib/qa_mblock_sys.cc b/mblock/src/lib/qa_mblock_sys.cc index e8ff780a..8c8dbbf0 100644 --- a/mblock/src/lib/qa_mblock_sys.cc +++ b/mblock/src/lib/qa_mblock_sys.cc @@ -40,7 +40,7 @@ #include #include -using namespace gruel; +using namespace pmt; static pmt_t s_data = pmt_intern("data"); static pmt_t s_status = pmt_intern("status"); diff --git a/mblock/src/lib/qa_timeouts.cc b/mblock/src/lib/qa_timeouts.cc index 39761c0b..b230f86d 100644 --- a/mblock/src/lib/qa_timeouts.cc +++ b/mblock/src/lib/qa_timeouts.cc @@ -34,7 +34,7 @@ #include #include -using namespace gruel; +using namespace pmt; static pmt_t s_timeout = pmt_intern("%timeout"); static pmt_t s_done = pmt_intern("done");