| 1 |
import re |
| 2 |
|
| 3 |
from . import info as _info |
| 4 |
from .parser._regexes import SIMPLE_TYPE |
| 5 |
|
| 6 |
|
| 7 |
_KIND = _info.KIND |
| 8 |
|
| 9 |
|
| 10 |
def match_storage(decl, expected): |
| 11 |
default = _info.get_default_storage(decl) |
| 12 |
#assert default |
| 13 |
if expected is None: |
| 14 |
expected = {default} |
| 15 |
elif isinstance(expected, str): |
| 16 |
expected = {expected or default} |
| 17 |
elif not expected: |
| 18 |
expected = _info.STORAGE |
| 19 |
else: |
| 20 |
expected = {v or default for v in expected} |
| 21 |
storage = _info.get_effective_storage(decl, default=default) |
| 22 |
return storage in expected |
| 23 |
|
| 24 |
|
| 25 |
################################## |
| 26 |
# decl matchers |
| 27 |
|
| 28 |
def is_type_decl(item): |
| 29 |
return _KIND.is_type_decl(item.kind) |
| 30 |
|
| 31 |
|
| 32 |
def is_decl(item): |
| 33 |
return _KIND.is_decl(item.kind) |
| 34 |
|
| 35 |
|
| 36 |
def is_pots(typespec, *, |
| 37 |
_regex=re.compile(rf'^{SIMPLE_TYPE}$', re.VERBOSE), |
| 38 |
): |
| 39 |
|
| 40 |
if not typespec: |
| 41 |
return None |
| 42 |
if type(typespec) is not str: |
| 43 |
_, _, _, typespec, _ = _info.get_parsed_vartype(typespec) |
| 44 |
return _regex.match(typespec) is not None |
| 45 |
|
| 46 |
|
| 47 |
def is_funcptr(vartype): |
| 48 |
if not vartype: |
| 49 |
return None |
| 50 |
_, _, _, _, abstract = _info.get_parsed_vartype(vartype) |
| 51 |
return _is_funcptr(abstract) |
| 52 |
|
| 53 |
|
| 54 |
def _is_funcptr(declstr): |
| 55 |
if not declstr: |
| 56 |
return None |
| 57 |
# XXX Support "(<name>*)(". |
| 58 |
return '(*)(' in declstr.replace(' ', '') |
| 59 |
|
| 60 |
|
| 61 |
def is_forward_decl(decl): |
| 62 |
if decl.kind is _KIND.TYPEDEF: |
| 63 |
return False |
| 64 |
elif is_type_decl(decl): |
| 65 |
return not decl.data |
| 66 |
elif decl.kind is _KIND.FUNCTION: |
| 67 |
# XXX This doesn't work with ParsedItem. |
| 68 |
return decl.signature.isforward |
| 69 |
elif decl.kind is _KIND.VARIABLE: |
| 70 |
# No var decls are considered forward (or all are...). |
| 71 |
return False |
| 72 |
else: |
| 73 |
raise NotImplementedError(decl) |
| 74 |
|
| 75 |
|
| 76 |
def can_have_symbol(decl): |
| 77 |
return decl.kind in (_KIND.VARIABLE, _KIND.FUNCTION) |
| 78 |
|
| 79 |
|
| 80 |
def has_external_symbol(decl): |
| 81 |
if not can_have_symbol(decl): |
| 82 |
return False |
| 83 |
if _info.get_effective_storage(decl) != 'extern': |
| 84 |
return False |
| 85 |
if decl.kind is _KIND.FUNCTION: |
| 86 |
return not decl.signature.isforward |
| 87 |
else: |
| 88 |
# It must be a variable, which can only be implicitly extern here. |
| 89 |
return decl.storage != 'extern' |
| 90 |
|
| 91 |
|
| 92 |
def has_internal_symbol(decl): |
| 93 |
if not can_have_symbol(decl): |
| 94 |
return False |
| 95 |
return _info.get_actual_storage(decl) == 'static' |
| 96 |
|
| 97 |
|
| 98 |
def is_external_reference(decl): |
| 99 |
if not can_have_symbol(decl): |
| 100 |
return False |
| 101 |
# We have to check the declared storage rather tnan the effective. |
| 102 |
if decl.storage != 'extern': |
| 103 |
return False |
| 104 |
if decl.kind is _KIND.FUNCTION: |
| 105 |
return decl.signature.isforward |
| 106 |
# Otherwise it's a variable. |
| 107 |
return True |
| 108 |
|
| 109 |
|
| 110 |
def is_local_var(decl): |
| 111 |
if not decl.kind is _KIND.VARIABLE: |
| 112 |
return False |
| 113 |
return True if decl.parent else False |
| 114 |
|
| 115 |
|
| 116 |
def is_global_var(decl): |
| 117 |
if not decl.kind is _KIND.VARIABLE: |
| 118 |
return False |
| 119 |
return False if decl.parent else True |
| 120 |
|
| 121 |
|
| 122 |
################################## |
| 123 |
# filtering with matchers |
| 124 |
|
| 125 |
def filter_by_kind(items, kind): |
| 126 |
if kind == 'type': |
| 127 |
kinds = _KIND._TYPE_DECLS |
| 128 |
elif kind == 'decl': |
| 129 |
kinds = _KIND._TYPE_DECLS |
| 130 |
try: |
| 131 |
okay = kind in _KIND |
| 132 |
except TypeError: |
| 133 |
kinds = set(kind) |
| 134 |
else: |
| 135 |
kinds = {kind} if okay else set(kind) |
| 136 |
for item in items: |
| 137 |
if item.kind in kinds: |
| 138 |
yield item |
| 139 |
|
| 140 |
|
| 141 |
################################## |
| 142 |
# grouping with matchers |
| 143 |
|
| 144 |
def group_by_category(decls, categories, *, ignore_non_match=True): |
| 145 |
collated = {} |
| 146 |
for decl in decls: |
| 147 |
# Matchers should be mutually exclusive. (First match wins.) |
| 148 |
for category, match in categories.items(): |
| 149 |
if match(decl): |
| 150 |
if category not in collated: |
| 151 |
collated[category] = [decl] |
| 152 |
else: |
| 153 |
collated[category].append(decl) |
| 154 |
break |
| 155 |
else: |
| 156 |
if not ignore_non_match: |
| 157 |
raise Exception(f'no match for {decl!r}') |
| 158 |
return collated |
| 159 |
|
| 160 |
|
| 161 |
def group_by_kind(items): |
| 162 |
collated = {kind: [] for kind in _KIND} |
| 163 |
for item in items: |
| 164 |
try: |
| 165 |
collated[item.kind].append(item) |
| 166 |
except KeyError: |
| 167 |
raise ValueError(f'unsupported kind in {item!r}') |
| 168 |
return collated |
| 169 |
|
| 170 |
|
| 171 |
def group_by_kinds(items): |
| 172 |
# Collate into kind groups (decl, type, etc.). |
| 173 |
collated = {_KIND.get_group(k): [] for k in _KIND} |
| 174 |
for item in items: |
| 175 |
group = _KIND.get_group(item.kind) |
| 176 |
collated[group].append(item) |
| 177 |
return collated |