-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-include(GrPython)

-

-GR_PYTHON_INSTALL(FILES

- __init__.py

- __main__.py

- cli.py

- DESTINATION ${GR_PYTHON_DIR}/gnuradio/blocktool

-)

-

-########################################################################

-# Add subdirectories

-########################################################################

-add_subdirectory(core)

-gr_blocktool: Also known as the block header parsing tool, this tool

- automatically parses any GNU Radio or OOT block header.

-

-Block header tool from the Command Line Interface

-=================================================

-

-* Parse any GNU Radio or OOT header file with just the file path as an input.

-* Parse a complete header directory with directory-path as the input.

-* Get the output in the form of a YAML or a JSON file.

-* Add blocktool comments automatically in the header file from the implementation file.

-

-

-Integration of blocktool with modtool

-=====================================

-

-* Blocktool API can also be called from modtool.

-* Modtool makeyaml subcommand along with -b flag and a

- file path as the input can be used to create YAML files for the GRC.

-* YAML output is much better using the blocktool API.

-

-

-Use of blocktool as an independent API

-======================================

-

-Blocktool can be also be used as an independent API which thus can be used to

-parse a block header file during runtime.

-* A single mandatory argument block header file path is required.

-

-#

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-

-from .core.parseheader import BlockHeaderParser

-from .core.outputschema import RESULT_SCHEMA

-#

-# Copyright 2019 Free Software Foundation, Inc.

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-2.0-or-later

-#

-#

-""" main function to run the blocktool api from the command line. """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import sys

-from .cli import cli

-

-

-sys.exit(cli())

-#

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Module to generate parsed header output data """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import sys

-import json

-import logging

-

-import click

-from click import ClickException

-

-from gnuradio.modtool.core import yaml_generator

-

-from .core.parseheader import BlockHeaderParser

-

-LOGGER = logging.getLogger(__name__)

-

-

-class BlockToolException(ClickException):

- """ Exception class for enhanced CLI interface """

-

- def show(self, file=None):

- """ displays the colored message """

- click.secho('BlockToolException: {}'.format(

- self.format_message()), fg='red')

-

-

-def run_blocktool(module):

- """Call the run function of the core modules."""

- try:

- module.run_blocktool()

- except BlockToolException as err:

- click.echo(err, file=sys.stderr)

- exit(1)

-

-

-@click.command('parseheader',

- short_help='Generate the parsed output for the header file or directory in a specified format')

-@click.argument('file-path', nargs=1)

-@click.option('--yaml', is_flag=True,

- help='If given, a YAML response will be printed, else default json will be printed')

-@click.option('-c', '--blocktool-comments', is_flag=True,

- help='blocktool helper comments will be added in the header file')

-@click.option('-o', '--output', is_flag=True,

- help='If given, a file with desired output format will be generated')

-@click.option('-I', '--include_paths', default=None,

- help='Comma separated list of include paths for header files')

-def cli(**kwargs):

- """

- Block header parsing tool.

- \b

- A tool that can be used to automatically parse the headers in GNU Radio project

- or the OOT modules

- """

- kwargs['modtool'] = False

- if os.path.isfile(kwargs['file_path']):

- parser = BlockHeaderParser(**kwargs)

- run_blocktool(parser)

- if kwargs['yaml']:

- parser.yaml = True

- yaml_generator(parser, **kwargs)

- else:

- parser.json_confirm = True

- json_generator(parser, **kwargs)

- elif os.path.isdir(kwargs['file_path']):

- parse_directory(**kwargs)

- else:

- raise BlockToolException('Invalid file or directory path.')

-

-

-def json_generator(parser, **kwargs):

- """

- Generate JSON file for the block header

- """

- header = parser.filename.split('.')[0]

- block = parser.modname.split('-')[-1]

- if kwargs['output']:

- json_file = os.path.join('.', block+'_'+header + '.json')

- with open(json_file, 'w') as _file:

- json.dump(parser.parsed_data, _file, indent=4)

- else:

- print(json.dumps(parser.parsed_data, indent=4))

-

-

-def parse_directory(**kwargs):

- """

- Get parsed json and yaml output for complete header directory

- """

- kwargs['output'] = True

- dir_path = kwargs['file_path']

- dir_path = os.path.abspath(dir_path)

- list_header = []

- dir_name = os.path.basename(dir_path)

- for _header in os.listdir(dir_path):

- if _header.endswith('.h') and os.path.isfile(os.path.join(dir_path, _header)):

- list_header.append(os.path.join(dir_path, _header))

- list_header = sorted(list_header)

- if list_header:

- for header_path in list_header:

- kwargs['file_path'] = header_path

- header = os.path.basename(header_path)

- try:

- parse_dir = BlockHeaderParser(**kwargs)

- parse_dir.yaml = True

- parse_dir.json = True

- run_blocktool(parse_dir)

- yaml_generator(parse_dir, **kwargs)

- if not kwargs['modtool']:

- json_generator(parse_dir, **kwargs)

- except:

- logging.basicConfig(level=logging.DEBUG,

- filename=os.path.join('.', dir_name+'_log.out'))

- logging.exception(

- 'Log for Exception raised for the header: {}\n'.format(header))

- click.secho('Parsing unsuccessful: {}'.format(

- header), fg='yellow')

- else:

- raise BlockToolException(

- 'Invalid directory! No header found to be parsed')

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-include(GrPython)

-

-GR_PYTHON_INSTALL(FILES

- __init__.py

- base.py

- comments.py

- parseheader.py

- iosignature.py

- outputschema.py

- Constants.py

- DESTINATION ${GR_PYTHON_DIR}/gnuradio/blocktool/core

-)

-#

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" constants file """

-

-# Kernel Namespace

-KERNEL = 'kernel'

-

-# I/O Signature (Symbols and constants)

-IO_SIGNATURE = 'io_signature::'

-SIGNATURE_LIST = ['makev', 'make3', 'make2', 'make']

-MAKE = 'make'

-MAKE2 = 'make2'

-MAKE3 = 'make3'

-MAKEV = 'makev'

-

-

-# message ports id

-MESSAGE_INPUT = 'message_port_register_in'

-MESSAGE_OUTPUT = 'message_port_register_out'

-

-# Symbols and constants required for parsing

-GR = 'gr-'

-UTILS = 'utils'

-OPEN_BRACKET = '('

-CLOSE_BRACKET = ')'

-STRIP_SYMBOLS = ' ,:)'

-EXCLAMATION = '!'

-

-# Blocktool special comments

-BLOCKTOOL = '! BlockTool'

-END_BLOCKTOOL = 'EndTool !'

-INPUT_SIG = 'input_signature'

-OUTPUT_SIG = 'output_signature'

-INPUT_MIN = 'input_min_streams'

-INPUT_MAX = 'input_max_streams'

-OUTPUT_MIN = 'output_min_streams'

-OUTPUT_MAX = 'output_max_streams'

-INPUT_MAKE_SIZE = 'input_sizeof_stream_item'

-INPUT_MAKEV_SIZE = 'input_sizeof_stream_items'

-INPUT_MAKE_SIZE1 = 'input_sizeof_stream_item1'

-INPUT_MAKE_SIZE2 = 'input_sizeof_stream_item2'

-INPUT_MAKE_SIZE3 = 'input_sizeof_stream_item3'

-OUTPUT_MAKE_SIZE = 'output_sizeof_stream_item'

-OUTPUT_MAKEV_SIZE = 'output_sizeof_stream_items'

-OUTPUT_MAKE_SIZE1 = 'output_sizeof_stream_item1'

-OUTPUT_MAKE_SIZE2 = 'output_sizeof_stream_item2'

-OUTPUT_MAKE_SIZE3 = 'output_sizeof_stream_item3'

-INPUT_PORT = 'message_input'

-OUTPUT_PORT = 'message_output'

-#

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Base class for the modules """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-from abc import ABC, abstractmethod

-

-

-class BlockToolException(Exception):

- """ Standard exception for blocktool classes. """

- pass

-

-

-class BlockTool(ABC):

- """ Base class for all blocktool command classes. """

- name = 'base'

- description = None

-

- def __init__(self, modname=None, filename=None, targetdir=None,

- target_file=None, module=None, impldir=None, impl_file=None,

- yaml=False, json=False, include_paths=None, **kwargs):

- """ __init__ """

- pass

-

- def _validate(self):

- """ Validates the arguments """

- pass

-

- @abstractmethod

- def run_blocktool(self):

- """ Override this. """

- pass

-#

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Module to read and add special blocktool comments in the public header """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import warnings

-

-from ..core import Constants

-

-

-def strip_symbols(line):

- """

- helper function to strip symbols

- from blocktool comment syntax

- """

- return line.split(':')[-1].lstrip().rstrip()

-

-

-def exist_comments(self):

- """

- function to check if blocktool special comments

- already exist in the public header

- """

- _comments = True

- _index = None

- lines = []

- with open(self.target_file, 'r') as header:

- lines = header.readlines()

- for line in lines:

- if Constants.BLOCKTOOL in line:

- _index = lines.index(line)

- return bool(_index)

-

-

-def validate_message_port(self, message_ports, suppress_input, suppress_output):

- """

- function to solve conflicts if any in the

- *message_port* comments and the implementation information

- """

- if message_ports['input'] != self.parsed_data['message_port']['input']:

- if not suppress_input:

- warnings.warn(

- 'Conflict in values input message port Id. Add ! at the start of the key-value line to mandatory use the comment value.')

- self.parsed_data['message_port']['input'] = message_ports['input']

- if message_ports['output'] != self.parsed_data['message_port']['output']:

- if not suppress_output:

- warnings.warn(

- 'Conflict in values output message port Id. Add ! at the start of the key-value line to mandatory use the comment value.')

- self.parsed_data['message_port']['output'] = message_ports['output']

-

-

-def read_comments(self):

- """

- function to read special blocktool comments

- in the public header

- """

- temp_parsed_data = {}

- if self.parsed_data['io_signature'] or self.parsed_data['message_port']:

- temp_parsed_data['io_signature'] = self.parsed_data['io_signature']

- temp_parsed_data['message_port'] = self.parsed_data['message_port']

- self.parsed_data['io_signature'] = {

- "input": {

- "signature": None

- },

- "output": {

- "signature": None

- }

- }

- self.parsed_data['message_port'] = {

- "input": [],

- "output": []

- }

- _suppress_input = False

- _suppress_output = False

- parsed_io = self.parsed_data['io_signature']

- message_port = self.parsed_data['message_port']

- special_comments = []

- _index = None

- lines = []

- with open(self.target_file, 'r') as header:

- lines = header.readlines()

- for line in lines:

- if Constants.BLOCKTOOL in line:

- _index = lines.index(line)

-

- if _index is not None:

- _index = _index+1

- for num in range(_index, len(lines)):

- if Constants.END_BLOCKTOOL in lines[num]:

- break

- special_comments.append(lines[num])

- for comment in special_comments:

- if Constants.INPUT_SIG in comment:

- parsed_io['input']['signature'] = strip_symbols(comment)

- if Constants.INPUT_MAX in comment:

- parsed_io['input']['max_streams'] = strip_symbols(comment)

- if Constants.INPUT_MIN in comment:

- parsed_io['input']['min_streams'] = strip_symbols(comment)

- if parsed_io['input']['signature'] is Constants.MAKE and not None:

- if Constants.INPUT_MAKE_SIZE in comment:

- parsed_io['input']['sizeof_stream_item'] = strip_symbols(

- comment)

- elif parsed_io['input']['signature'] is Constants.MAKE2 and not None:

- if Constants.INPUT_MAKE_SIZE1 in comment:

- parsed_io['input']['sizeof_stream_item1'] = strip_symbols(

- comment)

- if Constants.INPUT_MAKE_SIZE2 in comment:

- parsed_io['input']['sizeof_stream_item2'] = strip_symbols(

- comment)

- elif parsed_io['input']['signature'] is Constants.MAKE3 and not None:

- if Constants.INPUT_MAKE_SIZE1 in comment:

- parsed_io['input']['sizeof_stream_item1'] = strip_symbols(

- comment)

- if Constants.INPUT_MAKE_SIZE2 in comment:

- parsed_io['input']['sizeof_stream_item2'] = strip_symbols(

- comment)

- if Constants.INPUT_MAKE_SIZE3 in comment:

- parsed_io['input']['sizeof_stream_item3'] = strip_symbols(

- comment)

- elif parsed_io['input']['signature'] is Constants.MAKEV and not None:

- if Constants.INPUT_MAKEV_SIZE in comment:

- parsed_io['input']['sizeof_stream_items'] = strip_symbols(

- comment)

-

- if Constants.OUTPUT_SIG in comment:

- parsed_io['output']['signature'] = strip_symbols(comment)

- if Constants.OUTPUT_MAX in comment:

- parsed_io['output']['max_streams'] = strip_symbols(comment)

- if Constants.OUTPUT_MIN in comment:

- parsed_io['output']['min_streams'] = strip_symbols(comment)

- if parsed_io['output']['signature'] is Constants.MAKE and not None:

- if Constants.OUTPUT_MAKE_SIZE in comment:

- parsed_io['output']['sizeof_stream_item'] = strip_symbols(

- comment)

- elif parsed_io['output']['signature'] is Constants.MAKE2:

- if Constants.OUTPUT_MAKE_SIZE1 in comment:

- parsed_io['output']['sizeof_stream_item1'] = strip_symbols(

- comment)

- if Constants.OUTPUT_MAKE_SIZE2 in comment:

- parsed_io['output']['sizeof_stream_item2'] = strip_symbols(

- comment)

- elif parsed_io['output']['signature'] is Constants.MAKE3 and not None:

- if Constants.OUTPUT_MAKE_SIZE1 in comment:

- parsed_io['output']['sizeof_stream_item1'] = strip_symbols(

- comment)

- if Constants.OUTPUT_MAKE_SIZE2 in comment:

- parsed_io['output']['sizeof_stream_item2'] = strip_symbols(

- comment)

- if Constants.OUTPUT_MAKE_SIZE3 in comment:

- parsed_io['output']['sizeof_stream_item3'] = strip_symbols(

- comment)

- elif parsed_io['output']['signature'] is Constants.MAKEV and not None:

- if Constants.OUTPUT_MAKEV_SIZE in comment:

- parsed_io['output']['sizeof_stream_items'] = strip_symbols(

- comment)

-

- if Constants.INPUT_PORT in comment:

- if Constants.EXCLAMATION in comment:

- _suppress_input = True

- if strip_symbols(comment):

- message_port['input'] = strip_symbols(comment).split(', ')

- if Constants.OUTPUT_PORT in comment:

- if Constants.EXCLAMATION in comment:

- _suppress_output = True

- if strip_symbols(comment):

- message_port['output'] = strip_symbols(comment).split(', ')

- validate_message_port(

- self, temp_parsed_data['message_port'], _suppress_input, _suppress_output)

- self.parsed_data['io_signature'] = temp_parsed_data['io_signature']

-

-

-def add_comments(self):

- """

- function to add special blocktool comments

- in the public header

- """

- _index = None

- lines = []

- parsed_io = self.parsed_data['io_signature']

- message_port = self.parsed_data['message_port']

- with open(self.target_file, 'r') as header:

- lines = header.readlines()

- for line in lines:

- if Constants.BLOCKTOOL in line:

- _index = lines.index(line)

- if _index is None:

- with open(self.target_file, 'a') as header:

- header.write('\n')

- header.write('/* '+Constants.BLOCKTOOL + '\n')

- header.write('input_signature: ' +

- parsed_io['input']['signature'] + '\n')

- header.write('input_min_streams: ' +

- parsed_io['input']['min_streams'] + '\n')

- header.write('input_max_streams: ' +

- parsed_io['input']['max_streams'] + '\n')

- if parsed_io['input']['signature'] is Constants.MAKE:

- header.write('input_sizeof_stream_item: ' +

- parsed_io['input']['sizeof_stream_item'] + '\n')

- elif parsed_io['input']['signature'] is Constants.MAKE2:

- header.write('input_sizeof_stream_item1: ' +

- parsed_io['input']['sizeof_stream_item1'] + '\n')

- header.write('input_sizeof_stream_item2: ' +

- parsed_io['input']['sizeof_stream_item2'] + '\n')

- elif parsed_io['input']['signature'] is Constants.MAKE3:

- header.write('input_sizeof_stream_item1: ' +

- parsed_io['input']['sizeof_stream_item1'] + '\n')

- header.write('input_sizeof_stream_item2: ' +

- parsed_io['input']['sizeof_stream_item2'] + '\n')

- header.write('input_sizeof_stream_item3: ' +

- parsed_io['input']['sizeof_stream_item3'] + '\n')

- elif parsed_io['input']['signature'] is Constants.MAKEV:

- header.write('input_sizeof_stream_item: ' +

- parsed_io['input']['sizeof_stream_items'] + '\n')

- header.write('output_signature: ' +

- parsed_io['output']['signature'] + '\n')

- header.write('output_min_streams: ' +

- parsed_io['output']['min_streams'] + '\n')

- header.write('output_max_streams: ' +

- parsed_io['output']['max_streams'] + '\n')

- if parsed_io['output']['signature'] is Constants.MAKE:

- header.write('output_sizeof_stream_item: ' +

- parsed_io['output']['sizeof_stream_item'] + '\n')

- elif parsed_io['output']['signature'] is Constants.MAKE2:

- header.write('output_sizeof_stream_item1: ' +

- parsed_io['output']['sizeof_stream_item1'] + '\n')

- header.write('output_sizeof_stream_item2: ' +

- parsed_io['output']['sizeof_stream_item2'] + '\n')

- elif parsed_io['output']['signature'] is Constants.MAKE3:

- header.write('output_sizeof_stream_item1: ' +

- parsed_io['output']['sizeof_stream_item1'] + '\n')

- header.write('output_sizeof_stream_item2: ' +

- parsed_io['output']['sizeof_stream_item2'] + '\n')

- header.write('output_sizeof_stream_item3: ' +

- parsed_io['output']['sizeof_stream_item3'] + '\n')

- elif parsed_io['output']['signature'] is Constants.MAKEV:

- header.write('output_sizeof_stream_item: ' +

- parsed_io['output']['sizeof_stream_items'] + '\n')

-

- if message_port['input']:

- header.write('message_input: ' +

- ', '.join(message_port['input']) + '\n')

- else:

- header.write('message_input: ' + '\n')

- if message_port['output']:

- header.write('message_output: ' +

- ', '.join(message_port['output']) + '\n')

- else:

- header.write('message_output: ' + '\n')

- header.write(Constants.END_BLOCKTOOL + '*/' + '\n')

-#

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Module to get io_signature of the header block """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import re

-import itertools

-import logging

-import string

-

-from ..core import Constants

-

-LOGGER = logging.getLogger(__name__)

-

-

-def io_signature(impl_file):

- """

- function to generate the io_signature of the block

- : returns the io parmaters

- """

- parsed_io = {

- "input": {

- "signature": None

- },

- "output": {

- "signature": None

- }

- }

- with open(impl_file, 'r') as impl:

- io_lines = []

- for line in impl:

- if Constants.IO_SIGNATURE in line:

- io_lines.append(line)

- if len(io_lines) > 2:

- io_lines = io_lines[0:2]

- _io_sig = []

- for line in io_lines:

- if Constants.IO_SIGNATURE in line:

- line = line.lstrip().rstrip().split(Constants.IO_SIGNATURE)

- _io_sig.append(line)

- _io_sig = list(itertools.chain.from_iterable(_io_sig))

- for index, _element in enumerate(_io_sig):

- _io_sig[index] = _element.lstrip().rstrip()

- if all(i in string.punctuation for i in _element):

- _io_sig.remove(_element)

- _io_sig = list(filter(None, _io_sig))

- io_func = []

- for _io in _io_sig:

- if Constants.MAKE in _io:

- io_func.append(_io.lstrip().rstrip(Constants.STRIP_SYMBOLS))

- for signature in Constants.SIGNATURE_LIST:

- if signature in io_func[0] and parsed_io['input']['signature'] is None:

- parsed_io['input']['signature'] = signature

- io_func[0] = io_func[0].lstrip(signature+' (')

- if signature in io_func[1] and parsed_io['output']['signature'] is None:

- parsed_io['output']['signature'] = signature

- io_func[1] = io_func[1].lstrip(signature+' (')

- io_elements = []

- for _io in io_func:

- _io = _io.split(',')

- io_elements.append(_io)

- io_elements = list(itertools.chain.from_iterable(io_elements))

- for index, _io in enumerate(io_elements):

- _io = _io.lstrip(' (').rstrip(' )')

- if Constants.OPEN_BRACKET in _io:

- _io = _io + Constants.CLOSE_BRACKET

- io_elements[index] = _io

-

- # Because of any possible combination of I/O signature and different number

- # of arguments, manual if else loop is required

- if parsed_io['input']['signature'] is Constants.MAKE:

- parsed_io['input']['min_streams'] = io_elements[0]

- parsed_io['input']['max_streams'] = io_elements[1]

- parsed_io['input']['sizeof_stream_item'] = io_elements[2]

- del io_elements[0:3]

- elif parsed_io['input']['signature'] is Constants.MAKE2:

- parsed_io['input']['min_streams'] = io_elements[0]

- parsed_io['input']['max_streams'] = io_elements[1]

- parsed_io['input']['sizeof_stream_item1'] = io_elements[2]

- parsed_io['input']['sizeof_stream_item2'] = io_elements[3]

- del io_elements[0:4]

- elif parsed_io['input']['signature'] is Constants.MAKE3:

- parsed_io['input']['min_streams'] = io_elements[0]

- parsed_io['input']['max_streams'] = io_elements[1]

- parsed_io['input']['sizeof_stream_item1'] = io_elements[2]

- parsed_io['input']['sizeof_stream_item2'] = io_elements[3]

- parsed_io['input']['sizeof_stream_item3'] = io_elements[4]

- del io_elements[0:5]

- elif parsed_io['input']['signature'] is Constants.MAKEV:

- parsed_io['input']['min_streams'] = io_elements[0]

- parsed_io['input']['max_streams'] = io_elements[1]

- parsed_io['input']['sizeof_stream_items'] = io_elements[2]

- del io_elements[0:3]

-

- if parsed_io['output']['signature'] is Constants.MAKE:

- parsed_io['output']['min_streams'] = io_elements[0]

- parsed_io['output']['max_streams'] = io_elements[1]

- parsed_io['output']['sizeof_stream_item'] = io_elements[2]

- del io_elements[0:3]

- elif parsed_io['output']['signature'] is Constants.MAKE2:

- parsed_io['output']['min_streams'] = io_elements[0]

- parsed_io['output']['max_streams'] = io_elements[1]

- parsed_io['output']['sizeof_stream_item1'] = io_elements[2]

- parsed_io['output']['sizeof_stream_item2'] = io_elements[3]

- del io_elements[0:4]

- elif parsed_io['output']['signature'] is Constants.MAKE3:

- parsed_io['output']['min_streams'] = io_elements[0]

- parsed_io['output']['max_streams'] = io_elements[1]

- parsed_io['output']['sizeof_stream_item1'] = io_elements[2]

- parsed_io['output']['sizeof_stream_item2'] = io_elements[3]

- parsed_io['output']['sizeof_stream_item3'] = io_elements[4]

- del io_elements[0:5]

- elif parsed_io['output']['signature'] is Constants.MAKEV:

- parsed_io['output']['min_streams'] = io_elements[0]

- parsed_io['output']['max_streams'] = io_elements[1]

- parsed_io['output']['sizeof_stream_items'] = io_elements[2]

- del io_elements[0:3]

- return parsed_io

-

-

-def message_port(impl_file):

- """

- parses message ports from implementation file

- """

- parsed_message_port = {

- "input": [],

- "output": []

- }

- with open(impl_file, 'r') as impl:

- _input = []

- _output = []

- for line in impl:

- if Constants.MESSAGE_INPUT in line:

- _input.append(line)

- if Constants.MESSAGE_OUTPUT in line:

- _output.append(line)

-

- input_port = []

- output_port = []

- if _input:

- for port in _input:

- port = port.lstrip().rstrip().strip(Constants.MESSAGE_INPUT)

- pattern = port.find('\"')

- if pattern != -1:

- if re.findall(r'"([^"]*)"', port)[0]:

- input_port.append(re.findall(r'"([^"]*)"', port)[0])

- else:

- input_port.append(port[port.find('(')+1:port.rfind(')')])

- _temp_port = ''.join(map(str, input_port))

- input_port.clear()

- input_port.append(_temp_port)

-

- if _output:

- for port in _output:

- port = port.lstrip().rstrip().strip(Constants.MESSAGE_OUTPUT)

- pattern = port.find('\"')

- if pattern != -1:

- if re.findall(r'"([^"]*)"', port)[0]:

- output_port.append(re.findall(r'"([^"]*)"', port)[0])

- else:

- output_port.append(port[port.find('(')+1:port.rfind(')')])

- _temp_port = ''.join(map(str, output_port))

- output_port.clear()

- output_port.append(_temp_port)

-

- if input_port:

- for port in input_port:

- parsed_message_port['input'].append(port)

-

- if output_port:

- for port in output_port:

- parsed_message_port['output'].append(port)

- return parsed_message_port

-#

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Schema to be strictly followed be parsed header output """

