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
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
/* Copyright (C) 2023 Aryadev Chavali
* You may distribute and modify this code under the terms of the
* GPLv2 license. You should have received a copy of the GPLv2
* license with this file. If not, please write to:
* aryadev@aryadevchavali.com.
* Created: 2023-10-24
* Author: Aryadev Chavali
* Description: Parser for assembly language
*/
#include <assert.h>
#include <errno.h>
#include <stdbool.h>
#include <string.h>
#include "./parser.h"
#define OPCODE_ON_TYPE(BASE_CODE, TYPE)
opcode_t get_typed_opcode(opcode_t base_code, data_type_t type)
{
switch (type)
{
case DATA_TYPE_NIL:
// TODO: Parse error (Not something we should pass here)
return 0;
case DATA_TYPE_BYTE:
return base_code;
case DATA_TYPE_HWORD:
return base_code + 1;
case DATA_TYPE_WORD:
return base_code + 2;
default:
// TODO: Parse error (EXPECTED_TYPE_TAG)
return 0;
}
}
data_type_t parse_data_type(const char *cstr, size_t length)
{
if (length >= 4 && strncmp(cstr, "BYTE", 4) == 0)
return DATA_TYPE_BYTE;
else if (length >= 5 && strncmp(cstr, "HWORD", 5) == 0)
return DATA_TYPE_HWORD;
else if (length >= 4 && strncmp(cstr, "WORD", 4) == 0)
return DATA_TYPE_WORD;
else
return DATA_TYPE_NIL;
}
word parse_word(token_t token)
{
assert(token.type == TOKEN_LITERAL_NUMBER);
bool is_negative = token.str_size > 1 && token.str[0] == '-';
word w = 0;
if (is_negative)
{
char *end = NULL;
// TODO: Make a standardised type of the same size as word in
// base.h
int64_t i = strtoll(token.str, &end, 0);
if (!(end && end[0] == '\0'))
// TODO: Parse error (NOT_A_NUMBER)
return 0;
else if (errno == ERANGE)
{
// TODO: Parse error (INTEGER_OVERFLOW)
errno = 0;
return 0;
}
memcpy(&w, &i, sizeof(w));
}
else
{
char *end = NULL;
w = strtoull(token.str, &end, 0);
if (!(end && end[0] == '\0'))
// TODO: Parse error (NOT_A_NUMBER)
return 0;
else if (errno == ERANGE)
{
// TODO: Parse error (WORD_OVERFLOW)
errno = 0;
return 0;
}
}
return w;
}
inst_t parse_next_inst(token_stream_t *stream)
{
token_t token = TOKEN_STREAM_AT(stream->data, stream->used);
if (token.type != TOKEN_SYMBOL)
// TODO Parser Error (EXPECTED_SYMBOL)
return INST_NOOP;
inst_t inst = {0};
char *opcode = token.str;
if (token.str_size >= 4 && strncmp(opcode, "HALT", 4) == 0)
{
inst = INST_HALT;
++stream->used;
}
else if (token.str_size >= 5 && strncmp(opcode, "PUSH.", 5) == 0)
{
data_type_t type = parse_data_type(opcode + 5, token.str_size - 5);
inst.opcode = get_typed_opcode(OP_PUSH_BYTE, type);
if (!OPCODE_IS_TYPE(inst.opcode, OP_PUSH))
// TODO: Parse error (EXPECTED_TYPE_TAG)
return INST_NOOP;
else if (stream->used == stream->available - 1)
// TODO: Parse error (EXPECTED_OPERAND)
return INST_NOOP;
inst.operand =
DWORD(parse_word(TOKEN_STREAM_AT(stream->data, stream->used + 1)));
stream->used += 2;
}
else if (token.str_size >= 4 && strncmp(opcode, "POP.", 4) == 0)
{
data_type_t type = parse_data_type(opcode + 4, token.str_size - 4);
inst.opcode = get_typed_opcode(OP_POP_BYTE, type);
if (!OPCODE_IS_TYPE(inst.opcode, OP_POP))
// TODO: Parse error (EXPECTED_TYPE_TAG)
return INST_NOOP;
++stream->used;
}
else if (token.str_size >= 9 && strncmp(opcode, "PUSH-REG.", 9) == 0)
{
data_type_t type = parse_data_type(opcode + 9, token.str_size - 9);
inst.opcode = get_typed_opcode(OP_PUSH_REGISTER_BYTE, type);
if (!OPCODE_IS_TYPE(inst.opcode, OP_PUSH_REGISTER))
// TODO: Parse error (EXPECTED_TYPE_TAG)
return INST_NOOP;
else if (stream->used == stream->available - 1)
// TODO: Parse error (EXPECTED_OPERAND)
return INST_NOOP;
inst.operand =
DWORD(parse_word(TOKEN_STREAM_AT(stream->data, stream->used + 1)));
stream->used += 2;
}
else if (token.str_size >= 4 && strncmp(opcode, "MOV.", 4) == 0)
{
data_type_t type = parse_data_type(opcode + 4, token.str_size - 4);
inst.opcode = get_typed_opcode(OP_MOV_BYTE, type);
if (!OPCODE_IS_TYPE(inst.opcode, OP_MOV))
// TODO: Parse error (EXPECTED_TYPE_TAG)
return INST_NOOP;
else if (stream->used == stream->available - 1)
// TODO: Parse error (EXPECTED_OPERAND)
return INST_NOOP;
inst.operand =
DWORD(parse_word(TOKEN_STREAM_AT(stream->data, stream->used + 1)));
stream->used += 2;
}
else if (token.str_size >= 4 && strncmp(opcode, "DUP.", 4) == 0)
{
data_type_t type = parse_data_type(opcode + 4, token.str_size - 4);
inst.opcode = get_typed_opcode(OP_DUP_BYTE, type);
if (!OPCODE_IS_TYPE(inst.opcode, OP_DUP))
// TODO: Parse error (EXPECTED_TYPE_TAG)
return INST_NOOP;
else if (stream->used == stream->available - 1)
// TODO: Parse error (EXPECTED_OPERAND)
return INST_NOOP;
inst.operand =
DWORD(parse_word(TOKEN_STREAM_AT(stream->data, stream->used + 1)));
stream->used += 2;
}
else
{
// TODO: Parse error (UNKNOWN_OPCODE)
return INST_NOOP;
}
return inst;
}
inst_t *parse_stream(token_stream_t *stream, size_t *size)
{
darr_t instructions = {0};
darr_init(&instructions, sizeof(inst_t));
while (stream->used < stream->available)
{
inst_t inst = parse_next_inst(stream);
darr_append_bytes(&instructions, (byte *)&inst, sizeof(inst_t));
}
*size = instructions.used / sizeof(inst_t);
return (inst_t *)instructions.data;
}
|
