Enum Op 

pub enum Op {
    Move {
        from: Operand,
        to: u32,
        plan: MovePlan,
        check: SenderCheck,
    },
    Set {
        from: Operand,
        to: u32,
        plan: MovePlan,
    },
    Initialize {
        target: u32,
        plan: u32,
    },
    Arith(u32),
    SetAddress {
        records: Vec<u16>,
        address: Operand,
    },
    SetUpDown {
        by: IntExpr,
        down: bool,
        targets: Vec<(u32, UpDown)>,
    },
    SetEntry {
        entry: Operand,
        targets: Vec<u32>,
    },
    Step {
        var: u32,
        by: u32,
        plan: StepPlan,
        prepass: Vec<u32>,
    },
    SetInt {
        target: u32,
        value: IntExpr,
    },
    Inspect(u32),
    String(u32),
    Unstring(u32),
    SearchAll(u32),
    Nest,
    Unnest(u8),
    SetTemp(u16, IntExpr),
    DecTemp(u16),
    SetCount(u16, Odo),
    Display(u32),
    Accept {
        target: u32,
        from: AcceptFrom,
        plan: MovePlan,
    },
    File(u32),
    Call(u32),
    Cancel(Operand),
    Sort(u32),
    Release(u32),
    Return(u32),
    Report(ReportOp),
    Invoke(u32),
    Cics(u32),
    Sql(u32),
    Alter {
        para: u32,
        to: u32,
    },
    EnterSegment(u8),
    DebugLine(u32),
    DebugAlter {
        range: u32,
        name: u32,
        contents: u32,
    },
    Markup(u32),
}

Variants

Move

to located, then from, which takes NUMCHECK’s check before it is read.

Fields

from: Operand

to: u32

plan: MovePlan

check: SenderCheck

Set

SET TO, and PERFORM VARYING’s FROM: as Move, but a data item sender is read as a number, its digits checked, where MOVE carries a zoned or packed sender’s invalid digits (C260).

Fields

from: Operand

to: u32

plan: MovePlan

Initialize

Fields

target: u32

plan: u32

Arith(u32)

SetAddress

SET ADDRESS OF: address evaluated once, NULL or an address in run-unit memory, then each LINKAGE record given it in turn.

Fields

records: Vec<u16>

address: Operand

SetUpDown

SET UP BY or DOWN BY: by evaluated once, then each receiver read and moved in turn.

Fields

by: IntExpr

down: bool

targets: Vec<(u32, UpDown)>

SetEntry

SET TO ENTRY: entry read as a program name and the program loaded, dynamically unless it is a literal under NODYNAM, then each function-pointer or procedure-pointer given the value naming it in the run unit’s list of entries.

Fields

entry: Operand

targets: Vec<u32>

Step

PERFORM VARYING’s increment: var located, then each place of prepass, then var + by computed and stored.

Fields

var: u32

by: u32

plan: StepPlan

prepass: Vec<u32>

SetInt

SEARCH’s index steps, SORT-RETURN.

Fields

target: u32

value: IntExpr

Inspect(u32)

String(u32)

Unstring(u32)

SearchAll(u32)

Nest

Raises the PERFORM and CALL depth, abending past 100.

Unnest(u8)

SetTemp(u16, IntExpr)

DecTemp(u16)

SetCount(u16, Odo)

SEARCH’s table count, evaluated once at the statement’s start as occurrences evaluates it, abending as it abends, and held in the top frame’s counter temp, which Count::Temp reads.

Display(u32)

Accept

Fields

target: u32

from: AcceptFrom

plan: MovePlan

File(u32)

Call(u32)

Cancel(Operand)

Sort(u32)

Release(u32)

Return(u32)

Report(ReportOp)

Invoke(u32)

Cics(u32)

Sql(u32)

Alter

ALTER: from now on control reaching paragraph para goes to to. The alter table lives as long as the program’s WORKING-STORAGE.

Fields

para: u32

to: u32

EnterSegment(u8)

Control reaching a paragraph of segment priority: when that differs from the segment register and is 50 or more, the alter entries of the segment’s paragraphs are cleared. The register then holds priority.

DebugLine(u32)

Under the DEBUG option: the line of the statement starting, which DEBUG-LINE gives.

DebugAlter

Under the DEBUG option, after an ALTER of a paragraph a debugging section serves: that section, with DEBUG-NAME name and DEBUG-CONTENTS contents, the TO PROCEED TO name.

Fields

range: u32

name: u32

contents: u32

Markup(u32)

JSON GENERATE, JSON PARSE, XML GENERATE or XML PARSE (lir.md §9.13).

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 Debug for Op

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

Formats the value using the given formatter.

impl Decode for Op

fn decode(r: &mut Reader<'_>) -> Result<Op, ModuleError>

impl Encode for Op

fn encode(&self, w: &mut Writer)

impl Eq for Op

impl PartialEq for Op

fn eq(&self, other: &Op) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Op