commit
e9aa1ab5fe
@ -0,0 +1,145 @@ |
||||
# 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. |
||||
|
||||
|
||||
######################################################################## |
||||
# Project setup |
||||
######################################################################## |
||||
cmake_minimum_required(VERSION 2.6) |
||||
project(gr-op25 CXX C) |
||||
enable_testing() |
||||
|
||||
#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 "") |
||||
|
||||
list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules) |
||||
|
||||
######################################################################## |
||||
# 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 op25") |
||||
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/op25) |
||||
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) |
||||
|
||||
######################################################################## |
||||
# Find gnuradio build dependencies |
||||
######################################################################## |
||||
find_package(GnuradioRuntime) |
||||
find_package(CppUnit) |
||||
|
||||
# To run a more advanced search for GNU Radio and it's components and |
||||
# versions, use the following. Add any components required to the list |
||||
# of GR_REQUIRED_COMPONENTS (in all caps) and change "version" to the |
||||
# minimum API compatible version required. |
||||
# |
||||
# set(GR_REQUIRED_COMPONENTS RUNTIME BLOCKS FILTER ...) |
||||
# find_package(Gnuradio "version") |
||||
|
||||
if(NOT GNURADIO_RUNTIME_FOUND) |
||||
message(FATAL_ERROR "GnuRadio Runtime required to compile op25") |
||||
endif() |
||||
if(NOT CPPUNIT_FOUND) |
||||
message(FATAL_ERROR "CppUnit required to compile op25") |
||||
endif() |
||||
|
||||
######################################################################## |
||||
# Setup the include and linker paths |
||||
######################################################################## |
||||
include_directories( |
||||
${CMAKE_SOURCE_DIR}/include |
||||
${Boost_INCLUDE_DIRS} |
||||
${CPPUNIT_INCLUDE_DIRS} |
||||
${GNURADIO_RUNTIME_INCLUDE_DIRS} |
||||
) |
||||
|
||||
link_directories( |
||||
${Boost_LIBRARY_DIRS} |
||||
${CPPUNIT_LIBRARY_DIRS} |
||||
${GNURADIO_RUNTIME_LIBRARY_DIRS} |
||||
) |
||||
|
||||
# Set component parameters |
||||
set(GR_OP25_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE INTERNAL "" FORCE) |
||||
set(GR_OP25_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/op25) |
||||
add_subdirectory(lib) |
||||
add_subdirectory(swig) |
||||
add_subdirectory(python) |
||||
add_subdirectory(grc) |
||||
add_subdirectory(apps) |
||||
add_subdirectory(docs) |
@ -0,0 +1,25 @@ |
||||
# 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(GrPython) |
||||
|
||||
GR_PYTHON_INSTALL( |
||||
PROGRAMS |
||||
DESTINATION bin |
||||
) |
@ -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,36 @@ |
||||
# 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} |
||||
PATHS |
||||
/usr/local/include |
||||
/usr/include |
||||
) |
||||
|
||||
FIND_LIBRARY(CPPUNIT_LIBRARIES |
||||
NAMES cppunit |
||||
HINTS ${PC_CPPUNIT_LIBDIR} |
||||
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,6 @@ |
||||
INCLUDE(FindPkgConfig) |
||||
PKG_CHECK_MODULES(GNURADIO_RUNTIME gnuradio-runtime) |
||||
|
||||
INCLUDE(FindPackageHandleStandardArgs) |
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(GNURADIO_RUNTIME DEFAULT_MSG GNURADIO_RUNTIME_LIBRARIES GNURADIO_RUNTIME_INCLUDE_DIRS) |
||||
MARK_AS_ADVANCED(GNURADIO_RUNTIME_LIBRARIES GNURADIO_RUNTIME_INCLUDE_DIRS) |
@ -0,0 +1,210 @@ |
||||
# 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_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}) |
||||
add_definitions(${flag}) |
||||
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 LIBRARY_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) |
@ -0,0 +1,46 @@ |
||||
# 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(LINUX AND EXISTS "/etc/debian_version") |
||||
set(DEBIAN TRUE) |
||||
endif() |
||||
|
||||
if(LINUX AND EXISTS "/etc/redhat-release") |
||||
set(REDHAT TRUE) |
||||
endif() |
||||
|
||||
######################################################################## |
||||
# when the library suffix should be 64 (applies to redhat linux family) |
||||
######################################################################## |
||||
if(NOT DEFINED LIB_SUFFIX AND REDHAT AND CMAKE_SYSTEM_PROCESSOR MATCHES "64$") |
||||
set(LIB_SUFFIX 64) |
||||
endif() |
||||
set(LIB_SUFFIX ${LIB_SUFFIX} CACHE STRING "lib directory suffix") |
@ -0,0 +1,227 @@ |
||||
# 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) |
||||
|
||||
#make the path to the executable appear in the cmake gui |
||||
set(PYTHON_EXECUTABLE ${PYTHON_EXECUTABLE} CACHE FILEPATH "python interpreter") |
||||
|
||||
#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} |
||||
except: exit(-1) |
||||
try: assert ${cmd} |
||||
except: exit(-1) |
||||
#########################################" |
||||
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 |
||||
######################################################################## |
||||
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 |
||||
) |
||||
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) |
||||
|
||||
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 |
||||
\"open('${pyexefile}', 'w').write('\#!${pyexe_native}\\n'+open('${pyfile}').read())\" |
||||
COMMENT "Shebangin ${pyfile_name}" |
||||
) |
||||
|
||||
#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:] |
||||