3 uni-tag (dienstag): basic color text, quadRX (slow),nPorts,CT, TODO:AF

9 years ago · 023005fddd
50 changed files with 17500 additions and 0 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -0,0 +1,198 @@
 # Copyright 2011,2012,2014,2016 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.
 ########################################################################
 # Project setup
 ########################################################################
 cmake_minimum_required(VERSION 2.6)
 project(gr-crfa CXX C)
 enable_testing()
 #install to PyBOMBS target prefix if defined
 if(DEFINED ENV{PYBOMBS_PREFIX})
    set(CMAKE_INSTALL_PREFIX $ENV{PYBOMBS_PREFIX})
    message(STATUS "PyBOMBS installed GNU Radio. Setting CMAKE_INSTALL_PREFIX to $ENV{PYBOMBS_PREFIX}")
 endif()
 #select the release build type by default to get optimization flags
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE "Release")
   message(STATUS "Build type not specified: defaulting to release.")
 endif(NOT CMAKE_BUILD_TYPE)
 set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")
 #make sure our local CMake Modules path comes first
 list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_SOURCE_DIR}/cmake/Modules)
 # Set the version information here
 set(VERSION_INFO_MAJOR_VERSION 1)
 set(VERSION_INFO_API_COMPAT    0)
 set(VERSION_INFO_MINOR_VERSION 0)
 set(VERSION_INFO_MAINT_VERSION git)
 ########################################################################
 # Compiler specific setup
 ########################################################################
 if(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
    #http://gcc.gnu.org/wiki/Visibility
    add_definitions(-fvisibility=hidden)
 endif()
 ########################################################################
 # Find boost
 ########################################################################
 if(UNIX AND EXISTS "/usr/lib64")
    list(APPEND BOOST_LIBRARYDIR "/usr/lib64") #fedora 64-bit fix
 endif(UNIX AND EXISTS "/usr/lib64")
 set(Boost_ADDITIONAL_VERSIONS
    "1.35.0" "1.35" "1.36.0" "1.36" "1.37.0" "1.37" "1.38.0" "1.38" "1.39.0" "1.39"
    "1.40.0" "1.40" "1.41.0" "1.41" "1.42.0" "1.42" "1.43.0" "1.43" "1.44.0" "1.44"
    "1.45.0" "1.45" "1.46.0" "1.46" "1.47.0" "1.47" "1.48.0" "1.48" "1.49.0" "1.49"
    "1.50.0" "1.50" "1.51.0" "1.51" "1.52.0" "1.52" "1.53.0" "1.53" "1.54.0" "1.54"
    "1.55.0" "1.55" "1.56.0" "1.56" "1.57.0" "1.57" "1.58.0" "1.58" "1.59.0" "1.59"
    "1.60.0" "1.60" "1.61.0" "1.61" "1.62.0" "1.62" "1.63.0" "1.63" "1.64.0" "1.64"
    "1.65.0" "1.65" "1.66.0" "1.66" "1.67.0" "1.67" "1.68.0" "1.68" "1.69.0" "1.69"
 )
 find_package(Boost "1.35" COMPONENTS filesystem system)
 if(NOT Boost_FOUND)
    message(FATAL_ERROR "Boost required to compile crfa")
 endif()
 ########################################################################
 # Install directories
 ########################################################################
 include(GrPlatform) #define LIB_SUFFIX
 set(GR_RUNTIME_DIR      bin)
 set(GR_LIBRARY_DIR      lib${LIB_SUFFIX})
 set(GR_INCLUDE_DIR      include/crfa)
 set(GR_DATA_DIR         share)
 set(GR_PKG_DATA_DIR     ${GR_DATA_DIR}/${CMAKE_PROJECT_NAME})
 set(GR_DOC_DIR          ${GR_DATA_DIR}/doc)
 set(GR_PKG_DOC_DIR      ${GR_DOC_DIR}/${CMAKE_PROJECT_NAME})
 set(GR_CONF_DIR         etc)
 set(GR_PKG_CONF_DIR     ${GR_CONF_DIR}/${CMAKE_PROJECT_NAME}/conf.d)
 set(GR_LIBEXEC_DIR      libexec)
 set(GR_PKG_LIBEXEC_DIR  ${GR_LIBEXEC_DIR}/${CMAKE_PROJECT_NAME})
 set(GRC_BLOCKS_DIR      ${GR_PKG_DATA_DIR}/grc/blocks)
 ########################################################################
 # On Apple only, set install name and use rpath correctly, if not already set
 ########################################################################
 if(APPLE)
    if(NOT CMAKE_INSTALL_NAME_DIR)
        set(CMAKE_INSTALL_NAME_DIR
            ${CMAKE_INSTALL_PREFIX}/${GR_LIBRARY_DIR} CACHE
            PATH "Library Install Name Destination Directory" FORCE)
    endif(NOT CMAKE_INSTALL_NAME_DIR)
    if(NOT CMAKE_INSTALL_RPATH)
        set(CMAKE_INSTALL_RPATH
            ${CMAKE_INSTALL_PREFIX}/${GR_LIBRARY_DIR} CACHE
            PATH "Library Install RPath" FORCE)
    endif(NOT CMAKE_INSTALL_RPATH)
    if(NOT CMAKE_BUILD_WITH_INSTALL_RPATH)
        set(CMAKE_BUILD_WITH_INSTALL_RPATH ON CACHE
            BOOL "Do Build Using Library Install RPath" FORCE)
    endif(NOT CMAKE_BUILD_WITH_INSTALL_RPATH)
 endif(APPLE)
 ########################################################################
 # Find gnuradio build dependencies
 ########################################################################
 find_package(CppUnit)
 find_package(Doxygen)
 # Search for GNU Radio and its components and versions. Add any
 # components required to the list of GR_REQUIRED_COMPONENTS (in all
 # caps such as FILTER or FFT) and change the version to the minimum
 # API compatible version required.
 set(GR_REQUIRED_COMPONENTS RUNTIME)
 find_package(Gnuradio "3.7.2" REQUIRED)
 list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_SOURCE_DIR}/cmake/Modules)
 include(GrVersion)
 if(NOT CPPUNIT_FOUND)
    message(FATAL_ERROR "CppUnit required to compile crfa")
 endif()
 ########################################################################
 # Setup doxygen option
 ########################################################################
 if(DOXYGEN_FOUND)
 	option(ENABLE_DOXYGEN "Build docs using Doxygen" ON)
 else(DOXYGEN_FOUND)
 	option(ENABLE_DOXYGEN "Build docs using Doxygen" OFF)
 endif(DOXYGEN_FOUND)
 ########################################################################
 # Setup the include and linker paths
 ########################################################################
 include_directories(
    ${CMAKE_SOURCE_DIR}/lib
    ${CMAKE_SOURCE_DIR}/include
    ${CMAKE_BINARY_DIR}/lib
    ${CMAKE_BINARY_DIR}/include
    ${Boost_INCLUDE_DIRS}
    ${CPPUNIT_INCLUDE_DIRS}
    ${GNURADIO_ALL_INCLUDE_DIRS}
 )
 link_directories(
    ${Boost_LIBRARY_DIRS}
    ${CPPUNIT_LIBRARY_DIRS}
    ${GNURADIO_RUNTIME_LIBRARY_DIRS}
 )
 # Set component parameters
 set(GR_CRFA_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE INTERNAL "" FORCE)
 set(GR_CRFA_SWIG_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/swig CACHE INTERNAL "" FORCE)
 ########################################################################
 # Create uninstall target
 ########################################################################
 configure_file(
    ${CMAKE_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in
    ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
@ONLY)
 add_custom_target(uninstall
    ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
 )
 ########################################################################
 # Add subdirectories
 ########################################################################
 add_subdirectory(include/crfa)
 add_subdirectory(lib)
 add_subdirectory(swig)
 add_subdirectory(python)
 add_subdirectory(grc)
 add_subdirectory(apps)
 add_subdirectory(docs)
 ########################################################################
 # Install cmake search helper for this library
 ########################################################################
 if(NOT CMAKE_MODULES_DIR)
  set(CMAKE_MODULES_DIR lib${LIB_SUFFIX}/cmake)
 endif(NOT CMAKE_MODULES_DIR)
 install(FILES cmake/Modules/crfaConfig.cmake
    DESTINATION ${CMAKE_MODULES_DIR}/crfa
 )
--- a/MANIFEST.md
+++ b/MANIFEST.md
@ -0,0 +1,16 @@
 title: The CRFA OOT Module
 brief: Short description of gr-crfa
 tags: # Tags are arbitrary, but look at CGRAN what other authors are using
  - sdr
 author:
  - Author Name <authors@email.address>
 copyright_owner:
  - Copyright Owner 1
 license:
 #repo: # Put the URL of the repository here, or leave blank for default
 #website: <module_website> # If you have a separate project website, put it here
 #icon: <icon_url> # Put a URL to a square image here that will be used as an icon on CGRAN
 ---
 A longer, multi-line description of gr-crfa.
 You may use some *basic* Markdown here.
 If left empty, it will try to find a README file instead.
--- a/cmake/Modules/CMakeParseArgumentsCopy.cmake
+++ b/cmake/Modules/CMakeParseArgumentsCopy.cmake
@ -0,0 +1,138 @@
 # CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords> <multi_value_keywords> args...)
 #
 # CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions for
 # parsing the arguments given to that macro or function.
 # It processes the arguments and defines a set of variables which hold the
 # values of the respective options.
 #
 # The <options> argument contains all options for the respective macro,
 # i.e. keywords which can be used when calling the macro without any value
 # following, like e.g. the OPTIONAL keyword of the install() command.
 #
 # The <one_value_keywords> argument contains all keywords for this macro
 # which are followed by one value, like e.g. DESTINATION keyword of the
 # install() command.
 #
 # The <multi_value_keywords> argument contains all keywords for this macro
 # which can be followed by more than one value, like e.g. the TARGETS or
 # FILES keywords of the install() command.
 #
 # When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the
 # keywords listed in <options>, <one_value_keywords> and
 # <multi_value_keywords> a variable composed of the given <prefix>
 # followed by "_" and the name of the respective keyword.
 # These variables will then hold the respective value from the argument list.
 # For the <options> keywords this will be TRUE or FALSE.
 #
 # All remaining arguments are collected in a variable
 # <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see whether
 # your macro was called with unrecognized parameters.
 #
 # As an example here a my_install() macro, which takes similar arguments as the
 # real install() command:
 #
 #   function(MY_INSTALL)
 #     set(options OPTIONAL FAST)
 #     set(oneValueArgs DESTINATION RENAME)
 #     set(multiValueArgs TARGETS CONFIGURATIONS)
 #     cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
 #     ...
 #
 # Assume my_install() has been called like this:
 #   my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)
 #
 # After the cmake_parse_arguments() call the macro will have set the following
 # variables:
 #   MY_INSTALL_OPTIONAL = TRUE
 #   MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()
 #   MY_INSTALL_DESTINATION = "bin"
 #   MY_INSTALL_RENAME = "" (was not used)
 #   MY_INSTALL_TARGETS = "foo;bar"
 #   MY_INSTALL_CONFIGURATIONS = "" (was not used)
 #   MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"
 #
 # You can the continue and process these variables.
 #
 # Keywords terminate lists of values, e.g. if directly after a one_value_keyword
 # another recognized keyword follows, this is interpreted as the beginning of
 # the new option.
 # E.g. my_install(TARGETS foo DESTINATION OPTIONAL) would result in
 # MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION would
 # be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor.
 #=============================================================================
 # Copyright 2010 Alexander Neundorf <neundorf@kde.org>
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.
 #
 # This software is distributed WITHOUT ANY WARRANTY; without even the
 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 # See the License for more information.
 #=============================================================================
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 if(__CMAKE_PARSE_ARGUMENTS_INCLUDED)
  return()
 endif()
 set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE)
 function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames)
  # first set all result variables to empty/FALSE
  foreach(arg_name ${_singleArgNames} ${_multiArgNames})
    set(${prefix}_${arg_name})
  endforeach(arg_name)
  foreach(option ${_optionNames})
    set(${prefix}_${option} FALSE)
  endforeach(option)
  set(${prefix}_UNPARSED_ARGUMENTS)
  set(insideValues FALSE)
  set(currentArgName)
  # now iterate over all arguments and fill the result variables
  foreach(currentArg ${ARGN})
    list(FIND _optionNames "${currentArg}" optionIndex)  # ... then this marks the end of the arguments belonging to this keyword
    list(FIND _singleArgNames "${currentArg}" singleArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
    list(FIND _multiArgNames "${currentArg}" multiArgIndex)  # ... then this marks the end of the arguments belonging to this keyword
    if(${optionIndex} EQUAL -1  AND  ${singleArgIndex} EQUAL -1  AND  ${multiArgIndex} EQUAL -1)
      if(insideValues)
        if("${insideValues}" STREQUAL "SINGLE")
          set(${prefix}_${currentArgName} ${currentArg})
          set(insideValues FALSE)
        elseif("${insideValues}" STREQUAL "MULTI")
          list(APPEND ${prefix}_${currentArgName} ${currentArg})
        endif()
      else(insideValues)
        list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg})
      endif(insideValues)
    else()
      if(NOT ${optionIndex} EQUAL -1)
        set(${prefix}_${currentArg} TRUE)
        set(insideValues FALSE)
      elseif(NOT ${singleArgIndex} EQUAL -1)
        set(currentArgName ${currentArg})
        set(${prefix}_${currentArgName})
        set(insideValues "SINGLE")
      elseif(NOT ${multiArgIndex} EQUAL -1)
        set(currentArgName ${currentArg})
        set(${prefix}_${currentArgName})
        set(insideValues "MULTI")
      endif()
    endif()
  endforeach(currentArg)
  # propagate the result variables to the caller:
  foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames})
    set(${prefix}_${arg_name}  ${${prefix}_${arg_name}} PARENT_SCOPE)
  endforeach(arg_name)
  set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE)
 endfunction(CMAKE_PARSE_ARGUMENTS _options _singleArgs _multiArgs)
--- a/cmake/Modules/FindCppUnit.cmake
+++ b/cmake/Modules/FindCppUnit.cmake
@ -0,0 +1,39 @@
 # http://www.cmake.org/pipermail/cmake/2006-October/011446.html
 # Modified to use pkg config and use standard var names
 #
 # Find the CppUnit includes and library
 #
 # This module defines
 # CPPUNIT_INCLUDE_DIR, where to find tiff.h, etc.
 # CPPUNIT_LIBRARIES, the libraries to link against to use CppUnit.
 # CPPUNIT_FOUND, If false, do not try to use CppUnit.
 INCLUDE(FindPkgConfig)
 PKG_CHECK_MODULES(PC_CPPUNIT "cppunit")
 FIND_PATH(CPPUNIT_INCLUDE_DIRS
    NAMES cppunit/TestCase.h
    HINTS ${PC_CPPUNIT_INCLUDE_DIR}
    ${CMAKE_INSTALL_PREFIX}/include
    PATHS
    /usr/local/include
    /usr/include
 )
 FIND_LIBRARY(CPPUNIT_LIBRARIES
    NAMES cppunit
    HINTS ${PC_CPPUNIT_LIBDIR}
    ${CMAKE_INSTALL_PREFIX}/lib
    ${CMAKE_INSTALL_PREFIX}/lib64
    PATHS
    ${CPPUNIT_INCLUDE_DIRS}/../lib
    /usr/local/lib
    /usr/lib
 )
 LIST(APPEND CPPUNIT_LIBRARIES ${CMAKE_DL_LIBS})
 INCLUDE(FindPackageHandleStandardArgs)
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(CPPUNIT DEFAULT_MSG CPPUNIT_LIBRARIES CPPUNIT_INCLUDE_DIRS)
 MARK_AS_ADVANCED(CPPUNIT_LIBRARIES CPPUNIT_INCLUDE_DIRS)
--- a/cmake/Modules/FindGnuradioRuntime.cmake
+++ b/cmake/Modules/FindGnuradioRuntime.cmake
@ -0,0 +1,36 @@
 INCLUDE(FindPkgConfig)
 PKG_CHECK_MODULES(PC_GNURADIO_RUNTIME gnuradio-runtime)
 if(PC_GNURADIO_RUNTIME_FOUND)
  # look for include files
  FIND_PATH(
    GNURADIO_RUNTIME_INCLUDE_DIRS
    NAMES gnuradio/top_block.h
    HINTS $ENV{GNURADIO_RUNTIME_DIR}/include
          ${PC_GNURADIO_RUNTIME_INCLUDE_DIRS}
          ${CMAKE_INSTALL_PREFIX}/include
    PATHS /usr/local/include
          /usr/include
    )
  # look for libs
  FIND_LIBRARY(
    GNURADIO_RUNTIME_LIBRARIES
    NAMES gnuradio-runtime
    HINTS $ENV{GNURADIO_RUNTIME_DIR}/lib
          ${PC_GNURADIO_RUNTIME_LIBDIR}
          ${CMAKE_INSTALL_PREFIX}/lib/
          ${CMAKE_INSTALL_PREFIX}/lib64/
    PATHS /usr/local/lib
          /usr/local/lib64
          /usr/lib
          /usr/lib64
    )
  set(GNURADIO_RUNTIME_FOUND ${PC_GNURADIO_RUNTIME_FOUND})
 endif(PC_GNURADIO_RUNTIME_FOUND)
 INCLUDE(FindPackageHandleStandardArgs)
 # do not check GNURADIO_RUNTIME_INCLUDE_DIRS, is not set when default include path us used.
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(GNURADIO_RUNTIME DEFAULT_MSG GNURADIO_RUNTIME_LIBRARIES)
 MARK_AS_ADVANCED(GNURADIO_RUNTIME_LIBRARIES GNURADIO_RUNTIME_INCLUDE_DIRS)
