# line 2 "../itm_comp.y"
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 * Copyright (c) 1999 by Sun Microsystems, Inc.
 * All rights reserved.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <libintl.h>
#include <errno.h>

#include "iconv_tm.h"
#include "itmcomp.h"
#include "itm_util.h"


# line 43 "../itm_comp.y"
typedef union
#ifdef __cplusplus
	YYSTYPE
#endif
		yystacktype
{
	int		intval;

	itm_num_t	num;
	itm_data_t	*name;
	itm_data_t	*data;

	itm_tbl_hdr_t	*tbl_hdr;
	itm_direc_t	*direc_unit;
	itm_expr_t	*expr;

	itmc_action_t	action;
	itmc_obj_t	*obj;
	itmc_map_t	*map_list;
	itmc_ref_t	*itmc_ref;
	itmc_map_attr_t	*map_attr;
} YYSTYPE;
# define ITMNAME 257
# define NAME 258
# define MAPTYPE_NAME 259
# define HEXADECIMAL 260
# define DECIMAL 261
# define ITM_DEFAULT 262
# define ITM_IDENTICAL 263
# define BETWEEN 264
# define BREAK 265
# define CONDITION 266
# define DIRECTION 267
# define DISCARD 268
# define ERROR 269
# define ITM_ELSE 270
# define ITM_INIT 271
# define ITM_FALSE 272
# define ITM_IF 273
# define ITM_IN 274
# define ITM_INSIZE 275
# define NOP 276
# define OPERATION 277
# define ITM_OUT 278
# define ITM_OUTSIZE 279
# define PRINTCHR 280
# define PRINTHD 281
# define PRINTINT 282
# define MAP 283
# define RESET 284
# define RETURN 285
# define ITM_TRUE 286
# define ESCAPESEQ 287
# define MAPTYPE 288
# define RESULTLEN 289
# define MAPTYPE_AUTO 290
# define MAPTYPE_INDEX 291
# define MAPTYPE_DENSE 292
# define MAPTYPE_HASH 293
# define MAPTYPE_BINARY 294
# define ELLIPSES 295
# define CBO 296
# define CBC 297
# define SBO 298
# define SBC 299
# define PO 300
# define PC 301
# define SC 302
# define COMMA 303
# define COLON 304
# define ASSIGN 305
# define LOR 306
# define LAND 307
# define OR 308
# define XOR 309
# define AND 310
# define EQ 311
# define NE 312
# define LT 313
# define LE 314
# define GT 315
# define GE 316
# define SHL 317
# define SHR 318
# define PLUS 319
# define MINUS 320
# define MUL 321
# define DIV 322
# define MOD 323
# define NOT 324
# define NEG 325
# define UMINUS 326

#include <inttypes.h>

#ifdef __STDC__
#include <stdlib.h>
#include <string.h>
#define	YYCONST	const
#else
#include <malloc.h>
#include <memory.h>
#define	YYCONST
#endif

#include <values.h>

#if defined(__cplusplus) || defined(__STDC__)

#if defined(__cplusplus) && defined(__EXTERN_C__)
extern "C" {
#endif
#ifndef yyerror
#if defined(__cplusplus)
	void yyerror(YYCONST char *);
#endif
#endif
#ifndef yylex
	int yylex(void);
#endif
	int yyparse(void);
#if defined(__cplusplus) && defined(__EXTERN_C__)
}
#endif

#endif

#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern int yyerrflag;
YYSTYPE yylval;
YYSTYPE yyval;
typedef int yytabelem;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
#if YYMAXDEPTH > 0
int yy_yys[YYMAXDEPTH], *yys = yy_yys;
YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv;
#else	/* user does initial allocation */
int *yys;
YYSTYPE *yyv;
#endif
static int yymaxdepth = YYMAXDEPTH;
# define YYERRCODE 256

# line 2180 "../itm_comp.y"

static YYCONST yytabelem yyexca[] ={
-1, 1,
	0, -1,
	-2, 0,
	};
# define YYNPROD 116
# define YYLAST 1087
static YYCONST yytabelem yyact[]={

    19,   160,    48,    49,   112,   113,   114,    82,   131,    78,
    76,    75,    69,   132,    54,    87,    58,    52,    68,    79,
    77,    51,    84,    85,    86,    80,   133,    83,    53,   115,
   116,   110,   111,   112,   113,   114,   213,   204,   183,   247,
    67,    66,    46,   221,    73,   110,   111,   112,   113,   114,
   220,   219,   218,   182,    19,   180,    48,    49,   179,   178,
   177,    82,    57,    78,    76,    75,    55,    56,    54,    87,
    58,    52,   176,    79,    77,    51,    84,    85,    86,    80,
   175,    83,    53,   167,   166,   105,    33,    16,   171,    63,
   132,    64,   184,   242,   240,   138,    46,    89,    73,    88,
    70,    65,    63,    63,    64,    64,    19,    63,    19,    64,
    48,    49,    40,    19,    11,    82,    57,    78,    76,    75,
    55,    56,    54,    87,    58,    52,   234,    79,    77,    51,
    84,    85,    86,    80,    39,    83,    53,    11,    10,   212,
   209,    27,    28,    87,   139,   174,    27,   229,    13,    59,
    46,    21,    73,    34,    12,     3,    19,    28,   243,   235,
   144,    19,    19,   145,    48,    49,   245,    19,    14,    82,
    57,    78,    76,    75,    55,    56,    54,    87,    58,    52,
    31,    79,    77,    51,    84,    85,    86,    80,    19,    83,
    53,    27,    28,    32,    18,    19,    63,    10,    64,    23,
   236,   228,   151,   129,    46,    30,    73,    13,   163,   231,
   108,   141,   211,    12,    19,    19,    19,     2,    48,    49,
   143,   164,    11,    82,    57,    78,    76,    75,    55,    56,
    54,    87,    58,    52,   150,    79,    77,    51,    84,    85,
    86,    80,    39,    83,    53,    25,   142,    41,    19,   107,
    11,    10,   128,    91,    26,   214,    11,    50,    46,    81,
    73,    13,    93,     5,    35,   149,   127,    12,    15,   106,
    19,     4,    48,    49,     1,     0,    39,    82,    57,    78,
    76,    75,    55,    56,    54,    87,    58,    52,   102,    79,
    77,    51,    84,    85,    86,    80,    24,    83,    53,    90,
    97,    98,   100,     0,     9,     9,    96,     0,    42,   153,
     8,     8,    46,   148,    73,     0,     0,     0,    37,    60,
     0,   147,     7,     7,    19,    95,    48,    49,     0,     6,
     6,    82,    57,    78,    76,    75,    55,    56,    54,    87,
    58,    52,     0,    79,    77,    51,    84,    85,    86,    80,
   104,    83,    53,   109,   120,   123,   124,   121,   122,   115,
   116,   110,   111,   112,   113,   114,    46,   185,    73,   126,
   117,   118,   119,   109,   120,   123,   124,   121,   122,   115,
   116,   110,   111,   112,   113,   114,    57,   239,     0,     0,
    55,    56,   125,   126,   117,   118,   119,   109,   120,   123,
   124,   121,   122,   115,   116,   110,   111,   112,   113,   114,
   238,   104,     0,     0,   125,   126,   117,   118,   119,   109,
   120,   123,   124,   121,   122,   115,   116,   110,   111,   112,
   113,   114,   237,   230,     0,     0,   125,   126,   117,   118,
   119,   109,   120,   123,   124,   121,   122,   115,   116,   110,
   111,   112,   113,   114,   233,     0,     0,   232,     0,     0,
     0,   125,   126,   117,   118,   119,   109,   120,   123,   124,
   121,   122,   115,   116,   110,   111,   112,   113,   114,   226,
     0,     0,     0,   125,   126,   117,   118,   119,   109,   120,
   123,   124,   121,   122,   115,   116,   110,   111,   112,   113,
   114,   225,     0,   244,     0,   125,   126,   117,   118,   119,
   109,   120,   123,   124,   121,   122,   115,   116,   110,   111,
   112,   113,   114,   224,     0,     0,     0,   125,   126,   117,
   118,   119,   109,   120,   123,   124,   121,   122,   115,   116,
   110,   111,   112,   113,   114,   216,     0,     0,     0,   125,
   126,   117,   118,   119,   109,   120,   123,   124,   121,   122,
   115,   116,   110,   111,   112,   113,   114,   215,     0,     0,
     0,   125,   126,   117,   118,   119,   109,   120,   123,   124,
   121,   122,   115,   116,   110,   111,   112,   113,   114,   205,
     0,     0,     0,     0,   125,   126,   117,   118,   119,   109,
   120,   123,   124,   121,   122,   115,   116,   110,   111,   112,
   113,   114,   155,     0,     0,    71,   125,   126,   117,   118,
   119,   109,   120,   123,   124,   121,   122,   115,   116,   110,
   111,   112,   113,   114,   125,   126,   117,   118,   119,   109,
   120,   123,   124,   121,   122,   115,   116,   110,   111,   112,
   113,   114,    19,     0,    48,    49,     0,     0,    43,    36,
     0,    19,     0,    48,    49,     0,    54,    43,    58,    52,
     0,     0,     0,    51,     0,    54,     0,    58,    52,     0,
    53,    45,    51,     0,     0,    72,   152,     0,     0,    53,
    45,   181,     0,     0,    46,    92,     0,     0,    61,     0,
   103,     0,     0,    46,   172,   173,    62,     0,     0,     0,
     0,     0,     0,     0,    57,     0,     0,     0,    55,    56,
     0,     0,     0,    57,     0,     0,     0,    55,    56,   117,
   118,   119,   109,   120,   123,   124,   121,   122,   115,   116,
   110,   111,   112,   113,   114,    19,     0,    48,    49,     0,
    92,    43,     0,     0,     0,     0,     0,   154,   137,    54,
     0,    58,    52,     0,   146,     0,    51,     0,   140,     0,
     0,     0,     0,    53,    45,   123,   124,   121,   122,   115,
   116,   110,   111,   112,   113,   114,     0,    46,   118,   119,
   109,   120,   123,   124,   121,   122,   115,   116,   110,   111,
   112,   113,   114,    19,     0,    48,    49,    57,     0,     0,
     0,    55,    56,    19,     0,    48,    49,    54,     0,    58,
    52,     0,     0,     0,    51,     0,     0,    54,     0,    58,
    52,    53,     0,     0,    51,     0,     0,   210,   154,     0,
     0,    53,     0,     0,   140,    46,    19,   222,    48,    49,
     0,     0,     0,   140,     0,    46,   241,   158,   154,   154,
    54,   246,    58,    52,     0,    57,     0,    51,     0,    55,
    56,     0,     0,     0,    53,    57,     0,     0,     0,    55,
    56,     0,     0,     0,     0,     0,     0,     0,    46,     0,
   156,   119,   109,   120,   123,   124,   121,   122,   115,   116,
   110,   111,   112,   113,   114,     0,     0,    19,    57,    48,
    49,     0,    55,    56,    74,     0,     0,   140,     0,     0,
     0,    54,     0,    58,    52,     0,     0,   154,    51,     0,
     0,     0,   154,     0,     0,    53,    44,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,    46,
     0,     0,     0,     0,     0,    44,    44,     0,     0,     0,
     0,   130,     0,     0,     0,     0,     0,     0,     0,    57,
   134,   135,   136,    55,    56,    47,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,    17,    20,    22,    29,
   157,   159,     0,     0,    38,     0,     0,     0,     0,   168,
   169,   170,     0,     0,     0,     0,     0,     0,     0,     0,
    38,    38,     0,    94,    99,   101,     0,    44,     0,     0,
     0,     0,     0,     0,   186,   187,   188,   189,   190,   191,
   192,   193,   194,   195,   196,   197,   198,   199,   200,   201,
   202,   203,     0,     0,     0,     0,   206,   207,   208,     0,
     0,     0,     0,     0,   161,   162,   165,     0,     0,     0,
     0,     0,     0,     0,     0,     0,    38,     0,     0,     0,
     0,     0,     0,     0,     0,   217,     0,     0,     0,     0,
   223,     0,     0,     0,     0,     0,   227 };
