Enum Stmt 

pub enum Stmt {
    Move {
        from: Operand,
        to: Vec<Ref>,
        pos: Pos,
    },
    Compute {
        targets: Vec<Target>,
        expr: Expr,
        size_error: Option<SizeError>,
        pos: Pos,
    },
    Arith(Box<Arith>),
    If {
        cond: Cond,
        then: Vec<Stmt>,
        otherwise: Vec<Stmt>,
        pos: Pos,
    },
    PerformInline {
        body: Vec<Stmt>,
        repeat: Loop,
        pos: Pos,
    },
    PerformProc {
        from: ProcName,
        thru: Option<ProcName>,
        repeat: Loop,
        pos: Pos,
    },
    Evaluate {
        subjects: Vec<Subject>,
        whens: Vec<When>,
        other: Vec<Stmt>,
        pos: Pos,
    },
    Display {
        items: Vec<Operand>,
        no_advancing: bool,
        pos: Pos,
    },
    Open {
        files: Vec<(OpenMode, String)>,
        pos: Pos,
    },
    Close {
        files: Vec<String>,
        pos: Pos,
    },
    Read(Box<ReadStmt>),
    Write {
        record: Ref,
        from: Option<Operand>,
        advancing: Option<Advancing>,
        invalid: Handlers,
        end_of_page: Handlers,
        pos: Pos,
    },
    Rewrite {
        record: Ref,
        from: Option<Operand>,
        invalid: Handlers,
        pos: Pos,
    },
    Delete {
        file: String,
        invalid: Handlers,
        pos: Pos,
    },
    Start {
        file: String,
        key: Option<(RelOp, Ref)>,
        invalid: Handlers,
        pos: Pos,
    },
    Initialize {
        targets: Vec<Ref>,
        pos: Pos,
    },
    GoTo {
        target: Option<ProcName>,
        pos: Pos,
    },
    GoToDepending {
        targets: Vec<ProcName>,
        on: Ref,
        pos: Pos,
    },
    Alter {
        pairs: Vec<(ProcName, ProcName)>,
        pos: Pos,
    },
    Entry {
        name: String,
        using: Vec<Param>,
        pos: Pos,
    },
    Goback {
        pos: Pos,
    },
    ExitProgram {
        pos: Pos,
    },
    Call(Box<Call>),
    Cancel {
        targets: Vec<Operand>,
        pos: Pos,
    },
    Set {
        set: SetStmt,
        pos: Pos,
    },
    Accept {
        target: Ref,
        from: AcceptFrom,
        pos: Pos,
    },
    String(Box<StringStmt>),
    Unstring(Box<Unstring>),
    Inspect(Box<Inspect>),
    Search(Box<Search>),
    NextSentence,
    SentenceEnd,
    Exec(Box<ExecBlock>),
    Report(Box<ReportStmt>),
    Invoke(Box<Invoke>),
    ExitMethod {
        pos: Pos,
    },
    Sorting(Box<Sorting>),
    StopRun {
        pos: Pos,
    },
    Continue,
    Exit {
        kind: ExitKind,
        pos: Pos,
    },
}

Variants

Move

Fields

from: Operand

to: Vec<Ref>

pos: Pos

Compute

Fields

targets: Vec<Target>

expr: Expr

size_error: Option<SizeError>

pos: Pos

Arith(Box<Arith>)

ADD, SUBTRACT, MULTIPLY and DIVIDE, reduced to their arithmetic.

If

Fields

cond: Cond

then: Vec<Stmt>

otherwise: Vec<Stmt>

pos: Pos

PerformInline

Fields

body: Vec<Stmt>

repeat: Loop

pos: Pos

PerformProc

Fields

from: ProcName

thru: Option<ProcName>

repeat: Loop

pos: Pos

Evaluate

Fields

subjects: Vec<Subject>

whens: Vec<When>

other: Vec<Stmt>

pos: Pos

Display

Fields

items: Vec<Operand>

no_advancing: bool

pos: Pos

Open

Fields

files: Vec<(OpenMode, String)>

pos: Pos

Close

Fields

files: Vec<String>

pos: Pos

Read(Box<ReadStmt>)

Write

Fields

record: Ref

from: Option<Operand>

advancing: Option<Advancing>

invalid: Handlers

end_of_page: Handlers

pos: Pos

Rewrite

Fields

record: Ref

from: Option<Operand>

invalid: Handlers

pos: Pos

Delete

Fields

file: String

invalid: Handlers

pos: Pos

Start

Fields

file: String

key: Option<(RelOp, Ref)>

invalid: Handlers

pos: Pos

Initialize

Fields

targets: Vec<Ref>

pos: Pos

GoTo

GO TO; with no target, the altered GO TO that only an ALTER gives one.

Fields

target: Option<ProcName>

pos: Pos

GoToDepending

GO TO … DEPENDING ON: the procedure the item’s value numbers, or on when none does.

Fields

targets: Vec<ProcName>

on: Ref

pos: Pos

Alter

ALTER: each paragraph whose GO TO is to go instead to the procedure paired with it.

Fields

pairs: Vec<(ProcName, ProcName)>

pos: Pos

Entry

ENTRY: where a CALL of name begins, and the LINKAGE items its USING list addresses.

Fields

name: String

using: Vec<Param>

pos: Pos

Goback

Fields

pos: Pos

ExitProgram

EXIT PROGRAM: returns from a called program; in the first program it does nothing.

Fields

pos: Pos

Call(Box<Call>)

Cancel

Fields

targets: Vec<Operand>

pos: Pos

Set

Fields

set: SetStmt

pos: Pos

Accept

Fields

target: Ref

from: AcceptFrom

pos: Pos

String(Box<StringStmt>)

Unstring(Box<Unstring>)

Inspect(Box<Inspect>)

Search(Box<Search>)

NextSentence

NEXT SENTENCE: control passes to the statement after the next separator period.

SentenceEnd

A separator period in the PROCEDURE DIVISION: where NEXT SENTENCE resumes.

Exec(Box<ExecBlock>)

Report(Box<ReportStmt>)

Invoke(Box<Invoke>)

ExitMethod

Fields

pos: Pos

Sorting(Box<Sorting>)

StopRun

Fields

pos: Pos

Continue

Exit

Fields

kind: ExitKind

pos: Pos

Trait Implementations

impl Clone for Stmt

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Stmt

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

Formats the value using the given formatter.

impl Eq for Stmt

impl PartialEq for Stmt

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Stmt