# define IDENT 257
# define INTGR 258
# define NUMBER 259
# define STRCONST 260
# define AOPCODE 261
# define ELSE 262
# define EXPORTS 263
# define EXTEND 264
# define GLOBAL 265
# define IF 266
# define IMPORTS 267
# define INCHANNELS 268
# define INPUTMOD 269
# define INSTR 270
# define IOPCODE 271
# define IVAR 272
# define TABLE 273
# define KOPCODE 274
# define KRATE 275
# define KSIG 276
# define ASIG 277
# define MAP 278
# define OPARRAY 279
# define OPCODE 280
# define OUTBUS 281
# define OUTCHANNELS 282
# define OUTPUT 283
# define ROUTE 284
# define SEND 285
# define SEQUENCE 286
# define SRATE 287
# define TEMPLATE 288
# define TURNOFF 289
# define WHILE 290
# define WITH 291
# define XSIG 292
# define AND 293
# define OR 294
# define GEQ 295
# define LEQ 296
# define NEQ 297
# define EQEQ 298
# define MINUS 299
# define STAR 300
# define SPATIALIZE 301
# define SFSYNTH 302
# define TABLEMAP 303
# define SLASH 304
# define PLUS 305
# define GT 306
# define LT 307
# define Q 308
# define COL 309
# define LP 310
# define RP 311
# define LC 312
# define RC 313
# define LB 314
# define RB 315
# define SEM 316
# define COM 317
# define EQ 318
# define RETURN 319
# define NOT 320
# define ARRAYREF 321
# define OPCALL 322
# define IMPEXP 323
# define VARDECL 324
# define NOTAG 325
# define SPECIALOP 326
#include "saol.h"
#define YYDEBUG 1
extern sa_decoder *cur_sa;
# define UNOT 327
# define UMINUS 328
# define HIGHEST 329

#include <malloc.h>
#include <memory.h>

#ifndef _WIN32
#include <unistd.h>
#include <values.h>
#else
#define gettxt(x) printf("Error\n")
#endif

#ifdef __cplusplus

#ifndef yyerror
	void yyerror(const char *);
#endif
#ifndef yylex
	extern "C" int yylex(void);
#endif
	int yyparse(void);

#endif
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern int yyerrflag;
#ifndef YYSTYPE
#define YYSTYPE int
#endif
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


#include "lex.yy.c"

void parse_error(char *status) {
  int i;
  char c;
  
  printf("Line %d: %s\n", yyline,status);
  printf("%s\n",thisline);
  for (i=0;i<yycol-strlen(yytext)-1 && i < 100;i++) printf(" ");
  printf("^\n");
  cur_sa->synerror = 1;
  }

void parse_error_line(char *status,int line) {
  int i;
  char c;
  
  printf("Line %d: %s\n", line,status);
  printf("   %s\n\n",all_lines[line-1]);
  cur_sa->synerror = 1;
  }

void warn_line(char *status,int line) {
  int i;
  char c;
 
  if (line) { 
    printf("Warning: Line %d: %s\n", line,status);
    printf("   %s\n\n",all_lines[line-1]);
    }
  else printf("Warning: %s\n",status);
  }

  

void yyerror(char *foo) {}
yytabelem yyexca[] ={
-1, 0,
	0, 7,
	261, 7,
	265, 7,
	270, 7,
	271, 7,
	274, 7,
	280, 7,
	288, 7,
	-2, 0,
-1, 1,
	0, -1,
	-2, 0,
-1, 2,
	0, 1,
	-2, 0,
-1, 3,
	0, 2,
	-2, 8,
-1, 9,
	257, 119,
	-2, 10,
-1, 19,
	263, 28,
	267, 28,
	268, 28,
	269, 28,
	272, 28,
	273, 28,
	275, 28,
	276, 28,
	277, 28,
	279, 28,
	282, 28,
	284, 28,
	285, 28,
	286, 28,
	287, 28,
	303, 28,
	313, 28,
	-2, 0,
-1, 20,
	306, 71,
	317, 71,
	-2, 0,
-1, 21,
	311, 71,
	317, 71,
	-2, 0,
-1, 22,
	311, 75,
	317, 75,
	-2, 0,
-1, 23,
	272, 113,
	276, 113,
	277, 113,
	279, 113,
	-2, 0,
-1, 31,
	311, 76,
	317, 76,
	-2, 103,
-1, 48,
	316, 108,
	-2, 36,
-1, 82,
	311, 71,
	317, 71,
	-2, 0,
-1, 86,
	311, 71,
	317, 71,
	-2, 0,
-1, 88,
	257, 78,
	258, 78,
	259, 78,
	263, 78,
	264, 78,
	266, 78,
	267, 78,
	270, 78,
	272, 78,
	273, 78,
	276, 78,
	277, 78,
	279, 78,
	281, 78,
	283, 78,
	289, 78,
	290, 78,
	299, 78,
	301, 78,
	302, 78,
	303, 78,
	310, 78,
	313, 78,
	319, 78,
	320, 78,
	-2, 0,
-1, 89,
	257, 85,
	258, 85,
	259, 85,
	263, 85,
	264, 85,
	266, 85,
	267, 85,
	270, 85,
	272, 85,
	273, 85,
	276, 85,
	277, 85,
	279, 85,
	281, 85,
	283, 85,
	289, 85,
	290, 85,
	292, 85,
	299, 85,
	301, 85,
	302, 85,
	310, 85,
	313, 85,
	319, 85,
	320, 85,
	-2, 0,
-1, 91,
	311, 91,
	317, 91,
	-2, 103,
-1, 100,
	311, 71,
	317, 71,
	-2, 0,
-1, 107,
	257, 50,
	258, 50,
	259, 50,
	264, 50,
	266, 50,
	270, 50,
	272, 113,
	276, 113,
	277, 113,
	279, 113,
	281, 50,
	283, 50,
	289, 50,
	290, 50,
	299, 50,
	301, 50,
	302, 50,
	310, 50,
	313, 50,
	319, 50,
	320, 50,
	-2, 0,
-1, 109,
	257, 50,
	258, 50,
	259, 50,
	264, 50,
	266, 50,
	270, 50,
	272, 113,
	276, 113,
	277, 113,
	279, 113,
	281, 50,
	283, 50,
	289, 50,
	290, 50,
	292, 113,
	299, 50,
	301, 50,
	302, 50,
	310, 50,
	313, 50,
	319, 50,
	320, 50,
	-2, 0,
-1, 115,
	311, 71,
	317, 71,
	-2, 0,
-1, 116,
	316, 144,
	317, 144,
	-2, 0,
-1, 117,
	311, 144,
	317, 144,
	-2, 0,
-1, 123,
	263, 83,
	267, 83,
	272, 83,
	273, 83,
	276, 83,
	277, 83,
	279, 83,
	303, 83,
	316, 108,
	-2, 51,
-1, 126,
	263, 89,
	267, 89,
	272, 89,
	273, 89,
	276, 89,
	277, 89,
	279, 89,
	292, 89,
	316, 108,
	-2, 51,
-1, 161,
	293, 141,
	294, 141,
	295, 141,
	296, 141,
	297, 141,
	298, 141,
	300, 141,
	304, 141,
	305, 141,
	306, 141,
	307, 141,
	308, 141,
	316, 141,
	318, 68,
	-2, 65,
-1, 162,
	318, 66,
	-2, 120,
-1, 169,
	311, 71,
	317, 71,
	-2, 0,
-1, 185,
	311, 144,
	317, 144,
	-2, 0,
-1, 195,
	313, 71,
	317, 71,
	-2, 0,
-1, 201,
	311, 144,
	317, 144,
	-2, 0,
-1, 202,
	316, 144,
	317, 144,
	-2, 0,
-1, 203,
	311, 144,
	317, 144,
	-2, 0,
-1, 207,
	311, 144,
	317, 144,
	-2, 0,
-1, 214,
	295, 0,
	296, 0,
	297, 0,
	298, 0,
	306, 0,
	307, 0,
	-2, 126,
-1, 215,
	295, 0,
	296, 0,
	297, 0,
	298, 0,
	306, 0,
	307, 0,
	-2, 127,
-1, 216,
	295, 0,
	296, 0,
	297, 0,
	298, 0,
	306, 0,
	307, 0,
	-2, 128,
-1, 217,
	295, 0,
	296, 0,
	297, 0,
	298, 0,
	306, 0,
	307, 0,
	-2, 129,
-1, 218,
	295, 0,
	296, 0,
	297, 0,
	298, 0,
	306, 0,
	307, 0,
	-2, 130,
-1, 219,
	295, 0,
	296, 0,
	297, 0,
	298, 0,
	306, 0,
	307, 0,
	-2, 131,
-1, 236,
	311, 144,
	317, 144,
	-2, 0,
-1, 257,
	316, 71,
	317, 71,
	-2, 0,
-1, 259,
	311, 144,
	317, 144,
	-2, 0,
-1, 262,
	318, 67,
	-2, 122,
-1, 265,
	311, 144,
	317, 144,
	-2, 0,
-1, 267,
	257, 50,
	258, 50,
	259, 50,
	264, 50,
	266, 50,
	270, 50,
	281, 50,
	283, 50,
	289, 50,
	290, 50,
	299, 50,
	301, 50,
	302, 50,
	310, 50,
	313, 50,
	319, 50,
	320, 50,
	-2, 0,
-1, 268,
	257, 50,
	258, 50,
	259, 50,
	264, 50,
	266, 50,
	270, 50,
	281, 50,
	283, 50,
	289, 50,
	290, 50,
	299, 50,
	301, 50,
	302, 50,
	310, 50,
	313, 50,
	319, 50,
	320, 50,
	-2, 0,
-1, 277,
	313, 19,
	317, 19,
	-2, 0,
-1, 282,
	311, 144,
	317, 144,
	-2, 0,
-1, 302,
	257, 78,
	258, 78,
	259, 78,
	263, 78,
	264, 78,
	266, 78,
	267, 78,
	270, 78,
	272, 78,
	273, 78,
	276, 78,
	277, 78,
	279, 78,
	281, 78,
	283, 78,
	289, 78,
	290, 78,
	299, 78,
	301, 78,
	302, 78,
	303, 78,
	310, 78,
	313, 78,
	319, 78,
	320, 78,
	-2, 0,
-1, 306,
	257, 50,
	258, 50,
	259, 50,
	264, 50,
	266, 50,
	270, 50,
	281, 50,
	283, 50,
	289, 50,
	290, 50,
	299, 50,
	301, 50,
	302, 50,
	310, 50,
	313, 50,
	319, 50,
	320, 50,
	-2, 0,
-1, 308,
	257, 50,
	258, 50,
	259, 50,
	264, 50,
	266, 50,
	270, 50,
	272, 113,
	276, 113,
	277, 113,
	279, 113,
	281, 50,
	283, 50,
	289, 50,
	290, 50,
	299, 50,
	301, 50,
	302, 50,
	310, 50,
	313, 50,
	319, 50,
	320, 50,
	-2, 0,
	};
