modtool_add.py

modtool_base.py

modtool_disable.py

modtool_info.py

modtool_makexml.py

modtool_newmod.py

templates.py

util_functions.py

DESTINATION ${GR_PYTHON_DIR}/gnuradio/modtool

)

set(GR_PKG_MODTOOL_DATA_DIR ${GR_PKG_DATA_DIR}/modtool)

install(DIRECTORY gr-newmod

DESTINATION ${GR_PKG_MODTOOL_DATA_DIR}

)

install(

FILES ${CMAKE_CURRENT_BINARY_DIR}/modtool.conf

DESTINATION ${GR_PREFSDIR}

)

#

#

# This file is part of GNU Radio

#

# Boston, MA 02110-1301, USA.

#

# Leave this at the end

#

""" Edit CMakeLists.txt files """

import re

class CMakeFileEditor(object):

comment_out_re = r'\n' + self.indent + comment_out_re

(self.cfile, nsubs) = re.subn(r'(\b'+fname+r'\b)\s*', comment_out_re, self.cfile)

if nsubs == 0:

elif nsubs > 1:

def comment_out_lines(self, pattern, comment_str='#'):

""" Comments out all lines that match with pattern """

#

#

# This file is part of GNU Radio

#

# Boston, MA 02110-1301, USA.

#

""" A code generator (needed by ModToolAdd) """

# Also handle gnuradio custom naming conventions w/ extras mode.

########################################################################

function(GR_LIBRARY_FOO target)

#set additional target properties

set_target_properties(${target} PROPERTIES SOVERSION ${LIBVER})

#install the generated files like so...

install(TARGETS ${target}

)

#extras mode enabled automatically on linux

FILES

${CMAKE_CURRENT_BINARY_DIR}/lib${target}.so

${CMAKE_CURRENT_BINARY_DIR}/lib${target}-${LIBVER}.so.0

)

endif(LIBRARY_EXTRAS)

endfunction(GR_GEN_TARGET_DEPS)

########################################################################

# Run GRCC to compile .grc files into .py files.

#

# Usage: GRCC(filename, directory)

)

GR_ADD_COND_DEF(HAVE_SCHED_SETSCHEDULER)

endmacro(GR_CHECK_LINUX_SCHED_AVAIL)

else(PYTHON_EXECUTABLE)

#use the built-in find script

find_package(PythonInterp 2)

#and if that fails use the find program routine

if(NOT PYTHONINTERP_FOUND)

if(PYTHON_EXECUTABLE)

set(PYTHONINTERP_FOUND TRUE)

endif(PYTHON_EXECUTABLE)

try:

import ${mod}

assert ${cmd}

except: pass

#########################################"

RESULT_VARIABLE ${have}

if(NOT DEFINED GR_PYTHON_DIR)

execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "

from distutils import sysconfig

" OUTPUT_VARIABLE GR_PYTHON_DIR OUTPUT_STRIP_TRAILING_WHITESPACE

)

endif()

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

print(re.sub('\\W', '_', '${desc} ${reldir} ' + unique))"

OUTPUT_VARIABLE _target OUTPUT_STRIP_TRAILING_WHITESPACE)

add_custom_target(${_target} ALL DEPENDS ${ARGN})

########################################################################

function(GR_PYTHON_INSTALL)

include(CMakeParseArgumentsCopy)

####################################################################

if(GR_PYTHON_INSTALL_FILES)

set(python_install_gen_targets ${pycfiles} ${pyofiles})

install(FILES ${python_install_gen_targets}

DESTINATION ${GR_PYTHON_INSTALL_DESTINATION}

)

####################################################################

install(PROGRAMS ${pyexefile} RENAME ${pyfile_name}

DESTINATION ${GR_PYTHON_INSTALL_DESTINATION}

)

endforeach(pyfile)

file(WRITE ${CMAKE_BINARY_DIR}/python_compile_helper.py "

import sys, py_compile

files = sys.argv[1:]

for src, gen in zip(srcs, gens):

py_compile.compile(file=src, cfile=gen, doraise=True)

")

add_custom_command(

OUTPUT ${output_file}

DEPENDS ${input_files} ${stamp-file} ${OUTPUT_DIRECTORY}/xml/index.xml

${CMAKE_SOURCE_DIR}/docs/doxygen/swig_doc.py

${OUTPUT_DIRECTORY}/xml

${output_file}

# GR_SWIG_INSTALL(

# TARGETS target target target...

# [DESTINATION destination]

# )

########################################################################

macro(GR_SWIG_INSTALL)

include(CMakeParseArgumentsCopy)

foreach(name ${GR_SWIG_INSTALL_TARGETS})

install(TARGETS ${SWIG_MODULE_${name}_REAL_NAME}

DESTINATION ${GR_SWIG_INSTALL_DESTINATION}

)

include(GrPython)

GR_PYTHON_INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/${name}.py

DESTINATION ${GR_SWIG_INSTALL_DESTINATION}

)

GR_LIBTOOL(

u'Outputs the vital aadvark statistics.'

"""

def _test():

import os

Classes based upon this are used to make more user-friendly interfaces

to the doxygen xml docs than the generated classes provide.

"""

import os

import pdb

from xml.parsers.expat import ExpatError

class Base(object):

pass

pass

pass

def __init__(self, parse_data, top=None):

for cls in self.mem_classes:

if cls.can_parse(mem):

return cls

% (mem.get_name())))

def convert_mem(self, mem):

cls = self.get_cls(mem)

converted = cls.from_parse_data(mem, self.top)

if converted is None:

self.add_ref(converted)

return converted

@classmethod

def includes(cls, inst):

Classes providing more user-friendly interfaces to the doxygen xml

docs than the generated classes provide.

"""

import os

class DoxyIndex(Base):

"""

resultant classes are not very friendly to navigate so the rest of the

doxyxml module processes them further.

"""

"""

Generated Mon Feb 9 19:08:05 2009 by generateDS.py.

