source: mainline/uspace/app/bithenge/script.c@ ad5c8a48

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since ad5c8a48 was ad5c8a48, checked in by Sean Bartell <wingedtachikoma@…>, 13 years ago

Bithenge: add expressions with binary operators
  • Property mode set to 100644
File size: 26.7 KB
Line 
1/*
2 * Copyright (c) 2012 Sean Bartell
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup bithenge
30 * @{
31 */
32/**
33 * @file
34 * Script parsing.
35 */
36
37#include <ctype.h>
38#include <stdio.h>
39#include <stdlib.h>
40#include "expression.h"
41#include "os.h"
42#include "script.h"
43#include "sequence.h"
44#include "transform.h"
45#include "tree.h"
46
47/** Tokens with more characters than this may be read incorrectly. */
48#define MAX_TOKEN_SIZE 256
49#define BUFFER_SIZE 4096
50
51/** Single-character symbols are represented by the character itself. Every
52 * other token uses one of these values: */
53typedef enum {
54 TOKEN_EQUALS = -128,
55 TOKEN_ERROR,
56 TOKEN_EOF,
57 TOKEN_IDENTIFIER,
58 TOKEN_INTEGER,
59 TOKEN_LEFT_ARROW,
60
61 /* Keywords */
62 TOKEN_DO,
63 TOKEN_ELSE,
64 TOKEN_FALSE,
65 TOKEN_IF,
66 TOKEN_REPEAT,
67 TOKEN_STRUCT,
68 TOKEN_SWITCH,
69 TOKEN_TRANSFORM,
70 TOKEN_TRUE,
71 TOKEN_WHILE,
72} token_type_t;
73
74/** Singly-linked list of named transforms. */
75typedef struct transform_list {
76 char *name;
77 bithenge_transform_t *transform;
78 struct transform_list *next;
79} transform_list_t;
80
81/** State kept by the parser. */
82typedef struct {
83 /** Rather than constantly checking return values, the parser uses this
84 * to indicate whether an error has occurred. */
85 int error;
86
87 /** The list of named transforms. */
88 transform_list_t *transform_list;
89
90 /** The name of the script file. */
91 const char *filename;
92 /** The script file being read from. */
93 FILE *file;
94 /** The buffer that holds script code. There is always a '\0' after the
95 * current position to prevent reading too far. */
96 char buffer[BUFFER_SIZE];
97 /** The start position within the buffer of the next unread token. */
98 size_t buffer_pos;
99 /** The start position within the buffer of the current token. */
100 size_t old_buffer_pos;
101 /** The line number of the current token. */
102 int lineno;
103 /** Added to a buffer position to find the column number. */
104 int line_offset;
105
106 /** The type of the current token. */
107 token_type_t token;
108 union {
109 /** The value of a TOKEN_IDENTIFIER token. Unless changed to
110 * NULL, it will be freed when the next token is read. */
111 char *token_string;
112 /** The value of a TOKEN_INTEGER token. */
113 bithenge_int_t token_int;
114 };
115
116 /** The names of the current transform's parameters. */
117 char **parameter_names;
118 /** The number of parameters. */
119 int num_params;
120} state_t;
121
122/** Free the previous token's data. This must be called before changing
123 * state->token. */
124static void done_with_token(state_t *state)
125{
126 if (state->token == TOKEN_IDENTIFIER)
127 free(state->token_string);
128 state->token = TOKEN_ERROR;
129}
130
131/** Note that an error has occurred if error is not EOK. */
132static void error_errno(state_t *state, int error)
133{
134 // Don't overwrite a previous error.
135 if (state->error == EOK && error != EOK) {
136 done_with_token(state);
137 state->token = TOKEN_ERROR;
138 state->error = error;
139 }
140}
141
142/** Note that a syntax error has occurred and print an error message. */
143static void syntax_error(state_t *state, const char *message)
144{
145 // Printing multiple errors is confusing.
146 if (state->error == EOK) {
147 size_t start_char = state->old_buffer_pos + state->line_offset;
148 size_t end_char = state->buffer_pos + state->line_offset;
149 size_t size = end_char - start_char;
150 fprintf(stderr, "%s:%d:", state->filename, state->lineno);
151 if (size <= 1)
152 fprintf(stderr, "%zd: ", start_char);
153 else
154 fprintf(stderr, "%zd-%zd: ", start_char, end_char - 1);
155 fprintf(stderr, "%s: \"%.*s\"\n", message, (int)size,
156 state->buffer + state->old_buffer_pos);
157 error_errno(state, EINVAL);
158 }
159}
160
161/** Ensure the buffer contains enough characters to read a token. */
162static void fill_buffer(state_t *state)
163{
164 if (state->buffer_pos + MAX_TOKEN_SIZE < BUFFER_SIZE)
165 return;
166
167 size_t empty_size = state->buffer_pos;
168 size_t used_size = BUFFER_SIZE - 1 - state->buffer_pos;
169 memmove(state->buffer, state->buffer + state->buffer_pos, used_size);
170 state->line_offset += state->buffer_pos;
171 state->buffer_pos = 0;
172
173 size_t read_size = fread(state->buffer + used_size, 1, empty_size,
174 state->file);
175 if (ferror(state->file))
176 error_errno(state, EIO);
177 state->buffer[used_size + read_size] = '\0';
178}
179
180/** Read the next token. */
181static void next_token(state_t *state)
182{
183 fill_buffer(state);
184 done_with_token(state);
185 state->old_buffer_pos = state->buffer_pos;
186 char ch = state->buffer[state->buffer_pos];
187 if (ch == '\0') {
188 state->token = TOKEN_EOF;
189 } else if (ch == '#') {
190 while (state->buffer[state->buffer_pos] != '\n'
191 && state->buffer[state->buffer_pos] != '\0') {
192 state->buffer_pos++;
193 fill_buffer(state);
194 }
195 next_token(state);
196 return;
197 } else if (isspace(ch)) {
198 // Will eventually reach the '\0' at the end
199 while (isspace(state->buffer[state->buffer_pos])) {
200 if (state->buffer[state->buffer_pos] == '\n') {
201 state->lineno++;
202 state->line_offset = -state->buffer_pos;
203 }
204 state->buffer_pos++;
205 }
206 next_token(state);
207 return;
208 } else if (isalpha(ch)) {
209 while (isalnum(state->buffer[state->buffer_pos])
210 || state->buffer[state->buffer_pos] == '_')
211 state->buffer_pos++;
212 char *value = str_ndup(state->buffer + state->old_buffer_pos,
213 state->buffer_pos - state->old_buffer_pos);
214 if (!value) {
215 error_errno(state, ENOMEM);
216 } else if (!str_cmp(value, "do")) {
217 state->token = TOKEN_DO;
218 free(value);
219 } else if (!str_cmp(value, "else")) {
220 state->token = TOKEN_ELSE;
221 free(value);
222 } else if (!str_cmp(value, "false")) {
223 state->token = TOKEN_FALSE;
224 free(value);
225 } else if (!str_cmp(value, "if")) {
226 state->token = TOKEN_IF;
227 free(value);
228 } else if (!str_cmp(value, "repeat")) {
229 state->token = TOKEN_REPEAT;
230 free(value);
231 } else if (!str_cmp(value, "struct")) {
232 state->token = TOKEN_STRUCT;
233 free(value);
234 } else if (!str_cmp(value, "switch")) {
235 state->token = TOKEN_SWITCH;
236 free(value);
237 } else if (!str_cmp(value, "transform")) {
238 state->token = TOKEN_TRANSFORM;
239 free(value);
240 } else if (!str_cmp(value, "true")) {
241 state->token = TOKEN_TRUE;
242 free(value);
243 } else if (!str_cmp(value, "while")) {
244 state->token = TOKEN_WHILE;
245 free(value);
246 } else {
247 state->token = TOKEN_IDENTIFIER;
248 state->token_string = value;
249 }
250 } else if (isdigit(ch)) {
251 while (isdigit(state->buffer[state->buffer_pos]))
252 state->buffer_pos++;
253 state->token = TOKEN_INTEGER;
254 int rc = bithenge_parse_int(state->buffer +
255 state->old_buffer_pos, &state->token_int);
256 error_errno(state, rc);
257 } else if (ch == '<') {
258 state->token = ch;
259 state->buffer_pos++;
260 if (state->buffer[state->buffer_pos] == '-') {
261 state->buffer_pos++;
262 state->token = TOKEN_LEFT_ARROW;
263 }
264 } else if (ch == '=') {
265 state->token = ch;
266 state->buffer_pos++;
267 if (state->buffer[state->buffer_pos] == '=') {
268 state->token = TOKEN_EQUALS;
269 state->buffer_pos++;
270 }
271 } else {
272 state->token = ch;
273 state->buffer_pos++;
274 }
275}
276
277/** Allocate memory and handle failure by setting the error in the state. The
278 * caller must check the state for errors before using the return value of this
279 * function. */
280static void *state_malloc(state_t *state, size_t size)
281{
282 if (state->error != EOK)
283 return NULL;
284 void *result = malloc(size);
285 if (result == NULL)
286 error_errno(state, ENOMEM);
287 return result;
288}
289
290/** Reallocate memory and handle failure by setting the error in the state. If
291 * an error occurs, the existing pointer will be returned. */
292static void *state_realloc(state_t *state, void *ptr, size_t size)
293{
294 if (state->error != EOK)
295 return ptr;
296 void *result = realloc(ptr, size);
297 if (result == NULL) {
298 error_errno(state, ENOMEM);
299 return ptr;
300 }
301 return result;
302}
303
304/** Expect and consume a certain token. If the next token is of the wrong type,
305 * an error is caused. */
306static void expect(state_t *state, token_type_t type)
307{
308 if (state->token != type) {
309 syntax_error(state, "unexpected");
310 return;
311 }
312 next_token(state);
313}
314
315/** Expect and consume an identifier token. If the next token is not an
316 * identifier, an error is caused and this function returns null. */
317static char *expect_identifier(state_t *state)
318{
319 if (state->token != TOKEN_IDENTIFIER) {
320 syntax_error(state, "unexpected (identifier expected)");
321 return NULL;
322 }
323 char *val = state->token_string;
324 state->token_string = NULL;
325 next_token(state);
326 return val;
327}
328
329/** Find a transform by name. A reference will be added to the transform.
330 * @return The found transform, or NULL if none was found. */
331static bithenge_transform_t *get_named_transform(state_t *state,
332 const char *name)
333{
334 for (transform_list_t *e = state->transform_list; e; e = e->next) {
335 if (!str_cmp(e->name, name)) {
336 bithenge_transform_inc_ref(e->transform);
337 return e->transform;
338 }
339 }
340 for (int i = 0; bithenge_primitive_transforms[i].name; i++) {
341 if (!str_cmp(bithenge_primitive_transforms[i].name, name)) {
342 bithenge_transform_t *xform =
343 bithenge_primitive_transforms[i].transform;
344 bithenge_transform_inc_ref(xform);
345 return xform;
346 }
347 }
348 return NULL;
349}
350
351/** Add a named transform. This function takes ownership of the name and a
352 * reference to the transform. If an error has occurred, either may be null. */
353static void add_named_transform(state_t *state, bithenge_transform_t *xform, char *name)
354{
355 transform_list_t *entry = state_malloc(state, sizeof(*entry));
356 if (state->error != EOK) {
357 free(name);
358 bithenge_transform_dec_ref(xform);
359 free(entry);
360 return;
361 }
362 entry->name = name;
363 entry->transform = xform;
364 entry->next = state->transform_list;
365 state->transform_list = entry;
366}
367
368static bithenge_transform_t *parse_transform(state_t *state);
369static bithenge_transform_t *parse_struct(state_t *state);
370static bithenge_expression_t *parse_expression(state_t *state);
371
372
373
374/***************** Expressions *****************/
375
376typedef enum {
377 PRECEDENCE_NONE,
378 PRECEDENCE_EQUALS,
379 PRECEDENCE_ADD,
380 PRECEDENCE_MULTIPLY,
381} precedence_t;
382
383static bithenge_binary_op_t token_as_binary_operator(token_type_t token)
384{
385 switch ((int)token) {
386 case '+':
387 return BITHENGE_EXPRESSION_ADD;
388 case '-':
389 return BITHENGE_EXPRESSION_SUBTRACT;
390 case '*':
391 return BITHENGE_EXPRESSION_MULTIPLY;
392 case TOKEN_EQUALS:
393 return BITHENGE_EXPRESSION_EQUALS;
394 default:
395 return BITHENGE_EXPRESSION_INVALID_BINARY_OP;
396 }
397}
398
399static precedence_t binary_operator_precedence(bithenge_binary_op_t op)
400{
401 switch (op) {
402 case BITHENGE_EXPRESSION_ADD: /* fallthrough */
403 case BITHENGE_EXPRESSION_SUBTRACT:
404 return PRECEDENCE_ADD;
405 case BITHENGE_EXPRESSION_MULTIPLY:
406 return PRECEDENCE_MULTIPLY;
407 case BITHENGE_EXPRESSION_EQUALS:
408 return PRECEDENCE_EQUALS;
409 default:
410 assert(false);
411 return PRECEDENCE_NONE;
412 }
413}
414
415static bithenge_expression_t *parse_term(state_t *state)
416{
417 int rc;
418 if (state->token == TOKEN_TRUE || state->token == TOKEN_FALSE) {
419 bool val = state->token == TOKEN_TRUE;
420 next_token(state);
421 bithenge_node_t *node;
422 rc = bithenge_new_boolean_node(&node, val);
423 if (rc != EOK) {
424 error_errno(state, rc);
425 return NULL;
426 }
427
428 bithenge_expression_t *expr;
429 rc = bithenge_const_expression(&expr, node);
430 if (rc != EOK) {
431 error_errno(state, rc);
432 return NULL;
433 }
434
435 return expr;
436 } else if (state->token == TOKEN_INTEGER) {
437 bithenge_int_t val = state->token_int;
438 next_token(state);
439 bithenge_node_t *node;
440 rc = bithenge_new_integer_node(&node, val);
441 if (rc != EOK) {
442 error_errno(state, rc);
443 return NULL;
444 }
445
446 bithenge_expression_t *expr;
447 rc = bithenge_const_expression(&expr, node);
448 if (rc != EOK) {
449 error_errno(state, rc);
450 return NULL;
451 }
452
453 return expr;
454 } else if (state->token == TOKEN_IDENTIFIER) {
455 int i;
456 for (i = 0; i < state->num_params; i++)
457 if (!str_cmp(state->parameter_names[i],
458 state->token_string))
459 break;
460
461 if (i == state->num_params) {
462 syntax_error(state, "unknown identifier");
463 return NULL;
464 }
465
466 bithenge_expression_t *expr;
467 rc = bithenge_param_expression(&expr, i);
468 if (rc != EOK) {
469 error_errno(state, rc);
470 return NULL;
471 }
472
473 next_token(state);
474
475 return expr;
476 } else if (state->token == '.') {
477 next_token(state);
478
479 const char *id = expect_identifier(state);
480 bithenge_node_t *key = NULL;
481 bithenge_expression_t *expr = NULL;
482
483 if (state->error == EOK) {
484 rc = bithenge_new_string_node(&key, id, true);
485 id = NULL;
486 error_errno(state, rc);
487 }
488
489 if (state->error == EOK) {
490 rc = bithenge_scope_member_expression(&expr, key);
491 key = NULL;
492 if (rc != EOK)
493 expr = NULL;
494 error_errno(state, rc);
495 }
496
497 if (state->error != EOK) {
498 free((char *)id);
499 bithenge_node_dec_ref(key);
500 bithenge_expression_dec_ref(expr);
501 return NULL;
502 }
503
504 return expr;
505 } else if (state->token == '(') {
506 next_token(state);
507 bithenge_expression_t *expr = parse_expression(state);
508 expect(state, ')');
509 return expr;
510 } else {
511 syntax_error(state, "expression expected");
512 return NULL;
513 }
514}
515
516static bithenge_expression_t *parse_expression_precedence(state_t *state,
517 precedence_t prev_precedence)
518{
519 bithenge_expression_t *expr = parse_term(state);
520 while (state->error == EOK) {
521 bithenge_binary_op_t op =
522 token_as_binary_operator(state->token);
523 if (op == BITHENGE_EXPRESSION_INVALID_BINARY_OP)
524 break;
525 precedence_t precedence = binary_operator_precedence(op);
526 if (precedence <= prev_precedence)
527 break;
528 next_token(state);
529
530 bithenge_expression_t *expr2 = parse_term(state);
531 if (state->error != EOK) {
532 bithenge_expression_dec_ref(expr2);
533 break;
534 }
535 int rc = bithenge_binary_expression(&expr, op, expr, expr2);
536 if (rc != EOK)
537 error_errno(state, rc);
538 }
539 if (state->error != EOK) {
540 bithenge_expression_dec_ref(expr);
541 expr = NULL;
542 }
543 return expr;
544}
545
546static bithenge_expression_t *parse_expression(state_t *state)
547{
548 return parse_expression_precedence(state, PRECEDENCE_NONE);
549}
550
551
552
553/* state->token must be TOKEN_IDENTIFIER when this is called. */
554static bithenge_transform_t *parse_invocation(state_t *state)
555{
556 bithenge_transform_t *result = get_named_transform(state,
557 state->token_string);
558 if (!result)
559 syntax_error(state, "transform not found");
560 next_token(state);
561
562 bithenge_expression_t **params = NULL;
563 int num_params = 0;
564 if (state->token == '(') {
565 next_token(state);
566 while (state->error == EOK && state->token != ')') {
567 if (num_params)
568 expect(state, ',');
569 params = state_realloc(state, params,
570 (num_params + 1)*sizeof(*params));
571 if (state->error != EOK)
572 break;
573 params[num_params] = parse_expression(state);
574 num_params++;
575 }
576 expect(state, ')');
577 }
578
579 /* TODO: show correct error position */
580 if (state->error == EOK
581 && bithenge_transform_num_params(result) != num_params)
582 syntax_error(state, "incorrect number of parameters before");
583
584 if (state->error != EOK) {
585 while (num_params--)
586 bithenge_expression_dec_ref(params[num_params]);
587 free(params);
588 bithenge_transform_dec_ref(result);
589 return NULL;
590 }
591
592 if (num_params) {
593 int rc = bithenge_param_wrapper(&result, result, params);
594 if (rc != EOK) {
595 error_errno(state, rc);
596 result = NULL;
597 }
598 }
599
600 return result;
601}
602
603/** Create a transform that just produces an empty node.
604 * @param state The parser state.
605 * @return The new transform, or NULL on error. */
606static bithenge_transform_t *make_empty_transform(state_t *state)
607{
608 bithenge_node_t *node;
609 int rc = bithenge_new_empty_internal_node(&node);
610 if (rc != EOK) {
611 error_errno(state, rc);
612 return NULL;
613 }
614
615 bithenge_expression_t *expr;
616 rc = bithenge_const_expression(&expr, node);
617 if (rc != EOK) {
618 error_errno(state, rc);
619 return NULL;
620 }
621
622 bithenge_transform_t *xform;
623 rc = bithenge_expression_transform(&xform, expr);
624 if (rc != EOK) {
625 error_errno(state, rc);
626 return NULL;
627 }
628
629 return xform;
630}
631
632static bithenge_transform_t *parse_if(state_t *state, bool in_struct)
633{
634 expect(state, TOKEN_IF);
635 expect(state, '(');
636 bithenge_expression_t *expr = parse_expression(state);
637 expect(state, ')');
638 expect(state, '{');
639 bithenge_transform_t *true_xform =
640 in_struct ? parse_struct(state) : parse_transform(state);
641 expect(state, '}');
642
643 bithenge_transform_t *false_xform = NULL;
644 if (state->token == TOKEN_ELSE) {
645 next_token(state);
646 expect(state, '{');
647 false_xform =
648 in_struct ? parse_struct(state) : parse_transform(state);
649 expect(state, '}');
650 } else {
651 if (in_struct)
652 false_xform = make_empty_transform(state);
653 else
654 syntax_error(state, "else expected");
655 }
656
657 if (state->error != EOK) {
658 bithenge_expression_dec_ref(expr);
659 bithenge_transform_dec_ref(true_xform);
660 bithenge_transform_dec_ref(false_xform);
661 return NULL;
662 }
663
664 bithenge_transform_t *if_xform;
665 int rc = bithenge_if_transform(&if_xform, expr, true_xform,
666 false_xform);
667 if (rc != EOK) {
668 error_errno(state, rc);
669 return NULL;
670 }
671 return if_xform;
672}
673
674static bithenge_transform_t *parse_switch(state_t *state, bool in_struct)
675{
676 expect(state, TOKEN_SWITCH);
677 expect(state, '(');
678 bithenge_expression_t *ref_expr = parse_expression(state);
679 expect(state, ')');
680 expect(state, '{');
681 int num = 0;
682 bithenge_expression_t **exprs = NULL;
683 bithenge_transform_t **xforms = NULL;
684 while (state->error == EOK && state->token != '}') {
685 bithenge_expression_t *expr;
686 if (state->token == TOKEN_ELSE) {
687 next_token(state);
688 bithenge_node_t *node;
689 int rc = bithenge_new_boolean_node(&node, true);
690 if (rc != EOK) {
691 error_errno(state, rc);
692 break;
693 }
694 rc = bithenge_const_expression(&expr, node);
695 if (rc != EOK) {
696 error_errno(state, rc);
697 break;
698 }
699 } else {
700 expr = parse_expression(state);
701 if (state->error == EOK) {
702 bithenge_expression_inc_ref(ref_expr);
703 int rc = bithenge_binary_expression(&expr,
704 BITHENGE_EXPRESSION_EQUALS, ref_expr,
705 expr);
706 if (rc != EOK) {
707 error_errno(state, rc);
708 break;
709 }
710 }
711 }
712
713 expect(state, ':');
714 bithenge_transform_t *xform;
715 if (in_struct) {
716 expect(state, '{');
717 xform = parse_struct(state);
718 expect(state, '}');
719 } else
720 xform = parse_transform(state);
721 expect(state, ';');
722
723 exprs = state_realloc(state, exprs,
724 sizeof(*exprs) * (num + 1));
725 xforms = state_realloc(state, xforms,
726 sizeof(*xforms) * (num + 1));
727 if (state->error != EOK) {
728 bithenge_expression_dec_ref(expr);
729 bithenge_transform_dec_ref(xform);
730 break;
731 }
732
733 exprs[num] = expr;
734 xforms[num] = xform;
735 num++;
736 }
737 bithenge_expression_dec_ref(ref_expr);
738
739 bithenge_transform_t *switch_xform = &bithenge_invalid_transform;
740 bithenge_transform_inc_ref(switch_xform);
741 while (state->error == EOK && num >= 1) {
742 num--;
743 int rc = bithenge_if_transform(&switch_xform, exprs[num],
744 xforms[num], switch_xform);
745 if (rc != EOK)
746 error_errno(state, rc);
747 }
748
749 while (num >= 1) {
750 num--;
751 bithenge_expression_dec_ref(exprs[num]);
752 bithenge_transform_dec_ref(xforms[num]);
753 }
754 free(exprs);
755 free(xforms);
756
757 expect(state, '}');
758 return switch_xform;
759}
760
761static bithenge_transform_t *parse_repeat(state_t *state)
762{
763 expect(state, TOKEN_REPEAT);
764 bithenge_expression_t *expr = NULL;
765 if (state->token == '(') {
766 next_token(state);
767 expr = parse_expression(state);
768 expect(state, ')');
769 }
770 expect(state, '{');
771 bithenge_transform_t *xform = parse_transform(state);
772 expect(state, '}');
773
774 if (state->error != EOK) {
775 bithenge_expression_dec_ref(expr);
776 bithenge_transform_dec_ref(xform);
777 return NULL;
778 }
779
780 bithenge_transform_t *repeat_xform;
781 int rc = bithenge_repeat_transform(&repeat_xform, xform, expr);
782 if (rc != EOK) {
783 error_errno(state, rc);
784 return NULL;
785 }
786 return repeat_xform;
787}
788
789static bithenge_transform_t *parse_do_while(state_t *state)
790{
791 expect(state, TOKEN_DO);
792 expect(state, '{');
793 bithenge_transform_t *xform = parse_transform(state);
794 expect(state, '}');
795 expect(state, TOKEN_WHILE);
796 expect(state, '(');
797 bithenge_expression_t *expr = parse_expression(state);
798 expect(state, ')');
799
800 if (state->error != EOK) {
801 bithenge_expression_dec_ref(expr);
802 bithenge_transform_dec_ref(xform);
803 return NULL;
804 }
805
806 bithenge_transform_t *do_while_xform;
807 int rc = bithenge_do_while_transform(&do_while_xform, xform, expr);
808 if (rc != EOK) {
809 error_errno(state, rc);
810 return NULL;
811 }
812 return do_while_xform;
813}
814
815/* The TOKEN_STRUCT and '{' must already have been skipped. */
816static bithenge_transform_t *parse_struct(state_t *state)
817{
818 size_t num = 0;
819 bithenge_named_transform_t *subxforms;
820 /* We keep an extra space for the {NULL, NULL} terminator. */
821 subxforms = state_malloc(state, sizeof(*subxforms));
822 while (state->error == EOK && state->token != '}') {
823 if (state->token == TOKEN_IF) {
824 subxforms[num].transform = parse_if(state, true);
825 subxforms[num].name = NULL;
826 } else if (state->token == TOKEN_SWITCH) {
827 subxforms[num].transform = parse_switch(state, true);
828 subxforms[num].name = NULL;
829 } else {
830 if (state->token == '.') {
831 next_token(state);
832 subxforms[num].name = expect_identifier(state);
833 } else {
834 subxforms[num].name = NULL;
835 }
836 expect(state, TOKEN_LEFT_ARROW);
837 subxforms[num].transform = parse_transform(state);
838 expect(state, ';');
839 }
840 num++;
841 subxforms = state_realloc(state, subxforms,
842 (num + 1)*sizeof(*subxforms));
843 }
844
845 if (state->error != EOK) {
846 while (num--) {
847 free((void *)subxforms[num].name);
848 bithenge_transform_dec_ref(subxforms[num].transform);
849 }
850 free(subxforms);
851 return NULL;
852 }
853
854 subxforms[num].name = NULL;
855 subxforms[num].transform = NULL;
856 bithenge_transform_t *result;
857 int rc = bithenge_new_struct(&result, subxforms);
858 if (rc != EOK) {
859 error_errno(state, rc);
860 return NULL;
861 }
862 return result;
863}
864
865/** Parse a transform without composition.
866 * @return The parsed transform, or NULL if an error occurred. */
867static bithenge_transform_t *parse_transform_no_compose(state_t *state)
868{
869 if (state->token == TOKEN_DO) {
870 return parse_do_while(state);
871 } else if (state->token == TOKEN_IDENTIFIER) {
872 return parse_invocation(state);
873 } else if (state->token == TOKEN_IF) {
874 return parse_if(state, false);
875 } else if (state->token == TOKEN_REPEAT) {
876 return parse_repeat(state);
877 } else if (state->token == TOKEN_STRUCT) {
878 next_token(state);
879 expect(state, '{');
880 bithenge_transform_t *xform = parse_struct(state);
881 expect(state, '}');
882 return xform;
883 } else if (state->token == TOKEN_SWITCH) {
884 return parse_switch(state, false);
885 } else {
886 syntax_error(state, "unexpected (transform expected)");
887 return NULL;
888 }
889}
890
891/** Parse a transform.
892 * @return The parsed transform, or NULL if an error occurred. */
893static bithenge_transform_t *parse_transform(state_t *state)
894{
895 bithenge_transform_t *result = parse_transform_no_compose(state);
896 bithenge_transform_t **xforms = NULL;
897 size_t num = 1;
898 while (state->token == TOKEN_LEFT_ARROW) {
899 expect(state, TOKEN_LEFT_ARROW);
900 xforms = state_realloc(state, xforms,
901 (num + 1) * sizeof(*xforms));
902 if (state->error != EOK)
903 break;
904 xforms[num] = parse_transform_no_compose(state);
905 num++;
906 }
907 if (state->error != EOK) {
908 while (xforms && num--)
909 bithenge_transform_dec_ref(xforms[num]);
910 free(xforms);
911 bithenge_transform_dec_ref(result);
912 return NULL;
913 }
914 if (xforms) {
915 xforms[0] = result;
916 int rc = bithenge_new_composed_transform(&result, xforms, num);
917 if (rc != EOK) {
918 error_errno(state, rc);
919 return NULL;
920 }
921 }
922 return result;
923}
924
925/** Parse a definition. */
926static void parse_definition(state_t *state)
927{
928 expect(state, TOKEN_TRANSFORM);
929 char *name = expect_identifier(state);
930
931 if (state->token == '(') {
932 next_token(state);
933 while (state->error == EOK && state->token != ')') {
934 if (state->num_params)
935 expect(state, ',');
936 state->parameter_names = state_realloc(state,
937 state->parameter_names,
938 (state->num_params + 1)*sizeof(*state->parameter_names));
939 if (state->error != EOK)
940 break;
941 state->parameter_names[state->num_params++] =
942 expect_identifier(state);
943 }
944 expect(state, ')');
945 }
946
947 expect(state, '=');
948 bithenge_transform_t *xform = parse_transform(state);
949 expect(state, ';');
950
951 if (state->error == EOK) {
952 int rc = bithenge_new_barrier_transform(&xform, xform,
953 state->num_params);
954 if (rc != EOK) {
955 xform = NULL;
956 error_errno(state, rc);
957 }
958 }
959
960 add_named_transform(state, xform, name);
961
962 for (int i = 0; i < state->num_params; i++)
963 free(state->parameter_names[i]);
964 free(state->parameter_names);
965 state->parameter_names = NULL;
966 state->num_params = 0;
967}
968
969/** Initialize the state. */
970static void state_init(state_t *state, const char *filename)
971{
972 state->error = EOK;
973 state->transform_list = NULL;
974 state->parameter_names = NULL;
975 state->num_params = 0;
976 state->token = TOKEN_ERROR;
977 state->old_buffer_pos = state->buffer_pos = BUFFER_SIZE - 1;
978 state->lineno = 1;
979 state->line_offset = (int)-state->buffer_pos + 1;
980 state->filename = filename;
981 state->file = fopen(filename, "r");
982 if (!state->file) {
983 error_errno(state, errno);
984 } else {
985 next_token(state);
986 }
987}
988
989/** Destroy the state. */
990static void state_destroy(state_t *state)
991{
992 done_with_token(state);
993 state->token = TOKEN_ERROR;
994 if (state->file)
995 fclose(state->file);
996 transform_list_t *entry = state->transform_list;
997 while (entry) {
998 transform_list_t *next = entry->next;
999 free(entry->name);
1000 bithenge_transform_dec_ref(entry->transform);
1001 free(entry);
1002 entry = next;
1003 }
1004 for (int i = 0; i < state->num_params; i++)
1005 free(state->parameter_names[i]);
1006 free(state->parameter_names);
1007}
1008
1009/** Parse a script file.
1010 * @param filename The name of the script file.
1011 * @param[out] out Stores the "main" transform.
1012 * @return EOK on success, EINVAL on syntax error, or an error code from
1013 * errno.h. */
1014int bithenge_parse_script(const char *filename, bithenge_transform_t **out)
1015{
1016 state_t state;
1017 state_init(&state, filename);
1018 while (state.error == EOK && state.token != TOKEN_EOF)
1019 parse_definition(&state);
1020 *out = get_named_transform(&state, "main");
1021 int rc = state.error;
1022 state_destroy(&state);
1023 if (rc == EOK && !*out) {
1024 fprintf(stderr, "no \"main\" transform\n");
1025 rc = EINVAL;
1026 }
1027 return rc;
1028}
1029
1030/** @}
1031 */
Note: See TracBrowser for help on using the repository browser.