Add files using upload-large-folder tool

570ad17 verified 6 months ago

7.57 kB

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

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