### This file created by IYACC 1.0
### Please send bug reports to raypereda@hotmail.com
#define YYPREFIX "yy"
#line 1 "pass1/parser/grammar.indent.y"
$include "defs.icn"
$include "global_vars.icn"
global yylhs

#line 9 "pass1/parser/grammar.icn"
$define CAND 257
$define CHARACTERS 258
$define CONSTANTS 259
$define COR 260
$define DO 261
$define ELSE 262
$define ELSIF 263
$define END 264
$define ENUM 265
$define EXPORT 266
$define FI 267
$define FIELD 268
$define FUNC 269
$define H 270
$define HIDE 271
$define IF 272
$define IN 273
$define EXTEND 274
$define LET 275
$define NI 276
$define OD 277
$define READONLY 278
$define RECORD 279
$define THEN 280
$define TYPE 281
$define UNION 282
$define USE 283
$define VAL 284
$define VAR 285
$define WITH 286
$define RIGHT_ARROW 287
$define EQUALS_EQUALS 288
$define EQUALS_EQUALS_EQUALS 289
$define COLON 290
$define WORDID 291
$define OPID 292
$define PROD 293
$define QSTRING 294
$define UQSTRING 295
$define LEFT_ANGLE_BRACKET 296
$define RIGHT_ANGLE_BRACKET 297
$define EXTERN 298
$define SIGNATURE 299
$define YYERRCODE 256
procedure init()
  yylhs := [                                        -1,
    2,    0,    0,    4,    0,    5,    5,    5,    7,    7,
    9,    9,   10,   10,    6,    6,    8,    8,   12,   12,
   12,   12,   12,   12,   12,   12,   12,   12,   15,   15,
   18,   18,   19,   14,   14,   20,   20,   17,   17,   16,
   16,   21,   21,   21,   21,   21,   22,   22,    1,    1,
   13,   13,   23,   23,   23,   23,   24,   24,   24,   24,
   24,   24,   24,   24,   24,   24,   24,   24,    3,    3,
    3,   33,   33,   26,   26,   34,   34,   34,   27,   27,
   27,   27,   28,   28,   28,   28,   28,   42,   42,   42,
   25,   32,   32,   32,   31,   31,   43,   43,   43,   43,
   44,   44,   37,   39,   40,   40,   38,   38,   41,   41,
   45,   45,   46,   46,   47,   29,   29,   48,   48,   49,
   49,   49,   50,   50,   51,   51,   51,   52,   52,   52,
   53,   53,   35,   35,   54,   54,   55,   55,   30,   30,
   30,   30,   56,   11,   11,   36,   36,
  ]
  yylen := [                            2,
    0,    2,    1,    0,    3,    3,    1,    1,    1,    0,
    1,    0,    1,    3,    1,    3,    1,    1,    1,    2,
    2,    1,   14,   13,   12,   10,    8,    5,    1,    0,
    4,    0,    5,    7,    6,    1,    0,    1,    3,    1,
    0,    3,    5,    1,    1,    1,    1,    0,    1,    1,
    1,    1,    1,    1,    2,    2,    1,    1,    1,    1,
    1,    2,    3,    3,    3,    5,    5,    4,    3,    1,
    1,    1,    0,    4,    5,    1,    6,    5,    4,    3,
    2,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    3,    1,    3,    0,    1,    3,    4,    4,    0,    1,
    2,    0,    4,    4,    5,    2,    4,    2,    5,    2,
    1,    3,    1,    0,    3,    1,    1,    5,    2,    5,
    2,    2,    1,    1,    1,    3,    0,    3,    1,    1,
    1,    0,    3,    0,    1,    0,    2,    5,    1,    3,
    4,    1,    3,    1,    1,    1,    1,
  ]
  yydefred := [                         0,
    0,    0,    0,    0,   59,   60,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  144,  145,
    0,  146,  147,    0,   19,    0,    0,   52,    2,    0,
   49,   50,    0,    0,    0,   54,   57,   58,   61,    0,
   82,   83,   84,   85,   86,   87,   71,   70,    0,    0,
   89,    0,    0,    0,  139,    0,    0,    0,    0,    0,
    0,  100,    0,   15,    0,   95,  108,    0,    0,   40,
    0,  110,    0,    0,    0,   21,   76,   20,  106,    0,
    0,    0,    0,    0,   81,    0,   56,    0,    0,    0,
    0,   62,  116,  117,    0,    0,    0,    0,   65,    0,
    0,    0,    0,    0,    0,    0,   64,    0,    9,    0,
    0,    0,    0,    0,    0,    0,  111,  113,   29,    0,
    0,    0,    0,    0,    0,    0,   63,   91,    0,    0,
   17,   18,   22,  121,  122,  119,    0,    0,   80,    0,
    0,    0,   72,   69,    0,   90,   88,  140,    0,  103,
    0,    0,    8,   11,    0,    7,   13,    0,    0,    0,
    0,  104,   16,  101,    0,    0,    0,   96,    0,    0,
  107,    0,    0,   46,   45,    0,    0,    0,   38,   36,
    0,   93,    0,    0,   68,    0,    0,  133,    0,   79,
    0,    0,   74,    0,    0,  141,  135,   31,    0,    0,
    0,    0,    0,   97,   98,   66,  115,  112,    0,    0,
    0,    0,   28,  109,   67,  105,    0,    0,    0,  130,
  129,    0,    0,    0,   75,    0,    0,   33,    6,   14,
   35,    0,    0,    0,    0,   47,   42,    0,   39,    0,
    0,  118,    0,  120,    0,    0,   34,    0,    0,    0,
    0,    0,    0,  131,  128,  126,    0,    0,    0,    0,
   27,   43,    0,  138,    0,    0,    0,    0,    0,    0,
    0,   26,    0,    0,    0,    0,    0,   25,    0,   24,
   23,
  ]
  yydgoto := [                          2,
   48,    3,   49,    4,  154,  155,  111,  156,  157,  158,
   30,   31,   32,   33,  120,   71,  178,   58,   59,  179,
  180,  238,   34,   35,   36,   37,   38,   39,   92,   53,
   65,   75,  144,   40,   85,   41,   42,   43,   44,   45,
   46,   54,   66,  112,  116,  117,  118,   93,   94,   95,
  223,  224,  255,  196,  197,   55,
  ]
  yysindex := [                      -203,
    0,    0,  367,  263,    0,    0,  169,  -67,   20,  169,
  -62, -105,  -92,  -24,  -72,  367,  565,  565,    0,    0,
  -68,    0,    0,  -54,    0,  263,  367,    0,    0, -206,
    0,    0,    0,  729,  -31,    0,    0,    0,    0,   30,
    0,    0,    0,    0,    0,    0,    0,    0,   34,    0,
    0, -179,   -6, -168,    0, -257, -257,   49,  118,  -23,
  367,    0,  -40,    0,  -37,    0,    0, -257, -257,    0,
   52,    0,   54,  134,  -94,    0,    0,    0,    0,   67,
 -103,   48,   99,  440,    0,  -31,    0,  -57,  -55,  132,
  141,    0,    0,    0, -257,  327,  367,  263,    0,  223,
  263,  -11, -246,  294, -257,  111,    0,   80,    0, -257,
  440, -116,  263, -105,  -40,  -17,    0,    0,    0,  -22,
 -194,  294,  367,  263,  294,   82,    0,    0,   20,  -87,
    0,    0,    0,    0,    0,    0,   89, -206,    0,   91,
  -99,  -12,    0,    0,   35,    0,    0,    0,   34,    0,
  175,  -73,    0,    0,  -40,    0,    0,   -2,    0,  -65,
  294,    0,    0,    0,  367,  367,  -46,    0,  367, -257,
    0,  -63, -257,    0,    0,  -40,    0,  -10,    0,    0,
   -9,    0,  -42,   -8,    0,  136,  118,    0, -105,    0,
  -74,  107,    0,  263,  367,    0,    0,    0,  202,  440,
  294,  440,    6,    0,    0,    0,    0,    0,  -35,  149,
  637, -194,    0,    0,    0,    0,  294,  183,   -5,    0,
    0, -206,  162,  229,    0,   34,   10,    0,    0,    0,
    0,  440,   14, -257, -194,    0,    0,   23,    0,   12,
  294,    0, -228,    0,  -74,  263,    0,  -41,  179,   -4,
  565,  440,   17,    0,    0,    0,   35,  -30, -257, -194,
    0,    0,  440,    0,  271, -257,  199,    7, -257,  205,
 -194,    0,  211, -194,    9, -194,   13,    0,   19,    0,
    0,
  ]
  yyrindex := [                       419,
    1,    0,    0,    0,    0,    0,    0,    0,  234,    0,
    0,    8,    0,  224,  224,   76,    0,    0,    0,    0,
  224,    0,    0,    0,    0,    0,  258,    0,    0,   44,
    0,    0,  664,  530,   83,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  353,    2,
    0,   74,    0,    0,    0,    0,    0,    0,  234,    0,
    0,    0,  599,    0,    0,    0,    0,   22,  -21,    0,
    0,    0,    0,  -75,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  122,    0,  -98,  -95,  224,
    0,    0,    0,    0,  224,    0,  633,    0,    0,    0,
    0,    0,    0,   53,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    4,  469,    0,    0,    0,    0,    0,
   27,   36,  -70,    0,   36,    0,    0,    0,  234,    0,
    0,    0,    0,    0,    0,    0,    0,   44,    0,    0,
    0,    0,    0,    0,  -28,    0,    0,    0,  -26,    0,
    0,    0,    0,    0,  778,    0,    0,    0,  683,    0,
   53,    0,    0,    0,    0,    0,    0,    0,    0,   22,
    0,    0,  224,    0,    0,  510,  807,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  234,    0,   43,    0,
  239,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  -19,  245,    0,    0,    0,    0,    0,    0,    0,    0,
  105,   27,    0,    0,    0,    0,   53,    0,    0,    0,
    0,  -38,    0,  261,    0,  -25,    0,    0,    0,    0,
    0,  267,    0,  224,   27,    0,    0,    0,    0,    0,
   53,    0,   45,    0,  239,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,  -28,    0,  224,   27,
    0,    0,    0,    0,    0,  224,    0,    0,  224,    0,
   27,    0,    0,   27,    0,   27,    0,    0,    0,    0,
    0,
  ]
  yygindex := [                         0,
 1023,    0,   32,    0,    0,  601,   28,  662,  191,  -86,
  855,  -52,   -3,  997,    0,  -13, -135,  -33,  264,  188,
    0,    0,    0,  369,  372,    0,    0,    0,    0,  398,
  233,    3,    0,    0, -111,  321,    0,    0,    0,    0,
    0,    0,  313,    0,    0,  269,    0,    0,  185,    0,
  192,    0,    0,  189,    0,  340,
  ]
