@ai-ecoverse/wasix-python 3.14.2-2

package/include/python3.14/objimpl.h

@@ -0,0 +1,211 @@
+// The PyObject_ memory family:  high-level object memory interfaces.
+// See pymem.h for the low-level PyMem_ family.
+
+#ifndef Py_OBJIMPL_H
+#define Py_OBJIMPL_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* BEWARE:
+
+   Each interface exports both functions and macros.  Extension modules should
+   use the functions, to ensure binary compatibility across Python versions.
+   Because the Python implementation is free to change internal details, and
+   the macros may (or may not) expose details for speed, if you do use the
+   macros you must recompile your extensions with each Python release.
+
+   Never mix calls to PyObject_ memory functions with calls to the platform
+   malloc/realloc/ calloc/free, or with calls to PyMem_.
+*/
+
+/*
+Functions and macros for modules that implement new object types.
+
+ - PyObject_New(type, typeobj) allocates memory for a new object of the given
+   type, and initializes part of it.  'type' must be the C structure type used
+   to represent the object, and 'typeobj' the address of the corresponding
+   type object.  Reference count and type pointer are filled in; the rest of
+   the bytes of the object are *undefined*!  The resulting expression type is
+   'type *'.  The size of the object is determined by the tp_basicsize field
+   of the type object.
+
+ - PyObject_NewVar(type, typeobj, n) is similar but allocates a variable-size
+   object with room for n items.  In addition to the refcount and type pointer
+   fields, this also fills in the ob_size field.
+
+ - PyObject_Free(op) releases the memory allocated for an object.  It does not
+   run a destructor -- it only frees the memory.
+
+ - PyObject_Init(op, typeobj) and PyObject_InitVar(op, typeobj, n) don't
+   allocate memory.  Instead of a 'type' parameter, they take a pointer to a
+   new object (allocated by an arbitrary allocator), and initialize its object
+   header fields.
+
+Note that objects created with PyObject_{New, NewVar} are allocated using the
+specialized Python allocator (implemented in obmalloc.c), if WITH_PYMALLOC is
+enabled.  In addition, a special debugging allocator is used if Py_DEBUG
+macro is also defined.
+
+In case a specific form of memory management is needed (for example, if you
+must use the platform malloc heap(s), or shared memory, or C++ local storage or
+operator new), you must first allocate the object with your custom allocator,
+then pass its pointer to PyObject_{Init, InitVar} for filling in its Python-
+specific fields:  reference count, type pointer, possibly others.  You should
+be aware that Python has no control over these objects because they don't
+cooperate with the Python memory manager.  Such objects may not be eligible
+for automatic garbage collection and you have to make sure that they are
+released accordingly whenever their destructor gets called (cf. the specific
+form of memory management you're using).
+
+Unless you have specific memory management requirements, use
+PyObject_{New, NewVar, Del}.
+*/
+
+/*
+ * Raw object memory interface
+ * ===========================
+ */
+
+/* Functions to call the same malloc/realloc/free as used by Python's
+   object allocator.  If WITH_PYMALLOC is enabled, these may differ from
+   the platform malloc/realloc/free.  The Python object allocator is
+   designed for fast, cache-conscious allocation of many "small" objects,
+   and with low hidden memory overhead.
+
+   PyObject_Malloc(0) returns a unique non-NULL pointer if possible.
+
+   PyObject_Realloc(NULL, n) acts like PyObject_Malloc(n).
+   PyObject_Realloc(p != NULL, 0) does not return  NULL, or free the memory
+   at p.
+
+   Returned pointers must be checked for NULL explicitly; no action is
+   performed on failure other than to return NULL (no warning it printed, no
+   exception is set, etc).
+
+   For allocating objects, use PyObject_{New, NewVar} instead whenever
+   possible.  The PyObject_{Malloc, Realloc, Free} family is exposed
+   so that you can exploit Python's small-block allocator for non-object
+   uses.  If you must use these routines to allocate object memory, make sure
+   the object gets initialized via PyObject_{Init, InitVar} after obtaining
+   the raw memory.
+*/
+PyAPI_FUNC(void *) PyObject_Malloc(size_t size);
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03050000
+PyAPI_FUNC(void *) PyObject_Calloc(size_t nelem, size_t elsize);
+#endif
+PyAPI_FUNC(void *) PyObject_Realloc(void *ptr, size_t new_size);
+PyAPI_FUNC(void) PyObject_Free(void *ptr);
+
+
+// Deprecated aliases only kept for backward compatibility.
+// PyObject_Del and PyObject_DEL are defined with no parameter to be able to
+// use them as function pointers (ex: tp_free = PyObject_Del).
+#define PyObject_MALLOC         PyObject_Malloc
+#define PyObject_REALLOC        PyObject_Realloc
+#define PyObject_FREE           PyObject_Free
+#define PyObject_Del            PyObject_Free
+#define PyObject_DEL            PyObject_Free
+
+
+/*
+ * Generic object allocator interface
+ * ==================================
+ */
+
+/* Functions */
+PyAPI_FUNC(PyObject *) PyObject_Init(PyObject *, PyTypeObject *);
+PyAPI_FUNC(PyVarObject *) PyObject_InitVar(PyVarObject *,
+                                           PyTypeObject *, Py_ssize_t);
+
+#define PyObject_INIT(op, typeobj) \
+    PyObject_Init(_PyObject_CAST(op), (typeobj))
+#define PyObject_INIT_VAR(op, typeobj, size) \
+    PyObject_InitVar(_PyVarObject_CAST(op), (typeobj), (size))
+
+
+PyAPI_FUNC(PyObject *) _PyObject_New(PyTypeObject *);
+PyAPI_FUNC(PyVarObject *) _PyObject_NewVar(PyTypeObject *, Py_ssize_t);
+
+#define PyObject_New(type, typeobj) ((type *)_PyObject_New(typeobj))
+
+// Alias to PyObject_New(). In Python 3.8, PyObject_NEW() called directly
+// PyObject_MALLOC() with _PyObject_SIZE().
+#define PyObject_NEW(type, typeobj) PyObject_New(type, (typeobj))
+
+#define PyObject_NewVar(type, typeobj, n) \
+                ( (type *) _PyObject_NewVar((typeobj), (n)) )
+
+// Alias to PyObject_NewVar(). In Python 3.8, PyObject_NEW_VAR() called
+// directly PyObject_MALLOC() with _PyObject_VAR_SIZE().
+#define PyObject_NEW_VAR(type, typeobj, n) PyObject_NewVar(type, (typeobj), (n))
+
+
+/*
+ * Garbage Collection Support
+ * ==========================
+ */
+
+/* C equivalent of gc.collect(). */
+PyAPI_FUNC(Py_ssize_t) PyGC_Collect(void);
+/* C API for controlling the state of the garbage collector */
+PyAPI_FUNC(int) PyGC_Enable(void);
+PyAPI_FUNC(int) PyGC_Disable(void);
+PyAPI_FUNC(int) PyGC_IsEnabled(void);
+
+/* Test if a type has a GC head */
+#define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC)
+
+PyAPI_FUNC(PyVarObject *) _PyObject_GC_Resize(PyVarObject *, Py_ssize_t);
+#define PyObject_GC_Resize(type, op, n) \
+                ( (type *) _PyObject_GC_Resize(_PyVarObject_CAST(op), (n)) )
+
+
+
+PyAPI_FUNC(PyObject *) _PyObject_GC_New(PyTypeObject *);
+PyAPI_FUNC(PyVarObject *) _PyObject_GC_NewVar(PyTypeObject *, Py_ssize_t);
+
+/* Tell the GC to track this object.
+ *
+ * See also private _PyObject_GC_TRACK() macro. */
+PyAPI_FUNC(void) PyObject_GC_Track(void *);
+
+/* Tell the GC to stop tracking this object.
+ *
+ * See also private _PyObject_GC_UNTRACK() macro. */
+PyAPI_FUNC(void) PyObject_GC_UnTrack(void *);
+
+PyAPI_FUNC(void) PyObject_GC_Del(void *);
+
+#define PyObject_GC_New(type, typeobj) \
+    _Py_CAST(type*, _PyObject_GC_New(typeobj))
+#define PyObject_GC_NewVar(type, typeobj, n) \
+    _Py_CAST(type*, _PyObject_GC_NewVar((typeobj), (n)))
+
+PyAPI_FUNC(int) PyObject_GC_IsTracked(PyObject *);
+PyAPI_FUNC(int) PyObject_GC_IsFinalized(PyObject *);
+
+/* Utility macro to help write tp_traverse functions.
+ * To use this macro, the tp_traverse function must name its arguments
+ * "visit" and "arg".  This is intended to keep tp_traverse functions
+ * looking as much alike as possible.
+ */
+#define Py_VISIT(op)                                                    \
+    do {                                                                \
+        if (op) {                                                       \
+            int vret = visit(_PyObject_CAST(op), arg);                  \
+            if (vret)                                                   \
+                return vret;                                            \
+        }                                                               \
+    } while (0)
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_OBJIMPL_H
+#  include "cpython/objimpl.h"
+#  undef Py_CPYTHON_OBJIMPL_H
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif   // !Py_OBJIMPL_H

