FM / internal

/opt/imh/python3.13/include/python3.13/internal/

/opt/imh/python3.13/include/python3.13/internal

Name	Size	Mode	Actions
mimalloc/	-	0755	rm
pycore_abstract.h	1915	0644	edit dl rm
pycore_asdl.h	3035	0644	edit dl rm
pycore_ast.h	31520	0644	edit dl rm
pycore_ast_state.h	6779	0644	edit dl rm
pycore_atexit.h	1433	0644	edit dl rm
pycore_backoff.h	3902	0644	edit dl rm
pycore_bitutils.h	6026	0644	edit dl rm
pycore_blocks_output_buffer.h	8772	0644	edit dl rm
pycore_brc.h	2102	0644	edit dl rm
pycore_bytesobject.h	5099	0644	edit dl rm
pycore_bytes_methods.h	3933	0644	edit dl rm
pycore_call.h	6135	0644	edit dl rm
pycore_capsule.h	397	0644	edit dl rm
pycore_cell.h	1057	0644	edit dl rm
pycore_ceval.h	11162	0644	edit dl rm
pycore_ceval_state.h	3921	0644	edit dl rm
pycore_code.h	19864	0644	edit dl rm
pycore_codecs.h	2465	0644	edit dl rm
pycore_compile.h	3750	0644	edit dl rm
pycore_complexobject.h	588	0644	edit dl rm
pycore_condvar.h	2704	0644	edit dl rm
pycore_context.h	1182	0644	edit dl rm
pycore_critical_section.h	7968	0644	edit dl rm
pycore_crossinterp.h	12128	0644	edit dl rm
pycore_descrobject.h	543	0644	edit dl rm
pycore_dict.h	12264	0644	edit dl rm
pycore_dict_state.h	732	0644	edit dl rm
pycore_dtoa.h	1727	0644	edit dl rm
pycore_emscripten_signal.h	685	0644	edit dl rm
pycore_emscripten_trampoline.h	3180	0644	edit dl rm
pycore_exceptions.h	900	0644	edit dl rm
pycore_faulthandler.h	2245	0644	edit dl rm
pycore_fileutils.h	9468	0644	edit dl rm
pycore_fileutils_windows.h	2713	0644	edit dl rm
pycore_floatobject.h	1495	0644	edit dl rm
pycore_flowgraph.h	1489	0644	edit dl rm
pycore_format.h	480	0644	edit dl rm
pycore_frame.h	10875	0644	edit dl rm
pycore_freelist.h	4810	0644	edit dl rm
pycore_function.h	1538	0644	edit dl rm
pycore_gc.h	12967	0644	edit dl rm
pycore_genobject.h	859	0644	edit dl rm
pycore_getopt.h	490	0644	edit dl rm
pycore_gil.h	2196	0644	edit dl rm
pycore_global_objects.h	3090	0644	edit dl rm
pycore_global_objects_fini_generated.h	117804	0644	edit dl rm
pycore_global_strings.h	26706	0644	edit dl rm
pycore_hamt.h	3742	0644	edit dl rm
pycore_hashtable.h	4361	0644	edit dl rm
pycore_identifier.h	515	0644	edit dl rm
pycore_import.h	7731	0644	edit dl rm
pycore_importdl.h	4055	0644	edit dl rm
pycore_initconfig.h	6375	0644	edit dl rm
pycore_instruction_sequence.h	2161	0644	edit dl rm
pycore_instruments.h	2331	0644	edit dl rm
pycore_interp.h	15063	0644	edit dl rm
pycore_intrinsics.h	1756	0644	edit dl rm
pycore_jit.h	527	0644	edit dl rm
pycore_list.h	1859	0644	edit dl rm
pycore_llist.h	2420	0644	edit dl rm
pycore_lock.h	8538	0644	edit dl rm
pycore_long.h	9966	0644	edit dl rm
pycore_memoryobject.h	427	0644	edit dl rm
pycore_mimalloc.h	1637	0644	edit dl rm
pycore_modsupport.h	3351	0644	edit dl rm
pycore_moduleobject.h	1572	0644	edit dl rm
pycore_namespace.h	435	0644	edit dl rm
pycore_object.h	27936	0644	edit dl rm
pycore_object_alloc.h	2176	0644	edit dl rm
pycore_object_stack.h	2384	0644	edit dl rm
pycore_object_state.h	942	0644	edit dl rm
pycore_obmalloc.h	27418	0644	edit dl rm
pycore_obmalloc_init.h	1935	0644	edit dl rm
pycore_opcode_metadata.h	84722	0644	edit dl rm
pycore_opcode_utils.h	2122	0644	edit dl rm
pycore_optimizer.h	8303	0644	edit dl rm
pycore_parking_lot.h	3351	0644	edit dl rm
pycore_parser.h	2089	0644	edit dl rm
pycore_pathconfig.h	658	0644	edit dl rm
pycore_pyarena.h	2862	0644	edit dl rm
pycore_pyatomic_ft_wrappers.h	8056	0644	edit dl rm
pycore_pybuffer.h	510	0644	edit dl rm
pycore_pyerrors.h	4960	0644	edit dl rm
pycore_pyhash.h	2813	0644	edit dl rm
pycore_pylifecycle.h	4465	0644	edit dl rm
pycore_pymath.h	8600	0644	edit dl rm
pycore_pymem.h	4485	0644	edit dl rm
pycore_pymem_init.h	3520	0644	edit dl rm
pycore_pystate.h	9964	0644	edit dl rm
pycore_pystats.h	420	0644	edit dl rm
pycore_pythonrun.h	758	0644	edit dl rm
pycore_pythread.h	5431	0644	edit dl rm
pycore_qsbr.h	5524	0644	edit dl rm
pycore_range.h	346	0644	edit dl rm
pycore_runtime.h	13165	0644	edit dl rm
pycore_runtime_init.h	13045	0644	edit dl rm
pycore_runtime_init_generated.h	46820	0644	edit dl rm
pycore_semaphore.h	1731	0644	edit dl rm
pycore_setobject.h	951	0644	edit dl rm
pycore_signal.h	2931	0644	edit dl rm
pycore_sliceobject.h	369	0644	edit dl rm
pycore_stackref.h	5186	0644	edit dl rm
pycore_strhex.h	1013	0644	edit dl rm
pycore_structseq.h	963	0644	edit dl rm
pycore_symtable.h	8671	0644	edit dl rm
pycore_sysmodule.h	1177	0644	edit dl rm
pycore_time.h	11794	0644	edit dl rm
pycore_token.h	3001	0644	edit dl rm
pycore_traceback.h	3629	0644	edit dl rm
pycore_tracemalloc.h	4533	0644	edit dl rm
pycore_tstate.h	1354	0644	edit dl rm
pycore_tuple.h	820	0644	edit dl rm
pycore_typeobject.h	8877	0644	edit dl rm
pycore_typevarobject.h	924	0644	edit dl rm
pycore_ucnhash.h	958	0644	edit dl rm
pycore_unicodeobject.h	13270	0644	edit dl rm
pycore_unicodeobject_generated.h	132140	0644	edit dl rm
pycore_unionobject.h	742	0644	edit dl rm
pycore_uop_ids.h	10267	0644	edit dl rm
pycore_uop_metadata.h	39469	0644	edit dl rm
pycore_warnings.h	840	0644	edit dl rm
pycore_weakref.h	3889	0644	edit dl rm

