From ef28abff17ef8a0d0ee3837121cc68f36efd8aa3 Mon Sep 17 00:00:00 2001 From: twoone3 <3197653242@qq.com> Date: Fri, 19 Aug 2022 17:42:48 +0800 Subject: [PATCH] =?UTF-8?q?v2.1.0=E6=9B=B4=E6=96=B0=20-=20=E6=9B=B4?= =?UTF-8?q?=E6=96=B0python=E7=89=88=E6=9C=AC=E8=87=B33.10.6=20-=20?= =?UTF-8?q?=E6=8F=90=E9=AB=98=E4=BA=86=E7=A8=B3=E5=AE=9A=E6=80=A7?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- BDSpyrunner.vcxproj | 4 +- BDSpyrunner.vcxproj.filters | 3 - SDK | 2 +- include/Python-ast.h | 637 -------- include/Python.h | 57 +- include/abstract.h | 334 +--- include/asdl.h | 46 - include/ast.h | 29 - include/bitset.h | 32 - include/boolobject.h | 17 +- include/bytearrayobject.h | 24 +- include/bytesobject.h | 185 +-- include/cellobject.h | 4 +- include/ceval.h | 139 +- include/classobject.h | 7 +- include/code.h | 145 +- include/codecs.h | 8 + include/compile.h | 88 +- include/complexobject.h | 2 +- include/context.h | 9 +- include/cpython/abstract.h | 373 +++++ include/cpython/bytearrayobject.h | 20 + include/cpython/bytesobject.h | 118 ++ include/cpython/ceval.h | 30 + include/cpython/code.h | 184 +++ include/cpython/compile.h | 54 + include/cpython/dictobject.h | 84 + include/cpython/fileobject.h | 18 + include/cpython/fileutils.h | 172 +++ include/cpython/frameobject.h | 94 ++ include/cpython/import.h | 46 + include/cpython/initconfig.h | 249 +++ include/cpython/interpreteridobject.h | 11 + include/cpython/listobject.h | 34 + include/cpython/methodobject.h | 35 + include/cpython/object.h | 552 +++++++ include/cpython/objimpl.h | 100 ++ include/{ => cpython}/odictobject.h | 12 +- include/cpython/picklebufobject.h | 31 + include/{ => cpython}/pyctype.h | 6 + include/{ => cpython}/pydebug.h | 2 - include/cpython/pyerrors.h | 214 +++ include/{ => cpython}/pyfpe.h | 3 + include/cpython/pylifecycle.h | 64 + include/cpython/pymem.h | 98 ++ include/cpython/pystate.h | 305 ++++ include/cpython/pythonrun.h | 121 ++ include/{ => cpython}/pytime.h | 59 +- include/cpython/sysmodule.h | 16 + include/cpython/traceback.h | 14 + include/cpython/tupleobject.h | 28 + include/cpython/unicodeobject.h | 1169 ++++++++++++++ include/datetime.h | 46 +- include/descrobject.h | 6 +- include/dictobject.h | 152 +- include/errcode.h | 2 +- include/eval.h | 10 - include/exports.h | 30 + include/fileobject.h | 18 +- include/fileutils.h | 181 +-- include/floatobject.h | 14 +- include/frameobject.h | 85 +- include/funcobject.h | 39 +- include/genericaliasobject.h | 14 + include/genobject.h | 29 +- include/graminit.h | 89 -- include/grammar.h | 94 -- include/import.h | 59 +- include/internal/ceval.h | 52 - include/internal/import.h | 6 - include/internal/pycore_abstract.h | 22 + include/{accu.h => internal/pycore_accu.h} | 20 +- include/internal/pycore_asdl.h | 112 ++ include/internal/pycore_ast.h | 855 +++++++++++ include/internal/pycore_ast_state.h | 255 ++++ .../{pyatomic.h => internal/pycore_atomic.h} | 112 +- include/internal/pycore_atomic_funcs.h | 94 ++ include/internal/pycore_bitutils.h | 176 +++ .../internal/pycore_blocks_output_buffer.h | 317 ++++ .../pycore_bytes_methods.h} | 4 + include/internal/pycore_call.h | 39 + include/internal/pycore_ceval.h | 114 ++ include/internal/pycore_code.h | 34 + include/internal/pycore_compile.h | 44 + .../internal/{condvar.h => pycore_condvar.h} | 4 + .../internal/{context.h => pycore_context.h} | 9 +- include/{dtoa.h => internal/pycore_dtoa.h} | 12 +- include/internal/pycore_fileutils.h | 71 + include/internal/pycore_format.h | 27 + include/internal/{mem.h => pycore_gc.h} | 142 +- .../internal/{pygetopt.h => pycore_getopt.h} | 11 +- include/internal/{gil.h => pycore_gil.h} | 10 +- include/internal/{hamt.h => pycore_hamt.h} | 19 +- include/internal/pycore_hashtable.h | 148 ++ include/internal/pycore_import.h | 17 + include/internal/pycore_initconfig.h | 176 +++ include/internal/pycore_interp.h | 337 ++++ include/internal/pycore_list.h | 20 + include/internal/pycore_long.h | 40 + include/internal/pycore_moduleobject.h | 42 + include/internal/pycore_object.h | 186 +++ include/internal/pycore_parser.h | 31 + include/internal/pycore_pathconfig.h | 73 + include/internal/pycore_pyarena.h | 64 + include/internal/pycore_pyerrors.h | 96 ++ include/internal/{hash.h => pycore_pyhash.h} | 4 + include/internal/pycore_pylifecycle.h | 141 ++ include/internal/pycore_pymem.h | 101 ++ include/internal/pycore_pystate.h | 153 ++ include/internal/pycore_runtime.h | 157 ++ include/internal/pycore_structseq.h | 21 + .../pycore_symtable.h} | 57 +- include/internal/pycore_sysmodule.h | 24 + include/internal/pycore_traceback.h | 93 ++ include/internal/pycore_tuple.h | 20 + include/internal/pycore_ucnhash.h | 34 + include/internal/pycore_unionobject.h | 22 + .../{warnings.h => pycore_warnings.h} | 6 +- include/internal/pystate.h | 135 -- include/interpreteridobject.h | 17 + include/intrcheck.h | 5 +- include/iterobject.h | 8 +- include/listobject.h | 61 +- include/longobject.h | 24 +- include/magic_enum/magic_enum.hpp | 101 +- include/memoryobject.h | 2 +- include/metagrammar.h | 18 - include/methodobject.h | 91 +- include/modsupport.h | 36 +- include/moduleobject.h | 11 +- include/node.h | 44 - include/object.h | 858 +++-------- include/objimpl.h | 245 +-- include/opcode.h | 63 +- include/osdefs.h | 4 + include/parsetok.h | 108 -- include/patchlevel.h | 6 +- include/pgen.h | 18 - include/pgenheaders.h | 43 - include/py_curses.h | 62 +- include/pyarena.h | 64 - include/pycapsule.h | 2 +- include/pyconfig.h | 38 +- include/pydtrace.h | 2 + include/pyerrors.h | 215 +-- include/pyframe.h | 22 + include/pyhash.h | 11 +- include/pylifecycle.h | 190 +-- include/pymacro.h | 42 +- include/pymath.h | 2 +- include/pymem.h | 172 +-- include/pyport.h | 202 ++- include/pystate.h | 408 +---- include/pystrhex.h | 3 + include/pythonrun.h | 151 +- include/pythread.h | 38 +- include/rangeobject.h | 2 +- include/setobject.h | 18 +- include/sliceobject.h | 6 +- include/structmember.h | 1 + include/structseq.h | 2 +- include/sysmodule.h | 13 +- include/token.h | 27 +- include/traceback.h | 105 +- include/tracemalloc.h | 38 + include/tupleobject.h | 35 +- include/typeslots.h | 9 + include/ucnhash.h | 36 - include/unicodeobject.h | 1349 +---------------- include/weakrefobject.h | 6 +- lib/python310.lib | Bin 0 -> 356438 bytes lib/python37.lib | Bin 342420 -> 0 bytes src/api/event.cpp | 19 +- src/main.cpp | 11 +- src/py_utils.h | 13 +- 175 files changed, 10080 insertions(+), 6712 deletions(-) delete mode 100644 include/Python-ast.h delete mode 100644 include/asdl.h delete mode 100644 include/ast.h delete mode 100644 include/bitset.h create mode 100644 include/cpython/abstract.h create mode 100644 include/cpython/bytearrayobject.h create mode 100644 include/cpython/bytesobject.h create mode 100644 include/cpython/ceval.h create mode 100644 include/cpython/code.h create mode 100644 include/cpython/compile.h create mode 100644 include/cpython/dictobject.h create mode 100644 include/cpython/fileobject.h create mode 100644 include/cpython/fileutils.h create mode 100644 include/cpython/frameobject.h create mode 100644 include/cpython/import.h create mode 100644 include/cpython/initconfig.h create mode 100644 include/cpython/interpreteridobject.h create mode 100644 include/cpython/listobject.h create mode 100644 include/cpython/methodobject.h create mode 100644 include/cpython/object.h create mode 100644 include/cpython/objimpl.h rename include/{ => cpython}/odictobject.h (71%) create mode 100644 include/cpython/picklebufobject.h rename include/{ => cpython}/pyctype.h (95%) rename include/{ => cpython}/pydebug.h (90%) create mode 100644 include/cpython/pyerrors.h rename include/{ => cpython}/pyfpe.h (76%) create mode 100644 include/cpython/pylifecycle.h create mode 100644 include/cpython/pymem.h create mode 100644 include/cpython/pystate.h create mode 100644 include/cpython/pythonrun.h rename include/{ => cpython}/pytime.h (89%) create mode 100644 include/cpython/sysmodule.h create mode 100644 include/cpython/traceback.h create mode 100644 include/cpython/tupleobject.h create mode 100644 include/cpython/unicodeobject.h create mode 100644 include/exports.h create mode 100644 include/genericaliasobject.h delete mode 100644 include/graminit.h delete mode 100644 include/grammar.h delete mode 100644 include/internal/ceval.h delete mode 100644 include/internal/import.h create mode 100644 include/internal/pycore_abstract.h rename include/{accu.h => internal/pycore_accu.h} (82%) create mode 100644 include/internal/pycore_asdl.h create mode 100644 include/internal/pycore_ast.h create mode 100644 include/internal/pycore_ast_state.h rename include/{pyatomic.h => internal/pycore_atomic.h} (78%) create mode 100644 include/internal/pycore_atomic_funcs.h create mode 100644 include/internal/pycore_bitutils.h create mode 100644 include/internal/pycore_blocks_output_buffer.h rename include/{bytes_methods.h => internal/pycore_bytes_methods.h} (97%) create mode 100644 include/internal/pycore_call.h create mode 100644 include/internal/pycore_ceval.h create mode 100644 include/internal/pycore_code.h create mode 100644 include/internal/pycore_compile.h rename include/internal/{condvar.h => pycore_condvar.h} (97%) rename include/internal/{context.h => pycore_context.h} (78%) rename include/{dtoa.h => internal/pycore_dtoa.h} (66%) create mode 100644 include/internal/pycore_fileutils.h create mode 100644 include/internal/pycore_format.h rename include/internal/{mem.h => pycore_gc.h} (58%) rename include/internal/{pygetopt.h => pycore_getopt.h} (52%) rename include/internal/{gil.h => pycore_gil.h} (84%) rename include/internal/{hamt.h => pycore_hamt.h} (80%) create mode 100644 include/internal/pycore_hashtable.h create mode 100644 include/internal/pycore_import.h create mode 100644 include/internal/pycore_initconfig.h create mode 100644 include/internal/pycore_interp.h create mode 100644 include/internal/pycore_list.h create mode 100644 include/internal/pycore_long.h create mode 100644 include/internal/pycore_moduleobject.h create mode 100644 include/internal/pycore_object.h create mode 100644 include/internal/pycore_parser.h create mode 100644 include/internal/pycore_pathconfig.h create mode 100644 include/internal/pycore_pyarena.h create mode 100644 include/internal/pycore_pyerrors.h rename include/internal/{hash.h => pycore_pyhash.h} (59%) create mode 100644 include/internal/pycore_pylifecycle.h create mode 100644 include/internal/pycore_pymem.h create mode 100644 include/internal/pycore_pystate.h create mode 100644 include/internal/pycore_runtime.h create mode 100644 include/internal/pycore_structseq.h rename include/{symtable.h => internal/pycore_symtable.h} (74%) create mode 100644 include/internal/pycore_sysmodule.h create mode 100644 include/internal/pycore_traceback.h create mode 100644 include/internal/pycore_tuple.h create mode 100644 include/internal/pycore_ucnhash.h create mode 100644 include/internal/pycore_unionobject.h rename include/internal/{warnings.h => pycore_warnings.h} (77%) delete mode 100644 include/internal/pystate.h create mode 100644 include/interpreteridobject.h delete mode 100644 include/metagrammar.h delete mode 100644 include/node.h delete mode 100644 include/parsetok.h delete mode 100644 include/pgen.h delete mode 100644 include/pgenheaders.h delete mode 100644 include/pyarena.h create mode 100644 include/pyframe.h create mode 100644 include/tracemalloc.h delete mode 100644 include/ucnhash.h create mode 100644 lib/python310.lib delete mode 100644 lib/python37.lib diff --git a/BDSpyrunner.vcxproj b/BDSpyrunner.vcxproj index 80dac490..696fa676 100644 --- a/BDSpyrunner.vcxproj +++ b/BDSpyrunner.vcxproj @@ -54,6 +54,7 @@ NotUsing pch.h /utf-8 %(AdditionalOptions) + Sync Console @@ -61,7 +62,7 @@ true true bedrock_server.dll - %(AdditionalLibraryDirectories) + lib;%(AdditionalLibraryDirectories) if exist ..\BDS\plugins ( @@ -107,7 +108,6 @@ copy $(OutputPath)$(ProjectName).pdb ..\BDS\plugins\$(ProjectName).pdb - diff --git a/BDSpyrunner.vcxproj.filters b/BDSpyrunner.vcxproj.filters index 218c264d..ce74cd45 100644 --- a/BDSpyrunner.vcxproj.filters +++ b/BDSpyrunner.vcxproj.filters @@ -115,9 +115,6 @@ - - 库文件 - 库文件 diff --git a/SDK b/SDK index 2ee36e40..4703d95a 160000 --- a/SDK +++ b/SDK @@ -1 +1 @@ -Subproject commit 2ee36e4043bc3b5648f9119e8bcf6e9bd003dbaf +Subproject commit 4703d95a9a8f862edf55a69e7606e28d1a5321b9 diff --git a/include/Python-ast.h b/include/Python-ast.h deleted file mode 100644 index 8e0f750a..00000000 --- a/include/Python-ast.h +++ /dev/null @@ -1,637 +0,0 @@ -/* File automatically generated by Parser/asdl_c.py. */ - -#include "asdl.h" - -typedef struct _mod *mod_ty; - -typedef struct _stmt *stmt_ty; - -typedef struct _expr *expr_ty; - -typedef enum _expr_context { Load=1, Store=2, Del=3, AugLoad=4, AugStore=5, - Param=6 } expr_context_ty; - -typedef struct _slice *slice_ty; - -typedef enum _boolop { And=1, Or=2 } boolop_ty; - -typedef enum _operator { Add=1, Sub=2, Mult=3, MatMult=4, Div=5, Mod=6, Pow=7, - LShift=8, RShift=9, BitOr=10, BitXor=11, BitAnd=12, - FloorDiv=13 } operator_ty; - -typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty; - -typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8, - In=9, NotIn=10 } cmpop_ty; - -typedef struct _comprehension *comprehension_ty; - -typedef struct _excepthandler *excepthandler_ty; - -typedef struct _arguments *arguments_ty; - -typedef struct _arg *arg_ty; - -typedef struct _keyword *keyword_ty; - -typedef struct _alias *alias_ty; - -typedef struct _withitem *withitem_ty; - - -enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3, - Suite_kind=4}; -struct _mod { - enum _mod_kind kind; - union { - struct { - asdl_seq *body; - } Module; - - struct { - asdl_seq *body; - } Interactive; - - struct { - expr_ty body; - } Expression; - - struct { - asdl_seq *body; - } Suite; - - } v; -}; - -enum _stmt_kind {FunctionDef_kind=1, AsyncFunctionDef_kind=2, ClassDef_kind=3, - Return_kind=4, Delete_kind=5, Assign_kind=6, - AugAssign_kind=7, AnnAssign_kind=8, For_kind=9, - AsyncFor_kind=10, While_kind=11, If_kind=12, With_kind=13, - AsyncWith_kind=14, Raise_kind=15, Try_kind=16, - Assert_kind=17, Import_kind=18, ImportFrom_kind=19, - Global_kind=20, Nonlocal_kind=21, Expr_kind=22, Pass_kind=23, - Break_kind=24, Continue_kind=25}; -struct _stmt { - enum _stmt_kind kind; - union { - struct { - identifier name; - arguments_ty args; - asdl_seq *body; - asdl_seq *decorator_list; - expr_ty returns; - } FunctionDef; - - struct { - identifier name; - arguments_ty args; - asdl_seq *body; - asdl_seq *decorator_list; - expr_ty returns; - } AsyncFunctionDef; - - struct { - identifier name; - asdl_seq *bases; - asdl_seq *keywords; - asdl_seq *body; - asdl_seq *decorator_list; - } ClassDef; - - struct { - expr_ty value; - } Return; - - struct { - asdl_seq *targets; - } Delete; - - struct { - asdl_seq *targets; - expr_ty value; - } Assign; - - struct { - expr_ty target; - operator_ty op; - expr_ty value; - } AugAssign; - - struct { - expr_ty target; - expr_ty annotation; - expr_ty value; - int simple; - } AnnAssign; - - struct { - expr_ty target; - expr_ty iter; - asdl_seq *body; - asdl_seq *orelse; - } For; - - struct { - expr_ty target; - expr_ty iter; - asdl_seq *body; - asdl_seq *orelse; - } AsyncFor; - - struct { - expr_ty test; - asdl_seq *body; - asdl_seq *orelse; - } While; - - struct { - expr_ty test; - asdl_seq *body; - asdl_seq *orelse; - } If; - - struct { - asdl_seq *items; - asdl_seq *body; - } With; - - struct { - asdl_seq *items; - asdl_seq *body; - } AsyncWith; - - struct { - expr_ty exc; - expr_ty cause; - } Raise; - - struct { - asdl_seq *body; - asdl_seq *handlers; - asdl_seq *orelse; - asdl_seq *finalbody; - } Try; - - struct { - expr_ty test; - expr_ty msg; - } Assert; - - struct { - asdl_seq *names; - } Import; - - struct { - identifier module; - asdl_seq *names; - int level; - } ImportFrom; - - struct { - asdl_seq *names; - } Global; - - struct { - asdl_seq *names; - } Nonlocal; - - struct { - expr_ty value; - } Expr; - - } v; - int lineno; - int col_offset; -}; - -enum _expr_kind {BoolOp_kind=1, BinOp_kind=2, UnaryOp_kind=3, Lambda_kind=4, - IfExp_kind=5, Dict_kind=6, Set_kind=7, ListComp_kind=8, - SetComp_kind=9, DictComp_kind=10, GeneratorExp_kind=11, - Await_kind=12, Yield_kind=13, YieldFrom_kind=14, - Compare_kind=15, Call_kind=16, Num_kind=17, Str_kind=18, - FormattedValue_kind=19, JoinedStr_kind=20, Bytes_kind=21, - NameConstant_kind=22, Ellipsis_kind=23, Constant_kind=24, - Attribute_kind=25, Subscript_kind=26, Starred_kind=27, - Name_kind=28, List_kind=29, Tuple_kind=30}; -struct _expr { - enum _expr_kind kind; - union { - struct { - boolop_ty op; - asdl_seq *values; - } BoolOp; - - struct { - expr_ty left; - operator_ty op; - expr_ty right; - } BinOp; - - struct { - unaryop_ty op; - expr_ty operand; - } UnaryOp; - - struct { - arguments_ty args; - expr_ty body; - } Lambda; - - struct { - expr_ty test; - expr_ty body; - expr_ty orelse; - } IfExp; - - struct { - asdl_seq *keys; - asdl_seq *values; - } Dict; - - struct { - asdl_seq *elts; - } Set; - - struct { - expr_ty elt; - asdl_seq *generators; - } ListComp; - - struct { - expr_ty elt; - asdl_seq *generators; - } SetComp; - - struct { - expr_ty key; - expr_ty value; - asdl_seq *generators; - } DictComp; - - struct { - expr_ty elt; - asdl_seq *generators; - } GeneratorExp; - - struct { - expr_ty value; - } Await; - - struct { - expr_ty value; - } Yield; - - struct { - expr_ty value; - } YieldFrom; - - struct { - expr_ty left; - asdl_int_seq *ops; - asdl_seq *comparators; - } Compare; - - struct { - expr_ty func; - asdl_seq *args; - asdl_seq *keywords; - } Call; - - struct { - object n; - } Num; - - struct { - string s; - } Str; - - struct { - expr_ty value; - int conversion; - expr_ty format_spec; - } FormattedValue; - - struct { - asdl_seq *values; - } JoinedStr; - - struct { - bytes s; - } Bytes; - - struct { - singleton value; - } NameConstant; - - struct { - constant value; - } Constant; - - struct { - expr_ty value; - identifier attr; - expr_context_ty ctx; - } Attribute; - - struct { - expr_ty value; - slice_ty slice; - expr_context_ty ctx; - } Subscript; - - struct { - expr_ty value; - expr_context_ty ctx; - } Starred; - - struct { - identifier id; - expr_context_ty ctx; - } Name; - - struct { - asdl_seq *elts; - expr_context_ty ctx; - } List; - - struct { - asdl_seq *elts; - expr_context_ty ctx; - } Tuple; - - } v; - int lineno; - int col_offset; -}; - -enum _slice_kind {Slice_kind=1, ExtSlice_kind=2, Index_kind=3}; -struct _slice { - enum _slice_kind kind; - union { - struct { - expr_ty lower; - expr_ty upper; - expr_ty step; - } Slice; - - struct { - asdl_seq *dims; - } ExtSlice; - - struct { - expr_ty value; - } Index; - - } v; -}; - -struct _comprehension { - expr_ty target; - expr_ty iter; - asdl_seq *ifs; - int is_async; -}; - -enum _excepthandler_kind {ExceptHandler_kind=1}; -struct _excepthandler { - enum _excepthandler_kind kind; - union { - struct { - expr_ty type; - identifier name; - asdl_seq *body; - } ExceptHandler; - - } v; - int lineno; - int col_offset; -}; - -struct _arguments { - asdl_seq *args; - arg_ty vararg; - asdl_seq *kwonlyargs; - asdl_seq *kw_defaults; - arg_ty kwarg; - asdl_seq *defaults; -}; - -struct _arg { - identifier arg; - expr_ty annotation; - int lineno; - int col_offset; -}; - -struct _keyword { - identifier arg; - expr_ty value; -}; - -struct _alias { - identifier name; - identifier asname; -}; - -struct _withitem { - expr_ty context_expr; - expr_ty optional_vars; -}; - - -#define Module(a0, a1) _Py_Module(a0, a1) -mod_ty _Py_Module(asdl_seq * body, PyArena *arena); -#define Interactive(a0, a1) _Py_Interactive(a0, a1) -mod_ty _Py_Interactive(asdl_seq * body, PyArena *arena); -#define Expression(a0, a1) _Py_Expression(a0, a1) -mod_ty _Py_Expression(expr_ty body, PyArena *arena); -#define Suite(a0, a1) _Py_Suite(a0, a1) -mod_ty _Py_Suite(asdl_seq * body, PyArena *arena); -#define FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7) _Py_FunctionDef(a0, a1, a2, a3, a4, a5, a6, a7) -stmt_ty _Py_FunctionDef(identifier name, arguments_ty args, asdl_seq * body, - asdl_seq * decorator_list, expr_ty returns, int lineno, - int col_offset, PyArena *arena); -#define AsyncFunctionDef(a0, a1, a2, a3, a4, a5, a6, a7) _Py_AsyncFunctionDef(a0, a1, a2, a3, a4, a5, a6, a7) -stmt_ty _Py_AsyncFunctionDef(identifier name, arguments_ty args, asdl_seq * - body, asdl_seq * decorator_list, expr_ty returns, - int lineno, int col_offset, PyArena *arena); -#define ClassDef(a0, a1, a2, a3, a4, a5, a6, a7) _Py_ClassDef(a0, a1, a2, a3, a4, a5, a6, a7) -stmt_ty _Py_ClassDef(identifier name, asdl_seq * bases, asdl_seq * keywords, - asdl_seq * body, asdl_seq * decorator_list, int lineno, - int col_offset, PyArena *arena); -#define Return(a0, a1, a2, a3) _Py_Return(a0, a1, a2, a3) -stmt_ty _Py_Return(expr_ty value, int lineno, int col_offset, PyArena *arena); -#define Delete(a0, a1, a2, a3) _Py_Delete(a0, a1, a2, a3) -stmt_ty _Py_Delete(asdl_seq * targets, int lineno, int col_offset, PyArena - *arena); -#define Assign(a0, a1, a2, a3, a4) _Py_Assign(a0, a1, a2, a3, a4) -stmt_ty _Py_Assign(asdl_seq * targets, expr_ty value, int lineno, int - col_offset, PyArena *arena); -#define AugAssign(a0, a1, a2, a3, a4, a5) _Py_AugAssign(a0, a1, a2, a3, a4, a5) -stmt_ty _Py_AugAssign(expr_ty target, operator_ty op, expr_ty value, int - lineno, int col_offset, PyArena *arena); -#define AnnAssign(a0, a1, a2, a3, a4, a5, a6) _Py_AnnAssign(a0, a1, a2, a3, a4, a5, a6) -stmt_ty _Py_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int - simple, int lineno, int col_offset, PyArena *arena); -#define For(a0, a1, a2, a3, a4, a5, a6) _Py_For(a0, a1, a2, a3, a4, a5, a6) -stmt_ty _Py_For(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * - orelse, int lineno, int col_offset, PyArena *arena); -#define AsyncFor(a0, a1, a2, a3, a4, a5, a6) _Py_AsyncFor(a0, a1, a2, a3, a4, a5, a6) -stmt_ty _Py_AsyncFor(expr_ty target, expr_ty iter, asdl_seq * body, asdl_seq * - orelse, int lineno, int col_offset, PyArena *arena); -#define While(a0, a1, a2, a3, a4, a5) _Py_While(a0, a1, a2, a3, a4, a5) -stmt_ty _Py_While(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, - int col_offset, PyArena *arena); -#define If(a0, a1, a2, a3, a4, a5) _Py_If(a0, a1, a2, a3, a4, a5) -stmt_ty _Py_If(expr_ty test, asdl_seq * body, asdl_seq * orelse, int lineno, - int col_offset, PyArena *arena); -#define With(a0, a1, a2, a3, a4) _Py_With(a0, a1, a2, a3, a4) -stmt_ty _Py_With(asdl_seq * items, asdl_seq * body, int lineno, int col_offset, - PyArena *arena); -#define AsyncWith(a0, a1, a2, a3, a4) _Py_AsyncWith(a0, a1, a2, a3, a4) -stmt_ty _Py_AsyncWith(asdl_seq * items, asdl_seq * body, int lineno, int - col_offset, PyArena *arena); -#define Raise(a0, a1, a2, a3, a4) _Py_Raise(a0, a1, a2, a3, a4) -stmt_ty _Py_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, - PyArena *arena); -#define Try(a0, a1, a2, a3, a4, a5, a6) _Py_Try(a0, a1, a2, a3, a4, a5, a6) -stmt_ty _Py_Try(asdl_seq * body, asdl_seq * handlers, asdl_seq * orelse, - asdl_seq * finalbody, int lineno, int col_offset, PyArena - *arena); -#define Assert(a0, a1, a2, a3, a4) _Py_Assert(a0, a1, a2, a3, a4) -stmt_ty _Py_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, - PyArena *arena); -#define Import(a0, a1, a2, a3) _Py_Import(a0, a1, a2, a3) -stmt_ty _Py_Import(asdl_seq * names, int lineno, int col_offset, PyArena - *arena); -#define ImportFrom(a0, a1, a2, a3, a4, a5) _Py_ImportFrom(a0, a1, a2, a3, a4, a5) -stmt_ty _Py_ImportFrom(identifier module, asdl_seq * names, int level, int - lineno, int col_offset, PyArena *arena); -#define Global(a0, a1, a2, a3) _Py_Global(a0, a1, a2, a3) -stmt_ty _Py_Global(asdl_seq * names, int lineno, int col_offset, PyArena - *arena); -#define Nonlocal(a0, a1, a2, a3) _Py_Nonlocal(a0, a1, a2, a3) -stmt_ty _Py_Nonlocal(asdl_seq * names, int lineno, int col_offset, PyArena - *arena); -#define Expr(a0, a1, a2, a3) _Py_Expr(a0, a1, a2, a3) -stmt_ty _Py_Expr(expr_ty value, int lineno, int col_offset, PyArena *arena); -#define Pass(a0, a1, a2) _Py_Pass(a0, a1, a2) -stmt_ty _Py_Pass(int lineno, int col_offset, PyArena *arena); -#define Break(a0, a1, a2) _Py_Break(a0, a1, a2) -stmt_ty _Py_Break(int lineno, int col_offset, PyArena *arena); -#define Continue(a0, a1, a2) _Py_Continue(a0, a1, a2) -stmt_ty _Py_Continue(int lineno, int col_offset, PyArena *arena); -#define BoolOp(a0, a1, a2, a3, a4) _Py_BoolOp(a0, a1, a2, a3, a4) -expr_ty _Py_BoolOp(boolop_ty op, asdl_seq * values, int lineno, int col_offset, - PyArena *arena); -#define BinOp(a0, a1, a2, a3, a4, a5) _Py_BinOp(a0, a1, a2, a3, a4, a5) -expr_ty _Py_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, int - col_offset, PyArena *arena); -#define UnaryOp(a0, a1, a2, a3, a4) _Py_UnaryOp(a0, a1, a2, a3, a4) -expr_ty _Py_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int col_offset, - PyArena *arena); -#define Lambda(a0, a1, a2, a3, a4) _Py_Lambda(a0, a1, a2, a3, a4) -expr_ty _Py_Lambda(arguments_ty args, expr_ty body, int lineno, int col_offset, - PyArena *arena); -#define IfExp(a0, a1, a2, a3, a4, a5) _Py_IfExp(a0, a1, a2, a3, a4, a5) -expr_ty _Py_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, int - col_offset, PyArena *arena); -#define Dict(a0, a1, a2, a3, a4) _Py_Dict(a0, a1, a2, a3, a4) -expr_ty _Py_Dict(asdl_seq * keys, asdl_seq * values, int lineno, int - col_offset, PyArena *arena); -#define Set(a0, a1, a2, a3) _Py_Set(a0, a1, a2, a3) -expr_ty _Py_Set(asdl_seq * elts, int lineno, int col_offset, PyArena *arena); -#define ListComp(a0, a1, a2, a3, a4) _Py_ListComp(a0, a1, a2, a3, a4) -expr_ty _Py_ListComp(expr_ty elt, asdl_seq * generators, int lineno, int - col_offset, PyArena *arena); -#define SetComp(a0, a1, a2, a3, a4) _Py_SetComp(a0, a1, a2, a3, a4) -expr_ty _Py_SetComp(expr_ty elt, asdl_seq * generators, int lineno, int - col_offset, PyArena *arena); -#define DictComp(a0, a1, a2, a3, a4, a5) _Py_DictComp(a0, a1, a2, a3, a4, a5) -expr_ty _Py_DictComp(expr_ty key, expr_ty value, asdl_seq * generators, int - lineno, int col_offset, PyArena *arena); -#define GeneratorExp(a0, a1, a2, a3, a4) _Py_GeneratorExp(a0, a1, a2, a3, a4) -expr_ty _Py_GeneratorExp(expr_ty elt, asdl_seq * generators, int lineno, int - col_offset, PyArena *arena); -#define Await(a0, a1, a2, a3) _Py_Await(a0, a1, a2, a3) -expr_ty _Py_Await(expr_ty value, int lineno, int col_offset, PyArena *arena); -#define Yield(a0, a1, a2, a3) _Py_Yield(a0, a1, a2, a3) -expr_ty _Py_Yield(expr_ty value, int lineno, int col_offset, PyArena *arena); -#define YieldFrom(a0, a1, a2, a3) _Py_YieldFrom(a0, a1, a2, a3) -expr_ty _Py_YieldFrom(expr_ty value, int lineno, int col_offset, PyArena - *arena); -#define Compare(a0, a1, a2, a3, a4, a5) _Py_Compare(a0, a1, a2, a3, a4, a5) -expr_ty _Py_Compare(expr_ty left, asdl_int_seq * ops, asdl_seq * comparators, - int lineno, int col_offset, PyArena *arena); -#define Call(a0, a1, a2, a3, a4, a5) _Py_Call(a0, a1, a2, a3, a4, a5) -expr_ty _Py_Call(expr_ty func, asdl_seq * args, asdl_seq * keywords, int - lineno, int col_offset, PyArena *arena); -#define Num(a0, a1, a2, a3) _Py_Num(a0, a1, a2, a3) -expr_ty _Py_Num(object n, int lineno, int col_offset, PyArena *arena); -#define Str(a0, a1, a2, a3) _Py_Str(a0, a1, a2, a3) -expr_ty _Py_Str(string s, int lineno, int col_offset, PyArena *arena); -#define FormattedValue(a0, a1, a2, a3, a4, a5) _Py_FormattedValue(a0, a1, a2, a3, a4, a5) -expr_ty _Py_FormattedValue(expr_ty value, int conversion, expr_ty format_spec, - int lineno, int col_offset, PyArena *arena); -#define JoinedStr(a0, a1, a2, a3) _Py_JoinedStr(a0, a1, a2, a3) -expr_ty _Py_JoinedStr(asdl_seq * values, int lineno, int col_offset, PyArena - *arena); -#define Bytes(a0, a1, a2, a3) _Py_Bytes(a0, a1, a2, a3) -expr_ty _Py_Bytes(bytes s, int lineno, int col_offset, PyArena *arena); -#define NameConstant(a0, a1, a2, a3) _Py_NameConstant(a0, a1, a2, a3) -expr_ty _Py_NameConstant(singleton value, int lineno, int col_offset, PyArena - *arena); -#define Ellipsis(a0, a1, a2) _Py_Ellipsis(a0, a1, a2) -expr_ty _Py_Ellipsis(int lineno, int col_offset, PyArena *arena); -#define Constant(a0, a1, a2, a3) _Py_Constant(a0, a1, a2, a3) -expr_ty _Py_Constant(constant value, int lineno, int col_offset, PyArena - *arena); -#define Attribute(a0, a1, a2, a3, a4, a5) _Py_Attribute(a0, a1, a2, a3, a4, a5) -expr_ty _Py_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, int - lineno, int col_offset, PyArena *arena); -#define Subscript(a0, a1, a2, a3, a4, a5) _Py_Subscript(a0, a1, a2, a3, a4, a5) -expr_ty _Py_Subscript(expr_ty value, slice_ty slice, expr_context_ty ctx, int - lineno, int col_offset, PyArena *arena); -#define Starred(a0, a1, a2, a3, a4) _Py_Starred(a0, a1, a2, a3, a4) -expr_ty _Py_Starred(expr_ty value, expr_context_ty ctx, int lineno, int - col_offset, PyArena *arena); -#define Name(a0, a1, a2, a3, a4) _Py_Name(a0, a1, a2, a3, a4) -expr_ty _Py_Name(identifier id, expr_context_ty ctx, int lineno, int - col_offset, PyArena *arena); -#define List(a0, a1, a2, a3, a4) _Py_List(a0, a1, a2, a3, a4) -expr_ty _Py_List(asdl_seq * elts, expr_context_ty ctx, int lineno, int - col_offset, PyArena *arena); -#define Tuple(a0, a1, a2, a3, a4) _Py_Tuple(a0, a1, a2, a3, a4) -expr_ty _Py_Tuple(asdl_seq * elts, expr_context_ty ctx, int lineno, int - col_offset, PyArena *arena); -#define Slice(a0, a1, a2, a3) _Py_Slice(a0, a1, a2, a3) -slice_ty _Py_Slice(expr_ty lower, expr_ty upper, expr_ty step, PyArena *arena); -#define ExtSlice(a0, a1) _Py_ExtSlice(a0, a1) -slice_ty _Py_ExtSlice(asdl_seq * dims, PyArena *arena); -#define Index(a0, a1) _Py_Index(a0, a1) -slice_ty _Py_Index(expr_ty value, PyArena *arena); -#define comprehension(a0, a1, a2, a3, a4) _Py_comprehension(a0, a1, a2, a3, a4) -comprehension_ty _Py_comprehension(expr_ty target, expr_ty iter, asdl_seq * - ifs, int is_async, PyArena *arena); -#define ExceptHandler(a0, a1, a2, a3, a4, a5) _Py_ExceptHandler(a0, a1, a2, a3, a4, a5) -excepthandler_ty _Py_ExceptHandler(expr_ty type, identifier name, asdl_seq * - body, int lineno, int col_offset, PyArena - *arena); -#define arguments(a0, a1, a2, a3, a4, a5, a6) _Py_arguments(a0, a1, a2, a3, a4, a5, a6) -arguments_ty _Py_arguments(asdl_seq * args, arg_ty vararg, asdl_seq * - kwonlyargs, asdl_seq * kw_defaults, arg_ty kwarg, - asdl_seq * defaults, PyArena *arena); -#define arg(a0, a1, a2, a3, a4) _Py_arg(a0, a1, a2, a3, a4) -arg_ty _Py_arg(identifier arg, expr_ty annotation, int lineno, int col_offset, - PyArena *arena); -#define keyword(a0, a1, a2) _Py_keyword(a0, a1, a2) -keyword_ty _Py_keyword(identifier arg, expr_ty value, PyArena *arena); -#define alias(a0, a1, a2) _Py_alias(a0, a1, a2) -alias_ty _Py_alias(identifier name, identifier asname, PyArena *arena); -#define withitem(a0, a1, a2) _Py_withitem(a0, a1, a2) -withitem_ty _Py_withitem(expr_ty context_expr, expr_ty optional_vars, PyArena - *arena); - -PyObject* PyAST_mod2obj(mod_ty t); -mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode); -int PyAST_Check(PyObject* obj); diff --git a/include/Python.h b/include/Python.h index 54ea3214..d3186c32 100644 --- a/include/Python.h +++ b/include/Python.h @@ -32,22 +32,9 @@ #include #endif #include -#ifdef HAVE_UNISTD_H +#ifndef MS_WINDOWS #include #endif -#ifdef HAVE_CRYPT_H -#if defined(HAVE_CRYPT_R) && !defined(_GNU_SOURCE) -/* Required for glibc to expose the crypt_r() function prototype. */ -# define _GNU_SOURCE -# define _Py_GNU_SOURCE_FOR_CRYPT -#endif -#include -#ifdef _Py_GNU_SOURCE_FOR_CRYPT -/* Don't leak the _GNU_SOURCE define to other headers. */ -# undef _GNU_SOURCE -# undef _Py_GNU_SOURCE_FOR_CRYPT -#endif -#endif /* For size_t? */ #ifdef HAVE_STDDEF_H @@ -63,28 +50,25 @@ #include "pyport.h" #include "pymacro.h" -/* A convenient way for code to know if clang's memory sanitizer is enabled. */ +/* A convenient way for code to know if sanitizers are enabled. */ #if defined(__has_feature) # if __has_feature(memory_sanitizer) # if !defined(_Py_MEMORY_SANITIZER) # define _Py_MEMORY_SANITIZER # endif # endif +# if __has_feature(address_sanitizer) +# if !defined(_Py_ADDRESS_SANITIZER) +# define _Py_ADDRESS_SANITIZER +# endif +# endif +#elif defined(__GNUC__) +# if defined(__SANITIZE_ADDRESS__) +# define _Py_ADDRESS_SANITIZER +# endif #endif -#include "pyatomic.h" - -/* Debug-mode build with pymalloc implies PYMALLOC_DEBUG. - * PYMALLOC_DEBUG is in error if pymalloc is not in use. - */ -#if defined(Py_DEBUG) && defined(WITH_PYMALLOC) && !defined(PYMALLOC_DEBUG) -#define PYMALLOC_DEBUG -#endif -#if defined(PYMALLOC_DEBUG) && !defined(WITH_PYMALLOC) -#error "PYMALLOC_DEBUG requires WITH_PYMALLOC" -#endif #include "pymath.h" -#include "pytime.h" #include "pymem.h" #include "object.h" @@ -92,7 +76,7 @@ #include "typeslots.h" #include "pyhash.h" -#include "pydebug.h" +#include "cpython/pydebug.h" #include "bytearrayobject.h" #include "bytesobject.h" @@ -107,7 +91,7 @@ #include "tupleobject.h" #include "listobject.h" #include "dictobject.h" -#include "odictobject.h" +#include "cpython/odictobject.h" #include "enumobject.h" #include "setobject.h" #include "methodobject.h" @@ -116,24 +100,29 @@ #include "classobject.h" #include "fileobject.h" #include "pycapsule.h" +#include "code.h" +#include "pyframe.h" #include "traceback.h" #include "sliceobject.h" #include "cellobject.h" #include "iterobject.h" +#include "cpython/initconfig.h" #include "genobject.h" #include "descrobject.h" +#include "genericaliasobject.h" #include "warnings.h" #include "weakrefobject.h" #include "structseq.h" #include "namespaceobject.h" +#include "cpython/picklebufobject.h" +#include "cpython/pytime.h" #include "codecs.h" #include "pyerrors.h" - +#include "pythread.h" #include "pystate.h" #include "context.h" -#include "pyarena.h" #include "modsupport.h" #include "compile.h" #include "pythonrun.h" @@ -149,11 +138,11 @@ #include "eval.h" -#include "pyctype.h" +#include "cpython/pyctype.h" #include "pystrtod.h" #include "pystrcmp.h" -#include "dtoa.h" #include "fileutils.h" -#include "pyfpe.h" +#include "cpython/pyfpe.h" +#include "tracemalloc.h" #endif /* !Py_PYTHON_H */ diff --git a/include/abstract.h b/include/abstract.h index d8f648e2..9eaab6b2 100644 --- a/include/abstract.h +++ b/include/abstract.h @@ -138,9 +138,12 @@ extern "C" { #ifdef PY_SSIZE_T_CLEAN # define PyObject_CallFunction _PyObject_CallFunction_SizeT # define PyObject_CallMethod _PyObject_CallMethod_SizeT -# ifndef Py_LIMITED_API -# define _PyObject_CallMethodId _PyObject_CallMethodId_SizeT -# endif /* !Py_LIMITED_API */ +#endif + + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* Call a callable Python object without any arguments */ +PyAPI_FUNC(PyObject *) PyObject_CallNoArgs(PyObject *func); #endif @@ -155,123 +158,6 @@ extern "C" { PyAPI_FUNC(PyObject *) PyObject_Call(PyObject *callable, PyObject *args, PyObject *kwargs); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) _PyStack_AsTuple( - PyObject *const *stack, - Py_ssize_t nargs); - -PyAPI_FUNC(PyObject*) _PyStack_AsTupleSlice( - PyObject *const *stack, - Py_ssize_t nargs, - Py_ssize_t start, - Py_ssize_t end); - -/* Convert keyword arguments from the FASTCALL (stack: C array, kwnames: tuple) - format to a Python dictionary ("kwargs" dict). - - The type of kwnames keys is not checked. The final function getting - arguments is responsible to check if all keys are strings, for example using - PyArg_ParseTupleAndKeywords() or PyArg_ValidateKeywordArguments(). - - Duplicate keys are merged using the last value. If duplicate keys must raise - an exception, the caller is responsible to implement an explicit keys on - kwnames. */ -PyAPI_FUNC(PyObject *) _PyStack_AsDict( - PyObject *const *values, - PyObject *kwnames); - -/* Convert (args, nargs, kwargs: dict) into a (stack, nargs, kwnames: tuple). - - Return 0 on success, raise an exception and return -1 on error. - - Write the new stack into *p_stack. If *p_stack is differen than args, it - must be released by PyMem_Free(). - - The stack uses borrowed references. - - The type of keyword keys is not checked, these checks should be done - later (ex: _PyArg_ParseStackAndKeywords). */ -PyAPI_FUNC(int) _PyStack_UnpackDict( - PyObject *const *args, - Py_ssize_t nargs, - PyObject *kwargs, - PyObject *const **p_stack, - PyObject **p_kwnames); - -/* Suggested size (number of positional arguments) for arrays of PyObject* - allocated on a C stack to avoid allocating memory on the heap memory. Such - array is used to pass positional arguments to call functions of the - _PyObject_FastCall() family. - - The size is chosen to not abuse the C stack and so limit the risk of stack - overflow. The size is also chosen to allow using the small stack for most - function calls of the Python standard library. On 64-bit CPU, it allocates - 40 bytes on the stack. */ -#define _PY_FASTCALL_SMALL_STACK 5 - -/* Return 1 if callable supports FASTCALL calling convention for positional - arguments: see _PyObject_FastCallDict() and _PyObject_FastCallKeywords() */ -PyAPI_FUNC(int) _PyObject_HasFastCall(PyObject *callable); - -/* Call the callable object 'callable' with the "fast call" calling convention: - args is a C array for positional arguments (nargs is the number of - positional arguments), kwargs is a dictionary for keyword arguments. - - If nargs is equal to zero, args can be NULL. kwargs can be NULL. - nargs must be greater or equal to zero. - - Return the result on success. Raise an exception and return NULL on - error. */ -PyAPI_FUNC(PyObject *) _PyObject_FastCallDict( - PyObject *callable, - PyObject *const *args, - Py_ssize_t nargs, - PyObject *kwargs); - -/* Call the callable object 'callable' with the "fast call" calling convention: - args is a C array for positional arguments followed by values of - keyword arguments. Keys of keyword arguments are stored as a tuple - of strings in kwnames. nargs is the number of positional parameters at - the beginning of stack. The size of kwnames gives the number of keyword - values in the stack after positional arguments. - - kwnames must only contains str strings, no subclass, and all keys must - be unique. - - If nargs is equal to zero and there is no keyword argument (kwnames is - NULL or its size is zero), args can be NULL. - - Return the result on success. Raise an exception and return NULL on - error. */ -PyAPI_FUNC(PyObject *) _PyObject_FastCallKeywords( - PyObject *callable, - PyObject *const *args, - Py_ssize_t nargs, - PyObject *kwnames); - -#define _PyObject_FastCall(func, args, nargs) \ - _PyObject_FastCallDict((func), (args), (nargs), NULL) - -#define _PyObject_CallNoArg(func) \ - _PyObject_FastCallDict((func), NULL, 0, NULL) - -PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend( - PyObject *callable, - PyObject *obj, - PyObject *args, - PyObject *kwargs); - -PyAPI_FUNC(PyObject *) _PyObject_FastCall_Prepend( - PyObject *callable, - PyObject *obj, - PyObject *const *args, - Py_ssize_t nargs); - -PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult(PyObject *callable, - PyObject *result, - const char *where); -#endif /* Py_LIMITED_API */ - /* Call a callable Python object 'callable', with arguments given by the tuple 'args'. If no arguments are needed, then 'args' can be NULL. @@ -309,14 +195,6 @@ PyAPI_FUNC(PyObject *) PyObject_CallMethod(PyObject *obj, const char *name, const char *format, ...); -#ifndef Py_LIMITED_API -/* Like PyObject_CallMethod(), but expect a _Py_Identifier* - as the method name. */ -PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *obj, - _Py_Identifier *name, - const char *format, ...); -#endif /* !Py_LIMITED_API */ - PyAPI_FUNC(PyObject *) _PyObject_CallFunction_SizeT(PyObject *callable, const char *format, ...); @@ -326,13 +204,6 @@ PyAPI_FUNC(PyObject *) _PyObject_CallMethod_SizeT(PyObject *obj, const char *format, ...); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj, - _Py_Identifier *name, - const char *format, - ...); -#endif /* !Py_LIMITED_API */ - /* Call a callable Python object 'callable' with a variable number of C arguments. The C arguments are provided as PyObject* values, terminated by a NULL. @@ -357,13 +228,6 @@ PyAPI_FUNC(PyObject *) PyObject_CallMethodObjArgs( PyObject *name, ...); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs( - PyObject *obj, - struct _Py_Identifier *name, - ...); -#endif /* !Py_LIMITED_API */ - /* Implemented elsewhere: @@ -418,16 +282,6 @@ PyAPI_FUNC(Py_ssize_t) PyObject_Size(PyObject *o); PyAPI_FUNC(Py_ssize_t) PyObject_Length(PyObject *o); #define PyObject_Length PyObject_Size - -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyObject_HasLen(PyObject *o); - -/* Guess the size of object 'o' using len(o) or o.__length_hint__(). - If neither of those return a non-negative value, then return the default - value. If one of the calls fails, this function returns -1. */ -PyAPI_FUNC(Py_ssize_t) PyObject_LengthHint(PyObject *o, Py_ssize_t); -#endif - /* Return element of 'o' corresponding to the object 'key'. Return NULL on failure. @@ -464,21 +318,20 @@ PyAPI_FUNC(int) PyObject_DelItem(PyObject *o, PyObject *key); /* Takes an arbitrary object which must support the (character, single segment) buffer interface and returns a pointer to a read-only memory location - useable as character based input for subsequent processing. + usable as character based input for subsequent processing. Return 0 on success. buffer and buffer_len are only set in case no error occurs. Otherwise, -1 is returned and an exception set. */ +Py_DEPRECATED(3.0) PyAPI_FUNC(int) PyObject_AsCharBuffer(PyObject *obj, const char **buffer, - Py_ssize_t *buffer_len) - Py_DEPRECATED(3.0); + Py_ssize_t *buffer_len); /* Checks whether an arbitrary object supports the (character, single segment) buffer interface. Returns 1 on success, 0 on failure. */ -PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj) - Py_DEPRECATED(3.0); +Py_DEPRECATED(3.0) PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj); /* Same as PyObject_AsCharBuffer() except that this API expects (readable, single segment) buffer interface and returns a pointer to a read-only memory @@ -486,10 +339,10 @@ PyAPI_FUNC(int) PyObject_CheckReadBuffer(PyObject *obj) 0 is returned on success. buffer and buffer_len are only set in case no error occurs. Otherwise, -1 is returned and an exception set. */ +Py_DEPRECATED(3.0) PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj, const void **buffer, - Py_ssize_t *buffer_len) - Py_DEPRECATED(3.0); + Py_ssize_t *buffer_len); /* Takes an arbitrary object which must support the (writable, single segment) buffer interface and returns a pointer to a writable memory location in @@ -497,86 +350,14 @@ PyAPI_FUNC(int) PyObject_AsReadBuffer(PyObject *obj, Return 0 on success. buffer and buffer_len are only set in case no error occurs. Otherwise, -1 is returned and an exception set. */ +Py_DEPRECATED(3.0) PyAPI_FUNC(int) PyObject_AsWriteBuffer(PyObject *obj, void **buffer, - Py_ssize_t *buffer_len) - Py_DEPRECATED(3.0); + Py_ssize_t *buffer_len); /* === New Buffer API ============================================ */ -#ifndef Py_LIMITED_API - -/* Return 1 if the getbuffer function is available, otherwise return 0. */ -#define PyObject_CheckBuffer(obj) \ - (((obj)->ob_type->tp_as_buffer != NULL) && \ - ((obj)->ob_type->tp_as_buffer->bf_getbuffer != NULL)) - -/* This is a C-API version of the getbuffer function call. It checks - to make sure object has the required function pointer and issues the - call. - - Returns -1 and raises an error on failure and returns 0 on success. */ -PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view, - int flags); - -/* Get the memory area pointed to by the indices for the buffer given. - Note that view->ndim is the assumed size of indices. */ -PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices); - -/* Return the implied itemsize of the data-format area from a - struct-style description. */ -PyAPI_FUNC(int) PyBuffer_SizeFromFormat(const char *); - -/* Implementation in memoryobject.c */ -PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view, - Py_ssize_t len, char order); - -PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf, - Py_ssize_t len, char order); - -/* Copy len bytes of data from the contiguous chunk of memory - pointed to by buf into the buffer exported by obj. Return - 0 on success and return -1 and raise a PyBuffer_Error on - error (i.e. the object does not have a buffer interface or - it is not working). - - If fort is 'F', then if the object is multi-dimensional, - then the data will be copied into the array in - Fortran-style (first dimension varies the fastest). If - fort is 'C', then the data will be copied into the array - in C-style (last dimension varies the fastest). If fort - is 'A', then it does not matter and the copy will be made - in whatever way is more efficient. */ -PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src); - -/* Copy the data from the src buffer to the buffer of destination. */ -PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort); - -/*Fill the strides array with byte-strides of a contiguous - (Fortran-style if fort is 'F' or C-style otherwise) - array of the given shape with the given number of bytes - per element. */ -PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims, - Py_ssize_t *shape, - Py_ssize_t *strides, - int itemsize, - char fort); - -/* Fills in a buffer-info structure correctly for an exporter - that can only share a contiguous chunk of memory of - "unsigned bytes" of the given length. - - Returns 0 on success and -1 (with raising an error) on error. */ -PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf, - Py_ssize_t len, int readonly, - int flags); - -/* Releases a Py_buffer obtained from getbuffer ParseTuple's "s*". */ -PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view); - -#endif /* Py_LIMITED_API */ - /* Takes an arbitrary object and returns the result of calling obj.__format__(format_spec). */ PyAPI_FUNC(PyObject *) PyObject_Format(PyObject *obj, @@ -590,9 +371,20 @@ PyAPI_FUNC(PyObject *) PyObject_Format(PyObject *obj, returns itself. */ PyAPI_FUNC(PyObject *) PyObject_GetIter(PyObject *); -#define PyIter_Check(obj) \ - ((obj)->ob_type->tp_iternext != NULL && \ - (obj)->ob_type->tp_iternext != &_PyObject_NextNotImplemented) +/* Takes an AsyncIterable object and returns an AsyncIterator for it. + This is typically a new iterator but if the argument is an AsyncIterator, + this returns itself. */ +PyAPI_FUNC(PyObject *) PyObject_GetAIter(PyObject *); + +/* Returns non-zero if the object 'obj' provides iterator protocols, and 0 otherwise. + + This function always succeeds. */ +PyAPI_FUNC(int) PyIter_Check(PyObject *); + +/* Returns non-zero if the object 'obj' provides AsyncIterator protocols, and 0 otherwise. + + This function always succeeds. */ +PyAPI_FUNC(int) PyAIter_Check(PyObject *); /* Takes an iterator object and calls its tp_iternext slot, returning the next value. @@ -603,6 +395,19 @@ PyAPI_FUNC(PyObject *) PyObject_GetIter(PyObject *); NULL with an exception means an error occurred. */ PyAPI_FUNC(PyObject *) PyIter_Next(PyObject *); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 + +/* Takes generator, coroutine or iterator object and sends the value into it. + Returns: + - PYGEN_RETURN (0) if generator has returned. + 'result' parameter is filled with return value + - PYGEN_ERROR (-1) if exception was raised. + 'result' parameter is NULL + - PYGEN_NEXT (1) if generator has yielded. + 'result' parameter is filled with yielded value. */ +PyAPI_FUNC(PySendResult) PyIter_Send(PyObject *, PyObject *, PyObject **); +#endif + /* === Number Protocol ================================================== */ @@ -710,9 +515,9 @@ PyAPI_FUNC(PyObject *) PyNumber_Xor(PyObject *o1, PyObject *o2); This is the equivalent of the Python expression: o1 | o2. */ PyAPI_FUNC(PyObject *) PyNumber_Or(PyObject *o1, PyObject *o2); -#define PyIndex_Check(obj) \ - ((obj)->ob_type->tp_as_number != NULL && \ - (obj)->ob_type->tp_as_number->nb_index != NULL) +/* Returns 1 if obj is an index integer (has the nb_index slot of the + tp_as_number structure filled in), and 0 otherwise. */ +PyAPI_FUNC(int) PyIndex_Check(PyObject *); /* Returns the object 'o' converted to a Python int, or NULL with an exception raised on failure. */ @@ -919,13 +724,8 @@ PyAPI_FUNC(PyObject *) PySequence_Fast(PyObject *o, const char* m); #define PySequence_Fast_GET_ITEM(o, i)\ (PyList_Check(o) ? PyList_GET_ITEM(o, i) : PyTuple_GET_ITEM(o, i)) -/* Assume tp_as_sequence and sq_item exist and that 'i' does not - need to be corrected for a negative index. */ -#define PySequence_ITEM(o, i)\ - ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) ) - /* Return a pointer to the underlying item array for - an object retured by PySequence_Fast */ + an object returned by PySequence_Fast */ #define PySequence_Fast_ITEMS(sf) \ (PyList_Check(sf) ? ((PyListObject *)(sf))->ob_item \ : ((PyTupleObject *)(sf))->ob_item) @@ -943,27 +743,6 @@ PyAPI_FUNC(Py_ssize_t) PySequence_Count(PyObject *o, PyObject *value); Use __contains__ if possible, else _PySequence_IterSearch(). */ PyAPI_FUNC(int) PySequence_Contains(PyObject *seq, PyObject *ob); -#ifndef Py_LIMITED_API -#define PY_ITERSEARCH_COUNT 1 -#define PY_ITERSEARCH_INDEX 2 -#define PY_ITERSEARCH_CONTAINS 3 - -/* Iterate over seq. - - Result depends on the operation: - - PY_ITERSEARCH_COUNT: return # of times obj appears in seq; -1 if - error. - PY_ITERSEARCH_INDEX: return 0-based index of first occurrence of - obj in seq; set ValueError and return -1 if none found; - also return -1 on error. - PY_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on - error. */ -PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq, - PyObject *obj, int operation); -#endif - - /* For DLL-level backwards compatibility */ #undef PySequence_In /* Determine if the sequence 'o' contains 'value'. If an item in 'o' is equal @@ -1082,26 +861,11 @@ PyAPI_FUNC(int) PyObject_IsInstance(PyObject *object, PyObject *typeorclass); /* issubclass(object, typeorclass) */ PyAPI_FUNC(int) PyObject_IsSubclass(PyObject *object, PyObject *typeorclass); - #ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyObject_RealIsInstance(PyObject *inst, PyObject *cls); - -PyAPI_FUNC(int) _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls); - -PyAPI_FUNC(char *const *) _PySequence_BytesToCharpArray(PyObject* self); - -PyAPI_FUNC(void) _Py_FreeCharPArray(char *const array[]); - -/* For internal use by buffer API functions */ -PyAPI_FUNC(void) _Py_add_one_to_index_F(int nd, Py_ssize_t *index, - const Py_ssize_t *shape); -PyAPI_FUNC(void) _Py_add_one_to_index_C(int nd, Py_ssize_t *index, - const Py_ssize_t *shape); - -/* Convert Python int to Py_ssize_t. Do nothing if the argument is None. */ -PyAPI_FUNC(int) _Py_convert_optional_to_ssize_t(PyObject *, void *); -#endif /* !Py_LIMITED_API */ - +# define Py_CPYTHON_ABSTRACTOBJECT_H +# include "cpython/abstract.h" +# undef Py_CPYTHON_ABSTRACTOBJECT_H +#endif #ifdef __cplusplus } diff --git a/include/asdl.h b/include/asdl.h deleted file mode 100644 index 35e9fa18..00000000 --- a/include/asdl.h +++ /dev/null @@ -1,46 +0,0 @@ -#ifndef Py_ASDL_H -#define Py_ASDL_H - -typedef PyObject * identifier; -typedef PyObject * string; -typedef PyObject * bytes; -typedef PyObject * object; -typedef PyObject * singleton; -typedef PyObject * constant; - -/* It would be nice if the code generated by asdl_c.py was completely - independent of Python, but it is a goal the requires too much work - at this stage. So, for example, I'll represent identifiers as - interned Python strings. -*/ - -/* XXX A sequence should be typed so that its use can be typechecked. */ - -typedef struct { - Py_ssize_t size; - void *elements[1]; -} asdl_seq; - -typedef struct { - Py_ssize_t size; - int elements[1]; -} asdl_int_seq; - -asdl_seq *_Py_asdl_seq_new(Py_ssize_t size, PyArena *arena); -asdl_int_seq *_Py_asdl_int_seq_new(Py_ssize_t size, PyArena *arena); - -#define asdl_seq_GET(S, I) (S)->elements[(I)] -#define asdl_seq_LEN(S) ((S) == NULL ? 0 : (S)->size) -#ifdef Py_DEBUG -#define asdl_seq_SET(S, I, V) \ - do { \ - Py_ssize_t _asdl_i = (I); \ - assert((S) != NULL); \ - assert(_asdl_i < (S)->size); \ - (S)->elements[_asdl_i] = (V); \ - } while (0) -#else -#define asdl_seq_SET(S, I, V) (S)->elements[I] = (V) -#endif - -#endif /* !Py_ASDL_H */ diff --git a/include/ast.h b/include/ast.h deleted file mode 100644 index 5bc2b05b..00000000 --- a/include/ast.h +++ /dev/null @@ -1,29 +0,0 @@ -#ifndef Py_AST_H -#define Py_AST_H -#ifdef __cplusplus -extern "C" { -#endif - -PyAPI_FUNC(int) PyAST_Validate(mod_ty); -PyAPI_FUNC(mod_ty) PyAST_FromNode( - const node *n, - PyCompilerFlags *flags, - const char *filename, /* decoded from the filesystem encoding */ - PyArena *arena); -PyAPI_FUNC(mod_ty) PyAST_FromNodeObject( - const node *n, - PyCompilerFlags *flags, - PyObject *filename, - PyArena *arena); - -#ifndef Py_LIMITED_API - -/* _PyAST_ExprAsUnicode is defined in ast_unparse.c */ -PyAPI_FUNC(PyObject *) _PyAST_ExprAsUnicode(expr_ty); - -#endif /* !Py_LIMITED_API */ - -#ifdef __cplusplus -} -#endif -#endif /* !Py_AST_H */ diff --git a/include/bitset.h b/include/bitset.h deleted file mode 100644 index b22fa778..00000000 --- a/include/bitset.h +++ /dev/null @@ -1,32 +0,0 @@ - -#ifndef Py_BITSET_H -#define Py_BITSET_H -#ifdef __cplusplus -extern "C" { -#endif - -/* Bitset interface */ - -#define BYTE char - -typedef BYTE *bitset; - -bitset newbitset(int nbits); -void delbitset(bitset bs); -#define testbit(ss, ibit) (((ss)[BIT2BYTE(ibit)] & BIT2MASK(ibit)) != 0) -int addbit(bitset bs, int ibit); /* Returns 0 if already set */ -int samebitset(bitset bs1, bitset bs2, int nbits); -void mergebitset(bitset bs1, bitset bs2, int nbits); - -#define BITSPERBYTE (8*sizeof(BYTE)) -#define NBYTES(nbits) (((nbits) + BITSPERBYTE - 1) / BITSPERBYTE) - -#define BIT2BYTE(ibit) ((ibit) / BITSPERBYTE) -#define BIT2SHIFT(ibit) ((ibit) % BITSPERBYTE) -#define BIT2MASK(ibit) (1 << BIT2SHIFT(ibit)) -#define BYTE2BIT(ibyte) ((ibyte) * BITSPERBYTE) - -#ifdef __cplusplus -} -#endif -#endif /* !Py_BITSET_H */ diff --git a/include/boolobject.h b/include/boolobject.h index 7cc2f1fe..cda6f89a 100644 --- a/include/boolobject.h +++ b/include/boolobject.h @@ -9,21 +9,30 @@ extern "C" { PyAPI_DATA(PyTypeObject) PyBool_Type; -#define PyBool_Check(x) (Py_TYPE(x) == &PyBool_Type) +#define PyBool_Check(x) Py_IS_TYPE(x, &PyBool_Type) /* Py_False and Py_True are the only two bools in existence. Don't forget to apply Py_INCREF() when returning either!!! */ /* Don't use these directly */ -PyAPI_DATA(struct _longobject) _Py_FalseStruct, _Py_TrueStruct; +PyAPI_DATA(struct _longobject) _Py_FalseStruct; +PyAPI_DATA(struct _longobject) _Py_TrueStruct; /* Use these macros */ #define Py_False ((PyObject *) &_Py_FalseStruct) #define Py_True ((PyObject *) &_Py_TrueStruct) +// Test if an object is the True singleton, the same as "x is True" in Python. +PyAPI_FUNC(int) Py_IsTrue(PyObject *x); +#define Py_IsTrue(x) Py_Is((x), Py_True) + +// Test if an object is the False singleton, the same as "x is False" in Python. +PyAPI_FUNC(int) Py_IsFalse(PyObject *x); +#define Py_IsFalse(x) Py_Is((x), Py_False) + /* Macros for returning Py_True or Py_False, respectively */ -#define Py_RETURN_TRUE return Py_INCREF(Py_True), Py_True -#define Py_RETURN_FALSE return Py_INCREF(Py_False), Py_False +#define Py_RETURN_TRUE return Py_NewRef(Py_True) +#define Py_RETURN_FALSE return Py_NewRef(Py_False) /* Function to return a bool from a C long */ PyAPI_FUNC(PyObject *) PyBool_FromLong(long); diff --git a/include/bytearrayobject.h b/include/bytearrayobject.h index a757b880..9e95433f 100644 --- a/include/bytearrayobject.h +++ b/include/bytearrayobject.h @@ -18,25 +18,13 @@ extern "C" { * to contain a char pointer, not an unsigned char pointer. */ -/* Object layout */ -#ifndef Py_LIMITED_API -typedef struct { - PyObject_VAR_HEAD - Py_ssize_t ob_alloc; /* How many bytes allocated in ob_bytes */ - char *ob_bytes; /* Physical backing buffer */ - char *ob_start; /* Logical start inside ob_bytes */ - /* XXX(nnorwitz): should ob_exports be Py_ssize_t? */ - int ob_exports; /* How many buffer exports */ -} PyByteArrayObject; -#endif - /* Type object */ PyAPI_DATA(PyTypeObject) PyByteArray_Type; PyAPI_DATA(PyTypeObject) PyByteArrayIter_Type; /* Type check macros */ #define PyByteArray_Check(self) PyObject_TypeCheck(self, &PyByteArray_Type) -#define PyByteArray_CheckExact(self) (Py_TYPE(self) == &PyByteArray_Type) +#define PyByteArray_CheckExact(self) Py_IS_TYPE(self, &PyByteArray_Type) /* Direct API functions */ PyAPI_FUNC(PyObject *) PyByteArray_FromObject(PyObject *); @@ -46,14 +34,10 @@ PyAPI_FUNC(Py_ssize_t) PyByteArray_Size(PyObject *); PyAPI_FUNC(char *) PyByteArray_AsString(PyObject *); PyAPI_FUNC(int) PyByteArray_Resize(PyObject *, Py_ssize_t); -/* Macros, trading safety for speed */ #ifndef Py_LIMITED_API -#define PyByteArray_AS_STRING(self) \ - (assert(PyByteArray_Check(self)), \ - Py_SIZE(self) ? ((PyByteArrayObject *)(self))->ob_start : _PyByteArray_empty_string) -#define PyByteArray_GET_SIZE(self) (assert(PyByteArray_Check(self)), Py_SIZE(self)) - -PyAPI_DATA(char) _PyByteArray_empty_string[]; +# define Py_CPYTHON_BYTEARRAYOBJECT_H +# include "cpython/bytearrayobject.h" +# undef Py_CPYTHON_BYTEARRAYOBJECT_H #endif #ifdef __cplusplus diff --git a/include/bytesobject.h b/include/bytesobject.h index 3fde4a22..39c241a2 100644 --- a/include/bytesobject.h +++ b/include/bytesobject.h @@ -1,5 +1,5 @@ -/* Bytes (String) object interface */ +/* Bytes object interface */ #ifndef Py_BYTESOBJECT_H #define Py_BYTESOBJECT_H @@ -10,43 +10,26 @@ extern "C" { #include /* -Type PyBytesObject represents a character string. An extra zero byte is +Type PyBytesObject represents a byte string. An extra zero byte is reserved at the end to ensure it is zero-terminated, but a size is present so strings with null bytes in them can be represented. This is an immutable object type. -There are functions to create new string objects, to test -an object for string-ness, and to get the -string value. The latter function returns a null pointer +There are functions to create new bytes objects, to test +an object for bytes-ness, and to get the +byte string value. The latter function returns a null pointer if the object is not of the proper type. There is a variant that takes an explicit size as well as a variant that assumes a zero-terminated string. Note that none of the -functions should be applied to nil objects. +functions should be applied to NULL pointer. */ -/* Caching the hash (ob_shash) saves recalculation of a string's hash value. - This significantly speeds up dict lookups. */ - -#ifndef Py_LIMITED_API -typedef struct { - PyObject_VAR_HEAD - Py_hash_t ob_shash; - char ob_sval[1]; - - /* Invariants: - * ob_sval contains space for 'ob_size+1' elements. - * ob_sval[ob_size] == 0. - * ob_shash is the hash of the string or -1 if not computed yet. - */ -} PyBytesObject; -#endif - PyAPI_DATA(PyTypeObject) PyBytes_Type; PyAPI_DATA(PyTypeObject) PyBytesIter_Type; #define PyBytes_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_BYTES_SUBCLASS) -#define PyBytes_CheckExact(op) (Py_TYPE(op) == &PyBytes_Type) +#define PyBytes_CheckExact(op) Py_IS_TYPE(op, &PyBytes_Type) PyAPI_FUNC(PyObject *) PyBytes_FromStringAndSize(const char *, Py_ssize_t); PyAPI_FUNC(PyObject *) PyBytes_FromString(const char *); @@ -60,164 +43,26 @@ PyAPI_FUNC(char *) PyBytes_AsString(PyObject *); PyAPI_FUNC(PyObject *) PyBytes_Repr(PyObject *, int); PyAPI_FUNC(void) PyBytes_Concat(PyObject **, PyObject *); PyAPI_FUNC(void) PyBytes_ConcatAndDel(PyObject **, PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyBytes_Resize(PyObject **, Py_ssize_t); -PyAPI_FUNC(PyObject*) _PyBytes_FormatEx( - const char *format, - Py_ssize_t format_len, - PyObject *args, - int use_bytearray); -PyAPI_FUNC(PyObject*) _PyBytes_FromHex( - PyObject *string, - int use_bytearray); -#endif PyAPI_FUNC(PyObject *) PyBytes_DecodeEscape(const char *, Py_ssize_t, const char *, Py_ssize_t, const char *); -#ifndef Py_LIMITED_API -/* Helper for PyBytes_DecodeEscape that detects invalid escape chars. */ -PyAPI_FUNC(PyObject *) _PyBytes_DecodeEscape(const char *, Py_ssize_t, - const char *, Py_ssize_t, - const char *, - const char **); -#endif -/* Macro, trading safety for speed */ -#ifndef Py_LIMITED_API -#define PyBytes_AS_STRING(op) (assert(PyBytes_Check(op)), \ - (((PyBytesObject *)(op))->ob_sval)) -#define PyBytes_GET_SIZE(op) (assert(PyBytes_Check(op)),Py_SIZE(op)) -#endif - -/* _PyBytes_Join(sep, x) is like sep.join(x). sep must be PyBytesObject*, - x must be an iterable object. */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyBytes_Join(PyObject *sep, PyObject *x); -#endif - -/* Provides access to the internal data buffer and size of a string - object or the default encoded version of a Unicode object. Passing - NULL as *len parameter will force the string buffer to be - 0-terminated (passing a string with embedded NULL characters will +/* Provides access to the internal data buffer and size of a bytes object. + Passing NULL as len parameter will force the string buffer to be + 0-terminated (passing a string with embedded NUL characters will cause an exception). */ PyAPI_FUNC(int) PyBytes_AsStringAndSize( - PyObject *obj, /* string or Unicode object */ + PyObject *obj, /* bytes object */ char **s, /* pointer to buffer variable */ - Py_ssize_t *len /* pointer to length variable or NULL - (only possible for 0-terminated - strings) */ + Py_ssize_t *len /* pointer to length variable or NULL */ ); -/* Using the current locale, insert the thousands grouping - into the string pointed to by buffer. For the argument descriptions, - see Objects/stringlib/localeutil.h */ #ifndef Py_LIMITED_API -PyAPI_FUNC(Py_ssize_t) _PyBytes_InsertThousandsGroupingLocale(char *buffer, - Py_ssize_t n_buffer, - char *digits, - Py_ssize_t n_digits, - Py_ssize_t min_width); - -/* Using explicit passed-in values, insert the thousands grouping - into the string pointed to by buffer. For the argument descriptions, - see Objects/stringlib/localeutil.h */ -PyAPI_FUNC(Py_ssize_t) _PyBytes_InsertThousandsGrouping(char *buffer, - Py_ssize_t n_buffer, - char *digits, - Py_ssize_t n_digits, - Py_ssize_t min_width, - const char *grouping, - const char *thousands_sep); +# define Py_CPYTHON_BYTESOBJECT_H +# include "cpython/bytesobject.h" +# undef Py_CPYTHON_BYTESOBJECT_H #endif -/* Flags used by string formatting */ -#define F_LJUST (1<<0) -#define F_SIGN (1<<1) -#define F_BLANK (1<<2) -#define F_ALT (1<<3) -#define F_ZERO (1<<4) - -#ifndef Py_LIMITED_API -/* The _PyBytesWriter structure is big: it contains an embedded "stack buffer". - A _PyBytesWriter variable must be declared at the end of variables in a - function to optimize the memory allocation on the stack. */ -typedef struct { - /* bytes, bytearray or NULL (when the small buffer is used) */ - PyObject *buffer; - - /* Number of allocated size. */ - Py_ssize_t allocated; - - /* Minimum number of allocated bytes, - incremented by _PyBytesWriter_Prepare() */ - Py_ssize_t min_size; - - /* If non-zero, use a bytearray instead of a bytes object for buffer. */ - int use_bytearray; - - /* If non-zero, overallocate the buffer (default: 0). - This flag must be zero if use_bytearray is non-zero. */ - int overallocate; - - /* Stack buffer */ - int use_small_buffer; - char small_buffer[512]; -} _PyBytesWriter; - -/* Initialize a bytes writer - - By default, the overallocation is disabled. Set the overallocate attribute - to control the allocation of the buffer. */ -PyAPI_FUNC(void) _PyBytesWriter_Init(_PyBytesWriter *writer); - -/* Get the buffer content and reset the writer. - Return a bytes object, or a bytearray object if use_bytearray is non-zero. - Raise an exception and return NULL on error. */ -PyAPI_FUNC(PyObject *) _PyBytesWriter_Finish(_PyBytesWriter *writer, - void *str); - -/* Deallocate memory of a writer (clear its internal buffer). */ -PyAPI_FUNC(void) _PyBytesWriter_Dealloc(_PyBytesWriter *writer); - -/* Allocate the buffer to write size bytes. - Return the pointer to the beginning of buffer data. - Raise an exception and return NULL on error. */ -PyAPI_FUNC(void*) _PyBytesWriter_Alloc(_PyBytesWriter *writer, - Py_ssize_t size); - -/* Ensure that the buffer is large enough to write *size* bytes. - Add size to the writer minimum size (min_size attribute). - - str is the current pointer inside the buffer. - Return the updated current pointer inside the buffer. - Raise an exception and return NULL on error. */ -PyAPI_FUNC(void*) _PyBytesWriter_Prepare(_PyBytesWriter *writer, - void *str, - Py_ssize_t size); - -/* Resize the buffer to make it larger. - The new buffer may be larger than size bytes because of overallocation. - Return the updated current pointer inside the buffer. - Raise an exception and return NULL on error. - - Note: size must be greater than the number of allocated bytes in the writer. - - This function doesn't use the writer minimum size (min_size attribute). - - See also _PyBytesWriter_Prepare(). - */ -PyAPI_FUNC(void*) _PyBytesWriter_Resize(_PyBytesWriter *writer, - void *str, - Py_ssize_t size); - -/* Write bytes. - Raise an exception and return NULL on error. */ -PyAPI_FUNC(void*) _PyBytesWriter_WriteBytes(_PyBytesWriter *writer, - void *str, - const void *bytes, - Py_ssize_t size); -#endif /* Py_LIMITED_API */ - #ifdef __cplusplus } #endif diff --git a/include/cellobject.h b/include/cellobject.h index 2f9b5b75..81bc784d 100644 --- a/include/cellobject.h +++ b/include/cellobject.h @@ -13,14 +13,14 @@ typedef struct { PyAPI_DATA(PyTypeObject) PyCell_Type; -#define PyCell_Check(op) (Py_TYPE(op) == &PyCell_Type) +#define PyCell_Check(op) Py_IS_TYPE(op, &PyCell_Type) PyAPI_FUNC(PyObject *) PyCell_New(PyObject *); PyAPI_FUNC(PyObject *) PyCell_Get(PyObject *); PyAPI_FUNC(int) PyCell_Set(PyObject *, PyObject *); #define PyCell_GET(op) (((PyCellObject *)(op))->ob_ref) -#define PyCell_SET(op, v) (((PyCellObject *)(op))->ob_ref = v) +#define PyCell_SET(op, v) ((void)(((PyCellObject *)(op))->ob_ref = v)) #ifdef __cplusplus } diff --git a/include/ceval.h b/include/ceval.h index 11283c0a..0f687666 100644 --- a/include/ceval.h +++ b/include/ceval.h @@ -8,57 +8,32 @@ extern "C" { /* Interface to random parts in ceval.c */ /* PyEval_CallObjectWithKeywords(), PyEval_CallObject(), PyEval_CallFunction - * and PyEval_CallMethod are kept for backward compatibility: PyObject_Call(), - * PyObject_CallFunction() and PyObject_CallMethod() are recommended to call - * a callable object. + * and PyEval_CallMethod are deprecated. Since they are officially part of the + * stable ABI (PEP 384), they must be kept for backward compatibility. + * PyObject_Call(), PyObject_CallFunction() and PyObject_CallMethod() are + * recommended to call a callable object. */ -PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords( +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallObjectWithKeywords( PyObject *callable, PyObject *args, PyObject *kwargs); -/* Inline this */ +/* Deprecated since PyEval_CallObjectWithKeywords is deprecated */ #define PyEval_CallObject(callable, arg) \ PyEval_CallObjectWithKeywords(callable, arg, (PyObject *)NULL) -PyAPI_FUNC(PyObject *) PyEval_CallFunction(PyObject *callable, - const char *format, ...); -PyAPI_FUNC(PyObject *) PyEval_CallMethod(PyObject *obj, - const char *name, - const char *format, ...); - -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *); -PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *); -PyAPI_FUNC(void) _PyEval_SetCoroutineOriginTrackingDepth(int new_depth); -PyAPI_FUNC(int) _PyEval_GetCoroutineOriginTrackingDepth(void); -PyAPI_FUNC(void) _PyEval_SetCoroutineWrapper(PyObject *); -PyAPI_FUNC(PyObject *) _PyEval_GetCoroutineWrapper(void); -PyAPI_FUNC(void) _PyEval_SetAsyncGenFirstiter(PyObject *); -PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFirstiter(void); -PyAPI_FUNC(void) _PyEval_SetAsyncGenFinalizer(PyObject *); -PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFinalizer(void); -#endif - -struct _frame; /* Avoid including frameobject.h */ +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallFunction( + PyObject *callable, const char *format, ...); +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyEval_CallMethod( + PyObject *obj, const char *name, const char *format, ...); PyAPI_FUNC(PyObject *) PyEval_GetBuiltins(void); PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void); PyAPI_FUNC(PyObject *) PyEval_GetLocals(void); -PyAPI_FUNC(struct _frame *) PyEval_GetFrame(void); - -#ifndef Py_LIMITED_API -/* Helper to look up a builtin object */ -PyAPI_FUNC(PyObject *) _PyEval_GetBuiltinId(_Py_Identifier *); -/* Look at the current frame's (if any) code's co_flags, and turn on - the corresponding compiler flags in cf->cf_flags. Return 1 if any - flag was set, else return 0. */ -PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf); -#endif +PyAPI_FUNC(PyFrameObject *) PyEval_GetFrame(void); PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg); -PyAPI_FUNC(void) _PyEval_SignalReceived(void); PyAPI_FUNC(int) Py_MakePendingCalls(void); /* Protection against deeply nested recursive calls @@ -89,58 +64,14 @@ PyAPI_FUNC(int) Py_MakePendingCalls(void); PyAPI_FUNC(void) Py_SetRecursionLimit(int); PyAPI_FUNC(int) Py_GetRecursionLimit(void); -#define Py_EnterRecursiveCall(where) \ - (_Py_MakeRecCheck(PyThreadState_GET()->recursion_depth) && \ - _Py_CheckRecursiveCall(where)) -#define Py_LeaveRecursiveCall() \ - do{ if(_Py_MakeEndRecCheck(PyThreadState_GET()->recursion_depth)) \ - PyThreadState_GET()->overflowed = 0; \ - } while(0) -PyAPI_FUNC(int) _Py_CheckRecursiveCall(const char *where); - -/* Due to the macros in which it's used, _Py_CheckRecursionLimit is in - the stable ABI. It should be removed therefrom when possible. -*/ -PyAPI_DATA(int) _Py_CheckRecursionLimit; - -#ifdef USE_STACKCHECK -/* With USE_STACKCHECK, trigger stack checks in _Py_CheckRecursiveCall() - on every 64th call to Py_EnterRecursiveCall. -*/ -# define _Py_MakeRecCheck(x) \ - (++(x) > _Py_CheckRecursionLimit || \ - ++(PyThreadState_GET()->stackcheck_counter) > 64) -#else -# define _Py_MakeRecCheck(x) (++(x) > _Py_CheckRecursionLimit) -#endif - -/* Compute the "lower-water mark" for a recursion limit. When - * Py_LeaveRecursiveCall() is called with a recursion depth below this mark, - * the overflowed flag is reset to 0. */ -#define _Py_RecursionLimitLowerWaterMark(limit) \ - (((limit) > 200) \ - ? ((limit) - 50) \ - : (3 * ((limit) >> 2))) - -#define _Py_MakeEndRecCheck(x) \ - (--(x) < _Py_RecursionLimitLowerWaterMark(_Py_CheckRecursionLimit)) - -#define Py_ALLOW_RECURSION \ - do { unsigned char _old = PyThreadState_GET()->recursion_critical;\ - PyThreadState_GET()->recursion_critical = 1; - -#define Py_END_ALLOW_RECURSION \ - PyThreadState_GET()->recursion_critical = _old; \ - } while(0); +PyAPI_FUNC(int) Py_EnterRecursiveCall(const char *where); +PyAPI_FUNC(void) Py_LeaveRecursiveCall(void); PyAPI_FUNC(const char *) PyEval_GetFuncName(PyObject *); PyAPI_FUNC(const char *) PyEval_GetFuncDesc(PyObject *); -PyAPI_FUNC(PyObject *) PyEval_EvalFrame(struct _frame *); -PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(struct _frame *f, int exc); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(struct _frame *f, int exc); -#endif +PyAPI_FUNC(PyObject *) PyEval_EvalFrame(PyFrameObject *); +PyAPI_FUNC(PyObject *) PyEval_EvalFrameEx(PyFrameObject *f, int exc); /* Interface for threads. @@ -180,9 +111,6 @@ PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(struct _frame *f, int exc); WARNING: NEVER NEST CALLS TO Py_BEGIN_ALLOW_THREADS AND Py_END_ALLOW_THREADS!!! - The function PyEval_InitThreads() should be called only from - init_thread() in "_threadmodule.c". - Note that not yet all candidates have been converted to use this mechanism! */ @@ -190,25 +118,16 @@ PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(struct _frame *f, int exc); PyAPI_FUNC(PyThreadState *) PyEval_SaveThread(void); PyAPI_FUNC(void) PyEval_RestoreThread(PyThreadState *); -PyAPI_FUNC(int) PyEval_ThreadsInitialized(void); -PyAPI_FUNC(void) PyEval_InitThreads(void); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyEval_FiniThreads(void); -#endif /* !Py_LIMITED_API */ -PyAPI_FUNC(void) PyEval_AcquireLock(void) Py_DEPRECATED(3.2); -PyAPI_FUNC(void) PyEval_ReleaseLock(void) /* Py_DEPRECATED(3.2) */; +Py_DEPRECATED(3.9) PyAPI_FUNC(int) PyEval_ThreadsInitialized(void); +Py_DEPRECATED(3.9) PyAPI_FUNC(void) PyEval_InitThreads(void); +/* PyEval_AcquireLock() and PyEval_ReleaseLock() are part of stable ABI. + * They will be removed from this header file in the future version. + * But they will be remained in ABI until Python 4.0. + */ +Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_AcquireLock(void); +Py_DEPRECATED(3.2) PyAPI_FUNC(void) PyEval_ReleaseLock(void); PyAPI_FUNC(void) PyEval_AcquireThread(PyThreadState *tstate); PyAPI_FUNC(void) PyEval_ReleaseThread(PyThreadState *tstate); -PyAPI_FUNC(void) PyEval_ReInitThreads(void); - -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds); -PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void); -#endif - -#ifndef Py_LIMITED_API -PyAPI_FUNC(Py_ssize_t) _PyEval_RequestCodeExtraIndex(freefunc); -#endif #define Py_BEGIN_ALLOW_THREADS { \ PyThreadState *_save; \ @@ -218,12 +137,6 @@ PyAPI_FUNC(Py_ssize_t) _PyEval_RequestCodeExtraIndex(freefunc); #define Py_END_ALLOW_THREADS PyEval_RestoreThread(_save); \ } -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *); -PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *); -PyAPI_FUNC(void) _PyEval_SignalAsyncExc(void); -#endif - /* Masks and values used by FORMAT_VALUE opcode. */ #define FVC_MASK 0x3 #define FVC_NONE 0x0 @@ -233,6 +146,12 @@ PyAPI_FUNC(void) _PyEval_SignalAsyncExc(void); #define FVS_MASK 0x4 #define FVS_HAVE_SPEC 0x4 +#ifndef Py_LIMITED_API +# define Py_CPYTHON_CEVAL_H +# include "cpython/ceval.h" +# undef Py_CPYTHON_CEVAL_H +#endif + #ifdef __cplusplus } #endif diff --git a/include/classobject.h b/include/classobject.h index 209f0f4a..1952f673 100644 --- a/include/classobject.h +++ b/include/classobject.h @@ -14,11 +14,12 @@ typedef struct { PyObject *im_func; /* The callable object implementing the method */ PyObject *im_self; /* The instance it is bound to */ PyObject *im_weakreflist; /* List of weak references */ + vectorcallfunc vectorcall; } PyMethodObject; PyAPI_DATA(PyTypeObject) PyMethod_Type; -#define PyMethod_Check(op) ((op)->ob_type == &PyMethod_Type) +#define PyMethod_Check(op) Py_IS_TYPE(op, &PyMethod_Type) PyAPI_FUNC(PyObject *) PyMethod_New(PyObject *, PyObject *); @@ -32,8 +33,6 @@ PyAPI_FUNC(PyObject *) PyMethod_Self(PyObject *); #define PyMethod_GET_SELF(meth) \ (((PyMethodObject *)meth) -> im_self) -PyAPI_FUNC(int) PyMethod_ClearFreeList(void); - typedef struct { PyObject_HEAD PyObject *func; @@ -41,7 +40,7 @@ typedef struct { PyAPI_DATA(PyTypeObject) PyInstanceMethod_Type; -#define PyInstanceMethod_Check(op) ((op)->ob_type == &PyInstanceMethod_Type) +#define PyInstanceMethod_Check(op) Py_IS_TYPE(op, &PyInstanceMethod_Type) PyAPI_FUNC(PyObject *) PyInstanceMethod_New(PyObject *); PyAPI_FUNC(PyObject *) PyInstanceMethod_Function(PyObject *); diff --git a/include/code.h b/include/code.h index 2e661e8b..b9e23eb8 100644 --- a/include/code.h +++ b/include/code.h @@ -1,157 +1,20 @@ /* Definitions for bytecode */ -#ifndef Py_LIMITED_API #ifndef Py_CODE_H #define Py_CODE_H #ifdef __cplusplus extern "C" { #endif -typedef uint16_t _Py_CODEUNIT; - -#ifdef WORDS_BIGENDIAN -# define _Py_OPCODE(word) ((word) >> 8) -# define _Py_OPARG(word) ((word) & 255) -#else -# define _Py_OPCODE(word) ((word) & 255) -# define _Py_OPARG(word) ((word) >> 8) -#endif - -/* Bytecode object */ -typedef struct { - PyObject_HEAD - int co_argcount; /* #arguments, except *args */ - int co_kwonlyargcount; /* #keyword only arguments */ - int co_nlocals; /* #local variables */ - int co_stacksize; /* #entries needed for evaluation stack */ - int co_flags; /* CO_..., see below */ - int co_firstlineno; /* first source line number */ - PyObject *co_code; /* instruction opcodes */ - PyObject *co_consts; /* list (constants used) */ - PyObject *co_names; /* list of strings (names used) */ - PyObject *co_varnames; /* tuple of strings (local variable names) */ - PyObject *co_freevars; /* tuple of strings (free variable names) */ - PyObject *co_cellvars; /* tuple of strings (cell variable names) */ - /* The rest aren't used in either hash or comparisons, except for co_name, - used in both. This is done to preserve the name and line number - for tracebacks and debuggers; otherwise, constant de-duplication - would collapse identical functions/lambdas defined on different lines. - */ - Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */ - PyObject *co_filename; /* unicode (where it was loaded from) */ - PyObject *co_name; /* unicode (name, for reference) */ - PyObject *co_lnotab; /* string (encoding addr<->lineno mapping) See - Objects/lnotab_notes.txt for details. */ - void *co_zombieframe; /* for optimization only (see frameobject.c) */ - PyObject *co_weakreflist; /* to support weakrefs to code objects */ - /* Scratch space for extra data relating to the code object. - Type is a void* to keep the format private in codeobject.c to force - people to go through the proper APIs. */ - void *co_extra; -} PyCodeObject; - -/* Masks for co_flags above */ -#define CO_OPTIMIZED 0x0001 -#define CO_NEWLOCALS 0x0002 -#define CO_VARARGS 0x0004 -#define CO_VARKEYWORDS 0x0008 -#define CO_NESTED 0x0010 -#define CO_GENERATOR 0x0020 -/* The CO_NOFREE flag is set if there are no free or cell variables. - This information is redundant, but it allows a single flag test - to determine whether there is any extra work to be done when the - call frame it setup. -*/ -#define CO_NOFREE 0x0040 - -/* The CO_COROUTINE flag is set for coroutine functions (defined with - ``async def`` keywords) */ -#define CO_COROUTINE 0x0080 -#define CO_ITERABLE_COROUTINE 0x0100 -#define CO_ASYNC_GENERATOR 0x0200 - -/* These are no longer used. */ -#if 0 -#define CO_GENERATOR_ALLOWED 0x1000 -#endif -#define CO_FUTURE_DIVISION 0x2000 -#define CO_FUTURE_ABSOLUTE_IMPORT 0x4000 /* do absolute imports by default */ -#define CO_FUTURE_WITH_STATEMENT 0x8000 -#define CO_FUTURE_PRINT_FUNCTION 0x10000 -#define CO_FUTURE_UNICODE_LITERALS 0x20000 - -#define CO_FUTURE_BARRY_AS_BDFL 0x40000 -#define CO_FUTURE_GENERATOR_STOP 0x80000 -#define CO_FUTURE_ANNOTATIONS 0x100000 - -/* This value is found in the co_cell2arg array when the associated cell - variable does not correspond to an argument. */ -#define CO_CELL_NOT_AN_ARG (-1) - -/* This should be defined if a future statement modifies the syntax. - For example, when a keyword is added. -*/ -#define PY_PARSER_REQUIRES_FUTURE_KEYWORD - -#define CO_MAXBLOCKS 20 /* Max static block nesting within a function */ - -PyAPI_DATA(PyTypeObject) PyCode_Type; - -#define PyCode_Check(op) (Py_TYPE(op) == &PyCode_Type) -#define PyCode_GetNumFree(op) (PyTuple_GET_SIZE((op)->co_freevars)) - -/* Public interface */ -PyAPI_FUNC(PyCodeObject *) PyCode_New( - int, int, int, int, int, PyObject *, PyObject *, - PyObject *, PyObject *, PyObject *, PyObject *, - PyObject *, PyObject *, int, PyObject *); - /* same as struct above */ - -/* Creates a new empty code object with the specified source location. */ -PyAPI_FUNC(PyCodeObject *) -PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno); - -/* Return the line number associated with the specified bytecode index - in this code object. If you just need the line number of a frame, - use PyFrame_GetLineNumber() instead. */ -PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int); - -/* for internal use only */ -typedef struct _addr_pair { - int ap_lower; - int ap_upper; -} PyAddrPair; - -#ifndef Py_LIMITED_API -/* Update *bounds to describe the first and one-past-the-last instructions in the - same line as lasti. Return the number of that line. -*/ -PyAPI_FUNC(int) _PyCode_CheckLineNumber(PyCodeObject* co, - int lasti, PyAddrPair *bounds); - -/* Create a comparable key used to compare constants taking in account the - * object type. It is used to make sure types are not coerced (e.g., float and - * complex) _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms - * - * Return (type(obj), obj, ...): a tuple with variable size (at least 2 items) - * depending on the type and the value. The type is the first item to not - * compare bytes and str which can raise a BytesWarning exception. */ -PyAPI_FUNC(PyObject*) _PyCode_ConstantKey(PyObject *obj); -#endif - -PyAPI_FUNC(PyObject*) PyCode_Optimize(PyObject *code, PyObject* consts, - PyObject *names, PyObject *lnotab); - +typedef struct PyCodeObject PyCodeObject; #ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyCode_GetExtra(PyObject *code, Py_ssize_t index, - void **extra); -PyAPI_FUNC(int) _PyCode_SetExtra(PyObject *code, Py_ssize_t index, - void *extra); +# define Py_CPYTHON_CODE_H +# include "cpython/code.h" +# undef Py_CPYTHON_CODE_H #endif #ifdef __cplusplus } #endif #endif /* !Py_CODE_H */ -#endif /* Py_LIMITED_API */ diff --git a/include/codecs.h b/include/codecs.h index 3ad0f2b5..37ecfb4a 100644 --- a/include/codecs.h +++ b/include/codecs.h @@ -27,6 +27,14 @@ PyAPI_FUNC(int) PyCodec_Register( PyObject *search_function ); +/* Unregister a codec search function and clear the registry's cache. + If the search function is not registered, do nothing. + Return 0 on success. Raise an exception and return -1 on error. */ + +PyAPI_FUNC(int) PyCodec_Unregister( + PyObject *search_function + ); + /* Codec registry lookup API. Looks up the given encoding and returns a CodecInfo object with diff --git a/include/compile.h b/include/compile.h index edb961f4..3c5acd72 100644 --- a/include/compile.h +++ b/include/compile.h @@ -1,93 +1,25 @@ #ifndef Py_COMPILE_H #define Py_COMPILE_H - -#ifndef Py_LIMITED_API -#include "code.h" - #ifdef __cplusplus extern "C" { #endif -/* Public interface */ -struct _node; /* Declare the existence of this type */ -PyAPI_FUNC(PyCodeObject *) PyNode_Compile(struct _node *, const char *); -/* XXX (ncoghlan): Unprefixed type name in a public API! */ +/* These definitions must match corresponding definitions in graminit.h. */ +#define Py_single_input 256 +#define Py_file_input 257 +#define Py_eval_input 258 +#define Py_func_type_input 345 -#define PyCF_MASK (CO_FUTURE_DIVISION | CO_FUTURE_ABSOLUTE_IMPORT | \ - CO_FUTURE_WITH_STATEMENT | CO_FUTURE_PRINT_FUNCTION | \ - CO_FUTURE_UNICODE_LITERALS | CO_FUTURE_BARRY_AS_BDFL | \ - CO_FUTURE_GENERATOR_STOP | CO_FUTURE_ANNOTATIONS) -#define PyCF_MASK_OBSOLETE (CO_NESTED) -#define PyCF_SOURCE_IS_UTF8 0x0100 -#define PyCF_DONT_IMPLY_DEDENT 0x0200 -#define PyCF_ONLY_AST 0x0400 -#define PyCF_IGNORE_COOKIE 0x0800 +/* This doesn't need to match anything */ +#define Py_fstring_input 800 #ifndef Py_LIMITED_API -typedef struct { - int cf_flags; /* bitmask of CO_xxx flags relevant to future */ -} PyCompilerFlags; +# define Py_CPYTHON_COMPILE_H +# include "cpython/compile.h" +# undef Py_CPYTHON_COMPILE_H #endif -/* Future feature support */ - -typedef struct { - int ff_features; /* flags set by future statements */ - int ff_lineno; /* line number of last future statement */ -} PyFutureFeatures; - -#define FUTURE_NESTED_SCOPES "nested_scopes" -#define FUTURE_GENERATORS "generators" -#define FUTURE_DIVISION "division" -#define FUTURE_ABSOLUTE_IMPORT "absolute_import" -#define FUTURE_WITH_STATEMENT "with_statement" -#define FUTURE_PRINT_FUNCTION "print_function" -#define FUTURE_UNICODE_LITERALS "unicode_literals" -#define FUTURE_BARRY_AS_BDFL "barry_as_FLUFL" -#define FUTURE_GENERATOR_STOP "generator_stop" -#define FUTURE_ANNOTATIONS "annotations" - -struct _mod; /* Declare the existence of this type */ -#define PyAST_Compile(mod, s, f, ar) PyAST_CompileEx(mod, s, f, -1, ar) -PyAPI_FUNC(PyCodeObject *) PyAST_CompileEx( - struct _mod *mod, - const char *filename, /* decoded from the filesystem encoding */ - PyCompilerFlags *flags, - int optimize, - PyArena *arena); -PyAPI_FUNC(PyCodeObject *) PyAST_CompileObject( - struct _mod *mod, - PyObject *filename, - PyCompilerFlags *flags, - int optimize, - PyArena *arena); -PyAPI_FUNC(PyFutureFeatures *) PyFuture_FromAST( - struct _mod * mod, - const char *filename /* decoded from the filesystem encoding */ - ); -PyAPI_FUNC(PyFutureFeatures *) PyFuture_FromASTObject( - struct _mod * mod, - PyObject *filename - ); - -/* _Py_Mangle is defined in compile.c */ -PyAPI_FUNC(PyObject*) _Py_Mangle(PyObject *p, PyObject *name); - -#define PY_INVALID_STACK_EFFECT INT_MAX -PyAPI_FUNC(int) PyCompile_OpcodeStackEffect(int opcode, int oparg); - -PyAPI_FUNC(int) _PyAST_Optimize(struct _mod *, PyArena *arena, int optimize); - #ifdef __cplusplus } #endif - -#endif /* !Py_LIMITED_API */ - -/* These definitions must match corresponding definitions in graminit.h. - There's code in compile.c that checks that they are the same. */ -#define Py_single_input 256 -#define Py_file_input 257 -#define Py_eval_input 258 - #endif /* !Py_COMPILE_H */ diff --git a/include/complexobject.h b/include/complexobject.h index cb8c52c5..9221f9c5 100644 --- a/include/complexobject.h +++ b/include/complexobject.h @@ -39,7 +39,7 @@ typedef struct { PyAPI_DATA(PyTypeObject) PyComplex_Type; #define PyComplex_Check(op) PyObject_TypeCheck(op, &PyComplex_Type) -#define PyComplex_CheckExact(op) (Py_TYPE(op) == &PyComplex_Type) +#define PyComplex_CheckExact(op) Py_IS_TYPE(op, &PyComplex_Type) #ifndef Py_LIMITED_API PyAPI_FUNC(PyObject *) PyComplex_FromCComplex(Py_complex); diff --git a/include/context.h b/include/context.h index 95812852..4e500708 100644 --- a/include/context.h +++ b/include/context.h @@ -17,9 +17,9 @@ PyAPI_DATA(PyTypeObject) PyContextToken_Type; typedef struct _pycontexttokenobject PyContextToken; -#define PyContext_CheckExact(o) (Py_TYPE(o) == &PyContext_Type) -#define PyContextVar_CheckExact(o) (Py_TYPE(o) == &PyContextVar_Type) -#define PyContextToken_CheckExact(o) (Py_TYPE(o) == &PyContextToken_Type) +#define PyContext_CheckExact(o) Py_IS_TYPE(o, &PyContext_Type) +#define PyContextVar_CheckExact(o) Py_IS_TYPE(o, &PyContextVar_Type) +#define PyContextToken_CheckExact(o) Py_IS_TYPE(o, &PyContextToken_Type) PyAPI_FUNC(PyObject *) PyContext_New(void); @@ -73,9 +73,6 @@ PyAPI_FUNC(int) PyContextVar_Reset(PyObject *var, PyObject *token); PyAPI_FUNC(PyObject *) _PyContext_NewHamtForTests(void); -PyAPI_FUNC(int) PyContext_ClearFreeList(void); - - #endif /* !Py_LIMITED_API */ #ifdef __cplusplus diff --git a/include/cpython/abstract.h b/include/cpython/abstract.h new file mode 100644 index 00000000..db850219 --- /dev/null +++ b/include/cpython/abstract.h @@ -0,0 +1,373 @@ +#ifndef Py_CPYTHON_ABSTRACTOBJECT_H +# error "this header file must not be included directly" +#endif + +/* === Object Protocol ================================================== */ + +#ifdef PY_SSIZE_T_CLEAN +# define _PyObject_CallMethodId _PyObject_CallMethodId_SizeT +#endif + +/* Convert keyword arguments from the FASTCALL (stack: C array, kwnames: tuple) + format to a Python dictionary ("kwargs" dict). + + The type of kwnames keys is not checked. The final function getting + arguments is responsible to check if all keys are strings, for example using + PyArg_ParseTupleAndKeywords() or PyArg_ValidateKeywordArguments(). + + Duplicate keys are merged using the last value. If duplicate keys must raise + an exception, the caller is responsible to implement an explicit keys on + kwnames. */ +PyAPI_FUNC(PyObject *) _PyStack_AsDict( + PyObject *const *values, + PyObject *kwnames); + +/* Suggested size (number of positional arguments) for arrays of PyObject* + allocated on a C stack to avoid allocating memory on the heap memory. Such + array is used to pass positional arguments to call functions of the + PyObject_Vectorcall() family. + + The size is chosen to not abuse the C stack and so limit the risk of stack + overflow. The size is also chosen to allow using the small stack for most + function calls of the Python standard library. On 64-bit CPU, it allocates + 40 bytes on the stack. */ +#define _PY_FASTCALL_SMALL_STACK 5 + +PyAPI_FUNC(PyObject *) _Py_CheckFunctionResult( + PyThreadState *tstate, + PyObject *callable, + PyObject *result, + const char *where); + +/* === Vectorcall protocol (PEP 590) ============================= */ + +/* Call callable using tp_call. Arguments are like PyObject_Vectorcall() + or PyObject_FastCallDict() (both forms are supported), + except that nargs is plainly the number of arguments without flags. */ +PyAPI_FUNC(PyObject *) _PyObject_MakeTpCall( + PyThreadState *tstate, + PyObject *callable, + PyObject *const *args, Py_ssize_t nargs, + PyObject *keywords); + +#define PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + +static inline Py_ssize_t +PyVectorcall_NARGS(size_t n) +{ + return n & ~PY_VECTORCALL_ARGUMENTS_OFFSET; +} + +static inline vectorcallfunc +PyVectorcall_Function(PyObject *callable) +{ + PyTypeObject *tp; + Py_ssize_t offset; + vectorcallfunc ptr; + + assert(callable != NULL); + tp = Py_TYPE(callable); + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + offset = tp->tp_vectorcall_offset; + assert(offset > 0); + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + +/* Call the callable object 'callable' with the "vectorcall" calling + convention. + + args is a C array for positional arguments. + + nargsf is the number of positional arguments plus optionally the flag + PY_VECTORCALL_ARGUMENTS_OFFSET which means that the caller is allowed to + modify args[-1]. + + kwnames is a tuple of keyword names. The values of the keyword arguments + are stored in "args" after the positional arguments (note that the number + of keyword arguments does not change nargsf). kwnames can also be NULL if + there are no keyword arguments. + + keywords must only contain strings and all keys must be unique. + + Return the result on success. Raise an exception and return NULL on + error. */ +static inline PyObject * +_PyObject_VectorcallTstate(PyThreadState *tstate, PyObject *callable, + PyObject *const *args, size_t nargsf, + PyObject *kwnames) +{ + vectorcallfunc func; + PyObject *res; + + assert(kwnames == NULL || PyTuple_Check(kwnames)); + assert(args != NULL || PyVectorcall_NARGS(nargsf) == 0); + + func = PyVectorcall_Function(callable); + if (func == NULL) { + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + return _PyObject_MakeTpCall(tstate, callable, args, nargs, kwnames); + } + res = func(callable, args, nargsf, kwnames); + return _Py_CheckFunctionResult(tstate, callable, res, NULL); +} + +static inline PyObject * +PyObject_Vectorcall(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames) +{ + PyThreadState *tstate = PyThreadState_Get(); + return _PyObject_VectorcallTstate(tstate, callable, + args, nargsf, kwnames); +} + +// Backwards compatibility aliases for API that was provisional in Python 3.8 +#define _PyObject_Vectorcall PyObject_Vectorcall +#define _PyObject_VectorcallMethod PyObject_VectorcallMethod +#define _PyObject_FastCallDict PyObject_VectorcallDict +#define _PyVectorcall_Function PyVectorcall_Function +#define _PyObject_CallOneArg PyObject_CallOneArg +#define _PyObject_CallMethodNoArgs PyObject_CallMethodNoArgs +#define _PyObject_CallMethodOneArg PyObject_CallMethodOneArg + +/* Same as PyObject_Vectorcall except that keyword arguments are passed as + dict, which may be NULL if there are no keyword arguments. */ +PyAPI_FUNC(PyObject *) PyObject_VectorcallDict( + PyObject *callable, + PyObject *const *args, + size_t nargsf, + PyObject *kwargs); + +/* Call "callable" (which must support vectorcall) with positional arguments + "tuple" and keyword arguments "dict". "dict" may also be NULL */ +PyAPI_FUNC(PyObject *) PyVectorcall_Call(PyObject *callable, PyObject *tuple, PyObject *dict); + +static inline PyObject * +_PyObject_FastCallTstate(PyThreadState *tstate, PyObject *func, PyObject *const *args, Py_ssize_t nargs) +{ + return _PyObject_VectorcallTstate(tstate, func, args, (size_t)nargs, NULL); +} + +/* Same as PyObject_Vectorcall except without keyword arguments */ +static inline PyObject * +_PyObject_FastCall(PyObject *func, PyObject *const *args, Py_ssize_t nargs) +{ + PyThreadState *tstate = PyThreadState_Get(); + return _PyObject_FastCallTstate(tstate, func, args, nargs); +} + +/* Call a callable without any arguments + Private static inline function variant of public function + PyObject_CallNoArgs(). */ +static inline PyObject * +_PyObject_CallNoArg(PyObject *func) { + PyThreadState *tstate = PyThreadState_Get(); + return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL); +} + +static inline PyObject * +PyObject_CallOneArg(PyObject *func, PyObject *arg) +{ + PyObject *_args[2]; + PyObject **args; + PyThreadState *tstate; + size_t nargsf; + + assert(arg != NULL); + args = _args + 1; // For PY_VECTORCALL_ARGUMENTS_OFFSET + args[0] = arg; + tstate = PyThreadState_Get(); + nargsf = 1 | PY_VECTORCALL_ARGUMENTS_OFFSET; + return _PyObject_VectorcallTstate(tstate, func, args, nargsf, NULL); +} + +PyAPI_FUNC(PyObject *) PyObject_VectorcallMethod( + PyObject *name, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + +static inline PyObject * +PyObject_CallMethodNoArgs(PyObject *self, PyObject *name) +{ + return PyObject_VectorcallMethod(name, &self, + 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +} + +static inline PyObject * +PyObject_CallMethodOneArg(PyObject *self, PyObject *name, PyObject *arg) +{ + PyObject *args[2] = {self, arg}; + + assert(arg != NULL); + return PyObject_VectorcallMethod(name, args, + 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +} + +/* Like PyObject_CallMethod(), but expect a _Py_Identifier* + as the method name. */ +PyAPI_FUNC(PyObject *) _PyObject_CallMethodId(PyObject *obj, + _Py_Identifier *name, + const char *format, ...); + +PyAPI_FUNC(PyObject *) _PyObject_CallMethodId_SizeT(PyObject *obj, + _Py_Identifier *name, + const char *format, + ...); + +PyAPI_FUNC(PyObject *) _PyObject_CallMethodIdObjArgs( + PyObject *obj, + struct _Py_Identifier *name, + ...); + +static inline PyObject * +_PyObject_VectorcallMethodId( + _Py_Identifier *name, PyObject *const *args, + size_t nargsf, PyObject *kwnames) +{ + PyObject *oname = _PyUnicode_FromId(name); /* borrowed */ + if (!oname) { + return NULL; + } + return PyObject_VectorcallMethod(oname, args, nargsf, kwnames); +} + +static inline PyObject * +_PyObject_CallMethodIdNoArgs(PyObject *self, _Py_Identifier *name) +{ + return _PyObject_VectorcallMethodId(name, &self, + 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +} + +static inline PyObject * +_PyObject_CallMethodIdOneArg(PyObject *self, _Py_Identifier *name, PyObject *arg) +{ + PyObject *args[2] = {self, arg}; + + assert(arg != NULL); + return _PyObject_VectorcallMethodId(name, args, + 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +} + +PyAPI_FUNC(int) _PyObject_HasLen(PyObject *o); + +/* Guess the size of object 'o' using len(o) or o.__length_hint__(). + If neither of those return a non-negative value, then return the default + value. If one of the calls fails, this function returns -1. */ +PyAPI_FUNC(Py_ssize_t) PyObject_LengthHint(PyObject *o, Py_ssize_t); + +/* === New Buffer API ============================================ */ + +/* Return 1 if the getbuffer function is available, otherwise return 0. */ +PyAPI_FUNC(int) PyObject_CheckBuffer(PyObject *obj); + +/* This is a C-API version of the getbuffer function call. It checks + to make sure object has the required function pointer and issues the + call. + + Returns -1 and raises an error on failure and returns 0 on success. */ +PyAPI_FUNC(int) PyObject_GetBuffer(PyObject *obj, Py_buffer *view, + int flags); + +/* Get the memory area pointed to by the indices for the buffer given. + Note that view->ndim is the assumed size of indices. */ +PyAPI_FUNC(void *) PyBuffer_GetPointer(Py_buffer *view, Py_ssize_t *indices); + +/* Return the implied itemsize of the data-format area from a + struct-style description. */ +PyAPI_FUNC(Py_ssize_t) PyBuffer_SizeFromFormat(const char *format); + +/* Implementation in memoryobject.c */ +PyAPI_FUNC(int) PyBuffer_ToContiguous(void *buf, Py_buffer *view, + Py_ssize_t len, char order); + +PyAPI_FUNC(int) PyBuffer_FromContiguous(Py_buffer *view, void *buf, + Py_ssize_t len, char order); + +/* Copy len bytes of data from the contiguous chunk of memory + pointed to by buf into the buffer exported by obj. Return + 0 on success and return -1 and raise a PyBuffer_Error on + error (i.e. the object does not have a buffer interface or + it is not working). + + If fort is 'F', then if the object is multi-dimensional, + then the data will be copied into the array in + Fortran-style (first dimension varies the fastest). If + fort is 'C', then the data will be copied into the array + in C-style (last dimension varies the fastest). If fort + is 'A', then it does not matter and the copy will be made + in whatever way is more efficient. */ +PyAPI_FUNC(int) PyObject_CopyData(PyObject *dest, PyObject *src); + +/* Copy the data from the src buffer to the buffer of destination. */ +PyAPI_FUNC(int) PyBuffer_IsContiguous(const Py_buffer *view, char fort); + +/*Fill the strides array with byte-strides of a contiguous + (Fortran-style if fort is 'F' or C-style otherwise) + array of the given shape with the given number of bytes + per element. */ +PyAPI_FUNC(void) PyBuffer_FillContiguousStrides(int ndims, + Py_ssize_t *shape, + Py_ssize_t *strides, + int itemsize, + char fort); + +/* Fills in a buffer-info structure correctly for an exporter + that can only share a contiguous chunk of memory of + "unsigned bytes" of the given length. + + Returns 0 on success and -1 (with raising an error) on error. */ +PyAPI_FUNC(int) PyBuffer_FillInfo(Py_buffer *view, PyObject *o, void *buf, + Py_ssize_t len, int readonly, + int flags); + +/* Releases a Py_buffer obtained from getbuffer ParseTuple's "s*". */ +PyAPI_FUNC(void) PyBuffer_Release(Py_buffer *view); + +/* === Sequence protocol ================================================ */ + +/* Assume tp_as_sequence and sq_item exist and that 'i' does not + need to be corrected for a negative index. */ +#define PySequence_ITEM(o, i)\ + ( Py_TYPE(o)->tp_as_sequence->sq_item(o, i) ) + +#define PY_ITERSEARCH_COUNT 1 +#define PY_ITERSEARCH_INDEX 2 +#define PY_ITERSEARCH_CONTAINS 3 + +/* Iterate over seq. + + Result depends on the operation: + + PY_ITERSEARCH_COUNT: return # of times obj appears in seq; -1 if + error. + PY_ITERSEARCH_INDEX: return 0-based index of first occurrence of + obj in seq; set ValueError and return -1 if none found; + also return -1 on error. + PY_ITERSEARCH_CONTAINS: return 1 if obj in seq, else 0; -1 on + error. */ +PyAPI_FUNC(Py_ssize_t) _PySequence_IterSearch(PyObject *seq, + PyObject *obj, int operation); + +/* === Mapping protocol ================================================= */ + +PyAPI_FUNC(int) _PyObject_RealIsInstance(PyObject *inst, PyObject *cls); + +PyAPI_FUNC(int) _PyObject_RealIsSubclass(PyObject *derived, PyObject *cls); + +PyAPI_FUNC(char *const *) _PySequence_BytesToCharpArray(PyObject* self); + +PyAPI_FUNC(void) _Py_FreeCharPArray(char *const array[]); + +/* For internal use by buffer API functions */ +PyAPI_FUNC(void) _Py_add_one_to_index_F(int nd, Py_ssize_t *index, + const Py_ssize_t *shape); +PyAPI_FUNC(void) _Py_add_one_to_index_C(int nd, Py_ssize_t *index, + const Py_ssize_t *shape); + +/* Convert Python int to Py_ssize_t. Do nothing if the argument is None. */ +PyAPI_FUNC(int) _Py_convert_optional_to_ssize_t(PyObject *, void *); + +/* Same as PyNumber_Index but can return an instance of a subclass of int. */ +PyAPI_FUNC(PyObject *) _PyNumber_Index(PyObject *o); diff --git a/include/cpython/bytearrayobject.h b/include/cpython/bytearrayobject.h new file mode 100644 index 00000000..569b0cd0 --- /dev/null +++ b/include/cpython/bytearrayobject.h @@ -0,0 +1,20 @@ +#ifndef Py_CPYTHON_BYTEARRAYOBJECT_H +# error "this header file must not be included directly" +#endif + +/* Object layout */ +typedef struct { + PyObject_VAR_HEAD + Py_ssize_t ob_alloc; /* How many bytes allocated in ob_bytes */ + char *ob_bytes; /* Physical backing buffer */ + char *ob_start; /* Logical start inside ob_bytes */ + Py_ssize_t ob_exports; /* How many buffer exports */ +} PyByteArrayObject; + +/* Macros, trading safety for speed */ +#define PyByteArray_AS_STRING(self) \ + (assert(PyByteArray_Check(self)), \ + Py_SIZE(self) ? ((PyByteArrayObject *)(self))->ob_start : _PyByteArray_empty_string) +#define PyByteArray_GET_SIZE(self) (assert(PyByteArray_Check(self)), Py_SIZE(self)) + +PyAPI_DATA(char) _PyByteArray_empty_string[]; diff --git a/include/cpython/bytesobject.h b/include/cpython/bytesobject.h new file mode 100644 index 00000000..6b3f5522 --- /dev/null +++ b/include/cpython/bytesobject.h @@ -0,0 +1,118 @@ +#ifndef Py_CPYTHON_BYTESOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct { + PyObject_VAR_HEAD + Py_hash_t ob_shash; + char ob_sval[1]; + + /* Invariants: + * ob_sval contains space for 'ob_size+1' elements. + * ob_sval[ob_size] == 0. + * ob_shash is the hash of the byte string or -1 if not computed yet. + */ +} PyBytesObject; + +PyAPI_FUNC(int) _PyBytes_Resize(PyObject **, Py_ssize_t); +PyAPI_FUNC(PyObject*) _PyBytes_FormatEx( + const char *format, + Py_ssize_t format_len, + PyObject *args, + int use_bytearray); +PyAPI_FUNC(PyObject*) _PyBytes_FromHex( + PyObject *string, + int use_bytearray); + +/* Helper for PyBytes_DecodeEscape that detects invalid escape chars. */ +PyAPI_FUNC(PyObject *) _PyBytes_DecodeEscape(const char *, Py_ssize_t, + const char *, const char **); + +/* Macro, trading safety for speed */ +#define PyBytes_AS_STRING(op) (assert(PyBytes_Check(op)), \ + (((PyBytesObject *)(op))->ob_sval)) +#define PyBytes_GET_SIZE(op) (assert(PyBytes_Check(op)),Py_SIZE(op)) + +/* _PyBytes_Join(sep, x) is like sep.join(x). sep must be PyBytesObject*, + x must be an iterable object. */ +PyAPI_FUNC(PyObject *) _PyBytes_Join(PyObject *sep, PyObject *x); + + +/* The _PyBytesWriter structure is big: it contains an embedded "stack buffer". + A _PyBytesWriter variable must be declared at the end of variables in a + function to optimize the memory allocation on the stack. */ +typedef struct { + /* bytes, bytearray or NULL (when the small buffer is used) */ + PyObject *buffer; + + /* Number of allocated size. */ + Py_ssize_t allocated; + + /* Minimum number of allocated bytes, + incremented by _PyBytesWriter_Prepare() */ + Py_ssize_t min_size; + + /* If non-zero, use a bytearray instead of a bytes object for buffer. */ + int use_bytearray; + + /* If non-zero, overallocate the buffer (default: 0). + This flag must be zero if use_bytearray is non-zero. */ + int overallocate; + + /* Stack buffer */ + int use_small_buffer; + char small_buffer[512]; +} _PyBytesWriter; + +/* Initialize a bytes writer + + By default, the overallocation is disabled. Set the overallocate attribute + to control the allocation of the buffer. */ +PyAPI_FUNC(void) _PyBytesWriter_Init(_PyBytesWriter *writer); + +/* Get the buffer content and reset the writer. + Return a bytes object, or a bytearray object if use_bytearray is non-zero. + Raise an exception and return NULL on error. */ +PyAPI_FUNC(PyObject *) _PyBytesWriter_Finish(_PyBytesWriter *writer, + void *str); + +/* Deallocate memory of a writer (clear its internal buffer). */ +PyAPI_FUNC(void) _PyBytesWriter_Dealloc(_PyBytesWriter *writer); + +/* Allocate the buffer to write size bytes. + Return the pointer to the beginning of buffer data. + Raise an exception and return NULL on error. */ +PyAPI_FUNC(void*) _PyBytesWriter_Alloc(_PyBytesWriter *writer, + Py_ssize_t size); + +/* Ensure that the buffer is large enough to write *size* bytes. + Add size to the writer minimum size (min_size attribute). + + str is the current pointer inside the buffer. + Return the updated current pointer inside the buffer. + Raise an exception and return NULL on error. */ +PyAPI_FUNC(void*) _PyBytesWriter_Prepare(_PyBytesWriter *writer, + void *str, + Py_ssize_t size); + +/* Resize the buffer to make it larger. + The new buffer may be larger than size bytes because of overallocation. + Return the updated current pointer inside the buffer. + Raise an exception and return NULL on error. + + Note: size must be greater than the number of allocated bytes in the writer. + + This function doesn't use the writer minimum size (min_size attribute). + + See also _PyBytesWriter_Prepare(). + */ +PyAPI_FUNC(void*) _PyBytesWriter_Resize(_PyBytesWriter *writer, + void *str, + Py_ssize_t size); + +/* Write bytes. + Raise an exception and return NULL on error. */ +PyAPI_FUNC(void*) _PyBytesWriter_WriteBytes(_PyBytesWriter *writer, + void *str, + const void *bytes, + Py_ssize_t size); diff --git a/include/cpython/ceval.h b/include/cpython/ceval.h new file mode 100644 index 00000000..06338928 --- /dev/null +++ b/include/cpython/ceval.h @@ -0,0 +1,30 @@ +#ifndef Py_CPYTHON_CEVAL_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(void) PyEval_SetProfile(Py_tracefunc, PyObject *); +PyAPI_DATA(int) _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); +PyAPI_FUNC(void) PyEval_SetTrace(Py_tracefunc, PyObject *); +PyAPI_FUNC(int) _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); +PyAPI_FUNC(int) _PyEval_GetCoroutineOriginTrackingDepth(void); +PyAPI_FUNC(int) _PyEval_SetAsyncGenFirstiter(PyObject *); +PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFirstiter(void); +PyAPI_FUNC(int) _PyEval_SetAsyncGenFinalizer(PyObject *); +PyAPI_FUNC(PyObject *) _PyEval_GetAsyncGenFinalizer(void); + +/* Helper to look up a builtin object */ +PyAPI_FUNC(PyObject *) _PyEval_GetBuiltinId(_Py_Identifier *); +/* Look at the current frame's (if any) code's co_flags, and turn on + the corresponding compiler flags in cf->cf_flags. Return 1 if any + flag was set, else return 0. */ +PyAPI_FUNC(int) PyEval_MergeCompilerFlags(PyCompilerFlags *cf); + +PyAPI_FUNC(PyObject *) _PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int exc); + +PyAPI_FUNC(void) _PyEval_SetSwitchInterval(unsigned long microseconds); +PyAPI_FUNC(unsigned long) _PyEval_GetSwitchInterval(void); + +PyAPI_FUNC(Py_ssize_t) _PyEval_RequestCodeExtraIndex(freefunc); + +PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *); +PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *); diff --git a/include/cpython/code.h b/include/cpython/code.h new file mode 100644 index 00000000..fa640852 --- /dev/null +++ b/include/cpython/code.h @@ -0,0 +1,184 @@ +#ifndef Py_CPYTHON_CODE_H +# error "this header file must not be included directly" +#endif + +typedef uint16_t _Py_CODEUNIT; + +#ifdef WORDS_BIGENDIAN +# define _Py_OPCODE(word) ((word) >> 8) +# define _Py_OPARG(word) ((word) & 255) +#else +# define _Py_OPCODE(word) ((word) & 255) +# define _Py_OPARG(word) ((word) >> 8) +#endif + +typedef struct _PyOpcache _PyOpcache; + +/* Bytecode object */ +struct PyCodeObject { + PyObject_HEAD + int co_argcount; /* #arguments, except *args */ + int co_posonlyargcount; /* #positional only arguments */ + int co_kwonlyargcount; /* #keyword only arguments */ + int co_nlocals; /* #local variables */ + int co_stacksize; /* #entries needed for evaluation stack */ + int co_flags; /* CO_..., see below */ + int co_firstlineno; /* first source line number */ + PyObject *co_code; /* instruction opcodes */ + PyObject *co_consts; /* list (constants used) */ + PyObject *co_names; /* list of strings (names used) */ + PyObject *co_varnames; /* tuple of strings (local variable names) */ + PyObject *co_freevars; /* tuple of strings (free variable names) */ + PyObject *co_cellvars; /* tuple of strings (cell variable names) */ + /* The rest aren't used in either hash or comparisons, except for co_name, + used in both. This is done to preserve the name and line number + for tracebacks and debuggers; otherwise, constant de-duplication + would collapse identical functions/lambdas defined on different lines. + */ + Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */ + PyObject *co_filename; /* unicode (where it was loaded from) */ + PyObject *co_name; /* unicode (name, for reference) */ + PyObject *co_linetable; /* string (encoding addr<->lineno mapping) See + Objects/lnotab_notes.txt for details. */ + void *co_zombieframe; /* for optimization only (see frameobject.c) */ + PyObject *co_weakreflist; /* to support weakrefs to code objects */ + /* Scratch space for extra data relating to the code object. + Type is a void* to keep the format private in codeobject.c to force + people to go through the proper APIs. */ + void *co_extra; + + /* Per opcodes just-in-time cache + * + * To reduce cache size, we use indirect mapping from opcode index to + * cache object: + * cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1] + */ + + // co_opcache_map is indexed by (next_instr - first_instr). + // * 0 means there is no cache for this opcode. + // * n > 0 means there is cache in co_opcache[n-1]. + unsigned char *co_opcache_map; + _PyOpcache *co_opcache; + int co_opcache_flag; // used to determine when create a cache. + unsigned char co_opcache_size; // length of co_opcache. +}; + +/* Masks for co_flags above */ +#define CO_OPTIMIZED 0x0001 +#define CO_NEWLOCALS 0x0002 +#define CO_VARARGS 0x0004 +#define CO_VARKEYWORDS 0x0008 +#define CO_NESTED 0x0010 +#define CO_GENERATOR 0x0020 +/* The CO_NOFREE flag is set if there are no free or cell variables. + This information is redundant, but it allows a single flag test + to determine whether there is any extra work to be done when the + call frame it setup. +*/ +#define CO_NOFREE 0x0040 + +/* The CO_COROUTINE flag is set for coroutine functions (defined with + ``async def`` keywords) */ +#define CO_COROUTINE 0x0080 +#define CO_ITERABLE_COROUTINE 0x0100 +#define CO_ASYNC_GENERATOR 0x0200 + +/* bpo-39562: These constant values are changed in Python 3.9 + to prevent collision with compiler flags. CO_FUTURE_ and PyCF_ + constants must be kept unique. PyCF_ constants can use bits from + 0x0100 to 0x10000. CO_FUTURE_ constants use bits starting at 0x20000. */ +#define CO_FUTURE_DIVISION 0x20000 +#define CO_FUTURE_ABSOLUTE_IMPORT 0x40000 /* do absolute imports by default */ +#define CO_FUTURE_WITH_STATEMENT 0x80000 +#define CO_FUTURE_PRINT_FUNCTION 0x100000 +#define CO_FUTURE_UNICODE_LITERALS 0x200000 + +#define CO_FUTURE_BARRY_AS_BDFL 0x400000 +#define CO_FUTURE_GENERATOR_STOP 0x800000 +#define CO_FUTURE_ANNOTATIONS 0x1000000 + +/* This value is found in the co_cell2arg array when the associated cell + variable does not correspond to an argument. */ +#define CO_CELL_NOT_AN_ARG (-1) + +/* This should be defined if a future statement modifies the syntax. + For example, when a keyword is added. +*/ +#define PY_PARSER_REQUIRES_FUTURE_KEYWORD + +#define CO_MAXBLOCKS 20 /* Max static block nesting within a function */ + +PyAPI_DATA(PyTypeObject) PyCode_Type; + +#define PyCode_Check(op) Py_IS_TYPE(op, &PyCode_Type) +#define PyCode_GetNumFree(op) (PyTuple_GET_SIZE((op)->co_freevars)) + +/* Public interface */ +PyAPI_FUNC(PyCodeObject *) PyCode_New( + int, int, int, int, int, PyObject *, PyObject *, + PyObject *, PyObject *, PyObject *, PyObject *, + PyObject *, PyObject *, int, PyObject *); + +PyAPI_FUNC(PyCodeObject *) PyCode_NewWithPosOnlyArgs( + int, int, int, int, int, int, PyObject *, PyObject *, + PyObject *, PyObject *, PyObject *, PyObject *, + PyObject *, PyObject *, int, PyObject *); + /* same as struct above */ + +/* Creates a new empty code object with the specified source location. */ +PyAPI_FUNC(PyCodeObject *) +PyCode_NewEmpty(const char *filename, const char *funcname, int firstlineno); + +/* Return the line number associated with the specified bytecode index + in this code object. If you just need the line number of a frame, + use PyFrame_GetLineNumber() instead. */ +PyAPI_FUNC(int) PyCode_Addr2Line(PyCodeObject *, int); + +/* for internal use only */ +struct _opaque { + int computed_line; + const char *lo_next; + const char *limit; +}; + +typedef struct _line_offsets { + int ar_start; + int ar_end; + int ar_line; + struct _opaque opaque; +} PyCodeAddressRange; + +/* Update *bounds to describe the first and one-past-the-last instructions in the + same line as lasti. Return the number of that line. +*/ +PyAPI_FUNC(int) _PyCode_CheckLineNumber(int lasti, PyCodeAddressRange *bounds); + +/* Create a comparable key used to compare constants taking in account the + * object type. It is used to make sure types are not coerced (e.g., float and + * complex) _and_ to distinguish 0.0 from -0.0 e.g. on IEEE platforms + * + * Return (type(obj), obj, ...): a tuple with variable size (at least 2 items) + * depending on the type and the value. The type is the first item to not + * compare bytes and str which can raise a BytesWarning exception. */ +PyAPI_FUNC(PyObject*) _PyCode_ConstantKey(PyObject *obj); + +PyAPI_FUNC(PyObject*) PyCode_Optimize(PyObject *code, PyObject* consts, + PyObject *names, PyObject *lnotab); + + +PyAPI_FUNC(int) _PyCode_GetExtra(PyObject *code, Py_ssize_t index, + void **extra); +PyAPI_FUNC(int) _PyCode_SetExtra(PyObject *code, Py_ssize_t index, + void *extra); + +/** API for initializing the line number table. */ +int _PyCode_InitAddressRange(PyCodeObject* co, PyCodeAddressRange *bounds); + +/** Out of process API for initializing the line number table. */ +void PyLineTable_InitAddressRange(const char *linetable, Py_ssize_t length, int firstlineno, PyCodeAddressRange *range); + +/** API for traversing the line number table. */ +int PyLineTable_NextAddressRange(PyCodeAddressRange *range); +int PyLineTable_PreviousAddressRange(PyCodeAddressRange *range); + + diff --git a/include/cpython/compile.h b/include/cpython/compile.h new file mode 100644 index 00000000..518a3764 --- /dev/null +++ b/include/cpython/compile.h @@ -0,0 +1,54 @@ +#ifndef Py_CPYTHON_COMPILE_H +# error "this header file must not be included directly" +#endif + +/* Public interface */ +#define PyCF_MASK (CO_FUTURE_DIVISION | CO_FUTURE_ABSOLUTE_IMPORT | \ + CO_FUTURE_WITH_STATEMENT | CO_FUTURE_PRINT_FUNCTION | \ + CO_FUTURE_UNICODE_LITERALS | CO_FUTURE_BARRY_AS_BDFL | \ + CO_FUTURE_GENERATOR_STOP | CO_FUTURE_ANNOTATIONS) +#define PyCF_MASK_OBSOLETE (CO_NESTED) + +/* bpo-39562: CO_FUTURE_ and PyCF_ constants must be kept unique. + PyCF_ constants can use bits from 0x0100 to 0x10000. + CO_FUTURE_ constants use bits starting at 0x20000. */ +#define PyCF_SOURCE_IS_UTF8 0x0100 +#define PyCF_DONT_IMPLY_DEDENT 0x0200 +#define PyCF_ONLY_AST 0x0400 +#define PyCF_IGNORE_COOKIE 0x0800 +#define PyCF_TYPE_COMMENTS 0x1000 +#define PyCF_ALLOW_TOP_LEVEL_AWAIT 0x2000 +#define PyCF_ALLOW_INCOMPLETE_INPUT 0x4000 +#define PyCF_COMPILE_MASK (PyCF_ONLY_AST | PyCF_ALLOW_TOP_LEVEL_AWAIT | \ + PyCF_TYPE_COMMENTS | PyCF_DONT_IMPLY_DEDENT | \ + PyCF_ALLOW_INCOMPLETE_INPUT) + +typedef struct { + int cf_flags; /* bitmask of CO_xxx flags relevant to future */ + int cf_feature_version; /* minor Python version (PyCF_ONLY_AST) */ +} PyCompilerFlags; + +#define _PyCompilerFlags_INIT \ + (PyCompilerFlags){.cf_flags = 0, .cf_feature_version = PY_MINOR_VERSION} + +/* Future feature support */ + +typedef struct { + int ff_features; /* flags set by future statements */ + int ff_lineno; /* line number of last future statement */ +} PyFutureFeatures; + +#define FUTURE_NESTED_SCOPES "nested_scopes" +#define FUTURE_GENERATORS "generators" +#define FUTURE_DIVISION "division" +#define FUTURE_ABSOLUTE_IMPORT "absolute_import" +#define FUTURE_WITH_STATEMENT "with_statement" +#define FUTURE_PRINT_FUNCTION "print_function" +#define FUTURE_UNICODE_LITERALS "unicode_literals" +#define FUTURE_BARRY_AS_BDFL "barry_as_FLUFL" +#define FUTURE_GENERATOR_STOP "generator_stop" +#define FUTURE_ANNOTATIONS "annotations" + +#define PY_INVALID_STACK_EFFECT INT_MAX +PyAPI_FUNC(int) PyCompile_OpcodeStackEffect(int opcode, int oparg); +PyAPI_FUNC(int) PyCompile_OpcodeStackEffectWithJump(int opcode, int oparg, int jump); diff --git a/include/cpython/dictobject.h b/include/cpython/dictobject.h new file mode 100644 index 00000000..641d7bdc --- /dev/null +++ b/include/cpython/dictobject.h @@ -0,0 +1,84 @@ +#ifndef Py_CPYTHON_DICTOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct _dictkeysobject PyDictKeysObject; + +/* The ma_values pointer is NULL for a combined table + * or points to an array of PyObject* for a split table + */ +typedef struct { + PyObject_HEAD + + /* Number of items in the dictionary */ + Py_ssize_t ma_used; + + /* Dictionary version: globally unique, value change each time + the dictionary is modified */ + uint64_t ma_version_tag; + + PyDictKeysObject *ma_keys; + + /* If ma_values is NULL, the table is "combined": keys and values + are stored in ma_keys. + + If ma_values is not NULL, the table is split: + keys are stored in ma_keys and values are stored in ma_values */ + PyObject **ma_values; +} PyDictObject; + +PyAPI_FUNC(PyObject *) _PyDict_GetItem_KnownHash(PyObject *mp, PyObject *key, + Py_hash_t hash); +PyAPI_FUNC(PyObject *) _PyDict_GetItemIdWithError(PyObject *dp, + struct _Py_Identifier *key); +PyAPI_FUNC(PyObject *) _PyDict_GetItemStringWithError(PyObject *, const char *); +PyAPI_FUNC(PyObject *) PyDict_SetDefault( + PyObject *mp, PyObject *key, PyObject *defaultobj); +PyAPI_FUNC(int) _PyDict_SetItem_KnownHash(PyObject *mp, PyObject *key, + PyObject *item, Py_hash_t hash); +PyAPI_FUNC(int) _PyDict_DelItem_KnownHash(PyObject *mp, PyObject *key, + Py_hash_t hash); +PyAPI_FUNC(int) _PyDict_DelItemIf(PyObject *mp, PyObject *key, + int (*predicate)(PyObject *value)); +PyDictKeysObject *_PyDict_NewKeysForClass(void); +PyAPI_FUNC(int) _PyDict_Next( + PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, Py_hash_t *hash); + +/* Get the number of items of a dictionary. */ +#define PyDict_GET_SIZE(mp) (assert(PyDict_Check(mp)),((PyDictObject *)mp)->ma_used) +PyAPI_FUNC(int) _PyDict_Contains_KnownHash(PyObject *, PyObject *, Py_hash_t); +PyAPI_FUNC(int) _PyDict_ContainsId(PyObject *, struct _Py_Identifier *); +PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused); +PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp); +PyAPI_FUNC(int) _PyDict_HasOnlyStringKeys(PyObject *mp); +Py_ssize_t _PyDict_KeysSize(PyDictKeysObject *keys); +PyAPI_FUNC(Py_ssize_t) _PyDict_SizeOf(PyDictObject *); +PyAPI_FUNC(PyObject *) _PyDict_Pop(PyObject *, PyObject *, PyObject *); +PyObject *_PyDict_Pop_KnownHash(PyObject *, PyObject *, Py_hash_t, PyObject *); +PyObject *_PyDict_FromKeys(PyObject *, PyObject *, PyObject *); +#define _PyDict_HasSplitTable(d) ((d)->ma_values != NULL) + +/* Like PyDict_Merge, but override can be 0, 1 or 2. If override is 0, + the first occurrence of a key wins, if override is 1, the last occurrence + of a key wins, if override is 2, a KeyError with conflicting key as + argument is raised. +*/ +PyAPI_FUNC(int) _PyDict_MergeEx(PyObject *mp, PyObject *other, int override); +PyAPI_FUNC(int) _PyDict_SetItemId(PyObject *dp, struct _Py_Identifier *key, PyObject *item); + +PyAPI_FUNC(int) _PyDict_DelItemId(PyObject *mp, struct _Py_Identifier *key); +PyAPI_FUNC(void) _PyDict_DebugMallocStats(FILE *out); + +int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject **dictptr, PyObject *name, PyObject *value); +PyObject *_PyDict_LoadGlobal(PyDictObject *, PyDictObject *, PyObject *); +Py_ssize_t _PyDict_GetItemHint(PyDictObject *, PyObject *, Py_ssize_t, PyObject **); + +/* _PyDictView */ + +typedef struct { + PyObject_HEAD + PyDictObject *dv_dict; +} _PyDictViewObject; + +PyAPI_FUNC(PyObject *) _PyDictView_New(PyObject *, PyTypeObject *); +PyAPI_FUNC(PyObject *) _PyDictView_Intersect(PyObject* self, PyObject *other); diff --git a/include/cpython/fileobject.h b/include/cpython/fileobject.h new file mode 100644 index 00000000..cff2243d --- /dev/null +++ b/include/cpython/fileobject.h @@ -0,0 +1,18 @@ +#ifndef Py_CPYTHON_FILEOBJECT_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *); + +/* The std printer acts as a preliminary sys.stderr until the new io + infrastructure is in place. */ +PyAPI_FUNC(PyObject *) PyFile_NewStdPrinter(int); +PyAPI_DATA(PyTypeObject) PyStdPrinter_Type; + +typedef PyObject * (*Py_OpenCodeHookFunction)(PyObject *, void *); + +PyAPI_FUNC(PyObject *) PyFile_OpenCode(const char *utf8path); +PyAPI_FUNC(PyObject *) PyFile_OpenCodeObject(PyObject *path); +PyAPI_FUNC(int) PyFile_SetOpenCodeHook(Py_OpenCodeHookFunction hook, void *userData); + +PyAPI_FUNC(int) _PyLong_FileDescriptor_Converter(PyObject *, void *); diff --git a/include/cpython/fileutils.h b/include/cpython/fileutils.h new file mode 100644 index 00000000..ccf37e94 --- /dev/null +++ b/include/cpython/fileutils.h @@ -0,0 +1,172 @@ +#ifndef Py_CPYTHON_FILEUTILS_H +# error "this header file must not be included directly" +#endif + +typedef enum { + _Py_ERROR_UNKNOWN=0, + _Py_ERROR_STRICT, + _Py_ERROR_SURROGATEESCAPE, + _Py_ERROR_REPLACE, + _Py_ERROR_IGNORE, + _Py_ERROR_BACKSLASHREPLACE, + _Py_ERROR_SURROGATEPASS, + _Py_ERROR_XMLCHARREFREPLACE, + _Py_ERROR_OTHER +} _Py_error_handler; + +PyAPI_FUNC(_Py_error_handler) _Py_GetErrorHandler(const char *errors); + +PyAPI_FUNC(int) _Py_DecodeLocaleEx( + const char *arg, + wchar_t **wstr, + size_t *wlen, + const char **reason, + int current_locale, + _Py_error_handler errors); + +PyAPI_FUNC(int) _Py_EncodeLocaleEx( + const wchar_t *text, + char **str, + size_t *error_pos, + const char **reason, + int current_locale, + _Py_error_handler errors); + +PyAPI_FUNC(char*) _Py_EncodeLocaleRaw( + const wchar_t *text, + size_t *error_pos); + +PyAPI_FUNC(PyObject *) _Py_device_encoding(int); + +#if defined(MS_WINDOWS) || defined(__APPLE__) + /* On Windows, the count parameter of read() is an int (bpo-9015, bpo-9611). + On macOS 10.13, read() and write() with more than INT_MAX bytes + fail with EINVAL (bpo-24658). */ +# define _PY_READ_MAX INT_MAX +# define _PY_WRITE_MAX INT_MAX +#else + /* write() should truncate the input to PY_SSIZE_T_MAX bytes, + but it's safer to do it ourself to have a portable behaviour */ +# define _PY_READ_MAX PY_SSIZE_T_MAX +# define _PY_WRITE_MAX PY_SSIZE_T_MAX +#endif + +#ifdef MS_WINDOWS +struct _Py_stat_struct { + unsigned long st_dev; + uint64_t st_ino; + unsigned short st_mode; + int st_nlink; + int st_uid; + int st_gid; + unsigned long st_rdev; + __int64 st_size; + time_t st_atime; + int st_atime_nsec; + time_t st_mtime; + int st_mtime_nsec; + time_t st_ctime; + int st_ctime_nsec; + unsigned long st_file_attributes; + unsigned long st_reparse_tag; +}; +#else +# define _Py_stat_struct stat +#endif + +PyAPI_FUNC(int) _Py_fstat( + int fd, + struct _Py_stat_struct *status); + +PyAPI_FUNC(int) _Py_fstat_noraise( + int fd, + struct _Py_stat_struct *status); + +PyAPI_FUNC(int) _Py_stat( + PyObject *path, + struct stat *status); + +PyAPI_FUNC(int) _Py_open( + const char *pathname, + int flags); + +PyAPI_FUNC(int) _Py_open_noraise( + const char *pathname, + int flags); + +PyAPI_FUNC(FILE *) _Py_wfopen( + const wchar_t *path, + const wchar_t *mode); + +PyAPI_FUNC(FILE*) _Py_fopen_obj( + PyObject *path, + const char *mode); + +PyAPI_FUNC(Py_ssize_t) _Py_read( + int fd, + void *buf, + size_t count); + +PyAPI_FUNC(Py_ssize_t) _Py_write( + int fd, + const void *buf, + size_t count); + +PyAPI_FUNC(Py_ssize_t) _Py_write_noraise( + int fd, + const void *buf, + size_t count); + +#ifdef HAVE_READLINK +PyAPI_FUNC(int) _Py_wreadlink( + const wchar_t *path, + wchar_t *buf, + /* Number of characters of 'buf' buffer + including the trailing NUL character */ + size_t buflen); +#endif + +#ifdef HAVE_REALPATH +PyAPI_FUNC(wchar_t*) _Py_wrealpath( + const wchar_t *path, + wchar_t *resolved_path, + /* Number of characters of 'resolved_path' buffer + including the trailing NUL character */ + size_t resolved_path_len); +#endif + +#ifndef MS_WINDOWS +PyAPI_FUNC(int) _Py_isabs(const wchar_t *path); +#endif + +PyAPI_FUNC(int) _Py_abspath(const wchar_t *path, wchar_t **abspath_p); + +PyAPI_FUNC(wchar_t*) _Py_wgetcwd( + wchar_t *buf, + /* Number of characters of 'buf' buffer + including the trailing NUL character */ + size_t buflen); + +PyAPI_FUNC(int) _Py_get_inheritable(int fd); + +PyAPI_FUNC(int) _Py_set_inheritable(int fd, int inheritable, + int *atomic_flag_works); + +PyAPI_FUNC(int) _Py_set_inheritable_async_safe(int fd, int inheritable, + int *atomic_flag_works); + +PyAPI_FUNC(int) _Py_dup(int fd); + +#ifndef MS_WINDOWS +PyAPI_FUNC(int) _Py_get_blocking(int fd); + +PyAPI_FUNC(int) _Py_set_blocking(int fd, int blocking); +#else /* MS_WINDOWS */ +PyAPI_FUNC(void*) _Py_get_osfhandle_noraise(int fd); + +PyAPI_FUNC(void*) _Py_get_osfhandle(int fd); + +PyAPI_FUNC(int) _Py_open_osfhandle_noraise(void *handle, int flags); + +PyAPI_FUNC(int) _Py_open_osfhandle(void *handle, int flags); +#endif /* MS_WINDOWS */ diff --git a/include/cpython/frameobject.h b/include/cpython/frameobject.h new file mode 100644 index 00000000..5122ec41 --- /dev/null +++ b/include/cpython/frameobject.h @@ -0,0 +1,94 @@ +/* Frame object interface */ + +#ifndef Py_CPYTHON_FRAMEOBJECT_H +# error "this header file must not be included directly" +#endif + +/* These values are chosen so that the inline functions below all + * compare f_state to zero. + */ +enum _framestate { + FRAME_CREATED = -2, + FRAME_SUSPENDED = -1, + FRAME_EXECUTING = 0, + FRAME_RETURNED = 1, + FRAME_UNWINDING = 2, + FRAME_RAISED = 3, + FRAME_CLEARED = 4 +}; + +typedef signed char PyFrameState; + +typedef struct { + int b_type; /* what kind of block this is */ + int b_handler; /* where to jump to find handler */ + int b_level; /* value stack level to pop to */ +} PyTryBlock; + +struct _frame { + PyObject_VAR_HEAD + struct _frame *f_back; /* previous frame, or NULL */ + PyCodeObject *f_code; /* code segment */ + PyObject *f_builtins; /* builtin symbol table (PyDictObject) */ + PyObject *f_globals; /* global symbol table (PyDictObject) */ + PyObject *f_locals; /* local symbol table (any mapping) */ + PyObject **f_valuestack; /* points after the last local */ + PyObject *f_trace; /* Trace function */ + int f_stackdepth; /* Depth of value stack */ + char f_trace_lines; /* Emit per-line trace events? */ + char f_trace_opcodes; /* Emit per-opcode trace events? */ + + /* Borrowed reference to a generator, or NULL */ + PyObject *f_gen; + + int f_lasti; /* Last instruction if called */ + int f_lineno; /* Current line number. Only valid if non-zero */ + int f_iblock; /* index in f_blockstack */ + PyFrameState f_state; /* What state the frame is in */ + PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ + PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ +}; + +static inline int _PyFrame_IsRunnable(struct _frame *f) { + return f->f_state < FRAME_EXECUTING; +} + +static inline int _PyFrame_IsExecuting(struct _frame *f) { + return f->f_state == FRAME_EXECUTING; +} + +static inline int _PyFrameHasCompleted(struct _frame *f) { + return f->f_state > FRAME_EXECUTING; +} + +/* Standard object interface */ + +PyAPI_DATA(PyTypeObject) PyFrame_Type; + +#define PyFrame_Check(op) Py_IS_TYPE(op, &PyFrame_Type) + +PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *, + PyObject *, PyObject *); + +/* only internal use */ +PyFrameObject* +_PyFrame_New_NoTrack(PyThreadState *, PyFrameConstructor *, PyObject *); + + +/* The rest of the interface is specific for frame objects */ + +/* Block management functions */ + +PyAPI_FUNC(void) PyFrame_BlockSetup(PyFrameObject *, int, int, int); +PyAPI_FUNC(PyTryBlock *) PyFrame_BlockPop(PyFrameObject *); + +/* Conversions between "fast locals" and locals in dictionary */ + +PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int); + +PyAPI_FUNC(int) PyFrame_FastToLocalsWithError(PyFrameObject *f); +PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *); + +PyAPI_FUNC(void) _PyFrame_DebugMallocStats(FILE *out); + +PyAPI_FUNC(PyFrameObject *) PyFrame_GetBack(PyFrameObject *frame); diff --git a/include/cpython/import.h b/include/cpython/import.h new file mode 100644 index 00000000..419945f7 --- /dev/null +++ b/include/cpython/import.h @@ -0,0 +1,46 @@ +#ifndef Py_CPYTHON_IMPORT_H +# error "this header file must not be included directly" +#endif + +PyMODINIT_FUNC PyInit__imp(void); + +PyAPI_FUNC(int) _PyImport_IsInitialized(PyInterpreterState *); + +PyAPI_FUNC(PyObject *) _PyImport_GetModuleId(struct _Py_Identifier *name); +PyAPI_FUNC(int) _PyImport_SetModule(PyObject *name, PyObject *module); +PyAPI_FUNC(int) _PyImport_SetModuleString(const char *name, PyObject* module); + +PyAPI_FUNC(void) _PyImport_AcquireLock(void); +PyAPI_FUNC(int) _PyImport_ReleaseLock(void); + +/* Obsolete since 3.5, will be removed in 3.11. */ +Py_DEPRECATED(3.10) PyAPI_FUNC(PyObject *) _PyImport_FindExtensionObject(PyObject *, PyObject *); + +PyAPI_FUNC(int) _PyImport_FixupBuiltin( + PyObject *mod, + const char *name, /* UTF-8 encoded string */ + PyObject *modules + ); +PyAPI_FUNC(int) _PyImport_FixupExtensionObject(PyObject*, PyObject *, + PyObject *, PyObject *); + +struct _inittab { + const char *name; /* ASCII encoded string */ + PyObject* (*initfunc)(void); +}; +PyAPI_DATA(struct _inittab *) PyImport_Inittab; +PyAPI_FUNC(int) PyImport_ExtendInittab(struct _inittab *newtab); + +struct _frozen { + const char *name; /* ASCII encoded string */ + const unsigned char *code; + int size; +}; + +/* Embedding apps may change this pointer to point to their favorite + collection of frozen modules: */ + +PyAPI_DATA(const struct _frozen *) PyImport_FrozenModules; + +PyAPI_DATA(PyObject *) _PyImport_GetModuleAttr(PyObject *, PyObject *); +PyAPI_DATA(PyObject *) _PyImport_GetModuleAttrString(const char *, const char *); diff --git a/include/cpython/initconfig.h b/include/cpython/initconfig.h new file mode 100644 index 00000000..583165be --- /dev/null +++ b/include/cpython/initconfig.h @@ -0,0 +1,249 @@ +#ifndef Py_PYCORECONFIG_H +#define Py_PYCORECONFIG_H +#ifndef Py_LIMITED_API +#ifdef __cplusplus +extern "C" { +#endif + +/* --- PyStatus ----------------------------------------------- */ + +typedef struct { + enum { + _PyStatus_TYPE_OK=0, + _PyStatus_TYPE_ERROR=1, + _PyStatus_TYPE_EXIT=2 + } _type; + const char *func; + const char *err_msg; + int exitcode; +} PyStatus; + +PyAPI_FUNC(PyStatus) PyStatus_Ok(void); +PyAPI_FUNC(PyStatus) PyStatus_Error(const char *err_msg); +PyAPI_FUNC(PyStatus) PyStatus_NoMemory(void); +PyAPI_FUNC(PyStatus) PyStatus_Exit(int exitcode); +PyAPI_FUNC(int) PyStatus_IsError(PyStatus err); +PyAPI_FUNC(int) PyStatus_IsExit(PyStatus err); +PyAPI_FUNC(int) PyStatus_Exception(PyStatus err); + +/* --- PyWideStringList ------------------------------------------------ */ + +typedef struct { + /* If length is greater than zero, items must be non-NULL + and all items strings must be non-NULL */ + Py_ssize_t length; + wchar_t **items; +} PyWideStringList; + +PyAPI_FUNC(PyStatus) PyWideStringList_Append(PyWideStringList *list, + const wchar_t *item); +PyAPI_FUNC(PyStatus) PyWideStringList_Insert(PyWideStringList *list, + Py_ssize_t index, + const wchar_t *item); + + +/* --- PyPreConfig ----------------------------------------------- */ + +typedef struct PyPreConfig { + int _config_init; /* _PyConfigInitEnum value */ + + /* Parse Py_PreInitializeFromBytesArgs() arguments? + See PyConfig.parse_argv */ + int parse_argv; + + /* If greater than 0, enable isolated mode: sys.path contains + neither the script's directory nor the user's site-packages directory. + + Set to 1 by the -I command line option. If set to -1 (default), inherit + Py_IsolatedFlag value. */ + int isolated; + + /* If greater than 0: use environment variables. + Set to 0 by -E command line option. If set to -1 (default), it is + set to !Py_IgnoreEnvironmentFlag. */ + int use_environment; + + /* Set the LC_CTYPE locale to the user preferred locale? If equals to 0, + set coerce_c_locale and coerce_c_locale_warn to 0. */ + int configure_locale; + + /* Coerce the LC_CTYPE locale if it's equal to "C"? (PEP 538) + + Set to 0 by PYTHONCOERCECLOCALE=0. Set to 1 by PYTHONCOERCECLOCALE=1. + Set to 2 if the user preferred LC_CTYPE locale is "C". + + If it is equal to 1, LC_CTYPE locale is read to decide if it should be + coerced or not (ex: PYTHONCOERCECLOCALE=1). Internally, it is set to 2 + if the LC_CTYPE locale must be coerced. + + Disable by default (set to 0). Set it to -1 to let Python decide if it + should be enabled or not. */ + int coerce_c_locale; + + /* Emit a warning if the LC_CTYPE locale is coerced? + + Set to 1 by PYTHONCOERCECLOCALE=warn. + + Disable by default (set to 0). Set it to -1 to let Python decide if it + should be enabled or not. */ + int coerce_c_locale_warn; + +#ifdef MS_WINDOWS + /* If greater than 1, use the "mbcs" encoding instead of the UTF-8 + encoding for the filesystem encoding. + + Set to 1 if the PYTHONLEGACYWINDOWSFSENCODING environment variable is + set to a non-empty string. If set to -1 (default), inherit + Py_LegacyWindowsFSEncodingFlag value. + + See PEP 529 for more details. */ + int legacy_windows_fs_encoding; +#endif + + /* Enable UTF-8 mode? (PEP 540) + + Disabled by default (equals to 0). + + Set to 1 by "-X utf8" and "-X utf8=1" command line options. + Set to 1 by PYTHONUTF8=1 environment variable. + + Set to 0 by "-X utf8=0" and PYTHONUTF8=0. + + If equals to -1, it is set to 1 if the LC_CTYPE locale is "C" or + "POSIX", otherwise it is set to 0. Inherit Py_UTF8Mode value value. */ + int utf8_mode; + + /* If non-zero, enable the Python Development Mode. + + Set to 1 by the -X dev command line option. Set by the PYTHONDEVMODE + environment variable. */ + int dev_mode; + + /* Memory allocator: PYTHONMALLOC env var. + See PyMemAllocatorName for valid values. */ + int allocator; +} PyPreConfig; + +PyAPI_FUNC(void) PyPreConfig_InitPythonConfig(PyPreConfig *config); +PyAPI_FUNC(void) PyPreConfig_InitIsolatedConfig(PyPreConfig *config); + + +/* --- PyConfig ---------------------------------------------- */ + +/* This structure is best documented in the Doc/c-api/init_config.rst file. */ +typedef struct PyConfig { + int _config_init; /* _PyConfigInitEnum value */ + + int isolated; + int use_environment; + int dev_mode; + int install_signal_handlers; + int use_hash_seed; + unsigned long hash_seed; + int faulthandler; + int tracemalloc; + int import_time; + int show_ref_count; + int dump_refs; + int malloc_stats; + wchar_t *filesystem_encoding; + wchar_t *filesystem_errors; + wchar_t *pycache_prefix; + int parse_argv; + PyWideStringList orig_argv; + PyWideStringList argv; + PyWideStringList xoptions; + PyWideStringList warnoptions; + int site_import; + int bytes_warning; + int warn_default_encoding; + int inspect; + int interactive; + int optimization_level; + int parser_debug; + int write_bytecode; + int verbose; + int quiet; + int user_site_directory; + int configure_c_stdio; + int buffered_stdio; + wchar_t *stdio_encoding; + wchar_t *stdio_errors; +#ifdef MS_WINDOWS + int legacy_windows_stdio; +#endif + wchar_t *check_hash_pycs_mode; + + /* --- Path configuration inputs ------------ */ + int pathconfig_warnings; + wchar_t *program_name; + wchar_t *pythonpath_env; + wchar_t *home; + wchar_t *platlibdir; + + /* --- Path configuration outputs ----------- */ + int module_search_paths_set; + PyWideStringList module_search_paths; + wchar_t *executable; + wchar_t *base_executable; + wchar_t *prefix; + wchar_t *base_prefix; + wchar_t *exec_prefix; + wchar_t *base_exec_prefix; + + /* --- Parameter only used by Py_Main() ---------- */ + int skip_source_first_line; + wchar_t *run_command; + wchar_t *run_module; + wchar_t *run_filename; + + /* --- Private fields ---------------------------- */ + + // Install importlib? If equals to 0, importlib is not initialized at all. + // Needed by freeze_importlib. + int _install_importlib; + + // If equal to 0, stop Python initialization before the "main" phase. + int _init_main; + + // If non-zero, disallow threads, subprocesses, and fork. + // Default: 0. + int _isolated_interpreter; +} PyConfig; + +PyAPI_FUNC(void) PyConfig_InitPythonConfig(PyConfig *config); +PyAPI_FUNC(void) PyConfig_InitIsolatedConfig(PyConfig *config); +PyAPI_FUNC(void) PyConfig_Clear(PyConfig *); +PyAPI_FUNC(PyStatus) PyConfig_SetString( + PyConfig *config, + wchar_t **config_str, + const wchar_t *str); +PyAPI_FUNC(PyStatus) PyConfig_SetBytesString( + PyConfig *config, + wchar_t **config_str, + const char *str); +PyAPI_FUNC(PyStatus) PyConfig_Read(PyConfig *config); +PyAPI_FUNC(PyStatus) PyConfig_SetBytesArgv( + PyConfig *config, + Py_ssize_t argc, + char * const *argv); +PyAPI_FUNC(PyStatus) PyConfig_SetArgv(PyConfig *config, + Py_ssize_t argc, + wchar_t * const *argv); +PyAPI_FUNC(PyStatus) PyConfig_SetWideStringList(PyConfig *config, + PyWideStringList *list, + Py_ssize_t length, wchar_t **items); + + +/* --- Helper functions --------------------------------------- */ + +/* Get the original command line arguments, before Python modified them. + + See also PyConfig.orig_argv. */ +PyAPI_FUNC(void) Py_GetArgcArgv(int *argc, wchar_t ***argv); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_LIMITED_API */ +#endif /* !Py_PYCORECONFIG_H */ diff --git a/include/cpython/interpreteridobject.h b/include/cpython/interpreteridobject.h new file mode 100644 index 00000000..50765842 --- /dev/null +++ b/include/cpython/interpreteridobject.h @@ -0,0 +1,11 @@ +#ifndef Py_CPYTHON_INTERPRETERIDOBJECT_H +# error "this header file must not be included directly" +#endif + +/* Interpreter ID Object */ + +PyAPI_DATA(PyTypeObject) _PyInterpreterID_Type; + +PyAPI_FUNC(PyObject *) _PyInterpreterID_New(int64_t); +PyAPI_FUNC(PyObject *) _PyInterpreterState_GetIDObject(PyInterpreterState *); +PyAPI_FUNC(PyInterpreterState *) _PyInterpreterID_LookUp(PyObject *); diff --git a/include/cpython/listobject.h b/include/cpython/listobject.h new file mode 100644 index 00000000..e3239152 --- /dev/null +++ b/include/cpython/listobject.h @@ -0,0 +1,34 @@ +#ifndef Py_CPYTHON_LISTOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct { + PyObject_VAR_HEAD + /* Vector of pointers to list elements. list[0] is ob_item[0], etc. */ + PyObject **ob_item; + + /* ob_item contains space for 'allocated' elements. The number + * currently in use is ob_size. + * Invariants: + * 0 <= ob_size <= allocated + * len(list) == ob_size + * ob_item == NULL implies ob_size == allocated == 0 + * list.sort() temporarily sets allocated to -1 to detect mutations. + * + * Items must normally not be NULL, except during construction when + * the list is not yet visible outside the function that builds it. + */ + Py_ssize_t allocated; +} PyListObject; + +PyAPI_FUNC(PyObject *) _PyList_Extend(PyListObject *, PyObject *); +PyAPI_FUNC(void) _PyList_DebugMallocStats(FILE *out); + +/* Macro, trading safety for speed */ + +/* Cast argument to PyListObject* type. */ +#define _PyList_CAST(op) (assert(PyList_Check(op)), (PyListObject *)(op)) + +#define PyList_GET_ITEM(op, i) (_PyList_CAST(op)->ob_item[i]) +#define PyList_SET_ITEM(op, i, v) ((void)(_PyList_CAST(op)->ob_item[i] = (v))) +#define PyList_GET_SIZE(op) Py_SIZE(_PyList_CAST(op)) diff --git a/include/cpython/methodobject.h b/include/cpython/methodobject.h new file mode 100644 index 00000000..7ecbfe3b --- /dev/null +++ b/include/cpython/methodobject.h @@ -0,0 +1,35 @@ +#ifndef Py_CPYTHON_METHODOBJECT_H +# error "this header file must not be included directly" +#endif + +PyAPI_DATA(PyTypeObject) PyCMethod_Type; + +#define PyCMethod_CheckExact(op) Py_IS_TYPE(op, &PyCMethod_Type) +#define PyCMethod_Check(op) PyObject_TypeCheck(op, &PyCMethod_Type) + +/* Macros for direct access to these values. Type checks are *not* + done, so use with care. */ +#define PyCFunction_GET_FUNCTION(func) \ + (((PyCFunctionObject *)func) -> m_ml -> ml_meth) +#define PyCFunction_GET_SELF(func) \ + (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_STATIC ? \ + NULL : ((PyCFunctionObject *)func) -> m_self) +#define PyCFunction_GET_FLAGS(func) \ + (((PyCFunctionObject *)func) -> m_ml -> ml_flags) +#define PyCFunction_GET_CLASS(func) \ + (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_METHOD ? \ + ((PyCMethodObject *)func) -> mm_class : NULL) + +typedef struct { + PyObject_HEAD + PyMethodDef *m_ml; /* Description of the C function to call */ + PyObject *m_self; /* Passed as 'self' arg to the C func, can be NULL */ + PyObject *m_module; /* The __module__ attribute, can be anything */ + PyObject *m_weakreflist; /* List of weak references */ + vectorcallfunc vectorcall; +} PyCFunctionObject; + +typedef struct { + PyCFunctionObject func; + PyTypeObject *mm_class; /* Class that defines this method */ +} PyCMethodObject; diff --git a/include/cpython/object.h b/include/cpython/object.h new file mode 100644 index 00000000..84c60e55 --- /dev/null +++ b/include/cpython/object.h @@ -0,0 +1,552 @@ +#ifndef Py_CPYTHON_OBJECT_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(void) _Py_NewReference(PyObject *op); + +#ifdef Py_TRACE_REFS +/* Py_TRACE_REFS is such major surgery that we call external routines. */ +PyAPI_FUNC(void) _Py_ForgetReference(PyObject *); +#endif + +#ifdef Py_REF_DEBUG +PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void); +#endif + + +/********************* String Literals ****************************************/ +/* This structure helps managing static strings. The basic usage goes like this: + Instead of doing + + r = PyObject_CallMethod(o, "foo", "args", ...); + + do + + _Py_IDENTIFIER(foo); + ... + r = _PyObject_CallMethodId(o, &PyId_foo, "args", ...); + + PyId_foo is a static variable, either on block level or file level. On first + usage, the string "foo" is interned, and the structures are linked. On interpreter + shutdown, all strings are released. + + Alternatively, _Py_static_string allows choosing the variable name. + _PyUnicode_FromId returns a borrowed reference to the interned string. + _PyObject_{Get,Set,Has}AttrId are __getattr__ versions using _Py_Identifier*. +*/ +typedef struct _Py_Identifier { + const char* string; + // Index in PyInterpreterState.unicode.ids.array. It is process-wide + // unique and must be initialized to -1. + Py_ssize_t index; +} _Py_Identifier; + +#define _Py_static_string_init(value) { .string = value, .index = -1 } +#define _Py_static_string(varname, value) static _Py_Identifier varname = _Py_static_string_init(value) +#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname) + +/* buffer interface */ +typedef struct bufferinfo { + void *buf; + PyObject *obj; /* owned reference */ + Py_ssize_t len; + Py_ssize_t itemsize; /* This is Py_ssize_t so it can be + pointed to by strides in simple case.*/ + int readonly; + int ndim; + char *format; + Py_ssize_t *shape; + Py_ssize_t *strides; + Py_ssize_t *suboffsets; + void *internal; +} Py_buffer; + +typedef int (*getbufferproc)(PyObject *, Py_buffer *, int); +typedef void (*releasebufferproc)(PyObject *, Py_buffer *); + +typedef PyObject *(*vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + +/* Maximum number of dimensions */ +#define PyBUF_MAX_NDIM 64 + +/* Flags for getting buffers */ +#define PyBUF_SIMPLE 0 +#define PyBUF_WRITABLE 0x0001 +/* we used to include an E, backwards compatible alias */ +#define PyBUF_WRITEABLE PyBUF_WRITABLE +#define PyBUF_FORMAT 0x0004 +#define PyBUF_ND 0x0008 +#define PyBUF_STRIDES (0x0010 | PyBUF_ND) +#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES) +#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES) +#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES) +#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES) + +#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE) +#define PyBUF_CONTIG_RO (PyBUF_ND) + +#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE) +#define PyBUF_STRIDED_RO (PyBUF_STRIDES) + +#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT) +#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT) + +#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT) +#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT) + + +#define PyBUF_READ 0x100 +#define PyBUF_WRITE 0x200 +/* End buffer interface */ + + +typedef struct { + /* Number implementations must check *both* + arguments for proper type and implement the necessary conversions + in the slot functions themselves. */ + + binaryfunc nb_add; + binaryfunc nb_subtract; + binaryfunc nb_multiply; + binaryfunc nb_remainder; + binaryfunc nb_divmod; + ternaryfunc nb_power; + unaryfunc nb_negative; + unaryfunc nb_positive; + unaryfunc nb_absolute; + inquiry nb_bool; + unaryfunc nb_invert; + binaryfunc nb_lshift; + binaryfunc nb_rshift; + binaryfunc nb_and; + binaryfunc nb_xor; + binaryfunc nb_or; + unaryfunc nb_int; + void *nb_reserved; /* the slot formerly known as nb_long */ + unaryfunc nb_float; + + binaryfunc nb_inplace_add; + binaryfunc nb_inplace_subtract; + binaryfunc nb_inplace_multiply; + binaryfunc nb_inplace_remainder; + ternaryfunc nb_inplace_power; + binaryfunc nb_inplace_lshift; + binaryfunc nb_inplace_rshift; + binaryfunc nb_inplace_and; + binaryfunc nb_inplace_xor; + binaryfunc nb_inplace_or; + + binaryfunc nb_floor_divide; + binaryfunc nb_true_divide; + binaryfunc nb_inplace_floor_divide; + binaryfunc nb_inplace_true_divide; + + unaryfunc nb_index; + + binaryfunc nb_matrix_multiply; + binaryfunc nb_inplace_matrix_multiply; +} PyNumberMethods; + +typedef struct { + lenfunc sq_length; + binaryfunc sq_concat; + ssizeargfunc sq_repeat; + ssizeargfunc sq_item; + void *was_sq_slice; + ssizeobjargproc sq_ass_item; + void *was_sq_ass_slice; + objobjproc sq_contains; + + binaryfunc sq_inplace_concat; + ssizeargfunc sq_inplace_repeat; +} PySequenceMethods; + +typedef struct { + lenfunc mp_length; + binaryfunc mp_subscript; + objobjargproc mp_ass_subscript; +} PyMappingMethods; + +typedef PySendResult (*sendfunc)(PyObject *iter, PyObject *value, PyObject **result); + +typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + sendfunc am_send; +} PyAsyncMethods; + +typedef struct { + getbufferproc bf_getbuffer; + releasebufferproc bf_releasebuffer; +} PyBufferProcs; + +/* Allow printfunc in the tp_vectorcall_offset slot for + * backwards-compatibility */ +typedef Py_ssize_t printfunc; + +// If this structure is modified, Doc/includes/typestruct.h should be updated +// as well. +struct _typeobject { + PyObject_VAR_HEAD + const char *tp_name; /* For printing, in format "." */ + Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */ + + /* Methods to implement standard operations */ + + destructor tp_dealloc; + Py_ssize_t tp_vectorcall_offset; + getattrfunc tp_getattr; + setattrfunc tp_setattr; + PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2) + or tp_reserved (Python 3) */ + reprfunc tp_repr; + + /* Method suites for standard classes */ + + PyNumberMethods *tp_as_number; + PySequenceMethods *tp_as_sequence; + PyMappingMethods *tp_as_mapping; + + /* More standard operations (here for binary compatibility) */ + + hashfunc tp_hash; + ternaryfunc tp_call; + reprfunc tp_str; + getattrofunc tp_getattro; + setattrofunc tp_setattro; + + /* Functions to access object as input/output buffer */ + PyBufferProcs *tp_as_buffer; + + /* Flags to define presence of optional/expanded features */ + unsigned long tp_flags; + + const char *tp_doc; /* Documentation string */ + + /* Assigned meaning in release 2.0 */ + /* call function for all accessible objects */ + traverseproc tp_traverse; + + /* delete references to contained objects */ + inquiry tp_clear; + + /* Assigned meaning in release 2.1 */ + /* rich comparisons */ + richcmpfunc tp_richcompare; + + /* weak reference enabler */ + Py_ssize_t tp_weaklistoffset; + + /* Iterators */ + getiterfunc tp_iter; + iternextfunc tp_iternext; + + /* Attribute descriptor and subclassing stuff */ + struct PyMethodDef *tp_methods; + struct PyMemberDef *tp_members; + struct PyGetSetDef *tp_getset; + // Strong reference on a heap type, borrowed reference on a static type + struct _typeobject *tp_base; + PyObject *tp_dict; + descrgetfunc tp_descr_get; + descrsetfunc tp_descr_set; + Py_ssize_t tp_dictoffset; + initproc tp_init; + allocfunc tp_alloc; + newfunc tp_new; + freefunc tp_free; /* Low-level free-memory routine */ + inquiry tp_is_gc; /* For PyObject_IS_GC */ + PyObject *tp_bases; + PyObject *tp_mro; /* method resolution order */ + PyObject *tp_cache; + PyObject *tp_subclasses; + PyObject *tp_weaklist; + destructor tp_del; + + /* Type attribute cache version tag. Added in version 2.6 */ + unsigned int tp_version_tag; + + destructor tp_finalize; + vectorcallfunc tp_vectorcall; +}; + +/* The *real* layout of a type object when allocated on the heap */ +typedef struct _heaptypeobject { + /* Note: there's a dependency on the order of these members + in slotptr() in typeobject.c . */ + PyTypeObject ht_type; + PyAsyncMethods as_async; + PyNumberMethods as_number; + PyMappingMethods as_mapping; + PySequenceMethods as_sequence; /* as_sequence comes after as_mapping, + so that the mapping wins when both + the mapping and the sequence define + a given operator (e.g. __getitem__). + see add_operators() in typeobject.c . */ + PyBufferProcs as_buffer; + PyObject *ht_name, *ht_slots, *ht_qualname; + struct _dictkeysobject *ht_cached_keys; + PyObject *ht_module; + /* here are optional user slots, followed by the members. */ +} PyHeapTypeObject; + +/* access macro to the members which are floating "behind" the object */ +#define PyHeapType_GET_MEMBERS(etype) \ + ((PyMemberDef *)(((char *)etype) + Py_TYPE(etype)->tp_basicsize)) + +PyAPI_FUNC(const char *) _PyType_Name(PyTypeObject *); +PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *); +PyAPI_FUNC(PyObject *) _PyType_LookupId(PyTypeObject *, _Py_Identifier *); +PyAPI_FUNC(PyObject *) _PyObject_LookupSpecial(PyObject *, _Py_Identifier *); +PyAPI_FUNC(PyTypeObject *) _PyType_CalculateMetaclass(PyTypeObject *, PyObject *); +PyAPI_FUNC(PyObject *) _PyType_GetDocFromInternalDoc(const char *, const char *); +PyAPI_FUNC(PyObject *) _PyType_GetTextSignatureFromInternalDoc(const char *, const char *); +struct PyModuleDef; +PyAPI_FUNC(PyObject *) _PyType_GetModuleByDef(PyTypeObject *, struct PyModuleDef *); + +struct _Py_Identifier; +PyAPI_FUNC(int) PyObject_Print(PyObject *, FILE *, int); +PyAPI_FUNC(void) _Py_BreakPoint(void); +PyAPI_FUNC(void) _PyObject_Dump(PyObject *); +PyAPI_FUNC(int) _PyObject_IsFreed(PyObject *); + +PyAPI_FUNC(int) _PyObject_IsAbstract(PyObject *); +PyAPI_FUNC(PyObject *) _PyObject_GetAttrId(PyObject *, struct _Py_Identifier *); +PyAPI_FUNC(int) _PyObject_SetAttrId(PyObject *, struct _Py_Identifier *, PyObject *); +/* Replacements of PyObject_GetAttr() and _PyObject_GetAttrId() which + don't raise AttributeError. + + Return 1 and set *result != NULL if an attribute is found. + Return 0 and set *result == NULL if an attribute is not found; + an AttributeError is silenced. + Return -1 and set *result == NULL if an error other than AttributeError + is raised. +*/ +PyAPI_FUNC(int) _PyObject_LookupAttr(PyObject *, PyObject *, PyObject **); +PyAPI_FUNC(int) _PyObject_LookupAttrId(PyObject *, struct _Py_Identifier *, PyObject **); + +PyAPI_FUNC(int) _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); + +PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *); +PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *); +PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *); +PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *); + +/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes + dict as the last parameter. */ +PyAPI_FUNC(PyObject *) +_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *, int); +PyAPI_FUNC(int) +_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *, + PyObject *, PyObject *); + +PyAPI_FUNC(PyObject *) _PyObject_FunctionStr(PyObject *); + +/* Safely decref `op` and set `op` to `op2`. + * + * As in case of Py_CLEAR "the obvious" code can be deadly: + * + * Py_DECREF(op); + * op = op2; + * + * The safe way is: + * + * Py_SETREF(op, op2); + * + * That arranges to set `op` to `op2` _before_ decref'ing, so that any code + * triggered as a side-effect of `op` getting torn down no longer believes + * `op` points to a valid object. + * + * Py_XSETREF is a variant of Py_SETREF that uses Py_XDECREF instead of + * Py_DECREF. + */ + +#define Py_SETREF(op, op2) \ + do { \ + PyObject *_py_tmp = _PyObject_CAST(op); \ + (op) = (op2); \ + Py_DECREF(_py_tmp); \ + } while (0) + +#define Py_XSETREF(op, op2) \ + do { \ + PyObject *_py_tmp = _PyObject_CAST(op); \ + (op) = (op2); \ + Py_XDECREF(_py_tmp); \ + } while (0) + + +PyAPI_DATA(PyTypeObject) _PyNone_Type; +PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type; + +/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE. + * Defined in object.c. + */ +PyAPI_DATA(int) _Py_SwappedOp[]; + +PyAPI_FUNC(void) +_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks, + size_t sizeof_block); +PyAPI_FUNC(void) +_PyObject_DebugTypeStats(FILE *out); + +/* Define a pair of assertion macros: + _PyObject_ASSERT_FROM(), _PyObject_ASSERT_WITH_MSG() and _PyObject_ASSERT(). + + These work like the regular C assert(), in that they will abort the + process with a message on stderr if the given condition fails to hold, + but compile away to nothing if NDEBUG is defined. + + However, before aborting, Python will also try to call _PyObject_Dump() on + the given object. This may be of use when investigating bugs in which a + particular object is corrupt (e.g. buggy a tp_visit method in an extension + module breaking the garbage collector), to help locate the broken objects. + + The WITH_MSG variant allows you to supply an additional message that Python + will attempt to print to stderr, after the object dump. */ +#ifdef NDEBUG + /* No debugging: compile away the assertions: */ +# define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \ + ((void)0) +#else + /* With debugging: generate checks: */ +# define _PyObject_ASSERT_FROM(obj, expr, msg, filename, lineno, func) \ + ((expr) \ + ? (void)(0) \ + : _PyObject_AssertFailed((obj), Py_STRINGIFY(expr), \ + (msg), (filename), (lineno), (func))) +#endif + +#define _PyObject_ASSERT_WITH_MSG(obj, expr, msg) \ + _PyObject_ASSERT_FROM(obj, expr, msg, __FILE__, __LINE__, __func__) +#define _PyObject_ASSERT(obj, expr) \ + _PyObject_ASSERT_WITH_MSG(obj, expr, NULL) + +#define _PyObject_ASSERT_FAILED_MSG(obj, msg) \ + _PyObject_AssertFailed((obj), NULL, (msg), __FILE__, __LINE__, __func__) + +/* Declare and define _PyObject_AssertFailed() even when NDEBUG is defined, + to avoid causing compiler/linker errors when building extensions without + NDEBUG against a Python built with NDEBUG defined. + + msg, expr and function can be NULL. */ +PyAPI_FUNC(void) _Py_NO_RETURN _PyObject_AssertFailed( + PyObject *obj, + const char *expr, + const char *msg, + const char *file, + int line, + const char *function); + +/* Check if an object is consistent. For example, ensure that the reference + counter is greater than or equal to 1, and ensure that ob_type is not NULL. + + Call _PyObject_AssertFailed() if the object is inconsistent. + + If check_content is zero, only check header fields: reduce the overhead. + + The function always return 1. The return value is just here to be able to + write: + + assert(_PyObject_CheckConsistency(obj, 1)); */ +PyAPI_FUNC(int) _PyObject_CheckConsistency( + PyObject *op, + int check_content); + + +/* Trashcan mechanism, thanks to Christian Tismer. + +When deallocating a container object, it's possible to trigger an unbounded +chain of deallocations, as each Py_DECREF in turn drops the refcount on "the +next" object in the chain to 0. This can easily lead to stack overflows, +especially in threads (which typically have less stack space to work with). + +A container object can avoid this by bracketing the body of its tp_dealloc +function with a pair of macros: + +static void +mytype_dealloc(mytype *p) +{ + ... declarations go here ... + + PyObject_GC_UnTrack(p); // must untrack first + Py_TRASHCAN_BEGIN(p, mytype_dealloc) + ... The body of the deallocator goes here, including all calls ... + ... to Py_DECREF on contained objects. ... + Py_TRASHCAN_END // there should be no code after this +} + +CAUTION: Never return from the middle of the body! If the body needs to +"get out early", put a label immediately before the Py_TRASHCAN_END +call, and goto it. Else the call-depth counter (see below) will stay +above 0 forever, and the trashcan will never get emptied. + +How it works: The BEGIN macro increments a call-depth counter. So long +as this counter is small, the body of the deallocator is run directly without +further ado. But if the counter gets large, it instead adds p to a list of +objects to be deallocated later, skips the body of the deallocator, and +resumes execution after the END macro. The tp_dealloc routine then returns +without deallocating anything (and so unbounded call-stack depth is avoided). + +When the call stack finishes unwinding again, code generated by the END macro +notices this, and calls another routine to deallocate all the objects that +may have been added to the list of deferred deallocations. In effect, a +chain of N deallocations is broken into (N-1)/(PyTrash_UNWIND_LEVEL-1) pieces, +with the call stack never exceeding a depth of PyTrash_UNWIND_LEVEL. + +Since the tp_dealloc of a subclass typically calls the tp_dealloc of the base +class, we need to ensure that the trashcan is only triggered on the tp_dealloc +of the actual class being deallocated. Otherwise we might end up with a +partially-deallocated object. To check this, the tp_dealloc function must be +passed as second argument to Py_TRASHCAN_BEGIN(). +*/ + +/* This is the old private API, invoked by the macros before 3.2.4. + Kept for binary compatibility of extensions using the stable ABI. */ +PyAPI_FUNC(void) _PyTrash_deposit_object(PyObject*); +PyAPI_FUNC(void) _PyTrash_destroy_chain(void); + +/* This is the old private API, invoked by the macros before 3.9. + Kept for binary compatibility of extensions using the stable ABI. */ +PyAPI_FUNC(void) _PyTrash_thread_deposit_object(PyObject*); +PyAPI_FUNC(void) _PyTrash_thread_destroy_chain(void); + +/* Forward declarations for PyThreadState */ +struct _ts; + +/* Python 3.9 private API, invoked by the macros below. */ +PyAPI_FUNC(int) _PyTrash_begin(struct _ts *tstate, PyObject *op); +PyAPI_FUNC(void) _PyTrash_end(struct _ts *tstate); +/* Python 3.10 private API, invoked by the Py_TRASHCAN_BEGIN(). */ +PyAPI_FUNC(int) _PyTrash_cond(PyObject *op, destructor dealloc); + +#define PyTrash_UNWIND_LEVEL 50 + +#define Py_TRASHCAN_BEGIN_CONDITION(op, cond) \ + do { \ + PyThreadState *_tstate = NULL; \ + /* If "cond" is false, then _tstate remains NULL and the deallocator \ + * is run normally without involving the trashcan */ \ + if (cond) { \ + _tstate = PyThreadState_Get(); \ + if (_PyTrash_begin(_tstate, _PyObject_CAST(op))) { \ + break; \ + } \ + } + /* The body of the deallocator is here. */ +#define Py_TRASHCAN_END \ + if (_tstate) { \ + _PyTrash_end(_tstate); \ + } \ + } while (0); + +#define Py_TRASHCAN_BEGIN(op, dealloc) \ + Py_TRASHCAN_BEGIN_CONDITION(op, \ + _PyTrash_cond(_PyObject_CAST(op), (destructor)dealloc)) + +/* For backwards compatibility, these macros enable the trashcan + * unconditionally */ +#define Py_TRASHCAN_SAFE_BEGIN(op) Py_TRASHCAN_BEGIN_CONDITION(op, 1) +#define Py_TRASHCAN_SAFE_END(op) Py_TRASHCAN_END diff --git a/include/cpython/objimpl.h b/include/cpython/objimpl.h new file mode 100644 index 00000000..d83700e2 --- /dev/null +++ b/include/cpython/objimpl.h @@ -0,0 +1,100 @@ +#ifndef Py_CPYTHON_OBJIMPL_H +# error "this header file must not be included directly" +#endif + +#define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize ) + +/* _PyObject_VAR_SIZE returns the number of bytes (as size_t) allocated for a + vrbl-size object with nitems items, exclusive of gc overhead (if any). The + value is rounded up to the closest multiple of sizeof(void *), in order to + ensure that pointer fields at the end of the object are correctly aligned + for the platform (this is of special importance for subclasses of, e.g., + str or int, so that pointers can be stored after the embedded data). + + Note that there's no memory wastage in doing this, as malloc has to + return (at worst) pointer-aligned memory anyway. +*/ +#if ((SIZEOF_VOID_P - 1) & SIZEOF_VOID_P) != 0 +# error "_PyObject_VAR_SIZE requires SIZEOF_VOID_P be a power of 2" +#endif + +#define _PyObject_VAR_SIZE(typeobj, nitems) \ + _Py_SIZE_ROUND_UP((typeobj)->tp_basicsize + \ + (nitems)*(typeobj)->tp_itemsize, \ + SIZEOF_VOID_P) + + +/* This example code implements an object constructor with a custom + allocator, where PyObject_New is inlined, and shows the important + distinction between two steps (at least): + 1) the actual allocation of the object storage; + 2) the initialization of the Python specific fields + in this storage with PyObject_{Init, InitVar}. + + PyObject * + YourObject_New(...) + { + PyObject *op; + + op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct)); + if (op == NULL) { + return PyErr_NoMemory(); + } + + PyObject_Init(op, &YourTypeStruct); + + op->ob_field = value; + ... + return op; + } + + Note that in C++, the use of the new operator usually implies that + the 1st step is performed automatically for you, so in a C++ class + constructor you would start directly with PyObject_Init/InitVar. */ + +/* This function returns the number of allocated memory blocks, regardless of size */ +PyAPI_FUNC(Py_ssize_t) _Py_GetAllocatedBlocks(void); + +/* Macros */ +#ifdef WITH_PYMALLOC +PyAPI_FUNC(int) _PyObject_DebugMallocStats(FILE *out); +#endif + + +typedef struct { + /* user context passed as the first argument to the 2 functions */ + void *ctx; + + /* allocate an arena of size bytes */ + void* (*alloc) (void *ctx, size_t size); + + /* free an arena */ + void (*free) (void *ctx, void *ptr, size_t size); +} PyObjectArenaAllocator; + +/* Get the arena allocator. */ +PyAPI_FUNC(void) PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator); + +/* Set the arena allocator. */ +PyAPI_FUNC(void) PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator); + + +/* Test if an object implements the garbage collector protocol */ +PyAPI_FUNC(int) PyObject_IS_GC(PyObject *obj); + + +/* Code built with Py_BUILD_CORE must include pycore_gc.h instead which + defines a different _PyGC_FINALIZED() macro. */ +#ifndef Py_BUILD_CORE + // Kept for backward compatibility with Python 3.8 +# define _PyGC_FINALIZED(o) PyObject_GC_IsFinalized(o) +#endif + +PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t size); +PyAPI_FUNC(PyObject *) _PyObject_GC_Calloc(size_t size); + + +/* Test if a type supports weak references */ +#define PyType_SUPPORTS_WEAKREFS(t) ((t)->tp_weaklistoffset > 0) + +PyAPI_FUNC(PyObject **) PyObject_GET_WEAKREFS_LISTPTR(PyObject *op); diff --git a/include/odictobject.h b/include/cpython/odictobject.h similarity index 71% rename from include/odictobject.h rename to include/cpython/odictobject.h index 8378dc4b..e0704130 100644 --- a/include/odictobject.h +++ b/include/cpython/odictobject.h @@ -19,7 +19,7 @@ PyAPI_DATA(PyTypeObject) PyODictItems_Type; PyAPI_DATA(PyTypeObject) PyODictValues_Type; #define PyODict_Check(op) PyObject_TypeCheck(op, &PyODict_Type) -#define PyODict_CheckExact(op) (Py_TYPE(op) == &PyODict_Type) +#define PyODict_CheckExact(op) Py_IS_TYPE(op, &PyODict_Type) #define PyODict_SIZE(op) PyDict_GET_SIZE((op)) PyAPI_FUNC(PyObject *) PyODict_New(void); @@ -27,13 +27,13 @@ PyAPI_FUNC(int) PyODict_SetItem(PyObject *od, PyObject *key, PyObject *item); PyAPI_FUNC(int) PyODict_DelItem(PyObject *od, PyObject *key); /* wrappers around PyDict* functions */ -#define PyODict_GetItem(od, key) PyDict_GetItem((PyObject *)od, key) +#define PyODict_GetItem(od, key) PyDict_GetItem(_PyObject_CAST(od), key) #define PyODict_GetItemWithError(od, key) \ - PyDict_GetItemWithError((PyObject *)od, key) -#define PyODict_Contains(od, key) PyDict_Contains((PyObject *)od, key) -#define PyODict_Size(od) PyDict_Size((PyObject *)od) + PyDict_GetItemWithError(_PyObject_CAST(od), key) +#define PyODict_Contains(od, key) PyDict_Contains(_PyObject_CAST(od), key) +#define PyODict_Size(od) PyDict_Size(_PyObject_CAST(od)) #define PyODict_GetItemString(od, key) \ - PyDict_GetItemString((PyObject *)od, key) + PyDict_GetItemString(_PyObject_CAST(od), key) #endif diff --git a/include/cpython/picklebufobject.h b/include/cpython/picklebufobject.h new file mode 100644 index 00000000..0df2561d --- /dev/null +++ b/include/cpython/picklebufobject.h @@ -0,0 +1,31 @@ +/* PickleBuffer object. This is built-in for ease of use from third-party + * C extensions. + */ + +#ifndef Py_PICKLEBUFOBJECT_H +#define Py_PICKLEBUFOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_LIMITED_API + +PyAPI_DATA(PyTypeObject) PyPickleBuffer_Type; + +#define PyPickleBuffer_Check(op) Py_IS_TYPE(op, &PyPickleBuffer_Type) + +/* Create a PickleBuffer redirecting to the given buffer-enabled object */ +PyAPI_FUNC(PyObject *) PyPickleBuffer_FromObject(PyObject *); +/* Get the PickleBuffer's underlying view to the original object + * (NULL if released) + */ +PyAPI_FUNC(const Py_buffer *) PyPickleBuffer_GetBuffer(PyObject *); +/* Release the PickleBuffer. Returns 0 on success, -1 on error. */ +PyAPI_FUNC(int) PyPickleBuffer_Release(PyObject *); + +#endif /* !Py_LIMITED_API */ + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PICKLEBUFOBJECT_H */ diff --git a/include/pyctype.h b/include/cpython/pyctype.h similarity index 95% rename from include/pyctype.h rename to include/cpython/pyctype.h index 6bce63ee..729d9327 100644 --- a/include/pyctype.h +++ b/include/cpython/pyctype.h @@ -1,6 +1,9 @@ #ifndef Py_LIMITED_API #ifndef PYCTYPE_H #define PYCTYPE_H +#ifdef __cplusplus +extern "C" { +#endif #define PY_CTF_LOWER 0x01 #define PY_CTF_UPPER 0x02 @@ -29,5 +32,8 @@ PyAPI_DATA(const unsigned char) _Py_ctype_toupper[256]; #define Py_TOLOWER(c) (_Py_ctype_tolower[Py_CHARMASK(c)]) #define Py_TOUPPER(c) (_Py_ctype_toupper[Py_CHARMASK(c)]) +#ifdef __cplusplus +} +#endif #endif /* !PYCTYPE_H */ #endif /* !Py_LIMITED_API */ diff --git a/include/pydebug.h b/include/cpython/pydebug.h similarity index 90% rename from include/pydebug.h rename to include/cpython/pydebug.h index bd4aafe3..78bcb118 100644 --- a/include/pydebug.h +++ b/include/cpython/pydebug.h @@ -5,8 +5,6 @@ extern "C" { #endif -/* These global variable are defined in pylifecycle.c */ -/* XXX (ncoghlan): move these declarations to pylifecycle.h? */ PyAPI_DATA(int) Py_DebugFlag; PyAPI_DATA(int) Py_VerboseFlag; PyAPI_DATA(int) Py_QuietFlag; diff --git a/include/cpython/pyerrors.h b/include/cpython/pyerrors.h new file mode 100644 index 00000000..3f952456 --- /dev/null +++ b/include/cpython/pyerrors.h @@ -0,0 +1,214 @@ +#ifndef Py_CPYTHON_ERRORS_H +# error "this header file must not be included directly" +#endif + +/* Error objects */ + +/* PyException_HEAD defines the initial segment of every exception class. */ +#define PyException_HEAD PyObject_HEAD PyObject *dict;\ + PyObject *args; PyObject *traceback;\ + PyObject *context; PyObject *cause;\ + char suppress_context; + +typedef struct { + PyException_HEAD +} PyBaseExceptionObject; + +typedef struct { + PyException_HEAD + PyObject *msg; + PyObject *filename; + PyObject *lineno; + PyObject *offset; + PyObject *end_lineno; + PyObject *end_offset; + PyObject *text; + PyObject *print_file_and_line; +} PySyntaxErrorObject; + +typedef struct { + PyException_HEAD + PyObject *msg; + PyObject *name; + PyObject *path; +} PyImportErrorObject; + +typedef struct { + PyException_HEAD + PyObject *encoding; + PyObject *object; + Py_ssize_t start; + Py_ssize_t end; + PyObject *reason; +} PyUnicodeErrorObject; + +typedef struct { + PyException_HEAD + PyObject *code; +} PySystemExitObject; + +typedef struct { + PyException_HEAD + PyObject *myerrno; + PyObject *strerror; + PyObject *filename; + PyObject *filename2; +#ifdef MS_WINDOWS + PyObject *winerror; +#endif + Py_ssize_t written; /* only for BlockingIOError, -1 otherwise */ +} PyOSErrorObject; + +typedef struct { + PyException_HEAD + PyObject *value; +} PyStopIterationObject; + +typedef struct { + PyException_HEAD + PyObject *name; +} PyNameErrorObject; + +typedef struct { + PyException_HEAD + PyObject *obj; + PyObject *name; +} PyAttributeErrorObject; + +/* Compatibility typedefs */ +typedef PyOSErrorObject PyEnvironmentErrorObject; +#ifdef MS_WINDOWS +typedef PyOSErrorObject PyWindowsErrorObject; +#endif + +/* Error handling definitions */ + +PyAPI_FUNC(void) _PyErr_SetKeyError(PyObject *); +PyAPI_FUNC(_PyErr_StackItem*) _PyErr_GetTopmostException(PyThreadState *tstate); +PyAPI_FUNC(void) _PyErr_GetExcInfo(PyThreadState *, PyObject **, PyObject **, PyObject **); + +/* Context manipulation (PEP 3134) */ + +PyAPI_FUNC(void) _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *); + +/* Convenience functions */ + +#ifdef MS_WINDOWS +Py_DEPRECATED(3.3) +PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename( + PyObject *, const Py_UNICODE *); +#endif /* MS_WINDOWS */ + +/* Like PyErr_Format(), but saves current exception as __context__ and + __cause__. + */ +PyAPI_FUNC(PyObject *) _PyErr_FormatFromCause( + PyObject *exception, + const char *format, /* ASCII-encoded string */ + ... + ); + +#ifdef MS_WINDOWS +/* XXX redeclare to use WSTRING */ +Py_DEPRECATED(3.3) +PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename( + int, const Py_UNICODE *); +Py_DEPRECATED(3.3) +PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename( + PyObject *,int, const Py_UNICODE *); +#endif + +/* In exceptions.c */ + +/* Helper that attempts to replace the current exception with one of the + * same type but with a prefix added to the exception text. The resulting + * exception description looks like: + * + * prefix (exc_type: original_exc_str) + * + * Only some exceptions can be safely replaced. If the function determines + * it isn't safe to perform the replacement, it will leave the original + * unmodified exception in place. + * + * Returns a borrowed reference to the new exception (if any), NULL if the + * existing exception was left in place. + */ +PyAPI_FUNC(PyObject *) _PyErr_TrySetFromCause( + const char *prefix_format, /* ASCII-encoded string */ + ... + ); + +/* In signalmodule.c */ + +int PySignal_SetWakeupFd(int fd); +PyAPI_FUNC(int) _PyErr_CheckSignals(void); + +/* Support for adding program text to SyntaxErrors */ + +PyAPI_FUNC(void) PyErr_SyntaxLocationObject( + PyObject *filename, + int lineno, + int col_offset); + +PyAPI_FUNC(void) PyErr_RangedSyntaxLocationObject( + PyObject *filename, + int lineno, + int col_offset, + int end_lineno, + int end_col_offset); + +PyAPI_FUNC(PyObject *) PyErr_ProgramTextObject( + PyObject *filename, + int lineno); + +/* Create a UnicodeEncodeError object. + * + * TODO: This API will be removed in Python 3.11. + */ +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create( + const char *encoding, /* UTF-8 encoded string */ + const Py_UNICODE *object, + Py_ssize_t length, + Py_ssize_t start, + Py_ssize_t end, + const char *reason /* UTF-8 encoded string */ + ); + +/* Create a UnicodeTranslateError object. + * + * TODO: This API will be removed in Python 3.11. + */ +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create( + const Py_UNICODE *object, + Py_ssize_t length, + Py_ssize_t start, + Py_ssize_t end, + const char *reason /* UTF-8 encoded string */ + ); + +PyAPI_FUNC(PyObject *) _PyErr_ProgramDecodedTextObject( + PyObject *filename, + int lineno, + const char* encoding); + +PyAPI_FUNC(PyObject *) _PyUnicodeTranslateError_Create( + PyObject *object, + Py_ssize_t start, + Py_ssize_t end, + const char *reason /* UTF-8 encoded string */ + ); + +PyAPI_FUNC(void) _PyErr_WriteUnraisableMsg( + const char *err_msg, + PyObject *obj); + +PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFunc( + const char *func, + const char *message); + +PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalErrorFormat( + const char *func, + const char *format, + ...); + +#define Py_FatalError(message) _Py_FatalErrorFunc(__func__, message) diff --git a/include/pyfpe.h b/include/cpython/pyfpe.h similarity index 76% rename from include/pyfpe.h rename to include/cpython/pyfpe.h index 5a99e397..cc2def63 100644 --- a/include/pyfpe.h +++ b/include/cpython/pyfpe.h @@ -1,5 +1,7 @@ #ifndef Py_PYFPE_H #define Py_PYFPE_H +/* Header excluded from the stable API */ +#ifndef Py_LIMITED_API /* These macros used to do something when Python was built with --with-fpectl, * but support for that was dropped in 3.7. We continue to define them though, @@ -9,4 +11,5 @@ #define PyFPE_START_PROTECT(err_string, leave_stmt) #define PyFPE_END_PROTECT(v) +#endif /* !defined(Py_LIMITED_API) */ #endif /* !Py_PYFPE_H */ diff --git a/include/cpython/pylifecycle.h b/include/cpython/pylifecycle.h new file mode 100644 index 00000000..5faeb353 --- /dev/null +++ b/include/cpython/pylifecycle.h @@ -0,0 +1,64 @@ +#ifndef Py_CPYTHON_PYLIFECYCLE_H +# error "this header file must not be included directly" +#endif + +/* Py_FrozenMain is kept out of the Limited API until documented and present + in all builds of Python */ +PyAPI_FUNC(int) Py_FrozenMain(int argc, char **argv); + +/* Only used by applications that embed the interpreter and need to + * override the standard encoding determination mechanism + */ +PyAPI_FUNC(int) Py_SetStandardStreamEncoding(const char *encoding, + const char *errors); + +/* PEP 432 Multi-phase initialization API (Private while provisional!) */ + +PyAPI_FUNC(PyStatus) Py_PreInitialize( + const PyPreConfig *src_config); +PyAPI_FUNC(PyStatus) Py_PreInitializeFromBytesArgs( + const PyPreConfig *src_config, + Py_ssize_t argc, + char **argv); +PyAPI_FUNC(PyStatus) Py_PreInitializeFromArgs( + const PyPreConfig *src_config, + Py_ssize_t argc, + wchar_t **argv); + +PyAPI_FUNC(int) _Py_IsCoreInitialized(void); + + +/* Initialization and finalization */ + +PyAPI_FUNC(PyStatus) Py_InitializeFromConfig( + const PyConfig *config); +PyAPI_FUNC(PyStatus) _Py_InitializeMain(void); + +PyAPI_FUNC(int) Py_RunMain(void); + + +PyAPI_FUNC(void) _Py_NO_RETURN Py_ExitStatusException(PyStatus err); + +/* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. */ +PyAPI_FUNC(void) _Py_RestoreSignals(void); + +PyAPI_FUNC(int) Py_FdIsInteractive(FILE *, const char *); +PyAPI_FUNC(int) _Py_FdIsInteractive(FILE *fp, PyObject *filename); + +PyAPI_FUNC(void) _Py_SetProgramFullPath(const wchar_t *); + +PyAPI_FUNC(const char *) _Py_gitidentifier(void); +PyAPI_FUNC(const char *) _Py_gitversion(void); + +PyAPI_FUNC(int) _Py_IsFinalizing(void); + +/* Random */ +PyAPI_FUNC(int) _PyOS_URandom(void *buffer, Py_ssize_t size); +PyAPI_FUNC(int) _PyOS_URandomNonblock(void *buffer, Py_ssize_t size); + +/* Legacy locale support */ +PyAPI_FUNC(int) _Py_CoerceLegacyLocale(int warn); +PyAPI_FUNC(int) _Py_LegacyLocaleDetected(int warn); +PyAPI_FUNC(char *) _Py_SetLocaleFromEnv(int category); + +PyAPI_FUNC(PyThreadState *) _Py_NewInterpreter(int isolated_subinterpreter); diff --git a/include/cpython/pymem.h b/include/cpython/pymem.h new file mode 100644 index 00000000..d1054d76 --- /dev/null +++ b/include/cpython/pymem.h @@ -0,0 +1,98 @@ +#ifndef Py_CPYTHON_PYMEM_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(void *) PyMem_RawMalloc(size_t size); +PyAPI_FUNC(void *) PyMem_RawCalloc(size_t nelem, size_t elsize); +PyAPI_FUNC(void *) PyMem_RawRealloc(void *ptr, size_t new_size); +PyAPI_FUNC(void) PyMem_RawFree(void *ptr); + +/* Try to get the allocators name set by _PyMem_SetupAllocators(). */ +PyAPI_FUNC(const char*) _PyMem_GetCurrentAllocatorName(void); + +/* strdup() using PyMem_RawMalloc() */ +PyAPI_FUNC(char *) _PyMem_RawStrdup(const char *str); + +/* strdup() using PyMem_Malloc() */ +PyAPI_FUNC(char *) _PyMem_Strdup(const char *str); + +/* wcsdup() using PyMem_RawMalloc() */ +PyAPI_FUNC(wchar_t*) _PyMem_RawWcsdup(const wchar_t *str); + + +typedef enum { + /* PyMem_RawMalloc(), PyMem_RawRealloc() and PyMem_RawFree() */ + PYMEM_DOMAIN_RAW, + + /* PyMem_Malloc(), PyMem_Realloc() and PyMem_Free() */ + PYMEM_DOMAIN_MEM, + + /* PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() */ + PYMEM_DOMAIN_OBJ +} PyMemAllocatorDomain; + +typedef enum { + PYMEM_ALLOCATOR_NOT_SET = 0, + PYMEM_ALLOCATOR_DEFAULT = 1, + PYMEM_ALLOCATOR_DEBUG = 2, + PYMEM_ALLOCATOR_MALLOC = 3, + PYMEM_ALLOCATOR_MALLOC_DEBUG = 4, +#ifdef WITH_PYMALLOC + PYMEM_ALLOCATOR_PYMALLOC = 5, + PYMEM_ALLOCATOR_PYMALLOC_DEBUG = 6, +#endif +} PyMemAllocatorName; + + +typedef struct { + /* user context passed as the first argument to the 4 functions */ + void *ctx; + + /* allocate a memory block */ + void* (*malloc) (void *ctx, size_t size); + + /* allocate a memory block initialized by zeros */ + void* (*calloc) (void *ctx, size_t nelem, size_t elsize); + + /* allocate or resize a memory block */ + void* (*realloc) (void *ctx, void *ptr, size_t new_size); + + /* release a memory block */ + void (*free) (void *ctx, void *ptr); +} PyMemAllocatorEx; + +/* Get the memory block allocator of the specified domain. */ +PyAPI_FUNC(void) PyMem_GetAllocator(PyMemAllocatorDomain domain, + PyMemAllocatorEx *allocator); + +/* Set the memory block allocator of the specified domain. + + The new allocator must return a distinct non-NULL pointer when requesting + zero bytes. + + For the PYMEM_DOMAIN_RAW domain, the allocator must be thread-safe: the GIL + is not held when the allocator is called. + + If the new allocator is not a hook (don't call the previous allocator), the + PyMem_SetupDebugHooks() function must be called to reinstall the debug hooks + on top on the new allocator. */ +PyAPI_FUNC(void) PyMem_SetAllocator(PyMemAllocatorDomain domain, + PyMemAllocatorEx *allocator); + +/* Setup hooks to detect bugs in the following Python memory allocator + functions: + + - PyMem_RawMalloc(), PyMem_RawRealloc(), PyMem_RawFree() + - PyMem_Malloc(), PyMem_Realloc(), PyMem_Free() + - PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() + + Newly allocated memory is filled with the byte 0xCB, freed memory is filled + with the byte 0xDB. Additional checks: + + - detect API violations, ex: PyObject_Free() called on a buffer allocated + by PyMem_Malloc() + - detect write before the start of the buffer (buffer underflow) + - detect write after the end of the buffer (buffer overflow) + + The function does nothing if Python is not compiled is debug mode. */ +PyAPI_FUNC(void) PyMem_SetupDebugHooks(void); diff --git a/include/cpython/pystate.h b/include/cpython/pystate.h new file mode 100644 index 00000000..7c995b93 --- /dev/null +++ b/include/cpython/pystate.h @@ -0,0 +1,305 @@ +#ifndef Py_CPYTHON_PYSTATE_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(int) _PyInterpreterState_RequiresIDRef(PyInterpreterState *); +PyAPI_FUNC(void) _PyInterpreterState_RequireIDRef(PyInterpreterState *, int); + +PyAPI_FUNC(PyObject *) _PyInterpreterState_GetMainModule(PyInterpreterState *); + +/* State unique per thread */ + +/* Py_tracefunc return -1 when raising an exception, or 0 for success. */ +typedef int (*Py_tracefunc)(PyObject *, PyFrameObject *, int, PyObject *); + +/* The following values are used for 'what' for tracefunc functions + * + * To add a new kind of trace event, also update "trace_init" in + * Python/sysmodule.c to define the Python level event name + */ +#define PyTrace_CALL 0 +#define PyTrace_EXCEPTION 1 +#define PyTrace_LINE 2 +#define PyTrace_RETURN 3 +#define PyTrace_C_CALL 4 +#define PyTrace_C_EXCEPTION 5 +#define PyTrace_C_RETURN 6 +#define PyTrace_OPCODE 7 + + +typedef struct _cframe { + /* This struct will be threaded through the C stack + * allowing fast access to per-thread state that needs + * to be accessed quickly by the interpreter, but can + * be modified outside of the interpreter. + * + * WARNING: This makes data on the C stack accessible from + * heap objects. Care must be taken to maintain stack + * discipline and make sure that instances of this struct cannot + * accessed outside of their lifetime. + */ + int use_tracing; + struct _cframe *previous; +} CFrame; + +typedef struct _err_stackitem { + /* This struct represents an entry on the exception stack, which is a + * per-coroutine state. (Coroutine in the computer science sense, + * including the thread and generators). + * This ensures that the exception state is not impacted by "yields" + * from an except handler. + */ + PyObject *exc_type, *exc_value, *exc_traceback; + + struct _err_stackitem *previous_item; + +} _PyErr_StackItem; + + +// The PyThreadState typedef is in Include/pystate.h. +struct _ts { + /* See Python/ceval.c for comments explaining most fields */ + + struct _ts *prev; + struct _ts *next; + PyInterpreterState *interp; + + /* Borrowed reference to the current frame (it can be NULL) */ + PyFrameObject *frame; + int recursion_depth; + int recursion_headroom; /* Allow 50 more calls to handle any errors. */ + int stackcheck_counter; + + /* 'tracing' keeps track of the execution depth when tracing/profiling. + This is to prevent the actual trace/profile code from being recorded in + the trace/profile. */ + int tracing; + + /* Pointer to current CFrame in the C stack frame of the currently, + * or most recently, executing _PyEval_EvalFrameDefault. */ + CFrame *cframe; + + Py_tracefunc c_profilefunc; + Py_tracefunc c_tracefunc; + PyObject *c_profileobj; + PyObject *c_traceobj; + + /* The exception currently being raised */ + PyObject *curexc_type; + PyObject *curexc_value; + PyObject *curexc_traceback; + + /* The exception currently being handled, if no coroutines/generators + * are present. Always last element on the stack referred to be exc_info. + */ + _PyErr_StackItem exc_state; + + /* Pointer to the top of the stack of the exceptions currently + * being handled */ + _PyErr_StackItem *exc_info; + + PyObject *dict; /* Stores per-thread state */ + + int gilstate_counter; + + PyObject *async_exc; /* Asynchronous exception to raise */ + unsigned long thread_id; /* Thread id where this tstate was created */ + + int trash_delete_nesting; + PyObject *trash_delete_later; + + /* Called when a thread state is deleted normally, but not when it + * is destroyed after fork(). + * Pain: to prevent rare but fatal shutdown errors (issue 18808), + * Thread.join() must wait for the join'ed thread's tstate to be unlinked + * from the tstate chain. That happens at the end of a thread's life, + * in pystate.c. + * The obvious way doesn't quite work: create a lock which the tstate + * unlinking code releases, and have Thread.join() wait to acquire that + * lock. The problem is that we _are_ at the end of the thread's life: + * if the thread holds the last reference to the lock, decref'ing the + * lock will delete the lock, and that may trigger arbitrary Python code + * if there's a weakref, with a callback, to the lock. But by this time + * _PyRuntime.gilstate.tstate_current is already NULL, so only the simplest + * of C code can be allowed to run (in particular it must not be possible to + * release the GIL). + * So instead of holding the lock directly, the tstate holds a weakref to + * the lock: that's the value of on_delete_data below. Decref'ing a + * weakref is harmless. + * on_delete points to _threadmodule.c's static release_sentinel() function. + * After the tstate is unlinked, release_sentinel is called with the + * weakref-to-lock (on_delete_data) argument, and release_sentinel releases + * the indirectly held lock. + */ + void (*on_delete)(void *); + void *on_delete_data; + + int coroutine_origin_tracking_depth; + + PyObject *async_gen_firstiter; + PyObject *async_gen_finalizer; + + PyObject *context; + uint64_t context_ver; + + /* Unique thread state id. */ + uint64_t id; + + CFrame root_cframe; + + /* XXX signal handlers should also be here */ + +}; + +// Alias for backward compatibility with Python 3.8 +#define _PyInterpreterState_Get PyInterpreterState_Get + +PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *); + +/* Similar to PyThreadState_Get(), but don't issue a fatal error + * if it is NULL. */ +PyAPI_FUNC(PyThreadState *) _PyThreadState_UncheckedGet(void); + +PyAPI_FUNC(PyObject *) _PyThreadState_GetDict(PyThreadState *tstate); + +/* PyGILState */ + +/* Helper/diagnostic function - return 1 if the current thread + currently holds the GIL, 0 otherwise. + + The function returns 1 if _PyGILState_check_enabled is non-zero. */ +PyAPI_FUNC(int) PyGILState_Check(void); + +/* Get the single PyInterpreterState used by this process' GILState + implementation. + + This function doesn't check for error. Return NULL before _PyGILState_Init() + is called and after _PyGILState_Fini() is called. + + See also _PyInterpreterState_Get() and _PyInterpreterState_GET(). */ +PyAPI_FUNC(PyInterpreterState *) _PyGILState_GetInterpreterStateUnsafe(void); + +/* The implementation of sys._current_frames() Returns a dict mapping + thread id to that thread's current frame. +*/ +PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void); + +/* The implementation of sys._current_exceptions() Returns a dict mapping + thread id to that thread's current exception. +*/ +PyAPI_FUNC(PyObject *) _PyThread_CurrentExceptions(void); + +/* Routines for advanced debuggers, requested by David Beazley. + Don't use unless you know what you are doing! */ +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Main(void); +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void); +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *); +PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *); +PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *); +PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void); + +/* Frame evaluation API */ + +typedef PyObject* (*_PyFrameEvalFunction)(PyThreadState *tstate, PyFrameObject *, int); + +PyAPI_FUNC(_PyFrameEvalFunction) _PyInterpreterState_GetEvalFrameFunc( + PyInterpreterState *interp); +PyAPI_FUNC(void) _PyInterpreterState_SetEvalFrameFunc( + PyInterpreterState *interp, + _PyFrameEvalFunction eval_frame); + +PyAPI_FUNC(const PyConfig*) _PyInterpreterState_GetConfig(PyInterpreterState *interp); + +/* Get a copy of the current interpreter configuration. + + Return 0 on success. Raise an exception and return -1 on error. + + The caller must initialize 'config', using PyConfig_InitPythonConfig() + for example. + + Python must be preinitialized to call this method. + The caller must hold the GIL. */ +PyAPI_FUNC(int) _PyInterpreterState_GetConfigCopy( + struct PyConfig *config); + +/* Set the configuration of the current interpreter. + + This function should be called during or just after the Python + initialization. + + Update the sys module with the new configuration. If the sys module was + modified directly after the Python initialization, these changes are lost. + + Some configuration like faulthandler or warnoptions can be updated in the + configuration, but don't reconfigure Python (don't enable/disable + faulthandler and don't reconfigure warnings filters). + + Return 0 on success. Raise an exception and return -1 on error. + + The configuration should come from _PyInterpreterState_GetConfigCopy(). */ +PyAPI_FUNC(int) _PyInterpreterState_SetConfig( + const struct PyConfig *config); + +// Get the configuration of the current interpreter. +// The caller must hold the GIL. +PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void); + + +/* cross-interpreter data */ + +struct _xid; + +// _PyCrossInterpreterData is similar to Py_buffer as an effectively +// opaque struct that holds data outside the object machinery. This +// is necessary to pass safely between interpreters in the same process. +typedef struct _xid { + // data is the cross-interpreter-safe derivation of a Python object + // (see _PyObject_GetCrossInterpreterData). It will be NULL if the + // new_object func (below) encodes the data. + void *data; + // obj is the Python object from which the data was derived. This + // is non-NULL only if the data remains bound to the object in some + // way, such that the object must be "released" (via a decref) when + // the data is released. In that case the code that sets the field, + // likely a registered "crossinterpdatafunc", is responsible for + // ensuring it owns the reference (i.e. incref). + PyObject *obj; + // interp is the ID of the owning interpreter of the original + // object. It corresponds to the active interpreter when + // _PyObject_GetCrossInterpreterData() was called. This should only + // be set by the cross-interpreter machinery. + // + // We use the ID rather than the PyInterpreterState to avoid issues + // with deleted interpreters. Note that IDs are never re-used, so + // each one will always correspond to a specific interpreter + // (whether still alive or not). + int64_t interp; + // new_object is a function that returns a new object in the current + // interpreter given the data. The resulting object (a new + // reference) will be equivalent to the original object. This field + // is required. + PyObject *(*new_object)(struct _xid *); + // free is called when the data is released. If it is NULL then + // nothing will be done to free the data. For some types this is + // okay (e.g. bytes) and for those types this field should be set + // to NULL. However, for most the data was allocated just for + // cross-interpreter use, so it must be freed when + // _PyCrossInterpreterData_Release is called or the memory will + // leak. In that case, at the very least this field should be set + // to PyMem_RawFree (the default if not explicitly set to NULL). + // The call will happen with the original interpreter activated. + void (*free)(void *); +} _PyCrossInterpreterData; + +PyAPI_FUNC(int) _PyObject_GetCrossInterpreterData(PyObject *, _PyCrossInterpreterData *); +PyAPI_FUNC(PyObject *) _PyCrossInterpreterData_NewObject(_PyCrossInterpreterData *); +PyAPI_FUNC(void) _PyCrossInterpreterData_Release(_PyCrossInterpreterData *); + +PyAPI_FUNC(int) _PyObject_CheckCrossInterpreterData(PyObject *); + +/* cross-interpreter data registry */ + +typedef int (*crossinterpdatafunc)(PyObject *, struct _xid *); + +PyAPI_FUNC(int) _PyCrossInterpreterData_RegisterClass(PyTypeObject *, crossinterpdatafunc); +PyAPI_FUNC(crossinterpdatafunc) _PyCrossInterpreterData_Lookup(PyObject *); diff --git a/include/cpython/pythonrun.h b/include/cpython/pythonrun.h new file mode 100644 index 00000000..2e72d082 --- /dev/null +++ b/include/cpython/pythonrun.h @@ -0,0 +1,121 @@ +#ifndef Py_CPYTHON_PYTHONRUN_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(int) PyRun_SimpleStringFlags(const char *, PyCompilerFlags *); +PyAPI_FUNC(int) _PyRun_SimpleFileObject( + FILE *fp, + PyObject *filename, + int closeit, + PyCompilerFlags *flags); +PyAPI_FUNC(int) PyRun_AnyFileExFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + int closeit, + PyCompilerFlags *flags); +PyAPI_FUNC(int) _PyRun_AnyFileObject( + FILE *fp, + PyObject *filename, + int closeit, + PyCompilerFlags *flags); +PyAPI_FUNC(int) PyRun_SimpleFileExFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + int closeit, + PyCompilerFlags *flags); +PyAPI_FUNC(int) PyRun_InteractiveOneFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + PyCompilerFlags *flags); +PyAPI_FUNC(int) PyRun_InteractiveOneObject( + FILE *fp, + PyObject *filename, + PyCompilerFlags *flags); +PyAPI_FUNC(int) PyRun_InteractiveLoopFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + PyCompilerFlags *flags); +PyAPI_FUNC(int) _PyRun_InteractiveLoopObject( + FILE *fp, + PyObject *filename, + PyCompilerFlags *flags); + + +PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *, + PyObject *, PyCompilerFlags *); + +PyAPI_FUNC(PyObject *) PyRun_FileExFlags( + FILE *fp, + const char *filename, /* decoded from the filesystem encoding */ + int start, + PyObject *globals, + PyObject *locals, + int closeit, + PyCompilerFlags *flags); + + +PyAPI_FUNC(PyObject *) Py_CompileStringExFlags( + const char *str, + const char *filename, /* decoded from the filesystem encoding */ + int start, + PyCompilerFlags *flags, + int optimize); +PyAPI_FUNC(PyObject *) Py_CompileStringObject( + const char *str, + PyObject *filename, int start, + PyCompilerFlags *flags, + int optimize); + +#define Py_CompileString(str, p, s) Py_CompileStringExFlags(str, p, s, NULL, -1) +#define Py_CompileStringFlags(str, p, s, f) Py_CompileStringExFlags(str, p, s, f, -1) + + +PyAPI_FUNC(const char *) _Py_SourceAsString( + PyObject *cmd, + const char *funcname, + const char *what, + PyCompilerFlags *cf, + PyObject **cmd_copy); + + +/* A function flavor is also exported by libpython. It is required when + libpython is accessed directly rather than using header files which defines + macros below. On Windows, for example, PyAPI_FUNC() uses dllexport to + export functions in pythonXX.dll. */ +PyAPI_FUNC(PyObject *) PyRun_String(const char *str, int s, PyObject *g, PyObject *l); +PyAPI_FUNC(int) PyRun_AnyFile(FILE *fp, const char *name); +PyAPI_FUNC(int) PyRun_AnyFileEx(FILE *fp, const char *name, int closeit); +PyAPI_FUNC(int) PyRun_AnyFileFlags(FILE *, const char *, PyCompilerFlags *); +PyAPI_FUNC(int) PyRun_SimpleString(const char *s); +PyAPI_FUNC(int) PyRun_SimpleFile(FILE *f, const char *p); +PyAPI_FUNC(int) PyRun_SimpleFileEx(FILE *f, const char *p, int c); +PyAPI_FUNC(int) PyRun_InteractiveOne(FILE *f, const char *p); +PyAPI_FUNC(int) PyRun_InteractiveLoop(FILE *f, const char *p); +PyAPI_FUNC(PyObject *) PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l); +PyAPI_FUNC(PyObject *) PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c); +PyAPI_FUNC(PyObject *) PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, PyCompilerFlags *flags); + +/* Use macros for a bunch of old variants */ +#define PyRun_String(str, s, g, l) PyRun_StringFlags(str, s, g, l, NULL) +#define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags(fp, name, 0, NULL) +#define PyRun_AnyFileEx(fp, name, closeit) \ + PyRun_AnyFileExFlags(fp, name, closeit, NULL) +#define PyRun_AnyFileFlags(fp, name, flags) \ + PyRun_AnyFileExFlags(fp, name, 0, flags) +#define PyRun_SimpleString(s) PyRun_SimpleStringFlags(s, NULL) +#define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags(f, p, 0, NULL) +#define PyRun_SimpleFileEx(f, p, c) PyRun_SimpleFileExFlags(f, p, c, NULL) +#define PyRun_InteractiveOne(f, p) PyRun_InteractiveOneFlags(f, p, NULL) +#define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags(f, p, NULL) +#define PyRun_File(fp, p, s, g, l) \ + PyRun_FileExFlags(fp, p, s, g, l, 0, NULL) +#define PyRun_FileEx(fp, p, s, g, l, c) \ + PyRun_FileExFlags(fp, p, s, g, l, c, NULL) +#define PyRun_FileFlags(fp, p, s, g, l, flags) \ + PyRun_FileExFlags(fp, p, s, g, l, 0, flags) + + +/* Stuff with no proper home (yet) */ +PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, const char *); +PyAPI_DATA(PyThreadState*) _PyOS_ReadlineTState; +PyAPI_DATA(char) *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *); diff --git a/include/pytime.h b/include/cpython/pytime.h similarity index 89% rename from include/pytime.h rename to include/cpython/pytime.h index bdda1da2..754c7f47 100644 --- a/include/pytime.h +++ b/include/cpython/pytime.h @@ -2,9 +2,6 @@ #ifndef Py_PYTIME_H #define Py_PYTIME_H -#include "pyconfig.h" /* include for defines */ -#include "object.h" - /************************************************************************** Symbols and macros to supply platform-independent interfaces to time related functions and constants @@ -91,13 +88,13 @@ PyAPI_FUNC(_PyTime_t) _PyTime_FromNanoseconds(_PyTime_t ns); PyAPI_FUNC(int) _PyTime_FromNanosecondsObject(_PyTime_t *t, PyObject *obj); -/* Convert a number of seconds (Python float or int) to a timetamp. +/* Convert a number of seconds (Python float or int) to a timestamp. Raise an exception and return -1 on error, return 0 on success. */ PyAPI_FUNC(int) _PyTime_FromSecondsObject(_PyTime_t *t, PyObject *obj, _PyTime_round_t round); -/* Convert a number of milliseconds (Python float or int, 10^-3) to a timetamp. +/* Convert a number of milliseconds (Python float or int, 10^-3) to a timestamp. Raise an exception and return -1 on error, return 0 on success. */ PyAPI_FUNC(int) _PyTime_FromMillisecondsObject(_PyTime_t *t, PyObject *obj, @@ -164,22 +161,6 @@ PyAPI_FUNC(_PyTime_t) _PyTime_MulDiv(_PyTime_t ticks, _PyTime_t mul, _PyTime_t div); -/* Get the current time from the system clock. - - The function cannot fail. _PyTime_Init() ensures that the system clock - works. */ -PyAPI_FUNC(_PyTime_t) _PyTime_GetSystemClock(void); - -/* Get the time of a monotonic clock, i.e. a clock that cannot go backwards. - The clock is not affected by system clock updates. The reference point of - the returned value is undefined, so that only the difference between the - results of consecutive calls is valid. - - The function cannot fail. _PyTime_Init() ensures that a monotonic clock - is available and works. */ -PyAPI_FUNC(_PyTime_t) _PyTime_GetMonotonicClock(void); - - /* Structure used by time.get_clock_info() */ typedef struct { const char *implementation; @@ -189,13 +170,34 @@ typedef struct { } _Py_clock_info_t; /* Get the current time from the system clock. - * Fill clock information if info is not NULL. - * Raise an exception and return -1 on error, return 0 on success. + + If the internal clock fails, silently ignore the error and return 0. + On integer overflow, silently ignore the overflow and truncated the clock to + _PyTime_MIN or _PyTime_MAX. + + Use _PyTime_GetSystemClockWithInfo() to check for failure. */ +PyAPI_FUNC(_PyTime_t) _PyTime_GetSystemClock(void); + +/* Get the current time from the system clock. + * On success, set *t and *info (if not NULL), and return 0. + * On error, raise an exception and return -1. */ PyAPI_FUNC(int) _PyTime_GetSystemClockWithInfo( _PyTime_t *t, _Py_clock_info_t *info); +/* Get the time of a monotonic clock, i.e. a clock that cannot go backwards. + The clock is not affected by system clock updates. The reference point of + the returned value is undefined, so that only the difference between the + results of consecutive calls is valid. + + If the internal clock fails, silently ignore the error and return 0. + On integer overflow, silently ignore the overflow and truncated the clock to + _PyTime_MIN or _PyTime_MAX. + + Use _PyTime_GetMonotonicClockWithInfo() to check for failure. */ +PyAPI_FUNC(_PyTime_t) _PyTime_GetMonotonicClock(void); + /* Get the time of a monotonic clock, i.e. a clock that cannot go backwards. The clock is not affected by system clock updates. The reference point of the returned value is undefined, so that only the difference between the @@ -209,10 +211,6 @@ PyAPI_FUNC(int) _PyTime_GetMonotonicClockWithInfo( _Py_clock_info_t *info); -/* Initialize time. - Return 0 on success, raise an exception and return -1 on error. */ -PyAPI_FUNC(int) _PyTime_Init(void); - /* Converts a timestamp to the Gregorian time, using the local time zone. Return 0 on success, raise an exception and return -1 on error. */ PyAPI_FUNC(int) _PyTime_localtime(time_t t, struct tm *tm); @@ -224,8 +222,11 @@ PyAPI_FUNC(int) _PyTime_gmtime(time_t t, struct tm *tm); /* Get the performance counter: clock with the highest available resolution to measure a short duration. - The function cannot fail. _PyTime_Init() ensures that the system clock - works. */ + If the internal clock fails, silently ignore the error and return 0. + On integer overflow, silently ignore the overflow and truncated the clock to + _PyTime_MIN or _PyTime_MAX. + + Use _PyTime_GetPerfCounterWithInfo() to check for failure. */ PyAPI_FUNC(_PyTime_t) _PyTime_GetPerfCounter(void); /* Get the performance counter: clock with the highest available resolution to diff --git a/include/cpython/sysmodule.h b/include/cpython/sysmodule.h new file mode 100644 index 00000000..fc4c899b --- /dev/null +++ b/include/cpython/sysmodule.h @@ -0,0 +1,16 @@ +#ifndef Py_CPYTHON_SYSMODULE_H +# error "this header file must not be included directly" +#endif + +PyAPI_FUNC(PyObject *) _PySys_GetObjectId(_Py_Identifier *key); +PyAPI_FUNC(int) _PySys_SetObjectId(_Py_Identifier *key, PyObject *); + +PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *); + +typedef int(*Py_AuditHookFunction)(const char *, PyObject *, void *); + +PyAPI_FUNC(int) PySys_Audit( + const char *event, + const char *argFormat, + ...); +PyAPI_FUNC(int) PySys_AddAuditHook(Py_AuditHookFunction, void*); diff --git a/include/cpython/traceback.h b/include/cpython/traceback.h new file mode 100644 index 00000000..aac5b42c --- /dev/null +++ b/include/cpython/traceback.h @@ -0,0 +1,14 @@ +#ifndef Py_CPYTHON_TRACEBACK_H +# error "this header file must not be included directly" +#endif + +typedef struct _traceback { + PyObject_HEAD + struct _traceback *tb_next; + PyFrameObject *tb_frame; + int tb_lasti; + int tb_lineno; +} PyTracebackObject; + +PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, PyObject *, int, int); +PyAPI_FUNC(void) _PyTraceback_Add(const char *, const char *, int); diff --git a/include/cpython/tupleobject.h b/include/cpython/tupleobject.h new file mode 100644 index 00000000..7cada884 --- /dev/null +++ b/include/cpython/tupleobject.h @@ -0,0 +1,28 @@ +#ifndef Py_CPYTHON_TUPLEOBJECT_H +# error "this header file must not be included directly" +#endif + +typedef struct { + PyObject_VAR_HEAD + /* ob_item contains space for 'ob_size' elements. + Items must normally not be NULL, except during construction when + the tuple is not yet visible outside the function that builds it. */ + PyObject *ob_item[1]; +} PyTupleObject; + +PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t); +PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *); + +/* Macros trading safety for speed */ + +/* Cast argument to PyTupleObject* type. */ +#define _PyTuple_CAST(op) (assert(PyTuple_Check(op)), (PyTupleObject *)(op)) + +#define PyTuple_GET_SIZE(op) Py_SIZE(_PyTuple_CAST(op)) + +#define PyTuple_GET_ITEM(op, i) (_PyTuple_CAST(op)->ob_item[i]) + +/* Macro, *only* to be used to fill in brand new tuples */ +#define PyTuple_SET_ITEM(op, i, v) ((void)(_PyTuple_CAST(op)->ob_item[i] = v)) + +PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out); diff --git a/include/cpython/unicodeobject.h b/include/cpython/unicodeobject.h new file mode 100644 index 00000000..0761f01e --- /dev/null +++ b/include/cpython/unicodeobject.h @@ -0,0 +1,1169 @@ +#ifndef Py_CPYTHON_UNICODEOBJECT_H +# error "this header file must not be included directly" +#endif + +/* Py_UNICODE was the native Unicode storage format (code unit) used by + Python and represents a single Unicode element in the Unicode type. + With PEP 393, Py_UNICODE is deprecated and replaced with a + typedef to wchar_t. */ +#define PY_UNICODE_TYPE wchar_t +/* Py_DEPRECATED(3.3) */ typedef wchar_t Py_UNICODE; + +/* --- Internal Unicode Operations ---------------------------------------- */ + +#ifndef USE_UNICODE_WCHAR_CACHE +# define USE_UNICODE_WCHAR_CACHE 1 +#endif /* USE_UNICODE_WCHAR_CACHE */ + +/* Since splitting on whitespace is an important use case, and + whitespace in most situations is solely ASCII whitespace, we + optimize for the common case by using a quick look-up table + _Py_ascii_whitespace (see below) with an inlined check. + + */ +#define Py_UNICODE_ISSPACE(ch) \ + ((Py_UCS4)(ch) < 128U ? _Py_ascii_whitespace[(ch)] : _PyUnicode_IsWhitespace(ch)) + +#define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch) +#define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch) +#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch) +#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch) + +#define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch) +#define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch) +#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch) + +#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch) +#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch) +#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch) +#define Py_UNICODE_ISPRINTABLE(ch) _PyUnicode_IsPrintable(ch) + +#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch) +#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch) +#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch) + +#define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch) + +#define Py_UNICODE_ISALNUM(ch) \ + (Py_UNICODE_ISALPHA(ch) || \ + Py_UNICODE_ISDECIMAL(ch) || \ + Py_UNICODE_ISDIGIT(ch) || \ + Py_UNICODE_ISNUMERIC(ch)) + +Py_DEPRECATED(3.3) static inline void +Py_UNICODE_COPY(Py_UNICODE *target, const Py_UNICODE *source, Py_ssize_t length) { + memcpy(target, source, (size_t)(length) * sizeof(Py_UNICODE)); +} + +Py_DEPRECATED(3.3) static inline void +Py_UNICODE_FILL(Py_UNICODE *target, Py_UNICODE value, Py_ssize_t length) { + Py_ssize_t i; + for (i = 0; i < length; i++) { + target[i] = value; + } +} + +/* macros to work with surrogates */ +#define Py_UNICODE_IS_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDFFF) +#define Py_UNICODE_IS_HIGH_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDBFF) +#define Py_UNICODE_IS_LOW_SURROGATE(ch) (0xDC00 <= (ch) && (ch) <= 0xDFFF) +/* Join two surrogate characters and return a single Py_UCS4 value. */ +#define Py_UNICODE_JOIN_SURROGATES(high, low) \ + (((((Py_UCS4)(high) & 0x03FF) << 10) | \ + ((Py_UCS4)(low) & 0x03FF)) + 0x10000) +/* high surrogate = top 10 bits added to D800 */ +#define Py_UNICODE_HIGH_SURROGATE(ch) (0xD800 - (0x10000 >> 10) + ((ch) >> 10)) +/* low surrogate = bottom 10 bits added to DC00 */ +#define Py_UNICODE_LOW_SURROGATE(ch) (0xDC00 + ((ch) & 0x3FF)) + +/* --- Unicode Type ------------------------------------------------------- */ + +/* ASCII-only strings created through PyUnicode_New use the PyASCIIObject + structure. state.ascii and state.compact are set, and the data + immediately follow the structure. utf8_length and wstr_length can be found + in the length field; the utf8 pointer is equal to the data pointer. */ +typedef struct { + /* There are 4 forms of Unicode strings: + + - compact ascii: + + * structure = PyASCIIObject + * test: PyUnicode_IS_COMPACT_ASCII(op) + * kind = PyUnicode_1BYTE_KIND + * compact = 1 + * ascii = 1 + * ready = 1 + * (length is the length of the utf8 and wstr strings) + * (data starts just after the structure) + * (since ASCII is decoded from UTF-8, the utf8 string are the data) + + - compact: + + * structure = PyCompactUnicodeObject + * test: PyUnicode_IS_COMPACT(op) && !PyUnicode_IS_ASCII(op) + * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or + PyUnicode_4BYTE_KIND + * compact = 1 + * ready = 1 + * ascii = 0 + * utf8 is not shared with data + * utf8_length = 0 if utf8 is NULL + * wstr is shared with data and wstr_length=length + if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2 + or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_t)=4 + * wstr_length = 0 if wstr is NULL + * (data starts just after the structure) + + - legacy string, not ready: + + * structure = PyUnicodeObject + * test: kind == PyUnicode_WCHAR_KIND + * length = 0 (use wstr_length) + * hash = -1 + * kind = PyUnicode_WCHAR_KIND + * compact = 0 + * ascii = 0 + * ready = 0 + * interned = SSTATE_NOT_INTERNED + * wstr is not NULL + * data.any is NULL + * utf8 is NULL + * utf8_length = 0 + + - legacy string, ready: + + * structure = PyUnicodeObject structure + * test: !PyUnicode_IS_COMPACT(op) && kind != PyUnicode_WCHAR_KIND + * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or + PyUnicode_4BYTE_KIND + * compact = 0 + * ready = 1 + * data.any is not NULL + * utf8 is shared and utf8_length = length with data.any if ascii = 1 + * utf8_length = 0 if utf8 is NULL + * wstr is shared with data.any and wstr_length = length + if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2 + or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_4)=4 + * wstr_length = 0 if wstr is NULL + + Compact strings use only one memory block (structure + characters), + whereas legacy strings use one block for the structure and one block + for characters. + + Legacy strings are created by PyUnicode_FromUnicode() and + PyUnicode_FromStringAndSize(NULL, size) functions. They become ready + when PyUnicode_READY() is called. + + See also _PyUnicode_CheckConsistency(). + */ + PyObject_HEAD + Py_ssize_t length; /* Number of code points in the string */ + Py_hash_t hash; /* Hash value; -1 if not set */ + struct { + /* + SSTATE_NOT_INTERNED (0) + SSTATE_INTERNED_MORTAL (1) + SSTATE_INTERNED_IMMORTAL (2) + + If interned != SSTATE_NOT_INTERNED, the two references from the + dictionary to this object are *not* counted in ob_refcnt. + */ + unsigned int interned:2; + /* Character size: + + - PyUnicode_WCHAR_KIND (0): + + * character type = wchar_t (16 or 32 bits, depending on the + platform) + + - PyUnicode_1BYTE_KIND (1): + + * character type = Py_UCS1 (8 bits, unsigned) + * all characters are in the range U+0000-U+00FF (latin1) + * if ascii is set, all characters are in the range U+0000-U+007F + (ASCII), otherwise at least one character is in the range + U+0080-U+00FF + + - PyUnicode_2BYTE_KIND (2): + + * character type = Py_UCS2 (16 bits, unsigned) + * all characters are in the range U+0000-U+FFFF (BMP) + * at least one character is in the range U+0100-U+FFFF + + - PyUnicode_4BYTE_KIND (4): + + * character type = Py_UCS4 (32 bits, unsigned) + * all characters are in the range U+0000-U+10FFFF + * at least one character is in the range U+10000-U+10FFFF + */ + unsigned int kind:3; + /* Compact is with respect to the allocation scheme. Compact unicode + objects only require one memory block while non-compact objects use + one block for the PyUnicodeObject struct and another for its data + buffer. */ + unsigned int compact:1; + /* The string only contains characters in the range U+0000-U+007F (ASCII) + and the kind is PyUnicode_1BYTE_KIND. If ascii is set and compact is + set, use the PyASCIIObject structure. */ + unsigned int ascii:1; + /* The ready flag indicates whether the object layout is initialized + completely. This means that this is either a compact object, or + the data pointer is filled out. The bit is redundant, and helps + to minimize the test in PyUnicode_IS_READY(). */ + unsigned int ready:1; + /* Padding to ensure that PyUnicode_DATA() is always aligned to + 4 bytes (see issue #19537 on m68k). */ + unsigned int :24; + } state; + wchar_t *wstr; /* wchar_t representation (null-terminated) */ +} PyASCIIObject; + +/* Non-ASCII strings allocated through PyUnicode_New use the + PyCompactUnicodeObject structure. state.compact is set, and the data + immediately follow the structure. */ +typedef struct { + PyASCIIObject _base; + Py_ssize_t utf8_length; /* Number of bytes in utf8, excluding the + * terminating \0. */ + char *utf8; /* UTF-8 representation (null-terminated) */ + Py_ssize_t wstr_length; /* Number of code points in wstr, possible + * surrogates count as two code points. */ +} PyCompactUnicodeObject; + +/* Strings allocated through PyUnicode_FromUnicode(NULL, len) use the + PyUnicodeObject structure. The actual string data is initially in the wstr + block, and copied into the data block using _PyUnicode_Ready. */ +typedef struct { + PyCompactUnicodeObject _base; + union { + void *any; + Py_UCS1 *latin1; + Py_UCS2 *ucs2; + Py_UCS4 *ucs4; + } data; /* Canonical, smallest-form Unicode buffer */ +} PyUnicodeObject; + +PyAPI_FUNC(int) _PyUnicode_CheckConsistency( + PyObject *op, + int check_content); + +/* Fast access macros */ + +/* Returns the deprecated Py_UNICODE representation's size in code units + (this includes surrogate pairs as 2 units). + If the Py_UNICODE representation is not available, it will be computed + on request. Use PyUnicode_GET_LENGTH() for the length in code points. */ + +/* Py_DEPRECATED(3.3) */ +#define PyUnicode_GET_SIZE(op) \ + (assert(PyUnicode_Check(op)), \ + (((PyASCIIObject *)(op))->wstr) ? \ + PyUnicode_WSTR_LENGTH(op) : \ + ((void)PyUnicode_AsUnicode(_PyObject_CAST(op)),\ + assert(((PyASCIIObject *)(op))->wstr), \ + PyUnicode_WSTR_LENGTH(op))) + +/* Py_DEPRECATED(3.3) */ +#define PyUnicode_GET_DATA_SIZE(op) \ + (PyUnicode_GET_SIZE(op) * Py_UNICODE_SIZE) + +/* Alias for PyUnicode_AsUnicode(). This will create a wchar_t/Py_UNICODE + representation on demand. Using this macro is very inefficient now, + try to port your code to use the new PyUnicode_*BYTE_DATA() macros or + use PyUnicode_WRITE() and PyUnicode_READ(). */ + +/* Py_DEPRECATED(3.3) */ +#define PyUnicode_AS_UNICODE(op) \ + (assert(PyUnicode_Check(op)), \ + (((PyASCIIObject *)(op))->wstr) ? (((PyASCIIObject *)(op))->wstr) : \ + PyUnicode_AsUnicode(_PyObject_CAST(op))) + +/* Py_DEPRECATED(3.3) */ +#define PyUnicode_AS_DATA(op) \ + ((const char *)(PyUnicode_AS_UNICODE(op))) + + +/* --- Flexible String Representation Helper Macros (PEP 393) -------------- */ + +/* Values for PyASCIIObject.state: */ + +/* Interning state. */ +#define SSTATE_NOT_INTERNED 0 +#define SSTATE_INTERNED_MORTAL 1 +#define SSTATE_INTERNED_IMMORTAL 2 + +/* Return true if the string contains only ASCII characters, or 0 if not. The + string may be compact (PyUnicode_IS_COMPACT_ASCII) or not, but must be + ready. */ +#define PyUnicode_IS_ASCII(op) \ + (assert(PyUnicode_Check(op)), \ + assert(PyUnicode_IS_READY(op)), \ + ((PyASCIIObject*)op)->state.ascii) + +/* Return true if the string is compact or 0 if not. + No type checks or Ready calls are performed. */ +#define PyUnicode_IS_COMPACT(op) \ + (((PyASCIIObject*)(op))->state.compact) + +/* Return true if the string is a compact ASCII string (use PyASCIIObject + structure), or 0 if not. No type checks or Ready calls are performed. */ +#define PyUnicode_IS_COMPACT_ASCII(op) \ + (((PyASCIIObject*)op)->state.ascii && PyUnicode_IS_COMPACT(op)) + +enum PyUnicode_Kind { +/* String contains only wstr byte characters. This is only possible + when the string was created with a legacy API and _PyUnicode_Ready() + has not been called yet. */ + PyUnicode_WCHAR_KIND = 0, +/* Return values of the PyUnicode_KIND() macro: */ + PyUnicode_1BYTE_KIND = 1, + PyUnicode_2BYTE_KIND = 2, + PyUnicode_4BYTE_KIND = 4 +}; + +/* Return pointers to the canonical representation cast to unsigned char, + Py_UCS2, or Py_UCS4 for direct character access. + No checks are performed, use PyUnicode_KIND() before to ensure + these will work correctly. */ + +#define PyUnicode_1BYTE_DATA(op) ((Py_UCS1*)PyUnicode_DATA(op)) +#define PyUnicode_2BYTE_DATA(op) ((Py_UCS2*)PyUnicode_DATA(op)) +#define PyUnicode_4BYTE_DATA(op) ((Py_UCS4*)PyUnicode_DATA(op)) + +/* Return one of the PyUnicode_*_KIND values defined above. */ +#define PyUnicode_KIND(op) \ + (assert(PyUnicode_Check(op)), \ + assert(PyUnicode_IS_READY(op)), \ + ((PyASCIIObject *)(op))->state.kind) + +/* Return a void pointer to the raw unicode buffer. */ +#define _PyUnicode_COMPACT_DATA(op) \ + (PyUnicode_IS_ASCII(op) ? \ + ((void*)((PyASCIIObject*)(op) + 1)) : \ + ((void*)((PyCompactUnicodeObject*)(op) + 1))) + +#define _PyUnicode_NONCOMPACT_DATA(op) \ + (assert(((PyUnicodeObject*)(op))->data.any), \ + ((((PyUnicodeObject *)(op))->data.any))) + +#define PyUnicode_DATA(op) \ + (assert(PyUnicode_Check(op)), \ + PyUnicode_IS_COMPACT(op) ? _PyUnicode_COMPACT_DATA(op) : \ + _PyUnicode_NONCOMPACT_DATA(op)) + +/* In the access macros below, "kind" may be evaluated more than once. + All other macro parameters are evaluated exactly once, so it is safe + to put side effects into them (such as increasing the index). */ + +/* Write into the canonical representation, this macro does not do any sanity + checks and is intended for usage in loops. The caller should cache the + kind and data pointers obtained from other macro calls. + index is the index in the string (starts at 0) and value is the new + code point value which should be written to that location. */ +#define PyUnicode_WRITE(kind, data, index, value) \ + do { \ + switch ((kind)) { \ + case PyUnicode_1BYTE_KIND: { \ + ((Py_UCS1 *)(data))[(index)] = (Py_UCS1)(value); \ + break; \ + } \ + case PyUnicode_2BYTE_KIND: { \ + ((Py_UCS2 *)(data))[(index)] = (Py_UCS2)(value); \ + break; \ + } \ + default: { \ + assert((kind) == PyUnicode_4BYTE_KIND); \ + ((Py_UCS4 *)(data))[(index)] = (Py_UCS4)(value); \ + } \ + } \ + } while (0) + +/* Read a code point from the string's canonical representation. No checks + or ready calls are performed. */ +#define PyUnicode_READ(kind, data, index) \ + ((Py_UCS4) \ + ((kind) == PyUnicode_1BYTE_KIND ? \ + ((const Py_UCS1 *)(data))[(index)] : \ + ((kind) == PyUnicode_2BYTE_KIND ? \ + ((const Py_UCS2 *)(data))[(index)] : \ + ((const Py_UCS4 *)(data))[(index)] \ + ) \ + )) + +/* PyUnicode_READ_CHAR() is less efficient than PyUnicode_READ() because it + calls PyUnicode_KIND() and might call it twice. For single reads, use + PyUnicode_READ_CHAR, for multiple consecutive reads callers should + cache kind and use PyUnicode_READ instead. */ +#define PyUnicode_READ_CHAR(unicode, index) \ + (assert(PyUnicode_Check(unicode)), \ + assert(PyUnicode_IS_READY(unicode)), \ + (Py_UCS4) \ + (PyUnicode_KIND((unicode)) == PyUnicode_1BYTE_KIND ? \ + ((const Py_UCS1 *)(PyUnicode_DATA((unicode))))[(index)] : \ + (PyUnicode_KIND((unicode)) == PyUnicode_2BYTE_KIND ? \ + ((const Py_UCS2 *)(PyUnicode_DATA((unicode))))[(index)] : \ + ((const Py_UCS4 *)(PyUnicode_DATA((unicode))))[(index)] \ + ) \ + )) + +/* Returns the length of the unicode string. The caller has to make sure that + the string has it's canonical representation set before calling + this macro. Call PyUnicode_(FAST_)Ready to ensure that. */ +#define PyUnicode_GET_LENGTH(op) \ + (assert(PyUnicode_Check(op)), \ + assert(PyUnicode_IS_READY(op)), \ + ((PyASCIIObject *)(op))->length) + + +/* Fast check to determine whether an object is ready. Equivalent to + PyUnicode_IS_COMPACT(op) || ((PyUnicodeObject*)(op))->data.any */ + +#define PyUnicode_IS_READY(op) (((PyASCIIObject*)op)->state.ready) + +/* PyUnicode_READY() does less work than _PyUnicode_Ready() in the best + case. If the canonical representation is not yet set, it will still call + _PyUnicode_Ready(). + Returns 0 on success and -1 on errors. */ +#define PyUnicode_READY(op) \ + (assert(PyUnicode_Check(op)), \ + (PyUnicode_IS_READY(op) ? \ + 0 : _PyUnicode_Ready(_PyObject_CAST(op)))) + +/* Return a maximum character value which is suitable for creating another + string based on op. This is always an approximation but more efficient + than iterating over the string. */ +#define PyUnicode_MAX_CHAR_VALUE(op) \ + (assert(PyUnicode_IS_READY(op)), \ + (PyUnicode_IS_ASCII(op) ? \ + (0x7f) : \ + (PyUnicode_KIND(op) == PyUnicode_1BYTE_KIND ? \ + (0xffU) : \ + (PyUnicode_KIND(op) == PyUnicode_2BYTE_KIND ? \ + (0xffffU) : \ + (0x10ffffU))))) + +Py_DEPRECATED(3.3) +static inline Py_ssize_t _PyUnicode_get_wstr_length(PyObject *op) { + return PyUnicode_IS_COMPACT_ASCII(op) ? + ((PyASCIIObject*)op)->length : + ((PyCompactUnicodeObject*)op)->wstr_length; +} +#define PyUnicode_WSTR_LENGTH(op) _PyUnicode_get_wstr_length((PyObject*)op) + +/* === Public API ========================================================= */ + +/* --- Plain Py_UNICODE --------------------------------------------------- */ + +/* With PEP 393, this is the recommended way to allocate a new unicode object. + This function will allocate the object and its buffer in a single memory + block. Objects created using this function are not resizable. */ +PyAPI_FUNC(PyObject*) PyUnicode_New( + Py_ssize_t size, /* Number of code points in the new string */ + Py_UCS4 maxchar /* maximum code point value in the string */ + ); + +/* Initializes the canonical string representation from the deprecated + wstr/Py_UNICODE representation. This function is used to convert Unicode + objects which were created using the old API to the new flexible format + introduced with PEP 393. + + Don't call this function directly, use the public PyUnicode_READY() macro + instead. */ +PyAPI_FUNC(int) _PyUnicode_Ready( + PyObject *unicode /* Unicode object */ + ); + +/* Get a copy of a Unicode string. */ +PyAPI_FUNC(PyObject*) _PyUnicode_Copy( + PyObject *unicode + ); + +/* Copy character from one unicode object into another, this function performs + character conversion when necessary and falls back to memcpy() if possible. + + Fail if to is too small (smaller than *how_many* or smaller than + len(from)-from_start), or if kind(from[from_start:from_start+how_many]) > + kind(to), or if *to* has more than 1 reference. + + Return the number of written character, or return -1 and raise an exception + on error. + + Pseudo-code: + + how_many = min(how_many, len(from) - from_start) + to[to_start:to_start+how_many] = from[from_start:from_start+how_many] + return how_many + + Note: The function doesn't write a terminating null character. + */ +PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters( + PyObject *to, + Py_ssize_t to_start, + PyObject *from, + Py_ssize_t from_start, + Py_ssize_t how_many + ); + +/* Unsafe version of PyUnicode_CopyCharacters(): don't check arguments and so + may crash if parameters are invalid (e.g. if the output string + is too short). */ +PyAPI_FUNC(void) _PyUnicode_FastCopyCharacters( + PyObject *to, + Py_ssize_t to_start, + PyObject *from, + Py_ssize_t from_start, + Py_ssize_t how_many + ); + +/* Fill a string with a character: write fill_char into + unicode[start:start+length]. + + Fail if fill_char is bigger than the string maximum character, or if the + string has more than 1 reference. + + Return the number of written character, or return -1 and raise an exception + on error. */ +PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill( + PyObject *unicode, + Py_ssize_t start, + Py_ssize_t length, + Py_UCS4 fill_char + ); + +/* Unsafe version of PyUnicode_Fill(): don't check arguments and so may crash + if parameters are invalid (e.g. if length is longer than the string). */ +PyAPI_FUNC(void) _PyUnicode_FastFill( + PyObject *unicode, + Py_ssize_t start, + Py_ssize_t length, + Py_UCS4 fill_char + ); + +/* Create a Unicode Object from the Py_UNICODE buffer u of the given + size. + + u may be NULL which causes the contents to be undefined. It is the + user's responsibility to fill in the needed data afterwards. Note + that modifying the Unicode object contents after construction is + only allowed if u was set to NULL. + + The buffer is copied into the new object. */ +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode( + const Py_UNICODE *u, /* Unicode buffer */ + Py_ssize_t size /* size of buffer */ + ); + +/* Create a new string from a buffer of Py_UCS1, Py_UCS2 or Py_UCS4 characters. + Scan the string to find the maximum character. */ +PyAPI_FUNC(PyObject*) PyUnicode_FromKindAndData( + int kind, + const void *buffer, + Py_ssize_t size); + +/* Create a new string from a buffer of ASCII characters. + WARNING: Don't check if the string contains any non-ASCII character. */ +PyAPI_FUNC(PyObject*) _PyUnicode_FromASCII( + const char *buffer, + Py_ssize_t size); + +/* Compute the maximum character of the substring unicode[start:end]. + Return 127 for an empty string. */ +PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar ( + PyObject *unicode, + Py_ssize_t start, + Py_ssize_t end); + +/* Return a read-only pointer to the Unicode object's internal + Py_UNICODE buffer. + If the wchar_t/Py_UNICODE representation is not yet available, this + function will calculate it. */ +Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode( + PyObject *unicode /* Unicode object */ + ); + +/* Similar to PyUnicode_AsUnicode(), but raises a ValueError if the string + contains null characters. */ +PyAPI_FUNC(const Py_UNICODE *) _PyUnicode_AsUnicode( + PyObject *unicode /* Unicode object */ + ); + +/* Return a read-only pointer to the Unicode object's internal + Py_UNICODE buffer and save the length at size. + If the wchar_t/Py_UNICODE representation is not yet available, this + function will calculate it. */ + +Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicodeAndSize( + PyObject *unicode, /* Unicode object */ + Py_ssize_t *size /* location where to save the length */ + ); + + +/* --- _PyUnicodeWriter API ----------------------------------------------- */ + +typedef struct { + PyObject *buffer; + void *data; + enum PyUnicode_Kind kind; + Py_UCS4 maxchar; + Py_ssize_t size; + Py_ssize_t pos; + + /* minimum number of allocated characters (default: 0) */ + Py_ssize_t min_length; + + /* minimum character (default: 127, ASCII) */ + Py_UCS4 min_char; + + /* If non-zero, overallocate the buffer (default: 0). */ + unsigned char overallocate; + + /* If readonly is 1, buffer is a shared string (cannot be modified) + and size is set to 0. */ + unsigned char readonly; +} _PyUnicodeWriter ; + +/* Initialize a Unicode writer. + * + * By default, the minimum buffer size is 0 character and overallocation is + * disabled. Set min_length, min_char and overallocate attributes to control + * the allocation of the buffer. */ +PyAPI_FUNC(void) +_PyUnicodeWriter_Init(_PyUnicodeWriter *writer); + +/* Prepare the buffer to write 'length' characters + with the specified maximum character. + + Return 0 on success, raise an exception and return -1 on error. */ +#define _PyUnicodeWriter_Prepare(WRITER, LENGTH, MAXCHAR) \ + (((MAXCHAR) <= (WRITER)->maxchar \ + && (LENGTH) <= (WRITER)->size - (WRITER)->pos) \ + ? 0 \ + : (((LENGTH) == 0) \ + ? 0 \ + : _PyUnicodeWriter_PrepareInternal((WRITER), (LENGTH), (MAXCHAR)))) + +/* Don't call this function directly, use the _PyUnicodeWriter_Prepare() macro + instead. */ +PyAPI_FUNC(int) +_PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer, + Py_ssize_t length, Py_UCS4 maxchar); + +/* Prepare the buffer to have at least the kind KIND. + For example, kind=PyUnicode_2BYTE_KIND ensures that the writer will + support characters in range U+000-U+FFFF. + + Return 0 on success, raise an exception and return -1 on error. */ +#define _PyUnicodeWriter_PrepareKind(WRITER, KIND) \ + (assert((KIND) != PyUnicode_WCHAR_KIND), \ + (KIND) <= (WRITER)->kind \ + ? 0 \ + : _PyUnicodeWriter_PrepareKindInternal((WRITER), (KIND))) + +/* Don't call this function directly, use the _PyUnicodeWriter_PrepareKind() + macro instead. */ +PyAPI_FUNC(int) +_PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer, + enum PyUnicode_Kind kind); + +/* Append a Unicode character. + Return 0 on success, raise an exception and return -1 on error. */ +PyAPI_FUNC(int) +_PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer, + Py_UCS4 ch + ); + +/* Append a Unicode string. + Return 0 on success, raise an exception and return -1 on error. */ +PyAPI_FUNC(int) +_PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer, + PyObject *str /* Unicode string */ + ); + +/* Append a substring of a Unicode string. + Return 0 on success, raise an exception and return -1 on error. */ +PyAPI_FUNC(int) +_PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer, + PyObject *str, /* Unicode string */ + Py_ssize_t start, + Py_ssize_t end + ); + +/* Append an ASCII-encoded byte string. + Return 0 on success, raise an exception and return -1 on error. */ +PyAPI_FUNC(int) +_PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer, + const char *str, /* ASCII-encoded byte string */ + Py_ssize_t len /* number of bytes, or -1 if unknown */ + ); + +/* Append a latin1-encoded byte string. + Return 0 on success, raise an exception and return -1 on error. */ +PyAPI_FUNC(int) +_PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer, + const char *str, /* latin1-encoded byte string */ + Py_ssize_t len /* length in bytes */ + ); + +/* Get the value of the writer as a Unicode string. Clear the + buffer of the writer. Raise an exception and return NULL + on error. */ +PyAPI_FUNC(PyObject *) +_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer); + +/* Deallocate memory of a writer (clear its internal buffer). */ +PyAPI_FUNC(void) +_PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer); + + +/* Format the object based on the format_spec, as defined in PEP 3101 + (Advanced String Formatting). */ +PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter( + _PyUnicodeWriter *writer, + PyObject *obj, + PyObject *format_spec, + Py_ssize_t start, + Py_ssize_t end); + +/* --- Manage the default encoding ---------------------------------------- */ + +/* Returns a pointer to the default encoding (UTF-8) of the + Unicode object unicode. + + Like PyUnicode_AsUTF8AndSize(), this also caches the UTF-8 representation + in the unicodeobject. + + _PyUnicode_AsString is a #define for PyUnicode_AsUTF8 to + support the previous internal function with the same behaviour. + + Use of this API is DEPRECATED since no size information can be + extracted from the returned data. +*/ + +PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode); + +#define _PyUnicode_AsString PyUnicode_AsUTF8 + +/* --- Generic Codecs ----------------------------------------------------- */ + +/* Encodes a Py_UNICODE buffer of the given size and returns a + Python string object. */ +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_Encode( + const Py_UNICODE *s, /* Unicode char buffer */ + Py_ssize_t size, /* number of Py_UNICODE chars to encode */ + const char *encoding, /* encoding */ + const char *errors /* error handling */ + ); + +/* --- UTF-7 Codecs ------------------------------------------------------- */ + +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length, /* number of Py_UNICODE chars to encode */ + int base64SetO, /* Encode RFC2152 Set O characters in base64 */ + int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */ + const char *errors /* error handling */ + ); + +PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF7( + PyObject *unicode, /* Unicode object */ + int base64SetO, /* Encode RFC2152 Set O characters in base64 */ + int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */ + const char *errors /* error handling */ + ); + +/* --- UTF-8 Codecs ------------------------------------------------------- */ + +PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String( + PyObject *unicode, + const char *errors); + +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length, /* number of Py_UNICODE chars to encode */ + const char *errors /* error handling */ + ); + +/* --- UTF-32 Codecs ------------------------------------------------------ */ + +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length, /* number of Py_UNICODE chars to encode */ + const char *errors, /* error handling */ + int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */ + ); + +PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32( + PyObject *object, /* Unicode object */ + const char *errors, /* error handling */ + int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */ + ); + +/* --- UTF-16 Codecs ------------------------------------------------------ */ + +/* Returns a Python string object holding the UTF-16 encoded value of + the Unicode data. + + If byteorder is not 0, output is written according to the following + byte order: + + byteorder == -1: little endian + byteorder == 0: native byte order (writes a BOM mark) + byteorder == 1: big endian + + If byteorder is 0, the output string will always start with the + Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is + prepended. + + Note that Py_UNICODE data is being interpreted as UTF-16 reduced to + UCS-2. This trick makes it possible to add full UTF-16 capabilities + at a later point without compromising the APIs. + +*/ +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length, /* number of Py_UNICODE chars to encode */ + const char *errors, /* error handling */ + int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */ + ); + +PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16( + PyObject* unicode, /* Unicode object */ + const char *errors, /* error handling */ + int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */ + ); + +/* --- Unicode-Escape Codecs ---------------------------------------------- */ + +/* Variant of PyUnicode_DecodeUnicodeEscape that supports partial decoding. */ +PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeStateful( + const char *string, /* Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed /* bytes consumed */ +); + +/* Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape + chars. */ +PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscapeInternal( + const char *string, /* Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed, /* bytes consumed */ + const char **first_invalid_escape /* on return, points to first + invalid escaped char in + string. */ +); + +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length /* Number of Py_UNICODE chars to encode */ + ); + +/* --- Raw-Unicode-Escape Codecs ------------------------------------------ */ + +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length /* Number of Py_UNICODE chars to encode */ + ); + +/* Variant of PyUnicode_DecodeRawUnicodeEscape that supports partial decoding. */ +PyAPI_FUNC(PyObject*) _PyUnicode_DecodeRawUnicodeEscapeStateful( + const char *string, /* Unicode-Escape encoded string */ + Py_ssize_t length, /* size of string */ + const char *errors, /* error handling */ + Py_ssize_t *consumed /* bytes consumed */ +); + +/* --- Latin-1 Codecs ----------------------------------------------------- */ + +PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String( + PyObject* unicode, + const char* errors); + +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ + const char *errors /* error handling */ + ); + +/* --- ASCII Codecs ------------------------------------------------------- */ + +PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString( + PyObject* unicode, + const char* errors); + +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ + const char *errors /* error handling */ + ); + +/* --- Character Map Codecs ----------------------------------------------- */ + +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ + PyObject *mapping, /* encoding mapping */ + const char *errors /* error handling */ + ); + +PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap( + PyObject *unicode, /* Unicode object */ + PyObject *mapping, /* encoding mapping */ + const char *errors /* error handling */ + ); + +/* Translate a Py_UNICODE buffer of the given length by applying a + character mapping table to it and return the resulting Unicode + object. + + The mapping table must map Unicode ordinal integers to Unicode strings, + Unicode ordinal integers or None (causing deletion of the character). + + Mapping tables may be dictionaries or sequences. Unmapped character + ordinals (ones which cause a LookupError) are left untouched and + are copied as-is. + +*/ +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ + PyObject *table, /* Translate table */ + const char *errors /* error handling */ + ); + +/* --- MBCS codecs for Windows -------------------------------------------- */ + +#ifdef MS_WINDOWS +Py_DEPRECATED(3.3) PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS( + const Py_UNICODE *data, /* Unicode char buffer */ + Py_ssize_t length, /* number of Py_UNICODE chars to encode */ + const char *errors /* error handling */ + ); +#endif + +/* --- Decimal Encoder ---------------------------------------------------- */ + +/* Takes a Unicode string holding a decimal value and writes it into + an output buffer using standard ASCII digit codes. + + The output buffer has to provide at least length+1 bytes of storage + area. The output string is 0-terminated. + + The encoder converts whitespace to ' ', decimal characters to their + corresponding ASCII digit and all other Latin-1 characters except + \0 as-is. Characters outside this range (Unicode ordinals 1-256) + are treated as errors. This includes embedded NULL bytes. + + Error handling is defined by the errors argument: + + NULL or "strict": raise a ValueError + "ignore": ignore the wrong characters (these are not copied to the + output buffer) + "replace": replaces illegal characters with '?' + + Returns 0 on success, -1 on failure. + +*/ + +Py_DEPRECATED(3.3) PyAPI_FUNC(int) PyUnicode_EncodeDecimal( + Py_UNICODE *s, /* Unicode buffer */ + Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ + char *output, /* Output buffer; must have size >= length */ + const char *errors /* error handling */ + ); + +/* Transforms code points that have decimal digit property to the + corresponding ASCII digit code points. + + Returns a new Unicode string on success, NULL on failure. +*/ + +Py_DEPRECATED(3.3) +PyAPI_FUNC(PyObject*) PyUnicode_TransformDecimalToASCII( + Py_UNICODE *s, /* Unicode buffer */ + Py_ssize_t length /* Number of Py_UNICODE chars to transform */ + ); + +/* Coverts a Unicode object holding a decimal value to an ASCII string + for using in int, float and complex parsers. + Transforms code points that have decimal digit property to the + corresponding ASCII digit code points. Transforms spaces to ASCII. + Transforms code points starting from the first non-ASCII code point that + is neither a decimal digit nor a space to the end into '?'. */ + +PyAPI_FUNC(PyObject*) _PyUnicode_TransformDecimalAndSpaceToASCII( + PyObject *unicode /* Unicode object */ + ); + +/* --- Methods & Slots ---------------------------------------------------- */ + +PyAPI_FUNC(PyObject *) _PyUnicode_JoinArray( + PyObject *separator, + PyObject *const *items, + Py_ssize_t seqlen + ); + +/* Test whether a unicode is equal to ASCII identifier. Return 1 if true, + 0 otherwise. The right argument must be ASCII identifier. + Any error occurs inside will be cleared before return. */ +PyAPI_FUNC(int) _PyUnicode_EqualToASCIIId( + PyObject *left, /* Left string */ + _Py_Identifier *right /* Right identifier */ + ); + +/* Test whether a unicode is equal to ASCII string. Return 1 if true, + 0 otherwise. The right argument must be ASCII-encoded string. + Any error occurs inside will be cleared before return. */ +PyAPI_FUNC(int) _PyUnicode_EqualToASCIIString( + PyObject *left, + const char *right /* ASCII-encoded string */ + ); + +/* Externally visible for str.strip(unicode) */ +PyAPI_FUNC(PyObject *) _PyUnicode_XStrip( + PyObject *self, + int striptype, + PyObject *sepobj + ); + +/* Using explicit passed-in values, insert the thousands grouping + into the string pointed to by buffer. For the argument descriptions, + see Objects/stringlib/localeutil.h */ +PyAPI_FUNC(Py_ssize_t) _PyUnicode_InsertThousandsGrouping( + _PyUnicodeWriter *writer, + Py_ssize_t n_buffer, + PyObject *digits, + Py_ssize_t d_pos, + Py_ssize_t n_digits, + Py_ssize_t min_width, + const char *grouping, + PyObject *thousands_sep, + Py_UCS4 *maxchar); + +/* === Characters Type APIs =============================================== */ + +/* Helper array used by Py_UNICODE_ISSPACE(). */ + +PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[]; + +/* These should not be used directly. Use the Py_UNICODE_IS* and + Py_UNICODE_TO* macros instead. + + These APIs are implemented in Objects/unicodectype.c. + +*/ + +PyAPI_FUNC(int) _PyUnicode_IsLowercase( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsUppercase( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsTitlecase( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsXidStart( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsXidContinue( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsWhitespace( + const Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsLinebreak( + const Py_UCS4 ch /* Unicode character */ + ); + +/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToLowercase( + Py_UCS4 ch /* Unicode character */ + ); + +/* Py_DEPRECATED(3.3) */ PyAPI_FUNC(Py_UCS4) _PyUnicode_ToUppercase( + Py_UCS4 ch /* Unicode character */ + ); + +Py_DEPRECATED(3.3) PyAPI_FUNC(Py_UCS4) _PyUnicode_ToTitlecase( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_ToLowerFull( + Py_UCS4 ch, /* Unicode character */ + Py_UCS4 *res + ); + +PyAPI_FUNC(int) _PyUnicode_ToTitleFull( + Py_UCS4 ch, /* Unicode character */ + Py_UCS4 *res + ); + +PyAPI_FUNC(int) _PyUnicode_ToUpperFull( + Py_UCS4 ch, /* Unicode character */ + Py_UCS4 *res + ); + +PyAPI_FUNC(int) _PyUnicode_ToFoldedFull( + Py_UCS4 ch, /* Unicode character */ + Py_UCS4 *res + ); + +PyAPI_FUNC(int) _PyUnicode_IsCaseIgnorable( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsCased( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_ToDigit( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(double) _PyUnicode_ToNumeric( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsDigit( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsNumeric( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsPrintable( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(int) _PyUnicode_IsAlpha( + Py_UCS4 ch /* Unicode character */ + ); + +PyAPI_FUNC(PyObject*) _PyUnicode_FormatLong(PyObject *, int, int, int); + +/* Return an interned Unicode object for an Identifier; may fail if there is no memory.*/ +PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*); + +/* Fast equality check when the inputs are known to be exact unicode types + and where the hash values are equal (i.e. a very probable match) */ +PyAPI_FUNC(int) _PyUnicode_EQ(PyObject *, PyObject *); + +PyAPI_FUNC(int) _PyUnicode_WideCharString_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyUnicode_WideCharString_Opt_Converter(PyObject *, void *); + +PyAPI_FUNC(Py_ssize_t) _PyUnicode_ScanIdentifier(PyObject *); diff --git a/include/datetime.h b/include/datetime.h index 059d5ecf..bb565201 100644 --- a/include/datetime.h +++ b/include/datetime.h @@ -115,6 +115,10 @@ typedef struct /* Apply for date and datetime instances. */ + +// o is a pointer to a time or a datetime object. +#define _PyDateTime_HAS_TZINFO(o) (((_PyDateTime_BaseTZInfo *)(o))->hastzinfo) + #define PyDateTime_GET_YEAR(o) ((((PyDateTime_Date*)o)->data[0] << 8) | \ ((PyDateTime_Date*)o)->data[1]) #define PyDateTime_GET_MONTH(o) (((PyDateTime_Date*)o)->data[2]) @@ -128,6 +132,8 @@ typedef struct (((PyDateTime_DateTime*)o)->data[8] << 8) | \ ((PyDateTime_DateTime*)o)->data[9]) #define PyDateTime_DATE_GET_FOLD(o) (((PyDateTime_DateTime*)o)->fold) +#define PyDateTime_DATE_GET_TZINFO(o) (_PyDateTime_HAS_TZINFO(o) ? \ + ((PyDateTime_DateTime *)(o))->tzinfo : Py_None) /* Apply for time instances. */ #define PyDateTime_TIME_GET_HOUR(o) (((PyDateTime_Time*)o)->data[0]) @@ -138,6 +144,8 @@ typedef struct (((PyDateTime_Time*)o)->data[4] << 8) | \ ((PyDateTime_Time*)o)->data[5]) #define PyDateTime_TIME_GET_FOLD(o) (((PyDateTime_Time*)o)->fold) +#define PyDateTime_TIME_GET_TZINFO(o) (_PyDateTime_HAS_TZINFO(o) ? \ + ((PyDateTime_Time *)(o))->tzinfo : Py_None) /* Apply for time delta instances */ #define PyDateTime_DELTA_GET_DAYS(o) (((PyDateTime_Delta*)o)->days) @@ -180,26 +188,11 @@ typedef struct { #define PyDateTime_CAPSULE_NAME "datetime.datetime_CAPI" -#ifdef Py_BUILD_CORE - -/* Macros for type checking when building the Python core. */ -#define PyDate_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateType) -#define PyDate_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DateType) - -#define PyDateTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_DateTimeType) -#define PyDateTime_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DateTimeType) - -#define PyTime_Check(op) PyObject_TypeCheck(op, &PyDateTime_TimeType) -#define PyTime_CheckExact(op) (Py_TYPE(op) == &PyDateTime_TimeType) - -#define PyDelta_Check(op) PyObject_TypeCheck(op, &PyDateTime_DeltaType) -#define PyDelta_CheckExact(op) (Py_TYPE(op) == &PyDateTime_DeltaType) - -#define PyTZInfo_Check(op) PyObject_TypeCheck(op, &PyDateTime_TZInfoType) -#define PyTZInfo_CheckExact(op) (Py_TYPE(op) == &PyDateTime_TZInfoType) - -#else - +/* This block is only used as part of the public API and should not be + * included in _datetimemodule.c, which does not use the C API capsule. + * See bpo-35081 for more details. + * */ +#ifndef _PY_DATETIME_IMPL /* Define global variable for the C API and a macro for setting it. */ static PyDateTime_CAPI *PyDateTimeAPI = NULL; @@ -211,19 +204,20 @@ static PyDateTime_CAPI *PyDateTimeAPI = NULL; /* Macros for type checking when not building the Python core. */ #define PyDate_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateType) -#define PyDate_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DateType) +#define PyDate_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DateType) #define PyDateTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DateTimeType) -#define PyDateTime_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DateTimeType) +#define PyDateTime_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DateTimeType) #define PyTime_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TimeType) -#define PyTime_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->TimeType) +#define PyTime_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->TimeType) #define PyDelta_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->DeltaType) -#define PyDelta_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->DeltaType) +#define PyDelta_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->DeltaType) #define PyTZInfo_Check(op) PyObject_TypeCheck(op, PyDateTimeAPI->TZInfoType) -#define PyTZInfo_CheckExact(op) (Py_TYPE(op) == PyDateTimeAPI->TZInfoType) +#define PyTZInfo_CheckExact(op) Py_IS_TYPE(op, PyDateTimeAPI->TZInfoType) + /* Macros for accessing constructors in a simplified fashion. */ #define PyDate_FromDate(year, month, day) \ @@ -264,7 +258,7 @@ static PyDateTime_CAPI *PyDateTimeAPI = NULL; PyDateTimeAPI->Date_FromTimestamp( \ (PyObject*) (PyDateTimeAPI->DateType), args) -#endif /* Py_BUILD_CORE */ +#endif /* !defined(_PY_DATETIME_IMPL) */ #ifdef __cplusplus } diff --git a/include/descrobject.h b/include/descrobject.h index 73bbb3fe..703bc8fd 100644 --- a/include/descrobject.h +++ b/include/descrobject.h @@ -53,6 +53,7 @@ typedef struct { typedef struct { PyDescr_COMMON; PyMethodDef *d_method; + vectorcallfunc vectorcall; } PyMethodDescrObject; typedef struct { @@ -90,12 +91,9 @@ PyAPI_FUNC(PyObject *) PyDescr_NewMember(PyTypeObject *, PyAPI_FUNC(PyObject *) PyDescr_NewGetSet(PyTypeObject *, struct PyGetSetDef *); #ifndef Py_LIMITED_API - -PyAPI_FUNC(PyObject *) _PyMethodDescr_FastCallKeywords( - PyObject *descrobj, PyObject *const *stack, Py_ssize_t nargs, PyObject *kwnames); PyAPI_FUNC(PyObject *) PyDescr_NewWrapper(PyTypeObject *, struct wrapperbase *, void *); -#define PyDescr_IsData(d) (Py_TYPE(d)->tp_descr_set != NULL) +PyAPI_FUNC(int) PyDescr_IsData(PyObject *); #endif PyAPI_FUNC(PyObject *) PyDictProxy_New(PyObject *); diff --git a/include/dictobject.h b/include/dictobject.h index 28930f43..da5a36ba 100644 --- a/include/dictobject.h +++ b/include/dictobject.h @@ -4,7 +4,6 @@ extern "C" { #endif - /* Dictionary object type -- mapping from hashable object to object */ /* The distribution includes a separate file, Objects/dictnotes.txt, @@ -13,116 +12,26 @@ extern "C" { tuning dictionaries, and several ideas for possible optimizations. */ -#ifndef Py_LIMITED_API - -typedef struct _dictkeysobject PyDictKeysObject; - -/* The ma_values pointer is NULL for a combined table - * or points to an array of PyObject* for a split table - */ -typedef struct { - PyObject_HEAD - - /* Number of items in the dictionary */ - Py_ssize_t ma_used; - - /* Dictionary version: globally unique, value change each time - the dictionary is modified */ - uint64_t ma_version_tag; - - PyDictKeysObject *ma_keys; - - /* If ma_values is NULL, the table is "combined": keys and values - are stored in ma_keys. - - If ma_values is not NULL, the table is splitted: - keys are stored in ma_keys and values are stored in ma_values */ - PyObject **ma_values; -} PyDictObject; - -typedef struct { - PyObject_HEAD - PyDictObject *dv_dict; -} _PyDictViewObject; - -#endif /* Py_LIMITED_API */ - PyAPI_DATA(PyTypeObject) PyDict_Type; -PyAPI_DATA(PyTypeObject) PyDictIterKey_Type; -PyAPI_DATA(PyTypeObject) PyDictIterValue_Type; -PyAPI_DATA(PyTypeObject) PyDictIterItem_Type; -PyAPI_DATA(PyTypeObject) PyDictKeys_Type; -PyAPI_DATA(PyTypeObject) PyDictItems_Type; -PyAPI_DATA(PyTypeObject) PyDictValues_Type; #define PyDict_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_DICT_SUBCLASS) -#define PyDict_CheckExact(op) (Py_TYPE(op) == &PyDict_Type) -#define PyDictKeys_Check(op) PyObject_TypeCheck(op, &PyDictKeys_Type) -#define PyDictItems_Check(op) PyObject_TypeCheck(op, &PyDictItems_Type) -#define PyDictValues_Check(op) PyObject_TypeCheck(op, &PyDictValues_Type) -/* This excludes Values, since they are not sets. */ -# define PyDictViewSet_Check(op) \ - (PyDictKeys_Check(op) || PyDictItems_Check(op)) - +#define PyDict_CheckExact(op) Py_IS_TYPE(op, &PyDict_Type) PyAPI_FUNC(PyObject *) PyDict_New(void); PyAPI_FUNC(PyObject *) PyDict_GetItem(PyObject *mp, PyObject *key); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyDict_GetItem_KnownHash(PyObject *mp, PyObject *key, - Py_hash_t hash); -#endif PyAPI_FUNC(PyObject *) PyDict_GetItemWithError(PyObject *mp, PyObject *key); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyDict_GetItemIdWithError(PyObject *dp, - struct _Py_Identifier *key); -PyAPI_FUNC(PyObject *) PyDict_SetDefault( - PyObject *mp, PyObject *key, PyObject *defaultobj); -#endif PyAPI_FUNC(int) PyDict_SetItem(PyObject *mp, PyObject *key, PyObject *item); -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyDict_SetItem_KnownHash(PyObject *mp, PyObject *key, - PyObject *item, Py_hash_t hash); -#endif PyAPI_FUNC(int) PyDict_DelItem(PyObject *mp, PyObject *key); -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyDict_DelItem_KnownHash(PyObject *mp, PyObject *key, - Py_hash_t hash); -PyAPI_FUNC(int) _PyDict_DelItemIf(PyObject *mp, PyObject *key, - int (*predicate)(PyObject *value)); -#endif PyAPI_FUNC(void) PyDict_Clear(PyObject *mp); PyAPI_FUNC(int) PyDict_Next( PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value); -#ifndef Py_LIMITED_API -PyDictKeysObject *_PyDict_NewKeysForClass(void); -PyAPI_FUNC(PyObject *) PyObject_GenericGetDict(PyObject *, void *); -PyAPI_FUNC(int) _PyDict_Next( - PyObject *mp, Py_ssize_t *pos, PyObject **key, PyObject **value, Py_hash_t *hash); -PyObject *_PyDictView_New(PyObject *, PyTypeObject *); -#endif PyAPI_FUNC(PyObject *) PyDict_Keys(PyObject *mp); PyAPI_FUNC(PyObject *) PyDict_Values(PyObject *mp); PyAPI_FUNC(PyObject *) PyDict_Items(PyObject *mp); PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp); PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp); PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key); -#ifndef Py_LIMITED_API -/* Get the number of items of a dictionary. */ -#define PyDict_GET_SIZE(mp) (assert(PyDict_Check(mp)),((PyDictObject *)mp)->ma_used) -PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, Py_hash_t hash); -PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused); -PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp); -PyAPI_FUNC(int) _PyDict_HasOnlyStringKeys(PyObject *mp); -Py_ssize_t _PyDict_KeysSize(PyDictKeysObject *keys); -PyAPI_FUNC(Py_ssize_t) _PyDict_SizeOf(PyDictObject *); -PyAPI_FUNC(PyObject *) _PyDict_Pop(PyObject *, PyObject *, PyObject *); -PyObject *_PyDict_Pop_KnownHash(PyObject *, PyObject *, Py_hash_t, PyObject *); -PyObject *_PyDict_FromKeys(PyObject *, PyObject *, PyObject *); -#define _PyDict_HasSplitTable(d) ((d)->ma_values != NULL) - -PyAPI_FUNC(int) PyDict_ClearFreeList(void); -#endif /* PyDict_Update(mp, other) is equivalent to PyDict_Merge(mp, other, 1). */ PyAPI_FUNC(int) PyDict_Update(PyObject *mp, PyObject *other); @@ -133,18 +42,8 @@ PyAPI_FUNC(int) PyDict_Update(PyObject *mp, PyObject *other); dict.update(other) is equivalent to PyDict_Merge(dict, other, 1). */ PyAPI_FUNC(int) PyDict_Merge(PyObject *mp, - PyObject *other, - int override); - -#ifndef Py_LIMITED_API -/* Like PyDict_Merge, but override can be 0, 1 or 2. If override is 0, - the first occurrence of a key wins, if override is 1, the last occurrence - of a key wins, if override is 2, a KeyError with conflicting key as - argument is raised. -*/ -PyAPI_FUNC(int) _PyDict_MergeEx(PyObject *mp, PyObject *other, int override); -PyAPI_FUNC(PyObject *) _PyDictView_Intersect(PyObject* self, PyObject *other); -#endif + PyObject *other, + int override); /* PyDict_MergeFromSeq2 updates/merges from an iterable object producing iterable objects of length 2. If override is true, the last occurrence @@ -152,25 +51,44 @@ PyAPI_FUNC(PyObject *) _PyDictView_Intersect(PyObject* self, PyObject *other); is equivalent to dict={}; PyDict_MergeFromSeq(dict, seq2, 1). */ PyAPI_FUNC(int) PyDict_MergeFromSeq2(PyObject *d, - PyObject *seq2, - int override); + PyObject *seq2, + int override); PyAPI_FUNC(PyObject *) PyDict_GetItemString(PyObject *dp, const char *key); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyDict_GetItemId(PyObject *dp, struct _Py_Identifier *key); -#endif /* !Py_LIMITED_API */ PyAPI_FUNC(int) PyDict_SetItemString(PyObject *dp, const char *key, PyObject *item); -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyDict_SetItemId(PyObject *dp, struct _Py_Identifier *key, PyObject *item); -#endif /* !Py_LIMITED_API */ PyAPI_FUNC(int) PyDict_DelItemString(PyObject *dp, const char *key); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +PyAPI_FUNC(PyObject *) PyObject_GenericGetDict(PyObject *, void *); +#endif -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyDict_DelItemId(PyObject *mp, struct _Py_Identifier *key); -PyAPI_FUNC(void) _PyDict_DebugMallocStats(FILE *out); +/* Dictionary (keys, values, items) views */ -int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject **dictptr, PyObject *name, PyObject *value); -PyObject *_PyDict_LoadGlobal(PyDictObject *, PyDictObject *, PyObject *); +PyAPI_DATA(PyTypeObject) PyDictKeys_Type; +PyAPI_DATA(PyTypeObject) PyDictValues_Type; +PyAPI_DATA(PyTypeObject) PyDictItems_Type; + +#define PyDictKeys_Check(op) PyObject_TypeCheck(op, &PyDictKeys_Type) +#define PyDictValues_Check(op) PyObject_TypeCheck(op, &PyDictValues_Type) +#define PyDictItems_Check(op) PyObject_TypeCheck(op, &PyDictItems_Type) +/* This excludes Values, since they are not sets. */ +# define PyDictViewSet_Check(op) \ + (PyDictKeys_Check(op) || PyDictItems_Check(op)) + +/* Dictionary (key, value, items) iterators */ + +PyAPI_DATA(PyTypeObject) PyDictIterKey_Type; +PyAPI_DATA(PyTypeObject) PyDictIterValue_Type; +PyAPI_DATA(PyTypeObject) PyDictIterItem_Type; + +PyAPI_DATA(PyTypeObject) PyDictRevIterKey_Type; +PyAPI_DATA(PyTypeObject) PyDictRevIterItem_Type; +PyAPI_DATA(PyTypeObject) PyDictRevIterValue_Type; + + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_DICTOBJECT_H +# include "cpython/dictobject.h" +# undef Py_CPYTHON_DICTOBJECT_H #endif #ifdef __cplusplus diff --git a/include/errcode.h b/include/errcode.h index b37cd261..54ae929b 100644 --- a/include/errcode.h +++ b/include/errcode.h @@ -29,8 +29,8 @@ extern "C" { #define E_EOFS 23 /* EOF in triple-quoted string */ #define E_EOLS 24 /* EOL in single-quoted string */ #define E_LINECONT 25 /* Unexpected characters after a line continuation */ -#define E_IDENTIFIER 26 /* Invalid characters in identifier */ #define E_BADSINGLE 27 /* Ill-formed single statement input */ +#define E_INTERACT_STOP 28 /* Interactive mode stopped tokenization */ #ifdef __cplusplus } diff --git a/include/eval.h b/include/eval.h index 2c1c2d05..eda28df8 100644 --- a/include/eval.h +++ b/include/eval.h @@ -18,16 +18,6 @@ PyAPI_FUNC(PyObject *) PyEval_EvalCodeEx(PyObject *co, PyObject *kwdefs, PyObject *closure); #ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyEval_EvalCodeWithName( - PyObject *co, - PyObject *globals, PyObject *locals, - PyObject *const *args, Py_ssize_t argcount, - PyObject *const *kwnames, PyObject *const *kwargs, - Py_ssize_t kwcount, int kwstep, - PyObject *const *defs, Py_ssize_t defcount, - PyObject *kwdefs, PyObject *closure, - PyObject *name, PyObject *qualname); - PyAPI_FUNC(PyObject *) _PyEval_CallTracing(PyObject *func, PyObject *args); #endif diff --git a/include/exports.h b/include/exports.h new file mode 100644 index 00000000..fc1a5c5e --- /dev/null +++ b/include/exports.h @@ -0,0 +1,30 @@ +#ifndef Py_EXPORTS_H +#define Py_EXPORTS_H + +#if defined(_WIN32) || defined(__CYGWIN__) + #define Py_IMPORTED_SYMBOL __declspec(dllimport) + #define Py_EXPORTED_SYMBOL __declspec(dllexport) + #define Py_LOCAL_SYMBOL +#else +/* + * If we only ever used gcc >= 5, we could use __has_attribute(visibility) + * as a cross-platform way to determine if visibility is supported. However, + * we may still need to support gcc >= 4, as some Ubuntu LTS and Centos versions + * have 4 < gcc < 5. + */ + #ifndef __has_attribute + #define __has_attribute(x) 0 // Compatibility with non-clang compilers. + #endif + #if (defined(__GNUC__) && (__GNUC__ >= 4)) ||\ + (defined(__clang__) && __has_attribute(visibility)) + #define Py_IMPORTED_SYMBOL __attribute__ ((visibility ("default"))) + #define Py_EXPORTED_SYMBOL __attribute__ ((visibility ("default"))) + #define Py_LOCAL_SYMBOL __attribute__ ((visibility ("hidden"))) + #else + #define Py_IMPORTED_SYMBOL + #define Py_EXPORTED_SYMBOL + #define Py_LOCAL_SYMBOL + #endif +#endif + +#endif /* Py_EXPORTS_H */ diff --git a/include/fileobject.h b/include/fileobject.h index 89e8dd6a..6ec2994a 100644 --- a/include/fileobject.h +++ b/include/fileobject.h @@ -15,9 +15,6 @@ PyAPI_FUNC(PyObject *) PyFile_GetLine(PyObject *, int); PyAPI_FUNC(int) PyFile_WriteObject(PyObject *, PyObject *, int); PyAPI_FUNC(int) PyFile_WriteString(const char *, PyObject *); PyAPI_FUNC(int) PyObject_AsFileDescriptor(PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(char *) Py_UniversalNewlineFgets(char *, int, FILE*, PyObject *); -#endif /* The default encoding used by the platform file system APIs If non-NULL, this is different than the default encoding for strings @@ -32,15 +29,6 @@ PyAPI_DATA(int) Py_HasFileSystemDefaultEncoding; PyAPI_DATA(int) Py_UTF8Mode; #endif -/* Internal API - - The std printer acts as a preliminary sys.stderr until the new io - infrastructure is in place. */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) PyFile_NewStdPrinter(int); -PyAPI_DATA(PyTypeObject) PyStdPrinter_Type; -#endif /* Py_LIMITED_API */ - /* A routine to check if a file descriptor can be select()-ed. */ #ifdef _MSC_VER /* On Windows, any socket fd can be select()-ed, no matter how high */ @@ -49,6 +37,12 @@ PyAPI_DATA(PyTypeObject) PyStdPrinter_Type; #define _PyIsSelectable_fd(FD) ((unsigned int)(FD) < (unsigned int)FD_SETSIZE) #endif +#ifndef Py_LIMITED_API +# define Py_CPYTHON_FILEOBJECT_H +# include "cpython/fileobject.h" +# undef Py_CPYTHON_FILEOBJECT_H +#endif + #ifdef __cplusplus } #endif diff --git a/include/fileutils.h b/include/fileutils.h index 419d49ab..16f3b635 100644 --- a/include/fileutils.h +++ b/include/fileutils.h @@ -1,6 +1,5 @@ #ifndef Py_FILEUTILS_H #define Py_FILEUTILS_H - #ifdef __cplusplus extern "C" { #endif @@ -13,189 +12,15 @@ PyAPI_FUNC(wchar_t *) Py_DecodeLocale( PyAPI_FUNC(char*) Py_EncodeLocale( const wchar_t *text, size_t *error_pos); - -PyAPI_FUNC(char*) _Py_EncodeLocaleRaw( - const wchar_t *text, - size_t *error_pos); -#endif - -#ifdef Py_BUILD_CORE -PyAPI_FUNC(int) _Py_DecodeUTF8Ex( - const char *arg, - Py_ssize_t arglen, - wchar_t **wstr, - size_t *wlen, - const char **reason, - int surrogateescape); - -PyAPI_FUNC(int) _Py_EncodeUTF8Ex( - const wchar_t *text, - char **str, - size_t *error_pos, - const char **reason, - int raw_malloc, - int surrogateescape); - -PyAPI_FUNC(wchar_t*) _Py_DecodeUTF8_surrogateescape( - const char *arg, - Py_ssize_t arglen); - -PyAPI_FUNC(int) _Py_DecodeLocaleEx( - const char *arg, - wchar_t **wstr, - size_t *wlen, - const char **reason, - int current_locale, - int surrogateescape); - -PyAPI_FUNC(int) _Py_EncodeLocaleEx( - const wchar_t *text, - char **str, - size_t *error_pos, - const char **reason, - int current_locale, - int surrogateescape); #endif #ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _Py_device_encoding(int); - -#if defined(MS_WINDOWS) || defined(__APPLE__) - /* On Windows, the count parameter of read() is an int (bpo-9015, bpo-9611). - On macOS 10.13, read() and write() with more than INT_MAX bytes - fail with EINVAL (bpo-24658). */ -# define _PY_READ_MAX INT_MAX -# define _PY_WRITE_MAX INT_MAX -#else - /* write() should truncate the input to PY_SSIZE_T_MAX bytes, - but it's safer to do it ourself to have a portable behaviour */ -# define _PY_READ_MAX PY_SSIZE_T_MAX -# define _PY_WRITE_MAX PY_SSIZE_T_MAX -#endif - -#ifdef MS_WINDOWS -struct _Py_stat_struct { - unsigned long st_dev; - uint64_t st_ino; - unsigned short st_mode; - int st_nlink; - int st_uid; - int st_gid; - unsigned long st_rdev; - __int64 st_size; - time_t st_atime; - int st_atime_nsec; - time_t st_mtime; - int st_mtime_nsec; - time_t st_ctime; - int st_ctime_nsec; - unsigned long st_file_attributes; -}; -#else -# define _Py_stat_struct stat -#endif - -PyAPI_FUNC(int) _Py_fstat( - int fd, - struct _Py_stat_struct *status); - -PyAPI_FUNC(int) _Py_fstat_noraise( - int fd, - struct _Py_stat_struct *status); - -PyAPI_FUNC(int) _Py_stat( - PyObject *path, - struct stat *status); - -PyAPI_FUNC(int) _Py_open( - const char *pathname, - int flags); - -PyAPI_FUNC(int) _Py_open_noraise( - const char *pathname, - int flags); - -PyAPI_FUNC(FILE *) _Py_wfopen( - const wchar_t *path, - const wchar_t *mode); - -PyAPI_FUNC(FILE*) _Py_fopen( - const char *pathname, - const char *mode); - -PyAPI_FUNC(FILE*) _Py_fopen_obj( - PyObject *path, - const char *mode); - -PyAPI_FUNC(Py_ssize_t) _Py_read( - int fd, - void *buf, - size_t count); - -PyAPI_FUNC(Py_ssize_t) _Py_write( - int fd, - const void *buf, - size_t count); - -PyAPI_FUNC(Py_ssize_t) _Py_write_noraise( - int fd, - const void *buf, - size_t count); - -#ifdef HAVE_READLINK -PyAPI_FUNC(int) _Py_wreadlink( - const wchar_t *path, - wchar_t *buf, - size_t bufsiz); -#endif - -#ifdef HAVE_REALPATH -PyAPI_FUNC(wchar_t*) _Py_wrealpath( - const wchar_t *path, - wchar_t *resolved_path, - size_t resolved_path_size); -#endif - -PyAPI_FUNC(wchar_t*) _Py_wgetcwd( - wchar_t *buf, - size_t size); - -PyAPI_FUNC(int) _Py_get_inheritable(int fd); - -PyAPI_FUNC(int) _Py_set_inheritable(int fd, int inheritable, - int *atomic_flag_works); - -PyAPI_FUNC(int) _Py_set_inheritable_async_safe(int fd, int inheritable, - int *atomic_flag_works); - -PyAPI_FUNC(int) _Py_dup(int fd); - -#ifndef MS_WINDOWS -PyAPI_FUNC(int) _Py_get_blocking(int fd); - -PyAPI_FUNC(int) _Py_set_blocking(int fd, int blocking); -#endif /* !MS_WINDOWS */ - -PyAPI_FUNC(int) _Py_GetLocaleconvNumeric( - PyObject **decimal_point, - PyObject **thousands_sep, - const char **grouping); - -#endif /* Py_LIMITED_API */ - -#ifdef Py_BUILD_CORE -PyAPI_FUNC(int) _Py_GetForceASCII(void); - -/* Reset "force ASCII" mode (if it was initialized). - - This function should be called when Python changes the LC_CTYPE locale, - so the "force ASCII" mode can be detected again on the new locale - encoding. */ -PyAPI_FUNC(void) _Py_ResetForceASCII(void); +# define Py_CPYTHON_FILEUTILS_H +# include "cpython/fileutils.h" +# undef Py_CPYTHON_FILEUTILS_H #endif #ifdef __cplusplus } #endif - #endif /* !Py_FILEUTILS_H */ diff --git a/include/floatobject.h b/include/floatobject.h index f1044d64..e994aa8f 100644 --- a/include/floatobject.h +++ b/include/floatobject.h @@ -21,7 +21,7 @@ typedef struct { PyAPI_DATA(PyTypeObject) PyFloat_Type; #define PyFloat_Check(op) PyObject_TypeCheck(op, &PyFloat_Type) -#define PyFloat_CheckExact(op) (Py_TYPE(op) == &PyFloat_Type) +#define PyFloat_CheckExact(op) Py_IS_TYPE(op, &PyFloat_Type) #ifdef Py_NAN #define Py_RETURN_NAN return PyFloat_FromDouble(Py_NAN) @@ -88,15 +88,6 @@ PyAPI_FUNC(int) _PyFloat_Pack2(double x, unsigned char *p, int le); PyAPI_FUNC(int) _PyFloat_Pack4(double x, unsigned char *p, int le); PyAPI_FUNC(int) _PyFloat_Pack8(double x, unsigned char *p, int le); -/* Needed for the old way for marshal to store a floating point number. - Returns the string length copied into p, -1 on error. - */ -PyAPI_FUNC(int) _PyFloat_Repr(double x, char *p, size_t len); - -/* Used to get the important decimal digits of a double */ -PyAPI_FUNC(int) _PyFloat_Digits(char *buf, double v, int *signum); -PyAPI_FUNC(void) _PyFloat_DigitsInit(void); - /* The unpack routines read 2, 4 or 8 bytes, starting at p. le is a bool * argument, true if the string is in little-endian format (exponent * last, at p+1, p+3 or p+7), false if big-endian (exponent first, at p). @@ -109,9 +100,6 @@ PyAPI_FUNC(double) _PyFloat_Unpack2(const unsigned char *p, int le); PyAPI_FUNC(double) _PyFloat_Unpack4(const unsigned char *p, int le); PyAPI_FUNC(double) _PyFloat_Unpack8(const unsigned char *p, int le); -/* free list api */ -PyAPI_FUNC(int) PyFloat_ClearFreeList(void); - PyAPI_FUNC(void) _PyFloat_DebugMallocStats(FILE* out); /* Format the object based on the format_spec, as defined in PEP 3101 diff --git a/include/frameobject.h b/include/frameobject.h index a95baf88..c118af12 100644 --- a/include/frameobject.h +++ b/include/frameobject.h @@ -1,93 +1,20 @@ - /* Frame object interface */ -#ifndef Py_LIMITED_API #ifndef Py_FRAMEOBJECT_H #define Py_FRAMEOBJECT_H #ifdef __cplusplus extern "C" { #endif -typedef struct { - int b_type; /* what kind of block this is */ - int b_handler; /* where to jump to find handler */ - int b_level; /* value stack level to pop to */ -} PyTryBlock; - -typedef struct _frame { - PyObject_VAR_HEAD - struct _frame *f_back; /* previous frame, or NULL */ - PyCodeObject *f_code; /* code segment */ - PyObject *f_builtins; /* builtin symbol table (PyDictObject) */ - PyObject *f_globals; /* global symbol table (PyDictObject) */ - PyObject *f_locals; /* local symbol table (any mapping) */ - PyObject **f_valuestack; /* points after the last local */ - /* Next free slot in f_valuestack. Frame creation sets to f_valuestack. - Frame evaluation usually NULLs it, but a frame that yields sets it - to the current stack top. */ - PyObject **f_stacktop; - PyObject *f_trace; /* Trace function */ - char f_trace_lines; /* Emit per-line trace events? */ - char f_trace_opcodes; /* Emit per-opcode trace events? */ - - /* Borrowed reference to a generator, or NULL */ - PyObject *f_gen; - - int f_lasti; /* Last instruction if called */ - /* Call PyFrame_GetLineNumber() instead of reading this field - directly. As of 2.3 f_lineno is only valid when tracing is - active (i.e. when f_trace is set). At other times we use - PyCode_Addr2Line to calculate the line from the current - bytecode index. */ - int f_lineno; /* Current line number */ - int f_iblock; /* index in f_blockstack */ - char f_executing; /* whether the frame is still executing */ - PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */ - PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */ -} PyFrameObject; - - -/* Standard object interface */ - -PyAPI_DATA(PyTypeObject) PyFrame_Type; - -#define PyFrame_Check(op) (Py_TYPE(op) == &PyFrame_Type) - -PyAPI_FUNC(PyFrameObject *) PyFrame_New(PyThreadState *, PyCodeObject *, - PyObject *, PyObject *); - -/* only internal use */ -PyFrameObject* _PyFrame_New_NoTrack(PyThreadState *, PyCodeObject *, - PyObject *, PyObject *); - +#include "pyframe.h" -/* The rest of the interface is specific for frame objects */ - -/* Block management functions */ - -PyAPI_FUNC(void) PyFrame_BlockSetup(PyFrameObject *, int, int, int); -PyAPI_FUNC(PyTryBlock *) PyFrame_BlockPop(PyFrameObject *); - -/* Extend the value stack */ - -PyAPI_FUNC(PyObject **) PyFrame_ExtendStack(PyFrameObject *, int, int); - -/* Conversions between "fast locals" and locals in dictionary */ - -PyAPI_FUNC(void) PyFrame_LocalsToFast(PyFrameObject *, int); - -PyAPI_FUNC(int) PyFrame_FastToLocalsWithError(PyFrameObject *f); -PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *); - -PyAPI_FUNC(int) PyFrame_ClearFreeList(void); - -PyAPI_FUNC(void) _PyFrame_DebugMallocStats(FILE *out); - -/* Return the line of code the frame is currently executing. */ -PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *); +#ifndef Py_LIMITED_API +# define Py_CPYTHON_FRAMEOBJECT_H +# include "cpython/frameobject.h" +# undef Py_CPYTHON_FRAMEOBJECT_H +#endif #ifdef __cplusplus } #endif #endif /* !Py_FRAMEOBJECT_H */ -#endif /* Py_LIMITED_API */ diff --git a/include/funcobject.h b/include/funcobject.h index 86674ac9..d7acd18c 100644 --- a/include/funcobject.h +++ b/include/funcobject.h @@ -7,6 +7,21 @@ extern "C" { #endif + +#define COMMON_FIELDS(PREFIX) \ + PyObject *PREFIX ## globals; \ + PyObject *PREFIX ## builtins; \ + PyObject *PREFIX ## name; \ + PyObject *PREFIX ## qualname; \ + PyObject *PREFIX ## code; /* A code object, the __code__ attribute */ \ + PyObject *PREFIX ## defaults; /* NULL or a tuple */ \ + PyObject *PREFIX ## kwdefaults; /* NULL or a dict */ \ + PyObject *PREFIX ## closure; /* NULL or a tuple of cell objects */ + +typedef struct { + COMMON_FIELDS(fc_) +} PyFrameConstructor; + /* Function objects and code objects should not be confused with each other: * * Function objects are created by the execution of the 'def' statement. @@ -20,18 +35,13 @@ extern "C" { typedef struct { PyObject_HEAD - PyObject *func_code; /* A code object, the __code__ attribute */ - PyObject *func_globals; /* A dictionary (other mappings won't do) */ - PyObject *func_defaults; /* NULL or a tuple */ - PyObject *func_kwdefaults; /* NULL or a dict */ - PyObject *func_closure; /* NULL or a tuple of cell objects */ + COMMON_FIELDS(func_) PyObject *func_doc; /* The __doc__ attribute, can be anything */ - PyObject *func_name; /* The __name__ attribute, a string object */ PyObject *func_dict; /* The __dict__ attribute, a dict or NULL */ PyObject *func_weakreflist; /* List of weak references */ PyObject *func_module; /* The __module__ attribute, can be anything */ PyObject *func_annotations; /* Annotations, a dict or NULL */ - PyObject *func_qualname; /* The qualified name */ + vectorcallfunc vectorcall; /* Invariant: * func_closure contains the bindings for func_code->co_freevars, so @@ -42,7 +52,7 @@ typedef struct { PyAPI_DATA(PyTypeObject) PyFunction_Type; -#define PyFunction_Check(op) (Py_TYPE(op) == &PyFunction_Type) +#define PyFunction_Check(op) Py_IS_TYPE(op, &PyFunction_Type) PyAPI_FUNC(PyObject *) PyFunction_New(PyObject *, PyObject *); PyAPI_FUNC(PyObject *) PyFunction_NewWithQualName(PyObject *, PyObject *, PyObject *); @@ -59,16 +69,10 @@ PyAPI_FUNC(PyObject *) PyFunction_GetAnnotations(PyObject *); PyAPI_FUNC(int) PyFunction_SetAnnotations(PyObject *, PyObject *); #ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyFunction_FastCallDict( - PyObject *func, - PyObject *const *args, - Py_ssize_t nargs, - PyObject *kwargs); - -PyAPI_FUNC(PyObject *) _PyFunction_FastCallKeywords( +PyAPI_FUNC(PyObject *) _PyFunction_Vectorcall( PyObject *func, PyObject *const *stack, - Py_ssize_t nargs, + size_t nargsf, PyObject *kwnames); #endif @@ -89,6 +93,9 @@ PyAPI_FUNC(PyObject *) _PyFunction_FastCallKeywords( #define PyFunction_GET_ANNOTATIONS(func) \ (((PyFunctionObject *)func) -> func_annotations) +#define PyFunction_AS_FRAME_CONSTRUCTOR(func) \ + ((PyFrameConstructor *)&((PyFunctionObject *)(func))->func_globals) + /* The classmethod and staticmethod types lives here, too */ PyAPI_DATA(PyTypeObject) PyClassMethod_Type; PyAPI_DATA(PyTypeObject) PyStaticMethod_Type; diff --git a/include/genericaliasobject.h b/include/genericaliasobject.h new file mode 100644 index 00000000..cf002976 --- /dev/null +++ b/include/genericaliasobject.h @@ -0,0 +1,14 @@ +// Implementation of PEP 585: support list[int] etc. +#ifndef Py_GENERICALIASOBJECT_H +#define Py_GENERICALIASOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +PyAPI_FUNC(PyObject *) Py_GenericAlias(PyObject *, PyObject *); +PyAPI_DATA(PyTypeObject) Py_GenericAliasType; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_GENERICALIASOBJECT_H */ diff --git a/include/genobject.h b/include/genobject.h index 16b98333..e965334a 100644 --- a/include/genobject.h +++ b/include/genobject.h @@ -8,16 +8,15 @@ extern "C" { #endif -struct _frame; /* Avoid including frameobject.h */ +#include "pystate.h" /* _PyErr_StackItem */ +#include "abstract.h" /* PySendResult */ /* _PyGenObject_HEAD defines the initial segment of generator and coroutine objects. */ #define _PyGenObject_HEAD(prefix) \ PyObject_HEAD \ /* Note: gi_frame can be NULL if the generator is "finished" */ \ - struct _frame *prefix##_frame; \ - /* True if generator is being executed. */ \ - char prefix##_running; \ + PyFrameObject *prefix##_frame; \ /* The code object backing the generator */ \ PyObject *prefix##_code; \ /* List of weak reference. */ \ @@ -36,15 +35,13 @@ typedef struct { PyAPI_DATA(PyTypeObject) PyGen_Type; #define PyGen_Check(op) PyObject_TypeCheck(op, &PyGen_Type) -#define PyGen_CheckExact(op) (Py_TYPE(op) == &PyGen_Type) +#define PyGen_CheckExact(op) Py_IS_TYPE(op, &PyGen_Type) -PyAPI_FUNC(PyObject *) PyGen_New(struct _frame *); -PyAPI_FUNC(PyObject *) PyGen_NewWithQualName(struct _frame *, +PyAPI_FUNC(PyObject *) PyGen_New(PyFrameObject *); +PyAPI_FUNC(PyObject *) PyGen_NewWithQualName(PyFrameObject *, PyObject *name, PyObject *qualname); -PyAPI_FUNC(int) PyGen_NeedsFinalizing(PyGenObject *); PyAPI_FUNC(int) _PyGen_SetStopIterationValue(PyObject *); PyAPI_FUNC(int) _PyGen_FetchStopIterationValue(PyObject **); -PyAPI_FUNC(PyObject *) _PyGen_Send(PyGenObject *, PyObject *); PyObject *_PyGen_yf(PyGenObject *); PyAPI_FUNC(void) _PyGen_Finalize(PyObject *self); @@ -57,11 +54,9 @@ typedef struct { PyAPI_DATA(PyTypeObject) PyCoro_Type; PyAPI_DATA(PyTypeObject) _PyCoroWrapper_Type; -PyAPI_DATA(PyTypeObject) _PyAIterWrapper_Type; - -#define PyCoro_CheckExact(op) (Py_TYPE(op) == &PyCoro_Type) +#define PyCoro_CheckExact(op) Py_IS_TYPE(op, &PyCoro_Type) PyObject *_PyCoro_GetAwaitableIter(PyObject *o); -PyAPI_FUNC(PyObject *) PyCoro_New(struct _frame *, +PyAPI_FUNC(PyObject *) PyCoro_New(PyFrameObject *, PyObject *name, PyObject *qualname); /* Asynchronous Generators */ @@ -78,6 +73,8 @@ typedef struct { /* Flag is set to 1 when aclose() is called for the first time, or when a StopAsyncIteration exception is raised. */ int ag_closed; + + int ag_running_async; } PyAsyncGenObject; PyAPI_DATA(PyTypeObject) PyAsyncGen_Type; @@ -85,15 +82,13 @@ PyAPI_DATA(PyTypeObject) _PyAsyncGenASend_Type; PyAPI_DATA(PyTypeObject) _PyAsyncGenWrappedValue_Type; PyAPI_DATA(PyTypeObject) _PyAsyncGenAThrow_Type; -PyAPI_FUNC(PyObject *) PyAsyncGen_New(struct _frame *, +PyAPI_FUNC(PyObject *) PyAsyncGen_New(PyFrameObject *, PyObject *name, PyObject *qualname); -#define PyAsyncGen_CheckExact(op) (Py_TYPE(op) == &PyAsyncGen_Type) +#define PyAsyncGen_CheckExact(op) Py_IS_TYPE(op, &PyAsyncGen_Type) PyObject *_PyAsyncGenValueWrapperNew(PyObject *); -int PyAsyncGen_ClearFreeLists(void); - #endif #undef _PyGenObject_HEAD diff --git a/include/graminit.h b/include/graminit.h deleted file mode 100644 index bdfe821a..00000000 --- a/include/graminit.h +++ /dev/null @@ -1,89 +0,0 @@ -/* Generated by Parser/pgen */ - -#define single_input 256 -#define file_input 257 -#define eval_input 258 -#define decorator 259 -#define decorators 260 -#define decorated 261 -#define async_funcdef 262 -#define funcdef 263 -#define parameters 264 -#define typedargslist 265 -#define tfpdef 266 -#define varargslist 267 -#define vfpdef 268 -#define stmt 269 -#define simple_stmt 270 -#define small_stmt 271 -#define expr_stmt 272 -#define annassign 273 -#define testlist_star_expr 274 -#define augassign 275 -#define del_stmt 276 -#define pass_stmt 277 -#define flow_stmt 278 -#define break_stmt 279 -#define continue_stmt 280 -#define return_stmt 281 -#define yield_stmt 282 -#define raise_stmt 283 -#define import_stmt 284 -#define import_name 285 -#define import_from 286 -#define import_as_name 287 -#define dotted_as_name 288 -#define import_as_names 289 -#define dotted_as_names 290 -#define dotted_name 291 -#define global_stmt 292 -#define nonlocal_stmt 293 -#define assert_stmt 294 -#define compound_stmt 295 -#define async_stmt 296 -#define if_stmt 297 -#define while_stmt 298 -#define for_stmt 299 -#define try_stmt 300 -#define with_stmt 301 -#define with_item 302 -#define except_clause 303 -#define suite 304 -#define test 305 -#define test_nocond 306 -#define lambdef 307 -#define lambdef_nocond 308 -#define or_test 309 -#define and_test 310 -#define not_test 311 -#define comparison 312 -#define comp_op 313 -#define star_expr 314 -#define expr 315 -#define xor_expr 316 -#define and_expr 317 -#define shift_expr 318 -#define arith_expr 319 -#define term 320 -#define factor 321 -#define power 322 -#define atom_expr 323 -#define atom 324 -#define testlist_comp 325 -#define trailer 326 -#define subscriptlist 327 -#define subscript 328 -#define sliceop 329 -#define exprlist 330 -#define testlist 331 -#define dictorsetmaker 332 -#define classdef 333 -#define arglist 334 -#define argument 335 -#define comp_iter 336 -#define sync_comp_for 337 -#define comp_for 338 -#define comp_if 339 -#define encoding_decl 340 -#define yield_expr 341 -#define yield_arg 342 diff --git a/include/grammar.h b/include/grammar.h deleted file mode 100644 index e1703f4b..00000000 --- a/include/grammar.h +++ /dev/null @@ -1,94 +0,0 @@ - -/* Grammar interface */ - -#ifndef Py_GRAMMAR_H -#define Py_GRAMMAR_H -#ifdef __cplusplus -extern "C" { -#endif - -#include "bitset.h" /* Sigh... */ - -/* A label of an arc */ - -typedef struct { - int lb_type; - char *lb_str; -} label; - -#define EMPTY 0 /* Label number 0 is by definition the empty label */ - -/* A list of labels */ - -typedef struct { - int ll_nlabels; - label *ll_label; -} labellist; - -/* An arc from one state to another */ - -typedef struct { - short a_lbl; /* Label of this arc */ - short a_arrow; /* State where this arc goes to */ -} arc; - -/* A state in a DFA */ - -typedef struct { - int s_narcs; - arc *s_arc; /* Array of arcs */ - - /* Optional accelerators */ - int s_lower; /* Lowest label index */ - int s_upper; /* Highest label index */ - int *s_accel; /* Accelerator */ - int s_accept; /* Nonzero for accepting state */ -} state; - -/* A DFA */ - -typedef struct { - int d_type; /* Non-terminal this represents */ - char *d_name; /* For printing */ - int d_initial; /* Initial state */ - int d_nstates; - state *d_state; /* Array of states */ - bitset d_first; -} dfa; - -/* A grammar */ - -typedef struct { - int g_ndfas; - dfa *g_dfa; /* Array of DFAs */ - labellist g_ll; - int g_start; /* Start symbol of the grammar */ - int g_accel; /* Set if accelerators present */ -} grammar; - -/* FUNCTIONS */ - -grammar *newgrammar(int start); -void freegrammar(grammar *g); -dfa *adddfa(grammar *g, int type, const char *name); -int addstate(dfa *d); -void addarc(dfa *d, int from, int to, int lbl); -dfa *PyGrammar_FindDFA(grammar *g, int type); - -int addlabel(labellist *ll, int type, const char *str); -int findlabel(labellist *ll, int type, const char *str); -const char *PyGrammar_LabelRepr(label *lb); -void translatelabels(grammar *g); - -void addfirstsets(grammar *g); - -void PyGrammar_AddAccelerators(grammar *g); -void PyGrammar_RemoveAccelerators(grammar *); - -void printgrammar(grammar *g, FILE *fp); -void printnonterminals(grammar *g, FILE *fp); - -#ifdef __cplusplus -} -#endif -#endif /* !Py_GRAMMAR_H */ diff --git a/include/import.h b/include/import.h index c6648034..aeef3efd 100644 --- a/include/import.h +++ b/include/import.h @@ -1,4 +1,3 @@ - /* Module definition and import interface */ #ifndef Py_IMPORT_H @@ -7,11 +6,6 @@ extern "C" { #endif -#ifndef Py_LIMITED_API -PyAPI_FUNC(_PyInitError) _PyImportZip_Init(void); - -PyMODINIT_FUNC PyInit__imp(void); -#endif /* !Py_LIMITED_API */ PyAPI_FUNC(long) PyImport_GetMagicNumber(void); PyAPI_FUNC(const char *) PyImport_GetMagicTag(void); PyAPI_FUNC(PyObject *) PyImport_ExecCodeModule( @@ -41,14 +35,6 @@ PyAPI_FUNC(PyObject *) PyImport_GetModuleDict(void); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 PyAPI_FUNC(PyObject *) PyImport_GetModule(PyObject *name); #endif -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyImport_IsInitialized(PyInterpreterState *); -PyAPI_FUNC(PyObject *) _PyImport_GetModuleId(struct _Py_Identifier *name); -PyAPI_FUNC(PyObject *) _PyImport_AddModuleObject(PyObject *name, - PyObject *modules); -PyAPI_FUNC(int) _PyImport_SetModule(PyObject *name, PyObject *module); -PyAPI_FUNC(int) _PyImport_SetModuleString(const char *name, PyObject* module); -#endif #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject *) PyImport_AddModuleObject( PyObject *name @@ -86,7 +72,6 @@ PyAPI_FUNC(PyObject *) PyImport_ImportModuleLevelObject( PyAPI_FUNC(PyObject *) PyImport_GetImporter(PyObject *path); PyAPI_FUNC(PyObject *) PyImport_Import(PyObject *name); PyAPI_FUNC(PyObject *) PyImport_ReloadModule(PyObject *m); -PyAPI_FUNC(void) PyImport_Cleanup(void); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(int) PyImport_ImportFrozenModuleObject( PyObject *name @@ -96,53 +81,15 @@ PyAPI_FUNC(int) PyImport_ImportFrozenModule( const char *name /* UTF-8 encoded string */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyImport_AcquireLock(void); -PyAPI_FUNC(int) _PyImport_ReleaseLock(void); - -PyAPI_FUNC(void) _PyImport_ReInitLock(void); - -PyAPI_FUNC(PyObject *) _PyImport_FindBuiltin( - const char *name, /* UTF-8 encoded string */ - PyObject *modules - ); -PyAPI_FUNC(PyObject *) _PyImport_FindExtensionObject(PyObject *, PyObject *); -PyAPI_FUNC(PyObject *) _PyImport_FindExtensionObjectEx(PyObject *, PyObject *, - PyObject *); -PyAPI_FUNC(int) _PyImport_FixupBuiltin( - PyObject *mod, - const char *name, /* UTF-8 encoded string */ - PyObject *modules - ); -PyAPI_FUNC(int) _PyImport_FixupExtensionObject(PyObject*, PyObject *, - PyObject *, PyObject *); - -struct _inittab { - const char *name; /* ASCII encoded string */ - PyObject* (*initfunc)(void); -}; -PyAPI_DATA(struct _inittab *) PyImport_Inittab; -PyAPI_FUNC(int) PyImport_ExtendInittab(struct _inittab *newtab); -#endif /* Py_LIMITED_API */ - -PyAPI_DATA(PyTypeObject) PyNullImporter_Type; - PyAPI_FUNC(int) PyImport_AppendInittab( const char *name, /* ASCII encoded string */ PyObject* (*initfunc)(void) ); #ifndef Py_LIMITED_API -struct _frozen { - const char *name; /* ASCII encoded string */ - const unsigned char *code; - int size; -}; - -/* Embedding apps may change this pointer to point to their favorite - collection of frozen modules: */ - -PyAPI_DATA(const struct _frozen *) PyImport_FrozenModules; +# define Py_CPYTHON_IMPORT_H +# include "cpython/import.h" +# undef Py_CPYTHON_IMPORT_H #endif #ifdef __cplusplus diff --git a/include/internal/ceval.h b/include/internal/ceval.h deleted file mode 100644 index cdabb952..00000000 --- a/include/internal/ceval.h +++ /dev/null @@ -1,52 +0,0 @@ -#ifndef Py_INTERNAL_CEVAL_H -#define Py_INTERNAL_CEVAL_H -#ifdef __cplusplus -extern "C" { -#endif - -#include "pyatomic.h" -#include "pythread.h" - -struct _pending_calls { - unsigned long main_thread; - PyThread_type_lock lock; - /* Request for running pending calls. */ - _Py_atomic_int calls_to_do; - /* Request for looking at the `async_exc` field of the current - thread state. - Guarded by the GIL. */ - int async_exc; -#define NPENDINGCALLS 32 - struct { - int (*func)(void *); - void *arg; - } calls[NPENDINGCALLS]; - int first; - int last; -}; - -#include "internal/gil.h" - -struct _ceval_runtime_state { - int recursion_limit; - /* Records whether tracing is on for any thread. Counts the number - of threads for which tstate->c_tracefunc is non-NULL, so if the - value is 0, we know we don't have to check this thread's - c_tracefunc. This speeds up the if statement in - PyEval_EvalFrameEx() after fast_next_opcode. */ - int tracing_possible; - /* This single variable consolidates all requests to break out of - the fast path in the eval loop. */ - _Py_atomic_int eval_breaker; - /* Request for dropping the GIL */ - _Py_atomic_int gil_drop_request; - struct _pending_calls pending; - struct _gil_runtime_state gil; -}; - -PyAPI_FUNC(void) _PyEval_Initialize(struct _ceval_runtime_state *); - -#ifdef __cplusplus -} -#endif -#endif /* !Py_INTERNAL_CEVAL_H */ diff --git a/include/internal/import.h b/include/internal/import.h deleted file mode 100644 index 4746e755..00000000 --- a/include/internal/import.h +++ /dev/null @@ -1,6 +0,0 @@ -#ifndef Py_INTERNAL_IMPORT_H -#define Py_INTERNAL_IMPORT_H - -extern const char *_Py_CheckHashBasedPycsMode; - -#endif diff --git a/include/internal/pycore_abstract.h b/include/internal/pycore_abstract.h new file mode 100644 index 00000000..b791bf24 --- /dev/null +++ b/include/internal/pycore_abstract.h @@ -0,0 +1,22 @@ +#ifndef Py_INTERNAL_ABSTRACT_H +#define Py_INTERNAL_ABSTRACT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +// Fast inlined version of PyIndex_Check() +static inline int +_PyIndex_Check(PyObject *obj) +{ + PyNumberMethods *tp_as_number = Py_TYPE(obj)->tp_as_number; + return (tp_as_number != NULL && tp_as_number->nb_index != NULL); +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_ABSTRACT_H */ diff --git a/include/accu.h b/include/internal/pycore_accu.h similarity index 82% rename from include/accu.h rename to include/internal/pycore_accu.h index 3636ea6c..d346222e 100644 --- a/include/accu.h +++ b/include/internal/pycore_accu.h @@ -1,21 +1,24 @@ #ifndef Py_LIMITED_API -#ifndef Py_ACCU_H -#define Py_ACCU_H +#ifndef Py_INTERNAL_ACCU_H +#define Py_INTERNAL_ACCU_H +#ifdef __cplusplus +extern "C" { +#endif /*** This is a private API for use by the interpreter and the stdlib. *** Its definition may be changed or removed at any moment. ***/ +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + /* * A two-level accumulator of unicode objects that avoids both the overhead * of keeping a huge number of small separate objects, and the quadratic * behaviour of using a naive repeated concatenation scheme. */ -#ifdef __cplusplus -extern "C" { -#endif - #undef small /* defined by some Windows headers */ typedef struct { @@ -32,6 +35,5 @@ PyAPI_FUNC(void) _PyAccu_Destroy(_PyAccu *acc); #ifdef __cplusplus } #endif - -#endif /* Py_ACCU_H */ -#endif /* Py_LIMITED_API */ +#endif /* !Py_INTERNAL_ACCU_H */ +#endif /* !Py_LIMITED_API */ diff --git a/include/internal/pycore_asdl.h b/include/internal/pycore_asdl.h new file mode 100644 index 00000000..c0b07c31 --- /dev/null +++ b/include/internal/pycore_asdl.h @@ -0,0 +1,112 @@ +#ifndef Py_INTERNAL_ASDL_H +#define Py_INTERNAL_ASDL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_pyarena.h" // _PyArena_Malloc() + +typedef PyObject * identifier; +typedef PyObject * string; +typedef PyObject * object; +typedef PyObject * constant; + +/* It would be nice if the code generated by asdl_c.py was completely + independent of Python, but it is a goal the requires too much work + at this stage. So, for example, I'll represent identifiers as + interned Python strings. +*/ + +#define _ASDL_SEQ_HEAD \ + Py_ssize_t size; \ + void **elements; + +typedef struct { + _ASDL_SEQ_HEAD +} asdl_seq; + +typedef struct { + _ASDL_SEQ_HEAD + void *typed_elements[1]; +} asdl_generic_seq; + +typedef struct { + _ASDL_SEQ_HEAD + PyObject *typed_elements[1]; +} asdl_identifier_seq; + +typedef struct { + _ASDL_SEQ_HEAD + int typed_elements[1]; +} asdl_int_seq; + +asdl_generic_seq *_Py_asdl_generic_seq_new(Py_ssize_t size, PyArena *arena); +asdl_identifier_seq *_Py_asdl_identifier_seq_new(Py_ssize_t size, PyArena *arena); +asdl_int_seq *_Py_asdl_int_seq_new(Py_ssize_t size, PyArena *arena); + + +#define GENERATE_ASDL_SEQ_CONSTRUCTOR(NAME, TYPE) \ +asdl_ ## NAME ## _seq *_Py_asdl_ ## NAME ## _seq_new(Py_ssize_t size, PyArena *arena) \ +{ \ + asdl_ ## NAME ## _seq *seq = NULL; \ + size_t n; \ + /* check size is sane */ \ + if (size < 0 || \ + (size && (((size_t)size - 1) > (SIZE_MAX / sizeof(void *))))) { \ + PyErr_NoMemory(); \ + return NULL; \ + } \ + n = (size ? (sizeof(TYPE *) * (size - 1)) : 0); \ + /* check if size can be added safely */ \ + if (n > SIZE_MAX - sizeof(asdl_ ## NAME ## _seq)) { \ + PyErr_NoMemory(); \ + return NULL; \ + } \ + n += sizeof(asdl_ ## NAME ## _seq); \ + seq = (asdl_ ## NAME ## _seq *)_PyArena_Malloc(arena, n); \ + if (!seq) { \ + PyErr_NoMemory(); \ + return NULL; \ + } \ + memset(seq, 0, n); \ + seq->size = size; \ + seq->elements = (void**)seq->typed_elements; \ + return seq; \ +} + +#define asdl_seq_GET_UNTYPED(S, I) (S)->elements[(I)] +#define asdl_seq_GET(S, I) (S)->typed_elements[(I)] +#define asdl_seq_LEN(S) ((S) == NULL ? 0 : (S)->size) + +#ifdef Py_DEBUG +# define asdl_seq_SET(S, I, V) \ + do { \ + Py_ssize_t _asdl_i = (I); \ + assert((S) != NULL); \ + assert(0 <= _asdl_i && _asdl_i < (S)->size); \ + (S)->typed_elements[_asdl_i] = (V); \ + } while (0) +#else +# define asdl_seq_SET(S, I, V) (S)->typed_elements[I] = (V) +#endif + +#ifdef Py_DEBUG +# define asdl_seq_SET_UNTYPED(S, I, V) \ + do { \ + Py_ssize_t _asdl_i = (I); \ + assert((S) != NULL); \ + assert(0 <= _asdl_i && _asdl_i < (S)->size); \ + (S)->elements[_asdl_i] = (V); \ + } while (0) +#else +# define asdl_seq_SET_UNTYPED(S, I, V) (S)->elements[I] = (V) +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_ASDL_H */ diff --git a/include/internal/pycore_ast.h b/include/internal/pycore_ast.h new file mode 100644 index 00000000..ebb6a900 --- /dev/null +++ b/include/internal/pycore_ast.h @@ -0,0 +1,855 @@ +// File automatically generated by Parser/asdl_c.py. + +#ifndef Py_INTERNAL_AST_H +#define Py_INTERNAL_AST_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_asdl.h" + +typedef struct _mod *mod_ty; + +typedef struct _stmt *stmt_ty; + +typedef struct _expr *expr_ty; + +typedef enum _expr_context { Load=1, Store=2, Del=3 } expr_context_ty; + +typedef enum _boolop { And=1, Or=2 } boolop_ty; + +typedef enum _operator { Add=1, Sub=2, Mult=3, MatMult=4, Div=5, Mod=6, Pow=7, + LShift=8, RShift=9, BitOr=10, BitXor=11, BitAnd=12, + FloorDiv=13 } operator_ty; + +typedef enum _unaryop { Invert=1, Not=2, UAdd=3, USub=4 } unaryop_ty; + +typedef enum _cmpop { Eq=1, NotEq=2, Lt=3, LtE=4, Gt=5, GtE=6, Is=7, IsNot=8, + In=9, NotIn=10 } cmpop_ty; + +typedef struct _comprehension *comprehension_ty; + +typedef struct _excepthandler *excepthandler_ty; + +typedef struct _arguments *arguments_ty; + +typedef struct _arg *arg_ty; + +typedef struct _keyword *keyword_ty; + +typedef struct _alias *alias_ty; + +typedef struct _withitem *withitem_ty; + +typedef struct _match_case *match_case_ty; + +typedef struct _pattern *pattern_ty; + +typedef struct _type_ignore *type_ignore_ty; + + +typedef struct { + _ASDL_SEQ_HEAD + mod_ty typed_elements[1]; +} asdl_mod_seq; + +asdl_mod_seq *_Py_asdl_mod_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + stmt_ty typed_elements[1]; +} asdl_stmt_seq; + +asdl_stmt_seq *_Py_asdl_stmt_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + expr_ty typed_elements[1]; +} asdl_expr_seq; + +asdl_expr_seq *_Py_asdl_expr_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + comprehension_ty typed_elements[1]; +} asdl_comprehension_seq; + +asdl_comprehension_seq *_Py_asdl_comprehension_seq_new(Py_ssize_t size, PyArena + *arena); + +typedef struct { + _ASDL_SEQ_HEAD + excepthandler_ty typed_elements[1]; +} asdl_excepthandler_seq; + +asdl_excepthandler_seq *_Py_asdl_excepthandler_seq_new(Py_ssize_t size, PyArena + *arena); + +typedef struct { + _ASDL_SEQ_HEAD + arguments_ty typed_elements[1]; +} asdl_arguments_seq; + +asdl_arguments_seq *_Py_asdl_arguments_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + arg_ty typed_elements[1]; +} asdl_arg_seq; + +asdl_arg_seq *_Py_asdl_arg_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + keyword_ty typed_elements[1]; +} asdl_keyword_seq; + +asdl_keyword_seq *_Py_asdl_keyword_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + alias_ty typed_elements[1]; +} asdl_alias_seq; + +asdl_alias_seq *_Py_asdl_alias_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + withitem_ty typed_elements[1]; +} asdl_withitem_seq; + +asdl_withitem_seq *_Py_asdl_withitem_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + match_case_ty typed_elements[1]; +} asdl_match_case_seq; + +asdl_match_case_seq *_Py_asdl_match_case_seq_new(Py_ssize_t size, PyArena + *arena); + +typedef struct { + _ASDL_SEQ_HEAD + pattern_ty typed_elements[1]; +} asdl_pattern_seq; + +asdl_pattern_seq *_Py_asdl_pattern_seq_new(Py_ssize_t size, PyArena *arena); + +typedef struct { + _ASDL_SEQ_HEAD + type_ignore_ty typed_elements[1]; +} asdl_type_ignore_seq; + +asdl_type_ignore_seq *_Py_asdl_type_ignore_seq_new(Py_ssize_t size, PyArena + *arena); + + +enum _mod_kind {Module_kind=1, Interactive_kind=2, Expression_kind=3, + FunctionType_kind=4}; +struct _mod { + enum _mod_kind kind; + union { + struct { + asdl_stmt_seq *body; + asdl_type_ignore_seq *type_ignores; + } Module; + + struct { + asdl_stmt_seq *body; + } Interactive; + + struct { + expr_ty body; + } Expression; + + struct { + asdl_expr_seq *argtypes; + expr_ty returns; + } FunctionType; + + } v; +}; + +enum _stmt_kind {FunctionDef_kind=1, AsyncFunctionDef_kind=2, ClassDef_kind=3, + Return_kind=4, Delete_kind=5, Assign_kind=6, + AugAssign_kind=7, AnnAssign_kind=8, For_kind=9, + AsyncFor_kind=10, While_kind=11, If_kind=12, With_kind=13, + AsyncWith_kind=14, Match_kind=15, Raise_kind=16, Try_kind=17, + Assert_kind=18, Import_kind=19, ImportFrom_kind=20, + Global_kind=21, Nonlocal_kind=22, Expr_kind=23, Pass_kind=24, + Break_kind=25, Continue_kind=26}; +struct _stmt { + enum _stmt_kind kind; + union { + struct { + identifier name; + arguments_ty args; + asdl_stmt_seq *body; + asdl_expr_seq *decorator_list; + expr_ty returns; + string type_comment; + } FunctionDef; + + struct { + identifier name; + arguments_ty args; + asdl_stmt_seq *body; + asdl_expr_seq *decorator_list; + expr_ty returns; + string type_comment; + } AsyncFunctionDef; + + struct { + identifier name; + asdl_expr_seq *bases; + asdl_keyword_seq *keywords; + asdl_stmt_seq *body; + asdl_expr_seq *decorator_list; + } ClassDef; + + struct { + expr_ty value; + } Return; + + struct { + asdl_expr_seq *targets; + } Delete; + + struct { + asdl_expr_seq *targets; + expr_ty value; + string type_comment; + } Assign; + + struct { + expr_ty target; + operator_ty op; + expr_ty value; + } AugAssign; + + struct { + expr_ty target; + expr_ty annotation; + expr_ty value; + int simple; + } AnnAssign; + + struct { + expr_ty target; + expr_ty iter; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + string type_comment; + } For; + + struct { + expr_ty target; + expr_ty iter; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + string type_comment; + } AsyncFor; + + struct { + expr_ty test; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + } While; + + struct { + expr_ty test; + asdl_stmt_seq *body; + asdl_stmt_seq *orelse; + } If; + + struct { + asdl_withitem_seq *items; + asdl_stmt_seq *body; + string type_comment; + } With; + + struct { + asdl_withitem_seq *items; + asdl_stmt_seq *body; + string type_comment; + } AsyncWith; + + struct { + expr_ty subject; + asdl_match_case_seq *cases; + } Match; + + struct { + expr_ty exc; + expr_ty cause; + } Raise; + + struct { + asdl_stmt_seq *body; + asdl_excepthandler_seq *handlers; + asdl_stmt_seq *orelse; + asdl_stmt_seq *finalbody; + } Try; + + struct { + expr_ty test; + expr_ty msg; + } Assert; + + struct { + asdl_alias_seq *names; + } Import; + + struct { + identifier module; + asdl_alias_seq *names; + int level; + } ImportFrom; + + struct { + asdl_identifier_seq *names; + } Global; + + struct { + asdl_identifier_seq *names; + } Nonlocal; + + struct { + expr_ty value; + } Expr; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +enum _expr_kind {BoolOp_kind=1, NamedExpr_kind=2, BinOp_kind=3, UnaryOp_kind=4, + Lambda_kind=5, IfExp_kind=6, Dict_kind=7, Set_kind=8, + ListComp_kind=9, SetComp_kind=10, DictComp_kind=11, + GeneratorExp_kind=12, Await_kind=13, Yield_kind=14, + YieldFrom_kind=15, Compare_kind=16, Call_kind=17, + FormattedValue_kind=18, JoinedStr_kind=19, Constant_kind=20, + Attribute_kind=21, Subscript_kind=22, Starred_kind=23, + Name_kind=24, List_kind=25, Tuple_kind=26, Slice_kind=27}; +struct _expr { + enum _expr_kind kind; + union { + struct { + boolop_ty op; + asdl_expr_seq *values; + } BoolOp; + + struct { + expr_ty target; + expr_ty value; + } NamedExpr; + + struct { + expr_ty left; + operator_ty op; + expr_ty right; + } BinOp; + + struct { + unaryop_ty op; + expr_ty operand; + } UnaryOp; + + struct { + arguments_ty args; + expr_ty body; + } Lambda; + + struct { + expr_ty test; + expr_ty body; + expr_ty orelse; + } IfExp; + + struct { + asdl_expr_seq *keys; + asdl_expr_seq *values; + } Dict; + + struct { + asdl_expr_seq *elts; + } Set; + + struct { + expr_ty elt; + asdl_comprehension_seq *generators; + } ListComp; + + struct { + expr_ty elt; + asdl_comprehension_seq *generators; + } SetComp; + + struct { + expr_ty key; + expr_ty value; + asdl_comprehension_seq *generators; + } DictComp; + + struct { + expr_ty elt; + asdl_comprehension_seq *generators; + } GeneratorExp; + + struct { + expr_ty value; + } Await; + + struct { + expr_ty value; + } Yield; + + struct { + expr_ty value; + } YieldFrom; + + struct { + expr_ty left; + asdl_int_seq *ops; + asdl_expr_seq *comparators; + } Compare; + + struct { + expr_ty func; + asdl_expr_seq *args; + asdl_keyword_seq *keywords; + } Call; + + struct { + expr_ty value; + int conversion; + expr_ty format_spec; + } FormattedValue; + + struct { + asdl_expr_seq *values; + } JoinedStr; + + struct { + constant value; + string kind; + } Constant; + + struct { + expr_ty value; + identifier attr; + expr_context_ty ctx; + } Attribute; + + struct { + expr_ty value; + expr_ty slice; + expr_context_ty ctx; + } Subscript; + + struct { + expr_ty value; + expr_context_ty ctx; + } Starred; + + struct { + identifier id; + expr_context_ty ctx; + } Name; + + struct { + asdl_expr_seq *elts; + expr_context_ty ctx; + } List; + + struct { + asdl_expr_seq *elts; + expr_context_ty ctx; + } Tuple; + + struct { + expr_ty lower; + expr_ty upper; + expr_ty step; + } Slice; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _comprehension { + expr_ty target; + expr_ty iter; + asdl_expr_seq *ifs; + int is_async; +}; + +enum _excepthandler_kind {ExceptHandler_kind=1}; +struct _excepthandler { + enum _excepthandler_kind kind; + union { + struct { + expr_ty type; + identifier name; + asdl_stmt_seq *body; + } ExceptHandler; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _arguments { + asdl_arg_seq *posonlyargs; + asdl_arg_seq *args; + arg_ty vararg; + asdl_arg_seq *kwonlyargs; + asdl_expr_seq *kw_defaults; + arg_ty kwarg; + asdl_expr_seq *defaults; +}; + +struct _arg { + identifier arg; + expr_ty annotation; + string type_comment; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _keyword { + identifier arg; + expr_ty value; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _alias { + identifier name; + identifier asname; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +struct _withitem { + expr_ty context_expr; + expr_ty optional_vars; +}; + +struct _match_case { + pattern_ty pattern; + expr_ty guard; + asdl_stmt_seq *body; +}; + +enum _pattern_kind {MatchValue_kind=1, MatchSingleton_kind=2, + MatchSequence_kind=3, MatchMapping_kind=4, + MatchClass_kind=5, MatchStar_kind=6, MatchAs_kind=7, + MatchOr_kind=8}; +struct _pattern { + enum _pattern_kind kind; + union { + struct { + expr_ty value; + } MatchValue; + + struct { + constant value; + } MatchSingleton; + + struct { + asdl_pattern_seq *patterns; + } MatchSequence; + + struct { + asdl_expr_seq *keys; + asdl_pattern_seq *patterns; + identifier rest; + } MatchMapping; + + struct { + expr_ty cls; + asdl_pattern_seq *patterns; + asdl_identifier_seq *kwd_attrs; + asdl_pattern_seq *kwd_patterns; + } MatchClass; + + struct { + identifier name; + } MatchStar; + + struct { + pattern_ty pattern; + identifier name; + } MatchAs; + + struct { + asdl_pattern_seq *patterns; + } MatchOr; + + } v; + int lineno; + int col_offset; + int end_lineno; + int end_col_offset; +}; + +enum _type_ignore_kind {TypeIgnore_kind=1}; +struct _type_ignore { + enum _type_ignore_kind kind; + union { + struct { + int lineno; + string tag; + } TypeIgnore; + + } v; +}; + + +// Note: these macros affect function definitions, not only call sites. +mod_ty _PyAST_Module(asdl_stmt_seq * body, asdl_type_ignore_seq * type_ignores, + PyArena *arena); +mod_ty _PyAST_Interactive(asdl_stmt_seq * body, PyArena *arena); +mod_ty _PyAST_Expression(expr_ty body, PyArena *arena); +mod_ty _PyAST_FunctionType(asdl_expr_seq * argtypes, expr_ty returns, PyArena + *arena); +stmt_ty _PyAST_FunctionDef(identifier name, arguments_ty args, asdl_stmt_seq * + body, asdl_expr_seq * decorator_list, expr_ty + returns, string type_comment, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +stmt_ty _PyAST_AsyncFunctionDef(identifier name, arguments_ty args, + asdl_stmt_seq * body, asdl_expr_seq * + decorator_list, expr_ty returns, string + type_comment, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_ClassDef(identifier name, asdl_expr_seq * bases, + asdl_keyword_seq * keywords, asdl_stmt_seq * body, + asdl_expr_seq * decorator_list, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +stmt_ty _PyAST_Return(expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Delete(asdl_expr_seq * targets, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Assign(asdl_expr_seq * targets, expr_ty value, string + type_comment, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_AugAssign(expr_ty target, operator_ty op, expr_ty value, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_AnnAssign(expr_ty target, expr_ty annotation, expr_ty value, int + simple, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_For(expr_ty target, expr_ty iter, asdl_stmt_seq * body, + asdl_stmt_seq * orelse, string type_comment, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +stmt_ty _PyAST_AsyncFor(expr_ty target, expr_ty iter, asdl_stmt_seq * body, + asdl_stmt_seq * orelse, string type_comment, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_While(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * + orelse, int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_If(expr_ty test, asdl_stmt_seq * body, asdl_stmt_seq * orelse, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_With(asdl_withitem_seq * items, asdl_stmt_seq * body, string + type_comment, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_AsyncWith(asdl_withitem_seq * items, asdl_stmt_seq * body, + string type_comment, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Match(expr_ty subject, asdl_match_case_seq * cases, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +stmt_ty _PyAST_Raise(expr_ty exc, expr_ty cause, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Try(asdl_stmt_seq * body, asdl_excepthandler_seq * handlers, + asdl_stmt_seq * orelse, asdl_stmt_seq * finalbody, int + lineno, int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +stmt_ty _PyAST_Assert(expr_ty test, expr_ty msg, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Import(asdl_alias_seq * names, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_ImportFrom(identifier module, asdl_alias_seq * names, int level, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_Global(asdl_identifier_seq * names, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Nonlocal(asdl_identifier_seq * names, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +stmt_ty _PyAST_Expr(expr_ty value, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +stmt_ty _PyAST_Pass(int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_Break(int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +stmt_ty _PyAST_Continue(int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_BoolOp(boolop_ty op, asdl_expr_seq * values, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_NamedExpr(expr_ty target, expr_ty value, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +expr_ty _PyAST_BinOp(expr_ty left, operator_ty op, expr_ty right, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +expr_ty _PyAST_UnaryOp(unaryop_ty op, expr_ty operand, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Lambda(arguments_ty args, expr_ty body, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_IfExp(expr_ty test, expr_ty body, expr_ty orelse, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +expr_ty _PyAST_Dict(asdl_expr_seq * keys, asdl_expr_seq * values, int lineno, + int col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Set(asdl_expr_seq * elts, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_ListComp(expr_ty elt, asdl_comprehension_seq * generators, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_SetComp(expr_ty elt, asdl_comprehension_seq * generators, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_DictComp(expr_ty key, expr_ty value, asdl_comprehension_seq * + generators, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_GeneratorExp(expr_ty elt, asdl_comprehension_seq * generators, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_Await(expr_ty value, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_Yield(expr_ty value, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_YieldFrom(expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_Compare(expr_ty left, asdl_int_seq * ops, asdl_expr_seq * + comparators, int lineno, int col_offset, int end_lineno, + int end_col_offset, PyArena *arena); +expr_ty _PyAST_Call(expr_ty func, asdl_expr_seq * args, asdl_keyword_seq * + keywords, int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_FormattedValue(expr_ty value, int conversion, expr_ty + format_spec, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_JoinedStr(asdl_expr_seq * values, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena *arena); +expr_ty _PyAST_Constant(constant value, string kind, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Attribute(expr_ty value, identifier attr, expr_context_ty ctx, + int lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_Subscript(expr_ty value, expr_ty slice, expr_context_ty ctx, int + lineno, int col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +expr_ty _PyAST_Starred(expr_ty value, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Name(identifier id, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_List(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Tuple(asdl_expr_seq * elts, expr_context_ty ctx, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +expr_ty _PyAST_Slice(expr_ty lower, expr_ty upper, expr_ty step, int lineno, + int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +comprehension_ty _PyAST_comprehension(expr_ty target, expr_ty iter, + asdl_expr_seq * ifs, int is_async, + PyArena *arena); +excepthandler_ty _PyAST_ExceptHandler(expr_ty type, identifier name, + asdl_stmt_seq * body, int lineno, int + col_offset, int end_lineno, int + end_col_offset, PyArena *arena); +arguments_ty _PyAST_arguments(asdl_arg_seq * posonlyargs, asdl_arg_seq * args, + arg_ty vararg, asdl_arg_seq * kwonlyargs, + asdl_expr_seq * kw_defaults, arg_ty kwarg, + asdl_expr_seq * defaults, PyArena *arena); +arg_ty _PyAST_arg(identifier arg, expr_ty annotation, string type_comment, int + lineno, int col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +keyword_ty _PyAST_keyword(identifier arg, expr_ty value, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +alias_ty _PyAST_alias(identifier name, identifier asname, int lineno, int + col_offset, int end_lineno, int end_col_offset, PyArena + *arena); +withitem_ty _PyAST_withitem(expr_ty context_expr, expr_ty optional_vars, + PyArena *arena); +match_case_ty _PyAST_match_case(pattern_ty pattern, expr_ty guard, + asdl_stmt_seq * body, PyArena *arena); +pattern_ty _PyAST_MatchValue(expr_ty value, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +pattern_ty _PyAST_MatchSingleton(constant value, int lineno, int col_offset, + int end_lineno, int end_col_offset, PyArena + *arena); +pattern_ty _PyAST_MatchSequence(asdl_pattern_seq * patterns, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +pattern_ty _PyAST_MatchMapping(asdl_expr_seq * keys, asdl_pattern_seq * + patterns, identifier rest, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +pattern_ty _PyAST_MatchClass(expr_ty cls, asdl_pattern_seq * patterns, + asdl_identifier_seq * kwd_attrs, asdl_pattern_seq + * kwd_patterns, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +pattern_ty _PyAST_MatchStar(identifier name, int lineno, int col_offset, int + end_lineno, int end_col_offset, PyArena *arena); +pattern_ty _PyAST_MatchAs(pattern_ty pattern, identifier name, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +pattern_ty _PyAST_MatchOr(asdl_pattern_seq * patterns, int lineno, int + col_offset, int end_lineno, int end_col_offset, + PyArena *arena); +type_ignore_ty _PyAST_TypeIgnore(int lineno, string tag, PyArena *arena); + + +PyObject* PyAST_mod2obj(mod_ty t); +mod_ty PyAST_obj2mod(PyObject* ast, PyArena* arena, int mode); +int PyAST_Check(PyObject* obj); + +extern int _PyAST_Validate(mod_ty); + +/* _PyAST_ExprAsUnicode is defined in ast_unparse.c */ +extern PyObject* _PyAST_ExprAsUnicode(expr_ty); + +/* Return the borrowed reference to the first literal string in the + sequence of statements or NULL if it doesn't start from a literal string. + Doesn't set exception. */ +extern PyObject* _PyAST_GetDocString(asdl_stmt_seq *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_AST_H */ diff --git a/include/internal/pycore_ast_state.h b/include/internal/pycore_ast_state.h new file mode 100644 index 00000000..882cd09c --- /dev/null +++ b/include/internal/pycore_ast_state.h @@ -0,0 +1,255 @@ +// File automatically generated by Parser/asdl_c.py. + +#ifndef Py_INTERNAL_AST_STATE_H +#define Py_INTERNAL_AST_STATE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +struct ast_state { + int initialized; + PyObject *AST_type; + PyObject *Add_singleton; + PyObject *Add_type; + PyObject *And_singleton; + PyObject *And_type; + PyObject *AnnAssign_type; + PyObject *Assert_type; + PyObject *Assign_type; + PyObject *AsyncFor_type; + PyObject *AsyncFunctionDef_type; + PyObject *AsyncWith_type; + PyObject *Attribute_type; + PyObject *AugAssign_type; + PyObject *Await_type; + PyObject *BinOp_type; + PyObject *BitAnd_singleton; + PyObject *BitAnd_type; + PyObject *BitOr_singleton; + PyObject *BitOr_type; + PyObject *BitXor_singleton; + PyObject *BitXor_type; + PyObject *BoolOp_type; + PyObject *Break_type; + PyObject *Call_type; + PyObject *ClassDef_type; + PyObject *Compare_type; + PyObject *Constant_type; + PyObject *Continue_type; + PyObject *Del_singleton; + PyObject *Del_type; + PyObject *Delete_type; + PyObject *DictComp_type; + PyObject *Dict_type; + PyObject *Div_singleton; + PyObject *Div_type; + PyObject *Eq_singleton; + PyObject *Eq_type; + PyObject *ExceptHandler_type; + PyObject *Expr_type; + PyObject *Expression_type; + PyObject *FloorDiv_singleton; + PyObject *FloorDiv_type; + PyObject *For_type; + PyObject *FormattedValue_type; + PyObject *FunctionDef_type; + PyObject *FunctionType_type; + PyObject *GeneratorExp_type; + PyObject *Global_type; + PyObject *GtE_singleton; + PyObject *GtE_type; + PyObject *Gt_singleton; + PyObject *Gt_type; + PyObject *IfExp_type; + PyObject *If_type; + PyObject *ImportFrom_type; + PyObject *Import_type; + PyObject *In_singleton; + PyObject *In_type; + PyObject *Interactive_type; + PyObject *Invert_singleton; + PyObject *Invert_type; + PyObject *IsNot_singleton; + PyObject *IsNot_type; + PyObject *Is_singleton; + PyObject *Is_type; + PyObject *JoinedStr_type; + PyObject *LShift_singleton; + PyObject *LShift_type; + PyObject *Lambda_type; + PyObject *ListComp_type; + PyObject *List_type; + PyObject *Load_singleton; + PyObject *Load_type; + PyObject *LtE_singleton; + PyObject *LtE_type; + PyObject *Lt_singleton; + PyObject *Lt_type; + PyObject *MatMult_singleton; + PyObject *MatMult_type; + PyObject *MatchAs_type; + PyObject *MatchClass_type; + PyObject *MatchMapping_type; + PyObject *MatchOr_type; + PyObject *MatchSequence_type; + PyObject *MatchSingleton_type; + PyObject *MatchStar_type; + PyObject *MatchValue_type; + PyObject *Match_type; + PyObject *Mod_singleton; + PyObject *Mod_type; + PyObject *Module_type; + PyObject *Mult_singleton; + PyObject *Mult_type; + PyObject *Name_type; + PyObject *NamedExpr_type; + PyObject *Nonlocal_type; + PyObject *NotEq_singleton; + PyObject *NotEq_type; + PyObject *NotIn_singleton; + PyObject *NotIn_type; + PyObject *Not_singleton; + PyObject *Not_type; + PyObject *Or_singleton; + PyObject *Or_type; + PyObject *Pass_type; + PyObject *Pow_singleton; + PyObject *Pow_type; + PyObject *RShift_singleton; + PyObject *RShift_type; + PyObject *Raise_type; + PyObject *Return_type; + PyObject *SetComp_type; + PyObject *Set_type; + PyObject *Slice_type; + PyObject *Starred_type; + PyObject *Store_singleton; + PyObject *Store_type; + PyObject *Sub_singleton; + PyObject *Sub_type; + PyObject *Subscript_type; + PyObject *Try_type; + PyObject *Tuple_type; + PyObject *TypeIgnore_type; + PyObject *UAdd_singleton; + PyObject *UAdd_type; + PyObject *USub_singleton; + PyObject *USub_type; + PyObject *UnaryOp_type; + PyObject *While_type; + PyObject *With_type; + PyObject *YieldFrom_type; + PyObject *Yield_type; + PyObject *__dict__; + PyObject *__doc__; + PyObject *__match_args__; + PyObject *__module__; + PyObject *_attributes; + PyObject *_fields; + PyObject *alias_type; + PyObject *annotation; + PyObject *arg; + PyObject *arg_type; + PyObject *args; + PyObject *argtypes; + PyObject *arguments_type; + PyObject *asname; + PyObject *ast; + PyObject *attr; + PyObject *bases; + PyObject *body; + PyObject *boolop_type; + PyObject *cases; + PyObject *cause; + PyObject *cls; + PyObject *cmpop_type; + PyObject *col_offset; + PyObject *comparators; + PyObject *comprehension_type; + PyObject *context_expr; + PyObject *conversion; + PyObject *ctx; + PyObject *decorator_list; + PyObject *defaults; + PyObject *elt; + PyObject *elts; + PyObject *end_col_offset; + PyObject *end_lineno; + PyObject *exc; + PyObject *excepthandler_type; + PyObject *expr_context_type; + PyObject *expr_type; + PyObject *finalbody; + PyObject *format_spec; + PyObject *func; + PyObject *generators; + PyObject *guard; + PyObject *handlers; + PyObject *id; + PyObject *ifs; + PyObject *is_async; + PyObject *items; + PyObject *iter; + PyObject *key; + PyObject *keys; + PyObject *keyword_type; + PyObject *keywords; + PyObject *kind; + PyObject *kw_defaults; + PyObject *kwarg; + PyObject *kwd_attrs; + PyObject *kwd_patterns; + PyObject *kwonlyargs; + PyObject *left; + PyObject *level; + PyObject *lineno; + PyObject *lower; + PyObject *match_case_type; + PyObject *mod_type; + PyObject *module; + PyObject *msg; + PyObject *name; + PyObject *names; + PyObject *op; + PyObject *operand; + PyObject *operator_type; + PyObject *ops; + PyObject *optional_vars; + PyObject *orelse; + PyObject *pattern; + PyObject *pattern_type; + PyObject *patterns; + PyObject *posonlyargs; + PyObject *rest; + PyObject *returns; + PyObject *right; + PyObject *simple; + PyObject *slice; + PyObject *step; + PyObject *stmt_type; + PyObject *subject; + PyObject *tag; + PyObject *target; + PyObject *targets; + PyObject *test; + PyObject *type; + PyObject *type_comment; + PyObject *type_ignore_type; + PyObject *type_ignores; + PyObject *unaryop_type; + PyObject *upper; + PyObject *value; + PyObject *values; + PyObject *vararg; + PyObject *withitem_type; +}; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_AST_STATE_H */ + diff --git a/include/pyatomic.h b/include/internal/pycore_atomic.h similarity index 78% rename from include/pyatomic.h rename to include/internal/pycore_atomic.h index 9a497a68..3d42e544 100644 --- a/include/pyatomic.h +++ b/include/internal/pycore_atomic.h @@ -1,19 +1,26 @@ #ifndef Py_ATOMIC_H #define Py_ATOMIC_H -#ifdef Py_BUILD_CORE +#ifdef __cplusplus +extern "C" { +#endif -#include "dynamic_annotations.h" +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif +#include "dynamic_annotations.h" /* _Py_ANNOTATE_MEMORY_ORDER */ #include "pyconfig.h" -#if defined(HAVE_STD_ATOMIC) -#include +#ifdef HAVE_STD_ATOMIC +# include #endif #if defined(_MSC_VER) #include -#include +#if defined(_M_IX86) || defined(_M_X64) +# include +#endif #endif /* This is modeled after the atomics interface from C1x, according to @@ -50,12 +57,12 @@ typedef struct _Py_atomic_int { atomic_thread_fence(ORDER) #define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \ - atomic_store_explicit(&(ATOMIC_VAL)->_value, NEW_VAL, ORDER) + atomic_store_explicit(&((ATOMIC_VAL)->_value), NEW_VAL, ORDER) #define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \ - atomic_load_explicit(&(ATOMIC_VAL)->_value, ORDER) + atomic_load_explicit(&((ATOMIC_VAL)->_value), ORDER) -/* Use builtin atomic operations in GCC >= 4.7 */ +// Use builtin atomic operations in GCC >= 4.7 and clang #elif defined(HAVE_BUILTIN_ATOMIC) typedef enum _Py_memory_order { @@ -84,14 +91,14 @@ typedef struct _Py_atomic_int { (assert((ORDER) == __ATOMIC_RELAXED \ || (ORDER) == __ATOMIC_SEQ_CST \ || (ORDER) == __ATOMIC_RELEASE), \ - __atomic_store_n(&(ATOMIC_VAL)->_value, NEW_VAL, ORDER)) + __atomic_store_n(&((ATOMIC_VAL)->_value), NEW_VAL, ORDER)) #define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \ (assert((ORDER) == __ATOMIC_RELAXED \ || (ORDER) == __ATOMIC_SEQ_CST \ || (ORDER) == __ATOMIC_ACQUIRE \ || (ORDER) == __ATOMIC_CONSUME), \ - __atomic_load_n(&(ATOMIC_VAL)->_value, ORDER)) + __atomic_load_n(&((ATOMIC_VAL)->_value), ORDER)) /* Only support GCC (for expression statements) and x86 (for simple * atomic semantics) and MSVC x86/x64/ARM */ @@ -253,13 +260,13 @@ typedef struct _Py_atomic_int { #define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) \ switch (ORDER) { \ case _Py_memory_order_acquire: \ - _InterlockedExchange64_HLEAcquire((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \ + _InterlockedExchange64_HLEAcquire((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)(NEW_VAL)); \ break; \ case _Py_memory_order_release: \ - _InterlockedExchange64_HLERelease((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \ + _InterlockedExchange64_HLERelease((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)(NEW_VAL)); \ break; \ default: \ - _InterlockedExchange64((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \ + _InterlockedExchange64((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)(NEW_VAL)); \ break; \ } #else @@ -269,13 +276,13 @@ typedef struct _Py_atomic_int { #define _Py_atomic_store_32bit(ATOMIC_VAL, NEW_VAL, ORDER) \ switch (ORDER) { \ case _Py_memory_order_acquire: \ - _InterlockedExchange_HLEAcquire((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \ + _InterlockedExchange_HLEAcquire((volatile long*)&((ATOMIC_VAL)->_value), (int)(NEW_VAL)); \ break; \ case _Py_memory_order_release: \ - _InterlockedExchange_HLERelease((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \ + _InterlockedExchange_HLERelease((volatile long*)&((ATOMIC_VAL)->_value), (int)(NEW_VAL)); \ break; \ default: \ - _InterlockedExchange((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \ + _InterlockedExchange((volatile long*)&((ATOMIC_VAL)->_value), (int)(NEW_VAL)); \ break; \ } @@ -284,7 +291,7 @@ typedef struct _Py_atomic_int { gil_created() uses -1 as a sentinel value, if this returns a uintptr_t it will do an unsigned compare and crash */ -inline intptr_t _Py_atomic_load_64bit(volatile uintptr_t* value, int order) { +inline intptr_t _Py_atomic_load_64bit_impl(volatile uintptr_t* value, int order) { __int64 old; switch (order) { case _Py_memory_order_acquire: @@ -315,11 +322,14 @@ inline intptr_t _Py_atomic_load_64bit(volatile uintptr_t* value, int order) { return old; } +#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) \ + _Py_atomic_load_64bit_impl((volatile uintptr_t*)&((ATOMIC_VAL)->_value), (ORDER)) + #else -#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) *ATOMIC_VAL +#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) ((ATOMIC_VAL)->_value) #endif -inline int _Py_atomic_load_32bit(volatile int* value, int order) { +inline int _Py_atomic_load_32bit_impl(volatile int* value, int order) { long old; switch (order) { case _Py_memory_order_acquire: @@ -350,16 +360,19 @@ inline int _Py_atomic_load_32bit(volatile int* value, int order) { return old; } +#define _Py_atomic_load_32bit(ATOMIC_VAL, ORDER) \ + _Py_atomic_load_32bit_impl((volatile int*)&((ATOMIC_VAL)->_value), (ORDER)) + #define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \ - if (sizeof(*ATOMIC_VAL._value) == 8) { \ - _Py_atomic_store_64bit((volatile long long*)ATOMIC_VAL._value, NEW_VAL, ORDER) } else { \ - _Py_atomic_store_32bit((volatile long*)ATOMIC_VAL._value, NEW_VAL, ORDER) } + if (sizeof((ATOMIC_VAL)->_value) == 8) { \ + _Py_atomic_store_64bit((ATOMIC_VAL), NEW_VAL, ORDER) } else { \ + _Py_atomic_store_32bit((ATOMIC_VAL), NEW_VAL, ORDER) } #define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \ ( \ - sizeof(*(ATOMIC_VAL._value)) == 8 ? \ - _Py_atomic_load_64bit((volatile long long*)ATOMIC_VAL._value, ORDER) : \ - _Py_atomic_load_32bit((volatile long*)ATOMIC_VAL._value, ORDER) \ + sizeof((ATOMIC_VAL)->_value) == 8 ? \ + _Py_atomic_load_64bit((ATOMIC_VAL), ORDER) : \ + _Py_atomic_load_32bit((ATOMIC_VAL), ORDER) \ ) #elif defined(_M_ARM) || defined(_M_ARM64) typedef enum _Py_memory_order { @@ -383,13 +396,13 @@ typedef struct _Py_atomic_int { #define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) \ switch (ORDER) { \ case _Py_memory_order_acquire: \ - _InterlockedExchange64_acq((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \ + _InterlockedExchange64_acq((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)NEW_VAL); \ break; \ case _Py_memory_order_release: \ - _InterlockedExchange64_rel((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \ + _InterlockedExchange64_rel((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)NEW_VAL); \ break; \ default: \ - _InterlockedExchange64((__int64 volatile*)ATOMIC_VAL, (__int64)NEW_VAL); \ + _InterlockedExchange64((__int64 volatile*)&((ATOMIC_VAL)->_value), (__int64)NEW_VAL); \ break; \ } #else @@ -399,13 +412,13 @@ typedef struct _Py_atomic_int { #define _Py_atomic_store_32bit(ATOMIC_VAL, NEW_VAL, ORDER) \ switch (ORDER) { \ case _Py_memory_order_acquire: \ - _InterlockedExchange_acq((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \ + _InterlockedExchange_acq((volatile long*)&((ATOMIC_VAL)->_value), (int)NEW_VAL); \ break; \ case _Py_memory_order_release: \ - _InterlockedExchange_rel((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \ + _InterlockedExchange_rel((volatile long*)&((ATOMIC_VAL)->_value), (int)NEW_VAL); \ break; \ default: \ - _InterlockedExchange((volatile long*)ATOMIC_VAL, (int)NEW_VAL); \ + _InterlockedExchange((volatile long*)&((ATOMIC_VAL)->_value), (int)NEW_VAL); \ break; \ } @@ -414,7 +427,7 @@ typedef struct _Py_atomic_int { gil_created() uses -1 as a sentinel value, if this returns a uintptr_t it will do an unsigned compare and crash */ -inline intptr_t _Py_atomic_load_64bit(volatile uintptr_t* value, int order) { +inline intptr_t _Py_atomic_load_64bit_impl(volatile uintptr_t* value, int order) { uintptr_t old; switch (order) { case _Py_memory_order_acquire: @@ -445,11 +458,14 @@ inline intptr_t _Py_atomic_load_64bit(volatile uintptr_t* value, int order) { return old; } +#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) \ + _Py_atomic_load_64bit_impl((volatile uintptr_t*)&((ATOMIC_VAL)->_value), (ORDER)) + #else -#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) *ATOMIC_VAL +#define _Py_atomic_load_64bit(ATOMIC_VAL, ORDER) ((ATOMIC_VAL)->_value) #endif -inline int _Py_atomic_load_32bit(volatile int* value, int order) { +inline int _Py_atomic_load_32bit_impl(volatile int* value, int order) { int old; switch (order) { case _Py_memory_order_acquire: @@ -480,16 +496,19 @@ inline int _Py_atomic_load_32bit(volatile int* value, int order) { return old; } +#define _Py_atomic_load_32bit(ATOMIC_VAL, ORDER) \ + _Py_atomic_load_32bit_impl((volatile int*)&((ATOMIC_VAL)->_value), (ORDER)) + #define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \ - if (sizeof(*ATOMIC_VAL._value) == 8) { \ - _Py_atomic_store_64bit(ATOMIC_VAL._value, NEW_VAL, ORDER) } else { \ - _Py_atomic_store_32bit(ATOMIC_VAL._value, NEW_VAL, ORDER) } + if (sizeof((ATOMIC_VAL)->_value) == 8) { \ + _Py_atomic_store_64bit((ATOMIC_VAL), (NEW_VAL), (ORDER)) } else { \ + _Py_atomic_store_32bit((ATOMIC_VAL), (NEW_VAL), (ORDER)) } #define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \ ( \ - sizeof(*(ATOMIC_VAL._value)) == 8 ? \ - _Py_atomic_load_64bit(ATOMIC_VAL._value, ORDER) : \ - _Py_atomic_load_32bit(ATOMIC_VAL._value, ORDER) \ + sizeof((ATOMIC_VAL)->_value) == 8 ? \ + _Py_atomic_load_64bit((ATOMIC_VAL), (ORDER)) : \ + _Py_atomic_load_32bit((ATOMIC_VAL), (ORDER)) \ ) #endif #else /* !gcc x86 !_msc_ver */ @@ -521,15 +540,18 @@ typedef struct _Py_atomic_int { /* Standardized shortcuts. */ #define _Py_atomic_store(ATOMIC_VAL, NEW_VAL) \ - _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, _Py_memory_order_seq_cst) + _Py_atomic_store_explicit((ATOMIC_VAL), (NEW_VAL), _Py_memory_order_seq_cst) #define _Py_atomic_load(ATOMIC_VAL) \ - _Py_atomic_load_explicit(ATOMIC_VAL, _Py_memory_order_seq_cst) + _Py_atomic_load_explicit((ATOMIC_VAL), _Py_memory_order_seq_cst) /* Python-local extensions */ #define _Py_atomic_store_relaxed(ATOMIC_VAL, NEW_VAL) \ - _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, _Py_memory_order_relaxed) + _Py_atomic_store_explicit((ATOMIC_VAL), (NEW_VAL), _Py_memory_order_relaxed) #define _Py_atomic_load_relaxed(ATOMIC_VAL) \ - _Py_atomic_load_explicit(ATOMIC_VAL, _Py_memory_order_relaxed) -#endif /* Py_BUILD_CORE */ + _Py_atomic_load_explicit((ATOMIC_VAL), _Py_memory_order_relaxed) + +#ifdef __cplusplus +} +#endif #endif /* Py_ATOMIC_H */ diff --git a/include/internal/pycore_atomic_funcs.h b/include/internal/pycore_atomic_funcs.h new file mode 100644 index 00000000..a708789c --- /dev/null +++ b/include/internal/pycore_atomic_funcs.h @@ -0,0 +1,94 @@ +/* Atomic functions: similar to pycore_atomic.h, but don't need + to declare variables as atomic. + + Py_ssize_t type: + + * value = _Py_atomic_size_get(&var) + * _Py_atomic_size_set(&var, value) + + Use sequentially-consistent ordering (__ATOMIC_SEQ_CST memory order): + enforce total ordering with all other atomic functions. +*/ +#ifndef Py_ATOMIC_FUNC_H +#define Py_ATOMIC_FUNC_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#if defined(_MSC_VER) +# include // _InterlockedExchange() +#endif + + +// Use builtin atomic operations in GCC >= 4.7 and clang +#ifdef HAVE_BUILTIN_ATOMIC + +static inline Py_ssize_t _Py_atomic_size_get(Py_ssize_t *var) +{ + return __atomic_load_n(var, __ATOMIC_SEQ_CST); +} + +static inline void _Py_atomic_size_set(Py_ssize_t *var, Py_ssize_t value) +{ + __atomic_store_n(var, value, __ATOMIC_SEQ_CST); +} + +#elif defined(_MSC_VER) + +static inline Py_ssize_t _Py_atomic_size_get(Py_ssize_t *var) +{ +#if SIZEOF_VOID_P == 8 + Py_BUILD_ASSERT(sizeof(__int64) == sizeof(*var)); + volatile __int64 *volatile_var = (volatile __int64 *)var; + __int64 old; + do { + old = *volatile_var; + } while(_InterlockedCompareExchange64(volatile_var, old, old) != old); +#else + Py_BUILD_ASSERT(sizeof(long) == sizeof(*var)); + volatile long *volatile_var = (volatile long *)var; + long old; + do { + old = *volatile_var; + } while(_InterlockedCompareExchange(volatile_var, old, old) != old); +#endif + return old; +} + +static inline void _Py_atomic_size_set(Py_ssize_t *var, Py_ssize_t value) +{ +#if SIZEOF_VOID_P == 8 + Py_BUILD_ASSERT(sizeof(__int64) == sizeof(*var)); + volatile __int64 *volatile_var = (volatile __int64 *)var; + _InterlockedExchange64(volatile_var, value); +#else + Py_BUILD_ASSERT(sizeof(long) == sizeof(*var)); + volatile long *volatile_var = (volatile long *)var; + _InterlockedExchange(volatile_var, value); +#endif +} + +#else +// Fallback implementation using volatile + +static inline Py_ssize_t _Py_atomic_size_get(Py_ssize_t *var) +{ + volatile Py_ssize_t *volatile_var = (volatile Py_ssize_t *)var; + return *volatile_var; +} + +static inline void _Py_atomic_size_set(Py_ssize_t *var, Py_ssize_t value) +{ + volatile Py_ssize_t *volatile_var = (volatile Py_ssize_t *)var; + *volatile_var = value; +} +#endif + +#ifdef __cplusplus +} +#endif +#endif /* Py_ATOMIC_FUNC_H */ diff --git a/include/internal/pycore_bitutils.h b/include/internal/pycore_bitutils.h new file mode 100644 index 00000000..e4aa7a3d --- /dev/null +++ b/include/internal/pycore_bitutils.h @@ -0,0 +1,176 @@ +/* Bit and bytes utilities. + + Bytes swap functions, reverse order of bytes: + + - _Py_bswap16(uint16_t) + - _Py_bswap32(uint32_t) + - _Py_bswap64(uint64_t) +*/ + +#ifndef Py_INTERNAL_BITUTILS_H +#define Py_INTERNAL_BITUTILS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#if defined(__GNUC__) \ + && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) + /* __builtin_bswap16() is available since GCC 4.8, + __builtin_bswap32() is available since GCC 4.3, + __builtin_bswap64() is available since GCC 4.3. */ +# define _PY_HAVE_BUILTIN_BSWAP +#endif + +#ifdef _MSC_VER + /* Get _byteswap_ushort(), _byteswap_ulong(), _byteswap_uint64() */ +# include +#endif + +static inline uint16_t +_Py_bswap16(uint16_t word) +{ +#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap16) + return __builtin_bswap16(word); +#elif defined(_MSC_VER) + Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned short)); + return _byteswap_ushort(word); +#else + // Portable implementation which doesn't rely on circular bit shift + return ( ((word & UINT16_C(0x00FF)) << 8) + | ((word & UINT16_C(0xFF00)) >> 8)); +#endif +} + +static inline uint32_t +_Py_bswap32(uint32_t word) +{ +#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap32) + return __builtin_bswap32(word); +#elif defined(_MSC_VER) + Py_BUILD_ASSERT(sizeof(word) == sizeof(unsigned long)); + return _byteswap_ulong(word); +#else + // Portable implementation which doesn't rely on circular bit shift + return ( ((word & UINT32_C(0x000000FF)) << 24) + | ((word & UINT32_C(0x0000FF00)) << 8) + | ((word & UINT32_C(0x00FF0000)) >> 8) + | ((word & UINT32_C(0xFF000000)) >> 24)); +#endif +} + +static inline uint64_t +_Py_bswap64(uint64_t word) +{ +#if defined(_PY_HAVE_BUILTIN_BSWAP) || _Py__has_builtin(__builtin_bswap64) + return __builtin_bswap64(word); +#elif defined(_MSC_VER) + return _byteswap_uint64(word); +#else + // Portable implementation which doesn't rely on circular bit shift + return ( ((word & UINT64_C(0x00000000000000FF)) << 56) + | ((word & UINT64_C(0x000000000000FF00)) << 40) + | ((word & UINT64_C(0x0000000000FF0000)) << 24) + | ((word & UINT64_C(0x00000000FF000000)) << 8) + | ((word & UINT64_C(0x000000FF00000000)) >> 8) + | ((word & UINT64_C(0x0000FF0000000000)) >> 24) + | ((word & UINT64_C(0x00FF000000000000)) >> 40) + | ((word & UINT64_C(0xFF00000000000000)) >> 56)); +#endif +} + + +// Population count: count the number of 1's in 'x' +// (number of bits set to 1), also known as the hamming weight. +// +// Implementation note. CPUID is not used, to test if x86 POPCNT instruction +// can be used, to keep the implementation simple. For example, Visual Studio +// __popcnt() is not used this reason. The clang and GCC builtin function can +// use the x86 POPCNT instruction if the target architecture has SSE4a or +// newer. +static inline int +_Py_popcount32(uint32_t x) +{ +#if (defined(__clang__) || defined(__GNUC__)) + +#if SIZEOF_INT >= 4 + Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned int)); + return __builtin_popcount(x); +#else + // The C standard guarantees that unsigned long will always be big enough + // to hold a uint32_t value without losing information. + Py_BUILD_ASSERT(sizeof(x) <= sizeof(unsigned long)); + return __builtin_popcountl(x); +#endif + +#else + // 32-bit SWAR (SIMD Within A Register) popcount + + // Binary: 0 1 0 1 ... + const uint32_t M1 = 0x55555555; + // Binary: 00 11 00 11. .. + const uint32_t M2 = 0x33333333; + // Binary: 0000 1111 0000 1111 ... + const uint32_t M4 = 0x0F0F0F0F; + // 256**4 + 256**3 + 256**2 + 256**1 + const uint32_t SUM = 0x01010101; + + // Put count of each 2 bits into those 2 bits + x = x - ((x >> 1) & M1); + // Put count of each 4 bits into those 4 bits + x = (x & M2) + ((x >> 2) & M2); + // Put count of each 8 bits into those 8 bits + x = (x + (x >> 4)) & M4; + // Sum of the 4 byte counts + return (uint32_t)((uint64_t)x * (uint64_t)SUM) >> 24; +#endif +} + + +// Return the index of the most significant 1 bit in 'x'. This is the smallest +// integer k such that x < 2**k. Equivalent to floor(log2(x)) + 1 for x != 0. +static inline int +_Py_bit_length(unsigned long x) +{ +#if (defined(__clang__) || defined(__GNUC__)) + if (x != 0) { + // __builtin_clzl() is available since GCC 3.4. + // Undefined behavior for x == 0. + return (int)sizeof(unsigned long) * 8 - __builtin_clzl(x); + } + else { + return 0; + } +#elif defined(_MSC_VER) + // _BitScanReverse() is documented to search 32 bits. + Py_BUILD_ASSERT(sizeof(unsigned long) <= 4); + unsigned long msb; + if (_BitScanReverse(&msb, x)) { + return (int)msb + 1; + } + else { + return 0; + } +#else + const int BIT_LENGTH_TABLE[32] = { + 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 + }; + int msb = 0; + while (x >= 32) { + msb += 6; + x >>= 6; + } + msb += BIT_LENGTH_TABLE[x]; + return msb; +#endif +} + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_BITUTILS_H */ diff --git a/include/internal/pycore_blocks_output_buffer.h b/include/internal/pycore_blocks_output_buffer.h new file mode 100644 index 00000000..28cf6fba --- /dev/null +++ b/include/internal/pycore_blocks_output_buffer.h @@ -0,0 +1,317 @@ +/* + _BlocksOutputBuffer is used to maintain an output buffer + that has unpredictable size. Suitable for compression/decompression + API (bz2/lzma/zlib) that has stream->next_out and stream->avail_out: + + stream->next_out: point to the next output position. + stream->avail_out: the number of available bytes left in the buffer. + + It maintains a list of bytes object, so there is no overhead of resizing + the buffer. + + Usage: + + 1, Initialize the struct instance like this: + _BlocksOutputBuffer buffer = {.list = NULL}; + Set .list to NULL for _BlocksOutputBuffer_OnError() + + 2, Initialize the buffer use one of these functions: + _BlocksOutputBuffer_InitAndGrow() + _BlocksOutputBuffer_InitWithSize() + + 3, If (avail_out == 0), grow the buffer: + _BlocksOutputBuffer_Grow() + + 4, Get the current outputted data size: + _BlocksOutputBuffer_GetDataSize() + + 5, Finish the buffer, and return a bytes object: + _BlocksOutputBuffer_Finish() + + 6, Clean up the buffer when an error occurred: + _BlocksOutputBuffer_OnError() +*/ + +#ifndef Py_INTERNAL_BLOCKS_OUTPUT_BUFFER_H +#define Py_INTERNAL_BLOCKS_OUTPUT_BUFFER_H +#ifdef __cplusplus +extern "C" { +#endif + +#include "Python.h" + +typedef struct { + // List of bytes objects + PyObject *list; + // Number of whole allocated size + Py_ssize_t allocated; + // Max length of the buffer, negative number means unlimited length. + Py_ssize_t max_length; +} _BlocksOutputBuffer; + +static const char unable_allocate_msg[] = "Unable to allocate output buffer."; + +/* In 32-bit build, the max block size should <= INT32_MAX. */ +#define OUTPUT_BUFFER_MAX_BLOCK_SIZE (256*1024*1024) + +/* Block size sequence */ +#define KB (1024) +#define MB (1024*1024) +static const Py_ssize_t BUFFER_BLOCK_SIZE[] = + { 32*KB, 64*KB, 256*KB, 1*MB, 4*MB, 8*MB, 16*MB, 16*MB, + 32*MB, 32*MB, 32*MB, 32*MB, 64*MB, 64*MB, 128*MB, 128*MB, + OUTPUT_BUFFER_MAX_BLOCK_SIZE }; +#undef KB +#undef MB + +/* According to the block sizes defined by BUFFER_BLOCK_SIZE, the whole + allocated size growth step is: + 1 32 KB +32 KB + 2 96 KB +64 KB + 3 352 KB +256 KB + 4 1.34 MB +1 MB + 5 5.34 MB +4 MB + 6 13.34 MB +8 MB + 7 29.34 MB +16 MB + 8 45.34 MB +16 MB + 9 77.34 MB +32 MB + 10 109.34 MB +32 MB + 11 141.34 MB +32 MB + 12 173.34 MB +32 MB + 13 237.34 MB +64 MB + 14 301.34 MB +64 MB + 15 429.34 MB +128 MB + 16 557.34 MB +128 MB + 17 813.34 MB +256 MB + 18 1069.34 MB +256 MB + 19 1325.34 MB +256 MB + 20 1581.34 MB +256 MB + 21 1837.34 MB +256 MB + 22 2093.34 MB +256 MB + ... +*/ + +/* Initialize the buffer, and grow the buffer. + + max_length: Max length of the buffer, -1 for unlimited length. + + On success, return allocated size (>=0) + On failure, return -1 +*/ +static inline Py_ssize_t +_BlocksOutputBuffer_InitAndGrow(_BlocksOutputBuffer *buffer, + const Py_ssize_t max_length, + void **next_out) +{ + PyObject *b; + Py_ssize_t block_size; + + // ensure .list was set to NULL + assert(buffer->list == NULL); + + // get block size + if (0 <= max_length && max_length < BUFFER_BLOCK_SIZE[0]) { + block_size = max_length; + } else { + block_size = BUFFER_BLOCK_SIZE[0]; + } + + // the first block + b = PyBytes_FromStringAndSize(NULL, block_size); + if (b == NULL) { + return -1; + } + + // create the list + buffer->list = PyList_New(1); + if (buffer->list == NULL) { + Py_DECREF(b); + return -1; + } + PyList_SET_ITEM(buffer->list, 0, b); + + // set variables + buffer->allocated = block_size; + buffer->max_length = max_length; + + *next_out = PyBytes_AS_STRING(b); + return block_size; +} + +/* Initialize the buffer, with an initial size. + + Check block size limit in the outer wrapper function. For example, some libs + accept UINT32_MAX as the maximum block size, then init_size should <= it. + + On success, return allocated size (>=0) + On failure, return -1 +*/ +static inline Py_ssize_t +_BlocksOutputBuffer_InitWithSize(_BlocksOutputBuffer *buffer, + const Py_ssize_t init_size, + void **next_out) +{ + PyObject *b; + + // ensure .list was set to NULL + assert(buffer->list == NULL); + + // the first block + b = PyBytes_FromStringAndSize(NULL, init_size); + if (b == NULL) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return -1; + } + + // create the list + buffer->list = PyList_New(1); + if (buffer->list == NULL) { + Py_DECREF(b); + return -1; + } + PyList_SET_ITEM(buffer->list, 0, b); + + // set variables + buffer->allocated = init_size; + buffer->max_length = -1; + + *next_out = PyBytes_AS_STRING(b); + return init_size; +} + +/* Grow the buffer. The avail_out must be 0, please check it before calling. + + On success, return allocated size (>=0) + On failure, return -1 +*/ +static inline Py_ssize_t +_BlocksOutputBuffer_Grow(_BlocksOutputBuffer *buffer, + void **next_out, + const Py_ssize_t avail_out) +{ + PyObject *b; + const Py_ssize_t list_len = Py_SIZE(buffer->list); + Py_ssize_t block_size; + + // ensure no gaps in the data + if (avail_out != 0) { + PyErr_SetString(PyExc_SystemError, + "avail_out is non-zero in _BlocksOutputBuffer_Grow()."); + return -1; + } + + // get block size + if (list_len < (Py_ssize_t) Py_ARRAY_LENGTH(BUFFER_BLOCK_SIZE)) { + block_size = BUFFER_BLOCK_SIZE[list_len]; + } else { + block_size = BUFFER_BLOCK_SIZE[Py_ARRAY_LENGTH(BUFFER_BLOCK_SIZE) - 1]; + } + + // check max_length + if (buffer->max_length >= 0) { + // if (rest == 0), should not grow the buffer. + Py_ssize_t rest = buffer->max_length - buffer->allocated; + assert(rest > 0); + + // block_size of the last block + if (block_size > rest) { + block_size = rest; + } + } + + // check buffer->allocated overflow + if (block_size > PY_SSIZE_T_MAX - buffer->allocated) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return -1; + } + + // create the block + b = PyBytes_FromStringAndSize(NULL, block_size); + if (b == NULL) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return -1; + } + if (PyList_Append(buffer->list, b) < 0) { + Py_DECREF(b); + return -1; + } + Py_DECREF(b); + + // set variables + buffer->allocated += block_size; + + *next_out = PyBytes_AS_STRING(b); + return block_size; +} + +/* Return the current outputted data size. */ +static inline Py_ssize_t +_BlocksOutputBuffer_GetDataSize(_BlocksOutputBuffer *buffer, + const Py_ssize_t avail_out) +{ + return buffer->allocated - avail_out; +} + +/* Finish the buffer. + + Return a bytes object on success + Return NULL on failure +*/ +static inline PyObject * +_BlocksOutputBuffer_Finish(_BlocksOutputBuffer *buffer, + const Py_ssize_t avail_out) +{ + PyObject *result, *block; + const Py_ssize_t list_len = Py_SIZE(buffer->list); + + // fast path for single block + if ((list_len == 1 && avail_out == 0) || + (list_len == 2 && Py_SIZE(PyList_GET_ITEM(buffer->list, 1)) == avail_out)) + { + block = PyList_GET_ITEM(buffer->list, 0); + Py_INCREF(block); + + Py_CLEAR(buffer->list); + return block; + } + + // final bytes object + result = PyBytes_FromStringAndSize(NULL, buffer->allocated - avail_out); + if (result == NULL) { + PyErr_SetString(PyExc_MemoryError, unable_allocate_msg); + return NULL; + } + + // memory copy + if (list_len > 0) { + char *posi = PyBytes_AS_STRING(result); + + // blocks except the last one + Py_ssize_t i = 0; + for (; i < list_len-1; i++) { + block = PyList_GET_ITEM(buffer->list, i); + memcpy(posi, PyBytes_AS_STRING(block), Py_SIZE(block)); + posi += Py_SIZE(block); + } + // the last block + block = PyList_GET_ITEM(buffer->list, i); + memcpy(posi, PyBytes_AS_STRING(block), Py_SIZE(block) - avail_out); + } else { + assert(Py_SIZE(result) == 0); + } + + Py_CLEAR(buffer->list); + return result; +} + +/* Clean up the buffer when an error occurred. */ +static inline void +_BlocksOutputBuffer_OnError(_BlocksOutputBuffer *buffer) +{ + Py_CLEAR(buffer->list); +} + +#ifdef __cplusplus +} +#endif +#endif /* Py_INTERNAL_BLOCKS_OUTPUT_BUFFER_H */ \ No newline at end of file diff --git a/include/bytes_methods.h b/include/internal/pycore_bytes_methods.h similarity index 97% rename from include/bytes_methods.h rename to include/internal/pycore_bytes_methods.h index 8434a50a..11e8ab20 100644 --- a/include/bytes_methods.h +++ b/include/internal/pycore_bytes_methods.h @@ -2,6 +2,10 @@ #ifndef Py_BYTES_CTYPE_H #define Py_BYTES_CTYPE_H +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + /* * The internal implementation behind PyBytes (bytes) and PyByteArray (bytearray) * methods of the given names, they operate on ASCII byte strings. diff --git a/include/internal/pycore_call.h b/include/internal/pycore_call.h new file mode 100644 index 00000000..f7d856a5 --- /dev/null +++ b/include/internal/pycore_call.h @@ -0,0 +1,39 @@ +#ifndef Py_INTERNAL_CALL_H +#define Py_INTERNAL_CALL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +PyAPI_FUNC(PyObject *) _PyObject_Call_Prepend( + PyThreadState *tstate, + PyObject *callable, + PyObject *obj, + PyObject *args, + PyObject *kwargs); + +PyAPI_FUNC(PyObject *) _PyObject_FastCallDictTstate( + PyThreadState *tstate, + PyObject *callable, + PyObject *const *args, + size_t nargsf, + PyObject *kwargs); + +PyAPI_FUNC(PyObject *) _PyObject_Call( + PyThreadState *tstate, + PyObject *callable, + PyObject *args, + PyObject *kwargs); + +static inline PyObject * +_PyObject_CallNoArgTstate(PyThreadState *tstate, PyObject *func) { + return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL); +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CALL_H */ diff --git a/include/internal/pycore_ceval.h b/include/internal/pycore_ceval.h new file mode 100644 index 00000000..f573c3e5 --- /dev/null +++ b/include/internal/pycore_ceval.h @@ -0,0 +1,114 @@ +#ifndef Py_INTERNAL_CEVAL_H +#define Py_INTERNAL_CEVAL_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Forward declarations */ +struct pyruntimestate; +struct _ceval_runtime_state; + +#include "pycore_interp.h" /* PyInterpreterState.eval_frame */ + +extern void _Py_FinishPendingCalls(PyThreadState *tstate); +extern void _PyEval_InitRuntimeState(struct _ceval_runtime_state *); +extern int _PyEval_InitState(struct _ceval_state *ceval); +extern void _PyEval_FiniState(struct _ceval_state *ceval); +PyAPI_FUNC(void) _PyEval_SignalReceived(PyInterpreterState *interp); +PyAPI_FUNC(int) _PyEval_AddPendingCall( + PyInterpreterState *interp, + int (*func)(void *), + void *arg); +PyAPI_FUNC(void) _PyEval_SignalAsyncExc(PyInterpreterState *interp); +#ifdef HAVE_FORK +extern PyStatus _PyEval_ReInitThreads(PyThreadState *tstate); +#endif +PyAPI_FUNC(void) _PyEval_SetCoroutineOriginTrackingDepth( + PyThreadState *tstate, + int new_depth); + +void _PyEval_Fini(void); + + +extern PyObject* _PyEval_GetBuiltins(PyThreadState *tstate); +extern PyObject *_PyEval_BuiltinsFromGlobals( + PyThreadState *tstate, + PyObject *globals); + + +static inline PyObject* +_PyEval_EvalFrame(PyThreadState *tstate, PyFrameObject *f, int throwflag) +{ + return tstate->interp->eval_frame(tstate, f, throwflag); +} + +extern PyObject * +_PyEval_Vector(PyThreadState *tstate, + PyFrameConstructor *desc, PyObject *locals, + PyObject* const* args, size_t argcount, + PyObject *kwnames); + +#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS +extern int _PyEval_ThreadsInitialized(PyInterpreterState *interp); +#else +extern int _PyEval_ThreadsInitialized(struct pyruntimestate *runtime); +#endif +extern PyStatus _PyEval_InitGIL(PyThreadState *tstate); +extern void _PyEval_FiniGIL(PyInterpreterState *interp); + +extern void _PyEval_ReleaseLock(PyThreadState *tstate); + +extern void _PyEval_DeactivateOpCache(void); + + +/* --- _Py_EnterRecursiveCall() ----------------------------------------- */ + +#ifdef USE_STACKCHECK +/* With USE_STACKCHECK macro defined, trigger stack checks in + _Py_CheckRecursiveCall() on every 64th call to Py_EnterRecursiveCall. */ +static inline int _Py_MakeRecCheck(PyThreadState *tstate) { + return (++tstate->recursion_depth > tstate->interp->ceval.recursion_limit + || ++tstate->stackcheck_counter > 64); +} +#else +static inline int _Py_MakeRecCheck(PyThreadState *tstate) { + return (++tstate->recursion_depth > tstate->interp->ceval.recursion_limit); +} +#endif + +PyAPI_FUNC(int) _Py_CheckRecursiveCall( + PyThreadState *tstate, + const char *where); + +static inline int _Py_EnterRecursiveCall(PyThreadState *tstate, + const char *where) { + return (_Py_MakeRecCheck(tstate) && _Py_CheckRecursiveCall(tstate, where)); +} + +static inline int _Py_EnterRecursiveCall_inline(const char *where) { + PyThreadState *tstate = PyThreadState_GET(); + return _Py_EnterRecursiveCall(tstate, where); +} + +#define Py_EnterRecursiveCall(where) _Py_EnterRecursiveCall_inline(where) + +static inline void _Py_LeaveRecursiveCall(PyThreadState *tstate) { + tstate->recursion_depth--; +} + +static inline void _Py_LeaveRecursiveCall_inline(void) { + PyThreadState *tstate = PyThreadState_GET(); + _Py_LeaveRecursiveCall(tstate); +} + +#define Py_LeaveRecursiveCall() _Py_LeaveRecursiveCall_inline() + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CEVAL_H */ diff --git a/include/internal/pycore_code.h b/include/internal/pycore_code.h new file mode 100644 index 00000000..8ff1863d --- /dev/null +++ b/include/internal/pycore_code.h @@ -0,0 +1,34 @@ +#ifndef Py_INTERNAL_CODE_H +#define Py_INTERNAL_CODE_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + PyObject *ptr; /* Cached pointer (borrowed reference) */ + uint64_t globals_ver; /* ma_version of global dict */ + uint64_t builtins_ver; /* ma_version of builtin dict */ +} _PyOpcache_LoadGlobal; + +typedef struct { + PyTypeObject *type; + Py_ssize_t hint; + unsigned int tp_version_tag; +} _PyOpCodeOpt_LoadAttr; + +struct _PyOpcache { + union { + _PyOpcache_LoadGlobal lg; + _PyOpCodeOpt_LoadAttr la; + } u; + char optimized; +}; + +/* Private API */ +int _PyCode_InitOpcache(PyCodeObject *co); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CODE_H */ diff --git a/include/internal/pycore_compile.h b/include/internal/pycore_compile.h new file mode 100644 index 00000000..06a6082c --- /dev/null +++ b/include/internal/pycore_compile.h @@ -0,0 +1,44 @@ +#ifndef Py_INTERNAL_COMPILE_H +#define Py_INTERNAL_COMPILE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +struct _arena; // Type defined in pycore_pyarena.h +struct _mod; // Type defined in pycore_ast.h + +// Export the symbol for test_peg_generator (built as a library) +PyAPI_FUNC(PyCodeObject*) _PyAST_Compile( + struct _mod *mod, + PyObject *filename, + PyCompilerFlags *flags, + int optimize, + struct _arena *arena); +extern PyFutureFeatures* _PyFuture_FromAST( + struct _mod * mod, + PyObject *filename + ); + +extern PyObject* _Py_Mangle(PyObject *p, PyObject *name); + +typedef struct { + int optimize; + int ff_features; + + int recursion_depth; /* current recursion depth */ + int recursion_limit; /* recursion limit */ +} _PyASTOptimizeState; + +extern int _PyAST_Optimize( + struct _mod *, + struct _arena *arena, + _PyASTOptimizeState *state); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_COMPILE_H */ diff --git a/include/internal/condvar.h b/include/internal/pycore_condvar.h similarity index 97% rename from include/internal/condvar.h rename to include/internal/pycore_condvar.h index f9330890..8b89d709 100644 --- a/include/internal/condvar.h +++ b/include/internal/pycore_condvar.h @@ -1,6 +1,10 @@ #ifndef Py_INTERNAL_CONDVAR_H #define Py_INTERNAL_CONDVAR_H +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + #ifndef _POSIX_THREADS /* This means pthreads are not implemented in libc headers, hence the macro not present in unistd.h. But they still can be implemented as an external diff --git a/include/internal/context.h b/include/internal/pycore_context.h similarity index 78% rename from include/internal/context.h rename to include/internal/pycore_context.h index 59f88f26..a482dd42 100644 --- a/include/internal/context.h +++ b/include/internal/pycore_context.h @@ -1,9 +1,11 @@ #ifndef Py_INTERNAL_CONTEXT_H #define Py_INTERNAL_CONTEXT_H +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif -#include "internal/hamt.h" - +#include "pycore_hamt.h" /* PyHamtObject */ struct _pycontextobject { PyObject_HEAD @@ -35,7 +37,6 @@ struct _pycontexttokenobject { int _PyContext_Init(void); -void _PyContext_Fini(void); - +void _PyContext_Fini(PyInterpreterState *interp); #endif /* !Py_INTERNAL_CONTEXT_H */ diff --git a/include/dtoa.h b/include/internal/pycore_dtoa.h similarity index 66% rename from include/dtoa.h rename to include/internal/pycore_dtoa.h index 9bfb6251..3faf8cf6 100644 --- a/include/dtoa.h +++ b/include/internal/pycore_dtoa.h @@ -1,9 +1,15 @@ -#ifndef Py_LIMITED_API #ifndef PY_NO_SHORT_FLOAT_REPR #ifdef __cplusplus extern "C" { #endif +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* These functions are used by modules compiled as C extension like math: + they must be exported. */ + PyAPI_FUNC(double) _Py_dg_strtod(const char *str, char **ptr); PyAPI_FUNC(char *) _Py_dg_dtoa(double d, int mode, int ndigits, int *decpt, int *sign, char **rve); @@ -11,9 +17,7 @@ PyAPI_FUNC(void) _Py_dg_freedtoa(char *s); PyAPI_FUNC(double) _Py_dg_stdnan(int sign); PyAPI_FUNC(double) _Py_dg_infinity(int sign); - #ifdef __cplusplus } #endif -#endif -#endif +#endif /* !PY_NO_SHORT_FLOAT_REPR */ diff --git a/include/internal/pycore_fileutils.h b/include/internal/pycore_fileutils.h new file mode 100644 index 00000000..c1c9244a --- /dev/null +++ b/include/internal/pycore_fileutils.h @@ -0,0 +1,71 @@ +#ifndef Py_INTERNAL_FILEUTILS_H +#define Py_INTERNAL_FILEUTILS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "Py_BUILD_CORE must be defined to include this header" +#endif + +#include /* struct lconv */ + +PyAPI_DATA(int) _Py_HasFileSystemDefaultEncodeErrors; + +PyAPI_FUNC(int) _Py_DecodeUTF8Ex( + const char *arg, + Py_ssize_t arglen, + wchar_t **wstr, + size_t *wlen, + const char **reason, + _Py_error_handler errors); + +PyAPI_FUNC(int) _Py_EncodeUTF8Ex( + const wchar_t *text, + char **str, + size_t *error_pos, + const char **reason, + int raw_malloc, + _Py_error_handler errors); + +PyAPI_FUNC(wchar_t*) _Py_DecodeUTF8_surrogateescape( + const char *arg, + Py_ssize_t arglen, + size_t *wlen); + +PyAPI_FUNC(int) _Py_GetForceASCII(void); + +/* Reset "force ASCII" mode (if it was initialized). + + This function should be called when Python changes the LC_CTYPE locale, + so the "force ASCII" mode can be detected again on the new locale + encoding. */ +PyAPI_FUNC(void) _Py_ResetForceASCII(void); + + +PyAPI_FUNC(int) _Py_GetLocaleconvNumeric( + struct lconv *lc, + PyObject **decimal_point, + PyObject **thousands_sep); + +PyAPI_FUNC(void) _Py_closerange(int first, int last); + +PyAPI_FUNC(wchar_t*) _Py_GetLocaleEncoding(void); +PyAPI_FUNC(PyObject*) _Py_GetLocaleEncodingObject(void); + +#ifdef HAVE_NON_UNICODE_WCHAR_T_REPRESENTATION +extern int _Py_LocaleUsesNonUnicodeWchar(void); + +extern wchar_t* _Py_DecodeNonUnicodeWchar( + const wchar_t* native, + Py_ssize_t size); + +extern int _Py_EncodeNonUnicodeWchar_InPlace( + wchar_t* unicode, + Py_ssize_t size); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FILEUTILS_H */ diff --git a/include/internal/pycore_format.h b/include/internal/pycore_format.h new file mode 100644 index 00000000..1b8d5753 --- /dev/null +++ b/include/internal/pycore_format.h @@ -0,0 +1,27 @@ +#ifndef Py_INTERNAL_FORMAT_H +#define Py_INTERNAL_FORMAT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Format codes + * F_LJUST '-' + * F_SIGN '+' + * F_BLANK ' ' + * F_ALT '#' + * F_ZERO '0' + */ +#define F_LJUST (1<<0) +#define F_SIGN (1<<1) +#define F_BLANK (1<<2) +#define F_ALT (1<<3) +#define F_ZERO (1<<4) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_FORMAT_H */ diff --git a/include/internal/mem.h b/include/internal/pycore_gc.h similarity index 58% rename from include/internal/mem.h rename to include/internal/pycore_gc.h index 5896e4a0..9db4a471 100644 --- a/include/internal/mem.h +++ b/include/internal/pycore_gc.h @@ -1,11 +1,67 @@ -#ifndef Py_INTERNAL_MEM_H -#define Py_INTERNAL_MEM_H +#ifndef Py_INTERNAL_GC_H +#define Py_INTERNAL_GC_H #ifdef __cplusplus extern "C" { #endif -#include "objimpl.h" -#include "pymem.h" +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* GC information is stored BEFORE the object structure. */ +typedef struct { + // Pointer to next object in the list. + // 0 means the object is not tracked + uintptr_t _gc_next; + + // Pointer to previous object in the list. + // Lowest two bits are used for flags documented later. + uintptr_t _gc_prev; +} PyGC_Head; + +#define _Py_AS_GC(o) ((PyGC_Head *)(o)-1) + +/* True if the object is currently tracked by the GC. */ +#define _PyObject_GC_IS_TRACKED(o) (_Py_AS_GC(o)->_gc_next != 0) + +/* True if the object may be tracked by the GC in the future, or already is. + This can be useful to implement some optimizations. */ +#define _PyObject_GC_MAY_BE_TRACKED(obj) \ + (PyObject_IS_GC(obj) && \ + (!PyTuple_CheckExact(obj) || _PyObject_GC_IS_TRACKED(obj))) + + +/* Bit flags for _gc_prev */ +/* Bit 0 is set when tp_finalize is called */ +#define _PyGC_PREV_MASK_FINALIZED (1) +/* Bit 1 is set when the object is in generation which is GCed currently. */ +#define _PyGC_PREV_MASK_COLLECTING (2) +/* The (N-2) most significant bits contain the real address. */ +#define _PyGC_PREV_SHIFT (2) +#define _PyGC_PREV_MASK (((uintptr_t) -1) << _PyGC_PREV_SHIFT) + +// Lowest bit of _gc_next is used for flags only in GC. +// But it is always 0 for normal code. +#define _PyGCHead_NEXT(g) ((PyGC_Head*)(g)->_gc_next) +#define _PyGCHead_SET_NEXT(g, p) ((g)->_gc_next = (uintptr_t)(p)) + +// Lowest two bits of _gc_prev is used for _PyGC_PREV_MASK_* flags. +#define _PyGCHead_PREV(g) ((PyGC_Head*)((g)->_gc_prev & _PyGC_PREV_MASK)) +#define _PyGCHead_SET_PREV(g, p) do { \ + assert(((uintptr_t)p & ~_PyGC_PREV_MASK) == 0); \ + (g)->_gc_prev = ((g)->_gc_prev & ~_PyGC_PREV_MASK) \ + | ((uintptr_t)(p)); \ + } while (0) + +#define _PyGCHead_FINALIZED(g) \ + (((g)->_gc_prev & _PyGC_PREV_MASK_FINALIZED) != 0) +#define _PyGCHead_SET_FINALIZED(g) \ + ((g)->_gc_prev |= _PyGC_PREV_MASK_FINALIZED) + +#define _PyGC_FINALIZED(o) \ + _PyGCHead_FINALIZED(_Py_AS_GC(o)) +#define _PyGC_SET_FINALIZED(o) \ + _PyGCHead_SET_FINALIZED(_Py_AS_GC(o)) /* GC runtime state */ @@ -13,42 +69,6 @@ extern "C" { /* If we change this, we need to change the default value in the signature of gc.collect. */ #define NUM_GENERATIONS 3 - -/* - NOTE: about the counting of long-lived objects. - - To limit the cost of garbage collection, there are two strategies; - - make each collection faster, e.g. by scanning fewer objects - - do less collections - This heuristic is about the latter strategy. - - In addition to the various configurable thresholds, we only trigger a - full collection if the ratio - long_lived_pending / long_lived_total - is above a given value (hardwired to 25%). - - The reason is that, while "non-full" collections (i.e., collections of - the young and middle generations) will always examine roughly the same - number of objects -- determined by the aforementioned thresholds --, - the cost of a full collection is proportional to the total number of - long-lived objects, which is virtually unbounded. - - Indeed, it has been remarked that doing a full collection every - of object creations entails a dramatic performance - degradation in workloads which consist in creating and storing lots of - long-lived objects (e.g. building a large list of GC-tracked objects would - show quadratic performance, instead of linear as expected: see issue #4074). - - Using the above ratio, instead, yields amortized linear performance in - the total number of objects (the effect of which can be summarized - thusly: "each full garbage collection is more and more costly as the - number of objects grows, but we do fewer and fewer of them"). - - This heuristic was suggested by Martin von Löwis on python-dev in - June 2008. His original analysis and proposal can be found at: - http://mail.python.org/pipermail/python-dev/2008-June/080579.html -*/ - /* NOTE: about untracking of mutable objects. @@ -141,35 +161,21 @@ struct _gc_runtime_state { Py_ssize_t long_lived_pending; }; -PyAPI_FUNC(void) _PyGC_Initialize(struct _gc_runtime_state *); - -#define _PyGC_generation0 _PyRuntime.gc.generation0 - -/* Heuristic checking if a pointer value is newly allocated - (uninitialized) or newly freed. The pointer is not dereferenced, only the - pointer value is checked. - - The heuristic relies on the debug hooks on Python memory allocators which - fills newly allocated memory with CLEANBYTE (0xCD) and newly freed memory - with DEADBYTE (0xDD). Detect also "untouchable bytes" marked - with FORBIDDENBYTE (0xFD). */ -static inline int _PyMem_IsPtrFreed(void *ptr) -{ - uintptr_t value = (uintptr_t)ptr; -#if SIZEOF_VOID_P == 8 - return (value == (uintptr_t)0xCDCDCDCDCDCDCDCD - || value == (uintptr_t)0xDDDDDDDDDDDDDDDD - || value == (uintptr_t)0xFDFDFDFDFDFDFDFD); -#elif SIZEOF_VOID_P == 4 - return (value == (uintptr_t)0xCDCDCDCD - || value == (uintptr_t)0xDDDDDDDD - || value == (uintptr_t)0xFDFDFDFD); -#else -# error "unknown pointer size" -#endif -} +extern void _PyGC_InitState(struct _gc_runtime_state *); + +extern Py_ssize_t _PyGC_CollectNoFail(PyThreadState *tstate); + + +// Functions to clear types free lists +extern void _PyFrame_ClearFreeList(PyInterpreterState *interp); +extern void _PyTuple_ClearFreeList(PyInterpreterState *interp); +extern void _PyFloat_ClearFreeList(PyInterpreterState *interp); +extern void _PyList_ClearFreeList(PyInterpreterState *interp); +extern void _PyDict_ClearFreeList(PyInterpreterState *interp); +extern void _PyAsyncGen_ClearFreeLists(PyInterpreterState *interp); +extern void _PyContext_ClearFreeList(PyInterpreterState *interp); #ifdef __cplusplus } #endif -#endif /* !Py_INTERNAL_MEM_H */ +#endif /* !Py_INTERNAL_GC_H */ diff --git a/include/internal/pygetopt.h b/include/internal/pycore_getopt.h similarity index 52% rename from include/internal/pygetopt.h rename to include/internal/pycore_getopt.h index 8ef2ada7..7f0dd13a 100644 --- a/include/internal/pygetopt.h +++ b/include/internal/pycore_getopt.h @@ -1,9 +1,13 @@ #ifndef Py_INTERNAL_PYGETOPT_H #define Py_INTERNAL_PYGETOPT_H +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + extern int _PyOS_opterr; -extern int _PyOS_optind; -extern wchar_t *_PyOS_optarg; +extern Py_ssize_t _PyOS_optind; +extern const wchar_t *_PyOS_optarg; extern void _PyOS_ResetGetOpt(void); @@ -13,7 +17,6 @@ typedef struct { int val; } _PyOS_LongOption; -extern int _PyOS_GetOpt(int argc, wchar_t **argv, wchar_t *optstring, - const _PyOS_LongOption *longopts, int *longindex); +extern int _PyOS_GetOpt(Py_ssize_t argc, wchar_t * const *argv, int *longindex); #endif /* !Py_INTERNAL_PYGETOPT_H */ diff --git a/include/internal/gil.h b/include/internal/pycore_gil.h similarity index 84% rename from include/internal/gil.h rename to include/internal/pycore_gil.h index 6139bd21..8ebad37b 100644 --- a/include/internal/gil.h +++ b/include/internal/pycore_gil.h @@ -4,11 +4,15 @@ extern "C" { #endif -#include "pyatomic.h" +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_atomic.h" /* _Py_atomic_address */ +#include "pycore_condvar.h" /* PyCOND_T */ -#include "internal/condvar.h" #ifndef Py_HAVE_CONDVAR -#error You need either a POSIX-compatible or a Windows system! +# error You need either a POSIX-compatible or a Windows system! #endif /* Enable if you want to force the switching of threads at least diff --git a/include/internal/hamt.h b/include/internal/pycore_hamt.h similarity index 80% rename from include/internal/hamt.h rename to include/internal/pycore_hamt.h index 29ad28b1..357d9661 100644 --- a/include/internal/hamt.h +++ b/include/internal/pycore_hamt.h @@ -1,11 +1,26 @@ #ifndef Py_INTERNAL_HAMT_H #define Py_INTERNAL_HAMT_H +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif -#define _Py_HAMT_MAX_TREE_DEPTH 7 +/* +HAMT tree is shaped by hashes of keys. Every group of 5 bits of a hash denotes +the exact position of the key in one level of the tree. Since we're using +32 bit hashes, we can have at most 7 such levels. Although if there are +two distinct keys with equal hashes, they will have to occupy the same +cell in the 7th level of the tree -- so we'd put them in a "collision" node. +Which brings the total possible tree depth to 8. Read more about the actual +layout of the HAMT tree in `hamt.c`. -#define PyHamt_Check(o) (Py_TYPE(o) == &_PyHamt_Type) +This constant is used to define a datastucture for storing iteration state. +*/ +#define _Py_HAMT_MAX_TREE_DEPTH 8 + + +#define PyHamt_Check(o) Py_IS_TYPE(o, &_PyHamt_Type) /* Abstract tree node. */ diff --git a/include/internal/pycore_hashtable.h b/include/internal/pycore_hashtable.h new file mode 100644 index 00000000..18757abc --- /dev/null +++ b/include/internal/pycore_hashtable.h @@ -0,0 +1,148 @@ +#ifndef Py_INTERNAL_HASHTABLE_H +#define Py_INTERNAL_HASHTABLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Single linked list */ + +typedef struct _Py_slist_item_s { + struct _Py_slist_item_s *next; +} _Py_slist_item_t; + +typedef struct { + _Py_slist_item_t *head; +} _Py_slist_t; + +#define _Py_SLIST_ITEM_NEXT(ITEM) (((_Py_slist_item_t *)ITEM)->next) + +#define _Py_SLIST_HEAD(SLIST) (((_Py_slist_t *)SLIST)->head) + + +/* _Py_hashtable: table entry */ + +typedef struct { + /* used by _Py_hashtable_t.buckets to link entries */ + _Py_slist_item_t _Py_slist_item; + + Py_uhash_t key_hash; + void *key; + void *value; +} _Py_hashtable_entry_t; + + +/* _Py_hashtable: prototypes */ + +/* Forward declaration */ +struct _Py_hashtable_t; +typedef struct _Py_hashtable_t _Py_hashtable_t; + +typedef Py_uhash_t (*_Py_hashtable_hash_func) (const void *key); +typedef int (*_Py_hashtable_compare_func) (const void *key1, const void *key2); +typedef void (*_Py_hashtable_destroy_func) (void *key); +typedef _Py_hashtable_entry_t* (*_Py_hashtable_get_entry_func)(_Py_hashtable_t *ht, + const void *key); + +typedef struct { + // Allocate a memory block + void* (*malloc) (size_t size); + + // Release a memory block + void (*free) (void *ptr); +} _Py_hashtable_allocator_t; + + +/* _Py_hashtable: table */ +struct _Py_hashtable_t { + size_t nentries; // Total number of entries in the table + size_t nbuckets; + _Py_slist_t *buckets; + + _Py_hashtable_get_entry_func get_entry_func; + _Py_hashtable_hash_func hash_func; + _Py_hashtable_compare_func compare_func; + _Py_hashtable_destroy_func key_destroy_func; + _Py_hashtable_destroy_func value_destroy_func; + _Py_hashtable_allocator_t alloc; +}; + +/* Hash a pointer (void*) */ +PyAPI_FUNC(Py_uhash_t) _Py_hashtable_hash_ptr(const void *key); + +/* Comparison using memcmp() */ +PyAPI_FUNC(int) _Py_hashtable_compare_direct( + const void *key1, + const void *key2); + +PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new( + _Py_hashtable_hash_func hash_func, + _Py_hashtable_compare_func compare_func); + +PyAPI_FUNC(_Py_hashtable_t *) _Py_hashtable_new_full( + _Py_hashtable_hash_func hash_func, + _Py_hashtable_compare_func compare_func, + _Py_hashtable_destroy_func key_destroy_func, + _Py_hashtable_destroy_func value_destroy_func, + _Py_hashtable_allocator_t *allocator); + +PyAPI_FUNC(void) _Py_hashtable_destroy(_Py_hashtable_t *ht); + +PyAPI_FUNC(void) _Py_hashtable_clear(_Py_hashtable_t *ht); + +typedef int (*_Py_hashtable_foreach_func) (_Py_hashtable_t *ht, + const void *key, const void *value, + void *user_data); + +/* Call func() on each entry of the hashtable. + Iteration stops if func() result is non-zero, in this case it's the result + of the call. Otherwise, the function returns 0. */ +PyAPI_FUNC(int) _Py_hashtable_foreach( + _Py_hashtable_t *ht, + _Py_hashtable_foreach_func func, + void *user_data); + +PyAPI_FUNC(size_t) _Py_hashtable_size(const _Py_hashtable_t *ht); + +/* Add a new entry to the hash. The key must not be present in the hash table. + Return 0 on success, -1 on memory error. */ +PyAPI_FUNC(int) _Py_hashtable_set( + _Py_hashtable_t *ht, + const void *key, + void *value); + + +/* Get an entry. + Return NULL if the key does not exist. */ +static inline _Py_hashtable_entry_t * +_Py_hashtable_get_entry(_Py_hashtable_t *ht, const void *key) +{ + return ht->get_entry_func(ht, key); +} + + +/* Get value from an entry. + Return NULL if the entry is not found. + + Use _Py_hashtable_get_entry() to distinguish entry value equal to NULL + and entry not found. */ +PyAPI_FUNC(void*) _Py_hashtable_get(_Py_hashtable_t *ht, const void *key); + + +/* Remove a key and its associated value without calling key and value destroy + functions. + + Return the removed value if the key was found. + Return NULL if the key was not found. */ +PyAPI_FUNC(void*) _Py_hashtable_steal( + _Py_hashtable_t *ht, + const void *key); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_HASHTABLE_H */ diff --git a/include/internal/pycore_import.h b/include/internal/pycore_import.h new file mode 100644 index 00000000..e21ed0a7 --- /dev/null +++ b/include/internal/pycore_import.h @@ -0,0 +1,17 @@ +#ifndef Py_LIMITED_API +#ifndef Py_INTERNAL_IMPORT_H +#define Py_INTERNAL_IMPORT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef HAVE_FORK +extern PyStatus _PyImport_ReInitLock(void); +#endif +extern PyObject* _PyImport_BootstrapImp(PyThreadState *tstate); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_IMPORT_H */ +#endif /* !Py_LIMITED_API */ diff --git a/include/internal/pycore_initconfig.h b/include/internal/pycore_initconfig.h new file mode 100644 index 00000000..4b009e81 --- /dev/null +++ b/include/internal/pycore_initconfig.h @@ -0,0 +1,176 @@ +#ifndef Py_INTERNAL_CORECONFIG_H +#define Py_INTERNAL_CORECONFIG_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Forward declaration */ +struct pyruntimestate; + +/* --- PyStatus ----------------------------------------------- */ + +/* Almost all errors causing Python initialization to fail */ +#ifdef _MSC_VER + /* Visual Studio 2015 doesn't implement C99 __func__ in C */ +# define _PyStatus_GET_FUNC() __FUNCTION__ +#else +# define _PyStatus_GET_FUNC() __func__ +#endif + +#define _PyStatus_OK() \ + (PyStatus){._type = _PyStatus_TYPE_OK,} + /* other fields are set to 0 */ +#define _PyStatus_ERR(ERR_MSG) \ + (PyStatus){ \ + ._type = _PyStatus_TYPE_ERROR, \ + .func = _PyStatus_GET_FUNC(), \ + .err_msg = (ERR_MSG)} + /* other fields are set to 0 */ +#define _PyStatus_NO_MEMORY() _PyStatus_ERR("memory allocation failed") +#define _PyStatus_EXIT(EXITCODE) \ + (PyStatus){ \ + ._type = _PyStatus_TYPE_EXIT, \ + .exitcode = (EXITCODE)} +#define _PyStatus_IS_ERROR(err) \ + (err._type == _PyStatus_TYPE_ERROR) +#define _PyStatus_IS_EXIT(err) \ + (err._type == _PyStatus_TYPE_EXIT) +#define _PyStatus_EXCEPTION(err) \ + (err._type != _PyStatus_TYPE_OK) +#define _PyStatus_UPDATE_FUNC(err) \ + do { err.func = _PyStatus_GET_FUNC(); } while (0) + +PyObject* _PyErr_SetFromPyStatus(PyStatus status); + +/* --- PyWideStringList ------------------------------------------------ */ + +#define _PyWideStringList_INIT (PyWideStringList){.length = 0, .items = NULL} + +#ifndef NDEBUG +PyAPI_FUNC(int) _PyWideStringList_CheckConsistency(const PyWideStringList *list); +#endif +PyAPI_FUNC(void) _PyWideStringList_Clear(PyWideStringList *list); +PyAPI_FUNC(int) _PyWideStringList_Copy(PyWideStringList *list, + const PyWideStringList *list2); +PyAPI_FUNC(PyStatus) _PyWideStringList_Extend(PyWideStringList *list, + const PyWideStringList *list2); +PyAPI_FUNC(PyObject*) _PyWideStringList_AsList(const PyWideStringList *list); + + +/* --- _PyArgv ---------------------------------------------------- */ + +typedef struct _PyArgv { + Py_ssize_t argc; + int use_bytes_argv; + char * const *bytes_argv; + wchar_t * const *wchar_argv; +} _PyArgv; + +PyAPI_FUNC(PyStatus) _PyArgv_AsWstrList(const _PyArgv *args, + PyWideStringList *list); + + +/* --- Helper functions ------------------------------------------- */ + +PyAPI_FUNC(int) _Py_str_to_int( + const char *str, + int *result); +PyAPI_FUNC(const wchar_t*) _Py_get_xoption( + const PyWideStringList *xoptions, + const wchar_t *name); +PyAPI_FUNC(const char*) _Py_GetEnv( + int use_environment, + const char *name); +PyAPI_FUNC(void) _Py_get_env_flag( + int use_environment, + int *flag, + const char *name); + +/* Py_GetArgcArgv() helper */ +PyAPI_FUNC(void) _Py_ClearArgcArgv(void); + + +/* --- _PyPreCmdline ------------------------------------------------- */ + +typedef struct { + PyWideStringList argv; + PyWideStringList xoptions; /* "-X value" option */ + int isolated; /* -I option */ + int use_environment; /* -E option */ + int dev_mode; /* -X dev and PYTHONDEVMODE */ + int warn_default_encoding; /* -X warn_default_encoding and PYTHONWARNDEFAULTENCODING */ +} _PyPreCmdline; + +#define _PyPreCmdline_INIT \ + (_PyPreCmdline){ \ + .use_environment = -1, \ + .isolated = -1, \ + .dev_mode = -1} +/* Note: _PyPreCmdline_INIT sets other fields to 0/NULL */ + +extern void _PyPreCmdline_Clear(_PyPreCmdline *cmdline); +extern PyStatus _PyPreCmdline_SetArgv(_PyPreCmdline *cmdline, + const _PyArgv *args); +extern PyStatus _PyPreCmdline_SetConfig( + const _PyPreCmdline *cmdline, + PyConfig *config); +extern PyStatus _PyPreCmdline_Read(_PyPreCmdline *cmdline, + const PyPreConfig *preconfig); + + +/* --- PyPreConfig ----------------------------------------------- */ + +PyAPI_FUNC(void) _PyPreConfig_InitCompatConfig(PyPreConfig *preconfig); +extern void _PyPreConfig_InitFromConfig( + PyPreConfig *preconfig, + const PyConfig *config); +extern PyStatus _PyPreConfig_InitFromPreConfig( + PyPreConfig *preconfig, + const PyPreConfig *config2); +extern PyObject* _PyPreConfig_AsDict(const PyPreConfig *preconfig); +extern void _PyPreConfig_GetConfig(PyPreConfig *preconfig, + const PyConfig *config); +extern PyStatus _PyPreConfig_Read(PyPreConfig *preconfig, + const _PyArgv *args); +extern PyStatus _PyPreConfig_Write(const PyPreConfig *preconfig); + + +/* --- PyConfig ---------------------------------------------- */ + +typedef enum { + /* Py_Initialize() API: backward compatibility with Python 3.6 and 3.7 */ + _PyConfig_INIT_COMPAT = 1, + _PyConfig_INIT_PYTHON = 2, + _PyConfig_INIT_ISOLATED = 3 +} _PyConfigInitEnum; + +PyAPI_FUNC(void) _PyConfig_InitCompatConfig(PyConfig *config); +extern PyStatus _PyConfig_Copy( + PyConfig *config, + const PyConfig *config2); +extern PyStatus _PyConfig_InitPathConfig( + PyConfig *config, + int compute_path_config); +extern PyStatus _PyConfig_Read(PyConfig *config, int compute_path_config); +extern PyStatus _PyConfig_Write(const PyConfig *config, + struct pyruntimestate *runtime); +extern PyStatus _PyConfig_SetPyArgv( + PyConfig *config, + const _PyArgv *args); + +PyAPI_FUNC(PyObject*) _PyConfig_AsDict(const PyConfig *config); +PyAPI_FUNC(int) _PyConfig_FromDict(PyConfig *config, PyObject *dict); + + +/* --- Function used for testing ---------------------------------- */ + +PyAPI_FUNC(PyObject*) _Py_GetConfigsAsDict(void); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_CORECONFIG_H */ diff --git a/include/internal/pycore_interp.h b/include/internal/pycore_interp.h new file mode 100644 index 00000000..4307b61c --- /dev/null +++ b/include/internal/pycore_interp.h @@ -0,0 +1,337 @@ +#ifndef Py_INTERNAL_INTERP_H +#define Py_INTERNAL_INTERP_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_atomic.h" // _Py_atomic_address +#include "pycore_ast_state.h" // struct ast_state +#include "pycore_gil.h" // struct _gil_runtime_state +#include "pycore_gc.h" // struct _gc_runtime_state +#include "pycore_warnings.h" // struct _warnings_runtime_state + +struct _pending_calls { + PyThread_type_lock lock; + /* Request for running pending calls. */ + _Py_atomic_int calls_to_do; + /* Request for looking at the `async_exc` field of the current + thread state. + Guarded by the GIL. */ + int async_exc; +#define NPENDINGCALLS 32 + struct { + int (*func)(void *); + void *arg; + } calls[NPENDINGCALLS]; + int first; + int last; +}; + +struct _ceval_state { + int recursion_limit; + /* This single variable consolidates all requests to break out of + the fast path in the eval loop. */ + _Py_atomic_int eval_breaker; + /* Request for dropping the GIL */ + _Py_atomic_int gil_drop_request; + struct _pending_calls pending; +#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS + struct _gil_runtime_state gil; +#endif +}; + +/* fs_codec.encoding is initialized to NULL. + Later, it is set to a non-NULL string by _PyUnicode_InitEncodings(). */ +struct _Py_unicode_fs_codec { + char *encoding; // Filesystem encoding (encoded to UTF-8) + int utf8; // encoding=="utf-8"? + char *errors; // Filesystem errors (encoded to UTF-8) + _Py_error_handler error_handler; +}; + +struct _Py_bytes_state { + PyObject *empty_string; + PyBytesObject *characters[256]; +}; + +struct _Py_unicode_ids { + Py_ssize_t size; + PyObject **array; +}; + +struct _Py_unicode_state { + // The empty Unicode object is a singleton to improve performance. + PyObject *empty_string; + /* Single character Unicode strings in the Latin-1 range are being + shared as well. */ + PyObject *latin1[256]; + struct _Py_unicode_fs_codec fs_codec; + + // Unused member kept for ABI backward compatibility with Python 3.10.0: + // see bpo-46006. + PyObject *unused_interned; + + // Unicode identifiers (_Py_Identifier): see _PyUnicode_FromId() + struct _Py_unicode_ids ids; +}; + +struct _Py_float_state { + /* Special free list + free_list is a singly-linked list of available PyFloatObjects, + linked via abuse of their ob_type members. */ + int numfree; + PyFloatObject *free_list; +}; + +/* Speed optimization to avoid frequent malloc/free of small tuples */ +#ifndef PyTuple_MAXSAVESIZE + // Largest tuple to save on free list +# define PyTuple_MAXSAVESIZE 20 +#endif +#ifndef PyTuple_MAXFREELIST + // Maximum number of tuples of each size to save +# define PyTuple_MAXFREELIST 2000 +#endif + +struct _Py_tuple_state { +#if PyTuple_MAXSAVESIZE > 0 + /* Entries 1 up to PyTuple_MAXSAVESIZE are free lists, + entry 0 is the empty tuple () of which at most one instance + will be allocated. */ + PyTupleObject *free_list[PyTuple_MAXSAVESIZE]; + int numfree[PyTuple_MAXSAVESIZE]; +#endif +}; + +/* Empty list reuse scheme to save calls to malloc and free */ +#ifndef PyList_MAXFREELIST +# define PyList_MAXFREELIST 80 +#endif + +struct _Py_list_state { + PyListObject *free_list[PyList_MAXFREELIST]; + int numfree; +}; + +#ifndef PyDict_MAXFREELIST +# define PyDict_MAXFREELIST 80 +#endif + +struct _Py_dict_state { + /* Dictionary reuse scheme to save calls to malloc and free */ + PyDictObject *free_list[PyDict_MAXFREELIST]; + int numfree; + PyDictKeysObject *keys_free_list[PyDict_MAXFREELIST]; + int keys_numfree; +}; + +struct _Py_frame_state { + PyFrameObject *free_list; + /* number of frames currently in free_list */ + int numfree; +}; + +#ifndef _PyAsyncGen_MAXFREELIST +# define _PyAsyncGen_MAXFREELIST 80 +#endif + +struct _Py_async_gen_state { + /* Freelists boost performance 6-10%; they also reduce memory + fragmentation, as _PyAsyncGenWrappedValue and PyAsyncGenASend + are short-living objects that are instantiated for every + __anext__() call. */ + struct _PyAsyncGenWrappedValue* value_freelist[_PyAsyncGen_MAXFREELIST]; + int value_numfree; + + struct PyAsyncGenASend* asend_freelist[_PyAsyncGen_MAXFREELIST]; + int asend_numfree; +}; + +struct _Py_context_state { + // List of free PyContext objects + PyContext *freelist; + int numfree; +}; + +struct _Py_exc_state { + // The dict mapping from errno codes to OSError subclasses + PyObject *errnomap; + PyBaseExceptionObject *memerrors_freelist; + int memerrors_numfree; +}; + + +// atexit state +typedef struct { + PyObject *func; + PyObject *args; + PyObject *kwargs; +} atexit_callback; + +struct atexit_state { + atexit_callback **callbacks; + int ncallbacks; + int callback_len; +}; + + +// Type attribute lookup cache: speed up attribute and method lookups, +// see _PyType_Lookup(). +struct type_cache_entry { + unsigned int version; // initialized from type->tp_version_tag + PyObject *name; // reference to exactly a str or None + PyObject *value; // borrowed reference or NULL +}; + +#define MCACHE_SIZE_EXP 12 +#define MCACHE_STATS 0 + +struct type_cache { + struct type_cache_entry hashtable[1 << MCACHE_SIZE_EXP]; +#if MCACHE_STATS + size_t hits; + size_t misses; + size_t collisions; +#endif +}; + + +/* interpreter state */ + +#define _PY_NSMALLPOSINTS 257 +#define _PY_NSMALLNEGINTS 5 + +// _PyLong_GetZero() and _PyLong_GetOne() must always be available +#if _PY_NSMALLPOSINTS < 2 +# error "_PY_NSMALLPOSINTS must be greater than 1" +#endif + +// The PyInterpreterState typedef is in Include/pystate.h. +struct _is { + + struct _is *next; + struct _ts *tstate_head; + + /* Reference to the _PyRuntime global variable. This field exists + to not have to pass runtime in addition to tstate to a function. + Get runtime from tstate: tstate->interp->runtime. */ + struct pyruntimestate *runtime; + + int64_t id; + int64_t id_refcount; + int requires_idref; + PyThread_type_lock id_mutex; + + int finalizing; + + struct _ceval_state ceval; + struct _gc_runtime_state gc; + + // sys.modules dictionary + PyObject *modules; + PyObject *modules_by_index; + // Dictionary of the sys module + PyObject *sysdict; + // Dictionary of the builtins module + PyObject *builtins; + // importlib module + PyObject *importlib; + + /* Used in Modules/_threadmodule.c. */ + long num_threads; + /* Support for runtime thread stack size tuning. + A value of 0 means using the platform's default stack size + or the size specified by the THREAD_STACK_SIZE macro. */ + /* Used in Python/thread.c. */ + size_t pythread_stacksize; + + PyObject *codec_search_path; + PyObject *codec_search_cache; + PyObject *codec_error_registry; + int codecs_initialized; + + PyConfig config; +#ifdef HAVE_DLOPEN + int dlopenflags; +#endif + + PyObject *dict; /* Stores per-interpreter state */ + + PyObject *builtins_copy; + PyObject *import_func; + // Initialized to _PyEval_EvalFrameDefault(). + _PyFrameEvalFunction eval_frame; + + Py_ssize_t co_extra_user_count; + freefunc co_extra_freefuncs[MAX_CO_EXTRA_USERS]; + +#ifdef HAVE_FORK + PyObject *before_forkers; + PyObject *after_forkers_parent; + PyObject *after_forkers_child; +#endif + + uint64_t tstate_next_unique_id; + + struct _warnings_runtime_state warnings; + struct atexit_state atexit; + + PyObject *audit_hooks; + + /* Small integers are preallocated in this array so that they + can be shared. + The integers that are preallocated are those in the range + -_PY_NSMALLNEGINTS (inclusive) to _PY_NSMALLPOSINTS (not inclusive). + */ + PyLongObject* small_ints[_PY_NSMALLNEGINTS + _PY_NSMALLPOSINTS]; + struct _Py_bytes_state bytes; + struct _Py_unicode_state unicode; + struct _Py_float_state float_state; + /* Using a cache is very effective since typically only a single slice is + created and then deleted again. */ + PySliceObject *slice_cache; + + struct _Py_tuple_state tuple; + struct _Py_list_state list; + struct _Py_dict_state dict_state; + struct _Py_frame_state frame; + struct _Py_async_gen_state async_gen; + struct _Py_context_state context; + struct _Py_exc_state exc_state; + + struct ast_state ast; + struct type_cache type_cache; +}; + +extern void _PyInterpreterState_ClearModules(PyInterpreterState *interp); +extern void _PyInterpreterState_Clear(PyThreadState *tstate); + + +/* cross-interpreter data registry */ + +/* For now we use a global registry of shareable classes. An + alternative would be to add a tp_* slot for a class's + crossinterpdatafunc. It would be simpler and more efficient. */ + +struct _xidregitem; + +struct _xidregitem { + PyTypeObject *cls; + crossinterpdatafunc getdata; + struct _xidregitem *next; +}; + +PyAPI_FUNC(struct _is*) _PyInterpreterState_LookUpID(int64_t); + +PyAPI_FUNC(int) _PyInterpreterState_IDInitref(struct _is *); +PyAPI_FUNC(int) _PyInterpreterState_IDIncref(struct _is *); +PyAPI_FUNC(void) _PyInterpreterState_IDDecref(struct _is *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_INTERP_H */ diff --git a/include/internal/pycore_list.h b/include/internal/pycore_list.h new file mode 100644 index 00000000..f18fb052 --- /dev/null +++ b/include/internal/pycore_list.h @@ -0,0 +1,20 @@ +#ifndef Py_INTERNAL_LIST_H +#define Py_INTERNAL_LIST_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "listobject.h" // _PyList_CAST() + + +#define _PyList_ITEMS(op) (_PyList_CAST(op)->ob_item) + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LIST_H */ diff --git a/include/internal/pycore_long.h b/include/internal/pycore_long.h new file mode 100644 index 00000000..2bea3a55 --- /dev/null +++ b/include/internal/pycore_long.h @@ -0,0 +1,40 @@ +#ifndef Py_INTERNAL_LONG_H +#define Py_INTERNAL_LONG_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_interp.h" // PyInterpreterState.small_ints +#include "pycore_pystate.h" // _PyThreadState_GET() + +// Don't call this function but _PyLong_GetZero() and _PyLong_GetOne() +static inline PyObject* __PyLong_GetSmallInt_internal(int value) +{ + PyInterpreterState *interp = _PyInterpreterState_GET(); + assert(-_PY_NSMALLNEGINTS <= value && value < _PY_NSMALLPOSINTS); + size_t index = _PY_NSMALLNEGINTS + value; + PyObject *obj = (PyObject*)interp->small_ints[index]; + // _PyLong_GetZero(), _PyLong_GetOne() and get_small_int() must not be + // called before _PyLong_Init() nor after _PyLong_Fini(). + assert(obj != NULL); + return obj; +} + +// Return a borrowed reference to the zero singleton. +// The function cannot return NULL. +static inline PyObject* _PyLong_GetZero(void) +{ return __PyLong_GetSmallInt_internal(0); } + +// Return a borrowed reference to the one singleton. +// The function cannot return NULL. +static inline PyObject* _PyLong_GetOne(void) +{ return __PyLong_GetSmallInt_internal(1); } + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LONG_H */ diff --git a/include/internal/pycore_moduleobject.h b/include/internal/pycore_moduleobject.h new file mode 100644 index 00000000..e9978abd --- /dev/null +++ b/include/internal/pycore_moduleobject.h @@ -0,0 +1,42 @@ +#ifndef Py_INTERNAL_MODULEOBJECT_H +#define Py_INTERNAL_MODULEOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct { + PyObject_HEAD + PyObject *md_dict; + struct PyModuleDef *md_def; + void *md_state; + PyObject *md_weaklist; + // for logging purposes after md_dict is cleared + PyObject *md_name; +} PyModuleObject; + +static inline PyModuleDef* _PyModule_GetDef(PyObject *mod) { + assert(PyModule_Check(mod)); + return ((PyModuleObject *)mod)->md_def; +} + +static inline void* _PyModule_GetState(PyObject* mod) { + assert(PyModule_Check(mod)); + return ((PyModuleObject *)mod)->md_state; +} + +static inline PyObject* _PyModule_GetDict(PyObject *mod) { + assert(PyModule_Check(mod)); + PyObject *dict = ((PyModuleObject *)mod) -> md_dict; + // _PyModule_GetDict(mod) must not be used after calling module_clear(mod) + assert(dict != NULL); + return dict; +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_MODULEOBJECT_H */ diff --git a/include/internal/pycore_object.h b/include/internal/pycore_object.h new file mode 100644 index 00000000..90d98134 --- /dev/null +++ b/include/internal/pycore_object.h @@ -0,0 +1,186 @@ +#ifndef Py_INTERNAL_OBJECT_H +#define Py_INTERNAL_OBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_gc.h" // _PyObject_GC_IS_TRACKED() +#include "pycore_interp.h" // PyInterpreterState.gc +#include "pycore_pystate.h" // _PyInterpreterState_GET() + +PyAPI_FUNC(int) _PyType_CheckConsistency(PyTypeObject *type); +PyAPI_FUNC(int) _PyDict_CheckConsistency(PyObject *mp, int check_content); + +/* Update the Python traceback of an object. This function must be called + when a memory block is reused from a free list. + + Internal function called by _Py_NewReference(). */ +extern int _PyTraceMalloc_NewReference(PyObject *op); + +// Fast inlined version of PyType_HasFeature() +static inline int +_PyType_HasFeature(PyTypeObject *type, unsigned long feature) { + return ((type->tp_flags & feature) != 0); +} + +extern void _PyType_InitCache(PyInterpreterState *interp); + +/* Only private in Python 3.10 and 3.9.8+; public in 3.11 */ +extern PyObject *_PyType_GetQualName(PyTypeObject *type); + +/* Inline functions trading binary compatibility for speed: + _PyObject_Init() is the fast version of PyObject_Init(), and + _PyObject_InitVar() is the fast version of PyObject_InitVar(). + + These inline functions must not be called with op=NULL. */ +static inline void +_PyObject_Init(PyObject *op, PyTypeObject *typeobj) +{ + assert(op != NULL); + Py_SET_TYPE(op, typeobj); + if (_PyType_HasFeature(typeobj, Py_TPFLAGS_HEAPTYPE)) { + Py_INCREF(typeobj); + } + _Py_NewReference(op); +} + +static inline void +_PyObject_InitVar(PyVarObject *op, PyTypeObject *typeobj, Py_ssize_t size) +{ + assert(op != NULL); + Py_SET_SIZE(op, size); + _PyObject_Init((PyObject *)op, typeobj); +} + + +/* Tell the GC to track this object. + * + * The object must not be tracked by the GC. + * + * NB: While the object is tracked by the collector, it must be safe to call the + * ob_traverse method. + * + * Internal note: interp->gc.generation0->_gc_prev doesn't have any bit flags + * because it's not object header. So we don't use _PyGCHead_PREV() and + * _PyGCHead_SET_PREV() for it to avoid unnecessary bitwise operations. + * + * See also the public PyObject_GC_Track() function. + */ +static inline void _PyObject_GC_TRACK( +// The preprocessor removes _PyObject_ASSERT_FROM() calls if NDEBUG is defined +#ifndef NDEBUG + const char *filename, int lineno, +#endif + PyObject *op) +{ + _PyObject_ASSERT_FROM(op, !_PyObject_GC_IS_TRACKED(op), + "object already tracked by the garbage collector", + filename, lineno, __func__); + + PyGC_Head *gc = _Py_AS_GC(op); + _PyObject_ASSERT_FROM(op, + (gc->_gc_prev & _PyGC_PREV_MASK_COLLECTING) == 0, + "object is in generation which is garbage collected", + filename, lineno, __func__); + + PyInterpreterState *interp = _PyInterpreterState_GET(); + PyGC_Head *generation0 = interp->gc.generation0; + PyGC_Head *last = (PyGC_Head*)(generation0->_gc_prev); + _PyGCHead_SET_NEXT(last, gc); + _PyGCHead_SET_PREV(gc, last); + _PyGCHead_SET_NEXT(gc, generation0); + generation0->_gc_prev = (uintptr_t)gc; +} + +/* Tell the GC to stop tracking this object. + * + * Internal note: This may be called while GC. So _PyGC_PREV_MASK_COLLECTING + * must be cleared. But _PyGC_PREV_MASK_FINALIZED bit is kept. + * + * The object must be tracked by the GC. + * + * See also the public PyObject_GC_UnTrack() which accept an object which is + * not tracked. + */ +static inline void _PyObject_GC_UNTRACK( +// The preprocessor removes _PyObject_ASSERT_FROM() calls if NDEBUG is defined +#ifndef NDEBUG + const char *filename, int lineno, +#endif + PyObject *op) +{ + _PyObject_ASSERT_FROM(op, _PyObject_GC_IS_TRACKED(op), + "object not tracked by the garbage collector", + filename, lineno, __func__); + + PyGC_Head *gc = _Py_AS_GC(op); + PyGC_Head *prev = _PyGCHead_PREV(gc); + PyGC_Head *next = _PyGCHead_NEXT(gc); + _PyGCHead_SET_NEXT(prev, next); + _PyGCHead_SET_PREV(next, prev); + gc->_gc_next = 0; + gc->_gc_prev &= _PyGC_PREV_MASK_FINALIZED; +} + +// Macros to accept any type for the parameter, and to automatically pass +// the filename and the filename (if NDEBUG is not defined) where the macro +// is called. +#ifdef NDEBUG +# define _PyObject_GC_TRACK(op) \ + _PyObject_GC_TRACK(_PyObject_CAST(op)) +# define _PyObject_GC_UNTRACK(op) \ + _PyObject_GC_UNTRACK(_PyObject_CAST(op)) +#else +# define _PyObject_GC_TRACK(op) \ + _PyObject_GC_TRACK(__FILE__, __LINE__, _PyObject_CAST(op)) +# define _PyObject_GC_UNTRACK(op) \ + _PyObject_GC_UNTRACK(__FILE__, __LINE__, _PyObject_CAST(op)) +#endif + +#ifdef Py_REF_DEBUG +extern void _PyDebug_PrintTotalRefs(void); +#endif + +#ifdef Py_TRACE_REFS +extern void _Py_AddToAllObjects(PyObject *op, int force); +extern void _Py_PrintReferences(FILE *); +extern void _Py_PrintReferenceAddresses(FILE *); +#endif + +static inline PyObject ** +_PyObject_GET_WEAKREFS_LISTPTR(PyObject *op) +{ + Py_ssize_t offset = Py_TYPE(op)->tp_weaklistoffset; + return (PyObject **)((char *)op + offset); +} + +// Fast inlined version of PyObject_IS_GC() +static inline int +_PyObject_IS_GC(PyObject *obj) +{ + return (PyType_IS_GC(Py_TYPE(obj)) + && (Py_TYPE(obj)->tp_is_gc == NULL + || Py_TYPE(obj)->tp_is_gc(obj))); +} + +// Fast inlined version of PyType_IS_GC() +#define _PyType_IS_GC(t) _PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC) + +// Usage: assert(_Py_CheckSlotResult(obj, "__getitem__", result != NULL)); +extern int _Py_CheckSlotResult( + PyObject *obj, + const char *slot_name, + int success); + +// PyType_Ready() must be called if _PyType_IsReady() is false. +// See also the Py_TPFLAGS_READY flag. +#define _PyType_IsReady(type) ((type)->tp_dict != NULL) + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_OBJECT_H */ diff --git a/include/internal/pycore_parser.h b/include/internal/pycore_parser.h new file mode 100644 index 00000000..e2de24e2 --- /dev/null +++ b/include/internal/pycore_parser.h @@ -0,0 +1,31 @@ +#ifndef Py_INTERNAL_PARSER_H +#define Py_INTERNAL_PARSER_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern struct _mod* _PyParser_ASTFromString( + const char *str, + PyObject* filename, + int mode, + PyCompilerFlags *flags, + PyArena *arena); +extern struct _mod* _PyParser_ASTFromFile( + FILE *fp, + PyObject *filename_ob, + const char *enc, + int mode, + const char *ps1, + const char *ps2, + PyCompilerFlags *flags, + int *errcode, + PyArena *arena); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PARSER_H */ diff --git a/include/internal/pycore_pathconfig.h b/include/internal/pycore_pathconfig.h new file mode 100644 index 00000000..15447f54 --- /dev/null +++ b/include/internal/pycore_pathconfig.h @@ -0,0 +1,73 @@ +#ifndef Py_INTERNAL_PATHCONFIG_H +#define Py_INTERNAL_PATHCONFIG_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct _PyPathConfig { + /* Full path to the Python program */ + wchar_t *program_full_path; + wchar_t *prefix; + wchar_t *exec_prefix; + /* Set by Py_SetPath(), or computed by _PyConfig_InitPathConfig() */ + wchar_t *module_search_path; + /* Python program name */ + wchar_t *program_name; + /* Set by Py_SetPythonHome() or PYTHONHOME environment variable */ + wchar_t *home; +#ifdef MS_WINDOWS + /* isolated and site_import are used to set Py_IsolatedFlag and + Py_NoSiteFlag flags on Windows in read_pth_file(). These fields + are ignored when their value are equal to -1 (unset). */ + int isolated; + int site_import; + /* Set when a venv is detected */ + wchar_t *base_executable; +#endif +} _PyPathConfig; + +#ifdef MS_WINDOWS +# define _PyPathConfig_INIT \ + {.module_search_path = NULL, \ + .isolated = -1, \ + .site_import = -1} +#else +# define _PyPathConfig_INIT \ + {.module_search_path = NULL} +#endif +/* Note: _PyPathConfig_INIT sets other fields to 0/NULL */ + +PyAPI_DATA(_PyPathConfig) _Py_path_config; +#ifdef MS_WINDOWS +PyAPI_DATA(wchar_t*) _Py_dll_path; +#endif + +extern void _PyPathConfig_ClearGlobal(void); + +extern PyStatus _PyPathConfig_Calculate( + _PyPathConfig *pathconfig, + const PyConfig *config); +extern int _PyPathConfig_ComputeSysPath0( + const PyWideStringList *argv, + PyObject **path0); +extern PyStatus _Py_FindEnvConfigValue( + FILE *env_file, + const wchar_t *key, + wchar_t **value_p); + +#ifdef MS_WINDOWS +extern wchar_t* _Py_GetDLLPath(void); +#endif + +extern PyStatus _PyConfig_WritePathConfig(const PyConfig *config); +extern void _Py_DumpPathConfig(PyThreadState *tstate); +extern PyObject* _PyPathConfig_AsDict(void); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PATHCONFIG_H */ diff --git a/include/internal/pycore_pyarena.h b/include/internal/pycore_pyarena.h new file mode 100644 index 00000000..d78972a8 --- /dev/null +++ b/include/internal/pycore_pyarena.h @@ -0,0 +1,64 @@ +/* An arena-like memory interface for the compiler. + */ + +#ifndef Py_INTERNAL_PYARENA_H +#define Py_INTERNAL_PYARENA_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +typedef struct _arena PyArena; + +/* _PyArena_New() and _PyArena_Free() create a new arena and free it, + respectively. Once an arena has been created, it can be used + to allocate memory via _PyArena_Malloc(). Pointers to PyObject can + also be registered with the arena via _PyArena_AddPyObject(), and the + arena will ensure that the PyObjects stay alive at least until + _PyArena_Free() is called. When an arena is freed, all the memory it + allocated is freed, the arena releases internal references to registered + PyObject*, and none of its pointers are valid. + XXX (tim) What does "none of its pointers are valid" mean? Does it + XXX mean that pointers previously obtained via _PyArena_Malloc() are + XXX no longer valid? (That's clearly true, but not sure that's what + XXX the text is trying to say.) + + _PyArena_New() returns an arena pointer. On error, it + returns a negative number and sets an exception. + XXX (tim): Not true. On error, _PyArena_New() actually returns NULL, + XXX and looks like it may or may not set an exception (e.g., if the + XXX internal PyList_New(0) returns NULL, _PyArena_New() passes that on + XXX and an exception is set; OTOH, if the internal + XXX block_new(DEFAULT_BLOCK_SIZE) returns NULL, that's passed on but + XXX an exception is not set in that case). +*/ +PyAPI_FUNC(PyArena*) _PyArena_New(void); +PyAPI_FUNC(void) _PyArena_Free(PyArena *); + +/* Mostly like malloc(), return the address of a block of memory spanning + * `size` bytes, or return NULL (without setting an exception) if enough + * new memory can't be obtained. Unlike malloc(0), _PyArena_Malloc() with + * size=0 does not guarantee to return a unique pointer (the pointer + * returned may equal one or more other pointers obtained from + * _PyArena_Malloc()). + * Note that pointers obtained via _PyArena_Malloc() must never be passed to + * the system free() or realloc(), or to any of Python's similar memory- + * management functions. _PyArena_Malloc()-obtained pointers remain valid + * until _PyArena_Free(ar) is called, at which point all pointers obtained + * from the arena `ar` become invalid simultaneously. + */ +PyAPI_FUNC(void*) _PyArena_Malloc(PyArena *, size_t size); + +/* This routine isn't a proper arena allocation routine. It takes + * a PyObject* and records it so that it can be DECREFed when the + * arena is freed. + */ +PyAPI_FUNC(int) _PyArena_AddPyObject(PyArena *, PyObject *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYARENA_H */ diff --git a/include/internal/pycore_pyerrors.h b/include/internal/pycore_pyerrors.h new file mode 100644 index 00000000..a5e97fe2 --- /dev/null +++ b/include/internal/pycore_pyerrors.h @@ -0,0 +1,96 @@ +#ifndef Py_INTERNAL_PYERRORS_H +#define Py_INTERNAL_PYERRORS_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +static inline PyObject* _PyErr_Occurred(PyThreadState *tstate) +{ + assert(tstate != NULL); + return tstate->curexc_type; +} + +static inline void _PyErr_ClearExcState(_PyErr_StackItem *exc_state) +{ + PyObject *t, *v, *tb; + t = exc_state->exc_type; + v = exc_state->exc_value; + tb = exc_state->exc_traceback; + exc_state->exc_type = NULL; + exc_state->exc_value = NULL; + exc_state->exc_traceback = NULL; + Py_XDECREF(t); + Py_XDECREF(v); + Py_XDECREF(tb); +} + + +PyAPI_FUNC(void) _PyErr_Fetch( + PyThreadState *tstate, + PyObject **type, + PyObject **value, + PyObject **traceback); + +PyAPI_FUNC(int) _PyErr_ExceptionMatches( + PyThreadState *tstate, + PyObject *exc); + +PyAPI_FUNC(void) _PyErr_Restore( + PyThreadState *tstate, + PyObject *type, + PyObject *value, + PyObject *traceback); + +PyAPI_FUNC(void) _PyErr_SetObject( + PyThreadState *tstate, + PyObject *type, + PyObject *value); + +PyAPI_FUNC(void) _PyErr_ChainStackItem( + _PyErr_StackItem *exc_info); + +PyAPI_FUNC(void) _PyErr_Clear(PyThreadState *tstate); + +PyAPI_FUNC(void) _PyErr_SetNone(PyThreadState *tstate, PyObject *exception); + +PyAPI_FUNC(PyObject *) _PyErr_NoMemory(PyThreadState *tstate); + +PyAPI_FUNC(void) _PyErr_SetString( + PyThreadState *tstate, + PyObject *exception, + const char *string); + +PyAPI_FUNC(PyObject *) _PyErr_Format( + PyThreadState *tstate, + PyObject *exception, + const char *format, + ...); + +PyAPI_FUNC(void) _PyErr_NormalizeException( + PyThreadState *tstate, + PyObject **exc, + PyObject **val, + PyObject **tb); + +PyAPI_FUNC(PyObject *) _PyErr_FormatFromCauseTstate( + PyThreadState *tstate, + PyObject *exception, + const char *format, + ...); + +PyAPI_FUNC(int) _PyErr_CheckSignalsTstate(PyThreadState *tstate); + +PyAPI_FUNC(void) _Py_DumpExtensionModules(int fd, PyInterpreterState *interp); + +extern PyObject* _Py_Offer_Suggestions(PyObject* exception); +PyAPI_FUNC(Py_ssize_t) _Py_UTF8_Edit_Cost(PyObject *str_a, PyObject *str_b, + Py_ssize_t max_cost); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYERRORS_H */ diff --git a/include/internal/hash.h b/include/internal/pycore_pyhash.h similarity index 59% rename from include/internal/hash.h rename to include/internal/pycore_pyhash.h index e14b80a7..a229f8d8 100644 --- a/include/internal/hash.h +++ b/include/internal/pycore_pyhash.h @@ -1,6 +1,10 @@ #ifndef Py_INTERNAL_HASH_H #define Py_INTERNAL_HASH_H +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + uint64_t _Py_KeyedHash(uint64_t, const char *, Py_ssize_t); #endif diff --git a/include/internal/pycore_pylifecycle.h b/include/internal/pycore_pylifecycle.h new file mode 100644 index 00000000..524be9d4 --- /dev/null +++ b/include/internal/pycore_pylifecycle.h @@ -0,0 +1,141 @@ +#ifndef Py_INTERNAL_LIFECYCLE_H +#define Py_INTERNAL_LIFECYCLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#ifdef HAVE_SIGNAL_H +#include +#endif + +#include "pycore_runtime.h" // _PyRuntimeState + +#ifndef NSIG +# if defined(_NSIG) +# define NSIG _NSIG /* For BSD/SysV */ +# elif defined(_SIGMAX) +# define NSIG (_SIGMAX + 1) /* For QNX */ +# elif defined(SIGMAX) +# define NSIG (SIGMAX + 1) /* For djgpp */ +# else +# define NSIG 64 /* Use a reasonable default value */ +# endif +#endif + +/* Forward declarations */ +struct _PyArgv; +struct pyruntimestate; + +/* True if the main interpreter thread exited due to an unhandled + * KeyboardInterrupt exception, suggesting the user pressed ^C. */ +PyAPI_DATA(int) _Py_UnhandledKeyboardInterrupt; + +extern int _Py_SetFileSystemEncoding( + const char *encoding, + const char *errors); +extern void _Py_ClearFileSystemEncoding(void); +extern PyStatus _PyUnicode_InitEncodings(PyThreadState *tstate); +#ifdef MS_WINDOWS +extern int _PyUnicode_EnableLegacyWindowsFSEncoding(void); +#endif + +PyAPI_FUNC(void) _Py_ClearStandardStreamEncoding(void); + +PyAPI_FUNC(int) _Py_IsLocaleCoercionTarget(const char *ctype_loc); + +/* Various one-time initializers */ + +extern PyStatus _PyUnicode_Init(PyInterpreterState *interp); +extern PyStatus _PyUnicode_InitTypes(void); +extern PyStatus _PyBytes_Init(PyInterpreterState *interp); +extern int _PyStructSequence_Init(void); +extern int _PyLong_Init(PyInterpreterState *interp); +extern int _PyLong_InitTypes(void); +extern PyStatus _PyTuple_Init(PyInterpreterState *interp); +extern PyStatus _PyFaulthandler_Init(int enable); +extern int _PyTraceMalloc_Init(int enable); +extern PyObject * _PyBuiltin_Init(PyInterpreterState *interp); +extern PyStatus _PySys_Create( + PyThreadState *tstate, + PyObject **sysmod_p); +extern PyStatus _PySys_ReadPreinitWarnOptions(PyWideStringList *options); +extern PyStatus _PySys_ReadPreinitXOptions(PyConfig *config); +extern int _PySys_UpdateConfig(PyThreadState *tstate); +extern PyStatus _PyExc_Init(PyInterpreterState *interp); +extern PyStatus _PyErr_InitTypes(void); +extern PyStatus _PyBuiltins_AddExceptions(PyObject * bltinmod); +extern void _PyFloat_Init(void); +extern int _PyFloat_InitTypes(void); +extern PyStatus _Py_HashRandomization_Init(const PyConfig *); + +extern PyStatus _PyTypes_Init(void); +extern PyStatus _PyTypes_InitSlotDefs(void); +extern PyStatus _PyImportZip_Init(PyThreadState *tstate); +extern PyStatus _PyGC_Init(PyInterpreterState *interp); +extern PyStatus _PyAtExit_Init(PyInterpreterState *interp); + + +/* Various internal finalizers */ + +extern void _PyFrame_Fini(PyInterpreterState *interp); +extern void _PyDict_Fini(PyInterpreterState *interp); +extern void _PyTuple_Fini(PyInterpreterState *interp); +extern void _PyList_Fini(PyInterpreterState *interp); +extern void _PyBytes_Fini(PyInterpreterState *interp); +extern void _PyFloat_Fini(PyInterpreterState *interp); +extern void _PySlice_Fini(PyInterpreterState *interp); +extern void _PyAsyncGen_Fini(PyInterpreterState *interp); + +extern int _PySignal_Init(int install_signal_handlers); +extern void _PySignal_Fini(void); + +extern void _PyExc_Fini(PyInterpreterState *interp); +extern void _PyImport_Fini(void); +extern void _PyImport_Fini2(void); +extern void _PyGC_Fini(PyInterpreterState *interp); +extern void _PyType_Fini(PyInterpreterState *interp); +extern void _Py_HashRandomization_Fini(void); +extern void _PyUnicode_Fini(PyInterpreterState *interp); +extern void _PyUnicode_ClearInterned(PyInterpreterState *interp); +extern void _PyLong_Fini(PyInterpreterState *interp); +extern void _PyFaulthandler_Fini(void); +extern void _PyHash_Fini(void); +extern void _PyTraceMalloc_Fini(void); +extern void _PyWarnings_Fini(PyInterpreterState *interp); +extern void _PyAST_Fini(PyInterpreterState *interp); +extern void _PyAtExit_Fini(PyInterpreterState *interp); + +extern PyStatus _PyGILState_Init(_PyRuntimeState *runtime); +extern PyStatus _PyGILState_SetTstate(PyThreadState *tstate); +extern void _PyGILState_Fini(PyInterpreterState *interp); + +PyAPI_FUNC(void) _PyGC_DumpShutdownStats(PyInterpreterState *interp); + +PyAPI_FUNC(PyStatus) _Py_PreInitializeFromPyArgv( + const PyPreConfig *src_config, + const struct _PyArgv *args); +PyAPI_FUNC(PyStatus) _Py_PreInitializeFromConfig( + const PyConfig *config, + const struct _PyArgv *args); + + +PyAPI_FUNC(int) _Py_HandleSystemExit(int *exitcode_p); + +PyAPI_FUNC(PyObject*) _PyErr_WriteUnraisableDefaultHook(PyObject *unraisable); + +PyAPI_FUNC(void) _PyErr_Print(PyThreadState *tstate); +PyAPI_FUNC(void) _PyErr_Display(PyObject *file, PyObject *exception, + PyObject *value, PyObject *tb); + +PyAPI_FUNC(void) _PyThreadState_DeleteCurrent(PyThreadState *tstate); + +extern void _PyAtExit_Call(PyInterpreterState *interp); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_LIFECYCLE_H */ diff --git a/include/internal/pycore_pymem.h b/include/internal/pycore_pymem.h new file mode 100644 index 00000000..49af1714 --- /dev/null +++ b/include/internal/pycore_pymem.h @@ -0,0 +1,101 @@ +#ifndef Py_INTERNAL_PYMEM_H +#define Py_INTERNAL_PYMEM_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pymem.h" // PyMemAllocatorName + + +/* Set the memory allocator of the specified domain to the default. + Save the old allocator into *old_alloc if it's non-NULL. + Return on success, or return -1 if the domain is unknown. */ +PyAPI_FUNC(int) _PyMem_SetDefaultAllocator( + PyMemAllocatorDomain domain, + PyMemAllocatorEx *old_alloc); + +/* Special bytes broadcast into debug memory blocks at appropriate times. + Strings of these are unlikely to be valid addresses, floats, ints or + 7-bit ASCII. + + - PYMEM_CLEANBYTE: clean (newly allocated) memory + - PYMEM_DEADBYTE dead (newly freed) memory + - PYMEM_FORBIDDENBYTE: untouchable bytes at each end of a block + + Byte patterns 0xCB, 0xDB and 0xFB have been replaced with 0xCD, 0xDD and + 0xFD to use the same values than Windows CRT debug malloc() and free(). + If modified, _PyMem_IsPtrFreed() should be updated as well. */ +#define PYMEM_CLEANBYTE 0xCD +#define PYMEM_DEADBYTE 0xDD +#define PYMEM_FORBIDDENBYTE 0xFD + +/* Heuristic checking if a pointer value is newly allocated + (uninitialized), newly freed or NULL (is equal to zero). + + The pointer is not dereferenced, only the pointer value is checked. + + The heuristic relies on the debug hooks on Python memory allocators which + fills newly allocated memory with CLEANBYTE (0xCD) and newly freed memory + with DEADBYTE (0xDD). Detect also "untouchable bytes" marked + with FORBIDDENBYTE (0xFD). */ +static inline int _PyMem_IsPtrFreed(const void *ptr) +{ + uintptr_t value = (uintptr_t)ptr; +#if SIZEOF_VOID_P == 8 + return (value == 0 + || value == (uintptr_t)0xCDCDCDCDCDCDCDCD + || value == (uintptr_t)0xDDDDDDDDDDDDDDDD + || value == (uintptr_t)0xFDFDFDFDFDFDFDFD); +#elif SIZEOF_VOID_P == 4 + return (value == 0 + || value == (uintptr_t)0xCDCDCDCD + || value == (uintptr_t)0xDDDDDDDD + || value == (uintptr_t)0xFDFDFDFD); +#else +# error "unknown pointer size" +#endif +} + +PyAPI_FUNC(int) _PyMem_GetAllocatorName( + const char *name, + PyMemAllocatorName *allocator); + +/* Configure the Python memory allocators. + Pass PYMEM_ALLOCATOR_DEFAULT to use default allocators. + PYMEM_ALLOCATOR_NOT_SET does nothing. */ +PyAPI_FUNC(int) _PyMem_SetupAllocators(PyMemAllocatorName allocator); + +struct _PyTraceMalloc_Config { + /* Module initialized? + Variable protected by the GIL */ + enum { + TRACEMALLOC_NOT_INITIALIZED, + TRACEMALLOC_INITIALIZED, + TRACEMALLOC_FINALIZED + } initialized; + + /* Is tracemalloc tracing memory allocations? + Variable protected by the GIL */ + int tracing; + + /* limit of the number of frames in a traceback, 1 by default. + Variable protected by the GIL. */ + int max_nframe; +}; + +#define _PyTraceMalloc_Config_INIT \ + {.initialized = TRACEMALLOC_NOT_INITIALIZED, \ + .tracing = 0, \ + .max_nframe = 1} + +PyAPI_DATA(struct _PyTraceMalloc_Config) _Py_tracemalloc_config; + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYMEM_H */ diff --git a/include/internal/pycore_pystate.h b/include/internal/pycore_pystate.h new file mode 100644 index 00000000..4b894f3e --- /dev/null +++ b/include/internal/pycore_pystate.h @@ -0,0 +1,153 @@ +#ifndef Py_INTERNAL_PYSTATE_H +#define Py_INTERNAL_PYSTATE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_runtime.h" /* PyRuntimeState */ + + +/* Check if the current thread is the main thread. + Use _Py_IsMainInterpreter() to check if it's the main interpreter. */ +static inline int +_Py_IsMainThread(void) +{ + unsigned long thread = PyThread_get_thread_ident(); + return (thread == _PyRuntime.main_thread); +} + + +static inline int +_Py_IsMainInterpreter(PyInterpreterState *interp) +{ + /* Use directly _PyRuntime rather than tstate->interp->runtime, since + this function is used in performance critical code path (ceval) */ + return (interp == _PyRuntime.interpreters.main); +} + + +/* Only handle signals on the main thread of the main interpreter. */ +static inline int +_Py_ThreadCanHandleSignals(PyInterpreterState *interp) +{ + return (_Py_IsMainThread() && interp == _PyRuntime.interpreters.main); +} + + +/* Only execute pending calls on the main thread. */ +static inline int +_Py_ThreadCanHandlePendingCalls(void) +{ + return _Py_IsMainThread(); +} + + +/* Variable and macro for in-line access to current thread + and interpreter state */ + +#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS +PyAPI_FUNC(PyThreadState*) _PyThreadState_GetTSS(void); +#endif + +static inline PyThreadState* +_PyRuntimeState_GetThreadState(_PyRuntimeState *runtime) +{ +#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS + return _PyThreadState_GetTSS(); +#else + return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->gilstate.tstate_current); +#endif +} + +/* Get the current Python thread state. + + Efficient macro reading directly the 'gilstate.tstate_current' atomic + variable. The macro is unsafe: it does not check for error and it can + return NULL. + + The caller must hold the GIL. + + See also PyThreadState_Get() and PyThreadState_GET(). */ +static inline PyThreadState* +_PyThreadState_GET(void) +{ +#ifdef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS + return _PyThreadState_GetTSS(); +#else + return _PyRuntimeState_GetThreadState(&_PyRuntime); +#endif +} + +/* Redefine PyThreadState_GET() as an alias to _PyThreadState_GET() */ +#undef PyThreadState_GET +#define PyThreadState_GET() _PyThreadState_GET() + +PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalError_TstateNULL(const char *func); + +static inline void +_Py_EnsureFuncTstateNotNULL(const char *func, PyThreadState *tstate) +{ + if (tstate == NULL) { + _Py_FatalError_TstateNULL(func); + } +} + +// Call Py_FatalError() if tstate is NULL +#define _Py_EnsureTstateNotNULL(tstate) \ + _Py_EnsureFuncTstateNotNULL(__func__, tstate) + + +/* Get the current interpreter state. + + The macro is unsafe: it does not check for error and it can return NULL. + + The caller must hold the GIL. + + See also _PyInterpreterState_Get() + and _PyGILState_GetInterpreterStateUnsafe(). */ +static inline PyInterpreterState* _PyInterpreterState_GET(void) { + PyThreadState *tstate = _PyThreadState_GET(); +#ifdef Py_DEBUG + _Py_EnsureTstateNotNULL(tstate); +#endif + return tstate->interp; +} + + +/* Other */ + +PyAPI_FUNC(void) _PyThreadState_Init( + PyThreadState *tstate); +PyAPI_FUNC(void) _PyThreadState_DeleteExcept( + _PyRuntimeState *runtime, + PyThreadState *tstate); + +PyAPI_FUNC(PyThreadState *) _PyThreadState_Swap( + struct _gilstate_runtime_state *gilstate, + PyThreadState *newts); + +PyAPI_FUNC(PyStatus) _PyInterpreterState_Enable(_PyRuntimeState *runtime); + +#ifdef HAVE_FORK +extern PyStatus _PyInterpreterState_DeleteExceptMain(_PyRuntimeState *runtime); +extern PyStatus _PyGILState_Reinit(_PyRuntimeState *runtime); +extern void _PySignal_AfterFork(void); +#endif + + +PyAPI_FUNC(int) _PyState_AddModule( + PyThreadState *tstate, + PyObject* module, + struct PyModuleDef* def); + + +PyAPI_FUNC(int) _PyOS_InterruptOccurred(PyThreadState *tstate); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_PYSTATE_H */ diff --git a/include/internal/pycore_runtime.h b/include/internal/pycore_runtime.h new file mode 100644 index 00000000..bcd710c4 --- /dev/null +++ b/include/internal/pycore_runtime.h @@ -0,0 +1,157 @@ +#ifndef Py_INTERNAL_RUNTIME_H +#define Py_INTERNAL_RUNTIME_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "pycore_atomic.h" /* _Py_atomic_address */ +#include "pycore_gil.h" // struct _gil_runtime_state + +/* ceval state */ + +struct _ceval_runtime_state { + /* Request for checking signals. It is shared by all interpreters (see + bpo-40513). Any thread of any interpreter can receive a signal, but only + the main thread of the main interpreter can handle signals: see + _Py_ThreadCanHandleSignals(). */ + _Py_atomic_int signals_pending; +#ifndef EXPERIMENTAL_ISOLATED_SUBINTERPRETERS + struct _gil_runtime_state gil; +#endif +}; + +/* GIL state */ + +struct _gilstate_runtime_state { + /* bpo-26558: Flag to disable PyGILState_Check(). + If set to non-zero, PyGILState_Check() always return 1. */ + int check_enabled; + /* Assuming the current thread holds the GIL, this is the + PyThreadState for the current thread. */ + _Py_atomic_address tstate_current; + /* The single PyInterpreterState used by this process' + GILState implementation + */ + /* TODO: Given interp_main, it may be possible to kill this ref */ + PyInterpreterState *autoInterpreterState; + Py_tss_t autoTSSkey; +}; + +/* Runtime audit hook state */ + +typedef struct _Py_AuditHookEntry { + struct _Py_AuditHookEntry *next; + Py_AuditHookFunction hookCFunction; + void *userData; +} _Py_AuditHookEntry; + +struct _Py_unicode_runtime_ids { + PyThread_type_lock lock; + // next_index value must be preserved when Py_Initialize()/Py_Finalize() + // is called multiple times: see _PyUnicode_FromId() implementation. + Py_ssize_t next_index; +}; + +/* Full Python runtime state */ + +typedef struct pyruntimestate { + /* Is running Py_PreInitialize()? */ + int preinitializing; + + /* Is Python preinitialized? Set to 1 by Py_PreInitialize() */ + int preinitialized; + + /* Is Python core initialized? Set to 1 by _Py_InitializeCore() */ + int core_initialized; + + /* Is Python fully initialized? Set to 1 by Py_Initialize() */ + int initialized; + + /* Set by Py_FinalizeEx(). Only reset to NULL if Py_Initialize() + is called again. + + Use _PyRuntimeState_GetFinalizing() and _PyRuntimeState_SetFinalizing() + to access it, don't access it directly. */ + _Py_atomic_address _finalizing; + + struct pyinterpreters { + PyThread_type_lock mutex; + PyInterpreterState *head; + PyInterpreterState *main; + /* _next_interp_id is an auto-numbered sequence of small + integers. It gets initialized in _PyInterpreterState_Init(), + which is called in Py_Initialize(), and used in + PyInterpreterState_New(). A negative interpreter ID + indicates an error occurred. The main interpreter will + always have an ID of 0. Overflow results in a RuntimeError. + If that becomes a problem later then we can adjust, e.g. by + using a Python int. */ + int64_t next_id; + } interpreters; + // XXX Remove this field once we have a tp_* slot. + struct _xidregistry { + PyThread_type_lock mutex; + struct _xidregitem *head; + } xidregistry; + + unsigned long main_thread; + +#define NEXITFUNCS 32 + void (*exitfuncs[NEXITFUNCS])(void); + int nexitfuncs; + + struct _ceval_runtime_state ceval; + struct _gilstate_runtime_state gilstate; + + PyPreConfig preconfig; + + // Audit values must be preserved when Py_Initialize()/Py_Finalize() + // is called multiple times. + Py_OpenCodeHookFunction open_code_hook; + void *open_code_userdata; + _Py_AuditHookEntry *audit_hook_head; + + struct _Py_unicode_runtime_ids unicode_ids; + + // XXX Consolidate globals found via the check-c-globals script. +} _PyRuntimeState; + +#define _PyRuntimeState_INIT \ + {.preinitialized = 0, .core_initialized = 0, .initialized = 0} +/* Note: _PyRuntimeState_INIT sets other fields to 0/NULL */ + + +PyAPI_DATA(_PyRuntimeState) _PyRuntime; + +PyAPI_FUNC(PyStatus) _PyRuntimeState_Init(_PyRuntimeState *runtime); +PyAPI_FUNC(void) _PyRuntimeState_Fini(_PyRuntimeState *runtime); + +#ifdef HAVE_FORK +extern PyStatus _PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime); +#endif + +/* Initialize _PyRuntimeState. + Return NULL on success, or return an error message on failure. */ +PyAPI_FUNC(PyStatus) _PyRuntime_Initialize(void); + +PyAPI_FUNC(void) _PyRuntime_Finalize(void); + + +static inline PyThreadState* +_PyRuntimeState_GetFinalizing(_PyRuntimeState *runtime) { + return (PyThreadState*)_Py_atomic_load_relaxed(&runtime->_finalizing); +} + +static inline void +_PyRuntimeState_SetFinalizing(_PyRuntimeState *runtime, PyThreadState *tstate) { + _Py_atomic_store_relaxed(&runtime->_finalizing, (uintptr_t)tstate); +} + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_RUNTIME_H */ diff --git a/include/internal/pycore_structseq.h b/include/internal/pycore_structseq.h new file mode 100644 index 00000000..84c8d477 --- /dev/null +++ b/include/internal/pycore_structseq.h @@ -0,0 +1,21 @@ +#ifndef Py_INTERNAL_STRUCTSEQ_H +#define Py_INTERNAL_STRUCTSEQ_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + + +PyAPI_FUNC(int) _PyStructSequence_InitType( + PyTypeObject *type, + PyStructSequence_Desc *desc, + unsigned long tp_flags); + + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_STRUCTSEQ_H */ diff --git a/include/symtable.h b/include/internal/pycore_symtable.h similarity index 74% rename from include/symtable.h rename to include/internal/pycore_symtable.h index 007f88db..a2e520b8 100644 --- a/include/symtable.h +++ b/include/internal/pycore_symtable.h @@ -1,18 +1,25 @@ -#ifndef Py_LIMITED_API -#ifndef Py_SYMTABLE_H -#define Py_SYMTABLE_H - +#ifndef Py_INTERNAL_SYMTABLE_H +#define Py_INTERNAL_SYMTABLE_H #ifdef __cplusplus extern "C" { #endif -/* XXX(ncoghlan): This is a weird mix of public names and interpreter internal - * names. - */ +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +struct _mod; // Type defined in pycore_ast.h -typedef enum _block_type { FunctionBlock, ClassBlock, ModuleBlock } +typedef enum _block_type { FunctionBlock, ClassBlock, ModuleBlock, AnnotationBlock } _Py_block_ty; +typedef enum _comprehension_type { + NoComprehension = 0, + ListComprehension = 1, + DictComprehension = 2, + SetComprehension = 3, + GeneratorExpression = 4 } _Py_comprehension_ty; + struct _symtable_entry; struct symtable { @@ -42,13 +49,14 @@ typedef struct _symtable_entry { PyObject *ste_varnames; /* list of function parameters */ PyObject *ste_children; /* list of child blocks */ PyObject *ste_directives;/* locations of global and nonlocal statements */ - _Py_block_ty ste_type; /* module, class, or function */ + _Py_block_ty ste_type; /* module, class or function */ int ste_nested; /* true if block is nested */ unsigned ste_free : 1; /* true if block has free variables */ unsigned ste_child_free : 1; /* true if a child block has free vars, including free refs to globals */ unsigned ste_generator : 1; /* true if namespace is a generator */ unsigned ste_coroutine : 1; /* true if namespace is a coroutine */ + _Py_comprehension_ty ste_comprehension; /* Kind of comprehension (if any) */ unsigned ste_varargs : 1; /* true if block has varargs */ unsigned ste_varkeywords : 1; /* true if block has varkeywords */ unsigned ste_returns_value : 1; /* true if namespace uses return with @@ -56,30 +64,30 @@ typedef struct _symtable_entry { unsigned ste_needs_class_closure : 1; /* for class scopes, true if a closure over __class__ should be created */ + unsigned ste_comp_iter_target : 1; /* true if visiting comprehension target */ + int ste_comp_iter_expr; /* non-zero if visiting a comprehension range expression */ int ste_lineno; /* first line of block */ int ste_col_offset; /* offset of first line of block */ + int ste_end_lineno; /* end line of block */ + int ste_end_col_offset; /* end offset of first line of block */ int ste_opt_lineno; /* lineno of last exec or import * */ int ste_opt_col_offset; /* offset of last exec or import * */ struct symtable *ste_table; } PySTEntryObject; -PyAPI_DATA(PyTypeObject) PySTEntry_Type; +extern PyTypeObject PySTEntry_Type; -#define PySTEntry_Check(op) (Py_TYPE(op) == &PySTEntry_Type) +#define PySTEntry_Check(op) Py_IS_TYPE(op, &PySTEntry_Type) -PyAPI_FUNC(int) PyST_GetScope(PySTEntryObject *, PyObject *); +extern int _PyST_GetScope(PySTEntryObject *, PyObject *); -PyAPI_FUNC(struct symtable *) PySymtable_Build( - mod_ty mod, - const char *filename, /* decoded from the filesystem encoding */ - PyFutureFeatures *future); -PyAPI_FUNC(struct symtable *) PySymtable_BuildObject( - mod_ty mod, +extern struct symtable* _PySymtable_Build( + struct _mod *mod, PyObject *filename, PyFutureFeatures *future); PyAPI_FUNC(PySTEntryObject *) PySymtable_Lookup(struct symtable *, void *); -PyAPI_FUNC(void) PySymtable_Free(struct symtable *); +extern void _PySymtable_Free(struct symtable *); /* Flags for def-use information */ @@ -92,6 +100,7 @@ PyAPI_FUNC(void) PySymtable_Free(struct symtable *); #define DEF_FREE_CLASS 2<<5 /* free variable from class's method */ #define DEF_IMPORT 2<<6 /* assignment occurred via import */ #define DEF_ANNOT 2<<7 /* this name is annotated */ +#define DEF_COMP_ITER 2<<8 /* this name is a comprehension iteration variable */ #define DEF_BOUND (DEF_LOCAL | DEF_PARAM | DEF_IMPORT) @@ -111,8 +120,14 @@ PyAPI_FUNC(void) PySymtable_Free(struct symtable *); #define GENERATOR 1 #define GENERATOR_EXPRESSION 2 +// Used by symtablemodule.c +extern struct symtable* _Py_SymtableStringObjectFlags( + const char *str, + PyObject *filename, + int start, + PyCompilerFlags *flags); + #ifdef __cplusplus } #endif -#endif /* !Py_SYMTABLE_H */ -#endif /* Py_LIMITED_API */ +#endif /* !Py_INTERNAL_SYMTABLE_H */ diff --git a/include/internal/pycore_sysmodule.h b/include/internal/pycore_sysmodule.h new file mode 100644 index 00000000..738a7746 --- /dev/null +++ b/include/internal/pycore_sysmodule.h @@ -0,0 +1,24 @@ +#ifndef Py_INTERNAL_SYSMODULE_H +#define Py_INTERNAL_SYSMODULE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +PyAPI_FUNC(int) _PySys_Audit( + PyThreadState *tstate, + const char *event, + const char *argFormat, + ...); + +/* We want minimal exposure of this function, so use extern rather than + PyAPI_FUNC() to not export the symbol. */ +extern void _PySys_ClearAuditHooks(PyThreadState *tstate); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_SYSMODULE_H */ diff --git a/include/internal/pycore_traceback.h b/include/internal/pycore_traceback.h new file mode 100644 index 00000000..c01a4763 --- /dev/null +++ b/include/internal/pycore_traceback.h @@ -0,0 +1,93 @@ +#ifndef Py_INTERNAL_TRACEBACK_H +#define Py_INTERNAL_TRACEBACK_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* Forward declaration */ +struct _is; + +/* Write the Python traceback into the file 'fd'. For example: + + Traceback (most recent call first): + File "xxx", line xxx in + File "xxx", line xxx in + ... + File "xxx", line xxx in + + This function is written for debug purpose only, to dump the traceback in + the worst case: after a segmentation fault, at fatal error, etc. That's why, + it is very limited. Strings are truncated to 100 characters and encoded to + ASCII with backslashreplace. It doesn't write the source code, only the + function name, filename and line number of each frame. Write only the first + 100 frames: if the traceback is truncated, write the line " ...". + + This function is signal safe. */ + +PyAPI_FUNC(void) _Py_DumpTraceback( + int fd, + PyThreadState *tstate); + +/* Write the traceback of all threads into the file 'fd'. current_thread can be + NULL. + + Return NULL on success, or an error message on error. + + This function is written for debug purpose only. It calls + _Py_DumpTraceback() for each thread, and so has the same limitations. It + only write the traceback of the first 100 threads: write "..." if there are + more threads. + + If current_tstate is NULL, the function tries to get the Python thread state + of the current thread. It is not an error if the function is unable to get + the current Python thread state. + + If interp is NULL, the function tries to get the interpreter state from + the current Python thread state, or from + _PyGILState_GetInterpreterStateUnsafe() in last resort. + + It is better to pass NULL to interp and current_tstate, the function tries + different options to retrieve this information. + + This function is signal safe. */ + +PyAPI_FUNC(const char*) _Py_DumpTracebackThreads( + int fd, + struct _is *interp, + PyThreadState *current_tstate); + +/* Write a Unicode object into the file descriptor fd. Encode the string to + ASCII using the backslashreplace error handler. + + Do nothing if text is not a Unicode object. The function accepts Unicode + string which is not ready (PyUnicode_WCHAR_KIND). + + This function is signal safe. */ +PyAPI_FUNC(void) _Py_DumpASCII(int fd, PyObject *text); + +/* Format an integer as decimal into the file descriptor fd. + + This function is signal safe. */ +PyAPI_FUNC(void) _Py_DumpDecimal( + int fd, + size_t value); + +/* Format an integer as hexadecimal with width digits into fd file descriptor. + The function is signal safe. */ +PyAPI_FUNC(void) _Py_DumpHexadecimal( + int fd, + uintptr_t value, + Py_ssize_t width); + +PyAPI_FUNC(PyObject*) _PyTraceBack_FromFrame( + PyObject *tb_next, + PyFrameObject *frame); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_TRACEBACK_H */ diff --git a/include/internal/pycore_tuple.h b/include/internal/pycore_tuple.h new file mode 100644 index 00000000..5353e18d --- /dev/null +++ b/include/internal/pycore_tuple.h @@ -0,0 +1,20 @@ +#ifndef Py_INTERNAL_TUPLE_H +#define Py_INTERNAL_TUPLE_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +#include "tupleobject.h" /* _PyTuple_CAST() */ + +#define _PyTuple_ITEMS(op) (_PyTuple_CAST(op)->ob_item) + +PyAPI_FUNC(PyObject *) _PyTuple_FromArray(PyObject *const *, Py_ssize_t); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_TUPLE_H */ diff --git a/include/internal/pycore_ucnhash.h b/include/internal/pycore_ucnhash.h new file mode 100644 index 00000000..187dd68e --- /dev/null +++ b/include/internal/pycore_ucnhash.h @@ -0,0 +1,34 @@ +/* Unicode name database interface */ +#ifndef Py_INTERNAL_UCNHASH_H +#define Py_INTERNAL_UCNHASH_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +/* revised ucnhash CAPI interface (exported through a "wrapper") */ + +#define PyUnicodeData_CAPSULE_NAME "unicodedata._ucnhash_CAPI" + +typedef struct { + + /* Get name for a given character code. + Returns non-zero if success, zero if not. + Does not set Python exceptions. */ + int (*getname)(Py_UCS4 code, char* buffer, int buflen, + int with_alias_and_seq); + + /* Get character code for a given name. + Same error handling as for getname(). */ + int (*getcode)(const char* name, int namelen, Py_UCS4* code, + int with_named_seq); + +} _PyUnicode_Name_CAPI; + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_UCNHASH_H */ diff --git a/include/internal/pycore_unionobject.h b/include/internal/pycore_unionobject.h new file mode 100644 index 00000000..9962f576 --- /dev/null +++ b/include/internal/pycore_unionobject.h @@ -0,0 +1,22 @@ +#ifndef Py_INTERNAL_UNIONOBJECT_H +#define Py_INTERNAL_UNIONOBJECT_H +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif + +extern PyTypeObject _PyUnion_Type; +#define _PyUnion_Check(op) Py_IS_TYPE(op, &_PyUnion_Type) +extern PyObject *_Py_union_type_or(PyObject *, PyObject *); + +#define _PyGenericAlias_Check(op) PyObject_TypeCheck(op, &Py_GenericAliasType) +extern PyObject *_Py_subs_parameters(PyObject *, PyObject *, PyObject *, PyObject *); +extern PyObject *_Py_make_parameters(PyObject *); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERNAL_UNIONOBJECT_H */ diff --git a/include/internal/warnings.h b/include/internal/pycore_warnings.h similarity index 77% rename from include/internal/warnings.h rename to include/internal/pycore_warnings.h index 2878a28a..f728ec30 100644 --- a/include/internal/warnings.h +++ b/include/internal/pycore_warnings.h @@ -4,7 +4,9 @@ extern "C" { #endif -#include "object.h" +#ifndef Py_BUILD_CORE +# error "this header requires Py_BUILD_CORE define" +#endif struct _warnings_runtime_state { /* Both 'filters' and 'onceregistry' can be set in warnings.py; @@ -15,6 +17,8 @@ struct _warnings_runtime_state { long filters_version; }; +extern int _PyWarnings_InitState(PyInterpreterState *interp); + #ifdef __cplusplus } #endif diff --git a/include/internal/pystate.h b/include/internal/pystate.h deleted file mode 100644 index 5891339b..00000000 --- a/include/internal/pystate.h +++ /dev/null @@ -1,135 +0,0 @@ -#ifndef Py_INTERNAL_PYSTATE_H -#define Py_INTERNAL_PYSTATE_H -#ifdef __cplusplus -extern "C" { -#endif - -#include "pystate.h" -#include "pyatomic.h" -#include "pythread.h" - -#include "internal/mem.h" -#include "internal/ceval.h" -#include "internal/warnings.h" - - -/* GIL state */ - -struct _gilstate_runtime_state { - int check_enabled; - /* Assuming the current thread holds the GIL, this is the - PyThreadState for the current thread. */ - _Py_atomic_address tstate_current; - PyThreadFrameGetter getframe; - /* The single PyInterpreterState used by this process' - GILState implementation - */ - /* TODO: Given interp_main, it may be possible to kill this ref */ - PyInterpreterState *autoInterpreterState; - Py_tss_t autoTSSkey; -}; - -/* hook for PyEval_GetFrame(), requested for Psyco */ -#define _PyThreadState_GetFrame _PyRuntime.gilstate.getframe - -/* Issue #26558: Flag to disable PyGILState_Check(). - If set to non-zero, PyGILState_Check() always return 1. */ -#define _PyGILState_check_enabled _PyRuntime.gilstate.check_enabled - - -typedef struct { - /* Full path to the Python program */ - wchar_t *program_full_path; - wchar_t *prefix; -#ifdef MS_WINDOWS - wchar_t *dll_path; -#else - wchar_t *exec_prefix; -#endif - /* Set by Py_SetPath(), or computed by _PyPathConfig_Init() */ - wchar_t *module_search_path; - /* Python program name */ - wchar_t *program_name; - /* Set by Py_SetPythonHome() or PYTHONHOME environment variable */ - wchar_t *home; -} _PyPathConfig; - -#define _PyPathConfig_INIT {.module_search_path = NULL} -/* Note: _PyPathConfig_INIT sets other fields to 0/NULL */ - -PyAPI_DATA(_PyPathConfig) _Py_path_config; - -PyAPI_FUNC(_PyInitError) _PyPathConfig_Calculate( - _PyPathConfig *config, - const _PyCoreConfig *core_config); -PyAPI_FUNC(void) _PyPathConfig_Clear(_PyPathConfig *config); - - -/* interpreter state */ - -PyAPI_FUNC(PyInterpreterState *) _PyInterpreterState_LookUpID(PY_INT64_T); - -PyAPI_FUNC(int) _PyInterpreterState_IDInitref(PyInterpreterState *); -PyAPI_FUNC(void) _PyInterpreterState_IDIncref(PyInterpreterState *); -PyAPI_FUNC(void) _PyInterpreterState_IDDecref(PyInterpreterState *); - -/* Full Python runtime state */ - -typedef struct pyruntimestate { - int initialized; - int core_initialized; - PyThreadState *finalizing; - - struct pyinterpreters { - PyThread_type_lock mutex; - PyInterpreterState *head; - PyInterpreterState *main; - /* _next_interp_id is an auto-numbered sequence of small - integers. It gets initialized in _PyInterpreterState_Init(), - which is called in Py_Initialize(), and used in - PyInterpreterState_New(). A negative interpreter ID - indicates an error occurred. The main interpreter will - always have an ID of 0. Overflow results in a RuntimeError. - If that becomes a problem later then we can adjust, e.g. by - using a Python int. */ - int64_t next_id; - } interpreters; - -#define NEXITFUNCS 32 - void (*exitfuncs[NEXITFUNCS])(void); - int nexitfuncs; - - struct _gc_runtime_state gc; - struct _warnings_runtime_state warnings; - struct _ceval_runtime_state ceval; - struct _gilstate_runtime_state gilstate; - - // XXX Consolidate globals found via the check-c-globals script. -} _PyRuntimeState; - -#define _PyRuntimeState_INIT {.initialized = 0, .core_initialized = 0} -/* Note: _PyRuntimeState_INIT sets other fields to 0/NULL */ - -PyAPI_DATA(_PyRuntimeState) _PyRuntime; -PyAPI_FUNC(_PyInitError) _PyRuntimeState_Init(_PyRuntimeState *); -PyAPI_FUNC(void) _PyRuntimeState_Fini(_PyRuntimeState *); - -/* Initialize _PyRuntimeState. - Return NULL on success, or return an error message on failure. */ -PyAPI_FUNC(_PyInitError) _PyRuntime_Initialize(void); - -PyAPI_FUNC(void) _PyRuntime_Finalize(void); - - -#define _Py_CURRENTLY_FINALIZING(tstate) \ - (_PyRuntime.finalizing == tstate) - - -/* Other */ - -PyAPI_FUNC(_PyInitError) _PyInterpreterState_Enable(_PyRuntimeState *); - -#ifdef __cplusplus -} -#endif -#endif /* !Py_INTERNAL_PYSTATE_H */ diff --git a/include/interpreteridobject.h b/include/interpreteridobject.h new file mode 100644 index 00000000..e744fcdc --- /dev/null +++ b/include/interpreteridobject.h @@ -0,0 +1,17 @@ +#ifndef Py_INTERPRETERIDOBJECT_H +#define Py_INTERPRETERIDOBJECT_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef Py_LIMITED_API +# define Py_CPYTHON_INTERPRETERIDOBJECT_H +# include "cpython/interpreteridobject.h" +# undef Py_CPYTHON_INTERPRETERIDOBJECT_H +#endif + +#ifdef __cplusplus +} +#endif +#endif /* !Py_INTERPRETERIDOBJECT_H */ diff --git a/include/intrcheck.h b/include/intrcheck.h index 2e17336c..b8cc6560 100644 --- a/include/intrcheck.h +++ b/include/intrcheck.h @@ -1,4 +1,3 @@ - #ifndef Py_INTRCHECK_H #define Py_INTRCHECK_H #ifdef __cplusplus @@ -6,7 +5,6 @@ extern "C" { #endif PyAPI_FUNC(int) PyOS_InterruptOccurred(void); -PyAPI_FUNC(void) PyOS_InitInterrupts(void); #ifdef HAVE_FORK #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 PyAPI_FUNC(void) PyOS_BeforeFork(void); @@ -15,11 +13,10 @@ PyAPI_FUNC(void) PyOS_AfterFork_Child(void); #endif #endif /* Deprecated, please use PyOS_AfterFork_Child() instead */ -PyAPI_FUNC(void) PyOS_AfterFork(void) Py_DEPRECATED(3.7); +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyOS_AfterFork(void); #ifndef Py_LIMITED_API PyAPI_FUNC(int) _PyOS_IsMainThread(void); -PyAPI_FUNC(void) _PySignal_AfterFork(void); #ifdef MS_WINDOWS /* windows.h is not included by Python.h so use void* instead of HANDLE */ diff --git a/include/iterobject.h b/include/iterobject.h index f61726f1..6454611a 100644 --- a/include/iterobject.h +++ b/include/iterobject.h @@ -7,14 +7,16 @@ extern "C" { PyAPI_DATA(PyTypeObject) PySeqIter_Type; PyAPI_DATA(PyTypeObject) PyCallIter_Type; -PyAPI_DATA(PyTypeObject) PyCmpWrapper_Type; +#ifdef Py_BUILD_CORE +extern PyTypeObject _PyAnextAwaitable_Type; +#endif -#define PySeqIter_Check(op) (Py_TYPE(op) == &PySeqIter_Type) +#define PySeqIter_Check(op) Py_IS_TYPE(op, &PySeqIter_Type) PyAPI_FUNC(PyObject *) PySeqIter_New(PyObject *); -#define PyCallIter_Check(op) (Py_TYPE(op) == &PyCallIter_Type) +#define PyCallIter_Check(op) Py_IS_TYPE(op, &PyCallIter_Type) PyAPI_FUNC(PyObject *) PyCallIter_New(PyObject *, PyObject *); diff --git a/include/listobject.h b/include/listobject.h index 6057279d..2a8a2552 100644 --- a/include/listobject.h +++ b/include/listobject.h @@ -1,16 +1,14 @@ +/* List object interface -/* List object interface */ + Another generally useful object type is a list of object pointers. + This is a mutable type: the list items can be changed, and items can be + added or removed. Out-of-range indices or non-list objects are ignored. -/* -Another generally useful object type is a list of object pointers. -This is a mutable type: the list items can be changed, and items can be -added or removed. Out-of-range indices or non-list objects are ignored. - -*** WARNING *** PyList_SetItem does not increment the new item's reference -count, but does decrement the reference count of the item it replaces, -if not nil. It does *decrement* the reference count if it is *not* -inserted in the list. Similarly, PyList_GetItem does not increment the -returned item's reference count. + WARNING: PyList_SetItem does not increment the new item's reference count, + but does decrement the reference count of the item it replaces, if not nil. + It does *decrement* the reference count if it is *not* inserted in the list. + Similarly, PyList_GetItem does not increment the returned item's reference + count. */ #ifndef Py_LISTOBJECT_H @@ -19,60 +17,33 @@ returned item's reference count. extern "C" { #endif -#ifndef Py_LIMITED_API -typedef struct { - PyObject_VAR_HEAD - /* Vector of pointers to list elements. list[0] is ob_item[0], etc. */ - PyObject **ob_item; - - /* ob_item contains space for 'allocated' elements. The number - * currently in use is ob_size. - * Invariants: - * 0 <= ob_size <= allocated - * len(list) == ob_size - * ob_item == NULL implies ob_size == allocated == 0 - * list.sort() temporarily sets allocated to -1 to detect mutations. - * - * Items must normally not be NULL, except during construction when - * the list is not yet visible outside the function that builds it. - */ - Py_ssize_t allocated; -} PyListObject; -#endif - PyAPI_DATA(PyTypeObject) PyList_Type; PyAPI_DATA(PyTypeObject) PyListIter_Type; PyAPI_DATA(PyTypeObject) PyListRevIter_Type; -PyAPI_DATA(PyTypeObject) PySortWrapper_Type; #define PyList_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LIST_SUBCLASS) -#define PyList_CheckExact(op) (Py_TYPE(op) == &PyList_Type) +#define PyList_CheckExact(op) Py_IS_TYPE(op, &PyList_Type) PyAPI_FUNC(PyObject *) PyList_New(Py_ssize_t size); PyAPI_FUNC(Py_ssize_t) PyList_Size(PyObject *); + PyAPI_FUNC(PyObject *) PyList_GetItem(PyObject *, Py_ssize_t); PyAPI_FUNC(int) PyList_SetItem(PyObject *, Py_ssize_t, PyObject *); PyAPI_FUNC(int) PyList_Insert(PyObject *, Py_ssize_t, PyObject *); PyAPI_FUNC(int) PyList_Append(PyObject *, PyObject *); + PyAPI_FUNC(PyObject *) PyList_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t); PyAPI_FUNC(int) PyList_SetSlice(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *); + PyAPI_FUNC(int) PyList_Sort(PyObject *); PyAPI_FUNC(int) PyList_Reverse(PyObject *); PyAPI_FUNC(PyObject *) PyList_AsTuple(PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyList_Extend(PyListObject *, PyObject *); - -PyAPI_FUNC(int) PyList_ClearFreeList(void); -PyAPI_FUNC(void) _PyList_DebugMallocStats(FILE *out); -#endif -/* Macro, trading safety for speed */ #ifndef Py_LIMITED_API -#define PyList_GET_ITEM(op, i) (((PyListObject *)(op))->ob_item[i]) -#define PyList_SET_ITEM(op, i, v) (((PyListObject *)(op))->ob_item[i] = (v)) -#define PyList_GET_SIZE(op) (assert(PyList_Check(op)),Py_SIZE(op)) -#define _PyList_ITEMS(op) (((PyListObject *)(op))->ob_item) +# define Py_CPYTHON_LISTOBJECT_H +# include "cpython/listobject.h" +# undef Py_CPYTHON_LISTOBJECT_H #endif #ifdef __cplusplus diff --git a/include/longobject.h b/include/longobject.h index 7bdd0472..e2301d7a 100644 --- a/include/longobject.h +++ b/include/longobject.h @@ -13,7 +13,7 @@ PyAPI_DATA(PyTypeObject) PyLong_Type; #define PyLong_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_LONG_SUBCLASS) -#define PyLong_CheckExact(op) (Py_TYPE(op) == &PyLong_Type) +#define PyLong_CheckExact(op) Py_IS_TYPE(op, &PyLong_Type) PyAPI_FUNC(PyObject *) PyLong_FromLong(long); PyAPI_FUNC(PyObject *) PyLong_FromUnsignedLong(unsigned long); @@ -65,8 +65,16 @@ PyAPI_FUNC(PyObject *) PyLong_GetInfo(void); # error "void* different in size from int, long and long long" #endif /* SIZEOF_VOID_P */ +#ifndef Py_LIMITED_API +PyAPI_FUNC(int) _PyLong_UnsignedShort_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_UnsignedInt_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_UnsignedLong_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_UnsignedLongLong_Converter(PyObject *, void *); +PyAPI_FUNC(int) _PyLong_Size_t_Converter(PyObject *, void *); +#endif + /* Used by Python/mystrtoul.c, _PyBytes_FromHex(), - _PyBytes_DecodeEscapeRecode(), etc. */ + _PyBytes_DecodeEscape(), etc. */ #ifndef Py_LIMITED_API PyAPI_DATA(unsigned char) _PyLong_DigitValue[256]; #endif @@ -94,7 +102,6 @@ PyAPI_FUNC(long long) PyLong_AsLongLongAndOverflow(PyObject *, int *); PyAPI_FUNC(PyObject *) PyLong_FromString(const char *, char **, int); #ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) PyLong_FromUnicode(Py_UNICODE*, Py_ssize_t, int) Py_DEPRECATED(3.3); PyAPI_FUNC(PyObject *) PyLong_FromUnicodeObject(PyObject *u, int base); PyAPI_FUNC(PyObject *) _PyLong_FromBytes(const char *, Py_ssize_t, int); #endif @@ -164,13 +171,6 @@ PyAPI_FUNC(int) _PyLong_AsByteArray(PyLongObject* v, unsigned char* bytes, size_t n, int little_endian, int is_signed); -/* _PyLong_FromNbInt: Convert the given object to a PyLongObject - using the nb_int slot, if available. Raise TypeError if either the - nb_int slot is not available or the result of the call to nb_int - returns something not of type int. -*/ -PyAPI_FUNC(PyLongObject *)_PyLong_FromNbInt(PyObject *); - /* _PyLong_Format: Convert the long to a string object with given base, appending a base prefix of 0[box] if base is 2, 8 or 16. */ PyAPI_FUNC(PyObject *) _PyLong_Format(PyObject *obj, int base); @@ -210,8 +210,8 @@ PyAPI_FUNC(PyObject *) _PyLong_GCD(PyObject *, PyObject *); #endif /* !Py_LIMITED_API */ #ifndef Py_LIMITED_API -PyAPI_DATA(PyObject *) _PyLong_Zero; -PyAPI_DATA(PyObject *) _PyLong_One; +PyAPI_FUNC(PyObject *) _PyLong_Rshift(PyObject *, size_t); +PyAPI_FUNC(PyObject *) _PyLong_Lshift(PyObject *, size_t); #endif #ifdef __cplusplus diff --git a/include/magic_enum/magic_enum.hpp b/include/magic_enum/magic_enum.hpp index 59e58666..cc7f1412 100644 --- a/include/magic_enum/magic_enum.hpp +++ b/include/magic_enum/magic_enum.hpp @@ -62,6 +62,8 @@ #if defined(__clang__) # pragma clang diagnostic push +# pragma clang diagnostic ignored "-Wunknown-warning-option" +# pragma clang diagnostic ignored "-Wenum-constexpr-conversion" #elif defined(__GNUC__) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wmaybe-uninitialized" // May be used uninitialized 'return {};'. @@ -213,7 +215,7 @@ class static_string { template constexpr static_string(string_view str, std::integer_sequence) noexcept : chars_{str[I]..., '\0'} {} - char chars_[N + 1]; + char chars_[static_cast(N) + 1]; }; template <> @@ -244,12 +246,12 @@ constexpr string_view pretty_name(string_view name) noexcept { } } - if (name.size() > 0 && ((name.front() >= 'a' && name.front() <= 'z') || - (name.front() >= 'A' && name.front() <= 'Z') || + if (name.size() > 0 && ((name[0] >= 'a' && name[0] <= 'z') || + (name[0] >= 'A' && name[0] <= 'Z') || #if defined(MAGIC_ENUM_ENABLE_NONASCII) - (name.front() & 0x80) || + (name[0]) & 0x80) || #endif - (name.front() == '_'))) { + (name[0] == '_'))) { return name; } @@ -291,7 +293,7 @@ constexpr std::size_t find(string_view str, char c) noexcept { return string_view::npos; } else { - return str.find_first_of(c); + return str.find(c); } } @@ -381,13 +383,7 @@ template constexpr auto n() noexcept { static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); - [[maybe_unused]] constexpr auto custom = customize::enum_type_name(); - static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); - if constexpr (custom.index() == 0) { - constexpr auto name = std::get(custom); - static_assert(!name.empty(), "magic_enum::customize requires not empty string."); - return static_string{name}; - } else if constexpr (custom.index() == 1 && supported::value) { + if constexpr (supported::value) { #if defined(__clang__) || defined(__GNUC__) constexpr auto name = pretty_name({__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 2}); #elif defined(_MSC_VER) @@ -402,19 +398,28 @@ constexpr auto n() noexcept { } template -inline constexpr auto type_name_v = n(); - -template -constexpr auto n() noexcept { +constexpr auto type_name() noexcept { static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); - [[maybe_unused]] constexpr auto custom = customize::enum_name(V); + [[maybe_unused]] constexpr auto custom = customize::enum_type_name(); static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); - if constexpr (custom.index() == 0) { + if constexpr (std::is_same_v, customize::customize_t> && custom.index() == 0) { constexpr auto name = std::get(custom); static_assert(!name.empty(), "magic_enum::customize requires not empty string."); return static_string{name}; - } else if constexpr (custom.index() == 1 && supported::value) { + } else { + return n(); + } +} + +template +inline constexpr auto type_name_v = type_name(); + +template +constexpr auto n() noexcept { + static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); + + if constexpr (supported::value) { #if defined(__clang__) || defined(__GNUC__) constexpr auto name = pretty_name({__PRETTY_FUNCTION__, sizeof(__PRETTY_FUNCTION__) - 2}); #elif defined(_MSC_VER) @@ -429,30 +434,66 @@ constexpr auto n() noexcept { } template -inline constexpr auto enum_name_v = n(); +constexpr auto enum_name() noexcept { + static_assert(is_enum_v, "magic_enum::detail::n requires enum type."); + + [[maybe_unused]] constexpr auto custom = customize::enum_name(V); + static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); + if constexpr (std::is_same_v, customize::customize_t> && custom.index() == 0) { + constexpr auto name = std::get(custom); + static_assert(!name.empty(), "magic_enum::customize requires not empty string."); + return static_string{name}; + } else { + return n(); + } +} + +template +inline constexpr auto enum_name_v = enum_name(); template constexpr bool is_valid() noexcept { static_assert(is_enum_v, "magic_enum::detail::is_valid requires enum type."); - return n(V)>().size() != 0; +#if defined(__clang__) && __clang_major__ >= 16 + // https://reviews.llvm.org/D130058, https://reviews.llvm.org/D131307 + constexpr E v = __builtin_bit_cast(E, V); + [[maybe_unused]] constexpr auto custom = customize::enum_name(v); + static_assert(std::is_same_v, customize::customize_t>, "magic_enum::customize requires customize_t type."); + if constexpr (std::is_same_v, customize::customize_t> && custom.index() == 0) { + constexpr auto name = std::get(custom); + static_assert(!name.empty(), "magic_enum::customize requires not empty string."); + return name.size() != 0; + } else { + return n().size() != 0; + } +#else + return enum_name(V)>().size() != 0; +#endif } template > -constexpr E value(std::size_t i) noexcept { - static_assert(is_enum_v, "magic_enum::detail::value requires enum type."); +constexpr U ualue(std::size_t i) noexcept { + static_assert(is_enum_v, "magic_enum::detail::ualue requires enum type."); if constexpr (std::is_same_v) { // bool special case - static_assert(O == 0, "magic_enum::detail::value requires valid offset."); + static_assert(O == 0, "magic_enum::detail::ualue requires valid offset."); - return static_cast(i); + return static_cast(i); } else if constexpr (IsFlags) { - return static_cast(U{1} << static_cast(static_cast(i) + O)); + return static_cast(U{1} << static_cast(static_cast(i) + O)); } else { - return static_cast(static_cast(i) + O); + return static_cast(static_cast(i) + O); } } +template > +constexpr E value(std::size_t i) noexcept { + static_assert(is_enum_v, "magic_enum::detail::value requires enum type."); + + return static_cast(ualue(i)); +} + template > constexpr int reflected_min() noexcept { static_assert(is_enum_v, "magic_enum::detail::reflected_min requires enum type."); @@ -510,7 +551,7 @@ constexpr std::size_t values_count(const bool (&valid)[N]) noexcept { template constexpr auto values(std::index_sequence) noexcept { static_assert(is_enum_v, "magic_enum::detail::values requires enum type."); - constexpr bool valid[sizeof...(I)] = {is_valid(I)>()...}; + constexpr bool valid[sizeof...(I)] = {is_valid(I)>()...}; constexpr std::size_t count = values_count(valid); if constexpr (count > 0) { @@ -748,7 +789,7 @@ struct constexpr_hash_t -[[maybe_unused]] constexpr static Hash hash_v{}; +inline constexpr Hash hash_v{}; template constexpr auto calculate_cases(std::size_t Page) noexcept { diff --git a/include/memoryobject.h b/include/memoryobject.h index 990a716f..306028f4 100644 --- a/include/memoryobject.h +++ b/include/memoryobject.h @@ -11,7 +11,7 @@ PyAPI_DATA(PyTypeObject) _PyManagedBuffer_Type; #endif PyAPI_DATA(PyTypeObject) PyMemoryView_Type; -#define PyMemoryView_Check(op) (Py_TYPE(op) == &PyMemoryView_Type) +#define PyMemoryView_Check(op) Py_IS_TYPE(op, &PyMemoryView_Type) #ifndef Py_LIMITED_API /* Get a pointer to the memoryview's private copy of the exporter's buffer. */ diff --git a/include/metagrammar.h b/include/metagrammar.h deleted file mode 100644 index 15c8ef8f..00000000 --- a/include/metagrammar.h +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef Py_METAGRAMMAR_H -#define Py_METAGRAMMAR_H -#ifdef __cplusplus -extern "C" { -#endif - - -#define MSTART 256 -#define RULE 257 -#define RHS 258 -#define ALT 259 -#define ITEM 260 -#define ATOM 261 - -#ifdef __cplusplus -} -#endif -#endif /* !Py_METAGRAMMAR_H */ diff --git a/include/methodobject.h b/include/methodobject.h index ea35d86b..9ffe8e1a 100644 --- a/include/methodobject.h +++ b/include/methodobject.h @@ -13,7 +13,8 @@ extern "C" { PyAPI_DATA(PyTypeObject) PyCFunction_Type; -#define PyCFunction_Check(op) (Py_TYPE(op) == &PyCFunction_Type) +#define PyCFunction_CheckExact(op) Py_IS_TYPE(op, &PyCFunction_Type) +#define PyCFunction_Check(op) PyObject_TypeCheck(op, &PyCFunction_Type) typedef PyObject *(*PyCFunction)(PyObject *, PyObject *); typedef PyObject *(*_PyCFunctionFast) (PyObject *, PyObject *const *, Py_ssize_t); @@ -22,36 +23,14 @@ typedef PyObject *(*PyCFunctionWithKeywords)(PyObject *, PyObject *, typedef PyObject *(*_PyCFunctionFastWithKeywords) (PyObject *, PyObject *const *, Py_ssize_t, PyObject *); -typedef PyObject *(*PyNoArgsFunction)(PyObject *); +typedef PyObject *(*PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, + size_t, PyObject *); PyAPI_FUNC(PyCFunction) PyCFunction_GetFunction(PyObject *); PyAPI_FUNC(PyObject *) PyCFunction_GetSelf(PyObject *); PyAPI_FUNC(int) PyCFunction_GetFlags(PyObject *); -/* Macros for direct access to these values. Type checks are *not* - done, so use with care. */ -#ifndef Py_LIMITED_API -#define PyCFunction_GET_FUNCTION(func) \ - (((PyCFunctionObject *)func) -> m_ml -> ml_meth) -#define PyCFunction_GET_SELF(func) \ - (((PyCFunctionObject *)func) -> m_ml -> ml_flags & METH_STATIC ? \ - NULL : ((PyCFunctionObject *)func) -> m_self) -#define PyCFunction_GET_FLAGS(func) \ - (((PyCFunctionObject *)func) -> m_ml -> ml_flags) -#endif -PyAPI_FUNC(PyObject *) PyCFunction_Call(PyObject *, PyObject *, PyObject *); - -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyCFunction_FastCallDict(PyObject *func, - PyObject *const *args, - Py_ssize_t nargs, - PyObject *kwargs); - -PyAPI_FUNC(PyObject *) _PyCFunction_FastCallKeywords(PyObject *func, - PyObject *const *stack, - Py_ssize_t nargs, - PyObject *kwnames); -#endif +Py_DEPRECATED(3.9) PyAPI_FUNC(PyObject *) PyCFunction_Call(PyObject *, PyObject *, PyObject *); struct PyMethodDef { const char *ml_name; /* The name of the built-in function/method */ @@ -62,10 +41,23 @@ struct PyMethodDef { }; typedef struct PyMethodDef PyMethodDef; +/* PyCFunction_New is declared as a function for stable ABI (declaration is + * needed for e.g. GCC with -fvisibility=hidden), but redefined as a macro + * that calls PyCFunction_NewEx. */ +PyAPI_FUNC(PyObject *) PyCFunction_New(PyMethodDef *, PyObject *); #define PyCFunction_New(ML, SELF) PyCFunction_NewEx((ML), (SELF), NULL) + +/* PyCFunction_NewEx is similar: on 3.9+, this calls PyCMethod_New. */ PyAPI_FUNC(PyObject *) PyCFunction_NewEx(PyMethodDef *, PyObject *, PyObject *); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +#define PyCFunction_NewEx(ML, SELF, MOD) PyCMethod_New((ML), (SELF), (MOD), NULL) +PyAPI_FUNC(PyObject *) PyCMethod_New(PyMethodDef *, PyObject *, + PyObject *, PyTypeObject *); +#endif + + /* Flag passed to newmethodobject */ /* #define METH_OLDARGS 0x0000 -- unsupported now */ #define METH_VARARGS 0x0001 @@ -87,46 +79,35 @@ PyAPI_FUNC(PyObject *) PyCFunction_NewEx(PyMethodDef *, PyObject *, #define METH_COEXIST 0x0040 -#ifndef Py_LIMITED_API -#define METH_FASTCALL 0x0080 +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030a0000 +# define METH_FASTCALL 0x0080 #endif /* This bit is preserved for Stackless Python */ #ifdef STACKLESS -#define METH_STACKLESS 0x0100 +# define METH_STACKLESS 0x0100 #else -#define METH_STACKLESS 0x0000 +# define METH_STACKLESS 0x0000 #endif -#ifndef Py_LIMITED_API -typedef struct { - PyObject_HEAD - PyMethodDef *m_ml; /* Description of the C function to call */ - PyObject *m_self; /* Passed as 'self' arg to the C func, can be NULL */ - PyObject *m_module; /* The __module__ attribute, can be anything */ - PyObject *m_weakreflist; /* List of weak references */ -} PyCFunctionObject; - -PyAPI_FUNC(PyObject *) _PyMethodDef_RawFastCallDict( - PyMethodDef *method, - PyObject *self, - PyObject *const *args, - Py_ssize_t nargs, - PyObject *kwargs); - -PyAPI_FUNC(PyObject *) _PyMethodDef_RawFastCallKeywords( - PyMethodDef *method, - PyObject *self, - PyObject *const *args, - Py_ssize_t nargs, - PyObject *kwnames); +/* METH_METHOD means the function stores an + * additional reference to the class that defines it; + * both self and class are passed to it. + * It uses PyCMethodObject instead of PyCFunctionObject. + * May not be combined with METH_NOARGS, METH_O, METH_CLASS or METH_STATIC. + */ + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +#define METH_METHOD 0x0200 #endif -PyAPI_FUNC(int) PyCFunction_ClearFreeList(void); #ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyCFunction_DebugMallocStats(FILE *out); -PyAPI_FUNC(void) _PyMethod_DebugMallocStats(FILE *out); + +#define Py_CPYTHON_METHODOBJECT_H +#include "cpython/methodobject.h" +#undef Py_CPYTHON_METHODOBJECT_H + #endif #ifdef __cplusplus diff --git a/include/modsupport.h b/include/modsupport.h index a238bef0..f009d586 100644 --- a/include/modsupport.h +++ b/include/modsupport.h @@ -60,12 +60,22 @@ PyAPI_FUNC(int) _PyArg_UnpackStack( ...); PyAPI_FUNC(int) _PyArg_NoKeywords(const char *funcname, PyObject *kwargs); +PyAPI_FUNC(int) _PyArg_NoKwnames(const char *funcname, PyObject *kwnames); PyAPI_FUNC(int) _PyArg_NoPositional(const char *funcname, PyObject *args); #define _PyArg_NoKeywords(funcname, kwargs) \ ((kwargs) == NULL || _PyArg_NoKeywords((funcname), (kwargs))) +#define _PyArg_NoKwnames(funcname, kwnames) \ + ((kwnames) == NULL || _PyArg_NoKwnames((funcname), (kwnames))) #define _PyArg_NoPositional(funcname, args) \ ((args) == NULL || _PyArg_NoPositional((funcname), (args))) +PyAPI_FUNC(void) _PyArg_BadArgument(const char *, const char *, const char *, PyObject *); +PyAPI_FUNC(int) _PyArg_CheckPositional(const char *, Py_ssize_t, + Py_ssize_t, Py_ssize_t); +#define _PyArg_CheckPositional(funcname, nargs, min, max) \ + (((min) <= (nargs) && (nargs) <= (max)) \ + || _PyArg_CheckPositional((funcname), (nargs), (min), (max))) + #endif PyAPI_FUNC(PyObject *) Py_VaBuildValue(const char *, va_list); @@ -111,12 +121,36 @@ PyAPI_FUNC(int) _PyArg_ParseStackAndKeywords( ...); PyAPI_FUNC(int) _PyArg_VaParseTupleAndKeywordsFast(PyObject *, PyObject *, struct _PyArg_Parser *, va_list); +PyAPI_FUNC(PyObject * const *) _PyArg_UnpackKeywords( + PyObject *const *args, Py_ssize_t nargs, + PyObject *kwargs, PyObject *kwnames, + struct _PyArg_Parser *parser, + int minpos, int maxpos, int minkw, + PyObject **buf); +#define _PyArg_UnpackKeywords(args, nargs, kwargs, kwnames, parser, minpos, maxpos, minkw, buf) \ + (((minkw) == 0 && (kwargs) == NULL && (kwnames) == NULL && \ + (minpos) <= (nargs) && (nargs) <= (maxpos) && args != NULL) ? (args) : \ + _PyArg_UnpackKeywords((args), (nargs), (kwargs), (kwnames), (parser), \ + (minpos), (maxpos), (minkw), (buf))) + void _PyArg_Fini(void); #endif /* Py_LIMITED_API */ -PyAPI_FUNC(int) PyModule_AddObject(PyObject *, const char *, PyObject *); +// Add an attribute with name 'name' and value 'obj' to the module 'mod. +// On success, return 0 on success. +// On error, raise an exception and return -1. +PyAPI_FUNC(int) PyModule_AddObjectRef(PyObject *mod, const char *name, PyObject *value); + +// Similar to PyModule_AddObjectRef() but steal a reference to 'obj' +// (Py_DECREF(obj)) on success (if it returns 0). +PyAPI_FUNC(int) PyModule_AddObject(PyObject *mod, const char *, PyObject *value); + PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject *, const char *, long); PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char *); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* New in 3.9 */ +PyAPI_FUNC(int) PyModule_AddType(PyObject *module, PyTypeObject *type); +#endif /* Py_LIMITED_API */ #define PyModule_AddIntMacro(m, c) PyModule_AddIntConstant(m, #c, c) #define PyModule_AddStringMacro(m, c) PyModule_AddStringConstant(m, #c, c) diff --git a/include/moduleobject.h b/include/moduleobject.h index 1d8fe46d..49b116ca 100644 --- a/include/moduleobject.h +++ b/include/moduleobject.h @@ -10,7 +10,7 @@ extern "C" { PyAPI_DATA(PyTypeObject) PyModule_Type; #define PyModule_Check(op) PyObject_TypeCheck(op, &PyModule_Type) -#define PyModule_CheckExact(op) (Py_TYPE(op) == &PyModule_Type) +#define PyModule_CheckExact(op) Py_IS_TYPE(op, &PyModule_Type) #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject *) PyModule_NewObject( @@ -25,11 +25,12 @@ PyAPI_FUNC(PyObject *) PyModule_GetDict(PyObject *); PyAPI_FUNC(PyObject *) PyModule_GetNameObject(PyObject *); #endif PyAPI_FUNC(const char *) PyModule_GetName(PyObject *); -PyAPI_FUNC(const char *) PyModule_GetFilename(PyObject *) Py_DEPRECATED(3.2); +Py_DEPRECATED(3.2) PyAPI_FUNC(const char *) PyModule_GetFilename(PyObject *); PyAPI_FUNC(PyObject *) PyModule_GetFilenameObject(PyObject *); #ifndef Py_LIMITED_API PyAPI_FUNC(void) _PyModule_Clear(PyObject *); PyAPI_FUNC(void) _PyModule_ClearDict(PyObject *); +PyAPI_FUNC(int) _PyModuleSpec_IsInitializing(PyObject *); #endif PyAPI_FUNC(struct PyModuleDef*) PyModule_GetDef(PyObject*); PyAPI_FUNC(void*) PyModule_GetState(PyObject*); @@ -83,6 +84,12 @@ typedef struct PyModuleDef{ freefunc m_free; } PyModuleDef; + +// Internal C API +#ifdef Py_BUILD_CORE +extern int _PyModule_IsExtension(PyObject *obj); +#endif + #ifdef __cplusplus } #endif diff --git a/include/node.h b/include/node.h deleted file mode 100644 index 40596dfe..00000000 --- a/include/node.h +++ /dev/null @@ -1,44 +0,0 @@ - -/* Parse tree node interface */ - -#ifndef Py_NODE_H -#define Py_NODE_H -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct _node { - short n_type; - char *n_str; - int n_lineno; - int n_col_offset; - int n_nchildren; - struct _node *n_child; -} node; - -PyAPI_FUNC(node *) PyNode_New(int type); -PyAPI_FUNC(int) PyNode_AddChild(node *n, int type, - char *str, int lineno, int col_offset); -PyAPI_FUNC(void) PyNode_Free(node *n); -#ifndef Py_LIMITED_API -PyAPI_FUNC(Py_ssize_t) _PyNode_SizeOf(node *n); -#endif - -/* Node access functions */ -#define NCH(n) ((n)->n_nchildren) - -#define CHILD(n, i) (&(n)->n_child[i]) -#define RCHILD(n, i) (CHILD(n, NCH(n) + i)) -#define TYPE(n) ((n)->n_type) -#define STR(n) ((n)->n_str) -#define LINENO(n) ((n)->n_lineno) - -/* Assert that the type of a node is what we expect */ -#define REQ(n, type) assert(TYPE(n) == (type)) - -PyAPI_FUNC(void) PyNode_ListTree(node *); - -#ifdef __cplusplus -} -#endif -#endif /* !Py_NODE_H */ diff --git a/include/object.h b/include/object.h index e212fca1..61e638c3 100644 --- a/include/object.h +++ b/include/object.h @@ -1,5 +1,6 @@ #ifndef Py_OBJECT_H #define Py_OBJECT_H + #ifdef __cplusplus extern "C" { #endif @@ -51,20 +52,18 @@ A standard interface exists for objects that contain an array of items whose size is determined when the object is allocated. */ -/* Py_DEBUG implies Py_TRACE_REFS. */ -#if defined(Py_DEBUG) && !defined(Py_TRACE_REFS) -#define Py_TRACE_REFS -#endif - -/* Py_TRACE_REFS implies Py_REF_DEBUG. */ -#if defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG) -#define Py_REF_DEBUG +/* Py_DEBUG implies Py_REF_DEBUG. */ +#if defined(Py_DEBUG) && !defined(Py_REF_DEBUG) +# define Py_REF_DEBUG #endif -#if defined(Py_LIMITED_API) && defined(Py_REF_DEBUG) -#error Py_LIMITED_API is incompatible with Py_DEBUG, Py_TRACE_REFS, and Py_REF_DEBUG +#if defined(Py_LIMITED_API) && defined(Py_TRACE_REFS) +# error Py_LIMITED_API is incompatible with Py_TRACE_REFS #endif +/* PyTypeObject structure is defined in cpython/object.h. + In Py_LIMITED_API, PyTypeObject is an opaque structure. */ +typedef struct _typeobject PyTypeObject; #ifdef Py_TRACE_REFS /* Define pointers to support a doubly-linked list of all live heap objects. */ @@ -75,8 +74,8 @@ whose size is determined when the object is allocated. #define _PyObject_EXTRA_INIT 0, 0, #else -#define _PyObject_HEAD_EXTRA -#define _PyObject_EXTRA_INIT +# define _PyObject_HEAD_EXTRA +# define _PyObject_EXTRA_INIT #endif /* PyObject_HEAD defines the initial segment of every PyObject. */ @@ -106,50 +105,66 @@ whose size is determined when the object is allocated. typedef struct _object { _PyObject_HEAD_EXTRA Py_ssize_t ob_refcnt; - struct _typeobject *ob_type; + PyTypeObject *ob_type; } PyObject; +/* Cast argument to PyObject* type. */ +#define _PyObject_CAST(op) ((PyObject*)(op)) +#define _PyObject_CAST_CONST(op) ((const PyObject*)(op)) + typedef struct { PyObject ob_base; Py_ssize_t ob_size; /* Number of items in variable part */ } PyVarObject; -#define Py_REFCNT(ob) (((PyObject*)(ob))->ob_refcnt) -#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type) -#define Py_SIZE(ob) (((PyVarObject*)(ob))->ob_size) +/* Cast argument to PyVarObject* type. */ +#define _PyVarObject_CAST(op) ((PyVarObject*)(op)) +#define _PyVarObject_CAST_CONST(op) ((const PyVarObject*)(op)) -#ifndef Py_LIMITED_API -/********************* String Literals ****************************************/ -/* This structure helps managing static strings. The basic usage goes like this: - Instead of doing - r = PyObject_CallMethod(o, "foo", "args", ...); +// Test if the 'x' object is the 'y' object, the same as "x is y" in Python. +PyAPI_FUNC(int) Py_Is(PyObject *x, PyObject *y); +#define Py_Is(x, y) ((x) == (y)) - do - _Py_IDENTIFIER(foo); - ... - r = _PyObject_CallMethodId(o, &PyId_foo, "args", ...); +static inline Py_ssize_t _Py_REFCNT(const PyObject *ob) { + return ob->ob_refcnt; +} +#define Py_REFCNT(ob) _Py_REFCNT(_PyObject_CAST_CONST(ob)) - PyId_foo is a static variable, either on block level or file level. On first - usage, the string "foo" is interned, and the structures are linked. On interpreter - shutdown, all strings are released (through _PyUnicode_ClearStaticStrings). - Alternatively, _Py_static_string allows choosing the variable name. - _PyUnicode_FromId returns a borrowed reference to the interned string. - _PyObject_{Get,Set,Has}AttrId are __getattr__ versions using _Py_Identifier*. -*/ -typedef struct _Py_Identifier { - struct _Py_Identifier *next; - const char* string; - PyObject *object; -} _Py_Identifier; +// bpo-39573: The Py_SET_TYPE() function must be used to set an object type. +#define Py_TYPE(ob) (_PyObject_CAST(ob)->ob_type) + +// bpo-39573: The Py_SET_SIZE() function must be used to set an object size. +#define Py_SIZE(ob) (_PyVarObject_CAST(ob)->ob_size) -#define _Py_static_string_init(value) { .next = NULL, .string = value, .object = NULL } -#define _Py_static_string(varname, value) static _Py_Identifier varname = _Py_static_string_init(value) -#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname) -#endif /* !Py_LIMITED_API */ +static inline int _Py_IS_TYPE(const PyObject *ob, const PyTypeObject *type) { + // bpo-44378: Don't use Py_TYPE() since Py_TYPE() requires a non-const + // object. + return ob->ob_type == type; +} +#define Py_IS_TYPE(ob, type) _Py_IS_TYPE(_PyObject_CAST_CONST(ob), type) + + +static inline void _Py_SET_REFCNT(PyObject *ob, Py_ssize_t refcnt) { + ob->ob_refcnt = refcnt; +} +#define Py_SET_REFCNT(ob, refcnt) _Py_SET_REFCNT(_PyObject_CAST(ob), refcnt) + + +static inline void _Py_SET_TYPE(PyObject *ob, PyTypeObject *type) { + ob->ob_type = type; +} +#define Py_SET_TYPE(ob, type) _Py_SET_TYPE(_PyObject_CAST(ob), type) + + +static inline void _Py_SET_SIZE(PyVarObject *ob, Py_ssize_t size) { + ob->ob_size = size; +} +#define Py_SET_SIZE(ob, size) _Py_SET_SIZE(_PyVarObject_CAST(ob), size) + /* Type objects contain a string containing the type name (to help somewhat @@ -177,154 +192,13 @@ typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *); typedef int(*ssizessizeobjargproc)(PyObject *, Py_ssize_t, Py_ssize_t, PyObject *); typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *); -#ifndef Py_LIMITED_API -/* buffer interface */ -typedef struct bufferinfo { - void *buf; - PyObject *obj; /* owned reference */ - Py_ssize_t len; - Py_ssize_t itemsize; /* This is Py_ssize_t so it can be - pointed to by strides in simple case.*/ - int readonly; - int ndim; - char *format; - Py_ssize_t *shape; - Py_ssize_t *strides; - Py_ssize_t *suboffsets; - void *internal; -} Py_buffer; - -typedef int (*getbufferproc)(PyObject *, Py_buffer *, int); -typedef void (*releasebufferproc)(PyObject *, Py_buffer *); - -/* Maximum number of dimensions */ -#define PyBUF_MAX_NDIM 64 - -/* Flags for getting buffers */ -#define PyBUF_SIMPLE 0 -#define PyBUF_WRITABLE 0x0001 -/* we used to include an E, backwards compatible alias */ -#define PyBUF_WRITEABLE PyBUF_WRITABLE -#define PyBUF_FORMAT 0x0004 -#define PyBUF_ND 0x0008 -#define PyBUF_STRIDES (0x0010 | PyBUF_ND) -#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES) -#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES) -#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES) -#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES) - -#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE) -#define PyBUF_CONTIG_RO (PyBUF_ND) - -#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE) -#define PyBUF_STRIDED_RO (PyBUF_STRIDES) - -#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT) -#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT) - -#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT) -#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT) - - -#define PyBUF_READ 0x100 -#define PyBUF_WRITE 0x200 - -/* End buffer interface */ -#endif /* Py_LIMITED_API */ - typedef int (*objobjproc)(PyObject *, PyObject *); typedef int (*visitproc)(PyObject *, void *); typedef int (*traverseproc)(PyObject *, visitproc, void *); -#ifndef Py_LIMITED_API -typedef struct { - /* Number implementations must check *both* - arguments for proper type and implement the necessary conversions - in the slot functions themselves. */ - - binaryfunc nb_add; - binaryfunc nb_subtract; - binaryfunc nb_multiply; - binaryfunc nb_remainder; - binaryfunc nb_divmod; - ternaryfunc nb_power; - unaryfunc nb_negative; - unaryfunc nb_positive; - unaryfunc nb_absolute; - inquiry nb_bool; - unaryfunc nb_invert; - binaryfunc nb_lshift; - binaryfunc nb_rshift; - binaryfunc nb_and; - binaryfunc nb_xor; - binaryfunc nb_or; - unaryfunc nb_int; - void *nb_reserved; /* the slot formerly known as nb_long */ - unaryfunc nb_float; - - binaryfunc nb_inplace_add; - binaryfunc nb_inplace_subtract; - binaryfunc nb_inplace_multiply; - binaryfunc nb_inplace_remainder; - ternaryfunc nb_inplace_power; - binaryfunc nb_inplace_lshift; - binaryfunc nb_inplace_rshift; - binaryfunc nb_inplace_and; - binaryfunc nb_inplace_xor; - binaryfunc nb_inplace_or; - - binaryfunc nb_floor_divide; - binaryfunc nb_true_divide; - binaryfunc nb_inplace_floor_divide; - binaryfunc nb_inplace_true_divide; - - unaryfunc nb_index; - - binaryfunc nb_matrix_multiply; - binaryfunc nb_inplace_matrix_multiply; -} PyNumberMethods; - -typedef struct { - lenfunc sq_length; - binaryfunc sq_concat; - ssizeargfunc sq_repeat; - ssizeargfunc sq_item; - void *was_sq_slice; - ssizeobjargproc sq_ass_item; - void *was_sq_ass_slice; - objobjproc sq_contains; - - binaryfunc sq_inplace_concat; - ssizeargfunc sq_inplace_repeat; -} PySequenceMethods; - -typedef struct { - lenfunc mp_length; - binaryfunc mp_subscript; - objobjargproc mp_ass_subscript; -} PyMappingMethods; - -typedef struct { - unaryfunc am_await; - unaryfunc am_aiter; - unaryfunc am_anext; -} PyAsyncMethods; - -typedef struct { - getbufferproc bf_getbuffer; - releasebufferproc bf_releasebuffer; -} PyBufferProcs; -#endif /* Py_LIMITED_API */ typedef void (*freefunc)(void *); typedef void (*destructor)(PyObject *); -#ifndef Py_LIMITED_API -/* We can't provide a full compile-time check that limited-API - users won't implement tp_print. However, not defining printfunc - and making tp_print of a different function pointer type - should at least cause a warning in most cases. */ -typedef int (*printfunc)(PyObject *, FILE *, int); -#endif typedef PyObject *(*getattrfunc)(PyObject *, char *); typedef PyObject *(*getattrofunc)(PyObject *, PyObject *); typedef int (*setattrfunc)(PyObject *, char *, PyObject *); @@ -337,103 +211,8 @@ typedef PyObject *(*iternextfunc) (PyObject *); typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *); typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *); typedef int (*initproc)(PyObject *, PyObject *, PyObject *); -typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *); -typedef PyObject *(*allocfunc)(struct _typeobject *, Py_ssize_t); - -#ifdef Py_LIMITED_API -typedef struct _typeobject PyTypeObject; /* opaque */ -#else -typedef struct _typeobject { - PyObject_VAR_HEAD - const char *tp_name; /* For printing, in format "." */ - Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */ - - /* Methods to implement standard operations */ - - destructor tp_dealloc; - printfunc tp_print; - getattrfunc tp_getattr; - setattrfunc tp_setattr; - PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2) - or tp_reserved (Python 3) */ - reprfunc tp_repr; - - /* Method suites for standard classes */ - - PyNumberMethods *tp_as_number; - PySequenceMethods *tp_as_sequence; - PyMappingMethods *tp_as_mapping; - - /* More standard operations (here for binary compatibility) */ - - hashfunc tp_hash; - ternaryfunc tp_call; - reprfunc tp_str; - getattrofunc tp_getattro; - setattrofunc tp_setattro; - - /* Functions to access object as input/output buffer */ - PyBufferProcs *tp_as_buffer; - - /* Flags to define presence of optional/expanded features */ - unsigned long tp_flags; - - const char *tp_doc; /* Documentation string */ - - /* Assigned meaning in release 2.0 */ - /* call function for all accessible objects */ - traverseproc tp_traverse; - - /* delete references to contained objects */ - inquiry tp_clear; - - /* Assigned meaning in release 2.1 */ - /* rich comparisons */ - richcmpfunc tp_richcompare; - - /* weak reference enabler */ - Py_ssize_t tp_weaklistoffset; - - /* Iterators */ - getiterfunc tp_iter; - iternextfunc tp_iternext; - - /* Attribute descriptor and subclassing stuff */ - struct PyMethodDef *tp_methods; - struct PyMemberDef *tp_members; - struct PyGetSetDef *tp_getset; - struct _typeobject *tp_base; - PyObject *tp_dict; - descrgetfunc tp_descr_get; - descrsetfunc tp_descr_set; - Py_ssize_t tp_dictoffset; - initproc tp_init; - allocfunc tp_alloc; - newfunc tp_new; - freefunc tp_free; /* Low-level free-memory routine */ - inquiry tp_is_gc; /* For PyObject_IS_GC */ - PyObject *tp_bases; - PyObject *tp_mro; /* method resolution order */ - PyObject *tp_cache; - PyObject *tp_subclasses; - PyObject *tp_weaklist; - destructor tp_del; - - /* Type attribute cache version tag. Added in version 2.6 */ - unsigned int tp_version_tag; - - destructor tp_finalize; - -#ifdef COUNT_ALLOCS - /* these must be last and never explicitly initialized */ - Py_ssize_t tp_allocs; - Py_ssize_t tp_frees; - Py_ssize_t tp_maxalloc; - struct _typeobject *tp_prev; - struct _typeobject *tp_next; -#endif -} PyTypeObject; -#endif +typedef PyObject *(*newfunc)(PyTypeObject *, PyObject *, PyObject *); +typedef PyObject *(*allocfunc)(PyTypeObject *, Py_ssize_t); typedef struct{ int slot; /* slot id, see below */ @@ -455,36 +234,19 @@ PyAPI_FUNC(PyObject*) PyType_FromSpecWithBases(PyType_Spec*, PyObject*); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03040000 PyAPI_FUNC(void*) PyType_GetSlot(PyTypeObject*, int); #endif - -#ifndef Py_LIMITED_API -/* The *real* layout of a type object when allocated on the heap */ -typedef struct _heaptypeobject { - /* Note: there's a dependency on the order of these members - in slotptr() in typeobject.c . */ - PyTypeObject ht_type; - PyAsyncMethods as_async; - PyNumberMethods as_number; - PyMappingMethods as_mapping; - PySequenceMethods as_sequence; /* as_sequence comes after as_mapping, - so that the mapping wins when both - the mapping and the sequence define - a given operator (e.g. __getitem__). - see add_operators() in typeobject.c . */ - PyBufferProcs as_buffer; - PyObject *ht_name, *ht_slots, *ht_qualname; - struct _dictkeysobject *ht_cached_keys; - /* here are optional user slots, followed by the members. */ -} PyHeapTypeObject; - -/* access macro to the members which are floating "behind" the object */ -#define PyHeapType_GET_MEMBERS(etype) \ - ((PyMemberDef *)(((char *)etype) + Py_TYPE(etype)->tp_basicsize)) +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +PyAPI_FUNC(PyObject*) PyType_FromModuleAndSpec(PyObject *, PyType_Spec *, PyObject *); +PyAPI_FUNC(PyObject *) PyType_GetModule(struct _typeobject *); +PyAPI_FUNC(void *) PyType_GetModuleState(struct _typeobject *); #endif /* Generic type check */ PyAPI_FUNC(int) PyType_IsSubtype(PyTypeObject *, PyTypeObject *); -#define PyObject_TypeCheck(ob, tp) \ - (Py_TYPE(ob) == (tp) || PyType_IsSubtype(Py_TYPE(ob), (tp))) + +static inline int _PyObject_TypeCheck(PyObject *ob, PyTypeObject *type) { + return Py_IS_TYPE(ob, type) || PyType_IsSubtype(Py_TYPE(ob), type); +} +#define PyObject_TypeCheck(ob, type) _PyObject_TypeCheck(_PyObject_CAST(ob), type) PyAPI_DATA(PyTypeObject) PyType_Type; /* built-in 'type' */ PyAPI_DATA(PyTypeObject) PyBaseObject_Type; /* built-in 'object' */ @@ -492,37 +254,14 @@ PyAPI_DATA(PyTypeObject) PySuper_Type; /* built-in 'super' */ PyAPI_FUNC(unsigned long) PyType_GetFlags(PyTypeObject*); -#define PyType_Check(op) \ - PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS) -#define PyType_CheckExact(op) (Py_TYPE(op) == &PyType_Type) - PyAPI_FUNC(int) PyType_Ready(PyTypeObject *); PyAPI_FUNC(PyObject *) PyType_GenericAlloc(PyTypeObject *, Py_ssize_t); PyAPI_FUNC(PyObject *) PyType_GenericNew(PyTypeObject *, PyObject *, PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(const char *) _PyType_Name(PyTypeObject *); -PyAPI_FUNC(PyObject *) _PyType_Lookup(PyTypeObject *, PyObject *); -PyAPI_FUNC(PyObject *) _PyType_LookupId(PyTypeObject *, _Py_Identifier *); -PyAPI_FUNC(PyObject *) _PyObject_LookupSpecial(PyObject *, _Py_Identifier *); -PyAPI_FUNC(PyTypeObject *) _PyType_CalculateMetaclass(PyTypeObject *, PyObject *); -#endif PyAPI_FUNC(unsigned int) PyType_ClearCache(void); PyAPI_FUNC(void) PyType_Modified(PyTypeObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyType_GetDocFromInternalDoc(const char *, const char *); -PyAPI_FUNC(PyObject *) _PyType_GetTextSignatureFromInternalDoc(const char *, const char *); -#endif - /* Generic operations on objects */ -#ifndef Py_LIMITED_API -struct _Py_Identifier; -PyAPI_FUNC(int) PyObject_Print(PyObject *, FILE *, int); -PyAPI_FUNC(void) _Py_BreakPoint(void); -PyAPI_FUNC(void) _PyObject_Dump(PyObject *); -PyAPI_FUNC(int) _PyObject_IsFreed(PyObject *); -#endif PyAPI_FUNC(PyObject *) PyObject_Repr(PyObject *); PyAPI_FUNC(PyObject *) PyObject_Str(PyObject *); PyAPI_FUNC(PyObject *) PyObject_ASCII(PyObject *); @@ -535,31 +274,9 @@ PyAPI_FUNC(int) PyObject_HasAttrString(PyObject *, const char *); PyAPI_FUNC(PyObject *) PyObject_GetAttr(PyObject *, PyObject *); PyAPI_FUNC(int) PyObject_SetAttr(PyObject *, PyObject *, PyObject *); PyAPI_FUNC(int) PyObject_HasAttr(PyObject *, PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyObject_IsAbstract(PyObject *); -PyAPI_FUNC(PyObject *) _PyObject_GetAttrId(PyObject *, struct _Py_Identifier *); -PyAPI_FUNC(int) _PyObject_SetAttrId(PyObject *, struct _Py_Identifier *, PyObject *); -PyAPI_FUNC(int) _PyObject_HasAttrId(PyObject *, struct _Py_Identifier *); -/* Replacements of PyObject_GetAttr() and _PyObject_GetAttrId() which - don't raise AttributeError. - - Return 1 and set *result != NULL if an attribute is found. - Return 0 and set *result == NULL if an attribute is not found; - an AttributeError is silenced. - Return -1 and set *result == NULL if an error other than AttributeError - is raised. -*/ -PyAPI_FUNC(int) _PyObject_LookupAttr(PyObject *, PyObject *, PyObject **); -PyAPI_FUNC(int) _PyObject_LookupAttrId(PyObject *, struct _Py_Identifier *, PyObject **); -PyAPI_FUNC(PyObject **) _PyObject_GetDictPtr(PyObject *); -#endif PyAPI_FUNC(PyObject *) PyObject_SelfIter(PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyObject_NextNotImplemented(PyObject *); -#endif PyAPI_FUNC(PyObject *) PyObject_GenericGetAttr(PyObject *, PyObject *); -PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *, - PyObject *, PyObject *); +PyAPI_FUNC(int) PyObject_GenericSetAttr(PyObject *, PyObject *, PyObject *); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(int) PyObject_GenericSetDict(PyObject *, PyObject *, void *); #endif @@ -568,28 +285,7 @@ PyAPI_FUNC(Py_hash_t) PyObject_HashNotImplemented(PyObject *); PyAPI_FUNC(int) PyObject_IsTrue(PyObject *); PyAPI_FUNC(int) PyObject_Not(PyObject *); PyAPI_FUNC(int) PyCallable_Check(PyObject *); - PyAPI_FUNC(void) PyObject_ClearWeakRefs(PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) PyObject_CallFinalizer(PyObject *); -PyAPI_FUNC(int) PyObject_CallFinalizerFromDealloc(PyObject *); -#endif - -#ifndef Py_LIMITED_API -/* Same as PyObject_Generic{Get,Set}Attr, but passing the attributes - dict as the last parameter. */ -PyAPI_FUNC(PyObject *) -_PyObject_GenericGetAttrWithDict(PyObject *, PyObject *, PyObject *, int); -PyAPI_FUNC(int) -_PyObject_GenericSetAttrWithDict(PyObject *, PyObject *, - PyObject *, PyObject *); -#endif /* !Py_LIMITED_API */ - -/* Helper to look up a builtin object */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) -_PyObject_GetBuiltin(const char *name); -#endif /* PyObject_Dir(obj) acts like Python builtins.dir(obj), returning a list of strings. PyObject_Dir(NULL) is like builtins.dir(), @@ -607,17 +303,14 @@ PyAPI_FUNC(void) Py_ReprLeave(PyObject *); #define Py_PRINT_RAW 1 /* No string quotes etc. */ /* -`Type flags (tp_flags) +Type flags (tp_flags) -These flags are used to extend the type structure in a backwards-compatible -fashion. Extensions can use the flags to indicate (and test) when a given -type structure contains a new feature. The Python core will use these when -introducing new functionality between major revisions (to avoid mid-version -changes in the PYTHON_API_VERSION). +These flags are used to change expected features and behavior for a +particular type. Arbitration of the flag bit positions will need to be coordinated among all extension writers who publicly release their extensions (this will -be fewer than you might expect!).. +be fewer than you might expect!). Most flags were removed as of Python 3.0 to make room for new flags. (Some flags are not for backwards compatibility but to indicate the presence of an @@ -629,19 +322,40 @@ Code can use PyType_HasFeature(type_ob, flag_value) to test whether the given type object has a specified feature. */ +#ifndef Py_LIMITED_API +/* Set if instances of the type object are treated as sequences for pattern matching */ +#define Py_TPFLAGS_SEQUENCE (1 << 5) +/* Set if instances of the type object are treated as mappings for pattern matching */ +#define Py_TPFLAGS_MAPPING (1 << 6) +#endif + +/* Disallow creating instances of the type: set tp_new to NULL and don't create + * the "__new__" key in the type dictionary. */ +#define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7) + +/* Set if the type object is immutable: type attributes cannot be set nor deleted */ +#define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8) + /* Set if the type object is dynamically allocated */ #define Py_TPFLAGS_HEAPTYPE (1UL << 9) /* Set if the type allows subclassing */ #define Py_TPFLAGS_BASETYPE (1UL << 10) +/* Set if the type implements the vectorcall protocol (PEP 590) */ +#ifndef Py_LIMITED_API +#define Py_TPFLAGS_HAVE_VECTORCALL (1UL << 11) +// Backwards compatibility alias for API that was provisional in Python 3.8 +#define _Py_TPFLAGS_HAVE_VECTORCALL Py_TPFLAGS_HAVE_VECTORCALL +#endif + /* Set if the type is 'ready' -- fully initialized */ #define Py_TPFLAGS_READY (1UL << 12) /* Set while the type is being 'readied', to prevent recursive ready calls */ #define Py_TPFLAGS_READYING (1UL << 13) -/* Objects support garbage collection (see objimp.h) */ +/* Objects support garbage collection (see objimpl.h) */ #define Py_TPFLAGS_HAVE_GC (1UL << 14) /* These two bits are preserved for Stackless Python, next after this is 17 */ @@ -651,13 +365,20 @@ given type object has a specified feature. #define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION 0 #endif -/* Objects support type attribute cache */ -#define Py_TPFLAGS_HAVE_VERSION_TAG (1UL << 18) +/* Objects behave like an unbound method */ +#define Py_TPFLAGS_METHOD_DESCRIPTOR (1UL << 17) + +/* Object has up-to-date type attribute cache */ #define Py_TPFLAGS_VALID_VERSION_TAG (1UL << 19) /* Type is abstract and cannot be instantiated */ #define Py_TPFLAGS_IS_ABSTRACT (1UL << 20) +// This undocumented flag gives certain built-ins their unique pattern-matching +// behavior, which allows a single positional subpattern to match against the +// subject itself (rather than a mapped attribute on it): +#define _Py_TPFLAGS_MATCH_SELF (1UL << 22) + /* These flags are used to determine if a type is a subclass. */ #define Py_TPFLAGS_LONG_SUBCLASS (1UL << 24) #define Py_TPFLAGS_LIST_SUBCLASS (1UL << 25) @@ -670,21 +391,23 @@ given type object has a specified feature. #define Py_TPFLAGS_DEFAULT ( \ Py_TPFLAGS_HAVE_STACKLESS_EXTENSION | \ - Py_TPFLAGS_HAVE_VERSION_TAG | \ 0) -/* NOTE: The following flags reuse lower bits (removed as part of the +/* NOTE: Some of the following flags reuse lower bits (removed as part of the * Python 3.0 transition). */ -/* Type structure has tp_finalize member (3.4) */ +/* The following flags are kept for compatibility; in previous + * versions they indicated presence of newer tp_* fields on the + * type struct. + * Starting with 3.8, binary compatibility of C extensions across + * feature releases of Python is not supported anymore (except when + * using the stable ABI, in which all classes are created dynamically, + * using the interpreter's memory layout.) + * Note that older extensions using the stable ABI set these flags, + * so the bits must not be repurposed. + */ #define Py_TPFLAGS_HAVE_FINALIZE (1UL << 0) - -#ifdef Py_LIMITED_API -#define PyType_HasFeature(t,f) ((PyType_GetFlags(t) & (f)) != 0) -#else -#define PyType_HasFeature(t,f) (((t)->tp_flags & (f)) != 0) -#endif -#define PyType_FastSubclass(t,f) PyType_HasFeature(t,f) +#define Py_TPFLAGS_HAVE_VERSION_TAG (1UL << 18) /* @@ -715,95 +438,75 @@ decision that's up to the implementer of each new type so if you want, you can count such references to the type object.) */ -/* First define a pile of simple helper macros, one set per special - * build symbol. These either expand to the obvious things, or to - * nothing at all when the special mode isn't in effect. The main - * macros can later be defined just once then, yet expand to different - * things depending on which special build options are and aren't in effect. - * Trust me : while painful, this is 20x easier to understand than, - * e.g, defining _Py_NewReference five different times in a maze of nested - * #ifdefs (we used to do that -- it was impenetrable). - */ #ifdef Py_REF_DEBUG PyAPI_DATA(Py_ssize_t) _Py_RefTotal; -PyAPI_FUNC(void) _Py_NegativeRefcount(const char *fname, - int lineno, PyObject *op); -PyAPI_FUNC(Py_ssize_t) _Py_GetRefTotal(void); -#define _Py_INC_REFTOTAL _Py_RefTotal++ -#define _Py_DEC_REFTOTAL _Py_RefTotal-- -#define _Py_REF_DEBUG_COMMA , -#define _Py_CHECK_REFCNT(OP) \ -{ if (((PyObject*)OP)->ob_refcnt < 0) \ - _Py_NegativeRefcount(__FILE__, __LINE__, \ - (PyObject *)(OP)); \ -} -/* Py_REF_DEBUG also controls the display of refcounts and memory block - * allocations at the interactive prompt and at interpreter shutdown - */ -PyAPI_FUNC(void) _PyDebug_PrintTotalRefs(void); -#else -#define _Py_INC_REFTOTAL -#define _Py_DEC_REFTOTAL -#define _Py_REF_DEBUG_COMMA -#define _Py_CHECK_REFCNT(OP) /* a semicolon */; +PyAPI_FUNC(void) _Py_NegativeRefcount(const char *filename, int lineno, + PyObject *op); #endif /* Py_REF_DEBUG */ -#ifdef COUNT_ALLOCS -PyAPI_FUNC(void) inc_count(PyTypeObject *); -PyAPI_FUNC(void) dec_count(PyTypeObject *); -#define _Py_INC_TPALLOCS(OP) inc_count(Py_TYPE(OP)) -#define _Py_INC_TPFREES(OP) dec_count(Py_TYPE(OP)) -#define _Py_DEC_TPFREES(OP) Py_TYPE(OP)->tp_frees-- -#define _Py_COUNT_ALLOCS_COMMA , -#else -#define _Py_INC_TPALLOCS(OP) -#define _Py_INC_TPFREES(OP) -#define _Py_DEC_TPFREES(OP) -#define _Py_COUNT_ALLOCS_COMMA -#endif /* COUNT_ALLOCS */ - -#ifdef Py_TRACE_REFS -/* Py_TRACE_REFS is such major surgery that we call external routines. */ -PyAPI_FUNC(void) _Py_NewReference(PyObject *); -PyAPI_FUNC(void) _Py_ForgetReference(PyObject *); PyAPI_FUNC(void) _Py_Dealloc(PyObject *); -PyAPI_FUNC(void) _Py_PrintReferences(FILE *); -PyAPI_FUNC(void) _Py_PrintReferenceAddresses(FILE *); -PyAPI_FUNC(void) _Py_AddToAllObjects(PyObject *, int force); -#else -/* Without Py_TRACE_REFS, there's little enough to do that we expand code - * inline. - */ -#define _Py_NewReference(op) ( \ - _Py_INC_TPALLOCS(op) _Py_COUNT_ALLOCS_COMMA \ - _Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \ - Py_REFCNT(op) = 1) +/* +These are provided as conveniences to Python runtime embedders, so that +they can have object code that is not dependent on Python compilation flags. +*/ +PyAPI_FUNC(void) Py_IncRef(PyObject *); +PyAPI_FUNC(void) Py_DecRef(PyObject *); -#define _Py_ForgetReference(op) _Py_INC_TPFREES(op) +// Similar to Py_IncRef() and Py_DecRef() but the argument must be non-NULL. +// Private functions used by Py_INCREF() and Py_DECREF(). +PyAPI_FUNC(void) _Py_IncRef(PyObject *); +PyAPI_FUNC(void) _Py_DecRef(PyObject *); -#ifdef Py_LIMITED_API -PyAPI_FUNC(void) _Py_Dealloc(PyObject *); +static inline void _Py_INCREF(PyObject *op) +{ +#if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000 + // Stable ABI for Python 3.10 built in debug mode. + _Py_IncRef(op); #else -#define _Py_Dealloc(op) ( \ - _Py_INC_TPFREES(op) _Py_COUNT_ALLOCS_COMMA \ - (*Py_TYPE(op)->tp_dealloc)((PyObject *)(op))) + // Non-limited C API and limited C API for Python 3.9 and older access + // directly PyObject.ob_refcnt. +#ifdef Py_REF_DEBUG + _Py_RefTotal++; #endif -#endif /* !Py_TRACE_REFS */ - -#define Py_INCREF(op) ( \ - _Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \ - ((PyObject *)(op))->ob_refcnt++) - -#define Py_DECREF(op) \ - do { \ - PyObject *_py_decref_tmp = (PyObject *)(op); \ - if (_Py_DEC_REFTOTAL _Py_REF_DEBUG_COMMA \ - --(_py_decref_tmp)->ob_refcnt != 0) \ - _Py_CHECK_REFCNT(_py_decref_tmp) \ - else \ - _Py_Dealloc(_py_decref_tmp); \ - } while (0) + op->ob_refcnt++; +#endif +} +#define Py_INCREF(op) _Py_INCREF(_PyObject_CAST(op)) + +static inline void _Py_DECREF( +#if defined(Py_REF_DEBUG) && !(defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000) + const char *filename, int lineno, +#endif + PyObject *op) +{ +#if defined(Py_REF_DEBUG) && defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000 + // Stable ABI for Python 3.10 built in debug mode. + _Py_DecRef(op); +#else + // Non-limited C API and limited C API for Python 3.9 and older access + // directly PyObject.ob_refcnt. +#ifdef Py_REF_DEBUG + _Py_RefTotal--; +#endif + if (--op->ob_refcnt != 0) { +#ifdef Py_REF_DEBUG + if (op->ob_refcnt < 0) { + _Py_NegativeRefcount(filename, lineno, op); + } +#endif + } + else { + _Py_Dealloc(op); + } +#endif +} +#if defined(Py_REF_DEBUG) && !(defined(Py_LIMITED_API) && Py_LIMITED_API+0 >= 0x030A0000) +# define Py_DECREF(op) _Py_DECREF(__FILE__, __LINE__, _PyObject_CAST(op)) +#else +# define Py_DECREF(op) _Py_DECREF(_PyObject_CAST(op)) +#endif + /* Safely decref `op` and set `op` to NULL, especially useful in tp_clear * and tp_dealloc implementations. @@ -841,75 +544,57 @@ PyAPI_FUNC(void) _Py_Dealloc(PyObject *); */ #define Py_CLEAR(op) \ do { \ - PyObject *_py_tmp = (PyObject *)(op); \ + PyObject *_py_tmp = _PyObject_CAST(op); \ if (_py_tmp != NULL) { \ (op) = NULL; \ Py_DECREF(_py_tmp); \ } \ } while (0) -/* Macros to use in case the object pointer may be NULL: */ -#define Py_XINCREF(op) \ - do { \ - PyObject *_py_xincref_tmp = (PyObject *)(op); \ - if (_py_xincref_tmp != NULL) \ - Py_INCREF(_py_xincref_tmp); \ - } while (0) +/* Function to use in case the object pointer can be NULL: */ +static inline void _Py_XINCREF(PyObject *op) +{ + if (op != NULL) { + Py_INCREF(op); + } +} -#define Py_XDECREF(op) \ - do { \ - PyObject *_py_xdecref_tmp = (PyObject *)(op); \ - if (_py_xdecref_tmp != NULL) \ - Py_DECREF(_py_xdecref_tmp); \ - } while (0) +#define Py_XINCREF(op) _Py_XINCREF(_PyObject_CAST(op)) -#ifndef Py_LIMITED_API -/* Safely decref `op` and set `op` to `op2`. - * - * As in case of Py_CLEAR "the obvious" code can be deadly: - * - * Py_DECREF(op); - * op = op2; - * - * The safe way is: - * - * Py_SETREF(op, op2); - * - * That arranges to set `op` to `op2` _before_ decref'ing, so that any code - * triggered as a side-effect of `op` getting torn down no longer believes - * `op` points to a valid object. - * - * Py_XSETREF is a variant of Py_SETREF that uses Py_XDECREF instead of - * Py_DECREF. - */ +static inline void _Py_XDECREF(PyObject *op) +{ + if (op != NULL) { + Py_DECREF(op); + } +} -#define Py_SETREF(op, op2) \ - do { \ - PyObject *_py_tmp = (PyObject *)(op); \ - (op) = (op2); \ - Py_DECREF(_py_tmp); \ - } while (0) +#define Py_XDECREF(op) _Py_XDECREF(_PyObject_CAST(op)) -#define Py_XSETREF(op, op2) \ - do { \ - PyObject *_py_tmp = (PyObject *)(op); \ - (op) = (op2); \ - Py_XDECREF(_py_tmp); \ - } while (0) +// Create a new strong reference to an object: +// increment the reference count of the object and return the object. +PyAPI_FUNC(PyObject*) Py_NewRef(PyObject *obj); -#endif /* ifndef Py_LIMITED_API */ +// Similar to Py_NewRef(), but the object can be NULL. +PyAPI_FUNC(PyObject*) Py_XNewRef(PyObject *obj); -/* -These are provided as conveniences to Python runtime embedders, so that -they can have object code that is not dependent on Python compilation flags. -*/ -PyAPI_FUNC(void) Py_IncRef(PyObject *); -PyAPI_FUNC(void) Py_DecRef(PyObject *); +static inline PyObject* _Py_NewRef(PyObject *obj) +{ + Py_INCREF(obj); + return obj; +} + +static inline PyObject* _Py_XNewRef(PyObject *obj) +{ + Py_XINCREF(obj); + return obj; +} + +// Py_NewRef() and Py_XNewRef() are exported as functions for the stable ABI. +// Names overridden with macros by static inline functions for best +// performances. +#define Py_NewRef(obj) _Py_NewRef(_PyObject_CAST(obj)) +#define Py_XNewRef(obj) _Py_XNewRef(_PyObject_CAST(obj)) -#ifndef Py_LIMITED_API -PyAPI_DATA(PyTypeObject) _PyNone_Type; -PyAPI_DATA(PyTypeObject) _PyNotImplemented_Type; -#endif /* !Py_LIMITED_API */ /* _Py_NoneStruct is an object of undefined type which can be used in contexts @@ -920,8 +605,12 @@ Don't forget to apply Py_INCREF() when returning this value!!! PyAPI_DATA(PyObject) _Py_NoneStruct; /* Don't use this directly */ #define Py_None (&_Py_NoneStruct) +// Test if an object is the None singleton, the same as "x is None" in Python. +PyAPI_FUNC(int) Py_IsNone(PyObject *x); +#define Py_IsNone(x) Py_Is((x), Py_None) + /* Macro for returning Py_None from a function */ -#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None +#define Py_RETURN_NONE return Py_NewRef(Py_None) /* Py_NotImplemented is a singleton used to signal that an operation is @@ -931,8 +620,7 @@ PyAPI_DATA(PyObject) _Py_NotImplementedStruct; /* Don't use this directly */ #define Py_NotImplemented (&_Py_NotImplementedStruct) /* Macro for returning Py_NotImplemented from a function */ -#define Py_RETURN_NOTIMPLEMENTED \ - return Py_INCREF(Py_NotImplemented), Py_NotImplemented +#define Py_RETURN_NOTIMPLEMENTED return Py_NewRef(Py_NotImplemented) /* Rich comparison opcodes */ #define Py_LT 0 @@ -942,6 +630,15 @@ PyAPI_DATA(PyObject) _Py_NotImplementedStruct; /* Don't use this directly */ #define Py_GT 4 #define Py_GE 5 +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +/* Result of calling PyIter_Send */ +typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, +} PySendResult; +#endif + /* * Macro for implementing rich comparisons * @@ -961,13 +658,6 @@ PyAPI_DATA(PyObject) _Py_NotImplementedStruct; /* Don't use this directly */ } \ } while (0) -#ifndef Py_LIMITED_API -/* Maps Py_LT to Py_GT, ..., Py_GE to Py_LE. - * Defined in object.c. - */ -PyAPI_DATA(int) _Py_SwappedOp[]; -#endif /* !Py_LIMITED_API */ - /* More conventions @@ -1021,83 +711,37 @@ it carefully, it may save lots of calls to Py_INCREF() and Py_DECREF() at times. */ +#ifndef Py_LIMITED_API +# define Py_CPYTHON_OBJECT_H +# include "cpython/object.h" +# undef Py_CPYTHON_OBJECT_H +#endif -/* Trashcan mechanism, thanks to Christian Tismer. - -When deallocating a container object, it's possible to trigger an unbounded -chain of deallocations, as each Py_DECREF in turn drops the refcount on "the -next" object in the chain to 0. This can easily lead to stack faults, and -especially in threads (which typically have less stack space to work with). - -A container object that participates in cyclic gc can avoid this by -bracketing the body of its tp_dealloc function with a pair of macros: -static void -mytype_dealloc(mytype *p) +static inline int +PyType_HasFeature(PyTypeObject *type, unsigned long feature) { - ... declarations go here ... - - PyObject_GC_UnTrack(p); // must untrack first - Py_TRASHCAN_SAFE_BEGIN(p) - ... The body of the deallocator goes here, including all calls ... - ... to Py_DECREF on contained objects. ... - Py_TRASHCAN_SAFE_END(p) + unsigned long flags; +#ifdef Py_LIMITED_API + // PyTypeObject is opaque in the limited C API + flags = PyType_GetFlags(type); +#else + flags = type->tp_flags; +#endif + return ((flags & feature) != 0); } -CAUTION: Never return from the middle of the body! If the body needs to -"get out early", put a label immediately before the Py_TRASHCAN_SAFE_END -call, and goto it. Else the call-depth counter (see below) will stay -above 0 forever, and the trashcan will never get emptied. - -How it works: The BEGIN macro increments a call-depth counter. So long -as this counter is small, the body of the deallocator is run directly without -further ado. But if the counter gets large, it instead adds p to a list of -objects to be deallocated later, skips the body of the deallocator, and -resumes execution after the END macro. The tp_dealloc routine then returns -without deallocating anything (and so unbounded call-stack depth is avoided). - -When the call stack finishes unwinding again, code generated by the END macro -notices this, and calls another routine to deallocate all the objects that -may have been added to the list of deferred deallocations. In effect, a -chain of N deallocations is broken into (N-1)/(PyTrash_UNWIND_LEVEL-1) pieces, -with the call stack never exceeding a depth of PyTrash_UNWIND_LEVEL. -*/ +#define PyType_FastSubclass(type, flag) PyType_HasFeature(type, flag) -#ifndef Py_LIMITED_API -/* This is the old private API, invoked by the macros before 3.2.4. - Kept for binary compatibility of extensions using the stable ABI. */ -PyAPI_FUNC(void) _PyTrash_deposit_object(PyObject*); -PyAPI_FUNC(void) _PyTrash_destroy_chain(void); -#endif /* !Py_LIMITED_API */ - -/* The new thread-safe private API, invoked by the macros below. */ -PyAPI_FUNC(void) _PyTrash_thread_deposit_object(PyObject*); -PyAPI_FUNC(void) _PyTrash_thread_destroy_chain(void); - -#define PyTrash_UNWIND_LEVEL 50 - -#define Py_TRASHCAN_SAFE_BEGIN(op) \ - do { \ - PyThreadState *_tstate = PyThreadState_GET(); \ - if (_tstate->trash_delete_nesting < PyTrash_UNWIND_LEVEL) { \ - ++_tstate->trash_delete_nesting; - /* The body of the deallocator is here. */ -#define Py_TRASHCAN_SAFE_END(op) \ - --_tstate->trash_delete_nesting; \ - if (_tstate->trash_delete_later && _tstate->trash_delete_nesting <= 0) \ - _PyTrash_thread_destroy_chain(); \ - } \ - else \ - _PyTrash_thread_deposit_object((PyObject*)op); \ - } while (0); +static inline int _PyType_Check(PyObject *op) { + return PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TYPE_SUBCLASS); +} +#define PyType_Check(op) _PyType_Check(_PyObject_CAST(op)) -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) -_PyDebugAllocatorStats(FILE *out, const char *block_name, int num_blocks, - size_t sizeof_block); -PyAPI_FUNC(void) -_PyObject_DebugTypeStats(FILE *out); -#endif /* ifndef Py_LIMITED_API */ +static inline int _PyType_CheckExact(PyObject *op) { + return Py_IS_TYPE(op, &PyType_Type); +} +#define PyType_CheckExact(op) _PyType_CheckExact(_PyObject_CAST(op)) #ifdef __cplusplus } diff --git a/include/objimpl.h b/include/objimpl.h index 0436ba78..450befad 100644 --- a/include/objimpl.h +++ b/include/objimpl.h @@ -38,7 +38,7 @@ Functions and macros for modules that implement new object types. object with room for n items. In addition to the refcount and type pointer fields, this also fills in the ob_size field. - - PyObject_Del(op) releases the memory allocated for an object. It does not + - PyObject_Free(op) releases the memory allocated for an object. It does not run a destructor -- it only frees the memory. PyObject_Free is identical. - PyObject_Init(op, typeobj) and PyObject_InitVar(op, typeobj, n) don't @@ -48,8 +48,8 @@ Functions and macros for modules that implement new object types. Note that objects created with PyObject_{New, NewVar} are allocated using the specialized Python allocator (implemented in obmalloc.c), if WITH_PYMALLOC is -enabled. In addition, a special debugging allocator is used if PYMALLOC_DEBUG -is also #defined. +enabled. In addition, a special debugging allocator is used if Py_DEBUG +macro is also defined. In case a specific form of memory management is needed (for example, if you must use the platform malloc heap(s), or shared memory, or C++ local storage or @@ -101,19 +101,10 @@ PyAPI_FUNC(void *) PyObject_Calloc(size_t nelem, size_t elsize); PyAPI_FUNC(void *) PyObject_Realloc(void *ptr, size_t new_size); PyAPI_FUNC(void) PyObject_Free(void *ptr); -#ifndef Py_LIMITED_API -/* This function returns the number of allocated memory blocks, regardless of size */ -PyAPI_FUNC(Py_ssize_t) _Py_GetAllocatedBlocks(void); -#endif /* !Py_LIMITED_API */ - -/* Macros */ -#ifdef WITH_PYMALLOC -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyObject_DebugMallocStats(FILE *out); -#endif /* #ifndef Py_LIMITED_API */ -#endif -/* Macros */ +// Deprecated aliases only kept for backward compatibility. +// PyObject_Del and PyObject_DEL are defined with no parameter to be able to +// use them as function pointers (ex: tp_free = PyObject_Del). #define PyObject_MALLOC PyObject_Malloc #define PyObject_REALLOC PyObject_Realloc #define PyObject_FREE PyObject_Free @@ -129,98 +120,29 @@ PyAPI_FUNC(int) _PyObject_DebugMallocStats(FILE *out); /* Functions */ PyAPI_FUNC(PyObject *) PyObject_Init(PyObject *, PyTypeObject *); PyAPI_FUNC(PyVarObject *) PyObject_InitVar(PyVarObject *, - PyTypeObject *, Py_ssize_t); -PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *); -PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t); + PyTypeObject *, Py_ssize_t); -#define PyObject_New(type, typeobj) \ - ( (type *) _PyObject_New(typeobj) ) -#define PyObject_NewVar(type, typeobj, n) \ - ( (type *) _PyObject_NewVar((typeobj), (n)) ) - -/* Macros trading binary compatibility for speed. See also pymem.h. - Note that these macros expect non-NULL object pointers.*/ #define PyObject_INIT(op, typeobj) \ - ( Py_TYPE(op) = (typeobj), _Py_NewReference((PyObject *)(op)), (op) ) + PyObject_Init(_PyObject_CAST(op), (typeobj)) #define PyObject_INIT_VAR(op, typeobj, size) \ - ( Py_SIZE(op) = (size), PyObject_INIT((op), (typeobj)) ) - -#define _PyObject_SIZE(typeobj) ( (typeobj)->tp_basicsize ) - -/* _PyObject_VAR_SIZE returns the number of bytes (as size_t) allocated for a - vrbl-size object with nitems items, exclusive of gc overhead (if any). The - value is rounded up to the closest multiple of sizeof(void *), in order to - ensure that pointer fields at the end of the object are correctly aligned - for the platform (this is of special importance for subclasses of, e.g., - str or int, so that pointers can be stored after the embedded data). + PyObject_InitVar(_PyVarObject_CAST(op), (typeobj), (size)) - Note that there's no memory wastage in doing this, as malloc has to - return (at worst) pointer-aligned memory anyway. -*/ -#if ((SIZEOF_VOID_P - 1) & SIZEOF_VOID_P) != 0 -# error "_PyObject_VAR_SIZE requires SIZEOF_VOID_P be a power of 2" -#endif - -#define _PyObject_VAR_SIZE(typeobj, nitems) \ - _Py_SIZE_ROUND_UP((typeobj)->tp_basicsize + \ - (nitems)*(typeobj)->tp_itemsize, \ - SIZEOF_VOID_P) - -#define PyObject_NEW(type, typeobj) \ -( (type *) PyObject_Init( \ - (PyObject *) PyObject_MALLOC( _PyObject_SIZE(typeobj) ), (typeobj)) ) - -#define PyObject_NEW_VAR(type, typeobj, n) \ -( (type *) PyObject_InitVar( \ - (PyVarObject *) PyObject_MALLOC(_PyObject_VAR_SIZE((typeobj),(n)) ),\ - (typeobj), (n)) ) - -/* This example code implements an object constructor with a custom - allocator, where PyObject_New is inlined, and shows the important - distinction between two steps (at least): - 1) the actual allocation of the object storage; - 2) the initialization of the Python specific fields - in this storage with PyObject_{Init, InitVar}. - - PyObject * - YourObject_New(...) - { - PyObject *op; - - op = (PyObject *) Your_Allocator(_PyObject_SIZE(YourTypeStruct)); - if (op == NULL) - return PyErr_NoMemory(); - - PyObject_Init(op, &YourTypeStruct); - - op->ob_field = value; - ... - return op; - } - - Note that in C++, the use of the new operator usually implies that - the 1st step is performed automatically for you, so in a C++ class - constructor you would start directly with PyObject_Init/InitVar -*/ -#ifndef Py_LIMITED_API -typedef struct { - /* user context passed as the first argument to the 2 functions */ - void *ctx; +PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *); +PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t); - /* allocate an arena of size bytes */ - void* (*alloc) (void *ctx, size_t size); +#define PyObject_New(type, typeobj) ((type *)_PyObject_New(typeobj)) - /* free an arena */ - void (*free) (void *ctx, void *ptr, size_t size); -} PyObjectArenaAllocator; +// Alias to PyObject_New(). In Python 3.8, PyObject_NEW() called directly +// PyObject_MALLOC() with _PyObject_SIZE(). +#define PyObject_NEW(type, typeobj) PyObject_New(type, typeobj) -/* Get the arena allocator. */ -PyAPI_FUNC(void) PyObject_GetArenaAllocator(PyObjectArenaAllocator *allocator); +#define PyObject_NewVar(type, typeobj, n) \ + ( (type *) _PyObject_NewVar((typeobj), (n)) ) -/* Set the arena allocator. */ -PyAPI_FUNC(void) PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator); -#endif +// Alias to PyObject_NewVar(). In Python 3.8, PyObject_NEW_VAR() called +// directly PyObject_MALLOC() with _PyObject_VAR_SIZE(). +#define PyObject_NEW_VAR(type, typeobj, n) PyObject_NewVar(type, typeobj, n) /* @@ -228,117 +150,35 @@ PyAPI_FUNC(void) PyObject_SetArenaAllocator(PyObjectArenaAllocator *allocator); * ========================== */ -/* C equivalent of gc.collect() which ignores the state of gc.enabled. */ +/* C equivalent of gc.collect(). */ PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void); - -#ifndef Py_LIMITED_API -PyAPI_FUNC(Py_ssize_t) _PyGC_CollectNoFail(void); -PyAPI_FUNC(Py_ssize_t) _PyGC_CollectIfEnabled(void); -#endif +/* C API for controlling the state of the garbage collector */ +PyAPI_FUNC(int) PyGC_Enable(void); +PyAPI_FUNC(int) PyGC_Disable(void); +PyAPI_FUNC(int) PyGC_IsEnabled(void); /* Test if a type has a GC head */ #define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC) -/* Test if an object has a GC head */ -#define PyObject_IS_GC(o) (PyType_IS_GC(Py_TYPE(o)) && \ - (Py_TYPE(o)->tp_is_gc == NULL || Py_TYPE(o)->tp_is_gc(o))) - PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t); #define PyObject_GC_Resize(type, op, n) \ - ( (type *) _PyObject_GC_Resize((PyVarObject *)(op), (n)) ) - -/* GC information is stored BEFORE the object structure. */ -#ifndef Py_LIMITED_API -typedef union _gc_head { - struct { - union _gc_head *gc_next; - union _gc_head *gc_prev; - Py_ssize_t gc_refs; - } gc; - long double dummy; /* force worst-case alignment */ - // malloc returns memory block aligned for any built-in types and - // long double is the largest standard C type. - // On amd64 linux, long double requires 16 byte alignment. - // See bpo-27987 for more discussion. -} PyGC_Head; - -extern PyGC_Head *_PyGC_generation0; - -#define _Py_AS_GC(o) ((PyGC_Head *)(o)-1) - -/* Bit 0 is set when tp_finalize is called */ -#define _PyGC_REFS_MASK_FINALIZED (1 << 0) -/* The (N-1) most significant bits contain the gc state / refcount */ -#define _PyGC_REFS_SHIFT (1) -#define _PyGC_REFS_MASK (((size_t) -1) << _PyGC_REFS_SHIFT) - -#define _PyGCHead_REFS(g) ((g)->gc.gc_refs >> _PyGC_REFS_SHIFT) -#define _PyGCHead_SET_REFS(g, v) do { \ - (g)->gc.gc_refs = ((g)->gc.gc_refs & ~_PyGC_REFS_MASK) \ - | (((size_t)(v)) << _PyGC_REFS_SHIFT); \ - } while (0) -#define _PyGCHead_DECREF(g) ((g)->gc.gc_refs -= 1 << _PyGC_REFS_SHIFT) - -#define _PyGCHead_FINALIZED(g) (((g)->gc.gc_refs & _PyGC_REFS_MASK_FINALIZED) != 0) -#define _PyGCHead_SET_FINALIZED(g, v) do { \ - (g)->gc.gc_refs = ((g)->gc.gc_refs & ~_PyGC_REFS_MASK_FINALIZED) \ - | (v != 0); \ - } while (0) - -#define _PyGC_FINALIZED(o) _PyGCHead_FINALIZED(_Py_AS_GC(o)) -#define _PyGC_SET_FINALIZED(o, v) _PyGCHead_SET_FINALIZED(_Py_AS_GC(o), v) - -#define _PyGC_REFS(o) _PyGCHead_REFS(_Py_AS_GC(o)) - -#define _PyGC_REFS_UNTRACKED (-2) -#define _PyGC_REFS_REACHABLE (-3) -#define _PyGC_REFS_TENTATIVELY_UNREACHABLE (-4) + ( (type *) _PyObject_GC_Resize(_PyVarObject_CAST(op), (n)) ) -/* Tell the GC to track this object. NB: While the object is tracked the - * collector it must be safe to call the ob_traverse method. */ -#define _PyObject_GC_TRACK(o) do { \ - PyGC_Head *g = _Py_AS_GC(o); \ - if (_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED) \ - Py_FatalError("GC object already tracked"); \ - _PyGCHead_SET_REFS(g, _PyGC_REFS_REACHABLE); \ - g->gc.gc_next = _PyGC_generation0; \ - g->gc.gc_prev = _PyGC_generation0->gc.gc_prev; \ - g->gc.gc_prev->gc.gc_next = g; \ - _PyGC_generation0->gc.gc_prev = g; \ - } while (0); -/* Tell the GC to stop tracking this object. - * gc_next doesn't need to be set to NULL, but doing so is a good - * way to provoke memory errors if calling code is confused. - */ -#define _PyObject_GC_UNTRACK(o) do { \ - PyGC_Head *g = _Py_AS_GC(o); \ - assert(_PyGCHead_REFS(g) != _PyGC_REFS_UNTRACKED); \ - _PyGCHead_SET_REFS(g, _PyGC_REFS_UNTRACKED); \ - g->gc.gc_prev->gc.gc_next = g->gc.gc_next; \ - g->gc.gc_next->gc.gc_prev = g->gc.gc_prev; \ - g->gc.gc_next = NULL; \ - } while (0); - -/* True if the object is currently tracked by the GC. */ -#define _PyObject_GC_IS_TRACKED(o) \ - (_PyGC_REFS(o) != _PyGC_REFS_UNTRACKED) - -/* True if the object may be tracked by the GC in the future, or already is. - This can be useful to implement some optimizations. */ -#define _PyObject_GC_MAY_BE_TRACKED(obj) \ - (PyObject_IS_GC(obj) && \ - (!PyTuple_CheckExact(obj) || _PyObject_GC_IS_TRACKED(obj))) -#endif /* Py_LIMITED_API */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyObject_GC_Malloc(size_t size); -PyAPI_FUNC(PyObject *) _PyObject_GC_Calloc(size_t size); -#endif /* !Py_LIMITED_API */ PyAPI_FUNC(PyObject *) _PyObject_GC_New(PyTypeObject *); PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t); + +/* Tell the GC to track this object. + * + * See also private _PyObject_GC_TRACK() macro. */ PyAPI_FUNC(void) PyObject_GC_Track(void *); + +/* Tell the GC to stop tracking this object. + * + * See also private _PyObject_GC_UNTRACK() macro. */ PyAPI_FUNC(void) PyObject_GC_UnTrack(void *); + PyAPI_FUNC(void) PyObject_GC_Del(void *); #define PyObject_GC_New(type, typeobj) \ @@ -346,6 +186,8 @@ PyAPI_FUNC(void) PyObject_GC_Del(void *); #define PyObject_GC_NewVar(type, typeobj, n) \ ( (type *) _PyObject_GC_NewVar((typeobj), (n)) ) +PyAPI_FUNC(int) PyObject_GC_IsTracked(PyObject *); +PyAPI_FUNC(int) PyObject_GC_IsFinalized(PyObject *); /* Utility macro to help write tp_traverse functions. * To use this macro, the tp_traverse function must name its arguments @@ -355,18 +197,17 @@ PyAPI_FUNC(void) PyObject_GC_Del(void *); #define Py_VISIT(op) \ do { \ if (op) { \ - int vret = visit((PyObject *)(op), arg); \ + int vret = visit(_PyObject_CAST(op), arg); \ if (vret) \ return vret; \ } \ } while (0) - -/* Test if a type supports weak references */ -#define PyType_SUPPORTS_WEAKREFS(t) ((t)->tp_weaklistoffset > 0) - -#define PyObject_GET_WEAKREFS_LISTPTR(o) \ - ((PyObject **) (((char *) (o)) + Py_TYPE(o)->tp_weaklistoffset)) +#ifndef Py_LIMITED_API +# define Py_CPYTHON_OBJIMPL_H +# include "cpython/objimpl.h" +# undef Py_CPYTHON_OBJIMPL_H +#endif #ifdef __cplusplus } diff --git a/include/opcode.h b/include/opcode.h index fc6cbf3a..52039754 100644 --- a/include/opcode.h +++ b/include/opcode.h @@ -1,4 +1,4 @@ -/* Auto-generated by Tools/scripts/generate_opcode_h.py */ +/* Auto-generated by Tools/scripts/generate_opcode_h.py from Lib/opcode.py */ #ifndef Py_OPCODE_H #define Py_OPCODE_H #ifdef __cplusplus @@ -12,6 +12,7 @@ extern "C" { #define ROT_THREE 3 #define DUP_TOP 4 #define DUP_TOP_TWO 5 +#define ROT_FOUR 6 #define NOP 9 #define UNARY_POSITIVE 10 #define UNARY_NEGATIVE 11 @@ -29,9 +30,16 @@ extern "C" { #define BINARY_TRUE_DIVIDE 27 #define INPLACE_FLOOR_DIVIDE 28 #define INPLACE_TRUE_DIVIDE 29 +#define GET_LEN 30 +#define MATCH_MAPPING 31 +#define MATCH_SEQUENCE 32 +#define MATCH_KEYS 33 +#define COPY_DICT_WITHOUT_KEYS 34 +#define WITH_EXCEPT_START 49 #define GET_AITER 50 #define GET_ANEXT 51 #define BEFORE_ASYNC_WITH 52 +#define END_ASYNC_FOR 54 #define INPLACE_ADD 55 #define INPLACE_SUBTRACT 56 #define INPLACE_MULTIPLY 57 @@ -50,20 +58,18 @@ extern "C" { #define LOAD_BUILD_CLASS 71 #define YIELD_FROM 72 #define GET_AWAITABLE 73 +#define LOAD_ASSERTION_ERROR 74 #define INPLACE_LSHIFT 75 #define INPLACE_RSHIFT 76 #define INPLACE_AND 77 #define INPLACE_XOR 78 #define INPLACE_OR 79 -#define BREAK_LOOP 80 -#define WITH_CLEANUP_START 81 -#define WITH_CLEANUP_FINISH 82 +#define LIST_TO_TUPLE 82 #define RETURN_VALUE 83 #define IMPORT_STAR 84 #define SETUP_ANNOTATIONS 85 #define YIELD_VALUE 86 #define POP_BLOCK 87 -#define END_FINALLY 88 #define POP_EXCEPT 89 #define HAVE_ARGUMENT 90 #define STORE_NAME 90 @@ -75,6 +81,7 @@ extern "C" { #define DELETE_ATTR 96 #define STORE_GLOBAL 97 #define DELETE_GLOBAL 98 +#define ROT_N 99 #define LOAD_CONST 100 #define LOAD_NAME 101 #define BUILD_TUPLE 102 @@ -92,13 +99,15 @@ extern "C" { #define POP_JUMP_IF_FALSE 114 #define POP_JUMP_IF_TRUE 115 #define LOAD_GLOBAL 116 -#define CONTINUE_LOOP 119 -#define SETUP_LOOP 120 -#define SETUP_EXCEPT 121 +#define IS_OP 117 +#define CONTAINS_OP 118 +#define RERAISE 119 +#define JUMP_IF_NOT_EXC_MATCH 121 #define SETUP_FINALLY 122 #define LOAD_FAST 124 #define STORE_FAST 125 #define DELETE_FAST 126 +#define GEN_START 129 #define RAISE_VARARGS 130 #define CALL_FUNCTION 131 #define MAKE_FUNCTION 132 @@ -115,18 +124,39 @@ extern "C" { #define SET_ADD 146 #define MAP_ADD 147 #define LOAD_CLASSDEREF 148 -#define BUILD_LIST_UNPACK 149 -#define BUILD_MAP_UNPACK 150 -#define BUILD_MAP_UNPACK_WITH_CALL 151 -#define BUILD_TUPLE_UNPACK 152 -#define BUILD_SET_UNPACK 153 +#define MATCH_CLASS 152 #define SETUP_ASYNC_WITH 154 #define FORMAT_VALUE 155 #define BUILD_CONST_KEY_MAP 156 #define BUILD_STRING 157 -#define BUILD_TUPLE_UNPACK_WITH_CALL 158 #define LOAD_METHOD 160 #define CALL_METHOD 161 +#define LIST_EXTEND 162 +#define SET_UPDATE 163 +#define DICT_MERGE 164 +#define DICT_UPDATE 165 +#ifdef NEED_OPCODE_JUMP_TABLES +static uint32_t _PyOpcode_RelativeJump[8] = { + 0U, + 0U, + 536870912U, + 67125248U, + 67141632U, + 0U, + 0U, + 0U, +}; +static uint32_t _PyOpcode_Jump[8] = { + 0U, + 0U, + 536870912U, + 101695488U, + 67141632U, + 0U, + 0U, + 0U, +}; +#endif /* OPCODE_TABLES */ /* EXCEPT_HANDLER is a special, implicit block type which is created when entering an except handler. It is not an opcode but we define it here @@ -134,11 +164,6 @@ extern "C" { remaining private.*/ #define EXCEPT_HANDLER 257 - -enum cmp_op {PyCmp_LT=Py_LT, PyCmp_LE=Py_LE, PyCmp_EQ=Py_EQ, PyCmp_NE=Py_NE, - PyCmp_GT=Py_GT, PyCmp_GE=Py_GE, PyCmp_IN, PyCmp_NOT_IN, - PyCmp_IS, PyCmp_IS_NOT, PyCmp_EXC_MATCH, PyCmp_BAD}; - #define HAS_ARG(op) ((op) >= HAVE_ARGUMENT) #ifdef __cplusplus diff --git a/include/osdefs.h b/include/osdefs.h index bd84c1c1..3243944a 100644 --- a/include/osdefs.h +++ b/include/osdefs.h @@ -14,6 +14,10 @@ extern "C" { #define DELIM L';' #endif +#ifdef __VXWORKS__ +#define DELIM L';' +#endif + /* Filename separator */ #ifndef SEP #define SEP L'/' diff --git a/include/parsetok.h b/include/parsetok.h deleted file mode 100644 index c9407a3f..00000000 --- a/include/parsetok.h +++ /dev/null @@ -1,108 +0,0 @@ - -/* Parser-tokenizer link interface */ -#ifndef Py_LIMITED_API -#ifndef Py_PARSETOK_H -#define Py_PARSETOK_H -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct { - int error; -#ifndef PGEN - /* The filename is useless for pgen, see comment in tok_state structure */ - PyObject *filename; -#endif - int lineno; - int offset; - char *text; /* UTF-8-encoded string */ - int token; - int expected; -} perrdetail; - -#if 0 -#define PyPARSE_YIELD_IS_KEYWORD 0x0001 -#endif - -#define PyPARSE_DONT_IMPLY_DEDENT 0x0002 - -#if 0 -#define PyPARSE_WITH_IS_KEYWORD 0x0003 -#define PyPARSE_PRINT_IS_FUNCTION 0x0004 -#define PyPARSE_UNICODE_LITERALS 0x0008 -#endif - -#define PyPARSE_IGNORE_COOKIE 0x0010 -#define PyPARSE_BARRY_AS_BDFL 0x0020 - -PyAPI_FUNC(node *) PyParser_ParseString(const char *, grammar *, int, - perrdetail *); -PyAPI_FUNC(node *) PyParser_ParseFile (FILE *, const char *, grammar *, int, - const char *, const char *, - perrdetail *); - -PyAPI_FUNC(node *) PyParser_ParseStringFlags(const char *, grammar *, int, - perrdetail *, int); -PyAPI_FUNC(node *) PyParser_ParseFileFlags( - FILE *fp, - const char *filename, /* decoded from the filesystem encoding */ - const char *enc, - grammar *g, - int start, - const char *ps1, - const char *ps2, - perrdetail *err_ret, - int flags); -PyAPI_FUNC(node *) PyParser_ParseFileFlagsEx( - FILE *fp, - const char *filename, /* decoded from the filesystem encoding */ - const char *enc, - grammar *g, - int start, - const char *ps1, - const char *ps2, - perrdetail *err_ret, - int *flags); -PyAPI_FUNC(node *) PyParser_ParseFileObject( - FILE *fp, - PyObject *filename, - const char *enc, - grammar *g, - int start, - const char *ps1, - const char *ps2, - perrdetail *err_ret, - int *flags); - -PyAPI_FUNC(node *) PyParser_ParseStringFlagsFilename( - const char *s, - const char *filename, /* decoded from the filesystem encoding */ - grammar *g, - int start, - perrdetail *err_ret, - int flags); -PyAPI_FUNC(node *) PyParser_ParseStringFlagsFilenameEx( - const char *s, - const char *filename, /* decoded from the filesystem encoding */ - grammar *g, - int start, - perrdetail *err_ret, - int *flags); -PyAPI_FUNC(node *) PyParser_ParseStringObject( - const char *s, - PyObject *filename, - grammar *g, - int start, - perrdetail *err_ret, - int *flags); - -/* Note that the following functions are defined in pythonrun.c, - not in parsetok.c */ -PyAPI_FUNC(void) PyParser_SetError(perrdetail *); -PyAPI_FUNC(void) PyParser_ClearError(perrdetail *); - -#ifdef __cplusplus -} -#endif -#endif /* !Py_PARSETOK_H */ -#endif /* !Py_LIMITED_API */ diff --git a/include/patchlevel.h b/include/patchlevel.h index d823319e..cef4374c 100644 --- a/include/patchlevel.h +++ b/include/patchlevel.h @@ -17,13 +17,13 @@ /* Version parsed out into numeric values */ /*--start constants--*/ #define PY_MAJOR_VERSION 3 -#define PY_MINOR_VERSION 7 -#define PY_MICRO_VERSION 9 +#define PY_MINOR_VERSION 10 +#define PY_MICRO_VERSION 6 #define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_FINAL #define PY_RELEASE_SERIAL 0 /* Version as a string */ -#define PY_VERSION "3.7.9" +#define PY_VERSION "3.10.6" /*--end constants--*/ /* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2. diff --git a/include/pgen.h b/include/pgen.h deleted file mode 100644 index 8a325ed0..00000000 --- a/include/pgen.h +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef Py_PGEN_H -#define Py_PGEN_H -#ifdef __cplusplus -extern "C" { -#endif - - -/* Parser generator interface */ - -extern grammar *meta_grammar(void); - -struct _node; -extern grammar *pgen(struct _node *); - -#ifdef __cplusplus -} -#endif -#endif /* !Py_PGEN_H */ diff --git a/include/pgenheaders.h b/include/pgenheaders.h deleted file mode 100644 index dbc5e0a5..00000000 --- a/include/pgenheaders.h +++ /dev/null @@ -1,43 +0,0 @@ -#ifndef Py_PGENHEADERS_H -#define Py_PGENHEADERS_H -#ifdef __cplusplus -extern "C" { -#endif - - -/* Include files and extern declarations used by most of the parser. */ - -#include "Python.h" - -PyAPI_FUNC(void) PySys_WriteStdout(const char *format, ...) - Py_GCC_ATTRIBUTE((format(printf, 1, 2))); -PyAPI_FUNC(void) PySys_WriteStderr(const char *format, ...) - Py_GCC_ATTRIBUTE((format(printf, 1, 2))); - -#define addarc _Py_addarc -#define addbit _Py_addbit -#define adddfa _Py_adddfa -#define addfirstsets _Py_addfirstsets -#define addlabel _Py_addlabel -#define addstate _Py_addstate -#define delbitset _Py_delbitset -#define dumptree _Py_dumptree -#define findlabel _Py_findlabel -#define freegrammar _Py_freegrammar -#define mergebitset _Py_mergebitset -#define meta_grammar _Py_meta_grammar -#define newbitset _Py_newbitset -#define newgrammar _Py_newgrammar -#define pgen _Py_pgen -#define printgrammar _Py_printgrammar -#define printnonterminals _Py_printnonterminals -#define printtree _Py_printtree -#define samebitset _Py_samebitset -#define showtree _Py_showtree -#define tok_dump _Py_tok_dump -#define translatelabels _Py_translatelabels - -#ifdef __cplusplus -} -#endif -#endif /* !Py_PGENHEADERS_H */ diff --git a/include/py_curses.h b/include/py_curses.h index 0eebc362..b70252d9 100644 --- a/include/py_curses.h +++ b/include/py_curses.h @@ -64,7 +64,7 @@ typedef struct { char *encoding; } PyCursesWindowObject; -#define PyCursesWindow_Check(v) (Py_TYPE(v) == &PyCursesWindow_Type) +#define PyCursesWindow_Check(v) Py_IS_TYPE(v, &PyCursesWindow_Type) #define PyCurses_CAPSULE_NAME "_curses._C_API" @@ -91,69 +91,9 @@ static void **PyCurses_API; static const char catchall_ERR[] = "curses function returned ERR"; static const char catchall_NULL[] = "curses function returned NULL"; -/* Function Prototype Macros - They are ugly but very, very useful. ;-) - - X - function name - TYPE - parameter Type - ERGSTR - format string for construction of the return value - PARSESTR - format string for argument parsing - */ - -#define NoArgNoReturnFunction(X) \ -static PyObject *PyCurses_ ## X (PyObject *self) \ -{ \ - PyCursesInitialised \ - return PyCursesCheckERR(X(), # X); } - -#define NoArgOrFlagNoReturnFunction(X) \ -static PyObject *PyCurses_ ## X (PyObject *self, PyObject *args) \ -{ \ - int flag = 0; \ - PyCursesInitialised \ - switch(PyTuple_Size(args)) { \ - case 0: \ - return PyCursesCheckERR(X(), # X); \ - case 1: \ - if (!PyArg_ParseTuple(args, "i;True(1) or False(0)", &flag)) return NULL; \ - if (flag) return PyCursesCheckERR(X(), # X); \ - else return PyCursesCheckERR(no ## X (), # X); \ - default: \ - PyErr_SetString(PyExc_TypeError, # X " requires 0 or 1 arguments"); \ - return NULL; } } - -#define NoArgReturnIntFunction(X) \ -static PyObject *PyCurses_ ## X (PyObject *self) \ -{ \ - PyCursesInitialised \ - return PyLong_FromLong((long) X()); } - - -#define NoArgReturnStringFunction(X) \ -static PyObject *PyCurses_ ## X (PyObject *self) \ -{ \ - PyCursesInitialised \ - return PyBytes_FromString(X()); } - -#define NoArgTrueFalseFunction(X) \ -static PyObject *PyCurses_ ## X (PyObject *self) \ -{ \ - PyCursesInitialised \ - if (X () == FALSE) { \ - Py_RETURN_FALSE; \ - } \ - Py_RETURN_TRUE; } - -#define NoArgNoReturnVoidFunction(X) \ -static PyObject *PyCurses_ ## X (PyObject *self) \ -{ \ - PyCursesInitialised \ - X(); \ - Py_RETURN_NONE; } - #ifdef __cplusplus } #endif #endif /* !defined(Py_CURSES_H) */ - diff --git a/include/pyarena.h b/include/pyarena.h deleted file mode 100644 index db3ad018..00000000 --- a/include/pyarena.h +++ /dev/null @@ -1,64 +0,0 @@ -/* An arena-like memory interface for the compiler. - */ - -#ifndef Py_LIMITED_API -#ifndef Py_PYARENA_H -#define Py_PYARENA_H - -#ifdef __cplusplus -extern "C" { -#endif - - typedef struct _arena PyArena; - - /* PyArena_New() and PyArena_Free() create a new arena and free it, - respectively. Once an arena has been created, it can be used - to allocate memory via PyArena_Malloc(). Pointers to PyObject can - also be registered with the arena via PyArena_AddPyObject(), and the - arena will ensure that the PyObjects stay alive at least until - PyArena_Free() is called. When an arena is freed, all the memory it - allocated is freed, the arena releases internal references to registered - PyObject*, and none of its pointers are valid. - XXX (tim) What does "none of its pointers are valid" mean? Does it - XXX mean that pointers previously obtained via PyArena_Malloc() are - XXX no longer valid? (That's clearly true, but not sure that's what - XXX the text is trying to say.) - - PyArena_New() returns an arena pointer. On error, it - returns a negative number and sets an exception. - XXX (tim): Not true. On error, PyArena_New() actually returns NULL, - XXX and looks like it may or may not set an exception (e.g., if the - XXX internal PyList_New(0) returns NULL, PyArena_New() passes that on - XXX and an exception is set; OTOH, if the internal - XXX block_new(DEFAULT_BLOCK_SIZE) returns NULL, that's passed on but - XXX an exception is not set in that case). - */ - PyAPI_FUNC(PyArena *) PyArena_New(void); - PyAPI_FUNC(void) PyArena_Free(PyArena *); - - /* Mostly like malloc(), return the address of a block of memory spanning - * `size` bytes, or return NULL (without setting an exception) if enough - * new memory can't be obtained. Unlike malloc(0), PyArena_Malloc() with - * size=0 does not guarantee to return a unique pointer (the pointer - * returned may equal one or more other pointers obtained from - * PyArena_Malloc()). - * Note that pointers obtained via PyArena_Malloc() must never be passed to - * the system free() or realloc(), or to any of Python's similar memory- - * management functions. PyArena_Malloc()-obtained pointers remain valid - * until PyArena_Free(ar) is called, at which point all pointers obtained - * from the arena `ar` become invalid simultaneously. - */ - PyAPI_FUNC(void *) PyArena_Malloc(PyArena *, size_t size); - - /* This routine isn't a proper arena allocation routine. It takes - * a PyObject* and records it so that it can be DECREFed when the - * arena is freed. - */ - PyAPI_FUNC(int) PyArena_AddPyObject(PyArena *, PyObject *); - -#ifdef __cplusplus -} -#endif - -#endif /* !Py_PYARENA_H */ -#endif /* Py_LIMITED_API */ diff --git a/include/pycapsule.h b/include/pycapsule.h index d9ecda7a..fb5d503f 100644 --- a/include/pycapsule.h +++ b/include/pycapsule.h @@ -22,7 +22,7 @@ PyAPI_DATA(PyTypeObject) PyCapsule_Type; typedef void (*PyCapsule_Destructor)(PyObject *); -#define PyCapsule_CheckExact(op) (Py_TYPE(op) == &PyCapsule_Type) +#define PyCapsule_CheckExact(op) Py_IS_TYPE(op, &PyCapsule_Type) PyAPI_FUNC(PyObject *) PyCapsule_New( diff --git a/include/pyconfig.h b/include/pyconfig.h index 81e76562..103e647a 100644 --- a/include/pyconfig.h +++ b/include/pyconfig.h @@ -126,15 +126,18 @@ WIN32 is still required for the locale module. #define COMPILER _Py_PASTE_VERSION("64 bit (AMD64)") #endif /* __INTEL_COMPILER */ #define PYD_PLATFORM_TAG "win_amd64" +#elif defined(_M_ARM64) +#define COMPILER _Py_PASTE_VERSION("64 bit (ARM64)") +#define PYD_PLATFORM_TAG "win_arm64" #else #define COMPILER _Py_PASTE_VERSION("64 bit (Unknown)") #endif #endif /* MS_WIN64 */ /* set the version macros for the windows headers */ -/* Python 3.5+ requires Windows Vista or greater */ -#define Py_WINVER 0x0600 /* _WIN32_WINNT_VISTA */ -#define Py_NTDDI NTDDI_VISTA +/* Python 3.9+ requires Windows 8 or greater */ +#define Py_WINVER 0x0602 /* _WIN32_WINNT_WIN8 */ +#define Py_NTDDI NTDDI_WIN8 /* We only set these values when building Python - we don't want to force these values on extensions, as that will affect the prototypes and @@ -162,11 +165,11 @@ WIN32 is still required for the locale module. /* Define like size_t, omitting the "unsigned" */ #ifdef MS_WIN64 -typedef __int64 ssize_t; +typedef __int64 Py_ssize_t; #else -typedef _W64 int ssize_t; +typedef _W64 int Py_ssize_t; #endif -#define HAVE_SSIZE_T 1 +#define HAVE_PY_SSIZE_T 1 #if defined(MS_WIN32) && !defined(MS_WIN64) #if defined(_M_IX86) @@ -178,7 +181,7 @@ typedef _W64 int ssize_t; #define PYD_PLATFORM_TAG "win32" #elif defined(_M_ARM) #define COMPILER _Py_PASTE_VERSION("32 bit (ARM)") -#define PYD_PLATFORM_TAG "win_arm" +#define PYD_PLATFORM_TAG "win_arm32" #else #define COMPILER _Py_PASTE_VERSION("32 bit (Unknown)") #endif @@ -190,12 +193,6 @@ typedef int pid_t; #define Py_IS_NAN _isnan #define Py_IS_INFINITY(X) (!_finite(X) && !_isnan(X)) #define Py_IS_FINITE(X) _finite(X) -#define copysign _copysign - -/* Side by Side assemblies supported in VS 2005 and VS 2008 but not 2010*/ -#if _MSC_VER >= 1400 && _MSC_VER < 1600 -#define HAVE_SXS 1 -#endif /* define some ANSI types that are not defined in earlier Win headers */ #if _MSC_VER >= 1200 @@ -271,11 +268,11 @@ Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ file in their Makefile (other compilers are generally taken care of by distutils.) */ # if defined(_DEBUG) -# pragma comment(lib,"python37_d.lib") +# pragma comment(lib,"python310_d.lib") # elif defined(Py_LIMITED_API) # pragma comment(lib,"python3.lib") # else -# pragma comment(lib,"python37.lib") +# pragma comment(lib,"python310.lib") # endif /* _DEBUG */ # endif /* _MSC_VER */ # endif /* Py_BUILD_CORE */ @@ -292,8 +289,9 @@ Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ # define SIZEOF_FPOS_T 8 # define SIZEOF_HKEY 8 # define SIZEOF_SIZE_T 8 +# define ALIGNOF_SIZE_T 8 /* configure.ac defines HAVE_LARGEFILE_SUPPORT iff - sizeof(off_t) > sizeof(long), and sizeof(PY_LONG_LONG) >= sizeof(off_t). + sizeof(off_t) > sizeof(long), and sizeof(long long) >= sizeof(off_t). On Win64 the second condition is not true, but if fpos_t replaces off_t then this is true. The uses of HAVE_LARGEFILE_SUPPORT imply that Win64 should define this. */ @@ -306,6 +304,7 @@ Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ # define SIZEOF_FPOS_T 8 # define SIZEOF_HKEY 4 # define SIZEOF_SIZE_T 4 +# define ALIGNOF_SIZE_T 4 /* MS VS2005 changes time_t to a 64-bit type on all platforms */ # if defined(_MSC_VER) && _MSC_VER >= 1400 # define SIZEOF_TIME_T 8 @@ -324,6 +323,7 @@ Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ #define SIZEOF_SHORT 2 #define SIZEOF_INT 4 #define SIZEOF_LONG 4 +#define ALIGNOF_LONG 4 #define SIZEOF_LONG_LONG 8 #define SIZEOF_DOUBLE 8 #define SIZEOF_FLOAT 4 @@ -383,6 +383,10 @@ Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ /* Define to 1 if you have the header file. */ #define HAVE_DIRECT_H 1 +/* Define to 1 if you have the declaration of `tzname', and to 0 if you don't. + */ +#define HAVE_DECL_TZNAME 1 + /* Define if you have dirent.h. */ /* #define DIRENT 1 */ @@ -681,4 +685,6 @@ Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ /* Define if libssl has X509_VERIFY_PARAM_set1_host and related function */ #define HAVE_X509_VERIFY_PARAM_SET1_HOST 1 +#define PLATLIBDIR "lib" + #endif /* !Py_CONFIG_H */ diff --git a/include/pydtrace.h b/include/pydtrace.h index 7a042781..75f8e7f7 100644 --- a/include/pydtrace.h +++ b/include/pydtrace.h @@ -36,6 +36,7 @@ static inline void PyDTrace_INSTANCE_DELETE_START(int arg0) {} static inline void PyDTrace_INSTANCE_DELETE_DONE(int arg0) {} static inline void PyDTrace_IMPORT_FIND_LOAD_START(const char *arg0) {} static inline void PyDTrace_IMPORT_FIND_LOAD_DONE(const char *arg0, int arg1) {} +static inline void PyDTrace_AUDIT(const char *arg0, void *arg1) {} static inline int PyDTrace_LINE_ENABLED(void) { return 0; } static inline int PyDTrace_FUNCTION_ENTRY_ENABLED(void) { return 0; } @@ -48,6 +49,7 @@ static inline int PyDTrace_INSTANCE_DELETE_START_ENABLED(void) { return 0; } static inline int PyDTrace_INSTANCE_DELETE_DONE_ENABLED(void) { return 0; } static inline int PyDTrace_IMPORT_FIND_LOAD_START_ENABLED(void) { return 0; } static inline int PyDTrace_IMPORT_FIND_LOAD_DONE_ENABLED(void) { return 0; } +static inline int PyDTrace_AUDIT_ENABLED(void) { return 0; } #endif /* !WITH_DTRACE */ diff --git a/include/pyerrors.h b/include/pyerrors.h index e56db035..f5d1c711 100644 --- a/include/pyerrors.h +++ b/include/pyerrors.h @@ -4,82 +4,12 @@ extern "C" { #endif -/* Error objects */ - -#ifndef Py_LIMITED_API -/* PyException_HEAD defines the initial segment of every exception class. */ -#define PyException_HEAD PyObject_HEAD PyObject *dict;\ - PyObject *args; PyObject *traceback;\ - PyObject *context; PyObject *cause;\ - char suppress_context; - -typedef struct { - PyException_HEAD -} PyBaseExceptionObject; - -typedef struct { - PyException_HEAD - PyObject *msg; - PyObject *filename; - PyObject *lineno; - PyObject *offset; - PyObject *text; - PyObject *print_file_and_line; -} PySyntaxErrorObject; - -typedef struct { - PyException_HEAD - PyObject *msg; - PyObject *name; - PyObject *path; -} PyImportErrorObject; - -typedef struct { - PyException_HEAD - PyObject *encoding; - PyObject *object; - Py_ssize_t start; - Py_ssize_t end; - PyObject *reason; -} PyUnicodeErrorObject; - -typedef struct { - PyException_HEAD - PyObject *code; -} PySystemExitObject; - -typedef struct { - PyException_HEAD - PyObject *myerrno; - PyObject *strerror; - PyObject *filename; - PyObject *filename2; -#ifdef MS_WINDOWS - PyObject *winerror; -#endif - Py_ssize_t written; /* only for BlockingIOError, -1 otherwise */ -} PyOSErrorObject; - -typedef struct { - PyException_HEAD - PyObject *value; -} PyStopIterationObject; - -/* Compatibility typedefs */ -typedef PyOSErrorObject PyEnvironmentErrorObject; -#ifdef MS_WINDOWS -typedef PyOSErrorObject PyWindowsErrorObject; -#endif -#endif /* !Py_LIMITED_API */ +#include // va_list /* Error handling definitions */ PyAPI_FUNC(void) PyErr_SetNone(PyObject *); PyAPI_FUNC(void) PyErr_SetObject(PyObject *, PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyErr_SetKeyError(PyObject *); -_PyErr_StackItem *_PyErr_GetTopmostException(PyThreadState *tstate); -#endif PyAPI_FUNC(void) PyErr_SetString( PyObject *exception, const char *string /* decoded from utf-8 */ @@ -93,23 +23,12 @@ PyAPI_FUNC(void) PyErr_GetExcInfo(PyObject **, PyObject **, PyObject **); PyAPI_FUNC(void) PyErr_SetExcInfo(PyObject *, PyObject *, PyObject *); #endif -#if defined(__clang__) || \ - (defined(__GNUC__) && \ - ((__GNUC__ >= 3) || \ - (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5))) -#define _Py_NO_RETURN __attribute__((__noreturn__)) -#else -#define _Py_NO_RETURN -#endif - -/* Defined in Python/pylifecycle.c */ -PyAPI_FUNC(void) Py_FatalError(const char *message) _Py_NO_RETURN; +/* Defined in Python/pylifecycle.c -#if defined(Py_DEBUG) || defined(Py_LIMITED_API) -#define _PyErr_OCCURRED() PyErr_Occurred() -#else -#define _PyErr_OCCURRED() (PyThreadState_GET()->curexc_type) -#endif + The Py_FatalError() function is replaced with a macro which logs + automatically the name of the current function, unless the Py_LIMITED_API + macro is defined. */ +PyAPI_FUNC(void) _Py_NO_RETURN Py_FatalError(const char *message); /* Error testing and normalization */ PyAPI_FUNC(int) PyErr_GivenExceptionMatches(PyObject *, PyObject *); @@ -127,9 +46,6 @@ PyAPI_FUNC(void) PyException_SetCause(PyObject *, PyObject *); /* Context manipulation (PEP 3134) */ PyAPI_FUNC(PyObject *) PyException_GetContext(PyObject *); PyAPI_FUNC(void) PyException_SetContext(PyObject *, PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *); -#endif /* */ @@ -138,12 +54,11 @@ PyAPI_FUNC(void) _PyErr_ChainExceptions(PyObject *, PyObject *, PyObject *); PyType_FastSubclass((PyTypeObject*)(x), Py_TPFLAGS_BASE_EXC_SUBCLASS)) #define PyExceptionInstance_Check(x) \ - PyType_FastSubclass((x)->ob_type, Py_TPFLAGS_BASE_EXC_SUBCLASS) + PyType_FastSubclass(Py_TYPE(x), Py_TPFLAGS_BASE_EXC_SUBCLASS) -#define PyExceptionClass_Name(x) \ - ((char *)(((PyTypeObject*)(x))->tp_name)) +PyAPI_FUNC(const char *) PyExceptionClass_Name(PyObject *); -#define PyExceptionInstance_Class(x) ((PyObject*)((x)->ob_type)) +#define PyExceptionInstance_Class(x) ((PyObject*)Py_TYPE(x)) /* Predefined exceptions */ @@ -231,6 +146,7 @@ PyAPI_DATA(PyObject *) PyExc_FutureWarning; PyAPI_DATA(PyObject *) PyExc_ImportWarning; PyAPI_DATA(PyObject *) PyExc_UnicodeWarning; PyAPI_DATA(PyObject *) PyExc_BytesWarning; +PyAPI_DATA(PyObject *) PyExc_EncodingWarning; PyAPI_DATA(PyObject *) PyExc_ResourceWarning; @@ -249,10 +165,6 @@ PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithFilename( PyObject *exc, const char *filename /* decoded from the filesystem encoding */ ); -#if defined(MS_WINDOWS) && !defined(Py_LIMITED_API) -PyAPI_FUNC(PyObject *) PyErr_SetFromErrnoWithUnicodeFilename( - PyObject *, const Py_UNICODE *) Py_DEPRECATED(3.3); -#endif /* MS_WINDOWS */ PyAPI_FUNC(PyObject *) PyErr_Format( PyObject *exception, @@ -266,27 +178,11 @@ PyAPI_FUNC(PyObject *) PyErr_FormatV( va_list vargs); #endif -#ifndef Py_LIMITED_API -/* Like PyErr_Format(), but saves current exception as __context__ and - __cause__. - */ -PyAPI_FUNC(PyObject *) _PyErr_FormatFromCause( - PyObject *exception, - const char *format, /* ASCII-encoded string */ - ... - ); -#endif - #ifdef MS_WINDOWS PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithFilename( int ierr, const char *filename /* decoded from the filesystem encoding */ ); -#ifndef Py_LIMITED_API -/* XXX redeclare to use WSTRING */ -PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErrWithUnicodeFilename( - int, const Py_UNICODE *) Py_DEPRECATED(3.3); -#endif PyAPI_FUNC(PyObject *) PyErr_SetFromWindowsErr(int); PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilenameObject( PyObject *,int, PyObject *); @@ -299,10 +195,6 @@ PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithFilename( int ierr, const char *filename /* decoded from the filesystem encoding */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErrWithUnicodeFilename( - PyObject *,int, const Py_UNICODE *) Py_DEPRECATED(3.3); -#endif PyAPI_FUNC(PyObject *) PyErr_SetExcFromWindowsErr(PyObject *, int); #endif /* MS_WINDOWS */ @@ -329,35 +221,12 @@ PyAPI_FUNC(PyObject *) PyErr_NewExceptionWithDoc( const char *name, const char *doc, PyObject *base, PyObject *dict); PyAPI_FUNC(void) PyErr_WriteUnraisable(PyObject *); -/* In exceptions.c */ -#ifndef Py_LIMITED_API -/* Helper that attempts to replace the current exception with one of the - * same type but with a prefix added to the exception text. The resulting - * exception description looks like: - * - * prefix (exc_type: original_exc_str) - * - * Only some exceptions can be safely replaced. If the function determines - * it isn't safe to perform the replacement, it will leave the original - * unmodified exception in place. - * - * Returns a borrowed reference to the new exception (if any), NULL if the - * existing exception was left in place. - */ -PyAPI_FUNC(PyObject *) _PyErr_TrySetFromCause( - const char *prefix_format, /* ASCII-encoded string */ - ... - ); -#endif - /* In signalmodule.c */ PyAPI_FUNC(int) PyErr_CheckSignals(void); PyAPI_FUNC(void) PyErr_SetInterrupt(void); - -/* In signalmodule.c */ -#ifndef Py_LIMITED_API -int PySignal_SetWakeupFd(int fd); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +PyAPI_FUNC(int) PyErr_SetInterruptEx(int signum); #endif /* Support for adding program text to SyntaxErrors */ @@ -368,20 +237,9 @@ PyAPI_FUNC(void) PyErr_SyntaxLocationEx( const char *filename, /* decoded from the filesystem encoding */ int lineno, int col_offset); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) PyErr_SyntaxLocationObject( - PyObject *filename, - int lineno, - int col_offset); -#endif PyAPI_FUNC(PyObject *) PyErr_ProgramText( const char *filename, /* decoded from the filesystem encoding */ int lineno); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) PyErr_ProgramTextObject( - PyObject *filename, - int lineno); -#endif /* The following functions are used to create and modify unicode exceptions from C */ @@ -396,35 +254,6 @@ PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_Create( const char *reason /* UTF-8 encoded string */ ); -/* create a UnicodeEncodeError object */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_Create( - const char *encoding, /* UTF-8 encoded string */ - const Py_UNICODE *object, - Py_ssize_t length, - Py_ssize_t start, - Py_ssize_t end, - const char *reason /* UTF-8 encoded string */ - ) Py_DEPRECATED(3.3); -#endif - -/* create a UnicodeTranslateError object */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) PyUnicodeTranslateError_Create( - const Py_UNICODE *object, - Py_ssize_t length, - Py_ssize_t start, - Py_ssize_t end, - const char *reason /* UTF-8 encoded string */ - ) Py_DEPRECATED(3.3); -PyAPI_FUNC(PyObject *) _PyUnicodeTranslateError_Create( - PyObject *object, - Py_ssize_t start, - Py_ssize_t end, - const char *reason /* UTF-8 encoded string */ - ); -#endif - /* get the encoding attribute */ PyAPI_FUNC(PyObject *) PyUnicodeEncodeError_GetEncoding(PyObject *); PyAPI_FUNC(PyObject *) PyUnicodeDecodeError_GetEncoding(PyObject *); @@ -478,25 +307,17 @@ PyAPI_FUNC(int) PyUnicodeTranslateError_SetReason( const char *reason /* UTF-8 encoded string */ ); -/* These APIs aren't really part of the error implementation, but - often needed to format error messages; the native C lib APIs are - not available on all platforms, which is why we provide emulations - for those platforms in Python/mysnprintf.c, - WARNING: The return value of snprintf varies across platforms; do - not rely on any particular behavior; eventually the C99 defn may - be reliable. -*/ -#if defined(MS_WIN32) && !defined(HAVE_SNPRINTF) -# define snprintf _snprintf -# define vsnprintf _vsnprintf -#endif - -#include PyAPI_FUNC(int) PyOS_snprintf(char *str, size_t size, const char *format, ...) Py_GCC_ATTRIBUTE((format(printf, 3, 4))); PyAPI_FUNC(int) PyOS_vsnprintf(char *str, size_t size, const char *format, va_list va) Py_GCC_ATTRIBUTE((format(printf, 3, 0))); +#ifndef Py_LIMITED_API +# define Py_CPYTHON_ERRORS_H +# include "cpython/pyerrors.h" +# undef Py_CPYTHON_ERRORS_H +#endif + #ifdef __cplusplus } #endif diff --git a/include/pyframe.h b/include/pyframe.h new file mode 100644 index 00000000..38162242 --- /dev/null +++ b/include/pyframe.h @@ -0,0 +1,22 @@ +/* Limited C API of PyFrame API + * + * Include "frameobject.h" to get the PyFrameObject structure. + */ + +#ifndef Py_PYFRAME_H +#define Py_PYFRAME_H +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _frame PyFrameObject; + +/* Return the line of code the frame is currently executing. */ +PyAPI_FUNC(int) PyFrame_GetLineNumber(PyFrameObject *); + +PyAPI_FUNC(PyCodeObject *) PyFrame_GetCode(PyFrameObject *frame); + +#ifdef __cplusplus +} +#endif +#endif /* !Py_PYFRAME_H */ diff --git a/include/pyhash.h b/include/pyhash.h index 9cfd071e..a314ea90 100644 --- a/include/pyhash.h +++ b/include/pyhash.h @@ -7,8 +7,10 @@ extern "C" { /* Helpers for hash functions */ #ifndef Py_LIMITED_API -PyAPI_FUNC(Py_hash_t) _Py_HashDouble(double); -PyAPI_FUNC(Py_hash_t) _Py_HashPointer(void*); +PyAPI_FUNC(Py_hash_t) _Py_HashDouble(PyObject *, double); +PyAPI_FUNC(Py_hash_t) _Py_HashPointer(const void*); +// Similar to _Py_HashPointer(), but don't replace -1 with -2 +PyAPI_FUNC(Py_hash_t) _Py_HashPointerRaw(const void*); PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void*, Py_ssize_t); #endif @@ -27,7 +29,6 @@ PyAPI_FUNC(Py_hash_t) _Py_HashBytes(const void*, Py_ssize_t); #define _PyHASH_MODULUS (((size_t)1 << _PyHASH_BITS) - 1) #define _PyHASH_INF 314159 -#define _PyHASH_NAN 0 #define _PyHASH_IMAG _PyHASH_MULTIPLIER @@ -75,7 +76,6 @@ typedef union { } expat; } _Py_HashSecret_t; PyAPI_DATA(_Py_HashSecret_t) _Py_HashSecret; -#endif #ifdef Py_DEBUG PyAPI_DATA(int) _Py_HashSecret_Initialized; @@ -83,7 +83,6 @@ PyAPI_DATA(int) _Py_HashSecret_Initialized; /* hash function definition */ -#ifndef Py_LIMITED_API typedef struct { Py_hash_t (*const hash)(const void *, Py_ssize_t); const char *name; @@ -119,7 +118,7 @@ PyAPI_FUNC(PyHash_FuncDef*) PyHash_GetFuncDef(void); * configure script. * * - FNV is available on all platforms and architectures. - * - SIPHASH24 only works on plaforms that don't require aligned memory for integers. + * - SIPHASH24 only works on platforms that don't require aligned memory for integers. * - With EXTERNAL embedders can provide an alternative implementation with:: * * PyHash_FuncDef PyHash_Func = {...}; diff --git a/include/pylifecycle.h b/include/pylifecycle.h index 5d9f049d..2df7fe6e 100644 --- a/include/pylifecycle.h +++ b/include/pylifecycle.h @@ -7,97 +7,10 @@ extern "C" { #endif -#ifndef Py_LIMITED_API -typedef struct { - const char *prefix; - const char *msg; - int user_err; -} _PyInitError; - -/* Almost all errors causing Python initialization to fail */ -#ifdef _MSC_VER - /* Visual Studio 2015 doesn't implement C99 __func__ in C */ -# define _Py_INIT_GET_FUNC() __FUNCTION__ -#else -# define _Py_INIT_GET_FUNC() __func__ -#endif - -#define _Py_INIT_OK() \ - (_PyInitError){.prefix = NULL, .msg = NULL, .user_err = 0} -#define _Py_INIT_ERR(MSG) \ - (_PyInitError){.prefix = _Py_INIT_GET_FUNC(), .msg = (MSG), .user_err = 0} -/* Error that can be fixed by the user like invalid input parameter. - Don't abort() the process on such error. */ -#define _Py_INIT_USER_ERR(MSG) \ - (_PyInitError){.prefix = _Py_INIT_GET_FUNC(), .msg = (MSG), .user_err = 1} -#define _Py_INIT_NO_MEMORY() _Py_INIT_USER_ERR("memory allocation failed") -#define _Py_INIT_FAILED(err) \ - (err.msg != NULL) - -#endif - - -PyAPI_FUNC(void) Py_SetProgramName(const wchar_t *); -PyAPI_FUNC(wchar_t *) Py_GetProgramName(void); - -PyAPI_FUNC(void) Py_SetPythonHome(const wchar_t *); -PyAPI_FUNC(wchar_t *) Py_GetPythonHome(void); - -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _Py_SetProgramFullPath(const wchar_t *); - -/* Only used by applications that embed the interpreter and need to - * override the standard encoding determination mechanism - */ -PyAPI_FUNC(int) Py_SetStandardStreamEncoding(const char *encoding, - const char *errors); - -/* PEP 432 Multi-phase initialization API (Private while provisional!) */ -PyAPI_FUNC(_PyInitError) _Py_InitializeCore( - PyInterpreterState **interp_p, - const _PyCoreConfig *config); -PyAPI_FUNC(int) _Py_IsCoreInitialized(void); -PyAPI_FUNC(_PyInitError) _Py_InitializeFromConfig( - const _PyCoreConfig *config); -#ifdef Py_BUILD_CORE -PyAPI_FUNC(void) _Py_Initialize_ReadEnvVarsNoAlloc(void); -#endif - -PyAPI_FUNC(PyObject *) _Py_GetGlobalVariablesAsDict(void); - -PyAPI_FUNC(_PyInitError) _PyCoreConfig_Read(_PyCoreConfig *); -PyAPI_FUNC(void) _PyCoreConfig_Clear(_PyCoreConfig *); -PyAPI_FUNC(int) _PyCoreConfig_Copy( - _PyCoreConfig *config, - const _PyCoreConfig *config2); -PyAPI_FUNC(PyObject *) _PyCoreConfig_AsDict(const _PyCoreConfig *config); -PyAPI_FUNC(void) _PyCoreConfig_SetGlobalConfig( - const _PyCoreConfig *config); - - -PyAPI_FUNC(_PyInitError) _PyMainInterpreterConfig_Read( - _PyMainInterpreterConfig *config, - const _PyCoreConfig *core_config); -PyAPI_FUNC(void) _PyMainInterpreterConfig_Clear(_PyMainInterpreterConfig *); -PyAPI_FUNC(int) _PyMainInterpreterConfig_Copy( - _PyMainInterpreterConfig *config, - const _PyMainInterpreterConfig *config2); -/* Used by _testcapi.get_main_config() */ -PyAPI_FUNC(PyObject*) _PyMainInterpreterConfig_AsDict( - const _PyMainInterpreterConfig *config); - -PyAPI_FUNC(_PyInitError) _Py_InitializeMainInterpreter( - PyInterpreterState *interp, - const _PyMainInterpreterConfig *config); -#endif /* !defined(Py_LIMITED_API) */ - /* Initialization and finalization */ PyAPI_FUNC(void) Py_Initialize(void); PyAPI_FUNC(void) Py_InitializeEx(int); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _Py_FatalInitError(_PyInitError err) _Py_NO_RETURN; -#endif PyAPI_FUNC(void) Py_Finalize(void); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000 PyAPI_FUNC(int) Py_FinalizeEx(void); @@ -112,42 +25,26 @@ PyAPI_FUNC(void) Py_EndInterpreter(PyThreadState *); /* Py_PyAtExit is for the atexit module, Py_AtExit is for low-level * exit functions. */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _Py_PyAtExit(void (*func)(PyObject *), PyObject *); -#endif PyAPI_FUNC(int) Py_AtExit(void (*func)(void)); -PyAPI_FUNC(void) Py_Exit(int) _Py_NO_RETURN; - -/* Restore signals that the interpreter has called SIG_IGN on to SIG_DFL. */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _Py_RestoreSignals(void); - -PyAPI_FUNC(int) Py_FdIsInteractive(FILE *, const char *); -#endif +PyAPI_FUNC(void) _Py_NO_RETURN Py_Exit(int); /* Bootstrap __main__ (defined in Modules/main.c) */ PyAPI_FUNC(int) Py_Main(int argc, wchar_t **argv); -#ifdef Py_BUILD_CORE -PyAPI_FUNC(int) _Py_UnixMain(int argc, char **argv); -#endif +PyAPI_FUNC(int) Py_BytesMain(int argc, char **argv); + +/* In pathconfig.c */ +PyAPI_FUNC(void) Py_SetProgramName(const wchar_t *); +PyAPI_FUNC(wchar_t *) Py_GetProgramName(void); + +PyAPI_FUNC(void) Py_SetPythonHome(const wchar_t *); +PyAPI_FUNC(wchar_t *) Py_GetPythonHome(void); -/* In getpath.c */ PyAPI_FUNC(wchar_t *) Py_GetProgramFullPath(void); + PyAPI_FUNC(wchar_t *) Py_GetPrefix(void); PyAPI_FUNC(wchar_t *) Py_GetExecPrefix(void); PyAPI_FUNC(wchar_t *) Py_GetPath(void); -#ifdef Py_BUILD_CORE -PyAPI_FUNC(_PyInitError) _PyPathConfig_Init(const _PyCoreConfig *core_config); -PyAPI_FUNC(int) _PyPathConfig_ComputeArgv0( - int argc, wchar_t **argv, - PyObject **argv0_p); -PyAPI_FUNC(int) _Py_FindEnvConfigValue( - FILE *env_file, - const wchar_t *key, - wchar_t *value, - size_t value_size); -#endif PyAPI_FUNC(void) Py_SetPath(const wchar_t *); #ifdef MS_WINDOWS int _Py_CheckPython3(void); @@ -159,60 +56,6 @@ PyAPI_FUNC(const char *) Py_GetPlatform(void); PyAPI_FUNC(const char *) Py_GetCopyright(void); PyAPI_FUNC(const char *) Py_GetCompiler(void); PyAPI_FUNC(const char *) Py_GetBuildInfo(void); -#ifndef Py_LIMITED_API -PyAPI_FUNC(const char *) _Py_gitidentifier(void); -PyAPI_FUNC(const char *) _Py_gitversion(void); -#endif - -/* Internal -- various one-time initializations */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyBuiltin_Init(void); -PyAPI_FUNC(_PyInitError) _PySys_BeginInit(PyObject **sysmod); -PyAPI_FUNC(int) _PySys_EndInit(PyObject *sysdict, _PyMainInterpreterConfig *config); -PyAPI_FUNC(_PyInitError) _PyImport_Init(PyInterpreterState *interp); -PyAPI_FUNC(void) _PyExc_Init(PyObject * bltinmod); -PyAPI_FUNC(_PyInitError) _PyImportHooks_Init(void); -PyAPI_FUNC(int) _PyFrame_Init(void); -PyAPI_FUNC(int) _PyFloat_Init(void); -PyAPI_FUNC(int) PyByteArray_Init(void); -PyAPI_FUNC(_PyInitError) _Py_HashRandomization_Init(const _PyCoreConfig *); -#endif -#ifdef Py_BUILD_CORE -PyAPI_FUNC(int) _Py_ReadHashSeed( - const char *seed_text, - int *use_hash_seed, - unsigned long *hash_seed); -#endif - -/* Various internal finalizers */ - -#ifdef Py_BUILD_CORE -PyAPI_FUNC(void) _PyExc_Fini(void); -PyAPI_FUNC(void) _PyImport_Fini(void); -PyAPI_FUNC(void) _PyImport_Fini2(void); -PyAPI_FUNC(void) _PyGC_DumpShutdownStats(void); -PyAPI_FUNC(void) _PyGC_Fini(void); -PyAPI_FUNC(void) _PyType_Fini(void); -PyAPI_FUNC(void) _Py_HashRandomization_Fini(void); -#endif /* Py_BUILD_CORE */ - -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) PyMethod_Fini(void); -PyAPI_FUNC(void) PyFrame_Fini(void); -PyAPI_FUNC(void) PyCFunction_Fini(void); -PyAPI_FUNC(void) PyDict_Fini(void); -PyAPI_FUNC(void) PyTuple_Fini(void); -PyAPI_FUNC(void) PyList_Fini(void); -PyAPI_FUNC(void) PySet_Fini(void); -PyAPI_FUNC(void) PyBytes_Fini(void); -PyAPI_FUNC(void) PyByteArray_Fini(void); -PyAPI_FUNC(void) PyFloat_Fini(void); -PyAPI_FUNC(void) PyOS_FiniInterrupts(void); -PyAPI_FUNC(void) PySlice_Fini(void); -PyAPI_FUNC(void) PyAsyncGen_Fini(void); - -PyAPI_FUNC(int) _Py_IsFinalizing(void); -#endif /* !Py_LIMITED_API */ /* Signals */ typedef void (*PyOS_sighandler_t)(int); @@ -220,16 +63,9 @@ PyAPI_FUNC(PyOS_sighandler_t) PyOS_getsig(int); PyAPI_FUNC(PyOS_sighandler_t) PyOS_setsig(int, PyOS_sighandler_t); #ifndef Py_LIMITED_API -/* Random */ -PyAPI_FUNC(int) _PyOS_URandom(void *buffer, Py_ssize_t size); -PyAPI_FUNC(int) _PyOS_URandomNonblock(void *buffer, Py_ssize_t size); -#endif /* !Py_LIMITED_API */ - -/* Legacy locale support */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _Py_CoerceLegacyLocale(const _PyCoreConfig *config); -PyAPI_FUNC(int) _Py_LegacyLocaleDetected(void); -PyAPI_FUNC(char *) _Py_SetLocaleFromEnv(int category); +# define Py_CPYTHON_PYLIFECYCLE_H +# include "cpython/pylifecycle.h" +# undef Py_CPYTHON_PYLIFECYCLE_H #endif #ifdef __cplusplus diff --git a/include/pymacro.h b/include/pymacro.h index 3f6ddbe9..202b936d 100644 --- a/include/pymacro.h +++ b/include/pymacro.h @@ -67,7 +67,7 @@ /* Define macros for inline documentation. */ -#define PyDoc_VAR(name) static char name[] +#define PyDoc_VAR(name) static const char name[] #define PyDoc_STRVAR(name,str) PyDoc_VAR(name) = PyDoc_STR(str) #ifdef WITH_DOC_STRINGS #define PyDoc_STR(str) str @@ -89,12 +89,44 @@ /* Check if pointer "p" is aligned to "a"-bytes boundary. */ #define _Py_IS_ALIGNED(p, a) (!((uintptr_t)(p) & (uintptr_t)((a) - 1))) -#ifdef __GNUC__ -#define Py_UNUSED(name) _unused_ ## name __attribute__((unused)) +/* Use this for unused arguments in a function definition to silence compiler + * warnings. Example: + * + * int func(int a, int Py_UNUSED(b)) { return a; } + */ +#if defined(__GNUC__) || defined(__clang__) +# define Py_UNUSED(name) _unused_ ## name __attribute__((unused)) #else -#define Py_UNUSED(name) _unused_ ## name +# define Py_UNUSED(name) _unused_ ## name #endif -#define Py_UNREACHABLE() abort() +#if defined(RANDALL_WAS_HERE) +# define Py_UNREACHABLE() \ + Py_FatalError( \ + "If you're seeing this, the code is in what I thought was\n" \ + "an unreachable state.\n\n" \ + "I could give you advice for what to do, but honestly, why\n" \ + "should you trust me? I clearly screwed this up. I'm writing\n" \ + "a message that should never appear, yet I know it will\n" \ + "probably appear someday.\n\n" \ + "On a deep level, I know I'm not up to this task.\n" \ + "I'm so sorry.\n" \ + "https://xkcd.com/2200") +#elif defined(Py_DEBUG) +# define Py_UNREACHABLE() \ + Py_FatalError( \ + "We've reached an unreachable state. Anything is possible.\n" \ + "The limits were in our heads all along. Follow your dreams.\n" \ + "https://xkcd.com/2200") +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 5)) +# define Py_UNREACHABLE() __builtin_unreachable() +#elif defined(__clang__) || defined(__INTEL_COMPILER) +# define Py_UNREACHABLE() __builtin_unreachable() +#elif defined(_MSC_VER) +# define Py_UNREACHABLE() __assume(0) +#else +# define Py_UNREACHABLE() \ + Py_FatalError("Unreachable C code path reached") +#endif #endif /* Py_PYMACRO_H */ diff --git a/include/pymath.h b/include/pymath.h index 6cf69f98..f8697243 100644 --- a/include/pymath.h +++ b/include/pymath.h @@ -125,7 +125,7 @@ PyAPI_FUNC(void) _Py_set_387controlword(unsigned short); /* Py_IS_FINITE(X) * Return 1 if float or double arg is neither infinite nor NAN, else 0. - * Some compilers (e.g. VisualStudio) have intrisics for this, so a special + * Some compilers (e.g. VisualStudio) have intrinsics for this, so a special * macro for this particular test is useful * Note: PC/pyconfig.h defines Py_IS_FINITE as _finite */ diff --git a/include/pymem.h b/include/pymem.h index 458a6489..66cdb0d2 100644 --- a/include/pymem.h +++ b/include/pymem.h @@ -11,53 +11,6 @@ extern "C" { #endif -#ifndef Py_LIMITED_API -PyAPI_FUNC(void *) PyMem_RawMalloc(size_t size); -PyAPI_FUNC(void *) PyMem_RawCalloc(size_t nelem, size_t elsize); -PyAPI_FUNC(void *) PyMem_RawRealloc(void *ptr, size_t new_size); -PyAPI_FUNC(void) PyMem_RawFree(void *ptr); - -/* Configure the Python memory allocators. Pass NULL to use default - allocators. */ -PyAPI_FUNC(int) _PyMem_SetupAllocators(const char *opt); - -/* Try to get the allocators name set by _PyMem_SetupAllocators(). */ -PyAPI_FUNC(const char*) _PyMem_GetAllocatorsName(void); - -/* Track an allocated memory block in the tracemalloc module. - Return 0 on success, return -1 on error (failed to allocate memory to store - the trace). - - Return -2 if tracemalloc is disabled. - - If memory block is already tracked, update the existing trace. */ -PyAPI_FUNC(int) PyTraceMalloc_Track( - unsigned int domain, - uintptr_t ptr, - size_t size); - -/* Untrack an allocated memory block in the tracemalloc module. - Do nothing if the block was not tracked. - - Return -2 if tracemalloc is disabled, otherwise return 0. */ -PyAPI_FUNC(int) PyTraceMalloc_Untrack( - unsigned int domain, - uintptr_t ptr); - -/* Get the traceback where a memory block was allocated. - - Return a tuple of (filename: str, lineno: int) tuples. - - Return None if the tracemalloc module is disabled or if the memory block - is not tracked by tracemalloc. - - Raise an exception and return NULL on error. */ -PyAPI_FUNC(PyObject*) _PyTraceMalloc_GetTraceback( - unsigned int domain, - uintptr_t ptr); -#endif /* !defined(Py_LIMITED_API) */ - - /* BEWARE: Each interface exports both functions and macros. Extension modules should @@ -72,8 +25,8 @@ PyAPI_FUNC(PyObject*) _PyTraceMalloc_GetTraceback( heap used by the Python DLL; it could be a disaster if you free()'ed that directly in your own extension. Using PyMem_Free instead ensures Python can return the memory to the proper heap. As another example, in - PYMALLOC_DEBUG mode, Python wraps all calls to all PyMem_ and PyObject_ - memory functions in special debugging wrappers that add additional + a debug build (Py_DEBUG macro), Python wraps all calls to all PyMem_ and + PyObject_ memory functions in special debugging wrappers that add additional debugging info to dynamic memory blocks. The system routines have no idea what to do with that stuff, and the Python wrappers have no idea what to do with raw blocks obtained directly by the system routines then. @@ -97,35 +50,10 @@ PyAPI_FUNC(PyObject*) _PyTraceMalloc_GetTraceback( */ PyAPI_FUNC(void *) PyMem_Malloc(size_t size); -#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000 PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); -#endif PyAPI_FUNC(void *) PyMem_Realloc(void *ptr, size_t new_size); PyAPI_FUNC(void) PyMem_Free(void *ptr); -#ifndef Py_LIMITED_API -/* strdup() using PyMem_RawMalloc() */ -PyAPI_FUNC(char *) _PyMem_RawStrdup(const char *str); - -/* strdup() using PyMem_Malloc() */ -PyAPI_FUNC(char *) _PyMem_Strdup(const char *str); - -/* wcsdup() using PyMem_RawMalloc() */ -PyAPI_FUNC(wchar_t*) _PyMem_RawWcsdup(const wchar_t *str); -#endif - -/* Macros. */ - -/* PyMem_MALLOC(0) means malloc(1). Some systems would return NULL - for malloc(0), which would be treated as an error. Some platforms - would return a pointer with no memory behind it, which would break - pymalloc. To solve these problems, allocate an extra byte. */ -/* Returns NULL to indicate error if a negative size or size larger than - Py_ssize_t can represent is supplied. Helps prevents security holes. */ -#define PyMem_MALLOC(n) PyMem_Malloc(n) -#define PyMem_REALLOC(p, n) PyMem_Realloc(p, n) -#define PyMem_FREE(p) PyMem_Free(p) - /* * Type-oriented memory interface * ============================== @@ -139,9 +67,6 @@ PyAPI_FUNC(wchar_t*) _PyMem_RawWcsdup(const wchar_t *str); #define PyMem_New(type, n) \ ( ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \ ( (type *) PyMem_Malloc((n) * sizeof(type)) ) ) -#define PyMem_NEW(type, n) \ - ( ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \ - ( (type *) PyMem_MALLOC((n) * sizeof(type)) ) ) /* * The value of (p) is always clobbered by this macro regardless of success. @@ -152,89 +77,24 @@ PyAPI_FUNC(wchar_t*) _PyMem_RawWcsdup(const wchar_t *str); #define PyMem_Resize(p, type, n) \ ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \ (type *) PyMem_Realloc((p), (n) * sizeof(type)) ) -#define PyMem_RESIZE(p, type, n) \ - ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : \ - (type *) PyMem_REALLOC((p), (n) * sizeof(type)) ) - -/* PyMem{Del,DEL} are left over from ancient days, and shouldn't be used - * anymore. They're just confusing aliases for PyMem_{Free,FREE} now. - */ -#define PyMem_Del PyMem_Free -#define PyMem_DEL PyMem_FREE - -#ifndef Py_LIMITED_API -typedef enum { - /* PyMem_RawMalloc(), PyMem_RawRealloc() and PyMem_RawFree() */ - PYMEM_DOMAIN_RAW, - - /* PyMem_Malloc(), PyMem_Realloc() and PyMem_Free() */ - PYMEM_DOMAIN_MEM, - - /* PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() */ - PYMEM_DOMAIN_OBJ -} PyMemAllocatorDomain; - -typedef struct { - /* user context passed as the first argument to the 4 functions */ - void *ctx; - - /* allocate a memory block */ - void* (*malloc) (void *ctx, size_t size); - - /* allocate a memory block initialized by zeros */ - void* (*calloc) (void *ctx, size_t nelem, size_t elsize); - /* allocate or resize a memory block */ - void* (*realloc) (void *ctx, void *ptr, size_t new_size); - /* release a memory block */ - void (*free) (void *ctx, void *ptr); -} PyMemAllocatorEx; +// Deprecated aliases only kept for backward compatibility. +// PyMem_Del and PyMem_DEL are defined with no parameter to be able to use +// them as function pointers (ex: dealloc = PyMem_Del). +#define PyMem_MALLOC(n) PyMem_Malloc(n) +#define PyMem_NEW(type, n) PyMem_New(type, n) +#define PyMem_REALLOC(p, n) PyMem_Realloc(p, n) +#define PyMem_RESIZE(p, type, n) PyMem_Resize(p, type, n) +#define PyMem_FREE(p) PyMem_Free(p) +#define PyMem_Del PyMem_Free +#define PyMem_DEL PyMem_Free -/* Get the memory block allocator of the specified domain. */ -PyAPI_FUNC(void) PyMem_GetAllocator(PyMemAllocatorDomain domain, - PyMemAllocatorEx *allocator); -/* Set the memory block allocator of the specified domain. - - The new allocator must return a distinct non-NULL pointer when requesting - zero bytes. - - For the PYMEM_DOMAIN_RAW domain, the allocator must be thread-safe: the GIL - is not held when the allocator is called. - - If the new allocator is not a hook (don't call the previous allocator), the - PyMem_SetupDebugHooks() function must be called to reinstall the debug hooks - on top on the new allocator. */ -PyAPI_FUNC(void) PyMem_SetAllocator(PyMemAllocatorDomain domain, - PyMemAllocatorEx *allocator); - -/* Setup hooks to detect bugs in the following Python memory allocator - functions: - - - PyMem_RawMalloc(), PyMem_RawRealloc(), PyMem_RawFree() - - PyMem_Malloc(), PyMem_Realloc(), PyMem_Free() - - PyObject_Malloc(), PyObject_Realloc() and PyObject_Free() - - Newly allocated memory is filled with the byte 0xCB, freed memory is filled - with the byte 0xDB. Additional checks: - - - detect API violations, ex: PyObject_Free() called on a buffer allocated - by PyMem_Malloc() - - detect write before the start of the buffer (buffer underflow) - - detect write after the end of the buffer (buffer overflow) - - The function does nothing if Python is not compiled is debug mode. */ -PyAPI_FUNC(void) PyMem_SetupDebugHooks(void); -#endif - -#ifdef Py_BUILD_CORE -/* Set the memory allocator of the specified domain to the default. - Save the old allocator into *old_alloc if it's non-NULL. - Return on success, or return -1 if the domain is unknown. */ -PyAPI_FUNC(int) _PyMem_SetDefaultAllocator( - PyMemAllocatorDomain domain, - PyMemAllocatorEx *old_alloc); +#ifndef Py_LIMITED_API +# define Py_CPYTHON_PYMEM_H +# include "cpython/pymem.h" +# undef Py_CPYTHON_PYMEM_H #endif #ifdef __cplusplus diff --git a/include/pyport.h b/include/pyport.h index 27e51b42..6ab0ae40 100644 --- a/include/pyport.h +++ b/include/pyport.h @@ -5,6 +5,27 @@ #include + +/* Defines to build Python and its standard library: + * + * - Py_BUILD_CORE: Build Python core. Give access to Python internals, but + * should not be used by third-party modules. + * - Py_BUILD_CORE_BUILTIN: Build a Python stdlib module as a built-in module. + * - Py_BUILD_CORE_MODULE: Build a Python stdlib module as a dynamic library. + * + * Py_BUILD_CORE_BUILTIN and Py_BUILD_CORE_MODULE imply Py_BUILD_CORE. + * + * On Windows, Py_BUILD_CORE_MODULE exports "PyInit_xxx" symbol, whereas + * Py_BUILD_CORE_BUILTIN does not. + */ +#if defined(Py_BUILD_CORE_BUILTIN) && !defined(Py_BUILD_CORE) +# define Py_BUILD_CORE +#endif +#if defined(Py_BUILD_CORE_MODULE) && !defined(Py_BUILD_CORE) +# define Py_BUILD_CORE +#endif + + /************************************************************************** Symbols and macros to supply platform-independent interfaces to basic C language & library operations whose spellings vary across platforms. @@ -80,7 +101,9 @@ typedef intptr_t Py_intptr_t; * sizeof(size_t). C99 doesn't define such a thing directly (size_t is an * unsigned integral type). See PEP 353 for details. */ -#ifdef HAVE_SSIZE_T +#ifdef HAVE_PY_SSIZE_T + +#elif HAVE_SSIZE_T typedef ssize_t Py_ssize_t; #elif SIZEOF_VOID_P == SIZEOF_SIZE_T typedef Py_intptr_t Py_ssize_t; @@ -110,10 +133,13 @@ typedef int Py_ssize_clean_t; /* Smallest negative value of type Py_ssize_t. */ #define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1) -/* PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf +/* Macro kept for backward compatibility: use "z" in new code. + * + * PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf * format to convert an argument with the width of a size_t or Py_ssize_t. - * C99 introduced "z" for this purpose, but not all platforms support that; - * e.g., MS compilers use "I" instead. + * C99 introduced "z" for this purpose, but old MSVCs had not supported it. + * Since MSVC supports "z" since (at least) 2015, we can just use "z" + * for new code. * * These "high level" Python format functions interpret "z" correctly on * all platforms (Python interprets the format string itself, and does whatever @@ -131,19 +157,11 @@ typedef int Py_ssize_clean_t; * Py_ssize_t index; * fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index); * - * That will expand to %ld, or %Id, or to something else correct for a - * Py_ssize_t on the platform. + * That will expand to %zd or to something else correct for a Py_ssize_t on + * the platform. */ #ifndef PY_FORMAT_SIZE_T -# if SIZEOF_SIZE_T == SIZEOF_INT && !defined(__APPLE__) -# define PY_FORMAT_SIZE_T "" -# elif SIZEOF_SIZE_T == SIZEOF_LONG -# define PY_FORMAT_SIZE_T "l" -# elif defined(MS_WINDOWS) -# define PY_FORMAT_SIZE_T "I" -# else -# error "This platform's pyconfig.h needs to define PY_FORMAT_SIZE_T" -# endif +# define PY_FORMAT_SIZE_T "z" #endif /* Py_LOCAL can be used instead of static to get the fastest possible calling @@ -164,18 +182,19 @@ typedef int Py_ssize_clean_t; */ #if defined(_MSC_VER) -#if defined(PY_LOCAL_AGGRESSIVE) -/* enable more aggressive optimization for visual studio */ -#pragma optimize("agtw", on) -#endif -/* ignore warnings if the compiler decides not to inline a function */ -#pragma warning(disable: 4710) -/* fastest possible local call under MSVC */ -#define Py_LOCAL(type) static type __fastcall -#define Py_LOCAL_INLINE(type) static __inline type __fastcall +# if defined(PY_LOCAL_AGGRESSIVE) + /* enable more aggressive optimization for MSVC */ + /* active in both release and debug builds - see bpo-43271 */ +# pragma optimize("gt", on) +#endif + /* ignore warnings if the compiler decides not to inline a function */ +# pragma warning(disable: 4710) + /* fastest possible local call under MSVC */ +# define Py_LOCAL(type) static type __fastcall +# define Py_LOCAL_INLINE(type) static __inline type __fastcall #else -#define Py_LOCAL(type) static type -#define Py_LOCAL_INLINE(type) static inline type +# define Py_LOCAL(type) static type +# define Py_LOCAL_INLINE(type) static inline type #endif /* Py_MEMCPY is kept for backwards compatibility, @@ -406,7 +425,7 @@ extern "C" { #endif /* get and set x87 control word for VisualStudio/x86 */ -#if defined(_MSC_VER) && !defined(_WIN64) /* x87 not supported in 64-bit */ +#if defined(_MSC_VER) && !defined(_WIN64) && !defined(_M_ARM) /* x87 not supported in 64-bit or ARM */ #define HAVE_PY_SET_53BIT_PRECISION 1 #define _Py_SET_53BIT_PRECISION_HEADER \ unsigned int old_387controlword, new_387controlword, out_387controlword @@ -483,18 +502,42 @@ extern "C" { /* Py_DEPRECATED(version) * Declare a variable, type, or function deprecated. + * The macro must be placed before the declaration. * Usage: - * extern int old_var Py_DEPRECATED(2.3); - * typedef int T1 Py_DEPRECATED(2.4); - * extern int x() Py_DEPRECATED(2.5); + * Py_DEPRECATED(3.3) extern int old_var; + * Py_DEPRECATED(3.4) typedef int T1; + * Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void); */ #if defined(__GNUC__) \ && ((__GNUC__ >= 4) || (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) #define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__)) +#elif defined(_MSC_VER) +#define Py_DEPRECATED(VERSION) __declspec(deprecated( \ + "deprecated in " #VERSION)) #else #define Py_DEPRECATED(VERSION_UNUSED) #endif +#if defined(__clang__) +#define _Py_COMP_DIAG_PUSH _Pragma("clang diagnostic push") +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ + _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#define _Py_COMP_DIAG_POP _Pragma("clang diagnostic pop") +#elif defined(__GNUC__) \ + && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) +#define _Py_COMP_DIAG_PUSH _Pragma("GCC diagnostic push") +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ + _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#define _Py_COMP_DIAG_POP _Pragma("GCC diagnostic pop") +#elif defined(_MSC_VER) +#define _Py_COMP_DIAG_PUSH __pragma(warning(push)) +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS __pragma(warning(disable: 4996)) +#define _Py_COMP_DIAG_POP __pragma(warning(pop)) +#else +#define _Py_COMP_DIAG_PUSH +#define _Py_COMP_DIAG_IGNORE_DEPR_DECLS +#define _Py_COMP_DIAG_POP +#endif /* _Py_HOT_FUNCTION * The hot attribute on a function is used to inform the compiler that the @@ -525,8 +568,10 @@ extern "C" { * Usage: * int _Py_NO_INLINE x(void) { return 3; } */ -#if defined(__GNUC__) || defined(__clang__) -# define _Py_NO_INLINE __attribute__((noinline)) +#if defined(_MSC_VER) +# define _Py_NO_INLINE __declspec(noinline) +#elif defined(__GNUC__) || defined(__clang__) +# define _Py_NO_INLINE __attribute__ ((noinline)) #else # define _Py_NO_INLINE #endif @@ -618,16 +663,18 @@ extern char * _getpty(int *, int, mode_t, int); # define HAVE_DECLSPEC_DLL #endif +#include "exports.h" + /* only get special linkage if built as shared or platform is Cygwin */ #if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__) # if defined(HAVE_DECLSPEC_DLL) -# if defined(Py_BUILD_CORE) || defined(Py_BUILD_CORE_BUILTIN) -# define PyAPI_FUNC(RTYPE) __declspec(dllexport) RTYPE -# define PyAPI_DATA(RTYPE) extern __declspec(dllexport) RTYPE +# if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE) +# define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE +# define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE /* module init functions inside the core need no external linkage */ /* except for Cygwin to handle embedding */ # if defined(__CYGWIN__) -# define PyMODINIT_FUNC __declspec(dllexport) PyObject* +# define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject* # else /* __CYGWIN__ */ # define PyMODINIT_FUNC PyObject* # endif /* __CYGWIN__ */ @@ -638,14 +685,14 @@ extern char * _getpty(int *, int, mode_t, int); /* failures similar to those described at the bottom of 4.1: */ /* http://docs.python.org/extending/windows.html#a-cookbook-approach */ # if !defined(__CYGWIN__) -# define PyAPI_FUNC(RTYPE) __declspec(dllimport) RTYPE +# define PyAPI_FUNC(RTYPE) Py_IMPORTED_SYMBOL RTYPE # endif /* !__CYGWIN__ */ -# define PyAPI_DATA(RTYPE) extern __declspec(dllimport) RTYPE +# define PyAPI_DATA(RTYPE) extern Py_IMPORTED_SYMBOL RTYPE /* module init functions outside the core must be exported */ # if defined(__cplusplus) -# define PyMODINIT_FUNC extern "C" __declspec(dllexport) PyObject* +# define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject* # else /* __cplusplus */ -# define PyMODINIT_FUNC __declspec(dllexport) PyObject* +# define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject* # endif /* __cplusplus */ # endif /* Py_BUILD_CORE */ # endif /* HAVE_DECLSPEC_DLL */ @@ -653,16 +700,16 @@ extern char * _getpty(int *, int, mode_t, int); /* If no external linkage macros defined by now, create defaults */ #ifndef PyAPI_FUNC -# define PyAPI_FUNC(RTYPE) RTYPE +# define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE #endif #ifndef PyAPI_DATA -# define PyAPI_DATA(RTYPE) extern RTYPE +# define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE #endif #ifndef PyMODINIT_FUNC # if defined(__cplusplus) -# define PyMODINIT_FUNC extern "C" PyObject* +# define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject* # else /* __cplusplus */ -# define PyMODINIT_FUNC PyObject* +# define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject* # endif /* __cplusplus */ #endif @@ -746,14 +793,14 @@ extern char * _getpty(int *, int, mode_t, int); */ #ifdef WORDS_BIGENDIAN -#define PY_BIG_ENDIAN 1 -#define PY_LITTLE_ENDIAN 0 +# define PY_BIG_ENDIAN 1 +# define PY_LITTLE_ENDIAN 0 #else -#define PY_BIG_ENDIAN 0 -#define PY_LITTLE_ENDIAN 1 +# define PY_BIG_ENDIAN 0 +# define PY_LITTLE_ENDIAN 1 #endif -#if defined(Py_BUILD_CORE) || defined(Py_BUILD_CORE_BUILTIN) +#ifdef Py_BUILD_CORE /* * Macros to protect CRT calls against instant termination when passed an * invalid parameter (issue23524). @@ -774,9 +821,9 @@ extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler; #endif /* Py_BUILD_CORE */ #ifdef __ANDROID__ -/* The Android langinfo.h header is not used. */ -#undef HAVE_LANGINFO_H -#undef CODESET + /* The Android langinfo.h header is not used. */ +# undef HAVE_LANGINFO_H +# undef CODESET #endif /* Maximum value of the Windows DWORD type */ @@ -787,7 +834,56 @@ extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler; * for compatibility. */ #ifndef WITH_THREAD -#define WITH_THREAD +# define WITH_THREAD #endif +/* Check that ALT_SOABI is consistent with Py_TRACE_REFS: + ./configure --with-trace-refs should must be used to define Py_TRACE_REFS */ +#if defined(ALT_SOABI) && defined(Py_TRACE_REFS) +# error "Py_TRACE_REFS ABI is not compatible with release and debug ABI" +#endif + +#if defined(__ANDROID__) || defined(__VXWORKS__) + // Use UTF-8 as the locale encoding, ignore the LC_CTYPE locale. + // See _Py_GetLocaleEncoding(), PyUnicode_DecodeLocale() + // and PyUnicode_EncodeLocale(). +# define _Py_FORCE_UTF8_LOCALE +#endif + +#if defined(_Py_FORCE_UTF8_LOCALE) || defined(__APPLE__) + // Use UTF-8 as the filesystem encoding. + // See PyUnicode_DecodeFSDefaultAndSize(), PyUnicode_EncodeFSDefault(), + // Py_DecodeLocale() and Py_EncodeLocale(). +# define _Py_FORCE_UTF8_FS_ENCODING +#endif + +/* Mark a function which cannot return. Example: + PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void); + + XLC support is intentionally omitted due to bpo-40244 */ +#ifndef _Py_NO_RETURN +#if defined(__clang__) || \ + (defined(__GNUC__) && \ + ((__GNUC__ >= 3) || \ + (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5))) +# define _Py_NO_RETURN __attribute__((__noreturn__)) +#elif defined(_MSC_VER) +# define _Py_NO_RETURN __declspec(noreturn) +#else +# define _Py_NO_RETURN +#endif +#endif + + +// Preprocessor check for a builtin preprocessor function. Always return 0 +// if __has_builtin() macro is not defined. +// +// __has_builtin() is available on clang and GCC 10. +#ifdef __has_builtin +# define _Py__has_builtin(x) __has_builtin(x) +#else +# define _Py__has_builtin(x) 0 +#endif + + #endif /* Py_PYPORT_H */ diff --git a/include/pystate.h b/include/pystate.h index 819c1427..bae44077 100644 --- a/include/pystate.h +++ b/include/pystate.h @@ -1,4 +1,3 @@ - /* Thread and interpreter state structures and their interfaces */ @@ -8,365 +7,88 @@ extern "C" { #endif -#include "pythread.h" - /* This limitation is for performance and simplicity. If needed it can be removed (with effort). */ #define MAX_CO_EXTRA_USERS 255 -/* State shared between threads */ - -struct _ts; /* Forward */ -struct _is; /* Forward */ -struct _frame; /* Forward declaration for PyFrameObject. */ +/* Forward declarations for PyFrameObject, PyThreadState + and PyInterpreterState */ +struct _ts; +struct _is; -#ifdef Py_LIMITED_API +/* struct _ts is defined in cpython/pystate.h */ +typedef struct _ts PyThreadState; +/* struct _is is defined in internal/pycore_interp.h */ typedef struct _is PyInterpreterState; -#else -typedef PyObject* (*_PyFrameEvalFunction)(struct _frame *, int); - - -typedef struct { - int install_signal_handlers; /* Install signal handlers? -1 means unset */ - - int ignore_environment; /* -E, Py_IgnoreEnvironmentFlag */ - int use_hash_seed; /* PYTHONHASHSEED=x */ - unsigned long hash_seed; - const char *allocator; /* Memory allocator: _PyMem_SetupAllocators() */ - int dev_mode; /* PYTHONDEVMODE, -X dev */ - int faulthandler; /* PYTHONFAULTHANDLER, -X faulthandler */ - int tracemalloc; /* PYTHONTRACEMALLOC, -X tracemalloc=N */ - int import_time; /* PYTHONPROFILEIMPORTTIME, -X importtime */ - int show_ref_count; /* -X showrefcount */ - int show_alloc_count; /* -X showalloccount */ - int dump_refs; /* PYTHONDUMPREFS */ - int malloc_stats; /* PYTHONMALLOCSTATS */ - int coerce_c_locale; /* PYTHONCOERCECLOCALE, -1 means unknown */ - int coerce_c_locale_warn; /* PYTHONCOERCECLOCALE=warn */ - int utf8_mode; /* PYTHONUTF8, -X utf8; -1 means unknown */ - - wchar_t *program_name; /* Program name, see also Py_GetProgramName() */ - int argc; /* Number of command line arguments, - -1 means unset */ - wchar_t **argv; /* Command line arguments */ - wchar_t *program; /* argv[0] or "" */ - - int nxoption; /* Number of -X options */ - wchar_t **xoptions; /* -X options */ - - int nwarnoption; /* Number of warnings options */ - wchar_t **warnoptions; /* Warnings options */ - - /* Path configuration inputs */ - wchar_t *module_search_path_env; /* PYTHONPATH environment variable */ - wchar_t *home; /* PYTHONHOME environment variable, - see also Py_SetPythonHome(). */ - - /* Path configuration outputs */ - int nmodule_search_path; /* Number of sys.path paths, - -1 means unset */ - wchar_t **module_search_paths; /* sys.path paths */ - wchar_t *executable; /* sys.executable */ - wchar_t *prefix; /* sys.prefix */ - wchar_t *base_prefix; /* sys.base_prefix */ - wchar_t *exec_prefix; /* sys.exec_prefix */ - wchar_t *base_exec_prefix; /* sys.base_exec_prefix */ - - /* Private fields */ - int _disable_importlib; /* Needed by freeze_importlib */ -} _PyCoreConfig; - -#define _PyCoreConfig_INIT \ - (_PyCoreConfig){ \ - .install_signal_handlers = -1, \ - .ignore_environment = -1, \ - .use_hash_seed = -1, \ - .coerce_c_locale = -1, \ - .faulthandler = -1, \ - .tracemalloc = -1, \ - .utf8_mode = -1, \ - .argc = -1, \ - .nmodule_search_path = -1} -/* Note: _PyCoreConfig_INIT sets other fields to 0/NULL */ - -/* Placeholders while working on the new configuration API - * - * See PEP 432 for final anticipated contents - */ -typedef struct { - int install_signal_handlers; /* Install signal handlers? -1 means unset */ - PyObject *argv; /* sys.argv list, can be NULL */ - PyObject *executable; /* sys.executable str */ - PyObject *prefix; /* sys.prefix str */ - PyObject *base_prefix; /* sys.base_prefix str, can be NULL */ - PyObject *exec_prefix; /* sys.exec_prefix str */ - PyObject *base_exec_prefix; /* sys.base_exec_prefix str, can be NULL */ - PyObject *warnoptions; /* sys.warnoptions list, can be NULL */ - PyObject *xoptions; /* sys._xoptions dict, can be NULL */ - PyObject *module_search_path; /* sys.path list */ -} _PyMainInterpreterConfig; - -#define _PyMainInterpreterConfig_INIT \ - (_PyMainInterpreterConfig){.install_signal_handlers = -1} -/* Note: _PyMainInterpreterConfig_INIT sets other fields to 0/NULL */ - -typedef struct _is { - - struct _is *next; - struct _ts *tstate_head; - - int64_t id; - int64_t id_refcount; - PyThread_type_lock id_mutex; - - PyObject *modules; - PyObject *modules_by_index; - PyObject *sysdict; - PyObject *builtins; - PyObject *importlib; - - /* Used in Python/sysmodule.c. */ - int check_interval; - - /* Used in Modules/_threadmodule.c. */ - long num_threads; - /* Support for runtime thread stack size tuning. - A value of 0 means using the platform's default stack size - or the size specified by the THREAD_STACK_SIZE macro. */ - /* Used in Python/thread.c. */ - size_t pythread_stacksize; - - PyObject *codec_search_path; - PyObject *codec_search_cache; - PyObject *codec_error_registry; - int codecs_initialized; - int fscodec_initialized; - - _PyCoreConfig core_config; - _PyMainInterpreterConfig config; -#ifdef HAVE_DLOPEN - int dlopenflags; -#endif - - PyObject *builtins_copy; - PyObject *import_func; - /* Initialized to PyEval_EvalFrameDefault(). */ - _PyFrameEvalFunction eval_frame; - Py_ssize_t co_extra_user_count; - freefunc co_extra_freefuncs[MAX_CO_EXTRA_USERS]; - -#ifdef HAVE_FORK - PyObject *before_forkers; - PyObject *after_forkers_parent; - PyObject *after_forkers_child; -#endif - /* AtExit module */ - void (*pyexitfunc)(PyObject *); - PyObject *pyexitmodule; - - uint64_t tstate_next_unique_id; -} PyInterpreterState; -#endif /* !Py_LIMITED_API */ +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void); +PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *); +PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *); +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* New in 3.9 */ +/* Get the current interpreter state. -/* State unique per thread */ + Issue a fatal error if there no current Python thread state or no current + interpreter. It cannot return NULL. -#ifndef Py_LIMITED_API -/* Py_tracefunc return -1 when raising an exception, or 0 for success. */ -typedef int (*Py_tracefunc)(PyObject *, struct _frame *, int, PyObject *); - -/* The following values are used for 'what' for tracefunc functions - * - * To add a new kind of trace event, also update "trace_init" in - * Python/sysmodule.c to define the Python level event name - */ -#define PyTrace_CALL 0 -#define PyTrace_EXCEPTION 1 -#define PyTrace_LINE 2 -#define PyTrace_RETURN 3 -#define PyTrace_C_CALL 4 -#define PyTrace_C_EXCEPTION 5 -#define PyTrace_C_RETURN 6 -#define PyTrace_OPCODE 7 -#endif /* Py_LIMITED_API */ - -#ifdef Py_LIMITED_API -typedef struct _ts PyThreadState; -#else - -typedef struct _err_stackitem { - /* This struct represents an entry on the exception stack, which is a - * per-coroutine state. (Coroutine in the computer science sense, - * including the thread and generators). - * This ensures that the exception state is not impacted by "yields" - * from an except handler. - */ - PyObject *exc_type, *exc_value, *exc_traceback; - - struct _err_stackitem *previous_item; - -} _PyErr_StackItem; - - -typedef struct _ts { - /* See Python/ceval.c for comments explaining most fields */ - - struct _ts *prev; - struct _ts *next; - PyInterpreterState *interp; - - /* Borrowed reference to the current frame (it can be NULL) */ - struct _frame *frame; - int recursion_depth; - char overflowed; /* The stack has overflowed. Allow 50 more calls - to handle the runtime error. */ - char recursion_critical; /* The current calls must not cause - a stack overflow. */ - int stackcheck_counter; - - /* 'tracing' keeps track of the execution depth when tracing/profiling. - This is to prevent the actual trace/profile code from being recorded in - the trace/profile. */ - int tracing; - int use_tracing; - - Py_tracefunc c_profilefunc; - Py_tracefunc c_tracefunc; - PyObject *c_profileobj; - PyObject *c_traceobj; - - /* The exception currently being raised */ - PyObject *curexc_type; - PyObject *curexc_value; - PyObject *curexc_traceback; - - /* The exception currently being handled, if no coroutines/generators - * are present. Always last element on the stack referred to be exc_info. - */ - _PyErr_StackItem exc_state; - - /* Pointer to the top of the stack of the exceptions currently - * being handled */ - _PyErr_StackItem *exc_info; - - PyObject *dict; /* Stores per-thread state */ - - int gilstate_counter; - - PyObject *async_exc; /* Asynchronous exception to raise */ - unsigned long thread_id; /* Thread id where this tstate was created */ - - int trash_delete_nesting; - PyObject *trash_delete_later; - - /* Called when a thread state is deleted normally, but not when it - * is destroyed after fork(). - * Pain: to prevent rare but fatal shutdown errors (issue 18808), - * Thread.join() must wait for the join'ed thread's tstate to be unlinked - * from the tstate chain. That happens at the end of a thread's life, - * in pystate.c. - * The obvious way doesn't quite work: create a lock which the tstate - * unlinking code releases, and have Thread.join() wait to acquire that - * lock. The problem is that we _are_ at the end of the thread's life: - * if the thread holds the last reference to the lock, decref'ing the - * lock will delete the lock, and that may trigger arbitrary Python code - * if there's a weakref, with a callback, to the lock. But by this time - * _PyThreadState_Current is already NULL, so only the simplest of C code - * can be allowed to run (in particular it must not be possible to - * release the GIL). - * So instead of holding the lock directly, the tstate holds a weakref to - * the lock: that's the value of on_delete_data below. Decref'ing a - * weakref is harmless. - * on_delete points to _threadmodule.c's static release_sentinel() function. - * After the tstate is unlinked, release_sentinel is called with the - * weakref-to-lock (on_delete_data) argument, and release_sentinel releases - * the indirectly held lock. - */ - void (*on_delete)(void *); - void *on_delete_data; - - int coroutine_origin_tracking_depth; - - PyObject *coroutine_wrapper; - int in_coroutine_wrapper; - - PyObject *async_gen_firstiter; - PyObject *async_gen_finalizer; - - PyObject *context; - uint64_t context_ver; - - /* Unique thread state id. */ - uint64_t id; - - /* XXX signal handlers should also be here */ - -} PyThreadState; -#endif /* !Py_LIMITED_API */ + The caller must hold the GIL. */ +PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Get(void); +#endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03080000 +/* New in 3.8 */ +PyAPI_FUNC(PyObject *) PyInterpreterState_GetDict(PyInterpreterState *); +#endif -PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void); -PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *); -PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 /* New in 3.7 */ PyAPI_FUNC(int64_t) PyInterpreterState_GetID(PyInterpreterState *); #endif -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyState_AddModule(PyObject*, struct PyModuleDef*); -#endif /* !Py_LIMITED_API */ #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 + +/* State unique per thread */ + /* New in 3.3 */ PyAPI_FUNC(int) PyState_AddModule(PyObject*, struct PyModuleDef*); PyAPI_FUNC(int) PyState_RemoveModule(struct PyModuleDef*); #endif PyAPI_FUNC(PyObject*) PyState_FindModule(struct PyModuleDef*); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyState_ClearModules(void); -#endif PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyThreadState *) _PyThreadState_Prealloc(PyInterpreterState *); -PyAPI_FUNC(void) _PyThreadState_Init(PyThreadState *); -#endif /* !Py_LIMITED_API */ PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *); PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyThreadState_DeleteExcept(PyThreadState *tstate); -#endif /* !Py_LIMITED_API */ -PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyGILState_Reinit(void); -#endif /* !Py_LIMITED_API */ -/* Return the current thread state. The global interpreter lock must be held. - * When the current thread state is NULL, this issues a fatal error (so that - * the caller needn't check for NULL). */ +/* Get the current thread state. + + When the current thread state is NULL, this issues a fatal error (so that + the caller needn't check for NULL). + + The caller must hold the GIL. + + See also PyThreadState_GET() and _PyThreadState_GET(). */ PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void); -#ifndef Py_LIMITED_API -/* Similar to PyThreadState_Get(), but don't issue a fatal error - * if it is NULL. */ -PyAPI_FUNC(PyThreadState *) _PyThreadState_UncheckedGet(void); -#endif /* !Py_LIMITED_API */ +/* Get the current Python thread state. + + Macro using PyThreadState_Get() or _PyThreadState_GET() depending if + pycore_pystate.h is included or not (this header redefines the macro). + + If PyThreadState_Get() is used, issue a fatal error if the current thread + state is NULL. + + See also PyThreadState_Get() and _PyThreadState_GET(). */ +#define PyThreadState_GET() PyThreadState_Get() PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *); PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void); PyAPI_FUNC(int) PyThreadState_SetAsyncExc(unsigned long, PyObject *); - -/* Variable and macro for in-line access to current thread state */ - -/* Assuming the current thread holds the GIL, this is the - PyThreadState for the current thread. */ -#ifdef Py_BUILD_CORE -# define _PyThreadState_Current _PyRuntime.gilstate.tstate_current -# define PyThreadState_GET() \ - ((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current)) -#else -# define PyThreadState_GET() PyThreadState_Get() +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03090000 +/* New in 3.9 */ +PyAPI_FUNC(PyInterpreterState*) PyThreadState_GetInterpreter(PyThreadState *tstate); +PyAPI_FUNC(PyFrameObject*) PyThreadState_GetFrame(PyThreadState *tstate); +PyAPI_FUNC(uint64_t) PyThreadState_GetID(PyThreadState *tstate); #endif typedef @@ -415,39 +137,11 @@ PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE); */ PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void); -#ifndef Py_LIMITED_API -/* Helper/diagnostic function - return 1 if the current thread - currently holds the GIL, 0 otherwise. - - The function returns 1 if _PyGILState_check_enabled is non-zero. */ -PyAPI_FUNC(int) PyGILState_Check(void); - -/* Unsafe function to get the single PyInterpreterState used by this process' - GILState implementation. - - Return NULL before _PyGILState_Init() is called and after _PyGILState_Fini() - is called. */ -PyAPI_FUNC(PyInterpreterState *) _PyGILState_GetInterpreterStateUnsafe(void); -#endif /* !Py_LIMITED_API */ - -/* The implementation of sys._current_frames() Returns a dict mapping - thread id to that thread's current frame. -*/ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyThread_CurrentFrames(void); -#endif - -/* Routines for advanced debuggers, requested by David Beazley. - Don't use unless you know what you are doing! */ #ifndef Py_LIMITED_API -PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Main(void); -PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Head(void); -PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_Next(PyInterpreterState *); -PyAPI_FUNC(PyThreadState *) PyInterpreterState_ThreadHead(PyInterpreterState *); -PyAPI_FUNC(PyThreadState *) PyThreadState_Next(PyThreadState *); - -typedef struct _frame *(*PyThreadFrameGetter)(PyThreadState *self_); +# define Py_CPYTHON_PYSTATE_H +# include "cpython/pystate.h" +# undef Py_CPYTHON_PYSTATE_H #endif #ifdef __cplusplus diff --git a/include/pystrhex.h b/include/pystrhex.h index 66a30e22..a4f36305 100644 --- a/include/pystrhex.h +++ b/include/pystrhex.h @@ -10,6 +10,9 @@ extern "C" { PyAPI_FUNC(PyObject*) _Py_strhex(const char* argbuf, const Py_ssize_t arglen); /* Returns a bytes() containing the ASCII hex representation of argbuf. */ PyAPI_FUNC(PyObject*) _Py_strhex_bytes(const char* argbuf, const Py_ssize_t arglen); +/* These variants include support for a separator between every N bytes: */ +PyAPI_FUNC(PyObject*) _Py_strhex_with_sep(const char* argbuf, const Py_ssize_t arglen, const PyObject* sep, const int bytes_per_group); +PyAPI_FUNC(PyObject*) _Py_strhex_bytes_with_sep(const char* argbuf, const Py_ssize_t arglen, const PyObject* sep, const int bytes_per_group); #endif /* !Py_LIMITED_API */ #ifdef __cplusplus diff --git a/include/pythonrun.h b/include/pythonrun.h index 6f0c6fc6..b0a2fc30 100644 --- a/include/pythonrun.h +++ b/include/pythonrun.h @@ -7,165 +7,22 @@ extern "C" { #endif -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) PyRun_SimpleStringFlags(const char *, PyCompilerFlags *); -PyAPI_FUNC(int) PyRun_AnyFileFlags(FILE *, const char *, PyCompilerFlags *); -PyAPI_FUNC(int) PyRun_AnyFileExFlags( - FILE *fp, - const char *filename, /* decoded from the filesystem encoding */ - int closeit, - PyCompilerFlags *flags); -PyAPI_FUNC(int) PyRun_SimpleFileExFlags( - FILE *fp, - const char *filename, /* decoded from the filesystem encoding */ - int closeit, - PyCompilerFlags *flags); -PyAPI_FUNC(int) PyRun_InteractiveOneFlags( - FILE *fp, - const char *filename, /* decoded from the filesystem encoding */ - PyCompilerFlags *flags); -PyAPI_FUNC(int) PyRun_InteractiveOneObject( - FILE *fp, - PyObject *filename, - PyCompilerFlags *flags); -PyAPI_FUNC(int) PyRun_InteractiveLoopFlags( - FILE *fp, - const char *filename, /* decoded from the filesystem encoding */ - PyCompilerFlags *flags); - -PyAPI_FUNC(struct _mod *) PyParser_ASTFromString( - const char *s, - const char *filename, /* decoded from the filesystem encoding */ - int start, - PyCompilerFlags *flags, - PyArena *arena); -PyAPI_FUNC(struct _mod *) PyParser_ASTFromStringObject( - const char *s, - PyObject *filename, - int start, - PyCompilerFlags *flags, - PyArena *arena); -PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile( - FILE *fp, - const char *filename, /* decoded from the filesystem encoding */ - const char* enc, - int start, - const char *ps1, - const char *ps2, - PyCompilerFlags *flags, - int *errcode, - PyArena *arena); -PyAPI_FUNC(struct _mod *) PyParser_ASTFromFileObject( - FILE *fp, - PyObject *filename, - const char* enc, - int start, - const char *ps1, - const char *ps2, - PyCompilerFlags *flags, - int *errcode, - PyArena *arena); -#endif - -#ifndef PyParser_SimpleParseString -#define PyParser_SimpleParseString(S, B) \ - PyParser_SimpleParseStringFlags(S, B, 0) -#define PyParser_SimpleParseFile(FP, S, B) \ - PyParser_SimpleParseFileFlags(FP, S, B, 0) -#endif -PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int, - int); -#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 -PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlagsFilename(const char *, - const char *, - int, int); -#endif -PyAPI_FUNC(struct _node *) PyParser_SimpleParseFileFlags(FILE *, const char *, - int, int); - -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *, - PyObject *, PyCompilerFlags *); - -PyAPI_FUNC(PyObject *) PyRun_FileExFlags( - FILE *fp, - const char *filename, /* decoded from the filesystem encoding */ - int start, - PyObject *globals, - PyObject *locals, - int closeit, - PyCompilerFlags *flags); -#endif - -#ifdef Py_LIMITED_API PyAPI_FUNC(PyObject *) Py_CompileString(const char *, const char *, int); -#else -#define Py_CompileString(str, p, s) Py_CompileStringExFlags(str, p, s, NULL, -1) -#define Py_CompileStringFlags(str, p, s, f) Py_CompileStringExFlags(str, p, s, f, -1) -PyAPI_FUNC(PyObject *) Py_CompileStringExFlags( - const char *str, - const char *filename, /* decoded from the filesystem encoding */ - int start, - PyCompilerFlags *flags, - int optimize); -PyAPI_FUNC(PyObject *) Py_CompileStringObject( - const char *str, - PyObject *filename, int start, - PyCompilerFlags *flags, - int optimize); -#endif -PyAPI_FUNC(struct symtable *) Py_SymtableString( - const char *str, - const char *filename, /* decoded from the filesystem encoding */ - int start); -#ifndef Py_LIMITED_API -PyAPI_FUNC(struct symtable *) Py_SymtableStringObject( - const char *str, - PyObject *filename, - int start); -#endif PyAPI_FUNC(void) PyErr_Print(void); PyAPI_FUNC(void) PyErr_PrintEx(int); PyAPI_FUNC(void) PyErr_Display(PyObject *, PyObject *, PyObject *); -#ifndef Py_LIMITED_API -/* Use macros for a bunch of old variants */ -#define PyRun_String(str, s, g, l) PyRun_StringFlags(str, s, g, l, NULL) -#define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags(fp, name, 0, NULL) -#define PyRun_AnyFileEx(fp, name, closeit) \ - PyRun_AnyFileExFlags(fp, name, closeit, NULL) -#define PyRun_AnyFileFlags(fp, name, flags) \ - PyRun_AnyFileExFlags(fp, name, 0, flags) -#define PyRun_SimpleString(s) PyRun_SimpleStringFlags(s, NULL) -#define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags(f, p, 0, NULL) -#define PyRun_SimpleFileEx(f, p, c) PyRun_SimpleFileExFlags(f, p, c, NULL) -#define PyRun_InteractiveOne(f, p) PyRun_InteractiveOneFlags(f, p, NULL) -#define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags(f, p, NULL) -#define PyRun_File(fp, p, s, g, l) \ - PyRun_FileExFlags(fp, p, s, g, l, 0, NULL) -#define PyRun_FileEx(fp, p, s, g, l, c) \ - PyRun_FileExFlags(fp, p, s, g, l, c, NULL) -#define PyRun_FileFlags(fp, p, s, g, l, flags) \ - PyRun_FileExFlags(fp, p, s, g, l, 0, flags) -#endif /* Stuff with no proper home (yet) */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, const char *); -#endif PyAPI_DATA(int) (*PyOS_InputHook)(void); -PyAPI_DATA(char) *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *); -#ifndef Py_LIMITED_API -PyAPI_DATA(PyThreadState*) _PyOS_ReadlineTState; -#endif /* Stack size, in "pointers" (so we get extra safety margins on 64-bit platforms). On a 32-bit platform, this translates to an 8k margin. */ #define PYOS_STACK_MARGIN 2048 -#if defined(WIN32) && !defined(MS_WIN64) && defined(_MSC_VER) && _MSC_VER >= 1300 +#if defined(WIN32) && !defined(MS_WIN64) && !defined(_M_ARM) && defined(_MSC_VER) && _MSC_VER >= 1300 /* Enable stack checking under Microsoft C */ #define USE_STACKCHECK #endif @@ -175,6 +32,12 @@ PyAPI_DATA(PyThreadState*) _PyOS_ReadlineTState; PyAPI_FUNC(int) PyOS_CheckStack(void); #endif +#ifndef Py_LIMITED_API +# define Py_CPYTHON_PYTHONRUN_H +# include "cpython/pythonrun.h" +# undef Py_CPYTHON_PYTHONRUN_H +#endif + #ifdef __cplusplus } #endif diff --git a/include/pythread.h b/include/pythread.h index eb61033b..bb9d8641 100644 --- a/include/pythread.h +++ b/include/pythread.h @@ -3,7 +3,6 @@ #define Py_PYTHREAD_H typedef void *PyThread_type_lock; -typedef void *PyThread_type_sema; #ifdef __cplusplus extern "C" { @@ -23,15 +22,29 @@ typedef enum PyLockStatus { PyAPI_FUNC(void) PyThread_init_thread(void); PyAPI_FUNC(unsigned long) PyThread_start_new_thread(void (*)(void *), void *); -PyAPI_FUNC(void) PyThread_exit_thread(void); +PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void); PyAPI_FUNC(unsigned long) PyThread_get_thread_ident(void); +#if defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(_WIN32) || defined(_AIX) +#define PY_HAVE_THREAD_NATIVE_ID +PyAPI_FUNC(unsigned long) PyThread_get_thread_native_id(void); +#endif + PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void); PyAPI_FUNC(void) PyThread_free_lock(PyThread_type_lock); PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int); #define WAIT_LOCK 1 #define NOWAIT_LOCK 0 +#ifndef Py_LIMITED_API +#ifdef HAVE_FORK +/* Private function to reinitialize a lock at fork in the child process. + Reset the lock to the unlocked state. + Return 0 on success, return -1 on error. */ +PyAPI_FUNC(int) _PyThread_at_fork_reinit(PyThread_type_lock *lock); +#endif /* HAVE_FORK */ +#endif /* !Py_LIMITED_API */ + /* PY_TIMEOUT_T is the integral type used to specify timeouts when waiting on a lock (see PyThread_acquire_lock_timed() below). PY_TIMEOUT_MAX is the highest usable value (in microseconds) of that @@ -46,16 +59,16 @@ PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int); #if defined(_POSIX_THREADS) /* PyThread_acquire_lock_timed() uses _PyTime_FromNanoseconds(us * 1000), convert microseconds to nanoseconds. */ -# define PY_TIMEOUT_MAX (PY_LLONG_MAX / 1000) +# define PY_TIMEOUT_MAX (LLONG_MAX / 1000) #elif defined (NT_THREADS) /* In the NT API, the timeout is a DWORD and is expressed in milliseconds */ -# if 0xFFFFFFFFLL * 1000 < PY_LLONG_MAX +# if 0xFFFFFFFFLL * 1000 < LLONG_MAX # define PY_TIMEOUT_MAX (0xFFFFFFFFLL * 1000) # else -# define PY_TIMEOUT_MAX PY_LLONG_MAX +# define PY_TIMEOUT_MAX LLONG_MAX # endif #else -# define PY_TIMEOUT_MAX PY_LLONG_MAX +# define PY_TIMEOUT_MAX LLONG_MAX #endif @@ -92,14 +105,15 @@ PyAPI_FUNC(PyObject*) PyThread_GetInfo(void); platforms, but it is not POSIX-compliant. Therefore, the new TSS API uses opaque data type to represent TSS keys to be compatible (see PEP 539). */ -PyAPI_FUNC(int) PyThread_create_key(void) Py_DEPRECATED(3.7); -PyAPI_FUNC(void) PyThread_delete_key(int key) Py_DEPRECATED(3.7); -PyAPI_FUNC(int) PyThread_set_key_value(int key, void *value) Py_DEPRECATED(3.7); -PyAPI_FUNC(void *) PyThread_get_key_value(int key) Py_DEPRECATED(3.7); -PyAPI_FUNC(void) PyThread_delete_key_value(int key) Py_DEPRECATED(3.7); +Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_create_key(void); +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key(int key); +Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_set_key_value(int key, + void *value); +Py_DEPRECATED(3.7) PyAPI_FUNC(void *) PyThread_get_key_value(int key); +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key_value(int key); /* Cleanup after a fork */ -PyAPI_FUNC(void) PyThread_ReInitTLS(void) Py_DEPRECATED(3.7); +Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_ReInitTLS(void); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 diff --git a/include/rangeobject.h b/include/rangeobject.h index 7e4dc288..d6af8473 100644 --- a/include/rangeobject.h +++ b/include/rangeobject.h @@ -19,7 +19,7 @@ PyAPI_DATA(PyTypeObject) PyRange_Type; PyAPI_DATA(PyTypeObject) PyRangeIter_Type; PyAPI_DATA(PyTypeObject) PyLongRangeIter_Type; -#define PyRange_Check(op) (Py_TYPE(op) == &PyRange_Type) +#define PyRange_Check(op) Py_IS_TYPE(op, &PyRange_Type) #ifdef __cplusplus } diff --git a/include/setobject.h b/include/setobject.h index fc0ea839..62516be5 100644 --- a/include/setobject.h +++ b/include/setobject.h @@ -70,7 +70,6 @@ PyAPI_DATA(PyObject *) _PySet_Dummy; PyAPI_FUNC(int) _PySet_NextEntry(PyObject *set, Py_ssize_t *pos, PyObject **key, Py_hash_t *hash); PyAPI_FUNC(int) _PySet_Update(PyObject *set, PyObject *iterable); -PyAPI_FUNC(int) PySet_ClearFreeList(void); #endif /* Section excluded by Py_LIMITED_API */ @@ -88,19 +87,22 @@ PyAPI_FUNC(int) PySet_Discard(PyObject *set, PyObject *key); PyAPI_FUNC(PyObject *) PySet_Pop(PyObject *set); PyAPI_FUNC(Py_ssize_t) PySet_Size(PyObject *anyset); -#define PyFrozenSet_CheckExact(ob) (Py_TYPE(ob) == &PyFrozenSet_Type) +#define PyFrozenSet_CheckExact(ob) Py_IS_TYPE(ob, &PyFrozenSet_Type) +#define PyFrozenSet_Check(ob) \ + (Py_IS_TYPE(ob, &PyFrozenSet_Type) || \ + PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) + #define PyAnySet_CheckExact(ob) \ - (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type) + (Py_IS_TYPE(ob, &PySet_Type) || Py_IS_TYPE(ob, &PyFrozenSet_Type)) #define PyAnySet_Check(ob) \ - (Py_TYPE(ob) == &PySet_Type || Py_TYPE(ob) == &PyFrozenSet_Type || \ + (Py_IS_TYPE(ob, &PySet_Type) || Py_IS_TYPE(ob, &PyFrozenSet_Type) || \ PyType_IsSubtype(Py_TYPE(ob), &PySet_Type) || \ PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) + +#define PySet_CheckExact(op) Py_IS_TYPE(op, &PySet_Type) #define PySet_Check(ob) \ - (Py_TYPE(ob) == &PySet_Type || \ + (Py_IS_TYPE(ob, &PySet_Type) || \ PyType_IsSubtype(Py_TYPE(ob), &PySet_Type)) -#define PyFrozenSet_Check(ob) \ - (Py_TYPE(ob) == &PyFrozenSet_Type || \ - PyType_IsSubtype(Py_TYPE(ob), &PyFrozenSet_Type)) #ifdef __cplusplus } diff --git a/include/sliceobject.h b/include/sliceobject.h index c238b099..2c889508 100644 --- a/include/sliceobject.h +++ b/include/sliceobject.h @@ -28,7 +28,7 @@ typedef struct { PyAPI_DATA(PyTypeObject) PySlice_Type; PyAPI_DATA(PyTypeObject) PyEllipsis_Type; -#define PySlice_Check(op) (Py_TYPE(op) == &PySlice_Type) +#define PySlice_Check(op) Py_IS_TYPE(op, &PySlice_Type) PyAPI_FUNC(PyObject *) PySlice_New(PyObject* start, PyObject* stop, PyObject* step); @@ -40,9 +40,11 @@ PyAPI_FUNC(int) _PySlice_GetLongIndices(PySliceObject *self, PyObject *length, #endif PyAPI_FUNC(int) PySlice_GetIndices(PyObject *r, Py_ssize_t length, Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step); +Py_DEPRECATED(3.7) PyAPI_FUNC(int) PySlice_GetIndicesEx(PyObject *r, Py_ssize_t length, Py_ssize_t *start, Py_ssize_t *stop, - Py_ssize_t *step, Py_ssize_t *slicelength) Py_DEPRECATED(3.7); + Py_ssize_t *step, + Py_ssize_t *slicelength); #if !defined(Py_LIMITED_API) || (Py_LIMITED_API+0 >= 0x03050400 && Py_LIMITED_API+0 < 0x03060000) || Py_LIMITED_API+0 >= 0x03060100 #define PySlice_GetIndicesEx(slice, length, start, stop, step, slicelen) ( \ diff --git a/include/structmember.h b/include/structmember.h index b54f7081..93b7aff8 100644 --- a/include/structmember.h +++ b/include/structmember.h @@ -62,6 +62,7 @@ typedef struct PyMemberDef { #define PY_WRITE_RESTRICTED 4 #define RESTRICTED (READ_RESTRICTED | PY_WRITE_RESTRICTED) +#define PY_AUDIT_READ READ_RESTRICTED /* Current API, use this */ PyAPI_FUNC(PyObject *) PyMember_GetOne(const char *, struct PyMemberDef *); diff --git a/include/structseq.h b/include/structseq.h index e5e5d5c5..8f51c891 100644 --- a/include/structseq.h +++ b/include/structseq.h @@ -19,7 +19,7 @@ typedef struct PyStructSequence_Desc { int n_in_sequence; } PyStructSequence_Desc; -extern char* PyStructSequence_UnnamedField; +extern const char * const PyStructSequence_UnnamedField; #ifndef Py_LIMITED_API PyAPI_FUNC(void) PyStructSequence_InitType(PyTypeObject *type, diff --git a/include/sysmodule.h b/include/sysmodule.h index 719ecfcf..670e5d28 100644 --- a/include/sysmodule.h +++ b/include/sysmodule.h @@ -9,10 +9,6 @@ extern "C" { PyAPI_FUNC(PyObject *) PySys_GetObject(const char *); PyAPI_FUNC(int) PySys_SetObject(const char *, PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PySys_GetObjectId(_Py_Identifier *key); -PyAPI_FUNC(int) _PySys_SetObjectId(_Py_Identifier *key, PyObject *); -#endif PyAPI_FUNC(void) PySys_SetArgv(int, wchar_t **); PyAPI_FUNC(void) PySys_SetArgvEx(int, wchar_t **, int); @@ -34,12 +30,9 @@ PyAPI_FUNC(void) PySys_AddXOption(const wchar_t *); PyAPI_FUNC(PyObject *) PySys_GetXOptions(void); #ifndef Py_LIMITED_API -PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *); -#endif - -#ifdef Py_BUILD_CORE -PyAPI_FUNC(int) _PySys_AddXOptionWithError(const wchar_t *s); -PyAPI_FUNC(int) _PySys_AddWarnOptionWithError(PyObject *option); +# define Py_CPYTHON_SYSMODULE_H +# include "cpython/sysmodule.h" +# undef Py_CPYTHON_SYSMODULE_H #endif #ifdef __cplusplus diff --git a/include/token.h b/include/token.h index cd1cd00f..eb1b9ea4 100644 --- a/include/token.h +++ b/include/token.h @@ -1,3 +1,4 @@ +/* Auto-generated by Tools/scripts/generate_token.py */ /* Token types */ #ifndef Py_LIMITED_API @@ -62,25 +63,29 @@ extern "C" { #define ATEQUAL 50 #define RARROW 51 #define ELLIPSIS 52 -/* Don't forget to update the table _PyParser_TokenNames in tokenizer.c! */ -#define OP 53 -#define ERRORTOKEN 54 -/* These aren't used by the C tokenizer but are needed for tokenize.py */ -#define COMMENT 55 -#define NL 56 -#define ENCODING 57 -#define N_TOKENS 58 +#define COLONEQUAL 53 +#define OP 54 +#define AWAIT 55 +#define ASYNC 56 +#define TYPE_IGNORE 57 +#define TYPE_COMMENT 58 +#define SOFT_KEYWORD 59 +#define ERRORTOKEN 60 +#define N_TOKENS 64 +#define NT_OFFSET 256 /* Special definitions for cooperation with parser */ -#define NT_OFFSET 256 - #define ISTERMINAL(x) ((x) < NT_OFFSET) #define ISNONTERMINAL(x) ((x) >= NT_OFFSET) #define ISEOF(x) ((x) == ENDMARKER) +#define ISWHITESPACE(x) ((x) == ENDMARKER || \ + (x) == NEWLINE || \ + (x) == INDENT || \ + (x) == DEDENT) -PyAPI_DATA(const char *) _PyParser_TokenNames[]; /* Token names */ +PyAPI_DATA(const char * const) _PyParser_TokenNames[]; /* Token names */ PyAPI_FUNC(int) PyToken_OneChar(int); PyAPI_FUNC(int) PyToken_TwoChars(int, int); PyAPI_FUNC(int) PyToken_ThreeChars(int, int, int); diff --git a/include/traceback.h b/include/traceback.h index b5874100..781e5a6e 100644 --- a/include/traceback.h +++ b/include/traceback.h @@ -1,117 +1,24 @@ - #ifndef Py_TRACEBACK_H #define Py_TRACEBACK_H #ifdef __cplusplus extern "C" { #endif -#include "pystate.h" - -struct _frame; - /* Traceback interface */ -#ifndef Py_LIMITED_API -typedef struct _traceback { - PyObject_HEAD - struct _traceback *tb_next; - struct _frame *tb_frame; - int tb_lasti; - int tb_lineno; -} PyTracebackObject; -#endif -PyAPI_FUNC(int) PyTraceBack_Here(struct _frame *); +PyAPI_FUNC(int) PyTraceBack_Here(PyFrameObject *); PyAPI_FUNC(int) PyTraceBack_Print(PyObject *, PyObject *); -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _Py_DisplaySourceLine(PyObject *, PyObject *, int, int); -PyAPI_FUNC(void) _PyTraceback_Add(const char *, const char *, int); -#endif /* Reveal traceback type so we can typecheck traceback objects */ PyAPI_DATA(PyTypeObject) PyTraceBack_Type; -#define PyTraceBack_Check(v) (Py_TYPE(v) == &PyTraceBack_Type) - -#ifndef Py_LIMITED_API -/* Write the Python traceback into the file 'fd'. For example: - - Traceback (most recent call first): - File "xxx", line xxx in - File "xxx", line xxx in - ... - File "xxx", line xxx in - - This function is written for debug purpose only, to dump the traceback in - the worst case: after a segmentation fault, at fatal error, etc. That's why, - it is very limited. Strings are truncated to 100 characters and encoded to - ASCII with backslashreplace. It doesn't write the source code, only the - function name, filename and line number of each frame. Write only the first - 100 frames: if the traceback is truncated, write the line " ...". - - This function is signal safe. */ - -PyAPI_FUNC(void) _Py_DumpTraceback( - int fd, - PyThreadState *tstate); - -/* Write the traceback of all threads into the file 'fd'. current_thread can be - NULL. - - Return NULL on success, or an error message on error. +#define PyTraceBack_Check(v) Py_IS_TYPE(v, &PyTraceBack_Type) - This function is written for debug purpose only. It calls - _Py_DumpTraceback() for each thread, and so has the same limitations. It - only write the traceback of the first 100 threads: write "..." if there are - more threads. - - If current_tstate is NULL, the function tries to get the Python thread state - of the current thread. It is not an error if the function is unable to get - the current Python thread state. - - If interp is NULL, the function tries to get the interpreter state from - the current Python thread state, or from - _PyGILState_GetInterpreterStateUnsafe() in last resort. - - It is better to pass NULL to interp and current_tstate, the function tries - different options to retrieve these informations. - - This function is signal safe. */ - -PyAPI_FUNC(const char*) _Py_DumpTracebackThreads( - int fd, - PyInterpreterState *interp, - PyThreadState *current_tstate); -#endif /* !Py_LIMITED_API */ #ifndef Py_LIMITED_API - -/* Write a Unicode object into the file descriptor fd. Encode the string to - ASCII using the backslashreplace error handler. - - Do nothing if text is not a Unicode object. The function accepts Unicode - string which is not ready (PyUnicode_WCHAR_KIND). - - This function is signal safe. */ -PyAPI_FUNC(void) _Py_DumpASCII(int fd, PyObject *text); - -/* Format an integer as decimal into the file descriptor fd. - - This function is signal safe. */ -PyAPI_FUNC(void) _Py_DumpDecimal( - int fd, - unsigned long value); - -/* Format an integer as hexadecimal into the file descriptor fd with at least - width digits. - - The maximum width is sizeof(unsigned long)*2 digits. - - This function is signal safe. */ -PyAPI_FUNC(void) _Py_DumpHexadecimal( - int fd, - unsigned long value, - Py_ssize_t width); - -#endif /* !Py_LIMITED_API */ +# define Py_CPYTHON_TRACEBACK_H +# include "cpython/traceback.h" +# undef Py_CPYTHON_TRACEBACK_H +#endif #ifdef __cplusplus } diff --git a/include/tracemalloc.h b/include/tracemalloc.h new file mode 100644 index 00000000..bd14217c --- /dev/null +++ b/include/tracemalloc.h @@ -0,0 +1,38 @@ +#ifndef Py_TRACEMALLOC_H +#define Py_TRACEMALLOC_H + +#ifndef Py_LIMITED_API +/* Track an allocated memory block in the tracemalloc module. + Return 0 on success, return -1 on error (failed to allocate memory to store + the trace). + + Return -2 if tracemalloc is disabled. + + If memory block is already tracked, update the existing trace. */ +PyAPI_FUNC(int) PyTraceMalloc_Track( + unsigned int domain, + uintptr_t ptr, + size_t size); + +/* Untrack an allocated memory block in the tracemalloc module. + Do nothing if the block was not tracked. + + Return -2 if tracemalloc is disabled, otherwise return 0. */ +PyAPI_FUNC(int) PyTraceMalloc_Untrack( + unsigned int domain, + uintptr_t ptr); + +/* Get the traceback where a memory block was allocated. + + Return a tuple of (filename: str, lineno: int) tuples. + + Return None if the tracemalloc module is disabled or if the memory block + is not tracked by tracemalloc. + + Raise an exception and return NULL on error. */ +PyAPI_FUNC(PyObject*) _PyTraceMalloc_GetTraceback( + unsigned int domain, + uintptr_t ptr); +#endif + +#endif /* !Py_TRACEMALLOC_H */ diff --git a/include/tupleobject.h b/include/tupleobject.h index 72a7d8d5..e796a320 100644 --- a/include/tupleobject.h +++ b/include/tupleobject.h @@ -1,4 +1,3 @@ - /* Tuple object interface */ #ifndef Py_TUPLEOBJECT_H @@ -21,52 +20,26 @@ inserted in the tuple. Similarly, PyTuple_GetItem does not increment the returned item's reference count. */ -#ifndef Py_LIMITED_API -typedef struct { - PyObject_VAR_HEAD - PyObject *ob_item[1]; - - /* ob_item contains space for 'ob_size' elements. - * Items must normally not be NULL, except during construction when - * the tuple is not yet visible outside the function that builds it. - */ -} PyTupleObject; -#endif - PyAPI_DATA(PyTypeObject) PyTuple_Type; PyAPI_DATA(PyTypeObject) PyTupleIter_Type; #define PyTuple_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_TUPLE_SUBCLASS) -#define PyTuple_CheckExact(op) (Py_TYPE(op) == &PyTuple_Type) +#define PyTuple_CheckExact(op) Py_IS_TYPE(op, &PyTuple_Type) PyAPI_FUNC(PyObject *) PyTuple_New(Py_ssize_t size); PyAPI_FUNC(Py_ssize_t) PyTuple_Size(PyObject *); PyAPI_FUNC(PyObject *) PyTuple_GetItem(PyObject *, Py_ssize_t); PyAPI_FUNC(int) PyTuple_SetItem(PyObject *, Py_ssize_t, PyObject *); PyAPI_FUNC(PyObject *) PyTuple_GetSlice(PyObject *, Py_ssize_t, Py_ssize_t); -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyTuple_Resize(PyObject **, Py_ssize_t); -#endif PyAPI_FUNC(PyObject *) PyTuple_Pack(Py_ssize_t, ...); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyTuple_MaybeUntrack(PyObject *); -#endif -/* Macro, trading safety for speed */ #ifndef Py_LIMITED_API -#define PyTuple_GET_ITEM(op, i) (((PyTupleObject *)(op))->ob_item[i]) -#define PyTuple_GET_SIZE(op) (assert(PyTuple_Check(op)),Py_SIZE(op)) - -/* Macro, *only* to be used to fill in brand new tuples */ -#define PyTuple_SET_ITEM(op, i, v) (((PyTupleObject *)(op))->ob_item[i] = v) +# define Py_CPYTHON_TUPLEOBJECT_H +# include "cpython/tupleobject.h" +# undef Py_CPYTHON_TUPLEOBJECT_H #endif -PyAPI_FUNC(int) PyTuple_ClearFreeList(void); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _PyTuple_DebugMallocStats(FILE *out); -#endif /* Py_LIMITED_API */ - #ifdef __cplusplus } #endif diff --git a/include/typeslots.h b/include/typeslots.h index 0ce6a377..5800d015 100644 --- a/include/typeslots.h +++ b/include/typeslots.h @@ -1,7 +1,12 @@ /* Do not renumber the file; these numbers are part of the stable ABI. */ +#if defined(Py_LIMITED_API) /* Disabled, see #10181 */ #undef Py_bf_getbuffer #undef Py_bf_releasebuffer +#else +#define Py_bf_getbuffer 1 +#define Py_bf_releasebuffer 2 +#endif #define Py_mp_ass_subscript 3 #define Py_mp_length 4 #define Py_mp_subscript 5 @@ -83,3 +88,7 @@ /* New in 3.5 */ #define Py_tp_finalize 80 #endif +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +/* New in 3.10 */ +#define Py_am_send 81 +#endif diff --git a/include/ucnhash.h b/include/ucnhash.h deleted file mode 100644 index 45362e99..00000000 --- a/include/ucnhash.h +++ /dev/null @@ -1,36 +0,0 @@ -/* Unicode name database interface */ -#ifndef Py_LIMITED_API -#ifndef Py_UCNHASH_H -#define Py_UCNHASH_H -#ifdef __cplusplus -extern "C" { -#endif - -/* revised ucnhash CAPI interface (exported through a "wrapper") */ - -#define PyUnicodeData_CAPSULE_NAME "unicodedata.ucnhash_CAPI" - -typedef struct { - - /* Size of this struct */ - int size; - - /* Get name for a given character code. Returns non-zero if - success, zero if not. Does not set Python exceptions. - If self is NULL, data come from the default version of the database. - If it is not NULL, it should be a unicodedata.ucd_X_Y_Z object */ - int (*getname)(PyObject *self, Py_UCS4 code, char* buffer, int buflen, - int with_alias_and_seq); - - /* Get character code for a given name. Same error handling - as for getname. */ - int (*getcode)(PyObject *self, const char* name, int namelen, Py_UCS4* code, - int with_named_seq); - -} _PyUnicode_Name_CAPI; - -#ifdef __cplusplus -} -#endif -#endif /* !Py_UCNHASH_H */ -#endif /* !Py_LIMITED_API */ diff --git a/include/unicodeobject.h b/include/unicodeobject.h index 45998a13..b0ac086a 100644 --- a/include/unicodeobject.h +++ b/include/unicodeobject.h @@ -83,16 +83,6 @@ Copyright (c) Corporation for National Research Initiatives. /* #define HAVE_WCHAR_H */ /* #define HAVE_USABLE_WCHAR_T */ -/* Py_UNICODE was the native Unicode storage format (code unit) used by - Python and represents a single Unicode element in the Unicode type. - With PEP 393, Py_UNICODE is deprecated and replaced with a - typedef to wchar_t. */ - -#ifndef Py_LIMITED_API -#define PY_UNICODE_TYPE wchar_t -typedef wchar_t Py_UNICODE /* Py_DEPRECATED(3.3) */; -#endif - /* If the compiler provides a wchar_t type we try to support it through the interface functions PyUnicode_FromWideChar(), PyUnicode_AsWideChar() and PyUnicode_AsWideCharString(). */ @@ -113,458 +103,17 @@ typedef uint32_t Py_UCS4; typedef uint16_t Py_UCS2; typedef uint8_t Py_UCS1; -/* --- Internal Unicode Operations ---------------------------------------- */ - -/* Since splitting on whitespace is an important use case, and - whitespace in most situations is solely ASCII whitespace, we - optimize for the common case by using a quick look-up table - _Py_ascii_whitespace (see below) with an inlined check. - - */ -#ifndef Py_LIMITED_API -#define Py_UNICODE_ISSPACE(ch) \ - ((ch) < 128U ? _Py_ascii_whitespace[(ch)] : _PyUnicode_IsWhitespace(ch)) - -#define Py_UNICODE_ISLOWER(ch) _PyUnicode_IsLowercase(ch) -#define Py_UNICODE_ISUPPER(ch) _PyUnicode_IsUppercase(ch) -#define Py_UNICODE_ISTITLE(ch) _PyUnicode_IsTitlecase(ch) -#define Py_UNICODE_ISLINEBREAK(ch) _PyUnicode_IsLinebreak(ch) - -#define Py_UNICODE_TOLOWER(ch) _PyUnicode_ToLowercase(ch) -#define Py_UNICODE_TOUPPER(ch) _PyUnicode_ToUppercase(ch) -#define Py_UNICODE_TOTITLE(ch) _PyUnicode_ToTitlecase(ch) - -#define Py_UNICODE_ISDECIMAL(ch) _PyUnicode_IsDecimalDigit(ch) -#define Py_UNICODE_ISDIGIT(ch) _PyUnicode_IsDigit(ch) -#define Py_UNICODE_ISNUMERIC(ch) _PyUnicode_IsNumeric(ch) -#define Py_UNICODE_ISPRINTABLE(ch) _PyUnicode_IsPrintable(ch) - -#define Py_UNICODE_TODECIMAL(ch) _PyUnicode_ToDecimalDigit(ch) -#define Py_UNICODE_TODIGIT(ch) _PyUnicode_ToDigit(ch) -#define Py_UNICODE_TONUMERIC(ch) _PyUnicode_ToNumeric(ch) - -#define Py_UNICODE_ISALPHA(ch) _PyUnicode_IsAlpha(ch) - -#define Py_UNICODE_ISALNUM(ch) \ - (Py_UNICODE_ISALPHA(ch) || \ - Py_UNICODE_ISDECIMAL(ch) || \ - Py_UNICODE_ISDIGIT(ch) || \ - Py_UNICODE_ISNUMERIC(ch)) - -#define Py_UNICODE_COPY(target, source, length) \ - memcpy((target), (source), (length)*sizeof(Py_UNICODE)) - -#define Py_UNICODE_FILL(target, value, length) \ - do {Py_ssize_t i_; Py_UNICODE *t_ = (target); Py_UNICODE v_ = (value);\ - for (i_ = 0; i_ < (length); i_++) t_[i_] = v_;\ - } while (0) - -/* macros to work with surrogates */ -#define Py_UNICODE_IS_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDFFF) -#define Py_UNICODE_IS_HIGH_SURROGATE(ch) (0xD800 <= (ch) && (ch) <= 0xDBFF) -#define Py_UNICODE_IS_LOW_SURROGATE(ch) (0xDC00 <= (ch) && (ch) <= 0xDFFF) -/* Join two surrogate characters and return a single Py_UCS4 value. */ -#define Py_UNICODE_JOIN_SURROGATES(high, low) \ - (((((Py_UCS4)(high) & 0x03FF) << 10) | \ - ((Py_UCS4)(low) & 0x03FF)) + 0x10000) -/* high surrogate = top 10 bits added to D800 */ -#define Py_UNICODE_HIGH_SURROGATE(ch) (0xD800 - (0x10000 >> 10) + ((ch) >> 10)) -/* low surrogate = bottom 10 bits added to DC00 */ -#define Py_UNICODE_LOW_SURROGATE(ch) (0xDC00 + ((ch) & 0x3FF)) - -/* Check if substring matches at given offset. The offset must be - valid, and the substring must not be empty. */ - -#define Py_UNICODE_MATCH(string, offset, substring) \ - ((*((string)->wstr + (offset)) == *((substring)->wstr)) && \ - ((*((string)->wstr + (offset) + (substring)->wstr_length-1) == *((substring)->wstr + (substring)->wstr_length-1))) && \ - !memcmp((string)->wstr + (offset), (substring)->wstr, (substring)->wstr_length*sizeof(Py_UNICODE))) - -#endif /* Py_LIMITED_API */ - #ifdef __cplusplus extern "C" { #endif -/* --- Unicode Type ------------------------------------------------------- */ - -#ifndef Py_LIMITED_API - -/* ASCII-only strings created through PyUnicode_New use the PyASCIIObject - structure. state.ascii and state.compact are set, and the data - immediately follow the structure. utf8_length and wstr_length can be found - in the length field; the utf8 pointer is equal to the data pointer. */ -typedef struct { - /* There are 4 forms of Unicode strings: - - - compact ascii: - - * structure = PyASCIIObject - * test: PyUnicode_IS_COMPACT_ASCII(op) - * kind = PyUnicode_1BYTE_KIND - * compact = 1 - * ascii = 1 - * ready = 1 - * (length is the length of the utf8 and wstr strings) - * (data starts just after the structure) - * (since ASCII is decoded from UTF-8, the utf8 string are the data) - - - compact: - - * structure = PyCompactUnicodeObject - * test: PyUnicode_IS_COMPACT(op) && !PyUnicode_IS_ASCII(op) - * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or - PyUnicode_4BYTE_KIND - * compact = 1 - * ready = 1 - * ascii = 0 - * utf8 is not shared with data - * utf8_length = 0 if utf8 is NULL - * wstr is shared with data and wstr_length=length - if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2 - or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_t)=4 - * wstr_length = 0 if wstr is NULL - * (data starts just after the structure) - - - legacy string, not ready: - - * structure = PyUnicodeObject - * test: kind == PyUnicode_WCHAR_KIND - * length = 0 (use wstr_length) - * hash = -1 - * kind = PyUnicode_WCHAR_KIND - * compact = 0 - * ascii = 0 - * ready = 0 - * interned = SSTATE_NOT_INTERNED - * wstr is not NULL - * data.any is NULL - * utf8 is NULL - * utf8_length = 0 - - - legacy string, ready: - - * structure = PyUnicodeObject structure - * test: !PyUnicode_IS_COMPACT(op) && kind != PyUnicode_WCHAR_KIND - * kind = PyUnicode_1BYTE_KIND, PyUnicode_2BYTE_KIND or - PyUnicode_4BYTE_KIND - * compact = 0 - * ready = 1 - * data.any is not NULL - * utf8 is shared and utf8_length = length with data.any if ascii = 1 - * utf8_length = 0 if utf8 is NULL - * wstr is shared with data.any and wstr_length = length - if kind=PyUnicode_2BYTE_KIND and sizeof(wchar_t)=2 - or if kind=PyUnicode_4BYTE_KIND and sizeof(wchar_4)=4 - * wstr_length = 0 if wstr is NULL - - Compact strings use only one memory block (structure + characters), - whereas legacy strings use one block for the structure and one block - for characters. - - Legacy strings are created by PyUnicode_FromUnicode() and - PyUnicode_FromStringAndSize(NULL, size) functions. They become ready - when PyUnicode_READY() is called. - - See also _PyUnicode_CheckConsistency(). - */ - PyObject_HEAD - Py_ssize_t length; /* Number of code points in the string */ - Py_hash_t hash; /* Hash value; -1 if not set */ - struct { - /* - SSTATE_NOT_INTERNED (0) - SSTATE_INTERNED_MORTAL (1) - SSTATE_INTERNED_IMMORTAL (2) - - If interned != SSTATE_NOT_INTERNED, the two references from the - dictionary to this object are *not* counted in ob_refcnt. - */ - unsigned int interned:2; - /* Character size: - - - PyUnicode_WCHAR_KIND (0): - - * character type = wchar_t (16 or 32 bits, depending on the - platform) - - - PyUnicode_1BYTE_KIND (1): - - * character type = Py_UCS1 (8 bits, unsigned) - * all characters are in the range U+0000-U+00FF (latin1) - * if ascii is set, all characters are in the range U+0000-U+007F - (ASCII), otherwise at least one character is in the range - U+0080-U+00FF - - - PyUnicode_2BYTE_KIND (2): - - * character type = Py_UCS2 (16 bits, unsigned) - * all characters are in the range U+0000-U+FFFF (BMP) - * at least one character is in the range U+0100-U+FFFF - - - PyUnicode_4BYTE_KIND (4): - - * character type = Py_UCS4 (32 bits, unsigned) - * all characters are in the range U+0000-U+10FFFF - * at least one character is in the range U+10000-U+10FFFF - */ - unsigned int kind:3; - /* Compact is with respect to the allocation scheme. Compact unicode - objects only require one memory block while non-compact objects use - one block for the PyUnicodeObject struct and another for its data - buffer. */ - unsigned int compact:1; - /* The string only contains characters in the range U+0000-U+007F (ASCII) - and the kind is PyUnicode_1BYTE_KIND. If ascii is set and compact is - set, use the PyASCIIObject structure. */ - unsigned int ascii:1; - /* The ready flag indicates whether the object layout is initialized - completely. This means that this is either a compact object, or - the data pointer is filled out. The bit is redundant, and helps - to minimize the test in PyUnicode_IS_READY(). */ - unsigned int ready:1; - /* Padding to ensure that PyUnicode_DATA() is always aligned to - 4 bytes (see issue #19537 on m68k). */ - unsigned int :24; - } state; - wchar_t *wstr; /* wchar_t representation (null-terminated) */ -} PyASCIIObject; - -/* Non-ASCII strings allocated through PyUnicode_New use the - PyCompactUnicodeObject structure. state.compact is set, and the data - immediately follow the structure. */ -typedef struct { - PyASCIIObject _base; - Py_ssize_t utf8_length; /* Number of bytes in utf8, excluding the - * terminating \0. */ - char *utf8; /* UTF-8 representation (null-terminated) */ - Py_ssize_t wstr_length; /* Number of code points in wstr, possible - * surrogates count as two code points. */ -} PyCompactUnicodeObject; - -/* Strings allocated through PyUnicode_FromUnicode(NULL, len) use the - PyUnicodeObject structure. The actual string data is initially in the wstr - block, and copied into the data block using _PyUnicode_Ready. */ -typedef struct { - PyCompactUnicodeObject _base; - union { - void *any; - Py_UCS1 *latin1; - Py_UCS2 *ucs2; - Py_UCS4 *ucs4; - } data; /* Canonical, smallest-form Unicode buffer */ -} PyUnicodeObject; -#endif PyAPI_DATA(PyTypeObject) PyUnicode_Type; PyAPI_DATA(PyTypeObject) PyUnicodeIter_Type; #define PyUnicode_Check(op) \ PyType_FastSubclass(Py_TYPE(op), Py_TPFLAGS_UNICODE_SUBCLASS) -#define PyUnicode_CheckExact(op) (Py_TYPE(op) == &PyUnicode_Type) - -/* Fast access macros */ -#ifndef Py_LIMITED_API - -#define PyUnicode_WSTR_LENGTH(op) \ - (PyUnicode_IS_COMPACT_ASCII(op) ? \ - ((PyASCIIObject*)op)->length : \ - ((PyCompactUnicodeObject*)op)->wstr_length) - -/* Returns the deprecated Py_UNICODE representation's size in code units - (this includes surrogate pairs as 2 units). - If the Py_UNICODE representation is not available, it will be computed - on request. Use PyUnicode_GET_LENGTH() for the length in code points. */ - -#define PyUnicode_GET_SIZE(op) \ - (assert(PyUnicode_Check(op)), \ - (((PyASCIIObject *)(op))->wstr) ? \ - PyUnicode_WSTR_LENGTH(op) : \ - ((void)PyUnicode_AsUnicode((PyObject *)(op)), \ - assert(((PyASCIIObject *)(op))->wstr), \ - PyUnicode_WSTR_LENGTH(op))) - /* Py_DEPRECATED(3.3) */ - -#define PyUnicode_GET_DATA_SIZE(op) \ - (PyUnicode_GET_SIZE(op) * Py_UNICODE_SIZE) - /* Py_DEPRECATED(3.3) */ - -/* Alias for PyUnicode_AsUnicode(). This will create a wchar_t/Py_UNICODE - representation on demand. Using this macro is very inefficient now, - try to port your code to use the new PyUnicode_*BYTE_DATA() macros or - use PyUnicode_WRITE() and PyUnicode_READ(). */ - -#define PyUnicode_AS_UNICODE(op) \ - (assert(PyUnicode_Check(op)), \ - (((PyASCIIObject *)(op))->wstr) ? (((PyASCIIObject *)(op))->wstr) : \ - PyUnicode_AsUnicode((PyObject *)(op))) - /* Py_DEPRECATED(3.3) */ - -#define PyUnicode_AS_DATA(op) \ - ((const char *)(PyUnicode_AS_UNICODE(op))) - /* Py_DEPRECATED(3.3) */ - - -/* --- Flexible String Representation Helper Macros (PEP 393) -------------- */ - -/* Values for PyASCIIObject.state: */ - -/* Interning state. */ -#define SSTATE_NOT_INTERNED 0 -#define SSTATE_INTERNED_MORTAL 1 -#define SSTATE_INTERNED_IMMORTAL 2 - -/* Return true if the string contains only ASCII characters, or 0 if not. The - string may be compact (PyUnicode_IS_COMPACT_ASCII) or not, but must be - ready. */ -#define PyUnicode_IS_ASCII(op) \ - (assert(PyUnicode_Check(op)), \ - assert(PyUnicode_IS_READY(op)), \ - ((PyASCIIObject*)op)->state.ascii) - -/* Return true if the string is compact or 0 if not. - No type checks or Ready calls are performed. */ -#define PyUnicode_IS_COMPACT(op) \ - (((PyASCIIObject*)(op))->state.compact) - -/* Return true if the string is a compact ASCII string (use PyASCIIObject - structure), or 0 if not. No type checks or Ready calls are performed. */ -#define PyUnicode_IS_COMPACT_ASCII(op) \ - (((PyASCIIObject*)op)->state.ascii && PyUnicode_IS_COMPACT(op)) - -enum PyUnicode_Kind { -/* String contains only wstr byte characters. This is only possible - when the string was created with a legacy API and _PyUnicode_Ready() - has not been called yet. */ - PyUnicode_WCHAR_KIND = 0, -/* Return values of the PyUnicode_KIND() macro: */ - PyUnicode_1BYTE_KIND = 1, - PyUnicode_2BYTE_KIND = 2, - PyUnicode_4BYTE_KIND = 4 -}; - -/* Return pointers to the canonical representation cast to unsigned char, - Py_UCS2, or Py_UCS4 for direct character access. - No checks are performed, use PyUnicode_KIND() before to ensure - these will work correctly. */ - -#define PyUnicode_1BYTE_DATA(op) ((Py_UCS1*)PyUnicode_DATA(op)) -#define PyUnicode_2BYTE_DATA(op) ((Py_UCS2*)PyUnicode_DATA(op)) -#define PyUnicode_4BYTE_DATA(op) ((Py_UCS4*)PyUnicode_DATA(op)) - -/* Return one of the PyUnicode_*_KIND values defined above. */ -#define PyUnicode_KIND(op) \ - (assert(PyUnicode_Check(op)), \ - assert(PyUnicode_IS_READY(op)), \ - ((PyASCIIObject *)(op))->state.kind) - -/* Return a void pointer to the raw unicode buffer. */ -#define _PyUnicode_COMPACT_DATA(op) \ - (PyUnicode_IS_ASCII(op) ? \ - ((void*)((PyASCIIObject*)(op) + 1)) : \ - ((void*)((PyCompactUnicodeObject*)(op) + 1))) - -#define _PyUnicode_NONCOMPACT_DATA(op) \ - (assert(((PyUnicodeObject*)(op))->data.any), \ - ((((PyUnicodeObject *)(op))->data.any))) - -#define PyUnicode_DATA(op) \ - (assert(PyUnicode_Check(op)), \ - PyUnicode_IS_COMPACT(op) ? _PyUnicode_COMPACT_DATA(op) : \ - _PyUnicode_NONCOMPACT_DATA(op)) - -/* In the access macros below, "kind" may be evaluated more than once. - All other macro parameters are evaluated exactly once, so it is safe - to put side effects into them (such as increasing the index). */ - -/* Write into the canonical representation, this macro does not do any sanity - checks and is intended for usage in loops. The caller should cache the - kind and data pointers obtained from other macro calls. - index is the index in the string (starts at 0) and value is the new - code point value which should be written to that location. */ -#define PyUnicode_WRITE(kind, data, index, value) \ - do { \ - switch ((kind)) { \ - case PyUnicode_1BYTE_KIND: { \ - ((Py_UCS1 *)(data))[(index)] = (Py_UCS1)(value); \ - break; \ - } \ - case PyUnicode_2BYTE_KIND: { \ - ((Py_UCS2 *)(data))[(index)] = (Py_UCS2)(value); \ - break; \ - } \ - default: { \ - assert((kind) == PyUnicode_4BYTE_KIND); \ - ((Py_UCS4 *)(data))[(index)] = (Py_UCS4)(value); \ - } \ - } \ - } while (0) - -/* Read a code point from the string's canonical representation. No checks - or ready calls are performed. */ -#define PyUnicode_READ(kind, data, index) \ - ((Py_UCS4) \ - ((kind) == PyUnicode_1BYTE_KIND ? \ - ((const Py_UCS1 *)(data))[(index)] : \ - ((kind) == PyUnicode_2BYTE_KIND ? \ - ((const Py_UCS2 *)(data))[(index)] : \ - ((const Py_UCS4 *)(data))[(index)] \ - ) \ - )) - -/* PyUnicode_READ_CHAR() is less efficient than PyUnicode_READ() because it - calls PyUnicode_KIND() and might call it twice. For single reads, use - PyUnicode_READ_CHAR, for multiple consecutive reads callers should - cache kind and use PyUnicode_READ instead. */ -#define PyUnicode_READ_CHAR(unicode, index) \ - (assert(PyUnicode_Check(unicode)), \ - assert(PyUnicode_IS_READY(unicode)), \ - (Py_UCS4) \ - (PyUnicode_KIND((unicode)) == PyUnicode_1BYTE_KIND ? \ - ((const Py_UCS1 *)(PyUnicode_DATA((unicode))))[(index)] : \ - (PyUnicode_KIND((unicode)) == PyUnicode_2BYTE_KIND ? \ - ((const Py_UCS2 *)(PyUnicode_DATA((unicode))))[(index)] : \ - ((const Py_UCS4 *)(PyUnicode_DATA((unicode))))[(index)] \ - ) \ - )) - -/* Returns the length of the unicode string. The caller has to make sure that - the string has it's canonical representation set before calling - this macro. Call PyUnicode_(FAST_)Ready to ensure that. */ -#define PyUnicode_GET_LENGTH(op) \ - (assert(PyUnicode_Check(op)), \ - assert(PyUnicode_IS_READY(op)), \ - ((PyASCIIObject *)(op))->length) - - -/* Fast check to determine whether an object is ready. Equivalent to - PyUnicode_IS_COMPACT(op) || ((PyUnicodeObject*)(op))->data.any) */ - -#define PyUnicode_IS_READY(op) (((PyASCIIObject*)op)->state.ready) - -/* PyUnicode_READY() does less work than _PyUnicode_Ready() in the best - case. If the canonical representation is not yet set, it will still call - _PyUnicode_Ready(). - Returns 0 on success and -1 on errors. */ -#define PyUnicode_READY(op) \ - (assert(PyUnicode_Check(op)), \ - (PyUnicode_IS_READY(op) ? \ - 0 : _PyUnicode_Ready((PyObject *)(op)))) - -/* Return a maximum character value which is suitable for creating another - string based on op. This is always an approximation but more efficient - than iterating over the string. */ -#define PyUnicode_MAX_CHAR_VALUE(op) \ - (assert(PyUnicode_IS_READY(op)), \ - (PyUnicode_IS_ASCII(op) ? \ - (0x7f) : \ - (PyUnicode_KIND(op) == PyUnicode_1BYTE_KIND ? \ - (0xffU) : \ - (PyUnicode_KIND(op) == PyUnicode_2BYTE_KIND ? \ - (0xffffU) : \ - (0x10ffffU))))) - -#endif +#define PyUnicode_CheckExact(op) Py_IS_TYPE(op, &PyUnicode_Type) /* --- Constants ---------------------------------------------------------- */ @@ -577,120 +126,6 @@ enum PyUnicode_Kind { /* === Public API ========================================================= */ -/* --- Plain Py_UNICODE --------------------------------------------------- */ - -/* With PEP 393, this is the recommended way to allocate a new unicode object. - This function will allocate the object and its buffer in a single memory - block. Objects created using this function are not resizable. */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) PyUnicode_New( - Py_ssize_t size, /* Number of code points in the new string */ - Py_UCS4 maxchar /* maximum code point value in the string */ - ); -#endif - -/* Initializes the canonical string representation from the deprecated - wstr/Py_UNICODE representation. This function is used to convert Unicode - objects which were created using the old API to the new flexible format - introduced with PEP 393. - - Don't call this function directly, use the public PyUnicode_READY() macro - instead. */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(int) _PyUnicode_Ready( - PyObject *unicode /* Unicode object */ - ); -#endif - -/* Get a copy of a Unicode string. */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) _PyUnicode_Copy( - PyObject *unicode - ); -#endif - -/* Copy character from one unicode object into another, this function performs - character conversion when necessary and falls back to memcpy() if possible. - - Fail if to is too small (smaller than *how_many* or smaller than - len(from)-from_start), or if kind(from[from_start:from_start+how_many]) > - kind(to), or if *to* has more than 1 reference. - - Return the number of written character, or return -1 and raise an exception - on error. - - Pseudo-code: - - how_many = min(how_many, len(from) - from_start) - to[to_start:to_start+how_many] = from[from_start:from_start+how_many] - return how_many - - Note: The function doesn't write a terminating null character. - */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(Py_ssize_t) PyUnicode_CopyCharacters( - PyObject *to, - Py_ssize_t to_start, - PyObject *from, - Py_ssize_t from_start, - Py_ssize_t how_many - ); - -/* Unsafe version of PyUnicode_CopyCharacters(): don't check arguments and so - may crash if parameters are invalid (e.g. if the output string - is too short). */ -PyAPI_FUNC(void) _PyUnicode_FastCopyCharacters( - PyObject *to, - Py_ssize_t to_start, - PyObject *from, - Py_ssize_t from_start, - Py_ssize_t how_many - ); -#endif - -#ifndef Py_LIMITED_API -/* Fill a string with a character: write fill_char into - unicode[start:start+length]. - - Fail if fill_char is bigger than the string maximum character, or if the - string has more than 1 reference. - - Return the number of written character, or return -1 and raise an exception - on error. */ -PyAPI_FUNC(Py_ssize_t) PyUnicode_Fill( - PyObject *unicode, - Py_ssize_t start, - Py_ssize_t length, - Py_UCS4 fill_char - ); - -/* Unsafe version of PyUnicode_Fill(): don't check arguments and so may crash - if parameters are invalid (e.g. if length is longer than the string). */ -PyAPI_FUNC(void) _PyUnicode_FastFill( - PyObject *unicode, - Py_ssize_t start, - Py_ssize_t length, - Py_UCS4 fill_char - ); -#endif - -/* Create a Unicode Object from the Py_UNICODE buffer u of the given - size. - - u may be NULL which causes the contents to be undefined. It is the - user's responsibility to fill in the needed data afterwards. Note - that modifying the Unicode object contents after construction is - only allowed if u was set to NULL. - - The buffer is copied into the new object. */ - -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) PyUnicode_FromUnicode( - const Py_UNICODE *u, /* Unicode buffer */ - Py_ssize_t size /* size of buffer */ - ) /* Py_DEPRECATED(3.3) */; -#endif - /* Similar to PyUnicode_FromUnicode(), but u points to UTF-8 encoded bytes */ PyAPI_FUNC(PyObject*) PyUnicode_FromStringAndSize( const char *u, /* UTF-8 encoded string */ @@ -703,21 +138,6 @@ PyAPI_FUNC(PyObject*) PyUnicode_FromString( const char *u /* UTF-8 encoded string */ ); -#ifndef Py_LIMITED_API -/* Create a new string from a buffer of Py_UCS1, Py_UCS2 or Py_UCS4 characters. - Scan the string to find the maximum character. */ -PyAPI_FUNC(PyObject*) PyUnicode_FromKindAndData( - int kind, - const void *buffer, - Py_ssize_t size); - -/* Create a new string from a buffer of ASCII characters. - WARNING: Don't check if the string contains any non-ASCII character. */ -PyAPI_FUNC(PyObject*) _PyUnicode_FromASCII( - const char *buffer, - Py_ssize_t size); -#endif - #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject*) PyUnicode_Substring( PyObject *str, @@ -725,15 +145,6 @@ PyAPI_FUNC(PyObject*) PyUnicode_Substring( Py_ssize_t end); #endif -#ifndef Py_LIMITED_API -/* Compute the maximum character of the substring unicode[start:end]. - Return 127 for an empty string. */ -PyAPI_FUNC(Py_UCS4) _PyUnicode_FindMaxChar ( - PyObject *unicode, - Py_ssize_t start, - Py_ssize_t end); -#endif - #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 /* Copy the string into a UCS4 buffer including the null character if copy_null is set. Return NULL and raise an exception on error. Raise a SystemError if @@ -752,33 +163,6 @@ PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4( PyAPI_FUNC(Py_UCS4*) PyUnicode_AsUCS4Copy(PyObject *unicode); #endif -#ifndef Py_LIMITED_API -/* Return a read-only pointer to the Unicode object's internal - Py_UNICODE buffer. - If the wchar_t/Py_UNICODE representation is not yet available, this - function will calculate it. */ - -PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicode( - PyObject *unicode /* Unicode object */ - ) /* Py_DEPRECATED(3.3) */; - -/* Similar to PyUnicode_AsUnicode(), but raises a ValueError if the string - contains null characters. */ -PyAPI_FUNC(const Py_UNICODE *) _PyUnicode_AsUnicode( - PyObject *unicode /* Unicode object */ - ); - -/* Return a read-only pointer to the Unicode object's internal - Py_UNICODE buffer and save the length at size. - If the wchar_t/Py_UNICODE representation is not yet available, this - function will calculate it. */ - -PyAPI_FUNC(Py_UNICODE *) PyUnicode_AsUnicodeAndSize( - PyObject *unicode, /* Unicode object */ - Py_ssize_t *size /* location where to save the length */ - ) /* Py_DEPRECATED(3.3) */; -#endif - #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 /* Get the length of the Unicode object. */ @@ -790,9 +174,9 @@ PyAPI_FUNC(Py_ssize_t) PyUnicode_GetLength( /* Get the number of Py_UNICODE units in the string representation. */ -PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize( +Py_DEPRECATED(3.3) PyAPI_FUNC(Py_ssize_t) PyUnicode_GetSize( PyObject *unicode /* Unicode object */ - ) Py_DEPRECATED(3.3); + ); #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 /* Read a character from the string. */ @@ -814,11 +198,6 @@ PyAPI_FUNC(int) PyUnicode_WriteChar( ); #endif -#ifndef Py_LIMITED_API -/* Get the maximum ordinal for a Unicode character. */ -PyAPI_FUNC(Py_UNICODE) PyUnicode_GetMax(void) Py_DEPRECATED(3.3); -#endif - /* Resize a Unicode object. The length is the number of characters, except if the kind of the string is PyUnicode_WCHAR_KIND: in this case, the length is the number of Py_UNICODE characters. @@ -881,141 +260,14 @@ PyAPI_FUNC(PyObject *) PyUnicode_FromFormat( ... ); -#ifndef Py_LIMITED_API -typedef struct { - PyObject *buffer; - void *data; - enum PyUnicode_Kind kind; - Py_UCS4 maxchar; - Py_ssize_t size; - Py_ssize_t pos; - - /* minimum number of allocated characters (default: 0) */ - Py_ssize_t min_length; - - /* minimum character (default: 127, ASCII) */ - Py_UCS4 min_char; - - /* If non-zero, overallocate the buffer (default: 0). */ - unsigned char overallocate; - - /* If readonly is 1, buffer is a shared string (cannot be modified) - and size is set to 0. */ - unsigned char readonly; -} _PyUnicodeWriter ; - -/* Initialize a Unicode writer. - * - * By default, the minimum buffer size is 0 character and overallocation is - * disabled. Set min_length, min_char and overallocate attributes to control - * the allocation of the buffer. */ -PyAPI_FUNC(void) -_PyUnicodeWriter_Init(_PyUnicodeWriter *writer); - -/* Prepare the buffer to write 'length' characters - with the specified maximum character. - - Return 0 on success, raise an exception and return -1 on error. */ -#define _PyUnicodeWriter_Prepare(WRITER, LENGTH, MAXCHAR) \ - (((MAXCHAR) <= (WRITER)->maxchar \ - && (LENGTH) <= (WRITER)->size - (WRITER)->pos) \ - ? 0 \ - : (((LENGTH) == 0) \ - ? 0 \ - : _PyUnicodeWriter_PrepareInternal((WRITER), (LENGTH), (MAXCHAR)))) - -/* Don't call this function directly, use the _PyUnicodeWriter_Prepare() macro - instead. */ -PyAPI_FUNC(int) -_PyUnicodeWriter_PrepareInternal(_PyUnicodeWriter *writer, - Py_ssize_t length, Py_UCS4 maxchar); - -/* Prepare the buffer to have at least the kind KIND. - For example, kind=PyUnicode_2BYTE_KIND ensures that the writer will - support characters in range U+000-U+FFFF. - - Return 0 on success, raise an exception and return -1 on error. */ -#define _PyUnicodeWriter_PrepareKind(WRITER, KIND) \ - (assert((KIND) != PyUnicode_WCHAR_KIND), \ - (KIND) <= (WRITER)->kind \ - ? 0 \ - : _PyUnicodeWriter_PrepareKindInternal((WRITER), (KIND))) - -/* Don't call this function directly, use the _PyUnicodeWriter_PrepareKind() - macro instead. */ -PyAPI_FUNC(int) -_PyUnicodeWriter_PrepareKindInternal(_PyUnicodeWriter *writer, - enum PyUnicode_Kind kind); - -/* Append a Unicode character. - Return 0 on success, raise an exception and return -1 on error. */ -PyAPI_FUNC(int) -_PyUnicodeWriter_WriteChar(_PyUnicodeWriter *writer, - Py_UCS4 ch - ); - -/* Append a Unicode string. - Return 0 on success, raise an exception and return -1 on error. */ -PyAPI_FUNC(int) -_PyUnicodeWriter_WriteStr(_PyUnicodeWriter *writer, - PyObject *str /* Unicode string */ - ); - -/* Append a substring of a Unicode string. - Return 0 on success, raise an exception and return -1 on error. */ -PyAPI_FUNC(int) -_PyUnicodeWriter_WriteSubstring(_PyUnicodeWriter *writer, - PyObject *str, /* Unicode string */ - Py_ssize_t start, - Py_ssize_t end - ); - -/* Append an ASCII-encoded byte string. - Return 0 on success, raise an exception and return -1 on error. */ -PyAPI_FUNC(int) -_PyUnicodeWriter_WriteASCIIString(_PyUnicodeWriter *writer, - const char *str, /* ASCII-encoded byte string */ - Py_ssize_t len /* number of bytes, or -1 if unknown */ - ); - -/* Append a latin1-encoded byte string. - Return 0 on success, raise an exception and return -1 on error. */ -PyAPI_FUNC(int) -_PyUnicodeWriter_WriteLatin1String(_PyUnicodeWriter *writer, - const char *str, /* latin1-encoded byte string */ - Py_ssize_t len /* length in bytes */ - ); - -/* Get the value of the writer as a Unicode string. Clear the - buffer of the writer. Raise an exception and return NULL - on error. */ -PyAPI_FUNC(PyObject *) -_PyUnicodeWriter_Finish(_PyUnicodeWriter *writer); - -/* Deallocate memory of a writer (clear its internal buffer). */ -PyAPI_FUNC(void) -_PyUnicodeWriter_Dealloc(_PyUnicodeWriter *writer); -#endif - -#ifndef Py_LIMITED_API -/* Format the object based on the format_spec, as defined in PEP 3101 - (Advanced String Formatting). */ -PyAPI_FUNC(int) _PyUnicode_FormatAdvancedWriter( - _PyUnicodeWriter *writer, - PyObject *obj, - PyObject *format_spec, - Py_ssize_t start, - Py_ssize_t end); -#endif - PyAPI_FUNC(void) PyUnicode_InternInPlace(PyObject **); -PyAPI_FUNC(void) PyUnicode_InternImmortal(PyObject **); PyAPI_FUNC(PyObject *) PyUnicode_InternFromString( const char *u /* UTF-8 encoded string */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void) _Py_ReleaseInternedUnicodeStrings(void); -#endif + +// PyUnicode_InternImmortal() is deprecated since Python 3.10 +// and will be removed in Python 3.12. Use PyUnicode_InternInPlace() instead. +Py_DEPRECATED(3.10) PyAPI_FUNC(void) PyUnicode_InternImmortal(PyObject **); /* Use only if you know it's a string */ #define PyUnicode_CHECK_INTERNED(op) \ @@ -1066,10 +318,6 @@ PyAPI_FUNC(wchar_t*) PyUnicode_AsWideCharString( Py_ssize_t *size /* number of characters of the result */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(void*) _PyUnicode_AsKind(PyObject *s, unsigned int kind); -#endif - #endif /* --- Unicode ordinals --------------------------------------------------- */ @@ -1083,17 +331,6 @@ PyAPI_FUNC(void*) _PyUnicode_AsKind(PyObject *s, unsigned int kind); PyAPI_FUNC(PyObject*) PyUnicode_FromOrdinal(int ordinal); -/* --- Free-list management ----------------------------------------------- */ - -/* Clear the free list used by the Unicode implementation. - - This can be used to release memory used for objects on the free - list back to the Python memory allocator. - -*/ - -PyAPI_FUNC(int) PyUnicode_ClearFreeList(void); - /* === Builtin Codecs ===================================================== Many of these APIs take two arguments encoding and errors. These @@ -1114,60 +351,7 @@ PyAPI_FUNC(int) PyUnicode_ClearFreeList(void); /* --- Manage the default encoding ---------------------------------------- */ -/* Returns a pointer to the default encoding (UTF-8) of the - Unicode object unicode and the size of the encoded representation - in bytes stored in *size. - - In case of an error, no *size is set. - - This function caches the UTF-8 encoded string in the unicodeobject - and subsequent calls will return the same string. The memory is released - when the unicodeobject is deallocated. - - _PyUnicode_AsStringAndSize is a #define for PyUnicode_AsUTF8AndSize to - support the previous internal function with the same behaviour. - - *** This API is for interpreter INTERNAL USE ONLY and will likely - *** be removed or changed in the future. - - *** If you need to access the Unicode object as UTF-8 bytes string, - *** please use PyUnicode_AsUTF8String() instead. -*/ - -#ifndef Py_LIMITED_API -PyAPI_FUNC(const char *) PyUnicode_AsUTF8AndSize( - PyObject *unicode, - Py_ssize_t *size); -#define _PyUnicode_AsStringAndSize PyUnicode_AsUTF8AndSize -#endif - -/* Returns a pointer to the default encoding (UTF-8) of the - Unicode object unicode. - - Like PyUnicode_AsUTF8AndSize(), this also caches the UTF-8 representation - in the unicodeobject. - - _PyUnicode_AsString is a #define for PyUnicode_AsUTF8 to - support the previous internal function with the same behaviour. - - Use of this API is DEPRECATED since no size information can be - extracted from the returned data. - - *** This API is for interpreter INTERNAL USE ONLY and will likely - *** be removed or changed for Python 3.1. - - *** If you need to access the Unicode object as UTF-8 bytes string, - *** please use PyUnicode_AsUTF8String() instead. - -*/ - -#ifndef Py_LIMITED_API -PyAPI_FUNC(const char *) PyUnicode_AsUTF8(PyObject *unicode); -#define _PyUnicode_AsString PyUnicode_AsUTF8 -#endif - /* Returns "utf-8". */ - PyAPI_FUNC(const char*) PyUnicode_GetDefaultEncoding(void); /* --- Generic Codecs ----------------------------------------------------- */ @@ -1189,11 +373,11 @@ PyAPI_FUNC(PyObject*) PyUnicode_Decode( Use PyCodec_Decode() to decode with rot13 and non-standard codecs that decode from str. */ -PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedObject( +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedObject( PyObject *unicode, /* Unicode object */ const char *encoding, /* encoding */ const char *errors /* error handling */ - ) Py_DEPRECATED(3.6); + ); /* Decode a Unicode object unicode and return the result as Unicode object. @@ -1202,23 +386,11 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedObject( Use PyCodec_Decode() to decode with rot13 and non-standard codecs that decode from str to str. */ -PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedUnicode( +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsDecodedUnicode( PyObject *unicode, /* Unicode object */ const char *encoding, /* encoding */ const char *errors /* error handling */ - ) Py_DEPRECATED(3.6); - -/* Encodes a Py_UNICODE buffer of the given size and returns a - Python string object. */ - -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) PyUnicode_Encode( - const Py_UNICODE *s, /* Unicode char buffer */ - Py_ssize_t size, /* number of Py_UNICODE chars to encode */ - const char *encoding, /* encoding */ - const char *errors /* error handling */ - ) Py_DEPRECATED(3.3); -#endif + ); /* Encodes a Unicode object and returns the result as Python object. @@ -1228,11 +400,11 @@ PyAPI_FUNC(PyObject*) PyUnicode_Encode( Use PyCodec_Encode() for encoding with rot13 and non-standard codecs that encode form str to non-bytes. */ -PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedObject( +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedObject( PyObject *unicode, /* Unicode object */ const char *encoding, /* encoding */ const char *errors /* error handling */ - ) Py_DEPRECATED(3.6); + ); /* Encodes a Unicode object and returns the result as Python string object. */ @@ -1250,11 +422,11 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedString( Use PyCodec_Encode() to encode with rot13 and non-standard codecs that encode from str to str. */ -PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedUnicode( +Py_DEPRECATED(3.6) PyAPI_FUNC(PyObject*) PyUnicode_AsEncodedUnicode( PyObject *unicode, /* Unicode object */ const char *encoding, /* encoding */ const char *errors /* error handling */ - ) Py_DEPRECATED(3.6); + ); /* Build an encoding map. */ @@ -1277,22 +449,6 @@ PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF7Stateful( Py_ssize_t *consumed /* bytes consumed */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF7( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length, /* number of Py_UNICODE chars to encode */ - int base64SetO, /* Encode RFC2152 Set O characters in base64 */ - int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */ - const char *errors /* error handling */ - ) Py_DEPRECATED(3.3); -PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF7( - PyObject *unicode, /* Unicode object */ - int base64SetO, /* Encode RFC2152 Set O characters in base64 */ - int base64WhiteSpace, /* Encode whitespace (sp, ht, nl, cr) in base64 */ - const char *errors /* error handling */ - ); -#endif - /* --- UTF-8 Codecs ------------------------------------------------------- */ PyAPI_FUNC(PyObject*) PyUnicode_DecodeUTF8( @@ -1312,16 +468,21 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUTF8String( PyObject *unicode /* Unicode object */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) _PyUnicode_AsUTF8String( - PyObject *unicode, - const char *errors); +/* Returns a pointer to the default encoding (UTF-8) of the + Unicode object unicode and the size of the encoded representation + in bytes stored in *size. -PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF8( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length, /* number of Py_UNICODE chars to encode */ - const char *errors /* error handling */ - ) Py_DEPRECATED(3.3); + In case of an error, no *size is set. + + This function caches the UTF-8 encoded string in the unicodeobject + and subsequent calls will return the same string. The memory is released + when the unicodeobject is deallocated. +*/ + +#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030A0000 +PyAPI_FUNC(const char *) PyUnicode_AsUTF8AndSize( + PyObject *unicode, + Py_ssize_t *size); #endif /* --- UTF-32 Codecs ------------------------------------------------------ */ @@ -1391,20 +552,6 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUTF32String( */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF32( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length, /* number of Py_UNICODE chars to encode */ - const char *errors, /* error handling */ - int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */ - ) Py_DEPRECATED(3.3); -PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF32( - PyObject *object, /* Unicode object */ - const char *errors, /* error handling */ - int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */ - ); -#endif - /* --- UTF-16 Codecs ------------------------------------------------------ */ /* Decodes length bytes from a UTF-16 encoded buffer string and returns @@ -1456,40 +603,6 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsUTF16String( PyObject *unicode /* Unicode object */ ); -/* Returns a Python string object holding the UTF-16 encoded value of - the Unicode data. - - If byteorder is not 0, output is written according to the following - byte order: - - byteorder == -1: little endian - byteorder == 0: native byte order (writes a BOM mark) - byteorder == 1: big endian - - If byteorder is 0, the output string will always start with the - Unicode BOM mark (U+FEFF). In the other two modes, no BOM mark is - prepended. - - Note that Py_UNICODE data is being interpreted as UTF-16 reduced to - UCS-2. This trick makes it possible to add full UTF-16 capabilities - at a later point without compromising the APIs. - -*/ - -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) PyUnicode_EncodeUTF16( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length, /* number of Py_UNICODE chars to encode */ - const char *errors, /* error handling */ - int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */ - ) Py_DEPRECATED(3.3); -PyAPI_FUNC(PyObject*) _PyUnicode_EncodeUTF16( - PyObject* unicode, /* Unicode object */ - const char *errors, /* error handling */ - int byteorder /* byteorder to use 0=BOM+native;-1=LE,1=BE */ - ); -#endif - /* --- Unicode-Escape Codecs ---------------------------------------------- */ PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape( @@ -1498,30 +611,10 @@ PyAPI_FUNC(PyObject*) PyUnicode_DecodeUnicodeEscape( const char *errors /* error handling */ ); -#ifndef Py_LIMITED_API -/* Helper for PyUnicode_DecodeUnicodeEscape that detects invalid escape - chars. */ -PyAPI_FUNC(PyObject*) _PyUnicode_DecodeUnicodeEscape( - const char *string, /* Unicode-Escape encoded string */ - Py_ssize_t length, /* size of string */ - const char *errors, /* error handling */ - const char **first_invalid_escape /* on return, points to first - invalid escaped char in - string. */ -); -#endif - PyAPI_FUNC(PyObject*) PyUnicode_AsUnicodeEscapeString( PyObject *unicode /* Unicode object */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) PyUnicode_EncodeUnicodeEscape( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length /* Number of Py_UNICODE chars to encode */ - ) Py_DEPRECATED(3.3); -#endif - /* --- Raw-Unicode-Escape Codecs ------------------------------------------ */ PyAPI_FUNC(PyObject*) PyUnicode_DecodeRawUnicodeEscape( @@ -1534,30 +627,9 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsRawUnicodeEscapeString( PyObject *unicode /* Unicode object */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) PyUnicode_EncodeRawUnicodeEscape( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length /* Number of Py_UNICODE chars to encode */ - ) Py_DEPRECATED(3.3); -#endif - -/* --- Unicode Internal Codec --------------------------------------------- - - Only for internal use in _codecsmodule.c */ - -#ifndef Py_LIMITED_API -PyObject *_PyUnicode_DecodeUnicodeInternal( - const char *string, - Py_ssize_t length, - const char *errors - ); -#endif - /* --- Latin-1 Codecs ----------------------------------------------------- - Note: Latin-1 corresponds to the first 256 Unicode ordinals. - -*/ + Note: Latin-1 corresponds to the first 256 Unicode ordinals. */ PyAPI_FUNC(PyObject*) PyUnicode_DecodeLatin1( const char *string, /* Latin-1 encoded string */ @@ -1569,18 +641,6 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsLatin1String( PyObject *unicode /* Unicode object */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) _PyUnicode_AsLatin1String( - PyObject* unicode, - const char* errors); - -PyAPI_FUNC(PyObject*) PyUnicode_EncodeLatin1( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ - const char *errors /* error handling */ - ) Py_DEPRECATED(3.3); -#endif - /* --- ASCII Codecs ------------------------------------------------------- Only 7-bit ASCII data is excepted. All other codes generate errors. @@ -1597,18 +657,6 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsASCIIString( PyObject *unicode /* Unicode object */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) _PyUnicode_AsASCIIString( - PyObject* unicode, - const char* errors); - -PyAPI_FUNC(PyObject*) PyUnicode_EncodeASCII( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ - const char *errors /* error handling */ - ) Py_DEPRECATED(3.3); -#endif - /* --- Character Map Codecs ----------------------------------------------- This codec uses mappings to encode and decode characters. @@ -1638,46 +686,9 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsCharmapString( PyObject *mapping /* encoding mapping */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) PyUnicode_EncodeCharmap( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ - PyObject *mapping, /* encoding mapping */ - const char *errors /* error handling */ - ) Py_DEPRECATED(3.3); -PyAPI_FUNC(PyObject*) _PyUnicode_EncodeCharmap( - PyObject *unicode, /* Unicode object */ - PyObject *mapping, /* encoding mapping */ - const char *errors /* error handling */ - ); -#endif - -/* Translate a Py_UNICODE buffer of the given length by applying a - character mapping table to it and return the resulting Unicode - object. - - The mapping table must map Unicode ordinal integers to Unicode strings, - Unicode ordinal integers or None (causing deletion of the character). - - Mapping tables may be dictionaries or sequences. Unmapped character - ordinals (ones which cause a LookupError) are left untouched and - are copied as-is. - -*/ - -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) PyUnicode_TranslateCharmap( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ - PyObject *table, /* Translate table */ - const char *errors /* error handling */ - ) Py_DEPRECATED(3.3); -#endif - -#ifdef MS_WINDOWS - /* --- MBCS codecs for Windows -------------------------------------------- */ +#ifdef MS_WINDOWS PyAPI_FUNC(PyObject*) PyUnicode_DecodeMBCS( const char *string, /* MBCS encoded string */ Py_ssize_t length, /* size of string */ @@ -1705,14 +716,6 @@ PyAPI_FUNC(PyObject*) PyUnicode_AsMBCSString( PyObject *unicode /* Unicode object */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject*) PyUnicode_EncodeMBCS( - const Py_UNICODE *data, /* Unicode char buffer */ - Py_ssize_t length, /* number of Py_UNICODE chars to encode */ - const char *errors /* error handling */ - ) Py_DEPRECATED(3.3); -#endif - #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 PyAPI_FUNC(PyObject*) PyUnicode_EncodeCodePage( int code_page, /* code page number */ @@ -1723,61 +726,6 @@ PyAPI_FUNC(PyObject*) PyUnicode_EncodeCodePage( #endif /* MS_WINDOWS */ -#ifndef Py_LIMITED_API -/* --- Decimal Encoder ---------------------------------------------------- */ - -/* Takes a Unicode string holding a decimal value and writes it into - an output buffer using standard ASCII digit codes. - - The output buffer has to provide at least length+1 bytes of storage - area. The output string is 0-terminated. - - The encoder converts whitespace to ' ', decimal characters to their - corresponding ASCII digit and all other Latin-1 characters except - \0 as-is. Characters outside this range (Unicode ordinals 1-256) - are treated as errors. This includes embedded NULL bytes. - - Error handling is defined by the errors argument: - - NULL or "strict": raise a ValueError - "ignore": ignore the wrong characters (these are not copied to the - output buffer) - "replace": replaces illegal characters with '?' - - Returns 0 on success, -1 on failure. - -*/ - -PyAPI_FUNC(int) PyUnicode_EncodeDecimal( - Py_UNICODE *s, /* Unicode buffer */ - Py_ssize_t length, /* Number of Py_UNICODE chars to encode */ - char *output, /* Output buffer; must have size >= length */ - const char *errors /* error handling */ - ) /* Py_DEPRECATED(3.3) */; - -/* Transforms code points that have decimal digit property to the - corresponding ASCII digit code points. - - Returns a new Unicode string on success, NULL on failure. -*/ - -PyAPI_FUNC(PyObject*) PyUnicode_TransformDecimalToASCII( - Py_UNICODE *s, /* Unicode buffer */ - Py_ssize_t length /* Number of Py_UNICODE chars to transform */ - ) /* Py_DEPRECATED(3.3) */; - -/* Coverts a Unicode object holding a decimal value to an ASCII string - for using in int, float and complex parsers. - Transforms code points that have decimal digit property to the - corresponding ASCII digit code points. Transforms spaces to ASCII. - Transforms code points starting from the first non-ASCII code point that - is neither a decimal digit nor a space to the end into '?'. */ - -PyAPI_FUNC(PyObject*) _PyUnicode_TransformDecimalAndSpaceToASCII( - PyObject *unicode /* Unicode object */ - ); -#endif - /* --- Locale encoding --------------------------------------------------- */ #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000 @@ -1976,14 +924,6 @@ PyAPI_FUNC(PyObject*) PyUnicode_Join( PyObject *seq /* Sequence object */ ); -#ifndef Py_LIMITED_API -PyAPI_FUNC(PyObject *) _PyUnicode_JoinArray( - PyObject *separator, - PyObject *const *items, - Py_ssize_t seqlen - ); -#endif /* Py_LIMITED_API */ - /* Return 1 if substr matches str[start:end] at the given tail end, 0 otherwise. */ @@ -2047,17 +987,6 @@ PyAPI_FUNC(int) PyUnicode_Compare( PyObject *right /* Right string */ ); -#ifndef Py_LIMITED_API -/* Test whether a unicode is equal to ASCII identifier. Return 1 if true, - 0 otherwise. The right argument must be ASCII identifier. - Any error occurs inside will be cleared before return. */ - -PyAPI_FUNC(int) _PyUnicode_EqualToASCIIId( - PyObject *left, /* Left string */ - _Py_Identifier *right /* Right identifier */ - ); -#endif - /* Compare a Unicode object with C string and return -1, 0, 1 for less than, equal, and greater than, respectively. It is best to pass only ASCII-encoded strings, but the function interprets the input string as @@ -2069,17 +998,6 @@ PyAPI_FUNC(int) PyUnicode_CompareWithASCIIString( const char *right /* ASCII-encoded string */ ); -#ifndef Py_LIMITED_API -/* Test whether a unicode is equal to ASCII string. Return 1 if true, - 0 otherwise. The right argument must be ASCII-encoded string. - Any error occurs inside will be cleared before return. */ - -PyAPI_FUNC(int) _PyUnicode_EqualToASCIIString( - PyObject *left, - const char *right /* ASCII-encoded string */ - ); -#endif - /* Rich compare two strings and return one of the following: - NULL in case an exception was raised @@ -2121,213 +1039,14 @@ PyAPI_FUNC(int) PyUnicode_Contains( PyAPI_FUNC(int) PyUnicode_IsIdentifier(PyObject *s); -#ifndef Py_LIMITED_API -/* Externally visible for str.strip(unicode) */ -PyAPI_FUNC(PyObject *) _PyUnicode_XStrip( - PyObject *self, - int striptype, - PyObject *sepobj - ); -#endif - -/* Using explicit passed-in values, insert the thousands grouping - into the string pointed to by buffer. For the argument descriptions, - see Objects/stringlib/localeutil.h */ -#ifndef Py_LIMITED_API -PyAPI_FUNC(Py_ssize_t) _PyUnicode_InsertThousandsGrouping( - _PyUnicodeWriter *writer, - Py_ssize_t n_buffer, - PyObject *digits, - Py_ssize_t d_pos, - Py_ssize_t n_digits, - Py_ssize_t min_width, - const char *grouping, - PyObject *thousands_sep, - Py_UCS4 *maxchar); -#endif /* === Characters Type APIs =============================================== */ -/* Helper array used by Py_UNICODE_ISSPACE(). */ - #ifndef Py_LIMITED_API -PyAPI_DATA(const unsigned char) _Py_ascii_whitespace[]; - -/* These should not be used directly. Use the Py_UNICODE_IS* and - Py_UNICODE_TO* macros instead. - - These APIs are implemented in Objects/unicodectype.c. - -*/ - -PyAPI_FUNC(int) _PyUnicode_IsLowercase( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsUppercase( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsTitlecase( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsXidStart( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsXidContinue( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsWhitespace( - const Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsLinebreak( - const Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(Py_UCS4) _PyUnicode_ToLowercase( - Py_UCS4 ch /* Unicode character */ - ) /* Py_DEPRECATED(3.3) */; - -PyAPI_FUNC(Py_UCS4) _PyUnicode_ToUppercase( - Py_UCS4 ch /* Unicode character */ - ) /* Py_DEPRECATED(3.3) */; - -PyAPI_FUNC(Py_UCS4) _PyUnicode_ToTitlecase( - Py_UCS4 ch /* Unicode character */ - ) Py_DEPRECATED(3.3); - -PyAPI_FUNC(int) _PyUnicode_ToLowerFull( - Py_UCS4 ch, /* Unicode character */ - Py_UCS4 *res - ); - -PyAPI_FUNC(int) _PyUnicode_ToTitleFull( - Py_UCS4 ch, /* Unicode character */ - Py_UCS4 *res - ); - -PyAPI_FUNC(int) _PyUnicode_ToUpperFull( - Py_UCS4 ch, /* Unicode character */ - Py_UCS4 *res - ); - -PyAPI_FUNC(int) _PyUnicode_ToFoldedFull( - Py_UCS4 ch, /* Unicode character */ - Py_UCS4 *res - ); - -PyAPI_FUNC(int) _PyUnicode_IsCaseIgnorable( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsCased( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_ToDecimalDigit( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_ToDigit( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(double) _PyUnicode_ToNumeric( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsDecimalDigit( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsDigit( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsNumeric( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsPrintable( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(int) _PyUnicode_IsAlpha( - Py_UCS4 ch /* Unicode character */ - ); - -PyAPI_FUNC(size_t) Py_UNICODE_strlen( - const Py_UNICODE *u - ) Py_DEPRECATED(3.3); - -PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strcpy( - Py_UNICODE *s1, - const Py_UNICODE *s2) Py_DEPRECATED(3.3); - -PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strcat( - Py_UNICODE *s1, const Py_UNICODE *s2) Py_DEPRECATED(3.3); - -PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strncpy( - Py_UNICODE *s1, - const Py_UNICODE *s2, - size_t n) Py_DEPRECATED(3.3); - -PyAPI_FUNC(int) Py_UNICODE_strcmp( - const Py_UNICODE *s1, - const Py_UNICODE *s2 - ) Py_DEPRECATED(3.3); - -PyAPI_FUNC(int) Py_UNICODE_strncmp( - const Py_UNICODE *s1, - const Py_UNICODE *s2, - size_t n - ) Py_DEPRECATED(3.3); - -PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strchr( - const Py_UNICODE *s, - Py_UNICODE c - ) Py_DEPRECATED(3.3); - -PyAPI_FUNC(Py_UNICODE*) Py_UNICODE_strrchr( - const Py_UNICODE *s, - Py_UNICODE c - ) Py_DEPRECATED(3.3); - -PyAPI_FUNC(PyObject*) _PyUnicode_FormatLong(PyObject *, int, int, int); - -/* Create a copy of a unicode string ending with a nul character. Return NULL - and raise a MemoryError exception on memory allocation failure, otherwise - return a new allocated buffer (use PyMem_Free() to free the buffer). */ - -PyAPI_FUNC(Py_UNICODE*) PyUnicode_AsUnicodeCopy( - PyObject *unicode - ) Py_DEPRECATED(3.3); -#endif /* Py_LIMITED_API */ - -#if defined(Py_DEBUG) && !defined(Py_LIMITED_API) -PyAPI_FUNC(int) _PyUnicode_CheckConsistency( - PyObject *op, - int check_content); -#elif !defined(NDEBUG) -/* For asserts that call _PyUnicode_CheckConsistency(), which would - * otherwise be a problem when building with asserts but without Py_DEBUG. */ -#define _PyUnicode_CheckConsistency(op, check_content) PyUnicode_Check(op) +# define Py_CPYTHON_UNICODEOBJECT_H +# include "cpython/unicodeobject.h" +# undef Py_CPYTHON_UNICODEOBJECT_H #endif -#ifndef Py_LIMITED_API -/* Return an interned Unicode object for an Identifier; may fail if there is no memory.*/ -PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*); -/* Clear all static strings. */ -PyAPI_FUNC(void) _PyUnicode_ClearStaticStrings(void); - -/* Fast equality check when the inputs are known to be exact unicode types - and where the hash values are equal (i.e. a very probable match) */ -PyAPI_FUNC(int) _PyUnicode_EQ(PyObject *, PyObject *); -#endif /* !Py_LIMITED_API */ - #ifdef __cplusplus } #endif diff --git a/include/weakrefobject.h b/include/weakrefobject.h index 17051568..ac4b4821 100644 --- a/include/weakrefobject.h +++ b/include/weakrefobject.h @@ -46,10 +46,10 @@ PyAPI_DATA(PyTypeObject) _PyWeakref_CallableProxyType; #define PyWeakref_CheckRef(op) PyObject_TypeCheck(op, &_PyWeakref_RefType) #define PyWeakref_CheckRefExact(op) \ - (Py_TYPE(op) == &_PyWeakref_RefType) + Py_IS_TYPE(op, &_PyWeakref_RefType) #define PyWeakref_CheckProxy(op) \ - ((Py_TYPE(op) == &_PyWeakref_ProxyType) || \ - (Py_TYPE(op) == &_PyWeakref_CallableProxyType)) + (Py_IS_TYPE(op, &_PyWeakref_ProxyType) || \ + Py_IS_TYPE(op, &_PyWeakref_CallableProxyType)) #define PyWeakref_Check(op) \ (PyWeakref_CheckRef(op) || PyWeakref_CheckProxy(op)) diff --git a/lib/python310.lib b/lib/python310.lib new file mode 100644 index 0000000000000000000000000000000000000000..2b8e02d99c9d6583ed8e6628e3bcad56d3f6374e GIT binary patch literal 356438 zcmb4s4VYX-m3GZIP0w^srpZkA*xi#K zWRb;)F|sU+h?tELF=EVOgcu_tA|fIpMiwz5VvL9w5iug0MMV7GQ>XrK-45S8&->iz zbKZ06zi!>Cx^-VWwcH#SI^(c6ALswQ@f82J{xwPcGv(CNCQp|CpLduLFZsGCd~&fU zd}^I2Y`9${|E+MtX(A!~_dllySCQ`z0CrKnbb_t0u9W4^V4OOF zIIckLYR378;5V@1Zbt1m$bl707{iDYVQ4$!$3r3^+>g8_?0TB494$lKXBE z5)aG~31K(Nf^Z-HC;a3Z#*cQx4)_W3pYT5$6i&nyxPQL_Z0`piK>iSRt!4c9LBt2x zeHdfc1jvD_5Ff%v_AvfqlSl}cUctEh4v_%q!y6=$1w%sO!-yN^YGTE*oX6NBtpuY&>J#?II!kJJLk>=w`;h!=7;2KF0cEVF!G4GUM_d#0U5o%8zj6 z7RJYq6ba#~2N>&6F9=txR(KLu;KMgFK7x1=K7K%99j?F?$REO`$1^@LTO@@4+{O4v z0d~Mv_yr1^Co-->+a-MVL5XC`PC+PKcNb&xmEc_|ihWBJ?!)yyQTW_cg>ATQ6Uj|C zGCsRkBof280@q&5_`=;Hk?6w}_~O+HC*TTv^CZUhiKzF$*B+Eef4@r*lCPc5_$KNP z;kKqk+P+^%j7<}%#5P=k_IZqz6GaLXK3f;XcP$phcb|s;1>^G#kvZ6#WuV*oHob@Wp2p*5e9nYckN!7J&34I~eOug#C$- zp&SV}OksTK7*UY89M{W5`j>u*WHa&sxC|e+X2~}E9=r;6 zko_zb1>AoNKU*mZzd_&fF!K80EAbm?`S})+Y`aJz{rFBHaTV$YQ1~Syy&CNaC_IWh z0n-24BT?8pP7u;h9HD@E^odIl7Rnb$H{$*Z6n=d%WA6d*fyc%(e$_7ugh%gZ>{%!Z zK)M0#3n={RUdC^(N4$YYP)~sLzYrgw@arQb(*Hs`1`5AeEshpvrMRGiNukIJg#68emD3X8N52PYF0d?b_!8!2^k-TIX^mX`w?TNTIybk=s zRzeOx$5upg%%#8tk-QAH<59llv<>(KNcm(01Z5_8& zB(DK?+)RYG8n)<5UNZ@t9_S{ELta3o}em!jVwjGx9B_ZZ?0ynMDq@_O{ggg1;bPD1%eJcldrdfW#HZ+MJx(pty? z^!dpfZ(zI$c`9)^uD~0oNTlz-TS)w1w@88H+NT+BM!8EM&)*E3e2)U^$jQLur$o8~ z`7VKWx&!#iwF=1BuK?Ro-z65~3f$B$kxc3n5~rLd62hcA8K4z}hF(eYg=@&BIeiiJ1cRb9P zinXohS;Q*}?e9(a@tDr>|E)dzp@M z*ok~4d=32&VJGSm;r0W-IL3D>A|>2@iA3^4^m|`HKl7C{B$6MVE+o!D-8grvNX|hz zmkcwOUM3R4xyWN6y&LyEAbBs+NO;d2#u5QO@SdHFrO(0+Sn?3#y}Q8&mZB{K>D>z@ zlI43udJodFd{iR+0pdyc(UXk((EbSjgZu)L_pOsicbzN9<( zRRV4Hhrqq4g9JRYNc?zMq!I|{#{iydBp!eqNJ=OtLiq}Xqi_Y5Aw7f&>KS3+envm) zEnyIK2uQy_g|X`z#1r@*lr;g*XoRF+p>!9*0nXd3a4N2+!gi}f^1cH|FR-ki(f>4T zfyzwAAcaXdoH0;Ae2{dXTYdzeprfTnQIQ6mEK2 z6t>@oF&@S;gd0&mCEkQ9u)V^#X{{(o;J$g&ks?`(dj5gOMEbLW!V|a>E|N%4*Cj4S z-68zjY=v8J1ujAQB{t&CfkY_n<^^?inKe`OTu(bB`#_y#ddi$BVRzwn!K}mr;Ehzk$k5M(Y@n5^9f1 zBwxA=^Bx$By8es-@r>xlt@PqH;G|f zfk*dA6wii#AlZs~0~B_kKLC=OaW5q7e2($u^D!R*Y(pIZ(%-F=NVXk{--lu@=K$mP zNFU*k_e&(-SSkqV;|LE(Zk@^aN!+eT5KqF#r%4p2A0i0J*2frMzY=i(uE%e}%}5WBVtg&J8-1U|9k|{h zlJ{2_ZCnYX&oG+PL_%nxoF!1EEueV=qjf2M1K&Vd5N_;YwC{r-;QgpCgt6%o=}#UI z5+iz8vi7W7} zdl}yuhdyfp#;X_N9y$f{Kq&8rri%3cP!7+GlSqDcz96Lkw^1VbDaxDh;MEEz;tKrq zHpb8H2OoGF(n&!7BJuF~qIibD`1m6DeL^Dn`DH@lq3aPY@bGTN&ykNn`pjyH8Ty8yfkaKFC-{%^1^t)A23&y?(B~1}_z+_f+9%=7H!|MTBZ?C6^CsYw z@r>8sDvE^HJ;pc@^H&n*;tHJbJmZZ+@C%%9DdXh*qDVMt3*!yPi6Y_kvl)|4K={Dx zMj0nf1`l}iRK}v&B0Z}g&kiV)E|jeV^0*6_j&dWMj{X!V{xi}`c;z7q7vTyVHOP3? zuqYBNX%J_cmbzhqJa3H4!rJSiQ@6F1=6=D%sBx50hIeX ziL`sAVC=&cI2w6En2h=f6py`DB0V1QCY*Rb<5={=gtxqj@m7RKIQc|{jkp4@pTju% zBKSply?T#CI(a7i11BzH{Nvps1&T*6mPk*%N=Te^yGRLdMVtu7?qt02D3JoiV-P8-MOTrtkVH|fQc))4v_gm z@I#n|ewr}t0tN7=p)S8>rbIfiA{e`I1zvlo0(`v|c>Af0Dabp*Nz)jwzZ>NNyx}y3 z8*l~w5p9id415tzMLrSUdKlvvloR2U2NS>m!>oRc^AqHc*h>b)P*7?{L>bNDY#BS8Kd7IOk66FPQ44fyU-`x!8raj z)N`Z>&xwo;xB~B5r!WCmVD?;z;>m}i-5!cKGm5W8-vOjE5H3)B&CQG%2!rsJXGQU? z{Q&N3TQEKV(zB5^!rbE(uErH@{nV8T`*6j5_`l|3UF~_So$VLN2HfX>^iMa6&De0 zNw+YHxW^L?*~2JeEFke5uFr{dE6NH;lDiq{>99lp^+l9B;f5WIt!IG;d}$Knzri7V z=?019A8@Y*(l4W40?9udCy{PLdVKjBtU%V+x1jit>N^(-LXp z86i>_86J8g;&Pcp@?xZqAWmbv7-0g1zuzg595Rgj z0saBct3YwuR*4kr!4lgxBOL(7mxb?O{*mx4%!LxZw}J89C89w1_BO^{n5!Us2X%mO z=c5woW!r?rzaJ-3!sSAu@GZ>S5^l#_E#a-D{woWISJne4@fUN znenl$n3vy*F!2lur2l@UMB#gw?$d?gT{9|M>_U|fPL@W3>Q^ol;r>GX-hAGb)Pn^C8M!XKwF zo|`BNg#E`dp1TIWfxjY834cepK>CFP5``zO7L4O@1s?C0NI#3Z0TdqJ#rW-Aq5!0y zK2@Ud%oRf7FR3UHo;if^e``fS;&5DnKcT%6{)})4e|m=T=fm(DcnUhg)5tr*0hBZ0 zf8mpG0DcMoi##Cw0X~8BbC*aIe!Cd)LRQTxg%auK_9Hx$$?p&cAiZ{pMB(@FP58spjK89s zfb#t>e4t+IH_|tfa^z#eBTZlE7YZ$Z8_Y#(4 zOhp(%e@!T%uOytejPX9m2#pDhUT_JG#}qJ5X#lm`81K6qe4vi@N?3le0>%!@f%6f* z#0j_pr3)D=jub`0vQrf{;tI?E#zNZh8pwy}-S9N)#vFhkNCHBAK&Nq-&6egbR@8gf){GA4Go(6h6I2B3*rp zkho~KNP)sw1h_eLB@j~F@yCe#mZV`m^Uxy_MpRORB z3c{Gf_&06e+d8jq(osO>JE@z1Y4l6alJ(P-Y0~_xl2V#c;9u5 z^Ja>aa5L)m*RRAp?LD}n&fkJMbPN36e7YzO9KqZJY3Hc>9?*@n20Oz%{v*lO%W-OoOP>2dfPVq25v!l5z24E7~*=7o;4y!Y=el5>Md@+>1UGK`T!JbJtAF(HcTj?4iT0ip9tsP%~*!~CcF>z2q-RiL?Ue*g|Qf69ixsq zLOACswC5W|x&(dYdAk{{9yj-M&Rds~| zu7rmritjY}Sb+Y9uy~V1@m;9H zglR}4ke)L^qWI2rf{-pkyCc-v62-HT1|VJXB;!3x&<>V}V)q1zwEt4fjS>(y!T|CX zD9*cDB3-c&Z3-A3r?3`Rq-Q?rHjsXAp+s>(9r+Es1HK7oq25b8itD48e}^4V?7mb1 z&p+MIiu8XG9|`oQ|9g)p9tOR{)3^eM+{<|JbWtQ6GM7<&KokjwqMZ<4jCMjOT*gQW zqDUy<-bfIre-b-!1zvQr!u7ZU3F<1Li2Nd?NDCo(hLJvw-@su=H{l-5tnR!nctZgzxQQ+_4vO;6JA^t~^7eg#Sd{B3yX~<8kyy zgkL`)kxWPXCUl+5n0Bj32wiB)K>F1^3>tSzAbGKtd8%#=v~av%0eVa)N19TMr^ke3pu&woSQ|AaIX7H*J8zw-#z zNrAgiFD35B6}Yos0r_$#@ZF^fh}(B}Bh3h#u<&@syKfMQ#HqLfeXAwXZ=a9y1D+mL zKv_PGyx55Tm+)z7+bI9xyBH&A+l1l8j1^CyZ+QaG@F)wQIC7&zvS}&$yrmdlKFoOU zOi`5BhAVLH0fl35C9Ic7z6U>qyKk0A7fu%v?><+gK=Ol?jC+@fgmBO03diCKd=DJL zT^B1L{&xZ2-ORZ24v|PK#uaJkLE8q>ci+ocxD(;+gbmU}xEFB&3cov2BK^$c7~?-K z3QzVc;Qsg|Y&WAW1I5{gOC&$ohjX`C3tY_hyM?<<)|5BCfz=@I%=50ONPFMMC%k%2oot{{Z|R`5=L`{2qAXZpP!N zlZ4-*{t_OCf5LAMSAgAb$@Vab^sjFcgygY}jD6=LT;K_mGm!pulSJ}6lpByfd#gn9 z=XGdD!1GPU-*De1JU5l`*ZCqLJaZ}Id9+!HeYgUDJC5<(Ht>NzKf^eHdoAr+gB@6?9$AxzAn+TW&yF^<$)DBHd^Oe%&ZPa{7b1zTUc!&DvIevMQdF4{OYR3N5XAqN8!yd0dwFtby5# z#_%vo+cU&GGdwa_5A>+_Wq_%6YU2V>8G*`F;M<_|XwdJ*Xd)CToU1tr| zg5HuRmy&K7`@W%OwX7QnQ#}P!>j=3yHrie=Ffi6^I(Z7u-C1QvBNa%@s)XjyZZxZi zELv|%r4t6BqG!#lX0y~=ZJWSNo@5kR?yS|hY*MkojG^klicCbvyRXTz` TUV-x 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

0pK2CvxR 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 b5~Th{gT~9DGSs-O^4>_`B!qHWaJ~NndV!gd literal 0 HcmV?d00001 diff --git a/lib/python37.lib b/lib/python37.lib deleted file mode 100644 index 535fea812146aa5e5af1e9f3b2089b0019c0f1e7..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 342420 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 diff --git a/src/api/event.cpp b/src/api/event.cpp index 825cc628..2ccde618 100644 --- a/src/api/event.cpp +++ b/src/api/event.cpp @@ -15,13 +15,20 @@ #include "scoreboard.h" #include "utils.h" -#define EVENT_BEGIN(code) \ - Callbacker h(code); \ - PY_TRY; \ - h.insert("Event", py::cast(magic_enum::enum_name(code))) +#define EVENT_BEGIN(code) \ + PY_TRY \ + py::gil_scoped_acquire gil; \ + Callbacker h(code); \ + h.insert("Event", magic_enum::enum_name(code)) #define EVENT_INSERT(key) h.insert(#key, ev.m##key) #define EVENT_INSERT_EX(key, value) h.insert(#key, (value)) -#define EVENT_END PY_CATCH return h.callback() +#define EVENT_END \ + return h.callback(); \ + } \ + catch (const std::exception& e) { \ + logger.error("\n{}", e.what()); \ + return false; \ + } class Callbacker { public: @@ -32,7 +39,6 @@ class Callbacker { arg_.inc_ref(); // TODO: 为什么需要增加引用计数？ for (auto& cb : listeners[type_]) { PY_TRY; - py::gil_scoped_acquire gil_; pass = bool(cb(arg_)); PY_CATCH; } @@ -67,7 +73,6 @@ class Callbacker { private: EventCode type_; py::dict arg_; - py::gil_scoped_acquire gil_; }; void EnableEventListener(EventCode event_code) { diff --git a/src/main.cpp b/src/main.cpp index c97bc295..68de686e 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -6,9 +6,9 @@ #include "py_utils.h" constexpr unsigned PYR_VERSION_MAJOR = 2; -constexpr unsigned PYR_VERSION_MINOR = 0; -constexpr unsigned PYR_VERSION_MICRO = 9; -constexpr const char* PYR_VERSION = "v2.0.9"; +constexpr unsigned PYR_VERSION_MINOR = 1; +constexpr unsigned PYR_VERSION_MICRO = 0; +constexpr const char* PYR_VERSION = "v2.1.0"; Logger logger("BDSpyrunner"); @@ -20,6 +20,7 @@ void entry() { // 创建插件目录 if (!fs::exists(PLUGIN_PATH)) { fs::create_directory(PLUGIN_PATH); + logger.warn("create plugin directory: {}", PLUGIN_PATH); } // 初始化解释器 py::initialize_interpreter(true, 0, nullptr, false); @@ -27,8 +28,6 @@ void entry() { py::module_::import("sys").attr("path").attr("insert")(0, PLUGIN_PATH); // 输出版本号信息 logger.info("{} loaded.", PYR_VERSION); - // 启用线程支持 - PyEval_InitThreads(); #if 0 auto a = CompoundTag::fromSNBT(R"({ "a24z": { @@ -56,7 +55,7 @@ void entry() { } } // 启动子线程前执行，释放PyEval_InitThreads获得的全局锁，否则子线程可能无法获取到全局锁。 - PyEval_ReleaseThread(PyThreadState_Get()); + PyEval_ReleaseThread(PyThreadState_GET()); PY_CATCH; } diff --git a/src/py_utils.h b/src/py_utils.h index 719d38b9..ab2edb8e 100644 --- a/src/py_utils.h +++ b/src/py_utils.h @@ -5,16 +5,11 @@ #include "global.h" #define PY_TRY try { -#define PY_CATCH \ - } \ - catch (const std::exception& e) { \ - logger.error("\n{}", e.what()); \ - } \ - catch (...) { \ - logger.fatal("An unknown exception was occurred! Function: {}", \ - __FUNCSIG__); \ +#define PY_CATCH \ + } \ + catch (const std::exception& e) { \ + logger.error("\n{}", e.what()); \ } - namespace py = pybind11; inline unordered_map> listeners;