Struct Op 

pub struct Op(/* private fields */);

Non-null pointer to a Perl OP. Same ABI as *mut OP.

Like Sv, an Op does not own its referent — dropping it is a no-op. OP lifetimes follow their owning CV (perl_destruct / op_free invalidate them), which the type does not track; keep walks inside the scope where the CV is known live.

Implementations

impl Op

pub unsafe fn from_raw_unchecked(p: *const OP) -> Self

Wrap a raw OP pointer without checking for null.

Safety

Caller must guarantee p is non-null and points to a valid OP for at least the lifetime of the resulting Op.

pub fn from_raw(p: *const OP) -> Option<Self>

Wrap a raw OP pointer, returning None on null input. Takes *const OP because that is what tree sources like Cv::root / Cv::start hand out.

pub fn as_ptr(&self) -> *mut OP

Raw pointer for FFI calls.

pub fn op_type_raw(&self) -> u32

The op’s type as a plain integer. The underlying bitfield is u16 on modern Perl but u32 on 5.30 and older — normalising to u32 here keeps callers version-portable.

pub fn opcode(&self) -> Option<opcode>

The op’s type as the opcode enum, or None for out-of-range values (custom ops).

pub fn name(&self) -> Option<&'static str>

The op’s name ("nextstate", "add", …) from the PL_op_name table, or None for out-of-range op types.

Examples found in repository

examples/walker_stash.rs (line 18)

fn print_tree(perl: &Perl, op: Op, level: usize) {
    let name = op.name().unwrap_or("<custom>");
    let loc = op
        .as_cop(perl)
        .map(|cop| format!(" (line {})", cop.line()))
        .unwrap_or_default();
    println!("{}{name}{loc}", "  ".repeat(level));
    for kid in op.kids() {
        print_tree(perl, kid, level + 1);
    }
}

examples/walker_subs.rs (line 62)

fn main() {
    let mut perl = Perl::new();
    perl.parse_env_args(env::args(), env::vars());

    let sv0 = perl.get_sv("0", 0).expect("$0 is always set");
    let main_file = String::from_utf8_lossy(sv0.pv(&perl)).into_owned();
    println!("$0 = {main_file:?}");

    let mut walker = StashWalker::new(&perl);
    walker.walk("main", &mut |e| {
        if e.cv.file().as_deref() != Some(main_file.as_str()) {
            return;
        }
        let qual = e
            .cv
            .names(&perl)
            .map(|(full, _)| full)
            .unwrap_or_else(|| format!("{}::{}", e.package, e.name));
        let line = e.cv.first_cop(&perl).map(|c| c.line());
        println!("sub {qual} (first statement at line {line:?})");

        let lexicals: Vec<String> = e
            .cv
            .pad_names()
            .flatten() // skip unnamed slots
            .filter_map(|pn| {
                // Target/temporary slots have a non-null but empty PV;
                // only real `my`/`our` names are interesting here.
                let pv = pn.pv().filter(|s| !s.is_empty())?;
                Some(match pn.type_stash_name() {
                    Some(t) => format!("{pv}: {t}"),
                    None => pv,
                })
            })
            .collect();
        println!("  lexicals: {lexicals:?}");

        let ops: Vec<&str> = e
            .cv
            .start_op()
            .into_iter()
            .flat_map(|s| s.next_iter())
            .take(20)
            .map(|o| o.name().unwrap_or("<custom>"))
            .collect();
        println!("  ops (execution order, first 20): {}", ops.join(" "));
    });
}

pub fn flags(&self) -> u8

op_flags (OPf_KIDS and friends).

pub fn next(&self) -> Option<Op>

Next op in execution order (op_next), or None at the end of the chain.

pub fn sibling(&self) -> Option<Op>

Next sibling in tree order (official OpSIBLING: the op_moresib check terminates at the parent back-pointer on 5.26+ layouts), or None for the last sibling.

pub fn first(&self) -> Option<Op>

First child (cUNOPx(o)->op_first equivalent), or None when the op has no kids (OPf_KIDS unset). No public C macro exists for this — the struct read matches what B does.

pub fn kids(&self) -> OpSiblingIter

Iterate this op’s children in tree order (first child, then its siblings). Empty for kid-less ops.

Examples found in repository

examples/walker_stash.rs (line 24)

fn print_tree(perl: &Perl, op: Op, level: usize) {
    let name = op.name().unwrap_or("<custom>");
    let loc = op
        .as_cop(perl)
        .map(|cop| format!(" (line {})", cop.line()))
        .unwrap_or_default();
    println!("{}{name}{loc}", "  ".repeat(level));
    for kid in op.kids() {
        print_tree(perl, kid, level + 1);
    }
}

pub fn next_iter(&self) -> OpNextIter

Iterate in execution order starting from (and including) this op, following op_next until null.

Note: the static op_next chain of a finished sub is not acyclic — loop constructs point back to their condition — so an unbounded walk over arbitrary code may not terminate. Cap with .take(n) unless the code is known to be straight-line.

Examples found in repository

examples/walker_subs.rs (line 60)

fn main() {
    let mut perl = Perl::new();
    perl.parse_env_args(env::args(), env::vars());

    let sv0 = perl.get_sv("0", 0).expect("$0 is always set");
    let main_file = String::from_utf8_lossy(sv0.pv(&perl)).into_owned();
    println!("$0 = {main_file:?}");

    let mut walker = StashWalker::new(&perl);
    walker.walk("main", &mut |e| {
        if e.cv.file().as_deref() != Some(main_file.as_str()) {
            return;
        }
        let qual = e
            .cv
            .names(&perl)
            .map(|(full, _)| full)
            .unwrap_or_else(|| format!("{}::{}", e.package, e.name));
        let line = e.cv.first_cop(&perl).map(|c| c.line());
        println!("sub {qual} (first statement at line {line:?})");

        let lexicals: Vec<String> = e
            .cv
            .pad_names()
            .flatten() // skip unnamed slots
            .filter_map(|pn| {
                // Target/temporary slots have a non-null but empty PV;
                // only real `my`/`our` names are interesting here.
                let pv = pn.pv().filter(|s| !s.is_empty())?;
                Some(match pn.type_stash_name() {
                    Some(t) => format!("{pv}: {t}"),
                    None => pv,
                })
            })
            .collect();
        println!("  lexicals: {lexicals:?}");

        let ops: Vec<&str> = e
            .cv
            .start_op()
            .into_iter()
            .flat_map(|s| s.next_iter())
            .take(20)
            .map(|o| o.name().unwrap_or("<custom>"))
            .collect();
        println!("  ops (execution order, first 20): {}", ops.join(" "));
    });
}

pub fn class(&self, perl: &Perl) -> OPclass

The op’s class (Perl_op_class, the same classification B exposes as B::class).

pub fn as_cop(&self, perl: &Perl) -> Option<Cop>

View this op as a Cop when it is one (nextstate / dbstate), giving access to its file / line.

Examples found in repository

examples/walker_stash.rs (line 20)

fn print_tree(perl: &Perl, op: Op, level: usize) {
    let name = op.name().unwrap_or("<custom>");
    let loc = op
        .as_cop(perl)
        .map(|cop| format!(" (line {})", cop.line()))
        .unwrap_or_default();
    println!("{}{name}{loc}", "  ".repeat(level));
    for kid in op.kids() {
        print_tree(perl, kid, level + 1);
    }
}

Trait Implementations

impl Clone for Op

fn clone(&self) -> Op

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Op