Edit: /opt/imh/python3.13/include/python3.13/internal/pycore_interp.h (15063B)

#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>              // bool

#include "pycore_ast_state.h"     // struct ast_state
#include "pycore_atexit.h"        // struct atexit_state
#include "pycore_ceval_state.h"   // struct _ceval_state
#include "pycore_code.h"          // struct callable_cache
#include "pycore_codecs.h"        // struct codecs_state
#include "pycore_context.h"       // struct _Py_context_state
#include "pycore_crossinterp.h"   // struct _xidregistry
#include "pycore_dict_state.h"    // struct _Py_dict_state
#include "pycore_dtoa.h"          // struct _dtoa_state
#include "pycore_exceptions.h"    // struct _Py_exc_state
#include "pycore_floatobject.h"   // struct _Py_float_state
#include "pycore_function.h"      // FUNC_MAX_WATCHERS
#include "pycore_gc.h"            // struct _gc_runtime_state
#include "pycore_genobject.h"     // struct _Py_async_gen_state
#include "pycore_global_objects.h"// struct _Py_interp_cached_objects
#include "pycore_import.h"        // struct _import_state
#include "pycore_instruments.h"   // _PY_MONITORING_EVENTS
#include "pycore_list.h"          // struct _Py_list_state
#include "pycore_mimalloc.h"      // struct _mimalloc_interp_state
#include "pycore_object_state.h"  // struct _py_object_state
#include "pycore_optimizer.h"     // _PyOptimizerObject
#include "pycore_obmalloc.h"      // struct _obmalloc_state
#include "pycore_qsbr.h"          // struct _qsbr_state
#include "pycore_tstate.h"        // _PyThreadStateImpl
#include "pycore_tuple.h"         // struct _Py_tuple_state
#include "pycore_typeobject.h"    // struct types_state
#include "pycore_unicodeobject.h" // struct _Py_unicode_state
#include "pycore_warnings.h"      // struct _warnings_runtime_state

