File Manager

X7ROOT File Manager

Current Path: /opt/alt/python313/include/python3.13/internal

opt / alt / python313 / include / python3.13 / internal /

ðŸ“ ..
ðŸ“ mimalloc
ðŸ“„ pycore_abstract.h(1.87 KB)
ðŸ“„ pycore_asdl.h(2.96 KB)
ðŸ“„ pycore_ast.h(30.78 KB)
ðŸ“„ pycore_ast_state.h(6.62 KB)
ðŸ“„ pycore_atexit.h(1.4 KB)
ðŸ“„ pycore_backoff.h(3.81 KB)
ðŸ“„ pycore_bitutils.h(5.88 KB)
ðŸ“„ pycore_blocks_output_buffer.h(8.57 KB)
ðŸ“„ pycore_brc.h(2.05 KB)
ðŸ“„ pycore_bytes_methods.h(3.84 KB)
ðŸ“„ pycore_bytesobject.h(4.75 KB)
ðŸ“„ pycore_call.h(5.99 KB)
ðŸ“„ pycore_capsule.h(397 B)
ðŸ“„ pycore_cell.h(1.03 KB)
ðŸ“„ pycore_ceval.h(10.9 KB)
ðŸ“„ pycore_ceval_state.h(3.83 KB)
ðŸ“„ pycore_code.h(19.4 KB)
ðŸ“„ pycore_codecs.h(2.41 KB)
ðŸ“„ pycore_compile.h(3.66 KB)
ðŸ“„ pycore_complexobject.h(588 B)
ðŸ“„ pycore_condvar.h(2.64 KB)
ðŸ“„ pycore_context.h(1.15 KB)
ðŸ“„ pycore_critical_section.h(7.78 KB)
ðŸ“„ pycore_crossinterp.h(11.84 KB)
ðŸ“„ pycore_descrobject.h(543 B)
ðŸ“„ pycore_dict.h(11.98 KB)
ðŸ“„ pycore_dict_state.h(732 B)
ðŸ“„ pycore_dtoa.h(1.69 KB)
ðŸ“„ pycore_emscripten_signal.h(685 B)
ðŸ“„ pycore_emscripten_trampoline.h(3.11 KB)
ðŸ“„ pycore_exceptions.h(900 B)
ðŸ“„ pycore_faulthandler.h(2.19 KB)
ðŸ“„ pycore_fileutils.h(9.25 KB)
ðŸ“„ pycore_fileutils_windows.h(2.65 KB)
ðŸ“„ pycore_floatobject.h(1.46 KB)
ðŸ“„ pycore_flowgraph.h(1.45 KB)
ðŸ“„ pycore_format.h(480 B)
ðŸ“„ pycore_frame.h(10.62 KB)
ðŸ“„ pycore_freelist.h(4.7 KB)
ðŸ“„ pycore_function.h(1.5 KB)
ðŸ“„ pycore_gc.h(12.66 KB)
ðŸ“„ pycore_genobject.h(859 B)
ðŸ“„ pycore_getopt.h(490 B)
ðŸ“„ pycore_gil.h(2.14 KB)
ðŸ“„ pycore_global_objects.h(3.02 KB)
ðŸ“„ pycore_global_objects_fini_generated.h(115.04 KB)
ðŸ“„ pycore_global_strings.h(26.08 KB)
ðŸ“„ pycore_hamt.h(3.65 KB)
ðŸ“„ pycore_hashtable.h(4.26 KB)
ðŸ“„ pycore_identifier.h(515 B)
ðŸ“„ pycore_import.h(7.55 KB)
ðŸ“„ pycore_importdl.h(3.96 KB)
ðŸ“„ pycore_initconfig.h(6.23 KB)
ðŸ“„ pycore_instruction_sequence.h(2.11 KB)
ðŸ“„ pycore_instruments.h(2.28 KB)
ðŸ“„ pycore_interp.h(14.71 KB)
ðŸ“„ pycore_intrinsics.h(1.71 KB)
ðŸ“„ pycore_jit.h(527 B)
ðŸ“„ pycore_list.h(1.82 KB)
ðŸ“„ pycore_llist.h(2.36 KB)
ðŸ“„ pycore_lock.h(8.34 KB)
ðŸ“„ pycore_long.h(9.73 KB)
ðŸ“„ pycore_memoryobject.h(427 B)
ðŸ“„ pycore_mimalloc.h(1.6 KB)
ðŸ“„ pycore_modsupport.h(3.27 KB)
ðŸ“„ pycore_moduleobject.h(1.54 KB)
ðŸ“„ pycore_namespace.h(435 B)
ðŸ“„ pycore_object.h(26.64 KB)
ðŸ“„ pycore_object_alloc.h(2.13 KB)
ðŸ“„ pycore_object_stack.h(2.33 KB)
ðŸ“„ pycore_object_state.h(942 B)
ðŸ“„ pycore_obmalloc.h(26.78 KB)
ðŸ“„ pycore_obmalloc_init.h(1.89 KB)
ðŸ“„ pycore_opcode_metadata.h(82.74 KB)
ðŸ“„ pycore_opcode_utils.h(2.07 KB)
ðŸ“„ pycore_optimizer.h(8.11 KB)
ðŸ“„ pycore_parking_lot.h(3.27 KB)
ðŸ“„ pycore_parser.h(2.04 KB)
ðŸ“„ pycore_pathconfig.h(658 B)
ðŸ“„ pycore_pyarena.h(2.79 KB)
ðŸ“„ pycore_pyatomic_ft_wrappers.h(7.87 KB)
ðŸ“„ pycore_pybuffer.h(510 B)
ðŸ“„ pycore_pyerrors.h(4.84 KB)
ðŸ“„ pycore_pyhash.h(2.75 KB)
ðŸ“„ pycore_pylifecycle.h(4.36 KB)
ðŸ“„ pycore_pymath.h(8.4 KB)
ðŸ“„ pycore_pymem.h(4.37 KB)
ðŸ“„ pycore_pymem_init.h(3.44 KB)
ðŸ“„ pycore_pystate.h(9.73 KB)
ðŸ“„ pycore_pystats.h(420 B)
ðŸ“„ pycore_pythonrun.h(758 B)
ðŸ“„ pycore_pythread.h(5.3 KB)
ðŸ“„ pycore_qsbr.h(4.81 KB)
ðŸ“„ pycore_range.h(346 B)
ðŸ“„ pycore_runtime.h(12.84 KB)
ðŸ“„ pycore_runtime_init.h(12.74 KB)
ðŸ“„ pycore_runtime_init_generated.h(45.72 KB)
ðŸ“„ pycore_semaphore.h(1.69 KB)
ðŸ“„ pycore_setobject.h(951 B)
ðŸ“„ pycore_signal.h(2.86 KB)
ðŸ“„ pycore_sliceobject.h(369 B)
ðŸ“„ pycore_stackref.h(5.06 KB)
ðŸ“„ pycore_strhex.h(1013 B)
ðŸ“„ pycore_structseq.h(963 B)
ðŸ“„ pycore_symtable.h(8.47 KB)
ðŸ“„ pycore_sysmodule.h(1.15 KB)
ðŸ“„ pycore_time.h(11.52 KB)
ðŸ“„ pycore_token.h(2.93 KB)
ðŸ“„ pycore_traceback.h(3.54 KB)
ðŸ“„ pycore_tracemalloc.h(4.43 KB)
ðŸ“„ pycore_tstate.h(1.32 KB)
ðŸ“„ pycore_tuple.h(820 B)
ðŸ“„ pycore_typeobject.h(8.67 KB)
ðŸ“„ pycore_typevarobject.h(924 B)
ðŸ“„ pycore_ucnhash.h(958 B)
ðŸ“„ pycore_unicodeobject.h(12.15 KB)
ðŸ“„ pycore_unicodeobject_generated.h(129.04 KB)
ðŸ“„ pycore_unionobject.h(742 B)
ðŸ“„ pycore_uop_ids.h(10.03 KB)
ðŸ“„ pycore_uop_metadata.h(38.54 KB)
ðŸ“„ pycore_warnings.h(840 B)
ðŸ“„ pycore_weakref.h(3.25 KB)

