1 2 # line 2 "../common/dt_grammar.y" 3 /* 4 * CDDL HEADER START 5 * 6 * The contents of this file are subject to the terms of the 7 * Common Development and Distribution License, Version 1.0 only 8 * (the "License"). You may not use this file except in compliance 9 * with the License. 10 * 11 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 12 * or http://www.opensolaris.org/os/licensing. 13 * See the License for the specific language governing permissions 14 * and limitations under the License. 15 * 16 * When distributing Covered Code, include this CDDL HEADER in each 17 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 18 * If applicable, add the following below this CDDL HEADER, with the 19 * fields enclosed by brackets "[]" replaced with your own identifying 20 * information: Portions Copyright [yyyy] [name of copyright owner] 21 * 22 * CDDL HEADER END 23 * 24 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28 /* 29 * Copyright (c) 2014, 2016 by Delphix. All rights reserved. 30 * Copyright (c) 2013, Joyent, Inc. All rights reserved. 31 */ 32 33 #include <dt_impl.h> 34 35 #define OP1(op, c) dt_node_op1(op, c) 36 #define OP2(op, l, r) dt_node_op2(op, l, r) 37 #define OP3(x, y, z) dt_node_op3(x, y, z) 38 #define LINK(l, r) dt_node_link(l, r) 39 #define DUP(s) strdup(s) 40 41 42 # line 42 "../common/dt_grammar.y" 43 typedef union 44 #ifdef __cplusplus 45 YYSTYPE 46 #endif 47 { 48 dt_node_t *l_node; 49 dt_decl_t *l_decl; 50 char *l_str; 51 uintmax_t l_int; 52 int l_tok; 53 } YYSTYPE; 54 # define DT_TOK_COMMA 257 55 # define DT_TOK_ELLIPSIS 258 56 # define DT_TOK_ASGN 259 57 # define DT_TOK_ADD_EQ 260 58 # define DT_TOK_SUB_EQ 261 59 # define DT_TOK_MUL_EQ 262 60 # define DT_TOK_DIV_EQ 263 61 # define DT_TOK_MOD_EQ 264 62 # define DT_TOK_AND_EQ 265 63 # define DT_TOK_XOR_EQ 266 64 # define DT_TOK_OR_EQ 267 65 # define DT_TOK_LSH_EQ 268 66 # define DT_TOK_RSH_EQ 269 67 # define DT_TOK_QUESTION 270 68 # define DT_TOK_COLON 271 69 # define DT_TOK_LOR 272 70 # define DT_TOK_LXOR 273 71 # define DT_TOK_LAND 274 72 # define DT_TOK_BOR 275 73 # define DT_TOK_XOR 276 74 # define DT_TOK_BAND 277 75 # define DT_TOK_EQU 278 76 # define DT_TOK_NEQ 279 77 # define DT_TOK_LT 280 78 # define DT_TOK_LE 281 79 # define DT_TOK_GT 282 80 # define DT_TOK_GE 283 81 # define DT_TOK_LSH 284 82 # define DT_TOK_RSH 285 83 # define DT_TOK_ADD 286 84 # define DT_TOK_SUB 287 85 # define DT_TOK_MUL 288 86 # define DT_TOK_DIV 289 87 # define DT_TOK_MOD 290 88 # define DT_TOK_LNEG 291 89 # define DT_TOK_BNEG 292 90 # define DT_TOK_ADDADD 293 91 # define DT_TOK_SUBSUB 294 92 # define DT_TOK_PREINC 295 93 # define DT_TOK_POSTINC 296 94 # define DT_TOK_PREDEC 297 95 # define DT_TOK_POSTDEC 298 96 # define DT_TOK_IPOS 299 97 # define DT_TOK_INEG 300 98 # define DT_TOK_DEREF 301 99 # define DT_TOK_ADDROF 302 100 # define DT_TOK_OFFSETOF 303 101 # define DT_TOK_SIZEOF 304 102 # define DT_TOK_STRINGOF 305 103 # define DT_TOK_XLATE 306 104 # define DT_TOK_LPAR 307 105 # define DT_TOK_RPAR 308 106 # define DT_TOK_LBRAC 309 107 # define DT_TOK_RBRAC 310 108 # define DT_TOK_PTR 311 109 # define DT_TOK_DOT 312 110 # define DT_TOK_STRING 313 111 # define DT_TOK_IDENT 314 112 # define DT_TOK_PSPEC 315 113 # define DT_TOK_AGG 316 114 # define DT_TOK_TNAME 317 115 # define DT_TOK_INT 318 116 # define DT_KEY_AUTO 319 117 # define DT_KEY_BREAK 320 118 # define DT_KEY_CASE 321 119 # define DT_KEY_CHAR 322 120 # define DT_KEY_CONST 323 121 # define DT_KEY_CONTINUE 324 122 # define DT_KEY_COUNTER 325 123 # define DT_KEY_DEFAULT 326 124 # define DT_KEY_DO 327 125 # define DT_KEY_DOUBLE 328 126 # define DT_KEY_ELSE 329 127 # define DT_KEY_ENUM 330 128 # define DT_KEY_EXTERN 331 129 # define DT_KEY_FLOAT 332 130 # define DT_KEY_FOR 333 131 # define DT_KEY_GOTO 334 132 # define DT_KEY_IF 335 133 # define DT_KEY_IMPORT 336 134 # define DT_KEY_INLINE 337 135 # define DT_KEY_INT 338 136 # define DT_KEY_LONG 339 137 # define DT_KEY_PROBE 340 138 # define DT_KEY_PROVIDER 341 139 # define DT_KEY_REGISTER 342 140 # define DT_KEY_RESTRICT 343 141 # define DT_KEY_RETURN 344 142 # define DT_KEY_SELF 345 143 # define DT_KEY_SHORT 346 144 # define DT_KEY_SIGNED 347 145 # define DT_KEY_STATIC 348 146 # define DT_KEY_STRING 349 147 # define DT_KEY_STRUCT 350 148 # define DT_KEY_SWITCH 351 149 # define DT_KEY_THIS 352 150 # define DT_KEY_TYPEDEF 353 151 # define DT_KEY_UNION 354 152 # define DT_KEY_UNSIGNED 355 153 # define DT_KEY_USERLAND 356 154 # define DT_KEY_VOID 357 155 # define DT_KEY_VOLATILE 358 156 # define DT_KEY_WHILE 359 157 # define DT_KEY_XLATOR 360 158 # define DT_TOK_EPRED 361 159 # define DT_CTX_DEXPR 362 160 # define DT_CTX_DPROG 363 161 # define DT_CTX_DTYPE 364 162 # define DT_TOK_EOF 0 163 164 #include <inttypes.h> 165 166 #ifdef __STDC__ 167 #include <stdlib.h> 168 #include <string.h> 169 #define YYCONST const 170 #else 171 #include <malloc.h> 172 #include <memory.h> 173 #define YYCONST 174 #endif 175 176 #include <values.h> 177 178 #if defined(__cplusplus) || defined(__STDC__) 179 180 #if defined(__cplusplus) && defined(__EXTERN_C__) 181 extern "C" { 182 #endif 183 #ifndef yyerror 184 #if defined(__cplusplus) 185 void yyerror(YYCONST char *); 186 #endif 187 #endif 188 #ifndef yylex 189 int yylex(void); 190 #endif 191 int yyparse(void); 192 #if defined(__cplusplus) && defined(__EXTERN_C__) 193 } 194 #endif 195 196 #endif 197 198 #define yyclearin yychar = -1 199 #define yyerrok yyerrflag = 0 200 extern int yychar; 201 extern int yyerrflag; 202 YYSTYPE yylval; 203 YYSTYPE yyval; 204 typedef int yytabelem; 205 #ifndef YYMAXDEPTH 206 #define YYMAXDEPTH 150 207 #endif 208 #if YYMAXDEPTH > 0 209 int yy_yys[YYMAXDEPTH], *yys = yy_yys; 210 YYSTYPE yy_yyv[YYMAXDEPTH], *yyv = yy_yyv; 211 #else /* user does initial allocation */ 212 int *yys; 213 YYSTYPE *yyv; 214 #endif 215 static int yymaxdepth = YYMAXDEPTH; 216 # define YYERRCODE 256 217 218 # line 862 "../common/dt_grammar.y" 219 220 static YYCONST yytabelem yyexca[] ={ 221 -1, 1, 222 0, -1, 223 -2, 0, 224 -1, 192, 225 288, 212, 226 307, 212, 227 309, 212, 228 314, 212, 229 -2, 242, 230 }; 231 # define YYNPROD 246 232 # define YYLAST 815 233 static YYCONST yytabelem yyact[]={ 234 235 302, 5, 6, 7, 357, 318, 360, 103, 168, 369, 236 336, 86, 313, 66, 87, 314, 234, 278, 321, 26, 237 303, 188, 206, 12, 164, 207, 317, 182, 28, 29, 238 27, 168, 169, 31, 30, 17, 18, 204, 157, 166, 239 205, 338, 337, 83, 185, 24, 20, 21, 25, 39, 240 192, 364, 193, 179, 327, 36, 33, 166, 34, 80, 241 35, 88, 356, 84, 70, 83, 241, 103, 193, 253, 242 75, 268, 96, 91, 74, 192, 241, 193, 85, 298, 243 72, 73, 166, 288, 89, 84, 168, 37, 71, 76, 244 90, 79, 97, 26, 38, 92, 98, 77, 78, 69, 245 85, 271, 28, 29, 27, 169, 103, 31, 30, 17, 246 18, 286, 166, 192, 323, 193, 168, 163, 353, 24, 247 20, 21, 25, 39, 269, 191, 168, 196, 197, 36, 248 33, 214, 34, 80, 35, 192, 315, 193, 70, 83, 249 133, 158, 201, 201, 75, 169, 96, 251, 74, 149, 250 150, 268, 166, 103, 72, 73, 341, 348, 128, 84, 251 273, 37, 71, 76, 14, 79, 97, 232, 38, 346, 252 98, 77, 78, 69, 85, 134, 124, 126, 140, 129, 253 131, 264, 160, 136, 86, 139, 80, 87, 88, 11, 254 242, 70, 83, 151, 152, 153, 135, 75, 14, 96, 255 91, 74, 270, 279, 213, 132, 56, 72, 73, 261, 256 58, 89, 84, 138, 67, 71, 76, 90, 79, 97, 257 280, 68, 92, 98, 77, 78, 69, 85, 80, 57, 258 88, 248, 280, 70, 83, 183, 147, 148, 184, 75, 259 358, 96, 91, 74, 177, 141, 142, 178, 293, 72, 260 73, 358, 367, 89, 84, 352, 165, 71, 76, 90, 261 79, 97, 14, 14, 92, 98, 77, 78, 69, 85, 262 322, 300, 294, 231, 302, 291, 14, 14, 14, 305, 263 305, 117, 186, 116, 14, 243, 284, 328, 316, 14, 264 240, 80, 312, 88, 252, 258, 70, 83, 181, 256, 265 272, 199, 75, 170, 96, 91, 74, 159, 143, 145, 266 144, 146, 72, 73, 263, 361, 89, 84, 14, 67, 267 71, 76, 90, 79, 97, 103, 68, 92, 98, 77, 268 78, 69, 85, 80, 162, 88, 284, 103, 70, 83, 269 340, 345, 305, 236, 75, 46, 96, 91, 74, 347, 270 362, 267, 175, 261, 72, 73, 242, 187, 89, 84, 271 365, 237, 71, 76, 90, 79, 97, 13, 240, 92, 272 98, 77, 78, 69, 85, 80, 373, 100, 32, 370, 273 70, 83, 374, 354, 122, 123, 75, 263, 96, 65, 274 74, 372, 281, 40, 14, 43, 72, 73, 119, 350, 275 118, 84, 121, 120, 71, 76, 42, 79, 97, 324, 276 252, 168, 98, 77, 78, 69, 85, 14, 260, 283, 277 259, 190, 329, 80, 255, 245, 47, 14, 70, 83, 278 169, 257, 254, 60, 75, 41, 96, 166, 74, 233, 279 325, 375, 297, 167, 72, 73, 187, 343, 371, 84, 280 243, 368, 71, 76, 366, 79, 97, 44, 349, 101, 281 98, 77, 78, 69, 85, 200, 63, 351, 103, 342, 282 320, 176, 10, 292, 14, 14, 9, 359, 8, 194, 283 195, 319, 14, 265, 266, 102, 330, 180, 22, 95, 284 155, 250, 64, 224, 225, 174, 171, 172, 173, 339, 285 93, 289, 304, 62, 26, 50, 275, 344, 1, 63, 286 94, 209, 14, 28, 29, 27, 63, 99, 31, 30, 287 17, 18, 63, 63, 63, 19, 14, 249, 14, 212, 288 24, 20, 21, 25, 39, 64, 217, 363, 310, 309, 289 36, 33, 64, 34, 189, 35, 216, 104, 64, 64, 290 64, 282, 176, 363, 26, 154, 296, 137, 48, 238, 291 247, 331, 285, 28, 29, 27, 326, 23, 31, 30, 292 17, 18, 37, 287, 215, 156, 226, 227, 127, 38, 293 24, 20, 21, 25, 39, 203, 239, 26, 16, 331, 294 36, 33, 15, 34, 299, 35, 28, 29, 27, 218, 295 219, 31, 30, 17, 18, 198, 308, 301, 244, 82, 296 262, 81, 285, 24, 20, 21, 25, 39, 202, 161, 297 55, 295, 37, 36, 33, 45, 34, 235, 35, 38, 298 26, 189, 61, 189, 295, 311, 59, 54, 277, 28, 299 29, 27, 53, 355, 31, 30, 17, 18, 208, 52, 300 51, 210, 211, 49, 246, 37, 24, 20, 21, 25, 301 39, 295, 38, 26, 239, 4, 36, 33, 3, 34, 302 2, 35, 28, 29, 27, 0, 0, 31, 30, 17, 303 18, 0, 0, 262, 0, 0, 0, 0, 0, 24, 304 20, 21, 25, 125, 0, 0, 0, 0, 37, 36, 305 33, 0, 34, 0, 35, 38, 26, 0, 0, 0, 306 228, 229, 230, 0, 0, 28, 29, 27, 0, 0, 307 31, 30, 17, 18, 0, 306, 306, 0, 0, 0, 308 290, 37, 24, 20, 21, 25, 130, 0, 38, 333, 309 334, 335, 36, 33, 0, 34, 0, 35, 332, 0, 310 276, 307, 307, 105, 109, 110, 106, 107, 108, 113, 311 114, 115, 111, 112, 0, 63, 63, 63, 0, 220, 312 221, 222, 223, 274, 37, 332, 332, 0, 0, 0, 313 0, 38, 0, 0, 0, 0, 0, 0, 306, 0, 314 0, 64, 64, 64, 0, 0, 0, 0, 0, 0, 315 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 316 0, 0, 0, 0, 307 }; 317 static YYCONST yytabelem yypact[]={ 318 319 -361,-10000000, 478, 476, 472, 353, -131, 58,-10000000,-10000000, 320 -10000000, 68,-10000000,-10000000, 494, 11, 91, 386, 386, 353, 321 429, 386, -68,-10000000, -167, -105,-10000000,-10000000,-10000000,-10000000, 322 -10000000,-10000000, -78,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -184, 323 -62, -91, -99, -33, 28, -48, -137, -95,-10000000, -131, 324 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -26, 58, -276, 18, 325 123, 46, -26, -26, -26,-10000000,-10000000,-10000000,-10000000,-10000000, 326 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 327 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 328 -10000000,-10000000,-10000000, 58, -70, -287, -79,-10000000,-10000000,-10000000, 329 -172, 58, 58, 353, 353,-10000000,-10000000,-10000000,-10000000,-10000000, 330 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000, 353, 353, 353, 310, 331 -277, -292,-10000000,-10000000,-10000000, 353,-10000000,-10000000,-10000000,-10000000, 332 -184,-10000000, 353, 58, 58, 353, -104, -177, 353, 353, 333 353, 353, 353, 353, 353, 353, 353, 353, 353, 353, 334 353, 353, 353, 353,-10000000, -162, -113, 316,-10000000, 353, 335 -10000000, 302,-10000000,-10000000, -241, -275,-10000000, -162, -280,-10000000, 336 -304,-10000000,-10000000,-10000000, 106,-10000000, -202, 309, 301,-10000000, 337 174,-10000000, 36, 297, 295,-10000000,-10000000, -194, -241, -172, 338 -10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -68, 80, 339 -186,-10000000,-10000000, -106,-10000000,-10000000,-10000000,-10000000, -207, -78, 340 43, -122, -62,-10000000, 353, -91, -99, -33, 28, 28, 341 -48, -48, -48, -48, -137, -137, -95, -95,-10000000,-10000000, 342 -10000000,-10000000, 58, -108, 267, 277, -250,-10000000, -162,-10000000, 343 -10000000,-10000000, -241, -225, -280,-10000000,-10000000,-10000000,-10000000,-10000000, 344 216,-10000000, -23, 353,-10000000,-10000000,-10000000, -287, 353,-10000000, 345 -10000000, -241,-10000000,-10000000, -229, 16, -258, 353, 353,-10000000, 346 -10000000,-10000000, -302, -171,-10000000, 29, -288, -120, 411,-10000000, 347 -296,-10000000,-10000000, 211,-10000000, -193, 286,-10000000,-10000000,-10000000, 348 -10000000,-10000000, -202, 353,-10000000,-10000000,-10000000,-10000000,-10000000, -254, 349 -10000000, 30,-10000000,-10000000, -257, -26, -26, -26, -300,-10000000, 350 -10000000,-10000000,-10000000, -266, -267, 353, 353, -126, 410,-10000000, 351 -10000000, -231,-10000000, 353,-10000000,-10000000,-10000000,-10000000, -89,-10000000, 352 -10000000, -232, -257,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000, -151, 353 399, 276,-10000000, 196, -190, 258,-10000000,-10000000,-10000000,-10000000, 354 -63, -231,-10000000, 227,-10000000, -74, 395,-10000000, -7, 392, 355 -320,-10000000,-10000000, 211, 389,-10000000,-10000000, 353,-10000000, 227, 356 257,-10000000, 382,-10000000,-10000000,-10000000 }; 357 static YYCONST yytabelem yypgo[]={ 358 359 0, 670, 668, 665, 653, 505, 650, 649, 643, 4, 360 642, 638, 203, 637, 636, 632, 389, 16, 627, 6, 361 315, 620, 619, 334, 459, 485, 611, 377, 609, 117, 362 24, 256, 608, 517, 181, 21, 271, 607, 20, 421, 363 606, 125, 594, 183, 23, 367, 272, 592, 488, 378, 364 393, 435, 406, 395, 457, 625, 345, 426, 558, 158, 365 588, 567, 465, 547, 525, 510, 508, 433, 506, 503, 366 502, 13, 500, 495, 352, 491, 147, 489, 487, 298, 367 443, 484, 483 }; 368 static YYCONST yytabelem yyr1[]={ 369 370 0, 66, 66, 66, 1, 1, 2, 2, 3, 3, 371 4, 4, 5, 5, 5, 5, 5, 68, 6, 7, 372 7, 8, 8, 9, 10, 10, 11, 11, 12, 12, 373 13, 13, 13, 13, 14, 15, 15, 16, 16, 18, 374 18, 17, 17, 19, 19, 20, 20, 20, 20, 62, 375 62, 61, 61, 61, 61, 61, 61, 61, 60, 60, 376 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 377 60, 59, 59, 59, 59, 59, 59, 59, 64, 64, 378 64, 64, 64, 64, 58, 58, 57, 57, 57, 57, 379 56, 56, 56, 55, 55, 55, 54, 54, 54, 54, 380 54, 53, 53, 53, 52, 52, 51, 51, 50, 50, 381 49, 49, 48, 48, 47, 47, 46, 45, 45, 44, 382 44, 63, 63, 63, 63, 63, 63, 63, 63, 63, 383 63, 63, 43, 43, 21, 21, 67, 67, 67, 67, 384 67, 67, 70, 70, 70, 70, 70, 70, 71, 71, 385 71, 71, 71, 69, 69, 69, 24, 24, 24, 24, 386 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 387 25, 25, 25, 26, 26, 26, 72, 72, 72, 65, 388 65, 73, 73, 22, 22, 23, 74, 27, 27, 27, 389 27, 75, 75, 76, 76, 76, 28, 28, 28, 77, 390 77, 77, 78, 78, 79, 79, 29, 29, 30, 30, 391 30, 30, 80, 31, 31, 31, 31, 32, 32, 36, 392 36, 36, 37, 37, 38, 38, 38, 33, 33, 34, 393 34, 34, 35, 35, 35, 35, 35, 81, 39, 40, 394 40, 40, 82, 41, 42, 42 }; 395 static YYCONST yytabelem yyr2[]={ 396 397 0, 5, 5, 5, 3, 5, 3, 5, 3, 5, 398 2, 5, 2, 2, 2, 2, 2, 1, 15, 21, 399 19, 2, 5, 9, 13, 11, 2, 5, 13, 9, 400 3, 9, 9, 15, 3, 2, 7, 3, 3, 1, 401 5, 3, 5, 2, 7, 3, 5, 11, 15, 2, 402 7, 3, 3, 3, 3, 3, 3, 7, 2, 9, 403 7, 9, 7, 7, 7, 7, 5, 5, 13, 13, 404 15, 2, 5, 5, 5, 5, 9, 5, 3, 3, 405 3, 3, 3, 3, 2, 9, 2, 7, 7, 7, 406 2, 7, 7, 2, 7, 7, 2, 7, 7, 7, 407 7, 2, 7, 7, 2, 7, 2, 7, 2, 7, 408 2, 7, 2, 7, 2, 7, 2, 2, 11, 2, 409 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 410 3, 3, 2, 7, 5, 7, 2, 4, 2, 4, 411 2, 4, 2, 4, 2, 4, 2, 4, 3, 3, 412 3, 3, 3, 2, 3, 3, 3, 3, 3, 3, 413 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 414 3, 3, 3, 7, 5, 5, 5, 7, 7, 3, 415 3, 2, 4, 2, 7, 3, 7, 2, 5, 2, 416 5, 2, 6, 3, 5, 7, 7, 5, 5, 5, 417 7, 7, 2, 6, 3, 7, 2, 4, 3, 7, 418 5, 5, 3, 3, 5, 5, 7, 2, 5, 2, 419 3, 7, 2, 7, 3, 5, 5, 3, 5, 2, 420 2, 4, 7, 5, 3, 5, 3, 1, 9, 1, 421 3, 3, 1, 9, 1, 3 }; 422 static YYCONST yytabelem yychk[]={ 423 424 -10000000, -66, -1, -2, -3, 362, 363, 364, 0, 0, 425 0, -43, -44, -45, -59, -47, -60, 293, 294, -64, 426 304, 305, -48, -61, 303, 306, 277, 288, 286, 287, 427 292, 291, -49, 314, 316, 318, 313, 345, 352, 307, 428 -50, -51, -52, -53, -54, -55, -56, -57, -58, -4, 429 -5, -6, -7, -10, -13, -21, 337, 360, 341, -14, 430 -67, -15, -69, -24, -25, -16, -71, 345, 352, 357, 431 322, 346, 338, 339, 332, 328, 347, 355, 356, 349, 432 317, -26, -28, 323, 343, 358, 315, 318, 319, 342, 433 348, 331, 353, -72, -65, -77, 330, 350, 354, -33, 434 -27, -24, -25, 257, -63, 259, 262, 263, 264, 260, 435 261, 268, 269, 265, 266, 267, 272, 270, 309, 307, 436 312, 311, 293, 294, -59, 307, -59, -58, -59, -59, 437 307, -59, 273, 307, 280, 274, -43, -33, 275, 276, 438 277, 278, 279, 280, 282, 281, 283, 284, 285, 286, 439 287, 288, 289, 290, -5, -67, -33, 314, 123, 289, 440 59, -22, -23, -29, -30, -31, 314, -80, 288, 307, 441 257, -67, -67, -67, -73, -74, -27, 314, 317, 123, 442 -78, -79, 314, 314, 317, 123, -34, -31, -35, -80, 443 -39, -41, 307, 309, -27, -27, -44, -44, -48, -43, 444 -62, -44, 308, -62, 314, 317, 314, 317, -33, -49, 445 -33, -33, -50, 308, 308, -51, -52, -53, -54, -54, 446 -55, -55, -55, -55, -56, -56, -57, -57, -58, -58, 447 -58, -29, 280, 123, -17, -18, -43, 59, 257, -39, 448 -41, 307, -30, -29, -32, -31, -25, -16, 125, -74, 449 -75, -76, -29, 271, 123, 123, 125, 257, 259, 123, 450 123, -35, -39, -41, -34, -82, -81, 271, 257, 310, 451 308, 308, 257, 282, -58, -68, -33, -11, 125, -12, 452 340, 125, -20, -43, 59, 335, 361, -23, 308, -31, 453 -25, 59, 257, 271, -46, -45, -79, -43, 308, -42, 454 -36, -37, 258, -38, -70, -71, -24, -25, -40, -46, 455 -36, -45, -44, 314, 317, 307, 259, 314, 125, -12, 456 59, 314, 59, 307, 123, -76, -46, 308, 257, -29, 457 -34, -31, -80, -67, -67, -67, 310, 308, 308, -43, 458 -44, 282, 59, -41, -43, -17, 258, -38, 308, 59, 459 123, 271, 59, 308, 125, -8, 125, -9, 314, -41, 460 -19, -20, 123, -43, 125, -9, 59, 259, 59, 329, 461 -17, 59, -44, -19, 125, 59 }; 462 static YYCONST yytabelem yydef[]={ 463 464 0, -2, 0, 0, 0, 4, 6, 8, 1, 2, 465 3, 5, 132, 119, 84, 117, 71, 0, 0, 0, 466 0, 0, 114, 58, 0, 0, 78, 79, 80, 81, 467 82, 83, 112, 51, 52, 53, 54, 55, 56, 0, 468 110, 108, 106, 104, 101, 96, 93, 90, 86, 7, 469 10, 12, 13, 14, 15, 16, 0, 0, 0, 30, 470 0, 34, 136, 138, 140, 35, 153, 154, 155, 156, 471 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 472 167, 168, 169, 170, 171, 172, 37, 38, 148, 149, 473 150, 151, 152, 0, 0, 0, 0, 179, 180, 9, 474 227, 187, 189, 0, 0, 121, 122, 123, 124, 125, 475 126, 127, 128, 129, 130, 131, 0, 0, 0, 0, 476 0, 0, 66, 67, 72, 0, 73, 74, 84, 75, 477 0, 77, 0, 0, 0, 0, 0, 0, 0, 0, 478 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 479 0, 0, 0, 0, 11, 0, 0, 0, 39, 0, 480 134, 0, 183, 185, 206, 0, 208, 0, 213, 212, 481 0, 137, 139, 141, 0, 181, 0, 174, 175, 176, 482 0, 202, 204, 197, 198, 199, 228, 229, 230, 0, 483 234, 236, -2, 237, 188, 190, 133, 120, 115, 0, 484 0, 49, 60, 0, 62, 63, 64, 65, 0, 113, 485 0, 0, 111, 57, 0, 109, 107, 105, 102, 103, 486 97, 98, 99, 100, 94, 95, 91, 92, 87, 88, 487 89, 17, 0, 0, 0, 41, 0, 135, 0, 210, 488 211, 242, 207, 0, 214, 215, 217, 36, 173, 182, 489 0, 191, 193, 0, 177, 178, 196, 0, 0, 200, 490 201, 231, 233, 235, 0, 244, 239, 0, 0, 59, 491 61, 76, 0, 0, 85, 0, 0, 0, 0, 26, 492 0, 31, 40, 42, 45, 0, 32, 184, 209, 216, 493 218, 186, 0, 0, 194, 116, 203, 205, 232, 0, 494 245, 219, 220, 222, 224, 142, 144, 146, 0, 240, 495 241, 118, 50, 0, 0, 0, 0, 0, 0, 27, 496 25, 0, 46, 0, 39, 192, 195, 243, 0, 225, 497 226, 229, 0, 143, 145, 147, 238, 68, 69, 0, 498 0, 0, 24, 0, 0, 0, 221, 223, 70, 18, 499 0, 0, 29, 0, 33, 0, 0, 21, 0, 0, 500 47, 43, 39, 0, 0, 22, 20, 0, 28, 0, 501 0, 19, 0, 48, 44, 23 }; 502 typedef struct 503 #ifdef __cplusplus 504 yytoktype 505 #endif 506 { 507 #ifdef __cplusplus 508 const 509 #endif 510 char *t_name; int t_val; } yytoktype; 511 #ifndef YYDEBUG 512 # define YYDEBUG 0 /* don't allow debugging */ 513 #endif 514 515 #if YYDEBUG 516 517 yytoktype yytoks[] = 518 { 519 "DT_TOK_COMMA", 257, 520 "DT_TOK_ELLIPSIS", 258, 521 "DT_TOK_ASGN", 259, 522 "DT_TOK_ADD_EQ", 260, 523 "DT_TOK_SUB_EQ", 261, 524 "DT_TOK_MUL_EQ", 262, 525 "DT_TOK_DIV_EQ", 263, 526 "DT_TOK_MOD_EQ", 264, 527 "DT_TOK_AND_EQ", 265, 528 "DT_TOK_XOR_EQ", 266, 529 "DT_TOK_OR_EQ", 267, 530 "DT_TOK_LSH_EQ", 268, 531 "DT_TOK_RSH_EQ", 269, 532 "DT_TOK_QUESTION", 270, 533 "DT_TOK_COLON", 271, 534 "DT_TOK_LOR", 272, 535 "DT_TOK_LXOR", 273, 536 "DT_TOK_LAND", 274, 537 "DT_TOK_BOR", 275, 538 "DT_TOK_XOR", 276, 539 "DT_TOK_BAND", 277, 540 "DT_TOK_EQU", 278, 541 "DT_TOK_NEQ", 279, 542 "DT_TOK_LT", 280, 543 "DT_TOK_LE", 281, 544 "DT_TOK_GT", 282, 545 "DT_TOK_GE", 283, 546 "DT_TOK_LSH", 284, 547 "DT_TOK_RSH", 285, 548 "DT_TOK_ADD", 286, 549 "DT_TOK_SUB", 287, 550 "DT_TOK_MUL", 288, 551 "DT_TOK_DIV", 289, 552 "DT_TOK_MOD", 290, 553 "DT_TOK_LNEG", 291, 554 "DT_TOK_BNEG", 292, 555 "DT_TOK_ADDADD", 293, 556 "DT_TOK_SUBSUB", 294, 557 "DT_TOK_PREINC", 295, 558 "DT_TOK_POSTINC", 296, 559 "DT_TOK_PREDEC", 297, 560 "DT_TOK_POSTDEC", 298, 561 "DT_TOK_IPOS", 299, 562 "DT_TOK_INEG", 300, 563 "DT_TOK_DEREF", 301, 564 "DT_TOK_ADDROF", 302, 565 "DT_TOK_OFFSETOF", 303, 566 "DT_TOK_SIZEOF", 304, 567 "DT_TOK_STRINGOF", 305, 568 "DT_TOK_XLATE", 306, 569 "DT_TOK_LPAR", 307, 570 "DT_TOK_RPAR", 308, 571 "DT_TOK_LBRAC", 309, 572 "DT_TOK_RBRAC", 310, 573 "DT_TOK_PTR", 311, 574 "DT_TOK_DOT", 312, 575 "DT_TOK_STRING", 313, 576 "DT_TOK_IDENT", 314, 577 "DT_TOK_PSPEC", 315, 578 "DT_TOK_AGG", 316, 579 "DT_TOK_TNAME", 317, 580 "DT_TOK_INT", 318, 581 "DT_KEY_AUTO", 319, 582 "DT_KEY_BREAK", 320, 583 "DT_KEY_CASE", 321, 584 "DT_KEY_CHAR", 322, 585 "DT_KEY_CONST", 323, 586 "DT_KEY_CONTINUE", 324, 587 "DT_KEY_COUNTER", 325, 588 "DT_KEY_DEFAULT", 326, 589 "DT_KEY_DO", 327, 590 "DT_KEY_DOUBLE", 328, 591 "DT_KEY_ELSE", 329, 592 "DT_KEY_ENUM", 330, 593 "DT_KEY_EXTERN", 331, 594 "DT_KEY_FLOAT", 332, 595 "DT_KEY_FOR", 333, 596 "DT_KEY_GOTO", 334, 597 "DT_KEY_IF", 335, 598 "DT_KEY_IMPORT", 336, 599 "DT_KEY_INLINE", 337, 600 "DT_KEY_INT", 338, 601 "DT_KEY_LONG", 339, 602 "DT_KEY_PROBE", 340, 603 "DT_KEY_PROVIDER", 341, 604 "DT_KEY_REGISTER", 342, 605 "DT_KEY_RESTRICT", 343, 606 "DT_KEY_RETURN", 344, 607 "DT_KEY_SELF", 345, 608 "DT_KEY_SHORT", 346, 609 "DT_KEY_SIGNED", 347, 610 "DT_KEY_STATIC", 348, 611 "DT_KEY_STRING", 349, 612 "DT_KEY_STRUCT", 350, 613 "DT_KEY_SWITCH", 351, 614 "DT_KEY_THIS", 352, 615 "DT_KEY_TYPEDEF", 353, 616 "DT_KEY_UNION", 354, 617 "DT_KEY_UNSIGNED", 355, 618 "DT_KEY_USERLAND", 356, 619 "DT_KEY_VOID", 357, 620 "DT_KEY_VOLATILE", 358, 621 "DT_KEY_WHILE", 359, 622 "DT_KEY_XLATOR", 360, 623 "DT_TOK_EPRED", 361, 624 "DT_CTX_DEXPR", 362, 625 "DT_CTX_DPROG", 363, 626 "DT_CTX_DTYPE", 364, 627 "DT_TOK_EOF", 0, 628 "-unknown-", -1 /* ends search */ 629 }; 630 631 #ifdef __cplusplus 632 const 633 #endif 634 char * yyreds[] = 635 { 636 "-no such reduction-", 637 "dtrace_program : d_expression DT_TOK_EOF", 638 "dtrace_program : d_program DT_TOK_EOF", 639 "dtrace_program : d_type DT_TOK_EOF", 640 "d_expression : DT_CTX_DEXPR", 641 "d_expression : DT_CTX_DEXPR expression", 642 "d_program : DT_CTX_DPROG", 643 "d_program : DT_CTX_DPROG translation_unit", 644 "d_type : DT_CTX_DTYPE", 645 "d_type : DT_CTX_DTYPE type_name", 646 "translation_unit : external_declaration", 647 "translation_unit : translation_unit external_declaration", 648 "external_declaration : inline_definition", 649 "external_declaration : translator_definition", 650 "external_declaration : provider_definition", 651 "external_declaration : probe_definition", 652 "external_declaration : declaration", 653 "inline_definition : DT_KEY_INLINE declaration_specifiers declarator", 654 "inline_definition : DT_KEY_INLINE declaration_specifiers declarator DT_TOK_ASGN assignment_expression ';'", 655 "translator_definition : DT_KEY_XLATOR type_name DT_TOK_LT type_name DT_TOK_IDENT DT_TOK_GT '{' translator_member_list '}' ';'", 656 "translator_definition : DT_KEY_XLATOR type_name DT_TOK_LT type_name DT_TOK_IDENT DT_TOK_GT '{' '}' ';'", 657 "translator_member_list : translator_member", 658 "translator_member_list : translator_member_list translator_member", 659 "translator_member : DT_TOK_IDENT DT_TOK_ASGN assignment_expression ';'", 660 "provider_definition : DT_KEY_PROVIDER DT_TOK_IDENT '{' provider_probe_list '}' ';'", 661 "provider_definition : DT_KEY_PROVIDER DT_TOK_IDENT '{' '}' ';'", 662 "provider_probe_list : provider_probe", 663 "provider_probe_list : provider_probe_list provider_probe", 664 "provider_probe : DT_KEY_PROBE DT_TOK_IDENT function DT_TOK_COLON function ';'", 665 "provider_probe : DT_KEY_PROBE DT_TOK_IDENT function ';'", 666 "probe_definition : probe_specifiers", 667 "probe_definition : probe_specifiers '{' statement_list '}'", 668 "probe_definition : probe_specifiers DT_TOK_DIV expression DT_TOK_EPRED", 669 "probe_definition : probe_specifiers DT_TOK_DIV expression DT_TOK_EPRED '{' statement_list '}'", 670 "probe_specifiers : probe_specifier_list", 671 "probe_specifier_list : probe_specifier", 672 "probe_specifier_list : probe_specifier_list DT_TOK_COMMA probe_specifier", 673 "probe_specifier : DT_TOK_PSPEC", 674 "probe_specifier : DT_TOK_INT", 675 "statement_list_impl : /* empty */", 676 "statement_list_impl : statement_list_impl statement", 677 "statement_list : statement_list_impl", 678 "statement_list : statement_list_impl expression", 679 "statement_or_block : statement", 680 "statement_or_block : '{' statement_list '}'", 681 "statement : ';'", 682 "statement : expression ';'", 683 "statement : DT_KEY_IF DT_TOK_LPAR expression DT_TOK_RPAR statement_or_block", 684 "statement : DT_KEY_IF DT_TOK_LPAR expression DT_TOK_RPAR statement_or_block DT_KEY_ELSE statement_or_block", 685 "argument_expression_list : assignment_expression", 686 "argument_expression_list : argument_expression_list DT_TOK_COMMA assignment_expression", 687 "primary_expression : DT_TOK_IDENT", 688 "primary_expression : DT_TOK_AGG", 689 "primary_expression : DT_TOK_INT", 690 "primary_expression : DT_TOK_STRING", 691 "primary_expression : DT_KEY_SELF", 692 "primary_expression : DT_KEY_THIS", 693 "primary_expression : DT_TOK_LPAR expression DT_TOK_RPAR", 694 "postfix_expression : primary_expression", 695 "postfix_expression : postfix_expression DT_TOK_LBRAC argument_expression_list DT_TOK_RBRAC", 696 "postfix_expression : postfix_expression DT_TOK_LPAR DT_TOK_RPAR", 697 "postfix_expression : postfix_expression DT_TOK_LPAR argument_expression_list DT_TOK_RPAR", 698 "postfix_expression : postfix_expression DT_TOK_DOT DT_TOK_IDENT", 699 "postfix_expression : postfix_expression DT_TOK_DOT DT_TOK_TNAME", 700 "postfix_expression : postfix_expression DT_TOK_PTR DT_TOK_IDENT", 701 "postfix_expression : postfix_expression DT_TOK_PTR DT_TOK_TNAME", 702 "postfix_expression : postfix_expression DT_TOK_ADDADD", 703 "postfix_expression : postfix_expression DT_TOK_SUBSUB", 704 "postfix_expression : DT_TOK_OFFSETOF DT_TOK_LPAR type_name DT_TOK_COMMA DT_TOK_IDENT DT_TOK_RPAR", 705 "postfix_expression : DT_TOK_OFFSETOF DT_TOK_LPAR type_name DT_TOK_COMMA DT_TOK_TNAME DT_TOK_RPAR", 706 "postfix_expression : DT_TOK_XLATE DT_TOK_LT type_name DT_TOK_GT DT_TOK_LPAR expression DT_TOK_RPAR", 707 "unary_expression : postfix_expression", 708 "unary_expression : DT_TOK_ADDADD unary_expression", 709 "unary_expression : DT_TOK_SUBSUB unary_expression", 710 "unary_expression : unary_operator cast_expression", 711 "unary_expression : DT_TOK_SIZEOF unary_expression", 712 "unary_expression : DT_TOK_SIZEOF DT_TOK_LPAR type_name DT_TOK_RPAR", 713 "unary_expression : DT_TOK_STRINGOF unary_expression", 714 "unary_operator : DT_TOK_BAND", 715 "unary_operator : DT_TOK_MUL", 716 "unary_operator : DT_TOK_ADD", 717 "unary_operator : DT_TOK_SUB", 718 "unary_operator : DT_TOK_BNEG", 719 "unary_operator : DT_TOK_LNEG", 720 "cast_expression : unary_expression", 721 "cast_expression : DT_TOK_LPAR type_name DT_TOK_RPAR cast_expression", 722 "multiplicative_expression : cast_expression", 723 "multiplicative_expression : multiplicative_expression DT_TOK_MUL cast_expression", 724 "multiplicative_expression : multiplicative_expression DT_TOK_DIV cast_expression", 725 "multiplicative_expression : multiplicative_expression DT_TOK_MOD cast_expression", 726 "additive_expression : multiplicative_expression", 727 "additive_expression : additive_expression DT_TOK_ADD multiplicative_expression", 728 "additive_expression : additive_expression DT_TOK_SUB multiplicative_expression", 729 "shift_expression : additive_expression", 730 "shift_expression : shift_expression DT_TOK_LSH additive_expression", 731 "shift_expression : shift_expression DT_TOK_RSH additive_expression", 732 "relational_expression : shift_expression", 733 "relational_expression : relational_expression DT_TOK_LT shift_expression", 734 "relational_expression : relational_expression DT_TOK_GT shift_expression", 735 "relational_expression : relational_expression DT_TOK_LE shift_expression", 736 "relational_expression : relational_expression DT_TOK_GE shift_expression", 737 "equality_expression : relational_expression", 738 "equality_expression : equality_expression DT_TOK_EQU relational_expression", 739 "equality_expression : equality_expression DT_TOK_NEQ relational_expression", 740 "and_expression : equality_expression", 741 "and_expression : and_expression DT_TOK_BAND equality_expression", 742 "exclusive_or_expression : and_expression", 743 "exclusive_or_expression : exclusive_or_expression DT_TOK_XOR and_expression", 744 "inclusive_or_expression : exclusive_or_expression", 745 "inclusive_or_expression : inclusive_or_expression DT_TOK_BOR exclusive_or_expression", 746 "logical_and_expression : inclusive_or_expression", 747 "logical_and_expression : logical_and_expression DT_TOK_LAND inclusive_or_expression", 748 "logical_xor_expression : logical_and_expression", 749 "logical_xor_expression : logical_xor_expression DT_TOK_LXOR logical_and_expression", 750 "logical_or_expression : logical_xor_expression", 751 "logical_or_expression : logical_or_expression DT_TOK_LOR logical_xor_expression", 752 "constant_expression : conditional_expression", 753 "conditional_expression : logical_or_expression", 754 "conditional_expression : logical_or_expression DT_TOK_QUESTION expression DT_TOK_COLON conditional_expression", 755 "assignment_expression : conditional_expression", 756 "assignment_expression : unary_expression assignment_operator assignment_expression", 757 "assignment_operator : DT_TOK_ASGN", 758 "assignment_operator : DT_TOK_MUL_EQ", 759 "assignment_operator : DT_TOK_DIV_EQ", 760 "assignment_operator : DT_TOK_MOD_EQ", 761 "assignment_operator : DT_TOK_ADD_EQ", 762 "assignment_operator : DT_TOK_SUB_EQ", 763 "assignment_operator : DT_TOK_LSH_EQ", 764 "assignment_operator : DT_TOK_RSH_EQ", 765 "assignment_operator : DT_TOK_AND_EQ", 766 "assignment_operator : DT_TOK_XOR_EQ", 767 "assignment_operator : DT_TOK_OR_EQ", 768 "expression : assignment_expression", 769 "expression : expression DT_TOK_COMMA assignment_expression", 770 "declaration : declaration_specifiers ';'", 771 "declaration : declaration_specifiers init_declarator_list ';'", 772 "declaration_specifiers : d_storage_class_specifier", 773 "declaration_specifiers : d_storage_class_specifier declaration_specifiers", 774 "declaration_specifiers : type_specifier", 775 "declaration_specifiers : type_specifier declaration_specifiers", 776 "declaration_specifiers : type_qualifier", 777 "declaration_specifiers : type_qualifier declaration_specifiers", 778 "parameter_declaration_specifiers : storage_class_specifier", 779 "parameter_declaration_specifiers : storage_class_specifier declaration_specifiers", 780 "parameter_declaration_specifiers : type_specifier", 781 "parameter_declaration_specifiers : type_specifier declaration_specifiers", 782 "parameter_declaration_specifiers : type_qualifier", 783 "parameter_declaration_specifiers : type_qualifier declaration_specifiers", 784 "storage_class_specifier : DT_KEY_AUTO", 785 "storage_class_specifier : DT_KEY_REGISTER", 786 "storage_class_specifier : DT_KEY_STATIC", 787 "storage_class_specifier : DT_KEY_EXTERN", 788 "storage_class_specifier : DT_KEY_TYPEDEF", 789 "d_storage_class_specifier : storage_class_specifier", 790 "d_storage_class_specifier : DT_KEY_SELF", 791 "d_storage_class_specifier : DT_KEY_THIS", 792 "type_specifier : DT_KEY_VOID", 793 "type_specifier : DT_KEY_CHAR", 794 "type_specifier : DT_KEY_SHORT", 795 "type_specifier : DT_KEY_INT", 796 "type_specifier : DT_KEY_LONG", 797 "type_specifier : DT_KEY_FLOAT", 798 "type_specifier : DT_KEY_DOUBLE", 799 "type_specifier : DT_KEY_SIGNED", 800 "type_specifier : DT_KEY_UNSIGNED", 801 "type_specifier : DT_KEY_USERLAND", 802 "type_specifier : DT_KEY_STRING", 803 "type_specifier : DT_TOK_TNAME", 804 "type_specifier : struct_or_union_specifier", 805 "type_specifier : enum_specifier", 806 "type_qualifier : DT_KEY_CONST", 807 "type_qualifier : DT_KEY_RESTRICT", 808 "type_qualifier : DT_KEY_VOLATILE", 809 "struct_or_union_specifier : struct_or_union_definition struct_declaration_list '}'", 810 "struct_or_union_specifier : struct_or_union DT_TOK_IDENT", 811 "struct_or_union_specifier : struct_or_union DT_TOK_TNAME", 812 "struct_or_union_definition : struct_or_union '{'", 813 "struct_or_union_definition : struct_or_union DT_TOK_IDENT '{'", 814 "struct_or_union_definition : struct_or_union DT_TOK_TNAME '{'", 815 "struct_or_union : DT_KEY_STRUCT", 816 "struct_or_union : DT_KEY_UNION", 817 "struct_declaration_list : struct_declaration", 818 "struct_declaration_list : struct_declaration_list struct_declaration", 819 "init_declarator_list : init_declarator", 820 "init_declarator_list : init_declarator_list DT_TOK_COMMA init_declarator", 821 "init_declarator : declarator", 822 "struct_declaration : specifier_qualifier_list struct_declarator_list ';'", 823 "specifier_qualifier_list : type_specifier", 824 "specifier_qualifier_list : type_specifier specifier_qualifier_list", 825 "specifier_qualifier_list : type_qualifier", 826 "specifier_qualifier_list : type_qualifier specifier_qualifier_list", 827 "struct_declarator_list : struct_declarator", 828 "struct_declarator_list : struct_declarator_list DT_TOK_COMMA struct_declarator", 829 "struct_declarator : declarator", 830 "struct_declarator : DT_TOK_COLON constant_expression", 831 "struct_declarator : declarator DT_TOK_COLON constant_expression", 832 "enum_specifier : enum_definition enumerator_list '}'", 833 "enum_specifier : DT_KEY_ENUM DT_TOK_IDENT", 834 "enum_specifier : DT_KEY_ENUM DT_TOK_TNAME", 835 "enum_definition : DT_KEY_ENUM '{'", 836 "enum_definition : DT_KEY_ENUM DT_TOK_IDENT '{'", 837 "enum_definition : DT_KEY_ENUM DT_TOK_TNAME '{'", 838 "enumerator_list : enumerator", 839 "enumerator_list : enumerator_list DT_TOK_COMMA enumerator", 840 "enumerator : DT_TOK_IDENT", 841 "enumerator : DT_TOK_IDENT DT_TOK_ASGN expression", 842 "declarator : direct_declarator", 843 "declarator : pointer direct_declarator", 844 "direct_declarator : DT_TOK_IDENT", 845 "direct_declarator : lparen declarator DT_TOK_RPAR", 846 "direct_declarator : direct_declarator array", 847 "direct_declarator : direct_declarator function", 848 "lparen : DT_TOK_LPAR", 849 "pointer : DT_TOK_MUL", 850 "pointer : DT_TOK_MUL type_qualifier_list", 851 "pointer : DT_TOK_MUL pointer", 852 "pointer : DT_TOK_MUL type_qualifier_list pointer", 853 "type_qualifier_list : type_qualifier", 854 "type_qualifier_list : type_qualifier_list type_qualifier", 855 "parameter_type_list : parameter_list", 856 "parameter_type_list : DT_TOK_ELLIPSIS", 857 "parameter_type_list : parameter_list DT_TOK_COMMA DT_TOK_ELLIPSIS", 858 "parameter_list : parameter_declaration", 859 "parameter_list : parameter_list DT_TOK_COMMA parameter_declaration", 860 "parameter_declaration : parameter_declaration_specifiers", 861 "parameter_declaration : parameter_declaration_specifiers declarator", 862 "parameter_declaration : parameter_declaration_specifiers abstract_declarator", 863 "type_name : specifier_qualifier_list", 864 "type_name : specifier_qualifier_list abstract_declarator", 865 "abstract_declarator : pointer", 866 "abstract_declarator : direct_abstract_declarator", 867 "abstract_declarator : pointer direct_abstract_declarator", 868 "direct_abstract_declarator : lparen abstract_declarator DT_TOK_RPAR", 869 "direct_abstract_declarator : direct_abstract_declarator array", 870 "direct_abstract_declarator : array", 871 "direct_abstract_declarator : direct_abstract_declarator function", 872 "direct_abstract_declarator : function", 873 "array : DT_TOK_LBRAC", 874 "array : DT_TOK_LBRAC array_parameters DT_TOK_RBRAC", 875 "array_parameters : /* empty */", 876 "array_parameters : constant_expression", 877 "array_parameters : parameter_type_list", 878 "function : DT_TOK_LPAR", 879 "function : DT_TOK_LPAR function_parameters DT_TOK_RPAR", 880 "function_parameters : /* empty */", 881 "function_parameters : parameter_type_list", 882 }; 883 #endif /* YYDEBUG */ 884 # line 1 "/usr/share/lib/ccs/yaccpar" 885 /* 886 * CDDL HEADER START 887 * 888 * The contents of this file are subject to the terms of the 889 * Common Development and Distribution License, Version 1.0 only 890 * (the "License"). You may not use this file except in compliance 891 * with the License. 892 * 893 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 894 * or http://www.opensolaris.org/os/licensing. 895 * See the License for the specific language governing permissions 896 * and limitations under the License. 897 * 898 * When distributing Covered Code, include this CDDL HEADER in each 899 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 900 * If applicable, add the following below this CDDL HEADER, with the 901 * fields enclosed by brackets "[]" replaced with your own identifying 902 * information: Portions Copyright [yyyy] [name of copyright owner] 903 * 904 * CDDL HEADER END 905 */ 906 /* 907 * Copyright 1993 Sun Microsystems, Inc. All rights reserved. 908 * Use is subject to license terms. 909 */ 910 911 /* Copyright (c) 1988 AT&T */ 912 /* All Rights Reserved */ 913 914 #pragma ident "%Z%%M% %I% %E% SMI" 915 916 /* 917 ** Skeleton parser driver for yacc output 918 */ 919 920 /* 921 ** yacc user known macros and defines 922 */ 923 #define YYERROR goto yyerrlab 924 #define YYACCEPT return(0) 925 #define YYABORT return(1) 926 #define YYBACKUP( newtoken, newvalue )\ 927 {\ 928 if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\ 929 {\ 930 yyerror( "syntax error - cannot backup" );\ 931 goto yyerrlab;\ 932 }\ 933 yychar = newtoken;\ 934 yystate = *yyps;\ 935 yylval = newvalue;\ 936 goto yynewstate;\ 937 } 938 #define YYRECOVERING() (!!yyerrflag) 939 #define YYNEW(type) malloc(sizeof(type) * yynewmax) 940 #define YYCOPY(to, from, type) \ 941 (type *) memcpy(to, (char *) from, yymaxdepth * sizeof (type)) 942 #define YYENLARGE( from, type) \ 943 (type *) realloc((char *) from, yynewmax * sizeof(type)) 944 #ifndef YYDEBUG 945 # define YYDEBUG 1 /* make debugging available */ 946 #endif 947 948 /* 949 ** user known globals 950 */ 951 int yydebug; /* set to 1 to get debugging */ 952 953 /* 954 ** driver internal defines 955 */ 956 #define YYFLAG (-10000000) 957 958 /* 959 ** global variables used by the parser 960 */ 961 YYSTYPE *yypv; /* top of value stack */ 962 int *yyps; /* top of state stack */ 963 964 int yystate; /* current state */ 965 int yytmp; /* extra var (lasts between blocks) */ 966 967 int yynerrs; /* number of errors */ 968 int yyerrflag; /* error recovery flag */ 969 int yychar; /* current input token number */ 970 971 972 973 #ifdef YYNMBCHARS 974 #define YYLEX() yycvtok(yylex()) 975 /* 976 ** yycvtok - return a token if i is a wchar_t value that exceeds 255. 977 ** If i<255, i itself is the token. If i>255 but the neither 978 ** of the 30th or 31st bit is on, i is already a token. 979 */ 980 #if defined(__STDC__) || defined(__cplusplus) 981 int yycvtok(int i) 982 #else 983 int yycvtok(i) int i; 984 #endif 985 { 986 int first = 0; 987 int last = YYNMBCHARS - 1; 988 int mid; 989 wchar_t j; 990 991 if(i&0x60000000){/*Must convert to a token. */ 992 if( yymbchars[last].character < i ){ 993 return i;/*Giving up*/ 994 } 995 while ((last>=first)&&(first>=0)) {/*Binary search loop*/ 996 mid = (first+last)/2; 997 j = yymbchars[mid].character; 998 if( j==i ){/*Found*/ 999 return yymbchars[mid].tvalue; 1000 }else if( j<i ){ 1001 first = mid + 1; 1002 }else{ 1003 last = mid -1; 1004 } 1005 } 1006 /*No entry in the table.*/ 1007 return i;/* Giving up.*/ 1008 }else{/* i is already a token. */ 1009 return i; 1010 } 1011 } 1012 #else/*!YYNMBCHARS*/ 1013 #define YYLEX() yylex() 1014 #endif/*!YYNMBCHARS*/ 1015 1016 /* 1017 ** yyparse - return 0 if worked, 1 if syntax error not recovered from 1018 */ 1019 #if defined(__STDC__) || defined(__cplusplus) 1020 int yyparse(void) 1021 #else 1022 int yyparse() 1023 #endif 1024 { 1025 register YYSTYPE *yypvt = 0; /* top of value stack for $vars */ 1026 1027 #if defined(__cplusplus) || defined(lint) 1028 /* 1029 hacks to please C++ and lint - goto's inside 1030 switch should never be executed 1031 */ 1032 static int __yaccpar_lint_hack__ = 0; 1033 switch (__yaccpar_lint_hack__) 1034 { 1035 case 1: goto yyerrlab; 1036 case 2: goto yynewstate; 1037 } 1038 #endif 1039 1040 /* 1041 ** Initialize externals - yyparse may be called more than once 1042 */ 1043 yypv = &yyv[-1]; 1044 yyps = &yys[-1]; 1045 yystate = 0; 1046 yytmp = 0; 1047 yynerrs = 0; 1048 yyerrflag = 0; 1049 yychar = -1; 1050 1051 #if YYMAXDEPTH <= 0 1052 if (yymaxdepth <= 0) 1053 { 1054 if ((yymaxdepth = YYEXPAND(0)) <= 0) 1055 { 1056 yyerror("yacc initialization error"); 1057 YYABORT; 1058 } 1059 } 1060 #endif 1061 1062 { 1063 register YYSTYPE *yy_pv; /* top of value stack */ 1064 register int *yy_ps; /* top of state stack */ 1065 register int yy_state; /* current state */ 1066 register int yy_n; /* internal state number info */ 1067 goto yystack; /* moved from 6 lines above to here to please C++ */ 1068 1069 /* 1070 ** get globals into registers. 1071 ** branch to here only if YYBACKUP was called. 1072 */ 1073 yynewstate: 1074 yy_pv = yypv; 1075 yy_ps = yyps; 1076 yy_state = yystate; 1077 goto yy_newstate; 1078 1079 /* 1080 ** get globals into registers. 1081 ** either we just started, or we just finished a reduction 1082 */ 1083 yystack: 1084 yy_pv = yypv; 1085 yy_ps = yyps; 1086 yy_state = yystate; 1087 1088 /* 1089 ** top of for (;;) loop while no reductions done 1090 */ 1091 yy_stack: 1092 /* 1093 ** put a state and value onto the stacks 1094 */ 1095 #if YYDEBUG 1096 /* 1097 ** if debugging, look up token value in list of value vs. 1098 ** name pairs. 0 and negative (-1) are special values. 1099 ** Note: linear search is used since time is not a real 1100 ** consideration while debugging. 1101 */ 1102 if ( yydebug ) 1103 { 1104 register int yy_i; 1105 1106 printf( "State %d, token ", yy_state ); 1107 if ( yychar == 0 ) 1108 printf( "end-of-file\n" ); 1109 else if ( yychar < 0 ) 1110 printf( "-none-\n" ); 1111 else 1112 { 1113 for ( yy_i = 0; yytoks[yy_i].t_val >= 0; 1114 yy_i++ ) 1115 { 1116 if ( yytoks[yy_i].t_val == yychar ) 1117 break; 1118 } 1119 printf( "%s\n", yytoks[yy_i].t_name ); 1120 } 1121 } 1122 #endif /* YYDEBUG */ 1123 if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */ 1124 { 1125 /* 1126 ** reallocate and recover. Note that pointers 1127 ** have to be reset, or bad things will happen 1128 */ 1129 long yyps_index = (yy_ps - yys); 1130 long yypv_index = (yy_pv - yyv); 1131 long yypvt_index = (yypvt - yyv); 1132 int yynewmax; 1133 #ifdef YYEXPAND 1134 yynewmax = YYEXPAND(yymaxdepth); 1135 #else 1136 yynewmax = 2 * yymaxdepth; /* double table size */ 1137 if (yymaxdepth == YYMAXDEPTH) /* first time growth */ 1138 { 1139 char *newyys = (char *)YYNEW(int); 1140 char *newyyv = (char *)YYNEW(YYSTYPE); 1141 if (newyys != 0 && newyyv != 0) 1142 { 1143 yys = YYCOPY(newyys, yys, int); 1144 yyv = YYCOPY(newyyv, yyv, YYSTYPE); 1145 } 1146 else 1147 yynewmax = 0; /* failed */ 1148 } 1149 else /* not first time */ 1150 { 1151 yys = YYENLARGE(yys, int); 1152 yyv = YYENLARGE(yyv, YYSTYPE); 1153 if (yys == 0 || yyv == 0) 1154 yynewmax = 0; /* failed */ 1155 } 1156 #endif 1157 if (yynewmax <= yymaxdepth) /* tables not expanded */ 1158 { 1159 yyerror( "yacc stack overflow" ); 1160 YYABORT; 1161 } 1162 yymaxdepth = yynewmax; 1163 1164 yy_ps = yys + yyps_index; 1165 yy_pv = yyv + yypv_index; 1166 yypvt = yyv + yypvt_index; 1167 } 1168 *yy_ps = yy_state; 1169 *++yy_pv = yyval; 1170 1171 /* 1172 ** we have a new state - find out what to do 1173 */ 1174 yy_newstate: 1175 if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG ) 1176 goto yydefault; /* simple state */ 1177 #if YYDEBUG 1178 /* 1179 ** if debugging, need to mark whether new token grabbed 1180 */ 1181 yytmp = yychar < 0; 1182 #endif 1183 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) 1184 yychar = 0; /* reached EOF */ 1185 #if YYDEBUG 1186 if ( yydebug && yytmp ) 1187 { 1188 register int yy_i; 1189 1190 printf( "Received token " ); 1191 if ( yychar == 0 ) 1192 printf( "end-of-file\n" ); 1193 else if ( yychar < 0 ) 1194 printf( "-none-\n" ); 1195 else 1196 { 1197 for ( yy_i = 0; yytoks[yy_i].t_val >= 0; 1198 yy_i++ ) 1199 { 1200 if ( yytoks[yy_i].t_val == yychar ) 1201 break; 1202 } 1203 printf( "%s\n", yytoks[yy_i].t_name ); 1204 } 1205 } 1206 #endif /* YYDEBUG */ 1207 if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) ) 1208 goto yydefault; 1209 if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/ 1210 { 1211 yychar = -1; 1212 yyval = yylval; 1213 yy_state = yy_n; 1214 if ( yyerrflag > 0 ) 1215 yyerrflag--; 1216 goto yy_stack; 1217 } 1218 1219 yydefault: 1220 if ( ( yy_n = yydef[ yy_state ] ) == -2 ) 1221 { 1222 #if YYDEBUG 1223 yytmp = yychar < 0; 1224 #endif 1225 if ( ( yychar < 0 ) && ( ( yychar = YYLEX() ) < 0 ) ) 1226 yychar = 0; /* reached EOF */ 1227 #if YYDEBUG 1228 if ( yydebug && yytmp ) 1229 { 1230 register int yy_i; 1231 1232 printf( "Received token " ); 1233 if ( yychar == 0 ) 1234 printf( "end-of-file\n" ); 1235 else if ( yychar < 0 ) 1236 printf( "-none-\n" ); 1237 else 1238 { 1239 for ( yy_i = 0; 1240 yytoks[yy_i].t_val >= 0; 1241 yy_i++ ) 1242 { 1243 if ( yytoks[yy_i].t_val 1244 == yychar ) 1245 { 1246 break; 1247 } 1248 } 1249 printf( "%s\n", yytoks[yy_i].t_name ); 1250 } 1251 } 1252 #endif /* YYDEBUG */ 1253 /* 1254 ** look through exception table 1255 */ 1256 { 1257 register YYCONST int *yyxi = yyexca; 1258 1259 while ( ( *yyxi != -1 ) || 1260 ( yyxi[1] != yy_state ) ) 1261 { 1262 yyxi += 2; 1263 } 1264 while ( ( *(yyxi += 2) >= 0 ) && 1265 ( *yyxi != yychar ) ) 1266 ; 1267 if ( ( yy_n = yyxi[1] ) < 0 ) 1268 YYACCEPT; 1269 } 1270 } 1271 1272 /* 1273 ** check for syntax error 1274 */ 1275 if ( yy_n == 0 ) /* have an error */ 1276 { 1277 /* no worry about speed here! */ 1278 switch ( yyerrflag ) 1279 { 1280 case 0: /* new error */ 1281 yyerror( "syntax error" ); 1282 goto skip_init; 1283 yyerrlab: 1284 /* 1285 ** get globals into registers. 1286 ** we have a user generated syntax type error 1287 */ 1288 yy_pv = yypv; 1289 yy_ps = yyps; 1290 yy_state = yystate; 1291 skip_init: 1292 yynerrs++; 1293 /* FALLTHRU */ 1294 case 1: 1295 case 2: /* incompletely recovered error */ 1296 /* try again... */ 1297 yyerrflag = 3; 1298 /* 1299 ** find state where "error" is a legal 1300 ** shift action 1301 */ 1302 while ( yy_ps >= yys ) 1303 { 1304 yy_n = yypact[ *yy_ps ] + YYERRCODE; 1305 if ( yy_n >= 0 && yy_n < YYLAST && 1306 yychk[yyact[yy_n]] == YYERRCODE) { 1307 /* 1308 ** simulate shift of "error" 1309 */ 1310 yy_state = yyact[ yy_n ]; 1311 goto yy_stack; 1312 } 1313 /* 1314 ** current state has no shift on 1315 ** "error", pop stack 1316 */ 1317 #if YYDEBUG 1318 # define _POP_ "Error recovery pops state %d, uncovers state %d\n" 1319 if ( yydebug ) 1320 printf( _POP_, *yy_ps, 1321 yy_ps[-1] ); 1322 # undef _POP_ 1323 #endif 1324 yy_ps--; 1325 yy_pv--; 1326 } 1327 /* 1328 ** there is no state on stack with "error" as 1329 ** a valid shift. give up. 1330 */ 1331 YYABORT; 1332 case 3: /* no shift yet; eat a token */ 1333 #if YYDEBUG 1334 /* 1335 ** if debugging, look up token in list of 1336 ** pairs. 0 and negative shouldn't occur, 1337 ** but since timing doesn't matter when 1338 ** debugging, it doesn't hurt to leave the 1339 ** tests here. 1340 */ 1341 if ( yydebug ) 1342 { 1343 register int yy_i; 1344 1345 printf( "Error recovery discards " ); 1346 if ( yychar == 0 ) 1347 printf( "token end-of-file\n" ); 1348 else if ( yychar < 0 ) 1349 printf( "token -none-\n" ); 1350 else 1351 { 1352 for ( yy_i = 0; 1353 yytoks[yy_i].t_val >= 0; 1354 yy_i++ ) 1355 { 1356 if ( yytoks[yy_i].t_val 1357 == yychar ) 1358 { 1359 break; 1360 } 1361 } 1362 printf( "token %s\n", 1363 yytoks[yy_i].t_name ); 1364 } 1365 } 1366 #endif /* YYDEBUG */ 1367 if ( yychar == 0 ) /* reached EOF. quit */ 1368 YYABORT; 1369 yychar = -1; 1370 goto yy_newstate; 1371 } 1372 }/* end if ( yy_n == 0 ) */ 1373 /* 1374 ** reduction by production yy_n 1375 ** put stack tops, etc. so things right after switch 1376 */ 1377 #if YYDEBUG 1378 /* 1379 ** if debugging, print the string that is the user's 1380 ** specification of the reduction which is just about 1381 ** to be done. 1382 */ 1383 if ( yydebug ) 1384 printf( "Reduce by (%d) \"%s\"\n", 1385 yy_n, yyreds[ yy_n ] ); 1386 #endif 1387 yytmp = yy_n; /* value to switch over */ 1388 yypvt = yy_pv; /* $vars top of value stack */ 1389 /* 1390 ** Look in goto table for next state 1391 ** Sorry about using yy_state here as temporary 1392 ** register variable, but why not, if it works... 1393 ** If yyr2[ yy_n ] doesn't have the low order bit 1394 ** set, then there is no action to be done for 1395 ** this reduction. So, no saving & unsaving of 1396 ** registers done. The only difference between the 1397 ** code just after the if and the body of the if is 1398 ** the goto yy_stack in the body. This way the test 1399 ** can be made before the choice of what to do is needed. 1400 */ 1401 { 1402 /* length of production doubled with extra bit */ 1403 register int yy_len = yyr2[ yy_n ]; 1404 1405 if ( !( yy_len & 01 ) ) 1406 { 1407 yy_len >>= 1; 1408 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ 1409 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + 1410 *( yy_ps -= yy_len ) + 1; 1411 if ( yy_state >= YYLAST || 1412 yychk[ yy_state = 1413 yyact[ yy_state ] ] != -yy_n ) 1414 { 1415 yy_state = yyact[ yypgo[ yy_n ] ]; 1416 } 1417 goto yy_stack; 1418 } 1419 yy_len >>= 1; 1420 yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */ 1421 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] + 1422 *( yy_ps -= yy_len ) + 1; 1423 if ( yy_state >= YYLAST || 1424 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n ) 1425 { 1426 yy_state = yyact[ yypgo[ yy_n ] ]; 1427 } 1428 } 1429 /* save until reenter driver code */ 1430 yystate = yy_state; 1431 yyps = yy_ps; 1432 yypv = yy_pv; 1433 } 1434 /* 1435 ** code supplied by user is placed in this switch 1436 */ 1437 switch( yytmp ) 1438 { 1439 1440 case 1: 1441 # line 215 "../common/dt_grammar.y" 1442 { return (dt_node_root(yypvt[-1].l_node)); } break; 1443 case 2: 1444 # line 216 "../common/dt_grammar.y" 1445 { return (dt_node_root(yypvt[-1].l_node)); } break; 1446 case 3: 1447 # line 217 "../common/dt_grammar.y" 1448 { return (dt_node_root(yypvt[-1].l_node)); } break; 1449 case 4: 1450 # line 220 "../common/dt_grammar.y" 1451 { yyval.l_node = NULL; } break; 1452 case 5: 1453 # line 221 "../common/dt_grammar.y" 1454 { yyval.l_node = yypvt[-0].l_node; } break; 1455 case 6: 1456 # line 224 "../common/dt_grammar.y" 1457 { yyval.l_node = dt_node_program(NULL); } break; 1458 case 7: 1459 # line 225 "../common/dt_grammar.y" 1460 { yyval.l_node = dt_node_program(yypvt[-0].l_node); } break; 1461 case 8: 1462 # line 228 "../common/dt_grammar.y" 1463 { yyval.l_node = NULL; } break; 1464 case 9: 1465 # line 229 "../common/dt_grammar.y" 1466 { yyval.l_node = (dt_node_t *)yypvt[-0].l_decl; } break; 1467 case 11: 1468 # line 234 "../common/dt_grammar.y" 1469 { yyval.l_node = LINK(yypvt[-1].l_node, yypvt[-0].l_node); } break; 1470 case 17: 1471 # line 247 "../common/dt_grammar.y" 1472 { dt_scope_push(NULL, CTF_ERR); } break; 1473 case 18: 1474 # line 248 "../common/dt_grammar.y" 1475 { 1476 /* 1477 * We push a new declaration scope before shifting the 1478 * assignment_expression in order to preserve ds_class 1479 * and ds_ident for use in dt_node_inline(). Once the 1480 * entire inline_definition rule is matched, pop the 1481 * scope and construct the inline using the saved decl. 1482 */ 1483 dt_scope_pop(); 1484 yyval.l_node = dt_node_inline(yypvt[-1].l_node); 1485 } break; 1486 case 19: 1487 # line 263 "../common/dt_grammar.y" 1488 { 1489 yyval.l_node = dt_node_xlator(yypvt[-8].l_decl, yypvt[-6].l_decl, yypvt[-5].l_str, yypvt[-2].l_node); 1490 } break; 1491 case 20: 1492 # line 267 "../common/dt_grammar.y" 1493 { 1494 yyval.l_node = dt_node_xlator(yypvt[-7].l_decl, yypvt[-5].l_decl, yypvt[-4].l_str, NULL); 1495 } break; 1496 case 22: 1497 # line 274 "../common/dt_grammar.y" 1498 { yyval.l_node = LINK(yypvt[-1].l_node,yypvt[-0].l_node); } break; 1499 case 23: 1500 # line 278 "../common/dt_grammar.y" 1501 { 1502 yyval.l_node = dt_node_member(NULL, yypvt[-3].l_str, yypvt[-1].l_node); 1503 } break; 1504 case 24: 1505 # line 284 "../common/dt_grammar.y" 1506 { 1507 yyval.l_node = dt_node_provider(yypvt[-4].l_str, yypvt[-2].l_node); 1508 } break; 1509 case 25: 1510 # line 287 "../common/dt_grammar.y" 1511 { 1512 yyval.l_node = dt_node_provider(yypvt[-3].l_str, NULL); 1513 } break; 1514 case 27: 1515 # line 294 "../common/dt_grammar.y" 1516 { yyval.l_node = LINK(yypvt[-1].l_node, yypvt[-0].l_node); } break; 1517 case 28: 1518 # line 298 "../common/dt_grammar.y" 1519 { 1520 yyval.l_node = dt_node_probe(yypvt[-4].l_str, 2, yypvt[-3].l_node, yypvt[-1].l_node); 1521 } break; 1522 case 29: 1523 # line 301 "../common/dt_grammar.y" 1524 { 1525 yyval.l_node = dt_node_probe(yypvt[-2].l_str, 1, yypvt[-1].l_node, NULL); 1526 } break; 1527 case 30: 1528 # line 308 "../common/dt_grammar.y" 1529 { 1530 /* 1531 * If the input stream is a file, do not permit a probe 1532 * specification without / <pred> / or { <act> } after 1533 * it. This can only occur if the next token is EOF or 1534 * an ambiguous predicate was slurped up as a comment. 1535 * We cannot perform this check if input() is a string 1536 * because dtrace(1M) [-fmnP] also use the compiler and 1537 * things like dtrace -n BEGIN have to be accepted. 1538 */ 1539 if (yypcb->pcb_fileptr != NULL) { 1540 dnerror(yypvt[-0].l_node, D_SYNTAX, "expected predicate and/" 1541 "or actions following probe description\n"); 1542 } 1543 yyval.l_node = dt_node_clause(yypvt[-0].l_node, NULL, NULL); 1544 yybegin(YYS_CLAUSE); 1545 } break; 1546 case 31: 1547 # line 325 "../common/dt_grammar.y" 1548 { 1549 yyval.l_node = dt_node_clause(yypvt[-3].l_node, NULL, yypvt[-1].l_node); 1550 yybegin(YYS_CLAUSE); 1551 } break; 1552 case 32: 1553 # line 329 "../common/dt_grammar.y" 1554 { 1555 dnerror(yypvt[-1].l_node, D_SYNTAX, "expected actions { } following " 1556 "probe description and predicate\n"); 1557 } break; 1558 case 33: 1559 # line 334 "../common/dt_grammar.y" 1560 { 1561 yyval.l_node = dt_node_clause(yypvt[-6].l_node, yypvt[-4].l_node, yypvt[-1].l_node); 1562 yybegin(YYS_CLAUSE); 1563 } break; 1564 case 34: 1565 # line 341 "../common/dt_grammar.y" 1566 { yybegin(YYS_EXPR); yyval.l_node = yypvt[-0].l_node; } break; 1567 case 36: 1568 # line 346 "../common/dt_grammar.y" 1569 { 1570 yyval.l_node = LINK(yypvt[-2].l_node, yypvt[-0].l_node); 1571 } break; 1572 case 37: 1573 # line 352 "../common/dt_grammar.y" 1574 { yyval.l_node = dt_node_pdesc_by_name(yypvt[-0].l_str); } break; 1575 case 38: 1576 # line 353 "../common/dt_grammar.y" 1577 { yyval.l_node = dt_node_pdesc_by_id(yypvt[-0].l_int); } break; 1578 case 39: 1579 # line 356 "../common/dt_grammar.y" 1580 { yyval.l_node = NULL; } break; 1581 case 40: 1582 # line 357 "../common/dt_grammar.y" 1583 { yyval.l_node = LINK(yypvt[-1].l_node, yypvt[-0].l_node); } break; 1584 case 41: 1585 # line 361 "../common/dt_grammar.y" 1586 { yyval.l_node = yypvt[-0].l_node; } break; 1587 case 42: 1588 # line 362 "../common/dt_grammar.y" 1589 { 1590 yyval.l_node = LINK(yypvt[-1].l_node, dt_node_statement(yypvt[-0].l_node)); 1591 } break; 1592 case 44: 1593 # line 369 "../common/dt_grammar.y" 1594 { yyval.l_node = yypvt[-1].l_node; } break; 1595 case 45: 1596 # line 371 "../common/dt_grammar.y" 1597 { yyval.l_node = NULL; } break; 1598 case 46: 1599 # line 372 "../common/dt_grammar.y" 1600 { yyval.l_node = dt_node_statement(yypvt[-1].l_node); } break; 1601 case 47: 1602 # line 373 "../common/dt_grammar.y" 1603 { 1604 yyval.l_node = dt_node_if(yypvt[-2].l_node, yypvt[-0].l_node, NULL); 1605 } break; 1606 case 48: 1607 # line 377 "../common/dt_grammar.y" 1608 { 1609 yyval.l_node = dt_node_if(yypvt[-4].l_node, yypvt[-2].l_node, yypvt[-0].l_node); 1610 } break; 1611 case 50: 1612 # line 384 "../common/dt_grammar.y" 1613 { 1614 yyval.l_node = LINK(yypvt[-2].l_node, yypvt[-0].l_node); 1615 } break; 1616 case 51: 1617 # line 390 "../common/dt_grammar.y" 1618 { yyval.l_node = dt_node_ident(yypvt[-0].l_str); } break; 1619 case 52: 1620 # line 391 "../common/dt_grammar.y" 1621 { yyval.l_node = dt_node_ident(yypvt[-0].l_str); } break; 1622 case 53: 1623 # line 392 "../common/dt_grammar.y" 1624 { yyval.l_node = dt_node_int(yypvt[-0].l_int); } break; 1625 case 54: 1626 # line 393 "../common/dt_grammar.y" 1627 { yyval.l_node = dt_node_string(yypvt[-0].l_str); } break; 1628 case 55: 1629 # line 394 "../common/dt_grammar.y" 1630 { yyval.l_node = dt_node_ident(DUP("self")); } break; 1631 case 56: 1632 # line 395 "../common/dt_grammar.y" 1633 { yyval.l_node = dt_node_ident(DUP("this")); } break; 1634 case 57: 1635 # line 396 "../common/dt_grammar.y" 1636 { yyval.l_node = yypvt[-1].l_node; } break; 1637 case 59: 1638 # line 402 "../common/dt_grammar.y" 1639 { 1640 yyval.l_node = OP2(DT_TOK_LBRAC, yypvt[-3].l_node, yypvt[-1].l_node); 1641 } break; 1642 case 60: 1643 # line 405 "../common/dt_grammar.y" 1644 { 1645 yyval.l_node = dt_node_func(yypvt[-2].l_node, NULL); 1646 } break; 1647 case 61: 1648 # line 409 "../common/dt_grammar.y" 1649 { 1650 yyval.l_node = dt_node_func(yypvt[-3].l_node, yypvt[-1].l_node); 1651 } break; 1652 case 62: 1653 # line 412 "../common/dt_grammar.y" 1654 { 1655 yyval.l_node = OP2(DT_TOK_DOT, yypvt[-2].l_node, dt_node_ident(yypvt[-0].l_str)); 1656 } break; 1657 case 63: 1658 # line 415 "../common/dt_grammar.y" 1659 { 1660 yyval.l_node = OP2(DT_TOK_DOT, yypvt[-2].l_node, dt_node_ident(yypvt[-0].l_str)); 1661 } break; 1662 case 64: 1663 # line 418 "../common/dt_grammar.y" 1664 { 1665 yyval.l_node = OP2(DT_TOK_PTR, yypvt[-2].l_node, dt_node_ident(yypvt[-0].l_str)); 1666 } break; 1667 case 65: 1668 # line 421 "../common/dt_grammar.y" 1669 { 1670 yyval.l_node = OP2(DT_TOK_PTR, yypvt[-2].l_node, dt_node_ident(yypvt[-0].l_str)); 1671 } break; 1672 case 66: 1673 # line 424 "../common/dt_grammar.y" 1674 { 1675 yyval.l_node = OP1(DT_TOK_POSTINC, yypvt[-1].l_node); 1676 } break; 1677 case 67: 1678 # line 427 "../common/dt_grammar.y" 1679 { 1680 yyval.l_node = OP1(DT_TOK_POSTDEC, yypvt[-1].l_node); 1681 } break; 1682 case 68: 1683 # line 431 "../common/dt_grammar.y" 1684 { 1685 yyval.l_node = dt_node_offsetof(yypvt[-3].l_decl, yypvt[-1].l_str); 1686 } break; 1687 case 69: 1688 # line 435 "../common/dt_grammar.y" 1689 { 1690 yyval.l_node = dt_node_offsetof(yypvt[-3].l_decl, yypvt[-1].l_str); 1691 } break; 1692 case 70: 1693 # line 439 "../common/dt_grammar.y" 1694 { 1695 yyval.l_node = OP2(DT_TOK_XLATE, dt_node_type(yypvt[-4].l_decl), yypvt[-1].l_node); 1696 } break; 1697 case 72: 1698 # line 446 "../common/dt_grammar.y" 1699 { yyval.l_node = OP1(DT_TOK_PREINC, yypvt[-0].l_node); } break; 1700 case 73: 1701 # line 447 "../common/dt_grammar.y" 1702 { yyval.l_node = OP1(DT_TOK_PREDEC, yypvt[-0].l_node); } break; 1703 case 74: 1704 # line 448 "../common/dt_grammar.y" 1705 { yyval.l_node = OP1(yypvt[-1].l_tok, yypvt[-0].l_node); } break; 1706 case 75: 1707 # line 449 "../common/dt_grammar.y" 1708 { yyval.l_node = OP1(DT_TOK_SIZEOF, yypvt[-0].l_node); } break; 1709 case 76: 1710 # line 450 "../common/dt_grammar.y" 1711 { 1712 yyval.l_node = OP1(DT_TOK_SIZEOF, dt_node_type(yypvt[-1].l_decl)); 1713 } break; 1714 case 77: 1715 # line 453 "../common/dt_grammar.y" 1716 { 1717 yyval.l_node = OP1(DT_TOK_STRINGOF, yypvt[-0].l_node); 1718 } break; 1719 case 78: 1720 # line 458 "../common/dt_grammar.y" 1721 { yyval.l_tok = DT_TOK_ADDROF; } break; 1722 case 79: 1723 # line 459 "../common/dt_grammar.y" 1724 { yyval.l_tok = DT_TOK_DEREF; } break; 1725 case 80: 1726 # line 460 "../common/dt_grammar.y" 1727 { yyval.l_tok = DT_TOK_IPOS; } break; 1728 case 81: 1729 # line 461 "../common/dt_grammar.y" 1730 { yyval.l_tok = DT_TOK_INEG; } break; 1731 case 82: 1732 # line 462 "../common/dt_grammar.y" 1733 { yyval.l_tok = DT_TOK_BNEG; } break; 1734 case 83: 1735 # line 463 "../common/dt_grammar.y" 1736 { yyval.l_tok = DT_TOK_LNEG; } break; 1737 case 85: 1738 # line 468 "../common/dt_grammar.y" 1739 { 1740 yyval.l_node = OP2(DT_TOK_LPAR, dt_node_type(yypvt[-2].l_decl), yypvt[-0].l_node); 1741 } break; 1742 case 87: 1743 # line 475 "../common/dt_grammar.y" 1744 { 1745 yyval.l_node = OP2(DT_TOK_MUL, yypvt[-2].l_node, yypvt[-0].l_node); 1746 } break; 1747 case 88: 1748 # line 478 "../common/dt_grammar.y" 1749 { 1750 yyval.l_node = OP2(DT_TOK_DIV, yypvt[-2].l_node, yypvt[-0].l_node); 1751 } break; 1752 case 89: 1753 # line 481 "../common/dt_grammar.y" 1754 { 1755 yyval.l_node = OP2(DT_TOK_MOD, yypvt[-2].l_node, yypvt[-0].l_node); 1756 } break; 1757 case 91: 1758 # line 488 "../common/dt_grammar.y" 1759 { 1760 yyval.l_node = OP2(DT_TOK_ADD, yypvt[-2].l_node, yypvt[-0].l_node); 1761 } break; 1762 case 92: 1763 # line 491 "../common/dt_grammar.y" 1764 { 1765 yyval.l_node = OP2(DT_TOK_SUB, yypvt[-2].l_node, yypvt[-0].l_node); 1766 } break; 1767 case 94: 1768 # line 498 "../common/dt_grammar.y" 1769 { 1770 yyval.l_node = OP2(DT_TOK_LSH, yypvt[-2].l_node, yypvt[-0].l_node); 1771 } break; 1772 case 95: 1773 # line 501 "../common/dt_grammar.y" 1774 { 1775 yyval.l_node = OP2(DT_TOK_RSH, yypvt[-2].l_node, yypvt[-0].l_node); 1776 } break; 1777 case 97: 1778 # line 508 "../common/dt_grammar.y" 1779 { 1780 yyval.l_node = OP2(DT_TOK_LT, yypvt[-2].l_node, yypvt[-0].l_node); 1781 } break; 1782 case 98: 1783 # line 511 "../common/dt_grammar.y" 1784 { 1785 yyval.l_node = OP2(DT_TOK_GT, yypvt[-2].l_node, yypvt[-0].l_node); 1786 } break; 1787 case 99: 1788 # line 514 "../common/dt_grammar.y" 1789 { 1790 yyval.l_node = OP2(DT_TOK_LE, yypvt[-2].l_node, yypvt[-0].l_node); 1791 } break; 1792 case 100: 1793 # line 517 "../common/dt_grammar.y" 1794 { 1795 yyval.l_node = OP2(DT_TOK_GE, yypvt[-2].l_node, yypvt[-0].l_node); 1796 } break; 1797 case 102: 1798 # line 524 "../common/dt_grammar.y" 1799 { 1800 yyval.l_node = OP2(DT_TOK_EQU, yypvt[-2].l_node, yypvt[-0].l_node); 1801 } break; 1802 case 103: 1803 # line 527 "../common/dt_grammar.y" 1804 { 1805 yyval.l_node = OP2(DT_TOK_NEQ, yypvt[-2].l_node, yypvt[-0].l_node); 1806 } break; 1807 case 105: 1808 # line 534 "../common/dt_grammar.y" 1809 { 1810 yyval.l_node = OP2(DT_TOK_BAND, yypvt[-2].l_node, yypvt[-0].l_node); 1811 } break; 1812 case 107: 1813 # line 541 "../common/dt_grammar.y" 1814 { 1815 yyval.l_node = OP2(DT_TOK_XOR, yypvt[-2].l_node, yypvt[-0].l_node); 1816 } break; 1817 case 109: 1818 # line 548 "../common/dt_grammar.y" 1819 { 1820 yyval.l_node = OP2(DT_TOK_BOR, yypvt[-2].l_node, yypvt[-0].l_node); 1821 } break; 1822 case 111: 1823 # line 555 "../common/dt_grammar.y" 1824 { 1825 yyval.l_node = OP2(DT_TOK_LAND, yypvt[-2].l_node, yypvt[-0].l_node); 1826 } break; 1827 case 113: 1828 # line 562 "../common/dt_grammar.y" 1829 { 1830 yyval.l_node = OP2(DT_TOK_LXOR, yypvt[-2].l_node, yypvt[-0].l_node); 1831 } break; 1832 case 115: 1833 # line 569 "../common/dt_grammar.y" 1834 { 1835 yyval.l_node = OP2(DT_TOK_LOR, yypvt[-2].l_node, yypvt[-0].l_node); 1836 } break; 1837 case 118: 1838 # line 580 "../common/dt_grammar.y" 1839 { yyval.l_node = OP3(yypvt[-4].l_node, yypvt[-2].l_node, yypvt[-0].l_node); } break; 1840 case 120: 1841 # line 585 "../common/dt_grammar.y" 1842 { 1843 yyval.l_node = OP2(yypvt[-1].l_tok, yypvt[-2].l_node, yypvt[-0].l_node); 1844 } break; 1845 case 121: 1846 # line 591 "../common/dt_grammar.y" 1847 { yyval.l_tok = DT_TOK_ASGN; } break; 1848 case 122: 1849 # line 592 "../common/dt_grammar.y" 1850 { yyval.l_tok = DT_TOK_MUL_EQ; } break; 1851 case 123: 1852 # line 593 "../common/dt_grammar.y" 1853 { yyval.l_tok = DT_TOK_DIV_EQ; } break; 1854 case 124: 1855 # line 594 "../common/dt_grammar.y" 1856 { yyval.l_tok = DT_TOK_MOD_EQ; } break; 1857 case 125: 1858 # line 595 "../common/dt_grammar.y" 1859 { yyval.l_tok = DT_TOK_ADD_EQ; } break; 1860 case 126: 1861 # line 596 "../common/dt_grammar.y" 1862 { yyval.l_tok = DT_TOK_SUB_EQ; } break; 1863 case 127: 1864 # line 597 "../common/dt_grammar.y" 1865 { yyval.l_tok = DT_TOK_LSH_EQ; } break; 1866 case 128: 1867 # line 598 "../common/dt_grammar.y" 1868 { yyval.l_tok = DT_TOK_RSH_EQ; } break; 1869 case 129: 1870 # line 599 "../common/dt_grammar.y" 1871 { yyval.l_tok = DT_TOK_AND_EQ; } break; 1872 case 130: 1873 # line 600 "../common/dt_grammar.y" 1874 { yyval.l_tok = DT_TOK_XOR_EQ; } break; 1875 case 131: 1876 # line 601 "../common/dt_grammar.y" 1877 { yyval.l_tok = DT_TOK_OR_EQ; } break; 1878 case 133: 1879 # line 605 "../common/dt_grammar.y" 1880 { 1881 yyval.l_node = OP2(DT_TOK_COMMA, yypvt[-2].l_node, yypvt[-0].l_node); 1882 } break; 1883 case 134: 1884 # line 610 "../common/dt_grammar.y" 1885 { 1886 yyval.l_node = dt_node_decl(); 1887 dt_decl_free(dt_decl_pop()); 1888 yybegin(YYS_CLAUSE); 1889 } break; 1890 case 135: 1891 # line 615 "../common/dt_grammar.y" 1892 { 1893 yyval.l_node = yypvt[-1].l_node; 1894 dt_decl_free(dt_decl_pop()); 1895 yybegin(YYS_CLAUSE); 1896 } break; 1897 case 148: 1898 # line 641 "../common/dt_grammar.y" 1899 { dt_decl_class(DT_DC_AUTO); } break; 1900 case 149: 1901 # line 642 "../common/dt_grammar.y" 1902 { dt_decl_class(DT_DC_REGISTER); } break; 1903 case 150: 1904 # line 643 "../common/dt_grammar.y" 1905 { dt_decl_class(DT_DC_STATIC); } break; 1906 case 151: 1907 # line 644 "../common/dt_grammar.y" 1908 { dt_decl_class(DT_DC_EXTERN); } break; 1909 case 152: 1910 # line 645 "../common/dt_grammar.y" 1911 { dt_decl_class(DT_DC_TYPEDEF); } break; 1912 case 154: 1913 # line 650 "../common/dt_grammar.y" 1914 { dt_decl_class(DT_DC_SELF); } break; 1915 case 155: 1916 # line 651 "../common/dt_grammar.y" 1917 { dt_decl_class(DT_DC_THIS); } break; 1918 case 156: 1919 # line 654 "../common/dt_grammar.y" 1920 { yyval.l_decl = dt_decl_spec(CTF_K_INTEGER, DUP("void")); } break; 1921 case 157: 1922 # line 655 "../common/dt_grammar.y" 1923 { yyval.l_decl = dt_decl_spec(CTF_K_INTEGER, DUP("char")); } break; 1924 case 158: 1925 # line 656 "../common/dt_grammar.y" 1926 { yyval.l_decl = dt_decl_attr(DT_DA_SHORT); } break; 1927 case 159: 1928 # line 657 "../common/dt_grammar.y" 1929 { yyval.l_decl = dt_decl_spec(CTF_K_INTEGER, DUP("int")); } break; 1930 case 160: 1931 # line 658 "../common/dt_grammar.y" 1932 { yyval.l_decl = dt_decl_attr(DT_DA_LONG); } break; 1933 case 161: 1934 # line 659 "../common/dt_grammar.y" 1935 { yyval.l_decl = dt_decl_spec(CTF_K_FLOAT, DUP("float")); } break; 1936 case 162: 1937 # line 660 "../common/dt_grammar.y" 1938 { yyval.l_decl = dt_decl_spec(CTF_K_FLOAT, DUP("double")); } break; 1939 case 163: 1940 # line 661 "../common/dt_grammar.y" 1941 { yyval.l_decl = dt_decl_attr(DT_DA_SIGNED); } break; 1942 case 164: 1943 # line 662 "../common/dt_grammar.y" 1944 { yyval.l_decl = dt_decl_attr(DT_DA_UNSIGNED); } break; 1945 case 165: 1946 # line 663 "../common/dt_grammar.y" 1947 { yyval.l_decl = dt_decl_attr(DT_DA_USER); } break; 1948 case 166: 1949 # line 664 "../common/dt_grammar.y" 1950 { 1951 yyval.l_decl = dt_decl_spec(CTF_K_TYPEDEF, DUP("string")); 1952 } break; 1953 case 167: 1954 # line 667 "../common/dt_grammar.y" 1955 { yyval.l_decl = dt_decl_spec(CTF_K_TYPEDEF, yypvt[-0].l_str); } break; 1956 case 170: 1957 # line 672 "../common/dt_grammar.y" 1958 { yyval.l_decl = dt_decl_attr(DT_DA_CONST); } break; 1959 case 171: 1960 # line 673 "../common/dt_grammar.y" 1961 { yyval.l_decl = dt_decl_attr(DT_DA_RESTRICT); } break; 1962 case 172: 1963 # line 674 "../common/dt_grammar.y" 1964 { yyval.l_decl = dt_decl_attr(DT_DA_VOLATILE); } break; 1965 case 173: 1966 # line 678 "../common/dt_grammar.y" 1967 { 1968 yyval.l_decl = dt_scope_pop(); 1969 } break; 1970 case 174: 1971 # line 681 "../common/dt_grammar.y" 1972 { yyval.l_decl = dt_decl_spec(yypvt[-1].l_tok, yypvt[-0].l_str); } break; 1973 case 175: 1974 # line 682 "../common/dt_grammar.y" 1975 { yyval.l_decl = dt_decl_spec(yypvt[-1].l_tok, yypvt[-0].l_str); } break; 1976 case 176: 1977 # line 686 "../common/dt_grammar.y" 1978 { dt_decl_sou(yypvt[-1].l_tok, NULL); } break; 1979 case 177: 1980 # line 687 "../common/dt_grammar.y" 1981 { dt_decl_sou(yypvt[-2].l_tok, yypvt[-1].l_str); } break; 1982 case 178: 1983 # line 688 "../common/dt_grammar.y" 1984 { dt_decl_sou(yypvt[-2].l_tok, yypvt[-1].l_str); } break; 1985 case 179: 1986 # line 692 "../common/dt_grammar.y" 1987 { yyval.l_tok = CTF_K_STRUCT; } break; 1988 case 180: 1989 # line 693 "../common/dt_grammar.y" 1990 { yyval.l_tok = CTF_K_UNION; } break; 1991 case 184: 1992 # line 703 "../common/dt_grammar.y" 1993 { 1994 yyval.l_node = LINK(yypvt[-2].l_node, yypvt[-0].l_node); 1995 } break; 1996 case 185: 1997 # line 709 "../common/dt_grammar.y" 1998 { 1999 yyval.l_node = dt_node_decl(); 2000 dt_decl_reset(); 2001 } break; 2002 case 186: 2003 # line 716 "../common/dt_grammar.y" 2004 { 2005 dt_decl_free(dt_decl_pop()); 2006 } break; 2007 case 188: 2008 # line 723 "../common/dt_grammar.y" 2009 { yyval.l_decl = yypvt[-0].l_decl; } break; 2010 case 190: 2011 # line 725 "../common/dt_grammar.y" 2012 { yyval.l_decl = yypvt[-0].l_decl; } break; 2013 case 193: 2014 # line 734 "../common/dt_grammar.y" 2015 { dt_decl_member(NULL); } break; 2016 case 194: 2017 # line 735 "../common/dt_grammar.y" 2018 { dt_decl_member(yypvt[-0].l_node); } break; 2019 case 195: 2020 # line 736 "../common/dt_grammar.y" 2021 { 2022 dt_decl_member(yypvt[-0].l_node); 2023 } break; 2024 case 196: 2025 # line 742 "../common/dt_grammar.y" 2026 { yyval.l_decl = dt_scope_pop(); } break; 2027 case 197: 2028 # line 743 "../common/dt_grammar.y" 2029 { yyval.l_decl = dt_decl_spec(CTF_K_ENUM, yypvt[-0].l_str); } break; 2030 case 198: 2031 # line 744 "../common/dt_grammar.y" 2032 { yyval.l_decl = dt_decl_spec(CTF_K_ENUM, yypvt[-0].l_str); } break; 2033 case 199: 2034 # line 748 "../common/dt_grammar.y" 2035 { dt_decl_enum(NULL); } break; 2036 case 200: 2037 # line 749 "../common/dt_grammar.y" 2038 { dt_decl_enum(yypvt[-1].l_str); } break; 2039 case 201: 2040 # line 750 "../common/dt_grammar.y" 2041 { dt_decl_enum(yypvt[-1].l_str); } break; 2042 case 204: 2043 # line 758 "../common/dt_grammar.y" 2044 { dt_decl_enumerator(yypvt[-0].l_str, NULL); } break; 2045 case 205: 2046 # line 759 "../common/dt_grammar.y" 2047 { 2048 dt_decl_enumerator(yypvt[-2].l_str, yypvt[-0].l_node); 2049 } break; 2050 case 208: 2051 # line 769 "../common/dt_grammar.y" 2052 { yyval.l_decl = dt_decl_ident(yypvt[-0].l_str); } break; 2053 case 209: 2054 # line 770 "../common/dt_grammar.y" 2055 { yyval.l_decl = yypvt[-1].l_decl; } break; 2056 case 210: 2057 # line 771 "../common/dt_grammar.y" 2058 { dt_decl_array(yypvt[-0].l_node); } break; 2059 case 211: 2060 # line 772 "../common/dt_grammar.y" 2061 { dt_decl_func(yypvt[-1].l_decl, yypvt[-0].l_node); } break; 2062 case 212: 2063 # line 775 "../common/dt_grammar.y" 2064 { dt_decl_top()->dd_attr |= DT_DA_PAREN; } break; 2065 case 213: 2066 # line 778 "../common/dt_grammar.y" 2067 { yyval.l_decl = dt_decl_ptr(); } break; 2068 case 214: 2069 # line 779 "../common/dt_grammar.y" 2070 { yyval.l_decl = dt_decl_ptr(); } break; 2071 case 215: 2072 # line 780 "../common/dt_grammar.y" 2073 { yyval.l_decl = dt_decl_ptr(); } break; 2074 case 216: 2075 # line 781 "../common/dt_grammar.y" 2076 { yyval.l_decl = dt_decl_ptr(); } break; 2077 case 218: 2078 # line 786 "../common/dt_grammar.y" 2079 { yyval.l_decl = yypvt[-0].l_decl; } break; 2080 case 220: 2081 # line 791 "../common/dt_grammar.y" 2082 { yyval.l_node = dt_node_vatype(); } break; 2083 case 221: 2084 # line 792 "../common/dt_grammar.y" 2085 { 2086 yyval.l_node = LINK(yypvt[-2].l_node, dt_node_vatype()); 2087 } break; 2088 case 223: 2089 # line 798 "../common/dt_grammar.y" 2090 { 2091 yyval.l_node = LINK(yypvt[-2].l_node, yypvt[-0].l_node); 2092 } break; 2093 case 224: 2094 # line 804 "../common/dt_grammar.y" 2095 { 2096 yyval.l_node = dt_node_type(NULL); 2097 } break; 2098 case 225: 2099 # line 807 "../common/dt_grammar.y" 2100 { 2101 yyval.l_node = dt_node_type(NULL); 2102 } break; 2103 case 226: 2104 # line 810 "../common/dt_grammar.y" 2105 { 2106 yyval.l_node = dt_node_type(NULL); 2107 } break; 2108 case 227: 2109 # line 815 "../common/dt_grammar.y" 2110 { 2111 yyval.l_decl = dt_decl_pop(); 2112 } break; 2113 case 228: 2114 # line 818 "../common/dt_grammar.y" 2115 { 2116 yyval.l_decl = dt_decl_pop(); 2117 } break; 2118 case 232: 2119 # line 830 "../common/dt_grammar.y" 2120 { yyval.l_decl = yypvt[-1].l_decl; } break; 2121 case 233: 2122 # line 831 "../common/dt_grammar.y" 2123 { dt_decl_array(yypvt[-0].l_node); } break; 2124 case 234: 2125 # line 832 "../common/dt_grammar.y" 2126 { dt_decl_array(yypvt[-0].l_node); yyval.l_decl = NULL; } break; 2127 case 235: 2128 # line 833 "../common/dt_grammar.y" 2129 { dt_decl_func(yypvt[-1].l_decl, yypvt[-0].l_node); } break; 2130 case 236: 2131 # line 834 "../common/dt_grammar.y" 2132 { dt_decl_func(NULL, yypvt[-0].l_node); } break; 2133 case 237: 2134 # line 837 "../common/dt_grammar.y" 2135 { dt_scope_push(NULL, CTF_ERR); } break; 2136 case 238: 2137 # line 838 "../common/dt_grammar.y" 2138 { 2139 dt_scope_pop(); 2140 yyval.l_node = yypvt[-1].l_node; 2141 } break; 2142 case 239: 2143 # line 845 "../common/dt_grammar.y" 2144 { yyval.l_node = NULL; } break; 2145 case 240: 2146 # line 846 "../common/dt_grammar.y" 2147 { yyval.l_node = yypvt[-0].l_node; } break; 2148 case 241: 2149 # line 847 "../common/dt_grammar.y" 2150 { yyval.l_node = yypvt[-0].l_node; } break; 2151 case 242: 2152 # line 850 "../common/dt_grammar.y" 2153 { dt_scope_push(NULL, CTF_ERR); } break; 2154 case 243: 2155 # line 851 "../common/dt_grammar.y" 2156 { 2157 dt_scope_pop(); 2158 yyval.l_node = yypvt[-1].l_node; 2159 } break; 2160 case 244: 2161 # line 858 "../common/dt_grammar.y" 2162 { yyval.l_node = NULL; } break; 2163 case 245: 2164 # line 859 "../common/dt_grammar.y" 2165 { yyval.l_node = yypvt[-0].l_node; } break; 2166 # line 556 "/usr/share/lib/ccs/yaccpar" 2167 } 2168 goto yystack; /* reset registers in driver code */ 2169 } 2170 2171