struct _Py_long_state {
    int max_str_digits;
};

// Support for stop-the-world events. This exists in both the PyRuntime struct
// for global pauses and in each PyInterpreterState for per-interpreter pauses.
struct _stoptheworld_state {
    PyMutex mutex;       // Serializes stop-the-world attempts.

// NOTE: The below fields are protected by HEAD_LOCK(runtime), not by the
    // above mutex.
    bool requested;      // Set when a pause is requested.
    bool world_stopped;  // Set when the world is stopped.
    bool is_global;      // Set when contained in PyRuntime struct.

PyEvent stop_event;  // Set when thread_countdown reaches zero.
    Py_ssize_t thread_countdown;  // Number of threads that must pause.

PyThreadState *requester; // Thread that requested the pause (may be NULL).
};

#ifdef Py_GIL_DISABLED
// This should be prime but otherwise the choice is arbitrary. A larger value
// increases concurrency at the expense of memory.
#  define NUM_WEAKREF_LIST_LOCKS 127
#endif

/* cross-interpreter data registry */

/* Tracks some rare events per-interpreter, used by the optimizer to turn on/off
   specific optimizations. */
typedef struct _rare_events {
    /* Setting an object's class, obj.__class__ = ... */
    uint8_t set_class;
    /* Setting the bases of a class, cls.__bases__ = ... */
    uint8_t set_bases;
    /* Setting the PEP 523 frame eval function, _PyInterpreterState_SetFrameEvalFunc() */
    uint8_t set_eval_frame_func;
    /* Modifying the builtins,  __builtins__.__dict__[var] = ... */
    uint8_t builtin_dict;
    /* Modifying a function, e.g. func.__defaults__ = ..., etc. */
    uint8_t func_modification;
} _rare_events;

/* 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/pytypedefs.h.
   */