$define YYTABLESIZE 1260
  yytable := [                        259,
    3,   73,    4,  110,   91,  234,  136,   80,  143,  137,
  266,  100,   97,   76,   78,   69,   97,   92,  173,   30,
  134,  114,   94,   81,  123,  106,  190,  124,  100,   83,
   68,  132,  110,   19,   20,  181,  142,   88,  184,   12,
    4,  170,   89,  134,   19,   20,   97,  151,  212,  201,
  201,  132,    1,  114,  212,   56,  201,   82,  132,   57,
   61,  174,   99,  175,  201,  212,   99,  212,   81,  132,
  201,  212,  132,   12,  203,  201,  137,  212,  134,  134,
  114,  140,   53,  134,  134,   37,  134,  134,  127,   84,
  202,    4,   97,   97,   12,  186,   19,   20,  232,  250,
   98,   99,  134,  132,  252,   12,   97,  171,  132,  263,
  243,   12,  193,  150,  213,  214,  216,   53,  101,  242,
  261,   55,   53,   53,  268,  182,   53,  142,   99,  145,
  240,  272,  149,  278,  134,  275,  134,  280,  277,  104,
  279,   53,  169,  281,  167,   12,  114,  132,  132,  132,
   62,   37,   96,  218,  253,  183,   55,  105,  132,  210,
   12,   55,   55,   67,  132,   55,  134,   99,  134,  132,
   28,  165,  166,   53,  121,   53,  122,  123,  124,  132,
   55,  220,  200,   72,  221,   19,   20,   79,  132,  125,
  126,  128,  123,  123,  192,  124,  124,   92,  134,  132,
  135,  161,   94,  211,  162,   53,  185,   53,   26,  188,
  132,  189,   55,  191,   55,  198,   19,   20,   19,   20,
  249,  199,   19,   20,   28,  226,  217,  134,  151,  206,
  209,  225,  134,  215,   88,  113,  172,   30,  136,   89,
  143,  137,  228,  107,   55,  267,   55,  262,  136,  109,
  143,  137,  270,  258,   90,  273,    4,    4,  233,   27,
    4,    4,   26,  265,   28,    4,   19,   20,  142,    4,
   99,  235,    4,  241,    4,    4,   99,  257,  142,    4,
   99,    4,    4,    4,    4,    4,  244,  245,   90,  246,
  251,    4,    4,    4,    4,    4,  194,  195,    4,    4,
  134,  260,   26,  134,  134,  134,  134,  248,  134,  134,
  134,  269,  134,   27,  134,  134,  134,  134,  134,  134,
  134,  271,  134,  134,   32,  134,  134,  274,   28,  134,
  134,  134,  134,  276,  134,  134,  134,  134,  134,   53,
  134,  134,   53,   53,   53,   53,   41,   53,   94,   53,
   94,   53,    5,   27,   53,   53,   53,   53,   53,   53,
   88,   53,   53,  127,   53,   53,   26,   78,   28,   53,
   53,   53,   48,   53,   53,   53,   53,   53,   55,   53,
   53,   55,   55,   55,   55,  125,   55,  136,   55,   77,
   55,  230,  187,   55,   55,   55,   55,   55,   55,  239,
   55,   55,   86,   55,   55,   87,   26,   60,   55,   55,
   55,  139,   55,   55,   55,   55,   55,   27,   55,   55,
    1,  219,   19,   20,   50,    5,  168,  254,    6,    7,
   51,   19,   20,    8,   22,   23,  256,    9,  208,  148,
   10,    0,   11,   12,    0,  264,    0,   13,    0,   14,
   15,   16,   17,   18,    0,    0,    0,   27,    1,   19,
   20,   21,   22,   23,    0,    0,   24,   25,    0,    0,
   10,    0,    0,    0,    0,    0,    0,    0,  146,    5,
    0,    0,    6,    7,   51,    0,    0,    8,    0,    0,
    0,    9,    0,    0,   10,    0,   11,   12,    0,    0,
    0,   13,    0,   14,   15,   16,   17,   18,   10,    1,
    0,    0,    0,   19,   20,   21,   22,   23,   47,    5,
   24,   25,    6,    7,    0,    0,    0,    8,    0,   51,
    0,    9,    0,    0,   10,    0,   11,   12,    0,    0,
    0,   13,    0,   14,   15,   16,   17,   18,    0,  153,
    0,    0,    0,   19,   20,   21,   22,   23,    0,   10,
   24,   25,  129,    0,   51,    0,   28,    0,    0,    0,
   51,    0,    0,   51,   14,    0,    0,   17,   18,    0,
    0,    0,   47,    5,   19,   20,    6,    7,   51,    0,
    0,    8,   25,    0,    0,    9,    0,    0,   10,    0,
   11,   12,    0,    0,   26,   13,    0,   14,   15,   16,
   17,   18,   63,    0,    0,    0,    0,   19,   20,   21,
   22,   23,   51,    5,  141,   25,    6,    7,    0,    0,
    0,    8,   73,    0,    0,    9,    0,    0,   10,    0,
   11,   12,    0,    0,    0,   13,    0,   14,   15,   16,
   17,   18,   51,    0,   51,   27,  102,   19,   20,   21,
   22,   23,    0,   22,   24,   25,    0,   73,  115,    0,
    0,    0,    0,   73,    0,    1,    0,    0,    1,    1,
    0,    0,    0,    1,    0,    0,    0,    1,    0,    0,
    1,   73,    1,    1,    0,    0,    0,    1,   22,    1,
    1,    1,    1,    1,   22,    0,    0,   22,  129,    1,
    1,    1,    1,    1,   63,    0,    1,    1,    0,    0,
   14,  176,   22,   17,   18,   10,   15,    0,   10,   10,
   19,   20,    0,   10,    0,    0,    0,   10,   25,    0,
   10,   17,   10,   10,    0,  130,    0,   10,    0,   10,
   10,   10,   10,   10,    0,    0,   22,   73,    0,   10,
   10,   10,   10,   10,    0,    0,   10,   10,   26,    0,
  115,    0,  164,    0,    0,   17,    0,   10,   10,    0,
    0,    0,    0,    0,    0,    0,   76,   10,   22,   63,
   10,   51,   51,   10,   10,    0,   51,    0,    0,    0,
   10,   10,   51,    0,    0,   51,   51,   17,   10,   51,
    0,    0,  176,    0,    0,    0,   51,   51,   51,   27,
    0,    5,    0,    0,    6,    7,   51,    0,    0,    8,
    0,    0,    0,    9,    0,  176,   10,    0,   11,   12,
    0,    0,    0,   13,    0,    0,   15,   16,    0,    0,
   15,    0,    0,    0,    0,   19,   20,   21,   22,   23,
  176,  229,   24,  231,    0,   44,   64,   10,   70,   70,
    0,  176,  237,    0,  176,   70,  176,    0,    0,   10,
    0,    0,   10,   10,    0,    0,  102,  102,    0,   10,
   10,    0,    0,  247,   73,   73,    0,   10,    0,   73,
    0,    0,    0,    0,    0,  129,    0,    0,   73,   73,
   64,  103,    0,  231,  236,    0,    0,   14,    0,    0,
   17,   18,   64,  119,  247,   22,   22,   19,   20,    0,
   22,   44,    0,    0,    0,   25,   22,    0,  131,   22,
   22,    0,    0,   22,   70,  138,    0,    0,    0,   70,
   22,   15,    0,    0,    0,    0,    0,  152,  159,  160,
    0,    0,    0,   15,  163,  131,   15,   15,   64,    0,
    0,    0,   15,   15,   15,  177,  159,    0,    0,  159,
    0,   15,    0,    0,    0,    5,    0,    0,    6,    7,
    0,    0,    0,    8,    0,    0,    0,    9,    0,    0,
   10,    0,   11,   12,    0,    0,    0,   13,    0,    0,
   15,   16,    0,   77,   77,  159,    0,    0,    0,   19,
   20,   21,   22,   23,   64,   29,   24,   70,    0,   52,
   77,    0,   52,    0,    0,    0,    0,    0,   74,    0,
    0,    0,    0,   64,    0,  222,   10,    0,    0,   74,
    0,    0,    0,    0,  131,  159,  131,    0,   10,    0,
    0,   10,   10,    0,    0,  131,  177,    0,   10,   10,
    0,  159,    0,    0,   15,   15,   10,    0,    0,    0,
  133,    0,    0,  108,   15,    0,  131,   15,   70,  177,
   15,   15,    0,    0,    0,  159,   15,   15,   15,  222,
  133,    0,    0,    0,    0,   15,  131,  133,    0,    0,
    0,    0,    0,   70,  177,    0,    0,  131,  133,  143,
   70,  133,  147,   70,    0,  177,    0,    0,  177,    0,
  177,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,   74,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,  133,    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,  204,  205,    0,
    0,  207,    0,    0,    0,    0,  133,  133,  133,    0,
    0,    0,    0,    0,    0,    0,    0,  133,    0,    0,
    0,    0,    0,  133,    0,    0,    0,  227,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  133,    0,
    0,    0,    0,    0,    0,    0,    0,  133,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   77,  133,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,  133,
  ]
  yycheck := [                         41,
    0,   15,    2,   44,   36,   41,   35,   21,   35,   35,
   41,   35,   59,   17,   18,   40,   59,   93,   41,   41,
   59,   59,   93,  123,  123,   59,  138,  123,   35,   27,
  123,   84,   44,  291,  292,  122,   35,  266,  125,   59,
   40,   59,  271,    0,  291,  292,   59,  294,   59,   59,
   59,  104,  256,   59,   59,  123,   59,   26,  111,   40,
  123,  256,   59,  258,   59,   59,   59,   59,  123,  122,
   59,   59,  125,   93,  161,   59,   90,   59,   35,   36,
   59,   95,    0,   40,   41,   59,  125,   44,   41,  296,
   93,   91,   59,   59,   59,  129,  291,  292,   93,  235,
  280,   59,   59,   59,   93,  125,   59,  125,  161,   93,
  222,   59,  125,  125,  125,  125,  125,   35,  287,  125,
  125,    0,   40,   41,  260,  123,   44,   96,  125,   98,
  217,  125,  101,  125,   91,  271,   93,  125,  274,   91,
  276,   59,  115,  125,  113,   93,  125,  200,  201,  202,
  256,  125,  123,  187,  241,  124,   35,   40,  211,  173,
  125,   40,   41,  256,  217,   44,  123,  125,  125,  125,
    2,  288,  289,   91,  123,   93,  123,   44,  273,  232,
   59,  256,  155,  256,  259,  291,  292,  256,  241,  123,
  294,   93,  291,  292,  294,  291,  292,  273,  256,  252,
  256,   91,  273,  176,  125,  123,  125,  125,   40,  297,
  263,  123,   91,  123,   93,   41,  291,  292,  291,  292,
  234,  295,  291,  292,    2,  194,   91,  266,  294,  276,
  294,  125,  271,  276,  266,  273,  259,  259,  267,  271,
  267,  267,   41,  267,  123,  259,  125,  251,  277,  290,
  277,  277,  266,  295,  286,  269,  256,  257,  294,   91,
  260,  261,   40,  294,    2,  265,  291,  292,  267,  269,
  277,  123,  272,   91,  274,  275,  273,  246,  277,  279,
  273,  281,  282,  283,  284,  285,  125,   59,  287,  280,
  268,  291,  292,  293,  294,  295,  262,  263,  298,  299,
  257,  123,   40,  260,  261,  262,  263,  294,  265,  266,
  267,   41,  269,   91,  271,  272,  273,  274,  275,  276,
  277,  123,  279,  280,   91,  282,  283,  123,    2,  286,
  287,  288,  289,  123,  291,  292,  293,  294,  295,  257,
  297,  298,  260,  261,  262,  263,  123,  265,  273,  267,
   93,  269,    0,   91,  272,  273,  274,  275,  276,  277,
  287,  279,  280,  125,  282,  283,   40,  123,    2,  287,
  288,  289,  268,  291,  292,  293,  294,  295,  257,  297,
  298,  260,  261,  262,  263,  125,  265,  256,  267,  123,
  269,  201,  129,  272,  273,  274,  275,  276,  277,  212,
  279,  280,   34,  282,  283,   34,   40,   10,  287,  288,
  289,   91,  291,  292,  293,  294,  295,   91,  297,  298,
    2,  189,  291,  292,  256,  257,  114,  243,  260,  261,
  262,  291,  292,  265,  294,  295,  245,  269,  170,  100,
  272,   -1,  274,  275,   -1,  257,   -1,  279,   -1,  281,
  282,  283,  284,  285,   -1,   -1,   -1,   91,   40,  291,
  292,  293,  294,  295,   -1,   -1,  298,  299,   -1,   -1,
    2,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,  257,
   -1,   -1,  260,  261,  262,   -1,   -1,  265,   -1,   -1,
   -1,  269,   -1,   -1,  272,   -1,  274,  275,   -1,   -1,
   -1,  279,   -1,  281,  282,  283,  284,  285,   40,   91,
   -1,   -1,   -1,  291,  292,  293,  294,  295,  256,  257,
  298,  299,  260,  261,   -1,   -1,   -1,  265,   -1,    0,
   -1,  269,   -1,   -1,  272,   -1,  274,  275,   -1,   -1,
   -1,  279,   -1,  281,  282,  283,  284,  285,   -1,  256,
   -1,   -1,   -1,  291,  292,  293,  294,  295,   -1,   91,
  298,  299,  269,   -1,   35,   -1,    2,   -1,   -1,   -1,
   41,   -1,   -1,   44,  281,   -1,   -1,  284,  285,   -1,
   -1,   -1,  256,  257,  291,  292,  260,  261,   59,   -1,
   -1,  265,  299,   -1,   -1,  269,   -1,   -1,  272,   -1,
  274,  275,   -1,   -1,   40,  279,   -1,  281,  282,  283,
  284,  285,   12,   -1,   -1,   -1,   -1,  291,  292,  293,
  294,  295,   93,  257,  298,  299,  260,  261,   -1,   -1,
   -1,  265,    0,   -1,   -1,  269,   -1,   -1,  272,   -1,
  274,  275,   -1,   -1,   -1,  279,   -1,  281,  282,  283,
  284,  285,  123,   -1,  125,   91,   56,  291,  292,  293,
  294,  295,   -1,    0,  298,  299,   -1,   35,   68,   -1,
   -1,   -1,   -1,   41,   -1,  257,   -1,   -1,  260,  261,
   -1,   -1,   -1,  265,   -1,   -1,   -1,  269,   -1,   -1,
  272,   59,  274,  275,   -1,   -1,   -1,  279,   35,  281,
  282,  283,  284,  285,   41,   -1,   -1,   44,  269,  291,
  292,  293,  294,  295,  114,   -1,  298,  299,   -1,   -1,
  281,  121,   59,  284,  285,  257,   44,   -1,  260,  261,
  291,  292,   -1,  265,   -1,   -1,   -1,  269,  299,   -1,
  272,   59,  274,  275,   -1,   84,   -1,  279,   -1,  281,
  282,  283,  284,  285,   -1,   -1,   93,  125,   -1,  291,
  292,  293,  294,  295,   -1,   -1,  298,  299,   40,   -1,
  170,   -1,  111,   -1,   -1,   93,   -1,  268,  269,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,  123,  278,  125,  189,
  281,  262,  263,  284,  285,   -1,  267,   -1,   -1,   -1,
  291,  292,  273,   -1,   -1,  276,  277,  125,  299,  280,
   -1,   -1,  212,   -1,   -1,   -1,  287,  288,  289,   91,
   -1,  257,   -1,   -1,  260,  261,  297,   -1,   -1,  265,
   -1,   -1,   -1,  269,   -1,  235,  272,   -1,  274,  275,
   -1,   -1,   -1,  279,   -1,   -1,  282,  283,   -1,   -1,
   44,   -1,   -1,   -1,   -1,  291,  292,  293,  294,  295,
  260,  200,  298,  202,   -1,   59,   12,  269,   14,   15,
   -1,  271,  211,   -1,  274,   21,  276,   -1,   -1,  281,
   -1,   -1,  284,  285,   -1,   -1,  288,  289,   -1,  291,
  292,   -1,   -1,  232,  262,  263,   -1,  299,   -1,  267,
   -1,   -1,   -1,   -1,   -1,  269,   -1,   -1,  276,  277,
   56,   57,   -1,  252,  278,   -1,   -1,  281,   -1,   -1,
  284,  285,   68,   69,  263,  262,  263,  291,  292,   -1,
  267,  125,   -1,   -1,   -1,  299,  273,   -1,   84,  276,
  277,   -1,   -1,  280,   90,   91,   -1,   -1,   -1,   95,
  287,  269,   -1,   -1,   -1,   -1,   -1,  103,  104,  105,
   -1,   -1,   -1,  281,  110,  111,  284,  285,  114,   -1,
   -1,   -1,  290,  291,  292,  121,  122,   -1,   -1,  125,
   -1,  299,   -1,   -1,   -1,  257,   -1,   -1,  260,  261,
   -1,   -1,   -1,  265,   -1,   -1,   -1,  269,   -1,   -1,
  272,   -1,  274,  275,   -1,   -1,   -1,  279,   -1,   -1,
  282,  283,   -1,   17,   18,  161,   -1,   -1,   -1,  291,
  292,  293,  294,  295,  170,    3,  298,  173,   -1,    7,
   34,   -1,   10,   -1,   -1,   -1,   -1,   -1,   16,   -1,
   -1,   -1,   -1,  189,   -1,  191,  269,   -1,   -1,   27,
   -1,   -1,   -1,   -1,  200,  201,  202,   -1,  281,   -1,
   -1,  284,  285,   -1,   -1,  211,  212,   -1,  291,  292,
   -1,  217,   -1,   -1,  268,  269,  299,   -1,   -1,   -1,
   84,   -1,   -1,   61,  278,   -1,  232,  281,  234,  235,
  284,  285,   -1,   -1,   -1,  241,  290,  291,  292,  245,
  104,   -1,   -1,   -1,   -1,  299,  252,  111,   -1,   -1,
   -1,   -1,   -1,  259,  260,   -1,   -1,  263,  122,   97,
  266,  125,  100,  269,   -1,  271,   -1,   -1,  274,   -1,
  276,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,  123,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  161,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  165,  166,   -1,
   -1,  169,   -1,   -1,   -1,   -1,  200,  201,  202,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  211,   -1,   -1,
   -1,   -1,   -1,  217,   -1,   -1,   -1,  195,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  232,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  241,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  251,  252,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  263,
  ]