-

-

-RESULT_SCHEMA = {

- "title": "JSON SCHEMA TO BE FOLLOWED BY BLOCK HEADER PARSING TOOL",

- "description": "Schema designed for the header file parsed python dict output",

- "type": "object",

- "properties": {

- "namespace": {

- "description": "List of nested namspace",

- "type": "array",

- "minItems": 1,

- "uniqueItems": True,

- "items": {

- "type": "string",

- "minLength": 1

- }

- },

- "class": {

- "description": "Class name",

- "type": "string",

- "minLength": 1

- },

- "io_signature": {

- "description": "I/O signature",

- "type": "object",

- "properties": {

- "input": {

- "description": "Input ports",

- "type": "object"

- },

- "output": {

- "description": "Output ports",

- "type": "object"

- }

- },

- "required": ["input", "output"]

- },

- "make": {

- "description": "Make function",

- "type": "object",

- "properties": {

- "arguments": {

- "description": "Arguments of make function",

- "type": "array",

- "minItems": 1,

- "uniqueItems": True,

- "items": {

- "type": "object",

- "properties": {

- "name": {

- "type": "string",

- "minLength": 1

- },

- "dtype": {

- "type": "string",

- "minLength": 1

- },

- "default": {

- "type": "string"

- }

- },

- "required": ["name"],

- "dependencies": {

- "name": [

- "dtype",

- "default"

- ]

- }

- }

- }

- }

- },

- "methods": {

- "description": "Setters",

- "type": "array",

- "minItems": 0,

- "items": {

- "type": "object",

- "properties": {

- "name": {

- "type": "string",

- "minLength": 1

- },

- "arguments_type": {

- "type": "array",

- "uniqueItems": True,

- "properties": {

- "name": {

- "type": "string",

- "minLength": 1

- },

- "dtype": {

- "type": "string",

- "minLength": 1

- }

- },

- "required": ["name"],

- "dependencies": {

- "name": ["dtype"]

- }

- }

- },

- "required": ["name"]

- }

- },

- "properties": {

- "description": "Getters",

- "type": "array",

- "uniqueItems": True,

- "items": {

- "type": "object",

- "properties": {

- "name": {

- "type": "string",

- "minLength": 1

- },

- "dtype": {

- "type": "string",

- "minLength": 1

- },

- "read_only": {

- "type": "boolean"

- }

- },

- "required": ["name"],

- "dependencies": {

- "name": [

- "dtype",

- "read_only"

- ]

- }

- }

- },

- "docstring": {

- "description": "documentation of the header file",

- "type": "array"

- }

- },

- "required": [

- "namespace",

- "class",

- "io_signature",

- "make",

- "methods",

- "properties",

- "docstring"

- ]

-}

-#

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Module to generate AST for the headers and parse it """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import re

-import codecs

-import logging

-

-from pygccxml import parser, declarations, utils

-

-from ..core.base import BlockToolException, BlockTool

-from ..core.iosignature import io_signature, message_port

-from ..core.comments import read_comments, add_comments, exist_comments

-from ..core import Constants

-

-LOGGER = logging.getLogger(__name__)

-

-

-class BlockHeaderParser(BlockTool):

- """

- : Single argument required: file_path

- file_path: enter path for the header block in any of GNU Radio module

- : returns the parsed header data in python dict

- : return dict keys: namespace, class, io_signature, make,

- properties, methods

- : Can be used as an CLI command or an extenal API

- """

- name = 'Block Parse Header'

- description = 'Create a parsed output from a block header file'

-

- def __init__(self, file_path=None, blocktool_comments=False, include_paths=None, **kwargs):

- """ __init__ """

- BlockTool.__init__(self, **kwargs)

- self.parsed_data = {}

- self.addcomments = blocktool_comments

- self.include_paths = None

- if (include_paths):

- self.include_paths = [p.strip() for p in include_paths.split(',')]

- if not os.path.isfile(file_path):

- raise BlockToolException('file does not exist')

- file_path = os.path.abspath(file_path)

- self.target_file = file_path

- self.initialize()

- self.validate()

-

- def initialize(self):

- """

- initialize all the required API variables

- """

- self.module = self.target_file

- for dirs in self.module:

- if not os.path.basename(self.module).startswith(Constants.GR):

- self.module = os.path.abspath(

- os.path.join(self.module, os.pardir))

- self.modname = os.path.basename(self.module)

- self.filename = os.path.basename(self.target_file)

- self.targetdir = os.path.dirname(self.target_file)

- for dirs in os.scandir(self.module):

- if dirs.is_dir():

- if dirs.path.endswith('lib'):

- self.impldir = dirs.path

- self.impl_file = os.path.join(self.impldir,

- self.filename.split('.')[0]+'_impl.cc')

-

- def validate(self):

- """ Override the Blocktool validate function """

- BlockTool._validate(self)

- if not self.filename.endswith('.h'):

- raise BlockToolException(

- 'Cannot parse a non-header file')

-

- def get_header_info(self):

- """

- PyGCCXML header code parser

- magic happens here!

- : returns the parsed header data in python dict

- : return dict keys: namespace, class, io_signature, make,

- properties, methods

- : Can be used as an CLI command or an extenal API

- """

- gr = self.modname.split('-')[0]

- module = self.modname.split('-')[-1]

- generator_path, generator_name = utils.find_xml_generator()

- xml_generator_config = parser.xml_generator_configuration_t(

- xml_generator_path=generator_path,

- xml_generator=generator_name,

- include_paths=self.include_paths,

- compiler='gcc',

- define_symbols=['BOOST_ATOMIC_DETAIL_EXTRA_BACKEND_GENERIC'],

- cflags='-std=c++11')

- decls = parser.parse(

- [self.target_file], xml_generator_config)

- global_namespace = declarations.get_global_namespace(decls)

-

- # namespace

- try:

- self.parsed_data['namespace'] = []

- ns = global_namespace.namespace(gr)

- if ns is None:

- raise BlockToolException

- main_namespace = ns.namespace(module)

- if main_namespace is None:

- raise BlockToolException('namespace cannot be none')

- self.parsed_data['namespace'] = [gr, module]

- if main_namespace.declarations:

- for _namespace in main_namespace.declarations:

- if isinstance(_namespace, declarations.namespace_t):

- if Constants.KERNEL not in str(_namespace):

- main_namespace = _namespace

- self.parsed_data['namespace'].append(

- str(_namespace).split('::')[-1].split(' ')[0])

- except RuntimeError:

- raise BlockToolException(

- 'Invalid namespace format in the block header file')

-

- # class

- try:

- self.parsed_data['class'] = ''

- for _class in main_namespace.declarations:

- if isinstance(_class, declarations.class_t):

- main_class = _class

- self.parsed_data['class'] = str(_class).split('::')[

- 2].split(' ')[0]

- except RuntimeError:

- raise BlockToolException(

- 'Block header namespace {} must consist of a valid class instance'.format(module))

-

- # io_signature, message_ports

- self.parsed_data['io_signature'] = {}

- self.parsed_data['message_port'] = {}

- if os.path.isfile(self.impl_file) and exist_comments(self):

- self.parsed_data['io_signature'] = io_signature(

- self.impl_file)

- self.parsed_data['message_port'] = message_port(

- self.impl_file)

- read_comments(self)

- elif os.path.isfile(self.impl_file) and not exist_comments(self):

- self.parsed_data['io_signature'] = io_signature(

- self.impl_file)

- self.parsed_data['message_port'] = message_port(

- self.impl_file)

- if self.addcomments:

- add_comments(self)

- elif not os.path.isfile(self.impl_file) and exist_comments(self):

- read_comments(self)

- else:

- self.parsed_data['io_signature'] = {

- "input": [],

- "output": []

- }

- self.parsed_data['message_port'] = self.parsed_data['io_signature']

-

- # make

- try:

- self.parsed_data['make'] = {}

- self.parsed_data['make']['arguments'] = []

- query_m = declarations.custom_matcher_t(

- lambda mem_fun: mem_fun.name.startswith('make'))

- query_make = query_m & declarations.access_type_matcher_t('public')

- make_func = main_class.member_functions(function=query_make,

- allow_empty=True,

- header_file=self.target_file)

- criteria = declarations.calldef_matcher(name='make')

- _make_fun = declarations.matcher.get_single(criteria, main_class)

- _make_fun = str(_make_fun).split(

- 'make')[-1].split(')')[0].split('(')[1].lstrip().rstrip().split(',')

- if make_func:

- for arg in make_func[0].arguments:

- for _arg in _make_fun:

- if str(arg.name) in _arg:

- make_arguments = {

- "name": str(arg.name),

- "dtype": str(arg.decl_type),

- "default": ""

- }

- if re.findall(r'[-+]?\d*\.\d+|\d+', _arg):

- make_arguments['default'] = re.findall(

- r'[-+]?\d*\.\d+|\d+', _arg)[0]

- elif re.findall(r'\"(.+?)\"', _arg):

- make_arguments['default'] = re.findall(

- r'\"(.+?)\"', _arg)[0]

- elif "true" in _arg:

- make_arguments['default'] = "True"

- elif "false" in _arg:

- make_arguments['default'] = "False"

- self.parsed_data['make']['arguments'].append(

- make_arguments.copy())

- except RuntimeError:

- self.parsed_data['make'] = {}

- self.parsed_data['make']['arguments'] = []

-

- # setters

- try:

- self.parsed_data['methods'] = []

- query_methods = declarations.access_type_matcher_t('public')

- setters = main_class.member_functions(function=query_methods,

- allow_empty=True,

- header_file=self.target_file)

- getter_arguments = []

- if setters:

- for setter in setters:

- if str(setter.name).startswith('set_') and setter.arguments:

- setter_args = {

- "name": str(setter.name),

- "arguments_type": []

- }

- for argument in setter.arguments:

- args = {

- "name": str(argument.name),

- "dtype": str(argument.decl_type)

- }

- getter_arguments.append(args['name'])

- setter_args['arguments_type'].append(args.copy())

- self.parsed_data['methods'].append(setter_args.copy())

- except RuntimeError:

- self.parsed_data['methods'] = []

-

- # getters

- try:

- self.parsed_data['properties'] = []

- query_properties = declarations.access_type_matcher_t('public')

- getters = main_class.member_functions(function=query_properties,

- allow_empty=True,

- header_file=self.target_file)

- if getters:

- for getter in getters:

- if not getter.arguments or getter.has_const:

- getter_args = {

- "name": str(getter.name),

- "dtype": str(getter.return_type),

- "read_only": True

- }

- if getter_args['name'] in getter_arguments:

- getter_args["read_only"] = False

- self.parsed_data['properties'].append(

- getter_args.copy())

- except RuntimeError:

- self.parsed_data['properties'] = []

-

- # documentation

- try:

- _index = None

- header_file = codecs.open(self.target_file, 'r', 'cp932')

- self.parsed_data['docstring'] = re.compile(

- r'//.*?$|/\*.*?\*/', re.DOTALL | re.MULTILINE).findall(

- header_file.read())[2:]

- header_file.close()

- for doc in self.parsed_data['docstring']:

- if Constants.BLOCKTOOL in doc:

- _index = self.parsed_data['docstring'].index(doc)

- if _index is not None:

- self.parsed_data['docstring'] = self.parsed_data['docstring'][: _index]

- except:

- self.parsed_data['docstring'] = []

-

- return self.parsed_data

-

- def run_blocktool(self):

- """ Run, run, run. """

- self.get_header_info()

-gr_blocktool: Block Header parsing tool.

-Parses GNU Radio header files to generate YAML or JSON output.

-

-This directory consists of test for the parsed header output and Blocktool Exceptions.

-============================================================================================

-- Schema defined in the test will be strictly followed for every parsed JSON output file.

-

-Two sample response for header files are available in this directory:

-=====================================================================

-

-- sample_agc2_cc.json for public header file agc2_cc.h from gr-analog directory.

-- sample_additive_scrambler_bb.json for public header file additive_scrambler_bb.h from gr-digital directory. \ No newline at end of file

-{

- "namespace": [

- "gr",

- "analog"

- ],

- "class": "agc2_cc",

- "io_signature": {

- "input": {

- "signature": "make",

- "min_streams": "1",

- "max_streams": "1",

- "sizeof_stream_item": "sizeof(gr_complex)"

- },

- "output": {

- "signature": "make",

- "min_streams": "1",

- "max_streams": "1",

- "sizeof_stream_item": "sizeof(gr_complex)"

- }

- },

- "message_port": {

- "input": [],

- "output": []

- },

- "make": {

- "arguments": [

- {

- "name": "attack_rate",

- "dtype": "float",

- "default": "0.10000000000000001"

- },

- {

- "name": "decay_rate",

- "dtype": "float",

- "default": "0.01"

- },

- {

- "name": "reference",

- "dtype": "float",

- "default": "1"

- },

- {

- "name": "gain",

- "dtype": "float",

- "default": "1"

- }

- ]

- },

- "methods": [

- {

- "name": "set_attack_rate",

- "arguments_type": [

- {

- "name": "rate",

- "dtype": "float"

- }

- ]

- },

- {

- "name": "set_decay_rate",

- "arguments_type": [

- {

- "name": "rate",

- "dtype": "float"

- }

- ]

- },

- {

- "name": "set_reference",

- "arguments_type": [

- {

- "name": "reference",

- "dtype": "float"

- }

- ]

- },

- {

- "name": "set_gain",

- "arguments_type": [

- {

- "name": "gain",

- "dtype": "float"

- }

- ]

- },

- {

- "name": "set_max_gain",

- "arguments_type": [

- {

- "name": "max_gain",

- "dtype": "float"

- }

- ]

- }

- ],

- "properties": [

- {

- "name": "attack_rate",

- "dtype": "float",

- "read_only": true

- },

- {

- "name": "decay_rate",

- "dtype": "float",

- "read_only": true

- },

- {

- "name": "reference",

- "dtype": "float",

- "read_only": false

- },

- {

- "name": "gain",

- "dtype": "float",

- "read_only": false

- },

- {

- "name": "max_gain",

- "dtype": "float",

- "read_only": false

- }

- ],

- "docstring": [

- "/*!\n * \\brief high performance Automatic Gain Control class with\n * attack and decay rates.\n * \\ingroup level_controllers_blk\n *\n * \\details\n * For Power the absolute value of the complex number is used.\n */",

- "// gr::analog::agc2_cc::sptr",

- "/*!\n * Build a complex value AGC loop block with attack and decay rates.\n *\n * \\param attack_rate the update rate of the loop when in attack mode.\n * \\param decay_rate the update rate of the loop when in decay mode.\n * \\param reference reference value to adjust signal power to.\n * \\param gain initial gain value.\n */",

- "/* namespace analog */",

- "/* namespace gr */",

- "/* INCLUDED_ANALOG_AGC2_CC_H */"

- ]

-} \ No newline at end of file

-{

- "namespace": [

- "gr",

- "digital"

- ],

- "class": "additive_scrambler_bb",

- "io_signature": {

- "input": {

- "signature": "make",

- "min_streams": "1",

- "max_streams": "1",

- "sizeof_stream_item": "sizeof(unsigned char)"

- },

- "output": {

- "signature": "make",

- "min_streams": "1",

- "max_streams": "1",

- "sizeof_stream_item": "sizeof(unsigned char)"

- }

- },

- "message_port": {

- "input": [],

- "output": []

- },

- "make": {

- "arguments": [

- {

- "name": "mask",

- "dtype": "int",

- "default": ""

- },

- {

- "name": "seed",

- "dtype": "int",

- "default": ""

- },

- {

- "name": "len",

- "dtype": "int",

- "default": ""

- },

- {

- "name": "count",

- "dtype": "int",

- "default": "0"

- },

- {

- "name": "bits_per_byte",

- "dtype": "int",

- "default": "1"

- },

- {

- "name": "reset_tag_key",

- "dtype": "std::string const &",

- "default": ""

- }

- ]

- },

- "methods": [],

- "properties": [

- {

- "name": "mask",

- "dtype": "int",

- "read_only": true

- },

- {

- "name": "seed",

- "dtype": "int",

- "read_only": true

- },

- {

- "name": "len",

- "dtype": "int",

- "read_only": true

- },

- {

- "name": "count",

- "dtype": "int",

- "read_only": true

- },

- {

- "name": "bits_per_byte",

- "dtype": "int",

- "read_only": true

- }

- ],

- "docstring": [

- "/*!\n * \\ingroup coding_blk\n *\n * \\brief\n * Scramble an input stream using an LFSR.\n *\n * \\details\n * This block scrambles up to 8 bits per byte of the input\n * data stream, starting at the LSB.\n *\n * The scrambler works by XORing the incoming bit stream by the\n * output of the LFSR. Optionally, after \\p count bits have been\n * processed, the shift register is reset to the \\p seed value.\n * This allows processing fixed length vectors of samples.\n *\n * Alternatively, the LFSR can be reset using a reset tag to\n * scramble variable length vectors. However, it cannot be reset\n * between bytes.\n *\n * For details on configuring the LFSR, see gr::digital::lfsr.\n */",

- "// gr::digital::additive_scrambler_bb::sptr",

- "/*!\n * \\brief Create additive scrambler.\n *\n * \\param mask Polynomial mask for LFSR\n * \\param seed Initial shift register contents\n * \\param len Shift register length\n * \\param count Number of bytes after which shift register is reset, 0=never\n * \\param bits_per_byte Number of bits per byte\n * \\param reset_tag_key When a tag with this key is detected, the shift register is reset (when this is set, count is ignored!)\n */",

- "/* namespace digital */",

- "/* namespace gr */",

- "/* INCLUDED_DIGITAL_ADDITIVE_SCRAMBLER_BB_H */"

- ]

-} \ No newline at end of file

-id: analog_agc2_cc

-label: AGC2

-category: '[Analog]'

-flags: '[python, cpp]'

-templates:

- imports: from gnuradio import analog

- make: analog.agc2_cc(${attack_rate}, ${decay_rate}, ${reference}, ${gain}, ${max_gain})

- callbacks: !!python/tuple

- - set_attack_rate(${rate})

- - set_decay_rate(${rate})

- - set_reference(${reference})

- - set_gain(${gain})

- - set_max_gain(${max_gain})

-parameters:

-- id: attack_rate

- label: Attack_rate

- dtype: float

- read_only: true

-- id: decay_rate

- label: Decay_rate

- dtype: float

- read_only: true

-- id: reference

- label: Reference

- dtype: float

- read_only: false

-- id: gain

- label: Gain

- dtype: float

- read_only: false

-- id: max_gain

- label: Max_gain

- dtype: float

- read_only: false

-inputs:

-- domain: stream

- dtype: sizeof(gr_complex)

-outputs:

-- domain: stream

- dtype: sizeof(gr_complex)

-cpp_templates:

- includes: '#include <gnuradio/analog/agc2_cc.h>'

- declartions: analog::agc2_cc::sptr ${id}

- make: this->${id} = analog::agc2_cc::make(${attack_rate}, ${decay_rate}, ${reference},

- ${gain}, ${max_gain})

- callbacks: !!python/tuple

- - set_attack_rate(${rate})

- - set_decay_rate(${rate})

- - set_reference(${reference})

- - set_gain(${gain})

- - set_max_gain(${max_gain})

- link: gnuradio-analog

-documentation:

-- "/*!\n * \\brief high performance Automatic Gain Control class with\n *

- attack and decay rates.\n * \\ingroup level_controllers_blk\n *\n *

- \\details\n * For Power the absolute value of the complex number is used.\n

- \ */"

-- // gr::analog::agc2_cc::sptr

-- "/*!\n * Build a complex value AGC loop block with attack and decay rates.\n

- \ *\n * \\param attack_rate the update rate of the loop when in attack

- mode.\n * \\param decay_rate the update rate of the loop when in decay mode.\n

- \ * \\param reference reference value to adjust signal power to.\n *

- \\param gain initial gain value.\n */"

-- /* namespace analog */

-- /* namespace gr */

-- /* INCLUDED_ANALOG_AGC2_CC_H */

-file_format: 1

-id: digital_additive_scrambler_bb

-label: ADDITIVE SCRAMBLER

-category: '[Digital]'

-flags: '[python, cpp]'

-templates:

- imports: from gnuradio import digital

- make: digital.additive_scrambler_bb(${mask}, ${seed}, ${len}, ${count}, ${bits_per_byte})

-parameters:

-- id: mask

- label: Mask

- dtype: int

- read_only: true

-- id: seed

- label: Seed

- dtype: int

- read_only: true

-- id: len

- label: Len

- dtype: int

- read_only: true

-- id: count

- label: Count

- dtype: int

- read_only: true

-- id: bits_per_byte

- label: Bits_per_byte

- dtype: int

- read_only: true

-inputs:

-- domain: stream

- dtype: sizeof(unsigned char)

-outputs:

-- domain: stream

- dtype: sizeof(unsigned char)

-cpp_templates:

- includes: '#include <gnuradio/digital/additive_scrambler_bb.h>'

- declartions: digital::additive_scrambler_bb::sptr ${id}

- make: this->${id} = digital::additive_scrambler_bb::make(${mask}, ${seed}, ${len},

- ${count}, ${bits_per_byte})

- link: gnuradio-digital

-documentation:

-- "/*!\n * \\ingroup coding_blk\n *\n * \\brief\n * Scramble an input

- stream using an LFSR.\n *\n * \\details\n * This block scrambles up

- to 8 bits per byte of the input\n * data stream, starting at the LSB.\n *\n

- \ * The scrambler works by XORing the incoming bit stream by the\n * output

- of the LFSR. Optionally, after \\p count bits have been\n * processed, the shift

- register is reset to the \\p seed value.\n * This allows processing fixed length

- vectors of samples.\n *\n * Alternatively, the LFSR can be reset using a

- reset tag to\n * scramble variable length vectors. However, it cannot be reset\n

- \ * between bytes.\n *\n * For details on configuring the LFSR, see gr::digital::lfsr.\n

- \ */"

-- // gr::digital::additive_scrambler_bb::sptr

-- "/*!\n * \\brief Create additive scrambler.\n *\n * \\param mask

- \ Polynomial mask for LFSR\n * \\param seed Initial shift register contents\n

- \ * \\param len Shift register length\n * \\param count Number of

- bytes after which shift register is reset, 0=never\n * \\param bits_per_byte

- Number of bits per byte\n * \\param reset_tag_key When a tag with this key

- is detected, the shift register is reset (when this is set, count is ignored!)\n

- \ */"

-- /* namespace digital */

-- /* namespace gr */

-- /* INCLUDED_DIGITAL_ADDITIVE_SCRAMBLER_BB_H */

-file_format: 1

-#

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" unittest for gr-blocktool api """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import unittest

-import warnings

-try:

- import pygccxml

- SKIP_BLOCK_TEST = False

-except:

- SKIP_BLOCK_TEST = True

-

-try:

- import apt

- CACHE = apt.cache.Cache()

- CACHE.open()

-

- PKG = CACHE['castxml']

- if PKG.is_installed:

- SKIP_BLOCK_TEST = False

- else:

- SKIP_BLOCK_TEST = True

-except:

- SKIP_BLOCK_TEST = True

-

-from jsonschema import validate

-

-from blocktool import BlockHeaderParser

-from blocktool.core.base import BlockToolException

-from blocktool.core import Constants

-from blocktool import RESULT_SCHEMA

-

-

-class TestBlocktoolCore(unittest.TestCase):

- """ The Tests for blocktool core """

-

- def __init__(self, *args, **kwargs):

- super(TestBlocktoolCore, self).__init__(*args, **kwargs)

- self.module = os.path.abspath(os.path.join(os.path.dirname(__file__),

- '../../../../gr-analog'))

- self.test_dir = os.path.abspath(os.path.join(self.module,

- 'include/gnuradio/analog'))

-

- def is_int(self, number):

- """

- Check for int conversion

- """

- try:

- int(number)

- return True

- except ValueError:

- return False

-

- @classmethod

- def setUpClass(cls):

- """ create a temporary Blocktool object """

- try:

- warnings.simplefilter("ignore", ResourceWarning)

- except NameError:

- pass

- test_path = {}

- target_file = os.path.abspath(os.path.join(os.path.dirname(

- __file__), '../../../../gr-analog/include/gnuradio/analog', 'agc2_cc.h'))

- test_path['file_path'] = target_file

- cls.test_obj = BlockHeaderParser(**test_path).get_header_info()

-

- @unittest.skipIf(SKIP_BLOCK_TEST, 'pygccxml not found, skipping this unittest')

- def test_blocktool_exceptions(self):

- """

- tests for blocktool exceptions

- """

- # test for non-existent header or invalid headers

- test_dict = {}

