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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

use std::{convert::TryInto, fmt};

use {
    super::{Op, Value},
    crate::CompileErrorType,
};

#[derive(Clone, Debug)]
struct LineRecord {
    line: usize,
    count: usize,
}

#[derive(Clone, Debug)]
pub(crate) struct Chunk {
    name: String,
    pub constants: Vec<Value>,
    pub code: Vec<Op>,
    lines: Vec<LineRecord>,
}

impl Chunk {
    pub fn new<T: ToString>(name: &T) -> Self {
        Self {
            name: name.to_string(),
            constants: Vec::new(),
            code: Vec::new(),
            lines: Vec::new(),
        }
    }

    pub fn write(&mut self, op: Op, line: usize) -> usize {
        self.code.push(op);

        match self.lines.last() {
            None => self.push_line_record(line),
            Some(rec) if rec.line < line => self.push_line_record(line),
            Some(rec) if rec.line == line => {
                // a little weird looking, but seems like the idiomatic way to update an Option's
                // wrapped value in place
                for last in self.lines.last_mut().iter_mut() {
                    last.count += 1;
                }
            }
            _ => unreachable!("Line number stack should not go backward"),
        }

        self.code.len() - 1
    }

    fn push_line_record(&mut self, line: usize) {
        self.lines.push(LineRecord { line, count: 1 });
    }

    /// Adds the value to the Chunk's constant table and returns its index
    pub fn add_constant(&mut self, value: Value) -> usize {
        self.constants.push(value);
        self.constants.len() - 1
    }

    fn disassemble_instruction<W: fmt::Write>(&self, index: usize, f: &mut W) -> fmt::Result {
        write!(f, "{:04} ", index)?;

        let (line, is_first) = self.find_line(index);

        if is_first {
            write!(f, "{:4} ", line)?;
        } else {
            write!(f, "   | ")?;
        }

        self.code[index].disassemble(self, f)
    }

    pub fn find_line(&self, instruction_index: usize) -> (usize, bool) {
        let mut line_num = 1;
        let mut is_first = true;

        let mut idx_counter = 0;
        'outer: for LineRecord { line, count } in &self.lines {
            line_num = *line;
            is_first = true;

            for _ in 0..*count {
                if idx_counter == instruction_index {
                    break 'outer;
                }

                idx_counter += 1;
                is_first = false;
            }
        }

        (line_num, is_first)
    }

    pub fn read_constant(&self, index: usize) -> &Value {
        &self.constants[index]
    }

    pub fn patch_jump(&mut self, index: usize) -> Result<(), CompileErrorType> {
        let distance = self.code.len() - index - 1;

        let distance = match distance.try_into() {
            Err(e) => {
                log::error!("{}", e);
                return Err(CompileErrorType::JumpTooLarge(distance));
            }
            Ok(d) => d,
        };

        match self.code.get_mut(index) {
            Some(Op::Jump(ref mut old)) | Some(Op::JumpIfFalse(ref mut old)) => *old = distance,
            other => unreachable!(
                "attempted to patch jump instruction with wrong index ({:05x} => {:?})",
                index, other,
            ),
        }

        Ok(())
    }
}

impl fmt::Display for Chunk {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        writeln!(f, "== {} ==", self.name)?;

        let mut lines = self.lines.iter();
        let mut line;
        let mut line_count = 0; // immediately hooks into advancement below
        for (idx, op) in self.code.iter().enumerate() {
            write!(f, "{:04} ", idx)?;

            if line_count == 0 {
                // advance
                if let Some(LineRecord { line: l, count: c }) = lines.next() {
                    line = l;
                    line_count = *c;
                } else {
                    unreachable!("Should not run out of lines before running out of instructions.");
                }

                write!(f, "{:4} ", line)?;
            } else {
                write!(f, "   | ")?;
            }

            line_count -= 1;

            op.disassemble(self, f)?;
            writeln!(f)?;
        }
        Ok(())
    }
}

/// A terrible, shameful, but ultimately necessary thing to do
impl fmt::LowerHex for Chunk {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let index = f.width().unwrap_or_default();

        self.disassemble_instruction(index, f)
    }
}