Add Doxygen stuff as it appears pybind macros require it.

Signed-off-by: Jaroslav Škarvada <jskarvad@redhat.com>

AUTHORS

@@ -1,7 +0,0 @@
-Mode S receiver:
-Nick Foster <bistromath@gmail.com>
-
-Parts of the ECC algorithm are from Eric Cottrell's gr-air program.
-
-gr-howto-write-a-block:
-Eric Blossom <eb@comsec.com>

CMakeLists.txt

@@ -21,12 +21,16 @@
 ########################################################################
 # Project setup
 ########################################################################
-cmake_minimum_required(VERSION 2.6)
-project(gr-gr-air-modes CXX)
-set(gr-gr-air-modes_VERSION_MAJOR 0)
-set(gr-gr-air-modes_VERSION_MINOR 0)
+cmake_minimum_required(VERSION 3.8)
+project(gr-air_modes 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")
@@ -34,64 +38,97 @@ if(NOT CMAKE_BUILD_TYPE)
 endif(NOT CMAKE_BUILD_TYPE)
 set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")
 
-list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/Modules)
+#make sure our local CMake Modules path comes first
+list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_SOURCE_DIR}/cmake/Modules)
+
+# Set the version information here
+set(VERSION_MAJOR 1)
+set(VERSION_API    0)
+set(VERSION_ABI 0)
+set(VERSION_PATCH git)
+
+# Set cmake policies.
+# This will suppress developer warnings during the cmake process that can occur
+# if a newer cmake version than the minimum is used.
+cmake_policy(SET CMP0011 NEW)
+
+# Enable generation of compile_commands.json for code completion engines
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 ########################################################################
 # Compiler specific setup
 ########################################################################
-if(CMAKE_COMPILER_IS_GNUCXX AND NOT WIN32)
+if((CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR
+    CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    AND NOT WIN32)
     #http://gcc.gnu.org/wiki/Visibility
     add_definitions(-fvisibility=hidden)
 endif()
 
-########################################################################
-# Find boost
-########################################################################
-include(GrBoost)
+IF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    SET(CMAKE_CXX_STANDARD 11)
+ELSEIF(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    SET(CMAKE_CXX_STANDARD 11)
+ELSEIF(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    SET(CMAKE_CXX_STANDARD 11)
+ELSE()
+    message(WARNING "C++ standard could not be set because compiler is not GNU, Clang or MSVC.")
+ENDIF()
 
-########################################################################
-# Install directories
-########################################################################
-include(GrPlatform) #define LIB_SUFFIX
-set(GR_RUNTIME_DIR      bin)
-set(GR_LIBRARY_DIR      lib${LIB_SUFFIX})
-set(GR_INCLUDE_DIR      include)
-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)
+IF(CMAKE_C_COMPILER_ID STREQUAL "GNU")
+    SET(CMAKE_C_STANDARD 11)
+ELSEIF(CMAKE_C_COMPILER_ID MATCHES "Clang")
+    SET(CMAKE_C_STANDARD 11)
+ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
+    SET(CMAKE_C_STANDARD 11)
+ELSE()
+    message(WARNING "C standard could not be set because compiler is not GNU, Clang or MSVC.")
+ENDIF()
+
+find_package(pybind11 REQUIRED)
+execute_process(
+    COMMAND "${PYTHON_EXECUTABLE}" -c
+    "try:\n import numpy\n import os\n inc_path = numpy.get_include()\n if os.path.exists(os.path.join(inc_path, 'numpy', 'arrayobject.h')):\n  print(inc_path, end='')\nexcept:\n pass"
+    OUTPUT_VARIABLE PYTHON_NUMPY_INCLUDE_DIR)
 
 ########################################################################
 # Find gnuradio build dependencies
 ########################################################################
-find_package(GnuradioRuntime)
+find_package(Gnuradio "3.9" REQUIRED)
+include(GrVersion)
 
-if(NOT GNURADIO_RUNTIME_FOUND)
-    message(FATAL_ERROR "GnuRadio Runtime required to compile gr-air-modes")
-endif()
+include(GrPlatform) #define LIB_SUFFIX
+
+if(NOT CMAKE_MODULES_DIR)
+  set(CMAKE_MODULES_DIR lib${LIB_SUFFIX}/cmake)
+endif(NOT CMAKE_MODULES_DIR)
+
+set(GR_INCLUDE_DIR      include/gr_air_modes)
+set(GR_CMAKE_DIR        ${CMAKE_MODULES_DIR}/${CMAKE_PROJECT_NAME})
+set(GR_PKG_DATA_DIR     ${GR_DATA_DIR}/${CMAKE_PROJECT_NAME})
+set(GR_PKG_DOC_DIR      ${GR_DOC_DIR}/${CMAKE_PROJECT_NAME})
+set(GR_PKG_CONF_DIR     ${GR_CONF_DIR}/${CMAKE_PROJECT_NAME}/conf.d)
+set(GR_PKG_LIBEXEC_DIR  ${GR_LIBEXEC_DIR}/${CMAKE_PROJECT_NAME})
 
 ########################################################################
-# Setup the include and linker paths
+# On Apple only, set install name and use rpath correctly, if not already set
 ########################################################################
-include_directories(
-    ${CMAKE_SOURCE_DIR}/include
-    ${Boost_INCLUDE_DIRS}
-    ${GNURADIO_RUNTIME_INCLUDE_DIRS}
-)
-
-link_directories(
-    ${Boost_LIBRARY_DIRS}
-    ${GNURADIO_RUNTIME_LIBRARY_DIRS}
-)
-
-# Set component parameters
-set(GR_GR-AIR-MODES_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE INTERNAL "" FORCE)
-set(GR_GR-AIR-MODES_SWIG_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}/swig CACHE INTERNAL "" FORCE)
+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)
 
 ########################################################################
 # Create uninstall target
@@ -105,14 +142,16 @@ add_custom_target(uninstall
     ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake
 )
 
+install(FILES cmake/Modules/air_modesConfig.cmake
+    DESTINATION ${CMAKE_MODULES_DIR}/air_modes
+)
+
 ########################################################################
 # Add subdirectories
 ########################################################################
-add_subdirectory(include/gr_air_modes)
+add_subdirectory(include/air_modes)
 add_subdirectory(lib)
-add_subdirectory(swig)
 add_subdirectory(python)
 add_subdirectory(grc)
 add_subdirectory(apps)
-add_subdirectory(docs)
 add_subdirectory(res)

Dockerfile

@@ -0,0 +1,13 @@
+FROM bistromath/gnuradio:v3.9
+
+ENV num_threads 10
+MAINTAINER bistromath@gmail.com version: 0.1
+
+WORKDIR /opt
+
+RUN apt install -y python3-zmq python3-scipy
+
+RUN mkdir gr-air_modes
+COPY . gr-air_modes/
+WORKDIR /opt/gr-air_modes
+RUN mkdir build && cd build && cmake ../ && make -j${num_threads} && make install && ldconfig

README

@@ -97,6 +97,7 @@ gr-air-modes requires:
 
 * Python >= 2.5 (written for Python 2.7, Python 3.0 might work)
 ** NumPy and SciPy are required for the FlightGear output plugin.
+* PyZMQ
 * Gnuradio >= 3.5.0
 * Ettus UHD >= 3.4.0 for use with USRPs
 * osmosdr (any version) for use with RTLSDR dongles

apps/modes_gui

@@ -30,6 +30,7 @@ import air_modes
 from air_modes.exceptions import *
 from air_modes.modes_rx_ui import Ui_MainWindow
 from air_modes.gui_model import *
+from air_modes.az_map import *
 import sqlite3
 import zmq
 
@@ -87,7 +88,9 @@ class mainwindow(QtGui.QMainWindow):
             self.ui.line_my_lat.insert(defaults["latitude"])
         if defaults["longitude"] is not None:
             self.ui.line_my_lon.insert(defaults["longitude"])
-
+        if defaults["apikey"] is not None:
+            self.ui.line_my_api_key.insert(defaults["apikey"])
+        
         #disable by default
         self.ui.check_adsbonly.setCheckState(QtCore.Qt.Unchecked)
 
@@ -104,7 +107,7 @@ class mainwindow(QtGui.QMainWindow):
         self.ui.list_aircraft.setModel(self.datamodel)
         self.ui.list_aircraft.setModelColumn(0)
 
-        self.az_model = air_modes.az_map_model(None)
+        self.az_model = air_modes.az_map.az_map_model(None)
         self.ui.azimuth_map.setModel(self.az_model)
 
         #set up dashboard views
@@ -233,7 +236,9 @@ class mainwindow(QtGui.QMainWindow):
             try:
                 import osmosdr
                 self.src = osmosdr.source("")
-                self.rates = [rate.start() for rate in self.src.get_sample_rates() if (rate.start() % 2.e6) == 0]
+                self.rates = [rate.start() for rate in self.src.get_sample_rates()
+                             if ((rate.start() % 2.e6) == 0)
+                             or (rate.start() < 4.e6 and ((rate.start()%0.2e6) == 0))]
                 self.antennas = ["RX"]
                 self.src = None
                 self.ui.combo_ant.setEnabled(False)
@@ -263,10 +268,15 @@ class mainwindow(QtGui.QMainWindow):
 
         #set up recommended sample rate
         if len(self.rates) > 1:
-            recommended_rate = min(x for x in self.rates if x >= 4e6 and
-                                 max(self.rates) % x == 0)
+            if max(self.rates) > 4.e6:
+                recommended_rate = min(x for x in self.rates if x >= 4e6 and
+                                      max(self.rates) % x == 0)
+            else:
+                recommended_rate = max(self.rates)
             if recommended_rate >= 8.e6:
                 self.ui.check_pmf.setChecked(True)
+            else:
+                self.ui.check_pmf.setChecked(False)
             self.ui.combo_rate.setCurrentIndex(self.rates.index(recommended_rate))
 
 ################ action handlers ####################
@@ -314,6 +324,11 @@ class mainwindow(QtGui.QMainWindow):
             except:
                 my_position = None
 
+            try:
+                my_apikey = str(self.ui.line_my_api_key.text())
+            except:
+                my_apikey = None
+
             self._cpr_dec = air_modes.cpr_decoder(my_position)
 
             self.datamodelout = dashboard_output(self._cpr_dec, self.datamodel, self._publisher)
@@ -336,7 +351,7 @@ class mainwindow(QtGui.QMainWindow):
 
             #add azimuth map output and hook it up
             if my_position is not None:
-                self.az_map_output = air_modes.az_map_output(self._cpr_dec, self.az_model, self._publisher)
+                self.az_map_output = air_modes.az_map.az_map_output(self._cpr_dec, self.az_model, self._publisher)
                 #self._relay.subscribe("dl_data", self.az_map_output.output)
 
             #set up map
@@ -352,12 +367,12 @@ class mainwindow(QtGui.QMainWindow):
             #create SQL database for KML and dashboard displays
             self.dbwriter = air_modes.output_sql(self._cpr_dec, self.dbname, self.lock, self._publisher)
             self.jsonpgen = air_modes.output_jsonp(self._jsonfile.name, self.dbname, my_position, self.lock, timeout=1)
-            htmlstring = air_modes.html_template(my_position, self._jsonfile.name)
+            htmlstring = air_modes.html_template(my_apikey, my_position, self._jsonfile.name)
             self._htmlfile.write(htmlstring)
             self._htmlfile.flush()
             class WebPage(QtWebKit.QWebPage):
                 def javaScriptConsoleMessage(self, msg, line, source):
-                    print '%s line %d: %s' % (source, line, msg)
+                    print('%s line %d: %s' % (source, line, msg))
             page = WebPage()
             self.ui.mapView.setPage(page)
             self.ui.mapView.load( QtCore.QUrl( QtCore.QUrl.fromLocalFile("/tmp/mode_s.html") ) )
@@ -397,13 +412,17 @@ class mainwindow(QtGui.QMainWindow):
                 self.prefs["longitude"] = float(self.ui.line_my_lon.text())
             except:
                 pass
-
+            try:
+                self.prefs["apikey"] = self.ui.line_my_api_key.text()
+            except:
+                pass
+                
     def on_quit(self):
         if self.running is True:
-            self._relay.close()
             self._radio.close()
-            self._relay = None
             self._radio = None
+            self._relay.close()
+            self._relay = None
             self._rps_timer = None
             try:
                 self.kmlgen.done = True
@@ -456,6 +475,7 @@ class mainwindow(QtGui.QMainWindow):
         defaults["threshold"] = "5"
         defaults["latitude"] = None
         defaults["longitude"] = None
+        defaults["apikey"] = None
 
         prefs = ConfigParser.ConfigParser(defaults)
         prefs.optionxform = str
@@ -465,7 +485,7 @@ class mainwindow(QtGui.QMainWindow):
             for item in prefs.items("GUI"):
                 defaults[item[0]] = item[1]
         except (IOError, ConfigParser.NoSectionError):
-            print "No preferences file %s found, creating..." % os.path.expanduser(self.opt_file)
+            print("No preferences file %s found, creating..." % os.path.expanduser(self.opt_file))
             self.write_defaults(defaults)
 
         return defaults

apps/modes_rx

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # Copyright 2010, 2013 Nick Foster
 # 
 # This file is part of gr-air-modes
@@ -23,9 +23,8 @@ from gnuradio.eng_option import eng_option
 from gnuradio.gr.pubsub import pubsub
 from optparse import OptionParser
 import time, os, sys, threading, math
-from string import split, join
 import air_modes
-from air_modes.types import *
+from air_modes.modes_types import *
 from air_modes.exceptions import *
 import zmq
 

cmake/Modules/CMakeParseArgumentsCopy.cmake

@@ -58,7 +58,7 @@
 # the new option.
 # E.g. my_install(TARGETS foo DESTINATION OPTIONAL) would result in
 # MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION would
-# be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor.
+# be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefore.
 
 #=============================================================================
 # Copyright 2010 Alexander Neundorf <neundorf@kde.org>

cmake/Modules/FindGnuradioRuntime.cmake

@@ -1,6 +0,0 @@
-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)

cmake/Modules/FindPyQt.py

@@ -1,24 +0,0 @@
-# Copyright (c) 2007, Simon Edwards <simon@simonzone.com>
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-
-import PyQt4.pyqtconfig
-
-pyqtcfg = PyQt4.pyqtconfig.Configuration()
-print("pyqt_version:%06.0x" % pyqtcfg.pyqt_version)
-print("pyqt_version_str:%s" % pyqtcfg.pyqt_version_str)
-
-pyqt_version_tag = ""
-in_t = False
-for item in pyqtcfg.pyqt_sip_flags.split(' '):
-    if item=="-t":
-        in_t = True
-    elif in_t:
-        if item.startswith("Qt_4"):
-            pyqt_version_tag = item
-    else:
-        in_t = False
-print("pyqt_version_tag:%s" % pyqt_version_tag)
-
-print("pyqt_sip_dir:%s" % pyqtcfg.pyqt_sip_dir)
-print("pyqt_sip_flags:%s" % pyqtcfg.pyqt_sip_flags)

cmake/Modules/FindPyQt4.cmake

@@ -1,61 +0,0 @@
-# Find PyQt4
-# ~~~~~~~~~~
-# Copyright (c) 2007-2008, Simon Edwards <simon@simonzone.com>
-# Copyright (c) 2012, Nicholas Corgan <nick.corgan@ettus.com>
-# Redistribution and use is allowed according to the terms of the BSD license.
-# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
-#
-# PyQt4 website: http://www.riverbankcomputing.co.uk/pyqt/index.php
-#
-# Find the installed version of PyQt4. FindPyQt4 should only be called after
-# Python has been found.
-#
-# This file defines the following variables:
-#
-# PYQT4_VERSION - The version of PyQt4 found expressed as a 6 digit hex number
-#     suitable for comparision as a string
-#
-# PYQT4_VERSION_STR - The version of PyQt4 as a human readable string.
-#
-# PYQT4_VERSION_TAG - The PyQt version tag using by PyQt's sip files.
-#
-# PYQT4_SIP_DIR - The directory holding the PyQt4 .sip files.
-#
-# PYQT4_SIP_FLAGS - The SIP flags used to build PyQt.
-
-IF(EXISTS PYQT4_VERSION AND EXISTS PYUIC4_EXECUTABLE)
-  # Already in cache, be silent
-  SET(PYQT4_FOUND TRUE)
-  SET(PYUIC4_FOUND TRUE)
-ELSE(EXISTS PYQT4_VERSION AND EXISTS PYUIC4_EXECUTABLE)
-
-  FIND_FILE(_find_pyqt_py FindPyQt.py PATHS ${CMAKE_MODULE_PATH})
-
-  EXECUTE_PROCESS(COMMAND ${PYTHON_EXECUTABLE} ${_find_pyqt_py} OUTPUT_VARIABLE pyqt_config)
-  IF(pyqt_config)
-    STRING(REGEX REPLACE "^pyqt_version:([^\n]+).*$" "\\1" PYQT4_VERSION ${pyqt_config})
-    STRING(REGEX REPLACE ".*\npyqt_version_str:([^\n]+).*$" "\\1" PYQT4_VERSION_STR ${pyqt_config})
-    STRING(REGEX REPLACE ".*\npyqt_version_tag:([^\n]+).*$" "\\1" PYQT4_VERSION_TAG ${pyqt_config})
-    STRING(REGEX REPLACE ".*\npyqt_sip_dir:([^\n]+).*$" "\\1" PYQT4_SIP_DIR ${pyqt_config})
-    STRING(REGEX REPLACE ".*\npyqt_sip_flags:([^\n]+).*$" "\\1" PYQT4_SIP_FLAGS ${pyqt_config})
-
-    SET(PYQT4_FOUND TRUE)
-  ENDIF(pyqt_config)
-
-  FIND_PROGRAM(PYUIC4_EXECUTABLE NAMES pyuic4)
-  IF(PYUIC4_EXECUTABLE)
-    SET(PYUIC4_FOUND TRUE)
-  ENDIF(PYUIC4_EXECUTABLE)
-
-  IF(PYQT4_FOUND AND PYUIC4_FOUND)
-    IF(NOT PYQT4_FIND_QUIETLY)
-      MESSAGE(STATUS "Found PyQt4 version: ${PYQT4_VERSION_STR}")
-      MESSAGE(STATUS "Found pyuic4: ${PYUIC4_EXECUTABLE}")
-    ENDIF(NOT PYQT4_FIND_QUIETLY)
-  ELSE(PYQT4_FOUND AND PYUIC4_FOUND)
-    IF(PYQT4_FIND_REQUIRED)
-      MESSAGE(FATAL_ERROR "Could not find Python")
-    ENDIF(PYQT4_FIND_REQUIRED)
-  ENDIF(PYQT4_FOUND AND PYUIC4_FOUND)
-
-ENDIF(EXISTS PYQT4_VERSION AND EXISTS PYUIC4_EXECUTABLE)

cmake/Modules/FindQwt.cmake

@@ -1,30 +0,0 @@
-# - try to find Qwt libraries and include files
-# QWT_INCLUDE_DIR where to find qwt_plot.h, etc.
-# QWT_LIBRARIES libraries to link against
-# QWT_FOUND If false, do not try to use Qwt
-
-find_path (QWT_INCLUDE_DIRS
-	NAMES qwt_plot.h
-	PATHS
-	/usr/local/include/qwt-qt4
-	/usr/local/include/qwt
-	/usr/include/qwt-qt4
-	/usr/include/qwt
-	/opt/local/include/qwt
-	/sw/include/qwt
-)
-
-find_library (QWT_LIBRARIES
-	NAMES qwt-qt4 qwt
-	PATHS
-	/usr/local/lib
-	/usr/lib
-	/opt/local/lib
-	/sw/lib
-)
-
-# handle the QUIETLY and REQUIRED arguments and set QWT_FOUND to TRUE if
-# all listed variables are TRUE
-include ( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( Qwt DEFAULT_MSG QWT_LIBRARIES QWT_INCLUDE_DIRS )
-MARK_AS_ADVANCED(QWT_LIBRARIES QWT_INCLUDE_DIRS)

cmake/Modules/FindZeroMQ.cmake

@@ -1,56 +0,0 @@
-# - Find zeromq libraries
-# This module finds zeromq if it is installed and determines where the
-# include files and libraries are. It also determines what the name of
-# the library is. This code sets the following variables:
-#
-#  ZEROMQ_FOUND               - have the zeromq libs been found
-#  ZEROMQ_LIBRARIES           - path to the zeromq library
-#  ZEROMQ_INCLUDE_DIRS        - path to where zmq.h is found
-#  ZEROMQ_DEBUG_LIBRARIES     - path to the debug library
-
-#INCLUDE(CMakeFindFrameworks)
-# Search for the zeromq framework on Apple.
-#CMAKE_FIND_FRAMEWORKS(ZeroMQ)
-
-IF(WIN32)
-	FIND_LIBRARY(ZEROMQ_DEBUG_LIBRARY
-		NAMES libzmq_d zmq_d
-		PATHS
-			${ZEROMQ_LIBRARIES}
-	)
-ENDIF(WIN32)
-
-FIND_LIBRARY(ZEROMQ_LIBRARY
-	NAMES libzmq zmq 
-	PATHS
-		${ZEROMQ_LIBRARIES}
-		${NSCP_LIBRARYDIR}
-)
-
-#  IF(ZeroMQ_FRAMEWORKS AND NOT ZEROMQ_INCLUDE_DIR)
-#    FOREACH(dir ${ZeroMQ_FRAMEWORKS})
-#      SET(ZEROMQ_FRAMEWORK_INCLUDES ${ZEROMQ_FRAMEWORK_INCLUDES}
-#        ${dir}/Versions/${_CURRENT_VERSION}/include/zeromq${_CURRENT_VERSION})
-#    ENDFOREACH(dir)
-#  ENDIF(ZeroMQ_FRAMEWORKS AND NOT ZEROMQ_INCLUDE_DIR)
-
-FIND_PATH(ZEROMQ_INCLUDE_DIR
-	NAMES zmq.hpp
-	PATHS
-#		${ZEROMQ_FRAMEWORK_INCLUDES}
-		${ZEROMQ_INCLUDE_DIRS}
-		${NSCP_INCLUDEDIR}
-		${ZEROMQ_INCLUDE_DIR}
-)
-
-MARK_AS_ADVANCED(
-  ZEROMQ_DEBUG_LIBRARY
-  ZEROMQ_LIBRARY
-  ZEROMQ_INCLUDE_DIR
-)
-SET(ZEROMQ_INCLUDE_DIRS "${ZEROMQ_INCLUDE_DIR}")
-SET(ZEROMQ_LIBRARIES "${ZEROMQ_LIBRARY}")
-SET(ZEROMQ_DEBUG_LIBRARIES "${ZEROMQ_DEBUG_LIBRARY}")
-
-INCLUDE(FindPackageHandleStandardArgs)
-FIND_PACKAGE_HANDLE_STANDARD_ARGS(ZeroMQ DEFAULT_MSG ZEROMQ_LIBRARIES ZEROMQ_INCLUDE_DIRS)

cmake/Modules/GrBoost.cmake

@@ -1,99 +0,0 @@
-# Copyright 2010-2011 Free Software Foundation, Inc.
-#
-# This file is part of GNU Radio
-#
-# GNU Radio is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3, or (at your option)
-# any later version.
-#
-# GNU Radio is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with GNU Radio; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-
-if(DEFINED __INCLUDED_GR_BOOST_CMAKE)
-    return()
-endif()
-set(__INCLUDED_GR_BOOST_CMAKE TRUE)
-
-########################################################################
-# Setup Boost and handle some system specific things
-########################################################################
-
-set(BOOST_REQUIRED_COMPONENTS
-    date_time
-    program_options
-    filesystem
-    system
-    thread
-)
-
-if(UNIX AND NOT BOOST_ROOT AND EXISTS "/usr/lib64")
-    list(APPEND BOOST_LIBRARYDIR "/usr/lib64") #fedora 64-bit fix
-endif(UNIX AND NOT BOOST_ROOT AND EXISTS "/usr/lib64")
-
-if(MSVC)
-    set(BOOST_REQUIRED_COMPONENTS ${BOOST_REQUIRED_COMPONENTS} chrono)
-
-    if (NOT DEFINED BOOST_ALL_DYN_LINK)
-        set(BOOST_ALL_DYN_LINK TRUE)
-    endif()
-    set(BOOST_ALL_DYN_LINK "${BOOST_ALL_DYN_LINK}" CACHE BOOL "boost enable dynamic linking")
-    if(BOOST_ALL_DYN_LINK)
-        add_definitions(-DBOOST_ALL_DYN_LINK) #setup boost auto-linking in msvc
-    else(BOOST_ALL_DYN_LINK)
-        unset(BOOST_REQUIRED_COMPONENTS) #empty components list for static link
-    endif(BOOST_ALL_DYN_LINK)
-endif(MSVC)
-
-find_package(Boost "1.35" COMPONENTS ${BOOST_REQUIRED_COMPONENTS})
-
-# This does not allow us to disable specific versions. It is used
-# internally by cmake to know the formation newer versions. As newer
-# Boost version beyond what is shown here are produced, we must extend
-# this list. To disable Boost versions, see below.
-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"
-)
-
-# Boost 1.52 disabled, see https://svn.boost.org/trac/boost/ticket/7669
-# Similar problems with Boost 1.46 and 1.47.
-
-OPTION(ENABLE_BAD_BOOST "Enable known bad versions of Boost" OFF)
-if(ENABLE_BAD_BOOST)
-  MESSAGE(STATUS "Enabling use of known bad versions of Boost.")
-endif(ENABLE_BAD_BOOST)
-
-# For any unsuitable Boost version, add the version number below in
-# the following format: XXYYZZ
-# Where:
-#     XX is the major version ('10' for version 1)
-#     YY is the minor version number ('46' for 1.46)
-#     ZZ is the patcher version number (typically just '00')
-set(Boost_NOGO_VERSIONS
-  104600 104601 104700 105200
-  )
-
-foreach(ver ${Boost_NOGO_VERSIONS})
-  if(${Boost_VERSION} EQUAL ${ver})
-    if(NOT ENABLE_BAD_BOOST)
-      MESSAGE(STATUS "WARNING: Found a known bad version of Boost (v${Boost_VERSION}). Disabling.")
-      set(Boost_FOUND FALSE)
-    else(NOT ENABLE_BAD_BOOST)
-      MESSAGE(STATUS "WARNING: Found a known bad version of Boost (v${Boost_VERSION}). Continuing anyway.")
-      set(Boost_FOUND TRUE)
-    endif(NOT ENABLE_BAD_BOOST)
-  endif(${Boost_VERSION} EQUAL ${ver})
-endforeach(ver)

cmake/Modules/GrMiscUtils.cmake

@@ -1,210 +0,0 @@
-# Copyright 2010-2011 Free Software Foundation, Inc.
-#
-# This file is part of GNU Radio
-#
-# GNU Radio is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3, or (at your option)
-# any later version.
-#
-# GNU Radio is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with GNU Radio; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-
-if(DEFINED __INCLUDED_GR_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 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)

cmake/Modules/GrPlatform.cmake

@@ -1,54 +0,0 @@
-# Copyright 2011 Free Software Foundation, Inc.
-#
-# This file is part of GNU Radio
-#
-# GNU Radio is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3, or (at your option)
-# any later version.
-#
-# GNU Radio is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with GNU Radio; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-
-if(DEFINED __INCLUDED_GR_PLATFORM_CMAKE)
-    return()
-endif()
-set(__INCLUDED_GR_PLATFORM_CMAKE TRUE)
-
-########################################################################
-# Setup additional defines for OS types
-########################################################################
-if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    set(LINUX TRUE)
-endif()
-
-if(LINUX AND EXISTS "/etc/debian_version")
-    set(DEBIAN TRUE)
-endif()
-
-if(LINUX AND EXISTS "/etc/redhat-release")
-    set(REDHAT TRUE)
-endif()
-
-if(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")

cmake/Modules/GrPython.cmake

@@ -1,232 +0,0 @@
-# Copyright 2010-2011 Free Software Foundation, Inc.
-#
-# This file is part of GNU Radio
-#
-# GNU Radio is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3, or (at your option)
-# any later version.
-#
-# GNU Radio is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with GNU Radio; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-
-if(DEFINED __INCLUDED_GR_PYTHON_CMAKE)
-    return()
-endif()
-set(__INCLUDED_GR_PYTHON_CMAKE TRUE)
-
-########################################################################
-# Setup the python interpreter:
-# This allows the user to specify a specific interpreter,
-# or finds the interpreter via the built-in cmake module.
-########################################################################
-#this allows the user to override PYTHON_EXECUTABLE
-if(PYTHON_EXECUTABLE)
-
-    set(PYTHONINTERP_FOUND TRUE)
-
-#otherwise if not set, try to automatically find it
-else(PYTHON_EXECUTABLE)
-
-    #use the built-in find script
-    find_package(PythonInterp)
-
-    #and if that fails use the find program routine
-    if(NOT PYTHONINTERP_FOUND)
-        find_program(PYTHON_EXECUTABLE NAMES python 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}
-    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
-########################################################################
-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)
-
-        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
-                \"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:]
-for src, gen in zip(srcs, gens):
-    py_compile.compile(file=src, cfile=gen, doraise=True)
-")

