Struct Machine 

pub struct Machine<'p, 'u, 'w> { /* private fields */ }

Implementations

impl<'p, 'u, 'w> Machine<'p, 'u, 'w>

pub fn activation( compiled: &'p Compiled, me: usize, unit: &'u mut RunUnit<'w>, main: bool, ) -> Result<Self, Abend>

An activation of loaded program me. Its storage is initialized on its first activation, after a CANCEL, and on every activation of an INITIAL program.

pub fn unbound( compiled: &'p Compiled, me: usize, unit: &'u mut RunUnit<'w>, ) -> Result<Self, Abend>

An activation with no EXTERNAL or GLOBAL record bound, which VALUE clauses never reach: the storage lowering keeps as a program’s initial image.

pub fn run_procedure(&mut self) -> Result<Ending, Abend>

Trait Implementations

impl<'a, 'w> Arguments<'w, &'a Ref, &'a Operand> for Machine<'_, '_, 'w>

fn item(&self, operand: &&'a Operand) -> Option<&'a Ref>

The data item an operand names, when it names one.

fn length_of(&self, operand: &&'a Operand) -> bool

Whether an operand is LENGTH OF, which BY CONTENT passes as a binary fullword.

fn content_item(&mut self, place: &'a Ref) -> Result<Loc, Abend>

A data item BY CONTENT copies, located and given NUMCHECK’s test.

impl<'a, 'w> CicsHost<'w, &'a Ref, &'a Operand, &'a str> for Machine<'_, '_, 'w>

fn handlers(&mut self) -> &mut Handlers

fn content(&mut self, operand: &&'a Operand, pos: Pos) -> Result<Vec<u8>, Abend>

An operand’s bytes as CALL BY CONTENT passes them.

fn integer_of(&mut self, operand: &&'a Operand, pos: Pos) -> Result<i64, Abend>

An operand’s value as a subscript takes it.

fn text(&self, text: &&'a str) -> String

fn activation(&self) -> u64

This activation of the program, which a HANDLE ABEND LABEL it sets belongs to.

fn program_id(&self) -> String

fn commarea(&self) -> Option<usize>

Where DFHCOMMAREA is, when the program has one with an address.

fn mapset(&mut self, name: &str) -> Option<Result<Mapset, String>>

A mapset from the copy libraries; None when no library holds it.

fn item_named(&mut self, name: &str, pos: Pos) -> Result<Option<Loc>, Abend>

The data item a name alone refers to, when it names one.

fn locate_named(&mut self, name: &str, pos: Pos) -> Result<Loc, Abend>

The data item a name alone refers to, or the abend a reference to it gives.

fn unaddressed(&mut self, place: &'a Ref) -> Option<usize>

The length of the data item place when it is in a LINKAGE record with no address, where ADDRESS OF gives NULL; None when it has storage to locate.

fn run_program( &mut self, program: Option<Rc<Compiled>>, index: usize, commarea: Option<usize>, xctl: bool, ) -> Result<Ending, Abend>

Runs program index from its start with DFHEIBLK and commarea as its USING items; for XCTL, in this program’s place at its logical level, with the handlers Handlers::xctl leaves it (C239, C146). program is None for the task’s first program, whose handle the run unit does not hold (C148).

impl<'a, 'p> Host<&'a Ref> for Machine<'p, '_, '_>

type Facts = Facts<'p>

fn facts(&self) -> Facts<'p>

fn mem(&mut self) -> &mut [u8]

fn taint(&mut self) -> Option<&mut Taint>

The run unit’s taint, when it traces input; a write through Host::mem marks its bytes here, as [write] does.

fn locate(&mut self, place: &'a Ref, receiving: bool) -> Result<Loc, Abend>

With receiving, a group holding the object of its own OCCURS DEPENDING ON is its maximum length.

fn integer(&mut self, place: &'a Ref, pos: Pos) -> Result<i64, Abend>

The place’s value as a subscript takes it.

fn assign( &mut self, dest: Loc, val: Val, src: Option<Loc>, pos: Pos, ) -> Result<(), Abend>

MOVE into dest; src is the sender’s storage when it has any.

fn store_fixed( &mut self, dest: Loc, value: &Fixed, pos: Pos, ) -> Result<(), Abend>

A numeric store, not ROUNDED, with no size error.

impl<'w> LeHost<'w> for Machine<'_, '_, 'w>

fn page(&self) -> &'static CodePage

fn method_name(program: &Rc<Compiled>) -> Option<String>

Class.method for a loaded COBOL method; None for a program, which a dump lists by name.

impl<'p> ReportHost<'p, Expr, Ref, Literal, (usize, usize)> for Machine<'p, '_, '_>

fn value(&mut self, expr: &Expr, pos: Pos) -> Result<Val, Abend>

fn operand( &mut self, expr: &Expr, pos: Pos, ) -> Option<Result<(Val, Option<Loc>), Abend>>

A lone operand’s value and its storage, when it has any; None for any other expression.

fn literal(&mut self, value: &Literal, pos: Pos) -> Result<Val, Abend>

fn item(&self, item: usize) -> Loc

fn store_value( &mut self, dest: Loc, value: Val, rounded: bool, keep_on_size_error: bool, pos: Pos, ) -> Result<bool, Abend>

Stores an arithmetic result; true when it was a size error.

fn store_checked( &mut self, dest: Loc, value: &Fixed, pos: Pos, ) -> Result<bool, Abend>

A numeric store, not ROUNDED, that keeps the receiver on a size error; true when it was one.

fn report_file(&mut self, k: usize) -> ReportFile

fn write_line( &mut self, k: usize, loc: Loc, space: Spacing, pos: Pos, ) -> Result<(), Abend>

WRITE … AFTER ADVANCING space of the record at loc to file k.

fn use_before_reporting( &mut self, (first, last): &Section, pos: Pos, ) -> Result<UseEnd, Abend>

Performs a USE BEFORE REPORTING procedure.

fn err(&mut self) -> &mut dyn Write

impl<'w> UnitHost<'w> for Machine<'_, '_, 'w>

type Program = Rc<Compiled>

type Loader = Library

fn unit(&mut self) -> &mut RunUnit<'w>

impl<'a> Values<&'a Ref, &'a Operand> for Machine<'_, '_, '_>

fn value(&mut self, operand: &&'a Operand, pos: Pos) -> Result<Val, Abend>