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
|
#include "lexer-stack.h"
#include <stdlib.h>
#include <assert.h>
#include <err.h>
void
varbuf_begin(struct varbuf *var)
{
assert(var);
var->offset = var->buf.written;
assert(var->offset <= var->buf.mem.len);
}
void
varbuf_reset(struct varbuf *var)
{
assert(var);
var->offset = var->buf.written = 0;
}
void
varbuf_remove_last(struct varbuf *var)
{
assert(var);
assert(var->buf.written >= var->offset);
const size_t size = var->buf.written - var->offset;
assert(var->buf.written >= size);
var->buf.written -= size;
assert(var->buf.written <= var->buf.mem.len);
}
static void
stack_check_type(const struct stack *stack, const enum stack_type type)
{
assert(stack);
if (stack->type == type)
return;
const char *got = (type == STACK_STR ? "str" : "num"), *expected = (stack->type == STACK_STR ? "str" : "num");
errx(EXIT_FAILURE, "tried to get '%s' from stack, but the last pushed type was '%s'", got, expected);
}
void
stack_num(struct stack *stack, const uint8_t base)
{
assert(stack);
membuf_terminate(&stack->var.buf, (char[]){ 0 }, 1);
const char *str = (char*)stack->var.buf.mem.data + stack->var.offset;
stack->type = STACK_NUM;
stack->num = strtoll(str, NULL, base);
varbuf_remove_last(&stack->var);
}
const struct fspec_mem*
stack_get_str(const struct stack *stack)
{
stack_check_type(stack, STACK_STR);
return &stack->str;
}
uint64_t
stack_get_num(const struct stack *stack)
{
stack_check_type(stack, STACK_NUM);
return stack->num;
}
%%{
machine fspec_stack;
action stack_oct {
stack_num(&stack, 8);
}
action stack_hex {
stack_num(&stack, 16);
}
action stack_dec {
stack_num(&stack, 10);
}
action stack_str {
membuf_terminate(&stack.var.buf, (char[]){ 0 }, 1);
stack.type = STACK_STR;
stack.str = stack.var.buf.mem;
stack.str.len = stack.var.buf.written;
}
action store_esc_num {
const fspec_num v = stack_get_num(&stack);
assert(v <= 255);
membuf_append(&stack.var.buf, (uint8_t[]){ v }, sizeof(uint8_t));
}
action store_esc {
const struct { const char e, v; } map[] = {
{ .e = 'a', .v = '\a' },
{ .e = 'b', .v = '\b' },
{ .e = 'f', .v = '\f' },
{ .e = 'n', .v = '\n' },
{ .e = 'r', .v = '\r' },
{ .e = 't', .v = '\t' },
{ .e = 'v', .v = '\v' },
{ .e = '\\', .v = '\\' },
{ .e = '\'', .v = '\'' },
{ .e = '\"', .v = '"' },
{ .e = 'e', .v = 0x1B },
};
for (size_t i = 0; i < sizeof(map) / sizeof(map[0]); ++i) {
if (fc != map[i].e)
continue;
membuf_append(&stack.var.buf, &map[i].v, sizeof(map[i].v));
break;
}
}
action store {
membuf_append(&stack.var.buf, fpc, 1);
}
action begin_num {
varbuf_begin(&stack.var);
}
action begin_str {
varbuf_reset(&stack.var);
}
quote = ['"];
esc = [abfnrtv\\'"e];
esc_chr = '\\';
esc_hex = 'x' <: xdigit{2};
hex = '0x' <: xdigit{1,};
oct = [0-7]{1,3};
dec = [\-+]? <: (([1-9] <: digit*) | '0');
name = ((alpha | '_') <: (alnum | '_')*);
stack_name = name >begin_str $store %stack_str;
stack_hex = hex >begin_num $store %stack_hex;
stack_dec = dec >begin_num $store %stack_dec;
stack_oct = oct >begin_num $store %stack_oct;
stack_esc_hex = esc_hex >begin_num <>*store %stack_hex;
stack_esc = esc_chr <: ((stack_esc_hex | stack_oct) %store_esc_num | esc %~store_esc);
stack_str = quote <: ((stack_esc? <: print? $store) - zlen)* >begin_str %stack_str :>> quote;
stack_num = stack_dec | stack_hex;
}%%
|
