### 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"