static YYCONST yytabelem yypact[]={

   -40,-10000000,  -141,   -16,  -129,  -215,-10000000,-10000000,-10000000,-10000000,
  -102,  -145,   -97,   -91,-10000000,  -216,-10000000,  -143,   -10,-10000000,
  -184,   487,  -147,   -64,  -195,  -262,  -263,  -287,  -293,  -196,
    66,  -197,  -199,-10000000,   -10,   -44,-10000000,   -70,   -70,   -70,
   487,   403,  -217,   -50,   328,   -57,   649,  -297,-10000000,-10000000,
  -285,-10000000,-10000000,-10000000,-10000000,   649,   649,   649,-10000000,   -64,
  -201,  -153,-10000000,   -49,  -100,   -64,  -132,  -142,   -25,   -59,
    66,    12,-10000000,-10000000,   310,   588,   555,  -304,   -43,   -63,
   -43,-10000000,  -218,  -219,   649,   649,   649,  -212,    66,    66,
  -152,-10000000,-10000000,  -222,  -230,-10000000,-10000000,-10000000,  -242,  -243,
  -244,  -247,   394,-10000000,  -249,-10000000,  -265,-10000000,  -203,   649,
   649,   649,   649,   649,   649,   649,   649,   649,   649,   649,
   649,   649,   649,   649,   649,   649,   649,  -266,-10000000,-10000000,
   288,   649,   649,   649,-10000000,-10000000,-10000000,  -157,   -64,-10000000,
-10000000,-10000000,   -48,-10000000,-10000000,-10000000,  -158,-10000000,-10000000,  -268,
-10000000,-10000000,   -42,-10000000,-10000000,-10000000,-10000000,   265,-10000000,   243,
   649,  -250,  -251,  -252,  -259,   545,-10000000,-10000000,   221,   199,
   177,   649,   -96,  -150,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
-10000000,-10000000,-10000000,   -50,   -51,  -208,   462,  -317,  -317,-10000000,
-10000000,-10000000,  -274,  -274,   479,   581,    42,   462,  -288,  -288,
  -288,  -288,    62,   421,   -57,-10000000,   328,   155,   462,-10000000,
  -171,  -101,-10000000,   -61,-10000000,-10000000,-10000000,   130,-10000000,-10000000,
-10000000,-10000000,-10000000,   108,-10000000,-10000000,-10000000,    86,-10000000,-10000000,
-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,  -202,
    66,  -204,  -112,  -130,-10000000,    66,  -258,-10000000 };
static YYCONST yytabelem yypgo[]={

     0,   274,   271,   263,   325,   264,   659,   262,   318,   247,
   308,   269,   249,   266,   252,   306,   698,   706,   296,   254,
   245,   265,   300,   615,   685,   259,   975,   914,   257 };
static YYCONST yytabelem yyr1[]={

     0,     1,     2,     2,     3,     3,     3,     3,     4,     4,
     5,     5,     6,     6,     6,     6,     6,     6,     7,     7,
     7,     8,     8,     9,     9,    10,    10,    10,    11,    11,
    12,    13,    13,    14,    15,    15,    15,    15,    18,    18,
    18,    18,    20,    20,    21,    19,    16,    16,    17,    17,
    17,    17,    17,    22,    22,    22,    22,    23,    23,    24,
    24,    24,    24,    24,    24,    24,    24,    24,    24,    24,
    24,    24,    24,    24,    24,    24,    24,    24,    25,    25,
    25,    26,    28,    27,    27,    27,    27,    27,    27,    27,
    27,    27,    27,    27,    27,    27,    27,    27,    27,    27,
    27,    27,    27,    27,    27,    27,    27,    27,    27,    27,
    27,    27,    27,    27,    27,    27 };
static YYCONST yytabelem yyr2[]={

     0,     9,     5,     7,     3,     3,     3,     3,    11,     9,
     3,     5,     7,     7,     7,     7,     7,     7,     3,     3,
     3,    11,     9,     5,     7,     5,     3,     5,     3,     7,
     7,     3,     7,     3,    11,     9,    13,    11,     7,     3,
     7,     3,    11,     7,     3,     7,     3,     5,     5,     9,
     5,     5,     5,    11,     9,    11,    11,     3,     5,     3,
     5,     5,     7,     5,     7,     9,     7,     7,     7,     7,
     7,     9,     3,     5,     5,     7,     7,     7,    15,    19,
    23,     3,     3,     7,     3,     3,     3,     9,     3,     3,
     3,     3,     7,     7,     5,     5,     5,     7,     7,     7,
     7,     7,     7,     7,     7,     7,     7,     7,     7,     7,
     7,     7,     7,     7,     7,     7 };
static YYCONST yytabelem yychk[]={

-10000000,    -1,   257,   296,    -2,    -3,    -4,    -8,   -15,   -22,
   267,   266,   283,   277,   297,    -3,   302,   -26,   296,   258,
   -26,   296,   -26,   296,   -18,   -20,   -19,   288,   289,   -26,
   296,   271,   284,   302,   296,    -5,    -6,    -8,   -26,   286,
   296,    -9,   -10,   264,   -27,   287,   300,   -26,   260,   261,
   -28,   279,   275,   286,   272,   324,   325,   320,   274,   296,
   -18,   -16,   -17,   260,   262,   296,   303,   303,   305,   305,
   296,   -23,   -24,   302,   -27,   269,   268,   278,   267,   277,
   283,   -25,   265,   285,   280,   281,   282,   273,   296,   296,
    -5,   297,    -6,    -7,   -26,    -4,   -15,   -22,    -7,   -26,
    -7,   -26,    -9,   297,   -10,   302,   -11,   -12,   260,   311,
   319,   320,   321,   322,   323,   317,   318,   308,   309,   310,
   312,   315,   316,   313,   314,   306,   307,   -13,   -14,   260,
   -27,   305,   298,   311,   -27,   -27,   -27,   -16,   296,   297,
   -17,   260,   295,   269,   260,   263,   -16,   -19,   -20,   -21,
   259,   261,   -23,   297,   -24,   302,   302,   -27,   302,   -27,
   305,   -26,   -26,   271,   284,   -26,   302,   302,   -27,   -27,
   -27,   300,   -23,   -23,   297,   302,   302,   302,   302,   302,
   302,   297,   302,   303,   295,   -28,   -27,   -27,   -27,   -27,
   -27,   -27,   -27,   -27,   -27,   -27,   -27,   -27,   -27,   -27,
   -27,   -27,   -27,   -27,   303,   301,   -27,   -27,   -27,   297,
   -16,   260,   297,   304,   297,   302,   302,   -27,   302,   302,
   302,   302,   302,   -27,   302,   302,   302,   -27,   297,   297,
   -12,   260,   -14,   299,   297,   260,   261,   302,   302,   301,
   296,   -23,   297,   270,   -25,   296,   -23,   297 };