cmake/Modules/GrSwig.cmake

@@ -1,232 +0,0 @@
-# Copyright 2010-2011 Free Software Foundation, Inc.
-#
-# This file is part of GNU Radio
-#
-# GNU Radio is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3, or (at your option)
-# any later version.
-#
-# GNU Radio is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with GNU Radio; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-
-if(DEFINED __INCLUDED_GR_SWIG_CMAKE)
-    return()
-endif()
-set(__INCLUDED_GR_SWIG_CMAKE TRUE)
-
-include(GrPython)
-
-########################################################################
-# Builds a swig documentation file to be generated into python docstrings
-# Usage: GR_SWIG_MAKE_DOCS(output_file input_path input_path....)
-#
-# Set the following variable to specify extra dependent targets:
-#   - GR_SWIG_DOCS_SOURCE_DEPS
-#   - GR_SWIG_DOCS_TARGET_DEPS
-########################################################################
-function(GR_SWIG_MAKE_DOCS output_file)
-    if(ENABLE_DOXYGEN)
-
-        #setup the input files variable list, quote formated
-        set(input_files)
-        unset(INPUT_PATHS)
-        foreach(input_path ${ARGN})
-            if (IS_DIRECTORY ${input_path}) #when input path is a directory
-                file(GLOB input_path_h_files ${input_path}/*.h)
-            else() #otherwise its just a file, no glob
-                set(input_path_h_files ${input_path})
-            endif()
-            list(APPEND input_files ${input_path_h_files})
-            set(INPUT_PATHS "${INPUT_PATHS} \"${input_path}\"")
-        endforeach(input_path)
-
-        #determine the output directory
-        get_filename_component(name ${output_file} NAME_WE)
-        get_filename_component(OUTPUT_DIRECTORY ${output_file} PATH)
-        set(OUTPUT_DIRECTORY ${OUTPUT_DIRECTORY}/${name}_swig_docs)
-        make_directory(${OUTPUT_DIRECTORY})
-
-        #generate the Doxyfile used by doxygen
-        configure_file(
-            ${CMAKE_SOURCE_DIR}/docs/doxygen/Doxyfile.swig_doc.in
-            ${OUTPUT_DIRECTORY}/Doxyfile
-        @ONLY)
-
-        #Create a dummy custom command that depends on other targets
-        include(GrMiscUtils)
-        GR_GEN_TARGET_DEPS(_${name}_tag tag_deps ${GR_SWIG_DOCS_TARGET_DEPS})
-
-        #call doxygen on the Doxyfile + input headers
-        add_custom_command(
-            OUTPUT ${OUTPUT_DIRECTORY}/xml/index.xml
-            DEPENDS ${input_files} ${GR_SWIG_DOCS_SOURCE_DEPS} ${tag_deps}
-            COMMAND ${DOXYGEN_EXECUTABLE} ${OUTPUT_DIRECTORY}/Doxyfile
-            COMMENT "Generating doxygen xml for ${name} docs"
-        )
-
-        #call the swig_doc script on the xml files
-        add_custom_command(
-            OUTPUT ${output_file}
-            DEPENDS ${input_files} ${stamp-file} ${OUTPUT_DIRECTORY}/xml/index.xml
-            COMMAND ${PYTHON_EXECUTABLE} ${PYTHON_DASH_B}
-                ${CMAKE_SOURCE_DIR}/docs/doxygen/swig_doc.py
-                ${OUTPUT_DIRECTORY}/xml
-                ${output_file}
-            COMMENT "Generating python docstrings for ${name}"
-            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/docs/doxygen
-        )
-
-    else(ENABLE_DOXYGEN)
-        file(WRITE ${output_file} "\n") #no doxygen -> empty file
-    endif(ENABLE_DOXYGEN)
-endfunction(GR_SWIG_MAKE_DOCS)
-
-########################################################################
-# Build a swig target for the common gnuradio use case. Usage:
-# GR_SWIG_MAKE(target ifile ifile ifile...)
-#
-# Set the following variables before calling:
-#   - GR_SWIG_FLAGS
-#   - GR_SWIG_INCLUDE_DIRS
-#   - GR_SWIG_LIBRARIES
-#   - GR_SWIG_SOURCE_DEPS
-#   - GR_SWIG_TARGET_DEPS
-#   - GR_SWIG_DOC_FILE
-#   - GR_SWIG_DOC_DIRS
-########################################################################
-macro(GR_SWIG_MAKE name)
-    set(ifiles ${ARGN})
-
-    list(APPEND GR_SWIG_TARGET_DEPS ${GR_SWIG_LIBRARIES})
-
-    #do swig doc generation if specified
-    if (GR_SWIG_DOC_FILE)
-        set(GR_SWIG_DOCS_SOURCE_DEPS ${GR_SWIG_SOURCE_DEPS})
-        set(GR_SWIG_DOCS_TAREGT_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)
-    endif()
-
-    #append additional include directories
-    find_package(PythonLibs)
-    list(APPEND GR_SWIG_INCLUDE_DIRS ${PYTHON_INCLUDE_PATH}) #deprecated name (now dirs)
-    list(APPEND GR_SWIG_INCLUDE_DIRS ${PYTHON_INCLUDE_DIRS})
-    list(APPEND GR_SWIG_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR})
-    list(APPEND GR_SWIG_INCLUDE_DIRS ${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})
-
-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
-
-include_matcher = re.compile('[#|%]include\\s*[<|\"](.*)[>|\"]')
-include_dirs = sys.argv[2].split(';')
-
-def get_swig_incs(file_path):
-    file_contents = open(file_path, 'r').read()
-    return include_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 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))
-    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)))
-")

cmake/Modules/GrTest.cmake

@@ -1,137 +0,0 @@
-# Copyright 2010-2011 Free Software Foundation, Inc.
-#
-# This file is part of GNU Radio
-#
-# GNU Radio is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3, or (at your option)
-# any later version.
-#
-# GNU Radio is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with GNU Radio; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-
-if(DEFINED __INCLUDED_GR_TEST_CMAKE)
-    return()
-endif()
-set(__INCLUDED_GR_TEST_CMAKE TRUE)
-
-########################################################################
-# Add a unit test and setup the environment for a unit test.
-# Takes the same arguments as the ADD_TEST function.
-#
-# Before calling set the following variables:
-# GR_TEST_TARGET_DEPS  - built targets for the library path
-# GR_TEST_LIBRARY_DIRS - directories for the library path
-# GR_TEST_PYTHON_DIRS  - directories for the python path
-########################################################################
-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 "GR_DONT_LOAD_PREFS=1" "srcdir=${srcdir}")
-
-    #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
-        find_program(SHELL sh)
-        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)

cmake/Modules/air_modesConfig.cmake

@@ -0,0 +1,31 @@
+INCLUDE(FindPkgConfig)
+PKG_CHECK_MODULES(PC_AIR_MODES air_modes)
+
+FIND_PATH(
+    AIR_MODES_INCLUDE_DIRS
+    NAMES air_modes/api.h
+    HINTS $ENV{AIR_MODES_DIR}/include
+    ${PC_AIR_MODES_INCLUDEDIR}
+    PATHS ${CMAKE_INSTALL_PREFIX}/include
+          /usr/local/include
+          /usr/include
+)
+
+FIND_LIBRARY(
+    AIR_MODES_LIBRARIES
+    NAMES gnuradio-air-modes
+    HINTS $ENV{AIR_MODES_DIR}/lib
+    ${PC_AIR_MODES_LIBDIR}
+    PATHS ${CMAKE_INSTALL_PREFIX}/lib
+          ${CMAKE_INSTALL_PREFIX}/lib64
+          /usr/local/lib
+          /usr/local/lib64
+          /usr/lib
+          /usr/lib64
+          )
+
+include("${CMAKE_CURRENT_LIST_DIR}/air_modesTarget.cmake")
+
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(AIR_MODES DEFAULT_MSG AIR_MODES_LIBRARIES AIR_MODES_INCLUDE_DIRS)
+MARK_AS_ADVANCED(AIR_MODES_LIBRARIES AIR_MODES_INCLUDE_DIRS)

cmake/Modules/targetConfig.cmake.in

@@ -1,52 +1,26 @@
+# Copyright 2018 Free Software Foundation, Inc.
 #
-# Copyright 2007,2009,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 $(top_srcdir)/Makefile.common
+include(CMakeFindDependencyMacro)
 
-EXTRA_DIST = \
-	example/aadvark.cc 		\
-	example/aadvark.h		\
-	example/Doxyfile		\
-	example/xml/aadvark_8cc.xml	\
-	example/xml/aadvark_8h.xml	\
-	example/xml/classAadvark.xml	\
-	example/xml/combine.xslt	\
-	example/xml/compound.xsd	\
-	example/xml/index.xml		\
-	example/xml/index.xsd
-
-if PYTHON
-utilspythondir = $(grpythondir)/doxyxml
-
-TESTS = 				\
-	run_tests
-
-nobase_utilspython_PYTHON = \
-	__init__.py \
-	base.py \
-	doxyindex.py \
-	text.py \
-	generated/__init__.py \
-	generated/index.py \
-	generated/indexsuper.py \
-	generated/compound.py \
-	generated/compoundsuper.py
-endif
+set(target_deps "@TARGET_DEPENDENCIES@")
+foreach(dep IN LISTS target_deps)
+    find_dependency(${dep})
+endforeach()
+include("${CMAKE_CURRENT_LIST_DIR}/@TARGET@Targets.cmake")

docs/CMakeLists.txt

@@ -1,21 +1,10 @@
 # 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.
+#
+# This file was generated by gr_modtool, a tool from the GNU Radio framework
+# This file is a part of gr-air-modes
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
 
 ########################################################################
 # Setup dependencies

docs/doxygen/CMakeLists.txt

@@ -1,21 +1,10 @@
 # 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.
+#
+# This file was generated by gr_modtool, a tool from the GNU Radio framework
+# This file is a part of gr-air-modes
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
 
 ########################################################################
 # Create the doxygen configuration file
@@ -28,6 +17,7 @@ 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_mathjax NO)
 set(enable_xml_docs YES)
 
 configure_file(

docs/doxygen/doxyxml/.gitignore

@@ -1,3 +0,0 @@
-/Makefile
-/Makefile.in
-

docs/doxygen/doxyxml/__init__.py

@@ -1,23 +1,12 @@
 #
 # 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.
-# 
+#
+# This file was generated by gr_modtool, a tool from the GNU Radio framework
+# This file is a part of gr-air-modes
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+#
 """
 Python interface to contents of doxygen xml documentation.
 
@@ -27,7 +16,7 @@ doxygen-generated xml used in this example.
 
 >>> # Parse the doxygen docs.
 >>> import os
->>> this_dir = os.path.dirname(globals()['__file__']) 
+>>> this_dir = os.path.dirname(globals()['__file__'])
 >>> xml_path = this_dir + "/example/xml/"
 >>> di = DoxyIndex(xml_path)
 
@@ -64,11 +53,11 @@ u'Outputs the vital aadvark statistics.'
 
 """
 
-from doxyindex import DoxyIndex, DoxyFunction, DoxyParam, DoxyClass, DoxyFile, DoxyNamespace, DoxyGroup, DoxyFriend, DoxyOther
+from .doxyindex import DoxyIndex, DoxyFunction, DoxyParam, DoxyClass, DoxyFile, DoxyNamespace, DoxyGroup, DoxyFriend, DoxyOther
 
 def _test():
     import os
-    this_dir = os.path.dirname(globals()['__file__']) 
+    this_dir = os.path.dirname(globals()['__file__'])
     xml_path = this_dir + "/example/xml/"
     di = DoxyIndex(xml_path)
     # Get the Aadvark class

docs/doxygen/doxyxml/base.py

@@ -1,23 +1,12 @@
 #
 # 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.
-# 
+#
+# This file was generated by gr_modtool, a tool from the GNU Radio framework
+# This file is a part of gr-air-modes
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+#
 """
 A base class is created.
 
@@ -30,18 +19,18 @@ import pdb
 
 from xml.parsers.expat import ExpatError
 
-from generated import compound
+from .generated import compound
 
 
 class Base(object):
 
-    class Duplicate(StandardError):
+    class Duplicate(Exception):
         pass
 
-    class NoSuchMember(StandardError):
+    class NoSuchMember(Exception):
         pass
 
-    class ParsingError(StandardError):
+    class ParsingError(Exception):
         pass
 
     def __init__(self, parse_data, top=None):
@@ -94,7 +83,7 @@ class Base(object):
         for cls in self.mem_classes:
             if cls.can_parse(mem):
                 return cls
-        raise StandardError(("Did not find a class for object '%s'." \
+        raise Exception(("Did not find a class for object '%s'." \
                                  % (mem.get_name())))
 
     def convert_mem(self, mem):
@@ -102,11 +91,11 @@ class Base(object):
             cls = self.get_cls(mem)
             converted = cls.from_parse_data(mem, self.top)
             if converted is None:
-                raise StandardError('No class matched this object.')
+                raise Exception('No class matched this object.')
             self.add_ref(converted)
             return converted
-        except StandardError, e:
-            print e
+        except Exception as e:
+            print(e)
 
     @classmethod
     def includes(cls, inst):
@@ -144,7 +133,7 @@ class Base(object):
             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.
@@ -173,7 +162,7 @@ class Base(object):
     def members(self):
         self.confirm_no_error()
         return self._members
-    
+
     def process_memberdefs(self):
         mdtss = []
         for sec in self._retrieved_data.compounddef.sectiondef:
@@ -188,7 +177,7 @@ class Base(object):
             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:
@@ -197,7 +186,7 @@ class Base(object):
             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()

docs/doxygen/doxyxml/doxyindex.py

@@ -1,23 +1,12 @@
 #
 # 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.
-# 
+#
+# This file was generated by gr_modtool, a tool from the GNU Radio framework
+# This file is a part of gr-air-modes
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+#
 """
 Classes providing more user-friendly interfaces to the doxygen xml
 docs than the generated classes provide.
@@ -25,9 +14,9 @@ docs than the generated classes provide.
 
 import os
 
-from generated import index
-from base import Base
-from text import description
+from .generated import index
+from .base import Base
+from .text import description
 
 class DoxyIndex(Base):
     """
@@ -40,28 +29,23 @@ class DoxyIndex(Base):
         if self._parsed:
             return
         super(DoxyIndex, self)._parse()
-        self._root = index.parse(os.path.join(self._xml_path, 'index.xml'))      
+        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.
+            # For files and namespaces we want the contents to be
+            # accessible directly from the parent rather than having
+            # to go through the file object.
             if self.get_cls(mem) == DoxyFile:
                 if mem.name.endswith('.h'):
                     self._members += converted.members()
                     self._members.append(converted)
+            elif self.get_cls(mem) == DoxyNamespace:
+                self._members += converted.members()
+                self._members.append(converted)
             else:
                 self._members.append(converted)
 
 
-def generate_swig_doc_i(self):
-    """
-    %feature("docstring") gr_make_align_on_samplenumbers_ss::align_state "
-    Wraps the C++: gr_align_on_samplenumbers_ss::align_state";
-    """
-    pass
-
-
 class DoxyCompMem(Base):
 
 
@@ -78,14 +62,30 @@ class DoxyCompMem(Base):
         bd = description(getattr(parse_data, 'briefdescription', None))
         dd = description(getattr(parse_data, 'detaileddescription', None))
         self._data['brief_description'] = bd
-        self._data['detailed_description'] = dd        
+        self._data['detailed_description'] = dd
+
+    def set_parameters(self, data):
+        vs = [ddc.value for ddc in data.detaileddescription.content_]
+        pls = []
+        for v in vs:
+            if hasattr(v, 'parameterlist'):
+                pls += v.parameterlist
+        pis = []
+        for pl in pls:
+            pis += pl.parameteritem
+        dpis = []
+        for pi in pis:
+            dpi = DoxyParameterItem(pi)
+            dpi._parse()
+            dpis.append(dpi)
+        self._data['params'] = dpis
+
 
 class DoxyCompound(DoxyCompMem):
     pass
 
 class DoxyMember(DoxyCompMem):
     pass
-    
 
 class DoxyFunction(DoxyMember):
 
@@ -98,10 +98,13 @@ class DoxyFunction(DoxyMember):
             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))
+        self.set_parameters(self._parse_data)
+        if not self._data['params']:
+            # If the params weren't set by a comment then just grab the names.
+            self._data['params'] = []
+            prms = self._parse_data.param
+            for prm in prms:
+                self._data['params'].append(DoxyParam(prm))
 
     brief_description = property(lambda self: self.data()['brief_description'])
     detailed_description = property(lambda self: self.data()['detailed_description'])
@@ -111,7 +114,7 @@ Base.mem_classes.append(DoxyFunction)
 
 
 class DoxyParam(DoxyMember):
-    
+
     __module__ = "gnuradio.utils.doxyxml"
 
     def _parse(self):
@@ -121,16 +124,46 @@ class DoxyParam(DoxyMember):
         self.set_descriptions(self._parse_data)
         self._data['declname'] = self._parse_data.declname
 
+    @property
+    def description(self):
+        descriptions = []
+        if self.brief_description:
+            descriptions.append(self.brief_description)
+        if self.detailed_description:
+            descriptions.append(self.detailed_description)
+        return '\n\n'.join(descriptions)
+
     brief_description = property(lambda self: self.data()['brief_description'])
     detailed_description = property(lambda self: self.data()['detailed_description'])
-    declname = property(lambda self: self.data()['declname'])
+    name = property(lambda self: self.data()['declname'])
+
+class DoxyParameterItem(DoxyMember):
+    """A different representation of a parameter in Doxygen."""
+
+    def _parse(self):
+        if self._parsed:
+            return
+        super(DoxyParameterItem, self)._parse()
+        names = []
+        for nl in self._parse_data.parameternamelist:
+            for pn in nl.parametername:
+                names.append(description(pn))
+        # Just take first name
+        self._data['name'] = names[0]
+        # Get description
+        pd = description(self._parse_data.get_parameterdescription())
+        self._data['description'] = pd
+
+    description = property(lambda self: self.data()['description'])
+    name = property(lambda self: self.data()['name'])
+
 
 class DoxyClass(DoxyCompound):
-    
+
     __module__ = "gnuradio.utils.doxyxml"
 
     kind = 'class'
-    
+
     def _parse(self):
         if self._parsed:
             return
@@ -139,22 +172,24 @@ class DoxyClass(DoxyCompound):
         if self._error:
             return
         self.set_descriptions(self._retrieved_data.compounddef)
+        self.set_parameters(self._retrieved_data.compounddef)
         # Sectiondef.kind tells about whether private or public.
         # We just ignore this for now.
         self.process_memberdefs()
 
     brief_description = property(lambda self: self.data()['brief_description'])
     detailed_description = property(lambda self: self.data()['detailed_description'])
+    params = property(lambda self: self.data()['params'])
 
 Base.mem_classes.append(DoxyClass)
-        
+
 
 class DoxyFile(DoxyCompound):
-    
+
     __module__ = "gnuradio.utils.doxyxml"
 
     kind = 'file'
-    
+
     def _parse(self):
         if self._parsed:
             return
@@ -164,7 +199,7 @@ class DoxyFile(DoxyCompound):
         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'])
 
@@ -172,16 +207,26 @@ Base.mem_classes.append(DoxyFile)
 
 
 class DoxyNamespace(DoxyCompound):
-    
+
     __module__ = "gnuradio.utils.doxyxml"
 
     kind = 'namespace'
-    
+
+    def _parse(self):
+        if self._parsed:
+            return
+        super(DoxyNamespace, self)._parse()
+        self.retrieve_data()
+        self.set_descriptions(self._retrieved_data.compounddef)
+        if self._error:
+            return
+        self.process_memberdefs()
+
 Base.mem_classes.append(DoxyNamespace)
 
 
 class DoxyGroup(DoxyCompound):
-    
+
     __module__ = "gnuradio.utils.doxyxml"
 
     kind = 'group'
@@ -209,7 +254,7 @@ class DoxyGroup(DoxyCompound):
         self.process_memberdefs()
 
     title = property(lambda self: self.data()['title'])
-        
+
 
 Base.mem_classes.append(DoxyGroup)
 
@@ -224,14 +269,14 @@ Base.mem_classes.append(DoxyFriend)
 
 
 class DoxyOther(Base):
-    
+
     __module__ = "gnuradio.utils.doxyxml"
 
-    kinds = set(['variable', 'struct', 'union', 'define', 'typedef', 'enum', 'dir', 'page'])
+    kinds = set(['variable', 'struct', 'union', 'define', 'typedef', 'enum',
+                 'dir', 'page', 'signal', 'slot', 'property'])
 
     @classmethod
     def can_parse(cls, obj):
         return obj.kind in cls.kinds
-    
-Base.mem_classes.append(DoxyOther)
 
+Base.mem_classes.append(DoxyOther)

docs/doxygen/doxyxml/example/aadvark.cc

@@ -1,50 +0,0 @@
-/* -*- c++ -*- */
-/*
- * 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.
- */
-#include <iostream>
-#include "aadvark.h"
-
-void Aadvark::print() {
-  std::cout << "aadvark is " << aadvarkness << "/10 aadvarky" << std::endl;
-}
-
-Aadvark::Aadvark(int aaness): aadvarkness(aaness) {}
-
-bool aadvarky_enough(Aadvark aad) {
-  if (aad.get_aadvarkness() > 6)
-    return true;
-  else
-    return false;
-}
-
-int Aadvark::get_aadvarkness() {
-  return aadvarkness;
-}
-
-int main() {
-  Aadvark arold = Aadvark(6);
-  arold.print();
-  if (aadvarky_enough(arold))
-    std::cout << "He is aadvarky enough" << std::endl;
-  else
-    std::cout << "He is not aadvarky enough" << std::endl;
-}
-

docs/doxygen/doxyxml/example/aadvark.h

@@ -1,44 +0,0 @@
-/* -*- c++ -*- */
-/*
- * 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.
- */
-#include <iostream>
-
-/*!
- * \brief Models the mammal Aadvark.
- *
- * Sadly the model is incomplete and cannot capture all aspects of an aadvark yet.
- *
- * This line is uninformative and is only to test line breaks in the comments.
- */
-class Aadvark {
-public:
-  //! \brief Outputs the vital aadvark statistics.
-  void print();
-  //! \param aaness The aadvarkness of an aadvark is a measure of how aadvarky it is.
-  Aadvark(int aaness);
-  int get_aadvarkness();
-private:
-  int aadvarkness;
-};
-
-bool aadvarky_enough(Aadvark aad);
-
-int main();

docs/doxygen/doxyxml/example/xml/aadvark_8cc.xml

@@ -1,88 +0,0 @@
-<?xml version='1.0' encoding='UTF-8' standalone='no'?>
-<doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="1.6.3">
-  <compounddef id="aadvark_8cc" kind="file">
-    <compoundname>aadvark.cc</compoundname>
-    <includes local="no">iostream</includes>
-    <includes refid="aadvark_8cc" local="yes">aadvark.h</includes>
-    <includedby refid="aadvark_8cc" local="yes">aadvark.cc</includedby>
-    <incdepgraph>
-      <node id="0">
-        <label>aadvark.cc</label>
-        <link refid="aadvark.cc"/>
-        <childnode refid="1" relation="include">
-        </childnode>
-      </node>
-      <node id="1">
-        <label>iostream</label>
-      </node>
-    </incdepgraph>
-      <sectiondef kind="func">
-      <memberdef kind="function" id="aadvark_8cc_1acb52858524210ec6dddc3e16d1e52946" prot="public" static="no" const="no" explicit="no" inline="no" virt="non-virtual">
-        <type>bool</type>
-        <definition>bool aadvarky_enough</definition>
-        <argsstring>(Aadvark aad)</argsstring>
-        <name>aadvarky_enough</name>
-        <param>
-          <type><ref refid="classAadvark" kindref="compound">Aadvark</ref></type>
-          <declname>aad</declname>
-        </param>
-        <briefdescription>
-        </briefdescription>
-        <detaileddescription>
-        </detaileddescription>
-        <inbodydescription>
-        </inbodydescription>
-        <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.cc" line="10" bodyfile="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.cc" bodystart="10" bodyend="15"/>
-      </memberdef>
-      <memberdef kind="function" id="aadvark_8cc_1ae66f6b31b5ad750f1fe042a706a4e3d4" prot="public" static="no" const="no" explicit="no" inline="no" virt="non-virtual">
-        <type>int</type>
-        <definition>int main</definition>
-        <argsstring>()</argsstring>
-        <name>main</name>
-        <briefdescription>
-        </briefdescription>
-        <detaileddescription>
-        </detaileddescription>
-        <inbodydescription>
-        </inbodydescription>
-        <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.cc" line="21" bodyfile="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.cc" bodystart="21" bodyend="28"/>
-      </memberdef>
-      </sectiondef>
-    <briefdescription>
-    </briefdescription>
-    <detaileddescription>
-    </detaileddescription>
-    <programlisting>
-<codeline lineno="1"><highlight class="preprocessor">#include<sp/>&lt;iostream&gt;</highlight><highlight class="normal"></highlight></codeline>
-<codeline lineno="2"><highlight class="normal"></highlight><highlight class="preprocessor">#include<sp/>&quot;aadvark.h&quot;</highlight><highlight class="normal"></highlight></codeline>
-<codeline lineno="3"><highlight class="normal"></highlight></codeline>
-<codeline lineno="4"><highlight class="normal"></highlight><highlight class="keywordtype">void</highlight><highlight class="normal"><sp/><ref refid="classAadvark_1abd061aa5f998002e72080a34f512a059" kindref="member" tooltip="Outputs the vital aadvark statistics.">Aadvark::print</ref>()<sp/>{</highlight></codeline>
-<codeline lineno="5"><highlight class="normal"><sp/><sp/>std::cout<sp/>&lt;&lt;<sp/></highlight><highlight class="stringliteral">&quot;aadvark<sp/>is<sp/>&quot;</highlight><highlight class="normal"><sp/>&lt;&lt;<sp/>aadvarkness<sp/>&lt;&lt;<sp/></highlight><highlight class="stringliteral">&quot;/10<sp/>aadvarky&quot;</highlight><highlight class="normal"><sp/>&lt;&lt;<sp/>std::endl;</highlight></codeline>
-<codeline lineno="6"><highlight class="normal">}</highlight></codeline>
-<codeline lineno="7"><highlight class="normal"></highlight></codeline>
-<codeline lineno="8"><highlight class="normal"><ref refid="classAadvark_1adf1a4b97a641411a74a04ab312484462" kindref="member">Aadvark::Aadvark</ref>(</highlight><highlight class="keywordtype">int</highlight><highlight class="normal"><sp/>aaness):<sp/>aadvarkness(aaness)<sp/>{}</highlight></codeline>
-<codeline lineno="9"><highlight class="normal"></highlight></codeline>
-<codeline lineno="10"><highlight class="normal"></highlight><highlight class="keywordtype">bool</highlight><highlight class="normal"><sp/>aadvarky_enough(<ref refid="classAadvark" kindref="compound" tooltip="Models the mammal Aadvark.">Aadvark</ref><sp/>aad)<sp/>{</highlight></codeline>
-<codeline lineno="11"><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">if</highlight><highlight class="normal"><sp/>(aad.get_aadvarkness()<sp/>&gt;<sp/>6)</highlight></codeline>
-<codeline lineno="12"><highlight class="normal"><sp/><sp/><sp/><sp/></highlight><highlight class="keywordflow">return</highlight><highlight class="normal"><sp/></highlight><highlight class="keyword">true</highlight><highlight class="normal">;</highlight></codeline>
-<codeline lineno="13"><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">else</highlight><highlight class="normal"></highlight></codeline>
-<codeline lineno="14"><highlight class="normal"><sp/><sp/><sp/><sp/></highlight><highlight class="keywordflow">return</highlight><highlight class="normal"><sp/></highlight><highlight class="keyword">false</highlight><highlight class="normal">;</highlight></codeline>
-<codeline lineno="15"><highlight class="normal">}</highlight></codeline>
-<codeline lineno="16"><highlight class="normal"></highlight></codeline>
-<codeline lineno="17"><highlight class="normal"></highlight><highlight class="keywordtype">int</highlight><highlight class="normal"><sp/>Aadvark::get_aadvarkness()<sp/>{</highlight></codeline>
-<codeline lineno="18"><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">return</highlight><highlight class="normal"><sp/>aadvarkness;</highlight></codeline>
-<codeline lineno="19"><highlight class="normal">}</highlight></codeline>
-<codeline lineno="20"><highlight class="normal"></highlight></codeline>
-<codeline lineno="21"><highlight class="normal"></highlight><highlight class="keywordtype">int</highlight><highlight class="normal"><sp/>main()<sp/>{</highlight></codeline>
-<codeline lineno="22"><highlight class="normal"><sp/><sp/><ref refid="classAadvark" kindref="compound" tooltip="Models the mammal Aadvark.">Aadvark</ref><sp/>arold<sp/>=<sp/><ref refid="classAadvark" kindref="compound" tooltip="Models the mammal Aadvark.">Aadvark</ref>(6);</highlight></codeline>
-<codeline lineno="23"><highlight class="normal"><sp/><sp/>arold.<ref refid="classAadvark_1abd061aa5f998002e72080a34f512a059" kindref="member" tooltip="Outputs the vital aadvark statistics.">print</ref>();</highlight></codeline>
-<codeline lineno="24"><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">if</highlight><highlight class="normal"><sp/>(aadvarky_enough(arold))</highlight></codeline>
-<codeline lineno="25"><highlight class="normal"><sp/><sp/><sp/><sp/>std::cout<sp/>&lt;&lt;<sp/></highlight><highlight class="stringliteral">&quot;He<sp/>is<sp/>aadvarky<sp/>enough&quot;</highlight><highlight class="normal"><sp/>&lt;&lt;<sp/>std::endl;</highlight></codeline>
-<codeline lineno="26"><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordflow">else</highlight><highlight class="normal"></highlight></codeline>
-<codeline lineno="27"><highlight class="normal"><sp/><sp/><sp/><sp/>std::cout<sp/>&lt;&lt;<sp/></highlight><highlight class="stringliteral">&quot;He<sp/>is<sp/>not<sp/>aadvarky<sp/>enough&quot;</highlight><highlight class="normal"><sp/>&lt;&lt;<sp/>std::endl;</highlight></codeline>
-<codeline lineno="28"><highlight class="normal">}</highlight></codeline>
-<codeline lineno="29"><highlight class="normal"></highlight></codeline>
-    </programlisting>
-    <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.cc"/>
-  </compounddef>
-</doxygen>

docs/doxygen/doxyxml/example/xml/aadvark_8h.xml

@@ -1,72 +0,0 @@
-<?xml version='1.0' encoding='UTF-8' standalone='no'?>
-<doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="1.6.3">
-  <compounddef id="aadvark_8h" kind="file">
-    <compoundname>aadvark.h</compoundname>
-    <includes local="no">iostream</includes>
-    <incdepgraph>
-      <node id="3">
-        <label>aadvark.h</label>
-        <link refid="aadvark.h"/>
-        <childnode refid="4" relation="include">
-        </childnode>
-      </node>
-      <node id="4">
-        <label>iostream</label>
-      </node>
-    </incdepgraph>
-    <innerclass refid="classAadvark" prot="public">Aadvark</innerclass>
-      <sectiondef kind="func">
-      <memberdef kind="function" id="aadvark_8h_1acb52858524210ec6dddc3e16d1e52946" prot="public" static="no" const="no" explicit="no" inline="no" virt="non-virtual">
-        <type>bool</type>
-        <definition>bool aadvarky_enough</definition>
-        <argsstring>(Aadvark aad)</argsstring>
-        <name>aadvarky_enough</name>
-        <param>
-          <type><ref refid="classAadvark" kindref="compound">Aadvark</ref></type>
-          <declname>aad</declname>
-        </param>
-        <briefdescription>
-        </briefdescription>
-        <detaileddescription>
-        </detaileddescription>
-        <inbodydescription>
-        </inbodydescription>
-        <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.h" line="21" bodyfile="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.cc" bodystart="10" bodyend="15"/>
-      </memberdef>
-      <memberdef kind="function" id="aadvark_8h_1ae66f6b31b5ad750f1fe042a706a4e3d4" prot="public" static="no" const="no" explicit="no" inline="no" virt="non-virtual">
-        <type>int</type>
-        <definition>int main</definition>
-        <argsstring>()</argsstring>
-        <name>main</name>
-        <briefdescription>
-        </briefdescription>
-        <detaileddescription>
-        </detaileddescription>
-        <inbodydescription>
-        </inbodydescription>
-        <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.h" line="23" bodyfile="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.cc" bodystart="21" bodyend="28"/>
-      </memberdef>
-      </sectiondef>
-    <briefdescription>
-    </briefdescription>
-    <detaileddescription>
-    </detaileddescription>
-    <programlisting>
-<codeline lineno="1"><highlight class="preprocessor">#include<sp/>&lt;iostream&gt;</highlight><highlight class="normal"></highlight></codeline>
-<codeline lineno="2"><highlight class="normal"></highlight></codeline>
-<codeline lineno="10" refid="classAadvark" refkind="compound"><highlight class="keyword">class<sp/></highlight><highlight class="normal"><ref refid="classAadvark" kindref="compound" tooltip="Models the mammal Aadvark.">Aadvark</ref><sp/>{</highlight></codeline>
-<codeline lineno="11"><highlight class="normal"></highlight><highlight class="keyword">public</highlight><highlight class="normal">:</highlight></codeline>
-<codeline lineno="13"><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordtype">void</highlight><highlight class="normal"><sp/><ref refid="classAadvark_1abd061aa5f998002e72080a34f512a059" kindref="member" tooltip="Outputs the vital aadvark statistics.">print</ref>();</highlight></codeline>
-<codeline lineno="15"><highlight class="normal"><sp/><sp/><ref refid="classAadvark_1adf1a4b97a641411a74a04ab312484462" kindref="member">Aadvark</ref>(</highlight><highlight class="keywordtype">int</highlight><highlight class="normal"><sp/>aaness);</highlight></codeline>
-<codeline lineno="16"><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordtype">int</highlight><highlight class="normal"><sp/>get_aadvarkness();</highlight></codeline>
-<codeline lineno="17"><highlight class="normal"></highlight><highlight class="keyword">private</highlight><highlight class="normal">:</highlight></codeline>
-<codeline lineno="18"><highlight class="normal"><sp/><sp/></highlight><highlight class="keywordtype">int</highlight><highlight class="normal"><sp/>aadvarkness;</highlight></codeline>
-<codeline lineno="19"><highlight class="normal">};</highlight></codeline>
-<codeline lineno="20"><highlight class="normal"></highlight></codeline>
-<codeline lineno="21"><highlight class="normal"></highlight><highlight class="keywordtype">bool</highlight><highlight class="normal"><sp/>aadvarky_enough(<ref refid="classAadvark" kindref="compound" tooltip="Models the mammal Aadvark.">Aadvark</ref><sp/>aad);</highlight></codeline>
-<codeline lineno="22"><highlight class="normal"></highlight></codeline>
-<codeline lineno="23"><highlight class="normal"></highlight><highlight class="keywordtype">int</highlight><highlight class="normal"><sp/>main();</highlight></codeline>
-    </programlisting>
-    <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.h"/>
-  </compounddef>
-</doxygen>

docs/doxygen/doxyxml/example/xml/classAadvark.xml

@@ -1,86 +0,0 @@
-<?xml version='1.0' encoding='UTF-8' standalone='no'?>
-<doxygen xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="compound.xsd" version="1.6.3">
-  <compounddef id="classAadvark" kind="class" prot="public">
-    <compoundname>Aadvark</compoundname>
-    <includes refid="aadvark_8h" local="no">aadvark.h</includes>
-      <sectiondef kind="private-attrib">
-      <memberdef kind="variable" id="classAadvark_1ab79eb58d7bb9d5ddfa5d6f783836cab9" prot="private" static="no" mutable="no">
-        <type>int</type>
-        <definition>int Aadvark::aadvarkness</definition>
-        <argsstring></argsstring>
-        <name>aadvarkness</name>
-        <briefdescription>
-        </briefdescription>
-        <detaileddescription>
-        </detaileddescription>
-        <inbodydescription>
-        </inbodydescription>
-        <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.h" line="18" bodyfile="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.h" bodystart="18" bodyend="-1"/>
-      </memberdef>
-      </sectiondef>
-      <sectiondef kind="public-func">
-      <memberdef kind="function" id="classAadvark_1abd061aa5f998002e72080a34f512a059" prot="public" static="no" const="no" explicit="no" inline="no" virt="non-virtual">
-        <type>void</type>
-        <definition>void Aadvark::print</definition>
-        <argsstring>()</argsstring>
-        <name>print</name>
-        <briefdescription>
-<para>Outputs the vital aadvark statistics. </para>        </briefdescription>
-        <detaileddescription>
-        </detaileddescription>
-        <inbodydescription>
-        </inbodydescription>
-        <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.h" line="13" bodyfile="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.cc" bodystart="4" bodyend="6"/>
-      </memberdef>
-      <memberdef kind="function" id="classAadvark_1adf1a4b97a641411a74a04ab312484462" prot="public" static="no" const="no" explicit="no" inline="no" virt="non-virtual">
-        <type></type>
-        <definition>Aadvark::Aadvark</definition>
-        <argsstring>(int aaness)</argsstring>
-        <name>Aadvark</name>
-        <param>
-          <type>int</type>
-          <declname>aaness</declname>
-        </param>
-        <briefdescription>
-        </briefdescription>
-        <detaileddescription>
-<para><parameterlist kind="param"><parameteritem>
-<parameternamelist>
-<parametername>aaness</parametername>
-</parameternamelist>
-<parameterdescription>
-<para>The aadvarkness of an aadvark is a measure of how aadvarky it is. </para></parameterdescription>
-</parameteritem>
-</parameterlist>
-</para>        </detaileddescription>
-        <inbodydescription>
-        </inbodydescription>
-        <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.h" line="15" bodyfile="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.cc" bodystart="8" bodyend="8"/>
-      </memberdef>
-      <memberdef kind="function" id="classAadvark_1affd2ada0a85807efcbe26615a848f53e" prot="public" static="no" const="no" explicit="no" inline="no" virt="non-virtual">
-        <type>int</type>
-        <definition>int Aadvark::get_aadvarkness</definition>
-        <argsstring>()</argsstring>
-        <name>get_aadvarkness</name>
-        <briefdescription>
-        </briefdescription>
-        <detaileddescription>
-        </detaileddescription>
-        <inbodydescription>
-        </inbodydescription>
-        <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.h" line="16" bodyfile="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.cc" bodystart="17" bodyend="19"/>
-      </memberdef>
-      </sectiondef>
-    <briefdescription>
-<para>Models the mammal <ref refid="classAadvark" kindref="compound">Aadvark</ref>. </para>    </briefdescription>
-    <detaileddescription>
-<para>Sadly the model is incomplete and cannot capture all aspects of an aadvark yet.</para><para>This line is uninformative and is only to test line breaks in the comments. </para>    </detaileddescription>
-    <location file="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.h" line="10" bodyfile="/home/ben/gnuradio/gnuradio-core/src/python/gnuradio/utils/doxyxml/example/aadvark.h" bodystart="10" bodyend="19"/>
-    <listofallmembers>
-      <member refid="classAadvark_1adf1a4b97a641411a74a04ab312484462" prot="public" virt="non-virtual"><scope>Aadvark</scope><name>Aadvark</name></member>
-      <member refid="classAadvark_1ab79eb58d7bb9d5ddfa5d6f783836cab9" prot="private" virt="non-virtual"><scope>Aadvark</scope><name>aadvarkness</name></member>
-      <member refid="classAadvark_1affd2ada0a85807efcbe26615a848f53e" prot="public" virt="non-virtual"><scope>Aadvark</scope><name>get_aadvarkness</name></member>
-      <member refid="classAadvark_1abd061aa5f998002e72080a34f512a059" prot="public" virt="non-virtual"><scope>Aadvark</scope><name>print</name></member>
-    </listofallmembers>
-  </compounddef>
-</doxygen>

docs/doxygen/doxyxml/example/xml/combine.xslt

@@ -1,15 +0,0 @@
-<!-- XSLT script to combine the generated output into a single file. 
-     If you have xsltproc you could use:
-     xsltproc combine.xslt index.xml >all.xml
--->
-<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
-  <xsl:output method="xml" version="1.0" indent="yes" standalone="yes" />
-  <xsl:template match="/">
-    <doxygen version="{doxygenindex/@version}">
-      <!-- Load all doxgen generated xml files -->
-      <xsl:for-each select="doxygenindex/compound">
-        <xsl:copy-of select="document( concat( @refid, '.xml' ) )/doxygen/*" />
-      </xsl:for-each>
-    </doxygen>
-  </xsl:template>
-</xsl:stylesheet>

docs/doxygen/doxyxml/example/xml/compound.xsd

@@ -1,814 +0,0 @@
-<?xml version='1.0' encoding='utf-8' ?>
-<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-  <xsd:element name="doxygen" type="DoxygenType"/>
-
-  <!-- Complex types -->
-
-  <xsd:complexType name="DoxygenType">
-    <xsd:sequence maxOccurs="unbounded">
-      <xsd:element name="compounddef" type="compounddefType" minOccurs="0" />
-    </xsd:sequence>
-    <xsd:attribute name="version" type="DoxVersionNumber" use="required" />
-  </xsd:complexType>
-
-  <xsd:complexType name="compounddefType">
-    <xsd:sequence>
-      <xsd:element name="compoundname" type="xsd:string"/>
-      <xsd:element name="title" type="xsd:string" minOccurs="0" />
-      <xsd:element name="basecompoundref" type="compoundRefType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="derivedcompoundref" type="compoundRefType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="includes" type="incType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="includedby" type="incType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="incdepgraph" type="graphType" minOccurs="0" />
-      <xsd:element name="invincdepgraph" type="graphType" minOccurs="0" />
-      <xsd:element name="innerdir" type="refType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="innerfile" type="refType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="innerclass" type="refType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="innernamespace" type="refType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="innerpage" type="refType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="innergroup" type="refType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="templateparamlist" type="templateparamlistType" minOccurs="0" />
-      <xsd:element name="sectiondef" type="sectiondefType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="briefdescription" type="descriptionType" minOccurs="0" />
-      <xsd:element name="detaileddescription" type="descriptionType" minOccurs="0" />
-      <xsd:element name="inheritancegraph" type="graphType" minOccurs="0" />
-      <xsd:element name="collaborationgraph" type="graphType" minOccurs="0" />
-      <xsd:element name="programlisting" type="listingType" minOccurs="0" />
-      <xsd:element name="location" type="locationType" minOccurs="0" />
-      <xsd:element name="listofallmembers" type="listofallmembersType" minOccurs="0" />
-    </xsd:sequence>
-    <xsd:attribute name="id" type="xsd:string" />
-    <xsd:attribute name="kind" type="DoxCompoundKind" />
-    <xsd:attribute name="prot" type="DoxProtectionKind" />
-  </xsd:complexType>
-
-  <xsd:complexType name="listofallmembersType">
-    <xsd:sequence>
-      <xsd:element name="member" type="memberRefType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="memberRefType">
-    <xsd:sequence>
-      <xsd:element name="scope" />
-      <xsd:element name="name" />
-    </xsd:sequence>
-    <xsd:attribute name="refid" type="xsd:string" />
-    <xsd:attribute name="prot" type="DoxProtectionKind" />
-    <xsd:attribute name="virt" type="DoxVirtualKind" />
-    <xsd:attribute name="ambiguityscope" type="xsd:string" />
-  </xsd:complexType>
-
-  <xsd:complexType name="compoundRefType" mixed="true">
-    <xsd:simpleContent>
-      <xsd:extension base="xsd:string">
-        <xsd:attribute name="refid" type="xsd:string" use="optional" />
-        <xsd:attribute name="prot" type="DoxProtectionKind" />
-        <xsd:attribute name="virt" type="DoxVirtualKind" />
-      </xsd:extension>
-    </xsd:simpleContent>
-  </xsd:complexType>
-
-  <xsd:complexType name="reimplementType" mixed="true">
-    <xsd:simpleContent>
-      <xsd:extension base="xsd:string">
-        <xsd:attribute name="refid" type="xsd:string" />
-      </xsd:extension>
-    </xsd:simpleContent>
-  </xsd:complexType>
-
-  <xsd:complexType name="incType" mixed="true">
-    <xsd:simpleContent>
-      <xsd:extension base="xsd:string">
-        <xsd:attribute name="refid" type="xsd:string" />
-        <xsd:attribute name="local" type="DoxBool" />
-      </xsd:extension>
-    </xsd:simpleContent>
-  </xsd:complexType>
-
-  <xsd:complexType name="refType" mixed="true">
-    <xsd:simpleContent>
-      <xsd:extension base="xsd:string">
-        <xsd:attribute name="refid" type="xsd:string" />
-        <xsd:attribute name="prot" type="DoxProtectionKind" use="optional"/>
-      </xsd:extension>
-    </xsd:simpleContent>
-  </xsd:complexType>
-
-  <xsd:complexType name="refTextType" mixed="true">
-    <xsd:simpleContent>
-      <xsd:extension base="xsd:string">
-       <xsd:attribute name="refid" type="xsd:string" />
-       <xsd:attribute name="kindref" type="DoxRefKind" />
-       <xsd:attribute name="external" type="xsd:string" use="optional"/>
-       <xsd:attribute name="tooltip" type="xsd:string" use="optional"/>
-      </xsd:extension>
-    </xsd:simpleContent>
-  </xsd:complexType>
-
-  <xsd:complexType name="sectiondefType">
-    <xsd:sequence>
-      <xsd:element name="header" type="xsd:string" minOccurs="0" />
-      <xsd:element name="description" type="descriptionType" minOccurs="0" />
-      <xsd:element name="memberdef" type="memberdefType" maxOccurs="unbounded" />
-    </xsd:sequence>
-    <xsd:attribute name="kind" type="DoxSectionKind" />
-  </xsd:complexType>
-
-  <xsd:complexType name="memberdefType">
-    <xsd:sequence>
-      <xsd:element name="templateparamlist" type="templateparamlistType" minOccurs="0" />
-      <xsd:element name="type" type="linkedTextType" minOccurs="0" />
-      <xsd:element name="definition" minOccurs="0" />
-      <xsd:element name="argsstring" minOccurs="0" />
-      <xsd:element name="name" />
-      <xsd:element name="read" minOccurs="0" />
-      <xsd:element name="write" minOccurs="0" />
-      <xsd:element name="bitfield" minOccurs="0" />
-      <xsd:element name="reimplements" type="reimplementType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="reimplementedby" type="reimplementType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="param" type="paramType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="enumvalue" type="enumvalueType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="initializer" type="linkedTextType" minOccurs="0" />
-      <xsd:element name="exceptions" type="linkedTextType" minOccurs="0" />
-      <xsd:element name="briefdescription" type="descriptionType" minOccurs="0" />
-      <xsd:element name="detaileddescription" type="descriptionType" minOccurs="0" />
-      <xsd:element name="inbodydescription" type="descriptionType" minOccurs="0" />
-      <xsd:element name="location" type="locationType" />
-      <xsd:element name="references" type="referenceType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="referencedby" type="referenceType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-    <xsd:attribute name="kind" type="DoxMemberKind" />
-    <xsd:attribute name="id" type="xsd:string" />
-    <xsd:attribute name="prot" type="DoxProtectionKind" />
-    <xsd:attribute name="static" type="DoxBool" />
-    <xsd:attribute name="const" type="DoxBool" />
-    <xsd:attribute name="explicit" type="DoxBool" />
-    <xsd:attribute name="inline" type="DoxBool" />
-    <xsd:attribute name="virt" type="DoxVirtualKind" />
-    <xsd:attribute name="volatile" type="DoxBool" />
-    <xsd:attribute name="mutable" type="DoxBool" />
-    <!-- Qt property -->
-    <xsd:attribute name="readable" type="DoxBool" use="optional"/>
-    <xsd:attribute name="writable" type="DoxBool" use="optional"/>
-    <!-- C++/CLI variable -->
-    <xsd:attribute name="initonly" type="DoxBool" use="optional"/>
-    <!-- C++/CLI and C# property -->
-    <xsd:attribute name="settable" type="DoxBool" use="optional"/>
-    <xsd:attribute name="gettable" type="DoxBool" use="optional"/>
-    <!-- C++/CLI function -->
-    <xsd:attribute name="final" type="DoxBool" use="optional"/>
-    <xsd:attribute name="sealed" type="DoxBool" use="optional"/>
-    <xsd:attribute name="new" type="DoxBool" use="optional"/>
-    <!-- C++/CLI event -->
-    <xsd:attribute name="add" type="DoxBool" use="optional"/>
-    <xsd:attribute name="remove" type="DoxBool" use="optional"/>
-    <xsd:attribute name="raise" type="DoxBool" use="optional"/>
-    <!-- Objective-C 2.0 protocol method -->
-    <xsd:attribute name="optional" type="DoxBool" use="optional"/>
-    <xsd:attribute name="required" type="DoxBool" use="optional"/>
-    <!-- Objective-C 2.0 property accessor -->
-    <xsd:attribute name="accessor" type="DoxAccessor" use="optional"/>
-  </xsd:complexType>
-
-  <xsd:complexType name="descriptionType" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="title" type="xsd:string" minOccurs="0"/>	    
-      <xsd:element name="para" type="docParaType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="sect1" type="docSect1Type" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="internal" type="docInternalType" minOccurs="0" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="enumvalueType" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="name" />
-      <xsd:element name="initializer" type="linkedTextType" minOccurs="0" />
-      <xsd:element name="briefdescription" type="descriptionType" minOccurs="0" />
-      <xsd:element name="detaileddescription" type="descriptionType" minOccurs="0" />
-    </xsd:sequence>
-    <xsd:attribute name="id" type="xsd:string" />
-    <xsd:attribute name="prot" type="DoxProtectionKind" />
-  </xsd:complexType>
-
-  <xsd:complexType name="templateparamlistType">
-    <xsd:sequence>
-      <xsd:element name="param" type="paramType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="paramType">
-    <xsd:sequence>
-      <xsd:element name="type" type="linkedTextType" minOccurs="0" />
-      <xsd:element name="declname" minOccurs="0" />
-      <xsd:element name="defname" minOccurs="0" />
-      <xsd:element name="array" minOccurs="0" />
-      <xsd:element name="defval" type="linkedTextType" minOccurs="0" />
-      <xsd:element name="briefdescription" type="descriptionType" minOccurs="0" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="linkedTextType" mixed="true">
-    <xsd:sequence>
-    <xsd:element name="ref" type="refTextType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="graphType">
-    <xsd:sequence>
-      <xsd:element name="node" type="nodeType" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="nodeType">
-    <xsd:sequence>
-      <xsd:element name="label" />
-      <xsd:element name="link" type="linkType" minOccurs="0" />
-      <xsd:element name="childnode" type="childnodeType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-    <xsd:attribute name="id" type="xsd:string" />
-  </xsd:complexType>
-
-  <xsd:complexType name="childnodeType">
-    <xsd:sequence>
-      <xsd:element name="edgelabel" minOccurs="0" maxOccurs="unbounded"/>
-    </xsd:sequence>
-    <xsd:attribute name="refid" type="xsd:string" />
-    <xsd:attribute name="relation" type="DoxGraphRelation" />
-  </xsd:complexType>
-
-  <xsd:complexType name="linkType">
-    <xsd:attribute name="refid" type="xsd:string" />
-    <xsd:attribute name="external" type="xsd:string" use="optional"/>
-  </xsd:complexType>
-
-  <xsd:complexType name="listingType">
-    <xsd:sequence>
-      <xsd:element name="codeline" type="codelineType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="codelineType">
-    <xsd:sequence>
-      <xsd:element name="highlight" type="highlightType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-    <xsd:attribute name="lineno" type="xsd:integer" />
-    <xsd:attribute name="refid" type="xsd:string" />
-    <xsd:attribute name="refkind" type="DoxRefKind" />
-    <xsd:attribute name="external" type="DoxBool" />
-  </xsd:complexType>
-
-  <xsd:complexType name="highlightType" mixed="true">
-    <xsd:choice minOccurs="0" maxOccurs="unbounded">
-      <xsd:element name="sp" />
-      <xsd:element name="ref" type="refTextType" />
-    </xsd:choice>
-    <xsd:attribute name="class" type="DoxHighlightClass" />
-  </xsd:complexType>
-
-  <xsd:complexType name="referenceType" mixed="true">
-    <xsd:attribute name="refid" type="xsd:string" />
-    <xsd:attribute name="compoundref" type="xsd:string" use="optional" />
-    <xsd:attribute name="startline" type="xsd:integer" />
-    <xsd:attribute name="endline" type="xsd:integer" />
-  </xsd:complexType>
-
-  <xsd:complexType name="locationType">
-    <xsd:attribute name="file" type="xsd:string" />
-    <xsd:attribute name="line" type="xsd:integer" />
-    <xsd:attribute name="bodyfile" type="xsd:string" />
-    <xsd:attribute name="bodystart" type="xsd:integer" />
-    <xsd:attribute name="bodyend" type="xsd:integer" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docSect1Type" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="title" type="xsd:string" />	    
-      <xsd:element name="para" type="docParaType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="sect2" type="docSect2Type" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="internal" type="docInternalS1Type" minOccurs="0" />
-    </xsd:sequence>
-    <xsd:attribute name="id" type="xsd:string" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docSect2Type" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="title" type="xsd:string" />	    
-      <xsd:element name="para" type="docParaType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="sect3" type="docSect3Type" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="internal" type="docInternalS2Type" minOccurs="0" />
-    </xsd:sequence>
-    <xsd:attribute name="id" type="xsd:string" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docSect3Type" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="title" type="xsd:string" />	    
-      <xsd:element name="para" type="docParaType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="sect4" type="docSect4Type" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="internal" type="docInternalS3Type" minOccurs="0" />
-    </xsd:sequence>
-    <xsd:attribute name="id" type="xsd:string" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docSect4Type" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="title" type="xsd:string" />	    
-      <xsd:element name="para" type="docParaType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="internal" type="docInternalS4Type" minOccurs="0" />
-    </xsd:sequence>
-    <xsd:attribute name="id" type="xsd:string" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docInternalType" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="para"  type="docParaType"  minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="sect1" type="docSect1Type" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docInternalS1Type" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="para"  type="docParaType"  minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="sect2" type="docSect2Type" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docInternalS2Type" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="para"  type="docParaType"  minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="sect3" type="docSect3Type" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docInternalS3Type" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="para"  type="docParaType"  minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="sect3" type="docSect4Type" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docInternalS4Type" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="para"  type="docParaType"  minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
- 
-  <xsd:group name="docTitleCmdGroup">
-    <xsd:choice>
-      <xsd:element name="ulink" type="docURLLink" />
-      <xsd:element name="bold" type="docMarkupType" />
-      <xsd:element name="emphasis" type="docMarkupType" />
-      <xsd:element name="computeroutput" type="docMarkupType" />
-      <xsd:element name="subscript" type="docMarkupType" />
-      <xsd:element name="superscript" type="docMarkupType" />
-      <xsd:element name="center" type="docMarkupType" />
-      <xsd:element name="small" type="docMarkupType" />
-      <xsd:element name="htmlonly" type="xsd:string" />
-      <xsd:element name="latexonly" type="xsd:string" />
-      <xsd:element name="dot" type="xsd:string" />
-      <xsd:element name="anchor" type="docAnchorType" />
-      <xsd:element name="formula" type="docFormulaType" />
-      <xsd:element name="ref" type="docRefTextType" />
-      <xsd:element name="copy" type="docEmptyType" />
-      <xsd:element name="trademark" type="docEmptyType" />
-      <xsd:element name="registered" type="docEmptyType" />
-      <xsd:element name="lsquo" type="docEmptyType" />
-      <xsd:element name="rsquo" type="docEmptyType" />
-      <xsd:element name="ldquo" type="docEmptyType" />
-      <xsd:element name="rdquo" type="docEmptyType" />
-      <xsd:element name="ndash" type="docEmptyType" />
-      <xsd:element name="mdash" type="docEmptyType" />
-      <xsd:element name="umlaut" type="docCharType" />
-      <xsd:element name="acute" type="docCharType" />
-      <xsd:element name="grave" type="docCharType" />
-      <xsd:element name="circ" type="docCharType" />
-      <xsd:element name="slash" type="docCharType" />
-      <xsd:element name="tilde" type="docCharType" />
-      <xsd:element name="cedil" type="docCharType" />
-      <xsd:element name="ring" type="docCharType" />
-      <xsd:element name="szlig" type="docEmptyType" />
-      <xsd:element name="nonbreakablespace" type="docEmptyType" />
-    </xsd:choice>
-  </xsd:group>
-
-  <xsd:complexType name="docTitleType" mixed="true">
-    <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
-  </xsd:complexType>
-
-  <xsd:group name="docCmdGroup">
-    <xsd:choice>
-      <xsd:group ref="docTitleCmdGroup"/>
-      <xsd:element name="linebreak" type="docEmptyType" />
-      <xsd:element name="hruler" type="docEmptyType" />
-      <xsd:element name="preformatted" type="docMarkupType" />
-      <xsd:element name="programlisting" type="listingType" />
-      <xsd:element name="verbatim" type="xsd:string" />
-      <xsd:element name="indexentry" type="docIndexEntryType" />
-      <xsd:element name="orderedlist" type="docListType" />
-      <xsd:element name="itemizedlist" type="docListType" />
-      <xsd:element name="simplesect" type="docSimpleSectType" />
-      <xsd:element name="title" type="docTitleType" />
-      <xsd:element name="variablelist" type="docVariableListType" />
-      <xsd:element name="table" type="docTableType" />
-      <xsd:element name="heading" type="docHeadingType" />
-      <xsd:element name="image" type="docImageType" />
-      <xsd:element name="dotfile" type="docDotFileType" />
-      <xsd:element name="toclist" type="docTocListType" />
-      <xsd:element name="language" type="docLanguageType" />
-      <xsd:element name="parameterlist" type="docParamListType" />
-      <xsd:element name="xrefsect" type="docXRefSectType" />
-      <xsd:element name="copydoc" type="docCopyType" />
-    </xsd:choice>
-  </xsd:group>
-
-  <xsd:complexType name="docParaType" mixed="true">
-    <xsd:group ref="docCmdGroup" minOccurs="0" maxOccurs="unbounded" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docMarkupType" mixed="true">
-    <xsd:group ref="docCmdGroup" minOccurs="0" maxOccurs="unbounded" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docURLLink" mixed="true">
-    <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
-    <xsd:attribute name="url" type="xsd:string" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docAnchorType" mixed="true">
-    <xsd:attribute name="id" type="xsd:string" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docFormulaType" mixed="true">
-    <xsd:attribute name="id" type="xsd:string" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docIndexEntryType">
-    <xsd:sequence>
-      <xsd:element name="primaryie" type="xsd:string" />
-      <xsd:element name="secondaryie" type="xsd:string" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docListType">
-    <xsd:sequence>
-      <xsd:element name="listitem" type="docListItemType" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docListItemType">
-    <xsd:sequence>
-      <xsd:element name="para" type="docParaType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docSimpleSectType">
-    <xsd:sequence>
-      <xsd:element name="title" type="docTitleType" minOccurs="0" />
-      <xsd:sequence minOccurs="0" maxOccurs="unbounded">
-        <xsd:element name="para" type="docParaType" minOccurs="1" maxOccurs="unbounded" />
-        <xsd:element name="simplesectsep" type="docEmptyType" minOccurs="0"/>
-      </xsd:sequence>
-    </xsd:sequence>
-    <xsd:attribute name="kind" type="DoxSimpleSectKind" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docVarListEntryType">
-    <xsd:sequence>
-      <xsd:element name="term" type="docTitleType" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:group name="docVariableListGroup">
-    <xsd:sequence>
-      <xsd:element name="varlistentry" type="docVarListEntryType" />
-      <xsd:element name="listitem" type="docListItemType" />
-    </xsd:sequence>
-  </xsd:group>
-
-  <xsd:complexType name="docVariableListType">
-    <xsd:sequence>
-      <xsd:group ref="docVariableListGroup" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docRefTextType" mixed="true">
-    <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
-    <xsd:attribute name="refid" type="xsd:string" />
-    <xsd:attribute name="kindref" type="DoxRefKind" />
-    <xsd:attribute name="external" type="xsd:string" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docTableType">
-    <xsd:sequence>
-      <xsd:element name="row" type="docRowType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="caption" type="docCaptionType" minOccurs="0" />
-    </xsd:sequence>
-    <xsd:attribute name="rows" type="xsd:integer" />
-    <xsd:attribute name="cols" type="xsd:integer" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docRowType">
-    <xsd:sequence>
-      <xsd:element name="entry" type="docEntryType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docEntryType">
-    <xsd:sequence>
-      <xsd:element name="para" type="docParaType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-    <xsd:attribute name="thead" type="DoxBool" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docCaptionType" mixed="true">
-    <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docHeadingType" mixed="true">
-    <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
-    <xsd:attribute name="level" type="xsd:integer" /> <!-- todo: range 1-6 -->
-  </xsd:complexType>
-
-  <xsd:complexType name="docImageType" mixed="true">
-    <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
-    <xsd:attribute name="type" type="DoxImageKind" /> 
-    <xsd:attribute name="name" type="xsd:string" /> 
-    <xsd:attribute name="width" type="xsd:string" /> 
-    <xsd:attribute name="height" type="xsd:string" /> 
-  </xsd:complexType>
-
-  <xsd:complexType name="docDotFileType" mixed="true">
-    <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
-    <xsd:attribute name="name" type="xsd:string" /> 
-  </xsd:complexType>
-
-  <xsd:complexType name="docTocItemType" mixed="true">
-    <xsd:group ref="docTitleCmdGroup" minOccurs="0" maxOccurs="unbounded" />
-    <xsd:attribute name="id" type="xsd:string" /> 
-  </xsd:complexType>
-
-  <xsd:complexType name="docTocListType">
-    <xsd:sequence>
-      <xsd:element name="tocitem" type="docTocItemType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docLanguageType">
-    <xsd:sequence>
-      <xsd:element name="para" type="docParaType" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-    <xsd:attribute name="langid" type="xsd:string" /> 
-  </xsd:complexType>
-
-  <xsd:complexType name="docParamListType">
-    <xsd:sequence>
-      <xsd:element name="parameteritem" type="docParamListItem" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-    <xsd:attribute name="kind" type="DoxParamListKind" /> 
-  </xsd:complexType>
-
-  <xsd:complexType name="docParamListItem">
-    <xsd:sequence>
-      <xsd:element name="parameternamelist" type="docParamNameList" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="parameterdescription" type="descriptionType" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docParamNameList">
-    <xsd:sequence>
-      <xsd:element name="parametername" type="docParamName" minOccurs="0" maxOccurs="unbounded" />
-    </xsd:sequence>
-  </xsd:complexType>
-
-  <xsd:complexType name="docParamName" mixed="true">
-    <xsd:sequence>
-      <xsd:element name="ref" type="refTextType" minOccurs="0" maxOccurs="1" />
-    </xsd:sequence>
-    <xsd:attribute name="direction" type="DoxParamDir" use="optional" />
-  </xsd:complexType>
-
-  <xsd:complexType name="docXRefSectType">
-    <xsd:sequence>
-      <xsd:element name="xreftitle" type="xsd:string" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="xrefdescription" type="descriptionType" />
-    </xsd:sequence>
-    <xsd:attribute name="id" type="xsd:string" /> 
-  </xsd:complexType>
-
-  <xsd:complexType name="docCopyType">
-    <xsd:sequence>
-      <xsd:element name="para" type="docParaType" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="sect1" type="docSect1Type" minOccurs="0" maxOccurs="unbounded" />
-      <xsd:element name="internal" type="docInternalType" minOccurs="0" />
-    </xsd:sequence>
-    <xsd:attribute name="link" type="xsd:string" /> 
-  </xsd:complexType>
-
-  <xsd:complexType name="docCharType">
-    <xsd:attribute name="char" type="DoxCharRange"/> 
-  </xsd:complexType>
-
-  <xsd:complexType name="docEmptyType"/>
-
-  <!-- Simple types -->
-
-  <xsd:simpleType name="DoxBool">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="yes" />
-      <xsd:enumeration value="no" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxGraphRelation">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="include" />
-      <xsd:enumeration value="usage" />
-      <xsd:enumeration value="template-instance" />
-      <xsd:enumeration value="public-inheritance" />
-      <xsd:enumeration value="protected-inheritance" />
-      <xsd:enumeration value="private-inheritance" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxRefKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="compound" />
-      <xsd:enumeration value="member" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxMemberKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="define" />
-      <xsd:enumeration value="property" />
-      <xsd:enumeration value="event" />
-      <xsd:enumeration value="variable" />
-      <xsd:enumeration value="typedef" />
-      <xsd:enumeration value="enum" />
-      <xsd:enumeration value="function" />
-      <xsd:enumeration value="signal" />
-      <xsd:enumeration value="prototype" />
-      <xsd:enumeration value="friend" />
-      <xsd:enumeration value="dcop" />
-      <xsd:enumeration value="slot" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxProtectionKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="public" />
-      <xsd:enumeration value="protected" />
-      <xsd:enumeration value="private" />
-      <xsd:enumeration value="package" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxVirtualKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="non-virtual" />
-      <xsd:enumeration value="virtual" />
-      <xsd:enumeration value="pure-virtual" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxCompoundKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="class" />
-      <xsd:enumeration value="struct" />
-      <xsd:enumeration value="union" />
-      <xsd:enumeration value="interface" />
-      <xsd:enumeration value="protocol" />
-      <xsd:enumeration value="category" />
-      <xsd:enumeration value="exception" />
-      <xsd:enumeration value="file" />
-      <xsd:enumeration value="namespace" />
-      <xsd:enumeration value="group" />
-      <xsd:enumeration value="page" />
-      <xsd:enumeration value="example" />
-      <xsd:enumeration value="dir" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxSectionKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="user-defined" />
-      <xsd:enumeration value="public-type" />
-      <xsd:enumeration value="public-func" />
-      <xsd:enumeration value="public-attrib" />
-      <xsd:enumeration value="public-slot" />
-      <xsd:enumeration value="signal" />
-      <xsd:enumeration value="dcop-func" />
-      <xsd:enumeration value="property" />
-      <xsd:enumeration value="event" />
-      <xsd:enumeration value="public-static-func" />
-      <xsd:enumeration value="public-static-attrib" />
-      <xsd:enumeration value="protected-type" />
-      <xsd:enumeration value="protected-func" />
-      <xsd:enumeration value="protected-attrib" />
-      <xsd:enumeration value="protected-slot" />
-      <xsd:enumeration value="protected-static-func" />
-      <xsd:enumeration value="protected-static-attrib" />
-      <xsd:enumeration value="package-type" />
-      <xsd:enumeration value="package-func" />
-      <xsd:enumeration value="package-attrib" />
-      <xsd:enumeration value="package-static-func" />
-      <xsd:enumeration value="package-static-attrib" />
-      <xsd:enumeration value="private-type" />
-      <xsd:enumeration value="private-func" />
-      <xsd:enumeration value="private-attrib" />
-      <xsd:enumeration value="private-slot" />
-      <xsd:enumeration value="private-static-func" />
-      <xsd:enumeration value="private-static-attrib" />
-      <xsd:enumeration value="friend" />
-      <xsd:enumeration value="related" />
-      <xsd:enumeration value="define" />
-      <xsd:enumeration value="prototype" />
-      <xsd:enumeration value="typedef" />
-      <xsd:enumeration value="enum" />
-      <xsd:enumeration value="func" />
-      <xsd:enumeration value="var" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxHighlightClass">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="comment" />
-      <xsd:enumeration value="normal" />
-      <xsd:enumeration value="preprocessor" />
-      <xsd:enumeration value="keyword" />
-      <xsd:enumeration value="keywordtype" />
-      <xsd:enumeration value="keywordflow" />
-      <xsd:enumeration value="stringliteral" />
-      <xsd:enumeration value="charliteral" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxSimpleSectKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="see" />
-      <xsd:enumeration value="return" />
-      <xsd:enumeration value="author" />
-      <xsd:enumeration value="authors" />
-      <xsd:enumeration value="version" />
-      <xsd:enumeration value="since" />
-      <xsd:enumeration value="date" />
-      <xsd:enumeration value="note" />
-      <xsd:enumeration value="warning" />
-      <xsd:enumeration value="pre" />
-      <xsd:enumeration value="post" />
-      <xsd:enumeration value="invariant" />
-      <xsd:enumeration value="remark" />
-      <xsd:enumeration value="attention" />
-      <xsd:enumeration value="par" />
-      <xsd:enumeration value="rcs" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxVersionNumber">
-    <xsd:restriction base="xsd:string">
-      <xsd:pattern value="\d+\.\d+.*" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxImageKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="html" />
-      <xsd:enumeration value="latex" />
-      <xsd:enumeration value="rtf" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxParamListKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="param" />
-      <xsd:enumeration value="retval" />
-      <xsd:enumeration value="exception" />
-      <xsd:enumeration value="templateparam" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxCharRange">
-    <xsd:restriction base="xsd:string">
-      <xsd:pattern value="[aeiouncAEIOUNC]" />
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxParamDir">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="in"/>
-      <xsd:enumeration value="out"/>
-      <xsd:enumeration value="inout"/>
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="DoxAccessor">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="retain"/>
-      <xsd:enumeration value="copy"/>
-      <xsd:enumeration value="assign"/>
-    </xsd:restriction>
-  </xsd:simpleType>
-
-</xsd:schema>
-

docs/doxygen/doxyxml/example/xml/index.xml

@@ -1,17 +0,0 @@
-<?xml version='1.0' encoding='UTF-8' standalone='no'?>
-<doxygenindex xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="index.xsd" version="1.6.3">
-  <compound refid="classAadvark" kind="class"><name>Aadvark</name>
-    <member refid="classAadvark_1ab79eb58d7bb9d5ddfa5d6f783836cab9" kind="variable"><name>aadvarkness</name></member>
-    <member refid="classAadvark_1abd061aa5f998002e72080a34f512a059" kind="function"><name>print</name></member>
-    <member refid="classAadvark_1adf1a4b97a641411a74a04ab312484462" kind="function"><name>Aadvark</name></member>
-    <member refid="classAadvark_1affd2ada0a85807efcbe26615a848f53e" kind="function"><name>get_aadvarkness</name></member>
-  </compound>
-  <compound refid="aadvark_8cc" kind="file"><name>aadvark.cc</name>
-    <member refid="aadvark_8cc_1acb52858524210ec6dddc3e16d1e52946" kind="function"><name>aadvarky_enough</name></member>
-    <member refid="aadvark_8cc_1ae66f6b31b5ad750f1fe042a706a4e3d4" kind="function"><name>main</name></member>
-  </compound>
-  <compound refid="aadvark_8h" kind="file"><name>aadvark.h</name>
-    <member refid="aadvark_8h_1acb52858524210ec6dddc3e16d1e52946" kind="function"><name>aadvarky_enough</name></member>
-    <member refid="aadvark_8h_1ae66f6b31b5ad750f1fe042a706a4e3d4" kind="function"><name>main</name></member>
-  </compound>
-</doxygenindex>

docs/doxygen/doxyxml/example/xml/index.xsd

@@ -1,66 +0,0 @@
-<?xml version='1.0' encoding='utf-8' ?>
-<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
-  <xsd:element name="doxygenindex" type="DoxygenType"/>
-
-  <xsd:complexType name="DoxygenType">
-    <xsd:sequence>
-      <xsd:element name="compound" type="CompoundType" minOccurs="0" maxOccurs="unbounded"/>
-    </xsd:sequence>
-    <xsd:attribute name="version" type="xsd:string" use="required"/>
-  </xsd:complexType>
-
-  <xsd:complexType name="CompoundType">
-    <xsd:sequence>
-      <xsd:element name="name" type="xsd:string"/>
-      <xsd:element name="member" type="MemberType" minOccurs="0" maxOccurs="unbounded"/>
-    </xsd:sequence>
-    <xsd:attribute name="refid" type="xsd:string" use="required"/>
-    <xsd:attribute name="kind" type="CompoundKind" use="required"/>
-  </xsd:complexType>
-
-  <xsd:complexType name="MemberType">
-    <xsd:sequence>
-      <xsd:element name="name" type="xsd:string"/>
-    </xsd:sequence>
-    <xsd:attribute name="refid" type="xsd:string" use="required"/>
-    <xsd:attribute name="kind" type="MemberKind" use="required"/>
-  </xsd:complexType>
-  
-  <xsd:simpleType name="CompoundKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="class"/>
-      <xsd:enumeration value="struct"/>
-      <xsd:enumeration value="union"/>
-      <xsd:enumeration value="interface"/>
-      <xsd:enumeration value="protocol"/>
-      <xsd:enumeration value="category"/>
-      <xsd:enumeration value="exception"/>
-      <xsd:enumeration value="file"/>
-      <xsd:enumeration value="namespace"/>
-      <xsd:enumeration value="group"/>
-      <xsd:enumeration value="page"/>
-      <xsd:enumeration value="example"/>
-      <xsd:enumeration value="dir"/>
-    </xsd:restriction>
-  </xsd:simpleType>
-
-  <xsd:simpleType name="MemberKind">
-    <xsd:restriction base="xsd:string">
-      <xsd:enumeration value="define"/>
-      <xsd:enumeration value="property"/>
-      <xsd:enumeration value="event"/>
-      <xsd:enumeration value="variable"/>
-      <xsd:enumeration value="typedef"/>
-      <xsd:enumeration value="enum"/>
-      <xsd:enumeration value="enumvalue"/>
-      <xsd:enumeration value="function"/>
-      <xsd:enumeration value="signal"/>
-      <xsd:enumeration value="prototype"/>
-      <xsd:enumeration value="friend"/>
-      <xsd:enumeration value="dcop"/>
-      <xsd:enumeration value="slot"/>
-    </xsd:restriction>
-  </xsd:simpleType>
-
-</xsd:schema>
-

docs/doxygen/doxyxml/generated/compound.py

@@ -4,14 +4,14 @@
 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
+from . import compoundsuper as supermod
+from .compoundsuper import MixedContainer
 
 
 class DoxygenTypeSub(supermod.DoxygenType):

docs/doxygen/doxyxml/generated/compoundsuper.py

@@ -4,9 +4,9 @@
 # Generated Thu Jun 11 18:44:25 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
 
@@ -19,9 +19,9 @@ from xml.dom import Node
 
 try:
     from generatedssuper import GeneratedsSuper
-except ImportError, exp:
+except ImportError as exp:
 
-    class GeneratedsSuper:
+    class GeneratedsSuper(object):
         def format_string(self, input_data, input_name=''):
             return input_data
         def format_integer(self, input_data, input_name=''):
@@ -64,7 +64,7 @@ def showIndent(outfile, level):
         outfile.write('    ')
 
 def quote_xml(inStr):
-    s1 = (isinstance(inStr, basestring) and inStr or
+    s1 = (isinstance(inStr, str) and inStr or
           '%s' % inStr)
     s1 = s1.replace('&', '&')
     s1 = s1.replace('<', '&lt;')
@@ -72,7 +72,7 @@ def quote_xml(inStr):
     return s1
 
 def quote_attrib(inStr):
-    s1 = (isinstance(inStr, basestring) and inStr or
+    s1 = (isinstance(inStr, str) and inStr or
           '%s' % inStr)
     s1 = s1.replace('&', '&amp;')
     s1 = s1.replace('<', '&lt;')
@@ -102,7 +102,7 @@ def quote_python(inStr):
             return '"""%s"""' % s1
 
 
-class MixedContainer:
+class MixedContainer(object):
     # Constants for category:
     CategoryNone = 0
     CategoryText = 1
@@ -4221,7 +4221,7 @@ class codelineType(GeneratedsSuper):
         if attrs.get('lineno'):
             try:
                 self.lineno = int(attrs.get('lineno').value)
-            except ValueError, exp:
+            except ValueError as exp:
                 raise ValueError('Bad integer attribute (lineno): %s' % exp)
         if attrs.get('refkind'):
             self.refkind = attrs.get('refkind').value
@@ -4504,12 +4504,12 @@ class referenceType(GeneratedsSuper):
         if attrs.get('endline'):
             try:
                 self.endline = int(attrs.get('endline').value)
-            except ValueError, exp:
+            except ValueError as exp:
                 raise ValueError('Bad integer attribute (endline): %s' % exp)
         if attrs.get('startline'):
             try:
                 self.startline = int(attrs.get('startline').value)
-            except ValueError, exp:
+            except ValueError as exp:
                 raise ValueError('Bad integer attribute (startline): %s' % exp)
         if attrs.get('refid'):
             self.refid = attrs.get('refid').value
@@ -4627,17 +4627,17 @@ class locationType(GeneratedsSuper):
         if attrs.get('bodystart'):
             try:
                 self.bodystart = int(attrs.get('bodystart').value)
-            except ValueError, exp:
+            except ValueError as exp:
                 raise ValueError('Bad integer attribute (bodystart): %s' % exp)
         if attrs.get('line'):
             try:
                 self.line = int(attrs.get('line').value)
-            except ValueError, exp:
+            except ValueError as exp:
                 raise ValueError('Bad integer attribute (line): %s' % exp)
         if attrs.get('bodyend'):
             try:
                 self.bodyend = int(attrs.get('bodyend').value)
-            except ValueError, exp:
+            except ValueError as exp:
                 raise ValueError('Bad integer attribute (bodyend): %s' % exp)
         if attrs.get('bodyfile'):
             self.bodyfile = attrs.get('bodyfile').value
@@ -6778,12 +6778,12 @@ class docTableType(GeneratedsSuper):
         if attrs.get('rows'):
             try:
                 self.rows = int(attrs.get('rows').value)
-            except ValueError, exp:
+            except ValueError as exp:
                 raise ValueError('Bad integer attribute (rows): %s' % exp)
         if attrs.get('cols'):
             try:
                 self.cols = int(attrs.get('cols').value)
-            except ValueError, exp:
+            except ValueError as exp:
                 raise ValueError('Bad integer attribute (cols): %s' % exp)
     def buildChildren(self, child_, nodeName_):
         if child_.nodeType == Node.ELEMENT_NODE and \
@@ -7108,7 +7108,7 @@ class docHeadingType(GeneratedsSuper):
         if attrs.get('level'):
             try:
                 self.level = int(attrs.get('level').value)
-            except ValueError, exp:
+            except ValueError as exp:
                 raise ValueError('Bad integer attribute (level): %s' % exp)
     def buildChildren(self, child_, nodeName_):
         if child_.nodeType == Node.TEXT_NODE:
@@ -8283,7 +8283,7 @@ Options:
 """
 
 def usage():
-    print USAGE_TEXT
+    print(USAGE_TEXT)
     sys.exit(1)
 
 
@@ -8339,4 +8339,3 @@ if __name__ == '__main__':
     main()
     #import pdb
     #pdb.run('main()')
-

docs/doxygen/doxyxml/generated/index.py

@@ -8,9 +8,9 @@ from xml.dom import minidom
 
 import os
 import sys
-import compound
+from . import compound
 
-import indexsuper as supermod
+from . import indexsuper as supermod
 
 class DoxygenTypeSub(supermod.DoxygenType):
     def __init__(self, version=None, compound=None):

docs/doxygen/doxyxml/generated/indexsuper.py

@@ -4,9 +4,9 @@
 # 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
 
@@ -19,9 +19,9 @@ from xml.dom import Node
 
 try:
     from generatedssuper import GeneratedsSuper
-except ImportError, exp:
+except ImportError as exp:
 
-    class GeneratedsSuper:
+    class GeneratedsSuper(object):
         def format_string(self, input_data, input_name=''):
             return input_data
         def format_integer(self, input_data, input_name=''):
@@ -64,7 +64,7 @@ def showIndent(outfile, level):
         outfile.write('    ')
 
 def quote_xml(inStr):
-    s1 = (isinstance(inStr, basestring) and inStr or
+    s1 = (isinstance(inStr, str) and inStr or
           '%s' % inStr)
     s1 = s1.replace('&', '&')
     s1 = s1.replace('<', '&lt;')
@@ -72,7 +72,7 @@ def quote_xml(inStr):
     return s1
 
 def quote_attrib(inStr):
-    s1 = (isinstance(inStr, basestring) and inStr or
+    s1 = (isinstance(inStr, str) and inStr or
           '%s' % inStr)
     s1 = s1.replace('&', '&amp;')
     s1 = s1.replace('<', '&lt;')
@@ -102,7 +102,7 @@ def quote_python(inStr):
             return '"""%s"""' % s1
 
 
-class MixedContainer:
+class MixedContainer(object):
     # Constants for category:
     CategoryNone = 0
     CategoryText = 1
@@ -462,7 +462,7 @@ Options:
 """
 
 def usage():
-    print USAGE_TEXT
+    print(USAGE_TEXT)
     sys.exit(1)
 
 
@@ -520,4 +520,3 @@ if __name__ == '__main__':
     main()
     #import pdb
     #pdb.run('main()')
-

docs/doxygen/doxyxml/run_tests.in

@@ -1,16 +0,0 @@
-#!/bin/sh
-
-# 1st parameter is absolute path to component source directory
-# 2nd parameter is absolute path to component build directory
-# 3rd parameter is path to Python QA directory
-
-# Note: calling master run_tests.sh in gnuradio core is not strictly
-# correct, as it will result in a partially bogus PYTHONPATH, but it
-# does make the correct paths in the second half so all is well.
-
-@PYTHON@ @srcdir@/__init__.py
-
-# @top_builddir@/run_tests.sh \
-#    @abs_top_srcdir@/gnuradio-core \
-#    @abs_top_builddir@/gnuradio-core \
-#    @srcdir@

docs/doxygen/doxyxml/text.py

@@ -1,23 +1,12 @@
 #
 # 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.
-# 
+#
+# This file was generated by gr_modtool, a tool from the GNU Radio framework
+# This file is a part of gr-air-modes
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+#
 """
 Utilities for extracting text from generated classes.
 """
@@ -26,7 +15,7 @@ def is_string(txt):
     if isinstance(txt, str):
         return True
     try:
-        if isinstance(txt, unicode):
+        if isinstance(txt, str):
             return True
     except NameError:
         pass
@@ -49,7 +38,7 @@ def description_bit(obj):
     elif is_string(obj):
         return obj
     else:
-        raise StandardError('Expecting a string or something with content, content_ or value attribute')
+        raise Exception('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"

docs/doxygen/other/group_defs.dox

@@ -1,6 +1,6 @@
-/*!  
- * \defgroup block GNU Radio GR-AIR-MODES C++ Signal Processing Blocks 
- * \brief All C++ blocks that can be used from the GR-AIR-MODES GNU Radio
+/*!
+ * \defgroup block GNU Radio gr-air-modes C++ Signal Processing Blocks
+ * \brief All C++ blocks that can be used from the gr-air-modes GNU Radio
  *        module are listed here or in the subcategories below.
  *
  */

docs/doxygen/other/main_page.dox

@@ -1,8 +1,8 @@
 /*! \mainpage
 
-Welcome to the GNU Radio GR-AIR-MODES Block
+Welcome to the GNU Radio gr-air-modes Block
 
-This is the intro page for the Doxygen manual generated for the GR-AIR-MODES
+This is the intro page for the Doxygen manual generated for the gr-air-modes
 block (docs/doxygen/other/main_page.dox). Edit it to add more detailed
 documentation about the new GNU Radio modules contained in this
 project.

docs/doxygen/pydoc_macros.h

@@ -0,0 +1,19 @@
+#ifndef PYDOC_MACROS_H
+#define PYDOC_MACROS_H
+
+#define __EXPAND(x) x
+#define __COUNT(_1, _2, _3, _4, _5, _6, _7, COUNT, ...) COUNT
+#define __VA_SIZE(...) __EXPAND(__COUNT(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1))
+#define __CAT1(a, b) a##b
+#define __CAT2(a, b) __CAT1(a, b)
+#define __DOC1(n1) __doc_##n1
+#define __DOC2(n1, n2) __doc_##n1##_##n2
+#define __DOC3(n1, n2, n3) __doc_##n1##_##n2##_##n3
+#define __DOC4(n1, n2, n3, n4) __doc_##n1##_##n2##_##n3##_##n4
+#define __DOC5(n1, n2, n3, n4, n5) __doc_##n1##_##n2##_##n3##_##n4##_##n5
+#define __DOC6(n1, n2, n3, n4, n5, n6) __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6
+#define __DOC7(n1, n2, n3, n4, n5, n6, n7) \
+    __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6##_##n7
+#define DOC(...) __EXPAND(__EXPAND(__CAT2(__DOC, __VA_SIZE(__VA_ARGS__)))(__VA_ARGS__))
+
+#endif // PYDOC_MACROS_H

docs/doxygen/swig_doc.py

@@ -1,253 +0,0 @@
-#
-# Copyright 2010,2011 Free Software Foundation, Inc.
-# 
-# This file is part of GNU Radio
-# 
-# GNU Radio is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 3, or (at your option)
-# any later version.
-# 
-# GNU Radio is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-# 
-# You should have received a copy of the GNU General Public License
-# along with GNU Radio; see the file COPYING.  If not, write to
-# the Free Software Foundation, Inc., 51 Franklin Street,
-# Boston, MA 02110-1301, USA.
-# 
-"""
-Creates the swig_doc.i SWIG interface file.
-Execute using: python swig_doc.py xml_path outputfilename
-
-The file instructs SWIG to transfer the doxygen comments into the
-python docstrings.
-
-"""
-
-import sys
-
-try:
-    from doxyxml import DoxyIndex, DoxyClass, DoxyFriend, DoxyFunction, DoxyFile, base
-except ImportError:
-    from gnuradio.doxyxml import DoxyIndex, DoxyClass, DoxyFriend, DoxyFunction, DoxyFile, base
-
-
-def py_name(name):
-    bits = name.split('_')
-    return '_'.join(bits[1:])
-
-def make_name(name):
-    bits = name.split('_')
-    return bits[0] + '_make_' + '_'.join(bits[1:])
-
-
-class Block(object):
-    """
-    Checks if doxyxml produced objects correspond to a gnuradio block.
-    """
-
-    @classmethod
-    def includes(cls, item):
-        if not isinstance(item, DoxyClass):
-            return False
-        # Check for a parsing error.
-        if item.error():
-            return False
-        return item.has_member(make_name(item.name()), DoxyFriend)
-
-
-def utoascii(text):
-    """
-    Convert unicode text into ascii and escape quotes.
-    """
-    if text is None:
-        return ''
-    out = text.encode('ascii', 'replace')
-    out = out.replace('"', '\\"')
-    return out
-
-
-def combine_descriptions(obj):
-    """
-    Combines the brief and detailed descriptions of an object together.
-    """
-    description = []
-    bd = obj.brief_description.strip()
-    dd = obj.detailed_description.strip()
-    if bd:
-        description.append(bd)
-    if dd:
-        description.append(dd)
-    return utoascii('\n\n'.join(description)).strip()
-    
-
-entry_templ = '%feature("docstring") {name} "{docstring}"'
-def make_entry(obj, name=None, templ="{description}", description=None):
-    """
-    Create a docstring entry for a swig interface file.
-    
-    obj - a doxyxml object from which documentation will be extracted.
-    name - the name of the C object (defaults to obj.name())
-    templ - an optional template for the docstring containing only one
-            variable named 'description'.
-    description - if this optional variable is set then it's value is
-            used as the description instead of extracting it from obj.
-    """
-    if name is None:
-        name=obj.name()
-    if 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)

docs/doxygen/update_pydoc.py

@@ -0,0 +1,346 @@
+#
+# Copyright 2010-2012 Free Software Foundation, Inc.
+#
+# This file was generated by gr_modtool, a tool from the GNU Radio framework
+# This file is a part of gnuradio
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+#
+"""
+Updates the *pydoc_h files for a module
+Execute using: python update_pydoc.py xml_path outputfilename
+
+The file instructs Pybind11 to transfer the doxygen comments into the
+python docstrings.
+
+"""
+
+import os, sys, time, glob, re, json
+from argparse import ArgumentParser
+
+from doxyxml import DoxyIndex, DoxyClass, DoxyFriend, DoxyFunction, DoxyFile
+from doxyxml import DoxyOther, base
+
+def py_name(name):
+    bits = name.split('_')
+    return '_'.join(bits[1:])
+
+def make_name(name):
+    bits = name.split('_')
+    return bits[0] + '_make_' + '_'.join(bits[1:])
+
+
+class Block(object):
+    """
+    Checks if doxyxml produced objects correspond to a gnuradio block.
+    """
+
+    @classmethod
+    def includes(cls, item):
+        if not isinstance(item, DoxyClass):
+            return False
+        # Check for a parsing error.
+        if item.error():
+            return False
+        friendname = make_name(item.name())
+        is_a_block = item.has_member(friendname, DoxyFriend)
+        # But now sometimes the make function isn't a friend so check again.
+        if not is_a_block:
+            is_a_block = di.has_member(friendname, DoxyFunction)
+        return is_a_block
+
+class Block2(object):
+    """
+    Checks if doxyxml produced objects correspond to a new style
+    gnuradio block.
+    """
+
+    @classmethod
+    def includes(cls, item):
+        if not isinstance(item, DoxyClass):
+            return False
+        # Check for a parsing error.
+        if item.error():
+            return False
+        is_a_block2 = item.has_member('make', DoxyFunction) and item.has_member('sptr', DoxyOther)
+        return is_a_block2
+
+
+def utoascii(text):
+    """
+    Convert unicode text into ascii and escape quotes and backslashes.
+    """
+    if text is None:
+        return ''
+    out = text.encode('ascii', 'replace')
+    # swig will require us to replace blackslash with 4 backslashes
+    # TODO: evaluate what this should be for pybind11
+    out = out.replace(b'\\', b'\\\\\\\\')
+    out = out.replace(b'"', b'\\"').decode('ascii')
+    return str(out)
+
+
+def combine_descriptions(obj):
+    """
+    Combines the brief and detailed descriptions of an object together.
+    """
+    description = []
+    bd = obj.brief_description.strip()
+    dd = obj.detailed_description.strip()
+    if bd:
+        description.append(bd)
+    if dd:
+        description.append(dd)
+    return utoascii('\n\n'.join(description)).strip()
+
+def format_params(parameteritems):
+    output = ['Args:']
+    template = '    {0} : {1}'
+    for pi in parameteritems:
+        output.append(template.format(pi.name, pi.description))
+    return '\n'.join(output)
+
+entry_templ = '%feature("docstring") {name} "{docstring}"'
+def make_entry(obj, name=None, templ="{description}", description=None, params=[]):
+    """
+    Create a docstring key/value pair, where the key is the object name.
+
+    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 hasattr(obj,'_parse_data') and hasattr(obj._parse_data,'definition'):
+            name=obj._parse_data.definition.split(' ')[-1]
+    if "operator " in name:
+        return ''
+    if description is None:
+        description = combine_descriptions(obj)
+    if params:
+        description += '\n\n'
+        description += utoascii(format_params(params))
+    docstring = templ.format(description=description)
+
+    return {name: docstring}
+
+
+def make_class_entry(klass, description=None, ignored_methods=[], params=None):
+    """
+    Create a class docstring key/value pair.
+    """
+    if params is None:
+        params = klass.params
+    output = {}
+    output.update(make_entry(klass, description=description, params=params))
+    for func in klass.in_category(DoxyFunction):
+        if func.name() not in ignored_methods:
+            name = klass.name() + '::' + func.name()
+            output.update(make_entry(func, name=name))
+    return output
+
+
+def make_block_entry(di, block):
+    """
+    Create class and function docstrings of a gnuradio block
+    """
+    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.update(make_class_entry(block, description=super_description))
+    output.update(make_entry(make_func, description=super_description,
+                                  params=block.params))
+    return output
+
+def make_block2_entry(di, block):
+    """
+    Create class and function docstrings of a new style gnuradio block
+    """
+    # For new style blocks all the relevant documentation should be
+    # associated with the 'make' method.
+    class_description = combine_descriptions(block)
+    make_func = block.get_member('make', DoxyFunction)
+    make_description = combine_descriptions(make_func)
+    description = class_description + "\n\nConstructor Specific Documentation:\n\n" + make_description
+    # Associate the combined description with the class and
+    # the make function.
+    output = {}
+    output.update(make_class_entry(
+            block, description=description,
+            ignored_methods=['make'], params=make_func.params))
+    makename = block.name() + '::make'
+    output.update(make_entry(
+            make_func, name=makename, description=description,
+            params=make_func.params))
+    return output
+
+def get_docstrings_dict(di, custom_output=None):
+
+    output = {}
+    if custom_output:
+        output.update(custom_output)
+
+    # Create docstrings for the blocks.
+    blocks = di.in_category(Block)
+    blocks2 = di.in_category(Block2)
+
+    make_funcs = set([])
+    for block in blocks:
+        try:
+            make_func = di.get_member(make_name(block.name()), DoxyFunction)
+            # Don't want to risk writing to output twice.
+            if make_func.name() not in make_funcs:
+                make_funcs.add(make_func.name())
+                output.update(make_block_entry(di, block))
+        except block.ParsingError:
+            sys.stderr.write('Parsing error for block {0}\n'.format(block.name()))
+            raise
+
+    for block in blocks2:
+        try:
+            make_func = block.get_member('make', DoxyFunction)
+            make_func_name = block.name() +'::make'
+            # Don't want to risk writing to output twice.
+            if make_func_name not in make_funcs:
+                make_funcs.add(make_func_name)
+                output.update(make_block2_entry(di, block))
+        except block.ParsingError:
+            sys.stderr.write('Parsing error for block {0}\n'.format(block.name()))
+            raise
+
+    # Create docstrings for functions
+    # Don't include the make functions since they have already been dealt with.
+    funcs = [f for f in di.in_category(DoxyFunction)
+             if f.name() not in make_funcs and not f.name().startswith('std::')]
+    for f in funcs:
+        try:
+            output.update(make_entry(f))
+        except f.ParsingError:
+            sys.stderr.write('Parsing error for function {0}\n'.format(f.name()))
+
+    # Create docstrings for classes
+    block_names = [block.name() for block in blocks]
+    block_names += [block.name() for block in blocks2]
+    klasses = [k for k in di.in_category(DoxyClass)
+               if k.name() not in block_names and not k.name().startswith('std::')]
+    for k in klasses:
+        try:
+            output.update(make_class_entry(k))
+        except k.ParsingError:
+            sys.stderr.write('Parsing error for class {0}\n'.format(k.name()))
+
+    # Docstrings are not created for anything that is not a function or a class.
+    # If this excludes anything important please add it here.
+
+    return output
+
+def sub_docstring_in_pydoc_h(pydoc_files, docstrings_dict, output_dir, filter_str=None):
+    if filter_str:
+        docstrings_dict = {k: v for k, v in docstrings_dict.items() if k.startswith(filter_str)}
+
+    with open(os.path.join(output_dir,'docstring_status'),'w') as status_file:
+    
+        for pydoc_file in pydoc_files:
+            if filter_str:
+                filter_str2 = "::".join((filter_str,os.path.split(pydoc_file)[-1].split('_pydoc_template.h')[0]))
+                docstrings_dict2 = {k: v for k, v in docstrings_dict.items() if k.startswith(filter_str2)}
+            else:
+                docstrings_dict2 = docstrings_dict
+
+
+
+            file_in = open(pydoc_file,'r').read()
+            for key, value in docstrings_dict2.items(): 
+                file_in_tmp = file_in 
+                try:
+                    doc_key = key.split("::")
+                    # if 'gr' in doc_key:
+                    #     doc_key.remove('gr') 
+                    doc_key = '_'.join(doc_key)
+                    regexp = r'(__doc_{} =\sR\"doc\()[^)]*(\)doc\")'.format(doc_key)
+                    regexp = re.compile(regexp, re.MULTILINE)
+                
+                    (file_in, nsubs) = regexp.subn(r'\1'+value+r'\2', file_in, count=1)
+                    if nsubs == 1:
+                        status_file.write("PASS: " + pydoc_file + "\n")
+                except KeyboardInterrupt:
+                    raise KeyboardInterrupt
+                except: # be permissive, TODO log, but just leave the docstring blank
+                    status_file.write("FAIL: " + pydoc_file + "\n")
+                    file_in = file_in_tmp
+
+            output_pathname = os.path.join(output_dir, os.path.basename(pydoc_file).replace('_template.h','.h'))
+            # FIXME: Remove this debug print
+            print('output docstrings to {}'.format(output_pathname))
+            with open(output_pathname,'w') as file_out:
+                file_out.write(file_in)
+
+def copy_docstring_templates(pydoc_files, output_dir):
+    with open(os.path.join(output_dir,'docstring_status'),'w') as status_file:
+        for pydoc_file in pydoc_files:
+            file_in = open(pydoc_file,'r').read()
+            output_pathname = os.path.join(output_dir, os.path.basename(pydoc_file).replace('_template.h','.h'))
+            # FIXME: Remove this debug print
+            print('copy docstrings to {}'.format(output_pathname))
+            with open(output_pathname,'w') as file_out:
+                file_out.write(file_in)
+        status_file.write("DONE")
+
+def argParse():
+    """Parses commandline args."""
+    desc='Scrape the doxygen generated xml for docstrings to insert into python bindings'
+    parser = ArgumentParser(description=desc)
+    
+    parser.add_argument("function", help="Operation to perform on docstrings", choices=["scrape","sub","copy"])
+
+    parser.add_argument("--xml_path")
+    parser.add_argument("--bindings_dir")
+    parser.add_argument("--output_dir")
+    parser.add_argument("--json_path")
+    parser.add_argument("--filter", default=None)
+
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    # Parse command line options and set up doxyxml.
+    args = argParse()
+    if args.function.lower() == 'scrape':
+        di = DoxyIndex(args.xml_path)
+        docstrings_dict = get_docstrings_dict(di)
+        with open(args.json_path, 'w') as fp:
+            json.dump(docstrings_dict, fp)
+    elif args.function.lower() == 'sub':
+        with open(args.json_path, 'r') as fp:
+            docstrings_dict = json.load(fp)
+        pydoc_files = glob.glob(os.path.join(args.bindings_dir,'*_pydoc_template.h'))
+        sub_docstring_in_pydoc_h(pydoc_files, docstrings_dict, args.output_dir, args.filter)
+    elif args.function.lower() == 'copy':
+        pydoc_files = glob.glob(os.path.join(args.bindings_dir,'*_pydoc_template.h'))
+        copy_docstring_templates(pydoc_files, args.output_dir)
+
+            

include/air_modes/preamble.h

@@ -24,7 +24,7 @@
 #define INCLUDED_AIR_MODES_PREAMBLE_H
 
 #include <gnuradio/block.h>
-#include <gr_air_modes/api.h>
+#include <air_modes/api.h>
 
 namespace gr {
 namespace air_modes {
@@ -36,12 +36,12 @@ namespace air_modes {
 class AIR_MODES_API preamble : virtual public gr::block
 {
 public:
-    typedef boost::shared_ptr<preamble> sptr;
-    static sptr make(int channel_rate, float threshold_db);
+    typedef std::shared_ptr<preamble> sptr;
+    static sptr make(float channel_rate, float threshold_db);
 
-    virtual void set_rate(int channel_rate) = 0;
+    virtual void set_rate(float channel_rate) = 0;
     virtual void set_threshold(float threshold_db) = 0;
-    virtual int get_rate(void) = 0;
+    virtual float get_rate(void) = 0;
     virtual float get_threshold(void) = 0;
 };
 

include/air_modes/slicer.h

@@ -23,8 +23,8 @@
 #ifndef INCLUDED_AIR_MODES_SLICER_H
 #define INCLUDED_AIR_MODES_SLICER_H
 
-#include <gnuradio/block.h>
-#include <gr_air_modes/api.h>
+#include <air_modes/api.h>
+#include <gnuradio/sync_block.h>
 #include <gnuradio/msg_queue.h>
 
 namespace gr {
@@ -37,7 +37,7 @@ namespace air_modes {
 class AIR_MODES_API slicer : virtual public gr::sync_block
 {
 public:
-    typedef boost::shared_ptr<slicer> sptr;
+    typedef std::shared_ptr<slicer> sptr;
     static sptr make(gr::msg_queue::sptr queue);
 };
 

lib/CMakeLists.txt

@@ -22,39 +22,41 @@
 ########################################################################
 include(GrPlatform) #define LIB_SUFFIX
 
-add_library(air_modes SHARED
+set(air_modes_sources
     preamble_impl.cc
     slicer_impl.cc
     modes_crc.cc
 )
-target_link_libraries(air_modes ${Boost_LIBRARIES} ${GNURADIO_RUNTIME_LIBRARIES})
-set_target_properties(air_modes PROPERTIES DEFINE_SYMBOL "AIR_MODES_EXPORTS")
-set_target_properties(air_modes PROPERTIES SOVERSION "${gr-gr-air-modes_VERSION_MAJOR}")
-set_target_properties(air_modes PROPERTIES VERSION "${gr-gr-air-modes_VERSION_MAJOR}.${gr-gr-air-modes_VERSION_MINOR}")
+
+set(air_modes_sources "${air_modes_sources}" PARENT_SCOPE)
+
+add_library(gnuradio-air_modes SHARED
+    ${air_modes_sources}
+)
+target_link_libraries(gnuradio-air_modes gnuradio::gnuradio-runtime)
+target_include_directories(gnuradio-air_modes
+    PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
+    PUBLIC $<INSTALL_INTERFACE:include>
+  )
+
+set_target_properties(gnuradio-air_modes PROPERTIES DEFINE_SYMBOL "AIR_MODES_EXPORTS")
+set_target_properties(gnuradio-air_modes PROPERTIES SOVERSION "${VERSION_MAJOR}")
+set_target_properties(gnuradio-air_modes PROPERTIES VERSION "${VERSION_MAJOR}.${VERSION_MINOR}")
+
+if(APPLE)
+    set_target_properties(gnuradio-air_modes PROPERTIES
+        INSTALL_NAME_DIR "${CMAKE_INSTALL_PREFIX}/lib"
+    )
+endif(APPLE)
 
 ########################################################################
 # Install built library files
 ########################################################################
-install(TARGETS air_modes
-    LIBRARY DESTINATION lib${LIB_SUFFIX} # .so/.dylib file
-    ARCHIVE DESTINATION lib${LIB_SUFFIX} # .lib file
-    RUNTIME DESTINATION bin              # .dll file
-)
+include(GrMiscUtils)
+GR_LIBRARY_FOO(gnuradio-air_modes)
 
 ########################################################################
-# Build and register unit test
+# Print summary
 ########################################################################
-#find_package(Boost COMPONENTS unit_test_framework)
-
-#include(GrTest)
-#set(GR_TEST_TARGET_DEPS gnuradio-gr-air-modes)
-#turn each test cpp file into an executable with an int main() function
-#add_definitions(-DBOOST_TEST_DYN_LINK -DBOOST_TEST_MAIN)
-
-#add_executable(qa_gr-air-modes_square_ff qa_gr-air-modes_square_ff.cc)
-#target_link_libraries(qa_gr-air-modes_square_ff gnuradio-gr-air-modes ${Boost_LIBRARIES})
-#GR_ADD_TEST(qa_gr-air-modes_square_ff qa_gr-air-modes_square_ff)
-
-#add_executable(qa_gr-air-modes_square2_ff qa_gr-air-modes_square2_ff.cc)
-#target_link_libraries(qa_gr-air-modes_square2_ff gnuradio-gr-air-modes ${Boost_LIBRARIES})
-#GR_ADD_TEST(qa_gr-air-modes_square2_ff qa_gr-air-modes_square2_ff)
+message(STATUS "Using install prefix: ${CMAKE_INSTALL_PREFIX}")
+message(STATUS "Building for version: ${VERSION} / ${LIBVER}")

lib/modes_crc.cc

@@ -25,8 +25,8 @@
 #endif
 
 #include <stdio.h>
-#include <gr_air_modes/types.h>
-#include <gr_air_modes/modes_crc.h>
+#include <air_modes/types.h>
+#include <air_modes/modes_crc.h>
 #include <math.h>
 #include <stdlib.h>
 

lib/preamble_impl.cc

@@ -33,15 +33,19 @@
 #include <gnuradio/tags.h>
 
 namespace gr {
+namespace air_modes {
 
-air_modes::preamble::sptr air_modes::preamble::make(int channel_rate, float threshold_db) {
-    return gnuradio::get_initial_sptr(new air_modes::preamble_impl(channel_rate, threshold_db));
+using input_type = float;
+using output_type = float;
+
+preamble::sptr preamble::make(float channel_rate, float threshold_db) {
+    return gnuradio::make_block_sptr<preamble_impl>(channel_rate, threshold_db);
 }
 
-air_modes::preamble_impl::preamble_impl(int channel_rate, float threshold_db) :
-        gr::block ("preamble",
-           gr::io_signature::make2 (2, 2, sizeof(float), sizeof(float)), //stream 0 is received data, stream 1 is moving average for reference
-           gr::io_signature::make (1, 1, sizeof(float))) //the output soft symbols
+preamble_impl::preamble_impl(float channel_rate, float threshold_db)
+    : gr::block ("preamble",
+           gr::io_signature::make(2, 2, sizeof(input_type)),
+           gr::io_signature::make(1, 1, sizeof(output_type)))
 {
     d_chip_rate = 2000000; //2Mchips per second
     set_rate(channel_rate);
@@ -53,26 +57,26 @@ air_modes::preamble_impl::preamble_impl(int channel_rate, float threshold_db) :
     d_key = pmt::string_to_symbol("preamble_found");
 }
 
-void air_modes::preamble_impl::set_rate(int channel_rate) {
+void air_modes::preamble_impl::set_rate(float channel_rate) {
     d_samples_per_chip = channel_rate / d_chip_rate;
     d_samples_per_symbol = d_samples_per_chip * 2;
     d_check_width = 120 * d_samples_per_symbol;
-    d_secs_per_sample = 1.0/channel_rate;
+    d_sample_rate = channel_rate;
     set_output_multiple(1+d_check_width*2);
     set_history(d_samples_per_symbol);
 }
 
-void air_modes::preamble_impl::set_threshold(float threshold_db) {
+void preamble_impl::set_threshold(float threshold_db) {
     d_threshold_db = threshold_db;
     d_threshold = powf(10., threshold_db/20.); //the level that the sample must be above the moving average in order to qualify as a pulse
 }
 
-float air_modes::preamble_impl::get_threshold(void) {
+float preamble_impl::get_threshold(void) {
     return d_threshold_db;
 }
 
-int air_modes::preamble_impl::get_rate(void) {
-    return d_samples_per_chip * d_chip_rate;
+float preamble_impl::get_rate(void) {
+    return d_sample_rate;
 }
 
 static void integrate_and_dump(float *out, const float *in, int chips, int samps_per_chip) {
@@ -97,23 +101,46 @@ static double correlate_preamble(const float *in, int samples_per_chip) {
     return corr;
 }
 
-//todo: make it return a pair of some kind, otherwise you can lose precision
-static double tag_to_timestamp(gr::tag_t tstamp, uint64_t abs_sample_cnt, double secs_per_sample) {
-    uint64_t ts_sample, last_whole_stamp;
+static pmt::pmt_t tag_to_timestamp(gr::tag_t tstamp, uint64_t abs_sample_cnt, int rate) {
+    uint64_t last_whole_stamp;
     double last_frac_stamp;
+    pmt::pmt_t tstime = pmt::make_tuple(pmt::from_uint64(0), pmt::from_double(0));
+    if(tstamp.key == NULL 
+    || !pmt::is_symbol(tstamp.key) 
+    || pmt::symbol_to_string(tstamp.key) != "rx_time") {
+        last_whole_stamp = 0;
+        last_frac_stamp = 0;
+    } else {
+        last_whole_stamp = pmt::to_uint64(pmt::tuple_ref(tstamp.value, 0));
+        last_frac_stamp = pmt::to_double(pmt::tuple_ref(tstamp.value, 1));
+    }
 
-    if(tstamp.key == NULL || pmt::symbol_to_string(tstamp.key) != "rx_time") return 0;
+    //the timestamp tag has tstamp.offset, the sample index of the timestamp tag
+    //also tstamp.value, a pmt pair with (uint64, double) representing int and
+    //fractional timestamp, respectively.
+    //this function also gets an abs_sample_cnt which represents the sample count to
+    //find a timestamp for. sps is obviously samples per second.
+    //
+    //so (abs_sample_cnt - tstamp.offset) is the delay we apply to the tag
+    //   int((abs_sample_cnt - tstamp.offset)/sps) is the integer offset
+    //   (abs_sample_cnt - tstamp.offset)/sps is the fractional offset
 
-    last_whole_stamp = pmt::to_uint64(pmt::tuple_ref(tstamp.value, 0));
-    last_frac_stamp = pmt::to_double(pmt::tuple_ref(tstamp.value, 1));
-    ts_sample = tstamp.offset;
+    uint64_t int_offset = (abs_sample_cnt - tstamp.offset)/rate;
+    double frac_offset = ((abs_sample_cnt - tstamp.offset) % rate) / double(rate);
+
+    uint64_t abs_whole = last_whole_stamp + int_offset;
+    double abs_frac = last_frac_stamp + frac_offset;
+    if(abs_frac > 1.0f) {
+        abs_frac -= 1.0f;
+        abs_whole += 1;
+    }
+
+    tstime = pmt::make_tuple(pmt::from_uint64(abs_whole), pmt::from_double(abs_frac));
 
-    double tstime = double(abs_sample_cnt * secs_per_sample) + last_whole_stamp + last_frac_stamp;
-    if(0) std::cout << "HEY WE GOT A STAMP AT " << tstime << " TICKS AT SAMPLE " << ts_sample << " ABS SAMPLE CNT IS " << abs_sample_cnt << std::endl;
     return tstime;
 }
 
-int air_modes::preamble_impl::general_work(int noutput_items,
+int preamble_impl::general_work(int noutput_items,
                           gr_vector_int &ninput_items,
                           gr_vector_const_void_star &input_items,
                           gr_vector_void_star &output_items)
@@ -124,7 +151,7 @@ int air_modes::preamble_impl::general_work(int noutput_items,
     int mininputs = std::min(ninput_items[0], ninput_items[1]); //they should be matched but let's be safe
     //round number of input samples down to nearest d_samples_per_chip
     //we also subtract off d_samples_per_chip to allow the bit center finder some leeway
-    const int ninputs = std::max(mininputs - (mininputs % d_samples_per_chip) - d_samples_per_chip, 0);
+    const int ninputs = std::max(mininputs - (mininputs % int(d_samples_per_chip)) - int(d_samples_per_chip), 0);
     if (ninputs <= 0) { consume_each(0); return 0; }
 
     float *out = (float *) output_items[0];
@@ -194,22 +221,20 @@ int air_modes::preamble_impl::general_work(int noutput_items,
 
             //all right i'm prepared to call this a preamble
             for(int j=0; j<240; j++) {
-                out[j] = in[i+j*d_samples_per_chip] - inavg[i];
+                out[j] = in[i+int(j*d_samples_per_chip)] - inavg[i];
             }
 
             //get the timestamp of the preamble
-            double tstamp = tag_to_timestamp(d_timestamp, abs_sample_cnt + i, d_secs_per_sample);
+            pmt::pmt_t tstamp = tag_to_timestamp(d_timestamp, abs_sample_cnt + i, d_sample_rate);
 
             //now tag the preamble
             add_item_tag(0, //stream ID
                      nitems_written(0), //sample
                      d_key,      //frame_info
-                     pmt::from_double(tstamp),
+                     tstamp,
                      d_me        //block src id
                     );
 
-            //std::cout << "PREAMBLE" << std::endl;
-
             //produce only one output per work call -- TODO this should probably change
             if(0) std::cout << "Preamble consumed " << i+240*d_samples_per_chip << "with i=" << i << ", returned 240" << std::endl;
 
@@ -224,4 +249,5 @@ int air_modes::preamble_impl::general_work(int noutput_items,
     return 0;
 }
 
+} //namespace air_modes
 } //namespace gr

lib/preamble_impl.h

@@ -3,8 +3,8 @@
 #define _AIR_MODES_PREAMBLE_IMPL_H_
 
 #include <gnuradio/block.h>
-#include <gr_air_modes/api.h>
-#include <gr_air_modes/preamble.h>
+#include <air_modes/api.h>
+#include <air_modes/preamble.h>
 
 namespace gr {
 namespace air_modes {
@@ -15,26 +15,26 @@ private:
     int d_check_width;
     int d_chip_rate;
     float d_preamble_length_us;
-    int d_samples_per_chip;
-    int d_samples_per_symbol;
+    float d_samples_per_chip;
+    float d_samples_per_symbol;
     float d_threshold_db;
     float d_threshold;
-    pmt::pmt_t d_me, d_key;
     gr::tag_t d_timestamp;
-    double d_secs_per_sample;
+    pmt::pmt_t d_me, d_key;
+    int d_sample_rate;
 
 public:
-    preamble_impl(int channel_rate, float threshold_db);
+    preamble_impl(float channel_rate, float threshold_db);
 
     int general_work (int noutput_items,
               gr_vector_int &ninput_items,
               gr_vector_const_void_star &input_items,
               gr_vector_void_star &output_items);
 
-    void set_rate(int channel_rate);
+    void set_rate(float channel_rate);
     void set_threshold(float threshold_db);
     float get_threshold(void);
-    int get_rate(void);
+    float get_rate(void);
 };
 
 } //namespace air_modes

lib/slicer_impl.cc

@@ -28,10 +28,10 @@
 #include <ciso646>
 #include "slicer_impl.h"
 #include <gnuradio/io_signature.h>
-#include <gr_air_modes/types.h>
+#include <air_modes/types.h>
 #include <sstream>
 #include <iomanip>
-#include <gr_air_modes/modes_crc.h>
+#include <air_modes/modes_crc.h>
 #include <iostream>
 #include <gnuradio/tags.h>
 
@@ -42,15 +42,16 @@ extern "C"
 }
 
 namespace gr {
+namespace air_modes {
 
-air_modes::slicer::sptr air_modes::slicer::make(gr::msg_queue::sptr queue) {
-    return gnuradio::get_initial_sptr(new air_modes::slicer_impl(queue));
+slicer::sptr slicer::make(gr::msg_queue::sptr queue) {
+    return gnuradio::make_block_sptr<slicer_impl>(queue);
 }
 
-air_modes::slicer_impl::slicer_impl(gr::msg_queue::sptr queue) :
+slicer_impl::slicer_impl(gr::msg_queue::sptr queue) :
   gr::sync_block ("slicer",
-                  gr::io_signature::make (1, 1, sizeof(float)),
-                  gr::io_signature::make (0, 0, 0) )
+                  gr::io_signature::make(1, 1, sizeof(float)),
+                  gr::io_signature::make(0, 0, 0))
 {
     //initialize private data here
     d_chip_rate = 2000000; //2Mchips per second
@@ -99,9 +100,9 @@ static slice_result_t llslicer(const float bit0, const float bit1, const float r
     return result;
 }
 
-int air_modes::slicer_impl::work(int noutput_items,
-                          gr_vector_const_void_star &input_items,
-                          gr_vector_void_star &output_items)
+int slicer_impl::work(int noutput_items,
+                      gr_vector_const_void_star &input_items,
+                      gr_vector_void_star &output_items)
 {
     const float *in = (const float *) input_items[0];
     int size = noutput_items - d_check_width; //since it's a sync block, i assume that it runs with ninput_items = noutput_items
@@ -158,8 +159,6 @@ int air_modes::slicer_impl::work(int noutput_items,
             }
         }
 
-        rx_packet.timestamp = pmt::to_double(tag_iter->value);
-
         //here you might want to traverse the whole packet and if you find all 0's, just toss it. don't know why these packets turn up, but they pass ECC.
         bool zeroes = 1;
         for(int m = 0; m < 14; m++) {
@@ -183,13 +182,15 @@ int air_modes::slicer_impl::work(int noutput_items,
         //crc for the other short packets is usually nonzero, so they can't really be trusted that far
         if(rx_packet.crc && (rx_packet.message_type == 11 || rx_packet.message_type == 17)) {continue;}
 
+        pmt::pmt_t tstamp = tag_iter->value;
+
         d_payload.str("");
         for(int m = 0; m < packet_length/8; m++) {
             d_payload << std::hex << std::setw(2) << std::setfill('0') << unsigned(rx_packet.data[m]);
         }
 
         d_payload << " " << std::setw(6) << rx_packet.crc << " " << std::dec << rx_packet.reference_level
-                  << " " << std::setprecision(10) << std::setw(10) << rx_packet.timestamp;
+                  << " " << pmt::to_uint64(pmt::tuple_ref(tstamp, 0)) << " " << std::setprecision(10) << pmt::to_double(pmt::tuple_ref(tstamp, 1));
         gr::message::sptr msg = gr::message::make_from_string(std::string(d_payload.str()));
         d_queue->handle(msg);
     }
@@ -197,4 +198,5 @@ int air_modes::slicer_impl::work(int noutput_items,
     return size;
 }
 
+} //namespace air_modes
 } //namespace gr

lib/slicer_impl.h

@@ -25,8 +25,8 @@
 
 #include <gnuradio/sync_block.h>
 #include <gnuradio/msg_queue.h>
-#include <gr_air_modes/api.h>
-#include <gr_air_modes/slicer.h>
+#include <air_modes/api.h>
+#include <air_modes/slicer.h>
 
 namespace gr {
 namespace air_modes {
@@ -38,6 +38,7 @@ private:
     int d_chip_rate;
     int d_samples_per_chip;
     int d_samples_per_symbol;
+    gr::tag_t d_timestamp;
     gr::msg_queue::sptr d_queue;
     std::ostringstream d_payload;
 

python/CMakeLists.txt

@@ -40,6 +40,7 @@ GR_PYTHON_INSTALL(
     flightgear.py
     gui_model.py
     kml.py
+    modes_types.py
     parse.py
     msprint.py
     radio.py
@@ -47,17 +48,10 @@ GR_PYTHON_INSTALL(
     rx_path.py
     sbs1.py
     sql.py
-    types.py
     zmq_socket.py
     Quaternion.py
+    msgq_runner.py
     DESTINATION ${GR_PYTHON_DIR}/air_modes
 )
 
-########################################################################
-# Handle the unit tests
-########################################################################
-#include(GrTest)
-
-#set(GR_TEST_TARGET_DEPS gnuradio-gr-air-modes)
-#set(GR_TEST_PYTHON_DIRS ${CMAKE_BINARY_DIR}/swig)
-#GR_ADD_TEST(qa_gr-air-modes ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/qa_gr-air-modes.py)
+add_subdirectory(bindings)

python/__init__.py

@@ -21,61 +21,43 @@
 '''
 This is the GNU Radio gr-air-modes package. It provides a library and
 application for receiving Mode S / ADS-B signals from aircraft. Use
-uhd_modes.py as the main application for receiving signals. cpr.py
+modes_rx as the main application for receiving signals. cpr.py
 provides an implementation of Compact Position Reporting. altitude.py
 implements Gray-coded altitude decoding. Various plugins exist for SQL,
 KML, and PlanePlotter-compliant SBS-1 emulation output. mlat.py provides
 an experimental implementation of a multilateration solver.
 '''
 
-# ----------------------------------------------------------------
-# Temporary workaround for ticket:181 (swig+python problem)
-import sys
-_RTLD_GLOBAL = 0
-try:
-    from dl import RTLD_GLOBAL as _RTLD_GLOBAL
-except ImportError:
-    try:
-	from DLFCN import RTLD_GLOBAL as _RTLD_GLOBAL
-    except ImportError:
-	pass
-    
-if _RTLD_GLOBAL != 0:
-    _dlopenflags = sys.getdlopenflags()
-    sys.setdlopenflags(_dlopenflags|_RTLD_GLOBAL)
-# ----------------------------------------------------------------
-
-
-# import swig generated symbols into the gr-air-modes namespace
-from air_modes_swig import *
+from .air_modes_python import *
 
 # import any pure python here
 #
-from rx_path import rx_path
-from zmq_socket import zmq_pubsub_iface
-from parse import *
-from msprint import output_print
-from sql import output_sql
-from sbs1 import output_sbs1
-from kml import output_kml, output_jsonp
-from raw_server import raw_server
-from radio import modes_radio
-from exceptions import *
-from az_map import *
-from types import *
-from altitude import *
-from cpr import cpr_decoder
-from html_template import html_template
+
+try:
+    import zmq
+except ImportError:
+    raise RuntimeError("PyZMQ not found! Please install libzmq and PyZMQ to run gr-air-modes")
+
+from .rx_path import rx_path
+from .zmq_socket import zmq_pubsub_iface
+from .parse import *
+from .msprint import output_print
+from .sql import output_sql
+from .sbs1 import output_sbs1
+from .kml import output_kml, output_jsonp
+from .raw_server import raw_server
+from .radio import modes_radio
+from .exceptions import *
+from .modes_types import *
+from .altitude import *
+from .cpr import cpr_decoder
+from .html_template import html_template
+from .msgq_runner import msgq_runner
+
 #this is try/excepted in case the user doesn't have numpy installed
 try:
-    from flightgear import output_flightgear
-    from Quaternion import *
+    from .flightgear import output_flightgear
+    from .Quaternion import *
 except ImportError:
-    print "gr-air-modes warning: numpy+scipy not installed, FlightGear interface not supported"
+    print("gr-air-modes warning: numpy+scipy not installed, FlightGear interface not supported")
     pass
-
-# ----------------------------------------------------------------
-# Tail of workaround
-if _RTLD_GLOBAL != 0:
-    sys.setdlopenflags(_dlopenflags)      # Restore original flags
-# ----------------------------------------------------------------

python/altitude.py

@@ -26,120 +26,119 @@
 from air_modes.exceptions import *
 
 def decode_alt(alt, bit13):
-	mbit = alt & 0x0040
-	qbit = alt & 0x0010
-	
-	if mbit and bit13:
-		#nobody uses metric altitude: AFAIK, it's an orphaned part of
-		#the spec. haven't seen it in three years. as a result, replies
-		#with mbit set can be considered spurious, and so we discard them here.
-		
-		#bits 20-25, 27-31 encode alt in meters
-		#remember that bits are LSB (bit 20 is MSB)
-		#meters_alt = 0
-		#for (shift, bit) in enumerate(range(31,26,-1)+range(25,19,-1)):
-		#	meters_alt += ((alt & (1<<bit)) != 0) << shift
-		#decoded_alt = meters_alt / 0.3048
-		raise MetricAltError
+        mbit = alt & 0x0040
+        qbit = alt & 0x0010
+        
+        if mbit and bit13:
+                #nobody uses metric altitude: AFAIK, it's an orphaned part of
+                #the spec. haven't seen it in three years. as a result, replies
+                #with mbit set can be considered spurious, and so we discard them here.
+                
+                #bits 20-25, 27-31 encode alt in meters
+                #remember that bits are LSB (bit 20 is MSB)
+                #meters_alt = 0
+                #for (shift, bit) in enumerate(range(31,26,-1)+range(25,19,-1)):
+                #       meters_alt += ((alt & (1<<bit)) != 0) << shift
+                #decoded_alt = meters_alt / 0.3048
+                raise MetricAltError
 
-	if qbit: #a mode S-style reply
-		#bit13 is false for BDS0,5 ADS-B squitters, and is true otherwise
-		if bit13:
-			#in this representation, the altitude bits are as follows:
-			# 12 11 10 9 8 7 (6) 5 (4) 3 2 1 0
-			# so bits 6 and 4 are the M and Q bits, respectively.
-			tmp1 = (alt & 0x3F80) >> 2
-			tmp2 = (alt & 0x0020) >> 1
-		else:
-			tmp1 = (alt & 0x1FE0) >> 1
-			tmp2 = 0
+        if qbit: #a mode S-style reply
+                #bit13 is false for BDS0,5 ADS-B squitters, and is true otherwise
+                if bit13:
+                        #in this representation, the altitude bits are as follows:
+                        # 12 11 10 9 8 7 (6) 5 (4) 3 2 1 0
+                        # so bits 6 and 4 are the M and Q bits, respectively.
+                        tmp1 = (alt & 0x3F80) >> 2
+                        tmp2 = (alt & 0x0020) >> 1
+                else:
+                        tmp1 = (alt & 0x1FE0) >> 1
+                        tmp2 = 0
 
-		decoded_alt = ((alt & 0x0F) | tmp1 | tmp2) * 25 - 1000
+                decoded_alt = ((alt & 0x0F) | tmp1 | tmp2) * 25 - 1000
 
-	else: #a mode C-style reply
-		  #okay, the order they come in is:
-		  #C1 A1 C2 A2 C4 A4 X B1 D1 B2 D2 B4 D4
-    	  #the order we want them in is:
-    	  #D2 D4 A1 A2 A4 B1 B2 B4
-    	  #so we'll reassemble into a Gray-coded representation
+        else: #a mode C-style reply
+                  #okay, the order they come in is:
+                  #C1 A1 C2 A2 C4 A4 X B1 D1 B2 D2 B4 D4
+          #the order we want them in is:
+          #D2 D4 A1 A2 A4 B1 B2 B4
+          #so we'll reassemble into a Gray-coded representation
 
-		if bit13 is False:
-			alt = (alt & 0x003F) | (alt & 0x0FC0 << 1)
+                if bit13 is False:
+                        alt = (alt & 0x003F) | (alt & 0x0FC0 << 1)
 
-		C1 = 0x1000
-		A1 = 0x0800
-		C2 = 0x0400
-		A2 = 0x0200	#this represents the order in which the bits come
-		C4 = 0x0100
-		A4 = 0x0080
-		B1 = 0x0020
-		D1 = 0x0010
-		B2 = 0x0008
-		D2 = 0x0004
-		B4 = 0x0002
-		D4 = 0x0001
+                C1 = 0x1000
+                A1 = 0x0800
+                C2 = 0x0400
+                A2 = 0x0200     #this represents the order in which the bits come
+                C4 = 0x0100
+                A4 = 0x0080
+                B1 = 0x0020
+                D1 = 0x0010
+                B2 = 0x0008
+                D2 = 0x0004
+                B4 = 0x0002
+                D4 = 0x0001
 
-		bigpart =  ((alt & B4) >> 1) \
-				 + ((alt & B2) >> 2) \
-				 + ((alt & B1) >> 3) \
-				 + ((alt & A4) >> 4) \
-				 + ((alt & A2) >> 5) \
-				 + ((alt & A1) >> 6) \
-				 + ((alt & D4) << 6) \
-				 + ((alt & D2) << 5)
+                bigpart =  ((alt & B4) >> 1) \
+                                 + ((alt & B2) >> 2) \
+                                 + ((alt & B1) >> 3) \
+                                 + ((alt & A4) >> 4) \
+                                 + ((alt & A2) >> 5) \
+                                 + ((alt & A1) >> 6) \
+                                 + ((alt & D4) << 6) \
+                                 + ((alt & D2) << 5)
 
-		#bigpart is now the 500-foot-resolution Gray-coded binary part
-		decoded_alt = gray2bin(bigpart)
-		#real_alt is now the 500-foot-per-tick altitude
+                #bigpart is now the 500-foot-resolution Gray-coded binary part
+                decoded_alt = gray2bin(bigpart)
+                #real_alt is now the 500-foot-per-tick altitude
 
-		cbits =   ((alt & C4) >> 8) + ((alt & C2) >> 9) + ((alt & C1) >> 10)
-		cval = gray2bin(cbits) #turn them into a real number
+                cbits =   ((alt & C4) >> 8) + ((alt & C2) >> 9) + ((alt & C1) >> 10)
+                cval = gray2bin(cbits) #turn them into a real number
 
-		if cval == 7:
-			cval = 5 #not a real gray code after all
+                if cval == 7:
+                        cval = 5 #not a real gray code after all
 
-		if decoded_alt % 2:
-			cval = 6 - cval #since the code is symmetric this unwraps it to see whether to subtract the C bits or add them
+                if decoded_alt % 2:
+                        cval = 6 - cval #since the code is symmetric this unwraps it to see whether to subtract the C bits or add them
 
-		decoded_alt *= 500 #take care of the A,B,D data
-		decoded_alt += cval * 100 #factor in the C data
-		decoded_alt -= 1300 #subtract the offset
+                decoded_alt *= 500 #take care of the A,B,D data
+                decoded_alt += cval * 100 #factor in the C data
+                decoded_alt -= 1300 #subtract the offset
 
-	return decoded_alt
+        return decoded_alt
 
 def gray2bin(gray):
-	i = gray >> 1
+        i = gray >> 1
 
-	while i != 0:
-		gray ^= i
-		i >>= 1
+        while i != 0:
+                gray ^= i
+                i >>= 1
 
-	return gray
+        return gray
 
 def encode_alt_modes(alt, bit13):
-	mbit = False
-	qbit = True
-	encalt = (int(alt) + 1000) / 25
+        mbit = False
+        qbit = True
+        encalt = (int(alt) + 1000) / 25
 
-	if bit13 is True:
-		tmp1 = (encalt & 0xfe0) << 2
-		tmp2 = (encalt & 0x010) << 1
-		
-	else:
-		tmp1 = (encalt & 0xff8) << 1
-		tmp2 = 0
+        if bit13 is True:
+                tmp1 = (encalt & 0xfe0) << 2
+                tmp2 = (encalt & 0x010) << 1
+        else:
+                tmp1 = (encalt & 0xff8) << 1
+                tmp2 = 0
 
-	return (encalt & 0x0F) | tmp1 | tmp2 | (mbit << 6) | (qbit << 4)
+        return (encalt & 0x0F) | tmp1 | tmp2 | (mbit << 6) | (qbit << 4)
 
 if __name__ == "__main__":
-	try:
-		for alt in range(-1000, 101400, 25):
-			dec = decode_alt(encode_alt_modes(alt, False), False)
-			if dec != alt:
-				print "Failure at %i with bit13 clear (got %s)" % (alt, dec)
-		for alt in range(-1000, 101400, 25):
-			dec = decode_alt(encode_alt_modes(alt, True), True)
-			if dec != alt:
-				print "Failure at %i with bit13 set (got %s)" % (alt, dec)
-	except MetricAltError:
-		print "Failure at %i due to metric alt bit" % alt
+        try:
+                for alt in range(-1000, 101400, 25):
+                        dec = decode_alt(encode_alt_modes(alt, False), False)
+                        if dec != alt:
+                                print("Failure at %i with bit13 clear (got %s)" % (alt, dec))
+                for alt in range(-1000, 101400, 25):
+                        dec = decode_alt(encode_alt_modes(alt, True), True)
+                        if dec != alt:
+                                print("Failure at %i with bit13 set (got %s)" % (alt, dec))
+        except MetricAltError:
+                print("Failure at %i due to metric alt bit" % alt)

python/az_map.py

@@ -25,7 +25,6 @@
 from PyQt4 import QtCore, QtGui
 import threading
 import math
-import air_modes
 from air_modes.exceptions import *
 import numpy as np
 

python/bindings/CMakeLists.txt

@@ -0,0 +1,41 @@
+# Copyright 2020 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+
+########################################################################
+# Check if there is C++ code at all
+########################################################################
+if(NOT air_modes_sources)
+    MESSAGE(STATUS "No C++ sources... skipping python bindings")
+    return()
+endif(NOT air_modes_sources)
+
+########################################################################
+# Check for pygccxml
+########################################################################
+GR_PYTHON_CHECK_MODULE_RAW(
+    "pygccxml"
+    "import pygccxml"
+    PYGCCXML_FOUND
+    )
+
+include(GrPybind)
+
+########################################################################
+# Python Bindings
+########################################################################
+
+list(APPEND air_modes_python_files
+    python_bindings.cc
+    preamble_python.cc
+    slicer_python.cc)
+
+GR_PYBIND_MAKE_OOT(air_modes 
+   ../..
+   gr::air_modes
+   "${air_modes_python_files}")
+
+install(TARGETS air_modes_python DESTINATION ${GR_PYTHON_DIR}/air_modes COMPONENT pythonapi)

python/bindings/bind_oot_file.py

@@ -0,0 +1,57 @@
+import warnings
+import argparse
+import os
+from gnuradio.bindtool import BindingGenerator
+import pathlib
+import sys
+
+parser = argparse.ArgumentParser(description='Bind a GR Out of Tree Block')
+parser.add_argument('--module', type=str,
+                    help='Name of gr module containing file to bind (e.g. fft digital analog)')
+
+parser.add_argument('--output_dir', default='/tmp',
+                    help='Output directory of generated bindings')
+parser.add_argument('--prefix', help='Prefix of Installed GNU Radio')
+parser.add_argument('--src', help='Directory of gnuradio source tree',
+                    default=os.path.dirname(os.path.abspath(__file__))+'/../../..')
+
+parser.add_argument(
+    '--filename', help="File to be parsed")
+
+parser.add_argument(
+    '--defines', help='Set additional defines for precompiler',default=(), nargs='*')
+parser.add_argument(
+    '--include', help='Additional Include Dirs, separated', default=(), nargs='*')
+
+parser.add_argument(
+    '--status', help='Location of output file for general status (used during cmake)', default=None
+)
+parser.add_argument(
+    '--flag_automatic', default='0'
+)
+parser.add_argument(
+    '--flag_pygccxml', default='0'
+)
+
+args = parser.parse_args()
+
+prefix = args.prefix
+output_dir = args.output_dir
+defines = tuple(','.join(args.defines).split(','))
+includes = ','.join(args.include)
+name = args.module
+
+namespace = ['gr', name]
+prefix_include_root = name
+
+
+with warnings.catch_warnings():
+    warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+    bg = BindingGenerator(prefix, namespace,
+                          prefix_include_root, output_dir, define_symbols=defines, addl_includes=includes,
+                          catch_exceptions=False, write_json_output=False, status_output=args.status,
+                          flag_automatic=True if args.flag_automatic.lower() in [
+                              '1', 'true'] else False,
+                          flag_pygccxml=True if args.flag_pygccxml.lower() in ['1', 'true'] else False)
+    bg.gen_file_binding(args.filename)

python/bindings/docstrings/README.md

@@ -0,0 +1 @@
+This directory stores templates for docstrings that are scraped from the include header files for each block

python/bindings/docstrings/preamble_pydoc_template.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2021 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+#include "pydoc_macros.h"
+#define D(...) DOC(gr,air_modes, __VA_ARGS__ )
+/*
+  This file contains placeholders for docstrings for the Python bindings.
+  Do not edit! These were automatically extracted during the binding process
+  and will be overwritten during the build process
+ */
+
+
+ 
+ static const char *__doc_gr_air_modes_preamble = R"doc()doc";
+
+
+ static const char *__doc_gr_air_modes_preamble_preamble_0 = R"doc()doc";
+
+
+ static const char *__doc_gr_air_modes_preamble_preamble_1 = R"doc()doc";
+
+
+ static const char *__doc_gr_air_modes_preamble_make = R"doc()doc";
+
+
+ static const char *__doc_gr_air_modes_preamble_set_rate = R"doc()doc";
+
+
+ static const char *__doc_gr_air_modes_preamble_set_threshold = R"doc()doc";
+
+
+ static const char *__doc_gr_air_modes_preamble_get_rate = R"doc()doc";
+
+
+ static const char *__doc_gr_air_modes_preamble_get_threshold = R"doc()doc";
+
+  

python/bindings/docstrings/slicer_pydoc_template.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2021 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+#include "pydoc_macros.h"
+#define D(...) DOC(gr,air_modes, __VA_ARGS__ )
+/*
+  This file contains placeholders for docstrings for the Python bindings.
+  Do not edit! These were automatically extracted during the binding process
+  and will be overwritten during the build process
+ */
+
+
+ 
+ static const char *__doc_gr_air_modes_slicer = R"doc()doc";
+
+
+ static const char *__doc_gr_air_modes_slicer_slicer = R"doc()doc";
+
+
+ static const char *__doc_gr_air_modes_slicer_make = R"doc()doc";
+
+  

python/bindings/header_utils.py

@@ -0,0 +1,78 @@
+# Utilities for reading values in header files
+
+from argparse import ArgumentParser
+import re
+
+
+class PybindHeaderParser:
+    def __init__(self, pathname):
+        with open(pathname,'r') as f:
+            self.file_txt = f.read()
+
+    def get_flag_automatic(self):
+        # p = re.compile(r'BINDTOOL_GEN_AUTOMATIC\(([^\s])\)')
+        # m = p.search(self.file_txt)
+        m = re.search(r'BINDTOOL_GEN_AUTOMATIC\(([^\s])\)', self.file_txt)
+        if (m and m.group(1) == '1'):
+            return True
+        else:
+            return False
+        
+    def get_flag_pygccxml(self):    
+        # p = re.compile(r'BINDTOOL_USE_PYGCCXML\(([^\s])\)')
+        # m = p.search(self.file_txt)
+        m = re.search(r'BINDTOOL_USE_PYGCCXML\(([^\s])\)', self.file_txt)
+        if (m and m.group(1) == '1'):
+            return True
+        else:
+            return False
+
+    def get_header_filename(self):
+        # p = re.compile(r'BINDTOOL_HEADER_FILE\(([^\s]*)\)')
+        # m = p.search(self.file_txt)
+        m = re.search(r'BINDTOOL_HEADER_FILE\(([^\s]*)\)', self.file_txt)
+        if (m):
+            return m.group(1)
+        else:
+            return None
+
+    def get_header_file_hash(self):
+        # p = re.compile(r'BINDTOOL_HEADER_FILE_HASH\(([^\s]*)\)')
+        # m = p.search(self.file_txt)
+        m = re.search(r'BINDTOOL_HEADER_FILE_HASH\(([^\s]*)\)', self.file_txt)
+        if (m):
+            return m.group(1)
+        else:
+            return None
+
+    def get_flags(self):
+        return f'{self.get_flag_automatic()};{self.get_flag_pygccxml()};{self.get_header_filename()};{self.get_header_file_hash()};'
+
+
+
+def argParse():
+    """Parses commandline args."""
+    desc='Reads the parameters from the comment block in the pybind files'
+    parser = ArgumentParser(description=desc)
+    
+    parser.add_argument("function", help="Operation to perform on comment block of pybind file", choices=["flag_auto","flag_pygccxml","header_filename","header_file_hash","all"])
+    parser.add_argument("pathname", help="Pathname of pybind c++ file to read, e.g. blockname_python.cc")
+
+    return parser.parse_args()
+
+if __name__ == "__main__":
+    # Parse command line options and set up doxyxml.
+    args = argParse()
+
+    pbhp = PybindHeaderParser(args.pathname)
+
+    if args.function == "flag_auto":
+        print(pbhp.get_flag_automatic())
+    elif args.function == "flag_pygccxml":
+        print(pbhp.get_flag_pygccxml())
+    elif args.function == "header_filename":
+        print(pbhp.get_header_filename())
+    elif args.function == "header_file_hash":
+        print(pbhp.get_header_file_hash()) 
+    elif args.function == "all":
+        print(pbhp.get_flags())

python/bindings/preamble_python.cc

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2021 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+
+/***********************************************************************************/
+/* This file is automatically generated using bindtool and can be manually edited  */
+/* The following lines can be configured to regenerate this file during cmake      */
+/* If manual edits are made, the following tags should be modified accordingly.    */
+/* BINDTOOL_GEN_AUTOMATIC(0)                                                       */
+/* BINDTOOL_USE_PYGCCXML(0)                                                        */
+/* BINDTOOL_HEADER_FILE(preamble.h)                                        */
+/* BINDTOOL_HEADER_FILE_HASH(7ce2f89dad5c95a56a123d11871bad67)                     */
+/***********************************************************************************/
+
+#include <pybind11/complex.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+#include <air_modes/preamble.h>
+// pydoc.h is automatically generated in the build directory
+#include <preamble_pydoc.h>
+
+void bind_preamble(py::module& m)
+{
+
+    using preamble    = ::gr::air_modes::preamble;
+
+
+    py::class_<preamble, gr::block, gr::basic_block,
+        std::shared_ptr<preamble>>(m, "preamble", D(preamble))
+
+        .def(py::init(&preamble::make),
+           py::arg("channel_rate"),
+           py::arg("threshold_db"),
+           D(preamble,make)
+        )
+        
+
+
+
+
+        
+        .def("set_rate",&preamble::set_rate,       
+            py::arg("channel_rate"),
+            D(preamble,set_rate)
+        )
+
+
+        
+        .def("set_threshold",&preamble::set_threshold,       
+            py::arg("threshold_db"),
+            D(preamble,set_threshold)
+        )
+
+
+        
+        .def("get_rate",&preamble::get_rate,       
+            D(preamble,get_rate)
+        )
+
+
+        
+        .def("get_threshold",&preamble::get_threshold,       
+            D(preamble,get_threshold)
+        )
+
+        ;
+
+
+
+
+}
+
+
+
+
+
+
+
+

python/bindings/python_bindings.cc

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2020 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+
+#include <pybind11/pybind11.h>
+
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include <numpy/arrayobject.h>
+
+namespace py = pybind11;
+
+// Headers for binding functions
+/**************************************/
+/* The following comment block is used for
+/* gr_modtool to insert function prototypes
+/* Please do not delete
+/**************************************/
+// BINDING_FUNCTION_PROTOTYPES(
+    void bind_preamble(py::module& m);
+    void bind_slicer(py::module& m);
+// ) END BINDING_FUNCTION_PROTOTYPES
+
+
+// We need this hack because import_array() returns NULL
+// for newer Python versions.
+// This function is also necessary because it ensures access to the C API
+// and removes a warning.
+void* init_numpy()
+{
+    import_array();
+    return NULL;
+}
+
+PYBIND11_MODULE(air_modes_python, m)
+{
+    // Initialize the numpy C API
+    // (otherwise we will see segmentation faults)
+    init_numpy();
+
+    // Allow access to base block methods
+    py::module::import("gnuradio.gr");
+
+    /**************************************/
+    /* The following comment block is used for
+    /* gr_modtool to insert binding function calls
+    /* Please do not delete
+    /**************************************/
+    // BINDING_FUNCTION_CALLS(
+    bind_preamble(m);
+    bind_slicer(m);
+    // ) END BINDING_FUNCTION_CALLS
+}

python/bindings/slicer_python.cc

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2021 Free Software Foundation, Inc.
+ *
+ * This file is part of GNU Radio
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ */
+
+/***********************************************************************************/
+/* This file is automatically generated using bindtool and can be manually edited  */
+/* The following lines can be configured to regenerate this file during cmake      */
+/* If manual edits are made, the following tags should be modified accordingly.    */
+/* BINDTOOL_GEN_AUTOMATIC(0)                                                       */
+/* BINDTOOL_USE_PYGCCXML(0)                                                        */
+/* BINDTOOL_HEADER_FILE(slicer.h)                                        */
+/* BINDTOOL_HEADER_FILE_HASH(de5bad12b8ae0f22c88c9cd886eaf8cc)                     */
+/***********************************************************************************/
+
+#include <pybind11/complex.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+namespace py = pybind11;
+
+#include <air_modes/slicer.h>
+// pydoc.h is automatically generated in the build directory
+#include <slicer_pydoc.h>
+
+void bind_slicer(py::module& m)
+{
+
+    using slicer    = ::gr::air_modes::slicer;
+
+
+    py::class_<slicer, gr::sync_block, gr::block, gr::basic_block,
+        std::shared_ptr<slicer>>(m, "slicer", D(slicer))
+
+        .def(py::init(&slicer::make),
+           py::arg("queue"),
+           D(slicer,make)
+        )
+        
+
+
+
+        ;
+
+
+
+
+}
+
+
+
+
+
+
+
+

python/cpr.py

@@ -31,302 +31,302 @@ from air_modes.exceptions import *
 latz = 15
 
 def nz(ctype):
-	return 4 * latz - ctype
+    return 4 * latz - ctype
 
 def dlat(ctype, surface):
-	if surface == 1:
-		tmp = 90.0
-	else:
-		tmp = 360.0
+    if surface == 1:
+        tmp = 90.0
+    else:
+        tmp = 360.0
 
-	nzcalc = nz(ctype)
-	if nzcalc == 0:
-		return tmp
-	else:
-		return tmp / nzcalc
+    nzcalc = nz(ctype)
+    if nzcalc == 0:
+        return tmp
+    else:
+        return tmp / nzcalc
 
 def nl(declat_in):
-	if abs(declat_in) >= 87.0:
-		return 1.0
-	return math.floor( (2.0*math.pi) * math.acos(1.0- (1.0-math.cos(math.pi/(2.0*latz))) / math.cos( (math.pi/180.0)*abs(declat_in) )**2 )**-1)
+    if abs(declat_in) >= 87.0:
+        return 1.0
+    return math.floor( (2.0*math.pi) * math.acos(1.0- (1.0-math.cos(math.pi/(2.0*latz))) / math.cos( (math.pi/180.0)*abs(declat_in) )**2 )**-1)
 
 def dlon(declat_in, ctype, surface):
-	if surface:
-		tmp = 90.0
-	else:
-		tmp = 360.0
-	nlcalc = max(nl(declat_in)-ctype, 1)
-	return tmp / nlcalc
+    if surface:
+        tmp = 90.0
+    else:
+        tmp = 360.0
+    nlcalc = max(nl(declat_in)-ctype, 1)
+    return tmp / nlcalc
 
 def decode_lat(enclat, ctype, my_lat, surface):
-	tmp1 = dlat(ctype, surface)
-	tmp2 = float(enclat) / (2**17)
-	j = math.floor(my_lat/tmp1) + math.floor(0.5 + ((my_lat % tmp1) / tmp1) - tmp2)
+    tmp1 = dlat(ctype, surface)
+    tmp2 = float(enclat) / (2**17)
+    j = math.floor(my_lat/tmp1) + math.floor(0.5 + ((my_lat % tmp1) / tmp1) - tmp2)
 
-	return tmp1 * (j + tmp2)
+    return tmp1 * (j + tmp2)
 
 def decode_lon(declat, enclon, ctype, my_lon, surface):
-	tmp1 = dlon(declat, ctype, surface)
-	tmp2 = float(enclon) / (2**17)
-	m = math.floor(my_lon / tmp1) + math.floor(0.5 + ((my_lon % tmp1) / tmp1) - tmp2)
+    tmp1 = dlon(declat, ctype, surface)
+    tmp2 = float(enclon) / (2**17)
+    m = math.floor(my_lon / tmp1) + math.floor(0.5 + ((my_lon % tmp1) / tmp1) - tmp2)
 
-	return tmp1 * (m + tmp2)
+    return tmp1 * (m + tmp2)
 
 def cpr_resolve_local(my_location, encoded_location, ctype, surface):
-	[my_lat, my_lon] = my_location
-	[enclat, enclon] = encoded_location
+    [my_lat, my_lon] = my_location
+    [enclat, enclon] = encoded_location
 
-	decoded_lat = decode_lat(enclat, ctype, my_lat, surface)
-	decoded_lon = decode_lon(decoded_lat, enclon, ctype, my_lon, surface)
+    decoded_lat = decode_lat(enclat, ctype, my_lat, surface)
+    decoded_lon = decode_lon(decoded_lat, enclon, ctype, my_lon, surface)
 
-	return [decoded_lat, decoded_lon]
+    return [decoded_lat, decoded_lon]
 
 def cpr_resolve_global(evenpos, oddpos, mypos, mostrecent, surface):
-	#cannot resolve surface positions unambiguously without knowing receiver position
-	if surface and mypos is None:
-		raise CPRNoPositionError
-	
-	dlateven = dlat(0, surface)
-	dlatodd  = dlat(1, surface)
+    #cannot resolve surface positions unambiguously without knowing receiver position
+    if surface and mypos is None:
+        raise CPRNoPositionError
+    
+    dlateven = dlat(0, surface)
+    dlatodd  = dlat(1, surface)
 
-	evenpos = [float(evenpos[0]), float(evenpos[1])]
-	oddpos = [float(oddpos[0]), float(oddpos[1])]
-	
-	j = math.floor(((nz(1)*evenpos[0] - nz(0)*oddpos[0])/2**17) + 0.5) #latitude index
+    evenpos = [float(evenpos[0]), float(evenpos[1])]
+    oddpos = [float(oddpos[0]), float(oddpos[1])]
+    
+    j = math.floor(((nz(1)*evenpos[0] - nz(0)*oddpos[0])/2**17) + 0.5) #latitude index
 
-	rlateven = dlateven * ((j % nz(0))+evenpos[0]/2**17)
-	rlatodd  = dlatodd  * ((j % nz(1))+ oddpos[0]/2**17)
+    rlateven = dlateven * ((j % nz(0))+evenpos[0]/2**17)
+    rlatodd  = dlatodd  * ((j % nz(1))+ oddpos[0]/2**17)
 
-	#limit to -90, 90
-	if rlateven > 270.0:
-		rlateven -= 360.0
-	if rlatodd > 270.0:
-		rlatodd -= 360.0
+    #limit to -90, 90
+    if rlateven > 270.0:
+        rlateven -= 360.0
+    if rlatodd > 270.0:
+        rlatodd -= 360.0
 
-	#This checks to see if the latitudes of the reports straddle a transition boundary
-	#If so, you can't get a globally-resolvable location.
-	if nl(rlateven) != nl(rlatodd):
-		raise CPRBoundaryStraddleError
+    #This checks to see if the latitudes of the reports straddle a transition boundary
+    #If so, you can't get a globally-resolvable location.
+    if nl(rlateven) != nl(rlatodd):
+        raise CPRBoundaryStraddleError
 
-	if mostrecent == 0:
-		rlat = rlateven
-	else:
-		rlat = rlatodd
+    if mostrecent == 0:
+        rlat = rlateven
+    else:
+        rlat = rlatodd
 
-	#disambiguate latitude
-	if surface:
-		if mypos[0] < 0:
-			rlat -= 90
+    #disambiguate latitude
+    if surface:
+        if mypos[0] < 0:
+            rlat -= 90
 
-	dl = dlon(rlat, mostrecent, surface)
-	nl_rlat = nl(rlat)
+    dl = dlon(rlat, mostrecent, surface)
+    nl_rlat = nl(rlat)
 
-	m = math.floor(((evenpos[1]*(nl_rlat-1)-oddpos[1]*nl_rlat)/2**17)+0.5) #longitude index
-	
-	#when surface positions straddle a disambiguation boundary (90 degrees),
-	#surface decoding will fail. this might never be a problem in real life, but it'll fail in the
-	#test case. the documentation doesn't mention it.
+    m = math.floor(((evenpos[1]*(nl_rlat-1)-oddpos[1]*nl_rlat)/2**17)+0.5) #longitude index
+    
+    #when surface positions straddle a disambiguation boundary (90 degrees),
+    #surface decoding will fail. this might never be a problem in real life, but it'll fail in the
+    #test case. the documentation doesn't mention it.
 
-	if mostrecent == 0:
-		enclon = evenpos[1]
-	else:
-		enclon = oddpos[1]
+    if mostrecent == 0:
+        enclon = evenpos[1]
+    else:
+        enclon = oddpos[1]
 
-	rlon = dl * ((m % max(nl_rlat-mostrecent,1)) + enclon/2.**17)
+    rlon = dl * ((m % max(nl_rlat-mostrecent,1)) + enclon/2.**17)
 
-	#print "DL: %f nl: %f m: %f rlon: %f" % (dl, nl_rlat, m, rlon)
-	#print "evenpos: %x, oddpos: %x, mostrecent: %i" % (evenpos[1], oddpos[1], mostrecent)
+    #print "DL: %f nl: %f m: %f rlon: %f" % (dl, nl_rlat, m, rlon)
+    #print "evenpos: %x, oddpos: %x, mostrecent: %i" % (evenpos[1], oddpos[1], mostrecent)
 
-	if surface:
-		#longitudes need to be resolved to the nearest 90 degree segment to the receiver.
-		wat = mypos[1]
-		if wat < 0:
-			wat += 360
-		zone = lambda lon: 90 * (int(lon) / 90)
-		rlon += (zone(wat) - zone(rlon))
+    if surface:
+        #longitudes need to be resolved to the nearest 90 degree segment to the receiver.
+        wat = mypos[1]
+        if wat < 0:
+            wat += 360
+        zone = lambda lon: 90 * (int(lon) / 90)
+        rlon += (zone(wat) - zone(rlon))
 
-	#limit to (-180, 180)
-	if rlon > 180:
-		rlon -= 360.0
+    #limit to (-180, 180)
+    if rlon > 180:
+        rlon -= 360.0
 
-	return [rlat, rlon]
+    return [rlat, rlon]
 
 
 #calculate range and bearing between two lat/lon points
 #should probably throw this in the mlat py somewhere or make another lib
 def range_bearing(loc_a, loc_b):
-	[a_lat, a_lon] = loc_a
-	[b_lat, b_lon] = loc_b
+    [a_lat, a_lon] = loc_a
+    [b_lat, b_lon] = loc_b
 
-	esquared = (1/298.257223563)*(2-(1/298.257223563))
-	earth_radius_mi = 3963.19059 * (math.pi / 180)
+    esquared = (1/298.257223563)*(2-(1/298.257223563))
+    earth_radius_mi = 3963.19059 * (math.pi / 180)
 
-	delta_lat = b_lat - a_lat
-	delta_lon = b_lon - a_lon
+    delta_lat = b_lat - a_lat
+    delta_lon = b_lon - a_lon
 
-	avg_lat = ((a_lat + b_lat) / 2.0) * math.pi / 180
+    avg_lat = ((a_lat + b_lat) / 2.0) * math.pi / 180
 
-	R1 = earth_radius_mi*(1.0-esquared)/pow((1.0-esquared*pow(math.sin(avg_lat),2)),1.5)
+    R1 = earth_radius_mi*(1.0-esquared)/pow((1.0-esquared*pow(math.sin(avg_lat),2)),1.5)
 
-	R2 = earth_radius_mi/math.sqrt(1.0-esquared*pow(math.sin(avg_lat),2))
+    R2 = earth_radius_mi/math.sqrt(1.0-esquared*pow(math.sin(avg_lat),2))
 
-	distance_North = R1*delta_lat
-	distance_East = R2*math.cos(avg_lat)*delta_lon
+    distance_North = R1*delta_lat
+    distance_East = R2*math.cos(avg_lat)*delta_lon
 
-	bearing = math.atan2(distance_East,distance_North) * (180.0 / math.pi)
-	if bearing < 0.0:
-		bearing += 360.0
+    bearing = math.atan2(distance_East,distance_North) * (180.0 / math.pi)
+    if bearing < 0.0:
+        bearing += 360.0
 
-	rnge = math.hypot(distance_East,distance_North)
-	return [rnge, bearing]
+    rnge = math.hypot(distance_East,distance_North)
+    return [rnge, bearing]
 
 class cpr_decoder:
-	def __init__(self, my_location):
-		self.my_location = my_location
-		self.evenlist = {}
-		self.oddlist = {}
-		self.evenlist_sfc = {}
-		self.oddlist_sfc = {}
+    def __init__(self, my_location):
+        self.my_location = my_location
+        self.evenlist = {}
+        self.oddlist = {}
+        self.evenlist_sfc = {}
+        self.oddlist_sfc = {}
 
-	def set_location(self, new_location):
-		self.my_location = new_location
+    def set_location(self, new_location):
+        self.my_location = new_location
 
-	def weed_poslists(self):
-		for poslist in [self.evenlist, self.oddlist]:
-			for key, item in poslist.items():
-				if time.time() - item[2] > 10:
-					del poslist[key]
-		for poslist in [self.evenlist_sfc, self.oddlist_sfc]:
-			for key, item in poslist.items():
-				if time.time() - item[2] > 25:
-					del poslist[key]
+    def weed_poslists(self):
+        for poslist in [self.evenlist, self.oddlist]:
+            for key, item in tuple(poslist.items()):
+                if time.time() - item[2] > 10:
+                    del poslist[key]
+        for poslist in [self.evenlist_sfc, self.oddlist_sfc]:
+            for key, item in tuple(poslist.items()):
+                if time.time() - item[2] > 25:
+                    del poslist[key]
 
-	def decode(self, icao24, encoded_lat, encoded_lon, cpr_format, surface):
-		if surface:
-			oddlist = self.oddlist_sfc
-			evenlist = self.evenlist_sfc
-		else:
-			oddlist = self.oddlist
-			evenlist = self.evenlist
+    def decode(self, icao24, encoded_lat, encoded_lon, cpr_format, surface):
+        if surface:
+            oddlist = self.oddlist_sfc
+            evenlist = self.evenlist_sfc
+        else:
+            oddlist = self.oddlist
+            evenlist = self.evenlist
 
-		#add the info to the position reports list for global decoding
-		if cpr_format==1:
-			oddlist[icao24] = [encoded_lat, encoded_lon, time.time()]
-		else:
-			evenlist[icao24] = [encoded_lat, encoded_lon, time.time()]
+        #add the info to the position reports list for global decoding
+        if cpr_format==1:
+            oddlist[icao24] = [encoded_lat, encoded_lon, time.time()]
+        else:
+            evenlist[icao24] = [encoded_lat, encoded_lon, time.time()]
 
-		[decoded_lat, decoded_lon] = [None, None]
+        [decoded_lat, decoded_lon] = [None, None]
 
-		#okay, let's traverse the lists and weed out those entries that are older than 10 seconds
-		self.weed_poslists()
+        #okay, let's traverse the lists and weed out those entries that are older than 10 seconds
+        self.weed_poslists()
 
-		if (icao24 in evenlist) \
-		  and (icao24 in oddlist):
-			newer = (oddlist[icao24][2] - evenlist[icao24][2]) > 0 #figure out which report is newer
-   			[decoded_lat, decoded_lon] = cpr_resolve_global(evenlist[icao24][0:2], oddlist[icao24][0:2], self.my_location, newer, surface) #do a global decode
-		else:
-			raise CPRNoPositionError
+        if (icao24 in evenlist) \
+          and (icao24 in oddlist):
+            newer = (oddlist[icao24][2] - evenlist[icao24][2]) > 0 #figure out which report is newer
+            [decoded_lat, decoded_lon] = cpr_resolve_global(evenlist[icao24][0:2], oddlist[icao24][0:2], self.my_location, newer, surface) #do a global decode
+        else:
+            raise CPRNoPositionError
 
-		if self.my_location is not None:
-			[rnge, bearing] = range_bearing(self.my_location, [decoded_lat, decoded_lon])
-		else:
-			rnge = None
-			bearing = None
+        if self.my_location is not None:
+            [rnge, bearing] = range_bearing(self.my_location, [decoded_lat, decoded_lon])
+        else:
+            rnge = None
+            bearing = None
 
-		return [decoded_lat, decoded_lon, rnge, bearing]
+        return [decoded_lat, decoded_lon, rnge, bearing]
 
 #encode CPR position
 def cpr_encode(lat, lon, ctype, surface):
-	if surface is True:
-		scalar = 2.**19
-	else:
-		scalar = 2.**17
+    if surface is True:
+        scalar = 2.**19
+    else:
+        scalar = 2.**17
 
-	#encode using 360 constant for segment size.
-	dlati = dlat(ctype, False)
-	yz = math.floor(scalar * ((lat % dlati)/dlati) + 0.5)
-	rlat = dlati * ((yz / scalar) + math.floor(lat / dlati))
+    #encode using 360 constant for segment size.
+    dlati = dlat(ctype, False)
+    yz = math.floor(scalar * ((lat % dlati)/dlati) + 0.5)
+    rlat = dlati * ((yz / scalar) + math.floor(lat / dlati))
 
-	#encode using 360 constant for segment size.
-	dloni = dlon(lat, ctype, False)
-	xz = math.floor(scalar * ((lon % dloni)/dloni) + 0.5)
+    #encode using 360 constant for segment size.
+    dloni = dlon(lat, ctype, False)
+    xz = math.floor(scalar * ((lon % dloni)/dloni) + 0.5)
 
-	yz = int(yz) & (2**17-1)
-	xz = int(xz) & (2**17-1)
+    yz = int(yz) & (2**17-1)
+    xz = int(xz) & (2**17-1)
 
-	return (yz, xz) #lat, lon
+    return (yz, xz) #lat, lon
 
 if __name__ == '__main__':
-	import sys, random
-	
-	rounds = 10001
-	threshold = 1e-3 #0.001 deg lat/lon
-	#this accuracy is highly dependent on latitude, since at high
-	#latitudes the corresponding error in longitude is greater
+    import sys, random
+    
+    rounds = 10001
+    threshold = 1e-3 #0.001 deg lat/lon
+    #this accuracy is highly dependent on latitude, since at high
+    #latitudes the corresponding error in longitude is greater
 
-	bs = 0
-	surface = False
+    bs = 0
+    surface = False
 
-	lats = [i/(rounds/170.)-85 for i in range(0,rounds)]
-	lons = [i/(rounds/360.)-180 for i in range(0,rounds)]
+    lats = [i/(rounds/170.)-85 for i in range(0,rounds)]
+    lons = [i/(rounds/360.)-180 for i in range(0,rounds)]
 
-	for i in range(0, rounds):
-		even_lat = lats[i]
-		#even_lat = random.uniform(-85, 85)
-		even_lon = lons[i]
-		#even_lon = random.uniform(-180, 180)
-		odd_lat = even_lat + 1e-3
-		odd_lon = min(even_lon + 1e-3, 180)
-		decoder = cpr_decoder([odd_lat, odd_lon])
+    for i in range(0, rounds):
+        even_lat = lats[i]
+        #even_lat = random.uniform(-85, 85)
+        even_lon = lons[i]
+        #even_lon = random.uniform(-180, 180)
+        odd_lat = even_lat + 1e-3
+        odd_lon = min(even_lon + 1e-3, 180)
+        decoder = cpr_decoder([odd_lat, odd_lon])
 
-		#encode that position
-		(evenenclat, evenenclon) = cpr_encode(even_lat, even_lon, False, surface)
-		(oddenclat, oddenclon)   = cpr_encode(odd_lat, odd_lon, True, surface)
+        #encode that position
+        (evenenclat, evenenclon) = cpr_encode(even_lat, even_lon, False, surface)
+        (oddenclat, oddenclon)   = cpr_encode(odd_lat, odd_lon, True, surface)
 
-		#try to perform a global decode -- this should fail since the decoder
-		#only has heard one position. need two for global decoding.
-		icao = random.randint(0, 0xffffff)
-		try:
-			evenpos = decoder.decode(icao, evenenclat, evenenclon, False, surface)
-			raise Exception("CPR test failure: global decode with only one report")
-		except CPRNoPositionError:
-			pass
+        #try to perform a global decode -- this should fail since the decoder
+        #only has heard one position. need two for global decoding.
+        icao = random.randint(0, 0xffffff)
+        try:
+            evenpos = decoder.decode(icao, evenenclat, evenenclon, False, surface)
+            raise Exception("CPR test failure: global decode with only one report")
+        except CPRNoPositionError:
+            pass
 
-		#now try to do a real decode with the last packet's odd complement
-		#watch for a boundary straddle -- this isn't fatal, it just indicates
-		#that the even and odd reports lie on either side of a longitudinal boundary
-		#and so you can't get a position
-		try:
-			(odddeclat, odddeclon, rng, brg) = decoder.decode(icao, oddenclat, oddenclon, True, surface)
-		except CPRBoundaryStraddleError:
-			bs += 1
-			continue
-		except CPRNoPositionError:
-			raise Exception("CPR test failure: no decode after even/odd inputs")
+        #now try to do a real decode with the last packet's odd complement
+        #watch for a boundary straddle -- this isn't fatal, it just indicates
+        #that the even and odd reports lie on either side of a longitudinal boundary
+        #and so you can't get a position
+        try:
+            (odddeclat, odddeclon, rng, brg) = decoder.decode(icao, oddenclat, oddenclon, True, surface)
+        except CPRBoundaryStraddleError:
+            bs += 1
+            continue
+        except CPRNoPositionError:
+            raise Exception("CPR test failure: no decode after even/odd inputs")
 
-		if abs(odddeclat - odd_lat) > threshold or abs(odddeclon - odd_lon) > threshold:
-			print "F odddeclat: %f odd_lat: %f" % (odddeclat, odd_lat)
-			print "F odddeclon: %f odd_lon: %f" % (odddeclon, odd_lon)
-			raise Exception("CPR test failure: global decode error greater than threshold")
-#		else:
-#			print "S odddeclat: %f odd_lat: %f" % (odddeclat, odd_lat)
-#			print "S odddeclon: %f odd_lon: %f" % (odddeclon, odd_lon)
+        if abs(odddeclat - odd_lat) > threshold or abs(odddeclon - odd_lon) > threshold:
+            print("F odddeclat: %f odd_lat: %f" % (odddeclat, odd_lat))
+            print( "F odddeclon: %f odd_lon: %f" % (odddeclon, odd_lon))
+            raise Exception("CPR test failure: global decode error greater than threshold")
+#       else:
+#           print("S odddeclat: %f odd_lat: %f" % (odddeclat, odd_lat))
+#           print("S odddeclon: %f odd_lon: %f" % (odddeclon, odd_lon))
 
-		nexteven_lat = odd_lat + 1e-3
-		nexteven_lon = min(odd_lon + 1e-3, 180)
+        nexteven_lat = odd_lat + 1e-3
+        nexteven_lon = min(odd_lon + 1e-3, 180)
 
-		(nexteven_enclat, nexteven_enclon) = cpr_encode(nexteven_lat, nexteven_lon, False, surface)
+        (nexteven_enclat, nexteven_enclon) = cpr_encode(nexteven_lat, nexteven_lon, False, surface)
 
-		#try a locally-referenced decode
-		try:
-			(evendeclat, evendeclon) = cpr_resolve_local([even_lat, even_lon], [nexteven_enclat, nexteven_enclon], False, surface)
-		except CPRNoPositionError:
-			raise Exception("CPR test failure: local decode failure to resolve")
+        #try a locally-referenced decode
+        try:
+            (evendeclat, evendeclon) = cpr_resolve_local([even_lat, even_lon], [nexteven_enclat, nexteven_enclon], False, surface)
+        except CPRNoPositionError:
+            raise Exception("CPR test failure: local decode failure to resolve")
 
-		#check to see if the positions were valid
-		if abs(evendeclat - nexteven_lat) > threshold or abs(evendeclon - nexteven_lon) > threshold:
-			print "F evendeclat: %f nexteven_lat: %f evenlat: %f" % (evendeclat, nexteven_lat, even_lat)
-			print "F evendeclon: %f nexteven_lon: %f evenlon: %f" % (evendeclon, nexteven_lon, even_lon)
-			raise Exception("CPR test failure: local decode error greater than threshold")
+        #check to see if the positions were valid
+        if abs(evendeclat - nexteven_lat) > threshold or abs(evendeclon - nexteven_lon) > threshold:
+            print("F evendeclat: %f nexteven_lat: %f evenlat: %f" % (evendeclat, nexteven_lat, even_lat))
+            print("F evendeclon: %f nexteven_lon: %f evenlon: %f" % (evendeclon, nexteven_lon, even_lon))
+            raise Exception("CPR test failure: local decode error greater than threshold")
 
-	print "CPR test successful. There were %i boundary straddles over %i rounds." % (bs, rounds)
+    print("CPR test successful. There were %i boundary straddles over %i rounds." % (bs, rounds))

python/flightgear.py

@@ -18,50 +18,48 @@ class output_flightgear:
     def __init__(self, cprdec, hostname, port, pub):
         self.hostname = hostname
         self.port = port
-        self.localpos = localpos
         self.positions = {}
         self.velocities = {}
         self.callsigns = {}
         self._cpr = cprdec
 
         self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        self.sock.connect((self.hostname, self.port))
-        pub.subscribe("type17_dl", output)
+#        self.sock.connect((self.hostname, self.port))
+        pub.subscribe("type17_dl", self.output)
 
     def output(self, msg):
-        
         try:
             msgtype = msg.data["df"]
             if msgtype == 17: #ADS-B report
                 icao24 = msg.data["aa"]
                 bdsreg = msg.data["me"].get_type()
                 if bdsreg == 0x08: #ident packet
-                    (ident, actype) = air_modes.parseBDS08(data)
+                    (ident, actype) = air_modes.parseBDS08(msg.data)
                     #select model based on actype
                     self.callsigns[icao24] = [ident, actype]
-                    
+
                 elif bdsreg == 0x06: #BDS0,6 pos
-                    [ground_track, decoded_lat, decoded_lon, rnge, bearing] = air_modes.parseBDS06(data, self._cpr)
+                    [ground_track, decoded_lat, decoded_lon, rnge, bearing] = air_modes.parseBDS06(msg.data, self._cpr)
                     self.positions[icao24] = [decoded_lat, decoded_lon, 0]
                     self.update(icao24)
 
                 elif bdsreg == 0x05: #BDS0,5 pos
-                    [altitude, decoded_lat, decoded_lon, rnge, bearing] = air_modes.parseBDS05(data, self._cpr)
+                    [altitude, decoded_lat, decoded_lon, rnge, bearing] = air_modes.parseBDS05(msg.data, self._cpr)
                     self.positions[icao24] = [decoded_lat, decoded_lon, altitude]
                     self.update(icao24)
 
                 elif bdsreg == 0x09: #velocity
-                    subtype = data["bds09"].get_type()
+                    subtype = msg.data["bds09"].get_type()
                     if subtype == 0:
-                      [velocity, heading, vert_spd, turnrate] = air_modes.parseBDS09_0(data)
+                      [velocity, heading, vert_spd, turnrate] = air_modes.parseBDS09_0(msg.data)
                     elif subtype == 1:
-                      [velocity, heading, vert_spd] = air_modes.parseBDS09_1(data)
+                      [velocity, heading, vert_spd] = air_modes.parseBDS09_1(msg.data)
                       turnrate = 0
                     else:
                         return
 
                     self.velocities[icao24] = [velocity, heading, vert_spd, turnrate]
-                    
+
         except ADSBError:
             pass
 
@@ -71,7 +69,7 @@ class output_flightgear:
                and (icao24 in self.velocities)\
                and (icao24 in self.callsigns)
         if complete:
-            print "FG update: %s" % (self.callsigns[icao24][0])
+            print("FG update: %s" % (self.callsigns[icao24][0]))
             msg = fg_posmsg(self.callsigns[icao24][0],
                             self.callsigns[icao24][1],
                             self.positions[icao24][0],
@@ -82,7 +80,7 @@ class output_flightgear:
                             self.velocities[icao24][2],
                             self.velocities[icao24][3]).pack()
 
-            self.sock.send(msg)
+            self.sock.sendto(msg, (self.hostname, self.port))
 
 class fg_header:
     def __init__(self):
@@ -121,7 +119,7 @@ modelmap = { None:                       'Aircraft/777-200/Models/777-200ER.xml'
             "SMALL":                     'Aircraft/CitationX/Models/Citation-X.xml',
             "LARGE":                     'Aircraft/CRJ700-family/Models/CRJ700.xml',
             "LARGE HIGH VORTEX":         'Aircraft/757-200/Models/757-200.xml',
-            "HEAVY":                     'Aircraft/747-200/Models/boeing747-200.xml',
+            "HEAVY":                     'Aircraft/IDG-A32X/Models/A320neo-CFM.xml',
             "HIGH PERFORMANCE":          'Aircraft/SR71-BlackBird/Models/Blackbird-SR71B.xml', #yeah i know
             "ROTORCRAFT":                'Aircraft/ec130/Models/ec130b4.xml',
             "GLIDER":                    'Aircraft/ASK21-MI/Models/ask21mi.xml',

python/html_template.py

@@ -2,7 +2,7 @@
 #HTML template for Mode S map display
 #Nick Foster, 2013
 
-def html_template(my_position, json_file):
+def html_template(my_apikey, my_position, json_file):
     if my_position is None:
         my_position = [37, -122]
 
@@ -25,9 +25,9 @@ def html_template(my_position, json_file):
                 white-space: nowrap;
             }
         </style>
-        <script type="text/javascript" src="http://maps.google.com/maps/api/js?sensor=false">
+        <script type="text/javascript" src="http://maps.google.com/maps/api/js?key=%s">
         </script>
-        <script type="text/javascript" src="http://google-maps-utility-library-v3.googlecode.com/svn/tags/markerwithlabel/1.1.9/src/markerwithlabel.js">
+        <script type="text/javascript" src="https://raw.githubusercontent.com/googlemaps/v3-utility-library/master/markerwithlabel/src/markerwithlabel.js">
         </script>
         <script type="text/javascript">
             var map;
@@ -53,7 +53,6 @@ def html_template(my_position, json_file):
             };
 
             function jsonp_callback(results) { // from JSONP
-                clearMarkers();
                 airplanes = {};
                 for (var i = 0; i < results.length; i++) {
                     airplanes[results[i].icao] = {
@@ -67,10 +66,20 @@ def html_template(my_position, json_file):
                         highlight: results[i].highlight
                     };
                 }
+//                clearMarkers();
                 refreshIcons();
             }
 
             function refreshIcons() {
+                //prune the list
+                for(var i = 0; i < planes.length; i++) {
+                    icao = planes[i].get("icao")
+                    if(!(icao in airplanes)) {
+                        planes[i].setMap(null)
+                        planes.splice(i, 1);
+                    };
+                };
+
                 for (var airplane in airplanes) {
                     if (airplanes[airplane].highlight != 0) {
                         icon_file = "http://www.nerdnetworks.org/~bistromath/airplane_sprite_highlight.png";
@@ -86,7 +95,7 @@ def html_template(my_position, json_file):
                     };
 
                     if (airplanes[airplane].ident.length != 8) {
-                        identstr = airplane; 
+                        identstr = airplane;
                     } else {
                         identstr = airplanes[airplane].ident;
                     };
@@ -94,14 +103,31 @@ def html_template(my_position, json_file):
                     var planeOptions = {
                         map: map,
                         position: airplanes[airplane].center,
+                        icao: airplane,
                         icon: plane_icon,
                         labelContent: identstr,
                         labelAnchor: new google.maps.Point(35, -32),
                         labelClass: "labels",
                         labelStyle: {opacity: 0.75}
                     };
-                    planeMarker = new MarkerWithLabel(planeOptions);
-                    planes.push(planeMarker);
+
+                    var i = 0;
+                    for(i; i<planes.length; i++) {
+                        if(planes[i].get("icao") == airplane) {
+                            planes[i].setPosition(airplanes[airplane].center);
+                            if(planes[i].get("icon") != plane_icon) {
+                                planes[i].setIcon(plane_icon); //handles highlight and heading
+                            };
+                            if(planes[i].get("labelContent") != identstr) {
+                                planes[i].set("labelContent", identstr);
+                            };
+                            break;
+                        };
+                    };
+                    if(i == planes.length) {
+                        planeMarker = new MarkerWithLabel(planeOptions);
+                        planes.push(planeMarker);
+                    };
                 };
             };
 
@@ -126,4 +152,4 @@ def html_template(my_position, json_file):
         <div id="map_canvas" style="width:100%%; height:100%%">
         </div>
     </body>
-</html>""" % (my_position[0], my_position[1], json_file)
+</html>""" % (my_apikey, my_position[0], my_position[1], json_file)

python/kml.py

@@ -20,7 +20,7 @@
 # 
 
 import sqlite3
-import string, math, threading, time
+import math, threading, time
 
 class output_kml(threading.Thread):
     def __init__(self, filename, dbname, localpos, lock, timeout=5):
@@ -89,7 +89,7 @@ class output_kml(threading.Thread):
             lon_out = center_lon + math.degrees(math.atan2(math.sin(bearing)*math.sin(tmp0)*math.cos(lat_rad), math.cos(tmp0)-math.sin(lat_rad)*math.sin(math.radians(lat_out))))
             retstr += " %.8f,%.8f, 0" % (lon_out, lat_out,)
 
-        retstr = string.lstrip(retstr)
+        retstr = retstr.lstrip()
         return retstr
 
     def genkml(self):
@@ -132,7 +132,7 @@ class output_kml(threading.Thread):
                 for pos in track:
                     trackstr += " %f,%f,%f" % (pos[4], pos[3], pos[2]*0.3048)
 
-                trackstr = string.lstrip(trackstr)
+                trackstr = trackstr.lstrip()
             else:
                 alt = 0
                 metric_alt = 0

python/mlat.py

@@ -55,7 +55,8 @@ wgs84_b2 = wgs84_b**2
 
 #convert ECEF to lat/lon/alt without geoid correction
 #returns alt in meters
-def ecef2llh((x,y,z)):
+def ecef2llh(ecef):
+    x, y, z = ecef
     ep  = math.sqrt((wgs84_a2 - wgs84_b2) / wgs84_b2)
     p   = math.sqrt(x**2+y**2)
     th  = math.atan2(wgs84_a*z, wgs84_b*p)
@@ -71,7 +72,8 @@ def ecef2llh((x,y,z)):
 
 #convert lat/lon/alt coords to ECEF without geoid correction, WGS84 model
 #remember that alt is in meters
-def llh2ecef((lat, lon, alt)):
+def llh2ecef(lla):
+    lat, lon, alt = lla
     lat *= (math.pi / 180.0)
     lon *= (math.pi / 180.0)
     
@@ -84,7 +86,8 @@ def llh2ecef((lat, lon, alt)):
     return [x,y,z]
     
 #do both of the above to get a geoid-corrected x,y,z position
-def llh2geoid((lat, lon, alt)):
+def llh2geoid(lla):
+    lat, lon, alt = lla
     (x,y,z) = llh2ecef((lat, lon, alt + wgs84_height(lat, lon)))
     return [x,y,z]
 
@@ -185,7 +188,7 @@ if __name__ == '__main__':
                     10 + numpy.linalg.norm(testplane-numpy.array(llh2geoid(teststations[3]))) / c,
                 ]
 
-    print teststamps
+    print(teststamps)
 
     replies = []
     for i in range(0, len(teststations)):
@@ -193,7 +196,7 @@ if __name__ == '__main__':
     ans = mlat(replies, testalt)
     error = numpy.linalg.norm(numpy.array(llh2ecef(ans))-numpy.array(testplane))
     range = numpy.linalg.norm(llh2geoid(ans)-numpy.array(testme))
-    print testplane-testme
-    print ans
-    print "Error: %.2fm" % (error)
-    print "Range: %.2fkm (from first station in list)" % (range/1000)
+    print(testplane-testme)
+    print(ans)
+    print("Error: %.2fm" % (error))
+    print("Range: %.2fkm (from first station in list)" % (range/1000))

python/mlat_types.py

@@ -1 +0,0 @@
-

python/msgq_runner.py

@@ -0,0 +1,70 @@
+#
+# Copyright 2009 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+#
+#
+
+"""
+Convenience class for dequeuing messages from a gr.msg_queue and
+invoking a callback.
+
+Creates a Python thread that does a blocking read on the supplied
+gr.msg_queue, then invokes callback each time a msg is received.
+
+If the msg type is not 0, then it is treated as a signal to exit
+its loop.
+
+If the callback raises an exception, and the runner was created
+with 'exit_on_error' equal to True, then the runner will store the
+exception and exit its loop, otherwise the exception is ignored.
+
+To get the exception that the callback raised, if any, call
+exit_error() on the object.
+
+To manually stop the runner, call stop() on the object.
+
+To determine if the runner has exited, call exited() on the object.
+"""
+
+from gnuradio import gr
+import threading
+
+class msgq_runner(threading.Thread):
+
+    def __init__(self, msgq, callback, exit_on_error=False):
+        threading.Thread.__init__(self)
+
+        self._msgq = msgq
+        self._callback = callback
+        self._exit_on_error = exit_on_error
+        self._done = False
+        self._exited = False
+        self._exit_error = None
+        self.setDaemon(1)
+        self.start()
+
+    def run(self):
+        while not self._done:
+            msg = self._msgq.delete_head()
+            if msg.type() != 0:
+                self.stop()
+            else:
+                try:
+                    self._callback(msg)
+                except Exception as e:
+                    if self._exit_on_error:
+                        self._exit_error = e
+                        self.stop()
+        self._exited = True
+
+    def stop(self):
+        self._done = True
+
+    def exited(self):
+        return self._exited
+
+    def exit_error(self):
+        return self._exit_error

python/msprint.py

@@ -20,7 +20,6 @@
 # 
 
 import time, os, sys
-from string import split, join
 import air_modes
 from air_modes.exceptions import *
 import math
@@ -44,7 +43,7 @@ class output_print:
 
   def _print(self, msg):
     if self._callback is None:
-        print msg
+        print(msg)
     else:
         self._callback(msg)
 
@@ -81,7 +80,7 @@ class output_print:
     except ADSBError:
         return
 
-    if msg.data["vs"] is 1:
+    if msg.data["vs"] == 1:
       retstr += " (aircraft is on the ground)"
 
     self._print(retstr)

python/parse.py

@@ -20,8 +20,7 @@
 #
 
 import time, os, sys
-from string import split, join
-from altitude import decode_alt
+from air_modes.altitude import decode_alt
 import math
 import air_modes
 from air_modes.exceptions import *
@@ -32,14 +31,14 @@ class data_field:
     self.data = data
     self.fields = self.parse()
 
-  types = { }
+  dtypes = { }
   offset = 1   #field offset applied to all fields. used for offsetting
                #subtypes to reconcile with the spec. Really just for readability.
 
   #get a particular field from the data
   def __getitem__(self, fieldname):
     mytype = self.get_type()
-    if mytype in self.types:
+    if mytype in self.dtypes:
       if fieldname in self.fields: #verify it exists in this packet type
         return self.fields[fieldname]
       else:
@@ -52,9 +51,9 @@ class data_field:
   def parse(self):
     fields = {}
     mytype = self.get_type()
-    if mytype in self.types:
-      for field in self.types[mytype]:
-        bits = self.types[self.get_type()][field]
+    if mytype in self.dtypes:
+      for field in self.dtypes[mytype]:
+        bits = self.dtypes[self.get_type()][field]
         if len(bits) == 3:
           obj = bits[2](self.get_bits(bits[0], bits[1]))
           fields.update(obj.parse())
@@ -93,7 +92,7 @@ class data_field:
 
 class bds09_reply(data_field):
   offset = 6
-  types = {  #BDS0,9 subtype 0
+  dtypes = {  #BDS0,9 subtype 0
              0: {"sub": (6,3), "dew": (10,1), "vew": (11,11), "dns": (22,1),
                  "vns": (23,11), "str": (34,1), "tr": (35,6), "dvr": (41,1),
                  "vr": (42,9)},
@@ -123,7 +122,7 @@ class bds09_reply(data_field):
 class me_reply(data_field):
   #types in this format are listed by BDS register
   #TODO: add comments explaining these fields
-  types = { 0x05: {"ftc": (1,5), "ss": (6,2), "saf": (8,1), "alt": (9,12), "time": (21,1), "cpr": (22,1), "lat": (23,17), "lon": (40,17)}, #airborne position
+  dtypes = { 0x05: {"ftc": (1,5), "ss": (6,2), "saf": (8,1), "alt": (9,12), "time": (21,1), "cpr": (22,1), "lat": (23,17), "lon": (40,17)}, #airborne position
             0x06: {"ftc": (1,5), "mvt": (6,7), "gts": (13,1), "gtk": (14,7), "time": (21,1), "cpr": (22,1), "lat": (23,17), "lon": (40,17)}, #surface position
             0x07: {"ftc": (1,5),}, #TODO extended squitter status
             0x08: {"ftc": (1,5), "cat": (6,3), "ident": (9,48)}, #extended squitter identification and type
@@ -157,7 +156,7 @@ class me_reply(data_field):
 #resolves the TCAS reply types from TTI info
 class tcas_reply(data_field):
   offset = 61
-  types = { 0: {"tti": (61,2)}, #UNKNOWN
+  dtypes = { 0: {"tti": (61,2)}, #UNKNOWN
             1: {"tti": (61,2), "tid": (63,26)},
             2: {"tti": (61,2), "tida": (63,13), "tidr": (76,7), "tidb": (83,6)}
           }
@@ -171,7 +170,7 @@ class tcas_reply(data_field):
 class mb_reply(data_field):
   offset = 33 #fields offset by 33 to match documentation
   #types are based on bds1 subfield
-  types = { 0: {"bds1": (33,4), "bds2": (37,4)}, #TODO
+  dtypes = { 0: {"bds1": (33,4), "bds2": (37,4)}, #TODO
             1: {"bds1": (33,4), "bds2": (37,4), "cfs": (41,4), "acs": (45,20), "bcs": (65,16), "ecs": (81,8)},
             2: {"bds1": (33,4), "bds2": (37,4), "ais": (41,48)},
             3: {"bds1": (33,4), "bds2": (37,4), "ara": (41,14), "rac": (55,4), "rat": (59,1),
@@ -195,7 +194,7 @@ class mb_reply(data_field):
 
 class mv_reply(data_field):
   offset = 33
-  types = { "ara": (41,14), "mte": (60,1),  "rac": (55,4), "rat": (59,1),
+  dtypes = { "ara": (41,14), "mte": (60,1),  "rac": (55,4), "rat": (59,1),
             "vds": (33,8),  "vds1": (33,4), "vds2": (37,4)
           }
 
@@ -211,7 +210,7 @@ class mv_reply(data_field):
 
 #the whole Mode S packet type
 class modes_reply(data_field):
-  types = { 0: {"df": (1,5), "vs": (6,1), "cc": (7,1), "sl": (9,3), "ri": (14,4), "ac": (20,13), "ap": (33,24)},
+  dtypes = { 0: {"df": (1,5), "vs": (6,1), "cc": (7,1), "sl": (9,3), "ri": (14,4), "ac": (20,13), "ap": (33,24)},
             4: {"df": (1,5), "fs": (6,3), "dr": (9,5), "um": (14,6), "ac": (20,13), "ap": (33,24)},
             5: {"df": (1,5), "fs": (6,3), "dr": (9,5), "um": (14,6), "id": (20,13), "ap": (33,24)},
            11: {"df": (1,5), "ca": (6,3), "aa": (9,24), "pi": (33,24)},
@@ -335,13 +334,13 @@ def parseBDS09_1(data):
   ew = bool(data["dew"])
   subtype = data["sub"]
   if subtype == 0x02:
-    ns_vel <<= 2
-    ew_vel <<= 2
+    ns_vel *= 4
+    ew_vel *= 4
 
   velocity = math.hypot(ns_vel, ew_vel)
   if ew:
     ew_vel = 0 - ew_vel
-	
+
   if ns_vel == 0:
     heading = 0
   else:
@@ -423,12 +422,12 @@ def parse_TCAS_CRM(data):
 def make_parser(pub):
   publisher = pub
   def publish(message):
-    [data, ecc, reference, timestamp] = message.split()
+    [data, ecc, reference, int_timestamp, frac_timestamp] = message.split()
     try:
       ret = air_modes.modes_report(modes_reply(int(data, 16)),
                                    int(ecc, 16),
                                    10.0*math.log10(max(1e-8,float(reference))),
-                                   air_modes.stamp(0, float(timestamp)))
+                                   air_modes.stamp(int(int_timestamp), float(frac_timestamp)))
       pub["modes_dl"] = ret
       pub["type%i_dl" % ret.data.get_type()] = ret
     except ADSBError:

python/qa_gr-air-modes.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python
-#
-# Copyright 2004,2007 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.
-# 
-
-from gnuradio import gr, gr_unittest
-import gr-air-modes_swig
-
-class qa_gr-air-modes (gr_unittest.TestCase):
-
-    def setUp (self):
-        self.tb = gr.top_block ()
-
-    def tearDown (self):
-        self.tb = None
-
-    def test_001_square_ff (self):
-        src_data = (-3, 4, -5.5, 2, 3)
-        expected_result = (9, 16, 30.25, 4, 9)
-        src = gr.vector_source_f (src_data)
-        sqr = gr-air-modes_swig.square_ff ()
-        dst = gr.vector_sink_f ()
-        self.tb.connect (src, sqr)
-        self.tb.connect (sqr, dst)
-        self.tb.run ()
-        result_data = dst.data ()
-        self.assertFloatTuplesAlmostEqual (expected_result, result_data, 6)
-
-    def test_002_square2_ff (self):
-        src_data = (-3, 4, -5.5, 2, 3)
-        expected_result = (9, 16, 30.25, 4, 9)
-        src = gr.vector_source_f (src_data)
-        sqr = gr-air-modes_swig.square2_ff ()
-        dst = gr.vector_sink_f ()
-        self.tb.connect (src, sqr)
-        self.tb.connect (sqr, dst)
-        self.tb.run ()
-        result_data = dst.data ()
-        self.assertFloatTuplesAlmostEqual (expected_result, result_data, 6)
-        
-if __name__ == '__main__':
-    gr_unittest.main ()

python/radio.py

@@ -23,17 +23,17 @@
 # You pass it options, it gives you data.
 # It uses the pubsub interface to allow clients to subscribe to its data feeds.
 
-from gnuradio import gr, gru, eng_notation, filter, blocks
+from gnuradio import gr, eng_notation, filter, blocks
 from gnuradio.filter import optfir
 from gnuradio.eng_option import eng_option
 from gnuradio.gr.pubsub import pubsub
+from gnuradio.filter import pfb
 from optparse import OptionParser, OptionGroup
 import air_modes
 import zmq
 import threading
 import time
 import re
-import fractions
 
 class modes_radio (gr.top_block, pubsub):
   def __init__(self, options, context):
@@ -45,12 +45,17 @@ class modes_radio (gr.top_block, pubsub):
 
     self._resample = None
     self._setup_source(options)
-    if self._resample is not None:
-        self._rate = 4.0e6 #fixed rate we resample to in RTL case
 
-    self._rx_path = air_modes.rx_path(self._rate, options.threshold,
+    if self._rate < 4e6:
+        self._resample = pfb.arb_resampler_ccf(4.e6/self._rate)
+        self._rx_rate = 4e6
+    else:
+        self._rx_rate = self._rate
+
+    self._rx_path = air_modes.rx_path(self._rx_rate, options.threshold,
                                       self._queue, options.pmf, options.dcblock)
 
+
     #now subscribe to set various options via pubsub
     self.subscribe("freq", self.set_freq)
     self.subscribe("gain", self.set_gain)
@@ -76,7 +81,7 @@ class modes_radio (gr.top_block, pubsub):
         server_addr += ["tcp://*:%i" % options.tcp]
 
     self._sender = air_modes.zmq_pubsub_iface(context, subaddr=None, pubaddr=server_addr)
-    self._async_sender = gru.msgq_runner(self._queue, self.send)
+    self._async_sender = air_modes.msgq_runner(self._queue, self.send)
 
   def send(self, msg):
     self._sender["dl_data"] = msg.to_string()
@@ -108,7 +113,7 @@ class modes_radio (gr.top_block, pubsub):
                       help="set sample rate [default=%default]")
     group.add_option("-T", "--threshold", type="eng_float", default=7.0,
                       help="set pulse detection threshold above noise in dB [default=%default]")
-    group.add_option("-p","--pmf", action="store_true", default=False,
+    group.add_option("-p","--pmf", action="store_true", default=True,
                       help="Use pulse matched filtering [default=%default]")
     group.add_option("-d","--dcblock", action="store_true", default=False,
                       help="Use a DC blocking filter (best for HackRF Jawbreaker) [default=%default]")
@@ -124,12 +129,24 @@ class modes_radio (gr.top_block, pubsub):
   def set_gain(self, gain):
     if self.live_source():
         self._u.set_gain(gain)
-        print "Gain is %f" % self.get_gain()
+        print("Gain is %f" % self.get_gain())
     return self.get_gain()
 
   def set_rate(self, rate):
-    self._rx_path.set_rate(rate)
-    return self._u.set_rate(rate) if self.live_source() else 0
+    if(rate < 4e6 and self._rate > 4e6):
+        raise NotImplementedError("Lowering rate <4e6Msps not currently supported.")
+    if(rate < 4e6):
+        self._resample.set_rate(4e6/rate)
+        self._rx_rate = 4e6
+    else:
+        self._rx_rate = rate
+    self._rx_path.set_rate(self._rx_rate)
+    if self._options.source in ("osmocom"):
+        return self._u.set_sample_rate(rate)
+    if self._options.source in ("uhd"):
+        return self._u.set_rate(rate)
+    else:
+        return 0
 
   def set_threshold(self, threshold):
     self._rx_path.set_threshold(threshold)
@@ -147,13 +164,19 @@ class modes_radio (gr.top_block, pubsub):
     if options.source == "uhd":
       #UHD source by default
       from gnuradio import uhd
-      self._u = uhd.single_usrp_source(options.args, uhd.io_type_t.COMPLEX_FLOAT32, 1)
+      self._u = uhd.usrp_source(
+          options.args,
+          uhd.stream_args(
+              cpu_format="fc32",
+              channels=range(1),
+          ),
+      )
 
       if(options.subdev):
         self._u.set_subdev_spec(options.subdev, 0)
 
       if not self._u.set_center_freq(options.freq):
-        print "Failed to set initial frequency"
+        print("Failed to set initial frequency")
 
       #check for GPSDO
       #if you have a GPSDO, UHD will automatically set the timestamp to UTC time
@@ -171,35 +194,29 @@ class modes_radio (gr.top_block, pubsub):
         g = self._u.get_gain_range()
         options.gain = (g.start()+g.stop()) / 2.0
 
-      print "Setting gain to %i" % options.gain
+      print("Setting gain to %i" % options.gain)
       self._u.set_gain(options.gain)
-      print "Gain is %i" % self._u.get_gain()
+      print("Gain is %i" % self._u.get_gain())
 
+    #TODO: detect if you're using an RTLSDR or Jawbreaker
+    #and set up accordingly.
     elif options.source == "osmocom": #RTLSDR dongle or HackRF Jawbreaker
         import osmosdr
         self._u = osmosdr.source(options.args)
-        rates = self._u.get_sample_rates()
-
+#        self._u.set_sample_rate(3.2e6) #fixed for RTL dongles
         self._u.set_sample_rate(options.rate)
-        actual_rate = int(self._u.get_sample_rate())
-
         if not self._u.set_center_freq(options.freq):
-            print "Failed to set initial frequency"
+            print("Failed to set initial frequency")
 
 #        self._u.set_gain_mode(0) #manual gain mode
         if options.gain is None:
             options.gain = 34
         self._u.set_gain(options.gain)
-        print "Gain is %i" % self._u.get_gain()
+        print("Gain is %i" % self._u.get_gain())
 
-        if actual_rate < 4.0e6:
-            gcd = fractions.gcd(4.0e6, actual_rate)
-            interp = 4.0e6 / gcd
-            decim = actual_rate / gcd
-            lpfiltcoeffs = filter.firdes.low_pass(1, interp*actual_rate, 1.6e6, 300e3)
-            self._resample = filter.rational_resampler_ccf(interpolation=interp,
-                                                           decimation=decim,
-                                                           taps=lpfiltcoeffs)
+        #Note: this should only come into play if using an RTLSDR.
+#        lpfiltcoeffs = gr.firdes.low_pass(1, 5*3.2e6, 1.6e6, 300e3)
+#        self._resample = filter.rational_resampler_ccf(interpolation=5, decimation=4, taps=lpfiltcoeffs)
 
     else:
       #semantically detect whether it's ip.ip.ip.ip:port or filename
@@ -208,14 +225,16 @@ class modes_radio (gr.top_block, pubsub):
           ip, port = re.search("(.*)\:(\d{1,5})", options.source).groups()
         except:
           raise Exception("Please input UDP source e.g. 192.168.10.1:12345")
-        self._u = gr.udp_source(gr.sizeof_gr_complex, ip, int(port))
-        print "Using UDP source %s:%s" % (ip, port)
+        self._u = blocks.udp_source(gr.sizeof_gr_complex, ip, int(port))
+        print("Using UDP source %s:%s" % (ip, port))
       else:
         self._u = blocks.file_source(gr.sizeof_gr_complex, options.source)
-        print "Using file source %s" % options.source
+        print("Using file source %s" % options.source)
 
-    print "Rate is %i" % actual_rate
+    print("Rate is %i" % (options.rate,))
 
   def close(self):
+    self.stop()
+    self.wait()
     self._sender.close()
     self._u = None

python/raw_server.py

@@ -21,7 +21,6 @@
 
 
 import time, os, sys, socket
-from string import split, join
 from datetime import *
 
 class raw_server:
@@ -41,12 +40,12 @@ class raw_server:
         conn.send(msg)
       except socket.error:
         self._conns.remove(conn)
-        print "Connections: ", len(self._conns)
+        print("Connections: ", len(self._conns))
 
   def add_pending_conns(self):
     try:
       conn, addr = self._s.accept()
       self._conns.append(conn)
-      print "Connections: ", len(self._conns)
+      print("Connections: ", len(self._conns))
     except socket.error:
       pass

python/rx_path.py

@@ -20,7 +20,7 @@
 # 
 
 from gnuradio import gr, blocks, filter
-import air_modes_swig
+import air_modes
 
 class rx_path(gr.hier_block2):
 
@@ -37,7 +37,7 @@ class rx_path(gr.hier_block2):
         # Convert incoming I/Q baseband to amplitude
         self._demod = blocks.complex_to_mag_squared()
         if use_dcblock:
-            self._dcblock = filter.dc_blocker_cc(100*self._spc,True)
+            self._dcblock = filter.dc_blocker_cc(100*self._spc,False)
             self.connect(self, self._dcblock, self._demod)
         else:
             self.connect(self, self._demod)
@@ -54,10 +54,10 @@ class rx_path(gr.hier_block2):
         self._avg = blocks.moving_average_ff(48*self._spc, 1.0/(48*self._spc))#, self._rate) # 3 preambles
 
         # Synchronize to Mode-S preamble
-        self._sync = air_modes_swig.preamble(self._rate, self._threshold)
+        self._sync = air_modes.preamble(self._rate, self._threshold)
 
         # Slice Mode-S bits and send to message queue
-        self._slicer = air_modes_swig.slicer(self._queue)
+        self._slicer = air_modes.slicer(self._queue)
 
         # Wire up the flowgraph
         self.connect(self._bb, (self._sync, 0))
@@ -65,13 +65,13 @@ class rx_path(gr.hier_block2):
         self.connect(self._sync, self._slicer)
 
     def set_rate(self, rate):
-        self._sync.set_rate(rate)
+        self._sync.set_rate(int(rate))
         self._spc = int(rate/2e6)
         self._avg.set_length_and_scale(48*self._spc, 1.0/(48*self._spc))
         if self._bb != self._demod:
             self._pmf.set_length_and_scale(self._spc, 1.0/self._spc)
-        if self._dcblock is not None:
-            self._dcblock.set_length(100*self._spc)
+#        if self._dcblock is not None:
+#            self._dcblock.set_length(100*self._spc)
 
     def set_threshold(self, threshold):
         self._sync.set_threshold(threshold)
@@ -83,6 +83,6 @@ class rx_path(gr.hier_block2):
     def get_pmf(self, pmf):
         return not (self._bb == self._demod)
 
-    def get_threshold(self, threshold):
+    def get_threshold(self):
         return self._sync.get_threshold()
 

python/sbs1.py

@@ -21,9 +21,8 @@
 
 
 import time, os, sys, socket
-from string import split, join
 import air_modes
-from datetime import *
+import datetime
 from air_modes.exceptions import *
 import threading
 
@@ -63,7 +62,7 @@ class output_sbs1:
     #it could be cleaner if there were separate output_* fns
     #but this works
     for i in (0, 4, 5, 11, 17):
-        pub.subscribe("type%i_dl" % i, output)
+        pub.subscribe("type%i_dl" % i, self.output)
 
     #spawn thread to add new connections as they come in
     self._runner = dumb_task_runner(self.add_pending_conns, 0.1)
@@ -83,7 +82,7 @@ class output_sbs1:
     # dictionary is getting too large.
     if len(self._aircraft_id_map) > 1e4:
       minimum = min(self._aircraft_id_map.values()) + (len(self._aircraft_id_map) - 1e4)
-      for icao, _id in self._aircraft_id_map:
+      for icao, _id in dict(self._aircraft_id_map).iteritems():
         if _id < minimum:
             del self._aircraft_id_map[icao]
 
@@ -94,11 +93,12 @@ class output_sbs1:
     try:
       sbs1_msg = self.parse(msg)
       if sbs1_msg is not None:
+        sbs1_bytes = sbs1_msg.encode('utf-8')
         for conn in self._conns[:]: #iterate over a copy of the list
-          conn.send(sbs1_msg)
+          conn.send(sbs1_bytes)
     except socket.error:
       self._conns.remove(conn)
-      print "Connections: ", len(self._conns)
+      print("Connections: ", len(self._conns))
     except ADSBError:
       pass
 
@@ -106,12 +106,12 @@ class output_sbs1:
     try:
       conn, addr = self._s.accept()
       self._conns.append(conn)
-      print "Connections: ", len(self._conns)
+      print("Connections: ", len(self._conns))
     except socket.error:
       pass
 
   def current_time(self):
-    timenow = datetime.now()
+    timenow = datetime.datetime.now()
     return [timenow.strftime("%Y/%m/%d"), timenow.strftime("%H:%M:%S.%f")[0:-3]]
 
   def decode_fs(self, fs):
@@ -154,7 +154,7 @@ class output_sbs1:
     [datestr, timestr] = self.current_time()
     aircraft_id = self.get_aircraft_id(ecc)
     retstr = "MSG,7,0,%i,%06X,%i,%s,%s,%s,%s,,%s,,,,,,,,,," % (aircraft_id, ecc, aircraft_id+100, datestr, timestr, datestr, timestr, air_modes.decode_alt(shortdata["ac"], True))
-    if vs:
+    if shortdata["vs"]:
       retstr += "1\r\n"
     else:
       retstr += "0\r\n"
@@ -174,7 +174,7 @@ class output_sbs1:
 
   def pp11(self, shortdata, ecc):
     [datestr, timestr] = self.current_time()
-    aircraft_id = self.get_aircraft_id(icao24)
+    aircraft_id = self.get_aircraft_id(shortdata["aa"])
     return "MSG,8,0,%i,%06X,%i,%s,%s,%s,%s,,,,,,,,,,,,\r\n" % (aircraft_id, shortdata["aa"], aircraft_id+100, datestr, timestr, datestr, timestr)
 
   def pp17(self, data):