mini-c-parser 0.1.4

minimal C language lexer & parser & executer from scratch
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

use super::Instruction;

use crate::program::variable::VariableData;

use std::cell::RefCell;
use std::rc::Rc;

/// inc 1 to register N
#[derive(Debug)]
pub struct Increment<const REGISTER: usize> {}
impl<const REGISTER: usize> Instruction for Increment<REGISTER> {
    fn execute(&self, program: &mut crate::program::program::Program) {
        let var = program.registers[REGISTER].clone();
        let var = &mut var.borrow_mut().1;
        match var {
            VariableData::Int8(ref mut value) => *value += 1,
            VariableData::UInt8(ref mut value) => *value += 1,
            VariableData::Int16(ref mut value) => *value += 1,
            VariableData::UInt16(ref mut value) => *value += 1,
            VariableData::Int32(ref mut value) => *value += 1,
            VariableData::UInt32(ref mut value) => *value += 1,
            VariableData::Int64(ref mut value) => *value += 1,
            VariableData::UInt64(ref mut value) => *value += 1,
            _ => panic!("Invalid type for increment"),
        }
    }
}

/// dec 1 to register N
#[derive(Debug)]
pub struct Decrement<const REGISTER: usize> {}
impl<const REGISTER: usize> Instruction for Decrement<REGISTER> {
    fn execute(&self, program: &mut crate::program::program::Program) {
        let var = program.registers[REGISTER].clone();
        let var = &mut var.borrow_mut().1;
        match var {
            VariableData::Int8(ref mut value) => *value -= 1,
            VariableData::UInt8(ref mut value) => *value -= 1,
            VariableData::Int16(ref mut value) => *value -= 1,
            VariableData::UInt16(ref mut value) => *value -= 1,
            VariableData::Int32(ref mut value) => *value -= 1,
            VariableData::UInt32(ref mut value) => *value -= 1,
            VariableData::Int64(ref mut value) => *value -= 1,
            VariableData::UInt64(ref mut value) => *value -= 1,
            _ => panic!("Invalid type for decrement"),
        }
    }
}

/// cast register N to type
#[derive(Debug)]
pub struct Cast<const REGISTER_FROM: usize, const REGISTER_TO: usize> {
    pub info: crate::ast::typename::TypeInfo,
}
impl<const REGISTER_FROM: usize, const REGISTER_TO: usize> Instruction
    for Cast<REGISTER_FROM, REGISTER_TO>
{
    fn execute(&self, program: &mut crate::program::program::Program) {
        let casted = program.registers[REGISTER_FROM]
            .borrow()
            .1
            .cast_to(&self.info);
        if let Some(casted) = casted {
            program.registers[REGISTER_TO] = Rc::new(RefCell::new((self.info.clone(), casted)));
        } else {
            panic!("Invalid cast");
        }
    }
}

/// neg register N
#[derive(Debug)]
pub struct Negate<const REGISTER: usize> {}
impl<const REGISTER: usize> Instruction for Negate<REGISTER> {
    fn execute(&self, program: &mut crate::program::program::Program) {
        let var = &mut program.registers[REGISTER].borrow_mut().1;
        match var {
            VariableData::UInt8(ref mut value) => *value = -(*value as i8) as u8,
            VariableData::UInt16(ref mut value) => *value = -(*value as i16) as u16,
            VariableData::UInt32(ref mut value) => *value = -(*value as i32) as u32,
            VariableData::UInt64(ref mut value) => *value = -(*value as i64) as u64,
            VariableData::Int8(ref mut value) => *value = -*value,
            VariableData::Int16(ref mut value) => *value = -*value,
            VariableData::Int32(ref mut value) => *value = -*value,
            VariableData::Int64(ref mut value) => *value = -*value,
            _ => panic!("Invalid type for negate"),
        }
    }
}

/// logical not register N
#[derive(Debug)]
pub struct LogicalNot<const REGISTER: usize> {}
impl<const REGISTER: usize> Instruction for LogicalNot<REGISTER> {
    fn execute(&self, program: &mut crate::program::program::Program) {
        let var = &mut program.registers[REGISTER].borrow_mut().1;
        match var {
            VariableData::UInt8(ref mut value) => *value = if *value == 0 { 1 } else { 0 },
            VariableData::UInt16(ref mut value) => *value = if *value == 0 { 1 } else { 0 },
            VariableData::UInt32(ref mut value) => *value = if *value == 0 { 1 } else { 0 },
            VariableData::UInt64(ref mut value) => *value = if *value == 0 { 1 } else { 0 },
            VariableData::Int8(ref mut value) => *value = if *value == 0 { 1 } else { 0 },
            VariableData::Int16(ref mut value) => *value = if *value == 0 { 1 } else { 0 },
            VariableData::Int32(ref mut value) => *value = if *value == 0 { 1 } else { 0 },
            VariableData::Int64(ref mut value) => *value = if *value == 0 { 1 } else { 0 },
            _ => panic!("Invalid type for logical not"),
        }
    }
}

/// bitwise not register N
#[derive(Debug)]
pub struct BitwiseNot<const REGISTER: usize> {}
impl<const REGISTER: usize> Instruction for BitwiseNot<REGISTER> {
    fn execute(&self, program: &mut crate::program::program::Program) {
        let var = &mut program.registers[REGISTER].borrow_mut().1;
        match var {
            VariableData::UInt8(ref mut value) => *value = !*value,
            VariableData::UInt16(ref mut value) => *value = !*value,
            VariableData::UInt32(ref mut value) => *value = !*value,
            VariableData::UInt64(ref mut value) => *value = !*value,
            VariableData::Int8(ref mut value) => *value = !*value,
            VariableData::Int16(ref mut value) => *value = !*value,
            VariableData::Int32(ref mut value) => *value = !*value,
            VariableData::Int64(ref mut value) => *value = !*value,
            _ => panic!("Invalid type for bitwise not"),
        }
    }
}

/// dereference register N
#[derive(Debug)]
pub struct Dereference<const REGISTER: usize> {}
impl<const REGISTER: usize> Instruction for Dereference<REGISTER> {
    fn execute(&self, program: &mut crate::program::program::Program) {
        let ptr = program.registers[REGISTER].clone().borrow().1.clone();
        if let VariableData::Pointer(val) = ptr {
            program.registers[REGISTER] = val.clone();
        } else {
            panic!("Invalid type for dereference");
        }
    }
}

/// address of variable to register N
#[derive(Debug)]
pub struct AddressOf<const REGISTER: usize> {}
impl<const REGISTER: usize> Instruction for AddressOf<REGISTER> {
    fn execute(&self, program: &mut crate::program::program::Program) {
        let var = program.registers[REGISTER].clone();
        let vartype = var.borrow().0.clone();
        let ptr = Rc::new(RefCell::new((
            crate::ast::typename::TypeInfo::Pointer(Box::new(vartype)),
            VariableData::Pointer(var),
        )));
        program.registers[REGISTER] = ptr;
    }
}