# define YYNPROD 154
# define YYLAST 848
yytabelem yyact[]={

   134,   161,   162,   141,   142,   282,    64,   301,   284,   158,
   314,   151,   304,   170,   170,   153,   187,   136,   141,   142,
   250,   305,   259,   305,   257,   170,   157,   283,   154,   161,
   162,   141,   142,   170,   159,   152,   292,   158,   196,   151,
   293,    63,   269,   153,   139,   261,   156,   155,   170,   251,
   145,   170,    64,    64,   157,   140,   154,   115,   316,   139,
   258,   256,   159,   152,   160,   138,   170,   170,   244,   113,
   140,   307,   139,   248,   156,   155,   245,   291,   230,   170,
   138,   190,    64,   140,   231,   168,   315,   170,   169,   170,
   129,    64,   160,   138,   194,   136,   141,   142,   192,   161,
   162,   141,   142,   281,   131,   120,   118,   158,   275,   151,
    64,    64,    64,   153,   112,   113,   274,    66,   272,   270,
   263,    65,   150,    67,   157,   150,   154,    64,   229,   210,
   206,   167,   159,   152,   166,   144,   117,   139,   116,   186,
   188,   189,   139,    96,   156,   155,   193,    95,   140,    94,
    93,    77,   265,   140,    92,   185,   289,   185,   138,   208,
   306,   184,   160,   138,   135,   136,   141,   142,   302,   277,
   268,   212,   213,   214,   215,   216,   217,   218,   219,   220,
   221,   222,   223,   224,   225,   226,   267,   195,   161,   162,
   141,   142,    89,    88,    19,   236,   158,   233,   151,   234,
   235,   207,   153,   205,   204,   203,   241,   139,   202,   243,
   201,   181,   182,   157,   199,   154,   183,   180,   140,   182,
   171,   159,   152,   183,   198,   105,   100,   171,   138,   171,
    86,   139,   249,   156,   155,    82,    81,    80,    79,    22,
    21,   287,   140,   303,    20,   288,   266,   264,   146,    84,
    83,   160,   138,   161,   162,   141,   142,   300,   123,    27,
    26,   158,   111,   151,    74,    61,   126,   153,   295,    60,
   107,   294,    73,    61,    76,    62,   240,    60,   157,   150,
   154,   150,    72,    62,    99,    69,   159,   152,   121,    71,
    35,    38,   286,   200,    36,    37,   139,    39,   156,   155,
   137,   161,   162,   141,   142,    55,   119,   140,   103,   158,
   163,   151,   102,   150,   150,   153,   160,   138,   178,   179,
   173,   172,   174,   175,   181,   182,   157,   101,   154,   183,
   180,   176,   177,   171,   159,   152,    70,    69,    87,    85,
   165,   252,    78,    18,   139,    17,   156,   155,   311,   297,
   141,   142,   299,    97,   279,   140,    35,    38,   147,   108,
    36,    37,   110,    39,   160,   138,   178,   179,   173,   172,
   174,   175,   181,   182,    24,     3,    33,   183,   180,   176,
   177,   171,   296,   297,   141,   142,   299,    30,    34,   197,
   178,   179,   173,   172,   174,   175,   181,   182,   124,    32,
   191,   183,   180,   176,   177,   171,   187,   136,   141,   142,
    54,   125,   262,   178,   179,   173,   172,   174,   175,   181,
   182,   149,   148,    98,   183,   180,   176,   177,   171,    53,
   122,    47,    46,    48,    45,   247,    44,    42,    41,   285,
    61,    23,    75,   109,    60,    51,    58,    29,    10,   139,
    62,     7,    50,     6,    43,    90,    68,     5,     4,    52,
   140,    56,    57,    59,    49,     2,     1,     0,     0,     0,
   138,   178,   179,   173,   172,   174,   175,   181,   182,     0,
    55,   133,   183,   180,   176,   177,   171,     0,     0,   260,
    40,   178,   179,   173,   172,   174,   175,   181,   182,     0,
     0,     0,   183,   180,   176,   177,   171,     0,     0,   254,
   178,   179,   173,   172,   174,   175,   181,   182,   209,     0,
   128,   183,   180,   176,   177,   171,     0,   164,   253,   178,
   179,   173,   172,   174,   175,   181,   182,   130,     0,   127,
   183,   180,   176,   177,   171,     0,     0,   228,   178,   179,
   173,   172,   174,   175,   181,   182,   278,   280,     0,   183,
   180,   176,   177,   171,   246,   178,   179,   173,   172,   174,
   175,   181,   182,   308,   310,   309,   183,   180,   176,   177,
   171,   173,   172,   174,   175,   181,   182,   298,     0,    25,
   183,   180,   176,   177,   171,   312,    91,   313,     0,   143,
     0,     0,     0,     0,   298,    31,   298,     0,     0,     0,
     0,    28,    35,    38,     0,     9,    36,    37,     0,    39,
    13,    35,    38,     0,    11,    36,    37,     0,    39,     8,
    15,     0,    33,    14,     0,     0,     0,     0,     0,    16,
     0,    33,     0,     0,     0,     0,     0,    12,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   227,     0,     0,
     0,     0,   104,     0,     0,     0,   106,     0,     0,     0,
     0,     0,     0,   237,   238,   239,     0,     0,     0,   242,
   114,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   132,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,   255,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,   273,     0,     0,     0,     0,     0,   276,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,   211,
     0,     0,     0,     0,   290,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,   232,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,     0,     0,   271 };