- test_dict['file_path'] = os.path.abspath(

- os.path.join(self.test_dir, 'sample.h'))

- with self.assertRaises(BlockToolException):

- BlockHeaderParser(**test_dict).run_blocktool()

- # test for invalid header file

- test_dict['file_path'] = os.path.abspath(

- os.path.join(self.test_dir, 'CMakeLists.txt'))

- if not os.path.basename(test_dict['file_path']).endswith('.h'):

- with self.assertRaises(BlockToolException):

- BlockHeaderParser(**test_dict).run_blocktool()

-

- @unittest.skipIf(SKIP_BLOCK_TEST, 'pygccxml not found, skipping this unittest')

- def test_namespace(self):

- """ test for header namespace """

- module_name = os.path.basename(self.module)

- self.assertTrue(self.test_obj['namespace'][0] == 'gr')

- self.assertTrue(self.test_obj['namespace']

- [1] == module_name.split('-')[-1])

-

- @unittest.skipIf(SKIP_BLOCK_TEST, 'pygccxml not found, skipping this unittest')

- def test_io_signature(self):

- """ test for io_signature """

- input_signature = self.test_obj['io_signature']['input']['signature']

- output_signature = self.test_obj['io_signature']['output']['signature']

- valid_signature = False

- if input_signature and output_signature in Constants.SIGNATURE_LIST:

- valid_signature = True

- self.assertTrue(valid_signature)

- valid_io_stream = False

- input_max = self.test_obj['io_signature']['input']['max_streams']

- input_min = self.test_obj['io_signature']['input']['min_streams']

- output_max = self.test_obj['io_signature']['output']['max_streams']

- output_min = self.test_obj['io_signature']['output']['min_streams']

- if self.is_int(input_max) and self.is_int(input_min) and self.is_int(output_max) and self.is_int(output_min):

- valid_io_stream = True

- self.assertTrue(valid_io_stream)

-

- @unittest.skipIf(SKIP_BLOCK_TEST, 'pygccxml not found, skipping this unittest')

- def test_message_port(self):

- """ test for message ports """

- input_port = self.test_obj['message_port']['input']

- output_port = self.test_obj['message_port']['output']

- valid_input_message_port = True

- valid_output_message_port = True

- if input_port:

- for port in input_port:

- if not port['id']:

- valid_input_message_port = False

- if output_port:

- for port in output_port:

- if not port['id']:

- valid_output_message_port = False

- self.assertTrue(valid_input_message_port)

- self.assertTrue(valid_output_message_port)

-

- @unittest.skipIf(SKIP_BLOCK_TEST, 'pygccxml not found, skipping this unittest')

- def test_factory_signature(self):

- """ test for factory signature in the header """

- valid_factory_arg = True

- if self.test_obj['make']['arguments']:

- for arguments in self.test_obj['make']['arguments']:

- if not arguments['name'] or not arguments['dtype']:

- valid_factory_arg = False

- self.assertTrue(valid_factory_arg)

-

- @unittest.skipIf(SKIP_BLOCK_TEST, 'pygccxml not found, skipping this unittest')

- def test_methods(self):

- """ test for methods """

- valid_method = True

- if self.test_obj['methods']:

- for arguments in self.test_obj['methods']:

- if not arguments['name']:

- valid_method = False

- if arguments['arguments_type']:

- for args in arguments['arguments_type']:

- if not args['name'] or not args['dtype']:

- valid_method = False

- self.assertTrue(valid_method)

-

- @unittest.skipIf(SKIP_BLOCK_TEST, 'pygccxml not found, skipping this unittest')

- def test_properties(self):

- """ test for properties """

- valid_properties = True

- if self.test_obj['properties']:

- for arguments in self.test_obj['properties']:

- if not arguments['name'] or not arguments['dtype']:

- valid_properties = False

- self.assertTrue(valid_properties)

-

- @unittest.skipIf(SKIP_BLOCK_TEST, 'pygccxml not found, skipping this unittest')

- def test_result_format(self):

- """ test for parsed blocktool output format """

- valid_schema = False

- try:

- validate(instance=self.test_obj, schema=RESULT_SCHEMA)

- valid_schema = True

- except BlockToolException:

- raise BlockToolException

- self.assertTrue(valid_schema)

-

-

-if __name__ == '__main__':

- unittest.main()

-#

-# Copyright 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" testing the JSON files generated by gr-blocktool """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import sys

-import json

-import jsonschema

-

-from blocktool import RESULT_SCHEMA

-

-

-def is_valid():

- """ Validate json file """

-

- with open(sys.argv[1], 'r') as json_file:

- data = json.load(json_file)

- try:

- print("Validating...")

- jsonschema.validate(data, RESULT_SCHEMA)

- except jsonschema.ValidationError as exception:

- print("Record JSON file # {}: NOT OK".format(sys.argv[1]))

- raise Exception(exception)

- else:

- print("Record JSON file # {}: OK".format(sys.argv[1]))

-

-

-if __name__ == '__main__':

- if len(sys.argv) == 2:

- is_valid()

- else:

- raise Exception('Please input only one json file')

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-GR_PYTHON_INSTALL(FILES

- __init__.py

- DESTINATION ${GR_PYTHON_DIR}/gnuradio/modtool

-)

-

-set(GR_PKG_MODTOOL_DATA_DIR ${GR_PKG_DATA_DIR}/modtool/templates)

-

-

-########################################################################

-# Create and install the modtool conf file

-########################################################################

-file(TO_NATIVE_PATH ${CMAKE_INSTALL_PREFIX}/${GR_PKG_MODTOOL_DATA_DIR}/gr-newmod newmoddir)

-

-configure_file(

- ${CMAKE_CURRENT_SOURCE_DIR}/modtool.conf.in

- ${CMAKE_CURRENT_BINARY_DIR}/modtool.conf

-@ONLY)

-

-install(

- FILES ${CMAKE_CURRENT_BINARY_DIR}/modtool.conf

- DESTINATION ${GR_PREFSDIR}

-)

-

-########################################################################

-# Add subdirectories

-########################################################################

-add_subdirectory(core)

-add_subdirectory(cli)

-add_subdirectory(tools)

-add_subdirectory(templates)

-add_subdirectory(tests)

-gr_modtool: Swiss Army Knife for editing GNU Radio modules and -components.

-

-Adding a new subcommand for Command Line Interface

-==================================================

-

-* Add a new file called SUBCOMMAND in the cli directory

-* Create a function cli with the decorator @click.command or @click.group

-* Add the necessary options for the command or command group

-* Add that file to __init__.py and CMakeLists.txt in the cli directory

-

-

-Adding a new subcommand for Exposing as an API

-==============================================

-

-* Add a new file called SUBCOMMAND in the core directory

-* Have a look at the other subcommands, it must inherit from ModTool

-* Add that file to __init__.py and CMakeLists.txt in the core directory

-

-

-The gr-newmod directory inside the templates directory

-======================================================

-

-This dir basically contains a copy of gr-howto-write-a-block from the gnuradio

-sources, with some differences:

-- All example blocks, apps, grc files (...) and references thereto in the

- CMake files are removed

-- In the top-level CMake file, the project is called 'gr-howto'.

-- Any time anything relevant is changed in gr-howto-write-a-block, it should

- be changed here, too.

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-include(GrPython)

-

-GR_PYTHON_INSTALL(FILES

- __init__.py

- add.py

- base.py

- disable.py

- info.py

- makeyaml.py

- newmod.py

- rm.py

- rename.py

- update.py

- DESTINATION ${GR_PYTHON_DIR}/gnuradio/modtool/cli

-)

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-from .base import cli, common_params, block_name, ModToolException

-from .base import setup_cli_logger, cli_input

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Module to add new blocks """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import re

-import getpass

-

-import click

-

-from ..core import ModToolAdd

-from ..tools import SequenceCompleter, ask_yes_no

-from .base import common_params, block_name, run, cli_input, ModToolException

-

-

-@click.command('add')

-@click.option('-t', '--block-type', type=click.Choice(ModToolAdd.block_types),

- help="One of {}.".format(', '.join(ModToolAdd.block_types)))

-@click.option('--license-file',

- help="File containing the license header for every source code file.")

-@click.option('--copyright',

- help="Name of the copyright holder (you or your company) MUST be a quoted string.")

-@click.option('--argument-list', default="",

- help="The argument list for the constructor and make functions.")

-@click.option('--add-python-qa', is_flag=True, default=None,

- help="If given, Python QA code is automatically added if possible.")

-@click.option('--add-cpp-qa', is_flag=True, default=None,

- help="If given, C++ QA code is automatically added if possible.")

-@click.option('--skip-cmakefiles', is_flag=True,

- help="If given, only source files are written, but CMakeLists.txt files are left unchanged.")

-@click.option('-l', '--lang', type=click.Choice(ModToolAdd.language_candidates),

- help="Programming Language")

-@common_params

-@block_name

-def cli(**kwargs):

- """Adds a block to the out-of-tree module."""

- kwargs['cli'] = True

- self = ModToolAdd(**kwargs)

- click.secho("GNU Radio module name identified: " + self.info['modname'], fg='green')

- get_blocktype(self)

- get_lang(self)

- click.secho("Language: {}".format({'cpp': 'C++', 'python': 'Python'}[self.info['lang']]), fg='green')

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

- get_blockname(self)

- click.secho("Block/code identifier: " + self.info['blockname'], fg='green')

- self.info['fullblockname'] = self.info['modname'] + '_' + self.info['blockname']

- if not self.license_file:

- get_copyrightholder(self)

- self.info['license'] = self.setup_choose_license()

- get_arglist(self)

- get_py_qa(self)

- get_cpp_qa(self)

- if self.info['version'] == 'autofoo' and not self.skip_cmakefiles:

- click.secho("Warning: Autotools modules are not supported. "+

- "Files will be created, but Makefiles will not be edited.",

- fg='yellow')

- self.skip_cmakefiles = True

- run(self)

-

-def get_blocktype(self):

- """ Get the blocktype of the block to be added """

- if self.info['blocktype'] is None:

- click.secho(str(self.block_types), fg='yellow')

- with SequenceCompleter(self.block_types):

- while self.info['blocktype'] not in self.block_types:

- self.info['blocktype'] = cli_input("Enter block type: ")

- if self.info['blocktype'] not in self.block_types:

- click.secho('Must be one of ' + str(self.block_types), fg='yellow')

-

-def get_lang(self):

- """ Get the Programming Language of the block to be added """

- if self.info['lang'] is None:

- with SequenceCompleter(self.language_candidates):

- while self.info['lang'] not in self.language_candidates:

- self.info['lang'] = cli_input("Language (python/cpp): ")

- if self.info['lang'] == 'c++':

- self.info['lang'] = 'cpp'

-

-def get_blockname(self):

- """ Get the blockname"""

- if not self.info['blockname'] or self.info['blockname'].isspace():

- while not self.info['blockname'] or self.info['blockname'].isspace():

- self.info['blockname'] = cli_input("Enter name of block/code (without module name prefix): ")

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

- raise ModToolException('Invalid block name.')

-

-def get_copyrightholder(self):

- """ Get the copyrightholder of the block to be added """

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

- user = getpass.getuser()

- git_user = self.scm.get_gituser()

- if git_user:

- copyright_candidates = (user, git_user, 'GNU Radio')

- else:

- copyright_candidates = (user, 'GNU Radio')

- with SequenceCompleter(copyright_candidates):

- self.info['copyrightholder'] = cli_input("Please specify the copyright holder: ")

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

- self.info['copyrightholder'] = "gr-{} author".format(self.info['modname'])

- elif self.info['is_component']:

- click.secho("For GNU Radio components the FSF is added as copyright holder",

- fg='cyan')

-

-def get_arglist(self):

- """ Get the argument list of the block to be added """

- if self.info['arglist'] is not None:

- self.info['arglist'] = click.prompt(click.style(

- 'Enter valid argument list, including default arguments: \n',

- fg='cyan'),

- prompt_suffix='',

- default='',

- show_default=False)

-

-def get_py_qa(self):

- """ Get a boolean value for addition of py_qa """

- if self.add_py_qa is None:

- if not (self.info['blocktype'] in ('noblock') or self.skip_subdirs['python']):

- self.add_py_qa = ask_yes_no(click.style('Add Python QA code?', fg='cyan'), True)

- else:

- self.add_py_qa = False

-

-def get_cpp_qa(self):

- """ Get a boolean value for addition of cpp_qa """

- if self.add_cc_qa is None:

- if self.info['lang'] == 'cpp':

- self.add_cc_qa = ask_yes_no(click.style('Add C++ QA code?', fg='cyan'),

- not self.add_py_qa)

- else:

- self.add_cc_qa = False

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Base CLI module """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import sys

-import logging

-import functools

-from importlib import import_module

-from pkg_resources import iter_entry_points

-from logging import Formatter, StreamHandler

-

-import click

-from click import ClickException

-from click_plugins import with_plugins

-

-from gnuradio import gr

-

-

-class ModToolException(ClickException):

- """ Exception class for enhanced CLI interface """

- def show(self, file = None):

- """ displays the colored message """

- click.secho('ModToolException: {}'.format(self.format_message()), fg='red')

-

-

-class CommandCLI(click.Group):

- """

- This is a derived class of the implemented click class

- which overrides some of the functional definitions for external

- plug-in support

- """

- cmd_folder = os.path.abspath(os.path.dirname(__file__))

-

- def list_commands(self, ctx):

- """

- Lists all the commands available in the modtool directory

- as well as the commands from external plug-ins.

- """

- cmds = []

- for filename in os.listdir(self.cmd_folder):

- if filename.endswith('.py') and not '_' in filename:

- cmds.append(filename[:-3])

- cmds.remove('base')

- cmds += self.commands

- return sorted(cmds)

-

- def get_command(self, ctx, cmd_name):

- """

- Returns a command object if it exists. The existing in-tree ModTool

- command is the priority over the same external plug-in command.

- """

- try:

- mod = import_module('gnuradio.modtool.cli.' + cmd_name)

- except ImportError:

- logging.error(ImportError)

- return self.commands.get(cmd_name)

- return mod.cli

-

-

-class ClickHandler(StreamHandler):

- """

- This is a derived class of implemented logging class

- StreamHandler which overrides some of its functional

- definitions to add colors to the stream output

- """

- def emit(self, record):

- """ Writes message to the stream """

- colormap = {

- 'DEBUG': ('white', 'black'),

- 'INFO': ('blue', None),

- 'WARNING': ('yellow', None),

- 'ERROR': ('red', None),

- 'CRITICAL': ('white', 'red'),

- }

- try:

- msg = self.format(record)

- colors = colormap.get(record.levelname, (None, None))

- fgcolor = colors[0]

- bgcolor = colors[1]

- click.secho(msg, fg=fgcolor, bg=bgcolor)

- self.flush()

- except Exception:

- self.handleError(record)

-

-

-def setup_cli_logger(logger):

- """ Sets up logger for CLI parsing """

- try:

- import colorama

- stream_handler = ClickHandler()

- logger.addHandler(stream_handler)

- except ImportError:

- stream_handler = logging.StreamHandler()

- logger.addHandler(stream_handler)

- finally:

- logger.setLevel(logging.INFO)

-

-

-def cli_input(msg):

- """ Returns enhanced input """

- return input(click.style(msg, fg='cyan'))

-

-

-def common_params(func):

- """ Common parameters for various modules"""

- @click.option('-d', '--directory', default='.',

- help="Base directory of the module. Defaults to the cwd.")

- @click.option('--skip-lib', is_flag=True,

- help="Don't do anything in the lib/ subdirectory.")

- @click.option('--skip-swig', is_flag=True,

- help="Don't do anything in the swig/ subdirectory.")

- @click.option('--skip-python', is_flag=True,

- help="Don't do anything in the python/ subdirectory.")

- @click.option('--skip-grc', is_flag=True,

- help="Don't do anything in the grc/ subdirectory.")

- @click.option('--scm-mode', type=click.Choice(['yes', 'no', 'auto']),

- default=gr.prefs().get_string('modtool', 'scm_mode', 'no'),

- help="Use source control management [ yes | no | auto ]).")

- @click.option('-y', '--yes', is_flag=True,

- help="Answer all questions with 'yes'. " +

- "This can overwrite and delete your files, so be careful.")

- @functools.wraps(func)

- def wrapper(*args, **kwargs):

- """ Decorator that wraps common options """

- return func(*args, **kwargs)

- return wrapper

-

-

-block_name = click.argument('blockname', nargs=1, required=False, metavar="BLOCK_NAME")

-

-

-@with_plugins(iter_entry_points('gnuradio.modtool.cli.plugins'))

-@click.command(cls=CommandCLI,

- epilog='Manipulate with GNU Radio modules source code tree. ' +

- 'Call it without options to run specified command interactively')

-def cli():

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

- pass

-

-

-def run(module):

- """Call the run function of the core modules."""

- try:

- module.run()

- except ModToolException as err:

- click.echo(err, file=sys.stderr)

- exit(1)

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Disable blocks module """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import click

-

-from ..core import get_block_candidates, ModToolDisable

-from ..tools import SequenceCompleter

-from .base import common_params, block_name, run, cli_input

-

-

-@click.command('disable', short_help=ModToolDisable.description)

-@common_params

-@block_name

-def cli(**kwargs):

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

- kwargs['cli'] = True

- self = ModToolDisable(**kwargs)

- click.secho("GNU Radio module name identified: " + self.info['modname'], fg='green')

- get_pattern(self)

- run(self)

-

-def get_pattern(self):

- """ Get the regex pattern for block(s) to be disabled """

- if self.info['pattern'] is None:

- block_candidates = get_block_candidates()

- with SequenceCompleter(block_candidates):

- self.info['pattern'] = cli_input('Which blocks do you want to disable? (Regex): ')

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

- self.info['pattern'] = '.'

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Returns information about a module """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import click

-

-from ..core import ModToolInfo

-from .base import common_params, run

-

-

-@click.command('info')

-@click.option('--python-readable', is_flag=True,

- help="Return the output in a format that's easier to read for Python scripts.")

-@click.option('--suggested-dirs',

- help="Suggest typical include dirs if nothing better can be detected.")

-@common_params

-def cli(**kwargs):

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

- self = ModToolInfo(**kwargs)

- run(self)

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Automatically create YAML bindings for GRC from block code """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import click

-

-try:

- from gnuradio.blocktool import BlockHeaderParser

- from gnuradio.blocktool.core.base import BlockToolException

-except ImportError:

- have_blocktool = False

-else:

- have_blocktool = True

-

-from ..core import get_block_candidates, ModToolMakeYAML, yaml_generator

-from ..tools import SequenceCompleter

-from .base import common_params, block_name, run, cli_input

-

-

-@click.command('makeyaml', short_help=ModToolMakeYAML.description)

-@click.option('-b', '--blocktool', is_flag=True,

- help='Use blocktool support to print yaml output. FILE PATH mandatory if used.')

-@click.option('-o', '--output', is_flag=True,

- help='If given, a file with desired output format will be generated')

-@common_params

-@block_name

-def cli(**kwargs):

- """

- \b

- Make an YAML file for GRC block bindings

-

- Note: This does not work on python blocks

- """

- kwargs['cli'] = True

- if kwargs['blocktool']:

- kwargs['modtool'] = True

- if kwargs['blockname'] is None:

- raise BlockToolException('Missing argument FILE PATH with blocktool flag')

- kwargs['file_path'] = os.path.abspath(kwargs['blockname'])

- if os.path.isfile(kwargs['file_path']):

- parse_yml = BlockHeaderParser(**kwargs)

- parse_yml.run_blocktool()

- parse_yml.cli = True

- parse_yml.yaml = True

- yaml_generator(parse_yml, **kwargs)

- else:

- raise BlockToolException('Invalid file path.')

- else:

- self = ModToolMakeYAML(**kwargs)

- click.secho("GNU Radio module name identified: " + self.info['modname'], fg='green')

- get_pattern(self)

- run(self)

-

-def get_pattern(self):

- """ Get the regex pattern for block(s) to be parsed """

- if self.info['pattern'] is None:

- block_candidates = get_block_candidates()

- with SequenceCompleter(block_candidates):

- self.info['pattern'] = cli_input('Which blocks do you want to parse? (Regex): ')

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

- self.info['pattern'] = '.'

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

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

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import re

-import os

-

-import click

-

-from gnuradio import gr

-from ..core import ModToolNewModule

-from .base import common_params, run, cli_input, ModToolException

-

-@click.command('newmod', short_help=ModToolNewModule.description)

-@click.option('--srcdir',

- help="Source directory for the module template.")

-@common_params

-@click.argument('module_name', metavar="MODULE-NAME", nargs=1, required=False)

-def cli(**kwargs):

- """

- \b

- Create a new out-of-tree module

-

- The argument MODULE-NAME is the name of the module to be added.

- """

- kwargs['cli'] = True

- self = ModToolNewModule(**kwargs)

- get_modname(self)

- self.dir = os.path.join(self.dir, 'gr-{}'.format(self.info['modname']))

- try:

- os.stat(self.dir)

- except OSError:

- pass # This is what should happen

- else:

- raise ModToolException('The given directory exists.')

- if self.srcdir is None:

- self.srcdir = os.path.join(gr.prefix(),'share','gnuradio','modtool','templates','gr-newmod')

- if not os.path.isdir(self.srcdir):

- raise ModToolException('Could not find gr-newmod source dir.')

- run(self)

-

-def get_modname(self):

- """ Get the name of the new module to be added """

- if self.info['modname'] is None:

- while not self.info['modname'] or self.info['modname'].isspace():

- self.info['modname'] = cli_input('Name of the new module: ')

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

- raise ModToolException('Invalid module name.')

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Module to rename blocks """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import re

-

-import click

-

-from ..core import get_block_candidates, ModToolRename

-from ..tools import SequenceCompleter

-from .base import common_params, block_name, run, cli_input, ModToolException

-

-

-@click.command('rename', short_help=ModToolRename.description)

-@common_params

-@block_name

-@click.argument('new-name', metavar="NEW-BLOCK-NAME", nargs=1, required=False)

-def cli(**kwargs):

- """

- \b

- Rename a block inside a module.

-

- The argument NEW-BLOCK-NAME is the new name of the block.

- """

- kwargs['cli'] = True

- self = ModToolRename(**kwargs)

- click.secho("GNU Radio module name identified: " + self.info['modname'], fg='green')

- # first make sure the old block name is provided

- get_oldname(self)

- click.secho("Block/code to rename identifier: " + self.info['oldname'], fg='green')

- self.info['fulloldname'] = self.info['modname'] + '_' + self.info['oldname']

- # now get the new block name

- get_newname(self)

- click.secho("Block/code identifier: " + self.info['newname'], fg='green')

- self.info['fullnewname'] = self.info['modname'] + '_' + self.info['newname']

- run(self)

-

-def get_oldname(self):

- """ Get the old block name to be replaced """

- block_candidates = get_block_candidates()

- if self.info['oldname'] is None:

- with SequenceCompleter(block_candidates):

- while not self.info['oldname'] or self.info['oldname'].isspace():

- self.info['oldname'] = cli_input("Enter name of block/code to rename "+

- "(without module name prefix): ")

- if self.info['oldname'] not in block_candidates:

- choices = [x for x in block_candidates if self.info['oldname'] in x]

- if len(choices) > 0:

- click.secho("Suggested alternatives: "+str(choices), fg='yellow')

- raise ModToolException("Blockname for renaming does not exists!")

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

- raise ModToolException('Invalid block name.')

-

-def get_newname(self):

- """ Get the new block name """

- if self.info['newname'] is None:

- while not self.info['newname'] or self.info['newname'].isspace():

- self.info['newname'] = cli_input("Enter name of block/code "+

- "(without module name prefix): ")

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

- raise ModToolException('Invalid block name.')

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Remove blocks module """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import click

-

-from ..core import get_block_candidates, ModToolRemove

-from ..tools import SequenceCompleter

-from .base import common_params, block_name, run, cli_input

-

-

-@click.command('remove', short_help=ModToolRemove.description)

-@common_params

-@block_name

-def cli(**kwargs):

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

- kwargs['cli'] = True

- self = ModToolRemove(**kwargs)

- click.secho("GNU Radio module name identified: " + self.info['modname'], fg='green')

- get_pattern(self)

- run(self)

-

-def get_pattern(self):

- """ Returns the regex pattern for block(s) to be removed """

- if self.info['pattern'] is None:

- block_candidates = get_block_candidates()

- with SequenceCompleter(block_candidates):

- self.info['pattern'] = cli_input('Which blocks do you want to delete? (Regex): ')

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

- self.info['pattern'] = '.'

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Module to convert XML bindings to YAML bindings """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import click

-

-from ..core import get_xml_candidates, ModToolUpdate

-from ..tools import SequenceCompleter

-from .base import block_name, run, cli_input, ModToolException

-

-

-@click.command('update', short_help=ModToolUpdate.description)

