| import re |
| import shlex |
| import subprocess |
| |
| from ..common.info import UNKNOWN |
| |
| from . import source |
| |
| |
| IDENTIFIER = r'(?:[a-zA-z]|_+[a-zA-Z0-9]\w*)' |
| |
| TYPE_QUAL = r'(?:const|volatile)' |
| |
| VAR_TYPE_SPEC = r'''(?: |
| void | |
| (?: |
| (?:(?:un)?signed\s+)? |
| (?: |
| char | |
| short | |
| int | |
| long | |
| long\s+int | |
| long\s+long |
| ) | |
| ) | |
| float | |
| double | |
| {IDENTIFIER} | |
| (?:struct|union)\s+{IDENTIFIER} |
| )''' |
| |
| POINTER = rf'''(?: |
| (?:\s+const)?\s*[*] |
| )''' |
| |
| #STRUCT = r'''(?: |
| # (?:struct|(struct\s+%s))\s*[{] |
| # [^}]* |
| # [}] |
| # )''' % (IDENTIFIER) |
| #UNION = r'''(?: |
| # (?:union|(union\s+%s))\s*[{] |
| # [^}]* |
| # [}] |
| # )''' % (IDENTIFIER) |
| #DECL_SPEC = rf'''(?: |
| # ({VAR_TYPE_SPEC}) | |
| # ({STRUCT}) | |
| # ({UNION}) |
| # )''' |
| |
| FUNC_START = rf'''(?: |
| (?: |
| (?: |
| extern | |
| static | |
| static\s+inline |
| )\s+ |
| )? |
| #(?:const\s+)? |
| {VAR_TYPE_SPEC} |
| )''' |
| #GLOBAL_VAR_START = rf'''(?: |
| # (?: |
| # (?: |
| # extern | |
| # static |
| # )\s+ |
| # )? |
| # (?: |
| # {TYPE_QUAL} |
| # (?:\s+{TYPE_QUAL})? |
| # )?\s+ |
| # {VAR_TYPE_SPEC} |
| # )''' |
| GLOBAL_DECL_START_RE = re.compile(rf''' |
| ^ |
| (?: |
| ({FUNC_START}) |
| ) |
| ''', re.VERBOSE) |
| |
| LOCAL_VAR_START = rf'''(?: |
| (?: |
| (?: |
| register | |
| static |
| )\s+ |
| )? |
| (?: |
| (?: |
| {TYPE_QUAL} |
| (?:\s+{TYPE_QUAL})? |
| )\s+ |
| )? |
| {VAR_TYPE_SPEC} |
| {POINTER}? |
| )''' |
| LOCAL_STMT_START_RE = re.compile(rf''' |
| ^ |
| (?: |
| ({LOCAL_VAR_START}) |
| ) |
| ''', re.VERBOSE) |
| |
| |
| def iter_global_declarations(lines): |
| """Yield (decl, body) for each global declaration in the given lines. |
| |
| For function definitions the header is reduced to one line and |
| the body is provided as-is. For other compound declarations (e.g. |
| struct) the entire declaration is reduced to one line and "body" |
| is None. Likewise for simple declarations (e.g. variables). |
| |
| Declarations inside function bodies are ignored, though their text |
| is provided in the function body. |
| """ |
| # XXX Bail out upon bogus syntax. |
| lines = source.iter_clean_lines(lines) |
| for line in lines: |
| if not GLOBAL_DECL_START_RE.match(line): |
| continue |
| # We only need functions here, since we only need locals for now. |
| if line.endswith(';'): |
| continue |
| if line.endswith('{') and '(' not in line: |
| continue |
| |
| # Capture the function. |
| # (assume no func is a one-liner) |
| decl = line |
| while '{' not in line: # assume no inline structs, etc. |
| try: |
| line = next(lines) |
| except StopIteration: |
| return |
| decl += ' ' + line |
| |
| body, end = _extract_block(lines) |
| if end is None: |
| return |
| assert end == '}' |
| yield (f'{decl}\n{body}\n{end}', body) |
| |
| |
| def iter_local_statements(lines): |
| """Yield (lines, blocks) for each statement in the given lines. |
| |
| For simple statements, "blocks" is None and the statement is reduced |
| to a single line. For compound statements, "blocks" is a pair of |
| (header, body) for each block in the statement. The headers are |
| reduced to a single line each, but the bpdies are provided as-is. |
| """ |
| # XXX Bail out upon bogus syntax. |
| lines = source.iter_clean_lines(lines) |
| for line in lines: |
| if not LOCAL_STMT_START_RE.match(line): |
| continue |
| |
| stmt = line |
| blocks = None |
| if not line.endswith(';'): |
| # XXX Support compound & multiline simple statements. |
| #blocks = [] |
| continue |
| |
| yield (stmt, blocks) |
| |
| |
| def _extract_block(lines): |
| end = None |
| depth = 1 |
| body = [] |
| for line in lines: |
| depth += line.count('{') - line.count('}') |
| if depth == 0: |
| end = line |
| break |
| body.append(line) |
| return '\n'.join(body), end |
| |
| |
| def parse_func(stmt, body): |
| """Return (name, signature) for the given function definition.""" |
| header, _, end = stmt.partition(body) |
| assert end.strip() == '}' |
| assert header.strip().endswith('{') |
| header, _, _= header.rpartition('{') |
| |
| signature = ' '.join(header.strip().splitlines()) |
| |
| _, _, name = signature.split('(')[0].strip().rpartition(' ') |
| assert name |
| |
| return name, signature |
| |
| |
| #TYPE_SPEC = rf'''(?: |
| # )''' |
| #VAR_DECLARATOR = rf'''(?: |
| # )''' |
| #VAR_DECL = rf'''(?: |
| # {TYPE_SPEC}+ |
| # {VAR_DECLARATOR} |
| # \s* |
| # )''' |
| #VAR_DECLARATION = rf'''(?: |
| # {VAR_DECL} |
| # (?: = [^=] [^;]* )? |
| # ; |
| # )''' |
| # |
| # |
| #def parse_variable(decl, *, inFunc=False): |
| # """Return [(name, storage, vartype)] for the given variable declaration.""" |
| # ... |
| |
| |
| def _parse_var(stmt): |
| """Return (name, vartype) for the given variable declaration.""" |
| stmt = stmt.rstrip(';') |
| m = LOCAL_STMT_START_RE.match(stmt) |
| assert m |
| vartype = m.group(0) |
| name = stmt[len(vartype):].partition('=')[0].strip() |
| |
| if name.startswith('('): |
| name, _, after = name[1:].partition(')') |
| assert after |
| name = name.replace('*', '* ') |
| inside, _, name = name.strip().rpartition(' ') |
| vartype = f'{vartype} ({inside.strip()}){after}' |
| else: |
| name = name.replace('*', '* ') |
| before, _, name = name.rpartition(' ') |
| vartype = f'{vartype} {before}' |
| |
| vartype = vartype.strip() |
| while ' ' in vartype: |
| vartype = vartype.replace(' ', ' ') |
| |
| return name, vartype |
| |
| |
| def extract_storage(decl, *, infunc=None): |
| """Return (storage, vartype) based on the given declaration. |
| |
| The default storage is "implicit" (or "local" if infunc is True). |
| """ |
| if decl == UNKNOWN: |
| return decl |
| if decl.startswith('static '): |
| return 'static' |
| #return 'static', decl.partition(' ')[2].strip() |
| elif decl.startswith('extern '): |
| return 'extern' |
| #return 'extern', decl.partition(' ')[2].strip() |
| elif re.match('.*\b(static|extern)\b', decl): |
| raise NotImplementedError |
| elif infunc: |
| return 'local' |
| else: |
| return 'implicit' |
| |
| |
| def parse_compound(stmt, blocks): |
| """Return (headers, bodies) for the given compound statement.""" |
| # XXX Identify declarations inside compound statements |
| # (if/switch/for/while). |
| raise NotImplementedError |
| |
| |
| def iter_variables(filename, *, |
| preprocessed=False, |
| _iter_source_lines=source.iter_lines, |
| _iter_global=iter_global_declarations, |
| _iter_local=iter_local_statements, |
| _parse_func=parse_func, |
| _parse_var=_parse_var, |
| _parse_compound=parse_compound, |
| ): |
| """Yield (funcname, name, vartype) for every variable in the given file.""" |
| if preprocessed: |
| raise NotImplementedError |
| lines = _iter_source_lines(filename) |
| for stmt, body in _iter_global(lines): |
| # At the file top-level we only have to worry about vars & funcs. |
| if not body: |
| name, vartype = _parse_var(stmt) |
| if name: |
| yield (None, name, vartype) |
| else: |
| funcname, _ = _parse_func(stmt, body) |
| localvars = _iter_locals(body, |
| _iter_statements=_iter_local, |
| _parse_var=_parse_var, |
| _parse_compound=_parse_compound, |
| ) |
| for name, vartype in localvars: |
| yield (funcname, name, vartype) |
| |
| |
| def _iter_locals(lines, *, |
| _iter_statements=iter_local_statements, |
| _parse_var=_parse_var, |
| _parse_compound=parse_compound, |
| ): |
| compound = [lines] |
| while compound: |
| body = compound.pop(0) |
| bodylines = body.splitlines() |
| for stmt, blocks in _iter_statements(bodylines): |
| if not blocks: |
| name, vartype = _parse_var(stmt) |
| if name: |
| yield (name, vartype) |
| else: |
| headers, bodies = _parse_compound(stmt, blocks) |
| for header in headers: |
| for line in header: |
| name, vartype = _parse_var(line) |
| if name: |
| yield (name, vartype) |
| compound.extend(bodies) |
| |
| |
| def iter_all(filename, *, |
| preprocessed=False, |
| ): |
| """Yield a Declaration for each one found. |
| |
| If there are duplicates, due to preprocessor conditionals, then |
| they are checked to make sure they are the same. |
| """ |
| # XXX For the moment we cheat. |
| for funcname, name, decl in iter_variables(filename, |
| preprocessed=preprocessed): |
| yield 'variable', funcname, name, decl |