yytabelem yypact[]={

   119,-10000000,   359,-10000000,-10000000,-10000000,-10000000,-10000000,    88,-10000000,
    86,  -118,   -63,-10000000,-10000000,-10000000,-10000000,   -70,   -71,   118,
     3,     3,   349,   177,-10000000,  -265,-10000000,-10000000,  -190,  -194,
-10000000,-10000000,    80,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,    31,
    24,    14,     6,    18,  -165,    85,   -72,   -73,   -74,   -75,
   -13,   -18,    82,   -80,    81,  -119,  -120,   340,-10000000,  -160,
-10000000,  -166,  -167,  -169,  -173,    28,-10000000,-10000000,   -84,    70,
    55,    51,     3,-10000000,-10000000,   -85,     3,-10000000,   103,   106,
-10000000,-10000000,     4,-10000000,-10000000,-10000000,-10000000,  -202,-10000000,-10000000,
     3,  -260,  -178,  -180,  -205,    49,  -206,     2,-10000000,    10,
-10000000,  -225,-10000000,    80,  -207,     3,   -92,   -92,  -181,  -267,
   -30,    45,-10000000,-10000000,    -3,-10000000,-10000000,    84,  -182,-10000000,
-10000000,  -185,  -226,  -228,   272,-10000000,  -153,-10000000,   150,   150,
   150,-10000000,-10000000,  -230,-10000000,  -162,  -125,-10000000,-10000000,  -280,
    73,   -86,   -96,    36,  -100,  -102,  -105,  -106,  -107,  -186,
  -109,-10000000,  -155,-10000000,    28,-10000000,-10000000,-10000000,  -187,     3,
   150,   150,   150,   150,   150,   150,   150,   150,   150,   150,
   150,   150,   150,   150,   150,   -92,   -79,-10000000,   -81,   236,
  -188,  -233,-10000000,   272,-10000000,     3,   150,-10000000,   150,   150,
  -115,   -92,   -92,   -92,    19,   150,-10000000,   -92,   150,  -248,
-10000000,  -235,   272,   255,   -88,   -88,   -88,   -88,   -88,   -88,
   286,   286,   -81,   -81,   -79,   -79,   120,  -238,-10000000,-10000000,
-10000000,  -240,  -264,    25,   217,   198,   -92,  -250,  -292,  -251,
  -295,   178,  -266,    97,-10000000,  -196,   150,  -158,-10000000,   272,
-10000000,   -45,-10000000,  -126,  -142,  -269,  -197,     3,  -198,   -92,
  -200,  -208,  -158,-10000000,   272,   -92,  -143,    98,    98,  -213,
-10000000,  -311,-10000000,  -284,-10000000,-10000000,  -303,   -15,   -68,-10000000,
  -157,-10000000,   -92,  -239,-10000000,  -277,   126,-10000000,    -5,-10000000,
  -304,-10000000,  -144,   -64,  -294,-10000000,-10000000,-10000000,-10000000,-10000000,
  -152,  -245,   103,   126,-10000000,    92,    98,-10000000,     2,  -296,
-10000000,-10000000,  -227,  -255,-10000000,-10000000,-10000000 };
yytabelem yypgo[]={

     0,   466,   465,   458,   457,   453,   451,   589,   270,   288,
   448,   447,   443,   441,   439,   271,   268,   300,   438,   437,
   430,   436,   434,   432,   431,   481,   422,   421,     0,   387,
   429,   388,   353,   410,   411,   399,   423,   400 };
yytabelem yyr1[]={

     0,     1,     1,     2,     2,     2,     2,     2,     2,     3,
     3,     4,     4,     5,     5,     6,     6,    14,    14,    14,
    14,    15,    15,    15,    16,    16,    16,    13,    13,    13,
    18,    18,    18,    18,    18,    18,    18,    19,    19,    19,
    19,    19,    21,    22,    22,    23,    23,    24,    24,     9,
     9,     9,    26,    26,    26,    26,    26,    26,    26,    26,
    26,    26,    26,    26,    26,    26,    27,    27,    27,     7,
     7,     7,     7,    11,    11,    11,    11,     8,     8,     8,
    20,    20,    20,    20,    12,    12,    12,    34,    34,    34,
    29,    29,    32,    32,    32,    36,    36,    36,    31,    31,
    31,    31,    31,    31,    35,    35,    35,    33,    33,    30,
    30,    30,    30,    30,    30,    10,    10,    10,    10,    10,
    28,    28,    28,    28,    28,    28,    28,    28,    28,    28,
    28,    28,    28,    28,    28,    28,    28,    28,    28,    28,
    28,    28,    25,    25,    25,    25,    37,    37,    37,    37,
    37,    17,    17,    17 };
yytabelem yyr2[]={

     0,     2,     3,     5,     5,     5,     5,     0,     3,    19,
     3,    19,     3,     9,     3,    39,     3,    11,     7,     1,
     3,     7,     3,     3,     3,     3,     3,     5,     1,     3,
     3,     3,     3,     3,     3,     3,     3,     7,     7,     7,
     7,     3,    15,    19,     3,    15,     3,    11,     3,     5,
     1,     3,     9,     5,    15,    23,    15,    13,    11,    19,
    11,    15,    11,     5,    11,     3,     3,     9,     3,     7,
     3,     1,     3,     7,     3,     1,     3,     5,     1,     3,
     9,     5,    13,     3,     5,     1,     3,     9,     5,     3,
     5,     3,     7,     3,     3,     3,     9,     3,     3,     3,
     3,     3,     3,     3,     3,     3,     3,    15,     3,     3,
     3,     5,     5,     1,     3,     3,     3,     3,     3,     3,
     3,     3,     9,     9,    15,    11,     7,     7,     7,     7,
     7,     7,     7,     7,     7,     7,     7,     7,     5,     5,
     7,     3,     7,     3,     1,     3,     7,     7,     3,     3,
     3,     3,     3,     3 };