$define YYFINAL 2
$define YYMAXTOKEN 299
  yyname := [
"end-of-file",0,"\002",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,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,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,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,"CAND","CHARACTERS","CONSTANTS","COR","DO","ELSE","ELSIF",
"END","ENUM","EXPORT","FI","FIELD","FUNC","H","HIDE","IF","IN","EXTEND","LET",
"NI","OD","READONLY","RECORD","THEN","TYPE","UNION","USE","VAL","VAR","WITH",
"RIGHT_ARROW","EQUALS_EQUALS","EQUALS_EQUALS_EQUALS","COLON","WORDID","OPID",
"PROD","QSTRING","UQSTRING","LEFT_ANGLE_BRACKET","RIGHT_ANGLE_BRACKET","EXTERN",
"SIGNATURE",
  ]
  yyrule := [
"$accept : Program",
"$$1 :",
"Program : $$1 Denotation",
"Program : error",
"$$2 :",
"Program : error $$2 Denotation.seq",
"Parameters : Id.list Opt.Colon Signature",
"Parameters : Signature",
"Parameters : error",
"Opt.Colon : COLON",
"Opt.Colon :",
"Opt.Parameters : Parameters",
"Opt.Parameters :",
"Opt.Parameter.list : Opt.Parameters",
"Opt.Parameter.list : Opt.Parameter.list ';' Opt.Parameters",
"Id.list : ID",
"Id.list : Id.list ',' ID",
"Signature : ID",
"Signature : ManifestSignature",
"ManifestSignature : SIGNATURE",
"ManifestSignature : VAR BasicDenotation",
"ManifestSignature : VAL BasicDenotation",
"ManifestSignature : FuncSignature",
"ManifestSignature : TYPE '(' Opt.Simple CONSTANTS QSTRING QSTRING QSTRING UQSTRING QSTRING ')' Opt.Id '{' Opt.TypeSignatureComponent.list '}'",
"ManifestSignature : TYPE '(' Opt.Simple CONSTANTS QSTRING QSTRING QSTRING UQSTRING ')' Opt.Id '{' Opt.TypeSignatureComponent.list '}'",
"ManifestSignature : TYPE '(' Opt.Simple CONSTANTS QSTRING QSTRING QSTRING ')' Opt.Id '{' Opt.TypeSignatureComponent.list '}'",
"ManifestSignature : TYPE '(' Opt.Simple CONSTANTS QSTRING ')' Opt.Id '{' Opt.TypeSignatureComponent.list '}'",
"ManifestSignature : TYPE '(' Opt.Simple ')' Opt.Id '{' Opt.TypeSignatureComponent.list '}'",
"ManifestSignature : TYPE Opt.Id '{' Opt.TypeSignatureComponent.list '}'",
"Opt.Simple : ID",
"Opt.Simple :",
"Opt.InLine : '(' ID QSTRING ')'",
"Opt.InLine :",
"Special : '(' ID ID UQSTRING ')'",
"FuncSignature : FUNC Special Opt.InLine '[' Opt.Parameter.list ']' Signature",
"FuncSignature : FUNC Opt.InLine '[' Opt.Parameter.list ']' Signature",
"Opt.TypeSignatureComponents : TypeSignatureComponents",
"Opt.TypeSignatureComponents :",
"Opt.TypeSignatureComponent.list : Opt.TypeSignatureComponents",
"Opt.TypeSignatureComponent.list : Opt.TypeSignatureComponent.list ';' Opt.TypeSignatureComponents",
"Opt.Id : ID",
"Opt.Id :",
"TypeSignatureComponents : Id.list Opt.Colon Signature",
"TypeSignatureComponents : Id.list Opt.Colon Opt.Readonly FIELD BasicDenotation",
"TypeSignatureComponents : ID",
"TypeSignatureComponents : CHARACTERS",
"TypeSignatureComponents : error",
"Opt.Readonly : READONLY",
"Opt.Readonly :",
"Denotation : ManifestSignature",
"Denotation : BasicDenotation",
"BasicDenotation : Primary.list",
"BasicDenotation : \002",
"Primary.list : Primary",
"Primary.list : ArgList",
"Primary.list : Primary.list Primary",
"Primary.list : Primary.list ArgList",
"Primary : FuncConstruction",
"Primary : Selection",
"Primary : CAND",
"Primary : COR",
"Primary : TypeConstruction",
"Primary : Primary TypeModifier",
"Primary : '(' Denotation.seq ')'",
"Primary : IF GuardedDenotation.list FI",
"Primary : DO GuardedDenotation.list OD",
"Primary : LET Opt.Declaration.list IN Denotation.seq NI",
"Primary : USE Opt.Denotation.list IN Denotation.seq NI",
"Primary : EXTERN '{' QSTRING '}'",
"Denotation.seq : Denotation.seq ';' Opt.Denotation",
"Denotation.seq : Denotation",
"Denotation.seq : error",
"Opt.Denotation : Denotation",
"Opt.Denotation :",
"FuncConstruction : IncompleteFuncSignature '{' Denotation.seq '}'",
"FuncConstruction : IncompleteFuncSignature '{' EXTERN QSTRING '}'",
"IncompleteFuncSignature : FuncSignature",
"IncompleteFuncSignature : FUNC Special Opt.InLine '[' Opt.Parameter.list ']'",
"IncompleteFuncSignature : FUNC Opt.InLine '[' Opt.Parameter.list ']'",
"Selection : Primary '$' ID Opt.SigClause",
"Selection : Primary '$' STRING",
"Selection : ID Opt.SigClause",
"Selection : STRING",
"TypeConstruction : Enumeration",
"TypeConstruction : Record",
"TypeConstruction : Extension",
"TypeConstruction : Product",
"TypeConstruction : Union",
"Guard : Denotation",
"Guard : ELSE",
"Guard : error",
"ArgList : '[' Opt.Denotation.list ']'",
"Opt.Denotation.list : Denotation",
"Opt.Denotation.list : Denotation ',' Opt.Denotation.list",
"Opt.Denotation.list :",
"Opt.Declaration.list : Opt.Declarations",
"Opt.Declaration.list : Opt.Declaration.list ';' Opt.Declarations",
"Opt.Declarations : Id.list Opt.ColonSignature EQUALS_EQUALS Denotation",
"Opt.Declarations : Id.list Opt.ColonSignature EQUALS_EQUALS_EQUALS Denotation",
"Opt.Declarations :",
"Opt.Declarations : error",
"Opt.ColonSignature : Opt.Colon Signature",
"Opt.ColonSignature :",
"Enumeration : ENUM '{' Id.list '}'",
"Extension : EXTEND '{' Denotation '}'",
"Product : PROD Opt.Id '{' Opt.Parameter.list '}'",
"Product : PROD error",
"Record : RECORD '{' Opt.RecordElement.list '}'",
"Record : RECORD error",
"Union : UNION Opt.Id '{' Opt.Parameter.list '}'",
"Union : UNION error",
"Opt.RecordElement.list : Opt.RecordElements",
"Opt.RecordElement.list : Opt.RecordElement.list ';' Opt.RecordElements",
"Opt.RecordElements : RecordElements",
"Opt.RecordElements :",
"RecordElements : Id.list Opt.Colon Denotation",
"TypeModifier : WithList",
"TypeModifier : ExportList",
"WithList : WITH Opt.Id '{' Opt.Declaration.list '}'",
"WithList : WITH error",
"ExportList : Start.ExportList Opt.Id '{' ExportElement.list '}'",
"ExportList : EXPORT error",
"ExportList : HIDE error",
"Start.ExportList : EXPORT",
"Start.ExportList : HIDE",
"ExportElement.list : ExportElement",
"ExportElement.list : ExportElement ';' ExportElement.list",
"ExportElement.list :",
"ExportElement : ID Opt.SigClause Opt.ExportList",
"ExportElement : CONSTANTS",
"ExportElement : error",
"Opt.ExportList : ExportList",
"Opt.ExportList :",
"Opt.SigClause : LEFT_ANGLE_BRACKET Signature RIGHT_ANGLE_BRACKET",
"Opt.SigClause :",
"Opt.ElseList : ElseList",
"Opt.ElseList :",
"ElseList : ELSE Denotation.seq",
"ElseList : ELSIF Denotation THEN Denotation.seq Opt.ElseList",
"GuardedDenotation.list : GuardedDenotation",
"GuardedDenotation.list : GuardedDenotation.list '#' GuardedDenotation",
"GuardedDenotation.list : Denotation THEN Denotation.seq Opt.ElseList",
"GuardedDenotation.list : error",
"GuardedDenotation : Guard RIGHT_ARROW Denotation.seq",
"ID : WORDID",
"ID : OPID",
"STRING : QSTRING",
"STRING : UQSTRING",
  ]

