mini-c-parser 0.12.2

minimal C language lexer & parser & virtual 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

use super::Instruction;

use super::operand::*;
use crate::ast::typename::TypeInfo;
use crate::virtualmachine::program::VirtualProgram;
use crate::virtualmachine::variable::VariableData;

/// cast register N to type
#[derive(Debug)]
pub struct Cast {
    pub info: TypeInfo,
    pub operand_from: Operand,
    pub operand_to: Operand,
}
impl Instruction for Cast {
    fn execute(&self, program: &mut VirtualProgram) {
        let rhs_casted = get_operand_value(program, &self.operand_from)
            .cast_to(&self.info)
            .expect(format!("Invalid cast: to {:?}", &self.info).as_str());
        *get_operand_value_mut(program, &self.operand_to) = rhs_casted;
    }
}

/// neg register N
#[derive(Debug)]
pub struct Negate {
    pub operand: Operand,
}
impl Instruction for Negate {
    fn execute(&self, program: &mut VirtualProgram) {
        let var = get_operand_value_mut(program, &self.operand);
        let res = match &var {
            VariableData::UInt8(value) => VariableData::Int8(-(*value as i8)),
            VariableData::UInt16(value) => VariableData::Int16(-(*value as i16)),
            VariableData::UInt32(value) => VariableData::Int32(-(*value as i32)),
            VariableData::UInt64(value) => VariableData::Int64(-(*value as i64)),
            VariableData::Int8(value) => VariableData::Int8(-*value),
            VariableData::Int16(value) => VariableData::Int16(-*value),
            VariableData::Int32(value) => VariableData::Int32(-*value),
            VariableData::Int64(value) => VariableData::Int64(-*value),
            VariableData::Float32(value) => VariableData::Float32(-*value),
            VariableData::Float64(value) => VariableData::Float64(-*value),
            _ => panic!("Invalid type for negate"),
        };
        *var = res;
    }
}

/// logical not register N
#[derive(Debug)]
pub struct LogicalNot {
    pub operand: Operand,
}
impl Instruction for LogicalNot {
    fn execute(&self, program: &mut VirtualProgram) {
        let var = get_operand_value_mut(program, &self.operand);
        let res = match &var {
            VariableData::UInt8(value) => {
                if *value == 0 {
                    1
                } else {
                    0
                }
            }
            VariableData::UInt16(value) => {
                if *value == 0 {
                    1
                } else {
                    0
                }
            }
            VariableData::UInt32(value) => {
                if *value == 0 {
                    1
                } else {
                    0
                }
            }
            VariableData::UInt64(value) => {
                if *value == 0 {
                    1
                } else {
                    0
                }
            }
            VariableData::Int8(value) => {
                if *value == 0 {
                    1
                } else {
                    0
                }
            }
            VariableData::Int16(value) => {
                if *value == 0 {
                    1
                } else {
                    0
                }
            }
            VariableData::Int32(value) => {
                if *value == 0 {
                    1
                } else {
                    0
                }
            }
            VariableData::Int64(value) => {
                if *value == 0 {
                    1
                } else {
                    0
                }
            }
            _ => panic!("Invalid type for logical not"),
        };
        *var = VariableData::UInt8(res as u8);
    }
}

/// bitwise not register N
#[derive(Debug)]
pub struct BitwiseNot {
    pub operand: Operand,
}
impl Instruction for BitwiseNot {
    fn execute(&self, program: &mut VirtualProgram) {
        let var = get_operand_value_mut(program, &self.operand);
        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"),
        }
    }
}