package/include/python3.14/opcode.h

@@ -0,0 +1,43 @@
+#ifndef Py_OPCODE_H
+#define Py_OPCODE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "opcode_ids.h"
+
+
+#define NB_ADD                                   0
+#define NB_AND                                   1
+#define NB_FLOOR_DIVIDE                          2
+#define NB_LSHIFT                                3
+#define NB_MATRIX_MULTIPLY                       4
+#define NB_MULTIPLY                              5
+#define NB_REMAINDER                             6
+#define NB_OR                                    7
+#define NB_POWER                                 8
+#define NB_RSHIFT                                9
+#define NB_SUBTRACT                             10
+#define NB_TRUE_DIVIDE                          11
+#define NB_XOR                                  12
+#define NB_INPLACE_ADD                          13
+#define NB_INPLACE_AND                          14
+#define NB_INPLACE_FLOOR_DIVIDE                 15
+#define NB_INPLACE_LSHIFT                       16
+#define NB_INPLACE_MATRIX_MULTIPLY              17
+#define NB_INPLACE_MULTIPLY                     18
+#define NB_INPLACE_REMAINDER                    19
+#define NB_INPLACE_OR                           20
+#define NB_INPLACE_POWER                        21
+#define NB_INPLACE_RSHIFT                       22
+#define NB_INPLACE_SUBTRACT                     23
+#define NB_INPLACE_TRUE_DIVIDE                  24
+#define NB_INPLACE_XOR                          25
+#define NB_SUBSCR                               26
+
+#define NB_OPARG_LAST                           26
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_OPCODE_H */

