lox-lang 0.0.3

A Lox language runtime for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

#![deny(clippy::all)]
#![warn(clippy::pedantic)]

//! An implementation of the Lox programming language.
//!
//! ## About Lox
//!
//! Lox is a dynamically typed, interpreted scripting language. It was designed by Bob Nystrom for
//! his book [Crafting Interpreters](http://craftinginterpreters.com).
//!
//! ## About this implementation
//!
//! This library aims to implement Lox faithfully to the quasi-specification laid out in the book,
//! as well as some language extensions suggested as exercises to the reader. It is loosely based
//! off of the book's third part, which is a guide to implementing an interpreter in C.
//!
//! ## Usage
//!
//! Included in this package (and installable via `cargo install lox_lang`) is a small wrapper
//! executable named `loxi`. It is the simplest route to trying out the Lox language.
//!
//! If you want to embed Lox in a larger Rust project, you will need to create an instance of
//! [`VM`](struct.VM.html) and use its [`interpret`](struct.VM.html#method.interpret) method to run
//! your code:
//!
//! ```
//! let mut my_vm = lox_lang::VM::default();
//! my_vm.interpret(r#" print "hello " + "world"; "#).unwrap();
//! ```

use std::{convert::From, error, fmt};

mod compiler;
mod lox_core;
pub mod lox_std;
mod vm;

pub use lox_core::{NativeFun, Value};
pub use vm::VM;

use {
    compiler::{CompileError, CompileErrorType, Compiler, Upvalue},
    lox_core::{Chunk, Class, Fun, Gc, Instance, Op, UpvalueRef},
    vm::RuntimeError,
};

/// Compilation and runtime errors in the Lox VM.
#[derive(Debug)]
pub struct Error {
    inner: Box<dyn error::Error>,
    category: ErrorCategory,
    line: usize,
}

impl Error {
    /// Which type of error was encountered
    pub fn category(&self) -> ErrorCategory {
        self.category
    }

    /// The line in the Lox source code where the error occurred
    pub fn line(&self) -> usize {
        self.line
    }

    fn from_runtime_error(err: RuntimeError, line: Option<usize>) -> Self {
        Self {
            inner: Box::new(err),
            category: ErrorCategory::Runtime,
            line: line.unwrap_or(1),
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.inner)
    }
}

impl error::Error for Error {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        Some(&*self.inner)
    }
}

/// Where in the pipeline an error occurred.
#[derive(Clone, Copy, Debug)]
#[non_exhaustive]
pub enum ErrorCategory {
    Compilation,
    Runtime,
}

impl From<CompileError> for Error {
    fn from(inner: CompileError) -> Self {
        Self {
            line: inner.line,
            inner: Box::new(inner),
            category: ErrorCategory::Compilation,
        }
    }
}