Struct Interpreter 

pub struct Interpreter {
    pub debug_breakpoint_check: Option<DebugBreakpointCheck>,
    pub debug_breakpoint_handler: Option<DebugBreakpointHandler>,
    /* private fields */
}

Pascal interpreter using modular architecture

Fields

debug_breakpoint_check: Option<DebugBreakpointCheck>

debug_breakpoint_handler: Option<DebugBreakpointHandler>

Implementations

impl Interpreter

pub fn new(verbose: bool) -> Self

Create a new interpreter

pub fn current_scope(&self) -> &Scope

Get the current scope for testing purposes

pub fn get_variable_value(&self, name: &str) -> Option<Value>

Get a variable value for testing purposes

pub fn scope_count(&self) -> usize

Number of active scopes (for leak analysis)

pub fn all_scope_variables(&self) -> Vec<(String, Value)>

All variables across all scopes

pub fn load_uses_clause(&mut self, uses: &[String]) -> Result<()>

Load uses clause units (simplified implementation)

pub fn declare_block_vars(&mut self, block: &Block) -> Result<()>

Declare variables in a block

pub fn register_block_types(&mut self, block: &Block) -> Result<()>

Register type declarations (enum constants and generic types) in a block

pub fn register_block_classes(&mut self, block: &Block) -> Result<()>

Register classes in a block

pub fn register_class(&mut self, class_decl: &ClassDecl) -> Result<()>

Register a single class (validates interfaces when registry knows them)

pub fn register_interface(&mut self, iface: InterfaceDecl)

Register an interface declaration

pub fn register_operator_overload(&mut self, overload: OperatorOverload)

Register a user-defined operator overload (the implementation is a function with the given name, already registered in the function table).

pub fn register_block_functions(&mut self, block: &Block) -> Result<()>

Register functions and procedures in a block

pub fn run_program(&mut self, program: &Program) -> Result<()>

Execute a program

pub fn execute_stmt(&mut self, stmt: &Stmt) -> Result<()>

Execute a statement

pub fn eval_expr(&mut self, expr: &Expr) -> Result<Value>

Evaluate an expression

pub fn eval_literal(&mut self, literal: &Literal) -> Result<Value>

Evaluate a literal value

pub fn call_function(&mut self, name: &str, args: &[Value]) -> Result<Value>

Call a built-in or user function

pub fn call_procedure(&mut self, name: &str, args: &[Value]) -> Result<()>

Call a procedure (function that returns Nil)

pub fn execute_block_stmts(&mut self, statements: &[Stmt]) -> Result<()>

Execute multiple statements (for blocks)

pub fn set_debug_mode(&mut self, debug: bool)

Enable debug mode

pub fn set_debug_breakpoint_check(&mut self, callback: DebugBreakpointCheck)

Set debug breakpoint callback

pub fn set_debug_breakpoint_handler(&mut self, handler: DebugBreakpointHandler)

Set debug breakpoint handler