package/include/python3.14/opcode_ids.h

@@ -0,0 +1,259 @@
+// This file is generated by Tools/cases_generator/opcode_id_generator.py
+// from:
+//   Python/bytecodes.c
+// Do not edit!
+
+#ifndef Py_OPCODE_IDS_H
+#define Py_OPCODE_IDS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Instruction opcodes for compiled code */
+#define CACHE                                    0
+#define BINARY_SLICE                             1
+#define BUILD_TEMPLATE                           2
+#define BINARY_OP_INPLACE_ADD_UNICODE            3
+#define CALL_FUNCTION_EX                         4
+#define CHECK_EG_MATCH                           5
+#define CHECK_EXC_MATCH                          6
+#define CLEANUP_THROW                            7
+#define DELETE_SUBSCR                            8
+#define END_FOR                                  9
+#define END_SEND                                10
+#define EXIT_INIT_CHECK                         11
+#define FORMAT_SIMPLE                           12
+#define FORMAT_WITH_SPEC                        13
+#define GET_AITER                               14
+#define GET_ANEXT                               15
+#define GET_ITER                                16
+#define RESERVED                                17
+#define GET_LEN                                 18
+#define GET_YIELD_FROM_ITER                     19
+#define INTERPRETER_EXIT                        20
+#define LOAD_BUILD_CLASS                        21
+#define LOAD_LOCALS                             22
+#define MAKE_FUNCTION                           23
+#define MATCH_KEYS                              24
+#define MATCH_MAPPING                           25
+#define MATCH_SEQUENCE                          26
+#define NOP                                     27
+#define NOT_TAKEN                               28
+#define POP_EXCEPT                              29
+#define POP_ITER                                30
+#define POP_TOP                                 31
+#define PUSH_EXC_INFO                           32
+#define PUSH_NULL                               33
+#define RETURN_GENERATOR                        34
+#define RETURN_VALUE                            35
+#define SETUP_ANNOTATIONS                       36
+#define STORE_SLICE                             37
+#define STORE_SUBSCR                            38
+#define TO_BOOL                                 39
+#define UNARY_INVERT                            40
+#define UNARY_NEGATIVE                          41
+#define UNARY_NOT                               42
+#define WITH_EXCEPT_START                       43
+#define BINARY_OP                               44
+#define BUILD_INTERPOLATION                     45
+#define BUILD_LIST                              46
+#define BUILD_MAP                               47
+#define BUILD_SET                               48
+#define BUILD_SLICE                             49
+#define BUILD_STRING                            50
+#define BUILD_TUPLE                             51
+#define CALL                                    52
+#define CALL_INTRINSIC_1                        53
+#define CALL_INTRINSIC_2                        54
+#define CALL_KW                                 55
+#define COMPARE_OP                              56
+#define CONTAINS_OP                             57
+#define CONVERT_VALUE                           58
+#define COPY                                    59
+#define COPY_FREE_VARS                          60
+#define DELETE_ATTR                             61
+#define DELETE_DEREF                            62
+#define DELETE_FAST                             63
+#define DELETE_GLOBAL                           64
+#define DELETE_NAME                             65
+#define DICT_MERGE                              66
+#define DICT_UPDATE                             67
+#define END_ASYNC_FOR                           68
+#define EXTENDED_ARG                            69
+#define FOR_ITER                                70
+#define GET_AWAITABLE                           71
+#define IMPORT_FROM                             72
+#define IMPORT_NAME                             73
+#define IS_OP                                   74
+#define JUMP_BACKWARD                           75
+#define JUMP_BACKWARD_NO_INTERRUPT              76
+#define JUMP_FORWARD                            77
+#define LIST_APPEND                             78
+#define LIST_EXTEND                             79
+#define LOAD_ATTR                               80
+#define LOAD_COMMON_CONSTANT                    81
+#define LOAD_CONST                              82
+#define LOAD_DEREF                              83
+#define LOAD_FAST                               84
+#define LOAD_FAST_AND_CLEAR                     85
+#define LOAD_FAST_BORROW                        86
+#define LOAD_FAST_BORROW_LOAD_FAST_BORROW       87
+#define LOAD_FAST_CHECK                         88
+#define LOAD_FAST_LOAD_FAST                     89
+#define LOAD_FROM_DICT_OR_DEREF                 90
+#define LOAD_FROM_DICT_OR_GLOBALS               91
+#define LOAD_GLOBAL                             92
+#define LOAD_NAME                               93
+#define LOAD_SMALL_INT                          94
+#define LOAD_SPECIAL                            95
+#define LOAD_SUPER_ATTR                         96
+#define MAKE_CELL                               97
+#define MAP_ADD                                 98
+#define MATCH_CLASS                             99
+#define POP_JUMP_IF_FALSE                      100
+#define POP_JUMP_IF_NONE                       101
+#define POP_JUMP_IF_NOT_NONE                   102
+#define POP_JUMP_IF_TRUE                       103
+#define RAISE_VARARGS                          104
+#define RERAISE                                105
+#define SEND                                   106
+#define SET_ADD                                107
+#define SET_FUNCTION_ATTRIBUTE                 108
+#define SET_UPDATE                             109
+#define STORE_ATTR                             110
+#define STORE_DEREF                            111
+#define STORE_FAST                             112
+#define STORE_FAST_LOAD_FAST                   113
+#define STORE_FAST_STORE_FAST                  114
+#define STORE_GLOBAL                           115
+#define STORE_NAME                             116
+#define SWAP                                   117
+#define UNPACK_EX                              118
+#define UNPACK_SEQUENCE                        119
+#define YIELD_VALUE                            120
+#define RESUME                                 128
+#define BINARY_OP_ADD_FLOAT                    129
+#define BINARY_OP_ADD_INT                      130
+#define BINARY_OP_ADD_UNICODE                  131
+#define BINARY_OP_EXTEND                       132
+#define BINARY_OP_MULTIPLY_FLOAT               133
+#define BINARY_OP_MULTIPLY_INT                 134
+#define BINARY_OP_SUBSCR_DICT                  135
+#define BINARY_OP_SUBSCR_GETITEM               136
+#define BINARY_OP_SUBSCR_LIST_INT              137
+#define BINARY_OP_SUBSCR_LIST_SLICE            138
+#define BINARY_OP_SUBSCR_STR_INT               139
+#define BINARY_OP_SUBSCR_TUPLE_INT             140
+#define BINARY_OP_SUBTRACT_FLOAT               141
+#define BINARY_OP_SUBTRACT_INT                 142
+#define CALL_ALLOC_AND_ENTER_INIT              143
+#define CALL_BOUND_METHOD_EXACT_ARGS           144
+#define CALL_BOUND_METHOD_GENERAL              145
+#define CALL_BUILTIN_CLASS                     146
+#define CALL_BUILTIN_FAST                      147
+#define CALL_BUILTIN_FAST_WITH_KEYWORDS        148
+#define CALL_BUILTIN_O                         149
+#define CALL_ISINSTANCE                        150
+#define CALL_KW_BOUND_METHOD                   151
+#define CALL_KW_NON_PY                         152
+#define CALL_KW_PY                             153
+#define CALL_LEN                               154
+#define CALL_LIST_APPEND                       155
+#define CALL_METHOD_DESCRIPTOR_FAST            156
+#define CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS 157
+#define CALL_METHOD_DESCRIPTOR_NOARGS          158
+#define CALL_METHOD_DESCRIPTOR_O               159
+#define CALL_NON_PY_GENERAL                    160
+#define CALL_PY_EXACT_ARGS                     161
+#define CALL_PY_GENERAL                        162
+#define CALL_STR_1                             163
+#define CALL_TUPLE_1                           164
+#define CALL_TYPE_1                            165
+#define COMPARE_OP_FLOAT                       166
+#define COMPARE_OP_INT                         167
+#define COMPARE_OP_STR                         168
+#define CONTAINS_OP_DICT                       169
+#define CONTAINS_OP_SET                        170
+#define FOR_ITER_GEN                           171
+#define FOR_ITER_LIST                          172
+#define FOR_ITER_RANGE                         173
+#define FOR_ITER_TUPLE                         174
+#define JUMP_BACKWARD_JIT                      175
+#define JUMP_BACKWARD_NO_JIT                   176
+#define LOAD_ATTR_CLASS                        177
+#define LOAD_ATTR_CLASS_WITH_METACLASS_CHECK   178
+#define LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN      179
+#define LOAD_ATTR_INSTANCE_VALUE               180
+#define LOAD_ATTR_METHOD_LAZY_DICT             181
+#define LOAD_ATTR_METHOD_NO_DICT               182
+#define LOAD_ATTR_METHOD_WITH_VALUES           183
+#define LOAD_ATTR_MODULE                       184
+#define LOAD_ATTR_NONDESCRIPTOR_NO_DICT        185
+#define LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES    186
+#define LOAD_ATTR_PROPERTY                     187
+#define LOAD_ATTR_SLOT                         188
+#define LOAD_ATTR_WITH_HINT                    189
+#define LOAD_CONST_IMMORTAL                    190
+#define LOAD_CONST_MORTAL                      191
+#define LOAD_GLOBAL_BUILTIN                    192
+#define LOAD_GLOBAL_MODULE                     193
+#define LOAD_SUPER_ATTR_ATTR                   194
+#define LOAD_SUPER_ATTR_METHOD                 195
+#define RESUME_CHECK                           196
+#define SEND_GEN                               197
+#define STORE_ATTR_INSTANCE_VALUE              198
+#define STORE_ATTR_SLOT                        199
+#define STORE_ATTR_WITH_HINT                   200
+#define STORE_SUBSCR_DICT                      201
+#define STORE_SUBSCR_LIST_INT                  202
+#define TO_BOOL_ALWAYS_TRUE                    203
+#define TO_BOOL_BOOL                           204
+#define TO_BOOL_INT                            205
+#define TO_BOOL_LIST                           206
+#define TO_BOOL_NONE                           207
+#define TO_BOOL_STR                            208
+#define UNPACK_SEQUENCE_LIST                   209
+#define UNPACK_SEQUENCE_TUPLE                  210
+#define UNPACK_SEQUENCE_TWO_TUPLE              211
+#define INSTRUMENTED_END_FOR                   234
+#define INSTRUMENTED_POP_ITER                  235
+#define INSTRUMENTED_END_SEND                  236
+#define INSTRUMENTED_FOR_ITER                  237
+#define INSTRUMENTED_INSTRUCTION               238
+#define INSTRUMENTED_JUMP_FORWARD              239
+#define INSTRUMENTED_NOT_TAKEN                 240
+#define INSTRUMENTED_POP_JUMP_IF_TRUE          241
+#define INSTRUMENTED_POP_JUMP_IF_FALSE         242
+#define INSTRUMENTED_POP_JUMP_IF_NONE          243
+#define INSTRUMENTED_POP_JUMP_IF_NOT_NONE      244
+#define INSTRUMENTED_RESUME                    245
+#define INSTRUMENTED_RETURN_VALUE              246
+#define INSTRUMENTED_YIELD_VALUE               247
+#define INSTRUMENTED_END_ASYNC_FOR             248
+#define INSTRUMENTED_LOAD_SUPER_ATTR           249
+#define INSTRUMENTED_CALL                      250
+#define INSTRUMENTED_CALL_KW                   251
+#define INSTRUMENTED_CALL_FUNCTION_EX          252
+#define INSTRUMENTED_JUMP_BACKWARD             253
+#define INSTRUMENTED_LINE                      254
+#define ENTER_EXECUTOR                         255
+#define ANNOTATIONS_PLACEHOLDER                256
+#define JUMP                                   257
+#define JUMP_IF_FALSE                          258
+#define JUMP_IF_TRUE                           259
+#define JUMP_NO_INTERRUPT                      260
+#define LOAD_CLOSURE                           261
+#define POP_BLOCK                              262
+#define SETUP_CLEANUP                          263
+#define SETUP_FINALLY                          264
+#define SETUP_WITH                             265
+#define STORE_FAST_MAYBE_NULL                  266
+
+#define HAVE_ARGUMENT                           43
+#define MIN_SPECIALIZED_OPCODE                 129
+#define MIN_INSTRUMENTED_OPCODE                234
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_OPCODE_IDS_H */

