yacc.cc
00001 00002 /* A Bison parser, made by GNU Bison 2.4.1. */ 00003 00004 /* Skeleton implementation for Bison's Yacc-like parsers in C 00005 00006 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 00007 Free Software Foundation, Inc. 00008 00009 This program is free software: you can redistribute it and/or modify 00010 it under the terms of the GNU General Public License as published by 00011 the Free Software Foundation, either version 3 of the License, or 00012 (at your option) any later version. 00013 00014 This program is distributed in the hope that it will be useful, 00015 but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00017 GNU General Public License for more details. 00018 00019 You should have received a copy of the GNU General Public License 00020 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 00021 00022 /* As a special exception, you may create a larger work that contains 00023 part or all of the Bison parser skeleton and distribute that work 00024 under terms of your choice, so long as that work isn't itself a 00025 parser generator using the skeleton or a modified version thereof 00026 as a parser skeleton. Alternatively, if you modify or redistribute 00027 the parser skeleton itself, you may (at your option) remove this 00028 special exception, which will cause the skeleton and the resulting 00029 Bison output files to be licensed under the GNU General Public 00030 License without this special exception. 00031 00032 This special exception was added by the Free Software Foundation in 00033 version 2.2 of Bison. */ 00034 00035 /* C LALR(1) parser skeleton written by Richard Stallman, by 00036 simplifying the original so-called "semantic" parser. */ 00037 00038 /* All symbols defined below should begin with yy or YY, to avoid 00039 infringing on user name space. This should be done even for local 00040 variables, as they might otherwise be expanded by user macros. 00041 There are some unavoidable exceptions within include files to 00042 define necessary library symbols; they are noted "INFRINGES ON 00043 USER NAME SPACE" below. */ 00044 00045 /* Identify Bison output. */ 00046 #define YYBISON 1 00047 00048 /* Bison version. */ 00049 #define YYBISON_VERSION "2.4.1" 00050 00051 /* Skeleton name. */ 00052 #define YYSKELETON_NAME "yacc.c" 00053 00054 /* Pure parsers. */ 00055 #define YYPURE 0 00056 00057 /* Push parsers. */ 00058 #define YYPUSH 0 00059 00060 /* Pull parsers. */ 00061 #define YYPULL 1 00062 00063 /* Using locations. */ 00064 #define YYLSP_NEEDED 0 00065 00066 00067 00068 /* Copy the first part of user declarations. */ 00069 00070 /* Line 189 of yacc.c */ 00071 #line 1 "yacc.yy" 00072 00073 /***************************************************************** 00074 Copyright (c) 1999 Torben Weis <weis@kde.org> 00075 Copyright (c) 2000 Matthias Ettrich <ettrich@kde.org> 00076 00077 Permission is hereby granted, free of charge, to any person obtaining a copy 00078 of this software and associated documentation files (the "Software"), to deal 00079 in the Software without restriction, including without limitation the rights 00080 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 00081 copies of the Software, and to permit persons to whom the Software is 00082 furnished to do so, subject to the following conditions: 00083 00084 The above copyright notice and this permission notice shall be included in 00085 all copies or substantial portions of the Software. 00086 00087 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00088 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00089 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 00090 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 00091 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 00092 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 00093 00094 ******************************************************************/ 00095 00096 #include <config.h> 00097 00098 // Workaround for a bison issue: 00099 // bison.simple concludes from _GNU_SOURCE that stpcpy is available, 00100 // while GNU string.h only exposes it if __USE_GNU is set. 00101 #ifdef _GNU_SOURCE 00102 #define __USE_GNU 1 00103 #endif 00104 00105 #include <stdlib.h> 00106 #include <stdio.h> 00107 #include <assert.h> 00108 00109 #include <tqstring.h> 00110 00111 #define AMP_ENTITY "&" 00112 #define YYERROR_VERBOSE 00113 00114 extern int yylex(); 00115 00116 // extern QString idl_lexFile; 00117 extern int idl_line_no; 00118 extern int function_mode; 00119 00120 static int dcop_area = 0; 00121 static int dcop_signal_area = 0; 00122 00123 static QString in_namespace( "" ); 00124 00125 void dcopidlInitFlex( const char *_code ); 00126 00127 void yyerror( const char *s ) 00128 { 00129 tqDebug( "In line %i : %s", idl_line_no, s ); 00130 exit(1); 00131 // theParser->parse_error( idl_lexFile, s, idl_line_no ); 00132 } 00133 00134 00135 00136 /* Line 189 of yacc.c */ 00137 #line 138 "yacc.cc" 00138 00139 /* Enabling traces. */ 00140 #ifndef YYDEBUG 00141 # define YYDEBUG 1 00142 #endif 00143 00144 /* Enabling verbose error messages. */ 00145 #ifdef YYERROR_VERBOSE 00146 # undef YYERROR_VERBOSE 00147 # define YYERROR_VERBOSE 1 00148 #else 00149 # define YYERROR_VERBOSE 0 00150 #endif 00151 00152 /* Enabling the token table. */ 00153 #ifndef YYTOKEN_TABLE 00154 # define YYTOKEN_TABLE 0 00155 #endif 00156 00157 00158 /* Tokens. */ 00159 #ifndef YYTOKENTYPE 00160 # define YYTOKENTYPE 00161 /* Put the tokens into the symbol table, so that GDB and other debuggers 00162 know about them. */ 00163 enum yytokentype { 00164 T_UNIMPORTANT = 258, 00165 T_CHARACTER_LITERAL = 259, 00166 T_DOUBLE_LITERAL = 260, 00167 T_IDENTIFIER = 261, 00168 T_INTEGER_LITERAL = 262, 00169 T_STRING_LITERAL = 263, 00170 T_INCLUDE = 264, 00171 T_CLASS = 265, 00172 T_STRUCT = 266, 00173 T_LEFT_CURLY_BRACKET = 267, 00174 T_LEFT_PARANTHESIS = 268, 00175 T_RIGHT_CURLY_BRACKET = 269, 00176 T_RIGHT_PARANTHESIS = 270, 00177 T_COLON = 271, 00178 T_SEMICOLON = 272, 00179 T_PUBLIC = 273, 00180 T_PROTECTED = 274, 00181 T_TRIPE_DOT = 275, 00182 T_PRIVATE = 276, 00183 T_VIRTUAL = 277, 00184 T_CONST = 278, 00185 T_INLINE = 279, 00186 T_FRIEND = 280, 00187 T_RETURN = 281, 00188 T_SIGNAL = 282, 00189 T_SLOT = 283, 00190 T_TYPEDEF = 284, 00191 T_PLUS = 285, 00192 T_MINUS = 286, 00193 T_COMMA = 287, 00194 T_ASTERISK = 288, 00195 T_TILDE = 289, 00196 T_LESS = 290, 00197 T_GREATER = 291, 00198 T_AMPERSAND = 292, 00199 T_EXTERN = 293, 00200 T_EXTERN_C = 294, 00201 T_ACCESS = 295, 00202 T_ENUM = 296, 00203 T_NAMESPACE = 297, 00204 T_USING = 298, 00205 T_UNKNOWN = 299, 00206 T_TRIPLE_DOT = 300, 00207 T_TRUE = 301, 00208 T_FALSE = 302, 00209 T_STATIC = 303, 00210 T_MUTABLE = 304, 00211 T_EQUAL = 305, 00212 T_SCOPE = 306, 00213 T_NULL = 307, 00214 T_INT = 308, 00215 T_ARRAY_OPEN = 309, 00216 T_ARRAY_CLOSE = 310, 00217 T_CHAR = 311, 00218 T_DCOP = 312, 00219 T_DCOP_AREA = 313, 00220 T_DCOP_SIGNAL_AREA = 314, 00221 T_SIGNED = 315, 00222 T_UNSIGNED = 316, 00223 T_LONG = 317, 00224 T_SHORT = 318, 00225 T_FUNOPERATOR = 319, 00226 T_MISCOPERATOR = 320, 00227 T_SHIFT = 321 00228 }; 00229 #endif 00230 00231 00232 00233 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 00234 typedef union YYSTYPE 00235 { 00236 00237 /* Line 214 of yacc.c */ 00238 #line 67 "yacc.yy" 00239 00240 long _int; 00241 QString *_str; 00242 unsigned short _char; 00243 double _float; 00244 00245 00246 00247 /* Line 214 of yacc.c */ 00248 #line 249 "yacc.cc" 00249 } YYSTYPE; 00250 # define YYSTYPE_IS_TRIVIAL 1 00251 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 00252 # define YYSTYPE_IS_DECLARED 1 00253 #endif 00254 00255 00256 /* Copy the second part of user declarations. */ 00257 00258 00259 /* Line 264 of yacc.c */ 00260 #line 261 "yacc.cc" 00261 00262 #ifdef short 00263 # undef short 00264 #endif 00265 00266 #ifdef YYTYPE_UINT8 00267 typedef YYTYPE_UINT8 yytype_uint8; 00268 #else 00269 typedef unsigned char yytype_uint8; 00270 #endif 00271 00272 #ifdef YYTYPE_INT8 00273 typedef YYTYPE_INT8 yytype_int8; 00274 #elif (defined __STDC__ || defined __C99__FUNC__ \ 00275 || defined __cplusplus || defined _MSC_VER) 00276 typedef signed char yytype_int8; 00277 #else 00278 typedef short int yytype_int8; 00279 #endif 00280 00281 #ifdef YYTYPE_UINT16 00282 typedef YYTYPE_UINT16 yytype_uint16; 00283 #else 00284 typedef unsigned short int yytype_uint16; 00285 #endif 00286 00287 #ifdef YYTYPE_INT16 00288 typedef YYTYPE_INT16 yytype_int16; 00289 #else 00290 typedef short int yytype_int16; 00291 #endif 00292 00293 #ifndef YYSIZE_T 00294 # ifdef __SIZE_TYPE__ 00295 # define YYSIZE_T __SIZE_TYPE__ 00296 # elif defined size_t 00297 # define YYSIZE_T size_t 00298 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 00299 || defined __cplusplus || defined _MSC_VER) 00300 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 00301 # define YYSIZE_T size_t 00302 # else 00303 # define YYSIZE_T unsigned int 00304 # endif 00305 #endif 00306 00307 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 00308 00309 #ifndef YY_ 00310 # if YYENABLE_NLS 00311 # if ENABLE_NLS 00312 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 00313 # define YY_(msgid) dgettext ("bison-runtime", msgid) 00314 # endif 00315 # endif 00316 # ifndef YY_ 00317 # define YY_(msgid) msgid 00318 # endif 00319 #endif 00320 00321 /* Suppress unused-variable warnings by "using" E. */ 00322 #if ! defined lint || defined __GNUC__ 00323 # define YYUSE(e) ((void) (e)) 00324 #else 00325 # define YYUSE(e) /* empty */ 00326 #endif 00327 00328 /* Identity function, used to suppress warnings about constant conditions. */ 00329 #ifndef lint 00330 # define YYID(n) (n) 00331 #else 00332 #if (defined __STDC__ || defined __C99__FUNC__ \ 00333 || defined __cplusplus || defined _MSC_VER) 00334 static int 00335 YYID (int yyi) 00336 #else 00337 static int 00338 YYID (yyi) 00339 int yyi; 00340 #endif 00341 { 00342 return yyi; 00343 } 00344 #endif 00345 00346 #if ! defined yyoverflow || YYERROR_VERBOSE 00347 00348 /* The parser invokes alloca or malloc; define the necessary symbols. */ 00349 00350 # ifdef YYSTACK_USE_ALLOCA 00351 # if YYSTACK_USE_ALLOCA 00352 # ifdef __GNUC__ 00353 # define YYSTACK_ALLOC __builtin_alloca 00354 # elif defined __BUILTIN_VA_ARG_INCR 00355 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 00356 # elif defined _AIX 00357 # define YYSTACK_ALLOC __alloca 00358 # elif defined _MSC_VER 00359 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 00360 # define alloca _alloca 00361 # else 00362 # define YYSTACK_ALLOC alloca 00363 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 00364 || defined __cplusplus || defined _MSC_VER) 00365 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 00366 # ifndef _STDLIB_H 00367 # define _STDLIB_H 1 00368 # endif 00369 # endif 00370 # endif 00371 # endif 00372 # endif 00373 00374 # ifdef YYSTACK_ALLOC 00375 /* Pacify GCC's `empty if-body' warning. */ 00376 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 00377 # ifndef YYSTACK_ALLOC_MAXIMUM 00378 /* The OS might guarantee only one guard page at the bottom of the stack, 00379 and a page size can be as small as 4096 bytes. So we cannot safely 00380 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 00381 to allow for a few compiler-allocated temporary stack slots. */ 00382 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 00383 # endif 00384 # else 00385 # define YYSTACK_ALLOC YYMALLOC 00386 # define YYSTACK_FREE YYFREE 00387 # ifndef YYSTACK_ALLOC_MAXIMUM 00388 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 00389 # endif 00390 # if (defined __cplusplus && ! defined _STDLIB_H \ 00391 && ! ((defined YYMALLOC || defined malloc) \ 00392 && (defined YYFREE || defined free))) 00393 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 00394 # ifndef _STDLIB_H 00395 # define _STDLIB_H 1 00396 # endif 00397 # endif 00398 # ifndef YYMALLOC 00399 # define YYMALLOC malloc 00400 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 00401 || defined __cplusplus || defined _MSC_VER) 00402 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 00403 # endif 00404 # endif 00405 # ifndef YYFREE 00406 # define YYFREE free 00407 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 00408 || defined __cplusplus || defined _MSC_VER) 00409 void free (void *); /* INFRINGES ON USER NAME SPACE */ 00410 # endif 00411 # endif 00412 # endif 00413 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 00414 00415 00416 #if (! defined yyoverflow \ 00417 && (! defined __cplusplus \ 00418 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 00419 00420 /* A type that is properly aligned for any stack member. */ 00421 union yyalloc 00422 { 00423 yytype_int16 yyss_alloc; 00424 YYSTYPE yyvs_alloc; 00425 }; 00426 00427 /* The size of the maximum gap between one aligned stack and the next. */ 00428 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 00429 00430 /* The size of an array large to enough to hold all stacks, each with 00431 N elements. */ 00432 # define YYSTACK_BYTES(N) \ 00433 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 00434 + YYSTACK_GAP_MAXIMUM) 00435 00436 /* Copy COUNT objects from FROM to TO. The source and destination do 00437 not overlap. */ 00438 # ifndef YYCOPY 00439 # if defined __GNUC__ && 1 < __GNUC__ 00440 # define YYCOPY(To, From, Count) \ 00441 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 00442 # else 00443 # define YYCOPY(To, From, Count) \ 00444 do \ 00445 { \ 00446 YYSIZE_T yyi; \ 00447 for (yyi = 0; yyi < (Count); yyi++) \ 00448 (To)[yyi] = (From)[yyi]; \ 00449 } \ 00450 while (YYID (0)) 00451 # endif 00452 # endif 00453 00454 /* Relocate STACK from its old location to the new one. The 00455 local variables YYSIZE and YYSTACKSIZE give the old and new number of 00456 elements in the stack, and YYPTR gives the new location of the 00457 stack. Advance YYPTR to a properly aligned location for the next 00458 stack. */ 00459 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 00460 do \ 00461 { \ 00462 YYSIZE_T yynewbytes; \ 00463 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 00464 Stack = &yyptr->Stack_alloc; \ 00465 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 00466 yyptr += yynewbytes / sizeof (*yyptr); \ 00467 } \ 00468 while (YYID (0)) 00469 00470 #endif 00471 00472 /* YYFINAL -- State number of the termination state. */ 00473 #define YYFINAL 5 00474 /* YYLAST -- Last index in YYTABLE. */ 00475 #define YYLAST 559 00476 00477 /* YYNTOKENS -- Number of terminals. */ 00478 #define YYNTOKENS 67 00479 /* YYNNTS -- Number of nonterminals. */ 00480 #define YYNNTS 53 00481 /* YYNRULES -- Number of rules. */ 00482 #define YYNRULES 185 00483 /* YYNRULES -- Number of states. */ 00484 #define YYNSTATES 374 00485 00486 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 00487 #define YYUNDEFTOK 2 00488 #define YYMAXUTOK 321 00489 00490 #define YYTRANSLATE(YYX) \ 00491 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 00492 00493 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 00494 static const yytype_uint8 yytranslate[] = 00495 { 00496 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00500 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00501 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00502 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00503 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00504 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00505 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00506 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00507 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00508 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00509 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00510 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00511 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00512 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00513 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00514 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00515 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00516 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00517 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00518 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00519 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00520 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00521 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 00522 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 00523 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 00524 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 00525 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 00526 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 00527 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 00528 65, 66 00529 }; 00530 00531 #if YYDEBUG 00532 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 00533 YYRHS. */ 00534 static const yytype_uint16 yyprhs[] = 00535 { 00536 0, 0, 3, 7, 8, 11, 16, 17, 19, 20, 00537 27, 35, 39, 43, 49, 50, 58, 63, 69, 72, 00538 77, 85, 94, 97, 99, 101, 103, 106, 107, 109, 00539 111, 113, 115, 117, 119, 121, 122, 126, 129, 132, 00540 135, 137, 141, 143, 148, 152, 154, 157, 161, 164, 00541 166, 167, 169, 171, 174, 178, 181, 184, 187, 190, 00542 193, 196, 202, 207, 212, 217, 224, 229, 236, 243, 00543 251, 258, 265, 271, 275, 277, 281, 283, 285, 287, 00544 290, 292, 294, 296, 300, 304, 312, 322, 323, 325, 00545 327, 330, 332, 335, 338, 342, 345, 349, 352, 356, 00546 359, 363, 365, 367, 370, 372, 375, 377, 380, 383, 00547 386, 388, 389, 391, 395, 397, 399, 402, 405, 410, 00548 417, 421, 423, 426, 428, 432, 436, 439, 442, 446, 00549 449, 451, 454, 458, 460, 464, 467, 469, 470, 473, 00550 479, 481, 483, 485, 487, 492, 493, 495, 497, 499, 00551 501, 503, 505, 512, 520, 522, 526, 527, 532, 534, 00552 538, 541, 547, 551, 557, 565, 572, 576, 578, 580, 00553 584, 589, 592, 593, 595, 598, 599, 601, 605, 608, 00554 611, 615, 621, 627, 633, 640 00555 }; 00556 00557 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 00558 static const yytype_int8 yyrhs[] = 00559 { 00560 68, 0, -1, 69, 71, 68, -1, -1, 69, 9, 00561 -1, 39, 12, 68, 14, -1, -1, 57, -1, -1, 00562 10, 80, 84, 70, 86, 17, -1, 10, 6, 80, 00563 84, 70, 86, 17, -1, 10, 80, 17, -1, 11, 00564 80, 17, -1, 11, 80, 84, 86, 17, -1, -1, 00565 42, 6, 12, 72, 68, 14, 85, -1, 43, 42, 00566 6, 17, -1, 43, 6, 51, 6, 17, -1, 38, 00567 17, -1, 29, 100, 80, 17, -1, 29, 11, 12, 00568 73, 14, 80, 17, -1, 29, 11, 80, 12, 73, 00569 14, 80, 17, -1, 24, 111, -1, 111, -1, 119, 00570 -1, 87, -1, 119, 73, -1, -1, 46, -1, 47, 00571 -1, 21, -1, 19, -1, 18, -1, 27, -1, 28, 00572 -1, -1, 75, 76, 16, -1, 76, 16, -1, 58, 00573 16, -1, 59, 16, -1, 6, -1, 6, 51, 80, 00574 -1, 80, -1, 80, 35, 101, 36, -1, 105, 18, 00575 81, -1, 81, -1, 82, 12, -1, 82, 32, 83, 00576 -1, 16, 83, -1, 12, -1, -1, 17, -1, 14, 00577 -1, 92, 86, -1, 24, 111, 86, -1, 111, 86, 00578 -1, 79, 86, -1, 87, 86, -1, 78, 86, -1, 00579 77, 86, -1, 119, 86, -1, 25, 10, 80, 17, 00580 86, -1, 25, 80, 17, 86, -1, 25, 107, 17, 00581 86, -1, 10, 80, 17, 86, -1, 10, 80, 84, 00582 86, 17, 86, -1, 11, 80, 17, 86, -1, 11, 00583 80, 84, 86, 17, 86, -1, 43, 6, 51, 6, 00584 17, 86, -1, 41, 6, 12, 88, 14, 6, 17, 00585 -1, 41, 6, 12, 88, 14, 17, -1, 41, 12, 00586 88, 14, 6, 17, -1, 41, 12, 88, 14, 17, 00587 -1, 89, 32, 88, -1, 89, -1, 6, 50, 91, 00588 -1, 6, -1, 4, -1, 7, -1, 31, 7, -1, 00589 52, -1, 80, -1, 90, -1, 90, 30, 90, -1, 00590 90, 66, 90, -1, 29, 80, 35, 101, 36, 80, 00591 17, -1, 29, 80, 35, 101, 36, 51, 6, 80, 00592 17, -1, -1, 23, -1, 60, -1, 60, 53, -1, 00593 61, -1, 61, 53, -1, 60, 63, -1, 60, 63, 00594 53, -1, 60, 62, -1, 60, 62, 53, -1, 61, 00595 63, -1, 61, 63, 53, -1, 61, 62, -1, 61, 00596 62, 53, -1, 53, -1, 62, -1, 62, 53, -1, 00597 63, -1, 63, 53, -1, 56, -1, 60, 56, -1, 00598 61, 56, -1, 33, 95, -1, 33, -1, -1, 102, 00599 -1, 96, 32, 102, -1, 94, -1, 80, -1, 11, 00600 80, -1, 10, 80, -1, 80, 35, 98, 36, -1, 00601 80, 35, 98, 36, 51, 80, -1, 99, 32, 98, 00602 -1, 99, -1, 97, 95, -1, 97, -1, 23, 97, 00603 95, -1, 23, 97, 37, -1, 23, 97, -1, 97, 00604 23, -1, 97, 23, 37, -1, 97, 37, -1, 97, 00605 -1, 97, 95, -1, 100, 32, 101, -1, 100, -1, 00606 100, 80, 103, -1, 100, 103, -1, 45, -1, -1, 00607 50, 104, -1, 50, 13, 100, 15, 104, -1, 8, 00608 -1, 91, -1, 5, -1, 74, -1, 80, 13, 96, 00609 15, -1, -1, 22, -1, 65, -1, 66, -1, 36, 00610 -1, 35, -1, 50, -1, 100, 80, 13, 96, 15, 00611 93, -1, 100, 64, 106, 13, 96, 15, 93, -1, 00612 104, -1, 104, 32, 108, -1, -1, 6, 13, 108, 00613 15, -1, 109, -1, 109, 32, 110, -1, 107, 113, 00614 -1, 22, 107, 50, 52, 113, -1, 22, 107, 113, 00615 -1, 80, 13, 96, 15, 113, -1, 80, 13, 96, 00616 15, 16, 110, 113, -1, 105, 34, 80, 13, 15, 00617 113, -1, 48, 107, 113, -1, 12, -1, 17, -1, 00618 112, 114, 14, -1, 112, 114, 14, 17, -1, 115, 00619 114, -1, -1, 17, -1, 32, 118, -1, -1, 6, 00620 -1, 6, 50, 104, -1, 95, 6, -1, 117, 116, 00621 -1, 100, 118, 17, -1, 100, 80, 16, 7, 17, 00622 -1, 48, 100, 6, 103, 17, -1, 49, 100, 6, 00623 103, 17, -1, 100, 6, 54, 91, 55, 17, -1, 00624 48, 100, 6, 54, 91, 55, 17, -1 00625 }; 00626 00627 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 00628 static const yytype_uint16 yyrline[] = 00629 { 00630 0, 164, 164, 167, 171, 175, 179, 184, 185, 189, 00631 198, 207, 210, 213, 217, 216, 228, 231, 234, 237, 00632 240, 243, 246, 249, 252, 255, 261, 262, 265, 265, 00633 267, 267, 267, 269, 269, 269, 272, 277, 285, 293, 00634 305, 308, 316, 322, 331, 335, 342, 346, 354, 358, 00635 366, 368, 372, 376, 380, 384, 388, 392, 396, 400, 00636 404, 408, 412, 416, 420, 424, 428, 432, 436, 443, 00637 444, 445, 446, 450, 451, 455, 456, 460, 461, 462, 00638 463, 464, 468, 469, 470, 474, 484, 493, 496, 503, 00639 504, 505, 506, 507, 508, 509, 510, 511, 512, 513, 00640 514, 515, 516, 517, 518, 519, 520, 521, 522, 526, 00641 527, 532, 535, 536, 544, 545, 546, 547, 548, 554, 00642 565, 569, 577, 582, 591, 596, 603, 608, 613, 620, 00643 625, 630, 638, 642, 649, 658, 666, 676, 678, 681, 00644 688, 691, 694, 697, 700, 706, 707, 711, 711, 711, 00645 711, 711, 715, 737, 748, 749, 750, 755, 760, 761, 00646 765, 769, 773, 777, 783, 789, 795, 808, 815, 816, 00647 817, 821, 822, 826, 830, 831, 834, 835, 836, 839, 00648 843, 844, 845, 846, 847, 848 00649 }; 00650 #endif 00651 00652 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 00653 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 00654 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 00655 static const char *const yytname[] = 00656 { 00657 "$end", "error", "$undefined", "T_UNIMPORTANT", "T_CHARACTER_LITERAL", 00658 "T_DOUBLE_LITERAL", "T_IDENTIFIER", "T_INTEGER_LITERAL", 00659 "T_STRING_LITERAL", "T_INCLUDE", "T_CLASS", "T_STRUCT", 00660 "T_LEFT_CURLY_BRACKET", "T_LEFT_PARANTHESIS", "T_RIGHT_CURLY_BRACKET", 00661 "T_RIGHT_PARANTHESIS", "T_COLON", "T_SEMICOLON", "T_PUBLIC", 00662 "T_PROTECTED", "T_TRIPE_DOT", "T_PRIVATE", "T_VIRTUAL", "T_CONST", 00663 "T_INLINE", "T_FRIEND", "T_RETURN", "T_SIGNAL", "T_SLOT", "T_TYPEDEF", 00664 "T_PLUS", "T_MINUS", "T_COMMA", "T_ASTERISK", "T_TILDE", "T_LESS", 00665 "T_GREATER", "T_AMPERSAND", "T_EXTERN", "T_EXTERN_C", "T_ACCESS", 00666 "T_ENUM", "T_NAMESPACE", "T_USING", "T_UNKNOWN", "T_TRIPLE_DOT", 00667 "T_TRUE", "T_FALSE", "T_STATIC", "T_MUTABLE", "T_EQUAL", "T_SCOPE", 00668 "T_NULL", "T_INT", "T_ARRAY_OPEN", "T_ARRAY_CLOSE", "T_CHAR", "T_DCOP", 00669 "T_DCOP_AREA", "T_DCOP_SIGNAL_AREA", "T_SIGNED", "T_UNSIGNED", "T_LONG", 00670 "T_SHORT", "T_FUNOPERATOR", "T_MISCOPERATOR", "T_SHIFT", "$accept", 00671 "main", "includes", "dcoptag", "declaration", "$@1", "member_list", 00672 "bool_value", "nodcop_area", "sigslot", "nodcop_area_begin", 00673 "dcop_area_begin", "dcop_signal_area_begin", "Identifier", 00674 "super_class_name", "super_class", "super_classes", "class_header", 00675 "opt_semicolon", "body", "enum", "enum_list", "enum_item", "number", 00676 "int_expression", "typedef", "const_qualifier", "int_type", "asterisks", 00677 "params", "type_name", "templ_type_list", "templ_type", "type", 00678 "type_list", "param", "default", "value", "virtual_qualifier", 00679 "operator", "function_header", "values", "init_item", "init_list", 00680 "function", "function_begin", "function_body", "function_lines", 00681 "function_line", "Identifier_list_rest", "Identifier_list_entry", 00682 "Identifier_list", "member", 0 00683 }; 00684 #endif 00685 00686 # ifdef YYPRINT 00687 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 00688 token YYLEX-NUM. */ 00689 static const yytype_uint16 yytoknum[] = 00690 { 00691 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 00692 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 00693 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 00694 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 00695 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 00696 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 00697 315, 316, 317, 318, 319, 320, 321 00698 }; 00699 # endif 00700 00701 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 00702 static const yytype_uint8 yyr1[] = 00703 { 00704 0, 67, 68, 68, 69, 69, 69, 70, 70, 71, 00705 71, 71, 71, 71, 72, 71, 71, 71, 71, 71, 00706 71, 71, 71, 71, 71, 71, 73, 73, 74, 74, 00707 75, 75, 75, 76, 76, 76, 77, 77, 78, 79, 00708 80, 80, 81, 81, 82, 82, 83, 83, 84, 84, 00709 85, 85, 86, 86, 86, 86, 86, 86, 86, 86, 00710 86, 86, 86, 86, 86, 86, 86, 86, 86, 87, 00711 87, 87, 87, 88, 88, 89, 89, 90, 90, 90, 00712 90, 90, 91, 91, 91, 92, 92, 93, 93, 94, 00713 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 00714 94, 94, 94, 94, 94, 94, 94, 94, 94, 95, 00715 95, 96, 96, 96, 97, 97, 97, 97, 97, 97, 00716 98, 98, 99, 99, 100, 100, 100, 100, 100, 100, 00717 100, 100, 101, 101, 102, 102, 102, 103, 103, 103, 00718 104, 104, 104, 104, 104, 105, 105, 106, 106, 106, 00719 106, 106, 107, 107, 108, 108, 108, 109, 110, 110, 00720 111, 111, 111, 111, 111, 111, 111, 112, 113, 113, 00721 113, 114, 114, 115, 116, 116, 117, 117, 117, 118, 00722 119, 119, 119, 119, 119, 119 00723 }; 00724 00725 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 00726 static const yytype_uint8 yyr2[] = 00727 { 00728 0, 2, 3, 0, 2, 4, 0, 1, 0, 6, 00729 7, 3, 3, 5, 0, 7, 4, 5, 2, 4, 00730 7, 8, 2, 1, 1, 1, 2, 0, 1, 1, 00731 1, 1, 1, 1, 1, 0, 3, 2, 2, 2, 00732 1, 3, 1, 4, 3, 1, 2, 3, 2, 1, 00733 0, 1, 1, 2, 3, 2, 2, 2, 2, 2, 00734 2, 5, 4, 4, 4, 6, 4, 6, 6, 7, 00735 6, 6, 5, 3, 1, 3, 1, 1, 1, 2, 00736 1, 1, 1, 3, 3, 7, 9, 0, 1, 1, 00737 2, 1, 2, 2, 3, 2, 3, 2, 3, 2, 00738 3, 1, 1, 2, 1, 2, 1, 2, 2, 2, 00739 1, 0, 1, 3, 1, 1, 2, 2, 4, 6, 00740 3, 1, 2, 1, 3, 3, 2, 2, 3, 2, 00741 1, 2, 3, 1, 3, 2, 1, 0, 2, 5, 00742 1, 1, 1, 1, 4, 0, 1, 1, 1, 1, 00743 1, 1, 6, 7, 1, 3, 0, 4, 1, 3, 00744 2, 5, 3, 5, 7, 6, 3, 1, 1, 3, 00745 4, 2, 0, 1, 2, 0, 1, 3, 2, 2, 00746 3, 5, 5, 5, 6, 7 00747 }; 00748 00749 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 00750 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 00751 means the default is an error. */ 00752 static const yytype_uint8 yydefact[] = 00753 { 00754 6, 0, 0, 145, 6, 1, 40, 4, 0, 0, 00755 146, 0, 145, 0, 0, 0, 0, 0, 0, 0, 00756 101, 106, 89, 91, 102, 104, 6, 115, 25, 114, 00757 130, 0, 0, 0, 23, 24, 0, 0, 40, 117, 00758 116, 0, 0, 115, 0, 0, 126, 0, 22, 0, 00759 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 00760 90, 107, 95, 93, 92, 108, 99, 97, 103, 105, 00761 2, 111, 0, 127, 110, 129, 131, 40, 0, 0, 00762 0, 175, 0, 0, 167, 168, 172, 160, 5, 41, 00763 0, 49, 145, 11, 8, 12, 35, 117, 116, 0, 00764 0, 162, 125, 124, 27, 116, 0, 0, 76, 0, 00765 74, 14, 0, 0, 40, 166, 137, 96, 94, 100, 00766 98, 136, 0, 137, 112, 123, 0, 121, 128, 109, 00767 0, 0, 150, 149, 151, 147, 148, 0, 111, 0, 00768 178, 0, 179, 180, 0, 173, 0, 172, 8, 146, 00769 42, 45, 0, 48, 0, 7, 35, 0, 0, 52, 00770 32, 31, 30, 145, 0, 33, 34, 0, 0, 0, 00771 0, 35, 0, 35, 35, 35, 0, 35, 35, 35, 00772 35, 0, 0, 0, 0, 27, 27, 19, 0, 0, 00773 0, 0, 6, 0, 16, 0, 0, 0, 0, 0, 00774 0, 137, 135, 122, 118, 0, 77, 142, 78, 140, 00775 0, 28, 29, 80, 143, 81, 82, 141, 177, 81, 00776 0, 111, 0, 0, 176, 174, 0, 169, 171, 35, 00777 0, 46, 145, 0, 0, 117, 116, 35, 0, 115, 00778 0, 0, 0, 38, 39, 0, 37, 59, 58, 56, 00779 13, 57, 53, 55, 60, 161, 0, 0, 0, 26, 00780 0, 0, 75, 0, 72, 73, 0, 17, 0, 138, 00781 0, 182, 183, 0, 163, 113, 134, 0, 120, 79, 00782 111, 0, 0, 0, 0, 87, 181, 0, 170, 0, 00783 133, 0, 47, 44, 9, 35, 35, 35, 35, 54, 00784 117, 35, 35, 0, 0, 36, 137, 0, 0, 0, 00785 70, 71, 50, 0, 0, 0, 158, 0, 119, 0, 00786 83, 84, 184, 87, 88, 152, 165, 10, 0, 43, 00787 64, 0, 66, 0, 35, 62, 63, 0, 0, 20, 00788 0, 69, 51, 15, 0, 185, 156, 0, 164, 144, 00789 153, 132, 35, 35, 61, 0, 35, 21, 139, 154, 00790 0, 159, 65, 67, 0, 0, 68, 156, 157, 0, 00791 85, 155, 0, 86 00792 }; 00793 00794 /* YYDEFGOTO[NTERM-NUM]. */ 00795 static const yytype_int16 yydefgoto[] = 00796 { 00797 -1, 2, 3, 156, 26, 192, 183, 214, 171, 172, 00798 173, 174, 175, 27, 151, 152, 153, 94, 343, 176, 00799 177, 109, 110, 216, 217, 178, 325, 29, 80, 122, 00800 30, 126, 127, 31, 291, 124, 197, 359, 32, 137, 00801 33, 360, 316, 317, 179, 86, 87, 146, 147, 142, 00802 81, 82, 180 00803 }; 00804 00805 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 00806 STATE-NUM. */ 00807 #define YYPACT_NINF -191 00808 static const yytype_int16 yypact[] = 00809 { 00810 28, 78, 99, 342, 80, -191, 67, -191, 115, 159, 00811 205, 81, 386, 463, 153, 44, 190, 32, 205, 205, 00812 -191, -191, 181, 287, 154, 161, 47, 66, -191, -191, 00813 138, 19, 185, 143, -191, -191, 207, 159, 21, 183, 00814 219, 159, 159, 194, 16, 31, 152, 205, -191, 91, 00815 159, -191, 228, 236, 233, 202, 264, 18, 143, 272, 00816 -191, -191, 231, 232, -191, -191, 246, 248, -191, -191, 00817 -191, 445, 81, 249, 256, -191, -191, 85, 182, 42, 00818 296, 273, 290, 159, -191, -191, 291, -191, -191, -191, 00819 196, -191, 146, -191, 262, -191, 269, -191, -191, 300, 00820 252, -191, -191, -191, 404, 311, 307, 236, 276, 319, 00821 302, -191, 329, 320, 60, -191, 289, -191, -191, -191, 00822 -191, -191, 114, 39, -191, 256, 305, 310, -191, -191, 00823 507, 101, -191, -191, -191, -191, -191, 332, 445, 339, 00824 -191, 62, -191, -191, 341, -191, 343, 291, 262, -191, 00825 321, -191, 34, -191, 337, -191, 269, 159, 159, -191, 00826 -191, -191, -191, 386, 474, -191, -191, 159, 352, 344, 00827 346, 211, 347, 269, 269, 269, 350, 269, 269, 269, 00828 269, 143, 205, 354, 87, 404, 404, -191, 356, 101, 00829 156, 236, 80, 359, -191, 120, 101, 360, 364, 247, 00830 445, 289, -191, -191, 331, 81, -191, -191, -191, -191, 00831 379, -191, -191, -191, -191, 374, 40, -191, -191, -191, 00832 333, 445, 116, 372, 349, -191, 378, 377, -191, 269, 00833 205, -191, 146, 159, 383, 265, 299, 269, 159, 27, 00834 384, 371, 361, -191, -191, 391, -191, -191, -191, -191, 00835 -191, -191, -191, -191, -191, -191, 407, 159, 400, -191, 00836 403, 176, -191, 401, -191, -191, 405, -191, 205, -191, 00837 365, -191, -191, 415, -191, -191, -191, 159, -191, -191, 00838 445, 101, 101, 406, 132, 399, -191, 143, -191, 408, 00839 392, 390, -191, -191, -191, 269, 269, 269, 269, -191, 00840 411, 269, 269, 205, 425, -191, 144, 418, 159, 419, 00841 -191, -191, 420, 417, 421, 427, 409, 143, -191, 148, 00842 -191, -191, -191, 399, -191, -191, -191, -191, 205, -191, 00843 -191, 426, -191, 428, 269, -191, -191, 414, 437, -191, 00844 441, -191, -191, -191, 507, -191, 507, 415, -191, -191, 00845 -191, -191, 269, 269, -191, 25, 269, -191, -191, 412, 00846 444, -191, -191, -191, 455, 446, -191, 507, -191, 159, 00847 -191, -191, 453, -191 00848 }; 00849 00850 /* YYPGOTO[NTERM-NUM]. */ 00851 static const yytype_int16 yypgoto[] = 00852 { 00853 -191, 9, -191, 314, -191, -191, -2, -191, -191, 301, 00854 -191, -191, -191, -8, 238, -191, 243, -33, -191, 77, 00855 473, -91, -191, -72, -111, -191, 155, -191, -9, -123, 00856 1, 274, -191, 41, -190, 277, -97, -124, -78, -191, 00857 22, 121, -191, 134, 6, -191, -41, 335, -191, -191, 00858 -191, 348, 5 00859 }; 00860 00861 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 00862 positive, shift that token. If negative, reduce the rule which 00863 number is the opposite. If zero, do what YYDEFACT says. 00864 If YYTABLE_NINF, syntax error. */ 00865 #define YYTABLE_NINF -177 00866 static const yytype_int16 yytable[] = 00867 { 00868 39, 40, 43, 43, 101, 43, 218, 96, 35, 34, 00869 43, 43, 46, 36, 154, 222, 188, 115, 48, 198, 00870 220, 76, 6, 79, 114, 77, 202, 6, -3, 89, 00871 90, 6, 45, 97, 98, 70, 99, 103, 55, 43, 00872 58, 105, 106, 84, 301, 6, 231, -3, 85, 99, 00873 52, 44, 74, 44, 50, 138, 53, 148, 139, 57, 00874 59, -3, 72, 43, 43, 129, 232, 1, 224, 58, 00875 281, 269, 37, 125, 56, 144, 364, -137, 262, 71, 00876 78, 100, 78, 78, 150, 270, 1, 6, 44, 195, 00877 4, 41, 42, 77, -3, 74, 43, 6, 284, 5, 00878 265, 72, -176, 104, 276, 206, 282, 6, 208, 185, 00879 195, 37, 123, 337, 196, 201, 203, -176, 37, 1, 00880 74, 38, 215, 219, 206, 207, 6, 208, 209, 199, 00881 43, 285, 210, 268, 20, 130, 37, 21, 351, 131, 00882 255, 22, 23, 24, 25, 184, 200, 323, 200, 235, 00883 236, 210, 6, 213, 154, 84, 239, 319, 274, 241, 00884 85, 73, 263, 349, 200, 6, 211, 212, 149, 237, 00885 51, 74, 213, 264, 43, 75, 258, 43, 43, 123, 00886 200, 219, 309, 259, 260, 74, 240, 215, 219, 102, 00887 185, 185, 43, 310, 195, 91, 54, 43, 196, 92, 00888 93, 266, 296, 298, 44, 44, 125, 68, 91, 320, 00889 321, 6, 92, 43, 69, 41, 42, 132, 133, 83, 00890 358, 88, 43, 256, 150, 150, 184, 184, 11, 72, 00891 300, 91, 134, 234, 60, 92, 95, 61, 165, 166, 00892 107, 123, 108, 62, 63, 111, 326, 135, 136, 307, 00893 247, 248, 249, 112, 251, 252, 253, 254, 20, 84, 00894 43, 21, 123, 273, 85, 22, 23, 24, 25, 318, 00895 113, 290, 43, 219, 219, 6, 348, 91, 116, 157, 00896 158, 92, 295, 159, 117, 118, 128, 160, 161, 74, 00897 162, 10, 11, 163, 164, 43, 165, 166, 167, 119, 00898 340, 120, 140, -145, 181, 141, 289, 143, 145, 313, 00899 15, 91, 168, 138, 299, 92, 297, 18, 19, 155, 00900 43, 123, 20, 186, 187, 21, 189, 169, 170, 22, 00901 23, 24, 25, 190, 191, 193, 215, 194, 215, 195, 00902 64, 204, 205, 65, 290, 221, 223, 365, 6, 66, 00903 67, 7, 8, 9, 226, 233, 230, 227, 242, 215, 00904 243, 372, 244, 246, 10, 11, 12, 250, 257, 290, 00905 261, 13, 330, 331, 332, 333, 267, 271, 335, 336, 00906 14, 272, 277, 15, 16, 17, 279, 280, 283, 286, 00907 18, 19, 6, 287, 288, 20, 41, 42, 21, 130, 00908 294, 302, 22, 23, 24, 25, 303, 305, 10, 11, 00909 6, 354, 304, 306, 41, 42, 139, 308, 311, 312, 00910 314, 315, 324, 322, 328, 327, 329, 11, 334, 362, 00911 363, 338, 344, 366, 47, 339, 341, 342, 345, 20, 00912 346, 347, 21, 352, 367, 353, 22, 23, 24, 25, 00913 355, 6, 182, 19, 356, 41, 42, 20, 357, 368, 00914 21, 369, 229, 370, 22, 23, 24, 25, 11, 6, 00915 373, 293, 245, 41, 49, 292, 28, 275, 350, 278, 00916 6, 361, 228, 0, 238, 42, 11, 0, 371, 225, 00917 121, 0, 0, 0, 0, 0, 0, 11, 20, 0, 00918 0, 21, 0, 0, 0, 22, 23, 24, 25, 0, 00919 0, 206, 207, 6, 208, 209, 20, 0, 0, 21, 00920 0, 0, 0, 22, 23, 24, 25, 20, 0, 0, 00921 21, 0, 0, 0, 22, 23, 24, 25, 210, 0, 00922 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00923 0, 0, 0, 211, 212, 0, 0, 0, 0, 213 00924 }; 00925 00926 static const yytype_int16 yycheck[] = 00927 { 00928 8, 9, 10, 11, 45, 13, 130, 40, 3, 3, 00929 18, 19, 11, 4, 92, 138, 107, 58, 12, 116, 00930 131, 30, 6, 31, 6, 6, 123, 6, 0, 37, 00931 38, 6, 10, 41, 42, 26, 44, 46, 6, 47, 00932 18, 49, 50, 12, 17, 6, 12, 0, 17, 57, 00933 6, 10, 33, 12, 13, 13, 12, 90, 16, 18, 00934 19, 14, 35, 71, 72, 74, 32, 39, 6, 47, 00935 30, 195, 51, 72, 42, 83, 51, 17, 189, 13, 00936 64, 50, 64, 64, 92, 196, 39, 6, 47, 50, 00937 12, 10, 11, 6, 14, 33, 104, 6, 221, 0, 00938 191, 35, 17, 12, 201, 4, 66, 6, 7, 104, 00939 50, 51, 71, 303, 54, 123, 125, 32, 51, 39, 00940 33, 6, 130, 131, 4, 5, 6, 7, 8, 15, 00941 138, 15, 31, 13, 53, 50, 51, 56, 328, 54, 00942 181, 60, 61, 62, 63, 104, 32, 15, 32, 157, 00943 158, 31, 6, 52, 232, 12, 164, 280, 199, 167, 00944 17, 23, 6, 15, 32, 6, 46, 47, 22, 163, 00945 17, 33, 52, 17, 182, 37, 184, 185, 186, 138, 00946 32, 189, 6, 185, 186, 33, 164, 195, 196, 37, 00947 185, 186, 200, 17, 50, 12, 6, 205, 54, 16, 00948 17, 192, 235, 236, 163, 164, 205, 53, 12, 281, 00949 282, 6, 16, 221, 53, 10, 11, 35, 36, 34, 00950 344, 14, 230, 182, 232, 233, 185, 186, 23, 35, 00951 238, 12, 50, 156, 53, 16, 17, 56, 27, 28, 00952 12, 200, 6, 62, 63, 12, 287, 65, 66, 257, 00953 173, 174, 175, 51, 177, 178, 179, 180, 53, 12, 00954 268, 56, 221, 16, 17, 60, 61, 62, 63, 277, 00955 6, 230, 280, 281, 282, 6, 317, 12, 6, 10, 00956 11, 16, 17, 14, 53, 53, 37, 18, 19, 33, 00957 21, 22, 23, 24, 25, 303, 27, 28, 29, 53, 00958 308, 53, 6, 34, 52, 32, 229, 17, 17, 268, 00959 41, 12, 43, 13, 237, 16, 17, 48, 49, 57, 00960 328, 280, 53, 12, 17, 56, 50, 58, 59, 60, 00961 61, 62, 63, 14, 32, 6, 344, 17, 346, 50, 00962 53, 36, 32, 56, 303, 13, 7, 355, 6, 62, 00963 63, 9, 10, 11, 13, 18, 35, 14, 6, 367, 00964 16, 369, 16, 16, 22, 23, 24, 17, 14, 328, 00965 14, 29, 295, 296, 297, 298, 17, 17, 301, 302, 00966 38, 17, 51, 41, 42, 43, 7, 13, 55, 17, 00967 48, 49, 6, 15, 17, 53, 10, 11, 56, 50, 00968 17, 17, 60, 61, 62, 63, 35, 16, 22, 23, 00969 6, 334, 51, 6, 10, 11, 16, 14, 17, 14, 00970 55, 6, 23, 17, 32, 17, 36, 23, 17, 352, 00971 353, 6, 15, 356, 48, 17, 17, 17, 17, 53, 00972 13, 32, 56, 17, 32, 17, 60, 61, 62, 63, 00973 36, 6, 48, 49, 17, 10, 11, 53, 17, 15, 00974 56, 6, 148, 17, 60, 61, 62, 63, 23, 6, 00975 17, 233, 171, 10, 11, 232, 3, 200, 323, 205, 00976 6, 347, 147, -1, 10, 11, 23, -1, 367, 141, 00977 45, -1, -1, -1, -1, -1, -1, 23, 53, -1, 00978 -1, 56, -1, -1, -1, 60, 61, 62, 63, -1, 00979 -1, 4, 5, 6, 7, 8, 53, -1, -1, 56, 00980 -1, -1, -1, 60, 61, 62, 63, 53, -1, -1, 00981 56, -1, -1, -1, 60, 61, 62, 63, 31, -1, 00982 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 00983 -1, -1, -1, 46, 47, -1, -1, -1, -1, 52 00984 }; 00985 00986 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 00987 symbol of state STATE-NUM. */ 00988 static const yytype_uint8 yystos[] = 00989 { 00990 0, 39, 68, 69, 12, 0, 6, 9, 10, 11, 00991 22, 23, 24, 29, 38, 41, 42, 43, 48, 49, 00992 53, 56, 60, 61, 62, 63, 71, 80, 87, 94, 00993 97, 100, 105, 107, 111, 119, 68, 51, 6, 80, 00994 80, 10, 11, 80, 100, 107, 97, 48, 111, 11, 00995 100, 17, 6, 12, 6, 6, 42, 100, 107, 100, 00996 53, 56, 62, 63, 53, 56, 62, 63, 53, 53, 00997 68, 13, 35, 23, 33, 37, 95, 6, 64, 80, 00998 95, 117, 118, 34, 12, 17, 112, 113, 14, 80, 00999 80, 12, 16, 17, 84, 17, 84, 80, 80, 80, 01000 50, 113, 37, 95, 12, 80, 80, 12, 6, 88, 01001 89, 12, 51, 6, 6, 113, 6, 53, 53, 53, 01002 53, 45, 96, 100, 102, 97, 98, 99, 37, 95, 01003 50, 54, 35, 36, 50, 65, 66, 106, 13, 16, 01004 6, 32, 116, 17, 80, 17, 114, 115, 84, 22, 01005 80, 81, 82, 83, 105, 57, 70, 10, 11, 14, 01006 18, 19, 21, 24, 25, 27, 28, 29, 43, 58, 01007 59, 75, 76, 77, 78, 79, 86, 87, 92, 111, 01008 119, 52, 48, 73, 100, 119, 12, 17, 88, 50, 01009 14, 32, 72, 6, 17, 50, 54, 103, 103, 15, 01010 32, 80, 103, 95, 36, 32, 4, 5, 7, 8, 01011 31, 46, 47, 52, 74, 80, 90, 91, 104, 80, 01012 91, 13, 96, 7, 6, 118, 13, 14, 114, 70, 01013 35, 12, 32, 18, 86, 80, 80, 111, 10, 80, 01014 107, 80, 6, 16, 16, 76, 16, 86, 86, 86, 01015 17, 86, 86, 86, 86, 113, 100, 14, 80, 73, 01016 73, 14, 91, 6, 17, 88, 68, 17, 13, 104, 01017 91, 17, 17, 16, 113, 102, 103, 51, 98, 7, 01018 13, 30, 66, 55, 96, 15, 17, 15, 17, 86, 01019 100, 101, 83, 81, 17, 17, 84, 17, 84, 86, 01020 80, 17, 17, 35, 51, 16, 6, 80, 14, 6, 01021 17, 17, 14, 100, 55, 6, 109, 110, 80, 96, 01022 90, 90, 17, 15, 23, 93, 113, 17, 32, 36, 01023 86, 86, 86, 86, 17, 86, 86, 101, 6, 17, 01024 80, 17, 17, 85, 15, 17, 13, 32, 113, 15, 01025 93, 101, 17, 17, 86, 36, 17, 17, 104, 104, 01026 108, 110, 86, 86, 51, 80, 86, 32, 15, 6, 01027 17, 108, 80, 17 01028 }; 01029 01030 #define yyerrok (yyerrstatus = 0) 01031 #define yyclearin (yychar = YYEMPTY) 01032 #define YYEMPTY (-2) 01033 #define YYEOF 0 01034 01035 #define YYACCEPT goto yyacceptlab 01036 #define YYABORT goto yyabortlab 01037 #define YYERROR goto yyerrorlab 01038 01039 01040 /* Like YYERROR except do call yyerror. This remains here temporarily 01041 to ease the transition to the new meaning of YYERROR, for GCC. 01042 Once GCC version 2 has supplanted version 1, this can go. */ 01043 01044 #define YYFAIL goto yyerrlab 01045 01046 #define YYRECOVERING() (!!yyerrstatus) 01047 01048 #define YYBACKUP(Token, Value) \ 01049 do \ 01050 if (yychar == YYEMPTY && yylen == 1) \ 01051 { \ 01052 yychar = (Token); \ 01053 yylval = (Value); \ 01054 yytoken = YYTRANSLATE (yychar); \ 01055 YYPOPSTACK (1); \ 01056 goto yybackup; \ 01057 } \ 01058 else \ 01059 { \ 01060 yyerror (YY_("syntax error: cannot back up")); \ 01061 YYERROR; \ 01062 } \ 01063 while (YYID (0)) 01064 01065 01066 #define YYTERROR 1 01067 #define YYERRCODE 256 01068 01069 01070 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 01071 If N is 0, then set CURRENT to the empty location which ends 01072 the previous symbol: RHS[0] (always defined). */ 01073 01074 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 01075 #ifndef YYLLOC_DEFAULT 01076 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 01077 do \ 01078 if (YYID (N)) \ 01079 { \ 01080 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 01081 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 01082 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 01083 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 01084 } \ 01085 else \ 01086 { \ 01087 (Current).first_line = (Current).last_line = \ 01088 YYRHSLOC (Rhs, 0).last_line; \ 01089 (Current).first_column = (Current).last_column = \ 01090 YYRHSLOC (Rhs, 0).last_column; \ 01091 } \ 01092 while (YYID (0)) 01093 #endif 01094 01095 01096 /* YY_LOCATION_PRINT -- Print the location on the stream. 01097 This macro was not mandated originally: define only if we know 01098 we won't break user code: when these are the locations we know. */ 01099 01100 #ifndef YY_LOCATION_PRINT 01101 # if YYLTYPE_IS_TRIVIAL 01102 # define YY_LOCATION_PRINT(File, Loc) \ 01103 fprintf (File, "%d.%d-%d.%d", \ 01104 (Loc).first_line, (Loc).first_column, \ 01105 (Loc).last_line, (Loc).last_column) 01106 # else 01107 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 01108 # endif 01109 #endif 01110 01111 01112 /* YYLEX -- calling `yylex' with the right arguments. */ 01113 01114 #ifdef YYLEX_PARAM 01115 # define YYLEX yylex (YYLEX_PARAM) 01116 #else 01117 # define YYLEX yylex () 01118 #endif 01119 01120 /* Enable debugging if requested. */ 01121 #if YYDEBUG 01122 01123 # ifndef YYFPRINTF 01124 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 01125 # define YYFPRINTF fprintf 01126 # endif 01127 01128 # define YYDPRINTF(Args) \ 01129 do { \ 01130 if (yydebug) \ 01131 YYFPRINTF Args; \ 01132 } while (YYID (0)) 01133 01134 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 01135 do { \ 01136 if (yydebug) \ 01137 { \ 01138 YYFPRINTF (stderr, "%s ", Title); \ 01139 yy_symbol_print (stderr, \ 01140 Type, Value); \ 01141 YYFPRINTF (stderr, "\n"); \ 01142 } \ 01143 } while (YYID (0)) 01144 01145 01146 /*--------------------------------. 01147 | Print this symbol on YYOUTPUT. | 01148 `--------------------------------*/ 01149 01150 /*ARGSUSED*/ 01151 #if (defined __STDC__ || defined __C99__FUNC__ \ 01152 || defined __cplusplus || defined _MSC_VER) 01153 static void 01154 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 01155 #else 01156 static void 01157 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 01158 FILE *yyoutput; 01159 int yytype; 01160 YYSTYPE const * const yyvaluep; 01161 #endif 01162 { 01163 if (!yyvaluep) 01164 return; 01165 # ifdef YYPRINT 01166 if (yytype < YYNTOKENS) 01167 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 01168 # else 01169 YYUSE (yyoutput); 01170 # endif 01171 switch (yytype) 01172 { 01173 default: 01174 break; 01175 } 01176 } 01177 01178 01179 /*--------------------------------. 01180 | Print this symbol on YYOUTPUT. | 01181 `--------------------------------*/ 01182 01183 #if (defined __STDC__ || defined __C99__FUNC__ \ 01184 || defined __cplusplus || defined _MSC_VER) 01185 static void 01186 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 01187 #else 01188 static void 01189 yy_symbol_print (yyoutput, yytype, yyvaluep) 01190 FILE *yyoutput; 01191 int yytype; 01192 YYSTYPE const * const yyvaluep; 01193 #endif 01194 { 01195 if (yytype < YYNTOKENS) 01196 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 01197 else 01198 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 01199 01200 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 01201 YYFPRINTF (yyoutput, ")"); 01202 } 01203 01204 /*------------------------------------------------------------------. 01205 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 01206 | TOP (included). | 01207 `------------------------------------------------------------------*/ 01208 01209 #if (defined __STDC__ || defined __C99__FUNC__ \ 01210 || defined __cplusplus || defined _MSC_VER) 01211 static void 01212 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 01213 #else 01214 static void 01215 yy_stack_print (yybottom, yytop) 01216 yytype_int16 *yybottom; 01217 yytype_int16 *yytop; 01218 #endif 01219 { 01220 YYFPRINTF (stderr, "Stack now"); 01221 for (; yybottom <= yytop; yybottom++) 01222 { 01223 int yybot = *yybottom; 01224 YYFPRINTF (stderr, " %d", yybot); 01225 } 01226 YYFPRINTF (stderr, "\n"); 01227 } 01228 01229 # define YY_STACK_PRINT(Bottom, Top) \ 01230 do { \ 01231 if (yydebug) \ 01232 yy_stack_print ((Bottom), (Top)); \ 01233 } while (YYID (0)) 01234 01235 01236 /*------------------------------------------------. 01237 | Report that the YYRULE is going to be reduced. | 01238 `------------------------------------------------*/ 01239 01240 #if (defined __STDC__ || defined __C99__FUNC__ \ 01241 || defined __cplusplus || defined _MSC_VER) 01242 static void 01243 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 01244 #else 01245 static void 01246 yy_reduce_print (yyvsp, yyrule) 01247 YYSTYPE *yyvsp; 01248 int yyrule; 01249 #endif 01250 { 01251 int yynrhs = yyr2[yyrule]; 01252 int yyi; 01253 unsigned long int yylno = yyrline[yyrule]; 01254 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 01255 yyrule - 1, yylno); 01256 /* The symbols being reduced. */ 01257 for (yyi = 0; yyi < yynrhs; yyi++) 01258 { 01259 YYFPRINTF (stderr, " $%d = ", yyi + 1); 01260 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 01261 &(yyvsp[(yyi + 1) - (yynrhs)]) 01262 ); 01263 YYFPRINTF (stderr, "\n"); 01264 } 01265 } 01266 01267 # define YY_REDUCE_PRINT(Rule) \ 01268 do { \ 01269 if (yydebug) \ 01270 yy_reduce_print (yyvsp, Rule); \ 01271 } while (YYID (0)) 01272 01273 /* Nonzero means print parse trace. It is left uninitialized so that 01274 multiple parsers can coexist. */ 01275 int yydebug; 01276 #else /* !YYDEBUG */ 01277 # define YYDPRINTF(Args) 01278 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 01279 # define YY_STACK_PRINT(Bottom, Top) 01280 # define YY_REDUCE_PRINT(Rule) 01281 #endif /* !YYDEBUG */ 01282 01283 01284 /* YYINITDEPTH -- initial size of the parser's stacks. */ 01285 #ifndef YYINITDEPTH 01286 # define YYINITDEPTH 200 01287 #endif 01288 01289 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 01290 if the built-in stack extension method is used). 01291 01292 Do not make this value too large; the results are undefined if 01293 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 01294 evaluated with infinite-precision integer arithmetic. */ 01295 01296 #ifndef YYMAXDEPTH 01297 # define YYMAXDEPTH 10000 01298 #endif 01299 01300 01301 01302 #if YYERROR_VERBOSE 01303 01304 # ifndef yystrlen 01305 # if defined __GLIBC__ && defined _STRING_H 01306 # define yystrlen strlen 01307 # else 01308 /* Return the length of YYSTR. */ 01309 #if (defined __STDC__ || defined __C99__FUNC__ \ 01310 || defined __cplusplus || defined _MSC_VER) 01311 static YYSIZE_T 01312 yystrlen (const char *yystr) 01313 #else 01314 static YYSIZE_T 01315 yystrlen (yystr) 01316 const char *yystr; 01317 #endif 01318 { 01319 YYSIZE_T yylen; 01320 for (yylen = 0; yystr[yylen]; yylen++) 01321 continue; 01322 return yylen; 01323 } 01324 # endif 01325 # endif 01326 01327 # ifndef yystpcpy 01328 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 01329 # define yystpcpy stpcpy 01330 # else 01331 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 01332 YYDEST. */ 01333 #if (defined __STDC__ || defined __C99__FUNC__ \ 01334 || defined __cplusplus || defined _MSC_VER) 01335 static char * 01336 yystpcpy (char *yydest, const char *yysrc) 01337 #else 01338 static char * 01339 yystpcpy (yydest, yysrc) 01340 char *yydest; 01341 const char *yysrc; 01342 #endif 01343 { 01344 char *yyd = yydest; 01345 const char *yys = yysrc; 01346 01347 while ((*yyd++ = *yys++) != '\0') 01348 continue; 01349 01350 return yyd - 1; 01351 } 01352 # endif 01353 # endif 01354 01355 # ifndef yytnamerr 01356 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 01357 quotes and backslashes, so that it's suitable for yyerror. The 01358 heuristic is that double-quoting is unnecessary unless the string 01359 contains an apostrophe, a comma, or backslash (other than 01360 backslash-backslash). YYSTR is taken from yytname. If YYRES is 01361 null, do not copy; instead, return the length of what the result 01362 would have been. */ 01363 static YYSIZE_T 01364 yytnamerr (char *yyres, const char *yystr) 01365 { 01366 if (*yystr == '"') 01367 { 01368 YYSIZE_T yyn = 0; 01369 char const *yyp = yystr; 01370 01371 for (;;) 01372 switch (*++yyp) 01373 { 01374 case '\'': 01375 case ',': 01376 goto do_not_strip_quotes; 01377 01378 case '\\': 01379 if (*++yyp != '\\') 01380 goto do_not_strip_quotes; 01381 /* Fall through. */ 01382 default: 01383 if (yyres) 01384 yyres[yyn] = *yyp; 01385 yyn++; 01386 break; 01387 01388 case '"': 01389 if (yyres) 01390 yyres[yyn] = '\0'; 01391 return yyn; 01392 } 01393 do_not_strip_quotes: ; 01394 } 01395 01396 if (! yyres) 01397 return yystrlen (yystr); 01398 01399 return yystpcpy (yyres, yystr) - yyres; 01400 } 01401 # endif 01402 01403 /* Copy into YYRESULT an error message about the unexpected token 01404 YYCHAR while in state YYSTATE. Return the number of bytes copied, 01405 including the terminating null byte. If YYRESULT is null, do not 01406 copy anything; just return the number of bytes that would be 01407 copied. As a special case, return 0 if an ordinary "syntax error" 01408 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 01409 size calculation. */ 01410 static YYSIZE_T 01411 yysyntax_error (char *yyresult, int yystate, int yychar) 01412 { 01413 int yyn = yypact[yystate]; 01414 01415 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 01416 return 0; 01417 else 01418 { 01419 int yytype = YYTRANSLATE (yychar); 01420 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 01421 YYSIZE_T yysize = yysize0; 01422 YYSIZE_T yysize1; 01423 int yysize_overflow = 0; 01424 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 01425 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 01426 int yyx; 01427 01428 # if 0 01429 /* This is so xgettext sees the translatable formats that are 01430 constructed on the fly. */ 01431 YY_("syntax error, unexpected %s"); 01432 YY_("syntax error, unexpected %s, expecting %s"); 01433 YY_("syntax error, unexpected %s, expecting %s or %s"); 01434 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 01435 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 01436 # endif 01437 char *yyfmt; 01438 char const *yyf; 01439 static char const yyunexpected[] = "syntax error, unexpected %s"; 01440 static char const yyexpecting[] = ", expecting %s"; 01441 static char const yyor[] = " or %s"; 01442 char yyformat[sizeof yyunexpected 01443 + sizeof yyexpecting - 1 01444 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 01445 * (sizeof yyor - 1))]; 01446 char const *yyprefix = yyexpecting; 01447 01448 /* Start YYX at -YYN if negative to avoid negative indexes in 01449 YYCHECK. */ 01450 int yyxbegin = yyn < 0 ? -yyn : 0; 01451 01452 /* Stay within bounds of both yycheck and yytname. */ 01453 int yychecklim = YYLAST - yyn + 1; 01454 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 01455 int yycount = 1; 01456 01457 yyarg[0] = yytname[yytype]; 01458 yyfmt = yystpcpy (yyformat, yyunexpected); 01459 01460 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 01461 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 01462 { 01463 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 01464 { 01465 yycount = 1; 01466 yysize = yysize0; 01467 yyformat[sizeof yyunexpected - 1] = '\0'; 01468 break; 01469 } 01470 yyarg[yycount++] = yytname[yyx]; 01471 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 01472 yysize_overflow |= (yysize1 < yysize); 01473 yysize = yysize1; 01474 yyfmt = yystpcpy (yyfmt, yyprefix); 01475 yyprefix = yyor; 01476 } 01477 01478 yyf = YY_(yyformat); 01479 yysize1 = yysize + yystrlen (yyf); 01480 yysize_overflow |= (yysize1 < yysize); 01481 yysize = yysize1; 01482 01483 if (yysize_overflow) 01484 return YYSIZE_MAXIMUM; 01485 01486 if (yyresult) 01487 { 01488 /* Avoid sprintf, as that infringes on the user's name space. 01489 Don't have undefined behavior even if the translation 01490 produced a string with the wrong number of "%s"s. */ 01491 char *yyp = yyresult; 01492 int yyi = 0; 01493 while ((*yyp = *yyf) != '\0') 01494 { 01495 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 01496 { 01497 yyp += yytnamerr (yyp, yyarg[yyi++]); 01498 yyf += 2; 01499 } 01500 else 01501 { 01502 yyp++; 01503 yyf++; 01504 } 01505 } 01506 } 01507 return yysize; 01508 } 01509 } 01510 #endif /* YYERROR_VERBOSE */ 01511 01512 01513 /*-----------------------------------------------. 01514 | Release the memory associated to this symbol. | 01515 `-----------------------------------------------*/ 01516 01517 /*ARGSUSED*/ 01518 #if (defined __STDC__ || defined __C99__FUNC__ \ 01519 || defined __cplusplus || defined _MSC_VER) 01520 static void 01521 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 01522 #else 01523 static void 01524 yydestruct (yymsg, yytype, yyvaluep) 01525 const char *yymsg; 01526 int yytype; 01527 YYSTYPE *yyvaluep; 01528 #endif 01529 { 01530 YYUSE (yyvaluep); 01531 01532 if (!yymsg) 01533 yymsg = "Deleting"; 01534 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 01535 01536 switch (yytype) 01537 { 01538 01539 default: 01540 break; 01541 } 01542 } 01543 01544 /* Prevent warnings from -Wmissing-prototypes. */ 01545 #ifdef YYPARSE_PARAM 01546 #if defined __STDC__ || defined __cplusplus 01547 int yyparse (void *YYPARSE_PARAM); 01548 #else 01549 int yyparse (); 01550 #endif 01551 #else /* ! YYPARSE_PARAM */ 01552 #if defined __STDC__ || defined __cplusplus 01553 int yyparse (void); 01554 #else 01555 int yyparse (); 01556 #endif 01557 #endif /* ! YYPARSE_PARAM */ 01558 01559 01560 /* The lookahead symbol. */ 01561 int yychar; 01562 01563 /* The semantic value of the lookahead symbol. */ 01564 YYSTYPE yylval; 01565 01566 /* Number of syntax errors so far. */ 01567 int yynerrs; 01568 01569 01570 01571 /*-------------------------. 01572 | yyparse or yypush_parse. | 01573 `-------------------------*/ 01574 01575 #ifdef YYPARSE_PARAM 01576 #if (defined __STDC__ || defined __C99__FUNC__ \ 01577 || defined __cplusplus || defined _MSC_VER) 01578 int 01579 yyparse (void *YYPARSE_PARAM) 01580 #else 01581 int 01582 yyparse (YYPARSE_PARAM) 01583 void *YYPARSE_PARAM; 01584 #endif 01585 #else /* ! YYPARSE_PARAM */ 01586 #if (defined __STDC__ || defined __C99__FUNC__ \ 01587 || defined __cplusplus || defined _MSC_VER) 01588 int 01589 yyparse (void) 01590 #else 01591 int 01592 yyparse () 01593 01594 #endif 01595 #endif 01596 { 01597 01598 01599 int yystate; 01600 /* Number of tokens to shift before error messages enabled. */ 01601 int yyerrstatus; 01602 01603 /* The stacks and their tools: 01604 `yyss': related to states. 01605 `yyvs': related to semantic values. 01606 01607 Refer to the stacks thru separate pointers, to allow yyoverflow 01608 to reallocate them elsewhere. */ 01609 01610 /* The state stack. */ 01611 yytype_int16 yyssa[YYINITDEPTH]; 01612 yytype_int16 *yyss; 01613 yytype_int16 *yyssp; 01614 01615 /* The semantic value stack. */ 01616 YYSTYPE yyvsa[YYINITDEPTH]; 01617 YYSTYPE *yyvs; 01618 YYSTYPE *yyvsp; 01619 01620 YYSIZE_T yystacksize; 01621 01622 int yyn; 01623 int yyresult; 01624 /* Lookahead token as an internal (translated) token number. */ 01625 int yytoken; 01626 /* The variables used to return semantic value and location from the 01627 action routines. */ 01628 YYSTYPE yyval; 01629 01630 #if YYERROR_VERBOSE 01631 /* Buffer for error messages, and its allocated size. */ 01632 char yymsgbuf[128]; 01633 char *yymsg = yymsgbuf; 01634 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 01635 #endif 01636 01637 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 01638 01639 /* The number of symbols on the RHS of the reduced rule. 01640 Keep to zero when no symbol should be popped. */ 01641 int yylen = 0; 01642 01643 yytoken = 0; 01644 yyss = yyssa; 01645 yyvs = yyvsa; 01646 yystacksize = YYINITDEPTH; 01647 01648 YYDPRINTF ((stderr, "Starting parse\n")); 01649 01650 yystate = 0; 01651 yyerrstatus = 0; 01652 yynerrs = 0; 01653 yychar = YYEMPTY; /* Cause a token to be read. */ 01654 01655 /* Initialize stack pointers. 01656 Waste one element of value and location stack 01657 so that they stay on the same level as the state stack. 01658 The wasted elements are never initialized. */ 01659 yyssp = yyss; 01660 yyvsp = yyvs; 01661 01662 goto yysetstate; 01663 01664 /*------------------------------------------------------------. 01665 | yynewstate -- Push a new state, which is found in yystate. | 01666 `------------------------------------------------------------*/ 01667 yynewstate: 01668 /* In all cases, when you get here, the value and location stacks 01669 have just been pushed. So pushing a state here evens the stacks. */ 01670 yyssp++; 01671 01672 yysetstate: 01673 *yyssp = yystate; 01674 01675 if (yyss + yystacksize - 1 <= yyssp) 01676 { 01677 /* Get the current used size of the three stacks, in elements. */ 01678 YYSIZE_T yysize = yyssp - yyss + 1; 01679 01680 #ifdef yyoverflow 01681 { 01682 /* Give user a chance to reallocate the stack. Use copies of 01683 these so that the &'s don't force the real ones into 01684 memory. */ 01685 YYSTYPE *yyvs1 = yyvs; 01686 yytype_int16 *yyss1 = yyss; 01687 01688 /* Each stack pointer address is followed by the size of the 01689 data in use in that stack, in bytes. This used to be a 01690 conditional around just the two extra args, but that might 01691 be undefined if yyoverflow is a macro. */ 01692 yyoverflow (YY_("memory exhausted"), 01693 &yyss1, yysize * sizeof (*yyssp), 01694 &yyvs1, yysize * sizeof (*yyvsp), 01695 &yystacksize); 01696 01697 yyss = yyss1; 01698 yyvs = yyvs1; 01699 } 01700 #else /* no yyoverflow */ 01701 # ifndef YYSTACK_RELOCATE 01702 goto yyexhaustedlab; 01703 # else 01704 /* Extend the stack our own way. */ 01705 if (YYMAXDEPTH <= yystacksize) 01706 goto yyexhaustedlab; 01707 yystacksize *= 2; 01708 if (YYMAXDEPTH < yystacksize) 01709 yystacksize = YYMAXDEPTH; 01710 01711 { 01712 yytype_int16 *yyss1 = yyss; 01713 union yyalloc *yyptr = 01714 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 01715 if (! yyptr) 01716 goto yyexhaustedlab; 01717 YYSTACK_RELOCATE (yyss_alloc, yyss); 01718 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 01719 # undef YYSTACK_RELOCATE 01720 if (yyss1 != yyssa) 01721 YYSTACK_FREE (yyss1); 01722 } 01723 # endif 01724 #endif /* no yyoverflow */ 01725 01726 yyssp = yyss + yysize - 1; 01727 yyvsp = yyvs + yysize - 1; 01728 01729 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 01730 (unsigned long int) yystacksize)); 01731 01732 if (yyss + yystacksize - 1 <= yyssp) 01733 YYABORT; 01734 } 01735 01736 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 01737 01738 if (yystate == YYFINAL) 01739 YYACCEPT; 01740 01741 goto yybackup; 01742 01743 /*-----------. 01744 | yybackup. | 01745 `-----------*/ 01746 yybackup: 01747 01748 /* Do appropriate processing given the current state. Read a 01749 lookahead token if we need one and don't already have one. */ 01750 01751 /* First try to decide what to do without reference to lookahead token. */ 01752 yyn = yypact[yystate]; 01753 if (yyn == YYPACT_NINF) 01754 goto yydefault; 01755 01756 /* Not known => get a lookahead token if don't already have one. */ 01757 01758 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 01759 if (yychar == YYEMPTY) 01760 { 01761 YYDPRINTF ((stderr, "Reading a token: ")); 01762 yychar = YYLEX; 01763 } 01764 01765 if (yychar <= YYEOF) 01766 { 01767 yychar = yytoken = YYEOF; 01768 YYDPRINTF ((stderr, "Now at end of input.\n")); 01769 } 01770 else 01771 { 01772 yytoken = YYTRANSLATE (yychar); 01773 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 01774 } 01775 01776 /* If the proper action on seeing token YYTOKEN is to reduce or to 01777 detect an error, take that action. */ 01778 yyn += yytoken; 01779 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 01780 goto yydefault; 01781 yyn = yytable[yyn]; 01782 if (yyn <= 0) 01783 { 01784 if (yyn == 0 || yyn == YYTABLE_NINF) 01785 goto yyerrlab; 01786 yyn = -yyn; 01787 goto yyreduce; 01788 } 01789 01790 /* Count tokens shifted since error; after three, turn off error 01791 status. */ 01792 if (yyerrstatus) 01793 yyerrstatus--; 01794 01795 /* Shift the lookahead token. */ 01796 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 01797 01798 /* Discard the shifted token. */ 01799 yychar = YYEMPTY; 01800 01801 yystate = yyn; 01802 *++yyvsp = yylval; 01803 01804 goto yynewstate; 01805 01806 01807 /*-----------------------------------------------------------. 01808 | yydefault -- do the default action for the current state. | 01809 `-----------------------------------------------------------*/ 01810 yydefault: 01811 yyn = yydefact[yystate]; 01812 if (yyn == 0) 01813 goto yyerrlab; 01814 goto yyreduce; 01815 01816 01817 /*-----------------------------. 01818 | yyreduce -- Do a reduction. | 01819 `-----------------------------*/ 01820 yyreduce: 01821 /* yyn is the number of a rule to reduce with. */ 01822 yylen = yyr2[yyn]; 01823 01824 /* If YYLEN is nonzero, implement the default value of the action: 01825 `$$ = $1'. 01826 01827 Otherwise, the following line sets YYVAL to garbage. 01828 This behavior is undocumented and Bison 01829 users should not rely upon it. Assigning to YYVAL 01830 unconditionally makes the parser a bit smaller, and it avoids a 01831 GCC warning that YYVAL may be used uninitialized. */ 01832 yyval = yyvsp[1-yylen]; 01833 01834 01835 YY_REDUCE_PRINT (yyn); 01836 switch (yyn) 01837 { 01838 case 2: 01839 01840 /* Line 1455 of yacc.c */ 01841 #line 165 "yacc.yy" 01842 { 01843 ;} 01844 break; 01845 01846 case 4: 01847 01848 /* Line 1455 of yacc.c */ 01849 #line 172 "yacc.yy" 01850 { 01851 printf("<INCLUDE>%s</INCLUDE>\n", (yyvsp[(2) - (2)]._str)->latin1() ); 01852 ;} 01853 break; 01854 01855 case 5: 01856 01857 /* Line 1455 of yacc.c */ 01858 #line 176 "yacc.yy" 01859 { 01860 ;} 01861 break; 01862 01863 case 6: 01864 01865 /* Line 1455 of yacc.c */ 01866 #line 179 "yacc.yy" 01867 { 01868 ;} 01869 break; 01870 01871 case 7: 01872 01873 /* Line 1455 of yacc.c */ 01874 #line 184 "yacc.yy" 01875 { (yyval._int) = 1; ;} 01876 break; 01877 01878 case 8: 01879 01880 /* Line 1455 of yacc.c */ 01881 #line 185 "yacc.yy" 01882 { (yyval._int) = 0; ;} 01883 break; 01884 01885 case 9: 01886 01887 /* Line 1455 of yacc.c */ 01888 #line 190 "yacc.yy" 01889 { 01890 if ((yyvsp[(4) - (6)]._int)) 01891 printf("<CLASS>\n <NAME>%s</NAME>\n%s%s</CLASS>\n", ( in_namespace + *(yyvsp[(2) - (6)]._str) ).latin1(), (yyvsp[(3) - (6)]._str)->latin1(), (yyvsp[(5) - (6)]._str)->latin1() ); 01892 // default C++ visibility specifier is 'private' 01893 dcop_area = 0; 01894 dcop_signal_area = 0; 01895 01896 ;} 01897 break; 01898 01899 case 10: 01900 01901 /* Line 1455 of yacc.c */ 01902 #line 199 "yacc.yy" 01903 { 01904 if ((yyvsp[(5) - (7)]._int)) 01905 printf("<CLASS>\n <NAME>%s</NAME>\n <LINK_SCOPE>%s</LINK_SCOPE>\n%s%s</CLASS>\n", ( in_namespace + *(yyvsp[(3) - (7)]._str) ).latin1(),(yyvsp[(2) - (7)]._str)->latin1(), (yyvsp[(4) - (7)]._str)->latin1(), (yyvsp[(6) - (7)]._str)->latin1() ); 01906 // default C++ visibility specifier is 'private' 01907 dcop_area = 0; 01908 dcop_signal_area = 0; 01909 01910 ;} 01911 break; 01912 01913 case 11: 01914 01915 /* Line 1455 of yacc.c */ 01916 #line 208 "yacc.yy" 01917 { 01918 ;} 01919 break; 01920 01921 case 12: 01922 01923 /* Line 1455 of yacc.c */ 01924 #line 211 "yacc.yy" 01925 { 01926 ;} 01927 break; 01928 01929 case 13: 01930 01931 /* Line 1455 of yacc.c */ 01932 #line 214 "yacc.yy" 01933 { 01934 ;} 01935 break; 01936 01937 case 14: 01938 01939 /* Line 1455 of yacc.c */ 01940 #line 217 "yacc.yy" 01941 { 01942 in_namespace += *(yyvsp[(2) - (3)]._str); in_namespace += "::"; 01943 ;} 01944 break; 01945 01946 case 15: 01947 01948 /* Line 1455 of yacc.c */ 01949 #line 221 "yacc.yy" 01950 { 01951 int pos = in_namespace.findRev( "::", -3 ); 01952 if( pos >= 0 ) 01953 in_namespace = in_namespace.left( pos + 2 ); 01954 else 01955 in_namespace = ""; 01956 ;} 01957 break; 01958 01959 case 16: 01960 01961 /* Line 1455 of yacc.c */ 01962 #line 229 "yacc.yy" 01963 { 01964 ;} 01965 break; 01966 01967 case 17: 01968 01969 /* Line 1455 of yacc.c */ 01970 #line 232 "yacc.yy" 01971 { 01972 ;} 01973 break; 01974 01975 case 18: 01976 01977 /* Line 1455 of yacc.c */ 01978 #line 235 "yacc.yy" 01979 { 01980 ;} 01981 break; 01982 01983 case 19: 01984 01985 /* Line 1455 of yacc.c */ 01986 #line 238 "yacc.yy" 01987 { 01988 ;} 01989 break; 01990 01991 case 20: 01992 01993 /* Line 1455 of yacc.c */ 01994 #line 241 "yacc.yy" 01995 { 01996 ;} 01997 break; 01998 01999 case 21: 02000 02001 /* Line 1455 of yacc.c */ 02002 #line 244 "yacc.yy" 02003 { 02004 ;} 02005 break; 02006 02007 case 22: 02008 02009 /* Line 1455 of yacc.c */ 02010 #line 247 "yacc.yy" 02011 { 02012 ;} 02013 break; 02014 02015 case 23: 02016 02017 /* Line 1455 of yacc.c */ 02018 #line 250 "yacc.yy" 02019 { 02020 ;} 02021 break; 02022 02023 case 24: 02024 02025 /* Line 1455 of yacc.c */ 02026 #line 253 "yacc.yy" 02027 { 02028 ;} 02029 break; 02030 02031 case 25: 02032 02033 /* Line 1455 of yacc.c */ 02034 #line 256 "yacc.yy" 02035 { 02036 ;} 02037 break; 02038 02039 case 36: 02040 02041 /* Line 1455 of yacc.c */ 02042 #line 273 "yacc.yy" 02043 { 02044 dcop_area = 0; 02045 dcop_signal_area = 0; 02046 ;} 02047 break; 02048 02049 case 37: 02050 02051 /* Line 1455 of yacc.c */ 02052 #line 278 "yacc.yy" 02053 { 02054 dcop_area = 0; 02055 dcop_signal_area = 0; 02056 ;} 02057 break; 02058 02059 case 38: 02060 02061 /* Line 1455 of yacc.c */ 02062 #line 286 "yacc.yy" 02063 { 02064 dcop_area = 1; 02065 dcop_signal_area = 0; 02066 ;} 02067 break; 02068 02069 case 39: 02070 02071 /* Line 1455 of yacc.c */ 02072 #line 294 "yacc.yy" 02073 { 02074 /* 02075 A dcop signals area needs all dcop area capabilities, 02076 e.g. parsing of function parameters. 02077 */ 02078 dcop_area = 1; 02079 dcop_signal_area = 1; 02080 ;} 02081 break; 02082 02083 case 40: 02084 02085 /* Line 1455 of yacc.c */ 02086 #line 305 "yacc.yy" 02087 { 02088 (yyval._str) = (yyvsp[(1) - (1)]._str); 02089 ;} 02090 break; 02091 02092 case 41: 02093 02094 /* Line 1455 of yacc.c */ 02095 #line 308 "yacc.yy" 02096 { 02097 QString* tmp = new QString( "%1::%2" ); 02098 *tmp = tmp->arg(*((yyvsp[(1) - (3)]._str))).arg(*((yyvsp[(3) - (3)]._str))); 02099 (yyval._str) = tmp; 02100 ;} 02101 break; 02102 02103 case 42: 02104 02105 /* Line 1455 of yacc.c */ 02106 #line 317 "yacc.yy" 02107 { 02108 QString* tmp = new QString( " <SUPER>%1</SUPER>\n" ); 02109 *tmp = tmp->arg( *((yyvsp[(1) - (1)]._str)) ); 02110 (yyval._str) = tmp; 02111 ;} 02112 break; 02113 02114 case 43: 02115 02116 /* Line 1455 of yacc.c */ 02117 #line 323 "yacc.yy" 02118 { 02119 QString* tmp = new QString( " <SUPER>%1</SUPER>\n" ); 02120 *tmp = tmp->arg( *((yyvsp[(1) - (4)]._str)) + "<" + *((yyvsp[(3) - (4)]._str)) + ">" ); 02121 (yyval._str) = tmp; 02122 ;} 02123 break; 02124 02125 case 44: 02126 02127 /* Line 1455 of yacc.c */ 02128 #line 332 "yacc.yy" 02129 { 02130 (yyval._str) = (yyvsp[(3) - (3)]._str); 02131 ;} 02132 break; 02133 02134 case 45: 02135 02136 /* Line 1455 of yacc.c */ 02137 #line 336 "yacc.yy" 02138 { 02139 (yyval._str) = (yyvsp[(1) - (1)]._str); 02140 ;} 02141 break; 02142 02143 case 46: 02144 02145 /* Line 1455 of yacc.c */ 02146 #line 343 "yacc.yy" 02147 { 02148 (yyval._str) = (yyvsp[(1) - (2)]._str); 02149 ;} 02150 break; 02151 02152 case 47: 02153 02154 /* Line 1455 of yacc.c */ 02155 #line 347 "yacc.yy" 02156 { 02157 /* $$ = $1; */ 02158 (yyval._str) = new QString( *((yyvsp[(1) - (3)]._str)) + *((yyvsp[(3) - (3)]._str)) ); 02159 ;} 02160 break; 02161 02162 case 48: 02163 02164 /* Line 1455 of yacc.c */ 02165 #line 355 "yacc.yy" 02166 { 02167 (yyval._str) = (yyvsp[(2) - (2)]._str); 02168 ;} 02169 break; 02170 02171 case 49: 02172 02173 /* Line 1455 of yacc.c */ 02174 #line 359 "yacc.yy" 02175 { 02176 (yyval._str) = new QString( "" ); 02177 ;} 02178 break; 02179 02180 case 50: 02181 02182 /* Line 1455 of yacc.c */ 02183 #line 366 "yacc.yy" 02184 { 02185 ;} 02186 break; 02187 02188 case 52: 02189 02190 /* Line 1455 of yacc.c */ 02191 #line 373 "yacc.yy" 02192 { 02193 (yyval._str) = new QString( "" ); 02194 ;} 02195 break; 02196 02197 case 53: 02198 02199 /* Line 1455 of yacc.c */ 02200 #line 377 "yacc.yy" 02201 { 02202 (yyval._str) = new QString( *((yyvsp[(1) - (2)]._str)) + *((yyvsp[(2) - (2)]._str)) ); 02203 ;} 02204 break; 02205 02206 case 54: 02207 02208 /* Line 1455 of yacc.c */ 02209 #line 381 "yacc.yy" 02210 { 02211 (yyval._str) = new QString( *((yyvsp[(2) - (3)]._str)) + *((yyvsp[(3) - (3)]._str)) ); 02212 ;} 02213 break; 02214 02215 case 55: 02216 02217 /* Line 1455 of yacc.c */ 02218 #line 385 "yacc.yy" 02219 { 02220 (yyval._str) = new QString( *((yyvsp[(1) - (2)]._str)) + *((yyvsp[(2) - (2)]._str)) ); 02221 ;} 02222 break; 02223 02224 case 56: 02225 02226 /* Line 1455 of yacc.c */ 02227 #line 389 "yacc.yy" 02228 { 02229 (yyval._str) = (yyvsp[(2) - (2)]._str); 02230 ;} 02231 break; 02232 02233 case 57: 02234 02235 /* Line 1455 of yacc.c */ 02236 #line 393 "yacc.yy" 02237 { 02238 (yyval._str) = (yyvsp[(2) - (2)]._str); 02239 ;} 02240 break; 02241 02242 case 58: 02243 02244 /* Line 1455 of yacc.c */ 02245 #line 397 "yacc.yy" 02246 { 02247 (yyval._str) = (yyvsp[(2) - (2)]._str); 02248 ;} 02249 break; 02250 02251 case 59: 02252 02253 /* Line 1455 of yacc.c */ 02254 #line 401 "yacc.yy" 02255 { 02256 (yyval._str) = (yyvsp[(2) - (2)]._str); 02257 ;} 02258 break; 02259 02260 case 60: 02261 02262 /* Line 1455 of yacc.c */ 02263 #line 405 "yacc.yy" 02264 { 02265 (yyval._str) = (yyvsp[(2) - (2)]._str); 02266 ;} 02267 break; 02268 02269 case 61: 02270 02271 /* Line 1455 of yacc.c */ 02272 #line 409 "yacc.yy" 02273 { 02274 (yyval._str) = (yyvsp[(5) - (5)]._str); 02275 ;} 02276 break; 02277 02278 case 62: 02279 02280 /* Line 1455 of yacc.c */ 02281 #line 413 "yacc.yy" 02282 { 02283 (yyval._str) = (yyvsp[(4) - (4)]._str); 02284 ;} 02285 break; 02286 02287 case 63: 02288 02289 /* Line 1455 of yacc.c */ 02290 #line 417 "yacc.yy" 02291 { 02292 (yyval._str) = (yyvsp[(4) - (4)]._str); 02293 ;} 02294 break; 02295 02296 case 64: 02297 02298 /* Line 1455 of yacc.c */ 02299 #line 421 "yacc.yy" 02300 { 02301 (yyval._str) = (yyvsp[(4) - (4)]._str); 02302 ;} 02303 break; 02304 02305 case 65: 02306 02307 /* Line 1455 of yacc.c */ 02308 #line 425 "yacc.yy" 02309 { 02310 (yyval._str) = (yyvsp[(6) - (6)]._str); 02311 ;} 02312 break; 02313 02314 case 66: 02315 02316 /* Line 1455 of yacc.c */ 02317 #line 429 "yacc.yy" 02318 { 02319 (yyval._str) = (yyvsp[(4) - (4)]._str); 02320 ;} 02321 break; 02322 02323 case 67: 02324 02325 /* Line 1455 of yacc.c */ 02326 #line 433 "yacc.yy" 02327 { 02328 (yyval._str) = (yyvsp[(6) - (6)]._str); 02329 ;} 02330 break; 02331 02332 case 68: 02333 02334 /* Line 1455 of yacc.c */ 02335 #line 437 "yacc.yy" 02336 { 02337 (yyval._str) = (yyvsp[(6) - (6)]._str); 02338 ;} 02339 break; 02340 02341 case 75: 02342 02343 /* Line 1455 of yacc.c */ 02344 #line 455 "yacc.yy" 02345 {;} 02346 break; 02347 02348 case 76: 02349 02350 /* Line 1455 of yacc.c */ 02351 #line 456 "yacc.yy" 02352 {;} 02353 break; 02354 02355 case 77: 02356 02357 /* Line 1455 of yacc.c */ 02358 #line 460 "yacc.yy" 02359 {;} 02360 break; 02361 02362 case 78: 02363 02364 /* Line 1455 of yacc.c */ 02365 #line 461 "yacc.yy" 02366 {;} 02367 break; 02368 02369 case 79: 02370 02371 /* Line 1455 of yacc.c */ 02372 #line 462 "yacc.yy" 02373 {;} 02374 break; 02375 02376 case 80: 02377 02378 /* Line 1455 of yacc.c */ 02379 #line 463 "yacc.yy" 02380 {;} 02381 break; 02382 02383 case 81: 02384 02385 /* Line 1455 of yacc.c */ 02386 #line 464 "yacc.yy" 02387 {;} 02388 break; 02389 02390 case 82: 02391 02392 /* Line 1455 of yacc.c */ 02393 #line 468 "yacc.yy" 02394 {;} 02395 break; 02396 02397 case 83: 02398 02399 /* Line 1455 of yacc.c */ 02400 #line 469 "yacc.yy" 02401 {;} 02402 break; 02403 02404 case 84: 02405 02406 /* Line 1455 of yacc.c */ 02407 #line 470 "yacc.yy" 02408 {;} 02409 break; 02410 02411 case 85: 02412 02413 /* Line 1455 of yacc.c */ 02414 #line 475 "yacc.yy" 02415 { 02416 if (dcop_area) { 02417 QString* tmp = new QString("<TYPEDEF name=\"%1\" template=\"%2\"><PARAM %3</TYPEDEF>\n"); 02418 *tmp = tmp->arg( *((yyvsp[(6) - (7)]._str)) ).arg( *((yyvsp[(2) - (7)]._str)) ).arg( *((yyvsp[(4) - (7)]._str)) ); 02419 (yyval._str) = tmp; 02420 } else { 02421 (yyval._str) = new QString(""); 02422 } 02423 ;} 02424 break; 02425 02426 case 86: 02427 02428 /* Line 1455 of yacc.c */ 02429 #line 485 "yacc.yy" 02430 { 02431 if (dcop_area) 02432 yyerror("scoped template typedefs are not supported in dcop areas!"); 02433 ;} 02434 break; 02435 02436 case 87: 02437 02438 /* Line 1455 of yacc.c */ 02439 #line 493 "yacc.yy" 02440 { 02441 (yyval._int) = 0; 02442 ;} 02443 break; 02444 02445 case 88: 02446 02447 /* Line 1455 of yacc.c */ 02448 #line 497 "yacc.yy" 02449 { 02450 (yyval._int) = 1; 02451 ;} 02452 break; 02453 02454 case 89: 02455 02456 /* Line 1455 of yacc.c */ 02457 #line 503 "yacc.yy" 02458 { (yyval._str) = new QString("signed int"); ;} 02459 break; 02460 02461 case 90: 02462 02463 /* Line 1455 of yacc.c */ 02464 #line 504 "yacc.yy" 02465 { (yyval._str) = new QString("signed int"); ;} 02466 break; 02467 02468 case 91: 02469 02470 /* Line 1455 of yacc.c */ 02471 #line 505 "yacc.yy" 02472 { (yyval._str) = new QString("unsigned int"); ;} 02473 break; 02474 02475 case 92: 02476 02477 /* Line 1455 of yacc.c */ 02478 #line 506 "yacc.yy" 02479 { (yyval._str) = new QString("unsigned int"); ;} 02480 break; 02481 02482 case 93: 02483 02484 /* Line 1455 of yacc.c */ 02485 #line 507 "yacc.yy" 02486 { (yyval._str) = new QString("signed short int"); ;} 02487 break; 02488 02489 case 94: 02490 02491 /* Line 1455 of yacc.c */ 02492 #line 508 "yacc.yy" 02493 { (yyval._str) = new QString("signed short int"); ;} 02494 break; 02495 02496 case 95: 02497 02498 /* Line 1455 of yacc.c */ 02499 #line 509 "yacc.yy" 02500 { (yyval._str) = new QString("signed long int"); ;} 02501 break; 02502 02503 case 96: 02504 02505 /* Line 1455 of yacc.c */ 02506 #line 510 "yacc.yy" 02507 { (yyval._str) = new QString("signed long int"); ;} 02508 break; 02509 02510 case 97: 02511 02512 /* Line 1455 of yacc.c */ 02513 #line 511 "yacc.yy" 02514 { (yyval._str) = new QString("unsigned short int"); ;} 02515 break; 02516 02517 case 98: 02518 02519 /* Line 1455 of yacc.c */ 02520 #line 512 "yacc.yy" 02521 { (yyval._str) = new QString("unsigned short int"); ;} 02522 break; 02523 02524 case 99: 02525 02526 /* Line 1455 of yacc.c */ 02527 #line 513 "yacc.yy" 02528 { (yyval._str) = new QString("unsigned long int"); ;} 02529 break; 02530 02531 case 100: 02532 02533 /* Line 1455 of yacc.c */ 02534 #line 514 "yacc.yy" 02535 { (yyval._str) = new QString("unsigned long int"); ;} 02536 break; 02537 02538 case 101: 02539 02540 /* Line 1455 of yacc.c */ 02541 #line 515 "yacc.yy" 02542 { (yyval._str) = new QString("int"); ;} 02543 break; 02544 02545 case 102: 02546 02547 /* Line 1455 of yacc.c */ 02548 #line 516 "yacc.yy" 02549 { (yyval._str) = new QString("long int"); ;} 02550 break; 02551 02552 case 103: 02553 02554 /* Line 1455 of yacc.c */ 02555 #line 517 "yacc.yy" 02556 { (yyval._str) = new QString("long int"); ;} 02557 break; 02558 02559 case 104: 02560 02561 /* Line 1455 of yacc.c */ 02562 #line 518 "yacc.yy" 02563 { (yyval._str) = new QString("short int"); ;} 02564 break; 02565 02566 case 105: 02567 02568 /* Line 1455 of yacc.c */ 02569 #line 519 "yacc.yy" 02570 { (yyval._str) = new QString("short int"); ;} 02571 break; 02572 02573 case 106: 02574 02575 /* Line 1455 of yacc.c */ 02576 #line 520 "yacc.yy" 02577 { (yyval._str) = new QString("char"); ;} 02578 break; 02579 02580 case 107: 02581 02582 /* Line 1455 of yacc.c */ 02583 #line 521 "yacc.yy" 02584 { (yyval._str) = new QString("signed char"); ;} 02585 break; 02586 02587 case 108: 02588 02589 /* Line 1455 of yacc.c */ 02590 #line 522 "yacc.yy" 02591 { (yyval._str) = new QString("unsigned char"); ;} 02592 break; 02593 02594 case 111: 02595 02596 /* Line 1455 of yacc.c */ 02597 #line 532 "yacc.yy" 02598 { 02599 (yyval._str) = new QString( "" ); 02600 ;} 02601 break; 02602 02603 case 113: 02604 02605 /* Line 1455 of yacc.c */ 02606 #line 537 "yacc.yy" 02607 { 02608 (yyval._str) = new QString( *((yyvsp[(1) - (3)]._str)) + *((yyvsp[(3) - (3)]._str)) ); 02609 ;} 02610 break; 02611 02612 case 115: 02613 02614 /* Line 1455 of yacc.c */ 02615 #line 545 "yacc.yy" 02616 { (yyval._str) = (yyvsp[(1) - (1)]._str); ;} 02617 break; 02618 02619 case 116: 02620 02621 /* Line 1455 of yacc.c */ 02622 #line 546 "yacc.yy" 02623 { (yyval._str) = (yyvsp[(2) - (2)]._str); ;} 02624 break; 02625 02626 case 117: 02627 02628 /* Line 1455 of yacc.c */ 02629 #line 547 "yacc.yy" 02630 { (yyval._str) = (yyvsp[(2) - (2)]._str); ;} 02631 break; 02632 02633 case 118: 02634 02635 /* Line 1455 of yacc.c */ 02636 #line 548 "yacc.yy" 02637 { 02638 QString *tmp = new QString("%1<%2>"); 02639 *tmp = tmp->arg(*((yyvsp[(1) - (4)]._str))); 02640 *tmp = tmp->arg(*((yyvsp[(3) - (4)]._str))); 02641 (yyval._str) = tmp; 02642 ;} 02643 break; 02644 02645 case 119: 02646 02647 /* Line 1455 of yacc.c */ 02648 #line 554 "yacc.yy" 02649 { 02650 QString *tmp = new QString("%1<%2>::%3"); 02651 *tmp = tmp->arg(*((yyvsp[(1) - (6)]._str))); 02652 *tmp = tmp->arg(*((yyvsp[(3) - (6)]._str))); 02653 *tmp = tmp->arg(*((yyvsp[(6) - (6)]._str))); 02654 (yyval._str) = tmp; 02655 ;} 02656 break; 02657 02658 case 120: 02659 02660 /* Line 1455 of yacc.c */ 02661 #line 566 "yacc.yy" 02662 { 02663 (yyval._str) = new QString(*((yyvsp[(1) - (3)]._str)) + "," + *((yyvsp[(3) - (3)]._str))); 02664 ;} 02665 break; 02666 02667 case 121: 02668 02669 /* Line 1455 of yacc.c */ 02670 #line 570 "yacc.yy" 02671 { 02672 (yyval._str) = (yyvsp[(1) - (1)]._str); 02673 ;} 02674 break; 02675 02676 case 122: 02677 02678 /* Line 1455 of yacc.c */ 02679 #line 578 "yacc.yy" 02680 { 02681 if (dcop_area) 02682 yyerror("in dcop areas are no pointers allowed"); 02683 ;} 02684 break; 02685 02686 case 123: 02687 02688 /* Line 1455 of yacc.c */ 02689 #line 583 "yacc.yy" 02690 { 02691 (yyval._str) = (yyvsp[(1) - (1)]._str); 02692 ;} 02693 break; 02694 02695 case 124: 02696 02697 /* Line 1455 of yacc.c */ 02698 #line 592 "yacc.yy" 02699 { 02700 if (dcop_area) 02701 yyerror("in dcop areas are no pointers allowed"); 02702 ;} 02703 break; 02704 02705 case 125: 02706 02707 /* Line 1455 of yacc.c */ 02708 #line 596 "yacc.yy" 02709 { 02710 if (dcop_area) { 02711 QString* tmp = new QString("<TYPE qleft=\"const\" qright=\"" AMP_ENTITY "\">%1</TYPE>"); 02712 *tmp = tmp->arg( *((yyvsp[(2) - (3)]._str)) ); 02713 (yyval._str) = tmp; 02714 } 02715 ;} 02716 break; 02717 02718 case 126: 02719 02720 /* Line 1455 of yacc.c */ 02721 #line 603 "yacc.yy" 02722 { 02723 QString* tmp = new QString("<TYPE>%1</TYPE>"); 02724 *tmp = tmp->arg( *((yyvsp[(2) - (2)]._str)) ); 02725 (yyval._str) = tmp; 02726 ;} 02727 break; 02728 02729 case 127: 02730 02731 /* Line 1455 of yacc.c */ 02732 #line 608 "yacc.yy" 02733 { 02734 QString* tmp = new QString("<TYPE>%1</TYPE>"); 02735 *tmp = tmp->arg( *((yyvsp[(1) - (2)]._str)) ); 02736 (yyval._str) = tmp; 02737 ;} 02738 break; 02739 02740 case 128: 02741 02742 /* Line 1455 of yacc.c */ 02743 #line 613 "yacc.yy" 02744 { 02745 if (dcop_area) { 02746 QString* tmp = new QString("<TYPE qleft=\"const\" qright=\"" AMP_ENTITY "\">%1</TYPE>"); 02747 *tmp = tmp->arg( *((yyvsp[(1) - (3)]._str)) ); 02748 (yyval._str) = tmp; 02749 } 02750 ;} 02751 break; 02752 02753 case 129: 02754 02755 /* Line 1455 of yacc.c */ 02756 #line 620 "yacc.yy" 02757 { 02758 if (dcop_area) 02759 yyerror("in dcop areas are only const references allowed!"); 02760 ;} 02761 break; 02762 02763 case 130: 02764 02765 /* Line 1455 of yacc.c */ 02766 #line 625 "yacc.yy" 02767 { 02768 QString* tmp = new QString("<TYPE>%1</TYPE>"); 02769 *tmp = tmp->arg( *((yyvsp[(1) - (1)]._str)) ); 02770 (yyval._str) = tmp; 02771 ;} 02772 break; 02773 02774 case 131: 02775 02776 /* Line 1455 of yacc.c */ 02777 #line 631 "yacc.yy" 02778 { 02779 if (dcop_area) 02780 yyerror("in dcop areas are no pointers allowed"); 02781 ;} 02782 break; 02783 02784 case 132: 02785 02786 /* Line 1455 of yacc.c */ 02787 #line 639 "yacc.yy" 02788 { 02789 (yyval._str) = new QString(*((yyvsp[(1) - (3)]._str)) + "," + *((yyvsp[(3) - (3)]._str))); 02790 ;} 02791 break; 02792 02793 case 133: 02794 02795 /* Line 1455 of yacc.c */ 02796 #line 643 "yacc.yy" 02797 { 02798 (yyval._str) = (yyvsp[(1) - (1)]._str); 02799 ;} 02800 break; 02801 02802 case 134: 02803 02804 /* Line 1455 of yacc.c */ 02805 #line 650 "yacc.yy" 02806 { 02807 if (dcop_area) { 02808 QString* tmp = new QString("\n <ARG>%1<NAME>%2</NAME></ARG>"); 02809 *tmp = tmp->arg( *((yyvsp[(1) - (3)]._str)) ); 02810 *tmp = tmp->arg( *((yyvsp[(2) - (3)]._str)) ); 02811 (yyval._str) = tmp; 02812 } else (yyval._str) = new QString(); 02813 ;} 02814 break; 02815 02816 case 135: 02817 02818 /* Line 1455 of yacc.c */ 02819 #line 659 "yacc.yy" 02820 { 02821 if (dcop_area) { 02822 QString* tmp = new QString("\n <ARG>%1</ARG>"); 02823 *tmp = tmp->arg( *((yyvsp[(1) - (2)]._str)) ); 02824 (yyval._str) = tmp; 02825 } else (yyval._str) = new QString(); 02826 ;} 02827 break; 02828 02829 case 136: 02830 02831 /* Line 1455 of yacc.c */ 02832 #line 667 "yacc.yy" 02833 { 02834 if (dcop_area) 02835 yyerror("variable arguments not supported in dcop area."); 02836 (yyval._str) = new QString(""); 02837 ;} 02838 break; 02839 02840 case 137: 02841 02842 /* Line 1455 of yacc.c */ 02843 #line 676 "yacc.yy" 02844 { 02845 ;} 02846 break; 02847 02848 case 138: 02849 02850 /* Line 1455 of yacc.c */ 02851 #line 679 "yacc.yy" 02852 { 02853 ;} 02854 break; 02855 02856 case 139: 02857 02858 /* Line 1455 of yacc.c */ 02859 #line 682 "yacc.yy" 02860 { 02861 ;} 02862 break; 02863 02864 case 140: 02865 02866 /* Line 1455 of yacc.c */ 02867 #line 689 "yacc.yy" 02868 { 02869 ;} 02870 break; 02871 02872 case 141: 02873 02874 /* Line 1455 of yacc.c */ 02875 #line 692 "yacc.yy" 02876 { 02877 ;} 02878 break; 02879 02880 case 142: 02881 02882 /* Line 1455 of yacc.c */ 02883 #line 695 "yacc.yy" 02884 { 02885 ;} 02886 break; 02887 02888 case 143: 02889 02890 /* Line 1455 of yacc.c */ 02891 #line 698 "yacc.yy" 02892 { 02893 ;} 02894 break; 02895 02896 case 144: 02897 02898 /* Line 1455 of yacc.c */ 02899 #line 701 "yacc.yy" 02900 { 02901 ;} 02902 break; 02903 02904 case 145: 02905 02906 /* Line 1455 of yacc.c */ 02907 #line 706 "yacc.yy" 02908 { (yyval._int) = 0; ;} 02909 break; 02910 02911 case 146: 02912 02913 /* Line 1455 of yacc.c */ 02914 #line 707 "yacc.yy" 02915 { (yyval._int) = 1; ;} 02916 break; 02917 02918 case 152: 02919 02920 /* Line 1455 of yacc.c */ 02921 #line 716 "yacc.yy" 02922 { 02923 if (dcop_area || dcop_signal_area) { 02924 QString* tmp = 0; 02925 tmp = new QString( 02926 " <%4>\n" 02927 " %2\n" 02928 " <NAME>%1</NAME>" 02929 "%3\n" 02930 " </%5>\n"); 02931 *tmp = tmp->arg( *((yyvsp[(2) - (6)]._str)) ); 02932 *tmp = tmp->arg( *((yyvsp[(1) - (6)]._str)) ); 02933 *tmp = tmp->arg( *((yyvsp[(4) - (6)]._str)) ); 02934 02935 QString tagname = (dcop_signal_area) ? "SIGNAL" : "FUNC"; 02936 QString attr = ((yyvsp[(6) - (6)]._int)) ? " qual=\"const\"" : ""; 02937 *tmp = tmp->arg( QString("%1%2").arg(tagname).arg(attr) ); 02938 *tmp = tmp->arg( QString("%1").arg(tagname) ); 02939 (yyval._str) = tmp; 02940 } else 02941 (yyval._str) = new QString(""); 02942 ;} 02943 break; 02944 02945 case 153: 02946 02947 /* Line 1455 of yacc.c */ 02948 #line 738 "yacc.yy" 02949 { 02950 if (dcop_area) 02951 yyerror("operators aren't allowed in dcop areas!"); 02952 (yyval._str) = new QString(""); 02953 ;} 02954 break; 02955 02956 case 154: 02957 02958 /* Line 1455 of yacc.c */ 02959 #line 748 "yacc.yy" 02960 {;} 02961 break; 02962 02963 case 155: 02964 02965 /* Line 1455 of yacc.c */ 02966 #line 749 "yacc.yy" 02967 {;} 02968 break; 02969 02970 case 156: 02971 02972 /* Line 1455 of yacc.c */ 02973 #line 750 "yacc.yy" 02974 {;} 02975 break; 02976 02977 case 157: 02978 02979 /* Line 1455 of yacc.c */ 02980 #line 755 "yacc.yy" 02981 {;} 02982 break; 02983 02984 case 158: 02985 02986 /* Line 1455 of yacc.c */ 02987 #line 760 "yacc.yy" 02988 {;} 02989 break; 02990 02991 case 159: 02992 02993 /* Line 1455 of yacc.c */ 02994 #line 761 "yacc.yy" 02995 {;} 02996 break; 02997 02998 case 160: 02999 03000 /* Line 1455 of yacc.c */ 03001 #line 766 "yacc.yy" 03002 { 03003 (yyval._str) = (yyvsp[(1) - (2)]._str); 03004 ;} 03005 break; 03006 03007 case 161: 03008 03009 /* Line 1455 of yacc.c */ 03010 #line 770 "yacc.yy" 03011 { 03012 (yyval._str) = (yyvsp[(2) - (5)]._str); 03013 ;} 03014 break; 03015 03016 case 162: 03017 03018 /* Line 1455 of yacc.c */ 03019 #line 774 "yacc.yy" 03020 { 03021 (yyval._str) = (yyvsp[(2) - (3)]._str); 03022 ;} 03023 break; 03024 03025 case 163: 03026 03027 /* Line 1455 of yacc.c */ 03028 #line 778 "yacc.yy" 03029 { 03030 /* The constructor */ 03031 assert(!dcop_area); 03032 (yyval._str) = new QString(""); 03033 ;} 03034 break; 03035 03036 case 164: 03037 03038 /* Line 1455 of yacc.c */ 03039 #line 784 "yacc.yy" 03040 { 03041 /* The constructor */ 03042 assert(!dcop_area); 03043 (yyval._str) = new QString(""); 03044 ;} 03045 break; 03046 03047 case 165: 03048 03049 /* Line 1455 of yacc.c */ 03050 #line 790 "yacc.yy" 03051 { 03052 /* The destructor */ 03053 assert(!dcop_area); 03054 (yyval._str) = new QString(""); 03055 ;} 03056 break; 03057 03058 case 166: 03059 03060 /* Line 1455 of yacc.c */ 03061 #line 796 "yacc.yy" 03062 { 03063 if (dcop_area) { 03064 if (dcop_signal_area) 03065 yyerror("DCOP signals cannot be static"); 03066 else 03067 yyerror("DCOP functions cannot be static"); 03068 } else { 03069 (yyval._str) = new QString(); 03070 } 03071 ;} 03072 break; 03073 03074 case 167: 03075 03076 /* Line 1455 of yacc.c */ 03077 #line 809 "yacc.yy" 03078 { 03079 function_mode = 1; 03080 ;} 03081 break; 03082 03083 case 171: 03084 03085 /* Line 1455 of yacc.c */ 03086 #line 821 "yacc.yy" 03087 {;} 03088 break; 03089 03090 case 172: 03091 03092 /* Line 1455 of yacc.c */ 03093 #line 822 "yacc.yy" 03094 {;} 03095 break; 03096 03097 case 176: 03098 03099 /* Line 1455 of yacc.c */ 03100 #line 834 "yacc.yy" 03101 {;} 03102 break; 03103 03104 case 177: 03105 03106 /* Line 1455 of yacc.c */ 03107 #line 835 "yacc.yy" 03108 {;} 03109 break; 03110 03111 case 178: 03112 03113 /* Line 1455 of yacc.c */ 03114 #line 836 "yacc.yy" 03115 {;} 03116 break; 03117 03118 case 179: 03119 03120 /* Line 1455 of yacc.c */ 03121 #line 839 "yacc.yy" 03122 {;} 03123 break; 03124 03125 case 180: 03126 03127 /* Line 1455 of yacc.c */ 03128 #line 843 "yacc.yy" 03129 {;} 03130 break; 03131 03132 case 181: 03133 03134 /* Line 1455 of yacc.c */ 03135 #line 844 "yacc.yy" 03136 {;} 03137 break; 03138 03139 case 182: 03140 03141 /* Line 1455 of yacc.c */ 03142 #line 845 "yacc.yy" 03143 {;} 03144 break; 03145 03146 case 183: 03147 03148 /* Line 1455 of yacc.c */ 03149 #line 846 "yacc.yy" 03150 {;} 03151 break; 03152 03153 case 184: 03154 03155 /* Line 1455 of yacc.c */ 03156 #line 847 "yacc.yy" 03157 {;} 03158 break; 03159 03160 case 185: 03161 03162 /* Line 1455 of yacc.c */ 03163 #line 848 "yacc.yy" 03164 {;} 03165 break; 03166 03167 03168 03169 /* Line 1455 of yacc.c */ 03170 #line 3171 "yacc.cc" 03171 default: break; 03172 } 03173 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 03174 03175 YYPOPSTACK (yylen); 03176 yylen = 0; 03177 YY_STACK_PRINT (yyss, yyssp); 03178 03179 *++yyvsp = yyval; 03180 03181 /* Now `shift' the result of the reduction. Determine what state 03182 that goes to, based on the state we popped back to and the rule 03183 number reduced by. */ 03184 03185 yyn = yyr1[yyn]; 03186 03187 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 03188 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 03189 yystate = yytable[yystate]; 03190 else 03191 yystate = yydefgoto[yyn - YYNTOKENS]; 03192 03193 goto yynewstate; 03194 03195 03196 /*------------------------------------. 03197 | yyerrlab -- here on detecting error | 03198 `------------------------------------*/ 03199 yyerrlab: 03200 /* If not already recovering from an error, report this error. */ 03201 if (!yyerrstatus) 03202 { 03203 ++yynerrs; 03204 #if ! YYERROR_VERBOSE 03205 yyerror (YY_("syntax error")); 03206 #else 03207 { 03208 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 03209 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 03210 { 03211 YYSIZE_T yyalloc = 2 * yysize; 03212 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 03213 yyalloc = YYSTACK_ALLOC_MAXIMUM; 03214 if (yymsg != yymsgbuf) 03215 YYSTACK_FREE (yymsg); 03216 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 03217 if (yymsg) 03218 yymsg_alloc = yyalloc; 03219 else 03220 { 03221 yymsg = yymsgbuf; 03222 yymsg_alloc = sizeof yymsgbuf; 03223 } 03224 } 03225 03226 if (0 < yysize && yysize <= yymsg_alloc) 03227 { 03228 (void) yysyntax_error (yymsg, yystate, yychar); 03229 yyerror (yymsg); 03230 } 03231 else 03232 { 03233 yyerror (YY_("syntax error")); 03234 if (yysize != 0) 03235 goto yyexhaustedlab; 03236 } 03237 } 03238 #endif 03239 } 03240 03241 03242 03243 if (yyerrstatus == 3) 03244 { 03245 /* If just tried and failed to reuse lookahead token after an 03246 error, discard it. */ 03247 03248 if (yychar <= YYEOF) 03249 { 03250 /* Return failure if at end of input. */ 03251 if (yychar == YYEOF) 03252 YYABORT; 03253 } 03254 else 03255 { 03256 yydestruct ("Error: discarding", 03257 yytoken, &yylval); 03258 yychar = YYEMPTY; 03259 } 03260 } 03261 03262 /* Else will try to reuse lookahead token after shifting the error 03263 token. */ 03264 goto yyerrlab1; 03265 03266 03267 /*---------------------------------------------------. 03268 | yyerrorlab -- error raised explicitly by YYERROR. | 03269 `---------------------------------------------------*/ 03270 yyerrorlab: 03271 03272 /* Pacify compilers like GCC when the user code never invokes 03273 YYERROR and the label yyerrorlab therefore never appears in user 03274 code. */ 03275 if (/*CONSTCOND*/ 0) 03276 goto yyerrorlab; 03277 03278 /* Do not reclaim the symbols of the rule which action triggered 03279 this YYERROR. */ 03280 YYPOPSTACK (yylen); 03281 yylen = 0; 03282 YY_STACK_PRINT (yyss, yyssp); 03283 yystate = *yyssp; 03284 goto yyerrlab1; 03285 03286 03287 /*-------------------------------------------------------------. 03288 | yyerrlab1 -- common code for both syntax error and YYERROR. | 03289 `-------------------------------------------------------------*/ 03290 yyerrlab1: 03291 yyerrstatus = 3; /* Each real token shifted decrements this. */ 03292 03293 for (;;) 03294 { 03295 yyn = yypact[yystate]; 03296 if (yyn != YYPACT_NINF) 03297 { 03298 yyn += YYTERROR; 03299 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 03300 { 03301 yyn = yytable[yyn]; 03302 if (0 < yyn) 03303 break; 03304 } 03305 } 03306 03307 /* Pop the current state because it cannot handle the error token. */ 03308 if (yyssp == yyss) 03309 YYABORT; 03310 03311 03312 yydestruct ("Error: popping", 03313 yystos[yystate], yyvsp); 03314 YYPOPSTACK (1); 03315 yystate = *yyssp; 03316 YY_STACK_PRINT (yyss, yyssp); 03317 } 03318 03319 *++yyvsp = yylval; 03320 03321 03322 /* Shift the error token. */ 03323 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 03324 03325 yystate = yyn; 03326 goto yynewstate; 03327 03328 03329 /*-------------------------------------. 03330 | yyacceptlab -- YYACCEPT comes here. | 03331 `-------------------------------------*/ 03332 yyacceptlab: 03333 yyresult = 0; 03334 goto yyreturn; 03335 03336 /*-----------------------------------. 03337 | yyabortlab -- YYABORT comes here. | 03338 `-----------------------------------*/ 03339 yyabortlab: 03340 yyresult = 1; 03341 goto yyreturn; 03342 03343 #if !defined(yyoverflow) || YYERROR_VERBOSE 03344 /*-------------------------------------------------. 03345 | yyexhaustedlab -- memory exhaustion comes here. | 03346 `-------------------------------------------------*/ 03347 yyexhaustedlab: 03348 yyerror (YY_("memory exhausted")); 03349 yyresult = 2; 03350 /* Fall through. */ 03351 #endif 03352 03353 yyreturn: 03354 if (yychar != YYEMPTY) 03355 yydestruct ("Cleanup: discarding lookahead", 03356 yytoken, &yylval); 03357 /* Do not reclaim the symbols of the rule which action triggered 03358 this YYABORT or YYACCEPT. */ 03359 YYPOPSTACK (yylen); 03360 YY_STACK_PRINT (yyss, yyssp); 03361 while (yyssp != yyss) 03362 { 03363 yydestruct ("Cleanup: popping", 03364 yystos[*yyssp], yyvsp); 03365 YYPOPSTACK (1); 03366 } 03367 #ifndef yyoverflow 03368 if (yyss != yyssa) 03369 YYSTACK_FREE (yyss); 03370 #endif 03371 #if YYERROR_VERBOSE 03372 if (yymsg != yymsgbuf) 03373 YYSTACK_FREE (yymsg); 03374 #endif 03375 /* Make sure YYID is used. */ 03376 return YYID (yyresult); 03377 } 03378 03379 03380 03381 /* Line 1675 of yacc.c */ 03382 #line 851 "yacc.yy" 03383 03384 03385 void dcopidlParse( const char *_code ) 03386 { 03387 dcopidlInitFlex( _code ); 03388 yyparse(); 03389 } 03390