static YYCONST yytabelem yydef[]={

     0,    -2,     0,     0,     0,     0,     4,     5,     6,     7,
     0,     0,     0,     0,     1,     0,     2,     0,     0,    81,
     0,     0,     0,     0,     0,    39,    41,     0,     0,     0,
     0,     0,     0,     3,     0,     0,    10,     0,     0,     0,
     0,     0,     0,     0,    26,     0,     0,    84,    85,    86,
     0,    88,    89,    90,    91,     0,     0,     0,    82,     0,
     0,     0,    46,     0,     0,     0,     0,     0,     0,     0,
     0,     0,    57,    59,     0,     0,     0,     0,     0,     0,
     0,    72,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     9,    11,     0,     0,    18,    19,    20,     0,     0,
     0,     0,     0,    22,     0,    23,    25,    28,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,    27,    31,    33,
     0,     0,     0,     0,    94,    95,    96,     0,     0,    35,
    47,    48,     0,    52,    50,    51,     0,    38,    40,    43,
    44,    45,     0,    54,    58,    60,    61,     0,    63,     0,
     0,     0,     0,     0,     0,     0,    73,    74,     0,     0,
     0,     0,     0,     0,     8,    12,    13,    14,    15,    16,
    17,    21,    24,     0,     0,    93,   107,    97,    98,    99,
   100,   101,   102,   103,   104,   105,   106,   108,   109,   110,
   111,   112,   114,   115,     0,    83,   113,     0,    92,    34,
     0,     0,    37,     0,    53,    62,    64,     0,    66,    67,
    68,    69,    70,     0,    75,    76,    77,     0,    55,    56,
    29,    30,    32,    87,    36,    49,    42,    65,    71,     0,
     0,     0,    78,     0,    79,     0,     0,    80 };
typedef struct
#ifdef __cplusplus
	yytoktype
#endif
{
#ifdef __cplusplus
const
#endif
char *t_name; int t_val; } yytoktype;
#ifndef YYDEBUG
#	define YYDEBUG	0	/* don't allow debugging */
#endif

#if YYDEBUG

yytoktype yytoks[] =
{
	"ITMNAME",	257,
	"NAME",	258,
	"MAPTYPE_NAME",	259,
	"HEXADECIMAL",	260,
	"DECIMAL",	261,
	"ITM_DEFAULT",	262,
	"ITM_IDENTICAL",	263,
	"BETWEEN",	264,
	"BREAK",	265,
	"CONDITION",	266,
	"DIRECTION",	267,
	"DISCARD",	268,
	"ERROR",	269,
	"ITM_ELSE",	270,
	"ITM_INIT",	271,
	"ITM_FALSE",	272,
	"ITM_IF",	273,
	"ITM_IN",	274,
	"ITM_INSIZE",	275,
	"NOP",	276,
	"OPERATION",	277,
	"ITM_OUT",	278,
	"ITM_OUTSIZE",	279,
	"PRINTCHR",	280,
	"PRINTHD",	281,
	"PRINTINT",	282,
	"MAP",	283,
	"RESET",	284,
	"RETURN",	285,
	"ITM_TRUE",	286,
	"ESCAPESEQ",	287,
	"MAPTYPE",	288,
	"RESULTLEN",	289,
	"MAPTYPE_AUTO",	290,
	"MAPTYPE_INDEX",	291,
	"MAPTYPE_DENSE",	292,
	"MAPTYPE_HASH",	293,
	"MAPTYPE_BINARY",	294,
	"ELLIPSES",	295,
	"CBO",	296,
	"CBC",	297,
	"SBO",	298,
	"SBC",	299,
	"PO",	300,
	"PC",	301,
	"SC",	302,
	"COMMA",	303,
	"COLON",	304,
	"ASSIGN",	305,
	"LOR",	306,
	"LAND",	307,
	"OR",	308,
	"XOR",	309,
	"AND",	310,
	"EQ",	311,
	"NE",	312,
	"LT",	313,
	"LE",	314,
	"GT",	315,
	"GE",	316,
	"SHL",	317,
	"SHR",	318,
	"PLUS",	319,
	"MINUS",	320,
	"MUL",	321,
	"DIV",	322,
	"MOD",	323,
	"NOT",	324,
	"NEG",	325,
	"UMINUS",	326,
	"-unknown-",	-1	/* ends search */
};

#ifdef __cplusplus
const
#endif
char * yyreds[] =
{
	"-no such reduction-",
	"itm_def : ITMNAME CBO def_element_list CBC",
	"def_element_list : def_element SC",
	"def_element_list : def_element_list def_element SC",
	"def_element : direction",
	"def_element : condition",
	"def_element : map",
	"def_element : operation",
	"direction : DIRECTION name CBO direction_unit_list CBC",
	"direction : DIRECTION CBO direction_unit_list CBC",
	"direction_unit_list : direction_unit",
	"direction_unit_list : direction_unit_list direction_unit",
	"direction_unit : condition action SC",
	"direction_unit : condition name SC",
	"direction_unit : name action SC",
	"direction_unit : name name SC",
	"direction_unit : ITM_TRUE action SC",
	"direction_unit : ITM_TRUE name SC",
	"action : direction",
	"action : map",
	"action : operation",
	"condition : CONDITION name CBO condition_list CBC",
	"condition : CONDITION CBO condition_list CBC",
	"condition_list : condition_expr SC",
	"condition_list : condition_list condition_expr SC",
	"condition_expr : BETWEEN range_list",
	"condition_expr : expr",
	"condition_expr : ESCAPESEQ escseq_list",
	"range_list : range_pair",
	"range_list : range_list COMMA range_pair",
	"range_pair : HEXADECIMAL ELLIPSES HEXADECIMAL",
	"escseq_list : escseq",
	"escseq_list : escseq_list COMMA escseq",
	"escseq : HEXADECIMAL",
	"map : MAP name CBO map_list CBC",
	"map : MAP CBO map_list CBC",
	"map : MAP name map_attribute CBO map_list CBC",
	"map : MAP map_attribute CBO map_list CBC",
	"map_attribute : map_type COMMA map_resultlen",
	"map_attribute : map_type",
	"map_attribute : map_resultlen COMMA map_type",
	"map_attribute : map_resultlen",
	"map_type : MAPTYPE ASSIGN map_type_names COLON DECIMAL",
	"map_type : MAPTYPE ASSIGN map_type_names",
	"map_type_names : MAPTYPE_NAME",
	"map_resultlen : RESULTLEN ASSIGN DECIMAL",
	"map_list : map_pair",
	"map_list : map_list map_pair",
	"map_pair : HEXADECIMAL HEXADECIMAL",
	"map_pair : HEXADECIMAL ELLIPSES HEXADECIMAL HEXADECIMAL",
	"map_pair : ITM_DEFAULT HEXADECIMAL",
	"map_pair : ITM_DEFAULT ITM_IDENTICAL",
	"map_pair : HEXADECIMAL ERROR",
	"operation : OPERATION name CBO op_list CBC",
	"operation : OPERATION CBO op_list CBC",
	"operation : OPERATION ITM_INIT CBO op_list CBC",
	"operation : OPERATION RESET CBO op_list CBC",
	"op_list : op_unit",
	"op_list : op_list op_unit",
	"op_unit : SC",
	"op_unit : expr SC",
	"op_unit : ERROR SC",
	"op_unit : ERROR expr SC",
	"op_unit : DISCARD SC",
	"op_unit : DISCARD expr SC",
	"op_unit : ITM_OUT ASSIGN expr SC",
	"op_unit : DIRECTION name SC",
	"op_unit : OPERATION name SC",
	"op_unit : OPERATION ITM_INIT SC",
	"op_unit : OPERATION RESET SC",
	"op_unit : MAP name SC",
	"op_unit : MAP name expr SC",
	"op_unit : op_if_else",
	"op_unit : BREAK SC",
	"op_unit : RETURN SC",
	"op_unit : PRINTCHR expr SC",
	"op_unit : PRINTHD expr SC",
	"op_unit : PRINTINT expr SC",
	"op_if_else : ITM_IF PO expr PC CBO op_list CBC",
	"op_if_else : ITM_IF PO expr PC CBO op_list CBC ITM_ELSE op_if_else",
	"op_if_else : ITM_IF PO expr PC CBO op_list CBC ITM_ELSE CBO op_list CBC",
	"name : NAME",
	"itm_in : ITM_IN",
	"expr : PO expr PC",
	"expr : name",
	"expr : HEXADECIMAL",
	"expr : DECIMAL",
	"expr : itm_in SBO expr SBC",
	"expr : ITM_OUTSIZE",
	"expr : ITM_INSIZE",
	"expr : ITM_TRUE",
	"expr : ITM_FALSE",
	"expr : itm_in EQ expr",
	"expr : expr EQ itm_in",
	"expr : NOT expr",
	"expr : NEG expr",
	"expr : MINUS expr",
	"expr : expr PLUS expr",
	"expr : expr MINUS expr",
	"expr : expr MUL expr",
	"expr : expr DIV expr",
	"expr : expr MOD expr",
	"expr : expr SHL expr",
	"expr : expr SHR expr",
	"expr : expr OR expr",
	"expr : expr XOR expr",
	"expr : expr AND expr",
	"expr : expr EQ expr",
	"expr : expr NE expr",
	"expr : expr GT expr",
	"expr : expr GE expr",
	"expr : expr LT expr",
	"expr : expr LE expr",
	"expr : name ASSIGN expr",
	"expr : expr LOR expr",
	"expr : expr LAND expr",
};
#endif /* YYDEBUG */
# line	1 "/usr/share/lib/ccs/yaccpar"
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 1993 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* Copyright (c) 1988 AT&T */
/* All Rights Reserved */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*
** Skeleton parser driver for yacc output
*/

