diff --git a/Doc/c-api/buffer.rst b/Doc/c-api/buffer.rst
index a04062fb2a68f1..91d1edd9b2ec46 100644
--- a/Doc/c-api/buffer.rst
+++ b/Doc/c-api/buffer.rst
@@ -499,7 +499,7 @@ Buffer-related functions
This function fails if *len* != *src->len*.
-.. c:function:: int PyObject_CopyData(Py_buffer *dest, Py_buffer *src)
+.. c:function:: int PyObject_CopyData(PyObject *dest, PyObject *src)
Copy data from *src* to *dest* buffer. Can convert between C-style and
or Fortran-style buffers.
diff --git a/Doc/conf.py b/Doc/conf.py
index b3da8fa9ec4497..29fb63cbcc8614 100644
--- a/Doc/conf.py
+++ b/Doc/conf.py
@@ -268,7 +268,7 @@
ogp_site_name = 'Python documentation'
ogp_image = '_static/og-image.png'
ogp_custom_meta_tags = [
- '',
- '',
- '',
+ '',
+ '',
+ '',
]
diff --git a/Doc/library/itertools.rst b/Doc/library/itertools.rst
index 95da7166842ee6..d85a17effb04a2 100644
--- a/Doc/library/itertools.rst
+++ b/Doc/library/itertools.rst
@@ -886,9 +886,12 @@ which incur interpreter overhead.
except AttributeError:
# Slow path for general iterables
it = islice(iterable, start, None)
- for i, element in enumerate(it, start):
- if element is value or element == value:
- yield i
+ i = start - 1
+ try:
+ while True:
+ yield (i := i + operator.indexOf(it, value) + 1)
+ except ValueError:
+ pass
else:
# Fast path for sequences
i = start - 1
diff --git a/Doc/library/os.rst b/Doc/library/os.rst
index 85924d0e48366b..23ce98785bedfc 100644
--- a/Doc/library/os.rst
+++ b/Doc/library/os.rst
@@ -201,6 +201,11 @@ process and user.
``'surrogateescape'`` error handler. Use :data:`environb` if you would like
to use a different encoding.
+ On Windows, the keys are converted to uppercase. This also applies when
+ getting, setting, or deleting an item. For example,
+ ``environ['monty'] = 'python'`` maps the key ``'MONTY'`` to the value
+ ``'python'``.
+
.. note::
Calling :func:`putenv` directly does not change :data:`os.environ`, so it's better
diff --git a/Doc/library/pathlib.rst b/Doc/library/pathlib.rst
index c8a734ecad8e7b..8e91936680fab8 100644
--- a/Doc/library/pathlib.rst
+++ b/Doc/library/pathlib.rst
@@ -105,8 +105,9 @@ we also call *flavours*:
PurePosixPath('setup.py')
Each element of *pathsegments* can be either a string representing a
- path segment, an object implementing the :class:`os.PathLike` interface
- which returns a string, or another path object::
+ path segment, or an object implementing the :class:`os.PathLike` interface
+ where the :meth:`~os.PathLike.__fspath__` method returns a string,
+ such as another path object::
>>> PurePath('foo', 'some/path', 'bar')
PurePosixPath('foo/some/path/bar')
diff --git a/Doc/library/sqlite3.rst b/Doc/library/sqlite3.rst
index 18d0a5e630f6a9..ff036ad56acba8 100644
--- a/Doc/library/sqlite3.rst
+++ b/Doc/library/sqlite3.rst
@@ -72,7 +72,7 @@ including `cursors`_ and `transactions`_.
First, we need to create a new database and open
a database connection to allow :mod:`!sqlite3` to work with it.
-Call :func:`sqlite3.connect` to to create a connection to
+Call :func:`sqlite3.connect` to create a connection to
the database :file:`tutorial.db` in the current working directory,
implicitly creating it if it does not exist:
diff --git a/Doc/library/stdtypes.rst b/Doc/library/stdtypes.rst
index 1240f80b0f11f0..550f808a16dfaa 100644
--- a/Doc/library/stdtypes.rst
+++ b/Doc/library/stdtypes.rst
@@ -530,12 +530,14 @@ class`. In addition, it provides a few more methods:
is ``False``.
The default values can be used to conveniently turn an integer into a
- single byte object. However, when using the default arguments, don't try
- to convert a value greater than 255 or you'll get an :exc:`OverflowError`::
+ single byte object::
>>> (65).to_bytes()
b'A'
+ However, when using the default arguments, don't try
+ to convert a value greater than 255 or you'll get an :exc:`OverflowError`.
+
Equivalent to::
def to_bytes(n, length=1, byteorder='big', signed=False):
diff --git a/Doc/library/test.rst b/Doc/library/test.rst
index 8199a27d7d9c4e..c60b4da75d1acb 100644
--- a/Doc/library/test.rst
+++ b/Doc/library/test.rst
@@ -536,6 +536,13 @@ The :mod:`test.support` module defines the following functions:
:func:`doctest.testmod`.
+.. function:: get_pagesize()
+
+ Get size of a page in bytes.
+
+ .. versionadded:: 3.12
+
+
.. function:: setswitchinterval(interval)
Set the :func:`sys.setswitchinterval` to the given *interval*. Defines
diff --git a/Doc/library/typing.rst b/Doc/library/typing.rst
index 3395e4bfb95c44..80a969e6335abe 100644
--- a/Doc/library/typing.rst
+++ b/Doc/library/typing.rst
@@ -1345,7 +1345,7 @@ These are not used in annotations. They are building blocks for creating generic
x: Ts # Not valid
x: tuple[Ts] # Not valid
- x: tuple[*Ts] # The correct way to to do it
+ x: tuple[*Ts] # The correct way to do it
Type variable tuples can be used in the same contexts as normal type
variables. For example, in class definitions, arguments, and return types::
diff --git a/Doc/library/unittest.mock.rst b/Doc/library/unittest.mock.rst
index d6d8e5e9557d5c..6c4d801f69f5a9 100644
--- a/Doc/library/unittest.mock.rst
+++ b/Doc/library/unittest.mock.rst
@@ -72,6 +72,7 @@ available, and then make assertions about how they have been used:
:attr:`side_effect` allows you to perform side effects, including raising an
exception when a mock is called:
+ >>> from unittest.mock import Mock
>>> mock = Mock(side_effect=KeyError('foo'))
>>> mock()
Traceback (most recent call last):
diff --git a/Doc/using/configure.rst b/Doc/using/configure.rst
index 8fa8d250d533c9..8936bd381c9d97 100644
--- a/Doc/using/configure.rst
+++ b/Doc/using/configure.rst
@@ -326,6 +326,11 @@ also be used to improve performance.
Enable C-level code profiling with ``gprof`` (disabled by default).
+.. cmdoption:: --with-strict-overflow
+
+ Add ``-fstrict-overflow`` to the C compiler flags (by default we add
+ ``-fno-strict-overflow`` instead).
+
.. _debug-build:
diff --git a/Include/internal/pycore_compile.h b/Include/internal/pycore_compile.h
index 967fe92a5bc2b2..511f0689c93822 100644
--- a/Include/internal/pycore_compile.h
+++ b/Include/internal/pycore_compile.h
@@ -19,12 +19,6 @@ PyAPI_FUNC(PyCodeObject*) _PyAST_Compile(
int optimize,
struct _arena *arena);
-int _PyFuture_FromAST(
- struct _mod * mod,
- PyObject *filename,
- PyFutureFeatures* futures);
-
-extern PyObject* _Py_Mangle(PyObject *p, PyObject *name);
typedef struct {
int optimize;
diff --git a/Include/internal/pycore_pymath.h b/Include/internal/pycore_pymath.h
index 5f3afe4df6865c..7a4e1c1eb714f7 100644
--- a/Include/internal/pycore_pymath.h
+++ b/Include/internal/pycore_pymath.h
@@ -56,21 +56,6 @@ static inline void _Py_ADJUST_ERANGE2(double x, double y)
}
}
-// Return the maximum value of integral type *type*.
-#define _Py_IntegralTypeMax(type) \
- (_Py_IS_TYPE_SIGNED(type) ? (((((type)1 << (sizeof(type)*CHAR_BIT - 2)) - 1) << 1) + 1) : ~(type)0)
-
-// Return the minimum value of integral type *type*.
-#define _Py_IntegralTypeMin(type) \
- (_Py_IS_TYPE_SIGNED(type) ? -_Py_IntegralTypeMax(type) - 1 : 0)
-
-// Check whether *v* is in the range of integral type *type*. This is most
-// useful if *v* is floating-point, since demoting a floating-point *v* to an
-// integral type that cannot represent *v*'s integral part is undefined
-// behavior.
-#define _Py_InIntegralTypeRange(type, v) \
- (_Py_IntegralTypeMin(type) <= v && v <= _Py_IntegralTypeMax(type))
-
//--- HAVE_PY_SET_53BIT_PRECISION macro ------------------------------------
//
diff --git a/Include/internal/pycore_symtable.h b/Include/internal/pycore_symtable.h
index 97e2cc6469a5bb..9a005be5402c4e 100644
--- a/Include/internal/pycore_symtable.h
+++ b/Include/internal/pycore_symtable.h
@@ -91,6 +91,8 @@ PyAPI_FUNC(PySTEntryObject *) PySymtable_Lookup(struct symtable *, void *);
extern void _PySymtable_Free(struct symtable *);
+extern PyObject* _Py_Mangle(PyObject *p, PyObject *name);
+
/* Flags for def-use information */
#define DEF_GLOBAL 1 /* global stmt */
@@ -129,6 +131,11 @@ extern struct symtable* _Py_SymtableStringObjectFlags(
int start,
PyCompilerFlags *flags);
+int _PyFuture_FromAST(
+ struct _mod * mod,
+ PyObject *filename,
+ PyFutureFeatures* futures);
+
#ifdef __cplusplus
}
#endif
diff --git a/Lib/argparse.py b/Lib/argparse.py
index 240625ff01084e..a819d2650e85f0 100644
--- a/Lib/argparse.py
+++ b/Lib/argparse.py
@@ -403,10 +403,18 @@ def _format_actions_usage(self, actions, groups):
except ValueError:
continue
else:
- end = start + len(group._group_actions)
+ group_action_count = len(group._group_actions)
+ end = start + group_action_count
if actions[start:end] == group._group_actions:
+
+ suppressed_actions_count = 0
for action in group._group_actions:
group_actions.add(action)
+ if action.help is SUPPRESS:
+ suppressed_actions_count += 1
+
+ exposed_actions_count = group_action_count - suppressed_actions_count
+
if not group.required:
if start in inserts:
inserts[start] += ' ['
@@ -416,7 +424,7 @@ def _format_actions_usage(self, actions, groups):
inserts[end] += ']'
else:
inserts[end] = ']'
- else:
+ elif exposed_actions_count > 1:
if start in inserts:
inserts[start] += ' ('
else:
@@ -490,7 +498,6 @@ def _format_actions_usage(self, actions, groups):
text = _re.sub(r'(%s) ' % open, r'\1', text)
text = _re.sub(r' (%s)' % close, r'\1', text)
text = _re.sub(r'%s *%s' % (open, close), r'', text)
- text = _re.sub(r'\(([^|]*)\)', r'\1', text)
text = text.strip()
# return the text
diff --git a/Lib/inspect.py b/Lib/inspect.py
index 8bb3a375735af6..166667c62cdccf 100644
--- a/Lib/inspect.py
+++ b/Lib/inspect.py
@@ -2805,7 +2805,7 @@ def __repr__(self):
return '<{} "{}">'.format(self.__class__.__name__, self)
def __hash__(self):
- return hash((self.name, self.kind, self.annotation, self.default))
+ return hash((self._name, self._kind, self._annotation, self._default))
def __eq__(self, other):
if self is other:
diff --git a/Lib/pathlib.py b/Lib/pathlib.py
index dde573592fddce..d375529ff5f767 100644
--- a/Lib/pathlib.py
+++ b/Lib/pathlib.py
@@ -275,9 +275,20 @@ def __reduce__(self):
def _parse_parts(cls, parts):
if not parts:
return '', '', []
+ elif len(parts) == 1:
+ path = os.fspath(parts[0])
+ else:
+ path = cls._flavour.join(*parts)
sep = cls._flavour.sep
altsep = cls._flavour.altsep
- path = cls._flavour.join(*parts)
+ if isinstance(path, str):
+ # Force-cast str subclasses to str (issue #21127)
+ path = str(path)
+ else:
+ raise TypeError(
+ "argument should be a str or an os.PathLike "
+ "object where __fspath__ returns a str, "
+ f"not {type(path).__name__!r}")
if altsep:
path = path.replace(altsep, sep)
drv, root, rel = cls._flavour.splitroot(path)
@@ -288,32 +299,10 @@ def _parse_parts(cls, parts):
parsed = [sys.intern(x) for x in unfiltered_parsed if x and x != '.']
return drv, root, parsed
- @classmethod
- def _parse_args(cls, args):
- # This is useful when you don't want to create an instance, just
- # canonicalize some constructor arguments.
- parts = []
- for a in args:
- if isinstance(a, PurePath):
- parts += a._parts
- else:
- a = os.fspath(a)
- if isinstance(a, str):
- # Force-cast str subclasses to str (issue #21127)
- parts.append(str(a))
- else:
- raise TypeError(
- "argument should be a str object or an os.PathLike "
- "object returning str, not %r"
- % type(a))
- return cls._parse_parts(parts)
-
@classmethod
def _from_parts(cls, args):
- # We need to call _parse_args on the instance, so as to get the
- # right flavour.
self = object.__new__(cls)
- drv, root, parts = self._parse_args(args)
+ drv, root, parts = self._parse_parts(args)
self._drv = drv
self._root = root
self._parts = parts
@@ -572,7 +561,7 @@ def joinpath(self, *args):
anchored).
"""
drv1, root1, parts1 = self._drv, self._root, self._parts
- drv2, root2, parts2 = self._parse_args(args)
+ drv2, root2, parts2 = self._parse_parts(args)
if root2:
if not drv2 and drv1:
return self._from_parsed_parts(drv1, root2, [drv1 + root2] + parts2[1:])
@@ -659,7 +648,7 @@ def match(self, path_pattern):
return True
# Can't subclass os.PathLike from PurePath and keep the constructor
-# optimizations in PurePath._parse_args().
+# optimizations in PurePath.__slots__.
os.PathLike.register(PurePath)
@@ -704,11 +693,7 @@ def __new__(cls, *args, **kwargs):
warnings._deprecated("pathlib.PurePath(**kwargs)", msg, remove=(3, 14))
if cls is Path:
cls = WindowsPath if os.name == 'nt' else PosixPath
- self = cls._from_parts(args)
- if self._flavour is not os.path:
- raise NotImplementedError("cannot instantiate %r on your system"
- % (cls.__name__,))
- return self
+ return cls._from_parts(args)
def _make_child_relpath(self, part):
# This is an optimization used for dir walking. `part` must be
@@ -1258,9 +1243,19 @@ class PosixPath(Path, PurePosixPath):
"""
__slots__ = ()
+ if os.name == 'nt':
+ def __new__(cls, *args, **kwargs):
+ raise NotImplementedError(
+ f"cannot instantiate {cls.__name__!r} on your system")
+
class WindowsPath(Path, PureWindowsPath):
"""Path subclass for Windows systems.
On a Windows system, instantiating a Path should return this object.
"""
__slots__ = ()
+
+ if os.name != 'nt':
+ def __new__(cls, *args, **kwargs):
+ raise NotImplementedError(
+ f"cannot instantiate {cls.__name__!r} on your system")
diff --git a/Lib/plistlib.py b/Lib/plistlib.py
index 30f3f673ada577..3292c30d5fb29b 100644
--- a/Lib/plistlib.py
+++ b/Lib/plistlib.py
@@ -21,6 +21,9 @@
Generate Plist example:
+ import datetime
+ import plistlib
+
pl = dict(
aString = "Doodah",
aList = ["A", "B", 12, 32.1, [1, 2, 3]],
@@ -28,22 +31,28 @@
anInt = 728,
aDict = dict(
anotherString = "",
- aUnicodeValue = "M\xe4ssig, Ma\xdf",
+ aThirdString = "M\xe4ssig, Ma\xdf",
aTrueValue = True,
aFalseValue = False,
),
someData = b"",
someMoreData = b"" * 10,
- aDate = datetime.datetime.fromtimestamp(time.mktime(time.gmtime())),
+ aDate = datetime.datetime.now()
)
- with open(fileName, 'wb') as fp:
- dump(pl, fp)
+ print(plistlib.dumps(pl).decode())
Parse Plist example:
- with open(fileName, 'rb') as fp:
- pl = load(fp)
- print(pl["aKey"])
+ import plistlib
+
+ plist = b'''
+
+ foo
+ bar
+
+ '''
+ pl = plistlib.loads(plist)
+ print(pl["foo"])
"""
__all__ = [
"InvalidFileException", "FMT_XML", "FMT_BINARY", "load", "dump", "loads", "dumps", "UID"
diff --git a/Lib/tabnanny.py b/Lib/tabnanny.py
index a47f5a96b89722..9d2df59d36ff47 100755
--- a/Lib/tabnanny.py
+++ b/Lib/tabnanny.py
@@ -35,6 +35,7 @@ def errprint(*args):
sys.stderr.write(sep + str(arg))
sep = " "
sys.stderr.write("\n")
+ sys.exit(1)
def main():
import getopt
@@ -44,7 +45,6 @@ def main():
opts, args = getopt.getopt(sys.argv[1:], "qv")
except getopt.error as msg:
errprint(msg)
- return
for o, a in opts:
if o == '-q':
filename_only = filename_only + 1
@@ -52,7 +52,6 @@ def main():
verbose = verbose + 1
if not args:
errprint("Usage:", sys.argv[0], "[-v] file_or_directory ...")
- return
for arg in args:
check(arg)
diff --git a/Lib/test/memory_watchdog.py b/Lib/test/memory_watchdog.py
index 88cca8d323a636..fee062ecc9b300 100644
--- a/Lib/test/memory_watchdog.py
+++ b/Lib/test/memory_watchdog.py
@@ -5,20 +5,13 @@
# If the process crashes, reading from the /proc entry will fail with ESRCH.
-import os
import sys
import time
+from test.support import get_pagesize
-try:
- page_size = os.sysconf('SC_PAGESIZE')
-except (ValueError, AttributeError):
- try:
- page_size = os.sysconf('SC_PAGE_SIZE')
- except (ValueError, AttributeError):
- page_size = 4096
-
while True:
+ page_size = get_pagesize()
sys.stdin.seek(0)
statm = sys.stdin.read()
data = int(statm.split()[5])
diff --git a/Lib/test/support/__init__.py b/Lib/test/support/__init__.py
index 4a22ccdd4db403..c309fd7910e0e6 100644
--- a/Lib/test/support/__init__.py
+++ b/Lib/test/support/__init__.py
@@ -51,6 +51,8 @@
# sys
"is_jython", "is_android", "is_emscripten", "is_wasi",
"check_impl_detail", "unix_shell", "setswitchinterval",
+ # os
+ "get_pagesize",
# network
"open_urlresource",
# processes
@@ -1893,6 +1895,18 @@ def setswitchinterval(interval):
return sys.setswitchinterval(interval)
+def get_pagesize():
+ """Get size of a page in bytes."""
+ try:
+ page_size = os.sysconf('SC_PAGESIZE')
+ except (ValueError, AttributeError):
+ try:
+ page_size = os.sysconf('SC_PAGE_SIZE')
+ except (ValueError, AttributeError):
+ page_size = 4096
+ return page_size
+
+
@contextlib.contextmanager
def disable_faulthandler():
import faulthandler
diff --git a/Lib/test/test_argparse.py b/Lib/test/test_argparse.py
index cabb2f837693ff..861da2326d1214 100644
--- a/Lib/test/test_argparse.py
+++ b/Lib/test/test_argparse.py
@@ -3764,6 +3764,28 @@ class TestHelpUsage(HelpTestCase):
version = ''
+class TestHelpUsageWithParentheses(HelpTestCase):
+ parser_signature = Sig(prog='PROG')
+ argument_signatures = [
+ Sig('positional', metavar='(example) positional'),
+ Sig('-p', '--optional', metavar='{1 (option A), 2 (option B)}'),
+ ]
+
+ usage = '''\
+ usage: PROG [-h] [-p {1 (option A), 2 (option B)}] (example) positional
+ '''
+ help = usage + '''\
+
+ positional arguments:
+ (example) positional
+
+ options:
+ -h, --help show this help message and exit
+ -p {1 (option A), 2 (option B)}, --optional {1 (option A), 2 (option B)}
+ '''
+ version = ''
+
+
class TestHelpOnlyUserGroups(HelpTestCase):
"""Test basic usage messages"""
diff --git a/Lib/test/test_asyncio/test_waitfor.py b/Lib/test/test_asyncio/test_waitfor.py
index ed80540b2b3852..d5c02ba4a01df9 100644
--- a/Lib/test/test_asyncio/test_waitfor.py
+++ b/Lib/test/test_asyncio/test_waitfor.py
@@ -159,7 +159,7 @@ async def test_wait_for_race_condition(self):
fut = loop.create_future()
task = asyncio.wait_for(fut, timeout=0.2)
- loop.call_later(0.1, fut.set_result, "ok")
+ loop.call_soon(fut.set_result, "ok")
res = await task
self.assertEqual(res, "ok")
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index 9e19af0ae90fc1..e7a79bc13b7f3d 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -926,6 +926,16 @@ def test_filter_pickle(self):
f2 = filter(filter_char, "abcdeabcde")
self.check_iter_pickle(f1, list(f2), proto)
+ def test_filter_dealloc(self):
+ # Tests recursive deallocation of nested filter objects using the
+ # thrashcan mechanism. See gh-102356 for more details.
+ max_iters = 1000000
+ i = filter(bool, range(max_iters))
+ for _ in range(max_iters):
+ i = filter(bool, i)
+ del i
+ gc.collect()
+
def test_getattr(self):
self.assertTrue(getattr(sys, 'stdout') is sys.stdout)
self.assertRaises(TypeError, getattr)
diff --git a/Lib/test/test_fcntl.py b/Lib/test/test_fcntl.py
index 26de67d924272a..5da75615b41d79 100644
--- a/Lib/test/test_fcntl.py
+++ b/Lib/test/test_fcntl.py
@@ -6,7 +6,7 @@
import struct
import sys
import unittest
-from test.support import verbose, cpython_only
+from test.support import verbose, cpython_only, get_pagesize
from test.support.import_helper import import_module
from test.support.os_helper import TESTFN, unlink
@@ -201,7 +201,8 @@ def test_fcntl_f_pipesize(self):
# Get the default pipesize with F_GETPIPE_SZ
pipesize_default = fcntl.fcntl(test_pipe_w, fcntl.F_GETPIPE_SZ)
pipesize = pipesize_default // 2 # A new value to detect change.
- if pipesize < 512: # the POSIX minimum
+ pagesize_default = get_pagesize()
+ if pipesize < pagesize_default: # the POSIX minimum
raise unittest.SkipTest(
'default pipesize too small to perform test.')
fcntl.fcntl(test_pipe_w, fcntl.F_SETPIPE_SZ, pipesize)
diff --git a/Lib/test/test_iter.py b/Lib/test/test_iter.py
index 6ab9b7a7230309..30aedb0db3bb3d 100644
--- a/Lib/test/test_iter.py
+++ b/Lib/test/test_iter.py
@@ -348,6 +348,31 @@ def spam(state=[0]):
return i
self.check_iterator(iter(spam, 20), list(range(10)), pickle=False)
+ def test_iter_function_concealing_reentrant_exhaustion(self):
+ # gh-101892: Test two-argument iter() with a function that
+ # exhausts its associated iterator but forgets to either return
+ # a sentinel value or raise StopIteration.
+ HAS_MORE = 1
+ NO_MORE = 2
+
+ def exhaust(iterator):
+ """Exhaust an iterator without raising StopIteration."""
+ list(iterator)
+
+ def spam():
+ # Touching the iterator with exhaust() below will call
+ # spam() once again so protect against recursion.
+ if spam.is_recursive_call:
+ return NO_MORE
+ spam.is_recursive_call = True
+ exhaust(spam.iterator)
+ return HAS_MORE
+
+ spam.is_recursive_call = False
+ spam.iterator = iter(spam, NO_MORE)
+ with self.assertRaises(StopIteration):
+ next(spam.iterator)
+
# Test exception propagation through function iterator
def test_exception_function(self):
def spam(state=[0]):
diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py
index b7e38c23349878..1db738d228b1b9 100644
--- a/Lib/test/test_operator.py
+++ b/Lib/test/test_operator.py
@@ -208,6 +208,9 @@ def test_indexOf(self):
nan = float("nan")
self.assertEqual(operator.indexOf([nan, nan, 21], nan), 0)
self.assertEqual(operator.indexOf([{}, 1, {}, 2], {}), 0)
+ it = iter('leave the iterator at exactly the position after the match')
+ self.assertEqual(operator.indexOf(it, 'a'), 2)
+ self.assertEqual(next(it), 'v')
def test_invert(self):
operator = self.module
diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py
index deea207bfdadd9..792794ca109489 100644
--- a/Lib/test/test_os.py
+++ b/Lib/test/test_os.py
@@ -2221,6 +2221,26 @@ def test_closerange(self):
def test_dup2(self):
self.check(os.dup2, 20)
+ @unittest.skipUnless(hasattr(os, 'dup2'), 'test needs os.dup2()')
+ @unittest.skipIf(
+ support.is_emscripten,
+ "dup2() with negative fds is broken on Emscripten (see gh-102179)"
+ )
+ def test_dup2_negative_fd(self):
+ valid_fd = os.open(__file__, os.O_RDONLY)
+ self.addCleanup(os.close, valid_fd)
+ fds = [
+ valid_fd,
+ -1,
+ -2**31,
+ ]
+ for fd, fd2 in itertools.product(fds, repeat=2):
+ if fd != fd2:
+ with self.subTest(fd=fd, fd2=fd2):
+ with self.assertRaises(OSError) as ctx:
+ os.dup2(fd, fd2)
+ self.assertEqual(ctx.exception.errno, errno.EBADF)
+
@unittest.skipUnless(hasattr(os, 'fchmod'), 'test needs os.fchmod()')
def test_fchmod(self):
self.check(os.fchmod, 0)
diff --git a/Lib/test/test_pathlib.py b/Lib/test/test_pathlib.py
index 4de91d52c6d10c..df9c1f6ba65deb 100644
--- a/Lib/test/test_pathlib.py
+++ b/Lib/test/test_pathlib.py
@@ -166,6 +166,33 @@ def test_constructor_common(self):
self.assertEqual(P(P('a'), P('b')), P('a/b'))
self.assertEqual(P(P('a'), P('b'), P('c')), P(FakePath("a/b/c")))
+ def test_bytes(self):
+ P = self.cls
+ message = (r"argument should be a str or an os\.PathLike object "
+ r"where __fspath__ returns a str, not 'bytes'")
+ with self.assertRaisesRegex(TypeError, message):
+ P(b'a')
+ with self.assertRaises(TypeError):
+ P(b'a', 'b')
+ with self.assertRaises(TypeError):
+ P('a', b'b')
+ with self.assertRaises(TypeError):
+ P('a').joinpath(b'b')
+ with self.assertRaises(TypeError):
+ P('a') / b'b'
+ with self.assertRaises(TypeError):
+ b'a' / P('b')
+ with self.assertRaises(TypeError):
+ P('a').match(b'b')
+ with self.assertRaises(TypeError):
+ P('a').relative_to(b'b')
+ with self.assertRaises(TypeError):
+ P('a').with_name(b'b')
+ with self.assertRaises(TypeError):
+ P('a').with_stem(b'b')
+ with self.assertRaises(TypeError):
+ P('a').with_suffix(b'b')
+
def _check_str_subclass(self, *args):
# Issue #21127: it should be possible to construct a PurePath object
# from a str subclass instance, and it then gets converted to
diff --git a/Lib/test/test_pow.py b/Lib/test/test_pow.py
index 5cea9ceb20f5cc..eeb482ec4b27e2 100644
--- a/Lib/test/test_pow.py
+++ b/Lib/test/test_pow.py
@@ -19,12 +19,11 @@ def powtest(self, type):
self.assertEqual(pow(2, i), pow2)
if i != 30 : pow2 = pow2*2
- for othertype in (int,):
- for i in list(range(-10, 0)) + list(range(1, 10)):
- ii = type(i)
- for j in range(1, 11):
- jj = -othertype(j)
- pow(ii, jj)
+ for i in list(range(-10, 0)) + list(range(1, 10)):
+ ii = type(i)
+ inv = pow(ii, -1) # inverse of ii
+ for jj in range(-10, 0):
+ self.assertAlmostEqual(pow(ii, jj), pow(inv, -jj))
for othertype in int, float:
for i in range(1, 100):
diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py
index 727b0e6dc578c2..3880125807f235 100644
--- a/Lib/test/test_subprocess.py
+++ b/Lib/test/test_subprocess.py
@@ -717,7 +717,8 @@ def test_pipesizes(self):
os.close(test_pipe_r)
os.close(test_pipe_w)
pipesize = pipesize_default // 2
- if pipesize < 512: # the POSIX minimum
+ pagesize_default = support.get_pagesize()
+ if pipesize < pagesize_default: # the POSIX minimum
raise unittest.SkipTest(
'default pipesize too small to perform test.')
p = subprocess.Popen(
diff --git a/Lib/test/test_tabnanny.py b/Lib/test/test_tabnanny.py
index e0a82e95c486be..afb8da719b0eed 100644
--- a/Lib/test/test_tabnanny.py
+++ b/Lib/test/test_tabnanny.py
@@ -110,9 +110,10 @@ def test_errprint(self):
for args, expected in tests:
with self.subTest(arguments=args, expected=expected):
- with captured_stderr() as stderr:
- tabnanny.errprint(*args)
- self.assertEqual(stderr.getvalue() , expected)
+ with self.assertRaises(SystemExit):
+ with captured_stderr() as stderr:
+ tabnanny.errprint(*args)
+ self.assertEqual(stderr.getvalue() , expected)
class TestNannyNag(TestCase):
@@ -203,14 +204,16 @@ def test_when_wrong_indented(self):
err = ('unindent does not match any outer indentation level'
' (, line 3)\n')
err = f"{file_path!r}: Indentation Error: {err}"
- self.verify_tabnanny_check(file_path, err=err)
+ with self.assertRaises(SystemExit):
+ self.verify_tabnanny_check(file_path, err=err)
def test_when_tokenize_tokenerror(self):
"""A python source code file eligible for raising 'tokenize.TokenError'."""
with TemporaryPyFile(SOURCE_CODES["incomplete_expression"]) as file_path:
err = "('EOF in multi-line statement', (7, 0))\n"
err = f"{file_path!r}: Token Error: {err}"
- self.verify_tabnanny_check(file_path, err=err)
+ with self.assertRaises(SystemExit):
+ self.verify_tabnanny_check(file_path, err=err)
def test_when_nannynag_error_verbose(self):
"""A python source code file eligible for raising `tabnanny.NannyNag`.
@@ -236,7 +239,8 @@ def test_when_no_file(self):
path = 'no_file.py'
err = (f"{path!r}: I/O Error: [Errno {errno.ENOENT}] "
f"{os.strerror(errno.ENOENT)}: {path!r}\n")
- self.verify_tabnanny_check(path, err=err)
+ with self.assertRaises(SystemExit):
+ self.verify_tabnanny_check(path, err=err)
def test_errored_directory(self):
"""Directory containing wrongly indented python source code files."""
@@ -251,7 +255,8 @@ def test_errored_directory(self):
err = ('unindent does not match any outer indentation level'
' (, line 3)\n')
err = f"{e_file!r}: Indentation Error: {err}"
- self.verify_tabnanny_check(tmp_dir, err=err)
+ with self.assertRaises(SystemExit):
+ self.verify_tabnanny_check(tmp_dir, err=err)
class TestProcessTokens(TestCase):
@@ -287,9 +292,12 @@ def test_with_errored_codes_samples(self):
class TestCommandLine(TestCase):
"""Tests command line interface of `tabnanny`."""
- def validate_cmd(self, *args, stdout="", stderr="", partial=False):
+ def validate_cmd(self, *args, stdout="", stderr="", partial=False, expect_failure=False):
"""Common function to assert the behaviour of command line interface."""
- _, out, err = script_helper.assert_python_ok('-m', 'tabnanny', *args)
+ if expect_failure:
+ _, out, err = script_helper.assert_python_failure('-m', 'tabnanny', *args)
+ else:
+ _, out, err = script_helper.assert_python_ok('-m', 'tabnanny', *args)
# Note: The `splitlines()` will solve the problem of CRLF(\r) added
# by OS Windows.
out = os.fsdecode(out)
@@ -310,7 +318,7 @@ def test_with_errored_file(self):
stderr = f"{file_path!r}: Indentation Error: "
stderr += ('unindent does not match any outer indentation level'
' (, line 3)')
- self.validate_cmd(file_path, stderr=stderr)
+ self.validate_cmd(file_path, stderr=stderr, expect_failure=True)
def test_with_error_free_file(self):
"""Should not display anything if python file is correctly indented."""
@@ -321,7 +329,7 @@ def test_command_usage(self):
"""Should display usage on no arguments."""
path = findfile('tabnanny.py')
stderr = f"Usage: {path} [-v] file_or_directory ..."
- self.validate_cmd(stderr=stderr)
+ self.validate_cmd(stderr=stderr, expect_failure=True)
def test_quiet_flag(self):
"""Should display less when quite mode is on."""
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
index d61dc6e2fbd70b..0483ca3aa42f94 100644
--- a/Lib/test/test_typing.py
+++ b/Lib/test/test_typing.py
@@ -473,7 +473,6 @@ def test_var_substitution(self):
def test_bad_var_substitution(self):
T = TypeVar('T')
- P = ParamSpec("P")
bad_args = (
(), (int, str), Union,
Generic, Generic[T], Protocol, Protocol[T],
@@ -1037,8 +1036,6 @@ class G2(Generic[Unpack[Ts]]): pass
def test_repr_is_correct(self):
Ts = TypeVarTuple('Ts')
- T = TypeVar('T')
- T2 = TypeVar('T2')
class G1(Generic[*Ts]): pass
class G2(Generic[Unpack[Ts]]): pass
@@ -1307,7 +1304,7 @@ def test_callable_args_are_correct(self):
i = Callable[[None], *Ts]
j = Callable[[None], Unpack[Ts]]
self.assertEqual(i.__args__, (type(None), *Ts))
- self.assertEqual(i.__args__, (type(None), Unpack[Ts]))
+ self.assertEqual(j.__args__, (type(None), Unpack[Ts]))
k = Callable[[None], tuple[int, *Ts]]
l = Callable[[None], Tuple[int, Unpack[Ts]]]
@@ -1435,8 +1432,6 @@ def g(*args: *Ts): pass
self.assertEqual(g.__annotations__, {'args': (*Ts,)[0]})
def test_variadic_args_with_ellipsis_annotations_are_correct(self):
- Ts = TypeVarTuple('Ts')
-
def a(*args: *tuple[int, ...]): pass
self.assertEqual(a.__annotations__,
{'args': (*tuple[int, ...],)[0]})
@@ -2921,8 +2916,8 @@ class DI:
def __init__(self):
self.x = None
- self.assertIsInstance(C(), P)
- self.assertIsInstance(D(), P)
+ self.assertIsInstance(CI(), P)
+ self.assertIsInstance(DI(), P)
def test_protocols_in_unions(self):
class P(Protocol):
@@ -4171,38 +4166,129 @@ class OverrideDecoratorTests(BaseTestCase):
def test_override(self):
class Base:
def normal_method(self): ...
+ @classmethod
+ def class_method_good_order(cls): ...
+ @classmethod
+ def class_method_bad_order(cls): ...
@staticmethod
def static_method_good_order(): ...
@staticmethod
def static_method_bad_order(): ...
- @staticmethod
- def decorator_with_slots(): ...
class Derived(Base):
@override
def normal_method(self):
return 42
+ @classmethod
+ @override
+ def class_method_good_order(cls):
+ return 42
+ @override
+ @classmethod
+ def class_method_bad_order(cls):
+ return 42
+
@staticmethod
@override
def static_method_good_order():
return 42
-
@override
@staticmethod
def static_method_bad_order():
return 42
-
self.assertIsSubclass(Derived, Base)
instance = Derived()
self.assertEqual(instance.normal_method(), 42)
+ self.assertIs(True, Derived.normal_method.__override__)
self.assertIs(True, instance.normal_method.__override__)
+
+ self.assertEqual(Derived.class_method_good_order(), 42)
+ self.assertIs(True, Derived.class_method_good_order.__override__)
+ self.assertEqual(Derived.class_method_bad_order(), 42)
+ self.assertIs(False, hasattr(Derived.class_method_bad_order, "__override__"))
+
self.assertEqual(Derived.static_method_good_order(), 42)
self.assertIs(True, Derived.static_method_good_order.__override__)
self.assertEqual(Derived.static_method_bad_order(), 42)
self.assertIs(False, hasattr(Derived.static_method_bad_order, "__override__"))
+ # Base object is not changed:
+ self.assertIs(False, hasattr(Base.normal_method, "__override__"))
+ self.assertIs(False, hasattr(Base.class_method_good_order, "__override__"))
+ self.assertIs(False, hasattr(Base.class_method_bad_order, "__override__"))
+ self.assertIs(False, hasattr(Base.static_method_good_order, "__override__"))
+ self.assertIs(False, hasattr(Base.static_method_bad_order, "__override__"))
+
+ def test_property(self):
+ class Base:
+ @property
+ def correct(self) -> int:
+ return 1
+ @property
+ def wrong(self) -> int:
+ return 1
+
+ class Child(Base):
+ @property
+ @override
+ def correct(self) -> int:
+ return 2
+ @override
+ @property
+ def wrong(self) -> int:
+ return 2
+
+ instance = Child()
+ self.assertEqual(instance.correct, 2)
+ self.assertTrue(Child.correct.fget.__override__)
+ self.assertEqual(instance.wrong, 2)
+ self.assertFalse(hasattr(Child.wrong, "__override__"))
+ self.assertFalse(hasattr(Child.wrong.fset, "__override__"))
+
+ def test_silent_failure(self):
+ class CustomProp:
+ __slots__ = ('fget',)
+ def __init__(self, fget):
+ self.fget = fget
+ def __get__(self, obj, objtype=None):
+ return self.fget(obj)
+
+ class WithOverride:
+ @override # must not fail on object with `__slots__`
+ @CustomProp
+ def some(self):
+ return 1
+
+ self.assertEqual(WithOverride.some, 1)
+ self.assertFalse(hasattr(WithOverride.some, "__override__"))
+
+ def test_multiple_decorators(self):
+ import functools
+
+ def with_wraps(f): # similar to `lru_cache` definition
+ @functools.wraps(f)
+ def wrapper(*args, **kwargs):
+ return f(*args, **kwargs)
+ return wrapper
+
+ class WithOverride:
+ @override
+ @with_wraps
+ def on_top(self, a: int) -> int:
+ return a + 1
+ @with_wraps
+ @override
+ def on_bottom(self, a: int) -> int:
+ return a + 2
+
+ instance = WithOverride()
+ self.assertEqual(instance.on_top(1), 2)
+ self.assertTrue(instance.on_top.__override__)
+ self.assertEqual(instance.on_bottom(1), 3)
+ self.assertTrue(instance.on_bottom.__override__)
+
class CastTests(BaseTestCase):
@@ -4827,7 +4913,6 @@ def test_overload_registry_repeated(self):
# Definitions needed for features introduced in Python 3.6
from test import ann_module, ann_module2, ann_module3, ann_module5, ann_module6
-import asyncio
T_a = TypeVar('T_a')
@@ -6986,16 +7071,6 @@ class C:
self.assertEqual(get_type_hints(C, globals())['classvar'], ClassVar[int])
self.assertEqual(get_type_hints(C, globals())['const'], Final[int])
- def test_hash_eq(self):
- self.assertEqual(len({Annotated[int, 4, 5], Annotated[int, 4, 5]}), 1)
- self.assertNotEqual(Annotated[int, 4, 5], Annotated[int, 5, 4])
- self.assertNotEqual(Annotated[int, 4, 5], Annotated[str, 4, 5])
- self.assertNotEqual(Annotated[int, 4], Annotated[int, 4, 4])
- self.assertEqual(
- {Annotated[int, 4, 5], Annotated[int, 4, 5], Annotated[T, 4, 5]},
- {Annotated[int, 4, 5], Annotated[T, 4, 5]}
- )
-
def test_cannot_subclass(self):
with self.assertRaisesRegex(TypeError, "Cannot subclass .*Annotated"):
class C(Annotated):
@@ -7424,7 +7499,6 @@ class Y(Generic[P, T]):
self.assertEqual(B.__args__, ((int, str,), Tuple[bytes, float]))
def test_var_substitution(self):
- T = TypeVar("T")
P = ParamSpec("P")
subst = P.__typing_subst__
self.assertEqual(subst((int, str)), (int, str))
@@ -7744,7 +7818,7 @@ def test_special_attrs2(self):
self.assertEqual(fr.__module__, 'typing')
# Forward refs are currently unpicklable.
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
- with self.assertRaises(TypeError) as exc:
+ with self.assertRaises(TypeError):
pickle.dumps(fr, proto)
self.assertEqual(SpecialAttrsTests.TypeName.__name__, 'TypeName')
diff --git a/Lib/zoneinfo/_zoneinfo.py b/Lib/zoneinfo/_zoneinfo.py
index de68380792f17c..eede15b8271058 100644
--- a/Lib/zoneinfo/_zoneinfo.py
+++ b/Lib/zoneinfo/_zoneinfo.py
@@ -302,7 +302,7 @@ def _utcoff_to_dstoff(trans_idx, utcoffsets, isdsts):
# difference between utcoffset() and the "standard" offset, but
# the "base offset" and "DST offset" are not encoded in the file;
# we can infer what they are from the isdst flag, but it is not
- # sufficient to to just look at the last standard offset, because
+ # sufficient to just look at the last standard offset, because
# occasionally countries will shift both DST offset and base offset.
typecnt = len(isdsts)
diff --git a/Makefile.pre.in b/Makefile.pre.in
index b12a1bc060af90..1a1853bf3d7871 100644
--- a/Makefile.pre.in
+++ b/Makefile.pre.in
@@ -1485,9 +1485,9 @@ regen-cases:
PYTHONPATH=$(srcdir)/Tools/cases_generator \
$(PYTHON_FOR_REGEN) \
$(srcdir)/Tools/cases_generator/generate_cases.py \
- -i $(srcdir)/Python/bytecodes.c \
-o $(srcdir)/Python/generated_cases.c.h.new \
- -m $(srcdir)/Python/opcode_metadata.h.new
+ -m $(srcdir)/Python/opcode_metadata.h.new \
+ $(srcdir)/Python/bytecodes.c
$(UPDATE_FILE) $(srcdir)/Python/generated_cases.c.h $(srcdir)/Python/generated_cases.c.h.new
$(UPDATE_FILE) $(srcdir)/Python/opcode_metadata.h $(srcdir)/Python/opcode_metadata.h.new
diff --git a/Misc/ACKS b/Misc/ACKS
index 2da3d0ab29b81d..7bbde3af99782b 100644
--- a/Misc/ACKS
+++ b/Misc/ACKS
@@ -322,6 +322,7 @@ Adal Chiriliuc
Matt Chisholm
Lita Cho
Kit Yan Choi
+Byeongmin Choi
Sayan Chowdhury
Yuan-Chao Chou
Anders Chrigström
@@ -636,6 +637,7 @@ Tim Golden
Yonatan Goldschmidt
Mark Gollahon
Mikhail Golubev
+Marta Gómez Macías
Guilherme Gonçalves
Tiago Gonçalves
Chris Gonnerman
diff --git a/Misc/NEWS.d/next/Build/2022-09-14-10-38-15.gh-issue-96821.Zk2a9c.rst b/Misc/NEWS.d/next/Build/2022-09-14-10-38-15.gh-issue-96821.Zk2a9c.rst
new file mode 100644
index 00000000000000..865cfde8b06359
--- /dev/null
+++ b/Misc/NEWS.d/next/Build/2022-09-14-10-38-15.gh-issue-96821.Zk2a9c.rst
@@ -0,0 +1,3 @@
+Explicitly mark C extension modules that need defined signed integer overflow,
+and add a configure option :option:`--with-strict-overflow`.
+Patch by Matthias Görgens and Shantanu Jain.
diff --git a/Misc/NEWS.d/next/Core and Builtins/2023-02-28-21-17-03.gh-issue-102336.-wL3Tm.rst b/Misc/NEWS.d/next/Core and Builtins/2023-02-28-21-17-03.gh-issue-102336.-wL3Tm.rst
new file mode 100644
index 00000000000000..0c3e4bd4b86094
--- /dev/null
+++ b/Misc/NEWS.d/next/Core and Builtins/2023-02-28-21-17-03.gh-issue-102336.-wL3Tm.rst
@@ -0,0 +1 @@
+Cleanup Windows 7 specific special handling. Patch by Max Bachmann.
diff --git a/Misc/NEWS.d/next/Core and Builtins/2023-03-04-20-56-12.gh-issue-102356.07KvUd.rst b/Misc/NEWS.d/next/Core and Builtins/2023-03-04-20-56-12.gh-issue-102356.07KvUd.rst
new file mode 100644
index 00000000000000..c03fd5266bc301
--- /dev/null
+++ b/Misc/NEWS.d/next/Core and Builtins/2023-03-04-20-56-12.gh-issue-102356.07KvUd.rst
@@ -0,0 +1,2 @@
+Fix a bug that caused a crash when deallocating deeply nested filter
+objects. Patch by Marta Gómez Macías.
diff --git a/Misc/NEWS.d/next/Core and Builtins/2023-03-06-13-05-33.gh-issue-102416.dz6K5f.rst b/Misc/NEWS.d/next/Core and Builtins/2023-03-06-13-05-33.gh-issue-102416.dz6K5f.rst
new file mode 100644
index 00000000000000..9ffc67cfb7ed56
--- /dev/null
+++ b/Misc/NEWS.d/next/Core and Builtins/2023-03-06-13-05-33.gh-issue-102416.dz6K5f.rst
@@ -0,0 +1 @@
+Do not memoize incorrectly automatically generated loop rules in the parser. Patch by Pablo Galindo.
diff --git a/Misc/NEWS.d/next/Library/2023-02-01-10-42-16.gh-issue-63301.XNxSFh.rst b/Misc/NEWS.d/next/Library/2023-02-01-10-42-16.gh-issue-63301.XNxSFh.rst
new file mode 100644
index 00000000000000..e00e71fb8554f3
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2023-02-01-10-42-16.gh-issue-63301.XNxSFh.rst
@@ -0,0 +1 @@
+Set exit code when :mod:`tabnanny` CLI exits on error.
diff --git a/Misc/NEWS.d/next/Library/2023-02-07-20-46-08.gh-issue-101362.2ckZ6R.rst b/Misc/NEWS.d/next/Library/2023-02-07-20-46-08.gh-issue-101362.2ckZ6R.rst
new file mode 100644
index 00000000000000..8421466cdbb3c9
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2023-02-07-20-46-08.gh-issue-101362.2ckZ6R.rst
@@ -0,0 +1,2 @@
+Speed up :class:`pathlib.Path` construction by running the path flavour
+compatibility check only when pathlib is imported.
diff --git a/Misc/NEWS.d/next/Library/2023-02-07-21-16-41.gh-issue-101362.KMQllM.rst b/Misc/NEWS.d/next/Library/2023-02-07-21-16-41.gh-issue-101362.KMQllM.rst
new file mode 100644
index 00000000000000..af4ee9ad904868
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2023-02-07-21-16-41.gh-issue-101362.KMQllM.rst
@@ -0,0 +1,2 @@
+Speed up :class:`pathlib.PurePath` construction by calling
+:func:`os.path.join` only when two or more arguments are given.
diff --git a/Misc/NEWS.d/next/Library/2023-02-07-22-20-32.gh-issue-101362.Jlk6mt.rst b/Misc/NEWS.d/next/Library/2023-02-07-22-20-32.gh-issue-101362.Jlk6mt.rst
new file mode 100644
index 00000000000000..c05f92ae699de9
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2023-02-07-22-20-32.gh-issue-101362.Jlk6mt.rst
@@ -0,0 +1,4 @@
+Speed up :class:`pathlib.PurePath` construction by handling arguments more
+uniformly. When a :class:`pathlib.Path` argument is supplied,
+we use its string representation rather than joining its parts
+with :func:`os.path.join`.
diff --git a/Misc/NEWS.d/next/Library/2023-02-14-09-08-48.gh-issue-101892.FMos8l.rst b/Misc/NEWS.d/next/Library/2023-02-14-09-08-48.gh-issue-101892.FMos8l.rst
new file mode 100644
index 00000000000000..d586779b3a8a36
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2023-02-14-09-08-48.gh-issue-101892.FMos8l.rst
@@ -0,0 +1,3 @@
+Callable iterators no longer raise :class:`SystemError` when the
+callable object exhausts the iterator but forgets to either return a
+sentinel value or raise :class:`StopIteration`.
diff --git a/Misc/NEWS.d/next/Library/2023-02-23-15-06-01.gh-issue-102179.P6KQ4c.rst b/Misc/NEWS.d/next/Library/2023-02-23-15-06-01.gh-issue-102179.P6KQ4c.rst
new file mode 100644
index 00000000000000..f77493e267ac7e
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2023-02-23-15-06-01.gh-issue-102179.P6KQ4c.rst
@@ -0,0 +1 @@
+Fix :func:`os.dup2` error message for negative fds.
diff --git a/Misc/NEWS.d/next/Library/2023-02-28-09-52-25.gh-issue-101979.or3hXV.rst b/Misc/NEWS.d/next/Library/2023-02-28-09-52-25.gh-issue-101979.or3hXV.rst
new file mode 100644
index 00000000000000..1efe72439b3a4a
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2023-02-28-09-52-25.gh-issue-101979.or3hXV.rst
@@ -0,0 +1,2 @@
+Fix a bug where parentheses in the ``metavar`` argument to :meth:`argparse.ArgumentParser.add_argument` were
+dropped. Patch by Yeojin Kim.
diff --git a/Misc/NEWS.d/next/Library/2023-03-04-14-46-47.gh-issue-102302.-b_s6Z.rst b/Misc/NEWS.d/next/Library/2023-03-04-14-46-47.gh-issue-102302.-b_s6Z.rst
new file mode 100644
index 00000000000000..aaf4e62069ca24
--- /dev/null
+++ b/Misc/NEWS.d/next/Library/2023-03-04-14-46-47.gh-issue-102302.-b_s6Z.rst
@@ -0,0 +1 @@
+Micro-optimise hashing of :class:`inspect.Parameter`, reducing the time it takes to hash an instance by around 40%.
diff --git a/Misc/NEWS.d/next/Windows/2023-03-01-01-36-39.gh-issue-102344.Dgfux4.rst b/Misc/NEWS.d/next/Windows/2023-03-01-01-36-39.gh-issue-102344.Dgfux4.rst
new file mode 100644
index 00000000000000..4804212be8182c
--- /dev/null
+++ b/Misc/NEWS.d/next/Windows/2023-03-01-01-36-39.gh-issue-102344.Dgfux4.rst
@@ -0,0 +1,2 @@
+Implement ``winreg.QueryValue`` using ``QueryValueEx`` and
+``winreg.SetValue`` using ``SetValueEx``. Patch by Max Bachmann.
diff --git a/Modules/_testcapi/code.c b/Modules/_testcapi/code.c
index 588dc67971ea5a..84c668cd6b3b00 100644
--- a/Modules/_testcapi/code.c
+++ b/Modules/_testcapi/code.c
@@ -92,7 +92,11 @@ test_code_extra(PyObject* self, PyObject *Py_UNUSED(callable))
goto finally;
}
assert ((uintptr_t)extra == 77);
-
+ // Revert to initial code extra value.
+ res = PyUnstable_Code_SetExtra(test_func_code, code_extra_index, NULL);
+ if (res < 0) {
+ goto finally;
+ }
result = Py_NewRef(Py_None);
finally:
Py_XDECREF(test_module);
diff --git a/Modules/_tkinter.c b/Modules/_tkinter.c
index d4a129058702a2..1608939766ffb6 100644
--- a/Modules/_tkinter.c
+++ b/Modules/_tkinter.c
@@ -321,8 +321,6 @@ static PyObject *Tkinter_TclError;
static int quitMainLoop = 0;
static int errorInCmd = 0;
static PyObject *excInCmd;
-static PyObject *valInCmd;
-static PyObject *trbInCmd;
#ifdef TKINTER_PROTECT_LOADTK
static int tk_load_failed = 0;
@@ -1222,7 +1220,7 @@ typedef struct Tkapp_CallEvent {
PyObject *args;
int flags;
PyObject **res;
- PyObject **exc_type, **exc_value, **exc_tb;
+ PyObject **exc;
Tcl_Condition *done;
} Tkapp_CallEvent;
@@ -1339,7 +1337,7 @@ Tkapp_CallProc(Tkapp_CallEvent *e, int flags)
ENTER_PYTHON
objv = Tkapp_CallArgs(e->args, objStore, &objc);
if (!objv) {
- PyErr_Fetch(e->exc_type, e->exc_value, e->exc_tb);
+ *(e->exc) = PyErr_GetRaisedException();
*(e->res) = NULL;
}
LEAVE_PYTHON
@@ -1354,7 +1352,7 @@ Tkapp_CallProc(Tkapp_CallEvent *e, int flags)
*(e->res) = Tkapp_ObjectResult(e->self);
}
if (*(e->res) == NULL) {
- PyErr_Fetch(e->exc_type, e->exc_value, e->exc_tb);
+ *(e->exc) = PyErr_GetRaisedException();
}
LEAVE_PYTHON
@@ -1401,7 +1399,7 @@ Tkapp_Call(PyObject *selfptr, PyObject *args)
marshal the parameters to the interpreter thread. */
Tkapp_CallEvent *ev;
Tcl_Condition cond = NULL;
- PyObject *exc_type, *exc_value, *exc_tb;
+ PyObject *exc;
if (!WaitForMainloop(self))
return NULL;
ev = (Tkapp_CallEvent*)attemptckalloc(sizeof(Tkapp_CallEvent));
@@ -1413,18 +1411,18 @@ Tkapp_Call(PyObject *selfptr, PyObject *args)
ev->self = self;
ev->args = args;
ev->res = &res;
- ev->exc_type = &exc_type;
- ev->exc_value = &exc_value;
- ev->exc_tb = &exc_tb;
+ ev->exc = &exc;
ev->done = &cond;
Tkapp_ThreadSend(self, (Tcl_Event*)ev, &cond, &call_mutex);
if (res == NULL) {
- if (exc_type)
- PyErr_Restore(exc_type, exc_value, exc_tb);
- else
- PyErr_SetObject(Tkinter_TclError, exc_value);
+ if (exc) {
+ PyErr_SetRaisedException(exc);
+ }
+ else {
+ PyErr_SetObject(Tkinter_TclError, exc);
+ }
}
Tcl_ConditionFinalize(&cond);
}
@@ -1578,8 +1576,7 @@ typedef struct VarEvent {
int flags;
EventFunc func;
PyObject **res;
- PyObject **exc_type;
- PyObject **exc_val;
+ PyObject **exc;
Tcl_Condition *cond;
} VarEvent;
@@ -1643,12 +1640,7 @@ var_perform(VarEvent *ev)
{
*(ev->res) = ev->func(ev->self, ev->args, ev->flags);
if (!*(ev->res)) {
- PyObject *exc, *val, *tb;
- PyErr_Fetch(&exc, &val, &tb);
- PyErr_NormalizeException(&exc, &val, &tb);
- *(ev->exc_type) = exc;
- *(ev->exc_val) = val;
- Py_XDECREF(tb);
+ *(ev->exc) = PyErr_GetRaisedException();;
}
}
@@ -1672,7 +1664,7 @@ var_invoke(EventFunc func, PyObject *selfptr, PyObject *args, int flags)
TkappObject *self = (TkappObject*)selfptr;
if (self->threaded && self->thread_id != Tcl_GetCurrentThread()) {
VarEvent *ev;
- PyObject *res, *exc_type, *exc_val;
+ PyObject *res, *exc;
Tcl_Condition cond = NULL;
/* The current thread is not the interpreter thread. Marshal
@@ -1691,16 +1683,14 @@ var_invoke(EventFunc func, PyObject *selfptr, PyObject *args, int flags)
ev->flags = flags;
ev->func = func;
ev->res = &res;
- ev->exc_type = &exc_type;
- ev->exc_val = &exc_val;
+ ev->exc = &exc;
ev->cond = &cond;
ev->ev.proc = (Tcl_EventProc*)var_proc;
Tkapp_ThreadSend(self, (Tcl_Event*)ev, &cond, &var_mutex);
Tcl_ConditionFinalize(&cond);
if (!res) {
- PyErr_SetObject(exc_type, exc_val);
- Py_DECREF(exc_type);
- Py_DECREF(exc_val);
+ PyErr_SetObject((PyObject*)Py_TYPE(exc), exc);
+ Py_DECREF(exc);
return NULL;
}
return res;
@@ -2188,7 +2178,7 @@ static int
PythonCmd_Error(Tcl_Interp *interp)
{
errorInCmd = 1;
- PyErr_Fetch(&excInCmd, &valInCmd, &trbInCmd);
+ excInCmd = PyErr_GetRaisedException();
LEAVE_PYTHON
return TCL_ERROR;
}
@@ -2458,7 +2448,7 @@ FileHandler(ClientData clientData, int mask)
res = PyObject_CallFunction(func, "Oi", file, mask);
if (res == NULL) {
errorInCmd = 1;
- PyErr_Fetch(&excInCmd, &valInCmd, &trbInCmd);
+ excInCmd = PyErr_GetRaisedException();
}
Py_XDECREF(res);
LEAVE_PYTHON
@@ -2628,7 +2618,7 @@ TimerHandler(ClientData clientData)
if (res == NULL) {
errorInCmd = 1;
- PyErr_Fetch(&excInCmd, &valInCmd, &trbInCmd);
+ excInCmd = PyErr_GetRaisedException();
}
else
Py_DECREF(res);
@@ -2725,8 +2715,8 @@ _tkinter_tkapp_mainloop_impl(TkappObject *self, int threshold)
if (errorInCmd) {
errorInCmd = 0;
- PyErr_Restore(excInCmd, valInCmd, trbInCmd);
- excInCmd = valInCmd = trbInCmd = NULL;
+ PyErr_SetRaisedException(excInCmd);
+ excInCmd = NULL;
return NULL;
}
Py_RETURN_NONE;
@@ -3187,8 +3177,8 @@ EventHook(void)
#endif
if (errorInCmd) {
errorInCmd = 0;
- PyErr_Restore(excInCmd, valInCmd, trbInCmd);
- excInCmd = valInCmd = trbInCmd = NULL;
+ PyErr_SetRaisedException(excInCmd);
+ excInCmd = NULL;
PyErr_Print();
}
PyEval_SaveThread();
diff --git a/Modules/_winapi.c b/Modules/_winapi.c
index f4d982b15d402a..eefc2571ee8287 100644
--- a/Modules/_winapi.c
+++ b/Modules/_winapi.c
@@ -63,23 +63,6 @@
#define T_HANDLE T_POINTER
-/* Grab CancelIoEx dynamically from kernel32 */
-static int has_CancelIoEx = -1;
-static BOOL (CALLBACK *Py_CancelIoEx)(HANDLE, LPOVERLAPPED);
-
-static int
-check_CancelIoEx()
-{
- if (has_CancelIoEx == -1)
- {
- HINSTANCE hKernel32 = GetModuleHandle("KERNEL32");
- * (FARPROC *) &Py_CancelIoEx = GetProcAddress(hKernel32,
- "CancelIoEx");
- has_CancelIoEx = (Py_CancelIoEx != NULL);
- }
- return has_CancelIoEx;
-}
-
typedef struct {
PyTypeObject *overlapped_type;
} WinApiState;
@@ -134,8 +117,7 @@ overlapped_dealloc(OverlappedObject *self)
PyObject_GC_UnTrack(self);
if (self->pending) {
- if (check_CancelIoEx() &&
- Py_CancelIoEx(self->handle, &self->overlapped) &&
+ if (CancelIoEx(self->handle, &self->overlapped) &&
GetOverlappedResult(self->handle, &self->overlapped, &bytes, TRUE))
{
/* The operation is no longer pending -- nothing to do. */
@@ -306,10 +288,7 @@ _winapi_Overlapped_cancel_impl(OverlappedObject *self)
if (self->pending) {
Py_BEGIN_ALLOW_THREADS
- if (check_CancelIoEx())
- res = Py_CancelIoEx(self->handle, &self->overlapped);
- else
- res = CancelIo(self->handle);
+ res = CancelIoEx(self->handle, &self->overlapped);
Py_END_ALLOW_THREADS
}
@@ -655,8 +634,10 @@ _winapi_CreateJunction_impl(PyObject *module, LPCWSTR src_path,
cleanup:
ret = GetLastError();
- CloseHandle(token);
- CloseHandle(junction);
+ if (token != NULL)
+ CloseHandle(token);
+ if (junction != NULL)
+ CloseHandle(junction);
PyMem_RawFree(rdb);
if (ret != 0)
diff --git a/Modules/_xxsubinterpretersmodule.c b/Modules/_xxsubinterpretersmodule.c
index 461c505c092c70..79dbe3474ba9e8 100644
--- a/Modules/_xxsubinterpretersmodule.c
+++ b/Modules/_xxsubinterpretersmodule.c
@@ -61,9 +61,9 @@ add_new_exception(PyObject *mod, const char *name, PyObject *base)
static int
_release_xid_data(_PyCrossInterpreterData *data, int ignoreexc)
{
- PyObject *exctype, *excval, *exctb;
+ PyObject *exc;
if (ignoreexc) {
- PyErr_Fetch(&exctype, &excval, &exctb);
+ exc = PyErr_GetRaisedException();
}
int res = _PyCrossInterpreterData_Release(data);
if (res < 0) {
@@ -84,7 +84,7 @@ _release_xid_data(_PyCrossInterpreterData *data, int ignoreexc)
}
}
if (ignoreexc) {
- PyErr_Restore(exctype, excval, exctb);
+ PyErr_SetRaisedException(exc);
}
return res;
}
@@ -294,9 +294,9 @@ _sharedexception_free(_sharedexception *exc)
}
static _sharedexception *
-_sharedexception_bind(PyObject *exctype, PyObject *exc, PyObject *tb)
+_sharedexception_bind(PyObject *exc)
{
- assert(exctype != NULL);
+ assert(exc != NULL);
char *failure = NULL;
_sharedexception *err = _sharedexception_new();
@@ -304,7 +304,7 @@ _sharedexception_bind(PyObject *exctype, PyObject *exc, PyObject *tb)
goto finally;
}
- PyObject *name = PyUnicode_FromFormat("%S", exctype);
+ PyObject *name = PyUnicode_FromFormat("%S", Py_TYPE(exc));
if (name == NULL) {
failure = "unable to format exception type name";
goto finally;
@@ -432,10 +432,7 @@ static int
_run_script(PyInterpreterState *interp, const char *codestr,
_sharedns *shared, _sharedexception **exc)
{
- PyObject *exctype = NULL;
PyObject *excval = NULL;
- PyObject *tb = NULL;
-
PyObject *main_mod = _PyInterpreterState_GetMainModule(interp);
if (main_mod == NULL) {
goto error;
@@ -469,12 +466,9 @@ _run_script(PyInterpreterState *interp, const char *codestr,
return 0;
error:
- PyErr_Fetch(&exctype, &excval, &tb);
-
- _sharedexception *sharedexc = _sharedexception_bind(exctype, excval, tb);
- Py_XDECREF(exctype);
+ excval = PyErr_GetRaisedException();
+ _sharedexception *sharedexc = _sharedexception_bind(excval);
Py_XDECREF(excval);
- Py_XDECREF(tb);
if (sharedexc == NULL) {
fprintf(stderr, "RunFailedError: script raised an uncaught exception");
PyErr_Clear();
diff --git a/Modules/cjkcodecs/_codecs_kr.c b/Modules/cjkcodecs/_codecs_kr.c
index 6d6acb5c4be4b5..72641e495af0b0 100644
--- a/Modules/cjkcodecs/_codecs_kr.c
+++ b/Modules/cjkcodecs/_codecs_kr.c
@@ -60,7 +60,7 @@ ENCODER(euc_kr)
}
else {
/* Mapping is found in CP949 extension,
- but we encode it in KS X 1001:1998 Annex 3,
+ but we encode it in KS X 1001:1998,
make-up sequence for EUC-KR. */
REQUIRE_OUTBUF(8);
@@ -120,7 +120,7 @@ DECODER(euc_kr)
if (c == EUCKR_JAMO_FIRSTBYTE &&
INBYTE2 == EUCKR_JAMO_FILLER) {
- /* KS X 1001:1998 Annex 3 make-up sequence */
+ /* KS X 1001:1998 make-up sequence */
DBCHAR cho, jung, jong;
REQUIRE_INBUF(8);
diff --git a/Modules/getpath.c b/Modules/getpath.c
index 13db010649fed8..c807a3c8e9a2b9 100644
--- a/Modules/getpath.c
+++ b/Modules/getpath.c
@@ -227,12 +227,11 @@ getpath_isxfile(PyObject *Py_UNUSED(self), PyObject *args)
path = PyUnicode_AsWideCharString(pathobj, &cchPath);
if (path) {
#ifdef MS_WINDOWS
- const wchar_t *ext;
DWORD attr = GetFileAttributesW(path);
r = (attr != INVALID_FILE_ATTRIBUTES) &&
!(attr & FILE_ATTRIBUTE_DIRECTORY) &&
- SUCCEEDED(PathCchFindExtension(path, cchPath + 1, &ext)) &&
- (CompareStringOrdinal(ext, -1, L".exe", -1, 1 /* ignore case */) == CSTR_EQUAL)
+ (cchPath >= 4) &&
+ (CompareStringOrdinal(path + cchPath - 4, -1, L".exe", -1, 1 /* ignore case */) == CSTR_EQUAL)
? Py_True : Py_False;
#else
struct stat st;
diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c
index a01e798265c5a5..6054c2853d7a78 100644
--- a/Modules/mmapmodule.c
+++ b/Modules/mmapmodule.c
@@ -502,7 +502,7 @@ mmap_resize_method(mmap_object *self,
CloseHandle(self->map_handle);
/* if the file mapping still exists, it cannot be resized. */
if (self->tagname) {
- self->map_handle = OpenFileMapping(FILE_MAP_WRITE, FALSE,
+ self->map_handle = OpenFileMappingA(FILE_MAP_WRITE, FALSE,
self->tagname);
if (self->map_handle) {
PyErr_SetFromWindowsErr(ERROR_USER_MAPPED_FILE);
@@ -531,7 +531,7 @@ mmap_resize_method(mmap_object *self,
/* create a new file mapping and map a new view */
/* FIXME: call CreateFileMappingW with wchar_t tagname */
- self->map_handle = CreateFileMapping(
+ self->map_handle = CreateFileMappingA(
self->file_handle,
NULL,
PAGE_READWRITE,
@@ -1514,12 +1514,12 @@ new_mmap_object(PyTypeObject *type, PyObject *args, PyObject *kwdict)
off_lo = (DWORD)(offset & 0xFFFFFFFF);
/* For files, it would be sufficient to pass 0 as size.
For anonymous maps, we have to pass the size explicitly. */
- m_obj->map_handle = CreateFileMapping(m_obj->file_handle,
- NULL,
- flProtect,
- size_hi,
- size_lo,
- m_obj->tagname);
+ m_obj->map_handle = CreateFileMappingA(m_obj->file_handle,
+ NULL,
+ flProtect,
+ size_hi,
+ size_lo,
+ m_obj->tagname);
if (m_obj->map_handle != NULL) {
m_obj->data = (char *) MapViewOfFile(m_obj->map_handle,
dwDesiredAccess,
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index 6ea216b3bf5e79..7beb2cee64a05c 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -10,16 +10,6 @@
#define PY_SSIZE_T_CLEAN
#include "Python.h"
-// Include before pycore internal headers. FSCTL_GET_REPARSE_POINT
-// is not exported by if the WIN32_LEAN_AND_MEAN macro is defined,
-// whereas pycore_condvar.h defines the WIN32_LEAN_AND_MEAN macro.
-#ifdef MS_WINDOWS
-# include
-# include
-# include // UNLEN
-# include "osdefs.h" // SEP
-# define HAVE_SYMLINK
-#endif
#ifdef __VXWORKS__
# include "pycore_bitutils.h" // _Py_popcount32()
@@ -34,6 +24,15 @@
#include "pycore_pystate.h" // _PyInterpreterState_GET()
#include "pycore_signal.h" // Py_NSIG
+#ifdef MS_WINDOWS
+# include
+# include
+# include
+# include // UNLEN
+# include "osdefs.h" // SEP
+# define HAVE_SYMLINK
+#endif
+
#include "structmember.h" // PyMemberDef
#ifndef MS_WINDOWS
# include "posixmodule.h"
@@ -1507,32 +1506,6 @@ _Py_Sigset_Converter(PyObject *obj, void *addr)
}
#endif /* HAVE_SIGSET_T */
-#ifdef MS_WINDOWS
-
-static int
-win32_get_reparse_tag(HANDLE reparse_point_handle, ULONG *reparse_tag)
-{
- char target_buffer[_Py_MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
- _Py_REPARSE_DATA_BUFFER *rdb = (_Py_REPARSE_DATA_BUFFER *)target_buffer;
- DWORD n_bytes_returned;
-
- if (0 == DeviceIoControl(
- reparse_point_handle,
- FSCTL_GET_REPARSE_POINT,
- NULL, 0, /* in buffer */
- target_buffer, sizeof(target_buffer),
- &n_bytes_returned,
- NULL)) /* we're not using OVERLAPPED_IO */
- return FALSE;
-
- if (reparse_tag)
- *reparse_tag = rdb->ReparseTag;
-
- return TRUE;
-}
-
-#endif /* MS_WINDOWS */
-
/* Return a dictionary corresponding to the POSIX environment table */
#if defined(WITH_NEXT_FRAMEWORK) || (defined(__APPLE__) && defined(Py_ENABLE_SHARED))
/* On Darwin/MacOSX a shared library or framework has no access to
@@ -8263,42 +8236,32 @@ os_setpgrp_impl(PyObject *module)
#ifdef HAVE_GETPPID
#ifdef MS_WINDOWS
-#include
+#include
static PyObject*
win32_getppid()
{
- HANDLE snapshot;
+ DWORD error;
PyObject* result = NULL;
- BOOL have_record;
- PROCESSENTRY32 pe;
-
- DWORD mypid = GetCurrentProcessId(); /* This function never fails */
-
- snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
- if (snapshot == INVALID_HANDLE_VALUE)
- return PyErr_SetFromWindowsErr(GetLastError());
-
- pe.dwSize = sizeof(pe);
- have_record = Process32First(snapshot, &pe);
- while (have_record) {
- if (mypid == pe.th32ProcessID) {
- /* We could cache the ulong value in a static variable. */
- result = PyLong_FromUnsignedLong(pe.th32ParentProcessID);
- break;
- }
+ HANDLE process = GetCurrentProcess();
- have_record = Process32Next(snapshot, &pe);
+ HPSS snapshot = NULL;
+ error = PssCaptureSnapshot(process, PSS_CAPTURE_NONE, 0, &snapshot);
+ if (error != ERROR_SUCCESS) {
+ return PyErr_SetFromWindowsErr(error);
}
- /* If our loop exits and our pid was not found (result will be NULL)
- * then GetLastError will return ERROR_NO_MORE_FILES. This is an
- * error anyway, so let's raise it. */
- if (!result)
- result = PyErr_SetFromWindowsErr(GetLastError());
-
- CloseHandle(snapshot);
+ PSS_PROCESS_INFORMATION info;
+ error = PssQuerySnapshot(snapshot, PSS_QUERY_PROCESS_INFORMATION, &info,
+ sizeof(info));
+ if (error == ERROR_SUCCESS) {
+ result = PyLong_FromUnsignedLong(info.ParentProcessId);
+ }
+ else {
+ result = PyErr_SetFromWindowsErr(error);
+ }
+ PssFreeSnapshot(process, snapshot);
return result;
}
#endif /*MS_WINDOWS*/
@@ -9832,11 +9795,6 @@ os_dup2_impl(PyObject *module, int fd, int fd2, int inheritable)
static int dup3_works = -1;
#endif
- if (fd < 0 || fd2 < 0) {
- posix_error();
- return -1;
- }
-
/* dup2() can fail with EINTR if the target FD is already open, because it
* then has to be closed. See os_close_impl() for why we don't handle EINTR
* upon close(), and therefore below.
@@ -15067,9 +15025,6 @@ os_getrandom_impl(PyObject *module, Py_ssize_t size, int flags)
* on win32
*/
-typedef DLL_DIRECTORY_COOKIE (WINAPI *PAddDllDirectory)(PCWSTR newDirectory);
-typedef BOOL (WINAPI *PRemoveDllDirectory)(DLL_DIRECTORY_COOKIE cookie);
-
/*[clinic input]
os._add_dll_directory
@@ -15089,8 +15044,6 @@ static PyObject *
os__add_dll_directory_impl(PyObject *module, path_t *path)
/*[clinic end generated code: output=80b025daebb5d683 input=1de3e6c13a5808c8]*/
{
- HMODULE hKernel32;
- PAddDllDirectory AddDllDirectory;
DLL_DIRECTORY_COOKIE cookie = 0;
DWORD err = 0;
@@ -15098,14 +15051,8 @@ os__add_dll_directory_impl(PyObject *module, path_t *path)
return NULL;
}
- /* For Windows 7, we have to load this. As this will be a fairly
- infrequent operation, just do it each time. Kernel32 is always
- loaded. */
Py_BEGIN_ALLOW_THREADS
- if (!(hKernel32 = GetModuleHandleW(L"kernel32")) ||
- !(AddDllDirectory = (PAddDllDirectory)GetProcAddress(
- hKernel32, "AddDllDirectory")) ||
- !(cookie = (*AddDllDirectory)(path->wide))) {
+ if (!(cookie = AddDllDirectory(path->wide))) {
err = GetLastError();
}
Py_END_ALLOW_THREADS
@@ -15134,8 +15081,6 @@ static PyObject *
os__remove_dll_directory_impl(PyObject *module, PyObject *cookie)
/*[clinic end generated code: output=594350433ae535bc input=c1d16a7e7d9dc5dc]*/
{
- HMODULE hKernel32;
- PRemoveDllDirectory RemoveDllDirectory;
DLL_DIRECTORY_COOKIE cookieValue;
DWORD err = 0;
@@ -15148,14 +15093,8 @@ os__remove_dll_directory_impl(PyObject *module, PyObject *cookie)
cookieValue = (DLL_DIRECTORY_COOKIE)PyCapsule_GetPointer(
cookie, "DLL directory cookie");
- /* For Windows 7, we have to load this. As this will be a fairly
- infrequent operation, just do it each time. Kernel32 is always
- loaded. */
Py_BEGIN_ALLOW_THREADS
- if (!(hKernel32 = GetModuleHandleW(L"kernel32")) ||
- !(RemoveDllDirectory = (PRemoveDllDirectory)GetProcAddress(
- hKernel32, "RemoveDllDirectory")) ||
- !(*RemoveDllDirectory)(cookieValue)) {
+ if (!RemoveDllDirectory(cookieValue)) {
err = GetLastError();
}
Py_END_ALLOW_THREADS
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index 00608be38f61bb..43a0cc0f963f9d 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -606,11 +606,6 @@ select_error(void)
# define SUPPRESS_DEPRECATED_CALL
#endif
-#ifdef MS_WINDOWS
-/* Does WSASocket() support the WSA_FLAG_NO_HANDLE_INHERIT flag? */
-static int support_wsa_no_inherit = -1;
-#endif
-
/* Convenience function to raise an error according to errno
and return a NULL pointer from a function. */
@@ -5342,6 +5337,13 @@ sock_initobj_impl(PySocketSockObject *self, int family, int type, int proto,
set_error();
return -1;
}
+
+ if (!SetHandleInformation((HANDLE)fd, HANDLE_FLAG_INHERIT, 0)) {
+ closesocket(fd);
+ PyErr_SetFromWindowsErr(0);
+ return -1;
+ }
+
family = info.iAddressFamily;
type = info.iSocketType;
proto = info.iProtocol;
@@ -5438,33 +5440,15 @@ sock_initobj_impl(PySocketSockObject *self, int family, int type, int proto,
#endif
Py_BEGIN_ALLOW_THREADS
- if (support_wsa_no_inherit) {
- fd = WSASocketW(family, type, proto,
- NULL, 0,
- WSA_FLAG_OVERLAPPED | WSA_FLAG_NO_HANDLE_INHERIT);
- if (fd == INVALID_SOCKET) {
- /* Windows 7 or Windows 2008 R2 without SP1 or the hotfix */
- support_wsa_no_inherit = 0;
- fd = socket(family, type, proto);
- }
- }
- else {
- fd = socket(family, type, proto);
- }
+ fd = WSASocketW(family, type, proto,
+ NULL, 0,
+ WSA_FLAG_OVERLAPPED | WSA_FLAG_NO_HANDLE_INHERIT);
Py_END_ALLOW_THREADS
if (fd == INVALID_SOCKET) {
set_error();
return -1;
}
-
- if (!support_wsa_no_inherit) {
- if (!SetHandleInformation((HANDLE)fd, HANDLE_FLAG_INHERIT, 0)) {
- closesocket(fd);
- PyErr_SetFromWindowsErr(0);
- return -1;
- }
- }
#else
/* UNIX */
Py_BEGIN_ALLOW_THREADS
@@ -7340,12 +7324,6 @@ PyInit__socket(void)
if (!os_init())
return NULL;
-#ifdef MS_WINDOWS
- if (support_wsa_no_inherit == -1) {
- support_wsa_no_inherit = IsWindows7SP1OrGreater();
- }
-#endif
-
Py_SET_TYPE(&sock_type, &PyType_Type);
m = PyModule_Create(&socketmodule);
if (m == NULL)
diff --git a/Objects/iterobject.c b/Objects/iterobject.c
index 149b701b68e91a..7cb17a6ca4ab56 100644
--- a/Objects/iterobject.c
+++ b/Objects/iterobject.c
@@ -219,7 +219,7 @@ calliter_iternext(calliterobject *it)
}
result = _PyObject_CallNoArgs(it->it_callable);
- if (result != NULL) {
+ if (result != NULL && it->it_sentinel != NULL){
int ok;
ok = PyObject_RichCompareBool(it->it_sentinel, result, Py_EQ);
@@ -227,7 +227,6 @@ calliter_iternext(calliterobject *it)
return result; /* Common case, fast path */
}
- Py_DECREF(result);
if (ok > 0) {
Py_CLEAR(it->it_callable);
Py_CLEAR(it->it_sentinel);
@@ -238,6 +237,7 @@ calliter_iternext(calliterobject *it)
Py_CLEAR(it->it_callable);
Py_CLEAR(it->it_sentinel);
}
+ Py_XDECREF(result);
return NULL;
}
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index b3f1429debc58b..981930f58417d8 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -3,7 +3,7 @@
#include "Python.h"
#include "pycore_call.h"
#include "pycore_code.h" // CO_FAST_FREE
-#include "pycore_compile.h" // _Py_Mangle()
+#include "pycore_symtable.h" // _Py_Mangle()
#include "pycore_dict.h" // _PyDict_KeysSize()
#include "pycore_initconfig.h" // _PyStatus_OK()
#include "pycore_moduleobject.h" // _PyModule_GetDef()
@@ -3822,11 +3822,11 @@ PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module,
res->ht_qualname = Py_NewRef(ht_name);
res->ht_name = ht_name;
- ht_name = NULL; // Give our reference to to the type
+ ht_name = NULL; // Give our reference to the type
type->tp_name = _ht_tpname;
res->_ht_tpname = _ht_tpname;
- _ht_tpname = NULL; // Give ownership to to the type
+ _ht_tpname = NULL; // Give ownership to the type
/* Copy the sizes */
diff --git a/PC/winreg.c b/PC/winreg.c
index 63b37be526ab80..86efed09855b01 100644
--- a/PC/winreg.c
+++ b/PC/winreg.c
@@ -561,7 +561,7 @@ Py2Reg(PyObject *value, DWORD typ, BYTE **retDataBuf, DWORD *retDataSize)
{
Py_ssize_t i,j;
switch (typ) {
- case REG_DWORD:
+ case REG_DWORD:
{
if (value != Py_None && !PyLong_Check(value)) {
return FALSE;
@@ -585,7 +585,7 @@ Py2Reg(PyObject *value, DWORD typ, BYTE **retDataBuf, DWORD *retDataSize)
*retDataSize = sizeof(DWORD);
break;
}
- case REG_QWORD:
+ case REG_QWORD:
{
if (value != Py_None && !PyLong_Check(value)) {
return FALSE;
@@ -1488,53 +1488,77 @@ static PyObject *
winreg_QueryValue_impl(PyObject *module, HKEY key, const Py_UNICODE *sub_key)
/*[clinic end generated code: output=c655810ae50c63a9 input=41cafbbf423b21d6]*/
{
- long rc;
- PyObject *retStr;
- wchar_t *retBuf;
- DWORD bufSize = 0;
- DWORD retSize = 0;
- wchar_t *tmp;
+ LONG rc;
+ HKEY childKey = key;
+ WCHAR buf[256], *pbuf = buf;
+ DWORD size = sizeof(buf);
+ DWORD type;
+ Py_ssize_t length;
+ PyObject *result = NULL;
if (PySys_Audit("winreg.QueryValue", "nuu",
- (Py_ssize_t)key, sub_key, NULL) < 0) {
+ (Py_ssize_t)key, sub_key, NULL) < 0)
+ {
return NULL;
}
- rc = RegQueryValueW(key, sub_key, NULL, &retSize);
- if (rc == ERROR_MORE_DATA)
- retSize = 256;
- else if (rc != ERROR_SUCCESS)
- return PyErr_SetFromWindowsErrWithFunction(rc,
+
+ if (key == HKEY_PERFORMANCE_DATA) {
+ return PyErr_SetFromWindowsErrWithFunction(ERROR_INVALID_HANDLE,
"RegQueryValue");
+ }
- bufSize = retSize;
- retBuf = (wchar_t *) PyMem_Malloc(bufSize);
- if (retBuf == NULL)
- return PyErr_NoMemory();
+ if (sub_key && sub_key[0]) {
+ Py_BEGIN_ALLOW_THREADS
+ rc = RegOpenKeyExW(key, sub_key, 0, KEY_QUERY_VALUE, &childKey);
+ Py_END_ALLOW_THREADS
+ if (rc != ERROR_SUCCESS) {
+ return PyErr_SetFromWindowsErrWithFunction(rc, "RegOpenKeyEx");
+ }
+ }
while (1) {
- retSize = bufSize;
- rc = RegQueryValueW(key, sub_key, retBuf, &retSize);
- if (rc != ERROR_MORE_DATA)
+ Py_BEGIN_ALLOW_THREADS
+ rc = RegQueryValueExW(childKey, NULL, NULL, &type, (LPBYTE)pbuf,
+ &size);
+ Py_END_ALLOW_THREADS
+ if (rc != ERROR_MORE_DATA) {
break;
-
- bufSize *= 2;
- tmp = (wchar_t *) PyMem_Realloc(retBuf, bufSize);
+ }
+ void *tmp = PyMem_Realloc(pbuf != buf ? pbuf : NULL, size);
if (tmp == NULL) {
- PyMem_Free(retBuf);
- return PyErr_NoMemory();
+ PyErr_NoMemory();
+ goto exit;
}
- retBuf = tmp;
+ pbuf = tmp;
}
- if (rc != ERROR_SUCCESS) {
- PyMem_Free(retBuf);
- return PyErr_SetFromWindowsErrWithFunction(rc,
- "RegQueryValue");
+ if (rc == ERROR_SUCCESS) {
+ if (type != REG_SZ) {
+ PyErr_SetFromWindowsErrWithFunction(ERROR_INVALID_DATA,
+ "RegQueryValue");
+ goto exit;
+ }
+ length = wcsnlen(pbuf, size / sizeof(WCHAR));
+ }
+ else if (rc == ERROR_FILE_NOT_FOUND) {
+ // Return an empty string if there's no default value.
+ length = 0;
+ }
+ else {
+ PyErr_SetFromWindowsErrWithFunction(rc, "RegQueryValueEx");
+ goto exit;
}
- retStr = PyUnicode_FromWideChar(retBuf, wcslen(retBuf));
- PyMem_Free(retBuf);
- return retStr;
+ result = PyUnicode_FromWideChar(pbuf, length);
+
+exit:
+ if (pbuf != buf) {
+ PyMem_Free(pbuf);
+ }
+ if (childKey != key) {
+ RegCloseKey(childKey);
+ }
+ return result;
}
@@ -1687,38 +1711,69 @@ winreg_SetValue_impl(PyObject *module, HKEY key, const Py_UNICODE *sub_key,
DWORD type, PyObject *value_obj)
/*[clinic end generated code: output=d4773dc9c372311a input=bf088494ae2d24fd]*/
{
- Py_ssize_t value_length;
- long rc;
+ LONG rc;
+ HKEY childKey = key;
+ LPWSTR value;
+ Py_ssize_t size;
+ Py_ssize_t length;
+ PyObject *result = NULL;
if (type != REG_SZ) {
PyErr_SetString(PyExc_TypeError, "type must be winreg.REG_SZ");
return NULL;
}
- wchar_t *value = PyUnicode_AsWideCharString(value_obj, &value_length);
+ value = PyUnicode_AsWideCharString(value_obj, &length);
if (value == NULL) {
return NULL;
}
- if ((Py_ssize_t)(DWORD)value_length != value_length) {
+
+ size = (length + 1) * sizeof(WCHAR);
+ if ((Py_ssize_t)(DWORD)size != size) {
PyErr_SetString(PyExc_OverflowError, "value is too long");
- PyMem_Free(value);
- return NULL;
+ goto exit;
}
if (PySys_Audit("winreg.SetValue", "nunu#",
(Py_ssize_t)key, sub_key, (Py_ssize_t)type,
- value, value_length) < 0) {
- PyMem_Free(value);
- return NULL;
+ value, length) < 0)
+ {
+ goto exit;
+ }
+
+ if (key == HKEY_PERFORMANCE_DATA) {
+ PyErr_SetFromWindowsErrWithFunction(ERROR_INVALID_HANDLE,
+ "RegSetValue");
+ goto exit;
+ }
+
+ if (sub_key && sub_key[0]) {
+ Py_BEGIN_ALLOW_THREADS
+ rc = RegCreateKeyExW(key, sub_key, 0, NULL, 0, KEY_SET_VALUE, NULL,
+ &childKey, NULL);
+ Py_END_ALLOW_THREADS
+ if (rc != ERROR_SUCCESS) {
+ PyErr_SetFromWindowsErrWithFunction(rc, "RegCreateKeyEx");
+ goto exit;
+ }
}
Py_BEGIN_ALLOW_THREADS
- rc = RegSetValueW(key, sub_key, REG_SZ, value, (DWORD)(value_length + 1));
+ rc = RegSetValueExW(childKey, NULL, 0, REG_SZ, (LPBYTE)value, (DWORD)size);
Py_END_ALLOW_THREADS
+ if (rc == ERROR_SUCCESS) {
+ result = Py_NewRef(Py_None);
+ }
+ else {
+ PyErr_SetFromWindowsErrWithFunction(rc, "RegSetValueEx");
+ }
+
+exit:
PyMem_Free(value);
- if (rc != ERROR_SUCCESS)
- return PyErr_SetFromWindowsErrWithFunction(rc, "RegSetValue");
- Py_RETURN_NONE;
+ if (childKey != key) {
+ RegCloseKey(childKey);
+ }
+ return result;
}
/*[clinic input]
@@ -1771,32 +1826,39 @@ winreg_SetValueEx_impl(PyObject *module, HKEY key,
DWORD type, PyObject *value)
/*[clinic end generated code: output=811b769a66ae11b7 input=900a9e3990bfb196]*/
{
- BYTE *data;
- DWORD len;
-
LONG rc;
+ BYTE *data = NULL;
+ DWORD size;
+ PyObject *result = NULL;
- if (!Py2Reg(value, type, &data, &len))
+ if (!Py2Reg(value, type, &data, &size))
{
- if (!PyErr_Occurred())
+ if (!PyErr_Occurred()) {
PyErr_SetString(PyExc_ValueError,
"Could not convert the data to the specified type.");
+ }
return NULL;
}
if (PySys_Audit("winreg.SetValue", "nunO",
(Py_ssize_t)key, value_name, (Py_ssize_t)type,
- value) < 0) {
- PyMem_Free(data);
- return NULL;
+ value) < 0)
+ {
+ goto exit;
}
+
Py_BEGIN_ALLOW_THREADS
- rc = RegSetValueExW(key, value_name, 0, type, data, len);
+ rc = RegSetValueExW(key, value_name, 0, type, data, size);
Py_END_ALLOW_THREADS
+ if (rc == ERROR_SUCCESS) {
+ result = Py_NewRef(Py_None);
+ }
+ else {
+ PyErr_SetFromWindowsErrWithFunction(rc, "RegSetValueEx");
+ }
+
+exit:
PyMem_Free(data);
- if (rc != ERROR_SUCCESS)
- return PyErr_SetFromWindowsErrWithFunction(rc,
- "RegSetValueEx");
- Py_RETURN_NONE;
+ return result;
}
/*[clinic input]
diff --git a/Parser/parser.c b/Parser/parser.c
index 845c1739d63a60..e0a88a9cc72c8b 100644
--- a/Parser/parser.c
+++ b/Parser/parser.c
@@ -23777,7 +23777,6 @@ _loop0_1_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -23828,7 +23827,6 @@ _loop0_1_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_1_type, _seq);
p->level--;
return _seq;
}
@@ -23847,7 +23845,6 @@ _loop0_2_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -23898,7 +23895,6 @@ _loop0_2_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_2_type, _seq);
p->level--;
return _seq;
}
@@ -23917,7 +23913,6 @@ _loop1_3_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -23973,7 +23968,6 @@ _loop1_3_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_3_type, _seq);
p->level--;
return _seq;
}
@@ -23992,7 +23986,6 @@ _loop0_5_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -24052,7 +24045,6 @@ _loop0_5_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_5_type, _seq);
p->level--;
return _seq;
}
@@ -24585,7 +24577,6 @@ _loop1_14_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -24641,7 +24632,6 @@ _loop1_14_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_14_type, _seq);
p->level--;
return _seq;
}
@@ -24823,7 +24813,6 @@ _loop0_19_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -24883,7 +24872,6 @@ _loop0_19_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_19_type, _seq);
p->level--;
return _seq;
}
@@ -24944,7 +24932,6 @@ _loop0_21_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -25004,7 +24991,6 @@ _loop0_21_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_21_type, _seq);
p->level--;
return _seq;
}
@@ -25170,7 +25156,6 @@ _loop0_24_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -25221,7 +25206,6 @@ _loop0_24_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_24_type, _seq);
p->level--;
return _seq;
}
@@ -25240,7 +25224,6 @@ _loop1_25_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -25296,7 +25279,6 @@ _loop1_25_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_25_type, _seq);
p->level--;
return _seq;
}
@@ -25315,7 +25297,6 @@ _loop0_27_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -25375,7 +25356,6 @@ _loop0_27_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_27_type, _seq);
p->level--;
return _seq;
}
@@ -25483,7 +25463,6 @@ _loop0_30_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -25543,7 +25522,6 @@ _loop0_30_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_30_type, _seq);
p->level--;
return _seq;
}
@@ -25651,7 +25629,6 @@ _loop1_32_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -25707,7 +25684,6 @@ _loop1_32_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_32_type, _seq);
p->level--;
return _seq;
}
@@ -25870,7 +25846,6 @@ _loop0_36_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -25921,7 +25896,6 @@ _loop0_36_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_36_type, _seq);
p->level--;
return _seq;
}
@@ -25940,7 +25914,6 @@ _loop0_37_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -25991,7 +25964,6 @@ _loop0_37_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_37_type, _seq);
p->level--;
return _seq;
}
@@ -26010,7 +25982,6 @@ _loop0_38_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26061,7 +26032,6 @@ _loop0_38_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_38_type, _seq);
p->level--;
return _seq;
}
@@ -26080,7 +26050,6 @@ _loop1_39_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26136,7 +26105,6 @@ _loop1_39_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_39_type, _seq);
p->level--;
return _seq;
}
@@ -26155,7 +26123,6 @@ _loop0_40_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26206,7 +26173,6 @@ _loop0_40_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_40_type, _seq);
p->level--;
return _seq;
}
@@ -26225,7 +26191,6 @@ _loop1_41_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26281,7 +26246,6 @@ _loop1_41_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_41_type, _seq);
p->level--;
return _seq;
}
@@ -26300,7 +26264,6 @@ _loop1_42_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26356,7 +26319,6 @@ _loop1_42_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_42_type, _seq);
p->level--;
return _seq;
}
@@ -26375,7 +26337,6 @@ _loop1_43_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26431,7 +26392,6 @@ _loop1_43_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_43_type, _seq);
p->level--;
return _seq;
}
@@ -26450,7 +26410,6 @@ _loop0_44_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26501,7 +26460,6 @@ _loop0_44_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_44_type, _seq);
p->level--;
return _seq;
}
@@ -26520,7 +26478,6 @@ _loop1_45_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26576,7 +26533,6 @@ _loop1_45_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_45_type, _seq);
p->level--;
return _seq;
}
@@ -26595,7 +26551,6 @@ _loop0_46_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26646,7 +26601,6 @@ _loop0_46_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_46_type, _seq);
p->level--;
return _seq;
}
@@ -26665,7 +26619,6 @@ _loop1_47_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26721,7 +26674,6 @@ _loop1_47_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_47_type, _seq);
p->level--;
return _seq;
}
@@ -26740,7 +26692,6 @@ _loop0_48_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26791,7 +26742,6 @@ _loop0_48_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_48_type, _seq);
p->level--;
return _seq;
}
@@ -26810,7 +26760,6 @@ _loop0_49_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26861,7 +26810,6 @@ _loop0_49_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_49_type, _seq);
p->level--;
return _seq;
}
@@ -26880,7 +26828,6 @@ _loop1_50_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -26936,7 +26883,6 @@ _loop1_50_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_50_type, _seq);
p->level--;
return _seq;
}
@@ -26955,7 +26901,6 @@ _loop0_52_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -27015,7 +26960,6 @@ _loop0_52_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_52_type, _seq);
p->level--;
return _seq;
}
@@ -27076,7 +27020,6 @@ _loop0_54_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -27136,7 +27079,6 @@ _loop0_54_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_54_type, _seq);
p->level--;
return _seq;
}
@@ -27197,7 +27139,6 @@ _loop0_56_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -27257,7 +27198,6 @@ _loop0_56_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_56_type, _seq);
p->level--;
return _seq;
}
@@ -27318,7 +27258,6 @@ _loop0_58_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -27378,7 +27317,6 @@ _loop0_58_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_58_type, _seq);
p->level--;
return _seq;
}
@@ -27516,7 +27454,6 @@ _loop1_60_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -27572,7 +27509,6 @@ _loop1_60_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_60_type, _seq);
p->level--;
return _seq;
}
@@ -27591,7 +27527,6 @@ _loop1_61_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -27647,7 +27582,6 @@ _loop1_61_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_61_type, _seq);
p->level--;
return _seq;
}
@@ -27760,7 +27694,6 @@ _loop1_64_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -27816,7 +27749,6 @@ _loop1_64_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_64_type, _seq);
p->level--;
return _seq;
}
@@ -27835,7 +27767,6 @@ _loop0_66_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -27895,7 +27826,6 @@ _loop0_66_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_66_type, _seq);
p->level--;
return _seq;
}
@@ -28226,7 +28156,6 @@ _loop0_72_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -28286,7 +28215,6 @@ _loop0_72_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_72_type, _seq);
p->level--;
return _seq;
}
@@ -28347,7 +28275,6 @@ _loop0_74_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -28407,7 +28334,6 @@ _loop0_74_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_74_type, _seq);
p->level--;
return _seq;
}
@@ -28526,7 +28452,6 @@ _loop0_77_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -28586,7 +28511,6 @@ _loop0_77_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_77_type, _seq);
p->level--;
return _seq;
}
@@ -28647,7 +28571,6 @@ _loop0_79_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -28707,7 +28630,6 @@ _loop0_79_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_79_type, _seq);
p->level--;
return _seq;
}
@@ -28768,7 +28690,6 @@ _loop1_80_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -28824,7 +28745,6 @@ _loop1_80_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_80_type, _seq);
p->level--;
return _seq;
}
@@ -28843,7 +28763,6 @@ _loop1_81_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -28899,7 +28818,6 @@ _loop1_81_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_81_type, _seq);
p->level--;
return _seq;
}
@@ -28918,7 +28836,6 @@ _loop0_83_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -28978,7 +28895,6 @@ _loop0_83_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_83_type, _seq);
p->level--;
return _seq;
}
@@ -29039,7 +28955,6 @@ _loop1_84_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -29095,7 +29010,6 @@ _loop1_84_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_84_type, _seq);
p->level--;
return _seq;
}
@@ -29114,7 +29028,6 @@ _loop1_85_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -29170,7 +29083,6 @@ _loop1_85_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_85_type, _seq);
p->level--;
return _seq;
}
@@ -29189,7 +29101,6 @@ _loop1_86_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -29245,7 +29156,6 @@ _loop1_86_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_86_type, _seq);
p->level--;
return _seq;
}
@@ -29308,7 +29218,6 @@ _loop0_89_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -29368,7 +29277,6 @@ _loop0_89_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_89_type, _seq);
p->level--;
return _seq;
}
@@ -29765,7 +29673,6 @@ _loop0_95_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -29816,7 +29723,6 @@ _loop0_95_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_95_type, _seq);
p->level--;
return _seq;
}
@@ -29835,7 +29741,6 @@ _loop0_96_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -29886,7 +29791,6 @@ _loop0_96_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_96_type, _seq);
p->level--;
return _seq;
}
@@ -29905,7 +29809,6 @@ _loop0_97_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -29956,7 +29859,6 @@ _loop0_97_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_97_type, _seq);
p->level--;
return _seq;
}
@@ -29975,7 +29877,6 @@ _loop1_98_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30031,7 +29932,6 @@ _loop1_98_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_98_type, _seq);
p->level--;
return _seq;
}
@@ -30050,7 +29950,6 @@ _loop0_99_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30101,7 +30000,6 @@ _loop0_99_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_99_type, _seq);
p->level--;
return _seq;
}
@@ -30120,7 +30018,6 @@ _loop1_100_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30176,7 +30073,6 @@ _loop1_100_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_100_type, _seq);
p->level--;
return _seq;
}
@@ -30195,7 +30091,6 @@ _loop1_101_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30251,7 +30146,6 @@ _loop1_101_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_101_type, _seq);
p->level--;
return _seq;
}
@@ -30270,7 +30164,6 @@ _loop1_102_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30326,7 +30219,6 @@ _loop1_102_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_102_type, _seq);
p->level--;
return _seq;
}
@@ -30345,7 +30237,6 @@ _loop0_103_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30396,7 +30287,6 @@ _loop0_103_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_103_type, _seq);
p->level--;
return _seq;
}
@@ -30415,7 +30305,6 @@ _loop1_104_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30471,7 +30360,6 @@ _loop1_104_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_104_type, _seq);
p->level--;
return _seq;
}
@@ -30490,7 +30378,6 @@ _loop0_105_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30541,7 +30428,6 @@ _loop0_105_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_105_type, _seq);
p->level--;
return _seq;
}
@@ -30560,7 +30446,6 @@ _loop1_106_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30616,7 +30501,6 @@ _loop1_106_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_106_type, _seq);
p->level--;
return _seq;
}
@@ -30635,7 +30519,6 @@ _loop0_107_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30686,7 +30569,6 @@ _loop0_107_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_107_type, _seq);
p->level--;
return _seq;
}
@@ -30705,7 +30587,6 @@ _loop1_108_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30761,7 +30642,6 @@ _loop1_108_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_108_type, _seq);
p->level--;
return _seq;
}
@@ -30780,7 +30660,6 @@ _loop1_109_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30836,7 +30715,6 @@ _loop1_109_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_109_type, _seq);
p->level--;
return _seq;
}
@@ -30905,7 +30783,6 @@ _loop0_112_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -30965,7 +30842,6 @@ _loop0_112_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_112_type, _seq);
p->level--;
return _seq;
}
@@ -31026,7 +30902,6 @@ _loop1_113_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -31082,7 +30957,6 @@ _loop1_113_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_113_type, _seq);
p->level--;
return _seq;
}
@@ -31101,7 +30975,6 @@ _loop0_114_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -31152,7 +31025,6 @@ _loop0_114_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_114_type, _seq);
p->level--;
return _seq;
}
@@ -31171,7 +31043,6 @@ _loop0_115_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -31222,7 +31093,6 @@ _loop0_115_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_115_type, _seq);
p->level--;
return _seq;
}
@@ -31301,7 +31171,6 @@ _loop0_118_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -31361,7 +31230,6 @@ _loop0_118_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_118_type, _seq);
p->level--;
return _seq;
}
@@ -31470,7 +31338,6 @@ _loop0_121_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -31530,7 +31397,6 @@ _loop0_121_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_121_type, _seq);
p->level--;
return _seq;
}
@@ -31591,7 +31457,6 @@ _loop0_123_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -31651,7 +31516,6 @@ _loop0_123_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_123_type, _seq);
p->level--;
return _seq;
}
@@ -31712,7 +31576,6 @@ _loop0_125_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -31772,7 +31635,6 @@ _loop0_125_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_125_type, _seq);
p->level--;
return _seq;
}
@@ -31833,7 +31695,6 @@ _loop0_127_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -31893,7 +31754,6 @@ _loop0_127_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_127_type, _seq);
p->level--;
return _seq;
}
@@ -31954,7 +31814,6 @@ _loop0_128_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -32005,7 +31864,6 @@ _loop0_128_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_128_type, _seq);
p->level--;
return _seq;
}
@@ -32024,7 +31882,6 @@ _loop0_130_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -32084,7 +31941,6 @@ _loop0_130_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_130_type, _seq);
p->level--;
return _seq;
}
@@ -32145,7 +32001,6 @@ _loop1_131_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -32201,7 +32056,6 @@ _loop1_131_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_131_type, _seq);
p->level--;
return _seq;
}
@@ -32261,7 +32115,6 @@ _loop0_134_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -32321,7 +32174,6 @@ _loop0_134_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_134_type, _seq);
p->level--;
return _seq;
}
@@ -32382,7 +32234,6 @@ _loop0_136_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -32442,7 +32293,6 @@ _loop0_136_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_136_type, _seq);
p->level--;
return _seq;
}
@@ -32503,7 +32353,6 @@ _loop0_138_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -32563,7 +32412,6 @@ _loop0_138_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_138_type, _seq);
p->level--;
return _seq;
}
@@ -32624,7 +32472,6 @@ _loop0_140_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -32684,7 +32531,6 @@ _loop0_140_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_140_type, _seq);
p->level--;
return _seq;
}
@@ -32745,7 +32591,6 @@ _loop0_142_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -32805,7 +32650,6 @@ _loop0_142_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_142_type, _seq);
p->level--;
return _seq;
}
@@ -33557,7 +33401,6 @@ _loop0_154_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -33608,7 +33451,6 @@ _loop0_154_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_154_type, _seq);
p->level--;
return _seq;
}
@@ -33627,7 +33469,6 @@ _loop0_155_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -33678,7 +33519,6 @@ _loop0_155_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_155_type, _seq);
p->level--;
return _seq;
}
@@ -33697,7 +33537,6 @@ _loop0_156_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -33748,7 +33587,6 @@ _loop0_156_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_156_type, _seq);
p->level--;
return _seq;
}
@@ -34076,7 +33914,6 @@ _loop0_162_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -34127,7 +33964,6 @@ _loop0_162_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_162_type, _seq);
p->level--;
return _seq;
}
@@ -34146,7 +33982,6 @@ _loop0_163_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -34197,7 +34032,6 @@ _loop0_163_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_163_type, _seq);
p->level--;
return _seq;
}
@@ -34216,7 +34050,6 @@ _loop0_164_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -34267,7 +34100,6 @@ _loop0_164_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_164_type, _seq);
p->level--;
return _seq;
}
@@ -34286,7 +34118,6 @@ _loop1_165_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -34342,7 +34173,6 @@ _loop1_165_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_165_type, _seq);
p->level--;
return _seq;
}
@@ -34419,7 +34249,6 @@ _loop0_167_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -34470,7 +34299,6 @@ _loop0_167_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_167_type, _seq);
p->level--;
return _seq;
}
@@ -34547,7 +34375,6 @@ _loop0_169_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -34598,7 +34425,6 @@ _loop0_169_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_169_type, _seq);
p->level--;
return _seq;
}
@@ -34617,7 +34443,6 @@ _loop1_170_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -34673,7 +34498,6 @@ _loop1_170_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_170_type, _seq);
p->level--;
return _seq;
}
@@ -34869,7 +34693,6 @@ _loop0_174_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -34920,7 +34743,6 @@ _loop0_174_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_174_type, _seq);
p->level--;
return _seq;
}
@@ -35074,7 +34896,6 @@ _loop1_177_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -35130,7 +34951,6 @@ _loop1_177_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_177_type, _seq);
p->level--;
return _seq;
}
@@ -35207,7 +35027,6 @@ _loop0_179_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -35258,7 +35077,6 @@ _loop0_179_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_179_type, _seq);
p->level--;
return _seq;
}
@@ -35277,7 +35095,6 @@ _loop0_180_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -35328,7 +35145,6 @@ _loop0_180_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_180_type, _seq);
p->level--;
return _seq;
}
@@ -35347,7 +35163,6 @@ _loop0_181_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -35398,7 +35213,6 @@ _loop0_181_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_181_type, _seq);
p->level--;
return _seq;
}
@@ -35417,7 +35231,6 @@ _loop0_183_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -35477,7 +35290,6 @@ _loop0_183_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_183_type, _seq);
p->level--;
return _seq;
}
@@ -35596,7 +35408,6 @@ _loop0_185_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -35647,7 +35458,6 @@ _loop0_185_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_185_type, _seq);
p->level--;
return _seq;
}
@@ -35724,7 +35534,6 @@ _loop0_187_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -35775,7 +35584,6 @@ _loop0_187_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_187_type, _seq);
p->level--;
return _seq;
}
@@ -35794,7 +35602,6 @@ _loop1_188_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -35850,7 +35657,6 @@ _loop1_188_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_188_type, _seq);
p->level--;
return _seq;
}
@@ -35869,7 +35675,6 @@ _loop1_189_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -35925,7 +35730,6 @@ _loop1_189_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_189_type, _seq);
p->level--;
return _seq;
}
@@ -36063,7 +35867,6 @@ _loop0_192_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -36114,7 +35917,6 @@ _loop0_192_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_192_type, _seq);
p->level--;
return _seq;
}
@@ -36345,7 +36147,6 @@ _loop0_197_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -36405,7 +36206,6 @@ _loop0_197_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_197_type, _seq);
p->level--;
return _seq;
}
@@ -36466,7 +36266,6 @@ _loop0_199_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -36526,7 +36325,6 @@ _loop0_199_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_199_type, _seq);
p->level--;
return _seq;
}
@@ -36587,7 +36385,6 @@ _loop0_201_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -36647,7 +36444,6 @@ _loop0_201_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_201_type, _seq);
p->level--;
return _seq;
}
@@ -36708,7 +36504,6 @@ _loop0_203_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -36768,7 +36563,6 @@ _loop0_203_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_203_type, _seq);
p->level--;
return _seq;
}
@@ -36887,7 +36681,6 @@ _loop0_205_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -36938,7 +36731,6 @@ _loop0_205_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_205_type, _seq);
p->level--;
return _seq;
}
@@ -36957,7 +36749,6 @@ _loop1_206_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -37013,7 +36804,6 @@ _loop1_206_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_206_type, _seq);
p->level--;
return _seq;
}
@@ -37074,7 +36864,6 @@ _loop0_208_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -37125,7 +36914,6 @@ _loop0_208_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_208_type, _seq);
p->level--;
return _seq;
}
@@ -37144,7 +36932,6 @@ _loop1_209_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -37200,7 +36987,6 @@ _loop1_209_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop1_209_type, _seq);
p->level--;
return _seq;
}
@@ -37664,7 +37450,6 @@ _loop0_221_rule(Parser *p)
}
void *_res = NULL;
int _mark = p->mark;
- int _start_mark = p->mark;
void **_children = PyMem_Malloc(sizeof(void *));
if (!_children) {
p->error_indicator = 1;
@@ -37724,7 +37509,6 @@ _loop0_221_rule(Parser *p)
}
for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);
PyMem_Free(_children);
- _PyPegen_insert_memo(p, _start_mark, _loop0_221_type, _seq);
p->level--;
return _seq;
}
diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c
index 53439ab16040c4..12ca0ba6c4873c 100644
--- a/Python/bltinmodule.c
+++ b/Python/bltinmodule.c
@@ -553,9 +553,11 @@ static void
filter_dealloc(filterobject *lz)
{
PyObject_GC_UnTrack(lz);
+ Py_TRASHCAN_BEGIN(lz, filter_dealloc)
Py_XDECREF(lz->func);
Py_XDECREF(lz->it);
Py_TYPE(lz)->tp_free(lz);
+ Py_TRASHCAN_END
}
static int
diff --git a/Python/compile.c b/Python/compile.c
index 78145d41973f18..5882417bb31a2a 100644
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -29,12 +29,12 @@
#include "Python.h"
#include "pycore_ast.h" // _PyAST_GetDocString()
#include "pycore_code.h" // _PyCode_New()
-#include "pycore_compile.h" // _PyFuture_FromAST()
+#include "pycore_compile.h"
#include "pycore_intrinsics.h"
#include "pycore_long.h" // _PyLong_GetZero()
#include "pycore_opcode.h" // _PyOpcode_Caches
#include "pycore_pymem.h" // _PyMem_IsPtrFreed()
-#include "pycore_symtable.h" // PySTEntryObject
+#include "pycore_symtable.h" // PySTEntryObject, _PyFuture_FromAST()
#include "opcode_metadata.h" // _PyOpcode_opcode_metadata, _PyOpcode_num_popped/pushed
@@ -571,72 +571,6 @@ static PyCodeObject *assemble(struct compiler *, int addNone);
#define CAPSULE_NAME "compile.c compiler unit"
-PyObject *
-_Py_Mangle(PyObject *privateobj, PyObject *ident)
-{
- /* Name mangling: __private becomes _classname__private.
- This is independent from how the name is used. */
- PyObject *result;
- size_t nlen, plen, ipriv;
- Py_UCS4 maxchar;
- if (privateobj == NULL || !PyUnicode_Check(privateobj) ||
- PyUnicode_READ_CHAR(ident, 0) != '_' ||
- PyUnicode_READ_CHAR(ident, 1) != '_') {
- return Py_NewRef(ident);
- }
- nlen = PyUnicode_GET_LENGTH(ident);
- plen = PyUnicode_GET_LENGTH(privateobj);
- /* Don't mangle __id__ or names with dots.
-
- The only time a name with a dot can occur is when
- we are compiling an import statement that has a
- package name.
-
- TODO(jhylton): Decide whether we want to support
- mangling of the module name, e.g. __M.X.
- */
- if ((PyUnicode_READ_CHAR(ident, nlen-1) == '_' &&
- PyUnicode_READ_CHAR(ident, nlen-2) == '_') ||
- PyUnicode_FindChar(ident, '.', 0, nlen, 1) != -1) {
- return Py_NewRef(ident); /* Don't mangle __whatever__ */
- }
- /* Strip leading underscores from class name */
- ipriv = 0;
- while (PyUnicode_READ_CHAR(privateobj, ipriv) == '_')
- ipriv++;
- if (ipriv == plen) {
- return Py_NewRef(ident); /* Don't mangle if class is just underscores */
- }
- plen -= ipriv;
-
- if (plen + nlen >= PY_SSIZE_T_MAX - 1) {
- PyErr_SetString(PyExc_OverflowError,
- "private identifier too large to be mangled");
- return NULL;
- }
-
- maxchar = PyUnicode_MAX_CHAR_VALUE(ident);
- if (PyUnicode_MAX_CHAR_VALUE(privateobj) > maxchar)
- maxchar = PyUnicode_MAX_CHAR_VALUE(privateobj);
-
- result = PyUnicode_New(1 + nlen + plen, maxchar);
- if (!result) {
- return NULL;
- }
- /* ident = "_" + priv[ipriv:] + ident # i.e. 1+plen+nlen bytes */
- PyUnicode_WRITE(PyUnicode_KIND(result), PyUnicode_DATA(result), 0, '_');
- if (PyUnicode_CopyCharacters(result, 1, privateobj, ipriv, plen) < 0) {
- Py_DECREF(result);
- return NULL;
- }
- if (PyUnicode_CopyCharacters(result, plen+1, ident, 0, nlen) < 0) {
- Py_DECREF(result);
- return NULL;
- }
- assert(_PyUnicode_CheckConsistency(result, 1));
- return result;
-}
-
static int
compiler_setup(struct compiler *c, mod_ty mod, PyObject *filename,
diff --git a/Python/fileutils.c b/Python/fileutils.c
index 897c2f9f4ea160..93bee9ee007cd4 100644
--- a/Python/fileutils.c
+++ b/Python/fileutils.c
@@ -1362,17 +1362,11 @@ set_inheritable(int fd, int inheritable, int raise, int *atomic_flag_works)
else
flags = 0;
- /* This check can be removed once support for Windows 7 ends. */
-#define CONSOLE_PSEUDOHANDLE(handle) (((ULONG_PTR)(handle) & 0x3) == 0x3 && \
- GetFileType(handle) == FILE_TYPE_CHAR)
-
- if (!CONSOLE_PSEUDOHANDLE(handle) &&
- !SetHandleInformation(handle, HANDLE_FLAG_INHERIT, flags)) {
+ if (!SetHandleInformation(handle, HANDLE_FLAG_INHERIT, flags)) {
if (raise)
PyErr_SetFromWindowsErr(0);
return -1;
}
-#undef CONSOLE_PSEUDOHANDLE
return 0;
#else
diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h
index d155a42fa3cf51..2a557f6c8271bc 100644
--- a/Python/generated_cases.c.h
+++ b/Python/generated_cases.c.h
@@ -1,5 +1,6 @@
// This file is generated by Tools/cases_generator/generate_cases.py
-// from Python/bytecodes.c
+// from:
+// Python/bytecodes.c
// Do not edit!
TARGET(NOP) {
diff --git a/Python/opcode_metadata.h b/Python/opcode_metadata.h
index 31dc2ee5241940..767e83971f90bb 100644
--- a/Python/opcode_metadata.h
+++ b/Python/opcode_metadata.h
@@ -1,5 +1,6 @@
-// This file is generated by Tools/cases_generator/generate_cases.py --metadata
-// from Python/bytecodes.c
+// This file is generated by Tools/cases_generator/generate_cases.py
+// from:
+// Python/bytecodes.c
// Do not edit!
#ifndef NEED_OPCODE_TABLES
diff --git a/Python/symtable.c b/Python/symtable.c
index 3198856f043411..c25311a8659e34 100644
--- a/Python/symtable.c
+++ b/Python/symtable.c
@@ -1,6 +1,5 @@
#include "Python.h"
#include "pycore_ast.h" // identifier, stmt_ty
-#include "pycore_compile.h" // _Py_Mangle(), _PyFuture_FromAST()
#include "pycore_parser.h" // _PyParser_ASTFromString()
#include "pycore_pystate.h" // _PyThreadState_GET()
#include "pycore_symtable.h" // PySTEntryObject
@@ -2242,3 +2241,69 @@ _Py_SymtableStringObjectFlags(const char *str, PyObject *filename,
_PyArena_Free(arena);
return st;
}
+
+PyObject *
+_Py_Mangle(PyObject *privateobj, PyObject *ident)
+{
+ /* Name mangling: __private becomes _classname__private.
+ This is independent from how the name is used. */
+ if (privateobj == NULL || !PyUnicode_Check(privateobj) ||
+ PyUnicode_READ_CHAR(ident, 0) != '_' ||
+ PyUnicode_READ_CHAR(ident, 1) != '_') {
+ return Py_NewRef(ident);
+ }
+ size_t nlen = PyUnicode_GET_LENGTH(ident);
+ size_t plen = PyUnicode_GET_LENGTH(privateobj);
+ /* Don't mangle __id__ or names with dots.
+
+ The only time a name with a dot can occur is when
+ we are compiling an import statement that has a
+ package name.
+
+ TODO(jhylton): Decide whether we want to support
+ mangling of the module name, e.g. __M.X.
+ */
+ if ((PyUnicode_READ_CHAR(ident, nlen-1) == '_' &&
+ PyUnicode_READ_CHAR(ident, nlen-2) == '_') ||
+ PyUnicode_FindChar(ident, '.', 0, nlen, 1) != -1) {
+ return Py_NewRef(ident); /* Don't mangle __whatever__ */
+ }
+ /* Strip leading underscores from class name */
+ size_t ipriv = 0;
+ while (PyUnicode_READ_CHAR(privateobj, ipriv) == '_') {
+ ipriv++;
+ }
+ if (ipriv == plen) {
+ return Py_NewRef(ident); /* Don't mangle if class is just underscores */
+ }
+ plen -= ipriv;
+
+ if (plen + nlen >= PY_SSIZE_T_MAX - 1) {
+ PyErr_SetString(PyExc_OverflowError,
+ "private identifier too large to be mangled");
+ return NULL;
+ }
+
+ Py_UCS4 maxchar = PyUnicode_MAX_CHAR_VALUE(ident);
+ if (PyUnicode_MAX_CHAR_VALUE(privateobj) > maxchar) {
+ maxchar = PyUnicode_MAX_CHAR_VALUE(privateobj);
+ }
+
+ PyObject *result = PyUnicode_New(1 + nlen + plen, maxchar);
+ if (!result) {
+ return NULL;
+ }
+ /* ident = "_" + priv[ipriv:] + ident # i.e. 1+plen+nlen bytes */
+ PyUnicode_WRITE(PyUnicode_KIND(result), PyUnicode_DATA(result), 0, '_');
+ if (PyUnicode_CopyCharacters(result, 1, privateobj, ipriv, plen) < 0) {
+ Py_DECREF(result);
+ return NULL;
+ }
+ if (PyUnicode_CopyCharacters(result, plen+1, ident, 0, nlen) < 0) {
+ Py_DECREF(result);
+ return NULL;
+ }
+ assert(_PyUnicode_CheckConsistency(result, 1));
+ return result;
+}
+
diff --git a/Tools/cases_generator/generate_cases.py b/Tools/cases_generator/generate_cases.py
index b760172974c8a5..25cf75e4c1c490 100644
--- a/Tools/cases_generator/generate_cases.py
+++ b/Tools/cases_generator/generate_cases.py
@@ -37,15 +37,15 @@
description="Generate the code for the interpreter switch.",
formatter_class=argparse.ArgumentDefaultsHelpFormatter,
)
-arg_parser.add_argument(
- "-i", "--input", type=str, help="Instruction definitions", default=DEFAULT_INPUT
-)
arg_parser.add_argument(
"-o", "--output", type=str, help="Generated code", default=DEFAULT_OUTPUT
)
arg_parser.add_argument(
"-m", "--metadata", type=str, help="Generated metadata", default=DEFAULT_METADATA_OUTPUT
)
+arg_parser.add_argument(
+ "input", nargs=argparse.REMAINDER, help="Instruction definition file(s)"
+)
def effect_size(effect: StackEffect) -> tuple[int, str]:
@@ -485,6 +485,11 @@ class MacroInstruction(SuperOrMacroInstruction):
parts: list[Component | parser.CacheEffect]
+@dataclasses.dataclass
+class OverriddenInstructionPlaceHolder:
+ name: str
+
+
AnyInstruction = Instruction | SuperInstruction | MacroInstruction
INSTR_FMT_PREFIX = "INSTR_FMT_"
@@ -492,32 +497,33 @@ class MacroInstruction(SuperOrMacroInstruction):
class Analyzer:
"""Parse input, analyze it, and write to output."""
- filename: str
+ input_filenames: list[str]
output_filename: str
metadata_filename: str
- src: str
errors: int = 0
- def __init__(self, filename: str, output_filename: str, metadata_filename: str):
+ def __init__(self, input_filenames: list[str], output_filename: str, metadata_filename: str):
"""Read the input file."""
- self.filename = filename
+ self.input_filenames = input_filenames
self.output_filename = output_filename
self.metadata_filename = metadata_filename
- with open(filename) as f:
- self.src = f.read()
def error(self, msg: str, node: parser.Node) -> None:
lineno = 0
+ filename = ""
if context := node.context:
+ filename = context.owner.filename
# Use line number of first non-comment in the node
for token in context.owner.tokens[context.begin : context.end]:
lineno = token.line
if token.kind != "COMMENT":
break
- print(f"{self.filename}:{lineno}: {msg}", file=sys.stderr)
+ print(f"{filename}:{lineno}: {msg}", file=sys.stderr)
self.errors += 1
- everything: list[parser.InstDef | parser.Super | parser.Macro]
+ everything: list[
+ parser.InstDef | parser.Super | parser.Macro | OverriddenInstructionPlaceHolder
+ ]
instrs: dict[str, Instruction] # Includes ops
supers: dict[str, parser.Super]
super_instrs: dict[str, SuperInstruction]
@@ -531,7 +537,31 @@ def parse(self) -> None:
We only want the parser to see the stuff between the
begin and end markers.
"""
- psr = parser.Parser(self.src, filename=self.filename)
+
+ self.everything = []
+ self.instrs = {}
+ self.supers = {}
+ self.macros = {}
+ self.families = {}
+
+ instrs_idx: dict[str, int] = dict()
+
+ for filename in self.input_filenames:
+ self.parse_file(filename, instrs_idx)
+
+ files = " + ".join(self.input_filenames)
+ print(
+ f"Read {len(self.instrs)} instructions/ops, "
+ f"{len(self.supers)} supers, {len(self.macros)} macros, "
+ f"and {len(self.families)} families from {files}",
+ file=sys.stderr,
+ )
+
+ def parse_file(self, filename: str, instrs_idx: dict[str, int]) -> None:
+ with open(filename) as file:
+ src = file.read()
+
+ psr = parser.Parser(src, filename=filename)
# Skip until begin marker
while tkn := psr.next(raw=True):
@@ -551,16 +581,27 @@ def parse(self) -> None:
# Parse from start
psr.setpos(start)
- self.everything = []
- self.instrs = {}
- self.supers = {}
- self.macros = {}
- self.families = {}
thing: parser.InstDef | parser.Super | parser.Macro | parser.Family | None
+ thing_first_token = psr.peek()
while thing := psr.definition():
match thing:
case parser.InstDef(name=name):
+ if name in self.instrs:
+ if not thing.override:
+ raise psr.make_syntax_error(
+ f"Duplicate definition of '{name}' @ {thing.context} "
+ f"previous definition @ {self.instrs[name].inst.context}",
+ thing_first_token,
+ )
+ self.everything[instrs_idx[name]] = OverriddenInstructionPlaceHolder(name=name)
+ if name not in self.instrs and thing.override:
+ raise psr.make_syntax_error(
+ f"Definition of '{name}' @ {thing.context} is supposed to be "
+ "an override but no previous definition exists.",
+ thing_first_token,
+ )
self.instrs[name] = Instruction(thing)
+ instrs_idx[name] = len(self.everything)
self.everything.append(thing)
case parser.Super(name):
self.supers[name] = thing
@@ -573,14 +614,7 @@ def parse(self) -> None:
case _:
typing.assert_never(thing)
if not psr.eof():
- raise psr.make_syntax_error("Extra stuff at the end")
-
- print(
- f"Read {len(self.instrs)} instructions/ops, "
- f"{len(self.supers)} supers, {len(self.macros)} macros, "
- f"and {len(self.families)} families from {self.filename}",
- file=sys.stderr,
- )
+ raise psr.make_syntax_error(f"Extra stuff at the end of {filename}")
def analyze(self) -> None:
"""Analyze the inputs.
@@ -879,6 +913,8 @@ def write_stack_effect_functions(self) -> None:
popped_data: list[tuple[AnyInstruction, str]] = []
pushed_data: list[tuple[AnyInstruction, str]] = []
for thing in self.everything:
+ if isinstance(thing, OverriddenInstructionPlaceHolder):
+ continue
instr, popped, pushed = self.get_stack_effect_info(thing)
if instr is not None:
popped_data.append((instr, popped))
@@ -907,6 +943,13 @@ def write_function(
write_function("pushed", pushed_data)
self.out.emit("")
+ def from_source_files(self) -> str:
+ paths = "\n// ".join(
+ os.path.relpath(filename, ROOT).replace(os.path.sep, posixpath.sep)
+ for filename in self.input_filenames
+ )
+ return f"// from:\n// {paths}\n"
+
def write_metadata(self) -> None:
"""Write instruction metadata to output file."""
@@ -914,6 +957,8 @@ def write_metadata(self) -> None:
all_formats: set[str] = set()
for thing in self.everything:
match thing:
+ case OverriddenInstructionPlaceHolder():
+ continue
case parser.InstDef():
format = self.instrs[thing.name].instr_fmt
case parser.Super():
@@ -928,8 +973,8 @@ def write_metadata(self) -> None:
with open(self.metadata_filename, "w") as f:
# Write provenance header
- f.write(f"// This file is generated by {THIS} --metadata\n")
- f.write(f"// from {os.path.relpath(self.filename, ROOT).replace(os.path.sep, posixpath.sep)}\n")
+ f.write(f"// This file is generated by {THIS}\n")
+ f.write(self.from_source_files())
f.write(f"// Do not edit!\n")
# Create formatter; the rest of the code uses this
@@ -959,6 +1004,8 @@ def write_metadata(self) -> None:
# Write metadata for each instruction
for thing in self.everything:
match thing:
+ case OverriddenInstructionPlaceHolder():
+ continue
case parser.InstDef():
if thing.kind != "op":
self.write_metadata_for_inst(self.instrs[thing.name])
@@ -1008,7 +1055,7 @@ def write_instructions(self) -> None:
with open(self.output_filename, "w") as f:
# Write provenance header
f.write(f"// This file is generated by {THIS}\n")
- f.write(f"// from {os.path.relpath(self.filename, ROOT).replace(os.path.sep, posixpath.sep)}\n")
+ f.write(self.from_source_files())
f.write(f"// Do not edit!\n")
# Create formatter; the rest of the code uses this
@@ -1020,6 +1067,8 @@ def write_instructions(self) -> None:
n_macros = 0
for thing in self.everything:
match thing:
+ case OverriddenInstructionPlaceHolder():
+ self.write_overridden_instr_place_holder(thing)
case parser.InstDef():
if thing.kind != "op":
n_instrs += 1
@@ -1039,9 +1088,17 @@ def write_instructions(self) -> None:
file=sys.stderr,
)
+ def write_overridden_instr_place_holder(self,
+ place_holder: OverriddenInstructionPlaceHolder) -> None:
+ self.out.emit("")
+ self.out.emit(
+ f"// TARGET({place_holder.name}) overridden by later definition")
+
def write_instr(self, instr: Instruction) -> None:
name = instr.name
self.out.emit("")
+ if instr.inst.override:
+ self.out.emit("// Override")
with self.out.block(f"TARGET({name})"):
if instr.predicted:
self.out.emit(f"PREDICTED({name});")
@@ -1190,6 +1247,8 @@ def variable_used(node: parser.Node, name: str) -> bool:
def main():
"""Parse command line, parse input, analyze, write output."""
args = arg_parser.parse_args() # Prints message and sys.exit(2) on error
+ if len(args.input) == 0:
+ args.input.append(DEFAULT_INPUT)
a = Analyzer(args.input, args.output, args.metadata) # Raises OSError if input unreadable
a.parse() # Raises SyntaxError on failure
a.analyze() # Prints messages and sets a.errors on failure
diff --git a/Tools/cases_generator/lexer.py b/Tools/cases_generator/lexer.py
index 39b6a212a67b1c..1c70d1c4089e4e 100644
--- a/Tools/cases_generator/lexer.py
+++ b/Tools/cases_generator/lexer.py
@@ -119,7 +119,7 @@ def choice(*opts):
kwds = (
'AUTO', 'BREAK', 'CASE', 'CHAR', 'CONST',
'CONTINUE', 'DEFAULT', 'DO', 'DOUBLE', 'ELSE', 'ENUM', 'EXTERN',
- 'FLOAT', 'FOR', 'GOTO', 'IF', 'INLINE', 'INT', 'LONG',
+ 'FLOAT', 'FOR', 'GOTO', 'IF', 'INLINE', 'INT', 'LONG', 'OVERRIDE',
'REGISTER', 'OFFSETOF',
'RESTRICT', 'RETURN', 'SHORT', 'SIGNED', 'SIZEOF', 'STATIC', 'STRUCT',
'SWITCH', 'TYPEDEF', 'UNION', 'UNSIGNED', 'VOID',
diff --git a/Tools/cases_generator/parser.py b/Tools/cases_generator/parser.py
index c7c8d8af6b7318..7bf45a350bc84b 100644
--- a/Tools/cases_generator/parser.py
+++ b/Tools/cases_generator/parser.py
@@ -33,7 +33,7 @@ class Context(NamedTuple):
owner: PLexer
def __repr__(self):
- return f"<{self.begin}-{self.end}>"
+ return f"<{self.owner.filename}: {self.begin}-{self.end}>"
@dataclass
@@ -99,6 +99,7 @@ class OpName(Node):
@dataclass
class InstHeader(Node):
+ override: bool
register: bool
kind: Literal["inst", "op", "legacy"] # Legacy means no (inputs -- outputs)
name: str
@@ -108,6 +109,7 @@ class InstHeader(Node):
@dataclass
class InstDef(Node):
+ override: bool
register: bool
kind: Literal["inst", "op", "legacy"]
name: str
@@ -152,17 +154,18 @@ def inst_def(self) -> InstDef | None:
if hdr := self.inst_header():
if block := self.block():
return InstDef(
- hdr.register, hdr.kind, hdr.name, hdr.inputs, hdr.outputs, block
+ hdr.override, hdr.register, hdr.kind, hdr.name, hdr.inputs, hdr.outputs, block
)
raise self.make_syntax_error("Expected block")
return None
@contextual
def inst_header(self) -> InstHeader | None:
- # inst(NAME)
- # | [register] inst(NAME, (inputs -- outputs))
- # | [register] op(NAME, (inputs -- outputs))
+ # [override] inst(NAME)
+ # | [override] [register] inst(NAME, (inputs -- outputs))
+ # | [override] [register] op(NAME, (inputs -- outputs))
# TODO: Make INST a keyword in the lexer.
+ override = bool(self.expect(lx.OVERRIDE))
register = bool(self.expect(lx.REGISTER))
if (tkn := self.expect(lx.IDENTIFIER)) and (kind := tkn.text) in ("inst", "op"):
if self.expect(lx.LPAREN) and (tkn := self.expect(lx.IDENTIFIER)):
@@ -171,10 +174,10 @@ def inst_header(self) -> InstHeader | None:
inp, outp = self.io_effect()
if self.expect(lx.RPAREN):
if (tkn := self.peek()) and tkn.kind == lx.LBRACE:
- return InstHeader(register, kind, name, inp, outp)
+ return InstHeader(override, register, kind, name, inp, outp)
elif self.expect(lx.RPAREN) and kind == "inst":
# No legacy stack effect if kind is "op".
- return InstHeader(register, "legacy", name, [], [])
+ return InstHeader(override, register, "legacy", name, [], [])
return None
def io_effect(self) -> tuple[list[InputEffect], list[OutputEffect]]:
diff --git a/Tools/peg_generator/pegen/c_generator.py b/Tools/peg_generator/pegen/c_generator.py
index c41d87b74d1c49..e72ce7afdc4796 100644
--- a/Tools/peg_generator/pegen/c_generator.py
+++ b/Tools/peg_generator/pegen/c_generator.py
@@ -619,7 +619,8 @@ def _handle_loop_rule_body(self, node: Rule, rhs: Rhs) -> None:
self.add_return("_res")
self.print("}")
self.print("int _mark = p->mark;")
- self.print("int _start_mark = p->mark;")
+ if memoize:
+ self.print("int _start_mark = p->mark;")
self.print("void **_children = PyMem_Malloc(sizeof(void *));")
self.out_of_memory_return(f"!_children")
self.print("Py_ssize_t _children_capacity = 1;")
@@ -642,7 +643,7 @@ def _handle_loop_rule_body(self, node: Rule, rhs: Rhs) -> None:
self.out_of_memory_return(f"!_seq", cleanup_code="PyMem_Free(_children);")
self.print("for (int i = 0; i < _n; i++) asdl_seq_SET_UNTYPED(_seq, i, _children[i]);")
self.print("PyMem_Free(_children);")
- if node.name:
+ if memoize and node.name:
self.print(f"_PyPegen_insert_memo(p, _start_mark, {node.name}_type, _seq);")
self.add_return("_seq")
diff --git a/configure b/configure
index 557519ad86e06d..9e99352f589f21 100755
--- a/configure
+++ b/configure
@@ -1054,6 +1054,7 @@ with_assertions
enable_optimizations
with_lto
enable_bolt
+with_strict_overflow
with_dsymutil
with_address_sanitizer
with_memory_sanitizer
@@ -1825,6 +1826,8 @@ Optional Packages:
--with-lto=[full|thin|no|yes]
enable Link-Time-Optimization in any build (default
is no)
+ --with-strict-overflow if 'yes', add -fstrict-overflow to CFLAGS, else add
+ -fno-strict-overflow (default is no)
--with-dsymutil link debug information into final executable with
dsymutil in macOS (default is no)
--with-address-sanitizer
@@ -8376,6 +8379,64 @@ case $CC in
fi
esac
+save_CFLAGS=$CFLAGS
+CFLAGS="-fstrict-overflow -fno-strict-overflow"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC supports -fstrict-overflow and -fno-strict-overflow" >&5
+$as_echo_n "checking if $CC supports -fstrict-overflow and -fno-strict-overflow... " >&6; }
+if ${ac_cv_cc_supports_fstrict_overflow+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+
+int
+main ()
+{
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+ ac_cv_cc_supports_fstrict_overflow=yes
+else
+ ac_cv_cc_supports_fstrict_overflow=no
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cc_supports_fstrict_overflow" >&5
+$as_echo "$ac_cv_cc_supports_fstrict_overflow" >&6; }
+CFLAGS=$save_CFLAGS
+
+if test "x$ac_cv_cc_supports_fstrict_overflow" = xyes; then :
+ STRICT_OVERFLOW_CFLAGS="-fstrict-overflow"
+ NO_STRICT_OVERFLOW_CFLAGS="-fno-strict-overflow"
+else
+ STRICT_OVERFLOW_CFLAGS=""
+ NO_STRICT_OVERFLOW_CFLAGS=""
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for --with-strict-overflow" >&5
+$as_echo_n "checking for --with-strict-overflow... " >&6; }
+
+# Check whether --with-strict-overflow was given.
+if test "${with_strict_overflow+set}" = set; then :
+ withval=$with_strict_overflow;
+ if test "x$ac_cv_cc_supports_fstrict_overflow" = xno; then :
+ { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-strict-overflow=yes requires a compiler that supports -fstrict-overflow" >&5
+$as_echo "$as_me: WARNING: --with-strict-overflow=yes requires a compiler that supports -fstrict-overflow" >&2;}
+fi
+
+else
+ with_strict_overflow=no
+
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_strict_overflow" >&5
+$as_echo "$with_strict_overflow" >&6; }
+
# Check if CC supports -Og optimization level
save_CFLAGS=$CFLAGS
CFLAGS="-Og"
@@ -8428,15 +8489,8 @@ if test "${OPT-unset}" = "unset"
then
case $GCC in
yes)
- # For gcc 4.x we need to use -fwrapv so lets check if its supported
- if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
- WRAP="-fwrapv"
- fi
-
if test -n "${cc_is_clang}"
then
- # Clang also needs -fwrapv
- WRAP="-fwrapv"
# bpo-30104: disable strict aliasing to compile correctly dtoa.c,
# see Makefile.pre.in for more information
CFLAGS_ALIASING="-fno-strict-aliasing"
@@ -8447,7 +8501,7 @@ then
if test "$Py_DEBUG" = 'true' ; then
OPT="-g $PYDEBUG_CFLAGS -Wall"
else
- OPT="-g $WRAP -O3 -Wall"
+ OPT="-g -O3 -Wall"
fi
;;
*)
@@ -8580,6 +8634,12 @@ UNIVERSAL_ARCH_FLAGS=
# tweak BASECFLAGS based on compiler and platform
+if test "x$with_strict_overflow" = xyes; then :
+ BASECFLAGS="$BASECFLAGS $STRICT_OVERFLOW_CFLAGS"
+else
+ BASECFLAGS="$BASECFLAGS $NO_STRICT_OVERFLOW_CFLAGS"
+fi
+
case $GCC in
yes)
CFLAGS_NODIST="$CFLAGS_NODIST -std=c11"
@@ -27049,7 +27109,7 @@ fi
as_fn_append MODULE_BLOCK "MODULE__CTYPES_STATE=$py_cv_module__ctypes$as_nl"
if test "x$py_cv_module__ctypes" = xyes; then :
- as_fn_append MODULE_BLOCK "MODULE__CTYPES_CFLAGS=$LIBFFI_CFLAGS$as_nl"
+ as_fn_append MODULE_BLOCK "MODULE__CTYPES_CFLAGS=$NO_STRICT_OVERFLOW_CFLAGS $LIBFFI_CFLAGS$as_nl"
as_fn_append MODULE_BLOCK "MODULE__CTYPES_LDFLAGS=$LIBFFI_LIBS$as_nl"
fi
diff --git a/configure.ac b/configure.ac
index 982f669acbcfe5..31b7a2157a2bcc 100644
--- a/configure.ac
+++ b/configure.ac
@@ -2073,6 +2073,45 @@ case $CC in
fi
esac
+dnl Historically, some of our code assumed that signed integer overflow
+dnl is defined behaviour via twos-complement.
+dnl Set STRICT_OVERFLOW_CFLAGS and NO_STRICT_OVERFLOW_CFLAGS depending on compiler support.
+dnl Pass the latter to modules that depend on such behaviour.
+_SAVE_VAR([CFLAGS])
+CFLAGS="-fstrict-overflow -fno-strict-overflow"
+AC_CACHE_CHECK([if $CC supports -fstrict-overflow and -fno-strict-overflow],
+ [ac_cv_cc_supports_fstrict_overflow],
+ AC_COMPILE_IFELSE(
+ [AC_LANG_PROGRAM([[]], [[]])],
+ [ac_cv_cc_supports_fstrict_overflow=yes],
+ [ac_cv_cc_supports_fstrict_overflow=no]
+ )
+)
+_RESTORE_VAR([CFLAGS])
+
+AS_VAR_IF([ac_cv_cc_supports_fstrict_overflow], [yes],
+ [STRICT_OVERFLOW_CFLAGS="-fstrict-overflow"
+ NO_STRICT_OVERFLOW_CFLAGS="-fno-strict-overflow"],
+ [STRICT_OVERFLOW_CFLAGS=""
+ NO_STRICT_OVERFLOW_CFLAGS=""])
+
+AC_MSG_CHECKING([for --with-strict-overflow])
+AC_ARG_WITH([strict-overflow],
+ AS_HELP_STRING(
+ [--with-strict-overflow],
+ [if 'yes', add -fstrict-overflow to CFLAGS, else add -fno-strict-overflow (default is no)]
+ ),
+ [
+ AS_VAR_IF(
+ [ac_cv_cc_supports_fstrict_overflow], [no],
+ [AC_MSG_WARN([--with-strict-overflow=yes requires a compiler that supports -fstrict-overflow])],
+ []
+ )
+ ],
+ [with_strict_overflow=no]
+)
+AC_MSG_RESULT([$with_strict_overflow])
+
# Check if CC supports -Og optimization level
_SAVE_VAR([CFLAGS])
CFLAGS="-Og"
@@ -2103,15 +2142,8 @@ if test "${OPT-unset}" = "unset"
then
case $GCC in
yes)
- # For gcc 4.x we need to use -fwrapv so lets check if its supported
- if "$CC" -v --help 2>/dev/null |grep -- -fwrapv > /dev/null; then
- WRAP="-fwrapv"
- fi
-
if test -n "${cc_is_clang}"
then
- # Clang also needs -fwrapv
- WRAP="-fwrapv"
# bpo-30104: disable strict aliasing to compile correctly dtoa.c,
# see Makefile.pre.in for more information
CFLAGS_ALIASING="-fno-strict-aliasing"
@@ -2122,7 +2154,7 @@ then
if test "$Py_DEBUG" = 'true' ; then
OPT="-g $PYDEBUG_CFLAGS -Wall"
else
- OPT="-g $WRAP -O3 -Wall"
+ OPT="-g -O3 -Wall"
fi
;;
*)
@@ -2237,6 +2269,10 @@ AC_DEFUN([PY_CHECK_CC_WARNING], [
])
# tweak BASECFLAGS based on compiler and platform
+AS_VAR_IF([with_strict_overflow], [yes],
+ [BASECFLAGS="$BASECFLAGS $STRICT_OVERFLOW_CFLAGS"],
+ [BASECFLAGS="$BASECFLAGS $NO_STRICT_OVERFLOW_CFLAGS"])
+
case $GCC in
yes)
CFLAGS_NODIST="$CFLAGS_NODIST -std=c11"
@@ -7213,7 +7249,7 @@ PY_STDLIB_MOD([_crypt],
[$LIBCRYPT_CFLAGS], [$LIBCRYPT_LIBS])
PY_STDLIB_MOD([_ctypes],
[], [test "$have_libffi" = yes],
- [$LIBFFI_CFLAGS], [$LIBFFI_LIBS])
+ [$NO_STRICT_OVERFLOW_CFLAGS $LIBFFI_CFLAGS], [$LIBFFI_LIBS])
PY_STDLIB_MOD([_curses],
[], [test "$have_curses" != "no"],
[$CURSES_CFLAGS], [$CURSES_LIBS]