yytabelem yychk[]={

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

    -2,    -2,    -2,    -2,     3,     4,     5,     6,     0,    -2,
     0,     0,     0,   115,   116,   117,   118,     0,     0,    -2,
    -2,    -2,    -2,    -2,    29,     0,    70,    72,     0,     0,
    74,    -2,     0,   104,   105,    98,    99,   100,   101,   102,
    13,    27,    30,    31,    32,    33,    34,    35,    -2,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
   109,   110,     0,     0,     0,     0,     0,     0,    90,    95,
    97,     0,     0,     0,     0,     0,   103,    81,     0,     0,
     0,     0,    -2,   111,   112,     0,    -2,    69,    -2,    -2,
    73,    -2,     0,    37,    38,    39,    40,     0,    93,    94,
    -2,     0,     0,     0,     0,     0,     0,    -2,    79,    -2,
    86,     0,    80,     0,     0,    -2,    -2,    -2,     0,     0,
     0,     0,    77,    -2,     0,    84,    -2,     0,     0,    96,
    92,     0,     0,     0,   143,   141,   120,   121,     0,     0,
     0,   151,   152,     0,    47,     0,     0,     9,    49,     0,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,    -2,    -2,    11,     0,   103,    88,    82,     0,    -2,
     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
     0,     0,     0,     0,     0,    -2,   138,   141,   139,     0,
     0,     0,   148,   149,   141,    -2,     0,    53,     0,     0,
     0,    -2,    -2,    -2,     0,     0,    63,    -2,     0,     0,
    42,     0,   142,     0,    -2,    -2,    -2,    -2,    -2,    -2,
   132,   133,   134,   135,   136,   137,     0,     0,   140,    45,
   107,     0,     0,     0,     0,     0,    -2,     0,     0,     0,
     0,     0,     0,     0,    87,     0,     0,   122,   123,   146,
   147,     0,    52,     0,     0,     0,     0,    -2,     0,    -2,
     0,     0,    -2,    43,   125,    -2,     0,    -2,    -2,     0,
    58,     0,    60,     0,    62,    64,     0,    -2,     0,    51,
     0,    57,    -2,     0,   124,     0,     0,    20,    54,    56,
     0,    61,     0,     0,     0,    22,    23,    24,    25,    26,
     0,     0,    -2,     0,    18,     0,    -2,    59,    -2,     0,
    21,   153,     0,     0,    17,    55,    15 };
typedef struct
#ifdef __cplusplus
	yytoktype
#endif
{ char *t_name; int t_val; } yytoktype;
#ifndef YYDEBUG
#	define YYDEBUG	1	/* allow debugging */
#endif

#if YYDEBUG

yytoktype yytoks[] =
{
	"IDENT",	257,
	"INTGR",	258,
	"NUMBER",	259,
	"STRCONST",	260,
	"AOPCODE",	261,
	"ELSE",	262,
	"EXPORTS",	263,
	"EXTEND",	264,
	"GLOBAL",	265,
	"IF",	266,
	"IMPORTS",	267,
	"INCHANNELS",	268,
	"INPUTMOD",	269,
	"INSTR",	270,
	"IOPCODE",	271,
	"IVAR",	272,
	"TABLE",	273,
	"KOPCODE",	274,
	"KRATE",	275,
	"KSIG",	276,
	"ASIG",	277,
	"MAP",	278,
	"OPARRAY",	279,
	"OPCODE",	280,
	"OUTBUS",	281,
	"OUTCHANNELS",	282,
	"OUTPUT",	283,
	"ROUTE",	284,
	"SEND",	285,
	"SEQUENCE",	286,
	"SRATE",	287,
	"TEMPLATE",	288,
	"TURNOFF",	289,
	"WHILE",	290,
	"WITH",	291,
	"XSIG",	292,
	"AND",	293,
	"OR",	294,
	"GEQ",	295,
	"LEQ",	296,
	"NEQ",	297,
	"EQEQ",	298,
	"MINUS",	299,
	"STAR",	300,
	"SPATIALIZE",	301,
	"SFSYNTH",	302,
	"TABLEMAP",	303,
	"SLASH",	304,
	"PLUS",	305,
	"GT",	306,
	"LT",	307,
	"Q",	308,
	"COL",	309,
	"LP",	310,
	"RP",	311,
	"LC",	312,
	"RC",	313,
	"LB",	314,
	"RB",	315,
	"SEM",	316,
	"COM",	317,
	"EQ",	318,
	"RETURN",	319,
	"NOT",	320,
	"ARRAYREF",	321,
	"OPCALL",	322,
	"IMPEXP",	323,
	"VARDECL",	324,
	"NOTAG",	325,
	"SPECIALOP",	326,
	"UNOT",	327,
	"UMINUS",	328,
	"HIGHEST",	329,
	"-unknown-",	-1	/* ends search */
};

