Struct FrameObject 

pub struct FrameObject { /* private fields */ }

Implementations

impl FrameObject

pub fn lineno(&self) -> i32

Current line, or -1 when the linetable has no line for lasti.

pub fn f_code(&self) -> PyRef<PyCode>

impl FrameObject

pub fn iframe(&self) -> &InterpreterFrame

Shared access to the embedded interpreter frame. Safe to call on any reachable FrameObject: immutable fields and atomic/mutex fields are always safe to access.

impl FrameObject

pub unsafe fn fastlocals(&self) -> &[Option<PyObjectRef>]

Access fastlocals immutably.

Safety

Caller must ensure no concurrent mutable access (frame not executing, or called from the same thread during trace callback).

pub unsafe fn fastlocals_mut(&self) -> &mut [Option<PyObjectRef>]

Access fastlocals mutably.

Safety

Caller must ensure exclusive access (frame not executing).

pub fn set_generator(&self, generator: &PyObject)

Store a borrowed back-reference to the owning generator/coroutine. The caller must ensure the generator outlives the frame.

pub fn clear_generator(&self)

Clear the generator back-reference. Called when the generator is finalized.

pub fn current_location(&self) -> SourceLocation

pub fn previous_iframe(&self) -> *const InterpreterFrame

Get the previous InterpreterFrame in the chain. Returns null if the frame has been cleared (GC deallocation).

pub fn previous_frame(&self) -> *const Self

Get the previous FrameObject in the chain, if any. Walks through the chain to find the next materialized frame.

pub fn lasti(&self) -> u32

pub fn set_lasti(&self, val: u32)

pub fn locals(&self, vm: &VirtualMachine) -> PyResult<ArgMapping>

pub fn locals_snapshot_cache(&self, vm: &VirtualMachine) -> PyDictRef

Return the lazily allocated dict used by APIs that must keep a frame-owned locals snapshot. Ordinary VM execution never accesses it.

Trait Implementations

impl Debug for FrameObject

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl MaybeTraverse for FrameObject

const HAS_TRAVERSE: bool = true

if is traceable, will be used by vtable to determine

const HAS_CLEAR: bool = true

if has clear implementation for circular reference resolution (tp_clear)

fn try_traverse(&self, tracer_fn: &mut TraverseFn<'_>)

fn try_clear(&mut self, out: &mut Vec<PyObjectRef>)

impl PyClassDef for FrameObject

const NAME: &'static str = "frame"

const MODULE_NAME: Option<&'static str> = None

const TP_NAME: &'static str = "frame"

const DOC: ItemDoc = ::rustpython_vm::function::ItemDoc::NONE

const ATTR_DOCS: &'static [(&'static str, u32, u32)]

Attribute name → database span, sorted by name. (u32::MAX, 0) is an explicit empty doc.

const BASICSIZE: usize

const UNHASHABLE: bool = false

const MEMBERS: &'static [PyMemberSpec]

type Base = PyBaseObject

fn assert_member_layout()

const ITEMSIZE: usize = 0

impl PyClassImpl for FrameObject

const TP_FLAGS: PyTypeFlags

const INTERNAL_DOC: ItemDoc

Signature-bearing class doc. ItemDoc::NONE when the constructor has no signature.

const METHOD_DEFS: &'static [PyMethodDef]

fn impl_extend_class(ctx: &'static Context, class: &'static Py<PyType>)

fn extend_slots(slots: &mut PyTypeSlots)

fn extend_class(ctx: &'static Context, class: &'static Py<PyType>)

where Self: Sized,

fn make_static_type() -> PyTypeRef

where Self: StaticType + Sized,

fn make_slots() -> PyTypeSlots

impl PyPayload for FrameObject

const MAX_FREELIST: usize = 200

Maximum number of objects to keep in the freelist.

const HAS_FREELIST: bool = true

Whether this type has a freelist. Types with freelists require immediate (non-deferred) GC untracking during dealloc to prevent race conditions when the object is reused.

const NEW_REF_UNTRACKED: bool = true

Whether PyRef::new_ref skips auto-tracking this type in the GC even when it would otherwise qualify (has traverse, dict, or heap type). Such objects are created untracked and must be tracked explicitly if and when they can become part of a reference cycle. Used by FrameObject, which is created untracked and tracked lazily only on escape.

fn class(ctx: &Context) -> &'static Py<PyType>

unsafe fn freelist_push(obj: *mut PyObject) -> bool

Try to push a dead object onto this type’s freelist for reuse. Returns true if the object was stored (caller must NOT free the memory). Called after tp_clear, so the payload is a cleared husk; implementations must not rely on its pre-clear contents.

unsafe fn freelist_pop(_payload: &Self) -> Option<NonNull<PyObject>>

Try to pop a pre-allocated object from this type’s freelist. The returned pointer still has the old payload; the caller must reinitialize ref_count, gc_bits, and payload.

const PAYLOAD_TYPE_ID: TypeId = _

unsafe fn validate_downcastable_from(_obj: &PyObject) -> bool

Safety

fn try_downcast_from(obj: &PyObject, vm: &VirtualMachine) -> PyResult<()>

fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef

where Self: Debug,

fn _into_ref(self, cls: PyTypeRef, ctx: &Context) -> PyRef<Self>

where Self: Debug,

fn into_exact_ref(self, ctx: &Context) -> PyRefExact<Self>

where Self: Debug,

fn into_ref(self, ctx: &Context) -> PyRef<Self>

where Self: Debug,

fn into_ref_with_type( self, vm: &VirtualMachine, cls: PyTypeRef, ) -> PyResult<PyRef<Self>>

where Self: Debug,

fn into_ref_with_type_lazy_dict( self, vm: &VirtualMachine, cls: PyTypeRef, ) -> PyResult<PyRef<Self>>

where Self: Debug,

Like into_ref_with_type, but leaves the instance __dict__ unallocated until the first attribute write or __dict__ access. Only valid for types whose attribute protocol materializes the dict lazily via get_or_insert.

fn into_ref_with_type_and_dict( self, vm: &VirtualMachine, cls: PyTypeRef, eager_dict: bool, ) -> PyResult<PyRef<Self>>

where Self: Debug,

impl Representable for FrameObject

fn repr_str(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<String>

fn slot_repr(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>>

fn repr(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyRef<PyStr>>

fn repr_wtf8(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<Wtf8Buf>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

fn __extend_py_class(ctx: &'static Context, class: &'static Py<PyType>)

fn __extend_slots(slots: &mut PyTypeSlots)

impl StaticType for FrameObject

fn static_cell() -> &'static StaticCell<PyTypeRef>

fn static_metaclass() -> &'static Py<PyType>

fn static_baseclass() -> &'static Py<PyType>

fn static_type() -> &'static Py<PyType>

fn init_manually(typ: PyTypeRef) -> &'static Py<PyType>

fn init_builtin_type() -> &'static Py<PyType>

where Self: PyClassImpl,

fn create_static_type() -> PyTypeRef

where Self: PyClassImpl,

impl Traverse for FrameObject

fn traverse(&self, tracer_fn: &mut TraverseFn<'_>)

impl traverse() with caution! Following those guideline so traverse doesn’t cause memory error!:

fn clear(&mut self, out: &mut Vec<PyObjectRef>)

Extract all owned child PyObjectRefs for circular reference resolution (tp_clear). Called just before object deallocation to break circular references. Default implementation does nothing.