Blame


1 fb1a36c0 2022-01-09 op /*
2 fb1a36c0 2022-01-09 op * Copyright (c) 2021 Omar Polo <op@omarpolo.com>
3 fb1a36c0 2022-01-09 op *
4 fb1a36c0 2022-01-09 op * Permission to use, copy, modify, and distribute this software for any
5 fb1a36c0 2022-01-09 op * purpose with or without fee is hereby granted, provided that the above
6 fb1a36c0 2022-01-09 op * copyright notice and this permission notice appear in all copies.
7 fb1a36c0 2022-01-09 op *
8 fb1a36c0 2022-01-09 op * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 fb1a36c0 2022-01-09 op * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 fb1a36c0 2022-01-09 op * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 fb1a36c0 2022-01-09 op * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 fb1a36c0 2022-01-09 op * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 fb1a36c0 2022-01-09 op * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 fb1a36c0 2022-01-09 op * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15 fb1a36c0 2022-01-09 op */
16 fb1a36c0 2022-01-09 op
17 fb1a36c0 2022-01-09 op #include <sys/queue.h>
18 fb1a36c0 2022-01-09 op #include <sys/socket.h>
19 fb1a36c0 2022-01-09 op #include <sys/stat.h>
20 fb1a36c0 2022-01-09 op #include <sys/wait.h>
21 fb1a36c0 2022-01-09 op
22 fb1a36c0 2022-01-09 op #include <assert.h>
23 fb1a36c0 2022-01-09 op #include <endian.h>
24 fb1a36c0 2022-01-09 op #include <err.h>
25 fb1a36c0 2022-01-09 op #include <errno.h>
26 fb1a36c0 2022-01-09 op #include <event.h>
27 fb1a36c0 2022-01-09 op #include <fcntl.h>
28 fb1a36c0 2022-01-09 op #include <inttypes.h>
29 fb1a36c0 2022-01-09 op #include <poll.h>
30 fb1a36c0 2022-01-09 op #include <pwd.h>
31 fb1a36c0 2022-01-09 op #include <regex.h>
32 fb1a36c0 2022-01-09 op #include <signal.h>
33 fb1a36c0 2022-01-09 op #include <stdio.h>
34 fb1a36c0 2022-01-09 op #include <stdlib.h>
35 fb1a36c0 2022-01-09 op #include <string.h>
36 fb1a36c0 2022-01-09 op #include <syslog.h>
37 fb1a36c0 2022-01-09 op #include <unistd.h>
38 fb1a36c0 2022-01-09 op
39 fb1a36c0 2022-01-09 op #include "client.h"
40 fb1a36c0 2022-01-09 op #include "kami.h"
41 fb1a36c0 2022-01-09 op #include "kamid.h"
42 fb1a36c0 2022-01-09 op #include "log.h"
43 fb1a36c0 2022-01-09 op #include "script.h"
44 fb1a36c0 2022-01-09 op #include "utils.h"
45 fb1a36c0 2022-01-09 op
46 fb1a36c0 2022-01-09 op #define DEBUG 0
47 fb1a36c0 2022-01-09 op
48 fb1a36c0 2022-01-09 op #ifndef INFTIM
49 fb1a36c0 2022-01-09 op #define INFTIM -1
50 fb1a36c0 2022-01-09 op #endif
51 fb1a36c0 2022-01-09 op
52 fb1a36c0 2022-01-09 op static const char *argv0;
53 fb1a36c0 2022-01-09 op
54 fb1a36c0 2022-01-09 op static uint8_t *lastmsg;
55 fb1a36c0 2022-01-09 op
56 fb1a36c0 2022-01-09 op static struct imsgbuf ibuf;
57 fb1a36c0 2022-01-09 op static int ibuf_inuse;
58 fb1a36c0 2022-01-09 op static int child_out = -1;
59 fb1a36c0 2022-01-09 op
60 fb1a36c0 2022-01-09 op static struct procs procs = TAILQ_HEAD_INITIALIZER(procs);
61 fb1a36c0 2022-01-09 op static struct tests tests = TAILQ_HEAD_INITIALIZER(tests);
62 fb1a36c0 2022-01-09 op
63 fb1a36c0 2022-01-09 op static int ntests;
64 fb1a36c0 2022-01-09 op
65 fb1a36c0 2022-01-09 op static struct opstacks blocks = TAILQ_HEAD_INITIALIZER(blocks);
66 fb1a36c0 2022-01-09 op static struct opstacks args = TAILQ_HEAD_INITIALIZER(args);
67 fb1a36c0 2022-01-09 op
68 fb1a36c0 2022-01-09 op #define STACK_HEIGHT 64
69 fb1a36c0 2022-01-09 op static struct value vstack[STACK_HEIGHT];
70 fb1a36c0 2022-01-09 op static int stackh;
71 fb1a36c0 2022-01-09 op
72 fb1a36c0 2022-01-09 op static struct envs envs = TAILQ_HEAD_INITIALIZER(envs);
73 fb1a36c0 2022-01-09 op
74 fb1a36c0 2022-01-09 op static struct value v_false = {.type = V_NUM, .v = {.num = 0}};
75 fb1a36c0 2022-01-09 op static struct value v_true = {.type = V_NUM, .v = {.num = 1}};
76 fb1a36c0 2022-01-09 op
77 fb1a36c0 2022-01-09 op static uint8_t lasttag;
78 fb1a36c0 2022-01-09 op
79 fb1a36c0 2022-01-09 op static int debug;
80 fb1a36c0 2022-01-09 op static int syntaxcheck;
81 fb1a36c0 2022-01-09 op
82 fb1a36c0 2022-01-09 op static const char *filler;
83 fb1a36c0 2022-01-09 op
84 fb1a36c0 2022-01-09 op static inline void
85 fb1a36c0 2022-01-09 op before_printing(void)
86 fb1a36c0 2022-01-09 op {
87 fb1a36c0 2022-01-09 op if (filler != NULL) {
88 fb1a36c0 2022-01-09 op printf("%s", filler);
89 fb1a36c0 2022-01-09 op filler = NULL;
90 fb1a36c0 2022-01-09 op }
91 fb1a36c0 2022-01-09 op }
92 fb1a36c0 2022-01-09 op
93 fb1a36c0 2022-01-09 op static inline void
94 fb1a36c0 2022-01-09 op check_for_output(void)
95 fb1a36c0 2022-01-09 op {
96 fb1a36c0 2022-01-09 op static char buf[BUFSIZ];
97 fb1a36c0 2022-01-09 op struct pollfd pfd;
98 fb1a36c0 2022-01-09 op ssize_t r;
99 fb1a36c0 2022-01-09 op
100 fb1a36c0 2022-01-09 op pfd.fd = child_out;
101 fb1a36c0 2022-01-09 op pfd.events = POLLIN;
102 fb1a36c0 2022-01-09 op if (poll(&pfd, 1, 0) == -1)
103 fb1a36c0 2022-01-09 op fatal("poll");
104 fb1a36c0 2022-01-09 op
105 fb1a36c0 2022-01-09 op if (!(pfd.revents & POLLIN))
106 fb1a36c0 2022-01-09 op return;
107 fb1a36c0 2022-01-09 op
108 fb1a36c0 2022-01-09 op for (;;) {
109 fb1a36c0 2022-01-09 op if ((r = read(child_out, buf, sizeof(buf))) == -1) {
110 fb1a36c0 2022-01-09 op if (errno == EAGAIN)
111 fb1a36c0 2022-01-09 op break;
112 fb1a36c0 2022-01-09 op fatal("read");
113 fb1a36c0 2022-01-09 op }
114 fb1a36c0 2022-01-09 op if (r == 0)
115 fb1a36c0 2022-01-09 op break;
116 fb1a36c0 2022-01-09 op before_printing();
117 fb1a36c0 2022-01-09 op fwrite(buf, 1, r, stdout);
118 fb1a36c0 2022-01-09 op }
119 fb1a36c0 2022-01-09 op }
120 fb1a36c0 2022-01-09 op
121 fb1a36c0 2022-01-09 op static inline void
122 fb1a36c0 2022-01-09 op peekn(int depth, struct value *v)
123 fb1a36c0 2022-01-09 op {
124 fb1a36c0 2022-01-09 op if (depth > stackh)
125 fb1a36c0 2022-01-09 op errx(1, "can't peek the stack at %d: underflow",
126 fb1a36c0 2022-01-09 op depth);
127 fb1a36c0 2022-01-09 op memcpy(v, &vstack[stackh - depth], sizeof(*v));
128 fb1a36c0 2022-01-09 op
129 fb1a36c0 2022-01-09 op #if DEBUG
130 fb1a36c0 2022-01-09 op printf("peeking(%d) ", depth); pp_val(v); printf("\n");
131 fb1a36c0 2022-01-09 op #endif
132 fb1a36c0 2022-01-09 op }
133 fb1a36c0 2022-01-09 op
134 fb1a36c0 2022-01-09 op static inline void
135 fb1a36c0 2022-01-09 op popv(struct value *v)
136 fb1a36c0 2022-01-09 op {
137 fb1a36c0 2022-01-09 op if (stackh == 0)
138 fb1a36c0 2022-01-09 op errx(1, "can't pop the stack: underflow");
139 fb1a36c0 2022-01-09 op memcpy(v, &vstack[--stackh], sizeof(*v));
140 fb1a36c0 2022-01-09 op
141 fb1a36c0 2022-01-09 op #if DEBUG
142 fb1a36c0 2022-01-09 op printf("popping "); pp_val(v); printf("\n");
143 fb1a36c0 2022-01-09 op #endif
144 fb1a36c0 2022-01-09 op }
145 fb1a36c0 2022-01-09 op
146 fb1a36c0 2022-01-09 op static inline void
147 fb1a36c0 2022-01-09 op popvn(int n)
148 fb1a36c0 2022-01-09 op {
149 fb1a36c0 2022-01-09 op struct value v;
150 fb1a36c0 2022-01-09 op
151 fb1a36c0 2022-01-09 op while (n-- > 0)
152 fb1a36c0 2022-01-09 op popv(&v);
153 fb1a36c0 2022-01-09 op }
154 fb1a36c0 2022-01-09 op
155 fb1a36c0 2022-01-09 op static inline void
156 fb1a36c0 2022-01-09 op pushv(struct value *v)
157 fb1a36c0 2022-01-09 op {
158 fb1a36c0 2022-01-09 op if (stackh == STACK_HEIGHT)
159 fb1a36c0 2022-01-09 op errx(1, "can't push the stack: overflow");
160 fb1a36c0 2022-01-09 op
161 fb1a36c0 2022-01-09 op #if DEBUG
162 fb1a36c0 2022-01-09 op printf("pushing "); pp_val(v); printf("\n");
163 fb1a36c0 2022-01-09 op #endif
164 fb1a36c0 2022-01-09 op
165 fb1a36c0 2022-01-09 op memcpy(&vstack[stackh++], v, sizeof(*v));
166 fb1a36c0 2022-01-09 op }
167 fb1a36c0 2022-01-09 op
168 fb1a36c0 2022-01-09 op static inline void
169 fb1a36c0 2022-01-09 op pushbool(int n)
170 fb1a36c0 2022-01-09 op {
171 fb1a36c0 2022-01-09 op pushv(n ? &v_true : &v_false);
172 fb1a36c0 2022-01-09 op }
173 fb1a36c0 2022-01-09 op
174 fb1a36c0 2022-01-09 op static inline void
175 fb1a36c0 2022-01-09 op pushnum(int64_t n)
176 fb1a36c0 2022-01-09 op {
177 fb1a36c0 2022-01-09 op struct value v;
178 fb1a36c0 2022-01-09 op
179 fb1a36c0 2022-01-09 op v.type = V_NUM;
180 fb1a36c0 2022-01-09 op v.v.num = n;
181 fb1a36c0 2022-01-09 op pushv(&v);
182 fb1a36c0 2022-01-09 op }
183 fb1a36c0 2022-01-09 op
184 fb1a36c0 2022-01-09 op static inline struct opstack *
185 fb1a36c0 2022-01-09 op pushstack(struct opstacks *stack)
186 fb1a36c0 2022-01-09 op {
187 fb1a36c0 2022-01-09 op struct opstack *ops;
188 fb1a36c0 2022-01-09 op
189 fb1a36c0 2022-01-09 op ops = xcalloc(1, sizeof(*ops));
190 fb1a36c0 2022-01-09 op TAILQ_INSERT_HEAD(stack, ops, entry);
191 fb1a36c0 2022-01-09 op return ops;
192 fb1a36c0 2022-01-09 op }
193 fb1a36c0 2022-01-09 op
194 fb1a36c0 2022-01-09 op static inline struct opstack *
195 fb1a36c0 2022-01-09 op peek(struct opstacks *stack)
196 fb1a36c0 2022-01-09 op {
197 fb1a36c0 2022-01-09 op if (TAILQ_EMPTY(stack))
198 fb1a36c0 2022-01-09 op errx(1, "%s: args underflow", __func__);
199 fb1a36c0 2022-01-09 op
200 fb1a36c0 2022-01-09 op return TAILQ_FIRST(stack);
201 fb1a36c0 2022-01-09 op }
202 fb1a36c0 2022-01-09 op
203 fb1a36c0 2022-01-09 op static inline struct op *
204 fb1a36c0 2022-01-09 op finalize(struct opstacks *stack, int *argc)
205 fb1a36c0 2022-01-09 op {
206 fb1a36c0 2022-01-09 op struct opstack *ops;
207 fb1a36c0 2022-01-09 op struct op *op;
208 fb1a36c0 2022-01-09 op
209 fb1a36c0 2022-01-09 op if (TAILQ_EMPTY(stack))
210 fb1a36c0 2022-01-09 op errx(1, "%s: args underflow", __func__);
211 fb1a36c0 2022-01-09 op
212 fb1a36c0 2022-01-09 op ops = peek(stack);
213 fb1a36c0 2022-01-09 op TAILQ_REMOVE(&args, ops, entry);
214 fb1a36c0 2022-01-09 op op = ops->base.next;
215 fb1a36c0 2022-01-09 op
216 fb1a36c0 2022-01-09 op if (argc != NULL)
217 fb1a36c0 2022-01-09 op *argc = ops->counter;
218 fb1a36c0 2022-01-09 op
219 fb1a36c0 2022-01-09 op free(ops);
220 fb1a36c0 2022-01-09 op return op;
221 fb1a36c0 2022-01-09 op }
222 fb1a36c0 2022-01-09 op
223 fb1a36c0 2022-01-09 op static inline void
224 fb1a36c0 2022-01-09 op push(struct opstacks *stack, struct op *op)
225 fb1a36c0 2022-01-09 op {
226 fb1a36c0 2022-01-09 op struct opstack *ops;
227 fb1a36c0 2022-01-09 op
228 fb1a36c0 2022-01-09 op ops = peek(stack);
229 fb1a36c0 2022-01-09 op if (ops->last == NULL) {
230 fb1a36c0 2022-01-09 op ops->base.next = op;
231 fb1a36c0 2022-01-09 op ops->last = op;
232 fb1a36c0 2022-01-09 op } else {
233 fb1a36c0 2022-01-09 op ops->last->next = op;
234 fb1a36c0 2022-01-09 op ops->last = op;
235 fb1a36c0 2022-01-09 op }
236 fb1a36c0 2022-01-09 op
237 fb1a36c0 2022-01-09 op ops->counter++;
238 fb1a36c0 2022-01-09 op }
239 fb1a36c0 2022-01-09 op
240 fb1a36c0 2022-01-09 op static inline void
241 fb1a36c0 2022-01-09 op pushenv(void)
242 fb1a36c0 2022-01-09 op {
243 fb1a36c0 2022-01-09 op struct env *e;
244 fb1a36c0 2022-01-09 op
245 fb1a36c0 2022-01-09 op e = xcalloc(1, sizeof(*e));
246 fb1a36c0 2022-01-09 op TAILQ_INSERT_HEAD(&envs, e, entry);
247 fb1a36c0 2022-01-09 op }
248 fb1a36c0 2022-01-09 op
249 fb1a36c0 2022-01-09 op static inline struct env *
250 fb1a36c0 2022-01-09 op currentenv(void)
251 fb1a36c0 2022-01-09 op {
252 fb1a36c0 2022-01-09 op assert(!TAILQ_EMPTY(&envs));
253 fb1a36c0 2022-01-09 op return TAILQ_FIRST(&envs);
254 fb1a36c0 2022-01-09 op }
255 fb1a36c0 2022-01-09 op
256 fb1a36c0 2022-01-09 op static void
257 fb1a36c0 2022-01-09 op popenv(void)
258 fb1a36c0 2022-01-09 op {
259 fb1a36c0 2022-01-09 op struct env *e;
260 fb1a36c0 2022-01-09 op struct binding *b, *tb;
261 fb1a36c0 2022-01-09 op
262 fb1a36c0 2022-01-09 op e = currentenv();
263 fb1a36c0 2022-01-09 op TAILQ_REMOVE(&envs, e, entry);
264 fb1a36c0 2022-01-09 op
265 fb1a36c0 2022-01-09 op TAILQ_FOREACH_SAFE(b, &e->bindings, entry, tb)
266 fb1a36c0 2022-01-09 op free(b);
267 fb1a36c0 2022-01-09 op
268 fb1a36c0 2022-01-09 op free(e);
269 fb1a36c0 2022-01-09 op }
270 fb1a36c0 2022-01-09 op
271 fb1a36c0 2022-01-09 op static inline int
272 fb1a36c0 2022-01-09 op setvar(char *sym, struct op *op)
273 fb1a36c0 2022-01-09 op {
274 fb1a36c0 2022-01-09 op struct binding *b;
275 fb1a36c0 2022-01-09 op struct env *e;
276 fb1a36c0 2022-01-09 op int ret, height;
277 fb1a36c0 2022-01-09 op
278 fb1a36c0 2022-01-09 op height = stackh;
279 fb1a36c0 2022-01-09 op if ((ret = eval(op)) != EVAL_OK)
280 fb1a36c0 2022-01-09 op return ret;
281 fb1a36c0 2022-01-09 op
282 fb1a36c0 2022-01-09 op if (stackh != height + 1) {
283 fb1a36c0 2022-01-09 op before_printing();
284 fb1a36c0 2022-01-09 op printf("trying to assign to `%s' a void value: ", sym);
285 fb1a36c0 2022-01-09 op pp_op(op);
286 fb1a36c0 2022-01-09 op printf("\n");
287 fb1a36c0 2022-01-09 op return EVAL_ERR;
288 fb1a36c0 2022-01-09 op }
289 fb1a36c0 2022-01-09 op
290 fb1a36c0 2022-01-09 op b = xcalloc(1, sizeof(*b));
291 fb1a36c0 2022-01-09 op b->name = sym;
292 fb1a36c0 2022-01-09 op popv(&b->val);
293 fb1a36c0 2022-01-09 op
294 fb1a36c0 2022-01-09 op e = TAILQ_FIRST(&envs);
295 fb1a36c0 2022-01-09 op TAILQ_INSERT_HEAD(&e->bindings, b, entry);
296 fb1a36c0 2022-01-09 op
297 fb1a36c0 2022-01-09 op return EVAL_OK;
298 fb1a36c0 2022-01-09 op }
299 fb1a36c0 2022-01-09 op
300 fb1a36c0 2022-01-09 op static inline void
301 fb1a36c0 2022-01-09 op setvar_raw(char *sym, struct op *op)
302 fb1a36c0 2022-01-09 op {
303 fb1a36c0 2022-01-09 op struct binding *b;
304 fb1a36c0 2022-01-09 op struct env *e;
305 fb1a36c0 2022-01-09 op
306 fb1a36c0 2022-01-09 op b = xcalloc(1, sizeof(*b));
307 fb1a36c0 2022-01-09 op b->name = sym;
308 fb1a36c0 2022-01-09 op b->raw = op;
309 fb1a36c0 2022-01-09 op
310 fb1a36c0 2022-01-09 op e = TAILQ_FIRST(&envs);
311 fb1a36c0 2022-01-09 op TAILQ_INSERT_HEAD(&e->bindings, b, entry);
312 fb1a36c0 2022-01-09 op }
313 fb1a36c0 2022-01-09 op
314 fb1a36c0 2022-01-09 op static inline int
315 fb1a36c0 2022-01-09 op getvar(const char *sym, struct value *v)
316 fb1a36c0 2022-01-09 op {
317 fb1a36c0 2022-01-09 op struct env *e;
318 fb1a36c0 2022-01-09 op struct binding *b;
319 fb1a36c0 2022-01-09 op
320 fb1a36c0 2022-01-09 op TAILQ_FOREACH(e, &envs, entry) {
321 fb1a36c0 2022-01-09 op TAILQ_FOREACH(b, &e->bindings, entry) {
322 fb1a36c0 2022-01-09 op if (!strcmp(sym, b->name)) {
323 fb1a36c0 2022-01-09 op memcpy(v, &b->val, sizeof(*v));
324 fb1a36c0 2022-01-09 op return EVAL_OK;
325 fb1a36c0 2022-01-09 op }
326 fb1a36c0 2022-01-09 op }
327 fb1a36c0 2022-01-09 op }
328 fb1a36c0 2022-01-09 op
329 fb1a36c0 2022-01-09 op before_printing();
330 fb1a36c0 2022-01-09 op fprintf(stderr, "unbound variable %s\n", sym);
331 fb1a36c0 2022-01-09 op return EVAL_ERR;
332 fb1a36c0 2022-01-09 op }
333 fb1a36c0 2022-01-09 op
334 fb1a36c0 2022-01-09 op static inline int
335 fb1a36c0 2022-01-09 op getvar_raw(const char *sym, struct op **raw)
336 fb1a36c0 2022-01-09 op {
337 fb1a36c0 2022-01-09 op struct env *e;
338 fb1a36c0 2022-01-09 op struct binding *b;
339 fb1a36c0 2022-01-09 op
340 fb1a36c0 2022-01-09 op TAILQ_FOREACH(e, &envs, entry) {
341 fb1a36c0 2022-01-09 op TAILQ_FOREACH(b, &e->bindings, entry) {
342 fb1a36c0 2022-01-09 op if (!strcmp(sym, b->name)) {
343 fb1a36c0 2022-01-09 op *raw = b->raw;
344 fb1a36c0 2022-01-09 op return EVAL_OK;
345 fb1a36c0 2022-01-09 op }
346 fb1a36c0 2022-01-09 op }
347 fb1a36c0 2022-01-09 op }
348 fb1a36c0 2022-01-09 op
349 fb1a36c0 2022-01-09 op return EVAL_ERR;
350 fb1a36c0 2022-01-09 op }
351 fb1a36c0 2022-01-09 op
352 fb1a36c0 2022-01-09 op int
353 fb1a36c0 2022-01-09 op global_set(char *sym, struct op *op)
354 fb1a36c0 2022-01-09 op {
355 fb1a36c0 2022-01-09 op struct binding *b;
356 fb1a36c0 2022-01-09 op struct env *e;
357 fb1a36c0 2022-01-09 op
358 fb1a36c0 2022-01-09 op /* TODO: check for duplicates */
359 fb1a36c0 2022-01-09 op
360 fb1a36c0 2022-01-09 op if (op->type != OP_LITERAL &&
361 fb1a36c0 2022-01-09 op (op->type == OP_CAST && op->v.cast.expr->type != OP_LITERAL))
362 fb1a36c0 2022-01-09 op return 0;
363 fb1a36c0 2022-01-09 op
364 fb1a36c0 2022-01-09 op b = xcalloc(1, sizeof(*b));
365 fb1a36c0 2022-01-09 op b->name = sym;
366 fb1a36c0 2022-01-09 op
367 fb1a36c0 2022-01-09 op /* it's only a cast on a literal! */
368 fb1a36c0 2022-01-09 op if (op->type == OP_CAST) {
369 fb1a36c0 2022-01-09 op if (eval(op) != EVAL_OK) {
370 fb1a36c0 2022-01-09 op free(b);
371 fb1a36c0 2022-01-09 op return 0;
372 fb1a36c0 2022-01-09 op }
373 fb1a36c0 2022-01-09 op popv(&b->val);
374 fb1a36c0 2022-01-09 op } else
375 fb1a36c0 2022-01-09 op memcpy(&b->val, &op->v.literal, sizeof(b->val));
376 fb1a36c0 2022-01-09 op
377 fb1a36c0 2022-01-09 op e = TAILQ_LAST(&envs, envs);
378 fb1a36c0 2022-01-09 op TAILQ_INSERT_HEAD(&e->bindings, b, entry);
379 fb1a36c0 2022-01-09 op
380 fb1a36c0 2022-01-09 op return 1;
381 fb1a36c0 2022-01-09 op }
382 fb1a36c0 2022-01-09 op
383 fb1a36c0 2022-01-09 op struct op *
384 fb1a36c0 2022-01-09 op newop(int type)
385 fb1a36c0 2022-01-09 op {
386 fb1a36c0 2022-01-09 op struct op *op;
387 fb1a36c0 2022-01-09 op
388 fb1a36c0 2022-01-09 op op = xcalloc(1, sizeof(*op));
389 fb1a36c0 2022-01-09 op op->type = type;
390 fb1a36c0 2022-01-09 op
391 fb1a36c0 2022-01-09 op return op;
392 fb1a36c0 2022-01-09 op }
393 fb1a36c0 2022-01-09 op
394 fb1a36c0 2022-01-09 op void
395 fb1a36c0 2022-01-09 op free_op_rec(struct op *op)
396 fb1a36c0 2022-01-09 op {
397 fb1a36c0 2022-01-09 op struct op *n;
398 fb1a36c0 2022-01-09 op
399 fb1a36c0 2022-01-09 op while (op != NULL) {
400 fb1a36c0 2022-01-09 op n = op->next;
401 fb1a36c0 2022-01-09 op free_op(op);
402 fb1a36c0 2022-01-09 op op = n;
403 fb1a36c0 2022-01-09 op }
404 fb1a36c0 2022-01-09 op }
405 fb1a36c0 2022-01-09 op
406 fb1a36c0 2022-01-09 op void
407 fb1a36c0 2022-01-09 op free_op(struct op *op)
408 fb1a36c0 2022-01-09 op {
409 fb1a36c0 2022-01-09 op if (op == NULL)
410 fb1a36c0 2022-01-09 op return;
411 fb1a36c0 2022-01-09 op
412 fb1a36c0 2022-01-09 op switch (op->type) {
413 fb1a36c0 2022-01-09 op case OP_REST:
414 fb1a36c0 2022-01-09 op case OP_LITERAL:
415 fb1a36c0 2022-01-09 op case OP_VARGS:
416 fb1a36c0 2022-01-09 op break;
417 fb1a36c0 2022-01-09 op case OP_ASSIGN:
418 fb1a36c0 2022-01-09 op free(op->v.assign.name);
419 fb1a36c0 2022-01-09 op free_op_rec(op->v.assign.expr);
420 fb1a36c0 2022-01-09 op break;
421 fb1a36c0 2022-01-09 op case OP_ASSERT:
422 fb1a36c0 2022-01-09 op free_op_rec(op->v.assert);
423 fb1a36c0 2022-01-09 op break;
424 fb1a36c0 2022-01-09 op case OP_FUNCALL:
425 fb1a36c0 2022-01-09 op free_op_rec(op->v.funcall.argv);
426 fb1a36c0 2022-01-09 op break;
427 fb1a36c0 2022-01-09 op case OP_VAR:
428 fb1a36c0 2022-01-09 op free(op->v.var);
429 fb1a36c0 2022-01-09 op break;
430 fb1a36c0 2022-01-09 op case OP_CAST:
431 fb1a36c0 2022-01-09 op free_op_rec(op->v.cast.expr);
432 fb1a36c0 2022-01-09 op break;
433 fb1a36c0 2022-01-09 op case OP_CMP_EQ:
434 fb1a36c0 2022-01-09 op case OP_CMP_LEQ:
435 fb1a36c0 2022-01-09 op free_op_rec(op->v.bin_cmp.a);
436 fb1a36c0 2022-01-09 op free_op_rec(op->v.bin_cmp.b);
437 fb1a36c0 2022-01-09 op break;
438 fb1a36c0 2022-01-09 op case OP_FACCESS:
439 fb1a36c0 2022-01-09 op free_op_rec(op->v.faccess.expr);
440 fb1a36c0 2022-01-09 op free(op->v.faccess.field);
441 fb1a36c0 2022-01-09 op break;
442 fb1a36c0 2022-01-09 op case OP_SFAIL:
443 fb1a36c0 2022-01-09 op free(op->v.sfail.msg);
444 fb1a36c0 2022-01-09 op free_op_rec(op->v.sfail.expr);
445 fb1a36c0 2022-01-09 op break;
446 fb1a36c0 2022-01-09 op default:
447 fb1a36c0 2022-01-09 op /* unreachable */
448 fb1a36c0 2022-01-09 op abort();
449 fb1a36c0 2022-01-09 op }
450 fb1a36c0 2022-01-09 op
451 fb1a36c0 2022-01-09 op free(op);
452 fb1a36c0 2022-01-09 op }
453 fb1a36c0 2022-01-09 op
454 fb1a36c0 2022-01-09 op struct op *
455 fb1a36c0 2022-01-09 op op_rest(void)
456 fb1a36c0 2022-01-09 op {
457 fb1a36c0 2022-01-09 op return newop(OP_REST);
458 fb1a36c0 2022-01-09 op }
459 fb1a36c0 2022-01-09 op
460 fb1a36c0 2022-01-09 op struct op *
461 fb1a36c0 2022-01-09 op op_assign(char *sym, struct op *expr)
462 fb1a36c0 2022-01-09 op {
463 fb1a36c0 2022-01-09 op struct op *op;
464 fb1a36c0 2022-01-09 op
465 fb1a36c0 2022-01-09 op op = newop(OP_ASSIGN);
466 fb1a36c0 2022-01-09 op op->v.assign.name = sym;
467 fb1a36c0 2022-01-09 op op->v.assign.expr = expr;
468 fb1a36c0 2022-01-09 op
469 fb1a36c0 2022-01-09 op return op;
470 fb1a36c0 2022-01-09 op }
471 fb1a36c0 2022-01-09 op
472 fb1a36c0 2022-01-09 op struct op *
473 fb1a36c0 2022-01-09 op op_assert(struct op *expr)
474 fb1a36c0 2022-01-09 op {
475 fb1a36c0 2022-01-09 op struct op *op;
476 fb1a36c0 2022-01-09 op
477 fb1a36c0 2022-01-09 op op = newop(OP_ASSERT);
478 fb1a36c0 2022-01-09 op op->v.assert = expr;
479 fb1a36c0 2022-01-09 op
480 fb1a36c0 2022-01-09 op return op;
481 fb1a36c0 2022-01-09 op }
482 fb1a36c0 2022-01-09 op
483 fb1a36c0 2022-01-09 op struct op *
484 fb1a36c0 2022-01-09 op op_var(char *sym)
485 fb1a36c0 2022-01-09 op {
486 fb1a36c0 2022-01-09 op struct op *op;
487 fb1a36c0 2022-01-09 op
488 fb1a36c0 2022-01-09 op op = newop(OP_VAR);
489 fb1a36c0 2022-01-09 op op->v.var = sym;
490 fb1a36c0 2022-01-09 op
491 fb1a36c0 2022-01-09 op return op;
492 fb1a36c0 2022-01-09 op }
493 fb1a36c0 2022-01-09 op
494 fb1a36c0 2022-01-09 op struct op *
495 fb1a36c0 2022-01-09 op op_lit_str(char *str)
496 fb1a36c0 2022-01-09 op {
497 fb1a36c0 2022-01-09 op struct op *op;
498 fb1a36c0 2022-01-09 op
499 fb1a36c0 2022-01-09 op op = newop(OP_LITERAL);
500 fb1a36c0 2022-01-09 op op->v.literal.type = V_STR;
501 fb1a36c0 2022-01-09 op op->v.literal.v.str = str;
502 fb1a36c0 2022-01-09 op
503 fb1a36c0 2022-01-09 op return op;
504 fb1a36c0 2022-01-09 op }
505 fb1a36c0 2022-01-09 op
506 fb1a36c0 2022-01-09 op struct op *
507 fb1a36c0 2022-01-09 op op_lit_num(uint64_t n)
508 fb1a36c0 2022-01-09 op {
509 fb1a36c0 2022-01-09 op struct op *op;
510 fb1a36c0 2022-01-09 op
511 fb1a36c0 2022-01-09 op op = newop(OP_LITERAL);
512 fb1a36c0 2022-01-09 op op->v.literal.type = V_NUM;
513 fb1a36c0 2022-01-09 op op->v.literal.v.num = n;
514 fb1a36c0 2022-01-09 op
515 fb1a36c0 2022-01-09 op return op;
516 fb1a36c0 2022-01-09 op }
517 fb1a36c0 2022-01-09 op
518 fb1a36c0 2022-01-09 op struct op *
519 fb1a36c0 2022-01-09 op op_cmp_eq(struct op *a, struct op *b)
520 fb1a36c0 2022-01-09 op {
521 fb1a36c0 2022-01-09 op struct op *op;
522 fb1a36c0 2022-01-09 op
523 fb1a36c0 2022-01-09 op op = newop(OP_CMP_EQ);
524 fb1a36c0 2022-01-09 op op->v.bin_cmp.a = a;
525 fb1a36c0 2022-01-09 op op->v.bin_cmp.b = b;
526 fb1a36c0 2022-01-09 op
527 fb1a36c0 2022-01-09 op return op;
528 fb1a36c0 2022-01-09 op }
529 fb1a36c0 2022-01-09 op
530 fb1a36c0 2022-01-09 op struct op *
531 fb1a36c0 2022-01-09 op op_cmp_leq(struct op *a, struct op *b)
532 fb1a36c0 2022-01-09 op {
533 fb1a36c0 2022-01-09 op struct op *op;
534 fb1a36c0 2022-01-09 op
535 fb1a36c0 2022-01-09 op op = newop(OP_CMP_LEQ);
536 fb1a36c0 2022-01-09 op op->v.bin_cmp.a = a;
537 fb1a36c0 2022-01-09 op op->v.bin_cmp.b = b;
538 fb1a36c0 2022-01-09 op
539 fb1a36c0 2022-01-09 op return op;
540 fb1a36c0 2022-01-09 op }
541 fb1a36c0 2022-01-09 op
542 fb1a36c0 2022-01-09 op struct op *
543 fb1a36c0 2022-01-09 op op_cast(struct op *expr, int totype)
544 fb1a36c0 2022-01-09 op {
545 fb1a36c0 2022-01-09 op struct op *op;
546 fb1a36c0 2022-01-09 op
547 fb1a36c0 2022-01-09 op op = newop(OP_CAST);
548 fb1a36c0 2022-01-09 op op->v.cast.expr = expr;
549 fb1a36c0 2022-01-09 op op->v.cast.totype = totype;
550 fb1a36c0 2022-01-09 op
551 fb1a36c0 2022-01-09 op return op;
552 fb1a36c0 2022-01-09 op }
553 fb1a36c0 2022-01-09 op
554 fb1a36c0 2022-01-09 op struct op *
555 fb1a36c0 2022-01-09 op op_faccess(struct op *expr, char *field)
556 fb1a36c0 2022-01-09 op {
557 fb1a36c0 2022-01-09 op struct op *op;
558 fb1a36c0 2022-01-09 op
559 fb1a36c0 2022-01-09 op op = newop(OP_FACCESS);
560 fb1a36c0 2022-01-09 op op->v.faccess.expr = expr;
561 fb1a36c0 2022-01-09 op op->v.faccess.field = field;
562 fb1a36c0 2022-01-09 op
563 fb1a36c0 2022-01-09 op return op;
564 fb1a36c0 2022-01-09 op }
565 fb1a36c0 2022-01-09 op
566 fb1a36c0 2022-01-09 op struct op *
567 fb1a36c0 2022-01-09 op op_sfail(struct op *expr, char *msg)
568 fb1a36c0 2022-01-09 op {
569 fb1a36c0 2022-01-09 op struct op *op;
570 fb1a36c0 2022-01-09 op
571 fb1a36c0 2022-01-09 op op = newop(OP_SFAIL);
572 fb1a36c0 2022-01-09 op op->v.sfail.expr = expr;
573 fb1a36c0 2022-01-09 op op->v.sfail.msg = msg;
574 fb1a36c0 2022-01-09 op
575 fb1a36c0 2022-01-09 op return op;
576 fb1a36c0 2022-01-09 op }
577 fb1a36c0 2022-01-09 op
578 fb1a36c0 2022-01-09 op struct op *
579 fb1a36c0 2022-01-09 op op_vargs(void)
580 fb1a36c0 2022-01-09 op {
581 fb1a36c0 2022-01-09 op struct op *op;
582 fb1a36c0 2022-01-09 op
583 fb1a36c0 2022-01-09 op op = newop(OP_VARGS);
584 fb1a36c0 2022-01-09 op
585 fb1a36c0 2022-01-09 op return op;
586 fb1a36c0 2022-01-09 op }
587 fb1a36c0 2022-01-09 op
588 fb1a36c0 2022-01-09 op void
589 fb1a36c0 2022-01-09 op ppf_val(FILE *f, struct value *val)
590 fb1a36c0 2022-01-09 op {
591 fb1a36c0 2022-01-09 op size_t i;
592 fb1a36c0 2022-01-09 op
593 fb1a36c0 2022-01-09 op switch (val->type) {
594 fb1a36c0 2022-01-09 op case V_SYM:
595 fb1a36c0 2022-01-09 op fprintf(f, "%s", val->v.str);
596 fb1a36c0 2022-01-09 op break;
597 fb1a36c0 2022-01-09 op case V_STR:
598 fb1a36c0 2022-01-09 op fprintf(f, "\"%s\"", val->v.str);
599 fb1a36c0 2022-01-09 op break;
600 fb1a36c0 2022-01-09 op case V_NUM:
601 fb1a36c0 2022-01-09 op fprintf(f, "%"PRIi64, val->v.num);
602 fb1a36c0 2022-01-09 op break;
603 fb1a36c0 2022-01-09 op case V_U8:
604 fb1a36c0 2022-01-09 op fprintf(f, "%"PRIu8, val->v.u8);
605 fb1a36c0 2022-01-09 op break;
606 fb1a36c0 2022-01-09 op case V_U16:
607 fb1a36c0 2022-01-09 op fprintf(f, "%"PRIu16, val->v.u16);
608 fb1a36c0 2022-01-09 op break;
609 fb1a36c0 2022-01-09 op case V_U32:
610 fb1a36c0 2022-01-09 op fprintf(f, "%"PRIu32, val->v.u32);
611 fb1a36c0 2022-01-09 op break;
612 fb1a36c0 2022-01-09 op case V_MSG:
613 fb1a36c0 2022-01-09 op fprintf(f, "(");
614 fb1a36c0 2022-01-09 op for (i = 0; i < val->v.msg.len; ++i)
615 fb1a36c0 2022-01-09 op fprintf(f, "%x%s", val->v.msg.msg[i],
616 fb1a36c0 2022-01-09 op i == val->v.msg.len-1 ? "" : " ");
617 fb1a36c0 2022-01-09 op fprintf(f, ")");
618 fb1a36c0 2022-01-09 op break;
619 fb1a36c0 2022-01-09 op case V_QIDVEC:
620 fb1a36c0 2022-01-09 op fprintf(f, "qids[n=%zu]", val->v.qidvec.len);
621 fb1a36c0 2022-01-09 op break;
622 fb1a36c0 2022-01-09 op default:
623 fb1a36c0 2022-01-09 op fprintf(f, "<unknown value>");
624 fb1a36c0 2022-01-09 op break;
625 fb1a36c0 2022-01-09 op }
626 fb1a36c0 2022-01-09 op }
627 fb1a36c0 2022-01-09 op
628 fb1a36c0 2022-01-09 op void
629 fb1a36c0 2022-01-09 op pp_val(struct value *val)
630 fb1a36c0 2022-01-09 op {
631 fb1a36c0 2022-01-09 op ppf_val(stdout, val);
632 fb1a36c0 2022-01-09 op }
633 fb1a36c0 2022-01-09 op
634 fb1a36c0 2022-01-09 op const char *
635 fb1a36c0 2022-01-09 op val_type(struct value *v)
636 fb1a36c0 2022-01-09 op {
637 fb1a36c0 2022-01-09 op switch (v->type) {
638 fb1a36c0 2022-01-09 op case V_SYM: return "symbol";
639 fb1a36c0 2022-01-09 op case V_STR: return "string";
640 fb1a36c0 2022-01-09 op case V_NUM: return "number";
641 fb1a36c0 2022-01-09 op case V_MSG: return "message";
642 fb1a36c0 2022-01-09 op case V_QID: return "qid";
643 fb1a36c0 2022-01-09 op case V_U8: return "u8";
644 fb1a36c0 2022-01-09 op case V_U16: return "u16";
645 fb1a36c0 2022-01-09 op case V_U32: return "u32";
646 fb1a36c0 2022-01-09 op default: return "unknown";
647 fb1a36c0 2022-01-09 op }
648 fb1a36c0 2022-01-09 op }
649 fb1a36c0 2022-01-09 op
650 fb1a36c0 2022-01-09 op int
651 fb1a36c0 2022-01-09 op val_trueish(struct value *a)
652 fb1a36c0 2022-01-09 op {
653 fb1a36c0 2022-01-09 op if (val_isnum(a))
654 fb1a36c0 2022-01-09 op return val_tonum(a);
655 fb1a36c0 2022-01-09 op return 1;
656 fb1a36c0 2022-01-09 op }
657 fb1a36c0 2022-01-09 op
658 fb1a36c0 2022-01-09 op int
659 fb1a36c0 2022-01-09 op val_isnum(struct value *a)
660 fb1a36c0 2022-01-09 op {
661 fb1a36c0 2022-01-09 op return a->type == V_NUM
662 fb1a36c0 2022-01-09 op || a->type == V_U8
663 fb1a36c0 2022-01-09 op || a->type == V_U16
664 fb1a36c0 2022-01-09 op || a->type == V_U32;
665 fb1a36c0 2022-01-09 op }
666 fb1a36c0 2022-01-09 op
667 fb1a36c0 2022-01-09 op int64_t
668 fb1a36c0 2022-01-09 op val_tonum(struct value *a)
669 fb1a36c0 2022-01-09 op {
670 fb1a36c0 2022-01-09 op switch (a->type) {
671 fb1a36c0 2022-01-09 op case V_NUM: return a->v.num;
672 fb1a36c0 2022-01-09 op case V_U8: return a->v.u8;
673 fb1a36c0 2022-01-09 op case V_U16: return a->v.u16;
674 fb1a36c0 2022-01-09 op case V_U32: return a->v.u32;
675 fb1a36c0 2022-01-09 op default:
676 fb1a36c0 2022-01-09 op before_printing();
677 fb1a36c0 2022-01-09 op fprintf(stderr, "%s: given value is not a number\n", __func__);
678 fb1a36c0 2022-01-09 op abort();
679 fb1a36c0 2022-01-09 op }
680 fb1a36c0 2022-01-09 op }
681 fb1a36c0 2022-01-09 op
682 fb1a36c0 2022-01-09 op int
683 fb1a36c0 2022-01-09 op val_eq(struct value *a, struct value *b)
684 fb1a36c0 2022-01-09 op {
685 fb1a36c0 2022-01-09 op if (val_isnum(a) && val_isnum(b))
686 fb1a36c0 2022-01-09 op return val_tonum(a) == val_tonum(b);
687 fb1a36c0 2022-01-09 op
688 fb1a36c0 2022-01-09 op if (a->type != b->type)
689 fb1a36c0 2022-01-09 op return 0;
690 fb1a36c0 2022-01-09 op
691 fb1a36c0 2022-01-09 op switch (a->type) {
692 fb1a36c0 2022-01-09 op case V_STR:
693 fb1a36c0 2022-01-09 op case V_SYM:
694 fb1a36c0 2022-01-09 op return !strcmp(a->v.str, b->v.str);
695 fb1a36c0 2022-01-09 op }
696 fb1a36c0 2022-01-09 op
697 fb1a36c0 2022-01-09 op return 0;
698 fb1a36c0 2022-01-09 op }
699 fb1a36c0 2022-01-09 op
700 fb1a36c0 2022-01-09 op int
701 fb1a36c0 2022-01-09 op val_leq(struct value *a, struct value *b)
702 fb1a36c0 2022-01-09 op {
703 fb1a36c0 2022-01-09 op if (val_isnum(a) && val_isnum(b))
704 fb1a36c0 2022-01-09 op return val_tonum(a) <= val_tonum(b);
705 fb1a36c0 2022-01-09 op return 0;
706 fb1a36c0 2022-01-09 op }
707 fb1a36c0 2022-01-09 op
708 fb1a36c0 2022-01-09 op static inline const char *
709 fb1a36c0 2022-01-09 op pp_totype(int totype)
710 fb1a36c0 2022-01-09 op {
711 fb1a36c0 2022-01-09 op /*
712 fb1a36c0 2022-01-09 op * Not all of these are valid cast type thought, including
713 fb1a36c0 2022-01-09 op * every possibility only to aid debugging.
714 fb1a36c0 2022-01-09 op */
715 fb1a36c0 2022-01-09 op switch (totype) {
716 fb1a36c0 2022-01-09 op case V_STR: return "str";
717 fb1a36c0 2022-01-09 op case V_SYM: return "sym";
718 fb1a36c0 2022-01-09 op case V_NUM: return "num";
719 fb1a36c0 2022-01-09 op case V_QID: return "qid";
720 fb1a36c0 2022-01-09 op case V_U8: return "u8";
721 fb1a36c0 2022-01-09 op case V_U16: return "u16";
722 fb1a36c0 2022-01-09 op case V_U32: return "u32";
723 fb1a36c0 2022-01-09 op default: return "unknown";
724 fb1a36c0 2022-01-09 op }
725 fb1a36c0 2022-01-09 op }
726 fb1a36c0 2022-01-09 op
727 fb1a36c0 2022-01-09 op int
728 fb1a36c0 2022-01-09 op val_cast(struct value *a, int totype)
729 fb1a36c0 2022-01-09 op {
730 fb1a36c0 2022-01-09 op int64_t v;
731 fb1a36c0 2022-01-09 op
732 fb1a36c0 2022-01-09 op #define NUMCAST(val, t, c, totype, max) do { \
733 fb1a36c0 2022-01-09 op if (val > max) { \
734 fb1a36c0 2022-01-09 op before_printing(); \
735 fb1a36c0 2022-01-09 op fprintf(stderr, "can't cast %"PRIu64 \
736 fb1a36c0 2022-01-09 op " to %s\n", val, pp_totype(totype)); \
737 fb1a36c0 2022-01-09 op return EVAL_ERR; \
738 fb1a36c0 2022-01-09 op } \
739 fb1a36c0 2022-01-09 op a->type = totype; \
740 fb1a36c0 2022-01-09 op a->v.t = (c)val; \
741 fb1a36c0 2022-01-09 op return EVAL_OK; \
742 fb1a36c0 2022-01-09 op } while (0)
743 fb1a36c0 2022-01-09 op
744 fb1a36c0 2022-01-09 op if (a->type == totype)
745 fb1a36c0 2022-01-09 op return EVAL_OK;
746 fb1a36c0 2022-01-09 op
747 fb1a36c0 2022-01-09 op if (!val_isnum(a)) {
748 fb1a36c0 2022-01-09 op before_printing();
749 fb1a36c0 2022-01-09 op fprintf(stderr, "can't cast ");
750 fb1a36c0 2022-01-09 op ppf_val(stderr, a);
751 fb1a36c0 2022-01-09 op fprintf(stderr, " to type %s\n", pp_totype(totype));
752 fb1a36c0 2022-01-09 op return EVAL_ERR;
753 fb1a36c0 2022-01-09 op }
754 fb1a36c0 2022-01-09 op
755 fb1a36c0 2022-01-09 op v = a->v.num;
756 fb1a36c0 2022-01-09 op switch (totype) {
757 fb1a36c0 2022-01-09 op case V_U8: NUMCAST(v, u8, uint8_t, totype, UINT8_MAX);
758 fb1a36c0 2022-01-09 op case V_U16: NUMCAST(v, u16, uint16_t, totype, UINT16_MAX);
759 fb1a36c0 2022-01-09 op case V_U32: NUMCAST(v, u32, uint32_t, totype, UINT32_MAX);
760 fb1a36c0 2022-01-09 op default:
761 fb1a36c0 2022-01-09 op before_printing();
762 fb1a36c0 2022-01-09 op fprintf(stderr, "can't cast %"PRIu64" to %s\n",
763 fb1a36c0 2022-01-09 op v, pp_totype(totype));
764 fb1a36c0 2022-01-09 op return EVAL_ERR;
765 fb1a36c0 2022-01-09 op }
766 fb1a36c0 2022-01-09 op
767 fb1a36c0 2022-01-09 op #undef NUMCAST
768 fb1a36c0 2022-01-09 op }
769 fb1a36c0 2022-01-09 op
770 fb1a36c0 2022-01-09 op int
771 fb1a36c0 2022-01-09 op val_faccess(struct value *a, const char *field, struct value *ret)
772 fb1a36c0 2022-01-09 op {
773 fb1a36c0 2022-01-09 op uint8_t mtype;
774 fb1a36c0 2022-01-09 op uint16_t len;
775 fb1a36c0 2022-01-09 op const char *errstr;
776 fb1a36c0 2022-01-09 op
777 fb1a36c0 2022-01-09 op #define MSGTYPE(m) *(m.msg + 4) /* skip the length */
778 fb1a36c0 2022-01-09 op
779 fb1a36c0 2022-01-09 op switch (a->type) {
780 fb1a36c0 2022-01-09 op case V_QID:
781 fb1a36c0 2022-01-09 op /* TODO: add path. needs uint64_t values thought! */
782 fb1a36c0 2022-01-09 op if (!strcmp(field, "vers")) {
783 fb1a36c0 2022-01-09 op ret->type = V_U32;
784 fb1a36c0 2022-01-09 op memcpy(&ret->v.u32, a->v.qid+1, 4);
785 fb1a36c0 2022-01-09 op return EVAL_OK;
786 fb1a36c0 2022-01-09 op } else if (!strcmp(field, "type")) {
787 fb1a36c0 2022-01-09 op ret->type = V_U8;
788 fb1a36c0 2022-01-09 op ret->v.u8 = *a->v.qid;
789 fb1a36c0 2022-01-09 op return EVAL_OK;
790 fb1a36c0 2022-01-09 op }
791 fb1a36c0 2022-01-09 op break;
792 fb1a36c0 2022-01-09 op
793 fb1a36c0 2022-01-09 op case V_MSG:
794 fb1a36c0 2022-01-09 op mtype = MSGTYPE(a->v.msg);
795 fb1a36c0 2022-01-09 op if (!strcmp(field, "type")) {
796 fb1a36c0 2022-01-09 op ret->type = V_U8;
797 fb1a36c0 2022-01-09 op ret->v.u8 = MSGTYPE(a->v.msg);
798 fb1a36c0 2022-01-09 op return EVAL_OK;
799 fb1a36c0 2022-01-09 op } else if (!strcmp(field, "tag")) {
800 fb1a36c0 2022-01-09 op ret->type = V_U16;
801 fb1a36c0 2022-01-09 op memcpy(&ret->v.u16, &a->v.msg.msg[5], 2);
802 fb1a36c0 2022-01-09 op ret->v.u16 = le16toh(ret->v.u16);
803 fb1a36c0 2022-01-09 op return EVAL_OK;
804 fb1a36c0 2022-01-09 op } else if (!strcmp(field, "msize") && mtype == Rversion) {
805 fb1a36c0 2022-01-09 op ret->type = V_U32;
806 fb1a36c0 2022-01-09 op memcpy(&ret->v.u32, &a->v.msg.msg[7], 4);
807 fb1a36c0 2022-01-09 op ret->v.u32 = le32toh(ret->v.u32);
808 fb1a36c0 2022-01-09 op return EVAL_OK;
809 fb1a36c0 2022-01-09 op } else if (!strcmp(field, "qid") && mtype == Rattach) {
810 fb1a36c0 2022-01-09 op ret->type = V_QID;
811 fb1a36c0 2022-01-09 op memcpy(&ret->v.qid, &a->v.msg.msg[7], QIDSIZE);
812 fb1a36c0 2022-01-09 op return EVAL_OK;
813 fb1a36c0 2022-01-09 op } else if (!strcmp(field, "nwqid") && mtype == Rwalk) {
814 fb1a36c0 2022-01-09 op ret->type = V_U16;
815 fb1a36c0 2022-01-09 op memcpy(&ret->v.u16, &a->v.msg.msg[7], 2);
816 fb1a36c0 2022-01-09 op ret->v.u16 = le16toh(ret->v.u16);
817 fb1a36c0 2022-01-09 op return EVAL_OK;
818 fb1a36c0 2022-01-09 op } else if (!strcmp(field, "wqid") && mtype == Rwalk) {
819 fb1a36c0 2022-01-09 op ret->type = V_QIDVEC;
820 fb1a36c0 2022-01-09 op ret->v.qidvec.start = &a->v.msg.msg[9];
821 fb1a36c0 2022-01-09 op memcpy(&len, &a->v.msg.msg[7], 2);
822 fb1a36c0 2022-01-09 op len = le16toh(len);
823 fb1a36c0 2022-01-09 op ret->v.qidvec.len = len;
824 fb1a36c0 2022-01-09 op return EVAL_OK;
825 fb1a36c0 2022-01-09 op }
826 fb1a36c0 2022-01-09 op break;
827 fb1a36c0 2022-01-09 op
828 fb1a36c0 2022-01-09 op case V_QIDVEC:
829 fb1a36c0 2022-01-09 op len = strtonum(field, 0, MAXWELEM, &errstr);
830 fb1a36c0 2022-01-09 op if (errstr != NULL) {
831 fb1a36c0 2022-01-09 op before_printing();
832 fb1a36c0 2022-01-09 op printf("can't access qid #%s: %s\n", field, errstr);
833 fb1a36c0 2022-01-09 op return EVAL_ERR;
834 fb1a36c0 2022-01-09 op }
835 fb1a36c0 2022-01-09 op
836 fb1a36c0 2022-01-09 op if (len >= a->v.qidvec.len) {
837 fb1a36c0 2022-01-09 op before_printing();
838 fb1a36c0 2022-01-09 op printf("can't access qid #%d: out-of-bound "
839 fb1a36c0 2022-01-09 op "(max %zu)\n", len, a->v.qidvec.len);
840 fb1a36c0 2022-01-09 op return EVAL_ERR;
841 fb1a36c0 2022-01-09 op }
842 fb1a36c0 2022-01-09 op
843 fb1a36c0 2022-01-09 op ret->type = V_QID;
844 fb1a36c0 2022-01-09 op memcpy(&ret->v.qid, a->v.qidvec.start + len * QIDSIZE,
845 fb1a36c0 2022-01-09 op QIDSIZE);
846 fb1a36c0 2022-01-09 op
847 fb1a36c0 2022-01-09 op return EVAL_OK;
848 fb1a36c0 2022-01-09 op
849 fb1a36c0 2022-01-09 op default:
850 fb1a36c0 2022-01-09 op break;
851 fb1a36c0 2022-01-09 op }
852 fb1a36c0 2022-01-09 op
853 fb1a36c0 2022-01-09 op before_printing();
854 fb1a36c0 2022-01-09 op printf("can't access field `%s' on type %s (", field, val_type(a));
855 fb1a36c0 2022-01-09 op pp_val(a);
856 fb1a36c0 2022-01-09 op printf(")\n");
857 fb1a36c0 2022-01-09 op return EVAL_ERR;
858 fb1a36c0 2022-01-09 op
859 fb1a36c0 2022-01-09 op #undef MSGTYPE
860 fb1a36c0 2022-01-09 op }
861 fb1a36c0 2022-01-09 op
862 fb1a36c0 2022-01-09 op void
863 fb1a36c0 2022-01-09 op pp_op(struct op *op)
864 fb1a36c0 2022-01-09 op {
865 fb1a36c0 2022-01-09 op struct op *aux;
866 fb1a36c0 2022-01-09 op
867 fb1a36c0 2022-01-09 op switch (op->type) {
868 fb1a36c0 2022-01-09 op case OP_REST:
869 fb1a36c0 2022-01-09 op printf("...");
870 fb1a36c0 2022-01-09 op break;
871 fb1a36c0 2022-01-09 op case OP_ASSIGN:
872 fb1a36c0 2022-01-09 op printf("%s = ", op->v.assign.name);
873 fb1a36c0 2022-01-09 op pp_op(op->v.assign.expr);
874 fb1a36c0 2022-01-09 op break;
875 fb1a36c0 2022-01-09 op case OP_ASSERT:
876 fb1a36c0 2022-01-09 op printf("assert ");
877 fb1a36c0 2022-01-09 op pp_op(op->v.assert);
878 fb1a36c0 2022-01-09 op break;
879 fb1a36c0 2022-01-09 op case OP_FUNCALL:
880 fb1a36c0 2022-01-09 op printf("funcall %s(", op->v.funcall.proc->name);
881 fb1a36c0 2022-01-09 op for (aux = op->v.funcall.argv; aux != NULL; aux = aux->next) {
882 fb1a36c0 2022-01-09 op pp_op(aux);
883 fb1a36c0 2022-01-09 op if (aux->next != NULL)
884 fb1a36c0 2022-01-09 op printf(", ");
885 fb1a36c0 2022-01-09 op }
886 fb1a36c0 2022-01-09 op printf(")");
887 fb1a36c0 2022-01-09 op break;
888 fb1a36c0 2022-01-09 op case OP_LITERAL:
889 fb1a36c0 2022-01-09 op pp_val(&op->v.literal);
890 fb1a36c0 2022-01-09 op break;
891 fb1a36c0 2022-01-09 op case OP_VAR:
892 fb1a36c0 2022-01-09 op printf("%s", op->v.var);
893 fb1a36c0 2022-01-09 op break;
894 fb1a36c0 2022-01-09 op case OP_CAST:
895 fb1a36c0 2022-01-09 op pp_op(op->v.cast.expr);
896 fb1a36c0 2022-01-09 op printf(":");
897 fb1a36c0 2022-01-09 op switch (op->v.cast.totype) {
898 fb1a36c0 2022-01-09 op case V_U8: printf("u8"); break;
899 fb1a36c0 2022-01-09 op case V_U16: printf("u16"); break;
900 fb1a36c0 2022-01-09 op case V_U32: printf("u32"); break;
901 fb1a36c0 2022-01-09 op case V_STR: printf("str"); break;
902 fb1a36c0 2022-01-09 op default: printf("???"); break;
903 fb1a36c0 2022-01-09 op }
904 fb1a36c0 2022-01-09 op break;
905 fb1a36c0 2022-01-09 op case OP_CMP_EQ:
906 fb1a36c0 2022-01-09 op pp_op(op->v.bin_cmp.a);
907 fb1a36c0 2022-01-09 op printf(" == ");
908 fb1a36c0 2022-01-09 op pp_op(op->v.bin_cmp.b);
909 fb1a36c0 2022-01-09 op break;
910 fb1a36c0 2022-01-09 op case OP_CMP_LEQ:
911 fb1a36c0 2022-01-09 op pp_op(op->v.bin_cmp.a);
912 fb1a36c0 2022-01-09 op printf(" <= ");
913 fb1a36c0 2022-01-09 op pp_op(op->v.bin_cmp.b);
914 fb1a36c0 2022-01-09 op break;
915 fb1a36c0 2022-01-09 op case OP_FACCESS:
916 fb1a36c0 2022-01-09 op pp_op(op->v.faccess.expr);
917 fb1a36c0 2022-01-09 op printf(".%s", op->v.faccess.field);
918 fb1a36c0 2022-01-09 op break;
919 fb1a36c0 2022-01-09 op case OP_SFAIL:
920 fb1a36c0 2022-01-09 op printf("should-fail ");
921 fb1a36c0 2022-01-09 op pp_op(op->v.sfail.expr);
922 fb1a36c0 2022-01-09 op if (op->v.sfail.msg != NULL)
923 fb1a36c0 2022-01-09 op printf(": \"%s\"", op->v.sfail.msg);
924 fb1a36c0 2022-01-09 op break;
925 fb1a36c0 2022-01-09 op case OP_VARGS:
926 fb1a36c0 2022-01-09 op printf("vargs");
927 fb1a36c0 2022-01-09 op break;
928 fb1a36c0 2022-01-09 op default:
929 fb1a36c0 2022-01-09 op printf(" ???[%d] ", op->type);
930 fb1a36c0 2022-01-09 op }
931 fb1a36c0 2022-01-09 op }
932 fb1a36c0 2022-01-09 op
933 fb1a36c0 2022-01-09 op void
934 fb1a36c0 2022-01-09 op pp_block(struct op *op)
935 fb1a36c0 2022-01-09 op {
936 fb1a36c0 2022-01-09 op while (op != NULL) {
937 fb1a36c0 2022-01-09 op printf("> ");
938 fb1a36c0 2022-01-09 op pp_op(op);
939 fb1a36c0 2022-01-09 op printf("\n");
940 fb1a36c0 2022-01-09 op
941 fb1a36c0 2022-01-09 op op = op->next;
942 fb1a36c0 2022-01-09 op }
943 fb1a36c0 2022-01-09 op }
944 fb1a36c0 2022-01-09 op
945 fb1a36c0 2022-01-09 op int
946 fb1a36c0 2022-01-09 op eval(struct op *op)
947 fb1a36c0 2022-01-09 op {
948 fb1a36c0 2022-01-09 op struct value a, b;
949 fb1a36c0 2022-01-09 op struct proc *proc;
950 fb1a36c0 2022-01-09 op struct op *t, *tnext;
951 fb1a36c0 2022-01-09 op int i, ret;
952 fb1a36c0 2022-01-09 op
953 fb1a36c0 2022-01-09 op #if DEBUG
954 fb1a36c0 2022-01-09 op pp_op(op);
955 fb1a36c0 2022-01-09 op printf("\n");
956 fb1a36c0 2022-01-09 op #endif
957 fb1a36c0 2022-01-09 op
958 fb1a36c0 2022-01-09 op switch (op->type) {
959 fb1a36c0 2022-01-09 op case OP_REST:
960 fb1a36c0 2022-01-09 op /*
961 fb1a36c0 2022-01-09 op * Try to load the rest argument. Note that it can be
962 fb1a36c0 2022-01-09 op * empty!
963 fb1a36c0 2022-01-09 op */
964 fb1a36c0 2022-01-09 op if ((ret = getvar_raw("...", &t)) == EVAL_OK)
965 fb1a36c0 2022-01-09 op if ((ret = eval(t)) != EVAL_OK)
966 fb1a36c0 2022-01-09 op return ret;
967 fb1a36c0 2022-01-09 op break;
968 fb1a36c0 2022-01-09 op
969 fb1a36c0 2022-01-09 op case OP_ASSIGN:
970 fb1a36c0 2022-01-09 op ret = setvar(op->v.assign.name, op->v.assign.expr);
971 fb1a36c0 2022-01-09 op if (ret != EVAL_OK)
972 fb1a36c0 2022-01-09 op return ret;
973 fb1a36c0 2022-01-09 op break;
974 fb1a36c0 2022-01-09 op
975 fb1a36c0 2022-01-09 op case OP_ASSERT:
976 fb1a36c0 2022-01-09 op if ((ret = eval(op->v.assert)) != EVAL_OK)
977 fb1a36c0 2022-01-09 op return ret;
978 fb1a36c0 2022-01-09 op popv(&a);
979 fb1a36c0 2022-01-09 op if (!val_trueish(&a)) {
980 fb1a36c0 2022-01-09 op before_printing();
981 fb1a36c0 2022-01-09 op printf("assertion failed: ");
982 fb1a36c0 2022-01-09 op pp_op(op->v.assert);
983 fb1a36c0 2022-01-09 op printf("\n");
984 fb1a36c0 2022-01-09 op return EVAL_ERR;
985 fb1a36c0 2022-01-09 op }
986 fb1a36c0 2022-01-09 op break;
987 fb1a36c0 2022-01-09 op
988 fb1a36c0 2022-01-09 op case OP_FUNCALL:
989 fb1a36c0 2022-01-09 op /* assume airity matches */
990 fb1a36c0 2022-01-09 op
991 fb1a36c0 2022-01-09 op proc = op->v.funcall.proc;
992 fb1a36c0 2022-01-09 op if (proc->nativefn != NULL) {
993 fb1a36c0 2022-01-09 op /*
994 fb1a36c0 2022-01-09 op * Push arguments on the stack for builtin
995 fb1a36c0 2022-01-09 op * functions. Counting the height of the
996 fb1a36c0 2022-01-09 op * stack is done to compute the correct number
997 fb1a36c0 2022-01-09 op * in the vararg case. argc only counts the
998 fb1a36c0 2022-01-09 op * "syntactical" arguments, i.e. foo(x, ...)
999 fb1a36c0 2022-01-09 op * has argc == 2, but at runtime argc may be
1000 fb1a36c0 2022-01-09 op * 1, 2 or a greater number!
1001 fb1a36c0 2022-01-09 op */
1002 fb1a36c0 2022-01-09 op
1003 fb1a36c0 2022-01-09 op i = stackh;
1004 fb1a36c0 2022-01-09 op t = op->v.funcall.argv;
1005 fb1a36c0 2022-01-09 op if (t != NULL && (ret = eval(t)) != EVAL_OK)
1006 fb1a36c0 2022-01-09 op return ret;
1007 fb1a36c0 2022-01-09 op i = stackh - i;
1008 fb1a36c0 2022-01-09 op
1009 fb1a36c0 2022-01-09 op assert(i >= 0);
1010 fb1a36c0 2022-01-09 op
1011 fb1a36c0 2022-01-09 op if ((ret = proc->nativefn(i))
1012 fb1a36c0 2022-01-09 op != EVAL_OK)
1013 fb1a36c0 2022-01-09 op return ret;
1014 fb1a36c0 2022-01-09 op } else {
1015 fb1a36c0 2022-01-09 op if (proc->body == NULL) {
1016 fb1a36c0 2022-01-09 op before_printing();
1017 fb1a36c0 2022-01-09 op printf("warn: calling the empty proc `%s'\n",
1018 fb1a36c0 2022-01-09 op proc->name);
1019 fb1a36c0 2022-01-09 op break;
1020 fb1a36c0 2022-01-09 op }
1021 fb1a36c0 2022-01-09 op
1022 fb1a36c0 2022-01-09 op pushenv();
1023 fb1a36c0 2022-01-09 op
1024 fb1a36c0 2022-01-09 op for (t = op->v.funcall.argv, i = 0;
1025 fb1a36c0 2022-01-09 op t != NULL;
1026 fb1a36c0 2022-01-09 op t = t->next, i++) {
1027 fb1a36c0 2022-01-09 op /*
1028 fb1a36c0 2022-01-09 op * Push a pseudo variable `...' (and
1029 fb1a36c0 2022-01-09 op * don't evaluate it) in the vararg
1030 fb1a36c0 2022-01-09 op * case. A special case is when the
1031 fb1a36c0 2022-01-09 op * variable is itself `...'.
1032 fb1a36c0 2022-01-09 op */
1033 fb1a36c0 2022-01-09 op if (proc->vararg && i == proc->minargs) {
1034 fb1a36c0 2022-01-09 op if (t->type != OP_REST)
1035 fb1a36c0 2022-01-09 op setvar_raw(xstrdup("..."), t);
1036 fb1a36c0 2022-01-09 op break;
1037 fb1a36c0 2022-01-09 op }
1038 fb1a36c0 2022-01-09 op
1039 fb1a36c0 2022-01-09 op /*
1040 fb1a36c0 2022-01-09 op * The arguments are a linked list of
1041 fb1a36c0 2022-01-09 op * ops. Setvar will call eval that
1042 fb1a36c0 2022-01-09 op * will evaluate *all* the arguments.
1043 fb1a36c0 2022-01-09 op * The dance here that sets next to
1044 fb1a36c0 2022-01-09 op * NULL and then restores it is to
1045 fb1a36c0 2022-01-09 op * avoid this behaviour.
1046 fb1a36c0 2022-01-09 op */
1047 fb1a36c0 2022-01-09 op tnext = t->next;
1048 fb1a36c0 2022-01-09 op t->next = NULL;
1049 fb1a36c0 2022-01-09 op ret = setvar(proc->args[i], t);
1050 fb1a36c0 2022-01-09 op t->next = tnext;
1051 fb1a36c0 2022-01-09 op
1052 fb1a36c0 2022-01-09 op if (ret != EVAL_OK)
1053 fb1a36c0 2022-01-09 op return ret;
1054 fb1a36c0 2022-01-09 op }
1055 fb1a36c0 2022-01-09 op
1056 fb1a36c0 2022-01-09 op if ((ret = eval(proc->body)) != EVAL_OK)
1057 fb1a36c0 2022-01-09 op return ret;
1058 fb1a36c0 2022-01-09 op
1059 fb1a36c0 2022-01-09 op popenv();
1060 fb1a36c0 2022-01-09 op }
1061 fb1a36c0 2022-01-09 op
1062 fb1a36c0 2022-01-09 op break;
1063 fb1a36c0 2022-01-09 op
1064 fb1a36c0 2022-01-09 op case OP_LITERAL:
1065 fb1a36c0 2022-01-09 op pushv(&op->v.literal);
1066 fb1a36c0 2022-01-09 op break;
1067 fb1a36c0 2022-01-09 op
1068 fb1a36c0 2022-01-09 op case OP_VAR:
1069 fb1a36c0 2022-01-09 op if ((ret = getvar(op->v.var, &a)) != EVAL_OK)
1070 fb1a36c0 2022-01-09 op return ret;
1071 fb1a36c0 2022-01-09 op pushv(&a);
1072 fb1a36c0 2022-01-09 op break;
1073 fb1a36c0 2022-01-09 op
1074 fb1a36c0 2022-01-09 op case OP_CAST:
1075 fb1a36c0 2022-01-09 op if ((ret = eval(op->v.cast.expr)) != EVAL_OK)
1076 fb1a36c0 2022-01-09 op return ret;
1077 fb1a36c0 2022-01-09 op popv(&a);
1078 fb1a36c0 2022-01-09 op if ((ret = val_cast(&a, op->v.cast.totype)) != EVAL_OK)
1079 fb1a36c0 2022-01-09 op return ret;
1080 fb1a36c0 2022-01-09 op pushv(&a);
1081 fb1a36c0 2022-01-09 op break;
1082 fb1a36c0 2022-01-09 op
1083 fb1a36c0 2022-01-09 op case OP_CMP_EQ:
1084 fb1a36c0 2022-01-09 op if ((ret = eval(op->v.bin_cmp.a)) != EVAL_OK)
1085 fb1a36c0 2022-01-09 op return ret;
1086 fb1a36c0 2022-01-09 op if ((ret = eval(op->v.bin_cmp.b)) != EVAL_OK)
1087 fb1a36c0 2022-01-09 op return ret;
1088 fb1a36c0 2022-01-09 op
1089 fb1a36c0 2022-01-09 op popv(&b);
1090 fb1a36c0 2022-01-09 op popv(&a);
1091 fb1a36c0 2022-01-09 op pushbool(val_eq(&a, &b));
1092 fb1a36c0 2022-01-09 op break;
1093 fb1a36c0 2022-01-09 op
1094 fb1a36c0 2022-01-09 op case OP_CMP_LEQ:
1095 fb1a36c0 2022-01-09 op if ((ret = eval(op->v.bin_cmp.a)) != EVAL_OK)
1096 fb1a36c0 2022-01-09 op return ret;
1097 fb1a36c0 2022-01-09 op if ((ret = eval(op->v.bin_cmp.b)) != EVAL_OK)
1098 fb1a36c0 2022-01-09 op return ret;
1099 fb1a36c0 2022-01-09 op
1100 fb1a36c0 2022-01-09 op popv(&b);
1101 fb1a36c0 2022-01-09 op popv(&a);
1102 fb1a36c0 2022-01-09 op pushbool(val_leq(&a, &b));
1103 fb1a36c0 2022-01-09 op break;
1104 fb1a36c0 2022-01-09 op
1105 fb1a36c0 2022-01-09 op case OP_FACCESS:
1106 fb1a36c0 2022-01-09 op if ((ret = eval(op->v.faccess.expr)) != EVAL_OK)
1107 fb1a36c0 2022-01-09 op return ret;
1108 fb1a36c0 2022-01-09 op popv(&a);
1109 fb1a36c0 2022-01-09 op if ((ret = val_faccess(&a, op->v.faccess.field, &b))
1110 fb1a36c0 2022-01-09 op != EVAL_OK)
1111 fb1a36c0 2022-01-09 op return ret;
1112 fb1a36c0 2022-01-09 op pushv(&b);
1113 fb1a36c0 2022-01-09 op break;
1114 fb1a36c0 2022-01-09 op
1115 fb1a36c0 2022-01-09 op case OP_SFAIL:
1116 fb1a36c0 2022-01-09 op if ((ret = eval(op->v.sfail.expr)) == EVAL_OK) {
1117 fb1a36c0 2022-01-09 op before_printing();
1118 fb1a36c0 2022-01-09 op printf("expecting failure");
1119 fb1a36c0 2022-01-09 op if (op->v.sfail.msg != NULL)
1120 fb1a36c0 2022-01-09 op printf(" \"%s\"", op->v.sfail.msg);
1121 fb1a36c0 2022-01-09 op printf("\n");
1122 fb1a36c0 2022-01-09 op printf("expression: ");
1123 fb1a36c0 2022-01-09 op pp_op(op->v.sfail.expr);
1124 fb1a36c0 2022-01-09 op printf("\n");
1125 fb1a36c0 2022-01-09 op return EVAL_ERR;
1126 fb1a36c0 2022-01-09 op }
1127 fb1a36c0 2022-01-09 op if (ret == EVAL_SKIP)
1128 fb1a36c0 2022-01-09 op return ret;
1129 fb1a36c0 2022-01-09 op break;
1130 fb1a36c0 2022-01-09 op
1131 fb1a36c0 2022-01-09 op case OP_VARGS:
1132 fb1a36c0 2022-01-09 op if ((ret = getvar_raw("...", &t)) == EVAL_OK) {
1133 fb1a36c0 2022-01-09 op for (i = 0; t != NULL; t = t->next)
1134 fb1a36c0 2022-01-09 op i++;
1135 fb1a36c0 2022-01-09 op pushnum(i);
1136 fb1a36c0 2022-01-09 op } else
1137 fb1a36c0 2022-01-09 op pushnum(0);
1138 fb1a36c0 2022-01-09 op break;
1139 fb1a36c0 2022-01-09 op
1140 fb1a36c0 2022-01-09 op default:
1141 fb1a36c0 2022-01-09 op before_printing();
1142 fb1a36c0 2022-01-09 op fprintf(stderr, "invalid op, aborting.\n");
1143 fb1a36c0 2022-01-09 op abort();
1144 fb1a36c0 2022-01-09 op }
1145 fb1a36c0 2022-01-09 op
1146 fb1a36c0 2022-01-09 op if (op->next)
1147 fb1a36c0 2022-01-09 op return eval(op->next);
1148 fb1a36c0 2022-01-09 op return EVAL_OK;
1149 fb1a36c0 2022-01-09 op }
1150 fb1a36c0 2022-01-09 op
1151 fb1a36c0 2022-01-09 op void
1152 fb1a36c0 2022-01-09 op prepare_funcall(void)
1153 fb1a36c0 2022-01-09 op {
1154 fb1a36c0 2022-01-09 op pushstack(&args);
1155 fb1a36c0 2022-01-09 op }
1156 fb1a36c0 2022-01-09 op
1157 fb1a36c0 2022-01-09 op void
1158 fb1a36c0 2022-01-09 op push_arg(struct op *op)
1159 fb1a36c0 2022-01-09 op {
1160 fb1a36c0 2022-01-09 op push(&args, op);
1161 fb1a36c0 2022-01-09 op }
1162 fb1a36c0 2022-01-09 op
1163 fb1a36c0 2022-01-09 op struct op *
1164 fb1a36c0 2022-01-09 op op_funcall(struct proc *proc)
1165 fb1a36c0 2022-01-09 op {
1166 fb1a36c0 2022-01-09 op struct op *op, *argv;
1167 fb1a36c0 2022-01-09 op int argc;
1168 fb1a36c0 2022-01-09 op
1169 fb1a36c0 2022-01-09 op argv = finalize(&args, &argc);
1170 fb1a36c0 2022-01-09 op
1171 fb1a36c0 2022-01-09 op op = newop(OP_FUNCALL);
1172 fb1a36c0 2022-01-09 op op->v.funcall.proc = proc;
1173 fb1a36c0 2022-01-09 op op->v.funcall.argv = argv;
1174 fb1a36c0 2022-01-09 op op->v.funcall.argc = argc;
1175 fb1a36c0 2022-01-09 op
1176 fb1a36c0 2022-01-09 op return op;
1177 fb1a36c0 2022-01-09 op }
1178 fb1a36c0 2022-01-09 op
1179 fb1a36c0 2022-01-09 op void
1180 fb1a36c0 2022-01-09 op add_builtin_proc(const char *name, int (*fn)(int), int argc, int vararg)
1181 fb1a36c0 2022-01-09 op {
1182 fb1a36c0 2022-01-09 op struct proc *proc;
1183 fb1a36c0 2022-01-09 op
1184 fb1a36c0 2022-01-09 op proc = xcalloc(1, sizeof(*proc));
1185 fb1a36c0 2022-01-09 op proc->name = xstrdup(name);
1186 fb1a36c0 2022-01-09 op proc->nativefn = fn;
1187 fb1a36c0 2022-01-09 op proc->minargs = argc;
1188 fb1a36c0 2022-01-09 op proc->vararg = vararg;
1189 fb1a36c0 2022-01-09 op
1190 fb1a36c0 2022-01-09 op TAILQ_INSERT_HEAD(&procs, proc, entry);
1191 fb1a36c0 2022-01-09 op }
1192 fb1a36c0 2022-01-09 op
1193 fb1a36c0 2022-01-09 op void
1194 fb1a36c0 2022-01-09 op prepare_proc(void)
1195 fb1a36c0 2022-01-09 op {
1196 fb1a36c0 2022-01-09 op pushstack(&args);
1197 fb1a36c0 2022-01-09 op }
1198 fb1a36c0 2022-01-09 op
1199 fb1a36c0 2022-01-09 op int
1200 fb1a36c0 2022-01-09 op proc_setup_body(void)
1201 fb1a36c0 2022-01-09 op {
1202 fb1a36c0 2022-01-09 op struct opstack *argv;
1203 fb1a36c0 2022-01-09 op struct op *op;
1204 fb1a36c0 2022-01-09 op int i;
1205 fb1a36c0 2022-01-09 op
1206 fb1a36c0 2022-01-09 op argv = peek(&args);
1207 fb1a36c0 2022-01-09 op for (i = 0, op = argv->base.next; op != NULL; i++) {
1208 fb1a36c0 2022-01-09 op /*
1209 fb1a36c0 2022-01-09 op * TODO: should free the whole list on error but..,
1210 fb1a36c0 2022-01-09 op * we're gonna exit real soon(tm)!
1211 fb1a36c0 2022-01-09 op */
1212 fb1a36c0 2022-01-09 op if (op->type != OP_VAR && op->type != OP_REST)
1213 fb1a36c0 2022-01-09 op return 0;
1214 fb1a36c0 2022-01-09 op
1215 fb1a36c0 2022-01-09 op op = op->next;
1216 fb1a36c0 2022-01-09 op }
1217 fb1a36c0 2022-01-09 op
1218 fb1a36c0 2022-01-09 op assert(i == argv->counter);
1219 fb1a36c0 2022-01-09 op pushstack(&blocks);
1220 fb1a36c0 2022-01-09 op return 1;
1221 fb1a36c0 2022-01-09 op }
1222 fb1a36c0 2022-01-09 op
1223 fb1a36c0 2022-01-09 op void
1224 fb1a36c0 2022-01-09 op proc_done(char *name)
1225 fb1a36c0 2022-01-09 op {
1226 fb1a36c0 2022-01-09 op struct proc *proc;
1227 fb1a36c0 2022-01-09 op struct op *op, *next, *argv, *body;
1228 fb1a36c0 2022-01-09 op int i, argc;
1229 fb1a36c0 2022-01-09 op
1230 fb1a36c0 2022-01-09 op argv = finalize(&args, &argc);
1231 fb1a36c0 2022-01-09 op body = finalize(&blocks, NULL);
1232 fb1a36c0 2022-01-09 op
1233 fb1a36c0 2022-01-09 op proc = xcalloc(1, sizeof(*proc));
1234 fb1a36c0 2022-01-09 op proc->name = name;
1235 fb1a36c0 2022-01-09 op proc->minargs = argc;
1236 fb1a36c0 2022-01-09 op
1237 fb1a36c0 2022-01-09 op for (i = 0, op = argv; op != NULL; ++i) {
1238 fb1a36c0 2022-01-09 op if (op->type == OP_REST) {
1239 fb1a36c0 2022-01-09 op proc->vararg = 1;
1240 fb1a36c0 2022-01-09 op proc->minargs = i;
1241 fb1a36c0 2022-01-09 op break;
1242 fb1a36c0 2022-01-09 op }
1243 fb1a36c0 2022-01-09 op
1244 fb1a36c0 2022-01-09 op proc->args[i] = xstrdup(op->v.var);
1245 fb1a36c0 2022-01-09 op
1246 fb1a36c0 2022-01-09 op next = op->next;
1247 fb1a36c0 2022-01-09 op free_op(op);
1248 fb1a36c0 2022-01-09 op op = next;
1249 fb1a36c0 2022-01-09 op }
1250 fb1a36c0 2022-01-09 op assert(i == argc || (proc->vararg && i == proc->minargs));
1251 fb1a36c0 2022-01-09 op
1252 fb1a36c0 2022-01-09 op proc->body = body;
1253 fb1a36c0 2022-01-09 op
1254 fb1a36c0 2022-01-09 op TAILQ_INSERT_HEAD(&procs, proc, entry);
1255 fb1a36c0 2022-01-09 op }
1256 fb1a36c0 2022-01-09 op
1257 fb1a36c0 2022-01-09 op void
1258 fb1a36c0 2022-01-09 op block_push(struct op *op)
1259 fb1a36c0 2022-01-09 op {
1260 fb1a36c0 2022-01-09 op push(&blocks, op);
1261 fb1a36c0 2022-01-09 op }
1262 fb1a36c0 2022-01-09 op
1263 fb1a36c0 2022-01-09 op struct proc *
1264 fb1a36c0 2022-01-09 op proc_by_name(const char *name)
1265 fb1a36c0 2022-01-09 op {
1266 fb1a36c0 2022-01-09 op struct proc *p;
1267 fb1a36c0 2022-01-09 op
1268 fb1a36c0 2022-01-09 op TAILQ_FOREACH(p, &procs, entry) {
1269 fb1a36c0 2022-01-09 op if (!strcmp(p->name, name))
1270 fb1a36c0 2022-01-09 op return p;
1271 fb1a36c0 2022-01-09 op }
1272 fb1a36c0 2022-01-09 op
1273 fb1a36c0 2022-01-09 op return NULL;
1274 fb1a36c0 2022-01-09 op }
1275 fb1a36c0 2022-01-09 op
1276 fb1a36c0 2022-01-09 op void
1277 fb1a36c0 2022-01-09 op prepare_test(void)
1278 fb1a36c0 2022-01-09 op {
1279 fb1a36c0 2022-01-09 op pushstack(&blocks);
1280 fb1a36c0 2022-01-09 op }
1281 fb1a36c0 2022-01-09 op
1282 fb1a36c0 2022-01-09 op void
1283 fb1a36c0 2022-01-09 op test_done(int shouldfail, char *name, char *dir)
1284 fb1a36c0 2022-01-09 op {
1285 fb1a36c0 2022-01-09 op struct test *test;
1286 fb1a36c0 2022-01-09 op
1287 fb1a36c0 2022-01-09 op test = xcalloc(1, sizeof(*test));
1288 fb1a36c0 2022-01-09 op test->shouldfail = shouldfail;
1289 fb1a36c0 2022-01-09 op test->name = name;
1290 fb1a36c0 2022-01-09 op test->dir = dir;
1291 fb1a36c0 2022-01-09 op test->body = finalize(&blocks, NULL);
1292 fb1a36c0 2022-01-09 op
1293 fb1a36c0 2022-01-09 op if (TAILQ_EMPTY(&tests))
1294 fb1a36c0 2022-01-09 op TAILQ_INSERT_HEAD(&tests, test, entry);
1295 fb1a36c0 2022-01-09 op else
1296 fb1a36c0 2022-01-09 op TAILQ_INSERT_TAIL(&tests, test, entry);
1297 fb1a36c0 2022-01-09 op
1298 fb1a36c0 2022-01-09 op ntests++;
1299 fb1a36c0 2022-01-09 op }
1300 fb1a36c0 2022-01-09 op
1301 fb1a36c0 2022-01-09 op static int
1302 fb1a36c0 2022-01-09 op builtin_print(int argc)
1303 fb1a36c0 2022-01-09 op {
1304 fb1a36c0 2022-01-09 op struct value v;
1305 fb1a36c0 2022-01-09 op int i;
1306 fb1a36c0 2022-01-09 op
1307 fb1a36c0 2022-01-09 op before_printing();
1308 fb1a36c0 2022-01-09 op
1309 fb1a36c0 2022-01-09 op for (i = argc; i > 0; --i) {
1310 fb1a36c0 2022-01-09 op peekn(i, &v);
1311 fb1a36c0 2022-01-09 op if (v.type == V_STR)
1312 fb1a36c0 2022-01-09 op printf("%s", v.v.str);
1313 fb1a36c0 2022-01-09 op else
1314 fb1a36c0 2022-01-09 op pp_val(&v);
1315 fb1a36c0 2022-01-09 op printf(" ");
1316 fb1a36c0 2022-01-09 op }
1317 fb1a36c0 2022-01-09 op
1318 fb1a36c0 2022-01-09 op printf("\n");
1319 fb1a36c0 2022-01-09 op
1320 fb1a36c0 2022-01-09 op popvn(argc);
1321 fb1a36c0 2022-01-09 op
1322 fb1a36c0 2022-01-09 op return EVAL_OK;
1323 fb1a36c0 2022-01-09 op }
1324 fb1a36c0 2022-01-09 op
1325 fb1a36c0 2022-01-09 op static int
1326 fb1a36c0 2022-01-09 op builtin_debug(int argc)
1327 fb1a36c0 2022-01-09 op {
1328 fb1a36c0 2022-01-09 op if (debug)
1329 fb1a36c0 2022-01-09 op return builtin_print(argc);
1330 fb1a36c0 2022-01-09 op
1331 fb1a36c0 2022-01-09 op popvn(argc);
1332 fb1a36c0 2022-01-09 op return EVAL_OK;
1333 fb1a36c0 2022-01-09 op }
1334 fb1a36c0 2022-01-09 op
1335 fb1a36c0 2022-01-09 op static int
1336 fb1a36c0 2022-01-09 op builtin_skip(int argc)
1337 fb1a36c0 2022-01-09 op {
1338 fb1a36c0 2022-01-09 op return EVAL_SKIP;
1339 fb1a36c0 2022-01-09 op }
1340 fb1a36c0 2022-01-09 op
1341 fb1a36c0 2022-01-09 op static int
1342 fb1a36c0 2022-01-09 op builtin_iota(int argc)
1343 fb1a36c0 2022-01-09 op {
1344 fb1a36c0 2022-01-09 op struct value v;
1345 fb1a36c0 2022-01-09 op
1346 fb1a36c0 2022-01-09 op v.type = V_U16;
1347 fb1a36c0 2022-01-09 op if ((v.v.u16 = ++lasttag) == 255)
1348 fb1a36c0 2022-01-09 op v.v.u16 = ++lasttag;
1349 fb1a36c0 2022-01-09 op
1350 fb1a36c0 2022-01-09 op pushv(&v);
1351 fb1a36c0 2022-01-09 op return EVAL_OK;
1352 fb1a36c0 2022-01-09 op }
1353 fb1a36c0 2022-01-09 op
1354 fb1a36c0 2022-01-09 op static int
1355 fb1a36c0 2022-01-09 op builtin_send(int argc)
1356 fb1a36c0 2022-01-09 op {
1357 fb1a36c0 2022-01-09 op struct ibuf *buf;
1358 fb1a36c0 2022-01-09 op struct value v;
1359 fb1a36c0 2022-01-09 op uint32_t len;
1360 fb1a36c0 2022-01-09 op uint16_t slen;
1361 fb1a36c0 2022-01-09 op int i;
1362 fb1a36c0 2022-01-09 op
1363 fb1a36c0 2022-01-09 op check_for_output();
1364 fb1a36c0 2022-01-09 op
1365 fb1a36c0 2022-01-09 op /*
1366 fb1a36c0 2022-01-09 op * Compute the length of the packet. 4 is for the initial
1367 fb1a36c0 2022-01-09 op * length field
1368 fb1a36c0 2022-01-09 op */
1369 fb1a36c0 2022-01-09 op len = 4;
1370 fb1a36c0 2022-01-09 op
1371 fb1a36c0 2022-01-09 op for (i = argc; i > 0; --i) {
1372 fb1a36c0 2022-01-09 op peekn(i, &v);
1373 fb1a36c0 2022-01-09 op switch (v.type) {
1374 fb1a36c0 2022-01-09 op case V_STR:
1375 fb1a36c0 2022-01-09 op len += 2; /* count */
1376 fb1a36c0 2022-01-09 op len += strlen(v.v.str);
1377 fb1a36c0 2022-01-09 op break;
1378 fb1a36c0 2022-01-09 op
1379 fb1a36c0 2022-01-09 op case V_U8:
1380 fb1a36c0 2022-01-09 op len += 1;
1381 fb1a36c0 2022-01-09 op break;
1382 fb1a36c0 2022-01-09 op
1383 fb1a36c0 2022-01-09 op case V_U16:
1384 fb1a36c0 2022-01-09 op len += 2;
1385 fb1a36c0 2022-01-09 op break;
1386 fb1a36c0 2022-01-09 op
1387 fb1a36c0 2022-01-09 op case V_U32:
1388 fb1a36c0 2022-01-09 op len += 4;
1389 fb1a36c0 2022-01-09 op break;
1390 fb1a36c0 2022-01-09 op
1391 fb1a36c0 2022-01-09 op default:
1392 fb1a36c0 2022-01-09 op before_printing();
1393 fb1a36c0 2022-01-09 op printf("%s: can't serialize ", __func__);
1394 fb1a36c0 2022-01-09 op pp_val(&v);
1395 fb1a36c0 2022-01-09 op printf("\n");
1396 fb1a36c0 2022-01-09 op return EVAL_ERR;
1397 fb1a36c0 2022-01-09 op }
1398 fb1a36c0 2022-01-09 op }
1399 fb1a36c0 2022-01-09 op
1400 fb1a36c0 2022-01-09 op if (len > UINT16_MAX) {
1401 fb1a36c0 2022-01-09 op before_printing();
1402 fb1a36c0 2022-01-09 op printf("%s: message size too long: got %d when max is %d\n",
1403 fb1a36c0 2022-01-09 op __func__, len, UINT16_MAX);
1404 fb1a36c0 2022-01-09 op return EVAL_ERR;
1405 fb1a36c0 2022-01-09 op }
1406 fb1a36c0 2022-01-09 op
1407 fb1a36c0 2022-01-09 op if ((buf = imsg_create(&ibuf, IMSG_BUF, 0, 0, len)) == NULL)
1408 fb1a36c0 2022-01-09 op fatal("imsg_create(%d)", len);
1409 fb1a36c0 2022-01-09 op
1410 fb1a36c0 2022-01-09 op len = htole32(len);
1411 fb1a36c0 2022-01-09 op imsg_add(buf, &len, sizeof(len));
1412 fb1a36c0 2022-01-09 op
1413 fb1a36c0 2022-01-09 op for (i = argc; i > 0; --i) {
1414 fb1a36c0 2022-01-09 op peekn(i, &v);
1415 fb1a36c0 2022-01-09 op switch (v.type) {
1416 fb1a36c0 2022-01-09 op case V_STR:
1417 fb1a36c0 2022-01-09 op slen = strlen(v.v.str);
1418 fb1a36c0 2022-01-09 op slen = htole16(slen);
1419 fb1a36c0 2022-01-09 op imsg_add(buf, &slen, sizeof(slen));
1420 fb1a36c0 2022-01-09 op imsg_add(buf, v.v.str, strlen(v.v.str));
1421 fb1a36c0 2022-01-09 op break;
1422 fb1a36c0 2022-01-09 op
1423 fb1a36c0 2022-01-09 op case V_U8:
1424 fb1a36c0 2022-01-09 op imsg_add(buf, &v.v.u8, 1);
1425 fb1a36c0 2022-01-09 op break;
1426 fb1a36c0 2022-01-09 op
1427 fb1a36c0 2022-01-09 op case V_U16:
1428 fb1a36c0 2022-01-09 op v.v.u16 = htole16(v.v.u16);
1429 fb1a36c0 2022-01-09 op imsg_add(buf, &v.v.u16, 2);
1430 fb1a36c0 2022-01-09 op break;
1431 fb1a36c0 2022-01-09 op
1432 fb1a36c0 2022-01-09 op case V_U32:
1433 fb1a36c0 2022-01-09 op v.v.u32 = htole32(v.v.u32);
1434 fb1a36c0 2022-01-09 op imsg_add(buf, &v.v.u32, 4);
1435 fb1a36c0 2022-01-09 op break;
1436 fb1a36c0 2022-01-09 op }
1437 fb1a36c0 2022-01-09 op }
1438 fb1a36c0 2022-01-09 op
1439 fb1a36c0 2022-01-09 op imsg_close(&ibuf, buf);
1440 fb1a36c0 2022-01-09 op
1441 fb1a36c0 2022-01-09 op if (imsg_flush(&ibuf) == -1) {
1442 fb1a36c0 2022-01-09 op i = errno;
1443 fb1a36c0 2022-01-09 op before_printing();
1444 fb1a36c0 2022-01-09 op printf("%s: imsg_flush failed: %s\n", __func__, strerror(i));
1445 fb1a36c0 2022-01-09 op return EVAL_ERR;
1446 fb1a36c0 2022-01-09 op }
1447 fb1a36c0 2022-01-09 op
1448 fb1a36c0 2022-01-09 op check_for_output();
1449 fb1a36c0 2022-01-09 op return EVAL_OK;
1450 fb1a36c0 2022-01-09 op }
1451 fb1a36c0 2022-01-09 op
1452 fb1a36c0 2022-01-09 op static int
1453 fb1a36c0 2022-01-09 op builtin_recv(int argc)
1454 fb1a36c0 2022-01-09 op {
1455 fb1a36c0 2022-01-09 op struct pollfd pfd;
1456 fb1a36c0 2022-01-09 op struct value v;
1457 fb1a36c0 2022-01-09 op struct imsg imsg;
1458 fb1a36c0 2022-01-09 op ssize_t n, datalen;
1459 fb1a36c0 2022-01-09 op int serrno;
1460 fb1a36c0 2022-01-09 op
1461 fb1a36c0 2022-01-09 op if (lastmsg != NULL) {
1462 fb1a36c0 2022-01-09 op free(lastmsg);
1463 fb1a36c0 2022-01-09 op lastmsg = NULL;
1464 fb1a36c0 2022-01-09 op }
1465 fb1a36c0 2022-01-09 op
1466 fb1a36c0 2022-01-09 op pfd.fd = ibuf.fd;
1467 fb1a36c0 2022-01-09 op pfd.events = POLLIN;
1468 fb1a36c0 2022-01-09 op if (poll(&pfd, 1, INFTIM) == -1) {
1469 fb1a36c0 2022-01-09 op serrno = errno;
1470 fb1a36c0 2022-01-09 op before_printing();
1471 fb1a36c0 2022-01-09 op printf("%s: poll failed: %s\n", __func__, strerror(serrno));
1472 fb1a36c0 2022-01-09 op return EVAL_ERR;
1473 fb1a36c0 2022-01-09 op }
1474 fb1a36c0 2022-01-09 op
1475 fb1a36c0 2022-01-09 op again:
1476 fb1a36c0 2022-01-09 op if ((n = imsg_read(&ibuf)) == -1) {
1477 fb1a36c0 2022-01-09 op if (errno == EAGAIN)
1478 fb1a36c0 2022-01-09 op goto again;
1479 fb1a36c0 2022-01-09 op fatal("imsg_read");
1480 fb1a36c0 2022-01-09 op }
1481 fb1a36c0 2022-01-09 op if (n == 0) {
1482 fb1a36c0 2022-01-09 op disconnect:
1483 fb1a36c0 2022-01-09 op before_printing();
1484 fb1a36c0 2022-01-09 op printf("child disconnected\n");
1485 fb1a36c0 2022-01-09 op return EVAL_ERR;
1486 fb1a36c0 2022-01-09 op }
1487 fb1a36c0 2022-01-09 op
1488 fb1a36c0 2022-01-09 op nextmessage:
1489 fb1a36c0 2022-01-09 op check_for_output();
1490 fb1a36c0 2022-01-09 op
1491 fb1a36c0 2022-01-09 op /* read only one message */
1492 fb1a36c0 2022-01-09 op if ((n = imsg_get(&ibuf, &imsg)) == -1)
1493 fb1a36c0 2022-01-09 op fatal("imsg_get");
1494 fb1a36c0 2022-01-09 op if (n == 0)
1495 fb1a36c0 2022-01-09 op goto disconnect;
1496 fb1a36c0 2022-01-09 op
1497 fb1a36c0 2022-01-09 op datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
1498 fb1a36c0 2022-01-09 op switch (imsg.hdr.type) {
1499 fb1a36c0 2022-01-09 op case IMSG_BUF:
1500 fb1a36c0 2022-01-09 op v.type = V_MSG;
1501 fb1a36c0 2022-01-09 op if ((v.v.msg.msg = malloc(datalen)) == NULL)
1502 fb1a36c0 2022-01-09 op fatal("malloc");
1503 fb1a36c0 2022-01-09 op memcpy(v.v.msg.msg, imsg.data, datalen);
1504 fb1a36c0 2022-01-09 op v.v.msg.len = datalen;
1505 fb1a36c0 2022-01-09 op pushv(&v);
1506 fb1a36c0 2022-01-09 op imsg_free(&imsg);
1507 fb1a36c0 2022-01-09 op return EVAL_OK;
1508 fb1a36c0 2022-01-09 op
1509 fb1a36c0 2022-01-09 op case IMSG_CLOSE:
1510 fb1a36c0 2022-01-09 op before_printing();
1511 fb1a36c0 2022-01-09 op printf("subprocess closed the connection\n");
1512 fb1a36c0 2022-01-09 op imsg_free(&imsg);
1513 fb1a36c0 2022-01-09 op return EVAL_ERR;
1514 fb1a36c0 2022-01-09 op
1515 fb1a36c0 2022-01-09 op case IMSG_MSIZE:
1516 fb1a36c0 2022-01-09 op imsg_free(&imsg);
1517 fb1a36c0 2022-01-09 op goto nextmessage;
1518 fb1a36c0 2022-01-09 op
1519 fb1a36c0 2022-01-09 op default:
1520 fb1a36c0 2022-01-09 op before_printing();
1521 fb1a36c0 2022-01-09 op printf("got unknown message from subprocess: %d\n",
1522 fb1a36c0 2022-01-09 op imsg.hdr.type);
1523 fb1a36c0 2022-01-09 op imsg_free(&imsg);
1524 fb1a36c0 2022-01-09 op return EVAL_ERR;
1525 fb1a36c0 2022-01-09 op }
1526 fb1a36c0 2022-01-09 op }
1527 fb1a36c0 2022-01-09 op
1528 fb1a36c0 2022-01-09 op static pid_t
1529 fb1a36c0 2022-01-09 op spawn_client_proc(void)
1530 fb1a36c0 2022-01-09 op {
1531 fb1a36c0 2022-01-09 op const char *argv[4];
1532 fb1a36c0 2022-01-09 op int p[2], out[2], argc = 0;
1533 fb1a36c0 2022-01-09 op pid_t pid;
1534 fb1a36c0 2022-01-09 op
1535 fb1a36c0 2022-01-09 op if (child_out != -1)
1536 fb1a36c0 2022-01-09 op close(child_out);
1537 fb1a36c0 2022-01-09 op
1538 fb1a36c0 2022-01-09 op if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
1539 fb1a36c0 2022-01-09 op PF_UNSPEC, p) == -1)
1540 fb1a36c0 2022-01-09 op fatal("socketpair");
1541 fb1a36c0 2022-01-09 op
1542 fb1a36c0 2022-01-09 op if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
1543 fb1a36c0 2022-01-09 op PF_UNSPEC, out) == -1)
1544 fb1a36c0 2022-01-09 op fatal("socketpair");
1545 fb1a36c0 2022-01-09 op
1546 fb1a36c0 2022-01-09 op switch (pid = fork()) {
1547 fb1a36c0 2022-01-09 op case -1:
1548 fb1a36c0 2022-01-09 op fatal("cannot fork");
1549 fb1a36c0 2022-01-09 op case 0:
1550 fb1a36c0 2022-01-09 op break;
1551 fb1a36c0 2022-01-09 op default:
1552 fb1a36c0 2022-01-09 op close(p[1]);
1553 fb1a36c0 2022-01-09 op close(out[1]);
1554 fb1a36c0 2022-01-09 op child_out = out[0];
1555 fb1a36c0 2022-01-09 op if (ibuf_inuse) {
1556 fb1a36c0 2022-01-09 op msgbuf_clear(&ibuf.w);
1557 fb1a36c0 2022-01-09 op close(ibuf.fd);
1558 fb1a36c0 2022-01-09 op }
1559 fb1a36c0 2022-01-09 op imsg_init(&ibuf, p[0]);
1560 fb1a36c0 2022-01-09 op ibuf_inuse = 1;
1561 fb1a36c0 2022-01-09 op return pid;
1562 fb1a36c0 2022-01-09 op }
1563 fb1a36c0 2022-01-09 op
1564 fb1a36c0 2022-01-09 op close(p[0]);
1565 fb1a36c0 2022-01-09 op close(out[0]);
1566 fb1a36c0 2022-01-09 op
1567 fb1a36c0 2022-01-09 op if (dup2(out[1], 1) == -1 ||
1568 fb1a36c0 2022-01-09 op dup2(out[1], 2) == -1)
1569 fb1a36c0 2022-01-09 op fatal("dup2");
1570 fb1a36c0 2022-01-09 op
1571 fb1a36c0 2022-01-09 op if (p[1] != 3) {
1572 fb1a36c0 2022-01-09 op if (dup2(p[1], 3) == -1)
1573 fb1a36c0 2022-01-09 op fatal("cannot setup imsg fd");
1574 fb1a36c0 2022-01-09 op } else if (fcntl(F_SETFD, 0) == -1)
1575 fb1a36c0 2022-01-09 op fatal("cannot setup imsg fd");
1576 fb1a36c0 2022-01-09 op
1577 fb1a36c0 2022-01-09 op argv[argc++] = argv0;
1578 fb1a36c0 2022-01-09 op argv[argc++] = "-Tc";
1579 fb1a36c0 2022-01-09 op
1580 fb1a36c0 2022-01-09 op #if DEBUG
1581 fb1a36c0 2022-01-09 op argv[argc++] = "-v";
1582 fb1a36c0 2022-01-09 op #endif
1583 fb1a36c0 2022-01-09 op
1584 fb1a36c0 2022-01-09 op argv[argc++] = NULL;
1585 fb1a36c0 2022-01-09 op
1586 fb1a36c0 2022-01-09 op execvp(argv0, (char *const *)argv);
1587 fb1a36c0 2022-01-09 op fatal("execvp");
1588 fb1a36c0 2022-01-09 op }
1589 fb1a36c0 2022-01-09 op
1590 fb1a36c0 2022-01-09 op static void
1591 fb1a36c0 2022-01-09 op prepare_child_for_test(struct test *t)
1592 fb1a36c0 2022-01-09 op {
1593 fb1a36c0 2022-01-09 op struct passwd *pw;
1594 fb1a36c0 2022-01-09 op struct stat sb;
1595 fb1a36c0 2022-01-09 op
1596 fb1a36c0 2022-01-09 op if (stat(t->dir, &sb) == -1)
1597 fb1a36c0 2022-01-09 op fatal("stat(\"%s\")", t->dir);
1598 fb1a36c0 2022-01-09 op
1599 fb1a36c0 2022-01-09 op if ((pw = getpwuid(sb.st_uid)) == NULL)
1600 fb1a36c0 2022-01-09 op fatal("getpwuid(%d)", sb.st_uid);
1601 fb1a36c0 2022-01-09 op
1602 fb1a36c0 2022-01-09 op imsg_compose(&ibuf, IMSG_AUTH, 0, 0, -1,
1603 fb1a36c0 2022-01-09 op pw->pw_name, strlen(pw->pw_name)+1);
1604 fb1a36c0 2022-01-09 op imsg_compose(&ibuf, IMSG_AUTH_DIR, 0, 0, -1,
1605 fb1a36c0 2022-01-09 op t->dir, strlen(t->dir)+1);
1606 fb1a36c0 2022-01-09 op
1607 fb1a36c0 2022-01-09 op if (imsg_flush(&ibuf) == -1)
1608 fb1a36c0 2022-01-09 op fatal("imsg_flush");
1609 fb1a36c0 2022-01-09 op }
1610 fb1a36c0 2022-01-09 op
1611 fb1a36c0 2022-01-09 op static int
1612 fb1a36c0 2022-01-09 op run_test(struct test *t)
1613 fb1a36c0 2022-01-09 op {
1614 fb1a36c0 2022-01-09 op pid_t pid;
1615 fb1a36c0 2022-01-09 op int ret;
1616 fb1a36c0 2022-01-09 op
1617 fb1a36c0 2022-01-09 op #if DEBUG
1618 fb1a36c0 2022-01-09 op before_printing();
1619 fb1a36c0 2022-01-09 op puts("=====================");
1620 fb1a36c0 2022-01-09 op pp_block(t->body);
1621 fb1a36c0 2022-01-09 op puts("=====================");
1622 fb1a36c0 2022-01-09 op #endif
1623 fb1a36c0 2022-01-09 op
1624 fb1a36c0 2022-01-09 op if (stackh != 0)
1625 fb1a36c0 2022-01-09 op popvn(stackh);
1626 fb1a36c0 2022-01-09 op
1627 fb1a36c0 2022-01-09 op if (t->body == NULL) {
1628 fb1a36c0 2022-01-09 op before_printing();
1629 fb1a36c0 2022-01-09 op printf("no instructions, skipping...\n");
1630 fb1a36c0 2022-01-09 op return EVAL_SKIP;
1631 fb1a36c0 2022-01-09 op }
1632 fb1a36c0 2022-01-09 op
1633 fb1a36c0 2022-01-09 op pid = spawn_client_proc();
1634 fb1a36c0 2022-01-09 op prepare_child_for_test(t);
1635 fb1a36c0 2022-01-09 op ret = eval(t->body);
1636 fb1a36c0 2022-01-09 op
1637 fb1a36c0 2022-01-09 op imsg_compose(&ibuf, IMSG_CONN_GONE, 0, 0, -1, NULL, 0);
1638 fb1a36c0 2022-01-09 op imsg_flush(&ibuf);
1639 fb1a36c0 2022-01-09 op
1640 fb1a36c0 2022-01-09 op while (waitpid(pid, NULL, 0) != pid)
1641 fb1a36c0 2022-01-09 op ; /* nop */
1642 fb1a36c0 2022-01-09 op
1643 fb1a36c0 2022-01-09 op check_for_output();
1644 fb1a36c0 2022-01-09 op
1645 fb1a36c0 2022-01-09 op if (t->shouldfail) {
1646 fb1a36c0 2022-01-09 op if (ret == EVAL_OK) {
1647 fb1a36c0 2022-01-09 op before_printing();
1648 fb1a36c0 2022-01-09 op printf("test was expected to fail\n");
1649 fb1a36c0 2022-01-09 op return EVAL_ERR;
1650 fb1a36c0 2022-01-09 op } else if (ret == EVAL_ERR)
1651 fb1a36c0 2022-01-09 op return EVAL_OK;
1652 fb1a36c0 2022-01-09 op }
1653 fb1a36c0 2022-01-09 op
1654 fb1a36c0 2022-01-09 op return ret;
1655 fb1a36c0 2022-01-09 op }
1656 fb1a36c0 2022-01-09 op
1657 fb1a36c0 2022-01-09 op int
1658 fb1a36c0 2022-01-09 op main(int argc, char **argv)
1659 fb1a36c0 2022-01-09 op {
1660 fb1a36c0 2022-01-09 op struct test *t;
1661 fb1a36c0 2022-01-09 op int ch, i, r, passed = 0, failed = 0, skipped = 0;
1662 fb1a36c0 2022-01-09 op int runclient = 0;
1663 fb1a36c0 2022-01-09 op const char *pat = NULL;
1664 fb1a36c0 2022-01-09 op regex_t reg;
1665 fb1a36c0 2022-01-09 op
1666 fb1a36c0 2022-01-09 op assert(argv0 = argv[0]);
1667 fb1a36c0 2022-01-09 op
1668 fb1a36c0 2022-01-09 op signal(SIGPIPE, SIG_IGN);
1669 fb1a36c0 2022-01-09 op
1670 fb1a36c0 2022-01-09 op log_init(1, LOG_DAEMON);
1671 fb1a36c0 2022-01-09 op log_setverbose(1);
1672 fb1a36c0 2022-01-09 op
1673 fb1a36c0 2022-01-09 op /* prepare the global env */
1674 fb1a36c0 2022-01-09 op pushenv();
1675 fb1a36c0 2022-01-09 op
1676 fb1a36c0 2022-01-09 op add_builtin_proc("print", builtin_print, 1, 1);
1677 fb1a36c0 2022-01-09 op add_builtin_proc("debug", builtin_debug, 1, 1);
1678 fb1a36c0 2022-01-09 op add_builtin_proc("skip", builtin_skip, 0, 0);
1679 fb1a36c0 2022-01-09 op add_builtin_proc("iota", builtin_iota, 0, 0);
1680 fb1a36c0 2022-01-09 op add_builtin_proc("send", builtin_send, 2, 1);
1681 fb1a36c0 2022-01-09 op add_builtin_proc("recv", builtin_recv, 0, 0);
1682 fb1a36c0 2022-01-09 op
1683 fb1a36c0 2022-01-09 op while ((ch = getopt(argc, argv, "nT:vx:")) != -1) {
1684 fb1a36c0 2022-01-09 op switch (ch) {
1685 fb1a36c0 2022-01-09 op case 'n':
1686 fb1a36c0 2022-01-09 op syntaxcheck = 1;
1687 fb1a36c0 2022-01-09 op break;
1688 fb1a36c0 2022-01-09 op case 'T':
1689 fb1a36c0 2022-01-09 op assert(*optarg == 'c');
1690 fb1a36c0 2022-01-09 op runclient = 1;
1691 fb1a36c0 2022-01-09 op break;
1692 fb1a36c0 2022-01-09 op case 'v':
1693 fb1a36c0 2022-01-09 op debug = 1;
1694 fb1a36c0 2022-01-09 op break;
1695 fb1a36c0 2022-01-09 op case 'x':
1696 fb1a36c0 2022-01-09 op pat = optarg;
1697 fb1a36c0 2022-01-09 op break;
1698 fb1a36c0 2022-01-09 op default:
1699 fb1a36c0 2022-01-09 op fprintf(stderr, "Usage: %s [-nv] [files...]\n",
1700 fb1a36c0 2022-01-09 op *argv);
1701 fb1a36c0 2022-01-09 op exit(1);
1702 fb1a36c0 2022-01-09 op }
1703 fb1a36c0 2022-01-09 op }
1704 fb1a36c0 2022-01-09 op argc -= optind;
1705 fb1a36c0 2022-01-09 op argv += optind;
1706 fb1a36c0 2022-01-09 op
1707 fb1a36c0 2022-01-09 op if (runclient)
1708 fb1a36c0 2022-01-09 op client(1, debug);
1709 fb1a36c0 2022-01-09 op
1710 fb1a36c0 2022-01-09 op if (pat == NULL)
1711 fb1a36c0 2022-01-09 op pat = ".*";
1712 fb1a36c0 2022-01-09 op
1713 ba8b636b 2022-01-09 op if (regcomp(&reg, pat, REG_ICASE | REG_NOSUB) != 0)
1714 fb1a36c0 2022-01-09 op fatalx("invalid regexp: %s", pat);
1715 fb1a36c0 2022-01-09 op
1716 fb1a36c0 2022-01-09 op for (i = 0; i < argc; ++i)
1717 fb1a36c0 2022-01-09 op loadfile(argv[i]);
1718 fb1a36c0 2022-01-09 op
1719 fb1a36c0 2022-01-09 op if (syntaxcheck) {
1720 fb1a36c0 2022-01-09 op fprintf(stderr, "files OK\n");
1721 fb1a36c0 2022-01-09 op return 0;
1722 fb1a36c0 2022-01-09 op }
1723 fb1a36c0 2022-01-09 op
1724 fb1a36c0 2022-01-09 op /* Check for root privileges. */
1725 fb1a36c0 2022-01-09 op if (geteuid())
1726 fb1a36c0 2022-01-09 op fatalx("need root privileges");
1727 fb1a36c0 2022-01-09 op
1728 fb1a36c0 2022-01-09 op i = 0;
1729 fb1a36c0 2022-01-09 op TAILQ_FOREACH(t, &tests, entry) {
1730 fb1a36c0 2022-01-09 op if (regexec(&reg, t->name, 0, NULL, 0) != 0)
1731 fb1a36c0 2022-01-09 op continue;
1732 fb1a36c0 2022-01-09 op
1733 fb1a36c0 2022-01-09 op printf("===> [%d/%d] running test \"%s\"... ", i+1, ntests,
1734 fb1a36c0 2022-01-09 op t->name);
1735 fb1a36c0 2022-01-09 op fflush(stdout);
1736 fb1a36c0 2022-01-09 op
1737 fb1a36c0 2022-01-09 op filler = "\n";
1738 fb1a36c0 2022-01-09 op r = run_test(t);
1739 fb1a36c0 2022-01-09 op if (filler == NULL)
1740 fb1a36c0 2022-01-09 op printf("=> test ");
1741 fb1a36c0 2022-01-09 op
1742 fb1a36c0 2022-01-09 op switch (r) {
1743 fb1a36c0 2022-01-09 op case EVAL_OK:
1744 fb1a36c0 2022-01-09 op printf("passed\n");
1745 fb1a36c0 2022-01-09 op passed++;
1746 fb1a36c0 2022-01-09 op break;
1747 fb1a36c0 2022-01-09 op case EVAL_ERR:
1748 fb1a36c0 2022-01-09 op failed++;
1749 fb1a36c0 2022-01-09 op printf("failed\n");
1750 fb1a36c0 2022-01-09 op break;
1751 fb1a36c0 2022-01-09 op case EVAL_SKIP:
1752 fb1a36c0 2022-01-09 op printf("skipped\n");
1753 fb1a36c0 2022-01-09 op skipped++;
1754 fb1a36c0 2022-01-09 op break;
1755 fb1a36c0 2022-01-09 op }
1756 fb1a36c0 2022-01-09 op
1757 fb1a36c0 2022-01-09 op if (filler == NULL)
1758 fb1a36c0 2022-01-09 op printf("\n");
1759 fb1a36c0 2022-01-09 op i++;
1760 fb1a36c0 2022-01-09 op }
1761 fb1a36c0 2022-01-09 op
1762 fb1a36c0 2022-01-09 op printf("\n");
1763 fb1a36c0 2022-01-09 op printf("%d/%d passed (%d skipped and %d failed)\n",
1764 fb1a36c0 2022-01-09 op passed, i, skipped, failed);
1765 fb1a36c0 2022-01-09 op
1766 fb1a36c0 2022-01-09 op popenv();
1767 fb1a36c0 2022-01-09 op free(lastmsg);
1768 fb1a36c0 2022-01-09 op regfree(&reg);
1769 fb1a36c0 2022-01-09 op
1770 fb1a36c0 2022-01-09 op return failed != 0;
1771 fb1a36c0 2022-01-09 op }