phoenix-lang 1.5.3

A simple, fast 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

use crate::chunk::{Chunk, ClassChunk, FunctionChunk, Instr, OpCode};
use crate::value::Value;

pub fn disassemble_class_chunk(
    class_chunk: &ClassChunk,
    function_defs: &[FunctionChunk],
    class_defs: &[ClassChunk],
    constants: &[Value],
    identifiers: &[String],
) {
    match class_chunk.superclass {
        Some(i) => eprintln!(
            "== <class {} | subclass of {}> ===============",
            &class_chunk.name, &class_defs[i].name
        ),
        None => eprintln!("== <class {}> ===============", &class_chunk.name),
    }
    for (name, fn_index) in class_chunk.methods.iter() {
        eprintln!(
            "== <method {} | #{}> ============",
            identifiers.get(*name).unwrap(),
            fn_index
        );
        disassemble_chunk(&function_defs[*fn_index].chunk, constants, identifiers);
    }
}

pub fn disassemble_fn_chunk(
    file_name: String,
    index: usize,
    fn_chunk: &FunctionChunk,
    constants: &[Value],
    identifiers: &[String],
) {
    match &fn_chunk.name {
        Some(name) => eprintln!("== <fn {} | #{}> ==============", name, index),
        None => eprintln!("== <{}> ==============", file_name),
    }
    disassemble_chunk(&fn_chunk.chunk, constants, identifiers);
}

fn disassemble_chunk(chunk: &Chunk, constants: &[Value], identifiers: &[String]) {
    eprintln!("---");
    eprintln!("byte\tline\tOpCode");
    let mut last_line_num = 0;
    for (i, instr) in chunk.code.iter().enumerate() {
        let line_marker = if last_line_num == instr.line_num {
            "|".to_string()
        } else {
            instr.line_num.to_string()
        };
        last_line_num = instr.line_num;
        eprint!("{}\t{}", i, line_marker);
        disassemble_instruction(instr, i, constants, identifiers)
    }

    eprintln!("======================\n");
}

pub fn disassemble_instruction(
    instr: &Instr,
    instr_offset: usize,
    constants: &[Value],
    identifiers: &[String],
) {
    match instr.op_code {
        OpCode::OpConstant(index) => eprintln!(
            "\t{:?} => {:?}",
            instr.op_code,
            constants.get(index).unwrap()
        ),
        OpCode::OpDefineGlobal(index)
        | OpCode::OpGetSuper(index)
        | OpCode::OpSetGlobal(index)
        | OpCode::OpGetGlobal(index)
        | OpCode::OpCallGlobal(_, index, _)
        | OpCode::OpGetProperty(index)
        | OpCode::OpSetProperty(index) => eprintln!(
            "\t{:?} => name: {:?}",
            instr.op_code,
            identifiers.get(index).unwrap()
        ),
        OpCode::OpJump(jump_offset) | OpCode::OpJumpIfFalse(jump_offset) => eprintln!(
            "\t{:?} | jump -> {}",
            instr.op_code,
            instr_offset + jump_offset
        ),
        OpCode::OpLoop(neg_offset) => eprintln!(
            "\t{:?} | loop back -> {}",
            instr.op_code,
            instr_offset - neg_offset
        ),
        _ => eprintln!("\t{:?}", instr.op_code),
    }
}