📦 jxtrt / cminus

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//Expressions

value[[IntLiteral: expression -> INT_CONSTANT]] = 
	<pushi > INT_CONSTANT
	
value[[RealLiteral: expression -> REAL_CONSTANT]] = 
	<pushf > expression.value

value[[CharLiteral: expression -> CHAR_CONSTANT]] =
	<pushb > (int) expression.value

address[[Variable: expression -> ID]] =
	if (expression.definition.scope == 0) { //if global
		<pusha > expression.definition.offset
	else {
		<push bp>
		<pushi > expression.definition.offset
		<addi>
	}

value[[Variable: expression -> ID]] =
	address[[expression]]
	<load> expression.type.suffix()
	
value[[Arithmetic: expression1 -> expression2 ('+'|'-'|'*'|'/') expression3]] =
	value[[expression2]]
	expression2.type.convertTo(expression1.type)
	value[[expression3]]
	expression3.type.convertTo(expression1.type)
	switch (expression1.operator) {
		case '+': 
			<add> expression1.type.suffix()
			break
		case '-':
			<sub> expression1.type.suffix()
			break
		case '*':
			<mul> expression1.type.suffix()
			break
		case '/':
			<div> expression1.type.suffix()
			break	
	}
	
value[[UnaryMinus: expression1 -> expression2]] = 
	value[[expression2]]
	<pushi -1>
	<muli>
	
value[[Comparison: expression1 -> expression2 (">"|"<"|">="|"<="|"=="|"!=") expression3]] =
	value[[expression2]]
	expression2.type.promoteTo(expression1.type) //does nothing when real -> int and prints b2i when byte -> int
	value[[expression3]]
	expression3.type.promoteTo(expression1.type)
	
	switch (expression1.operator) {
		case ">":
			<gt> cg.minIntSuffix(expression2.type)
			break
		case "<":
			<lt> cg.minIntSuffix(expression2.type) 
			break
		case ">=":
			<ge> cg.minIntSuffix(expression2.type)
			break
		case "<=":
			<le> cg.minIntSuffix(expression2.type)
			break
		case "==":
			<eq> cg.minIntSuffix(expression2.type)
			break
		case "!=":
			<ne> cg.minIntSuffix(expression2.type)
			break
	}
		
value[[UnaryNot: expression1 -> expression2]] =
	value[[expression2]]
	<not>	

value[[Logical: expression1 -> expression2 ("&&"|"||") expression3]] =
	value[[expression2]]
	value[[expression3]]
	
	switch (expression1.operator) {
		case "&&":
			<and>
			break
		case "||":
			<or>
			break
	}
	
value[[Cast: expression1 -> type expression2]] = 
	value[[expression2]]
	expression2.type.convertTo(expression1.type)


//Statements
execute[[Assignment: statement -> expression1 expression2]] = 
	address[[expression1]]
	value[[expression2]]
	<store > + expression1.type.suffix()

execute[[Write: statement -> expression]] =
	value[[expression]]
	<out > expression.type.suffix()

execute[[Read: statement -> expression]] =
	address[[expression]]
	<in > expression.type.suffix()


//Definitions
execute[[FunctionDefinition: definition -> type ID definition* statement*]] =
	ID <:>
	cg.comment("Parameters")
	for (int i = 0; i < type.parameters.size(); i++) {
		execute[[type.parameters.get(i)]]
	}
	cg.comment("Local variables")
	for (int i = 0; i < definition*.size(); i++) {
		execute[[definition*.get(i)]]
	}
	<enter > definition*.get(definition*.size()-1).offset
	statement*.forEach(statement -> execute[[statement]])

	int variables = definition.localVariables.stream().mapToInt(var -> var.type.numberOfBytes).sum()
	int parameters = type.parameters.stream().mapToInt(parameter -> parameter.type.numberOfBytes).sum()
	if (type.returnType instanceof VoidType) {
		<ret > 0, variables, parameters
	}

execute[[VariableDefinition: definition -> type ID]] =
	cg.comment(type.getSimpleName() + " " + ID + " (offset " + definition.offset+")")

execute[[Program: program -> definition*]] =
	<call main>
	<halt>
	program.definitions.forEach(def -> execute[[def]]);