--- a/cmake/Modules/GrMiscUtils.cmake
+++ b/cmake/Modules/GrMiscUtils.cmake
@ -0,0 +1,528 @@
 # Copyright 2010-2011,2014 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.
 if(DEFINED __INCLUDED_GR_MISC_UTILS_CMAKE)
    return()
 endif()
 set(__INCLUDED_GR_MISC_UTILS_CMAKE TRUE)
 ########################################################################
 # Set global variable macro.
 # Used for subdirectories to export settings.
 # Example: include and library paths.
 ########################################################################
 function(GR_SET_GLOBAL var)
    set(${var} ${ARGN} CACHE INTERNAL "" FORCE)
 endfunction(GR_SET_GLOBAL)
 ########################################################################
 # Set the pre-processor definition if the condition is true.
 #  - def the pre-processor definition to set and condition name
 ########################################################################
 function(GR_ADD_COND_DEF def)
    if(${def})
        add_definitions(-D${def})
    endif(${def})
 endfunction(GR_ADD_COND_DEF)
 ########################################################################
 # Check for a header and conditionally set a compile define.
 #  - hdr the relative path to the header file
 #  - def the pre-processor definition to set
 ########################################################################
 function(GR_CHECK_HDR_N_DEF hdr def)
    include(CheckIncludeFileCXX)
    CHECK_INCLUDE_FILE_CXX(${hdr} ${def})
    GR_ADD_COND_DEF(${def})
 endfunction(GR_CHECK_HDR_N_DEF)
 ########################################################################
 # Include subdirectory macro.
 # Sets the CMake directory variables,
 # includes the subdirectory CMakeLists.txt,
 # resets the CMake directory variables.
 #
 # This macro includes subdirectories rather than adding them
 # so that the subdirectory can affect variables in the level above.
 # This provides a work-around for the lack of convenience libraries.
 # This way a subdirectory can append to the list of library sources.
 ########################################################################
 macro(GR_INCLUDE_SUBDIRECTORY subdir)
    #insert the current directories on the front of the list
    list(INSERT _cmake_source_dirs 0 ${CMAKE_CURRENT_SOURCE_DIR})
    list(INSERT _cmake_binary_dirs 0 ${CMAKE_CURRENT_BINARY_DIR})
    #set the current directories to the names of the subdirs
    set(CMAKE_CURRENT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/${subdir})
    set(CMAKE_CURRENT_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/${subdir})
    #include the subdirectory CMakeLists to run it
    file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
    include(${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt)
    #reset the value of the current directories
    list(GET _cmake_source_dirs 0 CMAKE_CURRENT_SOURCE_DIR)
    list(GET _cmake_binary_dirs 0 CMAKE_CURRENT_BINARY_DIR)
    #pop the subdir names of the front of the list
    list(REMOVE_AT _cmake_source_dirs 0)
    list(REMOVE_AT _cmake_binary_dirs 0)
 endmacro(GR_INCLUDE_SUBDIRECTORY)
 ########################################################################
 # Check if a compiler flag works and conditionally set a compile define.
 #  - flag the compiler flag to check for
 #  - have the variable to set with result
 ########################################################################
 macro(GR_ADD_CXX_COMPILER_FLAG_IF_AVAILABLE flag have)
    include(CheckCXXCompilerFlag)
    CHECK_CXX_COMPILER_FLAG(${flag} ${have})
    if(${have})
      if(${CMAKE_VERSION} VERSION_GREATER "2.8.4")
        STRING(FIND "${CMAKE_CXX_FLAGS}" "${flag}" flag_dup)
        if(${flag_dup} EQUAL -1)
          set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
          set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
        endif(${flag_dup} EQUAL -1)
      endif(${CMAKE_VERSION} VERSION_GREATER "2.8.4")
    endif(${have})
 endmacro(GR_ADD_CXX_COMPILER_FLAG_IF_AVAILABLE)
 ########################################################################
 # Generates the .la libtool file
 # This appears to generate libtool files that cannot be used by auto*.
 # Usage GR_LIBTOOL(TARGET [target] DESTINATION [dest])
 # Notice: there is not COMPONENT option, these will not get distributed.
 ########################################################################
 function(GR_LIBTOOL)
    if(NOT DEFINED GENERATE_LIBTOOL)
        set(GENERATE_LIBTOOL OFF) #disabled by default
    endif()
    if(GENERATE_LIBTOOL)
        include(CMakeParseArgumentsCopy)
        CMAKE_PARSE_ARGUMENTS(GR_LIBTOOL "" "TARGET;DESTINATION" "" ${ARGN})
        find_program(LIBTOOL libtool)
        if(LIBTOOL)
            include(CMakeMacroLibtoolFile)
            CREATE_LIBTOOL_FILE(${GR_LIBTOOL_TARGET} /${GR_LIBTOOL_DESTINATION})
        endif(LIBTOOL)
    endif(GENERATE_LIBTOOL)
 endfunction(GR_LIBTOOL)
 ########################################################################
 # Do standard things to the library target
 # - set target properties
 # - make install rules
 # Also handle gnuradio custom naming conventions w/ extras mode.
 ########################################################################
 function(GR_LIBRARY_FOO target)
    #parse the arguments for component names
    include(CMakeParseArgumentsCopy)
    CMAKE_PARSE_ARGUMENTS(GR_LIBRARY "" "RUNTIME_COMPONENT;DEVEL_COMPONENT" "" ${ARGN})
    #set additional target properties
    set_target_properties(${target} PROPERTIES SOVERSION ${LIBVER})
    #install the generated files like so...
    install(TARGETS ${target}
        LIBRARY DESTINATION ${GR_LIBRARY_DIR} COMPONENT ${GR_LIBRARY_RUNTIME_COMPONENT} # .so/.dylib file
        ARCHIVE DESTINATION ${GR_LIBRARY_DIR} COMPONENT ${GR_LIBRARY_DEVEL_COMPONENT}   # .lib file
        RUNTIME DESTINATION ${GR_RUNTIME_DIR} COMPONENT ${GR_LIBRARY_RUNTIME_COMPONENT} # .dll file
    )
    #extras mode enabled automatically on linux
    if(NOT DEFINED LIBRARY_EXTRAS)
        set(LIBRARY_EXTRAS ${LINUX})
    endif()
    #special extras mode to enable alternative naming conventions
    if(LIBRARY_EXTRAS)
        #create .la file before changing props
        GR_LIBTOOL(TARGET ${target} DESTINATION ${GR_LIBRARY_DIR})
        #give the library a special name with ultra-zero soversion
        set_target_properties(${target} PROPERTIES OUTPUT_NAME ${target}-${LIBVER} SOVERSION "0.0.0")
        set(target_name lib${target}-${LIBVER}.so.0.0.0)
        #custom command to generate symlinks
        add_custom_command(
            TARGET ${target}
            POST_BUILD
            COMMAND ${CMAKE_COMMAND} -E create_symlink ${target_name} ${CMAKE_CURRENT_BINARY_DIR}/lib${target}.so
            COMMAND ${CMAKE_COMMAND} -E create_symlink ${target_name} ${CMAKE_CURRENT_BINARY_DIR}/lib${target}-${LIBVER}.so.0
            COMMAND ${CMAKE_COMMAND} -E touch ${target_name} #so the symlinks point to something valid so cmake 2.6 will install
        )
        #and install the extra symlinks
        install(
            FILES
            ${CMAKE_CURRENT_BINARY_DIR}/lib${target}.so
            ${CMAKE_CURRENT_BINARY_DIR}/lib${target}-${LIBVER}.so.0
            DESTINATION ${GR_LIBRARY_DIR} COMPONENT ${GR_LIBRARY_RUNTIME_COMPONENT}
        )
    endif(LIBRARY_EXTRAS)
 endfunction(GR_LIBRARY_FOO)
 ########################################################################
 # Create a dummy custom command that depends on other targets.
 # Usage:
 #   GR_GEN_TARGET_DEPS(unique_name target_deps <target1> <target2> ...)
 #   ADD_CUSTOM_COMMAND(<the usual args> ${target_deps})
 #
 # Custom command cant depend on targets, but can depend on executables,
 # and executables can depend on targets. So this is the process:
 ########################################################################
 function(GR_GEN_TARGET_DEPS name var)
    file(
        WRITE ${CMAKE_CURRENT_BINARY_DIR}/${name}.cpp.in
        "int main(void){return 0;}\n"
    )
    execute_process(
        COMMAND ${CMAKE_COMMAND} -E copy_if_different
        ${CMAKE_CURRENT_BINARY_DIR}/${name}.cpp.in
        ${CMAKE_CURRENT_BINARY_DIR}/${name}.cpp
    )
    add_executable(${name} ${CMAKE_CURRENT_BINARY_DIR}/${name}.cpp)
    if(ARGN)
        add_dependencies(${name} ${ARGN})
    endif(ARGN)
    if(CMAKE_CROSSCOMPILING)
        set(${var} "DEPENDS;${name}" PARENT_SCOPE) #cant call command when cross
    else()
        set(${var} "DEPENDS;${name};COMMAND;${name}" PARENT_SCOPE)
    endif()
 endfunction(GR_GEN_TARGET_DEPS)
 ########################################################################
 # Control use of gr_logger
 # Usage:
 #   GR_LOGGING()
 #
 # Will set ENABLE_GR_LOG to 1 by default.
 # Can manually set with -DENABLE_GR_LOG=0|1
 ########################################################################
 function(GR_LOGGING)
  find_package(Log4cpp)
  OPTION(ENABLE_GR_LOG "Use gr_logger" ON)
  if(ENABLE_GR_LOG)
    # If gr_logger is enabled, make it usable
    add_definitions( -DENABLE_GR_LOG )
    # also test LOG4CPP; if we have it, use this version of the logger
    # otherwise, default to the stdout/stderr model.
    if(LOG4CPP_FOUND)
      SET(HAVE_LOG4CPP True CACHE INTERNAL "" FORCE)
      add_definitions( -DHAVE_LOG4CPP )
    else(not LOG4CPP_FOUND)
      SET(HAVE_LOG4CPP False CACHE INTERNAL "" FORCE)
      SET(LOG4CPP_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
      SET(LOG4CPP_LIBRARY_DIRS "" CACHE INTERNAL "" FORCE)
      SET(LOG4CPP_LIBRARIES "" CACHE INTERNAL "" FORCE)
    endif(LOG4CPP_FOUND)
    SET(ENABLE_GR_LOG ${ENABLE_GR_LOG} CACHE INTERNAL "" FORCE)
  else(ENABLE_GR_LOG)
    SET(HAVE_LOG4CPP False CACHE INTERNAL "" FORCE)
    SET(LOG4CPP_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
    SET(LOG4CPP_LIBRARY_DIRS "" CACHE INTERNAL "" FORCE)
    SET(LOG4CPP_LIBRARIES "" CACHE INTERNAL "" FORCE)
  endif(ENABLE_GR_LOG)
  message(STATUS "ENABLE_GR_LOG set to ${ENABLE_GR_LOG}.")
  message(STATUS "HAVE_LOG4CPP set to ${HAVE_LOG4CPP}.")
  message(STATUS "LOG4CPP_LIBRARIES set to ${LOG4CPP_LIBRARIES}.")
 endfunction(GR_LOGGING)
 ########################################################################
 # Run GRCC to compile .grc files into .py files.
 #
 # Usage: GRCC(filename, directory)
 #    - filenames: List of file name of .grc file
 #    - directory: directory of built .py file - usually in
 #                 ${CMAKE_CURRENT_BINARY_DIR}
 #    - Sets PYFILES: output converted GRC file names to Python files.
 ########################################################################
 function(GRCC)
  # Extract directory from list of args, remove it for the list of filenames.
  list(GET ARGV -1 directory)
  list(REMOVE_AT ARGV -1)
  set(filenames ${ARGV})
  file(MAKE_DIRECTORY ${directory})
  SET(GRCC_COMMAND ${CMAKE_SOURCE_DIR}/gr-utils/python/grcc)
  # GRCC uses some stuff in grc and gnuradio-runtime, so we force
  # the known paths here
  list(APPEND PYTHONPATHS
    ${CMAKE_SOURCE_DIR}
    ${CMAKE_SOURCE_DIR}/gnuradio-runtime/python
    ${CMAKE_SOURCE_DIR}/gnuradio-runtime/lib/swig
    ${CMAKE_BINARY_DIR}/gnuradio-runtime/lib/swig
    )
  if(WIN32)
    #SWIG generates the python library files into a subdirectory.
    #Therefore, we must append this subdirectory into PYTHONPATH.
    #Only do this for the python directories matching the following:
    foreach(pydir ${PYTHONPATHS})
      get_filename_component(name ${pydir} NAME)
      if(name MATCHES "^(swig|lib|src)$")
        list(APPEND PYTHONPATHS ${pydir}/${CMAKE_BUILD_TYPE})
      endif()
    endforeach(pydir)
  endif(WIN32)
  file(TO_NATIVE_PATH "${PYTHONPATHS}" pypath)
  if(UNIX)
    list(APPEND pypath "$PYTHONPATH")
    string(REPLACE ";" ":" pypath "${pypath}")
    set(ENV{PYTHONPATH} ${pypath})
  endif(UNIX)
  if(WIN32)
    list(APPEND pypath "%PYTHONPATH%")
    string(REPLACE ";" "\\;" pypath "${pypath}")
    #list(APPEND environs "PYTHONPATH=${pypath}")
    set(ENV{PYTHONPATH} ${pypath})
  endif(WIN32)
  foreach(f ${filenames})
    execute_process(
      COMMAND ${GRCC_COMMAND} -d ${directory} ${f}
      )
    string(REPLACE ".grc" ".py" pyfile "${f}")
    string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}" pyfile "${pyfile}")
    list(APPEND pyfiles ${pyfile})
  endforeach(f)
  set(PYFILES ${pyfiles} PARENT_SCOPE)
 endfunction(GRCC)
 ########################################################################
 # Check if HAVE_PTHREAD_SETSCHEDPARAM and HAVE_SCHED_SETSCHEDULER
 #  should be defined
 ########################################################################
 macro(GR_CHECK_LINUX_SCHED_AVAIL)
 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)
 endmacro(GR_CHECK_LINUX_SCHED_AVAIL)
 ########################################################################
 # Macros to generate source and header files from template
 ########################################################################
 macro(GR_EXPAND_X_H component root)
  include(GrPython)
  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
 "#!${PYTHON_EXECUTABLE}
 import sys, os, re
 sys.path.append('${GR_RUNTIME_PYTHONPATH}')
 sys.path.append('${CMAKE_SOURCE_DIR}/python')
 os.environ['srcdir'] = '${CMAKE_CURRENT_SOURCE_DIR}'
 os.chdir('${CMAKE_CURRENT_BINARY_DIR}')
 if __name__ == '__main__':
    import build_utils
    root, inp = sys.argv[1:3]
    for sig in sys.argv[3:]:
        name = re.sub ('X+', sig, root)
        d = build_utils.standard_dict2(name, sig, '${component}')
        build_utils.expand_template(d, inp)
 ")
  #make a list of all the generated headers
  unset(expanded_files_h)
  foreach(sig ${ARGN})
    string(REGEX REPLACE "X+" ${sig} name ${root})
    list(APPEND expanded_files_h ${CMAKE_CURRENT_BINARY_DIR}/${name}.h)
  endforeach(sig)
  unset(name)
  #create a command to generate the headers
  add_custom_command(
    OUTPUT ${expanded_files_h}
    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.h.t
    COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
    ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
    ${root} ${root}.h.t ${ARGN}
  )
  #install rules for the generated headers
  list(APPEND generated_includes ${expanded_files_h})
 endmacro(GR_EXPAND_X_H)
 macro(GR_EXPAND_X_CC_H component root)
  include(GrPython)
  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
 "#!${PYTHON_EXECUTABLE}
 import sys, os, re
 sys.path.append('${GR_RUNTIME_PYTHONPATH}')
 sys.path.append('${CMAKE_SOURCE_DIR}/python')
 os.environ['srcdir'] = '${CMAKE_CURRENT_SOURCE_DIR}'
 os.chdir('${CMAKE_CURRENT_BINARY_DIR}')
 if __name__ == '__main__':
    import build_utils
    root, inp = sys.argv[1:3]
    for sig in sys.argv[3:]:
        name = re.sub ('X+', sig, root)
        d = build_utils.standard_impl_dict2(name, sig, '${component}')
        build_utils.expand_template(d, inp)
 ")
  #make a list of all the generated files
  unset(expanded_files_cc)
  unset(expanded_files_h)
  foreach(sig ${ARGN})
    string(REGEX REPLACE "X+" ${sig} name ${root})
    list(APPEND expanded_files_cc ${CMAKE_CURRENT_BINARY_DIR}/${name}.cc)
    list(APPEND expanded_files_h  ${CMAKE_CURRENT_BINARY_DIR}/${name}.h)
  endforeach(sig)
  unset(name)
  #create a command to generate the source files
  add_custom_command(
    OUTPUT ${expanded_files_cc}
    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.cc.t
    COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
    ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
    ${root} ${root}.cc.t ${ARGN}
  )
  #create a command to generate the header files
  add_custom_command(
    OUTPUT ${expanded_files_h}
    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.h.t
    COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
    ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
    ${root} ${root}.h.t ${ARGN}
  )
  #make source files depends on headers to force generation
  set_source_files_properties(${expanded_files_cc}
    PROPERTIES OBJECT_DEPENDS "${expanded_files_h}"
  )
  #install rules for the generated files
  list(APPEND generated_sources ${expanded_files_cc})
  list(APPEND generated_headers ${expanded_files_h})
 endmacro(GR_EXPAND_X_CC_H)
 macro(GR_EXPAND_X_CC_H_IMPL component root)
  include(GrPython)
  file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
 "#!${PYTHON_EXECUTABLE}
 import sys, os, re
 sys.path.append('${GR_RUNTIME_PYTHONPATH}')
 sys.path.append('${CMAKE_SOURCE_DIR}/python')
 os.environ['srcdir'] = '${CMAKE_CURRENT_SOURCE_DIR}'
 os.chdir('${CMAKE_CURRENT_BINARY_DIR}')
 if __name__ == '__main__':
    import build_utils
    root, inp = sys.argv[1:3]
    for sig in sys.argv[3:]:
        name = re.sub ('X+', sig, root)
        d = build_utils.standard_dict(name, sig, '${component}')
        build_utils.expand_template(d, inp, '_impl')
 ")
  #make a list of all the generated files
  unset(expanded_files_cc_impl)
  unset(expanded_files_h_impl)
  unset(expanded_files_h)
  foreach(sig ${ARGN})
    string(REGEX REPLACE "X+" ${sig} name ${root})
    list(APPEND expanded_files_cc_impl ${CMAKE_CURRENT_BINARY_DIR}/${name}_impl.cc)
    list(APPEND expanded_files_h_impl ${CMAKE_CURRENT_BINARY_DIR}/${name}_impl.h)
    list(APPEND expanded_files_h ${CMAKE_CURRENT_BINARY_DIR}/../include/gnuradio/${component}/${name}.h)
  endforeach(sig)
  unset(name)
  #create a command to generate the _impl.cc files
  add_custom_command(
    OUTPUT ${expanded_files_cc_impl}
    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}_impl.cc.t
    COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
    ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
    ${root} ${root}_impl.cc.t ${ARGN}
  )
  #create a command to generate the _impl.h files
  add_custom_command(
    OUTPUT ${expanded_files_h_impl}
    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}_impl.h.t
    COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
    ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
    ${root} ${root}_impl.h.t ${ARGN}
  )
  #make _impl.cc source files depend on _impl.h to force generation
  set_source_files_properties(${expanded_files_cc_impl}
    PROPERTIES OBJECT_DEPENDS "${expanded_files_h_impl}"
  )
  #make _impl.h source files depend on headers to force generation
  set_source_files_properties(${expanded_files_h_impl}
    PROPERTIES OBJECT_DEPENDS "${expanded_files_h}"
  )
  #install rules for the generated files
  list(APPEND generated_sources ${expanded_files_cc_impl})
  list(APPEND generated_headers ${expanded_files_h_impl})
 endmacro(GR_EXPAND_X_CC_H_IMPL)
--- a/cmake/Modules/GrPlatform.cmake
+++ b/cmake/Modules/GrPlatform.cmake
@ -0,0 +1,54 @@
 # 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 GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 if(DEFINED __INCLUDED_GR_PLATFORM_CMAKE)
    return()
 endif()
 set(__INCLUDED_GR_PLATFORM_CMAKE TRUE)
 ########################################################################
 # Setup additional defines for OS types
 ########################################################################
 if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
    set(LINUX TRUE)
 endif()
 if(NOT CMAKE_CROSSCOMPILING AND LINUX AND EXISTS "/etc/debian_version")
    set(DEBIAN TRUE)
 endif()
 if(NOT CMAKE_CROSSCOMPILING AND LINUX AND EXISTS "/etc/redhat-release")
    set(REDHAT TRUE)
 endif()
 if(NOT CMAKE_CROSSCOMPILING AND LINUX AND EXISTS "/etc/slackware-version")
    set(SLACKWARE TRUE)
 endif()
 ########################################################################
 # when the library suffix should be 64 (applies to redhat linux family)
 ########################################################################
 if (REDHAT OR SLACKWARE)
    set(LIB64_CONVENTION TRUE)
 endif()
 if(NOT DEFINED LIB_SUFFIX AND LIB64_CONVENTION AND CMAKE_SYSTEM_PROCESSOR MATCHES "64$")
    set(LIB_SUFFIX 64)
 endif()
 set(LIB_SUFFIX ${LIB_SUFFIX} CACHE STRING "lib directory suffix")