Editing: pycore_frame.h

#ifndef Py_INTERNAL_FRAME_H
#define Py_INTERNAL_FRAME_H
#ifdef __cplusplus
extern "C" {
#endif

#ifndef Py_BUILD_CORE
#  error "this header requires Py_BUILD_CORE define"
#endif

#include <stdbool.h>
#include <stddef.h>               // offsetof()
#include "pycore_code.h"          // STATS

/* 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? */
    PyObject *f_extra_locals;   /* Dict for locals set by users using f_locals, could be NULL */
    /* This is purely for backwards compatibility for PyEval_GetLocals.
       PyEval_GetLocals requires a borrowed reference so the actual reference
       is stored here */
    PyObject *f_locals_cache;
    /* 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 = -3,
    FRAME_SUSPENDED = -2,
    FRAME_SUSPENDED_YIELD_FROM = -1,
    FRAME_EXECUTING = 0,
    FRAME_COMPLETED = 1,
    FRAME_CLEARED = 4
} PyFrameState;

#define FRAME_STATE_SUSPENDED(S) ((S) == FRAME_SUSPENDED || (S) == FRAME_SUSPENDED_YIELD_FROM)
#define FRAME_STATE_FINISHED(S) ((S) >= FRAME_COMPLETED)

enum _frameowner {
    FRAME_OWNED_BY_THREAD = 0,
    FRAME_OWNED_BY_GENERATOR = 1,
    FRAME_OWNED_BY_FRAME_OBJECT = 2,
    FRAME_OWNED_BY_CSTACK = 3,
};

typedef struct _PyInterpreterFrame {
    PyObject *f_executable; /* Strong reference (code object or None) */
    struct _PyInterpreterFrame *previous;
    PyObject *f_funcobj; /* Strong reference. Only valid if not on C stack */
    PyObject *f_globals; /* Borrowed reference. Only valid if not on C stack */
    PyObject *f_builtins; /* Borrowed reference. Only valid if not on C stack */
    PyObject *f_locals; /* Strong reference, may be NULL. Only valid if not on C stack */
    PyFrameObject *frame_obj; /* Strong reference, may be NULL. Only valid if not on C stack */
    _Py_CODEUNIT *instr_ptr; /* Instruction currently executing (or about to begin) */
    int stacktop;  /* Offset of TOS from localsplus  */
    uint16_t return_offset;  /* Only relevant during a function call */
    char owner;
    /* Locals and stack */
    PyObject *localsplus[1];
} _PyInterpreterFrame;

