bpo-36876: Add a tool that identifies unsupported global C variables. (#15877)
diff --git a/Tools/c-analyzer/README b/Tools/c-analyzer/README
new file mode 100644
index 0000000..0ee8ac3
--- /dev/null
+++ b/Tools/c-analyzer/README
@@ -0,0 +1,41 @@
+#######################################
+# C Globals and CPython Runtime State.
+
+CPython's C code makes extensive use of global variables. Each global
+falls into one of several categories:
+
+* (effectively) constants (incl. static types)
+* globals used exclusively in main or in the REPL
+* freelists, caches, and counters
+* process-global state
+* module state
+* Python runtime state
+
+The ignored-globals.txt file is organized similarly. Of the different
+categories, the last two are problematic and generally should not exist
+in the codebase.
+
+Globals that hold module state (i.e. in Modules/*.c) cause problems
+when multiple interpreters are in use. For more info, see PEP 3121,
+which addresses the situation for extension modules in general.
+
+Globals in the last category should be avoided as well. The problem
+isn't with the Python runtime having state. Rather, the problem is with
+that state being 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 check-c-globals script
+should be run to ensure that no new globals have been added:
+
+ python3 Tools/c-globals/check-c-globals.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-globals.py b/Tools/c-analyzer/c-globals.py
new file mode 100644
index 0000000..9afe059
--- /dev/null
+++ b/Tools/c-analyzer/c-globals.py
@@ -0,0 +1,9 @@
+# This is a script equivalent of running "python -m test.test_c_globals.cg".
+
+from c_globals.__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_common/__init__.py b/Tools/c-analyzer/c_analyzer_common/__init__.py
new file mode 100644
index 0000000..888b16f
--- /dev/null
+++ b/Tools/c-analyzer/c_analyzer_common/__init__.py
@@ -0,0 +1,19 @@
+import os.path
+
+
+PKG_ROOT = os.path.dirname(__file__)
+DATA_DIR = os.path.dirname(PKG_ROOT)
+REPO_ROOT = os.path.dirname(
+ os.path.dirname(DATA_DIR))
+
+SOURCE_DIRS = [os.path.join(REPO_ROOT, name) for name in [
+ 'Include',
+ 'Python',
+ 'Parser',
+ 'Objects',
+ 'Modules',
+ ]]
+
+
+# Clean up the namespace.
+del os
diff --git a/Tools/c-analyzer/c_analyzer_common/_generate.py b/Tools/c-analyzer/c_analyzer_common/_generate.py
new file mode 100644
index 0000000..1629aa6
--- /dev/null
+++ b/Tools/c-analyzer/c_analyzer_common/_generate.py
@@ -0,0 +1,328 @@
+# The code here consists of hacks for pre-populating the known.tsv file.
+
+from c_parser.preprocessor import _iter_clean_lines
+from c_parser.naive import (
+ iter_variables, parse_variable_declaration, find_variables,
+ )
+from c_parser.info import Variable
+
+from . import SOURCE_DIRS, REPO_ROOT
+from .known import DATA_FILE as KNOWN_FILE, HEADER as KNOWN_HEADER
+from .info import UNKNOWN, ID
+from .util import write_tsv
+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 ',
+ # Parser/listnode.c
+ 'level': 'static int ',
+ 'atbol': 'static int ',
+ # 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, 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)
+ 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/c_analyzer_common/files.py b/Tools/c-analyzer/c_analyzer_common/files.py
new file mode 100644
index 0000000..b3cd16c
--- /dev/null
+++ b/Tools/c-analyzer/c_analyzer_common/files.py
@@ -0,0 +1,138 @@
+import glob
+import os
+import os.path
+
+from . import SOURCE_DIRS, REPO_ROOT
+
+
+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,
+ ):
+ """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)
+
+
+def iter_cpython_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/c_analyzer_common/info.py b/Tools/c-analyzer/c_analyzer_common/info.py
new file mode 100644
index 0000000..e217380
--- /dev/null
+++ b/Tools/c-analyzer/c_analyzer_common/info.py
@@ -0,0 +1,69 @@
+from collections import namedtuple
+import re
+
+from .util import classonly, _NTBase
+
+
+UNKNOWN = '???'
+
+NAME_RE = re.compile(r'^([a-zA-Z]|_\w*[a-zA-Z]\w*|[a-zA-Z]\w*)$')
+
+
+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')
+ else:
+ if not NAME_RE.match(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.match(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
diff --git a/Tools/c-analyzer/c_analyzer_common/known.py b/Tools/c-analyzer/c_analyzer_common/known.py
new file mode 100644
index 0000000..a0c6dfa
--- /dev/null
+++ b/Tools/c-analyzer/c_analyzer_common/known.py
@@ -0,0 +1,67 @@
+import csv
+import os.path
+
+from c_parser.info import Variable
+
+from . import DATA_DIR
+from .info import ID, UNKNOWN
+from .util import read_tsv
+
+
+DATA_FILE = os.path.join(DATA_DIR, 'known.tsv')
+
+COLUMNS = ('filename', 'funcname', 'name', 'kind', 'declaration')
+HEADER = '\t'.join(COLUMNS)
+
+
+# XXX need tests:
+# * from_file()
+
+def from_file(infile, *,
+ _read_tsv=read_tsv,
+ ):
+ """Return the info for known declarations in the given file."""
+ known = {
+ 'variables': {},
+ #'types': {},
+ #'constants': {},
+ #'macros': {},
+ }
+ 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)
+ if kind == 'variable':
+ values = known['variables']
+ value = Variable(id, declaration)
+ value._isglobal = _is_global(declaration) or id.funcname is None
+ else:
+ raise ValueError(f'unsupported kind in row {row}')
+ if value.name == 'id' and declaration == UNKNOWN:
+ # None of these are variables.
+ declaration = 'int id';
+ else:
+ value.validate()
+ values[id] = value
+ return known
+
+
+def _is_global(vartype):
+ # statics
+ if vartype.startswith('static '):
+ return True
+ if vartype.startswith(('Py_LOCAL(', 'Py_LOCAL_INLINE(')):
+ return True
+ if vartype.startswith(('_Py_IDENTIFIER(', '_Py_static_string(')):
+ return True
+ if vartype.startswith('PyDoc_VAR('):
+ return True
+ if vartype.startswith(('SLOT1BINFULL(', 'SLOT1BIN(')):
+ return True
+ if vartype.startswith('WRAP_METHOD('):
+ return True
+ # public extern
+ if vartype.startswith('PyAPI_DATA('):
+ return True
+ return False
diff --git a/Tools/c-analyzer/c_analyzer_common/util.py b/Tools/c-analyzer/c_analyzer_common/util.py
new file mode 100644
index 0000000..511c54f
--- /dev/null
+++ b/Tools/c-analyzer/c_analyzer_common/util.py
@@ -0,0 +1,214 @@
+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.
+
+ This is useful for types that can't have slots via __slots__,
+ e.g. tuple subclasses.
+ """
+
+ __slots__ = ('initial', 'default', 'readonly', 'instances', 'name')
+
+ def __init__(self, initial=_NOT_SET, *,
+ default=_NOT_SET,
+ readonly=False,
+ ):
+ self.initial = initial
+ self.default = default
+ self.readonly = readonly
+
+ self.instances = {}
+ self.name = None
+
+ def __set_name__(self, cls, name):
+ if self.name is not None:
+ raise TypeError('already used')
+ self.name = name
+
+ def __get__(self, obj, cls):
+ if obj is None: # called on the class
+ return self
+ try:
+ value = self.instances[id(obj)]
+ except KeyError:
+ if self.initial is _NOT_SET:
+ value = self.default
+ else:
+ value = self.initial
+ self.instances[id(obj)] = value
+ if value is _NOT_SET:
+ raise AttributeError(self.name)
+ # XXX Optionally make a copy?
+ return value
+
+ def __set__(self, obj, value):
+ if self.readonly:
+ raise AttributeError(f'{self.name} is readonly')
+ # XXX Optionally coerce?
+ self.instances[id(obj)] = value
+
+ def __delete__(self, obj):
+ if self.readonly:
+ raise AttributeError(f'{self.name} is readonly')
+ self.instances[id(obj)] = self.default
+
+ def set(self, obj, value):
+ """Update the cached value for an object.
+
+ This works even if the descriptor is read-only. This is
+ particularly useful when initializing the object (e.g. in
+ its __new__ or __init__).
+ """
+ self.instances[id(obj)] = value
+
+
+class classonly:
+ """A non-data descriptor that makes a value only visible on the class.
+
+ This is like the "classmethod" builtin, but does not show up on
+ instances of the class. It may be used as a decorator.
+ """
+
+ def __init__(self, value):
+ self.value = value
+ self.getter = classmethod(value).__get__
+ self.name = None
+
+ def __set_name__(self, cls, name):
+ if self.name is not None:
+ raise TypeError('already used')
+ self.name = name
+
+ def __get__(self, obj, cls):
+ if obj is not None:
+ 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_globals/README b/Tools/c-analyzer/c_globals/README
new file mode 100644
index 0000000..772b8be
--- /dev/null
+++ b/Tools/c-analyzer/c_globals/README
@@ -0,0 +1,72 @@
+#######################################
+# 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/c_globals/__init__.py b/Tools/c-analyzer/c_globals/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/Tools/c-analyzer/c_globals/__init__.py
diff --git a/Tools/c-analyzer/c_globals/__main__.py b/Tools/c-analyzer/c_globals/__main__.py
new file mode 100644
index 0000000..9570fb6
--- /dev/null
+++ b/Tools/c-analyzer/c_globals/__main__.py
@@ -0,0 +1,209 @@
+import argparse
+import os.path
+import re
+import sys
+
+from c_analyzer_common import SOURCE_DIRS, REPO_ROOT
+from c_analyzer_common.info import UNKNOWN
+from c_analyzer_common.known import (
+ from_file as known_from_file,
+ DATA_FILE as KNOWN_FILE,
+ )
+from . import find, show
+from .supported import is_supported, ignored_from_file, IGNORED_FILE, _is_object
+
+
+def _match_unused_global(variable, knownvars, used):
+ 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
+
+
+def _check_results(unknown, knownvars, used):
+ 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, knownvars, used):
+ 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')
+
+
+def _find_globals(dirnames, known, ignored):
+ if dirnames == SOURCE_DIRS:
+ dirnames = [os.path.relpath(d, REPO_ROOT) for d in dirnames]
+
+ ignored = ignored_from_file(ignored)
+ known = known_from_file(known)
+
+ used = set()
+ unknown = set()
+ knownvars = (known or {}).get('variables')
+ for variable in find.globals_from_binary(knownvars=knownvars,
+ dirnames=dirnames):
+ #for variable in find.globals(dirnames, known, kind='platform'):
+ if variable.vartype == UNKNOWN:
+ unknown.add(variable)
+ continue
+ yield variable, is_supported(variable, ignored, known)
+ used.add(variable.id)
+
+ #_check_results(unknown, knownvars, used)
+
+
+def cmd_check(cmd, dirs=SOURCE_DIRS, *,
+ ignored=IGNORED_FILE,
+ known=KNOWN_FILE,
+ _find=_find_globals,
+ _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 = [v for v, s in _find(dirs, known, ignored) if not s]
+ 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, dirs=SOURCE_DIRS, *,
+ ignored=IGNORED_FILE,
+ known=KNOWN_FILE,
+ skip_objects=False,
+ _find=_find_globals,
+ _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(dirs, known, ignored):
+ if skip_objects: # XXX Support proper filters instead.
+ if _is_object(found.vartype):
+ 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,
+ )
+ subs = parser.add_subparsers(dest='cmd')
+
+ check = subs.add_parser('check', parents=[common])
+
+ show = subs.add_parser('show', parents=[common])
+ show.add_argument('--skip-objects', action='store_true')
+
+ if _fail is None:
+ def _fail(msg):
+ parser.error(msg)
+
+ # 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
+
+
+def main(cmd, cmdkwargs=None, *, _COMMANDS=COMMANDS):
+ try:
+ cmdfunc = _COMMANDS[cmd]
+ except KeyError:
+ raise ValueError(
+ f'unsupported cmd {cmd!r}' if cmd else 'missing cmd')
+
+ cmdfunc(cmd, **cmdkwargs or {})
+
+
+if __name__ == '__main__':
+ cmd, cmdkwargs = parse_args()
+ main(cmd, cmdkwargs)
diff --git a/Tools/c-analyzer/c_globals/find.py b/Tools/c-analyzer/c_globals/find.py
new file mode 100644
index 0000000..a51b947
--- /dev/null
+++ b/Tools/c-analyzer/c_globals/find.py
@@ -0,0 +1,95 @@
+from c_analyzer_common import SOURCE_DIRS
+from c_analyzer_common.info import UNKNOWN
+from c_symbols import (
+ info as s_info,
+ binary as b_symbols,
+ source as s_symbols,
+ resolve,
+ )
+from c_parser import info, declarations
+
+
+# XXX needs tests:
+# * iter_variables
+
+def globals_from_binary(binfile=b_symbols.PYTHON, *,
+ knownvars=None,
+ dirnames=None,
+ _iter_symbols=b_symbols.iter_symbols,
+ _resolve=resolve.symbols_to_variables,
+ _get_symbol_resolver=resolve.get_resolver,
+ ):
+ """Yield a Variable for each found Symbol.
+
+ Details are filled in from the given "known" variables and types.
+ """
+ symbols = _iter_symbols(binfile, find_local_symbol=None)
+ #symbols = list(symbols)
+ for variable in _resolve(symbols,
+ resolve=_get_symbol_resolver(knownvars, dirnames),
+ ):
+ # Skip each non-global variable (unless we couldn't find it).
+ # XXX Drop the "UNKNOWN" condition?
+ if not variable.isglobal and variable.vartype != UNKNOWN:
+ continue
+ yield variable
+
+
+def globals_from_declarations(dirnames=SOURCE_DIRS, *,
+ known=None,
+ ):
+ """Yield a Variable for each found declaration.
+
+ Details are filled in from the given "known" variables and types.
+ """
+ raise NotImplementedError
+
+
+def iter_variables(kind='platform', *,
+ known=None,
+ dirnames=None,
+ _resolve_symbols=resolve.symbols_to_variables,
+ _get_symbol_resolver=resolve.get_resolver,
+ _symbols_from_binary=b_symbols.iter_symbols,
+ _symbols_from_source=s_symbols.iter_symbols,
+ _iter_raw=declarations.iter_all,
+ _iter_preprocessed=declarations.iter_preprocessed,
+ ):
+ """Yield a Variable for each one found (e.g. in files)."""
+ kind = kind or 'platform'
+
+ if kind == 'symbols':
+ knownvars = (known or {}).get('variables')
+ yield from _resolve_symbols(
+ _symbols_from_source(dirnames, known),
+ resolve=_get_symbol_resolver(knownvars, dirnames),
+ )
+ elif kind == 'platform':
+ knownvars = (known or {}).get('variables')
+ yield from _resolve_symbols(
+ _symbols_from_binary(find_local_symbol=None),
+ resolve=_get_symbol_resolver(knownvars, dirnames),
+ )
+ elif kind == 'declarations':
+ for decl in _iter_raw(dirnames):
+ if not isinstance(decl, info.Variable):
+ continue
+ yield decl
+ elif kind == 'preprocessed':
+ for decl in _iter_preprocessed(dirnames):
+ if not isinstance(decl, info.Variable):
+ continue
+ yield decl
+ else:
+ raise ValueError(f'unsupported kind {kind!r}')
+
+
+def globals(dirnames, known, *,
+ kind=None, # Use the default.
+ _iter_variables=iter_variables,
+ ):
+ """Return a list of (StaticVar, <supported>) for each found global var."""
+ for found in _iter_variables(kind, known=known, dirnames=dirnames):
+ if not found.isglobal:
+ continue
+ yield found
diff --git a/Tools/c-analyzer/c_globals/show.py b/Tools/c-analyzer/c_globals/show.py
new file mode 100644
index 0000000..f4298b1
--- /dev/null
+++ b/Tools/c-analyzer/c_globals/show.py
@@ -0,0 +1,16 @@
+
+def basic(globals, *,
+ _print=print):
+ """Print each row simply."""
+ for variable in globals:
+ if variable.funcname:
+ line = f'{variable.filename}:{variable.funcname}():{variable.name}'
+ else:
+ line = f'{variable.filename}:{variable.name}'
+ vartype = variable.vartype
+ #if vartype.startswith('static '):
+ # vartype = vartype.partition(' ')[2]
+ #else:
+ # vartype = '=' + vartype
+ line = f'{line:<64} {vartype}'
+ _print(line)
diff --git a/Tools/c-analyzer/c_globals/supported.py b/Tools/c-analyzer/c_globals/supported.py
new file mode 100644
index 0000000..4643e4e
--- /dev/null
+++ b/Tools/c-analyzer/c_globals/supported.py
@@ -0,0 +1,368 @@
+import os.path
+import re
+
+from c_analyzer_common import DATA_DIR
+from c_analyzer_common.info import ID
+from c_analyzer_common.util import read_tsv, write_tsv
+
+
+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
+
+
+def _is_object(vartype):
+ if re.match(r'.*\bPy\w*Object\b', vartype):
+ return True
+ if '_PyArg_Parser ' in vartype:
+ return True
+ if vartype.startswith(('_Py_IDENTIFIER(', 'static _Py_Identifier',
+ '_Py_static_string(')):
+ return True
+ if 'traceback_t' in vartype:
+ return True
+ if 'PyAsyncGenASend' in vartype:
+ return True
+ if '_PyAsyncGenWrappedValue' in vartype:
+ return True
+ if 'PyContext' in vartype:
+ return True
+ if 'method_cache_entry' in vartype:
+ return True
+ if vartype.startswith('static identifier '):
+ 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 c_analyzer_common import SOURCE_DIRS
+ from c_analyzer_common.known import (
+ from_file as known_from_file,
+ DATA_FILE as KNOWN_FILE,
+ )
+ 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/c_parser/__init__.py b/Tools/c-analyzer/c_parser/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/__init__.py
diff --git a/Tools/c-analyzer/c_parser/declarations.py b/Tools/c-analyzer/c_parser/declarations.py
new file mode 100644
index 0000000..19fa3ff
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/declarations.py
@@ -0,0 +1,295 @@
+import re
+import shlex
+import subprocess
+
+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
+
+
+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 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, *,
+ _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."""
+ 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(dirnames):
+ """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.
+ """
+ raise NotImplementedError
+
+
+def iter_preprocessed(dirnames):
+ """Yield a Declaration for each one found.
+
+ All source files are run through the preprocessor first.
+ """
+ raise NotImplementedError
diff --git a/Tools/c-analyzer/c_parser/info.py b/Tools/c-analyzer/c_parser/info.py
new file mode 100644
index 0000000..9ab6979
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/info.py
@@ -0,0 +1,78 @@
+from collections import namedtuple
+
+from c_analyzer_common import info, util
+from c_analyzer_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)
+
+
+class Variable(_NTBase,
+ namedtuple('Variable', 'id vartype')):
+ """Information about a single variable declaration."""
+
+ __slots__ = ()
+ _isglobal = util.Slot()
+
+ @classonly
+ def from_parts(cls, filename, funcname, name, vartype, isglobal=False):
+ id = info.ID(filename, funcname, name)
+ self = cls(id, vartype)
+ if isglobal:
+ self._isglobal = True
+ return self
+
+ def __new__(cls, id, vartype):
+ self = super().__new__(
+ cls,
+ id=info.ID.from_raw(id),
+ 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 == info.UNKNOWN:
+ raise TypeError(f'id missing filename ({self.id})')
+
+ if self.funcname and self.funcname == info.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.vartype is None or self.vartype == info.UNKNOWN:
+ raise TypeError('missing vartype')
+
+ @property
+ def isglobal(self):
+ try:
+ return self._isglobal
+ except AttributeError:
+ # XXX Include extern variables.
+ # XXX Ignore functions.
+ self._isglobal = ('static' in self.vartype.split())
+ return self._isglobal
+
+ @property
+ def isconst(self):
+ return 'const' in self.vartype.split()
diff --git a/Tools/c-analyzer/c_parser/naive.py b/Tools/c-analyzer/c_parser/naive.py
new file mode 100644
index 0000000..e0370cc
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/naive.py
@@ -0,0 +1,180 @@
+import re
+
+from c_analyzer_common.info import UNKNOWN
+
+from .info import Variable
+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 a Variable 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 a Variable for each 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 Variable.from_parts(filename, _funcname, name, decl)
+ continue
+ name, decl = info
+
+ if name is None:
+ continue
+ yield Variable.from_parts(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 variable in _iter_variables(filename,
+ srccache=srccache,
+ parse_variable=parse_variable,
+ ):
+ if _match_varid(variable, name, funcname, ignored):
+ return variable
+ else:
+ return None
+
+
+def find_variables(varids, filenames=None, *,
+ srccache=_NOT_SET,
+ parse_variable=None,
+ _find_symbol=find_variable,
+ ):
+ """Yield a Variable 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 Variable(varid, UNKNOWN)
+ continue
+ srcfiles = filenames
+ for filename in srcfiles:
+ found = _find_varid(filename, varid.funcname, varid.name,
+ ignored=used,
+ srccache=srccache,
+ parse_variable=parse_variable,
+ )
+ if found:
+ yield found
+ used.add(found)
+ break
+ else:
+ yield Variable(varid, UNKNOWN)
diff --git a/Tools/c-analyzer/c_parser/preprocessor.py b/Tools/c-analyzer/c_parser/preprocessor.py
new file mode 100644
index 0000000..0e2866e
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/preprocessor.py
@@ -0,0 +1,512 @@
+from collections import namedtuple
+import shlex
+import os
+import re
+
+from c_analyzer_common import util
+from . import 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_parser/source.py b/Tools/c-analyzer/c_parser/source.py
new file mode 100644
index 0000000..f8998c8
--- /dev/null
+++ b/Tools/c-analyzer/c_parser/source.py
@@ -0,0 +1,34 @@
+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_symbols/__init__.py b/Tools/c-analyzer/c_symbols/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/Tools/c-analyzer/c_symbols/__init__.py
diff --git a/Tools/c-analyzer/c_symbols/binary.py b/Tools/c-analyzer/c_symbols/binary.py
new file mode 100644
index 0000000..e125dbd5
--- /dev/null
+++ b/Tools/c-analyzer/c_symbols/binary.py
@@ -0,0 +1,157 @@
+import os
+import os.path
+import shutil
+import sys
+
+from c_analyzer_common import util, info
+from . import source
+from .info import Symbol
+
+
+#PYTHON = os.path.join(REPO_ROOT, 'python')
+PYTHON = sys.executable
+
+
+def iter_symbols(binary=PYTHON, dirnames=None, *,
+ # Alternately, use look_up_known_symbol()
+ # from c_globals.supported.
+ find_local_symbol=source.find_symbol,
+ _file_exists=os.path.exists,
+ _iter_symbols_nm=(lambda b, *a: _iter_symbols_nm(b, *a)),
+ ):
+ """Yield a Symbol for each symbol found in the binary."""
+ if not _file_exists(binary):
+ raise Exception('executable missing (need to build it first?)')
+
+ if find_local_symbol:
+ cache = {}
+ def find_local_symbol(name, *, _find=find_local_symbol):
+ return _find(name, dirnames, _perfilecache=cache)
+ else:
+ find_local_symbol = None
+
+ if os.name == 'nt':
+ # XXX Support this.
+ raise NotImplementedError
+ else:
+ yield from _iter_symbols_nm(binary, find_local_symbol)
+
+
+#############################
+# binary format (e.g. ELF)
+
+SPECIAL_SYMBOLS = {
+ '__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
+
+
+#############################
+# "nm"
+
+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,
+ }
+
+
+def _iter_symbols_nm(binary, find_local_symbol=None,
+ *,
+ _which=shutil.which,
+ _run=util.run_cmd,
+ ):
+ nm = _which('nm')
+ if not nm:
+ raise NotImplementedError
+ argv = [nm,
+ '--line-numbers',
+ binary,
+ ]
+ 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, vartype,
+ ) = _parse_nm_line(line,
+ _find_local_symbol=find_local_symbol,
+ )
+ if kind != Symbol.KIND.VARIABLE:
+ continue
+ elif _is_special_symbol(name):
+ continue
+ assert vartype is None
+ yield Symbol(
+ id=(filename, funcname, name),
+ kind=kind,
+ external=external,
+ )
+
+
+def _parse_nm_line(line, *, _find_local_symbol=None):
+ _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
+
+ vartype = None
+ name, islocal = _parse_nm_name(name, kind)
+ if islocal:
+ funcname = info.UNKNOWN
+ if _find_local_symbol is not None:
+ filename, funcname, vartype = _find_local_symbol(name)
+ filename = filename or info.UNKNOWN
+ funcname = funcname or info.UNKNOWN
+ else:
+ funcname = None
+ # XXX fine filename and vartype?
+ return name, kind, external, filename, funcname, vartype
+
+
+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_symbols/info.py b/Tools/c-analyzer/c_symbols/info.py
new file mode 100644
index 0000000..f6ed52c
--- /dev/null
+++ b/Tools/c-analyzer/c_symbols/info.py
@@ -0,0 +1,51 @@
+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_symbols/resolve.py b/Tools/c-analyzer/c_symbols/resolve.py
new file mode 100644
index 0000000..dc876ae
--- /dev/null
+++ b/Tools/c-analyzer/c_symbols/resolve.py
@@ -0,0 +1,149 @@
+import os.path
+
+from c_analyzer_common import files
+from c_analyzer_common.info import UNKNOWN
+from c_parser import declarations, info
+from .info import Symbol
+from .source import _find_symbol
+
+
+# XXX need tests:
+# * look_up_known_symbol()
+# * symbol_from_source()
+# * get_resolver()
+# * symbols_to_variables()
+
+def look_up_known_symbol(symbol, knownvars, *,
+ match_files=(lambda f1, f2: f1 == f2),
+ ):
+ """Return the known variable matching the given symbol.
+
+ "knownvars" is a mapping of common.ID to parser.Variable.
+
+ "match_files" is used to verify if two filenames point to
+ the same file.
+ """
+ if not knownvars:
+ return None
+
+ if symbol.funcname == UNKNOWN:
+ if not symbol.filename or symbol.filename == UNKNOWN:
+ for varid in knownvars:
+ if not varid.funcname:
+ continue
+ if varid.name == symbol.name:
+ return knownvars[varid]
+ else:
+ return None
+ else:
+ for varid in knownvars:
+ if not varid.funcname:
+ continue
+ if not match_files(varid.filename, symbol.filename):
+ continue
+ if varid.name == symbol.name:
+ return knownvars[varid]
+ else:
+ return None
+ elif not symbol.filename or symbol.filename == UNKNOWN:
+ raise NotImplementedError
+ else:
+ return knownvars.get(symbol.id)
+
+
+def find_in_source(symbol, dirnames, *,
+ _perfilecache={},
+ _find_symbol=_find_symbol,
+ _iter_files=files.iter_files_by_suffix,
+ ):
+ """Return the Variable matching the given Symbol.
+
+ If there is no match then return None.
+ """
+ if symbol.filename and symbol.filename != UNKNOWN:
+ filenames = [symbol.filename]
+ else:
+ filenames = _iter_files(dirnames, ('.c', '.h'))
+
+ if symbol.funcname and symbol.funcname != UNKNOWN:
+ raise NotImplementedError
+
+ (filename, funcname, vartype
+ ) = _find_symbol(symbol.name, filenames, _perfilecache)
+ if filename == UNKNOWN:
+ return None
+ return info.Variable(
+ id=(filename, funcname, symbol.name),
+ vartype=vartype,
+ )
+
+
+def get_resolver(knownvars=None, dirnames=None, *,
+ _look_up_known=look_up_known_symbol,
+ _from_source=find_in_source,
+ ):
+ """Return a "resolver" func for the given known vars and dirnames.
+
+ The 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.
+ """
+ if knownvars:
+ knownvars = dict(knownvars) # a copy
+ def resolve_known(symbol):
+ found = _look_up_known(symbol, knownvars)
+ if found is None:
+ return None
+ elif symbol.funcname == UNKNOWN:
+ knownvars.pop(found.id)
+ elif not symbol.filename or symbol.filename == UNKNOWN:
+ knownvars.pop(found.id)
+ return found
+ if dirnames:
+ def resolve(symbol):
+ found = resolve_known(symbol)
+ if found is None:
+ return None
+ #return _from_source(symbol, dirnames)
+ else:
+ for dirname in dirnames:
+ if not dirname.endswith(os.path.sep):
+ dirname += os.path.sep
+ if found.filename.startswith(dirname):
+ break
+ else:
+ return None
+ return found
+ else:
+ resolve = resolve_known
+ elif dirnames:
+ def resolve(symbol):
+ return _from_source(symbol, dirnames)
+ else:
+ def resolve(symbol):
+ return None
+ return resolve
+
+
+def symbols_to_variables(symbols, *,
+ resolve=(lambda s: look_up_known_symbol(s, None)),
+ ):
+ """Yield the variable the matches each given symbol.
+
+ Use get_resolver() for a "resolve" func to use.
+ """
+ for symbol in symbols:
+ if isinstance(symbol, info.Variable):
+ # XXX validate?
+ yield symbol
+ continue
+ if symbol.kind != Symbol.KIND.VARIABLE:
+ continue
+ resolved = resolve(symbol)
+ if resolved is None:
+ #raise NotImplementedError(symbol)
+ resolved = info.Variable(
+ id=symbol.id,
+ vartype=UNKNOWN,
+ )
+ yield resolved
diff --git a/Tools/c-analyzer/c_symbols/source.py b/Tools/c-analyzer/c_symbols/source.py
new file mode 100644
index 0000000..a724810
--- /dev/null
+++ b/Tools/c-analyzer/c_symbols/source.py
@@ -0,0 +1,58 @@
+from c_analyzer_common import files
+from c_analyzer_common.info import UNKNOWN
+from c_parser import declarations
+
+
+# XXX need tests:
+# * find_symbol()
+
+def find_symbol(name, dirnames, *,
+ _perfilecache,
+ _iter_files=files.iter_files_by_suffix,
+ **kwargs
+ ):
+ """Return (filename, funcname, vartype) for the matching Symbol."""
+ filenames = _iter_files(dirnames, ('.c', '.h'))
+ return _find_symbol(name, filenames, _perfilecache, **kwargs)
+
+
+def _get_symbols(filename, *,
+ _iter_variables=declarations.iter_variables,
+ ):
+ """Return the list of Symbols found in the given file."""
+ symbols = {}
+ for funcname, name, vartype in _iter_variables(filename):
+ if not funcname:
+ continue
+ try:
+ instances = symbols[name]
+ except KeyError:
+ instances = symbols[name] = []
+ instances.append((funcname, vartype))
+ return symbols
+
+
+def _find_symbol(name, filenames, _perfilecache, *,
+ _get_local_symbols=_get_symbols,
+ ):
+ for filename in filenames:
+ try:
+ symbols = _perfilecache[filename]
+ except KeyError:
+ symbols = _perfilecache[filename] = _get_local_symbols(filename)
+
+ try:
+ instances = symbols[name]
+ except KeyError:
+ continue
+
+ funcname, vartype = instances.pop(0)
+ if not instances:
+ symbols.pop(name)
+ return filename, funcname, vartype
+ else:
+ return UNKNOWN, UNKNOWN, UNKNOWN
+
+
+def iter_symbols():
+ raise NotImplementedError
diff --git a/Tools/c-analyzer/check-c-globals.py b/Tools/c-analyzer/check-c-globals.py
new file mode 100644
index 0000000..e68ed92
--- /dev/null
+++ b/Tools/c-analyzer/check-c-globals.py
@@ -0,0 +1,446 @@
+
+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(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:]
+
+ import argparse
+ parser = argparse.ArgumentParser()
+
+ 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)
+
+ total = 0
+ for line, count in lines:
+ total += count
+ log(line)
+ log('\ntotal: {}'.format(total))
+
+ if total and rc:
+ print('ERROR: found unsafe globals', file=sys.stderr)
+ return rc
+ return 0
+
+
+if __name__ == '__main__':
+ args = parse_args()
+ sys.exit(
+ main(**vars(args)))
diff --git a/Tools/c-analyzer/ignored-globals.txt b/Tools/c-analyzer/ignored-globals.txt
new file mode 100644
index 0000000..ce6d1d8
--- /dev/null
+++ b/Tools/c-analyzer/ignored-globals.txt
@@ -0,0 +1,492 @@
+# 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
new file mode 100644
index 0000000..a0e0e50
--- /dev/null
+++ b/Tools/c-analyzer/ignored.tsv
@@ -0,0 +1 @@
+filename funcname name kind reason
diff --git a/Tools/c-analyzer/known.tsv b/Tools/c-analyzer/known.tsv
new file mode 100644
index 0000000..ce2afcb
--- /dev/null
+++ b/Tools/c-analyzer/known.tsv
@@ -0,0 +1,1922 @@
+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
+Parser/listnode.c - atbol variable static int atbol
+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
+Parser/listnode.c - level variable static int level
+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
+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
+Python/ceval.c - _Py_CheckRecursionLimit variable int _Py_CheckRecursionLimit
+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/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/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
+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/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/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