/*
** yacc user known macros and defines
*/
#define YYERROR		goto yyerrlab
#define YYACCEPT	return(0)
#define YYABORT		return(1)
#define YYBACKUP( newtoken, newvalue )\
{\
	if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
	{\
		yyerror( "syntax error - cannot backup" );\
		goto yyerrlab;\
	}\
	yychar = newtoken;\
	yystate = *yyps;\
	yylval = newvalue;\
	goto yynewstate;\
}
#define YYRECOVERING()	(!!yyerrflag)
#define YYNEW(type)	malloc(sizeof(type) * yynewmax)
#define YYCOPY(to, from, type) \
	(type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type))
#define YYENLARGE( from, type) \
	(type *) realloc((char *) from, yynewmax * sizeof(type))
#ifndef YYDEBUG
#	define YYDEBUG	1	/* make debugging available */
#endif

/*
** user known globals
*/
int yydebug;			/* set to 1 to get debugging */

/*
** driver internal defines
*/
#define YYFLAG		(-10000000)

/*
** global variables used by the parser
*/
YYSTYPE *yypv;			/* top of value stack */
int *yyps;			/* top of state stack */

int yystate;			/* current state */
int yytmp;			/* extra var (lasts between blocks) */

int yynerrs;			/* number of errors */
int yyerrflag;			/* error recovery flag */
int yychar;			/* current input token number */



#ifdef YYNMBCHARS
#define YYLEX()		yycvtok(yylex())
/*
** yycvtok - return a token if i is a wchar_t value that exceeds 255.
**	If i<255, i itself is the token.  If i>255 but the neither 
**	of the 30th or 31st bit is on, i is already a token.
*/
#if defined(__STDC__) || defined(__cplusplus)
int yycvtok(int i)
#else
int yycvtok(i) int i;
#endif
{
	int first = 0;
	int last = YYNMBCHARS - 1;
	int mid;
	wchar_t j;

	if(i&0x60000000){/*Must convert to a token. */
		if( yymbchars[last].character < i ){
			return i;/*Giving up*/
		}
		while ((last>=first)&&(first>=0)) {/*Binary search loop*/
			mid = (first+last)/2;
			j = yymbchars[mid].character;
			if( j==i ){/*Found*/ 
				return yymbchars[mid].tvalue;
			}else if( j<i ){
				first = mid + 1;
			}else{
				last = mid -1;
			}
		}
		/*No entry in the table.*/
		return i;/* Giving up.*/
	}else{/* i is already a token. */
		return i;
	}
}
#else/*!YYNMBCHARS*/
#define YYLEX()		yylex()
#endif/*!YYNMBCHARS*/

/*
** yyparse - return 0 if worked, 1 if syntax error not recovered from
*/
#if defined(__STDC__) || defined(__cplusplus)
int yyparse(void)
#else
int yyparse()
#endif
{
	register YYSTYPE *yypvt = 0;	/* top of value stack for $vars */

#if defined(__cplusplus) || defined(lint)
/*
	hacks to please C++ and lint - goto's inside
	switch should never be executed
*/
	static int __yaccpar_lint_hack__ = 0;
	switch (__yaccpar_lint_hack__)
	{
		case 1: goto yyerrlab;
		case 2: goto yynewstate;
	}
#endif

	/*
	** Initialize externals - yyparse may be called more than once
	*/
	yypv = &yyv[-1];
	yyps = &yys[-1];
	yystate = 0;
	yytmp = 0;
	yynerrs = 0;
	yyerrflag = 0;
	yychar = -1;

#if YYMAXDEPTH <= 0
	if (yymaxdepth <= 0)
	{
		if ((yymaxdepth = YYEXPAND(0)) <= 0)
		{
			yyerror("yacc initialization error");
			YYABORT;
		}
	}
#endif

	{
		register YYSTYPE *yy_pv;	/* top of value stack */
		register int *yy_ps;		/* top of state stack */
		register int yy_state;		/* current state */
		register int  yy_n;		/* internal state number info */
	goto yystack;	/* moved from 6 lines above to here to please C++ */

		/*
		** get globals into registers.
		** branch to here only if YYBACKUP was called.
		*/
	yynewstate:
		yy_pv = yypv;
		yy_ps = yyps;
		yy_state = yystate;
		goto yy_newstate;

		/*
		** get globals into registers.
		** either we just started, or we just finished a reduction
		*/
	yystack:
		yy_pv = yypv;
		yy_ps = yyps;
		yy_state = yystate;

		/*
		** top of for (;;) loop while no reductions done
		*/
	yy_stack:
		/*
		** put a state and value onto the stacks
		*/
#if YYDEBUG
		/*
		** if debugging, look up token value in list of value vs.
		** name pairs.  0 and negative (-1) are special values.
		** Note: linear search is used since time is not a real
		** consideration while debugging.
		*/
		if ( yydebug )
		{
			register int yy_i;

			printf( "State %d, token ", yy_state );
			if ( yychar == 0 )
				printf( "end-of-file\n" );
			else if ( yychar < 0 )
				printf( "-none-\n" );
			else
			{
				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
					yy_i++ )
				{
					if ( yytoks[yy_i].t_val == yychar )
						break;
				}
				printf( "%s\n", yytoks[yy_i].t_name );
			}
		}
#endif /* YYDEBUG */
		if ( ++yy_ps >= &yys[ yymaxdepth ] )	/* room on stack? */
		{
			/*
			** reallocate and recover.  Note that pointers
			** have to be reset, or bad things will happen
			*/
			long yyps_index = (yy_ps - yys);
			long yypv_index = (yy_pv - yyv);
			long yypvt_index = (yypvt - yyv);
			int yynewmax;
#ifdef YYEXPAND
			yynewmax = YYEXPAND(yymaxdepth);
#else
			yynewmax = 2 * yymaxdepth;	/* double table size */
			if (yymaxdepth == YYMAXDEPTH)	/* first time growth */
			{
				char *newyys = (char *)YYNEW(int);
				char *newyyv = (char *)YYNEW(YYSTYPE);
				if (newyys != 0 && newyyv != 0)
				{
					yys = YYCOPY(newyys, yys, int);
					yyv = YYCOPY(newyyv, yyv, YYSTYPE);
				}
				else
					yynewmax = 0;	/* failed */
			}
			else				/* not first time */
			{
				yys = YYENLARGE(yys, int);
				yyv = YYENLARGE(yyv, YYSTYPE);
				if (yys == 0 || yyv == 0)
					yynewmax = 0;	/* failed */
			}
#endif
			if (yynewmax <= yymaxdepth)	/* tables not expanded */
			{
				yyerror( "yacc stack overflow" );
				YYABORT;
			}
			yymaxdepth = yynewmax;

			yy_ps = yys + yyps_index;
			yy_pv = yyv + yypv_index;
			yypvt = yyv + yypvt_index;
		}
		*yy_ps = yy_state;
		*++yy_pv = yyval;

		/*
		** we have a new state - find out what to do
		*/
	yy_newstate:
		if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
			goto yydefault;		/* simple state */
#if YYDEBUG
		/*
		** if debugging, need to mark whether new token grabbed
		*/
		yytmp = yychar < 0;
#endif
		if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) )
			yychar = 0;		/* reached EOF */
#if YYDEBUG
		if ( yydebug && yytmp )
		{
			register int yy_i;

			printf( "Received token " );
			if ( yychar == 0 )
				printf( "end-of-file\n" );
			else if ( yychar < 0 )
				printf( "-none-\n" );
			else
			{
				for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
					yy_i++ )
				{
					if ( yytoks[yy_i].t_val == yychar )
						break;
				}
				printf( "%s\n", yytoks[yy_i].t_name );
			}
		}
#endif /* YYDEBUG */
		if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
			goto yydefault;
		if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )	/*valid shift*/
		{
			yychar = -1;
			yyval = yylval;
			yy_state = yy_n;
			if ( yyerrflag > 0 )
				yyerrflag--;
			goto yy_stack;
		}

	yydefault:
		if ( ( yy_n = yydef[ yy_state ] ) == -2 )
		{
#if YYDEBUG
			yytmp = yychar < 0;
#endif
			if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) )
				yychar = 0;		/* reached EOF */
#if YYDEBUG
			if ( yydebug && yytmp )
			{
				register int yy_i;

				printf( "Received token " );
				if ( yychar == 0 )
					printf( "end-of-file\n" );
				else if ( yychar < 0 )
					printf( "-none-\n" );
				else
				{
					for ( yy_i = 0;
						yytoks[yy_i].t_val >= 0;
						yy_i++ )
					{
						if ( yytoks[yy_i].t_val
							== yychar )
						{
							break;
						}
					}
					printf( "%s\n", yytoks[yy_i].t_name );
				}
			}