char * yyreds[] =
{
	"-no such reduction-",
	"orcfile : proclist",
	"orcfile : error",
	"proclist : proclist instrdecl",
	"proclist : proclist opcodedecl",
	"proclist : proclist globaldecl",
	"proclist : proclist templatedecl",
	"proclist : /* empty */",
	"proclist : error",
	"instrdecl : INSTR IDENT LP identlist RP LC vardecls block RC",
	"instrdecl : error",
	"opcodedecl : optype IDENT LP paramlist RP LC opvardecls block RC",
	"opcodedecl : error",
	"globaldecl : GLOBAL LC globalblock RC",
	"globaldecl : error",
	"templatedecl : TEMPLATE LT identlist GT LP identlist RP MAP LC identlist RC WITH LC mapblock RC LC vardecls block RC",
	"templatedecl : error",
	"mapblock : mapblock COM LT terminal_list GT",
	"mapblock : LT terminal_list GT",
	"mapblock : /* empty */",
	"mapblock : error",
	"terminal_list : terminal_list COM terminal",
	"terminal_list : terminal",
	"terminal_list : error",
	"terminal : IDENT",
	"terminal : const",
	"terminal : STRCONST",
	"globalblock : globalblock globaldef",
	"globalblock : /* empty */",
	"globalblock : error",
	"globaldef : rtparam",
	"globaldef : vardecl",
	"globaldef : routedef",
	"globaldef : senddef",
	"globaldef : inputmoddef",
	"globaldef : seqdef",
	"globaldef : error",
	"rtparam : SRATE INTGR SEM",
	"rtparam : KRATE INTGR SEM",
	"rtparam : INCHANNELS INTGR SEM",
	"rtparam : OUTCHANNELS INTGR SEM",
	"rtparam : error",
	"routedef : ROUTE LP IDENT COM identlist RP SEM",
	"senddef : SEND LP IDENT SEM exprlist SEM identlist RP SEM",
	"senddef : error",
	"inputmoddef : INPUTMOD LP IDENT SEM exprlist RP SEM",
	"inputmoddef : error",
	"seqdef : SEQUENCE LP identlist RP SEM",
	"seqdef : error",
	"block : block statement",
	"block : /* empty */",
	"block : error",
	"statement : lvalue EQ expr SEM",
	"statement : expr SEM",
	"statement : IF LP expr RP LC block RC",
	"statement : IF LP expr RP LC block RC ELSE LC block RC",
	"statement : WHILE LP expr RP LC block RC",
	"statement : INSTR IDENT LP exprlist RP SEM",
	"statement : OUTPUT LP exprlist RP SEM",
	"statement : SFSYNTH LP exprlist SEM identlist SEM exprlist RP SEM",
	"statement : SPATIALIZE LP exprlist RP SEM",
	"statement : OUTBUS LP IDENT COM exprlist RP SEM",
	"statement : EXTEND LP expr RP SEM",
	"statement : TURNOFF SEM",
	"statement : RETURN LP exprlist RP SEM",
	"statement : error",
	"lvalue : IDENT",
	"lvalue : IDENT LB expr RB",
	"lvalue : error",
	"identlist : identlist COM IDENT",
	"identlist : IDENT",
	"identlist : /* empty */",
	"identlist : error",
	"paramlist : paramlist COM paramdecl",
	"paramlist : paramdecl",
	"paramlist : /* empty */",
	"paramlist : error",
	"vardecls : vardecls vardecl",
	"vardecls : /* empty */",
	"vardecls : error",
	"vardecl : taglist stype namelist SEM",
	"vardecl : tabledecl SEM",
	"vardecl : TABLEMAP IDENT LP identlist RP SEM",
	"vardecl : error",
	"opvardecls : opvardecls opvardecl",
	"opvardecls : /* empty */",
	"opvardecls : error",
	"opvardecl : taglist otype namelist SEM",
	"opvardecl : tabledecl SEM",
	"opvardecl : error",
	"paramdecl : otype name",
	"paramdecl : error",
	"namelist : namelist COM name",
	"namelist : name",
	"namelist : error",
	"name : IDENT",
	"name : IDENT LB INTGR RB",
	"name : error",
	"stype : IVAR",
	"stype : KSIG",
	"stype : ASIG",
	"stype : TABLE",
	"stype : OPARRAY",
	"stype : error",
	"otype : XSIG",
	"otype : stype",
	"otype : error",
	"tabledecl : TABLE IDENT LP IDENT COM exprstrlist RP",
	"tabledecl : error",
	"taglist : IMPORTS",
	"taglist : EXPORTS",
	"taglist : IMPORTS EXPORTS",
	"taglist : EXPORTS IMPORTS",
	"taglist : /* empty */",
	"taglist : error",
	"optype : AOPCODE",
	"optype : KOPCODE",
	"optype : IOPCODE",
	"optype : OPCODE",
	"optype : error",
	"expr : IDENT",
	"expr : const",
	"expr : IDENT LB expr RB",
	"expr : IDENT LP exprlist RP",
	"expr : IDENT LB expr RB LP exprlist RP",
	"expr : expr Q expr COL expr",
	"expr : expr LEQ expr",
	"expr : expr GEQ expr",
	"expr : expr NEQ expr",
	"expr : expr EQEQ expr",
	"expr : expr GT expr",
	"expr : expr LT expr",
	"expr : expr AND expr",
	"expr : expr OR expr",
	"expr : expr PLUS expr",
	"expr : expr MINUS expr",
	"expr : expr STAR expr",
	"expr : expr SLASH expr",
	"expr : NOT expr",
	"expr : MINUS expr",
	"expr : LP expr RP",
	"expr : error",
	"exprlist : exprlist COM expr",
	"exprlist : expr",
	"exprlist : /* empty */",
	"exprlist : error",
	"exprstrlist : exprstrlist COM expr",
	"exprstrlist : exprstrlist COM STRCONST",
	"exprstrlist : STRCONST",
	"exprstrlist : expr",
	"exprstrlist : error",
	"const : INTGR",
	"const : NUMBER",
	"const : error",
};
#endif /* YYDEBUG */
/* 
 *	Copyright 1987 Silicon Graphics, Inc. - All Rights Reserved
 */

/* #ident	"@(#)yacc:yaccpar	1.10" */
#ident	"$Revision: 1.10 $"

/*
** Skeleton parser driver for yacc output
*/
#include "stddef.h"

