?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / geniconvtbl / itm_comp.y
blob580211788c04e6026ec50ac40416fc569bb54a8f
1 %{
2 /*
3 * CDDL HEADER START
4 *
5 * The contents of this file are subject to the terms of the
6 * Common Development and Distribution License, Version 1.0 only
7 * (the "License"). You may not use this file except in compliance
8 * with the License.
9 *
10 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
11 * or http://www.opensolaris.org/os/licensing.
12 * See the License for the specific language governing permissions
13 * and limitations under the License.
14 *
15 * When distributing Covered Code, include this CDDL HEADER in each
16 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
17 * If applicable, add the following below this CDDL HEADER, with the
18 * fields enclosed by brackets "[]" replaced with your own identifying
19 * information: Portions Copyright [yyyy] [name of copyright owner]
20 *
21 * CDDL HEADER END
22 *
23 * Copyright (c) 1999 by Sun Microsystems, Inc.
24 * All rights reserved.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <ctype.h>
32 #include <libintl.h>
33 #include <errno.h>
34
35 #include "iconv_tm.h"
36 #include "itmcomp.h"
37 #include "itm_util.h"
38
39 %}
40
41 %start itm_def
42
43 %union yystacktype
44 {
45 int intval;
46
47 itm_num_t num;
48 itm_data_t *name;
49 itm_data_t *data;
50
51 itm_tbl_hdr_t *tbl_hdr;
52 itm_direc_t *direc_unit;
53 itm_expr_t *expr;
54
55 itmc_action_t action;
56 itmc_obj_t *obj;
57 itmc_map_t *map_list;
58 itmc_ref_t *itmc_ref;
59 itmc_map_attr_t *map_attr;
60 }
61
62 %type <intval> itm_def
63 %type <obj> def_element_list
64 %type <tbl_hdr> def_element
65
66 %type <tbl_hdr> direction
67 %type <obj> direction_unit_list
68 %type <obj> direction_unit
69
70 %type <action> action
71
72 %type <itmc_ref> condition
73 %type <obj> condition_list
74 %type <obj> condition_expr
75
76 %type <obj> range_list
77 %type <obj> range_pair
78
79 %type <obj> escseq_list
80 %type <obj> escseq
81
82 %type <tbl_hdr> map
83 %type <map_list> map_list
84 %type <map_list> map_pair
85 %type <map_attr> map_attribute
86 %type <intval> map_resultlen
87 %type <map_attr> map_type
88 %type <name> map_type_names
89
90 %type <tbl_hdr> operation
91 %type <obj> op_list
92 %type <obj> op_unit
93 %type <obj> op_if_else
94
95 %type <data> name
96
97 %type <expr> expr
98 %type <expr> itm_in
99
100 %token <name> ITMNAME
101 %token <name> NAME
102 %token <name> MAPTYPE_NAME
103 %token <data> HEXADECIMAL
104 %token <num> DECIMAL
105
106 %token ITM_DEFAULT
107 %token ITM_IDENTICAL
108
109 %token BETWEEN
110 %token BREAK
111 %token CONDITION
112 %token DIRECTION
113 %token DISCARD
114 %token ERROR
115 %token ITM_ELSE
116 %token ITM_INIT
117 %token ITM_FALSE
118 %token ITM_IF
119 %token ITM_IN
120 %token ITM_INSIZE
121 %token NOP
122 %token OPERATION
123 %token ITM_OUT
124 %token ITM_OUTSIZE
125 %token PRINTCHR
126 %token PRINTHD
127 %token PRINTINT
128 %token MAP
129 %token RESET
130 %token RETURN
131 %token ITM_TRUE
132 %token ESCAPESEQ
133 %token MAPTYPE
134 %token RESULTLEN
135
136
137 %token MAPTYPE_AUTO
138 %token MAPTYPE_INDEX
139 %token MAPTYPE_DENSE
140 %token MAPTYPE_HASH
141 %token MAPTYPE_BINARY
142
143 %token ELLIPSES
144 %token CBO CBC
145 %token SBO SBC
146 %token PO PC
147 %token SC
148 %token COMMA
149 %token COLON
150
151 %right ASSIGN
152 %left LOR
153 %left LAND
154 %left OR
155 %left XOR
156 %left AND
157 %left EQ NE
158 %left LT LE GT GE
159 %left SHL SHR
160 %left PLUS MINUS
161 %left MUL DIV MOD
162 %right NOT NEG UMINUS
163
164 %%
165
166 itm_def
167 : ITMNAME CBO def_element_list CBC
168 {
169 itm_def_process($1);
170 }
171 ;
172
173 def_element_list
174 : def_element SC
175 {
176 TRACE_MESSAGE('y', ("def_element_list: def_element ;\n"));
177 $$ = NULL;
178 }
179 | def_element_list def_element SC
180 {
181 TRACE_MESSAGE('y',
182 ("def_element_list: def_element_list def_element ;\n"));
183 $$ = NULL;
184 }
185 ;
186
187 def_element
188 : direction
189 {
190 TRACE_MESSAGE('y', ("def_element: direction\n"));
191 (void) obj_register(ITMC_OBJ_DIREC, (itm_data_t *)($1->name.itm_ptr),
192 $1, $1->size,
193 NULL, OBJ_REG_TAIL);
194 $$ = $1;
195 }
196 | condition
197 {
198 TRACE_MESSAGE('y', ("def_element: condition\n"));
199 $$ = (itm_tbl_hdr_t *)($1->referencee);
200 }
201 | map
202 {
203 TRACE_MESSAGE('y', ("def_element: map\n"));
204 if (NULL != $1) {
205 (void) obj_register(ITMC_OBJ_MAP,
206 (itm_data_t *)($1->name.itm_ptr),
207 $1, $1->size,
208 NULL, OBJ_REG_TAIL);
209 }
210 $$ = $1;
211 }
212 | operation
213 {
214 TRACE_MESSAGE('y', ("def_element: operation\n"));
215 (void) obj_register(ITMC_OBJ_OP, (itm_data_t *)($1->name.itm_ptr),
216 $1, $1->size,
217 NULL, OBJ_REG_TAIL);
218 $$ = $1;
219 }
220 ;
221
222 direction
223 : DIRECTION name CBO direction_unit_list CBC
224 {
225 TRACE_MESSAGE('y', ("direction name (direction_unit_list)\n"));
226 $$ = obj_table(ITM_TBL_DIREC, $2,
227 $4, sizeof (itm_direc_t));
228 }
229 | DIRECTION CBO direction_unit_list CBC
230 {
231 TRACE_MESSAGE('y', ("direction name (direction_unit_list)\n"));
232 $$ = obj_table(ITM_TBL_DIREC, NULL,
233 $3, sizeof (itm_direc_t));
234 }
235 ;
236
237 direction_unit_list
238 : direction_unit
239 {
240 TRACE_MESSAGE('y', ("direction_unit_list: direction_unit\n"));
241 $$ = obj_list_append(NULL, $1);
242 }
243 | direction_unit_list direction_unit
244 {
245 TRACE_MESSAGE('y', ("direction_unit_list: "
246 "direction_unit_list direction_unit\n"));
247 $$ = obj_list_append($1, $2);
248 }
249 ;
250
251 direction_unit
252 : condition action SC
253 {
254 TRACE_MESSAGE('y', ("direction_unit: condition action ;\n"));
255 $$ = direction_unit($1, NULL, &($2), NULL);
256 }
257 | condition name SC
258 {
259 itm_direc_t *direc;
260 TRACE_MESSAGE('y', ("direction_unit: condition NAME ;\n"));
261 $$ = direction_unit($1, NULL, NULL, $2);
262 }
263 | name action SC
264 {
265 itm_direc_t *direc;
266 TRACE_MESSAGE('y', ("direction_unit: NAME action ;\n"));
267 $$ = direction_unit(NULL, $1, &($2), NULL);
268 }
269 | name name SC
270 {
271 itm_direc_t *direc;
272 TRACE_MESSAGE('y', ("direction_unit: NAME NAME ;\n"));
273 $$ = direction_unit(NULL, $1, NULL, $2);
274 }
275 | ITM_TRUE action SC
276 {
277 itm_direc_t *direc;
278 $$ = direction_unit(NULL, NULL, &($2), NULL);
279 }
280 | ITM_TRUE name SC
281 {
282 itm_direc_t *direc;
283 TRACE_MESSAGE('y', ("direction_unit: TRUE NAME ;\n"));
284 $$ = direction_unit(NULL, NULL, NULL, $2);
285 }
286 ;
287
288 action
289 : direction
290 {
291 TRACE_MESSAGE('y', ("action: direction\n"));
292 $$.type = ITMC_OBJ_DIREC;
293 $$.tbl_hdr = $1;
294 }
295 | map
296 {
297 TRACE_MESSAGE('y', ("action: map\n"));
298 $$.type = ITMC_OBJ_MAP;
299 $$.tbl_hdr = $1;
300 }
301 | operation
302 {
303 TRACE_MESSAGE('y', ("action: operation\n"));
304 $$.type = ITMC_OBJ_OP;
305 $$.tbl_hdr = $1;
306 }
307 ;
308
309 condition
310 : CONDITION name CBO condition_list CBC
311 {
312 itm_tbl_hdr_t *tbl_hdr;
313 TRACE_MESSAGE('y', ("condition\n"));
314 tbl_hdr = obj_table(ITM_TBL_COND, $2,
315 $4, sizeof (itm_cond_t));
316 $$ = obj_register(ITMC_OBJ_COND, $2,
317 tbl_hdr, tbl_hdr->size,
318 NULL, OBJ_REG_TAIL);
319 }
320 | CONDITION CBO condition_list CBC
321 {
322 itm_tbl_hdr_t *tbl_hdr;
323 TRACE_MESSAGE('y', ("condition\n"));
324 tbl_hdr = obj_table(ITM_TBL_COND, NULL,
325 $3, sizeof (itm_cond_t));
326 $$ = obj_register(ITMC_OBJ_COND, NULL,
327 tbl_hdr, tbl_hdr->size,
328 NULL, OBJ_REG_TAIL);
329 }
330 ;
331
332 condition_list
333 : condition_expr SC
334 {
335 TRACE_MESSAGE('y', ("condition_list: condition_expr;\n"));
336 $$ = obj_list_append(NULL, $1);
337 }
338 | condition_list condition_expr SC
339 {
340 TRACE_MESSAGE('y', ("condition_list: "
341 "condition_list condition_expr;\n"));
342 $$ = obj_list_append($1, $2);
343 }
344 ;
345
346 condition_expr
347 : BETWEEN range_list
348 {
349 itm_tbl_hdr_t *range;
350 itm_cond_t *cond;
351 TRACE_MESSAGE('y', ("condition_expr: between\n"));
352 range = range_table(NULL, $2);
353 if (range == NULL) {
354 $$ = NULL;
355 } else {
356 $$ = malloc_vital(sizeof (itmc_obj_t));
357 $$->type = ITMC_OBJ_RANGE;
358 $$->name = NULL;
359 cond = malloc_vital(sizeof (itm_cond_t));
360 $$->obj = cond;
361 cond->type = ITM_COND_BETWEEN;
362 cond->operand.place.itm_ptr = (itm_place2_t)range;
363 $$->ref[0] = obj_register(ITMC_OBJ_RANGE, NULL,
364 range, range->size,
365 &(cond->operand.place),
366 OBJ_REG_TAIL);
367 $$->ref[1] = NULL;
368 $$->ref[2] = NULL;
369 $$->next = $$->last = NULL;
370 }
371 }
372 | expr
373 {
374 itm_cond_t *cond;
375 TRACE_MESSAGE('y', ("condition_expr: expr\n"));
376 $$ = malloc_vital(sizeof (itmc_obj_t));
377 $$->type = ITMC_OBJ_EXPR;
378 $$->name = NULL;
379 cond = malloc_vital(sizeof (itm_cond_t));
380 $$->obj = cond;
381 cond->type = ITM_COND_EXPR;
382 cond->operand.place.itm_ptr = (itm_place2_t)($1);
383 $$->ref[0] = obj_register(ITMC_OBJ_EXPR, NULL,
384 $1, sizeof (itm_expr_t),
385 &(cond->operand.place),
386 OBJ_REG_TAIL);
387 $$->ref[1] = NULL;
388 $$->ref[2] = NULL;
389 $$->next = $$->last = NULL;
390 }
391 | ESCAPESEQ escseq_list
392 {
393 itm_tbl_hdr_t *escseq;
394 itm_cond_t *cond;
395 TRACE_MESSAGE('y', ("condition_expr: escseq {escseq_list;}\n"));
396 escseq = escseq_table(NULL, $2);
397 if (escseq == NULL) {
398 $$ = NULL;
399 } else {
400 $$ = malloc_vital(sizeof (itmc_obj_t));
401 $$->type = ITMC_OBJ_ESCAPESEQ;
402 $$->name = NULL;
403 cond = malloc_vital(sizeof (itm_cond_t));
404 $$->obj = cond;
405 cond->type = ITM_COND_ESCAPESEQ;
406 cond->operand.place.itm_ptr = (itm_place2_t)escseq;
407 $$->ref[0] = obj_register(ITMC_OBJ_ESCAPESEQ, NULL,
408 escseq, escseq->size,
409 &(cond->operand.place),
410 OBJ_REG_TAIL);
411 $$->ref[1] = NULL;
412 $$->ref[2] = NULL;
413 $$->next = $$->last = NULL;
414 }
415 }
416 ;
417
418 range_list
419 : range_pair
420 {
421 TRACE_MESSAGE('y', ("range_list: range_pair\n"));
422 $$ = obj_list_append(NULL, $1);
423 }
424 | range_list COMMA range_pair
425 {
426 TRACE_MESSAGE('y', ("range_list: range_list, range_pair\n"));
427 $$ = obj_list_append($1, $3);
428 }
429 ;
430
431 range_pair
432 : HEXADECIMAL ELLIPSES HEXADECIMAL
433 {
434 itmc_data_pair_t *range;
435 TRACE_MESSAGE('y', ("range_pair: HEXADECIMAL...HEXADECIMAL\n"));
436 $$ = malloc_vital(sizeof (itmc_obj_t));
437 $$->type = ITMC_OBJ_RANGE;
438 $$->name = NULL;
439 range = malloc_vital(sizeof (itmc_data_pair_t));
440 $$->obj = range;
441 if (data_compare($1, $3) < 0) {
442 range->data0 = *($1);
443 range->data1 = *($3);
444 } else {
445 range->data0 = *($3);
446 range->data1 = *($1);
447 }
448 }
449 ;
450 escseq_list
451 : escseq
452 {
453 TRACE_MESSAGE('y', ("escseq_list: escseq\n"));
454 $$ = obj_list_append(NULL, $1);
455 }
456 | escseq_list COMMA escseq
457 {
458 TRACE_MESSAGE('y', ("escseq_list: escseq_list; escseq\n"));
459 $$ = obj_list_append($1, $3);
460 }
461 ;
462
463 escseq
464 : HEXADECIMAL
465 {
466 itm_data_t *escseq;
467 TRACE_MESSAGE('y', ("escseq: HEXADECIMAL\n"));
468 $$ = malloc_vital(sizeof (itmc_obj_t));
469 $$->type = ITMC_OBJ_ESCAPESEQ;
470 $$->name = NULL;
471 escseq = malloc_vital(sizeof (itm_data_t));
472 $$->obj = escseq;
473 *escseq = *($1);
474 }
475 ;
476
477 map : MAP name CBO map_list CBC
478 {
479 TRACE_MESSAGE('y', ("map: map name {map_list}\n"));
480 $$ = map_table($2, $4, NULL);
481 }
482 | MAP CBO map_list CBC
483 {
484 TRACE_MESSAGE('y', ("map: map {map_list}\n"));
485 $$ = map_table(NULL, $3, NULL);
486 }
487 | MAP name map_attribute CBO map_list CBC
488 {
489 TRACE_MESSAGE('y', ("map: map name attribute {map_list}\n"));
490 $$ = map_table($2, $5, $3);
491 }
492 | MAP map_attribute CBO map_list CBC
493 {
494 TRACE_MESSAGE('y', ("map: map attribute {map_list}\n"));
495 $$ = map_table(NULL, $4, $2);
496 }
497 ;
498
499 map_attribute
500 :map_type COMMA map_resultlen
501 {
502 TRACE_MESSAGE('y', ("map_attribute: map_type map_resultlen\n"));
503 $$ = $1;
504 $$->resultlen = $3;
505 }
506 |map_type
507 {
508 TRACE_MESSAGE('y', ("map_attribute: map_type\n"));
509 $$ = $1;
510 $$->resultlen = 0;
511 }
512 |map_resultlen COMMA map_type
513 {
514 TRACE_MESSAGE('y', ("map_attribute: map_resultlen map_type\n"));
515 $$ = $3;
516 $$->resultlen = $1;
517 }
518 |map_resultlen
519 {
520 TRACE_MESSAGE('y', ("map_attribute: map_resultlen\n"));
521 $$ = malloc_vital(sizeof (itmc_map_attr_t));
522 $$->resultlen = $1;
523 $$->type = NULL;
524 $$->hash_factor = 0;
525 }
526 ;
527
528 map_type
529 : MAPTYPE ASSIGN map_type_names COLON DECIMAL
530 {
531 TRACE_MESSAGE('y', ("map_type: maptype=type:factor(%d)\n",
532 $5));
533 $$ = malloc_vital(sizeof (itmc_map_attr_t));
534 $$->type = $3;
535 $$->hash_factor = $5;
536 }
537 | MAPTYPE ASSIGN map_type_names
538 {
539 TRACE_MESSAGE('y', ("map_type: maptype=type\n"));
540 $$ = malloc_vital(sizeof (itmc_map_attr_t));
541 $$->type = $3;
542 $$->hash_factor = 0;
543 }
544 ;
545
546 map_type_names
547 : MAPTYPE_NAME
548 {
549 TRACE_MESSAGE('y', ("map_type_names: size=%*s\n",
550 yylval.data->size, NSPTR(yylval.data)));
551 $$ = yylval.data;
552 }
553 ;
554
555
556 map_resultlen
557 : RESULTLEN ASSIGN DECIMAL
558 {
559 TRACE_MESSAGE('y', ("map_resultlen(%d)\n", $3));
560 $$ = $3;
561 }
562 ;
563
564 map_list
565 : map_pair
566 {
567 TRACE_MESSAGE('y', ("map_list: map_pair\n"));
568 $$ = map_list_append(NULL, $1);
569 }
570 | map_list map_pair
571 {
572 TRACE_MESSAGE('y', ("map_list: map_list map_pair\n"));
573 $$ = map_list_append($1, $2);
574 }
575 ;
576
577 map_pair
578 : HEXADECIMAL HEXADECIMAL
579 {
580 TRACE_MESSAGE('y', ("map_pair: HEXADECIMAL HEXADECIMAL\n"));
581 $$ = malloc_vital(sizeof (itmc_map_t));
582 $$->data_pair.data0 = *($1);
583 free($1);
584 $$->data_pair.data1 = *($2);
585 free($2);
586 }
587 | HEXADECIMAL ELLIPSES HEXADECIMAL HEXADECIMAL
588 {
589 TRACE_MESSAGE('y', ("map_pair: "
590 "HEXADECIMAL ELLIPSES HEXADECIMAL\n"));
591 $$ = malloc_vital(sizeof (itmc_map_t));
592 $$->data_pair.data0 = *($1);
593 $$->data_pair.range = *($3);
594 free($1);
595 free($3);
596 $$->data_pair.data1 = *($4);
597 free($4);
598 }
599 | ITM_DEFAULT HEXADECIMAL
600 {
601 TRACE_MESSAGE('y', ("map_pair: default HEXADECIMAL\n"));
602 $$ = malloc_vital(sizeof (itmc_map_t));
603 $$->data_pair.data0.size = 0;
604 $$->data_pair.data1 = *($2);
605 free($2);
606 }
607 | ITM_DEFAULT ITM_IDENTICAL
608 {
609 TRACE_MESSAGE('y', ("map_pair: default default\n"));
610 $$ = malloc_vital(sizeof (itmc_map_t));
611 $$->data_pair.data0.size = 0;
612 $$->data_pair.data1.size = 0;
613 }
614 | HEXADECIMAL ERROR /* NO RANGE */
615 {
616 TRACE_MESSAGE('y', ("map_pair: hexadecimal error\n"));
617 $$ = malloc_vital(sizeof (itmc_map_t));
618 $$->data_pair.data0 = *($1);
619 free($1);
620 $$->data_pair.data1.size = 0;
621 }
622 ;
623
624 operation
625 : OPERATION name CBO op_list CBC
626 {
627 TRACE_MESSAGE('y', ("operation: operation name {op_list}\n"));
628 $$ = obj_table(ITM_TBL_OP, $2,
629 $4, sizeof (itm_op_t));
630 }
631 | OPERATION CBO op_list CBC
632 {
633 TRACE_MESSAGE('y', ("operation: operation {op_list}\n"));
634 $$ = obj_table(ITM_TBL_OP, NULL,
635 $3, sizeof (itm_op_t));
636 }
637 | OPERATION ITM_INIT CBO op_list CBC
638 {
639 TRACE_MESSAGE('y', ("operation: operation init {op_list}\n"));
640 $$ = obj_table(ITM_TBL_OP_INIT, NULL,
641 $4, sizeof (itm_op_t));
642 }
643 | OPERATION RESET CBO op_list CBC
644 {
645 TRACE_MESSAGE('y', ("operation: operation reset {op_list}\n"));
646 $$ = obj_table(ITM_TBL_OP_RESET, NULL,
647 $4, sizeof (itm_op_t));
648 }
649 ;
650
651 op_list : op_unit
652 {
653 TRACE_MESSAGE('y', ("op_list: op_unit\n"));
654 $$ = obj_list_append(NULL, $1);
655 }
656 | op_list op_unit
657 {
658 TRACE_MESSAGE('y', ("op_list: op_list op_unit\n"));
659 $$ = obj_list_append($1, $2);
660 }
661 ;
662
663 op_unit : /* */ SC
664 {
665 TRACE_MESSAGE('y', ("op_unit: / *null */;\n"));
666 $$ = NULL;
667 }
668 | expr SC
669 {
670 TRACE_MESSAGE('y', ("op_unit: expr;\n"));
671 $$ = op_unary(ITM_OP_EXPR, $1, sizeof (itm_expr_t));
672 }
673 | ERROR SC
674 {
675 TRACE_MESSAGE('y', ("expr: error;\n"));
676 $$ = op_self_num(ITM_OP_ERROR_D, EINVAL);
677 }
678 | ERROR expr SC
679 {
680 TRACE_MESSAGE('y', ("expr: error;\n"));
681 if (ITM_EXPR_INT == $2->type) {
682 $$ = op_self_num(ITM_OP_ERROR_D, $2->data.itm_exnum);
683 } else {
684 $$ = op_unary(ITM_OP_ERROR, $2, sizeof (itm_expr_t));
685 }
686 }
687 | DISCARD SC
688 {
689 TRACE_MESSAGE('y', ("discard expr;\n"));
690 $$ = op_self_num(ITM_OP_DISCARD_D, 1);
691 }
692 | DISCARD expr SC
693 {
694 TRACE_MESSAGE('y', ("discard expr;\n"));
695 if (ITM_EXPR_INT == $2->type) {
696 $$ = op_self_num(ITM_OP_DISCARD_D, $2->data.itm_exnum);
697 } else {
698 $$ = op_unary(ITM_OP_DISCARD, $2, sizeof (itm_expr_t));
699 }
700 }
701 | ITM_OUT ASSIGN expr SC
702 {
703 TRACE_MESSAGE('y', ("out = expr;\n"));
704 switch ($3->type) {
705 case ITM_EXPR_INT:
706 $$ = op_unary(ITM_OP_OUT_D, $3, sizeof (itm_expr_t));
707 break;
708 case ITM_EXPR_SEQ:
709 $$ = op_unary(ITM_OP_OUT_S, $3, sizeof (itm_expr_t));
710 break;
711 case ITM_EXPR_REG:
712 $$ = op_unary(ITM_OP_OUT_R, $3, sizeof (itm_expr_t));
713 break;
714 case ITM_EXPR_IN_VECTOR_D:
715 $$ = op_unary(ITM_OP_OUT_INVD, $3, sizeof (itm_expr_t));
716 break;
717 default:
718 $$ = op_unary(ITM_OP_OUT, $3, sizeof (itm_expr_t));
719 break;
720 }
721 }
722 | DIRECTION name SC
723 {
724 itm_op_t *op;
725 TRACE_MESSAGE('y', ("direction NAME;\n"));
726 $$ = op_unit(ITM_OP_DIRECTION, NULL, 0, NULL, 0, NULL, 0);
727 op = (itm_op_t *)($$->obj);
728 op->data.operand[0].itm_ptr = (itm_place2_t)($2);
729 $$->ref[0] = obj_register(ITMC_OBJ_DIREC, $2,
730 NULL, 0,
731 &(op->data.operand[0]), OBJ_REG_TAIL);
732 }
733 | OPERATION name SC
734 {
735 itm_op_t *op;
736 TRACE_MESSAGE('y', ("operation NAME;\n"));
737 $$ = op_unit(ITM_OP_OPERATION, NULL, 0, NULL, 0, NULL, 0);
738 op = (itm_op_t *)($$->obj);
739 op->data.operand[0].itm_ptr = (itm_place2_t)($2);
740 $$->ref[0] = obj_register(ITMC_OBJ_OP, $2,
741 NULL, 0,
742 &(op->data.operand[0]), OBJ_REG_TAIL);
743 }
744 | OPERATION ITM_INIT SC
745 {
746 itm_op_t *op;
747 TRACE_MESSAGE('y', ("operation init;\n"));
748 $$ = op_self(ITM_OP_INIT);
749 }
750 | OPERATION RESET SC
751 {
752 itm_op_t *op;
753 TRACE_MESSAGE('y', ("operation reset;\n"));
754 $$ = op_self(ITM_OP_RESET);
755 }
756 | MAP name SC
757 {
758 itm_op_t *op;
759 TRACE_MESSAGE('y', ("map NAME;\n"));
760 $$ = op_unit(ITM_OP_MAP, NULL, 0, NULL, 0, NULL, 0);
761 op = (itm_op_t *)($$->obj);
762 op->data.operand[0].itm_ptr = (itm_place2_t)($2);
763 $$->ref[0] = obj_register(ITMC_OBJ_MAP, $2,
764 NULL, 0,
765 &(op->data.operand[0]), OBJ_REG_TAIL);
766 }
767 | MAP name expr SC
768 {
769 itm_op_t *op;
770 TRACE_MESSAGE('y', ("map NAME expr;\n"));
771 $$ = op_unit(ITM_OP_MAP, NULL, 0, $3,
772 sizeof (itm_expr_t), NULL, 0);
773 op = (itm_op_t *)($$->obj);
774 op->data.operand[0].itm_ptr = (itm_place2_t)($2);
775 $$->ref[0] = obj_register(ITMC_OBJ_MAP, $2,
776 NULL, 0,
777 &(op->data.operand[0]), OBJ_REG_TAIL);
778 }
779 | op_if_else
780 {
781 TRACE_MESSAGE('y', ("op_unit: op_if_else\n"));
782 $$ = $1;
783 }
784 | BREAK SC
785 {
786 TRACE_MESSAGE('y', ("break;\n"));
787 $$ = op_self(ITM_OP_BREAK);
788 }
789 | RETURN SC
790 {
791 TRACE_MESSAGE('y', ("return;\n"));
792 $$ = op_self(ITM_OP_RETURN);
793 }
794 | PRINTCHR expr SC
795 {
796 TRACE_MESSAGE('y', ("printchr expr;\n"));
797 $$ = op_unary(ITM_OP_PRINTCHR, $2, sizeof (itm_expr_t));
798 }
799 | PRINTHD expr SC
800 {
801 TRACE_MESSAGE('y', ("printchr expr;\n"));
802 $$ = op_unary(ITM_OP_PRINTHD, $2, sizeof (itm_expr_t));
803 }
804 | PRINTINT expr SC
805 {
806 TRACE_MESSAGE('y', ("printint expr;\n"));
807 $$ = op_unary(ITM_OP_PRINTINT, $2, sizeof (itm_expr_t));
808 }
809 ;
810
811 op_if_else
812 : ITM_IF PO expr PC CBO op_list CBC
813 {
814 itm_tbl_hdr_t *tbl_hdr;
815 TRACE_MESSAGE('y', ("op_if_else: if (expr) {op_list}\n"));
816 tbl_hdr = obj_table(ITM_TBL_OP, NULL,
817 $6, sizeof (itm_op_t));
818 $$ = op_unit(ITM_OP_IF,
819 $3, sizeof (itm_expr_t),
820 tbl_hdr, tbl_hdr->size,
821 NULL, 0);
822 }
823 | ITM_IF PO expr PC CBO op_list CBC ITM_ELSE op_if_else
824 {
825 itm_tbl_hdr_t *tbl_hdr1;
826 itm_tbl_hdr_t *tbl_hdr2;
827 TRACE_MESSAGE('y', ("op_if_else: "
828 "if (expr) {op_list} else op_if_else\n"));
829 tbl_hdr1 = obj_table(ITM_TBL_OP, NULL,
830 $6, sizeof (itm_op_t));
831 tbl_hdr2 = obj_table(ITM_TBL_OP, NULL,
832 $9, sizeof (itm_op_t));
833 $$ = op_unit(ITM_OP_IF_ELSE,
834 $3, sizeof (itm_expr_t),
835 tbl_hdr1, tbl_hdr1->size,
836 tbl_hdr2, tbl_hdr2->size);
837 }
838 | ITM_IF PO expr PC CBO op_list CBC ITM_ELSE CBO op_list CBC
839 {
840 itm_tbl_hdr_t *tbl_hdr1;
841 itm_tbl_hdr_t *tbl_hdr2;
842 TRACE_MESSAGE('y', ("op_if_else: "
843 "if (expr) {op_list} else {op_list}\n"));
844 tbl_hdr1 = obj_table(ITM_TBL_OP, NULL,
845 $6, sizeof (itm_op_t));
846 tbl_hdr2 = obj_table(ITM_TBL_OP, NULL,
847 $10, sizeof (itm_op_t));
848 $$ = op_unit(ITM_OP_IF_ELSE,
849 $3, sizeof (itm_expr_t),
850 tbl_hdr1, tbl_hdr1->size,
851 tbl_hdr2, tbl_hdr2->size);
852 }
853 ;
854
855 name : NAME
856 {
857 TRACE_MESSAGE('y', ("name: size=%*s\n",
858 yylval.data->size, NSPTR(yylval.data)));
859 $$ = yylval.data;
860 }
861 ;
862
863 itm_in : ITM_IN
864 {
865 TRACE_MESSAGE('y', ("in\n"));
866 $$ = expr_self(ITM_EXPR_IN, NULL);
867 }
868 ;
869
870 expr : PO expr PC
871 {
872 TRACE_MESSAGE('y', ("expr: (expr)\n"));
873 $$ = $2;
874 }
875 | name
876 {
877 TRACE_MESSAGE('y', ("expr: NAME\n"));
878 $$ = expr_self(ITM_EXPR_NAME, $1);
879 }
880 | HEXADECIMAL
881 {
882 TRACE_MESSAGE('y', ("expr: HEXADECIMAL\n"));
883 $$ = expr_self(ITM_EXPR_SEQ, yylval.data);
884 }
885 | DECIMAL
886 {
887 TRACE_MESSAGE('y', ("expr: DECIMAL\n"));
888 $$ = expr_self_num(ITM_EXPR_INT, yylval.num);
889 }
890 | itm_in SBO expr SBC
891 {
892 if (ITM_EXPR_INT == $3->type) {
893 TRACE_MESSAGE('y', ("expr: in[%ld]\n",
894 $3->data.itm_exnum));
895 $$ = expr_self_num(ITM_EXPR_IN_VECTOR_D,
896 $3->data.itm_exnum);
897 } else {
898 TRACE_MESSAGE('y', ("expr: in[expr]\n"));
899 $$ = expr_unary(ITM_EXPR_IN_VECTOR, $3);
900 }
901 }
902 | ITM_OUTSIZE
903 {
904 TRACE_MESSAGE('y', ("expr: outsize\n"));
905 $$ = expr_self_num(ITM_EXPR_OUT, 0);
906 }
907 | ITM_INSIZE
908 {
909 TRACE_MESSAGE('y', ("expr: inputsize\n"));
910 $$ = expr_self_num(ITM_EXPR_IN_VECTOR_D, (size_t)-1);
911 }
912 | ITM_TRUE
913 {
914 TRACE_MESSAGE('y', ("expr: true\n"));
915 $$ = expr_self_num(ITM_EXPR_TRUE, 1);
916 }
917 | ITM_FALSE
918 {
919 TRACE_MESSAGE('y', ("expr: false\n"));
920 $$ = expr_self_num(ITM_EXPR_FALSE, 0);
921 }
922 | itm_in EQ expr
923 {
924 TRACE_MESSAGE('y', ("expr: in == expr\n"));
925 $$ = expr_unary(ITM_EXPR_IN_EQ, $3);
926 }
927 | expr EQ itm_in
928 {
929 TRACE_MESSAGE('y', ("expr: expr == in\n"));
930 $$ = expr_unary(ITM_EXPR_IN_EQ, $1);
931 }
932 | NOT expr
933 {
934 TRACE_MESSAGE('y', ("expr: ! expr\n"));
935
936 if (ITM_EXPR_INT == $2->type) {
937 $$ = expr_self_num(ITM_EXPR_INT, !($2->data.itm_exnum));
938 } else {
939 $$ = expr_unary(ITM_EXPR_NOT, $2);
940 }
941 }
942 | NEG expr
943 {
944 TRACE_MESSAGE('y', ("expr: ~ expr\n"));
945 if (ITM_EXPR_INT == $2->type) {
946 $$ = expr_self_num(ITM_EXPR_INT, ~($2->data.itm_exnum));
947 } else {
948 $$ = expr_unary(ITM_EXPR_NEG, $2);
949 }
950 }
951 | MINUS expr %prec MUL
952 {
953 TRACE_MESSAGE('y', ("expr: - expr\n"));
954 if (ITM_EXPR_INT == $2->type) {
955 $$ = expr_self_num(ITM_EXPR_INT,
956 (-1) * ($2->data.itm_exnum));
957 } else {
958 $$ = expr_unary(ITM_EXPR_UMINUS, $2);
959 }
960 }
961 | expr PLUS expr
962 {
963 TRACE_MESSAGE('y', ("expr: expr + expr\n"));
964 $$ = expr_binary(ITM_EXPR_PLUS, $1, $3);
965 $1 = expr_seq_to_int($1);
966 $3 = expr_seq_to_int($3);
967 switch ($1->type) {
968 case ITM_EXPR_INT:
969 switch ($3->type) {
970 case ITM_EXPR_INT:
971 $$ = expr_binary2(ITM_EXPR_PLUS_D_D, $1, $3);
972 break;
973 case ITM_EXPR_REG:
974 $$ = expr_binary2(ITM_EXPR_PLUS_D_R, $1, $3);
975 break;
976 case ITM_EXPR_IN_VECTOR_D:
977 $$ = expr_binary2(ITM_EXPR_PLUS_D_INVD, $1, $3);
978 break;
979 default:
980 $$ = expr_binary2(ITM_EXPR_PLUS_D_E, $1, $3);
981 break;
982 }
983 break;
984 case ITM_EXPR_REG:
985 switch ($3->type) {
986 case ITM_EXPR_INT:
987 $$ = expr_binary2(ITM_EXPR_PLUS_R_D, $1, $3);
988 break;
989 case ITM_EXPR_REG:
990 $$ = expr_binary2(ITM_EXPR_PLUS_R_R, $1, $3);
991 break;
992 case ITM_EXPR_IN_VECTOR_D:
993 $$ = expr_binary2(ITM_EXPR_PLUS_R_INVD, $1, $3);
994 break;
995 default:
996 $$ = expr_binary2(ITM_EXPR_PLUS_R_E, $1, $3);
997 break;
998 }
999 break;
1000 case ITM_EXPR_IN_VECTOR_D:
1001 switch ($3->type) {
1002 case ITM_EXPR_INT:
1003 $$ = expr_binary2(ITM_EXPR_PLUS_INVD_D, $1, $3);
1004 break;
1005 case ITM_EXPR_REG:
1006 $$ = expr_binary2(ITM_EXPR_PLUS_INVD_R, $1, $3);
1007 break;
1008 case ITM_EXPR_IN_VECTOR_D:
1009 $$ = expr_binary2(ITM_EXPR_PLUS_INVD_INVD,
1010 $1, $3);
1011 break;
1012 default:
1013 $$ = expr_binary2(ITM_EXPR_PLUS_INVD_E, $1, $3);
1014 break;
1015 }
1016 break;
1017 default:
1018 switch ($3->type) {
1019 case ITM_EXPR_INT:
1020 $$ = expr_binary2(ITM_EXPR_PLUS_E_D, $1, $3);
1021 break;
1022 case ITM_EXPR_REG:
1023 $$ = expr_binary2(ITM_EXPR_PLUS_E_R, $1, $3);
1024 break;
1025 case ITM_EXPR_IN_VECTOR_D:
1026 $$ = expr_binary2(ITM_EXPR_PLUS_E_INVD, $1, $3);
1027 break;
1028 default:
1029 $$ = expr_binary2(ITM_EXPR_PLUS, $1, $3);
1030 break;
1031 }
1032 break;
1033 }
1034 }
1035 | expr MINUS expr
1036 {
1037 TRACE_MESSAGE('y', ("expr: expr - expr\n"));
1038 $$ = expr_binary(ITM_EXPR_MINUS, $1, $3);
1039 $1 = expr_seq_to_int($1);
1040 $3 = expr_seq_to_int($3);
1041 switch ($1->type) {
1042 case ITM_EXPR_INT:
1043 switch ($3->type) {
1044 case ITM_EXPR_INT:
1045 $$ = expr_binary2(ITM_EXPR_MINUS_D_D, $1, $3);
1046 break;
1047 case ITM_EXPR_REG:
1048 $$ = expr_binary2(ITM_EXPR_MINUS_D_R, $1, $3);
1049 break;
1050 case ITM_EXPR_IN_VECTOR_D:
1051 $$ = expr_binary2(ITM_EXPR_MINUS_D_INVD,
1052 $1, $3);
1053 break;
1054 default:
1055 $$ = expr_binary2(ITM_EXPR_MINUS_D_E, $1, $3);
1056 break;
1057 }
1058 break;
1059 case ITM_EXPR_REG:
1060 switch ($3->type) {
1061 case ITM_EXPR_INT:
1062 $$ = expr_binary2(ITM_EXPR_MINUS_R_D, $1, $3);
1063 break;
1064 case ITM_EXPR_REG:
1065 $$ = expr_binary2(ITM_EXPR_MINUS_R_R, $1, $3);
1066 break;
1067 case ITM_EXPR_IN_VECTOR_D:
1068 $$ = expr_binary2(ITM_EXPR_MINUS_R_INVD,
1069 $1, $3);
1070 break;
1071 default:
1072 $$ = expr_binary2(ITM_EXPR_MINUS_R_E, $1, $3);
1073 break;
1074 }
1075 break;
1076 case ITM_EXPR_IN_VECTOR_D:
1077 switch ($3->type) {
1078 case ITM_EXPR_INT:
1079 $$ = expr_binary2(ITM_EXPR_MINUS_INVD_D,
1080 $1, $3);
1081 break;
1082 case ITM_EXPR_REG:
1083 $$ = expr_binary2(ITM_EXPR_MINUS_INVD_R,
1084 $1, $3);
1085 break;
1086 case ITM_EXPR_IN_VECTOR_D:
1087 $$ = expr_binary2(ITM_EXPR_MINUS_INVD_INVD,
1088 $1, $3);
1089 break;
1090 default:
1091 $$ = expr_binary2(ITM_EXPR_MINUS_INVD_E,
1092 $1, $3);
1093 break;
1094 }
1095 break;
1096 default:
1097 switch ($3->type) {
1098 case ITM_EXPR_INT:
1099 $$ = expr_binary2(ITM_EXPR_MINUS_E_D, $1, $3);
1100 break;
1101 case ITM_EXPR_REG:
1102 $$ = expr_binary2(ITM_EXPR_MINUS_E_R, $1, $3);
1103 break;
1104 case ITM_EXPR_IN_VECTOR_D:
1105 $$ = expr_binary2(ITM_EXPR_MINUS_E_INVD,
1106 $1, $3);
1107 break;
1108 default:
1109 $$ = expr_binary2(ITM_EXPR_MINUS, $1, $3);
1110 break;
1111 }
1112 break;
1113 }
1114 }
1115 | expr MUL expr
1116 {
1117 TRACE_MESSAGE('y', ("expr: expr *expr\n"));
1118 $$ = expr_binary(ITM_EXPR_MUL, $1, $3);
1119 $1 = expr_seq_to_int($1);
1120 $3 = expr_seq_to_int($3);
1121 switch ($1->type) {
1122 case ITM_EXPR_INT:
1123 switch ($3->type) {
1124 case ITM_EXPR_INT:
1125 $$ = expr_binary2(ITM_EXPR_MUL_D_D, $1, $3);
1126 break;
1127 case ITM_EXPR_REG:
1128 $$ = expr_binary2(ITM_EXPR_MUL_D_R, $1, $3);
1129 break;
1130 case ITM_EXPR_IN_VECTOR_D:
1131 $$ = expr_binary2(ITM_EXPR_MUL_D_INVD, $1, $3);
1132 break;
1133 default:
1134 $$ = expr_binary2(ITM_EXPR_MUL_D_E, $1, $3);
1135 break;
1136 }
1137 break;
1138 case ITM_EXPR_REG:
1139 switch ($3->type) {
1140 case ITM_EXPR_INT:
1141 $$ = expr_binary2(ITM_EXPR_MUL_R_D, $1, $3);
1142 break;
1143 case ITM_EXPR_REG:
1144 $$ = expr_binary2(ITM_EXPR_MUL_R_R, $1, $3);
1145 break;
1146 case ITM_EXPR_IN_VECTOR_D:
1147 $$ = expr_binary2(ITM_EXPR_MUL_R_INVD, $1, $3);
1148 break;
1149 default:
1150 $$ = expr_binary2(ITM_EXPR_MUL_R_E, $1, $3);
1151 break;
1152 }
1153 break;
1154 case ITM_EXPR_IN_VECTOR_D:
1155 switch ($3->type) {
1156 case ITM_EXPR_INT:
1157 $$ = expr_binary2(ITM_EXPR_MUL_INVD_D, $1, $3);
1158 break;
1159 case ITM_EXPR_REG:
1160 $$ = expr_binary2(ITM_EXPR_MUL_INVD_R, $1, $3);
1161 break;
1162 case ITM_EXPR_IN_VECTOR_D:
1163 $$ = expr_binary2(ITM_EXPR_MUL_INVD_INVD,
1164 $1, $3);
1165 break;
1166 default:
1167 $$ = expr_binary2(ITM_EXPR_MUL_INVD_E, $1, $3);
1168 break;
1169 }
1170 break;
1171 default:
1172 switch ($3->type) {
1173 case ITM_EXPR_INT:
1174 $$ = expr_binary2(ITM_EXPR_MUL_E_D, $1, $3);
1175 break;
1176 case ITM_EXPR_REG:
1177 $$ = expr_binary2(ITM_EXPR_MUL_E_R, $1, $3);
1178 break;
1179 case ITM_EXPR_IN_VECTOR_D:
1180 $$ = expr_binary2(ITM_EXPR_MUL_E_INVD, $1, $3);
1181 break;
1182 default:
1183 $$ = expr_binary2(ITM_EXPR_MUL, $1, $3);
1184 break;
1185 }
1186 break;
1187 }
1188 }
1189 | expr DIV expr
1190 {
1191 TRACE_MESSAGE('y', ("expr: expr / expr\n"));
1192 $$ = expr_binary(ITM_EXPR_DIV, $1, $3);
1193 $1 = expr_seq_to_int($1);
1194 $3 = expr_seq_to_int($3);
1195 switch ($1->type) {
1196 case ITM_EXPR_INT:
1197 switch ($3->type) {
1198 case ITM_EXPR_INT:
1199 $$ = expr_binary2(ITM_EXPR_DIV_D_D, $1, $3);
1200 break;
1201 case ITM_EXPR_REG:
1202 $$ = expr_binary2(ITM_EXPR_DIV_D_R, $1, $3);
1203 break;
1204 case ITM_EXPR_IN_VECTOR_D:
1205 $$ = expr_binary2(ITM_EXPR_DIV_D_INVD, $1, $3);
1206 break;
1207 default:
1208 $$ = expr_binary2(ITM_EXPR_DIV_D_E, $1, $3);
1209 break;
1210 }
1211 break;
1212 case ITM_EXPR_REG:
1213 switch ($3->type) {
1214 case ITM_EXPR_INT:
1215 $$ = expr_binary2(ITM_EXPR_DIV_R_D, $1, $3);
1216 break;
1217 case ITM_EXPR_REG:
1218 $$ = expr_binary2(ITM_EXPR_DIV_R_R, $1, $3);
1219 break;
1220 case ITM_EXPR_IN_VECTOR_D:
1221 $$ = expr_binary2(ITM_EXPR_DIV_R_INVD, $1, $3);
1222 break;
1223 default:
1224 $$ = expr_binary2(ITM_EXPR_DIV_R_E, $1, $3);
1225 break;
1226 }
1227 break;
1228 case ITM_EXPR_IN_VECTOR_D:
1229 switch ($3->type) {
1230 case ITM_EXPR_INT:
1231 $$ = expr_binary2(ITM_EXPR_DIV_INVD_D, $1, $3);
1232 break;
1233 case ITM_EXPR_REG:
1234 $$ = expr_binary2(ITM_EXPR_DIV_INVD_R, $1, $3);
1235 break;
1236 case ITM_EXPR_IN_VECTOR_D:
1237 $$ = expr_binary2(ITM_EXPR_DIV_INVD_INVD,
1238 $1, $3);
1239 break;
1240 default:
1241 $$ = expr_binary2(ITM_EXPR_DIV_INVD_E, $1, $3);
1242 break;
1243 }
1244 break;
1245 default:
1246 switch ($3->type) {
1247 case ITM_EXPR_INT:
1248 $$ = expr_binary2(ITM_EXPR_DIV_E_D, $1, $3);
1249 break;
1250 case ITM_EXPR_REG:
1251 $$ = expr_binary2(ITM_EXPR_DIV_E_R, $1, $3);
1252 break;
1253 case ITM_EXPR_IN_VECTOR_D:
1254 $$ = expr_binary2(ITM_EXPR_DIV_E_INVD, $1, $3);
1255 break;
1256 default:
1257 $$ = expr_binary2(ITM_EXPR_DIV, $1, $3);
1258 break;
1259 }
1260 break;
1261 }
1262 }
1263 | expr MOD expr
1264 {
1265 TRACE_MESSAGE('y', ("expr: expr % expr\n"));
1266 $$ = expr_binary(ITM_EXPR_MOD, $1, $3);
1267 $1 = expr_seq_to_int($1);
1268 $3 = expr_seq_to_int($3);
1269 switch ($1->type) {
1270 case ITM_EXPR_INT:
1271 switch ($3->type) {
1272 case ITM_EXPR_INT:
1273 $$ = expr_binary2(ITM_EXPR_MOD_D_D, $1, $3);
1274 break;
1275 case ITM_EXPR_REG:
1276 $$ = expr_binary2(ITM_EXPR_MOD_D_R, $1, $3);
1277 break;
1278 case ITM_EXPR_IN_VECTOR_D:
1279 $$ = expr_binary2(ITM_EXPR_MOD_D_INVD, $1, $3);
1280 break;
1281 default:
1282 $$ = expr_binary2(ITM_EXPR_MOD_D_E, $1, $3);
1283 break;
1284 }
1285 break;
1286 case ITM_EXPR_REG:
1287 switch ($3->type) {
1288 case ITM_EXPR_INT:
1289 $$ = expr_binary2(ITM_EXPR_MOD_R_D, $1, $3);
1290 break;
1291 case ITM_EXPR_REG:
1292 $$ = expr_binary2(ITM_EXPR_MOD_R_R, $1, $3);
1293 break;
1294 case ITM_EXPR_IN_VECTOR_D:
1295 $$ = expr_binary2(ITM_EXPR_MOD_R_INVD, $1, $3);
1296 break;
1297 default:
1298 $$ = expr_binary2(ITM_EXPR_MOD_R_E, $1, $3);
1299 break;
1300 }
1301 break;
1302 case ITM_EXPR_IN_VECTOR_D:
1303 switch ($3->type) {
1304 case ITM_EXPR_INT:
1305 $$ = expr_binary2(ITM_EXPR_MOD_INVD_D, $1, $3);
1306 break;
1307 case ITM_EXPR_REG:
1308 $$ = expr_binary2(ITM_EXPR_MOD_INVD_R, $1, $3);
1309 break;
1310 case ITM_EXPR_IN_VECTOR_D:
1311 $$ = expr_binary2(ITM_EXPR_MOD_INVD_INVD,
1312 $1, $3);
1313 break;
1314 default:
1315 $$ = expr_binary2(ITM_EXPR_MOD_INVD_E, $1, $3);
1316 break;
1317 }
1318 break;
1319 default:
1320 switch ($3->type) {
1321 case ITM_EXPR_INT:
1322 $$ = expr_binary2(ITM_EXPR_MOD_E_D, $1, $3);
1323 break;
1324 case ITM_EXPR_REG:
1325 $$ = expr_binary2(ITM_EXPR_MOD_E_R, $1, $3);
1326 break;
1327 case ITM_EXPR_IN_VECTOR_D:
1328 $$ = expr_binary2(ITM_EXPR_MOD_E_INVD, $1, $3);
1329 break;
1330 default:
1331 $$ = expr_binary2(ITM_EXPR_MOD, $1, $3);
1332 break;
1333 }
1334 break;
1335 }
1336 }
1337 | expr SHL expr
1338 {
1339 TRACE_MESSAGE('y', ("expr: expr << expr\n"));
1340 $$ = expr_binary(ITM_EXPR_SHIFT_L, $1, $3);
1341 $1 = expr_seq_to_int($1);
1342 $3 = expr_seq_to_int($3);
1343 switch ($1->type) {
1344 case ITM_EXPR_INT:
1345 switch ($3->type) {
1346 case ITM_EXPR_INT:
1347 $$ = expr_binary2(ITM_EXPR_SHIFT_L_D_D, $1, $3);
1348 break;
1349 case ITM_EXPR_REG:
1350 $$ = expr_binary2(ITM_EXPR_SHIFT_L_D_R, $1, $3);
1351 break;
1352 case ITM_EXPR_IN_VECTOR_D:
1353 $$ = expr_binary2(ITM_EXPR_SHIFT_L_D_INVD,
1354 $1, $3);
1355 break;
1356 default:
1357 $$ = expr_binary2(ITM_EXPR_SHIFT_L_D_E, $1, $3);
1358 break;
1359 }
1360 break;
1361 case ITM_EXPR_REG:
1362 switch ($3->type) {
1363 case ITM_EXPR_INT:
1364 $$ = expr_binary2(ITM_EXPR_SHIFT_L_R_D, $1, $3);
1365 break;
1366 case ITM_EXPR_REG:
1367 $$ = expr_binary2(ITM_EXPR_SHIFT_L_R_R, $1, $3);
1368 break;
1369 case ITM_EXPR_IN_VECTOR_D:
1370 $$ = expr_binary2(ITM_EXPR_SHIFT_L_R_INVD,
1371 $1, $3);
1372 break;
1373 default:
1374 $$ = expr_binary2(ITM_EXPR_SHIFT_L_R_E, $1, $3);
1375 break;
1376 }
1377 break;
1378 case ITM_EXPR_IN_VECTOR_D:
1379 switch ($3->type) {
1380 case ITM_EXPR_INT:
1381 $$ = expr_binary2(ITM_EXPR_SHIFT_L_INVD_D,
1382 $1, $3);
1383 break;
1384 case ITM_EXPR_REG:
1385 $$ = expr_binary2(ITM_EXPR_SHIFT_L_INVD_R,
1386 $1, $3);
1387 break;
1388 case ITM_EXPR_IN_VECTOR_D:
1389 $$ = expr_binary2(ITM_EXPR_SHIFT_L_INVD_INVD,
1390 $1, $3);
1391 break;
1392 default:
1393 $$ = expr_binary2(ITM_EXPR_SHIFT_L_INVD_E,
1394 $1, $3);
1395 break;
1396 }
1397 break;
1398 default:
1399 switch ($3->type) {
1400 case ITM_EXPR_INT:
1401 $$ = expr_binary2(ITM_EXPR_SHIFT_L_E_D, $1, $3);
1402 break;
1403 case ITM_EXPR_REG:
1404 $$ = expr_binary2(ITM_EXPR_SHIFT_L_E_R, $1, $3);
1405 break;
1406 case ITM_EXPR_IN_VECTOR_D:
1407 $$ = expr_binary2(ITM_EXPR_SHIFT_L_E_INVD,
1408 $1, $3);
1409 break;
1410 default:
1411 $$ = expr_binary2(ITM_EXPR_SHIFT_L, $1, $3);
1412 break;
1413 }
1414 break;
1415 }
1416 }
1417 | expr SHR expr
1418 {
1419 TRACE_MESSAGE('y', ("expr: expr >> expr\n"));
1420 $$ = expr_binary(ITM_EXPR_SHIFT_R, $1, $3);
1421 $1 = expr_seq_to_int($1);
1422 $3 = expr_seq_to_int($3);
1423 switch ($1->type) {
1424 case ITM_EXPR_INT:
1425 switch ($3->type) {
1426 case ITM_EXPR_INT:
1427 $$ = expr_binary2(ITM_EXPR_SHIFT_R_D_D, $1, $3);
1428 break;
1429 case ITM_EXPR_REG:
1430 $$ = expr_binary2(ITM_EXPR_SHIFT_R_D_R, $1, $3);
1431 break;
1432 case ITM_EXPR_IN_VECTOR_D:
1433 $$ = expr_binary2(ITM_EXPR_SHIFT_R_D_INVD,
1434 $1, $3);
1435 break;
1436 default:
1437 $$ = expr_binary2(ITM_EXPR_SHIFT_R_D_E, $1, $3);
1438 break;
1439 }
1440 break;
1441 case ITM_EXPR_REG:
1442 switch ($3->type) {
1443 case ITM_EXPR_INT:
1444 $$ = expr_binary2(ITM_EXPR_SHIFT_R_R_D, $1, $3);
1445 break;
1446 case ITM_EXPR_REG:
1447 $$ = expr_binary2(ITM_EXPR_SHIFT_R_R_R, $1, $3);
1448 break;
1449 case ITM_EXPR_IN_VECTOR_D:
1450 $$ = expr_binary2(ITM_EXPR_SHIFT_R_R_INVD,
1451 $1, $3);
1452 break;
1453 default:
1454 $$ = expr_binary2(ITM_EXPR_SHIFT_R_R_E, $1, $3);
1455 break;
1456 }
1457 break;
1458 case ITM_EXPR_IN_VECTOR_D:
1459 switch ($3->type) {
1460 case ITM_EXPR_INT:
1461 $$ = expr_binary2(ITM_EXPR_SHIFT_R_INVD_D,
1462 $1, $3);
1463 break;
1464 case ITM_EXPR_REG:
1465 $$ = expr_binary2(ITM_EXPR_SHIFT_R_INVD_R,
1466 $1, $3);
1467 break;
1468 case ITM_EXPR_IN_VECTOR_D:
1469 $$ = expr_binary2(ITM_EXPR_SHIFT_R_INVD_INVD,
1470 $1, $3);
1471 break;
1472 default:
1473 $$ = expr_binary2(ITM_EXPR_SHIFT_R_INVD_E,
1474 $1, $3);
1475 break;
1476 }
1477 break;
1478 default:
1479 switch ($3->type) {
1480 case ITM_EXPR_INT:
1481 $$ = expr_binary2(ITM_EXPR_SHIFT_R_E_D, $1, $3);
1482 break;
1483 case ITM_EXPR_REG:
1484 $$ = expr_binary2(ITM_EXPR_SHIFT_R_E_R, $1, $3);
1485 break;
1486 case ITM_EXPR_IN_VECTOR_D:
1487 $$ = expr_binary2(ITM_EXPR_SHIFT_R_E_INVD,
1488 $1, $3);
1489 break;
1490 default:
1491 $$ = expr_binary2(ITM_EXPR_SHIFT_R, $1, $3);
1492 break;
1493 }
1494 break;
1495 }
1496 }
1497 | expr OR expr
1498 {
1499 TRACE_MESSAGE('y', ("expr: expr | expr\n"));
1500 $$ = expr_binary(ITM_EXPR_OR, $1, $3);
1501 $1 = expr_seq_to_int($1);
1502 $3 = expr_seq_to_int($3);
1503 switch ($1->type) {
1504 case ITM_EXPR_INT:
1505 switch ($3->type) {
1506 case ITM_EXPR_INT:
1507 $$ = expr_binary2(ITM_EXPR_OR_D_D, $1, $3);
1508 break;
1509 case ITM_EXPR_REG:
1510 $$ = expr_binary2(ITM_EXPR_OR_D_R, $1, $3);
1511 break;
1512 case ITM_EXPR_IN_VECTOR_D:
1513 $$ = expr_binary2(ITM_EXPR_OR_D_INVD, $1, $3);
1514 break;
1515 default:
1516 $$ = expr_binary2(ITM_EXPR_OR_D_E, $1, $3);
1517 break;
1518 }
1519 break;
1520 case ITM_EXPR_REG:
1521 switch ($3->type) {
1522 case ITM_EXPR_INT:
1523 $$ = expr_binary2(ITM_EXPR_OR_R_D, $1, $3);
1524 break;
1525 case ITM_EXPR_REG:
1526 $$ = expr_binary2(ITM_EXPR_OR_R_R, $1, $3);
1527 break;
1528 case ITM_EXPR_IN_VECTOR_D:
1529 $$ = expr_binary2(ITM_EXPR_OR_R_INVD, $1, $3);
1530 break;
1531 default:
1532 $$ = expr_binary2(ITM_EXPR_OR_R_E, $1, $3);
1533 break;
1534 }
1535 break;
1536 case ITM_EXPR_IN_VECTOR_D:
1537 switch ($3->type) {
1538 case ITM_EXPR_INT:
1539 $$ = expr_binary2(ITM_EXPR_OR_INVD_D, $1, $3);
1540 break;
1541 case ITM_EXPR_REG:
1542 $$ = expr_binary2(ITM_EXPR_OR_INVD_R, $1, $3);
1543 break;
1544 case ITM_EXPR_IN_VECTOR_D:
1545 $$ = expr_binary2(ITM_EXPR_OR_INVD_INVD,
1546 $1, $3);
1547 break;
1548 default:
1549 $$ = expr_binary2(ITM_EXPR_OR_INVD_E, $1, $3);
1550 break;
1551 }
1552 break;
1553 default:
1554 switch ($3->type) {
1555 case ITM_EXPR_INT:
1556 $$ = expr_binary2(ITM_EXPR_OR_E_D, $1, $3);
1557 break;
1558 case ITM_EXPR_REG:
1559 $$ = expr_binary2(ITM_EXPR_OR_E_R, $1, $3);
1560 break;
1561 case ITM_EXPR_IN_VECTOR_D:
1562 $$ = expr_binary2(ITM_EXPR_OR_E_INVD, $1, $3);
1563 break;
1564 default:
1565 $$ = expr_binary2(ITM_EXPR_OR, $1, $3);
1566 break;
1567 }
1568 break;
1569 }
1570 }
1571 | expr XOR expr
1572 {
1573 TRACE_MESSAGE('y', ("expr: expr ^ expr\n"));
1574 $$ = expr_binary(ITM_EXPR_XOR, $1, $3);
1575 $1 = expr_seq_to_int($1);
1576 $3 = expr_seq_to_int($3);
1577 switch ($1->type) {
1578 case ITM_EXPR_INT:
1579 switch ($3->type) {
1580 case ITM_EXPR_INT:
1581 $$ = expr_binary2(ITM_EXPR_XOR_D_D, $1, $3);
1582 break;
1583 case ITM_EXPR_REG:
1584 $$ = expr_binary2(ITM_EXPR_XOR_D_R, $1, $3);
1585 break;
1586 case ITM_EXPR_IN_VECTOR_D:
1587 $$ = expr_binary2(ITM_EXPR_XOR_D_INVD, $1, $3);
1588 break;
1589 default:
1590 $$ = expr_binary2(ITM_EXPR_XOR_D_E, $1, $3);
1591 break;
1592 }
1593 break;
1594 case ITM_EXPR_REG:
1595 switch ($3->type) {
1596 case ITM_EXPR_INT:
1597 $$ = expr_binary2(ITM_EXPR_XOR_R_D, $1, $3);
1598 break;
1599 case ITM_EXPR_REG:
1600 $$ = expr_binary2(ITM_EXPR_XOR_R_R, $1, $3);
1601 break;
1602 case ITM_EXPR_IN_VECTOR_D:
1603 $$ = expr_binary2(ITM_EXPR_XOR_R_INVD, $1, $3);
1604 break;
1605 default:
1606 $$ = expr_binary2(ITM_EXPR_XOR_R_E, $1, $3);
1607 break;
1608 }
1609 break;
1610 case ITM_EXPR_IN_VECTOR_D:
1611 switch ($3->type) {
1612 case ITM_EXPR_INT:
1613 $$ = expr_binary2(ITM_EXPR_XOR_INVD_D, $1, $3);
1614 break;
1615 case ITM_EXPR_REG:
1616 $$ = expr_binary2(ITM_EXPR_XOR_INVD_R, $1, $3);
1617 break;
1618 case ITM_EXPR_IN_VECTOR_D:
1619 $$ = expr_binary2(ITM_EXPR_XOR_INVD_INVD,
1620 $1, $3);
1621 break;
1622 default:
1623 $$ = expr_binary2(ITM_EXPR_XOR_INVD_E, $1, $3);
1624 break;
1625 }
1626 break;
1627 default:
1628 switch ($3->type) {
1629 case ITM_EXPR_INT:
1630 $$ = expr_binary2(ITM_EXPR_XOR_E_D, $1, $3);
1631 break;
1632 case ITM_EXPR_REG:
1633 $$ = expr_binary2(ITM_EXPR_XOR_E_R, $1, $3);
1634 break;
1635 case ITM_EXPR_IN_VECTOR_D:
1636 $$ = expr_binary2(ITM_EXPR_XOR_E_INVD, $1, $3);
1637 break;
1638 default:
1639 $$ = expr_binary2(ITM_EXPR_XOR, $1, $3);
1640 break;
1641 }
1642 break;
1643 }
1644 }
1645 | expr AND expr
1646 {
1647 TRACE_MESSAGE('y', ("expr: expr & expr\n"));
1648 $$ = expr_binary(ITM_EXPR_AND, $1, $3);
1649 $1 = expr_seq_to_int($1);
1650 $3 = expr_seq_to_int($3);
1651 switch ($1->type) {
1652 case ITM_EXPR_INT:
1653 switch ($3->type) {
1654 case ITM_EXPR_INT:
1655 $$ = expr_binary2(ITM_EXPR_AND_D_D, $1, $3);
1656 break;
1657 case ITM_EXPR_REG:
1658 $$ = expr_binary2(ITM_EXPR_AND_D_R, $1, $3);
1659 break;
1660 case ITM_EXPR_IN_VECTOR_D:
1661 $$ = expr_binary2(ITM_EXPR_AND_D_INVD, $1, $3);
1662 break;
1663 default:
1664 $$ = expr_binary2(ITM_EXPR_AND_D_E, $1, $3);
1665 break;
1666 }
1667 break;
1668 case ITM_EXPR_REG:
1669 switch ($3->type) {
1670 case ITM_EXPR_INT:
1671 $$ = expr_binary2(ITM_EXPR_AND_R_D, $1, $3);
1672 break;
1673 case ITM_EXPR_REG:
1674 $$ = expr_binary2(ITM_EXPR_AND_R_R, $1, $3);
1675 break;
1676 case ITM_EXPR_IN_VECTOR_D:
1677 $$ = expr_binary2(ITM_EXPR_AND_R_INVD, $1, $3);
1678 break;
1679 default:
1680 $$ = expr_binary2(ITM_EXPR_AND_R_E, $1, $3);
1681 break;
1682 }
1683 break;
1684 case ITM_EXPR_IN_VECTOR_D:
1685 switch ($3->type) {
1686 case ITM_EXPR_INT:
1687 $$ = expr_binary2(ITM_EXPR_AND_INVD_D, $1, $3);
1688 break;
1689 case ITM_EXPR_REG:
1690 $$ = expr_binary2(ITM_EXPR_AND_INVD_R, $1, $3);
1691 break;
1692 case ITM_EXPR_IN_VECTOR_D:
1693 $$ = expr_binary2(ITM_EXPR_AND_INVD_INVD,
1694 $1, $3);
1695 break;
1696 default:
1697 $$ = expr_binary2(ITM_EXPR_AND_INVD_E, $1, $3);
1698 break;
1699 }
1700 break;
1701 default:
1702 switch ($3->type) {
1703 case ITM_EXPR_INT:
1704 $$ = expr_binary2(ITM_EXPR_AND_E_D, $1, $3);
1705 break;
1706 case ITM_EXPR_REG:
1707 $$ = expr_binary2(ITM_EXPR_AND_E_R, $1, $3);
1708 break;
1709 case ITM_EXPR_IN_VECTOR_D:
1710 $$ = expr_binary2(ITM_EXPR_AND_E_INVD, $1, $3);
1711 break;
1712 default:
1713 $$ = expr_binary2(ITM_EXPR_AND, $1, $3);
1714 break;
1715 }
1716 break;
1717 }
1718 }
1719 | expr EQ expr
1720 {
1721 TRACE_MESSAGE('y', ("expr: expr == expr\n"));
1722 $$ = expr_binary(ITM_EXPR_EQ, $1, $3);
1723 $1 = expr_seq_to_int($1);
1724 $3 = expr_seq_to_int($3);
1725 switch ($1->type) {
1726 case ITM_EXPR_INT:
1727 switch ($3->type) {
1728 case ITM_EXPR_INT:
1729 $$ = expr_binary2(ITM_EXPR_EQ_D_D, $1, $3);
1730 break;
1731 case ITM_EXPR_REG:
1732 $$ = expr_binary2(ITM_EXPR_EQ_D_R, $1, $3);
1733 break;
1734 case ITM_EXPR_IN_VECTOR_D:
1735 $$ = expr_binary2(ITM_EXPR_EQ_D_INVD, $1, $3);
1736 break;
1737 default:
1738 $$ = expr_binary2(ITM_EXPR_EQ_D_E, $1, $3);
1739 break;
1740 }
1741 break;
1742 case ITM_EXPR_REG:
1743 switch ($3->type) {
1744 case ITM_EXPR_INT:
1745 $$ = expr_binary2(ITM_EXPR_EQ_R_D, $1, $3);
1746 break;
1747 case ITM_EXPR_REG:
1748 $$ = expr_binary2(ITM_EXPR_EQ_R_R, $1, $3);
1749 break;
1750 case ITM_EXPR_IN_VECTOR_D:
1751 $$ = expr_binary2(ITM_EXPR_EQ_R_INVD, $1, $3);
1752 break;
1753 default:
1754 $$ = expr_binary2(ITM_EXPR_EQ_R_E, $1, $3);
1755 break;
1756 }
1757 break;
1758 case ITM_EXPR_IN_VECTOR_D:
1759 switch ($3->type) {
1760 case ITM_EXPR_INT:
1761 $$ = expr_binary2(ITM_EXPR_EQ_INVD_D, $1, $3);
1762 break;
1763 case ITM_EXPR_REG:
1764 $$ = expr_binary2(ITM_EXPR_EQ_INVD_R, $1, $3);
1765 break;
1766 case ITM_EXPR_IN_VECTOR_D:
1767 $$ = expr_binary2(ITM_EXPR_EQ_INVD_INVD,
1768 $1, $3);
1769 break;
1770 default:
1771 $$ = expr_binary2(ITM_EXPR_EQ_INVD_E, $1, $3);
1772 break;
1773 }
1774 break;
1775 default:
1776 switch ($3->type) {
1777 case ITM_EXPR_INT:
1778 $$ = expr_binary2(ITM_EXPR_EQ_E_D, $1, $3);
1779 break;
1780 case ITM_EXPR_REG:
1781 $$ = expr_binary2(ITM_EXPR_EQ_E_R, $1, $3);
1782 break;
1783 case ITM_EXPR_IN_VECTOR_D:
1784 $$ = expr_binary2(ITM_EXPR_EQ_E_INVD, $1, $3);
1785 break;
1786 default:
1787 $$ = expr_binary2(ITM_EXPR_EQ, $1, $3);
1788 break;
1789 }
1790 break;
1791 }
1792 }
1793 | expr NE expr
1794 {
1795 TRACE_MESSAGE('y', ("expr: expr != expr\n"));
1796 $$ = expr_binary(ITM_EXPR_NE, $1, $3);
1797 $1 = expr_seq_to_int($1);
1798 $3 = expr_seq_to_int($3);
1799 switch ($1->type) {
1800 case ITM_EXPR_INT:
1801 switch ($3->type) {
1802 case ITM_EXPR_INT:
1803 $$ = expr_binary2(ITM_EXPR_NE_D_D, $1, $3);
1804 break;
1805 case ITM_EXPR_REG:
1806 $$ = expr_binary2(ITM_EXPR_NE_D_R, $1, $3);
1807 break;
1808 case ITM_EXPR_IN_VECTOR_D:
1809 $$ = expr_binary2(ITM_EXPR_NE_D_INVD, $1, $3);
1810 break;
1811 default:
1812 $$ = expr_binary2(ITM_EXPR_NE_D_E, $1, $3);
1813 break;
1814 }
1815 break;
1816 case ITM_EXPR_REG:
1817 switch ($3->type) {
1818 case ITM_EXPR_INT:
1819 $$ = expr_binary2(ITM_EXPR_NE_R_D, $1, $3);
1820 break;
1821 case ITM_EXPR_REG:
1822 $$ = expr_binary2(ITM_EXPR_NE_R_R, $1, $3);
1823 break;
1824 case ITM_EXPR_IN_VECTOR_D:
1825 $$ = expr_binary2(ITM_EXPR_NE_R_INVD, $1, $3);
1826 break;
1827 default:
1828 $$ = expr_binary2(ITM_EXPR_NE_R_E, $1, $3);
1829 break;
1830 }
1831 break;
1832 case ITM_EXPR_IN_VECTOR_D:
1833 switch ($3->type) {
1834 case ITM_EXPR_INT:
1835 $$ = expr_binary2(ITM_EXPR_NE_INVD_D, $1, $3);
1836 break;
1837 case ITM_EXPR_REG:
1838 $$ = expr_binary2(ITM_EXPR_NE_INVD_R, $1, $3);
1839 break;
1840 case ITM_EXPR_IN_VECTOR_D:
1841 $$ = expr_binary2(ITM_EXPR_NE_INVD_INVD,
1842 $1, $3);
1843 break;
1844 default:
1845 $$ = expr_binary2(ITM_EXPR_NE_INVD_E, $1, $3);
1846 break;
1847 }
1848 break;
1849 default:
1850 switch ($3->type) {
1851 case ITM_EXPR_INT:
1852 $$ = expr_binary2(ITM_EXPR_NE_E_D, $1, $3);
1853 break;
1854 case ITM_EXPR_REG:
1855 $$ = expr_binary2(ITM_EXPR_NE_E_R, $1, $3);
1856 break;
1857 case ITM_EXPR_IN_VECTOR_D:
1858 $$ = expr_binary2(ITM_EXPR_NE_E_INVD, $1, $3);
1859 break;
1860 default:
1861 $$ = expr_binary2(ITM_EXPR_NE, $1, $3);
1862 break;
1863 }
1864 break;
1865 }
1866 }
1867 | expr GT expr
1868 {
1869 TRACE_MESSAGE('y', ("expr: expr > expr\n"));
1870 $$ = expr_binary(ITM_EXPR_GT, $1, $3);
1871 $1 = expr_seq_to_int($1);
1872 $3 = expr_seq_to_int($3);
1873 switch ($1->type) {
1874 case ITM_EXPR_INT:
1875 switch ($3->type) {
1876 case ITM_EXPR_INT:
1877 $$ = expr_binary2(ITM_EXPR_GT_D_D, $1, $3);
1878 break;
1879 case ITM_EXPR_REG:
1880 $$ = expr_binary2(ITM_EXPR_GT_D_R, $1, $3);
1881 break;
1882 case ITM_EXPR_IN_VECTOR_D:
1883 $$ = expr_binary2(ITM_EXPR_GT_D_INVD, $1, $3);
1884 break;
1885 default:
1886 $$ = expr_binary2(ITM_EXPR_GT_D_E, $1, $3);
1887 break;
1888 }
1889 break;
1890 case ITM_EXPR_REG:
1891 switch ($3->type) {
1892 case ITM_EXPR_INT:
1893 $$ = expr_binary2(ITM_EXPR_GT_R_D, $1, $3);
1894 break;
1895 case ITM_EXPR_REG:
1896 $$ = expr_binary2(ITM_EXPR_GT_R_R, $1, $3);
1897 break;
1898 case ITM_EXPR_IN_VECTOR_D:
1899 $$ = expr_binary2(ITM_EXPR_GT_R_INVD, $1, $3);
1900 break;
1901 default:
1902 $$ = expr_binary2(ITM_EXPR_GT_R_E, $1, $3);
1903 break;
1904 }
1905 break;
1906 case ITM_EXPR_IN_VECTOR_D:
1907 switch ($3->type) {
1908 case ITM_EXPR_INT:
1909 $$ = expr_binary2(ITM_EXPR_GT_INVD_D, $1, $3);
1910 break;
1911 case ITM_EXPR_REG:
1912 $$ = expr_binary2(ITM_EXPR_GT_INVD_R, $1, $3);
1913 break;
1914 case ITM_EXPR_IN_VECTOR_D:
1915 $$ = expr_binary2(ITM_EXPR_GT_INVD_INVD,
1916 $1, $3);
1917 break;
1918 default:
1919 $$ = expr_binary2(ITM_EXPR_GT_INVD_E, $1, $3);
1920 break;
1921 }
1922 break;
1923 default:
1924 switch ($3->type) {
1925 case ITM_EXPR_INT:
1926 $$ = expr_binary2(ITM_EXPR_GT_E_D, $1, $3);
1927 break;
1928 case ITM_EXPR_REG:
1929 $$ = expr_binary2(ITM_EXPR_GT_E_R, $1, $3);
1930 break;
1931 case ITM_EXPR_IN_VECTOR_D:
1932 $$ = expr_binary2(ITM_EXPR_GT_E_INVD, $1, $3);
1933 break;
1934 default:
1935 $$ = expr_binary2(ITM_EXPR_GT, $1, $3);
1936 break;
1937 }
1938 break;
1939 }
1940 }
1941 | expr GE expr
1942 {
1943 TRACE_MESSAGE('y', ("expr: expr >= expr\n"));
1944 $$ = expr_binary(ITM_EXPR_GE, $1, $3);
1945 $1 = expr_seq_to_int($1);
1946 $3 = expr_seq_to_int($3);
1947 switch ($1->type) {
1948 case ITM_EXPR_INT:
1949 switch ($3->type) {
1950 case ITM_EXPR_INT:
1951 $$ = expr_binary2(ITM_EXPR_GE_D_D, $1, $3);
1952 break;
1953 case ITM_EXPR_REG:
1954 $$ = expr_binary2(ITM_EXPR_GE_D_R, $1, $3);
1955 break;
1956 case ITM_EXPR_IN_VECTOR_D:
1957 $$ = expr_binary2(ITM_EXPR_GE_D_INVD, $1, $3);
1958 break;
1959 default:
1960 $$ = expr_binary2(ITM_EXPR_GE_D_E, $1, $3);
1961 break;
1962 }
1963 break;
1964 case ITM_EXPR_REG:
1965 switch ($3->type) {
1966 case ITM_EXPR_INT:
1967 $$ = expr_binary2(ITM_EXPR_GE_R_D, $1, $3);
1968 break;
1969 case ITM_EXPR_REG:
1970 $$ = expr_binary2(ITM_EXPR_GE_R_R, $1, $3);
1971 break;
1972 case ITM_EXPR_IN_VECTOR_D:
1973 $$ = expr_binary2(ITM_EXPR_GE_R_INVD, $1, $3);
1974 break;
1975 default:
1976 $$ = expr_binary2(ITM_EXPR_GE_R_E, $1, $3);
1977 break;
1978 }
1979 break;
1980 case ITM_EXPR_IN_VECTOR_D:
1981 switch ($3->type) {
1982 case ITM_EXPR_INT:
1983 $$ = expr_binary2(ITM_EXPR_GE_INVD_D, $1, $3);
1984 break;
1985 case ITM_EXPR_REG:
1986 $$ = expr_binary2(ITM_EXPR_GE_INVD_R, $1, $3);
1987 break;
1988 case ITM_EXPR_IN_VECTOR_D:
1989 $$ = expr_binary2(ITM_EXPR_GE_INVD_INVD,
1990 $1, $3);
1991 break;
1992 default:
1993 $$ = expr_binary2(ITM_EXPR_GE_INVD_E, $1, $3);
1994 break;
1995 }
1996 break;
1997 default:
1998 switch ($3->type) {
1999 case ITM_EXPR_INT:
2000 $$ = expr_binary2(ITM_EXPR_GE_E_D, $1, $3);
2001 break;
2002 case ITM_EXPR_REG:
2003 $$ = expr_binary2(ITM_EXPR_GE_E_R, $1, $3);
2004 break;
2005 case ITM_EXPR_IN_VECTOR_D:
2006 $$ = expr_binary2(ITM_EXPR_GE_E_INVD, $1, $3);
2007 break;
2008 default:
2009 $$ = expr_binary2(ITM_EXPR_GE, $1, $3);
2010 break;
2011 }
2012 break;
2013 }
2014 }
2015 | expr LT expr
2016 {
2017 TRACE_MESSAGE('y', ("expr: expr < expr\n"));
2018 $$ = expr_binary(ITM_EXPR_LT, $1, $3);
2019 $1 = expr_seq_to_int($1);
2020 $3 = expr_seq_to_int($3);
2021 switch ($1->type) {
2022 case ITM_EXPR_INT:
2023 switch ($3->type) {
2024 case ITM_EXPR_INT:
2025 $$ = expr_binary2(ITM_EXPR_LT_D_D, $1, $3);
2026 break;
2027 case ITM_EXPR_REG:
2028 $$ = expr_binary2(ITM_EXPR_LT_D_R, $1, $3);
2029 break;
2030 case ITM_EXPR_IN_VECTOR_D:
2031 $$ = expr_binary2(ITM_EXPR_LT_D_INVD, $1, $3);
2032 break;
2033 default:
2034 $$ = expr_binary2(ITM_EXPR_LT_D_E, $1, $3);
2035 break;
2036 }
2037 break;
2038 case ITM_EXPR_REG:
2039 switch ($3->type) {
2040 case ITM_EXPR_INT:
2041 $$ = expr_binary2(ITM_EXPR_LT_R_D, $1, $3);
2042 break;
2043 case ITM_EXPR_REG:
2044 $$ = expr_binary2(ITM_EXPR_LT_R_R, $1, $3);
2045 break;
2046 case ITM_EXPR_IN_VECTOR_D:
2047 $$ = expr_binary2(ITM_EXPR_LT_R_INVD, $1, $3);
2048 break;
2049 default:
2050 $$ = expr_binary2(ITM_EXPR_LT_R_E, $1, $3);
2051 break;
2052 }
2053 break;
2054 case ITM_EXPR_IN_VECTOR_D:
2055 switch ($3->type) {
2056 case ITM_EXPR_INT:
2057 $$ = expr_binary2(ITM_EXPR_LT_INVD_D, $1, $3);
2058 break;
2059 case ITM_EXPR_REG:
2060 $$ = expr_binary2(ITM_EXPR_LT_INVD_R, $1, $3);
2061 break;
2062 case ITM_EXPR_IN_VECTOR_D:
2063 $$ = expr_binary2(ITM_EXPR_LT_INVD_INVD,
2064 $1, $3);
2065 break;
2066 default:
2067 $$ = expr_binary2(ITM_EXPR_LT_INVD_E, $1, $3);
2068 break;
2069 }
2070 break;
2071 default:
2072 switch ($3->type) {
2073 case ITM_EXPR_INT:
2074 $$ = expr_binary2(ITM_EXPR_LT_E_D, $1, $3);
2075 break;
2076 case ITM_EXPR_REG:
2077 $$ = expr_binary2(ITM_EXPR_LT_E_R, $1, $3);
2078 break;
2079 case ITM_EXPR_IN_VECTOR_D:
2080 $$ = expr_binary2(ITM_EXPR_LT_E_INVD, $1, $3);
2081 break;
2082 default:
2083 $$ = expr_binary2(ITM_EXPR_LT, $1, $3);
2084 break;
2085 }
2086 break;
2087 }
2088 }
2089 | expr LE expr
2090 {
2091 TRACE_MESSAGE('y', ("expr: expr <= expr\n"));
2092 $$ = expr_binary(ITM_EXPR_LE, $1, $3);
2093 $1 = expr_seq_to_int($1);
2094 $3 = expr_seq_to_int($3);
2095 switch ($1->type) {
2096 case ITM_EXPR_INT:
2097 switch ($3->type) {
2098 case ITM_EXPR_INT:
2099 $$ = expr_binary2(ITM_EXPR_LE_D_D, $1, $3);
2100 break;
2101 case ITM_EXPR_REG:
2102 $$ = expr_binary2(ITM_EXPR_LE_D_R, $1, $3);
2103 break;
2104 case ITM_EXPR_IN_VECTOR_D:
2105 $$ = expr_binary2(ITM_EXPR_LE_D_INVD, $1, $3);
2106 break;
2107 default:
2108 $$ = expr_binary2(ITM_EXPR_LE_D_E, $1, $3);
2109 break;
2110 }
2111 break;
2112 case ITM_EXPR_REG:
2113 switch ($3->type) {
2114 case ITM_EXPR_INT:
2115 $$ = expr_binary2(ITM_EXPR_LE_R_D, $1, $3);
2116 break;
2117 case ITM_EXPR_REG:
2118 $$ = expr_binary2(ITM_EXPR_LE_R_R, $1, $3);
2119 break;
2120 case ITM_EXPR_IN_VECTOR_D:
2121 $$ = expr_binary2(ITM_EXPR_LE_R_INVD, $1, $3);
2122 break;
2123 default:
2124 $$ = expr_binary2(ITM_EXPR_LE_R_E, $1, $3);
2125 break;
2126 }
2127 break;
2128 case ITM_EXPR_IN_VECTOR_D:
2129 switch ($3->type) {
2130 case ITM_EXPR_INT:
2131 $$ = expr_binary2(ITM_EXPR_LE_INVD_D, $1, $3);
2132 break;
2133 case ITM_EXPR_REG:
2134 $$ = expr_binary2(ITM_EXPR_LE_INVD_R, $1, $3);
2135 break;
2136 case ITM_EXPR_IN_VECTOR_D:
2137 $$ = expr_binary2(ITM_EXPR_LE_INVD_INVD,
2138 $1, $3);
2139 break;
2140 default:
2141 $$ = expr_binary2(ITM_EXPR_LE_INVD_E, $1, $3);
2142 break;
2143 }
2144 break;
2145 default:
2146 switch ($3->type) {
2147 case ITM_EXPR_INT:
2148 $$ = expr_binary2(ITM_EXPR_LE_E_D, $1, $3);
2149 break;
2150 case ITM_EXPR_REG:
2151 $$ = expr_binary2(ITM_EXPR_LE_E_R, $1, $3);
2152 break;
2153 case ITM_EXPR_IN_VECTOR_D:
2154 $$ = expr_binary2(ITM_EXPR_LE_E_INVD, $1, $3);
2155 break;
2156 default:
2157 $$ = expr_binary2(ITM_EXPR_LE, $1, $3);
2158 break;
2159 }
2160 break;
2161 }
2162 }
2163 | name ASSIGN expr
2164 {
2165 TRACE_MESSAGE('y', ("expr: NAME = expr\n"));
2166 $$ = expr_assign(ITM_EXPR_ASSIGN, $1, $3);
2167 }
2168 | expr LOR expr
2169 {
2170 TRACE_MESSAGE('y', ("expr: expr || expr\n"));
2171 $$ = expr_binary(ITM_EXPR_LOR, $1, $3);
2172 }
2173 | expr LAND expr
2174 {
2175 TRACE_MESSAGE('y', ("expr: expr && expr\n"));
2176 $$ = expr_binary(ITM_EXPR_LAND, $1, $3);
2177 }
2178 ;
2179
2180 %%
unleashed repo fork