Struct tokay::vm::Context

pub struct Context<'program, 'reader, 'thread, 'parselet> {
    pub thread: &'thread mut Thread<'program, 'reader>,
    pub parselet: &'parselet Parselet,
    pub reader_start: Offset,
    pub depth: usize,
    pub debug: u8,
    pub stack: Vec<Capture>,
    pub frames: Vec<Frame>,
    pub frame: Frame,
    pub loops: Vec<Loop>,
    pub source_offset: Option<Offset>,
    /* private fields */
}

Contexts represent stack frames for parselet calls.

Within the context, most operations regarding capture storing and loading is performed.

Fields

thread: &'thread mut Thread<'program, 'reader>

parselet: &'parselet Parselet

reader_start: Offset

depth: usize

debug: u8

stack: Vec<Capture>

frames: Vec<Frame>

frame: Frame

loops: Vec<Loop>

source_offset: Option<Offset>

Implementations

impl<'program, 'reader, 'thread, 'parselet> Context<'program, 'reader, 'thread, 'parselet>

pub fn new( thread: &'thread mut Thread<'program, 'reader>, parselet: &'parselet Parselet, depth: usize, stack: Vec<Capture>, ) -> Self

pub fn log(&self, msg: &str)

Print debug output with context depth indention

pub fn push(&self, value: RefValue) -> Result<Accept, Reject>

Shortcut for an Ok(Accept::Push) with the given value. To push a value immediatelly, use context.thread.stack.push().

pub fn pop(&mut self) -> RefValue

Pop value off the stack.

pub fn peek(&mut self) -> RefValue

Peek top value of stack.

pub fn load(&mut self, index: usize) -> Result<Accept, Reject>

pub fn frame0(&self) -> &Frame

Return top-level frame

pub fn frame0_mut(&mut self) -> &mut Frame

Return mutable top-level frame

pub fn get_capture(&mut self, pos: usize) -> Option<Capture>

Return a capture by index as RefValue.

pub fn get_capture_by_name(&mut self, name: &str) -> Option<Capture>

Return a capture by name as RefValue.

pub fn set_capture(&mut self, pos: usize, value: RefValue)

Set a capture to a RefValue by index.

pub fn set_capture_by_name(&mut self, name: &str, value: RefValue)

Set a capture to a RefValue by name.

pub fn collect( &mut self, capture_start: usize, copy: bool, sequence: bool, debug: bool, ) -> Capture

Collect captures from a capture_start and turn them either into a dict or list object capture.

Any items with a severity of at least 1 are being collected, but higher severities always win.

• Results of a collection (either list or dict) inherit the highest collected severity
• Token severity:
  • 0: Whitespace
  • 1: Touch
  • 5: Match, character-class, parselet
  • 10: Defined value

This function is internally used for automatic AST construction and value inheriting.

pub fn drain(&mut self, n: usize) -> Vec<RefValue>

Drains n items off the stack into a vector of values

pub fn run(&mut self, main: bool) -> Result<Accept, Reject>

Run the current context with the associated parselet