#endif /* YYDEBUG */
			/*
			** look through exception table
			*/
			{
				register YYCONST int *yyxi = yyexca;

				while ( ( *yyxi != -1 ) ||
					( yyxi[1] != yy_state ) )
				{
					yyxi += 2;
				}
				while ( ( *(yyxi += 2) >= 0 ) &&
					( *yyxi != yychar ) )
					;
				if ( ( yy_n = yyxi[1] ) < 0 )
					YYACCEPT;
			}
		}

		/*
		** check for syntax error
		*/
		if ( yy_n == 0 )	/* have an error */
		{
			/* no worry about speed here! */
			switch ( yyerrflag )
			{
			case 0:		/* new error */
				yyerror( "syntax error" );
				goto skip_init;
			yyerrlab:
				/*
				** get globals into registers.
				** we have a user generated syntax type error
				*/
				yy_pv = yypv;
				yy_ps = yyps;
				yy_state = yystate;
			skip_init:
				yynerrs++;
				/* FALLTHRU */
			case 1:
			case 2:		/* incompletely recovered error */
					/* try again... */
				yyerrflag = 3;
				/*
				** find state where "error" is a legal
				** shift action
				*/
				while ( yy_ps >= yys )
				{
					yy_n = yypact[ *yy_ps ] + YYERRCODE;
					if ( yy_n >= 0 && yy_n < YYLAST &&
						yychk[yyact[yy_n]] == YYERRCODE)					{
						/*
						** simulate shift of "error"
						*/
						yy_state = yyact[ yy_n ];
						goto yy_stack;
					}
					/*
					** current state has no shift on
					** "error", pop stack
					*/
#if YYDEBUG
#	define _POP_ "Error recovery pops state %d, uncovers state %d\n"
					if ( yydebug )
						printf( _POP_, *yy_ps,
							yy_ps[-1] );
#	undef _POP_
#endif
					yy_ps--;
					yy_pv--;
				}
				/*
				** there is no state on stack with "error" as
				** a valid shift.  give up.
				*/
				YYABORT;
			case 3:		/* no shift yet; eat a token */
#if YYDEBUG
				/*
				** if debugging, look up token in list of
				** pairs.  0 and negative shouldn't occur,
				** but since timing doesn't matter when
				** debugging, it doesn't hurt to leave the
				** tests here.
				*/
				if ( yydebug )
				{
					register int yy_i;

					printf( "Error recovery discards " );
					if ( yychar == 0 )
						printf( "token end-of-file\n" );
					else if ( yychar < 0 )
						printf( "token -none-\n" );
					else
					{
						for ( yy_i = 0;
							yytoks[yy_i].t_val >= 0;
							yy_i++ )
						{
							if ( yytoks[yy_i].t_val
								== yychar )
							{
								break;
							}
						}
						printf( "token %s\n",
							yytoks[yy_i].t_name );
					}
				}
#endif /* YYDEBUG */
				if ( yychar == 0 )	/* reached EOF. quit */
					YYABORT;
				yychar = -1;
				goto yy_newstate;
			}
		}/* end if ( yy_n == 0 ) */
		/*
		** reduction by production yy_n
		** put stack tops, etc. so things right after switch
		*/
#if YYDEBUG
		/*
		** if debugging, print the string that is the user's
		** specification of the reduction which is just about
		** to be done.
		*/
		if ( yydebug )
			printf( "Reduce by (%d) \"%s\"\n",
				yy_n, yyreds[ yy_n ] );
#endif
		yytmp = yy_n;			/* value to switch over */
		yypvt = yy_pv;			/* $vars top of value stack */
		/*
		** Look in goto table for next state
		** Sorry about using yy_state here as temporary
		** register variable, but why not, if it works...
		** If yyr2[ yy_n ] doesn't have the low order bit
		** set, then there is no action to be done for
		** this reduction.  So, no saving & unsaving of
		** registers done.  The only difference between the
		** code just after the if and the body of the if is
		** the goto yy_stack in the body.  This way the test
		** can be made before the choice of what to do is needed.
		*/
		{
			/* length of production doubled with extra bit */
			register int yy_len = yyr2[ yy_n ];

			if ( !( yy_len & 01 ) )
			{
				yy_len >>= 1;
				yyval = ( yy_pv -= yy_len )[1];	/* $$ = $1 */
				yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
					*( yy_ps -= yy_len ) + 1;
				if ( yy_state >= YYLAST ||
					yychk[ yy_state =
					yyact[ yy_state ] ] != -yy_n )
				{
					yy_state = yyact[ yypgo[ yy_n ] ];
				}
				goto yy_stack;
			}
			yy_len >>= 1;
			yyval = ( yy_pv -= yy_len )[1];	/* $$ = $1 */
			yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
				*( yy_ps -= yy_len ) + 1;
			if ( yy_state >= YYLAST ||
				yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
			{
				yy_state = yyact[ yypgo[ yy_n ] ];
			}
		}
					/* save until reenter driver code */
		yystate = yy_state;
		yyps = yy_ps;
		yypv = yy_pv;
	}
	/*
	** code supplied by user is placed in this switch
	*/
	switch( yytmp )
	{
		
case 1:
# line 168 "../itm_comp.y"
{
		itm_def_process(yypvt[-3].name);
	} break;
case 2:
# line 175 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("def_element_list: def_element ;\n"));
		yyval.obj = NULL;
	} break;
case 3:
# line 180 "../itm_comp.y"
{
		TRACE_MESSAGE('y',
			("def_element_list: def_element_list def_element ;\n"));
		yyval.obj = NULL;
	} break;
case 4:
# line 189 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("def_element: direction\n"));
		(void) obj_register(ITMC_OBJ_DIREC, (itm_data_t *)(yypvt[-0].tbl_hdr->name.itm_ptr),
			yypvt[-0].tbl_hdr, yypvt[-0].tbl_hdr->size,
			NULL, OBJ_REG_TAIL);
		yyval.tbl_hdr = yypvt[-0].tbl_hdr;
	} break;
case 5:
# line 197 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("def_element: condition\n"));
		yyval.tbl_hdr = (itm_tbl_hdr_t *)(yypvt[-0].itmc_ref->referencee);
	} break;
case 6:
# line 202 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("def_element: map\n"));
		if (NULL != yypvt[-0].tbl_hdr) {
			(void) obj_register(ITMC_OBJ_MAP,
				(itm_data_t *)(yypvt[-0].tbl_hdr->name.itm_ptr),
				yypvt[-0].tbl_hdr, yypvt[-0].tbl_hdr->size,
				NULL, OBJ_REG_TAIL);
	}
		yyval.tbl_hdr = yypvt[-0].tbl_hdr;
	} break;
case 7:
# line 213 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("def_element: operation\n"));
		(void) obj_register(ITMC_OBJ_OP, (itm_data_t *)(yypvt[-0].tbl_hdr->name.itm_ptr),
			yypvt[-0].tbl_hdr, yypvt[-0].tbl_hdr->size,
			NULL, OBJ_REG_TAIL);
		yyval.tbl_hdr = yypvt[-0].tbl_hdr;
	} break;
case 8:
# line 224 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("direction name (direction_unit_list)\n"));
		yyval.tbl_hdr = obj_table(ITM_TBL_DIREC, yypvt[-3].data,
			yypvt[-1].obj, sizeof (itm_direc_t));
	} break;
case 9:
# line 230 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("direction name (direction_unit_list)\n"));
		yyval.tbl_hdr = obj_table(ITM_TBL_DIREC, NULL,
			yypvt[-1].obj, sizeof (itm_direc_t));
	} break;
case 10:
# line 239 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("direction_unit_list: direction_unit\n"));
		yyval.obj = obj_list_append(NULL, yypvt[-0].obj);
	} break;
case 11:
# line 244 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("direction_unit_list: "
			"direction_unit_list direction_unit\n"));
		yyval.obj = obj_list_append(yypvt[-1].obj, yypvt[-0].obj);
	} break;
case 12:
# line 253 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("direction_unit: condition action ;\n"));
		yyval.obj = direction_unit(yypvt[-2].itmc_ref, NULL, &(yypvt[-1].action), NULL);
	} break;
case 13:
# line 258 "../itm_comp.y"
{
		itm_direc_t	*direc;
		TRACE_MESSAGE('y', ("direction_unit: condition NAME ;\n"));
		yyval.obj = direction_unit(yypvt[-2].itmc_ref, NULL, NULL, yypvt[-1].data);
	} break;
case 14:
# line 264 "../itm_comp.y"
{
		itm_direc_t	*direc;
		TRACE_MESSAGE('y', ("direction_unit: NAME action ;\n"));
		yyval.obj = direction_unit(NULL, yypvt[-2].data, &(yypvt[-1].action), NULL);
	} break;
case 15:
# line 270 "../itm_comp.y"
{
		itm_direc_t	*direc;
		TRACE_MESSAGE('y', ("direction_unit: NAME NAME ;\n"));
		yyval.obj = direction_unit(NULL, yypvt[-2].data, NULL, yypvt[-1].data);
	} break;
case 16:
# line 276 "../itm_comp.y"
{
		itm_direc_t	*direc;
		yyval.obj = direction_unit(NULL, NULL, &(yypvt[-1].action), NULL);
	} break;
case 17:
# line 281 "../itm_comp.y"
{
		itm_direc_t	*direc;
		TRACE_MESSAGE('y', ("direction_unit: TRUE NAME ;\n"));
		yyval.obj = direction_unit(NULL, NULL, NULL, yypvt[-1].data);
	} break;
case 18:
# line 290 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("action: direction\n"));
		yyval.action.type = ITMC_OBJ_DIREC;
		yyval.action.tbl_hdr = yypvt[-0].tbl_hdr;
	} break;
case 19:
# line 296 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("action: map\n"));
		yyval.action.type = ITMC_OBJ_MAP;
		yyval.action.tbl_hdr = yypvt[-0].tbl_hdr;
	} break;
case 20:
# line 302 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("action: operation\n"));
		yyval.action.type = ITMC_OBJ_OP;
		yyval.action.tbl_hdr = yypvt[-0].tbl_hdr;
	} break;
case 21:
# line 311 "../itm_comp.y"
{
		itm_tbl_hdr_t	*tbl_hdr;
		TRACE_MESSAGE('y', ("condition\n"));
		tbl_hdr = obj_table(ITM_TBL_COND, yypvt[-3].data,
				    yypvt[-1].obj, sizeof (itm_cond_t));
		yyval.itmc_ref = obj_register(ITMC_OBJ_COND, yypvt[-3].data,
				tbl_hdr, tbl_hdr->size,
				NULL, OBJ_REG_TAIL);
	} break;
