Added gr-hamnet70 OOT module
This module will contain custom blocks written for GNU Radio. Up to now, it contains one block for rotating the phase for the amount given in a specific tag on the stream.
This commit is contained in:
parent
baf0911f14
commit
0bf421c603
1
gr-hamnet70/.gitignore
vendored
Normal file
1
gr-hamnet70/.gitignore
vendored
Normal file
|
|
@ -0,0 +1 @@
|
||||||
|
build/
|
||||||
216
gr-hamnet70/CMakeLists.txt
Normal file
216
gr-hamnet70/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,216 @@
|
||||||
|
# Copyright 2011,2012,2014,2016 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
# Boston, MA 02110-1301, USA.
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Project setup
|
||||||
|
########################################################################
|
||||||
|
cmake_minimum_required(VERSION 2.6)
|
||||||
|
project(gr-hamnet70 CXX C)
|
||||||
|
enable_testing()
|
||||||
|
|
||||||
|
#install to PyBOMBS target prefix if defined
|
||||||
|
if(DEFINED ENV{PYBOMBS_PREFIX})
|
||||||
|
#IGNORE 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)
|
||||||
|
#IGNORE set(CMAKE_BUILD_TYPE "Release")
|
||||||
|
message(STATUS "Build type not specified: defaulting to release.")
|
||||||
|
endif(NOT CMAKE_BUILD_TYPE)
|
||||||
|
#IGNORE set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")
|
||||||
|
|
||||||
|
#make sure our local CMake Modules path comes first
|
||||||
|
list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_SOURCE_DIR}/cmake/Modules)
|
||||||
|
|
||||||
|
# Set the version information here
|
||||||
|
set(VERSION_INFO_MAJOR_VERSION 1)
|
||||||
|
set(VERSION_INFO_API_COMPAT 0)
|
||||||
|
set(VERSION_INFO_MINOR_VERSION 0)
|
||||||
|
set(VERSION_INFO_MAINT_VERSION git)
|
||||||
|
|
||||||
|
# Set cmake policies.
|
||||||
|
# This will suppress developer warnings during the cmake process that can occur
|
||||||
|
# if a newer cmake version than the minimum is used.
|
||||||
|
|
||||||
|
if(POLICY CMP0026)
|
||||||
|
cmake_policy(SET CMP0026 OLD)
|
||||||
|
endif()
|
||||||
|
if(POLICY CMP0043)
|
||||||
|
cmake_policy(SET CMP0043 OLD)
|
||||||
|
endif()
|
||||||
|
if(POLICY CMP0045)
|
||||||
|
cmake_policy(SET CMP0045 OLD)
|
||||||
|
endif()
|
||||||
|
if(POLICY CMP0046)
|
||||||
|
cmake_policy(SET CMP0046 OLD)
|
||||||
|
endif()
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Compiler specific setup
|
||||||
|
########################################################################
|
||||||
|
if(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
|
||||||
|
#http://gcc.gnu.org/wiki/Visibility
|
||||||
|
add_definitions(-fvisibility=hidden)
|
||||||
|
endif()
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Find boost
|
||||||
|
########################################################################
|
||||||
|
if(UNIX AND EXISTS "/usr/lib64")
|
||||||
|
list(APPEND BOOST_LIBRARYDIR "/usr/lib64") #fedora 64-bit fix
|
||||||
|
endif(UNIX AND EXISTS "/usr/lib64")
|
||||||
|
set(Boost_ADDITIONAL_VERSIONS
|
||||||
|
"1.35.0" "1.35" "1.36.0" "1.36" "1.37.0" "1.37" "1.38.0" "1.38" "1.39.0" "1.39"
|
||||||
|
"1.40.0" "1.40" "1.41.0" "1.41" "1.42.0" "1.42" "1.43.0" "1.43" "1.44.0" "1.44"
|
||||||
|
"1.45.0" "1.45" "1.46.0" "1.46" "1.47.0" "1.47" "1.48.0" "1.48" "1.49.0" "1.49"
|
||||||
|
"1.50.0" "1.50" "1.51.0" "1.51" "1.52.0" "1.52" "1.53.0" "1.53" "1.54.0" "1.54"
|
||||||
|
"1.55.0" "1.55" "1.56.0" "1.56" "1.57.0" "1.57" "1.58.0" "1.58" "1.59.0" "1.59"
|
||||||
|
"1.60.0" "1.60" "1.61.0" "1.61" "1.62.0" "1.62" "1.63.0" "1.63" "1.64.0" "1.64"
|
||||||
|
"1.65.0" "1.65" "1.66.0" "1.66" "1.67.0" "1.67" "1.68.0" "1.68" "1.69.0" "1.69"
|
||||||
|
)
|
||||||
|
find_package(Boost "1.35" COMPONENTS filesystem system)
|
||||||
|
|
||||||
|
if(NOT Boost_FOUND)
|
||||||
|
message(FATAL_ERROR "Boost required to compile hamnet70")
|
||||||
|
endif()
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Install directories
|
||||||
|
########################################################################
|
||||||
|
include(GrPlatform) #define LIB_SUFFIX
|
||||||
|
set(GR_RUNTIME_DIR bin)
|
||||||
|
set(GR_LIBRARY_DIR lib${LIB_SUFFIX})
|
||||||
|
set(GR_INCLUDE_DIR include/hamnet70)
|
||||||
|
set(GR_DATA_DIR share)
|
||||||
|
set(GR_PKG_DATA_DIR ${GR_DATA_DIR}/${CMAKE_PROJECT_NAME})
|
||||||
|
set(GR_DOC_DIR ${GR_DATA_DIR}/doc)
|
||||||
|
set(GR_PKG_DOC_DIR ${GR_DOC_DIR}/${CMAKE_PROJECT_NAME})
|
||||||
|
set(GR_CONF_DIR etc)
|
||||||
|
set(GR_PKG_CONF_DIR ${GR_CONF_DIR}/${CMAKE_PROJECT_NAME}/conf.d)
|
||||||
|
set(GR_LIBEXEC_DIR libexec)
|
||||||
|
set(GR_PKG_LIBEXEC_DIR ${GR_LIBEXEC_DIR}/${CMAKE_PROJECT_NAME})
|
||||||
|
set(GRC_BLOCKS_DIR ${GR_PKG_DATA_DIR}/grc/blocks)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# On Apple only, set install name and use rpath correctly, if not already set
|
||||||
|
########################################################################
|
||||||
|
if(APPLE)
|
||||||
|
if(NOT CMAKE_INSTALL_NAME_DIR)
|
||||||
|
set(CMAKE_INSTALL_NAME_DIR
|
||||||
|
${CMAKE_INSTALL_PREFIX}/${GR_LIBRARY_DIR} CACHE
|
||||||
|
PATH "Library Install Name Destination Directory" FORCE)
|
||||||
|
endif(NOT CMAKE_INSTALL_NAME_DIR)
|
||||||
|
if(NOT CMAKE_INSTALL_RPATH)
|
||||||
|
set(CMAKE_INSTALL_RPATH
|
||||||
|
${CMAKE_INSTALL_PREFIX}/${GR_LIBRARY_DIR} CACHE
|
||||||
|
PATH "Library Install RPath" FORCE)
|
||||||
|
endif(NOT CMAKE_INSTALL_RPATH)
|
||||||
|
if(NOT CMAKE_BUILD_WITH_INSTALL_RPATH)
|
||||||
|
set(CMAKE_BUILD_WITH_INSTALL_RPATH ON CACHE
|
||||||
|
BOOL "Do Build Using Library Install RPath" FORCE)
|
||||||
|
endif(NOT CMAKE_BUILD_WITH_INSTALL_RPATH)
|
||||||
|
endif(APPLE)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Find gnuradio build dependencies
|
||||||
|
########################################################################
|
||||||
|
find_package(CppUnit)
|
||||||
|
find_package(Doxygen)
|
||||||
|
|
||||||
|
# Search for GNU Radio and its components and versions. Add any
|
||||||
|
# components required to the list of GR_REQUIRED_COMPONENTS (in all
|
||||||
|
# caps such as FILTER or FFT) and change the version to the minimum
|
||||||
|
# API compatible version required.
|
||||||
|
set(GR_REQUIRED_COMPONENTS RUNTIME)
|
||||||
|
find_package(Gnuradio "3.7.2" REQUIRED)
|
||||||
|
list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_SOURCE_DIR}/cmake/Modules)
|
||||||
|
include(GrVersion)
|
||||||
|
|
||||||
|
if(NOT CPPUNIT_FOUND)
|
||||||
|
message(FATAL_ERROR "CppUnit required to compile hamnet70")
|
||||||
|
endif()
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Setup doxygen option
|
||||||
|
########################################################################
|
||||||
|
if(DOXYGEN_FOUND)
|
||||||
|
option(ENABLE_DOXYGEN "Build docs using Doxygen" ON)
|
||||||
|
else(DOXYGEN_FOUND)
|
||||||
|
option(ENABLE_DOXYGEN "Build docs using Doxygen" OFF)
|
||||||
|
endif(DOXYGEN_FOUND)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Setup the include and linker paths
|
||||||
|
########################################################################
|
||||||
|
include_directories(
|
||||||
|
${CMAKE_SOURCE_DIR}/lib
|
||||||
|
${CMAKE_SOURCE_DIR}/include
|
||||||
|
${CMAKE_BINARY_DIR}/lib
|
||||||
|
${CMAKE_BINARY_DIR}/include
|
||||||
|
${Boost_INCLUDE_DIRS}
|
||||||
|
${CPPUNIT_INCLUDE_DIRS}
|
||||||
|
${GNURADIO_ALL_INCLUDE_DIRS}
|
||||||
|
)
|
||||||
|
|
||||||
|
link_directories(
|
||||||
|
${Boost_LIBRARY_DIRS}
|
||||||
|
${CPPUNIT_LIBRARY_DIRS}
|
||||||
|
${GNURADIO_RUNTIME_LIBRARY_DIRS}
|
||||||
|
)
|
||||||
|
|
||||||
|
# Set component parameters
|
||||||
|
set(GR_HAMNET70_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE INTERNAL "" FORCE)
|
||||||
|
set(GR_HAMNET70_SWIG_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/swig CACHE INTERNAL "" FORCE)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Create uninstall target
|
||||||
|
########################################################################
|
||||||
|
configure_file(
|
||||||
|
${CMAKE_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
|
||||||
|
@ONLY)
|
||||||
|
|
||||||
|
add_custom_target(uninstall
|
||||||
|
${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
|
||||||
|
)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Add subdirectories
|
||||||
|
########################################################################
|
||||||
|
add_subdirectory(include/hamnet70)
|
||||||
|
add_subdirectory(lib)
|
||||||
|
add_subdirectory(swig)
|
||||||
|
add_subdirectory(python)
|
||||||
|
add_subdirectory(grc)
|
||||||
|
add_subdirectory(apps)
|
||||||
|
add_subdirectory(docs)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Install cmake search helper for this library
|
||||||
|
########################################################################
|
||||||
|
if(NOT CMAKE_MODULES_DIR)
|
||||||
|
set(CMAKE_MODULES_DIR lib${LIB_SUFFIX}/cmake)
|
||||||
|
endif(NOT CMAKE_MODULES_DIR)
|
||||||
|
|
||||||
|
install(FILES cmake/Modules/hamnet70Config.cmake
|
||||||
|
DESTINATION ${CMAKE_MODULES_DIR}/hamnet70
|
||||||
|
)
|
||||||
16
gr-hamnet70/MANIFEST.md
Normal file
16
gr-hamnet70/MANIFEST.md
Normal file
|
|
@ -0,0 +1,16 @@
|
||||||
|
title: The HAMNET70 OOT Module
|
||||||
|
brief: Short description of gr-hamnet70
|
||||||
|
tags: # Tags are arbitrary, but look at CGRAN what other authors are using
|
||||||
|
- sdr
|
||||||
|
author:
|
||||||
|
- Author Name <authors@email.address>
|
||||||
|
copyright_owner:
|
||||||
|
- Copyright Owner 1
|
||||||
|
license:
|
||||||
|
#repo: # Put the URL of the repository here, or leave blank for default
|
||||||
|
#website: <module_website> # If you have a separate project website, put it here
|
||||||
|
#icon: <icon_url> # Put a URL to a square image here that will be used as an icon on CGRAN
|
||||||
|
---
|
||||||
|
A longer, multi-line description of gr-hamnet70.
|
||||||
|
You may use some *basic* Markdown here.
|
||||||
|
If left empty, it will try to find a README file instead.
|
||||||
26
gr-hamnet70/apps/CMakeLists.txt
Normal file
26
gr-hamnet70/apps/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,26 @@
|
||||||
|
# Copyright 2011 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
# Boston, MA 02110-1301, USA.
|
||||||
|
|
||||||
|
include(GrPython)
|
||||||
|
|
||||||
|
GR_PYTHON_INSTALL(
|
||||||
|
PROGRAMS
|
||||||
|
DESTINATION bin
|
||||||
|
)
|
||||||
138
gr-hamnet70/cmake/Modules/CMakeParseArgumentsCopy.cmake
Normal file
138
gr-hamnet70/cmake/Modules/CMakeParseArgumentsCopy.cmake
Normal file
|
|
@ -0,0 +1,138 @@
|
||||||
|
# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords> <multi_value_keywords> args...)
|
||||||
|
#
|
||||||
|
# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions for
|
||||||
|
# parsing the arguments given to that macro or function.
|
||||||
|
# It processes the arguments and defines a set of variables which hold the
|
||||||
|
# values of the respective options.
|
||||||
|
#
|
||||||
|
# The <options> argument contains all options for the respective macro,
|
||||||
|
# i.e. keywords which can be used when calling the macro without any value
|
||||||
|
# following, like e.g. the OPTIONAL keyword of the install() command.
|
||||||
|
#
|
||||||
|
# The <one_value_keywords> argument contains all keywords for this macro
|
||||||
|
# which are followed by one value, like e.g. DESTINATION keyword of the
|
||||||
|
# install() command.
|
||||||
|
#
|
||||||
|
# The <multi_value_keywords> argument contains all keywords for this macro
|
||||||
|
# which can be followed by more than one value, like e.g. the TARGETS or
|
||||||
|
# FILES keywords of the install() command.
|
||||||
|
#
|
||||||
|
# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the
|
||||||
|
# keywords listed in <options>, <one_value_keywords> and
|
||||||
|
# <multi_value_keywords> a variable composed of the given <prefix>
|
||||||
|
# followed by "_" and the name of the respective keyword.
|
||||||
|
# These variables will then hold the respective value from the argument list.
|
||||||
|
# For the <options> keywords this will be TRUE or FALSE.
|
||||||
|
#
|
||||||
|
# All remaining arguments are collected in a variable
|
||||||
|
# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see whether
|
||||||
|
# your macro was called with unrecognized parameters.
|
||||||
|
#
|
||||||
|
# As an example here a my_install() macro, which takes similar arguments as the
|
||||||
|
# real install() command:
|
||||||
|
#
|
||||||
|
# function(MY_INSTALL)
|
||||||
|
# set(options OPTIONAL FAST)
|
||||||
|
# set(oneValueArgs DESTINATION RENAME)
|
||||||
|
# set(multiValueArgs TARGETS CONFIGURATIONS)
|
||||||
|
# cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )
|
||||||
|
# ...
|
||||||
|
#
|
||||||
|
# Assume my_install() has been called like this:
|
||||||
|
# my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)
|
||||||
|
#
|
||||||
|
# After the cmake_parse_arguments() call the macro will have set the following
|
||||||
|
# variables:
|
||||||
|
# MY_INSTALL_OPTIONAL = TRUE
|
||||||
|
# MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()
|
||||||
|
# MY_INSTALL_DESTINATION = "bin"
|
||||||
|
# MY_INSTALL_RENAME = "" (was not used)
|
||||||
|
# MY_INSTALL_TARGETS = "foo;bar"
|
||||||
|
# MY_INSTALL_CONFIGURATIONS = "" (was not used)
|
||||||
|
# MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"
|
||||||
|
#
|
||||||
|
# You can the continue and process these variables.
|
||||||
|
#
|
||||||
|
# Keywords terminate lists of values, e.g. if directly after a one_value_keyword
|
||||||
|
# another recognized keyword follows, this is interpreted as the beginning of
|
||||||
|
# the new option.
|
||||||
|
# E.g. my_install(TARGETS foo DESTINATION OPTIONAL) would result in
|
||||||
|
# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION would
|
||||||
|
# be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefore.
|
||||||
|
|
||||||
|
#=============================================================================
|
||||||
|
# Copyright 2010 Alexander Neundorf <neundorf@kde.org>
|
||||||
|
#
|
||||||
|
# Distributed under the OSI-approved BSD License (the "License");
|
||||||
|
# see accompanying file Copyright.txt for details.
|
||||||
|
#
|
||||||
|
# This software is distributed WITHOUT ANY WARRANTY; without even the
|
||||||
|
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||||
|
# See the License for more information.
|
||||||
|
#=============================================================================
|
||||||
|
# (To distribute this file outside of CMake, substitute the full
|
||||||
|
# License text for the above reference.)
|
||||||
|
|
||||||
|
|
||||||
|
if(__CMAKE_PARSE_ARGUMENTS_INCLUDED)
|
||||||
|
return()
|
||||||
|
endif()
|
||||||
|
set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE)
|
||||||
|
|
||||||
|
|
||||||
|
function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames)
|
||||||
|
# first set all result variables to empty/FALSE
|
||||||
|
foreach(arg_name ${_singleArgNames} ${_multiArgNames})
|
||||||
|
set(${prefix}_${arg_name})
|
||||||
|
endforeach(arg_name)
|
||||||
|
|
||||||
|
foreach(option ${_optionNames})
|
||||||
|
set(${prefix}_${option} FALSE)
|
||||||
|
endforeach(option)
|
||||||
|
|
||||||
|
set(${prefix}_UNPARSED_ARGUMENTS)
|
||||||
|
|
||||||
|
set(insideValues FALSE)
|
||||||
|
set(currentArgName)
|
||||||
|
|
||||||
|
# now iterate over all arguments and fill the result variables
|
||||||
|
foreach(currentArg ${ARGN})
|
||||||
|
list(FIND _optionNames "${currentArg}" optionIndex) # ... then this marks the end of the arguments belonging to this keyword
|
||||||
|
list(FIND _singleArgNames "${currentArg}" singleArgIndex) # ... then this marks the end of the arguments belonging to this keyword
|
||||||
|
list(FIND _multiArgNames "${currentArg}" multiArgIndex) # ... then this marks the end of the arguments belonging to this keyword
|
||||||
|
|
||||||
|
if(${optionIndex} EQUAL -1 AND ${singleArgIndex} EQUAL -1 AND ${multiArgIndex} EQUAL -1)
|
||||||
|
if(insideValues)
|
||||||
|
if("${insideValues}" STREQUAL "SINGLE")
|
||||||
|
set(${prefix}_${currentArgName} ${currentArg})
|
||||||
|
set(insideValues FALSE)
|
||||||
|
elseif("${insideValues}" STREQUAL "MULTI")
|
||||||
|
list(APPEND ${prefix}_${currentArgName} ${currentArg})
|
||||||
|
endif()
|
||||||
|
else(insideValues)
|
||||||
|
list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg})
|
||||||
|
endif(insideValues)
|
||||||
|
else()
|
||||||
|
if(NOT ${optionIndex} EQUAL -1)
|
||||||
|
set(${prefix}_${currentArg} TRUE)
|
||||||
|
set(insideValues FALSE)
|
||||||
|
elseif(NOT ${singleArgIndex} EQUAL -1)
|
||||||
|
set(currentArgName ${currentArg})
|
||||||
|
set(${prefix}_${currentArgName})
|
||||||
|
set(insideValues "SINGLE")
|
||||||
|
elseif(NOT ${multiArgIndex} EQUAL -1)
|
||||||
|
set(currentArgName ${currentArg})
|
||||||
|
set(${prefix}_${currentArgName})
|
||||||
|
set(insideValues "MULTI")
|
||||||
|
endif()
|
||||||
|
endif()
|
||||||
|
|
||||||
|
endforeach(currentArg)
|
||||||
|
|
||||||
|
# propagate the result variables to the caller:
|
||||||
|
foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames})
|
||||||
|
set(${prefix}_${arg_name} ${${prefix}_${arg_name}} PARENT_SCOPE)
|
||||||
|
endforeach(arg_name)
|
||||||
|
set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE)
|
||||||
|
|
||||||
|
endfunction(CMAKE_PARSE_ARGUMENTS _options _singleArgs _multiArgs)
|
||||||
39
gr-hamnet70/cmake/Modules/FindCppUnit.cmake
Normal file
39
gr-hamnet70/cmake/Modules/FindCppUnit.cmake
Normal file
|
|
@ -0,0 +1,39 @@
|
||||||
|
# http://www.cmake.org/pipermail/cmake/2006-October/011446.html
|
||||||
|
# Modified to use pkg config and use standard var names
|
||||||
|
|
||||||
|
#
|
||||||
|
# Find the CppUnit includes and library
|
||||||
|
#
|
||||||
|
# This module defines
|
||||||
|
# CPPUNIT_INCLUDE_DIR, where to find tiff.h, etc.
|
||||||
|
# CPPUNIT_LIBRARIES, the libraries to link against to use CppUnit.
|
||||||
|
# CPPUNIT_FOUND, If false, do not try to use CppUnit.
|
||||||
|
|
||||||
|
INCLUDE(FindPkgConfig)
|
||||||
|
PKG_CHECK_MODULES(PC_CPPUNIT "cppunit")
|
||||||
|
|
||||||
|
FIND_PATH(CPPUNIT_INCLUDE_DIRS
|
||||||
|
NAMES cppunit/TestCase.h
|
||||||
|
HINTS ${PC_CPPUNIT_INCLUDE_DIR}
|
||||||
|
${CMAKE_INSTALL_PREFIX}/include
|
||||||
|
PATHS
|
||||||
|
/usr/local/include
|
||||||
|
/usr/include
|
||||||
|
)
|
||||||
|
|
||||||
|
FIND_LIBRARY(CPPUNIT_LIBRARIES
|
||||||
|
NAMES cppunit
|
||||||
|
HINTS ${PC_CPPUNIT_LIBDIR}
|
||||||
|
${CMAKE_INSTALL_PREFIX}/lib
|
||||||
|
${CMAKE_INSTALL_PREFIX}/lib64
|
||||||
|
PATHS
|
||||||
|
${CPPUNIT_INCLUDE_DIRS}/../lib
|
||||||
|
/usr/local/lib
|
||||||
|
/usr/lib
|
||||||
|
)
|
||||||
|
|
||||||
|
LIST(APPEND CPPUNIT_LIBRARIES ${CMAKE_DL_LIBS})
|
||||||
|
|
||||||
|
INCLUDE(FindPackageHandleStandardArgs)
|
||||||
|
FIND_PACKAGE_HANDLE_STANDARD_ARGS(CPPUNIT DEFAULT_MSG CPPUNIT_LIBRARIES CPPUNIT_INCLUDE_DIRS)
|
||||||
|
MARK_AS_ADVANCED(CPPUNIT_LIBRARIES CPPUNIT_INCLUDE_DIRS)
|
||||||
36
gr-hamnet70/cmake/Modules/FindGnuradioRuntime.cmake
Normal file
36
gr-hamnet70/cmake/Modules/FindGnuradioRuntime.cmake
Normal file
|
|
@ -0,0 +1,36 @@
|
||||||
|
INCLUDE(FindPkgConfig)
|
||||||
|
PKG_CHECK_MODULES(PC_GNURADIO_RUNTIME gnuradio-runtime)
|
||||||
|
|
||||||
|
if(PC_GNURADIO_RUNTIME_FOUND)
|
||||||
|
# look for include files
|
||||||
|
FIND_PATH(
|
||||||
|
GNURADIO_RUNTIME_INCLUDE_DIRS
|
||||||
|
NAMES gnuradio/top_block.h
|
||||||
|
HINTS $ENV{GNURADIO_RUNTIME_DIR}/include
|
||||||
|
${PC_GNURADIO_RUNTIME_INCLUDE_DIRS}
|
||||||
|
${CMAKE_INSTALL_PREFIX}/include
|
||||||
|
PATHS /usr/local/include
|
||||||
|
/usr/include
|
||||||
|
)
|
||||||
|
|
||||||
|
# look for libs
|
||||||
|
FIND_LIBRARY(
|
||||||
|
GNURADIO_RUNTIME_LIBRARIES
|
||||||
|
NAMES gnuradio-runtime
|
||||||
|
HINTS $ENV{GNURADIO_RUNTIME_DIR}/lib
|
||||||
|
${PC_GNURADIO_RUNTIME_LIBDIR}
|
||||||
|
${CMAKE_INSTALL_PREFIX}/lib/
|
||||||
|
${CMAKE_INSTALL_PREFIX}/lib64/
|
||||||
|
PATHS /usr/local/lib
|
||||||
|
/usr/local/lib64
|
||||||
|
/usr/lib
|
||||||
|
/usr/lib64
|
||||||
|
)
|
||||||
|
|
||||||
|
set(GNURADIO_RUNTIME_FOUND ${PC_GNURADIO_RUNTIME_FOUND})
|
||||||
|
endif(PC_GNURADIO_RUNTIME_FOUND)
|
||||||
|
|
||||||
|
INCLUDE(FindPackageHandleStandardArgs)
|
||||||
|
# do not check GNURADIO_RUNTIME_INCLUDE_DIRS, is not set when default include path us used.
|
||||||
|
FIND_PACKAGE_HANDLE_STANDARD_ARGS(GNURADIO_RUNTIME DEFAULT_MSG GNURADIO_RUNTIME_LIBRARIES)
|
||||||
|
MARK_AS_ADVANCED(GNURADIO_RUNTIME_LIBRARIES GNURADIO_RUNTIME_INCLUDE_DIRS)
|
||||||
529
gr-hamnet70/cmake/Modules/GrMiscUtils.cmake
Normal file
529
gr-hamnet70/cmake/Modules/GrMiscUtils.cmake
Normal file
|
|
@ -0,0 +1,529 @@
|
||||||
|
# Copyright 2010-2011,2014 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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 can't 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) #can't call command when cross
|
||||||
|
else()
|
||||||
|
set(${var} "DEPENDS;${name};COMMAND;${name}" PARENT_SCOPE)
|
||||||
|
endif()
|
||||||
|
endfunction(GR_GEN_TARGET_DEPS)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Control use of gr_logger
|
||||||
|
# Usage:
|
||||||
|
# GR_LOGGING()
|
||||||
|
#
|
||||||
|
# Will set ENABLE_GR_LOG to 1 by default.
|
||||||
|
# Can manually set with -DENABLE_GR_LOG=0|1
|
||||||
|
########################################################################
|
||||||
|
function(GR_LOGGING)
|
||||||
|
find_package(Log4cpp)
|
||||||
|
|
||||||
|
OPTION(ENABLE_GR_LOG "Use gr_logger" ON)
|
||||||
|
if(ENABLE_GR_LOG)
|
||||||
|
# If gr_logger is enabled, make it usable
|
||||||
|
add_definitions( -DENABLE_GR_LOG )
|
||||||
|
|
||||||
|
# also test LOG4CPP; if we have it, use this version of the logger
|
||||||
|
# otherwise, default to the stdout/stderr model.
|
||||||
|
if(LOG4CPP_FOUND)
|
||||||
|
SET(HAVE_LOG4CPP True CACHE INTERNAL "" FORCE)
|
||||||
|
add_definitions( -DHAVE_LOG4CPP )
|
||||||
|
else(not LOG4CPP_FOUND)
|
||||||
|
SET(HAVE_LOG4CPP False CACHE INTERNAL "" FORCE)
|
||||||
|
SET(LOG4CPP_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
|
||||||
|
SET(LOG4CPP_LIBRARY_DIRS "" CACHE INTERNAL "" FORCE)
|
||||||
|
SET(LOG4CPP_LIBRARIES "" CACHE INTERNAL "" FORCE)
|
||||||
|
endif(LOG4CPP_FOUND)
|
||||||
|
|
||||||
|
SET(ENABLE_GR_LOG ${ENABLE_GR_LOG} CACHE INTERNAL "" FORCE)
|
||||||
|
|
||||||
|
else(ENABLE_GR_LOG)
|
||||||
|
SET(HAVE_LOG4CPP False CACHE INTERNAL "" FORCE)
|
||||||
|
SET(LOG4CPP_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
|
||||||
|
SET(LOG4CPP_LIBRARY_DIRS "" CACHE INTERNAL "" FORCE)
|
||||||
|
SET(LOG4CPP_LIBRARIES "" CACHE INTERNAL "" FORCE)
|
||||||
|
endif(ENABLE_GR_LOG)
|
||||||
|
|
||||||
|
message(STATUS "ENABLE_GR_LOG set to ${ENABLE_GR_LOG}.")
|
||||||
|
message(STATUS "HAVE_LOG4CPP set to ${HAVE_LOG4CPP}.")
|
||||||
|
message(STATUS "LOG4CPP_LIBRARIES set to ${LOG4CPP_LIBRARIES}.")
|
||||||
|
|
||||||
|
endfunction(GR_LOGGING)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Run GRCC to compile .grc files into .py files.
|
||||||
|
#
|
||||||
|
# Usage: GRCC(filename, directory)
|
||||||
|
# - filenames: List of file name of .grc file
|
||||||
|
# - directory: directory of built .py file - usually in
|
||||||
|
# ${CMAKE_CURRENT_BINARY_DIR}
|
||||||
|
# - Sets PYFILES: output converted GRC file names to Python files.
|
||||||
|
########################################################################
|
||||||
|
function(GRCC)
|
||||||
|
# Extract directory from list of args, remove it for the list of filenames.
|
||||||
|
list(GET ARGV -1 directory)
|
||||||
|
list(REMOVE_AT ARGV -1)
|
||||||
|
set(filenames ${ARGV})
|
||||||
|
file(MAKE_DIRECTORY ${directory})
|
||||||
|
|
||||||
|
SET(GRCC_COMMAND ${CMAKE_SOURCE_DIR}/gr-utils/python/grcc)
|
||||||
|
|
||||||
|
# GRCC uses some stuff in grc and gnuradio-runtime, so we force
|
||||||
|
# the known paths here
|
||||||
|
list(APPEND PYTHONPATHS
|
||||||
|
${CMAKE_SOURCE_DIR}
|
||||||
|
${CMAKE_SOURCE_DIR}/gnuradio-runtime/python
|
||||||
|
${CMAKE_SOURCE_DIR}/gnuradio-runtime/lib/swig
|
||||||
|
${CMAKE_BINARY_DIR}/gnuradio-runtime/lib/swig
|
||||||
|
)
|
||||||
|
|
||||||
|
if(WIN32)
|
||||||
|
#SWIG generates the python library files into a subdirectory.
|
||||||
|
#Therefore, we must append this subdirectory into PYTHONPATH.
|
||||||
|
#Only do this for the python directories matching the following:
|
||||||
|
foreach(pydir ${PYTHONPATHS})
|
||||||
|
get_filename_component(name ${pydir} NAME)
|
||||||
|
if(name MATCHES "^(swig|lib|src)$")
|
||||||
|
list(APPEND PYTHONPATHS ${pydir}/${CMAKE_BUILD_TYPE})
|
||||||
|
endif()
|
||||||
|
endforeach(pydir)
|
||||||
|
endif(WIN32)
|
||||||
|
|
||||||
|
file(TO_NATIVE_PATH "${PYTHONPATHS}" pypath)
|
||||||
|
|
||||||
|
if(UNIX)
|
||||||
|
list(APPEND pypath "$PYTHONPATH")
|
||||||
|
string(REPLACE ";" ":" pypath "${pypath}")
|
||||||
|
set(ENV{PYTHONPATH} ${pypath})
|
||||||
|
endif(UNIX)
|
||||||
|
|
||||||
|
if(WIN32)
|
||||||
|
list(APPEND pypath "%PYTHONPATH%")
|
||||||
|
string(REPLACE ";" "\\;" pypath "${pypath}")
|
||||||
|
#list(APPEND environs "PYTHONPATH=${pypath}")
|
||||||
|
set(ENV{PYTHONPATH} ${pypath})
|
||||||
|
endif(WIN32)
|
||||||
|
|
||||||
|
foreach(f ${filenames})
|
||||||
|
execute_process(
|
||||||
|
COMMAND ${GRCC_COMMAND} -d ${directory} ${f}
|
||||||
|
)
|
||||||
|
string(REPLACE ".grc" ".py" pyfile "${f}")
|
||||||
|
string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}" pyfile "${pyfile}")
|
||||||
|
list(APPEND pyfiles ${pyfile})
|
||||||
|
endforeach(f)
|
||||||
|
|
||||||
|
set(PYFILES ${pyfiles} PARENT_SCOPE)
|
||||||
|
endfunction(GRCC)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Check if HAVE_PTHREAD_SETSCHEDPARAM and HAVE_SCHED_SETSCHEDULER
|
||||||
|
# should be defined
|
||||||
|
########################################################################
|
||||||
|
macro(GR_CHECK_LINUX_SCHED_AVAIL)
|
||||||
|
set(CMAKE_REQUIRED_LIBRARIES -lpthread)
|
||||||
|
CHECK_CXX_SOURCE_COMPILES("
|
||||||
|
#include <pthread.h>
|
||||||
|
int main(){
|
||||||
|
pthread_t pthread;
|
||||||
|
pthread_setschedparam(pthread, 0, 0);
|
||||||
|
return 0;
|
||||||
|
} " HAVE_PTHREAD_SETSCHEDPARAM
|
||||||
|
)
|
||||||
|
GR_ADD_COND_DEF(HAVE_PTHREAD_SETSCHEDPARAM)
|
||||||
|
|
||||||
|
CHECK_CXX_SOURCE_COMPILES("
|
||||||
|
#include <sched.h>
|
||||||
|
int main(){
|
||||||
|
pid_t pid;
|
||||||
|
sched_setscheduler(pid, 0, 0);
|
||||||
|
return 0;
|
||||||
|
} " HAVE_SCHED_SETSCHEDULER
|
||||||
|
)
|
||||||
|
GR_ADD_COND_DEF(HAVE_SCHED_SETSCHEDULER)
|
||||||
|
endmacro(GR_CHECK_LINUX_SCHED_AVAIL)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Macros to generate source and header files from template
|
||||||
|
########################################################################
|
||||||
|
macro(GR_EXPAND_X_H component root)
|
||||||
|
|
||||||
|
include(GrPython)
|
||||||
|
|
||||||
|
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
|
||||||
|
"#!${PYTHON_EXECUTABLE}
|
||||||
|
|
||||||
|
import sys, os, re
|
||||||
|
sys.path.append('${GR_RUNTIME_PYTHONPATH}')
|
||||||
|
sys.path.append('${CMAKE_SOURCE_DIR}/python')
|
||||||
|
os.environ['srcdir'] = '${CMAKE_CURRENT_SOURCE_DIR}'
|
||||||
|
os.chdir('${CMAKE_CURRENT_BINARY_DIR}')
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
import build_utils
|
||||||
|
root, inp = sys.argv[1:3]
|
||||||
|
for sig in sys.argv[3:]:
|
||||||
|
name = re.sub ('X+', sig, root)
|
||||||
|
d = build_utils.standard_dict2(name, sig, '${component}')
|
||||||
|
build_utils.expand_template(d, inp)
|
||||||
|
")
|
||||||
|
|
||||||
|
#make a list of all the generated headers
|
||||||
|
unset(expanded_files_h)
|
||||||
|
foreach(sig ${ARGN})
|
||||||
|
string(REGEX REPLACE "X+" ${sig} name ${root})
|
||||||
|
list(APPEND expanded_files_h ${CMAKE_CURRENT_BINARY_DIR}/${name}.h)
|
||||||
|
endforeach(sig)
|
||||||
|
unset(name)
|
||||||
|
|
||||||
|
#create a command to generate the headers
|
||||||
|
add_custom_command(
|
||||||
|
OUTPUT ${expanded_files_h}
|
||||||
|
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.h.t
|
||||||
|
COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
|
||||||
|
${root} ${root}.h.t ${ARGN}
|
||||||
|
)
|
||||||
|
|
||||||
|
#install rules for the generated headers
|
||||||
|
list(APPEND generated_includes ${expanded_files_h})
|
||||||
|
|
||||||
|
endmacro(GR_EXPAND_X_H)
|
||||||
|
|
||||||
|
macro(GR_EXPAND_X_CC_H component root)
|
||||||
|
|
||||||
|
include(GrPython)
|
||||||
|
|
||||||
|
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
|
||||||
|
"#!${PYTHON_EXECUTABLE}
|
||||||
|
|
||||||
|
import sys, os, re
|
||||||
|
sys.path.append('${GR_RUNTIME_PYTHONPATH}')
|
||||||
|
sys.path.append('${CMAKE_SOURCE_DIR}/python')
|
||||||
|
os.environ['srcdir'] = '${CMAKE_CURRENT_SOURCE_DIR}'
|
||||||
|
os.chdir('${CMAKE_CURRENT_BINARY_DIR}')
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
import build_utils
|
||||||
|
root, inp = sys.argv[1:3]
|
||||||
|
for sig in sys.argv[3:]:
|
||||||
|
name = re.sub ('X+', sig, root)
|
||||||
|
d = build_utils.standard_impl_dict2(name, sig, '${component}')
|
||||||
|
build_utils.expand_template(d, inp)
|
||||||
|
")
|
||||||
|
|
||||||
|
#make a list of all the generated files
|
||||||
|
unset(expanded_files_cc)
|
||||||
|
unset(expanded_files_h)
|
||||||
|
foreach(sig ${ARGN})
|
||||||
|
string(REGEX REPLACE "X+" ${sig} name ${root})
|
||||||
|
list(APPEND expanded_files_cc ${CMAKE_CURRENT_BINARY_DIR}/${name}.cc)
|
||||||
|
list(APPEND expanded_files_h ${CMAKE_CURRENT_BINARY_DIR}/${name}.h)
|
||||||
|
endforeach(sig)
|
||||||
|
unset(name)
|
||||||
|
|
||||||
|
#create a command to generate the source files
|
||||||
|
add_custom_command(
|
||||||
|
OUTPUT ${expanded_files_cc}
|
||||||
|
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.cc.t
|
||||||
|
COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
|
||||||
|
${root} ${root}.cc.t ${ARGN}
|
||||||
|
)
|
||||||
|
|
||||||
|
#create a command to generate the header files
|
||||||
|
add_custom_command(
|
||||||
|
OUTPUT ${expanded_files_h}
|
||||||
|
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.h.t
|
||||||
|
COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
|
||||||
|
${root} ${root}.h.t ${ARGN}
|
||||||
|
)
|
||||||
|
|
||||||
|
#make source files depends on headers to force generation
|
||||||
|
set_source_files_properties(${expanded_files_cc}
|
||||||
|
PROPERTIES OBJECT_DEPENDS "${expanded_files_h}"
|
||||||
|
)
|
||||||
|
|
||||||
|
#install rules for the generated files
|
||||||
|
list(APPEND generated_sources ${expanded_files_cc})
|
||||||
|
list(APPEND generated_headers ${expanded_files_h})
|
||||||
|
|
||||||
|
endmacro(GR_EXPAND_X_CC_H)
|
||||||
|
|
||||||
|
macro(GR_EXPAND_X_CC_H_IMPL component root)
|
||||||
|
|
||||||
|
include(GrPython)
|
||||||
|
|
||||||
|
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
|
||||||
|
"#!${PYTHON_EXECUTABLE}
|
||||||
|
|
||||||
|
import sys, os, re
|
||||||
|
sys.path.append('${GR_RUNTIME_PYTHONPATH}')
|
||||||
|
sys.path.append('${CMAKE_SOURCE_DIR}/python')
|
||||||
|
os.environ['srcdir'] = '${CMAKE_CURRENT_SOURCE_DIR}'
|
||||||
|
os.chdir('${CMAKE_CURRENT_BINARY_DIR}')
|
||||||
|
|
||||||
|
if __name__ == '__main__':
|
||||||
|
import build_utils
|
||||||
|
root, inp = sys.argv[1:3]
|
||||||
|
for sig in sys.argv[3:]:
|
||||||
|
name = re.sub ('X+', sig, root)
|
||||||
|
d = build_utils.standard_dict(name, sig, '${component}')
|
||||||
|
build_utils.expand_template(d, inp, '_impl')
|
||||||
|
")
|
||||||
|
|
||||||
|
#make a list of all the generated files
|
||||||
|
unset(expanded_files_cc_impl)
|
||||||
|
unset(expanded_files_h_impl)
|
||||||
|
unset(expanded_files_h)
|
||||||
|
foreach(sig ${ARGN})
|
||||||
|
string(REGEX REPLACE "X+" ${sig} name ${root})
|
||||||
|
list(APPEND expanded_files_cc_impl ${CMAKE_CURRENT_BINARY_DIR}/${name}_impl.cc)
|
||||||
|
list(APPEND expanded_files_h_impl ${CMAKE_CURRENT_BINARY_DIR}/${name}_impl.h)
|
||||||
|
list(APPEND expanded_files_h ${CMAKE_CURRENT_BINARY_DIR}/../include/gnuradio/${component}/${name}.h)
|
||||||
|
endforeach(sig)
|
||||||
|
unset(name)
|
||||||
|
|
||||||
|
#create a command to generate the _impl.cc files
|
||||||
|
add_custom_command(
|
||||||
|
OUTPUT ${expanded_files_cc_impl}
|
||||||
|
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}_impl.cc.t
|
||||||
|
COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
|
||||||
|
${root} ${root}_impl.cc.t ${ARGN}
|
||||||
|
)
|
||||||
|
|
||||||
|
#create a command to generate the _impl.h files
|
||||||
|
add_custom_command(
|
||||||
|
OUTPUT ${expanded_files_h_impl}
|
||||||
|
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}_impl.h.t
|
||||||
|
COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py
|
||||||
|
${root} ${root}_impl.h.t ${ARGN}
|
||||||
|
)
|
||||||
|
|
||||||
|
#make _impl.cc source files depend on _impl.h to force generation
|
||||||
|
set_source_files_properties(${expanded_files_cc_impl}
|
||||||
|
PROPERTIES OBJECT_DEPENDS "${expanded_files_h_impl}"
|
||||||
|
)
|
||||||
|
|
||||||
|
#make _impl.h source files depend on headers to force generation
|
||||||
|
set_source_files_properties(${expanded_files_h_impl}
|
||||||
|
PROPERTIES OBJECT_DEPENDS "${expanded_files_h}"
|
||||||
|
)
|
||||||
|
|
||||||
|
#install rules for the generated files
|
||||||
|
list(APPEND generated_sources ${expanded_files_cc_impl})
|
||||||
|
list(APPEND generated_headers ${expanded_files_h_impl})
|
||||||
|
|
||||||
|
endmacro(GR_EXPAND_X_CC_H_IMPL)
|
||||||
63
gr-hamnet70/cmake/Modules/GrPlatform.cmake
Normal file
63
gr-hamnet70/cmake/Modules/GrPlatform.cmake
Normal file
|
|
@ -0,0 +1,63 @@
|
||||||
|
# Copyright 2011 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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()
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Detect /lib versus /lib64
|
||||||
|
########################################################################
|
||||||
|
if (CMAKE_INSTALL_LIBDIR MATCHES lib64)
|
||||||
|
set(LIB_SUFFIX 64)
|
||||||
|
endif()
|
||||||
|
|
||||||
|
set(LIB_SUFFIX ${LIB_SUFFIX} CACHE STRING "lib directory suffix")
|
||||||
242
gr-hamnet70/cmake/Modules/GrPython.cmake
Normal file
242
gr-hamnet70/cmake/Modules/GrPython.cmake
Normal file
|
|
@ -0,0 +1,242 @@
|
||||||
|
# Copyright 2010-2011 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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)
|
||||||
|
")
|
||||||
257
gr-hamnet70/cmake/Modules/GrSwig.cmake
Normal file
257
gr-hamnet70/cmake/Modules/GrSwig.cmake
Normal file
|
|
@ -0,0 +1,257 @@
|
||||||
|
# Copyright 2010-2011 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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 formatted
|
||||||
|
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})
|
||||||
|
if(APPLE)
|
||||||
|
set(PYTHON_LINK_OPTIONS "-undefined dynamic_lookup")
|
||||||
|
else()
|
||||||
|
set(PYTHON_LINK_OPTIONS ${PYTHON_LIBRARIES})
|
||||||
|
endif(APPLE)
|
||||||
|
SWIG_LINK_LIBRARIES(${name} ${PYTHON_LINK_OPTIONS} ${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 don't 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)))
|
||||||
|
")
|
||||||
144
gr-hamnet70/cmake/Modules/GrTest.cmake
Normal file
144
gr-hamnet70/cmake/Modules/GrTest.cmake
Normal file
|
|
@ -0,0 +1,144 @@
|
||||||
|
# Copyright 2010-2011 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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)
|
||||||
304
gr-hamnet70/cmake/Modules/UseSWIG.cmake
Normal file
304
gr-hamnet70/cmake/Modules/UseSWIG.cmake
Normal file
|
|
@ -0,0 +1,304 @@
|
||||||
|
# - SWIG module for CMake
|
||||||
|
# Defines the following macros:
|
||||||
|
# SWIG_ADD_MODULE(name language [ files ])
|
||||||
|
# - Define swig module with given name and specified language
|
||||||
|
# SWIG_LINK_LIBRARIES(name [ libraries ])
|
||||||
|
# - Link libraries to swig module
|
||||||
|
# All other macros are for internal use only.
|
||||||
|
# To get the actual name of the swig module,
|
||||||
|
# use: ${SWIG_MODULE_${name}_REAL_NAME}.
|
||||||
|
# Set Source files properties such as CPLUSPLUS and SWIG_FLAGS to specify
|
||||||
|
# special behavior of SWIG. Also global CMAKE_SWIG_FLAGS can be used to add
|
||||||
|
# special flags to all swig calls.
|
||||||
|
# Another special variable is CMAKE_SWIG_OUTDIR, it allows one to specify
|
||||||
|
# where to write all the swig generated module (swig -outdir option)
|
||||||
|
# The name-specific variable SWIG_MODULE_<name>_EXTRA_DEPS may be used
|
||||||
|
# to specify extra dependencies for the generated modules.
|
||||||
|
# If the source file generated by swig need some special flag you can use
|
||||||
|
# set_source_files_properties( ${swig_generated_file_fullname}
|
||||||
|
# PROPERTIES COMPILE_FLAGS "-bla")
|
||||||
|
|
||||||
|
|
||||||
|
#=============================================================================
|
||||||
|
# Copyright 2004-2009 Kitware, Inc.
|
||||||
|
# Copyright 2009 Mathieu Malaterre <mathieu.malaterre@gmail.com>
|
||||||
|
#
|
||||||
|
# Distributed under the OSI-approved BSD License (the "License");
|
||||||
|
# see accompanying file Copyright.txt for details.
|
||||||
|
#
|
||||||
|
# This software is distributed WITHOUT ANY WARRANTY; without even the
|
||||||
|
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
||||||
|
# See the License for more information.
|
||||||
|
#=============================================================================
|
||||||
|
# (To distribute this file outside of CMake, substitute the full
|
||||||
|
# License text for the above reference.)
|
||||||
|
|
||||||
|
set(SWIG_CXX_EXTENSION "cxx")
|
||||||
|
set(SWIG_EXTRA_LIBRARIES "")
|
||||||
|
|
||||||
|
set(SWIG_PYTHON_EXTRA_FILE_EXTENSION "py")
|
||||||
|
|
||||||
|
#
|
||||||
|
# For given swig module initialize variables associated with it
|
||||||
|
#
|
||||||
|
macro(SWIG_MODULE_INITIALIZE name language)
|
||||||
|
string(TOUPPER "${language}" swig_uppercase_language)
|
||||||
|
string(TOLOWER "${language}" swig_lowercase_language)
|
||||||
|
set(SWIG_MODULE_${name}_LANGUAGE "${swig_uppercase_language}")
|
||||||
|
set(SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG "${swig_lowercase_language}")
|
||||||
|
|
||||||
|
set(SWIG_MODULE_${name}_REAL_NAME "${name}")
|
||||||
|
if("${SWIG_MODULE_${name}_LANGUAGE}" STREQUAL "UNKNOWN")
|
||||||
|
message(FATAL_ERROR "SWIG Error: Language \"${language}\" not found")
|
||||||
|
elseif("${SWIG_MODULE_${name}_LANGUAGE}" STREQUAL "PYTHON")
|
||||||
|
# when swig is used without the -interface it will produce in the module.py
|
||||||
|
# a 'import _modulename' statement, which implies having a corresponding
|
||||||
|
# _modulename.so (*NIX), _modulename.pyd (Win32).
|
||||||
|
set(SWIG_MODULE_${name}_REAL_NAME "_${name}")
|
||||||
|
elseif("${SWIG_MODULE_${name}_LANGUAGE}" STREQUAL "PERL")
|
||||||
|
set(SWIG_MODULE_${name}_EXTRA_FLAGS "-shadow")
|
||||||
|
endif()
|
||||||
|
endmacro()
|
||||||
|
|
||||||
|
#
|
||||||
|
# For a given language, input file, and output file, determine extra files that
|
||||||
|
# will be generated. This is internal swig macro.
|
||||||
|
#
|
||||||
|
|
||||||
|
macro(SWIG_GET_EXTRA_OUTPUT_FILES language outfiles generatedpath infile)
|
||||||
|
set(${outfiles} "")
|
||||||
|
get_source_file_property(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename
|
||||||
|
${infile} SWIG_MODULE_NAME)
|
||||||
|
if(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename STREQUAL "NOTFOUND")
|
||||||
|
get_filename_component(SWIG_GET_EXTRA_OUTPUT_FILES_module_basename "${infile}" NAME_WE)
|
||||||
|
endif()
|
||||||
|
foreach(it ${SWIG_${language}_EXTRA_FILE_EXTENSION})
|
||||||
|
set(${outfiles} ${${outfiles}}
|
||||||
|
"${generatedpath}/${SWIG_GET_EXTRA_OUTPUT_FILES_module_basename}.${it}")
|
||||||
|
endforeach()
|
||||||
|
endmacro()
|
||||||
|
|
||||||
|
#
|
||||||
|
# Take swig (*.i) file and add proper custom commands for it
|
||||||
|
#
|
||||||
|
macro(SWIG_ADD_SOURCE_TO_MODULE name outfiles infile)
|
||||||
|
set(swig_full_infile ${infile})
|
||||||
|
get_filename_component(swig_source_file_path "${infile}" PATH)
|
||||||
|
get_filename_component(swig_source_file_name_we "${infile}" NAME_WE)
|
||||||
|
get_source_file_property(swig_source_file_generated ${infile} GENERATED)
|
||||||
|
get_source_file_property(swig_source_file_cplusplus ${infile} CPLUSPLUS)
|
||||||
|
get_source_file_property(swig_source_file_flags ${infile} SWIG_FLAGS)
|
||||||
|
if("${swig_source_file_flags}" STREQUAL "NOTFOUND")
|
||||||
|
set(swig_source_file_flags "")
|
||||||
|
endif()
|
||||||
|
set(swig_source_file_fullname "${infile}")
|
||||||
|
if(${swig_source_file_path} MATCHES "^${CMAKE_CURRENT_SOURCE_DIR}")
|
||||||
|
string(REGEX REPLACE
|
||||||
|
"^${CMAKE_CURRENT_SOURCE_DIR}" ""
|
||||||
|
swig_source_file_relative_path
|
||||||
|
"${swig_source_file_path}")
|
||||||
|
else()
|
||||||
|
if(${swig_source_file_path} MATCHES "^${CMAKE_CURRENT_BINARY_DIR}")
|
||||||
|
string(REGEX REPLACE
|
||||||
|
"^${CMAKE_CURRENT_BINARY_DIR}" ""
|
||||||
|
swig_source_file_relative_path
|
||||||
|
"${swig_source_file_path}")
|
||||||
|
set(swig_source_file_generated 1)
|
||||||
|
else()
|
||||||
|
set(swig_source_file_relative_path "${swig_source_file_path}")
|
||||||
|
if(swig_source_file_generated)
|
||||||
|
set(swig_source_file_fullname "${CMAKE_CURRENT_BINARY_DIR}/${infile}")
|
||||||
|
else()
|
||||||
|
set(swig_source_file_fullname "${CMAKE_CURRENT_SOURCE_DIR}/${infile}")
|
||||||
|
endif()
|
||||||
|
endif()
|
||||||
|
endif()
|
||||||
|
|
||||||
|
set(swig_generated_file_fullname
|
||||||
|
"${CMAKE_CURRENT_BINARY_DIR}")
|
||||||
|
if(swig_source_file_relative_path)
|
||||||
|
set(swig_generated_file_fullname
|
||||||
|
"${swig_generated_file_fullname}/${swig_source_file_relative_path}")
|
||||||
|
endif()
|
||||||
|
# If CMAKE_SWIG_OUTDIR was specified then pass it to -outdir
|
||||||
|
if(CMAKE_SWIG_OUTDIR)
|
||||||
|
set(swig_outdir ${CMAKE_SWIG_OUTDIR})
|
||||||
|
else()
|
||||||
|
set(swig_outdir ${CMAKE_CURRENT_BINARY_DIR})
|
||||||
|
endif()
|
||||||
|
SWIG_GET_EXTRA_OUTPUT_FILES(${SWIG_MODULE_${name}_LANGUAGE}
|
||||||
|
swig_extra_generated_files
|
||||||
|
"${swig_outdir}"
|
||||||
|
"${infile}")
|
||||||
|
set(swig_generated_file_fullname
|
||||||
|
"${swig_generated_file_fullname}/${swig_source_file_name_we}")
|
||||||
|
# add the language into the name of the file (i.e. TCL_wrap)
|
||||||
|
# this allows for the same .i file to be wrapped into different languages
|
||||||
|
set(swig_generated_file_fullname
|
||||||
|
"${swig_generated_file_fullname}${SWIG_MODULE_${name}_LANGUAGE}_wrap")
|
||||||
|
|
||||||
|
if(swig_source_file_cplusplus)
|
||||||
|
set(swig_generated_file_fullname
|
||||||
|
"${swig_generated_file_fullname}.${SWIG_CXX_EXTENSION}")
|
||||||
|
else()
|
||||||
|
set(swig_generated_file_fullname
|
||||||
|
"${swig_generated_file_fullname}.c")
|
||||||
|
endif()
|
||||||
|
|
||||||
|
# Shut up some warnings from poor SWIG code generation that we
|
||||||
|
# can do nothing about, when this flag is available
|
||||||
|
include(CheckCXXCompilerFlag)
|
||||||
|
check_cxx_compiler_flag("-Wno-unused-but-set-variable" HAVE_WNO_UNUSED_BUT_SET_VARIABLE)
|
||||||
|
if(HAVE_WNO_UNUSED_BUT_SET_VARIABLE)
|
||||||
|
set_source_files_properties(${swig_generated_file_fullname}
|
||||||
|
PROPERTIES COMPILE_FLAGS "-Wno-unused-but-set-variable")
|
||||||
|
endif(HAVE_WNO_UNUSED_BUT_SET_VARIABLE)
|
||||||
|
|
||||||
|
get_directory_property(cmake_include_directories INCLUDE_DIRECTORIES)
|
||||||
|
set(swig_include_dirs)
|
||||||
|
foreach(it ${cmake_include_directories})
|
||||||
|
set(swig_include_dirs ${swig_include_dirs} "-I${it}")
|
||||||
|
endforeach()
|
||||||
|
|
||||||
|
set(swig_special_flags)
|
||||||
|
# default is c, so add c++ flag if it is c++
|
||||||
|
if(swig_source_file_cplusplus)
|
||||||
|
set(swig_special_flags ${swig_special_flags} "-c++")
|
||||||
|
endif()
|
||||||
|
set(swig_extra_flags)
|
||||||
|
if(SWIG_MODULE_${name}_EXTRA_FLAGS)
|
||||||
|
set(swig_extra_flags ${swig_extra_flags} ${SWIG_MODULE_${name}_EXTRA_FLAGS})
|
||||||
|
endif()
|
||||||
|
|
||||||
|
# hack to work around CMake bug in add_custom_command with multiple OUTPUT files
|
||||||
|
|
||||||
|
file(RELATIVE_PATH reldir ${CMAKE_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR})
|
||||||
|
execute_process(
|
||||||
|
COMMAND ${PYTHON_EXECUTABLE} -c "import re, hashlib
|
||||||
|
unique = hashlib.md5('${reldir}${ARGN}').hexdigest()[:5]
|
||||||
|
print(re.sub('\\W', '_', '${name} ${reldir} ' + unique))"
|
||||||
|
OUTPUT_VARIABLE _target OUTPUT_STRIP_TRAILING_WHITESPACE
|
||||||
|
)
|
||||||
|
|
||||||
|
file(
|
||||||
|
WRITE ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp.in
|
||||||
|
"int main(void){return 0;}\n"
|
||||||
|
)
|
||||||
|
|
||||||
|
# create dummy dependencies
|
||||||
|
add_custom_command(
|
||||||
|
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp
|
||||||
|
COMMAND ${CMAKE_COMMAND} -E copy
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp.in
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp
|
||||||
|
DEPENDS "${swig_source_file_fullname}" ${SWIG_MODULE_${name}_EXTRA_DEPS}
|
||||||
|
COMMENT ""
|
||||||
|
)
|
||||||
|
|
||||||
|
# create the dummy target
|
||||||
|
add_executable(${_target} ${CMAKE_CURRENT_BINARY_DIR}/${_target}.cpp)
|
||||||
|
|
||||||
|
# add a custom command to the dummy target
|
||||||
|
add_custom_command(
|
||||||
|
TARGET ${_target}
|
||||||
|
# Let's create the ${swig_outdir} at execution time, in case dir contains $(OutDir)
|
||||||
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${swig_outdir}
|
||||||
|
COMMAND "${SWIG_EXECUTABLE}"
|
||||||
|
ARGS "-${SWIG_MODULE_${name}_SWIG_LANGUAGE_FLAG}"
|
||||||
|
${swig_source_file_flags}
|
||||||
|
${CMAKE_SWIG_FLAGS}
|
||||||
|
-outdir ${swig_outdir}
|
||||||
|
${swig_special_flags}
|
||||||
|
${swig_extra_flags}
|
||||||
|
${swig_include_dirs}
|
||||||
|
-o "${swig_generated_file_fullname}"
|
||||||
|
"${swig_source_file_fullname}"
|
||||||
|
COMMENT "Swig source"
|
||||||
|
)
|
||||||
|
|
||||||
|
#add dummy independent dependencies from the _target to each file
|
||||||
|
#that will be generated by the SWIG command above
|
||||||
|
|
||||||
|
set(${outfiles} "${swig_generated_file_fullname}" ${swig_extra_generated_files})
|
||||||
|
|
||||||
|
foreach(swig_gen_file ${${outfiles}})
|
||||||
|
add_custom_command(
|
||||||
|
OUTPUT ${swig_gen_file}
|
||||||
|
COMMAND "${CMAKE_COMMAND}" -E touch_nocreate "${swig_gen_file}"
|
||||||
|
DEPENDS ${_target}
|
||||||
|
COMMENT "dummy command to show ${_target} dependency of ${swig_gen_file}"
|
||||||
|
)
|
||||||
|
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()
|
||||||
30
gr-hamnet70/cmake/Modules/hamnet70Config.cmake
Normal file
30
gr-hamnet70/cmake/Modules/hamnet70Config.cmake
Normal file
|
|
@ -0,0 +1,30 @@
|
||||||
|
INCLUDE(FindPkgConfig)
|
||||||
|
PKG_CHECK_MODULES(PC_HAMNET70 hamnet70)
|
||||||
|
|
||||||
|
FIND_PATH(
|
||||||
|
HAMNET70_INCLUDE_DIRS
|
||||||
|
NAMES hamnet70/api.h
|
||||||
|
HINTS $ENV{HAMNET70_DIR}/include
|
||||||
|
${PC_HAMNET70_INCLUDEDIR}
|
||||||
|
PATHS ${CMAKE_INSTALL_PREFIX}/include
|
||||||
|
/usr/local/include
|
||||||
|
/usr/include
|
||||||
|
)
|
||||||
|
|
||||||
|
FIND_LIBRARY(
|
||||||
|
HAMNET70_LIBRARIES
|
||||||
|
NAMES gnuradio-hamnet70
|
||||||
|
HINTS $ENV{HAMNET70_DIR}/lib
|
||||||
|
${PC_HAMNET70_LIBDIR}
|
||||||
|
PATHS ${CMAKE_INSTALL_PREFIX}/lib
|
||||||
|
${CMAKE_INSTALL_PREFIX}/lib64
|
||||||
|
/usr/local/lib
|
||||||
|
/usr/local/lib64
|
||||||
|
/usr/lib
|
||||||
|
/usr/lib64
|
||||||
|
)
|
||||||
|
|
||||||
|
INCLUDE(FindPackageHandleStandardArgs)
|
||||||
|
FIND_PACKAGE_HANDLE_STANDARD_ARGS(HAMNET70 DEFAULT_MSG HAMNET70_LIBRARIES HAMNET70_INCLUDE_DIRS)
|
||||||
|
MARK_AS_ADVANCED(HAMNET70_LIBRARIES HAMNET70_INCLUDE_DIRS)
|
||||||
|
|
||||||
32
gr-hamnet70/cmake/cmake_uninstall.cmake.in
Normal file
32
gr-hamnet70/cmake/cmake_uninstall.cmake.in
Normal file
|
|
@ -0,0 +1,32 @@
|
||||||
|
# http://www.vtk.org/Wiki/CMake_FAQ#Can_I_do_.22make_uninstall.22_with_CMake.3F
|
||||||
|
|
||||||
|
IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
|
||||||
|
MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")
|
||||||
|
ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")
|
||||||
|
|
||||||
|
FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)
|
||||||
|
STRING(REGEX REPLACE "\n" ";" files "${files}")
|
||||||
|
FOREACH(file ${files})
|
||||||
|
MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")
|
||||||
|
IF(EXISTS "$ENV{DESTDIR}${file}")
|
||||||
|
EXEC_PROGRAM(
|
||||||
|
"@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
|
||||||
|
OUTPUT_VARIABLE rm_out
|
||||||
|
RETURN_VALUE rm_retval
|
||||||
|
)
|
||||||
|
IF(NOT "${rm_retval}" STREQUAL 0)
|
||||||
|
MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
|
||||||
|
ENDIF(NOT "${rm_retval}" STREQUAL 0)
|
||||||
|
ELSEIF(IS_SYMLINK "$ENV{DESTDIR}${file}")
|
||||||
|
EXEC_PROGRAM(
|
||||||
|
"@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""
|
||||||
|
OUTPUT_VARIABLE rm_out
|
||||||
|
RETURN_VALUE rm_retval
|
||||||
|
)
|
||||||
|
IF(NOT "${rm_retval}" STREQUAL 0)
|
||||||
|
MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")
|
||||||
|
ENDIF(NOT "${rm_retval}" STREQUAL 0)
|
||||||
|
ELSE(EXISTS "$ENV{DESTDIR}${file}")
|
||||||
|
MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")
|
||||||
|
ENDIF(EXISTS "$ENV{DESTDIR}${file}")
|
||||||
|
ENDFOREACH(file)
|
||||||
36
gr-hamnet70/docs/CMakeLists.txt
Normal file
36
gr-hamnet70/docs/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,36 @@
|
||||||
|
# Copyright 2011 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
# Boston, MA 02110-1301, USA.
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Setup dependencies
|
||||||
|
########################################################################
|
||||||
|
find_package(Doxygen)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Begin conditional configuration
|
||||||
|
########################################################################
|
||||||
|
if(ENABLE_DOXYGEN)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Add subdirectories
|
||||||
|
########################################################################
|
||||||
|
add_subdirectory(doxygen)
|
||||||
|
|
||||||
|
endif(ENABLE_DOXYGEN)
|
||||||
11
gr-hamnet70/docs/README.hamnet70
Normal file
11
gr-hamnet70/docs/README.hamnet70
Normal file
|
|
@ -0,0 +1,11 @@
|
||||||
|
This is the hamnet70-write-a-block package meant as a guide to building
|
||||||
|
out-of-tree packages. To use the hamnet70 blocks, the Python namespaces
|
||||||
|
is in 'hamnet70', which is imported as:
|
||||||
|
|
||||||
|
import hamnet70
|
||||||
|
|
||||||
|
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(hamnet70)
|
||||||
53
gr-hamnet70/docs/doxygen/CMakeLists.txt
Normal file
53
gr-hamnet70/docs/doxygen/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,53 @@
|
||||||
|
# Copyright 2011 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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})
|
||||||
1910
gr-hamnet70/docs/doxygen/Doxyfile.in
Normal file
1910
gr-hamnet70/docs/doxygen/Doxyfile.in
Normal file
File diff suppressed because it is too large
Load diff
1878
gr-hamnet70/docs/doxygen/Doxyfile.swig_doc.in
Normal file
1878
gr-hamnet70/docs/doxygen/Doxyfile.swig_doc.in
Normal file
File diff suppressed because it is too large
Load diff
83
gr-hamnet70/docs/doxygen/doxyxml/__init__.py
Normal file
83
gr-hamnet70/docs/doxygen/doxyxml/__init__.py
Normal file
|
|
@ -0,0 +1,83 @@
|
||||||
|
#
|
||||||
|
# Copyright 2010 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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()
|
||||||
|
|
||||||
220
gr-hamnet70/docs/doxygen/doxyxml/base.py
Normal file
220
gr-hamnet70/docs/doxygen/doxyxml/base.py
Normal file
|
|
@ -0,0 +1,220 @@
|
||||||
|
#
|
||||||
|
# Copyright 2010 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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
|
||||||
302
gr-hamnet70/docs/doxygen/doxyxml/doxyindex.py
Normal file
302
gr-hamnet70/docs/doxygen/doxyxml/doxyindex.py
Normal file
|
|
@ -0,0 +1,302 @@
|
||||||
|
#
|
||||||
|
# Copyright 2010 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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 and namespaces 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)
|
||||||
|
elif self.get_cls(mem) == DoxyNamespace:
|
||||||
|
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
|
||||||
|
|
||||||
|
def set_parameters(self, data):
|
||||||
|
vs = [ddc.value for ddc in data.detaileddescription.content_]
|
||||||
|
pls = []
|
||||||
|
for v in vs:
|
||||||
|
if hasattr(v, 'parameterlist'):
|
||||||
|
pls += v.parameterlist
|
||||||
|
pis = []
|
||||||
|
for pl in pls:
|
||||||
|
pis += pl.parameteritem
|
||||||
|
dpis = []
|
||||||
|
for pi in pis:
|
||||||
|
dpi = DoxyParameterItem(pi)
|
||||||
|
dpi._parse()
|
||||||
|
dpis.append(dpi)
|
||||||
|
self._data['params'] = dpis
|
||||||
|
|
||||||
|
|
||||||
|
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.set_parameters(self._parse_data)
|
||||||
|
if not self._data['params']:
|
||||||
|
# If the params weren't set by a comment then just grab the names.
|
||||||
|
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
|
||||||
|
|
||||||
|
@property
|
||||||
|
def description(self):
|
||||||
|
descriptions = []
|
||||||
|
if self.brief_description:
|
||||||
|
descriptions.append(self.brief_description)
|
||||||
|
if self.detailed_description:
|
||||||
|
descriptions.append(self.detailed_description)
|
||||||
|
return '\n\n'.join(descriptions)
|
||||||
|
|
||||||
|
brief_description = property(lambda self: self.data()['brief_description'])
|
||||||
|
detailed_description = property(lambda self: self.data()['detailed_description'])
|
||||||
|
name = property(lambda self: self.data()['declname'])
|
||||||
|
|
||||||
|
class DoxyParameterItem(DoxyMember):
|
||||||
|
"""A different representation of a parameter in Doxygen."""
|
||||||
|
|
||||||
|
def _parse(self):
|
||||||
|
if self._parsed:
|
||||||
|
return
|
||||||
|
super(DoxyParameterItem, self)._parse()
|
||||||
|
names = []
|
||||||
|
for nl in self._parse_data.parameternamelist:
|
||||||
|
for pn in nl.parametername:
|
||||||
|
names.append(description(pn))
|
||||||
|
# Just take first name
|
||||||
|
self._data['name'] = names[0]
|
||||||
|
# Get description
|
||||||
|
pd = description(self._parse_data.get_parameterdescription())
|
||||||
|
self._data['description'] = pd
|
||||||
|
|
||||||
|
description = property(lambda self: self.data()['description'])
|
||||||
|
name = property(lambda self: self.data()['name'])
|
||||||
|
|
||||||
|
|
||||||
|
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)
|
||||||
|
self.set_parameters(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'])
|
||||||
|
params = property(lambda self: self.data()['params'])
|
||||||
|
|
||||||
|
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'
|
||||||
|
|
||||||
|
def _parse(self):
|
||||||
|
if self._parsed:
|
||||||
|
return
|
||||||
|
super(DoxyNamespace, self)._parse()
|
||||||
|
self.retrieve_data()
|
||||||
|
self.set_descriptions(self._retrieved_data.compounddef)
|
||||||
|
if self._error:
|
||||||
|
return
|
||||||
|
self.process_memberdefs()
|
||||||
|
|
||||||
|
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', 'signal', 'slot', 'property'])
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def can_parse(cls, obj):
|
||||||
|
return obj.kind in cls.kinds
|
||||||
|
|
||||||
|
Base.mem_classes.append(DoxyOther)
|
||||||
7
gr-hamnet70/docs/doxygen/doxyxml/generated/__init__.py
Normal file
7
gr-hamnet70/docs/doxygen/doxyxml/generated/__init__.py
Normal file
|
|
@ -0,0 +1,7 @@
|
||||||
|
"""
|
||||||
|
Contains generated files produced by generateDS.py.
|
||||||
|
|
||||||
|
These do the real work of parsing the doxygen xml files but the
|
||||||
|
resultant classes are not very friendly to navigate so the rest of the
|
||||||
|
doxyxml module processes them further.
|
||||||
|
"""
|
||||||
503
gr-hamnet70/docs/doxygen/doxyxml/generated/compound.py
Normal file
503
gr-hamnet70/docs/doxygen/doxyxml/generated/compound.py
Normal file
|
|
@ -0,0 +1,503 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
|
||||||
|
"""
|
||||||
|
Generated Mon Feb 9 19:08:05 2009 by generateDS.py.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from string import lower as str_lower
|
||||||
|
from xml.dom import minidom
|
||||||
|
from xml.dom import Node
|
||||||
|
|
||||||
|
import sys
|
||||||
|
|
||||||
|
import compoundsuper as supermod
|
||||||
|
from compoundsuper import MixedContainer
|
||||||
|
|
||||||
|
|
||||||
|
class DoxygenTypeSub(supermod.DoxygenType):
|
||||||
|
def __init__(self, version=None, compounddef=None):
|
||||||
|
supermod.DoxygenType.__init__(self, version, compounddef)
|
||||||
|
|
||||||
|
def find(self, details):
|
||||||
|
|
||||||
|
return self.compounddef.find(details)
|
||||||
|
|
||||||
|
supermod.DoxygenType.subclass = DoxygenTypeSub
|
||||||
|
# end class DoxygenTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class compounddefTypeSub(supermod.compounddefType):
|
||||||
|
def __init__(self, kind=None, prot=None, id=None, compoundname='', title='', basecompoundref=None, derivedcompoundref=None, includes=None, includedby=None, incdepgraph=None, invincdepgraph=None, innerdir=None, innerfile=None, innerclass=None, innernamespace=None, innerpage=None, innergroup=None, templateparamlist=None, sectiondef=None, briefdescription=None, detaileddescription=None, inheritancegraph=None, collaborationgraph=None, programlisting=None, location=None, listofallmembers=None):
|
||||||
|
supermod.compounddefType.__init__(self, kind, prot, id, compoundname, title, basecompoundref, derivedcompoundref, includes, includedby, incdepgraph, invincdepgraph, innerdir, innerfile, innerclass, innernamespace, innerpage, innergroup, templateparamlist, sectiondef, briefdescription, detaileddescription, inheritancegraph, collaborationgraph, programlisting, location, listofallmembers)
|
||||||
|
|
||||||
|
def find(self, details):
|
||||||
|
|
||||||
|
if self.id == details.refid:
|
||||||
|
return self
|
||||||
|
|
||||||
|
for sectiondef in self.sectiondef:
|
||||||
|
result = sectiondef.find(details)
|
||||||
|
if result:
|
||||||
|
return result
|
||||||
|
|
||||||
|
|
||||||
|
supermod.compounddefType.subclass = compounddefTypeSub
|
||||||
|
# end class compounddefTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class listofallmembersTypeSub(supermod.listofallmembersType):
|
||||||
|
def __init__(self, member=None):
|
||||||
|
supermod.listofallmembersType.__init__(self, member)
|
||||||
|
supermod.listofallmembersType.subclass = listofallmembersTypeSub
|
||||||
|
# end class listofallmembersTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class memberRefTypeSub(supermod.memberRefType):
|
||||||
|
def __init__(self, virt=None, prot=None, refid=None, ambiguityscope=None, scope='', name=''):
|
||||||
|
supermod.memberRefType.__init__(self, virt, prot, refid, ambiguityscope, scope, name)
|
||||||
|
supermod.memberRefType.subclass = memberRefTypeSub
|
||||||
|
# end class memberRefTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class compoundRefTypeSub(supermod.compoundRefType):
|
||||||
|
def __init__(self, virt=None, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.compoundRefType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.compoundRefType.subclass = compoundRefTypeSub
|
||||||
|
# end class compoundRefTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class reimplementTypeSub(supermod.reimplementType):
|
||||||
|
def __init__(self, refid=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.reimplementType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.reimplementType.subclass = reimplementTypeSub
|
||||||
|
# end class reimplementTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class incTypeSub(supermod.incType):
|
||||||
|
def __init__(self, local=None, refid=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.incType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.incType.subclass = incTypeSub
|
||||||
|
# end class incTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class refTypeSub(supermod.refType):
|
||||||
|
def __init__(self, prot=None, refid=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.refType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.refType.subclass = refTypeSub
|
||||||
|
# end class refTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
class refTextTypeSub(supermod.refTextType):
|
||||||
|
def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.refTextType.__init__(self, mixedclass_, content_)
|
||||||
|
|
||||||
|
supermod.refTextType.subclass = refTextTypeSub
|
||||||
|
# end class refTextTypeSub
|
||||||
|
|
||||||
|
class sectiondefTypeSub(supermod.sectiondefType):
|
||||||
|
|
||||||
|
|
||||||
|
def __init__(self, kind=None, header='', description=None, memberdef=None):
|
||||||
|
supermod.sectiondefType.__init__(self, kind, header, description, memberdef)
|
||||||
|
|
||||||
|
def find(self, details):
|
||||||
|
|
||||||
|
for memberdef in self.memberdef:
|
||||||
|
if memberdef.id == details.refid:
|
||||||
|
return memberdef
|
||||||
|
|
||||||
|
return None
|
||||||
|
|
||||||
|
|
||||||
|
supermod.sectiondefType.subclass = sectiondefTypeSub
|
||||||
|
# end class sectiondefTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class memberdefTypeSub(supermod.memberdefType):
|
||||||
|
def __init__(self, initonly=None, kind=None, volatile=None, const=None, raise_=None, virt=None, readable=None, prot=None, explicit=None, new=None, final=None, writable=None, add=None, static=None, remove=None, sealed=None, mutable=None, gettable=None, inline=None, settable=None, id=None, templateparamlist=None, type_=None, definition='', argsstring='', name='', read='', write='', bitfield='', reimplements=None, reimplementedby=None, param=None, enumvalue=None, initializer=None, exceptions=None, briefdescription=None, detaileddescription=None, inbodydescription=None, location=None, references=None, referencedby=None):
|
||||||
|
supermod.memberdefType.__init__(self, initonly, kind, volatile, const, raise_, virt, readable, prot, explicit, new, final, writable, add, static, remove, sealed, mutable, gettable, inline, settable, id, templateparamlist, type_, definition, argsstring, name, read, write, bitfield, reimplements, reimplementedby, param, enumvalue, initializer, exceptions, briefdescription, detaileddescription, inbodydescription, location, references, referencedby)
|
||||||
|
supermod.memberdefType.subclass = memberdefTypeSub
|
||||||
|
# end class memberdefTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class descriptionTypeSub(supermod.descriptionType):
|
||||||
|
def __init__(self, title='', para=None, sect1=None, internal=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.descriptionType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.descriptionType.subclass = descriptionTypeSub
|
||||||
|
# end class descriptionTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class enumvalueTypeSub(supermod.enumvalueType):
|
||||||
|
def __init__(self, prot=None, id=None, name='', initializer=None, briefdescription=None, detaileddescription=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.enumvalueType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.enumvalueType.subclass = enumvalueTypeSub
|
||||||
|
# end class enumvalueTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class templateparamlistTypeSub(supermod.templateparamlistType):
|
||||||
|
def __init__(self, param=None):
|
||||||
|
supermod.templateparamlistType.__init__(self, param)
|
||||||
|
supermod.templateparamlistType.subclass = templateparamlistTypeSub
|
||||||
|
# end class templateparamlistTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class paramTypeSub(supermod.paramType):
|
||||||
|
def __init__(self, type_=None, declname='', defname='', array='', defval=None, briefdescription=None):
|
||||||
|
supermod.paramType.__init__(self, type_, declname, defname, array, defval, briefdescription)
|
||||||
|
supermod.paramType.subclass = paramTypeSub
|
||||||
|
# end class paramTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class linkedTextTypeSub(supermod.linkedTextType):
|
||||||
|
def __init__(self, ref=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.linkedTextType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.linkedTextType.subclass = linkedTextTypeSub
|
||||||
|
# end class linkedTextTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class graphTypeSub(supermod.graphType):
|
||||||
|
def __init__(self, node=None):
|
||||||
|
supermod.graphType.__init__(self, node)
|
||||||
|
supermod.graphType.subclass = graphTypeSub
|
||||||
|
# end class graphTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class nodeTypeSub(supermod.nodeType):
|
||||||
|
def __init__(self, id=None, label='', link=None, childnode=None):
|
||||||
|
supermod.nodeType.__init__(self, id, label, link, childnode)
|
||||||
|
supermod.nodeType.subclass = nodeTypeSub
|
||||||
|
# end class nodeTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class childnodeTypeSub(supermod.childnodeType):
|
||||||
|
def __init__(self, relation=None, refid=None, edgelabel=None):
|
||||||
|
supermod.childnodeType.__init__(self, relation, refid, edgelabel)
|
||||||
|
supermod.childnodeType.subclass = childnodeTypeSub
|
||||||
|
# end class childnodeTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class linkTypeSub(supermod.linkType):
|
||||||
|
def __init__(self, refid=None, external=None, valueOf_=''):
|
||||||
|
supermod.linkType.__init__(self, refid, external)
|
||||||
|
supermod.linkType.subclass = linkTypeSub
|
||||||
|
# end class linkTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class listingTypeSub(supermod.listingType):
|
||||||
|
def __init__(self, codeline=None):
|
||||||
|
supermod.listingType.__init__(self, codeline)
|
||||||
|
supermod.listingType.subclass = listingTypeSub
|
||||||
|
# end class listingTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class codelineTypeSub(supermod.codelineType):
|
||||||
|
def __init__(self, external=None, lineno=None, refkind=None, refid=None, highlight=None):
|
||||||
|
supermod.codelineType.__init__(self, external, lineno, refkind, refid, highlight)
|
||||||
|
supermod.codelineType.subclass = codelineTypeSub
|
||||||
|
# end class codelineTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class highlightTypeSub(supermod.highlightType):
|
||||||
|
def __init__(self, class_=None, sp=None, ref=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.highlightType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.highlightType.subclass = highlightTypeSub
|
||||||
|
# end class highlightTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class referenceTypeSub(supermod.referenceType):
|
||||||
|
def __init__(self, endline=None, startline=None, refid=None, compoundref=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.referenceType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.referenceType.subclass = referenceTypeSub
|
||||||
|
# end class referenceTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class locationTypeSub(supermod.locationType):
|
||||||
|
def __init__(self, bodystart=None, line=None, bodyend=None, bodyfile=None, file=None, valueOf_=''):
|
||||||
|
supermod.locationType.__init__(self, bodystart, line, bodyend, bodyfile, file)
|
||||||
|
supermod.locationType.subclass = locationTypeSub
|
||||||
|
# end class locationTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docSect1TypeSub(supermod.docSect1Type):
|
||||||
|
def __init__(self, id=None, title='', para=None, sect2=None, internal=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.docSect1Type.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docSect1Type.subclass = docSect1TypeSub
|
||||||
|
# end class docSect1TypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docSect2TypeSub(supermod.docSect2Type):
|
||||||
|
def __init__(self, id=None, title='', para=None, sect3=None, internal=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.docSect2Type.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docSect2Type.subclass = docSect2TypeSub
|
||||||
|
# end class docSect2TypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docSect3TypeSub(supermod.docSect3Type):
|
||||||
|
def __init__(self, id=None, title='', para=None, sect4=None, internal=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.docSect3Type.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docSect3Type.subclass = docSect3TypeSub
|
||||||
|
# end class docSect3TypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docSect4TypeSub(supermod.docSect4Type):
|
||||||
|
def __init__(self, id=None, title='', para=None, internal=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.docSect4Type.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docSect4Type.subclass = docSect4TypeSub
|
||||||
|
# end class docSect4TypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docInternalTypeSub(supermod.docInternalType):
|
||||||
|
def __init__(self, para=None, sect1=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.docInternalType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docInternalType.subclass = docInternalTypeSub
|
||||||
|
# end class docInternalTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docInternalS1TypeSub(supermod.docInternalS1Type):
|
||||||
|
def __init__(self, para=None, sect2=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.docInternalS1Type.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docInternalS1Type.subclass = docInternalS1TypeSub
|
||||||
|
# end class docInternalS1TypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docInternalS2TypeSub(supermod.docInternalS2Type):
|
||||||
|
def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.docInternalS2Type.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docInternalS2Type.subclass = docInternalS2TypeSub
|
||||||
|
# end class docInternalS2TypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docInternalS3TypeSub(supermod.docInternalS3Type):
|
||||||
|
def __init__(self, para=None, sect3=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.docInternalS3Type.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docInternalS3Type.subclass = docInternalS3TypeSub
|
||||||
|
# end class docInternalS3TypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docInternalS4TypeSub(supermod.docInternalS4Type):
|
||||||
|
def __init__(self, para=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.docInternalS4Type.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docInternalS4Type.subclass = docInternalS4TypeSub
|
||||||
|
# end class docInternalS4TypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docURLLinkSub(supermod.docURLLink):
|
||||||
|
def __init__(self, url=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.docURLLink.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docURLLink.subclass = docURLLinkSub
|
||||||
|
# end class docURLLinkSub
|
||||||
|
|
||||||
|
|
||||||
|
class docAnchorTypeSub(supermod.docAnchorType):
|
||||||
|
def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.docAnchorType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docAnchorType.subclass = docAnchorTypeSub
|
||||||
|
# end class docAnchorTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docFormulaTypeSub(supermod.docFormulaType):
|
||||||
|
def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.docFormulaType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docFormulaType.subclass = docFormulaTypeSub
|
||||||
|
# end class docFormulaTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docIndexEntryTypeSub(supermod.docIndexEntryType):
|
||||||
|
def __init__(self, primaryie='', secondaryie=''):
|
||||||
|
supermod.docIndexEntryType.__init__(self, primaryie, secondaryie)
|
||||||
|
supermod.docIndexEntryType.subclass = docIndexEntryTypeSub
|
||||||
|
# end class docIndexEntryTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docListTypeSub(supermod.docListType):
|
||||||
|
def __init__(self, listitem=None):
|
||||||
|
supermod.docListType.__init__(self, listitem)
|
||||||
|
supermod.docListType.subclass = docListTypeSub
|
||||||
|
# end class docListTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docListItemTypeSub(supermod.docListItemType):
|
||||||
|
def __init__(self, para=None):
|
||||||
|
supermod.docListItemType.__init__(self, para)
|
||||||
|
supermod.docListItemType.subclass = docListItemTypeSub
|
||||||
|
# end class docListItemTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docSimpleSectTypeSub(supermod.docSimpleSectType):
|
||||||
|
def __init__(self, kind=None, title=None, para=None):
|
||||||
|
supermod.docSimpleSectType.__init__(self, kind, title, para)
|
||||||
|
supermod.docSimpleSectType.subclass = docSimpleSectTypeSub
|
||||||
|
# end class docSimpleSectTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docVarListEntryTypeSub(supermod.docVarListEntryType):
|
||||||
|
def __init__(self, term=None):
|
||||||
|
supermod.docVarListEntryType.__init__(self, term)
|
||||||
|
supermod.docVarListEntryType.subclass = docVarListEntryTypeSub
|
||||||
|
# end class docVarListEntryTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docRefTextTypeSub(supermod.docRefTextType):
|
||||||
|
def __init__(self, refid=None, kindref=None, external=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.docRefTextType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docRefTextType.subclass = docRefTextTypeSub
|
||||||
|
# end class docRefTextTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docTableTypeSub(supermod.docTableType):
|
||||||
|
def __init__(self, rows=None, cols=None, row=None, caption=None):
|
||||||
|
supermod.docTableType.__init__(self, rows, cols, row, caption)
|
||||||
|
supermod.docTableType.subclass = docTableTypeSub
|
||||||
|
# end class docTableTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docRowTypeSub(supermod.docRowType):
|
||||||
|
def __init__(self, entry=None):
|
||||||
|
supermod.docRowType.__init__(self, entry)
|
||||||
|
supermod.docRowType.subclass = docRowTypeSub
|
||||||
|
# end class docRowTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docEntryTypeSub(supermod.docEntryType):
|
||||||
|
def __init__(self, thead=None, para=None):
|
||||||
|
supermod.docEntryType.__init__(self, thead, para)
|
||||||
|
supermod.docEntryType.subclass = docEntryTypeSub
|
||||||
|
# end class docEntryTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docHeadingTypeSub(supermod.docHeadingType):
|
||||||
|
def __init__(self, level=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.docHeadingType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docHeadingType.subclass = docHeadingTypeSub
|
||||||
|
# end class docHeadingTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docImageTypeSub(supermod.docImageType):
|
||||||
|
def __init__(self, width=None, type_=None, name=None, height=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.docImageType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docImageType.subclass = docImageTypeSub
|
||||||
|
# end class docImageTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docDotFileTypeSub(supermod.docDotFileType):
|
||||||
|
def __init__(self, name=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.docDotFileType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docDotFileType.subclass = docDotFileTypeSub
|
||||||
|
# end class docDotFileTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docTocItemTypeSub(supermod.docTocItemType):
|
||||||
|
def __init__(self, id=None, valueOf_='', mixedclass_=None, content_=None):
|
||||||
|
supermod.docTocItemType.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docTocItemType.subclass = docTocItemTypeSub
|
||||||
|
# end class docTocItemTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docTocListTypeSub(supermod.docTocListType):
|
||||||
|
def __init__(self, tocitem=None):
|
||||||
|
supermod.docTocListType.__init__(self, tocitem)
|
||||||
|
supermod.docTocListType.subclass = docTocListTypeSub
|
||||||
|
# end class docTocListTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docLanguageTypeSub(supermod.docLanguageType):
|
||||||
|
def __init__(self, langid=None, para=None):
|
||||||
|
supermod.docLanguageType.__init__(self, langid, para)
|
||||||
|
supermod.docLanguageType.subclass = docLanguageTypeSub
|
||||||
|
# end class docLanguageTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docParamListTypeSub(supermod.docParamListType):
|
||||||
|
def __init__(self, kind=None, parameteritem=None):
|
||||||
|
supermod.docParamListType.__init__(self, kind, parameteritem)
|
||||||
|
supermod.docParamListType.subclass = docParamListTypeSub
|
||||||
|
# end class docParamListTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docParamListItemSub(supermod.docParamListItem):
|
||||||
|
def __init__(self, parameternamelist=None, parameterdescription=None):
|
||||||
|
supermod.docParamListItem.__init__(self, parameternamelist, parameterdescription)
|
||||||
|
supermod.docParamListItem.subclass = docParamListItemSub
|
||||||
|
# end class docParamListItemSub
|
||||||
|
|
||||||
|
|
||||||
|
class docParamNameListSub(supermod.docParamNameList):
|
||||||
|
def __init__(self, parametername=None):
|
||||||
|
supermod.docParamNameList.__init__(self, parametername)
|
||||||
|
supermod.docParamNameList.subclass = docParamNameListSub
|
||||||
|
# end class docParamNameListSub
|
||||||
|
|
||||||
|
|
||||||
|
class docParamNameSub(supermod.docParamName):
|
||||||
|
def __init__(self, direction=None, ref=None, mixedclass_=None, content_=None):
|
||||||
|
supermod.docParamName.__init__(self, mixedclass_, content_)
|
||||||
|
supermod.docParamName.subclass = docParamNameSub
|
||||||
|
# end class docParamNameSub
|
||||||
|
|
||||||
|
|
||||||
|
class docXRefSectTypeSub(supermod.docXRefSectType):
|
||||||
|
def __init__(self, id=None, xreftitle=None, xrefdescription=None):
|
||||||
|
supermod.docXRefSectType.__init__(self, id, xreftitle, xrefdescription)
|
||||||
|
supermod.docXRefSectType.subclass = docXRefSectTypeSub
|
||||||
|
# end class docXRefSectTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docCopyTypeSub(supermod.docCopyType):
|
||||||
|
def __init__(self, link=None, para=None, sect1=None, internal=None):
|
||||||
|
supermod.docCopyType.__init__(self, link, para, sect1, internal)
|
||||||
|
supermod.docCopyType.subclass = docCopyTypeSub
|
||||||
|
# end class docCopyTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class docCharTypeSub(supermod.docCharType):
|
||||||
|
def __init__(self, char=None, valueOf_=''):
|
||||||
|
supermod.docCharType.__init__(self, char)
|
||||||
|
supermod.docCharType.subclass = docCharTypeSub
|
||||||
|
# end class docCharTypeSub
|
||||||
|
|
||||||
|
class docParaTypeSub(supermod.docParaType):
|
||||||
|
def __init__(self, char=None, valueOf_=''):
|
||||||
|
supermod.docParaType.__init__(self, char)
|
||||||
|
|
||||||
|
self.parameterlist = []
|
||||||
|
self.simplesects = []
|
||||||
|
self.content = []
|
||||||
|
|
||||||
|
def buildChildren(self, child_, nodeName_):
|
||||||
|
supermod.docParaType.buildChildren(self, child_, nodeName_)
|
||||||
|
|
||||||
|
if child_.nodeType == Node.TEXT_NODE:
|
||||||
|
obj_ = self.mixedclass_(MixedContainer.CategoryText,
|
||||||
|
MixedContainer.TypeNone, '', child_.nodeValue)
|
||||||
|
self.content.append(obj_)
|
||||||
|
elif child_.nodeType == Node.ELEMENT_NODE and \
|
||||||
|
nodeName_ == "ref":
|
||||||
|
obj_ = supermod.docRefTextType.factory()
|
||||||
|
obj_.build(child_)
|
||||||
|
self.content.append(obj_)
|
||||||
|
elif child_.nodeType == Node.ELEMENT_NODE and \
|
||||||
|
nodeName_ == 'parameterlist':
|
||||||
|
obj_ = supermod.docParamListType.factory()
|
||||||
|
obj_.build(child_)
|
||||||
|
self.parameterlist.append(obj_)
|
||||||
|
elif child_.nodeType == Node.ELEMENT_NODE and \
|
||||||
|
nodeName_ == 'simplesect':
|
||||||
|
obj_ = supermod.docSimpleSectType.factory()
|
||||||
|
obj_.build(child_)
|
||||||
|
self.simplesects.append(obj_)
|
||||||
|
|
||||||
|
|
||||||
|
supermod.docParaType.subclass = docParaTypeSub
|
||||||
|
# end class docParaTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
def parse(inFilename):
|
||||||
|
doc = minidom.parse(inFilename)
|
||||||
|
rootNode = doc.documentElement
|
||||||
|
rootObj = supermod.DoxygenType.factory()
|
||||||
|
rootObj.build(rootNode)
|
||||||
|
return rootObj
|
||||||
|
|
||||||
|
|
||||||
8342
gr-hamnet70/docs/doxygen/doxyxml/generated/compoundsuper.py
Normal file
8342
gr-hamnet70/docs/doxygen/doxyxml/generated/compoundsuper.py
Normal file
File diff suppressed because it is too large
Load diff
77
gr-hamnet70/docs/doxygen/doxyxml/generated/index.py
Normal file
77
gr-hamnet70/docs/doxygen/doxyxml/generated/index.py
Normal file
|
|
@ -0,0 +1,77 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
|
||||||
|
"""
|
||||||
|
Generated Mon Feb 9 19:08:05 2009 by generateDS.py.
|
||||||
|
"""
|
||||||
|
|
||||||
|
from xml.dom import minidom
|
||||||
|
|
||||||
|
import os
|
||||||
|
import sys
|
||||||
|
import compound
|
||||||
|
|
||||||
|
import indexsuper as supermod
|
||||||
|
|
||||||
|
class DoxygenTypeSub(supermod.DoxygenType):
|
||||||
|
def __init__(self, version=None, compound=None):
|
||||||
|
supermod.DoxygenType.__init__(self, version, compound)
|
||||||
|
|
||||||
|
def find_compounds_and_members(self, details):
|
||||||
|
"""
|
||||||
|
Returns a list of all compounds and their members which match details
|
||||||
|
"""
|
||||||
|
|
||||||
|
results = []
|
||||||
|
for compound in self.compound:
|
||||||
|
members = compound.find_members(details)
|
||||||
|
if members:
|
||||||
|
results.append([compound, members])
|
||||||
|
else:
|
||||||
|
if details.match(compound):
|
||||||
|
results.append([compound, []])
|
||||||
|
|
||||||
|
return results
|
||||||
|
|
||||||
|
supermod.DoxygenType.subclass = DoxygenTypeSub
|
||||||
|
# end class DoxygenTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class CompoundTypeSub(supermod.CompoundType):
|
||||||
|
def __init__(self, kind=None, refid=None, name='', member=None):
|
||||||
|
supermod.CompoundType.__init__(self, kind, refid, name, member)
|
||||||
|
|
||||||
|
def find_members(self, details):
|
||||||
|
"""
|
||||||
|
Returns a list of all members which match details
|
||||||
|
"""
|
||||||
|
|
||||||
|
results = []
|
||||||
|
|
||||||
|
for member in self.member:
|
||||||
|
if details.match(member):
|
||||||
|
results.append(member)
|
||||||
|
|
||||||
|
return results
|
||||||
|
|
||||||
|
supermod.CompoundType.subclass = CompoundTypeSub
|
||||||
|
# end class CompoundTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
class MemberTypeSub(supermod.MemberType):
|
||||||
|
|
||||||
|
def __init__(self, kind=None, refid=None, name=''):
|
||||||
|
supermod.MemberType.__init__(self, kind, refid, name)
|
||||||
|
|
||||||
|
supermod.MemberType.subclass = MemberTypeSub
|
||||||
|
# end class MemberTypeSub
|
||||||
|
|
||||||
|
|
||||||
|
def parse(inFilename):
|
||||||
|
|
||||||
|
doc = minidom.parse(inFilename)
|
||||||
|
rootNode = doc.documentElement
|
||||||
|
rootObj = supermod.DoxygenType.factory()
|
||||||
|
rootObj.build(rootNode)
|
||||||
|
|
||||||
|
return rootObj
|
||||||
|
|
||||||
523
gr-hamnet70/docs/doxygen/doxyxml/generated/indexsuper.py
Normal file
523
gr-hamnet70/docs/doxygen/doxyxml/generated/indexsuper.py
Normal file
|
|
@ -0,0 +1,523 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
|
||||||
|
#
|
||||||
|
# Generated Thu Jun 11 18:43:54 2009 by generateDS.py.
|
||||||
|
#
|
||||||
|
|
||||||
|
import sys
|
||||||
|
import getopt
|
||||||
|
from string import lower as str_lower
|
||||||
|
from xml.dom import minidom
|
||||||
|
from xml.dom import Node
|
||||||
|
|
||||||
|
#
|
||||||
|
# User methods
|
||||||
|
#
|
||||||
|
# Calls to the methods in these classes are generated by generateDS.py.
|
||||||
|
# You can replace these methods by re-implementing the following class
|
||||||
|
# in a module named generatedssuper.py.
|
||||||
|
|
||||||
|
try:
|
||||||
|
from generatedssuper import GeneratedsSuper
|
||||||
|
except ImportError, exp:
|
||||||
|
|
||||||
|
class GeneratedsSuper:
|
||||||
|
def format_string(self, input_data, input_name=''):
|
||||||
|
return input_data
|
||||||
|
def format_integer(self, input_data, input_name=''):
|
||||||
|
return '%d' % input_data
|
||||||
|
def format_float(self, input_data, input_name=''):
|
||||||
|
return '%f' % input_data
|
||||||
|
def format_double(self, input_data, input_name=''):
|
||||||
|
return '%e' % input_data
|
||||||
|
def format_boolean(self, input_data, input_name=''):
|
||||||
|
return '%s' % input_data
|
||||||
|
|
||||||
|
|
||||||
|
#
|
||||||
|
# If you have installed IPython you can uncomment and use the following.
|
||||||
|
# IPython is available from http://ipython.scipy.org/.
|
||||||
|
#
|
||||||
|
|
||||||
|
## from IPython.Shell import IPShellEmbed
|
||||||
|
## args = ''
|
||||||
|
## ipshell = IPShellEmbed(args,
|
||||||
|
## banner = 'Dropping into IPython',
|
||||||
|
## exit_msg = 'Leaving Interpreter, back to program.')
|
||||||
|
|
||||||
|
# Then use the following line where and when you want to drop into the
|
||||||
|
# IPython shell:
|
||||||
|
# ipshell('<some message> -- Entering ipshell.\nHit Ctrl-D to exit')
|
||||||
|
|
||||||
|
#
|
||||||
|
# Globals
|
||||||
|
#
|
||||||
|
|
||||||
|
ExternalEncoding = 'ascii'
|
||||||
|
|
||||||
|
#
|
||||||
|
# Support/utility functions.
|
||||||
|
#
|
||||||
|
|
||||||
|
def showIndent(outfile, level):
|
||||||
|
for idx in range(level):
|
||||||
|
outfile.write(' ')
|
||||||
|
|
||||||
|
def quote_xml(inStr):
|
||||||
|
s1 = (isinstance(inStr, basestring) and inStr or
|
||||||
|
'%s' % inStr)
|
||||||
|
s1 = s1.replace('&', '&')
|
||||||
|
s1 = s1.replace('<', '<')
|
||||||
|
s1 = s1.replace('>', '>')
|
||||||
|
return s1
|
||||||
|
|
||||||
|
def quote_attrib(inStr):
|
||||||
|
s1 = (isinstance(inStr, basestring) and inStr or
|
||||||
|
'%s' % inStr)
|
||||||
|
s1 = s1.replace('&', '&')
|
||||||
|
s1 = s1.replace('<', '<')
|
||||||
|
s1 = s1.replace('>', '>')
|
||||||
|
if '"' in s1:
|
||||||
|
if "'" in s1:
|
||||||
|
s1 = '"%s"' % s1.replace('"', """)
|
||||||
|
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()')
|
||||||
|
|
||||||
57
gr-hamnet70/docs/doxygen/doxyxml/text.py
Normal file
57
gr-hamnet70/docs/doxygen/doxyxml/text.py
Normal file
|
|
@ -0,0 +1,57 @@
|
||||||
|
#
|
||||||
|
# Copyright 2010 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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
|
||||||
7
gr-hamnet70/docs/doxygen/other/group_defs.dox
Normal file
7
gr-hamnet70/docs/doxygen/other/group_defs.dox
Normal file
|
|
@ -0,0 +1,7 @@
|
||||||
|
/*!
|
||||||
|
* \defgroup block GNU Radio HAMNET70 C++ Signal Processing Blocks
|
||||||
|
* \brief All C++ blocks that can be used from the HAMNET70 GNU Radio
|
||||||
|
* module are listed here or in the subcategories below.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
10
gr-hamnet70/docs/doxygen/other/main_page.dox
Normal file
10
gr-hamnet70/docs/doxygen/other/main_page.dox
Normal file
|
|
@ -0,0 +1,10 @@
|
||||||
|
/*! \mainpage
|
||||||
|
|
||||||
|
Welcome to the GNU Radio HAMNET70 Block
|
||||||
|
|
||||||
|
This is the intro page for the Doxygen manual generated for the HAMNET70
|
||||||
|
block (docs/doxygen/other/main_page.dox). Edit it to add more detailed
|
||||||
|
documentation about the new GNU Radio modules contained in this
|
||||||
|
project.
|
||||||
|
|
||||||
|
*/
|
||||||
329
gr-hamnet70/docs/doxygen/swig_doc.py
Normal file
329
gr-hamnet70/docs/doxygen/swig_doc.py
Normal file
|
|
@ -0,0 +1,329 @@
|
||||||
|
#
|
||||||
|
# Copyright 2010-2012 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# 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, time
|
||||||
|
|
||||||
|
from doxyxml import DoxyIndex, DoxyClass, DoxyFriend, DoxyFunction, DoxyFile
|
||||||
|
from doxyxml import DoxyOther, 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
|
||||||
|
friendname = make_name(item.name())
|
||||||
|
is_a_block = item.has_member(friendname, DoxyFriend)
|
||||||
|
# But now sometimes the make function isn't a friend so check again.
|
||||||
|
if not is_a_block:
|
||||||
|
is_a_block = di.has_member(friendname, DoxyFunction)
|
||||||
|
return is_a_block
|
||||||
|
|
||||||
|
class Block2(object):
|
||||||
|
"""
|
||||||
|
Checks if doxyxml produced objects correspond to a new style
|
||||||
|
gnuradio block.
|
||||||
|
"""
|
||||||
|
|
||||||
|
@classmethod
|
||||||
|
def includes(cls, item):
|
||||||
|
if not isinstance(item, DoxyClass):
|
||||||
|
return False
|
||||||
|
# Check for a parsing error.
|
||||||
|
if item.error():
|
||||||
|
return False
|
||||||
|
is_a_block2 = item.has_member('make', DoxyFunction) and item.has_member('sptr', DoxyOther)
|
||||||
|
return is_a_block2
|
||||||
|
|
||||||
|
|
||||||
|
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()
|
||||||
|
|
||||||
|
def format_params(parameteritems):
|
||||||
|
output = ['Args:']
|
||||||
|
template = ' {0} : {1}'
|
||||||
|
for pi in parameteritems:
|
||||||
|
output.append(template.format(pi.name, pi.description))
|
||||||
|
return '\n'.join(output)
|
||||||
|
|
||||||
|
entry_templ = '%feature("docstring") {name} "{docstring}"'
|
||||||
|
def make_entry(obj, name=None, templ="{description}", description=None, params=[]):
|
||||||
|
"""
|
||||||
|
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)
|
||||||
|
if params:
|
||||||
|
description += '\n\n'
|
||||||
|
description += utoascii(format_params(params))
|
||||||
|
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)
|
||||||
|
return make_entry(func, name=name, description=description, params=params)
|
||||||
|
|
||||||
|
|
||||||
|
def make_class_entry(klass, description=None, ignored_methods=[], params=None):
|
||||||
|
"""
|
||||||
|
Create a class docstring for a swig interface file.
|
||||||
|
"""
|
||||||
|
if params is None:
|
||||||
|
params = klass.params
|
||||||
|
output = []
|
||||||
|
output.append(make_entry(klass, description=description, params=params))
|
||||||
|
for func in klass.in_category(DoxyFunction):
|
||||||
|
if func.name() not in ignored_methods:
|
||||||
|
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))
|
||||||
|
output.append(make_func_entry(make_func, description=super_description,
|
||||||
|
params=block.params))
|
||||||
|
return "\n\n".join(output)
|
||||||
|
|
||||||
|
def make_block2_entry(di, block):
|
||||||
|
"""
|
||||||
|
Create class and function docstrings of a new style gnuradio block for a
|
||||||
|
swig interface file.
|
||||||
|
"""
|
||||||
|
descriptions = []
|
||||||
|
# For new style blocks all the relevant documentation should be
|
||||||
|
# associated with the 'make' method.
|
||||||
|
class_description = combine_descriptions(block)
|
||||||
|
make_func = block.get_member('make', DoxyFunction)
|
||||||
|
make_description = combine_descriptions(make_func)
|
||||||
|
description = class_description + "\n\nConstructor Specific Documentation:\n\n" + make_description
|
||||||
|
# Associate the combined description with the class and
|
||||||
|
# the make function.
|
||||||
|
output = []
|
||||||
|
output.append(make_class_entry(
|
||||||
|
block, description=description,
|
||||||
|
ignored_methods=['make'], params=make_func.params))
|
||||||
|
makename = block.name() + '::make'
|
||||||
|
output.append(make_func_entry(
|
||||||
|
make_func, name=makename, description=description,
|
||||||
|
params=make_func.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)
|
||||||
|
blocks2 = di.in_category(Block2)
|
||||||
|
|
||||||
|
make_funcs = set([])
|
||||||
|
for block in blocks:
|
||||||
|
try:
|
||||||
|
make_func = di.get_member(make_name(block.name()), DoxyFunction)
|
||||||
|
# Don't want to risk writing to output twice.
|
||||||
|
if make_func.name() not in make_funcs:
|
||||||
|
make_funcs.add(make_func.name())
|
||||||
|
output.append(make_block_entry(di, block))
|
||||||
|
except block.ParsingError:
|
||||||
|
sys.stderr.write('Parsing error for block {0}\n'.format(block.name()))
|
||||||
|
raise
|
||||||
|
|
||||||
|
for block in blocks2:
|
||||||
|
try:
|
||||||
|
make_func = block.get_member('make', DoxyFunction)
|
||||||
|
make_func_name = block.name() +'::make'
|
||||||
|
# Don't want to risk writing to output twice.
|
||||||
|
if make_func_name not in make_funcs:
|
||||||
|
make_funcs.add(make_func_name)
|
||||||
|
output.append(make_block2_entry(di, block))
|
||||||
|
except block.ParsingError:
|
||||||
|
sys.stderr.write('Parsing error for block {0}\n'.format(block.name()))
|
||||||
|
raise
|
||||||
|
|
||||||
|
# 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 and not f.name().startswith('std::')]
|
||||||
|
for f in funcs:
|
||||||
|
try:
|
||||||
|
output.append(make_func_entry(f))
|
||||||
|
except f.ParsingError:
|
||||||
|
sys.stderr.write('Parsing error for function {0}\n'.format(f.name()))
|
||||||
|
|
||||||
|
# Create docstrings for classes
|
||||||
|
block_names = [block.name() for block in blocks]
|
||||||
|
block_names += [block.name() for block in blocks2]
|
||||||
|
klasses = [k for k in di.in_category(DoxyClass)
|
||||||
|
if k.name() not in block_names and not k.name().startswith('std::')]
|
||||||
|
for k in klasses:
|
||||||
|
try:
|
||||||
|
output.append(make_class_entry(k))
|
||||||
|
except k.ParsingError:
|
||||||
|
sys.stderr.write('Parsing error for class {0}\n'.format(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)
|
||||||
4
gr-hamnet70/examples/README
Normal file
4
gr-hamnet70/examples/README
Normal file
|
|
@ -0,0 +1,4 @@
|
||||||
|
It is considered good practice to add examples in here to demonstrate the
|
||||||
|
functionality of your OOT module. Python scripts, GRC flow graphs or other
|
||||||
|
code can go here.
|
||||||
|
|
||||||
23
gr-hamnet70/grc/CMakeLists.txt
Normal file
23
gr-hamnet70/grc/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,23 @@
|
||||||
|
# Copyright 2011 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
# Boston, MA 02110-1301, USA.
|
||||||
|
|
||||||
|
install(FILES
|
||||||
|
hamnet70_correct_phase_from_tag.xml DESTINATION share/gnuradio/grc/blocks
|
||||||
|
)
|
||||||
38
gr-hamnet70/grc/hamnet70_correct_phase_from_tag.xml
Normal file
38
gr-hamnet70/grc/hamnet70_correct_phase_from_tag.xml
Normal file
|
|
@ -0,0 +1,38 @@
|
||||||
|
<?xml version="1.0"?>
|
||||||
|
<block>
|
||||||
|
<name>correct_phase_from_tag</name>
|
||||||
|
<key>hamnet70_correct_phase_from_tag</key>
|
||||||
|
<category>[hamnet70]</category>
|
||||||
|
<import>import hamnet70</import>
|
||||||
|
<make>hamnet70.correct_phase_from_tag($phase_tag_name)</make>
|
||||||
|
<!-- Make one 'param' node for every Parameter you want settable from the GUI.
|
||||||
|
Sub-nodes:
|
||||||
|
* name
|
||||||
|
* key (makes the value accessible as $keyname, e.g. in the make node)
|
||||||
|
* type -->
|
||||||
|
<param>
|
||||||
|
<name>Phase Tag</name>
|
||||||
|
<key>phase_tag_name</key>
|
||||||
|
<type>string</type>
|
||||||
|
</param>
|
||||||
|
|
||||||
|
<!-- Make one 'sink' node per input. Sub-nodes:
|
||||||
|
* name (an identifier for the GUI)
|
||||||
|
* type
|
||||||
|
* vlen
|
||||||
|
* optional (set to 1 for optional inputs) -->
|
||||||
|
<sink>
|
||||||
|
<name>in</name>
|
||||||
|
<type>complex</type>
|
||||||
|
</sink>
|
||||||
|
|
||||||
|
<!-- Make one 'source' node per output. Sub-nodes:
|
||||||
|
* name (an identifier for the GUI)
|
||||||
|
* type
|
||||||
|
* vlen
|
||||||
|
* optional (set to 1 for optional inputs) -->
|
||||||
|
<source>
|
||||||
|
<name>out</name>
|
||||||
|
<type>complex</type>
|
||||||
|
</source>
|
||||||
|
</block>
|
||||||
27
gr-hamnet70/include/hamnet70/CMakeLists.txt
Normal file
27
gr-hamnet70/include/hamnet70/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,27 @@
|
||||||
|
# Copyright 2011,2012 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
# Boston, MA 02110-1301, USA.
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Install public header files
|
||||||
|
########################################################################
|
||||||
|
install(FILES
|
||||||
|
api.h
|
||||||
|
correct_phase_from_tag.h DESTINATION include/hamnet70
|
||||||
|
)
|
||||||
34
gr-hamnet70/include/hamnet70/api.h
Normal file
34
gr-hamnet70/include/hamnet70/api.h
Normal file
|
|
@ -0,0 +1,34 @@
|
||||||
|
/*
|
||||||
|
* Copyright 2011 Free Software Foundation, Inc.
|
||||||
|
*
|
||||||
|
* This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
* This file is a part of gr-hamnet70
|
||||||
|
*
|
||||||
|
* GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
* it under the terms of the GNU General Public License as published by
|
||||||
|
* the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
* any later version.
|
||||||
|
*
|
||||||
|
* GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License
|
||||||
|
* along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
* Boston, MA 02110-1301, USA.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef INCLUDED_HAMNET70_API_H
|
||||||
|
#define INCLUDED_HAMNET70_API_H
|
||||||
|
|
||||||
|
#include <gnuradio/attributes.h>
|
||||||
|
|
||||||
|
#ifdef gnuradio_hamnet70_EXPORTS
|
||||||
|
# define HAMNET70_API __GR_ATTR_EXPORT
|
||||||
|
#else
|
||||||
|
# define HAMNET70_API __GR_ATTR_IMPORT
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#endif /* INCLUDED_HAMNET70_API_H */
|
||||||
56
gr-hamnet70/include/hamnet70/correct_phase_from_tag.h
Normal file
56
gr-hamnet70/include/hamnet70/correct_phase_from_tag.h
Normal file
|
|
@ -0,0 +1,56 @@
|
||||||
|
/* -*- c++ -*- */
|
||||||
|
/*
|
||||||
|
* Copyright 2019 Thomas Kolb.
|
||||||
|
*
|
||||||
|
* 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_HAMNET70_CORRECT_PHASE_FROM_TAG_H
|
||||||
|
#define INCLUDED_HAMNET70_CORRECT_PHASE_FROM_TAG_H
|
||||||
|
|
||||||
|
#include <hamnet70/api.h>
|
||||||
|
#include <gnuradio/sync_block.h>
|
||||||
|
|
||||||
|
namespace gr {
|
||||||
|
namespace hamnet70 {
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Rotate the phase by the value specified in the given tag.
|
||||||
|
* \ingroup hamnet70
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
class HAMNET70_API correct_phase_from_tag : virtual public gr::sync_block
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef boost::shared_ptr<correct_phase_from_tag> sptr;
|
||||||
|
|
||||||
|
/*!
|
||||||
|
* \brief Return a shared_ptr to a new instance of hamnet70::correct_phase_from_tag.
|
||||||
|
*
|
||||||
|
* To avoid accidental use of raw pointers, hamnet70::correct_phase_from_tag's
|
||||||
|
* constructor is in a private implementation
|
||||||
|
* class. hamnet70::correct_phase_from_tag::make is the public interface for
|
||||||
|
* creating new instances.
|
||||||
|
*/
|
||||||
|
static sptr make(const std::string &phase_tag_name = "phase_est");
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace hamnet70
|
||||||
|
} // namespace gr
|
||||||
|
|
||||||
|
#endif /* INCLUDED_HAMNET70_CORRECT_PHASE_FROM_TAG_H */
|
||||||
|
|
||||||
84
gr-hamnet70/lib/CMakeLists.txt
Normal file
84
gr-hamnet70/lib/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,84 @@
|
||||||
|
# Copyright 2011,2012,2016 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
# Boston, MA 02110-1301, USA.
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Setup library
|
||||||
|
########################################################################
|
||||||
|
include(GrPlatform) #define LIB_SUFFIX
|
||||||
|
|
||||||
|
include_directories(${Boost_INCLUDE_DIR})
|
||||||
|
link_directories(${Boost_LIBRARY_DIRS})
|
||||||
|
|
||||||
|
list(APPEND hamnet70_sources
|
||||||
|
correct_phase_from_tag_impl.cc
|
||||||
|
)
|
||||||
|
|
||||||
|
set(hamnet70_sources "${hamnet70_sources}" PARENT_SCOPE)
|
||||||
|
if(NOT hamnet70_sources)
|
||||||
|
MESSAGE(STATUS "No C++ sources... skipping lib/")
|
||||||
|
return()
|
||||||
|
endif(NOT hamnet70_sources)
|
||||||
|
|
||||||
|
add_library(gnuradio-hamnet70 SHARED ${hamnet70_sources})
|
||||||
|
target_link_libraries(gnuradio-hamnet70 ${Boost_LIBRARIES} ${GNURADIO_ALL_LIBRARIES})
|
||||||
|
set_target_properties(gnuradio-hamnet70 PROPERTIES DEFINE_SYMBOL "gnuradio_hamnet70_EXPORTS")
|
||||||
|
|
||||||
|
if(APPLE)
|
||||||
|
set_target_properties(gnuradio-hamnet70 PROPERTIES
|
||||||
|
INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib"
|
||||||
|
)
|
||||||
|
endif(APPLE)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Install built library files
|
||||||
|
########################################################################
|
||||||
|
include(GrMiscUtils)
|
||||||
|
GR_LIBRARY_FOO(gnuradio-hamnet70 RUNTIME_COMPONENT "hamnet70_runtime" DEVEL_COMPONENT "hamnet70_devel")
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Build and register unit test
|
||||||
|
########################################################################
|
||||||
|
include(GrTest)
|
||||||
|
|
||||||
|
include_directories(${CPPUNIT_INCLUDE_DIRS})
|
||||||
|
|
||||||
|
list(APPEND test_hamnet70_sources
|
||||||
|
${CMAKE_CURRENT_SOURCE_DIR}/test_hamnet70.cc
|
||||||
|
${CMAKE_CURRENT_SOURCE_DIR}/qa_hamnet70.cc
|
||||||
|
)
|
||||||
|
|
||||||
|
add_executable(test-hamnet70 ${test_hamnet70_sources})
|
||||||
|
|
||||||
|
target_link_libraries(
|
||||||
|
test-hamnet70
|
||||||
|
${GNURADIO_RUNTIME_LIBRARIES}
|
||||||
|
${Boost_LIBRARIES}
|
||||||
|
${CPPUNIT_LIBRARIES}
|
||||||
|
gnuradio-hamnet70
|
||||||
|
)
|
||||||
|
|
||||||
|
#GR_ADD_TEST(test_hamnet70 test-hamnet70)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Print summary
|
||||||
|
########################################################################
|
||||||
|
message(STATUS "Using install prefix: ${CMAKE_INSTALL_PREFIX}")
|
||||||
|
message(STATUS "Building for version: ${VERSION} / ${LIBVER}")
|
||||||
|
|
||||||
95
gr-hamnet70/lib/correct_phase_from_tag_impl.cc
Normal file
95
gr-hamnet70/lib/correct_phase_from_tag_impl.cc
Normal file
|
|
@ -0,0 +1,95 @@
|
||||||
|
/* -*- c++ -*- */
|
||||||
|
/*
|
||||||
|
* Copyright 2019 Thomas Kolb.
|
||||||
|
*
|
||||||
|
* 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 <gnuradio/expj.h>
|
||||||
|
#include "correct_phase_from_tag_impl.h"
|
||||||
|
|
||||||
|
namespace gr {
|
||||||
|
namespace hamnet70 {
|
||||||
|
|
||||||
|
correct_phase_from_tag::sptr
|
||||||
|
correct_phase_from_tag::make(const std::string &phase_tag_name)
|
||||||
|
{
|
||||||
|
return gnuradio::get_initial_sptr
|
||||||
|
(new correct_phase_from_tag_impl(phase_tag_name));
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The private constructor
|
||||||
|
*/
|
||||||
|
correct_phase_from_tag_impl::correct_phase_from_tag_impl(const std::string &phase_tag_name)
|
||||||
|
: gr::sync_block("correct_phase_from_tag",
|
||||||
|
gr::io_signature::make(1, 1, sizeof(gr_complex)),
|
||||||
|
gr::io_signature::make(1, 1, sizeof(gr_complex))),
|
||||||
|
m_pmtPhaseTagName(pmt::intern(phase_tag_name)),
|
||||||
|
m_rotation(1, 0)
|
||||||
|
{}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Our virtual destructor.
|
||||||
|
*/
|
||||||
|
correct_phase_from_tag_impl::~correct_phase_from_tag_impl()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
int
|
||||||
|
correct_phase_from_tag_impl::work(int noutput_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];
|
||||||
|
|
||||||
|
std::vector<tag_t> tags;
|
||||||
|
get_tags_in_window(tags, 0, 0, noutput_items, m_pmtPhaseTagName);
|
||||||
|
|
||||||
|
std::cerr << "correct_phase_from_tag: Found " << tags.size() << " tags." << std::endl;
|
||||||
|
|
||||||
|
size_t tagidx = 0;
|
||||||
|
|
||||||
|
// rotate the data by the last set phase angle
|
||||||
|
for(int i = 0; i < noutput_items; i++) {
|
||||||
|
if((tagidx < tags.size()) && (tags[tagidx].offset == nitems_read(0) + i)) {
|
||||||
|
double phase = pmt::to_double(tags[tagidx].value);
|
||||||
|
m_rotation = gr_expj(-phase);
|
||||||
|
|
||||||
|
std::cerr << "correct_phase_from_tag: Updated phase correction to " << -phase << std::endl;
|
||||||
|
|
||||||
|
tagidx++;
|
||||||
|
}
|
||||||
|
|
||||||
|
out[i] = in[i] * m_rotation;
|
||||||
|
}
|
||||||
|
|
||||||
|
for(size_t i = 0; i < tags.size(); i++) {
|
||||||
|
}
|
||||||
|
|
||||||
|
// Tell runtime system how many output items we produced.
|
||||||
|
return noutput_items;
|
||||||
|
}
|
||||||
|
|
||||||
|
} /* namespace hamnet70 */
|
||||||
|
} /* namespace gr */
|
||||||
|
|
||||||
50
gr-hamnet70/lib/correct_phase_from_tag_impl.h
Normal file
50
gr-hamnet70/lib/correct_phase_from_tag_impl.h
Normal file
|
|
@ -0,0 +1,50 @@
|
||||||
|
/* -*- c++ -*- */
|
||||||
|
/*
|
||||||
|
* Copyright 2019 Thomas Kolb.
|
||||||
|
*
|
||||||
|
* 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_HAMNET70_CORRECT_PHASE_FROM_TAG_IMPL_H
|
||||||
|
#define INCLUDED_HAMNET70_CORRECT_PHASE_FROM_TAG_IMPL_H
|
||||||
|
|
||||||
|
#include <hamnet70/correct_phase_from_tag.h>
|
||||||
|
#include <pmt/pmt.h>
|
||||||
|
|
||||||
|
namespace gr {
|
||||||
|
namespace hamnet70 {
|
||||||
|
|
||||||
|
class correct_phase_from_tag_impl : public correct_phase_from_tag
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
pmt::pmt_t m_pmtPhaseTagName;
|
||||||
|
gr_complex m_rotation;
|
||||||
|
|
||||||
|
public:
|
||||||
|
correct_phase_from_tag_impl(const std::string &phase_tag_name);
|
||||||
|
~correct_phase_from_tag_impl();
|
||||||
|
|
||||||
|
// Where all the action really happens
|
||||||
|
int work(int noutput_items,
|
||||||
|
gr_vector_const_void_star &input_items,
|
||||||
|
gr_vector_void_star &output_items);
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace hamnet70
|
||||||
|
} // namespace gr
|
||||||
|
|
||||||
|
#endif /* INCLUDED_HAMNET70_CORRECT_PHASE_FROM_TAG_IMPL_H */
|
||||||
|
|
||||||
37
gr-hamnet70/lib/qa_hamnet70.cc
Normal file
37
gr-hamnet70/lib/qa_hamnet70.cc
Normal file
|
|
@ -0,0 +1,37 @@
|
||||||
|
/*
|
||||||
|
* Copyright 2012 Free Software Foundation, Inc.
|
||||||
|
*
|
||||||
|
* This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
* This file is a part of gr-hamnet70
|
||||||
|
*
|
||||||
|
* GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
* it under the terms of the GNU General Public License as published by
|
||||||
|
* the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
* any later version.
|
||||||
|
*
|
||||||
|
* GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License
|
||||||
|
* along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
* Boston, MA 02110-1301, USA.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/*
|
||||||
|
* This class gathers together all the test cases for the gr-filter
|
||||||
|
* directory into a single test suite. As you create new test cases,
|
||||||
|
* add them here.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "qa_hamnet70.h"
|
||||||
|
|
||||||
|
CppUnit::TestSuite *
|
||||||
|
qa_hamnet70::suite()
|
||||||
|
{
|
||||||
|
CppUnit::TestSuite *s = new CppUnit::TestSuite("hamnet70");
|
||||||
|
|
||||||
|
return s;
|
||||||
|
}
|
||||||
39
gr-hamnet70/lib/qa_hamnet70.h
Normal file
39
gr-hamnet70/lib/qa_hamnet70.h
Normal file
|
|
@ -0,0 +1,39 @@
|
||||||
|
/* -*- c++ -*- */
|
||||||
|
/*
|
||||||
|
* Copyright 2012 Free Software Foundation, Inc.
|
||||||
|
*
|
||||||
|
* This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
* This file is a part of gr-hamnet70
|
||||||
|
*
|
||||||
|
* GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
* it under the terms of the GNU General Public License as published by
|
||||||
|
* the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
* any later version.
|
||||||
|
*
|
||||||
|
* GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License
|
||||||
|
* along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
* Boston, MA 02110-1301, USA.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef _QA_HAMNET70_H_
|
||||||
|
#define _QA_HAMNET70_H_
|
||||||
|
|
||||||
|
#include <gnuradio/attributes.h>
|
||||||
|
#include <cppunit/TestSuite.h>
|
||||||
|
|
||||||
|
//! collect all the tests for the gr-filter directory
|
||||||
|
|
||||||
|
class __GR_ATTR_EXPORT qa_hamnet70
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
//! return suite of tests for all of gr-filter directory
|
||||||
|
static CppUnit::TestSuite *suite();
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif /* _QA_HAMNET70_H_ */
|
||||||
49
gr-hamnet70/lib/test_hamnet70.cc
Normal file
49
gr-hamnet70/lib/test_hamnet70.cc
Normal file
|
|
@ -0,0 +1,49 @@
|
||||||
|
/* -*- c++ -*- */
|
||||||
|
/*
|
||||||
|
* Copyright 2012 Free Software Foundation, Inc.
|
||||||
|
*
|
||||||
|
* This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
* This file is a part of gr-hamnet70
|
||||||
|
*
|
||||||
|
* GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
* it under the terms of the GNU General Public License as published by
|
||||||
|
* the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
* any later version.
|
||||||
|
*
|
||||||
|
* GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License
|
||||||
|
* along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
* Boston, MA 02110-1301, USA.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifdef HAVE_CONFIG_H
|
||||||
|
#include "config.h"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#include <cppunit/TextTestRunner.h>
|
||||||
|
#include <cppunit/XmlOutputter.h>
|
||||||
|
|
||||||
|
#include <gnuradio/unittests.h>
|
||||||
|
#include "qa_hamnet70.h"
|
||||||
|
#include <iostream>
|
||||||
|
#include <fstream>
|
||||||
|
|
||||||
|
int
|
||||||
|
main (int argc, char **argv)
|
||||||
|
{
|
||||||
|
CppUnit::TextTestRunner runner;
|
||||||
|
std::ofstream xmlfile(get_unittest_path("hamnet70.xml").c_str());
|
||||||
|
CppUnit::XmlOutputter *xmlout = new CppUnit::XmlOutputter(&runner.result(), xmlfile);
|
||||||
|
|
||||||
|
runner.addTest(qa_hamnet70::suite());
|
||||||
|
runner.setOutputter(xmlout);
|
||||||
|
|
||||||
|
bool was_successful = runner.run("", false);
|
||||||
|
|
||||||
|
return was_successful ? 0 : 1;
|
||||||
|
}
|
||||||
6
gr-hamnet70/make.sh
Executable file
6
gr-hamnet70/make.sh
Executable file
|
|
@ -0,0 +1,6 @@
|
||||||
|
#!/bin/sh
|
||||||
|
|
||||||
|
mkdir -p build
|
||||||
|
cd build
|
||||||
|
cmake ..
|
||||||
|
make -j4
|
||||||
45
gr-hamnet70/python/CMakeLists.txt
Normal file
45
gr-hamnet70/python/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,45 @@
|
||||||
|
# Copyright 2011 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
# Boston, MA 02110-1301, USA.
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Include python install macros
|
||||||
|
########################################################################
|
||||||
|
include(GrPython)
|
||||||
|
if(NOT PYTHONINTERP_FOUND)
|
||||||
|
return()
|
||||||
|
endif()
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Install python sources
|
||||||
|
########################################################################
|
||||||
|
GR_PYTHON_INSTALL(
|
||||||
|
FILES
|
||||||
|
__init__.py
|
||||||
|
DESTINATION ${GR_PYTHON_DIR}/hamnet70
|
||||||
|
)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Handle the unit tests
|
||||||
|
########################################################################
|
||||||
|
include(GrTest)
|
||||||
|
|
||||||
|
set(GR_TEST_TARGET_DEPS gnuradio-hamnet70)
|
||||||
|
set(GR_TEST_PYTHON_DIRS ${CMAKE_BINARY_DIR}/swig)
|
||||||
|
#GR_ADD_TEST(qa_correct_phase_from_tag ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/qa_correct_phase_from_tag.py)
|
||||||
36
gr-hamnet70/python/__init__.py
Normal file
36
gr-hamnet70/python/__init__.py
Normal file
|
|
@ -0,0 +1,36 @@
|
||||||
|
#
|
||||||
|
# Copyright 2008,2009 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This application is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# This application is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License along
|
||||||
|
# with this program; if not, write to the Free Software Foundation, Inc.,
|
||||||
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||||
|
#
|
||||||
|
|
||||||
|
# The presence of this file turns this directory into a Python package
|
||||||
|
|
||||||
|
'''
|
||||||
|
This is the GNU Radio HAMNET70 module. Place your Python package
|
||||||
|
description here (python/__init__.py).
|
||||||
|
'''
|
||||||
|
|
||||||
|
## import swig generated symbols into the hamnet70 namespace
|
||||||
|
#try:
|
||||||
|
# # this might fail if the module is python-only
|
||||||
|
# from hamnet70_swig import *
|
||||||
|
#except ImportError:
|
||||||
|
# pass
|
||||||
|
|
||||||
|
from hamnet70_swig import *
|
||||||
|
|
||||||
|
# import any pure python here
|
||||||
|
#
|
||||||
227
gr-hamnet70/python/build_utils.py
Normal file
227
gr-hamnet70/python/build_utils.py
Normal file
|
|
@ -0,0 +1,227 @@
|
||||||
|
#
|
||||||
|
# Copyright 2004,2009,2012 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
# Boston, MA 02110-1301, USA.
|
||||||
|
#
|
||||||
|
|
||||||
|
"""Misc utilities used at build time
|
||||||
|
"""
|
||||||
|
|
||||||
|
import re, os, os.path
|
||||||
|
from build_utils_codes import *
|
||||||
|
|
||||||
|
|
||||||
|
# set srcdir to the directory that contains Makefile.am
|
||||||
|
try:
|
||||||
|
srcdir = os.environ['srcdir']
|
||||||
|
except KeyError, e:
|
||||||
|
srcdir = "."
|
||||||
|
srcdir = srcdir + '/'
|
||||||
|
|
||||||
|
# set do_makefile to either true or false dependeing on the environment
|
||||||
|
try:
|
||||||
|
if os.environ['do_makefile'] == '0':
|
||||||
|
do_makefile = False
|
||||||
|
else:
|
||||||
|
do_makefile = True
|
||||||
|
except KeyError, e:
|
||||||
|
do_makefile = False
|
||||||
|
|
||||||
|
# set do_sources to either true or false dependeing on the environment
|
||||||
|
try:
|
||||||
|
if os.environ['do_sources'] == '0':
|
||||||
|
do_sources = False
|
||||||
|
else:
|
||||||
|
do_sources = True
|
||||||
|
except KeyError, e:
|
||||||
|
do_sources = True
|
||||||
|
|
||||||
|
name_dict = {}
|
||||||
|
|
||||||
|
def log_output_name (name):
|
||||||
|
(base, ext) = os.path.splitext (name)
|
||||||
|
ext = ext[1:] # drop the leading '.'
|
||||||
|
|
||||||
|
entry = name_dict.setdefault (ext, [])
|
||||||
|
entry.append (name)
|
||||||
|
|
||||||
|
def open_and_log_name (name, dir):
|
||||||
|
global do_sources
|
||||||
|
if do_sources:
|
||||||
|
f = open (name, dir)
|
||||||
|
else:
|
||||||
|
f = None
|
||||||
|
log_output_name (name)
|
||||||
|
return f
|
||||||
|
|
||||||
|
def expand_template (d, template_filename, extra = ""):
|
||||||
|
'''Given a dictionary D and a TEMPLATE_FILENAME, expand template into output file
|
||||||
|
'''
|
||||||
|
global do_sources
|
||||||
|
output_extension = extract_extension (template_filename)
|
||||||
|
template = open_src (template_filename, 'r')
|
||||||
|
output_name = d['NAME'] + extra + '.' + output_extension
|
||||||
|
log_output_name (output_name)
|
||||||
|
if do_sources:
|
||||||
|
output = open (output_name, 'w')
|
||||||
|
do_substitution (d, template, output)
|
||||||
|
output.close ()
|
||||||
|
template.close ()
|
||||||
|
|
||||||
|
def output_glue (dirname):
|
||||||
|
output_makefile_fragment ()
|
||||||
|
output_ifile_include (dirname)
|
||||||
|
|
||||||
|
def output_makefile_fragment ():
|
||||||
|
global do_makefile
|
||||||
|
if not do_makefile:
|
||||||
|
return
|
||||||
|
# overwrite the source, which must be writable; this should have been
|
||||||
|
# checked for beforehand in the top-level Makefile.gen.gen .
|
||||||
|
f = open (os.path.join (os.environ.get('gendir', os.environ.get('srcdir', '.')), 'Makefile.gen'), 'w')
|
||||||
|
f.write ('#\n# This file is machine generated. All edits will be overwritten\n#\n')
|
||||||
|
output_subfrag (f, 'h')
|
||||||
|
output_subfrag (f, 'i')
|
||||||
|
output_subfrag (f, 'cc')
|
||||||
|
f.close ()
|
||||||
|
|
||||||
|
def output_ifile_include (dirname):
|
||||||
|
global do_sources
|
||||||
|
if do_sources:
|
||||||
|
f = open ('%s_generated.i' % (dirname,), 'w')
|
||||||
|
f.write ('//\n// This file is machine generated. All edits will be overwritten\n//\n')
|
||||||
|
files = name_dict.setdefault ('i', [])
|
||||||
|
files.sort ()
|
||||||
|
f.write ('%{\n')
|
||||||
|
for file in files:
|
||||||
|
f.write ('#include <%s>\n' % (file[0:-1] + 'h',))
|
||||||
|
f.write ('%}\n\n')
|
||||||
|
for file in files:
|
||||||
|
f.write ('%%include <%s>\n' % (file,))
|
||||||
|
|
||||||
|
def output_subfrag (f, ext):
|
||||||
|
files = name_dict.setdefault (ext, [])
|
||||||
|
files.sort ()
|
||||||
|
f.write ("GENERATED_%s =" % (ext.upper ()))
|
||||||
|
for file in files:
|
||||||
|
f.write (" \\\n\t%s" % (file,))
|
||||||
|
f.write ("\n\n")
|
||||||
|
|
||||||
|
def extract_extension (template_name):
|
||||||
|
# template name is something like: GrFIRfilterXXX.h.t
|
||||||
|
# we return everything between the penultimate . and .t
|
||||||
|
mo = re.search (r'\.([a-z]+)\.t$', template_name)
|
||||||
|
if not mo:
|
||||||
|
raise ValueError, "Incorrectly formed template_name '%s'" % (template_name,)
|
||||||
|
return mo.group (1)
|
||||||
|
|
||||||
|
def open_src (name, mode):
|
||||||
|
global srcdir
|
||||||
|
return open (os.path.join (srcdir, name), mode)
|
||||||
|
|
||||||
|
def do_substitution (d, in_file, out_file):
|
||||||
|
def repl (match_obj):
|
||||||
|
key = match_obj.group (1)
|
||||||
|
# print key
|
||||||
|
return d[key]
|
||||||
|
|
||||||
|
inp = in_file.read ()
|
||||||
|
out = re.sub (r"@([a-zA-Z0-9_]+)@", repl, inp)
|
||||||
|
out_file.write (out)
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
copyright = '''/* -*- c++ -*- */
|
||||||
|
/*
|
||||||
|
* Copyright 2003,2004 Free Software Foundation, Inc.
|
||||||
|
*
|
||||||
|
* This file is part of GNU Radio
|
||||||
|
*
|
||||||
|
* GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
* it under the terms of the GNU General Public License as published by
|
||||||
|
* the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
* any later version.
|
||||||
|
*
|
||||||
|
* GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
* GNU General Public License for more details.
|
||||||
|
*
|
||||||
|
* You should have received a copy of the GNU General Public License
|
||||||
|
* along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
* the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
* Boston, MA 02110-1301, USA.
|
||||||
|
*/
|
||||||
|
'''
|
||||||
|
|
||||||
|
def is_complex (code3):
|
||||||
|
if i_code (code3) == 'c' or o_code (code3) == 'c':
|
||||||
|
return '1'
|
||||||
|
else:
|
||||||
|
return '0'
|
||||||
|
|
||||||
|
|
||||||
|
def standard_dict (name, code3, package='gr'):
|
||||||
|
d = {}
|
||||||
|
d['NAME'] = name
|
||||||
|
d['NAME_IMPL'] = name+'_impl'
|
||||||
|
d['GUARD_NAME'] = 'INCLUDED_%s_%s_H' % (package.upper(), name.upper())
|
||||||
|
d['GUARD_NAME_IMPL'] = 'INCLUDED_%s_%s_IMPL_H' % (package.upper(), name.upper())
|
||||||
|
d['BASE_NAME'] = re.sub ('^' + package + '_', '', name)
|
||||||
|
d['SPTR_NAME'] = '%s_sptr' % name
|
||||||
|
d['WARNING'] = 'WARNING: this file is machine generated. Edits will be overwritten'
|
||||||
|
d['COPYRIGHT'] = copyright
|
||||||
|
d['TYPE'] = i_type (code3)
|
||||||
|
d['I_TYPE'] = i_type (code3)
|
||||||
|
d['O_TYPE'] = o_type (code3)
|
||||||
|
d['TAP_TYPE'] = tap_type (code3)
|
||||||
|
d['IS_COMPLEX'] = is_complex (code3)
|
||||||
|
return d
|
||||||
|
|
||||||
|
|
||||||
|
def standard_dict2 (name, code3, package):
|
||||||
|
d = {}
|
||||||
|
d['NAME'] = name
|
||||||
|
d['BASE_NAME'] = name
|
||||||
|
d['GUARD_NAME'] = 'INCLUDED_%s_%s_H' % (package.upper(), name.upper())
|
||||||
|
d['WARNING'] = 'WARNING: this file is machine generated. Edits will be overwritten'
|
||||||
|
d['COPYRIGHT'] = copyright
|
||||||
|
d['TYPE'] = i_type (code3)
|
||||||
|
d['I_TYPE'] = i_type (code3)
|
||||||
|
d['O_TYPE'] = o_type (code3)
|
||||||
|
d['TAP_TYPE'] = tap_type (code3)
|
||||||
|
d['IS_COMPLEX'] = is_complex (code3)
|
||||||
|
return d
|
||||||
|
|
||||||
|
def standard_impl_dict2 (name, code3, package):
|
||||||
|
d = {}
|
||||||
|
d['NAME'] = name
|
||||||
|
d['IMPL_NAME'] = name
|
||||||
|
d['BASE_NAME'] = name.rstrip("impl").rstrip("_")
|
||||||
|
d['GUARD_NAME'] = 'INCLUDED_%s_%s_H' % (package.upper(), name.upper())
|
||||||
|
d['WARNING'] = 'WARNING: this file is machine generated. Edits will be overwritten'
|
||||||
|
d['COPYRIGHT'] = copyright
|
||||||
|
d['FIR_TYPE'] = "fir_filter_" + code3
|
||||||
|
d['CFIR_TYPE'] = "fir_filter_" + code3[0:2] + 'c'
|
||||||
|
d['TYPE'] = i_type (code3)
|
||||||
|
d['I_TYPE'] = i_type (code3)
|
||||||
|
d['O_TYPE'] = o_type (code3)
|
||||||
|
d['TAP_TYPE'] = tap_type (code3)
|
||||||
|
d['IS_COMPLEX'] = is_complex (code3)
|
||||||
|
return d
|
||||||
53
gr-hamnet70/python/build_utils_codes.py
Normal file
53
gr-hamnet70/python/build_utils_codes.py
Normal file
|
|
@ -0,0 +1,53 @@
|
||||||
|
#
|
||||||
|
# Copyright 2004 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
# Boston, MA 02110-1301, USA.
|
||||||
|
#
|
||||||
|
|
||||||
|
def i_code (code3):
|
||||||
|
return code3[0]
|
||||||
|
|
||||||
|
def o_code (code3):
|
||||||
|
if len (code3) >= 2:
|
||||||
|
return code3[1]
|
||||||
|
else:
|
||||||
|
return code3[0]
|
||||||
|
|
||||||
|
def tap_code (code3):
|
||||||
|
if len (code3) >= 3:
|
||||||
|
return code3[2]
|
||||||
|
else:
|
||||||
|
return code3[0]
|
||||||
|
|
||||||
|
def i_type (code3):
|
||||||
|
return char_to_type[i_code (code3)]
|
||||||
|
|
||||||
|
def o_type (code3):
|
||||||
|
return char_to_type[o_code (code3)]
|
||||||
|
|
||||||
|
def tap_type (code3):
|
||||||
|
return char_to_type[tap_code (code3)]
|
||||||
|
|
||||||
|
|
||||||
|
char_to_type = {}
|
||||||
|
char_to_type['s'] = 'short'
|
||||||
|
char_to_type['i'] = 'int'
|
||||||
|
char_to_type['f'] = 'float'
|
||||||
|
char_to_type['c'] = 'gr_complex'
|
||||||
|
char_to_type['b'] = 'unsigned char'
|
||||||
41
gr-hamnet70/python/qa_correct_phase_from_tag.py
Executable file
41
gr-hamnet70/python/qa_correct_phase_from_tag.py
Executable file
|
|
@ -0,0 +1,41 @@
|
||||||
|
#!/usr/bin/env python
|
||||||
|
# -*- coding: utf-8 -*-
|
||||||
|
#
|
||||||
|
# Copyright 2019 Thomas Kolb.
|
||||||
|
#
|
||||||
|
# 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 hamnet70_swig as hamnet70
|
||||||
|
|
||||||
|
class qa_correct_phase_from_tag (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_correct_phase_from_tag, "qa_correct_phase_from_tag.xml")
|
||||||
66
gr-hamnet70/swig/CMakeLists.txt
Normal file
66
gr-hamnet70/swig/CMakeLists.txt
Normal file
|
|
@ -0,0 +1,66 @@
|
||||||
|
# Copyright 2011 Free Software Foundation, Inc.
|
||||||
|
#
|
||||||
|
# This file was generated by gr_modtool, a tool from the GNU Radio framework
|
||||||
|
# This file is a part of gr-hamnet70
|
||||||
|
#
|
||||||
|
# GNU Radio is free software; you can redistribute it and/or modify
|
||||||
|
# it under the terms of the GNU General Public License as published by
|
||||||
|
# the Free Software Foundation; either version 3, or (at your option)
|
||||||
|
# any later version.
|
||||||
|
#
|
||||||
|
# GNU Radio is distributed in the hope that it will be useful,
|
||||||
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||||
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||||
|
# GNU General Public License for more details.
|
||||||
|
#
|
||||||
|
# You should have received a copy of the GNU General Public License
|
||||||
|
# along with GNU Radio; see the file COPYING. If not, write to
|
||||||
|
# the Free Software Foundation, Inc., 51 Franklin Street,
|
||||||
|
# Boston, MA 02110-1301, USA.
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Check if there is C++ code at all
|
||||||
|
########################################################################
|
||||||
|
if(NOT hamnet70_sources)
|
||||||
|
MESSAGE(STATUS "No C++ sources... skipping swig/")
|
||||||
|
return()
|
||||||
|
endif(NOT hamnet70_sources)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Include swig generation macros
|
||||||
|
########################################################################
|
||||||
|
find_package(SWIG)
|
||||||
|
find_package(PythonLibs 2)
|
||||||
|
if(NOT SWIG_FOUND OR NOT PYTHONLIBS_FOUND)
|
||||||
|
return()
|
||||||
|
endif()
|
||||||
|
include(GrSwig)
|
||||||
|
include(GrPython)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Setup swig generation
|
||||||
|
########################################################################
|
||||||
|
foreach(incdir ${GNURADIO_RUNTIME_INCLUDE_DIRS})
|
||||||
|
list(APPEND GR_SWIG_INCLUDE_DIRS ${incdir}/gnuradio/swig)
|
||||||
|
endforeach(incdir)
|
||||||
|
|
||||||
|
set(GR_SWIG_LIBRARIES gnuradio-hamnet70)
|
||||||
|
set(GR_SWIG_DOC_FILE ${CMAKE_CURRENT_BINARY_DIR}/hamnet70_swig_doc.i)
|
||||||
|
set(GR_SWIG_DOC_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/../include)
|
||||||
|
|
||||||
|
GR_SWIG_MAKE(hamnet70_swig hamnet70_swig.i)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Install the build swig module
|
||||||
|
########################################################################
|
||||||
|
GR_SWIG_INSTALL(TARGETS hamnet70_swig DESTINATION ${GR_PYTHON_DIR}/hamnet70)
|
||||||
|
|
||||||
|
########################################################################
|
||||||
|
# Install swig .i files for development
|
||||||
|
########################################################################
|
||||||
|
install(
|
||||||
|
FILES
|
||||||
|
hamnet70_swig.i
|
||||||
|
${CMAKE_CURRENT_BINARY_DIR}/hamnet70_swig_doc.i
|
||||||
|
DESTINATION ${GR_INCLUDE_DIR}/hamnet70/swig
|
||||||
|
)
|
||||||
16
gr-hamnet70/swig/hamnet70_swig.i
Normal file
16
gr-hamnet70/swig/hamnet70_swig.i
Normal file
|
|
@ -0,0 +1,16 @@
|
||||||
|
/* -*- c++ -*- */
|
||||||
|
|
||||||
|
#define HAMNET70_API
|
||||||
|
|
||||||
|
%include "gnuradio.i" // the common stuff
|
||||||
|
|
||||||
|
//load generated python docstrings
|
||||||
|
%include "hamnet70_swig_doc.i"
|
||||||
|
|
||||||
|
%{
|
||||||
|
#include "hamnet70/correct_phase_from_tag.h"
|
||||||
|
%}
|
||||||
|
|
||||||
|
|
||||||
|
%include "hamnet70/correct_phase_from_tag.h"
|
||||||
|
GR_SWIG_BLOCK_MAGIC2(hamnet70, correct_phase_from_tag);
|
||||||
Loading…
Reference in a new issue