pushes changes needed for building in OE with pyro branch

CMakeLists.txt

@@ -42,6 +42,11 @@ if(NOT CPPUNIT_FOUND)
     message(FATAL_ERROR "CPPUNIT NOT FOUND!")
 endif(NOT CPPUNIT_FOUND)
 
+find_package(Log4Cpp)
+if(NOT LOG4CPP_FOUND)
+    message(FATAL_ERROR "LOG4CPP NOT FOUND!")
+endif(NOT LOG4CPP_FOUND)
+
 ########################################################################
 # Deal with Controlport.
 ########################################################################

cmake/Modules/FindLog4Cpp.cmake

@@ -1,35 +1,53 @@
-# Locate log4cpp include paths and libraries
-# log4cpp can be found at http://log4cpp.sourceforge.net/
-# Written by Manfred Ulz, manfred.ulz_at_tugraz.at
-
-# This module defines
-# LOG4CPP_INCLUDE_DIR, where to find ptlib.h, etc.
-# LOG4CPP_LIBRARIES, the libraries to link against to use pwlib.
-# LOG4CPP_FOUND, If false, don't try to use pwlib.
-
-FIND_PATH(LOG4CPP_INCLUDE_DIR log4cpp/Category.hh
-  PATHS
-    "$ENV{LOG4CPP}/include"
-    /usr/local/include
-    /usr/include
+# - Find Log4cpp
+# Find the native LOG4CPP includes and library
+#
+#  LOG4CPP_INCLUDE_DIR - where to find LOG4CPP.h, etc.
+#  LOG4CPP_LIBRARIES   - List of libraries when using LOG4CPP.
+#  LOG4CPP_FOUND       - True if LOG4CPP found.
+
+
+if (LOG4CPP_INCLUDE_DIR)
+  # Already in cache, be silent
+  set(LOG4CPP_FIND_QUIETLY TRUE)
+endif ()
+
+find_path(LOG4CPP_INCLUDE_DIR log4cpp/Category.hh
+  /opt/local/include
+  /usr/local/include
+  /usr/include
 )
 
-FIND_LIBRARY(LOG4CPP_LIBRARIES log4cpp
-  PATHS
-    "$ENV{LOG4CPP}/lib"
-    /usr/local/lib
-    /usr/lib
+set(LOG4CPP_NAMES log4cpp)
+find_library(LOG4CPP_LIBRARY
+  NAMES ${LOG4CPP_NAMES}
+  PATHS /usr/lib /usr/local/lib /opt/local/lib
 )
 
-SET(LOG4CPP_FOUND 0)
-IF(LOG4CPP_INCLUDE_DIR)
-  IF(LOG4CPP_LIBRARIES)
-    SET(LOG4CPP_FOUND 1)
-    MESSAGE(STATUS "Found Log4CPP")
-  ENDIF(LOG4CPP_LIBRARIES)
-ENDIF(LOG4CPP_INCLUDE_DIR)
 
-MARK_AS_ADVANCED(
-  LOG4CPP_INCLUDE_DIR
+if (LOG4CPP_INCLUDE_DIR AND LOG4CPP_LIBRARY)
+  set(LOG4CPP_FOUND TRUE)
+  set(LOG4CPP_LIBRARIES ${LOG4CPP_LIBRARY} CACHE INTERNAL "" FORCE)
+  set(LOG4CPP_INCLUDE_DIRS ${LOG4CPP_INCLUDE_DIR} CACHE INTERNAL "" FORCE)
+else ()
+  set(LOG4CPP_FOUND FALSE CACHE INTERNAL "" FORCE)
+  set(LOG4CPP_LIBRARY "" CACHE INTERNAL "" FORCE)
+  set(LOG4CPP_LIBRARIES "" CACHE INTERNAL "" FORCE)
+  set(LOG4CPP_INCLUDE_DIR "" CACHE INTERNAL "" FORCE)
+  set(LOG4CPP_INCLUDE_DIRS "" CACHE INTERNAL "" FORCE)
+endif ()
+
+if (LOG4CPP_FOUND)
+  if (NOT LOG4CPP_FIND_QUIETLY)
+    message(STATUS "Found LOG4CPP: ${LOG4CPP_LIBRARIES}")
+  endif ()
+else ()
+  if (LOG4CPP_FIND_REQUIRED)
+    message(STATUS "Looked for LOG4CPP libraries named ${LOG4CPPS_NAMES}.")
+    message(FATAL_ERROR "Could NOT find LOG4CPP library")
+  endif ()
+endif ()
+
+mark_as_advanced(
   LOG4CPP_LIBRARIES
-) 
+  LOG4CPP_INCLUDE_DIRS
+)

cmake/Modules/GrSwig.cmake

@@ -1,17 +1,17 @@
 # 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,
@@ -24,6 +24,71 @@ 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...)
@@ -34,42 +99,103 @@ include(GrPython)
 #   - 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})
 
+    # Take care of a SWIG < 3.0 bug with handling std::vector<size_t>,
+    # by mapping to the correct sized type on the runtime system, one
+    # of "unsigned int", "unsigned long", or "unsigned long long".
+    # Compare the sizeof(size_t) with the sizeof the other types, and
+    # pick the first one in the list with the same sizeof. The logic
+    # in gnuradio-runtime/swig/gr_types.i handles the rest. It is
+    # probably not necessary to do this assignment all of the time,
+    # but it's easier to do it this way than to figure out the
+    # conditions when it is necessary -- and doing it this way won't
+    # hurt.  This bug seems to have been fixed with SWIG >= 3.0, and
+    # mostly happens when not doing a native build (e.g., on Mac OS X
+    # when using a 64-bit CPU but building for 32-bit).
+
+    if(SWIG_VERSION VERSION_LESS "3.0.0")
+        include(CheckTypeSize)
+        check_type_size("size_t" SIZEOF_SIZE_T)
+        check_type_size("unsigned int" SIZEOF_UINT)
+        check_type_size("unsigned long" SIZEOF_UL)
+        check_type_size("unsigned long long" SIZEOF_ULL)
+
+        if(${SIZEOF_SIZE_T} EQUAL ${SIZEOF_UINT})
+            list(APPEND GR_SWIG_FLAGS -DSIZE_T_UINT)
+        elseif(${SIZEOF_SIZE_T} EQUAL ${SIZEOF_UL})
+            list(APPEND GR_SWIG_FLAGS -DSIZE_T_UL)
+        elseif(${SIZEOF_SIZE_T} EQUAL ${SIZEOF_ULL})
+            list(APPEND GR_SWIG_FLAGS -DSIZE_T_ULL)
+        else()
+            message(FATAL_ERROR "GrSwig: Unable to find replace for std::vector<size_t>; this should never happen!")
+        endif()
+    endif()
+
+    #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}"
+        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 ${GR_SWIG_SOURCE_DEPS})
-
-    find_package(PythonLibs)
-    include_directories(${PYTHON_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(CMAKE_SWIG_FLAGS -fvirtual -modern -keyword -w511 -w314 -module ${name} ${GR_SWIG_FLAGS})
 
     #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(GR_SWIG_TARGET_DEPS)
-        add_dependencies(${SWIG_MODULE_${name}_REAL_NAME} ${GR_SWIG_TARGET_DEPS})
-    endif(GR_SWIG_TARGET_DEPS)
+    if(APPLE)
+      set(PYTHON_LINK_OPTIONS "-undefined dynamic_lookup")
+    else()
+      set(PYTHON_LINK_OPTIONS ${PYTHON_LIBRARIES})
+    endif(APPLE)
+    SWIG_LINK_LIBRARIES(${name} ${PYTHON_LINK_OPTIONS} ${GR_SWIG_LIBRARIES})
+    if(${name} STREQUAL "runtime_swig")
+        SET_TARGET_PROPERTIES(${SWIG_MODULE_runtime_swig_REAL_NAME} PROPERTIES DEFINE_SYMBOL "gnuradio_runtime_EXPORTS")
+    endif(${name} STREQUAL "runtime_swig")
 
 endmacro(GR_SWIG_MAKE)
 
@@ -98,11 +224,10 @@ macro(GR_SWIG_INSTALL)
             COMPONENT ${GR_SWIG_INSTALL_COMPONENT}
         )
 
-        find_program(LIBTOOL libtool)
-        if(LIBTOOL)
-            include(CMakeMacroLibtoolFile)
-            CREATE_LIBTOOL_FILE(${SWIG_MODULE_${name}_REAL_NAME} /${GR_SWIG_INSTALL_DESTINATION})
-        endif(LIBTOOL)
+        GR_LIBTOOL(
+            TARGET ${SWIG_MODULE_${name}_REAL_NAME}
+            DESTINATION ${GR_SWIG_INSTALL_DESTINATION}
+        )
 
     endforeach(name)
 
@@ -118,21 +243,25 @@ file(WRITE ${CMAKE_BINARY_DIR}/get_swig_deps.py "
 
 import os, sys, re
 
-include_matcher = re.compile('[#|%]include\\s*[<|\"](.*)[>|\"]')
+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 include_matcher.findall(file_contents, re.MULTILINE)
+    return matcher.findall(file_contents, re.MULTILINE)
 
 def get_swig_deps(file_path, level):
     deps = [file_path]
     if level == 0: return deps
-    for inc_file in get_swig_incs(file_path):
+    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__':

lib/CMakeLists.txt

@@ -6,7 +6,7 @@ include_directories(
     ${GNURADIO_RUNTIME_INCLUDE_DIRS}
     ${GNURADIO_BLOCKS_INCLUDE_DIRS}
     ${PYTHON_INCLUDE_DIRS}
-	${BOOST_INCLUDE_DIRS}
+    ${BOOST_INCLUDE_DIRS}
 )
 
 # Set up LDFLAGS
@@ -18,6 +18,7 @@ list(APPEND eventstream_libs
     ${GNURADIO_BLOCKS_LIBRARIES}
     ${GNURADIO_PMT_LIBRARIES}
     ${PYTHON_LIBRARIES}
+    ${LOG4CPP_LIBRARIES}
 )
 
 list(APPEND eventstream_sources