end

#####################################################################
#####################################################################
invocable all    # need to look up semantic actions by name

global yytext    # user variable to return contextual strings
global yyval     # used to return semantic vals from action routines
global yylval    # the 'lval' (result) I got from yylex()
global yydebug   # (boolean) do I want debug output?
global yynerrs   # (integer) number of errors so far
global yyerrflag # (integer) was there an error?
global yychar    # (integer) the current working character
global action    # maps an integer to a semantic action procedure

global yylhs
global yylen
global yydefred
global yydgoto
global yysindex
global yyrindex
global yygindex
global yytable
global yycheck
global yyname
global yyrule

global statestk         # state stack
global valstk           # value stack
################################################################
# procedure: init_stacks : allocate and prepare stacks
################################################################
procedure init_stacks()
  statestk := []
  valstk := []
  yyval  := 0
  yylval := 0
  action := list(1000, action_null)  # remove hard coded 1000 later
  every i := 1 to 1000 do action[i] := proc("action_" || i)
end

#line 1154 "pass1/parser/grammar.indent.y"



#line 672 "pass1/parser/grammar.icn"
################################################################
# procedure: yyparse : parse input and execute indicated items
################################################################
procedure yyparse()
  local yyn        # next next thing to do
  local yym        #
  local yystate    # current parsing state from state table
  local yys        # current token string
  local doaction   # set to 1 if there need to execute action
  local token      # current token

  if /yytable then init()
  init_stacks()
  yynerrs   := 0
  yyerrflag := 0
  yychar    := -1           # impossible char forces a read
  yystate   := 0            # initial state
  push(statestk, yystate)   # save it

  repeat { # until parsing is done, either correctly, or w/error
    doaction := 1

    ##### NEXT ACTION (from reduction table)
	yyn := yydefred[yystate+1]

    while yyn = 0 do {

      if yychar < 0 then {   # we want a char?
        yychar := yylex()    # get next token
        ##### ERROR CHECK ####
        if yychar < 0 then { # it it didn't work/error
          yychar := 0        # change it to default string (no -1!)
          if yydebug = 1 then yylexdebug(yystate, yychar)
          }
        } # yychar < 0

      yyn := yysindex[yystate+1]  # get amount to shift by (shift index)

      if (yyn ~= 0)           & ((yyn +:= yychar) >= 0) &
         (yyn <= YYTABLESIZE) & (yycheck[yyn+1] = yychar) then {

        ##### NEXT STATE ####
        yystate := yytable[yyn+1] # we are in a new state
        push(statestk, yystate)   # save it
        push(valstk, yylval)      # push our lval as the input for next rule
        yychar := -1              # since we have 'eaten' a token, say we need another
        if yyerrflag > 0 then     # have we recovered an error?
           yyerrflag -:= 1        # give ourselves credit
        doaction := 0             # but don't process yet
        break                     # quit the yyn=0 loop
        }

    yyn := yyrindex[yystate+1]    # reduce

    if (yyn ~= 0)           & ((yyn +:= yychar) >= 0) &
       (yyn <= YYTABLESIZE) & (yycheck[yyn+1] = yychar) then {
      # e reduced!
      yyn      := yytable[yyn+1]
      doaction := 1  # get ready to execute
      break          # drop down to actions
      }
    else { #ERROR RECOVERY
      if yyerrflag == 0 then {
        (\yyerror | write)("syntax error")
        yynerrs +:= 1
      }
      if yyerrflag < 3 then {     # low error count?
        yyerrflag := 3
        repeat { #do until break
          if *statestk < 1 then {  # check for under & overflow here
            (\yyerror | write)("stack underflow. aborting...")   # note lower case 's'
            return 1
          }
          yyn := yysindex[statestk[1]]
          if ((yyn ~= 0) & (yyn +:= YYERRCODE) >= 0 &
                    yyn <= YYTABLESIZE & yycheck[yyn+1] == YYERRCODE) then {
            yystate := yytable[yyn+1]
            push(statestk, yystate)
            push(valstk, yylval)
            doaction := 0
            break
          }
          else {
            if *statestk = 0 then { # check for under & overflow here
              write("Stack underflow. aborting...") # capital 'S'
              return 1
            }
            pop(statestk)
            pop(valstk)
            }
          }
        }
      else  # discard this token
        {
        if yychar = 0 then return 1  # yyabort
        if yydebug = 1 then {
          yys := &null
          if yychar <= YYMAXTOKEN then yys := yyname[yychar+1]
          if integer(yys) & yys = 0 then yys := "illegal-symbol"
          write("state ",  yystate, ", error recovery discards token ",
                yychar, " (", yys, ")")
          }
        yychar := -1       # read another
        }
      } # end error recovery
      yyn := yydefred[yystate+1]
    }# yyn = 0 loop

    if doaction = 0 then   # any reason not to proceed?
      next                 # skip action

    yym := yylen[yyn+1]    # get count of terminals on rhs
    yyval := valstk[yym]   # get current semantic value
    yyinfo("Parser: action = " || yyn)
    write(reduce,"Parser: action = " || yyn)
    parser_actions_cnt +:= 1

    action[yyn]()          # execute the semantic action

    ##### Now let's reduce... ####
    every 1 to yym do pop(statestk)# we just reduced yylen states
    yystate := statestk[1]        # get new state

    every 1 to yym do pop(valstk) # corresponding value drop
    yym := yylhs[yyn+1]           # select next TERMINAL(on lhs)
    if yystate = 0 & yym = 0 then {
                                  # done? 'rest' state and at first TERMINAL
      yystate := YYFINAL          # explicitly say we're done
      push(statestk, YYFINAL)     # and save it
      push(valstk, yyval)         # also save the semantic value of parsing
      if yychar < 0 then {        # we want another character?
        yychar := yylex()         # get next character
        if yychar < 0 then yychar := 0   #clean, if necessary
      }
      if yychar = 0 then break    # Good exit (if lex returns 0  -)
                                  # quit the loop--all DONE
    } # if yystate
    else {                        #else not done yet
      # get next state and push, for next yydefred[]
      yyn := yygindex[yym+1]        # find out where to go
      if (yyn ~= 0)           & ((yyn +:= yystate) >= 0) &
         (yyn <= YYTABLESIZE) & (yycheck[yyn+1] = yystate) then {
        yystate := yytable[yyn+1]   # get new state
        }
      else {
        yystate := yydgoto[yym+1]   # else go to new defred
	     }
      push(statestk, yystate)       # going again, so push state & val...
      push(valstk, yyval)           # for next action
      }
    } # main loop
  yyinfo("Parser: Program accepted!!!!")
  write(reduce,"Parser: Program accepted!!!!")

  return 0 # yyaccept!!
end

### end of procedure parse() ######################################

### start semantic actions ########################################

procedure action_null()
  #write("null action")
end

procedure action_1()
#line 54 "pass1/parser/grammar.indent.y"
 yyval := insrtptr
end

procedure action_2()
#line 55 "pass1/parser/grammar.indent.y"

        { if (\stxtree) then {
            		if (\valstk[2]) then
				   valstk[2] . bld_den_seq := mklist([valstk[1]])
                else
		    yyperror("No insertion marker in standard prologue")
          } else {
	    stxtree := lock(valstk[1])
          }

}
end

procedure action_3()
#line 66 "pass1/parser/grammar.indent.y"
  yyperror("Syntax error")
end

procedure action_4()
#line 68 "pass1/parser/grammar.indent.y"
  yyperror("Syntax error")
end

procedure action_6()
#line 72 "pass1/parser/grammar.indent.y"

	{
	    if (/valstk[2]) then {
		yyperror("Missing colon in parameter specification")
	    }
            lock(valstk[3])
lock(valstk[1])
	    if not(has_field(first(valstk[3]),"id_str_table_index")) then {
	      tmp := first(valstk[3]).cn_hd_field
	      if \ tmp. id_str_table_index then {
            if (tmp . id_str_table_index = indx_Boolean) &
                 (/(id_Boolean . id_last_definition)) then {
                    yyval := p := split(PARAMETER, valstk[3], valstk[1])
		    id_Boolean . id_last_definition := first(p)

                    id_Boolean . id_def_found := TRUE
                    if (initflag = FALSE) then {
                        yywarn ("No builtin type Boolean")
                    }
	      } else if ((tmp . id_str_table_index = indx_Void) &
		        (/(id_Void . id_last_definition))) then {
                    yyval := p := split(PARAMETER, valstk[3], valstk[1])
		    id_Void . id_last_definition := first(p)
                    id_Void . id_def_found := TRUE
                    if (initflag = FALSE) then {
                        yywarn ("No builtin type Void")
                    }
	      } else if ((tmp . id_str_table_index = indx_Integer) &
		        (/id_Integer . id_last_definition)) then {
                    yyval := p := split(PARAMETER, valstk[3], valstk[1])
                    id_Integer . id_last_definition := first(p)
                    id_Integer . id_def_found := TRUE
                    if (initflag = FALSE) then {
                        yywarn ("No builtin type Integer")
                    }
	      } else if ((tmp . id_str_table_index = indx_Null) &
		       (/(id_Null . id_last_definition))) then {
                    yyval := p := split(PARAMETER, valstk[3], valstk[1])
		    id_Null . id_last_definition := first(p)
		    id_Null . id_def_found := TRUE
                    if (initflag = FALSE) then {
			yywarn ("No builtin constant Null")
                    }

		  } } } else {
                yyval := split(PARAMETER, valstk[3], valstk[1])
            }


            vfree(unlock(valstk[3]))
 vfree(unlock(valstk[1]))

}
end

procedure action_7()
#line 124 "pass1/parser/grammar.indent.y"

        {  yyval := mklist([ mknode([PARAMETER,nil,valstk[1]]) ])
}
end

procedure action_8()
#line 127 "pass1/parser/grammar.indent.y"

		local i , c, p

		  i := 0
		yyperror("Error in Parameter Specification")
		c := yychar
		  while not (in(c, paramstop)) do {
		    i +:= 1
                    if ( i > maxskip ) then {
			break
		      }
		        c := yylex()

                      }
		yyclearin
		case (c)  of {
                     VAL:
                        {
                        yyunlex(c)
                        yyunlex(";")
			 }

                     VAR:
                        {
                        yyunlex(c)
                        yyunlex(";")
			 }

                     FUNC:
                        {
                        yyunlex(c)
                        yyunlex(";")
			 }

			"{": {
                        yyunlex(c)
                        yyunlex(WORDID)
                          yyunlex(VAL)
                        yyunlex("]")
			  }
                     ";":

		       {
			yyunlex(c)
			  }
		       "]":
		       {
			yyunlex(c)
			  }

		EOF: {
			exit(1)
			  }
		default:{
                        yyunlex(c)
			  yyunlex("]")
			  }
                }
		yyval := emptylist()

end

procedure action_9()
#line 191 "pass1/parser/grammar.indent.y"
 yyval := TRUE
end

procedure action_10()
#line 193 "pass1/parser/grammar.indent.y"
 yyval := FALSE
end

procedure action_11()
#line 196 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_12()
#line 198 "pass1/parser/grammar.indent.y"

        { yyval := emptylist()
}
end

procedure action_13()
#line 202 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_14()
#line 204 "pass1/parser/grammar.indent.y"

        { yyval := conc(valstk[3],valstk[1])
}
end

procedure action_15()
#line 208 "pass1/parser/grammar.indent.y"

        { yyval := mklist([valstk[1]])
}
end

procedure action_16()
#line 210 "pass1/parser/grammar.indent.y"

        { yyval := addright(valstk[3],valstk[1])
}
end

procedure action_17()
#line 215 "pass1/parser/grammar.indent.y"
 yyval := valstk[1]
end

procedure action_18()
#line 217 "pass1/parser/grammar.indent.y"
 yyval := valstk[1]
end

procedure action_19()
#line 221 "pass1/parser/grammar.indent.y"

	  yyval := sig_Signature

end

procedure action_20()
#line 224 "pass1/parser/grammar.indent.y"

	{
	  yyval := mknode([VARSIGNATURE,valstk[1]])

}
end

procedure action_21()
#line 228 "pass1/parser/grammar.indent.y"

	{
	  yyval := mknode([VALSIGNATURE,valstk[1]])

}
end

procedure action_22()
#line 232 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_23()
#line 235 "pass1/parser/grammar.indent.y"

	{
	  if (initflag = FALSE) then {
	    yywarn("Compiler directive outside initialization")
	  }
	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[10],valstk[9],valstk[8],valstk[6]])
	  yyval . ts_string_max := valstk[7]
	  yyval . ts_simple_type := valstk[12]

}
end

procedure action_24()
#line 245 "pass1/parser/grammar.indent.y"

	{
	  if (initflag = FALSE) then {
	    yywarn("Compiler directive outside initialization")
	  }
	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[9],valstk[8],valstk[7],nil])
	  yyval . ts_string_max := valstk[6]
	  yyval . ts_simple_type := valstk[11]

}
end

procedure action_25()
#line 255 "pass1/parser/grammar.indent.y"

	{
	  if (initflag = FALSE) then {
	    yywarn("Compiler directive outside initialization")
	  }
	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[8],valstk[7],valstk[6],nil])
	  yyval . ts_string_max := -1
	  yyval . ts_simple_type := valstk[10]

}
end

procedure action_26()
#line 265 "pass1/parser/grammar.indent.y"

	{
	  if (initflag = FALSE) then {
	    yywarn("Compiler directive outside initialization")
	  }
	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],valstk[6],nil,nil,nil])
	  yyval . ts_string_max := -1
	  yyval . ts_simple_type := valstk[8]

}
end

procedure action_27()
#line 275 "pass1/parser/grammar.indent.y"

	{
	  if (initflag = FALSE) then {
	    yywarn("Compiler directive outside initialization")
	  }
	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],nil,nil,nil,nil])
	  yyval . ts_string_max := -1
	  yyval . ts_simple_type := valstk[6]

}
end

procedure action_28()
#line 284 "pass1/parser/grammar.indent.y"

	{
	  yyval := mknode([TYPESIGNATURE,valstk[4],valstk[2],nil,nil,nil,nil])
	  yyval . ts_string_max := -1
	  yyval . ts_simple_type := FALSE

}
end

procedure action_29()
#line 292 "pass1/parser/grammar.indent.y"

	{
	  if (valstk[1] . id_str_table_index = indx_simple) then {
	    yyval := TRUE
	  } else {
	    yywarn("Compiler directive not understood")
	    yyval := FALSE
	  }
	  vfree(valstk[1])

}
end

procedure action_30()
#line 302 "pass1/parser/grammar.indent.y"

	{ yyval := FALSE
}
end

procedure action_31()
#line 307 "pass1/parser/grammar.indent.y"

	  if (initflag = FALSE) then {
	    yywarn("Compiler directive outside initialization")
	  }
	  if (valstk[3] . id_str_table_index = indx_inline) then {
	    yyval := ((*inline_cnvt)(valstk[2]))
	  } else {
	    yywarn("Compiler directive not understood")
	    yyval := nil
	  }
	  vfree(valstk[3])

end

procedure action_32()
#line 319 "pass1/parser/grammar.indent.y"

	{ yyval := nil
}
end

procedure action_33()
#line 324 "pass1/parser/grammar.indent.y"

	  local num_arg
	  if (initflag = FALSE) then {
	    yywarn("Compiler directive outside initialization")
	  }
	  if (valstk[4] . id_str_table_index = indx_standard) then {
	    num_arg := valstk[2]

	    if (valstk[3] . id_str_table_index = indx_New) then {
		yyval := special(STD_NEW, num_arg)
	    } else if (valstk[3] . id_str_table_index = indx_ptr_New) then {
		yyval := special(PTR_NEW, num_arg)
	    } else if (valstk[3] . id_str_table_index = indx_init_New) then {
		yyval := special(INIT_NEW, num_arg)
	    } else if (valstk[3] . id_str_table_index = indx_ValueOf) then {
		yyval := special(STD_VALUEOF, num_arg)
	    } else if (valstk[3] . id_str_table_index = indx_assign) then {
		yyval := special(STD_ASSIGN, num_arg)
	    } else if (valstk[3] . id_str_table_index = indx_put) then {
		yyval := special(STD_PUT, num_arg)
	    } else if (valstk[3] . id_str_table_index = indx_Callcc) then {
		yyval := special(STD_CALLCC, num_arg)
	    } else if (valstk[3] . id_str_table_index = indx_Array) then {
		yyval := special(STD_ARRAY, num_arg)
	    } else if (valstk[3] . id_str_table_index = indx_passign) then {
		yyval := special(STD_PASSIGN, num_arg)
	    } else if (valstk[3] . id_str_table_index = indx_massign) then {
		yyval := special(STD_MASSIGN, num_arg)
	    } else {
		yywarn("Bad standard directive")
		yyval := 0
	    }
	  } else {
	    yywarn("Compiler directive not understood")
	    yyval := nil
	  }
	  vfree(valstk[4])
          vfree(valstk[3])

end

procedure action_34()
#line 365 "pass1/parser/grammar.indent.y"

	{
	  yyval := mknode([FUNCSIGNATURE,valstk[5],valstk[3],valstk[1]])
	  yyval . fsig_special := valstk[6]

}
end

procedure action_35()
#line 370 "pass1/parser/grammar.indent.y"

	{
	  yyval := mknode([FUNCSIGNATURE,valstk[5],valstk[3],valstk[1]])
	  if (\valstk[5]) then {
	    yyval . fsig_special := special(OTHER_BUILTIN, 0)
	  }

}
end

procedure action_36()
#line 379 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_37()
#line 381 "pass1/parser/grammar.indent.y"

        { yyval := emptylist()
}
end

procedure action_38()
#line 385 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_39()
#line 387 "pass1/parser/grammar.indent.y"

        { yyval := conc(valstk[3],valstk[1])
}
end

procedure action_40()
#line 391 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_41()
#line 393 "pass1/parser/grammar.indent.y"

        { yyval := nil
}
end

procedure action_42()
#line 397 "pass1/parser/grammar.indent.y"

        {
	    if (valstk[2] = FALSE) then {
		yyperror("Missing colon in type component")
	    }
	  lock(valstk[3])
          lock(valstk[1])
	  if (valstk[1] . kind = VARSIGNATURE) then {
	    yyperror("Variable as type signature component")
	  }
          yyval := split(TSCOMPONENT, valstk[3], valstk[1])
          vfree(unlock(valstk[3]))
          vfree(unlock(valstk[1]))

}
end

procedure action_43()
#line 411 "pass1/parser/grammar.indent.y"

        {
	  if (valstk[4] := FALSE) then {
	      yyperror("Missing colon in field specification")
	  }
          vl_field_sig := mknode([FUNCSIGNATURE,
                                nil,
                                mklist([mknode([PARAMETER,
                                              nil,
                                              mknode([VALSIGNATURE,
                                                     mknode([LETTERID])])])
                                       ]),
                                mknode([VALSIGNATURE, valstk[1]])])
          lock(valstk[5])
          lock(valstk[1])
          if ( is_present(valstk[3]) ) then {
            yyval := split(TSCOMPONENT,valstk[5],vl_field_sig)
          } else {
            vr_field_sig := mknode([FUNCSIGNATURE,
                                  nil,
                                  mklist([mknode([PARAMETER,
                                                nil,
                                                mknode([VARSIGNATURE,
                                                       mknode([LETTERID])])])
                                         ]),
                                  mknode([VARSIGNATURE, valstk[1]])])
            yyval := conc(split(TSCOMPONENT,valstk[5],vl_field_sig),
                      split(TSCOMPONENT,valstk[5],vr_field_sig))
          }
          vfree(unlock(valstk[5]))
          vfree(unlock(valstk[1]))

}
end

procedure action_44()
#line 443 "pass1/parser/grammar.indent.y"

        {
            case (valstk[1] . kind) of {
	    OPRID: {
                    i := valstk[1] . id_str_table_index
                    if ( i = indx_assign ) then
                        result := mknode([TSCOMPONENT,valstk[1],sig_assign])
		      else if ((i = indx_less) | (i = indx_le )) then
                        result := mknode([TSCOMPONENT,valstk[1],sig_less])
			else if (( i = indx_greater) | (i = indx_ge )) then
                        result := mknode([TSCOMPONENT,valstk[1],sig_greater])
			  else if ( (i = indx_equals) | (i = indx_ne) ) then
			result := mknode([TSCOMPONENT,valstk[1],sig_equals])
		    else if (i = indx_sconc ) then
			result := mknode([TSCOMPONENT,valstk[1],sig_sconc])
		    else if ( i = indx_pconc ) then
			result := mknode([TSCOMPONENT,valstk[1],sig_pconc])
                    else
			yyperror("Missing signature")
			  }
	    LETTERID: {
                    i := valstk[1] . id_str_table_index
                    if ( i = indx_New ) then
                        result := mknode([TSCOMPONENT,valstk[1],sig_New])
                    else if ( i = indx_ValueOf ) then
                        result := mknode([TSCOMPONENT,valstk[1],sig_ValueOf])
                    else if ( *(getname(i)) = "\"" ) then
                        result := mknode([TSCOMPONENT,valstk[1],sig_const])
                    else
			yyperror("Missing signature")
			  }

	    default: {
                        rpt_err("parser: incorrect id structure")
	    }
            }
            yyval := mklist([result])

}
end

procedure action_45()
#line 481 "pass1/parser/grammar.indent.y"

        {
		yyval := mklist([mknode([DEFCHARSIGS, RCS0, RCS1, RCS2, RCS3])])

}
end

procedure action_46()
#line 486 "pass1/parser/grammar.indent.y"

	    yyperror("Error in type signature component")
	    yyval := emptylist()

end

procedure action_47()
#line 492 "pass1/parser/grammar.indent.y"

        { yyval := PRESENT
}
end

procedure action_48()
#line 494 "pass1/parser/grammar.indent.y"

        { yyval := NOTPRESENT
}
end

procedure action_49()
#line 499 "pass1/parser/grammar.indent.y"
 yyval := valstk[1]
end

procedure action_51()
#line 503 "pass1/parser/grammar.indent.y"

        {
            lock(valstk[1])
            yyval := mkappl(valstk[1])
            lock(yyval)
            vfree(unlock(valstk[1]))
            unlock(yyval)

}
end

procedure action_52()
#line 512 "pass1/parser/grammar.indent.y"

        {
            if (initflag = FALSE) then {
		yyperror("use of insertion character in non-initialization run")
            } else {
		yyval := insrtptr := mknode([BLOCKDENOTATION,emptylist(),nil])
		insrtptr . bld_precedence := INFINITE
            }

}
end

