Fix use of VLA

udpate readme and manifest
boost 1.73 fix
2021-08-05 16:20:09 +02:00 · 2021-07-20 12:26:30 +02:00 · 2020-08-12 11:46:12 +02:00 · 2019-12-17 11:13:10 +01:00 · 2019-10-21 10:59:12 +02:00 · 2019-10-15 10:25:50 +02:00
75 changed files with 1421 additions and 15816 deletions
@@ -1,6 +1,6 @@
-# Copyright 2011,2012 Free Software Foundation, Inc.
+# Copyright 2011,2012,2014,2016,2018 Free Software Foundation, Inc.
 #
-# This file is part of GNU Radio
+# This file is part of gr-foo
 #
 # 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
@@ -17,32 +17,70 @@
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 ########################################################################
 # Project setup
 ########################################################################
-cmake_minimum_required(VERSION 2.6)
+cmake_minimum_required(VERSION 3.8)
 project(gr-foo CXX C)
 enable_testing()
-#select the release build type by default to get optimization flags
+# 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_MAJOR 1)
 set(VERSION_API    1)
 set(VERSION_ABI 0)
 set(VERSION_PATCH git)
 cmake_policy(SET CMP0011 NEW)
 # Enable generation of compile_commands.json for code completion engines
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 ########################################################################
 # Compiler specific setup
 ########################################################################
-if(NOT WIN32)
+if((CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR
    CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    AND NOT WIN32)
    #http://gcc.gnu.org/wiki/Visibility
    add_definitions(-fvisibility=hidden)
    add_definitions(-std=c++0x)
 endif()
 IF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    SET(CMAKE_CXX_STANDARD 11)
 ELSEIF(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
    SET(CMAKE_CXX_STANDARD 11)
 ELSEIF(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
    SET(CMAKE_CXX_STANDARD 11)
 ELSE()
    message(WARNING "C++ standard could not be set because compiler is not GNU, Clang or MSVC.")
 ENDIF()
 IF(CMAKE_C_COMPILER_ID STREQUAL "GNU")
    SET(CMAKE_C_STANDARD 11)
 ELSEIF(CMAKE_C_COMPILER_ID MATCHES "Clang")
    SET(CMAKE_C_STANDARD 11)
 ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
    SET(CMAKE_C_STANDARD 11)
 ELSE()
    message(WARNING "C standard could not be set because compiler is not GNU, Clang or MSVC.")
 ENDIF()
 find_package(UHD)
 if(NOT UHD_FOUND)
    message(STATUS "UHD library not found, no support for timed TX.")
@@ -54,63 +92,24 @@ else()
    add_definitions(-DFOO_UHD)
 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 thread)
 if(NOT Boost_FOUND)
    message(FATAL_ERROR "Boost required to compile foo")
 endif()
 ########################################################################
 # Install directories
 ########################################################################
 find_package(Gnuradio "3.8" REQUIRED COMPONENTS blocks analog filter fft)
 include(GrVersion)
 include(GrPlatform) #define LIB_SUFFIX
-set(GR_RUNTIME_DIR      bin)
+
-set(GR_LIBRARY_DIR      lib${LIB_SUFFIX})
+if(NOT CMAKE_MODULES_DIR)
  set(CMAKE_MODULES_DIR lib${LIB_SUFFIX}/cmake)
 endif(NOT CMAKE_MODULES_DIR)
 set(GR_INCLUDE_DIR      include/foo)
-set(GR_DATA_DIR         share)
+set(GR_CMAKE_DIR        ${CMAKE_MODULES_DIR}/foo)
 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)
 ########################################################################
 # Find gnuradio build dependencies
 ########################################################################
 set(GR_REQUIRED_COMPONENTS RUNTIME PMT BLOCKS FILTER ANALOG)
 find_package(Gnuradio)
 if(NOT GNURADIO_RUNTIME_FOUND)
    message(FATAL_ERROR "GnuRadio Runtime required to compile foo")
 endif()
 find_package(CppUnit)
 if(NOT CPPUNIT_FOUND)
    message(FATAL_ERROR "CppUnit required to compile foo")
 endif()
 find_package(SWIG)
 if(NOT SWIG_FOUND)
    message(FATAL_ERROR "SWIG required to compile gr-foo")
 endif()
 ########################################################################
 # On Apple only, set install name and use rpath correctly, if not already set
@@ -122,7 +121,7 @@ if(APPLE)
            PATH "Library Install Name Destination Directory" FORCE)
    endif(NOT CMAKE_INSTALL_NAME_DIR)
    if(NOT CMAKE_INSTALL_RPATH)
