Struct Context

pub struct Context<'a> {
    pub state: State,
    pub stack: Stack,
    pub exit_code: u8,
    pub next: Option<RcFiftCont>,
    pub dicts: Dictionaries,
    pub limits: ExecutionLimits,
    pub stats: ExecutionStats,
    pub input: Lexer,
    pub exit_interpret: SharedBox,
    pub env: &'a mut dyn Environment,
    pub stdout: &'a mut dyn Write,
    pub stderr: &'a mut dyn Write,
}

Fields

state: State

stack: Stack

exit_code: u8

next: Option<RcFiftCont>

dicts: Dictionaries

limits: ExecutionLimits

stats: ExecutionStats

input: Lexer

exit_interpret: SharedBox

env: &'a mut dyn Environment

stdout: &'a mut dyn Write

stderr: &'a mut dyn Write

Implementations

impl<'a> Context<'a>

pub fn new( env: &'a mut dyn Environment, stdout: &'a mut dyn Write, stderr: &'a mut dyn Write, ) -> Self

pub fn with_module<T: Module>(self, module: T) -> Result<Self>

pub fn add_module<T: Module>(&mut self, module: T) -> Result<()>

pub fn with_source_block(self, block: SourceBlock) -> Self

pub fn add_source_block(&mut self, block: SourceBlock)

pub fn with_limits(self, limits: ExecutionLimits) -> Self

pub fn set_limits(&mut self, limits: ExecutionLimits)

pub fn run(&mut self) -> Result<u8>

impl Context<'_>

pub fn with_basic_modules(self) -> Result<Self>