bpo-36876: Fix the C analyzer tool. (GH-22841)

The original tool wasn't working right and it was simpler to create a new one, partially re-using some of the old code. At this point the tool runs properly on the master. (Try: ./python Tools/c-analyzer/c-analyzer.py analyze.)  It take ~40 seconds on my machine to analyze the full CPython code base.

Note that we'll need to iron out some OS-specific stuff (e.g. preprocessor). We're okay though since this tool isn't used yet in our workflow. We will also need to verify the analysis results in detail before activating the check in CI, though I'm pretty sure it's close.

https://bugs.python.org/issue36876

72 files changed, 8882 insertions, 6239 deletions

diff --git a/Tools/c-analyzer/README b/Tools/c-analyzer/README
index 8cf20e276d9..86bf1e77e0b 100644
--- a/Tools/c-analyzer/README
+++ b/Tools/c-analyzer/README
@@ -36,6 +36,10 @@ should be run to ensure that no new globals have been added:
 
   python3 Tools/c-analyzer/check-c-globals.py
 
+You can also use the more generic tool:
+
+  python3 Tools/c-analyzer/c-analyzer.py
+
 If it reports any globals then they should be resolved.  If the globals
 are runtime state then they should be folded into _PyRuntimeState.
 Otherwise they should be added to ignored-globals.txt.
diff --git a/Tools/c-analyzer/c-analyzer.py b/Tools/c-analyzer/c-analyzer.py
new file mode 100644
index 00000000000..4a5e88cdaf1
--- /dev/null
+++ b/Tools/c-analyzer/c-analyzer.py
@@ -0,0 +1,7 @@
+from cpython.__main__ import parse_args, main, configure_logger
+
+
+cmd, cmd_kwargs, verbosity, traceback_cm = parse_args()
+configure_logger(verbosity)
+with traceback_cm:
+    main(cmd, cmd_kwargs)
diff --git a/Tools/c-analyzer/c-globals.py b/Tools/c-analyzer/c-globals.py
deleted file mode 100644
index b36b791241d..00000000000
--- a/Tools/c-analyzer/c-globals.py
+++ /dev/null
@@ -1,9 +0,0 @@
-# This is a script equivalent of running "python -m test.test_c_globals.cg".
-
-from cpython.__main__ import parse_args, main
-
-
-# This is effectively copied from cg/__main__.py:
-if __name__ == '__main__':
-    cmd, cmdkwargs = parse_args()
-    main(cmd, cmdkwargs)
diff --git a/Tools/c-analyzer/c_analyzer/__init__.py b/Tools/c-analyzer/c_analyzer/__init__.py
index e69de29bb2d..4a01cd396f5 100644
--- a/Tools/c-analyzer/c_analyzer/__init__.py
+++ b/Tools/c-analyzer/c_analyzer/__init__.py
@@ -0,0 +1,103 @@
+from c_parser import (
+    parse_files as _parse_files,
+)
+from c_parser.info import (
+    KIND,
+    TypeDeclaration,
+    filter_by_kind,
+    collate_by_kind_group,
+    resolve_parsed,
+)
+from . import (
+    analyze as _analyze,
+    datafiles as _datafiles,
+)
+from .info import Analysis
+
+
+def analyze(filenmes, **kwargs):
+    results = iter_analyis_results(filenames, **kwargs)
+    return Analysis.from_results(results)
+
+
+def iter_analysis_results(filenmes, *,
+                          known=None,
+                          **kwargs
+                          ):
+    decls = iter_decls(filenames, **kwargs)
+    yield from analyze_decls(decls, known)
+
+
+def iter_decls(filenames, *,
+               kinds=None,
+               parse_files=_parse_files,
+               **kwargs
+               ):
+    kinds = KIND.DECLS if kinds is None else (KIND.DECLS & set(kinds))
+    parse_files = parse_files or _parse_files
+
+    parsed = parse_files(filenames, **kwargs)
+    parsed = filter_by_kind(parsed, kinds)
+    for item in parsed:
+        yield resolve_parsed(item)
+
+
+def analyze_decls(decls, known, *,
+                  analyze_resolved=None,
+                  handle_unresolved=True,
+                  relroot=None,
+                  ):
+    knowntypes, knowntypespecs = _datafiles.get_known(
+        known,
+        handle_unresolved=handle_unresolved,
+        analyze_resolved=analyze_resolved,
+        relroot=relroot,
+    )
+
+    decls = list(decls)
+    collated = collate_by_kind_group(decls)
+
+    types = {decl: None for decl in collated['type']}
+    typespecs = _analyze.get_typespecs(types)
+
+    def analyze_decl(decl):
+        return _analyze.analyze_decl(
+            decl,
+            typespecs,
+            knowntypespecs,
+            types,
+            knowntypes,
+            analyze_resolved=analyze_resolved,
+        )
+    _analyze.analyze_type_decls(types, analyze_decl, handle_unresolved)
+    for decl in decls:
+        if decl in types:
+            resolved = types[decl]
+        else:
+            resolved = analyze_decl(decl)
+            if resolved and handle_unresolved:
+                typedeps, _ = resolved
+                if not isinstance(typedeps, TypeDeclaration):
+                    if not typedeps or None in typedeps:
+                        raise NotImplementedError((decl, resolved))
+
+        yield decl, resolved
+
+
+#######################################
+# checks
+
+def check_all(analysis, checks, *, failfast=False):
+    for check in checks or ():
+        for data, failure in check(analysis):
+            if failure is None:
+                continue
+
+            yield data, failure
+            if failfast:
+                yield None, None
+                break
+        else:
+            continue
+        # We failed fast.
+        break
diff --git a/Tools/c-analyzer/c_analyzer/__main__.py b/Tools/c-analyzer/c_analyzer/__main__.py
new file mode 100644
index 00000000000..1fd45b985d9
--- /dev/null
+++ b/Tools/c-analyzer/c_analyzer/__main__.py
@@ -0,0 +1,501 @@
+import io
+import logging
+import os.path
+import re
+import sys
+
+from c_common.logging import VERBOSITY, Printer
+from c_common.scriptutil import (
+    add_verbosity_cli,
+    add_traceback_cli,
+    add_sepval_cli,
+    add_files_cli,
+    add_commands_cli,
+    process_args_by_key,
+    configure_logger,
+    get_prog,
+    filter_filenames,
+    iter_marks,
+)
+from c_parser.info import KIND, is_type_decl
+from . import (
+    analyze as _analyze,
+    check_all as _check_all,
+    datafiles as _datafiles,
+)
+
+
+KINDS = [
+    KIND.TYPEDEF,
+    KIND.STRUCT,
+    KIND.UNION,
+    KIND.ENUM,
+    KIND.FUNCTION,
+    KIND.VARIABLE,
+    KIND.STATEMENT,
+]
+
+logger = logging.getLogger(__name__)
+
+
+#######################################
+# table helpers
+
+TABLE_SECTIONS = {
+    'types': (
+        ['kind', 'name', 'data', 'file'],
+        is_type_decl,
+        (lambda v: (v.kind.value, v.filename or '', v.name)),
+    ),
+    'typedefs': 'types',
+    'structs': 'types',
+    'unions': 'types',
+    'enums': 'types',
+    'functions': (
+        ['name', 'data', 'file'],
+        (lambda kind: kind is KIND.FUNCTION),
+        (lambda v: (v.filename or '', v.name)),
+    ),
+    'variables': (
+        ['name', 'parent', 'data', 'file'],
+        (lambda kind: kind is KIND.VARIABLE),
+        (lambda v: (v.filename or '', str(v.parent) if v.parent else '', v.name)),
+    ),
+    'statements': (
+        ['file', 'parent', 'data'],
+        (lambda kind: kind is KIND.STATEMENT),
+        (lambda v: (v.filename or '', str(v.parent) if v.parent else '', v.name)),
+    ),
+    KIND.TYPEDEF: 'typedefs',
+    KIND.STRUCT: 'structs',
+    KIND.UNION: 'unions',
+    KIND.ENUM: 'enums',
+    KIND.FUNCTION: 'functions',
+    KIND.VARIABLE: 'variables',
+    KIND.STATEMENT: 'statements',
+}
+
+
+def _render_table(items, columns, relroot=None):
+    # XXX improve this
+    header = '\t'.join(columns)
+    div = '--------------------'
+    yield header
+    yield div
+    total = 0
+    for item in items:
+        rowdata = item.render_rowdata(columns)
+        row = [rowdata[c] for c in columns]
+        if relroot and 'file' in columns:
+            index = columns.index('file')
+            row[index] = os.path.relpath(row[index], relroot)
+        yield '\t'.join(row)
+        total += 1
+    yield div
+    yield f'total: {total}'
+
+
+def build_section(name, groupitems, *, relroot=None):
+    info = TABLE_SECTIONS[name]
+    while type(info) is not tuple:
+        if name in KINDS:
+            name = info
+        info = TABLE_SECTIONS[info]
+
+    columns, match_kind, sortkey = info
+    items = (v for v in groupitems if match_kind(v.kind))
+    items = sorted(items, key=sortkey)
+    def render():
+        yield ''
+        yield f'{name}:'
+        yield ''
+        for line in _render_table(items, columns, relroot):
+            yield line
+    return items, render
+
+
+#######################################
+# the checks
+
+CHECKS = {
+    #'globals': _check_globals,
+}
+
+
+def add_checks_cli(parser, checks=None, *, add_flags=None):
+    default = False
+    if not checks:
+        checks = list(CHECKS)
+        default = True
+    elif isinstance(checks, str):
+        checks = [checks]
+    if (add_flags is None and len(checks) > 1) or default:
+        add_flags = True
+
+    process_checks = add_sepval_cli(parser, '--check', 'checks', checks)
+    if add_flags:
+        for check in checks:
+            parser.add_argument(f'--{check}', dest='checks',
+                                action='append_const', const=check)
+    return [
+        process_checks,
+    ]
+
+
+def _get_check_handlers(fmt, printer, verbosity=VERBOSITY):
+    div = None
+    def handle_after():
+        pass
+    if not fmt:
+        div = ''
+        def handle_failure(failure, data):
+            data = repr(data)
+            if verbosity >= 3:
+                logger.info(f'failure: {failure}')
+                logger.info(f'data:    {data}')
+            else:
+                logger.warn(f'failure: {failure} (data: {data})')
+    elif fmt == 'raw':
+        def handle_failure(failure, data):
+            print(f'{failure!r} {data!r}')
+    elif fmt == 'brief':
+        def handle_failure(failure, data):
+            parent = data.parent or ''
+            funcname = parent if isinstance(parent, str) else parent.name
+            name = f'({funcname}).{data.name}' if funcname else data.name
+            failure = failure.split('\t')[0]
+            print(f'{data.filename}:{name} - {failure}')
+    elif fmt == 'summary':
+        def handle_failure(failure, data):
+            parent = data.parent or ''
+            funcname = parent if isinstance(parent, str) else parent.name
+            print(f'{data.filename:35}\t{funcname or "-":35}\t{data.name:40}\t{failure}')
+    elif fmt == 'full':
+        div = ''
+        def handle_failure(failure, data):
+            name = data.shortkey if data.kind is KIND.VARIABLE else data.name
+            parent = data.parent or ''
+            funcname = parent if isinstance(parent, str) else parent.name
+            known = 'yes' if data.is_known else '*** NO ***'
+            print(f'{data.kind.value} {name!r} failed ({failure})')
+            print(f'  file:         {data.filename}')
+            print(f'  func:         {funcname or "-"}')
+            print(f'  name:         {data.name}')
+            print(f'  data:         ...')
+            print(f'  type unknown: {known}')
+    else:
+        if fmt in FORMATS:
+            raise NotImplementedError(fmt)
+        raise ValueError(f'unsupported fmt {fmt!r}')
+    return handle_failure, handle_after, div
+
+
+#######################################
+# the formats
+
+def fmt_raw(analysis):
+    for item in analysis:
+        yield from item.render('raw')
+
+
+def fmt_brief(analysis):
+    # XXX Support sorting.
+    items = sorted(analysis)
+    for kind in KINDS:
+        if kind is KIND.STATEMENT:
+            continue
+        for item in items:
+            if item.kind is not kind:
+                continue
+            yield from item.render('brief')
+    yield f'  total: {len(items)}'
+
+
+def fmt_summary(analysis):
+    # XXX Support sorting and grouping.
+    items = list(analysis)
+    total = len(items)
+
+    def section(name):
+        _, render = build_section(name, items)
+        yield from render()
+
+    yield from section('types')
+    yield from section('functions')
+    yield from section('variables')
+    yield from section('statements')
+
+    yield ''
+#    yield f'grand total: {len(supported) + len(unsupported)}'
+    yield f'grand total: {total}'
+
+
+def fmt_full(analysis):
+    # XXX Support sorting.
+    items = sorted(analysis, key=lambda v: v.key)
+    yield ''
+    for item in items:
+        yield from item.render('full')
+        yield ''
+    yield f'total: {len(items)}'
+
+
+FORMATS = {
+    'raw': fmt_raw,
+    'brief': fmt_brief,
+    'summary': fmt_summary,
+    'full': fmt_full,
+}
+
+
+def add_output_cli(parser, *, default='summary'):
+    parser.add_argument('--format', dest='fmt', default=default, choices=tuple(FORMATS))
+
+    def process_args(args):
+        pass
+    return process_args
+
+
+#######################################
+# the commands
+
+def _cli_check(parser, checks=None, **kwargs):
+    if isinstance(checks, str):
+        checks = [checks]
+    if checks is False:
+        process_checks = None
+    elif checks is None:
+        process_checks = add_checks_cli(parser)
+    elif len(checks) == 1 and type(checks) is not dict and re.match(r'^<.*>$', checks[0]):
+        check = checks[0][1:-1]
+        def process_checks(args):
+            args.checks = [check]
+    else:
+        process_checks = add_checks_cli(parser, checks=checks)
+    process_output = add_output_cli(parser, default=None)
+    process_files = add_files_cli(parser, **kwargs)
+    return [
+        process_checks,
+        process_output,
+        process_files,
+    ]
+
+
+def cmd_check(filenames, *,
+              checks=None,
+              ignored=None,
+              fmt=None,
+              relroot=None,
+              failfast=False,
+              iter_filenames=None,
+              verbosity=VERBOSITY,
+              _analyze=_analyze,
+              _CHECKS=CHECKS,
+              **kwargs
+              ):
+    if not checks:
+        checks = _CHECKS
+    elif isinstance(checks, str):
+        checks = [checks]
+    checks = [_CHECKS[c] if isinstance(c, str) else c
+              for c in checks]
+    printer = Printer(verbosity)
+    (handle_failure, handle_after, div
+     ) = _get_check_handlers(fmt, printer, verbosity)
+
+    filenames = filter_filenames(filenames, iter_filenames)
+
+    logger.info('analyzing...')
+    analyzed = _analyze(filenames, **kwargs)
+    if relroot:
+        analyzed.fix_filenames(relroot)
+
+    logger.info('checking...')
+    numfailed = 0
+    for data, failure in _check_all(analyzed, checks, failfast=failfast):
+        if data is None:
+            printer.info('stopping after one failure')
+            break
+        if div is not None and numfailed > 0:
+            printer.info(div)
+        numfailed += 1
+        handle_failure(failure, data)
+    handle_after()
+
+    printer.info('-------------------------')
+    logger.info(f'total failures: {numfailed}')
+    logger.info('done checking')
+
+    if numfailed > 0:
+        sys.exit(numfailed)
+
+
+def _cli_analyze(parser, **kwargs):
+    process_output = add_output_cli(parser)
+    process_files = add_files_cli(parser, **kwargs)
+    return [
+        process_output,
+        process_files,
+    ]
+
+
+# XXX Support filtering by kind.
+def cmd_analyze(filenames, *,
+                fmt=None,
+                iter_filenames=None,
+                verbosity=None,
+                _analyze=_analyze,
+                formats=FORMATS,
+                **kwargs
+                ):
+    verbosity = verbosity if verbosity is not None else 3
+
+    try:
+        do_fmt = formats[fmt]
+    except KeyError:
+        raise ValueError(f'unsupported fmt {fmt!r}')
+
+    filenames = filter_filenames(filenames, iter_filenames)
+    if verbosity == 2:
+        def iter_filenames(filenames=filenames):
+            marks = iter_marks()
+            for filename in filenames:
+                print(next(marks), end='')
+                yield filename
+        filenames = iter_filenames()
+    elif verbosity > 2:
+        def iter_filenames(filenames=filenames):
+            for filename in filenames:
+                print(f'<{filename}>')
+                yield filename
+        filenames = iter_filenames()
+
+    logger.info('analyzing...')
+    analyzed = _analyze(filenames, **kwargs)
+
+    for line in do_fmt(analyzed):
+        print(line)
+
+
+def _cli_data(parser, filenames=None, known=None):
+    ArgumentParser = type(parser)
+    common = ArgumentParser(add_help=False)
+    if filenames is None:
+        common.add_argument('filenames', metavar='FILE', nargs='+')
+
+    subs = parser.add_subparsers(dest='datacmd')
+
+    sub = subs.add_parser('show', parents=[common])
+    if known is None:
+        sub.add_argument('--known', required=True)
+
+    sub = subs.add_parser('dump')
+    if known is None:
+        sub.add_argument('--known')
+    sub.add_argument('--show', action='store_true')
+
+    sub = subs.add_parser('check')
+    if known is None:
+        sub.add_argument('--known', required=True)
+
+    return None
+
+
+def cmd_data(datacmd, filenames, known=None, *,
+             _analyze=_analyze,
+             formats=FORMATS,
+             extracolumns=None,
+             relroot=None,
+             **kwargs
+             ):
+    kwargs.pop('verbosity', None)
+    usestdout = kwargs.pop('show', None)
+    if datacmd == 'show':
+        do_fmt = formats['summary']
+        if isinstance(known, str):
+            known, _ = _datafiles.get_known(known, extracolumns, relroot)
+        for line in do_fmt(known):
+            print(line)
+    elif datacmd == 'dump':
+        analyzed = _analyze(filenames, **kwargs)
+        if known is None or usestdout:
+            outfile = io.StringIO()
+            _datafiles.write_known(analyzed, outfile, extracolumns,
+                                   relroot=relroot)
+            print(outfile.getvalue())
+        else:
+            _datafiles.write_known(analyzed, known, extracolumns,
+                                   relroot=relroot)
+    elif datacmd == 'check':
+        raise NotImplementedError(datacmd)
+    else:
+        raise ValueError(f'unsupported data command {datacmd!r}')
+
+
+COMMANDS = {
+    'check': (
+        'analyze and fail if the given C source/header files have any problems',
+        [_cli_check],
+        cmd_check,
+    ),
+    'analyze': (
+        'report on the state of the given C source/header files',
+        [_cli_analyze],
+        cmd_analyze,
+    ),
+    'data': (
+        'check/manage local data (e.g. knwon types, ignored vars, caches)',
+        [_cli_data],
+        cmd_data,
+    ),
+}
+
+
+#######################################
+# the script
+
+def parse_args(argv=sys.argv[1:], prog=sys.argv[0], *, subset=None):
+    import argparse
+    parser = argparse.ArgumentParser(
+        prog=prog or get_prog(),
+    )
+
+    processors = add_commands_cli(
+        parser,
+        commands={k: v[1] for k, v in COMMANDS.items()},
+        commonspecs=[
+            add_verbosity_cli,
+            add_traceback_cli,
+        ],
+        subset=subset,
+    )
+
+    args = parser.parse_args(argv)
+    ns = vars(args)
+
+    cmd = ns.pop('cmd')
+
+    verbosity, traceback_cm = process_args_by_key(
+        args,
+        processors[cmd],
+        ['verbosity', 'traceback_cm'],
+    )
+    # "verbosity" is sent to the commands, so we put it back.
+    args.verbosity = verbosity
+
+    return cmd, ns, verbosity, traceback_cm
+
+
+def main(cmd, cmd_kwargs):
+    try:
+        run_cmd = COMMANDS[cmd][0]
+    except KeyError:
+        raise ValueError(f'unsupported cmd {cmd!r}')
+    run_cmd(**cmd_kwargs)
+
+
+if __name__ == '__main__':
+    cmd, cmd_kwargs, verbosity, traceback_cm = parse_args()
+    configure_logger(verbosity)
+    with traceback_cm:
+        main(cmd, cmd_kwargs)
diff --git a/Tools/c-analyzer/c_analyzer/analyze.py b/Tools/c-analyzer/c_analyzer/analyze.py
new file mode 100644
index 00000000000..d8ae915e420
--- /dev/null
+++ b/Tools/c-analyzer/c_analyzer/analyze.py
@@ -0,0 +1,307 @@
+from c_parser.info import (
+    KIND,
+    TypeDeclaration,
+    POTSType,
+    FuncPtr,
+    is_pots,
+    is_funcptr,
+)
+from .info import (
+    IGNORED,
+    UNKNOWN,
+    is_system_type,
+    SystemType,
+)
+
+
+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,
+            )
diff --git a/Tools/c-analyzer/c_analyzer/common/files.py b/Tools/c-analyzer/c_analyzer/common/files.py
deleted file mode 100644
index a8a044757d0..00000000000
--- a/Tools/c-analyzer/c_analyzer/common/files.py
+++ /dev/null
@@ -1,124 +0,0 @@
-import glob
-import os
-import os.path
-
-# XXX need tests:
-# * walk_tree()
-# * glob_tree()
-# * iter_files_by_suffix()
-
-
-C_SOURCE_SUFFIXES = ('.c', '.h')
-
-
-def _walk_tree(root, *,
-               _walk=os.walk,
-               ):
-    # A wrapper around os.walk that resolves the filenames.
-    for parent, _, names in _walk(root):
-        for name in names:
-            yield os.path.join(parent, name)
-
-
-def walk_tree(root, *,
-              suffix=None,
-              walk=_walk_tree,
-              ):
-    """Yield each file in the tree under the given directory name.
-
-    If "suffix" is provided then only files with that suffix will
-    be included.
-    """
-    if suffix and not isinstance(suffix, str):
-        raise ValueError('suffix must be a string')
-
-    for filename in walk(root):
-        if suffix and not filename.endswith(suffix):
-            continue
-        yield filename
-
-
-def glob_tree(root, *,
-              suffix=None,
-              _glob=glob.iglob,
-              _escape=glob.escape,
-              _join=os.path.join,
-              ):
-    """Yield each file in the tree under the given directory name.
-
-    If "suffix" is provided then only files with that suffix will
-    be included.
-    """
-    suffix = suffix or ''
-    if not isinstance(suffix, str):
-        raise ValueError('suffix must be a string')
-
-    for filename in _glob(_join(_escape(root), f'*{suffix}')):
-        yield filename
-    for filename in _glob(_join(_escape(root), f'**/*{suffix}')):
-        yield filename
-
-
-def iter_files(root, suffix=None, relparent=None, *,
-               get_files=None,
-               _glob=glob_tree,
-               _walk=walk_tree,
-               ):
-    """Yield each file in the tree under the given directory name.
-
-    If "root" is a non-string iterable then do the same for each of
-    those trees.
-
-    If "suffix" is provided then only files with that suffix will
-    be included.
-
-    if "relparent" is provided then it is used to resolve each
-    filename as a relative path.
-    """
-    if get_files is None:
-        get_files = os.walk
-    if not isinstance(root, str):
-        roots = root
-        for root in roots:
-            yield from iter_files(root, suffix, relparent,
-                                  get_files=get_files,
-                                  _glob=_glob, _walk=_walk)
-        return
-
-    # Use the right "walk" function.
-    if get_files in (glob.glob, glob.iglob, glob_tree):
-        get_files = _glob
-    else:
-        _files = _walk_tree if get_files in (os.walk, walk_tree) else get_files
-        get_files = (lambda *a, **k: _walk(*a, walk=_files, **k))
-
-    # Handle a single suffix.
-    if suffix and not isinstance(suffix, str):
-        filenames = get_files(root)
-        suffix = tuple(suffix)
-    else:
-        filenames = get_files(root, suffix=suffix)
-        suffix = None
-
-    for filename in filenames:
-        if suffix and not isinstance(suffix, str):  # multiple suffixes
-            if not filename.endswith(suffix):
-                continue
-        if relparent:
-            filename = os.path.relpath(filename, relparent)
-        yield filename
-
-
-def iter_files_by_suffix(root, suffixes, relparent=None, *,
-                         walk=walk_tree,
-                         _iter_files=iter_files,
-                         ):
-    """Yield each file in the tree that has the given suffixes.
-
-    Unlike iter_files(), the results are in the original suffix order.
-    """
-    if isinstance(suffixes, str):
-        suffixes = [suffixes]
-    # XXX Ignore repeated suffixes?
-    for suffix in suffixes:
-        yield from _iter_files(root, suffix, relparent)
diff --git a/Tools/c-analyzer/c_analyzer/common/info.py b/Tools/c-analyzer/c_analyzer/common/info.py
deleted file mode 100644
index 1a853a42ff2..00000000000
--- a/Tools/c-analyzer/c_analyzer/common/info.py
+++ /dev/null
@@ -1,138 +0,0 @@
-from collections import namedtuple
-import re
-
-from .util import classonly, _NTBase
-
-# XXX need tests:
-# * ID.match()
-
-
-UNKNOWN = '???'
-
-# Does not start with digit and contains at least one letter.
-NAME_RE = re.compile(r'(?!\d)(?=.*?[A-Za-z])\w+', re.ASCII)
-
-
-class ID(_NTBase, namedtuple('ID', 'filename funcname name')):
-    """A unique ID for a single symbol or declaration."""
-
-    __slots__ = ()
-    # XXX Add optional conditions (tuple of strings) field.
-    #conditions = Slot()
-
-    @classonly
-    def from_raw(cls, raw):
-        if not raw:
-            return None
-        if isinstance(raw, str):
-            return cls(None, None, raw)
-        try:
-            name, = raw
-            filename = None
-        except ValueError:
-            try:
-                filename, name = raw
-            except ValueError:
-                return super().from_raw(raw)
-        return cls(filename, None, name)
-
-    def __new__(cls, filename, funcname, name):
-        self = super().__new__(
-                cls,
-                filename=str(filename) if filename else None,
-                funcname=str(funcname) if funcname else None,
-                name=str(name) if name else None,
-                )
-        #cls.conditions.set(self, tuple(str(s) if s else None
-        #                               for s in conditions or ()))
-        return self
-
-    def validate(self):
-        """Fail if the object is invalid (i.e. init with bad data)."""
-        if not self.name:
-            raise TypeError('missing name')
-        if not NAME_RE.fullmatch(self.name):
-            raise ValueError(
-                    f'name must be an identifier, got {self.name!r}')
-
-        # Symbols from a binary might not have filename/funcname info.
-
-        if self.funcname:
-            if not self.filename:
-                raise TypeError('missing filename')
-            if not NAME_RE.fullmatch(self.funcname) and self.funcname != UNKNOWN:
-                raise ValueError(
-                        f'name must be an identifier, got {self.funcname!r}')
-
-        # XXX Require the filename (at least UNKONWN)?
-        # XXX Check the filename?
-
-    @property
-    def islocal(self):
-        return self.funcname is not None
-
-    def match(self, other, *,
-              match_files=(lambda f1, f2: f1 == f2),
-              ):
-        """Return True if the two match.
-
-        At least one of the two must be completely valid (no UNKNOWN
-        anywhere).  Otherwise False is returned.  The remaining one
-        *may* have UNKNOWN for both funcname and filename.  It must
-        have a valid name though.
-
-        The caller is responsible for knowing which of the two is valid
-        (and which to use if both are valid).
-        """
-        # First check the name.
-        if self.name is None:
-            return False
-        if other.name != self.name:
-            return False
-
-        # Then check the filename.
-        if self.filename is None:
-            return False
-        if other.filename is None:
-            return False
-        if self.filename == UNKNOWN:
-            # "other" must be the valid one.
-            if other.funcname == UNKNOWN:
-                return False
-            elif self.funcname != UNKNOWN:
-                # XXX Try matching funcname even though we don't
-                # know the filename?
-                raise NotImplementedError
-            else:
-                return True
-        elif other.filename == UNKNOWN:
-            # "self" must be the valid one.
-            if self.funcname == UNKNOWN:
-                return False
-            elif other.funcname != UNKNOWN:
-                # XXX Try matching funcname even though we don't
-                # know the filename?
-                raise NotImplementedError
-            else:
-                return True
-        elif not match_files(self.filename, other.filename):
-            return False
-
-        # Finally, check the funcname.
-        if self.funcname == UNKNOWN:
-            # "other" must be the valid one.
-            if other.funcname == UNKNOWN:
-                return False
-            else:
-                return other.funcname is not None
-        elif other.funcname == UNKNOWN:
-            # "self" must be the valid one.
-            if self.funcname == UNKNOWN:
-                return False
-            else:
-                return self.funcname is not None
-        elif self.funcname == other.funcname:
-            # Both are valid.
-            return True
-
-        return False
diff --git a/Tools/c-analyzer/c_analyzer/common/show.py b/Tools/c-analyzer/c_analyzer/common/show.py
deleted file mode 100644
index 5f3cb1c2fb0..00000000000
--- a/Tools/c-analyzer/c_analyzer/common/show.py
+++ /dev/null
@@ -1,11 +0,0 @@
-
-def basic(variables, *,
-          _print=print):
-    """Print each row simply."""
-    for var in variables:
-        if var.funcname:
-            line = f'{var.filename}:{var.funcname}():{var.name}'
-        else:
-            line = f'{var.filename}:{var.name}'
-        line = f'{line:<64} {var.vartype}'
-        _print(line)
diff --git a/Tools/c-analyzer/c_analyzer/datafiles.py b/Tools/c-analyzer/c_analyzer/datafiles.py
new file mode 100644
index 00000000000..0de438cce47
--- /dev/null
+++ b/Tools/c-analyzer/c_analyzer/datafiles.py
@@ -0,0 +1,109 @@
+import c_common.tables as _tables
+import c_parser.info as _info
+import c_parser.datafiles as _parser
+from . import analyze as _analyze
+
+
+#############################
+# "known" decls
+
+EXTRA_COLUMNS = [
+    #'typedecl',
+]
+
+
+def analyze_known(known, *,
+                  analyze_resolved=None,
+                  handle_unresolved=True,
+                  ):
+    knowntypes = knowntypespecs = {}
+    collated = _info.collate_by_kind_group(known)
+    types = {decl: None for decl in collated['type']}
+    typespecs = _analyze.get_typespecs(types)
+    def analyze_decl(decl):
+        return _analyze.analyze_decl(
+            decl,
+            typespecs,
+            knowntypespecs,
+            types,
+            knowntypes,
+            analyze_resolved=analyze_resolved,
+        )
+    _analyze.analyze_type_decls(types, analyze_decl, handle_unresolved)
+    return types, typespecs
+
+
+def get_known(known, extracolumns=None, *,
+              analyze_resolved=None,
+              handle_unresolved=True,
+              relroot=None,
+              ):
+    if isinstance(known, str):
+        known = read_known(known, extracolumns, relroot)
+    return analyze_known(
+        known,
+        handle_unresolved=handle_unresolved,
+        analyze_resolved=analyze_resolved,
+    )
+
+
+def read_known(infile, extracolumns=None, relroot=None):
+    extracolumns = EXTRA_COLUMNS + (
+        list(extracolumns) if extracolumns else []
+    )
+    known = {}
+    for decl, extra in _parser.iter_decls_tsv(infile, extracolumns, relroot):
+        known[decl] = extra
+    return known
+
+
+def write_known(rows, outfile, extracolumns=None, *,
+                relroot=None,
+                backup=True,
+                ):
+    extracolumns = EXTRA_COLUMNS + (
+        list(extracolumns) if extracolumns else []
+    )
+    _parser.write_decls_tsv(
+        rows,
+        outfile,
+        extracolumns,
+        relroot=relroot,
+        backup=backup,
+    )
+
+
+#############################
+# ignored vars
+
+IGNORED_COLUMNS = [
+    'filename',
+    'funcname',
+    'name',
+    'reason',
+]
+IGNORED_HEADER = '\t'.join(IGNORED_COLUMNS)
+
+
+def read_ignored(infile):
+    return dict(_iter_ignored(infile))
+
+
+def _iter_ignored(infile):
+    for row in _tables.read_table(infile, IGNORED_HEADER, sep='\t'):
+        *varidinfo, reason = row
+        varid = _info.DeclID.from_row(varidinfo)
+        yield varid, reason
+
+
+def write_ignored(variables, outfile):
+    raise NotImplementedError
+    reason = '???'
+    #if not isinstance(varid, DeclID):
+    #    varid = getattr(varid, 'parsed', varid).id
+    _tables.write_table(
+        outfile,
+        IGNORED_HEADER,
+        sep='\t',
+        rows=(r.render_rowdata() + (reason,) for r in decls),
+    )
diff --git a/Tools/c-analyzer/c_analyzer/info.py b/Tools/c-analyzer/c_analyzer/info.py
new file mode 100644
index 00000000000..23d77611a4c
--- /dev/null
+++ b/Tools/c-analyzer/c_analyzer/info.py
@@ -0,0 +1,353 @@
+from collections import namedtuple
+
+from c_common.clsutil import classonly
+import c_common.misc as _misc
+from c_parser.info import (
+    KIND,
+    HighlevelParsedItem,
+    Declaration,
+    TypeDeclaration,
+    is_type_decl,
+    is_process_global,
+)
+
+
+IGNORED = _misc.Labeled('IGNORED')
+UNKNOWN = _misc.Labeled('UNKNOWN')
+
+
+# XXX Use known.tsv for these?
+SYSTEM_TYPES = {
+    'int8_t',
+    'uint8_t',
+    'int16_t',
+    'uint16_t',
+    'int32_t',
+    'uint32_t',
+    'int64_t',
+    'uint64_t',
+    'size_t',
+    'ssize_t',
+    'intptr_t',
+    'uintptr_t',
+    'wchar_t',
+    '',
+    # OS-specific
+    'pthread_cond_t',
+    'pthread_mutex_t',
+    'pthread_key_t',
+    'atomic_int',
+    'atomic_uintptr_t',
+    '',
+    # lib-specific
+    'WINDOW',  # curses
+    'XML_LChar',
+    'XML_Size',
+    'XML_Parser',
+    'enum XML_Error',
+    'enum XML_Status',
+    '',
+}
+
+
+def is_system_type(typespec):
+    return typespec in SYSTEM_TYPES
+
+
+class SystemType(TypeDeclaration):
+
+    def __init__(self, name):
+        super().__init__(None, name, None, None, _shortkey=name)
+
+
+class Analyzed:
+    _locked = False
+
+    @classonly
+    def is_target(cls, raw):
+        if isinstance(raw, HighlevelParsedItem):
+            return True
+        else:
+            return False
+
+    @classonly
+    def from_raw(cls, raw, **extra):
+        if isinstance(raw, cls):
+            if extra:
+                # XXX ?
+                raise NotImplementedError((raw, extra))
+                #return cls(raw.item, raw.typedecl, **raw._extra, **extra)
+            else:
+                return info
+        elif cls.is_target(raw):
+            return cls(raw, **extra)
+        else:
+            raise NotImplementedError((raw, extra))
+
+    @classonly
+    def from_resolved(cls, item, resolved, **extra):
+        if isinstance(resolved, TypeDeclaration):
+            return cls(item, typedecl=resolved, **extra)
+        else:
+            typedeps, extra = cls._parse_raw_resolved(item, resolved, extra)
+            if item.kind is KIND.ENUM:
+                if typedeps:
+                    raise NotImplementedError((item, resolved, extra))
+            elif not typedeps:
+                raise NotImplementedError((item, resolved, extra))
+            return cls(item, typedeps, **extra or {})
+
+    @classonly
+    def _parse_raw_resolved(cls, item, resolved, extra_extra):
+        if resolved in (UNKNOWN, IGNORED):
+            return resolved, None
+        try:
+            typedeps, extra = resolved
+        except (TypeError, ValueError):
+            typedeps = extra = None
+        if extra:
+            # The resolved data takes precedence.
+            extra = dict(extra_extra, **extra)
+        if isinstance(typedeps, TypeDeclaration):
+            return typedeps, extra
+        elif typedeps in (None, UNKNOWN):
+            # It is still effectively unresolved.
+            return UNKNOWN, extra
+        elif None in typedeps or UNKNOWN in typedeps:
+            # It is still effectively unresolved.
+            return typedeps, extra
+        elif any(not isinstance(td, TypeDeclaration) for td in typedeps):
+            raise NotImplementedError((item, typedeps, extra))
+        return typedeps, extra
+
+    def __init__(self, item, typedecl=None, **extra):
+        assert item is not None
+        self.item = item
+        if typedecl in (UNKNOWN, IGNORED):
+            pass
+        elif item.kind is KIND.STRUCT or item.kind is KIND.UNION:
+            if isinstance(typedecl, TypeDeclaration):
+                raise NotImplementedError(item, typedecl)
+            elif typedecl is None:
+                typedecl = UNKNOWN
+            else:
+                typedecl = [UNKNOWN if d is None else d for d in typedecl]
+        elif typedecl is None:
+            typedecl = UNKNOWN
+        elif typedecl and not isinstance(typedecl, TypeDeclaration):
+            # All the other decls have a single type decl.
+            typedecl, = typedecl
+            if typedecl is None:
+                typedecl = UNKNOWN
+        self.typedecl = typedecl
+        self._extra = extra
+        self._locked = True
+
+        self._validate()
+
+    def _validate(self):
+        item = self.item
+        extra = self._extra
+        # Check item.
+        if not isinstance(item, HighlevelParsedItem):
+            raise ValueError(f'"item" must be a high-level parsed item, got {item!r}')
+        # Check extra.
+        for key, value in extra.items():
+            if key.startswith('_'):
+                raise ValueError(f'extra items starting with {"_"!r} not allowed, got {extra!r}')
+            if hasattr(item, key) and not callable(getattr(item, key)):
+                raise ValueError(f'extra cannot override item, got {value!r} for key {key!r}')
+
+    def __repr__(self):
+        kwargs = [
+            f'item={self.item!r}',
+            f'typedecl={self.typedecl!r}',
+            *(f'{k}={v!r}' for k, v in self._extra.items())
+        ]
+        return f'{type(self).__name__}({", ".join(kwargs)})'
+
+    def __str__(self):
+        try:
+            return self._str
+        except AttributeError:
+            self._str, = self.render('line')
+            return self._str
+
+    def __hash__(self):
+        return hash(self.item)
+
+    def __eq__(self, other):
+        if isinstance(other, Analyzed):
+            return self.item == other.item
+        elif isinstance(other, HighlevelParsedItem):
+            return self.item == other
+        elif type(other) is tuple:
+            return self.item == other
+        else:
+            return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, Analyzed):
+            return self.item > other.item
+        elif isinstance(other, HighlevelParsedItem):
+            return self.item > other
+        elif type(other) is tuple:
+            return self.item > other
+        else:
+            return NotImplemented
+
+    def __dir__(self):
+        names = set(super().__dir__())
+        names.update(self._extra)
+        names.remove('_locked')
+        return sorted(names)
+
+    def __getattr__(self, name):
+        if name.startswith('_'):
+            raise AttributeError(name)
+        # The item takes precedence over the extra data (except if callable).
+        try:
+            value = getattr(self.item, name)
+            if callable(value):
+                raise AttributeError(name)
+        except AttributeError:
+            try:
+                value = self._extra[name]
+            except KeyError:
+                pass
+            else:
+                # Speed things up the next time.
+                self.__dict__[name] = value
+                return value
+            raise  # re-raise
+        else:
+            return value
+
+    def __setattr__(self, name, value):
+        if self._locked and name != '_str':
+            raise AttributeError(f'readonly ({name})')
+        super().__setattr__(name, value)
+
+    def __delattr__(self, name):
+        if self._locked:
+            raise AttributeError(f'readonly ({name})')
+        super().__delattr__(name)
+
+    @property
+    def decl(self):
+        if not isinstance(self.item, Declaration):
+            raise AttributeError('decl')
+        return self.item
+
+    @property
+    def signature(self):
+        # XXX vartype...
+        ...
+
+    @property
+    def istype(self):
+        return is_type_decl(self.item.kind)
+
+    @property
+    def is_known(self):
+        if self.typedecl in (UNKNOWN, IGNORED):
+            return False
+        elif isinstance(self.typedecl, TypeDeclaration):
+            return True
+        else:
+            return UNKNOWN not in self.typedecl
+
+    def fix_filename(self, relroot):
+        self.item.fix_filename(relroot)
+
+    def as_rowdata(self, columns=None):
+        # XXX finsih!
+        return self.item.as_rowdata(columns)
+
+    def render_rowdata(self, columns=None):
+        # XXX finsih!
+        return self.item.render_rowdata(columns)
+
+    def render(self, fmt='line', *, itemonly=False):
+        if fmt == 'raw':
+            yield repr(self)
+            return
+        rendered = self.item.render(fmt)
+        if itemonly or not self._extra:
+            yield from rendered
+            return
+        extra = self._render_extra(fmt)
+        if not extra:
+            yield from rendered
+        elif fmt in ('brief', 'line'):
+            rendered, = rendered
+            extra, = extra
+            yield f'{rendered}\t{extra}'
+        elif fmt == 'summary':
+            raise NotImplementedError(fmt)
+        elif fmt == 'full':
+            yield from rendered
+            for line in extra:
+                yield f'\t{line}'
+        else:
+            raise NotImplementedError(fmt)
+
+    def _render_extra(self, fmt):
+        if fmt in ('brief', 'line'):
+            yield str(self._extra)
+        else:
+            raise NotImplementedError(fmt)
+
+
+class Analysis:
+
+    _item_class = Analyzed
+
+    @classonly
+    def build_item(cls, info, resolved=None, **extra):
+        if resolved is None:
+            return cls._item_class.from_raw(info, **extra)
+        else:
+            return cls._item_class.from_resolved(info, resolved, **extra)
+
+    @classmethod
+    def from_results(cls, results):
+        self = cls()
+        for info, resolved in results:
+            self._add_result(info, resolved)
+        return self
+
+    def __init__(self, items=None):
+        self._analyzed = {type(self).build_item(item): None
+                          for item in items or ()}
+
+    def __repr__(self):
+        return f'{type(self).__name__}({list(self._analyzed.keys())})'
+
+    def __iter__(self):
+        #yield from self.types
+        #yield from self.functions
+        #yield from self.variables
+        yield from self._analyzed
+
+    def __len__(self):
+        return len(self._analyzed)
+
+    def __getitem__(self, key):
+        if type(key) is int:
+            for i, val in enumerate(self._analyzed):
+                if i == key:
+                    return val
+            else:
+                raise IndexError(key)
+        else:
+            return self._analyzed[key]
+
+    def fix_filenames(self, relroot):
+        for item in self._analyzed:
+            item.fix_filename(relroot)
+
+    def _add_result(self, info, resolved):
+        analyzed = type(self).build_item(info, resolved)
+        self._analyzed[analyzed] = None
+        return analyzed
diff --git a/Tools/c-analyzer/c_analyzer/parser/declarations.py b/Tools/c-analyzer/c_analyzer/parser/declarations.py
deleted file mode 100644
index f37072cccad..00000000000
--- a/Tools/c-analyzer/c_analyzer/parser/declarations.py
+++ /dev/null
@@ -1,339 +0,0 @@
-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
diff --git a/Tools/c-analyzer/c_analyzer/parser/find.py b/Tools/c-analyzer/c_analyzer/parser/find.py
deleted file mode 100644
index 3860d3d459b..00000000000
--- a/Tools/c-analyzer/c_analyzer/parser/find.py
+++ /dev/null
@@ -1,107 +0,0 @@
-from ..common.info import UNKNOWN, ID
-
-from . import declarations
-
-# XXX need tests:
-# * variables
-# * variable
-# * variable_from_id
-
-
-def _iter_vars(filenames, preprocessed, *,
-               handle_id=None,
-               _iter_decls=declarations.iter_all,
-               ):
-    if handle_id is None:
-        handle_id = ID
-
-    for filename in filenames or ():
-        for kind, funcname, name, decl in _iter_decls(filename,
-                                                      preprocessed=preprocessed,
-                                                      ):
-            if kind != 'variable':
-                continue
-            varid = handle_id(filename, funcname, name)
-            yield varid, decl
-
-
-# XXX Add a "handle_var" arg like we did for get_resolver()?
-
-def variables(*filenames,
-              perfilecache=None,
-              preprocessed=False,
-              known=None,  # for types
-              handle_id=None,
-              _iter_vars=_iter_vars,
-              ):
-    """Yield (varid, decl) for each variable found in the given files.
-
-    If "preprocessed" is provided (and not False/None) then it is used
-    to decide which tool to use to parse the source code after it runs
-    through the C preprocessor.  Otherwise the raw
-    """
-    if len(filenames) == 1 and not (filenames[0], str):
-        filenames, = filenames
-
-    if perfilecache is None:
-        yield from _iter_vars(filenames, preprocessed)
-    else:
-        # XXX Cache per-file variables (e.g. `{filename: [(varid, decl)]}`).
-        raise NotImplementedError
-
-
-def variable(name, filenames, *,
-             local=False,
-             perfilecache=None,
-             preprocessed=False,
-             handle_id=None,
-             _iter_vars=variables,
-             ):
-    """Return (varid, decl) for the first found variable that matches.
-
-    If "local" is True then the first matching local variable in the
-    file will always be returned.  To avoid that, pass perfilecache and
-    pop each variable from the cache after using it.
-    """
-    for varid, decl in _iter_vars(filenames,
-                                  perfilecache=perfilecache,
-                                  preprocessed=preprocessed,
-                                  ):
-        if varid.name != name:
-            continue
-        if local:
-            if varid.funcname:
-                if varid.funcname == UNKNOWN:
-                    raise NotImplementedError
-                return varid, decl
-        elif not varid.funcname:
-            return varid, decl
-    else:
-        return None, None  # No matching variable was found.
-
-
-def variable_from_id(id, filenames, *,
-                     perfilecache=None,
-                     preprocessed=False,
-                     handle_id=None,
-                     _get_var=variable,
-                     ):
-    """Return (varid, decl) for the first found variable that matches."""
-    local = False
-    if isinstance(id, str):
-        name = id
-    else:
-        if id.funcname == UNKNOWN:
-            local = True
-        elif id.funcname:
-            raise NotImplementedError
-
-        name = id.name
-        if id.filename and id.filename != UNKNOWN:
-            filenames = [id.filename]
-    return _get_var(name, filenames,
-                    local=local,
-                    perfilecache=perfilecache,
-                    preprocessed=preprocessed,
-                    handle_id=handle_id,
-                    )
diff --git a/Tools/c-analyzer/c_analyzer/parser/naive.py b/Tools/c-analyzer/c_analyzer/parser/naive.py
deleted file mode 100644
index 4a4822d84ff..00000000000
--- a/Tools/c-analyzer/c_analyzer/parser/naive.py
+++ /dev/null
@@ -1,179 +0,0 @@
-import re
-
-from ..common.info import UNKNOWN, ID
-
-from .preprocessor import _iter_clean_lines
-
-
-_NOT_SET = object()
-
-
-def get_srclines(filename, *,
-                 cache=None,
-                 _open=open,
-                 _iter_lines=_iter_clean_lines,
-                 ):
-    """Return the file's lines as a list.
-
-    Each line will have trailing whitespace removed (including newline).
-
-    If a cache is given the it is used.
-    """
-    if cache is not None:
-        try:
-            return cache[filename]
-        except KeyError:
-            pass
-
-    with _open(filename) as srcfile:
-        srclines = [line
-                    for _, line in _iter_lines(srcfile)
-                    if not line.startswith('#')]
-    for i, line in enumerate(srclines):
-        srclines[i] = line.rstrip()
-
-    if cache is not None:
-        cache[filename] = srclines
-    return srclines
-
-
-def parse_variable_declaration(srcline):
-    """Return (name, decl) for the given declaration line."""
-    # XXX possible false negatives...
-    decl, sep, _ = srcline.partition('=')
-    if not sep:
-        if not srcline.endswith(';'):
-            return None, None
-        decl = decl.strip(';')
-    decl = decl.strip()
-    m = re.match(r'.*\b(\w+)\s*(?:\[[^\]]*\])?$', decl)
-    if not m:
-        return None, None
-    name = m.group(1)
-    return name, decl
-
-
-def parse_variable(srcline, funcname=None):
-    """Return (varid, decl) for the variable declared on the line (or None)."""
-    line = srcline.strip()
-
-    # XXX Handle more than just static variables.
-    if line.startswith('static '):
-        if '(' in line and '[' not in line:
-            # a function
-            return None, None
-        return parse_variable_declaration(line)
-    else:
-        return None, None
-
-
-def iter_variables(filename, *,
-                   srccache=None,
-                   parse_variable=None,
-                   _get_srclines=get_srclines,
-                   _default_parse_variable=parse_variable,
-                   ):
-    """Yield (varid, decl) for each variable in the given source file."""
-    if parse_variable is None:
-        parse_variable = _default_parse_variable
-
-    indent = ''
-    prev = ''
-    funcname = None
-    for line in _get_srclines(filename, cache=srccache):
-        # remember current funcname
-        if funcname:
-            if line == indent + '}':
-                funcname = None
-                continue
-        else:
-            if '(' in prev and line == indent + '{':
-                if not prev.startswith('__attribute__'):
-                    funcname = prev.split('(')[0].split()[-1]
-                    prev = ''
-                    continue
-            indent = line[:-len(line.lstrip())]
-            prev = line
-
-        info = parse_variable(line, funcname)
-        if isinstance(info, list):
-            for name, _funcname, decl in info:
-                yield ID(filename, _funcname, name), decl
-            continue
-        name, decl = info
-
-        if name is None:
-            continue
-        yield ID(filename, funcname, name), decl
-
-
-def _match_varid(variable, name, funcname, ignored=None):
-    if ignored and variable in ignored:
-        return False
-
-    if variable.name != name:
-        return False
-
-    if funcname == UNKNOWN:
-        if not variable.funcname:
-            return False
-    elif variable.funcname != funcname:
-        return False
-
-    return True
-
-
-def find_variable(filename, funcname, name, *,
-                  ignored=None,
-                  srccache=None,  # {filename: lines}
-                  parse_variable=None,
-                  _iter_variables=iter_variables,
-                  ):
-    """Return the matching variable.
-
-    Return None if the variable is not found.
-    """
-    for varid, decl in _iter_variables(filename,
-                                    srccache=srccache,
-                                    parse_variable=parse_variable,
-                                    ):
-        if _match_varid(varid, name, funcname, ignored):
-            return varid, decl
-    else:
-        return None
-
-
-def find_variables(varids, filenames=None, *,
-                   srccache=_NOT_SET,
-                   parse_variable=None,
-                   _find_symbol=find_variable,
-                   ):
-    """Yield (varid, decl) for each ID.
-
-    If the variable is not found then its decl will be UNKNOWN.  That
-    way there will be one resulting variable per given ID.
-    """
-    if srccache is _NOT_SET:
-        srccache = {}
-
-    used = set()
-    for varid in varids:
-        if varid.filename and varid.filename != UNKNOWN:
-            srcfiles = [varid.filename]
-        else:
-            if not filenames:
-                yield varid, UNKNOWN
-                continue
-            srcfiles = filenames
-        for filename in srcfiles:
-            varid, decl = _find_varid(filename, varid.funcname, varid.name,
-                                      ignored=used,
-                                      srccache=srccache,
-                                      parse_variable=parse_variable,
-                                      )
-            if varid:
-                yield varid, decl
-                used.add(varid)
-                break
-        else:
-            yield varid, UNKNOWN
diff --git a/Tools/c-analyzer/c_analyzer/parser/preprocessor.py b/Tools/c-analyzer/c_analyzer/parser/preprocessor.py
deleted file mode 100644
index 41f306e5f80..00000000000
--- a/Tools/c-analyzer/c_analyzer/parser/preprocessor.py
+++ /dev/null
@@ -1,511 +0,0 @@
-from collections import namedtuple
-import shlex
-import os
-import re
-
-from ..common import util, info
-
-
-CONTINUATION = '\\' + os.linesep
-
-IDENTIFIER = r'(?:\w*[a-zA-Z]\w*)'
-IDENTIFIER_RE = re.compile('^' + IDENTIFIER + '$')
-
-
-def _coerce_str(value):
-    if not value:
-        return ''
-    return str(value).strip()
-
-
-#############################
-# directives
-
-DIRECTIVE_START = r'''
-    (?:
-      ^ \s*
-      [#] \s*
-      )'''
-DIRECTIVE_TEXT = r'''
-    (?:
-      (?: \s+ ( .*\S ) )?
-      \s* $
-      )'''
-DIRECTIVE = rf'''
-    (?:
-      {DIRECTIVE_START}
-      (
-        include |
-        error | warning |
-        pragma |
-        define | undef |
-        if | ifdef | ifndef | elseif | else | endif |
-        __FILE__ | __LINE__ | __DATE __ | __TIME__ | __TIMESTAMP__
-        )
-      {DIRECTIVE_TEXT}
-      )'''
-#       (?:
-#        [^\\\n] |
-#        \\ [^\n] |
-#        \\ \n
-#        )+
-#      ) \n
-#     )'''
-DIRECTIVE_RE = re.compile(DIRECTIVE, re.VERBOSE)
-
-DEFINE = rf'''
-    (?:
-      {DIRECTIVE_START} define \s+
-      (?:
-        ( \w*[a-zA-Z]\w* )
-        (?: \s* [(] ([^)]*) [)] )?
-        )
-      {DIRECTIVE_TEXT}
-      )'''
-DEFINE_RE = re.compile(DEFINE, re.VERBOSE)
-
-
-def parse_directive(line):
-    """Return the appropriate directive for the given line."""
-    line = line.strip()
-    if line.startswith('#'):
-        line = line[1:].lstrip()
-        line = '#' + line
-    directive = line
-    #directive = '#' + line
-    while '  ' in directive:
-        directive = directive.replace('  ', ' ')
-    return _parse_directive(directive)
-
-
-def _parse_directive(line):
-    m = DEFINE_RE.match(line)
-    if m:
-        name, args, text = m.groups()
-        if args:
-            args = [a.strip() for a in args.split(',')]
-            return Macro(name, args, text)
-        else:
-            return Constant(name, text)
-
-    m = DIRECTIVE_RE.match(line)
-    if not m:
-        raise ValueError(f'unsupported directive {line!r}')
-    kind, text = m.groups()
-    if not text:
-        if kind not in ('else', 'endif'):
-            raise ValueError(f'missing text in directive {line!r}')
-    elif kind in ('else', 'endif', 'define'):
-        raise ValueError(f'unexpected text in directive {line!r}')
-    if kind == 'include':
-        directive = Include(text)
-    elif kind in IfDirective.KINDS:
-        directive = IfDirective(kind, text)
-    else:
-        directive = OtherDirective(kind, text)
-    directive.validate()
-    return directive
-
-
-class PreprocessorDirective(util._NTBase):
-    """The base class for directives."""
-
-    __slots__ = ()
-
-    KINDS = frozenset([
-            'include',
-            'pragma',
-            'error', 'warning',
-            'define', 'undef',
-            'if', 'ifdef', 'ifndef', 'elseif', 'else', 'endif',
-            '__FILE__', '__DATE__', '__LINE__', '__TIME__', '__TIMESTAMP__',
-            ])
-
-    @property
-    def text(self):
-        return ' '.join(v for v in self[1:] if v and v.strip()) or None
-
-    def validate(self):
-        """Fail if the object is invalid (i.e. init with bad data)."""
-        super().validate()
-
-        if not self.kind:
-            raise TypeError('missing kind')
-        elif self.kind not in self.KINDS:
-            raise ValueError
-
-        # text can be anything, including None.
-
-
-class Constant(PreprocessorDirective,
-               namedtuple('Constant', 'kind name value')):
-    """A single "constant" directive ("define")."""
-
-    __slots__ = ()
-
-    def __new__(cls, name, value=None):
-        self = super().__new__(
-                cls,
-                'define',
-                name=_coerce_str(name) or None,
-                value=_coerce_str(value) or None,
-                )
-        return self
-
-    def validate(self):
-        """Fail if the object is invalid (i.e. init with bad data)."""
-        super().validate()
-
-        if not self.name:
-            raise TypeError('missing name')
-        elif not IDENTIFIER_RE.match(self.name):
-            raise ValueError(f'name must be identifier, got {self.name!r}')
-
-        # value can be anything, including None
-
-
-class Macro(PreprocessorDirective,
-            namedtuple('Macro', 'kind name args body')):
-    """A single "macro" directive ("define")."""
-
-    __slots__ = ()
-
-    def __new__(cls, name, args, body=None):
-        # "args" must be a string or an iterable of strings (or "empty").
-        if isinstance(args, str):
-            args = [v.strip() for v in args.split(',')]
-        if args:
-            args = tuple(_coerce_str(a) or None for a in args)
-        self = super().__new__(
-                cls,
-                kind='define',
-                name=_coerce_str(name) or None,
-                args=args if args else (),
-                body=_coerce_str(body) or None,
-                )
-        return self
-
-    @property
-    def text(self):
-        if self.body:
-            return f'{self.name}({", ".join(self.args)}) {self.body}'
-        else:
-            return f'{self.name}({", ".join(self.args)})'
-
-    def validate(self):
-        """Fail if the object is invalid (i.e. init with bad data)."""
-        super().validate()
-
-        if not self.name:
-            raise TypeError('missing name')
-        elif not IDENTIFIER_RE.match(self.name):
-            raise ValueError(f'name must be identifier, got {self.name!r}')
-
-        for arg in self.args:
-            if not arg:
-                raise ValueError(f'missing arg in {self.args}')
-            elif not IDENTIFIER_RE.match(arg):
-                raise ValueError(f'arg must be identifier, got {arg!r}')
-
-        # body can be anything, including None
-
-
-class IfDirective(PreprocessorDirective,
-                  namedtuple('IfDirective', 'kind condition')):
-    """A single conditional directive (e.g. "if", "ifdef").
-
-    This only includes directives that actually provide conditions.  The
-    related directives "else" and "endif" are covered by OtherDirective
-    instead.
-    """
-
-    __slots__ = ()
-
-    KINDS = frozenset([
-            'if',
-            'ifdef',
-            'ifndef',
-            'elseif',
-            ])
-
-    @classmethod
-    def _condition_from_raw(cls, raw, kind):
-        #return Condition.from_raw(raw, _kind=kind)
-        condition = _coerce_str(raw)
-        if not condition:
-            return None
-
-        if kind == 'ifdef':
-            condition = f'defined({condition})'
-        elif kind == 'ifndef':
-            condition = f'! defined({condition})'
-
-        return condition
-
-    def __new__(cls, kind, condition):
-        kind = _coerce_str(kind)
-        self = super().__new__(
-                cls,
-                kind=kind or None,
-                condition=cls._condition_from_raw(condition, kind),
-                )
-        return self
-
-    @property
-    def text(self):
-        if self.kind == 'ifdef':
-            return self.condition[8:-1]  # strip "defined("
-        elif self.kind == 'ifndef':
-            return self.condition[10:-1]  # strip "! defined("
-        else:
-            return self.condition
-        #return str(self.condition)
-
-    def validate(self):
-        """Fail if the object is invalid (i.e. init with bad data)."""
-        super().validate()
-
-        if not self.condition:
-            raise TypeError('missing condition')
-        #else:
-        #    for cond in self.condition:
-        #        if not cond:
-        #            raise ValueError(f'missing condition in {self.condition}')
-        #        cond.validate()
-        #    if self.kind in ('ifdef', 'ifndef'):
-        #        if len(self.condition) != 1:
-        #            raise ValueError('too many condition')
-        #        if self.kind == 'ifdef':
-        #            if not self.condition[0].startswith('defined '):
-        #                raise ValueError('bad condition')
-        #        else:
-        #            if not self.condition[0].startswith('! defined '):
-        #                raise ValueError('bad condition')
-
-
-class Include(PreprocessorDirective,
-              namedtuple('Include', 'kind file')):
-    """A single "include" directive.
-
-    Supported "file" values are either follow the bracket style
-    (<stdio>) or double quotes ("spam.h").
-    """
-
-    __slots__ = ()
-
-    def __new__(cls, file):
-        self = super().__new__(
-                cls,
-                kind='include',
-                file=_coerce_str(file) or None,
-                )
-        return self
-
-    def validate(self):
-        """Fail if the object is invalid (i.e. init with bad data)."""
-        super().validate()
-
-        if not self.file:
-            raise TypeError('missing file')
-
-
-class OtherDirective(PreprocessorDirective,
-                     namedtuple('OtherDirective', 'kind text')):
-    """A single directive not covered by another class.
-
-    This includes the "else", "endif", and "undef" directives, which are
-    otherwise inherently related to the directives covered by the
-    Constant, Macro, and IfCondition classes.
-
-    Note that all directives must have a text value, except for "else"
-    and "endif" (which must have no text).
-    """
-
-    __slots__ = ()
-
-    KINDS = PreprocessorDirective.KINDS - {'include', 'define'} - IfDirective.KINDS
-
-    def __new__(cls, kind, text):
-        self = super().__new__(
-                cls,
-                kind=_coerce_str(kind) or None,
-                text=_coerce_str(text) or None,
-                )
-        return self
-
-    def validate(self):
-        """Fail if the object is invalid (i.e. init with bad data)."""
-        super().validate()
-
-        if self.text:
-            if self.kind in ('else', 'endif'):
-                raise ValueError('unexpected text in directive')
-        elif self.kind not in ('else', 'endif'):
-            raise TypeError('missing text')
-
-
-#############################
-# iterating lines
-
-def _recompute_conditions(directive, ifstack):
-    if directive.kind in ('if', 'ifdef', 'ifndef'):
-        ifstack.append(
-                ([], directive.condition))
-    elif directive.kind == 'elseif':
-        if ifstack:
-            negated, active = ifstack.pop()
-            if active:
-                negated.append(active)
-        else:
-            negated = []
-        ifstack.append(
-                (negated, directive.condition))
-    elif directive.kind == 'else':
-        if ifstack:
-            negated, active = ifstack.pop()
-            if active:
-                negated.append(active)
-            ifstack.append(
-                    (negated, None))
-    elif directive.kind == 'endif':
-        if ifstack:
-            ifstack.pop()
-
-    conditions = []
-    for negated, active in ifstack:
-        for condition in negated:
-            conditions.append(f'! ({condition})')
-        if active:
-            conditions.append(active)
-    return tuple(conditions)
-
-
-def _iter_clean_lines(lines):
-    lines = iter(enumerate(lines, 1))
-    for lno, line in lines:
-        # Handle line continuations.
-        while line.endswith(CONTINUATION):
-            try:
-                lno, _line = next(lines)
-            except StopIteration:
-                break
-            line = line[:-len(CONTINUATION)] + ' ' + _line
-
-        # Deal with comments.
-        after = line
-        line = ''
-        while True:
-            # Look for a comment.
-            before, begin, remainder = after.partition('/*')
-            if '//' in before:
-                before, _, _ = before.partition('//')
-                line += before + ' '  # per the C99 spec
-                break
-            line += before
-            if not begin:
-                break
-            line += ' '  # per the C99 spec
-
-            # Go until we find the end of the comment.
-            _, end, after = remainder.partition('*/')
-            while not end:
-                try:
-                    lno, remainder = next(lines)
-                except StopIteration:
-                    raise Exception('unterminated comment')
-                _, end, after = remainder.partition('*/')
-
-        yield lno, line
-
-
-def iter_lines(lines, *,
-                   _iter_clean_lines=_iter_clean_lines,
-                   _parse_directive=_parse_directive,
-                   _recompute_conditions=_recompute_conditions,
-                   ):
-    """Yield (lno, line, directive, active conditions) for each given line.
-
-    This is effectively a subset of the operations taking place in
-    translation phases 2-4 from the C99 spec (ISO/IEC 9899:TC2); see
-    section 5.1.1.2.  Line continuations are removed and comments
-    replaced with a single space.  (In both cases "lno" will be the last
-    line involved.)  Otherwise each line is returned as-is.
-
-    "lno" is the (1-indexed) line number for the line.
-
-    "directive" will be a PreprocessorDirective or None, depending on
-    whether or not there is a directive on the line.
-
-    "active conditions" is the set of preprocessor conditions (e.g.
-    "defined()") under which the current line of code will be included
-    in compilation.  That set is derived from every conditional
-    directive block (e.g. "if defined()", "ifdef", "else") containing
-    that line.  That includes nested directives.  Note that the
-    current line does not affect the active conditions for iteself.
-    It only impacts subsequent lines.  That applies to directives
-    that close blocks (e.g. "endif") just as much as conditional
-    directvies.  Also note that "else" and "elseif" directives
-    update the active conditions (for later lines), rather than
-    adding to them.
-    """
-    ifstack = []
-    conditions = ()
-    for lno, line in _iter_clean_lines(lines):
-        stripped = line.strip()
-        if not stripped.startswith('#'):
-            yield lno, line, None, conditions
-            continue
-
-        directive = '#' + stripped[1:].lstrip()
-        while '  ' in directive:
-            directive = directive.replace('  ', ' ')
-        directive = _parse_directive(directive)
-        yield lno, line, directive, conditions
-
-        if directive.kind in ('else', 'endif'):
-            conditions = _recompute_conditions(directive, ifstack)
-        elif isinstance(directive, IfDirective):
-            conditions = _recompute_conditions(directive, ifstack)
-
-
-#############################
-# running (platform-specific?)
-
-def _gcc(filename, *,
-         _get_argv=(lambda: _get_gcc_argv()),
-         _run=util.run_cmd,
-         ):
-    argv = _get_argv()
-    argv.extend([
-            '-E', filename,
-            ])
-    output = _run(argv)
-    return output
-
-
-def _get_gcc_argv(*,
-                  _open=open,
-                  _run=util.run_cmd,
-                  ):
-    with _open('/tmp/print.mk', 'w') as tmpfile:
-        tmpfile.write('print-%:\n')
-        #tmpfile.write('\t@echo $* = $($*)\n')
-        tmpfile.write('\t@echo $($*)\n')
-    argv = ['/usr/bin/make',
-            '-f', 'Makefile',
-            '-f', '/tmp/print.mk',
-            'print-CC',
-            'print-PY_CORE_CFLAGS',
-            ]
-    output = _run(argv)
-    gcc, cflags = output.strip().splitlines()
-    argv = shlex.split(gcc.strip())
-    cflags = shlex.split(cflags.strip())
-    return argv + cflags
-
-
-def run(filename, *,
-        _gcc=_gcc,
-        ):
-    """Return the text of the given file after running the preprocessor."""
-    return _gcc(filename)
diff --git a/Tools/c-analyzer/c_analyzer/parser/source.py b/Tools/c-analyzer/c_analyzer/parser/source.py
deleted file mode 100644
index f8998c8a338..00000000000
--- a/Tools/c-analyzer/c_analyzer/parser/source.py
+++ /dev/null
@@ -1,34 +0,0 @@
-from . import preprocessor
-
-
-def iter_clean_lines(lines):
-    incomment = False
-    for line in lines:
-        # Deal with comments.
-        if incomment:
-            _, sep, line = line.partition('*/')
-            if sep:
-                incomment = False
-            continue
-        line, _, _ = line.partition('//')
-        line, sep, remainder = line.partition('/*')
-        if sep:
-            _, sep, after = remainder.partition('*/')
-            if not sep:
-                incomment = True
-                continue
-            line += ' ' + after
-
-        # Ignore blank lines and leading/trailing whitespace.
-        line = line.strip()
-        if not line:
-            continue
-
-        yield line
-
-
-def iter_lines(filename, *,
-               preprocess=preprocessor.run,
-               ):
-    content = preprocess(filename)
-    return iter(content.splitlines())
diff --git a/Tools/c-analyzer/c_analyzer/symbols/__init__.py b/Tools/c-analyzer/c_analyzer/symbols/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
--- a/Tools/c-analyzer/c_analyzer/symbols/__init__.py
+++ /dev/null
diff --git a/Tools/c-analyzer/c_analyzer/symbols/_nm.py b/Tools/c-analyzer/c_analyzer/symbols/_nm.py
deleted file mode 100644
index f3a75a6d4ba..00000000000
--- a/Tools/c-analyzer/c_analyzer/symbols/_nm.py
+++ /dev/null
@@ -1,117 +0,0 @@
-import os.path
-import shutil
-
-from c_analyzer.common import util, info
-
-from .info import Symbol
-
-
-# XXX need tests:
-# * iter_symbols
-
-NM_KINDS = {
-        'b': Symbol.KIND.VARIABLE,  # uninitialized
-        'd': Symbol.KIND.VARIABLE,  # initialized
-        #'g': Symbol.KIND.VARIABLE,  # uninitialized
-        #'s': Symbol.KIND.VARIABLE,  # initialized
-        't': Symbol.KIND.FUNCTION,
-        }
-
-SPECIAL_SYMBOLS = {
-        # binary format (e.g. ELF)
-        '__bss_start',
-        '__data_start',
-        '__dso_handle',
-        '_DYNAMIC',
-        '_edata',
-        '_end',
-        '__environ@@GLIBC_2.2.5',
-        '_GLOBAL_OFFSET_TABLE_',
-        '__JCR_END__',
-        '__JCR_LIST__',
-        '__TMC_END__',
-        }
-
-
-def _is_special_symbol(name):
-    if name in SPECIAL_SYMBOLS:
-        return True
-    if '@@GLIBC' in name:
-        return True
-    return False
-
-
-def iter_symbols(binfile, *,
-                 nm=None,
-                 handle_id=None,
-                 _which=shutil.which,
-                 _run=util.run_cmd,
-                 ):
-    """Yield a Symbol for each relevant entry reported by the "nm" command."""
-    if nm is None:
-        nm = _which('nm')
-        if not nm:
-            raise NotImplementedError
-    if handle_id is None:
-        handle_id = info.ID
-
-    argv = [nm,
-            '--line-numbers',
-            binfile,
-            ]
-    try:
-        output = _run(argv)
-    except Exception:
-        if nm is None:
-            # XXX Use dumpbin.exe /SYMBOLS on Windows.
-            raise NotImplementedError
-        raise
-    for line in output.splitlines():
-        (name, kind, external, filename, funcname,
-         ) = _parse_nm_line(line)
-        if kind != Symbol.KIND.VARIABLE:
-            continue
-        elif _is_special_symbol(name):
-            continue
-        yield Symbol(
-                id=handle_id(filename, funcname, name),
-                kind=kind,
-                external=external,
-                )
-
-
-def _parse_nm_line(line):
-    _origline = line
-    _, _, line = line.partition(' ')  # strip off the address
-    line = line.strip()
-
-    kind, _, line = line.partition(' ')
-    line = line.strip()
-    external = kind.isupper()
-    kind = NM_KINDS.get(kind.lower(), Symbol.KIND.OTHER)
-
-    name, _, filename = line.partition('\t')
-    name = name.strip()
-    if filename:
-        filename = os.path.relpath(filename.partition(':')[0])
-    else:
-        filename = info.UNKNOWN
-
-    name, islocal = _parse_nm_name(name, kind)
-    funcname = info.UNKNOWN if islocal else None
-    return name, kind, external, filename, funcname
-
-
-def _parse_nm_name(name, kind):
-    if kind != Symbol.KIND.VARIABLE:
-        return name, None
-    if _is_special_symbol(name):
-        return name, None
-
-    actual, sep, digits = name.partition('.')
-    if not sep:
-        return name, False
-
-    if not digits.isdigit():
-        raise Exception(f'got bogus name {name}')
-    return actual, True
diff --git a/Tools/c-analyzer/c_analyzer/symbols/find.py b/Tools/c-analyzer/c_analyzer/symbols/find.py
deleted file mode 100644
index 85646523f7a..00000000000
--- a/Tools/c-analyzer/c_analyzer/symbols/find.py
+++ /dev/null
@@ -1,175 +0,0 @@
-import os
-import os.path
-import shutil
-
-from ..common import files
-from ..common.info import UNKNOWN, ID
-from ..parser import find as p_find
-
-from . import _nm
-from .info import Symbol
-
-# XXX need tests:
-# * get_resolver()
-# * get_resolver_from_dirs()
-# * symbol()
-# * symbols()
-# * variables()
-
-
-def _resolve_known(symbol, knownvars):
-    for varid in knownvars:
-        if symbol.match(varid):
-            break
-    else:
-        return None
-    return knownvars.pop(varid)
-
-
-def get_resolver(filenames=None, known=None, *,
-                 handle_var,
-                 check_filename=None,
-                 perfilecache=None,
-                 preprocessed=False,
-                 _from_source=p_find.variable_from_id,
-                 ):
-    """Return a "resolver" func for the given known vars/types and filenames.
-
-    "handle_var" is a callable that takes (ID, decl) and returns a
-    Variable.  Variable.from_id is a suitable callable.
-
-    The returned func takes a single Symbol and returns a corresponding
-    Variable.  If the symbol was located then the variable will be
-    valid, populated with the corresponding information.  Otherwise None
-    is returned.
-    """
-    knownvars = (known or {}).get('variables')
-    if knownvars:
-        knownvars = dict(knownvars)  # a copy
-        if filenames:
-            if check_filename is None:
-                filenames = list(filenames)
-                def check_filename(filename):
-                    return filename in filenames
-            def resolve(symbol):
-                # XXX Check "found" instead?
-                if not check_filename(symbol.filename):
-                    return None
-                found = _resolve_known(symbol, knownvars)
-                if found is None:
-                    #return None
-                    varid, decl = _from_source(symbol, filenames,
-                                               perfilecache=perfilecache,
-                                               preprocessed=preprocessed,
-                                               )
-                    found = handle_var(varid, decl)
-                return found
-        else:
-            def resolve(symbol):
-                return _resolve_known(symbol, knownvars)
-    elif filenames:
-        def resolve(symbol):
-            varid, decl = _from_source(symbol, filenames,
-                                       perfilecache=perfilecache,
-                                       preprocessed=preprocessed,
-                                       )
-            return handle_var(varid, decl)
-    else:
-        def resolve(symbol):
-            return None
-    return resolve
-
-
-def get_resolver_from_dirs(dirnames, known=None, *,
-                           handle_var,
-                           suffixes=('.c',),
-                           perfilecache=None,
-                           preprocessed=False,
-                           _iter_files=files.iter_files_by_suffix,
-                           _get_resolver=get_resolver,
-                           ):
-    """Return a "resolver" func for the given known vars/types and filenames.
-
-    "dirnames" should be absolute paths.  If not then they will be
-    resolved relative to CWD.
-
-    See get_resolver().
-    """
-    dirnames = [d if d.endswith(os.path.sep) else d + os.path.sep
-                for d in dirnames]
-    filenames = _iter_files(dirnames, suffixes)
-    def check_filename(filename):
-        for dirname in dirnames:
-            if filename.startswith(dirname):
-                return True
-        else:
-            return False
-    return _get_resolver(filenames, known,
-                         handle_var=handle_var,
-                         check_filename=check_filename,
-                         perfilecache=perfilecache,
-                         preprocessed=preprocessed,
-                         )
-
-
-def symbol(symbol, filenames, known=None, *,
-           perfilecache=None,
-           preprocessed=False,
-           handle_id=None,
-           _get_resolver=get_resolver,
-           ):
-    """Return a Variable for the one matching the given symbol.
-
-    "symbol" can be one of several objects:
-
-    * Symbol - use the contained info
-    * name (str) - look for a global variable with that name
-    * (filename, name) - look for named global in file
-    * (filename, funcname, name) - look for named local in file
-
-    A name is always required.  If the filename is None, "", or
-    "UNKNOWN" then all files will be searched.  If the funcname is
-    "" or "UNKNOWN" then only local variables will be searched for.
-    """
-    resolve = _get_resolver(known, filenames,
-                            handle_id=handle_id,
-                            perfilecache=perfilecache,
-                            preprocessed=preprocessed,
-                            )
-    return resolve(symbol)
-
-
-def _get_platform_tool():
-    if os.name == 'nt':
-        # XXX Support this.
-        raise NotImplementedError
-    elif nm := shutil.which('nm'):
-        return lambda b, hi: _nm.iter_symbols(b, nm=nm, handle_id=hi)
-    else:
-        raise NotImplementedError
-
-
-def symbols(binfile, *,
-            handle_id=None,
-            _file_exists=os.path.exists,
-            _get_platform_tool=_get_platform_tool,
-            ):
-    """Yield a Symbol for each one found in the binary."""
-    if not _file_exists(binfile):
-        raise Exception('executable missing (need to build it first?)')
-
-    _iter_symbols = _get_platform_tool()
-    yield from _iter_symbols(binfile, handle_id)
-
-
-def variables(binfile, *,
-              resolve,
-              handle_id=None,
-              _iter_symbols=symbols,
-              ):
-    """Yield (Variable, Symbol) for each found symbol."""
-    for symbol in _iter_symbols(binfile, handle_id=handle_id):
-        if symbol.kind != Symbol.KIND.VARIABLE:
-            continue
-        var = resolve(symbol) or None
-        yield var, symbol
diff --git a/Tools/c-analyzer/c_analyzer/symbols/info.py b/Tools/c-analyzer/c_analyzer/symbols/info.py
deleted file mode 100644
index 96a251abb7c..00000000000
--- a/Tools/c-analyzer/c_analyzer/symbols/info.py
+++ /dev/null
@@ -1,51 +0,0 @@
-from collections import namedtuple
-
-from c_analyzer.common.info import ID
-from c_analyzer.common.util import classonly, _NTBase
-
-
-class Symbol(_NTBase, namedtuple('Symbol', 'id kind external')):
-    """Info for a single compilation symbol."""
-
-    __slots__ = ()
-
-    class KIND:
-        VARIABLE = 'variable'
-        FUNCTION = 'function'
-        OTHER = 'other'
-
-    @classonly
-    def from_name(cls, name, filename=None, kind=KIND.VARIABLE, external=None):
-        """Return a new symbol based on the given name."""
-        id = ID(filename, None, name)
-        return cls(id, kind, external)
-
-    def __new__(cls, id, kind=KIND.VARIABLE, external=None):
-        self = super().__new__(
-                cls,
-                id=ID.from_raw(id),
-                kind=str(kind) if kind else None,
-                external=bool(external) if external is not None else None,
-                )
-        return self
-
-    def __hash__(self):
-        return hash(self.id)
-
-    def __getattr__(self, name):
-        return getattr(self.id, name)
-
-    def validate(self):
-        """Fail if the object is invalid (i.e. init with bad data)."""
-        if not self.id:
-            raise TypeError('missing id')
-        else:
-            self.id.validate()
-
-        if not self.kind:
-            raise TypeError('missing kind')
-        elif self.kind not in vars(self.KIND).values():
-            raise ValueError(f'unsupported kind {self.kind}')
-
-        if self.external is None:
-            raise TypeError('missing external')
diff --git a/Tools/c-analyzer/c_analyzer/variables/__init__.py b/Tools/c-analyzer/c_analyzer/variables/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
--- a/Tools/c-analyzer/c_analyzer/variables/__init__.py
+++ /dev/null
diff --git a/Tools/c-analyzer/c_analyzer/variables/find.py b/Tools/c-analyzer/c_analyzer/variables/find.py
deleted file mode 100644
index 3fe7284fc00..00000000000
--- a/Tools/c-analyzer/c_analyzer/variables/find.py
+++ /dev/null
@@ -1,75 +0,0 @@
-from ..common import files
-from ..common.info import UNKNOWN
-from ..parser import (
-        find as p_find,
-        )
-from ..symbols import (
-        info as s_info,
-        find as s_find,
-        )
-from .info import Variable
-
-# XXX need tests:
-# * vars_from_source
-
-
-def _remove_cached(cache, var):
-    if not cache:
-        return
-    try:
-        cached = cache[var.filename]
-        cached.remove(var)
-    except (KeyError, IndexError):
-        pass
-
-
-def vars_from_binary(binfile, *,
-                     known=None,
-                     filenames=None,
-                     handle_id=None,
-                     check_filename=None,
-                     handle_var=Variable.from_id,
-                     _iter_vars=s_find.variables,
-                     _get_symbol_resolver=s_find.get_resolver,
-                     ):
-    """Yield a Variable for each found Symbol.
-
-    Details are filled in from the given "known" variables and types.
-    """
-    cache = {}
-    resolve = _get_symbol_resolver(filenames, known,
-                                   handle_var=handle_var,
-                                   check_filename=check_filename,
-                                   perfilecache=cache,
-                                   )
-    for var, symbol in _iter_vars(binfile,
-                                  resolve=resolve,
-                                  handle_id=handle_id,
-                                  ):
-        if var is None:
-            var = Variable(symbol.id, UNKNOWN, UNKNOWN)
-        yield var
-        _remove_cached(cache, var)
-
-
-def vars_from_source(filenames, *,
-                     preprocessed=None,
-                     known=None,
-                     handle_id=None,
-                     handle_var=Variable.from_id,
-                     iter_vars=p_find.variables,
-                     ):
-    """Yield a Variable for each declaration in the raw source code.
-
-    Details are filled in from the given "known" variables and types.
-    """
-    cache = {}
-    for varid, decl in iter_vars(filenames or (),
-                                 perfilecache=cache,
-                                 preprocessed=preprocessed,
-                                 known=known,
-                                 handle_id=handle_id,
-                                 ):
-        var = handle_var(varid, decl)
-        yield var
-        _remove_cached(cache, var)
diff --git a/Tools/c-analyzer/c_analyzer/variables/info.py b/Tools/c-analyzer/c_analyzer/variables/info.py
deleted file mode 100644
index 336a523c7a2..00000000000
--- a/Tools/c-analyzer/c_analyzer/variables/info.py
+++ /dev/null
@@ -1,93 +0,0 @@
-from collections import namedtuple
-
-from ..common.info import ID, UNKNOWN
-from ..common.util import classonly, _NTBase
-
-
-def normalize_vartype(vartype):
-    """Return the canonical form for a variable type (or func signature)."""
-    # We allow empty strring through for semantic reasons.
-    if vartype is None:
-        return None
-
-    # XXX finish!
-    # XXX Return (modifiers, type, pointer)?
-    return str(vartype)
-
-
-# XXX Variable.vartype -> decl (Declaration).
-
-class Variable(_NTBase,
-               namedtuple('Variable', 'id storage vartype')):
-    """Information about a single variable declaration."""
-
-    __slots__ = ()
-
-    STORAGE = (
-            'static',
-            'extern',
-            'implicit',
-            'local',
-            )
-
-    @classonly
-    def from_parts(cls, filename, funcname, name, decl, storage=None):
-        varid = ID(filename, funcname, name)
-        if storage is None:
-            self = cls.from_id(varid, decl)
-        else:
-            self = cls(varid, storage, decl)
-        return self
-
-    @classonly
-    def from_id(cls, varid, decl):
-        from ..parser.declarations import extract_storage
-        storage = extract_storage(decl, infunc=varid.funcname)
-        return cls(varid, storage, decl)
-
-    def __new__(cls, id, storage, vartype):
-        self = super().__new__(
-                cls,
-                id=ID.from_raw(id),
-                storage=str(storage) if storage else None,
-                vartype=normalize_vartype(vartype) if vartype else None,
-                )
-        return self
-
-    def __hash__(self):
-        return hash(self.id)
-
-    def __getattr__(self, name):
-        return getattr(self.id, name)
-
-    def _validate_id(self):
-        if not self.id:
-            raise TypeError('missing id')
-
-        if not self.filename or self.filename == UNKNOWN:
-            raise TypeError(f'id missing filename ({self.id})')
-
-        if self.funcname and self.funcname == UNKNOWN:
-            raise TypeError(f'id missing funcname ({self.id})')
-
-        self.id.validate()
-
-    def validate(self):
-        """Fail if the object is invalid (i.e. init with bad data)."""
-        self._validate_id()
-
-        if self.storage is None or self.storage == UNKNOWN:
-            raise TypeError('missing storage')
-        elif self.storage not in self.STORAGE:
-            raise ValueError(f'unsupported storage {self.storage:r}')
-
-        if self.vartype is None or self.vartype == UNKNOWN:
-            raise TypeError('missing vartype')
-
-    @property
-    def isglobal(self):
-        return self.storage != 'local'
-
-    @property
-    def isconst(self):
-        return 'const' in self.vartype.split()
diff --git a/Tools/c-analyzer/c_analyzer/variables/known.py b/Tools/c-analyzer/c_analyzer/variables/known.py
deleted file mode 100644
index aa2934a069e..00000000000
--- a/Tools/c-analyzer/c_analyzer/variables/known.py
+++ /dev/null
@@ -1,91 +0,0 @@
-import csv
-
-from ..common.info import ID, UNKNOWN
-from ..common.util import read_tsv
-from .info import Variable
-
-
-# XXX need tests:
-# * read_file()
-# * look_up_variable()
-
-
-COLUMNS = ('filename', 'funcname', 'name', 'kind', 'declaration')
-HEADER = '\t'.join(COLUMNS)
-
-
-def read_file(infile, *,
-              _read_tsv=read_tsv,
-              ):
-    """Yield (kind, id, decl) for each row in the data file.
-
-    The caller is responsible for validating each row.
-    """
-    for row in _read_tsv(infile, HEADER):
-        filename, funcname, name, kind, declaration = row
-        if not funcname or funcname == '-':
-            funcname = None
-        id = ID(filename, funcname, name)
-        yield kind, id, declaration
-
-
-def from_file(infile, *,
-              handle_var=Variable.from_id,
-              _read_file=read_file,
-              ):
-    """Return the info for known declarations in the given file."""
-    known = {
-        'variables': {},
-        #'types': {},
-        #'constants': {},
-        #'macros': {},
-        }
-    for kind, id, decl in _read_file(infile):
-        if kind == 'variable':
-            values = known['variables']
-            value = handle_var(id, decl)
-        else:
-            raise ValueError(f'unsupported kind in row {row}')
-        value.validate()
-        values[id] = value
-    return known
-
-
-def look_up_variable(varid, knownvars, *,
-                     match_files=(lambda f1, f2: f1 == f2),
-                     ):
-    """Return the known Variable matching the given ID.
-
-    "knownvars" is a mapping of ID to Variable.
-
-    "match_files" is used to verify if two filenames point to
-    the same file.
-
-    If no match is found then None is returned.
-    """
-    if not knownvars:
-        return None
-
-    if varid.funcname == UNKNOWN:
-        if not varid.filename or varid.filename == UNKNOWN:
-            for varid in knownvars:
-                if not varid.funcname:
-                    continue
-                if varid.name == varid.name:
-                    return knownvars[varid]
-            else:
-                return None
-        else:
-            for varid in knownvars:
-                if not varid.funcname:
-                    continue
-                if not match_files(varid.filename, varid.filename):
-                    continue
-                if varid.name == varid.name:
-                    return knownvars[varid]
-            else:
-                return None
-    elif not varid.filename or varid.filename == UNKNOWN:
-        raise NotImplementedError
-    else:
-        return knownvars.get(varid.id)
diff --git a/Tools/c-analyzer/c_common/__init__.py b/Tools/c-analyzer/c_common/__init__.py
new file mode 100644
index 00000000000..a4c3bb24230
--- /dev/null
+++ b/Tools/c-analyzer/c_common/__init__.py
@@ -0,0 +1,2 @@
+
+NOT_SET = object()
diff --git a/Tools/c-analyzer/c_analyzer/common/util.py b/Tools/c-analyzer/c_common/clsutil.py
index 43d0bb6e665..aa5f6b9831d 100644
--- a/Tools/c-analyzer/c_analyzer/common/util.py
+++ b/Tools/c-analyzer/c_common/clsutil.py
@@ -1,70 +1,7 @@
-import csv
-import subprocess
-
 
 _NOT_SET = object()
 
 
-def run_cmd(argv, **kwargs):
-    proc = subprocess.run(
-            argv,
-            #capture_output=True,
-            #stderr=subprocess.STDOUT,
-            stdout=subprocess.PIPE,
-            text=True,
-            check=True,
-            **kwargs
-            )
-    return proc.stdout
-
-
-def read_tsv(infile, header, *,
-             _open=open,
-             _get_reader=csv.reader,
-             ):
-    """Yield each row of the given TSV (tab-separated) file."""
-    if isinstance(infile, str):
-        with _open(infile, newline='') as infile:
-            yield from read_tsv(infile, header,
-                                _open=_open,
-                                _get_reader=_get_reader,
-                                )
-            return
-    lines = iter(infile)
-
-    # Validate the header.
-    try:
-        actualheader = next(lines).strip()
-    except StopIteration:
-        actualheader = ''
-    if actualheader != header:
-        raise ValueError(f'bad header {actualheader!r}')
-
-    for row in _get_reader(lines, delimiter='\t'):
-        yield tuple(v.strip() for v in row)
-
-
-def write_tsv(outfile, header, rows, *,
-             _open=open,
-             _get_writer=csv.writer,
-             ):
-    """Write each of the rows to the given TSV (tab-separated) file."""
-    if isinstance(outfile, str):
-        with _open(outfile, 'w', newline='') as outfile:
-            return write_tsv(outfile, header, rows,
-                            _open=_open,
-                            _get_writer=_get_writer,
-                            )
-
-    if isinstance(header, str):
-        header = header.split('\t')
-    writer = _get_writer(outfile, delimiter='\t')
-    writer.writerow(header)
-    for row in rows:
-        writer.writerow('' if v is None else str(v)
-                        for v in row)
-
-
 class Slot:
     """A descriptor that provides a slot.
 
@@ -178,66 +115,3 @@ class classonly:
             raise AttributeError(self.name)
         # called on the class
         return self.getter(None, cls)
-
-
-class _NTBase:
-
-    __slots__ = ()
-
-    @classonly
-    def from_raw(cls, raw):
-        if not raw:
-            return None
-        elif isinstance(raw, cls):
-            return raw
-        elif isinstance(raw, str):
-            return cls.from_string(raw)
-        else:
-            if hasattr(raw, 'items'):
-                return cls(**raw)
-            try:
-                args = tuple(raw)
-            except TypeError:
-                pass
-            else:
-                return cls(*args)
-        raise NotImplementedError
-
-    @classonly
-    def from_string(cls, value):
-        """Return a new instance based on the given string."""
-        raise NotImplementedError
-
-    @classmethod
-    def _make(cls, iterable):  # The default _make() is not subclass-friendly.
-        return cls.__new__(cls, *iterable)
-
-    # XXX Always validate?
-    #def __init__(self, *args, **kwargs):
-    #    self.validate()
-
-    # XXX The default __repr__() is not subclass-friendly (where the name changes).
-    #def __repr__(self):
-    #    _, _, sig = super().__repr__().partition('(')
-    #    return f'{self.__class__.__name__}({sig}'
-
-    # To make sorting work with None:
-    def __lt__(self, other):
-        try:
-            return super().__lt__(other)
-        except TypeError:
-            if None in self:
-                return True
-            elif None in other:
-                return False
-            else:
-                raise
-
-    def validate(self):
-        return
-
-    # XXX Always validate?
-    #def _replace(self, **kwargs):
-    #    obj = super()._replace(**kwargs)
-    #    obj.validate()
-    #    return obj
diff --git a/Tools/c-analyzer/c_common/fsutil.py b/Tools/c-analyzer/c_common/fsutil.py
new file mode 100644
index 00000000000..56023f33523
--- /dev/null
+++ b/Tools/c-analyzer/c_common/fsutil.py
@@ -0,0 +1,388 @@
+import fnmatch
+import glob
+import os
+import os.path
+import shutil
+import stat
+
+from .iterutil import iter_many
+
+
+C_SOURCE_SUFFIXES = ('.c', '.h')
+
+
+def create_backup(old, backup=None):
+    if isinstance(old, str):
+        filename = old
+    else:
+        filename = getattr(old, 'name', None)
+    if not filename:
+        return None
+    if not backup or backup is True:
+        backup = f'{filename}.bak'
+    try:
+        shutil.copyfile(filename, backup)
+    except FileNotFoundError as exc:
+        if exc.filename != filename:
+            raise   # re-raise
+        backup = None
+    return backup
+
+
+##################################
+# find files
+
+def match_glob(filename, pattern):
+    if fnmatch.fnmatch(filename, pattern):
+        return True
+
+    # fnmatch doesn't handle ** quite right.  It will not match the
+    # following:
+    #
+    #  ('x/spam.py', 'x/**/*.py')
+    #  ('spam.py', '**/*.py')
+    #
+    # though it *will* match the following:
+    #
+    #  ('x/y/spam.py', 'x/**/*.py')
+    #  ('x/spam.py', '**/*.py')
+
+    if '**/' not in pattern:
+        return False
+
+    # We only accommodate the single-"**" case.
+    return fnmatch.fnmatch(filename, pattern.replace('**/', '', 1))
+
+
+def iter_filenames(filenames, *,
+                   start=None,
+                   include=None,
+                   exclude=None,
+                   ):
+    onempty = Exception('no filenames provided')
+    for filename, solo in iter_many(filenames, onempty):
+        check, start = _get_check(filename, start, include, exclude)
+        yield filename, check, solo
+#    filenames = iter(filenames or ())
+#    try:
+#        first = next(filenames)
+#    except StopIteration:
+#        raise Exception('no filenames provided')
+#    try:
+#        second = next(filenames)
+#    except StopIteration:
+#        check, _ = _get_check(first, start, include, exclude)
+#        yield first, check, False
+#        return
+#
+#    check, start = _get_check(first, start, include, exclude)
+#    yield first, check, True
+#    check, start = _get_check(second, start, include, exclude)
+#    yield second, check, True
+#    for filename in filenames:
+#        check, start = _get_check(filename, start, include, exclude)
+#        yield filename, check, True
+
+
+def expand_filenames(filenames):
+    for filename in filenames:
+        # XXX Do we need to use glob.escape (a la commit 9355868458, GH-20994)?
+        if '**/' in filename:
+            yield from glob.glob(filename.replace('**/', ''))
+        yield from glob.glob(filename)
+
+
+def _get_check(filename, start, include, exclude):
+    if start and filename != start:
+        return (lambda: '<skipped>'), start
+    else:
+        def check():
+            if _is_excluded(filename, exclude, include):
+                return '<excluded>'
+            return None
+        return check, None
+
+
+def _is_excluded(filename, exclude, include):
+    if include:
+        for included in include:
+            if match_glob(filename, included):
+                return False
+        return True
+    elif exclude:
+        for excluded in exclude:
+            if match_glob(filename, excluded):
+                return True
+        return False
+    else:
+        return False
+
+
+def _walk_tree(root, *,
+               _walk=os.walk,
+               ):
+    # A wrapper around os.walk that resolves the filenames.
+    for parent, _, names in _walk(root):
+        for name in names:
+            yield os.path.join(parent, name)
+
+
+def walk_tree(root, *,
+              suffix=None,
+              walk=_walk_tree,
+              ):
+    """Yield each file in the tree under the given directory name.
+
+    If "suffix" is provided then only files with that suffix will
+    be included.
+    """
+    if suffix and not isinstance(suffix, str):
+        raise ValueError('suffix must be a string')
+
+    for filename in walk(root):
+        if suffix and not filename.endswith(suffix):
+            continue
+        yield filename
+
+
+def glob_tree(root, *,
+              suffix=None,
+              _glob=glob.iglob,
+              ):
+    """Yield each file in the tree under the given directory name.
+
+    If "suffix" is provided then only files with that suffix will
+    be included.
+    """
+    suffix = suffix or ''
+    if not isinstance(suffix, str):
+        raise ValueError('suffix must be a string')
+
+    for filename in _glob(f'{root}/*{suffix}'):
+        yield filename
+    for filename in _glob(f'{root}/**/*{suffix}'):
+        yield filename
+
+
+def iter_files(root, suffix=None, relparent=None, *,
+               get_files=os.walk,
+               _glob=glob_tree,
+               _walk=walk_tree,
+               ):
+    """Yield each file in the tree under the given directory name.
+
+    If "root" is a non-string iterable then do the same for each of
+    those trees.
+
+    If "suffix" is provided then only files with that suffix will
+    be included.
+
+    if "relparent" is provided then it is used to resolve each
+    filename as a relative path.
+    """
+    if not isinstance(root, str):
+        roots = root
+        for root in roots:
+            yield from iter_files(root, suffix, relparent,
+                                  get_files=get_files,
+                                  _glob=_glob, _walk=_walk)
+        return
+
+    # Use the right "walk" function.
+    if get_files in (glob.glob, glob.iglob, glob_tree):
+        get_files = _glob
+    else:
+        _files = _walk_tree if get_files in (os.walk, walk_tree) else get_files
+        get_files = (lambda *a, **k: _walk(*a, walk=_files, **k))
+
+    # Handle a single suffix.
+    if suffix and not isinstance(suffix, str):
+        filenames = get_files(root)
+        suffix = tuple(suffix)
+    else:
+        filenames = get_files(root, suffix=suffix)
+        suffix = None
+
+    for filename in filenames:
+        if suffix and not isinstance(suffix, str):  # multiple suffixes
+            if not filename.endswith(suffix):
+                continue
+        if relparent:
+            filename = os.path.relpath(filename, relparent)
+        yield filename
+
+
+def iter_files_by_suffix(root, suffixes, relparent=None, *,
+                         walk=walk_tree,
+                         _iter_files=iter_files,
+                         ):
+    """Yield each file in the tree that has the given suffixes.
+
+    Unlike iter_files(), the results are in the original suffix order.
+    """
+    if isinstance(suffixes, str):
+        suffixes = [suffixes]
+    # XXX Ignore repeated suffixes?
+    for suffix in suffixes:
+        yield from _iter_files(root, suffix, relparent)
+
+
+##################################
+# file info
+
+# XXX posix-only?
+
+S_IRANY = stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH
+S_IWANY = stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH
+S_IXANY = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+
+
+def is_readable(file, *, user=None, check=False):
+    filename, st, mode = _get_file_info(file)
+    if check:
+        try:
+            okay = _check_file(filename, S_IRANY)
+        except NotImplementedError:
+            okay = NotImplemented
+        if okay is not NotImplemented:
+            return okay
+        # Fall back to checking the mode.
+    return _check_mode(st, mode, S_IRANY, user)
+
+
+def is_writable(file, *, user=None, check=False):
+    filename, st, mode = _get_file_info(file)
+    if check:
+        try:
+            okay = _check_file(filename, S_IWANY)
+        except NotImplementedError:
+            okay = NotImplemented
+        if okay is not NotImplemented:
+            return okay
+        # Fall back to checking the mode.
+    return _check_mode(st, mode, S_IWANY, user)
+
+
+def is_executable(file, *, user=None, check=False):
+    filename, st, mode = _get_file_info(file)
+    if check:
+        try:
+            okay = _check_file(filename, S_IXANY)
+        except NotImplementedError:
+            okay = NotImplemented
+        if okay is not NotImplemented:
+            return okay
+        # Fall back to checking the mode.
+    return _check_mode(st, mode, S_IXANY, user)
+
+
+def _get_file_info(file):
+    filename = st = mode = None
+    if isinstance(file, int):
+        mode = file
+    elif isinstance(file, os.stat_result):
+        st = file
+    else:
+        if isinstance(file, str):
+            filename = file
+        elif hasattr(file, 'name') and os.path.exists(file.name):
+            filename = file.name
+        else:
+            raise NotImplementedError(file)
+        st = os.stat(filename)
+    return filename, st, mode or st.st_mode
+
+
+def _check_file(filename, check):
+    if not isinstance(filename, str):
+        raise Exception(f'filename required to check file, got {filename}')
+    if check & S_IRANY:
+        flags = os.O_RDONLY
+    elif check & S_IWANY:
+        flags = os.O_WRONLY
+    elif check & S_IXANY:
+        # We can worry about S_IXANY later
+        return NotImplemented
+    else:
+        raise NotImplementedError(check)
+
+    try:
+        fd = os.open(filename, flags)
+    except PermissionError:
+        return False
+    # We do not ignore other exceptions.
+    else:
+        os.close(fd)
+        return True
+
+
+def _get_user_info(user):
+    import pwd
+    username = uid = gid = groups = None
+    if user is None:
+        uid = os.geteuid()
+        #username = os.getlogin()
+        username = pwd.getpwuid(uid)[0]
+        gid = os.getgid()
+        groups = os.getgroups()
+    else:
+        if isinstance(user, int):
+            uid = user
+            entry = pwd.getpwuid(uid)
+            username = entry.pw_name
+        elif isinstance(user, str):
+            username = user
+            entry = pwd.getpwnam(username)
+            uid = entry.pw_uid
+        else:
+            raise NotImplementedError(user)
+        gid = entry.pw_gid
+        os.getgrouplist(username, gid)
+    return username, uid, gid, groups
+
+
+def _check_mode(st, mode, check, user):
+    orig = check
+    _, uid, gid, groups = _get_user_info(user)
+    if check & S_IRANY:
+        check -= S_IRANY
+        matched = False
+        if mode & stat.S_IRUSR:
+            if st.st_uid == uid:
+                matched = True
+        if mode & stat.S_IRGRP:
+            if st.st_uid == gid or st.st_uid in groups:
+                matched = True
+        if mode & stat.S_IROTH:
+            matched = True
+        if not matched:
+            return False
+    if check & S_IWANY:
+        check -= S_IWANY
+        matched = False
+        if mode & stat.S_IWUSR:
+            if st.st_uid == uid:
+                matched = True
+        if mode & stat.S_IWGRP:
+            if st.st_uid == gid or st.st_uid in groups:
+                matched = True
+        if mode & stat.S_IWOTH:
+            matched = True
+        if not matched:
+            return False
+    if check & S_IXANY:
+        check -= S_IXANY
+        matched = False
+        if mode & stat.S_IXUSR:
+            if st.st_uid == uid:
+                matched = True
+        if mode & stat.S_IXGRP:
+            if st.st_uid == gid or st.st_uid in groups:
+                matched = True
+        if mode & stat.S_IXOTH:
+            matched = True
+        if not matched:
+            return False
+    if check:
+        raise NotImplementedError((orig, check))
+    return True
diff --git a/Tools/c-analyzer/c_analyzer/common/__init__.py b/Tools/c-analyzer/c_common/info.py
index e69de29bb2d..e69de29bb2d 100644
--- a/Tools/c-analyzer/c_analyzer/common/__init__.py
+++ b/Tools/c-analyzer/c_common/info.py
diff --git a/Tools/c-analyzer/c_common/iterutil.py b/Tools/c-analyzer/c_common/iterutil.py
new file mode 100644
index 00000000000..6ded105304e
--- /dev/null
+++ b/Tools/c-analyzer/c_common/iterutil.py
@@ -0,0 +1,48 @@
+
+_NOT_SET = object()
+
+
+def peek_and_iter(items):
+    if not items:
+        return None, None
+    items = iter(items)
+    try:
+        peeked = next(items)
+    except StopIteration:
+        return None, None
+    def chain():
+        yield peeked
+        yield from items
+    return chain(), peeked
+
+
+def iter_many(items, onempty=None):
+    if not items:
+        if onempty is None:
+            return
+        if not callable(onempty):
+            raise onEmpty
+        items = onempty(items)
+        yield from iter_many(items, onempty=None)
+        return
+    items = iter(items)
+    try:
+        first = next(items)
+    except StopIteration:
+        if onempty is None:
+            return
+        if not callable(onempty):
+            raise onEmpty
+        items = onempty(items)
+        yield from iter_many(items, onempty=None)
+    else:
+        try:
+            second = next(items)
+        except StopIteration:
+            yield first, False
+            return
+        else:
+            yield first, True
+            yield second, True
+        for item in items:
+            yield item, True
diff --git a/Tools/c-analyzer/c_common/logging.py b/Tools/c-analyzer/c_common/logging.py
new file mode 100644
index 00000000000..12398f7e385
--- /dev/null
+++ b/Tools/c-analyzer/c_common/logging.py
@@ -0,0 +1,63 @@
+import logging
+import sys
+
+
+VERBOSITY = 3
+
+
+# The root logger for the whole top-level package:
+_logger = logging.getLogger(__name__.rpartition('.')[0])
+
+
+def configure_logger(logger, verbosity=VERBOSITY, *,
+                     logfile=None,
+                     maxlevel=logging.CRITICAL,
+                     ):
+    level = max(1,  # 0 disables it, so we use the next lowest.
+                min(maxlevel,
+                    maxlevel - verbosity * 10))
+    logger.setLevel(level)
+    #logger.propagate = False
+
+    if not logger.handlers:
+        if logfile:
+            handler = logging.FileHandler(logfile)
+        else:
+            handler = logging.StreamHandler(sys.stdout)
+        handler.setLevel(level)
+        #handler.setFormatter(logging.Formatter())
+        logger.addHandler(handler)
+
+    # In case the provided logger is in a sub-package...
+    if logger is not _logger:
+        configure_logger(
+            _logger,
+            verbosity,
+            logfile=logfile,
+            maxlevel=maxlevel,
+        )
+
+
+def hide_emit_errors():
+    """Ignore errors while emitting log entries.
+
+    Rather than printing a message desribing the error, we show nothing.
+    """
+    # For now we simply ignore all exceptions.  If we wanted to ignore
+    # specific ones (e.g. BrokenPipeError) then we would need to use
+    # a Handler subclass with a custom handleError() method.
+    orig = logging.raiseExceptions
+    logging.raiseExceptions = False
+    def restore():
+        logging.raiseExceptions = orig
+    return restore
+
+
+class Printer:
+    def __init__(self, verbosity=VERBOSITY):
+        self.verbosity = verbosity
+
+    def info(self, *args, **kwargs):
+        if self.verbosity < 3:
+            return
+        print(*args, **kwargs)
diff --git a/Tools/c-analyzer/c_common/misc.py b/Tools/c-analyzer/c_common/misc.py
new file mode 100644
index 00000000000..bfd503ab24a
--- /dev/null
+++ b/Tools/c-analyzer/c_common/misc.py
@@ -0,0 +1,7 @@
+
+class Labeled:
+    __slots__ = ('_label',)
+    def __init__(self, label):
+        self._label = label
+    def __repr__(self):
+        return f'<{self._label}>'
diff --git a/Tools/c-analyzer/c_common/scriptutil.py b/Tools/c-analyzer/c_common/scriptutil.py
new file mode 100644
index 00000000000..939a85003b2
--- /dev/null
+++ b/Tools/c-analyzer/c_common/scriptutil.py
@@ -0,0 +1,577 @@
+import argparse
+import contextlib
+import fnmatch
+import logging
+import os
+import os.path
+import shutil
+import sys
+
+from . import fsutil, strutil, iterutil, logging as loggingutil
+
+
+def get_prog(spec=None, *, absolute=False, allowsuffix=True):
+    if spec is None:
+        _, spec = _find_script()
+        # This is more natural for prog than __file__ would be.
+        filename = sys.argv[0]
+    elif isinstance(spec, str):
+        filename = os.path.normpath(spec)
+        spec = None
+    else:
+        filename = spec.origin
+    if _is_standalone(filename):
+        # Check if "installed".
+        if allowsuffix or not filename.endswith('.py'):
+            basename = os.path.basename(filename)
+            found = shutil.which(basename)
+            if found:
+                script = os.path.abspath(filename)
+                found = os.path.abspath(found)
+                if os.path.normcase(script) == os.path.normcase(found):
+                    return basename
+        # It is only "standalone".
+        if absolute:
+            filename = os.path.abspath(filename)
+        return filename
+    elif spec is not None:
+        module = spec.name
+        if module.endswith('.__main__'):
+            module = module[:-9]
+        return f'{sys.executable} -m {module}'
+    else:
+        if absolute:
+            filename = os.path.abspath(filename)
+        return f'{sys.executable} {filename}'
+
+
+def _find_script():
+    frame = sys._getframe(2)
+    while frame.f_globals['__name__'] != '__main__':
+        frame = frame.f_back
+
+    # This should match sys.argv[0].
+    filename = frame.f_globals['__file__']
+    # This will be None if -m wasn't used..
+    spec = frame.f_globals['__spec__']
+    return filename, spec
+
+
+def is_installed(filename, *, allowsuffix=True):
+    if not allowsuffix and filename.endswith('.py'):
+        return False
+    filename = os.path.abspath(os.path.normalize(filename))
+    found = shutil.which(os.path.basename(filename))
+    if not found:
+        return False
+    if found != filename:
+        return False
+    return _is_standalone(filename)
+
+
+def is_standalone(filename):
+    filename = os.path.abspath(os.path.normalize(filename))
+    return _is_standalone(filename)
+
+
+def _is_standalone(filename):
+    return fsutil.is_executable(filename)
+
+
+##################################
+# logging
+
+VERBOSITY = 3
+
+TRACEBACK = os.environ.get('SHOW_TRACEBACK', '').strip()
+TRACEBACK = bool(TRACEBACK and TRACEBACK.upper() not in ('0', 'FALSE', 'NO'))
+
+
+logger = logging.getLogger(__name__)
+
+
+def configure_logger(verbosity, logger=None, **kwargs):
+    if logger is None:
+        # Configure the root logger.
+        logger = logging.getLogger()
+    loggingutil.configure_logger(logger, verbosity, **kwargs)
+
+
+##################################
+# selections
+
+class UnsupportedSelectionError(Exception):
+    def __init__(self, values, possible):
+        self.values = tuple(values)
+        self.possible = tuple(possible)
+        super().__init__(f'unsupported selections {self.unique}')
+
+    @property
+    def unique(self):
+        return tuple(sorted(set(self.values)))
+
+
+def normalize_selection(selected: str, *, possible=None):
+    if selected in (None, True, False):
+        return selected
+    elif isinstance(selected, str):
+        selected = [selected]
+    elif not selected:
+        return ()
+
+    unsupported = []
+    _selected = set()
+    for item in selected:
+        if not item:
+            continue
+        for value in item.strip().replace(',', ' ').split():
+            if not value:
+                continue
+            # XXX Handle subtraction (leading "-").
+            if possible and value not in possible and value != 'all':
+                unsupported.append(value)
+            _selected.add(value)
+    if unsupported:
+        raise UnsupportedSelectionError(unsupported, tuple(possible))
+    if 'all' in _selected:
+        return True
+    return frozenset(selected)
+
+
+##################################
+# CLI parsing helpers
+
+class CLIArgSpec(tuple):
+    def __new__(cls, *args, **kwargs):
+        return super().__new__(cls, (args, kwargs))
+
+    def __repr__(self):
+        args, kwargs = self
+        args = [repr(arg) for arg in args]
+        for name, value in kwargs.items():
+            args.append(f'{name}={value!r}')
+        return f'{type(self).__name__}({", ".join(args)})'
+
+    def __call__(self, parser, *, _noop=(lambda a: None)):
+        self.apply(parser)
+        return _noop
+
+    def apply(self, parser):
+        args, kwargs = self
+        parser.add_argument(*args, **kwargs)
+
+
+def apply_cli_argspecs(parser, specs):
+    processors = []
+    for spec in specs:
+        if callable(spec):
+            procs = spec(parser)
+            _add_procs(processors, procs)
+        else:
+            args, kwargs = spec
+            parser.add_argument(args, kwargs)
+    return processors
+
+
+def _add_procs(flattened, procs):
+    # XXX Fail on non-empty, non-callable procs?
+    if not procs:
+        return
+    if callable(procs):
+        flattened.append(procs)
+    else:
+        #processors.extend(p for p in procs if callable(p))
+        for proc in procs:
+            _add_procs(flattened, proc)
+
+
+def add_verbosity_cli(parser):
+    parser.add_argument('-q', '--quiet', action='count', default=0)
+    parser.add_argument('-v', '--verbose', action='count', default=0)
+
+    def process_args(args):
+        ns = vars(args)
+        key = 'verbosity'
+        if key in ns:
+            parser.error(f'duplicate arg {key!r}')
+        ns[key] = max(0, VERBOSITY + ns.pop('verbose') - ns.pop('quiet'))
+        return key
+    return process_args
+
+
+def add_traceback_cli(parser):
+    parser.add_argument('--traceback', '--tb', action='store_true',
+                        default=TRACEBACK)
+    parser.add_argument('--no-traceback', '--no-tb', dest='traceback',
+                        action='store_const', const=False)
+
+    def process_args(args):
+        ns = vars(args)
+        key = 'traceback_cm'
+        if key in ns:
+            parser.error(f'duplicate arg {key!r}')
+        showtb = ns.pop('traceback')
+
+        @contextlib.contextmanager
+        def traceback_cm():
+            restore = loggingutil.hide_emit_errors()
+            try:
+                yield
+            except BrokenPipeError:
+                # It was piped to "head" or something similar.
+                pass
+            except NotImplementedError:
+                raise  # re-raise
+            except Exception as exc:
+                if not showtb:
+                    sys.exit(f'ERROR: {exc}')
+                raise  # re-raise
+            except KeyboardInterrupt:
+                if not showtb:
+                    sys.exit('\nINTERRUPTED')
+                raise  # re-raise
+            except BaseException as exc:
+                if not showtb:
+                    sys.exit(f'{type(exc).__name__}: {exc}')
+                raise  # re-raise
+            finally:
+                restore()
+        ns[key] = traceback_cm()
+        return key
+    return process_args
+
+
+def add_sepval_cli(parser, opt, dest, choices, *, sep=',', **kwargs):
+#    if opt is True:
+#        parser.add_argument(f'--{dest}', action='append', **kwargs)
+#    elif isinstance(opt, str) and opt.startswith('-'):
+#        parser.add_argument(opt, dest=dest, action='append', **kwargs)
+#    else:
+#        arg = dest if not opt else opt
+#        kwargs.setdefault('nargs', '+')
+#        parser.add_argument(arg, dest=dest, action='append', **kwargs)
+    if not isinstance(opt, str):
+        parser.error(f'opt must be a string, got {opt!r}')
+    elif opt.startswith('-'):
+        parser.add_argument(opt, dest=dest, action='append', **kwargs)
+    else:
+        kwargs.setdefault('nargs', '+')
+        #kwargs.setdefault('metavar', opt.upper())
+        parser.add_argument(opt, dest=dest, action='append', **kwargs)
+
+    def process_args(args):
+        ns = vars(args)
+
+        # XXX Use normalize_selection()?
+        if isinstance(ns[dest], str):
+            ns[dest] = [ns[dest]]
+        selections = []
+        for many in ns[dest] or ():
+            for value in many.split(sep):
+                if value not in choices:
+                    parser.error(f'unknown {dest} {value!r}')
+                selections.append(value)
+        ns[dest] = selections
+    return process_args
+
+
+def add_files_cli(parser, *, excluded=None, nargs=None):
+    process_files = add_file_filtering_cli(parser, excluded=excluded)
+    parser.add_argument('filenames', nargs=nargs or '+', metavar='FILENAME')
+    return [
+        process_files,
+    ]
+
+
+def add_file_filtering_cli(parser, *, excluded=None):
+    parser.add_argument('--start')
+    parser.add_argument('--include', action='append')
+    parser.add_argument('--exclude', action='append')
+
+    excluded = tuple(excluded or ())
+
+    def process_args(args):
+        ns = vars(args)
+        key = 'iter_filenames'
+        if key in ns:
+            parser.error(f'duplicate arg {key!r}')
+
+        _include = tuple(ns.pop('include') or ())
+        _exclude = excluded + tuple(ns.pop('exclude') or ())
+        kwargs = dict(
+            start=ns.pop('start'),
+            include=tuple(_parse_files(_include)),
+            exclude=tuple(_parse_files(_exclude)),
+            # We use the default for "show_header"
+        )
+        ns[key] = (lambda files: fsutil.iter_filenames(files, **kwargs))
+    return process_args
+
+
+def _parse_files(filenames):
+    for filename, _ in strutil.parse_entries(filenames):
+        yield filename.strip()
+
+
+def add_failure_filtering_cli(parser, pool, *, default=False):
+    parser.add_argument('--fail', action='append',
+                        metavar=f'"{{all|{"|".join(sorted(pool))}}},..."')
+    parser.add_argument('--no-fail', dest='fail', action='store_const', const=())
+
+    def process_args(args):
+        ns = vars(args)
+
+        fail = ns.pop('fail')
+        try:
+            fail = normalize_selection(fail, possible=pool)
+        except UnsupportedSelectionError as exc:
+            parser.error(f'invalid --fail values: {", ".join(exc.unique)}')
+        else:
+            if fail is None:
+                fail = default
+
+            if fail is True:
+                def ignore_exc(_exc):
+                    return False
+            elif fail is False:
+                def ignore_exc(_exc):
+                    return True
+            else:
+                def ignore_exc(exc):
+                    for err in fail:
+                        if type(exc) == pool[err]:
+                            return False
+                    else:
+                        return True
+            args.ignore_exc = ignore_exc
+    return process_args
+
+
+def add_kind_filtering_cli(parser, *, default=None):
+    parser.add_argument('--kinds', action='append')
+
+    def process_args(args):
+        ns = vars(args)
+
+        kinds = []
+        for kind in ns.pop('kinds') or default or ():
+            kinds.extend(kind.strip().replace(',', ' ').split())
+
+        if not kinds:
+            match_kind = (lambda k: True)
+        else:
+            included = set()
+            excluded = set()
+            for kind in kinds:
+                if kind.startswith('-'):
+                    kind = kind[1:]
+                    excluded.add(kind)
+                    if kind in included:
+                        included.remove(kind)
+                else:
+                    included.add(kind)
+                    if kind in excluded:
+                        excluded.remove(kind)
+            if excluded:
+                if included:
+                    ...  # XXX fail?
+                def match_kind(kind, *, _excluded=excluded):
+                    return kind not in _excluded
+            else:
+                def match_kind(kind, *, _included=included):
+                    return kind in _included
+        args.match_kind = match_kind
+    return process_args
+
+
+COMMON_CLI = [
+    add_verbosity_cli,
+    add_traceback_cli,
+    #add_dryrun_cli,
+]
+
+
+def add_commands_cli(parser, commands, *, commonspecs=COMMON_CLI, subset=None):
+    arg_processors = {}
+    if isinstance(subset, str):
+        cmdname = subset
+        try:
+            _, argspecs, _ = commands[cmdname]
+        except KeyError:
+            raise ValueError(f'unsupported subset {subset!r}')
+        parser.set_defaults(cmd=cmdname)
+        arg_processors[cmdname] = _add_cmd_cli(parser, commonspecs, argspecs)
+    else:
+        if subset is None:
+            cmdnames = subset = list(commands)
+        elif not subset:
+            raise NotImplementedError
+        elif isinstance(subset, set):
+            cmdnames = [k for k in commands if k in subset]
+            subset = sorted(subset)
+        else:
+            cmdnames = [n for n in subset if n in commands]
+        if len(cmdnames) < len(subset):
+            bad = tuple(n for n in subset if n not in commands)
+            raise ValueError(f'unsupported subset {bad}')
+
+        common = argparse.ArgumentParser(add_help=False)
+        common_processors = apply_cli_argspecs(common, commonspecs)
+        subs = parser.add_subparsers(dest='cmd')
+        for cmdname in cmdnames:
+            description, argspecs, _ = commands[cmdname]
+            sub = subs.add_parser(
+                cmdname,
+                description=description,
+                parents=[common],
+            )
+            cmd_processors = _add_cmd_cli(sub, (), argspecs)
+            arg_processors[cmdname] = common_processors + cmd_processors
+    return arg_processors
+
+
+def _add_cmd_cli(parser, commonspecs, argspecs):
+    processors = []
+    argspecs = list(commonspecs or ()) + list(argspecs or ())
+    for argspec in argspecs:
+        if callable(argspec):
+            procs = argspec(parser)
+            _add_procs(processors, procs)
+        else:
+            if not argspec:
+                raise NotImplementedError
+            args = list(argspec)
+            if not isinstance(args[-1], str):
+                kwargs = args.pop()
+                if not isinstance(args[0], str):
+                    try:
+                        args, = args
+                    except (TypeError, ValueError):
+                        parser.error(f'invalid cmd args {argspec!r}')
+            else:
+                kwargs = {}
+            parser.add_argument(*args, **kwargs)
+            # There will be nothing to process.
+    return processors
+
+
+def _flatten_processors(processors):
+    for proc in processors:
+        if proc is None:
+            continue
+        if callable(proc):
+            yield proc
+        else:
+            yield from _flatten_processors(proc)
+
+
+def process_args(args, processors, *, keys=None):
+    processors = _flatten_processors(processors)
+    ns = vars(args)
+    extracted = {}
+    if keys is None:
+        for process_args in processors:
+            for key in process_args(args):
+                extracted[key] = ns.pop(key)
+    else:
+        remainder = set(keys)
+        for process_args in processors:
+            hanging = process_args(args)
+            if isinstance(hanging, str):
+                hanging = [hanging]
+            for key in hanging or ():
+                if key not in remainder:
+                    raise NotImplementedError(key)
+                extracted[key] = ns.pop(key)
+                remainder.remove(key)
+        if remainder:
+            raise NotImplementedError(sorted(remainder))
+    return extracted
+
+
+def process_args_by_key(args, processors, keys):
+    extracted = process_args(args, processors, keys=keys)
+    return [extracted[key] for key in keys]
+
+
+##################################
+# commands
+
+def set_command(name, add_cli):
+    """A decorator factory to set CLI info."""
+    def decorator(func):
+        if hasattr(func, '__cli__'):
+            raise Exception(f'already set')
+        func.__cli__ = (name, add_cli)
+        return func
+    return decorator
+
+
+##################################
+# main() helpers
+
+def filter_filenames(filenames, iter_filenames=None):
+    for filename, check, _ in _iter_filenames(filenames, iter_filenames):
+        if (reason := check()):
+            logger.debug(f'{filename}: {reason}')
+            continue
+        yield filename
+
+
+def main_for_filenames(filenames, iter_filenames=None):
+    for filename, check, show in _iter_filenames(filenames, iter_filenames):
+        if show:
+            print()
+            print('-------------------------------------------')
+            print(filename)
+        if (reason := check()):
+            print(reason)
+            continue
+        yield filename
+
+
+def _iter_filenames(filenames, iter_files):
+    if iter_files is None:
+        iter_files = fsutil.iter_filenames
+        yield from iter_files(filenames)
+        return
+
+    onempty = Exception('no filenames provided')
+    items = iter_files(filenames)
+    items, peeked = iterutil.peek_and_iter(items)
+    if not items:
+        raise onempty
+    if isinstance(peeked, str):
+        check = (lambda: True)
+        for filename, ismany in iterutil.iter_many(items, onempty):
+            yield filename, check, ismany
+    elif len(peeked) == 3:
+        yield from items
+    else:
+        raise NotImplementedError
+
+
+def iter_marks(mark='.', *, group=5, groups=2, lines=10, sep=' '):
+    mark = mark or ''
+    sep = f'{mark}{sep}' if sep else mark
+    end = f'{mark}{os.linesep}'
+    div = os.linesep
+    perline = group * groups
+    perlines = perline * lines
+
+    if perline == 1:
+        yield end
+    elif group == 1:
+        yield sep
+
+    count = 1
+    while True:
+        if count % perline == 0:
+            yield end
+            if count % perlines == 0:
+                yield div
+        elif count % group == 0:
+            yield sep
+        else:
+            yield mark
+        count += 1
diff --git a/Tools/c-analyzer/c_analyzer/parser/__init__.py b/Tools/c-analyzer/c_common/show.py
index e69de29bb2d..e69de29bb2d 100644
--- a/Tools/c-analyzer/c_analyzer/parser/__init__.py
+++ b/Tools/c-analyzer/c_common/show.py
diff --git a/Tools/c-analyzer/c_common/strutil.py b/Tools/c-analyzer/c_common/strutil.py
new file mode 100644
index 00000000000..e7535d45bbb
--- /dev/null
+++ b/Tools/c-analyzer/c_common/strutil.py
@@ -0,0 +1,42 @@
+import logging
+
+
+logger = logging.getLogger(__name__)
+
+
+def unrepr(value):
+    raise NotImplementedError
+
+
+def parse_entries(entries, *, ignoresep=None):
+    for entry in entries:
+        if ignoresep and ignoresep in entry:
+            subentries = [entry]
+        else:
+            subentries = entry.strip().replace(',', ' ').split()
+        for item in subentries:
+            if item.startswith('+'):
+                filename = item[1:]
+                try:
+                    infile = open(filename)
+                except FileNotFoundError:
+                    logger.debug(f'ignored in parse_entries(): +{filename}')
+                    return
+                with infile:
+                    # We read the entire file here to ensure the file
+                    # gets closed sooner rather than later.  Note that
+                    # the file would stay open if this iterator is never
+                    # exchausted.
+                    lines = infile.read().splitlines()
+                for line in _iter_significant_lines(lines):
+                    yield line, filename
+            else:
+                yield item, None
+
+
+def _iter_significant_lines(lines):
+    for line in lines:
+        line = line.partition('#')[0]
+        if not line.strip():
+            continue
+        yield line
diff --git a/Tools/c-analyzer/c_common/tables.py b/Tools/c-analyzer/c_common/tables.py
new file mode 100644
index 00000000000..70a230a90b6
--- /dev/null
+++ b/Tools/c-analyzer/c_common/tables.py
@@ -0,0 +1,213 @@
+import csv
+
+from . import NOT_SET, strutil, fsutil
+
+
+EMPTY = '-'
+UNKNOWN = '???'
+
+
+def parse_markers(markers, default=None):
+    if markers is NOT_SET:
+        return default
+    if not markers:
+        return None
+    if type(markers) is not str:
+        return markers
+    if markers == markers[0] * len(markers):
+        return [markers]
+    return list(markers)
+
+
+def fix_row(row, **markers):
+    if isinstance(row, str):
+        raise NotImplementedError(row)
+    empty = parse_markers(markers.pop('empty', ('-',)))
+    unknown = parse_markers(markers.pop('unknown', ('???',)))
+    row = (val if val else None for val in row)
+    if not empty:
+        if not unknown:
+            return row
+        return (UNKNOWN if val in unknown else val for val in row)
+    elif not unknown:
+        return (EMPTY if val in empty else val for val in row)
+    return (EMPTY if val in empty else (UNKNOWN if val in unknown else val)
+            for val in row)
+
+
+def _fix_read_default(row):
+    for value in row:
+        yield value.strip()
+
+
+def _fix_write_default(row, empty=''):
+    for value in row:
+        yield empty if value is None else str(value)
+
+
+def _normalize_fix_read(fix):
+    if fix is None:
+        fix = ''
+    if callable(fix):
+        def fix_row(row):
+            values = fix(row)
+            return _fix_read_default(values)
+    elif isinstance(fix, str):
+        def fix_row(row):
+            values = _fix_read_default(row)
+            return (None if v == fix else v
+                    for v in values)
+    else:
+        raise NotImplementedError(fix)
+    return fix_row
+
+
+def _normalize_fix_write(fix, empty=''):
+    if fix is None:
+        fix = empty
+    if callable(fix):
+        def fix_row(row):
+            values = fix(row)
+            return _fix_write_default(values, empty)
+    elif isinstance(fix, str):
+        def fix_row(row):
+            return _fix_write_default(row, fix)
+    else:
+        raise NotImplementedError(fix)
+    return fix_row
+
+
+def read_table(infile, header, *,
+               sep='\t',
+               fix=None,
+               _open=open,
+               _get_reader=csv.reader,
+               ):
+    """Yield each row of the given ???-separated (e.g. tab) file."""
+    if isinstance(infile, str):
+        with _open(infile, newline='') as infile:
+            yield from read_table(
+                infile,
+                header,
+                sep=sep,
+                fix=fix,
+                _open=_open,
+                _get_reader=_get_reader,
+            )
+            return
+    lines = strutil._iter_significant_lines(infile)
+
+    # Validate the header.
+    if not isinstance(header, str):
+        header = sep.join(header)
+    try:
+        actualheader = next(lines).strip()
+    except StopIteration:
+        actualheader = ''
+    if actualheader != header:
+        raise ValueError(f'bad header {actualheader!r}')
+
+    fix_row = _normalize_fix_read(fix)
+    for row in _get_reader(lines, delimiter=sep or '\t'):
+        yield tuple(fix_row(row))
+
+
+def write_table(outfile, header, rows, *,
+                sep='\t',
+                fix=None,
+                backup=True,
+                _open=open,
+                _get_writer=csv.writer,
+                ):
+    """Write each of the rows to the given ???-separated (e.g. tab) file."""
+    if backup:
+        fsutil.create_backup(outfile, backup)
+    if isinstance(outfile, str):
+        with _open(outfile, 'w', newline='') as outfile:
+            return write_table(
+                outfile,
+                header,
+                rows,
+                sep=sep,
+                fix=fix,
+                backup=backup,
+                _open=_open,
+                _get_writer=_get_writer,
+            )
+
+    if isinstance(header, str):
+        header = header.split(sep or '\t')
+    fix_row = _normalize_fix_write(fix)
+    writer = _get_writer(outfile, delimiter=sep or '\t')
+    writer.writerow(header)
+    for row in rows:
+        writer.writerow(
+            tuple(fix_row(row))
+        )
+
+
+def parse_table(entries, sep, header=None, rawsep=None, *,
+                default=NOT_SET,
+                strict=True,
+                ):
+    header, sep = _normalize_table_file_props(header, sep)
+    if not sep:
+        raise ValueError('missing "sep"')
+
+    ncols = None
+    if header:
+        if strict:
+            ncols = len(header.split(sep))
+        cur_file = None
+    for line, filename in strutil.parse_entries(entries, ignoresep=sep):
+        _sep = sep
+        if filename:
+            if header and cur_file != filename:
+                cur_file = filename
+                # Skip the first line if it's the header.
+                if line.strip() == header:
+                    continue
+                else:
+                    # We expected the header.
+                    raise NotImplementedError((header, line))
+        elif rawsep and sep not in line:
+            _sep = rawsep
+
+        row = _parse_row(line, _sep, ncols, default)
+        if strict and not ncols:
+            ncols = len(row)
+        yield row, filename
+
+
+def parse_row(line, sep, *, ncols=None, default=NOT_SET):
+    if not sep:
+        raise ValueError('missing "sep"')
+    return _parse_row(line, sep, ncols, default)
+
+
+def _parse_row(line, sep, ncols, default):
+    row = tuple(v.strip() for v in line.split(sep))
+    if (ncols or 0) > 0:
+        diff = ncols - len(row)
+        if diff:
+            if default is NOT_SET or diff < 0:
+                raise Exception(f'bad row (expected {ncols} columns, got {row!r})')
+            row += (default,) * diff
+    return row
+
+
+def _normalize_table_file_props(header, sep):
+    if not header:
+        return None, sep
+
+    if not isinstance(header, str):
+        if not sep:
+            raise NotImplementedError(header)
+        header = sep.join(header)
+    elif not sep:
+        for sep in ('\t', ',', ' '):
+            if sep in header:
+                break
+        else:
+            sep = None
+    return header, sep
diff --git a/Tools/c-analyzer/c_parser/__init__.py b/Tools/c-analyzer/c_parser/__init__.py
new file mode 100644
index 00000000000..39455ddbf1a
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/__init__.py
@@ -0,0 +1,46 @@
+from .parser import parse as _parse
+from .preprocessor import get_preprocessor as _get_preprocessor
+
+
+def parse_file(filename, *,
+               match_kind=None,
+               get_file_preprocessor=None,
+               ):
+    if get_file_preprocessor is None:
+        get_file_preprocessor = _get_preprocessor()
+    yield from _parse_file(filename, match_kind, get_file_preprocessor)
+
+
+def parse_files(filenames, *,
+                match_kind=None,
+                get_file_preprocessor=None,
+                ):
+    if get_file_preprocessor is None:
+        get_file_preprocessor = _get_preprocessor()
+    for filename in filenames:
+        yield from _parse_file(filename, match_kind, get_file_preprocessor)
+
+
+def _parse_file(filename, match_kind, get_file_preprocessor):
+    # Preprocess the file.
+    preprocess = get_file_preprocessor(filename)
+    preprocessed = preprocess()
+    if preprocessed is None:
+        return
+
+    # Parse the lines.
+    srclines = ((l.file, l.data) for l in preprocessed if l.kind == 'source')
+    for item in _parse(srclines):
+        if match_kind is not None and not match_kind(item.kind):
+            continue
+        if not item.filename:
+            raise NotImplementedError(repr(item))
+        yield item
+
+
+def parse_signature(text):
+    raise NotImplementedError
+
+
+# aliases
+from .info import resolve_parsed
diff --git a/Tools/c-analyzer/c_parser/__main__.py b/Tools/c-analyzer/c_parser/__main__.py
new file mode 100644
index 00000000000..1752a703f60
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/__main__.py
@@ -0,0 +1,261 @@
+import logging
+import os.path
+import sys
+
+from c_common.scriptutil import (
+    CLIArgSpec as Arg,
+    add_verbosity_cli,
+    add_traceback_cli,
+    add_kind_filtering_cli,
+    add_files_cli,
+    add_commands_cli,
+    process_args_by_key,
+    configure_logger,
+    get_prog,
+    main_for_filenames,
+)
+from .preprocessor import get_preprocessor
+from .preprocessor.__main__ import (
+    add_common_cli as add_preprocessor_cli,
+)
+from .info import KIND
+from . import parse_file as _iter_parsed
+
+
+logger = logging.getLogger(__name__)
+
+
+def _format_vartype(vartype):
+    if isinstance(vartype, str):
+        return vartype
+
+    data = vartype
+    try:
+        vartype = data['vartype']
+    except KeyError:
+        storage, typequal, typespec, abstract = vartype.values()
+    else:
+        storage = data.get('storage')
+        if storage:
+            _, typequal, typespec, abstract = vartype.values()
+        else:
+            storage, typequal, typespec, abstract = vartype.values()
+
+    vartype = f'{typespec} {abstract}'
+    if typequal:
+        vartype = f'{typequal} {vartype}'
+    if storage:
+        vartype = f'{storage} {vartype}'
+    return vartype
+
+
+def _get_preprocessor(filename, **kwargs):
+    return get_processor(filename,
+                         log_err=print,
+                         **kwargs
+                         )
+
+
+#######################################
+# the formats
+
+def fmt_raw(filename, item, *, showfwd=None):
+    yield str(tuple(item))
+
+
+def fmt_summary(filename, item, *, showfwd=None):
+    if item.filename and item.filename != os.path.join('.', filename):
+        yield f'> {item.filename}'
+    if showfwd is None:
+        LINE = ' {lno:>5} {kind:10} {funcname:40} {fwd:1} {name:40} {data}'
+    else:
+        LINE = ' {lno:>5} {kind:10} {funcname:40} {name:40} {data}'
+    lno = kind = funcname = fwd = name = data = ''
+    MIN_LINE = len(LINE.format(**locals()))
+
+    fileinfo, kind, funcname, name, data = item
+    lno = fileinfo.lno if fileinfo and fileinfo.lno >= 0 else ''
+    funcname = funcname or ' --'
+    name = name or ' --'
+    isforward = False
+    if kind is KIND.FUNCTION:
+        storage, inline, params, returntype, isforward = data.values()
+        returntype = _format_vartype(returntype)
+        data = returntype + params
+        if inline:
+            data = f'inline {data}'
+        if storage:
+            data = f'{storage} {data}'
+    elif kind is KIND.VARIABLE:
+        data = _format_vartype(data)
+    elif kind is KIND.STRUCT or kind is KIND.UNION:
+        if data is None:
+            isforward = True
+        else:
+            fields = data
+            data = f'({len(data)}) {{ '
+            indent = ',\n' + ' ' * (MIN_LINE + len(data))
+            data += ', '.join(f.name for f in fields[:5])
+            fields = fields[5:]
+            while fields:
+                data = f'{data}{indent}{", ".join(f.name for f in fields[:5])}'
+                fields = fields[5:]
+            data += ' }'
+    elif kind is KIND.ENUM:
+        if data is None:
+            isforward = True
+        else:
+            names = [d if isinstance(d, str) else d.name
+                     for d in data]
+            data = f'({len(data)}) {{ '
+            indent = ',\n' + ' ' * (MIN_LINE + len(data))
+            data += ', '.join(names[:5])
+            names = names[5:]
+            while names:
+                data = f'{data}{indent}{", ".join(names[:5])}'
+                names = names[5:]
+            data += ' }'
+    elif kind is KIND.TYPEDEF:
+        data = f'typedef {data}'
+    elif kind == KIND.STATEMENT:
+        pass
+    else:
+        raise NotImplementedError(item)
+    if isforward:
+        fwd = '*'
+        if not showfwd and showfwd is not None:
+            return
+    elif showfwd:
+        return
+    kind = kind.value
+    yield LINE.format(**locals())
+
+
+def fmt_full(filename, item, *, showfwd=None):
+    raise NotImplementedError
+
+
+FORMATS = {
+    'raw': fmt_raw,
+    'summary': fmt_summary,
+    'full': fmt_full,
+}
+
+
+def add_output_cli(parser):
+    parser.add_argument('--format', dest='fmt', default='summary', choices=tuple(FORMATS))
+    parser.add_argument('--showfwd', action='store_true', default=None)
+    parser.add_argument('--no-showfwd', dest='showfwd', action='store_false', default=None)
+
+    def process_args(args):
+        pass
+    return process_args
+
+
+#######################################
+# the commands
+
+def _cli_parse(parser, excluded=None, **prepr_kwargs):
+    process_output = add_output_cli(parser)
+    process_kinds = add_kind_filtering_cli(parser)
+    process_preprocessor = add_preprocessor_cli(parser, **prepr_kwargs)
+    process_files = add_files_cli(parser, excluded=excluded)
+    return [
+        process_output,
+        process_kinds,
+        process_preprocessor,
+        process_files,
+    ]
+
+
+def cmd_parse(filenames, *,
+              fmt='summary',
+              showfwd=None,
+              iter_filenames=None,
+              **kwargs
+              ):
+    if 'get_file_preprocessor' not in kwargs:
+        kwargs['get_file_preprocessor'] = _get_preprocessor()
+    try:
+        do_fmt = FORMATS[fmt]
+    except KeyError:
+        raise ValueError(f'unsupported fmt {fmt!r}')
+    for filename in main_for_filenames(filenames, iter_filenames):
+        for item in _iter_parsed(filename, **kwargs):
+            for line in do_fmt(filename, item, showfwd=showfwd):
+                print(line)
+
+
+def _cli_data(parser):
+    ...
+
+    return []
+
+
+def cmd_data(filenames,
+             **kwargs
+             ):
+    # XXX
+    raise NotImplementedError
+
+
+COMMANDS = {
+    'parse': (
+        'parse the given C source & header files',
+        [_cli_parse],
+        cmd_parse,
+    ),
+    'data': (
+        'check/manage local data (e.g. excludes, macros)',
+        [_cli_data],
+        cmd_data,
+    ),
+}
+
+
+#######################################
+# the script
+
+def parse_args(argv=sys.argv[1:], prog=sys.argv[0], *, subset='parse'):
+    import argparse
+    parser = argparse.ArgumentParser(
+        prog=prog or get_prog,
+    )
+
+    processors = add_commands_cli(
+        parser,
+        commands={k: v[1] for k, v in COMMANDS.items()},
+        commonspecs=[
+            add_verbosity_cli,
+            add_traceback_cli,
+        ],
+        subset=subset,
+    )
+
+    args = parser.parse_args(argv)
+    ns = vars(args)
+
+    cmd = ns.pop('cmd')
+
+    verbosity, traceback_cm = process_args_by_key(
+        args,
+        processors[cmd],
+        ['verbosity', 'traceback_cm'],
+    )
+
+    return cmd, ns, verbosity, traceback_cm
+
+
+def main(cmd, cmd_kwargs):
+    try:
+        run_cmd = COMMANDS[cmd][0]
+    except KeyError:
+        raise ValueError(f'unsupported cmd {cmd!r}')
+    run_cmd(**cmd_kwargs)
+
+
+if __name__ == '__main__':
+    cmd, cmd_kwargs, verbosity, traceback_cm = parse_args()
+    configure_logger(verbosity)
+    with traceback_cm:
+        main(cmd, cmd_kwargs)
diff --git a/Tools/c-analyzer/c_parser/_state_machine.py b/Tools/c-analyzer/c_parser/_state_machine.py
new file mode 100644
index 00000000000..b505b4e3e47
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/_state_machine.py
@@ -0,0 +1,244 @@
+
+f'''
+    struct {ANON_IDENTIFIER};
+    struct {{ ... }}
+    struct {IDENTIFIER} {{ ... }}
+
+    union {ANON_IDENTIFIER};
+    union {{ ... }}
+    union {IDENTIFIER} {{ ... }}
+
+    enum {ANON_IDENTIFIER};
+    enum {{ ... }}
+    enum {IDENTIFIER} {{ ... }}
+
+    typedef {VARTYPE} {IDENTIFIER};
+    typedef {IDENTIFIER};
+    typedef {IDENTIFIER};
+    typedef {IDENTIFIER};
+'''
+
+
+def parse(srclines):
+    if isinstance(srclines, str):  # a filename
+        raise NotImplementedError
+
+    
+
+# This only handles at most 10 nested levels.
+#MATCHED_PARENS = textwrap.dedent(rf'''
+#    # matched parens
+#    (?:
+#        [(]  # level 0
+#        (?:
+#            [^()]*
+#            [(]  # level 1
+#            (?:
+#                [^()]*
+#                [(]  # level 2
+#                (?:
+#                    [^()]*
+#                    [(]  # level 3
+#                    (?:
+#                        [^()]*
+#                        [(]  # level 4
+#                        (?:
+#                            [^()]*
+#                            [(]  # level 5
+#                            (?:
+#                                [^()]*
+#                                [(]  # level 6
+#                                (?:
+#                                    [^()]*
+#                                    [(]  # level 7
+#                                    (?:
+#                                        [^()]*
+#                                        [(]  # level 8
+#                                        (?:
+#                                            [^()]*
+#                                            [(]  # level 9
+#                                            (?:
+#                                                [^()]*
+#                                                [(]  # level 10
+#                                                [^()]*
+#                                                [)]
+#                                             )*
+#                                            [^()]*
+#                                            [)]
+#                                         )*
+#                                        [^()]*
+#                                        [)]
+#                                     )*
+#                                    [^()]*
+#                                    [)]
+#                                 )*
+#                                [^()]*
+#                                [)]
+#                             )*
+#                            [^()]*
+#                            [)]
+#                         )*
+#                        [^()]*
+#                        [)]
+#                     )*
+#                    [^()]*
+#                    [)]
+#                 )*
+#                [^()]*
+#                [)]
+#             )*
+#            [^()]*
+#            [)]
+#         )*
+#        [^()]*
+#        [)]
+#     )
+#    # end matched parens
+#    ''')
+
+'''
+        # for loop
+        (?:
+            \s* \b for
+            \s* [(]
+            (
+                [^;]* ;
+                [^;]* ;
+                .*?
+             )  # <header>
+            [)]
+            \s*
+            (?:
+                (?:
+                    (
+                        {_ind(SIMPLE_STMT, 6)}
+                     )  # <stmt>
+                    ;
+                 )
+                |
+                ( {{ )  # <open>
+             )
+         )
+        |
+
+
+
+            (
+                (?:
+                    (?:
+                        (?:
+                            {_ind(SIMPLE_STMT, 6)}
+                         )?
+                        return \b \s*
+                        {_ind(INITIALIZER, 5)}
+                     )
+                    |
+                    (?:
+                        (?:
+                            {IDENTIFIER} \s*
+                            (?: . | -> ) \s*
+                         )*
+                        {IDENTIFIER}
+                        \s* = \s*
+                        {_ind(INITIALIZER, 5)}
+                     )
+                    |
+                    (?:
+                        {_ind(SIMPLE_STMT, 5)}
+                     )
+                 )
+                |
+                # cast compound literal
+                (?:
+                    (?:
+                        [^'"{{}};]*
+                        {_ind(STRING_LITERAL, 5)}
+                     )*
+                    [^'"{{}};]*?
+                    [^'"{{}};=]
+                    =
+                    \s* [(] [^)]* [)]
+                    \s* {{ [^;]* }}
+                 )
+             )  # <stmt>
+
+
+
+        # compound statement
+        (?:
+            (
+                (?:
+
+                    # "for" statements are handled separately above.
+                    (?: (?: else \s+ )? if | switch | while ) \s*
+                    {_ind(COMPOUND_HEAD, 5)}
+                 )
+                |
+                (?: else | do )
+                # We do not worry about compound statements for labels,
+                # "case", or "default".
+             )?  # <header>
+            \s*
+            ( {{ )  # <open>
+         )
+
+
+
+            (
+                (?:
+                    [^'"{{}};]*
+                    {_ind(STRING_LITERAL, 5)}
+                 )*
+                [^'"{{}};]*
+                # Presumably we will not see "== {{".
+                [^\s='"{{}};]
+             )?  # <header>
+
+
+
+            (
+                \b
+                (?:
+                    # We don't worry about labels with a compound statement.
+                    (?:
+                        switch \s* [(] [^{{]* [)]
+                     )
+                    |
+                    (?:
+                        case \b \s* [^:]+ [:]
+                     )
+                    |
+                    (?:
+                        default \s* [:]
+                     )
+                    |
+                    (?:
+                        do
+                     )
+                    |
+                    (?:
+                        while \s* [(] [^{{]* [)]
+                     )
+                    |
+                    #(?:
+                    #    for \s* [(] [^{{]* [)]
+                    # )
+                    #|
+                    (?:
+                        if \s* [(]
+                        (?: [^{{]* [^)] \s* {{ )* [^{{]*
+                        [)]
+                     )
+                    |
+                    (?:
+                        else
+                        (?:
+                            \s*
+                            if \s* [(]
+                            (?: [^{{]* [^)] \s* {{ )* [^{{]*
+                            [)]
+                         )?
+                     )
+                 )
+             )?  # <header>
+'''
diff --git a/Tools/c-analyzer/c_parser/datafiles.py b/Tools/c-analyzer/c_parser/datafiles.py
new file mode 100644
index 00000000000..5bdb946b177
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/datafiles.py
@@ -0,0 +1,150 @@
+import os.path
+
+import c_common.tables as _tables
+import c_parser.info as _info
+
+
+BASE_COLUMNS = [
+    'filename',
+    'funcname',
+    'name',
+    'kind',
+]
+END_COLUMNS = {
+    'parsed': 'data',
+    'decls': 'declaration',
+}
+
+
+def _get_columns(group, extra=None):
+    return BASE_COLUMNS + list(extra or ()) + [END_COLUMNS[group]]
+    #return [
+    #    *BASE_COLUMNS,
+    #    *extra or (),
+    #    END_COLUMNS[group],
+    #]
+
+
+#############################
+# high-level
+
+def read_parsed(infile):
+    # XXX Support other formats than TSV?
+    columns = _get_columns('parsed')
+    for row in _tables.read_table(infile, columns, sep='\t', fix='-'):
+        yield _info.ParsedItem.from_row(row, columns)
+
+
+def write_parsed(items, outfile):
+    # XXX Support other formats than TSV?
+    columns = _get_columns('parsed')
+    rows = (item.as_row(columns) for item in items)
+    _tables.write_table(outfile, columns, rows, sep='\t', fix='-')
+
+
+def read_decls(infile, fmt=None):
+    if fmt is None:
+        fmt = _get_format(infile)
+    read_all, _ = _get_format_handlers('decls', fmt)
+    for decl, _ in read_all(infile):
+        yield decl
+
+
+def write_decls(decls, outfile, fmt=None, *, backup=False):
+    if fmt is None:
+        fmt = _get_format(infile)
+    _, write_all = _get_format_handlers('decls', fmt)
+    write_all(decls, outfile, backup=backup)
+
+
+#############################
+# formats
+
+def _get_format(file, default='tsv'):
+    if isinstance(file, str):
+        filename = file
+    else:
+        filename = getattr(file, 'name', '')
+    _, ext = os.path.splitext(filename)
+    return ext[1:] if ext else default
+
+
+def _get_format_handlers(group, fmt):
+    # XXX Use a registry.
+    if group != 'decls':
+        raise NotImplementedError(group)
+    if fmt == 'tsv':
+        return (_iter_decls_tsv, _write_decls_tsv)
+    else:
+        raise NotImplementedError(fmt)
+
+
+# tsv
+
+def iter_decls_tsv(infile, extracolumns=None, relroot=None):
+    for info, extra in _iter_decls_tsv(infile, extracolumns, relroot):
+        decl = _info.Declaration.from_row(info)
+        yield decl, extra
+
+
+def write_decls_tsv(decls, outfile, extracolumns=None, *,
+                    relroot=None,
+                    **kwargs
+                    ):
+    # XXX Move the row rendering here.
+    _write_decls_tsv(rows, outfile, extracolumns, relroot, kwargs)
+
+
+def _iter_decls_tsv(infile, extracolumns=None, relroot=None):
+    columns = _get_columns('decls', extracolumns)
+    for row in _tables.read_table(infile, columns, sep='\t'):
+        if extracolumns:
+            declinfo = row[:4] + row[-1:]
+            extra = row[4:-1]
+        else:
+            declinfo = row
+            extra = None
+        if relroot:
+            # XXX Use something like tables.fix_row() here.
+            declinfo = [None if v == '-' else v
+                        for v in declinfo]
+            declinfo[0] = os.path.join(relroot, declinfo[0])
+        yield declinfo, extra
+
+
+def _write_decls_tsv(decls, outfile, extracolumns, relroot,kwargs):
+    columns = _get_columns('decls', extracolumns)
+    if extracolumns:
+        def render_decl(decl):
+            if type(row) is tuple:
+                decl, *extra = decl
+            else:
+                extra = ()
+            extra += ('???',) * (len(extraColumns) - len(extra))
+            *row, declaration = _render_known_row(decl, relroot)
+            row += extra + (declaration,)
+            return row
+    else:
+        render_decl = _render_known_decl
+    _tables.write_table(
+        outfile,
+        header='\t'.join(columns),
+        rows=(render_decl(d, relroot) for d in decls),
+        sep='\t',
+        **kwargs
+    )
+
+
+def _render_known_decl(decl, relroot, *,
+                       # These match BASE_COLUMNS + END_COLUMNS[group].
+                       _columns = 'filename parent name kind data'.split(),
+                       ):
+    if not isinstance(decl, _info.Declaration):
+        # e.g. Analyzed
+        decl = decl.decl
+    rowdata = decl.render_rowdata(_columns)
+    if relroot:
+        rowdata['filename'] = os.path.relpath(rowdata['filename'], relroot)
+    return [rowdata[c] or '-' for c in _columns]
+    # XXX
+    #return _tables.fix_row(rowdata[c] for c in columns)
diff --git a/Tools/c-analyzer/c_parser/info.py b/Tools/c-analyzer/c_parser/info.py
new file mode 100644
index 00000000000..a07ce2e0ccb
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/info.py
@@ -0,0 +1,1658 @@
+from collections import namedtuple
+import enum
+import os.path
+import re
+
+from c_common.clsutil import classonly
+import c_common.misc as _misc
+import c_common.strutil as _strutil
+import c_common.tables as _tables
+from .parser._regexes import SIMPLE_TYPE
+
+
+FIXED_TYPE = _misc.Labeled('FIXED_TYPE')
+
+POTS_REGEX = re.compile(rf'^{SIMPLE_TYPE}$', re.VERBOSE)
+
+
+def is_pots(typespec):
+    if not typespec:
+        return None
+    if type(typespec) is not str:
+        _, _, _, typespec, _ = get_parsed_vartype(typespec)
+    return POTS_REGEX.match(typespec) is not None
+
+
+def is_funcptr(vartype):
+    if not vartype:
+        return None
+    _, _, _, _, abstract = get_parsed_vartype(vartype)
+    return _is_funcptr(abstract)
+
+
+def _is_funcptr(declstr):
+    if not declstr:
+        return None
+    # XXX Support "(<name>*)(".
+    return '(*)(' in declstr.replace(' ', '')
+
+
+def is_exported_symbol(decl):
+    _, storage, _, _, _ = get_parsed_vartype(decl)
+    raise NotImplementedError
+
+
+def is_process_global(vardecl):
+    kind, storage, _, _, _ = get_parsed_vartype(vardecl)
+    if kind is not KIND.VARIABLE:
+        raise NotImplementedError(vardecl)
+    if 'static' in (storage or ''):
+        return True
+
+    if hasattr(vardecl, 'parent'):
+        parent = vardecl.parent
+    else:
+        parent = vardecl.get('parent')
+    return not parent
+
+
+def is_fixed_type(vardecl):
+    if not vardecl:
+        return None
+    _, _, _, typespec, abstract = get_parsed_vartype(vardecl)
+    if 'typeof' in typespec:
+        raise NotImplementedError(vardecl)
+    elif not abstract:
+        return True
+
+    if '*' not in abstract:
+        # XXX What about []?
+        return True
+    elif _is_funcptr(abstract):
+        return True
+    else:
+        for after in abstract.split('*')[1:]:
+            if not after.lstrip().startswith('const'):
+                return False
+        else:
+            return True
+
+
+def is_immutable(vardecl):
+    if not vardecl:
+        return None
+    if not is_fixed_type(vardecl):
+        return False
+    _, _, typequal, _, _ = get_parsed_vartype(vardecl)
+    # If there, it can only be "const" or "volatile".
+    return typequal == 'const'
+
+
+#############################
+# kinds
+
+@enum.unique
+class KIND(enum.Enum):
+
+    # XXX Use these in the raw parser code.
+    TYPEDEF = 'typedef'
+    STRUCT = 'struct'
+    UNION = 'union'
+    ENUM = 'enum'
+    FUNCTION = 'function'
+    VARIABLE = 'variable'
+    STATEMENT = 'statement'
+
+    @classonly
+    def _from_raw(cls, raw):
+        if raw is None:
+            return None
+        elif isinstance(raw, cls):
+            return raw
+        elif type(raw) is str:
+            # We could use cls[raw] for the upper-case form,
+            # but there's no need to go to the trouble.
+            return cls(raw.lower())
+        else:
+            raise NotImplementedError(raw)
+
+    @classonly
+    def by_priority(cls, group=None):
+        if group is None:
+            return cls._ALL_BY_PRIORITY.copy()
+        elif group == 'type':
+            return cls._TYPE_DECLS_BY_PRIORITY.copy()
+        elif group == 'decl':
+            return cls._ALL_DECLS_BY_PRIORITY.copy()
+        elif isinstance(group, str):
+            raise NotImplementedError(group)
+        else:
+            # XXX Treat group as a set of kinds & return in priority order?
+            raise NotImplementedError(group)
+
+    @classonly
+    def is_type_decl(cls, kind):
+        if kind in cls.TYPES:
+            return True
+        if not isinstance(kind, cls):
+            raise TypeError(f'expected KIND, got {kind!r}')
+        return False
+
+    @classonly
+    def is_decl(cls, kind):
+        if kind in cls.DECLS:
+            return True
+        if not isinstance(kind, cls):
+            raise TypeError(f'expected KIND, got {kind!r}')
+        return False
+
+    @classonly
+    def get_group(cls, kind, *, groups=None):
+        if not isinstance(kind, cls):
+            raise TypeError(f'expected KIND, got {kind!r}')
+        if groups is None:
+            groups = ['type']
+        elif not groups:
+            groups = ()
+        elif isinstance(groups, str):
+            group = groups
+            if group not in cls._GROUPS:
+                raise ValueError(f'unsupported group {group!r}')
+            groups = [group]
+        else:
+            unsupported = [g for g in groups if g not in cls._GROUPS]
+            if unsupported:
+                raise ValueError(f'unsupported groups {", ".join(repr(unsupported))}')
+        for group in groups:
+            if kind in cls._GROUPS[group]:
+                return group
+        else:
+            return kind.value
+
+    @classonly
+    def resolve_group(cls, group):
+        if isinstance(group, cls):
+            return {group}
+        elif isinstance(group, str):
+            try:
+                return cls._GROUPS[group].copy()
+            except KeyError:
+                raise ValueError(f'unsupported group {group!r}')
+        else:
+            resolved = set()
+            for gr in group:
+                resolve.update(cls.resolve_group(gr))
+            return resolved
+            #return {*cls.resolve_group(g) for g in group}
+
+
+KIND._TYPE_DECLS_BY_PRIORITY = [
+    # These are in preferred order.
+    KIND.TYPEDEF,
+    KIND.STRUCT,
+    KIND.UNION,
+    KIND.ENUM,
+]
+KIND._ALL_DECLS_BY_PRIORITY = [
+    # These are in preferred order.
+    *KIND._TYPE_DECLS_BY_PRIORITY,
+    KIND.FUNCTION,
+    KIND.VARIABLE,
+]
+KIND._ALL_BY_PRIORITY = [
+    # These are in preferred order.
+    *KIND._ALL_DECLS_BY_PRIORITY,
+    KIND.STATEMENT,
+]
+
+KIND.TYPES = frozenset(KIND._TYPE_DECLS_BY_PRIORITY)
+KIND.DECLS = frozenset(KIND._ALL_DECLS_BY_PRIORITY)
+KIND._GROUPS = {
+    'type': KIND.TYPES,
+    'decl': KIND.DECLS,
+}
+KIND._GROUPS.update((k.value, {k}) for k in KIND)
+
+
+# The module-level kind-related helpers (below) deal with <item>.kind:
+
+def is_type_decl(kind):
+    # Handle ParsedItem, Declaration, etc..
+    kind = getattr(kind, 'kind', kind)
+    return KIND.is_type_decl(kind)
+
+
+def is_decl(kind):
+    # Handle ParsedItem, Declaration, etc..
+    kind = getattr(kind, 'kind', kind)
+    return KIND.is_decl(kind)
+
+
+def filter_by_kind(items, kind):
+    if kind == 'type':
+        kinds = KIND._TYPE_DECLS
+    elif kind == 'decl':
+        kinds = KIND._TYPE_DECLS
+    try:
+        okay = kind in KIND
+    except TypeError:
+        kinds = set(kind)
+    else:
+        kinds = {kind} if okay else set(kind)
+    for item in items:
+        if item.kind in kinds:
+            yield item
+
+
+def collate_by_kind(items):
+    collated = {kind: [] for kind in KIND}
+    for item in items:
+        try:
+            collated[item.kind].append(item)
+        except KeyError:
+            raise ValueError(f'unsupported kind in {item!r}')
+    return collated
+
+
+def get_kind_group(kind):
+    # Handle ParsedItem, Declaration, etc..
+    kind = getattr(kind, 'kind', kind)
+    return KIND.get_group(kind)
+
+
+def collate_by_kind_group(items):
+    collated = {KIND.get_group(k): [] for k in KIND}
+    for item in items:
+        group = KIND.get_group(item.kind)
+        collated[group].append(item)
+    return collated
+
+
+#############################
+# low-level
+
+class FileInfo(namedtuple('FileInfo', 'filename lno')):
+    @classmethod
+    def from_raw(cls, raw):
+        if isinstance(raw, cls):
+            return raw
+        elif isinstance(raw, tuple):
+            return cls(*raw)
+        elif not raw:
+            return None
+        elif isinstance(raw, str):
+            return cls(raw, -1)
+        else:
+            raise TypeError(f'unsupported "raw": {raw:!r}')
+
+    def __str__(self):
+        return self.filename
+
+    def fix_filename(self, relroot):
+        filename = os.path.relpath(self.filename, relroot)
+        return self._replace(filename=filename)
+
+
+class SourceLine(namedtuple('Line', 'file kind data conditions')):
+    KINDS = (
+        #'directive',  # data is ...
+        'source',  # "data" is the line
+        #'comment',  # "data" is the text, including comment markers
+    )
+
+    @property
+    def filename(self):
+        return self.file.filename
+
+    @property
+    def lno(self):
+        return self.file.lno
+
+
+class DeclID(namedtuple('DeclID', 'filename funcname name')):
+    """The globally-unique identifier for a declaration."""
+
+    @classmethod
+    def from_row(cls, row, **markers):
+        row = _tables.fix_row(row, **markers)
+        return cls(*row)
+
+    def __new__(cls, filename, funcname, name):
+        self = super().__new__(
+            cls,
+            filename=str(filename) if filename else None,
+            funcname=str(funcname) if funcname else None,
+            name=str(name) if name else None,
+        )
+        self._compare = tuple(v or '' for v in self)
+        return self
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def __eq__(self, other):
+        try:
+            other = tuple(v or '' for v in other)
+        except TypeError:
+            return NotImplemented
+        return self._compare == other
+
+    def __gt__(self, other):
+        try:
+            other = tuple(v or '' for v in other)
+        except TypeError:
+            return NotImplemented
+        return self._compare > other
+
+
+class ParsedItem(namedtuple('ParsedItem', 'file kind parent name data')):
+
+    @classmethod
+    def from_raw(cls, raw):
+        if isinstance(raw, cls):
+            return raw
+        elif isinstance(raw, tuple):
+            return cls(*raw)
+        else:
+            raise TypeError(f'unsupported "raw": {raw:!r}')
+
+    @classmethod
+    def from_row(cls, row, columns=None):
+        if not columns:
+            colnames = 'filename funcname name kind data'.split()
+        else:
+            colnames = list(columns)
+            for i, column in enumerate(colnames):
+                if column == 'file':
+                    colnames[i] = 'filename'
+                elif column == 'funcname':
+                    colnames[i] = 'parent'
+        if len(row) != len(set(colnames)):
+            raise NotImplementedError(columns, row)
+        kwargs = {}
+        for column, value in zip(colnames, row):
+            if column == 'filename':
+                kwargs['file'] = FileInfo.from_raw(value)
+            elif column == 'kind':
+                kwargs['kind'] = KIND(value)
+            elif column in cls._fields:
+                kwargs[column] = value
+            else:
+                raise NotImplementedError(column)
+        return cls(**kwargs)
+
+    @property
+    def id(self):
+        try:
+            return self._id
+        except AttributeError:
+            if self.kind is KIND.STATEMENT:
+                self._id = None
+            else:
+                self._id = DeclID(str(self.file), self.funcname, self.name)
+            return self._id
+
+    @property
+    def filename(self):
+        if not self.file:
+            return None
+        return self.file.filename
+
+    @property
+    def lno(self):
+        if not self.file:
+            return -1
+        return self.file.lno
+
+    @property
+    def funcname(self):
+        if not self.parent:
+            return None
+        if type(self.parent) is str:
+            return self.parent
+        else:
+            return self.parent.name
+
+    def as_row(self, columns=None):
+        if not columns:
+            columns = self._fields
+        row = []
+        for column in columns:
+            if column == 'file':
+                value = self.filename
+            elif column == 'kind':
+                value = self.kind.value
+            elif column == 'data':
+                value = self._render_data()
+            else:
+                value = getattr(self, column)
+            row.append(value)
+        return row
+
+    def _render_data(self):
+        if not self.data:
+            return None
+        elif isinstance(self.data, str):
+            return self.data
+        else:
+            # XXX
+            raise NotImplementedError
+
+
+def _get_vartype(data):
+    try:
+        vartype = dict(data['vartype'])
+    except KeyError:
+        vartype = dict(data)
+        storage = data.get('storage')
+    else:
+        storage = data.get('storage') or vartype.get('storage')
+    del vartype['storage']
+    return storage, vartype
+
+
+def get_parsed_vartype(decl):
+    kind = getattr(decl, 'kind', None)
+    if isinstance(decl, ParsedItem):
+        storage, vartype = _get_vartype(decl.data)
+        typequal = vartype['typequal']
+        typespec = vartype['typespec']
+        abstract = vartype['abstract']
+    elif isinstance(decl, dict):
+        kind = decl.get('kind')
+        storage, vartype = _get_vartype(decl)
+        typequal = vartype['typequal']
+        typespec = vartype['typespec']
+        abstract = vartype['abstract']
+    elif isinstance(decl, VarType):
+        storage = None
+        typequal, typespec, abstract = decl
+    elif isinstance(decl, TypeDef):
+        storage = None
+        typequal, typespec, abstract = decl.vartype
+    elif isinstance(decl, Variable):
+        storage = decl.storage
+        typequal, typespec, abstract = decl.vartype
+    elif isinstance(decl, Function):
+        storage = decl.storage
+        typequal, typespec, abstract = decl.signature.returntype
+    elif isinstance(decl, str):
+        vartype, storage = VarType.from_str(decl)
+        typequal, typespec, abstract = vartype
+    else:
+        raise NotImplementedError(decl)
+    return kind, storage, typequal, typespec, abstract
+
+
+#############################
+# high-level
+
+class HighlevelParsedItem:
+
+    kind = None
+
+    FIELDS = ('file', 'parent', 'name', 'data')
+
+    @classmethod
+    def from_parsed(cls, parsed):
+        if parsed.kind is not cls.kind:
+            raise TypeError(f'kind mismatch ({parsed.kind.value} != {cls.kind.value})')
+        data, extra = cls._resolve_data(parsed.data)
+        self = cls(
+            cls._resolve_file(parsed),
+            parsed.name,
+            data,
+            cls._resolve_parent(parsed) if parsed.parent else None,
+            **extra or {}
+        )
+        self._parsed = parsed
+        return self
+
+    @classmethod
+    def _resolve_file(cls, parsed):
+        fileinfo = FileInfo.from_raw(parsed.file)
+        if not fileinfo:
+            raise NotImplementedError(parsed)
+        return fileinfo
+
+    @classmethod
+    def _resolve_data(cls, data):
+        return data, None
+
+    @classmethod
+    def _raw_data(cls, data, extra):
+        if isinstance(data, str):
+            return data
+        else:
+            raise NotImplementedError(data)
+
+    @classmethod
+    def _data_as_row(cls, data, extra, colnames):
+        row = {}
+        for colname in colnames:
+            if colname in row:
+                continue
+            rendered = cls._render_data_row_item(colname, data, extra)
+            if rendered is iter(rendered):
+                rendered, = rendered
+            row[colname] = rendered
+        return row
+
+    @classmethod
+    def _render_data_row_item(cls, colname, data, extra):
+        if colname == 'data':
+            return str(data)
+        else:
+            return None
+
+    @classmethod
+    def _render_data_row(cls, fmt, data, extra, colnames):
+        if fmt != 'row':
+            raise NotImplementedError
+        datarow = cls._data_as_row(data, extra, colnames)
+        unresolved = [c for c, v in datarow.items() if v is None]
+        if unresolved:
+            raise NotImplementedError(unresolved)
+        for colname, value in datarow.items():
+            if type(value) != str:
+                if colname == 'kind':
+                    datarow[colname] = value.value
+                else:
+                    datarow[colname] = str(value)
+        return datarow
+
+    @classmethod
+    def _render_data(cls, fmt, data, extra):
+        row = cls._render_data_row(fmt, data, extra, ['data'])
+        yield ' '.join(row.values())
+
+    @classmethod
+    def _resolve_parent(cls, parsed, *, _kind=None):
+        fileinfo = FileInfo(parsed.file.filename, -1)
+        if isinstance(parsed.parent, str):
+            if parsed.parent.isidentifier():
+                name = parsed.parent
+            else:
+                # XXX It could be something like "<kind> <name>".
+                raise NotImplementedError(repr(parsed.parent))
+            parent = ParsedItem(fileinfo, _kind, None, name, None)
+        elif type(parsed.parent) is tuple:
+            # XXX It could be something like (kind, name).
+            raise NotImplementedError(repr(parsed.parent))
+        else:
+            return parsed.parent
+        Parent = KIND_CLASSES.get(_kind, Declaration)
+        return Parent.from_parsed(parent)
+
+    @classmethod
+    def _parse_columns(cls, columns):
+        colnames = {}  # {requested -> actual}
+        columns = list(columns or cls.FIELDS)
+        datacolumns = []
+        for i, colname in enumerate(columns):
+            if colname == 'file':
+                columns[i] = 'filename'
+                colnames['file'] = 'filename'
+            elif colname == 'lno':
+                columns[i] = 'line'
+                colnames['lno'] = 'line'
+            elif colname in ('filename', 'line'):
+                colnames[colname] = colname
+            elif colname == 'data':
+                datacolumns.append(colname)
+                colnames[colname] = None
+            elif colname in cls.FIELDS or colname == 'kind':
+                colnames[colname] = colname
+            else:
+                datacolumns.append(colname)
+                colnames[colname] = None
+        return columns, datacolumns, colnames
+
+    def __init__(self, file, name, data, parent=None, *,
+                 _extra=None,
+                 _shortkey=None,
+                 _key=None,
+                 ):
+        self.file = file
+        self.parent = parent or None
+        self.name = name
+        self.data = data
+        self._extra = _extra or {}
+        self._shortkey = _shortkey
+        self._key = _key
+
+    def __repr__(self):
+        args = [f'{n}={getattr(self, n)!r}'
+                for n in ['file', 'name', 'data', 'parent', *(self._extra or ())]]
+        return f'{type(self).__name__}({", ".join(args)})'
+
+    def __str__(self):
+        try:
+            return self._str
+        except AttributeError:
+            self._str = next(self.render())
+            return self._str
+
+    def __getattr__(self, name):
+        try:
+            return self._extra[name]
+        except KeyError:
+            raise AttributeError(name)
+
+    def __hash__(self):
+        return hash(self._key)
+
+    def __eq__(self, other):
+        if isinstance(other, HighlevelParsedItem):
+            return self._key == other._key
+        elif type(other) is tuple:
+            return self._key == other
+        else:
+            return NotImplemented
+
+    def __gt__(self, other):
+        if isinstance(other, HighlevelParsedItem):
+            return self._key > other._key
+        elif type(other) is tuple:
+            return self._key > other
+        else:
+            return NotImplemented
+
+    @property
+    def id(self):
+        return self.parsed.id
+
+    @property
+    def shortkey(self):
+        return self._shortkey
+
+    @property
+    def key(self):
+        return self._key
+
+    @property
+    def filename(self):
+        if not self.file:
+            return None
+        return self.file.filename
+
+    @property
+    def parsed(self):
+        try:
+            return self._parsed
+        except AttributeError:
+            parent = self.parent
+            if parent is not None and not isinstance(parent, str):
+                parent = parent.name
+            self._parsed = ParsedItem(
+                self.file,
+                self.kind,
+                parent,
+                self.name,
+                self._raw_data(),
+            )
+            return self._parsed
+
+    def fix_filename(self, relroot):
+        if self.file:
+            self.file = self.file.fix_filename(relroot)
+
+    def as_rowdata(self, columns=None):
+        columns, datacolumns, colnames = self._parse_columns(columns)
+        return self._as_row(colnames, datacolumns, self._data_as_row)
+
+    def render_rowdata(self, columns=None):
+        columns, datacolumns, colnames = self._parse_columns(columns)
+        def data_as_row(data, ext, cols):
+            return self._render_data_row('row', data, ext, cols)
+        rowdata = self._as_row(colnames, datacolumns, data_as_row)
+        for column, value in rowdata.items():
+            colname = colnames.get(column)
+            if not colname:
+                continue
+            if column == 'kind':
+                value = value.value
+            else:
+                if column == 'parent':
+                    if self.parent:
+                        value = f'({self.parent.kind.value} {self.parent.name})'
+                if not value:
+                    value = '-'
+                elif type(value) is VarType:
+                    value = repr(str(value))
+                else:
+                    value = str(value)
+            rowdata[column] = value
+        return rowdata
+
+    def _as_row(self, colnames, datacolumns, data_as_row):
+        try:
+            data = data_as_row(self.data, self._extra, datacolumns)
+        except NotImplementedError:
+            data = None
+        row = data or {}
+        for column, colname in colnames.items():
+            if colname == 'filename':
+                value = self.file.filename if self.file else None
+            elif colname == 'line':
+                value = self.file.lno if self.file else None
+            elif colname is None:
+                value = getattr(self, column, None)
+            else:
+                value = getattr(self, colname, None)
+            row.setdefault(column, value)
+        return row
+
+    def render(self, fmt='line'):
+        fmt = fmt or 'line'
+        try:
+            render = _FORMATS[fmt]
+        except KeyError:
+            raise TypeError(f'unsupported fmt {fmt!r}')
+        try:
+            data = self._render_data(fmt, self.data, self._extra)
+        except NotImplementedError:
+            data = '-'
+        yield from render(self, data)
+
+
+### formats ###
+
+def _fmt_line(parsed, data=None):
+    parts = [
+        f'<{parsed.kind.value}>',
+    ]
+    parent = ''
+    if parsed.parent:
+        parent = parsed.parent
+        if not isinstance(parent, str):
+            if parent.kind is KIND.FUNCTION:
+                parent = f'{parent.name}()'
+            else:
+                parent = parent.name
+        name = f'<{parent}>.{parsed.name}'
+    else:
+        name = parsed.name
+    if data is None:
+        data = parsed.data
+    elif data is iter(data):
+        data, = data
+    parts.extend([
+        name,
+        f'<{data}>' if data else '-',
+        f'({str(parsed.file or "<unknown file>")})',
+    ])
+    yield '\t'.join(parts)
+
+
+def _fmt_full(parsed, data=None):
+    if parsed.kind is KIND.VARIABLE and parsed.parent:
+        prefix = 'local '
+        suffix = f' ({parsed.parent.name})'
+    else:
+        # XXX Show other prefixes (e.g. global, public)
+        prefix = suffix = ''
+    yield f'{prefix}{parsed.kind.value} {parsed.name!r}{suffix}'
+    for column, info in parsed.render_rowdata().items():
+        if column == 'kind':
+            continue
+        if column == 'name':
+            continue
+        if column == 'parent' and parsed.kind is not KIND.VARIABLE:
+            continue
+        if column == 'data':
+            if parsed.kind in (KIND.STRUCT, KIND.UNION):
+                column = 'members'
+            elif parsed.kind is KIND.ENUM:
+                column = 'enumerators'
+            elif parsed.kind is KIND.STATEMENT:
+                column = 'text'
+                data, = data
+            else:
+                column = 'signature'
+                data, = data
+            if not data:
+#                yield f'\t{column}:\t-'
+                continue
+            elif isinstance(data, str):
+                yield f'\t{column}:\t{data!r}'
+            else:
+                yield f'\t{column}:'
+                for line in data:
+                    yield f'\t\t- {line}'
+        else:
+            yield f'\t{column}:\t{info}'
+
+
+_FORMATS = {
+    'raw': (lambda v, _d: [repr(v)]),
+    'brief': _fmt_line,
+    'line': _fmt_line,
+    'full': _fmt_full,
+}
+
+
+### declarations ##
+
+class Declaration(HighlevelParsedItem):
+
+    @classmethod
+    def from_row(cls, row, **markers):
+        fixed = tuple(_tables.fix_row(row, **markers))
+        if cls is Declaration:
+            _, _, _, kind, _ = fixed
+            sub = KIND_CLASSES.get(KIND(kind))
+            if not sub or not issubclass(sub, Declaration):
+                raise TypeError(f'unsupported kind, got {row!r}')
+        else:
+            sub = cls
+        return sub._from_row(fixed)
+
+    @classmethod
+    def _from_row(cls, row):
+        filename, funcname, name, kind, data = row
+        kind = KIND._from_raw(kind)
+        if kind is not cls.kind:
+            raise TypeError(f'expected kind {cls.kind.value!r}, got {row!r}')
+        fileinfo = FileInfo.from_raw(filename)
+        if isinstance(data, str):
+            data, extra = cls._parse_data(data, fmt='row')
+        if extra:
+            return cls(fileinfo, name, data, funcname, _extra=extra)
+        else:
+            return cls(fileinfo, name, data, funcname)
+
+    @classmethod
+    def _resolve_parent(cls, parsed, *, _kind=None):
+        if _kind is None:
+            raise TypeError(f'{cls.kind.value} declarations do not have parents ({parsed})')
+        return super()._resolve_parent(parsed, _kind=_kind)
+
+    @classmethod
+    def _render_data(cls, fmt, data, extra):
+        if not data:
+            # XXX There should be some!  Forward?
+            yield '???'
+        else:
+            yield from cls._format_data(fmt, data, extra)
+
+    @classmethod
+    def _render_data_row_item(cls, colname, data, extra):
+        if colname == 'data':
+            return cls._format_data('row', data, extra)
+        else:
+            return None
+
+    @classmethod
+    def _format_data(cls, fmt, data, extra):
+        raise NotImplementedError(fmt)
+
+    @classmethod
+    def _parse_data(cls, datastr, fmt=None):
+        """This is the reverse of _render_data."""
+        if not datastr or datastr is _tables.UNKNOWN or datastr == '???':
+            return None, None
+        elif datastr is _tables.EMPTY or datastr == '-':
+            # All the kinds have *something* even it is unknown.
+            raise TypeError('all declarations have data of some sort, got none')
+        else:
+            return cls._unformat_data(datastr, fmt)
+
+    @classmethod
+    def _unformat_data(cls, datastr, fmt=None):
+        raise NotImplementedError(fmt)
+
+
+class VarType(namedtuple('VarType', 'typequal typespec abstract')):
+
+    @classmethod
+    def from_str(cls, text):
+        orig = text
+        storage, sep, text = text.strip().partition(' ')
+        if not sep:
+            text = storage
+            storage = None
+        elif storage not in ('auto', 'register', 'static', 'extern'):
+            text = orig
+            storage = None
+        return cls._from_str(text), storage
+
+    @classmethod
+    def _from_str(cls, text):
+        orig = text
+        if text.startswith(('const ', 'volatile ')):
+            typequal, _, text = text.partition(' ')
+        else:
+            typequal = None
+
+        # Extract a series of identifiers/keywords.
+        m = re.match(r"^ *'?([a-zA-Z_]\w*(?:\s+[a-zA-Z_]\w*)*)\s*(.*?)'?\s*$", text)
+        if not m:
+            raise ValueError(f'invalid vartype text {orig!r}')
+        typespec, abstract = m.groups()
+
+        return cls(typequal, typespec, abstract or None)
+
+    def __str__(self):
+        parts = []
+        if self.qualifier:
+            parts.append(self.qualifier)
+        parts.append(self.spec + (self.abstract or ''))
+        return ' '.join(parts)
+
+    @property
+    def qualifier(self):
+        return self.typequal
+
+    @property
+    def spec(self):
+        return self.typespec
+
+
+class Variable(Declaration):
+    kind = KIND.VARIABLE
+
+    @classmethod
+    def _resolve_parent(cls, parsed):
+        return super()._resolve_parent(parsed, _kind=KIND.FUNCTION)
+
+    @classmethod
+    def _resolve_data(cls, data):
+        if not data:
+            return None, None
+        storage, vartype = _get_vartype(data)
+        return VarType(**vartype), {'storage': storage}
+
+    @classmethod
+    def _raw_data(self, data, extra):
+        vartype = data._asdict()
+        return {
+            'storage': extra['storage'],
+            'vartype': vartype,
+        }
+
+    @classmethod
+    def _format_data(cls, fmt, data, extra):
+        storage = extra.get('storage')
+        text = f'{storage} {data}' if storage else str(data)
+        if fmt in ('line', 'brief'):
+            yield text
+        #elif fmt == 'full':
+        elif fmt == 'row':
+            yield text
+        else:
+            raise NotImplementedError(fmt)
+
+    @classmethod
+    def _unformat_data(cls, datastr, fmt=None):
+        if fmt in ('line', 'brief'):
+            vartype, storage = VarType.from_str(datastr)
+            return vartype, {'storage': storage}
+        #elif fmt == 'full':
+        elif fmt == 'row':
+            vartype, storage = VarType.from_str(datastr)
+            return vartype, {'storage': storage}
+        else:
+            raise NotImplementedError(fmt)
+
+    def __init__(self, file, name, data, parent=None, storage=None):
+        super().__init__(file, name, data, parent,
+                         _extra={'storage': storage},
+                         _shortkey=f'({parent.name}).{name}' if parent else name,
+                         _key=(str(file),
+                               # Tilde comes after all other ascii characters.
+                               f'~{parent or ""}~',
+                               name,
+                               ),
+                         )
+
+    @property
+    def vartype(self):
+        return self.data
+
+
+class Signature(namedtuple('Signature', 'params returntype inline isforward')):
+
+    @classmethod
+    def from_str(cls, text):
+        orig = text
+        storage, sep, text = text.strip().partition(' ')
+        if not sep:
+            text = storage
+            storage = None
+        elif storage not in ('auto', 'register', 'static', 'extern'):
+            text = orig
+            storage = None
+        return cls._from_str(text), storage
+
+    @classmethod
+    def _from_str(cls, text):
+        orig = text
+        inline, sep, text = text.partition('|')
+        if not sep:
+            text = inline
+            inline = None
+
+        isforward = False
+        if text.endswith(';'):
+            text = text[:-1]
+            isforward = True
+        elif text.endswith('{}'):
+            text = text[:-2]
+
+        index = text.rindex('(')
+        if index < 0:
+            raise ValueError(f'bad signature text {orig!r}')
+        params = text[index:]
+        while params.count('(') <= params.count(')'):
+            index = text.rindex('(', 0, index)
+            if index < 0:
+                raise ValueError(f'bad signature text {orig!r}')
+            params = text[index:]
+        text = text[:index]
+
+        returntype = VarType._from_str(text.rstrip())
+
+        return cls(params, returntype, inline, isforward)
+
+    def __str__(self):
+        parts = []
+        if self.inline:
+            parts.extend([
+                self.inline,
+                '|',
+            ])
+        parts.extend([
+            str(self.returntype),
+            self.params,
+            ';' if self.isforward else '{}',
+        ])
+        return ' '.join(parts)
+
+    @property
+    def returns(self):
+        return self.returntype
+
+
+class Function(Declaration):
+    kind = KIND.FUNCTION
+
+    @classmethod
+    def _resolve_data(cls, data):
+        if not data:
+            return None, None
+        kwargs = dict(data)
+        returntype = dict(data['returntype'])
+        del returntype['storage']
+        kwargs['returntype'] = VarType(**returntype)
+        storage = kwargs.pop('storage')
+        return Signature(**kwargs), {'storage': storage}
+
+    @classmethod
+    def _raw_data(self, data):
+        # XXX finsh!
+        return data
+
+    @classmethod
+    def _format_data(cls, fmt, data, extra):
+        storage = extra.get('storage')
+        text = f'{storage} {data}' if storage else str(data)
+        if fmt in ('line', 'brief'):
+            yield text
+        #elif fmt == 'full':
+        elif fmt == 'row':
+            yield text
+        else:
+            raise NotImplementedError(fmt)
+
+    @classmethod
+    def _unformat_data(cls, datastr, fmt=None):
+        if fmt in ('line', 'brief'):
+            sig, storage = Signature.from_str(sig)
+            return sig, {'storage': storage}
+        #elif fmt == 'full':
+        elif fmt == 'row':
+            sig, storage = Signature.from_str(sig)
+            return sig, {'storage': storage}
+        else:
+            raise NotImplementedError(fmt)
+
+    def __init__(self, file, name, data, parent=None, storage=None):
+        super().__init__(file, name, data, parent, _extra={'storage': storage})
+        self._shortkey = f'~{name}~ {self.data}'
+        self._key = (
+            str(file),
+            self._shortkey,
+        )
+
+    @property
+    def signature(self):
+        return self.data
+
+
+class TypeDeclaration(Declaration):
+
+    def __init__(self, file, name, data, parent=None, *, _shortkey=None):
+        if not _shortkey:
+            _shortkey = f'{self.kind.value} {name}'
+        super().__init__(file, name, data, parent,
+                         _shortkey=_shortkey,
+                         _key=(
+                             str(file),
+                             _shortkey,
+                             ),
+                         )
+
+
+class POTSType(TypeDeclaration):
+
+    def __init__(self, name):
+        _file = _data = _parent = None
+        super().__init__(_file, name, _data, _parent, _shortkey=name)
+
+
+class FuncPtr(TypeDeclaration):
+
+    def __init__(self, vartype):
+        _file = _name = _parent = None
+        data = vartype
+        self.vartype = vartype
+        super().__init__(_file, _name, data, _parent, _shortkey=f'<{vartype}>')
+
+
+class TypeDef(TypeDeclaration):
+    kind = KIND.TYPEDEF
+
+    @classmethod
+    def _resolve_data(cls, data):
+        if not data:
+            raise NotImplementedError(data)
+        vartype = dict(data)
+        del vartype['storage']
+        return VarType(**vartype), None
+
+    @classmethod
+    def _raw_data(self, data):
+        # XXX finish!
+        return data
+
+    @classmethod
+    def _format_data(cls, fmt, data, extra):
+        text = str(data)
+        if fmt in ('line', 'brief'):
+            yield text
+        elif fmt == 'full':
+            yield text
+        elif fmt == 'row':
+            yield text
+        else:
+            raise NotImplementedError(fmt)
+
+    @classmethod
+    def _unformat_data(cls, datastr, fmt=None):
+        if fmt in ('line', 'brief'):
+            vartype, _ = VarType.from_str(datastr)
+            return vartype, None
+        #elif fmt == 'full':
+        elif fmt == 'row':
+            vartype, _ = VarType.from_str(datastr)
+            return vartype, None
+        else:
+            raise NotImplementedError(fmt)
+
+    def __init__(self, file, name, data, parent=None):
+        super().__init__(file, name, data, parent, _shortkey=name)
+
+    @property
+    def vartype(self):
+        return self.data
+
+
+class Member(namedtuple('Member', 'name vartype size')):
+
+    @classmethod
+    def from_data(cls, raw, index):
+        name = raw.name if raw.name else index
+        vartype = size = None
+        if type(raw.data) is int:
+            size = raw.data
+        elif isinstance(raw.data, str):
+            size = int(raw.data)
+        elif raw.data:
+            vartype = dict(raw.data)
+            del vartype['storage']
+            if 'size' in vartype:
+                size = int(vartype.pop('size'))
+            vartype = VarType(**vartype)
+        return cls(name, vartype, size)
+
+    @classmethod
+    def from_str(cls, text):
+        name, _, vartype = text.partition(': ')
+        if name.startswith('#'):
+            name = int(name[1:])
+        if vartype.isdigit():
+            size = int(vartype)
+            vartype = None
+        else:
+            vartype, _ = VarType.from_str(vartype)
+            size = None
+        return cls(name, vartype, size)
+
+    def __str__(self):
+        name = self.name if isinstance(self.name, str) else f'#{self.name}'
+        return f'{name}: {self.vartype or self.size}'
+
+
+class _StructUnion(TypeDeclaration):
+
+    @classmethod
+    def _resolve_data(cls, data):
+        if not data:
+            # XXX There should be some!  Forward?
+            return None, None
+        return [Member.from_data(v, i) for i, v in enumerate(data)], None
+
+    @classmethod
+    def _raw_data(self, data):
+        # XXX finish!
+        return data
+
+    @classmethod
+    def _format_data(cls, fmt, data, extra):
+        if fmt in ('line', 'brief'):
+            members = ', '.join(f'<{m}>' for m in data)
+            yield f'[{members}]'
+        elif fmt == 'full':
+            for member in data:
+                yield f'{member}'
+        elif fmt == 'row':
+            members = ', '.join(f'<{m}>' for m in data)
+            yield f'[{members}]'
+        else:
+            raise NotImplementedError(fmt)
+
+    @classmethod
+    def _unformat_data(cls, datastr, fmt=None):
+        if fmt in ('line', 'brief'):
+            members = [Member.from_str(m[1:-1])
+                       for m in datastr[1:-1].split(', ')]
+            return members, None
+        #elif fmt == 'full':
+        elif fmt == 'row':
+            members = [Member.from_str(m.rstrip('>').lstrip('<'))
+                       for m in datastr[1:-1].split('>, <')]
+            return members, None
+        else:
+            raise NotImplementedError(fmt)
+
+    def __init__(self, file, name, data, parent=None):
+        super().__init__(file, name, data, parent)
+
+    @property
+    def members(self):
+        return self.data
+
+
+class Struct(_StructUnion):
+    kind = KIND.STRUCT
+
+
+class Union(_StructUnion):
+    kind = KIND.UNION
+
+
+class Enum(TypeDeclaration):
+    kind = KIND.ENUM
+
+    @classmethod
+    def _resolve_data(cls, data):
+        if not data:
+            # XXX There should be some!  Forward?
+            return None, None
+        enumerators = [e if isinstance(e, str) else e.name
+                       for e in data]
+        return enumerators, None
+
+    @classmethod
+    def _raw_data(self, data):
+        # XXX finsih!
+        return data
+
+    @classmethod
+    def _format_data(cls, fmt, data, extra):
+        if fmt in ('line', 'brief'):
+            yield repr(data)
+        elif fmt == 'full':
+            for enumerator in data:
+                yield f'{enumerator}'
+        elif fmt == 'row':
+            # XXX This won't work with CSV...
+            yield ','.join(data)
+        else:
+            raise NotImplementedError(fmt)
+
+    @classmethod
+    def _unformat_data(cls, datastr, fmt=None):
+        if fmt in ('line', 'brief'):
+            return _strutil.unrepr(datastr), None
+        #elif fmt == 'full':
+        elif fmt == 'row':
+            return datastr.split(','), None
+        else:
+            raise NotImplementedError(fmt)
+
+    def __init__(self, file, name, data, parent=None):
+        super().__init__(file, name, data, parent)
+
+    @property
+    def enumerators(self):
+        return self.data
+
+
+### statements ###
+
+class Statement(HighlevelParsedItem):
+    kind = KIND.STATEMENT
+
+    @classmethod
+    def _resolve_data(cls, data):
+        # XXX finsih!
+        return data, None
+
+    @classmethod
+    def _raw_data(self, data):
+        # XXX finsih!
+        return data
+
+    @classmethod
+    def _render_data(cls, fmt, data, extra):
+        # XXX Handle other formats?
+        return repr(data)
+
+    @classmethod
+    def _parse_data(self, datastr, fmt=None):
+        # XXX Handle other formats?
+        return _strutil.unrepr(datastr), None
+
+    def __init__(self, file, name, data, parent=None):
+        super().__init__(file, name, data, parent,
+                         _shortkey=data or '',
+                         _key=(
+                             str(file),
+                             file.lno,
+                             # XXX Only one stmt per line?
+                             ),
+                         )
+
+    @property
+    def text(self):
+        return self.data
+
+
+###
+
+KIND_CLASSES = {cls.kind: cls for cls in [
+    Variable,
+    Function,
+    TypeDef,
+    Struct,
+    Union,
+    Enum,
+    Statement,
+]}
+
+
+def resolve_parsed(parsed):
+    if isinstance(parsed, HighlevelParsedItem):
+        return parsed
+    try:
+        cls = KIND_CLASSES[parsed.kind]
+    except KeyError:
+        raise ValueError(f'unsupported kind in {parsed!r}')
+    return cls.from_parsed(parsed)
+
+
+#############################
+# composite
+
+class Declarations:
+
+    @classmethod
+    def from_decls(cls, decls):
+        return cls(decls)
+
+    @classmethod
+    def from_parsed(cls, items):
+        decls = (resolve_parsed(item)
+                 for item in items
+                 if item.kind is not KIND.STATEMENT)
+        return cls.from_decls(decls)
+
+    @classmethod
+    def _resolve_key(cls, raw):
+        if isinstance(raw, str):
+            raw = [raw]
+        elif isinstance(raw, Declaration):
+            raw = (
+                raw.filename if cls._is_public(raw) else None,
+                # `raw.parent` is always None for types and functions.
+                raw.parent if raw.kind is KIND.VARIABLE else None,
+                raw.name,
+            )
+
+        extra = None
+        if len(raw) == 1:
+            name, = raw
+            if name:
+                name = str(name)
+                if name.endswith(('.c', '.h')):
+                    # This is only legit as a query.
+                    key = (name, None, None)
+                else:
+                    key = (None, None, name)
+            else:
+                key = (None, None, None)
+        elif len(raw) == 2:
+            parent, name = raw
+            name = str(name)
+            if isinstance(parent, Declaration):
+                key = (None, parent.name, name)
+            elif not parent:
+                key = (None, None, name)
+            else:
+                parent = str(parent)
+                if parent.endswith(('.c', '.h')):
+                    key = (parent, None, name)
+                else:
+                    key = (None, parent, name)
+        else:
+            key, extra = raw[:3], raw[3:]
+            filename, funcname, name = key
+            filename = str(filename) if filename else None
+            if isinstance(funcname, Declaration):
+                funcname = funcname.name
+            else:
+                funcname = str(funcname) if funcname else None
+            name = str(name) if name else None
+            key = (filename, funcname, name)
+        return key, extra
+
+    @classmethod
+    def _is_public(cls, decl):
+        # For .c files don't we need info from .h files to make this decision?
+        # XXX Check for "extern".
+        # For now we treat all decls a "private" (have filename set).
+        return False
+
+    def __init__(self, decls):
+        # (file, func, name) -> decl
+        # "public":
+        #   * (None, None, name)
+        # "private", "global":
+        #   * (file, None, name)
+        # "private", "local":
+        #   * (file, func, name)
+        if hasattr(decls, 'items'):
+            self._decls = decls
+        else:
+            self._decls = {}
+            self._extend(decls)
+
+        # XXX always validate?
+
+    def validate(self):
+        for key, decl in self._decls.items():
+            if type(key) is not tuple or len(key) != 3:
+                raise ValueError(f'expected 3-tuple key, got {key!r} (for decl {decl!r})')
+            filename, funcname, name = key
+            if not name:
+                raise ValueError(f'expected name in key, got {key!r} (for decl {decl!r})')
+            elif type(name) is not str:
+                raise ValueError(f'expected name in key to be str, got {key!r} (for decl {decl!r})')
+            # XXX Check filename type?
+            # XXX Check funcname type?
+
+            if decl.kind is KIND.STATEMENT:
+                raise ValueError(f'expected a declaration, got {decl!r}')
+
+    def __repr__(self):
+        return f'{type(self).__name__}({list(self)})'
+
+    def __len__(self):
+        return len(self._decls)
+
+    def __iter__(self):
+        yield from self._decls
+
+    def __getitem__(self, key):
+        # XXX Be more exact for the 3-tuple case?
+        if type(key) not in (str, tuple):
+            raise KeyError(f'unsupported key {key!r}')
+        resolved, extra = self._resolve_key(key)
+        if extra:
+            raise KeyError(f'key must have at most 3 parts, got {key!r}')
+        if not resolved[2]:
+            raise ValueError(f'expected name in key, got {key!r}')
+        try:
+            return self._decls[resolved]
+        except KeyError:
+            if type(key) is tuple and len(key) == 3:
+                filename, funcname, name = key
+            else:
+                filename, funcname, name = resolved
+            if filename and not filename.endswith(('.c', '.h')):
+                raise KeyError(f'invalid filename in key {key!r}')
+            elif funcname and funcname.endswith(('.c', '.h')):
+                raise KeyError(f'invalid funcname in key {key!r}')
+            elif name and name.endswith(('.c', '.h')):
+                raise KeyError(f'invalid name in key {key!r}')
+            else:
+                raise  # re-raise
+
+    @property
+    def types(self):
+        return self._find(kind=KIND.TYPES)
+
+    @property
+    def functions(self):
+        return self._find(None, None, None, KIND.FUNCTION)
+
+    @property
+    def variables(self):
+        return self._find(None, None, None, KIND.VARIABLE)
+
+    def iter_all(self):
+        yield from self._decls.values()
+
+    def get(self, key, default=None):
+        try:
+           return self[key]
+        except KeyError:
+            return default
+
+    #def add_decl(self, decl, key=None):
+    #    decl = _resolve_parsed(decl)
+    #    self._add_decl(decl, key)
+
+    def find(self, *key, **explicit):
+        if not key:
+            if not explicit:
+                return iter(self)
+            return self._find(**explicit)
+
+        resolved, extra = self._resolve_key(key)
+        filename, funcname, name = resolved
+        if not extra:
+            kind = None
+        elif len(extra) == 1:
+            kind, = extra
+        else:
+            raise KeyError(f'key must have at most 4 parts, got {key!r}')
+
+        implicit= {}
+        if filename:
+            implicit['filename'] = filename
+        if funcname:
+            implicit['funcname'] = funcname
+        if name:
+            implicit['name'] = name
+        if kind:
+            implicit['kind'] = kind
+        return self._find(**implicit, **explicit)
+
+    def _find(self, filename=None, funcname=None, name=None, kind=None):
+        for decl in self._decls.values():
+            if filename and decl.filename != filename:
+                continue
+            if funcname:
+                if decl.kind is not KIND.VARIABLE:
+                    continue
+                if decl.parent.name != funcname:
+                    continue
+            if name and decl.name != name:
+                continue
+            if kind:
+                kinds = KIND.resolve_group(kind)
+                if decl.kind not in kinds:
+                    continue
+            yield decl
+
+    def _add_decl(self, decl, key=None):
+        if key:
+            if type(key) not in (str, tuple):
+                raise NotImplementedError((key, decl))
+            # Any partial key will be turned into a full key, but that
+            # same partial key will still match a key lookup.
+            resolved, _ = self._resolve_key(key)
+            if not resolved[2]:
+                raise ValueError(f'expected name in key, got {key!r}')
+            key = resolved
+            # XXX Also add with the decl-derived key if not the same?
+        else:
+            key, _ = self._resolve_key(decl)
+        self._decls[key] = decl
+
+    def _extend(self, decls):
+        decls = iter(decls)
+        # Check only the first item.
+        for decl in decls:
+            if isinstance(decl, Declaration):
+                self._add_decl(decl)
+                # Add the rest without checking.
+                for decl in decls:
+                    self._add_decl(decl)
+            elif isinstance(decl, HighlevelParsedItem):
+                raise NotImplementedError(decl)
+            else:
+                try:
+                    key, decl = decl
+                except ValueError:
+                    raise NotImplementedError(decl)
+                if not isinstance(decl, Declaration):
+                    raise NotImplementedError(decl)
+                self._add_decl(decl, key)
+                # Add the rest without checking.
+                for key, decl in decls:
+                    self._add_decl(decl, key)
+            # The iterator will be exhausted at this point.
diff --git a/Tools/c-analyzer/c_parser/parser/__init__.py b/Tools/c-analyzer/c_parser/parser/__init__.py
new file mode 100644
index 00000000000..7cb34caf09e
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/parser/__init__.py
@@ -0,0 +1,212 @@
+"""A simple non-validating parser for C99.
+
+The functions and regex patterns here are not entirely suitable for
+validating C syntax.  Please rely on a proper compiler for that.
+Instead our goal here is merely matching and extracting information from
+valid C code.
+
+Furthermore, the grammar rules for the C syntax (particularly as
+described in the K&R book) actually describe a superset, of which the
+full C langage is a proper subset.  Here are some of the extra
+conditions that must be applied when parsing C code:
+
+* ...
+
+(see: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1256.pdf)
+
+We have taken advantage of the elements of the C grammar that are used
+only in a few limited contexts, mostly as delimiters.  They allow us to
+focus the regex patterns confidently.  Here are the relevant tokens and
+in which grammar rules they are used:
+
+separators:
+* ";"
+   + (decl) struct/union:  at end of each member decl
+   + (decl) declaration:  at end of each (non-compound) decl
+   + (stmt) expr stmt:  at end of each stmt
+   + (stmt) for:  between exprs in "header"
+   + (stmt) goto:  at end
+   + (stmt) continue:  at end
+   + (stmt) break:  at end
+   + (stmt) return:  at end
+* ","
+   + (decl) struct/union:  between member declators
+   + (decl) param-list:  between params
+   + (decl) enum: between enumerators
+   + (decl) initializer (compound):  between initializers
+   + (expr) postfix:  between func call args
+   + (expr) expression:  between "assignment" exprs
+* ":"
+   + (decl) struct/union:  in member declators
+   + (stmt) label:  between label and stmt
+   + (stmt) case:  between expression and stmt
+   + (stmt) default:  between "default" and stmt
+* "="
+   + (decl) delaration:  between decl and initializer
+   + (decl) enumerator:  between identifier and "initializer"
+   + (expr) assignment:  between "var" and expr
+
+wrappers:
+* "(...)"
+   + (decl) declarator (func ptr):  to wrap ptr/name
+   + (decl) declarator (func ptr):  around params
+   + (decl) declarator:  around sub-declarator (for readability)
+   + (expr) postfix (func call):  around args
+   + (expr) primary:  around sub-expr
+   + (stmt) if:  around condition
+   + (stmt) switch:  around source expr
+   + (stmt) while:  around condition
+   + (stmt) do-while:  around condition
+   + (stmt) for:  around "header"
+* "{...}"
+   + (decl) enum:  around enumerators
+   + (decl) func:  around body
+   + (stmt) compound:  around stmts
+* "[...]"
+   * (decl) declarator:  for arrays
+   * (expr) postfix:  array access
+
+other:
+* "*"
+   + (decl) declarator:  for pointer types
+   + (expr) unary:  for pointer deref
+
+
+To simplify the regular expressions used here, we've takens some
+shortcuts and made certain assumptions about the code we are parsing.
+Some of these allow us to skip context-sensitive matching (e.g. braces)
+or otherwise still match arbitrary C code unambiguously.  However, in
+some cases there are certain corner cases where the patterns are
+ambiguous relative to arbitrary C code.  However, they are still
+unambiguous in the specific code we are parsing.
+
+Here are the cases where we've taken shortcuts or made assumptions:
+
+* there is no overlap syntactically between the local context (func
+  bodies) and the global context (other than variable decls), so we
+  do not need to worry about ambiguity due to the overlap:
+   + the global context has no expressions or statements
+   + the local context has no function definitions or type decls
+* no "inline" type declarations (struct, union, enum) in function
+  parameters ~(including function pointers)~
+* no "inline" type decls in function return types
+* no superflous parentheses in declarators
+* var decls in for loops are always "simple" (e.g. no inline types)
+* only inline struct/union/enum decls may be anonymouns (without a name)
+* no function pointers in function pointer parameters
+* for loop "headers" do not have curly braces (e.g. compound init)
+* syntactically, variable decls do not overlap with stmts/exprs, except
+  in the following case:
+    spam (*eggs) (...)
+  This could be either a function pointer variable named "eggs"
+  or a call to a function named "spam", which returns a function
+  pointer that gets called.  The only differentiator is the
+  syntax used in the "..." part.  It will be comma-separated
+  parameters for the former and comma-separated expressions for
+  the latter.  Thus, if we expect such decls or calls then we must
+  parse the decl params.
+"""
+
+"""
+TODO:
+* extract CPython-specific code
+* drop include injection (or only add when needed)
+* track position instead of slicing "text"
+* Parser class instead of the _iter_source() mess
+* alt impl using a state machine (& tokenizer or split on delimiters)
+"""
+
+from ..info import ParsedItem
+from ._info import SourceInfo
+
+
+def parse(srclines):
+    if isinstance(srclines, str):  # a filename
+        raise NotImplementedError
+
+    anon_name = anonymous_names()
+    for result in _parse(srclines, anon_name):
+        yield ParsedItem.from_raw(result)
+
+
+# XXX Later: Add a separate function to deal with preprocessor directives
+# parsed out of raw source.
+
+
+def anonymous_names():
+    counter = 1
+    def anon_name(prefix='anon-'):
+        nonlocal counter
+        name = f'{prefix}{counter}'
+        counter += 1
+        return name
+    return anon_name
+
+
+#############################
+# internal impl
+
+import logging
+
+
+_logger = logging.getLogger(__name__)
+
+
+def _parse(srclines, anon_name):
+    from ._global import parse_globals
+
+    source = _iter_source(srclines)
+    #source = _iter_source(srclines, showtext=True)
+    for result in parse_globals(source, anon_name):
+        # XXX Handle blocks here insted of in parse_globals().
+        yield result
+
+
+def _iter_source(lines, *, maxtext=20_000, maxlines=700, showtext=False):
+    filestack = []
+    allinfo = {}
+    # "lines" should be (fileinfo, data), as produced by the preprocessor code.
+    for fileinfo, line in lines:
+        if fileinfo.filename in filestack:
+            while fileinfo.filename != filestack[-1]:
+                filename = filestack.pop()
+                del allinfo[filename]
+            filename = fileinfo.filename
+            srcinfo = allinfo[filename]
+        else:
+            filename = fileinfo.filename
+            srcinfo = SourceInfo(filename)
+            filestack.append(filename)
+            allinfo[filename] = srcinfo
+
+        _logger.debug(f'-> {line}')
+        srcinfo._add_line(line, fileinfo.lno)
+        if len(srcinfo.text) > maxtext:
+            break
+        if srcinfo.end - srcinfo.start > maxlines:
+            break
+        while srcinfo._used():
+            yield srcinfo
+            if showtext:
+                _logger.debug(f'=> {srcinfo.text}')
+    else:
+        if not filestack:
+            srcinfo = SourceInfo('???')
+        else:
+            filename = filestack[-1]
+            srcinfo = allinfo[filename]
+            while srcinfo._used():
+                yield srcinfo
+                if showtext:
+                    _logger.debug(f'=> {srcinfo.text}')
+        yield srcinfo
+        if showtext:
+            _logger.debug(f'=> {srcinfo.text}')
+        if not srcinfo._ready:
+            return
+    # At this point either the file ended prematurely
+    # or there's "too much" text.
+    filename, lno, text = srcinfo.filename, srcinfo._start, srcinfo.text
+    if len(text) > 500:
+        text = text[:500] + '...'
+    raise Exception(f'unmatched text ({filename} starting at line {lno}):\n{text}')
diff --git a/Tools/c-analyzer/c_parser/parser/_alt.py b/Tools/c-analyzer/c_parser/parser/_alt.py
new file mode 100644
index 00000000000..05a9101b4f5
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/parser/_alt.py
@@ -0,0 +1,6 @@
+
+def _parse(srclines, anon_name):
+    text = ' '.join(l for _, l in srclines)
+
+    from ._delim import parse
+    yield from parse(text, anon_name)
diff --git a/Tools/c-analyzer/c_parser/parser/_common.py b/Tools/c-analyzer/c_parser/parser/_common.py
new file mode 100644
index 00000000000..40c36039f3f
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/parser/_common.py
@@ -0,0 +1,115 @@
+import re
+
+from ._regexes import (
+    _ind,
+    STRING_LITERAL,
+    VAR_DECL as _VAR_DECL,
+)
+
+
+def log_match(group, m):
+    from . import _logger
+    _logger.debug(f'matched <{group}> ({m.group(0)})')
+
+
+#############################
+# regex utils
+
+def set_capture_group(pattern, group, *, strict=True):
+    old = f'(?:  # <{group}>'
+    if strict and f'(?:  # <{group}>' not in pattern:
+        raise ValueError(f'{old!r} not found in pattern')
+    return pattern.replace(old, f'(  # <{group}>', 1)
+
+
+def set_capture_groups(pattern, groups, *, strict=True):
+    for group in groups:
+        pattern = set_capture_group(pattern, group, strict=strict)
+    return pattern
+
+
+#############################
+# syntax-related utils
+
+_PAREN_RE = re.compile(rf'''
+    (?:
+        (?:
+            [^'"()]*
+            {_ind(STRING_LITERAL, 3)}
+         )*
+        [^'"()]*
+        (?:
+            ( [(] )
+            |
+            ( [)] )
+         )
+     )
+    ''', re.VERBOSE)
+
+
+def match_paren(text, depth=0):
+    pos = 0
+    while (m := _PAREN_RE.match(text, pos)):
+        pos = m.end()
+        _open, _close = m.groups()
+        if _open:
+            depth += 1
+        else:  # _close
+            depth -= 1
+            if depth == 0:
+                return pos
+    else:
+        raise ValueError(f'could not find matching parens for {text!r}')
+
+
+VAR_DECL = set_capture_groups(_VAR_DECL, (
+    'STORAGE',
+    'TYPE_QUAL',
+    'TYPE_SPEC',
+    'DECLARATOR',
+    'IDENTIFIER',
+    'WRAPPED_IDENTIFIER',
+    'FUNC_IDENTIFIER',
+))
+
+
+def parse_var_decl(decl):
+    m = re.match(VAR_DECL, decl, re.VERBOSE)
+    (storage, typequal, typespec, declarator,
+     name,
+     wrappedname,
+     funcptrname,
+     ) = m.groups()
+    if name:
+        kind = 'simple'
+    elif wrappedname:
+        kind = 'wrapped'
+        name = wrappedname
+    elif funcptrname:
+        kind = 'funcptr'
+        name = funcptrname
+    else:
+        raise NotImplementedError
+    abstract = declarator.replace(name, '')
+    vartype = {
+        'storage': storage,
+        'typequal': typequal,
+        'typespec': typespec,
+        'abstract': abstract,
+    }
+    return (kind, name, vartype)
+
+
+#############################
+# parser state utils
+
+# XXX Drop this or use it!
+def iter_results(results):
+    if not results:
+        return
+    if callable(results):
+        results = results()
+
+    for result, text in results():
+        if result:
+            yield result, text
diff --git a/Tools/c-analyzer/c_parser/parser/_compound_decl_body.py b/Tools/c-analyzer/c_parser/parser/_compound_decl_body.py
new file mode 100644
index 00000000000..eb5bc67607b
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/parser/_compound_decl_body.py
@@ -0,0 +1,158 @@
+import re
+
+from ._regexes import (
+    STRUCT_MEMBER_DECL as _STRUCT_MEMBER_DECL,
+    ENUM_MEMBER_DECL as _ENUM_MEMBER_DECL,
+)
+from ._common import (
+    log_match,
+    parse_var_decl,
+    set_capture_groups,
+)
+
+
+#############################
+# struct / union
+
+STRUCT_MEMBER_DECL = set_capture_groups(_STRUCT_MEMBER_DECL, (
+    'COMPOUND_TYPE_KIND',
+    'COMPOUND_TYPE_NAME',
+    'SPECIFIER_QUALIFIER',
+    'DECLARATOR',
+    'SIZE',
+    'ENDING',
+    'CLOSE',
+))
+STRUCT_MEMBER_RE = re.compile(rf'^ \s* {STRUCT_MEMBER_DECL}', re.VERBOSE)
+
+
+def parse_struct_body(source, anon_name, parent):
+    done = False
+    while not done:
+        done = True
+        for srcinfo in source:
+            m = STRUCT_MEMBER_RE.match(srcinfo.text)
+            if m:
+                break
+        else:
+            # We ran out of lines.
+            if srcinfo is not None:
+                srcinfo.done()
+            return
+        for item in _parse_struct_next(m, srcinfo, anon_name, parent):
+            if callable(item):
+                parse_body = item
+                yield from parse_body(source)
+            else:
+                yield item
+            done = False
+
+
+def _parse_struct_next(m, srcinfo, anon_name, parent):
+    (inline_kind, inline_name,
+     qualspec, declarator,
+     size,
+     ending,
+     close,
+     ) = m.groups()
+    remainder = srcinfo.text[m.end():]
+
+    if close:
+        log_match('compound close', m)
+        srcinfo.advance(remainder)
+
+    elif inline_kind:
+        log_match('compound inline', m)
+        kind = inline_kind
+        name = inline_name or anon_name('inline-')
+        # Immediately emit a forward declaration.
+        yield srcinfo.resolve(kind, name=name, data=None)
+
+        # un-inline the decl.  Note that it might not actually be inline.
+        # We handle the case in the "maybe_inline_actual" branch.
+        srcinfo.nest(
+            remainder,
+            f'{kind} {name}',
+        )
+        def parse_body(source):
+            _parse_body = DECL_BODY_PARSERS[kind]
+
+            data = []  # members
+            ident = f'{kind} {name}'
+            for item in _parse_body(source, anon_name, ident):
+                if item.kind == 'field':
+                    data.append(item)
+                else:
+                    yield item
+            # XXX Should "parent" really be None for inline type decls?
+            yield srcinfo.resolve(kind, data, name, parent=None)
+
+            srcinfo.resume()
+        yield parse_body
+
+    else:
+        # not inline (member)
+        log_match('compound member', m)
+        if qualspec:
+            _, name, data = parse_var_decl(f'{qualspec} {declarator}')
+            if not name:
+                name = anon_name('struct-field-')
+            if size:
+#                data = (data, size)
+                data['size'] = int(size)
+        else:
+            # This shouldn't happen (we expect each field to have a name).
+            raise NotImplementedError
+            name = sized_name or anon_name('struct-field-')
+            data = int(size)
+
+        yield srcinfo.resolve('field', data, name, parent)  # XXX Restart?
+        if ending == ',':
+            remainder = rf'{qualspec} {remainder}'
+        srcinfo.advance(remainder)
+
+
+#############################
+# enum
+
+ENUM_MEMBER_DECL = set_capture_groups(_ENUM_MEMBER_DECL, (
+    'CLOSE',
+    'NAME',
+    'INIT',
+    'ENDING',
+))
+ENUM_MEMBER_RE = re.compile(rf'{ENUM_MEMBER_DECL}', re.VERBOSE)
+
+
+def parse_enum_body(source, _anon_name, _parent):
+    ending = None
+    while ending != '}':
+        for srcinfo in source:
+            m = ENUM_MEMBER_RE.match(srcinfo.text)
+            if m:
+                break
+        else:
+            # We ran out of lines.
+            if srcinfo is not None:
+                srcinfo.done()
+            return
+        remainder = srcinfo.text[m.end():]
+
+        (close,
+         name, init, ending,
+         ) = m.groups()
+        if close:
+            ending = '}'
+        else:
+            data = init
+            yield srcinfo.resolve('field', data, name, _parent)
+        srcinfo.advance(remainder)
+
+
+#############################
+
+DECL_BODY_PARSERS = {
+    'struct': parse_struct_body,
+    'union': parse_struct_body,
+    'enum': parse_enum_body,
+}
diff --git a/Tools/c-analyzer/c_parser/parser/_delim.py b/Tools/c-analyzer/c_parser/parser/_delim.py
new file mode 100644
index 00000000000..51433a629d3
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/parser/_delim.py
@@ -0,0 +1,54 @@
+import re
+import textwrap
+
+from ._regexes import _ind, STRING_LITERAL
+
+
+def parse(text, anon_name):
+    context = None
+    data = None
+    for m in DELIMITER_RE.find_iter(text):
+        before, opened, closed = m.groups()
+        delim = opened or closed
+
+        handle_segment = HANDLERS[context][delim]
+        result, context, data = handle_segment(before, delim, data)
+        if result:
+            yield result
+
+
+DELIMITER = textwrap.dedent(rf'''
+    (
+        (?:
+            [^'"()\[\]{};]*
+            {_ind(STRING_LITERAL, 3)}
+        }*
+        [^'"()\[\]{};]+
+     )?  # <before>
+    (?:
+        (
+            [(\[{]
+         )  # <open>
+        |
+        (
+            [)\]};]
+         )  # <close>
+     )?
+    ''')
+DELIMITER_RE = re.compile(DELIMITER, re.VERBOSE)
+
+_HANDLERS = {
+    None: {  # global
+        # opened
+        '{': ...,
+        '[': None,
+        '(': None,
+        # closed
+        '}': None,
+        ']': None,
+        ')': None,
+        ';': ...,
+    },
+    '': {
+    },
+}
diff --git a/Tools/c-analyzer/c_parser/parser/_func_body.py b/Tools/c-analyzer/c_parser/parser/_func_body.py
new file mode 100644
index 00000000000..42fd459e111
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/parser/_func_body.py
@@ -0,0 +1,278 @@
+import re
+
+from ._regexes import (
+    LOCAL as _LOCAL,
+    LOCAL_STATICS as _LOCAL_STATICS,
+)
+from ._common import (
+    log_match,
+    parse_var_decl,
+    set_capture_groups,
+    match_paren,
+)
+from ._compound_decl_body import DECL_BODY_PARSERS
+
+
+LOCAL = set_capture_groups(_LOCAL, (
+    'EMPTY',
+    'INLINE_LEADING',
+    'INLINE_PRE',
+    'INLINE_KIND',
+    'INLINE_NAME',
+    'STORAGE',
+    'VAR_DECL',
+    'VAR_INIT',
+    'VAR_ENDING',
+    'COMPOUND_BARE',
+    'COMPOUND_LABELED',
+    'COMPOUND_PAREN',
+    'BLOCK_LEADING',
+    'BLOCK_OPEN',
+    'SIMPLE_STMT',
+    'SIMPLE_ENDING',
+    'BLOCK_CLOSE',
+))
+LOCAL_RE = re.compile(rf'^ \s* {LOCAL}', re.VERBOSE)
+
+
+# Note that parse_function_body() still has trouble with a few files
+# in the CPython codebase.
+
+def parse_function_body(source, name, anon_name):
+    # XXX
+    raise NotImplementedError
+
+
+def parse_function_body(name, text, resolve, source, anon_name, parent):
+    raise NotImplementedError
+    # For now we do not worry about locals declared in for loop "headers".
+    depth = 1;
+    while depth > 0:
+        m = LOCAL_RE.match(text)
+        while not m:
+            text, resolve = continue_text(source, text or '{', resolve)
+            m = LOCAL_RE.match(text)
+        text = text[m.end():]
+        (
+         empty,
+         inline_leading, inline_pre, inline_kind, inline_name,
+         storage, decl,
+         var_init, var_ending,
+         compound_bare, compound_labeled, compound_paren,
+         block_leading, block_open,
+         simple_stmt, simple_ending,
+         block_close,
+         ) = m.groups()
+
+        if empty:
+            log_match('', m)
+            resolve(None, None, None, text)
+            yield None, text
+        elif inline_kind:
+            log_match('', m)
+            kind = inline_kind
+            name = inline_name or anon_name('inline-')
+            data = []  # members
+            # We must set the internal "text" from _iter_source() to the
+            # start of the inline compound body,
+            # Note that this is effectively like a forward reference that
+            # we do not emit.
+            resolve(kind, None, name, text, None)
+            _parse_body = DECL_BODY_PARSERS[kind]
+            before = []
+            ident = f'{kind} {name}'
+            for member, inline, text in _parse_body(text, resolve, source, anon_name, ident):
+                if member:
+                    data.append(member)
+                if inline:
+                    yield from inline
+            # un-inline the decl.  Note that it might not actually be inline.
+            # We handle the case in the "maybe_inline_actual" branch.
+            text = f'{inline_leading or ""} {inline_pre or ""} {kind} {name} {text}'
+            # XXX Should "parent" really be None for inline type decls?
+            yield resolve(kind, data, name, text, None), text
+        elif block_close:
+            log_match('', m)
+            depth -= 1
+            resolve(None, None, None, text)
+            # XXX This isn't great.  Calling resolve() should have
+            # cleared the closing bracket.  However, some code relies
+            # on the yielded value instead of the resolved one.  That
+            # needs to be fixed.
+            yield None, text
+        elif compound_bare:
+            log_match('', m)
+            yield resolve('statement', compound_bare, None, text, parent), text
+        elif compound_labeled:
+            log_match('', m)
+            yield resolve('statement', compound_labeled, None, text, parent), text
+        elif compound_paren:
+            log_match('', m)
+            try:
+                pos = match_paren(text)
+            except ValueError:
+                text = f'{compound_paren} {text}'
+                #resolve(None, None, None, text)
+                text, resolve = continue_text(source, text, resolve)
+                yield None, text
+            else:
+                head = text[:pos]
+                text = text[pos:]
+                if compound_paren == 'for':
+                    # XXX Parse "head" as a compound statement.
+                    stmt1, stmt2, stmt3 = head.split(';', 2)
+                    data = {
+                        'compound': compound_paren,
+                        'statements': (stmt1, stmt2, stmt3),
+                    }
+                else:
+                    data = {
+                        'compound': compound_paren,
+                        'statement': head,
+                    }
+                yield resolve('statement', data, None, text, parent), text
+        elif block_open:
+            log_match('', m)
+            depth += 1
+            if block_leading:
+                # An inline block: the last evaluated expression is used
+                # in place of the block.
+                # XXX Combine it with the remainder after the block close.
+                stmt = f'{block_open}{{<expr>}}...;'
+                yield resolve('statement', stmt, None, text, parent), text
+            else:
+                resolve(None, None, None, text)
+                yield None, text
+        elif simple_ending:
+            log_match('', m)
+            yield resolve('statement', simple_stmt, None, text, parent), text
+        elif var_ending:
+            log_match('', m)
+            kind = 'variable'
+            _, name, vartype = parse_var_decl(decl)
+            data = {
+                'storage': storage,
+                'vartype': vartype,
+            }
+            after = ()
+            if var_ending == ',':
+                # It was a multi-declaration, so queue up the next one.
+                _, qual, typespec, _ = vartype.values()
+                text = f'{storage or ""} {qual or ""} {typespec} {text}'
+            yield resolve(kind, data, name, text, parent), text
+            if var_init:
+                _data = f'{name} = {var_init.strip()}'
+                yield resolve('statement', _data, None, text, parent), text
+        else:
+            # This should be unreachable.
+            raise NotImplementedError
+
+
+#############################
+# static local variables
+
+LOCAL_STATICS = set_capture_groups(_LOCAL_STATICS, (
+    'INLINE_LEADING',
+    'INLINE_PRE',
+    'INLINE_KIND',
+    'INLINE_NAME',
+    'STATIC_DECL',
+    'STATIC_INIT',
+    'STATIC_ENDING',
+    'DELIM_LEADING',
+    'BLOCK_OPEN',
+    'BLOCK_CLOSE',
+    'STMT_END',
+))
+LOCAL_STATICS_RE = re.compile(rf'^ \s* {LOCAL_STATICS}', re.VERBOSE)
+
+
+def parse_function_statics(source, func, anon_name):
+    # For now we do not worry about locals declared in for loop "headers".
+    depth = 1;
+    while depth > 0:
+        for srcinfo in source:
+            m = LOCAL_STATICS_RE.match(srcinfo.text)
+            if m:
+                break
+        else:
+            # We ran out of lines.
+            if srcinfo is not None:
+                srcinfo.done()
+            return
+        for item, depth in _parse_next_local_static(m, srcinfo,
+                                                    anon_name, func, depth):
+            if callable(item):
+                parse_body = item
+                yield from parse_body(source)
+            elif item is not None:
+                yield item
+
+
+def _parse_next_local_static(m, srcinfo, anon_name, func, depth):
+    (inline_leading, inline_pre, inline_kind, inline_name,
+     static_decl, static_init, static_ending,
+     _delim_leading,
+     block_open,
+     block_close,
+     stmt_end,
+     ) = m.groups()
+    remainder = srcinfo.text[m.end():]
+
+    if inline_kind:
+        log_match('func inline', m)
+        kind = inline_kind
+        name = inline_name or anon_name('inline-')
+        # Immediately emit a forward declaration.
+        yield srcinfo.resolve(kind, name=name, data=None), depth
+
+        # un-inline the decl.  Note that it might not actually be inline.
+        # We handle the case in the "maybe_inline_actual" branch.
+        srcinfo.nest(
+            remainder,
+            f'{inline_leading or ""} {inline_pre or ""} {kind} {name}'
+        )
+        def parse_body(source):
+            _parse_body = DECL_BODY_PARSERS[kind]
+
+            data = []  # members
+            ident = f'{kind} {name}'
+            for item in _parse_body(source, anon_name, ident):
+                if item.kind == 'field':
+                    data.append(item)
+                else:
+                    yield item
+            # XXX Should "parent" really be None for inline type decls?
+            yield srcinfo.resolve(kind, data, name, parent=None)
+
+            srcinfo.resume()
+        yield parse_body, depth
+
+    elif static_decl:
+        log_match('local variable', m)
+        _, name, data = parse_var_decl(static_decl)
+
+        yield srcinfo.resolve('variable', data, name, parent=func), depth
+
+        if static_init:
+            srcinfo.advance(f'{name} {static_init} {remainder}')
+        elif static_ending == ',':
+            # It was a multi-declaration, so queue up the next one.
+            _, qual, typespec, _ = data.values()
+            srcinfo.advance(f'static {qual or ""} {typespec} {remainder}')
+        else:
+            srcinfo.advance('')
+
+    else:
+        log_match('func other', m)
+        if block_open:
+            depth += 1
+        elif block_close:
+            depth -= 1
+        elif stmt_end:
+            pass
+        else:
+            # This should be unreachable.
+            raise NotImplementedError
+        srcinfo.advance(remainder)
+        yield None, depth
diff --git a/Tools/c-analyzer/c_parser/parser/_global.py b/Tools/c-analyzer/c_parser/parser/_global.py
new file mode 100644
index 00000000000..35947c12998
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/parser/_global.py
@@ -0,0 +1,179 @@
+import re
+
+from ._regexes import (
+    GLOBAL as _GLOBAL,
+)
+from ._common import (
+    log_match,
+    parse_var_decl,
+    set_capture_groups,
+)
+from ._compound_decl_body import DECL_BODY_PARSERS
+#from ._func_body import parse_function_body
+from ._func_body import parse_function_statics as parse_function_body
+
+
+GLOBAL = set_capture_groups(_GLOBAL, (
+    'EMPTY',
+    'COMPOUND_LEADING',
+    'COMPOUND_KIND',
+    'COMPOUND_NAME',
+    'FORWARD_KIND',
+    'FORWARD_NAME',
+    'MAYBE_INLINE_ACTUAL',
+    'TYPEDEF_DECL',
+    'TYPEDEF_FUNC_PARAMS',
+    'VAR_STORAGE',
+    'FUNC_INLINE',
+    'VAR_DECL',
+    'FUNC_PARAMS',
+    'FUNC_DELIM',
+    'FUNC_LEGACY_PARAMS',
+    'VAR_INIT',
+    'VAR_ENDING',
+))
+GLOBAL_RE = re.compile(rf'^ \s* {GLOBAL}', re.VERBOSE)
+
+
+def parse_globals(source, anon_name):
+    for srcinfo in source:
+        m = GLOBAL_RE.match(srcinfo.text)
+        if not m:
+            # We need more text.
+            continue
+        for item in _parse_next(m, srcinfo, anon_name):
+            if callable(item):
+                parse_body = item
+                yield from parse_body(source)
+            else:
+                yield item
+    else:
+        # We ran out of lines.
+        if srcinfo is not None:
+            srcinfo.done()
+        return
+
+
+def _parse_next(m, srcinfo, anon_name):
+    (
+     empty,
+     # compound type decl (maybe inline)
+     compound_leading, compound_kind, compound_name,
+     forward_kind, forward_name, maybe_inline_actual,
+     # typedef
+     typedef_decl, typedef_func_params,
+     # vars and funcs
+     storage, func_inline, decl,
+     func_params, func_delim, func_legacy_params,
+     var_init, var_ending,
+     ) = m.groups()
+    remainder = srcinfo.text[m.end():]
+
+    if empty:
+        log_match('global empty', m)
+        srcinfo.advance(remainder)
+
+    elif maybe_inline_actual:
+        log_match('maybe_inline_actual', m)
+        # Ignore forward declarations.
+        # XXX Maybe return them too (with an "isforward" flag)?
+        if not maybe_inline_actual.strip().endswith(';'):
+            remainder = maybe_inline_actual + remainder
+        yield srcinfo.resolve(forward_kind, None, forward_name)
+        if maybe_inline_actual.strip().endswith('='):
+            # We use a dummy prefix for a fake typedef.
+            # XXX Ideally this case would not be caught by MAYBE_INLINE_ACTUAL.
+            _, name, data = parse_var_decl(f'{forward_kind} {forward_name} fake_typedef_{forward_name}')
+            yield srcinfo.resolve('typedef', data, name, parent=None)
+            remainder = f'{name} {remainder}'
+        srcinfo.advance(remainder)
+
+    elif compound_kind:
+        kind = compound_kind
+        name = compound_name or anon_name('inline-')
+        # Immediately emit a forward declaration.
+        yield srcinfo.resolve(kind, name=name, data=None)
+
+        # un-inline the decl.  Note that it might not actually be inline.
+        # We handle the case in the "maybe_inline_actual" branch.
+        srcinfo.nest(
+            remainder,
+            f'{compound_leading or ""} {compound_kind} {name}',
+        )
+        def parse_body(source):
+            _parse_body = DECL_BODY_PARSERS[compound_kind]
+
+            data = []  # members
+            ident = f'{kind} {name}'
+            for item in _parse_body(source, anon_name, ident):
+                if item.kind == 'field':
+                    data.append(item)
+                else:
+                    yield item
+            # XXX Should "parent" really be None for inline type decls?
+            yield srcinfo.resolve(kind, data, name, parent=None)
+
+            srcinfo.resume()
+        yield parse_body
+
+    elif typedef_decl:
+        log_match('typedef', m)
+        kind = 'typedef'
+        _, name, data = parse_var_decl(typedef_decl)
+        if typedef_func_params:
+            return_type = data
+            # This matches the data for func declarations.
+            data = {
+                'storage': None,
+                'inline': None,
+                'params': f'({typedef_func_params})',
+                'returntype': return_type,
+                'isforward': True,
+            }
+        yield srcinfo.resolve(kind, data, name, parent=None)
+        srcinfo.advance(remainder)
+
+    elif func_delim or func_legacy_params:
+        log_match('function', m)
+        kind = 'function'
+        _, name, return_type = parse_var_decl(decl)
+        func_params = func_params or func_legacy_params
+        data = {
+            'storage': storage,
+            'inline': func_inline,
+            'params': f'({func_params})',
+            'returntype': return_type,
+            'isforward': func_delim == ';',
+        }
+
+        yield srcinfo.resolve(kind, data, name, parent=None)
+        srcinfo.advance(remainder)
+
+        if func_delim == '{' or func_legacy_params:
+            def parse_body(source):
+                yield from parse_function_body(source, name, anon_name)
+            yield parse_body
+
+    elif var_ending:
+        log_match('global variable', m)
+        kind = 'variable'
+        _, name, vartype = parse_var_decl(decl)
+        data = {
+            'storage': storage,
+            'vartype': vartype,
+        }
+        yield srcinfo.resolve(kind, data, name, parent=None)
+
+        if var_ending == ',':
+            # It was a multi-declaration, so queue up the next one.
+            _, qual, typespec, _ = vartype.values()
+            remainder = f'{storage or ""} {qual or ""} {typespec} {remainder}'
+        srcinfo.advance(remainder)
+
+        if var_init:
+            _data = f'{name} = {var_init.strip()}'
+            yield srcinfo.resolve('statement', _data, name=None)
+
+    else:
+        # This should be unreachable.
+        raise NotImplementedError
diff --git a/Tools/c-analyzer/c_parser/parser/_info.py b/Tools/c-analyzer/c_parser/parser/_info.py
new file mode 100644
index 00000000000..2dcd5e5e760
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/parser/_info.py
@@ -0,0 +1,168 @@
+from ..info import KIND, ParsedItem, FileInfo
+
+
+class TextInfo:
+
+    def __init__(self, text, start=None, end=None):
+        # immutable:
+        if not start:
+            start = 1
+        self.start = start
+
+        # mutable:
+        lines = text.splitlines() or ['']
+        self.text = text.strip()
+        if not end:
+            end = start + len(lines) - 1
+        self.end = end
+        self.line = lines[-1]
+
+    def __repr__(self):
+        args = (f'{a}={getattr(self, a)!r}'
+                for a in ['text', 'start', 'end'])
+        return f'{type(self).__name__}({", ".join(args)})'
+
+    def add_line(self, line, lno=None):
+        if lno is None:
+            lno = self.end + 1
+        else:
+            if isinstance(lno, FileInfo):
+                fileinfo = lno
+                if fileinfo.filename != self.filename:
+                    raise NotImplementedError((fileinfo, self.filename))
+                lno = fileinfo.lno
+            # XXX
+            #if lno < self.end:
+            #    raise NotImplementedError((lno, self.end))
+        line = line.lstrip()
+        self.text += ' ' + line
+        self.line = line
+        self.end = lno
+
+
+class SourceInfo:
+
+    _ready = False
+
+    def __init__(self, filename, _current=None):
+        # immutable:
+        self.filename = filename
+        # mutable:
+        if isinstance(_current, str):
+            _current = TextInfo(_current)
+        self._current = _current
+        start = -1
+        self._start = _current.start if _current else -1
+        self._nested = []
+        self._set_ready()
+
+    def __repr__(self):
+        args = (f'{a}={getattr(self, a)!r}'
+                for a in ['filename', '_current'])
+        return f'{type(self).__name__}({", ".join(args)})'
+
+    @property
+    def start(self):
+        if self._current is None:
+            return self._start
+        return self._current.start
+
+    @property
+    def end(self):
+        if self._current is None:
+            return self._start
+        return self._current.end
+
+    @property
+    def text(self):
+        if self._current is None:
+            return ''
+        return self._current.text
+
+    def nest(self, text, before, start=None):
+        if self._current is None:
+            raise Exception('nesting requires active source text')
+        current = self._current
+        current.text = before
+        self._nested.append(current)
+        self._replace(text, start)
+
+    def resume(self, remainder=None):
+        if not self._nested:
+            raise Exception('no nested text to resume')
+        if self._current is None:
+            raise Exception('un-nesting requires active source text')
+        if remainder is None:
+            remainder = self._current.text
+        self._clear()
+        self._current = self._nested.pop()
+        self._current.text += ' ' + remainder
+        self._set_ready()
+
+    def advance(self, remainder, start=None):
+        if self._current is None:
+            raise Exception('advancing requires active source text')
+        if remainder.strip():
+            self._replace(remainder, start, fixnested=True)
+        else:
+            if self._nested:
+                self._replace('', start, fixnested=True)
+                #raise Exception('cannot advance while nesting')
+            else:
+                self._clear(start)
+
+    def resolve(self, kind, data, name, parent=None):
+        # "field" isn't a top-level kind, so we leave it as-is.
+        if kind and kind != 'field':
+            kind = KIND._from_raw(kind)
+        fileinfo = FileInfo(self.filename, self._start)
+        return ParsedItem(fileinfo, kind, parent, name, data)
+
+    def done(self):
+        self._set_ready()
+
+    def _set_ready(self):
+        if self._current is None:
+            self._ready = False
+        else:
+            self._ready = self._current.text.strip() != ''
+
+    def _used(self):
+        ready = self._ready
+        self._ready = False
+        return ready
+
+    def _clear(self, start=None):
+        old = self._current
+        if self._current is not None:
+            # XXX Fail if self._current wasn't used up?
+            if start is None:
+                start = self._current.end
+            self._current = None
+        if start is not None:
+            self._start = start
+        self._set_ready()
+        return old
+
+    def _replace(self, text, start=None, *, fixnested=False):
+        end = self._current.end
+        old = self._clear(start)
+        self._current = TextInfo(text, self._start, end)
+        if fixnested and self._nested and self._nested[-1] is old:
+            self._nested[-1] = self._current
+        self._set_ready()
+
+    def _add_line(self, line, lno=None):
+        if not line.strip():
+            # We don't worry about multi-line string literals.
+            return
+        if self._current is None:
+            self._start = lno
+            self._current = TextInfo(line, lno)
+        else:
+            # XXX
+            #if lno < self._current.end:
+            #    # A circular include?
+            #    raise NotImplementedError((lno, self))
+            self._current.add_line(line, lno)
+        self._ready = True
diff --git a/Tools/c-analyzer/c_parser/parser/_regexes.py b/Tools/c-analyzer/c_parser/parser/_regexes.py
new file mode 100644
index 00000000000..e9bc31d335a
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/parser/_regexes.py
@@ -0,0 +1,796 @@
+# Regular expression patterns for C syntax.
+#
+# None of these patterns has any capturing.  However, a number of them
+# have capturing markers compatible with utils.set_capture_groups().
+
+import textwrap
+
+
+def _ind(text, level=1, edges='both'):
+    indent = '    ' * level
+    text = textwrap.indent(text, indent)
+    if edges == 'pre' or edges == 'both':
+        text = '\n' + indent + text.lstrip()
+    if edges == 'post' or edges == 'both':
+        text = text.rstrip() + '\n' + '    ' * (level - 1)
+    return text
+
+
+#######################################
+# general
+
+HEX = r'(?: [0-9a-zA-Z] )'
+
+STRING_LITERAL = textwrap.dedent(rf'''
+    (?:
+        # character literal
+        (?:
+            ['] [^'] [']
+            |
+            ['] \\ . [']
+            |
+            ['] \\x{HEX}{HEX} [']
+            |
+            ['] \\0\d\d [']
+            |
+            (?:
+                ['] \\o[01]\d\d [']
+                |
+                ['] \\o2[0-4]\d [']
+                |
+                ['] \\o25[0-5] [']
+             )
+         )
+        |
+        # string literal
+        (?:
+            ["] (?: [^"\\]* \\ . )* [^"\\]* ["]
+         )
+        # end string literal
+     )
+    ''')
+
+_KEYWORD = textwrap.dedent(r'''
+    (?:
+        \b
+        (?:
+            auto |
+            extern |
+            register |
+            static |
+            typedef |
+
+            const |
+            volatile |
+
+            signed |
+            unsigned |
+            char |
+            short |
+            int |
+            long |
+            float |
+            double |
+            void |
+
+            struct |
+            union |
+            enum |
+
+            goto |
+            return |
+            sizeof |
+            break |
+            continue |
+            if |
+            else |
+            for |
+            do |
+            while |
+            switch |
+            case |
+            default |
+            entry
+         )
+        \b
+     )
+    ''')
+KEYWORD = rf'''
+    # keyword
+    {_KEYWORD}
+    # end keyword
+    '''
+_KEYWORD = ''.join(_KEYWORD.split())
+
+IDENTIFIER = r'(?: [a-zA-Z_][a-zA-Z0-9_]* )'
+# We use a negative lookahead to filter out keywords.
+STRICT_IDENTIFIER = rf'(?: (?! {_KEYWORD} ) \b {IDENTIFIER} \b )'
+ANON_IDENTIFIER = rf'(?: (?! {_KEYWORD} ) \b {IDENTIFIER} (?: - \d+ )? \b )'
+
+
+#######################################
+# types
+
+SIMPLE_TYPE = textwrap.dedent(rf'''
+    # simple type
+    (?:
+        \b
+        (?:
+            void
+            |
+            (?: signed | unsigned )  # implies int
+            |
+            (?:
+                (?: (?: signed | unsigned ) \s+ )?
+                (?: (?: long | short ) \s+ )?
+                (?: char | short | int | long | float | double )
+             )
+         )
+        \b
+     )
+    # end simple type
+    ''')
+
+COMPOUND_TYPE_KIND = r'(?: \b (?: struct | union | enum ) \b )'
+
+
+#######################################
+# variable declarations
+
+STORAGE_CLASS = r'(?: \b (?: auto | register | static | extern ) \b )'
+TYPE_QUALIFIER = r'(?: \b (?: const | volatile ) \b )'
+PTR_QUALIFIER = rf'(?: [*] (?: \s* {TYPE_QUALIFIER} )? )'
+
+TYPE_SPEC = textwrap.dedent(rf'''
+    # type spec
+    (?:
+        {_ind(SIMPLE_TYPE, 2)}
+        |
+        (?:
+            [_]*typeof[_]*
+            \s* [(]
+            (?: \s* [*&] )*
+            \s* {STRICT_IDENTIFIER}
+            \s* [)]
+         )
+        |
+        # reference to a compound type
+        (?:
+            {COMPOUND_TYPE_KIND}
+            (?: \s* {ANON_IDENTIFIER} )?
+         )
+        |
+        # reference to a typedef
+        {STRICT_IDENTIFIER}
+     )
+    # end type spec
+    ''')
+
+DECLARATOR = textwrap.dedent(rf'''
+    # declarator  (possibly abstract)
+    (?:
+        (?: {PTR_QUALIFIER} \s* )*
+        (?:
+            (?:
+                (?:  # <IDENTIFIER>
+                    {STRICT_IDENTIFIER}
+                )
+                (?: \s* \[ (?: \s* [^\]]+ \s* )? [\]] )*  # arrays
+             )
+            |
+            (?:
+                [(] \s*
+                (?:  # <WRAPPED_IDENTIFIER>
+                    {STRICT_IDENTIFIER}
+                )
+                (?: \s* \[ (?: \s* [^\]]+ \s* )? [\]] )*  # arrays
+                \s* [)]
+             )
+            |
+            # func ptr
+            (?:
+                [(] (?: \s* {PTR_QUALIFIER} )? \s*
+                (?:  # <FUNC_IDENTIFIER>
+                    {STRICT_IDENTIFIER}
+                )
+                (?: \s* \[ (?: \s* [^\]]+ \s* )? [\]] )*  # arrays
+                \s* [)]
+                # We allow for a single level of paren nesting in parameters.
+                \s* [(] (?: [^()]* [(] [^)]* [)] )* [^)]* [)]
+             )
+         )
+     )
+    # end declarator
+    ''')
+
+VAR_DECL = textwrap.dedent(rf'''
+    # var decl (and typedef and func return type)
+    (?:
+        (?:
+            (?:  # <STORAGE>
+                {STORAGE_CLASS}
+            )
+            \s*
+        )?
+        (?:
+            (?:  # <TYPE_QUAL>
+                {TYPE_QUALIFIER}
+            )
+            \s*
+         )?
+        (?:
+            (?:  # <TYPE_SPEC>
+                {_ind(TYPE_SPEC, 4)}
+            )
+         )
+        \s*
+        (?:
+            (?:  # <DECLARATOR>
+                {_ind(DECLARATOR, 4)}
+            )
+         )
+     )
+    # end var decl
+    ''')
+
+INITIALIZER = textwrap.dedent(rf'''
+    # initializer
+    (?:
+        (?:
+            [(]
+            # no nested parens (e.g. func ptr)
+            [^)]*
+            [)]
+            \s*
+         )?
+        (?:
+            # a string literal
+            (?:
+                (?: {_ind(STRING_LITERAL, 4)} \s* )*
+                {_ind(STRING_LITERAL, 4)}
+             )
+            |
+
+            # a simple initializer
+            (?:
+                (?:
+                    [^'",;{{]*
+                    {_ind(STRING_LITERAL, 4)}
+                 )*
+                [^'",;{{]*
+             )
+            |
+
+            # a struct/array literal
+            (?:
+                # We only expect compound initializers with
+                # single-variable declarations.
+                {{
+                (?:
+                    [^'";]*?
+                    {_ind(STRING_LITERAL, 5)}
+                 )*
+                [^'";]*?
+                }}
+                (?= \s* ; )  # Note this lookahead.
+             )
+         )
+     )
+    # end initializer
+    ''')
+
+
+#######################################
+# compound type declarations
+
+STRUCT_MEMBER_DECL = textwrap.dedent(rf'''
+    (?:
+        # inline compound type decl
+        (?:
+            (?:  # <COMPOUND_TYPE_KIND>
+                {COMPOUND_TYPE_KIND}
+             )
+            (?:
+                \s+
+                (?:  # <COMPOUND_TYPE_NAME>
+                    {STRICT_IDENTIFIER}
+                 )
+             )?
+            \s* {{
+         )
+        |
+        (?:
+            # typed member
+            (?:
+                # Technically it doesn't have to have a type...
+                (?:  # <SPECIFIER_QUALIFIER>
+                    (?: {TYPE_QUALIFIER} \s* )?
+                    {_ind(TYPE_SPEC, 5)}
+                 )
+                (?:
+                    # If it doesn't have a declarator then it will have
+                    # a size and vice versa.
+                    \s*
+                    (?:  # <DECLARATOR>
+                        {_ind(DECLARATOR, 6)}
+                     )
+                 )?
+            )
+
+            # sized member
+            (?:
+                \s* [:] \s*
+                (?:  # <SIZE>
+                    \d+
+                 )
+             )?
+            \s*
+            (?:  # <ENDING>
+                [,;]
+             )
+         )
+        |
+        (?:
+            \s*
+            (?:  # <CLOSE>
+                }}
+             )
+         )
+     )
+    ''')
+
+ENUM_MEMBER_DECL = textwrap.dedent(rf'''
+    (?:
+        (?:
+            \s*
+            (?:  # <CLOSE>
+                }}
+             )
+         )
+        |
+        (?:
+            \s*
+            (?:  # <NAME>
+                {IDENTIFIER}
+             )
+            (?:
+                \s* = \s*
+                (?:  # <INIT>
+                    {_ind(STRING_LITERAL, 4)}
+                    |
+                    [^'",}}]+
+                 )
+             )?
+            \s*
+            (?:  # <ENDING>
+                , | }}
+             )
+         )
+     )
+    ''')
+
+
+#######################################
+# statements
+
+SIMPLE_STMT_BODY = textwrap.dedent(rf'''
+    # simple statement body
+    (?:
+        (?:
+            [^'"{{}};]*
+            {_ind(STRING_LITERAL, 3)}
+         )*
+        [^'"{{}};]*
+        #(?= [;{{] )  # Note this lookahead.
+     )
+    # end simple statement body
+    ''')
+SIMPLE_STMT = textwrap.dedent(rf'''
+    # simple statement
+    (?:
+        (?:  # <SIMPLE_STMT>
+            # stmt-inline "initializer"
+            (?:
+                return \b
+                (?:
+                    \s*
+                    {_ind(INITIALIZER, 5)}
+                )?
+             )
+            |
+            # variable assignment
+            (?:
+                (?: [*] \s* )?
+                (?:
+                    {STRICT_IDENTIFIER} \s*
+                    (?: . | -> ) \s*
+                 )*
+                {STRICT_IDENTIFIER}
+                (?: \s* \[ \s* \d+ \s* \] )?
+                \s* = \s*
+                {_ind(INITIALIZER, 4)}
+             )
+            |
+            # catchall return statement
+            (?:
+                return \b
+                (?:
+                    (?:
+                        [^'";]*
+                        {_ind(STRING_LITERAL, 6)}
+                     )*
+                    \s* [^'";]*
+                 )?
+             )
+            |
+            # simple statement
+            (?:
+                {_ind(SIMPLE_STMT_BODY, 4)}
+             )
+         )
+        \s*
+        (?:  # <SIMPLE_ENDING>
+            ;
+         )
+     )
+    # end simple statement
+    ''')
+COMPOUND_STMT = textwrap.dedent(rf'''
+    # compound statement
+    (?:
+        \b
+        (?:
+            (?:
+                (?:  # <COMPOUND_BARE>
+                    else | do
+                 )
+                \b
+             )
+            |
+            (?:
+                (?:  # <COMPOUND_LABELED>
+                    (?:
+                        case \b
+                        (?:
+                            [^'":]*
+                            {_ind(STRING_LITERAL, 7)}
+                         )*
+                        \s* [^'":]*
+                     )
+                    |
+                    default
+                    |
+                    {STRICT_IDENTIFIER}
+                 )
+                \s* [:]
+             )
+            |
+            (?:
+                (?:  # <COMPOUND_PAREN>
+                    for | while | if | switch
+                 )
+                \s* (?= [(] )  # Note this lookahead.
+             )
+         )
+        \s*
+     )
+    # end compound statement
+    ''')
+
+
+#######################################
+# function bodies
+
+LOCAL = textwrap.dedent(rf'''
+    (?:
+        # an empty statement
+        (?:  # <EMPTY>
+            ;
+         )
+        |
+        # inline type decl
+        (?:
+            (?:
+                (?:  # <INLINE_LEADING>
+                    [^;{{}}]+?
+                 )
+                \s*
+             )?
+            (?:  # <INLINE_PRE>
+                (?: {STORAGE_CLASS} \s* )?
+                (?: {TYPE_QUALIFIER} \s* )?
+             )?  # </INLINE_PRE>
+            (?:  # <INLINE_KIND>
+                {COMPOUND_TYPE_KIND}
+             )
+            (?:
+                \s+
+                (?:  # <INLINE_NAME>
+                    {STRICT_IDENTIFIER}
+                 )
+             )?
+            \s* {{
+         )
+        |
+        # var decl
+        (?:
+            (?:  # <STORAGE>
+                {STORAGE_CLASS}
+             )?  # </STORAGE>
+            (?:
+                \s*
+                (?:  # <VAR_DECL>
+                    {_ind(VAR_DECL, 5)}
+                 )
+             )
+            (?:
+                (?:
+                    # initializer
+                    # We expect only basic initializers.
+                    \s* = \s*
+                    (?:  # <VAR_INIT>
+                        {_ind(INITIALIZER, 6)}
+                     )
+                 )?
+                (?:
+                    \s*
+                    (?:  # <VAR_ENDING>
+                        [,;]
+                     )
+                 )
+             )
+         )
+        |
+        {_ind(COMPOUND_STMT, 2)}
+        |
+        # start-of-block
+        (?:
+            (?:  # <BLOCK_LEADING>
+                (?:
+                    [^'"{{}};]*
+                    {_ind(STRING_LITERAL, 5)}
+                 )*
+                [^'"{{}};]*
+                # Presumably we will not see "== {{".
+                [^\s='"{{}});]
+                \s*
+             )?  # </BLOCK_LEADING>
+            (?:  # <BLOCK_OPEN>
+                {{
+             )
+         )
+        |
+        {_ind(SIMPLE_STMT, 2)}
+        |
+        # end-of-block
+        (?:  # <BLOCK_CLOSE>
+            }}
+         )
+     )
+    ''')
+
+LOCAL_STATICS = textwrap.dedent(rf'''
+    (?:
+        # inline type decl
+        (?:
+            (?:
+                (?:  # <INLINE_LEADING>
+                    [^;{{}}]+?
+                 )
+                \s*
+             )?
+            (?:  # <INLINE_PRE>
+                (?: {STORAGE_CLASS} \s* )?
+                (?: {TYPE_QUALIFIER} \s* )?
+             )?
+            (?:  # <INLINE_KIND>
+                {COMPOUND_TYPE_KIND}
+             )
+            (?:
+                \s+
+                (?:  # <INLINE_NAME>
+                    {STRICT_IDENTIFIER}
+                 )
+             )?
+            \s* {{
+         )
+        |
+        # var decl
+        (?:
+            # We only look for static variables.
+            (?:  # <STATIC_DECL>
+                static \b
+                (?: \s* {TYPE_QUALIFIER} )?
+                \s* {_ind(TYPE_SPEC, 4)}
+                \s* {_ind(DECLARATOR, 4)}
+             )
+            \s*
+            (?:
+                (?:  # <STATIC_INIT>
+                    = \s*
+                    {_ind(INITIALIZER, 4)}
+                    \s*
+                    [,;{{]
+                 )
+                |
+                (?:  # <STATIC_ENDING>
+                    [,;]
+                 )
+             )
+         )
+        |
+        # everything else
+        (?:
+            (?:  # <DELIM_LEADING>
+                (?:
+                    [^'"{{}};]*
+                    {_ind(STRING_LITERAL, 4)}
+                 )*
+                \s* [^'"{{}};]*
+             )
+            (?:
+                (?:  # <BLOCK_OPEN>
+                    {{
+                 )
+                |
+                (?:  # <BLOCK_CLOSE>
+                    }}
+                 )
+                |
+                (?:  # <STMT_END>
+                    ;
+                 )
+             )
+         )
+     )
+    ''')
+
+
+#######################################
+# global declarations
+
+GLOBAL = textwrap.dedent(rf'''
+    (?:
+        # an empty statement
+        (?:  # <EMPTY>
+            ;
+         )
+        |
+
+        # compound type decl (maybe inline)
+        (?:
+            (?:
+                (?:  # <COMPOUND_LEADING>
+                    [^;{{}}]+?
+                 )
+                 \s*
+             )?
+            (?:  # <COMPOUND_KIND>
+                {COMPOUND_TYPE_KIND}
+             )
+            (?:
+                \s+
+                (?:  # <COMPOUND_NAME>
+                    {STRICT_IDENTIFIER}
+                 )
+             )?
+            \s* {{
+         )
+        |
+        # bogus inline decl artifact
+        # This simplifies resolving the relative syntactic ambiguity of
+        # inline structs.
+        (?:
+            (?:  # <FORWARD_KIND>
+                {COMPOUND_TYPE_KIND}
+             )
+            \s*
+            (?:  # <FORWARD_NAME>
+                {ANON_IDENTIFIER}
+             )
+            (?:  # <MAYBE_INLINE_ACTUAL>
+                [^=,;({{[*\]]*
+                [=,;({{]
+             )
+         )
+        |
+
+        # typedef
+        (?:
+            \b typedef \b \s*
+            (?:  # <TYPEDEF_DECL>
+                {_ind(VAR_DECL, 4)}
+             )
+            (?:
+                # We expect no inline type definitions in the parameters.
+                \s* [(] \s*
+                (?:  # <TYPEDEF_FUNC_PARAMS>
+                    [^{{;]*
+                 )
+                \s* [)]
+             )?
+            \s* ;
+         )
+        |
+
+        # func decl/definition & var decls
+        # XXX dedicated pattern for funcs (more restricted)?
+        (?:
+            (?:
+                (?:  # <VAR_STORAGE>
+                    {STORAGE_CLASS}
+                 )
+                \s*
+             )?
+            (?:
+                (?:  # <FUNC_INLINE>
+                    \b inline \b
+                 )
+                \s*
+             )?
+            (?:  # <VAR_DECL>
+                {_ind(VAR_DECL, 4)}
+             )
+            (?:
+                # func decl / definition
+                (?:
+                    (?:
+                        # We expect no inline type definitions in the parameters.
+                        \s* [(] \s*
+                        (?:  # <FUNC_PARAMS>
+                            [^{{;]*
+                         )
+                        \s* [)] \s*
+                        (?:  # <FUNC_DELIM>
+                            [{{;]
+                         )
+                     )
+                    |
+                    (?:
+                        # This is some old-school syntax!
+                        \s* [(] \s*
+                        # We throw away the bare names:
+                        {STRICT_IDENTIFIER}
+                        (?: \s* , \s* {STRICT_IDENTIFIER} )*
+                        \s* [)] \s*
+
+                        # We keep the trailing param declarations:
+                        (?:  # <FUNC_LEGACY_PARAMS>
+                            # There's at least one!
+                            (?: {TYPE_QUALIFIER} \s* )?
+                            {_ind(TYPE_SPEC, 7)}
+                            \s*
+                            {_ind(DECLARATOR, 7)}
+                            \s* ;
+                            (?:
+                                \s*
+                                (?: {TYPE_QUALIFIER} \s* )?
+                                {_ind(TYPE_SPEC, 8)}
+                                \s*
+                                {_ind(DECLARATOR, 8)}
+                                \s* ;
+                             )*
+                         )
+                        \s* {{
+                     )
+                 )
+                |
+                # var / typedef
+                (?:
+                    (?:
+                        # initializer
+                        # We expect only basic initializers.
+                        \s* = \s*
+                        (?:  # <VAR_INIT>
+                            {_ind(INITIALIZER, 6)}
+                         )
+                     )?
+                    \s*
+                    (?:  # <VAR_ENDING>
+                        [,;]
+                     )
+                 )
+             )
+         )
+     )
+    ''')
diff --git a/Tools/c-analyzer/c_parser/preprocessor/__init__.py b/Tools/c-analyzer/c_parser/preprocessor/__init__.py
new file mode 100644
index 00000000000..f206f694db5
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/preprocessor/__init__.py
@@ -0,0 +1,190 @@
+import contextlib
+import distutils.ccompiler
+import logging
+import os.path
+
+from c_common.fsutil import match_glob as _match_glob
+from c_common.tables import parse_table as _parse_table
+from ..source import (
+    resolve as _resolve_source,
+    good_file as _good_file,
+)
+from . import errors as _errors
+from . import (
+    pure as _pure,
+    gcc as _gcc,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+# Supprted "source":
+#  * filename (string)
+#  * lines (iterable)
+#  * text (string)
+# Supported return values:
+#  * iterator of SourceLine
+#  * sequence of SourceLine
+#  * text (string)
+#  * something that combines all those
+# XXX Add the missing support from above.
+# XXX Add more low-level functions to handle permutations?
+
+def preprocess(source, *,
+               incldirs=None,
+               macros=None,
+               samefiles=None,
+               filename=None,
+               tool=True,
+               ):
+    """...
+
+    CWD should be the project root and "source" should be relative.
+    """
+    if tool:
+        logger.debug(f'CWD: {os.getcwd()!r}')
+        logger.debug(f'incldirs: {incldirs!r}')
+        logger.debug(f'macros: {macros!r}')
+        logger.debug(f'samefiles: {samefiles!r}')
+        _preprocess = _get_preprocessor(tool)
+        with _good_file(source, filename) as source:
+            return _preprocess(source, incldirs, macros, samefiles) or ()
+    else:
+        source, filename = _resolve_source(source, filename)
+        # We ignore "includes", "macros", etc.
+        return _pure.preprocess(source, filename)
+
+    # if _run() returns just the lines:
+#    text = _run(source)
+#    lines = [line + os.linesep for line in text.splitlines()]
+#    lines[-1] = lines[-1].splitlines()[0]
+#
+#    conditions = None
+#    for lno, line in enumerate(lines, 1):
+#        kind = 'source'
+#        directive = None
+#        data = line
+#        yield lno, kind, data, conditions
+
+
+def get_preprocessor(*,
+                     file_macros=None,
+                     file_incldirs=None,
+                     file_same=None,
+                     ignore_exc=False,
+                     log_err=None,
+                     ):
+    _preprocess = preprocess
+    if file_macros:
+        file_macros = tuple(_parse_macros(file_macros))
+    if file_incldirs:
+        file_incldirs = tuple(_parse_incldirs(file_incldirs))
+    if file_same:
+        file_same = tuple(file_same)
+    if not callable(ignore_exc):
+        ignore_exc = (lambda exc, _ig=ignore_exc: _ig)
+
+    def get_file_preprocessor(filename):
+        filename = filename.strip()
+        if file_macros:
+            macros = list(_resolve_file_values(filename, file_macros))
+        if file_incldirs:
+            incldirs = [v for v, in _resolve_file_values(filename, file_incldirs)]
+    
+        def preprocess(**kwargs):
+            if file_macros and 'macros' not in kwargs:
+                kwargs['macros'] = macros
+            if file_incldirs and 'incldirs' not in kwargs:
+                kwargs['incldirs'] = [v for v, in _resolve_file_values(filename, file_incldirs)]
+            if file_same and 'file_same' not in kwargs:
+                kwargs['samefiles'] = file_same
+            kwargs.setdefault('filename', filename)
+            with handling_errors(ignore_exc, log_err=log_err):
+                return _preprocess(filename, **kwargs)
+        return preprocess
+    return get_file_preprocessor
+
+
+def _resolve_file_values(filename, file_values):
+    # We expect the filename and all patterns to be absolute paths.
+    for pattern, *value in file_values or ():
+        if _match_glob(filename, pattern):
+            yield value
+
+
+def _parse_macros(macros):
+    for row, srcfile in _parse_table(macros, '\t', 'glob\tname\tvalue', rawsep='=', default=None):
+        yield row
+
+
+def _parse_incldirs(incldirs):
+    for row, srcfile in _parse_table(incldirs, '\t', 'glob\tdirname', default=None):
+        glob, dirname = row
+        if dirname is None:
+            # Match all files.
+            dirname = glob
+            row = ('*', dirname.strip())
+        yield row
+
+
+@contextlib.contextmanager
+def handling_errors(ignore_exc=None, *, log_err=None):
+    try:
+        yield
+    except _errors.OSMismatchError as exc:
+        if not ignore_exc(exc):
+            raise  # re-raise
+        if log_err is not None:
+            log_err(f'<OS mismatch (expected {" or ".join(exc.expected)})>')
+        return None
+    except _errors.MissingDependenciesError as exc:
+        if not ignore_exc(exc):
+            raise  # re-raise
+        if log_err is not None:
+            log_err(f'<missing dependency {exc.missing}')
+        return None
+    except _errors.ErrorDirectiveError as exc:
+        if not ignore_exc(exc):
+            raise  # re-raise
+        if log_err is not None:
+            log_err(exc)
+        return None
+
+
+##################################
+# tools
+
+_COMPILERS = {
+    # matching disutils.ccompiler.compiler_class:
+    'unix': _gcc.preprocess,
+    'msvc': None,
+    'cygwin': None,
+    'mingw32': None,
+    'bcpp': None,
+    # aliases/extras:
+    'gcc': _gcc.preprocess,
+    'clang': None,
+}
+
+
+def _get_preprocessor(tool):
+    if tool is True:
+        tool = distutils.ccompiler.get_default_compiler()
+    preprocess = _COMPILERS.get(tool)
+    if preprocess is None:
+        raise ValueError(f'unsupported tool {tool}')
+    return preprocess
+
+
+##################################
+# aliases
+
+from .errors import (
+    PreprocessorError,
+    PreprocessorFailure,
+    ErrorDirectiveError,
+    MissingDependenciesError,
+    OSMismatchError,
+)
+from .common import FileInfo, SourceLine
diff --git a/Tools/c-analyzer/c_parser/preprocessor/__main__.py b/Tools/c-analyzer/c_parser/preprocessor/__main__.py
new file mode 100644
index 00000000000..a6054307c25
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/preprocessor/__main__.py
@@ -0,0 +1,196 @@
+import logging
+import sys
+
+from c_common.scriptutil import (
+    CLIArgSpec as Arg,
+    add_verbosity_cli,
+    add_traceback_cli,
+    add_kind_filtering_cli,
+    add_files_cli,
+    add_failure_filtering_cli,
+    add_commands_cli,
+    process_args_by_key,
+    configure_logger,
+    get_prog,
+    main_for_filenames,
+)
+from . import (
+    errors as _errors,
+    get_preprocessor as _get_preprocessor,
+)
+
+
+FAIL = {
+    'err': _errors.ErrorDirectiveError,
+    'deps': _errors.MissingDependenciesError,
+    'os': _errors.OSMismatchError,
+}
+FAIL_DEFAULT = tuple(v for v in FAIL if v != 'os')
+
+
+logger = logging.getLogger(__name__)
+
+
+##################################
+# CLI helpers
+
+def add_common_cli(parser, *, get_preprocessor=_get_preprocessor):
+    parser.add_argument('--macros', action='append')
+    parser.add_argument('--incldirs', action='append')
+    parser.add_argument('--same', action='append')
+    process_fail_arg = add_failure_filtering_cli(parser, FAIL)
+
+    def process_args(args):
+        ns = vars(args)
+
+        process_fail_arg(args)
+        ignore_exc = ns.pop('ignore_exc')
+        # We later pass ignore_exc to _get_preprocessor().
+
+        args.get_file_preprocessor = get_preprocessor(
+            file_macros=ns.pop('macros'),
+            file_incldirs=ns.pop('incldirs'),
+            file_same=ns.pop('same'),
+            ignore_exc=ignore_exc,
+            log_err=print,
+        )
+    return process_args
+
+
+def _iter_preprocessed(filename, *,
+                       get_preprocessor,
+                       match_kind=None,
+                       pure=False,
+                       ):
+    preprocess = get_preprocessor(filename)
+    for line in preprocess(tool=not pure) or ():
+        if match_kind is not None and not match_kind(line.kind):
+            continue
+        yield line
+
+
+#######################################
+# the commands
+
+def _cli_preprocess(parser, excluded=None, **prepr_kwargs):
+    parser.add_argument('--pure', action='store_true')
+    parser.add_argument('--no-pure', dest='pure', action='store_const', const=False)
+    process_kinds = add_kind_filtering_cli(parser)
+    process_common = add_common_cli(parser, **prepr_kwargs)
+    parser.add_argument('--raw', action='store_true')
+    process_files = add_files_cli(parser, excluded=excluded)
+
+    return [
+        process_kinds,
+        process_common,
+        process_files,
+    ]
+
+
+def cmd_preprocess(filenames, *,
+                   raw=False,
+                   iter_filenames=None,
+                   **kwargs
+                   ):
+    if 'get_file_preprocessor' not in kwargs:
+        kwargs['get_file_preprocessor'] = _get_preprocessor()
+    if raw:
+        def show_file(filename, lines):
+            for line in lines:
+                print(line)
+                #print(line.raw)
+    else:
+        def show_file(filename, lines):
+            for line in lines:
+                linefile = ''
+                if line.filename != filename:
+                    linefile = f' ({line.filename})'
+                text = line.data
+                if line.kind == 'comment':
+                    text = '/* ' + line.data.splitlines()[0]
+                    text += ' */' if '\n' in line.data else r'\n... */'
+                print(f' {line.lno:>4} {line.kind:10} | {text}')
+
+    filenames = main_for_filenames(filenames, iter_filenames)
+    for filename in filenames:
+        lines = _iter_preprocessed(filename, **kwargs)
+        show_file(filename, lines)
+
+
+def _cli_data(parser):
+    ...
+
+    return None
+
+
+def cmd_data(filenames,
+             **kwargs
+             ):
+    # XXX
+    raise NotImplementedError
+
+
+COMMANDS = {
+    'preprocess': (
+        'preprocess the given C source & header files',
+        [_cli_preprocess],
+        cmd_preprocess,
+    ),
+    'data': (
+        'check/manage local data (e.g. excludes, macros)',
+        [_cli_data],
+        cmd_data,
+    ),
+}
+
+
+#######################################
+# the script
+
+def parse_args(argv=sys.argv[1:], prog=sys.argv[0], *,
+               subset='preprocess',
+               excluded=None,
+               **prepr_kwargs
+               ):
+    import argparse
+    parser = argparse.ArgumentParser(
+        prog=prog or get_prog(),
+    )
+
+    processors = add_commands_cli(
+        parser,
+        commands={k: v[1] for k, v in COMMANDS.items()},
+        commonspecs=[
+            add_verbosity_cli,
+            add_traceback_cli,
+        ],
+        subset=subset,
+    )
+
+    args = parser.parse_args(argv)
+    ns = vars(args)
+
+    cmd = ns.pop('cmd')
+
+    verbosity, traceback_cm = process_args_by_key(
+        args,
+        processors[cmd],
+        ['verbosity', 'traceback_cm'],
+    )
+
+    return cmd, ns, verbosity, traceback_cm
+
+
+def main(cmd, cmd_kwargs):
+    try:
+        run_cmd = COMMANDS[cmd][0]
+    except KeyError:
+        raise ValueError(f'unsupported cmd {cmd!r}')
+    run_cmd(**cmd_kwargs)
+
+
+if __name__ == '__main__':
+    cmd, cmd_kwargs, verbosity, traceback_cm = parse_args()
+    configure_logger(verbosity)
+    with traceback_cm:
+        main(cmd, cmd_kwargs)
diff --git a/Tools/c-analyzer/c_parser/preprocessor/common.py b/Tools/c-analyzer/c_parser/preprocessor/common.py
new file mode 100644
index 00000000000..63681025c63
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/preprocessor/common.py
@@ -0,0 +1,173 @@
+import contextlib
+import distutils.ccompiler
+import logging
+import shlex
+import subprocess
+import sys
+
+from ..info import FileInfo, SourceLine
+from .errors import (
+    PreprocessorFailure,
+    ErrorDirectiveError,
+    MissingDependenciesError,
+    OSMismatchError,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+# XXX Add aggregate "source" class(es)?
+#  * expose all lines as single text string
+#  * expose all lines as sequence
+#  * iterate all lines
+
+
+def run_cmd(argv, *,
+            #capture_output=True,
+            stdout=subprocess.PIPE,
+            #stderr=subprocess.STDOUT,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+            **kwargs
+            ):
+    if isinstance(stderr, str) and stderr.lower() == 'stdout':
+        stderr = subprocess.STDOUT
+
+    kw = dict(locals())
+    kw.pop('argv')
+    kw.pop('kwargs')
+    kwargs.update(kw)
+
+    proc = subprocess.run(argv, **kwargs)
+    return proc.stdout
+
+
+def preprocess(tool, filename, **kwargs):
+    argv = _build_argv(tool, filename, **kwargs)
+    logger.debug(' '.join(shlex.quote(v) for v in argv))
+
+    # Make sure the OS is supported for this file.
+    if (_expected := is_os_mismatch(filename)):
+        error = None
+        raise OSMismatchError(filename, _expected, argv, error, TOOL)
+
+    # Run the command.
+    with converted_error(tool, argv, filename):
+        # We use subprocess directly here, instead of calling the
+        # distutil compiler object's preprocess() method, since that
+        # one writes to stdout/stderr and it's simpler to do it directly
+        # through subprocess.
+        return run_cmd(argv)
+
+
+def _build_argv(
+    tool,
+    filename,
+    incldirs=None,
+    macros=None,
+    preargs=None,
+    postargs=None,
+    executable=None,
+    compiler=None,
+):
+    compiler = distutils.ccompiler.new_compiler(
+        compiler=compiler or tool,
+    )
+    if executable:
+        compiler.set_executable('preprocessor', executable)
+
+    argv = None
+    def _spawn(_argv):
+        nonlocal argv
+        argv = _argv
+    compiler.spawn = _spawn
+    compiler.preprocess(
+        filename,
+        macros=[tuple(v) for v in macros or ()],
+        include_dirs=incldirs or (),
+        extra_preargs=preargs or (),
+        extra_postargs=postargs or (),
+    )
+    return argv
+
+
+@contextlib.contextmanager
+def converted_error(tool, argv, filename):
+    try:
+        yield
+    except subprocess.CalledProcessError as exc:
+        convert_error(
+            tool,
+            argv,
+            filename,
+            exc.stderr,
+            exc.returncode,
+        )
+
+
+def convert_error(tool, argv, filename, stderr, rc):
+    error = (stderr.splitlines()[0], rc)
+    if (_expected := is_os_mismatch(filename, stderr)):
+        logger.debug(stderr.strip())
+        raise OSMismatchError(filename, _expected, argv, error, tool)
+    elif (_missing := is_missing_dep(stderr)):
+        logger.debug(stderr.strip())
+        raise MissingDependenciesError(filename, (_missing,), argv, error, tool)
+    elif '#error' in stderr:
+        # XXX Ignore incompatible files.
+        error = (stderr.splitlines()[1], rc)
+        logger.debug(stderr.strip())
+        raise ErrorDirectiveError(filename, argv, error, tool)
+    else:
+        # Try one more time, with stderr written to the terminal.
+        try:
+            output = run_cmd(argv, stderr=None)
+        except subprocess.CalledProcessError:
+            raise PreprocessorFailure(filename, argv, error, tool)
+
+
+def is_os_mismatch(filename, errtext=None):
+    # See: https://docs.python.org/3/library/sys.html#sys.platform
+    actual = sys.platform
+    if actual == 'unknown':
+        raise NotImplementedError
+
+    if errtext is not None:
+        if (missing := is_missing_dep(errtext)):
+            matching = get_matching_oses(missing, filename)
+            if actual not in matching:
+                return matching
+    return False
+
+
+def get_matching_oses(missing, filename):
+    # OSX
+    if 'darwin' in filename or 'osx' in filename:
+        return ('darwin',)
+    elif missing == 'SystemConfiguration/SystemConfiguration.h':
+        return ('darwin',)
+
+    # Windows
+    elif missing in ('windows.h', 'winsock2.h'):
+        return ('win32',)
+
+    # other
+    elif missing == 'sys/ldr.h':
+        return ('aix',)
+    elif missing == 'dl.h':
+        # XXX The existence of Python/dynload_dl.c implies others...
+        # Note that hpux isn't actual supported any more.
+        return ('hpux', '???')
+
+    # unrecognized
+    else:
+        return ()
+
+
+def is_missing_dep(errtext):
+    if 'No such file or directory' in errtext:
+        missing = errtext.split(': No such file or directory')[0].split()[-1]
+        return missing
+    return False
diff --git a/Tools/c-analyzer/c_parser/preprocessor/errors.py b/Tools/c-analyzer/c_parser/preprocessor/errors.py
new file mode 100644
index 00000000000..9b66801d630
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/preprocessor/errors.py
@@ -0,0 +1,110 @@
+import sys
+
+
+OS = sys.platform
+
+
+def _as_tuple(items):
+    if isinstance(items, str):
+        return tuple(items.strip().replace(',', ' ').split())
+    elif items:
+        return tuple(items)
+    else:
+        return ()
+
+
+class PreprocessorError(Exception):
+    """Something preprocessor-related went wrong."""
+
+    @classmethod
+    def _msg(cls, filename, reason, **ignored):
+        msg = 'failure while preprocessing'
+        if reason:
+            msg = f'{msg} ({reason})'
+        return msg
+
+    def __init__(self, filename, preprocessor=None, reason=None):
+        if isinstance(reason, str):
+            reason = reason.strip()
+
+        self.filename = filename
+        self.preprocessor = preprocessor or None
+        self.reason = str(reason) if reason else None
+
+        msg = self._msg(**vars(self))
+        msg = f'({filename}) {msg}'
+        if preprocessor:
+            msg = f'[{preprocessor}] {msg}'
+        super().__init__(msg)
+
+
+class PreprocessorFailure(PreprocessorError):
+    """The preprocessor command failed."""
+
+    @classmethod
+    def _msg(cls, error, **ignored):
+        msg = 'preprocessor command failed'
+        if error:
+            msg = f'{msg} {error}'
+        return msg
+
+    def __init__(self, filename, argv, error=None, preprocessor=None):
+        exitcode = -1
+        if isinstance(error, tuple):
+            if len(error) == 2:
+                error, exitcode = error
+            else:
+                error = str(error)
+        if isinstance(error, str):
+            error = error.strip()
+
+        self.argv = _as_tuple(argv) or None
+        self.error = error if error else None
+        self.exitcode = exitcode
+
+        reason = str(self.error)
+        super().__init__(filename, preprocessor, reason)
+
+
+class ErrorDirectiveError(PreprocessorFailure):
+    """The file hit a #error directive."""
+
+    @classmethod
+    def _msg(cls, error, **ignored):
+        return f'#error directive hit ({error})'
+
+    def __init__(self, filename, argv, error, *args, **kwargs):
+        super().__init__(filename, argv, error, *args, **kwargs)
+
+
+class MissingDependenciesError(PreprocessorFailure):
+    """The preprocessor did not have access to all the target's dependencies."""
+
+    @classmethod
+    def _msg(cls, missing, **ignored):
+        msg = 'preprocessing failed due to missing dependencies'
+        if missing:
+            msg = f'{msg} ({", ".join(missing)})'
+        return msg
+
+    def __init__(self, filename, missing=None, *args, **kwargs):
+        self.missing = _as_tuple(missing) or None
+
+        super().__init__(filename, *args, **kwargs)
+
+
+class OSMismatchError(MissingDependenciesError):
+    """The target is not compatible with the host OS."""
+
+    @classmethod
+    def _msg(cls, expected, **ignored):
+        return f'OS is {OS} but expected {expected or "???"}'
+
+    def __init__(self, filename, expected=None, *args, **kwargs):
+        if isinstance(expected, str):
+            expected = expected.strip()
+
+        self.actual = OS
+        self.expected = expected if expected else None
+
+        super().__init__(filename, None, *args, **kwargs)
diff --git a/Tools/c-analyzer/c_parser/preprocessor/gcc.py b/Tools/c-analyzer/c_parser/preprocessor/gcc.py
new file mode 100644
index 00000000000..bb404a487b7
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/preprocessor/gcc.py
@@ -0,0 +1,123 @@
+import os.path
+import re
+
+from . import common as _common
+
+
+TOOL = 'gcc'
+
+# https://gcc.gnu.org/onlinedocs/cpp/Preprocessor-Output.html
+LINE_MARKER_RE = re.compile(r'^# (\d+) "([^"]+)"(?: [1234])*$')
+PREPROC_DIRECTIVE_RE = re.compile(r'^\s*#\s*(\w+)\b.*')
+COMPILER_DIRECTIVE_RE = re.compile(r'''
+    ^
+    (.*?)  # <before>
+    (__\w+__)  # <directive>
+    \s*
+    [(] [(]
+    (
+        [^()]*
+        (?:
+            [(]
+            [^()]*
+            [)]
+            [^()]*
+         )*
+     )  # <args>
+    ( [)] [)] )?  # <closed>
+''', re.VERBOSE)
+
+POST_ARGS = (
+    '-pthread',
+    '-std=c99',
+    #'-g',
+    #'-Og',
+    #'-Wno-unused-result',
+    #'-Wsign-compare',
+    #'-Wall',
+    #'-Wextra',
+    '-E',
+)
+
+
+def preprocess(filename, incldirs=None, macros=None, samefiles=None):
+    text = _common.preprocess(
+        TOOL,
+        filename,
+        incldirs=incldirs,
+        macros=macros,
+        #preargs=PRE_ARGS,
+        postargs=POST_ARGS,
+        executable=['gcc'],
+        compiler='unix',
+    )
+    return _iter_lines(text, filename, samefiles)
+
+
+def _iter_lines(text, filename, samefiles, *, raw=False):
+    lines = iter(text.splitlines())
+
+    # Build the lines and filter out directives.
+    partial = 0  # depth
+    origfile = None
+    for line in lines:
+        m = LINE_MARKER_RE.match(line)
+        if m:
+            lno, origfile = m.groups()
+            lno = int(lno)
+        elif _filter_orig_file(origfile, filename, samefiles):
+            if (m := PREPROC_DIRECTIVE_RE.match(line)):
+                name, = m.groups()
+                if name != 'pragma':
+                    raise Exception(line)
+            else:
+                if not raw:
+                    line, partial = _strip_directives(line, partial=partial)
+                yield _common.SourceLine(
+                    _common.FileInfo(filename, lno),
+                    'source',
+                    line or '',
+                    None,
+                )
+            lno += 1
+
+
+def _strip_directives(line, partial=0):
+    # We assume there are no string literals with parens in directive bodies.
+    while partial > 0:
+        if not (m := re.match(r'[^{}]*([()])', line)):
+            return None, partial
+        delim, = m.groups()
+        partial += 1 if delim == '(' else -1  # opened/closed
+        line = line[m.end():]
+
+    line = re.sub(r'__extension__', '', line)
+
+    while (m := COMPILER_DIRECTIVE_RE.match(line)):
+        before, _, _, closed = m.groups()
+        if closed:
+            line = f'{before} {line[m.end():]}'
+        else:
+            after, partial = _strip_directives(line[m.end():], 2)
+            line = f'{before} {after or ""}'
+            if partial:
+                break
+
+    return line, partial
+
+
+def _filter_orig_file(origfile, current, samefiles):
+    if origfile == current:
+        return True
+    if origfile == '<stdin>':
+        return True
+    if os.path.isabs(origfile):
+        return False
+
+    for filename in samefiles or ():
+        if filename.endswith(os.path.sep):
+            filename += os.path.basename(current)
+        if origfile == filename:
+            return True
+
+    return False
diff --git a/Tools/c-analyzer/c_parser/preprocessor/pure.py b/Tools/c-analyzer/c_parser/preprocessor/pure.py
new file mode 100644
index 00000000000..e971389b188
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/preprocessor/pure.py
@@ -0,0 +1,23 @@
+from ..source import (
+    opened as _open_source,
+)
+from . import common as _common
+
+
+def preprocess(lines, filename=None):
+    if isinstance(lines, str):
+        with _open_source(lines, filename) as (lines, filename):
+            yield from preprocess(lines, filename)
+        return
+
+    # XXX actually preprocess...
+    for lno, line in enumerate(lines, 1):
+        kind = 'source'
+        data = line
+        conditions = None
+        yield _common.SourceLine(
+            _common.FileInfo(filename, lno),
+            kind,
+            data,
+            conditions,
+        )
diff --git a/Tools/c-analyzer/c_parser/source.py b/Tools/c-analyzer/c_parser/source.py
new file mode 100644
index 00000000000..30a09eeb56a
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/source.py
@@ -0,0 +1,64 @@
+import contextlib
+import os.path
+
+
+def resolve(source, filename):
+    if _looks_like_filename(source):
+        return _resolve_filename(source, filename)
+
+    if isinstance(source, str):
+        source = source.splitlines()
+
+    # At this point "source" is not a str.
+    if not filename:
+        filename = None
+    elif not isinstance(filename, str):
+        raise TypeError(f'filename should be str (or None), got {filename!r}')
+    else:
+        filename, _ = _resolve_filename(filename)
+    return source, filename
+
+
+@contextlib.contextmanager
+def good_file(filename, alt=None):
+    if not _looks_like_filename(filename):
+        raise ValueError(f'expected a filename, got {filename}')
+    filename, _ = _resolve_filename(filename, alt)
+    try:
+        yield filename
+    except Exception:
+        if not os.path.exists(filename):
+            raise FileNotFoundError(f'file not found: {filename}')
+        raise  # re-raise
+
+
+def _looks_like_filename(value):
+    if not isinstance(value, str):
+        return False
+    return value.endswith(('.c', '.h'))
+
+
+def _resolve_filename(filename, alt=None):
+    if os.path.isabs(filename):
+        ...
+#        raise NotImplementedError
+    else:
+        filename = os.path.join('.', filename)
+
+    if not alt:
+        alt = filename
+    elif os.path.abspath(filename) == os.path.abspath(alt):
+        alt = filename
+    else:
+        raise ValueError(f'mismatch: {filename} != {alt}')
+    return filename, alt
+
+
+@contextlib.contextmanager
+def opened(source, filename=None):
+    source, filename = resolve(source, filename)
+    if isinstance(source, str):
+        with open(source) as srcfile:
+            yield srcfile, filename
+    else:
+        yield source, filename
diff --git a/Tools/c-analyzer/check-c-globals.py b/Tools/c-analyzer/check-c-globals.py
index 1371f927423..3fe2bdcae14 100644
--- a/Tools/c-analyzer/check-c-globals.py
+++ b/Tools/c-analyzer/check-c-globals.py
@@ -1,448 +1,35 @@
+from cpython.__main__ import main, configure_logger
 
-from collections import namedtuple
-import glob
-import os.path
-import re
-import shutil
-import sys
-import subprocess
-
-
-VERBOSITY = 2
-
-C_GLOBALS_DIR = os.path.abspath(os.path.dirname(__file__))
-TOOLS_DIR = os.path.dirname(C_GLOBALS_DIR)
-ROOT_DIR = os.path.dirname(TOOLS_DIR)
-GLOBALS_FILE = os.path.join(C_GLOBALS_DIR, 'ignored-globals.txt')
-
-SOURCE_DIRS = ['Include', 'Objects', 'Modules', 'Parser', 'Python']
-
-CAPI_REGEX = re.compile(r'^ *PyAPI_DATA\([^)]*\) \W*(_?Py\w+(?:, \w+)*\w).*;.*$')
-
-
-IGNORED_VARS = {
-        '_DYNAMIC',
-        '_GLOBAL_OFFSET_TABLE_',
-        '__JCR_LIST__',
-        '__JCR_END__',
-        '__TMC_END__',
-        '__bss_start',
-        '__data_start',
-        '__dso_handle',
-        '_edata',
-        '_end',
-        }
-
-
-def find_capi_vars(root):
-    capi_vars = {}
-    for dirname in SOURCE_DIRS:
-        for filename in glob.glob(os.path.join(
-                                  glob.escape(os.path.join(ROOT_DIR, dirname)),
-                                  '**/*.[hc]'),
-                                  recursive=True):
-            with open(filename) as file:
-                for name in _find_capi_vars(file):
-                    if name in capi_vars:
-                        assert not filename.endswith('.c')
-                        assert capi_vars[name].endswith('.c')
-                    capi_vars[name] = filename
-    return capi_vars
-
-
-def _find_capi_vars(lines):
-    for line in lines:
-        if not line.startswith('PyAPI_DATA'):
-            continue
-        assert '{' not in line
-        match = CAPI_REGEX.match(line)
-        assert match
-        names, = match.groups()
-        for name in names.split(', '):
-            yield name
-
-
-def _read_global_names(filename):
-    # These variables are shared between all interpreters in the process.
-    with open(filename) as file:
-        return {line.partition('#')[0].strip()
-                for line in file
-                if line.strip() and not line.startswith('#')}
-
-
-def _is_global_var(name, globalnames):
-    if _is_autogen_var(name):
-        return True
-    if _is_type_var(name):
-        return True
-    if _is_module(name):
-        return True
-    if _is_exception(name):
-        return True
-    if _is_compiler(name):
-        return True
-    return name in globalnames
-
-
-def _is_autogen_var(name):
-    return (
-        name.startswith('PyId_') or
-        '.' in name or
-        # Objects/typeobject.c
-        name.startswith('op_id.') or
-        name.startswith('rop_id.') or
-        # Python/graminit.c
-        name.startswith('arcs_') or
-        name.startswith('states_')
-        )
-
-
-def _is_type_var(name):
-    if name.endswith(('Type', '_Type', '_type')):  # XXX Always a static type?
-        return True
-    if name.endswith('_desc'):  # for structseq types
-        return True
-    return (
-        name.startswith('doc_') or
-        name.endswith(('_doc', '__doc__', '_docstring')) or
-        name.endswith('_methods') or
-        name.endswith('_fields') or
-        name.endswith(('_memberlist', '_members')) or
-        name.endswith('_slots') or
-        name.endswith(('_getset', '_getsets', '_getsetlist')) or
-        name.endswith('_as_mapping') or
-        name.endswith('_as_number') or
-        name.endswith('_as_sequence') or
-        name.endswith('_as_buffer') or
-        name.endswith('_as_async')
-        )
-
-
-def _is_module(name):
-    if name.endswith(('_functions', 'Methods', '_Methods')):
-        return True
-    if name == 'module_def':
-        return True
-    if name == 'initialized':
-        return True
-    return name.endswith(('module', '_Module'))
-
-
-def _is_exception(name):
-    # Other vars are enumerated in globals-core.txt.
-    if not name.startswith(('PyExc_', '_PyExc_')):
-        return False
-    return name.endswith(('Error', 'Warning'))
-
-
-def _is_compiler(name):
-    return (
-        # Python/Python-ast.c
-        name.endswith('_type') or
-        name.endswith('_singleton') or
-        name.endswith('_attributes')
-        )
-
-
-class Var(namedtuple('Var', 'name kind scope capi filename')):
-
-    @classmethod
-    def parse_nm(cls, line, expected, ignored, capi_vars, globalnames):
-        _, _, line = line.partition(' ')  # strip off the address
-        line = line.strip()
-        kind, _, line = line.partition(' ')
-        if kind in ignored or ():
-            return None
-        elif kind not in expected or ():
-            raise RuntimeError('unsupported NM type {!r}'.format(kind))
-
-        name, _, filename = line.partition('\t')
-        name = name.strip()
-        if _is_autogen_var(name):
-            return None
-        if _is_global_var(name, globalnames):
-            scope = 'global'
-        else:
-            scope = None
-        capi = (name in capi_vars or ())
-        if filename:
-            filename = os.path.relpath(filename.partition(':')[0])
-        return cls(name, kind, scope, capi, filename or '~???~')
-
-    @property
-    def external(self):
-        return self.kind.isupper()
-
-
-def find_vars(root, globals_filename=GLOBALS_FILE):
-    python = os.path.join(root, 'python')
-    if not os.path.exists(python):
-        raise RuntimeError('python binary missing (need to build it first?)')
-    capi_vars = find_capi_vars(root)
-    globalnames = _read_global_names(globals_filename)
-
-    nm = shutil.which('nm')
-    if nm is None:
-        # XXX Use dumpbin.exe /SYMBOLS on Windows.
-        raise NotImplementedError
-    else:
-        yield from (var
-                    for var in _find_var_symbols(python, nm, capi_vars,
-                                                 globalnames)
-                    if var.name not in IGNORED_VARS)
-
-
-NM_FUNCS = set('Tt')
-NM_PUBLIC_VARS = set('BD')
-NM_PRIVATE_VARS = set('bd')
-NM_VARS = NM_PUBLIC_VARS | NM_PRIVATE_VARS
-NM_DATA = set('Rr')
-NM_OTHER = set('ACGgiINpSsuUVvWw-?')
-NM_IGNORED = NM_FUNCS | NM_DATA | NM_OTHER
-
-
-def _find_var_symbols(python, nm, capi_vars, globalnames):
-    args = [nm,
-            '--line-numbers',
-            python]
-    out = subprocess.check_output(args)
-    for line in out.decode('utf-8').splitlines():
-        var = Var.parse_nm(line, NM_VARS, NM_IGNORED, capi_vars, globalnames)
-        if var is None:
-            continue
-        yield var
-
-
-#######################################
-
-class Filter(namedtuple('Filter', 'name op value action')):
-
-    @classmethod
-    def parse(cls, raw):
-        action = '+'
-        if raw.startswith(('+', '-')):
-            action = raw[0]
-            raw = raw[1:]
-        # XXX Support < and >?
-        name, op, value = raw.partition('=')
-        return cls(name, op, value, action)
-
-    def check(self, var):
-        value = getattr(var, self.name, None)
-        if not self.op:
-            matched = bool(value)
-        elif self.op == '=':
-            matched = (value == self.value)
-        else:
-            raise NotImplementedError
-
-        if self.action == '+':
-            return matched
-        elif self.action == '-':
-            return not matched
-        else:
-            raise NotImplementedError
-
-
-def filter_var(var, filters):
-    for filter in filters:
-        if not filter.check(var):
-            return False
-    return True
-
-
-def make_sort_key(spec):
-    columns = [(col.strip('_'), '_' if col.startswith('_') else '')
-               for col in spec]
-    def sort_key(var):
-        return tuple(getattr(var, col).lstrip(prefix)
-                     for col, prefix in columns)
-    return sort_key
-
-
-def make_groups(allvars, spec):
-    group = spec
-    groups = {}
-    for var in allvars:
-        value = getattr(var, group)
-        key = '{}: {}'.format(group, value)
-        try:
-            groupvars = groups[key]
-        except KeyError:
-            groupvars = groups[key] = []
-        groupvars.append(var)
-    return groups
-
-
-def format_groups(groups, columns, fmts, widths):
-    for group in sorted(groups):
-        groupvars = groups[group]
-        yield '', 0
-        yield '  # {}'.format(group), 0
-        yield from format_vars(groupvars, columns, fmts, widths)
-
-
-def format_vars(allvars, columns, fmts, widths):
-    fmt = ' '.join(fmts[col] for col in columns)
-    fmt = ' ' + fmt.replace(' ', '   ') + ' '  # for div margin
-    header = fmt.replace(':', ':^').format(*(col.upper() for col in columns))
-    yield header, 0
-    div = ' '.join('-'*(widths[col]+2) for col in columns)
-    yield div, 0
-    for var in allvars:
-        values = (getattr(var, col) for col in columns)
-        row = fmt.format(*('X' if val is True else val or ''
-                           for val in values))
-        yield row, 1
-    yield div, 0
-
-
-#######################################
-
-COLUMNS = 'name,external,capi,scope,filename'
-COLUMN_NAMES = COLUMNS.split(',')
-
-COLUMN_WIDTHS = {col: len(col)
-                 for col in COLUMN_NAMES}
-COLUMN_WIDTHS.update({
-        'name': 50,
-        'scope': 7,
-        'filename': 40,
-        })
-COLUMN_FORMATS = {col: '{:%s}' % width
-                  for col, width in COLUMN_WIDTHS.items()}
-for col in COLUMN_FORMATS:
-    if COLUMN_WIDTHS[col] == len(col):
-        COLUMN_FORMATS[col] = COLUMN_FORMATS[col].replace(':', ':^')
-
-
-def _parse_filters_arg(raw, error):
-    filters = []
-    for value in raw.split(','):
-        value=value.strip()
-        if not value:
-            continue
-        try:
-            filter = Filter.parse(value)
-            if filter.name not in COLUMN_NAMES:
-                raise Exception('unsupported column {!r}'.format(filter.name))
-        except Exception as e:
-            error('bad filter {!r}: {}'.format(raw, e))
-        filters.append(filter)
-    return filters
-
-
-def _parse_columns_arg(raw, error):
-    columns = raw.split(',')
-    for column in columns:
-        if column not in COLUMN_NAMES:
-            error('unsupported column {!r}'.format(column))
-    return columns
-
-
-def _parse_sort_arg(raw, error):
-    sort = raw.split(',')
-    for column in sort:
-        if column.lstrip('_') not in COLUMN_NAMES:
-            error('unsupported column {!r}'.format(column))
-    return sort
-
-
-def _parse_group_arg(raw, error):
-    if not raw:
-        return raw
-    group = raw
-    if group not in COLUMN_NAMES:
-        error('unsupported column {!r}'.format(group))
-    if group != 'filename':
-        error('unsupported group {!r}'.format(group))
-    return group
-
-
-def parse_args(argv=None):
-    if argv is None:
-        argv = sys.argv[1:]
 
+def parse_args():
     import argparse
+    from c_common.scriptutil import (
+        add_verbosity_cli,
+        add_traceback_cli,
+        process_args_by_key,
+    )
+    from cpython.__main__ import _cli_check
     parser = argparse.ArgumentParser()
+    processors = [
+        add_verbosity_cli(parser),
+        add_traceback_cli(parser),
+        _cli_check(parser, checks='<globals>'),
+    ]
 
-    parser.add_argument('-v', '--verbose', action='count', default=0)
-    parser.add_argument('-q', '--quiet', action='count', default=0)
-
-    parser.add_argument('--filters', default='-scope',
-                        help='[[-]<COLUMN>[=<GLOB>]] ...')
-
-    parser.add_argument('--columns', default=COLUMNS,
-                        help='a comma-separated list of columns to show')
-    parser.add_argument('--sort', default='filename,_name',
-                        help='a comma-separated list of columns to sort')
-    parser.add_argument('--group',
-                        help='group by the given column name (- to not group)')
-
-    parser.add_argument('--rc-on-match', dest='rc', type=int)
-
-    parser.add_argument('filename', nargs='?', default=GLOBALS_FILE)
-
-    args = parser.parse_args(argv)
-
-    verbose = vars(args).pop('verbose', 0)
-    quiet = vars(args).pop('quiet', 0)
-    args.verbosity = max(0, VERBOSITY + verbose - quiet)
-
-    if args.sort.startswith('filename') and not args.group:
-        args.group = 'filename'
-
-    if args.rc is None:
-        if '-scope=core' in args.filters or 'core' not in args.filters:
-            args.rc = 0
-        else:
-            args.rc = 1
-
-    args.filters = _parse_filters_arg(args.filters, parser.error)
-    args.columns = _parse_columns_arg(args.columns, parser.error)
-    args.sort = _parse_sort_arg(args.sort, parser.error)
-    args.group = _parse_group_arg(args.group, parser.error)
-
-    return args
-
-
-def main(root=ROOT_DIR, filename=GLOBALS_FILE,
-         filters=None, columns=COLUMN_NAMES, sort=None, group=None,
-         verbosity=VERBOSITY, rc=1):
-
-    log = lambda msg: ...
-    if verbosity >= 2:
-        log = lambda msg: print(msg)
-
-    allvars = (var
-               for var in find_vars(root, filename)
-               if filter_var(var, filters))
-    if sort:
-        allvars = sorted(allvars, key=make_sort_key(sort))
-
-    if group:
-        try:
-            columns.remove(group)
-        except ValueError:
-            pass
-        grouped = make_groups(allvars, group)
-        lines = format_groups(grouped, columns, COLUMN_FORMATS, COLUMN_WIDTHS)
-    else:
-        lines = format_vars(allvars, columns, COLUMN_FORMATS, COLUMN_WIDTHS)
+    args = parser.parse_args()
+    ns = vars(args)
 
-    total = 0
-    for line, count in lines:
-        total += count
-        log(line)
-    log('\ntotal: {}'.format(total))
+    cmd = 'check'
+    verbosity, traceback_cm = process_args_by_key(
+        args,
+        processors,
+        ['verbosity', 'traceback_cm'],
+    )
 
-    if total and rc:
-        print('ERROR: found unsafe globals', file=sys.stderr)
-        return rc
-    return 0
+    return cmd, ns, verbosity, traceback_cm
 
 
-if __name__ == '__main__':
-    args = parse_args()
-    sys.exit(
-            main(**vars(args)))
+(cmd, cmd_kwargs, verbosity, traceback_cm) = parse_args()
+configure_logger(verbosity)
+with traceback_cm:
+    main(cmd, cmd_kwargs)
diff --git a/Tools/c-analyzer/cpython/README b/Tools/c-analyzer/cpython/README
deleted file mode 100644
index 772b8be2700..00000000000
--- a/Tools/c-analyzer/cpython/README
+++ /dev/null
@@ -1,72 +0,0 @@
-#######################################
-# C Globals and CPython Runtime State.
-
-CPython's C code makes extensive use of global variables (whether static
-globals or static locals).  Each such variable falls into one of several
-categories:
-
-* strictly const data
-* used exclusively in main or in the REPL
-* process-global state (e.g. managing process-level resources
-  like signals and file descriptors)
-* Python "global" runtime state
-* per-interpreter runtime state
-
-The last one can be a problem as soon as anyone creates a second
-interpreter (AKA "subinterpreter") in a process.  It is definitely a
-problem under subinterpreters if they are no longer sharing the GIL,
-since the GIL protects us from a lot of race conditions.  Keep in mind
-that ultimately *all* objects (PyObject) should be treated as
-per-interpreter state.  This includes "static types", freelists,
-_PyIdentifier, and singletons.  Take that in for a second.  It has
-significant implications on where we use static variables!
-
-Be aware that module-global state (stored in C statics) is a kind of
-per-interpreter state.  There have been efforts across many years, and
-still going, to provide extension module authors mechanisms to store
-that state safely (see PEPs 3121, 489, etc.).
-
-(Note that there has been discussion around support for running multiple
-Python runtimes in the same process.  That would ends up with the same
-problems, relative to static variables, that subinterpreters have.)
-
-Historically we have been bad at keeping per-interpreter state out of
-static variables, mostly because until recently subinterpreters were
-not widely used nor even factored in to solutions.  However, the
-feature is growing in popularity and use in the community.
-
-Mandate: "Eliminate use of static variables for per-interpreter state."
-
-The "c-statics.py" script in this directory, along with its accompanying
-data files, are part of the effort to resolve existing problems with
-our use of static variables and to prevent future problems.
-
-#-------------------------
-## statics for actually-global state (and runtime state consolidation)
-
-In general, holding any kind of state in static variables
-increases maintenance burden and increases the complexity of code (e.g.
-we use TSS to identify the active thread state).  So it is a good idea
-to avoid using statics for state even if for the "global" runtime or
-for process-global state.
-
-Relative to maintenance burden, one problem is where the runtime
-state is spread throughout the codebase in dozens of individual
-globals.  Unlike the other globals, the runtime state represents a set
-of values that are constantly shifting in a complex way.  When they are
-spread out it's harder to get a clear picture of what the runtime
-involves.  Furthermore, when they are spread out it complicates efforts
-that change the runtime.
-
-Consequently, the globals for Python's runtime state have been
-consolidated under a single top-level _PyRuntime global. No new globals
-should be added for runtime state.  Instead, they should be added to
-_PyRuntimeState or one of its sub-structs.  The tools in this directory
-are run as part of the test suite to ensure that no new globals have
-been added.  The script can be run manually as well:
-
-  ./python Lib/test/test_c_statics/c-statics.py check
-
-If it reports any globals then they should be resolved.  If the globals
-are runtime state then they should be folded into _PyRuntimeState.
-Otherwise they should be marked as ignored.
diff --git a/Tools/c-analyzer/cpython/__init__.py b/Tools/c-analyzer/cpython/__init__.py
index ae45b424e3c..d0b3eff3c4b 100644
--- a/Tools/c-analyzer/cpython/__init__.py
+++ b/Tools/c-analyzer/cpython/__init__.py
@@ -1,29 +1,20 @@
 import os.path
-import sys
 
 
-TOOL_ROOT = os.path.abspath(
+TOOL_ROOT = os.path.normcase(
+    os.path.abspath(
         os.path.dirname(  # c-analyzer/
-            os.path.dirname(__file__)))  # cpython/
-DATA_DIR = TOOL_ROOT
+            os.path.dirname(__file__))))  # cpython/
 REPO_ROOT = (
         os.path.dirname(  # ..
             os.path.dirname(TOOL_ROOT)))  # Tools/
 
 INCLUDE_DIRS = [os.path.join(REPO_ROOT, name) for name in [
-        'Include',
-        ]]
+    'Include',
+]]
 SOURCE_DIRS = [os.path.join(REPO_ROOT, name) for name in [
-        'Python',
-        'Parser',
-        'Objects',
-        'Modules',
-        ]]
-
-#PYTHON = os.path.join(REPO_ROOT, 'python')
-PYTHON = sys.executable
-
-
-# Clean up the namespace.
-del sys
-del os
+    'Python',
+    'Parser',
+    'Objects',
+    'Modules',
+]]
diff --git a/Tools/c-analyzer/cpython/__main__.py b/Tools/c-analyzer/cpython/__main__.py
index 6b0f9bcb968..23a3de06f63 100644
--- a/Tools/c-analyzer/cpython/__main__.py
+++ b/Tools/c-analyzer/cpython/__main__.py
@@ -1,212 +1,280 @@
-import argparse
-import re
+import logging
 import sys
 
-from c_analyzer.common import show
-from c_analyzer.common.info import UNKNOWN
+from c_common.fsutil import expand_filenames, iter_files_by_suffix
+from c_common.scriptutil import (
+    add_verbosity_cli,
+    add_traceback_cli,
+    add_commands_cli,
+    add_kind_filtering_cli,
+    add_files_cli,
+    process_args_by_key,
+    configure_logger,
+    get_prog,
+)
+from c_parser.info import KIND
+import c_parser.__main__ as c_parser
+import c_analyzer.__main__ as c_analyzer
+import c_analyzer as _c_analyzer
+from c_analyzer.info import UNKNOWN
+from . import _analyzer, _parser, REPO_ROOT
+
+
+logger = logging.getLogger(__name__)
+
+
+def _resolve_filenames(filenames):
+    if filenames:
+        resolved = (_parser.resolve_filename(f) for f in filenames)
+    else:
+        resolved = _parser.iter_filenames()
+    return resolved
+
+
+def fmt_summary(analysis):
+    # XXX Support sorting and grouping.
+    supported = []
+    unsupported = []
+    for item in analysis:
+        if item.supported:
+            supported.append(item)
+        else:
+            unsupported.append(item)
+    total = 0
+
+    def section(name, groupitems):
+        nonlocal total
+        items, render = c_analyzer.build_section(name, groupitems,
+                                                 relroot=REPO_ROOT)
+        yield from render()
+        total += len(items)
+
+    yield ''
+    yield '===================='
+    yield 'supported'
+    yield '===================='
+
+    yield from section('types', supported)
+    yield from section('variables', supported)
+
+    yield ''
+    yield '===================='
+    yield 'unsupported'
+    yield '===================='
+
+    yield from section('types', unsupported)
+    yield from section('variables', unsupported)
+
+    yield ''
+    yield f'grand total: {total}'
+
 
-from . import SOURCE_DIRS
-from .find import supported_vars
-from .known import (
-    from_file as known_from_file,
-    DATA_FILE as KNOWN_FILE,
+#######################################
+# the checks
+
+CHECKS = dict(c_analyzer.CHECKS, **{
+    'globals': _analyzer.check_globals,
+})
+
+#######################################
+# the commands
+
+FILES_KWARGS = dict(excluded=_parser.EXCLUDED, nargs='*')
+
+
+def _cli_parse(parser):
+    process_output = c_parser.add_output_cli(parser)
+    process_kind = add_kind_filtering_cli(parser)
+    process_preprocessor = c_parser.add_preprocessor_cli(
+        parser,
+        get_preprocessor=_parser.get_preprocessor,
+    )
+    process_files = add_files_cli(parser, **FILES_KWARGS)
+    return [
+        process_output,
+        process_kind,
+        process_preprocessor,
+        process_files,
+    ]
+
+
+def cmd_parse(filenames=None, **kwargs):
+    filenames = _resolve_filenames(filenames)
+    if 'get_file_preprocessor' not in kwargs:
+        kwargs['get_file_preprocessor'] = _parser.get_preprocessor()
+    c_parser.cmd_parse(filenames, **kwargs)
+
+
+def _cli_check(parser, **kwargs):
+    return c_analyzer._cli_check(parser, CHECKS, **kwargs, **FILES_KWARGS)
+
+
+def cmd_check(filenames=None, **kwargs):
+    filenames = _resolve_filenames(filenames)
+    kwargs['get_file_preprocessor'] = _parser.get_preprocessor(log_err=print)
+    c_analyzer.cmd_check(
+        filenames,
+        relroot=REPO_ROOT,
+        _analyze=_analyzer.analyze,
+        _CHECKS=CHECKS,
+        **kwargs
     )
-from .supported import IGNORED_FILE
-
-
-def _check_results(unknown, knownvars, used):
-    def _match_unused_global(variable):
-        found = []
-        for varid in knownvars:
-            if varid in used:
-                continue
-            if varid.funcname is not None:
-                continue
-            if varid.name != variable.name:
-                continue
-            if variable.filename and variable.filename != UNKNOWN:
-                if variable.filename == varid.filename:
-                    found.append(varid)
-            else:
-                found.append(varid)
-        return found
-
-    badknown = set()
-    for variable in sorted(unknown):
-        msg = None
-        if variable.funcname != UNKNOWN:
-            msg = f'could not find global symbol {variable.id}'
-        elif m := _match_unused_global(variable):
-            assert isinstance(m, list)
-            badknown.update(m)
-        elif variable.name in ('completed', 'id'):  # XXX Figure out where these variables are.
-            unknown.remove(variable)
-        else:
-            msg = f'could not find local symbol {variable.id}'
-        if msg:
-            #raise Exception(msg)
-            print(msg)
-    if badknown:
-        print('---')
-        print(f'{len(badknown)} globals in known.tsv, but may actually be local:')
-        for varid in sorted(badknown):
-            print(f'{varid.filename:30} {varid.name}')
-    unused = sorted(varid
-                    for varid in set(knownvars) - used
-                    if varid.name != 'id')  # XXX Figure out where these variables are.
-    if unused:
-        print('---')
-        print(f'did not use {len(unused)} known vars:')
-        for varid in unused:
-            print(f'{varid.filename:30} {varid.funcname or "-":20} {varid.name}')
-        raise Exception('not all known symbols used')
-    if unknown:
-        print('---')
-        raise Exception('could not find all symbols')
-
-
-# XXX Move this check to its own command.
-def cmd_check_cache(cmd, *,
-                    known=KNOWN_FILE,
-                    ignored=IGNORED_FILE,
-                    _known_from_file=known_from_file,
-                    _find=supported_vars,
-                    ):
-    known = _known_from_file(known)
-
-    used = set()
-    unknown = set()
-    for var, supported in _find(known=known, ignored=ignored):
-        if supported is None:
-            unknown.add(var)
-            continue
-        used.add(var.id)
-    _check_results(unknown, known['variables'], used)
-
-
-def cmd_check(cmd, *,
-              known=KNOWN_FILE,
-              ignored=IGNORED_FILE,
-              _find=supported_vars,
-              _show=show.basic,
-              _print=print,
-              ):
-    """
-    Fail if there are unsupported globals variables.
-
-    In the failure case, the list of unsupported variables
-    will be printed out.
-    """
-    unsupported = []
-    for var, supported in _find(known=known, ignored=ignored):
-        if not supported:
-            unsupported.append(var)
-
-    if not unsupported:
-        #_print('okay')
-        return
-
-    _print('ERROR: found unsupported global variables')
-    _print()
-    _show(sorted(unsupported))
-    _print(f' ({len(unsupported)} total)')
-    sys.exit(1)
-
-
-def cmd_show(cmd, *,
-             known=KNOWN_FILE,
-             ignored=IGNORED_FILE,
-             skip_objects=False,
-              _find=supported_vars,
-             _show=show.basic,
-             _print=print,
-             ):
-    """
-    Print out the list of found global variables.
-
-    The variables will be distinguished as "supported" or "unsupported".
-    """
-    allsupported = []
-    allunsupported = []
-    for found, supported in _find(known=known,
-                                  ignored=ignored,
-                                  skip_objects=skip_objects,
-                                  ):
-        if supported is None:
-            continue
-        (allsupported if supported else allunsupported
-         ).append(found)
-
-    _print('supported:')
-    _print('----------')
-    _show(sorted(allsupported))
-    _print(f' ({len(allsupported)} total)')
-    _print()
-    _print('unsupported:')
-    _print('------------')
-    _show(sorted(allunsupported))
-    _print(f' ({len(allunsupported)} total)')
-
-
-#############################
-# the script
 
-COMMANDS = {
-        'check': cmd_check,
-        'show': cmd_show,
-        }
-
-PROG = sys.argv[0]
-PROG = 'c-globals.py'
-
-
-def parse_args(prog=PROG, argv=sys.argv[1:], *, _fail=None):
-    common = argparse.ArgumentParser(add_help=False)
-    common.add_argument('--ignored', metavar='FILE',
-                        default=IGNORED_FILE,
-                        help='path to file that lists ignored vars')
-    common.add_argument('--known', metavar='FILE',
-                        default=KNOWN_FILE,
-                        help='path to file that lists known types')
-    #common.add_argument('dirs', metavar='DIR', nargs='*',
-    #                    default=SOURCE_DIRS,
-    #                    help='a directory to check')
 
-    parser = argparse.ArgumentParser(
-            prog=prog,
+def cmd_analyze(filenames=None, **kwargs):
+    formats = dict(c_analyzer.FORMATS)
+    formats['summary'] = fmt_summary
+    filenames = _resolve_filenames(filenames)
+    kwargs['get_file_preprocessor'] = _parser.get_preprocessor(log_err=print)
+    c_analyzer.cmd_analyze(
+        filenames,
+        _analyze=_analyzer.analyze,
+        formats=formats,
+        **kwargs
+    )
+
+
+def _cli_data(parser):
+    filenames = False
+    known = True
+    return c_analyzer._cli_data(parser, filenames, known)
+
+
+def cmd_data(datacmd, **kwargs):
+    formats = dict(c_analyzer.FORMATS)
+    formats['summary'] = fmt_summary
+    filenames = (file
+                 for file in _resolve_filenames(None)
+                 if file not in _parser.EXCLUDED)
+    kwargs['get_file_preprocessor'] = _parser.get_preprocessor(log_err=print)
+    if datacmd == 'show':
+        types = _analyzer.read_known()
+        results = []
+        for decl, info in types.items():
+            if info is UNKNOWN:
+                if decl.kind in (KIND.STRUCT, KIND.UNION):
+                    extra = {'unsupported': ['type unknown'] * len(decl.members)}
+                else:
+                    extra = {'unsupported': ['type unknown']}
+                info = (info, extra)
+            results.append((decl, info))
+            if decl.shortkey == 'struct _object':
+                tempinfo = info
+        known = _analyzer.Analysis.from_results(results)
+        analyze = None
+    elif datacmd == 'dump':
+        known = _analyzer.KNOWN_FILE
+        def analyze(files, **kwargs):
+            decls = []
+            for decl in _analyzer.iter_decls(files, **kwargs):
+                if not KIND.is_type_decl(decl.kind):
+                    continue
+                if not decl.filename.endswith('.h'):
+                    if decl.shortkey not in _analyzer.KNOWN_IN_DOT_C:
+                        continue
+                decls.append(decl)
+            results = _c_analyzer.analyze_decls(
+                decls,
+                known={},
+                analyze_resolved=_analyzer.analyze_resolved,
             )
-    subs = parser.add_subparsers(dest='cmd')
+            return _analyzer.Analysis.from_results(results)
+    else:
+        known = _analyzer.read_known()
+        def analyze(files, **kwargs):
+            return _analyzer.iter_decls(files, **kwargs)
+    extracolumns = None
+    c_analyzer.cmd_data(
+        datacmd,
+        filenames,
+        known,
+        _analyze=analyze,
+        formats=formats,
+        extracolumns=extracolumns,
+        relroot=REPO_ROOT,
+        **kwargs
+    )
 
-    check = subs.add_parser('check', parents=[common])
 
-    show = subs.add_parser('show', parents=[common])
-    show.add_argument('--skip-objects', action='store_true')
+# We do not define any other cmd_*() handlers here,
+# favoring those defined elsewhere.
 
-    if _fail is None:
-        def _fail(msg):
-            parser.error(msg)
+COMMANDS = {
+    'check': (
+        'analyze and fail if the CPython source code has any problems',
+        [_cli_check],
+        cmd_check,
+    ),
+    'analyze': (
+        'report on the state of the CPython source code',
+        [(lambda p: c_analyzer._cli_analyze(p, **FILES_KWARGS))],
+        cmd_analyze,
+    ),
+    'parse': (
+        'parse the CPython source files',
+        [_cli_parse],
+        cmd_parse,
+    ),
+    'data': (
+        'check/manage local data (e.g. knwon types, ignored vars, caches)',
+        [_cli_data],
+        cmd_data,
+    ),
+}
+
+
+#######################################
+# the script
+
+def parse_args(argv=sys.argv[1:], prog=None, *, subset=None):
+    import argparse
+    parser = argparse.ArgumentParser(
+        prog=prog or get_prog(),
+    )
+
+#    if subset == 'check' or subset == ['check']:
+#        if checks is not None:
+#            commands = dict(COMMANDS)
+#            commands['check'] = list(commands['check'])
+#            cli = commands['check'][1][0]
+#            commands['check'][1][0] = (lambda p: cli(p, checks=checks))
+    processors = add_commands_cli(
+        parser,
+        commands=COMMANDS,
+        commonspecs=[
+            add_verbosity_cli,
+            add_traceback_cli,
+        ],
+        subset=subset,
+    )
 
-    # Now parse the args.
     args = parser.parse_args(argv)
     ns = vars(args)
 
     cmd = ns.pop('cmd')
-    if not cmd:
-        _fail('missing command')
 
-    return cmd, ns
+    verbosity, traceback_cm = process_args_by_key(
+        args,
+        processors[cmd],
+        ['verbosity', 'traceback_cm'],
+    )
+    if cmd != 'parse':
+        # "verbosity" is sent to the commands, so we put it back.
+        args.verbosity = verbosity
+
+    return cmd, ns, verbosity, traceback_cm
 
 
-def main(cmd, cmdkwargs=None, *, _COMMANDS=COMMANDS):
+def main(cmd, cmd_kwargs):
     try:
-        cmdfunc = _COMMANDS[cmd]
+        run_cmd = COMMANDS[cmd][-1]
     except KeyError:
-        raise ValueError(
-            f'unsupported cmd {cmd!r}' if cmd else 'missing cmd')
-
-    cmdfunc(cmd, **cmdkwargs or {})
+        raise ValueError(f'unsupported cmd {cmd!r}')
+    run_cmd(**cmd_kwargs)
 
 
 if __name__ == '__main__':
-    cmd, cmdkwargs = parse_args()
-    main(cmd, cmdkwargs)
+    cmd, cmd_kwargs, verbosity, traceback_cm = parse_args()
+    configure_logger(verbosity)
+    with traceback_cm:
+        main(cmd, cmd_kwargs)
diff --git a/Tools/c-analyzer/cpython/_analyzer.py b/Tools/c-analyzer/cpython/_analyzer.py
new file mode 100644
index 00000000000..98f8888651e
--- /dev/null
+++ b/Tools/c-analyzer/cpython/_analyzer.py
@@ -0,0 +1,348 @@
+import os.path
+import re
+
+from c_common.clsutil import classonly
+from c_parser.info import (
+    KIND,
+    DeclID,
+    Declaration,
+    TypeDeclaration,
+    TypeDef,
+    Struct,
+    Member,
+    FIXED_TYPE,
+    is_type_decl,
+    is_pots,
+    is_funcptr,
+    is_process_global,
+    is_fixed_type,
+    is_immutable,
+)
+import c_analyzer as _c_analyzer
+import c_analyzer.info as _info
+import c_analyzer.datafiles as _datafiles
+from . import _parser, REPO_ROOT
+
+
+_DATA_DIR = os.path.dirname(__file__)
+KNOWN_FILE = os.path.join(_DATA_DIR, 'known.tsv')
+IGNORED_FILE = os.path.join(_DATA_DIR, 'ignored.tsv')
+KNOWN_IN_DOT_C = {
+    'struct _odictobject': False,
+    'PyTupleObject': False,
+    'struct _typeobject': False,
+    'struct _arena': True,  # ???
+    'struct _frame': False,
+    'struct _ts': True,  # ???
+    'struct PyCodeObject': False,
+    'struct _is': True,  # ???
+    'PyWideStringList': True,  # ???
+    # recursive
+    'struct _dictkeysobject': False,
+}
+# These are loaded from the respective .tsv files upon first use.
+_KNOWN = {
+    # {(file, ID) | ID => info | bool}
+    #'PyWideStringList': True,
+}
+#_KNOWN = {(Struct(None, typeid.partition(' ')[-1], None)
+#           if typeid.startswith('struct ')
+#           else TypeDef(None, typeid, None)
+#           ): ([], {'unsupported': None if supported else True})
+#          for typeid, supported in _KNOWN_IN_DOT_C.items()}
+_IGNORED = {
+    # {ID => reason}
+}
+
+KINDS = frozenset((*KIND.TYPES, KIND.VARIABLE))
+
+
+def read_known():
+    if not _KNOWN:
+        # Cache a copy the first time.
+        extracols = None  # XXX
+        #extracols = ['unsupported']
+        known = _datafiles.read_known(KNOWN_FILE, extracols, REPO_ROOT)
+        # For now we ignore known.values() (i.e. "extra").
+        types, _ = _datafiles.analyze_known(
+            known,
+            analyze_resolved=analyze_resolved,
+        )
+        _KNOWN.update(types)
+    return _KNOWN.copy()
+
+
+def write_known():
+    raise NotImplementedError
+    datafiles.write_known(decls, IGNORED_FILE, ['unsupported'], relroot=REPO_ROOT)
+
+
+def read_ignored():
+    if not _IGNORED:
+        _IGNORED.update(_datafiles.read_ignored(IGNORED_FILE))
+    return dict(_IGNORED)
+
+
+def write_ignored():
+    raise NotImplementedError
+    datafiles.write_ignored(variables, IGNORED_FILE)
+
+
+def analyze(filenames, *,
+            skip_objects=False,
+            **kwargs
+            ):
+    if skip_objects:
+        # XXX Set up a filter.
+        raise NotImplementedError
+
+    known = read_known()
+
+    decls = iter_decls(filenames)
+    results = _c_analyzer.analyze_decls(
+        decls,
+        known,
+        analyze_resolved=analyze_resolved,
+    )
+    analysis = Analysis.from_results(results)
+
+    return analysis
+
+
+def iter_decls(filenames, **kwargs):
+    decls = _c_analyzer.iter_decls(
+        filenames,
+        # We ignore functions (and statements).
+        kinds=KINDS,
+        parse_files=_parser.parse_files,
+        **kwargs
+    )
+    for decl in decls:
+        if not decl.data:
+            # Ignore forward declarations.
+            continue
+        yield decl
+
+
+def analyze_resolved(resolved, decl, types, knowntypes, extra=None):
+    if decl.kind not in KINDS:
+        # Skip it!
+        return None
+
+    typedeps = resolved
+    if typedeps is _info.UNKNOWN:
+        if decl.kind in (KIND.STRUCT, KIND.UNION):
+            typedeps = [typedeps] * len(decl.members)
+        else:
+            typedeps = [typedeps]
+    #assert isinstance(typedeps, (list, TypeDeclaration)), typedeps
+
+    if extra is None:
+        extra = {}
+    elif 'unsupported' in extra:
+        raise NotImplementedError((decl, extra))
+
+    unsupported = _check_unsupported(decl, typedeps, types, knowntypes)
+    extra['unsupported'] = unsupported
+
+    return typedeps, extra
+
+
+def _check_unsupported(decl, typedeps, types, knowntypes):
+    if typedeps is None:
+        raise NotImplementedError(decl)
+
+    if decl.kind in (KIND.STRUCT, KIND.UNION):
+        return _check_members(decl, typedeps, types, knowntypes)
+    elif decl.kind is KIND.ENUM:
+        if typedeps:
+            raise NotImplementedError((decl, typedeps))
+        return None
+    else:
+        return _check_typedep(decl, typedeps, types, knowntypes)
+
+
+def _check_members(decl, typedeps, types, knowntypes):
+    if isinstance(typedeps, TypeDeclaration):
+        raise NotImplementedError((decl, typedeps))
+
+    #members = decl.members or ()  # A forward decl has no members.
+    members = decl.members
+    if not members:
+        # A forward decl has no members, but that shouldn't surface here..
+        raise NotImplementedError(decl)
+    if len(members) != len(typedeps):
+        raise NotImplementedError((decl, typedeps))
+
+    unsupported = []
+    for member, typedecl in zip(members, typedeps):
+        checked = _check_typedep(member, typedecl, types, knowntypes)
+        unsupported.append(checked)
+    if any(None if v is FIXED_TYPE else v for v in unsupported):
+        return unsupported
+    elif FIXED_TYPE in unsupported:
+        return FIXED_TYPE
+    else:
+        return None
+
+
+def _check_typedep(decl, typedecl, types, knowntypes):
+    if not isinstance(typedecl, TypeDeclaration):
+        if hasattr(type(typedecl), '__len__'):
+            if len(typedecl) == 1:
+                typedecl, = typedecl
+    if typedecl is None:
+        # XXX Fail?
+        return 'typespec (missing)'
+    elif typedecl is _info.UNKNOWN:
+        # XXX Is this right?
+        return 'typespec (unknown)'
+    elif not isinstance(typedecl, TypeDeclaration):
+        raise NotImplementedError((decl, typedecl))
+
+    if isinstance(decl, Member):
+        return _check_vartype(decl, typedecl, types, knowntypes)
+    elif not isinstance(decl, Declaration):
+        raise NotImplementedError(decl)
+    elif decl.kind is KIND.TYPEDEF:
+        return _check_vartype(decl, typedecl, types, knowntypes)
+    elif decl.kind is KIND.VARIABLE:
+        if not is_process_global(decl):
+            return None
+        checked = _check_vartype(decl, typedecl, types, knowntypes)
+        return 'mutable' if checked is FIXED_TYPE else checked
+    else:
+        raise NotImplementedError(decl)
+
+
+def _check_vartype(decl, typedecl, types, knowntypes):
+    """Return failure reason."""
+    checked = _check_typespec(decl, typedecl, types, knowntypes)
+    if checked:
+        return checked
+    if is_immutable(decl.vartype):
+        return None
+    if is_fixed_type(decl.vartype):
+        return FIXED_TYPE
+    return 'mutable'
+
+
+def _check_typespec(decl, typedecl, types, knowntypes):
+    typespec = decl.vartype.typespec
+    if typedecl is not None:
+        found = types.get(typedecl)
+        if found is None:
+            found = knowntypes.get(typedecl)
+
+        if found is not None:
+            _, extra = found
+            if extra is None:
+                # XXX Under what circumstances does this happen?
+                extra = {}
+            unsupported = extra.get('unsupported')
+            if unsupported is FIXED_TYPE:
+                unsupported = None
+            return 'typespec' if unsupported else None
+    # Fall back to default known types.
+    if is_pots(typespec):
+        return None
+    elif _info.is_system_type(typespec):
+        return None
+    elif is_funcptr(decl.vartype):
+        return None
+    return 'typespec'
+
+
+class Analyzed(_info.Analyzed):
+
+    @classonly
+    def is_target(cls, raw):
+        if not super().is_target(raw):
+            return False
+        if raw.kind not in KINDS:
+            return False
+        return True
+
+    #@classonly
+    #def _parse_raw_result(cls, result, extra):
+    #    typedecl, extra = super()._parse_raw_result(result, extra)
+    #    if typedecl is None:
+    #        return None, extra
+    #    raise NotImplementedError
+
+    def __init__(self, item, typedecl=None, *, unsupported=None, **extra):
+        if 'unsupported' in extra:
+            raise NotImplementedError((item, typedecl, unsupported, extra))
+        if not unsupported:
+            unsupported = None
+        elif isinstance(unsupported, (str, TypeDeclaration)):
+            unsupported = (unsupported,)
+        elif unsupported is not FIXED_TYPE:
+            unsupported = tuple(unsupported)
+        self.unsupported = unsupported
+        extra['unsupported'] = self.unsupported  # ...for __repr__(), etc.
+        if self.unsupported is None:
+            #self.supported = None
+            self.supported = True
+        elif self.unsupported is FIXED_TYPE:
+            if item.kind is KIND.VARIABLE:
+                raise NotImplementedError(item, typedecl, unsupported)
+            self.supported = True
+        else:
+            self.supported = not self.unsupported
+        super().__init__(item, typedecl, **extra)
+
+    def render(self, fmt='line', *, itemonly=False):
+        if fmt == 'raw':
+            yield repr(self)
+            return
+        rendered = super().render(fmt, itemonly=itemonly)
+        # XXX ???
+        #if itemonly:
+        #    yield from rendered
+        supported = self._supported
+        if fmt in ('line', 'brief'):
+            rendered, = rendered
+            parts = [
+                '+' if supported else '-' if supported is False else '',
+                rendered,
+            ]
+            yield '\t'.join(parts)
+        elif fmt == 'summary':
+            raise NotImplementedError(fmt)
+        elif fmt == 'full':
+            yield from rendered
+            if supported:
+                yield f'\tsupported:\t{supported}'
+        else:
+            raise NotImplementedError(fmt)
+
+
+class Analysis(_info.Analysis):
+    _item_class = Analyzed
+
+    @classonly
+    def build_item(cls, info, result=None):
+        if not isinstance(info, Declaration) or info.kind not in KINDS:
+            raise NotImplementedError((info, result))
+        return super().build_item(info, result)
+
+
+def check_globals(analysis):
+    # yield (data, failure)
+    ignored = read_ignored()
+    for item in analysis:
+        if item.kind != KIND.VARIABLE:
+            continue
+        if item.supported:
+            continue
+        if item.id in ignored:
+            continue
+        reason = item.unsupported
+        if not reason:
+            reason = '???'
+        elif not isinstance(reason, str):
+            if len(reason) == 1:
+                reason, = reason
+        reason = f'({reason})'
+        yield item, f'not supported {reason:20}\t{item.storage or ""} {item.vartype}'
diff --git a/Tools/c-analyzer/cpython/_generate.py b/Tools/c-analyzer/cpython/_generate.py
deleted file mode 100644
index 3456604b814..00000000000
--- a/Tools/c-analyzer/cpython/_generate.py
+++ /dev/null
@@ -1,326 +0,0 @@
-# The code here consists of hacks for pre-populating the known.tsv file.
-
-from c_analyzer.parser.preprocessor import _iter_clean_lines
-from c_analyzer.parser.naive import (
-        iter_variables, parse_variable_declaration, find_variables,
-        )
-from c_analyzer.common.known import HEADER as KNOWN_HEADER
-from c_analyzer.common.info import UNKNOWN, ID
-from c_analyzer.variables import Variable
-from c_analyzer.util import write_tsv
-
-from . import SOURCE_DIRS, REPO_ROOT
-from .known import DATA_FILE as KNOWN_FILE
-from .files import iter_cpython_files
-
-
-POTS = ('char ', 'wchar_t ', 'int ', 'Py_ssize_t ')
-POTS += tuple('const ' + v for v in POTS)
-STRUCTS = ('PyTypeObject', 'PyObject', 'PyMethodDef', 'PyModuleDef', 'grammar')
-
-
-def _parse_global(line, funcname=None):
-    line = line.strip()
-    if line.startswith('static '):
-        if '(' in line and '[' not in line and ' = ' not in line:
-            return None, None
-        name, decl = parse_variable_declaration(line)
-    elif line.startswith(('Py_LOCAL(', 'Py_LOCAL_INLINE(')):
-        name, decl = parse_variable_declaration(line)
-    elif line.startswith('_Py_static_string('):
-        decl = line.strip(';').strip()
-        name = line.split('(')[1].split(',')[0].strip()
-    elif line.startswith('_Py_IDENTIFIER('):
-        decl = line.strip(';').strip()
-        name = 'PyId_' + line.split('(')[1].split(')')[0].strip()
-    elif funcname:
-        return None, None
-
-    # global-only
-    elif line.startswith('PyAPI_DATA('):  # only in .h files
-        name, decl = parse_variable_declaration(line)
-    elif line.startswith('extern '):  # only in .h files
-        name, decl = parse_variable_declaration(line)
-    elif line.startswith('PyDoc_VAR('):
-        decl = line.strip(';').strip()
-        name = line.split('(')[1].split(')')[0].strip()
-    elif line.startswith(POTS):  # implied static
-        if '(' in line and '[' not in line and ' = ' not in line:
-            return None, None
-        name, decl = parse_variable_declaration(line)
-    elif line.startswith(STRUCTS) and line.endswith(' = {'):  # implied static
-        name, decl = parse_variable_declaration(line)
-    elif line.startswith(STRUCTS) and line.endswith(' = NULL;'):  # implied static
-        name, decl = parse_variable_declaration(line)
-    elif line.startswith('struct '):
-        if not line.endswith(' = {'):
-            return None, None
-        if not line.partition(' ')[2].startswith(STRUCTS):
-            return None, None
-        # implied static
-        name, decl = parse_variable_declaration(line)
-
-    # file-specific
-    elif line.startswith(('SLOT1BINFULL(', 'SLOT1BIN(')):
-        # Objects/typeobject.c
-        funcname = line.split('(')[1].split(',')[0]
-        return [
-                ('op_id', funcname, '_Py_static_string(op_id, OPSTR)'),
-                ('rop_id', funcname, '_Py_static_string(op_id, OPSTR)'),
-                ]
-    elif line.startswith('WRAP_METHOD('):
-        # Objects/weakrefobject.c
-        funcname, name = (v.strip() for v in line.split('(')[1].split(')')[0].split(','))
-        return [
-                ('PyId_' + name, funcname, f'_Py_IDENTIFIER({name})'),
-                ]
-
-    else:
-        return None, None
-    return name, decl
-
-
-def _pop_cached(varcache, filename, funcname, name, *,
-                _iter_variables=iter_variables,
-                ):
-    # Look for the file.
-    try:
-        cached = varcache[filename]
-    except KeyError:
-        cached = varcache[filename] = {}
-        for variable in _iter_variables(filename,
-                                        parse_variable=_parse_global,
-                                        ):
-            variable._isglobal = True
-            cached[variable.id] = variable
-        for var in cached:
-            print(' ', var)
-
-    # Look for the variable.
-    if funcname == UNKNOWN:
-        for varid in cached:
-            if varid.name == name:
-                break
-        else:
-            return None
-        return cached.pop(varid)
-    else:
-        return cached.pop((filename, funcname, name), None)
-
-
-def find_matching_variable(varid, varcache, allfilenames, *,
-                           _pop_cached=_pop_cached,
-                           ):
-    if varid.filename and varid.filename != UNKNOWN:
-        filenames = [varid.filename]
-    else:
-        filenames = allfilenames
-    for filename in filenames:
-        variable = _pop_cached(varcache, filename, varid.funcname, varid.name)
-        if variable is not None:
-            return variable
-    else:
-        if varid.filename and varid.filename != UNKNOWN and varid.funcname is None:
-            for filename in allfilenames:
-                if not filename.endswith('.h'):
-                    continue
-                variable = _pop_cached(varcache, filename, None, varid.name)
-                if variable is not None:
-                    return variable
-        return None
-
-
-MULTILINE = {
-    # Python/Python-ast.c
-    'Load_singleton': 'PyObject *',
-    'Store_singleton': 'PyObject *',
-    'Del_singleton': 'PyObject *',
-    'AugLoad_singleton': 'PyObject *',
-    'AugStore_singleton': 'PyObject *',
-    'Param_singleton': 'PyObject *',
-    'And_singleton': 'PyObject *',
-    'Or_singleton': 'PyObject *',
-    'Add_singleton': 'static PyObject *',
-    'Sub_singleton': 'static PyObject *',
-    'Mult_singleton': 'static PyObject *',
-    'MatMult_singleton': 'static PyObject *',
-    'Div_singleton': 'static PyObject *',
-    'Mod_singleton': 'static PyObject *',
-    'Pow_singleton': 'static PyObject *',
-    'LShift_singleton': 'static PyObject *',
-    'RShift_singleton': 'static PyObject *',
-    'BitOr_singleton': 'static PyObject *',
-    'BitXor_singleton': 'static PyObject *',
-    'BitAnd_singleton': 'static PyObject *',
-    'FloorDiv_singleton': 'static PyObject *',
-    'Invert_singleton': 'static PyObject *',
-    'Not_singleton': 'static PyObject *',
-    'UAdd_singleton': 'static PyObject *',
-    'USub_singleton': 'static PyObject *',
-    'Eq_singleton': 'static PyObject *',
-    'NotEq_singleton': 'static PyObject *',
-    'Lt_singleton': 'static PyObject *',
-    'LtE_singleton': 'static PyObject *',
-    'Gt_singleton': 'static PyObject *',
-    'GtE_singleton': 'static PyObject *',
-    'Is_singleton': 'static PyObject *',
-    'IsNot_singleton': 'static PyObject *',
-    'In_singleton': 'static PyObject *',
-    'NotIn_singleton': 'static PyObject *',
-    # Python/symtable.c
-    'top': 'static identifier ',
-    'lambda': 'static identifier ',
-    'genexpr': 'static identifier ',
-    'listcomp': 'static identifier ',
-    'setcomp': 'static identifier ',
-    'dictcomp': 'static identifier ',
-    '__class__': 'static identifier ',
-    # Python/compile.c
-    '__doc__': 'static PyObject *',
-    '__annotations__': 'static PyObject *',
-    # Objects/floatobject.c
-    'double_format': 'static float_format_type ',
-    'float_format': 'static float_format_type ',
-    'detected_double_format': 'static float_format_type ',
-    'detected_float_format': 'static float_format_type ',
-    # Python/dtoa.c
-    'private_mem': 'static double private_mem[PRIVATE_mem]',
-    'pmem_next': 'static double *',
-    # Modules/_weakref.c
-    'weakref_functions': 'static PyMethodDef ',
-}
-INLINE = {
-    # Modules/_tracemalloc.c
-    'allocators': 'static struct { PyMemAllocatorEx mem; PyMemAllocatorEx raw; PyMemAllocatorEx obj; } ',
-    # Modules/faulthandler.c
-    'fatal_error': 'static struct { int enabled; PyObject *file; int fd; int all_threads; PyInterpreterState *interp; void *exc_handler; } ',
-    'thread': 'static struct { PyObject *file; int fd; PY_TIMEOUT_T timeout_us; int repeat; PyInterpreterState *interp; int exit; char *header; size_t header_len; PyThread_type_lock cancel_event; PyThread_type_lock running; } ',
-    # Modules/signalmodule.c
-    'Handlers': 'static volatile struct { _Py_atomic_int tripped; PyObject *func; } Handlers[NSIG]',
-    'wakeup': 'static volatile struct { SOCKET_T fd; int warn_on_full_buffer; int use_send; } ',
-    # Python/dynload_shlib.c
-    'handles': 'static struct { dev_t dev; ino_t ino; void *handle; } handles[128]',
-    # Objects/obmalloc.c
-    '_PyMem_Debug': 'static struct { debug_alloc_api_t raw; debug_alloc_api_t mem; debug_alloc_api_t obj; } ',
-    # Python/bootstrap_hash.c
-    'urandom_cache': 'static struct { int fd; dev_t st_dev; ino_t st_ino; } ',
-    }
-FUNC = {
-    # Objects/object.c
-    '_Py_abstract_hack': 'Py_ssize_t (*_Py_abstract_hack)(PyObject *)',
-    # Parser/myreadline.c
-    'PyOS_InputHook': 'int (*PyOS_InputHook)(void)',
-    # Python/pylifecycle.c
-    '_PyOS_mystrnicmp_hack': 'int (*_PyOS_mystrnicmp_hack)(const char *, const char *, Py_ssize_t)',
-    # Parser/myreadline.c
-    'PyOS_ReadlineFunctionPointer': 'char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *)',
-    }
-IMPLIED = {
-    # Objects/boolobject.c
-    '_Py_FalseStruct': 'static struct _longobject ',
-    '_Py_TrueStruct': 'static struct _longobject ',
-    # Modules/config.c
-    '_PyImport_Inittab': 'struct _inittab _PyImport_Inittab[]',
-    }
-GLOBALS = {}
-GLOBALS.update(MULTILINE)
-GLOBALS.update(INLINE)
-GLOBALS.update(FUNC)
-GLOBALS.update(IMPLIED)
-
-LOCALS = {
-    'buildinfo': ('Modules/getbuildinfo.c',
-                  'Py_GetBuildInfo',
-                  'static char buildinfo[50 + sizeof(GITVERSION) + ((sizeof(GITTAG) > sizeof(GITBRANCH)) ?  sizeof(GITTAG) : sizeof(GITBRANCH))]'),
-    'methods': ('Python/codecs.c',
-                '_PyCodecRegistry_Init',
-                'static struct { char *name; PyMethodDef def; } methods[]'),
-    }
-
-
-def _known(symbol):
-    if symbol.funcname:
-        if symbol.funcname != UNKNOWN or symbol.filename != UNKNOWN:
-            raise KeyError(symbol.name)
-        filename, funcname, decl = LOCALS[symbol.name]
-        varid = ID(filename, funcname, symbol.name)
-    elif not symbol.filename or symbol.filename == UNKNOWN:
-        raise KeyError(symbol.name)
-    else:
-        varid = symbol.id
-        try:
-            decl = GLOBALS[symbol.name]
-        except KeyError:
-
-            if symbol.name.endswith('_methods'):
-                decl = 'static PyMethodDef '
-            elif symbol.filename == 'Objects/exceptions.c' and symbol.name.startswith(('PyExc_', '_PyExc_')):
-                decl = 'static PyTypeObject '
-            else:
-                raise
-    if symbol.name not in decl:
-        decl = decl + symbol.name
-    return Variable(varid, 'static', decl)
-
-
-def known_row(varid, decl):
-    return (
-            varid.filename,
-            varid.funcname or '-',
-            varid.name,
-            'variable',
-            decl,
-            )
-
-
-def known_rows(symbols, *,
-               cached=True,
-               _get_filenames=iter_cpython_files,
-               _find_match=find_matching_variable,
-               _find_symbols=find_variables,
-               _as_known=known_row,
-               ):
-    filenames = list(_get_filenames())
-    cache = {}
-    if cached:
-        for symbol in symbols:
-            try:
-                found = _known(symbol)
-            except KeyError:
-                found = _find_match(symbol, cache, filenames)
-                if found is None:
-                    found = Variable(symbol.id, UNKNOWN, UNKNOWN)
-            yield _as_known(found.id, found.vartype)
-    else:
-        raise NotImplementedError  # XXX incorporate KNOWN
-        for variable in _find_symbols(symbols, filenames,
-                                      srccache=cache,
-                                      parse_variable=_parse_global,
-                                      ):
-            #variable = variable._replace(
-            #    filename=os.path.relpath(variable.filename, REPO_ROOT))
-            if variable.funcname == UNKNOWN:
-                print(variable)
-            if variable.vartype== UNKNOWN:
-                print(variable)
-            yield _as_known(variable.id, variable.vartype)
-
-
-def generate(symbols, filename=None, *,
-             _generate_rows=known_rows,
-             _write_tsv=write_tsv,
-             ):
-    if not filename:
-        filename = KNOWN_FILE + '.new'
-
-    rows = _generate_rows(symbols)
-    _write_tsv(filename, KNOWN_HEADER, rows)
-
-
-if __name__ == '__main__':
-    from c_symbols import binary
-    symbols = binary.iter_symbols(
-            binary.PYTHON,
-            find_local_symbol=None,
-            )
-    generate(symbols)
diff --git a/Tools/c-analyzer/cpython/_parser.py b/Tools/c-analyzer/cpython/_parser.py
new file mode 100644
index 00000000000..35fa296251e
--- /dev/null
+++ b/Tools/c-analyzer/cpython/_parser.py
@@ -0,0 +1,308 @@
+import os.path
+import re
+
+from c_common.fsutil import expand_filenames, iter_files_by_suffix
+from c_parser.preprocessor import (
+    get_preprocessor as _get_preprocessor,
+)
+from c_parser import (
+    parse_file as _parse_file,
+    parse_files as _parse_files,
+)
+from . import REPO_ROOT, INCLUDE_DIRS, SOURCE_DIRS
+
+
+GLOB_ALL = '**/*'
+
+
+def clean_lines(text):
+    """Clear out comments, blank lines, and leading/trailing whitespace."""
+    lines = (line.strip() for line in text.splitlines())
+    lines = (line.partition('#')[0].rstrip()
+             for line in lines
+             if line and not line.startswith('#'))
+    glob_all = f'{GLOB_ALL} '
+    lines = (re.sub(r'^[*] ', glob_all, line) for line in lines)
+    lines = (os.path.join(REPO_ROOT, line) for line in lines)
+    return list(lines)
+
+
+'''
+@begin=sh@
+./python ../c-parser/cpython.py
+    --exclude '+../c-parser/EXCLUDED'
+    --macros '+../c-parser/MACROS'
+    --incldirs '+../c-parser/INCL_DIRS'
+    --same './Include/cpython/'
+    Include/*.h
+    Include/internal/*.h
+    Modules/**/*.c
+    Objects/**/*.c
+    Parser/**/*.c
+    Python/**/*.c
+@end=sh@
+'''
+
+GLOBS = [
+    'Include/*.h',
+    'Include/internal/*.h',
+    'Modules/**/*.c',
+    'Objects/**/*.c',
+    'Parser/**/*.c',
+    'Python/**/*.c',
+]
+
+EXCLUDED = clean_lines('''
+# @begin=conf@
+
+# Rather than fixing for this one, we manually make sure it's okay.
+Modules/_sha3/kcp/KeccakP-1600-opt64.c
+
+# OSX
+#Modules/_ctypes/darwin/*.c
+#Modules/_ctypes/libffi_osx/*.c
+Modules/_scproxy.c                # SystemConfiguration/SystemConfiguration.h
+
+# Windows
+Modules/_winapi.c               # windows.h
+Modules/overlapped.c            # winsock.h
+Python/dynload_win.c            # windows.h
+
+# other OS-dependent
+Python/dynload_dl.c             # dl.h
+Python/dynload_hpux.c           # dl.h
+Python/dynload_aix.c            # sys/ldr.h
+
+# @end=conf@
+''')
+
+# XXX Fix the parser.
+EXCLUDED += clean_lines('''
+# The tool should be able to parse these...
+
+Modules/_dbmmodule.c
+Modules/cjkcodecs/_codecs_*.c
+Modules/expat/xmlrole.c
+Modules/expat/xmlparse.c
+Python/initconfig.c
+''')
+
+INCL_DIRS = clean_lines('''
+# @begin=tsv@
+
+glob	dirname
+*	.
+*	./Include
+*	./Include/internal
+
+Modules/_tkinter.c	/usr/include/tcl8.6
+Modules/tkappinit.c	/usr/include/tcl
+Modules/_decimal/**/*.c	Modules/_decimal/libmpdec
+
+# @end=tsv@
+''')[1:]
+
+MACROS = clean_lines('''
+# @begin=tsv@
+
+glob	name	value
+
+Include/internal/*.h	Py_BUILD_CORE	1
+Python/**/*.c	Py_BUILD_CORE	1
+Parser/**/*.c	Py_BUILD_CORE	1
+Objects/**/*.c	Py_BUILD_CORE	1
+
+Modules/faulthandler.c	Py_BUILD_CORE	1
+Modules/_functoolsmodule.c	Py_BUILD_CORE	1
+Modules/gcmodule.c	Py_BUILD_CORE	1
+Modules/getpath.c	Py_BUILD_CORE	1
+Modules/_io/*.c	Py_BUILD_CORE	1
+Modules/itertoolsmodule.c	Py_BUILD_CORE	1
+Modules/_localemodule.c	Py_BUILD_CORE	1
+Modules/main.c	Py_BUILD_CORE	1
+Modules/posixmodule.c	Py_BUILD_CORE	1
+Modules/signalmodule.c	Py_BUILD_CORE	1
+Modules/_threadmodule.c	Py_BUILD_CORE	1
+Modules/_tracemalloc.c	Py_BUILD_CORE	1
+Modules/_asynciomodule.c	Py_BUILD_CORE	1
+Modules/mathmodule.c	Py_BUILD_CORE	1
+Modules/cmathmodule.c	Py_BUILD_CORE	1
+Modules/_weakref.c	Py_BUILD_CORE	1
+Modules/sha256module.c	Py_BUILD_CORE	1
+Modules/sha512module.c	Py_BUILD_CORE	1
+Modules/_datetimemodule.c	Py_BUILD_CORE	1
+Modules/_ctypes/cfield.c	Py_BUILD_CORE	1
+Modules/_heapqmodule.c	Py_BUILD_CORE	1
+Modules/_posixsubprocess.c	Py_BUILD_CORE	1
+
+Modules/_json.c	Py_BUILD_CORE_BUILTIN	1
+Modules/_pickle.c	Py_BUILD_CORE_BUILTIN	1
+Modules/_testinternalcapi.c	Py_BUILD_CORE_BUILTIN	1
+
+Include/cpython/abstract.h	Py_CPYTHON_ABSTRACTOBJECT_H	1
+Include/cpython/bytearrayobject.h	Py_CPYTHON_BYTEARRAYOBJECT_H	1
+Include/cpython/bytesobject.h	Py_CPYTHON_BYTESOBJECT_H	1
+Include/cpython/ceval.h	Py_CPYTHON_CEVAL_H	1
+Include/cpython/code.h	Py_CPYTHON_CODE_H	1
+Include/cpython/dictobject.h	Py_CPYTHON_DICTOBJECT_H	1
+Include/cpython/fileobject.h	Py_CPYTHON_FILEOBJECT_H	1
+Include/cpython/fileutils.h	Py_CPYTHON_FILEUTILS_H	1
+Include/cpython/frameobject.h	Py_CPYTHON_FRAMEOBJECT_H	1
+Include/cpython/import.h	Py_CPYTHON_IMPORT_H	1
+Include/cpython/interpreteridobject.h	Py_CPYTHON_INTERPRETERIDOBJECT_H	1
+Include/cpython/listobject.h	Py_CPYTHON_LISTOBJECT_H	1
+Include/cpython/methodobject.h	Py_CPYTHON_METHODOBJECT_H	1
+Include/cpython/object.h	Py_CPYTHON_OBJECT_H	1
+Include/cpython/objimpl.h	Py_CPYTHON_OBJIMPL_H	1
+Include/cpython/pyerrors.h	Py_CPYTHON_ERRORS_H	1
+Include/cpython/pylifecycle.h	Py_CPYTHON_PYLIFECYCLE_H	1
+Include/cpython/pymem.h	Py_CPYTHON_PYMEM_H	1
+Include/cpython/pystate.h	Py_CPYTHON_PYSTATE_H	1
+Include/cpython/sysmodule.h	Py_CPYTHON_SYSMODULE_H	1
+Include/cpython/traceback.h	Py_CPYTHON_TRACEBACK_H	1
+Include/cpython/tupleobject.h	Py_CPYTHON_TUPLEOBJECT_H	1
+Include/cpython/unicodeobject.h	Py_CPYTHON_UNICODEOBJECT_H	1
+
+# implied include of pyport.h
+Include/**/*.h	PyAPI_DATA(RTYPE)	extern RTYPE
+Include/**/*.h	PyAPI_FUNC(RTYPE)	RTYPE
+Include/**/*.h	Py_DEPRECATED(VER)	/* */
+Include/**/*.h	_Py_NO_RETURN	/* */
+Include/**/*.h	PYLONG_BITS_IN_DIGIT	30
+Modules/**/*.c	PyMODINIT_FUNC	PyObject*
+Objects/unicodeobject.c	PyMODINIT_FUNC	PyObject*
+Python/marshal.c	PyMODINIT_FUNC	PyObject*
+Python/_warnings.c	PyMODINIT_FUNC	PyObject*
+Python/Python-ast.c	PyMODINIT_FUNC	PyObject*
+Python/import.c	PyMODINIT_FUNC	PyObject*
+Modules/_testcapimodule.c	PyAPI_FUNC(RTYPE)	RTYPE
+Python/getargs.c	PyAPI_FUNC(RTYPE)	RTYPE
+
+# implied include of exports.h
+#Modules/_io/bytesio.c	Py_EXPORTED_SYMBOL	/* */
+
+# implied include of object.h
+Include/**/*.h	PyObject_HEAD	PyObject ob_base;
+Include/**/*.h	PyObject_VAR_HEAD	PyVarObject ob_base;
+
+# implied include of pyconfig.h
+Include/**/*.h	SIZEOF_WCHAR_T	4
+
+# implied include of <unistd.h>
+Include/**/*.h	_POSIX_THREADS	1
+
+# from Makefile
+Modules/getpath.c	PYTHONPATH	1
+Modules/getpath.c	PREFIX	...
+Modules/getpath.c	EXEC_PREFIX	...
+Modules/getpath.c	VERSION	...
+Modules/getpath.c	VPATH	...
+
+# from Modules/_sha3/sha3module.c
+Modules/_sha3/kcp/KeccakP-1600-inplace32BI.c	PLATFORM_BYTE_ORDER	4321  # force big-endian
+Modules/_sha3/kcp/*.c	KeccakOpt	64
+Modules/_sha3/kcp/*.c	KeccakP200_excluded	1
+Modules/_sha3/kcp/*.c	KeccakP400_excluded	1
+Modules/_sha3/kcp/*.c	KeccakP800_excluded	1
+
+# See: setup.py
+Modules/_decimal/**/*.c	CONFIG_64	1
+Modules/_decimal/**/*.c	ASM	1
+Modules/expat/xmlparse.c	HAVE_EXPAT_CONFIG_H	1
+Modules/expat/xmlparse.c	XML_POOR_ENTROPY	1
+Modules/_dbmmodule.c	HAVE_GDBM_DASH_NDBM_H	1
+
+# @end=tsv@
+''')[1:]
+
+# -pthread
+# -Wno-unused-result
+# -Wsign-compare
+# -g
+# -Og
+# -Wall
+# -std=c99
+# -Wextra
+# -Wno-unused-result -Wno-unused-parameter
+# -Wno-missing-field-initializers
+# -Werror=implicit-function-declaration
+
+SAME = [
+    './Include/cpython/',
+]
+
+
+def resolve_filename(filename):
+    orig = filename
+    filename = os.path.normcase(os.path.normpath(filename))
+    if os.path.isabs(filename):
+        if os.path.relpath(filename, REPO_ROOT).startswith('.'):
+            raise Exception(f'{orig!r} is outside the repo ({REPO_ROOT})')
+        return filename
+    else:
+        return os.path.join(REPO_ROOT, filename)
+
+
+def iter_filenames(*, search=False):
+    if search:
+        yield from iter_files_by_suffix(INCLUDE_DIRS, ('.h',))
+        yield from iter_files_by_suffix(SOURCE_DIRS, ('.c',))
+    else:
+        globs = (os.path.join(REPO_ROOT, file) for file in GLOBS)
+        yield from expand_filenames(globs)
+
+
+def get_preprocessor(*,
+                     file_macros=None,
+                     file_incldirs=None,
+                     file_same=None,
+                     **kwargs
+                     ):
+    macros = tuple(MACROS)
+    if file_macros:
+        macros += tuple(file_macros)
+    incldirs = tuple(INCL_DIRS)
+    if file_incldirs:
+        incldirs += tuple(file_incldirs)
+    return _get_preprocessor(
+        file_macros=macros,
+        file_incldirs=incldirs,
+        file_same=file_same,
+        **kwargs
+    )
+
+
+def parse_file(filename, *,
+               match_kind=None,
+               ignore_exc=None,
+               log_err=None,
+               ):
+    get_file_preprocessor = get_preprocessor(
+        ignore_exc=ignore_exc,
+        log_err=log_err,
+    )
+    yield from _parse_file(
+        filename,
+        match_kind=match_kind,
+        get_file_preprocessor=get_file_preprocessor,
+    )
+
+
+def parse_files(filenames=None, *,
+                match_kind=None,
+                ignore_exc=None,
+                log_err=None,
+                get_file_preprocessor=None,
+                **file_kwargs
+                ):
+    if get_file_preprocessor is None:
+        get_file_preprocessor = get_preprocessor(
+            ignore_exc=ignore_exc,
+            log_err=log_err,
+        )
+    yield from _parse_files(
+        filenames,
+        match_kind=match_kind,
+        get_file_preprocessor=get_file_preprocessor,
+        **file_kwargs
+    )
diff --git a/Tools/c-analyzer/cpython/files.py b/Tools/c-analyzer/cpython/files.py
deleted file mode 100644
index 543097af7bc..00000000000
--- a/Tools/c-analyzer/cpython/files.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from c_analyzer.common.files import (
-        C_SOURCE_SUFFIXES, walk_tree, iter_files_by_suffix,
-        )
-
-from . import SOURCE_DIRS, REPO_ROOT
-
-# XXX need tests:
-# * iter_files()
-
-
-def iter_files(*,
-               walk=walk_tree,
-               _files=iter_files_by_suffix,
-               ):
-    """Yield each file in the tree for each of the given directory names."""
-    excludedtrees = [
-        os.path.join('Include', 'cpython', ''),
-        ]
-    def is_excluded(filename):
-        for root in excludedtrees:
-            if filename.startswith(root):
-                return True
-        return False
-    for filename in _files(SOURCE_DIRS, C_SOURCE_SUFFIXES, REPO_ROOT,
-                           walk=walk,
-                           ):
-        if is_excluded(filename):
-            continue
-        yield filename
diff --git a/Tools/c-analyzer/cpython/find.py b/Tools/c-analyzer/cpython/find.py
deleted file mode 100644
index a7bc0b477b8..00000000000
--- a/Tools/c-analyzer/cpython/find.py
+++ /dev/null
@@ -1,101 +0,0 @@
-import os.path
-
-from c_analyzer.common import files
-from c_analyzer.common.info import UNKNOWN, ID
-from c_analyzer.variables import find as _common
-
-from . import SOURCE_DIRS, PYTHON, REPO_ROOT
-from .known import (
-    from_file as known_from_file,
-    DATA_FILE as KNOWN_FILE,
-    )
-from .supported import (
-        ignored_from_file, IGNORED_FILE, is_supported, _is_object,
-        )
-
-# XXX need tests:
-# * vars_from_binary()
-# * vars_from_source()
-# * supported_vars()
-
-
-def _handle_id(filename, funcname, name, *,
-               _relpath=os.path.relpath,
-               ):
-    filename = _relpath(filename, REPO_ROOT)
-    return ID(filename, funcname, name)
-
-
-def vars_from_binary(*,
-                     known=KNOWN_FILE,
-                     _known_from_file=known_from_file,
-                     _iter_files=files.iter_files_by_suffix,
-                     _iter_vars=_common.vars_from_binary,
-                     ):
-    """Yield a Variable for each found Symbol.
-
-    Details are filled in from the given "known" variables and types.
-    """
-    if isinstance(known, str):
-        known = _known_from_file(known)
-    dirnames = SOURCE_DIRS
-    suffixes = ('.c',)
-    filenames = _iter_files(dirnames, suffixes)
-    # XXX For now we only use known variables (no source lookup).
-    filenames = None
-    yield from _iter_vars(PYTHON,
-                          known=known,
-                          filenames=filenames,
-                          handle_id=_handle_id,
-                          check_filename=(lambda n: True),
-                          )
-
-
-def vars_from_source(*,
-                     preprocessed=None,
-                     known=KNOWN_FILE,
-                     _known_from_file=known_from_file,
-                     _iter_files=files.iter_files_by_suffix,
-                     _iter_vars=_common.vars_from_source,
-                     ):
-    """Yield a Variable for each declaration in the raw source code.
-
-    Details are filled in from the given "known" variables and types.
-    """
-    if isinstance(known, str):
-        known = _known_from_file(known)
-    dirnames = SOURCE_DIRS
-    suffixes = ('.c',)
-    filenames = _iter_files(dirnames, suffixes)
-    yield from _iter_vars(filenames,
-                          preprocessed=preprocessed,
-                          known=known,
-                          handle_id=_handle_id,
-                          )
-
-
-def supported_vars(*,
-                   known=KNOWN_FILE,
-                   ignored=IGNORED_FILE,
-                   skip_objects=False,
-                   _known_from_file=known_from_file,
-                   _ignored_from_file=ignored_from_file,
-                   _iter_vars=vars_from_binary,
-                   _is_supported=is_supported,
-                   ):
-    """Yield (var, is supported) for each found variable."""
-    if isinstance(known, str):
-        known = _known_from_file(known)
-    if isinstance(ignored, str):
-        ignored = _ignored_from_file(ignored)
-
-    for var in _iter_vars(known=known):
-        if not var.isglobal:
-            continue
-        elif var.vartype == UNKNOWN:
-            yield var, None
-        # XXX Support proper filters instead.
-        elif skip_objects and _is_object(found.vartype):
-            continue
-        else:
-            yield var, _is_supported(var, ignored, known)
diff --git a/Tools/c-analyzer/cpython/ignored.tsv b/Tools/c-analyzer/cpython/ignored.tsv
new file mode 100644
index 00000000000..2c456db063e
--- /dev/null
+++ b/Tools/c-analyzer/cpython/ignored.tsv
@@ -0,0 +1,2 @@
+filename	funcname	name	reason
+#???	-	somevar	???
diff --git a/Tools/c-analyzer/cpython/known.py b/Tools/c-analyzer/cpython/known.py
deleted file mode 100644
index c3cc2c06026..00000000000
--- a/Tools/c-analyzer/cpython/known.py
+++ /dev/null
@@ -1,66 +0,0 @@
-import csv
-import os.path
-
-from c_analyzer.parser.declarations import extract_storage
-from c_analyzer.variables import known as _common
-from c_analyzer.variables.info import Variable
-
-from . import DATA_DIR
-
-
-# XXX need tests:
-# * from_file()
-# * look_up_variable()
-
-
-DATA_FILE = os.path.join(DATA_DIR, 'known.tsv')
-
-
-def _get_storage(decl, infunc):
-    # statics
-    if decl.startswith(('Py_LOCAL(', 'Py_LOCAL_INLINE(')):
-        return 'static'
-    if decl.startswith(('_Py_IDENTIFIER(', '_Py_static_string(')):
-        return 'static'
-    if decl.startswith('PyDoc_VAR('):
-        return 'static'
-    if decl.startswith(('SLOT1BINFULL(', 'SLOT1BIN(')):
-        return 'static'
-    if decl.startswith('WRAP_METHOD('):
-        return 'static'
-    # public extern
-    if decl.startswith('PyAPI_DATA('):
-        return 'extern'
-    # Fall back to the normal handler.
-    return extract_storage(decl, infunc=infunc)
-
-
-def _handle_var(varid, decl):
-#    if varid.name == 'id' and decl == UNKNOWN:
-#        # None of these are variables.
-#        decl = 'int id';
-    storage = _get_storage(decl, varid.funcname)
-    return Variable(varid, storage, decl)
-
-
-def from_file(infile=DATA_FILE, *,
-              _from_file=_common.from_file,
-              _handle_var=_handle_var,
-              ):
-    """Return the info for known declarations in the given file."""
-    return _from_file(infile, handle_var=_handle_var)
-
-
-def look_up_variable(varid, knownvars, *,
-                     _lookup=_common.look_up_variable,
-                     ):
-    """Return the known variable matching the given ID.
-
-    "knownvars" is a mapping of ID to Variable.
-
-    "match_files" is used to verify if two filenames point to
-    the same file.
-
-    If no match is found then None is returned.
-    """
-    return _lookup(varid, knownvars)
diff --git a/Tools/c-analyzer/cpython/known.tsv b/Tools/c-analyzer/cpython/known.tsv
new file mode 100644
index 00000000000..a48ef02dc6f
--- /dev/null
+++ b/Tools/c-analyzer/cpython/known.tsv
@@ -0,0 +1,3 @@
+filename	funcname	name	kind	declaration
+#filename	funcname	name	kind	is_supported	declaration
+#???	-	PyWideStringList	typedef	???
diff --git a/Tools/c-analyzer/cpython/supported.py b/Tools/c-analyzer/cpython/supported.py
deleted file mode 100644
index 18786eefd8d..00000000000
--- a/Tools/c-analyzer/cpython/supported.py
+++ /dev/null
@@ -1,398 +0,0 @@
-import os.path
-import re
-
-from c_analyzer.common.info import ID
-from c_analyzer.common.util import read_tsv, write_tsv
-
-from . import DATA_DIR
-
-# XXX need tests:
-# * generate / script
-
-
-IGNORED_FILE = os.path.join(DATA_DIR, 'ignored.tsv')
-
-IGNORED_COLUMNS = ('filename', 'funcname', 'name', 'kind', 'reason')
-IGNORED_HEADER = '\t'.join(IGNORED_COLUMNS)
-
-# XXX Move these to ignored.tsv.
-IGNORED = {
-        # global
-        'PyImport_FrozenModules': 'process-global',
-        'M___hello__': 'process-global',
-        'inittab_copy': 'process-global',
-        'PyHash_Func': 'process-global',
-        '_Py_HashSecret_Initialized': 'process-global',
-        '_TARGET_LOCALES': 'process-global',
-
-        # startup (only changed before/during)
-        '_PyRuntime': 'runtime startup',
-        'runtime_initialized': 'runtime startup',
-        'static_arg_parsers': 'runtime startup',
-        'orig_argv': 'runtime startup',
-        'opt_ptr': 'runtime startup',
-        '_preinit_warnoptions': 'runtime startup',
-        '_Py_StandardStreamEncoding': 'runtime startup',
-        'Py_FileSystemDefaultEncoding': 'runtime startup',
-        '_Py_StandardStreamErrors': 'runtime startup',
-        'Py_FileSystemDefaultEncodeErrors': 'runtime startup',
-        'Py_BytesWarningFlag': 'runtime startup',
-        'Py_DebugFlag': 'runtime startup',
-        'Py_DontWriteBytecodeFlag': 'runtime startup',
-        'Py_FrozenFlag': 'runtime startup',
-        'Py_HashRandomizationFlag': 'runtime startup',
-        'Py_IgnoreEnvironmentFlag': 'runtime startup',
-        'Py_InspectFlag': 'runtime startup',
-        'Py_InteractiveFlag': 'runtime startup',
-        'Py_IsolatedFlag': 'runtime startup',
-        'Py_NoSiteFlag': 'runtime startup',
-        'Py_NoUserSiteDirectory': 'runtime startup',
-        'Py_OptimizeFlag': 'runtime startup',
-        'Py_QuietFlag': 'runtime startup',
-        'Py_UTF8Mode': 'runtime startup',
-        'Py_UnbufferedStdioFlag': 'runtime startup',
-        'Py_VerboseFlag': 'runtime startup',
-        '_Py_path_config': 'runtime startup',
-        '_PyOS_optarg': 'runtime startup',
-        '_PyOS_opterr': 'runtime startup',
-        '_PyOS_optind': 'runtime startup',
-        '_Py_HashSecret': 'runtime startup',
-
-        # REPL
-        '_PyOS_ReadlineLock': 'repl',
-        '_PyOS_ReadlineTState': 'repl',
-
-        # effectively const
-        'tracemalloc_empty_traceback': 'const',
-        '_empty_bitmap_node': 'const',
-        'posix_constants_pathconf': 'const',
-        'posix_constants_confstr': 'const',
-        'posix_constants_sysconf': 'const',
-        '_PySys_ImplCacheTag': 'const',
-        '_PySys_ImplName': 'const',
-        'PyImport_Inittab': 'const',
-        '_PyImport_DynLoadFiletab': 'const',
-        '_PyParser_Grammar': 'const',
-        'Py_hexdigits': 'const',
-        '_PyImport_Inittab': 'const',
-        '_PyByteArray_empty_string': 'const',
-        '_PyLong_DigitValue': 'const',
-        '_Py_SwappedOp': 'const',
-        'PyStructSequence_UnnamedField': 'const',
-
-        # signals are main-thread only
-        'faulthandler_handlers': 'signals are main-thread only',
-        'user_signals': 'signals are main-thread only',
-        'wakeup': 'signals are main-thread only',
-
-        # hacks
-        '_PySet_Dummy': 'only used as a placeholder',
-        }
-
-BENIGN = 'races here are benign and unlikely'
-
-
-def is_supported(variable, ignored=None, known=None, *,
-                 _ignored=(lambda *a, **k: _is_ignored(*a, **k)),
-                 _vartype_okay=(lambda *a, **k: _is_vartype_okay(*a, **k)),
-                 ):
-    """Return True if the given global variable is okay in CPython."""
-    if _ignored(variable,
-                ignored and ignored.get('variables')):
-        return True
-    elif _vartype_okay(variable.vartype,
-                       ignored.get('types')):
-        return True
-    else:
-        return False
-
-
-def _is_ignored(variable, ignoredvars=None, *,
-                _IGNORED=IGNORED,
-                ):
-    """Return the reason if the variable is a supported global.
-
-    Return None if the variable is not a supported global.
-    """
-    if ignoredvars and (reason := ignoredvars.get(variable.id)):
-        return reason
-
-    if variable.funcname is None:
-        if reason := _IGNORED.get(variable.name):
-            return reason
-
-    # compiler
-    if variable.filename == 'Python/graminit.c':
-        if variable.vartype.startswith('static state '):
-            return 'compiler'
-    if variable.filename == 'Python/symtable.c':
-        if variable.vartype.startswith('static identifier '):
-            return 'compiler'
-    if variable.filename == 'Python/Python-ast.c':
-        # These should be const.
-        if variable.name.endswith('_field'):
-            return 'compiler'
-        if variable.name.endswith('_attribute'):
-            return 'compiler'
-
-    # other
-    if variable.filename == 'Python/dtoa.c':
-        # guarded by lock?
-        if variable.name in ('p5s', 'freelist'):
-            return 'dtoa is thread-safe?'
-        if variable.name in ('private_mem', 'pmem_next'):
-            return 'dtoa is thread-safe?'
-    if variable.filename == 'Python/thread.c':
-        # Threads do not become an issue until after these have been set
-        # and these never get changed after that.
-        if variable.name in ('initialized', 'thread_debug'):
-            return 'thread-safe'
-    if variable.filename == 'Python/getversion.c':
-        if variable.name == 'version':
-            # Races are benign here, as well as unlikely.
-            return BENIGN
-    if variable.filename == 'Python/fileutils.c':
-        if variable.name == 'force_ascii':
-            return BENIGN
-        if variable.name == 'ioctl_works':
-            return BENIGN
-        if variable.name == '_Py_open_cloexec_works':
-            return BENIGN
-    if variable.filename == 'Python/codecs.c':
-        if variable.name == 'ucnhash_CAPI':
-            return BENIGN
-    if variable.filename == 'Python/bootstrap_hash.c':
-        if variable.name == 'getrandom_works':
-            return BENIGN
-    if variable.filename == 'Objects/unicodeobject.c':
-        if variable.name == 'ucnhash_CAPI':
-            return BENIGN
-        if variable.name == 'bloom_linebreak':
-            # *mostly* benign
-            return BENIGN
-    if variable.filename == 'Modules/getbuildinfo.c':
-        if variable.name == 'buildinfo':
-            # The static is used for pre-allocation.
-            return BENIGN
-    if variable.filename == 'Modules/posixmodule.c':
-        if variable.name == 'ticks_per_second':
-            return BENIGN
-        if variable.name == 'dup3_works':
-            return BENIGN
-    if variable.filename == 'Modules/timemodule.c':
-        if variable.name == 'ticks_per_second':
-            return BENIGN
-    if variable.filename == 'Objects/longobject.c':
-        if variable.name == 'log_base_BASE':
-            return BENIGN
-        if variable.name == 'convwidth_base':
-            return BENIGN
-        if variable.name == 'convmultmax_base':
-            return BENIGN
-
-    return None
-
-
-def _is_vartype_okay(vartype, ignoredtypes=None):
-    if _is_object(vartype):
-        return None
-
-    if vartype.startswith('static const '):
-        return 'const'
-    if vartype.startswith('const '):
-        return 'const'
-
-    # components for TypeObject definitions
-    for name in ('PyMethodDef', 'PyGetSetDef', 'PyMemberDef'):
-        if name in vartype:
-            return 'const'
-    for name in ('PyNumberMethods', 'PySequenceMethods', 'PyMappingMethods',
-                 'PyBufferProcs', 'PyAsyncMethods'):
-        if name in vartype:
-            return 'const'
-    for name in ('slotdef', 'newfunc'):
-        if name in vartype:
-            return 'const'
-
-    # structseq
-    for name in ('PyStructSequence_Desc', 'PyStructSequence_Field'):
-        if name in vartype:
-            return 'const'
-
-    # other definiitions
-    if 'PyModuleDef' in vartype:
-        return 'const'
-
-    # thread-safe
-    if '_Py_atomic_int' in vartype:
-        return 'thread-safe'
-    if 'pthread_condattr_t' in vartype:
-        return 'thread-safe'
-
-    # startup
-    if '_Py_PreInitEntry' in vartype:
-        return 'startup'
-
-    # global
-#    if 'PyMemAllocatorEx' in vartype:
-#        return True
-
-    # others
-#    if 'PyThread_type_lock' in vartype:
-#        return True
-
-    # XXX ???
-    # _Py_tss_t
-    # _Py_hashtable_t
-    # stack_t
-    # _PyUnicode_Name_CAPI
-
-    # functions
-    if '(' in vartype and '[' not in vartype:
-        return 'function pointer'
-
-    # XXX finish!
-    # * allow const values?
-    #raise NotImplementedError
-    return None
-
-
-PYOBJECT_RE = re.compile(r'''
-        ^
-        (
-            # must start with "static "
-            static \s+
-            (
-                identifier
-            )
-            \b
-        ) |
-        (
-            # may start with "static "
-            ( static \s+ )?
-            (
-                .*
-                (
-                    PyObject |
-                    PyTypeObject |
-                    _? Py \w+ Object |
-                    _PyArg_Parser |
-                    _Py_Identifier |
-                    traceback_t |
-                    PyAsyncGenASend |
-                    _PyAsyncGenWrappedValue |
-                    PyContext |
-                    method_cache_entry
-                )
-                \b
-            ) |
-            (
-                (
-                    _Py_IDENTIFIER |
-                    _Py_static_string
-                )
-                [(]
-            )
-        )
-        ''', re.VERBOSE)
-
-
-def _is_object(vartype):
-    if 'PyDictKeysObject' in vartype:
-        return False
-    if PYOBJECT_RE.match(vartype):
-        return True
-    if vartype.endswith((' _Py_FalseStruct', ' _Py_TrueStruct')):
-        return True
-
-    # XXX Add more?
-
-    #for part in vartype.split():
-    #    # XXX const is automatic True?
-    #    if part == 'PyObject' or part.startswith('PyObject['):
-    #        return True
-    return False
-
-
-def ignored_from_file(infile, *,
-                      _read_tsv=read_tsv,
-                      ):
-    """Yield a Variable for each ignored var in the file."""
-    ignored = {
-        'variables': {},
-        #'types': {},
-        #'constants': {},
-        #'macros': {},
-        }
-    for row in _read_tsv(infile, IGNORED_HEADER):
-        filename, funcname, name, kind, reason = row
-        if not funcname or funcname == '-':
-            funcname = None
-        id = ID(filename, funcname, name)
-        if kind == 'variable':
-            values = ignored['variables']
-        else:
-            raise ValueError(f'unsupported kind in row {row}')
-        values[id] = reason
-    return ignored
-
-
-##################################
-# generate
-
-def _get_row(varid, reason):
-    return (
-            varid.filename,
-            varid.funcname or '-',
-            varid.name,
-            'variable',
-            str(reason),
-            )
-
-
-def _get_rows(variables, ignored=None, *,
-              _as_row=_get_row,
-              _is_ignored=_is_ignored,
-              _vartype_okay=_is_vartype_okay,
-              ):
-    count = 0
-    for variable in variables:
-        reason = _is_ignored(variable,
-                             ignored and ignored.get('variables'),
-                             )
-        if not reason:
-            reason = _vartype_okay(variable.vartype,
-                                   ignored and ignored.get('types'))
-        if not reason:
-            continue
-
-        print(' ', variable, repr(reason))
-        yield _as_row(variable.id, reason)
-        count += 1
-    print(f'total: {count}')
-
-
-def _generate_ignored_file(variables, filename=None, *,
-                           _generate_rows=_get_rows,
-                           _write_tsv=write_tsv,
-                           ):
-    if not filename:
-        filename = IGNORED_FILE + '.new'
-    rows = _generate_rows(variables)
-    _write_tsv(filename, IGNORED_HEADER, rows)
-
-
-if __name__ == '__main__':
-    from cpython import SOURCE_DIRS
-    from cpython.known import (
-        from_file as known_from_file,
-        DATA_FILE as KNOWN_FILE,
-        )
-    # XXX This is wrong!
-    from . import find
-    known = known_from_file(KNOWN_FILE)
-    knownvars = (known or {}).get('variables')
-    variables = find.globals_from_binary(knownvars=knownvars,
-                                         dirnames=SOURCE_DIRS)
-
-    _generate_ignored_file(variables)
diff --git a/Tools/c-analyzer/ignored-globals.txt b/Tools/c-analyzer/ignored-globals.txt
deleted file mode 100644
index ce6d1d80514..00000000000
--- a/Tools/c-analyzer/ignored-globals.txt
+++ /dev/null
@@ -1,492 +0,0 @@
-# All variables declared here are shared between all interpreters
-# in a single process.  That means that they must not be changed
-# unless that change should apply to all interpreters.
-#
-# See check-c-globals.py.
-#
-# Many generic names are handled via the script:
-#
-# * most exceptions and all warnings handled via _is_exception()
-# * for builtin modules, generic names are handled via _is_module()
-# * generic names for static types handled via _is_type_var()
-# * AST vars handled via _is_compiler()
-
-
-#######################################
-# main
-
-# Modules/getpath.c
-exec_prefix
-module_search_path
-prefix
-progpath
-
-# Modules/main.c
-orig_argc
-orig_argv
-
-# Python/getopt.c
-opt_ptr
-_PyOS_optarg
-_PyOS_opterr
-_PyOS_optind
-
-
-#######################################
-# REPL
-
-# Parser/myreadline.c
-PyOS_InputHook
-PyOS_ReadlineFunctionPointer
-_PyOS_ReadlineLock
-_PyOS_ReadlineTState
-
-
-#######################################
-# state
-
-# Python/dtoa.c
-p5s
-pmem_next  # very slight race
-private_mem  # very slight race
-
-# Python/import.c
-# For the moment the import lock stays global.  Ultimately there should
-# be a global lock for extension modules and a per-interpreter lock.
-import_lock
-import_lock_level
-import_lock_thread
-
-# Python/pylifecycle.c
-_PyRuntime
-
-
-#---------------------------------
-# module globals (PyObject)
-
-# Modules/_functoolsmodule.c
-kwd_mark
-
-# Modules/_localemodule.c
-Error
-
-# Modules/_threadmodule.c
-ThreadError
-
-# Modules/_tracemalloc.c
-unknown_filename
-
-# Modules/gcmodule.c
-gc_str
-
-# Modules/posixmodule.c
-billion
-posix_putenv_garbage
-
-# Modules/signalmodule.c
-DefaultHandler
-IgnoreHandler
-IntHandler
-ItimerError
-
-# Modules/zipimport.c
-ZipImportError
-zip_directory_cache
-
-
-#---------------------------------
-# module globals (other)
-
-# Modules/_tracemalloc.c
-allocators
-tables_lock
-tracemalloc_config
-tracemalloc_empty_traceback
-tracemalloc_filenames
-tracemalloc_peak_traced_memory
-tracemalloc_reentrant_key
-tracemalloc_traceback
-tracemalloc_tracebacks
-tracemalloc_traced_memory
-tracemalloc_traces
-
-# Modules/faulthandler.c
-fatal_error
-faulthandler_handlers
-old_stack
-stack
-thread
-user_signals
-
-# Modules/posixmodule.c
-posix_constants_confstr
-posix_constants_pathconf
-posix_constants_sysconf
-structseq_new
-ticks_per_second
-
-# Modules/signalmodule.c
-Handlers  # main thread only
-is_tripped  # main thread only
-main_pid
-main_thread
-old_siginthandler
-wakeup_fd  # main thread only
-
-# Modules/zipimport.c
-zip_searchorder
-
-# Python/bltinmodule.c
-Py_FileSystemDefaultEncodeErrors
-Py_FileSystemDefaultEncoding
-Py_HasFileSystemDefaultEncoding
-
-# Python/sysmodule.c
-_PySys_ImplCacheTag
-_PySys_ImplName
-
-
-#---------------------------------
-# freelists
-
-# Modules/_collectionsmodule.c
-freeblocks
-numfreeblocks
-
-# Objects/classobject.c
-free_list
-numfree
-
-# Objects/dictobject.c
-free_list
-keys_free_list
-numfree
-numfreekeys
-
-# Objects/exceptions.c
-memerrors_freelist
-memerrors_numfree
-
-# Objects/floatobject.c
-free_list
-numfree
-
-# Objects/frameobject.c
-free_list
-numfree
-
-# Objects/genobject.c
-ag_asend_freelist
-ag_asend_freelist_free
-ag_value_freelist
-ag_value_freelist_free
-
-# Objects/listobject.c
-free_list
-numfree
-
-# Objects/methodobject.c
-free_list
-numfree
-
-# Objects/sliceobject.c
-slice_cache  # slight race
-
-# Objects/tupleobject.c
-free_list
-numfree
-
-# Python/dtoa.c
-freelist  # very slight race
-
-
-#---------------------------------
-# caches (PyObject)
-
-# Objects/typeobject.c
-method_cache  # only for static types
-next_version_tag  # only for static types
-
-# Python/dynload_shlib.c
-handles  # slight race during import
-nhandles  # slight race during import
-
-# Python/import.c
-extensions  # slight race on init during import
-
-
-#---------------------------------
-# caches (other)
-
-# Python/bootstrap_hash.c
-urandom_cache
-
-# Python/modsupport.c
-_Py_PackageContext  # Slight race during import!  Move to PyThreadState?
-
-
-#---------------------------------
-# counters
-
-# Objects/bytesobject.c
-null_strings
-one_strings
-
-# Objects/dictobject.c
-pydict_global_version
-
-# Objects/moduleobject.c
-max_module_number  # slight race during import
-
-
-#######################################
-# constants
-
-#---------------------------------
-# singletons
-
-# Objects/boolobject.c
-_Py_FalseStruct
-_Py_TrueStruct
-
-# Objects/object.c
-_Py_NoneStruct
-_Py_NotImplementedStruct
-
-# Objects/sliceobject.c
-_Py_EllipsisObject
-
-
-#---------------------------------
-# constants (other)
-
-# Modules/config.c
-_PyImport_Inittab
-
-# Objects/bytearrayobject.c
-_PyByteArray_empty_string
-
-# Objects/dictobject.c
-empty_keys_struct
-empty_values
-
-# Objects/floatobject.c
-detected_double_format
-detected_float_format
-double_format
-float_format
-
-# Objects/longobject.c
-_PyLong_DigitValue
-
-# Objects/object.c
-_Py_SwappedOp
-
-# Objects/obmalloc.c
-_PyMem_Debug
-
-# Objects/setobject.c
-_dummy_struct
-
-# Objects/structseq.c
-PyStructSequence_UnnamedField
-
-# Objects/typeobject.c
-name_op
-slotdefs  # almost
-slotdefs_initialized  # almost
-subtype_getsets_dict_only
-subtype_getsets_full
-subtype_getsets_weakref_only
-tp_new_methoddef
-
-# Objects/unicodeobject.c
-bloom_linebreak
-static_strings  # slight race
-
-# Parser/tokenizer.c
-_PyParser_TokenNames
-
-# Python/Python-ast.c
-alias_fields
-
-# Python/codecs.c
-Py_hexdigits
-ucnhash_CAPI  # slight performance-only race
-
-# Python/dynload_shlib.c
-_PyImport_DynLoadFiletab
-
-# Python/fileutils.c
-_Py_open_cloexec_works
-force_ascii
-
-# Python/frozen.c
-M___hello__
-PyImport_FrozenModules
-
-# Python/graminit.c
-_PyParser_Grammar
-dfas
-labels
-
-# Python/import.c
-PyImport_Inittab
-
-# Python/pylifecycle.c
-_TARGET_LOCALES
-
-
-#---------------------------------
-# initialized (PyObject)
-
-# Objects/bytesobject.c
-characters
-nullstring
-
-# Objects/exceptions.c
-PyExc_RecursionErrorInst
-errnomap
-
-# Objects/longobject.c
-_PyLong_One
-_PyLong_Zero
-small_ints
-
-# Objects/setobject.c
-emptyfrozenset
-
-# Objects/unicodeobject.c
-interned  # slight race on init in PyUnicode_InternInPlace()
-unicode_empty
-unicode_latin1
-
-
-#---------------------------------
-# initialized (other)
-
-# Python/getargs.c
-static_arg_parsers
-
-# Python/pyhash.c
-PyHash_Func
-_Py_HashSecret
-_Py_HashSecret_Initialized
-
-# Python/pylifecycle.c
-_Py_StandardStreamEncoding
-_Py_StandardStreamErrors
-default_home
-env_home
-progname
-Py_BytesWarningFlag
-Py_DebugFlag
-Py_DontWriteBytecodeFlag
-Py_FrozenFlag
-Py_HashRandomizationFlag
-Py_IgnoreEnvironmentFlag
-Py_InspectFlag
-Py_InteractiveFlag
-Py_IsolatedFlag
-Py_NoSiteFlag
-Py_NoUserSiteDirectory
-Py_OptimizeFlag
-Py_QuietFlag
-Py_UnbufferedStdioFlag
-Py_VerboseFlag
-
-
-#---------------------------------
-# types
-
-# Modules/_threadmodule.c
-Locktype
-RLocktype
-localdummytype
-localtype
-
-# Objects/exceptions.c
-PyExc_BaseException
-PyExc_Exception
-PyExc_GeneratorExit
-PyExc_KeyboardInterrupt
-PyExc_StopAsyncIteration
-PyExc_StopIteration
-PyExc_SystemExit
-_PyExc_BaseException
-_PyExc_Exception
-_PyExc_GeneratorExit
-_PyExc_KeyboardInterrupt
-_PyExc_StopAsyncIteration
-_PyExc_StopIteration
-_PyExc_SystemExit
-
-# Objects/structseq.c
-_struct_sequence_template
-
-
-#---------------------------------
-# interned strings/bytes
-
-# Modules/_io/_iomodule.c
-_PyIO_empty_bytes
-_PyIO_empty_str
-_PyIO_str_close
-_PyIO_str_closed
-_PyIO_str_decode
-_PyIO_str_encode
-_PyIO_str_fileno
-_PyIO_str_flush
-_PyIO_str_getstate
-_PyIO_str_isatty
-_PyIO_str_newlines
-_PyIO_str_nl
-_PyIO_str_read
-_PyIO_str_read1
-_PyIO_str_readable
-_PyIO_str_readall
-_PyIO_str_readinto
-_PyIO_str_readline
-_PyIO_str_reset
-_PyIO_str_seek
-_PyIO_str_seekable
-_PyIO_str_setstate
-_PyIO_str_tell
-_PyIO_str_truncate
-_PyIO_str_writable
-_PyIO_str_write
-
-# Modules/_threadmodule.c
-str_dict
-
-# Objects/boolobject.c
-false_str
-true_str
-
-# Objects/listobject.c
-indexerr
-
-# Python/symtable.c
-__class__
-dictcomp
-genexpr
-lambda
-listcomp
-setcomp
-top
-
-# Python/sysmodule.c
-whatstrings
-
-
-#######################################
-# hacks
-
-# Objects/object.c
-_Py_abstract_hack
-
-# Objects/setobject.c
-_PySet_Dummy
-
-# Python/pylifecycle.c
-_PyOS_mystrnicmp_hack
diff --git a/Tools/c-analyzer/ignored.tsv b/Tools/c-analyzer/ignored.tsv
deleted file mode 100644
index a0e0e503da6..00000000000
--- a/Tools/c-analyzer/ignored.tsv
+++ /dev/null
@@ -1 +0,0 @@
-filename	funcname	name	kind	reason
diff --git a/Tools/c-analyzer/known.tsv b/Tools/c-analyzer/known.tsv
deleted file mode 100644
index f8c12a3944d..00000000000
--- a/Tools/c-analyzer/known.tsv
+++ /dev/null
@@ -1,1927 +0,0 @@
-filename	funcname	name	kind	declaration
-Modules/_abc.c	-	_abc_data_type	variable	static PyTypeObject _abc_data_type
-Modules/_abc.c	-	abc_invalidation_counter	variable	static unsigned long long abc_invalidation_counter
-Modules/_abc.c	-	_abcmodule	variable	static struct PyModuleDef _abcmodule
-Python/import.c	import_find_and_load	accumulated	variable	static _PyTime_t accumulated
-Modules/itertoolsmodule.c	-	accumulate_methods	variable	static PyMethodDef accumulate_methods
-Modules/itertoolsmodule.c	-	accumulate_type	variable	static PyTypeObject accumulate_type
-Python/Python-ast.c	-	Add_singleton	variable	static PyObject *Add_singleton
-Python/Python-ast.c	-	Add_type	variable	static PyTypeObject *Add_type
-Objects/genobject.c	-	ag_asend_freelist	variable	static PyAsyncGenASend *ag_asend_freelist[_PyAsyncGen_MAXFREELIST]
-Objects/genobject.c	-	ag_asend_freelist_free	variable	static int ag_asend_freelist_free
-Objects/genobject.c	-	ag_value_freelist	variable	static _PyAsyncGenWrappedValue *ag_value_freelist[_PyAsyncGen_MAXFREELIST]
-Objects/genobject.c	-	ag_value_freelist_free	variable	static int ag_value_freelist_free
-Python/Python-ast.c	-	alias_fields	variable	static const char *alias_fields[]
-Python/Python-ast.c	-	alias_type	variable	static PyTypeObject *alias_type
-Modules/_tracemalloc.c	-	allocators	variable	static struct { PyMemAllocatorEx mem; PyMemAllocatorEx raw; PyMemAllocatorEx obj; } allocators
-Python/Python-ast.c	-	And_singleton	variable	static PyObject *And_singleton
-Python/Python-ast.c	-	And_type	variable	static PyTypeObject *And_type
-Python/Python-ast.c	-	AnnAssign_fields	variable	static const char *AnnAssign_fields[]
-Python/Python-ast.c	-	AnnAssign_type	variable	static PyTypeObject *AnnAssign_type
-Python/compile.c	-	__annotations__	variable	static PyObject *__annotations__
-Objects/obmalloc.c	-	arenas	variable	static struct arena_object* arenas
-Python/Python-ast.c	-	arg_attributes	variable	static const char *arg_attributes[]
-Python/Python-ast.c	-	arg_fields	variable	static const char *arg_fields[]
-Python/Python-ast.c	-	arg_type	variable	static PyTypeObject *arg_type
-Python/Python-ast.c	-	arguments_fields	variable	static const char *arguments_fields[]
-Python/Python-ast.c	-	arguments_type	variable	static PyTypeObject *arguments_type
-Python/Python-ast.c	-	Assert_fields	variable	static const char *Assert_fields[]
-Python/compile.c	compiler_assert	assertion_error	variable	static PyObject *assertion_error
-Python/Python-ast.c	-	Assert_type	variable	static PyTypeObject *Assert_type
-Python/Python-ast.c	-	Assign_fields	variable	static const char *Assign_fields[]
-Python/Python-ast.c	-	Assign_type	variable	static PyTypeObject *Assign_type
-Python/Python-ast.c	-	_astmodule	variable	static struct PyModuleDef _astmodule
-Python/Python-ast.c	-	AST_type	variable	static PyTypeObject AST_type
-Python/Python-ast.c	-	ast_type_getsets	variable	static PyGetSetDef ast_type_getsets[]
-Python/Python-ast.c	-	ast_type_methods	variable	static PyMethodDef ast_type_methods
-Python/Python-ast.c	-	AsyncFor_fields	variable	static const char *AsyncFor_fields[]
-Python/Python-ast.c	-	AsyncFor_type	variable	static PyTypeObject *AsyncFor_type
-Python/Python-ast.c	-	AsyncFunctionDef_fields	variable	static const char *AsyncFunctionDef_fields[]
-Python/Python-ast.c	-	AsyncFunctionDef_type	variable	static PyTypeObject *AsyncFunctionDef_type
-Objects/genobject.c	-	async_gen_as_async	variable	static PyAsyncMethods async_gen_as_async
-Objects/genobject.c	-	async_gen_asend_as_async	variable	static PyAsyncMethods async_gen_asend_as_async
-Objects/genobject.c	-	async_gen_asend_methods	variable	static PyMethodDef async_gen_asend_methods
-Objects/genobject.c	-	async_gen_athrow_as_async	variable	static PyAsyncMethods async_gen_athrow_as_async
-Objects/genobject.c	-	async_gen_athrow_methods	variable	static PyMethodDef async_gen_athrow_methods
-Objects/genobject.c	-	async_gen_getsetlist	variable	static PyGetSetDef async_gen_getsetlist[]
-Python/sysmodule.c	-	asyncgen_hooks_desc	variable	static PyStructSequence_Desc asyncgen_hooks_desc
-Python/sysmodule.c	-	asyncgen_hooks_fields	variable	static PyStructSequence_Field asyncgen_hooks_fields[]
-Python/sysmodule.c	-	AsyncGenHooksType	variable	static PyTypeObject AsyncGenHooksType
-Objects/genobject.c	-	async_gen_memberlist	variable	static PyMemberDef async_gen_memberlist[]
-Objects/genobject.c	-	async_gen_methods	variable	static PyMethodDef async_gen_methods
-Python/Python-ast.c	-	AsyncWith_fields	variable	static const char *AsyncWith_fields[]
-Python/Python-ast.c	-	AsyncWith_type	variable	static PyTypeObject *AsyncWith_type
-Modules/atexitmodule.c	-	atexit_methods	variable	static PyMethodDef atexit_methods
-Modules/atexitmodule.c	-	atexitmodule	variable	static struct PyModuleDef atexitmodule
-Modules/atexitmodule.c	-	atexit_slots	variable	static PyModuleDef_Slot atexit_slots[]
-Modules/_operator.c	-	attrgetter_methods	variable	static PyMethodDef attrgetter_methods
-Modules/_operator.c	-	attrgetter_type	variable	static PyTypeObject attrgetter_type
-Python/Python-ast.c	-	Attribute_fields	variable	static const char *Attribute_fields[]
-Python/Python-ast.c	-	Attribute_type	variable	static PyTypeObject *Attribute_type
-Python/Python-ast.c	-	AugAssign_fields	variable	static const char *AugAssign_fields[]
-Python/Python-ast.c	-	AugAssign_type	variable	static PyTypeObject *AugAssign_type
-Python/Python-ast.c	-	AugLoad_singleton	variable	static PyObject *AugLoad_singleton
-Python/Python-ast.c	-	AugLoad_type	variable	static PyTypeObject *AugLoad_type
-Python/Python-ast.c	-	AugStore_singleton	variable	static PyObject *AugStore_singleton
-Python/Python-ast.c	-	AugStore_type	variable	static PyTypeObject *AugStore_type
-Python/Python-ast.c	-	Await_fields	variable	static const char *Await_fields[]
-Python/Python-ast.c	-	Await_type	variable	static PyTypeObject *Await_type
-Objects/exceptions.c	-	BaseException_getset	variable	static PyGetSetDef BaseException_getset[]
-Objects/exceptions.c	-	BaseException_members	variable	static struct PyMemberDef BaseException_members[]
-Objects/exceptions.c	-	BaseException_methods	variable	static PyMethodDef BaseException_methods
-Modules/posixmodule.c	-	billion	variable	static PyObject *billion
-Python/Python-ast.c	-	BinOp_fields	variable	static const char *BinOp_fields[]
-Python/Python-ast.c	-	BinOp_type	variable	static PyTypeObject *BinOp_type
-Python/Python-ast.c	-	BitAnd_singleton	variable	static PyObject *BitAnd_singleton
-Python/Python-ast.c	-	BitAnd_type	variable	static PyTypeObject *BitAnd_type
-Python/Python-ast.c	-	BitOr_singleton	variable	static PyObject *BitOr_singleton
-Python/Python-ast.c	-	BitOr_type	variable	static PyTypeObject *BitOr_type
-Python/Python-ast.c	-	BitXor_singleton	variable	static PyObject *BitXor_singleton
-Python/Python-ast.c	-	BitXor_type	variable	static PyTypeObject *BitXor_type
-Objects/unicodeobject.c	-	bloom_linebreak	variable	static BLOOM_MASK bloom_linebreak
-Objects/boolobject.c	-	bool_as_number	variable	static PyNumberMethods bool_as_number
-Python/Python-ast.c	-	BoolOp_fields	variable	static const char *BoolOp_fields[]
-Python/Python-ast.c	-	boolop_type	variable	static PyTypeObject *boolop_type
-Python/Python-ast.c	-	BoolOp_type	variable	static PyTypeObject *BoolOp_type
-Python/_warnings.c	is_internal_frame	bootstrap_string	variable	static PyObject *bootstrap_string
-Python/Python-ast.c	-	Break_type	variable	static PyTypeObject *Break_type
-Modules/_io/bufferedio.c	-	bufferediobase_methods	variable	static PyMethodDef bufferediobase_methods
-Modules/_io/bufferedio.c	-	bufferedrandom_getset	variable	static PyGetSetDef bufferedrandom_getset[]
-Modules/_io/bufferedio.c	-	bufferedrandom_members	variable	static PyMemberDef bufferedrandom_members[]
-Modules/_io/bufferedio.c	-	bufferedrandom_methods	variable	static PyMethodDef bufferedrandom_methods
-Modules/_io/bufferedio.c	-	bufferedreader_getset	variable	static PyGetSetDef bufferedreader_getset[]
-Modules/_io/bufferedio.c	-	bufferedreader_members	variable	static PyMemberDef bufferedreader_members[]
-Modules/_io/bufferedio.c	-	bufferedreader_methods	variable	static PyMethodDef bufferedreader_methods
-Modules/_io/bufferedio.c	-	bufferedrwpair_getset	variable	static PyGetSetDef bufferedrwpair_getset[]
-Modules/_io/bufferedio.c	-	bufferedrwpair_methods	variable	static PyMethodDef bufferedrwpair_methods
-Modules/_io/bufferedio.c	-	bufferedwriter_getset	variable	static PyGetSetDef bufferedwriter_getset[]
-Modules/_io/bufferedio.c	-	bufferedwriter_members	variable	static PyMemberDef bufferedwriter_members[]
-Modules/_io/bufferedio.c	-	bufferedwriter_methods	variable	static PyMethodDef bufferedwriter_methods
-Modules/getbuildinfo.c	Py_GetBuildInfo	buildinfo	variable	static char buildinfo[50 + sizeof(GITVERSION) + ((sizeof(GITTAG) > sizeof(GITBRANCH)) ?  sizeof(GITTAG) : sizeof(GITBRANCH))]
-Python/bltinmodule.c	-	builtin_methods	variable	static PyMethodDef builtin_methods
-Python/bltinmodule.c	-	builtinsmodule	variable	static struct PyModuleDef builtinsmodule
-Python/import.c	PyImport_Import	builtins_str	variable	static PyObject *builtins_str
-Python/ceval.c	make_pending_calls	busy	variable	static int busy
-Objects/bytearrayobject.c	-	bytearray_as_buffer	variable	static PyBufferProcs bytearray_as_buffer
-Objects/bytearrayobject.c	-	bytearray_as_mapping	variable	static PyMappingMethods bytearray_as_mapping
-Objects/bytearrayobject.c	-	bytearray_as_number	variable	static PyNumberMethods bytearray_as_number
-Objects/bytearrayobject.c	-	bytearray_as_sequence	variable	static PySequenceMethods bytearray_as_sequence
-Objects/bytearrayobject.c	-	bytearrayiter_methods	variable	static PyMethodDef bytearrayiter_methods
-Objects/bytearrayobject.c	-	bytearray_methods	variable	static PyMethodDef bytearray_methods
-Objects/bytesobject.c	-	bytes_as_buffer	variable	static PyBufferProcs bytes_as_buffer
-Objects/bytesobject.c	-	bytes_as_mapping	variable	static PyMappingMethods bytes_as_mapping
-Objects/bytesobject.c	-	bytes_as_number	variable	static PyNumberMethods bytes_as_number
-Objects/bytesobject.c	-	bytes_as_sequence	variable	static PySequenceMethods bytes_as_sequence
-Modules/_io/bytesio.c	-	bytesiobuf_as_buffer	variable	static PyBufferProcs bytesiobuf_as_buffer
-Modules/_io/bytesio.c	-	bytesio_getsetlist	variable	static PyGetSetDef bytesio_getsetlist[]
-Modules/_io/bytesio.c	-	bytesio_methods	variable	static PyMethodDef bytesio_methods
-Objects/bytesobject.c	-	bytes_methods	variable	static PyMethodDef bytes_methods
-Python/thread_pthread.h	init_condattr	ca	variable	static pthread_condattr_t ca
-Python/Python-ast.c	-	Call_fields	variable	static const char *Call_fields[]
-Objects/iterobject.c	-	calliter_methods	variable	static PyMethodDef calliter_methods
-Python/Python-ast.c	-	Call_type	variable	static PyTypeObject *Call_type
-Objects/cellobject.c	-	cell_getsetlist	variable	static PyGetSetDef cell_getsetlist[]
-Modules/itertoolsmodule.c	-	chain_methods	variable	static PyMethodDef chain_methods
-Modules/itertoolsmodule.c	-	chain_type	variable	static PyTypeObject chain_type
-Objects/bytesobject.c	-	characters	variable	static PyBytesObject *characters[UCHAR_MAX + 1]
-Python/symtable.c	-	__class__	variable	static identifier __class__
-Python/Python-ast.c	-	ClassDef_fields	variable	static const char *ClassDef_fields[]
-Python/Python-ast.c	-	ClassDef_type	variable	static PyTypeObject *ClassDef_type
-Objects/funcobject.c	-	cm_getsetlist	variable	static PyGetSetDef cm_getsetlist[]
-Objects/funcobject.c	-	cm_memberlist	variable	static PyMemberDef cm_memberlist[]
-Python/Python-ast.c	-	cmpop_type	variable	static PyTypeObject *cmpop_type
-Modules/_codecsmodule.c	-	_codecs_functions	variable	static PyMethodDef _codecs_functions[]
-Modules/_codecsmodule.c	-	codecsmodule	variable	static struct PyModuleDef codecsmodule
-Objects/codeobject.c	-	code_memberlist	variable	static PyMemberDef code_memberlist[]
-Objects/codeobject.c	-	code_methods	variable	static PyMethodDef code_methods
-Modules/_collectionsmodule.c	-	_collectionsmodule	variable	static struct PyModuleDef _collectionsmodule
-Modules/itertoolsmodule.c	-	combinations_methods	variable	static PyMethodDef combinations_methods
-Modules/itertoolsmodule.c	-	combinations_type	variable	static PyTypeObject combinations_type
-Objects/typeobject.c	object_new	comma_id	variable	_Py_static_string(comma_id, "", "")
-Python/Python-ast.c	-	Compare_fields	variable	static const char *Compare_fields[]
-Python/Python-ast.c	-	Compare_type	variable	static PyTypeObject *Compare_type
-Objects/complexobject.c	-	complex_as_number	variable	static PyNumberMethods complex_as_number
-Objects/complexobject.c	-	complex_members	variable	static PyMemberDef complex_members[]
-Objects/complexobject.c	-	complex_methods	variable	static PyMethodDef complex_methods
-Python/Python-ast.c	-	comprehension_fields	variable	static const char *comprehension_fields[]
-Python/Python-ast.c	-	comprehension_type	variable	static PyTypeObject *comprehension_type
-Modules/itertoolsmodule.c	-	compress_methods	variable	static PyMethodDef compress_methods
-Modules/itertoolsmodule.c	-	compress_type	variable	static PyTypeObject compress_type
-Python/thread_pthread.h	-	condattr_monotonic	variable	static pthread_condattr_t *condattr_monotonic
-Python/Python-ast.c	-	Constant_fields	variable	static const char *Constant_fields[]
-Python/Python-ast.c	-	Constant_type	variable	static PyTypeObject *Constant_type
-Python/Python-ast.c	-	Continue_type	variable	static PyTypeObject *Continue_type
-Objects/longobject.c	PyLong_FromString	convmultmax_base	variable	static twodigits convmultmax_base[37]
-Objects/longobject.c	PyLong_FromString	convwidth_base	variable	static int convwidth_base[37]
-Objects/genobject.c	-	coro_as_async	variable	static PyAsyncMethods coro_as_async
-Objects/genobject.c	-	coro_getsetlist	variable	static PyGetSetDef coro_getsetlist[]
-Objects/genobject.c	-	coro_memberlist	variable	static PyMemberDef coro_memberlist[]
-Objects/genobject.c	-	coro_methods	variable	static PyMethodDef coro_methods
-Objects/genobject.c	-	coro_wrapper_methods	variable	static PyMethodDef coro_wrapper_methods
-Modules/itertoolsmodule.c	-	count_methods	variable	static PyMethodDef count_methods
-Modules/itertoolsmodule.c	-	count_type	variable	static PyTypeObject count_type
-Python/context.c	-	ctx_freelist	variable	static PyContext *ctx_freelist
-Python/context.c	-	ctx_freelist_len	variable	static int ctx_freelist_len
-Modules/itertoolsmodule.c	-	cwr_methods	variable	static PyMethodDef cwr_methods
-Modules/itertoolsmodule.c	-	cwr_type	variable	static PyTypeObject cwr_type
-Modules/itertoolsmodule.c	-	cycle_methods	variable	static PyMethodDef cycle_methods
-Modules/itertoolsmodule.c	-	cycle_type	variable	static PyTypeObject cycle_type
-Objects/obmalloc.c	new_arena	debug_stats	variable	static int debug_stats
-Modules/signalmodule.c	-	DefaultHandler	variable	static PyObject *DefaultHandler
-Modules/_collectionsmodule.c	-	defdict_members	variable	static PyMemberDef defdict_members[]
-Modules/_collectionsmodule.c	-	defdict_methods	variable	static PyMethodDef defdict_methods
-Modules/_collectionsmodule.c	-	defdict_type	variable	static PyTypeObject defdict_type
-Python/Python-ast.c	-	Delete_fields	variable	static const char *Delete_fields[]
-Python/Python-ast.c	-	Delete_type	variable	static PyTypeObject *Delete_type
-Python/Python-ast.c	-	Del_singleton	variable	static PyObject *Del_singleton
-Python/Python-ast.c	-	Del_type	variable	static PyTypeObject *Del_type
-Modules/_collectionsmodule.c	-	deque_as_number	variable	static PyNumberMethods deque_as_number
-Modules/_collectionsmodule.c	-	deque_as_sequence	variable	static PySequenceMethods deque_as_sequence
-Modules/_collectionsmodule.c	-	deque_getset	variable	static PyGetSetDef deque_getset[]
-Modules/_collectionsmodule.c	-	dequeiter_methods	variable	static PyMethodDef dequeiter_methods
-Modules/_collectionsmodule.c	-	dequeiter_type	variable	static PyTypeObject dequeiter_type
-Modules/_collectionsmodule.c	-	deque_methods	variable	static PyMethodDef deque_methods
-Modules/_collectionsmodule.c	-	dequereviter_type	variable	static PyTypeObject dequereviter_type
-Modules/_collectionsmodule.c	-	deque_type	variable	static PyTypeObject deque_type
-Objects/descrobject.c	-	descr_members	variable	static PyMemberDef descr_members[]
-Objects/descrobject.c	-	descr_methods	variable	static PyMethodDef descr_methods
-Modules/_abc.c	-	_destroy_def	variable	static PyMethodDef _destroy_def
-Objects/floatobject.c	-	detected_double_format	variable	static float_format_type detected_double_format
-Objects/floatobject.c	-	detected_float_format	variable	static float_format_type detected_float_format
-Objects/dictobject.c	-	dict_as_mapping	variable	static PyMappingMethods dict_as_mapping
-Objects/dictobject.c	-	dict_as_sequence	variable	static PySequenceMethods dict_as_sequence
-Python/symtable.c	-	dictcomp	variable	static identifier dictcomp
-Python/Python-ast.c	-	DictComp_fields	variable	static const char *DictComp_fields[]
-Python/Python-ast.c	-	DictComp_type	variable	static PyTypeObject *DictComp_type
-Python/Python-ast.c	-	Dict_fields	variable	static const char *Dict_fields[]
-Objects/dictobject.c	-	dictitems_as_sequence	variable	static PySequenceMethods dictitems_as_sequence
-Objects/dictobject.c	-	dictitems_methods	variable	static PyMethodDef dictitems_methods
-Objects/dictobject.c	-	dictiter_methods	variable	static PyMethodDef dictiter_methods
-Objects/dictobject.c	-	dictkeys_as_sequence	variable	static PySequenceMethods dictkeys_as_sequence
-Objects/dictobject.c	-	dictkeys_methods	variable	static PyMethodDef dictkeys_methods
-Python/Python-ast.c	-	Dict_type	variable	static PyTypeObject *Dict_type
-Objects/dictobject.c	-	dictvalues_as_sequence	variable	static PySequenceMethods dictvalues_as_sequence
-Objects/dictobject.c	-	dictvalues_methods	variable	static PyMethodDef dictvalues_methods
-Objects/dictobject.c	-	dictviews_as_number	variable	static PyNumberMethods dictviews_as_number
-Modules/posixmodule.c	-	DirEntry_members	variable	static PyMemberDef DirEntry_members[]
-Modules/posixmodule.c	-	DirEntry_methods	variable	static PyMethodDef DirEntry_methods
-Modules/posixmodule.c	-	DirEntryType	variable	static PyTypeObject DirEntryType
-Python/Python-ast.c	-	Div_singleton	variable	static PyObject *Div_singleton
-Python/Python-ast.c	-	Div_type	variable	static PyTypeObject *Div_type
-Python/compile.c	-	__doc__	variable	static PyObject *__doc__
-Objects/classobject.c	method_get_doc	docstr	variable	static PyObject *docstr
-Objects/classobject.c	instancemethod_get_doc	docstr	variable	static PyObject *docstr
-Python/compile.c	compiler_set_qualname	dot	variable	_Py_static_string(dot, ""."")
-Python/compile.c	compiler_set_qualname	dot_locals	variable	_Py_static_string(dot_locals, "".<locals>"")
-Objects/floatobject.c	-	double_format	variable	static float_format_type double_format
-Modules/itertoolsmodule.c	-	dropwhile_methods	variable	static PyMethodDef dropwhile_methods
-Modules/itertoolsmodule.c	-	dropwhile_type	variable	static PyTypeObject dropwhile_type
-Objects/setobject.c	-	_dummy_struct	variable	static PyObject _dummy_struct
-Modules/posixmodule.c	os_dup2_impl	dup3_works	variable	static int dup3_works
-Modules/_io/bufferedio.c	_PyIO_trap_eintr	eintr_int	variable	static PyObject *eintr_int
-Objects/sliceobject.c	-	ellipsis_methods	variable	static PyMethodDef ellipsis_methods
-Python/hamt.c	-	_empty_bitmap_node	variable	static PyHamtNode_Bitmap *_empty_bitmap_node
-Objects/setobject.c	-	emptyfrozenset	variable	static PyObject *emptyfrozenset
-Python/hamt.c	-	_empty_hamt	variable	static PyHamtObject *_empty_hamt
-Objects/dictobject.c	-	empty_keys_struct	variable	static PyDictKeysObject empty_keys_struct
-Objects/codeobject.c	PyCode_NewEmpty	emptystring	variable	static PyObject *emptystring
-Python/compile.c	compiler_from_import	empty_string	variable	static PyObject *empty_string
-Objects/dictobject.c	-	empty_values	variable	static PyObject *empty_values[1]
-Objects/unicodeobject.c	-	encoding_map_methods	variable	static PyMethodDef encoding_map_methods
-Objects/unicodeobject.c	-	EncodingMapType	variable	static PyTypeObject EncodingMapType
-Objects/enumobject.c	-	enum_methods	variable	static PyMethodDef enum_methods
-Python/Python-ast.c	-	Eq_singleton	variable	static PyObject *Eq_singleton
-Python/Python-ast.c	-	Eq_type	variable	static PyTypeObject *Eq_type
-Objects/exceptions.c	-	errnomap	variable	static PyObject *errnomap
-Modules/errnomodule.c	-	errno_methods	variable	static PyMethodDef errno_methods
-Modules/errnomodule.c	-	errnomodule	variable	static struct PyModuleDef errnomodule
-Modules/_localemodule.c	-	Error	variable	static PyObject *Error
-Python/Python-ast.c	-	excepthandler_attributes	variable	static const char *excepthandler_attributes[]
-Python/Python-ast.c	-	ExceptHandler_fields	variable	static const char *ExceptHandler_fields[]
-Python/Python-ast.c	-	excepthandler_type	variable	static PyTypeObject *excepthandler_type
-Python/Python-ast.c	-	ExceptHandler_type	variable	static PyTypeObject *ExceptHandler_type
-Modules/_threadmodule.c	-	ExceptHookArgs_desc	variable	static PyStructSequence_Desc ExceptHookArgs_desc
-Modules/_threadmodule.c	-	ExceptHookArgs_fields	variable	static PyStructSequence_Field ExceptHookArgs_fields[]
-Modules/_threadmodule.c	-	ExceptHookArgsType	variable	static PyTypeObject ExceptHookArgsType
-Objects/exceptions.c	_check_for_legacy_statements	exec_prefix	variable	static PyObject *exec_prefix
-Python/Python-ast.c	-	expr_attributes	variable	static const char *expr_attributes[]
-Python/Python-ast.c	-	expr_context_type	variable	static PyTypeObject *expr_context_type
-Python/Python-ast.c	-	Expression_fields	variable	static const char *Expression_fields[]
-Python/Python-ast.c	-	Expression_type	variable	static PyTypeObject *Expression_type
-Python/Python-ast.c	-	Expr_fields	variable	static const char *Expr_fields[]
-Python/Python-ast.c	-	expr_type	variable	static PyTypeObject *expr_type
-Python/Python-ast.c	-	Expr_type	variable	static PyTypeObject *Expr_type
-Python/import.c	-	extensions	variable	static PyObject *extensions
-Python/Python-ast.c	-	ExtSlice_fields	variable	static const char *ExtSlice_fields[]
-Python/Python-ast.c	-	ExtSlice_type	variable	static PyTypeObject *ExtSlice_type
-Objects/boolobject.c	-	false_str	variable	static PyObject *false_str
-Modules/faulthandler.c	-	fatal_error	variable	static struct { int enabled; PyObject *file; int fd; int all_threads; PyInterpreterState *interp; void *exc_handler; } fatal_error
-Modules/faulthandler.c	-	faulthandler_handlers	variable	static fault_handler_t faulthandler_handlers[]
-Objects/stringlib/unicode_format.h	-	fieldnameiter_methods	variable	static PyMethodDef fieldnameiter_methods
-Modules/_io/fileio.c	-	fileio_getsetlist	variable	static PyGetSetDef fileio_getsetlist[]
-Modules/_io/fileio.c	-	fileio_members	variable	static PyMemberDef fileio_members[]
-Modules/_io/fileio.c	-	fileio_methods	variable	static PyMethodDef fileio_methods
-Modules/itertoolsmodule.c	-	filterfalse_methods	variable	static PyMethodDef filterfalse_methods
-Modules/itertoolsmodule.c	-	filterfalse_type	variable	static PyTypeObject filterfalse_type
-Python/bltinmodule.c	-	filter_methods	variable	static PyMethodDef filter_methods
-Python/sysmodule.c	-	flags_desc	variable	static PyStructSequence_Desc flags_desc
-Python/sysmodule.c	-	flags_fields	variable	static PyStructSequence_Field flags_fields[]
-Python/sysmodule.c	-	FlagsType	variable	static PyTypeObject FlagsType
-Objects/floatobject.c	-	float_as_number	variable	static PyNumberMethods float_as_number
-Objects/floatobject.c	-	float_format	variable	static float_format_type 
-Objects/floatobject.c	-	float_getset	variable	static PyGetSetDef float_getset[]
-Objects/floatobject.c	-	floatinfo_desc	variable	static PyStructSequence_Desc floatinfo_desc
-Objects/floatobject.c	-	floatinfo_fields	variable	static PyStructSequence_Field floatinfo_fields[]
-Objects/floatobject.c	-	FloatInfoType	variable	static PyTypeObject FloatInfoType
-Objects/floatobject.c	-	float_methods	variable	static PyMethodDef float_methods
-Python/Python-ast.c	-	FloorDiv_singleton	variable	static PyObject *FloorDiv_singleton
-Python/Python-ast.c	-	FloorDiv_type	variable	static PyTypeObject *FloorDiv_type
-Python/fileutils.c	-	force_ascii	variable	static int force_ascii
-Python/Python-ast.c	-	For_fields	variable	static const char *For_fields[]
-Python/Python-ast.c	-	FormattedValue_fields	variable	static const char *FormattedValue_fields[]
-Python/Python-ast.c	-	FormattedValue_type	variable	static PyTypeObject *FormattedValue_type
-Objects/stringlib/unicode_format.h	-	formatteriter_methods	variable	static PyMethodDef formatteriter_methods
-Python/Python-ast.c	-	For_type	variable	static PyTypeObject *For_type
-Objects/frameobject.c	-	frame_getsetlist	variable	static PyGetSetDef frame_getsetlist[]
-Objects/frameobject.c	-	frame_memberlist	variable	static PyMemberDef frame_memberlist[]
-Objects/frameobject.c	-	frame_methods	variable	static PyMethodDef frame_methods
-Modules/_collectionsmodule.c	-	freeblocks	variable	static block *freeblocks[MAXFREEBLOCKS]
-Python/dtoa.c	-	freelist	variable	static Bigint *freelist[Kmax+1]
-Objects/floatobject.c	-	free_list	variable	static PyFloatObject *free_list
-Objects/frameobject.c	-	free_list	variable	static PyFrameObject *free_list
-Objects/listobject.c	-	free_list	variable	static PyListObject *free_list[PyList_MAXFREELIST]
-Objects/dictobject.c	-	free_list	variable	static PyDictObject *free_list[PyDict_MAXFREELIST]
-Objects/methodobject.c	-	free_list	variable	static PyCFunctionObject *free_list
-Objects/tupleobject.c	-	free_list	variable	static PyTupleObject *free_list[PyTuple_MAXSAVESIZE]
-Objects/classobject.c	-	free_list	variable	static PyMethodObject *free_list
-Objects/setobject.c	-	frozenset_as_number	variable	static PyNumberMethods frozenset_as_number
-Objects/setobject.c	-	frozenset_methods	variable	static PyMethodDef frozenset_methods
-Objects/funcobject.c	-	func_getsetlist	variable	static PyGetSetDef func_getsetlist[]
-Objects/funcobject.c	-	func_memberlist	variable	static PyMemberDef func_memberlist[]
-Python/Python-ast.c	-	FunctionDef_fields	variable	static const char *FunctionDef_fields[]
-Python/Python-ast.c	-	FunctionDef_type	variable	static PyTypeObject *FunctionDef_type
-Modules/_sre.c	-	_functions	variable	static PyMethodDef _functions[]
-Python/Python-ast.c	-	FunctionType_fields	variable	static const char *FunctionType_fields[]
-Python/Python-ast.c	-	FunctionType_type	variable	static PyTypeObject *FunctionType_type
-Modules/_functoolsmodule.c	-	_functoolsmodule	variable	static struct PyModuleDef _functoolsmodule
-Modules/gcmodule.c	-	GcMethods	variable	static PyMethodDef GcMethods[]
-Modules/gcmodule.c	-	gcmodule	variable	static struct PyModuleDef gcmodule
-Modules/gcmodule.c	-	gc_str	variable	static PyObject *gc_str
-Python/Python-ast.c	-	GeneratorExp_fields	variable	static const char *GeneratorExp_fields[]
-Python/Python-ast.c	-	GeneratorExp_type	variable	static PyTypeObject *GeneratorExp_type
-Python/symtable.c	-	genexpr	variable	static identifier genexpr
-Objects/genobject.c	-	gen_getsetlist	variable	static PyGetSetDef gen_getsetlist[]
-Objects/genobject.c	-	gen_memberlist	variable	static PyMemberDef gen_memberlist[]
-Objects/genobject.c	-	gen_methods	variable	static PyMethodDef gen_methods
-Python/bootstrap_hash.c	py_getrandom	getrandom_works	variable	static int getrandom_works
-Objects/descrobject.c	-	getset_getset	variable	static PyGetSetDef getset_getset[]
-Python/Python-ast.c	-	Global_fields	variable	static const char *Global_fields[]
-Python/Python-ast.c	-	Global_type	variable	static PyTypeObject *Global_type
-Modules/itertoolsmodule.c	-	groupby_methods	variable	static PyMethodDef groupby_methods
-Modules/itertoolsmodule.c	-	groupby_type	variable	static PyTypeObject groupby_type
-Modules/itertoolsmodule.c	-	_grouper_methods	variable	static PyMethodDef _grouper_methods
-Modules/itertoolsmodule.c	-	_grouper_type	variable	static PyTypeObject _grouper_type
-Python/Python-ast.c	-	GtE_singleton	variable	static PyObject *GtE_singleton
-Python/Python-ast.c	-	GtE_type	variable	static PyTypeObject *GtE_type
-Python/Python-ast.c	-	Gt_singleton	variable	static PyObject *Gt_singleton
-Python/Python-ast.c	-	Gt_type	variable	static PyTypeObject *Gt_type
-Modules/signalmodule.c	-	Handlers	variable	static volatile struct { _Py_atomic_int tripped; PyObject *func; } Handlers[NSIG]
-Python/dynload_shlib.c	-	handles	variable	static struct { dev_t dev; ino_t ino; void *handle; } handles[128]
-Python/sysmodule.c	-	hash_info_desc	variable	static PyStructSequence_Desc hash_info_desc
-Python/sysmodule.c	-	hash_info_fields	variable	static PyStructSequence_Field hash_info_fields[]
-Python/sysmodule.c	-	Hash_InfoType	variable	static PyTypeObject Hash_InfoType
-Python/import.c	import_find_and_load	header	variable	static int header
-Python/Python-ast.c	-	IfExp_fields	variable	static const char *IfExp_fields[]
-Python/Python-ast.c	-	IfExp_type	variable	static PyTypeObject *IfExp_type
-Python/Python-ast.c	-	If_fields	variable	static const char *If_fields[]
-Python/Python-ast.c	-	If_type	variable	static PyTypeObject *If_type
-Modules/signalmodule.c	-	IgnoreHandler	variable	static PyObject *IgnoreHandler
-Python/import.c	-	imp_methods	variable	static PyMethodDef imp_methods
-Python/import.c	-	impmodule	variable	static struct PyModuleDef impmodule
-Objects/exceptions.c	-	ImportError_members	variable	static PyMemberDef ImportError_members[]
-Objects/exceptions.c	-	ImportError_methods	variable	static PyMethodDef ImportError_methods
-Python/Python-ast.c	-	Import_fields	variable	static const char *Import_fields[]
-Python/Python-ast.c	-	ImportFrom_fields	variable	static const char *ImportFrom_fields[]
-Python/Python-ast.c	-	ImportFrom_type	variable	static PyTypeObject *ImportFrom_type
-Python/import.c	import_find_and_load	import_level	variable	static int import_level
-Python/_warnings.c	is_internal_frame	importlib_string	variable	static PyObject *importlib_string
-Python/import.c	-	import_lock	variable	static PyThread_type_lock import_lock
-Python/import.c	-	import_lock_level	variable	static int import_lock_level
-Python/import.c	-	import_lock_thread	variable	static unsigned long import_lock_thread
-Python/import.c	PyImport_Import	import_str	variable	static PyObject *import_str
-Python/Python-ast.c	-	Import_type	variable	static PyTypeObject *Import_type
-Modules/_io/textio.c	-	incrementalnewlinedecoder_getset	variable	static PyGetSetDef incrementalnewlinedecoder_getset[]
-Modules/_io/textio.c	-	incrementalnewlinedecoder_methods	variable	static PyMethodDef incrementalnewlinedecoder_methods
-Objects/listobject.c	-	indexerr	variable	static PyObject *indexerr
-Python/Python-ast.c	-	Index_fields	variable	static const char *Index_fields[]
-Python/Python-ast.c	-	Index_type	variable	static PyTypeObject *Index_type
-Python/thread.c	-	initialized	variable	static int initialized
-Modules/posixmodule.c	-	initialized	variable	static int initialized
-Modules/pwdmodule.c	-	initialized	variable	static int initialized
-Modules/signalmodule.c	-	initialized	variable	static int initialized
-Modules/timemodule.c	-	initialized	variable	static int initialized
-Python/Python-ast.c	init_types	initialized	variable	static int initialized
-Objects/listobject.c	PyList_New	initialized	variable	static int initialized
-Python/import.c	-	inittab_copy	variable	static struct _inittab *inittab_copy
-Python/Python-ast.c	-	In_singleton	variable	static PyObject *In_singleton
-Objects/classobject.c	-	instancemethod_getset	variable	static PyGetSetDef instancemethod_getset[]
-Objects/classobject.c	-	instancemethod_memberlist	variable	static PyMemberDef instancemethod_memberlist[]
-Python/Python-ast.c	-	Interactive_fields	variable	static const char *Interactive_fields[]
-Python/Python-ast.c	-	Interactive_type	variable	static PyTypeObject *Interactive_type
-Objects/unicodeobject.c	-	interned	variable	static PyObject *interned
-Objects/interpreteridobject.c	-	interpid_as_number	variable	static PyNumberMethods interpid_as_number
-Modules/signalmodule.c	-	IntHandler	variable	static PyObject *IntHandler
-Objects/longobject.c	-	int_info_desc	variable	static PyStructSequence_Desc int_info_desc
-Objects/longobject.c	-	int_info_fields	variable	static PyStructSequence_Field int_info_fields[]
-Objects/longobject.c	-	Int_InfoType	variable	static PyTypeObject Int_InfoType
-Python/Python-ast.c	-	In_type	variable	static PyTypeObject *In_type
-Python/Python-ast.c	-	Invert_singleton	variable	static PyObject *Invert_singleton
-Python/Python-ast.c	-	Invert_type	variable	static PyTypeObject *Invert_type
-Modules/_io/iobase.c	-	iobase_getset	variable	static PyGetSetDef iobase_getset[]
-Modules/_io/iobase.c	-	iobase_methods	variable	static PyMethodDef iobase_methods
-Python/fileutils.c	set_inheritable	ioctl_works	variable	static int ioctl_works
-Modules/itertoolsmodule.c	-	islice_methods	variable	static PyMethodDef islice_methods
-Modules/itertoolsmodule.c	-	islice_type	variable	static PyTypeObject islice_type
-Python/Python-ast.c	-	IsNot_singleton	variable	static PyObject *IsNot_singleton
-Python/Python-ast.c	-	IsNot_type	variable	static PyTypeObject *IsNot_type
-Python/Python-ast.c	-	Is_singleton	variable	static PyObject *Is_singleton
-Modules/signalmodule.c	-	is_tripped	variable	static _Py_atomic_int is_tripped
-Python/Python-ast.c	-	Is_type	variable	static PyTypeObject *Is_type
-Modules/_operator.c	-	itemgetter_methods	variable	static PyMethodDef itemgetter_methods
-Modules/_operator.c	-	itemgetter_type	variable	static PyTypeObject itemgetter_type
-Modules/itertoolsmodule.c	-	itertoolsmodule	variable	static struct PyModuleDef itertoolsmodule
-Modules/signalmodule.c	-	ItimerError	variable	static PyObject *ItimerError
-Python/Python-ast.c	-	JoinedStr_fields	variable	static const char *JoinedStr_fields[]
-Python/Python-ast.c	-	JoinedStr_type	variable	static PyTypeObject *JoinedStr_type
-Modules/_functoolsmodule.c	-	keyobject_members	variable	static PyMemberDef keyobject_members[]
-Modules/_functoolsmodule.c	-	keyobject_type	variable	static PyTypeObject keyobject_type
-Objects/dictobject.c	-	keys_free_list	variable	static PyDictKeysObject *keys_free_list[PyDict_MAXFREELIST]
-Python/Python-ast.c	-	keyword_fields	variable	static const char *keyword_fields[]
-Python/sysmodule.c	sys_set_asyncgen_hooks	keywords	variable	static const char *keywords[]
-Modules/_bisectmodule.c	bisect_right	keywords	variable	static const char *keywords[]
-Modules/_bisectmodule.c	insort_right	keywords	variable	static const char *keywords[]
-Python/Python-ast.c	-	keyword_type	variable	static PyTypeObject *keyword_type
-Modules/_functoolsmodule.c	keyobject_call	kwargs	variable	static const char *kwargs[]
-Modules/_functoolsmodule.c	functools_cmp_to_key	kwargs	variable	static const char *kwargs[]
-Modules/itertoolsmodule.c	repeat_new	kwargs	variable	static const char *kwargs[]
-Python/_warnings.c	warnings_warn_explicit	kwd_list	variable	static const char *kwd_list[]
-Modules/_functoolsmodule.c	-	kwd_mark	variable	static PyObject *kwd_mark
-Python/bltinmodule.c	builtin___import__	kwlist	variable	static const char *kwlist[]
-Python/bltinmodule.c	min_max	kwlist	variable	static const char *kwlist[]
-Python/context.c	contextvar_tp_new	kwlist	variable	static const char *kwlist[]
-Python/sysmodule.c	sys_getsizeof	kwlist	variable	static const char *kwlist[]
-Objects/bytearrayobject.c	bytearray_init	kwlist	variable	static const char *kwlist[]
-Objects/bytesobject.c	bytes_new	kwlist	variable	static const char *kwlist[]
-Objects/exceptions.c	ImportError_init	kwlist	variable	static const char *kwlist[]
-Objects/interpreteridobject.c	interpid_new	kwlist	variable	static const char *kwlist[]
-Objects/memoryobject.c	memory_new	kwlist	variable	static const char *kwlist[]
-Objects/memoryobject.c	memory_cast	kwlist	variable	static const char *kwlist[]
-Objects/memoryobject.c	memory_tobytes	kwlist	variable	static const char *kwlist[]
-Objects/odictobject.c	odict_pop	kwlist	variable	static const char *kwlist[]
-Objects/unicodeobject.c	unicode_new	kwlist	variable	static const char *kwlist[]
-Objects/weakrefobject.c	weakref_call	kwlist	variable	static const char *kwlist[]
-Modules/_elementtree.c	element_setstate_from_Python	kwlist	variable	static const char *kwlist[]
-Modules/_json.c	scanner_call	kwlist	variable	static const char *kwlist[]
-Modules/_json.c	scanner_new	kwlist	variable	static const char *kwlist[]
-Modules/_json.c	encoder_new	kwlist	variable	static const char *kwlist[]
-Modules/_json.c	encoder_call	kwlist	variable	static const char *kwlist[]
-Python/symtable.c	-	lambda	variable	static identifier lambda
-Python/Python-ast.c	-	Lambda_fields	variable	static const char *Lambda_fields[]
-Python/Python-ast.c	-	Lambda_type	variable	static PyTypeObject *Lambda_type
-Objects/listobject.c	-	list_as_mapping	variable	static PyMappingMethods list_as_mapping
-Objects/listobject.c	-	list_as_sequence	variable	static PySequenceMethods list_as_sequence
-Python/symtable.c	-	listcomp	variable	static identifier listcomp
-Python/Python-ast.c	-	ListComp_fields	variable	static const char *ListComp_fields[]
-Python/Python-ast.c	-	ListComp_type	variable	static PyTypeObject *ListComp_type
-Python/Python-ast.c	-	List_fields	variable	static const char *List_fields[]
-Objects/listobject.c	-	listiter_methods	variable	static PyMethodDef listiter_methods
-Objects/listobject.c	-	list_methods	variable	static PyMethodDef list_methods
-Objects/listobject.c	-	listreviter_methods	variable	static PyMethodDef listreviter_methods
-Python/Python-ast.c	-	List_type	variable	static PyTypeObject *List_type
-Python/ceval.c	-	lltrace	variable	static int lltrace
-Python/Python-ast.c	-	Load_singleton	variable	static PyObject *Load_singleton
-Python/Python-ast.c	-	Load_type	variable	static PyTypeObject *Load_type
-Modules/_threadmodule.c	-	localdummytype	variable	static PyTypeObject localdummytype
-Modules/_localemodule.c	-	_localemodule	variable	static struct PyModuleDef _localemodule
-Modules/_threadmodule.c	-	localtype	variable	static PyTypeObject localtype
-Modules/_threadmodule.c	-	lock_methods	variable	static PyMethodDef lock_methods
-Modules/_threadmodule.c	-	Locktype	variable	static PyTypeObject Locktype
-Objects/longobject.c	PyLong_FromString	log_base_BASE	variable	static double log_base_BASE[37]
-Objects/longobject.c	-	long_as_number	variable	static PyNumberMethods long_as_number
-Objects/longobject.c	-	long_getset	variable	static PyGetSetDef long_getset[]
-Objects/longobject.c	-	long_methods	variable	static PyMethodDef long_methods
-Objects/rangeobject.c	-	longrangeiter_methods	variable	static PyMethodDef longrangeiter_methods
-Modules/_functoolsmodule.c	-	lru_cache_getsetlist	variable	static PyGetSetDef lru_cache_getsetlist[]
-Modules/_functoolsmodule.c	-	lru_cache_methods	variable	static PyMethodDef lru_cache_methods
-Modules/_functoolsmodule.c	-	lru_cache_type	variable	static PyTypeObject lru_cache_type
-Modules/_functoolsmodule.c	-	lru_list_elem_type	variable	static PyTypeObject lru_list_elem_type
-Python/Python-ast.c	-	LShift_singleton	variable	static PyObject *LShift_singleton
-Python/Python-ast.c	-	LShift_type	variable	static PyTypeObject *LShift_type
-Python/Python-ast.c	-	LtE_singleton	variable	static PyObject *LtE_singleton
-Python/Python-ast.c	-	LtE_type	variable	static PyTypeObject *LtE_type
-Python/Python-ast.c	-	Lt_singleton	variable	static PyObject *Lt_singleton
-Python/Python-ast.c	-	Lt_type	variable	static PyTypeObject *Lt_type
-Python/bltinmodule.c	-	map_methods	variable	static PyMethodDef map_methods
-Objects/descrobject.c	-	mappingproxy_as_mapping	variable	static PyMappingMethods mappingproxy_as_mapping
-Objects/descrobject.c	-	mappingproxy_as_sequence	variable	static PySequenceMethods mappingproxy_as_sequence
-Objects/descrobject.c	-	mappingproxy_methods	variable	static PyMethodDef mappingproxy_methods
-Objects/dictobject.c	-	mapp_methods	variable	static PyMethodDef mapp_methods
-Python/marshal.c	-	marshal_methods	variable	static PyMethodDef marshal_methods
-Python/marshal.c	-	marshalmodule	variable	static struct PyModuleDef marshalmodule
-Modules/_sre.c	-	match_as_mapping	variable	static PyMappingMethods match_as_mapping
-Modules/_sre.c	-	match_getset	variable	static PyGetSetDef match_getset[]
-Modules/_sre.c	-	match_members	variable	static PyMemberDef match_members[]
-Modules/_sre.c	-	match_methods	variable	static PyMethodDef match_methods
-Modules/_sre.c	-	Match_Type	variable	static PyTypeObject Match_Type
-Python/Python-ast.c	-	MatMult_singleton	variable	static PyObject *MatMult_singleton
-Python/Python-ast.c	-	MatMult_type	variable	static PyTypeObject *MatMult_type
-Objects/obmalloc.c	-	maxarenas	variable	static uint maxarenas
-Objects/moduleobject.c	-	max_module_number	variable	static Py_ssize_t max_module_number
-Objects/descrobject.c	-	member_getset	variable	static PyGetSetDef member_getset[]
-Objects/exceptions.c	-	memerrors_freelist	variable	static PyBaseExceptionObject *memerrors_freelist
-Objects/exceptions.c	-	memerrors_numfree	variable	static int memerrors_numfree
-Objects/memoryobject.c	-	memory_as_buffer	variable	static PyBufferProcs memory_as_buffer
-Objects/memoryobject.c	-	memory_as_mapping	variable	static PyMappingMethods memory_as_mapping
-Objects/memoryobject.c	-	memory_as_sequence	variable	static PySequenceMethods memory_as_sequence
-Objects/memoryobject.c	-	memory_getsetlist	variable	static PyGetSetDef memory_getsetlist[]
-Objects/memoryobject.c	-	memory_methods	variable	static PyMethodDef memory_methods
-Objects/methodobject.c	-	meth_getsets	variable	static PyGetSetDef meth_getsets []
-Objects/methodobject.c	-	meth_members	variable	static PyMemberDef meth_members[]
-Objects/methodobject.c	-	meth_methods	variable	static PyMethodDef meth_methods
-Objects/typeobject.c	-	method_cache	variable	static struct method_cache_entry method_cache[1 << MCACHE_SIZE_EXP]
-Modules/_operator.c	-	methodcaller_methods	variable	static PyMethodDef methodcaller_methods
-Modules/_operator.c	-	methodcaller_type	variable	static PyTypeObject methodcaller_type
-Objects/classobject.c	-	method_getset	variable	static PyGetSetDef method_getset[]
-Objects/descrobject.c	-	method_getset	variable	static PyGetSetDef method_getset[]
-Objects/classobject.c	-	method_memberlist	variable	static PyMemberDef method_memberlist[]
-Objects/classobject.c	-	method_methods	variable	static PyMethodDef method_methods
-Python/codecs.c	_PyCodecRegistry_Init	methods	variable	static struct { char *name; PyMethodDef def; } methods[]
-Python/frozen.c	-	M___hello__	variable	static unsigned char M___hello__[]
-Python/Python-ast.c	-	Mod_singleton	variable	static PyObject *Mod_singleton
-Python/Python-ast.c	-	mod_type	variable	static PyTypeObject *mod_type
-Python/Python-ast.c	-	Mod_type	variable	static PyTypeObject *Mod_type
-Modules/faulthandler.c	-	module_def	variable	static struct PyModuleDef module_def
-Modules/_tracemalloc.c	-	module_def	variable	static struct PyModuleDef module_def
-Python/Python-ast.c	-	Module_fields	variable	static const char *Module_fields[]
-Modules/_collectionsmodule.c	-	module_functions	variable	static struct PyMethodDef module_functions[]
-Modules/_abc.c	-	module_functions	variable	static struct PyMethodDef module_functions[]
-Objects/moduleobject.c	-	module_members	variable	static PyMemberDef module_members[]
-Objects/moduleobject.c	-	module_methods	variable	static PyMethodDef module_methods
-Modules/_functoolsmodule.c	-	module_methods	variable	static PyMethodDef module_methods
-Modules/itertoolsmodule.c	-	module_methods	variable	static PyMethodDef module_methods
-Modules/_io/_iomodule.c	-	module_methods	variable	static PyMethodDef module_methods
-Modules/faulthandler.c	-	module_methods	variable	static PyMethodDef module_methods
-Modules/_tracemalloc.c	-	module_methods	variable	static PyMethodDef module_methods
-Python/Python-ast.c	-	Module_type	variable	static PyTypeObject *Module_type
-Python/Python-ast.c	-	Mult_singleton	variable	static PyObject *Mult_singleton
-Python/Python-ast.c	-	Mult_type	variable	static PyTypeObject *Mult_type
-Objects/funcobject.c	PyFunction_NewWithQualName	__name__	variable	static PyObject *__name__
-Python/compile.c	compiler_lambda	name	variable	static identifier name
-Python/compile.c	compiler_genexp	name	variable	static identifier name
-Python/compile.c	compiler_listcomp	name	variable	static identifier name
-Python/compile.c	compiler_setcomp	name	variable	static identifier name
-Python/compile.c	compiler_dictcomp	name	variable	static identifier name
-Python/Python-ast.c	-	NamedExpr_fields	variable	static const char *NamedExpr_fields[]
-Python/Python-ast.c	-	NamedExpr_type	variable	static PyTypeObject *NamedExpr_type
-Python/Python-ast.c	-	Name_fields	variable	static const char *Name_fields[]
-Objects/typeobject.c	-	name_op	variable	static _Py_Identifier name_op[]
-Objects/namespaceobject.c	-	namespace_members	variable	static PyMemberDef namespace_members[]
-Objects/namespaceobject.c	-	namespace_methods	variable	static PyMethodDef namespace_methods
-Python/Python-ast.c	-	Name_type	variable	static PyTypeObject *Name_type
-Objects/obmalloc.c	-	narenas_currently_allocated	variable	static size_t narenas_currently_allocated
-Objects/obmalloc.c	-	narenas_highwater	variable	static size_t narenas_highwater
-Python/sysmodule.c	sys_displayhook	newline	variable	static PyObject *newline
-Objects/typeobject.c	-	next_version_tag	variable	static unsigned int next_version_tag
-Objects/obmalloc.c	-	nfp2lasta	variable	static struct arena_object* nfp2lasta[MAX_POOLS_IN_ARENA + 1]
-Python/dynload_shlib.c	-	nhandles	variable	static int nhandles
-Objects/object.c	-	none_as_number	variable	static PyNumberMethods none_as_number
-Python/Python-ast.c	-	Nonlocal_fields	variable	static const char *Nonlocal_fields[]
-Python/Python-ast.c	-	Nonlocal_type	variable	static PyTypeObject *Nonlocal_type
-Python/Python-ast.c	-	NotEq_singleton	variable	static PyObject *NotEq_singleton
-Python/Python-ast.c	-	NotEq_type	variable	static PyTypeObject *NotEq_type
-Objects/object.c	-	notimplemented_methods	variable	static PyMethodDef notimplemented_methods
-Python/Python-ast.c	-	NotIn_singleton	variable	static PyObject *NotIn_singleton
-Python/Python-ast.c	-	NotIn_type	variable	static PyTypeObject *NotIn_type
-Python/Python-ast.c	-	Not_singleton	variable	static PyObject *Not_singleton
-Python/Python-ast.c	-	Not_type	variable	static PyTypeObject *Not_type
-Objects/obmalloc.c	-	ntimes_arena_allocated	variable	static size_t ntimes_arena_allocated
-Objects/bytesobject.c	-	nullstring	variable	static PyBytesObject *nullstring
-Objects/codeobject.c	PyCode_NewEmpty	nulltuple	variable	static PyObject *nulltuple
-Objects/floatobject.c	-	numfree	variable	static int numfree
-Objects/frameobject.c	-	numfree	variable	static int numfree
-Objects/listobject.c	-	numfree	variable	static int numfree
-Objects/dictobject.c	-	numfree	variable	static int numfree
-Objects/methodobject.c	-	numfree	variable	static int numfree
-Objects/tupleobject.c	-	numfree	variable	static int numfree[PyTuple_MAXSAVESIZE]
-Objects/classobject.c	-	numfree	variable	static int numfree
-Modules/_collectionsmodule.c	-	numfreeblocks	variable	static Py_ssize_t numfreeblocks
-Objects/dictobject.c	-	numfreekeys	variable	static int numfreekeys
-Objects/typeobject.c	-	object_getsets	variable	static PyGetSetDef object_getsets[]
-Objects/typeobject.c	-	object_methods	variable	static PyMethodDef object_methods
-Objects/typeobject.c	object___reduce_ex___impl	objreduce	variable	static PyObject *objreduce
-Objects/odictobject.c	-	odict_as_mapping	variable	static PyMappingMethods odict_as_mapping
-Objects/odictobject.c	-	odict_getset	variable	static PyGetSetDef odict_getset[]
-Objects/odictobject.c	-	odictitems_methods	variable	static PyMethodDef odictitems_methods
-Objects/odictobject.c	-	odictiter_methods	variable	static PyMethodDef odictiter_methods
-Objects/odictobject.c	-	odictkeys_methods	variable	static PyMethodDef odictkeys_methods
-Objects/odictobject.c	-	odict_methods	variable	static PyMethodDef odict_methods
-Objects/odictobject.c	-	odictvalues_methods	variable	static PyMethodDef odictvalues_methods
-Modules/faulthandler.c	-	old_stack	variable	static stack_t old_stack
-Modules/_operator.c	-	operator_methods	variable	static PyMethodDef operator_methods
-Modules/_operator.c	-	operatormodule	variable	static struct PyModuleDef operatormodule
-Python/Python-ast.c	-	operator_type	variable	static PyTypeObject *operator_type
-Objects/typeobject.c	slot_nb_add	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_subtract	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_multiply	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_matrix_multiply	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_remainder	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_divmod	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_power_binary	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_lshift	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_rshift	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_and	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_xor	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_or	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_floor_divide	op_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_true_divide	op_id	variable	_Py_static_string(op_id, OPSTR)
-Python/getopt.c	-	opt_ptr	variable	static const wchar_t *opt_ptr
-Python/initconfig.c	-	orig_argv	variable	static PyWideStringList orig_argv
-Python/Python-ast.c	-	Or_singleton	variable	static PyObject *Or_singleton
-Python/Python-ast.c	-	Or_type	variable	static PyTypeObject *Or_type
-Objects/exceptions.c	-	OSError_getset	variable	static PyGetSetDef OSError_getset[]
-Objects/exceptions.c	-	OSError_members	variable	static PyMemberDef OSError_members[]
-Objects/exceptions.c	-	OSError_methods	variable	static PyMethodDef OSError_methods
-Python/dtoa.c	-	p5s	variable	static Bigint *p5s
-Python/Python-ast.c	-	Param_singleton	variable	static PyObject *Param_singleton
-Python/Python-ast.c	-	Param_type	variable	static PyTypeObject *Param_type
-Python/bltinmodule.c	builtin_print	_parser	variable	static struct _PyArg_Parser _parser
-Python/clinic/_warnings.c.h	warnings_warn	_parser	variable	static _PyArg_Parser _parser
-Python/clinic/bltinmodule.c.h	builtin_compile	_parser	variable	static _PyArg_Parser _parser
-Python/clinic/bltinmodule.c.h	builtin_round	_parser	variable	static _PyArg_Parser _parser
-Python/clinic/bltinmodule.c.h	builtin_sum	_parser	variable	static _PyArg_Parser _parser
-Python/clinic/import.c.h	_imp_source_hash	_parser	variable	static _PyArg_Parser _parser
-Python/clinic/sysmodule.c.h	sys_addaudithook	_parser	variable	static _PyArg_Parser _parser
-Python/clinic/sysmodule.c.h	sys_set_coroutine_origin_tracking_depth	_parser	variable	static _PyArg_Parser _parser
-Python/clinic/traceback.c.h	tb_new	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytearrayobject.c.h	bytearray_translate	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytearrayobject.c.h	bytearray_split	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytearrayobject.c.h	bytearray_rsplit	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytearrayobject.c.h	bytearray_decode	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytearrayobject.c.h	bytearray_splitlines	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytearrayobject.c.h	bytearray_hex	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytesobject.c.h	bytes_split	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytesobject.c.h	bytes_rsplit	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytesobject.c.h	bytes_translate	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytesobject.c.h	bytes_decode	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytesobject.c.h	bytes_splitlines	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/bytesobject.c.h	bytes_hex	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/codeobject.c.h	code_replace	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/complexobject.c.h	complex_new	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/descrobject.c.h	mappingproxy_new	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/descrobject.c.h	property_init	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/enumobject.c.h	enum_new	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/funcobject.c.h	func_new	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/listobject.c.h	list_sort	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/longobject.c.h	long_new	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/longobject.c.h	int_to_bytes	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/longobject.c.h	int_from_bytes	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/memoryobject.c.h	memoryview_hex	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/moduleobject.c.h	module___init__	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/odictobject.c.h	OrderedDict_fromkeys	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/odictobject.c.h	OrderedDict_setdefault	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/odictobject.c.h	OrderedDict_popitem	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/odictobject.c.h	OrderedDict_move_to_end	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/structseq.c.h	structseq_new	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/unicodeobject.c.h	unicode_encode	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/unicodeobject.c.h	unicode_expandtabs	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/unicodeobject.c.h	unicode_split	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/unicodeobject.c.h	unicode_rsplit	_parser	variable	static _PyArg_Parser _parser
-Objects/clinic/unicodeobject.c.h	unicode_splitlines	_parser	variable	static _PyArg_Parser _parser
-Objects/stringlib/clinic/transmogrify.h.h	stringlib_expandtabs	_parser	variable	static _PyArg_Parser _parser
-Modules/_blake2/clinic/blake2b_impl.c.h	py_blake2b_new	_parser	variable	static _PyArg_Parser _parser
-Modules/_blake2/clinic/blake2s_impl.c.h	py_blake2s_new	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/_iomodule.c.h	_io_open	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/_iomodule.c.h	_io_open_code	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/bufferedio.c.h	_io_BufferedReader___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/bufferedio.c.h	_io_BufferedWriter___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/bufferedio.c.h	_io_BufferedRandom___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/bytesio.c.h	_io_BytesIO___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/fileio.c.h	_io_FileIO___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/stringio.c.h	_io_StringIO___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/textio.c.h	_io_IncrementalNewlineDecoder___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/textio.c.h	_io_IncrementalNewlineDecoder_decode	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/textio.c.h	_io_TextIOWrapper___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/textio.c.h	_io_TextIOWrapper_reconfigure	_parser	variable	static _PyArg_Parser _parser
-Modules/_io/clinic/winconsoleio.c.h	_io__WindowsConsoleIO___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/_multiprocessing/clinic/posixshmem.c.h	_posixshmem_shm_open	_parser	variable	static _PyArg_Parser _parser
-Modules/_multiprocessing/clinic/posixshmem.c.h	_posixshmem_shm_unlink	_parser	variable	static _PyArg_Parser _parser
-Modules/cjkcodecs/clinic/multibytecodec.c.h	_multibytecodec_MultibyteCodec_encode	_parser	variable	static _PyArg_Parser _parser
-Modules/cjkcodecs/clinic/multibytecodec.c.h	_multibytecodec_MultibyteCodec_decode	_parser	variable	static _PyArg_Parser _parser
-Modules/cjkcodecs/clinic/multibytecodec.c.h	_multibytecodec_MultibyteIncrementalEncoder_encode	_parser	variable	static _PyArg_Parser _parser
-Modules/cjkcodecs/clinic/multibytecodec.c.h	_multibytecodec_MultibyteIncrementalDecoder_decode	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio_Future___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio_Future_add_done_callback	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio_Task___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio_Task_current_task	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio_Task_all_tasks	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio_Task_get_stack	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio_Task_print_stack	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio__register_task	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio__unregister_task	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio__enter_task	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_asynciomodule.c.h	_asyncio__leave_task	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_bz2module.c.h	_bz2_BZ2Decompressor_decompress	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_codecsmodule.c.h	_codecs_encode	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_codecsmodule.c.h	_codecs_decode	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_cursesmodule.c.h	_curses_setupterm	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_datetimemodule.c.h	datetime_datetime_now	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_elementtree.c.h	_elementtree_Element_find	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_elementtree.c.h	_elementtree_Element_findtext	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_elementtree.c.h	_elementtree_Element_findall	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_elementtree.c.h	_elementtree_Element_iterfind	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_elementtree.c.h	_elementtree_Element_get	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_elementtree.c.h	_elementtree_Element_iter	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_elementtree.c.h	_elementtree_Element_getiterator	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_elementtree.c.h	_elementtree_TreeBuilder___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_elementtree.c.h	_elementtree_XMLParser___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_hashopenssl.c.h	EVP_new	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_hashopenssl.c.h	pbkdf2_hmac	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_hashopenssl.c.h	_hashlib_scrypt	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_hashopenssl.c.h	_hashlib_hmac_digest	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_lzmamodule.c.h	_lzma_LZMADecompressor_decompress	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_lzmamodule.c.h	_lzma_LZMADecompressor___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_opcode.c.h	_opcode_stack_effect	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_pickle.c.h	_pickle_Pickler___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_pickle.c.h	_pickle_Unpickler___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_pickle.c.h	_pickle_dump	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_pickle.c.h	_pickle_dumps	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_pickle.c.h	_pickle_load	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_pickle.c.h	_pickle_loads	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_queuemodule.c.h	_queue_SimpleQueue_put	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_queuemodule.c.h	_queue_SimpleQueue_put_nowait	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_queuemodule.c.h	_queue_SimpleQueue_get	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Pattern_match	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Pattern_fullmatch	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Pattern_search	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Pattern_findall	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Pattern_finditer	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Pattern_scanner	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Pattern_split	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Pattern_sub	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Pattern_subn	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_compile	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Match_expand	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Match_groups	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_sre.c.h	_sre_SRE_Match_groupdict	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_ssl.c.h	_ssl__SSLSocket_get_channel_binding	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_ssl.c.h	_ssl__SSLContext_load_cert_chain	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_ssl.c.h	_ssl__SSLContext_load_verify_locations	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_ssl.c.h	_ssl__SSLContext__wrap_socket	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_ssl.c.h	_ssl__SSLContext__wrap_bio	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_ssl.c.h	_ssl__SSLContext_get_ca_certs	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_ssl.c.h	_ssl_txt2obj	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_ssl.c.h	_ssl_enum_certificates	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_ssl.c.h	_ssl_enum_crls	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_struct.c.h	Struct___init__	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_struct.c.h	Struct_unpack_from	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_struct.c.h	unpack_from	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_winapi.c.h	_winapi_ConnectNamedPipe	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_winapi.c.h	_winapi_ReadFile	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_winapi.c.h	_winapi_WriteFile	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/_winapi.c.h	_winapi_GetFileType	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/binascii.c.h	binascii_b2a_uu	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/binascii.c.h	binascii_b2a_base64	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/binascii.c.h	binascii_b2a_hex	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/binascii.c.h	binascii_hexlify	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/binascii.c.h	binascii_a2b_qp	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/binascii.c.h	binascii_b2a_qp	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/cmathmodule.c.h	cmath_isclose	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/gcmodule.c.h	gc_collect	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/gcmodule.c.h	gc_get_objects	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/grpmodule.c.h	grp_getgrgid	_parser	variable	static _PyArg_Parser _parser
-Modules/clinic/grpmodule.c.h	grp_getgrnam	_parser	variable	static _PyArg_Parser _parser
-Modules/_functoolsmodule.c	-	partial_getsetlist	variable	static PyGetSetDef partial_getsetlist[]
-Modules/_functoolsmodule.c	-	partial_memberlist	variable	static PyMemberDef partial_memberlist[]
-Modules/_functoolsmodule.c	-	partial_methods	variable	static PyMethodDef partial_methods
-Modules/_functoolsmodule.c	-	partial_type	variable	static PyTypeObject partial_type
-Python/Python-ast.c	-	Pass_type	variable	static PyTypeObject *Pass_type
-Modules/_sre.c	-	pattern_getset	variable	static PyGetSetDef pattern_getset[]
-Modules/_sre.c	-	pattern_members	variable	static PyMemberDef pattern_members[]
-Modules/_sre.c	-	pattern_methods	variable	static PyMethodDef pattern_methods
-Modules/_sre.c	-	Pattern_Type	variable	static PyTypeObject Pattern_Type
-Modules/itertoolsmodule.c	-	permuations_methods	variable	static PyMethodDef permuations_methods
-Modules/itertoolsmodule.c	-	permutations_type	variable	static PyTypeObject permutations_type
-Objects/picklebufobject.c	-	picklebuf_as_buffer	variable	static PyBufferProcs picklebuf_as_buffer
-Objects/picklebufobject.c	-	picklebuf_methods	variable	static PyMethodDef picklebuf_methods
-Python/dtoa.c	-	pmem_next	variable	static double *pmem_next
-Objects/typeobject.c	resolve_slotdups	pname	variable	static PyObject *pname
-Modules/posixmodule.c	-	posix_constants_confstr	variable	static struct constdef posix_constants_confstr[]
-Modules/posixmodule.c	-	posix_constants_pathconf	variable	static struct constdef  posix_constants_pathconf[]
-Modules/posixmodule.c	-	posix_constants_sysconf	variable	static struct constdef posix_constants_sysconf[]
-Modules/posixmodule.c	-	posix_methods	variable	static PyMethodDef posix_methods
-Modules/posixmodule.c	-	posixmodule	variable	static struct PyModuleDef posixmodule
-Modules/posixmodule.c	-	posix_putenv_garbage	variable	static PyObject *posix_putenv_garbage
-Python/Python-ast.c	-	Pow_singleton	variable	static PyObject *Pow_singleton
-Python/Python-ast.c	-	Pow_type	variable	static PyTypeObject *Pow_type
-Python/sysmodule.c	-	_preinit_warnoptions	variable	static _Py_PreInitEntry _preinit_warnoptions
-Python/sysmodule.c	-	_preinit_xoptions	variable	static _Py_PreInitEntry _preinit_xoptions
-Objects/exceptions.c	_check_for_legacy_statements	print_prefix	variable	static PyObject *print_prefix
-Python/dtoa.c	-	private_mem	variable	static double private_mem[PRIVATE_mem]
-Modules/itertoolsmodule.c	-	product_methods	variable	static PyMethodDef product_methods
-Modules/itertoolsmodule.c	-	product_type	variable	static PyTypeObject product_type
-Objects/descrobject.c	-	property_getsetlist	variable	static PyGetSetDef property_getsetlist[]
-Objects/descrobject.c	-	property_members	variable	static PyMemberDef property_members[]
-Objects/descrobject.c	-	property_methods	variable	static PyMethodDef property_methods
-Objects/weakrefobject.c	-	proxy_as_mapping	variable	static PyMappingMethods proxy_as_mapping
-Objects/weakrefobject.c	-	proxy_as_number	variable	static PyNumberMethods proxy_as_number
-Objects/weakrefobject.c	-	proxy_as_sequence	variable	static PySequenceMethods proxy_as_sequence
-Objects/weakrefobject.c	-	proxy_methods	variable	static PyMethodDef proxy_methods
-Objects/typeobject.c	resolve_slotdups	ptrs	variable	static slotdef *ptrs[MAX_EQUIV]
-Modules/pwdmodule.c	-	pwd_methods	variable	static PyMethodDef pwd_methods
-Modules/pwdmodule.c	-	pwdmodule	variable	static struct PyModuleDef pwdmodule
-Objects/obmalloc.c	-	_Py_AllocatedBlocks	variable	static Py_ssize_t _Py_AllocatedBlocks
-Objects/genobject.c	-	_PyAsyncGenASend_Type	variable	PyTypeObject _PyAsyncGenASend_Type
-Objects/genobject.c	-	_PyAsyncGenAThrow_Type	variable	PyTypeObject _PyAsyncGenAThrow_Type
-Objects/genobject.c	-	PyAsyncGen_Type	variable	PyTypeObject PyAsyncGen_Type
-Objects/genobject.c	-	_PyAsyncGenWrappedValue_Type	variable	PyTypeObject _PyAsyncGenWrappedValue_Type
-Objects/typeobject.c	-	PyBaseObject_Type	variable	PyTypeObject PyBaseObject_Type
-Modules/_blake2/blake2b_impl.c	-	PyBlake2_BLAKE2bType	variable	PyTypeObject PyBlake2_BLAKE2bType
-Modules/_blake2/blake2s_impl.c	-	PyBlake2_BLAKE2sType	variable	PyTypeObject PyBlake2_BLAKE2sType
-Objects/boolobject.c	-	PyBool_Type	variable	PyTypeObject PyBool_Type
-Modules/_io/bufferedio.c	-	PyBufferedIOBase_Type	variable	PyTypeObject PyBufferedIOBase_Type
-Modules/_io/bufferedio.c	-	PyBufferedRandom_Type	variable	PyTypeObject PyBufferedRandom_Type
-Modules/_io/bufferedio.c	-	PyBufferedReader_Type	variable	PyTypeObject PyBufferedReader_Type
-Modules/_io/bufferedio.c	-	PyBufferedRWPair_Type	variable	PyTypeObject PyBufferedRWPair_Type
-Modules/_io/bufferedio.c	-	PyBufferedWriter_Type	variable	PyTypeObject PyBufferedWriter_Type
-Objects/bytearrayobject.c	-	_PyByteArray_empty_string	variable	char _PyByteArray_empty_string[]
-Objects/bytearrayobject.c	-	PyByteArrayIter_Type	variable	PyTypeObject PyByteArrayIter_Type
-Objects/bytearrayobject.c	-	PyByteArray_Type	variable	PyTypeObject PyByteArray_Type
-Modules/_io/bytesio.c	-	_PyBytesIOBuffer_Type	variable	PyTypeObject _PyBytesIOBuffer_Type
-Modules/_io/bytesio.c	-	PyBytesIO_Type	variable	PyTypeObject PyBytesIO_Type
-Objects/bytesobject.c	-	PyBytesIter_Type	variable	PyTypeObject PyBytesIter_Type
-Objects/bytesobject.c	-	PyBytes_Type	variable	PyTypeObject PyBytes_Type
-Python/initconfig.c	-	Py_BytesWarningFlag	variable	int Py_BytesWarningFlag
-Objects/iterobject.c	-	PyCallIter_Type	variable	PyTypeObject PyCallIter_Type
-Objects/capsule.c	-	PyCapsule_Type	variable	PyTypeObject PyCapsule_Type
-Objects/cellobject.c	-	PyCell_Type	variable	PyTypeObject PyCell_Type
-Objects/methodobject.c	-	PyCFunction_Type	variable	PyTypeObject PyCFunction_Type
-Objects/descrobject.c	-	PyClassMethodDescr_Type	variable	PyTypeObject PyClassMethodDescr_Type
-Objects/funcobject.c	-	PyClassMethod_Type	variable	PyTypeObject PyClassMethod_Type
-Objects/codeobject.c	-	PyCode_Type	variable	PyTypeObject PyCode_Type
-Objects/complexobject.c	-	PyComplex_Type	variable	PyTypeObject PyComplex_Type
-Python/context.c	-	PyContext_as_mapping	variable	static PyMappingMethods PyContext_as_mapping
-Python/context.c	-	PyContext_as_sequence	variable	static PySequenceMethods PyContext_as_sequence
-Python/context.c	-	PyContext_methods	variable	static PyMethodDef PyContext_methods
-Python/context.c	-	PyContextTokenMissing_Type	variable	PyTypeObject PyContextTokenMissing_Type
-Python/context.c	-	PyContextToken_Type	variable	PyTypeObject PyContextToken_Type
-Python/context.c	-	PyContextTokenType_getsetlist	variable	static PyGetSetDef PyContextTokenType_getsetlist[]
-Python/context.c	-	PyContext_Type	variable	PyTypeObject PyContext_Type
-Python/context.c	-	PyContextVar_members	variable	static PyMemberDef PyContextVar_members[]
-Python/context.c	-	PyContextVar_methods	variable	static PyMethodDef PyContextVar_methods
-Python/context.c	-	PyContextVar_Type	variable	PyTypeObject PyContextVar_Type
-Objects/genobject.c	-	PyCoro_Type	variable	PyTypeObject PyCoro_Type
-Objects/genobject.c	-	_PyCoroWrapper_Type	variable	PyTypeObject _PyCoroWrapper_Type
-Python/initconfig.c	-	Py_DebugFlag	variable	int Py_DebugFlag
-Objects/dictobject.c	-	pydict_global_version	variable	static uint64_t pydict_global_version
-Objects/dictobject.c	-	PyDictItems_Type	variable	PyTypeObject PyDictItems_Type
-Objects/dictobject.c	-	PyDictIterItem_Type	variable	PyTypeObject PyDictIterItem_Type
-Objects/dictobject.c	-	PyDictIterKey_Type	variable	PyTypeObject PyDictIterKey_Type
-Objects/dictobject.c	-	PyDictIterValue_Type	variable	PyTypeObject PyDictIterValue_Type
-Objects/dictobject.c	-	PyDictKeys_Type	variable	PyTypeObject PyDictKeys_Type
-Objects/descrobject.c	-	PyDictProxy_Type	variable	PyTypeObject PyDictProxy_Type
-Objects/dictobject.c	-	PyDictRevIterItem_Type	variable	PyTypeObject PyDictRevIterItem_Type
-Objects/dictobject.c	-	PyDictRevIterKey_Type	variable	PyTypeObject PyDictRevIterKey_Type
-Objects/dictobject.c	-	PyDictRevIterValue_Type	variable	PyTypeObject PyDictRevIterValue_Type
-Objects/dictobject.c	-	PyDict_Type	variable	PyTypeObject PyDict_Type
-Objects/dictobject.c	-	PyDictValues_Type	variable	PyTypeObject PyDictValues_Type
-Python/initconfig.c	-	Py_DontWriteBytecodeFlag	variable	int Py_DontWriteBytecodeFlag
-Objects/sliceobject.c	-	_Py_EllipsisObject	variable	PyObject _Py_EllipsisObject
-Objects/sliceobject.c	-	PyEllipsis_Type	variable	PyTypeObject PyEllipsis_Type
-Objects/enumobject.c	-	PyEnum_Type	variable	PyTypeObject PyEnum_Type
-Objects/exceptions.c	-	_PyExc_ArithmeticError	variable	static PyTypeObject _PyExc_ArithmeticError
-Objects/exceptions.c	-	PyExc_ArithmeticError	variable	static PyTypeObject PyExc_ArithmeticError
-Objects/exceptions.c	-	_PyExc_AssertionError	variable	static PyTypeObject _PyExc_AssertionError
-Objects/exceptions.c	-	PyExc_AssertionError	variable	static PyTypeObject PyExc_AssertionError
-Objects/exceptions.c	-	_PyExc_AttributeError	variable	static PyTypeObject _PyExc_AttributeError
-Objects/exceptions.c	-	PyExc_AttributeError	variable	static PyTypeObject PyExc_AttributeError
-Objects/exceptions.c	-	_PyExc_BaseException	variable	static PyTypeObject _PyExc_BaseException
-Objects/exceptions.c	-	PyExc_BaseException	variable	static PyTypeObject PyExc_BaseException
-Objects/exceptions.c	-	_PyExc_BlockingIOError	variable	static PyTypeObject _PyExc_BlockingIOError
-Objects/exceptions.c	-	PyExc_BlockingIOError	variable	static PyTypeObject PyExc_BlockingIOError
-Objects/exceptions.c	-	_PyExc_BrokenPipeError	variable	static PyTypeObject _PyExc_BrokenPipeError
-Objects/exceptions.c	-	PyExc_BrokenPipeError	variable	static PyTypeObject PyExc_BrokenPipeError
-Objects/exceptions.c	-	_PyExc_BufferError	variable	static PyTypeObject _PyExc_BufferError
-Objects/exceptions.c	-	PyExc_BufferError	variable	static PyTypeObject PyExc_BufferError
-Objects/exceptions.c	-	_PyExc_BytesWarning	variable	static PyTypeObject _PyExc_BytesWarning
-Objects/exceptions.c	-	PyExc_BytesWarning	variable	static PyTypeObject PyExc_BytesWarning
-Objects/exceptions.c	-	_PyExc_ChildProcessError	variable	static PyTypeObject _PyExc_ChildProcessError
-Objects/exceptions.c	-	PyExc_ChildProcessError	variable	static PyTypeObject PyExc_ChildProcessError
-Objects/exceptions.c	-	_PyExc_ConnectionAbortedError	variable	static PyTypeObject _PyExc_ConnectionAbortedError
-Objects/exceptions.c	-	PyExc_ConnectionAbortedError	variable	static PyTypeObject PyExc_ConnectionAbortedError
-Objects/exceptions.c	-	_PyExc_ConnectionError	variable	static PyTypeObject _PyExc_ConnectionError
-Objects/exceptions.c	-	PyExc_ConnectionError	variable	static PyTypeObject PyExc_ConnectionError
-Objects/exceptions.c	-	_PyExc_ConnectionRefusedError	variable	static PyTypeObject _PyExc_ConnectionRefusedError
-Objects/exceptions.c	-	PyExc_ConnectionRefusedError	variable	static PyTypeObject PyExc_ConnectionRefusedError
-Objects/exceptions.c	-	_PyExc_ConnectionResetError	variable	static PyTypeObject _PyExc_ConnectionResetError
-Objects/exceptions.c	-	PyExc_ConnectionResetError	variable	static PyTypeObject PyExc_ConnectionResetError
-Objects/exceptions.c	-	_PyExc_DeprecationWarning	variable	static PyTypeObject _PyExc_DeprecationWarning
-Objects/exceptions.c	-	PyExc_DeprecationWarning	variable	static PyTypeObject PyExc_DeprecationWarning
-Objects/exceptions.c	-	PyExc_EnvironmentError	variable	static PyTypeObject PyExc_EnvironmentError
-Objects/exceptions.c	-	_PyExc_EOFError	variable	static PyTypeObject _PyExc_EOFError
-Objects/exceptions.c	-	PyExc_EOFError	variable	static PyTypeObject PyExc_EOFError
-Objects/exceptions.c	-	_PyExc_Exception	variable	static PyTypeObject _PyExc_Exception
-Objects/exceptions.c	-	PyExc_Exception	variable	static PyTypeObject PyExc_Exception
-Objects/exceptions.c	-	_PyExc_FileExistsError	variable	static PyTypeObject _PyExc_FileExistsError
-Objects/exceptions.c	-	PyExc_FileExistsError	variable	static PyTypeObject PyExc_FileExistsError
-Objects/exceptions.c	-	_PyExc_FileNotFoundError	variable	static PyTypeObject _PyExc_FileNotFoundError
-Objects/exceptions.c	-	PyExc_FileNotFoundError	variable	static PyTypeObject PyExc_FileNotFoundError
-Objects/exceptions.c	-	_PyExc_FloatingPointError	variable	static PyTypeObject _PyExc_FloatingPointError
-Objects/exceptions.c	-	PyExc_FloatingPointError	variable	static PyTypeObject PyExc_FloatingPointError
-Objects/exceptions.c	-	_PyExc_FutureWarning	variable	static PyTypeObject _PyExc_FutureWarning
-Objects/exceptions.c	-	PyExc_FutureWarning	variable	static PyTypeObject PyExc_FutureWarning
-Objects/exceptions.c	-	_PyExc_GeneratorExit	variable	static PyTypeObject _PyExc_GeneratorExit
-Objects/exceptions.c	-	PyExc_GeneratorExit	variable	static PyTypeObject PyExc_GeneratorExit
-Objects/exceptions.c	-	_PyExc_ImportError	variable	static PyTypeObject _PyExc_ImportError
-Objects/exceptions.c	-	PyExc_ImportError	variable	static PyTypeObject PyExc_ImportError
-Objects/exceptions.c	-	_PyExc_ImportWarning	variable	static PyTypeObject _PyExc_ImportWarning
-Objects/exceptions.c	-	PyExc_ImportWarning	variable	static PyTypeObject PyExc_ImportWarning
-Objects/exceptions.c	-	_PyExc_IndentationError	variable	static PyTypeObject _PyExc_IndentationError
-Objects/exceptions.c	-	PyExc_IndentationError	variable	static PyTypeObject PyExc_IndentationError
-Objects/exceptions.c	-	_PyExc_IndexError	variable	static PyTypeObject _PyExc_IndexError
-Objects/exceptions.c	-	PyExc_IndexError	variable	static PyTypeObject PyExc_IndexError
-Objects/exceptions.c	-	_PyExc_InterruptedError	variable	static PyTypeObject _PyExc_InterruptedError
-Objects/exceptions.c	-	PyExc_InterruptedError	variable	static PyTypeObject PyExc_InterruptedError
-Objects/exceptions.c	-	PyExc_IOError	variable	static PyTypeObject PyExc_IOError
-Objects/exceptions.c	-	_PyExc_IsADirectoryError	variable	static PyTypeObject _PyExc_IsADirectoryError
-Objects/exceptions.c	-	PyExc_IsADirectoryError	variable	static PyTypeObject PyExc_IsADirectoryError
-Objects/exceptions.c	-	_PyExc_KeyboardInterrupt	variable	static PyTypeObject _PyExc_KeyboardInterrupt
-Objects/exceptions.c	-	PyExc_KeyboardInterrupt	variable	static PyTypeObject PyExc_KeyboardInterrupt
-Objects/exceptions.c	-	_PyExc_KeyError	variable	static PyTypeObject _PyExc_KeyError
-Objects/exceptions.c	-	PyExc_KeyError	variable	static PyTypeObject PyExc_KeyError
-Objects/exceptions.c	-	_PyExc_LookupError	variable	static PyTypeObject _PyExc_LookupError
-Objects/exceptions.c	-	PyExc_LookupError	variable	static PyTypeObject PyExc_LookupError
-Objects/exceptions.c	-	_PyExc_MemoryError	variable	static PyTypeObject _PyExc_MemoryError
-Objects/exceptions.c	-	PyExc_MemoryError	variable	static PyTypeObject PyExc_MemoryError
-Objects/exceptions.c	-	_PyExc_ModuleNotFoundError	variable	static PyTypeObject _PyExc_ModuleNotFoundError
-Objects/exceptions.c	-	PyExc_ModuleNotFoundError	variable	static PyTypeObject PyExc_ModuleNotFoundError
-Objects/exceptions.c	-	_PyExc_NameError	variable	static PyTypeObject _PyExc_NameError
-Objects/exceptions.c	-	PyExc_NameError	variable	static PyTypeObject PyExc_NameError
-Objects/exceptions.c	-	_PyExc_NotADirectoryError	variable	static PyTypeObject _PyExc_NotADirectoryError
-Objects/exceptions.c	-	PyExc_NotADirectoryError	variable	static PyTypeObject PyExc_NotADirectoryError
-Objects/exceptions.c	-	_PyExc_NotImplementedError	variable	static PyTypeObject _PyExc_NotImplementedError
-Objects/exceptions.c	-	PyExc_NotImplementedError	variable	static PyTypeObject PyExc_NotImplementedError
-Objects/exceptions.c	-	_PyExc_OSError	variable	static PyTypeObject _PyExc_OSError
-Objects/exceptions.c	-	PyExc_OSError	variable	static PyTypeObject PyExc_OSError
-Objects/exceptions.c	-	_PyExc_OverflowError	variable	static PyTypeObject _PyExc_OverflowError
-Objects/exceptions.c	-	PyExc_OverflowError	variable	static PyTypeObject PyExc_OverflowError
-Objects/exceptions.c	-	_PyExc_PendingDeprecationWarning	variable	static PyTypeObject _PyExc_PendingDeprecationWarning
-Objects/exceptions.c	-	PyExc_PendingDeprecationWarning	variable	static PyTypeObject PyExc_PendingDeprecationWarning
-Objects/exceptions.c	-	_PyExc_PermissionError	variable	static PyTypeObject _PyExc_PermissionError
-Objects/exceptions.c	-	PyExc_PermissionError	variable	static PyTypeObject PyExc_PermissionError
-Objects/exceptions.c	-	_PyExc_ProcessLookupError	variable	static PyTypeObject _PyExc_ProcessLookupError
-Objects/exceptions.c	-	PyExc_ProcessLookupError	variable	static PyTypeObject PyExc_ProcessLookupError
-Objects/exceptions.c	-	_PyExc_RecursionError	variable	static PyTypeObject _PyExc_RecursionError
-Objects/exceptions.c	-	PyExc_RecursionError	variable	static PyTypeObject PyExc_RecursionError
-Objects/exceptions.c	-	_PyExc_ReferenceError	variable	static PyTypeObject _PyExc_ReferenceError
-Objects/exceptions.c	-	PyExc_ReferenceError	variable	static PyTypeObject PyExc_ReferenceError
-Objects/exceptions.c	-	_PyExc_ResourceWarning	variable	static PyTypeObject _PyExc_ResourceWarning
-Objects/exceptions.c	-	PyExc_ResourceWarning	variable	static PyTypeObject PyExc_ResourceWarning
-Objects/exceptions.c	-	_PyExc_RuntimeError	variable	static PyTypeObject _PyExc_RuntimeError
-Objects/exceptions.c	-	PyExc_RuntimeError	variable	static PyTypeObject PyExc_RuntimeError
-Objects/exceptions.c	-	_PyExc_RuntimeWarning	variable	static PyTypeObject _PyExc_RuntimeWarning
-Objects/exceptions.c	-	PyExc_RuntimeWarning	variable	static PyTypeObject PyExc_RuntimeWarning
-Objects/exceptions.c	-	_PyExc_StopAsyncIteration	variable	static PyTypeObject _PyExc_StopAsyncIteration
-Objects/exceptions.c	-	PyExc_StopAsyncIteration	variable	static PyTypeObject PyExc_StopAsyncIteration
-Objects/exceptions.c	-	_PyExc_StopIteration	variable	static PyTypeObject _PyExc_StopIteration
-Objects/exceptions.c	-	PyExc_StopIteration	variable	static PyTypeObject PyExc_StopIteration
-Objects/exceptions.c	-	_PyExc_SyntaxError	variable	static PyTypeObject _PyExc_SyntaxError
-Objects/exceptions.c	-	PyExc_SyntaxError	variable	static PyTypeObject PyExc_SyntaxError
-Objects/exceptions.c	-	_PyExc_SyntaxWarning	variable	static PyTypeObject _PyExc_SyntaxWarning
-Objects/exceptions.c	-	PyExc_SyntaxWarning	variable	static PyTypeObject PyExc_SyntaxWarning
-Objects/exceptions.c	-	_PyExc_SystemError	variable	static PyTypeObject _PyExc_SystemError
-Objects/exceptions.c	-	PyExc_SystemError	variable	static PyTypeObject PyExc_SystemError
-Objects/exceptions.c	-	_PyExc_SystemExit	variable	static PyTypeObject _PyExc_SystemExit
-Objects/exceptions.c	-	PyExc_SystemExit	variable	static PyTypeObject PyExc_SystemExit
-Objects/exceptions.c	-	_PyExc_TabError	variable	static PyTypeObject _PyExc_TabError
-Objects/exceptions.c	-	PyExc_TabError	variable	static PyTypeObject PyExc_TabError
-Objects/exceptions.c	-	_PyExc_TargetScopeError	variable	static PyTypeObject _PyExc_TargetScopeError
-Objects/exceptions.c	-	PyExc_TargetScopeError	variable	static PyTypeObject PyExc_TargetScopeError
-Objects/exceptions.c	-	_PyExc_TimeoutError	variable	static PyTypeObject _PyExc_TimeoutError
-Objects/exceptions.c	-	PyExc_TimeoutError	variable	static PyTypeObject PyExc_TimeoutError
-Objects/exceptions.c	-	_PyExc_TypeError	variable	static PyTypeObject _PyExc_TypeError
-Objects/exceptions.c	-	PyExc_TypeError	variable	static PyTypeObject PyExc_TypeError
-Objects/exceptions.c	-	_PyExc_UnboundLocalError	variable	static PyTypeObject _PyExc_UnboundLocalError
-Objects/exceptions.c	-	PyExc_UnboundLocalError	variable	static PyTypeObject PyExc_UnboundLocalError
-Objects/exceptions.c	-	_PyExc_UnicodeDecodeError	variable	static PyTypeObject _PyExc_UnicodeDecodeError
-Objects/exceptions.c	-	PyExc_UnicodeDecodeError	variable	static PyTypeObject PyExc_UnicodeDecodeError
-Objects/exceptions.c	-	_PyExc_UnicodeEncodeError	variable	static PyTypeObject _PyExc_UnicodeEncodeError
-Objects/exceptions.c	-	PyExc_UnicodeEncodeError	variable	static PyTypeObject PyExc_UnicodeEncodeError
-Objects/exceptions.c	-	_PyExc_UnicodeError	variable	static PyTypeObject _PyExc_UnicodeError
-Objects/exceptions.c	-	PyExc_UnicodeError	variable	static PyTypeObject PyExc_UnicodeError
-Objects/exceptions.c	-	_PyExc_UnicodeTranslateError	variable	static PyTypeObject _PyExc_UnicodeTranslateError
-Objects/exceptions.c	-	PyExc_UnicodeTranslateError	variable	static PyTypeObject PyExc_UnicodeTranslateError
-Objects/exceptions.c	-	_PyExc_UnicodeWarning	variable	static PyTypeObject _PyExc_UnicodeWarning
-Objects/exceptions.c	-	PyExc_UnicodeWarning	variable	static PyTypeObject PyExc_UnicodeWarning
-Objects/exceptions.c	-	_PyExc_UserWarning	variable	static PyTypeObject _PyExc_UserWarning
-Objects/exceptions.c	-	PyExc_UserWarning	variable	static PyTypeObject PyExc_UserWarning
-Objects/exceptions.c	-	_PyExc_ValueError	variable	static PyTypeObject _PyExc_ValueError
-Objects/exceptions.c	-	PyExc_ValueError	variable	static PyTypeObject PyExc_ValueError
-Objects/exceptions.c	-	_PyExc_Warning	variable	static PyTypeObject _PyExc_Warning
-Objects/exceptions.c	-	PyExc_Warning	variable	static PyTypeObject PyExc_Warning
-Objects/exceptions.c	-	_PyExc_ZeroDivisionError	variable	static PyTypeObject _PyExc_ZeroDivisionError
-Objects/exceptions.c	-	PyExc_ZeroDivisionError	variable	static PyTypeObject PyExc_ZeroDivisionError
-Objects/boolobject.c	-	_Py_FalseStruct	variable	static struct _longobject _Py_FalseStruct
-Objects/tupleobject.c	-	_Py_fast_tuple_allocs	variable	Py_ssize_t _Py_fast_tuple_allocs
-Objects/stringlib/unicode_format.h	-	PyFieldNameIter_Type	variable	static PyTypeObject PyFieldNameIter_Type
-Modules/_io/fileio.c	-	PyFileIO_Type	variable	PyTypeObject PyFileIO_Type
-Python/preconfig.c	-	Py_FileSystemDefaultEncodeErrors	variable	const char *Py_FileSystemDefaultEncodeErrors
-Python/preconfig.c	-	Py_FileSystemDefaultEncoding	variable	const char * Py_FileSystemDefaultEncoding
-Python/bltinmodule.c	-	PyFilter_Type	variable	PyTypeObject PyFilter_Type
-Objects/floatobject.c	-	PyFloat_Type	variable	PyTypeObject PyFloat_Type
-Objects/stringlib/unicode_format.h	-	PyFormatterIter_Type	variable	static PyTypeObject PyFormatterIter_Type
-Objects/frameobject.c	-	PyFrame_Type	variable	PyTypeObject PyFrame_Type
-Python/initconfig.c	-	Py_FrozenFlag	variable	int Py_FrozenFlag
-Objects/setobject.c	-	PyFrozenSet_Type	variable	PyTypeObject PyFrozenSet_Type
-Objects/funcobject.c	-	PyFunction_Type	variable	PyTypeObject PyFunction_Type
-Objects/genobject.c	-	PyGen_Type	variable	PyTypeObject PyGen_Type
-Objects/descrobject.c	-	PyGetSetDescr_Type	variable	PyTypeObject PyGetSetDescr_Type
-Python/hamt.c	-	_PyHamt_ArrayNode_Type	variable	PyTypeObject _PyHamt_ArrayNode_Type
-Python/hamt.c	-	PyHamt_as_mapping	variable	static PyMappingMethods PyHamt_as_mapping
-Python/hamt.c	-	PyHamt_as_sequence	variable	static PySequenceMethods PyHamt_as_sequence
-Python/hamt.c	-	_PyHamt_BitmapNode_Type	variable	PyTypeObject _PyHamt_BitmapNode_Type
-Python/hamt.c	-	_PyHamt_CollisionNode_Type	variable	PyTypeObject _PyHamt_CollisionNode_Type
-Python/hamt.c	-	_PyHamtItems_Type	variable	PyTypeObject _PyHamtItems_Type
-Python/hamt.c	-	PyHamtIterator_as_mapping	variable	static PyMappingMethods PyHamtIterator_as_mapping
-Python/hamt.c	-	_PyHamtKeys_Type	variable	PyTypeObject _PyHamtKeys_Type
-Python/hamt.c	-	PyHamt_methods	variable	static PyMethodDef PyHamt_methods
-Python/hamt.c	-	_PyHamt_Type	variable	PyTypeObject _PyHamt_Type
-Python/hamt.c	-	_PyHamtValues_Type	variable	PyTypeObject _PyHamtValues_Type
-Python/preconfig.c	-	_Py_HasFileSystemDefaultEncodeErrors	variable	const(int) _Py_HasFileSystemDefaultEncodeErrors
-Python/preconfig.c	-	Py_HasFileSystemDefaultEncoding	variable	const(int) Py_HasFileSystemDefaultEncoding
-Python/pyhash.c	-	PyHash_Func	variable	static PyHash_FuncDef PyHash_Func
-Python/initconfig.c	-	Py_HashRandomizationFlag	variable	int Py_HashRandomizationFlag
-Python/pyhash.c	-	_Py_HashSecret	variable	_Py_HashSecret_t _Py_HashSecret
-Python/bootstrap_hash.c	-	_Py_HashSecret_Initialized	variable	static int _Py_HashSecret_Initialized
-Python/codecs.c	-	Py_hexdigits	variable	const char * Py_hexdigits
-Python/sysmodule.c	-	PyId__	variable	_Py_IDENTIFIER(_)
-Modules/_abc.c	-	PyId__abc_impl	variable	_Py_IDENTIFIER(_abc_impl)
-Objects/typeobject.c	-	PyId___abstractmethods__	variable	_Py_IDENTIFIER(__abstractmethods__)
-Modules/_abc.c	-	PyId___abstractmethods__	variable	_Py_IDENTIFIER(__abstractmethods__)
-Python/ceval.c	_PyEval_EvalFrameDefault	PyId___aenter__	variable	_Py_IDENTIFIER(__aenter__)
-Python/ceval.c	_PyEval_EvalFrameDefault	PyId___aexit__	variable	_Py_IDENTIFIER(__aexit__)
-Objects/typeobject.c	slot_am_aiter	PyId___aiter__	variable	_Py_IDENTIFIER(__aiter__)
-Python/ceval.c	import_all_from	PyId___all__	variable	_Py_IDENTIFIER(__all__)
-Objects/typeobject.c	slot_am_anext	PyId___anext__	variable	_Py_IDENTIFIER(__anext__)
-Python/Python-ast.c	-	PyId_annotation	variable	_Py_IDENTIFIER(annotation)
-Python/ceval.c	_PyEval_EvalFrameDefault	PyId___annotations__	variable	_Py_IDENTIFIER(__annotations__)
-Python/Python-ast.c	-	PyId_arg	variable	_Py_IDENTIFIER(arg)
-Python/Python-ast.c	-	PyId_args	variable	_Py_IDENTIFIER(args)
-Python/Python-ast.c	-	PyId_argtypes	variable	_Py_IDENTIFIER(argtypes)
-Python/Python-ast.c	-	PyId_asname	variable	_Py_IDENTIFIER(asname)
-Python/Python-ast.c	make_type	PyId__ast	variable	_Py_IDENTIFIER(_ast)
-Python/Python-ast.c	-	PyId_attr	variable	_Py_IDENTIFIER(attr)
-Python/Python-ast.c	-	PyId__attributes	variable	_Py_IDENTIFIER(_attributes)
-Objects/typeobject.c	slot_am_await	PyId___await__	variable	_Py_IDENTIFIER(__await__)
-Python/Python-ast.c	-	PyId_bases	variable	_Py_IDENTIFIER(bases)
-Modules/_abc.c	-	PyId___bases__	variable	_Py_IDENTIFIER(__bases__)
-Objects/abstract.c	abstract_get_bases	PyId___bases__	variable	_Py_IDENTIFIER(__bases__)
-Objects/typeobject.c	merge_class_dict	PyId___bases__	variable	_Py_IDENTIFIER(__bases__)
-Objects/longobject.c	-	PyId_big	variable	_Py_IDENTIFIER(big)
-Modules/_io/_iomodule.c	_io_open_impl	PyId__blksize	variable	_Py_IDENTIFIER(_blksize)
-Python/Python-ast.c	-	PyId_body	variable	_Py_IDENTIFIER(body)
-Objects/typeobject.c	slot_nb_bool	PyId___bool__	variable	_Py_IDENTIFIER(__bool__)
-Python/sysmodule.c	-	PyId_buffer	variable	_Py_IDENTIFIER(buffer)
-Python/ceval.c	_PyEval_EvalFrameDefault	PyId___build_class__	variable	_Py_IDENTIFIER(__build_class__)
-Objects/typeobject.c	-	PyId_builtins	variable	_Py_IDENTIFIER(builtins)
-Python/errors.c	-	PyId_builtins	variable	_Py_IDENTIFIER(builtins)
-Python/pythonrun.c	-	PyId_builtins	variable	_Py_IDENTIFIER(builtins)
-Python/sysmodule.c	-	PyId_builtins	variable	_Py_IDENTIFIER(builtins)
-Objects/frameobject.c	-	PyId___builtins__	variable	_Py_IDENTIFIER(__builtins__)
-Python/bltinmodule.c	-	PyId___builtins__	variable	_Py_IDENTIFIER(__builtins__)
-Python/import.c	module_dict_for_exec	PyId___builtins__	variable	_Py_IDENTIFIER(__builtins__)
-Objects/object.c	-	PyId___bytes__	variable	_Py_IDENTIFIER(__bytes__)
-Objects/bytesobject.c	format_obj	PyId___bytes__	variable	_Py_IDENTIFIER(__bytes__)
-Objects/bytesobject.c	bytes_new	PyId___bytes__	variable	_Py_IDENTIFIER(__bytes__)
-Objects/weakrefobject.c	proxy_bytes	PyId___bytes__	variable	_Py_IDENTIFIER(__bytes__)
-Objects/typeobject.c	slot_tp_call	PyId___call__	variable	_Py_IDENTIFIER(__call__)
-Python/Python-ast.c	-	PyId_cause	variable	_Py_IDENTIFIER(cause)
-Objects/typeobject.c	-	PyId___class__	variable	_Py_IDENTIFIER(__class__)
-Modules/_abc.c	-	PyId___class__	variable	_Py_IDENTIFIER(__class__)
-Python/compile.c	compiler_enter_scope	PyId___class__	variable	_Py_IDENTIFIER(__class__)
-Objects/abstract.c	recursive_isinstance	PyId___class__	variable	_Py_IDENTIFIER(__class__)
-Objects/typeobject.c	type_new	PyId___classcell__	variable	_Py_IDENTIFIER(__classcell__)
-Objects/typeobject.c	-	PyId___class_getitem__	variable	_Py_IDENTIFIER(__class_getitem__)
-Objects/abstract.c	PyObject_GetItem	PyId___class_getitem__	variable	_Py_IDENTIFIER(__class_getitem__)
-Python/import.c	PyImport_Cleanup	PyId_clear	variable	_Py_IDENTIFIER(clear)
-Python/traceback.c	-	PyId_close	variable	_Py_IDENTIFIER(close)
-Modules/_io/bufferedio.c	-	PyId_close	variable	_Py_IDENTIFIER(close)
-Modules/_io/textio.c	-	PyId_close	variable	_Py_IDENTIFIER(close)
-Objects/genobject.c	gen_close_iter	PyId_close	variable	_Py_IDENTIFIER(close)
-Modules/_dbmmodule.c	dbm__exit__	PyId_close	variable	_Py_IDENTIFIER(close)
-Modules/_gdbmmodule.c	dbm__exit__	PyId_close	variable	_Py_IDENTIFIER(close)
-Python/pythonrun.c	_Py_HandleSystemExit	PyId_code	variable	_Py_IDENTIFIER(code)
-Python/Python-ast.c	-	PyId_col_offset	variable	_Py_IDENTIFIER(col_offset)
-Python/Python-ast.c	-	PyId_comparators	variable	_Py_IDENTIFIER(comparators)
-Objects/complexobject.c	try_complex_special_method	PyId___complex__	variable	_Py_IDENTIFIER(__complex__)
-Objects/typeobject.c	slot_sq_contains	PyId___contains__	variable	_Py_IDENTIFIER(__contains__)
-Python/Python-ast.c	-	PyId_context_expr	variable	_Py_IDENTIFIER(context_expr)
-Python/Python-ast.c	-	PyId_conversion	variable	_Py_IDENTIFIER(conversion)
-Modules/itertoolsmodule.c	itertools_tee_impl	PyId___copy__	variable	_Py_IDENTIFIER(__copy__)
-Objects/descrobject.c	mappingproxy_copy	PyId_copy	variable	_Py_IDENTIFIER(copy)
-Objects/typeobject.c	import_copyreg	PyId_copyreg	variable	_Py_IDENTIFIER(copyreg)
-Python/Python-ast.c	-	PyId_ctx	variable	_Py_IDENTIFIER(ctx)
-Modules/_io/bufferedio.c	-	PyId__dealloc_warn	variable	_Py_IDENTIFIER(_dealloc_warn)
-Modules/_io/textio.c	-	PyId__dealloc_warn	variable	_Py_IDENTIFIER(_dealloc_warn)
-Modules/_io/textio.c	-	PyId_decode	variable	_Py_IDENTIFIER(decode)
-Python/Python-ast.c	-	PyId_decorator_list	variable	_Py_IDENTIFIER(decorator_list)
-Python/_warnings.c	get_default_action	PyId_defaultaction	variable	_Py_IDENTIFIER(defaultaction)
-Python/Python-ast.c	-	PyId_defaults	variable	_Py_IDENTIFIER(defaults)
-Objects/typeobject.c	slot_tp_finalize	PyId___del__	variable	_Py_IDENTIFIER(__del__)
-Objects/typeobject.c	slot_tp_setattro	PyId___delattr__	variable	_Py_IDENTIFIER(__delattr__)
-Objects/typeobject.c	slot_tp_descr_set	PyId___delete__	variable	_Py_IDENTIFIER(__delete__)
-Objects/typeobject.c	-	PyId___delitem__	variable	_Py_IDENTIFIER(__delitem__)
-Objects/typeobject.c	-	PyId___dict__	variable	_Py_IDENTIFIER(__dict__)
-Modules/_abc.c	-	PyId___dict__	variable	_Py_IDENTIFIER(__dict__)
-Python/bltinmodule.c	-	PyId___dict__	variable	_Py_IDENTIFIER(__dict__)
-Python/Python-ast.c	ast_type_reduce	PyId___dict__	variable	_Py_IDENTIFIER(__dict__)
-Python/ceval.c	import_all_from	PyId___dict__	variable	_Py_IDENTIFIER(__dict__)
-Objects/bytearrayobject.c	_common_reduce	PyId___dict__	variable	_Py_IDENTIFIER(__dict__)
-Objects/moduleobject.c	module_dir	PyId___dict__	variable	_Py_IDENTIFIER(__dict__)
-Objects/odictobject.c	odict_reduce	PyId___dict__	variable	_Py_IDENTIFIER(__dict__)
-Objects/setobject.c	set_reduce	PyId___dict__	variable	_Py_IDENTIFIER(__dict__)
-Modules/_collectionsmodule.c	deque_reduce	PyId___dict__	variable	_Py_IDENTIFIER(__dict__)
-Objects/dictobject.c	dictviews_sub	PyId_difference_update	variable	_Py_IDENTIFIER(difference_update)
-Python/Python-ast.c	-	PyId_dims	variable	_Py_IDENTIFIER(dims)
-Objects/object.c	-	PyId___dir__	variable	_Py_IDENTIFIER(__dir__)
-Objects/moduleobject.c	module_dir	PyId___dir__	variable	_Py_IDENTIFIER(__dir__)
-Python/ceval.c	_PyEval_EvalFrameDefault	PyId_displayhook	variable	_Py_IDENTIFIER(displayhook)
-Objects/typeobject.c	-	PyId___doc__	variable	_Py_IDENTIFIER(__doc__)
-Objects/descrobject.c	property_init_impl	PyId___doc__	variable	_Py_IDENTIFIER(__doc__)
-Objects/moduleobject.c	module_init_dict	PyId___doc__	variable	_Py_IDENTIFIER(__doc__)
-Objects/moduleobject.c	PyModule_SetDocString	PyId___doc__	variable	_Py_IDENTIFIER(__doc__)
-Python/Python-ast.c	-	PyId_elt	variable	_Py_IDENTIFIER(elt)
-Python/Python-ast.c	-	PyId_elts	variable	_Py_IDENTIFIER(elts)
-Modules/faulthandler.c	-	PyId_enable	variable	_Py_IDENTIFIER(enable)
-Python/sysmodule.c	-	PyId_encoding	variable	_Py_IDENTIFIER(encoding)
-Python/bltinmodule.c	-	PyId_encoding	variable	_Py_IDENTIFIER(encoding)
-Python/pythonrun.c	PyRun_InteractiveOneObjectEx	PyId_encoding	variable	_Py_IDENTIFIER(encoding)
-Python/Python-ast.c	-	PyId_end_col_offset	variable	_Py_IDENTIFIER(end_col_offset)
-Python/Python-ast.c	-	PyId_end_lineno	variable	_Py_IDENTIFIER(end_lineno)
-Python/ceval.c	_PyEval_EvalFrameDefault	PyId___enter__	variable	_Py_IDENTIFIER(__enter__)
-Objects/typeobject.c	overrides_hash	PyId___eq__	variable	_Py_IDENTIFIER(__eq__)
-Python/bltinmodule.c	-	PyId_errors	variable	_Py_IDENTIFIER(errors)
-Python/Python-ast.c	-	PyId_exc	variable	_Py_IDENTIFIER(exc)
-Python/pythonrun.c	-	PyId_excepthook	variable	_Py_IDENTIFIER(excepthook)
-Python/ceval.c	_PyEval_EvalFrameDefault	PyId___exit__	variable	_Py_IDENTIFIER(__exit__)
-Modules/_pickle.c	do_append	PyId_extend	variable	_Py_IDENTIFIER(extend)
-Python/Python-ast.c	-	PyId__fields	variable	_Py_IDENTIFIER(_fields)
-Objects/moduleobject.c	PyModule_GetFilenameObject	PyId___file__	variable	_Py_IDENTIFIER(__file__)
-Python/errors.c	PyErr_SyntaxLocationObject	PyId_filename	variable	_Py_IDENTIFIER(filename)
-Python/pythonrun.c	parse_syntax_error	PyId_filename	variable	_Py_IDENTIFIER(filename)
-Modules/_io/textio.c	-	PyId_fileno	variable	_Py_IDENTIFIER(fileno)
-Modules/faulthandler.c	-	PyId_fileno	variable	_Py_IDENTIFIER(fileno)
-Python/bltinmodule.c	-	PyId_fileno	variable	_Py_IDENTIFIER(fileno)
-Objects/fileobject.c	PyObject_AsFileDescriptor	PyId_fileno	variable	_Py_IDENTIFIER(fileno)
-Modules/itertoolsmodule.c	zip_longest_new	PyId_fillvalue	variable	_Py_IDENTIFIER(fillvalue)
-Python/_warnings.c	get_filter	PyId_filters	variable	_Py_IDENTIFIER(filters)
-Python/Python-ast.c	-	PyId_finalbody	variable	_Py_IDENTIFIER(finalbody)
-Modules/_io/iobase.c	iobase_finalize	PyId__finalizing	variable	_Py_IDENTIFIER(_finalizing)
-Python/import.c	import_find_and_load	PyId__find_and_load	variable	_Py_IDENTIFIER(_find_and_load)
-Python/import.c	PyImport_ExecCodeModuleObject	PyId__fix_up_module	variable	_Py_IDENTIFIER(_fix_up_module)
-Python/errors.c	-	PyId_flush	variable	_Py_IDENTIFIER(flush)
-Python/pylifecycle.c	-	PyId_flush	variable	_Py_IDENTIFIER(flush)
-Python/pythonrun.c	-	PyId_flush	variable	_Py_IDENTIFIER(flush)
-Modules/_threadmodule.c	-	PyId_flush	variable	_Py_IDENTIFIER(flush)
-Modules/_io/bufferedio.c	-	PyId_flush	variable	_Py_IDENTIFIER(flush)
-Modules/_io/textio.c	-	PyId_flush	variable	_Py_IDENTIFIER(flush)
-Modules/faulthandler.c	-	PyId_flush	variable	_Py_IDENTIFIER(flush)
-Python/bltinmodule.c	-	PyId_flush	variable	_Py_IDENTIFIER(flush)
-Objects/abstract.c	PyObject_Format	PyId___format__	variable	_Py_IDENTIFIER(__format__)
-Python/Python-ast.c	-	PyId_format_spec	variable	_Py_IDENTIFIER(format_spec)
-Modules/posixmodule.c	path_converter	PyId___fspath__	variable	_Py_IDENTIFIER(__fspath__)
-Modules/posixmodule.c	PyOS_FSPath	PyId___fspath__	variable	_Py_IDENTIFIER(__fspath__)
-Python/Python-ast.c	-	PyId_func	variable	_Py_IDENTIFIER(func)
-Python/Python-ast.c	-	PyId_generators	variable	_Py_IDENTIFIER(generators)
-Objects/descrobject.c	mappingproxy_get	PyId_get	variable	_Py_IDENTIFIER(get)
-Modules/_collectionsmodule.c	_count_elements	PyId_get	variable	_Py_IDENTIFIER(get)
-Objects/typeobject.c	slot_tp_descr_get	PyId___get__	variable	_Py_IDENTIFIER(__get__)
-Objects/classobject.c	method_reduce	PyId_getattr	variable	_Py_IDENTIFIER(getattr)
-Objects/descrobject.c	descr_reduce	PyId_getattr	variable	_Py_IDENTIFIER(getattr)
-Objects/descrobject.c	wrapper_reduce	PyId_getattr	variable	_Py_IDENTIFIER(getattr)
-Objects/moduleobject.c	module_getattro	PyId___getattr__	variable	_Py_IDENTIFIER(__getattr__)
-Objects/methodobject.c	meth_reduce	PyId_getattr	variable	_Py_IDENTIFIER(getattr)
-Objects/typeobject.c	slot_tp_getattr_hook	PyId___getattr__	variable	_Py_IDENTIFIER(__getattr__)
-Objects/typeobject.c	-	PyId___getattribute__	variable	_Py_IDENTIFIER(__getattribute__)
-Objects/typeobject.c	-	PyId___getitem__	variable	_Py_IDENTIFIER(__getitem__)
-Objects/typeobject.c	_PyObject_GetNewArguments	PyId___getnewargs__	variable	_Py_IDENTIFIER(__getnewargs__)
-Objects/typeobject.c	_PyObject_GetNewArguments	PyId___getnewargs_ex__	variable	_Py_IDENTIFIER(__getnewargs_ex__)
-Modules/_io/textio.c	-	PyId_getpreferredencoding	variable	_Py_IDENTIFIER(getpreferredencoding)
-Python/_warnings.c	get_source_line	PyId_get_source	variable	_Py_IDENTIFIER(get_source)
-Python/import.c	PyImport_ExecCodeModuleWithPathnames	PyId__get_sourcefile	variable	_Py_IDENTIFIER(_get_sourcefile)
-Objects/typeobject.c	_PyObject_GetState	PyId___getstate__	variable	_Py_IDENTIFIER(__getstate__)
-Python/import.c	PyImport_ImportModuleLevelObject	PyId__handle_fromlist	variable	_Py_IDENTIFIER(_handle_fromlist)
-Python/Python-ast.c	-	PyId_handlers	variable	_Py_IDENTIFIER(handlers)
-Objects/typeobject.c	-	PyId___hash__	variable	_Py_IDENTIFIER(__hash__)
-Python/Python-ast.c	-	PyId_id	variable	_Py_IDENTIFIER(id)
-Python/Python-ast.c	-	PyId_ifs	variable	_Py_IDENTIFIER(ifs)
-Python/import.c	PyImport_ReloadModule	PyId_imp	variable	_Py_IDENTIFIER(imp)
-Python/ceval.c	import_name	PyId___import__	variable	_Py_IDENTIFIER(__import__)
-Objects/typeobject.c	slot_nb_index	PyId___index__	variable	_Py_IDENTIFIER(__index__)
-Objects/typeobject.c	slot_tp_init	PyId___init__	variable	_Py_IDENTIFIER(__init__)
-Objects/moduleobject.c	_PyModuleSpec_IsInitializing	PyId__initializing	variable	_Py_IDENTIFIER(_initializing)
-Objects/typeobject.c	-	PyId___init_subclass__	variable	_Py_IDENTIFIER(__init_subclass__)
-Objects/abstract.c	PyObject_IsInstance	PyId___instancecheck__	variable	_Py_IDENTIFIER(__instancecheck__)
-Objects/dictobject.c	_PyDictView_Intersect	PyId_intersection_update	variable	_Py_IDENTIFIER(intersection_update)
-Modules/_io/iobase.c	-	PyId___IOBase_closed	variable	_Py_IDENTIFIER(__IOBase_closed)
-Objects/typeobject.c	slot_nb_inplace_power	PyId___ipow__	variable	_Py_IDENTIFIER(__ipow__)
-Objects/object.c	-	PyId___isabstractmethod__	variable	_Py_IDENTIFIER(__isabstractmethod__)
-Python/Python-ast.c	-	PyId_is_async	variable	_Py_IDENTIFIER(is_async)
-Modules/_io/bufferedio.c	-	PyId_isatty	variable	_Py_IDENTIFIER(isatty)
-Modules/_io/textio.c	-	PyId_isatty	variable	_Py_IDENTIFIER(isatty)
-Python/pylifecycle.c	create_stdio	PyId_isatty	variable	_Py_IDENTIFIER(isatty)
-Modules/_io/_iomodule.c	_io_open_impl	PyId_isatty	variable	_Py_IDENTIFIER(isatty)
-Python/codecs.c	_PyCodec_LookupTextEncoding	PyId__is_text_encoding	variable	_Py_IDENTIFIER(_is_text_encoding)
-Python/Python-ast.c	-	PyId_items	variable	_Py_IDENTIFIER(items)
-Objects/abstract.c	PyMapping_Items	PyId_items	variable	_Py_IDENTIFIER(items)
-Objects/descrobject.c	mappingproxy_items	PyId_items	variable	_Py_IDENTIFIER(items)
-Objects/odictobject.c	odict_reduce	PyId_items	variable	_Py_IDENTIFIER(items)
-Objects/odictobject.c	odict_repr	PyId_items	variable	_Py_IDENTIFIER(items)
-Objects/odictobject.c	mutablemapping_update	PyId_items	variable	_Py_IDENTIFIER(items)
-Objects/typeobject.c	_PyObject_GetItemsIter	PyId_items	variable	_Py_IDENTIFIER(items)
-Modules/_collectionsmodule.c	defdict_reduce	PyId_items	variable	_Py_IDENTIFIER(items)
-Python/Python-ast.c	-	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/bytearrayobject.c	bytearrayiter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/bytesobject.c	striter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/dictobject.c	dictiter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/iterobject.c	iter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/iterobject.c	calliter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/listobject.c	listiter_reduce_general	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/odictobject.c	odictiter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/rangeobject.c	rangeiter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/rangeobject.c	longrangeiter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/setobject.c	setiter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/tupleobject.c	tupleiter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/unicodeobject.c	unicodeiter_reduce	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Objects/typeobject.c	slot_tp_iter	PyId___iter__	variable	_Py_IDENTIFIER(__iter__)
-Modules/arraymodule.c	array_arrayiterator___reduce___impl	PyId_iter	variable	_Py_IDENTIFIER(iter)
-Python/Python-ast.c	-	PyId_key	variable	_Py_IDENTIFIER(key)
-Python/Python-ast.c	-	PyId_keys	variable	_Py_IDENTIFIER(keys)
-Objects/abstract.c	PyMapping_Keys	PyId_keys	variable	_Py_IDENTIFIER(keys)
-Objects/descrobject.c	mappingproxy_keys	PyId_keys	variable	_Py_IDENTIFIER(keys)
-Objects/dictobject.c	dict_update_common	PyId_keys	variable	_Py_IDENTIFIER(keys)
-Objects/odictobject.c	mutablemapping_update	PyId_keys	variable	_Py_IDENTIFIER(keys)
-Python/Python-ast.c	-	PyId_keywords	variable	_Py_IDENTIFIER(keywords)
-Python/Python-ast.c	-	PyId_kind	variable	_Py_IDENTIFIER(kind)
-Python/Python-ast.c	-	PyId_kwarg	variable	_Py_IDENTIFIER(kwarg)
-Python/Python-ast.c	-	PyId_kw_defaults	variable	_Py_IDENTIFIER(kw_defaults)
-Python/Python-ast.c	-	PyId_kwonlyargs	variable	_Py_IDENTIFIER(kwonlyargs)
-Python/pythonrun.c	-	PyId_last_traceback	variable	_Py_IDENTIFIER(last_traceback)
-Python/pythonrun.c	-	PyId_last_type	variable	_Py_IDENTIFIER(last_type)
-Python/pythonrun.c	-	PyId_last_value	variable	_Py_IDENTIFIER(last_value)
-Python/Python-ast.c	-	PyId_left	variable	_Py_IDENTIFIER(left)
-Objects/typeobject.c	-	PyId___len__	variable	_Py_IDENTIFIER(__len__)
-Objects/abstract.c	PyObject_LengthHint	PyId___length_hint__	variable	_Py_IDENTIFIER(__length_hint__)
-Python/Python-ast.c	-	PyId_level	variable	_Py_IDENTIFIER(level)
-Python/Python-ast.c	-	PyId_lineno	variable	_Py_IDENTIFIER(lineno)
-Python/errors.c	PyErr_SyntaxLocationObject	PyId_lineno	variable	_Py_IDENTIFIER(lineno)
-Python/pythonrun.c	parse_syntax_error	PyId_lineno	variable	_Py_IDENTIFIER(lineno)
-Objects/longobject.c	-	PyId_little	variable	_Py_IDENTIFIER(little)
-Python/_warnings.c	get_source_line	PyId___loader__	variable	_Py_IDENTIFIER(__loader__)
-Objects/moduleobject.c	module_init_dict	PyId___loader__	variable	_Py_IDENTIFIER(__loader__)
-Python/import.c	PyImport_ImportModuleLevelObject	PyId__lock_unlock_module	variable	_Py_IDENTIFIER(_lock_unlock_module)
-Python/Python-ast.c	-	PyId_lower	variable	_Py_IDENTIFIER(lower)
-Python/ceval.c	_PyEval_EvalFrameDefault	PyId___ltrace__	variable	_Py_IDENTIFIER(__ltrace__)
-Python/pythonrun.c	PyRun_InteractiveOneObjectEx	PyId___main__	variable	_Py_IDENTIFIER(__main__)
-Python/_warnings.c	check_matched	PyId_match	variable	_Py_IDENTIFIER(match)
-Python/bltinmodule.c	-	PyId_metaclass	variable	_Py_IDENTIFIER(metaclass)
-Objects/dictobject.c	dict_subscript	PyId___missing__	variable	_Py_IDENTIFIER(__missing__)
-Modules/_io/bufferedio.c	-	PyId_mode	variable	_Py_IDENTIFIER(mode)
-Modules/_io/textio.c	-	PyId_mode	variable	_Py_IDENTIFIER(mode)
-Python/pylifecycle.c	create_stdio	PyId_mode	variable	_Py_IDENTIFIER(mode)
-Modules/_io/_iomodule.c	_io_open_impl	PyId_mode	variable	_Py_IDENTIFIER(mode)
-Python/Python-ast.c	-	PyId_module	variable	_Py_IDENTIFIER(module)
-Objects/typeobject.c	-	PyId___module__	variable	_Py_IDENTIFIER(__module__)
-Python/Python-ast.c	make_type	PyId___module__	variable	_Py_IDENTIFIER(__module__)
-Python/errors.c	PyErr_NewException	PyId___module__	variable	_Py_IDENTIFIER(__module__)
-Python/errors.c	PyErr_NewException	PyId___module__	variable	_Py_IDENTIFIER(__module__)
-Python/pythonrun.c	print_exception	PyId___module__	variable	_Py_IDENTIFIER(__module__)
-Modules/_pickle.c	whichmodule	PyId___module__	variable	_Py_IDENTIFIER(__module__)
-Objects/typeobject.c	type_mro_modified	PyId_mro	variable	_Py_IDENTIFIER(mro)
-Objects/typeobject.c	mro_invoke	PyId_mro	variable	_Py_IDENTIFIER(mro)
-Python/bltinmodule.c	-	PyId___mro_entries__	variable	_Py_IDENTIFIER(__mro_entries__)
-Objects/typeobject.c	type_new	PyId___mro_entries__	variable	_Py_IDENTIFIER(__mro_entries__)
-Python/Python-ast.c	-	PyId_msg	variable	_Py_IDENTIFIER(msg)
-Python/errors.c	PyErr_SyntaxLocationObject	PyId_msg	variable	_Py_IDENTIFIER(msg)
-Python/pythonrun.c	parse_syntax_error	PyId_msg	variable	_Py_IDENTIFIER(msg)
-Python/pylifecycle.c	-	PyId_name	variable	_Py_IDENTIFIER(name)
-Modules/_io/fileio.c	-	PyId_name	variable	_Py_IDENTIFIER(name)
-Modules/_io/bufferedio.c	-	PyId_name	variable	_Py_IDENTIFIER(name)
-Modules/_io/textio.c	-	PyId_name	variable	_Py_IDENTIFIER(name)
-Python/Python-ast.c	-	PyId_name	variable	_Py_IDENTIFIER(name)
-Objects/exceptions.c	ImportError_getstate	PyId_name	variable	_Py_IDENTIFIER(name)
-Objects/typeobject.c	-	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Objects/classobject.c	-	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Python/_warnings.c	setup_context	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Python/_warnings.c	get_source_line	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Python/_warnings.c	show_warning	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Python/ceval.c	import_from	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Python/ceval.c	import_all_from	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Python/import.c	resolve_name	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Objects/moduleobject.c	module_init_dict	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Objects/moduleobject.c	PyModule_GetNameObject	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Objects/moduleobject.c	module_getattro	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Objects/weakrefobject.c	weakref_repr	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Modules/_pickle.c	save_global	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Modules/_pickle.c	save_reduce	PyId___name__	variable	_Py_IDENTIFIER(__name__)
-Python/Python-ast.c	-	PyId_names	variable	_Py_IDENTIFIER(names)
-Objects/typeobject.c	-	PyId___new__	variable	_Py_IDENTIFIER(__new__)
-Objects/typeobject.c	reduce_newobj	PyId___newobj__	variable	_Py_IDENTIFIER(__newobj__)
-Objects/typeobject.c	reduce_newobj	PyId___newobj_ex__	variable	_Py_IDENTIFIER(__newobj_ex__)
-Objects/typeobject.c	slot_tp_iternext	PyId___next__	variable	_Py_IDENTIFIER(__next__)
-Objects/structseq.c	-	PyId_n_fields	variable	_Py_IDENTIFIER(n_fields)
-Python/ast.c	new_identifier	PyId_NFKC	variable	_Py_IDENTIFIER(NFKC)
-Objects/structseq.c	-	PyId_n_sequence_fields	variable	_Py_IDENTIFIER(n_sequence_fields)
-Objects/structseq.c	-	PyId_n_unnamed_fields	variable	_Py_IDENTIFIER(n_unnamed_fields)
-Python/errors.c	PyErr_SyntaxLocationObject	PyId_offset	variable	_Py_IDENTIFIER(offset)
-Python/pythonrun.c	parse_syntax_error	PyId_offset	variable	_Py_IDENTIFIER(offset)
-Python/_warnings.c	get_once_registry	PyId_onceregistry	variable	_Py_IDENTIFIER(onceregistry)
-Python/Python-ast.c	-	PyId_op	variable	_Py_IDENTIFIER(op)
-Python/traceback.c	-	PyId_open	variable	_Py_IDENTIFIER(open)
-Python/pylifecycle.c	create_stdio	PyId_open	variable	_Py_IDENTIFIER(open)
-Parser/tokenizer.c	fp_setreadl	PyId_open	variable	_Py_IDENTIFIER(open)
-Objects/fileobject.c	PyFile_FromFd	PyId_open	variable	_Py_IDENTIFIER(open)
-Objects/fileobject.c	PyFile_OpenCodeObject	PyId_open	variable	_Py_IDENTIFIER(open)
-Python/Python-ast.c	-	PyId_operand	variable	_Py_IDENTIFIER(operand)
-Python/Python-ast.c	-	PyId_ops	variable	_Py_IDENTIFIER(ops)
-Python/Python-ast.c	-	PyId_optional_vars	variable	_Py_IDENTIFIER(optional_vars)
-Python/Python-ast.c	-	PyId_orelse	variable	_Py_IDENTIFIER(orelse)
-Python/import.c	resolve_name	PyId___package__	variable	_Py_IDENTIFIER(__package__)
-Objects/moduleobject.c	module_init_dict	PyId___package__	variable	_Py_IDENTIFIER(__package__)
-Python/import.c	resolve_name	PyId_parent	variable	_Py_IDENTIFIER(parent)
-Modules/_operator.c	methodcaller_reduce	PyId_partial	variable	_Py_IDENTIFIER(partial)
-Python/sysmodule.c	-	PyId_path	variable	_Py_IDENTIFIER(path)
-Python/traceback.c	-	PyId_path	variable	_Py_IDENTIFIER(path)
-Objects/exceptions.c	ImportError_getstate	PyId_path	variable	_Py_IDENTIFIER(path)
-Modules/main.c	pymain_sys_path_add_path0	PyId_path	variable	_Py_IDENTIFIER(path)
-Python/import.c	resolve_name	PyId___path__	variable	_Py_IDENTIFIER(__path__)
-Python/import.c	PyImport_ImportModuleLevelObject	PyId___path__	variable	_Py_IDENTIFIER(__path__)
-Modules/_io/bufferedio.c	-	PyId_peek	variable	_Py_IDENTIFIER(peek)
-Python/Python-ast.c	-	PyId_posonlyargs	variable	_Py_IDENTIFIER(posonlyargs)
-Objects/typeobject.c	slot_nb_power	PyId___pow__	variable	_Py_IDENTIFIER(__pow__)
-Python/bltinmodule.c	-	PyId___prepare__	variable	_Py_IDENTIFIER(__prepare__)
-Python/errors.c	PyErr_SyntaxLocationObject	PyId_print_file_and_line	variable	_Py_IDENTIFIER(print_file_and_line)
-Python/pythonrun.c	print_exception	PyId_print_file_and_line	variable	_Py_IDENTIFIER(print_file_and_line)
-Python/pythonrun.c	-	PyId_ps1	variable	_Py_IDENTIFIER(ps1)
-Python/pythonrun.c	-	PyId_ps2	variable	_Py_IDENTIFIER(ps2)
-Objects/object.c	-	PyId_Py_Repr	variable	_Py_IDENTIFIER(Py_Repr)
-Objects/classobject.c	-	PyId___qualname__	variable	_Py_IDENTIFIER(__qualname__)
-Objects/descrobject.c	calculate_qualname	PyId___qualname__	variable	_Py_IDENTIFIER(__qualname__)
-Objects/methodobject.c	meth_get__qualname__	PyId___qualname__	variable	_Py_IDENTIFIER(__qualname__)
-Objects/typeobject.c	type_new	PyId___qualname__	variable	_Py_IDENTIFIER(__qualname__)
-Modules/_io/textio.c	-	PyId_raw	variable	_Py_IDENTIFIER(raw)
-Python/pylifecycle.c	create_stdio	PyId_raw	variable	_Py_IDENTIFIER(raw)
-Modules/_io/iobase.c	-	PyId_read	variable	_Py_IDENTIFIER(read)
-Modules/_io/bufferedio.c	-	PyId_read	variable	_Py_IDENTIFIER(read)
-Modules/_io/textio.c	-	PyId_read	variable	_Py_IDENTIFIER(read)
-Modules/_io/bufferedio.c	-	PyId_read1	variable	_Py_IDENTIFIER(read1)
-Python/marshal.c	marshal_load	PyId_read	variable	_Py_IDENTIFIER(read)
-Modules/_io/bufferedio.c	-	PyId_readable	variable	_Py_IDENTIFIER(readable)
-Modules/_io/textio.c	-	PyId_readable	variable	_Py_IDENTIFIER(readable)
-Modules/_io/iobase.c	_io__RawIOBase_read_impl	PyId_readall	variable	_Py_IDENTIFIER(readall)
-Modules/_io/bufferedio.c	-	PyId_readinto	variable	_Py_IDENTIFIER(readinto)
-Modules/_io/bufferedio.c	-	PyId_readinto1	variable	_Py_IDENTIFIER(readinto1)
-Python/marshal.c	r_string	PyId_readinto	variable	_Py_IDENTIFIER(readinto)
-Parser/tokenizer.c	fp_setreadl	PyId_readline	variable	_Py_IDENTIFIER(readline)
-Objects/fileobject.c	PyFile_GetLine	PyId_readline	variable	_Py_IDENTIFIER(readline)
-Objects/typeobject.c	object___reduce_ex___impl	PyId___reduce__	variable	_Py_IDENTIFIER(__reduce__)
-Python/import.c	PyImport_ReloadModule	PyId_reload	variable	_Py_IDENTIFIER(reload)
-Modules/_io/textio.c	-	PyId_replace	variable	_Py_IDENTIFIER(replace)
-Python/importdl.c	get_encoded_name	PyId_replace	variable	_Py_IDENTIFIER(replace)
-Objects/typeobject.c	slot_tp_repr	PyId___repr__	variable	_Py_IDENTIFIER(__repr__)
-Modules/_io/textio.c	-	PyId_reset	variable	_Py_IDENTIFIER(reset)
-Python/Python-ast.c	-	PyId_returns	variable	_Py_IDENTIFIER(returns)
-Objects/enumobject.c	reversed_new_impl	PyId___reversed__	variable	_Py_IDENTIFIER(__reversed__)
-Objects/listobject.c	listiter_reduce_general	PyId_reversed	variable	_Py_IDENTIFIER(reversed)
-Python/Python-ast.c	-	PyId_right	variable	_Py_IDENTIFIER(right)
-Python/bltinmodule.c	-	PyId___round__	variable	_Py_IDENTIFIER(__round__)
-Modules/_io/textio.c	-	PyId_seek	variable	_Py_IDENTIFIER(seek)
-Modules/_io/iobase.c	_io__IOBase_tell_impl	PyId_seek	variable	_Py_IDENTIFIER(seek)
-Modules/_io/textio.c	-	PyId_seekable	variable	_Py_IDENTIFIER(seekable)
-Python/ceval.c	_PyEval_EvalFrameDefault	PyId_send	variable	_Py_IDENTIFIER(send)
-Objects/typeobject.c	slot_tp_descr_set	PyId___set__	variable	_Py_IDENTIFIER(__set__)
-Objects/typeobject.c	slot_tp_setattro	PyId___setattr__	variable	_Py_IDENTIFIER(__setattr__)
-Objects/typeobject.c	-	PyId___setitem__	variable	_Py_IDENTIFIER(__setitem__)
-Modules/_collectionsmodule.c	_count_elements	PyId___setitem__	variable	_Py_IDENTIFIER(__setitem__)
-Objects/typeobject.c	-	PyId___set_name__	variable	_Py_IDENTIFIER(__set_name__)
-Modules/_io/textio.c	-	PyId_setstate	variable	_Py_IDENTIFIER(setstate)
-Modules/_pickle.c	load_build	PyId___setstate__	variable	_Py_IDENTIFIER(__setstate__)
-Python/_warnings.c	call_show_warning	PyId__showwarnmsg	variable	_Py_IDENTIFIER(_showwarnmsg)
-Python/pylifecycle.c	wait_for_thread_shutdown	PyId__shutdown	variable	_Py_IDENTIFIER(_shutdown)
-Python/Python-ast.c	-	PyId_simple	variable	_Py_IDENTIFIER(simple)
-Python/sysmodule.c	-	PyId___sizeof__	variable	_Py_IDENTIFIER(__sizeof__)
-Python/Python-ast.c	-	PyId_slice	variable	_Py_IDENTIFIER(slice)
-Objects/typeobject.c	_PyType_GetSlotNames	PyId___slotnames__	variable	_Py_IDENTIFIER(__slotnames__)
-Objects/typeobject.c	_PyType_GetSlotNames	PyId__slotnames	variable	_Py_IDENTIFIER(_slotnames)
-Objects/typeobject.c	type_new	PyId___slots__	variable	_Py_IDENTIFIER(__slots__)
-Python/bltinmodule.c	-	PyId_sort	variable	_Py_IDENTIFIER(sort)
-Python/import.c	resolve_name	PyId___spec__	variable	_Py_IDENTIFIER(__spec__)
-Python/import.c	PyImport_ImportModuleLevelObject	PyId___spec__	variable	_Py_IDENTIFIER(__spec__)
-Objects/moduleobject.c	module_init_dict	PyId___spec__	variable	_Py_IDENTIFIER(__spec__)
-Objects/moduleobject.c	module_getattro	PyId___spec__	variable	_Py_IDENTIFIER(__spec__)
-Python/_warnings.c	-	PyId_stderr	variable	_Py_IDENTIFIER(stderr)
-Python/errors.c	-	PyId_stderr	variable	_Py_IDENTIFIER(stderr)
-Python/pylifecycle.c	-	PyId_stderr	variable	_Py_IDENTIFIER(stderr)
-Python/pythonrun.c	-	PyId_stderr	variable	_Py_IDENTIFIER(stderr)
-Python/sysmodule.c	-	PyId_stderr	variable	_Py_IDENTIFIER(stderr)
-Modules/_threadmodule.c	-	PyId_stderr	variable	_Py_IDENTIFIER(stderr)
-Modules/faulthandler.c	-	PyId_stderr	variable	_Py_IDENTIFIER(stderr)
-Python/bltinmodule.c	-	PyId_stderr	variable	_Py_IDENTIFIER(stderr)
-Python/pylifecycle.c	-	PyId_stdin	variable	_Py_IDENTIFIER(stdin)
-Python/pythonrun.c	-	PyId_stdin	variable	_Py_IDENTIFIER(stdin)
-Python/bltinmodule.c	-	PyId_stdin	variable	_Py_IDENTIFIER(stdin)
-Python/pylifecycle.c	-	PyId_stdout	variable	_Py_IDENTIFIER(stdout)
-Python/pythonrun.c	-	PyId_stdout	variable	_Py_IDENTIFIER(stdout)
-Python/sysmodule.c	-	PyId_stdout	variable	_Py_IDENTIFIER(stdout)
-Python/bltinmodule.c	-	PyId_stdout	variable	_Py_IDENTIFIER(stdout)
-Python/Python-ast.c	-	PyId_step	variable	_Py_IDENTIFIER(step)
-Modules/posixmodule.c	DirEntry_test_mode	PyId_st_mode	variable	_Py_IDENTIFIER(st_mode)
-Modules/_io/textio.c	-	PyId_strict	variable	_Py_IDENTIFIER(strict)
-Python/pythonrun.c	-	PyId_string	variable	_Py_static_string(PyId_string, ""<string>"")
-Modules/timemodule.c	time_strptime	PyId__strptime_time	variable	_Py_IDENTIFIER(_strptime_time)
-Modules/posixmodule.c	wait_helper	PyId_struct_rusage	variable	_Py_IDENTIFIER(struct_rusage)
-Modules/_abc.c	-	PyId___subclasscheck__	variable	_Py_IDENTIFIER(__subclasscheck__)
-Objects/abstract.c	PyObject_IsSubclass	PyId___subclasscheck__	variable	_Py_IDENTIFIER(__subclasscheck__)
-Modules/_abc.c	-	PyId___subclasshook__	variable	_Py_IDENTIFIER(__subclasshook__)
-Objects/dictobject.c	dictviews_xor	PyId_symmetric_difference_update	variable	_Py_IDENTIFIER(symmetric_difference_update)
-Python/Python-ast.c	-	PyId_tag	variable	_Py_IDENTIFIER(tag)
-Python/Python-ast.c	-	PyId_target	variable	_Py_IDENTIFIER(target)
-Python/Python-ast.c	-	PyId_targets	variable	_Py_IDENTIFIER(targets)
-Modules/_io/textio.c	-	PyId_tell	variable	_Py_IDENTIFIER(tell)
-Python/Python-ast.c	-	PyId_test	variable	_Py_IDENTIFIER(test)
-Python/errors.c	PyErr_SyntaxLocationObject	PyId_text	variable	_Py_IDENTIFIER(text)
-Python/pythonrun.c	parse_syntax_error	PyId_text	variable	_Py_IDENTIFIER(text)
-Python/traceback.c	-	PyId_TextIOWrapper	variable	_Py_IDENTIFIER(TextIOWrapper)
-Python/pylifecycle.c	create_stdio	PyId_TextIOWrapper	variable	_Py_IDENTIFIER(TextIOWrapper)
-Python/pylifecycle.c	-	PyId_threading	variable	_Py_IDENTIFIER(threading)
-Objects/genobject.c	_gen_throw	PyId_throw	variable	_Py_IDENTIFIER(throw)
-Objects/abstract.c	PyNumber_Long	PyId___trunc__	variable	_Py_IDENTIFIER(__trunc__)
-Python/Python-ast.c	-	PyId_type	variable	_Py_IDENTIFIER(type)
-Python/Python-ast.c	-	PyId_type_comment	variable	_Py_IDENTIFIER(type_comment)
-Python/Python-ast.c	-	PyId_type_ignores	variable	_Py_IDENTIFIER(type_ignores)
-Python/errors.c	_PyErr_WriteUnraisableMsg	PyId_unraisablehook	variable	_Py_IDENTIFIER(unraisablehook)
-Objects/dictobject.c	dictviews_or	PyId_update	variable	_Py_IDENTIFIER(update)
-Python/Python-ast.c	-	PyId_upper	variable	_Py_IDENTIFIER(upper)
-Python/Python-ast.c	-	PyId_value	variable	_Py_IDENTIFIER(value)
-Python/Python-ast.c	-	PyId_values	variable	_Py_IDENTIFIER(values)
-Objects/abstract.c	PyMapping_Values	PyId_values	variable	_Py_IDENTIFIER(values)
-Objects/descrobject.c	mappingproxy_values	PyId_values	variable	_Py_IDENTIFIER(values)
-Python/Python-ast.c	-	PyId_vararg	variable	_Py_IDENTIFIER(vararg)
-Python/_warnings.c	already_warned	PyId_version	variable	_Py_IDENTIFIER(version)
-Python/_warnings.c	call_show_warning	PyId_WarningMessage	variable	_Py_IDENTIFIER(WarningMessage)
-Python/_warnings.c	setup_context	PyId___warningregistry__	variable	_Py_IDENTIFIER(__warningregistry__)
-Python/_warnings.c	get_warnings_attr	PyId_warnings	variable	_Py_IDENTIFIER(warnings)
-Python/sysmodule.c	-	PyId_warnoptions	variable	_Py_IDENTIFIER(warnoptions)
-Python/_warnings.c	_PyErr_WarnUnawaitedCoroutine	PyId__warn_unawaited_coroutine	variable	_Py_IDENTIFIER(_warn_unawaited_coroutine)
-Modules/_io/bufferedio.c	-	PyId_writable	variable	_Py_IDENTIFIER(writable)
-Modules/_io/textio.c	-	PyId_writable	variable	_Py_IDENTIFIER(writable)
-Python/sysmodule.c	-	PyId_write	variable	_Py_IDENTIFIER(write)
-Modules/_io/bufferedio.c	-	PyId_write	variable	_Py_IDENTIFIER(write)
-Python/marshal.c	marshal_dump_impl	PyId_write	variable	_Py_IDENTIFIER(write)
-Objects/fileobject.c	PyFile_WriteObject	PyId_write	variable	_Py_IDENTIFIER(write)
-Python/sysmodule.c	-	PyId__xoptions	variable	_Py_IDENTIFIER(_xoptions)
-Python/import.c	_PyImportZip_Init	PyId_zipimporter	variable	_Py_IDENTIFIER(zipimporter)
-Python/initconfig.c	-	Py_IgnoreEnvironmentFlag	variable	int Py_IgnoreEnvironmentFlag
-Python/dynload_shlib.c	-	_PyImport_DynLoadFiletab	variable	const char *_PyImport_DynLoadFiletab[]
-Python/frozen.c	-	PyImport_FrozenModules	variable	const struct _frozen * PyImport_FrozenModules
-Modules/config.c	-	_PyImport_Inittab	variable	struct _inittab _PyImport_Inittab[]
-Python/import.c	-	PyImport_Inittab	variable	struct _inittab * PyImport_Inittab
-Modules/_io/textio.c	-	PyIncrementalNewlineDecoder_Type	variable	PyTypeObject PyIncrementalNewlineDecoder_Type
-Python/initconfig.c	-	Py_InspectFlag	variable	int Py_InspectFlag
-Objects/classobject.c	-	PyInstanceMethod_Type	variable	PyTypeObject PyInstanceMethod_Type
-Python/initconfig.c	-	Py_InteractiveFlag	variable	int Py_InteractiveFlag
-Objects/interpreteridobject.c	-	_PyInterpreterID_Type	variable	PyTypeObject _PyInterpreterID_Type
-Modules/_io/iobase.c	-	PyIOBase_Type	variable	PyTypeObject PyIOBase_Type
-Modules/_io/_iomodule.c	-	_PyIO_empty_bytes	variable	PyObject *_PyIO_empty_bytes
-Modules/_io/_iomodule.c	-	_PyIO_empty_str	variable	PyObject *_PyIO_empty_str
-Modules/_io/_iomodule.c	-	_PyIO_Module	variable	struct PyModuleDef _PyIO_Module
-Modules/_io/_iomodule.c	-	_PyIO_str_close	variable	PyObject *_PyIO_str_close
-Modules/_io/_iomodule.c	-	_PyIO_str_closed	variable	PyObject *_PyIO_str_closed
-Modules/_io/_iomodule.c	-	_PyIO_str_decode	variable	PyObject *_PyIO_str_decode
-Modules/_io/_iomodule.c	-	_PyIO_str_encode	variable	PyObject *_PyIO_str_encode
-Modules/_io/_iomodule.c	-	_PyIO_str_fileno	variable	PyObject *_PyIO_str_fileno
-Modules/_io/_iomodule.c	-	_PyIO_str_flush	variable	PyObject *_PyIO_str_flush
-Modules/_io/_iomodule.c	-	_PyIO_str_getstate	variable	PyObject *_PyIO_str_getstate
-Modules/_io/_iomodule.c	-	_PyIO_str_isatty	variable	PyObject *_PyIO_str_isatty
-Modules/_io/_iomodule.c	-	_PyIO_str_newlines	variable	PyObject *_PyIO_str_newlines
-Modules/_io/_iomodule.c	-	_PyIO_str_nl	variable	PyObject *_PyIO_str_nl
-Modules/_io/_iomodule.c	-	_PyIO_str_peek	variable	PyObject *_PyIO_str_peek
-Modules/_io/_iomodule.c	-	_PyIO_str_read	variable	PyObject *_PyIO_str_read
-Modules/_io/_iomodule.c	-	_PyIO_str_read1	variable	PyObject *_PyIO_str_read1
-Modules/_io/_iomodule.c	-	_PyIO_str_readable	variable	PyObject *_PyIO_str_readable
-Modules/_io/_iomodule.c	-	_PyIO_str_readall	variable	PyObject *_PyIO_str_readall
-Modules/_io/_iomodule.c	-	_PyIO_str_readinto	variable	PyObject *_PyIO_str_readinto
-Modules/_io/_iomodule.c	-	_PyIO_str_readline	variable	PyObject *_PyIO_str_readline
-Modules/_io/_iomodule.c	-	_PyIO_str_reset	variable	PyObject *_PyIO_str_reset
-Modules/_io/_iomodule.c	-	_PyIO_str_seek	variable	PyObject *_PyIO_str_seek
-Modules/_io/_iomodule.c	-	_PyIO_str_seekable	variable	PyObject *_PyIO_str_seekable
-Modules/_io/_iomodule.c	-	_PyIO_str_setstate	variable	PyObject *_PyIO_str_setstate
-Modules/_io/_iomodule.c	-	_PyIO_str_tell	variable	PyObject *_PyIO_str_tell
-Modules/_io/_iomodule.c	-	_PyIO_str_truncate	variable	PyObject *_PyIO_str_truncate
-Modules/_io/_iomodule.c	-	_PyIO_str_writable	variable	PyObject *_PyIO_str_writable
-Modules/_io/_iomodule.c	-	_PyIO_str_write	variable	PyObject *_PyIO_str_write
-Python/initconfig.c	-	Py_IsolatedFlag	variable	int Py_IsolatedFlag
-Objects/listobject.c	-	PyListIter_Type	variable	PyTypeObject PyListIter_Type
-Objects/listobject.c	-	PyListRevIter_Type	variable	PyTypeObject PyListRevIter_Type
-Objects/listobject.c	-	PyList_Type	variable	PyTypeObject PyList_Type
-Modules/_localemodule.c	-	PyLocale_Methods	variable	static struct PyMethodDef PyLocale_Methods[]
-Objects/longobject.c	-	_PyLong_DigitValue	variable	unsigned char _PyLong_DigitValue[256]
-Objects/longobject.c	-	_PyLong_One	variable	PyObject *_PyLong_One
-Objects/rangeobject.c	-	PyLongRangeIter_Type	variable	PyTypeObject PyLongRangeIter_Type
-Objects/longobject.c	-	PyLong_Type	variable	PyTypeObject PyLong_Type
-Objects/longobject.c	-	_PyLong_Zero	variable	PyObject *_PyLong_Zero
-Objects/memoryobject.c	-	_PyManagedBuffer_Type	variable	PyTypeObject _PyManagedBuffer_Type
-Python/bltinmodule.c	-	PyMap_Type	variable	PyTypeObject PyMap_Type
-Objects/obmalloc.c	-	_PyMem	variable	static PyMemAllocatorEx _PyMem
-Objects/descrobject.c	-	PyMemberDescr_Type	variable	PyTypeObject PyMemberDescr_Type
-Objects/obmalloc.c	-	_PyMem_Debug	variable	static struct { debug_alloc_api_t raw; debug_alloc_api_t mem; debug_alloc_api_t obj; } _PyMem_Debug
-Objects/memoryobject.c	-	PyMemoryView_Type	variable	PyTypeObject PyMemoryView_Type
-Objects/obmalloc.c	-	_PyMem_Raw	variable	static PyMemAllocatorEx _PyMem_Raw
-Objects/descrobject.c	-	PyMethodDescr_Type	variable	PyTypeObject PyMethodDescr_Type
-Objects/classobject.c	-	PyMethod_Type	variable	PyTypeObject PyMethod_Type
-Objects/descrobject.c	-	_PyMethodWrapper_Type	variable	PyTypeObject _PyMethodWrapper_Type
-Objects/moduleobject.c	-	PyModuleDef_Type	variable	PyTypeObject PyModuleDef_Type
-Objects/moduleobject.c	-	PyModule_Type	variable	PyTypeObject PyModule_Type
-Objects/namespaceobject.c	-	_PyNamespace_Type	variable	PyTypeObject _PyNamespace_Type
-Objects/object.c	-	_Py_NoneStruct	variable	PyObject _Py_NoneStruct
-Objects/object.c	-	_PyNone_Type	variable	PyTypeObject _PyNone_Type
-Python/initconfig.c	-	Py_NoSiteFlag	variable	int Py_NoSiteFlag
-Objects/object.c	-	_Py_NotImplementedStruct	variable	PyObject _Py_NotImplementedStruct
-Objects/object.c	-	_PyNotImplemented_Type	variable	PyTypeObject _PyNotImplemented_Type
-Python/initconfig.c	-	Py_NoUserSiteDirectory	variable	int Py_NoUserSiteDirectory
-Objects/bytesobject.c	-	_Py_null_strings	variable	Py_ssize_t _Py_null_strings
-Objects/obmalloc.c	-	_PyObject	variable	static PyMemAllocatorEx _PyObject
-Objects/obmalloc.c	-	_PyObject_Arena	variable	static PyObjectArenaAllocator _PyObject_Arena
-Objects/odictobject.c	-	PyODictItems_Type	variable	PyTypeObject PyODictItems_Type
-Objects/odictobject.c	-	PyODictIter_Type	variable	PyTypeObject PyODictIter_Type
-Objects/odictobject.c	-	PyODictKeys_Type	variable	PyTypeObject PyODictKeys_Type
-Objects/odictobject.c	-	PyODict_Type	variable	PyTypeObject PyODict_Type
-Objects/odictobject.c	-	PyODictValues_Type	variable	PyTypeObject PyODictValues_Type
-Python/fileutils.c	-	_Py_open_cloexec_works	variable	int _Py_open_cloexec_works
-Objects/bytesobject.c	-	_Py_one_strings	variable	Py_ssize_t _Py_one_strings
-Python/initconfig.c	-	Py_OptimizeFlag	variable	int Py_OptimizeFlag
-Parser/myreadline.c	-	PyOS_InputHook	variable	int (*PyOS_InputHook)(void)
-Python/pylifecycle.c	-	_PyOS_mystrnicmp_hack	variable	int (*_PyOS_mystrnicmp_hack)(const char *, const char *, Py_ssize_t)
-Python/getopt.c	-	_PyOS_optarg	variable	const wchar_t *_PyOS_optarg
-Python/getopt.c	-	_PyOS_opterr	variable	int _PyOS_opterr
-Python/getopt.c	-	_PyOS_optind	variable	Py_ssize_t _PyOS_optind
-Parser/myreadline.c	-	PyOS_ReadlineFunctionPointer	variable	char *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *)
-Parser/myreadline.c	-	_PyOS_ReadlineLock	variable	static PyThread_type_lock _PyOS_ReadlineLock
-Parser/myreadline.c	-	_PyOS_ReadlineTState	variable	PyThreadState* _PyOS_ReadlineTState
-Python/modsupport.c	-	_Py_PackageContext	variable	const char *_Py_PackageContext
-Python/graminit.c	-	_PyParser_Grammar	variable	grammar _PyParser_Grammar
-Python/pathconfig.c	-	_Py_path_config	variable	_PyPathConfig _Py_path_config
-Objects/picklebufobject.c	-	PyPickleBuffer_Type	variable	PyTypeObject PyPickleBuffer_Type
-Objects/descrobject.c	-	PyProperty_Type	variable	PyTypeObject PyProperty_Type
-Python/initconfig.c	-	Py_QuietFlag	variable	int Py_QuietFlag
-Objects.longobject.c	-	_Py_quick_int_allocs	variable	Py_ssize_t _Py_quick_int_allocs
-Objects.longobject.c	-	_Py_quick_new_int_allocs	variable	Py_ssize_t _Py_quick_new_int_allocs
-Objects/rangeobject.c	-	PyRangeIter_Type	variable	PyTypeObject PyRangeIter_Type
-Objects/rangeobject.c	-	PyRange_Type	variable	PyTypeObject PyRange_Type
-Modules/_io/iobase.c	-	PyRawIOBase_Type	variable	PyTypeObject PyRawIOBase_Type
-Objects/object.c	-	_Py_RefTotal	variable	Py_ssize_t _Py_RefTotal
-Objects/enumobject.c	-	PyReversed_Type	variable	PyTypeObject PyReversed_Type
-Python/pylifecycle.c	-	_PyRuntime	variable	_PyRuntimeState _PyRuntime
-Objects/iterobject.c	-	PySeqIter_Type	variable	PyTypeObject PySeqIter_Type
-Objects/setobject.c	-	_PySet_Dummy	variable	PyObject * _PySet_Dummy
-Objects/setobject.c	-	_PySetDummy_Type	variable	static PyTypeObject _PySetDummy_Type
-Objects/setobject.c	-	PySetIter_Type	variable	PyTypeObject PySetIter_Type
-Objects/setobject.c	-	PySet_Type	variable	PyTypeObject PySet_Type
-Objects/sliceobject.c	-	PySlice_Type	variable	PyTypeObject PySlice_Type
-Python/initconfig.c	-	_Py_StandardStreamEncoding	variable	static char *_Py_StandardStreamEncoding
-Python/initconfig.c	-	_Py_StandardStreamErrors	variable	static char *_Py_StandardStreamErrors
-Objects/funcobject.c	-	PyStaticMethod_Type	variable	PyTypeObject PyStaticMethod_Type
-Objects/fileobject.c	-	PyStdPrinter_Type	variable	PyTypeObject PyStdPrinter_Type
-Python/symtable.c	-	PySTEntry_Type	variable	PyTypeObject PySTEntry_Type
-Modules/_io/stringio.c	-	PyStringIO_Type	variable	PyTypeObject PyStringIO_Type
-Objects/structseq.c	-	PyStructSequence_UnnamedField	variable	char *PyStructSequence_UnnamedField
-Objects/typeobject.c	-	PySuper_Type	variable	PyTypeObject PySuper_Type
-Objects/object.c	-	_Py_SwappedOp	variable	int _Py_SwappedOp[]
-Python/sysmodule.c	-	_PySys_ImplCacheTag	variable	const char *_PySys_ImplCacheTag
-Python/sysmodule.c	-	_PySys_ImplName	variable	const char *_PySys_ImplName
-Modules/_io/textio.c	-	PyTextIOBase_Type	variable	PyTypeObject PyTextIOBase_Type
-Modules/_io/textio.c	-	PyTextIOWrapper_Type	variable	PyTypeObject PyTextIOWrapper_Type
-Python/traceback.c	-	PyTraceBack_Type	variable	PyTypeObject PyTraceBack_Type
-Objects/obmalloc.c	-	_Py_tracemalloc_config	variable	struct _PyTraceMalloc_Config _Py_tracemalloc_config
-Objects/boolobject.c	-	_Py_TrueStruct	variable	static struct _longobject _Py_TrueStruct
-Objects/tupleobject.c	-	PyTupleIter_Type	variable	PyTypeObject PyTupleIter_Type
-Objects/tupleobject.c	-	PyTuple_Type	variable	PyTypeObject PyTuple_Type
-Objects/tupleobject.c	-	_Py_tuple_zero_allocs	variable	Py_ssize_t _Py_tuple_zero_allocs
-Objects/typeobject.c	-	PyType_Type	variable	PyTypeObject PyType_Type
-Python/initconfig.c	-	Py_UnbufferedStdioFlag	variable	int Py_UnbufferedStdioFlag
-Python/pylifecycle.c	-	_Py_UnhandledKeyboardInterrupt	variable	int _Py_UnhandledKeyboardInterrupt
-Objects/unicodeobject.c	-	PyUnicodeIter_Type	variable	PyTypeObject PyUnicodeIter_Type
-Objects/unicodeobject.c	-	PyUnicode_Type	variable	PyTypeObject PyUnicode_Type
-Python/initconfig.c	-	Py_UTF8Mode	variable	int Py_UTF8Mode
-Python/initconfig.c	-	Py_VerboseFlag	variable	int Py_VerboseFlag
-Objects/weakrefobject.c	-	_PyWeakref_CallableProxyType	variable	PyTypeObject _PyWeakref_CallableProxyType
-Objects/weakrefobject.c	-	_PyWeakref_ProxyType	variable	PyTypeObject _PyWeakref_ProxyType
-Objects/weakrefobject.c	-	_PyWeakref_RefType	variable	PyTypeObject _PyWeakref_RefType
-Objects/weakrefobject.c	-	_PyWeakref_RefType	variable	PyTypeObject _PyWeakref_RefType
-Objects/descrobject.c	-	PyWrapperDescr_Type	variable	PyTypeObject PyWrapperDescr_Type
-Python/bltinmodule.c	-	PyZip_Type	variable	PyTypeObject PyZip_Type
-Python/Python-ast.c	-	Raise_fields	variable	static const char *Raise_fields[]
-Python/Python-ast.c	-	Raise_type	variable	static PyTypeObject *Raise_type
-Objects/rangeobject.c	-	range_as_mapping	variable	static PyMappingMethods range_as_mapping
-Objects/rangeobject.c	-	range_as_number	variable	static PyNumberMethods range_as_number
-Objects/rangeobject.c	-	range_as_sequence	variable	static PySequenceMethods range_as_sequence
-Objects/rangeobject.c	-	rangeiter_methods	variable	static PyMethodDef rangeiter_methods
-Objects/rangeobject.c	-	range_members	variable	static PyMemberDef range_members[]
-Objects/rangeobject.c	-	range_methods	variable	static PyMethodDef range_methods
-Modules/_io/iobase.c	-	rawiobase_methods	variable	static PyMethodDef rawiobase_methods
-Python/pylifecycle.c	fatal_error	reentrant	variable	static int reentrant
-Modules/faulthandler.c	faulthandler_dump_traceback	reentrant	variable	static volatile int reentrant
-Modules/itertoolsmodule.c	-	repeat_methods	variable	static PyMethodDef repeat_methods
-Modules/itertoolsmodule.c	-	repeat_type	variable	static PyTypeObject repeat_type
-Python/Python-ast.c	-	Return_fields	variable	static const char *Return_fields[]
-Python/compile.c	compiler_visit_annotations	return_str	variable	static identifier return_str
-Python/Python-ast.c	-	Return_type	variable	static PyTypeObject *Return_type
-Objects/enumobject.c	-	reversediter_methods	variable	static PyMethodDef reversediter_methods
-Modules/_threadmodule.c	-	rlock_methods	variable	static PyMethodDef rlock_methods
-Modules/_threadmodule.c	-	RLocktype	variable	static PyTypeObject RLocktype
-Objects/typeobject.c	slot_nb_add	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_subtract	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_multiply	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_matrix_multiply	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_remainder	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_divmod	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_power_binary	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_lshift	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_rshift	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_and	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_xor	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_or	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_floor_divide	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Objects/typeobject.c	slot_nb_true_divide	rop_id	variable	_Py_static_string(op_id, OPSTR)
-Python/Python-ast.c	-	RShift_singleton	variable	static PyObject *RShift_singleton
-Python/Python-ast.c	-	RShift_type	variable	static PyTypeObject *RShift_type
-Python/pylifecycle.c	-	runtime_initialized	variable	static int runtime_initialized
-Modules/posixmodule.c	-	ScandirIterator_methods	variable	static PyMethodDef ScandirIterator_methods
-Modules/posixmodule.c	-	ScandirIteratorType	variable	static PyTypeObject ScandirIteratorType
-Modules/_sre.c	-	scanner_members	variable	static PyMemberDef scanner_members[]
-Modules/_sre.c	-	scanner_methods	variable	static PyMethodDef scanner_methods
-Modules/_sre.c	-	Scanner_Type	variable	static PyTypeObject Scanner_Type
-Modules/posixmodule.c	-	sched_param_desc	variable	static PyStructSequence_Desc sched_param_desc
-Modules/posixmodule.c	-	sched_param_fields	variable	static PyStructSequence_Field sched_param_fields[]
-Modules/posixmodule.c	-	SchedParamType	variable	static PyTypeObject* SchedParamType
-Objects/iterobject.c	-	seqiter_methods	variable	static PyMethodDef seqiter_methods
-Objects/setobject.c	-	set_as_number	variable	static PyNumberMethods set_as_number
-Objects/setobject.c	-	set_as_sequence	variable	static PySequenceMethods set_as_sequence
-Python/symtable.c	-	setcomp	variable	static identifier setcomp
-Python/Python-ast.c	-	SetComp_fields	variable	static const char *SetComp_fields[]
-Python/Python-ast.c	-	SetComp_type	variable	static PyTypeObject *SetComp_type
-Python/Python-ast.c	-	Set_fields	variable	static const char *Set_fields[]
-Objects/setobject.c	-	setiter_methods	variable	static PyMethodDef setiter_methods
-Objects/setobject.c	-	set_methods	variable	static PyMethodDef set_methods
-Python/Python-ast.c	-	Set_type	variable	static PyTypeObject *Set_type
-Modules/signalmodule.c	-	SiginfoType	variable	static PyTypeObject SiginfoType
-Modules/signalmodule.c	-	signal_methods	variable	static PyMethodDef signal_methods
-Modules/signalmodule.c	-	signalmodule	variable	static struct PyModuleDef signalmodule
-Python/import.c	PyImport_Import	silly_list	variable	static PyObject *silly_list
-Objects/sliceobject.c	-	slice_cache	variable	static PySliceObject *slice_cache
-Python/Python-ast.c	-	Slice_fields	variable	static const char *Slice_fields[]
-Objects/sliceobject.c	-	slice_members	variable	static PyMemberDef slice_members[]
-Objects/sliceobject.c	-	slice_methods	variable	static PyMethodDef slice_methods
-Python/Python-ast.c	-	slice_type	variable	static PyTypeObject *slice_type
-Python/Python-ast.c	-	Slice_type	variable	static PyTypeObject *Slice_type
-Objects/typeobject.c	-	slotdefs	variable	static slotdef slotdefs[]
-Objects/typeobject.c	-	slotdefs_initialized	variable	static int slotdefs_initialized
-Objects/longobject.c	-	small_ints	variable	static PyLongObject small_ints[NSMALLNEGINTS + NSMALLPOSINTS]
-Objects/funcobject.c	-	sm_getsetlist	variable	static PyGetSetDef sm_getsetlist[]
-Objects/funcobject.c	-	sm_memberlist	variable	static PyMemberDef sm_memberlist[]
-Modules/xxsubtype.c	-	spamdict_members	variable	static PyMemberDef spamdict_members[]
-Modules/xxsubtype.c	-	spamdict_methods	variable	static PyMethodDef spamdict_methods
-Modules/xxsubtype.c	-	spamdict_type	variable	static PyTypeObject spamdict_type
-Modules/xxsubtype.c	-	spamlist_getsets	variable	static PyGetSetDef spamlist_getsets[]
-Modules/xxsubtype.c	-	spamlist_methods	variable	static PyMethodDef spamlist_methods
-Modules/xxsubtype.c	-	spamlist_type	variable	static PyTypeObject spamlist_type
-Modules/_sre.c	-	sremodule	variable	static struct PyModuleDef sremodule
-Modules/faulthandler.c	-	stack	variable	static stack_t stack
-Modules/itertoolsmodule.c	-	starmap_methods	variable	static PyMethodDef starmap_methods
-Modules/itertoolsmodule.c	-	starmap_type	variable	static PyTypeObject starmap_type
-Python/Python-ast.c	-	Starred_fields	variable	static const char *Starred_fields[]
-Python/Python-ast.c	-	Starred_type	variable	static PyTypeObject *Starred_type
-Python/graminit.c	-	states_0	variable	static state states_0[3]
-Python/graminit.c	-	states_1	variable	static state states_1[2]
-Python/graminit.c	-	states_10	variable	static state states_10[4]
-Python/graminit.c	-	states_11	variable	static state states_11[34]
-Python/graminit.c	-	states_12	variable	static state states_12[2]
-Python/graminit.c	-	states_13	variable	static state states_13[2]
-Python/graminit.c	-	states_14	variable	static state states_14[4]
-Python/graminit.c	-	states_15	variable	static state states_15[2]
-Python/graminit.c	-	states_16	variable	static state states_16[6]
-Python/graminit.c	-	states_17	variable	static state states_17[5]
-Python/graminit.c	-	states_18	variable	static state states_18[3]
-Python/graminit.c	-	states_19	variable	static state states_19[2]
-Python/graminit.c	-	states_2	variable	static state states_2[3]
-Python/graminit.c	-	states_20	variable	static state states_20[3]
-Python/graminit.c	-	states_21	variable	static state states_21[2]
-Python/graminit.c	-	states_22	variable	static state states_22[2]
-Python/graminit.c	-	states_23	variable	static state states_23[2]
-Python/graminit.c	-	states_24	variable	static state states_24[2]
-Python/graminit.c	-	states_25	variable	static state states_25[3]
-Python/graminit.c	-	states_26	variable	static state states_26[2]
-Python/graminit.c	-	states_27	variable	static state states_27[5]
-Python/graminit.c	-	states_28	variable	static state states_28[2]
-Python/graminit.c	-	states_29	variable	static state states_29[3]
-Python/graminit.c	-	states_3	variable	static state states_3[7]
-Python/graminit.c	-	states_30	variable	static state states_30[8]
-Python/graminit.c	-	states_31	variable	static state states_31[4]
-Python/graminit.c	-	states_32	variable	static state states_32[4]
-Python/graminit.c	-	states_33	variable	static state states_33[3]
-Python/graminit.c	-	states_34	variable	static state states_34[2]
-Python/graminit.c	-	states_35	variable	static state states_35[2]
-Python/graminit.c	-	states_36	variable	static state states_36[3]
-Python/graminit.c	-	states_37	variable	static state states_37[3]
-Python/graminit.c	-	states_38	variable	static state states_38[5]
-Python/graminit.c	-	states_39	variable	static state states_39[2]
-Python/graminit.c	-	states_4	variable	static state states_4[2]
-Python/graminit.c	-	states_40	variable	static state states_40[3]
-Python/graminit.c	-	states_41	variable	static state states_41[8]
-Python/graminit.c	-	states_42	variable	static state states_42[8]
-Python/graminit.c	-	states_43	variable	static state states_43[11]
-Python/graminit.c	-	states_44	variable	static state states_44[13]
-Python/graminit.c	-	states_45	variable	static state states_45[6]
-Python/graminit.c	-	states_46	variable	static state states_46[4]
-Python/graminit.c	-	states_47	variable	static state states_47[5]
-Python/graminit.c	-	states_48	variable	static state states_48[5]
-Python/graminit.c	-	states_49	variable	static state states_49[4]
-Python/graminit.c	-	states_5	variable	static state states_5[3]
-Python/graminit.c	-	states_50	variable	static state states_50[6]
-Python/graminit.c	-	states_51	variable	static state states_51[2]
-Python/graminit.c	-	states_52	variable	static state states_52[5]
-Python/graminit.c	-	states_53	variable	static state states_53[5]
-Python/graminit.c	-	states_54	variable	static state states_54[2]
-Python/graminit.c	-	states_55	variable	static state states_55[2]
-Python/graminit.c	-	states_56	variable	static state states_56[3]
-Python/graminit.c	-	states_57	variable	static state states_57[2]
-Python/graminit.c	-	states_58	variable	static state states_58[4]
-Python/graminit.c	-	states_59	variable	static state states_59[3]
-Python/graminit.c	-	states_6	variable	static state states_6[3]
-Python/graminit.c	-	states_60	variable	static state states_60[2]
-Python/graminit.c	-	states_61	variable	static state states_61[2]
-Python/graminit.c	-	states_62	variable	static state states_62[2]
-Python/graminit.c	-	states_63	variable	static state states_63[2]
-Python/graminit.c	-	states_64	variable	static state states_64[2]
-Python/graminit.c	-	states_65	variable	static state states_65[2]
-Python/graminit.c	-	states_66	variable	static state states_66[3]
-Python/graminit.c	-	states_67	variable	static state states_67[4]
-Python/graminit.c	-	states_68	variable	static state states_68[3]
-Python/graminit.c	-	states_69	variable	static state states_69[9]
-Python/graminit.c	-	states_7	variable	static state states_7[9]
-Python/graminit.c	-	states_70	variable	static state states_70[5]
-Python/graminit.c	-	states_71	variable	static state states_71[7]
-Python/graminit.c	-	states_72	variable	static state states_72[3]
-Python/graminit.c	-	states_73	variable	static state states_73[5]
-Python/graminit.c	-	states_74	variable	static state states_74[3]
-Python/graminit.c	-	states_75	variable	static state states_75[3]
-Python/graminit.c	-	states_76	variable	static state states_76[3]
-Python/graminit.c	-	states_77	variable	static state states_77[14]
-Python/graminit.c	-	states_78	variable	static state states_78[8]
-Python/graminit.c	-	states_79	variable	static state states_79[3]
-Python/graminit.c	-	states_8	variable	static state states_8[4]
-Python/graminit.c	-	states_80	variable	static state states_80[4]
-Python/graminit.c	-	states_81	variable	static state states_81[2]
-Python/graminit.c	-	states_82	variable	static state states_82[6]
-Python/graminit.c	-	states_83	variable	static state states_83[3]
-Python/graminit.c	-	states_84	variable	static state states_84[4]
-Python/graminit.c	-	states_85	variable	static state states_85[2]
-Python/graminit.c	-	states_86	variable	static state states_86[3]
-Python/graminit.c	-	states_87	variable	static state states_87[3]
-Python/graminit.c	-	states_88	variable	static state states_88[7]
-Python/graminit.c	-	states_89	variable	static state states_89[3]
-Python/graminit.c	-	states_9	variable	static state states_9[42]
-Python/graminit.c	-	states_90	variable	static state states_90[6]
-Python/graminit.c	-	states_91	variable	static state states_91[11]
-Python/getargs.c	-	static_arg_parsers	variable	static struct _PyArg_Parser *static_arg_parsers
-Objects/unicodeobject.c	-	static_strings	variable	static _Py_Identifier *static_strings
-Modules/_stat.c	-	stat_methods	variable	static PyMethodDef stat_methods
-Modules/_stat.c	-	statmodule	variable	static struct PyModuleDef statmodule
-Modules/posixmodule.c	-	stat_result_desc	variable	static PyStructSequence_Desc stat_result_desc
-Modules/posixmodule.c	-	stat_result_fields	variable	static PyStructSequence_Field stat_result_fields[]
-Modules/posixmodule.c	-	StatResultType	variable	static PyTypeObject* StatResultType
-Modules/posixmodule.c	-	statvfs_result_desc	variable	static PyStructSequence_Desc statvfs_result_desc
-Modules/posixmodule.c	-	statvfs_result_fields	variable	static PyStructSequence_Field statvfs_result_fields[]
-Modules/posixmodule.c	-	StatVFSResultType	variable	static PyTypeObject* StatVFSResultType
-Objects/fileobject.c	-	stdprinter_getsetlist	variable	static PyGetSetDef stdprinter_getsetlist[]
-Objects/fileobject.c	-	stdprinter_methods	variable	static PyMethodDef stdprinter_methods
-Python/symtable.c	-	ste_memberlist	variable	static PyMemberDef ste_memberlist[]
-Python/Python-ast.c	-	stmt_attributes	variable	static const char *stmt_attributes[]
-Python/Python-ast.c	-	stmt_type	variable	static PyTypeObject *stmt_type
-Objects/exceptions.c	-	StopIteration_members	variable	static PyMemberDef StopIteration_members[]
-Python/Python-ast.c	-	Store_singleton	variable	static PyObject *Store_singleton
-Python/Python-ast.c	-	Store_type	variable	static PyTypeObject *Store_type
-Python/ast_unparse.c	-	_str_close_br	variable	static PyObject *_str_close_br
-Python/ast_unparse.c	-	_str_dbl_close_br	variable	static PyObject *_str_dbl_close_br
-Python/ast_unparse.c	-	_str_dbl_open_br	variable	static PyObject *_str_dbl_open_br
-Modules/_threadmodule.c	-	str_dict	variable	static PyObject *str_dict
-Modules/_io/stringio.c	-	stringio_getset	variable	static PyGetSetDef stringio_getset[]
-Modules/_io/stringio.c	-	stringio_methods	variable	static PyMethodDef stringio_methods
-Objects/unicodeobject.c	-	_string_methods	variable	static PyMethodDef _string_methods
-Objects/unicodeobject.c	-	_string_module	variable	static struct PyModuleDef _string_module
-Objects/bytesobject.c	-	striter_methods	variable	static PyMethodDef striter_methods
-Python/ast_unparse.c	-	_str_open_br	variable	static PyObject *_str_open_br
-Modules/pwdmodule.c	-	StructPwdType	variable	static PyTypeObject StructPwdType
-Modules/pwdmodule.c	-	struct_pwd_type_desc	variable	static PyStructSequence_Desc struct_pwd_type_desc
-Modules/pwdmodule.c	-	struct_pwd_type_fields	variable	static PyStructSequence_Field struct_pwd_type_fields[]
-Modules/posixmodule.c	wait_helper	struct_rusage	variable	static PyObject *struct_rusage
-Objects/structseq.c	-	structseq_methods	variable	static PyMethodDef structseq_methods
-Modules/posixmodule.c	-	structseq_new	variable	static newfunc structseq_new
-Modules/signalmodule.c	-	struct_siginfo_desc	variable	static PyStructSequence_Desc struct_siginfo_desc
-Modules/signalmodule.c	-	struct_siginfo_fields	variable	static PyStructSequence_Field struct_siginfo_fields[]
-Modules/timemodule.c	-	StructTimeType	variable	static PyTypeObject StructTimeType
-Modules/timemodule.c	-	struct_time_type_desc	variable	static PyStructSequence_Desc struct_time_type_desc
-Modules/timemodule.c	-	struct_time_type_fields	variable	static PyStructSequence_Field struct_time_type_fields[]
-Python/Python-ast.c	-	Subscript_fields	variable	static const char *Subscript_fields[]
-Python/Python-ast.c	-	Subscript_type	variable	static PyTypeObject *Subscript_type
-Python/Python-ast.c	-	Sub_singleton	variable	static PyObject *Sub_singleton
-Python/Python-ast.c	-	Sub_type	variable	static PyTypeObject *Sub_type
-Objects/typeobject.c	-	subtype_getsets_dict_only	variable	static PyGetSetDef subtype_getsets_dict_only[]
-Objects/typeobject.c	-	subtype_getsets_full	variable	static PyGetSetDef subtype_getsets_full[]
-Objects/typeobject.c	-	subtype_getsets_weakref_only	variable	static PyGetSetDef subtype_getsets_weakref_only[]
-Python/Python-ast.c	-	Suite_fields	variable	static const char *Suite_fields[]
-Python/Python-ast.c	-	Suite_type	variable	static PyTypeObject *Suite_type
-Objects/typeobject.c	-	super_members	variable	static PyMemberDef super_members[]
-Modules/symtablemodule.c	-	symtable_methods	variable	static PyMethodDef symtable_methods
-Modules/symtablemodule.c	-	symtablemodule	variable	static struct PyModuleDef symtablemodule
-Objects/exceptions.c	-	SyntaxError_members	variable	static PyMemberDef SyntaxError_members[]
-Python/sysmodule.c	-	sys_methods	variable	static PyMethodDef sys_methods
-Python/sysmodule.c	-	sysmodule	variable	static struct PyModuleDef sysmodule
-Objects/exceptions.c	-	SystemExit_members	variable	static PyMemberDef SystemExit_members[]
-Modules/_tracemalloc.c	-	tables_lock	variable	static PyThread_type_lock tables_lock
-Modules/itertoolsmodule.c	-	takewhile_reduce_methods	variable	static PyMethodDef takewhile_reduce_methods
-Modules/itertoolsmodule.c	-	takewhile_type	variable	static PyTypeObject takewhile_type
-Python/pylifecycle.c	-	_TARGET_LOCALES	variable	static _LocaleCoercionTarget _TARGET_LOCALES[]
-Python/traceback.c	-	tb_getsetters	variable	static PyGetSetDef tb_getsetters[]
-Python/traceback.c	-	tb_memberlist	variable	static PyMemberDef tb_memberlist[]
-Python/traceback.c	-	tb_methods	variable	static PyMethodDef tb_methods
-Modules/itertoolsmodule.c	-	teedataobject_methods	variable	static PyMethodDef teedataobject_methods
-Modules/itertoolsmodule.c	-	teedataobject_type	variable	static PyTypeObject teedataobject_type
-Modules/itertoolsmodule.c	-	tee_methods	variable	static PyMethodDef tee_methods
-Modules/itertoolsmodule.c	-	tee_type	variable	static PyTypeObject tee_type
-Modules/posixmodule.c	-	TerminalSize_desc	variable	static PyStructSequence_Desc TerminalSize_desc
-Modules/posixmodule.c	-	TerminalSize_fields	variable	static PyStructSequence_Field TerminalSize_fields[]
-Modules/posixmodule.c	-	TerminalSizeType	variable	static PyTypeObject* TerminalSizeType
-Modules/_io/textio.c	-	textiobase_getset	variable	static PyGetSetDef textiobase_getset[]
-Modules/_io/textio.c	-	textiobase_methods	variable	static PyMethodDef textiobase_methods
-Modules/_io/textio.c	-	textiowrapper_getset	variable	static PyGetSetDef textiowrapper_getset[]
-Modules/_io/textio.c	-	textiowrapper_members	variable	static PyMemberDef textiowrapper_members[]
-Modules/_io/textio.c	-	textiowrapper_methods	variable	static PyMethodDef textiowrapper_methods
-Modules/faulthandler.c	-	thread	variable	static struct { PyObject *file; int fd; PY_TIMEOUT_T timeout_us; int repeat; PyInterpreterState *interp; int exit; char *header; size_t header_len; PyThread_type_lock cancel_event; PyThread_type_lock running; } thread
-Python/thread.c	-	thread_debug	variable	static int thread_debug
-Modules/_threadmodule.c	-	ThreadError	variable	static PyObject *ThreadError
-Python/thread.c	-	threadinfo_desc	variable	static PyStructSequence_Desc threadinfo_desc
-Python/thread.c	-	threadinfo_fields	variable	static PyStructSequence_Field threadinfo_fields[]
-Python/thread.c	-	ThreadInfoType	variable	static PyTypeObject ThreadInfoType
-Modules/_threadmodule.c	-	thread_methods	variable	static PyMethodDef thread_methods
-Modules/_threadmodule.c	-	threadmodule	variable	static struct PyModuleDef threadmodule
-Modules/posixmodule.c	-	ticks_per_second	variable	static long ticks_per_second
-Modules/timemodule.c	_PyTime_GetProcessTimeWithInfo	ticks_per_second	variable	static long ticks_per_second
-Modules/timemodule.c	-	time_methods	variable	static PyMethodDef time_methods
-Modules/timemodule.c	-	timemodule	variable	static struct PyModuleDef timemodule
-Modules/posixmodule.c	-	times_result_desc	variable	static PyStructSequence_Desc times_result_desc
-Modules/posixmodule.c	-	times_result_fields	variable	static PyStructSequence_Field times_result_fields[]
-Modules/posixmodule.c	-	TimesResultType	variable	static PyTypeObject* TimesResultType
-Python/context.c	-	_token_missing	variable	static PyObject *_token_missing
-Python/symtable.c	-	top	variable	static identifier top
-Objects/typeobject.c	-	tp_new_methoddef	variable	static struct PyMethodDef tp_new_methoddef[]
-Modules/_tracemalloc.c	-	tracemalloc_empty_traceback	variable	static traceback_t tracemalloc_empty_traceback
-Modules/_tracemalloc.c	-	tracemalloc_filenames	variable	static _Py_hashtable_t *tracemalloc_filenames
-Modules/_tracemalloc.c	-	tracemalloc_peak_traced_memory	variable	static size_t tracemalloc_peak_traced_memory
-Modules/_tracemalloc.c	-	tracemalloc_reentrant_key	variable	static Py_tss_t tracemalloc_reentrant_key
-Modules/_tracemalloc.c	-	tracemalloc_traceback	variable	static traceback_t *tracemalloc_traceback
-Modules/_tracemalloc.c	-	tracemalloc_tracebacks	variable	static _Py_hashtable_t *tracemalloc_tracebacks
-Modules/_tracemalloc.c	-	tracemalloc_traced_memory	variable	static size_t tracemalloc_traced_memory
-Modules/_tracemalloc.c	-	tracemalloc_traces	variable	static _Py_hashtable_t *tracemalloc_traces
-Objects/boolobject.c	-	true_str	variable	static PyObject *true_str
-Python/Python-ast.c	-	Try_fields	variable	static const char *Try_fields[]
-Python/Python-ast.c	-	Try_type	variable	static PyTypeObject *Try_type
-Objects/tupleobject.c	-	tuple_as_mapping	variable	static PyMappingMethods tuple_as_mapping
-Objects/tupleobject.c	-	tuple_as_sequence	variable	static PySequenceMethods tuple_as_sequence
-Python/Python-ast.c	-	Tuple_fields	variable	static const char *Tuple_fields[]
-Modules/_collectionsmodule.c	-	tuplegetter_members	variable	static PyMemberDef tuplegetter_members[]
-Modules/_collectionsmodule.c	-	tuplegetter_methods	variable	static PyMethodDef tuplegetter_methods
-Modules/_collectionsmodule.c	-	tuplegetter_type	variable	static PyTypeObject tuplegetter_type
-Objects/tupleobject.c	-	tupleiter_methods	variable	static PyMethodDef tupleiter_methods
-Objects/tupleobject.c	-	tuple_methods	variable	static PyMethodDef tuple_methods
-Python/Python-ast.c	-	Tuple_type	variable	static PyTypeObject *Tuple_type
-Objects/typeobject.c	-	type_getsets	variable	static PyGetSetDef type_getsets[]
-Python/Python-ast.c	-	TypeIgnore_fields	variable	static const char *TypeIgnore_fields[]
-Python/Python-ast.c	-	type_ignore_type	variable	static PyTypeObject *type_ignore_type
-Python/Python-ast.c	-	TypeIgnore_type	variable	static PyTypeObject *TypeIgnore_type
-Objects/typeobject.c	-	type_members	variable	static PyMemberDef type_members[]
-Objects/typeobject.c	-	type_methods	variable	static PyMethodDef type_methods
-Python/Python-ast.c	-	UAdd_singleton	variable	static PyObject *UAdd_singleton
-Python/Python-ast.c	-	UAdd_type	variable	static PyTypeObject *UAdd_type
-Objects/unicodeobject.c	-	ucnhash_CAPI	variable	static _PyUnicode_Name_CAPI *ucnhash_CAPI
-Python/codecs.c	-	ucnhash_CAPI	variable	static _PyUnicode_Name_CAPI *ucnhash_CAPI
-Python/ast.c	-	u_kind	variable	static PyObject *u_kind
-Modules/posixmodule.c	-	uname_result_desc	variable	static PyStructSequence_Desc uname_result_desc
-Modules/posixmodule.c	-	uname_result_fields	variable	static PyStructSequence_Field uname_result_fields[]
-Modules/posixmodule.c	-	UnameResultType	variable	static PyTypeObject* UnameResultType
-Python/Python-ast.c	-	UnaryOp_fields	variable	static const char *UnaryOp_fields[]
-Python/Python-ast.c	-	unaryop_type	variable	static PyTypeObject *unaryop_type
-Python/Python-ast.c	-	UnaryOp_type	variable	static PyTypeObject *UnaryOp_type
-Objects/unicodeobject.c	-	unicode_as_mapping	variable	static PyMappingMethods unicode_as_mapping
-Objects/unicodeobject.c	-	unicode_as_number	variable	static PyNumberMethods unicode_as_number
-Objects/unicodeobject.c	-	unicode_as_sequence	variable	static PySequenceMethods unicode_as_sequence
-Objects/unicodeobject.c	-	unicode_empty	variable	static PyObject *unicode_empty
-Objects/exceptions.c	-	UnicodeError_members	variable	static PyMemberDef UnicodeError_members[]
-Objects/unicodeobject.c	-	unicodeiter_methods	variable	static PyMethodDef unicodeiter_methods
-Objects/unicodeobject.c	-	unicode_latin1	variable	static PyObject *unicode_latin1[256]
-Objects/unicodeobject.c	-	unicode_methods	variable	static PyMethodDef unicode_methods
-Modules/_tracemalloc.c	-	unknown_filename	variable	static PyObject *unknown_filename
-Python/errors.c	-	UnraisableHookArgs_desc	variable	static PyStructSequence_Desc UnraisableHookArgs_desc
-Python/errors.c	-	UnraisableHookArgs_fields	variable	static PyStructSequence_Field UnraisableHookArgs_fields[]
-Python/errors.c	-	UnraisableHookArgsType	variable	static PyTypeObject UnraisableHookArgsType
-Objects/obmalloc.c	-	unused_arena_objects	variable	static struct arena_object* unused_arena_objects
-Python/bootstrap_hash.c	-	urandom_cache	variable	static struct { int fd; dev_t st_dev; ino_t st_ino; } urandom_cache
-Objects/obmalloc.c	-	usable_arenas	variable	static struct arena_object* usable_arenas
-Objects/obmalloc.c	-	usedpools	variable	static poolp usedpools[2 * ((NB_SMALL_SIZE_CLASSES + 7) / 8) * 8]
-Modules/faulthandler.c	-	user_signals	variable	static user_signal_t *user_signals
-Python/Python-ast.c	-	USub_singleton	variable	static PyObject *USub_singleton
-Python/Python-ast.c	-	USub_type	variable	static PyTypeObject *USub_type
-Python/getversion.c	Py_GetVersion	version	variable	static char version[250]
-Python/sysmodule.c	-	version_info_desc	variable	static PyStructSequence_Desc version_info_desc
-Python/sysmodule.c	-	version_info_fields	variable	static PyStructSequence_Field version_info_fields[]
-Python/sysmodule.c	-	VersionInfoType	variable	static PyTypeObject VersionInfoType
-Modules/posixmodule.c	-	waitid_result_desc	variable	static PyStructSequence_Desc waitid_result_desc
-Modules/posixmodule.c	-	waitid_result_fields	variable	static PyStructSequence_Field waitid_result_fields[]
-Modules/posixmodule.c	-	WaitidResultType	variable	static PyTypeObject* WaitidResultType
-Modules/signalmodule.c	-	wakeup	variable	static volatile struct { SOCKET_T fd; int warn_on_full_buffer; int use_send; } wakeup
-Python/_warnings.c	-	warnings_functions	variable	static PyMethodDef warnings_functions[]
-Python/_warnings.c	-	warningsmodule	variable	static struct PyModuleDef warningsmodule
-Modules/_weakref.c	-	weakref_functions	variable	static PyMethodDef weakref_functions
-Objects/weakrefobject.c	-	weakref_members	variable	static PyMemberDef weakref_members[]
-Modules/_weakref.c	-	weakrefmodule	variable	static struct PyModuleDef weakrefmodule
-Python/sysmodule.c	-	whatstrings	variable	static PyObject *whatstrings[8]
-Python/Python-ast.c	-	While_fields	variable	static const char *While_fields[]
-Python/Python-ast.c	-	While_type	variable	static PyTypeObject *While_type
-Python/Python-ast.c	-	With_fields	variable	static const char *With_fields[]
-Python/Python-ast.c	-	withitem_fields	variable	static const char *withitem_fields[]
-Python/Python-ast.c	-	withitem_type	variable	static PyTypeObject *withitem_type
-Python/Python-ast.c	-	With_type	variable	static PyTypeObject *With_type
-Objects/descrobject.c	-	wrapperdescr_getset	variable	static PyGetSetDef wrapperdescr_getset[]
-Objects/descrobject.c	-	wrapper_getsets	variable	static PyGetSetDef wrapper_getsets[]
-Objects/descrobject.c	-	wrapper_members	variable	static PyMemberDef wrapper_members[]
-Objects/descrobject.c	-	wrapper_methods	variable	static PyMethodDef wrapper_methods
-Modules/_threadmodule.c	local_new	wr_callback_def	variable	static PyMethodDef wr_callback_def
-Modules/xxsubtype.c	-	xxsubtype_functions	variable	static PyMethodDef xxsubtype_functions[]
-Modules/xxsubtype.c	-	xxsubtypemodule	variable	static struct PyModuleDef xxsubtypemodule
-Modules/xxsubtype.c	-	xxsubtype_slots	variable	static struct PyModuleDef_Slot xxsubtype_slots[]
-Python/Python-ast.c	-	Yield_fields	variable	static const char *Yield_fields[]
-Python/Python-ast.c	-	YieldFrom_fields	variable	static const char *YieldFrom_fields[]
-Python/Python-ast.c	-	YieldFrom_type	variable	static PyTypeObject *YieldFrom_type
-Python/Python-ast.c	-	Yield_type	variable	static PyTypeObject *Yield_type
-Modules/itertoolsmodule.c	-	zip_longest_methods	variable	static PyMethodDef zip_longest_methods
-Modules/itertoolsmodule.c	-	ziplongest_type	variable	static PyTypeObject ziplongest_type
-Python/bltinmodule.c	-	zip_methods	variable	static PyMethodDef zip_methods