package/include/python3.14/osdefs.h

@@ -0,0 +1,57 @@
+// Operating system dependencies.
+//
+// Define constants:
+//
+// - ALTSEP
+// - DELIM
+// - MAXPATHLEN
+// - SEP
+
+#ifndef Py_OSDEFS_H
+#define Py_OSDEFS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef MS_WINDOWS
+#  define SEP L'\\'
+#  define ALTSEP L'/'
+#  define MAXPATHLEN 256
+#  define DELIM L';'
+#endif
+
+#ifdef __VXWORKS__
+#  define DELIM L';'
+#endif
+
+/* Filename separator */
+#ifndef SEP
+#  define SEP L'/'
+#endif
+
+/* Max pathname length */
+#ifdef __hpux
+#  include <sys/param.h>
+#  include <limits.h>
+#  ifndef PATH_MAX
+#    define PATH_MAX MAXPATHLEN
+#  endif
+#endif
+
+#ifndef MAXPATHLEN
+#  if defined(PATH_MAX) && PATH_MAX > 1024
+#    define MAXPATHLEN PATH_MAX
+#  else
+#    define MAXPATHLEN 1024
+#  endif
+#endif
+
+/* Search path entry delimiter */
+#ifndef DELIM
+#  define DELIM L':'
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif   // !Py_OSDEFS_H

