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

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

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