--- a/cmake/Modules/GrPython.cmake
+++ b/cmake/Modules/GrPython.cmake
@ -0,0 +1,241 @@
 # Copyright 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.
 if(DEFINED __INCLUDED_GR_PYTHON_CMAKE)
    return()
 endif()
 set(__INCLUDED_GR_PYTHON_CMAKE TRUE)
 ########################################################################
 # Setup the python interpreter:
 # This allows the user to specify a specific interpreter,
 # or finds the interpreter via the built-in cmake module.
 ########################################################################
 #this allows the user to override PYTHON_EXECUTABLE
 if(PYTHON_EXECUTABLE)
    set(PYTHONINTERP_FOUND TRUE)
 #otherwise if not set, try to automatically find it
 else(PYTHON_EXECUTABLE)
    #use the built-in find script
    find_package(PythonInterp 2)
    #and if that fails use the find program routine
    if(NOT PYTHONINTERP_FOUND)
        find_program(PYTHON_EXECUTABLE NAMES python python2 python2.7 python2.6 python2.5)
        if(PYTHON_EXECUTABLE)
            set(PYTHONINTERP_FOUND TRUE)
        endif(PYTHON_EXECUTABLE)
    endif(NOT PYTHONINTERP_FOUND)
 endif(PYTHON_EXECUTABLE)
 if (CMAKE_CROSSCOMPILING)
    set(QA_PYTHON_EXECUTABLE "/usr/bin/python")
 else (CMAKE_CROSSCOMPILING)
    set(QA_PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE})
 endif(CMAKE_CROSSCOMPILING)
 #make the path to the executable appear in the cmake gui
 set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE} CACHE FILEPATH "python interpreter")
 set(QA_PYTHON_EXECUTABLE ${QA_PYTHON_EXECUTABLE} CACHE FILEPATH "python interpreter for QA tests")
 #make sure we can use -B with python (introduced in 2.6)
 if(PYTHON_EXECUTABLE)
    execute_process(
        COMMAND ${PYTHON_EXECUTABLE} -B -c ""
        OUTPUT_QUIET ERROR_QUIET
        RESULT_VARIABLE PYTHON_HAS_DASH_B_RESULT
    )
    if(PYTHON_HAS_DASH_B_RESULT EQUAL 0)
        set(PYTHON_DASH_B "-B")
    endif()
 endif(PYTHON_EXECUTABLE)
 ########################################################################
 # Check for the existence of a python module:
 # - desc a string description of the check
 # - mod the name of the module to import
 # - cmd an additional command to run
 # - have the result variable to set
 ########################################################################
 macro(GR_PYTHON_CHECK_MODULE desc mod cmd have)
    message(STATUS "")
    message(STATUS "Python checking for ${desc}")
    execute_process(
        COMMAND ${PYTHON_EXECUTABLE} -c "
 #########################################
 try:
    import ${mod}
    assert ${cmd}
 except ImportError, AssertionError: exit(-1)
 except: pass
 #########################################"
        RESULT_VARIABLE ${have}
    )
    if(${have} EQUAL 0)
        message(STATUS "Python checking for ${desc} - found")
        set(${have} TRUE)
    else(${have} EQUAL 0)
        message(STATUS "Python checking for ${desc} - not found")
        set(${have} FALSE)
    endif(${have} EQUAL 0)
 endmacro(GR_PYTHON_CHECK_MODULE)
 ########################################################################
 # Sets the python installation directory GR_PYTHON_DIR
 ########################################################################
 if(NOT DEFINED GR_PYTHON_DIR)
 execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "
 from distutils import sysconfig
 print sysconfig.get_python_lib(plat_specific=True, prefix='')
 " OUTPUT_VARIABLE GR_PYTHON_DIR OUTPUT_STRIP_TRAILING_WHITESPACE
 )
 endif()
 file(TO_CMAKE_PATH ${GR_PYTHON_DIR} GR_PYTHON_DIR)
 ########################################################################
 # Create an always-built target with a unique name
 # Usage: GR_UNIQUE_TARGET(<description> <dependencies list>)
 ########################################################################
 function(GR_UNIQUE_TARGET desc)
    file(RELATIVE_PATH reldir ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR})
    execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import re, hashlib
 unique = hashlib.md5('${reldir}${ARGN}').hexdigest()[:5]
 print(re.sub('\\W', '_', '${desc} ${reldir} ' + unique))"
    OUTPUT_VARIABLE _target OUTPUT_STRIP_TRAILING_WHITESPACE)
    add_custom_target(${_target} ALL DEPENDS ${ARGN})
 endfunction(GR_UNIQUE_TARGET)
 ########################################################################
 # Install python sources (also builds and installs byte-compiled python)
 ########################################################################
 function(GR_PYTHON_INSTALL)
    include(CMakeParseArgumentsCopy)
    CMAKE_PARSE_ARGUMENTS(GR_PYTHON_INSTALL "" "DESTINATION;COMPONENT" "FILES;PROGRAMS" ${ARGN})
    ####################################################################
    if(GR_PYTHON_INSTALL_FILES)
    ####################################################################
        install(${ARGN}) #installs regular python files
        #create a list of all generated files
        unset(pysrcfiles)
        unset(pycfiles)
        unset(pyofiles)
        foreach(pyfile ${GR_PYTHON_INSTALL_FILES})
            get_filename_component(pyfile ${pyfile} ABSOLUTE)
            list(APPEND pysrcfiles ${pyfile})
            #determine if this file is in the source or binary directory
            file(RELATIVE_PATH source_rel_path ${CMAKE_CURRENT_SOURCE_DIR} ${pyfile})
            string(LENGTH "${source_rel_path}" source_rel_path_len)
            file(RELATIVE_PATH binary_rel_path ${CMAKE_CURRENT_BINARY_DIR} ${pyfile})
            string(LENGTH "${binary_rel_path}" binary_rel_path_len)
            #and set the generated path appropriately
            if(${source_rel_path_len} GREATER ${binary_rel_path_len})
                set(pygenfile ${CMAKE_CURRENT_BINARY_DIR}/${binary_rel_path})
            else()
                set(pygenfile ${CMAKE_CURRENT_BINARY_DIR}/${source_rel_path})
            endif()
            list(APPEND pycfiles ${pygenfile}c)
            list(APPEND pyofiles ${pygenfile}o)
            #ensure generation path exists
            get_filename_component(pygen_path ${pygenfile} PATH)
            file(MAKE_DIRECTORY ${pygen_path})
        endforeach(pyfile)
        #the command to generate the pyc files
        add_custom_command(
            DEPENDS ${pysrcfiles} OUTPUT ${pycfiles}
            COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_BINARY_DIR}/python_compile_helper.py ${pysrcfiles} ${pycfiles}
        )
        #the command to generate the pyo files
        add_custom_command(
            DEPENDS ${pysrcfiles} OUTPUT ${pyofiles}
            COMMAND ${PYTHON_EXECUTABLE} -O ${CMAKE_BINARY_DIR}/python_compile_helper.py ${pysrcfiles} ${pyofiles}
        )
        #create install rule and add generated files to target list
        set(python_install_gen_targets ${pycfiles} ${pyofiles})
        install(FILES ${python_install_gen_targets}
            DESTINATION ${GR_PYTHON_INSTALL_DESTINATION}
            COMPONENT ${GR_PYTHON_INSTALL_COMPONENT}
        )
    ####################################################################
    elseif(GR_PYTHON_INSTALL_PROGRAMS)
    ####################################################################
        file(TO_NATIVE_PATH ${PYTHON_EXECUTABLE} pyexe_native)
        if (CMAKE_CROSSCOMPILING)
           set(pyexe_native "/usr/bin/env python")
        endif()
        foreach(pyfile ${GR_PYTHON_INSTALL_PROGRAMS})
            get_filename_component(pyfile_name ${pyfile} NAME)
            get_filename_component(pyfile ${pyfile} ABSOLUTE)
            string(REPLACE "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" pyexefile "${pyfile}.exe")
            list(APPEND python_install_gen_targets ${pyexefile})
            get_filename_component(pyexefile_path ${pyexefile} PATH)
            file(MAKE_DIRECTORY ${pyexefile_path})
            add_custom_command(
                OUTPUT ${pyexefile} DEPENDS ${pyfile}
                COMMAND ${PYTHON_EXECUTABLE} -c
                "import re; R=re.compile('^\#!.*$\\n',flags=re.MULTILINE); open('${pyexefile}','w').write('\#!${pyexe_native}\\n'+R.sub('',open('${pyfile}','r').read()))"
                COMMENT "Shebangin ${pyfile_name}"
                VERBATIM
            )
            #on windows, python files need an extension to execute
            get_filename_component(pyfile_ext ${pyfile} EXT)
            if(WIN32 AND NOT pyfile_ext)
                set(pyfile_name "${pyfile_name}.py")
            endif()
            install(PROGRAMS ${pyexefile} RENAME ${pyfile_name}
                DESTINATION ${GR_PYTHON_INSTALL_DESTINATION}
                COMPONENT ${GR_PYTHON_INSTALL_COMPONENT}
            )
        endforeach(pyfile)
    endif()
    GR_UNIQUE_TARGET("pygen" ${python_install_gen_targets})
 endfunction(GR_PYTHON_INSTALL)
 ########################################################################
 # Write the python helper script that generates byte code files
 ########################################################################
 file(WRITE ${CMAKE_BINARY_DIR}/python_compile_helper.py "
 import sys, py_compile
 files = sys.argv[1:]
 srcs, gens = files[:len(files)/2], files[len(files)/2:]
 for src, gen in zip(srcs, gens):
    py_compile.compile(file=src, cfile=gen, doraise=True)
 ")
--- a/cmake/Modules/GrSwig.cmake
+++ b/cmake/Modules/GrSwig.cmake
@ -0,0 +1,251 @@
 # Copyright 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.
 if(DEFINED __INCLUDED_GR_SWIG_CMAKE)
    return()
 endif()
 set(__INCLUDED_GR_SWIG_CMAKE TRUE)
 include(GrPython)
 ########################################################################
 # Builds a swig documentation file to be generated into python docstrings
 # Usage: GR_SWIG_MAKE_DOCS(output_file input_path input_path....)
 #
 # Set the following variable to specify extra dependent targets:
 #   - GR_SWIG_DOCS_SOURCE_DEPS
 #   - GR_SWIG_DOCS_TARGET_DEPS
 ########################################################################
 function(GR_SWIG_MAKE_DOCS output_file)
    if(ENABLE_DOXYGEN)
        #setup the input files variable list, quote formated
        set(input_files)
        unset(INPUT_PATHS)
        foreach(input_path ${ARGN})
            if(IS_DIRECTORY ${input_path}) #when input path is a directory
                file(GLOB input_path_h_files ${input_path}/*.h)
            else() #otherwise its just a file, no glob
                set(input_path_h_files ${input_path})
            endif()
            list(APPEND input_files ${input_path_h_files})
            set(INPUT_PATHS "${INPUT_PATHS} \"${input_path}\"")
        endforeach(input_path)
        #determine the output directory
        get_filename_component(name ${output_file} NAME_WE)
        get_filename_component(OUTPUT_DIRECTORY ${output_file} PATH)
        set(OUTPUT_DIRECTORY ${OUTPUT_DIRECTORY}/${name}_swig_docs)
        make_directory(${OUTPUT_DIRECTORY})
        #generate the Doxyfile used by doxygen
        configure_file(
            ${CMAKE_SOURCE_DIR}/docs/doxygen/Doxyfile.swig_doc.in
            ${OUTPUT_DIRECTORY}/Doxyfile
        @ONLY)
        #Create a dummy custom command that depends on other targets
        include(GrMiscUtils)
        GR_GEN_TARGET_DEPS(_${name}_tag tag_deps ${GR_SWIG_DOCS_TARGET_DEPS})
        #call doxygen on the Doxyfile + input headers
        add_custom_command(
            OUTPUT ${OUTPUT_DIRECTORY}/xml/index.xml
            DEPENDS ${input_files} ${GR_SWIG_DOCS_SOURCE_DEPS} ${tag_deps}
            COMMAND ${DOXYGEN_EXECUTABLE} ${OUTPUT_DIRECTORY}/Doxyfile
            COMMENT "Generating doxygen xml for ${name} docs"
        )
        #call the swig_doc script on the xml files
        add_custom_command(
            OUTPUT ${output_file}
            DEPENDS ${input_files} ${stamp-file} ${OUTPUT_DIRECTORY}/xml/index.xml
            COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
                ${CMAKE_SOURCE_DIR}/docs/doxygen/swig_doc.py
                ${OUTPUT_DIRECTORY}/xml
                ${output_file}
            COMMENT "Generating python docstrings for ${name}"
            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/docs/doxygen
        )
    else(ENABLE_DOXYGEN)
        file(WRITE ${output_file} "\n") #no doxygen -> empty file
    endif(ENABLE_DOXYGEN)
 endfunction(GR_SWIG_MAKE_DOCS)
 ########################################################################
 # Build a swig target for the common gnuradio use case. Usage:
 # GR_SWIG_MAKE(target ifile ifile ifile...)
 #
 # Set the following variables before calling:
 #   - GR_SWIG_FLAGS
 #   - GR_SWIG_INCLUDE_DIRS
 #   - GR_SWIG_LIBRARIES
 #   - GR_SWIG_SOURCE_DEPS
 #   - GR_SWIG_TARGET_DEPS
 #   - GR_SWIG_DOC_FILE
 #   - GR_SWIG_DOC_DIRS
 ########################################################################
 macro(GR_SWIG_MAKE name)
    set(ifiles ${ARGN})
    # Shimming this in here to take care of a SWIG bug with handling
    # vector<size_t> and vector<unsigned int> (on 32-bit machines) and
    # vector<long unsigned int> (on 64-bit machines). Use this to test
    # the size of size_t, then set SIZE_T_32 if it's a 32-bit machine
    # or not if it's 64-bit. The logic in gr_type.i handles the rest.
    INCLUDE(CheckTypeSize)
    CHECK_TYPE_SIZE("size_t" SIZEOF_SIZE_T)
    CHECK_TYPE_SIZE("unsigned int" SIZEOF_UINT)
    if(${SIZEOF_SIZE_T} EQUAL ${SIZEOF_UINT})
      list(APPEND GR_SWIG_FLAGS -DSIZE_T_32)
    endif(${SIZEOF_SIZE_T} EQUAL ${SIZEOF_UINT})
    #do swig doc generation if specified
    if(GR_SWIG_DOC_FILE)
        set(GR_SWIG_DOCS_SOURCE_DEPS ${GR_SWIG_SOURCE_DEPS})
        list(APPEND GR_SWIG_DOCS_TARGET_DEPS ${GR_SWIG_TARGET_DEPS})
        GR_SWIG_MAKE_DOCS(${GR_SWIG_DOC_FILE} ${GR_SWIG_DOC_DIRS})
        add_custom_target(${name}_swig_doc DEPENDS ${GR_SWIG_DOC_FILE})
        list(APPEND GR_SWIG_TARGET_DEPS ${name}_swig_doc ${GR_RUNTIME_SWIG_DOC_FILE})
    endif()
    #append additional include directories
    find_package(PythonLibs 2)
    list(APPEND GR_SWIG_INCLUDE_DIRS ${PYTHON_INCLUDE_PATH}) #deprecated name (now dirs)
    list(APPEND GR_SWIG_INCLUDE_DIRS ${PYTHON_INCLUDE_DIRS})
    #prepend local swig directories
    list(INSERT GR_SWIG_INCLUDE_DIRS 0 ${CMAKE_CURRENT_SOURCE_DIR})
    list(INSERT GR_SWIG_INCLUDE_DIRS 0 ${CMAKE_CURRENT_BINARY_DIR})
    #determine include dependencies for swig file
    execute_process(
        COMMAND ${PYTHON_EXECUTABLE}
            ${CMAKE_BINARY_DIR}/get_swig_deps.py
            "${ifiles}" "${GR_SWIG_INCLUDE_DIRS}"
        OUTPUT_STRIP_TRAILING_WHITESPACE
        OUTPUT_VARIABLE SWIG_MODULE_${name}_EXTRA_DEPS
        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    )
    #Create a dummy custom command that depends on other targets
    include(GrMiscUtils)
    GR_GEN_TARGET_DEPS(_${name}_swig_tag tag_deps ${GR_SWIG_TARGET_DEPS})
    set(tag_file ${CMAKE_CURRENT_BINARY_DIR}/${name}.tag)
    add_custom_command(
        OUTPUT ${tag_file}
        DEPENDS ${GR_SWIG_SOURCE_DEPS} ${tag_deps}
        COMMAND ${CMAKE_COMMAND} -E touch ${tag_file}
    )
    #append the specified include directories
    include_directories(${GR_SWIG_INCLUDE_DIRS})
    list(APPEND SWIG_MODULE_${name}_EXTRA_DEPS ${tag_file})
    #setup the swig flags with flags and include directories
    set(CMAKE_SWIG_FLAGS -fvirtual -modern -keyword -w511 -module ${name} ${GR_SWIG_FLAGS})
    foreach(dir ${GR_SWIG_INCLUDE_DIRS})
        list(APPEND CMAKE_SWIG_FLAGS "-I${dir}")
    endforeach(dir)
    #set the C++ property on the swig .i file so it builds
    set_source_files_properties(${ifiles} PROPERTIES CPLUSPLUS ON)
    #setup the actual swig library target to be built
    include(UseSWIG)
    SWIG_ADD_MODULE(${name} python ${ifiles})
    SWIG_LINK_LIBRARIES(${name} ${PYTHON_LIBRARIES} ${GR_SWIG_LIBRARIES})
    if(${name} STREQUAL "runtime_swig")
        SET_TARGET_PROPERTIES(${SWIG_MODULE_runtime_swig_REAL_NAME} PROPERTIES DEFINE_SYMBOL "gnuradio_runtime_EXPORTS")
    endif(${name} STREQUAL "runtime_swig")
 endmacro(GR_SWIG_MAKE)
 ########################################################################
 # Install swig targets generated by GR_SWIG_MAKE. Usage:
 # GR_SWIG_INSTALL(
 #   TARGETS target target target...
 #   [DESTINATION destination]
 #   [COMPONENT component]
 # )
 ########################################################################
 macro(GR_SWIG_INSTALL)
    include(CMakeParseArgumentsCopy)
    CMAKE_PARSE_ARGUMENTS(GR_SWIG_INSTALL "" "DESTINATION;COMPONENT" "TARGETS" ${ARGN})
    foreach(name ${GR_SWIG_INSTALL_TARGETS})
        install(TARGETS ${SWIG_MODULE_${name}_REAL_NAME}
            DESTINATION ${GR_SWIG_INSTALL_DESTINATION}
            COMPONENT ${GR_SWIG_INSTALL_COMPONENT}
        )
        include(GrPython)
        GR_PYTHON_INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name}.py
            DESTINATION ${GR_SWIG_INSTALL_DESTINATION}
            COMPONENT ${GR_SWIG_INSTALL_COMPONENT}
        )
        GR_LIBTOOL(
            TARGET ${SWIG_MODULE_${name}_REAL_NAME}
            DESTINATION ${GR_SWIG_INSTALL_DESTINATION}
        )
    endforeach(name)
 endmacro(GR_SWIG_INSTALL)
 ########################################################################
 # Generate a python file that can determine swig dependencies.
 # Used by the make macro above to determine extra dependencies.
 # When you build C++, CMake figures out the header dependencies.
 # This code essentially performs that logic for swig includes.
 ########################################################################
 file(WRITE ${CMAKE_BINARY_DIR}/get_swig_deps.py "
 import os, sys, re
 i_include_matcher = re.compile('%(include|import)\\s*[<|\"](.*)[>|\"]')
 h_include_matcher = re.compile('#(include)\\s*[<|\"](.*)[>|\"]')
 include_dirs = sys.argv[2].split(';')
 def get_swig_incs(file_path):
    if file_path.endswith('.i'): matcher = i_include_matcher
    else: matcher = h_include_matcher
    file_contents = open(file_path, 'r').read()
    return matcher.findall(file_contents, re.MULTILINE)
 def get_swig_deps(file_path, level):
    deps = [file_path]
    if level == 0: return deps
    for keyword, inc_file in get_swig_incs(file_path):
        for inc_dir in include_dirs:
            inc_path = os.path.join(inc_dir, inc_file)
            if not os.path.exists(inc_path): continue
            deps.extend(get_swig_deps(inc_path, level-1))
            break #found, we dont search in lower prio inc dirs
    return deps
 if __name__ == '__main__':
    ifiles = sys.argv[1].split(';')
    deps = sum([get_swig_deps(ifile, 3) for ifile in ifiles], [])
    #sys.stderr.write(';'.join(set(deps)) + '\\n\\n')
    print(';'.join(set(deps)))
 ")
--- a/cmake/Modules/GrTest.cmake
+++ b/cmake/Modules/GrTest.cmake
@ -0,0 +1,143 @@
 # Copyright 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.
 if(DEFINED __INCLUDED_GR_TEST_CMAKE)
    return()
 endif()
 set(__INCLUDED_GR_TEST_CMAKE TRUE)
 ########################################################################
 # Add a unit test and setup the environment for a unit test.
 # Takes the same arguments as the ADD_TEST function.
 #
 # Before calling set the following variables:
 # GR_TEST_TARGET_DEPS  - built targets for the library path
 # GR_TEST_LIBRARY_DIRS - directories for the library path
 # GR_TEST_PYTHON_DIRS  - directories for the python path
 # GR_TEST_ENVIRONS  - other environment key/value pairs
 ########################################################################
 function(GR_ADD_TEST test_name)
        #Ensure that the build exe also appears in the PATH.
        list(APPEND GR_TEST_TARGET_DEPS ${ARGN})
        #In the land of windows, all libraries must be in the PATH.
        #Since the dependent libraries are not yet installed,
        #we must manually set them in the PATH to run tests.
        #The following appends the path of a target dependency.
        foreach(target ${GR_TEST_TARGET_DEPS})
            get_target_property(location ${target} LOCATION)
            if(location)
                get_filename_component(path ${location} PATH)
                string(REGEX REPLACE "\\$\\(.*\\)" ${CMAKE_BUILD_TYPE} path ${path})
                list(APPEND GR_TEST_LIBRARY_DIRS ${path})
            endif(location)
        endforeach(target)
    if(WIN32)
        #SWIG generates the python library files into a subdirectory.
        #Therefore, we must append this subdirectory into PYTHONPATH.
        #Only do this for the python directories matching the following:
        foreach(pydir ${GR_TEST_PYTHON_DIRS})
            get_filename_component(name ${pydir} NAME)
            if(name MATCHES "^(swig|lib|src)$")
                list(APPEND GR_TEST_PYTHON_DIRS ${pydir}/${CMAKE_BUILD_TYPE})
            endif()
        endforeach(pydir)
    endif(WIN32)
    file(TO_NATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR} srcdir)
    file(TO_NATIVE_PATH "${GR_TEST_LIBRARY_DIRS}" libpath) #ok to use on dir list?
    file(TO_NATIVE_PATH "${GR_TEST_PYTHON_DIRS}" pypath) #ok to use on dir list?
    set(environs "VOLK_GENERIC=1" "GR_DONT_LOAD_PREFS=1" "srcdir=${srcdir}")
    list(APPEND environs ${GR_TEST_ENVIRONS})
    #http://www.cmake.org/pipermail/cmake/2009-May/029464.html
    #Replaced this add test + set environs code with the shell script generation.
    #Its nicer to be able to manually run the shell script to diagnose problems.
    #ADD_TEST(${ARGV})
    #SET_TESTS_PROPERTIES(${test_name} PROPERTIES ENVIRONMENT "${environs}")
    if(UNIX)
        set(LD_PATH_VAR "LD_LIBRARY_PATH")
        if(APPLE)
            set(LD_PATH_VAR "DYLD_LIBRARY_PATH")
        endif()
        set(binpath "${CMAKE_CURRENT_BINARY_DIR}:$PATH")
        list(APPEND libpath "$${LD_PATH_VAR}")
        list(APPEND pypath "$PYTHONPATH")
        #replace list separator with the path separator
        string(REPLACE ";" ":" libpath "${libpath}")
        string(REPLACE ";" ":" pypath "${pypath}")
        list(APPEND environs "PATH=${binpath}" "${LD_PATH_VAR}=${libpath}" "PYTHONPATH=${pypath}")
        #generate a bat file that sets the environment and runs the test
 	if (CMAKE_CROSSCOMPILING)
                set(SHELL "/bin/sh")
        else(CMAKE_CROSSCOMPILING)
                find_program(SHELL sh)
        endif(CMAKE_CROSSCOMPILING)
        set(sh_file ${CMAKE_CURRENT_BINARY_DIR}/${test_name}_test.sh)
        file(WRITE ${sh_file} "#!${SHELL}\n")
        #each line sets an environment variable
        foreach(environ ${environs})
            file(APPEND ${sh_file} "export ${environ}\n")
        endforeach(environ)
        #load the command to run with its arguments
        foreach(arg ${ARGN})
            file(APPEND ${sh_file} "${arg} ")
        endforeach(arg)
        file(APPEND ${sh_file} "\n")
        #make the shell file executable
        execute_process(COMMAND chmod +x ${sh_file})
        add_test(${test_name} ${SHELL} ${sh_file})
    endif(UNIX)
    if(WIN32)
        list(APPEND libpath ${DLL_PATHS} "%PATH%")
        list(APPEND pypath "%PYTHONPATH%")
        #replace list separator with the path separator (escaped)
        string(REPLACE ";" "\\;" libpath "${libpath}")
        string(REPLACE ";" "\\;" pypath "${pypath}")
        list(APPEND environs "PATH=${libpath}" "PYTHONPATH=${pypath}")
        #generate a bat file that sets the environment and runs the test
        set(bat_file ${CMAKE_CURRENT_BINARY_DIR}/${test_name}_test.bat)
        file(WRITE ${bat_file} "@echo off\n")
        #each line sets an environment variable
        foreach(environ ${environs})
            file(APPEND ${bat_file} "SET ${environ}\n")
        endforeach(environ)
        #load the command to run with its arguments
        foreach(arg ${ARGN})
            file(APPEND ${bat_file} "${arg} ")
        endforeach(arg)
        file(APPEND ${bat_file} "\n")
        add_test(${test_name} ${bat_file})
    endif(WIN32)
 endfunction(GR_ADD_TEST)
--- a/cmake/Modules/UseSWIG.cmake
+++ b/cmake/Modules/UseSWIG.cmake
@ -0,0 +1,304 @@
 # - SWIG module for CMake
 # Defines the following macros:
 #   SWIG_ADD_MODULE(name language [ files ])
 #     - Define swig module with given name and specified language
 #   SWIG_LINK_LIBRARIES(name [ libraries ])
 #     - Link libraries to swig module
 # All other macros are for internal use only.
 # To get the actual name of the swig module,
 # use: ${SWIG_MODULE_${name}_REAL_NAME}.
 # Set Source files properties such as CPLUSPLUS and SWIG_FLAGS to specify
 # special behavior of SWIG. Also global CMAKE_SWIG_FLAGS can be used to add
 # special flags to all swig calls.
 # Another special variable is CMAKE_SWIG_OUTDIR, it allows one to specify
 # where to write all the swig generated module (swig -outdir option)
 # The name-specific variable SWIG_MODULE_<name>_EXTRA_DEPS may be used
 # to specify extra dependencies for the generated modules.
 # If the source file generated by swig need some special flag you can use
 # set_source_files_properties( ${swig_generated_file_fullname}
 #        PROPERTIES COMPILE_FLAGS "-bla")
 #=============================================================================
 # Copyright 2004-2009 Kitware, Inc.
 # Copyright 2009 Mathieu Malaterre <mathieu.malaterre@gmail.com>
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.
 #
 # This software is distributed WITHOUT ANY WARRANTY; without even the
 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 # See the License for more information.
 #=============================================================================
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 set(SWIG_CXX_EXTENSION "cxx")
 set(SWIG_EXTRA_LIBRARIES "")
 set(SWIG_PYTHON_EXTRA_FILE_EXTENSION "py")
 #
 # For given swig module initialize variables associated with it
 #
 macro(SWIG_MODULE_INITIALIZE name language)
  string(TOUPPER "${language}" swig_uppercase_language)
  string(TOLOWER "${language}" swig_lowercase_language)
  set(SWIG_MODULE_${name}_LANGUAGE "${swig_uppercase_language}")
  set(SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG "${swig_lowercase_language}")
  set(SWIG_MODULE_${name}_REAL_NAME "${name}")
  if("${SWIG_MODULE_${name}_LANGUAGE}" STREQUAL "UNKNOWN")
    message(FATAL_ERROR "SWIG Error: Language \"${language}\" not found")
  elseif("${SWIG_MODULE_${name}_LANGUAGE}" STREQUAL "PYTHON")
    # when swig is used without the -interface it will produce in the module.py
    # a 'import _modulename' statement, which implies having a corresponding
    # _modulename.so (*NIX), _modulename.pyd (Win32).
    set(SWIG_MODULE_${name}_REAL_NAME "_${name}")
  elseif("${SWIG_MODULE_${name}_LANGUAGE}" STREQUAL "PERL")
    set(SWIG_MODULE_${name}_EXTRA_FLAGS "-shadow")
  endif()
 endmacro()
 #
 # For a given language, input file, and output file, determine extra files that
 # will be generated. This is internal swig macro.
 #
 macro(SWIG_GET_EXTRA_OUTPUT_FILES language outfiles generatedpath infile)
  set(${outfiles} "")
  get_source_file_property(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename
    ${infile} SWIG_MODULE_NAME)
  if(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename STREQUAL "NOTFOUND")
    get_filename_component(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename "${infile}" NAME_WE)
  endif()
  foreach(it ${SWIG_${language}_EXTRA_FILE_EXTENSION})
    set(${outfiles} ${${outfiles}}
      "${generatedpath}/${SWIG_GET_EXTRA_OUTPUT_FILES_module_basename}.${it}")
  endforeach()
 endmacro()
 #
 # Take swig (*.i) file and add proper custom commands for it
 #
 macro(SWIG_ADD_SOURCE_TO_MODULE name outfiles infile)
  set(swig_full_infile ${infile})
  get_filename_component(swig_source_file_path "${infile}" PATH)
  get_filename_component(swig_source_file_name_we "${infile}" NAME_WE)
  get_source_file_property(swig_source_file_generated ${infile} GENERATED)
  get_source_file_property(swig_source_file_cplusplus ${infile} CPLUSPLUS)
  get_source_file_property(swig_source_file_flags ${infile} SWIG_FLAGS)
  if("${swig_source_file_flags}" STREQUAL "NOTFOUND")
    set(swig_source_file_flags "")
  endif()
  set(swig_source_file_fullname "${infile}")
  if(${swig_source_file_path} MATCHES "^${CMAKE_CURRENT_SOURCE_DIR}")
    string(REGEX REPLACE
      "^${CMAKE_CURRENT_SOURCE_DIR}" ""
      swig_source_file_relative_path
      "${swig_source_file_path}")
  else()
    if(${swig_source_file_path} MATCHES "^${CMAKE_CURRENT_BINARY_DIR}")
      string(REGEX REPLACE
        "^${CMAKE_CURRENT_BINARY_DIR}" ""
        swig_source_file_relative_path
        "${swig_source_file_path}")
      set(swig_source_file_generated 1)
    else()
      set(swig_source_file_relative_path "${swig_source_file_path}")
      if(swig_source_file_generated)
        set(swig_source_file_fullname "${CMAKE_CURRENT_BINARY_DIR}/${infile}")
      else()
        set(swig_source_file_fullname "${CMAKE_CURRENT_SOURCE_DIR}/${infile}")
      endif()
    endif()
  endif()
  set(swig_generated_file_fullname
    "${CMAKE_CURRENT_BINARY_DIR}")
  if(swig_source_file_relative_path)
    set(swig_generated_file_fullname
      "${swig_generated_file_fullname}/${swig_source_file_relative_path}")
  endif()
  # If CMAKE_SWIG_OUTDIR was specified then pass it to -outdir
  if(CMAKE_SWIG_OUTDIR)
    set(swig_outdir ${CMAKE_SWIG_OUTDIR})
  else()
    set(swig_outdir ${CMAKE_CURRENT_BINARY_DIR})
  endif()
  SWIG_GET_EXTRA_OUTPUT_FILES(${SWIG_MODULE_${name}_LANGUAGE}
    swig_extra_generated_files
    "${swig_outdir}"
    "${infile}")
  set(swig_generated_file_fullname
    "${swig_generated_file_fullname}/${swig_source_file_name_we}")
  # add the language into the name of the file (i.e. TCL_wrap)
  # this allows for the same .i file to be wrapped into different languages
  set(swig_generated_file_fullname
    "${swig_generated_file_fullname}${SWIG_MODULE_${name}_LANGUAGE}_wrap")
  if(swig_source_file_cplusplus)
    set(swig_generated_file_fullname
      "${swig_generated_file_fullname}.${SWIG_CXX_EXTENSION}")
  else()
    set(swig_generated_file_fullname
      "${swig_generated_file_fullname}.c")
  endif()
  # Shut up some warnings from poor SWIG code generation that we
  # can do nothing about, when this flag is available
  include(CheckCXXCompilerFlag)
  check_cxx_compiler_flag("-Wno-unused-but-set-variable" HAVE_WNO_UNUSED_BUT_SET_VARIABLE)
  if(HAVE_WNO_UNUSED_BUT_SET_VARIABLE)
    set_source_files_properties(${swig_generated_file_fullname}
      PROPERTIES COMPILE_FLAGS "-Wno-unused-but-set-variable")
  endif(HAVE_WNO_UNUSED_BUT_SET_VARIABLE)
  get_directory_property(cmake_include_directories INCLUDE_DIRECTORIES)
  set(swig_include_dirs)
  foreach(it ${cmake_include_directories})
    set(swig_include_dirs ${swig_include_dirs} "-I${it}")
  endforeach()
  set(swig_special_flags)
  # default is c, so add c++ flag if it is c++
  if(swig_source_file_cplusplus)
    set(swig_special_flags ${swig_special_flags} "-c++")
  endif()
  set(swig_extra_flags)
  if(SWIG_MODULE_${name}_EXTRA_FLAGS)
    set(swig_extra_flags ${swig_extra_flags} ${SWIG_MODULE_${name}_EXTRA_FLAGS})
  endif()
  # hack to work around CMake bug in add_custom_command with multiple OUTPUT files
  file(RELATIVE_PATH reldir ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR})
  execute_process(
    COMMAND ${PYTHON_EXECUTABLE} -c "import re, hashlib
 unique = hashlib.md5('${reldir}${ARGN}').hexdigest()[:5]
 print(re.sub('\\W', '_', '${name} ${reldir} ' + unique))"
    OUTPUT_VARIABLE _target OUTPUT_STRIP_TRAILING_WHITESPACE
  )
  file(
    WRITE ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp.in
   "int main(void){return 0;}\n"
  )
  # create dummy dependencies
  add_custom_command(
    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp
    COMMAND ${CMAKE_COMMAND} -E copy
        ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp.in
        ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp
    DEPENDS "${swig_source_file_fullname}" ${SWIG_MODULE_${name}_EXTRA_DEPS}
    COMMENT ""
  )
  # create the dummy target
  add_executable(${_target} ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp)
  # add a custom command to the dummy target
  add_custom_command(
    TARGET ${_target}
    # Let's create the ${swig_outdir} at execution time, in case dir contains $(OutDir)
    COMMAND ${CMAKE_COMMAND} -E make_directory ${swig_outdir}
    COMMAND "${SWIG_EXECUTABLE}"
    ARGS "-${SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG}"
    ${swig_source_file_flags}
    ${CMAKE_SWIG_FLAGS}
    -outdir ${swig_outdir}
    ${swig_special_flags}
    ${swig_extra_flags}
    ${swig_include_dirs}
    -o "${swig_generated_file_fullname}"
    "${swig_source_file_fullname}"
    COMMENT "Swig source"
  )
  #add dummy independent dependencies from the _target to each file
  #that will be generated by the SWIG command above
  set(${outfiles} "${swig_generated_file_fullname}" ${swig_extra_generated_files})
  foreach(swig_gen_file ${${outfiles}})
    add_custom_command(
      OUTPUT ${swig_gen_file}
      COMMAND ""
      DEPENDS ${_target}
      COMMENT ""
    )
  endforeach()
  set_source_files_properties(
    ${outfiles} PROPERTIES GENERATED 1
  )
 endmacro()
 #
 # Create Swig module
 #
 macro(SWIG_ADD_MODULE name language)
  SWIG_MODULE_INITIALIZE(${name} ${language})
  set(swig_dot_i_sources)
  set(swig_other_sources)
  foreach(it ${ARGN})
    if(${it} MATCHES ".*\\.i$")
      set(swig_dot_i_sources ${swig_dot_i_sources} "${it}")
    else()
      set(swig_other_sources ${swig_other_sources} "${it}")
    endif()
  endforeach()
  set(swig_generated_sources)
  foreach(it ${swig_dot_i_sources})
    SWIG_ADD_SOURCE_TO_MODULE(${name} swig_generated_source ${it})
    set(swig_generated_sources ${swig_generated_sources} "${swig_generated_source}")
  endforeach()
  get_directory_property(swig_extra_clean_files ADDITIONAL_MAKE_CLEAN_FILES)
  set_directory_properties(PROPERTIES
    ADDITIONAL_MAKE_CLEAN_FILES "${swig_extra_clean_files};${swig_generated_sources}")
  add_library(${SWIG_MODULE_${name}_REAL_NAME}
    MODULE
    ${swig_generated_sources}
    ${swig_other_sources})
  string(TOLOWER "${language}" swig_lowercase_language)
  if ("${swig_lowercase_language}" STREQUAL "java")
    if (APPLE)
        # In java you want:
        #      System.loadLibrary("LIBRARY");
        # then JNI will look for a library whose name is platform dependent, namely
        #   MacOS  : libLIBRARY.jnilib
        #   Windows: LIBRARY.dll
        #   Linux  : libLIBRARY.so
        set_target_properties (${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES SUFFIX ".jnilib")
      endif ()
  endif ()
  if ("${swig_lowercase_language}" STREQUAL "python")
    # this is only needed for the python case where a _modulename.so is generated
    set_target_properties(${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES PREFIX "")
    # Python extension modules on Windows must have the extension ".pyd"
    # instead of ".dll" as of Python 2.5.  Older python versions do support
    # this suffix.
    # http://docs.python.org/whatsnew/ports.html#SECTION0001510000000000000000
    # <quote>
    # Windows: .dll is no longer supported as a filename extension for extension modules.
    # .pyd is now the only filename extension that will be searched for.
    # </quote>
    if(WIN32 AND NOT CYGWIN)
      set_target_properties(${SWIG_MODULE_${name}_REAL_NAME} PROPERTIES SUFFIX ".pyd")
    endif()
  endif ()
 endmacro()
 #
 # Like TARGET_LINK_LIBRARIES but for swig modules
 #
 macro(SWIG_LINK_LIBRARIES name)
  if(SWIG_MODULE_${name}_REAL_NAME)
    target_link_libraries(${SWIG_MODULE_${name}_REAL_NAME} ${ARGN})
  else()
    message(SEND_ERROR "Cannot find Swig library \"${name}\".")
  endif()
 endmacro()
--- a/cmake/Modules/crfaConfig.cmake
+++ b/cmake/Modules/crfaConfig.cmake
@ -0,0 +1,30 @@
 INCLUDE(FindPkgConfig)
 PKG_CHECK_MODULES(PC_CRFA crfa)
 FIND_PATH(
    CRFA_INCLUDE_DIRS
    NAMES crfa/api.h
    HINTS $ENV{CRFA_DIR}/include
        ${PC_CRFA_INCLUDEDIR}
    PATHS ${CMAKE_INSTALL_PREFIX}/include
          /usr/local/include
          /usr/include
 )
 FIND_LIBRARY(
    CRFA_LIBRARIES
    NAMES gnuradio-crfa
    HINTS $ENV{CRFA_DIR}/lib
        ${PC_CRFA_LIBDIR}
    PATHS ${CMAKE_INSTALL_PREFIX}/lib
          ${CMAKE_INSTALL_PREFIX}/lib64
          /usr/local/lib
          /usr/local/lib64
          /usr/lib
          /usr/lib64
 )
 INCLUDE(FindPackageHandleStandardArgs)
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(CRFA DEFAULT_MSG CRFA_LIBRARIES CRFA_INCLUDE_DIRS)
 MARK_AS_ADVANCED(CRFA_LIBRARIES CRFA_INCLUDE_DIRS)
--- a/cmake/cmake_uninstall.cmake.in
+++ b/cmake/cmake_uninstall.cmake.in
@ -0,0 +1,32 @@
 # http://www.vtk.org/Wiki/CMake_FAQ#Can_I_do_.22make_uninstall.22_with_CMake.3F
 IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
  MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
 ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
 FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
 STRING(REGEX REPLACE "\n" ";" files "${files}")
 FOREACH(file ${files})
  MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
  IF(EXISTS "$ENV{DESTDIR}${file}")
    EXEC_PROGRAM(
      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
      OUTPUT_VARIABLE rm_out
      RETURN_VALUE rm_retval
      )
    IF(NOT "${rm_retval}" STREQUAL 0)
      MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
    ENDIF(NOT "${rm_retval}" STREQUAL 0)
  ELSEIF(IS_SYMLINK "$ENV{DESTDIR}${file}")
    EXEC_PROGRAM(
      "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
      OUTPUT_VARIABLE rm_out
      RETURN_VALUE rm_retval
      )
    IF(NOT "${rm_retval}" STREQUAL 0)
      MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
    ENDIF(NOT "${rm_retval}" STREQUAL 0)
  ELSE(EXISTS "$ENV{DESTDIR}${file}")
    MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
  ENDIF(EXISTS "$ENV{DESTDIR}${file}")
 ENDFOREACH(file)
--- a/docs/CMakeLists.txt
+++ b/docs/CMakeLists.txt
@ -0,0 +1,35 @@
 # 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 GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 ########################################################################
 # Setup dependencies
 ########################################################################
 find_package(Doxygen)
 ########################################################################
 # Begin conditional configuration
 ########################################################################
 if(ENABLE_DOXYGEN)
 ########################################################################
 # Add subdirectories
 ########################################################################
 add_subdirectory(doxygen)
 endif(ENABLE_DOXYGEN)
--- a/docs/README.crfa
+++ b/docs/README.crfa
@ -0,0 +1,11 @@
 This is the crfa-write-a-block package meant as a guide to building
 out-of-tree packages. To use the crfa blocks, the Python namespaces
 is in 'crfa', which is imported as:
    import crfa
 See the Doxygen documentation for details about the blocks available
 in this package. A quick listing of the details can be found in Python
 after importing by using:
    help(crfa)
--- a/docs/doxygen/CMakeLists.txt
+++ b/docs/doxygen/CMakeLists.txt
@ -0,0 +1,52 @@
 # 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 GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 ########################################################################
 # Create the doxygen configuration file
 ########################################################################
 file(TO_NATIVE_PATH ${CMAKE_SOURCE_DIR} top_srcdir)
 file(TO_NATIVE_PATH ${CMAKE_BINARY_DIR} top_builddir)
 file(TO_NATIVE_PATH ${CMAKE_SOURCE_DIR} abs_top_srcdir)
 file(TO_NATIVE_PATH ${CMAKE_BINARY_DIR} abs_top_builddir)
 set(HAVE_DOT ${DOXYGEN_DOT_FOUND})
 set(enable_html_docs YES)
 set(enable_latex_docs NO)
 set(enable_xml_docs YES)
 configure_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in
    ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
@ONLY)
 set(BUILT_DIRS ${CMAKE_CURRENT_BINARY_DIR}/xml ${CMAKE_CURRENT_BINARY_DIR}/html)
 ########################################################################
 # Make and install doxygen docs
 ########################################################################
 add_custom_command(
    OUTPUT ${BUILT_DIRS}
    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    COMMENT "Generating documentation with doxygen"
 )
 add_custom_target(doxygen_target ALL DEPENDS ${BUILT_DIRS})
 install(DIRECTORY ${BUILT_DIRS} DESTINATION ${GR_PKG_DOC_DIR})
--- a/docs/doxygen/Doxyfile.in
+++ b/docs/doxygen/Doxyfile.in
--- a/docs/doxygen/Doxyfile.swig_doc.in
+++ b/docs/doxygen/Doxyfile.swig_doc.in
--- a/docs/doxygen/doxyxml/init.py
+++ b/docs/doxygen/doxyxml/init.py
@ -0,0 +1,82 @@
 #
 # 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.
 #
 """
 Python interface to contents of doxygen xml documentation.
 Example use:
 See the contents of the example folder for the C++ and
 doxygen-generated xml used in this example.
 >>> # Parse the doxygen docs.
 >>> import os
 >>> this_dir = os.path.dirname(globals()['__file__'])
 >>> xml_path = this_dir + "/example/xml/"
 >>> di = DoxyIndex(xml_path)
 Get a list of all top-level objects.
 >>> print([mem.name() for mem in di.members()])
 [u'Aadvark', u'aadvarky_enough', u'main']
 Get all functions.
 >>> print([mem.name() for mem in di.in_category(DoxyFunction)])
 [u'aadvarky_enough', u'main']
 Check if an object is present.
 >>> di.has_member(u'Aadvark')
 True
 >>> di.has_member(u'Fish')
 False
 Get an item by name and check its properties.
 >>> aad = di.get_member(u'Aadvark')
 >>> print(aad.brief_description)
 Models the mammal Aadvark.
 >>> print(aad.detailed_description)
 Sadly the model is incomplete and cannot capture all aspects of an aadvark yet.
 <BLANKLINE>
 This line is uninformative and is only to test line breaks in the comments.
 >>> [mem.name() for mem in aad.members()]
 [u'aadvarkness', u'print', u'Aadvark', u'get_aadvarkness']
 >>> aad.get_member(u'print').brief_description
 u'Outputs the vital aadvark statistics.'
 """
 from doxyindex import DoxyIndex, DoxyFunction, DoxyParam, DoxyClass, DoxyFile, DoxyNamespace, DoxyGroup, DoxyFriend, DoxyOther
 def _test():
    import os
    this_dir = os.path.dirname(globals()['__file__'])
    xml_path = this_dir + "/example/xml/"
    di = DoxyIndex(xml_path)
    # Get the Aadvark class
    aad = di.get_member('Aadvark')
    aad.brief_description
    import doctest
    return doctest.testmod()
 if __name__ == "__main__":
    _test()
--- a/docs/doxygen/doxyxml/base.py
+++ b/docs/doxygen/doxyxml/base.py
@ -0,0 +1,219 @@
 #
 # 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.
 #
 """
 A base class is created.
 Classes based upon this are used to make more user-friendly interfaces
 to the doxygen xml docs than the generated classes provide.
 """
 import os
 import pdb
 from xml.parsers.expat import ExpatError
 from generated import compound
 class Base(object):
    class Duplicate(StandardError):
        pass
    class NoSuchMember(StandardError):
        pass
    class ParsingError(StandardError):
        pass
    def __init__(self, parse_data, top=None):
        self._parsed = False
        self._error = False
        self._parse_data = parse_data
        self._members = []
        self._dict_members = {}
        self._in_category = {}
        self._data = {}
        if top is not None:
            self._xml_path = top._xml_path
            # Set up holder of references
        else:
            top = self
            self._refs = {}
            self._xml_path = parse_data
        self.top = top
    @classmethod
    def from_refid(cls, refid, top=None):
        """ Instantiate class from a refid rather than parsing object. """
        # First check to see if its already been instantiated.
        if top is not None and refid in top._refs:
            return top._refs[refid]
        # Otherwise create a new instance and set refid.
        inst = cls(None, top=top)
        inst.refid = refid
        inst.add_ref(inst)
        return inst
    @classmethod
    def from_parse_data(cls, parse_data, top=None):
        refid = getattr(parse_data, 'refid', None)
        if refid is not None and top is not None and refid in top._refs:
            return top._refs[refid]
        inst = cls(parse_data, top=top)
        if refid is not None:
            inst.refid = refid
            inst.add_ref(inst)
        return inst
    def add_ref(self, obj):
        if hasattr(obj, 'refid'):
            self.top._refs[obj.refid] = obj
    mem_classes = []
    def get_cls(self, mem):
        for cls in self.mem_classes:
            if cls.can_parse(mem):
                return cls
        raise StandardError(("Did not find a class for object '%s'." \
                                 % (mem.get_name())))
    def convert_mem(self, mem):
        try:
            cls = self.get_cls(mem)
            converted = cls.from_parse_data(mem, self.top)
            if converted is None:
                raise StandardError('No class matched this object.')
            self.add_ref(converted)
            return converted
        except StandardError, e:
            print e
    @classmethod
    def includes(cls, inst):
        return isinstance(inst, cls)
    @classmethod
    def can_parse(cls, obj):
        return False
    def _parse(self):
        self._parsed = True
    def _get_dict_members(self, cat=None):
        """
        For given category a dictionary is returned mapping member names to
        members of that category.  For names that are duplicated the name is
        mapped to None.
        """
        self.confirm_no_error()
        if cat not in self._dict_members:
            new_dict = {}
            for mem in self.in_category(cat):
                if mem.name() not in new_dict:
                    new_dict[mem.name()] = mem
                else:
                    new_dict[mem.name()] = self.Duplicate
            self._dict_members[cat] = new_dict
        return self._dict_members[cat]
    def in_category(self, cat):
        self.confirm_no_error()
        if cat is None:
            return self._members
        if cat not in self._in_category:
            self._in_category[cat] = [mem for mem in self._members
                                      if cat.includes(mem)]
        return self._in_category[cat]
    def get_member(self, name, cat=None):
        self.confirm_no_error()
        # Check if it's in a namespace or class.
        bits = name.split('::')
        first = bits[0]
        rest = '::'.join(bits[1:])
        member = self._get_dict_members(cat).get(first, self.NoSuchMember)
        # Raise any errors that are returned.
        if member in set([self.NoSuchMember, self.Duplicate]):
            raise member()
        if rest:
            return member.get_member(rest, cat=cat)
        return member
    def has_member(self, name, cat=None):
        try:
            mem = self.get_member(name, cat=cat)
            return True
        except self.NoSuchMember:
            return False
    def data(self):
        self.confirm_no_error()
        return self._data
    def members(self):
        self.confirm_no_error()
        return self._members
    def process_memberdefs(self):
        mdtss = []
        for sec in self._retrieved_data.compounddef.sectiondef:
            mdtss += sec.memberdef
        # At the moment we lose all information associated with sections.
        # Sometimes a memberdef is in several sectiondef.
        # We make sure we don't get duplicates here.
        uniques = set([])
        for mem in mdtss:
            converted = self.convert_mem(mem)
            pair = (mem.name, mem.__class__)
            if pair not in uniques:
                uniques.add(pair)
                self._members.append(converted)
    def retrieve_data(self):
        filename = os.path.join(self._xml_path, self.refid + '.xml')
        try:
            self._retrieved_data = compound.parse(filename)
        except ExpatError:
            print('Error in xml in file %s' % filename)
            self._error = True
            self._retrieved_data = None
    def check_parsed(self):
        if not self._parsed:
            self._parse()
    def confirm_no_error(self):
        self.check_parsed()
        if self._error:
            raise self.ParsingError()
    def error(self):
        self.check_parsed()
        return self._error
    def name(self):
        # first see if we can do it without processing.
        if self._parse_data is not None:
            return self._parse_data.name
        self.check_parsed()
        return self._retrieved_data.compounddef.name
--- a/docs/doxygen/doxyxml/doxyindex.py
+++ b/docs/doxygen/doxyxml/doxyindex.py
@ -0,0 +1,237 @@
 #
 # 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.
 #
 """
 Classes providing more user-friendly interfaces to the doxygen xml
 docs than the generated classes provide.
 """
 import os
 from generated import index
 from base import Base
 from text import description
 class DoxyIndex(Base):
    """
    Parses a doxygen xml directory.
    """
    __module__ = "gnuradio.utils.doxyxml"
    def _parse(self):
        if self._parsed:
            return
        super(DoxyIndex, self)._parse()
        self._root = index.parse(os.path.join(self._xml_path, 'index.xml'))
        for mem in self._root.compound:
            converted = self.convert_mem(mem)
            # For files we want the contents to be accessible directly
            # from the parent rather than having to go through the file
            # object.
            if self.get_cls(mem) == DoxyFile:
                if mem.name.endswith('.h'):
                    self._members += converted.members()
                    self._members.append(converted)
            else:
                self._members.append(converted)
 def generate_swig_doc_i(self):
    """
    %feature("docstring") gr_make_align_on_samplenumbers_ss::align_state "
    Wraps the C++: gr_align_on_samplenumbers_ss::align_state";
    """
    pass
 class DoxyCompMem(Base):
    kind = None
    def __init__(self, *args, **kwargs):
        super(DoxyCompMem, self).__init__(*args, **kwargs)
    @classmethod
    def can_parse(cls, obj):
        return obj.kind == cls.kind
    def set_descriptions(self, parse_data):
        bd = description(getattr(parse_data, 'briefdescription', None))
        dd = description(getattr(parse_data, 'detaileddescription', None))
        self._data['brief_description'] = bd
        self._data['detailed_description'] = dd
 class DoxyCompound(DoxyCompMem):
    pass
 class DoxyMember(DoxyCompMem):
    pass
 class DoxyFunction(DoxyMember):
    __module__ = "gnuradio.utils.doxyxml"
    kind = 'function'
    def _parse(self):
        if self._parsed:
            return
        super(DoxyFunction, self)._parse()
        self.set_descriptions(self._parse_data)
        self._data['params'] = []
        prms = self._parse_data.param
        for prm in prms:
            self._data['params'].append(DoxyParam(prm))
    brief_description = property(lambda self: self.data()['brief_description'])
    detailed_description = property(lambda self: self.data()['detailed_description'])
    params = property(lambda self: self.data()['params'])
 Base.mem_classes.append(DoxyFunction)
 class DoxyParam(DoxyMember):
    __module__ = "gnuradio.utils.doxyxml"
    def _parse(self):
        if self._parsed:
            return
        super(DoxyParam, self)._parse()
        self.set_descriptions(self._parse_data)
        self._data['declname'] = self._parse_data.declname
    brief_description = property(lambda self: self.data()['brief_description'])
    detailed_description = property(lambda self: self.data()['detailed_description'])
    declname = property(lambda self: self.data()['declname'])
 class DoxyClass(DoxyCompound):
    __module__ = "gnuradio.utils.doxyxml"
    kind = 'class'
    def _parse(self):
        if self._parsed:
            return
        super(DoxyClass, self)._parse()
        self.retrieve_data()
        if self._error:
            return
        self.set_descriptions(self._retrieved_data.compounddef)
        # Sectiondef.kind tells about whether private or public.
        # We just ignore this for now.
        self.process_memberdefs()
    brief_description = property(lambda self: self.data()['brief_description'])
    detailed_description = property(lambda self: self.data()['detailed_description'])
 Base.mem_classes.append(DoxyClass)
 class DoxyFile(DoxyCompound):
    __module__ = "gnuradio.utils.doxyxml"
    kind = 'file'
    def _parse(self):
        if self._parsed:
            return
        super(DoxyFile, self)._parse()
        self.retrieve_data()
        self.set_descriptions(self._retrieved_data.compounddef)
        if self._error:
            return
        self.process_memberdefs()
    brief_description = property(lambda self: self.data()['brief_description'])
    detailed_description = property(lambda self: self.data()['detailed_description'])
 Base.mem_classes.append(DoxyFile)
 class DoxyNamespace(DoxyCompound):
    __module__ = "gnuradio.utils.doxyxml"
    kind = 'namespace'
 Base.mem_classes.append(DoxyNamespace)
 class DoxyGroup(DoxyCompound):
    __module__ = "gnuradio.utils.doxyxml"
    kind = 'group'
    def _parse(self):
        if self._parsed:
            return
        super(DoxyGroup, self)._parse()
        self.retrieve_data()
        if self._error:
            return
        cdef = self._retrieved_data.compounddef
        self._data['title'] = description(cdef.title)
        # Process inner groups
        grps = cdef.innergroup
        for grp in grps:
            converted = DoxyGroup.from_refid(grp.refid, top=self.top)
            self._members.append(converted)
        # Process inner classes
        klasses = cdef.innerclass
        for kls in klasses:
            converted = DoxyClass.from_refid(kls.refid, top=self.top)
            self._members.append(converted)
        # Process normal members
        self.process_memberdefs()
    title = property(lambda self: self.data()['title'])
 Base.mem_classes.append(DoxyGroup)
 class DoxyFriend(DoxyMember):
    __module__ = "gnuradio.utils.doxyxml"
    kind = 'friend'
 Base.mem_classes.append(DoxyFriend)
 class DoxyOther(Base):
    __module__ = "gnuradio.utils.doxyxml"
    kinds = set(['variable', 'struct', 'union', 'define', 'typedef', 'enum', 'dir', 'page'])
    @classmethod
    def can_parse(cls, obj):
        return obj.kind in cls.kinds
 Base.mem_classes.append(DoxyOther)
--- a/docs/doxygen/doxyxml/generated/init.py
+++ b/docs/doxygen/doxyxml/generated/init.py
@ -0,0 +1,7 @@
 """
 Contains generated files produced by generateDS.py.
 These do the real work of parsing the doxygen xml files but the
 resultant classes are not very friendly to navigate so the rest of the
 doxyxml module processes them further.
 """
--- a/docs/doxygen/doxyxml/generated/compound.py
+++ b/docs/doxygen/doxyxml/generated/compound.py
@ -0,0 +1,503 @@
 #!/usr/bin/env python
 """
 Generated Mon Feb  9 19:08:05 2009 by generateDS.py.
 """
 from string import lower as str_lower
 from xml.dom import minidom
 from xml.dom import Node
 import sys
 import compoundsuper as supermod
 from compoundsuper import MixedContainer
 class DoxygenTypeSub(supermod.DoxygenType):
    def __init__(self, version=None, compounddef=None):
        supermod.DoxygenType.__init__(self, version, compounddef)
    def find(self, details):
        return self.compounddef.find(details)
 supermod.DoxygenType.subclass = DoxygenTypeSub
 # end class DoxygenTypeSub
 class compounddefTypeSub(supermod.compounddefType):
    def __init__(self, kind=None, prot=None, id=None, compoundname='', title='', basecompoundref=None, derivedcompoundref=None, includes=None, includedby=None, incdepgraph=None, invincdepgraph=None, innerdir=None, innerfile=None, innerclass=None, innernamespace=None, innerpage=None, innergroup=None, templateparamlist=None, sectiondef=None, briefdescription=None, detaileddescription=None, inheritancegraph=None, collaborationgraph=None, programlisting=None, location=None, listofallmembers=None):
        supermod.compounddefType.__init__(self, kind, prot, id, compoundname, title, basecompoundref, derivedcompoundref, includes, includedby, incdepgraph, invincdepgraph, innerdir, innerfile, innerclass, innernamespace, innerpage, innergroup, templateparamlist, sectiondef, briefdescription, detaileddescription, inheritancegraph, collaborationgraph, programlisting, location, listofallmembers)
    def find(self, details):
        if self.id == details.refid:
            return self
        for sectiondef in self.sectiondef:
            result = sectiondef.find(details)
            if result:
                return result
 supermod.compounddefType.subclass = compounddefTypeSub
 # end class compounddefTypeSub
 class listofallmembersTypeSub(supermod.listofallmembersType):
    def __init__(self, member=None):
        supermod.listofallmembersType.__init__(self, member)
 supermod.listofallmembersType.subclass = listofallmembersTypeSub
 # end class listofallmembersTypeSub
 class memberRefTypeSub(supermod.memberRefType):
    def __init__(self, virt=None, prot=None, refid=None, ambiguityscope=None, scope='', name=''):
        supermod.memberRefType.__init__(self, virt, prot, refid, ambiguityscope, scope, name)
 supermod.memberRefType.subclass = memberRefTypeSub
 # end class memberRefTypeSub
 class compoundRefTypeSub(supermod.compoundRefType):
    def __init__(self, virt=None, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.compoundRefType.__init__(self, mixedclass_, content_)
 supermod.compoundRefType.subclass = compoundRefTypeSub
 # end class compoundRefTypeSub
 class reimplementTypeSub(supermod.reimplementType):
    def __init__(self, refid=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.reimplementType.__init__(self, mixedclass_, content_)
 supermod.reimplementType.subclass = reimplementTypeSub
 # end class reimplementTypeSub
 class incTypeSub(supermod.incType):
    def __init__(self, local=None, refid=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.incType.__init__(self, mixedclass_, content_)
 supermod.incType.subclass = incTypeSub
 # end class incTypeSub
 class refTypeSub(supermod.refType):
    def __init__(self, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.refType.__init__(self, mixedclass_, content_)
 supermod.refType.subclass = refTypeSub
 # end class refTypeSub
 class refTextTypeSub(supermod.refTextType):
    def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.refTextType.__init__(self, mixedclass_, content_)
 supermod.refTextType.subclass = refTextTypeSub
 # end class refTextTypeSub
 class sectiondefTypeSub(supermod.sectiondefType):
    def __init__(self, kind=None, header='', description=None, memberdef=None):
        supermod.sectiondefType.__init__(self, kind, header, description, memberdef)
    def find(self, details):
        for memberdef in self.memberdef:
            if memberdef.id == details.refid:
                return memberdef
        return None
 supermod.sectiondefType.subclass = sectiondefTypeSub
 # end class sectiondefTypeSub
 class memberdefTypeSub(supermod.memberdefType):
    def __init__(self, initonly=None, kind=None, volatile=None, const=None, raise_=None, virt=None, readable=None, prot=None, explicit=None, new=None, final=None, writable=None, add=None, static=None, remove=None, sealed=None, mutable=None, gettable=None, inline=None, settable=None, id=None, templateparamlist=None, type_=None, definition='', argsstring='', name='', read='', write='', bitfield='', reimplements=None, reimplementedby=None, param=None, enumvalue=None, initializer=None, exceptions=None, briefdescription=None, detaileddescription=None, inbodydescription=None, location=None, references=None, referencedby=None):
        supermod.memberdefType.__init__(self, initonly, kind, volatile, const, raise_, virt, readable, prot, explicit, new, final, writable, add, static, remove, sealed, mutable, gettable, inline, settable, id, templateparamlist, type_, definition, argsstring, name, read, write, bitfield, reimplements, reimplementedby, param, enumvalue, initializer, exceptions, briefdescription, detaileddescription, inbodydescription, location, references, referencedby)
 supermod.memberdefType.subclass = memberdefTypeSub
 # end class memberdefTypeSub
 class descriptionTypeSub(supermod.descriptionType):
    def __init__(self, title='', para=None, sect1=None, internal=None, mixedclass_=None, content_=None):
        supermod.descriptionType.__init__(self, mixedclass_, content_)
 supermod.descriptionType.subclass = descriptionTypeSub
 # end class descriptionTypeSub
 class enumvalueTypeSub(supermod.enumvalueType):
    def __init__(self, prot=None, id=None, name='', initializer=None, briefdescription=None, detaileddescription=None, mixedclass_=None, content_=None):
        supermod.enumvalueType.__init__(self, mixedclass_, content_)
 supermod.enumvalueType.subclass = enumvalueTypeSub
 # end class enumvalueTypeSub
 class templateparamlistTypeSub(supermod.templateparamlistType):
    def __init__(self, param=None):
        supermod.templateparamlistType.__init__(self, param)
 supermod.templateparamlistType.subclass = templateparamlistTypeSub
 # end class templateparamlistTypeSub
 class paramTypeSub(supermod.paramType):
    def __init__(self, type_=None, declname='', defname='', array='', defval=None, briefdescription=None):
        supermod.paramType.__init__(self, type_, declname, defname, array, defval, briefdescription)
 supermod.paramType.subclass = paramTypeSub
 # end class paramTypeSub
 class linkedTextTypeSub(supermod.linkedTextType):
    def __init__(self, ref=None, mixedclass_=None, content_=None):
        supermod.linkedTextType.__init__(self, mixedclass_, content_)
 supermod.linkedTextType.subclass = linkedTextTypeSub
 # end class linkedTextTypeSub
 class graphTypeSub(supermod.graphType):
    def __init__(self, node=None):
        supermod.graphType.__init__(self, node)
 supermod.graphType.subclass = graphTypeSub
 # end class graphTypeSub
 class nodeTypeSub(supermod.nodeType):
    def __init__(self, id=None, label='', link=None, childnode=None):
        supermod.nodeType.__init__(self, id, label, link, childnode)
 supermod.nodeType.subclass = nodeTypeSub
 # end class nodeTypeSub
 class childnodeTypeSub(supermod.childnodeType):
    def __init__(self, relation=None, refid=None, edgelabel=None):
        supermod.childnodeType.__init__(self, relation, refid, edgelabel)
 supermod.childnodeType.subclass = childnodeTypeSub
 # end class childnodeTypeSub
 class linkTypeSub(supermod.linkType):
    def __init__(self, refid=None, external=None, valueOf_=''):
        supermod.linkType.__init__(self, refid, external)
 supermod.linkType.subclass = linkTypeSub
 # end class linkTypeSub
 class listingTypeSub(supermod.listingType):
    def __init__(self, codeline=None):
        supermod.listingType.__init__(self, codeline)
 supermod.listingType.subclass = listingTypeSub
 # end class listingTypeSub
 class codelineTypeSub(supermod.codelineType):
    def __init__(self, external=None, lineno=None, refkind=None, refid=None, highlight=None):
        supermod.codelineType.__init__(self, external, lineno, refkind, refid, highlight)
 supermod.codelineType.subclass = codelineTypeSub
 # end class codelineTypeSub
 class highlightTypeSub(supermod.highlightType):
    def __init__(self, class_=None, sp=None, ref=None, mixedclass_=None, content_=None):
        supermod.highlightType.__init__(self, mixedclass_, content_)
 supermod.highlightType.subclass = highlightTypeSub
 # end class highlightTypeSub
 class referenceTypeSub(supermod.referenceType):
    def __init__(self, endline=None, startline=None, refid=None, compoundref=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.referenceType.__init__(self, mixedclass_, content_)
 supermod.referenceType.subclass = referenceTypeSub
 # end class referenceTypeSub
 class locationTypeSub(supermod.locationType):
    def __init__(self, bodystart=None, line=None, bodyend=None, bodyfile=None, file=None, valueOf_=''):
        supermod.locationType.__init__(self, bodystart, line, bodyend, bodyfile, file)
 supermod.locationType.subclass = locationTypeSub
 # end class locationTypeSub
 class docSect1TypeSub(supermod.docSect1Type):
    def __init__(self, id=None, title='', para=None, sect2=None, internal=None, mixedclass_=None, content_=None):
        supermod.docSect1Type.__init__(self, mixedclass_, content_)
 supermod.docSect1Type.subclass = docSect1TypeSub
 # end class docSect1TypeSub
 class docSect2TypeSub(supermod.docSect2Type):
    def __init__(self, id=None, title='', para=None, sect3=None, internal=None, mixedclass_=None, content_=None):
        supermod.docSect2Type.__init__(self, mixedclass_, content_)
 supermod.docSect2Type.subclass = docSect2TypeSub
 # end class docSect2TypeSub
 class docSect3TypeSub(supermod.docSect3Type):
    def __init__(self, id=None, title='', para=None, sect4=None, internal=None, mixedclass_=None, content_=None):
        supermod.docSect3Type.__init__(self, mixedclass_, content_)
 supermod.docSect3Type.subclass = docSect3TypeSub
 # end class docSect3TypeSub
 class docSect4TypeSub(supermod.docSect4Type):
    def __init__(self, id=None, title='', para=None, internal=None, mixedclass_=None, content_=None):
        supermod.docSect4Type.__init__(self, mixedclass_, content_)
 supermod.docSect4Type.subclass = docSect4TypeSub
 # end class docSect4TypeSub
 class docInternalTypeSub(supermod.docInternalType):
    def __init__(self, para=None, sect1=None, mixedclass_=None, content_=None):
        supermod.docInternalType.__init__(self, mixedclass_, content_)
 supermod.docInternalType.subclass = docInternalTypeSub
 # end class docInternalTypeSub
 class docInternalS1TypeSub(supermod.docInternalS1Type):
    def __init__(self, para=None, sect2=None, mixedclass_=None, content_=None):
        supermod.docInternalS1Type.__init__(self, mixedclass_, content_)
 supermod.docInternalS1Type.subclass = docInternalS1TypeSub
 # end class docInternalS1TypeSub
 class docInternalS2TypeSub(supermod.docInternalS2Type):
    def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None):
        supermod.docInternalS2Type.__init__(self, mixedclass_, content_)
 supermod.docInternalS2Type.subclass = docInternalS2TypeSub
 # end class docInternalS2TypeSub
 class docInternalS3TypeSub(supermod.docInternalS3Type):
    def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None):
        supermod.docInternalS3Type.__init__(self, mixedclass_, content_)
 supermod.docInternalS3Type.subclass = docInternalS3TypeSub
 # end class docInternalS3TypeSub
 class docInternalS4TypeSub(supermod.docInternalS4Type):
    def __init__(self, para=None, mixedclass_=None, content_=None):
        supermod.docInternalS4Type.__init__(self, mixedclass_, content_)
 supermod.docInternalS4Type.subclass = docInternalS4TypeSub
 # end class docInternalS4TypeSub
 class docURLLinkSub(supermod.docURLLink):
    def __init__(self, url=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.docURLLink.__init__(self, mixedclass_, content_)
 supermod.docURLLink.subclass = docURLLinkSub
 # end class docURLLinkSub
 class docAnchorTypeSub(supermod.docAnchorType):
    def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.docAnchorType.__init__(self, mixedclass_, content_)
 supermod.docAnchorType.subclass = docAnchorTypeSub
 # end class docAnchorTypeSub
 class docFormulaTypeSub(supermod.docFormulaType):
    def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.docFormulaType.__init__(self, mixedclass_, content_)
 supermod.docFormulaType.subclass = docFormulaTypeSub
 # end class docFormulaTypeSub
 class docIndexEntryTypeSub(supermod.docIndexEntryType):
    def __init__(self, primaryie='', secondaryie=''):
        supermod.docIndexEntryType.__init__(self, primaryie, secondaryie)
 supermod.docIndexEntryType.subclass = docIndexEntryTypeSub
 # end class docIndexEntryTypeSub
 class docListTypeSub(supermod.docListType):
    def __init__(self, listitem=None):
        supermod.docListType.__init__(self, listitem)
 supermod.docListType.subclass = docListTypeSub
 # end class docListTypeSub
 class docListItemTypeSub(supermod.docListItemType):
    def __init__(self, para=None):
        supermod.docListItemType.__init__(self, para)
 supermod.docListItemType.subclass = docListItemTypeSub
 # end class docListItemTypeSub
 class docSimpleSectTypeSub(supermod.docSimpleSectType):
    def __init__(self, kind=None, title=None, para=None):
        supermod.docSimpleSectType.__init__(self, kind, title, para)
 supermod.docSimpleSectType.subclass = docSimpleSectTypeSub
 # end class docSimpleSectTypeSub
 class docVarListEntryTypeSub(supermod.docVarListEntryType):
    def __init__(self, term=None):
        supermod.docVarListEntryType.__init__(self, term)
 supermod.docVarListEntryType.subclass = docVarListEntryTypeSub
 # end class docVarListEntryTypeSub
 class docRefTextTypeSub(supermod.docRefTextType):
    def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.docRefTextType.__init__(self, mixedclass_, content_)
 supermod.docRefTextType.subclass = docRefTextTypeSub
 # end class docRefTextTypeSub
 class docTableTypeSub(supermod.docTableType):
    def __init__(self, rows=None, cols=None, row=None, caption=None):
        supermod.docTableType.__init__(self, rows, cols, row, caption)
 supermod.docTableType.subclass = docTableTypeSub
 # end class docTableTypeSub
 class docRowTypeSub(supermod.docRowType):
    def __init__(self, entry=None):
        supermod.docRowType.__init__(self, entry)
 supermod.docRowType.subclass = docRowTypeSub
 # end class docRowTypeSub
 class docEntryTypeSub(supermod.docEntryType):
    def __init__(self, thead=None, para=None):
        supermod.docEntryType.__init__(self, thead, para)
 supermod.docEntryType.subclass = docEntryTypeSub
 # end class docEntryTypeSub
 class docHeadingTypeSub(supermod.docHeadingType):
    def __init__(self, level=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.docHeadingType.__init__(self, mixedclass_, content_)
 supermod.docHeadingType.subclass = docHeadingTypeSub
 # end class docHeadingTypeSub
 class docImageTypeSub(supermod.docImageType):
    def __init__(self, width=None, type_=None, name=None, height=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.docImageType.__init__(self, mixedclass_, content_)
 supermod.docImageType.subclass = docImageTypeSub
 # end class docImageTypeSub
 class docDotFileTypeSub(supermod.docDotFileType):
    def __init__(self, name=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.docDotFileType.__init__(self, mixedclass_, content_)
 supermod.docDotFileType.subclass = docDotFileTypeSub
 # end class docDotFileTypeSub
 class docTocItemTypeSub(supermod.docTocItemType):
    def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):
        supermod.docTocItemType.__init__(self, mixedclass_, content_)
 supermod.docTocItemType.subclass = docTocItemTypeSub
 # end class docTocItemTypeSub
 class docTocListTypeSub(supermod.docTocListType):
    def __init__(self, tocitem=None):
        supermod.docTocListType.__init__(self, tocitem)
 supermod.docTocListType.subclass = docTocListTypeSub
 # end class docTocListTypeSub
 class docLanguageTypeSub(supermod.docLanguageType):
    def __init__(self, langid=None, para=None):
        supermod.docLanguageType.__init__(self, langid, para)
 supermod.docLanguageType.subclass = docLanguageTypeSub
 # end class docLanguageTypeSub
 class docParamListTypeSub(supermod.docParamListType):
    def __init__(self, kind=None, parameteritem=None):
        supermod.docParamListType.__init__(self, kind, parameteritem)
 supermod.docParamListType.subclass = docParamListTypeSub
 # end class docParamListTypeSub
 class docParamListItemSub(supermod.docParamListItem):
    def __init__(self, parameternamelist=None, parameterdescription=None):
        supermod.docParamListItem.__init__(self, parameternamelist, parameterdescription)
 supermod.docParamListItem.subclass = docParamListItemSub
 # end class docParamListItemSub
 class docParamNameListSub(supermod.docParamNameList):
    def __init__(self, parametername=None):
        supermod.docParamNameList.__init__(self, parametername)
 supermod.docParamNameList.subclass = docParamNameListSub
 # end class docParamNameListSub
 class docParamNameSub(supermod.docParamName):
    def __init__(self, direction=None, ref=None, mixedclass_=None, content_=None):
        supermod.docParamName.__init__(self, mixedclass_, content_)
 supermod.docParamName.subclass = docParamNameSub
 # end class docParamNameSub
 class docXRefSectTypeSub(supermod.docXRefSectType):
    def __init__(self, id=None, xreftitle=None, xrefdescription=None):
        supermod.docXRefSectType.__init__(self, id, xreftitle, xrefdescription)
 supermod.docXRefSectType.subclass = docXRefSectTypeSub
 # end class docXRefSectTypeSub
 class docCopyTypeSub(supermod.docCopyType):
    def __init__(self, link=None, para=None, sect1=None, internal=None):
        supermod.docCopyType.__init__(self, link, para, sect1, internal)
 supermod.docCopyType.subclass = docCopyTypeSub
 # end class docCopyTypeSub
 class docCharTypeSub(supermod.docCharType):
    def __init__(self, char=None, valueOf_=''):
        supermod.docCharType.__init__(self, char)
 supermod.docCharType.subclass = docCharTypeSub
 # end class docCharTypeSub
 class docParaTypeSub(supermod.docParaType):
    def __init__(self, char=None, valueOf_=''):
        supermod.docParaType.__init__(self, char)
        self.parameterlist = []
        self.simplesects = []
        self.content = []
    def buildChildren(self, child_, nodeName_):
        supermod.docParaType.buildChildren(self, child_, nodeName_)
        if child_.nodeType == Node.TEXT_NODE:
            obj_ = self.mixedclass_(MixedContainer.CategoryText,
                MixedContainer.TypeNone, '', child_.nodeValue)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and \
                nodeName_ == "ref":
            obj_ = supermod.docRefTextType.factory()
            obj_.build(child_)
            self.content.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and \
                nodeName_ == 'parameterlist':
            obj_ = supermod.docParamListType.factory()
            obj_.build(child_)
            self.parameterlist.append(obj_)
        elif child_.nodeType == Node.ELEMENT_NODE and \
                nodeName_ == 'simplesect':
            obj_ = supermod.docSimpleSectType.factory()
            obj_.build(child_)
            self.simplesects.append(obj_)
 supermod.docParaType.subclass = docParaTypeSub
 # end class docParaTypeSub
 def parse(inFilename):
    doc = minidom.parse(inFilename)
    rootNode = doc.documentElement
    rootObj = supermod.DoxygenType.factory()
    rootObj.build(rootNode)
    return rootObj
--- a/docs/doxygen/doxyxml/generated/compoundsuper.py
+++ b/docs/doxygen/doxyxml/generated/compoundsuper.py
--- a/docs/doxygen/doxyxml/generated/index.py
+++ b/docs/doxygen/doxyxml/generated/index.py
@ -0,0 +1,77 @@
 #!/usr/bin/env python
 """
 Generated Mon Feb  9 19:08:05 2009 by generateDS.py.
 """
 from xml.dom import minidom
 import os
 import sys
 import compound
 import indexsuper as supermod
 class DoxygenTypeSub(supermod.DoxygenType):
    def __init__(self, version=None, compound=None):
        supermod.DoxygenType.__init__(self, version, compound)
    def find_compounds_and_members(self, details):
        """
        Returns a list of all compounds and their members which match details
        """
        results = []
        for compound in self.compound:
            members = compound.find_members(details)
            if members:
                results.append([compound, members])
            else:
                if details.match(compound):
                    results.append([compound, []])
        return results
 supermod.DoxygenType.subclass = DoxygenTypeSub
 # end class DoxygenTypeSub
 class CompoundTypeSub(supermod.CompoundType):
    def __init__(self, kind=None, refid=None, name='', member=None):
        supermod.CompoundType.__init__(self, kind, refid, name, member)
    def find_members(self, details):
        """
        Returns a list of all members which match details
        """
        results = []
        for member in self.member:
            if details.match(member):
                results.append(member)
        return results
 supermod.CompoundType.subclass = CompoundTypeSub
 # end class CompoundTypeSub
 class MemberTypeSub(supermod.MemberType):
    def __init__(self, kind=None, refid=None, name=''):
        supermod.MemberType.__init__(self, kind, refid, name)
 supermod.MemberType.subclass = MemberTypeSub
 # end class MemberTypeSub
 def parse(inFilename):
    doc = minidom.parse(inFilename)
    rootNode = doc.documentElement
    rootObj = supermod.DoxygenType.factory()
    rootObj.build(rootNode)
    return rootObj
--- a/docs/doxygen/doxyxml/generated/indexsuper.py
+++ b/docs/doxygen/doxyxml/generated/indexsuper.py
@ -0,0 +1,523 @@
 #!/usr/bin/env python
 #
 # Generated Thu Jun 11 18:43:54 2009 by generateDS.py.
 #
 import sys
 import getopt
 from string import lower as str_lower
 from xml.dom import minidom
 from xml.dom import Node
 #
 # User methods
 #
 # Calls to the methods in these classes are generated by generateDS.py.
 # You can replace these methods by re-implementing the following class
 #   in a module named generatedssuper.py.
 try:
    from generatedssuper import GeneratedsSuper
 except ImportError, exp:
    class GeneratedsSuper:
        def format_string(self, input_data, input_name=''):
            return input_data
        def format_integer(self, input_data, input_name=''):
            return '%d' % input_data
        def format_float(self, input_data, input_name=''):
            return '%f' % input_data
        def format_double(self, input_data, input_name=''):
            return '%e' % input_data
        def format_boolean(self, input_data, input_name=''):
            return '%s' % input_data
 #
 # If you have installed IPython you can uncomment and use the following.
 # IPython is available from http://ipython.scipy.org/.
 #
 ## from IPython.Shell import IPShellEmbed
 ## args = ''
 ## ipshell = IPShellEmbed(args,
 ##     banner = 'Dropping into IPython',
 ##     exit_msg = 'Leaving Interpreter, back to program.')
 # Then use the following line where and when you want to drop into the
 # IPython shell:
 #    ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit')
 #
 # Globals
 #
 ExternalEncoding = 'ascii'
 #
 # Support/utility functions.
 #
 def showIndent(outfile, level):
    for idx in range(level):
        outfile.write('    ')
 def quote_xml(inStr):
    s1 = (isinstance(inStr, basestring) and inStr or
          '%s' % inStr)
    s1 = s1.replace('&', '&amp;')
    s1 = s1.replace('<', '&lt;')
    s1 = s1.replace('>', '&gt;')
    return s1
 def quote_attrib(inStr):
    s1 = (isinstance(inStr, basestring) and inStr or
          '%s' % inStr)
    s1 = s1.replace('&', '&amp;')
    s1 = s1.replace('<', '&lt;')
    s1 = s1.replace('>', '&gt;')
    if '"' in s1:
        if "'" in s1:
            s1 = '"%s"' % s1.replace('"', "&quot;")
        else:
            s1 = "'%s'" % s1
    else:
        s1 = '"%s"' % s1
    return s1
 def quote_python(inStr):
    s1 = inStr
    if s1.find("'") == -1:
        if s1.find('\n') == -1:
            return "'%s'" % s1
        else:
            return "'''%s'''" % s1
    else:
        if s1.find('"') != -1:
            s1 = s1.replace('"', '\\"')
        if s1.find('\n') == -1:
            return '"%s"' % s1
        else:
            return '"""%s"""' % s1
 class MixedContainer:
    # Constants for category:
    CategoryNone = 0
    CategoryText = 1
    CategorySimple = 2
    CategoryComplex = 3
    # Constants for content_type:
    TypeNone = 0
    TypeText = 1
    TypeString = 2
    TypeInteger = 3
    TypeFloat = 4
    TypeDecimal = 5
    TypeDouble = 6
    TypeBoolean = 7
    def __init__(self, category, content_type, name, value):
        self.category = category
        self.content_type = content_type
        self.name = name
        self.value = value
    def getCategory(self):
        return self.category
    def getContenttype(self, content_type):
        return self.content_type
    def getValue(self):
        return self.value
    def getName(self):
        return self.name
    def export(self, outfile, level, name, namespace):
        if self.category == MixedContainer.CategoryText:
            outfile.write(self.value)
        elif self.category == MixedContainer.CategorySimple:
            self.exportSimple(outfile, level, name)
        else:    # category == MixedContainer.CategoryComplex
            self.value.export(outfile, level, namespace,name)
    def exportSimple(self, outfile, level, name):
        if self.content_type == MixedContainer.TypeString:
            outfile.write('<%s>%s</%s>' % (self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeInteger or \
                self.content_type == MixedContainer.TypeBoolean:
            outfile.write('<%s>%d</%s>' % (self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeFloat or \
                self.content_type == MixedContainer.TypeDecimal:
            outfile.write('<%s>%f</%s>' % (self.name, self.value, self.name))
        elif self.content_type == MixedContainer.TypeDouble:
            outfile.write('<%s>%g</%s>' % (self.name, self.value, self.name))
    def exportLiteral(self, outfile, level, name):
        if self.category == MixedContainer.CategoryText:
            showIndent(outfile, level)
            outfile.write('MixedContainer(%d, %d, "%s", "%s"),\n' % \
                (self.category, self.content_type, self.name, self.value))
        elif self.category == MixedContainer.CategorySimple:
            showIndent(outfile, level)
            outfile.write('MixedContainer(%d, %d, "%s", "%s"),\n' % \
                (self.category, self.content_type, self.name, self.value))
        else:    # category == MixedContainer.CategoryComplex
            showIndent(outfile, level)
            outfile.write('MixedContainer(%d, %d, "%s",\n' % \
                (self.category, self.content_type, self.name,))
            self.value.exportLiteral(outfile, level + 1)
            showIndent(outfile, level)
            outfile.write(')\n')
 class _MemberSpec(object):
    def __init__(self, name='', data_type='', container=0):
        self.name = name
        self.data_type = data_type
        self.container = container
    def set_name(self, name): self.name = name
    def get_name(self): return self.name
    def set_data_type(self, data_type): self.data_type = data_type
    def get_data_type(self): return self.data_type
    def set_container(self, container): self.container = container
    def get_container(self): return self.container
 #
 # Data representation classes.
 #
 class DoxygenType(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self, version=None, compound=None):
        self.version = version
        if compound is None:
            self.compound = []
        else:
            self.compound = compound
    def factory(*args_, **kwargs_):
        if DoxygenType.subclass:
            return DoxygenType.subclass(*args_, **kwargs_)
        else:
            return DoxygenType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_compound(self): return self.compound
    def set_compound(self, compound): self.compound = compound
    def add_compound(self, value): self.compound.append(value)
    def insert_compound(self, index, value): self.compound[index] = value
    def get_version(self): return self.version
    def set_version(self, version): self.version = version
    def export(self, outfile, level, namespace_='', name_='DoxygenType', namespacedef_=''):
        showIndent(outfile, level)
        outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
        self.exportAttributes(outfile, level, namespace_, name_='DoxygenType')
        if self.hasContent_():
            outfile.write('>\n')
            self.exportChildren(outfile, level + 1, namespace_, name_)
            showIndent(outfile, level)
            outfile.write('</%s%s>\n' % (namespace_, name_))
        else:
            outfile.write(' />\n')
    def exportAttributes(self, outfile, level, namespace_='', name_='DoxygenType'):
        outfile.write(' version=%s' % (self.format_string(quote_attrib(self.version).encode(ExternalEncoding), input_name='version'), ))
    def exportChildren(self, outfile, level, namespace_='', name_='DoxygenType'):
        for compound_ in self.compound:
            compound_.export(outfile, level, namespace_, name_='compound')
    def hasContent_(self):
        if (
            self.compound is not None
            ):
            return True
        else:
            return False
    def exportLiteral(self, outfile, level, name_='DoxygenType'):
        level += 1
        self.exportLiteralAttributes(outfile, level, name_)
        if self.hasContent_():
            self.exportLiteralChildren(outfile, level, name_)
    def exportLiteralAttributes(self, outfile, level, name_):
        if self.version is not None:
            showIndent(outfile, level)
            outfile.write('version = %s,\n' % (self.version,))
    def exportLiteralChildren(self, outfile, level, name_):
        showIndent(outfile, level)
        outfile.write('compound=[\n')
        level += 1
        for compound in self.compound:
            showIndent(outfile, level)
            outfile.write('model_.compound(\n')
            compound.exportLiteral(outfile, level, name_='compound')
            showIndent(outfile, level)
            outfile.write('),\n')
        level -= 1
        showIndent(outfile, level)
        outfile.write('],\n')
    def build(self, node_):
        attrs = node_.attributes
        self.buildAttributes(attrs)
        for child_ in node_.childNodes:
            nodeName_ = child_.nodeName.split(':')[-1]
            self.buildChildren(child_, nodeName_)
    def buildAttributes(self, attrs):
        if attrs.get('version'):
            self.version = attrs.get('version').value
    def buildChildren(self, child_, nodeName_):
        if child_.nodeType == Node.ELEMENT_NODE and \
            nodeName_ == 'compound':
            obj_ = CompoundType.factory()
            obj_.build(child_)
            self.compound.append(obj_)
 # end class DoxygenType
 class CompoundType(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self, kind=None, refid=None, name=None, member=None):
        self.kind = kind
        self.refid = refid
        self.name = name
        if member is None:
            self.member = []
        else:
            self.member = member
    def factory(*args_, **kwargs_):
        if CompoundType.subclass:
            return CompoundType.subclass(*args_, **kwargs_)
        else:
            return CompoundType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_name(self): return self.name
    def set_name(self, name): self.name = name
    def get_member(self): return self.member
    def set_member(self, member): self.member = member
    def add_member(self, value): self.member.append(value)
    def insert_member(self, index, value): self.member[index] = value
    def get_kind(self): return self.kind
    def set_kind(self, kind): self.kind = kind
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def export(self, outfile, level, namespace_='', name_='CompoundType', namespacedef_=''):
        showIndent(outfile, level)
        outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
        self.exportAttributes(outfile, level, namespace_, name_='CompoundType')
        if self.hasContent_():
            outfile.write('>\n')
            self.exportChildren(outfile, level + 1, namespace_, name_)
            showIndent(outfile, level)
            outfile.write('</%s%s>\n' % (namespace_, name_))
        else:
            outfile.write(' />\n')
    def exportAttributes(self, outfile, level, namespace_='', name_='CompoundType'):
        outfile.write(' kind=%s' % (quote_attrib(self.kind), ))
        outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
    def exportChildren(self, outfile, level, namespace_='', name_='CompoundType'):
        if self.name is not None:
            showIndent(outfile, level)
            outfile.write('<%sname>%s</%sname>\n' % (namespace_, self.format_string(quote_xml(self.name).encode(ExternalEncoding), input_name='name'), namespace_))
        for member_ in self.member:
            member_.export(outfile, level, namespace_, name_='member')
    def hasContent_(self):
        if (
            self.name is not None or
            self.member is not None
            ):
            return True
        else:
            return False
    def exportLiteral(self, outfile, level, name_='CompoundType'):
        level += 1
        self.exportLiteralAttributes(outfile, level, name_)
        if self.hasContent_():
            self.exportLiteralChildren(outfile, level, name_)
    def exportLiteralAttributes(self, outfile, level, name_):
        if self.kind is not None:
            showIndent(outfile, level)
            outfile.write('kind = "%s",\n' % (self.kind,))
        if self.refid is not None:
            showIndent(outfile, level)
            outfile.write('refid = %s,\n' % (self.refid,))
    def exportLiteralChildren(self, outfile, level, name_):
        showIndent(outfile, level)
        outfile.write('name=%s,\n' % quote_python(self.name).encode(ExternalEncoding))
        showIndent(outfile, level)
        outfile.write('member=[\n')
        level += 1
        for member in self.member:
            showIndent(outfile, level)
            outfile.write('model_.member(\n')
            member.exportLiteral(outfile, level, name_='member')
            showIndent(outfile, level)
            outfile.write('),\n')
        level -= 1
        showIndent(outfile, level)
        outfile.write('],\n')
    def build(self, node_):
        attrs = node_.attributes
        self.buildAttributes(attrs)
        for child_ in node_.childNodes:
            nodeName_ = child_.nodeName.split(':')[-1]
            self.buildChildren(child_, nodeName_)
    def buildAttributes(self, attrs):
        if attrs.get('kind'):
            self.kind = attrs.get('kind').value
        if attrs.get('refid'):
            self.refid = attrs.get('refid').value
    def buildChildren(self, child_, nodeName_):
        if child_.nodeType == Node.ELEMENT_NODE and \
            nodeName_ == 'name':
            name_ = ''
            for text__content_ in child_.childNodes:
                name_ += text__content_.nodeValue
            self.name = name_
        elif child_.nodeType == Node.ELEMENT_NODE and \
            nodeName_ == 'member':
            obj_ = MemberType.factory()
            obj_.build(child_)
            self.member.append(obj_)
 # end class CompoundType
 class MemberType(GeneratedsSuper):
    subclass = None
    superclass = None
    def __init__(self, kind=None, refid=None, name=None):
        self.kind = kind
        self.refid = refid
        self.name = name
    def factory(*args_, **kwargs_):
        if MemberType.subclass:
            return MemberType.subclass(*args_, **kwargs_)
        else:
            return MemberType(*args_, **kwargs_)
    factory = staticmethod(factory)
    def get_name(self): return self.name
    def set_name(self, name): self.name = name
    def get_kind(self): return self.kind
    def set_kind(self, kind): self.kind = kind
    def get_refid(self): return self.refid
    def set_refid(self, refid): self.refid = refid
    def export(self, outfile, level, namespace_='', name_='MemberType', namespacedef_=''):
        showIndent(outfile, level)
        outfile.write('<%s%s %s' % (namespace_, name_, namespacedef_, ))
        self.exportAttributes(outfile, level, namespace_, name_='MemberType')
        if self.hasContent_():
            outfile.write('>\n')
            self.exportChildren(outfile, level + 1, namespace_, name_)
            showIndent(outfile, level)
            outfile.write('</%s%s>\n' % (namespace_, name_))
        else:
            outfile.write(' />\n')
    def exportAttributes(self, outfile, level, namespace_='', name_='MemberType'):
        outfile.write(' kind=%s' % (quote_attrib(self.kind), ))
        outfile.write(' refid=%s' % (self.format_string(quote_attrib(self.refid).encode(ExternalEncoding), input_name='refid'), ))
    def exportChildren(self, outfile, level, namespace_='', name_='MemberType'):
        if self.name is not None:
            showIndent(outfile, level)
            outfile.write('<%sname>%s</%sname>\n' % (namespace_, self.format_string(quote_xml(self.name).encode(ExternalEncoding), input_name='name'), namespace_))
    def hasContent_(self):
        if (
            self.name is not None
            ):
            return True
        else:
            return False
    def exportLiteral(self, outfile, level, name_='MemberType'):
        level += 1
        self.exportLiteralAttributes(outfile, level, name_)
        if self.hasContent_():
            self.exportLiteralChildren(outfile, level, name_)
    def exportLiteralAttributes(self, outfile, level, name_):
        if self.kind is not None:
            showIndent(outfile, level)
            outfile.write('kind = "%s",\n' % (self.kind,))
        if self.refid is not None:
            showIndent(outfile, level)
            outfile.write('refid = %s,\n' % (self.refid,))
    def exportLiteralChildren(self, outfile, level, name_):
        showIndent(outfile, level)
        outfile.write('name=%s,\n' % quote_python(self.name).encode(ExternalEncoding))
    def build(self, node_):
        attrs = node_.attributes
        self.buildAttributes(attrs)
        for child_ in node_.childNodes:
            nodeName_ = child_.nodeName.split(':')[-1]
            self.buildChildren(child_, nodeName_)
    def buildAttributes(self, attrs):
        if attrs.get('kind'):
            self.kind = attrs.get('kind').value
        if attrs.get('refid'):
            self.refid = attrs.get('refid').value
    def buildChildren(self, child_, nodeName_):
        if child_.nodeType == Node.ELEMENT_NODE and \
            nodeName_ == 'name':
            name_ = ''
            for text__content_ in child_.childNodes:
                name_ += text__content_.nodeValue
            self.name = name_
 # end class MemberType
 USAGE_TEXT = """
 Usage: python <Parser>.py [ -s ] <in_xml_file>
 Options:
    -s        Use the SAX parser, not the minidom parser.
 """
 def usage():
    print USAGE_TEXT
    sys.exit(1)
 def parse(inFileName):
    doc = minidom.parse(inFileName)
    rootNode = doc.documentElement
    rootObj = DoxygenType.factory()
    rootObj.build(rootNode)
    # Enable Python to collect the space used by the DOM.
    doc = None
    sys.stdout.write('<?xml version="1.0" ?>\n')
    rootObj.export(sys.stdout, 0, name_="doxygenindex",
        namespacedef_='')
    return rootObj
 def parseString(inString):
    doc = minidom.parseString(inString)
    rootNode = doc.documentElement
    rootObj = DoxygenType.factory()
    rootObj.build(rootNode)
    # Enable Python to collect the space used by the DOM.
    doc = None
    sys.stdout.write('<?xml version="1.0" ?>\n')
    rootObj.export(sys.stdout, 0, name_="doxygenindex",
        namespacedef_='')
    return rootObj
 def parseLiteral(inFileName):
    doc = minidom.parse(inFileName)
    rootNode = doc.documentElement
    rootObj = DoxygenType.factory()
    rootObj.build(rootNode)
    # Enable Python to collect the space used by the DOM.
    doc = None
    sys.stdout.write('from index import *\n\n')
    sys.stdout.write('rootObj = doxygenindex(\n')
    rootObj.exportLiteral(sys.stdout, 0, name_="doxygenindex")
    sys.stdout.write(')\n')
    return rootObj
 def main():
    args = sys.argv[1:]
    if len(args) == 1:
        parse(args[0])
    else:
        usage()
 if __name__ == '__main__':
    main()
    #import pdb
    #pdb.run('main()')
--- a/docs/doxygen/doxyxml/text.py
+++ b/docs/doxygen/doxyxml/text.py
@ -0,0 +1,56 @@
 #
 # 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.
 #
 """
 Utilities for extracting text from generated classes.
 """
 def is_string(txt):
    if isinstance(txt, str):
        return True
    try:
        if isinstance(txt, unicode):
            return True
    except NameError:
        pass
    return False
 def description(obj):
    if obj is None:
        return None
    return description_bit(obj).strip()
 def description_bit(obj):
    if hasattr(obj, 'content'):
        contents = [description_bit(item) for item in obj.content]
        result = ''.join(contents)
    elif hasattr(obj, 'content_'):
        contents = [description_bit(item) for item in obj.content_]
        result = ''.join(contents)
    elif hasattr(obj, 'value'):
        result = description_bit(obj.value)
    elif is_string(obj):
        return obj
    else:
        raise StandardError('Expecting a string or something with content, content_ or value attribute')
    # If this bit is a paragraph then add one some line breaks.
    if hasattr(obj, 'name') and obj.name == 'para':
        result += "\n\n"
    return result
--- a/docs/doxygen/other/group_defs.dox
+++ b/docs/doxygen/other/group_defs.dox
@ -0,0 +1,7 @@
 /*!
 * \defgroup block GNU Radio CRFA C++ Signal Processing Blocks
 * \brief All C++ blocks that can be used from the CRFA GNU Radio
 *        module are listed here or in the subcategories below.
 *
 */
--- a/docs/doxygen/other/main_page.dox
+++ b/docs/doxygen/other/main_page.dox
@ -0,0 +1,10 @@
 /*! \mainpage
 Welcome to the GNU Radio CRFA Block
 This is the intro page for the Doxygen manual generated for the CRFA
 block (docs/doxygen/other/main_page.dox). Edit it to add more detailed
 documentation about the new GNU Radio modules contained in this
 project.
 */
--- a/docs/doxygen/swig_doc.py
+++ b/docs/doxygen/swig_doc.py
@ -0,0 +1,255 @@
 #
 # Copyright 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.
 #
 """
 Creates the swig_doc.i SWIG interface file.
 Execute using: python swig_doc.py xml_path outputfilename
 The file instructs SWIG to transfer the doxygen comments into the
 python docstrings.
 """
 import sys
 try:
    from doxyxml import DoxyIndex, DoxyClass, DoxyFriend, DoxyFunction, DoxyFile, base
 except ImportError:
    from gnuradio.doxyxml import DoxyIndex, DoxyClass, DoxyFriend, DoxyFunction, DoxyFile, base
 def py_name(name):
    bits = name.split('_')
    return '_'.join(bits[1:])
 def make_name(name):
    bits = name.split('_')
    return bits[0] + '_make_' + '_'.join(bits[1:])
 class Block(object):
    """
    Checks if doxyxml produced objects correspond to a gnuradio block.
    """
    @classmethod
    def includes(cls, item):
        if not isinstance(item, DoxyClass):
            return False
        # Check for a parsing error.
        if item.error():
            return False
        return item.has_member(make_name(item.name()), DoxyFriend)
 def utoascii(text):
    """
    Convert unicode text into ascii and escape quotes.
    """
    if text is None:
        return ''
    out = text.encode('ascii', 'replace')
    out = out.replace('"', '\\"')
    return out
 def combine_descriptions(obj):
    """
    Combines the brief and detailed descriptions of an object together.
    """
    description = []
    bd = obj.brief_description.strip()
    dd = obj.detailed_description.strip()
    if bd:
        description.append(bd)
    if dd:
        description.append(dd)
    return utoascii('\n\n'.join(description)).strip()
 entry_templ = '%feature("docstring") {name} "{docstring}"'
 def make_entry(obj, name=None, templ="{description}", description=None):
    """
    Create a docstring entry for a swig interface file.
    obj - a doxyxml object from which documentation will be extracted.
    name - the name of the C object (defaults to obj.name())
    templ - an optional template for the docstring containing only one
            variable named 'description'.
    description - if this optional variable is set then it's value is
            used as the description instead of extracting it from obj.
    """
    if name is None:
        name=obj.name()
    if "operator " in name:
        return ''
    if description is None:
        description = combine_descriptions(obj)
    docstring = templ.format(description=description)
    if not docstring:
        return ''
    return entry_templ.format(
        name=name,
        docstring=docstring,
        )
 def make_func_entry(func, name=None, description=None, params=None):
    """
    Create a function docstring entry for a swig interface file.
    func - a doxyxml object from which documentation will be extracted.
    name - the name of the C object (defaults to func.name())
    description - if this optional variable is set then it's value is
            used as the description instead of extracting it from func.
    params - a parameter list that overrides using func.params.
    """
    if params is None:
        params = func.params
    params = [prm.declname for prm in params]
    if params:
        sig = "Params: (%s)" % ", ".join(params)
    else:
        sig = "Params: (NONE)"
    templ = "{description}\n\n" + sig
    return make_entry(func, name=name, templ=utoascii(templ),
                      description=description)
 def make_class_entry(klass, description=None):
    """
    Create a class docstring for a swig interface file.
    """
    output = []
    output.append(make_entry(klass, description=description))
    for func in klass.in_category(DoxyFunction):
        name = klass.name() + '::' + func.name()
        output.append(make_func_entry(func, name=name))
    return "\n\n".join(output)
 def make_block_entry(di, block):
    """
    Create class and function docstrings of a gnuradio block for a
    swig interface file.
    """
    descriptions = []
    # Get the documentation associated with the class.
    class_desc = combine_descriptions(block)
    if class_desc:
        descriptions.append(class_desc)
    # Get the documentation associated with the make function
    make_func = di.get_member(make_name(block.name()), DoxyFunction)
    make_func_desc = combine_descriptions(make_func)
    if make_func_desc:
        descriptions.append(make_func_desc)
    # Get the documentation associated with the file
    try:
        block_file = di.get_member(block.name() + ".h", DoxyFile)
        file_desc = combine_descriptions(block_file)
        if file_desc:
            descriptions.append(file_desc)
    except base.Base.NoSuchMember:
        # Don't worry if we can't find a matching file.
        pass
    # And join them all together to make a super duper description.
    super_description = "\n\n".join(descriptions)
    # Associate the combined description with the class and
    # the make function.
    output = []
    output.append(make_class_entry(block, description=super_description))
    creator = block.get_member(block.name(), DoxyFunction)
    output.append(make_func_entry(make_func, description=super_description,
                                  params=creator.params))
    return "\n\n".join(output)
 def make_swig_interface_file(di, swigdocfilename, custom_output=None):
    output = ["""
 /*
 * This file was automatically generated using swig_doc.py.
 *
 * Any changes to it will be lost next time it is regenerated.
 */
 """]
    if custom_output is not None:
        output.append(custom_output)
    # Create docstrings for the blocks.
    blocks = di.in_category(Block)
    make_funcs = set([])
    for block in blocks:
        try:
            make_func = di.get_member(make_name(block.name()), DoxyFunction)
            make_funcs.add(make_func.name())
            output.append(make_block_entry(di, block))
        except block.ParsingError:
            print('Parsing error for block %s' % block.name())
    # Create docstrings for functions
    # Don't include the make functions since they have already been dealt with.
    funcs = [f for f in di.in_category(DoxyFunction) if f.name() not in make_funcs]
    for f in funcs:
        try:
            output.append(make_func_entry(f))
        except f.ParsingError:
            print('Parsing error for function %s' % f.name())
    # Create docstrings for classes
    block_names = [block.name() for block in blocks]
    klasses = [k for k in di.in_category(DoxyClass) if k.name() not in block_names]
    for k in klasses:
        try:
            output.append(make_class_entry(k))
        except k.ParsingError:
            print('Parsing error for class %s' % k.name())
    # Docstrings are not created for anything that is not a function or a class.
    # If this excludes anything important please add it here.
    output = "\n\n".join(output)
    swig_doc = file(swigdocfilename, 'w')
    swig_doc.write(output)
    swig_doc.close()
 if __name__ == "__main__":
    # Parse command line options and set up doxyxml.
    err_msg = "Execute using: python swig_doc.py xml_path outputfilename"
    if len(sys.argv) != 3:
        raise StandardError(err_msg)
    xml_path = sys.argv[1]
    swigdocfilename = sys.argv[2]
    di = DoxyIndex(xml_path)
    # gnuradio.gr.msq_queue.insert_tail and delete_head create errors unless docstrings are defined!
    # This is presumably a bug in SWIG.
    #msg_q = di.get_member(u'gr_msg_queue', DoxyClass)
    #insert_tail = msg_q.get_member(u'insert_tail', DoxyFunction)
    #delete_head = msg_q.get_member(u'delete_head', DoxyFunction)
    output = []
    #output.append(make_func_entry(insert_tail, name='gr_py_msg_queue__insert_tail'))
    #output.append(make_func_entry(delete_head, name='gr_py_msg_queue__delete_head'))
    custom_output = "\n\n".join(output)
    # Generate the docstrings interface file.
    make_swig_interface_file(di, swigdocfilename, custom_output=custom_output)
--- a/examples/README
+++ b/examples/README
@ -0,0 +1,4 @@
 It is considered good practice to add examples in here to demonstrate the
 functionality of your OOT module. Python scripts, GRC flow graphs or other
 code can go here.
--- a/grc/CMakeLists.txt
+++ b/grc/CMakeLists.txt
@ -0,0 +1,24 @@
 # 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 GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 install(FILES
    crfa_multi_rds_printer.xml
    crfa_qtguitest.xml
    crfa_rds_table_qt.xml DESTINATION share/gnuradio/grc/blocks
 )
--- a/grc/crfa_multi_rds_printer.xml
+++ b/grc/crfa_multi_rds_printer.xml
@ -0,0 +1,38 @@
 <?xml version="1.0"?>
 <block>
  <name>Multi RDS Printer</name>
  <key>crfa_multi_rds_printer</key>
  <category>[crfa]</category>
  <import>import crfa</import>
  <make>crfa.multi_rds_printer($print_freq,$nPorts)</make>
  <!-- Make one 'param' node for every Parameter you want settable from the GUI.
       Sub-nodes:
       * name
       * key (makes the value accessible as $keyname, e.g. in the make node)
       * type -->
  <param>
    <name>Print Frequency</name>
    <key>print_freq</key>
    <value>10</value>
    <type>int</type>
  </param>
  <!-- Make one 'sink' node per input. Sub-nodes:
       * name (an identifier for the GUI)
       * type
       * vlen
       * optional (set to 1 for optional inputs) -->
  <param>
    <name>Number of Ports</name>
    <key>nPorts</key>
    <value>2</value>
    <type>int</type>
    <hide>part</hide>
  </param>
  <sink>
    <name>in</name>
    <type>message</type>
    <nports>$nPorts</nports>
    <!--<optional>1</optional>-->
  </sink>
 </block>
--- a/grc/crfa_qtguitest.xml
+++ b/grc/crfa_qtguitest.xml
@ -0,0 +1,55 @@
 <?xml version="1.0"?>
 <block>
  <name>qtguitest</name>
  <key>crfa_qtguitest</key>
  <category>[crfa]</category>
  <import>import crfa</import>
  <import>from crfa.qtguitest import qtguitest, CRWidget,Signals</import>
  <var_make>self.$(id) = $(id) = $value</var_make>
  <make>#set $win = 'self._%s_win'%$id
 		#set $signals = 'self._%s_signals'%$id
 #if not $label()
 	#set $label = '"%s"'%$id
 #end if
 $(signals) = Signals()
 self.$(id) = crfa.qtguitest($(signals),$nPorts)
 $(win) = CRWidget($signals, $label)
 $(gui_hint()($win))</make>
  <param>
    <name>Label</name>
    <key>label</key>
    <value></value>
    <type>string</type>
    <hide>#if $label() then 'none' else 'part'#</hide>
  </param>
  <param>
    <name>GUI Hint</name>
    <key>gui_hint</key>
    <value></value>
    <type>gui_hint</type>
    <hide>part</hide>
  </param>
  <param>
    <name>Number of Ports</name>
    <key>nPorts</key>
    <value>1</value>
    <type>int</type>
    <hide>part</hide>
  </param>
  <sink>
    <name>in</name>
    <type>message</type>
    <nports>$nPorts</nports>
    <optional>1</optional>
  </sink>
   <!-- 
  <sink>
    <name>in1</name>
    <type>message</type>
  </sink>
  -->
 </block>
--- a/grc/crfa_rds_table_qt.xml
+++ b/grc/crfa_rds_table_qt.xml
@ -0,0 +1,46 @@
 <?xml version="1.0"?>
 <block>
  <name>RDS Table (qt)</name>
  <key>crfa_rds_table_qt</key>
  <category>[crfa]</category>
  <import>import crfa</import>
  <import>from crfa.rds_table_qt import rds_table_qt, rds_table_qt_Widget,rds_table_qt_Signals</import>
  <var_make>self.$(id) = $(id) = $value</var_make>
  <make>#set $win = 'self._%s_win'%$id
 		#set $signals = 'self._%s_signals'%$id
 #if not $label()
 	#set $label = '"%s"'%$id
 #end if
 $(signals) = rds_table_qt_Signals()
 self.$(id) = crfa.rds_table_qt($(signals),$nPorts)
 $(win) = rds_table_qt_Widget($signals, $label)
 $(gui_hint()($win))</make>
  <param>
    <name>Label</name>
    <key>label</key>
    <value></value>
    <type>string</type>
    <hide>#if $label() then 'none' else 'part'#</hide>
  </param>
  <param>
    <name>GUI Hint</name>
    <key>gui_hint</key>
    <value></value>
    <type>gui_hint</type>
    <hide>part</hide>
  </param>
  <param>
    <name>Number of Ports</name>
    <key>nPorts</key>
    <value>2</value>
    <type>int</type>
    <hide>part</hide>
  </param>
  <sink>
    <name>in</name>
    <type>message</type>
    <nports>$nPorts</nports>
    <!--<optional>1</optional>-->
  </sink>
 </block>
--- a/include/crfa/CMakeLists.txt
+++ b/include/crfa/CMakeLists.txt
@ -0,0 +1,26 @@
 # Copyright 2011,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.
 ########################################################################
 # Install public header files
 ########################################################################
 install(FILES
    api.h
    DESTINATION include/crfa
 )
--- a/include/crfa/api.h
+++ b/include/crfa/api.h
@ -0,0 +1,33 @@
 /*
 * 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 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_CRFA_API_H
 #define INCLUDED_CRFA_API_H
 #include <gnuradio/attributes.h>
 #ifdef gnuradio_crfa_EXPORTS
 #  define CRFA_API __GR_ATTR_EXPORT
 #else
 #  define CRFA_API __GR_ATTR_IMPORT
 #endif
 #endif /* INCLUDED_CRFA_API_H */
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@ -0,0 +1,82 @@
 # Copyright 2011,2012,2016 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.
 ########################################################################
 # Setup library
 ########################################################################
 include(GrPlatform) #define LIB_SUFFIX
 include_directories(${Boost_INCLUDE_DIR})
 link_directories(${Boost_LIBRARY_DIRS})
 list(APPEND crfa_sources
 )
 set(crfa_sources "${crfa_sources}" PARENT_SCOPE)
 if(NOT crfa_sources)
 	MESSAGE(STATUS "No C++ sources... skipping lib/")
 	return()
 endif(NOT crfa_sources)
 add_library(gnuradio-crfa SHARED ${crfa_sources})
 target_link_libraries(gnuradio-crfa ${Boost_LIBRARIES} ${GNURADIO_ALL_LIBRARIES})
 set_target_properties(gnuradio-crfa PROPERTIES DEFINE_SYMBOL "gnuradio_crfa_EXPORTS")
 if(APPLE)
    set_target_properties(gnuradio-crfa PROPERTIES
        INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib"
    )
 endif(APPLE)
 ########################################################################
 # Install built library files
 ########################################################################
 include(GrMiscUtils)
 GR_LIBRARY_FOO(gnuradio-crfa RUNTIME_COMPONENT "crfa_runtime" DEVEL_COMPONENT "crfa_devel")
 ########################################################################
 # Build and register unit test
 ########################################################################
 include(GrTest)
 include_directories(${CPPUNIT_INCLUDE_DIRS})
 list(APPEND test_crfa_sources
    ${CMAKE_CURRENT_SOURCE_DIR}/test_crfa.cc
    ${CMAKE_CURRENT_SOURCE_DIR}/qa_crfa.cc
 )
 add_executable(test-crfa ${test_crfa_sources})
 target_link_libraries(
  test-crfa
  ${GNURADIO_RUNTIME_LIBRARIES}
  ${Boost_LIBRARIES}
  ${CPPUNIT_LIBRARIES}
  gnuradio-crfa
 )
 GR_ADD_TEST(test_crfa test-crfa)
 ########################################################################
 # Print summary
 ########################################################################
 message(STATUS "Using install prefix: ${CMAKE_INSTALL_PREFIX}")
 message(STATUS "Building for version: ${VERSION} / ${LIBVER}")
--- a/lib/qa_crfa.cc
+++ b/lib/qa_crfa.cc
@ -0,0 +1,36 @@
 /*
 * 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.
 */
 /*
 * This class gathers together all the test cases for the gr-filter
 * directory into a single test suite.  As you create new test cases,
 * add them here.
 */
 #include "qa_crfa.h"
 CppUnit::TestSuite *
 qa_crfa::suite()
 {
  CppUnit::TestSuite *s = new CppUnit::TestSuite("crfa");
  return s;
 }
--- a/lib/qa_crfa.h
+++ b/lib/qa_crfa.h
@ -0,0 +1,38 @@
 /* -*- 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.
 */
 #ifndef _QA_CRFA_H_
 #define _QA_CRFA_H_
 #include <gnuradio/attributes.h>
 #include <cppunit/TestSuite.h>
 //! collect all the tests for the gr-filter directory
 class __GR_ATTR_EXPORT qa_crfa
 {
 public:
  //! return suite of tests for all of gr-filter directory
  static CppUnit::TestSuite *suite();
 };
 #endif /* _QA_CRFA_H_ */
--- a/lib/test_crfa.cc
+++ b/lib/test_crfa.cc
@ -0,0 +1,48 @@
 /* -*- 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 <cppunit/TextTestRunner.h>
 #include <cppunit/XmlOutputter.h>
 #include <gnuradio/unittests.h>
 #include "qa_crfa.h"
 #include <iostream>
 #include <fstream>
 int
 main (int argc, char **argv)
 {
  CppUnit::TextTestRunner runner;
  std::ofstream xmlfile(get_unittest_path("crfa.xml").c_str());
  CppUnit::XmlOutputter *xmlout = new CppUnit::XmlOutputter(&runner.result(), xmlfile);
  runner.addTest(qa_crfa::suite());
  runner.setOutputter(xmlout);
  bool was_successful = runner.run("", false);
  return was_successful ? 0 : 1;
 }
--- a/python/CMakeLists.txt
+++ b/python/CMakeLists.txt
@ -0,0 +1,45 @@
 # 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 GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 ########################################################################
 # Include python install macros
 ########################################################################
 include(GrPython)
 if(NOT PYTHONINTERP_FOUND)
    return()
 endif()
 ########################################################################
 # Install python sources
 ########################################################################
 GR_PYTHON_INSTALL(
    FILES
    __init__.py
    multi_rds_printer.py
    qtguitest.py
    rds_table_qt.py DESTINATION ${GR_PYTHON_DIR}/crfa
 )
 ########################################################################
 # Handle the unit tests
 ########################################################################
 include(GrTest)
 set(GR_TEST_TARGET_DEPS gnuradio-crfa)
 set(GR_TEST_PYTHON_DIRS ${CMAKE_BINARY_DIR}/swig)
--- a/python/init.py
+++ b/python/init.py
@ -0,0 +1,37 @@
 #
 # Copyright 2008,2009 Free Software Foundation, Inc.
 #
 # This application 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.
 #
 # This application 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.
 #
 # The presence of this file turns this directory into a Python package
 '''
 This is the GNU Radio CRFA module. Place your Python package
 description here (python/__init__.py).
 '''
 # import swig generated symbols into the crfa namespace
 try:
 	# this might fail if the module is python-only
 	from crfa_swig import *
 except ImportError:
 	pass
 # import any pure python here
 from multi_rds_printer import multi_rds_printer
 from qtguitest import qtguitest
 from rds_table_qt import rds_table_qt
 #
--- a/python/build_utils.py
+++ b/python/build_utils.py
@ -0,0 +1,226 @@
 #
 # Copyright 2004,2009,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.
 #
 """Misc utilities used at build time
 """
 import re, os, os.path
 from build_utils_codes import *
 # set srcdir to the directory that contains Makefile.am
 try:
    srcdir = os.environ['srcdir']
 except KeyError, e:
    srcdir = "."
 srcdir = srcdir + '/'
 # set do_makefile to either true or false dependeing on the environment
 try:
    if os.environ['do_makefile'] == '0':
        do_makefile = False
    else:
        do_makefile = True
 except KeyError, e:
    do_makefile = False
 # set do_sources to either true or false dependeing on the environment
 try:
    if os.environ['do_sources'] == '0':
        do_sources = False
    else:
        do_sources = True
 except KeyError, e:
    do_sources = True
 name_dict = {}
 def log_output_name (name):
    (base, ext) = os.path.splitext (name)
    ext = ext[1:]                       # drop the leading '.'
    entry = name_dict.setdefault (ext, [])
    entry.append (name)
 def open_and_log_name (name, dir):
    global do_sources
    if do_sources:
        f = open (name, dir)
    else:
        f = None
    log_output_name (name)
    return f
 def expand_template (d, template_filename, extra = ""):
    '''Given a dictionary D and a TEMPLATE_FILENAME, expand template into output file
    '''
    global do_sources
    output_extension = extract_extension (template_filename)
    template = open_src (template_filename, 'r')
    output_name = d['NAME'] + extra + '.' + output_extension
    log_output_name (output_name)
    if do_sources:
        output = open (output_name, 'w')
        do_substitution (d, template, output)
        output.close ()
    template.close ()
 def output_glue (dirname):
    output_makefile_fragment ()
    output_ifile_include (dirname)
 def output_makefile_fragment ():
    global do_makefile
    if not do_makefile:
        return
 # overwrite the source, which must be writable; this should have been
 # checked for beforehand in the top-level Makefile.gen.gen .
    f = open (os.path.join (os.environ.get('gendir', os.environ.get('srcdir', '.')), 'Makefile.gen'), 'w')
    f.write ('#\n# This file is machine generated.  All edits will be overwritten\n#\n')
    output_subfrag (f, 'h')
    output_subfrag (f, 'i')
    output_subfrag (f, 'cc')
    f.close ()
 def output_ifile_include (dirname):
    global do_sources
    if do_sources:
        f = open ('%s_generated.i' % (dirname,), 'w')
        f.write ('//\n// This file is machine generated.  All edits will be overwritten\n//\n')
        files = name_dict.setdefault ('i', [])
        files.sort ()
        f.write ('%{\n')
        for file in files:
            f.write ('#include <%s>\n' % (file[0:-1] + 'h',))
        f.write ('%}\n\n')
        for file in files:
            f.write ('%%include <%s>\n' % (file,))
 def output_subfrag (f, ext):
    files = name_dict.setdefault (ext, [])
    files.sort ()
    f.write ("GENERATED_%s =" % (ext.upper ()))
    for file in files:
        f.write (" \\\n\t%s" % (file,))
    f.write ("\n\n")
 def extract_extension (template_name):
    # template name is something like: GrFIRfilterXXX.h.t
    # we return everything between the penultimate . and .t
    mo = re.search (r'\.([a-z]+)\.t$', template_name)
    if not mo:
        raise ValueError, "Incorrectly formed template_name '%s'" % (template_name,)
    return mo.group (1)
 def open_src (name, mode):
    global srcdir
    return open (os.path.join (srcdir, name), mode)
 def do_substitution (d, in_file, out_file):
    def repl (match_obj):
        key = match_obj.group (1)
        # print key
        return d[key]
    inp = in_file.read ()
    out = re.sub (r"@([a-zA-Z0-9_]+)@", repl, inp)
    out_file.write (out)
 copyright = '''/* -*- c++ -*- */
 /*
 * Copyright 2003,2004 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.
 */
 '''
 def is_complex (code3):
    if i_code (code3) == 'c' or o_code (code3) == 'c':
        return '1'
    else:
        return '0'
 def standard_dict (name, code3, package='gr'):
    d = {}
    d['NAME'] = name
    d['NAME_IMPL'] = name+'_impl'
    d['GUARD_NAME'] = 'INCLUDED_%s_%s_H' % (package.upper(), name.upper())
    d['GUARD_NAME_IMPL'] = 'INCLUDED_%s_%s_IMPL_H' % (package.upper(), name.upper())
    d['BASE_NAME'] = re.sub ('^' + package + '_', '', name)
    d['SPTR_NAME'] = '%s_sptr' % name
    d['WARNING'] = 'WARNING: this file is machine generated. Edits will be overwritten'
    d['COPYRIGHT'] = copyright
    d['TYPE'] = i_type (code3)
    d['I_TYPE'] = i_type (code3)
    d['O_TYPE'] = o_type (code3)
    d['TAP_TYPE'] = tap_type (code3)
    d['IS_COMPLEX'] = is_complex (code3)
    return d
 def standard_dict2 (name, code3, package):
    d = {}
    d['NAME'] = name
    d['BASE_NAME'] = name
    d['GUARD_NAME'] = 'INCLUDED_%s_%s_H' % (package.upper(), name.upper())
    d['WARNING'] = 'WARNING: this file is machine generated. Edits will be overwritten'
    d['COPYRIGHT'] = copyright
    d['TYPE'] = i_type (code3)
    d['I_TYPE'] = i_type (code3)
    d['O_TYPE'] = o_type (code3)
    d['TAP_TYPE'] = tap_type (code3)
    d['IS_COMPLEX'] = is_complex (code3)
    return d
 def standard_impl_dict2 (name, code3, package):
    d = {}
    d['NAME'] = name
    d['IMPL_NAME'] = name
    d['BASE_NAME'] = name.rstrip("impl").rstrip("_")
    d['GUARD_NAME'] = 'INCLUDED_%s_%s_H' % (package.upper(), name.upper())
    d['WARNING'] = 'WARNING: this file is machine generated. Edits will be overwritten'
    d['COPYRIGHT'] = copyright
    d['FIR_TYPE'] = "fir_filter_" + code3
    d['CFIR_TYPE'] = "fir_filter_" + code3[0:2] + 'c'
    d['TYPE'] = i_type (code3)
    d['I_TYPE'] = i_type (code3)
    d['O_TYPE'] = o_type (code3)
    d['TAP_TYPE'] = tap_type (code3)
    d['IS_COMPLEX'] = is_complex (code3)
    return d
--- a/python/build_utils_codes.py
+++ b/python/build_utils_codes.py
@ -0,0 +1,52 @@
 #
 # Copyright 2004 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.
 #
 def i_code (code3):
    return code3[0]
 def o_code (code3):
    if len (code3) >= 2:
        return code3[1]
    else:
        return code3[0]
 def tap_code (code3):
    if len (code3) >= 3:
        return code3[2]
    else:
        return code3[0]
 def i_type (code3):
    return char_to_type[i_code (code3)]
 def o_type (code3):
    return char_to_type[o_code (code3)]
 def tap_type (code3):
    return char_to_type[tap_code (code3)]
 char_to_type = {}
 char_to_type['s'] = 'short'
 char_to_type['i'] = 'int'
 char_to_type['f'] = 'float'
 char_to_type['c'] = 'gr_complex'
 char_to_type['b'] = 'unsigned char'
--- a/python/multi_rds_printer.py
+++ b/python/multi_rds_printer.py
@ -0,0 +1,69 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # 
 # Copyright 2016 <+YOU OR YOUR COMPANY+>.
 # 
 # This 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.
 # 
 # This software 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 software; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 # 
 import numpy,pmt,functools
 from gnuradio import gr
 class multi_rds_printer(gr.sync_block):
    """
    docstring for block multi_rds_printer
    """
    def __init__(self, print_freq,nPorts):
 	gr.sync_block.__init__(self,
 	  name="multi_rds_printer",
 	  in_sig=None,
 	  out_sig=None)
 	self.PS="station name"
 	self.RT="radio text"
 	self.PI="C0FE"
 	self.stations = {}
 	self.print_freq = print_freq
 	self.print_count=print_freq
 	for i in range(0,nPorts):
 	  self.message_port_register_in(pmt.intern('in%d'%i))
 	  self.set_msg_handler(pmt.intern('in%d'%i), functools.partial(self.handle_msg, port=i))
    def handle_msg(self, msg, port):
 	t = pmt.to_long(pmt.tuple_ref(msg, 0))
 	m = pmt.symbol_to_string(pmt.tuple_ref(msg, 1))
 	#code.interact(local=locals())
 	if(t==0):
 		self.PI=m
 		self.stations[str(port)+"PI"]=m
 	elif(t==1):
 		self.PS=m
 		self.stations[str(port)+"PS"]=m
 	elif(t==4):
 		self.RT=m
 		self.stations[str(port)+"RT"]=m
 	self.print_count -= 1
 	#print(self.stations)
 	if (self.print_count==0):
 		self.print_count=self.print_freq
 		print("########## stations ###########")
 		for key in sorted(self.stations):
 		    print("%s: %s" % (key, self.stations[key]))
 #    def work(self, input_items, output_items):
 #        in0 = input_items[0]
 #        out = output_items[0]
 #        # <+signal processing here+>
 #        out[:] = in0
 #        return len(output_items[0])
--- a/python/qtguitest.py
+++ b/python/qtguitest.py
@ -0,0 +1,132 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # 
 # Copyright 2016 <+YOU OR YOUR COMPANY+>.
 # 
 # This 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.
 # 
 # This software 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 software; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 # 
 import numpy
 from gnuradio import gr
 import code,pmt
 from PyQt4 import Qt, QtCore, QtGui
 import pprint
 pp = pprint.PrettyPrinter()
 from PyQt4.QtCore import QObject, pyqtSignal
 class Signals(QObject):
    DataUpdateEvent = QtCore.pyqtSignal(dict)
    def __init__(self, parent=None):
 	super(QtCore.QObject, self).__init__()   
 class qtguitest(gr.sync_block):
    """
    docstring for block qtguitest
    """
    def __init__(self,signals,nPorts):
 	#QObject.__init__()
        gr.sync_block.__init__(self,
            name="qtguitest",
            in_sig=None,
            out_sig=None)
 	for i in range(0,nPorts):
 	  self.message_port_register_in(pmt.intern('in%d'%i))
 	  self.set_msg_handler(pmt.intern('in%d'%i), self.handle_msg)
 	#self.message_port_register_in(pmt.intern('in1'))
 	#self.set_msg_handler(pmt.intern('in1'), self.handle_msg)
 	#code.interact(local=locals())
 	self.signals=signals
    def handle_msg(self, msg):
 	self.signals.DataUpdateEvent.emit({'string':pmt.to_python(msg)})
 	print(msg)
 class CRWidget(QtGui.QWidget):
    def __init__(self, signals,label):
 	print("gui initializing")
 	self.signals = signals
 	self.signals.DataUpdateEvent.connect(self.display_data)
        """ Creates the QT Range widget """
        QtGui.QWidget.__init__(self)
        layout = Qt.QVBoxLayout()
        self.label = Qt.QLabel(label)
        layout.addWidget(self.label)
        self.setLayout(layout)
        self.table=QtGui.QTableWidget(self)
        self.table.setRowCount(5)
        self.table.setColumnCount(6)
        self.table.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers) #disallow editing
          #Data
        data = {'ID':range(1,6),
 		'freq':['97.0','101.3','104.6','107.7'], 
                'name':['foo','antenne1','bar','DieNeue'], 
                'AF':['7','8','9','5'],
                'text':['bla','bli','blu',u'blä'],
                'buttons':[]}
                 #Enter data onto Table
        horHeaders = []
        for n, key in enumerate(['ID','freq','name','AF','text','buttons']):
        #for n, key in enumerate(sorted(data.keys())):
            horHeaders.append(key)
            for m, item in enumerate(data[key]):
 	      if type(item)==int:#convert ints to strings
 		newitem = QtGui.QTableWidgetItem(str(item))
 	      else:
                newitem = QtGui.QTableWidgetItem(item)
              self.table.setItem(m, n, newitem)
        for i in range(0,4):
 	  button=QtGui.QPushButton("play")
 	  self.table.setCellWidget(i,5,button)
 	  button.clicked.connect(self.onCLick)
        #Add Header
        self.table.setHorizontalHeaderLabels(horHeaders)  
        layout.addWidget(self.label)
        layout.addWidget(self.table)
        self.button = QtGui.QPushButton("i am a button")
        layout.addWidget(self.button)
    def display_data(self, event):
 	#msg_type = event.data[0]
 	#msg = unicode(event.data[1], errors='replace')
 	#if (msg_type==0):     #program information
 	#   self.label.setText(msg)
 	#self.layout()
 	pp.pprint(event)
 	self.table.currentItem().setText(event['string'])
    def onCLick(self):
 	print("button clicked")
 	#pp.pprint(event)
 if __name__ == "__main__":
    from PyQt4 import Qt
    import sys
 #   def valueChanged(frequency):
 #       print("Value updated - " + str(frequency))
    app = Qt.QApplication(sys.argv)
   # widget = RangeWidget(Range(0, 100, 10, 1, 100), valueChanged, "Test", "counter_slider", int)
    mainobj= Signals()
    #mainobj=None
    widget = CRWidget(mainobj,"TestLabel")
    widget.show()
    widget.setWindowTitle("Test Qt gui")
    widget.setGeometry(200,200,600,300)
    #code.interact(local=locals())
    sys.exit(app.exec_())
    widget = None
--- a/python/rds_table_qt.py
+++ b/python/rds_table_qt.py
@ -0,0 +1,193 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 # 
 # Copyright 2016 <+YOU OR YOUR COMPANY+>.
 # 
 # This 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.
 # 
 # This software 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 software; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 # 
 import numpy
 from gnuradio import gr
 import code,pmt,functools
 from PyQt4 import Qt, QtCore, QtGui
 import pprint
 pp = pprint.PrettyPrinter()
 from PyQt4.QtCore import QObject, pyqtSignal
 class rds_table_qt_Signals(QObject):
    DataUpdateEvent = QtCore.pyqtSignal(dict)
    def __init__(self, parent=None):
 	super(QtCore.QObject, self).__init__()   
 class rds_table_qt(gr.sync_block):
    """
    docstring for block qtguitest
    """
    def __init__(self,signals,nPorts):
 	#QObject.__init__()
        gr.sync_block.__init__(self,
            name="RDS Table",
            in_sig=None,
            out_sig=None)
 	for i in range(0,nPorts):
 	  self.message_port_register_in(pmt.intern('in%d'%i))
 	  self.set_msg_handler(pmt.intern('in%d'%i), functools.partial(self.handle_msg, port=i))
 	#self.message_port_register_in(pmt.intern('in1'))
 	#self.message_port_register_in(pmt.intern('in2'))
 	#self.set_msg_handler(pmt.intern('in1'), functools.partial(self.handle_msg, port=1))
 	#self.set_msg_handler(pmt.intern('in2'), functools.partial(self.handle_msg, port=2))
 	#code.interact(local=locals())
 	self.signals=signals
 #/* type 0 = PI
 #* type 1 = PS
 #* type 2 = PTY
 #* type 3 = flagstring: TP, TA, MuSp, MoSt, AH, CMP, stPTY
 #* type 4 = RadioText 
 #* type 5 = ClockTime
 #* type 6 = Alternative Frequencies 
 #* type 7 = decode errors int (out  of 50), 51 == no_sync */
    def handle_msg(self, msg, port):
 	t = pmt.to_long(pmt.tuple_ref(msg, 0))
 	m = pmt.symbol_to_string(pmt.tuple_ref(msg, 1))
 	#code.interact(local=locals())
 	if(t==0):
 	    self.signals.DataUpdateEvent.emit({'col':0,'row':port,'string':m})
 		#self.PI=m
 		#self.stations[str(port)+"PI"]=m
 	elif(t==1):
 	    self.signals.DataUpdateEvent.emit({'col':2,'row':port,'string':m})
 		#self.PS=m
 		#self.stations[str(port)+"PS"]=m
 	elif(t==4):
 	    self.signals.DataUpdateEvent.emit({'col':5,'row':port,'string':m})
 	    #self.RT=m
 	    #self.stations[str(port)+"RT"]=m
 	elif(t==6):#alt freq
 	    #print("################alt freqs##################")
 	    #freqspmt=pmt.tuple_ref(msg, 1)
 	    #print(m)
 	    #pp.pprint(pmt.to_python(freqspmt)
 	    self.signals.DataUpdateEvent.emit({'col':3,'row':port,'string':m})
 	elif(t==5):#time
 	    self.signals.DataUpdateEvent.emit({'col':4,'row':port,'string':m})
    #def handle_msg(self, msg):
 #	self.signals.DataUpdateEvent.emit({'string':pmt.to_python(msg)})
 #	print(msg)
 class rds_table_qt_Widget(QtGui.QWidget):
    def __init__(self, signals,label):
 	print("gui initializing")
 	self.signals = signals
 	self.signals.DataUpdateEvent.connect(self.display_data)
        """ Creates the QT Range widget """
        QtGui.QWidget.__init__(self)
        layout = Qt.QVBoxLayout()
        self.label = Qt.QLabel(label)
        layout.addWidget(self.label)
        self.setLayout(layout)
        self.table=QtGui.QTableWidget(self)
        self.table.setRowCount(5)
        self.table.setColumnCount(7)
        self.table.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers) #disallow editing
          #Data
        self.data = {'ID':range(1,6),
 		'freq':['','','',''],
                'name':['','','',''],
                'AF':['','','',''],
                'time':['','','',''],
                'text':['','','',''],
                'buttons':[]}
        #Enter data onto Table
        horHeaders = []
        for n, key in enumerate(['ID','freq','name','AF','time','text','buttons']):
        #for n, key in enumerate(sorted(self.data.keys())):
            horHeaders.append(key)
            for m, item in enumerate(self.data[key]):
 	      if type(item)==int:#convert ints to strings
 		newitem = QtGui.QTableWidgetItem(str(item))
 	      else:
                newitem = QtGui.QTableWidgetItem(item)
              self.table.setItem(m, n, newitem)
        for i in range(0,4):
 	  button=QtGui.QPushButton("play")
 	  self.table.setCellWidget(i,self.table.columnCount()-1,button)
 	  button.clicked.connect(self.onCLick)
        #Add Header
        self.table.setHorizontalHeaderLabels(horHeaders)  
        layout.addWidget(self.label)
        layout.addWidget(self.table)
        self.button = QtGui.QPushButton("i am a button")
        layout.addWidget(self.button)
    def display_data(self, event):
 	#pp.pprint(event)
 	if type(event)==dict:
 	  if type(event['row']) == int and type(event['col']) == int:
 	    item=self.table.item(event['row'],event['col'])
 	    if event['col']==0 and event['string']!=item.text(): #clear data if PI changed
 	      for col in range(1,self.table.columnCount()-1):
 		self.table.item(event['row'],col).setText('')
 	    if item.text()==event['string']:
 	      item.setTextColor(QtCore.Qt.black)
 	    else:
 	      item.setTextColor(QtCore.Qt.green)
 	    item.setText(event['string'])
 	    item.setFont(QtGui.QFont("Courier New"))
 	    #print("table updated")
 	    self.table.resizeColumnsToContents()
 	  else:
 	    self.table.currentItem().setText(event['string'])
    def reset_color(self):
      for i in range(0,self.table.rowCount()):
 	for j in range(0,self.table.columnCount()):
 	  item = self.table.item(i,j)
 	  #code.interact(local=locals())
 	  #print(item.type())
 	  if item != '':
 	    try:
 	      item.setTextColor(QtCore.Qt.black)
 	    except:
 	      pass
      #for item in self.table.items():
 	#item.setTextColor(QtCore.Qt.black)
    def onCLick(self):
 	print("button clicked")
 	self.reset_color()
 	#pp.pprint(event)
 if __name__ == "__main__":
    from PyQt4 import Qt
    import sys
 #   def valueChanged(frequency):
 #       print("Value updated - " + str(frequency))
    app = Qt.QApplication(sys.argv)
   # widget = RangeWidget(Range(0, 100, 10, 1, 100), valueChanged, "Test", "counter_slider", int)
    mainobj= rds_table_qt_Signals()
    #mainobj=None
    widget = rds_table_qt_Widget(mainobj,"TestLabel")
    widget.show()
    widget.setWindowTitle("Test Qt gui")
    widget.setGeometry(200,200,600,300)
    #code.interact(local=locals())
    sys.exit(app.exec_())
    widget = None
--- a/swig/CMakeLists.txt
+++ b/swig/CMakeLists.txt
@ -0,0 +1,65 @@
 # 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 GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 ########################################################################
 # Check if there is C++ code at all
 ########################################################################
 if(NOT crfa_sources)
 	MESSAGE(STATUS "No C++ sources... skipping swig/")
 	return()
 endif(NOT crfa_sources)
 ########################################################################
 # Include swig generation macros
 ########################################################################
 find_package(SWIG)
 find_package(PythonLibs 2)
 if(NOT SWIG_FOUND OR NOT PYTHONLIBS_FOUND)
    return()
 endif()
 include(GrSwig)
 include(GrPython)
 ########################################################################
 # Setup swig generation
 ########################################################################
 foreach(incdir ${GNURADIO_RUNTIME_INCLUDE_DIRS})
    list(APPEND GR_SWIG_INCLUDE_DIRS ${incdir}/gnuradio/swig)
 endforeach(incdir)
 set(GR_SWIG_LIBRARIES gnuradio-crfa)
 set(GR_SWIG_DOC_FILE ${CMAKE_CURRENT_BINARY_DIR}/crfa_swig_doc.i)
 set(GR_SWIG_DOC_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../include)
 GR_SWIG_MAKE(crfa_swig crfa_swig.i)
 ########################################################################
 # Install the build swig module
 ########################################################################
 GR_SWIG_INSTALL(TARGETS crfa_swig DESTINATION ${GR_PYTHON_DIR}/crfa)
 ########################################################################
 # Install swig .i files for development
 ########################################################################
 install(
    FILES
    crfa_swig.i
    ${CMAKE_CURRENT_BINARY_DIR}/crfa_swig_doc.i
    DESTINATION ${GR_INCLUDE_DIR}/crfa/swig
 )
--- a/swig/crfa_swig.i
+++ b/swig/crfa_swig.i
@ -0,0 +1,13 @@
 /* -*- c++ -*- */
 #define CRFA_API
 %include "gnuradio.i"			// the common stuff
 //load generated python docstrings
 %include "crfa_swig_doc.i"
 %{
 %}