struct _is {

/* This struct contains the eval_breaker,
     * which is by far the hottest field in this struct
     * and should be placed at the beginning. */
    struct _ceval_state ceval;

PyInterpreterState *next;

int64_t id;
    int64_t id_refcount;
    int requires_idref;
    PyThread_type_lock id_mutex;

#define _PyInterpreterState_WHENCE_NOTSET -1
#define _PyInterpreterState_WHENCE_UNKNOWN 0
#define _PyInterpreterState_WHENCE_RUNTIME 1
#define _PyInterpreterState_WHENCE_LEGACY_CAPI 2
#define _PyInterpreterState_WHENCE_CAPI 3
#define _PyInterpreterState_WHENCE_XI 4
#define _PyInterpreterState_WHENCE_STDLIB 5
#define _PyInterpreterState_WHENCE_MAX 5
    long _whence;

/* 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;
    /* Has been fully initialized via pylifecycle.c. */
    int _ready;
    int finalizing;

uintptr_t last_restart_version;
    struct pythreads {
        uint64_t next_unique_id;
        /* The linked list of threads, newest first. */
        PyThreadState *head;
        /* The thread currently executing in the __main__ module, if any. */
        PyThreadState *main;
        /* Used in Modules/_threadmodule.c. */
        Py_ssize_t 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;

/* Set by Py_EndInterpreter().

Use _PyInterpreterState_GetFinalizing()
       and _PyInterpreterState_SetFinalizing()
       to access it, don't access it directly. */
    PyThreadState* _finalizing;
    /* The ID of the OS thread in which we are finalizing. */
    unsigned long _finalizing_id;

struct _gc_runtime_state gc;

/* 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.
       */

// Dictionary of the sys module
    PyObject *sysdict;

// Dictionary of the builtins module
    PyObject *builtins;

struct _import_state imports;

/* The per-interpreter GIL, which might not be used. */
    struct _gil_runtime_state _gil;

/* ---------- IMPORTANT ---------------------------
     The fields above this line are declared as early as
     possible to facilitate out-of-process observability
     tools. */

struct codecs_state codecs;

PyConfig config;
    unsigned long feature_flags;

PyObject *dict;  /* Stores per-interpreter state */

PyObject *sysdict_copy;
    PyObject *builtins_copy;
    // Initialized to _PyEval_EvalFrameDefault().
    _PyFrameEvalFunction eval_frame;

PyFunction_WatchCallback func_watchers[FUNC_MAX_WATCHERS];
    // One bit is set for each non-NULL entry in func_watchers
    uint8_t active_func_watchers;

Py_ssize_t co_extra_user_count;
    freefunc co_extra_freefuncs[MAX_CO_EXTRA_USERS];

/* cross-interpreter data and utils */
    struct _xi_state xi;

#ifdef HAVE_FORK
    PyObject *before_forkers;
    PyObject *after_forkers_parent;
    PyObject *after_forkers_child;
#endif

struct _warnings_runtime_state warnings;
    struct atexit_state atexit;
    struct _stoptheworld_state stoptheworld;
    struct _qsbr_shared qsbr;

#if defined(Py_GIL_DISABLED)
    struct _mimalloc_interp_state mimalloc;
    struct _brc_state brc;  // biased reference counting state
    PyMutex weakref_locks[NUM_WEAKREF_LIST_LOCKS];
#endif

// Per-interpreter state for the obmalloc allocator.  For the main
    // interpreter and for all interpreters that don't have their
    // own obmalloc state, this points to the static structure in
    // obmalloc.c obmalloc_state_main.  For other interpreters, it is
    // heap allocated by _PyMem_init_obmalloc() and freed when the
    // interpreter structure is freed.  In the case of a heap allocated
    // obmalloc state, it is not safe to hold on to or use memory after
    // the interpreter is freed. The obmalloc state corresponding to
    // that allocated memory is gone.  See free_obmalloc_arenas() for
    // more comments.
    struct _obmalloc_state *obmalloc;

PyObject *audit_hooks;
    PyType_WatchCallback type_watchers[TYPE_MAX_WATCHERS];
    PyCode_WatchCallback code_watchers[CODE_MAX_WATCHERS];
    // One bit is set for each non-NULL entry in code_watchers
    uint8_t active_code_watchers;

struct _py_object_state object_state;
    struct _Py_unicode_state unicode;
    struct _Py_long_state long_state;
    struct _dtoa_state dtoa;
    struct _py_func_state func_state;
    struct _py_code_state code_state;

struct _Py_dict_state dict_state;
    struct _Py_exc_state exc_state;
    struct _Py_mem_interp_free_queue mem_free_queue;

struct ast_state ast;
    struct types_state types;
    struct callable_cache callable_cache;
    _PyOptimizerObject *optimizer;
    _PyExecutorObject *executor_list_head;

_rare_events rare_events;
    PyDict_WatchCallback builtins_dict_watcher;

_Py_GlobalMonitors monitors;
    bool sys_profile_initialized;
    bool sys_trace_initialized;
    Py_ssize_t sys_profiling_threads; /* Count of threads with c_profilefunc set */
    Py_ssize_t sys_tracing_threads; /* Count of threads with c_tracefunc set */
    PyObject *monitoring_callables[PY_MONITORING_TOOL_IDS][_PY_MONITORING_EVENTS];
    PyObject *monitoring_tool_names[PY_MONITORING_TOOL_IDS];

struct _Py_interp_cached_objects cached_objects;
    struct _Py_interp_static_objects static_objects;

/* the initial PyInterpreterState.threads.head */
    _PyThreadStateImpl _initial_thread;
    Py_ssize_t _interactive_src_count;
    // In 3.14+ this is interp->threads.preallocated.
    _PyThreadStateImpl *threads_preallocated;
};

/* other API */

extern void _PyInterpreterState_Clear(PyThreadState *tstate);

static inline PyThreadState*
_PyInterpreterState_GetFinalizing(PyInterpreterState *interp) {
    return (PyThreadState*)_Py_atomic_load_ptr_relaxed(&interp->_finalizing);
}

static inline unsigned long
_PyInterpreterState_GetFinalizingID(PyInterpreterState *interp) {
    return _Py_atomic_load_ulong_relaxed(&interp->_finalizing_id);
}

static inline void
_PyInterpreterState_SetFinalizing(PyInterpreterState *interp, PyThreadState *tstate) {
    _Py_atomic_store_ptr_relaxed(&interp->_finalizing, tstate);
    if (tstate == NULL) {
        _Py_atomic_store_ulong_relaxed(&interp->_finalizing_id, 0);
    }
    else {
        // XXX Re-enable this assert once gh-109860 is fixed.
        //assert(tstate->thread_id == PyThread_get_thread_ident());
        _Py_atomic_store_ulong_relaxed(&interp->_finalizing_id,
                                       tstate->thread_id);
    }
}

// Exports for the _testinternalcapi module.
PyAPI_FUNC(int64_t) _PyInterpreterState_ObjectToID(PyObject *);
PyAPI_FUNC(PyInterpreterState *) _PyInterpreterState_LookUpID(int64_t);
PyAPI_FUNC(PyInterpreterState *) _PyInterpreterState_LookUpIDObject(PyObject *);
PyAPI_FUNC(int) _PyInterpreterState_IDInitref(PyInterpreterState *);
PyAPI_FUNC(int) _PyInterpreterState_IDIncref(PyInterpreterState *);
PyAPI_FUNC(void) _PyInterpreterState_IDDecref(PyInterpreterState *);

PyAPI_FUNC(int) _PyInterpreterState_IsReady(PyInterpreterState *interp);

PyAPI_FUNC(long) _PyInterpreterState_GetWhence(PyInterpreterState *interp);
extern void _PyInterpreterState_SetWhence(
    PyInterpreterState *interp,
    long whence);

extern const PyConfig* _PyInterpreterState_GetConfig(PyInterpreterState *interp);

// Get a copy of the current interpreter configuration.
//
// Return 0 on success. Raise an exception and return -1 on error.
//
// The caller must initialize 'config', using PyConfig_InitPythonConfig()
// for example.
//
// Python must be preinitialized to call this method.
// The caller must hold the GIL.
//
// Once done with the configuration, PyConfig_Clear() must be called to clear
// it.
//
// Export for '_testinternalcapi' shared extension.
PyAPI_FUNC(int) _PyInterpreterState_GetConfigCopy(
    struct PyConfig *config);

// Set the configuration of the current interpreter.
//
// This function should be called during or just after the Python
// initialization.
//
// Update the sys module with the new configuration. If the sys module was
// modified directly after the Python initialization, these changes are lost.
//
// Some configuration like faulthandler or warnoptions can be updated in the
// configuration, but don't reconfigure Python (don't enable/disable
// faulthandler and don't reconfigure warnings filters).
//
// Return 0 on success. Raise an exception and return -1 on error.
//
// The configuration should come from _PyInterpreterState_GetConfigCopy().
//
// Export for '_testinternalcapi' shared extension.
PyAPI_FUNC(int) _PyInterpreterState_SetConfig(
    const struct PyConfig *config);

/*
Runtime Feature Flags

Each flag indicate whether or not a specific runtime feature
is available in a given context.  For example, forking the process
might not be allowed in the current interpreter (i.e. os.fork() would fail).
*/

/* Set if the interpreter share obmalloc runtime state
   with the main interpreter. */
#define Py_RTFLAGS_USE_MAIN_OBMALLOC (1UL << 5)

/* Set if import should check a module for subinterpreter support. */
#define Py_RTFLAGS_MULTI_INTERP_EXTENSIONS (1UL << 8)

/* Set if threads are allowed. */
#define Py_RTFLAGS_THREADS (1UL << 10)

/* Set if daemon threads are allowed. */
#define Py_RTFLAGS_DAEMON_THREADS (1UL << 11)

/* Set if os.fork() is allowed. */
#define Py_RTFLAGS_FORK (1UL << 15)

/* Set if os.exec*() is allowed. */
#define Py_RTFLAGS_EXEC (1UL << 16)

extern int _PyInterpreterState_HasFeature(PyInterpreterState *interp,
                                          unsigned long feature);

PyAPI_FUNC(PyStatus) _PyInterpreterState_New(
    PyThreadState *tstate,
    PyInterpreterState **pinterp);

#define RARE_EVENT_INTERP_INC(interp, name) \
    do { \
        /* saturating add */ \
        int val = FT_ATOMIC_LOAD_UINT8_RELAXED(interp->rare_events.name); \
        if (val < UINT8_MAX) { \
            FT_ATOMIC_STORE_UINT8(interp->rare_events.name, val + 1); \
        } \
        RARE_EVENT_STAT_INC(name); \
    } while (0); \

#define RARE_EVENT_INC(name) \
    do { \
        PyInterpreterState *interp = PyInterpreterState_Get(); \
        RARE_EVENT_INTERP_INC(interp, name); \
    } while (0); \

#ifdef __cplusplus
}
#endif
#endif /* !Py_INTERNAL_INTERP_H */

cmd: