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 %% 2181