Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-21 15:51
📄 pycore_abstract.h #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); } PyObject _PyNumber_PowerNoMod(PyObject lhs, PyObject rhs); PyObject _PyNumber_InPlacePowerNoMod(PyObject lhs, PyObject rhs); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_ABSTRACT_H */	611 B	2025-10-09 16:16
📄 pycore_accu.h #ifndef Py_LIMITED_API #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. / #undef small / defined by some Windows headers / typedef struct { PyObject large; /* A list of previously accumulated large strings / PyObject small; /* Pending small strings / } _PyAccu; PyAPI_FUNC(int) _PyAccu_Init(_PyAccu acc); PyAPI_FUNC(int) _PyAccu_Accumulate(_PyAccu acc, PyObject unicode); PyAPI_FUNC(PyObject ) _PyAccu_FinishAsList(_PyAccu acc); PyAPI_FUNC(PyObject ) _PyAccu_Finish(_PyAccu acc); PyAPI_FUNC(void) _PyAccu_Destroy(_PyAccu acc); #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_ACCU_H / #endif / !Py_LIMITED_API */	1.1 KB	2025-10-09 16:16
📄 pycore_asdl.h #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) _Py_RVALUE((S)->elements[(I)]) #define asdl_seq_GET(S, I) _Py_RVALUE((S)->typed_elements[(I)]) #define asdl_seq_LEN(S) _Py_RVALUE(((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) _Py_RVALUE((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) _Py_RVALUE((S)->elements[I] = (V)) #endif #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_ASDL_H */	2.96 KB	2025-10-09 16:16
📄 pycore_ast.h // 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, TryStar_kind=18, Assert_kind=19, Import_kind=20, ImportFrom_kind=21, Global_kind=22, Nonlocal_kind=23, Expr_kind=24, Pass_kind=25, Break_kind=26, Continue_kind=27}; 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 { asdl_stmt_seq body; asdl_excepthandler_seq handlers; asdl_stmt_seq orelse; asdl_stmt_seq finalbody; } TryStar; 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_TryStar(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 */	28.63 KB	2025-10-09 16:16
📄 pycore_ast_state.h // 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; int unused_recursion_depth; int unused_recursion_limit; 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 TryStar_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 */	6.4 KB	2025-10-09 16:16
📄 pycore_atomic.h #ifndef Py_ATOMIC_H #define Py_ATOMIC_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif #include "dynamic_annotations.h" /* _Py_ANNOTATE_MEMORY_ORDER / #include "pyconfig.h" #ifdef HAVE_STD_ATOMIC # include <stdatomic.h> #endif #if defined(_MSC_VER) #include <intrin.h> #if defined(_M_IX86) \|\| defined(_M_X64) # include <immintrin.h> #endif #endif / This is modeled after the atomics interface from C1x, according to * the draft at * http://www.open-std.org/JTC1/SC22/wg14/www/docs/n1425.pdf. * Operations and types are named the same except with a _Py_ prefix * and have the same semantics. * * Beware, the implementations here are deep magic. / #if defined(HAVE_STD_ATOMIC) typedef enum _Py_memory_order { _Py_memory_order_relaxed = memory_order_relaxed, _Py_memory_order_acquire = memory_order_acquire, _Py_memory_order_release = memory_order_release, _Py_memory_order_acq_rel = memory_order_acq_rel, _Py_memory_order_seq_cst = memory_order_seq_cst } _Py_memory_order; typedef struct _Py_atomic_address { atomic_uintptr_t _value; } _Py_atomic_address; typedef struct _Py_atomic_int { atomic_int _value; } _Py_atomic_int; #define _Py_atomic_signal_fence(/memory_order/ ORDER) \ atomic_signal_fence(ORDER) #define _Py_atomic_thread_fence(/memory_order/ ORDER) \ atomic_thread_fence(ORDER) #define _Py_atomic_store_explicit(ATOMIC_VAL, 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) // Use builtin atomic operations in GCC >= 4.7 and clang #elif defined(HAVE_BUILTIN_ATOMIC) typedef enum _Py_memory_order { _Py_memory_order_relaxed = __ATOMIC_RELAXED, _Py_memory_order_acquire = __ATOMIC_ACQUIRE, _Py_memory_order_release = __ATOMIC_RELEASE, _Py_memory_order_acq_rel = __ATOMIC_ACQ_REL, _Py_memory_order_seq_cst = __ATOMIC_SEQ_CST } _Py_memory_order; typedef struct _Py_atomic_address { uintptr_t _value; } _Py_atomic_address; typedef struct _Py_atomic_int { int _value; } _Py_atomic_int; #define _Py_atomic_signal_fence(/memory_order/ ORDER) \ __atomic_signal_fence(ORDER) #define _Py_atomic_thread_fence(/memory_order/ ORDER) \ __atomic_thread_fence(ORDER) #define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \ (assert((ORDER) == __ATOMIC_RELAXED \ \|\| (ORDER) == __ATOMIC_SEQ_CST \ \|\| (ORDER) == __ATOMIC_RELEASE), \ __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)) / Only support GCC (for expression statements) and x86 (for simple * atomic semantics) and MSVC x86/x64/ARM / #elif defined(__GNUC__) && (defined(__i386__) \|\| defined(__amd64)) typedef enum _Py_memory_order { _Py_memory_order_relaxed, _Py_memory_order_acquire, _Py_memory_order_release, _Py_memory_order_acq_rel, _Py_memory_order_seq_cst } _Py_memory_order; typedef struct _Py_atomic_address { uintptr_t _value; } _Py_atomic_address; typedef struct _Py_atomic_int { int _value; } _Py_atomic_int; static __inline__ void _Py_atomic_signal_fence(_Py_memory_order order) { if (order != _Py_memory_order_relaxed) __asm__ volatile("":::"memory"); } static __inline__ void _Py_atomic_thread_fence(_Py_memory_order order) { if (order != _Py_memory_order_relaxed) __asm__ volatile("mfence":::"memory"); } / Tell the race checker about this operation's effects. / static __inline__ void _Py_ANNOTATE_MEMORY_ORDER(const volatile void address, _Py_memory_order order) { (void)address; /* shut up -Wunused-parameter / switch(order) { case _Py_memory_order_release: case _Py_memory_order_acq_rel: case _Py_memory_order_seq_cst: _Py_ANNOTATE_HAPPENS_BEFORE(address); break; case _Py_memory_order_relaxed: case _Py_memory_order_acquire: break; } switch(order) { case _Py_memory_order_acquire: case _Py_memory_order_acq_rel: case _Py_memory_order_seq_cst: _Py_ANNOTATE_HAPPENS_AFTER(address); break; case _Py_memory_order_relaxed: case _Py_memory_order_release: break; } } #define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \ __extension__ ({ \ __typeof__(ATOMIC_VAL) atomic_val = ATOMIC_VAL; \ __typeof__(atomic_val->_value) new_val = NEW_VAL;\ volatile __typeof__(new_val) volatile_data = &atomic_val->_value; \ _Py_memory_order order = ORDER; \ _Py_ANNOTATE_MEMORY_ORDER(atomic_val, order); \ \ /* Perform the operation. / \ _Py_ANNOTATE_IGNORE_WRITES_BEGIN(); \ switch(order) { \ case _Py_memory_order_release: \ _Py_atomic_signal_fence(_Py_memory_order_release); \ / fallthrough / \ case _Py_memory_order_relaxed: \ volatile_data = new_val; \ break; \ \ case _Py_memory_order_acquire: \ case _Py_memory_order_acq_rel: \ case _Py_memory_order_seq_cst: \ __asm__ volatile("xchg %0, %1" \ : "+r"(new_val) \ : "m"(atomic_val->_value) \ : "memory"); \ break; \ } \ _Py_ANNOTATE_IGNORE_WRITES_END(); \ }) #define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \ __extension__ ({ \ __typeof__(ATOMIC_VAL) atomic_val = ATOMIC_VAL; \ __typeof__(atomic_val->_value) result; \ volatile __typeof__(result) volatile_data = &atomic_val->_value; \ _Py_memory_order order = ORDER; \ _Py_ANNOTATE_MEMORY_ORDER(atomic_val, order); \ \ / Perform the operation. / \ _Py_ANNOTATE_IGNORE_READS_BEGIN(); \ switch(order) { \ case _Py_memory_order_release: \ case _Py_memory_order_acq_rel: \ case _Py_memory_order_seq_cst: \ / Loads on x86 are not releases by default, so need a / \ / thread fence. / \ _Py_atomic_thread_fence(_Py_memory_order_release); \ break; \ default: \ / No fence / \ break; \ } \ result = volatile_data; \ switch(order) { \ case _Py_memory_order_acquire: \ case _Py_memory_order_acq_rel: \ case _Py_memory_order_seq_cst: \ /* Loads on x86 are automatically acquire operations so / \ / can get by with just a compiler fence. / \ _Py_atomic_signal_fence(_Py_memory_order_acquire); \ break; \ default: \ / No fence / \ break; \ } \ _Py_ANNOTATE_IGNORE_READS_END(); \ result; \ }) #elif defined(_MSC_VER) / _Interlocked* functions provide a full memory barrier and are therefore enough for acq_rel and seq_cst. If the HLE variants aren't available in hardware they will fall back to a full memory barrier as well. This might affect performance but likely only in some very specific and hard to measure scenario. / #if defined(_M_IX86) \|\| defined(_M_X64) typedef enum _Py_memory_order { _Py_memory_order_relaxed, _Py_memory_order_acquire, _Py_memory_order_release, _Py_memory_order_acq_rel, _Py_memory_order_seq_cst } _Py_memory_order; typedef struct _Py_atomic_address { volatile uintptr_t _value; } _Py_atomic_address; typedef struct _Py_atomic_int { volatile int _value; } _Py_atomic_int; #if defined(_M_X64) #define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) \ switch (ORDER) { \ case _Py_memory_order_acquire: \ _InterlockedExchange64_HLEAcquire((__int64 volatile)&((ATOMIC_VAL)->_value), (__int64)(NEW_VAL)); \ break; \ case _Py_memory_order_release: \ _InterlockedExchange64_HLERelease((__int64 volatile)&((ATOMIC_VAL)->_value), (__int64)(NEW_VAL)); \ break; \ default: \ _InterlockedExchange64((__int64 volatile)&((ATOMIC_VAL)->_value), (__int64)(NEW_VAL)); \ break; \ } #else #define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) ((void)0); #endif #define _Py_atomic_store_32bit(ATOMIC_VAL, NEW_VAL, ORDER) \ switch (ORDER) { \ case _Py_memory_order_acquire: \ _InterlockedExchange_HLEAcquire((volatile long)&((ATOMIC_VAL)->_value), (int)(NEW_VAL)); \ break; \ case _Py_memory_order_release: \ _InterlockedExchange_HLERelease((volatile long)&((ATOMIC_VAL)->_value), (int)(NEW_VAL)); \ break; \ default: \ _InterlockedExchange((volatile long)&((ATOMIC_VAL)->_value), (int)(NEW_VAL)); \ break; \ } #if defined(_M_X64) / This has to be an intptr_t for now. 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_impl(volatile uintptr_t value, int order) { __int64 old; switch (order) { case _Py_memory_order_acquire: { do { old = value; } while(_InterlockedCompareExchange64_HLEAcquire((volatile __int64)value, old, old) != old); break; } case _Py_memory_order_release: { do { old = value; } while(_InterlockedCompareExchange64_HLERelease((volatile __int64)value, old, old) != old); break; } case _Py_memory_order_relaxed: old = value; break; default: { do { old = value; } while(_InterlockedCompareExchange64((volatile __int64)value, old, old) != old); break; } } 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)->_value) #endif inline int _Py_atomic_load_32bit_impl(volatile int* value, int order) { long old; switch (order) { case _Py_memory_order_acquire: { do { old = value; } while(_InterlockedCompareExchange_HLEAcquire((volatile long)value, old, old) != old); break; } case _Py_memory_order_release: { do { old = value; } while(_InterlockedCompareExchange_HLERelease((volatile long)value, old, old) != old); break; } case _Py_memory_order_relaxed: old = value; break; default: { do { old = value; } while(_InterlockedCompareExchange((volatile long)value, old, old) != old); break; } } 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), 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), ORDER) : \ _Py_atomic_load_32bit((ATOMIC_VAL), ORDER) \ ) #elif defined(_M_ARM) \|\| defined(_M_ARM64) typedef enum _Py_memory_order { _Py_memory_order_relaxed, _Py_memory_order_acquire, _Py_memory_order_release, _Py_memory_order_acq_rel, _Py_memory_order_seq_cst } _Py_memory_order; typedef struct _Py_atomic_address { volatile uintptr_t _value; } _Py_atomic_address; typedef struct _Py_atomic_int { volatile int _value; } _Py_atomic_int; #if defined(_M_ARM64) #define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) \ switch (ORDER) { \ case _Py_memory_order_acquire: \ _InterlockedExchange64_acq((__int64 volatile)&((ATOMIC_VAL)->_value), (__int64)NEW_VAL); \ break; \ case _Py_memory_order_release: \ _InterlockedExchange64_rel((__int64 volatile)&((ATOMIC_VAL)->_value), (__int64)NEW_VAL); \ break; \ default: \ _InterlockedExchange64((__int64 volatile)&((ATOMIC_VAL)->_value), (__int64)NEW_VAL); \ break; \ } #else #define _Py_atomic_store_64bit(ATOMIC_VAL, NEW_VAL, ORDER) ((void)0); #endif #define _Py_atomic_store_32bit(ATOMIC_VAL, NEW_VAL, ORDER) \ switch (ORDER) { \ case _Py_memory_order_acquire: \ _InterlockedExchange_acq((volatile long)&((ATOMIC_VAL)->_value), (int)NEW_VAL); \ break; \ case _Py_memory_order_release: \ _InterlockedExchange_rel((volatile long)&((ATOMIC_VAL)->_value), (int)NEW_VAL); \ break; \ default: \ _InterlockedExchange((volatile long)&((ATOMIC_VAL)->_value), (int)NEW_VAL); \ break; \ } #if defined(_M_ARM64) /* This has to be an intptr_t for now. 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_impl(volatile uintptr_t value, int order) { uintptr_t old; switch (order) { case _Py_memory_order_acquire: { do { old = value; } while(_InterlockedCompareExchange64_acq(value, old, old) != old); break; } case _Py_memory_order_release: { do { old = value; } while(_InterlockedCompareExchange64_rel(value, old, old) != old); break; } case _Py_memory_order_relaxed: old = value; break; default: { do { old = value; } while(_InterlockedCompareExchange64(value, old, old) != old); break; } } 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)->_value) #endif inline int _Py_atomic_load_32bit_impl(volatile int value, int order) { int old; switch (order) { case _Py_memory_order_acquire: { do { old = value; } while(_InterlockedCompareExchange_acq(value, old, old) != old); break; } case _Py_memory_order_release: { do { old = value; } while(_InterlockedCompareExchange_rel(value, old, old) != old); break; } case _Py_memory_order_relaxed: old = value; break; default: { do { old = value; } while(_InterlockedCompareExchange(value, old, old) != old); break; } } 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), (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), (ORDER)) : \ _Py_atomic_load_32bit((ATOMIC_VAL), (ORDER)) \ ) #endif #else / !gcc x86 !_msc_ver / typedef enum _Py_memory_order { _Py_memory_order_relaxed, _Py_memory_order_acquire, _Py_memory_order_release, _Py_memory_order_acq_rel, _Py_memory_order_seq_cst } _Py_memory_order; typedef struct _Py_atomic_address { uintptr_t _value; } _Py_atomic_address; typedef struct _Py_atomic_int { int _value; } _Py_atomic_int; / Fall back to other compilers and processors by assuming that simple volatile accesses are atomic. This is false, so people should port this. / #define _Py_atomic_signal_fence(/memory_order/ ORDER) ((void)0) #define _Py_atomic_thread_fence(/memory_order/ ORDER) ((void)0) #define _Py_atomic_store_explicit(ATOMIC_VAL, NEW_VAL, ORDER) \ ((ATOMIC_VAL)->_value = NEW_VAL) #define _Py_atomic_load_explicit(ATOMIC_VAL, ORDER) \ ((ATOMIC_VAL)->_value) #endif / Standardized shortcuts. / #define _Py_atomic_store(ATOMIC_VAL, NEW_VAL) \ _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) / Python-local extensions / #define _Py_atomic_store_relaxed(ATOMIC_VAL, NEW_VAL) \ _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) #ifdef __cplusplus } #endif #endif / Py_ATOMIC_H */	16.58 KB	2025-10-09 16:16
📄 pycore_atomic_funcs.h /* 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 <intrin.h> // _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 */	2.38 KB	2025-10-09 16:16
📄 pycore_bitutils.h /* 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 <intrin.h> #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; // 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. // Take care when considering changes to the next line. Portability and // correctness are delicate here, thanks to C's "integer promotions" (C99 // §6.3.1.1p2). On machines where the `int` type has width greater than 32 // bits, `x` will be promoted to an `int`, and following C's "usual // arithmetic conversions" (C99 §6.3.1.8), the multiplication will be // performed as a multiplication of two `unsigned int` operands. In this // case it's critical that we cast back to `uint32_t` in order to keep only // the least significant 32 bits. On machines where the `int` type has // width no greater than 32, the multiplication is of two 32-bit unsigned // integer types, and the (uint32_t) cast is a no-op. In both cases, we // avoid the risk of undefined behaviour due to overflow of a // multiplication of signed integer types. return (uint32_t)(x 0x01010101U) >> 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 */	5.92 KB	2025-10-09 16:16
📄 pycore_blocks_output_buffer.h /* _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 (25610241024) / Block size sequence / #define KB (1024) #define MB (10241024) static const Py_ssize_t BUFFER_BLOCK_SIZE[] = { 32KB, 64KB, 256KB, 1MB, 4MB, 8MB, 16MB, 16MB, 32MB, 32MB, 32MB, 32MB, 64MB, 64MB, 128MB, 128MB, 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 */	8.48 KB	2025-10-09 16:16
📄 pycore_bytes_methods.h #ifndef Py_LIMITED_API #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. / extern PyObject _Py_bytes_isspace(const char cptr, Py_ssize_t len); extern PyObject _Py_bytes_isalpha(const char cptr, Py_ssize_t len); extern PyObject _Py_bytes_isalnum(const char cptr, Py_ssize_t len); extern PyObject _Py_bytes_isascii(const char cptr, Py_ssize_t len); extern PyObject _Py_bytes_isdigit(const char cptr, Py_ssize_t len); extern PyObject _Py_bytes_islower(const char cptr, Py_ssize_t len); extern PyObject _Py_bytes_isupper(const char cptr, Py_ssize_t len); extern PyObject _Py_bytes_istitle(const char cptr, Py_ssize_t len); / These store their len sized answer in the given preallocated result arg. / extern void _Py_bytes_lower(char result, const char cptr, Py_ssize_t len); extern void _Py_bytes_upper(char result, const char cptr, Py_ssize_t len); extern void _Py_bytes_title(char result, const char s, Py_ssize_t len); extern void _Py_bytes_capitalize(char result, const char s, Py_ssize_t len); extern void _Py_bytes_swapcase(char result, const char s, Py_ssize_t len); extern PyObject _Py_bytes_find(const char str, Py_ssize_t len, PyObject args); extern PyObject _Py_bytes_index(const char str, Py_ssize_t len, PyObject args); extern PyObject _Py_bytes_rfind(const char str, Py_ssize_t len, PyObject args); extern PyObject _Py_bytes_rindex(const char str, Py_ssize_t len, PyObject args); extern PyObject _Py_bytes_count(const char str, Py_ssize_t len, PyObject args); extern int _Py_bytes_contains(const char str, Py_ssize_t len, PyObject arg); extern PyObject _Py_bytes_startswith(const char str, Py_ssize_t len, PyObject args); extern PyObject _Py_bytes_endswith(const char str, Py_ssize_t len, PyObject args); / The maketrans() static method. / extern PyObject _Py_bytes_maketrans(Py_buffer frm, Py_buffer to); /* Shared __doc__ strings. / extern const char _Py_isspace__doc__[]; extern const char _Py_isalpha__doc__[]; extern const char _Py_isalnum__doc__[]; extern const char _Py_isascii__doc__[]; extern const char _Py_isdigit__doc__[]; extern const char _Py_islower__doc__[]; extern const char _Py_isupper__doc__[]; extern const char _Py_istitle__doc__[]; extern const char _Py_lower__doc__[]; extern const char _Py_upper__doc__[]; extern const char _Py_title__doc__[]; extern const char _Py_capitalize__doc__[]; extern const char _Py_swapcase__doc__[]; extern const char _Py_count__doc__[]; extern const char _Py_find__doc__[]; extern const char _Py_index__doc__[]; extern const char _Py_rfind__doc__[]; extern const char _Py_rindex__doc__[]; extern const char _Py_startswith__doc__[]; extern const char _Py_endswith__doc__[]; extern const char _Py_maketrans__doc__[]; extern const char _Py_expandtabs__doc__[]; extern const char _Py_ljust__doc__[]; extern const char _Py_rjust__doc__[]; extern const char _Py_center__doc__[]; extern const char _Py_zfill__doc__[]; / this is needed because some docs are shared from the .o, not static / #define PyDoc_STRVAR_shared(name,str) const char name[] = PyDoc_STR(str) #endif / !Py_BYTES_CTYPE_H / #endif / !Py_LIMITED_API */	3.3 KB	2025-10-09 16:16
📄 pycore_bytesobject.h #ifndef Py_INTERNAL_BYTESOBJECT_H #define Py_INTERNAL_BYTESOBJECT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif /* runtime lifecycle / extern PyStatus _PyBytes_InitTypes(PyInterpreterState ); /* Substring Search. Returns the index of the first occurrence of a substring ("needle") in a larger text ("haystack"). If the needle is not found, return -1. If the needle is found, add offset to the index. / PyAPI_FUNC(Py_ssize_t) _PyBytes_Find(const char haystack, Py_ssize_t len_haystack, const char needle, Py_ssize_t len_needle, Py_ssize_t offset); / Same as above, but search right-to-left / PyAPI_FUNC(Py_ssize_t) _PyBytes_ReverseFind(const char haystack, Py_ssize_t len_haystack, const char needle, Py_ssize_t len_needle, Py_ssize_t offset); /* Helper function to implement the repeat and inplace repeat methods on a buffer * * len_dest is assumed to be an integer multiple of len_src. * If src equals dest, then assume the operation is inplace. * * This method repeately doubles the number of bytes copied to reduce * the number of invocations of memcpy. / PyAPI_FUNC(void) _PyBytes_Repeat(char dest, Py_ssize_t len_dest, const char* src, Py_ssize_t len_src); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_BYTESOBJECT_H */	1.39 KB	2025-10-09 16:16
📄 pycore_call.h #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 #include "pycore_pystate.h" // _PyThreadState_GET() 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); extern PyObject _PyObject_CallMethodFormat( PyThreadState tstate, PyObject callable, const char format, ...); // Static inline variant of public PyVectorcall_Function(). static inline vectorcallfunc _PyVectorcall_FunctionInline(PyObject callable) { assert(callable != NULL); PyTypeObject tp = Py_TYPE(callable); if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { return NULL; } assert(PyCallable_Check(callable)); Py_ssize_t offset = tp->tp_vectorcall_offset; assert(offset > 0); vectorcallfunc ptr; 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_FunctionInline(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_CallNoArgsTstate(PyThreadState tstate, PyObject func) { return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL); } // Private static inline function variant of public PyObject_CallNoArgs() static inline PyObject * _PyObject_CallNoArgs(PyObject func) { PyThreadState tstate = _PyThreadState_GET(); return _PyObject_VectorcallTstate(tstate, func, NULL, 0, NULL); } 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); } #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_CALL_H */	3.39 KB	2025-10-09 16:16
📄 pycore_ceval.h #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; / WASI has limited call stack. Python's recursion limit depends on code layout, optimization, and WASI runtime. Wasmtime can handle about 700-750 recursions, sometimes less. 600 is a more conservative limit. / #ifndef Py_DEFAULT_RECURSION_LIMIT # ifdef __wasi__ # define Py_DEFAULT_RECURSION_LIMIT 600 # else # define Py_DEFAULT_RECURSION_LIMIT 1000 # endif #endif #include "pycore_interp.h" // PyInterpreterState.eval_frame #include "pycore_pystate.h" // _PyThreadState_GET() extern void _Py_FinishPendingCalls(PyThreadState tstate); extern void _PyEval_InitRuntimeState(struct _ceval_runtime_state ); extern void _PyEval_InitState(struct _ceval_state , PyThread_type_lock); 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 // Used by sys.call_tracing() extern PyObject* _PyEval_CallTracing(PyObject func, PyObject args); // Used by sys.get_asyncgen_hooks() extern PyObject* _PyEval_GetAsyncGenFirstiter(void); extern PyObject* _PyEval_GetAsyncGenFinalizer(void); // Used by sys.set_asyncgen_hooks() extern int _PyEval_SetAsyncGenFirstiter(PyObject ); extern int _PyEval_SetAsyncGenFinalizer(PyObject ); // Used by sys.get_coroutine_origin_tracking_depth() // and sys.set_coroutine_origin_tracking_depth() extern int _PyEval_GetCoroutineOriginTrackingDepth(void); extern int _PyEval_SetCoroutineOriginTrackingDepth(int depth); extern 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, struct _PyInterpreterFrame frame, int throwflag) { if (tstate->interp->eval_frame == NULL) { return _PyEval_EvalFrameDefault(tstate, frame, throwflag); } return tstate->interp->eval_frame(tstate, frame, throwflag); } extern PyObject* _PyEval_Vector(PyThreadState tstate, PyFunctionObject func, PyObject locals, PyObject const* args, size_t argcount, PyObject kwnames); extern int _PyEval_ThreadsInitialized(struct pyruntimestate runtime); 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_remaining-- <= 0 \|\| (tstate->recursion_remaining & 63) == 0); } #else static inline int _Py_MakeRecCheck(PyThreadState tstate) { return tstate->recursion_remaining-- <= 0; } #endif PyAPI_FUNC(int) _Py_CheckRecursiveCall( PyThreadState tstate, const char where); static inline int _Py_EnterRecursiveCallTstate(PyThreadState tstate, const char where) { return (_Py_MakeRecCheck(tstate) && _Py_CheckRecursiveCall(tstate, where)); } static inline int _Py_EnterRecursiveCall(const char where) { PyThreadState tstate = _PyThreadState_GET(); return _Py_EnterRecursiveCallTstate(tstate, where); } static inline void _Py_LeaveRecursiveCallTstate(PyThreadState tstate) { tstate->recursion_remaining++; } static inline void _Py_LeaveRecursiveCall(void) { PyThreadState tstate = _PyThreadState_GET(); _Py_LeaveRecursiveCallTstate(tstate); } extern struct _PyInterpreterFrame _PyEval_GetFrame(void); extern PyObject* _Py_MakeCoro(PyFunctionObject func); #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_CEVAL_H */	4.31 KB	2025-10-09 16:16
📄 pycore_code.h #ifndef Py_INTERNAL_CODE_H #define Py_INTERNAL_CODE_H #ifdef __cplusplus extern "C" { #endif /* PEP 659 * Specialization and quickening structs and helper functions / // Inline caches. If you change the number of cache entries for an instruction, // you must also* update the number of cache entries in Lib/opcode.py and bump // the magic number in Lib/importlib/_bootstrap_external.py! #define CACHE_ENTRIES(cache) (sizeof(cache)/sizeof(_Py_CODEUNIT)) typedef struct { _Py_CODEUNIT counter; _Py_CODEUNIT index; _Py_CODEUNIT module_keys_version[2]; _Py_CODEUNIT builtin_keys_version; } _PyLoadGlobalCache; #define INLINE_CACHE_ENTRIES_LOAD_GLOBAL CACHE_ENTRIES(_PyLoadGlobalCache) typedef struct { _Py_CODEUNIT counter; } _PyBinaryOpCache; #define INLINE_CACHE_ENTRIES_BINARY_OP CACHE_ENTRIES(_PyBinaryOpCache) typedef struct { _Py_CODEUNIT counter; } _PyUnpackSequenceCache; #define INLINE_CACHE_ENTRIES_UNPACK_SEQUENCE \ CACHE_ENTRIES(_PyUnpackSequenceCache) typedef struct { _Py_CODEUNIT counter; _Py_CODEUNIT mask; } _PyCompareOpCache; #define INLINE_CACHE_ENTRIES_COMPARE_OP CACHE_ENTRIES(_PyCompareOpCache) typedef struct { _Py_CODEUNIT counter; _Py_CODEUNIT type_version[2]; _Py_CODEUNIT func_version; } _PyBinarySubscrCache; #define INLINE_CACHE_ENTRIES_BINARY_SUBSCR CACHE_ENTRIES(_PyBinarySubscrCache) typedef struct { _Py_CODEUNIT counter; _Py_CODEUNIT version[2]; _Py_CODEUNIT index; } _PyAttrCache; #define INLINE_CACHE_ENTRIES_LOAD_ATTR CACHE_ENTRIES(_PyAttrCache) #define INLINE_CACHE_ENTRIES_STORE_ATTR CACHE_ENTRIES(_PyAttrCache) typedef struct { _Py_CODEUNIT counter; _Py_CODEUNIT type_version[2]; _Py_CODEUNIT dict_offset; _Py_CODEUNIT keys_version[2]; _Py_CODEUNIT descr[4]; } _PyLoadMethodCache; #define INLINE_CACHE_ENTRIES_LOAD_METHOD CACHE_ENTRIES(_PyLoadMethodCache) typedef struct { _Py_CODEUNIT counter; _Py_CODEUNIT func_version[2]; _Py_CODEUNIT min_args; } _PyCallCache; #define INLINE_CACHE_ENTRIES_CALL CACHE_ENTRIES(_PyCallCache) typedef struct { _Py_CODEUNIT counter; } _PyPrecallCache; #define INLINE_CACHE_ENTRIES_PRECALL CACHE_ENTRIES(_PyPrecallCache) typedef struct { _Py_CODEUNIT counter; } _PyStoreSubscrCache; #define INLINE_CACHE_ENTRIES_STORE_SUBSCR CACHE_ENTRIES(_PyStoreSubscrCache) #define QUICKENING_WARMUP_DELAY 8 /* We want to compare to zero for efficiency, so we offset values accordingly / #define QUICKENING_INITIAL_WARMUP_VALUE (-QUICKENING_WARMUP_DELAY) void _PyCode_Quicken(PyCodeObject code); static inline void _PyCode_Warmup(PyCodeObject code) { if (code->co_warmup != 0) { code->co_warmup++; if (code->co_warmup == 0) { _PyCode_Quicken(code); } } } extern uint8_t _PyOpcode_Adaptive[256]; extern Py_ssize_t _Py_QuickenedCount; // Borrowed references to common callables: struct callable_cache { PyObject isinstance; PyObject len; PyObject list_append; }; /* "Locals plus" for a code object is the set of locals + cell vars + * free vars. This relates to variable names as well as offsets into * the "fast locals" storage array of execution frames. The compiler * builds the list of names, their offsets, and the corresponding * kind of local. * * Those kinds represent the source of the initial value and the * variable's scope (as related to closures). A "local" is an * argument or other variable defined in the current scope. A "free" * variable is one that is defined in an outer scope and comes from * the function's closure. A "cell" variable is a local that escapes * into an inner function as part of a closure, and thus must be * wrapped in a cell. Any "local" can also be a "cell", but the * "free" kind is mutually exclusive with both. / // Note that these all fit within a byte, as do combinations. // Later, we will use the smaller numbers to differentiate the different // kinds of locals (e.g. pos-only arg, varkwargs, local-only). #define CO_FAST_LOCAL 0x20 #define CO_FAST_CELL 0x40 #define CO_FAST_FREE 0x80 typedef unsigned char _PyLocals_Kind; static inline _PyLocals_Kind _PyLocals_GetKind(PyObject kinds, int i) { assert(PyBytes_Check(kinds)); assert(0 <= i && i < PyBytes_GET_SIZE(kinds)); char ptr = PyBytes_AS_STRING(kinds); return (_PyLocals_Kind)(ptr[i]); } static inline void _PyLocals_SetKind(PyObject kinds, int i, _PyLocals_Kind kind) { assert(PyBytes_Check(kinds)); assert(0 <= i && i < PyBytes_GET_SIZE(kinds)); char ptr = PyBytes_AS_STRING(kinds); ptr[i] = (char) kind; } struct _PyCodeConstructor { / metadata / PyObject filename; PyObject name; PyObject qualname; int flags; /* the code / PyObject code; int firstlineno; PyObject linetable; / used by the code / PyObject consts; PyObject names; / mapping frame offsets to information / PyObject localsplusnames; // Tuple of strings PyObject localspluskinds; // Bytes object, one byte per variable / args (within varnames) / int argcount; int posonlyargcount; // XXX Replace argcount with posorkwargcount (argcount - posonlyargcount). int kwonlyargcount; / needed to create the frame / int stacksize; / used by the eval loop / PyObject exceptiontable; }; // Using an "arguments struct" like this is helpful for maintainability // in a case such as this with many parameters. It does bear a risk: // if the struct changes and callers are not updated properly then the // compiler will not catch problems (like a missing argument). This can // cause hard-to-debug problems. The risk is mitigated by the use of // check_code() in codeobject.c. However, we may decide to switch // back to a regular function signature. Regardless, this approach // wouldn't be appropriate if this weren't a strictly internal API. // (See the comments in https://github.com/python/cpython/pull/26258.) PyAPI_FUNC(int) _PyCode_Validate(struct _PyCodeConstructor ); PyAPI_FUNC(PyCodeObject ) _PyCode_New(struct _PyCodeConstructor ); / Private API / / Getters for internal PyCodeObject data. / extern PyObject _PyCode_GetVarnames(PyCodeObject ); extern PyObject _PyCode_GetCellvars(PyCodeObject ); extern PyObject _PyCode_GetFreevars(PyCodeObject ); extern PyObject _PyCode_GetCode(PyCodeObject ); /* API for initializing the line number tables. / extern int _PyCode_InitAddressRange(PyCodeObject co, PyCodeAddressRange bounds); /* Out of process API for initializing the location table. / extern void _PyLineTable_InitAddressRange( const char linetable, Py_ssize_t length, int firstlineno, PyCodeAddressRange range); /* API for traversing the line number table. / extern int _PyLineTable_NextAddressRange(PyCodeAddressRange range); extern int _PyLineTable_PreviousAddressRange(PyCodeAddressRange range); / Specialization functions / extern int _Py_Specialize_LoadAttr(PyObject owner, _Py_CODEUNIT instr, PyObject name); extern int _Py_Specialize_StoreAttr(PyObject owner, _Py_CODEUNIT instr, PyObject name); extern int _Py_Specialize_LoadGlobal(PyObject globals, PyObject builtins, _Py_CODEUNIT instr, PyObject name); extern int _Py_Specialize_LoadMethod(PyObject owner, _Py_CODEUNIT instr, PyObject name); extern int _Py_Specialize_BinarySubscr(PyObject sub, PyObject container, _Py_CODEUNIT instr); extern int _Py_Specialize_StoreSubscr(PyObject container, PyObject sub, _Py_CODEUNIT instr); extern int _Py_Specialize_Call(PyObject callable, _Py_CODEUNIT instr, int nargs, PyObject kwnames); extern int _Py_Specialize_Precall(PyObject callable, _Py_CODEUNIT instr, int nargs, PyObject kwnames, int oparg); extern void _Py_Specialize_BinaryOp(PyObject lhs, PyObject rhs, _Py_CODEUNIT instr, int oparg, PyObject locals); extern void _Py_Specialize_CompareOp(PyObject lhs, PyObject rhs, _Py_CODEUNIT instr, int oparg); extern void _Py_Specialize_UnpackSequence(PyObject seq, _Py_CODEUNIT instr, int oparg); /* Deallocator function for static codeobjects used in deepfreeze.py / extern void _PyStaticCode_Dealloc(PyCodeObject co); /* Function to intern strings of codeobjects / extern int _PyStaticCode_InternStrings(PyCodeObject co); #ifdef Py_STATS #define SPECIALIZATION_FAILURE_KINDS 30 typedef struct _specialization_stats { uint64_t success; uint64_t failure; uint64_t hit; uint64_t deferred; uint64_t miss; uint64_t deopt; uint64_t failure_kinds[SPECIALIZATION_FAILURE_KINDS]; } SpecializationStats; typedef struct _opcode_stats { SpecializationStats specialization; uint64_t execution_count; uint64_t pair_count[256]; } OpcodeStats; typedef struct _call_stats { uint64_t inlined_py_calls; uint64_t pyeval_calls; uint64_t frames_pushed; uint64_t frame_objects_created; } CallStats; typedef struct _object_stats { uint64_t allocations; uint64_t allocations512; uint64_t allocations4k; uint64_t allocations_big; uint64_t frees; uint64_t to_freelist; uint64_t from_freelist; uint64_t new_values; uint64_t dict_materialized_on_request; uint64_t dict_materialized_new_key; uint64_t dict_materialized_too_big; uint64_t dict_materialized_str_subclass; } ObjectStats; typedef struct _stats { OpcodeStats opcode_stats[256]; CallStats call_stats; ObjectStats object_stats; } PyStats; extern PyStats _py_stats; #define STAT_INC(opname, name) _py_stats.opcode_stats[opname].specialization.name++ #define STAT_DEC(opname, name) _py_stats.opcode_stats[opname].specialization.name-- #define OPCODE_EXE_INC(opname) _py_stats.opcode_stats[opname].execution_count++ #define CALL_STAT_INC(name) _py_stats.call_stats.name++ #define OBJECT_STAT_INC(name) _py_stats.object_stats.name++ #define OBJECT_STAT_INC_COND(name, cond) \ do { if (cond) _py_stats.object_stats.name++; } while (0) extern void _Py_PrintSpecializationStats(int to_file); // Used by the _opcode extension which is built as a shared library PyAPI_FUNC(PyObject) _Py_GetSpecializationStats(void); #else #define STAT_INC(opname, name) ((void)0) #define STAT_DEC(opname, name) ((void)0) #define OPCODE_EXE_INC(opname) ((void)0) #define CALL_STAT_INC(name) ((void)0) #define OBJECT_STAT_INC(name) ((void)0) #define OBJECT_STAT_INC_COND(name, cond) ((void)0) #endif // !Py_STATS // Cache values are only valid in memory, so use native endianness. #ifdef WORDS_BIGENDIAN static inline void write_u32(uint16_t p, uint32_t val) { p[0] = (uint16_t)(val >> 16); p[1] = (uint16_t)(val >> 0); } static inline void write_u64(uint16_t p, uint64_t val) { p[0] = (uint16_t)(val >> 48); p[1] = (uint16_t)(val >> 32); p[2] = (uint16_t)(val >> 16); p[3] = (uint16_t)(val >> 0); } static inline uint32_t read_u32(uint16_t p) { uint32_t val = 0; val \|= (uint32_t)p[0] << 16; val \|= (uint32_t)p[1] << 0; return val; } static inline uint64_t read_u64(uint16_t p) { uint64_t val = 0; val \|= (uint64_t)p[0] << 48; val \|= (uint64_t)p[1] << 32; val \|= (uint64_t)p[2] << 16; val \|= (uint64_t)p[3] << 0; return val; } #else static inline void write_u32(uint16_t p, uint32_t val) { p[0] = (uint16_t)(val >> 0); p[1] = (uint16_t)(val >> 16); } static inline void write_u64(uint16_t p, uint64_t val) { p[0] = (uint16_t)(val >> 0); p[1] = (uint16_t)(val >> 16); p[2] = (uint16_t)(val >> 32); p[3] = (uint16_t)(val >> 48); } static inline uint32_t read_u32(uint16_t p) { uint32_t val = 0; val \|= (uint32_t)p[0] << 0; val \|= (uint32_t)p[1] << 16; return val; } static inline uint64_t read_u64(uint16_t p) { uint64_t val = 0; val \|= (uint64_t)p[0] << 0; val \|= (uint64_t)p[1] << 16; val \|= (uint64_t)p[2] << 32; val \|= (uint64_t)p[3] << 48; return val; } #endif static inline void write_obj(uint16_t p, PyObject obj) { uintptr_t val = (uintptr_t)obj; #if SIZEOF_VOID_P == 8 write_u64(p, val); #elif SIZEOF_VOID_P == 4 write_u32(p, val); #else #error "SIZEOF_VOID_P must be 4 or 8" #endif } static inline PyObject read_obj(uint16_t p) { uintptr_t val; #if SIZEOF_VOID_P == 8 val = read_u64(p); #elif SIZEOF_VOID_P == 4 val = read_u32(p); #else #error "SIZEOF_VOID_P must be 4 or 8" #endif return (PyObject )val; } /* See Objects/exception_handling_notes.txt for details. / static inline unsigned char parse_varint(unsigned char p, int result) { int val = p[0] & 63; while (p[0] & 64) { p++; val = (val << 6) \| (p[0] & 63); } result = val; return p+1; } static inline int write_varint(uint8_t ptr, unsigned int val) { int written = 1; while (val >= 64) { ptr++ = 64 \| (val & 63); val >>= 6; written++; } ptr = val; return written; } static inline int write_signed_varint(uint8_t ptr, int val) { if (val < 0) { val = ((-val)<<1) \| 1; } else { val = val << 1; } return write_varint(ptr, val); } static inline int write_location_entry_start(uint8_t ptr, int code, int length) { assert((code & 15) == code); ptr = 128 \| (code << 3) \| (length - 1); return 1; } /* Counters * The first 16-bit value in each inline cache is a counter. * When counting misses, the counter is treated as a simple unsigned value. * * When counting executions until the next specialization attempt, * exponential backoff is used to reduce the number of specialization failures. * The high 12 bits store the counter, the low 4 bits store the backoff exponent. * On a specialization failure, the backoff exponent is incremented and the * counter set to (2*backoff - 1). Backoff == 6 -> starting counter == 63, backoff == 10 -> starting counter == 1023. / / With a 16-bit counter, we have 12 bits for the counter value, and 4 bits for the backoff / #define ADAPTIVE_BACKOFF_BITS 4 / The initial counter value is 31 == 2*ADAPTIVE_BACKOFF_START - 1 / #define ADAPTIVE_BACKOFF_START 5 #define MAX_BACKOFF_VALUE (16 - ADAPTIVE_BACKOFF_BITS) static inline uint16_t adaptive_counter_bits(int value, int backoff) { return (value << ADAPTIVE_BACKOFF_BITS) \| (backoff & ((1<<ADAPTIVE_BACKOFF_BITS)-1)); } static inline uint16_t adaptive_counter_start(void) { unsigned int value = (1 << ADAPTIVE_BACKOFF_START) - 1; return adaptive_counter_bits(value, ADAPTIVE_BACKOFF_START); } static inline uint16_t adaptive_counter_backoff(uint16_t counter) { unsigned int backoff = counter & ((1<<ADAPTIVE_BACKOFF_BITS)-1); backoff++; if (backoff > MAX_BACKOFF_VALUE) { backoff = MAX_BACKOFF_VALUE; } unsigned int value = (1 << backoff) - 1; return adaptive_counter_bits(value, backoff); } /* Line array cache for tracing / extern int _PyCode_CreateLineArray(PyCodeObject co); static inline int _PyCode_InitLineArray(PyCodeObject co) { if (co->_co_linearray) { return 0; } return _PyCode_CreateLineArray(co); } static inline int _PyCode_LineNumberFromArray(PyCodeObject co, int index) { assert(co->_co_linearray != NULL); assert(index >= 0); assert(index < Py_SIZE(co)); if (co->_co_linearray_entry_size == 2) { return ((int16_t )co->_co_linearray)[index]; } else { assert(co->_co_linearray_entry_size == 4); return ((int32_t )co->_co_linearray)[index]; } } #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_CODE_H */	15.56 KB	2025-10-09 16:16
📄 pycore_compile.h #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 */	1.02 KB	2025-10-09 16:16
📄 pycore_condvar.h #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 library (e.g. gnu pth in pthread emulation) / # ifdef HAVE_PTHREAD_H # include <pthread.h> / _POSIX_THREADS / # endif #endif #ifdef _POSIX_THREADS / * POSIX support / #define Py_HAVE_CONDVAR #ifdef HAVE_PTHREAD_H # include <pthread.h> #endif #define PyMUTEX_T pthread_mutex_t #define PyCOND_T pthread_cond_t #elif defined(NT_THREADS) / * Windows (XP, 2003 server and later, as well as (hopefully) CE) support * * Emulated condition variables ones that work with XP and later, plus * example native support on VISTA and onwards. / #define Py_HAVE_CONDVAR / include windows if it hasn't been done before / #define WIN32_LEAN_AND_MEAN #include <windows.h> / options / / non-emulated condition variables are provided for those that want * to target Windows Vista. Modify this macro to enable them. / #ifndef _PY_EMULATED_WIN_CV #define _PY_EMULATED_WIN_CV 1 / use emulated condition variables / #endif / fall back to emulation if not targeting Vista / #if !defined NTDDI_VISTA \|\| NTDDI_VERSION < NTDDI_VISTA #undef _PY_EMULATED_WIN_CV #define _PY_EMULATED_WIN_CV 1 #endif #if _PY_EMULATED_WIN_CV typedef CRITICAL_SECTION PyMUTEX_T; / The ConditionVariable object. From XP onwards it is easily emulated with a Semaphore. Semaphores are available on Windows XP (2003 server) and later. We use a Semaphore rather than an auto-reset event, because although an auto-reset event might appear to solve the lost-wakeup bug (race condition between releasing the outer lock and waiting) because it maintains state even though a wait hasn't happened, there is still a lost wakeup problem if more than one thread are interrupted in the critical place. A semaphore solves that, because its state is counted, not Boolean. Because it is ok to signal a condition variable with no one waiting, we need to keep track of the number of waiting threads. Otherwise, the semaphore's state could rise without bound. This also helps reduce the number of "spurious wakeups" that would otherwise happen. / typedef struct _PyCOND_T { HANDLE sem; int waiting; / to allow PyCOND_SIGNAL to be a no-op / } PyCOND_T; #else / !_PY_EMULATED_WIN_CV / / Use native Win7 primitives if build target is Win7 or higher / / SRWLOCK is faster and better than CriticalSection / typedef SRWLOCK PyMUTEX_T; typedef CONDITION_VARIABLE PyCOND_T; #endif / _PY_EMULATED_WIN_CV / #endif / _POSIX_THREADS, NT_THREADS / #endif / Py_INTERNAL_CONDVAR_H */	2.77 KB	2025-10-09 16:16
📄 pycore_context.h #ifndef Py_INTERNAL_CONTEXT_H #define Py_INTERNAL_CONTEXT_H #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif #include "pycore_hamt.h" /* PyHamtObject / extern PyTypeObject _PyContextTokenMissing_Type; / runtime lifecycle / PyStatus _PyContext_Init(PyInterpreterState ); void _PyContext_Fini(PyInterpreterState ); / other API / #ifndef WITH_FREELISTS // without freelists # define PyContext_MAXFREELIST 0 #endif #ifndef PyContext_MAXFREELIST # define PyContext_MAXFREELIST 255 #endif struct _Py_context_state { #if PyContext_MAXFREELIST > 0 // List of free PyContext objects PyContext freelist; int numfree; #endif }; struct _pycontextobject { PyObject_HEAD PyContext ctx_prev; PyHamtObject ctx_vars; PyObject ctx_weakreflist; int ctx_entered; }; struct _pycontextvarobject { PyObject_HEAD PyObject var_name; PyObject var_default; PyObject var_cached; uint64_t var_cached_tsid; uint64_t var_cached_tsver; Py_hash_t var_hash; }; struct _pycontexttokenobject { PyObject_HEAD PyContext tok_ctx; PyContextVar tok_var; PyObject tok_oldval; int tok_used; }; #endif / !Py_INTERNAL_CONTEXT_H */	1.21 KB	2025-10-09 16:16
📄 pycore_dict.h #ifndef Py_INTERNAL_DICT_H #define Py_INTERNAL_DICT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif /* runtime lifecycle / extern void _PyDict_Fini(PyInterpreterState interp); /* other API / #ifndef WITH_FREELISTS // without freelists # define PyDict_MAXFREELIST 0 #endif #ifndef PyDict_MAXFREELIST # define PyDict_MAXFREELIST 80 #endif struct _Py_dict_state { #if PyDict_MAXFREELIST > 0 / 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; #endif }; typedef struct { / Cached hash code of me_key. / Py_hash_t me_hash; PyObject me_key; PyObject me_value; / This field is only meaningful for combined tables / } PyDictKeyEntry; typedef struct { PyObject me_key; /* The key must be Unicode and have hash. / PyObject me_value; /* This field is only meaningful for combined tables / } PyDictUnicodeEntry; extern PyDictKeysObject _PyDict_NewKeysForClass(void); extern PyObject _PyDict_FromKeys(PyObject , PyObject , PyObject ); /* Gets a version number unique to the current state of the keys of dict, if possible. * Returns the version number, or zero if it was not possible to get a version number. / extern uint32_t _PyDictKeys_GetVersionForCurrentState(PyDictKeysObject dictkeys); extern Py_ssize_t _PyDict_KeysSize(PyDictKeysObject keys); / _Py_dict_lookup() returns index of entry which can be used like DK_ENTRIES(dk)[index]. * -1 when no entry found, -3 when compare raises error. / extern Py_ssize_t _Py_dict_lookup(PyDictObject mp, PyObject key, Py_hash_t hash, PyObject value_addr); extern Py_ssize_t _PyDict_GetItemHint(PyDictObject , PyObject , Py_ssize_t, PyObject ); extern Py_ssize_t _PyDictKeys_StringLookup(PyDictKeysObject dictkeys, PyObject key); extern PyObject _PyDict_LoadGlobal(PyDictObject , PyDictObject , PyObject ); / Consumes references to key and value / extern int _PyDict_SetItem_Take2(PyDictObject op, PyObject key, PyObject value); extern int _PyObjectDict_SetItem(PyTypeObject tp, PyObject dictptr, PyObject name, PyObject value); extern PyObject _PyDict_Pop_KnownHash(PyObject , PyObject , Py_hash_t, PyObject ); #define DKIX_EMPTY (-1) #define DKIX_DUMMY (-2) / Used internally / #define DKIX_ERROR (-3) #define DKIX_KEY_CHANGED (-4) / Used internally / typedef enum { DICT_KEYS_GENERAL = 0, DICT_KEYS_UNICODE = 1, DICT_KEYS_SPLIT = 2 } DictKeysKind; / See dictobject.c for actual layout of DictKeysObject / struct _dictkeysobject { Py_ssize_t dk_refcnt; / Size of the hash table (dk_indices). It must be a power of 2. / uint8_t dk_log2_size; / Size of the hash table (dk_indices) by bytes. / uint8_t dk_log2_index_bytes; / Kind of keys / uint8_t dk_kind; / Version number -- Reset to 0 by any modification to keys / uint32_t dk_version; / Number of usable entries in dk_entries. / Py_ssize_t dk_usable; / Number of used entries in dk_entries. / Py_ssize_t dk_nentries; / Actual hash table of dk_size entries. It holds indices in dk_entries, or DKIX_EMPTY(-1) or DKIX_DUMMY(-2). Indices must be: 0 <= indice < USABLE_FRACTION(dk_size). The size in bytes of an indice depends on dk_size: - 1 byte if dk_size <= 0xff (char) - 2 bytes if dk_size <= 0xffff (int16_t) - 4 bytes if dk_size <= 0xffffffff (int32_t) - 8 bytes otherwise (int64_t) Dynamically sized, SIZEOF_VOID_P is minimum. / char dk_indices[]; / char is required to avoid strict aliasing. / / "PyDictKeyEntry or PyDictUnicodeEntry dk_entries[USABLE_FRACTION(DK_SIZE(dk))];" array follows: see the DK_ENTRIES() macro / }; / This must be no more than 250, for the prefix size to fit in one byte. / #define SHARED_KEYS_MAX_SIZE 30 #define NEXT_LOG2_SHARED_KEYS_MAX_SIZE 6 / Layout of dict values: * * The PyObject values are preceded by an array of bytes holding the insertion order and size. * [-1] = prefix size. [-2] = used size. size[-2-n...] = insertion order. / struct _dictvalues { PyObject values[1]; }; #define DK_LOG_SIZE(dk) ((dk)->dk_log2_size) #if SIZEOF_VOID_P > 4 #define DK_SIZE(dk) (((int64_t)1)<<DK_LOG_SIZE(dk)) #else #define DK_SIZE(dk) (1<<DK_LOG_SIZE(dk)) #endif #define DK_ENTRIES(dk) \ (assert(dk->dk_kind == DICT_KEYS_GENERAL), (PyDictKeyEntry)(&((int8_t)((dk)->dk_indices))[(size_t)1 << (dk)->dk_log2_index_bytes])) #define DK_UNICODE_ENTRIES(dk) \ (assert(dk->dk_kind != DICT_KEYS_GENERAL), (PyDictUnicodeEntry)(&((int8_t)((dk)->dk_indices))[(size_t)1 << (dk)->dk_log2_index_bytes])) #define DK_IS_UNICODE(dk) ((dk)->dk_kind != DICT_KEYS_GENERAL) extern uint64_t _pydict_global_version; #define DICT_NEXT_VERSION() (++_pydict_global_version) extern PyObject _PyObject_MakeDictFromInstanceAttributes(PyObject obj, PyDictValues values); extern PyObject _PyDict_FromItems( PyObject const keys, Py_ssize_t keys_offset, PyObject const values, Py_ssize_t values_offset, Py_ssize_t length); static inline void _PyDictValues_AddToInsertionOrder(PyDictValues values, Py_ssize_t ix) { assert(ix < SHARED_KEYS_MAX_SIZE); uint8_t size_ptr = ((uint8_t )values)-2; int size = size_ptr; assert(size+2 < ((uint8_t )values)[-1]); size++; size_ptr[-size] = (uint8_t)ix; size_ptr = size; } #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_DICT_H */	5.55 KB	2025-10-09 16:16
📄 pycore_dtoa.h #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif #include "pycore_pymath.h" // _PY_SHORT_FLOAT_REPR #if _PY_SHORT_FLOAT_REPR == 1 /* 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); PyAPI_FUNC(void) _Py_dg_freedtoa(char s); PyAPI_FUNC(double) _Py_dg_stdnan(int sign); PyAPI_FUNC(double) _Py_dg_infinity(int sign); #endif // _PY_SHORT_FLOAT_REPR == 1 #ifdef __cplusplus } #endif	704 B	2025-10-09 16:16
📄 pycore_emscripten_signal.h #ifndef Py_EMSCRIPTEN_SIGNAL_H #define Py_EMSCRIPTEN_SIGNAL_H #if defined(__EMSCRIPTEN__) void _Py_CheckEmscriptenSignals(void); void _Py_CheckEmscriptenSignalsPeriodically(void); #define _Py_CHECK_EMSCRIPTEN_SIGNALS() _Py_CheckEmscriptenSignals() #define _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY() _Py_CheckEmscriptenSignalsPeriodically() extern int Py_EMSCRIPTEN_SIGNAL_HANDLING; #else #define _Py_CHECK_EMSCRIPTEN_SIGNALS() #define _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY() #endif // defined(__EMSCRIPTEN__) #endif // ndef Py_EMSCRIPTEN_SIGNAL_H	562 B	2025-10-09 16:16
📄 pycore_exceptions.h #ifndef Py_INTERNAL_EXCEPTIONS_H #define Py_INTERNAL_EXCEPTIONS_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif /* runtime lifecycle / extern PyStatus _PyExc_InitState(PyInterpreterState ); extern PyStatus _PyExc_InitGlobalObjects(PyInterpreterState ); extern int _PyExc_InitTypes(PyInterpreterState ); extern void _PyExc_Fini(PyInterpreterState ); / other API / struct _Py_exc_state { // The dict mapping from errno codes to OSError subclasses PyObject errnomap; PyBaseExceptionObject memerrors_freelist; int memerrors_numfree; // The ExceptionGroup type PyObject PyExc_ExceptionGroup; }; extern void _PyExc_ClearExceptionGroupType(PyInterpreterState ); #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_EXCEPTIONS_H */	842 B	2025-10-09 16:16
📄 pycore_fileutils.h #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 <locale.h> /* struct lconv / 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(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 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 / // This is used after getting NULL back from Py_DecodeLocale(). #define DECODE_LOCALE_ERR(NAME, LEN) \ ((LEN) == (size_t)-2) \ ? _PyStatus_ERR("cannot decode " NAME) \ : _PyStatus_NO_MEMORY() 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); extern int _Py_wstat(const wchar_t , struct stat ); 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 extern int _Py_isabs(const wchar_t path); extern int _Py_abspath(const wchar_t path, wchar_t *abspath_p); #ifdef MS_WINDOWS extern int _PyOS_getfullpathname(const wchar_t path, wchar_t *abspath_p); #endif extern wchar_t _Py_join_relfile(const wchar_t dirname, const wchar_t relfile); extern int _Py_add_relfile(wchar_t dirname, const wchar_t relfile, size_t bufsize); extern size_t _Py_find_basename(const wchar_t filename); PyAPI_FUNC(wchar_t) _Py_normpath(wchar_t path, Py_ssize_t size); extern wchar_t _Py_normpath_and_size(wchar_t path, Py_ssize_t size, Py_ssize_t length); // Macros to protect CRT calls against instant termination when passed an // invalid parameter (bpo-23524). IPH stands for Invalid Parameter Handler. // Usage: // // _Py_BEGIN_SUPPRESS_IPH // ... // _Py_END_SUPPRESS_IPH #if defined _MSC_VER && _MSC_VER >= 1900 # include <stdlib.h> // _set_thread_local_invalid_parameter_handler() extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler; # define _Py_BEGIN_SUPPRESS_IPH \ { _invalid_parameter_handler _Py_old_handler = \ _set_thread_local_invalid_parameter_handler(_Py_silent_invalid_parameter_handler); # define _Py_END_SUPPRESS_IPH \ _set_thread_local_invalid_parameter_handler(_Py_old_handler); } #else # define _Py_BEGIN_SUPPRESS_IPH # define _Py_END_SUPPRESS_IPH #endif /* _MSC_VER >= 1900 / #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_FILEUTILS_H */	7.23 KB	2025-10-09 16:16
📄 pycore_floatobject.h #ifndef Py_INTERNAL_FLOATOBJECT_H #define Py_INTERNAL_FLOATOBJECT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif /* runtime lifecycle / extern void _PyFloat_InitState(PyInterpreterState ); extern PyStatus _PyFloat_InitTypes(PyInterpreterState ); extern void _PyFloat_Fini(PyInterpreterState ); extern void _PyFloat_FiniType(PyInterpreterState ); / other API / #ifndef WITH_FREELISTS // without freelists # define PyFloat_MAXFREELIST 0 #endif #ifndef PyFloat_MAXFREELIST # define PyFloat_MAXFREELIST 100 #endif struct _Py_float_state { #if PyFloat_MAXFREELIST > 0 / 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; #endif }; void _PyFloat_ExactDealloc(PyObject op); PyAPI_FUNC(void) _PyFloat_DebugMallocStats(FILE out); /* Format the object based on the format_spec, as defined in PEP 3101 (Advanced String Formatting). / PyAPI_FUNC(int) _PyFloat_FormatAdvancedWriter( _PyUnicodeWriter writer, PyObject obj, PyObject format_spec, Py_ssize_t start, Py_ssize_t end); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_FLOATOBJECT_H */	1.28 KB	2025-10-09 16:16
📄 pycore_format.h #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 */	480 B	2025-10-09 16:16
📄 pycore_frame.h #ifndef Py_INTERNAL_FRAME_H #define Py_INTERNAL_FRAME_H #ifdef __cplusplus extern "C" { #endif #include <stdbool.h> #include <stddef.h> /* See Objects/frame_layout.md for an explanation of the frame stack * including explanation of the PyFrameObject and _PyInterpreterFrame * structs. / struct _frame { PyObject_HEAD PyFrameObject f_back; /* previous frame, or NULL / struct _PyInterpreterFrame f_frame; /* points to the frame data / PyObject f_trace; /* Trace function / int f_lineno; / Current line number. Only valid if non-zero / char f_trace_lines; / Emit per-line trace events? / char f_trace_opcodes; / Emit per-opcode trace events? / char f_fast_as_locals; / Have the fast locals of this frame been converted to a dict? / / The frame data, if this frame object owns the frame / PyObject _f_frame_data[1]; }; extern PyFrameObject* _PyFrame_New_NoTrack(PyCodeObject code); / other API / typedef enum _framestate { FRAME_CREATED = -2, FRAME_SUSPENDED = -1, FRAME_EXECUTING = 0, FRAME_COMPLETED = 1, FRAME_CLEARED = 4 } PyFrameState; enum _frameowner { FRAME_OWNED_BY_THREAD = 0, FRAME_OWNED_BY_GENERATOR = 1, FRAME_OWNED_BY_FRAME_OBJECT = 2 }; typedef struct _PyInterpreterFrame { / "Specials" section / PyFunctionObject f_func; /* Strong reference / PyObject f_globals; /* Borrowed reference / PyObject f_builtins; /* Borrowed reference / PyObject f_locals; /* Strong reference, may be NULL / PyCodeObject f_code; /* Strong reference / PyFrameObject frame_obj; /* Strong reference, may be NULL / / Linkage section / struct _PyInterpreterFrame previous; // NOTE: This is not necessarily the last instruction started in the given // frame. Rather, it is the code unit prior to the next instruction. For // example, it may be an inline CACHE entry, an instruction we just jumped // over, or (in the case of a newly-created frame) a totally invalid value: _Py_CODEUNIT prev_instr; int stacktop; / Offset of TOS from localsplus / bool is_entry; // Whether this is the "root" frame for the current _PyCFrame. char owner; / Locals and stack / PyObject localsplus[1]; } _PyInterpreterFrame; #define _PyInterpreterFrame_LASTI(IF) \ ((int)((IF)->prev_instr - _PyCode_CODE((IF)->f_code))) static inline PyObject *_PyFrame_Stackbase(_PyInterpreterFrame f) { return f->localsplus + f->f_code->co_nlocalsplus; } static inline PyObject _PyFrame_StackPeek(_PyInterpreterFrame f) { assert(f->stacktop > f->f_code->co_nlocalsplus); assert(f->localsplus[f->stacktop-1] != NULL); return f->localsplus[f->stacktop-1]; } static inline PyObject _PyFrame_StackPop(_PyInterpreterFrame f) { assert(f->stacktop > f->f_code->co_nlocalsplus); f->stacktop--; return f->localsplus[f->stacktop]; } static inline void _PyFrame_StackPush(_PyInterpreterFrame f, PyObject value) { f->localsplus[f->stacktop] = value; f->stacktop++; } #define FRAME_SPECIALS_SIZE ((sizeof(_PyInterpreterFrame)-1)/sizeof(PyObject )) void _PyFrame_Copy(_PyInterpreterFrame src, _PyInterpreterFrame dest); / Consumes reference to func and locals. Does not initialize frame->previous, which happens when frame is linked into the frame stack. / static inline void _PyFrame_InitializeSpecials( _PyInterpreterFrame frame, PyFunctionObject func, PyObject locals, int nlocalsplus) { frame->f_func = func; frame->f_code = (PyCodeObject )Py_NewRef(func->func_code); frame->f_builtins = func->func_builtins; frame->f_globals = func->func_globals; frame->f_locals = Py_XNewRef(locals); frame->stacktop = nlocalsplus; frame->frame_obj = NULL; frame->prev_instr = _PyCode_CODE(frame->f_code) - 1; frame->is_entry = false; frame->owner = FRAME_OWNED_BY_THREAD; } / Gets the pointer to the locals array * that precedes this frame. / static inline PyObject* _PyFrame_GetLocalsArray(_PyInterpreterFrame frame) { return frame->localsplus; } static inline PyObject* _PyFrame_GetStackPointer(_PyInterpreterFrame frame) { return frame->localsplus+frame->stacktop; } static inline void _PyFrame_SetStackPointer(_PyInterpreterFrame frame, PyObject *stack_pointer) { frame->stacktop = (int)(stack_pointer - frame->localsplus); } / Determine whether a frame is incomplete. * A frame is incomplete if it is part way through * creating cell objects or a generator or coroutine. * * Frames on the frame stack are incomplete until the * first RESUME instruction. * Frames owned by a generator are always complete. / static inline bool _PyFrame_IsIncomplete(_PyInterpreterFrame frame) { return frame->owner != FRAME_OWNED_BY_GENERATOR && frame->prev_instr < _PyCode_CODE(frame->f_code) + frame->f_code->_co_firsttraceable; } /* For use by _PyFrame_GetFrameObject Do not call directly. / PyFrameObject _PyFrame_MakeAndSetFrameObject(_PyInterpreterFrame frame); / Gets the PyFrameObject for this frame, lazily * creating it if necessary. * Returns a borrowed referennce / static inline PyFrameObject _PyFrame_GetFrameObject(_PyInterpreterFrame frame) { assert(!_PyFrame_IsIncomplete(frame)); PyFrameObject res = frame->frame_obj; if (res != NULL) { return res; } return _PyFrame_MakeAndSetFrameObject(frame); } /* Clears all references in the frame. * If take is non-zero, then the _PyInterpreterFrame frame * may be transferred to the frame object it references * instead of being cleared. Either way * the caller no longer owns the references * in the frame. * take should be set to 1 for heap allocated * frames like the ones in generators and coroutines. / void _PyFrame_Clear(_PyInterpreterFrame frame); int _PyFrame_Traverse(_PyInterpreterFrame frame, visitproc visit, void arg); int _PyFrame_FastToLocalsWithError(_PyInterpreterFrame frame); void _PyFrame_LocalsToFast(_PyInterpreterFrame frame, int clear); extern _PyInterpreterFrame * _PyThreadState_BumpFramePointerSlow(PyThreadState tstate, size_t size); static inline bool _PyThreadState_HasStackSpace(PyThreadState tstate, size_t size) { assert( (tstate->datastack_top == NULL && tstate->datastack_limit == NULL) \|\| (tstate->datastack_top != NULL && tstate->datastack_limit != NULL) ); return tstate->datastack_top != NULL && size < (size_t)(tstate->datastack_limit - tstate->datastack_top); } static inline _PyInterpreterFrame * _PyThreadState_BumpFramePointer(PyThreadState tstate, size_t size) { if (_PyThreadState_HasStackSpace(tstate, size)) { _PyInterpreterFrame res = (_PyInterpreterFrame )tstate->datastack_top; tstate->datastack_top += size; return res; } return _PyThreadState_BumpFramePointerSlow(tstate, size); } void _PyThreadState_PopFrame(PyThreadState tstate, _PyInterpreterFrame frame); / Consume reference to func / _PyInterpreterFrame _PyFrame_Push(PyThreadState tstate, PyFunctionObject func); int _PyInterpreterFrame_GetLine(_PyInterpreterFrame frame); static inline PyGenObject _PyFrame_GetGenerator(_PyInterpreterFrame frame) { assert(frame->owner == FRAME_OWNED_BY_GENERATOR); size_t offset_in_gen = offsetof(PyGenObject, gi_iframe); return (PyGenObject )(((char )frame) - offset_in_gen); } #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_FRAME_H */	7.39 KB	2025-10-09 16:16
📄 pycore_function.h #ifndef Py_INTERNAL_FUNCTION_H #define Py_INTERNAL_FUNCTION_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif extern PyFunctionObject* _PyFunction_FromConstructor(PyFrameConstructor constr); extern uint32_t _PyFunction_GetVersionForCurrentState(PyFunctionObject func); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_FUNCTION_H */	413 B	2025-10-09 16:16
📄 pycore_gc.h #ifndef Py_INTERNAL_GC_H #define Py_INTERNAL_GC_H #ifdef __cplusplus extern "C" { #endif #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) #define _PyGC_Head_UNUSED PyGC_Head /* 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) _Py_RVALUE((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) \ _Py_RVALUE((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 / / If we change this, we need to change the default value in the signature of gc.collect. / #define NUM_GENERATIONS 3 / NOTE: about untracking of mutable objects. Certain types of container cannot participate in a reference cycle, and so do not need to be tracked by the garbage collector. Untracking these objects reduces the cost of garbage collections. However, determining which objects may be untracked is not free, and the costs must be weighed against the benefits for garbage collection. There are two possible strategies for when to untrack a container: i) When the container is created. ii) When the container is examined by the garbage collector. Tuples containing only immutable objects (integers, strings etc, and recursively, tuples of immutable objects) do not need to be tracked. The interpreter creates a large number of tuples, many of which will not survive until garbage collection. It is therefore not worthwhile to untrack eligible tuples at creation time. Instead, all tuples except the empty tuple are tracked when created. During garbage collection it is determined whether any surviving tuples can be untracked. A tuple can be untracked if all of its contents are already not tracked. Tuples are examined for untracking in all garbage collection cycles. It may take more than one cycle to untrack a tuple. Dictionaries containing only immutable objects also do not need to be tracked. Dictionaries are untracked when created. If a tracked item is inserted into a dictionary (either as a key or value), the dictionary becomes tracked. During a full garbage collection (all generations), the collector will untrack any dictionaries whose contents are not tracked. The module provides the python function is_tracked(obj), which returns the CURRENT tracking status of the object. Subsequent garbage collections may change the tracking status of the object. Untracking of certain containers was introduced in issue #4688, and the algorithm was refined in response to issue #14775. / struct gc_generation { PyGC_Head head; int threshold; / collection threshold / int count; / count of allocations or collections of younger generations / }; / Running stats per generation / struct gc_generation_stats { / total number of collections / Py_ssize_t collections; / total number of collected objects / Py_ssize_t collected; / total number of uncollectable objects (put into gc.garbage) / Py_ssize_t uncollectable; }; struct _gc_runtime_state { / List of objects that still need to be cleaned up, singly linked * via their gc headers' gc_prev pointers. / PyObject trash_delete_later; /* Current call-stack depth of tp_dealloc calls. / int trash_delete_nesting; / Is automatic collection enabled? / int enabled; int debug; / linked lists of container objects / struct gc_generation generations[NUM_GENERATIONS]; PyGC_Head generation0; /* a permanent generation which won't be collected / struct gc_generation permanent_generation; struct gc_generation_stats generation_stats[NUM_GENERATIONS]; / true if we are currently running the collector / int collecting; / list of uncollectable objects / PyObject garbage; /* a list of callbacks to be invoked when collection is performed / PyObject callbacks; /* This is the number of objects that survived the last full collection. It approximates the number of long lived objects tracked by the GC. (by "full collection", we mean a collection of the oldest generation). / Py_ssize_t long_lived_total; / This is the number of objects that survived all "non-full" collections, and are awaiting to undergo a full collection for the first time. / Py_ssize_t long_lived_pending; }; extern void _PyGC_InitState(struct _gc_runtime_state ); extern Py_ssize_t _PyGC_CollectNoFail(PyThreadState tstate); // Functions to clear types free lists 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_GC_H */	6.73 KB	2025-10-09 16:16
📄 pycore_genobject.h #ifndef Py_INTERNAL_GENOBJECT_H #define Py_INTERNAL_GENOBJECT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif extern PyObject _PyGen_yf(PyGenObject ); extern PyObject _PyCoro_GetAwaitableIter(PyObject o); extern PyObject _PyAsyncGenValueWrapperNew(PyObject ); /* runtime lifecycle / extern void _PyAsyncGen_Fini(PyInterpreterState ); /* other API / #ifndef WITH_FREELISTS // without freelists # define _PyAsyncGen_MAXFREELIST 0 #endif #ifndef _PyAsyncGen_MAXFREELIST # define _PyAsyncGen_MAXFREELIST 80 #endif struct _Py_async_gen_state { #if _PyAsyncGen_MAXFREELIST > 0 / 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; #endif }; #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_GENOBJECT_H */	1.14 KB	2025-10-09 16:16
📄 pycore_getopt.h #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 Py_ssize_t _PyOS_optind; extern const wchar_t _PyOS_optarg; extern void _PyOS_ResetGetOpt(void); typedef struct { const wchar_t name; int has_arg; int val; } _PyOS_LongOption; extern int _PyOS_GetOpt(Py_ssize_t argc, wchar_t * const argv, int longindex); #endif /* !Py_INTERNAL_PYGETOPT_H */	490 B	2025-10-09 16:16
📄 pycore_gil.h #ifndef Py_INTERNAL_GIL_H #define Py_INTERNAL_GIL_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_condvar.h" / PyCOND_T / #ifndef Py_HAVE_CONDVAR # error You need either a POSIX-compatible or a Windows system! #endif / Enable if you want to force the switching of threads at least every `interval`. / #undef FORCE_SWITCHING #define FORCE_SWITCHING struct _gil_runtime_state { / microseconds (the Python API uses seconds, though) / unsigned long interval; / Last PyThreadState holding / having held the GIL. This helps us know whether anyone else was scheduled after we dropped the GIL. / _Py_atomic_address last_holder; / Whether the GIL is already taken (-1 if uninitialized). This is atomic because it can be read without any lock taken in ceval.c. / _Py_atomic_int locked; / Number of GIL switches since the beginning. / unsigned long switch_number; / This condition variable allows one or several threads to wait until the GIL is released. In addition, the mutex also protects the above variables. / PyCOND_T cond; PyMUTEX_T mutex; #ifdef FORCE_SWITCHING / This condition variable helps the GIL-releasing thread wait for a GIL-awaiting thread to be scheduled and take the GIL. / PyCOND_T switch_cond; PyMUTEX_T switch_mutex; #endif }; #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_GIL_H */	1.53 KB	2025-10-09 16:16
📄 pycore_global_objects.h #ifndef Py_INTERNAL_GLOBAL_OBJECTS_H #define Py_INTERNAL_GLOBAL_OBJECTS_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif #include "pycore_gc.h" // PyGC_Head #include "pycore_global_strings.h" // struct _Py_global_strings // These would be in pycore_long.h if it weren't for an include cycle. #define _PY_NSMALLPOSINTS 257 #define _PY_NSMALLNEGINTS 5 // Only immutable objects should be considered runtime-global. // All others must be per-interpreter. #define _Py_GLOBAL_OBJECT(NAME) \ _PyRuntime.global_objects.NAME #define _Py_SINGLETON(NAME) \ _Py_GLOBAL_OBJECT(singletons.NAME) struct _Py_global_objects { struct { /* 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 (exclusive). / PyLongObject small_ints[_PY_NSMALLNEGINTS + _PY_NSMALLPOSINTS]; PyBytesObject bytes_empty; struct { PyBytesObject ob; char eos; } bytes_characters[256]; struct _Py_global_strings strings; _PyGC_Head_UNUSED _tuple_empty_gc_not_used; PyTupleObject tuple_empty; } singletons; }; #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_GLOBAL_OBJECTS_H */	1.4 KB	2025-10-09 16:16
📄 pycore_global_strings.h #ifndef Py_INTERNAL_GLOBAL_STRINGS_H #define Py_INTERNAL_GLOBAL_STRINGS_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif // The data structure & init here are inspired by Tools/scripts/deepfreeze.py. // All field names generated by ASCII_STR() have a common prefix, // to help avoid collisions with keywords, etc. #define STRUCT_FOR_ASCII_STR(LITERAL) \ struct { \ PyASCIIObject _ascii; \ uint8_t _data[sizeof(LITERAL)]; \ } #define STRUCT_FOR_STR(NAME, LITERAL) \ STRUCT_FOR_ASCII_STR(LITERAL) _ ## NAME; #define STRUCT_FOR_ID(NAME) \ STRUCT_FOR_ASCII_STR(#NAME) _ ## NAME; // XXX Order by frequency of use? /* The following is auto-generated by Tools/scripts/generate_global_objects.py. / struct _Py_global_strings { struct { STRUCT_FOR_STR(anon_dictcomp, "<dictcomp>") STRUCT_FOR_STR(anon_genexpr, "<genexpr>") STRUCT_FOR_STR(anon_lambda, "<lambda>") STRUCT_FOR_STR(anon_listcomp, "<listcomp>") STRUCT_FOR_STR(anon_module, "<module>") STRUCT_FOR_STR(anon_setcomp, "<setcomp>") STRUCT_FOR_STR(anon_string, "<string>") STRUCT_FOR_STR(anon_unknown, "<unknown>") STRUCT_FOR_STR(close_br, "}") STRUCT_FOR_STR(comma_sep, ", ") STRUCT_FOR_STR(dbl_close_br, "}}") STRUCT_FOR_STR(dbl_open_br, "{{") STRUCT_FOR_STR(dbl_percent, "%%") STRUCT_FOR_STR(dot, ".") STRUCT_FOR_STR(dot_locals, ".<locals>") STRUCT_FOR_STR(empty, "") STRUCT_FOR_STR(list_err, "list index out of range") STRUCT_FOR_STR(newline, "\n") STRUCT_FOR_STR(open_br, "{") STRUCT_FOR_STR(percent, "%") STRUCT_FOR_STR(utf_8, "utf-8") } literals; struct { STRUCT_FOR_ID(False) STRUCT_FOR_ID(Py_Repr) STRUCT_FOR_ID(TextIOWrapper) STRUCT_FOR_ID(True) STRUCT_FOR_ID(WarningMessage) STRUCT_FOR_ID(_) STRUCT_FOR_ID(__IOBase_closed) STRUCT_FOR_ID(__abc_tpflags__) STRUCT_FOR_ID(__abs__) STRUCT_FOR_ID(__abstractmethods__) STRUCT_FOR_ID(__add__) STRUCT_FOR_ID(__aenter__) STRUCT_FOR_ID(__aexit__) STRUCT_FOR_ID(__aiter__) STRUCT_FOR_ID(__all__) STRUCT_FOR_ID(__and__) STRUCT_FOR_ID(__anext__) STRUCT_FOR_ID(__annotations__) STRUCT_FOR_ID(__args__) STRUCT_FOR_ID(__await__) STRUCT_FOR_ID(__bases__) STRUCT_FOR_ID(__bool__) STRUCT_FOR_ID(__build_class__) STRUCT_FOR_ID(__builtins__) STRUCT_FOR_ID(__bytes__) STRUCT_FOR_ID(__call__) STRUCT_FOR_ID(__cantrace__) STRUCT_FOR_ID(__class__) STRUCT_FOR_ID(__class_getitem__) STRUCT_FOR_ID(__classcell__) STRUCT_FOR_ID(__complex__) STRUCT_FOR_ID(__contains__) STRUCT_FOR_ID(__copy__) STRUCT_FOR_ID(__del__) STRUCT_FOR_ID(__delattr__) STRUCT_FOR_ID(__delete__) STRUCT_FOR_ID(__delitem__) STRUCT_FOR_ID(__dict__) STRUCT_FOR_ID(__dir__) STRUCT_FOR_ID(__divmod__) STRUCT_FOR_ID(__doc__) STRUCT_FOR_ID(__enter__) STRUCT_FOR_ID(__eq__) STRUCT_FOR_ID(__exit__) STRUCT_FOR_ID(__file__) STRUCT_FOR_ID(__float__) STRUCT_FOR_ID(__floordiv__) STRUCT_FOR_ID(__format__) STRUCT_FOR_ID(__fspath__) STRUCT_FOR_ID(__ge__) STRUCT_FOR_ID(__get__) STRUCT_FOR_ID(__getattr__) STRUCT_FOR_ID(__getattribute__) STRUCT_FOR_ID(__getinitargs__) STRUCT_FOR_ID(__getitem__) STRUCT_FOR_ID(__getnewargs__) STRUCT_FOR_ID(__getnewargs_ex__) STRUCT_FOR_ID(__getstate__) STRUCT_FOR_ID(__gt__) STRUCT_FOR_ID(__hash__) STRUCT_FOR_ID(__iadd__) STRUCT_FOR_ID(__iand__) STRUCT_FOR_ID(__ifloordiv__) STRUCT_FOR_ID(__ilshift__) STRUCT_FOR_ID(__imatmul__) STRUCT_FOR_ID(__imod__) STRUCT_FOR_ID(__import__) STRUCT_FOR_ID(__imul__) STRUCT_FOR_ID(__index__) STRUCT_FOR_ID(__init__) STRUCT_FOR_ID(__init_subclass__) STRUCT_FOR_ID(__instancecheck__) STRUCT_FOR_ID(__int__) STRUCT_FOR_ID(__invert__) STRUCT_FOR_ID(__ior__) STRUCT_FOR_ID(__ipow__) STRUCT_FOR_ID(__irshift__) STRUCT_FOR_ID(__isabstractmethod__) STRUCT_FOR_ID(__isub__) STRUCT_FOR_ID(__iter__) STRUCT_FOR_ID(__itruediv__) STRUCT_FOR_ID(__ixor__) STRUCT_FOR_ID(__le__) STRUCT_FOR_ID(__len__) STRUCT_FOR_ID(__length_hint__) STRUCT_FOR_ID(__lltrace__) STRUCT_FOR_ID(__loader__) STRUCT_FOR_ID(__lshift__) STRUCT_FOR_ID(__lt__) STRUCT_FOR_ID(__main__) STRUCT_FOR_ID(__matmul__) STRUCT_FOR_ID(__missing__) STRUCT_FOR_ID(__mod__) STRUCT_FOR_ID(__module__) STRUCT_FOR_ID(__mro_entries__) STRUCT_FOR_ID(__mul__) STRUCT_FOR_ID(__name__) STRUCT_FOR_ID(__ne__) STRUCT_FOR_ID(__neg__) STRUCT_FOR_ID(__new__) STRUCT_FOR_ID(__newobj__) STRUCT_FOR_ID(__newobj_ex__) STRUCT_FOR_ID(__next__) STRUCT_FOR_ID(__notes__) STRUCT_FOR_ID(__or__) STRUCT_FOR_ID(__orig_class__) STRUCT_FOR_ID(__origin__) STRUCT_FOR_ID(__package__) STRUCT_FOR_ID(__parameters__) STRUCT_FOR_ID(__path__) STRUCT_FOR_ID(__pos__) STRUCT_FOR_ID(__pow__) STRUCT_FOR_ID(__prepare__) STRUCT_FOR_ID(__qualname__) STRUCT_FOR_ID(__radd__) STRUCT_FOR_ID(__rand__) STRUCT_FOR_ID(__rdivmod__) STRUCT_FOR_ID(__reduce__) STRUCT_FOR_ID(__reduce_ex__) STRUCT_FOR_ID(__repr__) STRUCT_FOR_ID(__reversed__) STRUCT_FOR_ID(__rfloordiv__) STRUCT_FOR_ID(__rlshift__) STRUCT_FOR_ID(__rmatmul__) STRUCT_FOR_ID(__rmod__) STRUCT_FOR_ID(__rmul__) STRUCT_FOR_ID(__ror__) STRUCT_FOR_ID(__round__) STRUCT_FOR_ID(__rpow__) STRUCT_FOR_ID(__rrshift__) STRUCT_FOR_ID(__rshift__) STRUCT_FOR_ID(__rsub__) STRUCT_FOR_ID(__rtruediv__) STRUCT_FOR_ID(__rxor__) STRUCT_FOR_ID(__set__) STRUCT_FOR_ID(__set_name__) STRUCT_FOR_ID(__setattr__) STRUCT_FOR_ID(__setitem__) STRUCT_FOR_ID(__setstate__) STRUCT_FOR_ID(__sizeof__) STRUCT_FOR_ID(__slotnames__) STRUCT_FOR_ID(__slots__) STRUCT_FOR_ID(__spec__) STRUCT_FOR_ID(__str__) STRUCT_FOR_ID(__sub__) STRUCT_FOR_ID(__subclasscheck__) STRUCT_FOR_ID(__subclasshook__) STRUCT_FOR_ID(__truediv__) STRUCT_FOR_ID(__trunc__) STRUCT_FOR_ID(__typing_is_unpacked_typevartuple__) STRUCT_FOR_ID(__typing_prepare_subst__) STRUCT_FOR_ID(__typing_subst__) STRUCT_FOR_ID(__typing_unpacked_tuple_args__) STRUCT_FOR_ID(__warningregistry__) STRUCT_FOR_ID(__weakref__) STRUCT_FOR_ID(__xor__) STRUCT_FOR_ID(_abc_impl) STRUCT_FOR_ID(_annotation) STRUCT_FOR_ID(_blksize) STRUCT_FOR_ID(_bootstrap) STRUCT_FOR_ID(_dealloc_warn) STRUCT_FOR_ID(_finalizing) STRUCT_FOR_ID(_find_and_load) STRUCT_FOR_ID(_fix_up_module) STRUCT_FOR_ID(_get_sourcefile) STRUCT_FOR_ID(_handle_fromlist) STRUCT_FOR_ID(_initializing) STRUCT_FOR_ID(_is_text_encoding) STRUCT_FOR_ID(_lock_unlock_module) STRUCT_FOR_ID(_showwarnmsg) STRUCT_FOR_ID(_shutdown) STRUCT_FOR_ID(_slotnames) STRUCT_FOR_ID(_strptime_time) STRUCT_FOR_ID(_uninitialized_submodules) STRUCT_FOR_ID(_warn_unawaited_coroutine) STRUCT_FOR_ID(_xoptions) STRUCT_FOR_ID(add) STRUCT_FOR_ID(append) STRUCT_FOR_ID(big) STRUCT_FOR_ID(buffer) STRUCT_FOR_ID(builtins) STRUCT_FOR_ID(c_call) STRUCT_FOR_ID(c_exception) STRUCT_FOR_ID(c_return) STRUCT_FOR_ID(call) STRUCT_FOR_ID(clear) STRUCT_FOR_ID(close) STRUCT_FOR_ID(closed) STRUCT_FOR_ID(code) STRUCT_FOR_ID(copy) STRUCT_FOR_ID(copyreg) STRUCT_FOR_ID(decode) STRUCT_FOR_ID(default) STRUCT_FOR_ID(defaultaction) STRUCT_FOR_ID(dictcomp) STRUCT_FOR_ID(difference_update) STRUCT_FOR_ID(dispatch_table) STRUCT_FOR_ID(displayhook) STRUCT_FOR_ID(enable) STRUCT_FOR_ID(encode) STRUCT_FOR_ID(encoding) STRUCT_FOR_ID(end_lineno) STRUCT_FOR_ID(end_offset) STRUCT_FOR_ID(errors) STRUCT_FOR_ID(excepthook) STRUCT_FOR_ID(exception) STRUCT_FOR_ID(extend) STRUCT_FOR_ID(filename) STRUCT_FOR_ID(fileno) STRUCT_FOR_ID(fillvalue) STRUCT_FOR_ID(filters) STRUCT_FOR_ID(find_class) STRUCT_FOR_ID(flush) STRUCT_FOR_ID(genexpr) STRUCT_FOR_ID(get) STRUCT_FOR_ID(get_source) STRUCT_FOR_ID(getattr) STRUCT_FOR_ID(getstate) STRUCT_FOR_ID(ignore) STRUCT_FOR_ID(importlib) STRUCT_FOR_ID(inf) STRUCT_FOR_ID(intersection) STRUCT_FOR_ID(isatty) STRUCT_FOR_ID(isinstance) STRUCT_FOR_ID(items) STRUCT_FOR_ID(iter) STRUCT_FOR_ID(join) STRUCT_FOR_ID(keys) STRUCT_FOR_ID(lambda) STRUCT_FOR_ID(last_traceback) STRUCT_FOR_ID(last_type) STRUCT_FOR_ID(last_value) STRUCT_FOR_ID(latin1) STRUCT_FOR_ID(len) STRUCT_FOR_ID(line) STRUCT_FOR_ID(lineno) STRUCT_FOR_ID(listcomp) STRUCT_FOR_ID(little) STRUCT_FOR_ID(locale) STRUCT_FOR_ID(match) STRUCT_FOR_ID(metaclass) STRUCT_FOR_ID(mode) STRUCT_FOR_ID(modules) STRUCT_FOR_ID(mro) STRUCT_FOR_ID(msg) STRUCT_FOR_ID(n_fields) STRUCT_FOR_ID(n_sequence_fields) STRUCT_FOR_ID(n_unnamed_fields) STRUCT_FOR_ID(name) STRUCT_FOR_ID(newlines) STRUCT_FOR_ID(next) STRUCT_FOR_ID(obj) STRUCT_FOR_ID(offset) STRUCT_FOR_ID(onceregistry) STRUCT_FOR_ID(opcode) STRUCT_FOR_ID(open) STRUCT_FOR_ID(parent) STRUCT_FOR_ID(partial) STRUCT_FOR_ID(path) STRUCT_FOR_ID(peek) STRUCT_FOR_ID(persistent_id) STRUCT_FOR_ID(persistent_load) STRUCT_FOR_ID(print_file_and_line) STRUCT_FOR_ID(ps1) STRUCT_FOR_ID(ps2) STRUCT_FOR_ID(raw) STRUCT_FOR_ID(read) STRUCT_FOR_ID(read1) STRUCT_FOR_ID(readable) STRUCT_FOR_ID(readall) STRUCT_FOR_ID(readinto) STRUCT_FOR_ID(readinto1) STRUCT_FOR_ID(readline) STRUCT_FOR_ID(reducer_override) STRUCT_FOR_ID(reload) STRUCT_FOR_ID(replace) STRUCT_FOR_ID(reset) STRUCT_FOR_ID(return) STRUCT_FOR_ID(reversed) STRUCT_FOR_ID(seek) STRUCT_FOR_ID(seekable) STRUCT_FOR_ID(send) STRUCT_FOR_ID(setcomp) STRUCT_FOR_ID(setstate) STRUCT_FOR_ID(sort) STRUCT_FOR_ID(stderr) STRUCT_FOR_ID(stdin) STRUCT_FOR_ID(stdout) STRUCT_FOR_ID(strict) STRUCT_FOR_ID(symmetric_difference_update) STRUCT_FOR_ID(tell) STRUCT_FOR_ID(text) STRUCT_FOR_ID(threading) STRUCT_FOR_ID(throw) STRUCT_FOR_ID(top) STRUCT_FOR_ID(truncate) STRUCT_FOR_ID(unraisablehook) STRUCT_FOR_ID(values) STRUCT_FOR_ID(version) STRUCT_FOR_ID(warnings) STRUCT_FOR_ID(warnoptions) STRUCT_FOR_ID(writable) STRUCT_FOR_ID(write) STRUCT_FOR_ID(zipimporter) } identifiers; struct { PyASCIIObject _ascii; uint8_t _data[2]; } ascii[128]; struct { PyCompactUnicodeObject _latin1; uint8_t _data[2]; } latin1[128]; }; / End auto-generated code / #undef ID #undef STR #define _Py_ID(NAME) \ (_Py_SINGLETON(strings.identifiers._ ## NAME._ascii.ob_base)) #define _Py_STR(NAME) \ (_Py_SINGLETON(strings.literals._ ## NAME._ascii.ob_base)) / _Py_DECLARE_STR() should precede all uses of _Py_STR() in a function. This is true even if the same string has already been declared elsewhere, even in the same file. Mismatched duplicates are detected by Tools/scripts/generate-global-objects.py. Pairing _Py_DECLARE_STR() with every use of _Py_STR() makes sure the string keeps working even if the declaration is removed somewhere else. It also makes it clear what the actual string is at every place it is being used. / #define _Py_DECLARE_STR(name, str) #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_GLOBAL_STRINGS_H */	12.68 KB	2025-10-09 16:16
📄 pycore_hamt.h #ifndef Py_INTERNAL_HAMT_H #define Py_INTERNAL_HAMT_H #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif /* 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`. This constant is used to define a datastucture for storing iteration state. / #define _Py_HAMT_MAX_TREE_DEPTH 8 extern PyTypeObject _PyHamt_Type; extern PyTypeObject _PyHamt_ArrayNode_Type; extern PyTypeObject _PyHamt_BitmapNode_Type; extern PyTypeObject _PyHamt_CollisionNode_Type; extern PyTypeObject _PyHamtKeys_Type; extern PyTypeObject _PyHamtValues_Type; extern PyTypeObject _PyHamtItems_Type; / runtime lifecycle / void _PyHamt_Fini(PyInterpreterState ); /* other API / #define PyHamt_Check(o) Py_IS_TYPE(o, &_PyHamt_Type) / Abstract tree node. / typedef struct { PyObject_HEAD } PyHamtNode; / An HAMT immutable mapping collection. / typedef struct { PyObject_HEAD PyHamtNode h_root; PyObject h_weakreflist; Py_ssize_t h_count; } PyHamtObject; / A struct to hold the state of depth-first traverse of the tree. HAMT is an immutable collection. Iterators will hold a strong reference to it, and every node in the HAMT has strong references to its children. So for iterators, we can implement zero allocations and zero reference inc/dec depth-first iteration. - i_nodes: an array of seven pointers to tree nodes - i_level: the current node in i_nodes - i_pos: an array of positions within nodes in i_nodes. / typedef struct { PyHamtNode i_nodes[_Py_HAMT_MAX_TREE_DEPTH]; Py_ssize_t i_pos[_Py_HAMT_MAX_TREE_DEPTH]; int8_t i_level; } PyHamtIteratorState; /* Base iterator object. Contains the iteration state, a pointer to the HAMT tree, and a pointer to the 'yield function'. The latter is a simple function that returns a key/value tuple for the 'Items' iterator, just a key for the 'Keys' iterator, and a value for the 'Values' iterator. / typedef struct { PyObject_HEAD PyHamtObject hi_obj; PyHamtIteratorState hi_iter; binaryfunc hi_yield; } PyHamtIterator; /* Create a new HAMT immutable mapping. / PyHamtObject _PyHamt_New(void); /* Return a new collection based on "o", but with an additional key/val pair. / PyHamtObject _PyHamt_Assoc(PyHamtObject o, PyObject key, PyObject val); / Return a new collection based on "o", but without "key". / PyHamtObject _PyHamt_Without(PyHamtObject o, PyObject key); /* Find "key" in the "o" collection. Return: - -1: An error occurred. - 0: "key" wasn't found in "o". - 1: "key" is in "o"; "val" is set to its value (a borrowed ref). / int _PyHamt_Find(PyHamtObject o, PyObject key, PyObject *val); / Check if "v" is equal to "w". Return: - 0: v != w - 1: v == w - -1: An error occurred. / int _PyHamt_Eq(PyHamtObject v, PyHamtObject w); / Return the size of "o"; equivalent of "len(o)". / Py_ssize_t _PyHamt_Len(PyHamtObject o); /* Return a Keys iterator over "o". / PyObject _PyHamt_NewIterKeys(PyHamtObject o); / Return a Values iterator over "o". / PyObject _PyHamt_NewIterValues(PyHamtObject o); / Return a Items iterator over "o". / PyObject _PyHamt_NewIterItems(PyHamtObject o); #endif / !Py_INTERNAL_HAMT_H */	3.61 KB	2025-10-09 16:16
📄 pycore_hashtable.h #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 */	4.1 KB	2025-10-09 16:16
📄 pycore_import.h #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); struct _module_alias { const char name; /* ASCII encoded string / const char orig; /* ASCII encoded string / }; PyAPI_DATA(const struct _frozen ) _PyImport_FrozenBootstrap; PyAPI_DATA(const struct _frozen ) _PyImport_FrozenStdlib; PyAPI_DATA(const struct _frozen ) _PyImport_FrozenTest; extern const struct _module_alias * _PyImport_FrozenAliases; #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_IMPORT_H / #endif / !Py_LIMITED_API */	743 B	2025-10-09 16:16
📄 pycore_initconfig.h #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_InitImportConfig(PyConfig 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); extern void _Py_DumpPathConfig(PyThreadState tstate); PyAPI_FUNC(PyObject) _Py_Get_Getpath_CodeObject(void); extern int _Py_global_config_int_max_str_digits; / --- Function used for testing ---------------------------------- / PyAPI_FUNC(PyObject) _Py_GetConfigsAsDict(void); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_CORECONFIG_H */	5.66 KB	2025-10-09 16:16
📄 pycore_interp.h #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 <stdbool.h> #include "pycore_atomic.h" // _Py_atomic_address #include "pycore_ast_state.h" // struct ast_state #include "pycore_code.h" // struct callable_cache #include "pycore_context.h" // struct _Py_context_state #include "pycore_dict.h" // struct _Py_dict_state #include "pycore_exceptions.h" // struct _Py_exc_state #include "pycore_floatobject.h" // struct _Py_float_state #include "pycore_genobject.h" // struct _Py_async_gen_state #include "pycore_gil.h" // struct _gil_runtime_state #include "pycore_gc.h" // struct _gc_runtime_state #include "pycore_list.h" // struct _Py_list_state #include "pycore_tuple.h" // struct _Py_tuple_state #include "pycore_typeobject.h" // struct type_cache #include "pycore_unicodeobject.h" // struct _Py_unicode_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; }; // atexit state typedef struct { PyObject func; PyObject args; PyObject kwargs; } atexit_callback; struct atexit_state { atexit_callback *callbacks; int ncallbacks; int callback_len; }; / interpreter state / / PyInterpreterState holds the global state for one of the runtime's interpreters. Typically the initial (main) interpreter is the only one. The PyInterpreterState typedef is in Include/pystate.h. / struct _is { PyInterpreterState next; struct pythreads { uint64_t next_unique_id; /* The linked list of threads, newest first. / PyThreadState head; /* Used in Modules/_threadmodule.c. / long count; / 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 stacksize; } threads; / 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; /* Has been initialized to a safe state. In order to be effective, this must be set to 0 during or right after allocation. / int _initialized; int finalizing; / Was this interpreter statically allocated? / bool _static; 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; // override for config->use_frozen_modules (for tests) // (-1: "off", 1: "on", 0: no override) int override_frozen_modules; 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 struct _warnings_runtime_state warnings; struct atexit_state atexit; PyObject audit_hooks; 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_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; struct callable_cache callable_cache; int int_max_str_digits; /* The following fields are here to avoid allocation during init. The data is exposed through PyInterpreterState pointer fields. These fields should not be accessed directly outside of init. All other PyInterpreterState pointer fields are populated when needed and default to NULL. For now there are some exceptions to that rule, which require allocation during init. These will be addressed on a case-by-case basis. Also see _PyRuntimeState regarding the various mutex fields. / / the initial PyInterpreterState.threads.head / PyThreadState _initial_thread; }; / other API / 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(PyInterpreterState) _PyInterpreterState_LookUpID(int64_t); PyAPI_FUNC(int) _PyInterpreterState_IDInitref(PyInterpreterState ); PyAPI_FUNC(int) _PyInterpreterState_IDIncref(PyInterpreterState ); PyAPI_FUNC(void) _PyInterpreterState_IDDecref(PyInterpreterState ); #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_INTERP_H */	6.51 KB	2025-10-09 16:16
📄 pycore_interpreteridobject.h /* Interpreter ID Object / #ifndef Py_INTERNAL_INTERPRETERIDOBJECT_H #define Py_INTERNAL_INTERPRETERIDOBJECT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif PyAPI_DATA(PyTypeObject) _PyInterpreterID_Type; PyAPI_FUNC(PyObject ) _PyInterpreterID_New(int64_t); PyAPI_FUNC(PyObject ) _PyInterpreterState_GetIDObject(PyInterpreterState ); PyAPI_FUNC(PyInterpreterState ) _PyInterpreterID_LookUp(PyObject ); #ifdef __cplusplus } #endif #endif // !Py_INTERNAL_INTERPRETERIDOBJECT_H	562 B	2025-10-09 16:16
📄 pycore_list.h #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() /* runtime lifecycle / extern void _PyList_Fini(PyInterpreterState ); /* other API / #ifndef WITH_FREELISTS // without freelists # define PyList_MAXFREELIST 0 #endif / Empty list reuse scheme to save calls to malloc and free / #ifndef PyList_MAXFREELIST # define PyList_MAXFREELIST 80 #endif struct _Py_list_state { #if PyList_MAXFREELIST > 0 PyListObject free_list[PyList_MAXFREELIST]; int numfree; #endif }; #define _PyList_ITEMS(op) (_PyList_CAST(op)->ob_item) extern int _PyList_AppendTakeRefListResize(PyListObject self, PyObject newitem); static inline int _PyList_AppendTakeRef(PyListObject self, PyObject newitem) { assert(self != NULL && newitem != NULL); assert(PyList_Check(self)); Py_ssize_t len = PyList_GET_SIZE(self); Py_ssize_t allocated = self->allocated; assert((size_t)len + 1 < PY_SSIZE_T_MAX); if (allocated > len) { PyList_SET_ITEM(self, len, newitem); Py_SET_SIZE(self, len + 1); return 0; } return _PyList_AppendTakeRefListResize(self, newitem); } #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_LIST_H */	1.32 KB	2025-10-09 16:16
📄 pycore_long.h #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_global_objects.h" // _PY_NSMALLNEGINTS #include "pycore_runtime.h" // _PyRuntime /* * Default int base conversion size limitation: Denial of Service prevention. * * Chosen such that this isn't wildly slow on modern hardware and so that * everyone's existing deployed numpy test suite passes before * https://github.com/numpy/numpy/issues/22098 is widely available. * * $ python -m timeit -s 's = "1"4300' 'int(s)' 2000 loops, best of 5: 125 usec per loop * $ python -m timeit -s 's = "1"4300; v = int(s)' 'str(v)' 1000 loops, best of 5: 311 usec per loop * (zen2 cloud VM) * * 4300 decimal digits fits a ~14284 bit number. / #define _PY_LONG_DEFAULT_MAX_STR_DIGITS 4300 / * Threshold for max digits check. For performance reasons int() and * int.__str__() don't checks values that are smaller than this * threshold. Acts as a guaranteed minimum size limit for bignums that * applications can expect from CPython. * * % python -m timeit -s 's = "1"640; v = int(s)' 'str(int(s))' 20000 loops, best of 5: 12 usec per loop * * "640 digits should be enough for anyone." - gps * fits a ~2126 bit decimal number. / #define _PY_LONG_MAX_STR_DIGITS_THRESHOLD 640 #if ((_PY_LONG_DEFAULT_MAX_STR_DIGITS != 0) && \ (_PY_LONG_DEFAULT_MAX_STR_DIGITS < _PY_LONG_MAX_STR_DIGITS_THRESHOLD)) # error "_PY_LONG_DEFAULT_MAX_STR_DIGITS smaller than threshold." #endif / runtime lifecycle / extern PyStatus _PyLong_InitTypes(PyInterpreterState ); extern void _PyLong_FiniTypes(PyInterpreterState interp); / other API / #define _PyLong_SMALL_INTS _Py_SINGLETON(small_ints) // _PyLong_GetZero() and _PyLong_GetOne() must always be available // _PyLong_FromUnsignedChar must always be available #if _PY_NSMALLPOSINTS < 257 # error "_PY_NSMALLPOSINTS must be greater than or equal to 257" #endif // Return a borrowed reference to the zero singleton. // The function cannot return NULL. static inline PyObject _PyLong_GetZero(void) { return (PyObject )&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS]; } // Return a borrowed reference to the one singleton. // The function cannot return NULL. static inline PyObject _PyLong_GetOne(void) { return (PyObject )&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS+1]; } static inline PyObject _PyLong_FromUnsignedChar(unsigned char i) { return Py_NewRef((PyObject )&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS+i]); } PyObject _PyLong_Add(PyLongObject left, PyLongObject right); PyObject _PyLong_Multiply(PyLongObject left, PyLongObject right); PyObject _PyLong_Subtract(PyLongObject left, PyLongObject right); /* Used by Python/mystrtoul.c, _PyBytes_FromHex(), _PyBytes_DecodeEscape(), etc. / PyAPI_DATA(unsigned char) _PyLong_DigitValue[256]; / Format the object based on the format_spec, as defined in PEP 3101 (Advanced String Formatting). / PyAPI_FUNC(int) _PyLong_FormatAdvancedWriter( _PyUnicodeWriter writer, PyObject obj, PyObject format_spec, Py_ssize_t start, Py_ssize_t end); PyAPI_FUNC(int) _PyLong_FormatWriter( _PyUnicodeWriter writer, PyObject obj, int base, int alternate); PyAPI_FUNC(char) _PyLong_FormatBytesWriter( _PyBytesWriter writer, char str, PyObject obj, int base, int alternate); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_LONG_H */	3.43 KB	2025-10-09 16:16
📄 pycore_moduleobject.h #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; 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 */	1.02 KB	2025-10-09 16:16
📄 pycore_namespace.h // Simple namespace object interface #ifndef Py_INTERNAL_NAMESPACE_H #define Py_INTERNAL_NAMESPACE_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif PyAPI_DATA(PyTypeObject) _PyNamespace_Type; PyAPI_FUNC(PyObject ) _PyNamespace_New(PyObject kwds); #ifdef __cplusplus } #endif #endif // !Py_INTERNAL_NAMESPACE_H	392 B	2025-10-09 16:16
📄 pycore_object.h #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 <stdbool.h> #include "pycore_gc.h" // _PyObject_GC_IS_TRACKED() #include "pycore_interp.h" // PyInterpreterState.gc #include "pycore_pystate.h" // _PyInterpreterState_GET() #include "pycore_runtime.h" // _PyRuntime #define _PyObject_IMMORTAL_INIT(type) \ { \ .ob_refcnt = 999999999, \ .ob_type = type, \ } #define _PyVarObject_IMMORTAL_INIT(type, size) \ { \ .ob_base = _PyObject_IMMORTAL_INIT(type), \ .ob_size = size, \ } PyAPI_FUNC(void) _Py_NO_RETURN _Py_FatalRefcountErrorFunc( const char func, const char message); #define _Py_FatalRefcountError(message) _Py_FatalRefcountErrorFunc(__func__, message) static inline void _Py_DECREF_SPECIALIZED(PyObject op, const destructor destruct) { #ifdef Py_REF_DEBUG _Py_RefTotal--; #endif if (--op->ob_refcnt != 0) { assert(op->ob_refcnt > 0); } else { #ifdef Py_TRACE_REFS _Py_ForgetReference(op); #endif destruct(op); } } static inline void _Py_DECREF_NO_DEALLOC(PyObject op) { #ifdef Py_REF_DEBUG _Py_RefTotal--; #endif op->ob_refcnt--; #ifdef Py_DEBUG if (op->ob_refcnt <= 0) { _Py_FatalRefcountError("Expected a positive remaining refcount"); } #endif } 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); /* 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) static inline size_t _PyType_PreHeaderSize(PyTypeObject tp) { return _PyType_IS_GC(tp) * sizeof(PyGC_Head) + _PyType_HasFeature(tp, Py_TPFLAGS_MANAGED_DICT) * 2 * sizeof(PyObject ); } void _PyObject_GC_Link(PyObject op); // 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) // Test if a type supports weak references static inline int _PyType_SUPPORTS_WEAKREFS(PyTypeObject type) { return (type->tp_weaklistoffset > 0); } extern PyObject _PyType_AllocNoTrack(PyTypeObject type, Py_ssize_t nitems); extern int _PyObject_InitializeDict(PyObject obj); extern int _PyObject_StoreInstanceAttribute(PyObject obj, PyDictValues values, PyObject name, PyObject value); PyObject * _PyObject_GetInstanceAttribute(PyObject obj, PyDictValues values, PyObject name); static inline PyDictValues _PyObject_ValuesPointer(PyObject obj) { assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT); return ((PyDictValues )obj)-4; } static inline PyObject _PyObject_ManagedDictPointer(PyObject obj) { assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT); return ((PyObject )obj)-3; } #define MANAGED_DICT_OFFSET (((int)sizeof(PyObject ))-3) extern PyObject * _PyObject_DictPointer(PyObject ); extern int _PyObject_VisitInstanceAttributes(PyObject self, visitproc visit, void arg); extern void _PyObject_ClearInstanceAttributes(PyObject self); extern void _PyObject_FreeInstanceAttributes(PyObject self); extern int _PyObject_IsInstanceDictEmpty(PyObject ); extern PyObject* _PyType_GetSubclasses(PyTypeObject ); // 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(PyObject ) _PyObject_LookupSpecial(PyObject , PyObject ); /* C function call trampolines to mitigate bad function pointer casts. * * Typical native ABIs ignore additional arguments or fill in missing * values with 0/NULL in function pointer cast. Compilers do not show * warnings when a function pointer is explicitly casted to an * incompatible type. * * Bad fpcasts are an issue in WebAssembly. WASM's indirect_call has strict * function signature checks. Argument count, types, and return type must * match. * * Third party code unintentionally rely on problematic fpcasts. The call * trampoline mitigates common occurences of bad fpcasts on Emscripten. / #if defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE) #define _PyCFunction_TrampolineCall(meth, self, args) \ _PyCFunctionWithKeywords_TrampolineCall( \ ((PyCFunctionWithKeywords)(void()(void))meth), self, args, NULL) extern PyObject _PyCFunctionWithKeywords_TrampolineCall( PyCFunctionWithKeywords meth, PyObject , PyObject , PyObject ); #else #define _PyCFunction_TrampolineCall(meth, self, args) \ (meth)((self), (args)) #define _PyCFunctionWithKeywords_TrampolineCall(meth, self, args, kw) \ (meth)((self), (args), (kw)) #endif // __EMSCRIPTEN__ && PY_CALL_TRAMPOLINE #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_OBJECT_H */	9.8 KB	2025-10-09 16:16
📄 pycore_opcode.h // Auto-generated by Tools/scripts/generate_opcode_h.py from Lib/opcode.py #ifndef Py_INTERNAL_OPCODE_H #define Py_INTERNAL_OPCODE_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif #include "opcode.h" extern const uint8_t _PyOpcode_Caches[256]; extern const uint8_t _PyOpcode_Deopt[256]; #ifdef NEED_OPCODE_TABLES static const uint32_t _PyOpcode_RelativeJump[8] = { 0U, 0U, 536870912U, 135118848U, 4163U, 122880U, 0U, 0U, }; static const uint32_t _PyOpcode_Jump[8] = { 0U, 0U, 536870912U, 135118848U, 4163U, 122880U, 0U, 0U, }; const uint8_t _PyOpcode_Caches[256] = { [BINARY_SUBSCR] = 4, [STORE_SUBSCR] = 1, [UNPACK_SEQUENCE] = 1, [STORE_ATTR] = 4, [LOAD_ATTR] = 4, [COMPARE_OP] = 2, [LOAD_GLOBAL] = 5, [BINARY_OP] = 1, [LOAD_METHOD] = 10, [PRECALL] = 1, [CALL] = 4, }; const uint8_t _PyOpcode_Deopt[256] = { [ASYNC_GEN_WRAP] = ASYNC_GEN_WRAP, [BEFORE_ASYNC_WITH] = BEFORE_ASYNC_WITH, [BEFORE_WITH] = BEFORE_WITH, [BINARY_OP] = BINARY_OP, [BINARY_OP_ADAPTIVE] = BINARY_OP, [BINARY_OP_ADD_FLOAT] = BINARY_OP, [BINARY_OP_ADD_INT] = BINARY_OP, [BINARY_OP_ADD_UNICODE] = BINARY_OP, [BINARY_OP_INPLACE_ADD_UNICODE] = BINARY_OP, [BINARY_OP_MULTIPLY_FLOAT] = BINARY_OP, [BINARY_OP_MULTIPLY_INT] = BINARY_OP, [BINARY_OP_SUBTRACT_FLOAT] = BINARY_OP, [BINARY_OP_SUBTRACT_INT] = BINARY_OP, [BINARY_SUBSCR] = BINARY_SUBSCR, [BINARY_SUBSCR_ADAPTIVE] = BINARY_SUBSCR, [BINARY_SUBSCR_DICT] = BINARY_SUBSCR, [BINARY_SUBSCR_GETITEM] = BINARY_SUBSCR, [BINARY_SUBSCR_LIST_INT] = BINARY_SUBSCR, [BINARY_SUBSCR_TUPLE_INT] = BINARY_SUBSCR, [BUILD_CONST_KEY_MAP] = BUILD_CONST_KEY_MAP, [BUILD_LIST] = BUILD_LIST, [BUILD_MAP] = BUILD_MAP, [BUILD_SET] = BUILD_SET, [BUILD_SLICE] = BUILD_SLICE, [BUILD_STRING] = BUILD_STRING, [BUILD_TUPLE] = BUILD_TUPLE, [CACHE] = CACHE, [CALL] = CALL, [CALL_ADAPTIVE] = CALL, [CALL_FUNCTION_EX] = CALL_FUNCTION_EX, [CALL_PY_EXACT_ARGS] = CALL, [CALL_PY_WITH_DEFAULTS] = CALL, [CHECK_EG_MATCH] = CHECK_EG_MATCH, [CHECK_EXC_MATCH] = CHECK_EXC_MATCH, [COMPARE_OP] = COMPARE_OP, [COMPARE_OP_ADAPTIVE] = COMPARE_OP, [COMPARE_OP_FLOAT_JUMP] = COMPARE_OP, [COMPARE_OP_INT_JUMP] = COMPARE_OP, [COMPARE_OP_STR_JUMP] = COMPARE_OP, [CONTAINS_OP] = CONTAINS_OP, [COPY] = COPY, [COPY_FREE_VARS] = COPY_FREE_VARS, [DELETE_ATTR] = DELETE_ATTR, [DELETE_DEREF] = DELETE_DEREF, [DELETE_FAST] = DELETE_FAST, [DELETE_GLOBAL] = DELETE_GLOBAL, [DELETE_NAME] = DELETE_NAME, [DELETE_SUBSCR] = DELETE_SUBSCR, [DICT_MERGE] = DICT_MERGE, [DICT_UPDATE] = DICT_UPDATE, [END_ASYNC_FOR] = END_ASYNC_FOR, [EXTENDED_ARG] = EXTENDED_ARG, [EXTENDED_ARG_QUICK] = EXTENDED_ARG, [FORMAT_VALUE] = FORMAT_VALUE, [FOR_ITER] = FOR_ITER, [GET_AITER] = GET_AITER, [GET_ANEXT] = GET_ANEXT, [GET_AWAITABLE] = GET_AWAITABLE, [GET_ITER] = GET_ITER, [GET_LEN] = GET_LEN, [GET_YIELD_FROM_ITER] = GET_YIELD_FROM_ITER, [IMPORT_FROM] = IMPORT_FROM, [IMPORT_NAME] = IMPORT_NAME, [IMPORT_STAR] = IMPORT_STAR, [IS_OP] = IS_OP, [JUMP_BACKWARD] = JUMP_BACKWARD, [JUMP_BACKWARD_NO_INTERRUPT] = JUMP_BACKWARD_NO_INTERRUPT, [JUMP_BACKWARD_QUICK] = JUMP_BACKWARD, [JUMP_FORWARD] = JUMP_FORWARD, [JUMP_IF_FALSE_OR_POP] = JUMP_IF_FALSE_OR_POP, [JUMP_IF_TRUE_OR_POP] = JUMP_IF_TRUE_OR_POP, [KW_NAMES] = KW_NAMES, [LIST_APPEND] = LIST_APPEND, [LIST_EXTEND] = LIST_EXTEND, [LIST_TO_TUPLE] = LIST_TO_TUPLE, [LOAD_ASSERTION_ERROR] = LOAD_ASSERTION_ERROR, [LOAD_ATTR] = LOAD_ATTR, [LOAD_ATTR_ADAPTIVE] = LOAD_ATTR, [LOAD_ATTR_INSTANCE_VALUE] = LOAD_ATTR, [LOAD_ATTR_MODULE] = LOAD_ATTR, [LOAD_ATTR_SLOT] = LOAD_ATTR, [LOAD_ATTR_WITH_HINT] = LOAD_ATTR, [LOAD_BUILD_CLASS] = LOAD_BUILD_CLASS, [LOAD_CLASSDEREF] = LOAD_CLASSDEREF, [LOAD_CLOSURE] = LOAD_CLOSURE, [LOAD_CONST] = LOAD_CONST, [LOAD_CONST__LOAD_FAST] = LOAD_CONST, [LOAD_DEREF] = LOAD_DEREF, [LOAD_FAST] = LOAD_FAST, [LOAD_FAST__LOAD_CONST] = LOAD_FAST, [LOAD_FAST__LOAD_FAST] = LOAD_FAST, [LOAD_GLOBAL] = LOAD_GLOBAL, [LOAD_GLOBAL_ADAPTIVE] = LOAD_GLOBAL, [LOAD_GLOBAL_BUILTIN] = LOAD_GLOBAL, [LOAD_GLOBAL_MODULE] = LOAD_GLOBAL, [LOAD_METHOD] = LOAD_METHOD, [LOAD_METHOD_ADAPTIVE] = LOAD_METHOD, [LOAD_METHOD_CLASS] = LOAD_METHOD, [LOAD_METHOD_MODULE] = LOAD_METHOD, [LOAD_METHOD_NO_DICT] = LOAD_METHOD, [LOAD_METHOD_WITH_DICT] = LOAD_METHOD, [LOAD_METHOD_WITH_VALUES] = LOAD_METHOD, [LOAD_NAME] = LOAD_NAME, [MAKE_CELL] = MAKE_CELL, [MAKE_FUNCTION] = MAKE_FUNCTION, [MAP_ADD] = MAP_ADD, [MATCH_CLASS] = MATCH_CLASS, [MATCH_KEYS] = MATCH_KEYS, [MATCH_MAPPING] = MATCH_MAPPING, [MATCH_SEQUENCE] = MATCH_SEQUENCE, [NOP] = NOP, [POP_EXCEPT] = POP_EXCEPT, [POP_JUMP_BACKWARD_IF_FALSE] = POP_JUMP_BACKWARD_IF_FALSE, [POP_JUMP_BACKWARD_IF_NONE] = POP_JUMP_BACKWARD_IF_NONE, [POP_JUMP_BACKWARD_IF_NOT_NONE] = POP_JUMP_BACKWARD_IF_NOT_NONE, [POP_JUMP_BACKWARD_IF_TRUE] = POP_JUMP_BACKWARD_IF_TRUE, [POP_JUMP_FORWARD_IF_FALSE] = POP_JUMP_FORWARD_IF_FALSE, [POP_JUMP_FORWARD_IF_NONE] = POP_JUMP_FORWARD_IF_NONE, [POP_JUMP_FORWARD_IF_NOT_NONE] = POP_JUMP_FORWARD_IF_NOT_NONE, [POP_JUMP_FORWARD_IF_TRUE] = POP_JUMP_FORWARD_IF_TRUE, [POP_TOP] = POP_TOP, [PRECALL] = PRECALL, [PRECALL_ADAPTIVE] = PRECALL, [PRECALL_BOUND_METHOD] = PRECALL, [PRECALL_BUILTIN_CLASS] = PRECALL, [PRECALL_BUILTIN_FAST_WITH_KEYWORDS] = PRECALL, [PRECALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = PRECALL, [PRECALL_NO_KW_BUILTIN_FAST] = PRECALL, [PRECALL_NO_KW_BUILTIN_O] = PRECALL, [PRECALL_NO_KW_ISINSTANCE] = PRECALL, [PRECALL_NO_KW_LEN] = PRECALL, [PRECALL_NO_KW_LIST_APPEND] = PRECALL, [PRECALL_NO_KW_METHOD_DESCRIPTOR_FAST] = PRECALL, [PRECALL_NO_KW_METHOD_DESCRIPTOR_NOARGS] = PRECALL, [PRECALL_NO_KW_METHOD_DESCRIPTOR_O] = PRECALL, [PRECALL_NO_KW_STR_1] = PRECALL, [PRECALL_NO_KW_TUPLE_1] = PRECALL, [PRECALL_NO_KW_TYPE_1] = PRECALL, [PRECALL_PYFUNC] = PRECALL, [PREP_RERAISE_STAR] = PREP_RERAISE_STAR, [PRINT_EXPR] = PRINT_EXPR, [PUSH_EXC_INFO] = PUSH_EXC_INFO, [PUSH_NULL] = PUSH_NULL, [RAISE_VARARGS] = RAISE_VARARGS, [RERAISE] = RERAISE, [RESUME] = RESUME, [RESUME_QUICK] = RESUME, [RETURN_GENERATOR] = RETURN_GENERATOR, [RETURN_VALUE] = RETURN_VALUE, [SEND] = SEND, [SETUP_ANNOTATIONS] = SETUP_ANNOTATIONS, [SET_ADD] = SET_ADD, [SET_UPDATE] = SET_UPDATE, [STORE_ATTR] = STORE_ATTR, [STORE_ATTR_ADAPTIVE] = STORE_ATTR, [STORE_ATTR_INSTANCE_VALUE] = STORE_ATTR, [STORE_ATTR_SLOT] = STORE_ATTR, [STORE_ATTR_WITH_HINT] = STORE_ATTR, [STORE_DEREF] = STORE_DEREF, [STORE_FAST] = STORE_FAST, [STORE_FAST__LOAD_FAST] = STORE_FAST, [STORE_FAST__STORE_FAST] = STORE_FAST, [STORE_GLOBAL] = STORE_GLOBAL, [STORE_NAME] = STORE_NAME, [STORE_SUBSCR] = STORE_SUBSCR, [STORE_SUBSCR_ADAPTIVE] = STORE_SUBSCR, [STORE_SUBSCR_DICT] = STORE_SUBSCR, [STORE_SUBSCR_LIST_INT] = STORE_SUBSCR, [SWAP] = SWAP, [UNARY_INVERT] = UNARY_INVERT, [UNARY_NEGATIVE] = UNARY_NEGATIVE, [UNARY_NOT] = UNARY_NOT, [UNARY_POSITIVE] = UNARY_POSITIVE, [UNPACK_EX] = UNPACK_EX, [UNPACK_SEQUENCE] = UNPACK_SEQUENCE, [UNPACK_SEQUENCE_ADAPTIVE] = UNPACK_SEQUENCE, [UNPACK_SEQUENCE_LIST] = UNPACK_SEQUENCE, [UNPACK_SEQUENCE_TUPLE] = UNPACK_SEQUENCE, [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, [WITH_EXCEPT_START] = WITH_EXCEPT_START, [YIELD_VALUE] = YIELD_VALUE, }; #endif // NEED_OPCODE_TABLES #ifdef Py_DEBUG static const char *const _PyOpcode_OpName[256] = { [CACHE] = "CACHE", [POP_TOP] = "POP_TOP", [PUSH_NULL] = "PUSH_NULL", [BINARY_OP_ADAPTIVE] = "BINARY_OP_ADAPTIVE", [BINARY_OP_ADD_FLOAT] = "BINARY_OP_ADD_FLOAT", [BINARY_OP_ADD_INT] = "BINARY_OP_ADD_INT", [BINARY_OP_ADD_UNICODE] = "BINARY_OP_ADD_UNICODE", [BINARY_OP_INPLACE_ADD_UNICODE] = "BINARY_OP_INPLACE_ADD_UNICODE", [BINARY_OP_MULTIPLY_FLOAT] = "BINARY_OP_MULTIPLY_FLOAT", [NOP] = "NOP", [UNARY_POSITIVE] = "UNARY_POSITIVE", [UNARY_NEGATIVE] = "UNARY_NEGATIVE", [UNARY_NOT] = "UNARY_NOT", [BINARY_OP_MULTIPLY_INT] = "BINARY_OP_MULTIPLY_INT", [BINARY_OP_SUBTRACT_FLOAT] = "BINARY_OP_SUBTRACT_FLOAT", [UNARY_INVERT] = "UNARY_INVERT", [BINARY_OP_SUBTRACT_INT] = "BINARY_OP_SUBTRACT_INT", [BINARY_SUBSCR_ADAPTIVE] = "BINARY_SUBSCR_ADAPTIVE", [BINARY_SUBSCR_DICT] = "BINARY_SUBSCR_DICT", [BINARY_SUBSCR_GETITEM] = "BINARY_SUBSCR_GETITEM", [BINARY_SUBSCR_LIST_INT] = "BINARY_SUBSCR_LIST_INT", [BINARY_SUBSCR_TUPLE_INT] = "BINARY_SUBSCR_TUPLE_INT", [CALL_ADAPTIVE] = "CALL_ADAPTIVE", [CALL_PY_EXACT_ARGS] = "CALL_PY_EXACT_ARGS", [CALL_PY_WITH_DEFAULTS] = "CALL_PY_WITH_DEFAULTS", [BINARY_SUBSCR] = "BINARY_SUBSCR", [COMPARE_OP_ADAPTIVE] = "COMPARE_OP_ADAPTIVE", [COMPARE_OP_FLOAT_JUMP] = "COMPARE_OP_FLOAT_JUMP", [COMPARE_OP_INT_JUMP] = "COMPARE_OP_INT_JUMP", [COMPARE_OP_STR_JUMP] = "COMPARE_OP_STR_JUMP", [GET_LEN] = "GET_LEN", [MATCH_MAPPING] = "MATCH_MAPPING", [MATCH_SEQUENCE] = "MATCH_SEQUENCE", [MATCH_KEYS] = "MATCH_KEYS", [EXTENDED_ARG_QUICK] = "EXTENDED_ARG_QUICK", [PUSH_EXC_INFO] = "PUSH_EXC_INFO", [CHECK_EXC_MATCH] = "CHECK_EXC_MATCH", [CHECK_EG_MATCH] = "CHECK_EG_MATCH", [JUMP_BACKWARD_QUICK] = "JUMP_BACKWARD_QUICK", [LOAD_ATTR_ADAPTIVE] = "LOAD_ATTR_ADAPTIVE", [LOAD_ATTR_INSTANCE_VALUE] = "LOAD_ATTR_INSTANCE_VALUE", [LOAD_ATTR_MODULE] = "LOAD_ATTR_MODULE", [LOAD_ATTR_SLOT] = "LOAD_ATTR_SLOT", [LOAD_ATTR_WITH_HINT] = "LOAD_ATTR_WITH_HINT", [LOAD_CONST__LOAD_FAST] = "LOAD_CONST__LOAD_FAST", [LOAD_FAST__LOAD_CONST] = "LOAD_FAST__LOAD_CONST", [LOAD_FAST__LOAD_FAST] = "LOAD_FAST__LOAD_FAST", [LOAD_GLOBAL_ADAPTIVE] = "LOAD_GLOBAL_ADAPTIVE", [LOAD_GLOBAL_BUILTIN] = "LOAD_GLOBAL_BUILTIN", [WITH_EXCEPT_START] = "WITH_EXCEPT_START", [GET_AITER] = "GET_AITER", [GET_ANEXT] = "GET_ANEXT", [BEFORE_ASYNC_WITH] = "BEFORE_ASYNC_WITH", [BEFORE_WITH] = "BEFORE_WITH", [END_ASYNC_FOR] = "END_ASYNC_FOR", [LOAD_GLOBAL_MODULE] = "LOAD_GLOBAL_MODULE", [LOAD_METHOD_ADAPTIVE] = "LOAD_METHOD_ADAPTIVE", [LOAD_METHOD_CLASS] = "LOAD_METHOD_CLASS", [LOAD_METHOD_MODULE] = "LOAD_METHOD_MODULE", [LOAD_METHOD_NO_DICT] = "LOAD_METHOD_NO_DICT", [STORE_SUBSCR] = "STORE_SUBSCR", [DELETE_SUBSCR] = "DELETE_SUBSCR", [LOAD_METHOD_WITH_DICT] = "LOAD_METHOD_WITH_DICT", [LOAD_METHOD_WITH_VALUES] = "LOAD_METHOD_WITH_VALUES", [PRECALL_ADAPTIVE] = "PRECALL_ADAPTIVE", [PRECALL_BOUND_METHOD] = "PRECALL_BOUND_METHOD", [PRECALL_BUILTIN_CLASS] = "PRECALL_BUILTIN_CLASS", [PRECALL_BUILTIN_FAST_WITH_KEYWORDS] = "PRECALL_BUILTIN_FAST_WITH_KEYWORDS", [GET_ITER] = "GET_ITER", [GET_YIELD_FROM_ITER] = "GET_YIELD_FROM_ITER", [PRINT_EXPR] = "PRINT_EXPR", [LOAD_BUILD_CLASS] = "LOAD_BUILD_CLASS", [PRECALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = "PRECALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS", [PRECALL_NO_KW_BUILTIN_FAST] = "PRECALL_NO_KW_BUILTIN_FAST", [LOAD_ASSERTION_ERROR] = "LOAD_ASSERTION_ERROR", [RETURN_GENERATOR] = "RETURN_GENERATOR", [PRECALL_NO_KW_BUILTIN_O] = "PRECALL_NO_KW_BUILTIN_O", [PRECALL_NO_KW_ISINSTANCE] = "PRECALL_NO_KW_ISINSTANCE", [PRECALL_NO_KW_LEN] = "PRECALL_NO_KW_LEN", [PRECALL_NO_KW_LIST_APPEND] = "PRECALL_NO_KW_LIST_APPEND", [PRECALL_NO_KW_METHOD_DESCRIPTOR_FAST] = "PRECALL_NO_KW_METHOD_DESCRIPTOR_FAST", [PRECALL_NO_KW_METHOD_DESCRIPTOR_NOARGS] = "PRECALL_NO_KW_METHOD_DESCRIPTOR_NOARGS", [LIST_TO_TUPLE] = "LIST_TO_TUPLE", [RETURN_VALUE] = "RETURN_VALUE", [IMPORT_STAR] = "IMPORT_STAR", [SETUP_ANNOTATIONS] = "SETUP_ANNOTATIONS", [YIELD_VALUE] = "YIELD_VALUE", [ASYNC_GEN_WRAP] = "ASYNC_GEN_WRAP", [PREP_RERAISE_STAR] = "PREP_RERAISE_STAR", [POP_EXCEPT] = "POP_EXCEPT", [STORE_NAME] = "STORE_NAME", [DELETE_NAME] = "DELETE_NAME", [UNPACK_SEQUENCE] = "UNPACK_SEQUENCE", [FOR_ITER] = "FOR_ITER", [UNPACK_EX] = "UNPACK_EX", [STORE_ATTR] = "STORE_ATTR", [DELETE_ATTR] = "DELETE_ATTR", [STORE_GLOBAL] = "STORE_GLOBAL", [DELETE_GLOBAL] = "DELETE_GLOBAL", [SWAP] = "SWAP", [LOAD_CONST] = "LOAD_CONST", [LOAD_NAME] = "LOAD_NAME", [BUILD_TUPLE] = "BUILD_TUPLE", [BUILD_LIST] = "BUILD_LIST", [BUILD_SET] = "BUILD_SET", [BUILD_MAP] = "BUILD_MAP", [LOAD_ATTR] = "LOAD_ATTR", [COMPARE_OP] = "COMPARE_OP", [IMPORT_NAME] = "IMPORT_NAME", [IMPORT_FROM] = "IMPORT_FROM", [JUMP_FORWARD] = "JUMP_FORWARD", [JUMP_IF_FALSE_OR_POP] = "JUMP_IF_FALSE_OR_POP", [JUMP_IF_TRUE_OR_POP] = "JUMP_IF_TRUE_OR_POP", [PRECALL_NO_KW_METHOD_DESCRIPTOR_O] = "PRECALL_NO_KW_METHOD_DESCRIPTOR_O", [POP_JUMP_FORWARD_IF_FALSE] = "POP_JUMP_FORWARD_IF_FALSE", [POP_JUMP_FORWARD_IF_TRUE] = "POP_JUMP_FORWARD_IF_TRUE", [LOAD_GLOBAL] = "LOAD_GLOBAL", [IS_OP] = "IS_OP", [CONTAINS_OP] = "CONTAINS_OP", [RERAISE] = "RERAISE", [COPY] = "COPY", [PRECALL_NO_KW_STR_1] = "PRECALL_NO_KW_STR_1", [BINARY_OP] = "BINARY_OP", [SEND] = "SEND", [LOAD_FAST] = "LOAD_FAST", [STORE_FAST] = "STORE_FAST", [DELETE_FAST] = "DELETE_FAST", [PRECALL_NO_KW_TUPLE_1] = "PRECALL_NO_KW_TUPLE_1", [POP_JUMP_FORWARD_IF_NOT_NONE] = "POP_JUMP_FORWARD_IF_NOT_NONE", [POP_JUMP_FORWARD_IF_NONE] = "POP_JUMP_FORWARD_IF_NONE", [RAISE_VARARGS] = "RAISE_VARARGS", [GET_AWAITABLE] = "GET_AWAITABLE", [MAKE_FUNCTION] = "MAKE_FUNCTION", [BUILD_SLICE] = "BUILD_SLICE", [JUMP_BACKWARD_NO_INTERRUPT] = "JUMP_BACKWARD_NO_INTERRUPT", [MAKE_CELL] = "MAKE_CELL", [LOAD_CLOSURE] = "LOAD_CLOSURE", [LOAD_DEREF] = "LOAD_DEREF", [STORE_DEREF] = "STORE_DEREF", [DELETE_DEREF] = "DELETE_DEREF", [JUMP_BACKWARD] = "JUMP_BACKWARD", [PRECALL_NO_KW_TYPE_1] = "PRECALL_NO_KW_TYPE_1", [CALL_FUNCTION_EX] = "CALL_FUNCTION_EX", [PRECALL_PYFUNC] = "PRECALL_PYFUNC", [EXTENDED_ARG] = "EXTENDED_ARG", [LIST_APPEND] = "LIST_APPEND", [SET_ADD] = "SET_ADD", [MAP_ADD] = "MAP_ADD", [LOAD_CLASSDEREF] = "LOAD_CLASSDEREF", [COPY_FREE_VARS] = "COPY_FREE_VARS", [RESUME_QUICK] = "RESUME_QUICK", [RESUME] = "RESUME", [MATCH_CLASS] = "MATCH_CLASS", [STORE_ATTR_ADAPTIVE] = "STORE_ATTR_ADAPTIVE", [STORE_ATTR_INSTANCE_VALUE] = "STORE_ATTR_INSTANCE_VALUE", [FORMAT_VALUE] = "FORMAT_VALUE", [BUILD_CONST_KEY_MAP] = "BUILD_CONST_KEY_MAP", [BUILD_STRING] = "BUILD_STRING", [STORE_ATTR_SLOT] = "STORE_ATTR_SLOT", [STORE_ATTR_WITH_HINT] = "STORE_ATTR_WITH_HINT", [LOAD_METHOD] = "LOAD_METHOD", [STORE_FAST__LOAD_FAST] = "STORE_FAST__LOAD_FAST", [LIST_EXTEND] = "LIST_EXTEND", [SET_UPDATE] = "SET_UPDATE", [DICT_MERGE] = "DICT_MERGE", [DICT_UPDATE] = "DICT_UPDATE", [PRECALL] = "PRECALL", [STORE_FAST__STORE_FAST] = "STORE_FAST__STORE_FAST", [STORE_SUBSCR_ADAPTIVE] = "STORE_SUBSCR_ADAPTIVE", [STORE_SUBSCR_DICT] = "STORE_SUBSCR_DICT", [STORE_SUBSCR_LIST_INT] = "STORE_SUBSCR_LIST_INT", [CALL] = "CALL", [KW_NAMES] = "KW_NAMES", [POP_JUMP_BACKWARD_IF_NOT_NONE] = "POP_JUMP_BACKWARD_IF_NOT_NONE", [POP_JUMP_BACKWARD_IF_NONE] = "POP_JUMP_BACKWARD_IF_NONE", [POP_JUMP_BACKWARD_IF_FALSE] = "POP_JUMP_BACKWARD_IF_FALSE", [POP_JUMP_BACKWARD_IF_TRUE] = "POP_JUMP_BACKWARD_IF_TRUE", [UNPACK_SEQUENCE_ADAPTIVE] = "UNPACK_SEQUENCE_ADAPTIVE", [UNPACK_SEQUENCE_LIST] = "UNPACK_SEQUENCE_LIST", [UNPACK_SEQUENCE_TUPLE] = "UNPACK_SEQUENCE_TUPLE", [UNPACK_SEQUENCE_TWO_TUPLE] = "UNPACK_SEQUENCE_TWO_TUPLE", [181] = "<181>", [182] = "<182>", [183] = "<183>", [184] = "<184>", [185] = "<185>", [186] = "<186>", [187] = "<187>", [188] = "<188>", [189] = "<189>", [190] = "<190>", [191] = "<191>", [192] = "<192>", [193] = "<193>", [194] = "<194>", [195] = "<195>", [196] = "<196>", [197] = "<197>", [198] = "<198>", [199] = "<199>", [200] = "<200>", [201] = "<201>", [202] = "<202>", [203] = "<203>", [204] = "<204>", [205] = "<205>", [206] = "<206>", [207] = "<207>", [208] = "<208>", [209] = "<209>", [210] = "<210>", [211] = "<211>", [212] = "<212>", [213] = "<213>", [214] = "<214>", [215] = "<215>", [216] = "<216>", [217] = "<217>", [218] = "<218>", [219] = "<219>", [220] = "<220>", [221] = "<221>", [222] = "<222>", [223] = "<223>", [224] = "<224>", [225] = "<225>", [226] = "<226>", [227] = "<227>", [228] = "<228>", [229] = "<229>", [230] = "<230>", [231] = "<231>", [232] = "<232>", [233] = "<233>", [234] = "<234>", [235] = "<235>", [236] = "<236>", [237] = "<237>", [238] = "<238>", [239] = "<239>", [240] = "<240>", [241] = "<241>", [242] = "<242>", [243] = "<243>", [244] = "<244>", [245] = "<245>", [246] = "<246>", [247] = "<247>", [248] = "<248>", [249] = "<249>", [250] = "<250>", [251] = "<251>", [252] = "<252>", [253] = "<253>", [254] = "<254>", [DO_TRACING] = "DO_TRACING", }; #endif #define EXTRA_CASES \ case 181: \ case 182: \ case 183: \ case 184: \ case 185: \ case 186: \ case 187: \ case 188: \ case 189: \ case 190: \ case 191: \ case 192: \ case 193: \ case 194: \ case 195: \ case 196: \ case 197: \ case 198: \ case 199: \ case 200: \ case 201: \ case 202: \ case 203: \ case 204: \ case 205: \ case 206: \ case 207: \ case 208: \ case 209: \ case 210: \ case 211: \ case 212: \ case 213: \ case 214: \ case 215: \ case 216: \ case 217: \ case 218: \ case 219: \ case 220: \ case 221: \ case 222: \ case 223: \ case 224: \ case 225: \ case 226: \ case 227: \ case 228: \ case 229: \ case 230: \ case 231: \ case 232: \ case 233: \ case 234: \ case 235: \ case 236: \ case 237: \ case 238: \ case 239: \ case 240: \ case 241: \ case 242: \ case 243: \ case 244: \ case 245: \ case 246: \ case 247: \ case 248: \ case 249: \ case 250: \ case 251: \ case 252: \ case 253: \ case 254: \ ; #ifdef __cplusplus } #endif #endif // !Py_INTERNAL_OPCODE_H	18.54 KB	2025-10-09 16:16
📄 pycore_parser.h #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 */	626 B	2025-10-09 16:16
📄 pycore_pathconfig.h #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 PyAPI_FUNC(void) _PyPathConfig_ClearGlobal(void); extern PyStatus _PyPathConfig_ReadGlobal(PyConfig config); extern PyStatus _PyPathConfig_UpdateGlobal(const PyConfig config); extern const wchar_t * _PyPathConfig_GetGlobalModuleSearchPath(void); extern int _PyPathConfig_ComputeSysPath0( const PyWideStringList argv, PyObject path0); #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_PATHCONFIG_H */	606 B	2025-10-09 16:16
📄 pycore_pyarena.h /* 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 */	2.67 KB	2025-10-09 16:16
📄 pycore_pyerrors.h #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 /* runtime lifecycle / extern PyStatus _PyErr_InitTypes(PyInterpreterState ); extern void _PyErr_FiniTypes(PyInterpreterState ); / other API / static inline PyObject _PyErr_Occurred(PyThreadState tstate) { assert(tstate != NULL); return tstate->curexc_type; } static inline void _PyErr_ClearExcState(_PyErr_StackItem exc_state) { Py_CLEAR(exc_state->exc_value); } PyAPI_FUNC(PyObject) _PyErr_StackItemToExcInfoTuple( _PyErr_StackItem err_info); 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(PyObject ) _PyExc_CreateExceptionGroup( const char msg, PyObject excs); PyAPI_FUNC(PyObject ) _PyExc_PrepReraiseStar( PyObject orig, PyObject excs); 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 */	2.44 KB	2025-10-09 16:16
📄 pycore_pyhash.h #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	206 B	2025-10-09 16:16
📄 pycore_pylifecycle.h #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 #include "pycore_runtime.h" // _PyRuntimeState /* 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 _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 void _PySys_Fini(PyInterpreterState interp); extern int _PyBuiltins_AddExceptions(PyObject bltinmod); extern PyStatus _Py_HashRandomization_Init(const PyConfig ); extern PyStatus _PyImportZip_Init(PyThreadState tstate); extern PyStatus _PyGC_Init(PyInterpreterState interp); extern PyStatus _PyAtExit_Init(PyInterpreterState interp); extern int _Py_Deepfreeze_Init(void); /* Various internal finalizers / extern int _PySignal_Init(int install_signal_handlers); extern void _PySignal_Fini(void); extern void _PyImport_Fini(void); extern void _PyImport_Fini2(void); extern void _PyGC_Fini(PyInterpreterState interp); extern void _Py_HashRandomization_Fini(void); 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 void _PyThread_FiniType(PyInterpreterState interp); extern void _Py_Deepfreeze_Fini(void); extern void _PyArg_Fini(void); 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(wchar_t ) _Py_GetStdlibDir(void); 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 */	3.42 KB	2025-10-09 16:16
📄 pycore_pymath.h #ifndef Py_INTERNAL_PYMATH_H #define Py_INTERNAL_PYMATH_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif /* _Py_ADJUST_ERANGE1(x) * _Py_ADJUST_ERANGE2(x, y) * Set errno to 0 before calling a libm function, and invoke one of these * macros after, passing the function result(s) (_Py_ADJUST_ERANGE2 is useful * for functions returning complex results). This makes two kinds of * adjustments to errno: (A) If it looks like the platform libm set * errno=ERANGE due to underflow, clear errno. (B) If it looks like the * platform libm overflowed but didn't set errno, force errno to ERANGE. In * effect, we're trying to force a useful implementation of C89 errno * behavior. * Caution: * This isn't reliable. C99 no longer requires libm to set errno under * any exceptional condition, but does require +- HUGE_VAL return * values on overflow. A 754 box probably maps HUGE_VAL to a * double infinity, and we're cool if that's so, unless the input * was an infinity and an infinity is the expected result. A C89 * system sets errno to ERANGE, so we check for that too. We're * out of luck if a C99 754 box doesn't map HUGE_VAL to +Inf, or * if the returned result is a NaN, or if a C89 box returns HUGE_VAL * in non-overflow cases. / static inline void _Py_ADJUST_ERANGE1(double x) { if (errno == 0) { if (x == Py_HUGE_VAL \|\| x == -Py_HUGE_VAL) { errno = ERANGE; } } else if (errno == ERANGE && x == 0.0) { errno = 0; } } static inline void _Py_ADJUST_ERANGE2(double x, double y) { if (x == Py_HUGE_VAL \|\| x == -Py_HUGE_VAL \|\| y == Py_HUGE_VAL \|\| y == -Py_HUGE_VAL) { if (errno == 0) { errno = ERANGE; } } else if (errno == ERANGE) { errno = 0; } } // Return whether integral type type* is signed or not. #define _Py_IntegralTypeSigned(type) \ ((type)(-1) < 0) // Return the maximum value of integral type type. #define _Py_IntegralTypeMax(type) \ ((_Py_IntegralTypeSigned(type)) ? (((((type)1 << (sizeof(type)CHAR_BIT - 2)) - 1) << 1) + 1) : ~(type)0) // Return the minimum value of integral type type. #define _Py_IntegralTypeMin(type) \ ((_Py_IntegralTypeSigned(type)) ? -_Py_IntegralTypeMax(type) - 1 : 0) // Check whether v* is in the range of integral type type. This is most // useful if v is floating-point, since demoting a floating-point v to an // integral type that cannot represent v's integral part is undefined // behavior. #define _Py_InIntegralTypeRange(type, v) \ (_Py_IntegralTypeMin(type) <= v && v <= _Py_IntegralTypeMax(type)) //--- HAVE_PY_SET_53BIT_PRECISION macro ------------------------------------ // // The functions _Py_dg_strtod() and _Py_dg_dtoa() in Python/dtoa.c (which are // required to support the short float repr introduced in Python 3.1) require // that the floating-point unit that's being used for arithmetic operations on // C doubles is set to use 53-bit precision. It also requires that the FPU // rounding mode is round-half-to-even, but that's less often an issue. // // If your FPU isn't already set to 53-bit precision/round-half-to-even, and // you want to make use of _Py_dg_strtod() and _Py_dg_dtoa(), then you should: // // #define HAVE_PY_SET_53BIT_PRECISION 1 // // and also give appropriate definitions for the following three macros: // // * _Py_SET_53BIT_PRECISION_HEADER: any variable declarations needed to // use the two macros below. // * _Py_SET_53BIT_PRECISION_START: store original FPU settings, and // set FPU to 53-bit precision/round-half-to-even // * _Py_SET_53BIT_PRECISION_END: restore original FPU settings // // The macros are designed to be used within a single C function: see // Python/pystrtod.c for an example of their use. // Get and set x87 control word for gcc/x86 #ifdef HAVE_GCC_ASM_FOR_X87 #define HAVE_PY_SET_53BIT_PRECISION 1 // Functions defined in Python/pymath.c extern unsigned short _Py_get_387controlword(void); extern void _Py_set_387controlword(unsigned short); #define _Py_SET_53BIT_PRECISION_HEADER \ unsigned short old_387controlword, new_387controlword #define _Py_SET_53BIT_PRECISION_START \ do { \ old_387controlword = _Py_get_387controlword(); \ new_387controlword = (old_387controlword & ~0x0f00) \| 0x0200; \ if (new_387controlword != old_387controlword) { \ _Py_set_387controlword(new_387controlword); \ } \ } while (0) #define _Py_SET_53BIT_PRECISION_END \ do { \ if (new_387controlword != old_387controlword) { \ _Py_set_387controlword(old_387controlword); \ } \ } while (0) #endif // Get and set x87 control word for VisualStudio/x86. // x87 is not supported in 64-bit or ARM. #if defined(_MSC_VER) && !defined(_WIN64) && !defined(_M_ARM) #define HAVE_PY_SET_53BIT_PRECISION 1 #include <float.h> // __control87_2() #define _Py_SET_53BIT_PRECISION_HEADER \ unsigned int old_387controlword, new_387controlword, out_387controlword // We use the __control87_2 function to set only the x87 control word. // The SSE control word is unaffected. #define _Py_SET_53BIT_PRECISION_START \ do { \ __control87_2(0, 0, &old_387controlword, NULL); \ new_387controlword = \ (old_387controlword & ~(_MCW_PC \| _MCW_RC)) \| (_PC_53 \| _RC_NEAR); \ if (new_387controlword != old_387controlword) { \ __control87_2(new_387controlword, _MCW_PC \| _MCW_RC, \ &out_387controlword, NULL); \ } \ } while (0) #define _Py_SET_53BIT_PRECISION_END \ do { \ if (new_387controlword != old_387controlword) { \ __control87_2(old_387controlword, _MCW_PC \| _MCW_RC, \ &out_387controlword, NULL); \ } \ } while (0) #endif // MC68881 #ifdef HAVE_GCC_ASM_FOR_MC68881 #define HAVE_PY_SET_53BIT_PRECISION 1 #define _Py_SET_53BIT_PRECISION_HEADER \ unsigned int old_fpcr, new_fpcr #define _Py_SET_53BIT_PRECISION_START \ do { \ __asm__ ("fmove.l %%fpcr,%0" : "=g" (old_fpcr)); \ /* Set double precision / round to nearest. / \ new_fpcr = (old_fpcr & ~0xf0) \| 0x80; \ if (new_fpcr != old_fpcr) { \ __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (new_fpcr));\ } \ } while (0) #define _Py_SET_53BIT_PRECISION_END \ do { \ if (new_fpcr != old_fpcr) { \ __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (old_fpcr)); \ } \ } while (0) #endif // Default definitions are empty #ifndef _Py_SET_53BIT_PRECISION_HEADER # define _Py_SET_53BIT_PRECISION_HEADER # define _Py_SET_53BIT_PRECISION_START # define _Py_SET_53BIT_PRECISION_END #endif //--- _PY_SHORT_FLOAT_REPR macro ------------------------------------------- // If we can't guarantee 53-bit precision, don't use the code // in Python/dtoa.c, but fall back to standard code. This // means that repr of a float will be long (17 significant digits). // // Realistically, there are two things that could go wrong: // // (1) doubles aren't IEEE 754 doubles, or // (2) we're on x86 with the rounding precision set to 64-bits // (extended precision), and we don't know how to change // the rounding precision. #if !defined(DOUBLE_IS_LITTLE_ENDIAN_IEEE754) && \ !defined(DOUBLE_IS_BIG_ENDIAN_IEEE754) && \ !defined(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754) # define _PY_SHORT_FLOAT_REPR 0 #endif // Double rounding is symptomatic of use of extended precision on x86. // If we're seeing double rounding, and we don't have any mechanism available // for changing the FPU rounding precision, then don't use Python/dtoa.c. #if defined(X87_DOUBLE_ROUNDING) && !defined(HAVE_PY_SET_53BIT_PRECISION) # define _PY_SHORT_FLOAT_REPR 0 #endif #ifndef _PY_SHORT_FLOAT_REPR # define _PY_SHORT_FLOAT_REPR 1 #endif #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_PYMATH_H */	9.21 KB	2025-10-09 16:16
📄 pycore_pymem.h #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; / Allocate memory directly from the O/S virtual memory system, * where supported. Otherwise fallback on malloc / void _PyObject_VirtualAlloc(size_t size); void _PyObject_VirtualFree(void , size_t size); / This function returns the number of allocated memory blocks, regardless of size / PyAPI_FUNC(Py_ssize_t) _Py_GetAllocatedBlocks(void); / Macros / #ifdef WITH_PYMALLOC // Export the symbol for the 3rd party guppy3 project PyAPI_FUNC(int) _PyObject_DebugMallocStats(FILE out); #endif #ifdef __cplusplus } #endif #endif // !Py_INTERNAL_PYMEM_H	3.62 KB	2025-10-09 16:16
📄 pycore_pystate.h #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 PyInterpreterState _PyInterpreterState_Main(void) { return _PyRuntime.interpreters.main; } static inline int _Py_IsMainInterpreter(PyInterpreterState interp) { return (interp == _PyInterpreterState_Main()); } static inline const PyConfig _Py_GetMainConfig(void) { PyInterpreterState interp = _PyInterpreterState_Main(); if (interp == NULL) { return NULL; } return _PyInterpreterState_GetConfig(interp); } / Only handle signals on the main thread of the main interpreter. / static inline int _Py_ThreadCanHandleSignals(PyInterpreterState interp) { return (_Py_IsMainThread() && _Py_IsMainInterpreter(interp)); } /* Only execute pending calls on the main thread. / static inline int _Py_ThreadCanHandlePendingCalls(void) { return _Py_IsMainThread(); } #ifndef NDEBUG extern int _PyThreadState_CheckConsistency(PyThreadState tstate); #endif int _PyThreadState_MustExit(PyThreadState tstate); / Variable and macro for in-line access to current thread and interpreter state / static inline PyThreadState _PyRuntimeState_GetThreadState(_PyRuntimeState runtime) { return (PyThreadState)_Py_atomic_load_relaxed(&runtime->gilstate.tstate_current); } /* 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_UncheckedGet(). / static inline PyThreadState _PyThreadState_GET(void) { return _PyRuntimeState_GetThreadState(&_PyRuntime); } 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; } // PyThreadState functions PyAPI_FUNC(void) _PyThreadState_SetCurrent(PyThreadState tstate); // We keep this around exclusively for stable ABI compatibility. PyAPI_FUNC(void) _PyThreadState_Init( PyThreadState tstate); PyAPI_FUNC(void) _PyThreadState_DeleteExcept( _PyRuntimeState runtime, PyThreadState tstate); static inline void _PyThreadState_UpdateTracingState(PyThreadState tstate) { bool use_tracing = (tstate->tracing == 0) && (tstate->c_tracefunc != NULL \|\| tstate->c_profilefunc != NULL); tstate->cframe->use_tracing = (use_tracing ? 255 : 0); } /* Other / 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, PyModuleDef* def); PyAPI_FUNC(int) _PyOS_InterruptOccurred(PyThreadState tstate); #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_PYSTATE_H */	4.15 KB	2025-10-09 16:16
📄 pycore_runtime.h #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 #include "pycore_global_objects.h" // struct _Py_global_objects #include "pycore_interp.h" // PyInterpreterState #include "pycore_unicodeobject.h" // struct _Py_unicode_runtime_ids / 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; struct _gil_runtime_state gil; }; / 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; / Full Python runtime state / / _PyRuntimeState holds the global state for the CPython runtime. That data is exposed in the internal API as a static variable (_PyRuntime). / typedef struct pyruntimestate { / Has been initialized to a safe state. In order to be effective, this must be set to 0 during or right after allocation. / int _initialized; / 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; / The linked list of interpreters, newest first. / PyInterpreterState head; /* The runtime's initial interpreter, which has a special role in the operation of the runtime. It is also often the only interpreter. / 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; /* All the objects that are shared by the runtime's interpreters. / struct _Py_global_objects global_objects; / The following fields are here to avoid allocation during init. The data is exposed through _PyRuntimeState pointer fields. These fields should not be accessed directly outside of init. All other _PyRuntimeState pointer fields are populated when needed and default to NULL. For now there are some exceptions to that rule, which require allocation during init. These will be addressed on a case-by-case basis. Most notably, we don't pre-allocated the several mutex (PyThread_type_lock) fields, because on Windows we only ever get a pointer type. / / PyInterpreterState.interpreters.main / PyInterpreterState _main_interpreter; } _PyRuntimeState; / other API / 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 */	5.85 KB	2025-10-09 16:16
📄 pycore_runtime_init.h #ifndef Py_INTERNAL_RUNTIME_INIT_H #define Py_INTERNAL_RUNTIME_INIT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif #include "pycore_object.h" /* The static initializers defined here should only be used in the runtime init code (in pystate.c and pylifecycle.c). / #define _PyRuntimeState_INIT \ { \ .gilstate = { \ .check_enabled = 1, \ / A TSS key must be initialized with Py_tss_NEEDS_INIT \ in accordance with the specification. / \ .autoTSSkey = Py_tss_NEEDS_INIT, \ }, \ .interpreters = { \ / This prevents interpreters from getting created \ until _PyInterpreterState_Enable() is called. / \ .next_id = -1, \ }, \ .global_objects = _Py_global_objects_INIT, \ ._main_interpreter = _PyInterpreterState_INIT, \ } #ifdef HAVE_DLOPEN # include <dlfcn.h> # if HAVE_DECL_RTLD_NOW # define _Py_DLOPEN_FLAGS RTLD_NOW # else # define _Py_DLOPEN_FLAGS RTLD_LAZY # endif # define DLOPENFLAGS_INIT .dlopenflags = _Py_DLOPEN_FLAGS, #else # define _Py_DLOPEN_FLAGS 0 # define DLOPENFLAGS_INIT #endif #define _PyInterpreterState_INIT \ { \ ._static = 1, \ .id_refcount = -1, \ DLOPENFLAGS_INIT \ .ceval = { \ .recursion_limit = Py_DEFAULT_RECURSION_LIMIT, \ }, \ .gc = { \ .enabled = 1, \ .generations = { \ / .head is set in _PyGC_InitState(). / \ { .threshold = 700, }, \ { .threshold = 10, }, \ { .threshold = 10, }, \ }, \ }, \ ._initial_thread = _PyThreadState_INIT, \ } #define _PyThreadState_INIT \ { \ ._static = 1, \ .recursion_limit = Py_DEFAULT_RECURSION_LIMIT, \ .context_ver = 1, \ } // global objects #define _PyLong_DIGIT_INIT(val) \ { \ _PyVarObject_IMMORTAL_INIT(&PyLong_Type, \ ((val) == 0 ? 0 : ((val) > 0 ? 1 : -1))), \ .ob_digit = { ((val) >= 0 ? (val) : -(val)) }, \ } #define _PyBytes_SIMPLE_INIT(CH, LEN) \ { \ _PyVarObject_IMMORTAL_INIT(&PyBytes_Type, LEN), \ .ob_shash = -1, \ .ob_sval = { CH }, \ } #define _PyBytes_CHAR_INIT(CH) \ { \ _PyBytes_SIMPLE_INIT(CH, 1) \ } #define _PyUnicode_ASCII_BASE_INIT(LITERAL, ASCII) \ { \ .ob_base = _PyObject_IMMORTAL_INIT(&PyUnicode_Type), \ .length = sizeof(LITERAL) - 1, \ .hash = -1, \ .state = { \ .kind = 1, \ .compact = 1, \ .ascii = ASCII, \ .ready = 1, \ }, \ } #define _PyASCIIObject_INIT(LITERAL) \ { \ ._ascii = _PyUnicode_ASCII_BASE_INIT(LITERAL, 1), \ ._data = LITERAL \ } #define INIT_STR(NAME, LITERAL) \ ._ ## NAME = _PyASCIIObject_INIT(LITERAL) #define INIT_ID(NAME) \ ._ ## NAME = _PyASCIIObject_INIT(#NAME) #define _PyUnicode_LATIN1_INIT(LITERAL) \ { \ ._latin1 = { \ ._base = _PyUnicode_ASCII_BASE_INIT(LITERAL, 0), \ }, \ ._data = LITERAL, \ } / The following is auto-generated by Tools/scripts/generate_global_objects.py. / #define _Py_global_objects_INIT { \ .singletons = { \ .small_ints = { \ _PyLong_DIGIT_INIT(-5), \ _PyLong_DIGIT_INIT(-4), \ _PyLong_DIGIT_INIT(-3), \ _PyLong_DIGIT_INIT(-2), \ _PyLong_DIGIT_INIT(-1), \ _PyLong_DIGIT_INIT(0), \ _PyLong_DIGIT_INIT(1), \ _PyLong_DIGIT_INIT(2), \ _PyLong_DIGIT_INIT(3), \ _PyLong_DIGIT_INIT(4), \ _PyLong_DIGIT_INIT(5), \ _PyLong_DIGIT_INIT(6), \ _PyLong_DIGIT_INIT(7), \ _PyLong_DIGIT_INIT(8), \ _PyLong_DIGIT_INIT(9), \ _PyLong_DIGIT_INIT(10), \ _PyLong_DIGIT_INIT(11), \ _PyLong_DIGIT_INIT(12), \ _PyLong_DIGIT_INIT(13), \ _PyLong_DIGIT_INIT(14), \ _PyLong_DIGIT_INIT(15), \ _PyLong_DIGIT_INIT(16), \ _PyLong_DIGIT_INIT(17), \ _PyLong_DIGIT_INIT(18), \ _PyLong_DIGIT_INIT(19), \ _PyLong_DIGIT_INIT(20), \ _PyLong_DIGIT_INIT(21), \ _PyLong_DIGIT_INIT(22), \ _PyLong_DIGIT_INIT(23), \ _PyLong_DIGIT_INIT(24), \ _PyLong_DIGIT_INIT(25), \ _PyLong_DIGIT_INIT(26), \ _PyLong_DIGIT_INIT(27), \ _PyLong_DIGIT_INIT(28), \ _PyLong_DIGIT_INIT(29), \ _PyLong_DIGIT_INIT(30), \ _PyLong_DIGIT_INIT(31), \ _PyLong_DIGIT_INIT(32), \ _PyLong_DIGIT_INIT(33), \ _PyLong_DIGIT_INIT(34), \ _PyLong_DIGIT_INIT(35), \ _PyLong_DIGIT_INIT(36), \ _PyLong_DIGIT_INIT(37), \ _PyLong_DIGIT_INIT(38), \ _PyLong_DIGIT_INIT(39), \ _PyLong_DIGIT_INIT(40), \ _PyLong_DIGIT_INIT(41), \ _PyLong_DIGIT_INIT(42), \ _PyLong_DIGIT_INIT(43), \ _PyLong_DIGIT_INIT(44), \ _PyLong_DIGIT_INIT(45), \ _PyLong_DIGIT_INIT(46), \ _PyLong_DIGIT_INIT(47), \ _PyLong_DIGIT_INIT(48), \ _PyLong_DIGIT_INIT(49), \ _PyLong_DIGIT_INIT(50), \ _PyLong_DIGIT_INIT(51), \ _PyLong_DIGIT_INIT(52), \ _PyLong_DIGIT_INIT(53), \ _PyLong_DIGIT_INIT(54), \ _PyLong_DIGIT_INIT(55), \ _PyLong_DIGIT_INIT(56), \ _PyLong_DIGIT_INIT(57), \ _PyLong_DIGIT_INIT(58), \ _PyLong_DIGIT_INIT(59), \ _PyLong_DIGIT_INIT(60), \ _PyLong_DIGIT_INIT(61), \ _PyLong_DIGIT_INIT(62), \ _PyLong_DIGIT_INIT(63), \ _PyLong_DIGIT_INIT(64), \ _PyLong_DIGIT_INIT(65), \ _PyLong_DIGIT_INIT(66), \ _PyLong_DIGIT_INIT(67), \ _PyLong_DIGIT_INIT(68), \ _PyLong_DIGIT_INIT(69), \ _PyLong_DIGIT_INIT(70), \ _PyLong_DIGIT_INIT(71), \ _PyLong_DIGIT_INIT(72), \ _PyLong_DIGIT_INIT(73), \ _PyLong_DIGIT_INIT(74), \ _PyLong_DIGIT_INIT(75), \ _PyLong_DIGIT_INIT(76), \ _PyLong_DIGIT_INIT(77), \ _PyLong_DIGIT_INIT(78), \ _PyLong_DIGIT_INIT(79), \ _PyLong_DIGIT_INIT(80), \ _PyLong_DIGIT_INIT(81), \ _PyLong_DIGIT_INIT(82), \ _PyLong_DIGIT_INIT(83), \ _PyLong_DIGIT_INIT(84), \ _PyLong_DIGIT_INIT(85), \ _PyLong_DIGIT_INIT(86), \ _PyLong_DIGIT_INIT(87), \ _PyLong_DIGIT_INIT(88), \ _PyLong_DIGIT_INIT(89), \ _PyLong_DIGIT_INIT(90), \ _PyLong_DIGIT_INIT(91), \ _PyLong_DIGIT_INIT(92), \ _PyLong_DIGIT_INIT(93), \ _PyLong_DIGIT_INIT(94), \ _PyLong_DIGIT_INIT(95), \ _PyLong_DIGIT_INIT(96), \ _PyLong_DIGIT_INIT(97), \ _PyLong_DIGIT_INIT(98), \ _PyLong_DIGIT_INIT(99), \ _PyLong_DIGIT_INIT(100), \ _PyLong_DIGIT_INIT(101), \ _PyLong_DIGIT_INIT(102), \ _PyLong_DIGIT_INIT(103), \ _PyLong_DIGIT_INIT(104), \ _PyLong_DIGIT_INIT(105), \ _PyLong_DIGIT_INIT(106), \ _PyLong_DIGIT_INIT(107), \ _PyLong_DIGIT_INIT(108), \ _PyLong_DIGIT_INIT(109), \ _PyLong_DIGIT_INIT(110), \ _PyLong_DIGIT_INIT(111), \ _PyLong_DIGIT_INIT(112), \ _PyLong_DIGIT_INIT(113), \ _PyLong_DIGIT_INIT(114), \ _PyLong_DIGIT_INIT(115), \ _PyLong_DIGIT_INIT(116), \ _PyLong_DIGIT_INIT(117), \ _PyLong_DIGIT_INIT(118), \ _PyLong_DIGIT_INIT(119), \ _PyLong_DIGIT_INIT(120), \ _PyLong_DIGIT_INIT(121), \ _PyLong_DIGIT_INIT(122), \ _PyLong_DIGIT_INIT(123), \ _PyLong_DIGIT_INIT(124), \ _PyLong_DIGIT_INIT(125), \ _PyLong_DIGIT_INIT(126), \ _PyLong_DIGIT_INIT(127), \ _PyLong_DIGIT_INIT(128), \ _PyLong_DIGIT_INIT(129), \ _PyLong_DIGIT_INIT(130), \ _PyLong_DIGIT_INIT(131), \ _PyLong_DIGIT_INIT(132), \ _PyLong_DIGIT_INIT(133), \ _PyLong_DIGIT_INIT(134), \ _PyLong_DIGIT_INIT(135), \ _PyLong_DIGIT_INIT(136), \ _PyLong_DIGIT_INIT(137), \ _PyLong_DIGIT_INIT(138), \ _PyLong_DIGIT_INIT(139), \ _PyLong_DIGIT_INIT(140), \ _PyLong_DIGIT_INIT(141), \ _PyLong_DIGIT_INIT(142), \ _PyLong_DIGIT_INIT(143), \ _PyLong_DIGIT_INIT(144), \ _PyLong_DIGIT_INIT(145), \ _PyLong_DIGIT_INIT(146), \ _PyLong_DIGIT_INIT(147), \ _PyLong_DIGIT_INIT(148), \ _PyLong_DIGIT_INIT(149), \ _PyLong_DIGIT_INIT(150), \ _PyLong_DIGIT_INIT(151), \ _PyLong_DIGIT_INIT(152), \ _PyLong_DIGIT_INIT(153), \ _PyLong_DIGIT_INIT(154), \ _PyLong_DIGIT_INIT(155), \ _PyLong_DIGIT_INIT(156), \ _PyLong_DIGIT_INIT(157), \ _PyLong_DIGIT_INIT(158), \ _PyLong_DIGIT_INIT(159), \ _PyLong_DIGIT_INIT(160), \ _PyLong_DIGIT_INIT(161), \ _PyLong_DIGIT_INIT(162), \ _PyLong_DIGIT_INIT(163), \ _PyLong_DIGIT_INIT(164), \ _PyLong_DIGIT_INIT(165), \ _PyLong_DIGIT_INIT(166), \ _PyLong_DIGIT_INIT(167), \ _PyLong_DIGIT_INIT(168), \ _PyLong_DIGIT_INIT(169), \ _PyLong_DIGIT_INIT(170), \ _PyLong_DIGIT_INIT(171), \ _PyLong_DIGIT_INIT(172), \ _PyLong_DIGIT_INIT(173), \ _PyLong_DIGIT_INIT(174), \ _PyLong_DIGIT_INIT(175), \ _PyLong_DIGIT_INIT(176), \ _PyLong_DIGIT_INIT(177), \ _PyLong_DIGIT_INIT(178), \ _PyLong_DIGIT_INIT(179), \ _PyLong_DIGIT_INIT(180), \ _PyLong_DIGIT_INIT(181), \ _PyLong_DIGIT_INIT(182), \ _PyLong_DIGIT_INIT(183), \ _PyLong_DIGIT_INIT(184), \ _PyLong_DIGIT_INIT(185), \ _PyLong_DIGIT_INIT(186), \ _PyLong_DIGIT_INIT(187), \ _PyLong_DIGIT_INIT(188), \ _PyLong_DIGIT_INIT(189), \ _PyLong_DIGIT_INIT(190), \ _PyLong_DIGIT_INIT(191), \ _PyLong_DIGIT_INIT(192), \ _PyLong_DIGIT_INIT(193), \ _PyLong_DIGIT_INIT(194), \ _PyLong_DIGIT_INIT(195), \ _PyLong_DIGIT_INIT(196), \ _PyLong_DIGIT_INIT(197), \ _PyLong_DIGIT_INIT(198), \ _PyLong_DIGIT_INIT(199), \ _PyLong_DIGIT_INIT(200), \ _PyLong_DIGIT_INIT(201), \ _PyLong_DIGIT_INIT(202), \ _PyLong_DIGIT_INIT(203), \ _PyLong_DIGIT_INIT(204), \ _PyLong_DIGIT_INIT(205), \ _PyLong_DIGIT_INIT(206), \ _PyLong_DIGIT_INIT(207), \ _PyLong_DIGIT_INIT(208), \ _PyLong_DIGIT_INIT(209), \ _PyLong_DIGIT_INIT(210), \ _PyLong_DIGIT_INIT(211), \ _PyLong_DIGIT_INIT(212), \ _PyLong_DIGIT_INIT(213), \ _PyLong_DIGIT_INIT(214), \ _PyLong_DIGIT_INIT(215), \ _PyLong_DIGIT_INIT(216), \ _PyLong_DIGIT_INIT(217), \ _PyLong_DIGIT_INIT(218), \ _PyLong_DIGIT_INIT(219), \ _PyLong_DIGIT_INIT(220), \ _PyLong_DIGIT_INIT(221), \ _PyLong_DIGIT_INIT(222), \ _PyLong_DIGIT_INIT(223), \ _PyLong_DIGIT_INIT(224), \ _PyLong_DIGIT_INIT(225), \ _PyLong_DIGIT_INIT(226), \ _PyLong_DIGIT_INIT(227), \ _PyLong_DIGIT_INIT(228), \ _PyLong_DIGIT_INIT(229), \ _PyLong_DIGIT_INIT(230), \ _PyLong_DIGIT_INIT(231), \ _PyLong_DIGIT_INIT(232), \ _PyLong_DIGIT_INIT(233), \ _PyLong_DIGIT_INIT(234), \ _PyLong_DIGIT_INIT(235), \ _PyLong_DIGIT_INIT(236), \ _PyLong_DIGIT_INIT(237), \ _PyLong_DIGIT_INIT(238), \ _PyLong_DIGIT_INIT(239), \ _PyLong_DIGIT_INIT(240), \ _PyLong_DIGIT_INIT(241), \ _PyLong_DIGIT_INIT(242), \ _PyLong_DIGIT_INIT(243), \ _PyLong_DIGIT_INIT(244), \ _PyLong_DIGIT_INIT(245), \ _PyLong_DIGIT_INIT(246), \ _PyLong_DIGIT_INIT(247), \ _PyLong_DIGIT_INIT(248), \ _PyLong_DIGIT_INIT(249), \ _PyLong_DIGIT_INIT(250), \ _PyLong_DIGIT_INIT(251), \ _PyLong_DIGIT_INIT(252), \ _PyLong_DIGIT_INIT(253), \ _PyLong_DIGIT_INIT(254), \ _PyLong_DIGIT_INIT(255), \ _PyLong_DIGIT_INIT(256), \ }, \ \ .bytes_empty = _PyBytes_SIMPLE_INIT(0, 0), \ .bytes_characters = { \ _PyBytes_CHAR_INIT(0), \ _PyBytes_CHAR_INIT(1), \ _PyBytes_CHAR_INIT(2), \ _PyBytes_CHAR_INIT(3), \ _PyBytes_CHAR_INIT(4), \ _PyBytes_CHAR_INIT(5), \ _PyBytes_CHAR_INIT(6), \ _PyBytes_CHAR_INIT(7), \ _PyBytes_CHAR_INIT(8), \ _PyBytes_CHAR_INIT(9), \ _PyBytes_CHAR_INIT(10), \ _PyBytes_CHAR_INIT(11), \ _PyBytes_CHAR_INIT(12), \ _PyBytes_CHAR_INIT(13), \ _PyBytes_CHAR_INIT(14), \ _PyBytes_CHAR_INIT(15), \ _PyBytes_CHAR_INIT(16), \ _PyBytes_CHAR_INIT(17), \ _PyBytes_CHAR_INIT(18), \ _PyBytes_CHAR_INIT(19), \ _PyBytes_CHAR_INIT(20), \ _PyBytes_CHAR_INIT(21), \ _PyBytes_CHAR_INIT(22), \ _PyBytes_CHAR_INIT(23), \ _PyBytes_CHAR_INIT(24), \ _PyBytes_CHAR_INIT(25), \ _PyBytes_CHAR_INIT(26), \ _PyBytes_CHAR_INIT(27), \ _PyBytes_CHAR_INIT(28), \ _PyBytes_CHAR_INIT(29), \ _PyBytes_CHAR_INIT(30), \ _PyBytes_CHAR_INIT(31), \ _PyBytes_CHAR_INIT(32), \ _PyBytes_CHAR_INIT(33), \ _PyBytes_CHAR_INIT(34), \ _PyBytes_CHAR_INIT(35), \ _PyBytes_CHAR_INIT(36), \ _PyBytes_CHAR_INIT(37), \ _PyBytes_CHAR_INIT(38), \ _PyBytes_CHAR_INIT(39), \ _PyBytes_CHAR_INIT(40), \ _PyBytes_CHAR_INIT(41), \ _PyBytes_CHAR_INIT(42), \ _PyBytes_CHAR_INIT(43), \ _PyBytes_CHAR_INIT(44), \ _PyBytes_CHAR_INIT(45), \ _PyBytes_CHAR_INIT(46), \ _PyBytes_CHAR_INIT(47), \ _PyBytes_CHAR_INIT(48), \ _PyBytes_CHAR_INIT(49), \ _PyBytes_CHAR_INIT(50), \ _PyBytes_CHAR_INIT(51), \ _PyBytes_CHAR_INIT(52), \ _PyBytes_CHAR_INIT(53), \ _PyBytes_CHAR_INIT(54), \ _PyBytes_CHAR_INIT(55), \ _PyBytes_CHAR_INIT(56), \ _PyBytes_CHAR_INIT(57), \ _PyBytes_CHAR_INIT(58), \ _PyBytes_CHAR_INIT(59), \ _PyBytes_CHAR_INIT(60), \ _PyBytes_CHAR_INIT(61), \ _PyBytes_CHAR_INIT(62), \ _PyBytes_CHAR_INIT(63), \ _PyBytes_CHAR_INIT(64), \ _PyBytes_CHAR_INIT(65), \ _PyBytes_CHAR_INIT(66), \ _PyBytes_CHAR_INIT(67), \ _PyBytes_CHAR_INIT(68), \ _PyBytes_CHAR_INIT(69), \ _PyBytes_CHAR_INIT(70), \ _PyBytes_CHAR_INIT(71), \ _PyBytes_CHAR_INIT(72), \ _PyBytes_CHAR_INIT(73), \ _PyBytes_CHAR_INIT(74), \ _PyBytes_CHAR_INIT(75), \ _PyBytes_CHAR_INIT(76), \ _PyBytes_CHAR_INIT(77), \ _PyBytes_CHAR_INIT(78), \ _PyBytes_CHAR_INIT(79), \ _PyBytes_CHAR_INIT(80), \ _PyBytes_CHAR_INIT(81), \ _PyBytes_CHAR_INIT(82), \ _PyBytes_CHAR_INIT(83), \ _PyBytes_CHAR_INIT(84), \ _PyBytes_CHAR_INIT(85), \ _PyBytes_CHAR_INIT(86), \ _PyBytes_CHAR_INIT(87), \ _PyBytes_CHAR_INIT(88), \ _PyBytes_CHAR_INIT(89), \ _PyBytes_CHAR_INIT(90), \ _PyBytes_CHAR_INIT(91), \ _PyBytes_CHAR_INIT(92), \ _PyBytes_CHAR_INIT(93), \ _PyBytes_CHAR_INIT(94), \ _PyBytes_CHAR_INIT(95), \ _PyBytes_CHAR_INIT(96), \ _PyBytes_CHAR_INIT(97), \ _PyBytes_CHAR_INIT(98), \ _PyBytes_CHAR_INIT(99), \ _PyBytes_CHAR_INIT(100), \ _PyBytes_CHAR_INIT(101), \ _PyBytes_CHAR_INIT(102), \ _PyBytes_CHAR_INIT(103), \ _PyBytes_CHAR_INIT(104), \ _PyBytes_CHAR_INIT(105), \ _PyBytes_CHAR_INIT(106), \ _PyBytes_CHAR_INIT(107), \ _PyBytes_CHAR_INIT(108), \ _PyBytes_CHAR_INIT(109), \ _PyBytes_CHAR_INIT(110), \ _PyBytes_CHAR_INIT(111), \ _PyBytes_CHAR_INIT(112), \ _PyBytes_CHAR_INIT(113), \ _PyBytes_CHAR_INIT(114), \ _PyBytes_CHAR_INIT(115), \ _PyBytes_CHAR_INIT(116), \ _PyBytes_CHAR_INIT(117), \ _PyBytes_CHAR_INIT(118), \ _PyBytes_CHAR_INIT(119), \ _PyBytes_CHAR_INIT(120), \ _PyBytes_CHAR_INIT(121), \ _PyBytes_CHAR_INIT(122), \ _PyBytes_CHAR_INIT(123), \ _PyBytes_CHAR_INIT(124), \ _PyBytes_CHAR_INIT(125), \ _PyBytes_CHAR_INIT(126), \ _PyBytes_CHAR_INIT(127), \ _PyBytes_CHAR_INIT(128), \ _PyBytes_CHAR_INIT(129), \ _PyBytes_CHAR_INIT(130), \ _PyBytes_CHAR_INIT(131), \ _PyBytes_CHAR_INIT(132), \ _PyBytes_CHAR_INIT(133), \ _PyBytes_CHAR_INIT(134), \ _PyBytes_CHAR_INIT(135), \ _PyBytes_CHAR_INIT(136), \ _PyBytes_CHAR_INIT(137), \ _PyBytes_CHAR_INIT(138), \ _PyBytes_CHAR_INIT(139), \ _PyBytes_CHAR_INIT(140), \ _PyBytes_CHAR_INIT(141), \ _PyBytes_CHAR_INIT(142), \ _PyBytes_CHAR_INIT(143), \ _PyBytes_CHAR_INIT(144), \ _PyBytes_CHAR_INIT(145), \ _PyBytes_CHAR_INIT(146), \ _PyBytes_CHAR_INIT(147), \ _PyBytes_CHAR_INIT(148), \ _PyBytes_CHAR_INIT(149), \ _PyBytes_CHAR_INIT(150), \ _PyBytes_CHAR_INIT(151), \ _PyBytes_CHAR_INIT(152), \ _PyBytes_CHAR_INIT(153), \ _PyBytes_CHAR_INIT(154), \ _PyBytes_CHAR_INIT(155), \ _PyBytes_CHAR_INIT(156), \ _PyBytes_CHAR_INIT(157), \ _PyBytes_CHAR_INIT(158), \ _PyBytes_CHAR_INIT(159), \ _PyBytes_CHAR_INIT(160), \ _PyBytes_CHAR_INIT(161), \ _PyBytes_CHAR_INIT(162), \ _PyBytes_CHAR_INIT(163), \ _PyBytes_CHAR_INIT(164), \ _PyBytes_CHAR_INIT(165), \ _PyBytes_CHAR_INIT(166), \ _PyBytes_CHAR_INIT(167), \ _PyBytes_CHAR_INIT(168), \ _PyBytes_CHAR_INIT(169), \ _PyBytes_CHAR_INIT(170), \ _PyBytes_CHAR_INIT(171), \ _PyBytes_CHAR_INIT(172), \ _PyBytes_CHAR_INIT(173), \ _PyBytes_CHAR_INIT(174), \ _PyBytes_CHAR_INIT(175), \ _PyBytes_CHAR_INIT(176), \ _PyBytes_CHAR_INIT(177), \ _PyBytes_CHAR_INIT(178), \ _PyBytes_CHAR_INIT(179), \ _PyBytes_CHAR_INIT(180), \ _PyBytes_CHAR_INIT(181), \ _PyBytes_CHAR_INIT(182), \ _PyBytes_CHAR_INIT(183), \ _PyBytes_CHAR_INIT(184), \ _PyBytes_CHAR_INIT(185), \ _PyBytes_CHAR_INIT(186), \ _PyBytes_CHAR_INIT(187), \ _PyBytes_CHAR_INIT(188), \ _PyBytes_CHAR_INIT(189), \ _PyBytes_CHAR_INIT(190), \ _PyBytes_CHAR_INIT(191), \ _PyBytes_CHAR_INIT(192), \ _PyBytes_CHAR_INIT(193), \ _PyBytes_CHAR_INIT(194), \ _PyBytes_CHAR_INIT(195), \ _PyBytes_CHAR_INIT(196), \ _PyBytes_CHAR_INIT(197), \ _PyBytes_CHAR_INIT(198), \ _PyBytes_CHAR_INIT(199), \ _PyBytes_CHAR_INIT(200), \ _PyBytes_CHAR_INIT(201), \ _PyBytes_CHAR_INIT(202), \ _PyBytes_CHAR_INIT(203), \ _PyBytes_CHAR_INIT(204), \ _PyBytes_CHAR_INIT(205), \ _PyBytes_CHAR_INIT(206), \ _PyBytes_CHAR_INIT(207), \ _PyBytes_CHAR_INIT(208), \ _PyBytes_CHAR_INIT(209), \ _PyBytes_CHAR_INIT(210), \ _PyBytes_CHAR_INIT(211), \ _PyBytes_CHAR_INIT(212), \ _PyBytes_CHAR_INIT(213), \ _PyBytes_CHAR_INIT(214), \ _PyBytes_CHAR_INIT(215), \ _PyBytes_CHAR_INIT(216), \ _PyBytes_CHAR_INIT(217), \ _PyBytes_CHAR_INIT(218), \ _PyBytes_CHAR_INIT(219), \ _PyBytes_CHAR_INIT(220), \ _PyBytes_CHAR_INIT(221), \ _PyBytes_CHAR_INIT(222), \ _PyBytes_CHAR_INIT(223), \ _PyBytes_CHAR_INIT(224), \ _PyBytes_CHAR_INIT(225), \ _PyBytes_CHAR_INIT(226), \ _PyBytes_CHAR_INIT(227), \ _PyBytes_CHAR_INIT(228), \ _PyBytes_CHAR_INIT(229), \ _PyBytes_CHAR_INIT(230), \ _PyBytes_CHAR_INIT(231), \ _PyBytes_CHAR_INIT(232), \ _PyBytes_CHAR_INIT(233), \ _PyBytes_CHAR_INIT(234), \ _PyBytes_CHAR_INIT(235), \ _PyBytes_CHAR_INIT(236), \ _PyBytes_CHAR_INIT(237), \ _PyBytes_CHAR_INIT(238), \ _PyBytes_CHAR_INIT(239), \ _PyBytes_CHAR_INIT(240), \ _PyBytes_CHAR_INIT(241), \ _PyBytes_CHAR_INIT(242), \ _PyBytes_CHAR_INIT(243), \ _PyBytes_CHAR_INIT(244), \ _PyBytes_CHAR_INIT(245), \ _PyBytes_CHAR_INIT(246), \ _PyBytes_CHAR_INIT(247), \ _PyBytes_CHAR_INIT(248), \ _PyBytes_CHAR_INIT(249), \ _PyBytes_CHAR_INIT(250), \ _PyBytes_CHAR_INIT(251), \ _PyBytes_CHAR_INIT(252), \ _PyBytes_CHAR_INIT(253), \ _PyBytes_CHAR_INIT(254), \ _PyBytes_CHAR_INIT(255), \ }, \ \ .strings = { \ .literals = { \ INIT_STR(anon_dictcomp, "<dictcomp>"), \ INIT_STR(anon_genexpr, "<genexpr>"), \ INIT_STR(anon_lambda, "<lambda>"), \ INIT_STR(anon_listcomp, "<listcomp>"), \ INIT_STR(anon_module, "<module>"), \ INIT_STR(anon_setcomp, "<setcomp>"), \ INIT_STR(anon_string, "<string>"), \ INIT_STR(anon_unknown, "<unknown>"), \ INIT_STR(close_br, "}"), \ INIT_STR(comma_sep, ", "), \ INIT_STR(dbl_close_br, "}}"), \ INIT_STR(dbl_open_br, "{{"), \ INIT_STR(dbl_percent, "%%"), \ INIT_STR(dot, "."), \ INIT_STR(dot_locals, ".<locals>"), \ INIT_STR(empty, ""), \ INIT_STR(list_err, "list index out of range"), \ INIT_STR(newline, "\n"), \ INIT_STR(open_br, "{"), \ INIT_STR(percent, "%"), \ INIT_STR(utf_8, "utf-8"), \ }, \ .identifiers = { \ INIT_ID(False), \ INIT_ID(Py_Repr), \ INIT_ID(TextIOWrapper), \ INIT_ID(True), \ INIT_ID(WarningMessage), \ INIT_ID(_), \ INIT_ID(__IOBase_closed), \ INIT_ID(__abc_tpflags__), \ INIT_ID(__abs__), \ INIT_ID(__abstractmethods__), \ INIT_ID(__add__), \ INIT_ID(__aenter__), \ INIT_ID(__aexit__), \ INIT_ID(__aiter__), \ INIT_ID(__all__), \ INIT_ID(__and__), \ INIT_ID(__anext__), \ INIT_ID(__annotations__), \ INIT_ID(__args__), \ INIT_ID(__await__), \ INIT_ID(__bases__), \ INIT_ID(__bool__), \ INIT_ID(__build_class__), \ INIT_ID(__builtins__), \ INIT_ID(__bytes__), \ INIT_ID(__call__), \ INIT_ID(__cantrace__), \ INIT_ID(__class__), \ INIT_ID(__class_getitem__), \ INIT_ID(__classcell__), \ INIT_ID(__complex__), \ INIT_ID(__contains__), \ INIT_ID(__copy__), \ INIT_ID(__del__), \ INIT_ID(__delattr__), \ INIT_ID(__delete__), \ INIT_ID(__delitem__), \ INIT_ID(__dict__), \ INIT_ID(__dir__), \ INIT_ID(__divmod__), \ INIT_ID(__doc__), \ INIT_ID(__enter__), \ INIT_ID(__eq__), \ INIT_ID(__exit__), \ INIT_ID(__file__), \ INIT_ID(__float__), \ INIT_ID(__floordiv__), \ INIT_ID(__format__), \ INIT_ID(__fspath__), \ INIT_ID(__ge__), \ INIT_ID(__get__), \ INIT_ID(__getattr__), \ INIT_ID(__getattribute__), \ INIT_ID(__getinitargs__), \ INIT_ID(__getitem__), \ INIT_ID(__getnewargs__), \ INIT_ID(__getnewargs_ex__), \ INIT_ID(__getstate__), \ INIT_ID(__gt__), \ INIT_ID(__hash__), \ INIT_ID(__iadd__), \ INIT_ID(__iand__), \ INIT_ID(__ifloordiv__), \ INIT_ID(__ilshift__), \ INIT_ID(__imatmul__), \ INIT_ID(__imod__), \ INIT_ID(__import__), \ INIT_ID(__imul__), \ INIT_ID(__index__), \ INIT_ID(__init__), \ INIT_ID(__init_subclass__), \ INIT_ID(__instancecheck__), \ INIT_ID(__int__), \ INIT_ID(__invert__), \ INIT_ID(__ior__), \ INIT_ID(__ipow__), \ INIT_ID(__irshift__), \ INIT_ID(__isabstractmethod__), \ INIT_ID(__isub__), \ INIT_ID(__iter__), \ INIT_ID(__itruediv__), \ INIT_ID(__ixor__), \ INIT_ID(__le__), \ INIT_ID(__len__), \ INIT_ID(__length_hint__), \ INIT_ID(__lltrace__), \ INIT_ID(__loader__), \ INIT_ID(__lshift__), \ INIT_ID(__lt__), \ INIT_ID(__main__), \ INIT_ID(__matmul__), \ INIT_ID(__missing__), \ INIT_ID(__mod__), \ INIT_ID(__module__), \ INIT_ID(__mro_entries__), \ INIT_ID(__mul__), \ INIT_ID(__name__), \ INIT_ID(__ne__), \ INIT_ID(__neg__), \ INIT_ID(__new__), \ INIT_ID(__newobj__), \ INIT_ID(__newobj_ex__), \ INIT_ID(__next__), \ INIT_ID(__notes__), \ INIT_ID(__or__), \ INIT_ID(__orig_class__), \ INIT_ID(__origin__), \ INIT_ID(__package__), \ INIT_ID(__parameters__), \ INIT_ID(__path__), \ INIT_ID(__pos__), \ INIT_ID(__pow__), \ INIT_ID(__prepare__), \ INIT_ID(__qualname__), \ INIT_ID(__radd__), \ INIT_ID(__rand__), \ INIT_ID(__rdivmod__), \ INIT_ID(__reduce__), \ INIT_ID(__reduce_ex__), \ INIT_ID(__repr__), \ INIT_ID(__reversed__), \ INIT_ID(__rfloordiv__), \ INIT_ID(__rlshift__), \ INIT_ID(__rmatmul__), \ INIT_ID(__rmod__), \ INIT_ID(__rmul__), \ INIT_ID(__ror__), \ INIT_ID(__round__), \ INIT_ID(__rpow__), \ INIT_ID(__rrshift__), \ INIT_ID(__rshift__), \ INIT_ID(__rsub__), \ INIT_ID(__rtruediv__), \ INIT_ID(__rxor__), \ INIT_ID(__set__), \ INIT_ID(__set_name__), \ INIT_ID(__setattr__), \ INIT_ID(__setitem__), \ INIT_ID(__setstate__), \ INIT_ID(__sizeof__), \ INIT_ID(__slotnames__), \ INIT_ID(__slots__), \ INIT_ID(__spec__), \ INIT_ID(__str__), \ INIT_ID(__sub__), \ INIT_ID(__subclasscheck__), \ INIT_ID(__subclasshook__), \ INIT_ID(__truediv__), \ INIT_ID(__trunc__), \ INIT_ID(__typing_is_unpacked_typevartuple__), \ INIT_ID(__typing_prepare_subst__), \ INIT_ID(__typing_subst__), \ INIT_ID(__typing_unpacked_tuple_args__), \ INIT_ID(__warningregistry__), \ INIT_ID(__weakref__), \ INIT_ID(__xor__), \ INIT_ID(_abc_impl), \ INIT_ID(_annotation), \ INIT_ID(_blksize), \ INIT_ID(_bootstrap), \ INIT_ID(_dealloc_warn), \ INIT_ID(_finalizing), \ INIT_ID(_find_and_load), \ INIT_ID(_fix_up_module), \ INIT_ID(_get_sourcefile), \ INIT_ID(_handle_fromlist), \ INIT_ID(_initializing), \ INIT_ID(_is_text_encoding), \ INIT_ID(_lock_unlock_module), \ INIT_ID(_showwarnmsg), \ INIT_ID(_shutdown), \ INIT_ID(_slotnames), \ INIT_ID(_strptime_time), \ INIT_ID(_uninitialized_submodules), \ INIT_ID(_warn_unawaited_coroutine), \ INIT_ID(_xoptions), \ INIT_ID(add), \ INIT_ID(append), \ INIT_ID(big), \ INIT_ID(buffer), \ INIT_ID(builtins), \ INIT_ID(c_call), \ INIT_ID(c_exception), \ INIT_ID(c_return), \ INIT_ID(call), \ INIT_ID(clear), \ INIT_ID(close), \ INIT_ID(closed), \ INIT_ID(code), \ INIT_ID(copy), \ INIT_ID(copyreg), \ INIT_ID(decode), \ INIT_ID(default), \ INIT_ID(defaultaction), \ INIT_ID(dictcomp), \ INIT_ID(difference_update), \ INIT_ID(dispatch_table), \ INIT_ID(displayhook), \ INIT_ID(enable), \ INIT_ID(encode), \ INIT_ID(encoding), \ INIT_ID(end_lineno), \ INIT_ID(end_offset), \ INIT_ID(errors), \ INIT_ID(excepthook), \ INIT_ID(exception), \ INIT_ID(extend), \ INIT_ID(filename), \ INIT_ID(fileno), \ INIT_ID(fillvalue), \ INIT_ID(filters), \ INIT_ID(find_class), \ INIT_ID(flush), \ INIT_ID(genexpr), \ INIT_ID(get), \ INIT_ID(get_source), \ INIT_ID(getattr), \ INIT_ID(getstate), \ INIT_ID(ignore), \ INIT_ID(importlib), \ INIT_ID(inf), \ INIT_ID(intersection), \ INIT_ID(isatty), \ INIT_ID(isinstance), \ INIT_ID(items), \ INIT_ID(iter), \ INIT_ID(join), \ INIT_ID(keys), \ INIT_ID(lambda), \ INIT_ID(last_traceback), \ INIT_ID(last_type), \ INIT_ID(last_value), \ INIT_ID(latin1), \ INIT_ID(len), \ INIT_ID(line), \ INIT_ID(lineno), \ INIT_ID(listcomp), \ INIT_ID(little), \ INIT_ID(locale), \ INIT_ID(match), \ INIT_ID(metaclass), \ INIT_ID(mode), \ INIT_ID(modules), \ INIT_ID(mro), \ INIT_ID(msg), \ INIT_ID(n_fields), \ INIT_ID(n_sequence_fields), \ INIT_ID(n_unnamed_fields), \ INIT_ID(name), \ INIT_ID(newlines), \ INIT_ID(next), \ INIT_ID(obj), \ INIT_ID(offset), \ INIT_ID(onceregistry), \ INIT_ID(opcode), \ INIT_ID(open), \ INIT_ID(parent), \ INIT_ID(partial), \ INIT_ID(path), \ INIT_ID(peek), \ INIT_ID(persistent_id), \ INIT_ID(persistent_load), \ INIT_ID(print_file_and_line), \ INIT_ID(ps1), \ INIT_ID(ps2), \ INIT_ID(raw), \ INIT_ID(read), \ INIT_ID(read1), \ INIT_ID(readable), \ INIT_ID(readall), \ INIT_ID(readinto), \ INIT_ID(readinto1), \ INIT_ID(readline), \ INIT_ID(reducer_override), \ INIT_ID(reload), \ INIT_ID(replace), \ INIT_ID(reset), \ INIT_ID(return), \ INIT_ID(reversed), \ INIT_ID(seek), \ INIT_ID(seekable), \ INIT_ID(send), \ INIT_ID(setcomp), \ INIT_ID(setstate), \ INIT_ID(sort), \ INIT_ID(stderr), \ INIT_ID(stdin), \ INIT_ID(stdout), \ INIT_ID(strict), \ INIT_ID(symmetric_difference_update), \ INIT_ID(tell), \ INIT_ID(text), \ INIT_ID(threading), \ INIT_ID(throw), \ INIT_ID(top), \ INIT_ID(truncate), \ INIT_ID(unraisablehook), \ INIT_ID(values), \ INIT_ID(version), \ INIT_ID(warnings), \ INIT_ID(warnoptions), \ INIT_ID(writable), \ INIT_ID(write), \ INIT_ID(zipimporter), \ }, \ .ascii = { \ _PyASCIIObject_INIT("\x00"), \ _PyASCIIObject_INIT("\x01"), \ _PyASCIIObject_INIT("\x02"), \ _PyASCIIObject_INIT("\x03"), \ _PyASCIIObject_INIT("\x04"), \ _PyASCIIObject_INIT("\x05"), \ _PyASCIIObject_INIT("\x06"), \ _PyASCIIObject_INIT("\x07"), \ _PyASCIIObject_INIT("\x08"), \ _PyASCIIObject_INIT("\x09"), \ _PyASCIIObject_INIT("\x0a"), \ _PyASCIIObject_INIT("\x0b"), \ _PyASCIIObject_INIT("\x0c"), \ _PyASCIIObject_INIT("\x0d"), \ _PyASCIIObject_INIT("\x0e"), \ _PyASCIIObject_INIT("\x0f"), \ _PyASCIIObject_INIT("\x10"), \ _PyASCIIObject_INIT("\x11"), \ _PyASCIIObject_INIT("\x12"), \ _PyASCIIObject_INIT("\x13"), \ _PyASCIIObject_INIT("\x14"), \ _PyASCIIObject_INIT("\x15"), \ _PyASCIIObject_INIT("\x16"), \ _PyASCIIObject_INIT("\x17"), \ _PyASCIIObject_INIT("\x18"), \ _PyASCIIObject_INIT("\x19"), \ _PyASCIIObject_INIT("\x1a"), \ _PyASCIIObject_INIT("\x1b"), \ _PyASCIIObject_INIT("\x1c"), \ _PyASCIIObject_INIT("\x1d"), \ _PyASCIIObject_INIT("\x1e"), \ _PyASCIIObject_INIT("\x1f"), \ _PyASCIIObject_INIT("\x20"), \ _PyASCIIObject_INIT("\x21"), \ _PyASCIIObject_INIT("\x22"), \ _PyASCIIObject_INIT("\x23"), \ _PyASCIIObject_INIT("\x24"), \ _PyASCIIObject_INIT("\x25"), \ _PyASCIIObject_INIT("\x26"), \ _PyASCIIObject_INIT("\x27"), \ _PyASCIIObject_INIT("\x28"), \ _PyASCIIObject_INIT("\x29"), \ _PyASCIIObject_INIT("\x2a"), \ _PyASCIIObject_INIT("\x2b"), \ _PyASCIIObject_INIT("\x2c"), \ _PyASCIIObject_INIT("\x2d"), \ _PyASCIIObject_INIT("\x2e"), \ _PyASCIIObject_INIT("\x2f"), \ _PyASCIIObject_INIT("\x30"), \ _PyASCIIObject_INIT("\x31"), \ _PyASCIIObject_INIT("\x32"), \ _PyASCIIObject_INIT("\x33"), \ _PyASCIIObject_INIT("\x34"), \ _PyASCIIObject_INIT("\x35"), \ _PyASCIIObject_INIT("\x36"), \ _PyASCIIObject_INIT("\x37"), \ _PyASCIIObject_INIT("\x38"), \ _PyASCIIObject_INIT("\x39"), \ _PyASCIIObject_INIT("\x3a"), \ _PyASCIIObject_INIT("\x3b"), \ _PyASCIIObject_INIT("\x3c"), \ _PyASCIIObject_INIT("\x3d"), \ _PyASCIIObject_INIT("\x3e"), \ _PyASCIIObject_INIT("\x3f"), \ _PyASCIIObject_INIT("\x40"), \ _PyASCIIObject_INIT("\x41"), \ _PyASCIIObject_INIT("\x42"), \ _PyASCIIObject_INIT("\x43"), \ _PyASCIIObject_INIT("\x44"), \ _PyASCIIObject_INIT("\x45"), \ _PyASCIIObject_INIT("\x46"), \ _PyASCIIObject_INIT("\x47"), \ _PyASCIIObject_INIT("\x48"), \ _PyASCIIObject_INIT("\x49"), \ _PyASCIIObject_INIT("\x4a"), \ _PyASCIIObject_INIT("\x4b"), \ _PyASCIIObject_INIT("\x4c"), \ _PyASCIIObject_INIT("\x4d"), \ _PyASCIIObject_INIT("\x4e"), \ _PyASCIIObject_INIT("\x4f"), \ _PyASCIIObject_INIT("\x50"), \ _PyASCIIObject_INIT("\x51"), \ _PyASCIIObject_INIT("\x52"), \ _PyASCIIObject_INIT("\x53"), \ _PyASCIIObject_INIT("\x54"), \ _PyASCIIObject_INIT("\x55"), \ _PyASCIIObject_INIT("\x56"), \ _PyASCIIObject_INIT("\x57"), \ _PyASCIIObject_INIT("\x58"), \ _PyASCIIObject_INIT("\x59"), \ _PyASCIIObject_INIT("\x5a"), \ _PyASCIIObject_INIT("\x5b"), \ _PyASCIIObject_INIT("\x5c"), \ _PyASCIIObject_INIT("\x5d"), \ _PyASCIIObject_INIT("\x5e"), \ _PyASCIIObject_INIT("\x5f"), \ _PyASCIIObject_INIT("\x60"), \ _PyASCIIObject_INIT("\x61"), \ _PyASCIIObject_INIT("\x62"), \ _PyASCIIObject_INIT("\x63"), \ _PyASCIIObject_INIT("\x64"), \ _PyASCIIObject_INIT("\x65"), \ _PyASCIIObject_INIT("\x66"), \ _PyASCIIObject_INIT("\x67"), \ _PyASCIIObject_INIT("\x68"), \ _PyASCIIObject_INIT("\x69"), \ _PyASCIIObject_INIT("\x6a"), \ _PyASCIIObject_INIT("\x6b"), \ _PyASCIIObject_INIT("\x6c"), \ _PyASCIIObject_INIT("\x6d"), \ _PyASCIIObject_INIT("\x6e"), \ _PyASCIIObject_INIT("\x6f"), \ _PyASCIIObject_INIT("\x70"), \ _PyASCIIObject_INIT("\x71"), \ _PyASCIIObject_INIT("\x72"), \ _PyASCIIObject_INIT("\x73"), \ _PyASCIIObject_INIT("\x74"), \ _PyASCIIObject_INIT("\x75"), \ _PyASCIIObject_INIT("\x76"), \ _PyASCIIObject_INIT("\x77"), \ _PyASCIIObject_INIT("\x78"), \ _PyASCIIObject_INIT("\x79"), \ _PyASCIIObject_INIT("\x7a"), \ _PyASCIIObject_INIT("\x7b"), \ _PyASCIIObject_INIT("\x7c"), \ _PyASCIIObject_INIT("\x7d"), \ _PyASCIIObject_INIT("\x7e"), \ _PyASCIIObject_INIT("\x7f"), \ }, \ .latin1 = { \ _PyUnicode_LATIN1_INIT("\x80"), \ _PyUnicode_LATIN1_INIT("\x81"), \ _PyUnicode_LATIN1_INIT("\x82"), \ _PyUnicode_LATIN1_INIT("\x83"), \ _PyUnicode_LATIN1_INIT("\x84"), \ _PyUnicode_LATIN1_INIT("\x85"), \ _PyUnicode_LATIN1_INIT("\x86"), \ _PyUnicode_LATIN1_INIT("\x87"), \ _PyUnicode_LATIN1_INIT("\x88"), \ _PyUnicode_LATIN1_INIT("\x89"), \ _PyUnicode_LATIN1_INIT("\x8a"), \ _PyUnicode_LATIN1_INIT("\x8b"), \ _PyUnicode_LATIN1_INIT("\x8c"), \ _PyUnicode_LATIN1_INIT("\x8d"), \ _PyUnicode_LATIN1_INIT("\x8e"), \ _PyUnicode_LATIN1_INIT("\x8f"), \ _PyUnicode_LATIN1_INIT("\x90"), \ _PyUnicode_LATIN1_INIT("\x91"), \ _PyUnicode_LATIN1_INIT("\x92"), \ _PyUnicode_LATIN1_INIT("\x93"), \ _PyUnicode_LATIN1_INIT("\x94"), \ _PyUnicode_LATIN1_INIT("\x95"), \ _PyUnicode_LATIN1_INIT("\x96"), \ _PyUnicode_LATIN1_INIT("\x97"), \ _PyUnicode_LATIN1_INIT("\x98"), \ _PyUnicode_LATIN1_INIT("\x99"), \ _PyUnicode_LATIN1_INIT("\x9a"), \ _PyUnicode_LATIN1_INIT("\x9b"), \ _PyUnicode_LATIN1_INIT("\x9c"), \ _PyUnicode_LATIN1_INIT("\x9d"), \ _PyUnicode_LATIN1_INIT("\x9e"), \ _PyUnicode_LATIN1_INIT("\x9f"), \ _PyUnicode_LATIN1_INIT("\xa0"), \ _PyUnicode_LATIN1_INIT("\xa1"), \ _PyUnicode_LATIN1_INIT("\xa2"), \ _PyUnicode_LATIN1_INIT("\xa3"), \ _PyUnicode_LATIN1_INIT("\xa4"), \ _PyUnicode_LATIN1_INIT("\xa5"), \ _PyUnicode_LATIN1_INIT("\xa6"), \ _PyUnicode_LATIN1_INIT("\xa7"), \ _PyUnicode_LATIN1_INIT("\xa8"), \ _PyUnicode_LATIN1_INIT("\xa9"), \ _PyUnicode_LATIN1_INIT("\xaa"), \ _PyUnicode_LATIN1_INIT("\xab"), \ _PyUnicode_LATIN1_INIT("\xac"), \ _PyUnicode_LATIN1_INIT("\xad"), \ _PyUnicode_LATIN1_INIT("\xae"), \ _PyUnicode_LATIN1_INIT("\xaf"), \ _PyUnicode_LATIN1_INIT("\xb0"), \ _PyUnicode_LATIN1_INIT("\xb1"), \ _PyUnicode_LATIN1_INIT("\xb2"), \ _PyUnicode_LATIN1_INIT("\xb3"), \ _PyUnicode_LATIN1_INIT("\xb4"), \ _PyUnicode_LATIN1_INIT("\xb5"), \ _PyUnicode_LATIN1_INIT("\xb6"), \ _PyUnicode_LATIN1_INIT("\xb7"), \ _PyUnicode_LATIN1_INIT("\xb8"), \ _PyUnicode_LATIN1_INIT("\xb9"), \ _PyUnicode_LATIN1_INIT("\xba"), \ _PyUnicode_LATIN1_INIT("\xbb"), \ _PyUnicode_LATIN1_INIT("\xbc"), \ _PyUnicode_LATIN1_INIT("\xbd"), \ _PyUnicode_LATIN1_INIT("\xbe"), \ _PyUnicode_LATIN1_INIT("\xbf"), \ _PyUnicode_LATIN1_INIT("\xc0"), \ _PyUnicode_LATIN1_INIT("\xc1"), \ _PyUnicode_LATIN1_INIT("\xc2"), \ _PyUnicode_LATIN1_INIT("\xc3"), \ _PyUnicode_LATIN1_INIT("\xc4"), \ _PyUnicode_LATIN1_INIT("\xc5"), \ _PyUnicode_LATIN1_INIT("\xc6"), \ _PyUnicode_LATIN1_INIT("\xc7"), \ _PyUnicode_LATIN1_INIT("\xc8"), \ _PyUnicode_LATIN1_INIT("\xc9"), \ _PyUnicode_LATIN1_INIT("\xca"), \ _PyUnicode_LATIN1_INIT("\xcb"), \ _PyUnicode_LATIN1_INIT("\xcc"), \ _PyUnicode_LATIN1_INIT("\xcd"), \ _PyUnicode_LATIN1_INIT("\xce"), \ _PyUnicode_LATIN1_INIT("\xcf"), \ _PyUnicode_LATIN1_INIT("\xd0"), \ _PyUnicode_LATIN1_INIT("\xd1"), \ _PyUnicode_LATIN1_INIT("\xd2"), \ _PyUnicode_LATIN1_INIT("\xd3"), \ _PyUnicode_LATIN1_INIT("\xd4"), \ _PyUnicode_LATIN1_INIT("\xd5"), \ _PyUnicode_LATIN1_INIT("\xd6"), \ _PyUnicode_LATIN1_INIT("\xd7"), \ _PyUnicode_LATIN1_INIT("\xd8"), \ _PyUnicode_LATIN1_INIT("\xd9"), \ _PyUnicode_LATIN1_INIT("\xda"), \ _PyUnicode_LATIN1_INIT("\xdb"), \ _PyUnicode_LATIN1_INIT("\xdc"), \ _PyUnicode_LATIN1_INIT("\xdd"), \ _PyUnicode_LATIN1_INIT("\xde"), \ _PyUnicode_LATIN1_INIT("\xdf"), \ _PyUnicode_LATIN1_INIT("\xe0"), \ _PyUnicode_LATIN1_INIT("\xe1"), \ _PyUnicode_LATIN1_INIT("\xe2"), \ _PyUnicode_LATIN1_INIT("\xe3"), \ _PyUnicode_LATIN1_INIT("\xe4"), \ _PyUnicode_LATIN1_INIT("\xe5"), \ _PyUnicode_LATIN1_INIT("\xe6"), \ _PyUnicode_LATIN1_INIT("\xe7"), \ _PyUnicode_LATIN1_INIT("\xe8"), \ _PyUnicode_LATIN1_INIT("\xe9"), \ _PyUnicode_LATIN1_INIT("\xea"), \ _PyUnicode_LATIN1_INIT("\xeb"), \ _PyUnicode_LATIN1_INIT("\xec"), \ _PyUnicode_LATIN1_INIT("\xed"), \ _PyUnicode_LATIN1_INIT("\xee"), \ _PyUnicode_LATIN1_INIT("\xef"), \ _PyUnicode_LATIN1_INIT("\xf0"), \ _PyUnicode_LATIN1_INIT("\xf1"), \ _PyUnicode_LATIN1_INIT("\xf2"), \ _PyUnicode_LATIN1_INIT("\xf3"), \ _PyUnicode_LATIN1_INIT("\xf4"), \ _PyUnicode_LATIN1_INIT("\xf5"), \ _PyUnicode_LATIN1_INIT("\xf6"), \ _PyUnicode_LATIN1_INIT("\xf7"), \ _PyUnicode_LATIN1_INIT("\xf8"), \ _PyUnicode_LATIN1_INIT("\xf9"), \ _PyUnicode_LATIN1_INIT("\xfa"), \ _PyUnicode_LATIN1_INIT("\xfb"), \ _PyUnicode_LATIN1_INIT("\xfc"), \ _PyUnicode_LATIN1_INIT("\xfd"), \ _PyUnicode_LATIN1_INIT("\xfe"), \ _PyUnicode_LATIN1_INIT("\xff"), \ }, \ }, \ \ .tuple_empty = { \ .ob_base = _PyVarObject_IMMORTAL_INIT(&PyTuple_Type, 0) \ }, \ }, \ } / End auto-generated code / #ifdef __cplusplus } #endif #endif / !Py_INTERNAL_RUNTIME_INIT_H */	47.94 KB	2025-10-09 16:16
📄 pycore_signal.h // Define Py_NSIG constant for signal handling. #ifndef Py_INTERNAL_SIGNAL_H #define Py_INTERNAL_SIGNAL_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif #include <signal.h> // NSIG #ifdef _SIG_MAXSIG // gh-91145: On FreeBSD, <signal.h> defines NSIG as 32: it doesn't include // realtime signals: [SIGRTMIN,SIGRTMAX]. Use _SIG_MAXSIG instead. For // example on x86-64 FreeBSD 13, SIGRTMAX is 126 and _SIG_MAXSIG is 128. # define Py_NSIG _SIG_MAXSIG #elif defined(NSIG) # define Py_NSIG NSIG #elif defined(_NSIG) # define Py_NSIG _NSIG // BSD/SysV #elif defined(_SIGMAX) # define Py_NSIG (_SIGMAX + 1) // QNX #elif defined(SIGMAX) # define Py_NSIG (SIGMAX + 1) // djgpp #else # define Py_NSIG 64 // Use a reasonable default value #endif #ifdef __cplusplus } #endif #endif // !Py_INTERNAL_SIGNAL_H	937 B	2025-10-09 16:16
📄 pycore_sliceobject.h #ifndef Py_INTERNAL_SLICEOBJECT_H #define Py_INTERNAL_SLICEOBJECT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif /* runtime lifecycle / extern void _PySlice_Fini(PyInterpreterState ); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_SLICEOBJECT_H */	336 B	2025-10-09 16:16
📄 pycore_strhex.h #ifndef Py_INTERNAL_STRHEX_H #define Py_INTERNAL_STRHEX_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif // Returns a str() containing the hex representation of argbuf. 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, PyObject* sep, const int bytes_per_group); PyAPI_FUNC(PyObject) _Py_strhex_bytes_with_sep( const char argbuf, const Py_ssize_t arglen, PyObject* sep, const int bytes_per_group); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_STRHEX_H */	937 B	2025-10-09 16:16
📄 pycore_structseq.h #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 /* other API / PyAPI_FUNC(PyTypeObject ) _PyStructSequence_NewType( PyStructSequence_Desc desc, unsigned long tp_flags); PyAPI_FUNC(int) _PyStructSequence_InitType( PyTypeObject type, PyStructSequence_Desc desc, unsigned long tp_flags); extern void _PyStructSequence_FiniType(PyTypeObject type); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_STRUCTSEQ_H */	580 B	2025-10-09 16:16
📄 pycore_symtable.h #ifndef Py_INTERNAL_SYMTABLE_H #define Py_INTERNAL_SYMTABLE_H #ifdef __cplusplus extern "C" { #endif #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, 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 { PyObject st_filename; / name of file being compiled, decoded from the filesystem encoding / struct _symtable_entry st_cur; /* current symbol table entry / struct _symtable_entry st_top; /* symbol table entry for module / PyObject st_blocks; /* dict: map AST node addresses * to symbol table entries / PyObject st_stack; /* list: stack of namespace info / PyObject st_global; /* borrowed ref to st_top->ste_symbols / int st_nblocks; / number of blocks used. kept for consistency with the corresponding compiler structure / PyObject st_private; /* name of current class or NULL / PyFutureFeatures st_future; /* module's future features that affect the symbol table / int recursion_depth; / current recursion depth / int recursion_limit; / recursion limit / }; typedef struct _symtable_entry { PyObject_HEAD PyObject ste_id; /* int: key in ste_table->st_blocks / PyObject ste_symbols; /* dict: variable names to flags / PyObject ste_name; /* string: name of current block / 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 / 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 an argument / 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; extern PyTypeObject PySTEntry_Type; #define PySTEntry_Check(op) Py_IS_TYPE(op, &PySTEntry_Type) extern long _PyST_GetSymbol(PySTEntryObject , PyObject ); extern int _PyST_GetScope(PySTEntryObject , PyObject ); extern struct symtable* _PySymtable_Build( struct _mod mod, PyObject filename, PyFutureFeatures future); PyAPI_FUNC(PySTEntryObject ) PySymtable_Lookup(struct symtable , void ); extern void _PySymtable_Free(struct symtable ); / Flags for def-use information / #define DEF_GLOBAL 1 / global stmt / #define DEF_LOCAL 2 / assignment in code block / #define DEF_PARAM 2<<1 / formal parameter / #define DEF_NONLOCAL 2<<2 / nonlocal stmt / #define USE 2<<3 / name is used / #define DEF_FREE 2<<4 / name used but not defined in nested block / #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) / GLOBAL_EXPLICIT and GLOBAL_IMPLICIT are used internally by the symbol table. GLOBAL is returned from PyST_GetScope() for either of them. It is stored in ste_symbols at bits 12-15. / #define SCOPE_OFFSET 11 #define SCOPE_MASK (DEF_GLOBAL \| DEF_LOCAL \| DEF_PARAM \| DEF_NONLOCAL) #define LOCAL 1 #define GLOBAL_EXPLICIT 2 #define GLOBAL_IMPLICIT 3 #define FREE 4 #define CELL 5 #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_INTERNAL_SYMTABLE_H */	5.51 KB	2025-10-09 16:16
📄 pycore_sysmodule.h #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); PyAPI_FUNC(int) _PySys_SetAttr(PyObject , PyObject ); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_SYSMODULE_H */	605 B	2025-10-09 16:16
📄 pycore_traceback.h #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 /* Write the Python traceback into the file 'fd'. For example: Traceback (most recent call first): File "xxx", line xxx in <xxx> File "xxx", line xxx in <xxx> ... File "xxx", line xxx in <xxx> 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, PyInterpreterState 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); #define EXCEPTION_TB_HEADER "Traceback (most recent call last):\n" #define EXCEPTION_GROUP_TB_HEADER "Exception Group Traceback (most recent call last):\n" /* Write the traceback tb to file f. Prefix each line with indent spaces followed by the margin (if it is not NULL). / PyAPI_FUNC(int) _PyTraceBack_Print_Indented( PyObject tb, int indent, const char* margin, const char header_margin, const char header, PyObject f); PyAPI_FUNC(int) _Py_WriteIndentedMargin(int, const char, PyObject ); PyAPI_FUNC(int) _Py_WriteIndent(int, PyObject ); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_TRACEBACK_H */	3.42 KB	2025-10-09 16:16
📄 pycore_tuple.h #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() / / runtime lifecycle / extern PyStatus _PyTuple_InitGlobalObjects(PyInterpreterState ); extern PyStatus _PyTuple_InitTypes(PyInterpreterState ); extern void _PyTuple_Fini(PyInterpreterState ); /* other API / // PyTuple_MAXSAVESIZE - largest tuple to save on free list // PyTuple_MAXFREELIST - maximum number of tuples of each size to save #if defined(PyTuple_MAXSAVESIZE) && PyTuple_MAXSAVESIZE <= 0 // A build indicated that tuple freelists should not be used. # define PyTuple_NFREELISTS 0 # undef PyTuple_MAXSAVESIZE # undef PyTuple_MAXFREELIST #elif !defined(WITH_FREELISTS) # define PyTuple_NFREELISTS 0 # undef PyTuple_MAXSAVESIZE # undef PyTuple_MAXFREELIST #else // We are using a freelist for tuples. # ifndef PyTuple_MAXSAVESIZE # define PyTuple_MAXSAVESIZE 20 # endif # define PyTuple_NFREELISTS PyTuple_MAXSAVESIZE # ifndef PyTuple_MAXFREELIST # define PyTuple_MAXFREELIST 2000 # endif #endif struct _Py_tuple_state { #if PyTuple_NFREELISTS > 0 / There is one freelist for each size from 1 to PyTuple_MAXSAVESIZE. The empty tuple is handled separately. Each tuple stored in the array is the head of the linked list (and the next available tuple) for that size. The actual tuple object is used as the linked list node, with its first item (ob_item[0]) pointing to the next node (i.e. the previous head). Each linked list is initially NULL. / PyTupleObject free_list[PyTuple_NFREELISTS]; int numfree[PyTuple_NFREELISTS]; #else char _unused; // Empty structs are not allowed. #endif }; #define _PyTuple_ITEMS(op) (_PyTuple_CAST(op)->ob_item) extern PyObject _PyTuple_FromArray(PyObject const , Py_ssize_t); extern PyObject _PyTuple_FromArraySteal(PyObject const , Py_ssize_t); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_TUPLE_H */	2.04 KB	2025-10-09 16:16
📄 pycore_typeobject.h #ifndef Py_INTERNAL_TYPEOBJECT_H #define Py_INTERNAL_TYPEOBJECT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif /* runtime lifecycle / extern PyStatus _PyTypes_InitState(PyInterpreterState ); extern PyStatus _PyTypes_InitTypes(PyInterpreterState ); extern void _PyTypes_FiniTypes(PyInterpreterState ); extern void _PyTypes_Fini(PyInterpreterState ); / other API / // 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 }; extern PyStatus _PyTypes_InitSlotDefs(void); extern void _PyStaticType_Dealloc(PyTypeObject type); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_TYPEOBJECT_H */	1.13 KB	2025-10-09 16:16
📄 pycore_ucnhash.h /* 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 */	898 B	2025-10-09 16:16
📄 pycore_unicodeobject.h #ifndef Py_INTERNAL_UNICODEOBJECT_H #define Py_INTERNAL_UNICODEOBJECT_H #ifdef __cplusplus extern "C" { #endif #ifndef Py_BUILD_CORE # error "this header requires Py_BUILD_CORE define" #endif #include "pycore_fileutils.h" // _Py_error_handler void _PyUnicode_ExactDealloc(PyObject op); / runtime lifecycle / extern void _PyUnicode_InitState(PyInterpreterState ); extern PyStatus _PyUnicode_InitGlobalObjects(PyInterpreterState ); extern PyStatus _PyUnicode_InitTypes(PyInterpreterState ); extern void _PyUnicode_Fini(PyInterpreterState ); extern void _PyUnicode_FiniTypes(PyInterpreterState ); extern void _PyStaticUnicode_Dealloc(PyObject ); extern PyTypeObject _PyUnicodeASCIIIter_Type; / other API / 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; }; / 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_unicode_ids { Py_ssize_t size; PyObject array; }; struct _Py_unicode_state { struct _Py_unicode_fs_codec fs_codec; // Unicode identifiers (_Py_Identifier): see _PyUnicode_FromId() struct _Py_unicode_ids ids; }; extern void _PyUnicode_ClearInterned(PyInterpreterState interp); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_UNICODEOBJECT_H */	1.68 KB	2025-10-09 16:16
📄 pycore_unionobject.h #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 ); extern PyObject _Py_union_args(PyObject self); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_UNIONOBJECT_H */	678 B	2025-10-09 16:16
📄 pycore_warnings.h #ifndef Py_INTERNAL_WARNINGS_H #define Py_INTERNAL_WARNINGS_H #ifdef __cplusplus extern "C" { #endif #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; get_warnings_attr() will reset these variables accordingly. / PyObject filters; /* List / PyObject once_registry; /* Dict / PyObject default_action; /* String / long filters_version; }; extern int _PyWarnings_InitState(PyInterpreterState interp); PyAPI_FUNC(PyObject) _PyWarnings_Init(void); extern void _PyErr_WarnUnawaitedCoroutine(PyObject coro); #ifdef __cplusplus } #endif #endif /* !Py_INTERNAL_WARNINGS_H */	740 B	2025-10-09 16:16

Edit File:

Terminal