#define _PyInterpreterFrame_LASTI(IF) \
    ((int)((IF)->instr_ptr - _PyCode_CODE(_PyFrame_GetCode(IF))))

static inline PyCodeObject *_PyFrame_GetCode(_PyInterpreterFrame *f) {
    assert(PyCode_Check(f->f_executable));
    return (PyCodeObject *)f->f_executable;
}

static inline PyObject **_PyFrame_Stackbase(_PyInterpreterFrame *f) {
    return f->localsplus + _PyFrame_GetCode(f)->co_nlocalsplus;
}

static inline PyObject *_PyFrame_StackPeek(_PyInterpreterFrame *f) {
    assert(f->stacktop > _PyFrame_GetCode(f)->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 > _PyFrame_GetCode(f)->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 ((int)((sizeof(_PyInterpreterFrame)-1)/sizeof(PyObject *)))

static inline int
_PyFrame_NumSlotsForCodeObject(PyCodeObject *code)
{
    /* This function needs to remain in sync with the calculation of
     * co_framesize in Tools/build/deepfreeze.py */
    assert(code->co_framesize >= FRAME_SPECIALS_SIZE);
    return code->co_framesize - FRAME_SPECIALS_SIZE;
}

static inline void _PyFrame_Copy(_PyInterpreterFrame *src, _PyInterpreterFrame *dest)
{
    assert(src->stacktop >= _PyFrame_GetCode(src)->co_nlocalsplus);
    *dest = *src;
    for (int i = 1; i < src->stacktop; i++) {
        dest->localsplus[i] = src->localsplus[i];
    }
    // Don't leave a dangling pointer to the old frame when creating generators
    // and coroutines:
    dest->previous = NULL;
}

/* 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_Initialize(
    _PyInterpreterFrame *frame, PyFunctionObject *func,
    PyObject *locals, PyCodeObject *code, int null_locals_from)
{
    frame->f_funcobj = (PyObject *)func;
    frame->f_executable = Py_NewRef(code);
    frame->f_builtins = func->func_builtins;
    frame->f_globals = func->func_globals;
    frame->f_locals = locals;
    frame->stacktop = code->co_nlocalsplus;
    frame->frame_obj = NULL;
    frame->instr_ptr = _PyCode_CODE(code);
    frame->return_offset = 0;
    frame->owner = FRAME_OWNED_BY_THREAD;

for (int i = null_locals_from; i < code->co_nlocalsplus; i++) {
        frame->localsplus[i] = NULL;
    }
}

/* Gets the pointer to the locals array
 * that precedes this frame.
 */
static inline PyObject**
_PyFrame_GetLocalsArray(_PyInterpreterFrame *frame)
{
    return frame->localsplus;
}

/* Fetches the stack pointer, and sets stacktop to -1.
   Having stacktop <= 0 ensures that invalid
   values are not visible to the cycle GC.
   We choose -1 rather than 0 to assist debugging. */
static inline PyObject**
_PyFrame_GetStackPointer(_PyInterpreterFrame *frame)
{
    PyObject **sp = frame->localsplus + frame->stacktop;
    frame->stacktop = -1;
    return sp;
}

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)
{
    if (frame->owner == FRAME_OWNED_BY_CSTACK) {
        return true;
    }
    return frame->owner != FRAME_OWNED_BY_GENERATOR &&
        frame->instr_ptr < _PyCode_CODE(_PyFrame_GetCode(frame)) + _PyFrame_GetCode(frame)->_co_firsttraceable;
}

static inline _PyInterpreterFrame *
_PyFrame_GetFirstComplete(_PyInterpreterFrame *frame)
{
    while (frame && _PyFrame_IsIncomplete(frame)) {
        frame = frame->previous;
    }
    return frame;
}

static inline _PyInterpreterFrame *
_PyThreadState_GetFrame(PyThreadState *tstate)
{
    return _PyFrame_GetFirstComplete(tstate->current_frame);
}

/* 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 reference */
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);
}

