1 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2 /* */
3 /* File....: code.c */
4 /* Name....: Code Node Functions */
5 /* Author..: Thorsten Koch */
6 /* Copyright by Author, All rights reserved */
7 /* */
8 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
9 /*
10 * Copyright (C) 2001-2018 by Thorsten Koch <koch@zib.de>
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public License
14 * as published by the Free Software Foundation; either version 3
15 * of the License, or (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
25 */
26
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <string.h>
30 #include <assert.h>
31 #include <stdarg.h>
32
33 #include <stdbool.h>
34 #include "zimpl/mshell.h"
35 #include "zimpl/stkchk.h"
36 #include "zimpl/ratlptypes.h"
37 #include "zimpl/numb.h"
38 #include "zimpl/elem.h"
39 #include "zimpl/tuple.h"
40 #include "zimpl/mme.h"
41 #include "zimpl/set.h"
42 #include "zimpl/symbol.h"
43 #include "zimpl/entry.h"
44 #include "zimpl/idxset.h"
45 #include "zimpl/rdefpar.h"
46 #include "zimpl/bound.h"
47 #include "zimpl/define.h"
48 #include "zimpl/mono.h"
49 #include "zimpl/term.h"
50 #include "zimpl/list.h"
51 #include "zimpl/stmt.h"
52 #include "zimpl/local.h"
53 #include "zimpl/code.h"
54 #include "zimpl/inst.h"
55
56 typedef union code_value CodeValue;
57
58 union code_value
59 {
60 Numb* numb;
61 const char* strg;
62 const char* name;
63 Tuple* tuple;
64 Set* set;
65 Term* term;
66 Entry* entry;
67 IdxSet* idxset;
68 bool bval;
69 int size;
70 List* list;
71 VarClass varclass;
72 ConType contype;
73 RDef* rdef;
74 RPar* rpar;
75 unsigned int bits;
76 Symbol* sym;
77 Define* def;
78 Bound* bound;
79 };
80
81 #define MAX_CHILDS 8
82
83 struct code_node
84 {
85 SID
86 CodeType type;
87 Inst eval;
88 CodeValue value;
89 CodeNode* child[MAX_CHILDS];
90 const Stmt* stmt;
91 int column;
92 };
93
94 #define CODE_SID 0x436f6465
95
96 static CodeNode* root = NULL;
97 static unsigned int inst_count = 0;
98
code_is_valid(const CodeNode * node)99 inline bool code_is_valid(const CodeNode* node)
100 {
101 return ((node != NULL) && SID_ok(node, CODE_SID));
102 }
103
code_new_inst(Inst inst,int childs,...)104 CodeNode* code_new_inst(Inst inst, int childs, ...)
105 {
106 va_list ap;
107 CodeNode* node = calloc(1, sizeof(*node));
108 int i;
109 CodeNode* child;
110
111 assert(inst != INST_NULL);
112 assert(node != NULL);
113 assert(childs <= MAX_CHILDS);
114
115 node->type = CODE_ERR; /* call to eval() will set this */
116 node->eval = inst;
117 /* Das sollte eigendlich ein parameter sein, aber wozu bei jedem
118 * code_new diese Funktionen mit uebergeben.
119 */
120 node->stmt = scan_get_stmt();
121 node->column = scan_get_column();
122
123 SID_set(node, CODE_SID);
124 assert(code_is_valid(node));
125
126 /*lint -save -e826 */
127 va_start(ap, childs);
128
129 for(i = 0; i < childs; i++)
130 {
131 child = va_arg(ap, CodeNode*);
132 assert((child == NULL) || code_is_valid(child));
133 node->child[i] = child;
134 }
135 va_end(ap);
136 /*lint -restore */
137
138 return node;
139 }
140
141 /* We eat the numb, i.e. we will free it!
142 */
code_new_numb(Numb * numb)143 CodeNode* code_new_numb(Numb* numb)
144 {
145 CodeNode* node = calloc(1, sizeof(*node));
146
147 assert(node != NULL);
148
149 node->type = CODE_NUMB;
150 node->eval = i_nop;
151 node->value.numb = numb;
152 node->stmt = scan_get_stmt();
153 node->column = scan_get_column();
154
155 SID_set(node, CODE_SID);
156 assert(code_is_valid(node));
157
158 return node;
159 }
160
code_new_strg(const char * strg)161 CodeNode* code_new_strg(const char* strg)
162 {
163 CodeNode* node = calloc(1, sizeof(*node));
164
165 assert(strg != NULL);
166 assert(node != NULL);
167
168 node->type = CODE_STRG;
169 node->eval = i_nop;
170 node->value.strg = strg;
171 node->stmt = scan_get_stmt();
172 node->column = scan_get_column();
173
174 SID_set(node, CODE_SID);
175 assert(code_is_valid(node));
176
177 return node;
178 }
179
code_new_name(const char * name)180 CodeNode* code_new_name(const char* name)
181 {
182 CodeNode* node = calloc(1, sizeof(*node));
183
184 assert(name != NULL);
185 assert(node != NULL);
186
187 node->type = CODE_NAME;
188 node->eval = i_nop;
189 node->value.name = name;
190 node->stmt = scan_get_stmt();
191 node->column = scan_get_column();
192
193 SID_set(node, CODE_SID);
194 assert(code_is_valid(node));
195
196 return node;
197 }
198
code_new_size(int size)199 CodeNode* code_new_size(int size)
200 {
201 CodeNode* node = calloc(1, sizeof(*node));
202
203 assert(size >= 0);
204 assert(node != NULL);
205
206 node->type = CODE_SIZE;
207 node->eval = i_nop;
208 node->value.size = size;
209 node->stmt = scan_get_stmt();
210 node->column = scan_get_column();
211
212 SID_set(node, CODE_SID);
213 assert(code_is_valid(node));
214
215 return node;
216 }
217
code_new_varclass(VarClass varclass)218 CodeNode* code_new_varclass(VarClass varclass)
219 {
220 CodeNode* node = calloc(1, sizeof(*node));
221
222 assert(node != NULL);
223
224 node->type = CODE_VARCLASS;
225 node->eval = i_nop;
226 node->value.varclass = varclass;
227 node->stmt = scan_get_stmt();
228 node->column = scan_get_column();
229
230 SID_set(node, CODE_SID);
231 assert(code_is_valid(node));
232
233 return node;
234 }
235
code_new_contype(ConType contype)236 CodeNode* code_new_contype(ConType contype)
237 {
238 CodeNode* node = calloc(1, sizeof(*node));
239
240 assert(node != NULL);
241
242 node->type = CODE_CONTYPE;
243 node->eval = i_nop;
244 node->value.contype = contype;
245 node->stmt = scan_get_stmt();
246 node->column = scan_get_column();
247
248 SID_set(node, CODE_SID);
249 assert(code_is_valid(node));
250
251 return node;
252 }
253
code_new_bits(unsigned int bits)254 CodeNode* code_new_bits(unsigned int bits)
255 {
256 CodeNode* node = calloc(1, sizeof(*node));
257
258 assert(node != NULL);
259
260 node->type = CODE_BITS;
261 node->eval = i_nop;
262 node->value.bits = bits;
263 node->stmt = scan_get_stmt();
264 node->column = scan_get_column();
265
266 SID_set(node, CODE_SID);
267 assert(code_is_valid(node));
268
269 return node;
270 }
271
code_new_symbol(Symbol * sym)272 CodeNode* code_new_symbol(Symbol* sym)
273 {
274 CodeNode* node = calloc(1, sizeof(*node));
275
276 assert(node != NULL);
277
278 node->type = CODE_SYM;
279 node->eval = i_nop;
280 node->value.sym = sym;
281 node->stmt = scan_get_stmt();
282 node->column = scan_get_column();
283
284 SID_set(node, CODE_SID);
285 assert(code_is_valid(node));
286
287 return node;
288 }
289
code_new_define(Define * def)290 CodeNode* code_new_define(Define* def)
291 {
292 CodeNode* node = calloc(1, sizeof(*node));
293
294 assert(node != NULL);
295
296 node->type = CODE_DEF;
297 node->eval = i_nop;
298 node->value.def = def;
299 node->stmt = scan_get_stmt();
300 node->column = scan_get_column();
301
302 SID_set(node, CODE_SID);
303 assert(code_is_valid(node));
304
305 return node;
306 }
307
308 /* We eat the bound, i.e. we will free it!
309 */
code_new_bound(BoundType type)310 CodeNode* code_new_bound(BoundType type)
311 {
312 CodeNode* node = calloc(1, sizeof(*node));
313
314 assert(node != NULL);
315 assert(type == BOUND_INFTY || type == BOUND_MINUS_INFTY);
316
317 node->type = CODE_BOUND;
318 node->eval = i_nop;
319 node->value.bound = bound_new(type, NULL);
320 node->stmt = scan_get_stmt();
321 node->column = scan_get_column();
322
323 SID_set(node, CODE_SID);
324 assert(code_is_valid(node));
325
326 return node;
327 }
328
code_free_value(CodeNode * node)329 void code_free_value(CodeNode* node)
330 {
331 assert(code_is_valid(node));
332
333 switch(node->type)
334 {
335 case CODE_ERR :
336 case CODE_VOID :
337 /* Kann passieren, wenn bei code_value_() ein bis dahin unbenutzter
338 * Knoten verwendet wird.
339 */
340 break;
341 case CODE_NUMB :
342 assert(node->value.numb != NULL);
343 numb_free(node->value.numb);
344 break;
345 case CODE_STRG :
346 case CODE_NAME :
347 break;
348 case CODE_TUPLE :
349 assert(node->value.tuple != NULL);
350 tuple_free(node->value.tuple);
351 node->value.tuple = NULL;
352 node->type = CODE_ERR;
353 break;
354 case CODE_SET :
355 assert(node->value.set != NULL);
356 set_free(node->value.set);
357 node->value.set = NULL;
358 node->type = CODE_ERR;
359 break;
360 case CODE_TERM :
361 assert(node->value.term != NULL);
362 term_free(node->value.term);
363 node->value.term = NULL;
364 node->type = CODE_ERR;
365 break;
366 case CODE_ENTRY :
367 assert(node->value.entry != NULL);
368 entry_free(node->value.entry);
369 node->value.entry = NULL;
370 node->type = CODE_ERR;
371 break;
372 case CODE_IDXSET :
373 assert(node->value.idxset != NULL);
374 idxset_free(node->value.idxset);
375 node->value.entry = NULL;
376 node->type = CODE_ERR;
377 break;
378 case CODE_BOOL :
379 case CODE_SIZE :
380 break;
381 case CODE_LIST :
382 assert(node->value.list != NULL);
383 list_free(node->value.list);
384 node->value.list = NULL;
385 node->type = CODE_ERR;
386 break;
387 case CODE_VARCLASS :
388 case CODE_CONTYPE :
389 break;
390 case CODE_RDEF :
391 assert(node->value.rdef != NULL);
392 rdef_free(node->value.rdef);
393 node->value.rdef = NULL;
394 node->type = CODE_ERR;
395 break;
396 case CODE_RPAR :
397 assert(node->value.rpar != NULL);
398 rpar_free(node->value.rpar);
399 node->value.rpar = NULL;
400 node->type = CODE_ERR;
401 break;
402 case CODE_BITS :
403 break;
404 case CODE_SYM :
405 break;
406 case CODE_DEF :
407 break;
408 case CODE_BOUND :
409 assert(node->value.bound != NULL);
410 bound_free(node->value.bound);
411 break;
412 default :
413 abort();
414 }
415 }
416
code_free(CodeNode * node)417 void code_free(CodeNode* node)
418 {
419 int i;
420
421 for(i = 0; i < MAX_CHILDS; i++)
422 if (node->child[i] != NULL)
423 code_free(node->child[i]);
424
425 code_free_value(node);
426
427 free(node);
428 }
429
code_set_child(CodeNode * node,int idx,CodeNode * child)430 void code_set_child(CodeNode* node, int idx, CodeNode* child)
431 {
432 assert(code_is_valid(node));
433 assert(idx >= 0);
434 assert(idx < MAX_CHILDS);
435 assert(child != NULL);
436
437 node->child[idx] = child;
438 }
439
code_get_type(const CodeNode * node)440 CodeType code_get_type(const CodeNode* node)
441 {
442 assert(code_is_valid(node));
443
444 return node->type;
445 }
446
code_get_inst(const CodeNode * node)447 Inst code_get_inst(const CodeNode* node)
448 {
449 assert(code_is_valid(node));
450
451 return node->eval;
452 }
453
code_set_root(CodeNode * node)454 void code_set_root(CodeNode* node)
455 {
456 assert(code_is_valid(node));
457
458 root = node;
459 }
460
code_get_root(void)461 CodeNode* code_get_root(void)
462 {
463 return root;
464 }
465
code_get_inst_count()466 unsigned int code_get_inst_count()
467 {
468 return inst_count;
469 }
470
code_clear_inst_count()471 void code_clear_inst_count()
472 {
473 inst_count = 0;
474 }
475
code_check_type(CodeNode * node,CodeType expected)476 static inline CodeNode* code_check_type(CodeNode* node, CodeType expected)
477 {
478 static const char* const tname[] =
479 {
480 "Error", "Number", "String", "Name", "Tuple", "Set", "Term", "Bool", "Size",
481 "IndexSet", "List", "Nothing", "Entry", "VarClass", "ConType",
482 "ReadDefinition", "ReadParameter", "BitFlag", "Symbol", "Define", "Bound"
483 };
484 assert(code_is_valid(node));
485 assert(sizeof(tname) / sizeof(tname[0]) > (size_t)node->type);
486
487 if (node->type != expected)
488 {
489 assert(sizeof(tname) / sizeof(tname[0]) > (size_t)expected);
490
491 fprintf(stderr, "*** Error 159: Type error, expected %s got %s\n",
492 tname[expected], tname[node->type]);
493 code_errmsg(node);
494 zpl_exit(EXIT_FAILURE);
495 }
496 return node;
497 }
498
code_errmsg(const CodeNode * node)499 void code_errmsg(const CodeNode* node)
500 {
501 fprintf(stderr, "*** File: %s Line %d\n",
502 stmt_get_filename(node->stmt),
503 stmt_get_lineno(node->stmt));
504
505 show_source(stderr, stmt_get_text(node->stmt), node->column);
506
507 if (verbose >= VERB_CHATTER)
508 local_print_all(stderr);
509 }
510
code_eval(CodeNode * node)511 inline CodeNode* code_eval(CodeNode* node)
512 {
513 assert(code_is_valid(node));
514
515 inst_count++;
516
517 stkchk_used(); // record maximum stack use
518
519 return (*node->eval)(node);
520 }
521
522
code_prune_tree(CodeNode * node)523 bool code_prune_tree(CodeNode* node)
524 {
525 static Inst const prunable[] =
526 {
527 i_expr_abs, i_expr_sgn, i_expr_add, i_expr_card, i_expr_ceil, i_expr_div, i_expr_exp,
528 i_expr_sqrt, i_expr_fac, i_expr_floor, i_expr_if_else, i_expr_intdiv, i_expr_length, i_expr_ln,
529 i_expr_log, i_expr_ord, i_expr_prod, i_expr_round, i_expr_sum, i_expr_max,
530 i_expr_max2, i_expr_sglmax, i_expr_min, i_expr_min2, i_expr_sglmin, i_expr_mul,
531 i_expr_mod, i_expr_neg, i_expr_pow, i_expr_sub, i_expr_substr, NULL
532 };
533
534 bool is_all_const = true;
535 int i;
536
537 if (node->eval == (Inst)i_nop)
538 return true;
539
540 for(i = 0; i < MAX_CHILDS; i++)
541 {
542 if (node->child[i] != NULL)
543 {
544 bool is_const = code_prune_tree(node->child[i]);
545
546 /* Writing directly && code_prune_tree might not work
547 * due to shortcut evaluation.
548 */
549 is_all_const = is_all_const && is_const;
550 }
551 }
552
553 if (is_all_const)
554 {
555 for(i = 0; prunable[i] != INST_NULL; i++)
556 if (prunable[i] == node->eval)
557 break;
558
559 if (prunable[i] == INST_NULL)
560 return false;
561
562 (void)code_eval(node);
563
564 for(i = 0; i < MAX_CHILDS; i++)
565 {
566 if (node->child[i] != NULL)
567 {
568 code_free(node->child[i]);
569 node->child[i] = NULL;
570 }
571 }
572 node->eval = i_nop;
573 }
574 return is_all_const;
575 }
576
577
578 /* ----------------------------------------------------------------------------
579 * Get Funktionen
580 * ----------------------------------------------------------------------------
581 */
582
code_get_child(const CodeNode * node,int no)583 inline CodeNode* code_get_child(const CodeNode* node, int no)
584 {
585 assert(code_is_valid(node));
586 assert(no >= 0);
587 assert(no < MAX_CHILDS);
588 assert(node->child[no] != NULL);
589
590 return node->child[no];
591 }
592
code_get_numb(CodeNode * node)593 inline const Numb* code_get_numb(CodeNode* node)
594 {
595 return code_check_type(node, CODE_NUMB)->value.numb;
596 }
597
code_get_strg(CodeNode * node)598 inline const char* code_get_strg(CodeNode* node)
599 {
600 return code_check_type(node, CODE_STRG)->value.strg;
601 }
602
code_get_name(CodeNode * node)603 inline const char* code_get_name(CodeNode* node)
604 {
605 return code_check_type(node, CODE_NAME)->value.name;
606 }
607
code_get_tuple(CodeNode * node)608 inline const Tuple* code_get_tuple(CodeNode* node)
609 {
610 return code_check_type(node, CODE_TUPLE)->value.tuple;
611 }
612
code_get_set(CodeNode * node)613 inline const Set* code_get_set(CodeNode* node)
614 {
615 return code_check_type(node, CODE_SET)->value.set;
616 }
617
code_get_idxset(CodeNode * node)618 inline const IdxSet* code_get_idxset(CodeNode* node)
619 {
620 return code_check_type(node, CODE_IDXSET)->value.idxset;
621 }
622
code_get_entry(CodeNode * node)623 inline const Entry* code_get_entry(CodeNode* node)
624 {
625 return code_check_type(node, CODE_ENTRY)->value.entry;
626 }
627
code_get_term(CodeNode * node)628 inline const Term* code_get_term(CodeNode* node)
629 {
630 return code_check_type(node, CODE_TERM)->value.term;
631 }
632
code_get_size(CodeNode * node)633 inline int code_get_size(CodeNode* node)
634 {
635 return code_check_type(node, CODE_SIZE)->value.size;
636 }
637
code_get_bool(CodeNode * node)638 inline bool code_get_bool(CodeNode* node)
639 {
640 return code_check_type(node, CODE_BOOL)->value.bval;
641 }
642
code_get_list(CodeNode * node)643 inline const List* code_get_list(CodeNode* node)
644 {
645 return code_check_type(node, CODE_LIST)->value.list;
646 }
647
code_get_varclass(CodeNode * node)648 inline VarClass code_get_varclass(CodeNode* node)
649 {
650 return code_check_type(node, CODE_VARCLASS)->value.varclass;
651 }
652
code_get_contype(CodeNode * node)653 inline ConType code_get_contype(CodeNode* node)
654 {
655 return code_check_type(node, CODE_CONTYPE)->value.contype;
656 }
657
code_get_rdef(CodeNode * node)658 inline const RDef* code_get_rdef(CodeNode* node)
659 {
660 return code_check_type(node, CODE_RDEF)->value.rdef;
661 }
662
code_get_rpar(CodeNode * node)663 inline const RPar* code_get_rpar(CodeNode* node)
664 {
665 return code_check_type(node, CODE_RPAR)->value.rpar;
666 }
667
code_get_bits(CodeNode * node)668 inline unsigned int code_get_bits(CodeNode* node)
669 {
670 return code_check_type(node, CODE_BITS)->value.bits;
671 }
672
code_get_symbol(CodeNode * node)673 inline Symbol* code_get_symbol(CodeNode* node)
674 {
675 return code_check_type(node, CODE_SYM)->value.sym;
676 }
677
code_get_define(CodeNode * node)678 inline Define* code_get_define(CodeNode* node)
679 {
680 return code_check_type(node, CODE_DEF)->value.def;
681 }
682
code_get_bound(CodeNode * node)683 inline const Bound* code_get_bound(CodeNode* node)
684 {
685 return code_check_type(node, CODE_BOUND)->value.bound;
686 }
687
688 /* ----------------------------------------------------------------------------
689 * Value Funktionen
690 * ----------------------------------------------------------------------------
691 */
code_value_numb(CodeNode * node,Numb * numb)692 void code_value_numb(CodeNode* node, Numb* numb)
693 {
694 assert(code_is_valid(node));
695
696 code_free_value(node);
697
698 node->type = CODE_NUMB;
699 node->value.numb = numb;
700 }
701
code_value_strg(CodeNode * node,const char * strg)702 void code_value_strg(CodeNode* node, const char* strg)
703 {
704 assert(code_is_valid(node));
705 assert(strg != NULL);
706
707 code_free_value(node);
708
709 node->type = CODE_STRG;
710 node->value.strg = strg;
711 }
712
code_value_name(CodeNode * node,const char * name)713 void code_value_name(CodeNode* node, const char* name)
714 {
715 assert(code_is_valid(node));
716 assert(name != NULL);
717
718 code_free_value(node);
719
720 node->type = CODE_NAME;
721 node->value.name = name;
722 }
723
code_value_tuple(CodeNode * node,Tuple * tuple)724 void code_value_tuple(CodeNode* node, Tuple* tuple)
725 {
726 assert(code_is_valid(node));
727 assert(tuple_is_valid(tuple));
728
729 code_free_value(node);
730
731 node->type = CODE_TUPLE;
732 node->value.tuple = tuple;
733 }
734
code_value_set(CodeNode * node,Set * set)735 void code_value_set(CodeNode* node, Set* set)
736 {
737 assert(code_is_valid(node));
738 assert(set_is_valid(set));
739
740 code_free_value(node);
741
742 node->type = CODE_SET;
743 node->value.set = set;
744 }
745
code_value_idxset(CodeNode * node,IdxSet * idxset)746 void code_value_idxset(CodeNode* node, IdxSet* idxset)
747 {
748 assert(code_is_valid(node));
749 assert(idxset_is_valid(idxset));
750
751 code_free_value(node);
752
753 node->type = CODE_IDXSET;
754 node->value.idxset = idxset;
755 }
756
code_value_entry(CodeNode * node,Entry * entry)757 void code_value_entry(CodeNode* node, Entry* entry)
758 {
759 assert(code_is_valid(node));
760 assert(entry_is_valid(entry));
761
762 code_free_value(node);
763
764 node->type = CODE_ENTRY;
765 node->value.entry = entry;
766 }
767
code_value_term(CodeNode * node,Term * term)768 void code_value_term(CodeNode* node, Term* term)
769 {
770 assert(code_is_valid(node));
771 assert(term_is_valid(term));
772
773 code_free_value(node);
774
775 node->type = CODE_TERM;
776 node->value.term = term;
777 }
778
code_value_steal_term(CodeNode * node,int no)779 Term* code_value_steal_term(CodeNode* node, int no)
780 {
781 CodeNode* child = code_get_child(node, no);
782
783 assert(code_is_valid(node));
784 assert(code_get_type(child) == CODE_TERM);
785
786 code_free_value(node);
787
788 node->type = CODE_TERM;
789 node->value.term = child->value.term;
790
791 child->type = CODE_ERR;
792 child->value.term = NULL;
793
794 return node->value.term;
795 }
796
797
code_value_bool(CodeNode * node,bool bval)798 void code_value_bool(CodeNode* node, bool bval)
799 {
800 assert(code_is_valid(node));
801
802 code_free_value(node);
803
804 node->type = CODE_BOOL;
805 node->value.bval = bval;
806 }
807
code_value_size(CodeNode * node,int size)808 void code_value_size(CodeNode* node, int size)
809 {
810 assert(code_is_valid(node));
811
812 code_free_value(node);
813
814 node->type = CODE_SIZE;
815 node->value.size = size;
816 }
817
code_value_list(CodeNode * node,List * list)818 void code_value_list(CodeNode* node, List* list)
819 {
820 assert(code_is_valid(node));
821 assert(list_is_valid(list));
822
823 code_free_value(node);
824
825 node->type = CODE_LIST;
826 node->value.list = list;
827 }
828
code_value_varclass(CodeNode * node,VarClass varclass)829 void code_value_varclass(CodeNode* node, VarClass varclass)
830 {
831 assert(code_is_valid(node));
832
833 code_free_value(node);
834
835 node->type = CODE_VARCLASS;
836 node->value.varclass = varclass;
837 }
838
code_value_contype(CodeNode * node,ConType contype)839 void code_value_contype(CodeNode* node, ConType contype)
840 {
841 assert(code_is_valid(node));
842
843 code_free_value(node);
844
845 node->type = CODE_CONTYPE;
846 node->value.contype = contype;
847 }
848
code_value_rdef(CodeNode * node,RDef * rdef)849 void code_value_rdef(CodeNode* node, RDef* rdef)
850 {
851 assert(code_is_valid(node));
852 assert(rdef_is_valid(rdef));
853
854 code_free_value(node);
855
856 node->type = CODE_RDEF;
857 node->value.rdef = rdef;
858 }
859
code_value_rpar(CodeNode * node,RPar * rpar)860 void code_value_rpar(CodeNode* node, RPar* rpar)
861 {
862 assert(code_is_valid(node));
863 assert(rpar_is_valid(rpar));
864
865 code_free_value(node);
866
867 node->type = CODE_RPAR;
868 node->value.rpar = rpar;
869 }
870
code_value_bits(CodeNode * node,unsigned int bits)871 void code_value_bits(CodeNode* node, unsigned int bits)
872 {
873 assert(code_is_valid(node));
874
875 code_free_value(node);
876
877 node->type = CODE_BITS;
878 node->value.bits = bits;
879 }
880
code_value_bound(CodeNode * node,Bound * bound)881 void code_value_bound(CodeNode* node, Bound* bound)
882 {
883 assert(code_is_valid(node));
884
885 code_free_value(node);
886
887 node->type = CODE_BOUND;
888 node->value.bound = bound;
889 }
890
code_value_void(CodeNode * node)891 void code_value_void(CodeNode* node)
892 {
893 assert(code_is_valid(node));
894
895 code_free_value(node);
896
897 node->type = CODE_VOID;
898 }
899
code_copy_value(CodeNode * dst,const CodeNode * src)900 void code_copy_value(CodeNode* dst, const CodeNode* src)
901 {
902 assert(code_is_valid(dst));
903 assert(code_is_valid(src));
904
905 code_free_value(dst);
906
907 switch(src->type)
908 {
909 case CODE_NUMB :
910 dst->value.numb = numb_copy(src->value.numb);
911 break;
912 case CODE_STRG :
913 dst->value.strg = src->value.strg;
914 break;
915 case CODE_NAME :
916 dst->value.name = src->value.name;
917 break;
918 case CODE_TUPLE:
919 dst->value.tuple = tuple_copy(src->value.tuple);
920 break;
921 case CODE_SET :
922 dst->value.set = set_copy(src->value.set);
923 break;
924 case CODE_IDXSET :
925 dst->value.idxset = idxset_copy(src->value.idxset);
926 break;
927 case CODE_ENTRY :
928 dst->value.entry = entry_copy(src->value.entry);
929 break;
930 case CODE_TERM :
931 dst->value.term = term_copy(src->value.term);
932 break;
933 case CODE_BOOL :
934 dst->value.bval = src->value.bval;
935 break;
936 case CODE_SIZE :
937 dst->value.size = src->value.size;
938 break;
939 case CODE_LIST :
940 dst->value.list = list_copy(src->value.list);
941 break;
942 case CODE_VARCLASS :
943 dst->value.varclass = src->value.varclass;
944 break;
945 case CODE_CONTYPE :
946 dst->value.contype = src->value.contype;
947 break;
948 case CODE_RDEF :
949 dst->value.rdef = rdef_copy(src->value.rdef);
950 break;
951 case CODE_RPAR :
952 dst->value.rpar = rpar_copy(src->value.rpar);
953 break;
954 case CODE_BITS :
955 dst->value.bits = src->value.bits;
956 break;
957 case CODE_BOUND :
958 dst->value.bound = bound_copy(src->value.bound);
959 break;
960 case CODE_VOID :
961 break;
962 default :
963 abort();
964 }
965 dst->type = src->type;
966 }
967
968 /* ----------------------------------------------------------------------------
969 * Macro Funktionen for better inlining
970 * ----------------------------------------------------------------------------
971 */
code_eval_child(const CodeNode * node,int no)972 CodeNode* code_eval_child(const CodeNode* node, int no)
973 {
974 return code_eval(code_get_child(node, no));
975 }
976
code_eval_child_numb(const CodeNode * node,int no)977 const Numb* code_eval_child_numb(const CodeNode* node, int no)
978 {
979 return code_get_numb(code_eval(code_get_child(node, no)));
980 }
981
code_eval_child_strg(const CodeNode * node,int no)982 const char* code_eval_child_strg(const CodeNode* node, int no)
983 {
984 return code_get_strg(code_eval(code_get_child(node, no)));
985 }
986
code_eval_child_name(const CodeNode * node,int no)987 const char*code_eval_child_name(const CodeNode* node, int no)
988 {
989 return code_get_name(code_eval(code_get_child(node, no)));
990 }
991
code_eval_child_tuple(const CodeNode * node,int no)992 const Tuple* code_eval_child_tuple(const CodeNode* node, int no)
993 {
994 return code_get_tuple(code_eval(code_get_child(node, no)));
995 }
996
code_eval_child_set(const CodeNode * node,int no)997 const Set* code_eval_child_set(const CodeNode* node, int no)
998 {
999 return code_get_set(code_eval(code_get_child(node, no)));
1000 }
1001
code_eval_child_idxset(const CodeNode * node,int no)1002 const IdxSet* code_eval_child_idxset(const CodeNode* node, int no)
1003 {
1004 return code_get_idxset(code_eval(code_get_child(node, no)));
1005 }
1006
code_eval_child_entry(const CodeNode * node,int no)1007 const Entry* code_eval_child_entry(const CodeNode* node, int no)
1008 {
1009 return code_get_entry(code_eval(code_get_child(node, no)));
1010 }
1011
code_eval_child_term(const CodeNode * node,int no)1012 const Term* code_eval_child_term(const CodeNode* node, int no)
1013 {
1014 return code_get_term(code_eval(code_get_child(node, no)));
1015 }
1016
code_eval_child_size(const CodeNode * node,int no)1017 int code_eval_child_size(const CodeNode* node, int no)
1018 {
1019 return code_get_size(code_eval(code_get_child(node, no)));
1020 }
1021
code_eval_child_bool(const CodeNode * node,int no)1022 bool code_eval_child_bool(const CodeNode* node, int no)
1023 {
1024 return code_get_bool(code_eval(code_get_child(node, no)));
1025 }
1026
code_eval_child_list(const CodeNode * node,int no)1027 const List* code_eval_child_list(const CodeNode* node, int no)
1028 {
1029 return code_get_list(code_eval(code_get_child(node, no)));
1030 }
1031
code_eval_child_varclass(const CodeNode * node,int no)1032 VarClass code_eval_child_varclass(const CodeNode* node, int no)
1033 {
1034 return code_get_varclass(code_eval(code_get_child(node, no)));
1035 }
1036
code_eval_child_contype(const CodeNode * node,int no)1037 ConType code_eval_child_contype(const CodeNode* node, int no)
1038 {
1039 return code_get_contype(code_eval(code_get_child(node, no)));
1040 }
1041
code_eval_child_rdef(const CodeNode * node,int no)1042 const RDef* code_eval_child_rdef(const CodeNode* node, int no)
1043 {
1044 return code_get_rdef(code_eval(code_get_child(node, no)));
1045 }
1046
code_eval_child_rpar(const CodeNode * node,int no)1047 const RPar* code_eval_child_rpar(const CodeNode* node, int no)
1048 {
1049 return code_get_rpar(code_eval(code_get_child(node, no)));
1050 }
1051
code_eval_child_bits(const CodeNode * node,int no)1052 unsigned int code_eval_child_bits(const CodeNode* node, int no)
1053 {
1054 return code_get_bits(code_eval(code_get_child(node, no)));
1055 }
1056
code_eval_child_symbol(const CodeNode * node,int no)1057 Symbol* code_eval_child_symbol(const CodeNode* node, int no)
1058 {
1059 return code_get_symbol(code_eval(code_get_child(node, no)));
1060 }
1061
code_eval_child_define(const CodeNode * node,int no)1062 Define* code_eval_child_define(const CodeNode* node, int no)
1063 {
1064 return code_get_define(code_eval(code_get_child(node, no)));
1065 }
1066
code_eval_child_bound(const CodeNode * node,int no)1067 const Bound* code_eval_child_bound(const CodeNode* node, int no)
1068 {
1069 return code_get_bound(code_eval(code_get_child(node, no)));
1070 }
1071
1072
1073
1074
1075
1076
1077
1078
1079