"""

from xml.dom import minidom

from xml.dom import Node

import sys

class DoxygenTypeSub(supermod.DoxygenType):

# Generated Thu Jun 11 18:44:25 2009 by generateDS.py.

#

import sys

from xml.dom import minidom

from xml.dom import Node

#

# User methods

#

try:

from generatedssuper import GeneratedsSuper

def format_string(self, input_data, input_name=''):

return input_data

def format_integer(self, input_data, input_name=''):

outfile.write(' ')

def quote_xml(inStr):

'%s' % inStr)

s1 = s1.replace('&', '&')

s1 = s1.replace('<', '&lt;')

return s1

def quote_attrib(inStr):

'%s' % inStr)

s1 = s1.replace('&', '&amp;')

s1 = s1.replace('<', '&lt;')

return '"""%s"""' % s1

# Constants for category:

CategoryNone = 0

CategoryText = 1

if attrs.get('lineno'):

try:

self.lineno = int(attrs.get('lineno').value)

raise ValueError('Bad integer attribute (lineno): %s' % exp)

if attrs.get('refkind'):

self.refkind = attrs.get('refkind').value

if attrs.get('endline'):

try:

self.endline = int(attrs.get('endline').value)

raise ValueError('Bad integer attribute (endline): %s' % exp)

if attrs.get('startline'):

try:

self.startline = int(attrs.get('startline').value)

raise ValueError('Bad integer attribute (startline): %s' % exp)

if attrs.get('refid'):

self.refid = attrs.get('refid').value

if attrs.get('bodystart'):

try:

self.bodystart = int(attrs.get('bodystart').value)

raise ValueError('Bad integer attribute (bodystart): %s' % exp)

if attrs.get('line'):

try:

self.line = int(attrs.get('line').value)

raise ValueError('Bad integer attribute (line): %s' % exp)

if attrs.get('bodyend'):

try:

self.bodyend = int(attrs.get('bodyend').value)

raise ValueError('Bad integer attribute (bodyend): %s' % exp)

if attrs.get('bodyfile'):

self.bodyfile = attrs.get('bodyfile').value

if attrs.get('rows'):

try:

self.rows = int(attrs.get('rows').value)

raise ValueError('Bad integer attribute (rows): %s' % exp)

if attrs.get('cols'):

try:

self.cols = int(attrs.get('cols').value)

raise ValueError('Bad integer attribute (cols): %s' % exp)

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.ELEMENT_NODE and \

if attrs.get('level'):

try:

self.level = int(attrs.get('level').value)

raise ValueError('Bad integer attribute (level): %s' % exp)

def buildChildren(self, child_, nodeName_):

if child_.nodeType == Node.TEXT_NODE:

"""

def usage():

sys.exit(1)

main()

#import pdb

#pdb.run('main()')

"""

Generated Mon Feb 9 19:08:05 2009 by generateDS.py.

"""

from xml.dom import minidom

import os

import sys

class DoxygenTypeSub(supermod.DoxygenType):

def __init__(self, version=None, compound=None):

# Generated Thu Jun 11 18:43:54 2009 by generateDS.py.

#

import sys

from xml.dom import minidom

from xml.dom import Node

#

# User methods

#

try:

from generatedssuper import GeneratedsSuper

def format_string(self, input_data, input_name=''):

return input_data

def format_integer(self, input_data, input_name=''):

outfile.write(' ')

def quote_xml(inStr):

'%s' % inStr)

s1 = s1.replace('&', '&amp;')

s1 = s1.replace('<', '&lt;')

return s1

def quote_attrib(inStr):

'%s' % inStr)

s1 = s1.replace('&', '&amp;')

s1 = s1.replace('<', '&lt;')

return '"""%s"""' % s1

# Constants for category:

CategoryNone = 0

CategoryText = 1

"""

def usage():

sys.exit(1)

main()

#import pdb

#pdb.run('main()')

"""

Utilities for extracting text from generated classes.

"""

def is_string(txt):

if isinstance(txt, str):

return True

try:

return True

except NameError:

pass

elif is_string(obj):

return obj

else:

# If this bit is a paragraph then add one some line breaks.

if hasattr(obj, 'name') and obj.name == 'para':

result += "\n\n"

python docstrings.

"""

import sys, time

# Parse command line options and set up doxyxml.

err_msg = "Execute using: python swig_doc.py xml_path outputfilename"

if len(sys.argv) != 3:

xml_path = sys.argv[1]

swigdocfilename = sys.argv[2]

di = DoxyIndex(xml_path)

# Install built library files

########################################################################

include(GrMiscUtils)

########################################################################

# Build and register unit test

########################################################################

message(STATUS "Using install prefix: ${CMAKE_INSTALL_PREFIX}")

message(STATUS "Building for version: ${VERSION} / ${LIBVER}")

This is the GNU Radio HOWTO module. Place your Python package

description here (python/__init__.py).

