# line 2 "../common/dt_grammar.y" /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * Copyright (c) 2014, 2016 by Delphix. All rights reserved. * Copyright (c) 2013, Joyent, Inc. All rights reserved. */ #include #define OP1(op, c) dt_node_op1(op, c) #define OP2(op, l, r) dt_node_op2(op, l, r) #define OP3(x, y, z) dt_node_op3(x, y, z) #define LINK(l, r) dt_node_link(l, r) #define DUP(s) strdup(s) # line 42 "../common/dt_grammar.y" typedef union #ifdef __cplusplus YYSTYPE #endif { dt_node_t *l_node; dt_decl_t *l_decl; char *l_str; uintmax_t l_int; int l_tok; } YYSTYPE; # define DT_TOK_COMMA 257 # define DT_TOK_ELLIPSIS 258 # define DT_TOK_ASGN 259 # define DT_TOK_ADD_EQ 260 # define DT_TOK_SUB_EQ 261 # define DT_TOK_MUL_EQ 262 # define DT_TOK_DIV_EQ 263 # define DT_TOK_MOD_EQ 264 # define DT_TOK_AND_EQ 265 # define DT_TOK_XOR_EQ 266 # define DT_TOK_OR_EQ 267 # define DT_TOK_LSH_EQ 268 # define DT_TOK_RSH_EQ 269 # define DT_TOK_QUESTION 270 # define DT_TOK_COLON 271 # define DT_TOK_LOR 272 # define DT_TOK_LXOR 273 # define DT_TOK_LAND 274 # define DT_TOK_BOR 275 # define DT_TOK_XOR 276 # define DT_TOK_BAND 277 # define DT_TOK_EQU 278 # define DT_TOK_NEQ 279 # define DT_TOK_LT 280 # define DT_TOK_LE 281 # define DT_TOK_GT 282 # define DT_TOK_GE 283 # define DT_TOK_LSH 284 # define DT_TOK_RSH 285 # define DT_TOK_ADD 286 # define DT_TOK_SUB 287 # define DT_TOK_MUL 288 # define DT_TOK_DIV 289 # define DT_TOK_MOD 290 # define DT_TOK_LNEG 291 # define DT_TOK_BNEG 292 # define DT_TOK_ADDADD 293 # define DT_TOK_SUBSUB 294 # define DT_TOK_PREINC 295 # define DT_TOK_POSTINC 296 # define DT_TOK_PREDEC 297 # define DT_TOK_POSTDEC 298 # define DT_TOK_IPOS 299 # define DT_TOK_INEG 300 # define DT_TOK_DEREF 301 # define DT_TOK_ADDROF 302 # define DT_TOK_OFFSETOF 303 # define DT_TOK_SIZEOF 304 # define DT_TOK_STRINGOF 305 # define DT_TOK_XLATE 306 # define DT_TOK_LPAR 307 # define DT_TOK_RPAR 308 # define DT_TOK_LBRAC 309 # define DT_TOK_RBRAC 310 # define DT_TOK_PTR 311 # define DT_TOK_DOT 312 # define DT_TOK_STRING 313 # define DT_TOK_IDENT 314 # define DT_TOK_PSPEC 315 # define DT_TOK_AGG 316 # define DT_TOK_TNAME 317 # define DT_TOK_INT 318 # define DT_KEY_AUTO 319 # define DT_KEY_BREAK 320 # define DT_KEY_CASE 321 # define DT_KEY_CHAR 322 # define DT_KEY_CONST 323 # define DT_KEY_CONTINUE 324 # define DT_KEY_COUNTER 325 # define DT_KEY_DEFAULT 326 # define DT_KEY_DO 327 # define DT_KEY_DOUBLE 328 # define DT_KEY_ELSE 329 # define DT_KEY_ENUM 330 # define DT_KEY_EXTERN 331 # define DT_KEY_FLOAT 332 # define DT_KEY_FOR 333 # define DT_KEY_GOTO 334 # define DT_KEY_IF 335 # define DT_KEY_IMPORT 336 # define DT_KEY_INLINE 337 # define DT_KEY_INT 338 # define DT_KEY_LONG 339 # define DT_KEY_PROBE 340 # define DT_KEY_PROVIDER 341 # define DT_KEY_REGISTER 342 # define DT_KEY_RESTRICT 343 # define DT_KEY_RETURN 344 # define DT_KEY_SELF 345 # define DT_KEY_SHORT 346 # define DT_KEY_SIGNED 347 # define DT_KEY_STATIC 348 # define DT_KEY_STRING 349 # define DT_KEY_STRUCT 350 # define DT_KEY_SWITCH 351 # define DT_KEY_THIS 352 # define DT_KEY_TYPEDEF 353 # define DT_KEY_UNION 354 # define DT_KEY_UNSIGNED 355 # define DT_KEY_USERLAND 356 # define DT_KEY_VOID 357 # define DT_KEY_VOLATILE 358 # define DT_KEY_WHILE 359 # define DT_KEY_XLATOR 360 # define DT_TOK_EPRED 361 # define DT_CTX_DEXPR 362 # define DT_CTX_DPROG 363 # define DT_CTX_DTYPE 364 # define DT_TOK_EOF 0 #include #ifdef __STDC__ #include #include #define YYCONST const #else #include #include #define YYCONST #endif #include #if defined(__cplusplus) || defined(__STDC__) #if defined(__cplusplus) && defined(__EXTERN_C__) extern "C" { #endif #ifndef yyerror #if defined(__cplusplus) void yyerror(YYCONST char *); #endif #endif #ifndef yylex int yylex(void); #endif int yyparse(void); #if defined(__cplusplus) && defined(__EXTERN_C__) } #endif #endif #define yyclearin yychar = -1 #define yyerrok yyerrflag = 0 extern int yychar; extern int yyerrflag; YYSTYPE yylval; YYSTYPE yyval; typedef int yytabelem; #ifndef YYMAXDEPTH #define YYMAXDEPTH 150 #endif #if YYMAXDEPTH > 0 int yy_yys[YYMAXDEPTH], *yys = yy_yys; YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv; #else /* user does initial allocation */ int *yys; YYSTYPE *yyv; #endif static int yymaxdepth = YYMAXDEPTH; # define YYERRCODE 256 # line 862 "../common/dt_grammar.y" static YYCONST yytabelem yyexca[] ={ -1, 1, 0, -1, -2, 0, -1, 192, 288, 212, 307, 212, 309, 212, 314, 212, -2, 242, }; # define YYNPROD 246 # define YYLAST 815 static YYCONST yytabelem yyact[]={ 302, 5, 6, 7, 357, 318, 360, 103, 168, 369, 336, 86, 313, 66, 87, 314, 234, 278, 321, 26, 303, 188, 206, 12, 164, 207, 317, 182, 28, 29, 27, 168, 169, 31, 30, 17, 18, 204, 157, 166, 205, 338, 337, 83, 185, 24, 20, 21, 25, 39, 192, 364, 193, 179, 327, 36, 33, 166, 34, 80, 35, 88, 356, 84, 70, 83, 241, 103, 193, 253, 75, 268, 96, 91, 74, 192, 241, 193, 85, 298, 72, 73, 166, 288, 89, 84, 168, 37, 71, 76, 90, 79, 97, 26, 38, 92, 98, 77, 78, 69, 85, 271, 28, 29, 27, 169, 103, 31, 30, 17, 18, 286, 166, 192, 323, 193, 168, 163, 353, 24, 20, 21, 25, 39, 269, 191, 168, 196, 197, 36, 33, 214, 34, 80, 35, 192, 315, 193, 70, 83, 133, 158, 201, 201, 75, 169, 96, 251, 74, 149, 150, 268, 166, 103, 72, 73, 341, 348, 128, 84, 273, 37, 71, 76, 14, 79, 97, 232, 38, 346, 98, 77, 78, 69, 85, 134, 124, 126, 140, 129, 131, 264, 160, 136, 86, 139, 80, 87, 88, 11, 242, 70, 83, 151, 152, 153, 135, 75, 14, 96, 91, 74, 270, 279, 213, 132, 56, 72, 73, 261, 58, 89, 84, 138, 67, 71, 76, 90, 79, 97, 280, 68, 92, 98, 77, 78, 69, 85, 80, 57, 88, 248, 280, 70, 83, 183, 147, 148, 184, 75, 358, 96, 91, 74, 177, 141, 142, 178, 293, 72, 73, 358, 367, 89, 84, 352, 165, 71, 76, 90, 79, 97, 14, 14, 92, 98, 77, 78, 69, 85, 322, 300, 294, 231, 302, 291, 14, 14, 14, 305, 305, 117, 186, 116, 14, 243, 284, 328, 316, 14, 240, 80, 312, 88, 252, 258, 70, 83, 181, 256, 272, 199, 75, 170, 96, 91, 74, 159, 143, 145, 144, 146, 72, 73, 263, 361, 89, 84, 14, 67, 71, 76, 90, 79, 97, 103, 68, 92, 98, 77, 78, 69, 85, 80, 162, 88, 284, 103, 70, 83, 340, 345, 305, 236, 75, 46, 96, 91, 74, 347, 362, 267, 175, 261, 72, 73, 242, 187, 89, 84, 365, 237, 71, 76, 90, 79, 97, 13, 240, 92, 98, 77, 78, 69, 85, 80, 373, 100, 32, 370, 70, 83, 374, 354, 122, 123, 75, 263, 96, 65, 74, 372, 281, 40, 14, 43, 72, 73, 119, 350, 118, 84, 121, 120, 71, 76, 42, 79, 97, 324, 252, 168, 98, 77, 78, 69, 85, 14, 260, 283, 259, 190, 329, 80, 255, 245, 47, 14, 70, 83, 169, 257, 254, 60, 75, 41, 96, 166, 74, 233, 325, 375, 297, 167, 72, 73, 187, 343, 371, 84, 243, 368, 71, 76, 366, 79, 97, 44, 349, 101, 98, 77, 78, 69, 85, 200, 63, 351, 103, 342, 320, 176, 10, 292, 14, 14, 9, 359, 8, 194, 195, 319, 14, 265, 266, 102, 330, 180, 22, 95, 155, 250, 64, 224, 225, 174, 171, 172, 173, 339, 93, 289, 304, 62, 26, 50, 275, 344, 1, 63, 94, 209, 14, 28, 29, 27, 63, 99, 31, 30, 17, 18, 63, 63, 63, 19, 14, 249, 14, 212, 24, 20, 21, 25, 39, 64, 217, 363, 310, 309, 36, 33, 64, 34, 189, 35, 216, 104, 64, 64, 64, 282, 176, 363, 26, 154, 296, 137, 48, 238, 247, 331, 285, 28, 29, 27, 326, 23, 31, 30, 17, 18, 37, 287, 215, 156, 226, 227, 127, 38, 24, 20, 21, 25, 39, 203, 239, 26, 16, 331, 36, 33, 15, 34, 299, 35, 28, 29, 27, 218, 219, 31, 30, 17, 18, 198, 308, 301, 244, 82, 262, 81, 285, 24, 20, 21, 25, 39, 202, 161, 55, 295, 37, 36, 33, 45, 34, 235, 35, 38, 26, 189, 61, 189, 295, 311, 59, 54, 277, 28, 29, 27, 53, 355, 31, 30, 17, 18, 208, 52, 51, 210, 211, 49, 246, 37, 24, 20, 21, 25, 39, 295, 38, 26, 239, 4, 36, 33, 3, 34, 2, 35, 28, 29, 27, 0, 0, 31, 30, 17, 18, 0, 0, 262, 0, 0, 0, 0, 0, 24, 20, 21, 25, 125, 0, 0, 0, 0, 37, 36, 33, 0, 34, 0, 35, 38, 26, 0, 0, 0, 228, 229, 230, 0, 0, 28, 29, 27, 0, 0, 31, 30, 17, 18, 0, 306, 306, 0, 0, 0, 290, 37, 24, 20, 21, 25, 130, 0, 38, 333, 334, 335, 36, 33, 0, 34, 0, 35, 332, 0, 276, 307, 307, 105, 109, 110, 106, 107, 108, 113, 114, 115, 111, 112, 0, 63, 63, 63, 0, 220, 221, 222, 223, 274, 37, 332, 332, 0, 0, 0, 0, 38, 0, 0, 0, 0, 0, 0, 306, 0, 0, 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 307 }; static YYCONST yytabelem yypact[]={ -361,-10000000, 478, 476, 472, 353, -131, 58,-10000000,-10000000, -10000000, 68,-10000000,-10000000, 494, 11, 91, 386, 386, 353, 429, 386, -68,-10000000, -167, -105,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000, -78,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -184, -62, -91, -99, -33, 28, -48, -137, -95,-10000000, -131, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -26, 58, -276, 18, 123, 46, -26, -26, -26,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000, 58, -70, -287, -79,-10000000,-10000000,-10000000, -172, 58, 58, 353, 353,-10000000,-10000000,-10000000,-10000000,-10000000, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 353, 353, 353, 310, -277, -292,-10000000,-10000000,-10000000, 353,-10000000,-10000000,-10000000,-10000000, -184,-10000000, 353, 58, 58, 353, -104, -177, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353,-10000000, -162, -113, 316,-10000000, 353, -10000000, 302,-10000000,-10000000, -241, -275,-10000000, -162, -280,-10000000, -304,-10000000,-10000000,-10000000, 106,-10000000, -202, 309, 301,-10000000, 174,-10000000, 36, 297, 295,-10000000,-10000000, -194, -241, -172, -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -68, 80, -186,-10000000,-10000000, -106,-10000000,-10000000,-10000000,-10000000, -207, -78, 43, -122, -62,-10000000, 353, -91, -99, -33, 28, 28, -48, -48, -48, -48, -137, -137, -95, -95,-10000000,-10000000, -10000000,-10000000, 58, -108, 267, 277, -250,-10000000, -162,-10000000, -10000000,-10000000, -241, -225, -280,-10000000,-10000000,-10000000,-10000000,-10000000, 216,-10000000, -23, 353,-10000000,-10000000,-10000000, -287, 353,-10000000, -10000000, -241,-10000000,-10000000, -229, 16, -258, 353, 353,-10000000, -10000000,-10000000, -302, -171,-10000000, 29, -288, -120, 411,-10000000, -296,-10000000,-10000000, 211,-10000000, -193, 286,-10000000,-10000000,-10000000, -10000000,-10000000, -202, 353,-10000000,-10000000,-10000000,-10000000,-10000000, -254, -10000000, 30,-10000000,-10000000, -257, -26, -26, -26, -300,-10000000, -10000000,-10000000,-10000000, -266, -267, 353, 353, -126, 410,-10000000, -10000000, -231,-10000000, 353,-10000000,-10000000,-10000000,-10000000, -89,-10000000, -10000000, -232, -257,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -151, 399, 276,-10000000, 196, -190, 258,-10000000,-10000000,-10000000,-10000000, -63, -231,-10000000, 227,-10000000, -74, 395,-10000000, -7, 392, -320,-10000000,-10000000, 211, 389,-10000000,-10000000, 353,-10000000, 227, 257,-10000000, 382,-10000000,-10000000,-10000000 }; static YYCONST yytabelem yypgo[]={ 0, 670, 668, 665, 653, 505, 650, 649, 643, 4, 642, 638, 203, 637, 636, 632, 389, 16, 627, 6, 315, 620, 619, 334, 459, 485, 611, 377, 609, 117, 24, 256, 608, 517, 181, 21, 271, 607, 20, 421, 606, 125, 594, 183, 23, 367, 272, 592, 488, 378, 393, 435, 406, 395, 457, 625, 345, 426, 558, 158, 588, 567, 465, 547, 525, 510, 508, 433, 506, 503, 502, 13, 500, 495, 352, 491, 147, 489, 487, 298, 443, 484, 483 }; static YYCONST yytabelem yyr1[]={ 0, 66, 66, 66, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5, 5, 68, 6, 7, 7, 8, 8, 9, 10, 10, 11, 11, 12, 12, 13, 13, 13, 13, 14, 15, 15, 16, 16, 18, 18, 17, 17, 19, 19, 20, 20, 20, 20, 62, 62, 61, 61, 61, 61, 61, 61, 61, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 59, 59, 59, 59, 59, 59, 59, 64, 64, 64, 64, 64, 64, 58, 58, 57, 57, 57, 57, 56, 56, 56, 55, 55, 55, 54, 54, 54, 54, 54, 53, 53, 53, 52, 52, 51, 51, 50, 50, 49, 49, 48, 48, 47, 47, 46, 45, 45, 44, 44, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 43, 43, 21, 21, 67, 67, 67, 67, 67, 67, 70, 70, 70, 70, 70, 70, 71, 71, 71, 71, 71, 69, 69, 69, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25, 26, 26, 26, 72, 72, 72, 65, 65, 73, 73, 22, 22, 23, 74, 27, 27, 27, 27, 75, 75, 76, 76, 76, 28, 28, 28, 77, 77, 77, 78, 78, 79, 79, 29, 29, 30, 30, 30, 30, 80, 31, 31, 31, 31, 32, 32, 36, 36, 36, 37, 37, 38, 38, 38, 33, 33, 34, 34, 34, 35, 35, 35, 35, 35, 81, 39, 40, 40, 40, 82, 41, 42, 42 }; static YYCONST yytabelem yyr2[]={ 0, 5, 5, 5, 3, 5, 3, 5, 3, 5, 2, 5, 2, 2, 2, 2, 2, 1, 15, 21, 19, 2, 5, 9, 13, 11, 2, 5, 13, 9, 3, 9, 9, 15, 3, 2, 7, 3, 3, 1, 5, 3, 5, 2, 7, 3, 5, 11, 15, 2, 7, 3, 3, 3, 3, 3, 3, 7, 2, 9, 7, 9, 7, 7, 7, 7, 5, 5, 13, 13, 15, 2, 5, 5, 5, 5, 9, 5, 3, 3, 3, 3, 3, 3, 2, 9, 2, 7, 7, 7, 2, 7, 7, 2, 7, 7, 2, 7, 7, 7, 7, 2, 7, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 7, 2, 2, 11, 2, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 7, 5, 7, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 3, 3, 3, 3, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 3, 3, 3, 7, 5, 5, 5, 7, 7, 3, 3, 2, 4, 2, 7, 3, 7, 2, 5, 2, 5, 2, 6, 3, 5, 7, 7, 5, 5, 5, 7, 7, 2, 6, 3, 7, 2, 4, 3, 7, 5, 5, 3, 3, 5, 5, 7, 2, 5, 2, 3, 7, 2, 7, 3, 5, 5, 3, 5, 2, 2, 4, 7, 5, 3, 5, 3, 1, 9, 1, 3, 3, 1, 9, 1, 3 }; static YYCONST yytabelem yychk[]={ -10000000, -66, -1, -2, -3, 362, 363, 364, 0, 0, 0, -43, -44, -45, -59, -47, -60, 293, 294, -64, 304, 305, -48, -61, 303, 306, 277, 288, 286, 287, 292, 291, -49, 314, 316, 318, 313, 345, 352, 307, -50, -51, -52, -53, -54, -55, -56, -57, -58, -4, -5, -6, -7, -10, -13, -21, 337, 360, 341, -14, -67, -15, -69, -24, -25, -16, -71, 345, 352, 357, 322, 346, 338, 339, 332, 328, 347, 355, 356, 349, 317, -26, -28, 323, 343, 358, 315, 318, 319, 342, 348, 331, 353, -72, -65, -77, 330, 350, 354, -33, -27, -24, -25, 257, -63, 259, 262, 263, 264, 260, 261, 268, 269, 265, 266, 267, 272, 270, 309, 307, 312, 311, 293, 294, -59, 307, -59, -58, -59, -59, 307, -59, 273, 307, 280, 274, -43, -33, 275, 276, 277, 278, 279, 280, 282, 281, 283, 284, 285, 286, 287, 288, 289, 290, -5, -67, -33, 314, 123, 289, 59, -22, -23, -29, -30, -31, 314, -80, 288, 307, 257, -67, -67, -67, -73, -74, -27, 314, 317, 123, -78, -79, 314, 314, 317, 123, -34, -31, -35, -80, -39, -41, 307, 309, -27, -27, -44, -44, -48, -43, -62, -44, 308, -62, 314, 317, 314, 317, -33, -49, -33, -33, -50, 308, 308, -51, -52, -53, -54, -54, -55, -55, -55, -55, -56, -56, -57, -57, -58, -58, -58, -29, 280, 123, -17, -18, -43, 59, 257, -39, -41, 307, -30, -29, -32, -31, -25, -16, 125, -74, -75, -76, -29, 271, 123, 123, 125, 257, 259, 123, 123, -35, -39, -41, -34, -82, -81, 271, 257, 310, 308, 308, 257, 282, -58, -68, -33, -11, 125, -12, 340, 125, -20, -43, 59, 335, 361, -23, 308, -31, -25, 59, 257, 271, -46, -45, -79, -43, 308, -42, -36, -37, 258, -38, -70, -71, -24, -25, -40, -46, -36, -45, -44, 314, 317, 307, 259, 314, 125, -12, 59, 314, 59, 307, 123, -76, -46, 308, 257, -29, -34, -31, -80, -67, -67, -67, 310, 308, 308, -43, -44, 282, 59, -41, -43, -17, 258, -38, 308, 59, 123, 271, 59, 308, 125, -8, 125, -9, 314, -41, -19, -20, 123, -43, 125, -9, 59, 259, 59, 329, -17, 59, -44, -19, 125, 59 }; static YYCONST yytabelem yydef[]={ 0, -2, 0, 0, 0, 4, 6, 8, 1, 2, 3, 5, 132, 119, 84, 117, 71, 0, 0, 0, 0, 0, 114, 58, 0, 0, 78, 79, 80, 81, 82, 83, 112, 51, 52, 53, 54, 55, 56, 0, 110, 108, 106, 104, 101, 96, 93, 90, 86, 7, 10, 12, 13, 14, 15, 16, 0, 0, 0, 30, 0, 34, 136, 138, 140, 35, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 37, 38, 148, 149, 150, 151, 152, 0, 0, 0, 0, 179, 180, 9, 227, 187, 189, 0, 0, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 0, 0, 0, 0, 0, 0, 66, 67, 72, 0, 73, 74, 84, 75, 0, 77, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 39, 0, 134, 0, 183, 185, 206, 0, 208, 0, 213, 212, 0, 137, 139, 141, 0, 181, 0, 174, 175, 176, 0, 202, 204, 197, 198, 199, 228, 229, 230, 0, 234, 236, -2, 237, 188, 190, 133, 120, 115, 0, 0, 49, 60, 0, 62, 63, 64, 65, 0, 113, 0, 0, 111, 57, 0, 109, 107, 105, 102, 103, 97, 98, 99, 100, 94, 95, 91, 92, 87, 88, 89, 17, 0, 0, 0, 41, 0, 135, 0, 210, 211, 242, 207, 0, 214, 215, 217, 36, 173, 182, 0, 191, 193, 0, 177, 178, 196, 0, 0, 200, 201, 231, 233, 235, 0, 244, 239, 0, 0, 59, 61, 76, 0, 0, 85, 0, 0, 0, 0, 26, 0, 31, 40, 42, 45, 0, 32, 184, 209, 216, 218, 186, 0, 0, 194, 116, 203, 205, 232, 0, 245, 219, 220, 222, 224, 142, 144, 146, 0, 240, 241, 118, 50, 0, 0, 0, 0, 0, 0, 27, 25, 0, 46, 0, 39, 192, 195, 243, 0, 225, 226, 229, 0, 143, 145, 147, 238, 68, 69, 0, 0, 0, 24, 0, 0, 0, 221, 223, 70, 18, 0, 0, 29, 0, 33, 0, 0, 21, 0, 0, 47, 43, 39, 0, 0, 22, 20, 0, 28, 0, 0, 19, 0, 48, 44, 23 }; typedef struct #ifdef __cplusplus yytoktype #endif { #ifdef __cplusplus const #endif char *t_name; int t_val; } yytoktype; #ifndef YYDEBUG # define YYDEBUG 0 /* don't allow debugging */ #endif #if YYDEBUG yytoktype yytoks[] = { "DT_TOK_COMMA", 257, "DT_TOK_ELLIPSIS", 258, "DT_TOK_ASGN", 259, "DT_TOK_ADD_EQ", 260, "DT_TOK_SUB_EQ", 261, "DT_TOK_MUL_EQ", 262, "DT_TOK_DIV_EQ", 263, "DT_TOK_MOD_EQ", 264, "DT_TOK_AND_EQ", 265, "DT_TOK_XOR_EQ", 266, "DT_TOK_OR_EQ", 267, "DT_TOK_LSH_EQ", 268, "DT_TOK_RSH_EQ", 269, "DT_TOK_QUESTION", 270, "DT_TOK_COLON", 271, "DT_TOK_LOR", 272, "DT_TOK_LXOR", 273, "DT_TOK_LAND", 274, "DT_TOK_BOR", 275, "DT_TOK_XOR", 276, "DT_TOK_BAND", 277, "DT_TOK_EQU", 278, "DT_TOK_NEQ", 279, "DT_TOK_LT", 280, "DT_TOK_LE", 281, "DT_TOK_GT", 282, "DT_TOK_GE", 283, "DT_TOK_LSH", 284, "DT_TOK_RSH", 285, "DT_TOK_ADD", 286, "DT_TOK_SUB", 287, "DT_TOK_MUL", 288, "DT_TOK_DIV", 289, "DT_TOK_MOD", 290, "DT_TOK_LNEG", 291, "DT_TOK_BNEG", 292, "DT_TOK_ADDADD", 293, "DT_TOK_SUBSUB", 294, "DT_TOK_PREINC", 295, "DT_TOK_POSTINC", 296, "DT_TOK_PREDEC", 297, "DT_TOK_POSTDEC", 298, "DT_TOK_IPOS", 299, "DT_TOK_INEG", 300, "DT_TOK_DEREF", 301, "DT_TOK_ADDROF", 302, "DT_TOK_OFFSETOF", 303, "DT_TOK_SIZEOF", 304, "DT_TOK_STRINGOF", 305, "DT_TOK_XLATE", 306, "DT_TOK_LPAR", 307, "DT_TOK_RPAR", 308, "DT_TOK_LBRAC", 309, "DT_TOK_RBRAC", 310, "DT_TOK_PTR", 311, "DT_TOK_DOT", 312, "DT_TOK_STRING", 313, "DT_TOK_IDENT", 314, "DT_TOK_PSPEC", 315, "DT_TOK_AGG", 316, "DT_TOK_TNAME", 317, "DT_TOK_INT", 318, "DT_KEY_AUTO", 319, "DT_KEY_BREAK", 320, "DT_KEY_CASE", 321, "DT_KEY_CHAR", 322, "DT_KEY_CONST", 323, "DT_KEY_CONTINUE", 324, "DT_KEY_COUNTER", 325, "DT_KEY_DEFAULT", 326, "DT_KEY_DO", 327, "DT_KEY_DOUBLE", 328, "DT_KEY_ELSE", 329, "DT_KEY_ENUM", 330, "DT_KEY_EXTERN", 331, "DT_KEY_FLOAT", 332, "DT_KEY_FOR", 333, "DT_KEY_GOTO", 334, "DT_KEY_IF", 335, "DT_KEY_IMPORT", 336, "DT_KEY_INLINE", 337, "DT_KEY_INT", 338, "DT_KEY_LONG", 339, "DT_KEY_PROBE", 340, "DT_KEY_PROVIDER", 341, "DT_KEY_REGISTER", 342, "DT_KEY_RESTRICT", 343, "DT_KEY_RETURN", 344, "DT_KEY_SELF", 345, "DT_KEY_SHORT", 346, "DT_KEY_SIGNED", 347, "DT_KEY_STATIC", 348, "DT_KEY_STRING", 349, "DT_KEY_STRUCT", 350, "DT_KEY_SWITCH", 351, "DT_KEY_THIS", 352, "DT_KEY_TYPEDEF", 353, "DT_KEY_UNION", 354, "DT_KEY_UNSIGNED", 355, "DT_KEY_USERLAND", 356, "DT_KEY_VOID", 357, "DT_KEY_VOLATILE", 358, "DT_KEY_WHILE", 359, "DT_KEY_XLATOR", 360, "DT_TOK_EPRED", 361, "DT_CTX_DEXPR", 362, "DT_CTX_DPROG", 363, "DT_CTX_DTYPE", 364, "DT_TOK_EOF", 0, "-unknown-", -1 /* ends search */ }; #ifdef __cplusplus const #endif char * yyreds[] = { "-no such reduction-", "dtrace_program : d_expression DT_TOK_EOF", "dtrace_program : d_program DT_TOK_EOF", "dtrace_program : d_type DT_TOK_EOF", "d_expression : DT_CTX_DEXPR", "d_expression : DT_CTX_DEXPR expression", "d_program : DT_CTX_DPROG", "d_program : DT_CTX_DPROG translation_unit", "d_type : DT_CTX_DTYPE", "d_type : DT_CTX_DTYPE type_name", "translation_unit : external_declaration", "translation_unit : translation_unit external_declaration", "external_declaration : inline_definition", "external_declaration : translator_definition", "external_declaration : provider_definition", "external_declaration : probe_definition", "external_declaration : declaration", "inline_definition : DT_KEY_INLINE declaration_specifiers declarator", "inline_definition : DT_KEY_INLINE declaration_specifiers declarator DT_TOK_ASGN assignment_expression ';'", "translator_definition : DT_KEY_XLATOR type_name DT_TOK_LT type_name DT_TOK_IDENT DT_TOK_GT '{' translator_member_list '}' ';'", "translator_definition : DT_KEY_XLATOR type_name DT_TOK_LT type_name DT_TOK_IDENT DT_TOK_GT '{' '}' ';'", "translator_member_list : translator_member", "translator_member_list : translator_member_list translator_member", "translator_member : DT_TOK_IDENT DT_TOK_ASGN assignment_expression ';'", "provider_definition : DT_KEY_PROVIDER DT_TOK_IDENT '{' provider_probe_list '}' ';'", "provider_definition : DT_KEY_PROVIDER DT_TOK_IDENT '{' '}' ';'", "provider_probe_list : provider_probe", "provider_probe_list : provider_probe_list provider_probe", "provider_probe : DT_KEY_PROBE DT_TOK_IDENT function DT_TOK_COLON function ';'", "provider_probe : DT_KEY_PROBE DT_TOK_IDENT function ';'", "probe_definition : probe_specifiers", "probe_definition : probe_specifiers '{' statement_list '}'", "probe_definition : probe_specifiers DT_TOK_DIV expression DT_TOK_EPRED", "probe_definition : probe_specifiers DT_TOK_DIV expression DT_TOK_EPRED '{' statement_list '}'", "probe_specifiers : probe_specifier_list", "probe_specifier_list : probe_specifier", "probe_specifier_list : probe_specifier_list DT_TOK_COMMA probe_specifier", "probe_specifier : DT_TOK_PSPEC", "probe_specifier : DT_TOK_INT", "statement_list_impl : /* empty */", "statement_list_impl : statement_list_impl statement", "statement_list : statement_list_impl", "statement_list : statement_list_impl expression", "statement_or_block : statement", "statement_or_block : '{' statement_list '}'", "statement : ';'", "statement : expression ';'", "statement : DT_KEY_IF DT_TOK_LPAR expression DT_TOK_RPAR statement_or_block", "statement : DT_KEY_IF DT_TOK_LPAR expression DT_TOK_RPAR statement_or_block DT_KEY_ELSE statement_or_block", "argument_expression_list : assignment_expression", "argument_expression_list : argument_expression_list DT_TOK_COMMA assignment_expression", "primary_expression : DT_TOK_IDENT", "primary_expression : DT_TOK_AGG", "primary_expression : DT_TOK_INT", "primary_expression : DT_TOK_STRING", "primary_expression : DT_KEY_SELF", "primary_expression : DT_KEY_THIS", "primary_expression : DT_TOK_LPAR expression DT_TOK_RPAR", "postfix_expression : primary_expression", "postfix_expression : postfix_expression DT_TOK_LBRAC argument_expression_list DT_TOK_RBRAC", "postfix_expression : postfix_expression DT_TOK_LPAR DT_TOK_RPAR", "postfix_expression : postfix_expression DT_TOK_LPAR argument_expression_list DT_TOK_RPAR", "postfix_expression : postfix_expression DT_TOK_DOT DT_TOK_IDENT", "postfix_expression : postfix_expression DT_TOK_DOT DT_TOK_TNAME", "postfix_expression : postfix_expression DT_TOK_PTR DT_TOK_IDENT", "postfix_expression : postfix_expression DT_TOK_PTR DT_TOK_TNAME", "postfix_expression : postfix_expression DT_TOK_ADDADD", "postfix_expression : postfix_expression DT_TOK_SUBSUB", "postfix_expression : DT_TOK_OFFSETOF DT_TOK_LPAR type_name DT_TOK_COMMA DT_TOK_IDENT DT_TOK_RPAR", "postfix_expression : DT_TOK_OFFSETOF DT_TOK_LPAR type_name DT_TOK_COMMA DT_TOK_TNAME DT_TOK_RPAR", "postfix_expression : DT_TOK_XLATE DT_TOK_LT type_name DT_TOK_GT DT_TOK_LPAR expression DT_TOK_RPAR", "unary_expression : postfix_expression", "unary_expression : DT_TOK_ADDADD unary_expression", "unary_expression : DT_TOK_SUBSUB unary_expression", "unary_expression : unary_operator cast_expression", "unary_expression : DT_TOK_SIZEOF unary_expression", "unary_expression : DT_TOK_SIZEOF DT_TOK_LPAR type_name DT_TOK_RPAR", "unary_expression : DT_TOK_STRINGOF unary_expression", "unary_operator : DT_TOK_BAND", "unary_operator : DT_TOK_MUL", "unary_operator : DT_TOK_ADD", "unary_operator : DT_TOK_SUB", "unary_operator : DT_TOK_BNEG", "unary_operator : DT_TOK_LNEG", "cast_expression : unary_expression", "cast_expression : DT_TOK_LPAR type_name DT_TOK_RPAR cast_expression", "multiplicative_expression : cast_expression", "multiplicative_expression : multiplicative_expression DT_TOK_MUL cast_expression", "multiplicative_expression : multiplicative_expression DT_TOK_DIV cast_expression", "multiplicative_expression : multiplicative_expression DT_TOK_MOD cast_expression", "additive_expression : multiplicative_expression", "additive_expression : additive_expression DT_TOK_ADD multiplicative_expression", "additive_expression : additive_expression DT_TOK_SUB multiplicative_expression", "shift_expression : additive_expression", "shift_expression : shift_expression DT_TOK_LSH additive_expression", "shift_expression : shift_expression DT_TOK_RSH additive_expression", "relational_expression : shift_expression", "relational_expression : relational_expression DT_TOK_LT shift_expression", "relational_expression : relational_expression DT_TOK_GT shift_expression", "relational_expression : relational_expression DT_TOK_LE shift_expression", "relational_expression : relational_expression DT_TOK_GE shift_expression", "equality_expression : relational_expression", "equality_expression : equality_expression DT_TOK_EQU relational_expression", "equality_expression : equality_expression DT_TOK_NEQ relational_expression", "and_expression : equality_expression", "and_expression : and_expression DT_TOK_BAND equality_expression", "exclusive_or_expression : and_expression", "exclusive_or_expression : exclusive_or_expression DT_TOK_XOR and_expression", "inclusive_or_expression : exclusive_or_expression", "inclusive_or_expression : inclusive_or_expression DT_TOK_BOR exclusive_or_expression", "logical_and_expression : inclusive_or_expression", "logical_and_expression : logical_and_expression DT_TOK_LAND inclusive_or_expression", "logical_xor_expression : logical_and_expression", "logical_xor_expression : logical_xor_expression DT_TOK_LXOR logical_and_expression", "logical_or_expression : logical_xor_expression", "logical_or_expression : logical_or_expression DT_TOK_LOR logical_xor_expression", "constant_expression : conditional_expression", "conditional_expression : logical_or_expression", "conditional_expression : logical_or_expression DT_TOK_QUESTION expression DT_TOK_COLON conditional_expression", "assignment_expression : conditional_expression", "assignment_expression : unary_expression assignment_operator assignment_expression", "assignment_operator : DT_TOK_ASGN", "assignment_operator : DT_TOK_MUL_EQ", "assignment_operator : DT_TOK_DIV_EQ", "assignment_operator : DT_TOK_MOD_EQ", "assignment_operator : DT_TOK_ADD_EQ", "assignment_operator : DT_TOK_SUB_EQ", "assignment_operator : DT_TOK_LSH_EQ", "assignment_operator : DT_TOK_RSH_EQ", "assignment_operator : DT_TOK_AND_EQ", "assignment_operator : DT_TOK_XOR_EQ", "assignment_operator : DT_TOK_OR_EQ", "expression : assignment_expression", "expression : expression DT_TOK_COMMA assignment_expression", "declaration : declaration_specifiers ';'", "declaration : declaration_specifiers init_declarator_list ';'", "declaration_specifiers : d_storage_class_specifier", "declaration_specifiers : d_storage_class_specifier declaration_specifiers", "declaration_specifiers : type_specifier", "declaration_specifiers : type_specifier declaration_specifiers", "declaration_specifiers : type_qualifier", "declaration_specifiers : type_qualifier declaration_specifiers", "parameter_declaration_specifiers : storage_class_specifier", "parameter_declaration_specifiers : storage_class_specifier declaration_specifiers", "parameter_declaration_specifiers : type_specifier", "parameter_declaration_specifiers : type_specifier declaration_specifiers", "parameter_declaration_specifiers : type_qualifier", "parameter_declaration_specifiers : type_qualifier declaration_specifiers", "storage_class_specifier : DT_KEY_AUTO", "storage_class_specifier : DT_KEY_REGISTER", "storage_class_specifier : DT_KEY_STATIC", "storage_class_specifier : DT_KEY_EXTERN", "storage_class_specifier : DT_KEY_TYPEDEF", "d_storage_class_specifier : storage_class_specifier", "d_storage_class_specifier : DT_KEY_SELF", "d_storage_class_specifier : DT_KEY_THIS", "type_specifier : DT_KEY_VOID", "type_specifier : DT_KEY_CHAR", "type_specifier : DT_KEY_SHORT", "type_specifier : DT_KEY_INT", "type_specifier : DT_KEY_LONG", "type_specifier : DT_KEY_FLOAT", "type_specifier : DT_KEY_DOUBLE", "type_specifier : DT_KEY_SIGNED", "type_specifier : DT_KEY_UNSIGNED", "type_specifier : DT_KEY_USERLAND", "type_specifier : DT_KEY_STRING", "type_specifier : DT_TOK_TNAME", "type_specifier : struct_or_union_specifier", "type_specifier : enum_specifier", "type_qualifier : DT_KEY_CONST", "type_qualifier : DT_KEY_RESTRICT", "type_qualifier : DT_KEY_VOLATILE", "struct_or_union_specifier : struct_or_union_definition struct_declaration_list '}'", "struct_or_union_specifier : struct_or_union DT_TOK_IDENT", "struct_or_union_specifier : struct_or_union DT_TOK_TNAME", "struct_or_union_definition : struct_or_union '{'", "struct_or_union_definition : struct_or_union DT_TOK_IDENT '{'", "struct_or_union_definition : struct_or_union DT_TOK_TNAME '{'", "struct_or_union : DT_KEY_STRUCT", "struct_or_union : DT_KEY_UNION", "struct_declaration_list : struct_declaration", "struct_declaration_list : struct_declaration_list struct_declaration", "init_declarator_list : init_declarator", "init_declarator_list : init_declarator_list DT_TOK_COMMA init_declarator", "init_declarator : declarator", "struct_declaration : specifier_qualifier_list struct_declarator_list ';'", "specifier_qualifier_list : type_specifier", "specifier_qualifier_list : type_specifier specifier_qualifier_list", "specifier_qualifier_list : type_qualifier", "specifier_qualifier_list : type_qualifier specifier_qualifier_list", "struct_declarator_list : struct_declarator", "struct_declarator_list : struct_declarator_list DT_TOK_COMMA struct_declarator", "struct_declarator : declarator", "struct_declarator : DT_TOK_COLON constant_expression", "struct_declarator : declarator DT_TOK_COLON constant_expression", "enum_specifier : enum_definition enumerator_list '}'", "enum_specifier : DT_KEY_ENUM DT_TOK_IDENT", "enum_specifier : DT_KEY_ENUM DT_TOK_TNAME", "enum_definition : DT_KEY_ENUM '{'", "enum_definition : DT_KEY_ENUM DT_TOK_IDENT '{'", "enum_definition : DT_KEY_ENUM DT_TOK_TNAME '{'", "enumerator_list : enumerator", "enumerator_list : enumerator_list DT_TOK_COMMA enumerator", "enumerator : DT_TOK_IDENT", "enumerator : DT_TOK_IDENT DT_TOK_ASGN expression", "declarator : direct_declarator", "declarator : pointer direct_declarator", "direct_declarator : DT_TOK_IDENT", "direct_declarator : lparen declarator DT_TOK_RPAR", "direct_declarator : direct_declarator array", "direct_declarator : direct_declarator function", "lparen : DT_TOK_LPAR", "pointer : DT_TOK_MUL", "pointer : DT_TOK_MUL type_qualifier_list", "pointer : DT_TOK_MUL pointer", "pointer : DT_TOK_MUL type_qualifier_list pointer", "type_qualifier_list : type_qualifier", "type_qualifier_list : type_qualifier_list type_qualifier", "parameter_type_list : parameter_list", "parameter_type_list : DT_TOK_ELLIPSIS", "parameter_type_list : parameter_list DT_TOK_COMMA DT_TOK_ELLIPSIS", "parameter_list : parameter_declaration", "parameter_list : parameter_list DT_TOK_COMMA parameter_declaration", "parameter_declaration : parameter_declaration_specifiers", "parameter_declaration : parameter_declaration_specifiers declarator", "parameter_declaration : parameter_declaration_specifiers abstract_declarator", "type_name : specifier_qualifier_list", "type_name : specifier_qualifier_list abstract_declarator", "abstract_declarator : pointer", "abstract_declarator : direct_abstract_declarator", "abstract_declarator : pointer direct_abstract_declarator", "direct_abstract_declarator : lparen abstract_declarator DT_TOK_RPAR", "direct_abstract_declarator : direct_abstract_declarator array", "direct_abstract_declarator : array", "direct_abstract_declarator : direct_abstract_declarator function", "direct_abstract_declarator : function", "array : DT_TOK_LBRAC", "array : DT_TOK_LBRAC array_parameters DT_TOK_RBRAC", "array_parameters : /* empty */", "array_parameters : constant_expression", "array_parameters : parameter_type_list", "function : DT_TOK_LPAR", "function : DT_TOK_LPAR function_parameters DT_TOK_RPAR", "function_parameters : /* empty */", "function_parameters : parameter_type_list", }; #endif /* YYDEBUG */ # line 1 "/usr/share/lib/ccs/yaccpar" /* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 1993 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1988 AT&T */ /* All Rights Reserved */ #pragma ident "%Z%%M% %I% %E% SMI" /* ** Skeleton parser driver for yacc output */ /* ** yacc user known macros and defines */ #define YYERROR goto yyerrlab #define YYACCEPT return(0) #define YYABORT return(1) #define YYBACKUP( newtoken, newvalue )\ {\ if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ {\ yyerror( "syntax error - cannot backup" );\ goto yyerrlab;\ }\ yychar = newtoken;\ yystate = *yyps;\ yylval = newvalue;\ goto yynewstate;\ } #define YYRECOVERING() (!!yyerrflag) #define YYNEW(type) malloc(sizeof(type) * yynewmax) #define YYCOPY(to, from, type) \ (type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type)) #define YYENLARGE( from, type) \ (type *) realloc((char *) from, yynewmax * sizeof(type)) #ifndef YYDEBUG # define YYDEBUG 1 /* make debugging available */ #endif /* ** user known globals */ int yydebug; /* set to 1 to get debugging */ /* ** driver internal defines */ #define YYFLAG (-10000000) /* ** global variables used by the parser */ YYSTYPE *yypv; /* top of value stack */ int *yyps; /* top of state stack */ int yystate; /* current state */ int yytmp; /* extra var (lasts between blocks) */ int yynerrs; /* number of errors */ int yyerrflag; /* error recovery flag */ int yychar; /* current input token number */ #ifdef YYNMBCHARS #define YYLEX() yycvtok(yylex()) /* ** yycvtok - return a token if i is a wchar_t value that exceeds 255. ** If i<255, i itself is the token. If i>255 but the neither ** of the 30th or 31st bit is on, i is already a token. */ #if defined(__STDC__) || defined(__cplusplus) int yycvtok(int i) #else int yycvtok(i) int i; #endif { int first = 0; int last = YYNMBCHARS - 1; int mid; wchar_t j; if(i&0x60000000){/*Must convert to a token. */ if( yymbchars[last].character < i ){ return i;/*Giving up*/ } while ((last>=first)&&(first>=0)) {/*Binary search loop*/ mid = (first+last)/2; j = yymbchars[mid].character; if( j==i ){/*Found*/ return yymbchars[mid].tvalue; }else if( j= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */ { /* ** reallocate and recover. Note that pointers ** have to be reset, or bad things will happen */ long yyps_index = (yy_ps - yys); long yypv_index = (yy_pv - yyv); long yypvt_index = (yypvt - yyv); int yynewmax; #ifdef YYEXPAND yynewmax = YYEXPAND(yymaxdepth); #else yynewmax = 2 * yymaxdepth; /* double table size */ if (yymaxdepth == YYMAXDEPTH) /* first time growth */ { char *newyys = (char *)YYNEW(int); char *newyyv = (char *)YYNEW(YYSTYPE); if (newyys != 0 && newyyv != 0) { yys = YYCOPY(newyys, yys, int); yyv = YYCOPY(newyyv, yyv, YYSTYPE); } else yynewmax = 0; /* failed */ } else /* not first time */ { yys = YYENLARGE(yys, int); yyv = YYENLARGE(yyv, YYSTYPE); if (yys == 0 || yyv == 0) yynewmax = 0; /* failed */ } #endif if (yynewmax <= yymaxdepth) /* tables not expanded */ { yyerror( "yacc stack overflow" ); YYABORT; } yymaxdepth = yynewmax; yy_ps = yys + yyps_index; yy_pv = yyv + yypv_index; yypvt = yyv + yypvt_index; } *yy_ps = yy_state; *++yy_pv = yyval; /* ** we have a new state - find out what to do */ yy_newstate: if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) goto yydefault; /* simple state */ #if YYDEBUG /* ** if debugging, need to mark whether new token grabbed */ yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; printf( "Received token " ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) break; } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) goto yydefault; if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ { yychar = -1; yyval = yylval; yy_state = yy_n; if ( yyerrflag > 0 ) yyerrflag--; goto yy_stack; } yydefault: if ( ( yy_n = yydef[ yy_state ] ) == -2 ) { #if YYDEBUG yytmp = yychar < 0; #endif if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) yychar = 0; /* reached EOF */ #if YYDEBUG if ( yydebug && yytmp ) { register int yy_i; printf( "Received token " ); if ( yychar == 0 ) printf( "end-of-file\n" ); else if ( yychar < 0 ) printf( "-none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } printf( "%s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ /* ** look through exception table */ { register YYCONST int *yyxi = yyexca; while ( ( *yyxi != -1 ) || ( yyxi[1] != yy_state ) ) { yyxi += 2; } while ( ( *(yyxi += 2) >= 0 ) && ( *yyxi != yychar ) ) ; if ( ( yy_n = yyxi[1] ) < 0 ) YYACCEPT; } } /* ** check for syntax error */ if ( yy_n == 0 ) /* have an error */ { /* no worry about speed here! */ switch ( yyerrflag ) { case 0: /* new error */ yyerror( "syntax error" ); goto skip_init; yyerrlab: /* ** get globals into registers. ** we have a user generated syntax type error */ yy_pv = yypv; yy_ps = yyps; yy_state = yystate; skip_init: yynerrs++; /* FALLTHRU */ case 1: case 2: /* incompletely recovered error */ /* try again... */ yyerrflag = 3; /* ** find state where "error" is a legal ** shift action */ while ( yy_ps >= yys ) { yy_n = yypact[ *yy_ps ] + YYERRCODE; if ( yy_n >= 0 && yy_n < YYLAST && yychk[yyact[yy_n]] == YYERRCODE) { /* ** simulate shift of "error" */ yy_state = yyact[ yy_n ]; goto yy_stack; } /* ** current state has no shift on ** "error", pop stack */ #if YYDEBUG # define _POP_ "Error recovery pops state %d, uncovers state %d\n" if ( yydebug ) printf( _POP_, *yy_ps, yy_ps[-1] ); # undef _POP_ #endif yy_ps--; yy_pv--; } /* ** there is no state on stack with "error" as ** a valid shift. give up. */ YYABORT; case 3: /* no shift yet; eat a token */ #if YYDEBUG /* ** if debugging, look up token in list of ** pairs. 0 and negative shouldn't occur, ** but since timing doesn't matter when ** debugging, it doesn't hurt to leave the ** tests here. */ if ( yydebug ) { register int yy_i; printf( "Error recovery discards " ); if ( yychar == 0 ) printf( "token end-of-file\n" ); else if ( yychar < 0 ) printf( "token -none-\n" ); else { for ( yy_i = 0; yytoks[yy_i].t_val >= 0; yy_i++ ) { if ( yytoks[yy_i].t_val == yychar ) { break; } } printf( "token %s\n", yytoks[yy_i].t_name ); } } #endif /* YYDEBUG */ if ( yychar == 0 ) /* reached EOF. quit */ YYABORT; yychar = -1; goto yy_newstate; } }/* end if ( yy_n == 0 ) */ /* ** reduction by production yy_n ** put stack tops, etc. so things right after switch */ #if YYDEBUG /* ** if debugging, print the string that is the user's ** specification of the reduction which is just about ** to be done. */ if ( yydebug ) printf( "Reduce by (%d) \"%s\"\n", yy_n, yyreds[ yy_n ] ); #endif yytmp = yy_n; /* value to switch over */ yypvt = yy_pv; /* $vars top of value stack */ /* ** Look in goto table for next state ** Sorry about using yy_state here as temporary ** register variable, but why not, if it works... ** If yyr2[ yy_n ] doesn't have the low order bit ** set, then there is no action to be done for ** this reduction. So, no saving & unsaving of ** registers done. The only difference between the ** code just after the if and the body of the if is ** the goto yy_stack in the body. This way the test ** can be made before the choice of what to do is needed. */ { /* length of production doubled with extra bit */ register int yy_len = yyr2[ yy_n ]; if ( !( yy_len & 01 ) ) { yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } goto yy_stack; } yy_len >>= 1; yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + *( yy_ps -= yy_len ) + 1; if ( yy_state >= YYLAST || yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) { yy_state = yyact[ yypgo[ yy_n ] ]; } } /* save until reenter driver code */ yystate = yy_state; yyps = yy_ps; yypv = yy_pv; } /* ** code supplied by user is placed in this switch */ switch( yytmp ) { case 1: # line 215 "../common/dt_grammar.y" { return (dt_node_root(yypvt[-1].l_node)); } break; case 2: # line 216 "../common/dt_grammar.y" { return (dt_node_root(yypvt[-1].l_node)); } break; case 3: # line 217 "../common/dt_grammar.y" { return (dt_node_root(yypvt[-1].l_node)); } break; case 4: # line 220 "../common/dt_grammar.y" { yyval.l_node = NULL; } break; case 5: # line 221 "../common/dt_grammar.y" { yyval.l_node = yypvt[-0].l_node; } break; case 6: # line 224 "../common/dt_grammar.y" { yyval.l_node = dt_node_program(NULL); } break; case 7: # line 225 "../common/dt_grammar.y" { yyval.l_node = dt_node_program(yypvt[-0].l_node); } break; case 8: # line 228 "../common/dt_grammar.y" { yyval.l_node = NULL; } break; case 9: # line 229 "../common/dt_grammar.y" { yyval.l_node = (dt_node_t *)yypvt[-0].l_decl; } break; case 11: # line 234 "../common/dt_grammar.y" { yyval.l_node = LINK(yypvt[-1].l_node, yypvt[-0].l_node); } break; case 17: # line 247 "../common/dt_grammar.y" { dt_scope_push(NULL, CTF_ERR); } break; case 18: # line 248 "../common/dt_grammar.y" { /* * We push a new declaration scope before shifting the * assignment_expression in order to preserve ds_class * and ds_ident for use in dt_node_inline(). Once the * entire inline_definition rule is matched, pop the * scope and construct the inline using the saved decl. */ dt_scope_pop(); yyval.l_node = dt_node_inline(yypvt[-1].l_node); } break; case 19: # line 263 "../common/dt_grammar.y" { yyval.l_node = dt_node_xlator(yypvt[-8].l_decl, yypvt[-6].l_decl, yypvt[-5].l_str, yypvt[-2].l_node); } break; case 20: # line 267 "../common/dt_grammar.y" { yyval.l_node = dt_node_xlator(yypvt[-7].l_decl, yypvt[-5].l_decl, yypvt[-4].l_str, NULL); } break; case 22: # line 274 "../common/dt_grammar.y" { yyval.l_node = LINK(yypvt[-1].l_node,yypvt[-0].l_node); } break; case 23: # line 278 "../common/dt_grammar.y" { yyval.l_node = dt_node_member(NULL, yypvt[-3].l_str, yypvt[-1].l_node); } break; case 24: # line 284 "../common/dt_grammar.y" { yyval.l_node = dt_node_provider(yypvt[-4].l_str, yypvt[-2].l_node); } break; case 25: # line 287 "../common/dt_grammar.y" { yyval.l_node = dt_node_provider(yypvt[-3].l_str, NULL); } break; case 27: # line 294 "../common/dt_grammar.y" { yyval.l_node = LINK(yypvt[-1].l_node, yypvt[-0].l_node); } break; case 28: # line 298 "../common/dt_grammar.y" { yyval.l_node = dt_node_probe(yypvt[-4].l_str, 2, yypvt[-3].l_node, yypvt[-1].l_node); } break; case 29: # line 301 "../common/dt_grammar.y" { yyval.l_node = dt_node_probe(yypvt[-2].l_str, 1, yypvt[-1].l_node, NULL); } break; case 30: # line 308 "../common/dt_grammar.y" { /* * If the input stream is a file, do not permit a probe * specification without / / or { } after * it. This can only occur if the next token is EOF or * an ambiguous predicate was slurped up as a comment. * We cannot perform this check if input() is a string * because dtrace(1M) [-fmnP] also use the compiler and * things like dtrace -n BEGIN have to be accepted. */ if (yypcb->pcb_fileptr != NULL) { dnerror(yypvt[-0].l_node, D_SYNTAX, "expected predicate and/" "or actions following probe description\n"); } yyval.l_node = dt_node_clause(yypvt[-0].l_node, NULL, NULL); yybegin(YYS_CLAUSE); } break; case 31: # line 325 "../common/dt_grammar.y" { yyval.l_node = dt_node_clause(yypvt[-3].l_node, NULL, yypvt[-1].l_node); yybegin(YYS_CLAUSE); } break; case 32: # line 329 "../common/dt_grammar.y" { dnerror(yypvt[-1].l_node, D_SYNTAX, "expected actions { } following " "probe description and predicate\n"); } break; case 33: # line 334 "../common/dt_grammar.y" { yyval.l_node = dt_node_clause(yypvt[-6].l_node, yypvt[-4].l_node, yypvt[-1].l_node); yybegin(YYS_CLAUSE); } break; case 34: # line 341 "../common/dt_grammar.y" { yybegin(YYS_EXPR); yyval.l_node = yypvt[-0].l_node; } break; case 36: # line 346 "../common/dt_grammar.y" { yyval.l_node = LINK(yypvt[-2].l_node, yypvt[-0].l_node); } break; case 37: # line 352 "../common/dt_grammar.y" { yyval.l_node = dt_node_pdesc_by_name(yypvt[-0].l_str); } break; case 38: # line 353 "../common/dt_grammar.y" { yyval.l_node = dt_node_pdesc_by_id(yypvt[-0].l_int); } break; case 39: # line 356 "../common/dt_grammar.y" { yyval.l_node = NULL; } break; case 40: # line 357 "../common/dt_grammar.y" { yyval.l_node = LINK(yypvt[-1].l_node, yypvt[-0].l_node); } break; case 41: # line 361 "../common/dt_grammar.y" { yyval.l_node = yypvt[-0].l_node; } break; case 42: # line 362 "../common/dt_grammar.y" { yyval.l_node = LINK(yypvt[-1].l_node, dt_node_statement(yypvt[-0].l_node)); } break; case 44: # line 369 "../common/dt_grammar.y" { yyval.l_node = yypvt[-1].l_node; } break; case 45: # line 371 "../common/dt_grammar.y" { yyval.l_node = NULL; } break; case 46: # line 372 "../common/dt_grammar.y" { yyval.l_node = dt_node_statement(yypvt[-1].l_node); } break; case 47: # line 373 "../common/dt_grammar.y" { yyval.l_node = dt_node_if(yypvt[-2].l_node, yypvt[-0].l_node, NULL); } break; case 48: # line 377 "../common/dt_grammar.y" { yyval.l_node = dt_node_if(yypvt[-4].l_node, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 50: # line 384 "../common/dt_grammar.y" { yyval.l_node = LINK(yypvt[-2].l_node, yypvt[-0].l_node); } break; case 51: # line 390 "../common/dt_grammar.y" { yyval.l_node = dt_node_ident(yypvt[-0].l_str); } break; case 52: # line 391 "../common/dt_grammar.y" { yyval.l_node = dt_node_ident(yypvt[-0].l_str); } break; case 53: # line 392 "../common/dt_grammar.y" { yyval.l_node = dt_node_int(yypvt[-0].l_int); } break; case 54: # line 393 "../common/dt_grammar.y" { yyval.l_node = dt_node_string(yypvt[-0].l_str); } break; case 55: # line 394 "../common/dt_grammar.y" { yyval.l_node = dt_node_ident(DUP("self")); } break; case 56: # line 395 "../common/dt_grammar.y" { yyval.l_node = dt_node_ident(DUP("this")); } break; case 57: # line 396 "../common/dt_grammar.y" { yyval.l_node = yypvt[-1].l_node; } break; case 59: # line 402 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_LBRAC, yypvt[-3].l_node, yypvt[-1].l_node); } break; case 60: # line 405 "../common/dt_grammar.y" { yyval.l_node = dt_node_func(yypvt[-2].l_node, NULL); } break; case 61: # line 409 "../common/dt_grammar.y" { yyval.l_node = dt_node_func(yypvt[-3].l_node, yypvt[-1].l_node); } break; case 62: # line 412 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_DOT, yypvt[-2].l_node, dt_node_ident(yypvt[-0].l_str)); } break; case 63: # line 415 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_DOT, yypvt[-2].l_node, dt_node_ident(yypvt[-0].l_str)); } break; case 64: # line 418 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_PTR, yypvt[-2].l_node, dt_node_ident(yypvt[-0].l_str)); } break; case 65: # line 421 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_PTR, yypvt[-2].l_node, dt_node_ident(yypvt[-0].l_str)); } break; case 66: # line 424 "../common/dt_grammar.y" { yyval.l_node = OP1(DT_TOK_POSTINC, yypvt[-1].l_node); } break; case 67: # line 427 "../common/dt_grammar.y" { yyval.l_node = OP1(DT_TOK_POSTDEC, yypvt[-1].l_node); } break; case 68: # line 431 "../common/dt_grammar.y" { yyval.l_node = dt_node_offsetof(yypvt[-3].l_decl, yypvt[-1].l_str); } break; case 69: # line 435 "../common/dt_grammar.y" { yyval.l_node = dt_node_offsetof(yypvt[-3].l_decl, yypvt[-1].l_str); } break; case 70: # line 439 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_XLATE, dt_node_type(yypvt[-4].l_decl), yypvt[-1].l_node); } break; case 72: # line 446 "../common/dt_grammar.y" { yyval.l_node = OP1(DT_TOK_PREINC, yypvt[-0].l_node); } break; case 73: # line 447 "../common/dt_grammar.y" { yyval.l_node = OP1(DT_TOK_PREDEC, yypvt[-0].l_node); } break; case 74: # line 448 "../common/dt_grammar.y" { yyval.l_node = OP1(yypvt[-1].l_tok, yypvt[-0].l_node); } break; case 75: # line 449 "../common/dt_grammar.y" { yyval.l_node = OP1(DT_TOK_SIZEOF, yypvt[-0].l_node); } break; case 76: # line 450 "../common/dt_grammar.y" { yyval.l_node = OP1(DT_TOK_SIZEOF, dt_node_type(yypvt[-1].l_decl)); } break; case 77: # line 453 "../common/dt_grammar.y" { yyval.l_node = OP1(DT_TOK_STRINGOF, yypvt[-0].l_node); } break; case 78: # line 458 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_ADDROF; } break; case 79: # line 459 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_DEREF; } break; case 80: # line 460 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_IPOS; } break; case 81: # line 461 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_INEG; } break; case 82: # line 462 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_BNEG; } break; case 83: # line 463 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_LNEG; } break; case 85: # line 468 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_LPAR, dt_node_type(yypvt[-2].l_decl), yypvt[-0].l_node); } break; case 87: # line 475 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_MUL, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 88: # line 478 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_DIV, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 89: # line 481 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_MOD, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 91: # line 488 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_ADD, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 92: # line 491 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_SUB, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 94: # line 498 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_LSH, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 95: # line 501 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_RSH, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 97: # line 508 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_LT, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 98: # line 511 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_GT, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 99: # line 514 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_LE, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 100: # line 517 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_GE, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 102: # line 524 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_EQU, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 103: # line 527 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_NEQ, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 105: # line 534 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_BAND, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 107: # line 541 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_XOR, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 109: # line 548 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_BOR, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 111: # line 555 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_LAND, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 113: # line 562 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_LXOR, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 115: # line 569 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_LOR, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 118: # line 580 "../common/dt_grammar.y" { yyval.l_node = OP3(yypvt[-4].l_node, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 120: # line 585 "../common/dt_grammar.y" { yyval.l_node = OP2(yypvt[-1].l_tok, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 121: # line 591 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_ASGN; } break; case 122: # line 592 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_MUL_EQ; } break; case 123: # line 593 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_DIV_EQ; } break; case 124: # line 594 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_MOD_EQ; } break; case 125: # line 595 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_ADD_EQ; } break; case 126: # line 596 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_SUB_EQ; } break; case 127: # line 597 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_LSH_EQ; } break; case 128: # line 598 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_RSH_EQ; } break; case 129: # line 599 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_AND_EQ; } break; case 130: # line 600 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_XOR_EQ; } break; case 131: # line 601 "../common/dt_grammar.y" { yyval.l_tok = DT_TOK_OR_EQ; } break; case 133: # line 605 "../common/dt_grammar.y" { yyval.l_node = OP2(DT_TOK_COMMA, yypvt[-2].l_node, yypvt[-0].l_node); } break; case 134: # line 610 "../common/dt_grammar.y" { yyval.l_node = dt_node_decl(); dt_decl_free(dt_decl_pop()); yybegin(YYS_CLAUSE); } break; case 135: # line 615 "../common/dt_grammar.y" { yyval.l_node = yypvt[-1].l_node; dt_decl_free(dt_decl_pop()); yybegin(YYS_CLAUSE); } break; case 148: # line 641 "../common/dt_grammar.y" { dt_decl_class(DT_DC_AUTO); } break; case 149: # line 642 "../common/dt_grammar.y" { dt_decl_class(DT_DC_REGISTER); } break; case 150: # line 643 "../common/dt_grammar.y" { dt_decl_class(DT_DC_STATIC); } break; case 151: # line 644 "../common/dt_grammar.y" { dt_decl_class(DT_DC_EXTERN); } break; case 152: # line 645 "../common/dt_grammar.y" { dt_decl_class(DT_DC_TYPEDEF); } break; case 154: # line 650 "../common/dt_grammar.y" { dt_decl_class(DT_DC_SELF); } break; case 155: # line 651 "../common/dt_grammar.y" { dt_decl_class(DT_DC_THIS); } break; case 156: # line 654 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(CTF_K_INTEGER, DUP("void")); } break; case 157: # line 655 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(CTF_K_INTEGER, DUP("char")); } break; case 158: # line 656 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_attr(DT_DA_SHORT); } break; case 159: # line 657 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(CTF_K_INTEGER, DUP("int")); } break; case 160: # line 658 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_attr(DT_DA_LONG); } break; case 161: # line 659 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(CTF_K_FLOAT, DUP("float")); } break; case 162: # line 660 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(CTF_K_FLOAT, DUP("double")); } break; case 163: # line 661 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_attr(DT_DA_SIGNED); } break; case 164: # line 662 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_attr(DT_DA_UNSIGNED); } break; case 165: # line 663 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_attr(DT_DA_USER); } break; case 166: # line 664 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(CTF_K_TYPEDEF, DUP("string")); } break; case 167: # line 667 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(CTF_K_TYPEDEF, yypvt[-0].l_str); } break; case 170: # line 672 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_attr(DT_DA_CONST); } break; case 171: # line 673 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_attr(DT_DA_RESTRICT); } break; case 172: # line 674 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_attr(DT_DA_VOLATILE); } break; case 173: # line 678 "../common/dt_grammar.y" { yyval.l_decl = dt_scope_pop(); } break; case 174: # line 681 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(yypvt[-1].l_tok, yypvt[-0].l_str); } break; case 175: # line 682 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(yypvt[-1].l_tok, yypvt[-0].l_str); } break; case 176: # line 686 "../common/dt_grammar.y" { dt_decl_sou(yypvt[-1].l_tok, NULL); } break; case 177: # line 687 "../common/dt_grammar.y" { dt_decl_sou(yypvt[-2].l_tok, yypvt[-1].l_str); } break; case 178: # line 688 "../common/dt_grammar.y" { dt_decl_sou(yypvt[-2].l_tok, yypvt[-1].l_str); } break; case 179: # line 692 "../common/dt_grammar.y" { yyval.l_tok = CTF_K_STRUCT; } break; case 180: # line 693 "../common/dt_grammar.y" { yyval.l_tok = CTF_K_UNION; } break; case 184: # line 703 "../common/dt_grammar.y" { yyval.l_node = LINK(yypvt[-2].l_node, yypvt[-0].l_node); } break; case 185: # line 709 "../common/dt_grammar.y" { yyval.l_node = dt_node_decl(); dt_decl_reset(); } break; case 186: # line 716 "../common/dt_grammar.y" { dt_decl_free(dt_decl_pop()); } break; case 188: # line 723 "../common/dt_grammar.y" { yyval.l_decl = yypvt[-0].l_decl; } break; case 190: # line 725 "../common/dt_grammar.y" { yyval.l_decl = yypvt[-0].l_decl; } break; case 193: # line 734 "../common/dt_grammar.y" { dt_decl_member(NULL); } break; case 194: # line 735 "../common/dt_grammar.y" { dt_decl_member(yypvt[-0].l_node); } break; case 195: # line 736 "../common/dt_grammar.y" { dt_decl_member(yypvt[-0].l_node); } break; case 196: # line 742 "../common/dt_grammar.y" { yyval.l_decl = dt_scope_pop(); } break; case 197: # line 743 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(CTF_K_ENUM, yypvt[-0].l_str); } break; case 198: # line 744 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_spec(CTF_K_ENUM, yypvt[-0].l_str); } break; case 199: # line 748 "../common/dt_grammar.y" { dt_decl_enum(NULL); } break; case 200: # line 749 "../common/dt_grammar.y" { dt_decl_enum(yypvt[-1].l_str); } break; case 201: # line 750 "../common/dt_grammar.y" { dt_decl_enum(yypvt[-1].l_str); } break; case 204: # line 758 "../common/dt_grammar.y" { dt_decl_enumerator(yypvt[-0].l_str, NULL); } break; case 205: # line 759 "../common/dt_grammar.y" { dt_decl_enumerator(yypvt[-2].l_str, yypvt[-0].l_node); } break; case 208: # line 769 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_ident(yypvt[-0].l_str); } break; case 209: # line 770 "../common/dt_grammar.y" { yyval.l_decl = yypvt[-1].l_decl; } break; case 210: # line 771 "../common/dt_grammar.y" { dt_decl_array(yypvt[-0].l_node); } break; case 211: # line 772 "../common/dt_grammar.y" { dt_decl_func(yypvt[-1].l_decl, yypvt[-0].l_node); } break; case 212: # line 775 "../common/dt_grammar.y" { dt_decl_top()->dd_attr |= DT_DA_PAREN; } break; case 213: # line 778 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_ptr(); } break; case 214: # line 779 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_ptr(); } break; case 215: # line 780 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_ptr(); } break; case 216: # line 781 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_ptr(); } break; case 218: # line 786 "../common/dt_grammar.y" { yyval.l_decl = yypvt[-0].l_decl; } break; case 220: # line 791 "../common/dt_grammar.y" { yyval.l_node = dt_node_vatype(); } break; case 221: # line 792 "../common/dt_grammar.y" { yyval.l_node = LINK(yypvt[-2].l_node, dt_node_vatype()); } break; case 223: # line 798 "../common/dt_grammar.y" { yyval.l_node = LINK(yypvt[-2].l_node, yypvt[-0].l_node); } break; case 224: # line 804 "../common/dt_grammar.y" { yyval.l_node = dt_node_type(NULL); } break; case 225: # line 807 "../common/dt_grammar.y" { yyval.l_node = dt_node_type(NULL); } break; case 226: # line 810 "../common/dt_grammar.y" { yyval.l_node = dt_node_type(NULL); } break; case 227: # line 815 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_pop(); } break; case 228: # line 818 "../common/dt_grammar.y" { yyval.l_decl = dt_decl_pop(); } break; case 232: # line 830 "../common/dt_grammar.y" { yyval.l_decl = yypvt[-1].l_decl; } break; case 233: # line 831 "../common/dt_grammar.y" { dt_decl_array(yypvt[-0].l_node); } break; case 234: # line 832 "../common/dt_grammar.y" { dt_decl_array(yypvt[-0].l_node); yyval.l_decl = NULL; } break; case 235: # line 833 "../common/dt_grammar.y" { dt_decl_func(yypvt[-1].l_decl, yypvt[-0].l_node); } break; case 236: # line 834 "../common/dt_grammar.y" { dt_decl_func(NULL, yypvt[-0].l_node); } break; case 237: # line 837 "../common/dt_grammar.y" { dt_scope_push(NULL, CTF_ERR); } break; case 238: # line 838 "../common/dt_grammar.y" { dt_scope_pop(); yyval.l_node = yypvt[-1].l_node; } break; case 239: # line 845 "../common/dt_grammar.y" { yyval.l_node = NULL; } break; case 240: # line 846 "../common/dt_grammar.y" { yyval.l_node = yypvt[-0].l_node; } break; case 241: # line 847 "../common/dt_grammar.y" { yyval.l_node = yypvt[-0].l_node; } break; case 242: # line 850 "../common/dt_grammar.y" { dt_scope_push(NULL, CTF_ERR); } break; case 243: # line 851 "../common/dt_grammar.y" { dt_scope_pop(); yyval.l_node = yypvt[-1].l_node; } break; case 244: # line 858 "../common/dt_grammar.y" { yyval.l_node = NULL; } break; case 245: # line 859 "../common/dt_grammar.y" { yyval.l_node = yypvt[-0].l_node; } break; # line 556 "/usr/share/lib/ccs/yaccpar" } goto yystack; /* reset registers in driver code */ }