import abc
import ast
+import builtins as bltns
import collections
import contextlib
import copy
import traceback
import types
+from collections.abc import Callable
from types import *
+from typing import Any, NamedTuple
# TODO:
#
sig_end_marker = '--'
+Appender = Callable[[str], None]
+Outputter = Callable[[None], str]
-_text_accumulator_nt = collections.namedtuple("_text_accumulator", "text append output")
+class _TextAccumulator(NamedTuple):
+ text: list[str]
+ append: Appender
+ output: Outputter
def _text_accumulator():
text = []
s = ''.join(text)
text.clear()
return s
- return _text_accumulator_nt(text, text.append, output)
+ return _TextAccumulator(text, text.append, output)
-text_accumulator_nt = collections.namedtuple("text_accumulator", "text append")
+class TextAccumulator(NamedTuple):
+ text: list[str]
+ append: Appender
def text_accumulator():
"""
empties the accumulator.
"""
text, append, output = _text_accumulator()
- return text_accumulator_nt(append, output)
+ return TextAccumulator(append, output)
def warn_or_fail(fail=False, *args, filename=None, line_number=None):
# maps strings to Language objects.
# "languages" maps the name of the language ("C", "Python").
# "extensions" maps the file extension ("c", "py").
+LangDict = dict[str, Callable[[str], Language]]
+
languages = { 'C': CLanguage, 'Python': PythonLanguage }
-extensions = { name: CLanguage for name in "c cc cpp cxx h hh hpp hxx".split() }
+extensions: LangDict = { name: CLanguage for name in "c cc cpp cxx h hh hpp hxx".split() }
extensions['py'] = PythonLanguage
"""
# The C name to use for this variable.
- name = None
+ name: str | None = None
# The Python name to use for this variable.
- py_name = None
+ py_name: str | None = None
# The C type to use for this variable.
# 'type' should be a Python string specifying the type, e.g. "int".
# If this is a pointer type, the type string should end with ' *'.
- type = None
+ type: str | None = None
# The Python default value for this parameter, as a Python value.
# Or the magic value "unspecified" if there is no default.
# If not None, default must be isinstance() of this type.
# (You can also specify a tuple of types.)
- default_type = None
+ default_type: bltns.type[Any] | tuple[bltns.type[Any], ...] | None = None
# "default" converted into a C value, as a string.
# Or None if there is no default.
- c_default = None
+ c_default: str | None = None
# "default" converted into a Python value, as a string.
# Or None if there is no default.
- py_default = None
+ py_default: str | None = None
# The default value used to initialize the C variable when
# there is no default, but not specifying a default may
#
# This value is specified as a string.
# Every non-abstract subclass should supply a valid value.
- c_ignored_default = 'NULL'
+ c_ignored_default: str = 'NULL'
# If true, wrap with Py_UNUSED.
unused = False
# The C converter *function* to be used, if any.
# (If this is not None, format_unit must be 'O&'.)
- converter = None
+ converter: str | None = None
# Should Argument Clinic add a '&' before the name of
# the variable when passing it into the _impl function?
def str_converter_key(types, encoding, zeroes):
return (frozenset(types), bool(encoding), bool(zeroes))
-str_converter_argument_map = {}
+str_converter_argument_map: dict[str, str] = {}
class str_converter(CConverter):
type = 'const char *'
import re
import sys
+from collections.abc import Callable
-def negate(condition):
+
+TokenAndCondition = tuple[str, str]
+TokenStack = list[TokenAndCondition]
+
+def negate(condition: str) -> str:
"""
Returns a CPP conditional that is the opposite of the conditional passed in.
"""
Anyway this implementation seems to work well enough for the CPython sources.
"""
+ is_a_simple_defined: Callable[[str], re.Match[str] | None]
is_a_simple_defined = re.compile(r'^defined\s*\(\s*[A-Za-z0-9_]+\s*\)$').match
- def __init__(self, filename=None, *, verbose=False):
- self.stack = []
+ def __init__(self, filename=None, *, verbose: bool = False):
+ self.stack: TokenStack = []
self.in_comment = False
- self.continuation = None
+ self.continuation: str | None = None
self.line_number = 0
self.filename = filename
self.verbose = verbose
- def __repr__(self):
+ def __repr__(self) -> str:
return ''.join((
'<Monitor ',
str(id(self)),
" condition=", repr(self.condition()),
">"))
- def status(self):
+ def status(self) -> str:
return str(self.line_number).rjust(4) + ": " + self.condition()
- def condition(self):
+ def condition(self) -> str:
"""
Returns the current preprocessor state, as a single #if condition.
"""
if self.stack:
self.fail("Ended file while still in a preprocessor conditional block!")
- def write(self, s):
+ def write(self, s: str) -> None:
for line in s.split("\n"):
self.writeline(line)
- def writeline(self, line):
+ def writeline(self, line: str) -> None:
self.line_number += 1
line = line.strip()
- def pop_stack():
+ def pop_stack() -> TokenAndCondition:
if not self.stack:
self.fail("#" + token + " without matching #if / #ifdef / #ifndef!")
return self.stack.pop()
projects / thirdparty / Python / cpython.git / commitdiff
