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

include(GrPython)

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

# Register component

#

# Copyright 2013-2014 Free Software Foundation, Inc.

#

# 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 """

# Boston, MA 02110-1301, USA.

#

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

from mako.template import Template

GRTYPELIST = {

'sync': 'sync_block',

add_custom_command(

OUTPUT ${expanded_files_h}

DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.h.t

${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py

${root} ${root}.h.t ${ARGN}

)

add_custom_command(

OUTPUT ${expanded_files_cc}

DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.cc.t

${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py

${root} ${root}.cc.t ${ARGN}

)

add_custom_command(

OUTPUT ${expanded_files_h}

DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}.h.t

${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py

${root} ${root}.h.t ${ARGN}

)

add_custom_command(

OUTPUT ${expanded_files_cc_impl}

DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}_impl.cc.t

${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py

${root} ${root}_impl.cc.t ${ARGN}

)

add_custom_command(

OUTPUT ${expanded_files_h_impl}

DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${root}_impl.h.t

${CMAKE_CURRENT_BINARY_DIR}/generate_helper.py

${root} ${root}_impl.h.t ${ARGN}

)

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})

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}

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)

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:

"""Misc utilities used at build time

"""

import re, os, os.path

# set srcdir to the directory that contains Makefile.am

try:

srcdir = os.environ['srcdir']

srcdir = "."

srcdir = srcdir + '/'

do_makefile = False

else:

do_makefile = True

do_makefile = False

# set do_sources to either true or false dependeing on the environment

do_sources = False

else:

do_sources = True

do_sources = True

name_dict = {}

# we return everything between the penultimate . and .t

mo = re.search (r'\.([a-z]+)\.t$', template_name)

if not mo:

return mo.group (1)

def open_src (name, mode):

#

# Copyright 2004 Free Software Foundation, Inc.

#

#

# 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. """

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

language_candidates = ('c++', 'cpp', 'python')

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 self._info['blockname'] is None:

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

raise ModToolException('Invalid block name.')

self._info['fullblockname'] = self._info['modname'] + '_' + self._info['blockname']

if not options.license_file:

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

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

self._info['copyrightholder'] = '<+YOU OR YOUR COMPANY+>'

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):

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

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

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

open(path_to_file, 'w').write(render_template(tpl, **self._info))

self.scm.add_files((path_to_file,))

)

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 = '_'

"""

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 argparse import ArgumentParser, RawDescriptionHelpFormatter

from gnuradio import gr

class ModToolException(BaseException):

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

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']))

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

#

""" Disable blocks module """

import os

import re

import sys

class ModToolDisable(ModTool):

if options.blockname is not None:

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

else:

if len(self._info['pattern']) == 0:

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

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)

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

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

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

swigfile = re.sub('(%include\s+"'+fname+'")', r'//\1', swigfile)

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'])

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):

):

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':

'36': 'pre-3.7',

'37': 'post-3.7',

'autofoo': 'Autotools (pre-3.5)'

else:

#

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

import os

import re

import glob

class ModToolMakeXML(ModTool):

if options.blockname is not None:

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

else:

if len(self._info['pattern']) == 0:

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

def run(self, options):

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

self.setup(options)

# 1) Go through lib/

if not self._skip_subdirs['lib']:

""" 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)

if len(files_filt) == 0:

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 """

if options.module_name:

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

else:

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

raise ModToolException('Invalid module name.')

self._dir = options.directory

* Rename files and directories that contain the word howto

"""

self.setup(options)

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. """

# first make sure the old block name is provided

self._info['oldname'] = options.blockname

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 options.new_name is None:

else:

self._info['newname'] = options.new_name[0]

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']

def run(self, options):

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):

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

else:

with SequenceCompleter():

if len(self._info['pattern']) == 0:

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

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)

if len(files_filt) == 0:

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:

# Boston, MA 02110-1301, USA.

#

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

from datetime import datetime

#

""" Utility functions for gr_modtool """

import re

import sys

import readline

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

#

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

from gnuradio.modtool import *

try:

args.module().run(args)

except ModToolException as err:

exit(1)

if __name__ == '__main__':

# Boston, MA 02110-1301, USA.

#

try:

import scipy

except ImportError:

from argparse import ArgumentParser

from gnuradio.plot_data import plot_data

# Boston, MA 02110-1301, USA.

#

try:

import scipy

except ImportError:

try:

from pylab import *

from matplotlib.font_manager import fontManager, FontProperties

except ImportError:

from argparse import ArgumentParser

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():

main()

except KeyboardInterrupt:

pass

# Boston, MA 02110-1301, USA.

#

try:

import scipy

except ImportError:

from argparse import ArgumentParser

from gnuradio.plot_data import plot_data

try:

import scipy

except ImportError:

from argparse import ArgumentParser

from gnuradio.plot_data import plot_data

# Boston, MA 02110-1301, USA.

#

try:

import scipy

except ImportError:

try:

from pylab import *

except ImportError:

from argparse import ArgumentParser

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."

main()

except KeyboardInterrupt:

pass

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 argparse import ArgumentParser

from gnuradio.plot_data import plot_data

# Boston, MA 02110-1301, USA.

#

import sys

from argparse import ArgumentParser

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__":

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:

from argparse import ArgumentParser

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):

def find(item_in, list_search):

try:

except ValueError:

def main():

parser = plot_fft_base.setup_options()

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 argparse import ArgumentParser

from scipy import log10

from gnuradio.eng_arg import eng_float, intx

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,

def find(item_in, list_search):

try:

except ValueError:

def main():

parser = plot_psd_base.setup_options()

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):