-        set(cmakE_INSTALL_RPATH
+        set(CMAKE_INSTALL_RPATH
            ${CMAKE_INSTALL_PREFIX}/${GR_LIBRARY_DIR} CACHE
            PATH "Library Install RPath" FORCE)
    endif(NOT CMAKE_INSTALL_RPATH)
@@ -132,26 +131,6 @@ if(APPLE)
    endif(NOT CMAKE_BUILD_WITH_INSTALL_RPATH)
 endif(APPLE)
 ########################################################################
 # Setup the include and linker paths
 ########################################################################
 include_directories(
    ${CMAKE_SOURCE_DIR}/include
    ${Boost_INCLUDE_DIRS}
    ${CPPUNIT_INCLUDE_DIRS}
    ${GNURADIO_RUNTIME_INCLUDE_DIRS}
 )
 link_directories(
    ${Boost_LIBRARY_DIRS}
    ${CPPUNIT_LIBRARY_DIRS}
    ${GNURADIO_RUNTIME_LIBRARY_DIRS}
 )
 # Set component parameters
 set(GR_CCS_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE INTERNAL "" FORCE)
 set(GR_CCS_SWIG_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/swig CACHE INTERNAL "" FORCE)
 ########################################################################
 # Create uninstall target
 ########################################################################
@@ -164,6 +143,7 @@ add_custom_target(uninstall
    ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
    )
 ########################################################################
 # Add subdirectories
 ########################################################################
@@ -172,4 +152,11 @@ add_subdirectory(lib)
 add_subdirectory(swig)
 add_subdirectory(python)
 add_subdirectory(grc)
-add_subdirectory(docs)
+
 ########################################################################
 # Install cmake search helper for this library
 ########################################################################
 install(FILES cmake/Modules/fooConfig.cmake
    DESTINATION ${CMAKE_MODULES_DIR}/foo
 )
@@ -1,16 +1,15 @@
 title: gr-foo
 brief: some utility blocks
 tags:
  - foo
 author:
  - Bastian Bloessl <bloessl@ccs-labs.org>
 copyright_owner:
  - Bastian Bloessl
 dependencies:
  - gnuradio (>= 3.7.4)
 repo: https://github.com/bastibl/gr-foo.git
 tags:
  - foo
 website: https://github.com/bastibl/gr-foo
 title: gr-foo
 icon: http://www.ccs-labs.org/projects/wime/wime.png
 gr_supported_version: v3.7, v3.8, v3.9
 ---
 This is a collection of custom blocks that are not directly associated with a project. For sample applications see:
@@ -20,8 +20,10 @@ project. For sample applications see:
 ### Development
-Like GNU Radio, this module uses *master* and *next* branches for development, which are supposed to be used with the corresponding GNU Radio branches.
+Like GNU Radio, this module uses *maint* branches for development.
-I recommend staying up-to-date by using the *next* branch.
+These branches are supposed to be used with the corresponding GNU Radio
 branches. This means: the *maint-3.7* branch is compatible with GNU Radio 3.7,
 *maint-3.8* is compatible with GNU Radio 3.8, etc.
@@ -82,9 +84,16 @@ final PMT_EOF message to indicate that it is done.
 I used this block for automated performance tests with no-GUI flow graphs.
 ### Dependencies
-GNU Radio v3.7
+### Pad Tagged Stream
 Pads an incoming tagged stream with 0s to the set buffer size.
 Padding is applied to the tail of the tagged stream.
 This is useful when transmitting packetized data by using a Pluto as SDR.
 The Pluto does currently not support a partial buffer flush triggered by an incoming tagged stream.
 Therefore this block pads incoming tagged stream to fill the Pluto buffer to enforce an immediate transmission.
 ### Installation
@@ -99,4 +108,3 @@ make
 sudo make install
 sudo ldconfig
 ``` 
@@ -58,7 +58,7 @@
 # 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.
+# be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefore.
 #=============================================================================
 # Copyright 2010 Alexander Neundorf <neundorf@kde.org>
@@ -1,39 +0,0 @@
 # 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)
@@ -1,36 +0,0 @@
 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)
@@ -1,26 +0,0 @@
 INCLUDE(FindPkgConfig)
 PKG_CHECK_MODULES(PC_GRUEL gruel)
 FIND_PATH(
    GRUEL_INCLUDE_DIRS
    NAMES gruel/attributes.h
    HINTS $ENV{GRUEL_DIR}/include
        ${PC_GRUEL_INCLUDEDIR}
    PATHS /usr/local/include
          /usr/include
 )
 FIND_LIBRARY(
    GRUEL_LIBRARIES
    NAMES gruel
    HINTS $ENV{GRUEL_DIR}/lib
        ${PC_GRUEL_LIBDIR}
    PATHS /usr/local/lib
          /usr/local/lib64
          /usr/lib
          /usr/lib64
 )
 INCLUDE(FindPackageHandleStandardArgs)
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(GRUEL DEFAULT_MSG GRUEL_LIBRARIES GRUEL_INCLUDE_DIRS)
 MARK_AS_ADVANCED(GRUEL_LIBRARIES GRUEL_INCLUDE_DIRS)
@@ -1,28 +0,0 @@
 ########################################################################
 # Find the library for the USRP Hardware Driver
 ########################################################################
 INCLUDE(FindPkgConfig)
 PKG_CHECK_MODULES(PC_UHD uhd)
 FIND_PATH(
    UHD_INCLUDE_DIRS
    NAMES uhd/config.hpp
    HINTS $ENV{UHD_DIR}/include
        ${PC_UHD_INCLUDEDIR}
    PATHS /usr/local/include
          /usr/include
 )
 FIND_LIBRARY(
    UHD_LIBRARIES
    NAMES uhd
    HINTS $ENV{UHD_DIR}/lib
        ${PC_UHD_LIBDIR}
    PATHS /usr/local/lib
          /usr/lib
 )
 INCLUDE(FindPackageHandleStandardArgs)
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(UHD DEFAULT_MSG UHD_LIBRARIES UHD_INCLUDE_DIRS)
 MARK_AS_ADVANCED(UHD_LIBRARIES UHD_INCLUDE_DIRS)
@@ -1,114 +0,0 @@
 # 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_COMPONENT_CMAKE)
    return()
 endif()
 set(__INCLUDED_GR_COMPONENT_CMAKE TRUE)
 set(_gr_enabled_components "" CACHE INTERNAL "" FORCE)
 set(_gr_disabled_components "" CACHE INTERNAL "" FORCE)
 if(NOT DEFINED ENABLE_DEFAULT)
    set(ENABLE_DEFAULT ON)
    message(STATUS "")
    message(STATUS "The build system will automatically enable all components.")
    message(STATUS "Use -DENABLE_DEFAULT=OFF to disable components by default.")
 endif()
 ########################################################################
 # Register a component into the system
 # - name: canonical component name
 # - var: variable for enabled status
 # - argn: list of dependencies
 ########################################################################
 function(GR_REGISTER_COMPONENT name var)
    include(CMakeDependentOption)
    message(STATUS "")
    message(STATUS "Configuring ${name} support...")
    foreach(dep ${ARGN})
        message(STATUS "  Dependency ${dep} = ${${dep}}")
    endforeach(dep)
    #if the user set the var to force on, we note this
    if("${${var}}" STREQUAL "ON")
        set(var_force TRUE)
    else()
        set(var_force FALSE)
    endif()
    #rewrite the dependency list so that deps that are also components use the cached version
    unset(comp_deps)
    foreach(dep ${ARGN})
        list(FIND _gr_enabled_components ${dep} dep_enb_index)
        list(FIND _gr_disabled_components ${dep} dep_dis_index)
        if (${dep_enb_index} EQUAL -1 AND ${dep_dis_index} EQUAL -1)
            list(APPEND comp_deps ${dep})
        else()
            list(APPEND comp_deps ${dep}_cached) #is a component, use cached version
        endif()
    endforeach(dep)
    #setup the dependent option for this component
    CMAKE_DEPENDENT_OPTION(${var} "enable ${name} support" ${ENABLE_DEFAULT} "${comp_deps}" OFF)
    set(${var} "${${var}}" PARENT_SCOPE)
    set(${var}_cached "${${var}}" CACHE INTERNAL "" FORCE)
    #force was specified, but the dependencies were not met
    if(NOT ${var} AND var_force)
        message(FATAL_ERROR "user force-enabled ${name} but configuration checked failed")
    endif()
    #append the component into one of the lists
    if(${var})
        message(STATUS "  Enabling ${name} support.")
        list(APPEND _gr_enabled_components ${name})
    else(${var})
        message(STATUS "  Disabling ${name} support.")
        list(APPEND _gr_disabled_components ${name})
    endif(${var})
    message(STATUS "  Override with -D${var}=ON/OFF")
    #make components lists into global variables
    set(_gr_enabled_components ${_gr_enabled_components} CACHE INTERNAL "" FORCE)
    set(_gr_disabled_components ${_gr_disabled_components} CACHE INTERNAL "" FORCE)
 endfunction(GR_REGISTER_COMPONENT)
 ########################################################################
 # Print the registered component summary
 ########################################################################
 function(GR_PRINT_COMPONENT_SUMMARY)
    message(STATUS "")
    message(STATUS "######################################################")
    message(STATUS "# gr-fosphor enabled components                       ")
    message(STATUS "######################################################")
    foreach(comp ${_gr_enabled_components})
        message(STATUS "  * ${comp}")
    endforeach(comp)
    message(STATUS "")
    message(STATUS "######################################################")
    message(STATUS "# gr-fosphor disabled components                      ")
    message(STATUS "######################################################")
    foreach(comp ${_gr_disabled_components})
        message(STATUS "  * ${comp}")
    endforeach(comp)
    message(STATUS "")
 endfunction(GR_PRINT_COMPONENT_SUMMARY)
@@ -1,525 +0,0 @@
 # 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}')
 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}')
 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}')
 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)
@@ -1,54 +0,0 @@
 # Copyright 2011 Free Software Foundation, Inc.
 #
 # This file is part of GNU Radio
 #
 # GNU Radio is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3, or (at your option)
 # any later version.
 #
 # GNU Radio is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with 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")
@@ -1,241 +0,0 @@
 # 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)
 ")
@@ -1,251 +0,0 @@
 # 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)))
 ")
@@ -1,143 +0,0 @@
 # 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)
@@ -1,304 +0,0 @@
 # - 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()
@@ -0,0 +1,31 @@
 INCLUDE(FindPkgConfig)
 PKG_CHECK_MODULES(PC_FOO foo)
 FIND_PATH(
    FOO_INCLUDE_DIRS
    NAMES foo/api.h
    HINTS $ENV{FOO_DIR}/include
        ${PC_FOO_INCLUDEDIR}
    PATHS ${CMAKE_INSTALL_PREFIX}/include
          /usr/local/include
          /usr/include
 )
 FIND_LIBRARY(
    FOO_LIBRARIES
    NAMES gnuradio-foo
    HINTS $ENV{FOO_DIR}/lib
        ${PC_FOO_LIBDIR}
    PATHS ${CMAKE_INSTALL_PREFIX}/lib
          ${CMAKE_INSTALL_PREFIX}/lib64
          /usr/local/lib
          /usr/local/lib64
          /usr/lib
          /usr/lib64
          )
 include("${CMAKE_CURRENT_LIST_DIR}/fooTarget.cmake")
 INCLUDE(FindPackageHandleStandardArgs)
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(FOO DEFAULT_MSG FOO_LIBRARIES FOO_INCLUDE_DIRS)
 MARK_AS_ADVANCED(FOO_LIBRARIES FOO_INCLUDE_DIRS)
@@ -1,4 +1,4 @@
-# Copyright 2011 Free Software Foundation, Inc.
+# Copyright 2018 Free Software Foundation, Inc.
 #
 # This file is part of GNU Radio
 #
@@ -17,19 +17,10 @@
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
-########################################################################
+include(CMakeFindDependencyMacro)
 # Setup dependencies
 ########################################################################
 find_package(Doxygen)
-########################################################################
+set(target_deps "@TARGET_DEPENDENCIES@")
-# Begin conditional configuration
+foreach(dep IN LISTS target_deps)
-########################################################################
+    find_dependency(${dep})
-if(ENABLE_DOXYGEN)
+endforeach()
-
+include("${CMAKE_CURRENT_LIST_DIR}/@TARGET@Targets.cmake")
 ########################################################################
 # Add subdirectories
 ########################################################################
 add_subdirectory(doxygen)
 endif(ENABLE_DOXYGEN)
@@ -1,11 +0,0 @@
 This is the ccs-write-a-block package meant as a guide to building
 out-of-tree packages. To use the ccs blocks, the Python namespaces
 is in 'ccs', which is imported as:
    import ccs
 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(ccs)
@@ -1,52 +0,0 @@
 # Copyright 2011 Free Software Foundation, Inc.
 #
 # This file is part of GNU Radio
 #
 # GNU Radio is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3, or (at your option)
 # any later version.
 #
 # GNU Radio is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with 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})
@@ -1,82 +0,0 @@
 #
 # Copyright 2010 Free Software Foundation, Inc.
 #
 # This file is part of GNU Radio
 #
 # GNU Radio is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3, or (at your option)
 # any later version.
 #
 # GNU Radio is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 #
 """
 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()
@@ -1,219 +0,0 @@
 #
 # Copyright 2010 Free Software Foundation, Inc.
 #
 # This file is part of GNU Radio
 #
 # GNU Radio is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3, or (at your option)
 # any later version.
 #
 # GNU Radio is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 #
 """
 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
@@ -1,237 +0,0 @@
 #
 # Copyright 2010 Free Software Foundation, Inc.
 #
 # This file is part of GNU Radio
 #
 # GNU Radio is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3, or (at your option)
 # any later version.
 #
 # GNU Radio is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 #
 """
 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)
@@ -1,7 +0,0 @@
 """
 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.
 """
@@ -1,503 +0,0 @@
 #!/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
@@ -1,77 +0,0 @@
 #!/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
@@ -1,523 +0,0 @@
 #!/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()')
@@ -1,56 +0,0 @@
 #
 # Copyright 2010 Free Software Foundation, Inc.
 #
 # This file is part of GNU Radio
 #
 # GNU Radio is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 3, or (at your option)
 # any later version.
 #
 # GNU Radio is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with GNU Radio; see the file COPYING.  If not, write to
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 #
 """
 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
@@ -1,7 +0,0 @@
 /*!
 * \defgroup block GNU Radio CCS C++ Signal Processing Blocks
 * \brief All C++ blocks that can be used from the CCS GNU Radio
 *        module are listed here or in the subcategories below.
 *
 */
@@ -1,10 +0,0 @@
 /*! \mainpage
 Welcome to the GNU Radio CCS Block
 This is the intro page for the Doxygen manual generated for the CCS
 block (docs/doxygen/other/main_page.dox). Edit it to add more detailed
 documentation about the new GNU Radio modules contained in this
 project.
 */
@@ -1,255 +0,0 @@
 #
 # 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)
@@ -1,6 +1,6 @@
 # Copyright 2011 Free Software Foundation, Inc.
 #
-# This file is part of GNU Radio
+# This file is part of gr-foo
 #
 # 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
@@ -17,6 +17,17 @@
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
-file(GLOB xml_files "*.xml")
+install(FILES
-
+	foo_burst_tagger.block.yml
-install(FILES ${xml_files} DESTINATION share/gnuradio/grc/blocks )
+	foo_packet_pad2.block.yml
 	foo_random_periodic_msg_source.block.yml
 	foo_valve.block.yml
 	foo_channel_model.block.yml
 	foo_packet_pad.block.yml
 	foo_rtt_measure.block.yml
 	foo_wireshark_connector.block.yml
 	foo_packet_dropper.block.yml
 	foo_periodic_msg_source.block.yml
 	foo_selector.block.yml
    foo_pad_tagged_stream.block.yml	DESTINATION share/gnuradio/grc/blocks
 )
@@ -0,0 +1,33 @@
 # auto-generated by grc.converter
 id: foo_burst_tagger
 label: Burst Tagger
 category: '[Foo]'
 parameters:
 -   id: tag_name
    label: Tag Name
    dtype: raw
    default: pmt.intern("burst_len")
 -   id: mult
    label: Multiplier
    dtype: int
    default: '1'
 inputs:
 -   domain: stream
    dtype: complex
 outputs:
 -   domain: stream
    dtype: complex
 asserts:
 - ${ mult > 0 }
 templates:
    imports: |-
        import pmt
        import foo
    make: foo.burst_tagger(${tag_name}, ${mult})
 file_format: 1
@@ -1,35 +0,0 @@
 <?xml version="1.0"?>
 <block>
  <name>Burst Tagger</name>
  <key>foo_burst_tagger</key>
  <category>[Foo]</category>
  <import>import pmt</import>
  <import>import foo</import>
  <make>foo.burst_tagger($tag_name, $mult)</make>
  <param>
    <name>Tag Name</name>
    <key>tag_name</key>
    <value>pmt.intern("burst_len")</value>
    <type>raw</type>
  </param>
  <param>
    <name>Multiplier</name>
    <key>mult</key>
    <value>1</value>
    <type>int</type>
  </param>
  <check>$mult > 0</check>
  <sink>
    <name>in</name>
    <type>complex</type>
  </sink>
  <source>
    <name>out</name>
    <type>complex</type>
  </source>
 </block>
@@ -0,0 +1,57 @@
 # auto-generated by grc.converter
 id: foo_channel_model
 label: Channel Model
 category: '[Foo]'
 parameters:
 -   id: noise_voltage
    label: Noise Voltage
    dtype: real
    default: '0.0'
 -   id: freq_offset
    label: Frequency Offset
    dtype: real
    default: '0.0'
 -   id: epsilon
    label: Epsilon
    dtype: real
    default: '1.0'
 -   id: taps
    label: Taps
    dtype: complex_vector
    default: 1.0 + 1.0j
 -   id: seed
    label: Seed
    dtype: int
    default: '0'
 -   id: block_tags
    label: Block Tag Propagation
    dtype: enum
    default: 'False'
    options: ['True', 'False']
    option_labels: ['Yes', 'No']
    option_attributes:
        hide_block: ['', part]
    hide: ${ block_tags.hide_block }
 inputs:
 -   domain: stream
    dtype: complex
 outputs:
 -   domain: stream
    dtype: complex
 templates:
    imports: import foo
    make: "foo.channel_model(\n\tnoise_voltage=${noise_voltage},\n\tfrequency_offset=${freq_offset},\n\
        \tepsilon=${epsilon},\n\ttaps=${taps},\n\tnoise_seed=${seed},\n\tblock_tags=${block_tags}\n\
        )"
    callbacks:
    - set_noise_voltage(${noise_voltage})
    - set_frequency_offset(${freq_offset})
    - set_taps(${taps})
    - set_timing_offset(${epsilon})
 file_format: 1
@@ -0,0 +1,29 @@
 # auto-generated by grc.converter
 id: foo_packet_dropper
 label: Packet Dropper
 category: '[Foo]'
 parameters:
 -   id: drop_rate
    label: Packet drop rate
    dtype: real
    default: '0.5'
 -   id: seed
    label: Random seed
    dtype: int
    default: '42'
 inputs:
 -   domain: message
    id: in
 outputs:
 -   domain: message
    id: out
 templates:
    imports: import foo
    make: foo.packet_dropper(${drop_rate}, ${seed})
 file_format: 1
@@ -1,32 +0,0 @@
 <?xml version="1.0"?>
 <block>
  <name>Packet Dropper</name>
  <key>foo_packet_dropper</key>
  <category>[Foo]</category>
  <import>import foo</import>
  <make>foo.packet_dropper($drop_rate, $seed)</make>
  <param>
    <name>Packet drop rate</name>
    <key>drop_rate</key>
    <value>0.5</value>
    <type>real</type>
  </param>
  <param>
    <name>Random seed</name>
    <key>seed</key>
    <value>42</value>
    <type>int</type>
  </param>
  <sink>
    <name>in</name>
    <type>message</type>
  </sink>
  <source>
    <name>out</name>
    <type>message</type>
  </source>
 </block> 
@@ -0,0 +1,51 @@
 # auto-generated by grc.converter
 id: foo_packet_pad
 label: Packet Pad
 category: '[Foo]'
 parameters:
 -   id: debug
    label: Debug
    dtype: bool
    default: 'False'
    options: ['True', 'False']
    option_labels: [Enable, Disable]
 -   id: delay
    label: Delay
    dtype: bool
    default: 'False'
    options: ['True', 'False']
    option_labels: [Enable, Disable]
 -   id: delay_sec
    label: Delay Sec
    dtype: real
    default: '0.001'
 -   id: pad_front
    label: Pad Front
    dtype: int
    default: '0'
 -   id: pad_tail
    label: Pad Tail
    dtype: int
    default: '0'
 inputs:
 -   domain: stream
    dtype: complex
    multiplicity: '1'
 outputs:
 -   domain: stream
    dtype: complex
    multiplicity: '1'
 asserts:
 - ${ pad_front >= 0 }
 - ${ pad_tail >= 0 }
 - ${ delay_sec > 0 }
 templates:
    imports: import foo
    make: foo.packet_pad(${debug}, ${delay}, ${delay_sec}, ${pad_front}, ${pad_tail})
 file_format: 1
@@ -1,79 +0,0 @@
 <?xml version="1.0"?>
 <block>
 	<name>Packet Pad</name>
 	<key>foo_packet_pad</key>
 	<category>[Foo]</category>
 	<import>import foo</import>
 	<make>foo.packet_pad($debug, $delay, $delay_sec, $pad_front, $pad_tail)</make>
 	<param>
 		<name>Debug</name>
 		<key>debug</key>
 		<value>False</value>
 		<type>bool</type>
 		<option>
 			<name>Enable</name>
 			<key>True</key>
 		</option>
 		<option>
 			<name>Disable</name>
 			<key>False</key>
 		</option>
 	</param>
 	<param>
 		<name>Delay</name>
 		<key>delay</key>
 		<value>False</value>
 		<type>bool</type>
 		<option>
 			<name>Enable</name>
 			<key>True</key>
 		</option>
 		<option>
 			<name>Disable</name>
 			<key>False</key>
 		</option>
 	</param>
 	<param>
 		<name>Delay Sec</name>
 		<key>delay_sec</key>
 		<value>0.001</value>
 		<type>real</type>
 	</param>
 	<param>
 		<name>Pad Front</name>
 		<key>pad_front</key>
 		<value>0</value>
 		<type>int</type>
 	</param>
 	<param>
 		<name>Pad Tail</name>
 		<key>pad_tail</key>
 		<value>0</value>
 		<type>int</type>
 	</param>
        <check>$pad_front >= 0</check>
        <check>$pad_tail >= 0</check>
        <check>$delay_sec > 0</check>
 	<sink>
 		<name>in</name>
 		<type>complex</type>
 		<nports>1</nports>
 	</sink>
 	<source>
 		<name>out</name>
 		<type>complex</type>
 		<nports>1</nports>
 	</source>
 </block>
@@ -0,0 +1,51 @@
 # auto-generated by grc.converter
 id: foo_packet_pad2
 label: Packet Pad2
 category: '[Foo]'
 parameters:
 -   id: debug
    label: Debug
    dtype: bool
    default: 'False'
    options: ['True', 'False']
    option_labels: [Enable, Disable]
 -   id: delay
    label: Delay
    dtype: bool
    default: 'False'
    options: ['True', 'False']
    option_labels: [Enable, Disable]
 -   id: delay_sec
    label: Delay Sec
    dtype: real
    default: '0.001'
 -   id: pad_front
    label: Pad Front
    dtype: int
    default: '0'
 -   id: pad_tail
    label: Pad Tail
    dtype: int
    default: '0'
 inputs:
 -   domain: stream
    dtype: complex
    multiplicity: '1'
 outputs:
 -   domain: stream
    dtype: complex
    multiplicity: '1'
 asserts:
 - ${ pad_front >= 0 }
 - ${ pad_tail >= 0 }
 - ${ delay_sec > 0 }
 templates:
    imports: import foo
    make: foo.packet_pad2(${debug}, ${delay}, ${delay_sec}, ${pad_front}, ${pad_tail})
 file_format: 1
@@ -1,79 +0,0 @@
 <?xml version="1.0"?>
 <block>
 	<name>Packet Pad2</name>
 	<key>foo_packet_pad2</key>
 	<category>[Foo]</category>
 	<import>import foo</import>
 	<make>foo.packet_pad2($debug, $delay, $delay_sec, $pad_front, $pad_tail)</make>
 	<param>
 		<name>Debug</name>
 		<key>debug</key>
 		<value>False</value>
 		<type>bool</type>
 		<option>
 			<name>Enable</name>
 			<key>True</key>
 		</option>
 		<option>
 			<name>Disable</name>
 			<key>False</key>
 		</option>
 	</param>
 	<param>
 		<name>Delay</name>
 		<key>delay</key>
 		<value>False</value>
 		<type>bool</type>
 		<option>
 			<name>Enable</name>
 			<key>True</key>
 		</option>
 		<option>
 			<name>Disable</name>
 			<key>False</key>
 		</option>
 	</param>
 	<param>
 		<name>Delay Sec</name>
 		<key>delay_sec</key>
 		<value>0.001</value>
 		<type>real</type>
 	</param>
 	<param>
 		<name>Pad Front</name>
 		<key>pad_front</key>
 		<value>0</value>
 		<type>int</type>
 	</param>
 	<param>
 		<name>Pad Tail</name>
 		<key>pad_tail</key>
 		<value>0</value>
 		<type>int</type>
 	</param>
        <check>$pad_front >= 0</check>
        <check>$pad_tail >= 0</check>
        <check>$delay_sec > 0</check>
 	<sink>
 		<name>in</name>
 		<type>complex</type>
 		<nports>1</nports>
 	</sink>
 	<source>
 		<name>out</name>
 		<type>complex</type>
 		<nports>1</nports>
 	</source>
 </block>
@@ -0,0 +1,46 @@
 id: foo_pad_tagged_stream
 label: Pad Tagged Stream
 category: '[Foo]'
 templates:
  imports: import foo
  make: foo.pad_tagged_stream(${buffer_size}, ${len_tag_name})
 #  Make one 'parameters' list entry for every parameter you want settable from the GUI.
 #     Keys include:
 #     * id (makes the value accessible as \$keyname, e.g. in the make entry)
 #     * label (label shown in the GUI)
 #     * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
 parameters:
 - id: buffer_size
  label: Buffer Size
  dtype: int
  default: '0x8000'
 - id: len_tag_name
  label: Length Tag Key
  dtype: string
 #  Make one 'inputs' list entry per input and one 'outputs' list entry per output.
 #  Keys include:
 #      * label (an identifier for the GUI)
 #      * domain (optional - stream or message. Default is stream)
 #      * dtype (e.g. int, float, complex, byte, short, xxx_vector, ...)
 #      * vlen (optional - data stream vector length. Default is 1)
 #      * optional (optional - set to 1 for optional inputs. Default is 0)
 inputs:
 - label: in
  domain: stream
  dtype: complex
  vlen: 1
  optional: 0
 outputs:
 - label: out
  domain: stream
  dtype: complex
  vlen: 1
  optional: 0
 #  'file_format' specifies the version of the GRC yml format used in the file
 #  and should usually not be changed.
 file_format: 1
@@ -0,0 +1,44 @@
 # auto-generated by grc.converter
 id: foo_periodic_msg_source
 label: Periodic Message Source
 category: '[Foo]'
 parameters:
 -   id: msg
    label: Message PMT
    dtype: raw
    default: pmt.intern("Hello World!")
 -   id: interval
    label: Period (ms)
    dtype: int
    default: '1000'
 -   id: quit
    label: Quit
    dtype: bool
    default: 'True'
    options: ['True', 'False']
    option_labels: [Enable, Disable]
 -   id: debug
    label: Debug
    dtype: bool
    default: 'False'
    options: ['True', 'False']
    option_labels: [Enable, Disable]
 -   id: num
    label: Num Messages
    dtype: int
    default: '-1'
 outputs:
 -   domain: message
    id: out
    optional: true
 templates:
    imports: |-
        import foo
        import pmt
    make: foo.periodic_msg_source(${msg}, ${interval}, ${num}, ${quit}, ${debug})
 file_format: 1
@@ -1,61 +0,0 @@
 <?xml version="1.0"?>
 <block>
 	<name>Periodic Message Source</name>
 	<key>foo_periodic_msg_source</key>
 	<category>[Foo]</category>
 	<import>import foo</import>
 	<import>import pmt</import>
 	<make>foo.periodic_msg_source($msg, $interval, $num, $quit, $debug)</make>
 	<param>
 		<name>Message PMT</name>
 		<key>msg</key>
 		<value>pmt.intern("Hello World!")</value>
 		<type>raw</type>
 	</param>
 	<param>
 		<name>Period (ms)</name>
 		<key>interval</key>
 		<value>1000</value>
 		<type>int</type>
 	</param>
 	<param>
 		<name>Quit</name>
 		<key>quit</key>
 		<value>True</value>
 		<type>bool</type>
 		<option>
 			<name>Enable</name>
 			<key>True</key>
 		</option>
 		<option>
 			<name>Disable</name>
 			<key>False</key>
 		</option>
 	</param>
 	<param>
 		<name>Debug</name>
 		<key>debug</key>
 		<value>False</value>
 		<type>bool</type>
 		<option>
 			<name>Enable</name>
 			<key>True</key>
 		</option>
 		<option>
 			<name>Disable</name>
 			<key>False</key>
 		</option>
 	</param>
 	<param>
 		<name>Num Messages</name>
 		<key>num</key>
 		<value>-1</value>
 		<type>int</type>
 	</param>
 	<source>
 		<name>out</name>
 		<type>message</type>
 		<optional>1</optional>
 	</source>
 </block>
@@ -0,0 +1,49 @@
 # auto-generated by grc.converter
 id: foo_random_periodic_msg_source
 label: Random Periodic Message Source
 category: '[Foo]'
 parameters:
 -   id: msg_len
    label: Message Length
    dtype: int
    default: '64'
 -   id: interval
    label: Period (ms)
    dtype: int
    default: '1000'
 -   id: quit
    label: Quit
    dtype: bool
    default: 'True'
    options: ['True', 'False']
    option_labels: [Enable, Disable]
 -   id: debug
    label: Debug
    dtype: bool
    default: 'False'
    options: ['True', 'False']
    option_labels: [Enable, Disable]
 -   id: num
    label: Num Messages
    dtype: int
    default: '1'
 -   id: seed
    label: Random Seed
    dtype: int
    default: '1'
 outputs:
 -   domain: message
    id: out
    optional: true
 templates:
    imports: |-
        import foo
        import pmt
    make: foo.random_periodic_msg_source(${msg_len}, ${interval}, ${num}, ${quit},
        ${debug}, ${seed})
 file_format: 1
@@ -1,67 +0,0 @@
 <?xml version="1.0"?>
 <block>
 	<name>Random Periodic Message Source</name>
 	<key>foo_random_periodic_msg_source</key>
 	<category>[Foo]</category>
 	<import>import foo</import>
 	<import>import pmt</import>
 	<make>foo.random_periodic_msg_source($msg_len, $interval, $num, $quit, $debug, $seed)</make>
 	<param>
 		<name>Message Length</name>
 		<key>msg_len</key>
 		<value>64</value>
 		<type>int</type>
 	</param>
 	<param>
 		<name>Period (ms)</name>
 		<key>interval</key>
 		<value>1000</value>
 		<type>int</type>
 	</param>
 	<param>
 		<name>Quit</name>
 		<key>quit</key>
 		<value>True</value>
 		<type>bool</type>
 		<option>
 			<name>Enable</name>
 			<key>True</key>
 		</option>
 		<option>
 			<name>Disable</name>
 			<key>False</key>
 		</option>
 	</param>
 	<param>
 		<name>Debug</name>
 		<key>debug</key>
 		<value>False</value>
 		<type>bool</type>
 		<option>
 			<name>Enable</name>
 			<key>True</key>
 		</option>
 		<option>
 			<name>Disable</name>
 			<key>False</key>
 		</option>
 	</param>
 	<param>
 		<name>Num Messages</name>
 		<key>num</key>
 		<value>1</value>
 		<type>int</type>
 	</param>
 	<param>
 		<name>Random Seed</name>
 		<key>seed</key>
 		<value>1</value>
 		<type>int</type>
 	</param>
 	<source>
 		<name>out</name>
 		<type>message</type>
 		<optional>1</optional>
 	</source>
 </block>
@@ -0,0 +1,28 @@
 # auto-generated by grc.converter
 id: foo_rtt_measure
 label: RTT measure
 category: '[Foo]'
 parameters:
 -   id: interval
    label: Send interval
    dtype: int
    default: '500'
 inputs:
 -   domain: message
    id: in
 outputs:
 -   label: dout
    domain: stream
    dtype: byte
 -   domain: message
    id: out
 templates:
    imports: import foo
    make: foo.rtt_measure(${interval})
 file_format: 1
@@ -1,30 +0,0 @@
 <?xml version="1.0"?>
 <block>
  <name>RTT measure</name>
  <key>foo_rtt_measure</key>
  <category>[Foo]</category>
  <import>import foo</import>
  <make>foo.rtt_measure($interval)</make>
  <param>
    <name>Send interval</name>
    <key>interval</key>
    <value>500</value>
    <type>int</type>
  </param>
  <sink>
    <name>in</name>
    <type>message</type>
  </sink>
  <source>
    <name>dout</name>
    <type>byte</type>
  </source>
  <source>
    <name>out</name>
    <type>message</type>
  </source>
 </block>  
@@ -0,0 +1,66 @@
 # auto-generated by grc.converter
 id: foo_selector
 label: Selector
 category: '[Foo]'
 parameters:
 -   id: type
    label: Type
    dtype: enum
    options: [complex, float, int, short, byte]
    option_attributes:
        size: [gr.sizeof_gr_complex, gr.sizeof_float, gr.sizeof_int, gr.sizeof_short,
            gr.sizeof_char]
    hide: part
 -   id: num_inputs
    label: Num Inputs
    dtype: int
    default: '2'
    hide: part
 -   id: num_outputs
    label: Num Outputs
    dtype: int
    default: '2'
    hide: part
 -   id: input_index
    label: Input Index
    dtype: int
    default: '0'
 -   id: output_index
    label: Output Index
    dtype: int
    default: '0'
 -   id: vlen
    label: Vec Length
    dtype: int
    default: '1'
    hide: ${ 'part' if vlen == 1 else 'none' }
 inputs:
 -   domain: stream
    dtype: ${ type }
    vlen: ${ vlen }
    multiplicity: ${ num_inputs }
 outputs:
 -   domain: stream
    dtype: ${ type }
    vlen: ${ vlen }
    multiplicity: ${ num_outputs }
 asserts:
 - ${ vlen > 0 }
 templates:
    imports: import foo
    make: "foo.selector(\n\titem_size=${type.size}*${vlen},\n\tnum_inputs=${num_inputs},\n\
        \tnum_outputs=${num_outputs},\n\tinput_index=${input_index},\n\toutput_index=${output_index},\n\
        )"
    callbacks:
    - set_input_index(int(${input_index}))
    - set_output_index(int(${output_index}))
 documentation: |-
    Connect the sink at input index to the source at output index. Leave all other ports disconnected.
 file_format: 1
@@ -0,0 +1,47 @@
 # auto-generated by grc.converter
 id: foo_valve
 label: Valve
 category: '[Foo]'
 parameters:
 -   id: type
    label: Type
    dtype: enum
    options: [complex, float, int, short, byte]
    option_attributes:
        size: [gr.sizeof_gr_complex, gr.sizeof_float, gr.sizeof_int, gr.sizeof_short,
            gr.sizeof_char]
    hide: part
 -   id: open
    label: Open
    dtype: raw
    default: '0'
 -   id: vlen
    label: Vec Length
    dtype: int
    default: '1'
    hide: ${ 'part' if vlen == 1 else 'none' }
 inputs:
 -   domain: stream
    dtype: ${ type }
    vlen: ${ vlen }
 outputs:
 -   domain: stream
    dtype: ${ type }
    vlen: ${ vlen }
 asserts:
 - ${ vlen > 0 }
 templates:
    imports: import foo
    make: foo.valve(item_size=${type.size}*${vlen}, open=bool(${open}))
    callbacks:
    - set_open(bool(${open}))
 documentation: |-
    Connect output to input when valve is closed (not open).
 file_format: 1
@@ -0,0 +1,34 @@
 # auto-generated by grc.converter
 id: foo_wireshark_connector
 label: Wireshark Connector
 category: '[Foo]'
 parameters:
 -   id: tech
    label: Technology
    dtype: enum
    default: '127'
    options: ['127', '195']
    option_labels: [WiFi, ZigBee]
 -   id: debug
    label: Debug
    dtype: bool
    default: 'False'
    options: ['True', 'False']
    option_labels: [Enable, Disable]
 inputs:
 -   domain: message
    id: in
 outputs:
 -   domain: stream
    dtype: byte
    multiplicity: '1'
 templates:
    imports: import foo
    make: foo.wireshark_connector(${tech}, ${debug})
 file_format: 1
@@ -1,49 +0,0 @@
 <?xml version="1.0"?>
 <block>
 	<name>Wireshark Connector</name>
 	<key>foo_wireshark_connector</key>
 	<category>[Foo]</category>
 	<import>import foo</import>
 	<make>foo.wireshark_connector($tech, $debug)</make>
 	<param>
 		<name>Technology</name>
 		<key>tech</key>
 		<value>127</value>
 		<type>enum</type>
 		<option>
 			<name>WiFi</name>
 			<key>127</key>
 		</option>
 		<option>
 			<name>ZigBee</name>
 			<key>195</key>
 		</option>
 	</param>
 	<param>
 		<name>Debug</name>
 		<key>debug</key>
 		<value>False</value>
 		<type>bool</type>
 		<option>
 			<name>Enable</name>
 			<key>True</key>
 		</option>
 		<option>
 			<name>Disable</name>
 			<key>False</key>
 		</option>
 	</param>
 	<sink>
 		<name>in</name>
 		<type>message</type>
 	</sink>
 	<source>
 		<name>out</name>
 		<type>byte</type>
 		<nports>1</nports>
 	</source>
 </block>
@@ -1,6 +1,6 @@
 # Copyright 2011,2012 Free Software Foundation, Inc.
 #
-# This file is part of GNU Radio
+# This file is part of gr-foo
 #
 # 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
@@ -23,6 +23,7 @@
 install(FILES
 	api.h
 	burst_tagger.h
 	channel_model.h
 	packet_dropper.h
 	packet_pad.h
 	packet_pad2.h
@@ -30,5 +31,5 @@ install(FILES
 	random_periodic_msg_source.h
 	rtt_measure.h
 	wireshark_connector.h
-	DESTINATION include/foo
+    pad_tagged_stream.h	DESTINATION include/foo
 )
@@ -1,7 +1,7 @@
 /*
 * Copyright 2011 Free Software Foundation, Inc.
 *
- * This file is part of GNU Radio
+ * This file is part of gr-foo
 *
 * 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
@@ -0,0 +1,51 @@
 /*
 * Copyright (C) 2017 Bastian Bloessl <mail@bastibl.net>
 *
 * This program 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 of the License, or
 * (at your option) any later version.
 *
 * This program 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, see <http://www.gnu.org/licenses/>.
 */
 #ifndef INCLUDED_FOO_CHANNEL_MODEL_H
 #define INCLUDED_FOO_CHANNEL_MODEL_H
 #include <foo/api.h>
 #include <gnuradio/hier_block2.h>
 #include <gnuradio/types.h>
 namespace gr {
 namespace foo {
 class FOO_API channel_model : virtual public hier_block2
 {
 public:
    typedef boost::shared_ptr<channel_model> sptr;
    static sptr make(double noise_voltage = 0.0, double frequency_offset = 0.0,
            double epsilon = 1.0,
            const std::vector<gr_complex> &taps = std::vector<gr_complex>(1, 1),
            double noise_seed = 0, bool block_tags = false);
    virtual void set_noise_voltage(double noise_voltage) = 0;
    virtual void set_frequency_offset(double frequency_offset) = 0;
    virtual void set_taps(const std::vector<gr_complex> &taps) = 0;
    virtual void set_timing_offset(double epsilon) = 0;
    virtual double noise_voltage() const = 0;
    virtual double frequency_offset() const = 0;
    virtual std::vector<gr_complex> taps() const = 0;
    virtual double timing_offset() const = 0;
 };
 } // namespace foo
 } // namespace gr
 #endif /* INCLUDED_FOO_CHANNEL_MODEL_H */
@@ -0,0 +1,55 @@
 /* -*- c++ -*- */
 /*
 * Copyright 2019 "Cyancali".
 *
 * 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.
 */
 #ifndef INCLUDED_FOO_PAD_TAGGED_STREAM_H
 #define INCLUDED_FOO_PAD_TAGGED_STREAM_H
 #include <foo/api.h>
 #include <gnuradio/tagged_stream_block.h>
 namespace gr {
  namespace foo {
    /*!
     * \brief <+description of block+>
     * \ingroup foo
     *
     */
    class FOO_API pad_tagged_stream : virtual public gr::tagged_stream_block
    {
     public:
      typedef boost::shared_ptr<pad_tagged_stream> sptr;
      /*!
       * \brief Return a shared_ptr to a new instance of foo::pad_tagged_stream.
       *
       * To avoid accidental use of raw pointers, foo::pad_tagged_stream's
       * constructor is in a private implementation
       * class. foo::pad_tagged_stream::make is the public interface for
       * creating new instances.
       */
      static sptr make(int buffer_size, const std::string len_tag_name);
    };
  } // namespace foo
 } // namespace gr
 #endif /* INCLUDED_FOO_PAD_TAGGED_STREAM_H */
@@ -1,6 +1,6 @@
 # Copyright 2011,2012 Free Software Foundation, Inc.
 #
-# This file is part of GNU Radio
+# This file is part of gr-foo
 #
 # 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
@@ -23,16 +23,15 @@
 include(GrPlatform) #define LIB_SUFFIX
 include_directories(
    ${Boost_INCLUDE_DIR}
    ${UHD_INCLUDE_DIRS}
 )
 link_directories(
    ${Boost_LIBRARY_DIRS}
    ${UHD_LIBRARY_DIRS}
 )
 list(APPEND foo_sources
    burst_tagger_impl.cc
    channel_model_impl.cc
    packet_dropper_impl.cc
    packet_pad2.cc
    packet_pad_impl.cc
@@ -40,36 +39,54 @@ list(APPEND foo_sources
    random_periodic_msg_source_impl.cc
    rtt_measure_impl.cc
    wireshark_connector_impl.cc
    pad_tagged_stream_impl.cc
 )
-set(PACKAGE_FIND_VERSION_MAJOR 0)
+set(foo_sources "${foo_sources}" PARENT_SCOPE)
-include(GnuradioConfigVersion)
+if(NOT foo_sources)
-
+    MESSAGE(STATUS "No C++ sources... skipping lib/")
-if(${API_COMPAT} EQUAL 8)
+    return()
-    message(STATUS "next branch (3.8 install), using new API")
+endif(NOT foo_sources)
    add_definitions("-DGR_FOO_NEW_API")
 elseif(${MINOR_VERSION} GREATER 7)
    message(STATUS "recent 3.7.8 install, using new API")
    add_definitions("-DGR_FOO_NEW_API")
 elseif(${MINOR_VERSION} EQUAL 7 AND NOT ${MAINT_VERSION} STREQUAL "git")
    message(STATUS "recent real 3.7.7 install, using new API")
    add_definitions("-DGR_FOO_NEW_API")
 elseif(${MINOR_VERSION} EQUAL 6 AND NOT ${MAINT_VERSION} STREQUAL "git" AND ${MAINT_VERSION} GREATER 0)
    message(STATUS "3.7.6 with maint version >= 1 install, using new API")
    add_definitions("-DGR_FOO_NEW_API")
 else()
    message(STATUS "using old API")
 endif()
 add_library(gnuradio-foo SHARED ${foo_sources})
-target_link_libraries(gnuradio-foo ${Boost_LIBRARIES} ${GNURADIO_ALL_LIBRARIES} ${UHD_LIBRARIES})
+target_link_libraries(gnuradio-foo
  gnuradio::gnuradio-runtime
  gnuradio::gnuradio-pmt
  gnuradio::gnuradio-blocks
  gnuradio::gnuradio-filter
  gnuradio::gnuradio-analog
  ${UHD_LIBRARIES})
 target_include_directories(gnuradio-foo
    PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
    PUBLIC $<INSTALL_INTERFACE:include>
  )
 set_target_properties(gnuradio-foo PROPERTIES DEFINE_SYMBOL "gnuradio_foo_EXPORTS")
 if(APPLE)
    set_target_properties(gnuradio-foo PROPERTIES
        INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib"
    )
 endif(APPLE)
 ########################################################################
 # Install built library files
 ########################################################################
-install(TARGETS gnuradio-foo
+include(GrMiscUtils)
-    LIBRARY DESTINATION lib${LIB_SUFFIX} # .so/.dylib file
+GR_LIBRARY_FOO(gnuradio-foo)
-    ARCHIVE DESTINATION lib${LIB_SUFFIX} # .lib file
+
-    RUNTIME DESTINATION bin              # .dll file
+########################################################################
 # Print summary
 ########################################################################
 message(STATUS "Using install prefix: ${CMAKE_INSTALL_PREFIX}")
 message(STATUS "Building for version: ${VERSION} / ${LIBVER}")
 ########################################################################
 # Build and register unit test
 ########################################################################
 include(GrTest)
 # If your unit tests require special include paths, add them here
 #include_directories()
 # List all files that contain Boost.UTF unit tests here
 list(APPEND test_foo_sources
 )
@@ -0,0 +1,140 @@
 /*
 * Copyright (C) 2017 Bastian Bloessl <mail@bastibl.net>
 *
 * This program 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 of the License, or
 * (at your option) any later version.
 *
 * This program 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, see <http://www.gnu.org/licenses/>.
 */
 #include "channel_model_impl.h"
 #include <gnuradio/io_signature.h>
 #include <iostream>
 namespace gr {
 namespace foo {
 channel_model::sptr
 channel_model::make(double noise_voltage,
 		    double frequency_offset,
 		    double epsilon,
 		    const std::vector<gr_complex> &taps,
 		    double noise_seed,
 		    bool block_tags)
 {
    return gnuradio::get_initial_sptr
    (new channel_model_impl(noise_voltage,
 			    frequency_offset,
 			    epsilon,
 			    taps,
 			    noise_seed,
 			    block_tags));
 }
 // Hierarchical block constructor
 channel_model_impl::channel_model_impl(double noise_voltage,
 					double frequency_offset,
 					double epsilon,
 					const std::vector<gr_complex> &taps,
 					double noise_seed,
 					bool block_tags
 					)
    : hier_block2("channel_model",
 		    io_signature::make(1, 1, sizeof(gr_complex)),
 		    io_signature::make(1, 1, sizeof(gr_complex)))
 {
    d_taps = taps;
    while(d_taps.size() < 2) {
    d_taps.push_back(0);
    }
    d_timing_offset = filter::mmse_resampler_cc::make(0, epsilon);
    d_multipath = filter::fir_filter_ccc::make(1, d_taps);
    d_noise_adder = blocks::add_cc::make();
    d_noise = analog::noise_source_c::make(analog::GR_GAUSSIAN,
 						noise_voltage, noise_seed);
    d_freq_offset = analog::sig_source_c::make(1, analog::GR_SIN_WAVE,
 						frequency_offset, 1.0, 0.0);
    d_mixer_offset = blocks::multiply_cc::make();
    connect(self(), 0, d_timing_offset, 0);
    connect(d_timing_offset, 0, d_multipath, 0);
    connect(d_multipath, 0, d_mixer_offset, 0);
    connect(d_freq_offset, 0, d_mixer_offset, 1);
    connect(d_mixer_offset, 0, d_noise_adder, 1);
    connect(d_noise, 0, d_noise_adder, 0);
    connect(d_noise_adder, 0, self(), 0);
    if (block_tags) {
    d_timing_offset->set_tag_propagation_policy(gr::block::TPP_DONT);
    }
 }
 channel_model_impl::~channel_model_impl()
 {
 }
 void
 channel_model_impl::set_noise_voltage(double noise_voltage)
 {
    d_noise->set_amplitude(noise_voltage);
 }
 void
 channel_model_impl::set_frequency_offset(double frequency_offset)
 {
    d_freq_offset->set_frequency(frequency_offset);
 }
 void
 channel_model_impl::set_taps(const std::vector<gr_complex> &taps)
 {
    d_taps = taps;
    while(d_taps.size() < 2) {
    d_taps.push_back(0);
    }
    d_multipath->set_taps(d_taps);
 }
 void
 channel_model_impl::set_timing_offset(double epsilon)
 {
    d_timing_offset->set_resamp_ratio(epsilon);
 }
 double
 channel_model_impl::noise_voltage() const
 {
    return d_noise->amplitude();
 }
 double
 channel_model_impl::frequency_offset() const
 {
    return d_freq_offset->frequency();
 }
 std::vector<gr_complex>
 channel_model_impl::taps() const
 {
    return d_multipath->taps();
 }
 double
 channel_model_impl::timing_offset() const
 {
    return d_timing_offset->resamp_ratio();
 }
 } /* namespace channels */
 } /* namespace gr */
@@ -0,0 +1,71 @@
 /*
 * Copyright (C) 2017 Bastian Bloessl <mail@bastibl.net>
 *
 * This program 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 of the License, or
 * (at your option) any later version.
 *
 * This program 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, see <http://www.gnu.org/licenses/>.
 */
 #ifndef INCLUDED_FOO_CHANNEL_MODEL_IMPL_H
 #define INCLUDED_FOO_CHANNEL_MODEL_IMPL_H
 #include <foo/channel_model.h>
 #include <gnuradio/top_block.h>
 #include <gnuradio/blocks/add_blk.h>
 #include <gnuradio/blocks/multiply.h>
 #include <gnuradio/analog/sig_source.h>
 #include <gnuradio/analog/noise_source.h>
 #include <gnuradio/filter/mmse_resampler_cc.h>
 #include <gnuradio/filter/fir_filter_blk.h>
 namespace gr {
 namespace foo {
 class FOO_API channel_model_impl : public foo::channel_model
 {
 private:
    blocks::add_cc::sptr d_noise_adder;
    blocks::multiply_cc::sptr d_mixer_offset;
    analog::sig_source_c::sptr d_freq_offset;
    analog::noise_source_c::sptr d_noise;
    filter::mmse_resampler_cc::sptr d_timing_offset;
    filter::fir_filter_ccc::sptr d_multipath;
    std::vector<gr_complex> d_taps;
 public:
    channel_model_impl(double noise_voltage,
 			double frequency_offset,
 			double epsilon,
 			const std::vector<gr_complex> &taps,
 			double noise_seed,
 			bool block_tags);
    ~channel_model_impl();
    void set_noise_voltage(double noise_voltage);
    void set_frequency_offset(double frequency_offset);
    void set_taps(const std::vector<gr_complex> &taps);
    void set_timing_offset(double epsilon);
    double noise_voltage() const;
    double frequency_offset() const;
    std::vector<gr_complex> taps() const;
    double timing_offset() const;
 };
 } // namespace foo
 } // namespace gr
 #endif /* INCLUDED_FOO_CHANNEL_MODEL_IMPL_H */
@@ -32,7 +32,7 @@ packet_dropper_impl::packet_dropper_impl(double drop_rate, unsigned long seed)
 		throw std::out_of_range("drop rate has to be < 1");
 	}
 	message_port_register_in(pmt::mp("in"));
-	set_msg_handler(pmt::mp("in"), boost::bind(&packet_dropper_impl::msg_handler, this, _1));
+	set_msg_handler(pmt::mp("in"), boost::bind(&packet_dropper_impl::msg_handler, this, boost::placeholders::_1));
 	message_port_register_out(pmt::mp("out"));
 }
@@ -0,0 +1,95 @@
 /* -*- c++ -*- */
 /*
 * Copyright 2019 "Cyancali".
 *
 * 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.
 */
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include <gnuradio/io_signature.h>
 #include "pad_tagged_stream_impl.h"
 namespace gr {
  namespace foo {
    pad_tagged_stream::sptr
    pad_tagged_stream::make(int buffer_size, const std::string len_tag_name)
    {
      return gnuradio::get_initial_sptr
        (new pad_tagged_stream_impl(buffer_size, len_tag_name));
    }
    /*
     * The private constructor
     */
    pad_tagged_stream_impl::pad_tagged_stream_impl(int buffer_size, const std::string len_tag_name)
      : gr::tagged_stream_block("pad_tagged_stream",
                                gr::io_signature::make(1, 1, sizeof(gr_complex)),
                                gr::io_signature::make(1, 1, sizeof(gr_complex)),
                                len_tag_name),
        d_buf_len(buffer_size),
        d_len_tag(len_tag_name)
    {
        set_min_output_buffer(buffer_size*2);
        set_tag_propagation_policy(TPP_DONT);
    }
    /*
     * Our virtual destructor.
     */
    pad_tagged_stream_impl::~pad_tagged_stream_impl()
    {
    }
    int
    pad_tagged_stream_impl::calculate_output_stream_length(const gr_vector_int &ninput_items)
    {
      return d_buf_len;
    }
    int
    pad_tagged_stream_impl::work (int noutput_items,
                       gr_vector_int &ninput_items,
                       gr_vector_const_void_star &input_items,
                       gr_vector_void_star &output_items)
    {
      const gr_complex *in = (const gr_complex *) input_items[0];
      gr_complex *out = (gr_complex *) output_items[0];
      noutput_items = d_buf_len;
      memcpy(out, in, sizeof(gr_complex) * std::min(d_buf_len, ninput_items[0]));
      if (ninput_items[0] <= noutput_items)
      {
        memset((out+ninput_items[0]), 0, sizeof(gr_complex) * noutput_items-ninput_items[0]);
      }
      else // ninput_items[0] > noutput_items
      {
        std::cout << "PadTaggedStream: Warning - Tagged stream is longer than buffer" << std::endl;
      }
      return noutput_items;
    }
  } /* namespace foo */
 } /* namespace gr */
@@ -0,0 +1,52 @@
 /* -*- c++ -*- */
 /*
 * Copyright 2019 "Cyancali".
 *
 * 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.
 */
 #ifndef INCLUDED_FOO_PAD_TAGGED_STREAM_IMPL_H
 #define INCLUDED_FOO_PAD_TAGGED_STREAM_IMPL_H
 #include <foo/pad_tagged_stream.h>
 namespace gr {
  namespace foo {
    class pad_tagged_stream_impl : public pad_tagged_stream
    {
     private:
      int d_buf_len;
      std::string d_len_tag;
     public:
      pad_tagged_stream_impl(int buffer_size, const std::string len_tag_name);
      ~pad_tagged_stream_impl();
      int calculate_output_stream_length(const gr_vector_int &ninput_items);
      // Where all the action really happens
      int work(int noutput_items,
           gr_vector_int &ninput_items,
           gr_vector_const_void_star &input_items,
           gr_vector_void_star &output_items);
    };
  } // namespace foo
 } // namespace gr
 #endif /* INCLUDED_FOO_PAD_TAGGED_STREAM_IMPL_H */
@@ -43,7 +43,7 @@ periodic_msg_source_impl::periodic_msg_source_impl(pmt::pmt_t msg,
 }
 periodic_msg_source_impl::~periodic_msg_source_impl() {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	d_finished = true;
 	d_thread->interrupt();
@@ -54,20 +54,17 @@ periodic_msg_source_impl::~periodic_msg_source_impl() {
 void
 periodic_msg_source_impl::run(periodic_msg_source_impl *instance) {
 	try {
 	// flow graph startup delay
 	boost::this_thread::sleep(boost::posix_time::milliseconds(500));
 	while(1) {
 		long delay;
 		{
-			gr::thread::scoped_lock(d_mutex);
+			gr::thread::scoped_lock d_mutex;
 			if(d_finished || !d_nmsg_left) {
 				d_finished = true;
 				if(d_quit) {
 					boost::this_thread::sleep(boost::posix_time::milliseconds(500));
 					message_port_pub( pmt::mp("out"), pmt::PMT_EOF);
 					post(pmt::mp("system"), pmt::cons(pmt::mp("done"), pmt::from_long(1)));
 				}
 				break;
@@ -85,47 +82,36 @@ periodic_msg_source_impl::run(periodic_msg_source_impl *instance) {
 		}
 		boost::this_thread::sleep(boost::posix_time::milliseconds(delay));
 	}
 	} catch(boost::thread_interrupted) {
 		gr::thread::scoped_lock(d_mutex);
 		dout << "PMS: thread interrupted" << std::endl;
 		d_finished = true;
 		if(d_quit) {
 			boost::this_thread::sleep(boost::posix_time::milliseconds(500));
 			message_port_pub( pmt::mp("out"), pmt::PMT_EOF);
 			post(pmt::mp("system"), pmt::cons(pmt::mp("done"), pmt::from_long(1)));
 		}
 	}
 }
 void
 periodic_msg_source_impl::set_nmsg(int nmsg) {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	d_nmsg_total = nmsg;
 }
 int
 periodic_msg_source_impl::get_nmsg() {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	return d_nmsg_total;
 }
 void
 periodic_msg_source_impl::set_delay(long delay) {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	d_interval = delay;
 }
 long
 periodic_msg_source_impl::get_delay() {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	return d_interval;
 }
 void
 periodic_msg_source_impl::start_tx() {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	if(is_running()) return;
@@ -49,7 +49,7 @@ random_periodic_msg_source_impl::random_periodic_msg_source_impl(int msg_len,
 }
 random_periodic_msg_source_impl::~random_periodic_msg_source_impl() {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	d_finished = true;
 	d_thread->interrupt();
 	d_thread->join();
@@ -59,20 +59,17 @@ random_periodic_msg_source_impl::~random_periodic_msg_source_impl() {
 void
 random_periodic_msg_source_impl::run(random_periodic_msg_source_impl *instance) {
 	try {
 	// flow graph startup delay
 	boost::this_thread::sleep(boost::posix_time::milliseconds(500));
 	while(1) {
 		long delay;
 		{
-			gr::thread::scoped_lock(d_mutex);
+			gr::thread::scoped_lock d_mutex;
 			if(d_finished || !d_nmsg_left) {
 				d_finished = true;
 				if(d_quit) {
 					boost::this_thread::sleep(boost::posix_time::milliseconds(500));
 					message_port_pub( pmt::mp("out"), pmt::PMT_EOF);
 					post(pmt::mp("system"), pmt::cons(pmt::mp("done"), pmt::from_long(1)));
 				}
 				break;
@@ -91,59 +88,48 @@ random_periodic_msg_source_impl::run(random_periodic_msg_source_impl *instance)
 		}
 		boost::this_thread::sleep(boost::posix_time::milliseconds(delay));
 	}
 	} catch(boost::thread_interrupted) {
 		gr::thread::scoped_lock(d_mutex);
 		dout << "PMS: thread interrupted" << std::endl;
 		d_finished = true;
 		if(d_quit) {
 			boost::this_thread::sleep(boost::posix_time::milliseconds(500));
 			message_port_pub( pmt::mp("out"), pmt::PMT_EOF);
 			post(pmt::mp("system"), pmt::cons(pmt::mp("done"), pmt::from_long(1)));
 		}
 	}
 }
 // Generate a random message
 pmt::pmt_t
 random_periodic_msg_source_impl::generate_msg() {
-	uint8_t vec[d_msg_len];
+	std::vector<uint8_t> vec(d_msg_len);
 	for(int i = 0; i < d_msg_len; i++) {
 		vec[i] = d_randbytes();
 	}
-	pmt::pmt_t blob = pmt::make_blob(vec, d_msg_len);
+	pmt::pmt_t blob = pmt::make_blob(vec.data(), d_msg_len);
 	return pmt::cons(pmt::PMT_NIL, blob);
 }
 void
 random_periodic_msg_source_impl::set_nmsg(int nmsg) {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	d_nmsg_total = nmsg;
 }
 int
 random_periodic_msg_source_impl::get_nmsg() {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	return d_nmsg_total;
 }
 void
 random_periodic_msg_source_impl::set_delay(long delay) {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	d_interval = delay;
 }
 long
 random_periodic_msg_source_impl::get_delay() {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	return d_interval;
 }
 void
 random_periodic_msg_source_impl::start_tx() {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	if(is_running()) return;
@@ -83,7 +83,7 @@ rtt_measure_impl::general_work(int noutput, gr_vector_int& ninput_items,
 boost::posix_time::ptime
 rtt_measure_impl::start_time()
 {
-	gr::thread::scoped_lock(d_mutex);
+	gr::thread::scoped_lock d_mutex;
 	return d_start_time;
 }
@@ -181,11 +181,7 @@ wireshark_connector_impl::general_work(int noutput, gr_vector_int& ninput_items,
 	gr_complex *out = (gr_complex*)output_items[0];
 	if(!d_msg_len) {
-#ifdef GR_FOO_NEW_API
+		pmt::pmt_t msg(delete_head_nowait(pmt::mp("in")));
 		pmt::pmt_t msg(delete_head_blocking(pmt::mp("in"), 100));
 #else
 		pmt::pmt_t msg(delete_head_blocking(pmt::mp("in")));
 #endif
 		if(!msg) {
 			return 0;
@@ -1,6 +1,6 @@
 # Copyright 2011 Free Software Foundation, Inc.
 #
-# This file is part of GNU Radio
+# This file is part of gr-foo
 #
 # 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
@@ -31,6 +31,7 @@ endif()
 GR_PYTHON_INSTALL(
    FILES
    __init__.py
    selector.py
    DESTINATION ${GR_PYTHON_DIR}/foo
 )
@@ -41,3 +42,4 @@ include(GrTest)
 set(GR_TEST_TARGET_DEPS gnuradio-foo)
 set(GR_TEST_PYTHON_DIRS ${CMAKE_BINARY_DIR}/swig)
 GR_ADD_TEST(qa_pad_tagged_stream ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/qa_pad_tagged_stream.py)
@@ -19,36 +19,18 @@
 # The presence of this file turns this directory into a Python package
 '''
-This is the GNU Radio CCS module. Place your Python package
+This is the GNU Radio FOO module. Place your Python package
 description here (python/__init__.py).
 '''
 from __future__ import unicode_literals
-# ----------------------------------------------------------------
+# import swig generated symbols into the foo namespace
 # Temporary workaround for ticket:181 (swig+python problem)
 import sys
 _RTLD_GLOBAL = 0
 try:
-    from dl import RTLD_GLOBAL as _RTLD_GLOBAL
+    # this might fail if the module is python-only
-except ImportError:
+    from .foo_swig import *
    try:
 	from DLFCN import RTLD_GLOBAL as _RTLD_GLOBAL
 except ImportError:
    pass
 if _RTLD_GLOBAL != 0:
    _dlopenflags = sys.getdlopenflags()
    sys.setdlopenflags(_dlopenflags|_RTLD_GLOBAL)
 # ----------------------------------------------------------------
 # import swig generated symbols into the foo namespace
 from foo_swig import *
 # import any pure python here
 from .selector import *
 #
 # ----------------------------------------------------------------
 # Tail of workaround
 if _RTLD_GLOBAL != 0:
    sys.setdlopenflags(_dlopenflags)      # Restore original flags
 # ----------------------------------------------------------------
@@ -0,0 +1,41 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 #
 # Copyright 2019 "Cyancali".
 #
 # 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.
 #
 from gnuradio import gr, gr_unittest
 from gnuradio import blocks
 import foo_swig as foo
 class qa_pad_tagged_stream(gr_unittest.TestCase):
    def setUp(self):
        self.tb = gr.top_block()
    def tearDown(self):
        self.tb = None
    def test_001_t(self):
        # set up fg
        self.tb.run()
        # check data
 if __name__ == '__main__':
    gr_unittest.run(qa_pad_tagged_stream)
@@ -0,0 +1,140 @@
 #
 # Copyright 2017 Bastian Bloessl <mail@bastibl.net>
 #
 # 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.
 from gnuradio import gr
 from gnuradio import blocks
 class selector(gr.hier_block2):
    """A hier2 block with N inputs and M outputs, where data is only forwarded through input n to output m."""
    def __init__(self, item_size, num_inputs, num_outputs, input_index, output_index):
        """
        Selector constructor.
        Args:
            item_size: the size of the gr data stream in bytes
            num_inputs: the number of inputs (integer)
            num_outputs: the number of outputs (integer)
            input_index: the index for the source data
            output_index: the index for the destination data
        """
        gr.hier_block2.__init__(
            self, 'selector',
            gr.io_signature(num_inputs, num_inputs, item_size),
            gr.io_signature(num_outputs, num_outputs, item_size),
        )
        #terminator blocks for unused inputs and outputs
        self.input_terminators = [blocks.null_sink(item_size) for i in range(num_inputs)]
        self.output_terminators = [blocks.head(item_size, 0) for i in range(num_outputs)]
        self.copy = blocks.copy(item_size)
        #connections
        for i in range(num_inputs): self.connect((self, i), self.input_terminators[i])
        for i in range(num_outputs): self.connect(blocks.null_source(item_size),
                                                          self.output_terminators[i], (self, i))
        self.item_size = item_size
        self.input_index = input_index
        self.output_index = output_index
        self.num_inputs = num_inputs
        self.num_outputs = num_outputs
        self._connect_current()
    def _indexes_valid(self):
        """
        Are the input and output indexes within range of the number of inputs and outputs?
        Returns:
            true if input index and output index are in range
        """
        return self.input_index in range(self.num_inputs) and self.output_index in range(self.num_outputs)
    def _connect_current(self):
        """If the input and output indexes are valid:
        disconnect the blocks at the input and output index from their terminators,
        and connect them to one another. Then connect the terminators to one another."""
        if self._indexes_valid():
            self.disconnect((self, self.input_index), self.input_terminators[self.input_index])
            self.disconnect(self.output_terminators[self.output_index], (self, self.output_index))
            self.connect((self, self.input_index), self.copy)
            self.connect(self.copy, (self, self.output_index))
            self.connect(self.output_terminators[self.output_index], self.input_terminators[self.input_index])
    def _disconnect_current(self):
        """If the input and output indexes are valid:
        disconnect the blocks at the input and output index from one another,
        and the terminators at the input and output index from one another.
        Reconnect the blocks to the terminators."""
        if self._indexes_valid():
            self.disconnect((self, self.input_index), self.copy)
            self.disconnect(self.copy, (self, self.output_index))
            self.disconnect(self.output_terminators[self.output_index], self.input_terminators[self.input_index])
            self.connect((self, self.input_index), self.input_terminators[self.input_index])
            self.connect(self.output_terminators[self.output_index], (self, self.output_index))
    def set_input_index(self, input_index):
        """
        Change the block to the new input index if the index changed.
        Args:
            input_index: the new input index
        """
        if self.input_index != input_index:
            self.lock()
            self._disconnect_current()
            self.input_index = input_index
            self._connect_current()
            self.unlock()
    def set_output_index(self, output_index):
        """
        Change the block to the new output index if the index changed.
        Args:
            output_index: the new output index
        """
        if self.output_index != output_index:
            self.lock()
            self._disconnect_current()
            self.output_index = output_index
            self._connect_current()
            self.unlock()
 class valve(selector):
    """Wrapper for selector with 1 input and 1 output."""
    def __init__(self, item_size, open):
        """
        Constructor for valve.
        Args:
            item_size: the size of the gr data stream in bytes
            open: true if initial valve state is open
        """
        if open: output_index = -1
        else: output_index = 0
        selector.__init__(self, item_size, 1, 1, 0, output_index)
    def set_open(self, open):
        """
        Callback to set open state.
        Args:
            open: true to set valve state to open
        """
        if open: output_index = -1
        else: output_index = 0
        self.set_output_index(output_index)
@@ -1,6 +1,6 @@
 # Copyright 2011 Free Software Foundation, Inc.
 #
-# This file is part of GNU Radio
+# This file is part of gr-foo
 #
 # 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
@@ -17,11 +17,19 @@
 # the Free Software Foundation, Inc., 51 Franklin Street,
 # Boston, MA 02110-1301, USA.
 ########################################################################
 # Check if there is C++ code at all
 ########################################################################
 if(NOT foo_sources)
    MESSAGE(STATUS "No C++ sources... skipping swig/")
    return()
 endif(NOT foo_sources)
 ########################################################################
 # Include swig generation macros
 ########################################################################
 find_package(SWIG)
-find_package(PythonLibs 2)
+find_package(PythonLibs)
 if(NOT SWIG_FOUND OR NOT PYTHONLIBS_FOUND)
    return()
 endif()
@@ -31,11 +39,11 @@ include(GrPython)
 ########################################################################
 # Setup swig generation
 ########################################################################
-foreach(incdir ${GNURADIO_RUNTIME_INCLUDE_DIRS})
+set(GR_SWIG_INCLUDE_DIRS $<TARGET_PROPERTY:gnuradio::runtime_swig,INTERFACE_INCLUDE_DIRECTORIES>)
-    list(APPEND GR_SWIG_INCLUDE_DIRS ${incdir}/gnuradio/swig)
+set(GR_SWIG_TARGET_DEPS gnuradio::runtime_swig)
 endforeach(incdir)
 set(GR_SWIG_LIBRARIES gnuradio-foo)
 set(GR_SWIG_DOC_FILE ${CMAKE_CURRENT_BINARY_DIR}/foo_swig_doc.i)
 set(GR_SWIG_DOC_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../include)
@@ -1,12 +1,15 @@
 /* -*- c++ -*- */
 #define FOO_API
-%include "gnuradio.i"
+%include "gnuradio.i"           // the common stuff
 //load generated python docstrings
 %include "foo_swig_doc.i"
 %{
 #include "foo/burst_tagger.h"
 #include "foo/channel_model.h"
 #include "foo/packet_dropper.h"
 #include "foo/packet_pad.h"
 #include "foo/packet_pad2.h"
@@ -14,10 +17,12 @@
 #include "foo/random_periodic_msg_source.h"
 #include "foo/rtt_measure.h"
 #include "foo/wireshark_connector.h"
 #include "foo/pad_tagged_stream.h"
 %}
 %include "foo/burst_tagger.h"
 %include "foo/channel_model.h"
 %include "foo/packet_dropper.h"
 %include "foo/packet_pad.h"
 %include "foo/packet_pad2.h"
@@ -27,6 +32,7 @@
 %include "foo/wireshark_connector.h"
 GR_SWIG_BLOCK_MAGIC2(foo, burst_tagger);
 GR_SWIG_BLOCK_MAGIC2(foo, channel_model);
 GR_SWIG_BLOCK_MAGIC2(foo, packet_dropper);
 GR_SWIG_BLOCK_MAGIC2(foo, packet_pad);
 GR_SWIG_BLOCK_MAGIC2(foo, packet_pad2);
@@ -34,3 +40,5 @@ GR_SWIG_BLOCK_MAGIC2(foo, periodic_msg_source);
 GR_SWIG_BLOCK_MAGIC2(foo, random_periodic_msg_source);
 GR_SWIG_BLOCK_MAGIC2(foo, rtt_measure);
 GR_SWIG_BLOCK_MAGIC2(foo, wireshark_connector);
 %include "foo/pad_tagged_stream.h"
 GR_SWIG_BLOCK_MAGIC2(foo, pad_tagged_stream);
@@ -20,6 +20,7 @@
 import sys, time
 from gnuradio import gr, ctrlport
 from subprocess import Popen, PIPE
 class MyApp(object):
    def __init__(self, args):
@@ -63,7 +64,7 @@ class MyApp(object):
        client.setKnobs(knobs)
        # let the flow graph run for some time
-        time.sleep(30)
+        time.sleep(60)
        ## get work time for all blocks
        kl = map(lambda x: "%s::total work time" % x, blocks)
@@ -75,4 +76,7 @@ class MyApp(object):
        print(",".join(map(lambda x: str(x[1]), sorted(work_times.items()))))
        p = Popen("uptime", stdout=PIPE, close_fds=True, shell=True)
        print(p.stdout.read())
 MyApp(sys.argv)
Author	SHA1	Message	Date
Gisle Vanem	7557bf48f3	Fix use of VLA	2021-08-05 16:20:09 +02:00
Bastian Bloessl	7b96dcb386	udpate readme and manifest	2021-07-20 12:26:30 +02:00
Bastian Bloessl	e17edbd4ad	boost 1.73 fix	2020-08-12 11:46:12 +02:00
Bastian Bloessl	13fac53de8	GR API was messed up through merging dev branch	2019-12-17 11:13:10 +01:00
aewag	65421a6755	lib/pad_tagged_stream_impl: Added element size to memcpy/memset call as the tagged stream is without it not completely copied	2019-10-21 10:59:12 +02:00
Cyancali	84b4e95007	lib/pad_tagged_stream_impl.cc: Apply min call to avoid copying too much input	2019-10-15 10:25:50 +02:00
Cyancali	2ab199f87a	lib/pad_tagged_stream_impl.cc: Added a warning if tagged stream is longer than buffer size	2019-10-15 10:25:50 +02:00
Cyancali	82b479c3e0	grc/foo_pad_tagged_stream.block: Added default value for buffer size to match default Pluto buffer size	2019-10-15 10:25:50 +02:00
Cyancali	e980b54f19	README.md: added documentation about the Pad Tagged Stream block	2019-10-15 10:25:50 +02:00
Cyancali	c81c8dfa19	lib/pad_tagged_stream_impl.cc: Added minimum output buffer size to not need to set it in the advanced tab	2019-10-15 10:25:50 +02:00
Cyancali	e3ada6d33e	Added new block: Pad Tagged Stream	2019-10-15 10:25:50 +02:00
Bastian Bloessl	e618e70b12	cmake: adapt versioning to gr 3.8	2019-08-26 13:20:54 +02:00
Bastian Bloessl	d26261fa13	readme: update	2019-06-06 07:21:01 +02:00
Bastian Bloessl	fe1607547a	readme: explain new development model	2019-06-06 06:39:36 +02:00
Bastian Bloessl	3f5718dec9	more porting	2019-06-06 06:27:09 +02:00
Bastian Bloessl	8998b5688f	enable grc variable	2019-03-13 20:53:58 +00:00
Bastian Bloessl	50c2310644	more updates	2019-03-13 20:51:40 +00:00
Bastian Bloessl	8360cae375	more updates	2019-03-08 12:38:20 +00:00
Bastian Bloessl	284a0b1fa5	cmake updates	2019-02-21 18:36:24 +00:00
Bastian Bloessl	d58e74decb	no docs	2019-02-21 18:35:51 +00:00
Bastian Bloessl	404cda65ca	start applying changes from modtool	2019-02-21 17:57:34 +00:00
Bastian Bloessl	450a37bb5e	del docs folder	2019-02-21 07:42:44 +00:00
Bastian Bloessl	9d02c2df6d	pyton: explicit relative imports	2018-10-04 14:04:55 +02:00
Bastian Bloessl	8e1dcdf929	gnuradio does not export python variable	2018-10-04 14:04:55 +02:00
Bastian Bloessl	dd16c69162	prepare for python3	2018-10-04 14:04:55 +02:00
Bastian Bloessl	b4e47b7c7b	del local cmake modules	2018-10-04 14:04:55 +02:00
Bastian Bloessl	42f06ef628	delete cpp unit	2018-10-04 14:04:55 +02:00
Bastian Bloessl	de8b850895	xml -> yaml	2018-10-04 14:04:55 +02:00
Bastian Bloessl	24914b9391	update to GR 3.8 API	2018-10-04 14:02:22 +02:00
Bastian Bloessl	0236c7d70c	Merge branch 'master' into next	2018-06-21 10:05:20 +01:00
Bastian Bloessl	dd69381a13	Merge branch 'master' into next	2018-03-31 11:58:11 +01:00
Bastian Bloessl	092e16f9de	Merge pull request #9 from jkbecker/fixreadme Markdown README + typo	2018-03-31 12:56:31 +02:00
Johannes Becker	35f41a33b6	converted to .md and fixes	2018-03-27 16:33:41 -04:00
Bastian Bloessl	5bbe1f87ae	channel: GNU Radio renamed resampler	2017-10-10 12:02:05 +01:00
Bastian Bloessl	2ba97c8d6d	perf-monitor: print load avg	2017-04-20 16:46:46 +02:00
Bastian Bloessl	5ff9e43532	Merge branch 'master' into next # Conflicts: # CMakeLists.txt	2017-03-17 14:53:00 +01:00
Bastian Bloessl	555a0895a5	add channel model with better noise source	2017-02-11 12:10:03 +01:00
Bastian Bloessl	fb3ea60bc4	selector, valve: remove deprecated warning	2017-02-11 11:43:53 +01:00
Bastian Bloessl	119d00d17c	resurrect selector block	2017-02-11 08:59:50 +01:00
Bastian Bloessl	eb6c6509ee	Merge branch 'master' into next	2016-12-16 10:08:36 +01:00
Bastian Bloessl	b5f59f0a2a	Merge branch 'master' into next	2016-12-04 16:29:25 +01:00
Bastian Bloessl	49fa80691f	Merge branch 'master' into next	2016-08-07 13:30:54 +02:00
Bastian Bloessl	a3c4a21ac1	Merge branch 'master' into development	2016-06-22 12:45:46 +02:00
Bastian Bloessl	02ee21184a	message sources: del try/catch block forgot why I added it in the first place	2016-05-31 13:05:41 +02:00
Bastian Bloessl	6f86f92ff4	cmake: delete API compile switch	2016-05-02 12:54:53 +02:00
Bastian Bloessl	c171d3501a	message source: don't send eofs	2016-05-01 19:29:20 +02:00
Bastian Bloessl	7bf5d07e94	wireshark: don't block waiting for messages	2016-05-01 19:29:20 +02:00
Bastian Bloessl	d32db7df76	message source: adapt to new api	2016-05-01 19:29:20 +02:00