### 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 1148 "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 ((first(valstk[3]) . 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 ((first(valstk[3]) . 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 ((first(valstk[3]) . 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 ((first(valstk[3]) . 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 118 "pass1/parser/grammar.indent.y"

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

procedure action_8()
#line 121 "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 185 "pass1/parser/grammar.indent.y"
    yyval := TRUE
end

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

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

    { yyval := valstk[1]
  }
end

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

    { yyval := emptylist()
  }
end

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

    { yyval := valstk[1]
  }
end

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

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

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

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

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

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

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

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

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

    yyval := sig_Signature

end

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

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

    }
end

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

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

    }
end

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

    { yyval := valstk[1]
  }
end

procedure action_23()
#line 229 "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 239 "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 249 "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 259 "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 269 "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 278 "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 286 "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 296 "pass1/parser/grammar.indent.y"

    { yyval := FALSE
  }
end

procedure action_31()
#line 301 "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 313 "pass1/parser/grammar.indent.y"

    { yyval := nil
  }
end

procedure action_33()
#line 318 "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 359 "pass1/parser/grammar.indent.y"

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

    }
end

procedure action_35()
#line 364 "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 373 "pass1/parser/grammar.indent.y"

    { yyval := valstk[1]
  }
end

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

    { yyval := emptylist()
  }
end

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

    { yyval := valstk[1]
  }
end

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

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

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

    { yyval := valstk[1]
  }
end

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

    { yyval := nil
  }
end

procedure action_42()
#line 391 "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 405 "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 437 "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 475 "pass1/parser/grammar.indent.y"

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

    }
end

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

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

end

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

    { yyval := PRESENT
  }
end

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

    { yyval := NOTPRESENT
  }
end

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

procedure action_51()
#line 497 "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 506 "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 517 "pass1/parser/grammar.indent.y"

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

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

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

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

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

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

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

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

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

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

procedure action_63()
#line 540 "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 553 "pass1/parser/grammar.indent.y"

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

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

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

procedure action_66()
#line 557 "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 564 "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 570 "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 578 "pass1/parser/grammar.indent.y"

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

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

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

procedure action_71()
#line 583 "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 654 "pass1/parser/grammar.indent.y"

    { yyval := valstk[1]
  }
end

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

    { yyval := nil
  }
end

procedure action_74()
#line 660 "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 {
	    global_fn_count := global_fn_count + 1
	    yyval . fc_code_label := "fn_global_" || global_fn_count
	}

    }
end

procedure action_75()
#line 675 "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 684 "pass1/parser/grammar.indent.y"

    { yyval := valstk[1]
  }
end

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

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

    }
end

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

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

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

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

    }
end

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

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

    }
end

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

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

    }
end

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

    {
	yyval := valstk[1]

    }
end

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

    { yyval := valstk[1]
  }
end

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

    { yyval := valstk[1]
  }
end

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

    { yyval := valstk[1]
  }
end

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

    { yyval := valstk[1]
  }
end

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

    { yyval := valstk[1]
  }
end

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

    { yyval := valstk[1]
  }
end

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

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

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

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

    { yyval := valstk[2]
  }
end

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

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

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

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

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

    { yyval := emptylist()
  }
end

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

    { yyval := valstk[1]
  }
end

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

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

procedure action_97()
#line 755 "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 765 "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 781 "pass1/parser/grammar.indent.y"

    { yyval := emptylist()
  }
end

procedure action_100()
#line 784 "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 851 "pass1/parser/grammar.indent.y"

    { yyval := valstk[1]
  }
end

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

    { yyval := nil
  }
end

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

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

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

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

procedure action_105()
#line 865 "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 879 "pass1/parser/grammar.indent.y"
    yyperror("Error in product construction")
end

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

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

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

procedure action_109()
#line 888 "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 903 "pass1/parser/grammar.indent.y"
    yyperror("Error in union construction")
end

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

    { yyval := valstk[1]
  }
end

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

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

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

    { yyval := valstk[1]
  }
end

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

    { yyval := emptylist()
  }
end

procedure action_115()
#line 918 "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 931 "pass1/parser/grammar.indent.y"

    { yyval := valstk[1]
  }
end

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

    { yyval := valstk[1]
  }
end

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

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

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

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

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

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

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

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

    { yyval := EXPORTLIST
  }
end

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

    { yyval := HIDELIST
  }
end

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

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

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

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

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

    { yyval := emptylist()
  }
end

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

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

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

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

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

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

    { yyval := valstk[1]
  }
end

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

    { yyval := nil
  }
end

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

    { yyval := valstk[2]
  }
end

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

    { yyval := nil
  }
end

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

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

    yyval := appl_Null

end

procedure action_137()
#line 994 "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 1004 "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 1019 "pass1/parser/grammar.indent.y"

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

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

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

procedure action_141()
#line 1024 "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 1038 "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 1123 "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 1136 "pass1/parser/grammar.indent.y"

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

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

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

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

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

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

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

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