Struct Interpreter

pub struct Interpreter<State> {
    pub state: State,
    /* private fields */
}

The core interpreter object. Takes in a custom defined state that can be modified by built-ins.

Fields

state: State

Custom state for each application. Allows users to register built-ins that modify this state.

Implementations

impl<State> Interpreter<State>

pub fn reset_program(&mut self)

Resets the program counter and clears the program and program debug locations but preserves RAM and stack.

impl<State> Interpreter<State>

pub fn format_code(code: &str, path: Option<PathBuf>) -> Result<String, Err>

Format a code file.

pub fn stringify_program(&self) -> String

Returns the program as a formatted string.

impl<State> Interpreter<State>

pub fn new(state: State) -> Self

Create a new interpreter. Pass in the initial custom state for the interpreter.

Examples found in repository

examples/add.rs (line 5)

fn main() {
    let code = "1 1 +";
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None).unwrap();

    println!("1 1 + ={}", interpreter.pop_number().unwrap());
}

examples/print_documentation.rs (line 8)

fn main() {
    println!("This is how you print documentation");
    let code = r#"
    documentation
    "#;
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None).unwrap();
}

examples/custom_word.rs (line 15)

fn main() {
    let code = r#"
    : squared
        "n -- n^2"
        "Squares the top of the stack"
        "2 squared"
        dup *
    ;

    2 squared
    print-stack
    "#;
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None).unwrap();
}

examples/repl.rs (line 6)

fn main() {
    // TODO: figure out way to start repl in interpreter
    // let code = "repl \"example of repl\" print-stack";
    let mut interpreter = Interpreter::new(());
    // interpreter.evaluate(code, None).unwrap();

    // Alternative way to start repl in host
    interpreter.start_repl();
}

examples/loop.rs (line 21)

fn main() {
    let code = r#"

    0
    begin
        print-stack
    
        dup 10 <=
        if
            drop
            "loop finished"
            print-stack
            break
        end
        1 + 
    loop
    
    "#;
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None);
}

examples/if.rs (line 29)

fn main() {
    let code = r#"
    "Example of if"
    print-stack
    drop

    1 if 
        "evaluated when true!"
        print-stack
        drop
    end

    "Now we do an example of an else"
    print-stack
    drop

    0 if 
        "Not ran"
        print-stack
        drop
    else
        "else is ran"
        print-stack
        drop
    end
    "#;
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None);
}

Additional examples can be found in:

• examples/custom_builtin.rs

pub fn evaluate(&mut self, code: &str, path: Option<PathBuf>) -> Result<(), Err>

Evaluate a program.

Examples found in repository

examples/add.rs (line 6)

fn main() {
    let code = "1 1 +";
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None).unwrap();

    println!("1 1 + ={}", interpreter.pop_number().unwrap());
}

examples/print_documentation.rs (line 9)

fn main() {
    println!("This is how you print documentation");
    let code = r#"
    documentation
    "#;
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None).unwrap();
}

examples/custom_word.rs (line 16)

fn main() {
    let code = r#"
    : squared
        "n -- n^2"
        "Squares the top of the stack"
        "2 squared"
        dup *
    ;

    2 squared
    print-stack
    "#;
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None).unwrap();
}

examples/loop.rs (line 22)

fn main() {
    let code = r#"

    0
    begin
        print-stack
    
        dup 10 <=
        if
            drop
            "loop finished"
            print-stack
            break
        end
        1 + 
    loop
    
    "#;
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None);
}

examples/if.rs (line 30)

fn main() {
    let code = r#"
    "Example of if"
    print-stack
    drop

    1 if 
        "evaluated when true!"
        print-stack
        drop
    end

    "Now we do an example of an else"
    print-stack
    drop

    0 if 
        "Not ran"
        print-stack
        drop
    else
        "else is ran"
        print-stack
        drop
    end
    "#;
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None);
}

examples/custom_builtin.rs (line 38)

