Struct rustpython_vm::frame::Frame

pub struct Frame {
    pub code: PyRef<PyCode>,
    pub fastlocals: PyMutex<Box<[Option<PyObjectRef>]>>,
    pub locals: ArgMapping,
    pub globals: PyDictRef,
    pub builtins: PyDictRef,
    pub lasti: Cell<u32>,
    pub trace: PyMutex<PyObjectRef>,
    pub trace_lines: PyMutex<bool>,
    pub temporary_refs: PyMutex<Vec<PyObjectRef>>,
    /* private fields */
}

Fields

code: PyRef<PyCode>

fastlocals: PyMutex<Box<[Option<PyObjectRef>]>>

locals: ArgMapping

globals: PyDictRef

builtins: PyDictRef

lasti: Cell<u32>

index of last instruction ran

trace: PyMutex<PyObjectRef>

tracer function for this frame (usually is None)

trace_lines: PyMutex<bool>

temporary_refs: PyMutex<Vec<PyObjectRef>>

Implementations

impl Frame

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

pub fn f_lineno(&self) -> usize

impl Frame

pub fn current_location(&self) -> SourceLocation

pub fn lasti(&self) -> u32

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

Trait Implementations

impl Debug for Frame

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

Formats the value using the given formatter.

impl MaybeTraverse for Frame

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

const IS_TRACE: bool = false

if is traceable, will be used by vtable to determine

impl PyClassDef for Frame

const NAME: &'static str = _

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

const TP_NAME: &'static str = _

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

const BASICSIZE: usize = 100usize

const UNHASHABLE: bool = false

type Base = PyBaseObject

impl PyClassImpl for Frame

const TP_FLAGS: PyTypeFlags = _

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

fn impl_extend_method_def(method_defs: &mut Vec<PyMethodDef>)

fn extend_slots(slots: &mut PyTypeSlots)

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

fn make_class(ctx: &Context) -> PyTypeRefwhere Self: StaticType,

fn make_slots() -> PyTypeSlots

impl PyPayload for Frame

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

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

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

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

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

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

impl Representable for Frame

fn repr(_zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyStrRef>

fn repr_str(_zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String>

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

fn __repr__(zelf: PyObjectRef, vm: &VirtualMachine) -> PyResult<PyStrRef>

fn __extend_method_def(method_defs: &mut Vec<PyMethodDef>)

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

fn __extend_slots(slots: &mut PyTypeSlots)

impl StaticType for Frame

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() -> PyTypeRefwhere Self: PyClassImpl,

impl Unconstructible for Frame