1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
#
# Copyright 2013 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# GNU Radio is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with GNU Radio; see the file COPYING. If not, write to
# the Free Software Foundation, Inc., 51 Franklin Street,
# Boston, MA 02110-1301, USA.
#
""" Utility functions for gr_modtool.py """
import re
import sys
def get_command_from_argv(possible_cmds):
""" Read the requested command from argv. This can't be done with optparse,
since the option parser isn't defined before the command is known, and
optparse throws an error."""
command = None
for arg in sys.argv:
if arg[0] == "-":
continue
else:
command = arg
if command in possible_cmds:
return arg
return None
def append_re_line_sequence(filename, linepattern, newline):
"""Detects the re 'linepattern' in the file. After its last occurrence,
paste 'newline'. If the pattern does not exist, append the new line
to the file. Then, write. """
oldfile = open(filename, 'r').read()
lines = re.findall(linepattern, oldfile, flags=re.MULTILINE)
if len(lines) == 0:
open(filename, 'a').write(newline)
return
last_line = lines[-1]
newfile = oldfile.replace(last_line, last_line + newline + '\n')
open(filename, 'w').write(newfile)
def remove_pattern_from_file(filename, pattern):
""" Remove all occurrences of a given pattern from a file. """
oldfile = open(filename, 'r').read()
pattern = re.compile(pattern, re.MULTILINE)
open(filename, 'w').write(pattern.sub('', oldfile))
def str_to_fancyc_comment(text):
""" Return a string as a C formatted comment. """
l_lines = text.splitlines()
outstr = "/* " + l_lines[0] + "\n"
for line in l_lines[1:]:
outstr += " * " + line + "\n"
outstr += " */\n"
return outstr
def str_to_python_comment(text):
""" Return a string as a Python formatted comment. """
return re.compile('^', re.MULTILINE).sub('# ', text)
def strip_default_values(string):
""" Strip default values from a C++ argument list. """
return re.sub(' *=[^,)]*', '', string)
def strip_arg_types(string):
"""" Strip the argument types from a list of arguments
Example: "int arg1, double arg2" -> "arg1, arg2" """
string = strip_default_values(string)
return ", ".join([part.strip().split(' ')[-1] for part in string.split(',')])
def get_modname():
""" Grep the current module's name from gnuradio.project or CMakeLists.txt """
modname_trans = {'howto-write-a-block': 'howto'}
try:
prfile = open('gnuradio.project', 'r').read()
regexp = r'projectname\s*=\s*([a-zA-Z0-9-_]+)$'
return re.search(regexp, prfile, flags=re.MULTILINE).group(1).strip()
except IOError:
pass
# OK, there's no gnuradio.project. So, we need to guess.
cmfile = open('CMakeLists.txt', 'r').read()
regexp = r'(project\s*\(\s*|GR_REGISTER_COMPONENT\(")gr-(?P<modname>[a-zA-Z1-9-_]+)(\s*(CXX)?|" ENABLE)'
try:
modname = re.search(regexp, cmfile, flags=re.MULTILINE).group('modname').strip()
if modname in modname_trans.keys():
modname = modname_trans[modname]
return modname
except AttributeError:
return None
def get_class_dict():
" Return a dictionary of the available commands in the form command->class "
classdict = {}
for g in globals().values():
try:
if issubclass(g, ModTool):
classdict[g.name] = g
for a in g.aliases:
classdict[a] = g
except (TypeError, AttributeError):
pass
return classdict
def is_number(s):
" Return True if the string s contains a number. "
try:
float(s)
return True
except ValueError:
return False
def xml_indent(elem, level=0):
""" Adds indents to XML for pretty printing """
i = "\n" + level*" "
if len(elem):
if not elem.text or not elem.text.strip():
elem.text = i + " "
if not elem.tail or not elem.tail.strip():
elem.tail = i
for elem in elem:
xml_indent(elem, level+1)
if not elem.tail or not elem.tail.strip():
elem.tail = i
else:
if level and (not elem.tail or not elem.tail.strip()):
elem.tail = i
def ask_yes_no(question, default):
""" Asks a binary question. Returns True for yes, False for no.
default is given as a boolean. """
question += {True: ' [Y/n] ', False: ' [y/N] '}[default]
if raw_input(question).lower() != {True: 'n', False: 'y'}[default]:
return default
else:
return not default
|