fn main() {
    let state: u32 = 0;
    let mut interpreter = Interpreter::new(state);

    interpreter.register_builtin(
        "increment-state",
        "--",
        "Increments the state.",
        "increment-state",
        |interpreter| {
            interpreter.state += 1;
            Ok(())
        },
    );

    interpreter.register_builtin(
        "get-state",
        "-- n",
        "Gets the state.",
        "get-state",
        |interpreter| {
            interpreter.push_number(interpreter.state as f32);
            Ok(())
        },
    );

    let code = r#"
    print-stack
    increment-state
    get-state
    "The state has been modified!"
    print-stack
    "#;

    println!("State before execution: {:?}", interpreter.state);
    interpreter.evaluate(code, None).unwrap();
    println!("State after execution: {:?}", interpreter.state);
}

pub fn get_name(&self, address: Address) -> String

Get the name of an address if present.

pub fn pop(&mut self) -> Result<StackValue, Err>

Pop a value from the stack.

pub fn pop_bool(&mut self) -> Result<bool, Err>

Pop a boolean from the stack.

pub fn pop_number(&mut self) -> Result<f32, Err>

Pop a number from the stack.

Examples found in repository

examples/add.rs (line 8)

fn main() {
    let code = "1 1 +";
    let mut interpreter = Interpreter::new(());
    interpreter.evaluate(code, None).unwrap();

    println!("1 1 + ={}", interpreter.pop_number().unwrap());
}

pub fn push_number(&mut self, number: f32)

Push a number onto the stack.

Examples found in repository

examples/custom_builtin.rs (line 24)

fn main() {
    let state: u32 = 0;
    let mut interpreter = Interpreter::new(state);

    interpreter.register_builtin(
        "increment-state",
        "--",
        "Increments the state.",
        "increment-state",
        |interpreter| {
            interpreter.state += 1;
            Ok(())
        },
    );

    interpreter.register_builtin(
        "get-state",
        "-- n",
        "Gets the state.",
        "get-state",
        |interpreter| {
            interpreter.push_number(interpreter.state as f32);
            Ok(())
        },
    );

    let code = r#"
    print-stack
    increment-state
    get-state
    "The state has been modified!"
    print-stack
    "#;

    println!("State before execution: {:?}", interpreter.state);
    interpreter.evaluate(code, None).unwrap();
    println!("State after execution: {:?}", interpreter.state);
}

pub fn push_address(&mut self, address: Address)

Push an address onto the stack.

pub fn pop_address(&mut self) -> Result<Address, Err>

Pop an address from the stack.

pub fn push_string(&mut self, string: String)

Push a string onto the stack.

pub fn pop_string(&mut self) -> Result<String, Err>

Pop a string from the stack.

pub fn start_repl(&mut self) -> Result<(), Err>

Start a REPL.

Examples found in repository

examples/repl.rs (line 10)

fn main() {
    // TODO: figure out way to start repl in interpreter
    // let code = "repl \"example of repl\" print-stack";
    let mut interpreter = Interpreter::new(());
    // interpreter.evaluate(code, None).unwrap();

    // Alternative way to start repl in host
    interpreter.start_repl();
}

pub fn register_builtin( &mut self, name: &str, stack_modification: &str, documentation: &str, example: &str, func: BuiltIn<State>, )

Register a built-in function to be used in the interpreter.

Examples found in repository

examples/custom_builtin.rs (lines 7-16)

fn main() {
    let state: u32 = 0;
    let mut interpreter = Interpreter::new(state);

    interpreter.register_builtin(
        "increment-state",
        "--",
        "Increments the state.",
        "increment-state",
        |interpreter| {
            interpreter.state += 1;
            Ok(())
        },
    );

    interpreter.register_builtin(
        "get-state",
        "-- n",
        "Gets the state.",
        "get-state",
        |interpreter| {
            interpreter.push_number(interpreter.state as f32);
            Ok(())
        },
    );

    let code = r#"
    print-stack
    increment-state
    get-state
    "The state has been modified!"
    print-stack
    "#;

    println!("State before execution: {:?}", interpreter.state);
    interpreter.evaluate(code, None).unwrap();
    println!("State after execution: {:?}", interpreter.state);
}

pub fn print_documentation(&self)

Print the documentation for all words.