'''

# import swig generated symbols into the howto namespace

try:

#

# Copyright 2013 Free Software Foundation, Inc.

#

# Boston, MA 02110-1301, USA.

#

import xml.etree.ElementTree as ET

try:

import lxml.etree

#

""" Module to add new blocks """

import os

import re

class ModToolAdd(ModTool):

""" Add block to the out-of-tree module. """

name = 'add'

_block_types = ('sink', 'source', 'sync', 'decimator', 'interpolator',

'general', 'tagged_stream', 'hier', 'noblock')

self._skip_cmakefiles = False

self._license_file = None

return parser

if self._info['blockname'] is None:

if len(args) >= 2:

self._info['blocktype'] = options.block_type

if self._info['blocktype'] is None:

# Print list out of blocktypes to user for reference

with SequenceCompleter(sorted(self._block_types)):

while self._info['blocktype'] not in self._block_types:

if self._info['blocktype'] not in self._block_types:

# Allow user to specify language interactively if not set

self._info['lang'] = options.lang

if self._info['lang'] is None:

with SequenceCompleter(language_candidates):

while self._info['lang'] not in language_candidates:

if self._info['lang'] == 'c++':

self._info['lang'] = 'cpp'

if ((self._skip_subdirs['lib'] and self._info['lang'] == 'cpp')

or (self._skip_subdirs['python'] and self._info['lang'] == 'python')):

raise ModToolException('Missing or skipping relevant subdir.')

if not options.license_file:

self._info['copyrightholder'] = options.copyright

if self._info['copyrightholder'] is None:

if not self._info['copyrightholder'] or self._info['copyrightholder'].isspace():

self._info['copyrightholder'] = "gr-"+self._info['modname']+" author"

elif self._info['is_component']:

self._license_file = options.license_file

self._info['license'] = self.setup_choose_license()

if options.argument_list is not None:

self._info['arglist'] = options.argument_list

else:

if not (self._info['blocktype'] in ('noblock') or self._skip_subdirs['python']):

self._add_py_qa = options.add_python_qa

self._add_cc_qa = ask_yes_no('Add C++ QA code?', not self._add_py_qa)

self._skip_cmakefiles = options.skip_cmakefiles

if self._info['version'] == 'autofoo' and not self._skip_cmakefiles:

self._skip_cmakefiles = True

def setup_choose_license(self):

return open('LICENCE').read()

elif self._info['is_component']:

return Templates['grlicense']

def _write_tpl(self, tpl, path, fname):

""" Shorthand for writing a substituted template to a file"""

path_to_file = os.path.join(path, fname)

self.scm.add_files((path_to_file,))

""" Go, go, go. """

has_swig = (

self._info['lang'] == 'cpp'

and not self._skip_subdirs['swig']

)

self.scm.mark_files_updated((self._file['qalib'],))

except IOError:

fname_cc = None

fname_h = None

if self._info['version'] == '37':

if self._info['version'] == '37':

_add_qa()

elif self._info['version'] == '36':

elif self._info['version'] == 'autofoo':

if not self._skip_cmakefiles:

ed = CMakeFileEditor(self._file['cmlib'])

cmake_list_var = '[a-z]*_?' + self._info['modname'] + '_sources'

- Edit main *.i file

"""

if self._get_mainswigfile() is None:

return

mod_block_sep = '/'

if self._info['version'] == '36':

mod_block_sep = '_'

open(self._file['swig'], 'a').write(swig_block_magic_str)

include_str = '#include "%s%s%s.h"' % (

{True: 'gnuradio/' + self._info['modname'],

"""

fname_py_qa = 'qa_' + self._info['blockname'] + '.py'

self._write_tpl('qa_python', self._info['pydir'], fname_py_qa)

self.scm.mark_files_updated((os.path.join(self._info['pydir'], fname_py_qa),))

if self._skip_cmakefiles or CMakeFileEditor(self._file['cmpython']).check_for_glob('qa_*.py'):

return

open(self._file['cmpython'], 'a').write(

'GR_ADD_TEST(qa_%s ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/%s)\n' % \

(self._info['blockname'], fname_py_qa))

ed = CMakeFileEditor(self._file['cmgrc'], '\n ')

if self._skip_cmakefiles or ed.check_for_glob('*.xml'):

return

ed.append_value('install', fname_grc, to_ignore_end='DESTINATION[^()]+')

ed.write()

self.scm.mark_files_updated((self._file['cmgrc'],))

#

""" Base class for the modules """

import os

import re

from gnuradio import gr

class ModToolException(BaseException):

""" Standard exception for modtool classes. """

class ModTool(object):

""" Base class for all modtool command classes. """

name = 'base'

def __init__(self):

self._subdirs = ['lib', 'include', 'python', 'swig', 'grc'] # List subdirs where stuff happens

self._has_subdirs = {}

for subdir in self._subdirs:

self._has_subdirs[subdir] = False

self._skip_subdirs[subdir] = False

self._dir = None

self.scm = None

return parser

""" Initialise all internal variables, such as the module name etc. """

self._dir = options.directory

if not self._check_directory(self._dir):

raise ModToolException('No GNU Radio module found in the given directory.')

self._info['modname'] = options.module_name

else:

self._info['modname'] = get_modname()

if self._info['modname'] is None:

raise ModToolException('No GNU Radio module found in the given directory.')

if self._info['version'] == '36' and (

os.path.isdir(os.path.join('include', self._info['modname'])) or

os.path.isdir(os.path.join('include', 'gnuradio', self._info['modname']))

self._skip_subdirs['swig'] = True

if options.skip_grc or not self._has_subdirs['grc']:

self._skip_subdirs['grc'] = True

self._setup_files()

self._info['yes'] = options.yes

self.options = options

else:

self.scm = SCMRepoFactory(self.options, '.').make_empty_scm_manager()

if self.scm is None:

exit(1)

def _check_directory(self, directory):

files = os.listdir(directory)

os.chdir(directory)

except OSError:

return False

self._info['is_component'] = False

for f in files:

has_makefile = True

# TODO search for autofoo

elif os.path.isdir(f):

self._has_subdirs[f] = True

else:

self._skip_subdirs[f] = True

def _get_mainswigfile(self):

""" Find out which name the main SWIG file has. In particular, is it

return fname

return None

""" Override this. """

try:

except (TypeError, AttributeError):

pass

#

""" Disable blocks module """

import os

import re

import sys

class ModToolDisable(ModTool):

""" Disable block (comments out CMake entries for files) """

name = 'disable'

def __init__(self):

ModTool.__init__(self)

else:

self._info['pattern'] = '.'

""" Go, go, go! """

def _handle_py_qa(cmake, fname):

""" Do stuff for py qa """

try:

initfile = open(self._file['pyinit']).read()

except IOError:

return False

pymodname = os.path.splitext(fname)[0]

initfile = re.sub(r'((from|import)\s+\b'+pymodname+r'\b)', r'#\1', initfile)

(swigfile, nsubs) = re.subn(r'(.include\s+"(%s/)?%s")' % (

self._info['modname'], fname), r'//\1', swigfile)

if nsubs > 0:

if nsubs > 1: # Need to find a single BLOCK_MAGIC

blockname = os.path.splitext(fname[len(self._info['modname'])+1:])[0]

if self._info['version'] == '37':

blockname = os.path.splitext(fname)[0]

(swigfile, nsubs) = re.subn('(GR_SWIG_BLOCK_MAGIC2?.+%s.+;)' % blockname, r'//\1', swigfile)

if nsubs > 1:

open(self._file['swig'], 'w').write(swigfile)

self.scm.mark_file_updated(self._file['swig'])

return False

blockname = os.path.splitext(fname[len(self._info['modname'])+1:])[0]

if self._info['version'] == '37':

blockname = os.path.splitext(fname)[0]

swigfile = re.sub('(GR_SWIG_BLOCK_MAGIC2?.+'+blockname+'.+;)', r'//\1', swigfile)

open(self._file['swig'], 'w').write(swigfile)

self.scm.mark_file_updated(self._file['swig'])

return False

# List of special rules: 0: subdir, 1: filename re match, 2: callback

special_treatments = (

('python', r'qa.+py$', _handle_py_qa),

cmake = CMakeFileEditor(os.path.join(subdir, 'CMakeLists.txt'))

except IOError:

continue

filenames = cmake.find_filenames_match(self._info['pattern'])

yes = self._info['yes']

for fname in filenames:

file_disabled = False

if not yes:

if ans == 'a':

yes = True

if ans == 'q':

cmake.disable_file(fname)

cmake.write()

self.scm.mark_files_updated((os.path.join(subdir, 'CMakeLists.txt'),))

# Copyright 2013 Free Software Foundation, Inc.

#

# This file is part of GNU Radio

#

""" Returns information about a module """

import os

class ModToolInfo(ModTool):

""" Return information about a given module """

name = 'info'

def __init__(self):

ModTool.__init__(self)

self._python_readable = False

self._suggested_dirs = None

""" Initialise the option parser for 'gr_modtool info' """

return parser

# Won't call parent's setup(), because that's too chatty

self._directory = options.directory

self._python_readable = options.python_readable

self._suggested_dirs = options.suggested_dirs

""" Go, go, go! """

mod_info = dict()

mod_info['base_dir'] = self._get_base_dir(self._directory)

if mod_info['base_dir'] is None:

):

self._info['version'] = '37'

mod_info['version'] = self._info['version']

mod_info['is_component'] = True

mod_info['incdirs'] = []

mod_incl_dir = os.path.join(mod_info['base_dir'], 'include')

mod_info['build_dir'] = build_dir

mod_info['incdirs'] += self._get_include_dirs(mod_info)

if self._python_readable:

else:

self._pretty_print(mod_info)

If that hasn't happened, the build dir cannot be detected, unless it's

called 'build', which is then assumed to be the build dir. """

base_build_dir = mod_info['base_dir']

(base_build_dir, rest_dir) = os.path.split(base_build_dir)

has_build_dir = os.path.isdir(os.path.join(base_build_dir, 'build'))

if (has_build_dir and os.path.isfile(os.path.join(base_build_dir, 'CMakeCache.txt'))):

""" Figure out include dirs for the make process. """

inc_dirs = []

path_or_internal = {True: 'INTERNAL',

try:

cmakecache_fid = open(os.path.join(mod_info['build_dir'], 'CMakeCache.txt'))

for line in cmakecache_fid:

inc_dirs = [os.path.normpath(path) for path in self._suggested_dirs.split(':') if os.path.isdir(path)]

return inc_dirs

""" Output the module info in human-readable format """

index_names = {'base_dir': 'Base directory',

'modname': 'Module name',

'is_component': 'Is GR component',

'build_dir': 'Build directory',

'incdirs': 'Include directories'}

if key == 'version':

else:

#

""" Automatically create XML bindings for GRC from block code """

import os

import re

import glob

class ModToolMakeXML(ModTool):

""" Make XML file for GRC block bindings """

name = 'makexml'

def __init__(self):

ModTool.__init__(self)

""" Initialise the option parser for 'gr_modtool makexml' """

Note: This does not work on Python blocks!

else:

self._info['pattern'] = '.'

""" Go, go, go! """

# 1) Go through lib/

if not self._skip_subdirs['lib']:

if self._info['version'] == '37':

""" Search for files matching pattern in the given path. """

files = sorted(glob.glob("%s/%s"% (path, path_glob)))

files_filt = []

for f in files:

if re.search(self._info['pattern'], os.path.basename(f)) is not None:

files_filt.append(f)

return files_filt

def _make_grc_xml_from_block_data(self, params, iosig, blockname):

return

else:

file_exists = True

grc_generator = GRCXMLGenerator(

modname=self._info['modname'],

blockname=blockname,

if not self._skip_subdirs['grc']:

ed = CMakeFileEditor(self._file['cmgrc'])

if re.search(fname_xml, ed.cfile) is None and not ed.check_for_glob('*.xml'):

ed.append_value('install', fname_xml, to_ignore_end='DESTINATION[^()]+')

ed.write()

self.scm.mark_files_updated(self._file['cmgrc'])

blockname = blockname.replace(self._info['modname']+'_', '', 1)

return (blockname, fname_h)

# Go, go, go

(blockname, fname_h) = _get_blockdata(fname_cc)

try:

parser = ParserCCBlock(fname_cc,

#

""" Create a whole new out-of-tree module """

import shutil

import os

import re

from gnuradio import gr

class ModToolNewModule(ModTool):

""" Create a new out-of-tree module """

name = 'newmod'

def __init__(self):

ModTool.__init__(self)

" Initialise the option parser for 'gr_modtool newmod' "

# Don't call ModTool.setup(), that assumes an existing module.

self._info['modname'] = options.module_name

if self._info['modname'] is None:

else:

if not re.match('[a-zA-Z0-9_]+$', self._info['modname']):

raise ModToolException('Invalid module name.')

self._dir = options.directory

self.options = options

self._setup_scm(mode='new')

"""

* Copy the example dir recursively

* Open all files, rename howto and HOWTO to the module name

* Rename files and directories that contain the word howto

"""

try:

shutil.copytree(self._srcdir, self._dir)

os.chdir(self._dir)

os.rename(f, os.path.join(root, filename.replace('howto', self._info['modname'])))

if os.path.basename(root) == 'howto':

os.rename(root, os.path.join(os.path.dirname(root), self._info['modname']))

if self.scm.init_repo(path_to_repo="."):

#

""" Module to rename blocks """

import os

import re

class ModToolRename(ModTool):

""" Rename a block in the out-of-tree module. """

name = 'rename'

def __init__(self):

ModTool.__init__(self)

self._skip_cmakefiles = False

self._license_file = None

return parser

if ((self._skip_subdirs['lib'] and self._info['lang'] == 'cpp')

or (self._skip_subdirs['python'] and self._info['lang'] == 'python')):

raise ModToolException('Missing or skipping relevant subdir.')

# first make sure the old block name is provided

if self._info['oldname'] is None:

if not re.match('[a-zA-Z0-9_]+', self._info['oldname']):

raise ModToolException('Invalid block name.')

self._info['fulloldname'] = self._info['modname'] + '_' + self._info['oldname']

# now get the new block name

if not re.match('[a-zA-Z0-9_]+', self._info['newname']):

raise ModToolException('Invalid block name.')

self._info['fullnewname'] = self._info['modname'] + '_' + self._info['newname']

""" Go, go, go. """

module = self._info['modname']

oldname = self._info['oldname']

newname = self._info['newname']

self._run_swig_rename(self._file['swig'], oldname, newname)

self._run_grc_rename(self._info['modname'], oldname, newname)

self._run_python_qa(self._info['modname'], oldname, newname)

""" Rename SWIG includes and block_magic """

nsubs = self._run_file_replace(swigfilename, old, new)

if nsubs < 1:

if nsubs == 2:

if nsubs > 3:

return False

def _run_lib(self, module, old, new):

filename = 'qa_' + module + '.cc'

nsubs = self._run_file_replace(path + filename, old, new)

if nsubs > 0:

filename = 'qa_' + old + '.cc'

self._run_file_replace(path + filename, old, new)

filename = 'qa_' + old + '.h'

self._run_file_replace(path + filename, old.upper(), new.upper())

self._run_file_rename(path, 'qa_' + old, 'qa_' + new)

else:

def _run_include(self, module, old, new):

path = './include/' + module + '/'

filename = '__init__.py'

nsubs = self._run_file_replace(path + filename, old, new)

if nsubs > 0:

filename = old + '.py'

self._run_file_replace(path + filename, old, new)

self._run_cmakelists(path, old, new)

self._run_file_rename(path, old, new)

else:

def _run_python_qa(self, module, old, new):

new = 'qa_' + new

filename = path + 'CMakeLists.txt'

nsubs = self._run_file_replace(filename, first, second)

if nsubs < 1:

def _run_file_rename(self, path, old, new):

files = os.listdir(path)

nl = file.replace(old, new)

src = path + file

dst = path + nl

os.rename(src, dst)

def _run_file_replace(self, filename, old, new):

if not os.path.isfile(filename):

return False

else:

cfile = open(filename).read()

(cfile, nsubs) = re.subn(old, new, cfile)

#

""" Remove blocks module """

import os

import re

import sys

import glob

class ModToolRemove(ModTool):

""" Remove block (delete files and remove Makefile entries) """

name = 'remove'

def __init__(self):

ModTool.__init__(self)

else:

block_candidates = self.get_block_candidates()

with SequenceCompleter(block_candidates):

if not self._info['pattern'] or self._info['pattern'].isspace():

self._info['pattern'] = '.'

""" Go, go, go! """

def _remove_cc_test_case(filename=None, ed=None):

""" Special function that removes the occurrences of a qa*.cc file

(self._info['modname'], pyblockname, self._info['modname'], filename)

return regexp

# Go, go, go!

if not self._skip_subdirs['lib']:

self._run_subdir('lib', ('*.cc', '*.h'), ('add_library', 'list'),

cmakeedit_func=_remove_cc_test_case)

for g in globs:

files = files + sorted(glob.glob("%s/%s"% (path, g)))

files_filt = []

for f in files:

if re.search(self._info['pattern'], os.path.basename(f)) is not None:

files_filt.append(f)

return []

# 2. Delete files, Makefile entries and other occurrences

files_deleted = []

for f in files_filt:

b = os.path.basename(f)

if not yes:

if ans == 'a':

yes = True

if ans == 'q':

if ans == 'n':

continue

files_deleted.append(b)

self.scm.remove_file(f)

os.unlink(f)

for var in makefile_vars:

ed.remove_value(var, b)

if cmakeedit_func is not None:

# Boston, MA 02110-1301, USA.

#

''' A parser for blocks written in C++ '''

import re

import sys

E.g., for sizeof(int), it will return 'int'.

Returns a list! """

if 'gr::io_signature::makev' in iosigcall:

raise ValueError

return {'type': [_typestr_to_iotype(x) for x in typestr.split(',')],

'vlen': [_typestr_to_vlen(x) for x in typestr.split(',')]

iosig_match.group('intype'))

iosig['in']['min_ports'] = iosig_match.group('inmin')

iosig['in']['max_ports'] = iosig_match.group('inmax')

try:

iosig['out'] = _figure_out_iotype_and_vlen(iosig_match.group('outcall'),

iosig_match.group('outtype'))

iosig['out']['min_ports'] = iosig_match.group('outmin')

iosig['out']['max_ports'] = iosig_match.group('outmax')

return iosig

try:

params_list = _scan_param_list(make_match.end(0))

except ValueError as ve:

sys.exit(0)

params = []

for plist in params_list:

#

""" Class to handle source code management repositories. """

import subprocess

try:

""" Returns a valid, usable object of type SCMRepository. """

if self.options.scm_mode == 'no':

return SCMRepository(self.path_to_repo)

try:

if issubclass(glbl, SCMRepository):

the_scm = glbl(self.path_to_repo)

if the_scm.is_active():

return the_scm

except (TypeError, AttributeError, InvalidSCMError):

pass

""" Returns a valid, usable object of type SCMRepository for an uninitialized dir. """

if self.options.scm_mode == 'no':

return SCMRepository(self.path_to_repo)

try:

if issubclass(glbl, SCMRepository):

if glbl.handles_scm_type == scm_type:

#

#

# This file is part of GNU Radio

#

# Boston, MA 02110-1301, USA.

#

''' All the templates for skeleton files (needed by ModToolAdd) '''

from datetime import datetime

''' % datetime.now().year