-@click.option('--complete', is_flag=True, default=None,

- help="Convert all the XML bindings to YAML.")

-@click.option('-I', '--include-blacklisted', is_flag=True, default=None,

- help="Include XML files with blacklisted names in the conversion process")

-@block_name

-def cli(**kwargs):

- """ Update the XML bindings to YAML bindings """

- kwargs['cli'] = True

- self = ModToolUpdate(**kwargs)

- click.secho("GNU Radio module name identified: " + self.info['modname'], fg='green')

- get_blockname(self)

- run(self)

-

-def get_blockname(self):

- """ Returns the blockname for block to be updated """

- if self.info['complete']:

- return

- block_candidates = get_xml_candidates()

- if self.info['blockname'] is None:

- with SequenceCompleter(block_candidates):

- self.info['blockname'] = cli_input('Which block do you wish to update? : ')

- if not self.info['blockname'] or self.info['blockname'].isspace():

- raise ModToolException('Block name not specified!')

- if self.info['blockname'] not in block_candidates:

- choices = [x for x in block_candidates if self.info['blockname'] in x]

- if len(choices) > 0:

- click.secho("Suggested alternatives: "+str(choices), fg='yellow')

- raise ModToolException("The XML bindings does not exists!")

-# Copyright 2011, 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-include(GrPython)

-

-GR_PYTHON_INSTALL(FILES

- __init__.py

- add.py

- base.py

- disable.py

- info.py

- makeyaml.py

- newmod.py

- rm.py

- rename.py

- update.py

- DESTINATION ${GR_PYTHON_DIR}/gnuradio/modtool/core

-)

-#

-# Copyright 2013-2014, 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-from .base import ModTool, ModToolException, get_block_candidates

-from .add import ModToolAdd

-from .disable import ModToolDisable

-from .info import ModToolInfo

-from .makeyaml import ModToolMakeYAML, yaml_generator

-from .newmod import ModToolNewModule

-from .rm import ModToolRemove

-from .rename import ModToolRename

-from .update import ModToolUpdate, get_xml_candidates

-#

-# Copyright 2013-2014,2017-2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Module to add new blocks """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import re

-import logging

-

-from ..tools import render_template, append_re_line_sequence, CMakeFileEditor

-from ..templates import Templates

-from .base import ModTool, ModToolException

-

-logger = logging.getLogger(__name__)

-

-

-class ModToolAdd(ModTool):

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

- name = 'add'

- description = 'Add new block into a module.'