case 22:
# line 321 "../itm_comp.y"
{
		itm_tbl_hdr_t	*tbl_hdr;
		TRACE_MESSAGE('y', ("condition\n"));
		tbl_hdr = obj_table(ITM_TBL_COND, NULL,
				    yypvt[-1].obj, sizeof (itm_cond_t));
		yyval.itmc_ref = obj_register(ITMC_OBJ_COND, NULL,
				tbl_hdr, tbl_hdr->size,
				NULL, OBJ_REG_TAIL);
	} break;
case 23:
# line 334 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("condition_list: condition_expr;\n"));
		yyval.obj = obj_list_append(NULL, yypvt[-1].obj);
	} break;
case 24:
# line 339 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("condition_list: "
			"condition_list condition_expr;\n"));
		yyval.obj = obj_list_append(yypvt[-2].obj, yypvt[-1].obj);
	} break;
case 25:
# line 348 "../itm_comp.y"
{
		itm_tbl_hdr_t	*range;
		itm_cond_t	*cond;
		TRACE_MESSAGE('y', ("condition_expr: between\n"));
		range = range_table(NULL, yypvt[-0].obj);
		if (range == NULL) {
			yyval.obj = NULL;
		} else {
			yyval.obj = malloc_vital(sizeof (itmc_obj_t));
			yyval.obj->type = ITMC_OBJ_RANGE;
			yyval.obj->name = NULL;
			cond = malloc_vital(sizeof (itm_cond_t));
			yyval.obj->obj = cond;
			cond->type = ITM_COND_BETWEEN;
			cond->operand.place.itm_ptr = (itm_place2_t)range;
			yyval.obj->ref[0] = obj_register(ITMC_OBJ_RANGE, NULL,
					range, range->size,
					&(cond->operand.place),
					OBJ_REG_TAIL);
			yyval.obj->ref[1] = NULL;
			yyval.obj->ref[2] = NULL;
			yyval.obj->next = yyval.obj->last = NULL;
		}
	} break;
case 26:
# line 373 "../itm_comp.y"
{
		itm_cond_t	*cond;
		TRACE_MESSAGE('y', ("condition_expr: expr\n"));
		yyval.obj = malloc_vital(sizeof (itmc_obj_t));
		yyval.obj->type = ITMC_OBJ_EXPR;
		yyval.obj->name = NULL;
		cond = malloc_vital(sizeof (itm_cond_t));
		yyval.obj->obj = cond;
		cond->type = ITM_COND_EXPR;
		cond->operand.place.itm_ptr = (itm_place2_t)(yypvt[-0].expr);
		yyval.obj->ref[0] = obj_register(ITMC_OBJ_EXPR, NULL,
					yypvt[-0].expr, sizeof (itm_expr_t),
					&(cond->operand.place),
					OBJ_REG_TAIL);
		yyval.obj->ref[1] = NULL;
		yyval.obj->ref[2] = NULL;
		yyval.obj->next = yyval.obj->last = NULL;
	} break;
case 27:
# line 392 "../itm_comp.y"
{
		itm_tbl_hdr_t	*escseq;
		itm_cond_t	*cond;
		TRACE_MESSAGE('y', ("condition_expr:  escseq {escseq_list;}\n"));
		escseq = escseq_table(NULL, yypvt[-0].obj);
		if (escseq == NULL) {
			yyval.obj = NULL;
		} else {
			yyval.obj = malloc_vital(sizeof (itmc_obj_t));
			yyval.obj->type = ITMC_OBJ_ESCAPESEQ;
			yyval.obj->name = NULL;
			cond = malloc_vital(sizeof (itm_cond_t));
			yyval.obj->obj = cond;
			cond->type = ITM_COND_ESCAPESEQ;
			cond->operand.place.itm_ptr = (itm_place2_t)escseq;
			yyval.obj->ref[0] = obj_register(ITMC_OBJ_ESCAPESEQ, NULL,
					escseq, escseq->size,
					&(cond->operand.place),
					OBJ_REG_TAIL);
			yyval.obj->ref[1] = NULL;
			yyval.obj->ref[2] = NULL;
			yyval.obj->next = yyval.obj->last = NULL;
		}
	} break;
case 28:
# line 420 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("range_list: range_pair\n"));
		yyval.obj = obj_list_append(NULL, yypvt[-0].obj);
	} break;
case 29:
# line 425 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("range_list: range_list, range_pair\n"));
		yyval.obj = obj_list_append(yypvt[-2].obj, yypvt[-0].obj);
	} break;
case 30:
# line 433 "../itm_comp.y"
{
		itmc_data_pair_t	*range;
		TRACE_MESSAGE('y', ("range_pair: HEXADECIMAL...HEXADECIMAL\n"));
		yyval.obj = malloc_vital(sizeof (itmc_obj_t));
		yyval.obj->type = ITMC_OBJ_RANGE;
		yyval.obj->name = NULL;
		range = malloc_vital(sizeof (itmc_data_pair_t));
		yyval.obj->obj = range;
		if (data_compare(yypvt[-2].data, yypvt[-0].data) < 0) {
			range->data0 = *(yypvt[-2].data);
			range->data1 = *(yypvt[-0].data);
		} else {
			range->data0 = *(yypvt[-0].data);
			range->data1 = *(yypvt[-2].data);
		}
	} break;
case 31:
# line 452 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("escseq_list: escseq\n"));
		yyval.obj = obj_list_append(NULL, yypvt[-0].obj);
	} break;
case 32:
# line 457 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("escseq_list: escseq_list; escseq\n"));
		yyval.obj = obj_list_append(yypvt[-2].obj, yypvt[-0].obj);
	} break;
case 33:
# line 465 "../itm_comp.y"
{
		itm_data_t	*escseq;
		TRACE_MESSAGE('y', ("escseq: HEXADECIMAL\n"));
		yyval.obj = malloc_vital(sizeof (itmc_obj_t));
		yyval.obj->type = ITMC_OBJ_ESCAPESEQ;
		yyval.obj->name = NULL;
		escseq = malloc_vital(sizeof (itm_data_t));
		yyval.obj->obj = escseq;
		*escseq = *(yypvt[-0].data);
	} break;
case 34:
# line 478 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map: map name {map_list}\n"));
		yyval.tbl_hdr = map_table(yypvt[-3].data, yypvt[-1].map_list, NULL);
	} break;
case 35:
# line 483 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map: map {map_list}\n"));
		yyval.tbl_hdr = map_table(NULL, yypvt[-1].map_list, NULL);
	} break;
case 36:
# line 488 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map: map name attribute {map_list}\n"));
		yyval.tbl_hdr = map_table(yypvt[-4].data, yypvt[-1].map_list, yypvt[-3].map_attr);
	} break;
case 37:
# line 493 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map: map attribute {map_list}\n"));
		yyval.tbl_hdr = map_table(NULL, yypvt[-1].map_list, yypvt[-3].map_attr);
	} break;
case 38:
# line 501 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_attribute: map_type map_resultlen\n"));
		yyval.map_attr = yypvt[-2].map_attr;
		yyval.map_attr->resultlen = yypvt[-0].intval;
	} break;
case 39:
# line 507 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_attribute: map_type\n"));
		yyval.map_attr = yypvt[-0].map_attr;
		yyval.map_attr->resultlen = 0;
	} break;
case 40:
# line 513 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_attribute: map_resultlen map_type\n"));
		yyval.map_attr = yypvt[-0].map_attr;
		yyval.map_attr->resultlen = yypvt[-2].intval;
	} break;
case 41:
# line 519 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_attribute: map_resultlen\n"));
		yyval.map_attr = malloc_vital(sizeof (itmc_map_attr_t));
		yyval.map_attr->resultlen = yypvt[-0].intval;
		yyval.map_attr->type = NULL;
		yyval.map_attr->hash_factor = 0;
	} break;
case 42:
# line 530 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_type: maptype=type:factor(%d)\n",
			yypvt[-0].num));
		yyval.map_attr = malloc_vital(sizeof (itmc_map_attr_t));
		yyval.map_attr->type = yypvt[-2].name;
		yyval.map_attr->hash_factor = yypvt[-0].num;
	} break;
case 43:
# line 538 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_type: maptype=type\n"));
		yyval.map_attr = malloc_vital(sizeof (itmc_map_attr_t));
		yyval.map_attr->type  = yypvt[-0].name;
		yyval.map_attr->hash_factor = 0;
	} break;
case 44:
# line 548 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_type_names: size=%*s\n",
				yylval.data->size, NSPTR(yylval.data)));
		yyval.name = yylval.data;
	} break;
case 45:
# line 558 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_resultlen(%d)\n", yypvt[-0].num));
		yyval.intval = yypvt[-0].num;
	} break;
case 46:
# line 566 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_list: map_pair\n"));
		yyval.map_list = map_list_append(NULL, yypvt[-0].map_list);
	} break;
case 47:
# line 571 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_list: map_list map_pair\n"));
		yyval.map_list = map_list_append(yypvt[-1].map_list, yypvt[-0].map_list);
	} break;
case 48:
# line 579 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_pair: HEXADECIMAL HEXADECIMAL\n"));
		yyval.map_list = malloc_vital(sizeof (itmc_map_t));
		yyval.map_list->data_pair.data0 = *(yypvt[-1].data);
		free(yypvt[-1].data);
		yyval.map_list->data_pair.data1 = *(yypvt[-0].data);
		free(yypvt[-0].data);
	} break;
case 49:
# line 588 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_pair: "
			"HEXADECIMAL ELLIPSES HEXADECIMAL\n"));
		yyval.map_list = malloc_vital(sizeof (itmc_map_t));
		yyval.map_list->data_pair.data0 = *(yypvt[-3].data);
		yyval.map_list->data_pair.range = *(yypvt[-1].data);
		free(yypvt[-3].data);
		free(yypvt[-1].data);
		yyval.map_list->data_pair.data1 = *(yypvt[-0].data);
		free(yypvt[-0].data);
	} break;
