[ PARENT ]

EDIT :: 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 */

SAVE CANCEL