Struct PyCode 

pub struct PyCode {
    pub code: CodeObject<Literal>,
    pub instrumentation_version: AtomicU64,
    pub monitoring_data: PyMutex<Option<CoMonitoringData>>,
    pub quickened: AtomicBool,
    pub has_exc_handling: bool,
    /* 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).

has_exc_handling: bool

Whether the bytecode contains any instruction that mutates the current exc_info slot (vm.set_exception). When false, a normal frame call for this code cannot leave the slot unbalanced, so with_frame skips the exc_info save/restore. Computed once by scanning the instruction stream.

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 new_ref_with_bag( vm: &VirtualMachine, code: CodeObject<Literal>, ) -> PyRef<Self>

pub fn new_ref_from_bytecode( vm: &VirtualMachine, code: CodeObject, ) -> PyRef<Self>

pub fn new_ref_from_frozen<B: AsRef<[u8]>>( vm: &VirtualMachine, code: FrozenCodeObject<B>, ) -> PyRef<Self>

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 addr2line(&self, lasti_bytes: i32) -> i32

Line number for a byte offset, or -1 when the linetable has no line.

impl PyCode

pub fn co_filename(&self) -> PyStrRef

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 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.

const DROP_KWARGS_WHEN_INIT_OVERRIDDEN: bool = false

When true, extra keywords are dropped if a subclass replaced tp_init.

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 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: ItemDoc

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 PyCode

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 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 NEW_REF_UNTRACKED: bool = false

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.

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 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.

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 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,