case 50:
# line 600 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_pair: default HEXADECIMAL\n"));
		yyval.map_list = malloc_vital(sizeof (itmc_map_t));
		yyval.map_list->data_pair.data0.size = 0;
		yyval.map_list->data_pair.data1 = *(yypvt[-0].data);
		free(yypvt[-0].data);
	} break;
case 51:
# line 608 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_pair: default default\n"));
		yyval.map_list = malloc_vital(sizeof (itmc_map_t));
		yyval.map_list->data_pair.data0.size = 0;
		yyval.map_list->data_pair.data1.size = 0;
	} break;
case 52:
# line 615 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("map_pair: hexadecimal error\n"));
		yyval.map_list = malloc_vital(sizeof (itmc_map_t));
		yyval.map_list->data_pair.data0 = *(yypvt[-1].data);
		free(yypvt[-1].data);
		yyval.map_list->data_pair.data1.size = 0;
	} break;
case 53:
# line 626 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("operation: operation name {op_list}\n"));
		yyval.tbl_hdr = obj_table(ITM_TBL_OP, yypvt[-3].data,
			yypvt[-1].obj, sizeof (itm_op_t));
	} break;
case 54:
# line 632 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("operation: operation {op_list}\n"));
		yyval.tbl_hdr = obj_table(ITM_TBL_OP, NULL,
				yypvt[-1].obj, sizeof (itm_op_t));
	} break;
case 55:
# line 638 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("operation: operation init {op_list}\n"));
		yyval.tbl_hdr = obj_table(ITM_TBL_OP_INIT, NULL,
			yypvt[-1].obj, sizeof (itm_op_t));
	} break;
case 56:
# line 644 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("operation: operation reset {op_list}\n"));
		yyval.tbl_hdr = obj_table(ITM_TBL_OP_RESET, NULL,
			yypvt[-1].obj, sizeof (itm_op_t));
	} break;
case 57:
# line 652 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("op_list: op_unit\n"));
		yyval.obj = obj_list_append(NULL, yypvt[-0].obj);
	} break;
case 58:
# line 657 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("op_list: op_list op_unit\n"));
		yyval.obj = obj_list_append(yypvt[-1].obj, yypvt[-0].obj);
	} break;
case 59:
# line 664 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("op_unit: /	*null */;\n"));
		yyval.obj = NULL;
	} break;
case 60:
# line 669 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("op_unit: expr;\n"));
		yyval.obj = op_unary(ITM_OP_EXPR, yypvt[-1].expr, sizeof (itm_expr_t));
	} break;
case 61:
# line 674 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: error;\n"));
		yyval.obj = op_self_num(ITM_OP_ERROR_D, EINVAL);
	} break;
case 62:
# line 679 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: error;\n"));
		if (ITM_EXPR_INT == yypvt[-1].expr->type) {
			yyval.obj = op_self_num(ITM_OP_ERROR_D, yypvt[-1].expr->data.itm_exnum);
		} else {
			yyval.obj = op_unary(ITM_OP_ERROR, yypvt[-1].expr, sizeof (itm_expr_t));
		}
	} break;
case 63:
# line 688 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("discard expr;\n"));
		yyval.obj = op_self_num(ITM_OP_DISCARD_D, 1);
	} break;
case 64:
# line 693 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("discard expr;\n"));
		if (ITM_EXPR_INT == yypvt[-1].expr->type) {
			yyval.obj = op_self_num(ITM_OP_DISCARD_D, yypvt[-1].expr->data.itm_exnum);
		} else {
			yyval.obj = op_unary(ITM_OP_DISCARD, yypvt[-1].expr, sizeof (itm_expr_t));
		}
	} break;
case 65:
# line 702 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("out = expr;\n"));
		switch (yypvt[-1].expr->type) {
		case ITM_EXPR_INT:
			yyval.obj = op_unary(ITM_OP_OUT_D, yypvt[-1].expr, sizeof (itm_expr_t));
			break;
		case ITM_EXPR_SEQ:
			yyval.obj = op_unary(ITM_OP_OUT_S, yypvt[-1].expr, sizeof (itm_expr_t));
			break;
		case ITM_EXPR_REG:
			yyval.obj = op_unary(ITM_OP_OUT_R, yypvt[-1].expr, sizeof (itm_expr_t));
			break;
		case ITM_EXPR_IN_VECTOR_D:
			yyval.obj = op_unary(ITM_OP_OUT_INVD, yypvt[-1].expr, sizeof (itm_expr_t));
			break;
		default:
			yyval.obj = op_unary(ITM_OP_OUT, yypvt[-1].expr, sizeof (itm_expr_t));
			break;
		}
	} break;
case 66:
# line 723 "../itm_comp.y"
{
		itm_op_t	*op;
		TRACE_MESSAGE('y', ("direction NAME;\n"));
		yyval.obj = op_unit(ITM_OP_DIRECTION, NULL, 0, NULL, 0, NULL, 0);
		op = (itm_op_t *)(yyval.obj->obj);
		op->data.operand[0].itm_ptr = (itm_place2_t)(yypvt[-1].data);
		yyval.obj->ref[0] = obj_register(ITMC_OBJ_DIREC, yypvt[-1].data,
					NULL, 0,
					&(op->data.operand[0]), OBJ_REG_TAIL);
	} break;
case 67:
# line 734 "../itm_comp.y"
{
		itm_op_t	*op;
		TRACE_MESSAGE('y', ("operation NAME;\n"));
		yyval.obj = op_unit(ITM_OP_OPERATION, NULL, 0, NULL, 0, NULL, 0);
		op = (itm_op_t *)(yyval.obj->obj);
		op->data.operand[0].itm_ptr = (itm_place2_t)(yypvt[-1].data);
		yyval.obj->ref[0] = obj_register(ITMC_OBJ_OP, yypvt[-1].data,
					NULL, 0,
					&(op->data.operand[0]), OBJ_REG_TAIL);
	} break;
case 68:
# line 745 "../itm_comp.y"
{
		itm_op_t	*op;
		TRACE_MESSAGE('y', ("operation init;\n"));
		yyval.obj = op_self(ITM_OP_INIT);
	} break;
case 69:
# line 751 "../itm_comp.y"
{
		itm_op_t	*op;
		TRACE_MESSAGE('y', ("operation reset;\n"));
		yyval.obj = op_self(ITM_OP_RESET);
	} break;
case 70:
# line 757 "../itm_comp.y"
{
		itm_op_t	*op;
		TRACE_MESSAGE('y', ("map NAME;\n"));
		yyval.obj = op_unit(ITM_OP_MAP, NULL, 0, NULL, 0, NULL, 0);
		op = (itm_op_t *)(yyval.obj->obj);
		op->data.operand[0].itm_ptr = (itm_place2_t)(yypvt[-1].data);
		yyval.obj->ref[0] = obj_register(ITMC_OBJ_MAP, yypvt[-1].data,
					NULL, 0,
					&(op->data.operand[0]), OBJ_REG_TAIL);
	} break;
case 71:
# line 768 "../itm_comp.y"
{
		itm_op_t	*op;
		TRACE_MESSAGE('y', ("map NAME expr;\n"));
		yyval.obj = op_unit(ITM_OP_MAP, NULL, 0, yypvt[-1].expr,
			sizeof (itm_expr_t), NULL, 0);
		op = (itm_op_t *)(yyval.obj->obj);
		op->data.operand[0].itm_ptr = (itm_place2_t)(yypvt[-2].data);
		yyval.obj->ref[0] = obj_register(ITMC_OBJ_MAP, yypvt[-2].data,
					NULL, 0,
					&(op->data.operand[0]), OBJ_REG_TAIL);
	} break;
case 72:
# line 780 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("op_unit: op_if_else\n"));
		yyval.obj = yypvt[-0].obj;
	} break;
case 73:
# line 785 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("break;\n"));
		yyval.obj = op_self(ITM_OP_BREAK);
	} break;
case 74:
# line 790 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("return;\n"));
		yyval.obj = op_self(ITM_OP_RETURN);
	} break;
case 75:
# line 795 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("printchr expr;\n"));
		yyval.obj = op_unary(ITM_OP_PRINTCHR, yypvt[-1].expr, sizeof (itm_expr_t));
	} break;
case 76:
# line 800 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("printchr expr;\n"));
		yyval.obj = op_unary(ITM_OP_PRINTHD, yypvt[-1].expr, sizeof (itm_expr_t));
	} break;
case 77:
# line 805 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("printint expr;\n"));
		yyval.obj = op_unary(ITM_OP_PRINTINT, yypvt[-1].expr, sizeof (itm_expr_t));
	} break;
case 78:
# line 813 "../itm_comp.y"
{
		itm_tbl_hdr_t	*tbl_hdr;
		TRACE_MESSAGE('y', ("op_if_else: if (expr) {op_list}\n"));
		tbl_hdr = obj_table(ITM_TBL_OP, NULL,
				    yypvt[-1].obj, sizeof (itm_op_t));
		yyval.obj = op_unit(ITM_OP_IF,
				yypvt[-4].expr, sizeof (itm_expr_t),
				tbl_hdr, tbl_hdr->size,
				NULL, 0);
	} break;
