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
|
#include "minias.h"
/* Maintain a direct mapped cache of Parsev*. */
static const Parsev *internparsev(Parsev *p) {
/* An extremely simple direct mapped cache of *Parsev,
It relies on direct pointer comparison, which
itself only works because our pointers are interned. */
size_t idx;
const Parsev *interned;
static const Parsev *cache[4096] = {0};
idx = murmurhash64a((char *)p, sizeof(Parsev)) % sizeof(cache) /
sizeof(cache[0]);
interned = cache[idx];
if (interned && memcmp(p, interned, sizeof(Parsev)) == 0)
return interned;
interned = (const Parsev *)xmemdup((char *)p, sizeof(Parsev));
cache[idx] = interned;
return interned;
}
/* Maintain a direct map cache of strings. */
const char *internstring(const char *s) {
size_t idx, len;
const char *interned;
static const char *cache[4096] = {0};
len = strlen(s);
idx = murmurhash64a(s, len) % sizeof(cache) / sizeof(cache[0]);
interned = cache[idx];
if (interned && strcmp(s, cache[idx]) == 0)
return interned;
interned = xstrdup(s);
cache[idx] = interned;
return interned;
}
static String decodestring(char *s) {
int i;
char *end;
size_t len = 0;
size_t cap = 0;
uint8_t *data = NULL;
uint8_t c = 0;
/* The string is already validated by the parser so we omit some checks*/
while (*s) {
if (*s == '\\') {
s++;
if (*s >= '0' && *s <= '7') {
c = strtoul(s, &end, 8);
s += 3;
} else if (*s == 'x') {
s++;
c = strtoul(s, &end, 16);
s = end;
} else if (*s == 'r') {
c = '\r';
} else if (*s == 'n') {
c = '\n';
} else if (*s == 't') {
c = '\t';
} else {
unreachable();
}
} else {
c = *s;
s++;
}
if (len == cap) {
cap = cap ? len * 2 : 8;
data = realloc(data, cap);
}
data[len++] = c;
}
return (String){.kind = ASM_STRING, .len = len, .data = data};
}
#define INSTR1(V, A1) \
(Parsev) { \
.instr = (Instr) { \
.kind = 0, .variant = V, .arg1 = internparsev(&A1), .arg2 = NULL, \
.arg3 = NULL \
} \
}
#define INSTR2(V, A1, A2) \
(Parsev) { \
.instr = (Instr) { \
.kind = 0, .variant = V, .arg1 = internparsev(&A1), \
.arg2 = internparsev(&A2), .arg3 = NULL \
} \
}
#define INSTR3(V, A1, A2, A3) \
(Parsev) { \
.instr = (Instr) { \
.kind = 0, .variant = V, .arg1 = internparsev(&A1), \
.arg2 = internparsev(&A2), .arg3 = internparsev(&A3) \
} \
}
#define REG(K) \
(Parsev) { .kind = K }
#define YYSTYPE Parsev
#define YY_CTX_LOCAL
#define YY_CTX_MEMBERS Parsev v;
#include "asm.peg.inc"
AsmLine *parse(void) {
AsmLine *result, *l, *prevl;
yycontext ctx;
memset(&ctx, 0, sizeof(yycontext));
prevl = NULL;
curlineno = 0;
while (yyparse(&ctx)) {
curlineno += 1;
if (ctx.v.kind == ASM_SYNTAX_ERROR)
lfatal("syntax error\n");
l = zalloc(sizeof(AsmLine));
l->v = ctx.v;
if (prevl)
prevl->next = l;
else
result = l;
prevl = l;
}
return result;
}
|