/*
** yacc user known macros and defines
*/
#define YYERROR		goto yyerrlab
#define YYACCEPT	return(0)
#define YYABORT		return(1)
#ifdef __cplusplus
#define YYBACKUP( newtoken, newvalue )\
{\
	if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
	{\
		yyerror( gettxt("uxlibc:78", "syntax error - cannot backup") );\
		goto yyerrlab;\
	}\
	yychar = newtoken;\
	yystate = *yyps;\
	yylval = newvalue;\
	goto yynewstate;\
}
#else
#define YYBACKUP( newtoken, newvalue )\
{\
	if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
	{\
		yyerror( gettxt("uxlibc:78", "Syntax error - cannot backup") );\
		goto yyerrlab;\
	}\
	yychar = newtoken;\
	yystate = *yyps;\
	yylval = newvalue;\
	goto yynewstate;\
}
#endif
#define YYRECOVERING()	(!!yyerrflag)
#define YYNEW(type)	malloc(sizeof(type) * yynewmax)
#define YYCOPY(to, from, type) \
	(type *) memcpy(to, (char *) from, yynewmax * 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 */



/*
** 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;	/* top of value stack for $vars */

	/*
	** 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)
		{
#ifdef __cplusplus
			yyerror(gettxt("uxlibc:79", "yacc initialization error"));
#else
			yyerror(gettxt("uxlibc:79", "Yacc initialization error"));
#endif
			YYABORT;
		}
	}
#endif

	goto yystack;
	{
		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 */

		/*
		** 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? */
		{
			int yynewmax;
			ptrdiff_t yys_off;

			/* The following pointer-differences are safe, since
			 * yypvt, yy_pv, and yypv all are a multiple of
			 * sizeof(YYSTYPE) bytes from yyv.
			 */
			ptrdiff_t yypvt_off = yypvt - yyv;
			ptrdiff_t yy_pv_off = yy_pv - yyv;
			ptrdiff_t yypv_off = yypv - yyv;

			int *yys_base = yys;
#ifdef YYEXPAND
			yynewmax = YYEXPAND(yymaxdepth);
#else
			yynewmax = 2 * yymaxdepth;	/* double table size */
			if (yymaxdepth == YYMAXDEPTH)	/* first time growth */
			{
				void *newyys = YYNEW(int);
				void *newyyv = 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 */
			{
#ifdef __cplusplus
				yyerror( gettxt("uxlibc:80", "yacc stack overflow") );
#else
				yyerror( gettxt("uxlibc:80", "Yacc stack overflow") );
#endif
				YYABORT;
			}
			yymaxdepth = yynewmax;

			/* reset pointers into yys */
			yys_off = yys - yys_base;
			yy_ps = yy_ps + yys_off;
			yyps = yyps + yys_off;

			/* reset pointers into yyv */
			yypvt = yyv + yypvt_off;
			yy_pv = yyv + yy_pv_off;
			yypv = yyv + yypv_off;
		}
		*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 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 */
#ifdef __cplusplus
				yyerror( gettxt("uxlibc:81", "syntax error") );
#else
				yyerror( gettxt("uxlibc:81", "Syntax error") );
#endif
				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;
				yynerrs++;
				/* FALLTHRU */
			skip_init:
			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 2:{ parse_error("Error in orcfile"); } break;
case 3:{
		      if (!cur_sa->all->il)
			 cur_sa->all->il = new_instr_list();
		      add_instr_list(cur_sa->all->il,ptr_index(yypvt[-0]));
		      printf("Read instr %s.\n",((instr_decl *)ptr_index(yypvt[-0]))->name);
		      } break;
case 4:{
		      if (!cur_sa->all->op)
		        cur_sa->all->op = new_opcode_list();
		      add_opcode_list(cur_sa->all->op,ptr_index(yypvt[-0]));
		      printf("Read opcode %s.\n",((opcode_decl *)ptr_index(yypvt[-0]))->name);
		      } break;
case 5:{
		      printf("Read global block.\n");
		      } break;
case 6:{
		      deal_with_template(cur_sa,ptr_index(yypvt[-0]));
		      } break;
case 8:{ parse_error("Error in proclist."); } break;
case 9:{
		      instr_decl *i;

		      i = new_instr_decl(ptr_index(yypvt[-7]),ptr_index(yypvt[-5]),
		                         ptr_index(yypvt[-2]),ptr_index(yypvt[-1]));
		      yyval = add_ptr_index(i);
		      } break;
case 10:{ parse_error("Error in instr."); } break;
case 11:{
		      opcode_decl *o;

		      o = new_opcode_decl(ptr_index(yypvt[-7]),ptr_index(yypvt[-5]),
		                          ptr_index(yypvt[-2]),ptr_index(yypvt[-1]),
					  yypvt[-8]);
		      yyval = add_ptr_index(o);
		      } break;
case 12:{ parse_error("Error in opcode."); } break;
case 13:{
		      if (!cur_sa->all->g) 
		         cur_sa->all->g = new_orc_global();
		      else
		         warn_line("Using multiple global blocks.",yyline);
		      sort_global_decls(cur_sa,cur_sa->all->g,ptr_index(yypvt[-1]));
		      } break;
case 14:{ parse_error("Error in global block."); } break;
case 15:{
		       template_decl *t;

		       t = new_template_decl(ptr_index(yypvt[-16]),ptr_index(yypvt[-13]),
		                             ptr_index(yypvt[-9]),ptr_index(yypvt[-5]),
					     ptr_index(yypvt[-2]),ptr_index(yypvt[-1]));
		       yyval = add_ptr_index(t);
		       } break;
case 16:{ parse_error("Error in template."); } break;
case 17:{
		       add_mapblock(ptr_index(yypvt[-4]),ptr_index(yypvt[-1]));
		       yyval = yypvt[-4];
		       } break;
case 18:{
		       mapblock *map;

		       map = new_mapblock(ptr_index(yypvt[-1]));
		       yyval = add_ptr_index(map);
		       } break;
case 19:{ parse_error("Empty map block not allowed."); } break;
case 20:{ parse_error("Bad map block."); } break;
case 21:{
		     add_terminal_list(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]));
		     yyval = yypvt[-2];
		     } break;
case 22:{
		     terminal_list *tl;
		     tl = new_terminal_list(ptr_index(yypvt[-0]));
		     yyval = add_ptr_index(tl);
		     } break;
case 23:{ parse_error("Bad values for mapping."); } break;
case 24:{
		     terminal *t;
		     t = new_terminal(IDENT,ptr_index(yypvt[-0]));
		     yyval = add_ptr_index(t);
		     } break;
case 25:{
		     terminal *t;
		     t = new_terminal(NUMBER,ptr_index(yypvt[-0]));
		     yyval = add_ptr_index(t);
		     } break;
case 26:{
		     terminal *t;
		     t = new_terminal(STRCONST, ptr_index(yypvt[-0]));
		     yyval = add_ptr_index(t);
		     } break;
case 27:{
		     add_gblock(ptr_index(yypvt[-1]),ptr_index(yypvt[-0]));
		     } break;
case 28:{
		     global_block *gb;
		     
		     gb = new_gblock();
		     yyval = add_ptr_index(gb);
		     } break;
case 29:{ parse_error("Bad global block."); } break;
case 30:{ yyval = yypvt[-0]; } break;
case 31:{
		      global_decl *g;
		      g = new_global(VARDECL);
		      set_global_vardecl(g,ptr_index(yypvt[-0]));
		      yyval = add_ptr_index(g);
		      } break;
case 32:{ yyval = yypvt[-0]; } break;
case 33:{ yyval = yypvt[-0]; } break;
case 34:{ yyval = yypvt[-0]; } break;
case 35:{ yyval = yypvt[-0]; } break;
case 36:{ parse_error("Bad global declaration"); } break;
case 37:{
		     global_decl *g;

		     g = new_global(SRATE);
		     set_global_rtparam(g,atoi(ptr_index(yypvt[-1])));
		     yyval = add_ptr_index(g);
		     } break;
case 38:{
		     global_decl *g;

		     g = new_global(KRATE);
		     set_global_rtparam(g,atoi(ptr_index(yypvt[-1])));
		     yyval = add_ptr_index(g);
		     } break;
case 39:{
		     global_decl *g;

		     g = new_global(INCHANNELS);
		     set_global_rtparam(g,atoi(ptr_index(yypvt[-1])));
		     yyval = add_ptr_index(g);
		     } break;
case 40:{
		     global_decl *g;

		     g = new_global(OUTCHANNELS);
		     set_global_rtparam(g,atoi(ptr_index(yypvt[-1])));
		     yyval = add_ptr_index(g);
		     } break;
case 41:{ parse_error("Bad real-time parameter."); } break;
case 42:{
                     global_decl *g;
		     routedef *r;

		     r = new_routedef(ptr_index(yypvt[-4]),ptr_index(yypvt[-2]));
		     g = new_global(ROUTE);
		     set_global_routedef(g,r);
		     yyval = add_ptr_index(g);
		     } break;
case 43:{
		     global_decl *g;
		     senddef *s;

		     s = new_senddef(ptr_index(yypvt[-6]),ptr_index(yypvt[-4]),
		                     ptr_index(yypvt[-2]));
		     g = new_global(SEND);
		     set_global_senddef(g,s);
		     yyval = add_ptr_index(g);
		     } break;
case 44:{ parse_error("Bad send definition."); } break;
case 45:{
		     global_decl *g;
		     inputmod *inmod;

		     inmod = new_inmod(ptr_index(yypvt[-4]),ptr_index(yypvt[-2]));
		     g = new_global(INPUTMOD);
		     set_global_inputmod(g,inmod);
		     yyval = add_ptr_index(g);
		     } break;
case 46:{ parse_error("Bad input modifier."); } break;
case 47:{
		     global_decl *g;
		     seqdef *s;
		     
		     s = new_seqdef(ptr_index(yypvt[-2]));
		     g = new_global(SEQUENCE);
		     set_global_seqdef(g,s);
		     yyval = add_ptr_index(g);
		     } break;
