diff options
Diffstat (limited to 'gruel/src/lib')
29 files changed, 0 insertions, 5292 deletions
diff --git a/gruel/src/lib/CMakeLists.txt b/gruel/src/lib/CMakeLists.txt deleted file mode 100644 index a3baa4fa5c..0000000000 --- a/gruel/src/lib/CMakeLists.txt +++ /dev/null @@ -1,125 +0,0 @@ -# Copyright 2010-2011,2013 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 subdirs rather to populate to the sources lists. -######################################################################## -include(GrMiscUtils) -include(CheckCXXSourceCompiles) - -GR_CHECK_HDR_N_DEF(signal.h HAVE_SIGNAL_H) -GR_CHECK_HDR_N_DEF(sched.h HAVE_SCHED_H) - -set(CMAKE_REQUIRED_LIBRARIES -lpthread) -CHECK_CXX_SOURCE_COMPILES(" - #include <signal.h> - int main(){pthread_sigmask(0, 0, 0); return 0;} - " HAVE_PTHREAD_SIGMASK -) -GR_ADD_COND_DEF(HAVE_PTHREAD_SIGMASK) - -set(CMAKE_REQUIRED_LIBRARIES -lpthread) -CHECK_CXX_SOURCE_COMPILES(" - #include <pthread.h> - int main(){ - pthread_t pthread; - pthread_setschedparam(pthread, 0, 0); - return 0; - } " HAVE_PTHREAD_SETSCHEDPARAM -) -GR_ADD_COND_DEF(HAVE_PTHREAD_SETSCHEDPARAM) - -CHECK_CXX_SOURCE_COMPILES(" - #include <sched.h> - int main(){ - pid_t pid; - sched_setscheduler(pid, 0, 0); - return 0; - } " HAVE_SCHED_SETSCHEDULER -) -GR_ADD_COND_DEF(HAVE_SCHED_SETSCHEDULER) - -######################################################################## -# Include subdirs rather to populate to the sources lists. -######################################################################## -GR_INCLUDE_SUBDIRECTORY(msg) -GR_INCLUDE_SUBDIRECTORY(pmt) - -######################################################################## -# Setup the include and linker paths -######################################################################## -include_directories( - ${CMAKE_CURRENT_SOURCE_DIR} - ${GRUEL_INCLUDE_DIRS} - ${Boost_INCLUDE_DIRS} -) -link_directories(${Boost_LIBRARY_DIRS}) - -######################################################################## -# Setup library -######################################################################## -list(APPEND gruel_sources - realtime.cc - sys_pri.cc - thread.cc - thread_body_wrapper.cc - thread_group.cc -) - -#Add Windows DLL resource file if using MSVC -if(MSVC) - include(${CMAKE_SOURCE_DIR}/cmake/Modules/GrVersion.cmake) - - configure_file( - ${CMAKE_CURRENT_SOURCE_DIR}/gruel.rc.in - ${CMAKE_CURRENT_BINARY_DIR}/gruel.rc - @ONLY) - - list(APPEND gruel_sources - ${CMAKE_CURRENT_BINARY_DIR}/gruel.rc - ) -endif(MSVC) - -list(APPEND gruel_libs ${Boost_LIBRARIES}) - -if(HAVE_PTHREAD_SETSCHEDPARAM) - list(APPEND gruel_libs pthread) -endif() - -add_library(gruel SHARED ${gruel_sources}) -target_link_libraries(gruel ${gruel_libs}) -GR_LIBRARY_FOO(gruel RUNTIME_COMPONENT "gruel_runtime" DEVEL_COMPONENT "gruel_devel") - -######################################################################## -# Setup tests -# Set the test environment so the build libs will be found under MSVC. -######################################################################## -if(ENABLE_TESTING) - -include_directories(${CPPUNIT_INCLUDE_DIRS}) -link_directories(${CPPUNIT_LIBRARY_DIRS}) - -include(GrTest) -set(GR_TEST_TARGET_DEPS gruel) -list(APPEND test_gruel_sources test_gruel.cc) -add_executable(test_gruel ${test_gruel_sources}) -target_link_libraries(test_gruel gruel ${CPPUNIT_LIBRARIES}) -GR_ADD_TEST(gruel-test test_gruel) - -endif(ENABLE_TESTING) diff --git a/gruel/src/lib/gruel.rc.in b/gruel/src/lib/gruel.rc.in deleted file mode 100644 index 906b7d61c2..0000000000 --- a/gruel/src/lib/gruel.rc.in +++ /dev/null @@ -1,55 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2013 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 <afxres.h> - -VS_VERSION_INFO VERSIONINFO - FILEVERSION @MAJOR_VERSION@,@API_COMPAT@,@RC_MINOR_VERSION@,@RC_MAINT_VERSION@ - PRODUCTVERSION @MAJOR_VERSION@,@API_COMPAT@,@RC_MINOR_VERSION@,@RC_MAINT_VERSION@ - FILEFLAGSMASK 0x3fL -#ifndef NDEBUG - FILEFLAGS 0x0L -#else - FILEFLAGS 0x1L -#endif - FILEOS VOS__WINDOWS32 - FILETYPE VFT_DLL - FILESUBTYPE VFT2_DRV_INSTALLABLE - BEGIN - BLOCK "StringFileInfo" - BEGIN - BLOCK "040904b0" - BEGIN - VALUE "FileDescription", "gruel" - VALUE "FileVersion", "@VERSION@" - VALUE "InternalName", "gruel.dll" - VALUE "LegalCopyright", "Licensed under GPLv3 or any later version" - VALUE "OriginalFilename", "gruel.dll" - VALUE "ProductName", "gruel" - VALUE "ProductVersion", "@VERSION@" - END - END - BLOCK "VarFileInfo" - BEGIN - VALUE "Translation", 0x409, 1200 - END - END diff --git a/gruel/src/lib/msg/CMakeLists.txt b/gruel/src/lib/msg/CMakeLists.txt deleted file mode 100644 index b8167fff34..0000000000 --- a/gruel/src/lib/msg/CMakeLists.txt +++ /dev/null @@ -1,29 +0,0 @@ -# Copyright 2010 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 file included, use CMake directory variables -######################################################################## - -list(APPEND gruel_sources - ${CMAKE_CURRENT_SOURCE_DIR}/msg_accepter.cc - ${CMAKE_CURRENT_SOURCE_DIR}/msg_accepter_msgq.cc - ${CMAKE_CURRENT_SOURCE_DIR}/msg_producer.cc - ${CMAKE_CURRENT_SOURCE_DIR}/msg_queue.cc -) diff --git a/gruel/src/lib/msg/msg_accepter.cc b/gruel/src/lib/msg/msg_accepter.cc deleted file mode 100644 index 5acd98aa22..0000000000 --- a/gruel/src/lib/msg/msg_accepter.cc +++ /dev/null @@ -1,36 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 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 "config.h" -#endif - -#include <gruel/msg_accepter.h> - -namespace gruel { - - msg_accepter::~msg_accepter() - { - // NOP, required as virtual destructor - } - -} /* namespace gruel */ diff --git a/gruel/src/lib/msg/msg_accepter_msgq.cc b/gruel/src/lib/msg/msg_accepter_msgq.cc deleted file mode 100644 index 2ae3537b8c..0000000000 --- a/gruel/src/lib/msg/msg_accepter_msgq.cc +++ /dev/null @@ -1,48 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 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. - */ - -#if HAVE_CONFIG_H -#include <config.h> -#endif - -#include <gruel/msg_accepter_msgq.h> - -using namespace pmt; - -namespace gruel { - - msg_accepter_msgq::msg_accepter_msgq(msg_queue_sptr msgq) - : d_msg_queue(msgq) - { - } - - msg_accepter_msgq::~msg_accepter_msgq() - { - // NOP, required as virtual destructor - } - - void - msg_accepter_msgq::post(pmt_t msg) - { - d_msg_queue->insert_tail(msg); - } - -} /* namespace gruel */ diff --git a/gruel/src/lib/msg/msg_producer.cc b/gruel/src/lib/msg/msg_producer.cc deleted file mode 100644 index 3e8148763b..0000000000 --- a/gruel/src/lib/msg/msg_producer.cc +++ /dev/null @@ -1,36 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2012 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 "config.h" -#endif - -#include <gruel/msg_producer.h> - -namespace gruel { - - msg_producer::~msg_producer() - { - // NOP, required as virtual destructor - } - -} /* namespace gruel */ diff --git a/gruel/src/lib/msg/msg_queue.cc b/gruel/src/lib/msg/msg_queue.cc deleted file mode 100644 index a0b120e40d..0000000000 --- a/gruel/src/lib/msg/msg_queue.cc +++ /dev/null @@ -1,103 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 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 "config.h" -#endif - -#include <gruel/msg_queue.h> -#include <stdexcept> - -using namespace pmt; - -namespace gruel { - - msg_queue_sptr - make_msg_queue(unsigned int limit) - { - return msg_queue_sptr(new msg_queue(limit)); - } - - msg_queue::msg_queue(unsigned int limit) - : d_limit(limit) - { - } - - msg_queue::~msg_queue() - { - flush(); - } - - void - msg_queue::insert_tail(pmt_t msg) - { - gruel::scoped_lock guard(d_mutex); - - while (full_p()) - d_not_full.wait(guard); - - d_msgs.push_back(msg); - d_not_empty.notify_one(); - } - - pmt_t - msg_queue::delete_head() - { - gruel::scoped_lock guard(d_mutex); - - while (empty_p()) - d_not_empty.wait(guard); - - pmt_t m(d_msgs.front()); - d_msgs.pop_front(); - - if (d_limit > 0) // Unlimited length queues never block on write - d_not_full.notify_one(); - - return m; - } - - pmt_t - msg_queue::delete_head_nowait() - { - gruel::scoped_lock guard(d_mutex); - - if (empty_p()) - return pmt_t(); - - pmt_t m(d_msgs.front()); - d_msgs.pop_front(); - - if (d_limit > 0) // Unlimited length queues never block on write - d_not_full.notify_one(); - - return m; - } - - void - msg_queue::flush() - { - while (delete_head_nowait() != pmt_t()) - ; - } - -} /* namespace gruel */ diff --git a/gruel/src/lib/pmt/CMakeLists.txt b/gruel/src/lib/pmt/CMakeLists.txt deleted file mode 100644 index 6ea616e107..0000000000 --- a/gruel/src/lib/pmt/CMakeLists.txt +++ /dev/null @@ -1,89 +0,0 @@ -# Copyright 2010-2012 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 file included, use CMake directory variables -######################################################################## -include_directories(${CMAKE_CURRENT_SOURCE_DIR}) -include_directories(${CMAKE_CURRENT_BINARY_DIR}) - -######################################################################## -# Generate serial tags header file -######################################################################## - -get_filename_component(PMT_SERIAL_TAGS_H - ${CMAKE_CURRENT_BINARY_DIR}/../../include/gruel/pmt_serial_tags.h ABSOLUTE -) - -add_custom_command( - OUTPUT ${PMT_SERIAL_TAGS_H} - DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/gen-serial-tags.py - DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/pmt-serial-tags.scm - COMMAND ${PYTHON_EXECUTABLE} - ${CMAKE_CURRENT_SOURCE_DIR}/gen-serial-tags.py - ${CMAKE_CURRENT_SOURCE_DIR}/pmt-serial-tags.scm - ${PMT_SERIAL_TAGS_H} -) - -install( - FILES ${PMT_SERIAL_TAGS_H} - DESTINATION ${GR_INCLUDE_DIR}/gruel - COMPONENT "gruel_devel" -) - -include(AddFileDependencies) -ADD_FILE_DEPENDENCIES( - ${CMAKE_CURRENT_SOURCE_DIR}/pmt_serialize.cc - ${PMT_SERIAL_TAGS_H} -) - -add_custom_target(pmt_generated DEPENDS ${PMT_SERIAL_TAGS_H}) - -######################################################################## -# Generate other pmt stuff -######################################################################## -add_custom_command( - OUTPUT - ${CMAKE_CURRENT_BINARY_DIR}/pmt_unv_int.h - ${CMAKE_CURRENT_BINARY_DIR}/qa_pmt_unv.h - ${CMAKE_CURRENT_BINARY_DIR}/pmt_unv.cc - ${CMAKE_CURRENT_BINARY_DIR}/qa_pmt_unv.cc - DEPENDS - ${CMAKE_CURRENT_SOURCE_DIR}/generate_unv.py - ${CMAKE_CURRENT_SOURCE_DIR}/unv_template.h.t - ${CMAKE_CURRENT_SOURCE_DIR}/unv_template.cc.t - ${CMAKE_CURRENT_SOURCE_DIR}/unv_qa_template.cc.t - COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B} -c - \"import os,sys\;srcdir='${CMAKE_CURRENT_SOURCE_DIR}'\;sys.path.append(srcdir)\;os.environ['srcdir']=srcdir\;from generate_unv import main\;main()\" - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} -) - -list(APPEND gruel_sources - ${CMAKE_CURRENT_BINARY_DIR}/pmt_unv.cc - ${CMAKE_CURRENT_SOURCE_DIR}/pmt.cc - ${CMAKE_CURRENT_SOURCE_DIR}/pmt_io.cc - ${CMAKE_CURRENT_SOURCE_DIR}/pmt_pool.cc - ${CMAKE_CURRENT_SOURCE_DIR}/pmt_serialize.cc -) - -list(APPEND test_gruel_sources - ${CMAKE_CURRENT_BINARY_DIR}/qa_pmt_unv.cc - ${CMAKE_CURRENT_SOURCE_DIR}/qa_pmt_prims.cc - ${CMAKE_CURRENT_SOURCE_DIR}/qa_pmt.cc -) diff --git a/gruel/src/lib/pmt/gen-serial-tags.py b/gruel/src/lib/pmt/gen-serial-tags.py deleted file mode 100644 index 18e927beb5..0000000000 --- a/gruel/src/lib/pmt/gen-serial-tags.py +++ /dev/null @@ -1,53 +0,0 @@ -""" -// -// Copyright 2011 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. -// -// -// THIS FILE IS MACHINE GENERATED FROM %s. DO NOT EDIT BY HAND. -// See %s for additional commentary. -// - -#ifndef INCLUDED_PMT_SERIAL_TAGS_H -#define INCLUDED_PMT_SERIAL_TAGS_H - -enum pst_tags { -%s -}; -#endif /* INCLUDED_PMT_SERIAL_TAGS_H */ -""" - -import sys, os, re - -if __name__ == '__main__': - if len(sys.argv) != 3: - print "Usage %s <input_scm_file> <output_hdr_file>"%__file__ - exit() - input_scm_file, output_hdr_file = sys.argv[1:] - enums = list() - for line in open(input_scm_file).readlines(): - match = re.match('^\s*\(define\s+([\w|-]+)\s+#x([0-9a-fA-F]+)\)', line) - if not match: continue - name, value = match.groups() - name = name.upper().replace('-', '_') - enums.append(' %s = 0x%s'%(name, value)) - open(output_hdr_file, 'w').write(__doc__%( - os.path.basename(__file__), - os.path.basename(input_scm_file), - ',\n'.join(enums), - )) diff --git a/gruel/src/lib/pmt/generate_unv.py b/gruel/src/lib/pmt/generate_unv.py deleted file mode 100755 index 42b57e2454..0000000000 --- a/gruel/src/lib/pmt/generate_unv.py +++ /dev/null @@ -1,190 +0,0 @@ -#!/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<float>'), - ('c64', 'std::complex<double>') - ) - -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 <config.h> -#endif -#include <vector> -#include <gruel/pmt.h> -#include "pmt_int.h" -""" - -qa_includes = """ -#include <qa_pmt_unv.h> -#include <cppunit/TestAssert.h> -#include <gruel/pmt.h> -#include <stdio.h> - -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 <cppunit/extensions/HelperMacros.h> -#include <cppunit/TestCase.h> - -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-serial-tags.scm b/gruel/src/lib/pmt/pmt-serial-tags.scm deleted file mode 100644 index 4f06bf75f8..0000000000 --- a/gruel/src/lib/pmt/pmt-serial-tags.scm +++ /dev/null @@ -1,77 +0,0 @@ -;;; -*-scheme-*- -;;; -;;; Copyright 2007 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 (define 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. -;;; - -;;; definitions of tag values used for marshalling pmt data - -(define pst-true #x00) -(define pst-false #x01) -(define pst-symbol #x02) ; untagged-int16 n; followed by n bytes of symbol name -(define pst-int32 #x03) -(define pst-double #x04) -(define pst-complex #x05) ; complex<double>: real, imag -(define pst-null #x06) -(define pst-pair #x07) ; followed by two objects -(define pst-vector #x08) ; untagged-int32 n; followed by n objects -(define pst-dict #x09) ; untagged-int32 n; followed by n key/value tuples - -(define pst-uniform-vector #x0a) -(define pst-uint64 #x0b) -(define pst-tuple #x0c) - -;; u8, s8, u16, s16, u32, s32, u64, s64, f32, f64, c32, c64 -;; -;; untagged-uint8 tag -;; untagged-uint8 uvi (define uniform vector info, see below) -;; untagged-int32 n-items -;; untagged-uint8 npad -;; npad bytes of zeros to align binary data -;; n-items binary numeric items -;; -;; uvi: -;; +-+-+-+-+-+-+-+-+ -;; |B| subtype | -;; +-+-+-+-+-+-+-+-+ -;; -;; B == 0, numeric data is little-endian. -;; B == 1, numeric data is big-endian. - - (define uvi-endian-mask #x80) - (define uvi-subtype-mask #x7f) - - (define uvi-little-endian #x00) - (define uvi-big-endian #x80) - - (define uvi-u8 #x00) - (define uvi-s8 #x01) - (define uvi-u16 #x02) - (define uvi-s16 #x03) - (define uvi-u32 #x04) - (define uvi-s32 #x05) - (define uvi-u64 #x06) - (define uvi-s64 #x07) - (define uvi-f32 #x08) - (define uvi-f64 #x09) - (define uvi-c32 #x0a) - (define uvi-c64 #x0b) - - -(define pst-comment #x3b) ; ascii ';' -(define pst-comment-end #x0a) ; ascii '\n' diff --git a/gruel/src/lib/pmt/pmt.cc b/gruel/src/lib/pmt/pmt.cc deleted file mode 100644 index 8ea0e76143..0000000000 --- a/gruel/src/lib/pmt/pmt.cc +++ /dev/null @@ -1,1435 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006,2009,2010 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 <config.h> -#endif -#include <vector> -#include <gruel/pmt.h> -#include "pmt_int.h" -#include <gruel/msg_accepter.h> -#include <gruel/pmt_pool.h> -#include <stdio.h> -#include <string.h> - -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<intptr_t>(p) & (CACHE_LINE_SIZE - 1)) == 0); - return p; -} - -void -pmt_base::operator delete(void *p, size_t size) -{ - global_pmt_pool.free(p); -} - -#endif - -void intrusive_ptr_add_ref(pmt_base* p) { ++(p->count_); } -void intrusive_ptr_release(pmt_base* p) { if (--(p->count_) == 0 ) delete p; } - -pmt_base::~pmt_base() -{ - // nop -- out of line virtual destructor -} - -//////////////////////////////////////////////////////////////////////////// -// Exceptions -//////////////////////////////////////////////////////////////////////////// - -exception::exception(const std::string &msg, pmt_t obj) - : logic_error(msg + ": " + write_string(obj)) -{ -} - -wrong_type::wrong_type(const std::string &msg, pmt_t obj) - : exception(msg + ": wrong_type ", obj) -{ -} - -out_of_range::out_of_range(const std::string &msg, pmt_t obj) - : exception(msg + ": out of range ", obj) -{ -} - -notimplemented::notimplemented(const std::string &msg, pmt_t obj) - : exception(msg + ": notimplemented ", obj) -{ -} - -//////////////////////////////////////////////////////////////////////////// -// Dynamic Casts -//////////////////////////////////////////////////////////////////////////// - -static pmt_symbol * -_symbol(pmt_t x) -{ - return dynamic_cast<pmt_symbol*>(x.get()); -} - -static pmt_integer * -_integer(pmt_t x) -{ - return dynamic_cast<pmt_integer*>(x.get()); -} - -static pmt_uint64 * -_uint64(pmt_t x) -{ - return dynamic_cast<pmt_uint64*>(x.get()); -} - -static pmt_real * -_real(pmt_t x) -{ - return dynamic_cast<pmt_real*>(x.get()); -} - -static pmt_complex * -_complex(pmt_t x) -{ - return dynamic_cast<pmt_complex*>(x.get()); -} - -static pmt_pair * -_pair(pmt_t x) -{ - return dynamic_cast<pmt_pair*>(x.get()); -} - -static pmt_vector * -_vector(pmt_t x) -{ - return dynamic_cast<pmt_vector*>(x.get()); -} - -static pmt_tuple * -_tuple(pmt_t x) -{ - return dynamic_cast<pmt_tuple*>(x.get()); -} - -static pmt_uniform_vector * -_uniform_vector(pmt_t x) -{ - return dynamic_cast<pmt_uniform_vector*>(x.get()); -} - -static pmt_any * -_any(pmt_t x) -{ - return dynamic_cast<pmt_any*>(x.get()); -} - -//////////////////////////////////////////////////////////////////////////// -// 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 = cons(PMT_NIL, PMT_NIL); // singleton - -//////////////////////////////////////////////////////////////////////////// -// Booleans -//////////////////////////////////////////////////////////////////////////// - -pmt_bool::pmt_bool(){} - -bool -is_true(pmt_t obj) -{ - return obj != PMT_F; -} - -bool -is_false(pmt_t obj) -{ - return obj == PMT_F; -} - -bool -is_bool(pmt_t obj) -{ - return obj->is_bool(); -} - -pmt_t -from_bool(bool val) -{ - return val ? PMT_T : PMT_F; -} - -bool -to_bool(pmt_t val) -{ - if (val == PMT_T) - return true; - if (val == PMT_F) - return false; - throw wrong_type("pmt_to_bool", val); -} - -//////////////////////////////////////////////////////////////////////////// -// Symbols -//////////////////////////////////////////////////////////////////////////// - -static const unsigned int SYMBOL_HASH_TABLE_SIZE = 701; -static std::vector<pmt_t> 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 -is_symbol(const pmt_t& obj) -{ - return obj->is_symbol(); -} - -pmt_t -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 -intern(const std::string &name) -{ - return string_to_symbol(name); -} - -const std::string -symbol_to_string(const pmt_t& sym) -{ - if (!sym->is_symbol()) - throw wrong_type("pmt_symbol_to_string", sym); - - return _symbol(sym)->name(); -} - - - -//////////////////////////////////////////////////////////////////////////// -// Number -//////////////////////////////////////////////////////////////////////////// - -bool -is_number(pmt_t x) -{ - return x->is_number(); -} - -//////////////////////////////////////////////////////////////////////////// -// Integer -//////////////////////////////////////////////////////////////////////////// - -pmt_integer::pmt_integer(long value) : d_value(value) {} - -bool -is_integer(pmt_t x) -{ - return x->is_integer(); -} - - -pmt_t -from_long(long x) -{ - return pmt_t(new pmt_integer(x)); -} - -long -to_long(pmt_t x) -{ - pmt_integer* i = dynamic_cast<pmt_integer*>(x.get()); - if ( i ) - return i->value(); - - throw wrong_type("pmt_to_long", x); -} - -//////////////////////////////////////////////////////////////////////////// -// Uint64 -//////////////////////////////////////////////////////////////////////////// - -pmt_uint64::pmt_uint64(uint64_t value) : d_value(value) {} - -bool -is_uint64(pmt_t x) -{ - return x->is_uint64(); -} - - -pmt_t -from_uint64(uint64_t x) -{ - return pmt_t(new pmt_uint64(x)); -} - -uint64_t -to_uint64(pmt_t x) -{ - if(x->is_uint64()) - return _uint64(x)->value(); - if(x->is_integer()) - { - long tmp = _integer(x)->value(); - if(tmp >= 0) - return (uint64_t) tmp; - } - - throw wrong_type("pmt_to_uint64", x); -} - -//////////////////////////////////////////////////////////////////////////// -// Real -//////////////////////////////////////////////////////////////////////////// - -pmt_real::pmt_real(double value) : d_value(value) {} - -bool -is_real(pmt_t x) -{ - return x->is_real(); -} - -pmt_t -from_double(double x) -{ - return pmt_t(new pmt_real(x)); -} - -double -to_double(pmt_t x) -{ - if (x->is_real()) - return _real(x)->value(); - if (x->is_integer()) - return _integer(x)->value(); - - throw wrong_type("pmt_to_double", x); -} - -//////////////////////////////////////////////////////////////////////////// -// Complex -//////////////////////////////////////////////////////////////////////////// - -pmt_complex::pmt_complex(std::complex<double> value) : d_value(value) {} - -bool -is_complex(pmt_t x) -{ - return x->is_complex(); -} - -pmt_t -make_rectangular(double re, double im) -{ - return from_complex(re, im); -} - -pmt_t -from_complex(double re, double im) -{ - return pmt_from_complex(re, im); -} - -pmt_t pmt_from_complex(double re, double im) -{ - return pmt_t(new pmt_complex(std::complex<double>(re, im))); -} - -pmt_t -from_complex(const std::complex<double> &z) -{ - return pmt_t(new pmt_complex(z)); -} - -std::complex<double> -to_complex(pmt_t x) -{ - if (x->is_complex()) - return _complex(x)->value(); - if (x->is_real()) - return _real(x)->value(); - if (x->is_integer()) - return _integer(x)->value(); - - throw wrong_type("pmt_to_complex", x); -} - -//////////////////////////////////////////////////////////////////////////// -// Pairs -//////////////////////////////////////////////////////////////////////////// - -pmt_null::pmt_null() {} -pmt_pair::pmt_pair(const pmt_t& car, const pmt_t& cdr) : d_car(car), d_cdr(cdr) {} - -bool -is_null(const pmt_t& x) -{ - return x == PMT_NIL; -} - -bool -is_pair(const pmt_t& obj) -{ - return obj->is_pair(); -} - -pmt_t -cons(const pmt_t& x, const pmt_t& y) -{ - return pmt_t(new pmt_pair(x, y)); -} - -pmt_t -car(const pmt_t& pair) -{ - pmt_pair* p = dynamic_cast<pmt_pair*>(pair.get()); - if ( p ) - return p->car(); - - throw wrong_type("pmt_car", pair); -} - -pmt_t -cdr(const pmt_t& pair) -{ - pmt_pair* p = dynamic_cast<pmt_pair*>(pair.get()); - if ( p ) - return p->cdr(); - - throw wrong_type("pmt_cdr", pair); -} - -void -set_car(pmt_t pair, pmt_t obj) -{ - if (pair->is_pair()) - _pair(pair)->set_car(obj); - else - throw wrong_type("pmt_set_car", pair); -} - -void -set_cdr(pmt_t pair, pmt_t obj) -{ - if (pair->is_pair()) - _pair(pair)->set_cdr(obj); - else - throw wrong_type("pmt_set_cdr", pair); -} - -//////////////////////////////////////////////////////////////////////////// -// 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 out_of_range("pmt_vector_ref", from_long(k)); - return d_v[k]; -} - -void -pmt_vector::set(size_t k, pmt_t obj) -{ - if (k >= length()) - throw out_of_range("pmt_vector_set", from_long(k)); - d_v[k] = obj; -} - -void -pmt_vector::fill(pmt_t obj) -{ - for (size_t i = 0; i < length(); i++) - d_v[i] = obj; -} - -bool -is_vector(pmt_t obj) -{ - return obj->is_vector(); -} - -pmt_t -make_vector(size_t k, pmt_t fill) -{ - return pmt_t(new pmt_vector(k, fill)); -} - -pmt_t -vector_ref(pmt_t vector, size_t k) -{ - if (!vector->is_vector()) - throw wrong_type("pmt_vector_ref", vector); - return _vector(vector)->ref(k); -} - -void -vector_set(pmt_t vector, size_t k, pmt_t obj) -{ - if (!vector->is_vector()) - throw wrong_type("pmt_vector_set", vector); - _vector(vector)->set(k, obj); -} - -void -vector_fill(pmt_t vector, pmt_t obj) -{ - if (!vector->is_vector()) - throw wrong_type("pmt_vector_set", vector); - _vector(vector)->fill(obj); -} - -//////////////////////////////////////////////////////////////////////////// -// Tuples -//////////////////////////////////////////////////////////////////////////// - -pmt_tuple::pmt_tuple(size_t len) - : d_v(len) -{ -} - -pmt_t -pmt_tuple::ref(size_t k) const -{ - if (k >= length()) - throw out_of_range("pmt_tuple_ref", from_long(k)); - return d_v[k]; -} - -bool -is_tuple(pmt_t obj) -{ - return obj->is_tuple(); -} - -pmt_t -tuple_ref(const pmt_t &tuple, size_t k) -{ - if (!tuple->is_tuple()) - throw wrong_type("pmt_tuple_ref", tuple); - return _tuple(tuple)->ref(k); -} - -// for (i=0; i < 10; i++) -// make_constructor() - -pmt_t -make_tuple() -{ - return pmt_t(new pmt_tuple(0)); -} - -pmt_t -make_tuple(const pmt_t &e0) -{ - pmt_tuple *t = new pmt_tuple(1); - t->_set(0, e0); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1) -{ - pmt_tuple *t = new pmt_tuple(2); - t->_set(0, e0); - t->_set(1, e1); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2) -{ - pmt_tuple *t = new pmt_tuple(3); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3) -{ - pmt_tuple *t = new pmt_tuple(4); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4) -{ - pmt_tuple *t = new pmt_tuple(5); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5) -{ - pmt_tuple *t = new pmt_tuple(6); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - t->_set(5, e5); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6) -{ - pmt_tuple *t = new pmt_tuple(7); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - t->_set(5, e5); - t->_set(6, e6); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7) -{ - pmt_tuple *t = new pmt_tuple(8); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - t->_set(5, e5); - t->_set(6, e6); - t->_set(7, e7); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8) -{ - pmt_tuple *t = new pmt_tuple(9); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - t->_set(5, e5); - t->_set(6, e6); - t->_set(7, e7); - t->_set(8, e8); - return pmt_t(t); -} - -pmt_t -make_tuple(const pmt_t &e0, const pmt_t &e1, const pmt_t &e2, const pmt_t &e3, const pmt_t &e4, const pmt_t &e5, const pmt_t &e6, const pmt_t &e7, const pmt_t &e8, const pmt_t &e9) -{ - pmt_tuple *t = new pmt_tuple(10); - t->_set(0, e0); - t->_set(1, e1); - t->_set(2, e2); - t->_set(3, e3); - t->_set(4, e4); - t->_set(5, e5); - t->_set(6, e6); - t->_set(7, e7); - t->_set(8, e8); - t->_set(9, e9); - return pmt_t(t); -} - -pmt_t -to_tuple(const pmt_t &x) -{ - if (x->is_tuple()) // already one - return x; - - size_t len = length(x); - pmt_tuple *t = new pmt_tuple(len); - pmt_t r = pmt_t(t); - - if (x->is_vector()){ - for (size_t i = 0; i < len; i++) - t->_set(i, _vector(x)->ref(i)); - return r; - } - - if (x->is_pair()){ - pmt_t y = x; - for (size_t i = 0; i < len; i++){ - t->_set(i, car(y)); - y = cdr(y); - } - return r; - } - - throw wrong_type("pmt_to_tuple", x); -} - - - -//////////////////////////////////////////////////////////////////////////// -// Uniform Numeric Vectors -//////////////////////////////////////////////////////////////////////////// - -bool -is_uniform_vector(pmt_t x) -{ - return x->is_uniform_vector(); -} - -const void * -uniform_vector_elements(pmt_t vector, size_t &len) -{ - if (!vector->is_uniform_vector()) - throw wrong_type("pmt_uniform_vector_elements", vector); - return _uniform_vector(vector)->uniform_elements(len); -} - -void * -uniform_vector_writable_elements(pmt_t vector, size_t &len) -{ - if (!vector->is_uniform_vector()) - throw wrong_type("pmt_uniform_vector_writable_elements", vector); - return _uniform_vector(vector)->uniform_writable_elements(len); -} - -//////////////////////////////////////////////////////////////////////////// -// Dictionaries -//////////////////////////////////////////////////////////////////////////// - -/* - * This is an a-list implementation. - * - * When we need better performance for large dictionaries, consider implementing - * persistent Red-Black trees as described in "Purely Functional Data Structures", - * Chris Okasaki, 1998, section 3.3. - */ - -bool -is_dict(const pmt_t &obj) -{ - return is_null(obj) || is_pair(obj); -} - -pmt_t -make_dict() -{ - return PMT_NIL; -} - -pmt_t -dict_add(const pmt_t &dict, const pmt_t &key, const pmt_t &value) -{ - if (is_null(dict)) - return acons(key, value, PMT_NIL); - - if (dict_has_key(dict, key)) - return acons(key, value, dict_delete(dict, key)); - - return acons(key, value, dict); -} - -pmt_t -dict_delete(const pmt_t &dict, const pmt_t &key) -{ - if (is_null(dict)) - return dict; - - if (eqv(caar(dict), key)) - return cdr(dict); - - return cons(car(dict), dict_delete(cdr(dict), key)); -} - -pmt_t -dict_ref(const pmt_t &dict, const pmt_t &key, const pmt_t ¬_found) -{ - pmt_t p = assv(key, dict); // look for (key . value) pair - if (is_pair(p)) - return cdr(p); - else - return not_found; -} - -bool -dict_has_key(const pmt_t &dict, const pmt_t &key) -{ - return is_pair(assv(key, dict)); -} - -pmt_t -dict_items(pmt_t dict) -{ - if (!is_dict(dict)) - throw wrong_type("pmt_dict_values", dict); - - return dict; // equivalent to dict in the a-list case -} - -pmt_t -dict_keys(pmt_t dict) -{ - if (!is_dict(dict)) - throw wrong_type("pmt_dict_keys", dict); - - return map(car, dict); -} - -pmt_t -dict_values(pmt_t dict) -{ - if (!is_dict(dict)) - throw wrong_type("pmt_dict_keys", dict); - - return map(cdr, dict); -} - -//////////////////////////////////////////////////////////////////////////// -// Any -//////////////////////////////////////////////////////////////////////////// - -pmt_any::pmt_any(const boost::any &any) : d_any(any) {} - -bool -is_any(pmt_t obj) -{ - return obj->is_any(); -} - -pmt_t -make_any(const boost::any &any) -{ - return pmt_t(new pmt_any(any)); -} - -boost::any -any_ref(pmt_t obj) -{ - if (!obj->is_any()) - throw wrong_type("pmt_any_ref", obj); - return _any(obj)->ref(); -} - -void -any_set(pmt_t obj, const boost::any &any) -{ - if (!obj->is_any()) - throw wrong_type("pmt_any_set", obj); - _any(obj)->set(any); -} - -//////////////////////////////////////////////////////////////////////////// -// msg_accepter -- built from "any" -//////////////////////////////////////////////////////////////////////////// - -bool -is_msg_accepter(const pmt_t &obj) -{ - if (!is_any(obj)) - return false; - - boost::any r = any_ref(obj); - return boost::any_cast<gruel::msg_accepter_sptr>(&r) != 0; -} - -//! make a msg_accepter -pmt_t -make_msg_accepter(gruel::msg_accepter_sptr ma) -{ - return make_any(ma); -} - -//! Return underlying msg_accepter -gruel::msg_accepter_sptr -msg_accepter_ref(const pmt_t &obj) -{ - try { - return boost::any_cast<gruel::msg_accepter_sptr>(any_ref(obj)); - } - catch (boost::bad_any_cast &e){ - throw wrong_type("pmt_msg_accepter_ref", obj); - } -} - - -//////////////////////////////////////////////////////////////////////////// -// Binary Large Object -- currently a u8vector -//////////////////////////////////////////////////////////////////////////// - -bool -is_blob(pmt_t x) -{ - // return is_u8vector(x); - return is_uniform_vector(x); -} - -pmt_t -make_blob(const void *buf, size_t len_in_bytes) -{ - return init_u8vector(len_in_bytes, (const uint8_t *) buf); -} - -const void * -blob_data(pmt_t blob) -{ - size_t len; - return uniform_vector_elements(blob, len); -} - -size_t -blob_length(pmt_t blob) -{ - size_t len; - uniform_vector_elements(blob, len); - return len; -} - - -//////////////////////////////////////////////////////////////////////////// -// General Functions -//////////////////////////////////////////////////////////////////////////// - -bool -eq(const pmt_t& x, const pmt_t& y) -{ - return x == y; -} - -bool -eqv(const pmt_t& x, const pmt_t& y) -{ - if (x == y) - return true; - - if (x->is_integer() && y->is_integer()) - return _integer(x)->value() == _integer(y)->value(); - - if (x->is_uint64() && y->is_uint64()) - return _uint64(x)->value() == _uint64(y)->value(); - - if (x->is_real() && y->is_real()) - return _real(x)->value() == _real(y)->value(); - - if (x->is_complex() && y->is_complex()) - return _complex(x)->value() == _complex(y)->value(); - - return false; -} - -bool -eqv_raw(pmt_base *x, pmt_base *y) -{ - if (x == y) - return true; - - if (x->is_integer() && y->is_integer()) - return _integer(x)->value() == _integer(y)->value(); - - if (x->is_uint64() && y->is_uint64()) - return _uint64(x)->value() == _uint64(y)->value(); - - if (x->is_real() && y->is_real()) - return _real(x)->value() == _real(y)->value(); - - if (x->is_complex() && y->is_complex()) - return _complex(x)->value() == _complex(y)->value(); - - return false; -} - -bool -equal(const pmt_t& x, const pmt_t& y) -{ - if (eqv(x, y)) - return true; - - if (x->is_pair() && y->is_pair()) - return equal(car(x), car(y)) && equal(cdr(x), cdr(y)); - - if (x->is_vector() && y->is_vector()){ - pmt_vector *xv = _vector(x); - pmt_vector *yv = _vector(y); - if (xv->length() != yv->length()) - return false; - - for (unsigned i = 0; i < xv->length(); i++) - if (!equal(xv->_ref(i), yv->_ref(i))) - return false; - - return true; - } - - if (x->is_tuple() && y->is_tuple()){ - pmt_tuple *xv = _tuple(x); - pmt_tuple *yv = _tuple(y); - if (xv->length() != yv->length()) - return false; - - for (unsigned i = 0; i < xv->length(); i++) - if (!equal(xv->_ref(i), yv->_ref(i))) - return false; - - return true; - } - - if (x->is_uniform_vector() && y->is_uniform_vector()){ - pmt_uniform_vector *xv = _uniform_vector(x); - pmt_uniform_vector *yv = _uniform_vector(y); - if (xv->length() != yv->length()) - return false; - - size_t len_x, len_y; - 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 -length(const pmt_t& x) -{ - if (x->is_vector()) - return _vector(x)->length(); - - if (x->is_uniform_vector()) - return _uniform_vector(x)->length(); - - if (x->is_tuple()) - return _tuple(x)->length(); - - if (x->is_null()) - return 0; - - if (x->is_pair()) { - size_t length=1; - pmt_t it = cdr(x); - while (is_pair(it)){ - length++; - it = cdr(it); - } - if (is_null(it)) - return length; - - // not a proper list - throw wrong_type("pmt_length", x); - } - - // FIXME dictionary length (number of entries) - - throw wrong_type("pmt_length", x); -} - -pmt_t -assq(pmt_t obj, pmt_t alist) -{ - while (is_pair(alist)){ - pmt_t p = car(alist); - if (!is_pair(p)) // malformed alist - return PMT_F; - - if (eq(obj, car(p))) - return p; - - alist = cdr(alist); - } - return PMT_F; -} - -/* - * This avoids a bunch of shared_pointer reference count manipulation. - */ -pmt_t -assv_raw(pmt_base *obj, pmt_base *alist) -{ - while (alist->is_pair()){ - pmt_base *p = ((pmt_pair *)alist)->d_car.get(); - if (!p->is_pair()) // malformed alist - return PMT_F; - - if (eqv_raw(obj, ((pmt_pair *)p)->d_car.get())) - return ((pmt_pair *)alist)->d_car; - - alist = (((pmt_pair *)alist)->d_cdr).get(); - } - return PMT_F; -} - -#if 1 - -pmt_t -assv(pmt_t obj, pmt_t alist) -{ - return assv_raw(obj.get(), alist.get()); -} - -#else - -pmt_t -assv(pmt_t obj, pmt_t alist) -{ - while (is_pair(alist)){ - pmt_t p = car(alist); - if (!is_pair(p)) // malformed alist - return PMT_F; - - if (eqv(obj, car(p))) - return p; - - alist = cdr(alist); - } - return PMT_F; -} - -#endif - - -pmt_t -assoc(pmt_t obj, pmt_t alist) -{ - while (is_pair(alist)){ - pmt_t p = car(alist); - if (!is_pair(p)) // malformed alist - return PMT_F; - - if (equal(obj, car(p))) - return p; - - alist = cdr(alist); - } - return PMT_F; -} - -pmt_t -map(pmt_t proc(const pmt_t&), pmt_t list) -{ - pmt_t r = PMT_NIL; - - while(is_pair(list)){ - r = cons(proc(car(list)), r); - list = cdr(list); - } - - return reverse_x(r); -} - -pmt_t -reverse(pmt_t listx) -{ - pmt_t list = listx; - pmt_t r = PMT_NIL; - - while(is_pair(list)){ - r = cons(car(list), r); - list = cdr(list); - } - if (is_null(list)) - return r; - else - throw wrong_type("pmt_reverse", listx); -} - -pmt_t -reverse_x(pmt_t list) -{ - // FIXME do it destructively - return reverse(list); -} - -pmt_t -nth(size_t n, pmt_t list) -{ - pmt_t t = nthcdr(n, list); - if (is_pair(t)) - return car(t); - else - return PMT_NIL; -} - -pmt_t -nthcdr(size_t n, pmt_t list) -{ - if (!(is_pair(list) || is_null(list))) - throw wrong_type("pmt_nthcdr", list); - - while (n > 0){ - if (is_pair(list)){ - list = cdr(list); - n--; - continue; - } - if (is_null(list)) - return PMT_NIL; - else - throw wrong_type("pmt_nthcdr: not a LIST", list); - } - return list; -} - -pmt_t -memq(pmt_t obj, pmt_t list) -{ - while (is_pair(list)){ - if (eq(obj, car(list))) - return list; - list = cdr(list); - } - return PMT_F; -} - -pmt_t -memv(pmt_t obj, pmt_t list) -{ - while (is_pair(list)){ - if (eqv(obj, car(list))) - return list; - list = cdr(list); - } - return PMT_F; -} - -pmt_t -member(pmt_t obj, pmt_t list) -{ - while (is_pair(list)){ - if (equal(obj, car(list))) - return list; - list = cdr(list); - } - return PMT_F; -} - -bool -subsetp(pmt_t list1, pmt_t list2) -{ - while (is_pair(list1)){ - pmt_t p = car(list1); - if (is_false(memv(p, list2))) - return false; - list1 = cdr(list1); - } - return true; -} - -pmt_t -list1(const pmt_t& x1) -{ - return cons(x1, PMT_NIL); -} - -pmt_t -list2(const pmt_t& x1, const pmt_t& x2) -{ - return cons(x1, cons(x2, PMT_NIL)); -} - -pmt_t -list3(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3) -{ - return cons(x1, cons(x2, cons(x3, PMT_NIL))); -} - -pmt_t -list4(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4) -{ - return cons(x1, cons(x2, cons(x3, cons(x4, PMT_NIL)))); -} - -pmt_t -list5(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5) -{ - return cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, PMT_NIL))))); -} - -pmt_t -list6(const pmt_t& x1, const pmt_t& x2, const pmt_t& x3, const pmt_t& x4, const pmt_t& x5, const pmt_t& x6) -{ - return cons(x1, cons(x2, cons(x3, cons(x4, cons(x5, cons(x6, PMT_NIL)))))); -} - -pmt_t -list_add(pmt_t list, const pmt_t& item) -{ - return reverse(cons(item, reverse(list))); -} - -pmt_t -list_rm(pmt_t list, const pmt_t& item) -{ - if(is_pair(list)){ - pmt_t left = car(list); - pmt_t right = cdr(list); - if(!equal(left, item)){ - return cons(left, list_rm(right, item)); - } else { - return list_rm(right, item); - } - } else { - return list; - } -} - -bool -list_has(pmt_t list, const pmt_t& item) -{ - if(is_pair(list)){ - pmt_t left = car(list); - pmt_t right = cdr(list); - if(equal(left,item)) - return true; - return list_has(right, item); - } else { - if(is_null(list)) - return false; - throw std::runtime_error("list contains invalid format!"); - } -} - -pmt_t -caar(pmt_t pair) -{ - return (car(car(pair))); -} - -pmt_t -cadr(pmt_t pair) -{ - return car(cdr(pair)); -} - -pmt_t -cdar(pmt_t pair) -{ - return cdr(car(pair)); -} - -pmt_t -cddr(pmt_t pair) -{ - return cdr(cdr(pair)); -} - -pmt_t -caddr(pmt_t pair) -{ - return car(cdr(cdr(pair))); -} - -pmt_t -cadddr(pmt_t pair) -{ - return car(cdr(cdr(cdr(pair)))); -} - -bool -is_eof_object(pmt_t obj) -{ - return eq(obj, PMT_EOF); -} - -void -dump_sizeof() -{ - printf("sizeof(pmt_t) = %3zd\n", sizeof(pmt_t)); - printf("sizeof(pmt_base) = %3zd\n", sizeof(pmt_base)); - printf("sizeof(pmt_bool) = %3zd\n", sizeof(pmt_bool)); - printf("sizeof(pmt_symbol) = %3zd\n", sizeof(pmt_symbol)); - printf("sizeof(pmt_integer) = %3zd\n", sizeof(pmt_integer)); - printf("sizeof(pmt_uint64) = %3zd\n", sizeof(pmt_uint64)); - printf("sizeof(pmt_real) = %3zd\n", sizeof(pmt_real)); - printf("sizeof(pmt_complex) = %3zd\n", sizeof(pmt_complex)); - printf("sizeof(pmt_null) = %3zd\n", sizeof(pmt_null)); - printf("sizeof(pmt_pair) = %3zd\n", sizeof(pmt_pair)); - printf("sizeof(pmt_vector) = %3zd\n", sizeof(pmt_vector)); - printf("sizeof(pmt_uniform_vector) = %3zd\n", sizeof(pmt_uniform_vector)); -} - -} /* namespace pmt */ diff --git a/gruel/src/lib/pmt/pmt_int.h b/gruel/src/lib/pmt/pmt_int.h deleted file mode 100644 index d669e10491..0000000000 --- a/gruel/src/lib/pmt/pmt_int.h +++ /dev/null @@ -1,247 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006,2009,2010 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 <gruel/pmt.h> -#include <boost/utility.hpp> -#include <boost/detail/atomic_count.hpp> - -/* - * 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 GRUEL_API pmt_base : boost::noncopyable { - mutable boost::detail::atomic_count count_; - -protected: - pmt_base() : count_(0) {}; - 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_uint64() 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_tuple() 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; } - - friend void intrusive_ptr_add_ref(pmt_base* p); - friend void intrusive_ptr_release(pmt_base* p); - -# 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 -{ -public: - long d_value; - - pmt_integer(long value); - //~pmt_integer(){} - - bool is_number() const { return true; } - bool is_integer() const { return true; } - long value() const { return d_value; } -}; - -class pmt_uint64 : public pmt_base -{ -public: - uint64_t d_value; - - pmt_uint64(uint64_t value); - //~pmt_uint64(){} - - bool is_number() const { return true; } - bool is_uint64() const { return true; } - uint64_t value() const { return d_value; } -}; - -class pmt_real : public pmt_base -{ -public: - double d_value; - - pmt_real(double value); - //~pmt_real(){} - - bool is_number() const { return true; } - bool is_real() const { return true; } - double value() const { return d_value; } -}; - -class pmt_complex : public pmt_base -{ -public: - std::complex<double> d_value; - - pmt_complex(std::complex<double> value); - //~pmt_complex(){} - - bool is_number() const { return true; } - bool is_complex() const { return true; } - std::complex<double> value() const { return d_value; } -}; - -class pmt_null : public pmt_base -{ -public: - pmt_null(); - //~pmt_null(){} - - bool is_null() const { return true; } -}; - -class pmt_pair : public pmt_base -{ -public: - pmt_t d_car; - pmt_t d_cdr; - - pmt_pair(const pmt_t& car, const pmt_t& cdr); - //~pmt_pair(){}; - - bool is_pair() const { return true; } - pmt_t car() const { return d_car; } - pmt_t cdr() const { return d_cdr; } - - void set_car(pmt_t car) { d_car = car; } - void set_cdr(pmt_t cdr) { d_cdr = cdr; } -}; - -class pmt_vector : public pmt_base -{ - std::vector<pmt_t> 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_tuple : public pmt_base -{ - std::vector<pmt_t> d_v; - -public: - pmt_tuple(size_t len); - //~pmt_tuple(); - - bool is_tuple() const { return true; } - pmt_t ref(size_t k) const; - size_t length() const { return d_v.size(); } - - pmt_t _ref(size_t k) const { return d_v[k]; } - void _set(size_t k, pmt_t v) { d_v[k] = v; } -}; - -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 deleted file mode 100644 index 2e853b9147..0000000000 --- a/gruel/src/lib/pmt/pmt_io.cc +++ /dev/null @@ -1,168 +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 <config.h> -#endif -#include <vector> -#include <gruel/pmt.h> -#include "pmt_int.h" -#include <sstream> -#include <iostream> - -namespace pmt { - -static void -write_list_tail(pmt_t obj, std::ostream &port) -{ - write(car(obj), port); // write the car - obj = cdr(obj); // step to cdr - - if (is_null(obj)) // () - port << ")"; - - else if (is_pair(obj)){ // normal list - port << " "; - write_list_tail(obj, port); - } - else { // dotted pair - port << " . "; - write(obj, port); - port << ")"; - } -} - -void -write(pmt_t obj, std::ostream &port) -{ - if (is_bool(obj)){ - if (is_true(obj)) - port << "#t"; - else - port << "#f"; - } - else if (is_symbol(obj)){ - port << symbol_to_string(obj); - } - else if (is_number(obj)){ - if (is_integer(obj)) - port << to_long(obj); - else if (is_uint64(obj)) - port << to_uint64(obj); - else if (is_real(obj)) - port << to_double(obj); - else if (is_complex(obj)){ - std::complex<double> c = to_complex(obj); - port << c.real() << '+' << c.imag() << 'i'; - } - else - goto error; - } - else if (is_null(obj)){ - port << "()"; - } - else if (is_pair(obj)){ - port << "("; - write_list_tail(obj, port); - } - else if (is_tuple(obj)){ - port << "{"; - size_t len = length(obj); - if (len > 0){ - port << tuple_ref(obj, 0); - for (size_t i = 1; i < len; i++) - port << " " << tuple_ref(obj, i); - } - port << "}"; - } - else if (is_vector(obj)){ - port << "#("; - size_t len = length(obj); - if (len > 0){ - port << vector_ref(obj, 0); - for (size_t i = 1; i < len; i++) - port << " " << vector_ref(obj, i); - } - port << ")"; - } - else if (is_dict(obj)){ - // FIXME - // port << "#<dict " << obj << ">"; - port << "#<dict>"; - } - else if (is_uniform_vector(obj)){ - // FIXME - // port << "#<uniform-vector " << obj << ">"; - port << "#<uniform-vector>"; - } - else { - error: - // FIXME - // port << "#<" << obj << ">"; - port << "#<unknown>"; - } -} - -std::ostream& operator<<(std::ostream &os, pmt_t obj) -{ - write(obj, os); - return os; -} - -std::string -write_string(pmt_t obj) -{ - std::ostringstream s; - s << obj; - return s.str(); -} - -pmt_t -read(std::istream &port) -{ - throw notimplemented("notimplemented: pmt::read", PMT_NIL); -} - -void -serialize(pmt_t obj, std::ostream &sink) -{ - throw notimplemented("notimplemented: pmt::serialize", obj); -} - -/*! - * \brief Create obj from portable byte-serial representation - */ -pmt_t -deserialize(std::istream &source) -{ - throw notimplemented("notimplemented: pmt::deserialize", PMT_NIL); -} - -} /* namespace pmt */ - - -void -pmt::print(pmt_t v) -{ - std::cout << write_string(v) << std::endl; -} - - diff --git a/gruel/src/lib/pmt/pmt_pool.cc b/gruel/src/lib/pmt/pmt_pool.cc deleted file mode 100644 index 63a681abff..0000000000 --- a/gruel/src/lib/pmt/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 <config.h> -#endif -#include <gruel/pmt_pool.h> -#include <algorithm> -#include <stdint.h> - -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 deleted file mode 100644 index 2c74f30b01..0000000000 --- a/gruel/src/lib/pmt/pmt_serialize.cc +++ /dev/null @@ -1,834 +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 <config.h> -#endif -#include <vector> -#include <gruel/pmt.h> -#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(); -} - -static bool -serialize_untagged_f64(double i, std::streambuf &sb) -{ - typedef union { - double id; - uint64_t ii; - } iu_t; - iu_t iu; - iu.id = i; - sb.sputc((iu.ii >> 56) & 0xff); - sb.sputc((iu.ii >> 48) & 0xff); - sb.sputc((iu.ii >> 40) & 0xff); - sb.sputc((iu.ii >> 32) & 0xff); - sb.sputc((iu.ii >> 24) & 0xff); - sb.sputc((iu.ii >> 16) & 0xff); - sb.sputc((iu.ii >> 8) & 0xff); - return sb.sputc((iu.ii >> 0) & 0xff) != std::streambuf::traits_type::eof(); -} - - -// 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(); -} - -// ---------------------------------------------------------------- -// 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(); -} - -// 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(); -} - -static bool -deserialize_untagged_f64(double *ip, std::streambuf &sb) -{ - std::streambuf::traits_type::int_type t; - - typedef union { - double id; - uint64_t ii; - } iu_t; - - iu_t iu; - - t = sb.sbumpc(); - iu.ii = t & 0xff; - - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - t = sb.sbumpc(); - iu.ii = (iu.ii<<8) | (t & 0xff); - - *ip = iu.id; - return t != std::streambuf::traits_type::eof(); -} - -static bool -deserialize_tuple(pmt_t *tuple, std::streambuf &sb) -{ - uint32_t nitems; - bool ok = deserialize_untagged_u32(&nitems, sb); - pmt_t list(PMT_NIL); - for(uint32_t i=0; i<nitems; i++) { - pmt_t item = deserialize(sb); - if(eq(list, PMT_NIL)) { - list = list1(item); - } - else { - list = list_add(list, item); - } - } - (*tuple) = to_tuple(list); - return ok; -} - - -/* - * Write portable byte-serial representation of \p obj to \p sb - * - * N.B., Circular structures cause infinite recursion. - */ -bool -serialize(pmt_t obj, std::streambuf &sb) -{ - bool ok = true; - - tail_recursion: - - if(is_bool(obj)) { - if(eq(obj, PMT_T)) - return serialize_untagged_u8(PST_TRUE, sb); - else - return serialize_untagged_u8(PST_FALSE, sb); - } - - if(is_null(obj)) - return serialize_untagged_u8(PST_NULL, sb); - - if(is_symbol(obj)) { - const std::string s = symbol_to_string(obj); - size_t len = s.size(); - ok = serialize_untagged_u8(PST_SYMBOL, sb); - ok &= serialize_untagged_u16(len, sb); - for(size_t i = 0; i < len; i++) - ok &= serialize_untagged_u8(s[i], sb); - return ok; - } - - if(is_pair(obj)) { - ok = serialize_untagged_u8(PST_PAIR, sb); - ok &= serialize(car(obj), sb); - if(!ok) - return false; - obj = cdr(obj); - goto tail_recursion; - } - - if(is_number(obj)) { - - if(is_uint64(obj)) { - uint64_t i = to_uint64(obj); - ok = serialize_untagged_u8(PST_UINT64, sb); - ok &= serialize_untagged_u64(i, sb); - return ok; - } - else { - if(is_integer(obj)) { - long i = to_long(obj); - if(sizeof(long) > 4) { - if(i < -2147483647 || i > 2147483647) - throw notimplemented("pmt::serialize (64-bit integers)", obj); - } - ok = serialize_untagged_u8(PST_INT32, sb); - ok &= serialize_untagged_u32(i, sb); - return ok; - } - } - - if(is_real(obj)) { - float i = to_double(obj); - ok = serialize_untagged_u8(PST_DOUBLE, sb); - ok &= serialize_untagged_f64(i, sb); - return ok; - } - - if(is_complex(obj)) { - std::complex<double> i = to_complex(obj); - ok = serialize_untagged_u8(PST_COMPLEX, sb); - ok &= serialize_untagged_f64(i.real(), sb); - ok &= serialize_untagged_f64(i.imag(), sb); - return ok; - } - } - - if(is_vector(obj)) { - size_t vec_len = pmt::length(obj); - ok = serialize_untagged_u8(PST_VECTOR, sb); - ok &= serialize_untagged_u32(vec_len, sb); - for(size_t i=0; i<vec_len; i++) { - ok &= serialize(vector_ref(obj, i), sb); - } - return ok; - } - - if(is_uniform_vector(obj)) { - size_t npad = 1; - size_t vec_len = pmt::length(obj); - - if(is_u8vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_U8, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u8(u8vector_ref(obj, i), sb); - } - return ok; - } - - if(is_s8vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_S8, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u8(s8vector_ref(obj, i), sb); - } - return ok; - } - - if(is_u16vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_U16, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u16(u16vector_ref(obj, i), sb); - } - return ok; - } - - if(is_s16vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_S16, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u16(s16vector_ref(obj, i), sb); - } - return ok; - } - - if(is_u32vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_U32, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u32(u32vector_ref(obj, i), sb); - } - return ok; - } - - if(is_s32vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_S32, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u32(s32vector_ref(obj, i), sb); - } - return ok; - } - - if(is_u64vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_U64, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u64(u64vector_ref(obj, i), sb); - } - return ok; - } - - if(is_s64vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_S64, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_u64(s64vector_ref(obj, i), sb); - } - return ok; - } - - if(is_f32vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_F32, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_f64(f32vector_ref(obj, i), sb); - } - return ok; - } - - if(is_f64vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_F64, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - ok &= serialize_untagged_f64(f64vector_ref(obj, i), sb); - } - return ok; - } - - if(is_c32vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_C32, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - std::complex<float> c = c32vector_ref(obj, i); - ok &= serialize_untagged_f64(c.real(), sb); - ok &= serialize_untagged_f64(c.imag(), sb); - } - return ok; - } - - if(is_c64vector(obj)) { - ok = serialize_untagged_u8(PST_UNIFORM_VECTOR, sb); - ok &= serialize_untagged_u8(UVI_C64, sb); - ok &= serialize_untagged_u32(vec_len, sb); - ok &= serialize_untagged_u8(npad, sb); - for(size_t i=0; i<npad; i++) { - ok &= serialize_untagged_u8(0, sb); - } - for(size_t i=0; i<vec_len; i++) { - std::complex<double> c = c64vector_ref(obj, i); - ok &= serialize_untagged_f64(c.real(), sb); - ok &= serialize_untagged_f64(c.imag(), sb); - } - return ok; - } - } - - if (is_dict(obj)) - throw notimplemented("pmt::serialize (dict)", obj); - - if (is_tuple(obj)){ - size_t tuple_len = pmt::length(obj); - ok = serialize_untagged_u8(PST_TUPLE, sb); - ok &= serialize_untagged_u32(tuple_len, sb); - for(size_t i=0; i<tuple_len; i++){ - ok &= serialize(tuple_ref(obj, i), sb); - } - return ok; - } - //throw pmt_notimplemented("pmt::serialize (tuple)", obj); - - throw notimplemented("pmt::serialize (?)", obj); -} - -/* - * 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 -deserialize(std::streambuf &sb) -{ - uint8_t tag; - uint8_t u8; - uint16_t u16; - uint32_t u32; - uint64_t u64; - double f64; - 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 notimplemented("pmt::deserialize: very long symbol", - PMT_F); - if (sb.sgetn(tmpbuf, u16) != u16) - goto error; - return intern(std::string(tmpbuf, u16)); - - case PST_INT32: - if (!deserialize_untagged_u32(&u32, sb)) - goto error; - return from_long((int32_t) u32); - - case PST_UINT64: - if(!deserialize_untagged_u64(&u64, sb)) - goto error; - return from_uint64(u64); - - case PST_PAIR: - return parse_pair(sb); - - case PST_DOUBLE: - if(!deserialize_untagged_f64(&f64, sb)) - goto error; - return from_double( f64 ); - - case PST_COMPLEX: - { - double r,i; - if(!deserialize_untagged_f64(&r, sb) && !deserialize_untagged_f64(&i, sb)) - goto error; - return make_rectangular( r,i ); - } - - case PST_TUPLE: - { - pmt_t tuple; - if(!deserialize_tuple(&tuple, sb)){ - goto error; - } - return tuple; - } - - case PST_VECTOR: - { - uint32_t nitems; - if(!deserialize_untagged_u32(&nitems, sb)) - goto error; - pmt_t vec = make_vector(nitems, PMT_NIL); - for(uint32_t i=0; i<nitems; i++) { - pmt_t item = deserialize(sb); - vector_set(vec, i, item); - } - return vec; - } - - case PST_UNIFORM_VECTOR: - { - uint8_t utag, npad; - uint32_t nitems; - - if(!deserialize_untagged_u8(&utag, sb)) - return PMT_EOF; - - if(!deserialize_untagged_u32(&nitems, sb)) - goto error; - - deserialize_untagged_u8(&npad, sb); - for(size_t i; i < npad; i++) - deserialize_untagged_u8(&u8, sb); - - switch(utag) { - case(UVI_U8): - { - pmt_t vec = make_u8vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u8(&u8, sb); - u8vector_set(vec, i, u8); - } - return vec; - } - case(UVI_S8): - { - pmt_t vec = make_s8vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u8(&u8, sb); - s8vector_set(vec, i, u8); - } - return vec; - } - case(UVI_U16): - { - pmt_t vec = make_u16vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u16(&u16, sb); - u16vector_set(vec, i, u16); - } - return vec; - } - case(UVI_S16): - { - pmt_t vec = make_s16vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u16(&u16, sb); - s16vector_set(vec, i, u16); - } - return vec; - } - case(UVI_U32): - { - pmt_t vec = make_u32vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u32(&u32, sb); - u32vector_set(vec, i, u32); - } - return vec; - } - case(UVI_S32): - { - pmt_t vec = make_s32vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u32(&u32, sb); - s32vector_set(vec, i, u32); - } - return vec; - } - case(UVI_U64): - { - pmt_t vec = make_u64vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u64(&u64, sb); - u64vector_set(vec, i, u64); - } - return vec; - } - case(UVI_S64): - { - pmt_t vec = make_s64vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_u64(&u64, sb); - s64vector_set(vec, i, u64); - } - return vec; - } - case(UVI_F32): - { - pmt_t vec = make_f32vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_f64(&f64, sb); - f32vector_set(vec, i, static_cast<float>(f64)); - } - return vec; - } - case(UVI_F64): - { - pmt_t vec = make_f64vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - deserialize_untagged_f64(&f64, sb); - f64vector_set(vec, i, f64); - } - return vec; - } - case(UVI_C32): - { - pmt_t vec = make_c32vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - float re, im; - deserialize_untagged_f64(&f64, sb); - re = static_cast<float>(f64); - deserialize_untagged_f64(&f64, sb); - im = static_cast<float>(f64); - c32vector_set(vec, i, std::complex<float>(re, im)); - } - return vec; - } - - case(UVI_C64): - { - pmt_t vec = make_c64vector(nitems, 0); - for(uint32_t i=0; i<nitems; i++) { - double re, im; - deserialize_untagged_f64(&f64, sb); - re = f64; - deserialize_untagged_f64(&f64, sb); - im = f64; - c64vector_set(vec, i, std::complex<double>(re, im)); - } - return vec; - } - - default: - throw exception("pmt::deserialize: malformed input stream, tag value = ", - from_long(tag)); - } - } - - case PST_DICT: - case PST_COMMENT: - throw notimplemented("pmt::deserialize: tag value = ", - from_long(tag)); - - default: - throw exception("pmt::deserialize: malformed input stream, tag value = ", - from_long(tag)); - } - - error: - throw exception("pmt::deserialize: malformed input stream", PMT_F); -} - - -/* - * provide a simple string accessor to the serialized pmt form - */ -std::string -serialize_str(pmt_t obj){ - std::stringbuf sb; - serialize(obj, sb); - return sb.str(); -} - - -/* - * provide a simple string accessor to the deserialized pmt form - */ -pmt_t -deserialize_str(std::string s){ - std::stringbuf sb(s); - return deserialize(sb); -} - - -/* - * 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 = deserialize(sb); // read the car - - nptr = cons(expr, PMT_NIL); // build new cell - if (is_null(lastnptr)) - val = nptr; - else - set_cdr(lastnptr, nptr); - lastnptr = nptr; - - if (!deserialize_untagged_u8(&tag, sb)) // get tag of cdr - throw exception("pmt::deserialize: malformed input stream", PMT_F); - - if (tag == PST_PAIR) - continue; // keep on looping... - - if (tag == PST_NULL){ - expr = PMT_NIL; - break; - } - - // - // default: push tag back and use pmt_deserialize to get the cdr - // - sb.sungetc(); - expr = deserialize(sb); - break; - } - - // - // At this point, expr contains the value of the final cdr in the list. - // - set_cdr(lastnptr, expr); - return val; -} - -} /* namespace pmt */ diff --git a/gruel/src/lib/pmt/qa_pmt.cc b/gruel/src/lib/pmt/qa_pmt.cc deleted file mode 100644 index 27c617e747..0000000000 --- a/gruel/src/lib/pmt/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 <qa_pmt.h> -#include <qa_pmt_prims.h> -#include <qa_pmt_unv.h> - -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 deleted file mode 100644 index 3de5872c74..0000000000 --- a/gruel/src/lib/pmt/qa_pmt.h +++ /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. - */ - -#ifndef INCLUDED_QA_PMT_H -#define INCLUDED_QA_PMT_H - -#include <gruel/attributes.h> -#include <cppunit/TestSuite.h> - -//! collect all the tests for pmt - -class __GR_ATTR_EXPORT 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 deleted file mode 100644 index 85d29cf78f..0000000000 --- a/gruel/src/lib/pmt/qa_pmt_prims.cc +++ /dev/null @@ -1,601 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006,2009,2010 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 <qa_pmt_prims.h> -#include <cppunit/TestAssert.h> -#include <gruel/msg_passing.h> -#include <boost/format.hpp> -#include <cstdio> -#include <cstring> -#include <sstream> - -void -qa_pmt_prims::test_symbols() -{ - CPPUNIT_ASSERT(!pmt::is_symbol(pmt::PMT_T)); - CPPUNIT_ASSERT(!pmt::is_symbol(pmt::PMT_F)); - CPPUNIT_ASSERT_THROW(pmt::symbol_to_string(pmt::PMT_F), pmt::wrong_type); - - pmt::pmt_t sym1 = pmt::mp("test"); - CPPUNIT_ASSERT(pmt::is_symbol(sym1)); - CPPUNIT_ASSERT_EQUAL(std::string("test"), pmt::symbol_to_string(sym1)); - CPPUNIT_ASSERT(pmt::is_true(sym1)); - CPPUNIT_ASSERT(!pmt::is_false(sym1)); - - pmt::pmt_t sym2 = pmt::mp("foo"); - pmt::pmt_t sym3 = pmt::mp("test"); - CPPUNIT_ASSERT_EQUAL(sym1, sym3); - CPPUNIT_ASSERT(sym1 != sym2); - CPPUNIT_ASSERT(sym1 == sym3); - - static const int N = 2048; - std::vector<pmt::pmt_t> v1(N); - std::vector<pmt::pmt_t> v2(N); - - // generate a bunch of symbols - for (int i = 0; i < N; i++){ - std::string buf = str(boost::format("test-%d") % i); - v1[i] = pmt::mp(buf.c_str()); - } - - // confirm that they are all unique - for (int i = 0; i < N; i++) - for (int j = i + 1; j < N; j++) - CPPUNIT_ASSERT(v1[i] != v1[j]); - - // generate the same symbols again - for (int i = 0; i < N; i++){ - std::string buf = str(boost::format("test-%d") % i); - v2[i] = pmt::mp(buf.c_str()); - } - - // confirm that we get the same ones back - for (int i = 0; i < N; i++) - CPPUNIT_ASSERT(v1[i] == v2[i]); -} - -void -qa_pmt_prims::test_booleans() -{ - pmt::pmt_t sym = pmt::mp("test"); - CPPUNIT_ASSERT(pmt::is_bool(pmt::PMT_T)); - CPPUNIT_ASSERT(pmt::is_bool(pmt::PMT_F)); - CPPUNIT_ASSERT(!pmt::is_bool(sym)); - CPPUNIT_ASSERT_EQUAL(pmt::from_bool(false), pmt::PMT_F); - CPPUNIT_ASSERT_EQUAL(pmt::from_bool(true), pmt::PMT_T); - CPPUNIT_ASSERT_EQUAL(false, pmt::to_bool(pmt::PMT_F)); - CPPUNIT_ASSERT_EQUAL(true, pmt::to_bool(pmt::PMT_T)); - CPPUNIT_ASSERT_THROW(pmt::to_bool(sym), pmt::wrong_type); -} - -void -qa_pmt_prims::test_integers() -{ - pmt::pmt_t p1 = pmt::from_long(1); - pmt::pmt_t m1 = pmt::from_long(-1); - CPPUNIT_ASSERT(!pmt::is_integer(pmt::PMT_T)); - CPPUNIT_ASSERT(pmt::is_integer(p1)); - CPPUNIT_ASSERT(pmt::is_integer(m1)); - CPPUNIT_ASSERT_THROW(pmt::to_long(pmt::PMT_T), pmt::wrong_type); - CPPUNIT_ASSERT_EQUAL(-1L, pmt::to_long(m1)); - CPPUNIT_ASSERT_EQUAL(1L, pmt::to_long(p1)); -} - -void -qa_pmt_prims::test_uint64s() -{ - pmt::pmt_t p1 = pmt::from_uint64((uint64_t)1); - pmt::pmt_t m1 = pmt::from_uint64((uint64_t)8589934592ULL); - CPPUNIT_ASSERT(!pmt::is_uint64(pmt::PMT_T)); - CPPUNIT_ASSERT(pmt::is_uint64(p1)); - CPPUNIT_ASSERT(pmt::is_uint64(m1)); - CPPUNIT_ASSERT_THROW(pmt::to_uint64(pmt::PMT_T), pmt::wrong_type); - CPPUNIT_ASSERT_EQUAL((uint64_t)8589934592ULL, (uint64_t)pmt::to_uint64(m1)); - CPPUNIT_ASSERT_EQUAL((uint64_t)1ULL, (uint64_t)pmt::to_uint64(p1)); -} - -void -qa_pmt_prims::test_reals() -{ - pmt::pmt_t p1 = pmt::from_double(1); - pmt::pmt_t m1 = pmt::from_double(-1); - CPPUNIT_ASSERT(!pmt::is_real(pmt::PMT_T)); - CPPUNIT_ASSERT(pmt::is_real(p1)); - CPPUNIT_ASSERT(pmt::is_real(m1)); - CPPUNIT_ASSERT_THROW(pmt::to_double(pmt::PMT_T), pmt::wrong_type); - CPPUNIT_ASSERT_EQUAL(-1.0, pmt::to_double(m1)); - CPPUNIT_ASSERT_EQUAL(1.0, pmt::to_double(p1)); - CPPUNIT_ASSERT_EQUAL(1.0, pmt::to_double(pmt::from_long(1))); -} - -void -qa_pmt_prims::test_complexes() -{ - pmt::pmt_t p1 = pmt::make_rectangular(2, -3); - pmt::pmt_t m1 = pmt::make_rectangular(-3, 2); - pmt::pmt_t p2 = pmt::from_complex(2, -3); - pmt::pmt_t m2 = pmt::from_complex(-3, 2); - pmt::pmt_t p3 = pmt::from_complex(std::complex<double>(2, -3)); - pmt::pmt_t m3 = pmt::from_complex(std::complex<double>(-3, 2)); - CPPUNIT_ASSERT(!pmt::is_complex(pmt::PMT_T)); - CPPUNIT_ASSERT(pmt::is_complex(p1)); - CPPUNIT_ASSERT(pmt::is_complex(m1)); - CPPUNIT_ASSERT(pmt::is_complex(p2)); - CPPUNIT_ASSERT(pmt::is_complex(m2)); - CPPUNIT_ASSERT(pmt::is_complex(p3)); - CPPUNIT_ASSERT(pmt::is_complex(m3)); - CPPUNIT_ASSERT_THROW(pmt::to_complex(pmt::PMT_T), pmt::wrong_type); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p1)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m1)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p2)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m2)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, -3), pmt::to_complex(p3)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(-3, 2), pmt::to_complex(m3)); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt::to_complex(pmt::from_long(1))); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(1.0, 0), pmt::to_complex(pmt::from_double(1.0))); -} - -void -qa_pmt_prims::test_pairs() -{ - CPPUNIT_ASSERT(pmt::is_null(pmt::PMT_NIL)); - CPPUNIT_ASSERT(!pmt::is_pair(pmt::PMT_NIL)); - pmt::pmt_t s1 = pmt::mp("s1"); - pmt::pmt_t s2 = pmt::mp("s2"); - pmt::pmt_t s3 = pmt::mp("s3"); - - - CPPUNIT_ASSERT_EQUAL((size_t)0, pmt::length(pmt::PMT_NIL)); - CPPUNIT_ASSERT_THROW(pmt::length(s1), pmt::wrong_type); - CPPUNIT_ASSERT_THROW(pmt::length(pmt::from_double(42)), pmt::wrong_type); - - pmt::pmt_t c1 = pmt::cons(s1, pmt::PMT_NIL); - CPPUNIT_ASSERT(pmt::is_pair(c1)); - CPPUNIT_ASSERT(!pmt::is_pair(s1)); - CPPUNIT_ASSERT_EQUAL(s1, pmt::car(c1)); - CPPUNIT_ASSERT_EQUAL(pmt::PMT_NIL, pmt::cdr(c1)); - CPPUNIT_ASSERT_EQUAL((size_t) 1, pmt::length(c1)); - - pmt::pmt_t c3 = pmt::cons(s3, pmt::PMT_NIL); - pmt::pmt_t c2 = pmt::cons(s2, c3); - pmt::set_cdr(c1, c2); - CPPUNIT_ASSERT_EQUAL(c2, pmt::cdr(c1)); - pmt::set_car(c1, s3); - CPPUNIT_ASSERT_EQUAL(s3, pmt::car(c1)); - CPPUNIT_ASSERT_EQUAL((size_t)1, pmt::length(c3)); - CPPUNIT_ASSERT_EQUAL((size_t)2, pmt::length(c2)); - - CPPUNIT_ASSERT_THROW(pmt::cdr(pmt::PMT_NIL), pmt::wrong_type); - CPPUNIT_ASSERT_THROW(pmt::car(pmt::PMT_NIL), pmt::wrong_type); - CPPUNIT_ASSERT_THROW(pmt::set_car(s1, pmt::PMT_NIL), pmt::wrong_type); - CPPUNIT_ASSERT_THROW(pmt::set_cdr(s1, pmt::PMT_NIL), pmt::wrong_type); -} - -void -qa_pmt_prims::test_vectors() -{ - static const size_t N = 3; - pmt::pmt_t v1 = pmt::make_vector(N, pmt::PMT_NIL); - CPPUNIT_ASSERT_EQUAL(N, pmt::length(v1)); - pmt::pmt_t s0 = pmt::mp("s0"); - pmt::pmt_t s1 = pmt::mp("s1"); - pmt::pmt_t s2 = pmt::mp("s2"); - - pmt::vector_set(v1, 0, s0); - pmt::vector_set(v1, 1, s1); - pmt::vector_set(v1, 2, s2); - - 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::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)); -} - -static void -check_tuple(size_t len, const std::vector<pmt::pmt_t> &s, pmt::pmt_t t) -{ - CPPUNIT_ASSERT_EQUAL(true, pmt::is_tuple(t)); - CPPUNIT_ASSERT_EQUAL(len, pmt::length(t)); - - for (size_t i = 0; i < len; i++) - CPPUNIT_ASSERT_EQUAL(s[i], pmt::tuple_ref(t, i)); - -} - -void -qa_pmt_prims::test_tuples() -{ - pmt::pmt_t v = pmt::make_vector(10, pmt::PMT_NIL); - std::vector<pmt::pmt_t> s(10); - for (size_t i = 0; i < 10; i++){ - std::ostringstream os; - os << "s" << i; - s[i] = pmt::mp(os.str()); - pmt::vector_set(v, i, s[i]); - } - - - pmt::pmt_t t; - - t = pmt::make_tuple(); - check_tuple(0, s, t); - - t = pmt::make_tuple(s[0]); - check_tuple(1, s, t); - - CPPUNIT_ASSERT(pmt::is_vector(v)); - CPPUNIT_ASSERT(!pmt::is_tuple(v)); - CPPUNIT_ASSERT(pmt::is_tuple(t)); - CPPUNIT_ASSERT(!pmt::is_vector(t)); - - t = pmt::make_tuple(s[0], s[1]); - check_tuple(2, s, t); - - t = pmt::make_tuple(s[0], s[1], s[2]); - check_tuple(3, s, t); - - t = pmt::make_tuple(s[0], s[1], s[2], s[3]); - check_tuple(4, s, t); - - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4]); - check_tuple(5, s, t); - - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5]); - check_tuple(6, s, t); - - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6]); - check_tuple(7, s, t); - - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7]); - check_tuple(8, s, t); - - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8]); - check_tuple(9, s, t); - - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]); - check_tuple(10, s, t); - - t = pmt::make_tuple(s[0], s[1], s[2]); - CPPUNIT_ASSERT_THROW(pmt::tuple_ref(t, 3), pmt::out_of_range); - CPPUNIT_ASSERT_THROW(pmt::vector_ref(t, 0), pmt::wrong_type); - CPPUNIT_ASSERT_THROW(pmt::tuple_ref(v, 0), pmt::wrong_type); - - t = pmt::make_tuple(s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], s[8], s[9]); - pmt::pmt_t t2 = pmt::to_tuple(v); - CPPUNIT_ASSERT_EQUAL(size_t(10), pmt::length(v)); - CPPUNIT_ASSERT(pmt::equal(t, t2)); - //std::cout << v << std::endl; - //std::cout << t2 << std::endl; - - - t = pmt::make_tuple(s[0], s[1], s[2]); - pmt::pmt_t list0 = pmt::list3(s[0], s[1], s[2]); - CPPUNIT_ASSERT_EQUAL(size_t(3), pmt::length(list0)); - t2 = pmt::to_tuple(list0); - CPPUNIT_ASSERT_EQUAL(size_t(3), pmt::length(t2)); - CPPUNIT_ASSERT(pmt::equal(t, t2)); -} - -void -qa_pmt_prims::test_equivalence() -{ - pmt::pmt_t s0 = pmt::mp("s0"); - pmt::pmt_t s1 = pmt::mp("s1"); - pmt::pmt_t s2 = pmt::mp("s2"); - pmt::pmt_t list0 = pmt::cons(s0, pmt::cons(s1, pmt::cons(s2, pmt::PMT_NIL))); - pmt::pmt_t list1 = pmt::cons(s0, pmt::cons(s1, pmt::cons(s2, pmt::PMT_NIL))); - pmt::pmt_t i0 = pmt::from_long(42); - pmt::pmt_t i1 = pmt::from_long(42); - pmt::pmt_t r0 = pmt::from_double(42); - pmt::pmt_t r1 = pmt::from_double(42); - pmt::pmt_t r2 = pmt::from_double(43); - - CPPUNIT_ASSERT(pmt::eq(s0, s0)); - CPPUNIT_ASSERT(!pmt::eq(s0, s1)); - CPPUNIT_ASSERT(pmt::eqv(s0, s0)); - CPPUNIT_ASSERT(!pmt::eqv(s0, s1)); - - CPPUNIT_ASSERT(pmt::eqv(i0, i1)); - CPPUNIT_ASSERT(pmt::eqv(r0, r1)); - CPPUNIT_ASSERT(!pmt::eqv(r0, r2)); - CPPUNIT_ASSERT(!pmt::eqv(i0, r0)); - - CPPUNIT_ASSERT(!pmt::eq(list0, list1)); - CPPUNIT_ASSERT(!pmt::eqv(list0, list1)); - CPPUNIT_ASSERT(pmt::equal(list0, list1)); - - pmt::pmt_t v0 = pmt::make_vector(3, s0); - pmt::pmt_t v1 = pmt::make_vector(3, s0); - pmt::pmt_t v2 = pmt::make_vector(4, s0); - CPPUNIT_ASSERT(!pmt::eqv(v0, v1)); - CPPUNIT_ASSERT(pmt::equal(v0, v1)); - CPPUNIT_ASSERT(!pmt::equal(v0, v2)); - - pmt::vector_set(v0, 0, list0); - pmt::vector_set(v0, 1, list0); - pmt::vector_set(v1, 0, list1); - pmt::vector_set(v1, 1, list1); - CPPUNIT_ASSERT(pmt::equal(v0, v1)); -} - -void -qa_pmt_prims::test_misc() -{ - pmt::pmt_t k0 = pmt::mp("k0"); - pmt::pmt_t k1 = pmt::mp("k1"); - pmt::pmt_t k2 = pmt::mp("k2"); - pmt::pmt_t k3 = pmt::mp("k3"); - pmt::pmt_t v0 = pmt::mp("v0"); - pmt::pmt_t v1 = pmt::mp("v1"); - pmt::pmt_t v2 = pmt::mp("v2"); - pmt::pmt_t p0 = pmt::cons(k0, v0); - pmt::pmt_t p1 = pmt::cons(k1, v1); - pmt::pmt_t p2 = pmt::cons(k2, v2); - - pmt::pmt_t alist = pmt::cons(p0, pmt::cons(p1, pmt::cons(p2, pmt::PMT_NIL))); - CPPUNIT_ASSERT(pmt::eq(p1, pmt::assv(k1, alist))); - CPPUNIT_ASSERT(pmt::eq(pmt::PMT_F, pmt::assv(k3, alist))); - - pmt::pmt_t keys = pmt::cons(k0, pmt::cons(k1, pmt::cons(k2, pmt::PMT_NIL))); - pmt::pmt_t vals = pmt::cons(v0, pmt::cons(v1, pmt::cons(v2, pmt::PMT_NIL))); - CPPUNIT_ASSERT(pmt::equal(keys, pmt::map(pmt::car, alist))); - CPPUNIT_ASSERT(pmt::equal(vals, pmt::map(pmt::cdr, alist))); -} - -void -qa_pmt_prims::test_dict() -{ - pmt::pmt_t dict = pmt::make_dict(); - CPPUNIT_ASSERT(pmt::is_dict(dict)); - - pmt::pmt_t k0 = pmt::mp("k0"); - pmt::pmt_t k1 = pmt::mp("k1"); - pmt::pmt_t k2 = pmt::mp("k2"); - pmt::pmt_t k3 = pmt::mp("k3"); - pmt::pmt_t v0 = pmt::mp("v0"); - pmt::pmt_t v1 = pmt::mp("v1"); - pmt::pmt_t v2 = pmt::mp("v2"); - pmt::pmt_t v3 = pmt::mp("v3"); - pmt::pmt_t not_found = pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL); - - CPPUNIT_ASSERT(!pmt::dict_has_key(dict, k0)); - dict = pmt::dict_add(dict, k0, v0); - CPPUNIT_ASSERT(pmt::dict_has_key(dict, k0)); - CPPUNIT_ASSERT(pmt::eqv(pmt::dict_ref(dict, k0, not_found), v0)); - CPPUNIT_ASSERT(pmt::eqv(pmt::dict_ref(dict, k1, not_found), not_found)); - dict = pmt::dict_add(dict, k1, v1); - dict = pmt::dict_add(dict, k2, v2); - CPPUNIT_ASSERT(pmt::eqv(pmt::dict_ref(dict, k1, not_found), v1)); - dict = pmt::dict_add(dict, k1, v3); - CPPUNIT_ASSERT(pmt::eqv(pmt::dict_ref(dict, k1, not_found), v3)); - - pmt::pmt_t keys = pmt::list3(k1, k2, k0); - pmt::pmt_t vals = pmt::list3(v3, v2, v0); - //std::cout << "pmt::dict_keys: " << pmt::dict_keys(dict) << std::endl; - //std::cout << "pmt::dict_values: " << pmt::dict_values(dict) << std::endl; - CPPUNIT_ASSERT(pmt::equal(keys, pmt::dict_keys(dict))); - CPPUNIT_ASSERT(pmt::equal(vals, pmt::dict_values(dict))); -} - -void -qa_pmt_prims::test_io() -{ - pmt::pmt_t k0 = pmt::mp("k0"); - pmt::pmt_t k1 = pmt::mp("k1"); - pmt::pmt_t k2 = pmt::mp("k2"); - pmt::pmt_t k3 = pmt::mp("k3"); - - CPPUNIT_ASSERT_EQUAL(std::string("k0"), pmt::write_string(k0)); -} - -void -qa_pmt_prims::test_lists() -{ - pmt::pmt_t s0 = pmt::mp("s0"); - pmt::pmt_t s1 = pmt::mp("s1"); - pmt::pmt_t s2 = pmt::mp("s2"); - pmt::pmt_t s3 = pmt::mp("s3"); - - pmt::pmt_t l1 = pmt::list4(s0, s1, s2, s3); - pmt::pmt_t l2 = pmt::list3(s0, s1, s2); - pmt::pmt_t l3 = pmt::list_add(l2, s3); - CPPUNIT_ASSERT(pmt::equal(l1, l3)); -} - -// ------------------------------------------------------------------------ - -// 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 << "<foo: " << obj.d_double << ", " << obj.d_int << ">"; - 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::pmt_t p0 = pmt::make_any(a0); - pmt::pmt_t p1 = pmt::make_any(a1); - pmt::pmt_t p2 = pmt::make_any(a2); - - CPPUNIT_ASSERT_EQUAL(std::string("Hello!"), - boost::any_cast<std::string>(pmt::any_ref(p0))); - - CPPUNIT_ASSERT_EQUAL(42, - boost::any_cast<int>(pmt::any_ref(p1))); - - CPPUNIT_ASSERT_EQUAL(foo(3.250, 21), - boost::any_cast<foo>(pmt::any_ref(p2))); -} - -// ------------------------------------------------------------------------ - -class qa_pmt_msg_accepter_nop : public gruel::msg_accepter { -public: - qa_pmt_msg_accepter_nop(){}; - ~qa_pmt_msg_accepter_nop(); - void post(pmt::pmt_t,pmt::pmt_t){}; -}; - -qa_pmt_msg_accepter_nop::~qa_pmt_msg_accepter_nop(){} - -void -qa_pmt_prims::test_msg_accepter() -{ - pmt::pmt_t sym = pmt::mp("my-symbol"); - - boost::any a0; - a0 = std::string("Hello!"); - pmt::pmt_t p0 = pmt::make_any(a0); - - gruel::msg_accepter_sptr ma0 = gruel::msg_accepter_sptr(new qa_pmt_msg_accepter_nop()); - pmt::pmt_t p1 = pmt::make_msg_accepter(ma0); - - CPPUNIT_ASSERT_EQUAL(ma0.get(), pmt::msg_accepter_ref(p1).get()); - - CPPUNIT_ASSERT_THROW(pmt::msg_accepter_ref(sym), pmt::wrong_type); - CPPUNIT_ASSERT_THROW(pmt::msg_accepter_ref(p0), pmt::wrong_type); - - // just confirm interfaces on send are OK - pmt::pmt_t port(pmt::intern("port")); - gruel::send(ma0.get(), port, sym); - gruel::send(ma0, port, sym); - gruel::send(p1, port, sym); - -} - -// ------------------------------------------------------------------------ - -void -qa_pmt_prims::test_serialize() -{ - std::stringbuf sb; // fake channel - pmt::pmt_t a = pmt::mp("a"); - pmt::pmt_t b = pmt::mp("b"); - pmt::pmt_t c = pmt::mp("c"); - - sb.str(""); // reset channel to empty - - // write stuff to channel - - pmt::serialize(pmt::PMT_NIL, sb); - pmt::serialize(pmt::mp("foobarvia"), sb); - pmt::serialize(pmt::from_long(123456789), sb); - pmt::serialize(pmt::from_long(-123456789), sb); - pmt::serialize(pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL), sb); - pmt::serialize(pmt::cons(a, b), sb); - pmt::serialize(pmt::list1(a), sb); - pmt::serialize(pmt::list2(a, b), sb); - pmt::serialize(pmt::list3(a, b, c), sb); - pmt::serialize(pmt::list3(a, pmt::list3(c, b, a), c), sb); - pmt::serialize(pmt::PMT_T, sb); - pmt::serialize(pmt::PMT_F, sb); - - // read it back - - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::PMT_NIL)); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::mp("foobarvia"))); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::from_long(123456789))); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::from_long(-123456789))); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::cons(pmt::PMT_NIL, pmt::PMT_NIL))); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::cons(a, b))); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::list1(a))); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::list2(a, b))); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::list3(a, b, c))); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::list3(a, pmt::list3(c, b, a), c))); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::PMT_T)); - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::PMT_F)); - - CPPUNIT_ASSERT(pmt::equal(pmt::deserialize(sb), pmt::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::pmt_t s1 = pmt::mp("s1"); - pmt::pmt_t s2 = pmt::mp("s2"); - pmt::pmt_t s3 = pmt::mp("s3"); - - pmt::pmt_t l1 = pmt::list1(s1); - pmt::pmt_t l2 = pmt::list2(s2,s3); - pmt::pmt_t l3 = pmt::list3(s1,s2,s3); - - CPPUNIT_ASSERT(pmt::is_pair(pmt::memq(s1,l1))); - CPPUNIT_ASSERT(pmt::is_false(pmt::memq(s3,l1))); - - CPPUNIT_ASSERT(pmt::subsetp(l1,l3)); - CPPUNIT_ASSERT(pmt::subsetp(l2,l3)); - CPPUNIT_ASSERT(!pmt::subsetp(l1,l2)); - CPPUNIT_ASSERT(!pmt::subsetp(l2,l1)); - CPPUNIT_ASSERT(!pmt::subsetp(l3,l2)); -} - -void -qa_pmt_prims::test_sugar() -{ - CPPUNIT_ASSERT(pmt::is_symbol(pmt::mp("my-symbol"))); - CPPUNIT_ASSERT_EQUAL((long) 10, pmt::to_long(pmt::mp(10))); - CPPUNIT_ASSERT_EQUAL((double) 1e6, pmt::to_double(pmt::mp(1e6))); - CPPUNIT_ASSERT_EQUAL(std::complex<double>(2, 3), - pmt::to_complex(pmt::mp(std::complex<double>(2, 3)))); - - int buf[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; - pmt::pmt_t blob = pmt::mp(buf, sizeof(buf)); - const void *data = pmt::blob_data(blob); - size_t nbytes = pmt::blob_length(blob); - CPPUNIT_ASSERT_EQUAL(sizeof(buf), nbytes); - CPPUNIT_ASSERT(memcmp(buf, data, nbytes) == 0); -} diff --git a/gruel/src/lib/pmt/qa_pmt_prims.h b/gruel/src/lib/pmt/qa_pmt_prims.h deleted file mode 100644 index a407509b2c..0000000000 --- a/gruel/src/lib/pmt/qa_pmt_prims.h +++ /dev/null @@ -1,77 +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 <gruel/attributes.h> -#include <gruel/api.h> //reason: suppress warnings -#include <cppunit/extensions/HelperMacros.h> -#include <cppunit/TestCase.h> - -class __GR_ATTR_EXPORT 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_uint64s); - CPPUNIT_TEST(test_reals); - CPPUNIT_TEST(test_complexes); - CPPUNIT_TEST(test_pairs); - CPPUNIT_TEST(test_vectors); - CPPUNIT_TEST(test_tuples); - CPPUNIT_TEST(test_equivalence); - CPPUNIT_TEST(test_misc); - CPPUNIT_TEST(test_dict); - CPPUNIT_TEST(test_any); - CPPUNIT_TEST(test_msg_accepter); - CPPUNIT_TEST(test_io); - CPPUNIT_TEST(test_lists); - CPPUNIT_TEST(test_serialize); - CPPUNIT_TEST(test_sets); - CPPUNIT_TEST(test_sugar); - CPPUNIT_TEST_SUITE_END(); - - private: - void test_symbols(); - void test_booleans(); - void test_integers(); - void test_uint64s(); - void test_reals(); - void test_complexes(); - void test_pairs(); - void test_vectors(); - void test_tuples(); - void test_equivalence(); - void test_misc(); - void test_dict(); - void test_any(); - void test_msg_accepter(); - void test_io(); - void test_lists(); - void test_serialize(); - void test_sets(); - void test_sugar(); -}; - -#endif /* INCLUDED_QA_PMT_PRIMS_H */ - diff --git a/gruel/src/lib/pmt/unv_qa_template.cc.t b/gruel/src/lib/pmt/unv_qa_template.cc.t deleted file mode 100644 index a04d532b4e..0000000000 --- a/gruel/src/lib/pmt/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/pmt/unv_template.cc.t b/gruel/src/lib/pmt/unv_template.cc.t deleted file mode 100644 index 8678894973..0000000000 --- a/gruel/src/lib/pmt/unv_template.cc.t +++ /dev/null @@ -1,141 +0,0 @@ -//////////////////////////////////////////////////////////////////////////// -// pmt_@TAG@vector -//////////////////////////////////////////////////////////////////////////// - -namespace pmt { - -static pmt_@TAG@vector * -_@TAG@vector(pmt_t x) -{ - return dynamic_cast<pmt_@TAG@vector*>(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 out_of_range("pmt_@TAG@vector_ref", from_long(k)); - return d_v[k]; -} - -void -pmt_@TAG@vector::set(size_t k, @TYPE@ x) -{ - if (k >= length()) - throw out_of_range("pmt_@TAG@vector_set", 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 -is_@TAG@vector(pmt_t obj) -{ - return obj->is_@TAG@vector(); -} - -pmt_t -make_@TAG@vector(size_t k, @TYPE@ fill) -{ - return pmt_t(new pmt_@TAG@vector(k, fill)); -} - -pmt_t -init_@TAG@vector(size_t k, const @TYPE@ *data) -{ - return pmt_t(new pmt_@TAG@vector(k, data)); -} - -pmt_t -init_@TAG@vector(size_t k, const std::vector< @TYPE@ > &data) -{ - - return pmt_t(new pmt_@TAG@vector(k, &data[0])); -} - -@TYPE@ -@TAG@vector_ref(pmt_t vector, size_t k) -{ - if (!vector->is_@TAG@vector()) - throw wrong_type("pmt_@TAG@vector_ref", vector); - return _@TAG@vector(vector)->ref(k); -} - -void -@TAG@vector_set(pmt_t vector, size_t k, @TYPE@ obj) -{ - if (!vector->is_@TAG@vector()) - throw wrong_type("pmt_@TAG@vector_set", vector); - _@TAG@vector(vector)->set(k, obj); -} - -const @TYPE@ * -@TAG@vector_elements(pmt_t vector, size_t &len) -{ - if (!vector->is_@TAG@vector()) - throw wrong_type("pmt_@TAG@vector_elements", vector); - return _@TAG@vector(vector)->elements(len); -} - -const std::vector< @TYPE@ > -@TAG@vector_elements(pmt_t vector) -{ - if (!vector->is_@TAG@vector()) - throw wrong_type("pmt_@TAG@vector_elements", vector); - size_t len; - const @TYPE@ *array = _@TAG@vector(vector)->elements(len); - const std::vector< @TYPE@ > vec(array, array+len); - return vec; -} - - -@TYPE@ * -@TAG@vector_writable_elements(pmt_t vector, size_t &len) -{ - if (!vector->is_@TAG@vector()) - throw 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 deleted file mode 100644 index 83ba0be0f4..0000000000 --- a/gruel/src/lib/pmt/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/gruel/src/lib/realtime.cc b/gruel/src/lib/realtime.cc deleted file mode 100644 index e01c6c53d4..0000000000 --- a/gruel/src/lib/realtime.cc +++ /dev/null @@ -1,178 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006,2007,2008 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 <config.h> -#endif - -#include <gruel/realtime.h> - -#ifdef HAVE_SCHED_H -#include <sched.h> -#endif - -#include <algorithm> -#include <math.h> -#include <string.h> -#include <errno.h> -#include <stdio.h> - -#if defined(HAVE_PTHREAD_SETSCHEDPARAM) || defined(HAVE_SCHED_SETSCHEDULER) -#include <pthread.h> - -namespace gruel { - - /*! - * Rescale our virtual priority so that it maps to the middle 1/2 of - * the priorities given by min_real_pri and max_real_pri. - */ - static int - rescale_virtual_pri(int virtual_pri, int min_real_pri, int max_real_pri) - { - float rmin = min_real_pri + (0.25 * (max_real_pri - min_real_pri)); - float rmax = min_real_pri + (0.75 * (max_real_pri - min_real_pri)); - float m = (rmax - rmin) / (rt_priority_max() - rt_priority_min()); - float y = m * (virtual_pri - rt_priority_min()) + rmin; - int y_int = static_cast<int>(rint(y)); - return std::max(min_real_pri, std::min(max_real_pri, y_int)); - } - -} // namespace gruel - -#endif - - -#if defined(HAVE_PTHREAD_SETSCHEDPARAM) - -namespace gruel { - - rt_status_t - enable_realtime_scheduling(rt_sched_param p) - { - int policy = p.policy == RT_SCHED_FIFO ? SCHED_FIFO : SCHED_RR; - int min_real_pri = sched_get_priority_min(policy); - int max_real_pri = sched_get_priority_max(policy); - int pri = rescale_virtual_pri(p.priority, min_real_pri, max_real_pri); - - // FIXME check hard and soft limits with getrlimit, and limit the value we ask for. - // fprintf(stderr, "pthread_setschedparam: policy = %d, pri = %d\n", policy, pri); - - struct sched_param param; - memset (¶m, 0, sizeof (param)); - param.sched_priority = pri; - int result = pthread_setschedparam (pthread_self(), policy, ¶m); - if (result != 0) { - if (result == EPERM) // N.B., return value, not errno - return RT_NO_PRIVS; - else { - fprintf(stderr, - "pthread_setschedparam: failed to set real time priority: %s\n", - strerror(result)); - return RT_OTHER_ERROR; - } - } - - //printf("SCHED_FIFO enabled with priority = %d\n", pri); - return RT_OK; - } -} // namespace gruel - - -#elif defined(HAVE_SCHED_SETSCHEDULER) - -namespace gruel { - - rt_status_t - enable_realtime_scheduling(rt_sched_param p) - { - int policy = p.policy == RT_SCHED_FIFO ? SCHED_FIFO : SCHED_RR; - int min_real_pri = sched_get_priority_min(policy); - int max_real_pri = sched_get_priority_max(policy); - int pri = rescale_virtual_pri(p.priority, min_real_pri, max_real_pri); - - // FIXME check hard and soft limits with getrlimit, and limit the value we ask for. - // fprintf(stderr, "sched_setscheduler: policy = %d, pri = %d\n", policy, pri); - - int pid = 0; // this process - struct sched_param param; - memset(¶m, 0, sizeof(param)); - param.sched_priority = pri; - int result = sched_setscheduler(pid, policy, ¶m); - if (result != 0){ - if (errno == EPERM) - return RT_NO_PRIVS; - else { - perror ("sched_setscheduler: failed to set real time priority"); - return RT_OTHER_ERROR; - } - } - - //printf("SCHED_FIFO enabled with priority = %d\n", pri); - return RT_OK; - } - -} // namespace gruel - -#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) - -#include <windows.h> - -namespace gruel { - - rt_status_t enable_realtime_scheduling(rt_sched_param p){ - - //set the priority class on the process - int pri_class = (true)? REALTIME_PRIORITY_CLASS : NORMAL_PRIORITY_CLASS; - if (SetPriorityClass(GetCurrentProcess(), pri_class) == 0) - return RT_OTHER_ERROR; - - //scale the priority value to the constants - int priorities[] = { - THREAD_PRIORITY_IDLE, THREAD_PRIORITY_LOWEST, THREAD_PRIORITY_BELOW_NORMAL, THREAD_PRIORITY_NORMAL, - THREAD_PRIORITY_ABOVE_NORMAL, THREAD_PRIORITY_HIGHEST, THREAD_PRIORITY_TIME_CRITICAL - }; - const double priority = double(p.priority)/(rt_priority_max() - rt_priority_min()); - size_t pri_index = size_t((priority+1.0)*6/2.0); // -1 -> 0, +1 -> 6 - pri_index %= sizeof(priorities)/sizeof(*priorities); //range check - - //set the thread priority on the thread - if (SetThreadPriority(GetCurrentThread(), priorities[pri_index]) == 0) - return RT_OTHER_ERROR; - - //printf("SetPriorityClass + SetThreadPriority\n"); - return RT_OK; - } - -} // namespace gruel - -#else - -namespace gruel { - - rt_status_t - enable_realtime_scheduling(rt_sched_param p) - { - return RT_NOT_IMPLEMENTED; - } -} // namespace gruel - -#endif diff --git a/gruel/src/lib/sys_pri.cc b/gruel/src/lib/sys_pri.cc deleted file mode 100644 index c8a505341f..0000000000 --- a/gruel/src/lib/sys_pri.cc +++ /dev/null @@ -1,61 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2008 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 <config.h> -#endif -#include <gruel/sys_pri.h> - -namespace gruel { - - /* - * These may need per-OS tweaking. - * - * Under linux virtual_pri -> system_pri - * 0 -> 0 - * 1 -> 5 - * 2 -> 10 - * 3 -> 15 - * 4 -> 20 // typically used by jack and pulse audio - * 5 -> 25 - * 6 -> 30 - * 7 -> 35 - * 8 -> 40 - * 9 -> 45 - * 10 -> 50 - * 11 -> 54 - * 12 -> 59 - * 13 -> 64 - * 14 -> 69 - * 15 -> 74 - */ - rt_sched_param - sys_pri::python() { return rt_sched_param(0, RT_SCHED_RR); } - - rt_sched_param - sys_pri::normal() { return rt_sched_param(2, RT_SCHED_RR); } - - rt_sched_param - sys_pri::gcell_event_handler(){ return rt_sched_param(5, RT_SCHED_FIFO); } - - rt_sched_param - sys_pri::usrp2_backend() { return rt_sched_param(6, RT_SCHED_FIFO); } -} diff --git a/gruel/src/lib/test_gruel.cc b/gruel/src/lib/test_gruel.cc deleted file mode 100644 index f32e3f3417..0000000000 --- a/gruel/src/lib/test_gruel.cc +++ /dev/null @@ -1,52 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2006,2009,2010,2011 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 <cppunit/TextTestRunner.h> -#include <cppunit/XmlOutputter.h> - -#include <stdlib.h> -#include <sys/stat.h> - -#include "pmt/qa_pmt.h" - -#include <boost/filesystem/operations.hpp> -#include <boost/filesystem/path.hpp> -namespace fs = boost::filesystem; - -int -main(int argc, char **argv) -{ - fs::path path = fs::current_path() / ".unittests"; - if (!fs::is_directory(path)) fs::create_directory(path); - path = path / "gruel.xml"; - - CppUnit::TextTestRunner runner; - std::ofstream xmlfile(path.string().c_str()); - CppUnit::XmlOutputter *xmlout = new CppUnit::XmlOutputter(&runner.result(), xmlfile); - - runner.addTest(qa_pmt::suite ()); - runner.setOutputter(xmlout); - - bool was_successful = runner.run("", false); - - return was_successful ? 0 : 1; -} diff --git a/gruel/src/lib/thread.cc b/gruel/src/lib/thread.cc deleted file mode 100644 index 8ebe822fbf..0000000000 --- a/gruel/src/lib/thread.cc +++ /dev/null @@ -1,226 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2012 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 <config.h> -#endif - -#include <gruel/thread.h> - -#if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) - -#include <Windows.h> - -namespace gruel { - - gr_thread_t - get_current_thread_id() - { - return GetCurrentThread(); - } - - void - thread_bind_to_processor(unsigned int n) - { - std::vector<unsigned int> mask(1, n); - thread_bind_to_processor(get_current_thread_id(), mask); - } - - void - thread_bind_to_processor(const std::vector<unsigned int> &mask) - { - thread_bind_to_processor(get_current_thread_id(), mask); - } - - void - thread_bind_to_processor(gr_thread_t thread, unsigned int n) - { - std::vector<unsigned int> mask(1, n); - thread_bind_to_processor(thread, mask); - } - - void - thread_bind_to_processor(gr_thread_t thread, const std::vector<unsigned int> &mask) - { - //DWORD_PTR mask = (1 << n); - DWORD_PTR dword_mask = 0; - - std::vector<unsigned int> _mask = mask; - std::vector<unsigned int>::iterator itr; - for(itr = _mask.begin(); itr != _mask.end(); itr++) - dword_mask |= (1 << (*itr)); - - DWORD_PTR ret = SetThreadAffinityMask(thread, dword_mask); - if(ret == 0) { - std::stringstream s; - s << "thread_bind_to_processor failed with error: " << GetLastError() << std::endl; - throw std::runtime_error(s.str()); - } - } - - void - thread_unbind() - { - thread_unbind(get_current_thread_id()); - } - - void - thread_unbind(gr_thread_t thread) - { - DWORD_PTR dword_mask = sizeof(DWORD_PTR) - 1; - DWORD_PTR ret = SetThreadAffinityMask(thread, dword_mask); - if(ret == 0) { - std::stringstream s; - s << "thread_unbind failed with error: " << GetLastError() << std::endl; - throw std::runtime_error(s.str()); - } - } -} /* namespace gruel */ - -#elif defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) - -namespace gruel { - - gr_thread_t - get_current_thread_id() - { - // Not implemented on OSX - } - - void - thread_bind_to_processor(unsigned int n) - { - // Not implemented on OSX - } - - void - thread_bind_to_processor(gr_thread_t thread, unsigned int n) - { - // Not implemented on OSX - } - - void - thread_bind_to_processor(const std::vector<unsigned int> &mask) - { - // Not implemented on OSX - } - - void - thread_bind_to_processor(gr_thread_t thread, const std::vector<unsigned int> &mask) - { - // Not implemented on OSX - } - - void - thread_unbind() - { - // Not implemented on OSX - } - - void - thread_unbind(gr_thread_t thread) - { - // Not implemented on OSX - } -} /* namespace gruel */ - -#else - -#include <sstream> -#include <stdexcept> -#include <pthread.h> - -namespace gruel { - - gr_thread_t - get_current_thread_id() - { - return pthread_self(); - } - - void - thread_bind_to_processor(unsigned int n) - { - std::vector<unsigned int> mask(1, n); - thread_bind_to_processor(get_current_thread_id(), mask); - } - - void - thread_bind_to_processor(const std::vector<unsigned int> &mask) - { - thread_bind_to_processor(get_current_thread_id(), mask); - } - - void - thread_bind_to_processor(gr_thread_t thread, unsigned int n) - { - std::vector<unsigned int> mask(1, n); - thread_bind_to_processor(thread, mask); - } - - void - thread_bind_to_processor(gr_thread_t thread, const std::vector<unsigned int> &mask) - { - cpu_set_t set; - size_t len = sizeof(cpu_set_t); - std::vector<unsigned int> _mask = mask; - std::vector<unsigned int>::iterator itr; - - CPU_ZERO(&set); - for(itr = _mask.begin(); itr != _mask.end(); itr++) - CPU_SET(*itr, &set); - - int ret = pthread_setaffinity_np(thread, len, &set); - if(ret != 0) { - std::stringstream s; - s << "thread_bind_to_processor failed with error: " << ret << std::endl; - throw std::runtime_error(s.str()); - } - } - - void - thread_unbind() - { - thread_unbind(get_current_thread_id()); - } - - void - thread_unbind(gr_thread_t thread) - { - cpu_set_t set; - size_t len = sizeof(cpu_set_t); - - CPU_ZERO(&set); - long ncpus = sysconf(_SC_NPROCESSORS_ONLN); - for(long n = 0; n < ncpus; n++) { - CPU_SET(n, &set); - } - - int ret = pthread_setaffinity_np(thread, len, &set); - if(ret != 0) { - std::stringstream s; - s << "thread_unbind failed with error: " << ret << std::endl; - throw std::runtime_error(s.str()); - } - } -} /* namespace gruel */ - -#endif diff --git a/gruel/src/lib/thread_body_wrapper.cc b/gruel/src/lib/thread_body_wrapper.cc deleted file mode 100644 index 019eaa342a..0000000000 --- a/gruel/src/lib/thread_body_wrapper.cc +++ /dev/null @@ -1,85 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright 2008 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 <config.h> -#endif -#include <gruel/thread_body_wrapper.h> -#ifdef HAVE_SIGNAL_H -#include <signal.h> -#endif -#include <stdio.h> - -namespace gruel { - -#if defined(HAVE_PTHREAD_SIGMASK) && defined(HAVE_SIGNAL_H) - - void mask_signals() - { - sigset_t new_set; - int r; - - sigemptyset(&new_set); - sigaddset(&new_set, SIGHUP); // block these... - sigaddset(&new_set, SIGINT); - sigaddset(&new_set, SIGPIPE); - sigaddset(&new_set, SIGALRM); - sigaddset(&new_set, SIGTERM); - sigaddset(&new_set, SIGUSR1); - sigaddset(&new_set, SIGCHLD); -#ifdef SIGPOLL - sigaddset(&new_set, SIGPOLL); -#endif -#ifdef SIGPROF - sigaddset(&new_set, SIGPROF); -#endif -#ifdef SIGSYS - sigaddset(&new_set, SIGSYS); -#endif -#ifdef SIGTRAP - sigaddset(&new_set, SIGTRAP); -#endif -#ifdef SIGURG - sigaddset(&new_set, SIGURG); -#endif -#ifdef SIGVTALRM - sigaddset(&new_set, SIGVTALRM); -#endif -#ifdef SIGXCPU - sigaddset(&new_set, SIGXCPU); -#endif -#ifdef SIGXFSZ - sigaddset(&new_set, SIGXFSZ); -#endif - r = pthread_sigmask(SIG_BLOCK, &new_set, 0); - if (r != 0) - perror("pthread_sigmask"); - } - -#else - - void mask_signals() - { - } - -#endif - -}; diff --git a/gruel/src/lib/thread_group.cc b/gruel/src/lib/thread_group.cc deleted file mode 100644 index 9e8ded4dfc..0000000000 --- a/gruel/src/lib/thread_group.cc +++ /dev/null @@ -1,99 +0,0 @@ -/* -*- c++ -*- */ -/* - * Copyright (C) 2001-2003 William E. Kempf - * Copyright (C) 2007 Anthony Williams - * Copyright 2008 Free Software Foundation, Inc. - * - * Distributed under the Boost Software License, Version 1.0. (See accompanying - * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) - */ - -/* - * This was extracted from Boost 1.35.0 and fixed. - */ - -#include <gruel/thread_group.h> - -namespace gruel -{ - thread_group::thread_group() - { - } - - thread_group::~thread_group() - { - // We shouldn't have to scoped_lock here, since referencing this object - // from another thread while we're deleting it in the current thread is - // going to lead to undefined behavior any way. - for (std::list<boost::thread*>::iterator it = m_threads.begin(); - it != m_threads.end(); ++it) - { - delete (*it); - } - } - - boost::thread* thread_group::create_thread(const boost::function0<void>& threadfunc) - { - // No scoped_lock required here since the only "shared data" that's - // modified here occurs inside add_thread which does scoped_lock. - std::auto_ptr<boost::thread> thrd(new boost::thread(threadfunc)); - add_thread(thrd.get()); - return thrd.release(); - } - - void thread_group::add_thread(boost::thread* thrd) - { - boost::lock_guard<boost::shared_mutex> guard(m_mutex); - - // For now we'll simply ignore requests to add a thread object multiple - // times. Should we consider this an error and either throw or return an - // error value? - std::list<boost::thread*>::iterator it = std::find(m_threads.begin(), - m_threads.end(), thrd); - BOOST_ASSERT(it == m_threads.end()); - if (it == m_threads.end()) - m_threads.push_back(thrd); - } - - void thread_group::remove_thread(boost::thread* thrd) - { - boost::lock_guard<boost::shared_mutex> guard(m_mutex); - - // For now we'll simply ignore requests to remove a thread object that's - // not in the group. Should we consider this an error and either throw or - // return an error value? - std::list<boost::thread*>::iterator it = std::find(m_threads.begin(), - m_threads.end(), thrd); - BOOST_ASSERT(it != m_threads.end()); - if (it != m_threads.end()) - m_threads.erase(it); - } - - void thread_group::join_all() - { - boost::shared_lock<boost::shared_mutex> guard(m_mutex); - for (std::list<boost::thread*>::iterator it = m_threads.begin(); - it != m_threads.end(); ++it) - { - (*it)->join(); - } - } - - void thread_group::interrupt_all() - { - boost::shared_lock<boost::shared_mutex> guard(m_mutex); - for(std::list<boost::thread*>::iterator it=m_threads.begin(),end=m_threads.end(); - it!=end; - ++it) - { - (*it)->interrupt(); - } - } - - size_t thread_group::size() const - { - boost::shared_lock<boost::shared_mutex> guard(m_mutex); - return m_threads.size(); - } - -} // namespace gruel |