- block_types = ('sink', 'source', 'sync', 'decimator', 'interpolator',

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

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

-

- def __init__(self, blockname=None, block_type=None, lang=None, copyright=None,

- license_file=None, argument_list="", add_python_qa=False,

- add_cpp_qa=False, skip_cmakefiles=False, **kwargs):

- ModTool.__init__(self, blockname, **kwargs)

- self.info['blocktype'] = block_type

- self.info['lang'] = lang

- self.license_file = license_file

- self.info['copyrightholder'] = copyright

- self.info['arglist'] = argument_list

- self.add_py_qa = add_python_qa

- self.add_cc_qa = add_cpp_qa

- self.skip_cmakefiles = skip_cmakefiles

-

- def validate(self):

- """ Validates the arguments """

- ModTool._validate(self)

- if self.info['blocktype'] is None:

- raise ModToolException('Blocktype not specified.')

- if self.info['blocktype'] not in self.block_types:

- raise ModToolException('Invalid blocktype')

- if self.info['lang'] is None:

- raise ModToolException('Programming language not specified.')

- if self.info['lang'] not in self.language_candidates:

- raise ModToolException('Invalid programming language.')

- if self.info['blocktype'] == 'tagged_stream' and self.info['lang'] == 'python':

- raise ModToolException('Tagged Stream Blocks for Python currently unsupported')

- if self.info['blockname'] is None:

- raise ModToolException('Blockname not specified.')

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

- raise ModToolException('Invalid block name.')

- if not isinstance(self.add_py_qa, bool):

- raise ModToolException('Expected a boolean value for add_python_qa.')

- if not isinstance(self.add_cc_qa, bool):

- raise ModToolException('Expected a boolean value for add_cpp_qa.')

- if not isinstance(self.skip_cmakefiles, bool):

- raise ModToolException('Expected a boolean value for skip_cmakefiles.')

-

- def assign(self):

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

- self.info['fullblockname'] = self.info['modname'] + '_' + self.info['blockname']

- if not self.license_file:

- if self.info['copyrightholder'] is None:

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

- self.info['license'] = self.setup_choose_license()

- if (self.info['blocktype'] in ('noblock') or self.skip_subdirs['python']):

- self.add_py_qa = False

- if not self.info['lang'] == 'cpp':

- self.add_cc_qa = False

- if self.info['version'] == 'autofoo' and not self.skip_cmakefiles:

- self.skip_cmakefiles = True

-

- def setup_choose_license(self):

- """ Select a license by the following rules, in this order:

- 1) The contents of the file given by --license-file

- 2) The contents of the file LICENSE or LICENCE in the modules

- top directory

- 3) The default license. """

- if self.license_file is not None \

- and os.path.isfile(self.license_file):

- with open(self.license_file) as f:

- return f.read()

- elif os.path.isfile('LICENSE'):

- with open('LICENSE') as f:

- return f.read()

- elif os.path.isfile('LICENCE'):

- with open('LICENCE') as f:

- return f.read()

- elif self.info['is_component']:

- return Templates['grlicense']

- else:

- return Templates['defaultlicense'].format(**self.info)

-

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

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

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

- logger.info("Adding file '{}'...".format(path_to_file))

- with open(path_to_file, 'w') as f:

- f.write(render_template(tpl, **self.info))

- self.scm.add_files((path_to_file,))

-

- def run(self):

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

-

- # Some validation covered by the CLI - validate all parameters here

- self.validate()

- self.assign()

-

- has_swig = (

- self.info['lang'] == 'cpp'

- and not self.skip_subdirs['swig']

- )

- has_grc = False

- if self.info['lang'] == 'cpp':

- self._run_lib()

- has_grc = has_swig

- else: # Python

- self._run_python()

- if self.info['blocktype'] != 'noblock':

- has_grc = True

- if has_swig:

- self._run_swig()

- if self.add_py_qa:

- self._run_python_qa()

- if has_grc and not self.skip_subdirs['grc']:

- self._run_grc()

-

- def _run_cc_qa(self):

- " Add C++ QA files for 3.7 API if intructed from _run_lib"

- fname_qa_h = 'qa_{}.h'.format(self.info['blockname'])

- fname_qa_cc = 'qa_{}.cc'.format(self.info['blockname'])

- self._write_tpl('qa_cpp', 'lib', fname_qa_cc)

- self._write_tpl('qa_h', 'lib', fname_qa_h)

- if self.skip_cmakefiles:

- return

- try:

- append_re_line_sequence(self._file['cmlib'],

- r'list\(APPEND test_{}_sources.*\n'.format(self.info['modname']),

- 'qa_{}.cc'.format(self.info['blockname']))

- append_re_line_sequence(self._file['qalib'],

- '#include.*\n',

- '#include "{}"'.format(fname_qa_h))

- append_re_line_sequence(self._file['qalib'],

- '(addTest.*suite.*\n|new CppUnit.*TestSuite.*\n)',

- ' s->addTest(gr::{}::qa_{}::suite());'.format(self.info['modname'],

- self.info['blockname'])

- )

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

- except IOError:

- logger.warning("Can't add C++ QA files.")

-

- def _run_cc_qa_boostutf(self):

- " Add C++ QA files for 3.8 API if intructed from _run_lib"

- fname_qa_cc = 'qa_{}.cc'.format(self.info['blockname'])

- self._write_tpl('qa_cpp_boostutf', 'lib', fname_qa_cc)

- if self.skip_cmakefiles:

- return

- try:

- append_re_line_sequence(self._file['cmlib'],

- r'list\(APPEND test_{}_sources.*\n'.format(self.info['modname']),

- 'qa_{}.cc'.format(self.info['blockname']))

- self.scm.mark_files_updated((self._file['cmlib'],))

- except IOError:

- logger.warning("Can't add C++ QA files.")

-

- def _run_lib(self):

- """ Do everything that needs doing in the subdir 'lib' and 'include'.

- - add .cc and .h files

- - include them into CMakeLists.txt

- - check if C++ QA code is req'd

- - if yes, create qa_*.{cc,h} and add them to CMakeLists.txt

- """

- fname_cc = None

- fname_h = None

- if self.info['version'] in ('37', '38'):

- fname_h = self.info['blockname'] + '.h'

- fname_cc = self.info['blockname'] + '.cc'

- if self.info['blocktype'] in ('source', 'sink', 'sync', 'decimator',

- 'interpolator', 'general', 'hier', 'tagged_stream'):

- fname_cc = self.info['blockname'] + '_impl.cc'

- self._write_tpl('block_impl_h', 'lib', self.info['blockname'] + '_impl.h')

- self._write_tpl('block_impl_cpp', 'lib', fname_cc)

- self._write_tpl('block_def_h', self.info['includedir'], fname_h)

- else: # Pre-3.7 or autotools

- fname_h = self.info['fullblockname'] + '.h'

- fname_cc = self.info['fullblockname'] + '.cc'

- self._write_tpl('block_h36', self.info['includedir'], fname_h)

- self._write_tpl('block_cpp36', 'lib', fname_cc)

- if self.add_cc_qa:

- if self.info['version'] == '38':

- self._run_cc_qa_boostutf()

- elif self.info['version'] == '37':

- self._run_cc_qa()

- elif self.info['version'] == '36':

- logger.warning("Warning: C++ QA files not supported for 3.6-style OOTs.")

- elif self.info['version'] == 'autofoo':

- logger.warning("Warning: C++ QA files not supported for autotools.")

- if not self.skip_cmakefiles:

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

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

- if not ed.append_value('list', fname_cc, to_ignore_start='APPEND ' + cmake_list_var):

- ed.append_value('add_library', fname_cc)

- ed.write()

- ed = CMakeFileEditor(self._file['cminclude'])

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

- ed.write()

- self.scm.mark_files_updated((self._file['cminclude'], self._file['cmlib']))

-

- def _run_swig(self):

- """ Do everything that needs doing in the subdir 'swig'.

- - Edit main *.i file

- """

- if self._get_mainswigfile() is None:

- logger.warning('Warning: No main swig file found.')

- return

- logger.info("Editing {}...".format(self._file['swig']))

- mod_block_sep = '/'

- if self.info['version'] == '36':

- mod_block_sep = '_'

- swig_block_magic_str = render_template('swig_block_magic', **self.info)

- with open(self._file['swig'], 'a') as f:

- f.write(swig_block_magic_str)

- include_str = '#include "{}{}{}.h"'.format(

- {True: 'gnuradio/' + self.info['modname'], False: self.info['modname']}[self.info['is_component']],

- mod_block_sep,

- self.info['blockname'])

- with open(self._file['swig'], 'r') as f:

- oldfile = f.read()

- if re.search('#include', oldfile):

- append_re_line_sequence(self._file['swig'], '^#include.*\n', include_str)

- else: # I.e., if the swig file is empty

- regexp = re.compile(r'^%\{\n', re.MULTILINE)

- oldfile = regexp.sub('%%{\n%s\n' % include_str, oldfile, count=1)

- with open(self._file['swig'], 'w') as f:

- f.write(oldfile)

- self.scm.mark_files_updated((self._file['swig'],))

-

- def _run_python_qa(self):

- """ Do everything that needs doing in the subdir 'python' to add

- QA code.

- - add .py files

- - include in CMakeLists.txt

- """

- fname_py_qa = 'qa_' + self.info['blockname'] + '.py'

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

- os.chmod(os.path.join(self.info['pydir'], fname_py_qa), 0o755)

- 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

- logger.info("Editing {}/CMakeLists.txt...".format(self.info['pydir']))

- with open(self._file['cmpython'], 'a') as f:

- f.write(

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

- (self.info['blockname'], fname_py_qa))

- self.scm.mark_files_updated((self._file['cmpython'],))

-

- def _run_python(self):

- """ Do everything that needs doing in the subdir 'python' to add

- a Python block.

- - add .py file

- - include in CMakeLists.txt

- - include in __init__.py

- """

- fname_py = self.info['blockname'] + '.py'

- self._write_tpl('block_python', self.info['pydir'], fname_py)

- append_re_line_sequence(self._file['pyinit'],

- '(^from.*import.*\n|# import any pure.*\n)',

- 'from .{} import {}'.format(self.info['blockname'], self.info['blockname']))

- self.scm.mark_files_updated((self._file['pyinit'],))

- if self.skip_cmakefiles:

- return

- ed = CMakeFileEditor(self._file['cmpython'])

- ed.append_value('GR_PYTHON_INSTALL', fname_py, to_ignore_end='DESTINATION[^()]+')

- ed.write()

- self.scm.mark_files_updated((self._file['cmpython'],))

-

- def _run_grc(self):

- """ Do everything that needs doing in the subdir 'grc' to add

- a GRC bindings YAML file.

- - add .yml file

- - include in CMakeLists.txt

- """

- fname_grc = self.info['fullblockname'] + '.block.yml'

- self._write_tpl('grc_yml', 'grc', fname_grc)

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

- if self.skip_cmakefiles or ed.check_for_glob('*.yml'):

- return

- logger.info("Editing grc/CMakeLists.txt...")

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

- ed.write()

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

-#

-# Copyright 2013, 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Base class for the modules """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import re

-import glob

-import logging

-import itertools

-

-from types import SimpleNamespace

-from gnuradio import gr

-from ..tools import get_modname, SCMRepoFactory

-

-logger = logging.getLogger('gnuradio.modtool')

-

-

-def get_block_candidates():

- """ Returns a list of all possible blocknames """

- block_candidates = []

- cpp_filters = ["*.cc", "*.cpp"]

- cpp_blocks = []

- for ftr in cpp_filters:

- cpp_blocks += [x for x in glob.glob1("lib", ftr) if not (x.startswith('qa_') or

- x.startswith('test_'))]

- python_blocks = [x for x in glob.glob1("python", "*.py") if not (x.startswith('qa_') or

- x.startswith('build') or x.startswith('__init__'))]

- for block in itertools.chain(cpp_blocks, python_blocks):

- block = os.path.splitext(block)[0]

- block = block.split('_impl')[0]

- block_candidates.append(block)

- return block_candidates

-

-

-class ModToolException(Exception):

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

- pass

-

-

-class ModTool(object):

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

- name = 'base'

- description = None

-

- def __init__(self, blockname=None, module_name=None, **kwargs):

- # List subdirs where stuff happens

- self._subdirs = ['lib', 'include', 'python', 'swig', 'grc']

- self.has_subdirs = {}

- self.skip_subdirs = {}

- self.info = {}

- self._file = {}

- for subdir in self._subdirs:

- self.has_subdirs[subdir] = False

- self.skip_subdirs[subdir] = False

- self.info['blockname'] = blockname

- self.info['modname'] = module_name

- self.cli = kwargs.get('cli', False)

- self.dir = kwargs.get('directory', '.')

- self.skip_subdirs['lib'] = kwargs.get('skip_lib', False)

- self.skip_subdirs['python'] = kwargs.get('skip_python', False)

- self.skip_subdirs['swig'] = kwargs.get('skip_swig', False)

- self.skip_subdirs['grc'] = kwargs.get('skip_grc', False)

- self._scm = kwargs.get('scm_mode',

- gr.prefs().get_string('modtool', 'scm_mode', 'no'))

- if not self.cli:

- logging.basicConfig(level=logging.ERROR, format='%(message)s')

- self.info['yes'] = True

- else:

- self.info['yes'] = kwargs.get('yes', False)

- from ..cli import setup_cli_logger

- setup_cli_logger(logger)

-

- if not type(self).__name__ in ['ModToolInfo', 'ModToolNewModule']:

- if self.cli:

- self._validate()

-

- def _validate(self):

- """ Validates the arguments """

- if not isinstance(self.skip_subdirs['lib'], bool):

- raise ModToolException('Expected a boolean value for skip_lib')

- if not isinstance(self.skip_subdirs['swig'], bool):

- raise ModToolException('Expected a boolean value for skip_swig')

- if not isinstance(self.skip_subdirs['python'], bool):

- raise ModToolException('Expected a boolean value for skip_python')

- if not isinstance(self.skip_subdirs['grc'], bool):

- raise ModToolException('Expected a boolean value for skip_grc')

- self._assign()

-

- def _assign(self):

- if not self._check_directory(self.dir):

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

- if self.info['modname'] is None:

- 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.info['version'] = '37'

- if not os.path.isfile(os.path.join('cmake', 'Modules', 'FindCppUnit.cmake')):

- self.info['version'] = '38'

- if self.skip_subdirs['lib'] or not self.has_subdirs['lib']:

- self.skip_subdirs['lib'] = True

- if not self.has_subdirs['python']:

- self.skip_subdirs['python'] = True

- if self._get_mainswigfile() is None or not self.has_subdirs['swig']:

- self.skip_subdirs['swig'] = True

- if not self.has_subdirs['grc']:

- self.skip_subdirs['grc'] = True

-

- self._setup_files()

- self._setup_scm()

-

- def _setup_files(self):

- """ Initialise the self._file[] dictionary """

- if not self.skip_subdirs['swig']:

- self._file['swig'] = os.path.join('swig', self._get_mainswigfile())

- self.info['pydir'] = 'python'

- if os.path.isdir(os.path.join('python', self.info['modname'])):

- self.info['pydir'] = os.path.join('python', self.info['modname'])

- self._file['qalib'] = os.path.join('lib', 'qa_{}.cc'.format(self.info['modname']))

- self._file['pyinit'] = os.path.join(self.info['pydir'], '__init__.py')

- self._file['cmlib'] = os.path.join('lib', 'CMakeLists.txt')

- self._file['cmgrc'] = os.path.join('grc', 'CMakeLists.txt')

- self._file['cmpython'] = os.path.join(self.info['pydir'], 'CMakeLists.txt')

- if self.info['is_component']:

- self.info['includedir'] = os.path.join('include', 'gnuradio', self.info['modname'])

- elif self.info['version'] in ('37', '38'):

- self.info['includedir'] = os.path.join('include', self.info['modname'])

- else:

- self.info['includedir'] = 'include'

- self._file['cminclude'] = os.path.join(self.info['includedir'], 'CMakeLists.txt')

- self._file['cmswig'] = os.path.join('swig', 'CMakeLists.txt')

- self._file['cmfind'] = os.path.join('cmake', 'Modules', 'howtoConfig.cmake')

-

-

- def _setup_scm(self, mode='active'):

- """ Initialize source control management. """

- self.options = SimpleNamespace(scm_mode = self._scm)

- if mode == 'active':

- self.scm = SCMRepoFactory(self.options, '.').make_active_scm_manager()

- else:

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

- if self.scm is None:

- logger.error("Error: Can't set up SCM.")

- exit(1)

-

- def _check_directory(self, directory):

- """ Guesses if dir is a valid GNU Radio module directory by looking for

- CMakeLists.txt and at least one of the subdirs lib/, python/ and swig/.

- Changes the directory, if valid. """

- has_makefile = False

- try:

- files = os.listdir(directory)

- os.chdir(directory)

- except OSError:

- logger.error("Can't read or chdir to directory {}.".format(directory))

- return False

- self.info['is_component'] = False

- for f in files:

- if os.path.isfile(f) and f == 'CMakeLists.txt':

- with open(f) as filetext:

- if re.search(r'find_package\(Gnuradio', filetext.read()) is not None:

- self.info['version'] = '36' # Might be 37, check that later

- has_makefile = True

- elif re.search('GR_REGISTER_COMPONENT', filetext.read()) is not None:

- self.info['version'] = '36' # Might be 37, check that later

- self.info['is_component'] = True

- has_makefile = True

- # TODO search for autofoo

- elif os.path.isdir(f):

- if (f in list(self.has_subdirs.keys())):

- self.has_subdirs[f] = True

- else:

- self.skip_subdirs[f] = True

- return bool(has_makefile and (list(self.has_subdirs.values())))

-

- def _get_mainswigfile(self):

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

- a MODNAME.i or a MODNAME_swig.i? Returns None if none is found. """

- modname = self.info['modname']

- swig_files = (modname + '.i',

- modname + '_swig.i')

- for fname in swig_files:

- if os.path.isfile(os.path.join(self.dir, 'swig', fname)):

- return fname

- return None

-

- def run(self):

- """ Override this. """

- raise NotImplementedError('Module implementation missing')

-#

-# Copyright 2013, 2018, 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Disable blocks module """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import re

-import sys

-import logging

-

-from ..tools import CMakeFileEditor

-from .base import ModTool, ModToolException

-

-logger = logging.getLogger(__name__)

-

-

-class ModToolDisable(ModTool):

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

- name = 'disable'

- description = 'Disable selected block in module.'

-

- def __init__(self, blockname=None, **kwargs):

- ModTool.__init__(self, blockname, **kwargs)

- self.info['pattern'] = blockname

-

- def validate(self):

- """ Validates the arguments """

- ModTool._validate(self)

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

- raise ModToolException("Invalid pattern!")

-

- def run(self):

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

- def _handle_py_qa(cmake, fname):

- """ Do stuff for py qa """

- cmake.comment_out_lines('GR_ADD_TEST.*'+fname)

- self.scm.mark_file_updated(cmake.filename)

- return True

- def _handle_py_mod(cmake, fname):

- """ Do stuff for py extra files """

- try:

- with open(self._file['pyinit']) as f:

- initfile = f.read()

- except IOError:

- logger.warning("Could not edit __init__.py, that might be a problem.")

- return False

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

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

- with open(self._file['pyinit'], 'w') as f:

- f.write(initfile)

- self.scm.mark_file_updated(self._file['pyinit'])

- return False

- def _handle_cc_qa(cmake, fname):

- """ Do stuff for cc qa """

- if self.info['version'] == '37':

- cmake.comment_out_lines(r'\$\{CMAKE_CURRENT_SOURCE_DIR\}/'+fname)

- fname_base = os.path.splitext(fname)[0]

- ed = CMakeFileEditor(self._file['qalib']) # Abusing the CMakeFileEditor...

- ed.comment_out_lines(r'#include\s+"{}.h"'.format(fname_base), comment_str='//')

- ed.comment_out_lines(r'{}::suite\(\)'.format(fname_base), comment_str='//')

- ed.write()

- self.scm.mark_file_updated(self._file['qalib'])

- elif self.info['version'] == '38':

- fname_qa_cc = 'qa_{}.cc'.format(self.info['blockname'])

- cmake.comment_out_lines(fname_qa_cc)

- elif self.info['version'] == '36':

- cmake.comment_out_lines('add_executable.*'+fname)

- cmake.comment_out_lines('target_link_libraries.*'+os.path.splitext(fname)[0])

- cmake.comment_out_lines('GR_ADD_TEST.*'+os.path.splitext(fname)[0])

- self.scm.mark_file_updated(cmake.filename)

- return True

- def _handle_h_swig(cmake, fname):

- """ Comment out include files from the SWIG file,

- as well as the block magic """

- with open(self._file['swig']) as f:

- swigfile = f.read()

- (swigfile, nsubs) = re.subn(r'(.include\s+"({}/)?{}")'.format(

- self.info['modname'], fname),

- r'//\1', swigfile)

- if nsubs > 0:

- logger.info("Changing {}...".format(self._file['swig']))

- 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'] in ('37', '38'):

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

- (swigfile, nsubs) = re.subn('(GR_SWIG_BLOCK_MAGIC2?.+{}.+;)'.format(blockname), r'//\1', swigfile)

- if nsubs > 1:

- logger.warning("Hm, changed more then expected while editing {}.".format(self._file['swig']))

- with open(self._file['swig'], 'w') as f:

- f.write(swigfile)

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

- return False

- def _handle_i_swig(cmake, fname):

- """ Comment out include files from the SWIG file,

- as well as the block magic """

- with open(self._file['swig']) as f:

- swigfile = f.read()

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

- if self.info['version'] in ('37', '38'):

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

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

- logger.info("Changing {}...".format(self._file['swig']))

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

- with open(self._file['swig'], 'w') as f:

- f.write(swigfile)

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

- return False

-

- # This portion will be covered by the CLI

- if not self.cli:

- self.validate()

- else:

- from ..cli import cli_input

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

- special_treatments = (

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

- ('python', r'^(?!qa).+py$', _handle_py_mod),

- ('lib', r'qa.+\.cc$', _handle_cc_qa),

- ('include/{}'.format(self.info['modname']), r'.+\.h$', _handle_h_swig),

- ('include', r'.+\.h$', _handle_h_swig),

- ('swig', r'.+\.i$', _handle_i_swig)

- )

- for subdir in self._subdirs:

- if self.skip_subdirs[subdir]:

- continue

- if self.info['version'] in ('37', '38') and subdir == 'include':

- subdir = 'include/{}'.format(self.info['modname'])

- try:

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

- except IOError:

- continue

- logger.info("Traversing {}...".format(subdir))

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

- yes = self.info['yes']

- for fname in filenames:

- file_disabled = False

- if not yes:

- ans = cli_input("Really disable {}? [Y/n/a/q]: ".format(fname)).lower().strip()

- if ans == 'a':

- yes = True

- if ans == 'q':

- sys.exit(0)

- if ans == 'n':

- continue

- for special_treatment in special_treatments:

- if special_treatment[0] == subdir and re.match(special_treatment[1], fname):

- file_disabled = special_treatment[2](cmake, fname)

- if not file_disabled:

- cmake.disable_file(fname)

- cmake.write()

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

- logger.warning("Careful: 'gr_modtool disable' does not resolve dependencies.")

-#

-# Copyright 2013, 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Returns information about a module """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-

-from ..tools import get_modname

-from .base import ModTool, ModToolException

-

-

-class ModToolInfo(ModTool):

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

- name = 'info'

- description = 'Return information about a given module.'

-

- def __init__(self, python_readable=False, suggested_dirs=None, **kwargs):

- ModTool.__init__(self, **kwargs)

- # Don't call ModTool._validate(), is is too chatty!

- self._directory = self.dir

- self._python_readable = python_readable

- self._suggested_dirs = suggested_dirs

-

- def run(self):

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

- mod_info = dict()

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

- if mod_info['base_dir'] is None:

- raise ModToolException('{}' if self._python_readable else "No module found.")

- os.chdir(mod_info['base_dir'])

- mod_info['modname'] = get_modname()

- if mod_info['modname'] is None:

- raise ModToolException('{}' if self._python_readable else "No module found.")

- if self.info['version'] == '36' and (

- os.path.isdir(os.path.join('include', mod_info['modname'])) or

- os.path.isdir(os.path.join('include', 'gnuradio', mod_info['modname']))

- ):

- self.info['version'] = '37'

- if not os.path.isfile(os.path.join('cmake', 'Modules', 'FindCppUnit.cmake')):

- self.info['version'] = '38'

- mod_info['version'] = self.info['version']

- if 'is_component' in list(self.info.keys()) and self.info['is_component']:

- mod_info['is_component'] = True

- mod_info['incdirs'] = []

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

- if os.path.isdir(os.path.join(mod_incl_dir, mod_info['modname'])):

- mod_info['incdirs'].append(os.path.join(mod_incl_dir, mod_info['modname']))

- else:

- mod_info['incdirs'].append(mod_incl_dir)

- build_dir = self._get_build_dir(mod_info)

- if build_dir is not None:

- mod_info['build_dir'] = build_dir

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

- if self._python_readable:

- print(str(mod_info))

- else:

- self._pretty_print(mod_info)

-

- def _get_base_dir(self, start_dir):

- """ Figure out the base dir (where the top-level cmake file is) """

- base_dir = os.path.abspath(start_dir)

- if self._check_directory(base_dir):

- return base_dir

- else:

- (up_dir, this_dir) = os.path.split(base_dir)

- if os.path.split(up_dir)[1] == 'include':

- up_dir = os.path.split(up_dir)[0]

- if self._check_directory(up_dir):

- return up_dir

- return None

-

- def _get_build_dir(self, mod_info):

- """ Figure out the build dir (i.e. where you run 'cmake'). This checks

- for a file called CMakeCache.txt, which is created when running cmake.

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

- if 'is_component' in list(mod_info.keys()):

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

- return os.path.join(base_build_dir, 'build')

- else:

- for (dirpath, dirnames, filenames) in os.walk(base_build_dir):

- if 'CMakeCache.txt' in filenames:

- return dirpath

- if has_build_dir:

- return os.path.join(base_build_dir, 'build')

- return None

-

- def _get_include_dirs(self, mod_info):

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

- inc_dirs = []

- path_or_internal = {True: 'INTERNAL',

- False: 'PATH'}['is_component' in list(mod_info.keys())]

- try:

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

- for line in cmakecache_fid:

- if line.find('GNURADIO_RUNTIME_INCLUDE_DIRS:{}'.format(path_or_internal)) != -1:

- inc_dirs += line.replace('GNURADIO_RUNTIME_INCLUDE_DIRS:{}='.format(path_or_internal), '').strip().split(';')

- except IOError:

- pass

- if not inc_dirs and self._suggested_dirs is not None:

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

- return inc_dirs

-

- def _pretty_print(elf, mod_info):

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

- for key in list(mod_info.keys()):

- if key == 'version':

- print(" API version: {}".format({

- '36': 'pre-3.7',

- '37': 'post-3.7',

- '38': 'post-3.8',

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

- }[mod_info['version']]))

- else:

- print('%19s: %s' % (index_names[key], mod_info[key]))

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Automatically create YAML bindings for GRC from block code """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import re

-import glob

-import logging

-import yaml

-

-from collections import OrderedDict

-

-try:

- from yaml import CLoader as Loader, CDumper as Dumper

-except:

- from yaml import Loader, Dumper

-

-try:

- from gnuradio.blocktool.core import Constants

-except ImportError:

- have_blocktool = False

-else:

- have_blocktool = True

-

-from ..tools import ParserCCBlock, CMakeFileEditor, ask_yes_no, GRCYAMLGenerator

-from .base import ModTool, ModToolException

-

-

-logger = logging.getLogger(__name__)

-

-## setup dumper for dumping OrderedDict ##

-_MAPPING_TAG = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG

-

-

-def dict_representer(dumper, data):

- """ Representer to represent special OrderedDict """

- return dumper.represent_dict(data.items())

-

-

-def dict_constructor(loader, node):

- """ Construct an OrderedDict for dumping """

- return OrderedDict(loader.construct_pairs(node))

-

-

-Dumper.add_representer(OrderedDict, dict_representer)

-Loader.add_constructor(_MAPPING_TAG, dict_constructor)

-

-

-class ModToolMakeYAML(ModTool):

- """ Make YAML file for GRC block bindings """

- name = 'makeyaml'

- description = 'Generate YAML files for GRC block bindings.'

-

- def __init__(self, blockname=None, **kwargs):

- ModTool.__init__(self, blockname, **kwargs)

- self.info['pattern'] = blockname

-

- def validate(self):

- """ Validates the arguments """

- ModTool._validate(self)

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

- raise ModToolException("Incorrect blockname (Regex)!")

-

- def run(self):

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

- # This portion will be covered by the CLI

- if not self.cli:

- self.validate()

- logger.warning(

- "Warning: This is an experimental feature. Don't expect any magic.")

- # 1) Go through lib/

- if not self.skip_subdirs['lib']:

- if self.info['version'] in ('37', '38'):

- files = self._search_files('lib', '*_impl.cc')

- else:

- files = self._search_files('lib', '*.cc')

- for f in files:

- if os.path.basename(f)[0:2] == 'qa':

- continue

- (params, iosig, blockname) = self._parse_cc_h(f)

- self._make_grc_yaml_from_block_data(params, iosig, blockname)

- # 2) Go through python/

- # TODO

-

- def _search_files(self, path, path_glob):

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

- files = sorted(glob.glob("{}/{}".format(path, path_glob)))

- files_filt = []

- logger.info("Searching for matching files in {}/:".format(path))

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

- logger.info("None found.")

- return files_filt

-

- def _make_grc_yaml_from_block_data(self, params, iosig, blockname):

- """ Take the return values from the parser and call the YAML

- generator. Also, check the makefile if the .yml file is in there.

- If necessary, add. """

- fname_yml = '{}_{}.block.yml'.format(self.info['modname'], blockname)

- path_to_yml = os.path.join('grc', fname_yml)

- # Some adaptions for the GRC

- for inout in ('in', 'out'):

- if iosig[inout]['max_ports'] == '-1':

- iosig[inout]['max_ports'] = '$num_{}puts'.format(inout)

- params.append({'key': 'num_{}puts'.format(inout),

- 'type': 'int',

- 'name': 'Num {}puts'.format(inout),

- 'default': '2',

- 'in_constructor': False})

- file_exists = False

- if os.path.isfile(path_to_yml):

- if not self.info['yes']:

- if not ask_yes_no('Overwrite existing GRC file?', False):

- return

- else:

- file_exists = True

- logger.warning("Warning: Overwriting existing GRC file.")

- grc_generator = GRCYAMLGenerator(

- modname=self.info['modname'],

- blockname=blockname,

- params=params,

- iosig=iosig

- )

- grc_generator.save(path_to_yml)

- if file_exists:

- self.scm.mark_files_updated((path_to_yml,))

- else:

- self.scm.add_files((path_to_yml,))

- if not self.skip_subdirs['grc']:

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

- if re.search(fname_yml, ed.cfile) is None and not ed.check_for_glob('*.yml'):

- logger.info("Adding GRC bindings to grc/CMakeLists.txt...")

- ed.append_value('install', fname_yml,

- to_ignore_end='DESTINATION[^()]+')

- ed.write()

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

-

- def _parse_cc_h(self, fname_cc):

- """ Go through a .cc and .h-file defining a block and return info """

- def _type_translate(p_type, default_v=None):

- """ Translates a type from C++ to GRC """

- translate_dict = {'float': 'float',

- 'double': 'real',

- 'int': 'int',

- 'gr_complex': 'complex',

- 'char': 'byte',

- 'unsigned char': 'byte',

- 'std::string': 'string',

- 'std::vector<int>': 'int_vector',

- 'std::vector<float>': 'real_vector',

- 'std::vector<gr_complex>': 'complex_vector',

- }

- if p_type in ('int',) and default_v is not None and len(default_v) > 1 and default_v[:2].lower() == '0x':

- return 'hex'

- try:

- return translate_dict[p_type]

- except KeyError:

- return 'raw'

-

- def _get_blockdata(fname_cc):

- """ Return the block name and the header file name from the .cc file name """

- blockname = os.path.splitext(os.path.basename(

- fname_cc.replace('_impl.', '.')))[0]

- fname_h = (blockname + '.h').replace('_impl.', '.')

- contains_modulename = blockname.startswith(

- self.info['modname']+'_')

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

- return (blockname, fname_h, contains_modulename)

- # Go, go, go

- logger.info("Making GRC bindings for {}...".format(fname_cc))

- (blockname, fname_h, contains_modulename) = _get_blockdata(fname_cc)

- try:

- parser = ParserCCBlock(fname_cc,

- os.path.join(

- self.info['includedir'], fname_h),

- blockname,

- self.info['version'],

- _type_translate

- )

- except IOError:

- raise ModToolException(

- "Can't open some of the files necessary to parse {}.".format(fname_cc))

-

- if contains_modulename:

- return (parser.read_params(), parser.read_io_signature(), self.info['modname']+'_'+blockname)

- else:

- return (parser.read_params(), parser.read_io_signature(), blockname)

-

-

-def yaml_generator(self, **kwargs):

- """

- Generate YAML file from the block header file using blocktool API

- """

- header = self.filename.split('.')[0]

- block = self.modname.split('-')[-1]

- label = header.split('_')

- del label[-1]

- yml_file = os.path.join('.', block+'_'+header+'.block.yml')

- _header = (('id', '{}_{}'.format(block, header)),

- ('label', ' '.join(label).upper()),

- ('category', '[{}]'.format(block.capitalize())),

- ('flags', '[python, cpp]')

- )

- params_list = [

- '${'+s['name']+'}' for s in self.parsed_data['properties'] if self.parsed_data['properties']]

- _templates = [('imports', 'from gnuradio import {}'.format(block)),

- ('make', '{}.{}({})'.format(block, header, ', '.join(params_list)))

- ]

-

- if self.parsed_data['methods']:

- list_callbacks = []

- for param in self.parsed_data['methods']:

- arguments = []

- for args in param['arguments_type']:

- arguments.append(args['name'])

- arg_list = ['${'+s+'}' for s in arguments if arguments]

- list_callbacks.append(

- param['name']+'({})'.format(', '.join(arg_list)))

- callback_key = ('callbacks')

- callbacks = (callback_key, tuple(list_callbacks))

- _templates.append(callbacks)

- _templates = tuple(_templates)

-

- data = OrderedDict()

- for tag, value in _header:

- data[tag] = value

-

- templates = OrderedDict()

- for tag, value in _templates:

- templates[tag] = value

- data['templates'] = templates

-

- parameters = []

- for param in self.parsed_data['properties']:

- parameter = OrderedDict()

- parameter['id'] = param['name']

- parameter['label'] = param['name'].capitalize()

- parameter['dtype'] = param['dtype']

- parameter['read_only'] = param['read_only']

- parameters.append(parameter)

- if parameters:

- data['parameters'] = parameters

-

- input_signature = []

- max_input_port = self.parsed_data['io_signature']['input']['max_streams']

- i_sig = self.parsed_data['io_signature']['input']['signature']

- for port in range(0, int(max_input_port)):

- input_sig = OrderedDict()

- if i_sig is Constants.MAKE:

- input_sig['domain'] = 'stream'

- input_sig['dtype'] = self.parsed_data['io_signature']['input']['sizeof_stream_item']

- elif i_sig is Constants.MAKE2:

- input_sig['domain'] = 'stream'

- input_sig['dtype'] = self.parsed_data['io_signature']['input']['sizeof_stream_item' +

- str(port+1)]

- elif i_sig is Constants.MAKE3:

- input_sig['domain'] = 'stream'

- input_sig['dtype'] = self.parsed_data['io_signature']['input']['sizeof_stream_item' +

- str(port+1)]

- elif i_sig is Constants.MAKEV:

- input_sig['domain'] = 'stream'

- input_sig['dtype'] = self.parsed_data['io_signature']['input']['sizeof_stream_items']

- input_signature.append(input_sig)

-

- if self.parsed_data['message_port']['input']:

- for _input in self.parsed_data['message_port']['input']:

- m_input_sig = OrderedDict()

- m_input_sig['domain'] = 'message'

- m_input_sig['id'] = _input

- input_signature.append(m_input_sig)

- if input_signature:

- data['inputs'] = input_signature

-

- output_signature = []

- max_output_port = self.parsed_data['io_signature']['output']['max_streams']

- o_sig = self.parsed_data['io_signature']['output']['signature']

- for port in range(0, int(max_output_port)):

- output_sig = OrderedDict()

- if o_sig is Constants.MAKE:

- output_sig['domain'] = 'stream'

- output_sig['dtype'] = self.parsed_data['io_signature']['output']['sizeof_stream_item']

- elif o_sig is Constants.MAKE2:

- output_sig['domain'] = 'stream'

- output_sig['dtype'] = self.parsed_data['io_signature']['output']['sizeof_stream_item' +

- str(port+1)]

- elif o_sig is Constants.MAKE3:

- output_sig['domain'] = 'stream'

- output_sig['dtype'] = self.parsed_data['io_signature']['output']['sizeof_stream_item' +

- str(port+1)]

- elif o_sig is Constants.MAKEV:

- output_sig['domain'] = 'stream'

- output_sig['dtype'] = self.parsed_data['io_signature']['output']['sizeof_stream_items']

- output_signature.append(output_sig)

-

- if self.parsed_data['message_port']['output']:

- for _output in self.parsed_data['message_port']['output']:

- m_output_sig = OrderedDict()

- m_output_sig['domain'] = 'message'

- m_output_sig['id'] = _output

- output_signature.append(m_output_sig)

- if output_signature:

- data['outputs'] = output_signature

-

- _cpp_templates = [('includes', '#include <gnuradio/{}/{}>'.format(block, self.filename)),

- ('declarations', '{}::{}::sptr ${{id}}'.format(block, header)),

- ('make', 'this->${{id}} = {}::{}::make({})'.format(

- block, header, ', '.join(params_list)))

- ]

-

- if self.parsed_data['methods']:

- list_callbacks = []

- for param in self.parsed_data['methods']:

- arguments = []

- for args in param['arguments_type']:

- arguments.append(args['name'])

- arg_list = ['${'+s+'}' for s in arguments if arguments]

- list_callbacks.append(

- param['name']+'({})'.format(', '.join(arg_list)))

- callback_key = ('callbacks')

- callbacks = (callback_key, tuple(list_callbacks))

- _cpp_templates.append(callbacks)

-

- link = ('link', 'gnuradio-{}'.format(block))

- _cpp_templates.append(link)

- _cpp_templates = tuple(_cpp_templates)

-

- cpp_templates = OrderedDict()

- for tag, value in _cpp_templates:

- cpp_templates[tag] = value

- data['cpp_templates'] = cpp_templates

-

- if self.parsed_data['docstring'] is not None:

- data['documentation'] = self.parsed_data['docstring']

- data['file_format'] = 1

-

- if kwargs['output']:

- with open(yml_file, 'w') as yml:

- yaml.dump(data, yml, Dumper=Dumper, default_flow_style=False)

- else:

- print(yaml.dump(data, Dumper=Dumper, allow_unicode=True,

- default_flow_style=False, indent=4))

-#

-# Copyright 2013, 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

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

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import shutil

-import os

-import re

-import logging

-

-from gnuradio import gr

-from ..tools import SCMRepoFactory

-from .base import ModTool, ModToolException

-

-logger = logging.getLogger(__name__)

-

-class ModToolNewModule(ModTool):

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

- name = 'newmod'

- description = 'Create new empty module, use add to add blocks.'

- def __init__(self, module_name=None, srcdir=None, **kwargs):

- ModTool.__init__(self, None, module_name, **kwargs)

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

- self.srcdir = srcdir

- self.directory = self.dir

-

- def assign(self):

- self.dir = os.path.join(self.directory, 'gr-{}'.format(self.info['modname']))

- if self.srcdir is None:

- self.srcdir = os.path.join(gr.prefix(),'share','gnuradio','modtool','templates','gr-newmod')

-

- def validate(self):

- """ Validates the arguments """

- if not self.info['modname']:

- raise ModToolException('Module name not specified.')

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

- raise ModToolException('Invalid module name.')

- try:

- os.stat(self.dir)

- except OSError:

- pass # This is what should happen

- else:

- raise ModToolException('The given directory exists.')

- if not os.path.isdir(self.srcdir):

- raise ModToolException('Could not find gr-newmod source dir \'' + self.srcdir + '\'')

-

- def run(self):

- """

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

- """

- # This portion will be covered by the CLI

- if not self.cli:

- self.assign()

- self.validate()

- self._setup_scm(mode='new')

- logger.info("Creating out-of-tree module in {}...".format(self.dir))

- try:

- shutil.copytree(self.srcdir, self.dir)

- os.chdir(self.dir)

- except OSError:

- raise ModToolException('Could not create directory {}.'.format(self.dir))

- for root, dirs, files in os.walk('.'):

- for filename in files:

- f = os.path.join(root, filename)

- with open(f, 'r') as filetext:

- s = filetext.read()

- s = s.replace('howto', self.info['modname'])

- s = s.replace('HOWTO', self.info['modname'].upper())

- with open(f, 'w') as filetext:

- filetext.write(s)

- if filename.find('howto') != -1:

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

- logger.info("Done.")

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

- logger.info("Created repository... you might want to commit before continuing.")

- logger.info("Use 'gr_modtool add' to add a new block to this currently empty module.")

-#

-# Copyright 2014, 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Module to rename blocks """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import re

-import logging

-

-from .base import get_block_candidates, ModTool, ModToolException

-

-logger = logging.getLogger(__name__)

-

-

-class ModToolRename(ModTool):

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

- name = 'rename'

- description = 'Rename a block inside a module.'

-

- def __init__(self, blockname=None, new_name=None, **kwargs):

- ModTool.__init__(self, blockname, **kwargs)

- self.info['oldname'] = blockname

- self.info['newname'] = new_name

-

- def validate(self):

- """ Validates the arguments """

- ModTool._validate(self)

- if not self.info['oldname']:

- raise ModToolException('Old block name (blockname) not specified.')

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

- raise ModToolException('Invalid block name.')

- block_candidates = get_block_candidates()

- if self.info['oldname'] not in block_candidates:

- choices = [x for x in block_candidates if self.info['oldname'] in x]

- if len(choices)>0:

- print("Suggested alternatives: "+str(choices))

- raise ModToolException("Blockname for renaming does not exists!")

- if not self.info['newname']:

- raise ModToolException('New blockname (new_name) not specified.')

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

- raise ModToolException('Invalid new block name.')

-

- def assign(self):

- self.info['fullnewname'] = self.info['modname'] + '_' + self.info['newname']

-

- def run(self):

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

- # This portion will be covered by the CLI

- if not self.cli:

- self.validate()

- self.assign()

- module = self.info['modname']

- oldname = self.info['oldname']

- newname = self.info['newname']

- logger.info("In module '{}' rename block '{}' to '{}'".format(module, oldname, 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)

- self._run_python(self.info['modname'], oldname, newname)

- self._run_lib(self.info['modname'], oldname, newname)

- self._run_include(self.info['modname'], oldname, newname)

- return

-

- def _run_swig_rename(self, swigfilename, old, new):

- """ Rename SWIG includes and block_magic """

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

- if nsubs < 1:

- logger.info("Couldn't find '{}' in file '{}'.".format(old, swigfilename))

- if nsubs == 2:

- logger.info("Changing 'noblock' type file")

- if nsubs > 3:

- logger.warning("Hm, changed more then expected while editing {}.".format(swigfilename))

- return False

-

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

- ccfile = './lib/' + old + '_impl.cc'

- if not os.path.isfile(ccfile): # in case it is a 'noblock'

- ccfile = './lib/' + old + '.cc'

- hfile = './lib/' + old + '_impl.h'

- self._run_file_replace(ccfile, old, new)

- self._run_file_replace(hfile, old, new)

- self._run_file_replace(hfile, old.upper(), new.upper()) # take care of include guards

- self._run_cmakelists('./lib/', old, new)

- self._run_file_rename('./lib/', old, new)

- self._run_cpp_qa(module, old, new)

-

- def _run_cpp_qa(self, module, old, new):

- path = './lib/'

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

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

- if nsubs > 0:

- logger.info("C++ QA code detected, renaming...")

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

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

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

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

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

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

- else:

- logger.info("No C++ QA code detected, skipping...")

-

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

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

- filename = path + old + '.h'

- self._run_file_replace(filename, old, new)

- self._run_file_replace(filename, old.upper(), new.upper()) # take care of include guards

- self._run_cmakelists(path, old, new)

- self._run_file_rename(path, old, new)

-

- def _run_python(self, module, old, new):

- path = './python/'

- filename = '__init__.py'

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

- if nsubs > 0:

- logger.info("Python block detected, renaming...")

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

- logger.info("Not a Python block, nothing to do here...")

-

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

- new = 'qa_' + new

- old = 'qa_' + old

- filename = './python/' + old + '.py'

- self._run_file_replace(filename, old, new)

- self._run_cmakelists('./python/', old, new)

- self._run_file_rename('./python/', old, new)

-

- def _run_grc_rename(self, module, old, new):

- grcfile = './grc/' + module + '_' + old + '.yml'

- self._run_file_replace(grcfile, old, new)

- self._run_cmakelists('./grc/', old, new)

- self._run_file_rename('./grc/', module + '_' + old, module + '_' + new)

-

- def _run_cmakelists(self, path, first, second):

- filename = path + 'CMakeLists.txt'

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

- if nsubs < 1:

- logger.info("'{}' wasn't in '{}'.".format(first, filename))

-

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

- files = os.listdir(path)

- for file in files:

- if file.find(old) > -1 and file.find(old) < 3:

- nl = file.replace(old, new)

- src = path + file

- dst = path + nl

- logger.info("Renaming file '{}' to '{}'.".format(src, dst))

- os.rename(src, dst)

-

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

- if not os.path.isfile(filename):

- return False

- else:

- logger.info("In '{}' renaming occurrences of '{}' to '{}'".format(filename, old, new))

-

- with open(filename) as f:

- cfile = f.read()

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

-

- with open(filename, 'w') as f:

- f.write(cfile)

- self.scm.mark_file_updated(filename)

- return nsubs

-#

-# Copyright 2013, 2018, 2019 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Remove blocks module """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import re

-import sys

-import glob

-import logging

-

-from ..tools import remove_pattern_from_file, CMakeFileEditor

-from .base import ModTool, ModToolException

-

-logger = logging.getLogger(__name__)

-

-

-class ModToolRemove(ModTool):

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

- name = 'remove'

- description = 'Remove a block from a module.'

-

- def __init__(self, blockname=None, **kwargs):

- ModTool.__init__(self, blockname, **kwargs)

- self.info['pattern'] = blockname

-

- def validate(self):

- """ Validates the arguments """

- ModTool._validate(self)

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

- raise ModToolException("Incorrect blockname (Regex)!")

-

- def run(self):

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

- # This portion will be covered by the CLI

- if not self.cli:

- self.validate()

- else:

- from ..cli import cli_input

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

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

- from the CMakeLists.txt. """

- if filename[:2] != 'qa':

- return

- if self.info['version'] == '37':

- (base, ext) = os.path.splitext(filename)

- if ext == '.h':

- remove_pattern_from_file(self._file['qalib'],

- r'^#include "{}"\s*$'.format(filename))

- remove_pattern_from_file(self._file['qalib'],

- r'^\s*s->addTest\(gr::{}::{}::suite\(\)\);\s*$'.format(

- self.info['modname'], base)

- )

- self.scm.mark_file_updated(self._file['qalib'])

- elif ext == '.cc':

- ed.remove_value('list',

- r'\$\{CMAKE_CURRENT_SOURCE_DIR\}/%s' % filename,

- to_ignore_start='APPEND test_{}_sources'.format(self.info['modname']))

- self.scm.mark_file_updated(ed.filename)

- elif self.info['version'] == '38':

- (base, ext) = os.path.splitext(filename)

- if ext == '.cc':

- ed.remove_value(

- 'list', filename,

- to_ignore_start='APPEND test_{}_sources'.format(self.info['modname']))

- self.scm.mark_file_updated(ed.filename)

- else:

- filebase = os.path.splitext(filename)[0]

- ed.delete_entry('add_executable', filebase)

- ed.delete_entry('target_link_libraries', filebase)

- ed.delete_entry('GR_ADD_TEST', filebase)

- ed.remove_double_newlines()

- self.scm.mark_file_updated(ed.filename)

-

- def _remove_py_test_case(filename=None, ed=None):

- """ Special function that removes the occurrences of a qa*.{cc,h} file

- from the CMakeLists.txt and the qa_$modname.cc. """

- if filename[:2] != 'qa':

- return

- filebase = os.path.splitext(filename)[0]

- ed.delete_entry('GR_ADD_TEST', filebase)

- ed.remove_double_newlines()

-

- def _make_swig_regex(filename):

- filebase = os.path.splitext(filename)[0]

- pyblockname = filebase.replace(self.info['modname'] + '_', '')

- regexp = r'(^\s*GR_SWIG_BLOCK_MAGIC2?\({},\s*{}\);|^\s*.include\s*"({}/)?{}"\s*)'.format \

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

- if not self.skip_subdirs['include']:

- incl_files_deleted = self._run_subdir(self.info['includedir'], ('*.h',), ('install',))

- if not self.skip_subdirs['swig']:

- swig_files_deleted = self._run_subdir('swig', ('*.i',), ('install',))

- for f in incl_files_deleted + swig_files_deleted:

- # TODO do this on all *.i files

- remove_pattern_from_file(self._file['swig'], _make_swig_regex(f))

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

- if not self.skip_subdirs['python']:

- py_files_deleted = self._run_subdir('python', ('*.py',), ('GR_PYTHON_INSTALL',),

- cmakeedit_func=_remove_py_test_case)

- for f in py_files_deleted:

- remove_pattern_from_file(self._file['pyinit'], r'.*import\s+{}.*'.format(f[:-3]))

- remove_pattern_from_file(self._file['pyinit'], r'.*from\s+{}\s+import.*\n'.format(f[:-3]))

- if not self.skip_subdirs['grc']:

- self._run_subdir('grc', ('*.yml',), ('install',))

-

- def _run_subdir(self, path, globs, makefile_vars, cmakeedit_func=None):

- """ Delete all files that match a certain pattern in path.

- path - The directory in which this will take place

- globs - A tuple of standard UNIX globs of files to delete (e.g. *.yml)

- makefile_vars - A tuple with a list of CMakeLists.txt-variables which

- may contain references to the globbed files

- cmakeedit_func - If the CMakeLists.txt needs special editing, use this

- """

- if self.cli:

- from ..cli import cli_input

- # 1. Create a filtered list

- files = []

- for g in globs:

- files = files + sorted(glob.glob("{}/{}".format(path, g)))

- files_filt = []

- logger.info("Searching for matching files in {}/:".format(path))

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

- logger.info("None found.")

- return []

- # 2. Delete files, Makefile entries and other occurrences

- files_deleted = []

- ed = CMakeFileEditor('{}/CMakeLists.txt'.format(path))

- yes = self.info['yes']

- for f in files_filt:

- b = os.path.basename(f)

- if not yes and self.cli:

- ans = cli_input("Really delete {}? [Y/n/a/q]: ".format(f)).lower().strip()

- if ans == 'a':

- yes = True

- if ans == 'q':

- sys.exit(0)

- if ans == 'n':

- continue

- files_deleted.append(b)

- logger.info("Deleting {}.".format(f))

- self.scm.remove_file(f)

- os.unlink(f)

- logger.info("Deleting occurrences of {} from {}/CMakeLists.txt...".format(b, path))

- for var in makefile_vars:

- ed.remove_value(var, b)

- if cmakeedit_func is not None:

- cmakeedit_func(b, ed)

- ed.write()

- self.scm.mark_files_updated(('{}/CMakeLists.txt'.format(path)))

- return files_deleted

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-""" Module to convert XML bindings to YAML bindings """

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-import os

-import re

-import glob

-import logging

-

-from .base import ModTool, ModToolException

-from ..tools import get_modname

-

-logger = logging.getLogger(__name__)

-

-

-def get_xml_candidates():

- """ Returns a list of XML candidates for update """

- xml_candidates = []

- xml_files = [x for x in glob.glob1("grc", "*.xml")]

- mod_name = get_modname()

- for candidate in xml_files:

- candidate = os.path.splitext(candidate)[0]

- candidate = candidate.split(mod_name + "_", 1)[-1]

- xml_candidates.append(candidate)

- return xml_candidates

-

-

-class ModToolUpdate(ModTool):

- """ Update the grc bindings for a block """

- name = 'update'

- description = 'Update the grc bindings for a block'

-

- def __init__(self, blockname=None, complete=False, include_blacklisted=False, **kwargs):

- ModTool.__init__(self, blockname, **kwargs)

- self.info['complete'] = complete

- self.info['include_blacklisted'] = include_blacklisted

-

-

- def validate(self):

- """ Validates the arguments """

- ModTool._validate(self)

- if self.info['complete']:

- return

- if not self.info['blockname'] or self.info['blockname'].isspace():

- raise ModToolException('Block name not specified!')

- block_candidates = get_xml_candidates()

- if self.info['blockname'] not in block_candidates:

- choices = [x for x in block_candidates if self.info['blockname'] in x]

- if len(choices) > 0:

- print("Suggested alternatives: "+str(choices))

- raise ModToolException("The XML bindings does not exists!")

-

- def run(self):

- from gnuradio.grc.converter import Converter

- if not self.cli:

- self.validate()

- logger.warning("Warning: This is an experimental feature. Please verify the bindings.")

- module_name = self.info['modname']

- path = './grc/'

- conv = Converter(path, path)

- if self.info['complete']:

- blocks = get_xml_candidates()

- else:

- blocks = [self.info['blockname']]

- for blockname in blocks:

- xml_file = "{}_{}.xml".format(module_name, blockname)

- yml_file = "{}_{}.block.yml".format(module_name, blockname)

- if not conv.load_block_xml(path+xml_file, self.info["include_blacklisted"]):

- continue

- logger.info("Converted {} to {}".format(xml_file, yml_file))

- os.remove(path+xml_file)

- nsubs = self._run_cmakelists(xml_file, yml_file)

- if nsubs > 1:

- logger.warning("Changed more than expected for the block '%s' in the CMakeLists.txt. "

- "Please verify the CMakeLists manually.", blockname)

- elif nsubs == 0:

- logger.warning("No entry found for the block '%s' in the CMakeLists.txt. "

- 'Please verify the CMakeLists manually.', blockname)

- else:

- logger.info('Updated the CMakeLists.txt')

-

- def _run_cmakelists(self, to_remove, to_add):

- """ Changes in the CMakeLists """

- filename = './grc/CMakeLists.txt'

- with open(filename) as f:

- cfile = f.read()

- (cfile, nsubs) = re.subn(to_remove, to_add, cfile)

- with open(filename, 'w') as f:

- f.write(cfile)

- self.scm.mark_file_updated(filename)

- return nsubs

-# This file contains system wide configuration data for GNU Radio.

-# You may override any setting on a per-user basis by editing

-# ~/.gnuradio/config.conf

-

-[modtool]

-newmod_path = @newmoddir@

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-include(GrPython)

-

-GR_PYTHON_INSTALL(FILES

- __init__.py

- templates.py

- DESTINATION ${GR_PYTHON_DIR}/gnuradio/modtool/templates

-)

-

-set(GR_PKG_MODTOOL_DATA_DIR ${GR_PKG_DATA_DIR}/modtool/templates)

-install(DIRECTORY gr-newmod

- DESTINATION ${GR_PKG_MODTOOL_DATA_DIR}

-)

-#

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-#

-

-from __future__ import print_function

-from __future__ import absolute_import

-from __future__ import unicode_literals

-

-from .templates import Templates

-# Copyright 2011,2012,2014,2016,2018 Free Software Foundation, Inc.

-#

-# This file was generated by gr_modtool, a tool from the GNU Radio framework

-# This file is a part of gr-howto

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-########################################################################

-# Project setup

-########################################################################

-cmake_minimum_required(VERSION 3.8)

-project(gr-howto 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")

- message(STATUS "Build type not specified: defaulting to release.")

-endif(NOT CMAKE_BUILD_TYPE)

-set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "")

-

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

-

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

-

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

-

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

-

-########################################################################

-# Install directories

-########################################################################

-find_package(Gnuradio "3.9" REQUIRED)

-include(GrVersion)

-

-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/howto)

-set(GR_CMAKE_DIR ${CMAKE_MODULES_DIR}/howto)

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

-

-########################################################################

-# On Apple only, set install name and use rpath correctly, if not already set

-########################################################################

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

-

-########################################################################

-# Find gnuradio build dependencies

-########################################################################

-find_package(Doxygen)

-

-########################################################################

-# Setup doxygen option

-########################################################################

-if(DOXYGEN_FOUND)

- option(ENABLE_DOXYGEN "Build docs using Doxygen" ON)

-else(DOXYGEN_FOUND)

- option(ENABLE_DOXYGEN "Build docs using Doxygen" OFF)

-endif(DOXYGEN_FOUND)

-

-########################################################################

-# Create uninstall target

-########################################################################

-configure_file(

- ${CMAKE_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in

- ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake

-@ONLY)

-

-add_custom_target(uninstall

- ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake

- )

-

-

-########################################################################

-# Add subdirectories

-########################################################################

-add_subdirectory(include/howto)

-add_subdirectory(lib)

-add_subdirectory(apps)

-add_subdirectory(docs)

-add_subdirectory(swig)

-add_subdirectory(python)

-add_subdirectory(grc)

-

-########################################################################

-# Install cmake search helper for this library

-########################################################################

-

-install(FILES cmake/Modules/howtoConfig.cmake

- DESTINATION ${CMAKE_MODULES_DIR}/howto

-)

-title: The HOWTO OOT Module

-brief: Short description of gr-howto

-tags: # Tags are arbitrary, but look at CGRAN what other authors are using

- - sdr

-author:

- - Author Name <authors@email.address>

-copyright_owner:

- - Copyright Owner 1

-license:

-gr_supported_version: # Put a comma separated list of supported GR versions here

-#repo: # Put the URL of the repository here, or leave blank for default

-#website: <module_website> # If you have a separate project website, put it here

-#icon: <icon_url> # Put a URL to a square image here that will be used as an icon on CGRAN

----

-A longer, multi-line description of gr-howto.

-You may use some *basic* Markdown here.

-If left empty, it will try to find a README file instead.

-# Copyright 2011 Free Software Foundation, Inc.

-#

-# This file was generated by gr_modtool, a tool from the GNU Radio framework

-# This file is a part of gr-howto

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-include(GrPython)

-

-GR_PYTHON_INSTALL(

- PROGRAMS

- DESTINATION bin

-)

-# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords> <multi_value_keywords> args...)

-#

-# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions for

-# parsing the arguments given to that macro or function.

-# It processes the arguments and defines a set of variables which hold the

-# values of the respective options.

-#

-# The <options> argument contains all options for the respective macro,

-# i.e. keywords which can be used when calling the macro without any value

-# following, like e.g. the OPTIONAL keyword of the install() command.

-#

-# The <one_value_keywords> argument contains all keywords for this macro

-# which are followed by one value, like e.g. DESTINATION keyword of the

-# install() command.

-#

-# The <multi_value_keywords> argument contains all keywords for this macro

-# which can be followed by more than one value, like e.g. the TARGETS or

-# FILES keywords of the install() command.

-#

-# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the

-# keywords listed in <options>, <one_value_keywords> and

-# <multi_value_keywords> a variable composed of the given <prefix>

-# followed by "_" and the name of the respective keyword.

-# These variables will then hold the respective value from the argument list.

-# For the <options> keywords this will be TRUE or FALSE.

-#

-# All remaining arguments are collected in a variable

-# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see whether

-# your macro was called with unrecognized parameters.

-#

-# As an example here a my_install() macro, which takes similar arguments as the

-# real install() command:

-#

-# function(MY_INSTALL)

-# set(options OPTIONAL FAST)

-# set(oneValueArgs DESTINATION RENAME)

-# set(multiValueArgs TARGETS CONFIGURATIONS)

-# cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )

-# ...

-#

-# Assume my_install() has been called like this:

-# my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)

-#

-# After the cmake_parse_arguments() call the macro will have set the following

-# variables:

-# MY_INSTALL_OPTIONAL = TRUE

-# MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()

-# MY_INSTALL_DESTINATION = "bin"

-# MY_INSTALL_RENAME = "" (was not used)

-# MY_INSTALL_TARGETS = "foo;bar"

-# MY_INSTALL_CONFIGURATIONS = "" (was not used)

-# MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"

-#

-# You can the continue and process these variables.

-#

-# Keywords terminate lists of values, e.g. if directly after a one_value_keyword

-# another recognized keyword follows, this is interpreted as the beginning of

-# the new option.

-# E.g. my_install(TARGETS foo DESTINATION OPTIONAL) would result in

-# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION would

-# be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefore.

-

-#=============================================================================

-# Copyright 2010 Alexander Neundorf <neundorf@kde.org>

-#

-# Distributed under the OSI-approved BSD License (the "License");

-# see accompanying file Copyright.txt for details.

-#

-# This software is distributed WITHOUT ANY WARRANTY; without even the

-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

-# See the License for more information.

-#=============================================================================

-# (To distribute this file outside of CMake, substitute the full

-# License text for the above reference.)

-

-

-if(__CMAKE_PARSE_ARGUMENTS_INCLUDED)

- return()

-endif()

-set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE)

-

-

-function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames)

- # first set all result variables to empty/FALSE

- foreach(arg_name ${_singleArgNames} ${_multiArgNames})

- set(${prefix}_${arg_name})

- endforeach(arg_name)

-

- foreach(option ${_optionNames})

- set(${prefix}_${option} FALSE)

- endforeach(option)

-

- set(${prefix}_UNPARSED_ARGUMENTS)

-

- set(insideValues FALSE)

- set(currentArgName)

-

- # now iterate over all arguments and fill the result variables

- foreach(currentArg ${ARGN})

- list(FIND _optionNames "${currentArg}" optionIndex) # ... then this marks the end of the arguments belonging to this keyword

- list(FIND _singleArgNames "${currentArg}" singleArgIndex) # ... then this marks the end of the arguments belonging to this keyword

- list(FIND _multiArgNames "${currentArg}" multiArgIndex) # ... then this marks the end of the arguments belonging to this keyword

-

- if(${optionIndex} EQUAL -1 AND ${singleArgIndex} EQUAL -1 AND ${multiArgIndex} EQUAL -1)

- if(insideValues)

- if("${insideValues}" STREQUAL "SINGLE")

- set(${prefix}_${currentArgName} ${currentArg})

- set(insideValues FALSE)

- elseif("${insideValues}" STREQUAL "MULTI")

- list(APPEND ${prefix}_${currentArgName} ${currentArg})

- endif()

- else(insideValues)

- list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg})

- endif(insideValues)

- else()

- if(NOT ${optionIndex} EQUAL -1)

- set(${prefix}_${currentArg} TRUE)

- set(insideValues FALSE)

- elseif(NOT ${singleArgIndex} EQUAL -1)

- set(currentArgName ${currentArg})

- set(${prefix}_${currentArgName})

- set(insideValues "SINGLE")

- elseif(NOT ${multiArgIndex} EQUAL -1)

- set(currentArgName ${currentArg})

- set(${prefix}_${currentArgName})

- set(insideValues "MULTI")

- endif()

- endif()

-

- endforeach(currentArg)

-

- # propagate the result variables to the caller:

- foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames})

- set(${prefix}_${arg_name} ${${prefix}_${arg_name}} PARENT_SCOPE)

- endforeach(arg_name)

- set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE)

-

-endfunction(CMAKE_PARSE_ARGUMENTS _options _singleArgs _multiArgs)

-INCLUDE(FindPkgConfig)

-PKG_CHECK_MODULES(PC_HOWTO howto)

-

-FIND_PATH(

- HOWTO_INCLUDE_DIRS

- NAMES howto/api.h

- HINTS $ENV{HOWTO_DIR}/include

- ${PC_HOWTO_INCLUDEDIR}

- PATHS ${CMAKE_INSTALL_PREFIX}/include

- /usr/local/include

- /usr/include

-)

-

-FIND_LIBRARY(

- HOWTO_LIBRARIES

- NAMES gnuradio-howto

- HINTS $ENV{HOWTO_DIR}/lib

- ${PC_HOWTO_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}/howtoTarget.cmake")

-

-INCLUDE(FindPackageHandleStandardArgs)

-FIND_PACKAGE_HANDLE_STANDARD_ARGS(HOWTO DEFAULT_MSG HOWTO_LIBRARIES HOWTO_INCLUDE_DIRS)

-MARK_AS_ADVANCED(HOWTO_LIBRARIES HOWTO_INCLUDE_DIRS)

-# Copyright 2018 Free Software Foundation, Inc.

-#

-# This file is part of GNU Radio

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-include(CMakeFindDependencyMacro)

-

-set(target_deps "@TARGET_DEPENDENCIES@")

-foreach(dep IN LISTS target_deps)

- find_dependency(${dep})

-endforeach()

-include("${CMAKE_CURRENT_LIST_DIR}/@TARGET@Targets.cmake")

-# http://www.vtk.org/Wiki/CMake_FAQ#Can_I_do_.22make_uninstall.22_with_CMake.3F

-

-IF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")

- MESSAGE(FATAL_ERROR "Cannot find install manifest: \"@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt\"")

-ENDIF(NOT EXISTS "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt")

-

-FILE(READ "@CMAKE_CURRENT_BINARY_DIR@/install_manifest.txt" files)

-STRING(REGEX REPLACE "\n" ";" files "${files}")

-FOREACH(file ${files})

- MESSAGE(STATUS "Uninstalling \"$ENV{DESTDIR}${file}\"")

- IF(EXISTS "$ENV{DESTDIR}${file}")

- EXEC_PROGRAM(

- "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""

- OUTPUT_VARIABLE rm_out

- RETURN_VALUE rm_retval

- )

- IF(NOT "${rm_retval}" STREQUAL 0)

- MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")

- ENDIF(NOT "${rm_retval}" STREQUAL 0)

- ELSEIF(IS_SYMLINK "$ENV{DESTDIR}${file}")

- EXEC_PROGRAM(

- "@CMAKE_COMMAND@" ARGS "-E remove \"$ENV{DESTDIR}${file}\""

- OUTPUT_VARIABLE rm_out

- RETURN_VALUE rm_retval

- )

- IF(NOT "${rm_retval}" STREQUAL 0)

- MESSAGE(FATAL_ERROR "Problem when removing \"$ENV{DESTDIR}${file}\"")

- ENDIF(NOT "${rm_retval}" STREQUAL 0)

- ELSE(EXISTS "$ENV{DESTDIR}${file}")

- MESSAGE(STATUS "File \"$ENV{DESTDIR}${file}\" does not exist.")

- ENDIF(EXISTS "$ENV{DESTDIR}${file}")

-ENDFOREACH(file)

-# Copyright 2011 Free Software Foundation, Inc.

-#

-# This file was generated by gr_modtool, a tool from the GNU Radio framework

-# This file is a part of gr-howto

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-########################################################################

-# Setup dependencies

-########################################################################

-find_package(Doxygen)

-

-########################################################################

-# Begin conditional configuration

-########################################################################

-if(ENABLE_DOXYGEN)

-

-########################################################################

-# Add subdirectories

-########################################################################

-add_subdirectory(doxygen)

-

-endif(ENABLE_DOXYGEN)

-This is the howto-write-a-block package meant as a guide to building

-out-of-tree packages. To use the howto blocks, the Python namespaces

-is in 'howto', which is imported as:

-

- import howto

-

-See the Doxygen documentation for details about the blocks available

-in this package. A quick listing of the details can be found in Python

-after importing by using:

-

- help(howto)

-# Copyright 2011 Free Software Foundation, Inc.

-#

-# This file was generated by gr_modtool, a tool from the GNU Radio framework

-# This file is a part of gr-howto

-#

-# SPDX-License-Identifier: GPL-3.0-or-later

-#

-

-########################################################################

-# Create the doxygen configuration file

-########################################################################

-file(TO_NATIVE_PATH ${CMAKE_SOURCE_DIR} top_srcdir)

-file(TO_NATIVE_PATH ${CMAKE_BINARY_DIR} top_builddir)

-file(TO_NATIVE_PATH ${CMAKE_SOURCE_DIR} abs_top_srcdir)

-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_xml_docs YES)

-

-configure_file(

- ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in

- ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile

-@ONLY)

-

-set(BUILT_DIRS ${CMAKE_CURRENT_BINARY_DIR}/xml ${CMAKE_CURRENT_BINARY_DIR}/html)

-

-########################################################################

-# Make and install doxygen docs

-########################################################################

-add_custom_command(

- OUTPUT ${BUILT_DIRS}

- COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile

- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}

- COMMENT "Generating documentation with doxygen"

-)

-

-add_custom_target(doxygen_target ALL DEPENDS ${BUILT_DIRS})

-

-install(DIRECTORY ${BUILT_DIRS} DESTINATION ${GR_PKG_DOC_DIR})

-# Doxyfile 1.8.4

-

-# This file describes the settings to be used by the documentation system

-# doxygen (www.doxygen.org) for a project.

-#

-# All text after a double hash (##) is considered a comment and is placed

-# in front of the TAG it is preceding .

-# All text after a hash (#) is considered a comment and will be ignored.

-# The format is:

-# TAG = value [value, ...]

-# For lists items can also be appended using:

-# TAG += value [value, ...]

-# Values that contain spaces should be placed between quotes (" ").

-

-#---------------------------------------------------------------------------

-# Project related configuration options

-#---------------------------------------------------------------------------

-

-# This tag specifies the encoding used for all characters in the config file

-# that follow. The default is UTF-8 which is also the encoding used for all

-# text before the first occurrence of this tag. Doxygen uses libiconv (or the

-# iconv built into libc) for the transcoding. See

-# http://www.gnu.org/software/libiconv for the list of possible encodings.

-

-DOXYFILE_ENCODING = UTF-8

-

-# The PROJECT_NAME tag is a single word (or sequence of words) that should

-# identify the project. Note that if you do not use Doxywizard you need

-# to put quotes around the project name if it contains spaces.

-

-PROJECT_NAME = "GNU Radio's HOWTO Package"

-

-# The PROJECT_NUMBER tag can be used to enter a project or revision number.

-# This could be handy for archiving the generated documentation or

-# if some version control system is used.

-

-PROJECT_NUMBER =

-

-# Using the PROJECT_BRIEF tag one can provide an optional one line description

-# for a project that appears at the top of each page and should give viewer

-# a quick idea about the purpose of the project. Keep the description short.

-

-PROJECT_BRIEF =

-

-# With the PROJECT_LOGO tag one can specify an logo or icon that is

-# included in the documentation. The maximum height of the logo should not

-# exceed 55 pixels and the maximum width should not exceed 200 pixels.

-# Doxygen will copy the logo to the output directory.

-

-PROJECT_LOGO =

-

-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)

-# base path where the generated documentation will be put.

-# If a relative path is entered, it will be relative to the location

-# where doxygen was started. If left blank the current directory will be used.

-

-OUTPUT_DIRECTORY =

-

-# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create

-# 4096 sub-directories (in 2 levels) under the output directory of each output

-# format and will distribute the generated files over these directories.

-# Enabling this option can be useful when feeding doxygen a huge amount of

-# source files, where putting all generated files in the same directory would

-# otherwise cause performance problems for the file system.

-

-CREATE_SUBDIRS = NO

-

-# The OUTPUT_LANGUAGE tag is used to specify the language in which all

-# documentation generated by doxygen is written. Doxygen will use this

-# information to generate all constant output in the proper language.

-# The default language is English, other supported languages are:

-# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,

-# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,

-# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English

-# messages), Korean, Korean-en, Latvian, Lithuanian, Norwegian, Macedonian,

-# Persian, Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic,

-# Slovak, Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.

-

-OUTPUT_LANGUAGE = English

-

-# If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will

-# include brief member descriptions after the members that are listed in

-# the file and class documentation (similar to JavaDoc).

-# Set to NO to disable this.

-

-BRIEF_MEMBER_DESC = YES

-

-# If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend

-# the brief description of a member or function before the detailed description.

-# Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the

-# brief descriptions will be completely suppressed.

-

-REPEAT_BRIEF = YES

-

-# This tag implements a quasi-intelligent brief description abbreviator

-# that is used to form the text in various listings. Each string

-# in this list, if found as the leading text of the brief description, will be

-# stripped from the text and the result after processing the whole list, is

-# used as the annotated text. Otherwise, the brief description is used as-is.

-# If left blank, the following values are used ("$name" is automatically

-# replaced with the name of the entity): "The $name class" "The $name widget"

-# "The $name file" "is" "provides" "specifies" "contains"

-# "represents" "a" "an" "the"

-

-ABBREVIATE_BRIEF =

-

-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then

-# Doxygen will generate a detailed section even if there is only a brief

-# description.

-

-ALWAYS_DETAILED_SEC = YES

-

-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all

-# inherited members of a class in the documentation of that class as if those

-# members were ordinary class members. Constructors, destructors and assignment

-# operators of the base classes will not be shown.

-

-INLINE_INHERITED_MEMB = NO

-

-# If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full

-# path before files name in the file list and in the header files. If set

-# to NO the shortest path that makes the file name unique will be used.

-

-FULL_PATH_NAMES = NO

-

-# If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag

-# can be used to strip a user-defined part of the path. Stripping is

-# only done if one of the specified strings matches the left-hand part of

-# the path. The tag can be used to show relative paths in the file list.

-# If left blank the directory from which doxygen is run is used as the

-# path to strip. Note that you specify absolute paths here, but also

-# relative paths, which will be relative from the directory where doxygen is

-# started.

-

-STRIP_FROM_PATH =

-

-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of

-# the path mentioned in the documentation of a class, which tells

-# the reader which header file to include in order to use a class.

-# If left blank only the name of the header file containing the class

-# definition is used. Otherwise one should specify the include paths that

-# are normally passed to the compiler using the -I flag.

-

-STRIP_FROM_INC_PATH =

-

-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter

-# (but less readable) file names. This can be useful if your file system

-# doesn't support long names like on DOS, Mac, or CD-ROM.

-

-SHORT_NAMES = NO

-

-# If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen

-# will interpret the first line (until the first dot) of a JavaDoc-style

-# comment as the brief description. If set to NO, the JavaDoc

-# comments will behave just like regular Qt-style comments

-# (thus requiring an explicit @brief command for a brief description.)

-

-JAVADOC_AUTOBRIEF = NO

-

-# If the QT_AUTOBRIEF tag is set to YES then Doxygen will

-# interpret the first line (until the first dot) of a Qt-style

-# comment as the brief description. If set to NO, the comments

-# will behave just like regular Qt-style comments (thus requiring

-# an explicit \brief command for a brief description.)

-

-QT_AUTOBRIEF = NO

-

-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen

-# treat a multi-line C++ special comment block (i.e. a block of //! or ///

-# comments) as a brief description. This used to be the default behaviour.

-# The new default is to treat a multi-line C++ comment block as a detailed

-# description. Set this tag to YES if you prefer the old behaviour instead.

-

-MULTILINE_CPP_IS_BRIEF = YES

-

-# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented

-# member inherits the documentation from any documented member that it

-# re-implements.

-

-INHERIT_DOCS = YES

-

-# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce

-# a new page for each member. If set to NO, the documentation of a member will

-# be part of the file/class/namespace that contains it.

-

-SEPARATE_MEMBER_PAGES = NO

-

-# The TAB_SIZE tag can be used to set the number of spaces in a tab.

-# Doxygen uses this value to replace tabs by spaces in code fragments.

-

-TAB_SIZE = 8

-

-# This tag can be used to specify a number of aliases that acts

-# as commands in the documentation. An alias has the form "name=value".

-# For example adding "sideeffect=\par Side Effects:\n" will allow you to

-# put the command \sideeffect (or @sideeffect) in the documentation, which

-# will result in a user-defined paragraph with heading "Side Effects:".

-# You can put \n's in the value part of an alias to insert newlines.

-

-ALIASES =

-

-# This tag can be used to specify a number of word-keyword mappings (TCL only).

-# A mapping has the form "name=value". For example adding

-# "class=itcl::class" will allow you to use the command class in the

-# itcl::class meaning.

-

-TCL_SUBST =

-

-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C

-# sources only. Doxygen will then generate output that is more tailored for C.

-# For instance, some of the names that are used will be different. The list

-# of all members will be omitted, etc.

-

-OPTIMIZE_OUTPUT_FOR_C = NO

-

-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java

-# sources only. Doxygen will then generate output that is more tailored for

-# Java. For instance, namespaces will be presented as packages, qualified

-# scopes will look different, etc.

-

-OPTIMIZE_OUTPUT_JAVA = NO

-

-# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran

-# sources only. Doxygen will then generate output that is more tailored for

-# Fortran.

-

-OPTIMIZE_FOR_FORTRAN = NO

-

-# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL

-# sources. Doxygen will then generate output that is tailored for

-# VHDL.

-

-OPTIMIZE_OUTPUT_VHDL = NO

-

-# Doxygen selects the parser to use depending on the extension of the files it

-# parses. With this tag you can assign which parser to use for a given

-# extension. Doxygen has a built-in mapping, but you can override or extend it

-# using this tag. The format is ext=language, where ext is a file extension,

-# and language is one of the parsers supported by doxygen: IDL, Java,

-# Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C,

-# C++. For instance to make doxygen treat .inc files as Fortran files (default

-# is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note

-# that for custom extensions you also need to set FILE_PATTERNS otherwise the

-# files are not read by doxygen.

-

-EXTENSION_MAPPING =

-

-# If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all

-# comments according to the Markdown format, which allows for more readable

-# documentation. See http://daringfireball.net/projects/markdown/ for details.

-# The output of markdown processing is further processed by doxygen, so you

-# can mix doxygen, HTML, and XML commands with Markdown formatting.

-# Disable only in case of backward compatibilities issues.

-

-MARKDOWN_SUPPORT = YES

-

-# When enabled doxygen tries to link words that correspond to documented

-# classes, or namespaces to their corresponding documentation. Such a link can

-# be prevented in individual cases by by putting a % sign in front of the word

-# or globally by setting AUTOLINK_SUPPORT to NO.

-

-AUTOLINK_SUPPORT = YES

-

-# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want

-# to include (a tag file for) the STL sources as input, then you should

-# set this tag to YES in order to let doxygen match functions declarations and

-# definitions whose arguments contain STL classes (e.g. func(std::string); v.s.

-# func(std::string) {}). This also makes the inheritance and collaboration

-# diagrams that involve STL classes more complete and accurate.

-

-BUILTIN_STL_SUPPORT = YES

-

-# If you use Microsoft's C++/CLI language, you should set this option to YES to

-# enable parsing support.

-

-CPP_CLI_SUPPORT = NO

-

-# Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.

-# Doxygen will parse them like normal C++ but will assume all classes use public

-# instead of private inheritance when no explicit protection keyword is present.

-

-SIP_SUPPORT = NO

-

-# For Microsoft's IDL there are propget and propput attributes to indicate

-# getter and setter methods for a property. Setting this option to YES (the

-# default) will make doxygen replace the get and set methods by a property in

-# the documentation. This will only work if the methods are indeed getting or

-# setting a simple type. If this is not the case, or you want to show the

-# methods anyway, you should set this option to NO.

-

-IDL_PROPERTY_SUPPORT = YES

-

-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC

-# tag is set to YES, then doxygen will reuse the documentation of the first

-# member in the group (if any) for the other members of the group. By default

-# all members of a group must be documented explicitly.

-

-DISTRIBUTE_GROUP_DOC = NO

-

-# Set the SUBGROUPING tag to YES (the default) to allow class member groups of

-# the same type (for instance a group of public functions) to be put as a

-# subgroup of that type (e.g. under the Public Functions section). Set it to

-# NO to prevent subgrouping. Alternatively, this can be done per class using

-# the \nosubgrouping command.

-

-SUBGROUPING = YES

-

-# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and

-# unions are shown inside the group in which they are included (e.g. using

-# @ingroup) instead of on a separate page (for HTML and Man pages) or

-# section (for LaTeX and RTF).

-

-INLINE_GROUPED_CLASSES = NO

-

-# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and

-# unions with only public data fields or simple typedef fields will be shown

-# inline in the documentation of the scope in which they are defined (i.e. file,

-# namespace, or group documentation), provided this scope is documented. If set

-# to NO (the default), structs, classes, and unions are shown on a separate

-# page (for HTML and Man pages) or section (for LaTeX and RTF).

-

-INLINE_SIMPLE_STRUCTS = NO

-

-# When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum

-# is documented as struct, union, or enum with the name of the typedef. So

-# typedef struct TypeS {} TypeT, will appear in the documentation as a struct

-# with name TypeT. When disabled the typedef will appear as a member of a file,

-# namespace, or class. And the struct will be named TypeS. This can typically

-# be useful for C code in case the coding convention dictates that all compound

-# types are typedef'ed and only the typedef is referenced, never the tag name.

-

-TYPEDEF_HIDES_STRUCT = NO

-

-# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This

-# cache is used to resolve symbols given their name and scope. Since this can

-# be an expensive process and often the same symbol appear multiple times in

-# the code, doxygen keeps a cache of pre-resolved symbols. If the cache is too

-# small doxygen will become slower. If the cache is too large, memory is wasted.

-# The cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid

-# range is 0..9, the default is 0, corresponding to a cache size of 2^16 = 65536

-# symbols.

-

-LOOKUP_CACHE_SIZE = 0

-

-#---------------------------------------------------------------------------

-# Build related configuration options

-#---------------------------------------------------------------------------

-

-# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in

-# documentation are documented, even if no documentation was available.

-# Private class members and static file members will be hidden unless

-# the EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES

-

-EXTRACT_ALL = YES

-

-# If the EXTRACT_PRIVATE tag is set to YES all private members of a class

-# will be included in the documentation.

-

-EXTRACT_PRIVATE = NO

-

-# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal

-# scope will be included in the documentation.

-

-EXTRACT_PACKAGE = NO

-

-# If the EXTRACT_STATIC tag is set to YES all static members of a file

-# will be included in the documentation.

-

-EXTRACT_STATIC = YES

-

-# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)

-# defined locally in source files will be included in the documentation.

-# If set to NO only classes defined in header files are included.

-

-EXTRACT_LOCAL_CLASSES = YES

-

-# This flag is only useful for Objective-C code. When set to YES local

-# methods, which are defined in the implementation section but not in

-# the interface are included in the documentation.

-# If set to NO (the default) only methods in the interface are included.

-

-EXTRACT_LOCAL_METHODS = NO

-

-# If this flag is set to YES, the members of anonymous namespaces will be

-# extracted and appear in the documentation as a namespace called

-# 'anonymous_namespace{file}', where file will be replaced with the base

-# name of the file that contains the anonymous namespace. By default

-# anonymous namespaces are hidden.

-

-EXTRACT_ANON_NSPACES = NO

-

-# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all

-# undocumented members of documented classes, files or namespaces.

-# If set to NO (the default) these members will be included in the

-# various overviews, but no documentation section is generated.

-# This option has no effect if EXTRACT_ALL is enabled.

-

-HIDE_UNDOC_MEMBERS = NO

-

-# If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all

-# undocumented classes that are normally visible in the class hierarchy.

-# If set to NO (the default) these classes will be included in the various

-# overviews. This option has no effect if EXTRACT_ALL is enabled.

-

-HIDE_UNDOC_CLASSES = NO

-

-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all

-# friend (class|struct|union) declarations.

-# If set to NO (the default) these declarations will be included in the

-# documentation.

-

-HIDE_FRIEND_COMPOUNDS = NO

-

-# If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any

-# documentation blocks found inside the body of a function.

-# If set to NO (the default) these blocks will be appended to the

-# function's detailed documentation block.

-

-HIDE_IN_BODY_DOCS = NO

-

-# The INTERNAL_DOCS tag determines if documentation

-# that is typed after a \internal command is included. If the tag is set

-# to NO (the default) then the documentation will be excluded.

-# Set it to YES to include the internal documentation.

-

-INTERNAL_DOCS = NO

-

-# If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate

-# file names in lower-case letters. If set to YES upper-case letters are also

-# allowed. This is useful if you have classes or files whose names only differ

-# in case and if your file system supports case sensitive file names. Windows

-# and Mac users are advised to set this option to NO.

-

-CASE_SENSE_NAMES = YES

-

-# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen

-# will show members with their full class and namespace scopes in the

-# documentation. If set to YES the scope will be hidden.

-

-HIDE_SCOPE_NAMES = NO

-

-# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen

-# will put a list of the files that are included by a file in the documentation

-# of that file.

-

-SHOW_INCLUDE_FILES = YES

-

-# If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen

-# will list include files with double quotes in the documentation

-# rather than with sharp brackets.

-

-FORCE_LOCAL_INCLUDES = NO

-

-# If the INLINE_INFO tag is set to YES (the default) then a tag [inline]

-# is inserted in the documentation for inline members.

-

-INLINE_INFO = YES

-

-# If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen

-# will sort the (detailed) documentation of file and class members

-# alphabetically by member name. If set to NO the members will appear in

-# declaration order.

-

-SORT_MEMBER_DOCS = YES

-

-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the

-# brief documentation of file, namespace and class members alphabetically

-# by member name. If set to NO (the default) the members will appear in

-# declaration order.

-

-SORT_BRIEF_DOCS = NO

-

-# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen

-# will sort the (brief and detailed) documentation of class members so that

-# constructors and destructors are listed first. If set to NO (the default)

-# the constructors will appear in the respective orders defined by

-# SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.

-# This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO

-# and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.

-

-SORT_MEMBERS_CTORS_1ST = NO

-

-# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the

-# hierarchy of group names into alphabetical order. If set to NO (the default)

-# the group names will appear in their defined order.

-

-SORT_GROUP_NAMES = NO

-

-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be

-# sorted by fully-qualified names, including namespaces. If set to

-# NO (the default), the class list will be sorted only by class name,

-# not including the namespace part.

-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.

-# Note: This option applies only to the class list, not to the

-# alphabetical list.

-

-SORT_BY_SCOPE_NAME = NO

-

-# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to

-# do proper type resolution of all parameters of a function it will reject a

-# match between the prototype and the implementation of a member function even

-# if there is only one candidate or it is obvious which candidate to choose

-# by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen

-# will still accept a match between prototype and implementation in such cases.

-

-STRICT_PROTO_MATCHING = NO

-

-# The GENERATE_TODOLIST tag can be used to enable (YES) or

-# disable (NO) the todo list. This list is created by putting \todo

-# commands in the documentation.

-

-GENERATE_TODOLIST = NO

-

-# The GENERATE_TESTLIST tag can be used to enable (YES) or

-# disable (NO) the test list. This list is created by putting \test

-# commands in the documentation.

-

-GENERATE_TESTLIST = NO

-

-# The GENERATE_BUGLIST tag can be used to enable (YES) or

-# disable (NO) the bug list. This list is created by putting \bug

-# commands in the documentation.

-

-GENERATE_BUGLIST = NO

-

-# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or

-# disable (NO) the deprecated list. This list is created by putting

-# \deprecated commands in the documentation.

-

-GENERATE_DEPRECATEDLIST= NO

-

-# The ENABLED_SECTIONS tag can be used to enable conditional

-# documentation sections, marked by \if section-label ... \endif

-# and \cond section-label ... \endcond blocks.

-

-ENABLED_SECTIONS =

-

-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines

-# the initial value of a variable or macro consists of for it to appear in

-# the documentation. If the initializer consists of more lines than specified

-# here it will be hidden. Use a value of 0 to hide initializers completely.

-# The appearance of the initializer of individual variables and macros in the

-# documentation can be controlled using \showinitializer or \hideinitializer

-# command in the documentation regardless of this setting.

-

-MAX_INITIALIZER_LINES = 30

-

-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated

-# at the bottom of the documentation of classes and structs. If set to YES the

-# list will mention the files that were used to generate the documentation.

-

-SHOW_USED_FILES = YES

-

-# Set the SHOW_FILES tag to NO to disable the generation of the Files page.

-# This will remove the Files entry from the Quick Index and from the

-# Folder Tree View (if specified). The default is YES.

-

-SHOW_FILES = YES

-

-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the

-# Namespaces page.

-# This will remove the Namespaces entry from the Quick Index

-# and from the Folder Tree View (if specified). The default is YES.

-

-SHOW_NAMESPACES = NO

-

-# The FILE_VERSION_FILTER tag can be used to specify a program or script that

-# doxygen should invoke to get the current version for each file (typically from

-# the version control system). Doxygen will invoke the program by executing (via

-# popen()) the command <command> <input-file>, where <command> is the value of

-# the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file

-# provided by doxygen. Whatever the program writes to standard output

-# is used as the file version. See the manual for examples.

-

-FILE_VERSION_FILTER =

-

-# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed

-# by doxygen. The layout file controls the global structure of the generated

-# output files in an output format independent way. To create the layout file

-# that represents doxygen's defaults, run doxygen with the -l option.

-# You can optionally specify a file name after the option, if omitted

-# DoxygenLayout.xml will be used as the name of the layout file.

-

-LAYOUT_FILE =

-

-# The CITE_BIB_FILES tag can be used to specify one or more bib files

-# containing the references data. This must be a list of .bib files. The

-# .bib extension is automatically appended if omitted. Using this command

-# requires the bibtex tool to be installed. See also

-# http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style

-# of the bibliography can be controlled using LATEX_BIB_STYLE. To use this

-# feature you need bibtex and perl available in the search path. Do not use

-# file names with spaces, bibtex cannot handle them.

-

-CITE_BIB_FILES =

-

-#---------------------------------------------------------------------------

-# configuration options related to warning and progress messages

-#---------------------------------------------------------------------------

-

-# The QUIET tag can be used to turn on/off the messages that are generated

-# by doxygen. Possible values are YES and NO. If left blank NO is used.

-

-QUIET = YES

-

-# The WARNINGS tag can be used to turn on/off the warning messages that are

-# generated by doxygen. Possible values are YES and NO. If left blank

-# NO is used.

-

-WARNINGS = YES

-

-# If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings

-# for undocumented members. If EXTRACT_ALL is set to YES then this flag will

-# automatically be disabled.

-

-WARN_IF_UNDOCUMENTED = YES

-

-# If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for

-# potential errors in the documentation, such as not documenting some

-# parameters in a documented function, or documenting parameters that

-# don't exist or using markup commands wrongly.

-

-WARN_IF_DOC_ERROR = YES

-

-# The WARN_NO_PARAMDOC option can be enabled to get warnings for

-# functions that are documented, but have no documentation for their parameters

-# or return value. If set to NO (the default) doxygen will only warn about

-# wrong or incomplete parameter documentation, but not about the absence of

-# documentation.

-

-WARN_NO_PARAMDOC = NO

-

-# The WARN_FORMAT tag determines the format of the warning messages that

-# doxygen can produce. The string should contain the $file, $line, and $text

-# tags, which will be replaced by the file and line number from which the

-# warning originated and the warning text. Optionally the format may contain

-# $version, which will be replaced by the version of the file (if it could

-# be obtained via FILE_VERSION_FILTER)

-

-WARN_FORMAT = "$file:$line: $text "

-

-# The WARN_LOGFILE tag can be used to specify a file to which warning

-# and error messages should be written. If left blank the output is written

-# to stderr.

-

-WARN_LOGFILE =

-

-#---------------------------------------------------------------------------

-# configuration options related to the input files

-#---------------------------------------------------------------------------

-

-# The INPUT tag can be used to specify the files and/or directories that contain

-# documented source files. You may enter file names like "myfile.cpp" or

-# directories like "/usr/src/myproject". Separate the files or directories

-# with spaces.

-

-INPUT = "@top_srcdir@" \

- "@top_builddir@"

-

-# This tag can be used to specify the character encoding of the source files

-# that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is

-# also the default input encoding. Doxygen uses libiconv (or the iconv built

-# into libc) for the transcoding. See http://www.gnu.org/software/libiconv for

-# the list of possible encodings.

-

-INPUT_ENCODING = UTF-8

-

-# If the value of the INPUT tag contains directories, you can use the

-# FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp

-# and *.h) to filter out the source-files in the directories. If left

-# blank the following patterns are tested:

-# *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh

-# *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py

-# *.f90 *.f *.for *.vhd *.vhdl

-

-FILE_PATTERNS = *.h \

- *.dox

-

-# The RECURSIVE tag can be used to turn specify whether or not subdirectories

-# should be searched for input files as well. Possible values are YES and NO.

-# If left blank NO is used.

-

-RECURSIVE = YES

-

-# The EXCLUDE tag can be used to specify files and/or directories that should be

-# excluded from the INPUT source files. This way you can easily exclude a

-# subdirectory from a directory tree whose root is specified with the INPUT tag.

-# Note that relative paths are relative to the directory from which doxygen is

-# run.

-

-EXCLUDE = @abs_top_builddir@/docs/doxygen/html \

- @abs_top_builddir@/docs/doxygen/xml \

- @abs_top_builddir@/docs/doxygen/other/doxypy.py \

- @abs_top_builddir@/_CPack_Packages \

- @abs_top_srcdir@/cmake

-

-# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or

-# directories that are symbolic links (a Unix file system feature) are excluded

-# from the input.

-

-EXCLUDE_SYMLINKS = NO

-

-# If the value of the INPUT tag contains directories, you can use the

-# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude

-# certain files from those directories. Note that the wildcards are matched

-# against the file with absolute path, so to exclude all test directories

-# for example use the pattern */test/*

-

-EXCLUDE_PATTERNS = */.deps/* \

- */.libs/* \

- */.svn/* \

- */CVS/* \

- */__init__.py \

- */qa_*.cc \

- */qa_*.h \

- */qa_*.py

-

-# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names

-# (namespaces, classes, functions, etc.) that should be excluded from the

-# output. The symbol name can be a fully qualified name, a word, or if the

-# wildcard * is used, a substring. Examples: ANamespace, AClass,

-# AClass::ANamespace, ANamespace::*Test

-

-EXCLUDE_SYMBOLS = ad9862 \

- numpy \

- *swig* \

- *Swig* \

- *my_top_block* \

- *my_graph* \

- *app_top_block* \

- *am_rx_graph* \

- *_queue_watcher_thread* \

- *parse* \

- *MyFrame* \

- *MyApp* \

- *PyObject* \

- *wfm_rx_block* \

- *_sptr* \

- *debug* \

- *wfm_rx_sca_block* \

- *tv_rx_block* \

- *wxapt_rx_block* \

- *example_signal*

-

-# The EXAMPLE_PATH tag can be used to specify one or more files or

-# directories that contain example code fragments that are included (see

-# the \include command).

-

-EXAMPLE_PATH =

-

-# If the value of the EXAMPLE_PATH tag contains directories, you can use the

-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp

-# and *.h) to filter out the source-files in the directories. If left

-# blank all files are included.

-

-EXAMPLE_PATTERNS =

-

-# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be

-# searched for input files to be used with the \include or \dontinclude

-# commands irrespective of the value of the RECURSIVE tag.

-# Possible values are YES and NO. If left blank NO is used.

-

-EXAMPLE_RECURSIVE = NO

-

-# The IMAGE_PATH tag can be used to specify one or more files or

-# directories that contain image that are included in the documentation (see

-# the \image command).

-

-IMAGE_PATH =

-

-# The INPUT_FILTER tag can be used to specify a program that doxygen should

-# invoke to filter for each input file. Doxygen will invoke the filter program

-# by executing (via popen()) the command <filter> <input-file>, where <filter>

-# is the value of the INPUT_FILTER tag, and <input-file> is the name of an

-# input file. Doxygen will then use the output that the filter program writes

-# to standard output.

-# If FILTER_PATTERNS is specified, this tag will be ignored.

-# Note that the filter must not add or remove lines; it is applied before the

-# code is scanned, but not when the output code is generated. If lines are added

-# or removed, the anchors will not be placed correctly.

-

-INPUT_FILTER =

-

-# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern

-# basis.

-# Doxygen will compare the file name with each pattern and apply the

-# filter if there is a match.

-# The filters are a list of the form:

-# pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further

-# info on how filters are used. If FILTER_PATTERNS is empty or if

-# non of the patterns match the file name, INPUT_FILTER is applied.

-

-FILTER_PATTERNS = *.py="@top_srcdir@"/doc/doxygen/other/doxypy.py

-

-# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using

-# INPUT_FILTER) will be used to filter the input files when producing source

-# files to browse (i.e. when SOURCE_BROWSER is set to YES).

-

-FILTER_SOURCE_FILES = NO

-

-# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file

-# pattern. A pattern will override the setting for FILTER_PATTERN (if any)

-# and it is also possible to disable source filtering for a specific pattern

-# using *.ext= (so without naming a filter). This option only has effect when

-# FILTER_SOURCE_FILES is enabled.

-

-FILTER_SOURCE_PATTERNS =

-

-# If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that

-# is part of the input, its contents will be placed on the main page

-# (index.html). This can be useful if you have a project on for instance GitHub

-# and want reuse the introduction page also for the doxygen output.

-

-USE_MDFILE_AS_MAINPAGE =

-

-#---------------------------------------------------------------------------

-# configuration options related to source browsing

-#---------------------------------------------------------------------------

-

-# If the SOURCE_BROWSER tag is set to YES then a list of source files will

-# be generated. Documented entities will be cross-referenced with these sources.

-# Note: To get rid of all source code in the generated output, make sure also

-# VERBATIM_HEADERS is set to NO.

-

-SOURCE_BROWSER = NO

-

-# Setting the INLINE_SOURCES tag to YES will include the body

-# of functions and classes directly in the documentation.

-

-INLINE_SOURCES = NO

-

-# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct

-# doxygen to hide any special comment blocks from generated source code

-# fragments. Normal C, C++ and Fortran comments will always remain visible.

-

-STRIP_CODE_COMMENTS = NO

-

-# If the REFERENCED_BY_RELATION tag is set to YES

-# then for each documented function all documented

-# functions referencing it will be listed.

-

-REFERENCED_BY_RELATION = YES

-

-# If the REFERENCES_RELATION tag is set to YES

-# then for each documented function all documented entities

-# called/used by that function will be listed.

-

-REFERENCES_RELATION = YES

-

-# If the REFERENCES_LINK_SOURCE tag is set to YES (the default)

-# and SOURCE_BROWSER tag is set to YES, then the hyperlinks from

-# functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will

-# link to the source code.

-# Otherwise they will link to the documentation.

-

-REFERENCES_LINK_SOURCE = YES

-

-# If the USE_HTAGS tag is set to YES then the references to source code

-# will point to the HTML generated by the htags(1) tool instead of doxygen

-# built-in source browser. The htags tool is part of GNU's global source

-# tagging system (see http://www.gnu.org/software/global/global.html). You

-# will need version 4.8.6 or higher.

-

-USE_HTAGS = NO

-

-# If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen

-# will generate a verbatim copy of the header file for each class for

-# which an include is specified. Set to NO to disable this.

-

-VERBATIM_HEADERS = YES

-

-#---------------------------------------------------------------------------

-# configuration options related to the alphabetical class index

-#---------------------------------------------------------------------------

-

-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index

-# of all compounds will be generated. Enable this if the project

-# contains a lot of classes, structs, unions or interfaces.

-

-ALPHABETICAL_INDEX = YES

-

-# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then

-# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns

-# in which this list will be split (can be a number in the range [1..20])

-

-COLS_IN_ALPHA_INDEX = 5

-

-# In case all classes in a project start with a common prefix, all

-# classes will be put under the same header in the alphabetical index.

-# The IGNORE_PREFIX tag can be used to specify one or more prefixes that

-# should be ignored while generating the index headers.

-

-IGNORE_PREFIX =

-

-#---------------------------------------------------------------------------

-# configuration options related to the HTML output

-#---------------------------------------------------------------------------

-

-# If the GENERATE_HTML tag is set to YES (the default) Doxygen will

-# generate HTML output.

-

-GENERATE_HTML = @enable_html_docs@

-

-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put.

-# If a relative path is entered the value of OUTPUT_DIRECTORY will be

-# put in front of it. If left blank `html' will be used as the default path.

-

-HTML_OUTPUT = html

-

-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for

-# each generated HTML page (for example: .htm,.php,.asp). If it is left blank

-# doxygen will generate files with .html extension.

-

-HTML_FILE_EXTENSION = .html

-

-# The HTML_HEADER tag can be used to specify a personal HTML header for

-# each generated HTML page. If it is left blank doxygen will generate a

-# standard header. Note that when using a custom header you are responsible

-# for the proper inclusion of any scripts and style sheets that doxygen

-# needs, which is dependent on the configuration options used.

-# It is advised to generate a default header using "doxygen -w html

-# header.html footer.html stylesheet.css YourConfigFile" and then modify

-# that header. Note that the header is subject to change so you typically

-# have to redo this when upgrading to a newer version of doxygen or when

-# changing the value of configuration settings such as GENERATE_TREEVIEW!

-

-HTML_HEADER =

-

-# The HTML_FOOTER tag can be used to specify a personal HTML footer for

-# each generated HTML page. If it is left blank doxygen will generate a

-# standard footer.

-

-HTML_FOOTER =

-

-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading

-# style sheet that is used by each HTML page. It can be used to

-# fine-tune the look of the HTML output. If left blank doxygen will

-# generate a default style sheet. Note that it is recommended to use

-# HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this

-# tag will in the future become obsolete.

-

-HTML_STYLESHEET =

-

-# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional

-# user-defined cascading style sheet that is included after the standard

-# style sheets created by doxygen. Using this option one can overrule

-# certain style aspects. This is preferred over using HTML_STYLESHEET

-# since it does not replace the standard style sheet and is therefore more

-# robust against future updates. Doxygen will copy the style sheet file to

-# the output directory.

-

-HTML_EXTRA_STYLESHEET =

-

-# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or

-# other source files which should be copied to the HTML output directory. Note

-# that these files will be copied to the base HTML output directory. Use the

-# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these

-# files. In the HTML_STYLESHEET file, use the file name only. Also note that

-# the files will be copied as-is; there are no commands or markers available.

-

-HTML_EXTRA_FILES =

-

-# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.

-# Doxygen will adjust the colors in the style sheet and background images

-# according to this color. Hue is specified as an angle on a colorwheel,

-# see http://en.wikipedia.org/wiki/Hue for more information.

-# For instance the value 0 represents red, 60 is yellow, 120 is green,

-# 180 is cyan, 240 is blue, 300 purple, and 360 is red again.

-# The allowed range is 0 to 359.

-

-HTML_COLORSTYLE_HUE = 220

-

-# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of

-# the colors in the HTML output. For a value of 0 the output will use

-# grayscales only. A value of 255 will produce the most vivid colors.

-

-HTML_COLORSTYLE_SAT = 100

-

-# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to

-# the luminance component of the colors in the HTML output. Values below

-# 100 gradually make the output lighter, whereas values above 100 make

-# the output darker. The value divided by 100 is the actual gamma applied,

-# so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,

-# and 100 does not change the gamma.

-

-HTML_COLORSTYLE_GAMMA = 80

-

-# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML

-# page will contain the date and time when the page was generated. Setting

-# this to NO can help when comparing the output of multiple runs.

-

-HTML_TIMESTAMP = NO

-

-# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML

-# documentation will contain sections that can be hidden and shown after the

-# page has loaded.

-

-HTML_DYNAMIC_SECTIONS = NO

-

-# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of

-# entries shown in the various tree structured indices initially; the user

-# can expand and collapse entries dynamically later on. Doxygen will expand

-# the tree to such a level that at most the specified number of entries are

-# visible (unless a fully collapsed tree already exceeds this amount).

-# So setting the number of entries 1 will produce a full collapsed tree by

-# default. 0 is a special value representing an infinite number of entries

-# and will result in a full expanded tree by default.

-

-HTML_INDEX_NUM_ENTRIES = 100

-

-# If the GENERATE_DOCSET tag is set to YES, additional index files

-# will be generated that can be used as input for Apple's Xcode 3

-# integrated development environment, introduced with OSX 10.5 (Leopard).

-# To create a documentation set, doxygen will generate a Makefile in the

-# HTML output directory. Running make will produce the docset in that

-# directory and running "make install" will install the docset in

-# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find

-# it at startup.

-# See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html

-# for more information.

-

-GENERATE_DOCSET = NO

-

-# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the

-# feed. A documentation feed provides an umbrella under which multiple

-# documentation sets from a single provider (such as a company or product suite)

-# can be grouped.

-

-DOCSET_FEEDNAME = "Doxygen generated docs"

-

-# When GENERATE_DOCSET tag is set to YES, this tag specifies a string that

-# should uniquely identify the documentation set bundle. This should be a

-# reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen

-# will append .docset to the name.

-

-DOCSET_BUNDLE_ID = org.doxygen.Project

-

-# When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely

-# identify the documentation publisher. This should be a reverse domain-name

-# style string, e.g. com.mycompany.MyDocSet.documentation.

-

-DOCSET_PUBLISHER_ID = org.doxygen.Publisher

-

-# The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.

-

-DOCSET_PUBLISHER_NAME = Publisher

-

-# If the GENERATE_HTMLHELP tag is set to YES, additional index files

-# will be generated that can be used as input for tools like the

-# Microsoft HTML help workshop to generate a compiled HTML help file (.chm)

-# of the generated HTML documentation.

-

-GENERATE_HTMLHELP = NO

-

-# If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can

-# be used to specify the file name of the resulting .chm file. You

-# can add a path in front of the file if the result should not be

-# written to the html output directory.

-

-CHM_FILE =

-

-# If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can

-# be used to specify the location (absolute path including file name) of

-# the HTML help compiler (hhc.exe). If non-empty doxygen will try to run

-# the HTML help compiler on the generated index.hhp.

-

-HHC_LOCATION =

-

-# If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag

-# controls if a separate .chi index file is generated (YES) or that

-# it should be included in the master .chm file (NO).

-

-GENERATE_CHI = NO

-

-# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING

-# is used to encode HtmlHelp index (hhk), content (hhc) and project file

-# content.

-

-CHM_INDEX_ENCODING =

-

-# If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag

-# controls whether a binary table of contents is generated (YES) or a

-# normal table of contents (NO) in the .chm file.

-

-BINARY_TOC = NO

-

-# The TOC_EXPAND flag can be set to YES to add extra items for group members

-# to the contents of the HTML help documentation and to the tree view.

-

-TOC_EXPAND = YES

-

-# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and

-# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated

-# that can be used as input for Qt's qhelpgenerator to generate a

-# Qt Compressed Help (.qch) of the generated HTML documentation.

-

-GENERATE_QHP = NO

-

-# If the QHG_LOCATION tag is specified, the QCH_FILE tag can

-# be used to specify the file name of the resulting .qch file.

-# The path specified is relative to the HTML output folder.

-

-QCH_FILE =

-

-# The QHP_NAMESPACE tag specifies the namespace to use when generating

-# Qt Help Project output. For more information please see

-# http://doc.trolltech.com/qthelpproject.html#namespace

-

-QHP_NAMESPACE = org.doxygen.Project

-

-# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating

-# Qt Help Project output. For more information please see

-# http://doc.trolltech.com/qthelpproject.html#virtual-folders

-

-QHP_VIRTUAL_FOLDER = doc

-

-# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to

-# add. For more information please see

-# http://doc.trolltech.com/qthelpproject.html#custom-filters

-

-QHP_CUST_FILTER_NAME =

-

-# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the

-# custom filter to add. For more information please see

-# <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">

-# Qt Help Project / Custom Filters</a>.

-

-QHP_CUST_FILTER_ATTRS =

-

-# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this

-# project's

-# filter section matches.

-# <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">

-# Qt Help Project / Filter Attributes</a>.

-

-QHP_SECT_FILTER_ATTRS =

-

-# If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can

-# be used to specify the location of Qt's qhelpgenerator.

-# If non-empty doxygen will try to run qhelpgenerator on the generated

-# .qhp file.

-

-QHG_LOCATION =

-

-# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files

-# will be generated, which together with the HTML files, form an Eclipse help

-# plugin. To install this plugin and make it available under the help contents

-# menu in Eclipse, the contents of the directory containing the HTML and XML

-# files needs to be copied into the plugins directory of eclipse. The name of

-# the directory within the plugins directory should be the same as

-# the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before

-# the help appears.

-

-GENERATE_ECLIPSEHELP = NO

-

-# A unique identifier for the eclipse help plugin. When installing the plugin

-# the directory name containing the HTML and XML files should also have

-# this name.

-

-ECLIPSE_DOC_ID = org.doxygen.Project

-

-# The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)

-# at top of each HTML page. The value NO (the default) enables the index and

-# the value YES disables it. Since the tabs have the same information as the

-# navigation tree you can set this option to NO if you already set

-# GENERATE_TREEVIEW to YES.

-

-DISABLE_INDEX = YES

-

-# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index

-# structure should be generated to display hierarchical information.

-# If the tag value is set to YES, a side panel will be generated

-# containing a tree-like index structure (just like the one that

-# is generated for HTML Help). For this to work a browser that supports

-# JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).

-# Windows users are probably better off using the HTML help feature.

-# Since the tree basically has the same information as the tab index you

-# could consider to set DISABLE_INDEX to NO when enabling this option.

-

-GENERATE_TREEVIEW = YES

-

-# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values

-# (range [0,1..20]) that doxygen will group on one line in the generated HTML

-# documentation. Note that a value of 0 will completely suppress the enum

-# values from appearing in the overview section.

-

-ENUM_VALUES_PER_LINE = 4

-

-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be

-# used to set the initial width (in pixels) of the frame in which the tree

-# is shown.

-

-TREEVIEW_WIDTH = 180

-

-# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open

-# links to external symbols imported via tag files in a separate window.

-

-EXT_LINKS_IN_WINDOW = NO

-

-# Use this tag to change the font size of Latex formulas included

-# as images in the HTML documentation. The default is 10. Note that

-# when you change the font size after a successful doxygen run you need

-# to manually remove any form_*.png images from the HTML output directory

-# to force them to be regenerated.

-

-FORMULA_FONTSIZE = 10

-

-# Use the FORMULA_TRANPARENT tag to determine whether or not the images

-# generated for formulas are transparent PNGs. Transparent PNGs are

-# not supported properly for IE 6.0, but are supported on all modern browsers.

-# Note that when changing this option you need to delete any form_*.png files

-# in the HTML output before the changes have effect.

-

-FORMULA_TRANSPARENT = YES

-

-# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax

-# (see http://www.mathjax.org) which uses client side Javascript for the

-# rendering instead of using prerendered bitmaps. Use this if you do not

-# have LaTeX installed or if you want to formulas look prettier in the HTML

-# output. When enabled you may also need to install MathJax separately and

-# configure the path to it using the MATHJAX_RELPATH option.

-

-USE_MATHJAX = NO

-

-# When MathJax is enabled you can set the default output format to be used for

-# the MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and

-# SVG. The default value is HTML-CSS, which is slower, but has the best

-# compatibility.

-

-MATHJAX_FORMAT = HTML-CSS

-

-# When MathJax is enabled you need to specify the location relative to the

-# HTML output directory using the MATHJAX_RELPATH option. The destination

-# directory should contain the MathJax.js script. For instance, if the mathjax

-# directory is located at the same level as the HTML output directory, then

-# MATHJAX_RELPATH should be ../mathjax. The default value points to

-# the MathJax Content Delivery Network so you can quickly see the result without

-# installing MathJax.

-# However, it is strongly recommended to install a local

-# copy of MathJax from http://www.mathjax.org before deployment.

-

-MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest

-

-# The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension

-# names that should be enabled during MathJax rendering.

-

-MATHJAX_EXTENSIONS =

-

-# The MATHJAX_CODEFILE tag can be used to specify a file with javascript

-# pieces of code that will be used on startup of the MathJax code.

-

-MATHJAX_CODEFILE =

-

-# When the SEARCHENGINE tag is enabled doxygen will generate a search box

-# for the HTML output. The underlying search engine uses javascript

-# and DHTML and should work on any modern browser. Note that when using

-# HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets

-# (GENERATE_DOCSET) there is already a search function so this one should

-# typically be disabled. For large projects the javascript based search engine

-# can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.

-

-SEARCHENGINE = NO

-

-# When the SERVER_BASED_SEARCH tag is enabled the search engine will be

-# implemented using a web server instead of a web client using Javascript.

-# There are two flavours of web server based search depending on the

-# EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for

-# searching and an index file used by the script. When EXTERNAL_SEARCH is

-# enabled the indexing and searching needs to be provided by external tools.

-# See the manual for details.

-

-SERVER_BASED_SEARCH = NO

-

-# When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP

-# script for searching. Instead the search results are written to an XML file

-# which needs to be processed by an external indexer. Doxygen will invoke an

-# external search engine pointed to by the SEARCHENGINE_URL option to obtain

-# the search results. Doxygen ships with an example indexer (doxyindexer) and

-# search engine (doxysearch.cgi) which are based on the open source search

-# engine library Xapian. See the manual for configuration details.

-

-EXTERNAL_SEARCH = NO

-

-# The SEARCHENGINE_URL should point to a search engine hosted by a web server

-# which will returned the search results when EXTERNAL_SEARCH is enabled.

-# Doxygen ships with an example search engine (doxysearch) which is based on

-# the open source search engine library Xapian. See the manual for configuration

-# details.

-

-SEARCHENGINE_URL =

-

-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed

-# search data is written to a file for indexing by an external tool. With the

-# SEARCHDATA_FILE tag the name of this file can be specified.

-

-SEARCHDATA_FILE = searchdata.xml

-

-# When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the

-# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is

-# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple

-# projects and redirect the results back to the right project.

-

-EXTERNAL_SEARCH_ID =

-

-# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen

-# projects other than the one defined by this configuration file, but that are

-# all added to the same external search index. Each project needs to have a

-# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id

-# of to a relative location where the documentation can be found.

-# The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ...

-

-EXTRA_SEARCH_MAPPINGS =

-

-#---------------------------------------------------------------------------

-# configuration options related to the LaTeX output

-#---------------------------------------------------------------------------

-

-# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will

-# generate Latex output.

-

-GENERATE_LATEX = @enable_latex_docs@

-

-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.

-# If a relative path is entered the value of OUTPUT_DIRECTORY will be

-# put in front of it. If left blank `latex' will be used as the default path.

-

-LATEX_OUTPUT = latex

-

-# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be

-# invoked. If left blank `latex' will be used as the default command name.

-# Note that when enabling USE_PDFLATEX this option is only used for

-# generating bitmaps for formulas in the HTML output, but not in the

-# Makefile that is written to the output directory.

-

-LATEX_CMD_NAME = latex

-

-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to

-# generate index for LaTeX. If left blank `makeindex' will be used as the

-# default command name.

-

-MAKEINDEX_CMD_NAME = makeindex

-

-# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact

-# LaTeX documents. This may be useful for small projects and may help to

-# save some trees in general.

-

-COMPACT_LATEX = NO

-

-# The PAPER_TYPE tag can be used to set the paper type that is used

-# by the printer. Possible values are: a4, letter, legal and

-# executive. If left blank a4 will be used.

-

-PAPER_TYPE = letter

-

-# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX

-# packages that should be included in the LaTeX output.

-

-EXTRA_PACKAGES =

-

-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for

-# the generated latex document. The header should contain everything until

-# the first chapter. If it is left blank doxygen will generate a

-# standard header. Notice: only use this tag if you know what you are doing!

-

-LATEX_HEADER =

-

-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for

-# the generated latex document. The footer should contain everything after

-# the last chapter. If it is left blank doxygen will generate a

-# standard footer. Notice: only use this tag if you know what you are doing!

-

-LATEX_FOOTER =

-

-# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images

-# or other source files which should be copied to the LaTeX output directory.

-# Note that the files will be copied as-is; there are no commands or markers

-# available.

-

-LATEX_EXTRA_FILES =

-

-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated

-# is prepared for conversion to pdf (using ps2pdf). The pdf file will

-# contain links (just like the HTML output) instead of page references

-# This makes the output suitable for online browsing using a pdf viewer.

-

-PDF_HYPERLINKS = YES

-

-# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of

-# plain latex in the generated Makefile. Set this option to YES to get a

-# higher quality PDF documentation.

-

-USE_PDFLATEX = NO

-

-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.

-# command to the generated LaTeX files. This will instruct LaTeX to keep

-# running if errors occur, instead of asking the user for help.

-# This option is also used when generating formulas in HTML.

-

-LATEX_BATCHMODE = NO

-

-# If LATEX_HIDE_INDICES is set to YES then doxygen will not

-# include the index chapters (such as File Index, Compound Index, etc.)

-# in the output.

-

-LATEX_HIDE_INDICES = NO

-

-# If LATEX_SOURCE_CODE is set to YES then doxygen will include

-# source code with syntax highlighting in the LaTeX output.

-# Note that which sources are shown also depends on other settings

-# such as SOURCE_BROWSER.

-

-LATEX_SOURCE_CODE = NO

-

-# The LATEX_BIB_STYLE tag can be used to specify the style to use for the

-# bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See

-# http://en.wikipedia.org/wiki/BibTeX for more info.

-

-LATEX_BIB_STYLE = plain

-

-#---------------------------------------------------------------------------

-# configuration options related to the RTF output

-#---------------------------------------------------------------------------

-

-# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output

-# The RTF output is optimized for Word 97 and may not look very pretty with

-# other RTF readers or editors.

-

-GENERATE_RTF = NO

-

-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put.

-# If a relative path is entered the value of OUTPUT_DIRECTORY will be

-# put in front of it. If left blank `rtf' will be used as the default path.

-

-RTF_OUTPUT = rtf

-

-# If the COMPACT_RTF tag is set to YES Doxygen generates more compact

-# RTF documents. This may be useful for small projects and may help to

-# save some trees in general.

-

-COMPACT_RTF = NO

-

-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated

-# will contain hyperlink fields. The RTF file will

-# contain links (just like the HTML output) instead of page references.

-# This makes the output suitable for online browsing using WORD or other

-# programs which support those fields.

-# Note: wordpad (write) and others do not support links.

-

-RTF_HYPERLINKS = NO

-

-# Load style sheet definitions from file. Syntax is similar to doxygen's

-# config file, i.e. a series of assignments. You only have to provide

-# replacements, missing definitions are set to their default value.

-

-RTF_STYLESHEET_FILE =

-

-# Set optional variables used in the generation of an rtf document.

-# Syntax is similar to doxygen's config file.

-

-RTF_EXTENSIONS_FILE =

-

-#---------------------------------------------------------------------------

-# configuration options related to the man page output

-#---------------------------------------------------------------------------

-

-# If the GENERATE_MAN tag is set to YES (the default) Doxygen will

-# generate man pages

-

-GENERATE_MAN = NO

-

-# The MAN_OUTPUT tag is used to specify where the man pages will be put.

-# If a relative path is entered the value of OUTPUT_DIRECTORY will be

-# put in front of it. If left blank `man' will be used as the default path.

-

-MAN_OUTPUT = man

-

-# The MAN_EXTENSION tag determines the extension that is added to

-# the generated man pages (default is the subroutine's section .3)

-

-MAN_EXTENSION = .3

-

-# If the MAN_LINKS tag is set to YES and Doxygen generates man output,

-# then it will generate one additional man file for each entity

-# documented in the real man page(s). These additional files

-# only source the real man page, but without them the man command

-# would be unable to find the correct page. The default is NO.

-

-MAN_LINKS = NO

-

-#---------------------------------------------------------------------------

-# configuration options related to the XML output

-#---------------------------------------------------------------------------

-

-# If the GENERATE_XML tag is set to YES Doxygen will

-# generate an XML file that captures the structure of

-# the code including all documentation.

-

-GENERATE_XML = @enable_xml_docs@

-

-# The XML_OUTPUT tag is used to specify where the XML pages will be put.

-# If a relative path is entered the value of OUTPUT_DIRECTORY will be

-# put in front of it. If left blank `xml' will be used as the default path.

-

-XML_OUTPUT = xml

-

-# If the XML_PROGRAMLISTING tag is set to YES Doxygen will

-# dump the program listings (including syntax highlighting

-# and cross-referencing information) to the XML output. Note that

-# enabling this will significantly increase the size of the XML output.

-

-XML_PROGRAMLISTING = NO

-

-#---------------------------------------------------------------------------

-# configuration options related to the DOCBOOK output

-#---------------------------------------------------------------------------

-

-# If the GENERATE_DOCBOOK tag is set to YES Doxygen will generate DOCBOOK files

-# that can be used to generate PDF.

-

-GENERATE_DOCBOOK = NO

-

-# The DOCBOOK_OUTPUT tag is used to specify where the DOCBOOK pages will be put.

-# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in

-# front of it. If left blank docbook will be used as the default path.

-

-DOCBOOK_OUTPUT = docbook

-

-#---------------------------------------------------------------------------

-# configuration options for the AutoGen Definitions output

-#---------------------------------------------------------------------------

-

-# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will

-# generate an AutoGen Definitions (see autogen.sf.net) file

-# that captures the structure of the code including all

-# documentation. Note that this feature is still experimental

-# and incomplete at the moment.

-

-GENERATE_AUTOGEN_DEF = NO

-