case 79:
# line 824 "../itm_comp.y"
{
		itm_tbl_hdr_t	*tbl_hdr1;
		itm_tbl_hdr_t	*tbl_hdr2;
		TRACE_MESSAGE('y', ("op_if_else: "
			"if (expr) {op_list} else op_if_else\n"));
		tbl_hdr1 = obj_table(ITM_TBL_OP, NULL,
				    yypvt[-3].obj, sizeof (itm_op_t));
		tbl_hdr2 = obj_table(ITM_TBL_OP, NULL,
				    yypvt[-0].obj, sizeof (itm_op_t));
		yyval.obj = op_unit(ITM_OP_IF_ELSE,
				yypvt[-6].expr, sizeof (itm_expr_t),
				tbl_hdr1, tbl_hdr1->size,
				tbl_hdr2, tbl_hdr2->size);
	} break;
case 80:
# line 839 "../itm_comp.y"
{
		itm_tbl_hdr_t	*tbl_hdr1;
		itm_tbl_hdr_t	*tbl_hdr2;
		TRACE_MESSAGE('y', ("op_if_else: "
			"if (expr) {op_list} else {op_list}\n"));
		tbl_hdr1 = obj_table(ITM_TBL_OP, NULL,
				    yypvt[-5].obj, sizeof (itm_op_t));
		tbl_hdr2 = obj_table(ITM_TBL_OP, NULL,
				    yypvt[-1].obj, sizeof (itm_op_t));
		yyval.obj = op_unit(ITM_OP_IF_ELSE,
				yypvt[-8].expr, sizeof (itm_expr_t),
				tbl_hdr1, tbl_hdr1->size,
				tbl_hdr2, tbl_hdr2->size);
	} break;
case 81:
# line 856 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("name: size=%*s\n",
				yylval.data->size, NSPTR(yylval.data)));
		yyval.data = yylval.data;
	} break;
case 82:
# line 864 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("in\n"));
		yyval.expr = expr_self(ITM_EXPR_IN, NULL);
	} break;
case 83:
# line 871 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: (expr)\n"));
		yyval.expr = yypvt[-1].expr;
	} break;
case 84:
# line 876 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: NAME\n"));
		yyval.expr = expr_self(ITM_EXPR_NAME, yypvt[-0].data);
	} break;
case 85:
# line 881 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: HEXADECIMAL\n"));
		yyval.expr = expr_self(ITM_EXPR_SEQ, yylval.data);
	} break;
case 86:
# line 886 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: DECIMAL\n"));
		yyval.expr = expr_self_num(ITM_EXPR_INT, yylval.num);
	} break;
case 87:
# line 891 "../itm_comp.y"
{
		if (ITM_EXPR_INT == yypvt[-1].expr->type) {
			TRACE_MESSAGE('y', ("expr: in[%ld]\n",
				yypvt[-1].expr->data.itm_exnum));
			yyval.expr = expr_self_num(ITM_EXPR_IN_VECTOR_D,
				yypvt[-1].expr->data.itm_exnum);
		} else {
			TRACE_MESSAGE('y', ("expr: in[expr]\n"));
			yyval.expr = expr_unary(ITM_EXPR_IN_VECTOR, yypvt[-1].expr);
		}
	} break;
case 88:
# line 903 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: outsize\n"));
		yyval.expr = expr_self_num(ITM_EXPR_OUT, 0);
	} break;
case 89:
# line 908 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: inputsize\n"));
		yyval.expr = expr_self_num(ITM_EXPR_IN_VECTOR_D, (size_t)-1);
	} break;
case 90:
# line 913 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: true\n"));
		yyval.expr = expr_self_num(ITM_EXPR_TRUE, 1);
	} break;
case 91:
# line 918 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: false\n"));
		yyval.expr = expr_self_num(ITM_EXPR_FALSE, 0);
	} break;
case 92:
# line 923 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: in == expr\n"));
		yyval.expr = expr_unary(ITM_EXPR_IN_EQ, yypvt[-0].expr);
	} break;
case 93:
# line 928 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr == in\n"));
		yyval.expr = expr_unary(ITM_EXPR_IN_EQ, yypvt[-2].expr);
	} break;
case 94:
# line 933 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: ! expr\n"));

		if (ITM_EXPR_INT == yypvt[-0].expr->type) {
			yyval.expr = expr_self_num(ITM_EXPR_INT, !(yypvt[-0].expr->data.itm_exnum));
		} else {
			yyval.expr = expr_unary(ITM_EXPR_NOT, yypvt[-0].expr);
		}
	} break;
case 95:
# line 943 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: ~ expr\n"));
		if (ITM_EXPR_INT == yypvt[-0].expr->type) {
			yyval.expr = expr_self_num(ITM_EXPR_INT, ~(yypvt[-0].expr->data.itm_exnum));
		} else {
			yyval.expr = expr_unary(ITM_EXPR_NEG, yypvt[-0].expr);
		}
	} break;
case 96:
# line 952 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: - expr\n"));
		if (ITM_EXPR_INT == yypvt[-0].expr->type) {
			yyval.expr = expr_self_num(ITM_EXPR_INT,
				(-1) * (yypvt[-0].expr->data.itm_exnum));
		} else {
			yyval.expr = expr_unary(ITM_EXPR_UMINUS, yypvt[-0].expr);
		}
	} break;
case 97:
# line 962 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr + expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_PLUS, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
		}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
		}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
		}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_PLUS, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 98:
# line 1036 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr - expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_MINUS, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_D_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_R_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_INVD_D,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_INVD_R,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_INVD_E,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS_E_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MINUS, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 99:
# line 1116 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr		*expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_MUL, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MUL_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MUL, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 100:
# line 1190 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr / expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_DIV, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_DIV_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_DIV, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 101:
# line 1264 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr % expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_MOD, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_MOD_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_MOD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 102:
# line 1338 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr << expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_SHIFT_L, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_D_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_R_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_INVD_D,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_INVD_R,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_INVD_E,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L_E_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_L, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 103:
# line 1418 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr >> expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_SHIFT_R, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_D_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_R_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_INVD_D,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_INVD_R,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_INVD_E,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R_E_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_SHIFT_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 104:
# line 1498 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr | expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_OR, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_OR_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_OR_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_OR_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_OR_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_OR_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_OR_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_OR_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_OR_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_OR_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_OR_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_OR_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_OR_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_OR_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_OR_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_OR_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_OR, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 105:
# line 1572 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr ^ expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_XOR, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_XOR_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_XOR, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 106:
# line 1646 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr & expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_AND, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_AND_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_AND_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_AND_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_AND_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
	}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_AND_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_AND_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_AND_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_AND_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_AND_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_AND_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_AND_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_AND_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_AND_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_AND_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_AND_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_AND, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 107:
# line 1720 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr == expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_EQ, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_EQ_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_EQ, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 108:
# line 1794 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr != expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_NE, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_NE_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_NE_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_NE_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_NE_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_NE_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_NE_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_NE_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_NE_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_NE_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_NE_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_NE_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_NE_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_NE_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_NE_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_NE_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_NE, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 109:
# line 1868 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr > expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_GT, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_GT_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_GT_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_GT_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_GT_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_GT_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_GT_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_GT_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_GT_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_GT_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_GT_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_GT_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_GT_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_GT_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_GT_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_GT_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_GT, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 110:
# line 1942 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr >= expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_GE, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_GE_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_GE_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_GE_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_GE_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_GE_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_GE_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_GE_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_GE_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_GE_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_GE_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_GE_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_GE_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_GE_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_GE_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_GE_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_GE, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 111:
# line 2016 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr < expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_LT, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_LT_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_LT_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_LT_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_LT_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_LT_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_LT_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_LT_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_LT_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_LT_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_LT_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_LT_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_LT_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_LT_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_LT_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_LT_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_LT, yypvt[-2].expr, yypvt[-0].expr);
				break;
				}
			break;
		}
	} break;
case 112:
# line 2090 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr <= expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_LE, yypvt[-2].expr, yypvt[-0].expr);
		yypvt[-2].expr = expr_seq_to_int(yypvt[-2].expr);
		yypvt[-0].expr = expr_seq_to_int(yypvt[-0].expr);
		switch (yypvt[-2].expr->type) {
		case ITM_EXPR_INT:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_LE_D_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_LE_D_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_LE_D_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_LE_D_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_REG:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_LE_R_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_LE_R_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_LE_R_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_LE_R_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		case ITM_EXPR_IN_VECTOR_D:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_LE_INVD_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_LE_INVD_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_LE_INVD_INVD,
					yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_LE_INVD_E, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		default:
			switch (yypvt[-0].expr->type) {
			case ITM_EXPR_INT:
				yyval.expr = expr_binary2(ITM_EXPR_LE_E_D, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_REG:
				yyval.expr = expr_binary2(ITM_EXPR_LE_E_R, yypvt[-2].expr, yypvt[-0].expr);
				break;
			case ITM_EXPR_IN_VECTOR_D:
				yyval.expr = expr_binary2(ITM_EXPR_LE_E_INVD, yypvt[-2].expr, yypvt[-0].expr);
				break;
			default:
				yyval.expr = expr_binary2(ITM_EXPR_LE, yypvt[-2].expr, yypvt[-0].expr);
				break;
			}
			break;
		}
	} break;
case 113:
# line 2164 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: NAME = expr\n"));
		yyval.expr = expr_assign(ITM_EXPR_ASSIGN, yypvt[-2].data, yypvt[-0].expr);
	} break;
case 114:
# line 2169 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr || expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_LOR, yypvt[-2].expr, yypvt[-0].expr);
	} break;
case 115:
# line 2174 "../itm_comp.y"
{
		TRACE_MESSAGE('y', ("expr: expr && expr\n"));
		yyval.expr = expr_binary(ITM_EXPR_LAND, yypvt[-2].expr, yypvt[-0].expr);
	} break;
# line	556 "/usr/share/lib/ccs/yaccpar"
	}
	goto yystack;		/* reset registers in driver code */
}