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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
#
# Copyright 2013, 2018, 2019 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# SPDX-License-Identifier: GPL-3.0-or-later
#
#
""" Utility functions for gr_modtool """
from __future__ import print_function
from __future__ import absolute_import
from __future__ import unicode_literals
import re
import sys
import readline
# None of these must depend on other modtool stuff!
def append_re_line_sequence(filename, linepattern, newline):
""" Detects the re 'linepattern' in the file. After its last occurrence,
paste 'newline'. If the pattern does not exist, append the new line
to the file. Then, write. """
with open(filename, 'r') as f:
oldfile = f.read()
lines = re.findall(linepattern, oldfile, flags=re.MULTILINE)
if len(lines) == 0:
with open(filename, 'a') as f:
f.write(newline)
return
last_line = lines[-1]
newfile = oldfile.replace(last_line, last_line + newline + '\n')
with open(filename, 'w') as f:
f.write(newfile)
def remove_pattern_from_file(filename, pattern):
""" Remove all occurrences of a given pattern from a file. """
with open(filename, 'r') as f:
oldfile = f.read()
pattern = re.compile(pattern, re.MULTILINE)
with open(filename, 'w') as f:
f.write(pattern.sub('', oldfile))
def str_to_fancyc_comment(text):
""" Return a string as a C formatted comment. """
l_lines = text.splitlines()
if len(l_lines[0]) == 0:
outstr = "/*\n"
else:
outstr = "/* " + l_lines[0] + "\n"
for line in l_lines[1:]:
if len(line) == 0:
outstr += " *\n"
else:
outstr += " * " + line + "\n"
outstr += " */\n"
return outstr
def str_to_python_comment(text):
""" Return a string as a Python formatted comment. """
l_lines = text.splitlines()
if len(l_lines[0]) == 0:
outstr = "#\n"
else:
outstr = "# " + l_lines[0] + "\n"
for line in l_lines[1:]:
if len(line) == 0:
outstr += "#\n"
else:
outstr += "# " + line + "\n"
outstr += "#\n"
return outstr
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"
Note that some types have qualifiers, which also are part of
the type, e.g. "const std::string &name" -> "name", or
"const char *str" -> "str".
"""
string = strip_default_values(string)
return ", ".join(
[part.strip().split(' ')[-1] for part in string.split(',')]
).replace('*','').replace('&','')
def strip_arg_types_grc(string):
"""" Strip the argument types from a list of arguments for GRC make tag.
Example: "int arg1, double arg2" -> "$arg1, $arg2" """
if len(string) == 0:
return ""
else:
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:
with open('gnuradio.project', 'r') as f:
prfile = f.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.
with open('CMakeLists.txt', 'r') as f:
cmfile = f.read()
regexp = r'(project\s*\(\s*|GR_REGISTER_COMPONENT\(")gr-(?P<modname>[a-zA-Z0-9-_]+)(\s*(CXX)?|" ENABLE)'
try:
modname = re.search(regexp, cmfile, flags=re.MULTILINE).group('modname').strip()
if modname in list(modname_trans.keys()):
modname = modname_trans[modname]
return modname
except AttributeError:
return None
def is_number(s):
""" Return True if the string s contains a number. """
try:
float(s)
return True
except ValueError:
return False
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 input(question).lower() != {True: 'n', False: 'y'}[default]:
return default
else:
return not default
class SequenceCompleter(object):
""" A simple completer function wrapper to be used with readline, e.g.
option_iterable = ("search", "seek", "destroy")
readline.set_completer(SequenceCompleter(option_iterable).completefunc)
Typical usage is with the `with` statement. Restores the previous completer
at exit, thus nestable.
"""
def __init__(self, sequence=None):
self._seq = sequence or []
self._tmp_matches = []
def completefunc(self, text, state):
if not text and state < len(self._seq):
return self._seq[state]
if not state:
self._tmp_matches = [candidate for candidate in self._seq if candidate.startswith(text)]
if state < len(self._tmp_matches):
return self._tmp_matches[state]
def __enter__(self):
self._old_completer = readline.get_completer()
readline.set_completer(self.completefunc)
readline.parse_and_bind("tab: complete")
def __exit__(self, exception_type, exception_value, traceback):
readline.set_completer(self._old_completer)
|