Templates['grlicense'] = '''

This file is part of GNU Radio

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.

# Header file of a sync/decimator/interpolator block

Templates['block_impl_h'] = '''/* -*- c++ -*- */

namespace gr {

namespace ${modname} {

private:

// Nothing to declare in this block.

protected:

int calculate_output_stream_length(const gr_vector_int &ninput_items);

public:

~${blockname}_impl();

// Where all the action really happens

void forecast (int noutput_items, gr_vector_int &ninput_items_required);

int general_work(int noutput_items,

gr_vector_int &ninput_items,

gr_vector_const_void_star &input_items,

gr_vector_void_star &output_items);

};

} // namespace ${modname}

} // namespace gr

'''

# C++ file of a GR block

Templates['block_impl_cpp'] = '''/* -*- c++ -*- */

namespace gr {

namespace ${modname} {

{

}

{

}

${blockname}::sptr

{

return gnuradio::get_initial_sptr

}

/*

* The private constructor

*/

: gr::${grblocktype}("${blockname}",

{

connect(self(), 0, d_firstblock, 0);

// connect other blocks

connect(d_lastblock, 0, self(), 0);

}

{}

/*

* Our virtual destructor.

{

}

void

${blockname}_impl::forecast (int noutput_items, gr_vector_int &ninput_items_required)

{

// Tell runtime system how many output items we produced.

return noutput_items;

}

int

${blockname}_impl::calculate_output_stream_length(const gr_vector_int &ninput_items)

{

// Tell runtime system how many output items we produced.

return noutput_items;

}

int

${blockname}_impl::work(int noutput_items,

gr_vector_const_void_star &input_items,

gr_vector_void_star &output_items)

{

const <+ITYPE+> *in = (const <+ITYPE+> *) input_items[0];

<+OTYPE+> *out = (<+OTYPE+> *) output_items[0];

// Do <+signal processing+>

// Tell runtime system how many output items we produced.

return noutput_items;

}

} /* namespace ${modname} */

} /* namespace gr */

# Block definition header file (for include/)

Templates['block_def_h'] = '''/* -*- c++ -*- */

namespace gr {

namespace ${modname} {

/*!

* \\brief <+description+>

*

*/

{

public:

${blockname}(${arglist});

~${blockname}();

private:

};

/*!

* \\brief <+description of block+>

* \ingroup ${modname}

*

*/

{

public:

typedef boost::shared_ptr<${blockname}> sptr;

* class. ${modname}::${blockname}::make is the public interface for

* creating new instances.

*/

};

} // namespace ${modname}

} // namespace gr

'''

# Python block

# -*- coding: utf-8 -*-

class ${blockname}(${parenttype}):

"""

docstring for block ${blockname}

"""

${parenttype}.__init__(self,

gr.io_signature(${inputsig}), # Input signature

gr.io_signature(${outputsig})) # Output signature

# Define blocks and connect them

self.connect()

name="${blockname}",

in_sig=${inputsig},

out_sig=${outputsig}${deciminterp})

def forecast(self, noutput_items, ninput_items_required):

#setup size of input_items[i] for work call

for i in range(len(ninput_items_required)):

consume(0, len(input_items[0]))

\#self.consume_each(len(input_items[0]))

return len(output_items[0])

def work(self, input_items, output_items):

in0 = input_items[0]

out = output_items[0]

# <+signal processing here+>

out[:] = in0

return len(output_items[0])

return len(input_items[0])

out[:] = whatever

return len(output_items[0])

'''

# C++ file for QA

Templates['qa_cpp'] = '''/* -*- c++ -*- */

namespace gr {

namespace ${modname} {

# Header file for QA

Templates['qa_h'] = '''/* -*- c++ -*- */

namespace gr {

namespace ${modname} {

} /* namespace ${modname} */

} /* namespace gr */

'''

# Python QA code

# -*- coding: utf-8 -*-

#

from gnuradio import gr, gr_unittest

from gnuradio import blocks

import ${modname}.${modname}_swig as ${modname}

from ${blockname} import ${blockname}

class qa_${blockname}(gr_unittest.TestCase):

Templates['grc_xml'] = '''<?xml version="1.0"?>

<block>

<!-- Make one 'param' node for every Parameter you want settable from the GUI.

Sub-nodes:

* name

</block>

'''

# SWIG string

"""

## Old stuff

# C++ file of a GR block

Templates['block_cpp36'] = '''/* -*- c++ -*- */

{

}

${modname}_${blockname}::~${modname}_${blockname}()

{

}

${modname}_${blockname}_sptr

{

}

/*

* The private constructor

*/

: gr_${grblocktype} ("${blockname}",

{

connect(self(), 0, d_firstblock, 0);

// <+connect other blocks+>

connect(d_lastblock, 0, self(), 0);

// Put in <+constructor stuff+> here

}

{

// Put in <+destructor stuff+> here

}

void

${modname}_${blockname}::forecast (int noutput_items, gr_vector_int &ninput_items_required)

{

// Tell runtime system how many output items we produced.

return noutput_items;

}

int

${modname}_${blockname}::work(int noutput_items,

gr_vector_const_void_star &input_items,

// Tell runtime system how many output items we produced.

return noutput_items;

}

'''

# Block definition header file (for include/)

Templates['block_h36'] = '''/* -*- c++ -*- */

{

${blockname}(${arglist});

~${blockname}();

private:

};

class ${modname}_${blockname};

typedef boost::shared_ptr<${modname}_${blockname}> ${modname}_${blockname}_sptr;

/*!

* \\brief <+description+>

* \ingroup ${modname}

*

*/

{

private:

public:

~${modname}_${blockname}();

void forecast (int noutput_items, gr_vector_int &ninput_items_required);

// Where all the action really happens

gr_vector_int &ninput_items,

gr_vector_const_void_star &input_items,

gr_vector_void_star &output_items);

// Where all the action really happens

int work (int noutput_items,

gr_vector_const_void_star &input_items,

gr_vector_void_star &output_items);

};

'''

#

""" Utility functions for gr_modtool """

import re

import sys

import readline

# None of these must depend on other modtool stuff!

def append_re_line_sequence(filename, linepattern, newline):

""" Detects the re 'linepattern' in the file. After its last occurrence,

paste 'newline'. If the pattern does not exist, append the new line

string = strip_default_values(string)

return ", ".join(

[part.strip().split(' ')[-1] for part in string.split(',')]

def strip_arg_types_grc(string):

"""" Strip the argument types from a list of arguments for GRC make tag.

regexp = r'(project\s*\(\s*|GR_REGISTER_COMPONENT\(")gr-(?P<modname>[a-zA-Z0-9-_]+)(\s*(CXX)?|" ENABLE)'

try:

modname = re.search(regexp, cmfile, flags=re.MULTILINE).group('modname').strip()

modname = modname_trans[modname]

return modname

except AttributeError:

""" Asks a binary question. Returns True for yes, False for no.

default is given as a boolean. """

question += {True: ' [Y/n] ', False: ' [y/N] '}[default]

return default

else:

return not default

pyqt_plot.py

pyqt_filter.py

DESTINATION ${GR_PYTHON_DIR}/gnuradio

)

GR_PYTHON_INSTALL(

gr_plot_short

gr_plot_qt

gr_read_file_metadata

DESTINATION ${GR_RUNTIME_DIR}

)

#!/usr/bin/env python

#

#

# This file is part of GNU Radio

#

#

""" A tool for editing GNU Radio out-of-tree modules. """

from gnuradio.modtool import *

def main():

""" Here we go. Parse command, choose class and run. """

except ModToolException as err:

exit(1)

if __name__ == '__main__':

# Boston, MA 02110-1301, USA.

#

try:

import scipy

except ImportError:

from gnuradio.plot_data import plot_data

def main():

description = "Takes a GNU Radio byte/char binary file and displays the samples versus time. You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

if __name__ == "__main__":

try:

# Boston, MA 02110-1301, USA.

#

try:

import scipy

except ImportError:

try:

from pylab import *

from matplotlib.font_manager import fontManager, FontProperties

except ImportError:

class draw_constellation:

def __init__(self, filename, options):

try:

iq = scipy.fromfile(self.hfile, dtype=self.datatype, count=self.block_length)

except MemoryError:

else:

# retesting length here as newer version of scipy does not throw a MemoryError, just

# returns a zero-length array

self.time = scipy.array([i*(1/self.sample_rate) for i in range(len(self.reals))])

return True

else:

return False

def make_plots(self):

def find(item_in, list_search):

try:

except ValueError:

def main():

description = "Takes a GNU Radio complex binary file and displays the I&Q data versus time and the constellation plot (I vs. Q). You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

if __name__ == "__main__":

try:

main()

except KeyboardInterrupt:

pass

def main():

parser = plot_fft_base.setup_options()

if __name__ == "__main__":

try:

def main():

parser = plot_fft_base.setup_options()

if __name__ == "__main__":

try:

def main():

parser = plot_fft_base.setup_options()

if __name__ == "__main__":

try:

# Boston, MA 02110-1301, USA.

#

try:

import scipy

except ImportError:

from gnuradio.plot_data import plot_data

def main():

description = "Takes a GNU Radio floating point binary file and displays the samples versus time. You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

datatype=scipy.float32

if __name__ == "__main__":

try:

try:

import scipy

except ImportError:

from gnuradio.plot_data import plot_data

def main():

description = "Takes a GNU Radio integer binary file and displays the samples versus time. You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

datatype=scipy.int32

if __name__ == "__main__":

try:

# Boston, MA 02110-1301, USA.

#

try:

import scipy

except ImportError:

try:

from pylab import *

except ImportError:

class draw_iq:

def __init__(self, filename, options):

try:

self.iq = scipy.fromfile(self.hfile, dtype=self.datatype, count=self.block_length)

except MemoryError:

else:

self.reals = scipy.array([r.real for r in self.iq])

self.imags = scipy.array([i.imag for i in self.iq])

def find(item_in, list_search):

try:

except ValueError:

def main():

description = "Takes a GNU Radio complex binary file and displays the I&Q data versus time. You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

if __name__ == "__main__":

try:

main()

except KeyboardInterrupt:

pass

def main():

parser = plot_psd_base.setup_options()

if __name__ == "__main__":

try:

# Boston, MA 02110-1301, USA.

#

from gnuradio.plot_psd_base import plot_psd_base

# This is a wrapper program for plot_psd_base specifically for complex data

def main():

parser = plot_psd_base.setup_options()

if __name__ == "__main__":

try:

# Boston, MA 02110-1301, USA.

#

from gnuradio.plot_psd_base import plot_psd_base

# This is a wrapper program for gr_plot_psd specifically for floating point data

def main():

parser = plot_psd_base.setup_options()

if __name__ == "__main__":

try:

import scipy

from scipy import fftpack

except ImportError:

try:

from matplotlib import mlab

except ImportError:

try:

from PyQt4 import Qt, QtCore, QtGui

except ImportError:

try:

import PyQt4.Qwt5 as Qwt

except ImportError:

try:

# FIXME: re-enable this before committing

#from gnuradio.pyqt_plot import Ui_MainWindow

from gnuradio.pyqt_plot import Ui_MainWindow

except ImportError:

import sys, os

from optparse import OptionParser

def open_file(self):

filename = Qt.QFileDialog.getOpenFileName(self, "Open", ".")

if(filename != ""):

self.initialize(filename)

def reload_file(self):

def init_data_input(self):

self.hfile.seek(0, os.SEEK_END)

self.signal_size = self.hfile.tell()/self.sizeof_data

self.hfile.seek(0, os.SEEK_SET)

def get_data(self, start, end):

tstep = 1.0 / self.sample_rate

self.iq = iq

self.set_file_pos_box(start, end)

except MemoryError:

# Boston, MA 02110-1301, USA.

#

try:

import scipy

except ImportError:

from gnuradio.plot_data import plot_data

def main():

description = "Takes a GNU Radio short integer binary file and displays the samples versus time. You can set the block size to specify how many points to read in at a time and the start position in the file. By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

datatype=scipy.int16

if __name__ == "__main__":

try:

# Boston, MA 02110-1301, USA.

#

import sys

import pmt

from gnuradio.blocks import parse_file_metadata

sys.stderr.write("Could not deserialize header: invalid or corrupt data file.\n")

sys.exit(1)

info = parse_file_metadata.parse_header(header, True)

if(info["extra_len"] > 0):

sys.stderr.write("Could not deserialize extras: invalid or corrupt data file.\n")

sys.exit(1)

extra_info = parse_file_metadata.parse_extra_dict(extra, info, True)

nheaders += 1

if(not detached):

nread += info['nbytes']

handle.seek(nread, 0)

if __name__ == "__main__":

description = "Read in a GNU Radio file with meta data, extracts the header and prints it."

help="Used if header is detached.")

Utility to help plotting data from files.

"""

try:

import scipy

except ImportError:

try:

from pylab import *

except ImportError:

def __init__(self, datatype, filenames, options):

self.hfile = list()

self.legend_text = list()

try:

f = scipy.fromfile(hfile, dtype=self.datatype, count=self.block_length)

except MemoryError:

else:

self.f = scipy.array(f)

def make_plots(self):

self.sp_f = self.fig.add_subplot(2,1,1, position=[0.075, 0.2, 0.875, 0.6])

def find(item_in, list_search):

try:

except ValueError:

# Boston, MA 02110-1301, USA.

#

try:

import scipy

from scipy import fftpack

except ImportError:

try:

from pylab import *

except ImportError:

def __init__(self, datatype, filename, options):

self.hfile = open(filename, "r")

self.block_length = options.block

show()

def get_data(self):

self.text_file_pos.set_text("File Position: %d" % (self.position))

try:

self.iq = scipy.fromfile(self.hfile, dtype=self.datatype, count=self.block_length)

except MemoryError:

else:

self.iq_fft = self.dofft(self.iq)

tstep = 1.0 / self.sample_rate

self.freq = self.calc_freq(self.time, self.sample_rate)

def dofft(self, iq):

N = len(iq)

iq_fft = scipy.fftpack.fftshift(scipy.fft(iq)) # fft and shift axis

# adding 1e-15 (-300 dB) to protect against value errors if an item in iq_fft is 0

return iq_fft

def calc_freq(self, time, sample_rate):

N = len(time)

Fn = 0.5 * sample_rate

return freq

def make_plots(self):

@staticmethod

def setup_options():

description = "Takes a GNU Radio complex binary file and displays the I&Q data versus time as well as the frequency domain (FFT) plot. The y-axis values are plotted assuming volts as the amplitude of the I&Q streams and converted into dBm in the frequency domain (the 1/N power adjustment out of the FFT is performed internally). The script plots a certain block of data at a time, specified on the command line as -B or --block. This value defaults to 1000. The start position in the file can be set by specifying -s or --start and defaults to 0 (the start of the file). By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time and frequency axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples."

return parser

def find(item_in, list_search):

try:

except ValueError:

def main():

parser = plot_fft_base.setup_options()

if __name__ == "__main__":

try:

main()

except KeyboardInterrupt:

pass

# Boston, MA 02110-1301, USA.

#

try:

import scipy

from scipy import fftpack

except ImportError:

try:

from pylab import *

except ImportError:

from scipy import log10

def __init__(self, datatype, filename, options):

self.hfile = open(filename, "r")

self.block_length = options.block

show()

def get_data(self):

self.text_file_pos.set_text("File Position: %d" % self.position)

try:

self.iq = scipy.fromfile(self.hfile, dtype=self.datatype, count=self.block_length)

except MemoryError:

return False

else:

# retesting length here as newer version of scipy does not throw a MemoryError, just

# returns a zero-length array

if(len(self.iq) > 0):

tstep = 1.0 / self.sample_rate

self.iq_psd, self.freq = self.dopsd(self.iq)

return True

else:

return False

def dopsd(self, iq):

''' Need to do this here and plot later so we can do the fftshift '''

winfunc = scipy.blackman

psd,freq = mlab.psd(iq, self.psdfftsize, self.sample_rate,

window = lambda d: d*winfunc(self.psdfftsize),

self.sp_psd.set_xlim([f.min(), f.max()])

def draw_spec(self, t, s):

winfunc = scipy.blackman

self.sp_spec.clear()

self.sp_spec.specgram(s, self.specfftsize, self.sample_rate,

@staticmethod

def setup_options():

description = "Takes a GNU Radio binary file (with specified data type using --data-type) and displays the I&Q data versus time as well as the power spectral density (PSD) plot. The y-axis values are plotted assuming volts as the amplitude of the I&Q streams and converted into dBm in the frequency domain (the 1/N power adjustment out of the FFT is performed internally). The script plots a certain block of data at a time, specified on the command line as -B or --block. The start position in the file can be set by specifying -s or --start and defaults to 0 (the start of the file). By default, the system assumes a sample rate of 1, so in time, each sample is plotted versus the sample number. To set a true time and frequency axis, set the sample rate (-R or --sample-rate) to the sample rate used when capturing the samples. Finally, the size of the FFT to use for the PSD and spectrogram plots can be set independently with --psd-size and --spec-size, respectively. The spectrogram plot does not display by default and is turned on with -S or --enable-spec."

return parser

def find(item_in, list_search):

try:

except ValueError:

def main():

parser = plot_psd_base.setup_options()

if __name__ == "__main__":

try:

main()

except KeyboardInterrupt:

pass

#

# WARNING! All changes made in this file will be lost!

from PyQt4 import QtCore, QtGui

class Ui_MainWindow(object):

#

# WARNING! All changes made in this file will be lost!

from PyQt4 import QtCore, QtGui

class Ui_MainWindow(object):