1 2 # line 2 "../itm_comp.y" 3 /* 4 * CDDL HEADER START 5 * 6 * The contents of this file are subject to the terms of the 7 * Common Development and Distribution License, Version 1.0 only 8 * (the "License"). You may not use this file except in compliance 9 * with the License. 10 * 11 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 12 * or http://www.opensolaris.org/os/licensing. 13 * See the License for the specific language governing permissions 14 * and limitations under the License. 15 * 16 * When distributing Covered Code, include this CDDL HEADER in each 17 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 18 * If applicable, add the following below this CDDL HEADER, with the 19 * fields enclosed by brackets "[]" replaced with your own identifying 20 * information: Portions Copyright [yyyy] [name of copyright owner] 21 * 22 * CDDL HEADER END 23 * 24 * Copyright (c) 1999 by Sun Microsystems, Inc. 25 * All rights reserved. 26 */ 27 28 #pragma ident "%Z%%M% %I% %E% SMI" 29 30 #include <stdio.h> 31 #include <stdlib.h> 32 #include <ctype.h> 33 #include <libintl.h> 34 #include <errno.h> 35 36 #include "iconv_tm.h" 37 #include "itmcomp.h" 38 #include "itm_util.h" 39 40 41 # line 43 "../itm_comp.y" 42 typedef union 43 #ifdef __cplusplus 44 YYSTYPE 45 #endif 46 yystacktype 47 { 48 int intval; 49 50 itm_num_t num; 51 itm_data_t *name; 52 itm_data_t *data; 53 54 itm_tbl_hdr_t *tbl_hdr; 55 itm_direc_t *direc_unit; 56 itm_expr_t *expr; 57 58 itmc_action_t action; 59 itmc_obj_t *obj; 60 itmc_map_t *map_list; 61 itmc_ref_t *itmc_ref; 62 itmc_map_attr_t *map_attr; 63 } YYSTYPE; 64 # define ITMNAME 257 65 # define NAME 258 66 # define MAPTYPE_NAME 259 67 # define HEXADECIMAL 260 68 # define DECIMAL 261 69 # define ITM_DEFAULT 262 70 # define ITM_IDENTICAL 263 71 # define BETWEEN 264 72 # define BREAK 265 73 # define CONDITION 266 74 # define DIRECTION 267 75 # define DISCARD 268 76 # define ERROR 269 77 # define ITM_ELSE 270 78 # define ITM_INIT 271 79 # define ITM_FALSE 272 80 # define ITM_IF 273 81 # define ITM_IN 274 82 # define ITM_INSIZE 275 83 # define NOP 276 84 # define OPERATION 277 85 # define ITM_OUT 278 86 # define ITM_OUTSIZE 279 87 # define PRINTCHR 280 88 # define PRINTHD 281 89 # define PRINTINT 282 90 # define MAP 283 91 # define RESET 284 92 # define RETURN 285 93 # define ITM_TRUE 286 94 # define ESCAPESEQ 287 95 # define MAPTYPE 288 96 # define RESULTLEN 289 97 # define MAPTYPE_AUTO 290 98 # define MAPTYPE_INDEX 291 99 # define MAPTYPE_DENSE 292 100 # define MAPTYPE_HASH 293 101 # define MAPTYPE_BINARY 294 102 # define ELLIPSES 295 103 # define CBO 296 104 # define CBC 297 105 # define SBO 298 106 # define SBC 299 107 # define PO 300 108 # define PC 301 109 # define SC 302 110 # define COMMA 303 111 # define COLON 304 112 # define ASSIGN 305 113 # define LOR 306 114 # define LAND 307 115 # define OR 308 116 # define XOR 309 117 # define AND 310 118 # define EQ 311 119 # define NE 312 120 # define LT 313 121 # define LE 314 122 # define GT 315 123 # define GE 316 124 # define SHL 317 125 # define SHR 318 126 # define PLUS 319 127 # define MINUS 320 128 # define MUL 321 129 # define DIV 322 130 # define MOD 323 131 # define NOT 324 132 # define NEG 325 133 # define UMINUS 326 134 135 #include <inttypes.h> 136 137 #ifdef __STDC__ 138 #include <stdlib.h> 139 #include <string.h> 140 #define YYCONST const 141 #else 142 #include <malloc.h> 143 #include <memory.h> 144 #define YYCONST 145 #endif 146 147 #include <values.h> 148 149 #if defined(__cplusplus) || defined(__STDC__) 150 151 #if defined(__cplusplus) && defined(__EXTERN_C__) 152 extern "C" { 153 #endif 154 #ifndef yyerror 155 #if defined(__cplusplus) 156 void yyerror(YYCONST char *); 157 #endif 158 #endif 159 #ifndef yylex 160 int yylex(void); 161 #endif 162 int yyparse(void); 163 #if defined(__cplusplus) && defined(__EXTERN_C__) 164 } 165 #endif 166 167 #endif 168 169 #define yyclearin yychar = -1 170 #define yyerrok yyerrflag = 0 171 extern int yychar; 172 extern int yyerrflag; 173 YYSTYPE yylval; 174 YYSTYPE yyval; 175 typedef int yytabelem; 176 #ifndef YYMAXDEPTH 177 #define YYMAXDEPTH 150 178 #endif 179 #if YYMAXDEPTH > 0 180 int yy_yys[YYMAXDEPTH], *yys = yy_yys; 181 YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv; 182 #else /* user does initial allocation */ 183 int *yys; 184 YYSTYPE *yyv; 185 #endif 186 static int yymaxdepth = YYMAXDEPTH; 187 # define YYERRCODE 256 188 189 # line 2180 "../itm_comp.y" 190 191 static YYCONST yytabelem yyexca[] ={ 192 -1, 1, 193 0, -1, 194 -2, 0, 195 }; 196 # define YYNPROD 116 197 # define YYLAST 1087 198 static YYCONST yytabelem yyact[]={ 199 200 19, 160, 48, 49, 112, 113, 114, 82, 131, 78, 201 76, 75, 69, 132, 54, 87, 58, 52, 68, 79, 202 77, 51, 84, 85, 86, 80, 133, 83, 53, 115, 203 116, 110, 111, 112, 113, 114, 213, 204, 183, 247, 204 67, 66, 46, 221, 73, 110, 111, 112, 113, 114, 205 220, 219, 218, 182, 19, 180, 48, 49, 179, 178, 206 177, 82, 57, 78, 76, 75, 55, 56, 54, 87, 207 58, 52, 176, 79, 77, 51, 84, 85, 86, 80, 208 175, 83, 53, 167, 166, 105, 33, 16, 171, 63, 209 132, 64, 184, 242, 240, 138, 46, 89, 73, 88, 210 70, 65, 63, 63, 64, 64, 19, 63, 19, 64, 211 48, 49, 40, 19, 11, 82, 57, 78, 76, 75, 212 55, 56, 54, 87, 58, 52, 234, 79, 77, 51, 213 84, 85, 86, 80, 39, 83, 53, 11, 10, 212, 214 209, 27, 28, 87, 139, 174, 27, 229, 13, 59, 215 46, 21, 73, 34, 12, 3, 19, 28, 243, 235, 216 144, 19, 19, 145, 48, 49, 245, 19, 14, 82, 217 57, 78, 76, 75, 55, 56, 54, 87, 58, 52, 218 31, 79, 77, 51, 84, 85, 86, 80, 19, 83, 219 53, 27, 28, 32, 18, 19, 63, 10, 64, 23, 220 236, 228, 151, 129, 46, 30, 73, 13, 163, 231, 221 108, 141, 211, 12, 19, 19, 19, 2, 48, 49, 222 143, 164, 11, 82, 57, 78, 76, 75, 55, 56, 223 54, 87, 58, 52, 150, 79, 77, 51, 84, 85, 224 86, 80, 39, 83, 53, 25, 142, 41, 19, 107, 225 11, 10, 128, 91, 26, 214, 11, 50, 46, 81, 226 73, 13, 93, 5, 35, 149, 127, 12, 15, 106, 227 19, 4, 48, 49, 1, 0, 39, 82, 57, 78, 228 76, 75, 55, 56, 54, 87, 58, 52, 102, 79, 229 77, 51, 84, 85, 86, 80, 24, 83, 53, 90, 230 97, 98, 100, 0, 9, 9, 96, 0, 42, 153, 231 8, 8, 46, 148, 73, 0, 0, 0, 37, 60, 232 0, 147, 7, 7, 19, 95, 48, 49, 0, 6, 233 6, 82, 57, 78, 76, 75, 55, 56, 54, 87, 234 58, 52, 0, 79, 77, 51, 84, 85, 86, 80, 235 104, 83, 53, 109, 120, 123, 124, 121, 122, 115, 236 116, 110, 111, 112, 113, 114, 46, 185, 73, 126, 237 117, 118, 119, 109, 120, 123, 124, 121, 122, 115, 238 116, 110, 111, 112, 113, 114, 57, 239, 0, 0, 239 55, 56, 125, 126, 117, 118, 119, 109, 120, 123, 240 124, 121, 122, 115, 116, 110, 111, 112, 113, 114, 241 238, 104, 0, 0, 125, 126, 117, 118, 119, 109, 242 120, 123, 124, 121, 122, 115, 116, 110, 111, 112, 243 113, 114, 237, 230, 0, 0, 125, 126, 117, 118, 244 119, 109, 120, 123, 124, 121, 122, 115, 116, 110, 245 111, 112, 113, 114, 233, 0, 0, 232, 0, 0, 246 0, 125, 126, 117, 118, 119, 109, 120, 123, 124, 247 121, 122, 115, 116, 110, 111, 112, 113, 114, 226, 248 0, 0, 0, 125, 126, 117, 118, 119, 109, 120, 249 123, 124, 121, 122, 115, 116, 110, 111, 112, 113, 250 114, 225, 0, 244, 0, 125, 126, 117, 118, 119, 251 109, 120, 123, 124, 121, 122, 115, 116, 110, 111, 252 112, 113, 114, 224, 0, 0, 0, 125, 126, 117, 253 118, 119, 109, 120, 123, 124, 121, 122, 115, 116, 254 110, 111, 112, 113, 114, 216, 0, 0, 0, 125, 255 126, 117, 118, 119, 109, 120, 123, 124, 121, 122, 256 115, 116, 110, 111, 112, 113, 114, 215, 0, 0, 257 0, 125, 126, 117, 118, 119, 109, 120, 123, 124, 258 121, 122, 115, 116, 110, 111, 112, 113, 114, 205, 259 0, 0, 0, 0, 125, 126, 117, 118, 119, 109, 260 120, 123, 124, 121, 122, 115, 116, 110, 111, 112, 261 113, 114, 155, 0, 0, 71, 125, 126, 117, 118, 262 119, 109, 120, 123, 124, 121, 122, 115, 116, 110, 263 111, 112, 113, 114, 125, 126, 117, 118, 119, 109, 264 120, 123, 124, 121, 122, 115, 116, 110, 111, 112, 265 113, 114, 19, 0, 48, 49, 0, 0, 43, 36, 266 0, 19, 0, 48, 49, 0, 54, 43, 58, 52, 267 0, 0, 0, 51, 0, 54, 0, 58, 52, 0, 268 53, 45, 51, 0, 0, 72, 152, 0, 0, 53, 269 45, 181, 0, 0, 46, 92, 0, 0, 61, 0, 270 103, 0, 0, 46, 172, 173, 62, 0, 0, 0, 271 0, 0, 0, 0, 57, 0, 0, 0, 55, 56, 272 0, 0, 0, 57, 0, 0, 0, 55, 56, 117, 273 118, 119, 109, 120, 123, 124, 121, 122, 115, 116, 274 110, 111, 112, 113, 114, 19, 0, 48, 49, 0, 275 92, 43, 0, 0, 0, 0, 0, 154, 137, 54, 276 0, 58, 52, 0, 146, 0, 51, 0, 140, 0, 277 0, 0, 0, 53, 45, 123, 124, 121, 122, 115, 278 116, 110, 111, 112, 113, 114, 0, 46, 118, 119, 279 109, 120, 123, 124, 121, 122, 115, 116, 110, 111, 280 112, 113, 114, 19, 0, 48, 49, 57, 0, 0, 281 0, 55, 56, 19, 0, 48, 49, 54, 0, 58, 282 52, 0, 0, 0, 51, 0, 0, 54, 0, 58, 283 52, 53, 0, 0, 51, 0, 0, 210, 154, 0, 284 0, 53, 0, 0, 140, 46, 19, 222, 48, 49, 285 0, 0, 0, 140, 0, 46, 241, 158, 154, 154, 286 54, 246, 58, 52, 0, 57, 0, 51, 0, 55, 287 56, 0, 0, 0, 53, 57, 0, 0, 0, 55, 288 56, 0, 0, 0, 0, 0, 0, 0, 46, 0, 289 156, 119, 109, 120, 123, 124, 121, 122, 115, 116, 290 110, 111, 112, 113, 114, 0, 0, 19, 57, 48, 291 49, 0, 55, 56, 74, 0, 0, 140, 0, 0, 292 0, 54, 0, 58, 52, 0, 0, 154, 51, 0, 293 0, 0, 154, 0, 0, 53, 44, 0, 0, 0, 294 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 295 0, 0, 0, 0, 0, 44, 44, 0, 0, 0, 296 0, 130, 0, 0, 0, 0, 0, 0, 0, 57, 297 134, 135, 136, 55, 56, 47, 0, 0, 0, 0, 298 0, 0, 0, 0, 0, 0, 17, 20, 22, 29, 299 157, 159, 0, 0, 38, 0, 0, 0, 0, 168, 300 169, 170, 0, 0, 0, 0, 0, 0, 0, 0, 301 38, 38, 0, 94, 99, 101, 0, 44, 0, 0, 302 0, 0, 0, 0, 186, 187, 188, 189, 190, 191, 303 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 304 202, 203, 0, 0, 0, 0, 206, 207, 208, 0, 305 0, 0, 0, 0, 161, 162, 165, 0, 0, 0, 306 0, 0, 0, 0, 0, 0, 38, 0, 0, 0, 307 0, 0, 0, 0, 0, 217, 0, 0, 0, 0, 308 223, 0, 0, 0, 0, 0, 227 }; 309 static YYCONST yytabelem yypact[]={ 310 311 -40,-10000000, -141, -16, -129, -215,-10000000,-10000000,-10000000,-10000000, 312 -102, -145, -97, -91,-10000000, -216,-10000000, -143, -10,-10000000, 313 -184, 487, -147, -64, -195, -262, -263, -287, -293, -196, 314 66, -197, -199,-10000000, -10, -44,-10000000, -70, -70, -70, 315 487, 403, -217, -50, 328, -57, 649, -297,-10000000,-10000000, 316 -285,-10000000,-10000000,-10000000,-10000000, 649, 649, 649,-10000000, -64, 317 -201, -153,-10000000, -49, -100, -64, -132, -142, -25, -59, 318 66, 12,-10000000,-10000000, 310, 588, 555, -304, -43, -63, 319 -43,-10000000, -218, -219, 649, 649, 649, -212, 66, 66, 320 -152,-10000000,-10000000, -222, -230,-10000000,-10000000,-10000000, -242, -243, 321 -244, -247, 394,-10000000, -249,-10000000, -265,-10000000, -203, 649, 322 649, 649, 649, 649, 649, 649, 649, 649, 649, 649, 323 649, 649, 649, 649, 649, 649, 649, -266,-10000000,-10000000, 324 288, 649, 649, 649,-10000000,-10000000,-10000000, -157, -64,-10000000, 325 -10000000,-10000000, -48,-10000000,-10000000,-10000000, -158,-10000000,-10000000, -268, 326 -10000000,-10000000, -42,-10000000,-10000000,-10000000,-10000000, 265,-10000000, 243, 327 649, -250, -251, -252, -259, 545,-10000000,-10000000, 221, 199, 328 177, 649, -96, -150,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 329 -10000000,-10000000,-10000000, -50, -51, -208, 462, -317, -317,-10000000, 330 -10000000,-10000000, -274, -274, 479, 581, 42, 462, -288, -288, 331 -288, -288, 62, 421, -57,-10000000, 328, 155, 462,-10000000, 332 -171, -101,-10000000, -61,-10000000,-10000000,-10000000, 130,-10000000,-10000000, 333 -10000000,-10000000,-10000000, 108,-10000000,-10000000,-10000000, 86,-10000000,-10000000, 334 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -202, 335 66, -204, -112, -130,-10000000, 66, -258,-10000000 }; 336 static YYCONST yytabelem yypgo[]={ 337 338 0, 274, 271, 263, 325, 264, 659, 262, 318, 247, 339 308, 269, 249, 266, 252, 306, 698, 706, 296, 254, 340 245, 265, 300, 615, 685, 259, 975, 914, 257 }; 341 static YYCONST yytabelem yyr1[]={ 342 343 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 344 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 345 7, 8, 8, 9, 9, 10, 10, 10, 11, 11, 346 12, 13, 13, 14, 15, 15, 15, 15, 18, 18, 347 18, 18, 20, 20, 21, 19, 16, 16, 17, 17, 348 17, 17, 17, 22, 22, 22, 22, 23, 23, 24, 349 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 350 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 351 25, 26, 28, 27, 27, 27, 27, 27, 27, 27, 352 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 353 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 354 27, 27, 27, 27, 27, 27 }; 355 static YYCONST yytabelem yyr2[]={ 356 357 0, 9, 5, 7, 3, 3, 3, 3, 11, 9, 358 3, 5, 7, 7, 7, 7, 7, 7, 3, 3, 359 3, 11, 9, 5, 7, 5, 3, 5, 3, 7, 360 7, 3, 7, 3, 11, 9, 13, 11, 7, 3, 361 7, 3, 11, 7, 3, 7, 3, 5, 5, 9, 362 5, 5, 5, 11, 9, 11, 11, 3, 5, 3, 363 5, 5, 7, 5, 7, 9, 7, 7, 7, 7, 364 7, 9, 3, 5, 5, 7, 7, 7, 15, 19, 365 23, 3, 3, 7, 3, 3, 3, 9, 3, 3, 366 3, 3, 7, 7, 5, 5, 5, 7, 7, 7, 367 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 368 7, 7, 7, 7, 7, 7 }; 369 static YYCONST yytabelem yychk[]={ 370 371 -10000000, -1, 257, 296, -2, -3, -4, -8, -15, -22, 372 267, 266, 283, 277, 297, -3, 302, -26, 296, 258, 373 -26, 296, -26, 296, -18, -20, -19, 288, 289, -26, 374 296, 271, 284, 302, 296, -5, -6, -8, -26, 286, 375 296, -9, -10, 264, -27, 287, 300, -26, 260, 261, 376 -28, 279, 275, 286, 272, 324, 325, 320, 274, 296, 377 -18, -16, -17, 260, 262, 296, 303, 303, 305, 305, 378 296, -23, -24, 302, -27, 269, 268, 278, 267, 277, 379 283, -25, 265, 285, 280, 281, 282, 273, 296, 296, 380 -5, 297, -6, -7, -26, -4, -15, -22, -7, -26, 381 -7, -26, -9, 297, -10, 302, -11, -12, 260, 311, 382 319, 320, 321, 322, 323, 317, 318, 308, 309, 310, 383 312, 315, 316, 313, 314, 306, 307, -13, -14, 260, 384 -27, 305, 298, 311, -27, -27, -27, -16, 296, 297, 385 -17, 260, 295, 269, 260, 263, -16, -19, -20, -21, 386 259, 261, -23, 297, -24, 302, 302, -27, 302, -27, 387 305, -26, -26, 271, 284, -26, 302, 302, -27, -27, 388 -27, 300, -23, -23, 297, 302, 302, 302, 302, 302, 389 302, 297, 302, 303, 295, -28, -27, -27, -27, -27, 390 -27, -27, -27, -27, -27, -27, -27, -27, -27, -27, 391 -27, -27, -27, -27, 303, 301, -27, -27, -27, 297, 392 -16, 260, 297, 304, 297, 302, 302, -27, 302, 302, 393 302, 302, 302, -27, 302, 302, 302, -27, 297, 297, 394 -12, 260, -14, 299, 297, 260, 261, 302, 302, 301, 395 296, -23, 297, 270, -25, 296, -23, 297 }; 396 static YYCONST yytabelem yydef[]={ 397 398 0, -2, 0, 0, 0, 0, 4, 5, 6, 7, 399 0, 0, 0, 0, 1, 0, 2, 0, 0, 81, 400 0, 0, 0, 0, 0, 39, 41, 0, 0, 0, 401 0, 0, 0, 3, 0, 0, 10, 0, 0, 0, 402 0, 0, 0, 0, 26, 0, 0, 84, 85, 86, 403 0, 88, 89, 90, 91, 0, 0, 0, 82, 0, 404 0, 0, 46, 0, 0, 0, 0, 0, 0, 0, 405 0, 0, 57, 59, 0, 0, 0, 0, 0, 0, 406 0, 72, 0, 0, 0, 0, 0, 0, 0, 0, 407 0, 9, 11, 0, 0, 18, 19, 20, 0, 0, 408 0, 0, 0, 22, 0, 23, 25, 28, 0, 0, 409 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 410 0, 0, 0, 0, 0, 0, 0, 27, 31, 33, 411 0, 0, 0, 0, 94, 95, 96, 0, 0, 35, 412 47, 48, 0, 52, 50, 51, 0, 38, 40, 43, 413 44, 45, 0, 54, 58, 60, 61, 0, 63, 0, 414 0, 0, 0, 0, 0, 0, 73, 74, 0, 0, 415 0, 0, 0, 0, 8, 12, 13, 14, 15, 16, 416 17, 21, 24, 0, 0, 93, 107, 97, 98, 99, 417 100, 101, 102, 103, 104, 105, 106, 108, 109, 110, 418 111, 112, 114, 115, 0, 83, 113, 0, 92, 34, 419 0, 0, 37, 0, 53, 62, 64, 0, 66, 67, 420 68, 69, 70, 0, 75, 76, 77, 0, 55, 56, 421 29, 30, 32, 87, 36, 49, 42, 65, 71, 0, 422 0, 0, 78, 0, 79, 0, 0, 80 }; 423 typedef struct 424 #ifdef __cplusplus 425 yytoktype 426 #endif 427 { 428 #ifdef __cplusplus 429 const 430 #endif 431 char *t_name; int t_val; } yytoktype; 432 #ifndef YYDEBUG 433 # define YYDEBUG 0 /* don't allow debugging */ 434 #endif 435 436 #if YYDEBUG 437 438 yytoktype yytoks[] = 439 { 440 "ITMNAME", 257, 441 "NAME", 258, 442 "MAPTYPE_NAME", 259, 443 "HEXADECIMAL", 260, 444 "DECIMAL", 261, 445 "ITM_DEFAULT", 262, 446 "ITM_IDENTICAL", 263, 447 "BETWEEN", 264, 448 "BREAK", 265, 449 "CONDITION", 266, 450 "DIRECTION", 267, 451 "DISCARD", 268, 452 "ERROR", 269, 453 "ITM_ELSE", 270, 454 "ITM_INIT", 271, 455 "ITM_FALSE", 272, 456 "ITM_IF", 273, 457 "ITM_IN", 274, 458 "ITM_INSIZE", 275, 459 "NOP", 276, 460 "OPERATION", 277, 461 "ITM_OUT", 278, 462 "ITM_OUTSIZE", 279, 463 "PRINTCHR", 280, 464 "PRINTHD", 281, 465 "PRINTINT", 282, 466 "MAP", 283, 467 "RESET", 284, 468 "RETURN", 285, 469 "ITM_TRUE", 286, 470 "ESCAPESEQ", 287, 471 "MAPTYPE", 288, 472 "RESULTLEN", 289, 473 "MAPTYPE_AUTO", 290, 474 "MAPTYPE_INDEX", 291, 475 "MAPTYPE_DENSE", 292, 476 "MAPTYPE_HASH", 293, 477 "MAPTYPE_BINARY", 294, 478 "ELLIPSES", 295, 479 "CBO", 296, 480 "CBC", 297, 481 "SBO", 298, 482 "SBC", 299, 483 "PO", 300, 484 "PC", 301, 485 "SC", 302, 486 "COMMA", 303, 487 "COLON", 304, 488 "ASSIGN", 305, 489 "LOR", 306, 490 "LAND", 307, 491 "OR", 308, 492 "XOR", 309, 493 "AND", 310, 494 "EQ", 311, 495 "NE", 312, 496 "LT", 313, 497 "LE", 314, 498 "GT", 315, 499 "GE", 316, 500 "SHL", 317, 501 "SHR", 318, 502 "PLUS", 319, 503 "MINUS", 320, 504 "MUL", 321, 505 "DIV", 322, 506 "MOD", 323, 507 "NOT", 324, 508 "NEG", 325, 509 "UMINUS", 326, 510 "-unknown-", -1 /* ends search */ 511 }; 512 513 #ifdef __cplusplus 514 const 515 #endif 516 char * yyreds[] = 517 { 518 "-no such reduction-", 519 "itm_def : ITMNAME CBO def_element_list CBC", 520 "def_element_list : def_element SC", 521 "def_element_list : def_element_list def_element SC", 522 "def_element : direction", 523 "def_element : condition", 524 "def_element : map", 525 "def_element : operation", 526 "direction : DIRECTION name CBO direction_unit_list CBC", 527 "direction : DIRECTION CBO direction_unit_list CBC", 528 "direction_unit_list : direction_unit", 529 "direction_unit_list : direction_unit_list direction_unit", 530 "direction_unit : condition action SC", 531 "direction_unit : condition name SC", 532 "direction_unit : name action SC", 533 "direction_unit : name name SC", 534 "direction_unit : ITM_TRUE action SC", 535 "direction_unit : ITM_TRUE name SC", 536 "action : direction", 537 "action : map", 538 "action : operation", 539 "condition : CONDITION name CBO condition_list CBC", 540 "condition : CONDITION CBO condition_list CBC", 541 "condition_list : condition_expr SC", 542 "condition_list : condition_list condition_expr SC", 543 "condition_expr : BETWEEN range_list", 544 "condition_expr : expr", 545 "condition_expr : ESCAPESEQ escseq_list", 546 "range_list : range_pair", 547 "range_list : range_list COMMA range_pair", 548 "range_pair : HEXADECIMAL ELLIPSES HEXADECIMAL", 549 "escseq_list : escseq", 550 "escseq_list : escseq_list COMMA escseq", 551 "escseq : HEXADECIMAL", 552 "map : MAP name CBO map_list CBC", 553 "map : MAP CBO map_list CBC", 554 "map : MAP name map_attribute CBO map_list CBC", 555 "map : MAP map_attribute CBO map_list CBC", 556 "map_attribute : map_type COMMA map_resultlen", 557 "map_attribute : map_type", 558 "map_attribute : map_resultlen COMMA map_type", 559 "map_attribute : map_resultlen", 560 "map_type : MAPTYPE ASSIGN map_type_names COLON DECIMAL", 561 "map_type : MAPTYPE ASSIGN map_type_names", 562 "map_type_names : MAPTYPE_NAME", 563 "map_resultlen : RESULTLEN ASSIGN DECIMAL", 564 "map_list : map_pair", 565 "map_list : map_list map_pair", 566 "map_pair : HEXADECIMAL HEXADECIMAL", 567 "map_pair : HEXADECIMAL ELLIPSES HEXADECIMAL HEXADECIMAL", 568 "map_pair : ITM_DEFAULT HEXADECIMAL", 569 "map_pair : ITM_DEFAULT ITM_IDENTICAL", 570 "map_pair : HEXADECIMAL ERROR", 571 "operation : OPERATION name CBO op_list CBC", 572 "operation : OPERATION CBO op_list CBC", 573 "operation : OPERATION ITM_INIT CBO op_list CBC", 574 "operation : OPERATION RESET CBO op_list CBC", 575 "op_list : op_unit", 576 "op_list : op_list op_unit", 577 "op_unit : SC", 578 "op_unit : expr SC", 579 "op_unit : ERROR SC", 580 "op_unit : ERROR expr SC", 581 "op_unit : DISCARD SC", 582 "op_unit : DISCARD expr SC", 583 "op_unit : ITM_OUT ASSIGN expr SC", 584 "op_unit : DIRECTION name SC", 585 "op_unit : OPERATION name SC", 586 "op_unit : OPERATION ITM_INIT SC", 587 "op_unit : OPERATION RESET SC", 588 "op_unit : MAP name SC", 589 "op_unit : MAP name expr SC", 590 "op_unit : op_if_else", 591 "op_unit : BREAK SC", 592 "op_unit : RETURN SC", 593 "op_unit : PRINTCHR expr SC", 594 "op_unit : PRINTHD expr SC", 595 "op_unit : PRINTINT expr SC", 596 "op_if_else : ITM_IF PO expr PC CBO op_list CBC", 597 "op_if_else : ITM_IF PO expr PC CBO op_list CBC ITM_ELSE op_if_else", 598 "op_if_else : ITM_IF PO expr PC CBO op_list CBC ITM_ELSE CBO op_list CBC", 599 "name : NAME", 600 "itm_in : ITM_IN", 601 "expr : PO expr PC", 602 "expr : name", 603 "expr : HEXADECIMAL", 604 "expr : DECIMAL", 605 "expr : itm_in SBO expr SBC", 606 "expr : ITM_OUTSIZE", 607 "expr : ITM_INSIZE", 608 "expr : ITM_TRUE", 609 "expr : ITM_FALSE", 610 "expr : itm_in EQ expr", 611 "expr : expr EQ itm_in", 612 "expr : NOT expr", 613 "expr : NEG expr", 614 "expr : MINUS expr", 615 "expr : expr PLUS expr", 616 "expr : expr MINUS expr", 617 "expr : expr MUL expr", 618 "expr : expr DIV expr", 619 "expr : expr MOD expr", 620 "expr : expr SHL expr", 621 "expr : expr SHR expr", 622 "expr : expr OR expr", 623 "expr : expr XOR expr", 624 "expr : expr AND expr", 625 "expr : expr EQ expr", 626 "expr : expr NE expr", 627 "expr : expr GT expr", 628 "expr : expr GE expr", 629 "expr : expr LT expr", 630 "expr : expr LE expr", 631 "expr : name ASSIGN expr", 632 "expr : expr LOR expr", 633 "expr : expr LAND expr", 634 }; 635 #endif /* YYDEBUG */ 636 # line 1 "/usr/share/lib/ccs/yaccpar" 637 /* 638 * CDDL HEADER START 639 * 640 * The contents of this file are subject to the terms of the 641 * Common Development and Distribution License, Version 1.0 only 642 * (the "License"). You may not use this file except in compliance 643 * with the License. 644 * 645 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 646 * or http://www.opensolaris.org/os/licensing. 647 * See the License for the specific language governing permissions 648 * and limitations under the License. 649 * 650 * When distributing Covered Code, include this CDDL HEADER in each 651 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 652 * If applicable, add the following below this CDDL HEADER, with the 653 * fields enclosed by brackets "[]" replaced with your own identifying 654 * information: Portions Copyright [yyyy] [name of copyright owner] 655 * 656 * CDDL HEADER END 657 */ 658 /* 659 * Copyright 1993 Sun Microsystems, Inc. All rights reserved. 660 * Use is subject to license terms. 661 */ 662 663 /* Copyright (c) 1988 AT&T */ 664 /* All Rights Reserved */ 665 666 #pragma ident "%Z%%M% %I% %E% SMI" 667 668 /* 669 ** Skeleton parser driver for yacc output 670 */ 671 672 /* 673 ** yacc user known macros and defines 674 */ 675 #define YYERROR goto yyerrlab 676 #define YYACCEPT return(0) 677 #define YYABORT return(1) 678 #define YYBACKUP( newtoken, newvalue )\ 679 {\ 680 if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ 681 {\ 682 yyerror( "syntax error - cannot backup" );\ 683 goto yyerrlab;\ 684 }\ 685 yychar = newtoken;\ 686 yystate = *yyps;\ 687 yylval = newvalue;\ 688 goto yynewstate;\ 689 } 690 #define YYRECOVERING() (!!yyerrflag) 691 #define YYNEW(type) malloc(sizeof(type) * yynewmax) 692 #define YYCOPY(to, from, type) \ 693 (type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type)) 694 #define YYENLARGE( from, type) \ 695 (type *) realloc((char *) from, yynewmax * sizeof(type)) 696 #ifndef YYDEBUG 697 # define YYDEBUG 1 /* make debugging available */ 698 #endif 699 700 /* 701 ** user known globals 702 */ 703 int yydebug; /* set to 1 to get debugging */ 704 705 /* 706 ** driver internal defines 707 */ 708 #define YYFLAG (-10000000) 709 710 /* 711 ** global variables used by the parser 712 */ 713 YYSTYPE *yypv; /* top of value stack */ 714 int *yyps; /* top of state stack */ 715 716 int yystate; /* current state */ 717 int yytmp; /* extra var (lasts between blocks) */ 718 719 int yynerrs; /* number of errors */ 720 int yyerrflag; /* error recovery flag */ 721 int yychar; /* current input token number */ 722 723 724 725 #ifdef YYNMBCHARS 726 #define YYLEX() yycvtok(yylex()) 727 /* 728 ** yycvtok - return a token if i is a wchar_t value that exceeds 255. 729 ** If i<255, i itself is the token. If i>255 but the neither 730 ** of the 30th or 31st bit is on, i is already a token. 731 */ 732 #if defined(__STDC__) || defined(__cplusplus) 733 int yycvtok(int i) 734 #else 735 int yycvtok(i) int i; 736 #endif 737 { 738 int first = 0; 739 int last = YYNMBCHARS - 1; 740 int mid; 741 wchar_t j; 742 743 if(i&0x60000000){/*Must convert to a token. */ 744 if( yymbchars[last].character < i ){ 745 return i;/*Giving up*/ 746 } 747 while ((last>=first)&&(first>=0)) {/*Binary search loop*/ 748 mid = (first+last)/2; 749 j = yymbchars[mid].character; 750 if( j==i ){/*Found*/ 751 return yymbchars[mid].tvalue; 752 }else if( j<i ){ 753 first = mid + 1; 754 }else{ 755 last = mid -1; 756 } 757 } 758 /*No entry in the table.*/ 759 return i;/* Giving up.*/ 760 }else{/* i is already a token. */ 761 return i; 762 } 763 } 764 #else/*!YYNMBCHARS*/ 765 #define YYLEX() yylex() 766 #endif/*!YYNMBCHARS*/ 767 768 /* 769 ** yyparse - return 0 if worked, 1 if syntax error not recovered from 770 */ 771 #if defined(__STDC__) || defined(__cplusplus) 772 int yyparse(void) 773 #else 774 int yyparse() 775 #endif 776 { 777 register YYSTYPE *yypvt = 0; /* top of value stack for $vars */ 778 779 #if defined(__cplusplus) || defined(lint) 780 /* 781 hacks to please C++ and lint - goto's inside 782 switch should never be executed 783 */ 784 static int __yaccpar_lint_hack__ = 0; 785 switch (__yaccpar_lint_hack__) 786 { 787 case 1: goto yyerrlab; 788 case 2: goto yynewstate; 789 } 790 #endif 791 792 /* 793 ** Initialize externals - yyparse may be called more than once 794 */ 795 yypv = &yyv[-1]; 796 yyps = &yys[-1]; 797 yystate = 0; 798 yytmp = 0; 799 yynerrs = 0; 800 yyerrflag = 0; 801 yychar = -1; 802 803 #if YYMAXDEPTH <= 0 804 if (yymaxdepth <= 0) 805 { 806 if ((yymaxdepth = YYEXPAND(0)) <= 0) 807 { 808 yyerror("yacc initialization error"); 809 YYABORT; 810 } 811 } 812 #endif 813 814 { 815 register YYSTYPE *yy_pv; /* top of value stack */ 816 register int *yy_ps; /* top of state stack */ 817 register int yy_state; /* current state */ 818 register int yy_n; /* internal state number info */ 819 goto yystack; /* moved from 6 lines above to here to please C++ */ 820 821 /* 822 ** get globals into registers. 823 ** branch to here only if YYBACKUP was called. 824 */ 825 yynewstate: 826 yy_pv = yypv; 827 yy_ps = yyps; 828 yy_state = yystate; 829 goto yy_newstate; 830 831 /* 832 ** get globals into registers. 833 ** either we just started, or we just finished a reduction 834 */ 835 yystack: 836 yy_pv = yypv; 837 yy_ps = yyps; 838 yy_state = yystate; 839 840 /* 841 ** top of for (;;) loop while no reductions done 842 */ 843 yy_stack: 844 /* 845 ** put a state and value onto the stacks 846 */ 847 #if YYDEBUG 848 /* 849 ** if debugging, look up token value in list of value vs. 850 ** name pairs. 0 and negative (-1) are special values. 851 ** Note: linear search is used since time is not a real 852 ** consideration while debugging. 853 */ 854 if ( yydebug ) 855 { 856 register int yy_i; 857 858 printf( "State %d, token ", yy_state ); 859 if ( yychar == 0 ) 860 printf( "end-of-file\n" ); 861 else if ( yychar < 0 ) 862 printf( "-none-\n" ); 863 else 864 { 865 for ( yy_i = 0; yytoks[yy_i].t_val >= 0; 866 yy_i++ ) 867 { 868 if ( yytoks[yy_i].t_val == yychar ) 869 break; 870 } 871 printf( "%s\n", yytoks[yy_i].t_name ); 872 } 873 } 874 #endif /* YYDEBUG */ 875 if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */ 876 { 877 /* 878 ** reallocate and recover. Note that pointers 879 ** have to be reset, or bad things will happen 880 */ 881 long yyps_index = (yy_ps - yys); 882 long yypv_index = (yy_pv - yyv); 883 long yypvt_index = (yypvt - yyv); 884 int yynewmax; 885 #ifdef YYEXPAND 886 yynewmax = YYEXPAND(yymaxdepth); 887 #else 888 yynewmax = 2 * yymaxdepth; /* double table size */ 889 if (yymaxdepth == YYMAXDEPTH) /* first time growth */ 890 { 891 char *newyys = (char *)YYNEW(int); 892 char *newyyv = (char *)YYNEW(YYSTYPE); 893 if (newyys != 0 && newyyv != 0) 894 { 895 yys = YYCOPY(newyys, yys, int); 896 yyv = YYCOPY(newyyv, yyv, YYSTYPE); 897 } 898 else 899 yynewmax = 0; /* failed */ 900 } 901 else /* not first time */ 902 { 903 yys = YYENLARGE(yys, int); 904 yyv = YYENLARGE(yyv, YYSTYPE); 905 if (yys == 0 || yyv == 0) 906 yynewmax = 0; /* failed */ 907 } 908 #endif 909 if (yynewmax <= yymaxdepth) /* tables not expanded */ 910 { 911 yyerror( "yacc stack overflow" ); 912 YYABORT; 913 } 914 yymaxdepth = yynewmax; 915 916 yy_ps = yys + yyps_index; 917 yy_pv = yyv + yypv_index; 918 yypvt = yyv + yypvt_index; 919 } 920 *yy_ps = yy_state; 921 *++yy_pv = yyval; 922 923 /* 924 ** we have a new state - find out what to do 925 */ 926 yy_newstate: 927 if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) 928 goto yydefault; /* simple state */ 929 #if YYDEBUG 930 /* 931 ** if debugging, need to mark whether new token grabbed 932 */ 933 yytmp = yychar < 0; 934 #endif 935 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) 936 yychar = 0; /* reached EOF */ 937 #if YYDEBUG 938 if ( yydebug && yytmp ) 939 { 940 register int yy_i; 941 942 printf( "Received token " ); 943 if ( yychar == 0 ) 944 printf( "end-of-file\n" ); 945 else if ( yychar < 0 ) 946 printf( "-none-\n" ); 947 else 948 { 949 for ( yy_i = 0; yytoks[yy_i].t_val >= 0; 950 yy_i++ ) 951 { 952 if ( yytoks[yy_i].t_val == yychar ) 953 break; 954 } 955 printf( "%s\n", yytoks[yy_i].t_name ); 956 } 957 } 958 #endif /* YYDEBUG */ 959 if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) 960 goto yydefault; 961 if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ 962 { 963 yychar = -1; 964 yyval = yylval; 965 yy_state = yy_n; 966 if ( yyerrflag > 0 ) 967 yyerrflag--; 968 goto yy_stack; 969 } 970 971 yydefault: 972 if ( ( yy_n = yydef[ yy_state ] ) == -2 ) 973 { 974 #if YYDEBUG 975 yytmp = yychar < 0; 976 #endif 977 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) 978 yychar = 0; /* reached EOF */ 979 #if YYDEBUG 980 if ( yydebug && yytmp ) 981 { 982 register int yy_i; 983 984 printf( "Received token " ); 985 if ( yychar == 0 ) 986 printf( "end-of-file\n" ); 987 else if ( yychar < 0 ) 988 printf( "-none-\n" ); 989 else 990 { 991 for ( yy_i = 0; 992 yytoks[yy_i].t_val >= 0; 993 yy_i++ ) 994 { 995 if ( yytoks[yy_i].t_val 996 == yychar ) 997 { 998 break; 999 } 1000 } 1001 printf( "%s\n", yytoks[yy_i].t_name ); 1002 } 1003 } 1004 #endif /* YYDEBUG */ 1005 /* 1006 ** look through exception table 1007 */ 1008 { 1009 register YYCONST int *yyxi = yyexca; 1010 1011 while ( ( *yyxi != -1 ) || 1012 ( yyxi[1] != yy_state ) ) 1013 { 1014 yyxi += 2; 1015 } 1016 while ( ( *(yyxi += 2) >= 0 ) && 1017 ( *yyxi != yychar ) ) 1018 ; 1019 if ( ( yy_n = yyxi[1] ) < 0 ) 1020 YYACCEPT; 1021 } 1022 } 1023 1024 /* 1025 ** check for syntax error 1026 */ 1027 if ( yy_n == 0 ) /* have an error */ 1028 { 1029 /* no worry about speed here! */ 1030 switch ( yyerrflag ) 1031 { 1032 case 0: /* new error */ 1033 yyerror( "syntax error" ); 1034 goto skip_init; 1035 yyerrlab: 1036 /* 1037 ** get globals into registers. 1038 ** we have a user generated syntax type error 1039 */ 1040 yy_pv = yypv; 1041 yy_ps = yyps; 1042 yy_state = yystate; 1043 skip_init: 1044 yynerrs++; 1045 /* FALLTHRU */ 1046 case 1: 1047 case 2: /* incompletely recovered error */ 1048 /* try again... */ 1049 yyerrflag = 3; 1050 /* 1051 ** find state where "error" is a legal 1052 ** shift action 1053 */ 1054 while ( yy_ps >= yys ) 1055 { 1056 yy_n = yypact[ *yy_ps ] + YYERRCODE; 1057 if ( yy_n >= 0 && yy_n < YYLAST && 1058 yychk[yyact[yy_n]] == YYERRCODE) { 1059 /* 1060 ** simulate shift of "error" 1061 */ 1062 yy_state = yyact[ yy_n ]; 1063 goto yy_stack; 1064 } 1065 /* 1066 ** current state has no shift on 1067 ** "error", pop stack 1068 */ 1069 #if YYDEBUG 1070 # define _POP_ "Error recovery pops state %d, uncovers state %d\n" 1071 if ( yydebug ) 1072 printf( _POP_, *yy_ps, 1073 yy_ps[-1] ); 1074 # undef _POP_ 1075 #endif 1076 yy_ps--; 1077 yy_pv--; 1078 } 1079 /* 1080 ** there is no state on stack with "error" as 1081 ** a valid shift. give up. 1082 */ 1083 YYABORT; 1084 case 3: /* no shift yet; eat a token */ 1085 #if YYDEBUG 1086 /* 1087 ** if debugging, look up token in list of 1088 ** pairs. 0 and negative shouldn't occur, 1089 ** but since timing doesn't matter when 1090 ** debugging, it doesn't hurt to leave the 1091 ** tests here. 1092 */ 1093 if ( yydebug ) 1094 { 1095 register int yy_i; 1096 1097 printf( "Error recovery discards " ); 1098 if ( yychar == 0 ) 1099 printf( "token end-of-file\n" ); 1100 else if ( yychar < 0 ) 1101 printf( "token -none-\n" ); 1102 else 1103 { 1104 for ( yy_i = 0; 1105 yytoks[yy_i].t_val >= 0; 1106 yy_i++ ) 1107 { 1108 if ( yytoks[yy_i].t_val 1109 == yychar ) 1110 { 1111 break; 1112 } 1113 } 1114 printf( "token %s\n", 1115 yytoks[yy_i].t_name ); 1116 } 1117 } 1118 #endif /* YYDEBUG */ 1119 if ( yychar == 0 ) /* reached EOF. quit */ 1120 YYABORT; 1121 yychar = -1; 1122 goto yy_newstate; 1123 } 1124 }/* end if ( yy_n == 0 ) */ 1125 /* 1126 ** reduction by production yy_n 1127 ** put stack tops, etc. so things right after switch 1128 */ 1129 #if YYDEBUG 1130 /* 1131 ** if debugging, print the string that is the user's 1132 ** specification of the reduction which is just about 1133 ** to be done. 1134 */ 1135 if ( yydebug ) 1136 printf( "Reduce by (%d) \"%s\"\n", 1137 yy_n, yyreds[ yy_n ] ); 1138 #endif 1139 yytmp = yy_n; /* value to switch over */ 1140 yypvt = yy_pv; /* $vars top of value stack */ 1141 /* 1142 ** Look in goto table for next state 1143 ** Sorry about using yy_state here as temporary 1144 ** register variable, but why not, if it works... 1145 ** If yyr2[ yy_n ] doesn't have the low order bit 1146 ** set, then there is no action to be done for 1147 ** this reduction. So, no saving & unsaving of 1148 ** registers done. The only difference between the 1149 ** code just after the if and the body of the if is 1150 ** the goto yy_stack in the body. This way the test 1151 ** can be made before the choice of what to do is needed. 1152 */ 1153 { 1154 /* length of production doubled with extra bit */ 1155 register int yy_len = yyr2[ yy_n ]; 1156 1157 if ( !( yy_len & 01 ) ) 1158 { 1159 yy_len >>= 1; 1160 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ 1161 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + 1162 *( yy_ps -= yy_len ) + 1; 1163 if ( yy_state >= YYLAST || 1164 yychk[ yy_state = 1165 yyact[ yy_state ] ] != -yy_n ) 1166 { 1167 yy_state = yyact[ yypgo[ yy_n ] ]; 1168 } 1169 goto yy_stack; 1170 } 1171 yy_len >>= 1; 1172 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ 1173 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + 1174 *( yy_ps -= yy_len ) + 1; 1175 if ( yy_state >= YYLAST || 1176 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) 1177 { 1178 yy_state = yyact[ yypgo[ yy_n ] ]; 1179 } 1180 } 1181 /* save until reenter driver code */ 1182 yystate = yy_state; 1183 yyps = yy_ps; 1184 yypv = yy_pv; 1185 } 1186 /* 1187 ** code supplied by user is placed in this switch 1188 */ 1189 switch( yytmp ) 1190 { 1191 1192 case 1: 1193 # line 168 "../itm_comp.y" 1194 { 1195 itm_def_process(yypvt[-3].name); 1196 } break; 1197 case 2: 1198 # line 175 "../itm_comp.y" 1199 { 1200 TRACE_MESSAGE('y', ("def_element_list: def_element ;\n")); 1201 yyval.obj = NULL; 1202 } break; 1203 case 3: 1204 # line 180 "../itm_comp.y" 1205 { 1206 TRACE_MESSAGE('y', 1207 ("def_element_list: def_element_list def_element ;\n")); 1208 yyval.obj = NULL; 1209 } break; 1210 case 4: 1211 # line 189 "../itm_comp.y" 1212 { 1213 TRACE_MESSAGE('y', ("def_element: direction\n")); 1214 (void) obj_register(ITMC_OBJ_DIREC, (itm_data_t *)(yypvt[-0].tbl_hdr->name.itm_ptr), 1215 yypvt[-0].tbl_hdr, yypvt[-0].tbl_hdr->size, 1216 NULL, OBJ_REG_TAIL); 1217 yyval.tbl_hdr = yypvt[-0].tbl_hdr; 1218 } break; 1219 case 5: 1220 # line 197 "../itm_comp.y" 1221 { 1222 TRACE_MESSAGE('y', ("def_element: condition\n")); 1223 yyval.tbl_hdr = (itm_tbl_hdr_t *)(yypvt[-0].itmc_ref->referencee); 1224 } break; 1225 case 6: 1226 # line 202 "../itm_comp.y" 1227 { 1228 TRACE_MESSAGE('y', ("def_element: map\n")); 1229 if (NULL != yypvt[-0].tbl_hdr) { 1230 (void) obj_register(ITMC_OBJ_MAP, 1231 (itm_data_t *)(yypvt[-0].tbl_hdr->name.itm_ptr), 1232 yypvt[-0].tbl_hdr, yypvt[-0].tbl_hdr->size, 1233 NULL, OBJ_REG_TAIL); 1234 } 1235 yyval.tbl_hdr = yypvt[-0].tbl_hdr; 1236 } break; 1237 case 7: 1238 # line 213 "../itm_comp.y" 1239 { 1240 TRACE_MESSAGE('y', ("def_element: operation\n")); 1241 (void) obj_register(ITMC_OBJ_OP, (itm_data_t *)(yypvt[-0].tbl_hdr->name.itm_ptr), 1242 yypvt[-0].tbl_hdr, yypvt[-0].tbl_hdr->size, 1243 NULL, OBJ_REG_TAIL); 1244 yyval.tbl_hdr = yypvt[-0].tbl_hdr; 1245 } break; 1246 case 8: 1247 # line 224 "../itm_comp.y" 1248 { 1249 TRACE_MESSAGE('y', ("direction name (direction_unit_list)\n")); 1250 yyval.tbl_hdr = obj_table(ITM_TBL_DIREC, yypvt[-3].data, 1251 yypvt[-1].obj, sizeof (itm_direc_t)); 1252 } break; 1253 case 9: 1254 # line 230 "../itm_comp.y" 1255 { 1256 TRACE_MESSAGE('y', ("direction name (direction_unit_list)\n")); 1257 yyval.tbl_hdr = obj_table(ITM_TBL_DIREC, NULL, 1258 yypvt[-1].obj, sizeof (itm_direc_t)); 1259 } break; 1260 case 10: 1261 # line 239 "../itm_comp.y" 1262 { 1263 TRACE_MESSAGE('y', ("direction_unit_list: direction_unit\n")); 1264 yyval.obj = obj_list_append(NULL, yypvt[-0].obj); 1265 } break; 1266 case 11: 1267 # line 244 "../itm_comp.y" 1268 { 1269 TRACE_MESSAGE('y', ("direction_unit_list: " 1270 "direction_unit_list direction_unit\n")); 1271 yyval.obj = obj_list_append(yypvt[-1].obj, yypvt[-0].obj); 1272 } break; 1273 case 12: 1274 # line 253 "../itm_comp.y" 1275 { 1276 TRACE_MESSAGE('y', ("direction_unit: condition action ;\n")); 1277 yyval.obj = direction_unit(yypvt[-2].itmc_ref, NULL, &(yypvt[-1].action), NULL); 1278 } break; 1279 case 13: 1280 # line 258 "../itm_comp.y" 1281 { 1282 itm_direc_t *direc; 1283 TRACE_MESSAGE('y', ("direction_unit: condition NAME ;\n")); 1284 yyval.obj = direction_unit(yypvt[-2].itmc_ref, NULL, NULL, yypvt[-1].data); 1285 } break; 1286 case 14: 1287 # line 264 "../itm_comp.y" 1288 { 1289 itm_direc_t *direc; 1290 TRACE_MESSAGE('y', ("direction_unit: NAME action ;\n")); 1291 yyval.obj = direction_unit(NULL, yypvt[-2].data, &(yypvt[-1].action), NULL); 1292 } break; 1293 case 15: 1294 # line 270 "../itm_comp.y" 1295 { 1296 itm_direc_t *direc; 1297 TRACE_MESSAGE('y', ("direction_unit: NAME NAME ;\n")); 1298 yyval.obj = direction_unit(NULL, yypvt[-2].data, NULL, yypvt[-1].data); 1299 } break; 1300 case 16: 1301 # line 276 "../itm_comp.y" 1302 { 1303 itm_direc_t *direc; 1304 yyval.obj = direction_unit(NULL, NULL, &(yypvt[-1].action), NULL); 1305 } break; 1306 case 17: 1307 # line 281 "../itm_comp.y" 1308 { 1309 itm_direc_t *direc; 1310 TRACE_MESSAGE('y', ("direction_unit: TRUE NAME ;\n")); 1311 yyval.obj = direction_unit(NULL, NULL, NULL, yypvt[-1].data); 1312 } break; 1313 case 18: 1314 # line 290 "../itm_comp.y" 1315 { 1316 TRACE_MESSAGE('y', ("action: direction\n")); 1317 yyval.action.type = ITMC_OBJ_DIREC; 1318 yyval.action.tbl_hdr = yypvt[-0].tbl_hdr; 1319 } break; 1320 case 19: 1321 # line 296 "../itm_comp.y" 1322 { 1323 TRACE_MESSAGE('y', ("action: map\n")); 1324 yyval.action.type = ITMC_OBJ_MAP; 1325 yyval.action.tbl_hdr = yypvt[-0].tbl_hdr; 1326 } break; 1327 case 20: 1328 # line 302 "../itm_comp.y" 1329 { 1330 TRACE_MESSAGE('y', ("action: operation\n")); 1331 yyval.action.type = ITMC_OBJ_OP; 1332 yyval.action.tbl_hdr = yypvt[-0].tbl_hdr; 1333 } break; 1334 case 21: 1335 # line 311 "../itm_comp.y" 1336 { 1337 itm_tbl_hdr_t *tbl_hdr; 1338 TRACE_MESSAGE('y', ("condition\n")); 1339 tbl_hdr = obj_table(ITM_TBL_COND, yypvt[-3].data, 1340 yypvt[-1].obj, sizeof (itm_cond_t)); 1341 yyval.itmc_ref = obj_register(ITMC_OBJ_COND, yypvt[-3].data, 1342 tbl_hdr, tbl_hdr->size, 1343 NULL, OBJ_REG_TAIL); 1344 } break; 1345 case 22: 1346 # line 321 "../itm_comp.y" 1347 { 1348 itm_tbl_hdr_t *tbl_hdr; 1349 TRACE_MESSAGE('y', ("condition\n")); 1350 tbl_hdr = obj_table(ITM_TBL_COND, NULL, 1351 yypvt[-1].obj, sizeof (itm_cond_t)); 1352 yyval.itmc_ref = obj_register(ITMC_OBJ_COND, NULL, 1353 tbl_hdr, tbl_hdr->size, 1354 NULL, OBJ_REG_TAIL); 1355 } break; 1356 case 23: 1357 # line 334 "../itm_comp.y" 1358 { 1359 TRACE_MESSAGE('y', ("condition_list: condition_expr;\n")); 1360 yyval.obj = obj_list_append(NULL, yypvt[-1].obj); 1361 } break; 1362 case 24: 1363 # line 339 "../itm_comp.y" 1364 { 1365 TRACE_MESSAGE('y', ("condition_list: " 1366 "condition_list condition_expr;\n")); 1367 yyval.obj = obj_list_append(yypvt[-2].obj, yypvt[-1].obj); 1368 } break; 1369 case 25: 1370 # line 348 "../itm_comp.y" 1371 { 1372 itm_tbl_hdr_t *range; 1373 itm_cond_t *cond; 1374 TRACE_MESSAGE('y', ("condition_expr: between\n")); 1375 range = range_table(NULL, yypvt[-0].obj); 1376 if (range == NULL) { 1377 yyval.obj = NULL; 1378 } else { 1379 yyval.obj = malloc_vital(sizeof (itmc_obj_t)); 1380 yyval.obj->type = ITMC_OBJ_RANGE; 1381 yyval.obj->name = NULL; 1382 cond = malloc_vital(sizeof (itm_cond_t)); 1383 yyval.obj->obj = cond; 1384 cond->type = ITM_COND_BETWEEN; 1385 cond->operand.place.itm_ptr = (itm_place2_t)range; 1386 yyval.obj->ref[0] = obj_register(ITMC_OBJ_RANGE, NULL, 1387 range, range->size, 1388 &(cond->operand.place), 1389 OBJ_REG_TAIL); 1390 yyval.obj->ref[1] = NULL; 1391 yyval.obj->ref[2] = NULL; 1392 yyval.obj->next = yyval.obj->last = NULL; 1393 } 1394 } break; 1395 case 26: 1396 # line 373 "../itm_comp.y" 1397 { 1398 itm_cond_t *cond; 1399 TRACE_MESSAGE('y', ("condition_expr: expr\n")); 1400 yyval.obj = malloc_vital(sizeof (itmc_obj_t)); 1401 yyval.obj->type = ITMC_OBJ_EXPR; 1402 yyval.obj->name = NULL; 1403 cond = malloc_vital(sizeof (itm_cond_t)); 1404 yyval.obj->obj = cond; 1405 cond->type = ITM_COND_EXPR; 1406 cond->operand.place.itm_ptr = (itm_place2_t)(yypvt[-0].expr); 1407 yyval.obj->ref[0] = obj_register(ITMC_OBJ_EXPR, NULL, 1408 yypvt[-0].expr, sizeof (itm_expr_t), 1409 &(cond->operand.place), 1410 OBJ_REG_TAIL); 1411 yyval.obj->ref[1] = NULL; 1412 yyval.obj->ref[2] = NULL; 1413 yyval.obj->next = yyval.obj->last = NULL; 1414 } break; 1415 case 27: 1416 # line 392 "../itm_comp.y" 1417 { 1418 itm_tbl_hdr_t *escseq; 1419 itm_cond_t *cond; 1420 TRACE_MESSAGE('y', ("condition_expr: escseq {escseq_list;}\n")); 1421 escseq = escseq_table(NULL, yypvt[-0].obj); 1422 if (escseq == NULL) { 1423 yyval.obj = NULL; 1424 } else { 1425 yyval.obj = malloc_vital(sizeof (itmc_obj_t)); 1426 yyval.obj->type = ITMC_OBJ_ESCAPESEQ; 1427 yyval.obj->name = NULL; 1428 cond = malloc_vital(sizeof (itm_cond_t)); 1429 yyval.obj->obj = cond; 1430 cond->type = ITM_COND_ESCAPESEQ; 1431 cond->operand.place.itm_ptr = (itm_place2_t)escseq; 1432 yyval.obj->ref[0] = obj_register(ITMC_OBJ_ESCAPESEQ, NULL, 1433 escseq, escseq->size, 1434 &(cond->operand.place), 1435 OBJ_REG_TAIL); 1436 yyval.obj->ref[1] = NULL; 1437 yyval.obj->ref[2] = NULL; 1438 yyval.obj->next = yyval.obj->last = NULL; 1439 } 1440 } break; 1441 case 28: 1442 # line 420 "../itm_comp.y" 1443 { 1444 TRACE_MESSAGE('y', ("range_list: range_pair\n")); 1445 yyval.obj = obj_list_append(NULL, yypvt[-0].obj); 1446 } break; 1447 case 29: 1448 # line 425 "../itm_comp.y" 1449 { 1450 TRACE_MESSAGE('y', ("range_list: range_list, range_pair\n")); 1451 yyval.obj = obj_list_append(yypvt[-2].obj, yypvt[-0].obj); 1452 } break; 1453 case 30: 1454 # line 433 "../itm_comp.y" 1455 { 1456 itmc_data_pair_t *range; 1457 TRACE_MESSAGE('y', ("range_pair: HEXADECIMAL...HEXADECIMAL\n")); 1458 yyval.obj = malloc_vital(sizeof (itmc_obj_t)); 1459 yyval.obj->type = ITMC_OBJ_RANGE; 1460 yyval.obj->name = NULL; 1461 range = malloc_vital(sizeof (itmc_data_pair_t)); 1462 yyval.obj->obj = range; 1463 if (data_compare(yypvt[-2].data, yypvt[-0].data) < 0) { 1464 range->data0 = *(yypvt[-2].data); 1465 range->data1 = *(yypvt[-0].data); 1466 } else { 1467 range->data0 = *(yypvt[-0].data); 1468 range->data1 = *(yypvt[-2].data); 1469 } 1470 } break; 1471 case 31: 1472 # line 452 "../itm_comp.y" 1473 { 1474 TRACE_MESSAGE('y', ("escseq_list: escseq\n")); 1475 yyval.obj = obj_list_append(NULL, yypvt[-0].obj); 1476 } break; 1477 case 32: 1478 # line 457 "../itm_comp.y" 1479 { 1480 TRACE_MESSAGE('y', ("escseq_list: escseq_list; escseq\n")); 1481 yyval.obj = obj_list_append(yypvt[-2].obj, yypvt[-0].obj); 1482 } break; 1483 case 33: 1484 # line 465 "../itm_comp.y" 1485 { 1486 itm_data_t *escseq; 1487 TRACE_MESSAGE('y', ("escseq: HEXADECIMAL\n")); 1488 yyval.obj = malloc_vital(sizeof (itmc_obj_t)); 1489 yyval.obj->type = ITMC_OBJ_ESCAPESEQ; 1490 yyval.obj->name = NULL; 1491 escseq = malloc_vital(sizeof (itm_data_t)); 1492 yyval.obj->obj = escseq; 1493 *escseq = *(yypvt[-0].data); 1494 } break; 1495 case 34: 1496 # line 478 "../itm_comp.y" 1497 { 1498 TRACE_MESSAGE('y', ("map: map name {map_list}\n")); 1499 yyval.tbl_hdr = map_table(yypvt[-3].data, yypvt[-1].map_list, NULL); 1500 } break; 1501 case 35: 1502 # line 483 "../itm_comp.y" 1503 { 1504 TRACE_MESSAGE('y', ("map: map {map_list}\n")); 1505 yyval.tbl_hdr = map_table(NULL, yypvt[-1].map_list, NULL); 1506 } break; 1507 case 36: 1508 # line 488 "../itm_comp.y" 1509 { 1510 TRACE_MESSAGE('y', ("map: map name attribute {map_list}\n")); 1511 yyval.tbl_hdr = map_table(yypvt[-4].data, yypvt[-1].map_list, yypvt[-3].map_attr); 1512 } break; 1513 case 37: 1514 # line 493 "../itm_comp.y" 1515 { 1516 TRACE_MESSAGE('y', ("map: map attribute {map_list}\n")); 1517 yyval.tbl_hdr = map_table(NULL, yypvt[-1].map_list, yypvt[-3].map_attr); 1518 } break; 1519 case 38: 1520 # line 501 "../itm_comp.y" 1521 { 1522 TRACE_MESSAGE('y', ("map_attribute: map_type map_resultlen\n")); 1523 yyval.map_attr = yypvt[-2].map_attr; 1524 yyval.map_attr->resultlen = yypvt[-0].intval; 1525 } break; 1526 case 39: 1527 # line 507 "../itm_comp.y" 1528 { 1529 TRACE_MESSAGE('y', ("map_attribute: map_type\n")); 1530 yyval.map_attr = yypvt[-0].map_attr; 1531 yyval.map_attr->resultlen = 0; 1532 } break; 1533 case 40: 1534 # line 513 "../itm_comp.y" 1535 { 1536 TRACE_MESSAGE('y', ("map_attribute: map_resultlen map_type\n")); 1537 yyval.map_attr = yypvt[-0].map_attr; 1538 yyval.map_attr->resultlen = yypvt[-2].intval; 1539 } break; 1540 case 41: 1541 # line 519 "../itm_comp.y" 1542 { 1543 TRACE_MESSAGE('y', ("map_attribute: map_resultlen\n")); 1544 yyval.map_attr = malloc_vital(sizeof (itmc_map_attr_t)); 1545 yyval.map_attr->resultlen = yypvt[-0].intval; 1546 yyval.map_attr->type = NULL; 1547 yyval.map_attr->hash_factor = 0; 1548 } break; 1549 case 42: 1550 # line 530 "../itm_comp.y" 1551 { 1552 TRACE_MESSAGE('y', ("map_type: maptype=type:factor(%d)\n", 1553 yypvt[-0].num)); 1554 yyval.map_attr = malloc_vital(sizeof (itmc_map_attr_t)); 1555 yyval.map_attr->type = yypvt[-2].name; 1556 yyval.map_attr->hash_factor = yypvt[-0].num; 1557 } break; 1558 case 43: 1559 # line 538 "../itm_comp.y" 1560 { 1561 TRACE_MESSAGE('y', ("map_type: maptype=type\n")); 1562 yyval.map_attr = malloc_vital(sizeof (itmc_map_attr_t)); 1563 yyval.map_attr->type = yypvt[-0].name; 1564 yyval.map_attr->hash_factor = 0; 1565 } break; 1566 case 44: 1567 # line 548 "../itm_comp.y" 1568 { 1569 TRACE_MESSAGE('y', ("map_type_names: size=%*s\n", 1570 yylval.data->size, NSPTR(yylval.data))); 1571 yyval.name = yylval.data; 1572 } break; 1573 case 45: 1574 # line 558 "../itm_comp.y" 1575 { 1576 TRACE_MESSAGE('y', ("map_resultlen(%d)\n", yypvt[-0].num)); 1577 yyval.intval = yypvt[-0].num; 1578 } break; 1579 case 46: 1580 # line 566 "../itm_comp.y" 1581 { 1582 TRACE_MESSAGE('y', ("map_list: map_pair\n")); 1583 yyval.map_list = map_list_append(NULL, yypvt[-0].map_list); 1584 } break; 1585 case 47: 1586 # line 571 "../itm_comp.y" 1587 { 1588 TRACE_MESSAGE('y', ("map_list: map_list map_pair\n")); 1589 yyval.map_list = map_list_append(yypvt[-1].map_list, yypvt[-0].map_list); 1590 } break; 1591 case 48: 1592 # line 579 "../itm_comp.y" 1593 { 1594 TRACE_MESSAGE('y', ("map_pair: HEXADECIMAL HEXADECIMAL\n")); 1595 yyval.map_list = malloc_vital(sizeof (itmc_map_t)); 1596 yyval.map_list->data_pair.data0 = *(yypvt[-1].data); 1597 free(yypvt[-1].data); 1598 yyval.map_list->data_pair.data1 = *(yypvt[-0].data); 1599 free(yypvt[-0].data); 1600 } break; 1601 case 49: 1602 # line 588 "../itm_comp.y" 1603 { 1604 TRACE_MESSAGE('y', ("map_pair: " 1605 "HEXADECIMAL ELLIPSES HEXADECIMAL\n")); 1606 yyval.map_list = malloc_vital(sizeof (itmc_map_t)); 1607 yyval.map_list->data_pair.data0 = *(yypvt[-3].data); 1608 yyval.map_list->data_pair.range = *(yypvt[-1].data); 1609 free(yypvt[-3].data); 1610 free(yypvt[-1].data); 1611 yyval.map_list->data_pair.data1 = *(yypvt[-0].data); 1612 free(yypvt[-0].data); 1613 } break; 1614 case 50: 1615 # line 600 "../itm_comp.y" 1616 { 1617 TRACE_MESSAGE('y', ("map_pair: default HEXADECIMAL\n")); 1618 yyval.map_list = malloc_vital(sizeof (itmc_map_t)); 1619 yyval.map_list->data_pair.data0.size = 0; 1620 yyval.map_list->data_pair.data1 = *(yypvt[-0].data); 1621 free(yypvt[-0].data); 1622 } break; 1623 case 51: 1624 # line 608 "../itm_comp.y" 1625 { 1626 TRACE_MESSAGE('y', ("map_pair: default default\n")); 1627 yyval.map_list = malloc_vital(sizeof (itmc_map_t)); 1628 yyval.map_list->data_pair.data0.size = 0; 1629 yyval.map_list->data_pair.data1.size = 0; 1630 } break; 1631 case 52: 1632 # line 615 "../itm_comp.y" 1633 { 1634 TRACE_MESSAGE('y', ("map_pair: hexadecimal error\n")); 1635 yyval.map_list = malloc_vital(sizeof (itmc_map_t)); 1636 yyval.map_list->data_pair.data0 = *(yypvt[-1].data); 1637 free(yypvt[-1].data); 1638 yyval.map_list->data_pair.data1.size = 0; 1639 } break; 1640 case 53: 1641 # line 626 "../itm_comp.y" 1642 { 1643 TRACE_MESSAGE('y', ("operation: operation name {op_list}\n")); 1644 yyval.tbl_hdr = obj_table(ITM_TBL_OP, yypvt[-3].data, 1645 yypvt[-1].obj, sizeof (itm_op_t)); 1646 } break; 1647 case 54: 1648 # line 632 "../itm_comp.y" 1649 { 1650 TRACE_MESSAGE('y', ("operation: operation {op_list}\n")); 1651 yyval.tbl_hdr = obj_table(ITM_TBL_OP, NULL, 1652 yypvt[-1].obj, sizeof (itm_op_t)); 1653 } break; 1654 case 55: 1655 # line 638 "../itm_comp.y" 1656 { 1657 TRACE_MESSAGE('y', ("operation: operation init {op_list}\n")); 1658 yyval.tbl_hdr = obj_table(ITM_TBL_OP_INIT, NULL, 1659 yypvt[-1].obj, sizeof (itm_op_t)); 1660 } break; 1661 case 56: 1662 # line 644 "../itm_comp.y" 1663 { 1664 TRACE_MESSAGE('y', ("operation: operation reset {op_list}\n")); 1665 yyval.tbl_hdr = obj_table(ITM_TBL_OP_RESET, NULL, 1666 yypvt[-1].obj, sizeof (itm_op_t)); 1667 } break; 1668 case 57: 1669 # line 652 "../itm_comp.y" 1670 { 1671 TRACE_MESSAGE('y', ("op_list: op_unit\n")); 1672 yyval.obj = obj_list_append(NULL, yypvt[-0].obj); 1673 } break; 1674 case 58: 1675 # line 657 "../itm_comp.y" 1676 { 1677 TRACE_MESSAGE('y', ("op_list: op_list op_unit\n")); 1678 yyval.obj = obj_list_append(yypvt[-1].obj, yypvt[-0].obj); 1679 } break; 1680 case 59: 1681 # line 664 "../itm_comp.y" 1682 { 1683 TRACE_MESSAGE('y', ("op_unit: / *null */;\n")); 1684 yyval.obj = NULL; 1685 } break; 1686 case 60: 1687 # line 669 "../itm_comp.y" 1688 { 1689 TRACE_MESSAGE('y', ("op_unit: expr;\n")); 1690 yyval.obj = op_unary(ITM_OP_EXPR, yypvt[-1].expr, sizeof (itm_expr_t)); 1691 } break; 1692 case 61: 1693 # line 674 "../itm_comp.y" 1694 { 1695 TRACE_MESSAGE('y', ("expr: error;\n")); 1696 yyval.obj = op_self_num(ITM_OP_ERROR_D, EINVAL); 1697 } break; 1698 case 62: 1699 # line 679 "../itm_comp.y" 1700 { 1701 TRACE_MESSAGE('y', ("expr: error;\n")); 1702 if (ITM_EXPR_INT == yypvt[-1].expr->type) { 1703 yyval.obj = op_self_num(ITM_OP_ERROR_D, yypvt[-1].expr->data.itm_exnum); 1704 } else { 1705 yyval.obj = op_unary(ITM_OP_ERROR, yypvt[-1].expr, sizeof (itm_expr_t)); 1706 } 1707 } break; 1708 case 63: 1709 # line 688 "../itm_comp.y" 1710 { 1711 TRACE_MESSAGE('y', ("discard expr;\n")); 1712 yyval.obj = op_self_num(ITM_OP_DISCARD_D, 1); 1713 } break; 1714 case 64: 1715 # line 693 "../itm_comp.y" 1716 { 1717 TRACE_MESSAGE('y', ("discard expr;\n")); 1718 if (ITM_EXPR_INT == yypvt[-1].expr->type) { 1719 yyval.obj = op_self_num(ITM_OP_DISCARD_D, yypvt[-1].expr->data.itm_exnum); 1720 } else { 1721 yyval.obj = op_unary(ITM_OP_DISCARD, yypvt[-1].expr, sizeof (itm_expr_t)); 1722 } 1723 } break; 1724 case 65: 1725 # line 702 "../itm_comp.y" 1726 { 1727 TRACE_MESSAGE('y', ("out = expr;\n")); 1728 switch (yypvt[-1].expr->type) { 1729 case ITM_EXPR_INT: 1730 yyval.obj = op_unary(ITM_OP_OUT_D, yypvt[-1].expr, sizeof (itm_expr_t)); 1731 break; 1732 case ITM_EXPR_SEQ: 1733 yyval.obj = op_unary(ITM_OP_OUT_S, yypvt[-1].expr, sizeof (itm_expr_t)); 1734 break; 1735 case ITM_EXPR_REG: 1736 yyval.obj = op_unary(ITM_OP_OUT_R, yypvt[-1].expr, sizeof (itm_expr_t)); 1737 break; 1738 case ITM_EXPR_IN_VECTOR_D: 1739 yyval.obj = op_unary(ITM_OP_OUT_INVD, yypvt[-1].expr, sizeof (itm_expr_t)); 1740 break; 1741 default: 1742 yyval.obj = op_unary(ITM_OP_OUT, yypvt[-1].expr, sizeof (itm_expr_t)); 1743 break; 1744 } 1745 } break; 1746 case 66: 1747 # line 723 "../itm_comp.y" 1748 { 1749 itm_op_t *op; 1750 TRACE_MESSAGE('y', ("direction NAME;\n")); 1751 yyval.obj = op_unit(ITM_OP_DIRECTION, NULL, 0, NULL, 0, NULL, 0); 1752 op = (itm_op_t *)(yyval.obj->obj); 1753 op->data.operand[0].itm_ptr = (itm_place2_t)(yypvt[-1].data); 1754 yyval.obj->ref[0] = obj_register(ITMC_OBJ_DIREC, yypvt[-1].data, 1755 NULL, 0, 1756 &(op->data.operand[0]), OBJ_REG_TAIL); 1757 } break; 1758 case 67: 1759 # line 734 "../itm_comp.y" 1760 { 1761 itm_op_t *op; 1762 TRACE_MESSAGE('y', ("operation NAME;\n")); 1763 yyval.obj = op_unit(ITM_OP_OPERATION, NULL, 0, NULL, 0, NULL, 0); 1764 op = (itm_op_t *)(yyval.obj->obj); 1765 op->data.operand[0].itm_ptr = (itm_place2_t)(yypvt[-1].data); 1766 yyval.obj->ref[0] = obj_register(ITMC_OBJ_OP, yypvt[-1].data, 1767 NULL, 0, 1768 &(op->data.operand[0]), OBJ_REG_TAIL); 1769 } break; 1770 case 68: 1771 # line 745 "../itm_comp.y" 1772 { 1773 itm_op_t *op; 1774 TRACE_MESSAGE('y', ("operation init;\n")); 1775 yyval.obj = op_self(ITM_OP_INIT); 1776 } break; 1777 case 69: 1778 # line 751 "../itm_comp.y" 1779 { 1780 itm_op_t *op; 1781 TRACE_MESSAGE('y', ("operation reset;\n")); 1782 yyval.obj = op_self(ITM_OP_RESET); 1783 } break; 1784 case 70: 1785 # line 757 "../itm_comp.y" 1786 { 1787 itm_op_t *op; 1788 TRACE_MESSAGE('y', ("map NAME;\n")); 1789 yyval.obj = op_unit(ITM_OP_MAP, NULL, 0, NULL, 0, NULL, 0); 1790 op = (itm_op_t *)(yyval.obj->obj); 1791 op->data.operand[0].itm_ptr = (itm_place2_t)(yypvt[-1].data); 1792 yyval.obj->ref[0] = obj_register(ITMC_OBJ_MAP, yypvt[-1].data, 1793 NULL, 0, 1794 &(op->data.operand[0]), OBJ_REG_TAIL); 1795 } break; 1796 case 71: 1797 # line 768 "../itm_comp.y" 1798 { 1799 itm_op_t *op; 1800 TRACE_MESSAGE('y', ("map NAME expr;\n")); 1801 yyval.obj = op_unit(ITM_OP_MAP, NULL, 0, yypvt[-1].expr, 1802 sizeof (itm_expr_t), NULL, 0); 1803 op = (itm_op_t *)(yyval.obj->obj); 1804 op->data.operand[0].itm_ptr = (itm_place2_t)(yypvt[-2].data); 1805 yyval.obj->ref[0] = obj_register(ITMC_OBJ_MAP, yypvt[-2].data, 1806 NULL, 0, 1807 &(op->data.operand[0]), OBJ_REG_TAIL); 1808 } break; 1809 case 72: 1810 # line 780 "../itm_comp.y" 1811 { 1812 TRACE_MESSAGE('y', ("op_unit: op_if_else\n")); 1813 yyval.obj = yypvt[-0].obj; 1814 } break; 1815 case 73: 1816 # line 785 "../itm_comp.y" 1817 { 1818 TRACE_MESSAGE('y', ("break;\n")); 1819 yyval.obj = op_self(ITM_OP_BREAK); 1820 } break; 1821 case 74: 1822 # line 790 "../itm_comp.y" 1823 { 1824 TRACE_MESSAGE('y', ("return;\n")); 1825 yyval.obj = op_self(ITM_OP_RETURN); 1826 } break; 1827 case 75: 1828 # line 795 "../itm_comp.y" 1829 { 1830 TRACE_MESSAGE('y', ("printchr expr;\n")); 1831 yyval.obj = op_unary(ITM_OP_PRINTCHR, yypvt[-1].expr, sizeof (itm_expr_t)); 1832 } break; 1833 case 76: 1834 # line 800 "../itm_comp.y" 1835 { 1836 TRACE_MESSAGE('y', ("printchr expr;\n")); 1837 yyval.obj = op_unary(ITM_OP_PRINTHD, yypvt[-1].expr, sizeof (itm_expr_t)); 1838 } break; 1839 case 77: 1840 # line 805 "../itm_comp.y" 1841 { 1842 TRACE_MESSAGE('y', ("printint expr;\n")); 1843 yyval.obj = op_unary(ITM_OP_PRINTINT, yypvt[-1].expr, sizeof (itm_expr_t)); 1844 } break; 1845 case 78: 1846 # line 813 "../itm_comp.y" 1847 { 1848 itm_tbl_hdr_t *tbl_hdr; 1849 TRACE_MESSAGE('y', ("op_if_else: if (expr) {op_list}\n")); 1850 tbl_hdr = obj_table(ITM_TBL_OP, NULL, 1851 yypvt[-1].obj, sizeof (itm_op_t)); 1852 yyval.obj = op_unit(ITM_OP_IF, 1853 yypvt[-4].expr, sizeof (itm_expr_t), 1854 tbl_hdr, tbl_hdr->size, 1855 NULL, 0); 1856 } break; 1857 case 79: 1858 # line 824 "../itm_comp.y" 1859 { 1860 itm_tbl_hdr_t *tbl_hdr1; 1861 itm_tbl_hdr_t *tbl_hdr2; 1862 TRACE_MESSAGE('y', ("op_if_else: " 1863 "if (expr) {op_list} else op_if_else\n")); 1864 tbl_hdr1 = obj_table(ITM_TBL_OP, NULL, 1865 yypvt[-3].obj, sizeof (itm_op_t)); 1866 tbl_hdr2 = obj_table(ITM_TBL_OP, NULL, 1867 yypvt[-0].obj, sizeof (itm_op_t)); 1868 yyval.obj = op_unit(ITM_OP_IF_ELSE, 1869 yypvt[-6].expr, sizeof (itm_expr_t), 1870 tbl_hdr1, tbl_hdr1->size, 1871 tbl_hdr2, tbl_hdr2->size); 1872 } break; 1873 case 80: 1874 # line 839 "../itm_comp.y" 1875 { 1876 itm_tbl_hdr_t *tbl_hdr1; 1877 itm_tbl_hdr_t *tbl_hdr2; 1878 TRACE_MESSAGE('y', ("op_if_else: " 1879 "if (expr) {op_list} else {op_list}\n")); 1880 tbl_hdr1 = obj_table(ITM_TBL_OP, NULL, 1881 yypvt[-5].obj, sizeof (itm_op_t)); 1882 tbl_hdr2 = obj_table(ITM_TBL_OP, NULL, 1883 yypvt[-1].obj, sizeof (itm_op_t)); 1884 yyval.obj = op_unit(ITM_OP_IF_ELSE, 1885 yypvt[-8].expr, sizeof (itm_expr_t), 1886 tbl_hdr1, tbl_hdr1->size, 1887 tbl_hdr2, tbl_hdr2->size); 1888 } break; 1889 case 81: 1890 # line 856 "../itm_comp.y" 1891 { 1892 TRACE_MESSAGE('y', ("name: size=%*s\n", 1893 yylval.data->size, NSPTR(yylval.data))); 1894 yyval.data = yylval.data; 1895 } break; 1896 case 82: 1897 # line 864 "../itm_comp.y" 1898 { 1899 TRACE_MESSAGE('y', ("in\n")); 1900 yyval.expr = expr_self(ITM_EXPR_IN, NULL); 1901 } break; 1902 case 83: 1903 # line 871 "../itm_comp.y" 1904 { 1905 TRACE_MESSAGE('y', ("expr: (expr)\n")); 1906 yyval.expr = yypvt[-1].expr; 1907 } break; 1908 case 84: 1909 # line 876 "../itm_comp.y" 1910 { 1911 TRACE_MESSAGE('y', ("expr: NAME\n")); 1912 yyval.expr = expr_self(ITM_EXPR_NAME, yypvt[-0].data); 1913 } break; 1914 case 85: 1915 # line 881 "../itm_comp.y" 1916 { 1917 TRACE_MESSAGE('y', ("expr: HEXADECIMAL\n")); 1918 yyval.expr = expr_self(ITM_EXPR_SEQ, yylval.data); 1919 } break; 1920 case 86: 1921 # line 886 "../itm_comp.y" 1922 { 1923 TRACE_MESSAGE('y', ("expr: DECIMAL\n")); 1924 yyval.expr = expr_self_num(ITM_EXPR_INT, yylval.num); 1925 } break; 1926 case 87: 1927 # line 891 "../itm_comp.y" 1928 { 1929 if (ITM_EXPR_INT == yypvt[-1].expr->type) { 1930 TRACE_MESSAGE('y', ("expr: in[%ld]\n", 1931 yypvt[-1].expr->data.itm_exnum)); 1932 yyval.expr = expr_self_num(ITM_EXPR_IN_VECTOR_D, 1933 yypvt[-1].expr->data.itm_exnum); 1934 } else { 1935 TRACE_MESSAGE('y', ("expr: in[expr]\n")); 1936 yyval.expr = expr_unary(ITM_EXPR_IN_VECTOR, yypvt[-1].expr); 1937 } 1938 } break; 1939 case 88: 1940 # line 903 "../itm_comp.y" 1941 { 1942 TRACE_MESSAGE('y', ("expr: outsize\n")); 1943 yyval.expr = expr_self_num(ITM_EXPR_OUT, 0); 1944 } break; 1945 case 89: 1946 # line 908 "../itm_comp.y" 1947 { 1948 TRACE_MESSAGE('y', ("expr: inputsize\n")); 1949 yyval.expr = expr_self_num(ITM_EXPR_IN_VECTOR_D, (size_t)-1); 1950 } break; 1951 case 90: 1952 # line 913 "../itm_comp.y" 1953 { 1954 TRACE_MESSAGE('y', ("expr: true\n")); 1955 yyval.expr = expr_self_num(ITM_EXPR_TRUE, 1); 1956 } break; 1957 case 91: 1958 # line 918 "../itm_comp.y" 1959 { 1960 TRACE_MESSAGE('y', ("expr: false\n")); 1961 yyval.expr = expr_self_num(ITM_EXPR_FALSE, 0); 1962 } break; 1963 case 92: 1964 # line 923 "../itm_comp.y" 1965 { 1966 TRACE_MESSAGE('y', ("expr: in == expr\n")); 1967 yyval.expr = expr_unary(ITM_EXPR_IN_EQ, yypvt[-0].expr); 1968 } break; 1969 case 93: 1970 # line 928 "../itm_comp.y" 1971 { 1972 TRACE_MESSAGE('y', ("expr: expr == in\n")); 1973 yyval.expr = expr_unary(ITM_EXPR_IN_EQ, yypvt[-2].expr); 1974 } break; 1975 case 94: 1976 # line 933 "../itm_comp.y" 1977 { 1978 TRACE_MESSAGE('y', ("expr: ! expr\n")); 1979 1980 if (ITM_EXPR_INT == yypvt[-0].expr->type) { 1981 yyval.expr = expr_self_num(ITM_EXPR_INT, !(yypvt[-0].expr->data.itm_exnum)); 1982 } else { 1983 yyval.expr = expr_unary(ITM_EXPR_NOT, yypvt[-0].expr); 1984 } 1985 } break; 1986 case 95: 1987 # line 943 "../itm_comp.y" 1988 { 1989 TRACE_MESSAGE('y', ("expr: ~ expr\n")); 1990 if (ITM_EXPR_INT == yypvt[-0].expr->type) { 1991 yyval.expr = expr_self_num(ITM_EXPR_INT, ~(yypvt[-0].expr->data.itm_exnum)); 1992 } else { 1993 yyval.expr = expr_unary(ITM_EXPR_NEG, yypvt[-0].expr); 1994 } 1995 } break; 1996 case 96: 1997 # line 952 "../itm_comp.y" 1998 { 1999 TRACE_MESSAGE('y', ("expr: - expr\n")); 2000 if (ITM_EXPR_INT == yypvt[-0].expr->type) { 2001 yyval.expr = expr_self_num(ITM_EXPR_INT, 2002 (-1) * (yypvt[-0].expr->data.itm_exnum)); 2003 } else { 2004 yyval.expr = expr_unary(ITM_EXPR_UMINUS, yypvt[-0].expr); 2005 } 2006 } break; 2007 case 97: 2008 # line 962 "../itm_comp.y" 2009 { 2010 TRACE_MESSAGE('y', ("expr: expr + expr\n")); 2011 yyval.expr = expr_binary(ITM_EXPR_PLUS, yypvt[-2].expr, yypvt[-0].expr); 2012 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2013 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2014 switch (yypvt[-2].expr->type) { 2015 case ITM_EXPR_INT: 2016 switch (yypvt[-0].expr->type) { 2017 case ITM_EXPR_INT: 2018 yyval.expr = expr_binary2(ITM_EXPR_PLUS_D_D, yypvt[-2].expr, yypvt[-0].expr); 2019 break; 2020 case ITM_EXPR_REG: 2021 yyval.expr = expr_binary2(ITM_EXPR_PLUS_D_R, yypvt[-2].expr, yypvt[-0].expr); 2022 break; 2023 case ITM_EXPR_IN_VECTOR_D: 2024 yyval.expr = expr_binary2(ITM_EXPR_PLUS_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 2025 break; 2026 default: 2027 yyval.expr = expr_binary2(ITM_EXPR_PLUS_D_E, yypvt[-2].expr, yypvt[-0].expr); 2028 break; 2029 } 2030 break; 2031 case ITM_EXPR_REG: 2032 switch (yypvt[-0].expr->type) { 2033 case ITM_EXPR_INT: 2034 yyval.expr = expr_binary2(ITM_EXPR_PLUS_R_D, yypvt[-2].expr, yypvt[-0].expr); 2035 break; 2036 case ITM_EXPR_REG: 2037 yyval.expr = expr_binary2(ITM_EXPR_PLUS_R_R, yypvt[-2].expr, yypvt[-0].expr); 2038 break; 2039 case ITM_EXPR_IN_VECTOR_D: 2040 yyval.expr = expr_binary2(ITM_EXPR_PLUS_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 2041 break; 2042 default: 2043 yyval.expr = expr_binary2(ITM_EXPR_PLUS_R_E, yypvt[-2].expr, yypvt[-0].expr); 2044 break; 2045 } 2046 break; 2047 case ITM_EXPR_IN_VECTOR_D: 2048 switch (yypvt[-0].expr->type) { 2049 case ITM_EXPR_INT: 2050 yyval.expr = expr_binary2(ITM_EXPR_PLUS_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 2051 break; 2052 case ITM_EXPR_REG: 2053 yyval.expr = expr_binary2(ITM_EXPR_PLUS_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 2054 break; 2055 case ITM_EXPR_IN_VECTOR_D: 2056 yyval.expr = expr_binary2(ITM_EXPR_PLUS_INVD_INVD, 2057 yypvt[-2].expr, yypvt[-0].expr); 2058 break; 2059 default: 2060 yyval.expr = expr_binary2(ITM_EXPR_PLUS_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 2061 break; 2062 } 2063 break; 2064 default: 2065 switch (yypvt[-0].expr->type) { 2066 case ITM_EXPR_INT: 2067 yyval.expr = expr_binary2(ITM_EXPR_PLUS_E_D, yypvt[-2].expr, yypvt[-0].expr); 2068 break; 2069 case ITM_EXPR_REG: 2070 yyval.expr = expr_binary2(ITM_EXPR_PLUS_E_R, yypvt[-2].expr, yypvt[-0].expr); 2071 break; 2072 case ITM_EXPR_IN_VECTOR_D: 2073 yyval.expr = expr_binary2(ITM_EXPR_PLUS_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 2074 break; 2075 default: 2076 yyval.expr = expr_binary2(ITM_EXPR_PLUS, yypvt[-2].expr, yypvt[-0].expr); 2077 break; 2078 } 2079 break; 2080 } 2081 } break; 2082 case 98: 2083 # line 1036 "../itm_comp.y" 2084 { 2085 TRACE_MESSAGE('y', ("expr: expr - expr\n")); 2086 yyval.expr = expr_binary(ITM_EXPR_MINUS, yypvt[-2].expr, yypvt[-0].expr); 2087 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2088 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2089 switch (yypvt[-2].expr->type) { 2090 case ITM_EXPR_INT: 2091 switch (yypvt[-0].expr->type) { 2092 case ITM_EXPR_INT: 2093 yyval.expr = expr_binary2(ITM_EXPR_MINUS_D_D, yypvt[-2].expr, yypvt[-0].expr); 2094 break; 2095 case ITM_EXPR_REG: 2096 yyval.expr = expr_binary2(ITM_EXPR_MINUS_D_R, yypvt[-2].expr, yypvt[-0].expr); 2097 break; 2098 case ITM_EXPR_IN_VECTOR_D: 2099 yyval.expr = expr_binary2(ITM_EXPR_MINUS_D_INVD, 2100 yypvt[-2].expr, yypvt[-0].expr); 2101 break; 2102 default: 2103 yyval.expr = expr_binary2(ITM_EXPR_MINUS_D_E, yypvt[-2].expr, yypvt[-0].expr); 2104 break; 2105 } 2106 break; 2107 case ITM_EXPR_REG: 2108 switch (yypvt[-0].expr->type) { 2109 case ITM_EXPR_INT: 2110 yyval.expr = expr_binary2(ITM_EXPR_MINUS_R_D, yypvt[-2].expr, yypvt[-0].expr); 2111 break; 2112 case ITM_EXPR_REG: 2113 yyval.expr = expr_binary2(ITM_EXPR_MINUS_R_R, yypvt[-2].expr, yypvt[-0].expr); 2114 break; 2115 case ITM_EXPR_IN_VECTOR_D: 2116 yyval.expr = expr_binary2(ITM_EXPR_MINUS_R_INVD, 2117 yypvt[-2].expr, yypvt[-0].expr); 2118 break; 2119 default: 2120 yyval.expr = expr_binary2(ITM_EXPR_MINUS_R_E, yypvt[-2].expr, yypvt[-0].expr); 2121 break; 2122 } 2123 break; 2124 case ITM_EXPR_IN_VECTOR_D: 2125 switch (yypvt[-0].expr->type) { 2126 case ITM_EXPR_INT: 2127 yyval.expr = expr_binary2(ITM_EXPR_MINUS_INVD_D, 2128 yypvt[-2].expr, yypvt[-0].expr); 2129 break; 2130 case ITM_EXPR_REG: 2131 yyval.expr = expr_binary2(ITM_EXPR_MINUS_INVD_R, 2132 yypvt[-2].expr, yypvt[-0].expr); 2133 break; 2134 case ITM_EXPR_IN_VECTOR_D: 2135 yyval.expr = expr_binary2(ITM_EXPR_MINUS_INVD_INVD, 2136 yypvt[-2].expr, yypvt[-0].expr); 2137 break; 2138 default: 2139 yyval.expr = expr_binary2(ITM_EXPR_MINUS_INVD_E, 2140 yypvt[-2].expr, yypvt[-0].expr); 2141 break; 2142 } 2143 break; 2144 default: 2145 switch (yypvt[-0].expr->type) { 2146 case ITM_EXPR_INT: 2147 yyval.expr = expr_binary2(ITM_EXPR_MINUS_E_D, yypvt[-2].expr, yypvt[-0].expr); 2148 break; 2149 case ITM_EXPR_REG: 2150 yyval.expr = expr_binary2(ITM_EXPR_MINUS_E_R, yypvt[-2].expr, yypvt[-0].expr); 2151 break; 2152 case ITM_EXPR_IN_VECTOR_D: 2153 yyval.expr = expr_binary2(ITM_EXPR_MINUS_E_INVD, 2154 yypvt[-2].expr, yypvt[-0].expr); 2155 break; 2156 default: 2157 yyval.expr = expr_binary2(ITM_EXPR_MINUS, yypvt[-2].expr, yypvt[-0].expr); 2158 break; 2159 } 2160 break; 2161 } 2162 } break; 2163 case 99: 2164 # line 1116 "../itm_comp.y" 2165 { 2166 TRACE_MESSAGE('y', ("expr: expr *expr\n")); 2167 yyval.expr = expr_binary(ITM_EXPR_MUL, yypvt[-2].expr, yypvt[-0].expr); 2168 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2169 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2170 switch (yypvt[-2].expr->type) { 2171 case ITM_EXPR_INT: 2172 switch (yypvt[-0].expr->type) { 2173 case ITM_EXPR_INT: 2174 yyval.expr = expr_binary2(ITM_EXPR_MUL_D_D, yypvt[-2].expr, yypvt[-0].expr); 2175 break; 2176 case ITM_EXPR_REG: 2177 yyval.expr = expr_binary2(ITM_EXPR_MUL_D_R, yypvt[-2].expr, yypvt[-0].expr); 2178 break; 2179 case ITM_EXPR_IN_VECTOR_D: 2180 yyval.expr = expr_binary2(ITM_EXPR_MUL_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 2181 break; 2182 default: 2183 yyval.expr = expr_binary2(ITM_EXPR_MUL_D_E, yypvt[-2].expr, yypvt[-0].expr); 2184 break; 2185 } 2186 break; 2187 case ITM_EXPR_REG: 2188 switch (yypvt[-0].expr->type) { 2189 case ITM_EXPR_INT: 2190 yyval.expr = expr_binary2(ITM_EXPR_MUL_R_D, yypvt[-2].expr, yypvt[-0].expr); 2191 break; 2192 case ITM_EXPR_REG: 2193 yyval.expr = expr_binary2(ITM_EXPR_MUL_R_R, yypvt[-2].expr, yypvt[-0].expr); 2194 break; 2195 case ITM_EXPR_IN_VECTOR_D: 2196 yyval.expr = expr_binary2(ITM_EXPR_MUL_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 2197 break; 2198 default: 2199 yyval.expr = expr_binary2(ITM_EXPR_MUL_R_E, yypvt[-2].expr, yypvt[-0].expr); 2200 break; 2201 } 2202 break; 2203 case ITM_EXPR_IN_VECTOR_D: 2204 switch (yypvt[-0].expr->type) { 2205 case ITM_EXPR_INT: 2206 yyval.expr = expr_binary2(ITM_EXPR_MUL_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 2207 break; 2208 case ITM_EXPR_REG: 2209 yyval.expr = expr_binary2(ITM_EXPR_MUL_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 2210 break; 2211 case ITM_EXPR_IN_VECTOR_D: 2212 yyval.expr = expr_binary2(ITM_EXPR_MUL_INVD_INVD, 2213 yypvt[-2].expr, yypvt[-0].expr); 2214 break; 2215 default: 2216 yyval.expr = expr_binary2(ITM_EXPR_MUL_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 2217 break; 2218 } 2219 break; 2220 default: 2221 switch (yypvt[-0].expr->type) { 2222 case ITM_EXPR_INT: 2223 yyval.expr = expr_binary2(ITM_EXPR_MUL_E_D, yypvt[-2].expr, yypvt[-0].expr); 2224 break; 2225 case ITM_EXPR_REG: 2226 yyval.expr = expr_binary2(ITM_EXPR_MUL_E_R, yypvt[-2].expr, yypvt[-0].expr); 2227 break; 2228 case ITM_EXPR_IN_VECTOR_D: 2229 yyval.expr = expr_binary2(ITM_EXPR_MUL_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 2230 break; 2231 default: 2232 yyval.expr = expr_binary2(ITM_EXPR_MUL, yypvt[-2].expr, yypvt[-0].expr); 2233 break; 2234 } 2235 break; 2236 } 2237 } break; 2238 case 100: 2239 # line 1190 "../itm_comp.y" 2240 { 2241 TRACE_MESSAGE('y', ("expr: expr / expr\n")); 2242 yyval.expr = expr_binary(ITM_EXPR_DIV, yypvt[-2].expr, yypvt[-0].expr); 2243 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2244 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2245 switch (yypvt[-2].expr->type) { 2246 case ITM_EXPR_INT: 2247 switch (yypvt[-0].expr->type) { 2248 case ITM_EXPR_INT: 2249 yyval.expr = expr_binary2(ITM_EXPR_DIV_D_D, yypvt[-2].expr, yypvt[-0].expr); 2250 break; 2251 case ITM_EXPR_REG: 2252 yyval.expr = expr_binary2(ITM_EXPR_DIV_D_R, yypvt[-2].expr, yypvt[-0].expr); 2253 break; 2254 case ITM_EXPR_IN_VECTOR_D: 2255 yyval.expr = expr_binary2(ITM_EXPR_DIV_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 2256 break; 2257 default: 2258 yyval.expr = expr_binary2(ITM_EXPR_DIV_D_E, yypvt[-2].expr, yypvt[-0].expr); 2259 break; 2260 } 2261 break; 2262 case ITM_EXPR_REG: 2263 switch (yypvt[-0].expr->type) { 2264 case ITM_EXPR_INT: 2265 yyval.expr = expr_binary2(ITM_EXPR_DIV_R_D, yypvt[-2].expr, yypvt[-0].expr); 2266 break; 2267 case ITM_EXPR_REG: 2268 yyval.expr = expr_binary2(ITM_EXPR_DIV_R_R, yypvt[-2].expr, yypvt[-0].expr); 2269 break; 2270 case ITM_EXPR_IN_VECTOR_D: 2271 yyval.expr = expr_binary2(ITM_EXPR_DIV_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 2272 break; 2273 default: 2274 yyval.expr = expr_binary2(ITM_EXPR_DIV_R_E, yypvt[-2].expr, yypvt[-0].expr); 2275 break; 2276 } 2277 break; 2278 case ITM_EXPR_IN_VECTOR_D: 2279 switch (yypvt[-0].expr->type) { 2280 case ITM_EXPR_INT: 2281 yyval.expr = expr_binary2(ITM_EXPR_DIV_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 2282 break; 2283 case ITM_EXPR_REG: 2284 yyval.expr = expr_binary2(ITM_EXPR_DIV_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 2285 break; 2286 case ITM_EXPR_IN_VECTOR_D: 2287 yyval.expr = expr_binary2(ITM_EXPR_DIV_INVD_INVD, 2288 yypvt[-2].expr, yypvt[-0].expr); 2289 break; 2290 default: 2291 yyval.expr = expr_binary2(ITM_EXPR_DIV_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 2292 break; 2293 } 2294 break; 2295 default: 2296 switch (yypvt[-0].expr->type) { 2297 case ITM_EXPR_INT: 2298 yyval.expr = expr_binary2(ITM_EXPR_DIV_E_D, yypvt[-2].expr, yypvt[-0].expr); 2299 break; 2300 case ITM_EXPR_REG: 2301 yyval.expr = expr_binary2(ITM_EXPR_DIV_E_R, yypvt[-2].expr, yypvt[-0].expr); 2302 break; 2303 case ITM_EXPR_IN_VECTOR_D: 2304 yyval.expr = expr_binary2(ITM_EXPR_DIV_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 2305 break; 2306 default: 2307 yyval.expr = expr_binary2(ITM_EXPR_DIV, yypvt[-2].expr, yypvt[-0].expr); 2308 break; 2309 } 2310 break; 2311 } 2312 } break; 2313 case 101: 2314 # line 1264 "../itm_comp.y" 2315 { 2316 TRACE_MESSAGE('y', ("expr: expr % expr\n")); 2317 yyval.expr = expr_binary(ITM_EXPR_MOD, yypvt[-2].expr, yypvt[-0].expr); 2318 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2319 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2320 switch (yypvt[-2].expr->type) { 2321 case ITM_EXPR_INT: 2322 switch (yypvt[-0].expr->type) { 2323 case ITM_EXPR_INT: 2324 yyval.expr = expr_binary2(ITM_EXPR_MOD_D_D, yypvt[-2].expr, yypvt[-0].expr); 2325 break; 2326 case ITM_EXPR_REG: 2327 yyval.expr = expr_binary2(ITM_EXPR_MOD_D_R, yypvt[-2].expr, yypvt[-0].expr); 2328 break; 2329 case ITM_EXPR_IN_VECTOR_D: 2330 yyval.expr = expr_binary2(ITM_EXPR_MOD_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 2331 break; 2332 default: 2333 yyval.expr = expr_binary2(ITM_EXPR_MOD_D_E, yypvt[-2].expr, yypvt[-0].expr); 2334 break; 2335 } 2336 break; 2337 case ITM_EXPR_REG: 2338 switch (yypvt[-0].expr->type) { 2339 case ITM_EXPR_INT: 2340 yyval.expr = expr_binary2(ITM_EXPR_MOD_R_D, yypvt[-2].expr, yypvt[-0].expr); 2341 break; 2342 case ITM_EXPR_REG: 2343 yyval.expr = expr_binary2(ITM_EXPR_MOD_R_R, yypvt[-2].expr, yypvt[-0].expr); 2344 break; 2345 case ITM_EXPR_IN_VECTOR_D: 2346 yyval.expr = expr_binary2(ITM_EXPR_MOD_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 2347 break; 2348 default: 2349 yyval.expr = expr_binary2(ITM_EXPR_MOD_R_E, yypvt[-2].expr, yypvt[-0].expr); 2350 break; 2351 } 2352 break; 2353 case ITM_EXPR_IN_VECTOR_D: 2354 switch (yypvt[-0].expr->type) { 2355 case ITM_EXPR_INT: 2356 yyval.expr = expr_binary2(ITM_EXPR_MOD_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 2357 break; 2358 case ITM_EXPR_REG: 2359 yyval.expr = expr_binary2(ITM_EXPR_MOD_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 2360 break; 2361 case ITM_EXPR_IN_VECTOR_D: 2362 yyval.expr = expr_binary2(ITM_EXPR_MOD_INVD_INVD, 2363 yypvt[-2].expr, yypvt[-0].expr); 2364 break; 2365 default: 2366 yyval.expr = expr_binary2(ITM_EXPR_MOD_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 2367 break; 2368 } 2369 break; 2370 default: 2371 switch (yypvt[-0].expr->type) { 2372 case ITM_EXPR_INT: 2373 yyval.expr = expr_binary2(ITM_EXPR_MOD_E_D, yypvt[-2].expr, yypvt[-0].expr); 2374 break; 2375 case ITM_EXPR_REG: 2376 yyval.expr = expr_binary2(ITM_EXPR_MOD_E_R, yypvt[-2].expr, yypvt[-0].expr); 2377 break; 2378 case ITM_EXPR_IN_VECTOR_D: 2379 yyval.expr = expr_binary2(ITM_EXPR_MOD_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 2380 break; 2381 default: 2382 yyval.expr = expr_binary2(ITM_EXPR_MOD, yypvt[-2].expr, yypvt[-0].expr); 2383 break; 2384 } 2385 break; 2386 } 2387 } break; 2388 case 102: 2389 # line 1338 "../itm_comp.y" 2390 { 2391 TRACE_MESSAGE('y', ("expr: expr << expr\n")); 2392 yyval.expr = expr_binary(ITM_EXPR_SHIFT_L, yypvt[-2].expr, yypvt[-0].expr); 2393 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2394 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2395 switch (yypvt[-2].expr->type) { 2396 case ITM_EXPR_INT: 2397 switch (yypvt[-0].expr->type) { 2398 case ITM_EXPR_INT: 2399 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_D_D, yypvt[-2].expr, yypvt[-0].expr); 2400 break; 2401 case ITM_EXPR_REG: 2402 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_D_R, yypvt[-2].expr, yypvt[-0].expr); 2403 break; 2404 case ITM_EXPR_IN_VECTOR_D: 2405 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_D_INVD, 2406 yypvt[-2].expr, yypvt[-0].expr); 2407 break; 2408 default: 2409 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_D_E, yypvt[-2].expr, yypvt[-0].expr); 2410 break; 2411 } 2412 break; 2413 case ITM_EXPR_REG: 2414 switch (yypvt[-0].expr->type) { 2415 case ITM_EXPR_INT: 2416 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_R_D, yypvt[-2].expr, yypvt[-0].expr); 2417 break; 2418 case ITM_EXPR_REG: 2419 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_R_R, yypvt[-2].expr, yypvt[-0].expr); 2420 break; 2421 case ITM_EXPR_IN_VECTOR_D: 2422 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_R_INVD, 2423 yypvt[-2].expr, yypvt[-0].expr); 2424 break; 2425 default: 2426 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_R_E, yypvt[-2].expr, yypvt[-0].expr); 2427 break; 2428 } 2429 break; 2430 case ITM_EXPR_IN_VECTOR_D: 2431 switch (yypvt[-0].expr->type) { 2432 case ITM_EXPR_INT: 2433 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_INVD_D, 2434 yypvt[-2].expr, yypvt[-0].expr); 2435 break; 2436 case ITM_EXPR_REG: 2437 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_INVD_R, 2438 yypvt[-2].expr, yypvt[-0].expr); 2439 break; 2440 case ITM_EXPR_IN_VECTOR_D: 2441 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_INVD_INVD, 2442 yypvt[-2].expr, yypvt[-0].expr); 2443 break; 2444 default: 2445 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_INVD_E, 2446 yypvt[-2].expr, yypvt[-0].expr); 2447 break; 2448 } 2449 break; 2450 default: 2451 switch (yypvt[-0].expr->type) { 2452 case ITM_EXPR_INT: 2453 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_E_D, yypvt[-2].expr, yypvt[-0].expr); 2454 break; 2455 case ITM_EXPR_REG: 2456 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_E_R, yypvt[-2].expr, yypvt[-0].expr); 2457 break; 2458 case ITM_EXPR_IN_VECTOR_D: 2459 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_E_INVD, 2460 yypvt[-2].expr, yypvt[-0].expr); 2461 break; 2462 default: 2463 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L, yypvt[-2].expr, yypvt[-0].expr); 2464 break; 2465 } 2466 break; 2467 } 2468 } break; 2469 case 103: 2470 # line 1418 "../itm_comp.y" 2471 { 2472 TRACE_MESSAGE('y', ("expr: expr >> expr\n")); 2473 yyval.expr = expr_binary(ITM_EXPR_SHIFT_R, yypvt[-2].expr, yypvt[-0].expr); 2474 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2475 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2476 switch (yypvt[-2].expr->type) { 2477 case ITM_EXPR_INT: 2478 switch (yypvt[-0].expr->type) { 2479 case ITM_EXPR_INT: 2480 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_D_D, yypvt[-2].expr, yypvt[-0].expr); 2481 break; 2482 case ITM_EXPR_REG: 2483 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_D_R, yypvt[-2].expr, yypvt[-0].expr); 2484 break; 2485 case ITM_EXPR_IN_VECTOR_D: 2486 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_D_INVD, 2487 yypvt[-2].expr, yypvt[-0].expr); 2488 break; 2489 default: 2490 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_D_E, yypvt[-2].expr, yypvt[-0].expr); 2491 break; 2492 } 2493 break; 2494 case ITM_EXPR_REG: 2495 switch (yypvt[-0].expr->type) { 2496 case ITM_EXPR_INT: 2497 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_R_D, yypvt[-2].expr, yypvt[-0].expr); 2498 break; 2499 case ITM_EXPR_REG: 2500 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_R_R, yypvt[-2].expr, yypvt[-0].expr); 2501 break; 2502 case ITM_EXPR_IN_VECTOR_D: 2503 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_R_INVD, 2504 yypvt[-2].expr, yypvt[-0].expr); 2505 break; 2506 default: 2507 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_R_E, yypvt[-2].expr, yypvt[-0].expr); 2508 break; 2509 } 2510 break; 2511 case ITM_EXPR_IN_VECTOR_D: 2512 switch (yypvt[-0].expr->type) { 2513 case ITM_EXPR_INT: 2514 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_INVD_D, 2515 yypvt[-2].expr, yypvt[-0].expr); 2516 break; 2517 case ITM_EXPR_REG: 2518 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_INVD_R, 2519 yypvt[-2].expr, yypvt[-0].expr); 2520 break; 2521 case ITM_EXPR_IN_VECTOR_D: 2522 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_INVD_INVD, 2523 yypvt[-2].expr, yypvt[-0].expr); 2524 break; 2525 default: 2526 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_INVD_E, 2527 yypvt[-2].expr, yypvt[-0].expr); 2528 break; 2529 } 2530 break; 2531 default: 2532 switch (yypvt[-0].expr->type) { 2533 case ITM_EXPR_INT: 2534 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_E_D, yypvt[-2].expr, yypvt[-0].expr); 2535 break; 2536 case ITM_EXPR_REG: 2537 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_E_R, yypvt[-2].expr, yypvt[-0].expr); 2538 break; 2539 case ITM_EXPR_IN_VECTOR_D: 2540 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_E_INVD, 2541 yypvt[-2].expr, yypvt[-0].expr); 2542 break; 2543 default: 2544 yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R, yypvt[-2].expr, yypvt[-0].expr); 2545 break; 2546 } 2547 break; 2548 } 2549 } break; 2550 case 104: 2551 # line 1498 "../itm_comp.y" 2552 { 2553 TRACE_MESSAGE('y', ("expr: expr | expr\n")); 2554 yyval.expr = expr_binary(ITM_EXPR_OR, yypvt[-2].expr, yypvt[-0].expr); 2555 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2556 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2557 switch (yypvt[-2].expr->type) { 2558 case ITM_EXPR_INT: 2559 switch (yypvt[-0].expr->type) { 2560 case ITM_EXPR_INT: 2561 yyval.expr = expr_binary2(ITM_EXPR_OR_D_D, yypvt[-2].expr, yypvt[-0].expr); 2562 break; 2563 case ITM_EXPR_REG: 2564 yyval.expr = expr_binary2(ITM_EXPR_OR_D_R, yypvt[-2].expr, yypvt[-0].expr); 2565 break; 2566 case ITM_EXPR_IN_VECTOR_D: 2567 yyval.expr = expr_binary2(ITM_EXPR_OR_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 2568 break; 2569 default: 2570 yyval.expr = expr_binary2(ITM_EXPR_OR_D_E, yypvt[-2].expr, yypvt[-0].expr); 2571 break; 2572 } 2573 break; 2574 case ITM_EXPR_REG: 2575 switch (yypvt[-0].expr->type) { 2576 case ITM_EXPR_INT: 2577 yyval.expr = expr_binary2(ITM_EXPR_OR_R_D, yypvt[-2].expr, yypvt[-0].expr); 2578 break; 2579 case ITM_EXPR_REG: 2580 yyval.expr = expr_binary2(ITM_EXPR_OR_R_R, yypvt[-2].expr, yypvt[-0].expr); 2581 break; 2582 case ITM_EXPR_IN_VECTOR_D: 2583 yyval.expr = expr_binary2(ITM_EXPR_OR_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 2584 break; 2585 default: 2586 yyval.expr = expr_binary2(ITM_EXPR_OR_R_E, yypvt[-2].expr, yypvt[-0].expr); 2587 break; 2588 } 2589 break; 2590 case ITM_EXPR_IN_VECTOR_D: 2591 switch (yypvt[-0].expr->type) { 2592 case ITM_EXPR_INT: 2593 yyval.expr = expr_binary2(ITM_EXPR_OR_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 2594 break; 2595 case ITM_EXPR_REG: 2596 yyval.expr = expr_binary2(ITM_EXPR_OR_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 2597 break; 2598 case ITM_EXPR_IN_VECTOR_D: 2599 yyval.expr = expr_binary2(ITM_EXPR_OR_INVD_INVD, 2600 yypvt[-2].expr, yypvt[-0].expr); 2601 break; 2602 default: 2603 yyval.expr = expr_binary2(ITM_EXPR_OR_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 2604 break; 2605 } 2606 break; 2607 default: 2608 switch (yypvt[-0].expr->type) { 2609 case ITM_EXPR_INT: 2610 yyval.expr = expr_binary2(ITM_EXPR_OR_E_D, yypvt[-2].expr, yypvt[-0].expr); 2611 break; 2612 case ITM_EXPR_REG: 2613 yyval.expr = expr_binary2(ITM_EXPR_OR_E_R, yypvt[-2].expr, yypvt[-0].expr); 2614 break; 2615 case ITM_EXPR_IN_VECTOR_D: 2616 yyval.expr = expr_binary2(ITM_EXPR_OR_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 2617 break; 2618 default: 2619 yyval.expr = expr_binary2(ITM_EXPR_OR, yypvt[-2].expr, yypvt[-0].expr); 2620 break; 2621 } 2622 break; 2623 } 2624 } break; 2625 case 105: 2626 # line 1572 "../itm_comp.y" 2627 { 2628 TRACE_MESSAGE('y', ("expr: expr ^ expr\n")); 2629 yyval.expr = expr_binary(ITM_EXPR_XOR, yypvt[-2].expr, yypvt[-0].expr); 2630 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2631 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2632 switch (yypvt[-2].expr->type) { 2633 case ITM_EXPR_INT: 2634 switch (yypvt[-0].expr->type) { 2635 case ITM_EXPR_INT: 2636 yyval.expr = expr_binary2(ITM_EXPR_XOR_D_D, yypvt[-2].expr, yypvt[-0].expr); 2637 break; 2638 case ITM_EXPR_REG: 2639 yyval.expr = expr_binary2(ITM_EXPR_XOR_D_R, yypvt[-2].expr, yypvt[-0].expr); 2640 break; 2641 case ITM_EXPR_IN_VECTOR_D: 2642 yyval.expr = expr_binary2(ITM_EXPR_XOR_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 2643 break; 2644 default: 2645 yyval.expr = expr_binary2(ITM_EXPR_XOR_D_E, yypvt[-2].expr, yypvt[-0].expr); 2646 break; 2647 } 2648 break; 2649 case ITM_EXPR_REG: 2650 switch (yypvt[-0].expr->type) { 2651 case ITM_EXPR_INT: 2652 yyval.expr = expr_binary2(ITM_EXPR_XOR_R_D, yypvt[-2].expr, yypvt[-0].expr); 2653 break; 2654 case ITM_EXPR_REG: 2655 yyval.expr = expr_binary2(ITM_EXPR_XOR_R_R, yypvt[-2].expr, yypvt[-0].expr); 2656 break; 2657 case ITM_EXPR_IN_VECTOR_D: 2658 yyval.expr = expr_binary2(ITM_EXPR_XOR_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 2659 break; 2660 default: 2661 yyval.expr = expr_binary2(ITM_EXPR_XOR_R_E, yypvt[-2].expr, yypvt[-0].expr); 2662 break; 2663 } 2664 break; 2665 case ITM_EXPR_IN_VECTOR_D: 2666 switch (yypvt[-0].expr->type) { 2667 case ITM_EXPR_INT: 2668 yyval.expr = expr_binary2(ITM_EXPR_XOR_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 2669 break; 2670 case ITM_EXPR_REG: 2671 yyval.expr = expr_binary2(ITM_EXPR_XOR_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 2672 break; 2673 case ITM_EXPR_IN_VECTOR_D: 2674 yyval.expr = expr_binary2(ITM_EXPR_XOR_INVD_INVD, 2675 yypvt[-2].expr, yypvt[-0].expr); 2676 break; 2677 default: 2678 yyval.expr = expr_binary2(ITM_EXPR_XOR_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 2679 break; 2680 } 2681 break; 2682 default: 2683 switch (yypvt[-0].expr->type) { 2684 case ITM_EXPR_INT: 2685 yyval.expr = expr_binary2(ITM_EXPR_XOR_E_D, yypvt[-2].expr, yypvt[-0].expr); 2686 break; 2687 case ITM_EXPR_REG: 2688 yyval.expr = expr_binary2(ITM_EXPR_XOR_E_R, yypvt[-2].expr, yypvt[-0].expr); 2689 break; 2690 case ITM_EXPR_IN_VECTOR_D: 2691 yyval.expr = expr_binary2(ITM_EXPR_XOR_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 2692 break; 2693 default: 2694 yyval.expr = expr_binary2(ITM_EXPR_XOR, yypvt[-2].expr, yypvt[-0].expr); 2695 break; 2696 } 2697 break; 2698 } 2699 } break; 2700 case 106: 2701 # line 1646 "../itm_comp.y" 2702 { 2703 TRACE_MESSAGE('y', ("expr: expr & expr\n")); 2704 yyval.expr = expr_binary(ITM_EXPR_AND, yypvt[-2].expr, yypvt[-0].expr); 2705 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2706 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2707 switch (yypvt[-2].expr->type) { 2708 case ITM_EXPR_INT: 2709 switch (yypvt[-0].expr->type) { 2710 case ITM_EXPR_INT: 2711 yyval.expr = expr_binary2(ITM_EXPR_AND_D_D, yypvt[-2].expr, yypvt[-0].expr); 2712 break; 2713 case ITM_EXPR_REG: 2714 yyval.expr = expr_binary2(ITM_EXPR_AND_D_R, yypvt[-2].expr, yypvt[-0].expr); 2715 break; 2716 case ITM_EXPR_IN_VECTOR_D: 2717 yyval.expr = expr_binary2(ITM_EXPR_AND_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 2718 break; 2719 default: 2720 yyval.expr = expr_binary2(ITM_EXPR_AND_D_E, yypvt[-2].expr, yypvt[-0].expr); 2721 break; 2722 } 2723 break; 2724 case ITM_EXPR_REG: 2725 switch (yypvt[-0].expr->type) { 2726 case ITM_EXPR_INT: 2727 yyval.expr = expr_binary2(ITM_EXPR_AND_R_D, yypvt[-2].expr, yypvt[-0].expr); 2728 break; 2729 case ITM_EXPR_REG: 2730 yyval.expr = expr_binary2(ITM_EXPR_AND_R_R, yypvt[-2].expr, yypvt[-0].expr); 2731 break; 2732 case ITM_EXPR_IN_VECTOR_D: 2733 yyval.expr = expr_binary2(ITM_EXPR_AND_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 2734 break; 2735 default: 2736 yyval.expr = expr_binary2(ITM_EXPR_AND_R_E, yypvt[-2].expr, yypvt[-0].expr); 2737 break; 2738 } 2739 break; 2740 case ITM_EXPR_IN_VECTOR_D: 2741 switch (yypvt[-0].expr->type) { 2742 case ITM_EXPR_INT: 2743 yyval.expr = expr_binary2(ITM_EXPR_AND_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 2744 break; 2745 case ITM_EXPR_REG: 2746 yyval.expr = expr_binary2(ITM_EXPR_AND_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 2747 break; 2748 case ITM_EXPR_IN_VECTOR_D: 2749 yyval.expr = expr_binary2(ITM_EXPR_AND_INVD_INVD, 2750 yypvt[-2].expr, yypvt[-0].expr); 2751 break; 2752 default: 2753 yyval.expr = expr_binary2(ITM_EXPR_AND_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 2754 break; 2755 } 2756 break; 2757 default: 2758 switch (yypvt[-0].expr->type) { 2759 case ITM_EXPR_INT: 2760 yyval.expr = expr_binary2(ITM_EXPR_AND_E_D, yypvt[-2].expr, yypvt[-0].expr); 2761 break; 2762 case ITM_EXPR_REG: 2763 yyval.expr = expr_binary2(ITM_EXPR_AND_E_R, yypvt[-2].expr, yypvt[-0].expr); 2764 break; 2765 case ITM_EXPR_IN_VECTOR_D: 2766 yyval.expr = expr_binary2(ITM_EXPR_AND_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 2767 break; 2768 default: 2769 yyval.expr = expr_binary2(ITM_EXPR_AND, yypvt[-2].expr, yypvt[-0].expr); 2770 break; 2771 } 2772 break; 2773 } 2774 } break; 2775 case 107: 2776 # line 1720 "../itm_comp.y" 2777 { 2778 TRACE_MESSAGE('y', ("expr: expr == expr\n")); 2779 yyval.expr = expr_binary(ITM_EXPR_EQ, yypvt[-2].expr, yypvt[-0].expr); 2780 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2781 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2782 switch (yypvt[-2].expr->type) { 2783 case ITM_EXPR_INT: 2784 switch (yypvt[-0].expr->type) { 2785 case ITM_EXPR_INT: 2786 yyval.expr = expr_binary2(ITM_EXPR_EQ_D_D, yypvt[-2].expr, yypvt[-0].expr); 2787 break; 2788 case ITM_EXPR_REG: 2789 yyval.expr = expr_binary2(ITM_EXPR_EQ_D_R, yypvt[-2].expr, yypvt[-0].expr); 2790 break; 2791 case ITM_EXPR_IN_VECTOR_D: 2792 yyval.expr = expr_binary2(ITM_EXPR_EQ_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 2793 break; 2794 default: 2795 yyval.expr = expr_binary2(ITM_EXPR_EQ_D_E, yypvt[-2].expr, yypvt[-0].expr); 2796 break; 2797 } 2798 break; 2799 case ITM_EXPR_REG: 2800 switch (yypvt[-0].expr->type) { 2801 case ITM_EXPR_INT: 2802 yyval.expr = expr_binary2(ITM_EXPR_EQ_R_D, yypvt[-2].expr, yypvt[-0].expr); 2803 break; 2804 case ITM_EXPR_REG: 2805 yyval.expr = expr_binary2(ITM_EXPR_EQ_R_R, yypvt[-2].expr, yypvt[-0].expr); 2806 break; 2807 case ITM_EXPR_IN_VECTOR_D: 2808 yyval.expr = expr_binary2(ITM_EXPR_EQ_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 2809 break; 2810 default: 2811 yyval.expr = expr_binary2(ITM_EXPR_EQ_R_E, yypvt[-2].expr, yypvt[-0].expr); 2812 break; 2813 } 2814 break; 2815 case ITM_EXPR_IN_VECTOR_D: 2816 switch (yypvt[-0].expr->type) { 2817 case ITM_EXPR_INT: 2818 yyval.expr = expr_binary2(ITM_EXPR_EQ_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 2819 break; 2820 case ITM_EXPR_REG: 2821 yyval.expr = expr_binary2(ITM_EXPR_EQ_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 2822 break; 2823 case ITM_EXPR_IN_VECTOR_D: 2824 yyval.expr = expr_binary2(ITM_EXPR_EQ_INVD_INVD, 2825 yypvt[-2].expr, yypvt[-0].expr); 2826 break; 2827 default: 2828 yyval.expr = expr_binary2(ITM_EXPR_EQ_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 2829 break; 2830 } 2831 break; 2832 default: 2833 switch (yypvt[-0].expr->type) { 2834 case ITM_EXPR_INT: 2835 yyval.expr = expr_binary2(ITM_EXPR_EQ_E_D, yypvt[-2].expr, yypvt[-0].expr); 2836 break; 2837 case ITM_EXPR_REG: 2838 yyval.expr = expr_binary2(ITM_EXPR_EQ_E_R, yypvt[-2].expr, yypvt[-0].expr); 2839 break; 2840 case ITM_EXPR_IN_VECTOR_D: 2841 yyval.expr = expr_binary2(ITM_EXPR_EQ_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 2842 break; 2843 default: 2844 yyval.expr = expr_binary2(ITM_EXPR_EQ, yypvt[-2].expr, yypvt[-0].expr); 2845 break; 2846 } 2847 break; 2848 } 2849 } break; 2850 case 108: 2851 # line 1794 "../itm_comp.y" 2852 { 2853 TRACE_MESSAGE('y', ("expr: expr != expr\n")); 2854 yyval.expr = expr_binary(ITM_EXPR_NE, yypvt[-2].expr, yypvt[-0].expr); 2855 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2856 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2857 switch (yypvt[-2].expr->type) { 2858 case ITM_EXPR_INT: 2859 switch (yypvt[-0].expr->type) { 2860 case ITM_EXPR_INT: 2861 yyval.expr = expr_binary2(ITM_EXPR_NE_D_D, yypvt[-2].expr, yypvt[-0].expr); 2862 break; 2863 case ITM_EXPR_REG: 2864 yyval.expr = expr_binary2(ITM_EXPR_NE_D_R, yypvt[-2].expr, yypvt[-0].expr); 2865 break; 2866 case ITM_EXPR_IN_VECTOR_D: 2867 yyval.expr = expr_binary2(ITM_EXPR_NE_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 2868 break; 2869 default: 2870 yyval.expr = expr_binary2(ITM_EXPR_NE_D_E, yypvt[-2].expr, yypvt[-0].expr); 2871 break; 2872 } 2873 break; 2874 case ITM_EXPR_REG: 2875 switch (yypvt[-0].expr->type) { 2876 case ITM_EXPR_INT: 2877 yyval.expr = expr_binary2(ITM_EXPR_NE_R_D, yypvt[-2].expr, yypvt[-0].expr); 2878 break; 2879 case ITM_EXPR_REG: 2880 yyval.expr = expr_binary2(ITM_EXPR_NE_R_R, yypvt[-2].expr, yypvt[-0].expr); 2881 break; 2882 case ITM_EXPR_IN_VECTOR_D: 2883 yyval.expr = expr_binary2(ITM_EXPR_NE_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 2884 break; 2885 default: 2886 yyval.expr = expr_binary2(ITM_EXPR_NE_R_E, yypvt[-2].expr, yypvt[-0].expr); 2887 break; 2888 } 2889 break; 2890 case ITM_EXPR_IN_VECTOR_D: 2891 switch (yypvt[-0].expr->type) { 2892 case ITM_EXPR_INT: 2893 yyval.expr = expr_binary2(ITM_EXPR_NE_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 2894 break; 2895 case ITM_EXPR_REG: 2896 yyval.expr = expr_binary2(ITM_EXPR_NE_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 2897 break; 2898 case ITM_EXPR_IN_VECTOR_D: 2899 yyval.expr = expr_binary2(ITM_EXPR_NE_INVD_INVD, 2900 yypvt[-2].expr, yypvt[-0].expr); 2901 break; 2902 default: 2903 yyval.expr = expr_binary2(ITM_EXPR_NE_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 2904 break; 2905 } 2906 break; 2907 default: 2908 switch (yypvt[-0].expr->type) { 2909 case ITM_EXPR_INT: 2910 yyval.expr = expr_binary2(ITM_EXPR_NE_E_D, yypvt[-2].expr, yypvt[-0].expr); 2911 break; 2912 case ITM_EXPR_REG: 2913 yyval.expr = expr_binary2(ITM_EXPR_NE_E_R, yypvt[-2].expr, yypvt[-0].expr); 2914 break; 2915 case ITM_EXPR_IN_VECTOR_D: 2916 yyval.expr = expr_binary2(ITM_EXPR_NE_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 2917 break; 2918 default: 2919 yyval.expr = expr_binary2(ITM_EXPR_NE, yypvt[-2].expr, yypvt[-0].expr); 2920 break; 2921 } 2922 break; 2923 } 2924 } break; 2925 case 109: 2926 # line 1868 "../itm_comp.y" 2927 { 2928 TRACE_MESSAGE('y', ("expr: expr > expr\n")); 2929 yyval.expr = expr_binary(ITM_EXPR_GT, yypvt[-2].expr, yypvt[-0].expr); 2930 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 2931 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 2932 switch (yypvt[-2].expr->type) { 2933 case ITM_EXPR_INT: 2934 switch (yypvt[-0].expr->type) { 2935 case ITM_EXPR_INT: 2936 yyval.expr = expr_binary2(ITM_EXPR_GT_D_D, yypvt[-2].expr, yypvt[-0].expr); 2937 break; 2938 case ITM_EXPR_REG: 2939 yyval.expr = expr_binary2(ITM_EXPR_GT_D_R, yypvt[-2].expr, yypvt[-0].expr); 2940 break; 2941 case ITM_EXPR_IN_VECTOR_D: 2942 yyval.expr = expr_binary2(ITM_EXPR_GT_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 2943 break; 2944 default: 2945 yyval.expr = expr_binary2(ITM_EXPR_GT_D_E, yypvt[-2].expr, yypvt[-0].expr); 2946 break; 2947 } 2948 break; 2949 case ITM_EXPR_REG: 2950 switch (yypvt[-0].expr->type) { 2951 case ITM_EXPR_INT: 2952 yyval.expr = expr_binary2(ITM_EXPR_GT_R_D, yypvt[-2].expr, yypvt[-0].expr); 2953 break; 2954 case ITM_EXPR_REG: 2955 yyval.expr = expr_binary2(ITM_EXPR_GT_R_R, yypvt[-2].expr, yypvt[-0].expr); 2956 break; 2957 case ITM_EXPR_IN_VECTOR_D: 2958 yyval.expr = expr_binary2(ITM_EXPR_GT_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 2959 break; 2960 default: 2961 yyval.expr = expr_binary2(ITM_EXPR_GT_R_E, yypvt[-2].expr, yypvt[-0].expr); 2962 break; 2963 } 2964 break; 2965 case ITM_EXPR_IN_VECTOR_D: 2966 switch (yypvt[-0].expr->type) { 2967 case ITM_EXPR_INT: 2968 yyval.expr = expr_binary2(ITM_EXPR_GT_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 2969 break; 2970 case ITM_EXPR_REG: 2971 yyval.expr = expr_binary2(ITM_EXPR_GT_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 2972 break; 2973 case ITM_EXPR_IN_VECTOR_D: 2974 yyval.expr = expr_binary2(ITM_EXPR_GT_INVD_INVD, 2975 yypvt[-2].expr, yypvt[-0].expr); 2976 break; 2977 default: 2978 yyval.expr = expr_binary2(ITM_EXPR_GT_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 2979 break; 2980 } 2981 break; 2982 default: 2983 switch (yypvt[-0].expr->type) { 2984 case ITM_EXPR_INT: 2985 yyval.expr = expr_binary2(ITM_EXPR_GT_E_D, yypvt[-2].expr, yypvt[-0].expr); 2986 break; 2987 case ITM_EXPR_REG: 2988 yyval.expr = expr_binary2(ITM_EXPR_GT_E_R, yypvt[-2].expr, yypvt[-0].expr); 2989 break; 2990 case ITM_EXPR_IN_VECTOR_D: 2991 yyval.expr = expr_binary2(ITM_EXPR_GT_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 2992 break; 2993 default: 2994 yyval.expr = expr_binary2(ITM_EXPR_GT, yypvt[-2].expr, yypvt[-0].expr); 2995 break; 2996 } 2997 break; 2998 } 2999 } break; 3000 case 110: 3001 # line 1942 "../itm_comp.y" 3002 { 3003 TRACE_MESSAGE('y', ("expr: expr >= expr\n")); 3004 yyval.expr = expr_binary(ITM_EXPR_GE, yypvt[-2].expr, yypvt[-0].expr); 3005 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 3006 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 3007 switch (yypvt[-2].expr->type) { 3008 case ITM_EXPR_INT: 3009 switch (yypvt[-0].expr->type) { 3010 case ITM_EXPR_INT: 3011 yyval.expr = expr_binary2(ITM_EXPR_GE_D_D, yypvt[-2].expr, yypvt[-0].expr); 3012 break; 3013 case ITM_EXPR_REG: 3014 yyval.expr = expr_binary2(ITM_EXPR_GE_D_R, yypvt[-2].expr, yypvt[-0].expr); 3015 break; 3016 case ITM_EXPR_IN_VECTOR_D: 3017 yyval.expr = expr_binary2(ITM_EXPR_GE_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 3018 break; 3019 default: 3020 yyval.expr = expr_binary2(ITM_EXPR_GE_D_E, yypvt[-2].expr, yypvt[-0].expr); 3021 break; 3022 } 3023 break; 3024 case ITM_EXPR_REG: 3025 switch (yypvt[-0].expr->type) { 3026 case ITM_EXPR_INT: 3027 yyval.expr = expr_binary2(ITM_EXPR_GE_R_D, yypvt[-2].expr, yypvt[-0].expr); 3028 break; 3029 case ITM_EXPR_REG: 3030 yyval.expr = expr_binary2(ITM_EXPR_GE_R_R, yypvt[-2].expr, yypvt[-0].expr); 3031 break; 3032 case ITM_EXPR_IN_VECTOR_D: 3033 yyval.expr = expr_binary2(ITM_EXPR_GE_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 3034 break; 3035 default: 3036 yyval.expr = expr_binary2(ITM_EXPR_GE_R_E, yypvt[-2].expr, yypvt[-0].expr); 3037 break; 3038 } 3039 break; 3040 case ITM_EXPR_IN_VECTOR_D: 3041 switch (yypvt[-0].expr->type) { 3042 case ITM_EXPR_INT: 3043 yyval.expr = expr_binary2(ITM_EXPR_GE_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 3044 break; 3045 case ITM_EXPR_REG: 3046 yyval.expr = expr_binary2(ITM_EXPR_GE_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 3047 break; 3048 case ITM_EXPR_IN_VECTOR_D: 3049 yyval.expr = expr_binary2(ITM_EXPR_GE_INVD_INVD, 3050 yypvt[-2].expr, yypvt[-0].expr); 3051 break; 3052 default: 3053 yyval.expr = expr_binary2(ITM_EXPR_GE_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 3054 break; 3055 } 3056 break; 3057 default: 3058 switch (yypvt[-0].expr->type) { 3059 case ITM_EXPR_INT: 3060 yyval.expr = expr_binary2(ITM_EXPR_GE_E_D, yypvt[-2].expr, yypvt[-0].expr); 3061 break; 3062 case ITM_EXPR_REG: 3063 yyval.expr = expr_binary2(ITM_EXPR_GE_E_R, yypvt[-2].expr, yypvt[-0].expr); 3064 break; 3065 case ITM_EXPR_IN_VECTOR_D: 3066 yyval.expr = expr_binary2(ITM_EXPR_GE_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 3067 break; 3068 default: 3069 yyval.expr = expr_binary2(ITM_EXPR_GE, yypvt[-2].expr, yypvt[-0].expr); 3070 break; 3071 } 3072 break; 3073 } 3074 } break; 3075 case 111: 3076 # line 2016 "../itm_comp.y" 3077 { 3078 TRACE_MESSAGE('y', ("expr: expr < expr\n")); 3079 yyval.expr = expr_binary(ITM_EXPR_LT, yypvt[-2].expr, yypvt[-0].expr); 3080 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 3081 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 3082 switch (yypvt[-2].expr->type) { 3083 case ITM_EXPR_INT: 3084 switch (yypvt[-0].expr->type) { 3085 case ITM_EXPR_INT: 3086 yyval.expr = expr_binary2(ITM_EXPR_LT_D_D, yypvt[-2].expr, yypvt[-0].expr); 3087 break; 3088 case ITM_EXPR_REG: 3089 yyval.expr = expr_binary2(ITM_EXPR_LT_D_R, yypvt[-2].expr, yypvt[-0].expr); 3090 break; 3091 case ITM_EXPR_IN_VECTOR_D: 3092 yyval.expr = expr_binary2(ITM_EXPR_LT_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 3093 break; 3094 default: 3095 yyval.expr = expr_binary2(ITM_EXPR_LT_D_E, yypvt[-2].expr, yypvt[-0].expr); 3096 break; 3097 } 3098 break; 3099 case ITM_EXPR_REG: 3100 switch (yypvt[-0].expr->type) { 3101 case ITM_EXPR_INT: 3102 yyval.expr = expr_binary2(ITM_EXPR_LT_R_D, yypvt[-2].expr, yypvt[-0].expr); 3103 break; 3104 case ITM_EXPR_REG: 3105 yyval.expr = expr_binary2(ITM_EXPR_LT_R_R, yypvt[-2].expr, yypvt[-0].expr); 3106 break; 3107 case ITM_EXPR_IN_VECTOR_D: 3108 yyval.expr = expr_binary2(ITM_EXPR_LT_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 3109 break; 3110 default: 3111 yyval.expr = expr_binary2(ITM_EXPR_LT_R_E, yypvt[-2].expr, yypvt[-0].expr); 3112 break; 3113 } 3114 break; 3115 case ITM_EXPR_IN_VECTOR_D: 3116 switch (yypvt[-0].expr->type) { 3117 case ITM_EXPR_INT: 3118 yyval.expr = expr_binary2(ITM_EXPR_LT_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 3119 break; 3120 case ITM_EXPR_REG: 3121 yyval.expr = expr_binary2(ITM_EXPR_LT_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 3122 break; 3123 case ITM_EXPR_IN_VECTOR_D: 3124 yyval.expr = expr_binary2(ITM_EXPR_LT_INVD_INVD, 3125 yypvt[-2].expr, yypvt[-0].expr); 3126 break; 3127 default: 3128 yyval.expr = expr_binary2(ITM_EXPR_LT_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 3129 break; 3130 } 3131 break; 3132 default: 3133 switch (yypvt[-0].expr->type) { 3134 case ITM_EXPR_INT: 3135 yyval.expr = expr_binary2(ITM_EXPR_LT_E_D, yypvt[-2].expr, yypvt[-0].expr); 3136 break; 3137 case ITM_EXPR_REG: 3138 yyval.expr = expr_binary2(ITM_EXPR_LT_E_R, yypvt[-2].expr, yypvt[-0].expr); 3139 break; 3140 case ITM_EXPR_IN_VECTOR_D: 3141 yyval.expr = expr_binary2(ITM_EXPR_LT_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 3142 break; 3143 default: 3144 yyval.expr = expr_binary2(ITM_EXPR_LT, yypvt[-2].expr, yypvt[-0].expr); 3145 break; 3146 } 3147 break; 3148 } 3149 } break; 3150 case 112: 3151 # line 2090 "../itm_comp.y" 3152 { 3153 TRACE_MESSAGE('y', ("expr: expr <= expr\n")); 3154 yyval.expr = expr_binary(ITM_EXPR_LE, yypvt[-2].expr, yypvt[-0].expr); 3155 yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr); 3156 yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr); 3157 switch (yypvt[-2].expr->type) { 3158 case ITM_EXPR_INT: 3159 switch (yypvt[-0].expr->type) { 3160 case ITM_EXPR_INT: 3161 yyval.expr = expr_binary2(ITM_EXPR_LE_D_D, yypvt[-2].expr, yypvt[-0].expr); 3162 break; 3163 case ITM_EXPR_REG: 3164 yyval.expr = expr_binary2(ITM_EXPR_LE_D_R, yypvt[-2].expr, yypvt[-0].expr); 3165 break; 3166 case ITM_EXPR_IN_VECTOR_D: 3167 yyval.expr = expr_binary2(ITM_EXPR_LE_D_INVD, yypvt[-2].expr, yypvt[-0].expr); 3168 break; 3169 default: 3170 yyval.expr = expr_binary2(ITM_EXPR_LE_D_E, yypvt[-2].expr, yypvt[-0].expr); 3171 break; 3172 } 3173 break; 3174 case ITM_EXPR_REG: 3175 switch (yypvt[-0].expr->type) { 3176 case ITM_EXPR_INT: 3177 yyval.expr = expr_binary2(ITM_EXPR_LE_R_D, yypvt[-2].expr, yypvt[-0].expr); 3178 break; 3179 case ITM_EXPR_REG: 3180 yyval.expr = expr_binary2(ITM_EXPR_LE_R_R, yypvt[-2].expr, yypvt[-0].expr); 3181 break; 3182 case ITM_EXPR_IN_VECTOR_D: 3183 yyval.expr = expr_binary2(ITM_EXPR_LE_R_INVD, yypvt[-2].expr, yypvt[-0].expr); 3184 break; 3185 default: 3186 yyval.expr = expr_binary2(ITM_EXPR_LE_R_E, yypvt[-2].expr, yypvt[-0].expr); 3187 break; 3188 } 3189 break; 3190 case ITM_EXPR_IN_VECTOR_D: 3191 switch (yypvt[-0].expr->type) { 3192 case ITM_EXPR_INT: 3193 yyval.expr = expr_binary2(ITM_EXPR_LE_INVD_D, yypvt[-2].expr, yypvt[-0].expr); 3194 break; 3195 case ITM_EXPR_REG: 3196 yyval.expr = expr_binary2(ITM_EXPR_LE_INVD_R, yypvt[-2].expr, yypvt[-0].expr); 3197 break; 3198 case ITM_EXPR_IN_VECTOR_D: 3199 yyval.expr = expr_binary2(ITM_EXPR_LE_INVD_INVD, 3200 yypvt[-2].expr, yypvt[-0].expr); 3201 break; 3202 default: 3203 yyval.expr = expr_binary2(ITM_EXPR_LE_INVD_E, yypvt[-2].expr, yypvt[-0].expr); 3204 break; 3205 } 3206 break; 3207 default: 3208 switch (yypvt[-0].expr->type) { 3209 case ITM_EXPR_INT: 3210 yyval.expr = expr_binary2(ITM_EXPR_LE_E_D, yypvt[-2].expr, yypvt[-0].expr); 3211 break; 3212 case ITM_EXPR_REG: 3213 yyval.expr = expr_binary2(ITM_EXPR_LE_E_R, yypvt[-2].expr, yypvt[-0].expr); 3214 break; 3215 case ITM_EXPR_IN_VECTOR_D: 3216 yyval.expr = expr_binary2(ITM_EXPR_LE_E_INVD, yypvt[-2].expr, yypvt[-0].expr); 3217 break; 3218 default: 3219 yyval.expr = expr_binary2(ITM_EXPR_LE, yypvt[-2].expr, yypvt[-0].expr); 3220 break; 3221 } 3222 break; 3223 } 3224 } break; 3225 case 113: 3226 # line 2164 "../itm_comp.y" 3227 { 3228 TRACE_MESSAGE('y', ("expr: NAME = expr\n")); 3229 yyval.expr = expr_assign(ITM_EXPR_ASSIGN, yypvt[-2].data, yypvt[-0].expr); 3230 } break; 3231 case 114: 3232 # line 2169 "../itm_comp.y" 3233 { 3234 TRACE_MESSAGE('y', ("expr: expr || expr\n")); 3235 yyval.expr = expr_binary(ITM_EXPR_LOR, yypvt[-2].expr, yypvt[-0].expr); 3236 } break; 3237 case 115: 3238 # line 2174 "../itm_comp.y" 3239 { 3240 TRACE_MESSAGE('y', ("expr: expr && expr\n")); 3241 yyval.expr = expr_binary(ITM_EXPR_LAND, yypvt[-2].expr, yypvt[-0].expr); 3242 } break; 3243 # line 556 "/usr/share/lib/ccs/yaccpar" 3244 } 3245 goto yystack; /* reset registers in driver code */ 3246 } 3247 3248