procedure action_53()
#line 523 "pass1/parser/grammar.indent.y"

        { yyval := mklist([valstk[1]])
}
end

procedure action_54()
#line 526 "pass1/parser/grammar.indent.y"
 yyval := mklist([valstk[1]])
end

procedure action_55()
#line 528 "pass1/parser/grammar.indent.y"
 yyval := addright(valstk[2],valstk[1])
end

procedure action_56()
#line 530 "pass1/parser/grammar.indent.y"
 yyval := addright(valstk[2],valstk[1])
end

procedure action_57()
#line 534 "pass1/parser/grammar.indent.y"
 yyval := valstk[1]
end

procedure action_58()
#line 536 "pass1/parser/grammar.indent.y"
 yyval := valstk[1]
end

procedure action_59()
#line 538 "pass1/parser/grammar.indent.y"
 yyval := mknode([WORDCAND])
end

procedure action_60()
#line 540 "pass1/parser/grammar.indent.y"
 yyval := mknode([WORDCOR])
end

procedure action_61()
#line 542 "pass1/parser/grammar.indent.y"
 yyval := valstk[1]
end

procedure action_62()
#line 544 "pass1/parser/grammar.indent.y"
 yyval := mknode([MODPRIMARY,valstk[2],valstk[1],nil])
end

procedure action_63()
#line 546 "pass1/parser/grammar.indent.y"
 local  prec, p
          if (first(valstk[2]) === last(valstk[2])) then {
                             yyval := p := last(valstk[2])
                lock(p)
                vfree(valstk[2])
                unlock(p)
          }
          else {
              prec := precedence( last(valstk[2]) )
	      yyval := p := mknode([BLOCKDENOTATION,emptylist(),valstk[2]])
	      p . bld_precedence := prec
          }

end

procedure action_64()
#line 559 "pass1/parser/grammar.indent.y"

        { yyval := mknode([GUARDEDLIST,valstk[2]])
}
end

procedure action_65()
#line 561 "pass1/parser/grammar.indent.y"

        { yyval := mknode([LOOPDENOTATION,valstk[2]])
}
end

procedure action_66()
#line 563 "pass1/parser/grammar.indent.y"

      {

	  prec := precedence( last(valstk[2]) )
	  yyval := p := mknode([BLOCKDENOTATION,valstk[4],valstk[2]])
	  p . bld_precedence := prec

}
end

procedure action_67()
#line 570 "pass1/parser/grammar.indent.y"

      {
	  prec := precedence( last(valstk[2]) )
	  yyval := p := mknode([USELIST,valstk[4],valstk[2]])
	  p . usl_precedence := prec

}
end

procedure action_68()
#line 576 "pass1/parser/grammar.indent.y"

	{
	  has_externs := TRUE
	  yyval := mknode([REXTERNDEF, read_signature(valstk[2]), valstk[2]])
	  yyval . sig_done := SIG_DONE

}
end

procedure action_69()
#line 584 "pass1/parser/grammar.indent.y"

        { yyval := addright(valstk[3],valstk[1])
}
end

procedure action_70()
#line 586 "pass1/parser/grammar.indent.y"

        { yyval := mklist([valstk[1]])
}
end

procedure action_71()
#line 589 "pass1/parser/grammar.indent.y"
  local c

		    yyperror("Error in Expression Sequence")
		   c := yychar
		   while not(in(c, denseqstop)) do
			    c := yylex()
		    yyclearin
		    case (c) of {
                         ";":
                            yyunlex(c)
                         "#":
                            yyunlex(c)
			 FI:
                            yyunlex(c)
			 ELSIF:
                            yyunlex(c)
			 ELSE:
                            yyunlex(c)
                         OD:
                            yyunlex(c)
                         ")":
                            yyunlex(c)
                         "NI":
                            yyunlex(c)
                         "}":
                            yyunlex(c)
                         IF:
                         {
                            yyunlex(c)
                            yyunlex(";")
			 }
                         DO:
                         {
                            yyunlex(c)
                            yyunlex(";")
			 }
                         LET:
                         {
                            yyunlex(c)
                            yyunlex(";")
			 }
                         FUNC:
                         {
                            yyunlex(c)
                            yyunlex(";")
			 }
                         "(":
                         {
                            yyunlex(c)
                            yyunlex(";")
			 }
		       WITH: {
                            yyunlex(c)
                            yyunlex(WORDID)
                            yyunlex(";")
		       }
		       IN: {
                            yyunlex(c)
                            yyunlex(LET)
                            yyunlex(";")
		       }
		       EOF: {
			 exit(1)
                          }
                        default:
                            yyunlex(c)
                    }
		    yyval := mklist([id_Integer])

end

procedure action_72()
#line 660 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_73()
#line 662 "pass1/parser/grammar.indent.y"

        { yyval := nil
}
end