case 48:{ parse_error("Bad sequence."); } break;
case 49:{
		      add_block(ptr_index(yypvt[-1]),ptr_index(yypvt[-0]));
		      yyval = yypvt[-1];
		      } break;
case 50:{
		      block *b;
		      long i;

		      b = new_block();
		      i = add_ptr_index(b);
		      yyval = i;
		      } break;
case 51:{ parse_error("; exprected"); } break;
case 52:{
		      statement *st;
		      long i;
		    
 		      st = new_statement(EQ,ptr_index(yypvt[-1]),NULL);
		      set_statement_lvalue(st,ptr_index(yypvt[-3]));
		      i = add_ptr_index(st);
		      yyval = i;
		      } break;
case 53:{ /* null assign */
		      statement *st;
		      st = new_statement(EQ,ptr_index(yypvt[-1]),NULL);
		      yyval = add_ptr_index(st);
		      } break;
case 54:{
		      statement *st;
		      long i;

		      st = new_statement(IF,ptr_index(yypvt[-4]),ptr_index(yypvt[-1]));
		      i = add_ptr_index(st);
		      yyval = i;
		      } break;
case 55:{
		      statement *st;
		      long i;

		      st = new_statement(ELSE,ptr_index(yypvt[-8]),ptr_index(yypvt[-5]));
		      set_statement_else(st,ptr_index(yypvt[-1]));
		      i = add_ptr_index(st);
		      yyval = i;
		      } break;
case 56:{
		      statement *st;
		      long i;

		      st = new_statement(WHILE,ptr_index(yypvt[-4]),ptr_index(yypvt[-1]));
		      i = add_ptr_index(st);
		      yyval = i;
		      } break;
case 57:{
		      statement *st;
		      
		      st = new_statement(INSTR,NULL,NULL);
		      set_statement_iname(st,ptr_index(yypvt[-4]));
		      set_statement_params(st,ptr_index(yypvt[-2]));
		      yyval = add_ptr_index(st);
		      } break;
case 58:{
		      statement *st;
		      long i;

		      st = new_statement(OUTPUT,NULL,NULL);
		      set_statement_params(st,ptr_index(yypvt[-2]));
		      i = add_ptr_index(st);
		      yyval = i;
		      } break;
case 59:{
		      statement *st;
		      long i;

		      st = new_statement(SFSYNTH,NULL,NULL);
		      set_statement_params(st,ptr_index(yypvt[-6]));
		      st->sfbusses = ptr_index(yypvt[-4]);
		      st->sfextra = ptr_index(yypvt[-2]);
		      yyval = add_ptr_index(st);
		      } break;
case 60:{
		      statement *st;
		      st = new_statement(SPATIALIZE, NULL, NULL);
		      set_statement_params(st,ptr_index(yypvt[-2]));
		      yyval = add_ptr_index(st);
		      } break;
case 61:{
		      statement *st;
		      long i;

      		      st = new_statement(OUTBUS,NULL,NULL);
		      set_statement_bus(st,ptr_index(yypvt[-4]));
		      set_statement_params(st,ptr_index(yypvt[-2]));
		      i = add_ptr_index(st);
		      yyval = i;
		      } break;
case 62:{
		      statement *st;
		      st = new_statement(EXTEND,ptr_index(yypvt[-2]),NULL);
		      yyval = add_ptr_index(st);
		      } break;
case 63:{
		      statement *st;
		      st = new_statement(TURNOFF,NULL,NULL);
		      yyval = add_ptr_index(st);
		      } break;
case 64:{ 
		      statement *st;
		      long i;

		      st = new_statement(RETURN,NULL,NULL);
		      st->params = ptr_index(yypvt[-2]);
		      i = add_ptr_index(st);
		      yyval = i;
		      } break;
case 65:{ parse_error("Bad statement."); } break;
case 66:{
		      terminal *t;
		      expr *p;

		      t = new_terminal(IDENT,ptr_index(yypvt[-0]));
		      p = new_expr(NULL,NULL,NULL,IDENT);
		      set_expr_data(p,t);
		      yyval = add_ptr_index(p);
		      } break;
case 67:{
		      terminal *t;
		      expr *p;

		      t = new_terminal(IDENT,ptr_index(yypvt[-3]));
		      p = new_expr(ptr_index(yypvt[-1]),NULL,NULL,ARRAYREF);
		      set_expr_data(p,t);
		      yyval = add_ptr_index(p);
		      } break;
case 68:{ parse_error("Bad lvalue in exprression"); } break;
case 69:{
		      name *v;
		      v = new_name(ptr_index(yypvt[-0]),1);
		      add_namelist(ptr_index(yypvt[-2]),v);
		      yyval = yypvt[-2];
		      } break;
case 70:{
		      name *v;
		      namelist *nl;

		      v = new_name(ptr_index(yypvt[-0]),1);
		      nl = new_namelist(v);
		      yyval = add_ptr_index(nl);
		      } break;
case 71:{
		      namelist *nl;

		      nl = new_namelist(NULL);
		      yyval = add_ptr_index(nl);
		      } break;
case 72:{ parse_error("Bad identifier list."); } break;
case 73:{
		      add_formalparam_list(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]));
		      yyval = yypvt[-2];
		      } break;
case 74:{
		      formalparam_list *fpl;

		      fpl = new_formalparam_list();
		      add_formalparam_list(fpl,ptr_index(yypvt[-0]));
		      yyval = add_ptr_index(fpl);
		      } break;
case 75:{
		      formalparam_list *fpl;

		      fpl = new_formalparam_list();
		      yyval = add_ptr_index(fpl);
		      } break;
case 76:{ parse_error("Bad parameter list."); } break;
case 77:{
		     add_vardecl_list(ptr_index(yypvt[-1]),ptr_index(yypvt[-0]));
		     yyval = yypvt[-1];
		     } break;
case 78:{
		     vardecl_list *vdl;

		     vdl = new_vardecl_list();
		     yyval = add_ptr_index(vdl);
		     } break;
case 79:{ parse_error("Bad declaration list."); } break;
case 80:{ 
		     vardecl *v;

		     v = new_vardecl(yypvt[-2],yypvt[-3],ptr_index(yypvt[-1]));
		     yyval = add_ptr_index(v);
		     } break;
case 81:{
		     vardecl *v;
		     v = new_vardecl(TABLE,NOTAG,NULL);
		     set_vardecl_tabledef(v,ptr_index(yypvt[-1]));
		     yyval = add_ptr_index(v);
		     } break;
case 82:{
		     vardecl *v;
		     v = new_vardecl(TABLEMAP,NOTAG,ptr_index(yypvt[-2]));
		     v->tablemap_name =  ptr_index(yypvt[-4]);
		     yyval = add_ptr_index(v);
		     } break;
case 83:{ parse_error("Bad declaration."); } break;
case 84:{
		     add_vardecl_list(ptr_index(yypvt[-1]),ptr_index(yypvt[-0]));
		     yyval = yypvt[-1];
		     } break;
case 85:{
		     vardecl_list *vdl;

		     vdl = new_vardecl_list();
		     yyval = add_ptr_index(vdl);
		     } break;
case 86:{ parse_error("Bad declaration list."); } break;
case 87:{
                     vardecl *v;

		     v = new_vardecl(yypvt[-2],yypvt[-3],ptr_index(yypvt[-1]));
		     yyval = add_ptr_index(v);
		     } break;
