lox_one 0.1.0

A tree-walking interpreter for the Lox programming language.
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
104

use super::*;

use crate::parser::Parser;
use crate::scanner::Scanner;
use crate::utils::{log_items, read_file};

fn assert_can_parse(title: &str, src: &str, verbose: bool) -> Vec<Stmt> {
    let tokens = Scanner::tokens_from_str(src, verbose);

    let mut parser = Parser::new(tokens);
    let statements = parser.program().unwrap_or_else(|e| {
        println!("{e}");
        panic!()
    });

    statements
}

fn assert_can_parse_file(file_name: &str, verbose: bool) -> Vec<Stmt> {
    let path = format!("examples/{}.lox", file_name);
    let src = read_file(path.as_str());

    assert_can_parse(path.as_str(), src.as_str(), verbose)
}

#[test]
fn parses_expr_stmts() {
    assert_can_parse_file("expr_stmt", false);
}

#[test]
fn can_parse_print_stmt() {
    assert_can_parse_file("print_stmt", false);
}

#[test]
fn can_parse_variables() {
    assert_can_parse_file("variables", false);
}

//     ("assignment", false),
#[test]
fn can_parse_assignment() {
    assert_can_parse_file("assignment", false);
}

//     ("if_stmt", false),
#[test]
fn can_parse_if_stmt() {
    assert_can_parse_file("if_stmt", false);
}

//     ("if_else_stmt", false),
#[test]
fn can_logical_if_else_stmt() {
    assert_can_parse_file("if_else_stmt", false);
}

//     ("logic_and", false),
#[test]
fn can_parse_logical_and_stmt() {
    assert_can_parse_file("logic_and", false);
}

//     ("logic_or", false),
#[test]
fn can_parse_logical_or_stmt() {
    assert_can_parse_file("logic_or", false);
}

//     ("while_stmt", false),
#[test]
fn can_parse_while_stmt() {
    assert_can_parse_file("while_stmt", false);
}

//     ("for_stmt", false),
#[test]
fn can_parse_for_stmt() {
    assert_can_parse_file("for_stmt", false);
}

//     ("continue", false),
#[test]
fn can_parse_continue() {
    assert_can_parse_file("continue", false);
}

// //     ("call_stmt", false),
#[test]
fn can_parse_call_stmt() {
    assert_can_parse_file("call_stmt", false);
}

//     ("fun_decl", false),
#[test]
fn can_parse_fun_decl_stmt() {
    assert_can_parse_file("fun_decl", false);
}

// #[test]
// fn can_parse_error_stmt() {
// assert_can_parse_file("errors", false);
// }