Struct PyCode 

pub struct PyCode {
    pub code: CodeObject<Literal>,
    pub instrumentation_version: AtomicU64,
    pub monitoring_data: PyMutex<Option<CoMonitoringData>>,
    pub quickened: AtomicBool,
    /* private fields */
}

Fields

code: CodeObject<Literal>

instrumentation_version: AtomicU64

Version counter for lazy re-instrumentation. Compared against PyGlobalState::instrumentation_version at RESUME.

monitoring_data: PyMutex<Option<CoMonitoringData>>

Side-table for INSTRUMENTED_LINE / INSTRUMENTED_INSTRUCTION.

quickened: AtomicBool

Whether adaptive counters have been initialized (lazy quickening).

Implementations

impl PyCode

pub fn new(code: CodeObject<Literal>) -> Self

pub fn source_path(&self) -> &'static PyStrInterned

pub fn set_source_path(&self, new: &'static PyStrInterned)

pub fn from_pyc_path(path: &Path, vm: &VirtualMachine) -> PyResult<PyRef<Self>>

pub fn from_pyc( pyc_bytes: &[u8], name: Option<&str>, bytecode_path: Option<&str>, source_path: Option<&str>, vm: &VirtualMachine, ) -> PyResult<PyRef<Self>>

impl PyCode

pub fn co_filename(&self) -> PyStrRef

pub fn co_cellvars(&self, vm: &VirtualMachine) -> PyTupleRef

pub fn co_varnames(&self, vm: &VirtualMachine) -> PyTupleRef

pub fn co_code(&self, vm: &VirtualMachine) -> PyBytesRef

pub fn _co_code_adaptive(&self, vm: &VirtualMachine) -> PyBytesRef

pub fn co_freevars(&self, vm: &VirtualMachine) -> PyTupleRef

pub fn co_linetable(&self, vm: &VirtualMachine) -> PyBytesRef

pub fn co_exceptiontable(&self, vm: &VirtualMachine) -> PyBytesRef

pub fn co_lines(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef>

pub fn co_positions(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef>

pub fn co_branches(&self, vm: &VirtualMachine) -> PyResult<PyObjectRef>

pub fn __replace__( &self, args: ReplaceArgs, vm: &VirtualMachine, ) -> PyResult<Self>

pub fn replace(&self, args: ReplaceArgs, vm: &VirtualMachine) -> PyResult<Self>

Methods from Deref<Target = CodeObject<Literal>>

pub fn arg_names(&self) -> Arguments<'_, <C as Constant>::Name>

Get all arguments of the code object like inspect.getargs

pub fn label_targets(&self) -> BTreeSet<Label>

Return the labels targeted by the instructions of this CodeObject

pub fn display_expand_code_objects(&self) -> impl Display

Recursively display this CodeObject

pub fn map_clone_bag<Bag>( &self, bag: &Bag, ) -> CodeObject<<Bag as ConstantBag>::Constant>

where Bag: ConstantBag,

Same as map_bag but clones self

Trait Implementations

impl Comparable for PyCode

fn cmp( zelf: &Py<Self>, other: &PyObject, op: PyComparisonOp, vm: &VirtualMachine, ) -> PyResult<PyComparisonValue>

fn slot_richcompare( zelf: &PyObject, other: &PyObject, op: PyComparisonOp, vm: &VirtualMachine, ) -> PyResult<Either<PyObjectRef, PyComparisonValue>>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

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

fn __extend_slots(slots: &mut PyTypeSlots)

impl Constructor for PyCode

type Args = PyCodeNewArgs

fn py_new( _cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine, ) -> PyResult<Self>

Creates the payload for this type. In most cases, just implement this method and let the default slot_new handle wrapping with the correct type.

fn slot_new(cls: PyTypeRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult

The type slot for __new__. Override this only when you need special behavior beyond simple payload creation.

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

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

fn __extend_slots(slots: &mut PyTypeSlots)

impl Debug for PyCode

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

Formats the value using the given formatter.

impl Deref for PyCode

type Target = CodeObject<Literal>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Display for PyCode

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

Formats the value using the given formatter.

impl Hashable for PyCode

fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<PyHash>

fn slot_hash(zelf: &PyObject, vm: &VirtualMachine) -> PyResult<PyHash>

const __OWN_METHOD_DEFS: &'static [PyMethodDef] = _

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

fn __extend_slots(slots: &mut PyTypeSlots)

impl MaybeTraverse for PyCode

const HAS_TRAVERSE: bool = false

if is traceable, will be used by vtable to determine

const HAS_CLEAR: bool = false

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 PyCode

const NAME: &'static str = "code"

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

const TP_NAME: &'static str = "code"

const DOC: Option<&'static str>

const BASICSIZE: usize

const UNHASHABLE: bool = false

type Base = PyBaseObject

const ITEMSIZE: usize = 0

impl PyClassImpl for PyCode

const TP_FLAGS: PyTypeFlags

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 PyCode

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

const PAYLOAD_TYPE_ID: TypeId = _

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

Safety

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

const HAS_FREELIST: bool = false

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 MAX_FREELIST: usize = 0

Maximum number of objects to keep in the freelist.

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 before tp_clear, so the payload is still intact.

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.

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,

impl Representable for PyCode

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 PyCode

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,