package/include/python3.14/osmodule.h

@@ -0,0 +1,17 @@
+
+/* os module interface */
+
+#ifndef Py_OSMODULE_H
+#define Py_OSMODULE_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03060000
+PyAPI_FUNC(PyObject *) PyOS_FSPath(PyObject *path);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_OSMODULE_H */

package/include/python3.14/patchlevel.h

@@ -0,0 +1,49 @@
+#ifndef _Py_PATCHLEVEL_H
+#define _Py_PATCHLEVEL_H
+/* Python version identification scheme.
+
+   When the major or minor version changes, the VERSION variable in
+   configure.ac must also be changed.
+
+   There is also (independent) API version information in modsupport.h.
+*/
+
+/* Values for PY_RELEASE_LEVEL */
+#define PY_RELEASE_LEVEL_ALPHA  0xA
+#define PY_RELEASE_LEVEL_BETA   0xB
+#define PY_RELEASE_LEVEL_GAMMA  0xC     /* For release candidates */
+#define PY_RELEASE_LEVEL_FINAL  0xF     /* Serial should be 0 here */
+                                        /* Higher for patch releases */
+
+/* Version parsed out into numeric values */
+/*--start constants--*/
+#define PY_MAJOR_VERSION        3
+#define PY_MINOR_VERSION        14
+#define PY_MICRO_VERSION        2
+#define PY_RELEASE_LEVEL        PY_RELEASE_LEVEL_FINAL
+#define PY_RELEASE_SERIAL       0
+
+/* Version as a string */
+#define PY_VERSION              "3.14.2"
+/*--end constants--*/
+
+
+#define _Py_PACK_FULL_VERSION(X, Y, Z, LEVEL, SERIAL) ( \
+    (((X) & 0xff) << 24) |                              \
+    (((Y) & 0xff) << 16) |                              \
+    (((Z) & 0xff) << 8) |                               \
+    (((LEVEL) & 0xf) << 4) |                            \
+    (((SERIAL) & 0xf) << 0))
+
+/* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2.
+   Use this for numeric comparisons, e.g. #if PY_VERSION_HEX >= ... */
+#define PY_VERSION_HEX _Py_PACK_FULL_VERSION( \
+    PY_MAJOR_VERSION,                         \
+    PY_MINOR_VERSION,                         \
+    PY_MICRO_VERSION,                         \
+    PY_RELEASE_LEVEL,                         \
+    PY_RELEASE_SERIAL)
+
+// Public Py_PACK_VERSION is declared in pymacro.h; it needs <inttypes.h>.
+
+#endif //_Py_PATCHLEVEL_H