procedure action_74()
#line 666 "pass1/parser/grammar.indent.y"

	{
	  if (length(valstk[2]) = 1) then {
	      yyval := mknode([FUNCCONSTR,valstk[4],first(valstk[2])])
	  } else {
	      yyval := mknode([FUNCCONSTR,valstk[4],
			      mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
	      yyval.fc_body.bld_precedence := INFINITE
	  }
	  valstk[4] . fsig_construction := yyval
	  if (initflag = TRUE) then {
	    fn_count := fn_count + 1
	    yyval . fc_code_label := "fn_global_" || fn_count
	  }

}
end

procedure action_75()
#line 681 "pass1/parser/grammar.indent.y"

	{
	  if (/(valstk[5] . fsig_result_sig)) then {
	    yyperror("Must specify result signature for extern")
	  }
	  yyval := mknode([FUNCCONSTR, valstk[5], mknode([EXTERNDEF, valstk[2]])])

}
end

procedure action_76()
#line 690 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_77()
#line 692 "pass1/parser/grammar.indent.y"

	{
	  yyval := mknode([FUNCSIGNATURE, valstk[4], valstk[2], nil])
	  yyval . fsig_special := valstk[5]

}
end

procedure action_78()
#line 697 "pass1/parser/grammar.indent.y"

	{ yyval := mknode([FUNCSIGNATURE, valstk[4], valstk[2], nil])
}
end

procedure action_79()
#line 701 "pass1/parser/grammar.indent.y"

        {
	valstk[2].sel_type :=  valstk[4]
	valstk[2].signature := valstk[1]
            yyval := valstk[2]

}
end

procedure action_80()
#line 707 "pass1/parser/grammar.indent.y"

        {
	valstk[1].sel_type := valstk[3]
            yyval := valstk[1]

}
end

procedure action_81()
#line 712 "pass1/parser/grammar.indent.y"

        {
	valstk[2].signature := valstk[1]
            yyval := valstk[2]

}
end

procedure action_82()
#line 717 "pass1/parser/grammar.indent.y"

        {
            yyval := valstk[1]

}
end

procedure action_83()
#line 723 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_84()
#line 725 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_85()
#line 727 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_86()
#line 729 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_87()
#line 731 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_88()
#line 735 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_89()
#line 737 "pass1/parser/grammar.indent.y"

        { yyval := mknode([WORDELSE])
}
end

procedure action_90()
#line 740 "pass1/parser/grammar.indent.y"
 yyperror("Error while trying to parse guard")
end

procedure action_91()
#line 743 "pass1/parser/grammar.indent.y"

        { yyval := valstk[2]
}
end

procedure action_92()
#line 747 "pass1/parser/grammar.indent.y"

        { yyval := mklist([valstk[1]])
}
end

procedure action_93()
#line 749 "pass1/parser/grammar.indent.y"

        { yyval := addleft(valstk[1],valstk[3])
}
end

procedure action_94()
#line 751 "pass1/parser/grammar.indent.y"

        { yyval := emptylist()
}
end

procedure action_95()
#line 755 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_96()
#line 757 "pass1/parser/grammar.indent.y"

        { yyval := conc(valstk[3],valstk[1])
}
end

procedure action_97()
#line 761 "pass1/parser/grammar.indent.y"

      {
            lock(valstk[4])
	    lock(valstk[3])
	    lock(valstk[1])
            yyval := split(DECLARATION,valstk[4],valstk[1],valstk[3])
            vfree(unlock(valstk[4]))
	    vfree(unlock(valstk[3]))
	    vfree(unlock(valstk[1]))

}
end

procedure action_98()
#line 771 "pass1/parser/grammar.indent.y"

        {
            lock(valstk[4])
	    lock(valstk[3])
	    lock(valstk[1])
	    yyval := q := split(DECLARATION,valstk[4],valstk[1],valstk[3])
	  temp := q.cn_hd_field
	  while \temp do {
	    p := temp.cn_hd_field
	    p . decl_sig_transp := TRUE
	    temp := temp.cn_tl_field
	    }
            vfree(unlock(valstk[4]))
	    vfree(unlock(valstk[3]))
	    vfree(unlock(valstk[1]))

}
end

procedure action_99()
#line 787 "pass1/parser/grammar.indent.y"

        { yyval := emptylist()
}
end

procedure action_100()
#line 790 "pass1/parser/grammar.indent.y"

		i := 0

		yyperror("Error in declaration")
		c := yychar
		  while not (in(c, declstop)) do {
		    i +:= 1
                    if ( i > maxskip ) then {
			break
		      }
		        c := yylex()

                      }
                yyclearin
                case (c)  of {
		EQUALS_EQUALS: {
                        yyunlex(c)
                        yyunlex(WORDID)
                        yyunlex(";")
			  }
                     ";" :
                        yyunlex(c)
                     "}" :
                        yyunlex(c)
                     IN:
                        yyunlex(c)
		       NI:  {
                        yyunlex(c)
                        yyunlex(WORDID)
                        yyunlex(IN)
			  }
                     IF:
		       {
                        yyunlex(c)
                        yyunlex(EQUALS_EQUALS)
                        yyunlex(WORDID)
			  }
                     DO:
		       {
                        yyunlex(c)
                        yyunlex(EQUALS_EQUALS)
                        yyunlex(WORDID)
			  }
                     LET:
		       {
                        yyunlex(c)
                        yyunlex(EQUALS_EQUALS)
                        yyunlex(WORDID)
			  }
                     "(":
		       {
                        yyunlex(c)
                        yyunlex(EQUALS_EQUALS)
                        yyunlex(WORDID)
			  }
		     EOF:
			exit(1)
		default : {
                        yyunlex(c)
                        yyunlex(NI)
                        yyunlex(IN)
			  }
                }
		yyval := emptylist()

end

procedure action_101()
#line 857 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_102()
#line 859 "pass1/parser/grammar.indent.y"

        { yyval := nil
}
end

procedure action_103()
#line 863 "pass1/parser/grammar.indent.y"

        { yyval := mknode([ENUMERATION,valstk[2]])
}
end

procedure action_104()
#line 867 "pass1/parser/grammar.indent.y"

        { yyval := mknode([EXTENSION,valstk[2]])
}
end

procedure action_105()
#line 871 "pass1/parser/grammar.indent.y"

        {
	temp := valstk[2].cn_hd_field
	while \temp do {
	      s := temp.cn_hd_field
	      if (/(s . par_id)) then {
		yyperror("Anonymous fields not allowed in product")
		}
	       temp := temp.cn_tl_field
	      }
	  yyval := mknode([PRODCONSTRUCTION,valstk[4],valstk[2]])

}
end

procedure action_106()
#line 885 "pass1/parser/grammar.indent.y"
 yyperror("Error in product construction")
end

procedure action_107()
#line 888 "pass1/parser/grammar.indent.y"

        { yyval := mknode([RECORDCONSTRUCTION,valstk[2]])
}
end

procedure action_108()
#line 891 "pass1/parser/grammar.indent.y"
 yyperror("Error in record construction")
end

procedure action_109()
#line 894 "pass1/parser/grammar.indent.y"

        {

	temp := valstk[2].cn_hd_field
	while \temp do {
	  s := temp. cn_hd_field
	      if (/(s . par_id)) then {
		yyperror("Anonymous fields not allowed in union")
            }

	  temp := temp.cn_tl_field
	  }
          yyval := mknode([UNIONCONSTRUCTION,valstk[4],valstk[2]])

}
end

procedure action_110()
#line 909 "pass1/parser/grammar.indent.y"
 yyperror("Error in union construction")
end

procedure action_111()
#line 912 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_112()
#line 914 "pass1/parser/grammar.indent.y"

        { yyval := conc(valstk[3],valstk[1])
}
end

procedure action_113()
#line 918 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_114()
#line 920 "pass1/parser/grammar.indent.y"

        { yyval := emptylist()
}
end

procedure action_115()
#line 924 "pass1/parser/grammar.indent.y"

        {
	    if (valstk[2] = FALSE) then {
		yyperror("Missing colon in record element specification")
	    }
            lock(valstk[3])
	    lock(valstk[1])
            yyval := split(RECORDELEMENT,valstk[3],valstk[1])
            vfree(unlock(valstk[3]))
	    vfree(unlock(valstk[1]))

}
end

procedure action_116()
#line 937 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_117()
#line 939 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_118()
#line 943 "pass1/parser/grammar.indent.y"

	{ yyval := mknode([WITHLIST,valstk[4],valstk[2]])
}
end

procedure action_119()
#line 946 "pass1/parser/grammar.indent.y"
 yyperror("Error in \"with\" type modification")
end

procedure action_120()
#line 949 "pass1/parser/grammar.indent.y"

	{ yyval := mknode([valstk[5],valstk[4],valstk[2]])
}
end

procedure action_121()
#line 952 "pass1/parser/grammar.indent.y"
 yyperror("Error in \"export\" type modification")
end

procedure action_122()
#line 954 "pass1/parser/grammar.indent.y"
 yyperror("Error in \"hide\" type modification")
end

procedure action_123()
#line 957 "pass1/parser/grammar.indent.y"

        { yyval := EXPORTLIST
}
end

procedure action_124()
#line 959 "pass1/parser/grammar.indent.y"

        { yyval := HIDELIST
}
end

procedure action_125()
#line 963 "pass1/parser/grammar.indent.y"

        { yyval := mklist([valstk[1]])
}
end

procedure action_126()
#line 965 "pass1/parser/grammar.indent.y"

        { yyval := addleft(valstk[1],valstk[3])
}
end

procedure action_127()
#line 967 "pass1/parser/grammar.indent.y"

        { yyval := emptylist()
}
end

procedure action_128()
#line 971 "pass1/parser/grammar.indent.y"

        { yyval := mknode([EXPORTELEMENT,valstk[3],valstk[2],valstk[1]])
}
end

procedure action_129()
#line 973 "pass1/parser/grammar.indent.y"

        { yyval := mknode([ALLCONSTANTS])
}
end

procedure action_130()
#line 976 "pass1/parser/grammar.indent.y"
 yyperror("Error in \"export\"ed or hidden element specification")
end

procedure action_131()
#line 979 "pass1/parser/grammar.indent.y"

        { yyval := valstk[1]
}
end

procedure action_132()
#line 981 "pass1/parser/grammar.indent.y"

        { yyval := nil
}
end

procedure action_133()
#line 985 "pass1/parser/grammar.indent.y"

        { yyval := valstk[2]
}
end

procedure action_134()
#line 987 "pass1/parser/grammar.indent.y"

        { yyval := nil
}
end

procedure action_135()
#line 992 "pass1/parser/grammar.indent.y"
 yyval := valstk[1]
end

procedure action_136()
#line 994 "pass1/parser/grammar.indent.y"

	    yyval := appl_Null

end

procedure action_137()
#line 1000 "pass1/parser/grammar.indent.y"

	    if (length(valstk[1]) = 1) then {
		yyval := first(valstk[1])
	    } else {
		p := mknode([BLOCKDENOTATION, emptylist(), valstk[1]])
		yyval := p
		p . bld_precedence := INFINITE
	    }

end

procedure action_138()
#line 1010 "pass1/parser/grammar.indent.y"

	  local ge1, ge2

	    if (length(valstk[2]) = 1) then {
		ge1 := mknode([GUARDEDELEMENT,valstk[4],first(valstk[2])])
	    } else {
		ge1 := mknode([GUARDEDELEMENT,valstk[4],
			    mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
		ge1.ge_element.bld_precedence := INFINITE
	    }
		    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), valstk[1]])
	    yyval := mknode([GUARDEDLIST, mklist([ge1, ge2])])

end

procedure action_139()
#line 1025 "pass1/parser/grammar.indent.y"

        { yyval := mklist([valstk[1]])
}
end

procedure action_140()
#line 1027 "pass1/parser/grammar.indent.y"

	{ yyval := addright(valstk[3],valstk[1])
}
end

procedure action_141()
#line 1030 "pass1/parser/grammar.indent.y"

	  local ge1, ge2

	    if (length(valstk[2]) = 1) then {
		ge1 := mknode([GUARDEDELEMENT,valstk[4],first(valstk[2])])
	    } else {
		ge1 := mknode([GUARDEDELEMENT,valstk[4],
			    mknode([BLOCKDENOTATION,emptylist(),valstk[2]])])
		ge1.ge_element.bld_precedence := INFINITE
	    }
	    ge2 := mknode([GUARDEDELEMENT, mknode([WORDELSE]), valstk[1]])
	    yyval := mklist([ge1, ge2])

end

procedure action_142()
#line 1044 "pass1/parser/grammar.indent.y"
 local i, c
	  i := 0

	  yyperror("Error in Loop or If")
		c := yychar
		  while not (in(c, condstop)) do {
		    i +:= 1
                    if ( i > maxskip ) then {
			break
		      }
		        c := yylex()

                      }
          yyclearin
          case (c) of {
               "#" :
                  yyunlex(c)
               FI :
                  yyunlex(c)
               OD :
                  yyunlex(c)
	       RIGHT_ARROW :
		 {
		  yyunlex(RIGHT_ARROW)
		 yyunlex(WORDID)
		 yyunlex("#")
		    }
	       ELSE :
		 {
		  yyunlex(RIGHT_ARROW)
		 yyunlex(WORDID)
		 yyunlex("#")
		    }
	       THEN :
		 {
		  yyunlex(RIGHT_ARROW)
		 yyunlex(WORDID)
		 yyunlex("#")
		    }
		 ";" :
		 {
		  yyunlex(RIGHT_ARROW)
		 yyunlex(WORDID)
		 yyunlex("#")
		    }
               LET :
		 {
                  yyunlex(c)
                  yyunlex(RIGHT_ARROW)
                  yyunlex(WORDID)
                  yyunlex("#")
		    }
               "(" :
		 {
                  yyunlex(c)
                  yyunlex(RIGHT_ARROW)
                  yyunlex(WORDID)
                  yyunlex("#")
		    }
               DO :
		 {
                  yyunlex(c)
                  yyunlex(RIGHT_ARROW)
                  yyunlex(WORDID)
                  yyunlex("#")
		    }
		 IF :
		 {
                  yyunlex(c)
                  yyunlex(RIGHT_ARROW)
                  yyunlex(WORDID)
                  yyunlex("#")
		    }
	       EOF:
		  exit(1)
	  default :
		 {
                  yyunlex(c)
		    yyunlex(END)
		    }
          }
	  yyval := emptylist()

end

procedure action_143()
#line 1129 "pass1/parser/grammar.indent.y"

	{
	  if (length(valstk[1]) = 1) then {
		yyval := mknode([GUARDEDELEMENT,valstk[3],first(valstk[1])])
	    } else {
		p := mknode([GUARDEDELEMENT,valstk[3],
				mknode([BLOCKDENOTATION,emptylist(),valstk[1]])])
		yyval:= p
		p.ge_element.bld_precedence := INFINITE
	    }

}
end

procedure action_144()
#line 1142 "pass1/parser/grammar.indent.y"

        { yyval := mknode([LETTERID,valstk[1]])
}
end

procedure action_145()
#line 1144 "pass1/parser/grammar.indent.y"

        { yyval := mknode([OPRID,valstk[1]])
}
end

procedure action_146()
#line 1148 "pass1/parser/grammar.indent.y"

        { yyval := mknode([QSTR,valstk[1]])
}
end

procedure action_147()
#line 1150 "pass1/parser/grammar.indent.y"

        { yyval := mknode([UQSTR,valstk[1]])
}
end

#line 2354 "pass1/parser/grammar.icn"