void
_PyFrame_ClearLocals(_PyInterpreterFrame *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_ClearExceptCode(_PyInterpreterFrame * frame);

int
_PyFrame_Traverse(_PyInterpreterFrame *frame, visitproc visit, void *arg);

bool
_PyFrame_HasHiddenLocals(_PyInterpreterFrame *frame);

PyObject *
_PyFrame_GetLocals(_PyInterpreterFrame *frame);

static inline bool
_PyThreadState_HasStackSpace(PyThreadState *tstate, int size)
{
    assert(
        (tstate->datastack_top == NULL && tstate->datastack_limit == NULL)
        ||
        (tstate->datastack_top != NULL && tstate->datastack_limit != NULL)
    );
    return tstate->datastack_top != NULL &&
        size < tstate->datastack_limit - tstate->datastack_top;
}

extern _PyInterpreterFrame *
_PyThreadState_PushFrame(PyThreadState *tstate, size_t size);

PyAPI_FUNC(void) _PyThreadState_PopFrame(PyThreadState *tstate, _PyInterpreterFrame *frame);

/* Pushes a frame without checking for space.
 * Must be guarded by _PyThreadState_HasStackSpace()
 * Consumes reference to func. */
static inline _PyInterpreterFrame *
_PyFrame_PushUnchecked(PyThreadState *tstate, PyFunctionObject *func, int null_locals_from)
{
    CALL_STAT_INC(frames_pushed);
    PyCodeObject *code = (PyCodeObject *)func->func_code;
    _PyInterpreterFrame *new_frame = (_PyInterpreterFrame *)tstate->datastack_top;
    tstate->datastack_top += code->co_framesize;
    assert(tstate->datastack_top < tstate->datastack_limit);
    _PyFrame_Initialize(new_frame, func, NULL, code, null_locals_from);
    return new_frame;
}

/* Pushes a trampoline frame without checking for space.
 * Must be guarded by _PyThreadState_HasStackSpace() */
static inline _PyInterpreterFrame *
_PyFrame_PushTrampolineUnchecked(PyThreadState *tstate, PyCodeObject *code, int stackdepth)
{
    CALL_STAT_INC(frames_pushed);
    _PyInterpreterFrame *frame = (_PyInterpreterFrame *)tstate->datastack_top;
    tstate->datastack_top += code->co_framesize;
    assert(tstate->datastack_top < tstate->datastack_limit);
    frame->f_funcobj = Py_None;
    frame->f_executable = Py_NewRef(code);
#ifdef Py_DEBUG
    frame->f_builtins = NULL;
    frame->f_globals = NULL;
#endif
    frame->f_locals = NULL;
    frame->stacktop = code->co_nlocalsplus + stackdepth;
    frame->frame_obj = NULL;
    frame->instr_ptr = _PyCode_CODE(code);
    frame->owner = FRAME_OWNED_BY_THREAD;
    frame->return_offset = 0;
    return 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);
}

PyAPI_FUNC(_PyInterpreterFrame *)
_PyEvalFramePushAndInit(PyThreadState *tstate, PyFunctionObject *func,
                        PyObject *locals, PyObject* const* args,
                        size_t argcount, PyObject *kwnames);

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

X7ROOT File Manager

Editing: pycore_frame.h

Upload File

Create Folder