mirror of
https://github.com/python/cpython.git
synced 2025-07-08 20:05:28 +00:00
fe55ff3f68
Up until now we had a single generated initializer macro for all the statically declared global objects in _PyRuntimeState, including several one-offs (e.g. the empty tuple). The one-offs don't need to be generated, but were because we had one big initializer. Having separate initializers for set of generated global objects allows us to generate only the ones we need to. This allows us to add initializers for one-off global objects without having to generate them. https://github.com/python/cpython/issues/81057
426 lines
13 KiB
Python
426 lines
13 KiB
Python
import contextlib
|
|
import io
|
|
import os.path
|
|
import re
|
|
|
|
SCRIPT_NAME = 'Tools/build/generate_global_objects.py'
|
|
__file__ = os.path.abspath(__file__)
|
|
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
|
|
INTERNAL = os.path.join(ROOT, 'Include', 'internal')
|
|
|
|
|
|
IGNORED = {
|
|
'ACTION', # Python/_warnings.c
|
|
'ATTR', # Python/_warnings.c and Objects/funcobject.c
|
|
'DUNDER', # Objects/typeobject.c
|
|
'RDUNDER', # Objects/typeobject.c
|
|
'SPECIAL', # Objects/weakrefobject.c
|
|
'NAME', # Objects/typeobject.c
|
|
}
|
|
IDENTIFIERS = [
|
|
# from ADD() Python/_warnings.c
|
|
'default',
|
|
'ignore',
|
|
|
|
# from GET_WARNINGS_ATTR() in Python/_warnings.c
|
|
'WarningMessage',
|
|
'_showwarnmsg',
|
|
'_warn_unawaited_coroutine',
|
|
'defaultaction',
|
|
'filters',
|
|
'onceregistry',
|
|
|
|
# from WRAP_METHOD() in Objects/weakrefobject.c
|
|
'__bytes__',
|
|
'__reversed__',
|
|
|
|
# from COPY_ATTR() in Objects/funcobject.c
|
|
'__module__',
|
|
'__name__',
|
|
'__qualname__',
|
|
'__doc__',
|
|
'__annotations__',
|
|
|
|
# from SLOT* in Objects/typeobject.c
|
|
'__abs__',
|
|
'__add__',
|
|
'__aiter__',
|
|
'__and__',
|
|
'__anext__',
|
|
'__await__',
|
|
'__bool__',
|
|
'__call__',
|
|
'__contains__',
|
|
'__del__',
|
|
'__delattr__',
|
|
'__delete__',
|
|
'__delitem__',
|
|
'__eq__',
|
|
'__float__',
|
|
'__floordiv__',
|
|
'__ge__',
|
|
'__get__',
|
|
'__getattr__',
|
|
'__getattribute__',
|
|
'__getitem__',
|
|
'__gt__',
|
|
'__hash__',
|
|
'__iadd__',
|
|
'__iand__',
|
|
'__ifloordiv__',
|
|
'__ilshift__',
|
|
'__imatmul__',
|
|
'__imod__',
|
|
'__imul__',
|
|
'__index__',
|
|
'__init__',
|
|
'__int__',
|
|
'__invert__',
|
|
'__ior__',
|
|
'__ipow__',
|
|
'__irshift__',
|
|
'__isub__',
|
|
'__iter__',
|
|
'__itruediv__',
|
|
'__ixor__',
|
|
'__le__',
|
|
'__len__',
|
|
'__lshift__',
|
|
'__lt__',
|
|
'__matmul__',
|
|
'__mod__',
|
|
'__mul__',
|
|
'__ne__',
|
|
'__neg__',
|
|
'__new__',
|
|
'__next__',
|
|
'__or__',
|
|
'__pos__',
|
|
'__pow__',
|
|
'__radd__',
|
|
'__rand__',
|
|
'__repr__',
|
|
'__rfloordiv__',
|
|
'__rlshift__',
|
|
'__rmatmul__',
|
|
'__rmod__',
|
|
'__rmul__',
|
|
'__ror__',
|
|
'__rpow__',
|
|
'__rrshift__',
|
|
'__rshift__',
|
|
'__rsub__',
|
|
'__rtruediv__',
|
|
'__rxor__',
|
|
'__set__',
|
|
'__setattr__',
|
|
'__setitem__',
|
|
'__str__',
|
|
'__sub__',
|
|
'__truediv__',
|
|
'__xor__',
|
|
'__divmod__',
|
|
'__rdivmod__',
|
|
]
|
|
|
|
NON_GENERATED_IMMORTAL_OBJECTS = [
|
|
# The generated ones come from generate_runtime_init().
|
|
'(PyObject *)&_Py_SINGLETON(bytes_empty)',
|
|
'(PyObject *)&_Py_SINGLETON(tuple_empty)',
|
|
]
|
|
|
|
|
|
#######################################
|
|
# helpers
|
|
|
|
def iter_files():
|
|
for name in ('Modules', 'Objects', 'Parser', 'PC', 'Programs', 'Python'):
|
|
root = os.path.join(ROOT, name)
|
|
for dirname, _, files in os.walk(root):
|
|
for name in files:
|
|
if not name.endswith(('.c', '.h')):
|
|
continue
|
|
yield os.path.join(dirname, name)
|
|
|
|
|
|
def iter_global_strings():
|
|
id_regex = re.compile(r'\b_Py_ID\((\w+)\)')
|
|
str_regex = re.compile(r'\b_Py_DECLARE_STR\((\w+), "(.*?)"\)')
|
|
for filename in iter_files():
|
|
try:
|
|
infile = open(filename, encoding='utf-8')
|
|
except FileNotFoundError:
|
|
# The file must have been a temporary file.
|
|
continue
|
|
with infile:
|
|
for lno, line in enumerate(infile, 1):
|
|
for m in id_regex.finditer(line):
|
|
identifier, = m.groups()
|
|
yield identifier, None, filename, lno, line
|
|
for m in str_regex.finditer(line):
|
|
varname, string = m.groups()
|
|
yield varname, string, filename, lno, line
|
|
|
|
|
|
def iter_to_marker(lines, marker):
|
|
for line in lines:
|
|
if line.rstrip() == marker:
|
|
break
|
|
yield line
|
|
|
|
|
|
class Printer:
|
|
|
|
def __init__(self, file):
|
|
self.level = 0
|
|
self.file = file
|
|
self.continuation = [False]
|
|
|
|
@contextlib.contextmanager
|
|
def indent(self):
|
|
save_level = self.level
|
|
try:
|
|
self.level += 1
|
|
yield
|
|
finally:
|
|
self.level = save_level
|
|
|
|
def write(self, arg):
|
|
eol = '\n'
|
|
if self.continuation[-1]:
|
|
eol = f' \\{eol}' if arg else f'\\{eol}'
|
|
self.file.writelines((" "*self.level, arg, eol))
|
|
|
|
@contextlib.contextmanager
|
|
def block(self, prefix, suffix="", *, continuation=None):
|
|
if continuation is None:
|
|
continuation = self.continuation[-1]
|
|
self.continuation.append(continuation)
|
|
|
|
self.write(prefix + " {")
|
|
with self.indent():
|
|
yield
|
|
self.continuation.pop()
|
|
self.write("}" + suffix)
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def open_for_changes(filename, orig):
|
|
"""Like open() but only write to the file if it changed."""
|
|
outfile = io.StringIO()
|
|
yield outfile
|
|
text = outfile.getvalue()
|
|
if text != orig:
|
|
with open(filename, 'w', encoding='utf-8') as outfile:
|
|
outfile.write(text)
|
|
else:
|
|
print(f'# not changed: {filename}')
|
|
|
|
|
|
#######################################
|
|
# the global objects
|
|
|
|
START = f'/* The following is auto-generated by {SCRIPT_NAME}. */'
|
|
END = '/* End auto-generated code */'
|
|
|
|
|
|
def generate_global_strings(identifiers, strings):
|
|
filename = os.path.join(INTERNAL, 'pycore_global_strings.h')
|
|
|
|
# Read the non-generated part of the file.
|
|
with open(filename) as infile:
|
|
orig = infile.read()
|
|
lines = iter(orig.rstrip().splitlines())
|
|
before = '\n'.join(iter_to_marker(lines, START))
|
|
for _ in iter_to_marker(lines, END):
|
|
pass
|
|
after = '\n'.join(lines)
|
|
|
|
# Generate the file.
|
|
with open_for_changes(filename, orig) as outfile:
|
|
printer = Printer(outfile)
|
|
printer.write(before)
|
|
printer.write(START)
|
|
with printer.block('struct _Py_global_strings', ';'):
|
|
with printer.block('struct', ' literals;'):
|
|
for literal, name in sorted(strings.items(), key=lambda x: x[1]):
|
|
printer.write(f'STRUCT_FOR_STR({name}, "{literal}")')
|
|
outfile.write('\n')
|
|
with printer.block('struct', ' identifiers;'):
|
|
for name in sorted(identifiers):
|
|
assert name.isidentifier(), name
|
|
printer.write(f'STRUCT_FOR_ID({name})')
|
|
with printer.block('struct', ' ascii[128];'):
|
|
printer.write("PyASCIIObject _ascii;")
|
|
printer.write("uint8_t _data[2];")
|
|
with printer.block('struct', ' latin1[128];'):
|
|
printer.write("PyCompactUnicodeObject _latin1;")
|
|
printer.write("uint8_t _data[2];")
|
|
printer.write(END)
|
|
printer.write(after)
|
|
|
|
|
|
def generate_runtime_init(identifiers, strings):
|
|
# First get some info from the declarations.
|
|
nsmallposints = None
|
|
nsmallnegints = None
|
|
with open(os.path.join(INTERNAL, 'pycore_global_objects.h')) as infile:
|
|
for line in infile:
|
|
if line.startswith('#define _PY_NSMALLPOSINTS'):
|
|
nsmallposints = int(line.split()[-1])
|
|
elif line.startswith('#define _PY_NSMALLNEGINTS'):
|
|
nsmallnegints = int(line.split()[-1])
|
|
break
|
|
else:
|
|
raise NotImplementedError
|
|
assert nsmallposints and nsmallnegints
|
|
|
|
# Then target the runtime initializer.
|
|
filename = os.path.join(INTERNAL, 'pycore_runtime_init_generated.h')
|
|
|
|
# Read the non-generated part of the file.
|
|
with open(filename) as infile:
|
|
orig = infile.read()
|
|
lines = iter(orig.rstrip().splitlines())
|
|
before = '\n'.join(iter_to_marker(lines, START))
|
|
for _ in iter_to_marker(lines, END):
|
|
pass
|
|
after = '\n'.join(lines)
|
|
|
|
# Generate the file.
|
|
with open_for_changes(filename, orig) as outfile:
|
|
immortal_objects = []
|
|
printer = Printer(outfile)
|
|
printer.write(before)
|
|
printer.write(START)
|
|
with printer.block('#define _Py_small_ints_INIT', continuation=True):
|
|
for i in range(-nsmallnegints, nsmallposints):
|
|
printer.write(f'_PyLong_DIGIT_INIT({i}),')
|
|
immortal_objects.append(f'(PyObject *)&_Py_SINGLETON(small_ints)[_PY_NSMALLNEGINTS + {i}]')
|
|
printer.write('')
|
|
with printer.block('#define _Py_bytes_characters_INIT', continuation=True):
|
|
for i in range(256):
|
|
printer.write(f'_PyBytes_CHAR_INIT({i}),')
|
|
immortal_objects.append(f'(PyObject *)&_Py_SINGLETON(bytes_characters)[{i}]')
|
|
printer.write('')
|
|
with printer.block('#define _Py_str_literals_INIT', continuation=True):
|
|
for literal, name in sorted(strings.items(), key=lambda x: x[1]):
|
|
printer.write(f'INIT_STR({name}, "{literal}"),')
|
|
immortal_objects.append(f'(PyObject *)&_Py_STR({name})')
|
|
printer.write('')
|
|
with printer.block('#define _Py_str_identifiers_INIT', continuation=True):
|
|
for name in sorted(identifiers):
|
|
assert name.isidentifier(), name
|
|
printer.write(f'INIT_ID({name}),')
|
|
immortal_objects.append(f'(PyObject *)&_Py_ID({name})')
|
|
printer.write('')
|
|
with printer.block('#define _Py_str_ascii_INIT', continuation=True):
|
|
for i in range(128):
|
|
printer.write(f'_PyASCIIObject_INIT("\\x{i:02x}"),')
|
|
immortal_objects.append(f'(PyObject *)&_Py_SINGLETON(strings).ascii[{i}]')
|
|
printer.write('')
|
|
with printer.block('#define _Py_str_latin1_INIT', continuation=True):
|
|
for i in range(128, 256):
|
|
utf8 = ['"']
|
|
for c in chr(i).encode('utf-8'):
|
|
utf8.append(f"\\x{c:02x}")
|
|
utf8.append('"')
|
|
printer.write(f'_PyUnicode_LATIN1_INIT("\\x{i:02x}", {"".join(utf8)}),')
|
|
immortal_objects.append(f'(PyObject *)&_Py_SINGLETON(strings).latin1[{i} - 128]')
|
|
printer.write(END)
|
|
printer.write(after)
|
|
return immortal_objects
|
|
|
|
|
|
def generate_static_strings_initializer(identifiers, strings):
|
|
# Target the runtime initializer.
|
|
filename = os.path.join(INTERNAL, 'pycore_unicodeobject_generated.h')
|
|
|
|
# Read the non-generated part of the file.
|
|
with open(filename) as infile:
|
|
orig = infile.read()
|
|
lines = iter(orig.rstrip().splitlines())
|
|
before = '\n'.join(iter_to_marker(lines, START))
|
|
for _ in iter_to_marker(lines, END):
|
|
pass
|
|
after = '\n'.join(lines)
|
|
|
|
# Generate the file.
|
|
with open_for_changes(filename, orig) as outfile:
|
|
printer = Printer(outfile)
|
|
printer.write(before)
|
|
printer.write(START)
|
|
printer.write("static inline void")
|
|
with printer.block("_PyUnicode_InitStaticStrings(void)"):
|
|
printer.write(f'PyObject *string;')
|
|
for i in sorted(identifiers):
|
|
# This use of _Py_ID() is ignored by iter_global_strings()
|
|
# since iter_files() ignores .h files.
|
|
printer.write(f'string = &_Py_ID({i});')
|
|
printer.write(f'PyUnicode_InternInPlace(&string);')
|
|
# XXX What about "strings"?
|
|
printer.write(END)
|
|
printer.write(after)
|
|
|
|
|
|
def generate_global_object_finalizers(generated_immortal_objects):
|
|
# Target the runtime initializer.
|
|
filename = os.path.join(INTERNAL, 'pycore_global_objects_fini_generated.h')
|
|
|
|
# Read the non-generated part of the file.
|
|
with open(filename) as infile:
|
|
orig = infile.read()
|
|
lines = iter(orig.rstrip().splitlines())
|
|
before = '\n'.join(iter_to_marker(lines, START))
|
|
for _ in iter_to_marker(lines, END):
|
|
pass
|
|
after = '\n'.join(lines)
|
|
|
|
# Generate the file.
|
|
with open_for_changes(filename, orig) as outfile:
|
|
printer = Printer(outfile)
|
|
printer.write(before)
|
|
printer.write(START)
|
|
printer.write('#ifdef Py_DEBUG')
|
|
printer.write("static inline void")
|
|
with printer.block("_PyStaticObjects_CheckRefcnt(void)"):
|
|
printer.write('/* generated (see pycore_runtime_init_generated.h) */')
|
|
for ref in generated_immortal_objects:
|
|
printer.write(f'_PyStaticObject_CheckRefcnt({ref});')
|
|
printer.write('/* non-generated */')
|
|
for ref in NON_GENERATED_IMMORTAL_OBJECTS:
|
|
printer.write(f'_PyStaticObject_CheckRefcnt({ref});')
|
|
printer.write('#endif // Py_DEBUG')
|
|
printer.write(END)
|
|
printer.write(after)
|
|
|
|
|
|
def get_identifiers_and_strings() -> 'tuple[set[str], dict[str, str]]':
|
|
identifiers = set(IDENTIFIERS)
|
|
strings = {}
|
|
for name, string, *_ in iter_global_strings():
|
|
if string is None:
|
|
if name not in IGNORED:
|
|
identifiers.add(name)
|
|
else:
|
|
if string not in strings:
|
|
strings[string] = name
|
|
elif name != strings[string]:
|
|
raise ValueError(f'string mismatch for {name!r} ({string!r} != {strings[name]!r}')
|
|
return identifiers, strings
|
|
|
|
|
|
#######################################
|
|
# the script
|
|
|
|
def main() -> None:
|
|
identifiers, strings = get_identifiers_and_strings()
|
|
|
|
generate_global_strings(identifiers, strings)
|
|
generated_immortal_objects = generate_runtime_init(identifiers, strings)
|
|
generate_static_strings_initializer(identifiers, strings)
|
|
generate_global_object_finalizers(generated_immortal_objects)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|