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