| from c_parser.info import ( |
| KIND, |
| TypeDeclaration, |
| POTSType, |
| FuncPtr, |
| ) |
| from c_parser.match import ( |
| is_pots, |
| is_funcptr, |
| ) |
| from .info import ( |
| IGNORED, |
| UNKNOWN, |
| SystemType, |
| ) |
| from .match import ( |
| is_system_type, |
| ) |
| |
| |
| def get_typespecs(typedecls): |
| typespecs = {} |
| for decl in typedecls: |
| if decl.shortkey not in typespecs: |
| typespecs[decl.shortkey] = [decl] |
| else: |
| typespecs[decl.shortkey].append(decl) |
| return typespecs |
| |
| |
| def analyze_decl(decl, typespecs, knowntypespecs, types, knowntypes, *, |
| analyze_resolved=None): |
| resolved = resolve_decl(decl, typespecs, knowntypespecs, types) |
| if resolved is None: |
| # The decl is supposed to be skipped or ignored. |
| return None |
| if analyze_resolved is None: |
| return resolved, None |
| return analyze_resolved(resolved, decl, types, knowntypes) |
| |
| # This alias helps us avoid name collisions. |
| _analyze_decl = analyze_decl |
| |
| |
| def analyze_type_decls(types, analyze_decl, handle_unresolved=True): |
| unresolved = set(types) |
| while unresolved: |
| updated = [] |
| for decl in unresolved: |
| resolved = analyze_decl(decl) |
| if resolved is None: |
| # The decl should be skipped or ignored. |
| types[decl] = IGNORED |
| updated.append(decl) |
| continue |
| typedeps, _ = resolved |
| if typedeps is None: |
| raise NotImplementedError(decl) |
| if UNKNOWN in typedeps: |
| # At least one dependency is unknown, so this decl |
| # is not resolvable. |
| types[decl] = UNKNOWN |
| updated.append(decl) |
| continue |
| if None in typedeps: |
| # XXX |
| # Handle direct recursive types first. |
| nonrecursive = 1 |
| if decl.kind is KIND.STRUCT or decl.kind is KIND.UNION: |
| nonrecursive = 0 |
| i = 0 |
| for member, dep in zip(decl.members, typedeps): |
| if dep is None: |
| if member.vartype.typespec != decl.shortkey: |
| nonrecursive += 1 |
| else: |
| typedeps[i] = decl |
| i += 1 |
| if nonrecursive: |
| # We don't have all dependencies resolved yet. |
| continue |
| types[decl] = resolved |
| updated.append(decl) |
| if updated: |
| for decl in updated: |
| unresolved.remove(decl) |
| else: |
| # XXX |
| # Handle indirect recursive types. |
| ... |
| # We couldn't resolve the rest. |
| # Let the caller deal with it! |
| break |
| if unresolved and handle_unresolved: |
| if handle_unresolved is True: |
| handle_unresolved = _handle_unresolved |
| handle_unresolved(unresolved, types, analyze_decl) |
| |
| |
| def resolve_decl(decl, typespecs, knowntypespecs, types): |
| if decl.kind is KIND.ENUM: |
| typedeps = [] |
| else: |
| if decl.kind is KIND.VARIABLE: |
| vartypes = [decl.vartype] |
| elif decl.kind is KIND.FUNCTION: |
| vartypes = [decl.signature.returntype] |
| elif decl.kind is KIND.TYPEDEF: |
| vartypes = [decl.vartype] |
| elif decl.kind is KIND.STRUCT or decl.kind is KIND.UNION: |
| vartypes = [m.vartype for m in decl.members] |
| else: |
| # Skip this one! |
| return None |
| |
| typedeps = [] |
| for vartype in vartypes: |
| typespec = vartype.typespec |
| if is_pots(typespec): |
| typedecl = POTSType(typespec) |
| elif is_system_type(typespec): |
| typedecl = SystemType(typespec) |
| elif is_funcptr(vartype): |
| typedecl = FuncPtr(vartype) |
| else: |
| typedecl = find_typedecl(decl, typespec, typespecs) |
| if typedecl is None: |
| typedecl = find_typedecl(decl, typespec, knowntypespecs) |
| elif not isinstance(typedecl, TypeDeclaration): |
| raise NotImplementedError(repr(typedecl)) |
| if typedecl is None: |
| # We couldn't find it! |
| typedecl = UNKNOWN |
| elif typedecl not in types: |
| # XXX How can this happen? |
| typedecl = UNKNOWN |
| elif types[typedecl] is UNKNOWN: |
| typedecl = UNKNOWN |
| elif types[typedecl] is IGNORED: |
| # We don't care if it didn't resolve. |
| pass |
| elif types[typedecl] is None: |
| # The typedecl for the typespec hasn't been resolved yet. |
| typedecl = None |
| typedeps.append(typedecl) |
| return typedeps |
| |
| |
| def find_typedecl(decl, typespec, typespecs): |
| specdecls = typespecs.get(typespec) |
| if not specdecls: |
| return None |
| |
| filename = decl.filename |
| |
| if len(specdecls) == 1: |
| typedecl, = specdecls |
| if '-' in typespec and typedecl.filename != filename: |
| # Inlined types are always in the same file. |
| return None |
| return typedecl |
| |
| # Decide which one to return. |
| candidates = [] |
| samefile = None |
| for typedecl in specdecls: |
| type_filename = typedecl.filename |
| if type_filename == filename: |
| if samefile is not None: |
| # We expect type names to be unique in a file. |
| raise NotImplementedError((decl, samefile, typedecl)) |
| samefile = typedecl |
| elif filename.endswith('.c') and not type_filename.endswith('.h'): |
| # If the decl is in a source file then we expect the |
| # type to be in the same file or in a header file. |
| continue |
| candidates.append(typedecl) |
| if not candidates: |
| return None |
| elif len(candidates) == 1: |
| winner, = candidates |
| # XXX Check for inline? |
| elif '-' in typespec: |
| # Inlined types are always in the same file. |
| winner = samefile |
| elif samefile is not None: |
| # Favor types in the same file. |
| winner = samefile |
| else: |
| # We don't know which to return. |
| raise NotImplementedError((decl, candidates)) |
| |
| return winner |
| |
| |
| ############################# |
| # handling unresolved decls |
| |
| class Skipped(TypeDeclaration): |
| def __init__(self): |
| _file = _name = _data = _parent = None |
| super().__init__(_file, _name, _data, _parent, _shortkey='<skipped>') |
| _SKIPPED = Skipped() |
| del Skipped |
| |
| |
| def _handle_unresolved(unresolved, types, analyze_decl): |
| #raise NotImplementedError(unresolved) |
| |
| dump = True |
| dump = False |
| if dump: |
| print() |
| for decl in types: # Preserve the original order. |
| if decl not in unresolved: |
| assert types[decl] is not None, decl |
| if types[decl] in (UNKNOWN, IGNORED): |
| unresolved.add(decl) |
| if dump: |
| _dump_unresolved(decl, types, analyze_decl) |
| print() |
| else: |
| assert types[decl][0] is not None, (decl, types[decl]) |
| assert None not in types[decl][0], (decl, types[decl]) |
| else: |
| assert types[decl] is None |
| if dump: |
| _dump_unresolved(decl, types, analyze_decl) |
| print() |
| #raise NotImplementedError |
| |
| for decl in unresolved: |
| types[decl] = ([_SKIPPED], None) |
| |
| for decl in types: |
| assert types[decl] |
| |
| |
| def _dump_unresolved(decl, types, analyze_decl): |
| if isinstance(decl, str): |
| typespec = decl |
| decl, = (d for d in types if d.shortkey == typespec) |
| elif type(decl) is tuple: |
| filename, typespec = decl |
| if '-' in typespec: |
| found = [d for d in types |
| if d.shortkey == typespec and d.filename == filename] |
| #if not found: |
| # raise NotImplementedError(decl) |
| decl, = found |
| else: |
| found = [d for d in types if d.shortkey == typespec] |
| if not found: |
| print(f'*** {typespec} ???') |
| return |
| #raise NotImplementedError(decl) |
| else: |
| decl, = found |
| resolved = analyze_decl(decl) |
| if resolved: |
| typedeps, _ = resolved or (None, None) |
| |
| if decl.kind is KIND.STRUCT or decl.kind is KIND.UNION: |
| print(f'*** {decl.shortkey} {decl.filename}') |
| for member, mtype in zip(decl.members, typedeps): |
| typespec = member.vartype.typespec |
| if typespec == decl.shortkey: |
| print(f' ~~~~: {typespec:20} - {member!r}') |
| continue |
| status = None |
| if is_pots(typespec): |
| mtype = typespec |
| status = 'okay' |
| elif is_system_type(typespec): |
| mtype = typespec |
| status = 'okay' |
| elif mtype is None: |
| if '-' in member.vartype.typespec: |
| mtype, = [d for d in types |
| if d.shortkey == member.vartype.typespec |
| and d.filename == decl.filename] |
| else: |
| found = [d for d in types |
| if d.shortkey == typespec] |
| if not found: |
| print(f' ???: {typespec:20}') |
| continue |
| mtype, = found |
| if status is None: |
| status = 'okay' if types.get(mtype) else 'oops' |
| if mtype is _SKIPPED: |
| status = 'okay' |
| mtype = '<skipped>' |
| elif isinstance(mtype, FuncPtr): |
| status = 'okay' |
| mtype = str(mtype.vartype) |
| elif not isinstance(mtype, str): |
| if hasattr(mtype, 'vartype'): |
| if is_funcptr(mtype.vartype): |
| status = 'okay' |
| mtype = str(mtype).rpartition('(')[0].rstrip() |
| status = ' okay' if status == 'okay' else f'--> {status}' |
| print(f' {status}: {typespec:20} - {member!r} ({mtype})') |
| else: |
| print(f'*** {decl} ({decl.vartype!r})') |
| if decl.vartype.typespec.startswith('struct ') or is_funcptr(decl): |
| _dump_unresolved( |
| (decl.filename, decl.vartype.typespec), |
| types, |
| analyze_decl, |
| ) |