case 88:{
		     vardecl *v;
		     v = new_vardecl(TABLE,NOTAG,NULL);
		     set_vardecl_tabledef(v,ptr_index(yypvt[-1]));
		     yyval = add_ptr_index(v);
		     } break;
case 89:{ parse_error("Bad declaration."); } break;
case 90:{
		     formalparam *fp;

		     fp = new_formalparam(yypvt[-1],ptr_index(yypvt[-0]));
		     yyval = add_ptr_index(fp);
		     } break;
case 91:{ parse_error("Bad parameter."); } break;
case 92:{
		      add_namelist(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]));
		      yyval = yypvt[-2];
		      } break;
case 93:{
		      namelist *v;
		      v = new_namelist(ptr_index(yypvt[-0]));
		      yyval = add_ptr_index(v);
		      } break;
case 94:{ parse_error("Bad variable list."); } break;
case 95:{
		      name *v;
		      v = new_name(ptr_index(yypvt[-0]),1);
		      yyval = add_ptr_index(v);
		      } break;
case 96:{
					/* add expressions here */
		      name *v;
		      v = new_name(ptr_index(yypvt[-3]),atoi(ptr_index(yypvt[-1])));
		      yyval = add_ptr_index(v);
		      } break;
case 97:{ parse_error("Bad variable declaration."); } break;
case 98:{ yyval = IVAR; } break;
case 99:{ yyval = KSIG; } break;
case 100:{ yyval = ASIG; } break;
case 101:{ yyval = TABLE; } break;
case 102:{ yyval = OPARRAY; } break;
case 103:{ parse_error("Unexpected type."); } break;
case 104:{ yyval = XSIG; } break;
case 105:{ yyval = yypvt[-0]; } break;
case 106:{ parse_error("Unexpected opcode type."); } break;
case 107:{
		      tabledef *t;

		      t = new_tabledef(ptr_index(yypvt[-5]),ptr_index(yypvt[-3]),
		                        ptr_index(yypvt[-1]));
		      yyval = add_ptr_index(t);
		      } break;
case 108:{ parse_error("Table placeholder must be global."); } break;
case 109:{ yyval = IMPORTS; } break;
case 110:{ yyval = EXPORTS; } break;
case 111:{ yyval = IMPEXP; } break;
case 112:{ yyval = IMPEXP; } break;
case 113:{yyval = NOTAG; } break;
case 114:{ parse_error("Unknown tag."); } break;
case 115:{ yyval = AOPCODE; } break;
case 116:{ yyval = KOPCODE; } break;
case 117:{ yyval = IOPCODE; } break;
case 118:{ yyval = OPCODE; } break;
case 119:{ parse_error("Invalid opcode type."); } break;
case 120:{
		      expr *p;
		      terminal *t;
		      long i;

		      p = new_expr(NULL,NULL,NULL,IDENT);
		      t = new_terminal(IDENT,ptr_index(yypvt[-0]));
		      set_expr_data(p,t);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 121:{
		      long i;
		      expr *p;
		      terminal *t;

		      p = new_expr(NULL,NULL,NULL,NUMBER);
		      t = new_terminal(NUMBER,ptr_index(yypvt[-0]));
		      set_expr_data(p,t);

		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 122:{ /* array reference */
		      long i;
		      expr *p;
		      terminal *t;

		      t = new_terminal(IDENT,ptr_index(yypvt[-3]));
		      p = new_expr(ptr_index(yypvt[-1]),NULL,NULL,ARRAYREF);
		      set_expr_data(p,t);

		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 123:{ /* opcode call */
		      long i;
		      expr *p;
		      terminal *t;

		      t = new_terminal(IDENT,ptr_index(yypvt[-3]));
		      p = new_expr(NULL,NULL,NULL,OPCALL);
		      set_expr_params(p,ptr_index(yypvt[-1]));
		      set_expr_data(p,t);

		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 124:{ /* oparray call */
		      expr *p;
                      terminal *t;

                      t = new_terminal(IDENT,ptr_index(yypvt[-6]));
		      p = new_expr(ptr_index(yypvt[-4]),NULL,NULL,OPARRAY);
		      set_expr_params(p,ptr_index(yypvt[-1]));
		      set_expr_data(p,t);
		      yyval = add_ptr_index(p);
		      } break;
case 125:{ /* a ? b : c */
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-4]),ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),Q);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 126:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,LEQ);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 127:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,GEQ);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 128:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,NEQ);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 129:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,EQEQ);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 130:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,GT);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 131:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,LT);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 132:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,AND);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 133:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,OR);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 134:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,PLUS);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 135:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,MINUS);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 136:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,STAR);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 137:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]),NULL,SLASH);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 138:{
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-0]),NULL,NULL,NOT);
		      yyval = add_ptr_index(p);
		      } break;
case 139:{
		      long i;
		      expr *p;

		      p = new_expr(ptr_index(yypvt[-0]),NULL,NULL,UMINUS);
		      i = add_ptr_index(p);
		      yyval = i;
		      } break;
case 140:{
		     long i;
		     expr *p;
		     p = new_expr(ptr_index(yypvt[-1]),NULL,NULL,LP);
		     i = add_ptr_index(p);
		     yyval = i;
		     } break;
case 141:{ parse_error("Bad exprression."); } break;
case 142:{
		      add_exprlist(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]));
		      yyval = yypvt[-2];
		      } break;
case 143:{
		      exprlist *e;
		      long i;
		      e = new_exprlist(ptr_index(yypvt[-0]));
		      i = add_ptr_index(e);
		      yyval = i;
		      } break;
case 144:{
		      exprlist *e;
		      long i;
		      e = new_exprlist(NULL);
		      i = add_ptr_index(e);
		      yyval = i;
		      } break;
case 145:{ parse_error("Bad parameter list."); } break;
case 146:{
		     add_exprlist(ptr_index(yypvt[-2]),ptr_index(yypvt[-0]));
		     yyval = yypvt[-2];
		     } break;
case 147:{
		     terminal *t;
		     expr *p;
		     t = new_terminal(STRCONST,ptr_index(yypvt[-0]));
		     p = new_expr(NULL,NULL,NULL,STRCONST);
		     set_expr_data(p,t);
		     add_ptr_index(p);
		     add_exprlist(ptr_index(yypvt[-2]),p);
		     yyval = yypvt[-2];
		     } break;
case 148:{
		     exprlist *e;
		     terminal *t;
		     expr *p;
		     long i;
		     t = new_terminal(STRCONST,ptr_index(yypvt[-0]));
		     p = new_expr(NULL,NULL,NULL,STRCONST);
		     set_expr_data(p,t);
		     add_ptr_index(p);
		     e = new_exprlist(p);
		     i = add_ptr_index(e);
		     yyval = i;
		     } break;
case 149:{
		     exprlist *e;
		     long i;
		     e = new_exprlist(ptr_index(yypvt[-0]));
		     i = add_ptr_index(e);
		     yyval = i;
		     } break;
case 150:{ parse_error("Bad table initializer."); } break;
case 151:{ yyval = yypvt[-0]; } break;
case 152:{ yyval = yypvt[-0]; } break;
case 153:{ parse_error("Bad numeric constant."); } break;
	}
	goto yystack;		/* reset registers in driver code */
}
