dcop Library API Documentation

yacc.cc

00001 /* A Bison parser, made by GNU Bison 1.875a.  */
00002 
00003 /* Skeleton parser for Yacc-like parsing with Bison,
00004    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
00005 
00006    This program is free software; you can redistribute it and/or modify
00007    it under the terms of the GNU General Public License as published by
00008    the Free Software Foundation; either version 2, or (at your option)
00009    any later version.
00010 
00011    This program is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014    GNU General Public License for more details.
00015 
00016    You should have received a copy of the GNU General Public License
00017    along with this program; if not, write to the Free Software
00018    Foundation, Inc., 59 Temple Place - Suite 330,
00019    Boston, MA 02111-1307, USA.  */
00020 
00021 /* As a special exception, when this file is copied by Bison into a
00022    Bison output file, you may use that output file without restriction.
00023    This special exception was added by the Free Software Foundation
00024    in version 1.24 of Bison.  */
00025 
00026 /* Written by Richard Stallman by simplifying the original so called
00027    ``semantic'' parser.  */
00028 
00029 /* All symbols defined below should begin with yy or YY, to avoid
00030    infringing on user name space.  This should be done even for local
00031    variables, as they might otherwise be expanded by user macros.
00032    There are some unavoidable exceptions within include files to
00033    define necessary library symbols; they are noted "INFRINGES ON
00034    USER NAME SPACE" below.  */
00035 
00036 /* Identify Bison output.  */
00037 #define YYBISON 1
00038 
00039 /* Skeleton name.  */
00040 #define YYSKELETON_NAME "yacc.c"
00041 
00042 /* Pure parsers.  */
00043 #define YYPURE 0
00044 
00045 /* Using locations.  */
00046 #define YYLSP_NEEDED 0
00047 
00048 
00049 
00050 /* Tokens.  */
00051 #ifndef YYTOKENTYPE
00052 # define YYTOKENTYPE
00053    /* Put the tokens into the symbol table, so that GDB and other debuggers
00054       know about them.  */
00055    enum yytokentype {
00056      T_CHARACTER_LITERAL = 258,
00057      T_DOUBLE_LITERAL = 259,
00058      T_IDENTIFIER = 260,
00059      T_INTEGER_LITERAL = 261,
00060      T_STRING_LITERAL = 262,
00061      T_INCLUDE = 263,
00062      T_CLASS = 264,
00063      T_STRUCT = 265,
00064      T_LEFT_CURLY_BRACKET = 266,
00065      T_LEFT_PARANTHESIS = 267,
00066      T_RIGHT_CURLY_BRACKET = 268,
00067      T_RIGHT_PARANTHESIS = 269,
00068      T_COLON = 270,
00069      T_SEMICOLON = 271,
00070      T_PUBLIC = 272,
00071      T_PROTECTED = 273,
00072      T_TRIPE_DOT = 274,
00073      T_PRIVATE = 275,
00074      T_VIRTUAL = 276,
00075      T_CONST = 277,
00076      T_INLINE = 278,
00077      T_FRIEND = 279,
00078      T_RETURN = 280,
00079      T_SIGNAL = 281,
00080      T_SLOT = 282,
00081      T_TYPEDEF = 283,
00082      T_PLUS = 284,
00083      T_MINUS = 285,
00084      T_COMMA = 286,
00085      T_ASTERISK = 287,
00086      T_TILDE = 288,
00087      T_LESS = 289,
00088      T_GREATER = 290,
00089      T_AMPERSAND = 291,
00090      T_EXTERN = 292,
00091      T_EXTERN_C = 293,
00092      T_ACCESS = 294,
00093      T_ENUM = 295,
00094      T_NAMESPACE = 296,
00095      T_USING = 297,
00096      T_UNKNOWN = 298,
00097      T_TRIPLE_DOT = 299,
00098      T_TRUE = 300,
00099      T_FALSE = 301,
00100      T_STATIC = 302,
00101      T_MUTABLE = 303,
00102      T_EQUAL = 304,
00103      T_SCOPE = 305,
00104      T_NULL = 306,
00105      T_INT = 307,
00106      T_ARRAY_OPEN = 308,
00107      T_ARRAY_CLOSE = 309,
00108      T_CHAR = 310,
00109      T_DCOP = 311,
00110      T_DCOP_AREA = 312,
00111      T_DCOP_SIGNAL_AREA = 313,
00112      T_SIGNED = 314,
00113      T_UNSIGNED = 315,
00114      T_LONG = 316,
00115      T_SHORT = 317,
00116      T_FUNOPERATOR = 318,
00117      T_MISCOPERATOR = 319,
00118      T_SHIFT = 320
00119    };
00120 #endif
00121 #define T_CHARACTER_LITERAL 258
00122 #define T_DOUBLE_LITERAL 259
00123 #define T_IDENTIFIER 260
00124 #define T_INTEGER_LITERAL 261
00125 #define T_STRING_LITERAL 262
00126 #define T_INCLUDE 263
00127 #define T_CLASS 264
00128 #define T_STRUCT 265
00129 #define T_LEFT_CURLY_BRACKET 266
00130 #define T_LEFT_PARANTHESIS 267
00131 #define T_RIGHT_CURLY_BRACKET 268
00132 #define T_RIGHT_PARANTHESIS 269
00133 #define T_COLON 270
00134 #define T_SEMICOLON 271
00135 #define T_PUBLIC 272
00136 #define T_PROTECTED 273
00137 #define T_TRIPE_DOT 274
00138 #define T_PRIVATE 275
00139 #define T_VIRTUAL 276
00140 #define T_CONST 277
00141 #define T_INLINE 278
00142 #define T_FRIEND 279
00143 #define T_RETURN 280
00144 #define T_SIGNAL 281
00145 #define T_SLOT 282
00146 #define T_TYPEDEF 283
00147 #define T_PLUS 284
00148 #define T_MINUS 285
00149 #define T_COMMA 286
00150 #define T_ASTERISK 287
00151 #define T_TILDE 288
00152 #define T_LESS 289
00153 #define T_GREATER 290
00154 #define T_AMPERSAND 291
00155 #define T_EXTERN 292
00156 #define T_EXTERN_C 293
00157 #define T_ACCESS 294
00158 #define T_ENUM 295
00159 #define T_NAMESPACE 296
00160 #define T_USING 297
00161 #define T_UNKNOWN 298
00162 #define T_TRIPLE_DOT 299
00163 #define T_TRUE 300
00164 #define T_FALSE 301
00165 #define T_STATIC 302
00166 #define T_MUTABLE 303
00167 #define T_EQUAL 304
00168 #define T_SCOPE 305
00169 #define T_NULL 306
00170 #define T_INT 307
00171 #define T_ARRAY_OPEN 308
00172 #define T_ARRAY_CLOSE 309
00173 #define T_CHAR 310
00174 #define T_DCOP 311
00175 #define T_DCOP_AREA 312
00176 #define T_DCOP_SIGNAL_AREA 313
00177 #define T_SIGNED 314
00178 #define T_UNSIGNED 315
00179 #define T_LONG 316
00180 #define T_SHORT 317
00181 #define T_FUNOPERATOR 318
00182 #define T_MISCOPERATOR 319
00183 #define T_SHIFT 320
00184 
00185 
00186 
00187 
00188 /* Copy the first part of user declarations.  */
00189 #line 1 "yacc.yy"
00190 
00191 /*****************************************************************
00192 Copyright (c) 1999 Torben Weis <weis@kde.org>
00193 Copyright (c) 2000 Matthias Ettrich <ettrich@kde.org>
00194 
00195 Permission is hereby granted, free of charge, to any person obtaining a copy
00196 of this software and associated documentation files (the "Software"), to deal
00197 in the Software without restriction, including without limitation the rights
00198 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
00199 copies of the Software, and to permit persons to whom the Software is
00200 furnished to do so, subject to the following conditions:
00201 
00202 The above copyright notice and this permission notice shall be included in
00203 all copies or substantial portions of the Software.
00204 
00205 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
00206 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
00207 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
00208 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
00209 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
00210 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00211 
00212 ******************************************************************/
00213 
00214 #include <config.h>
00215 
00216 // Workaround for a bison issue:
00217 // bison.simple concludes from _GNU_SOURCE that stpcpy is available,
00218 // while GNU string.h only exposes it if __USE_GNU is set.
00219 #ifdef _GNU_SOURCE
00220 #define __USE_GNU 1
00221 #endif
00222 
00223 #include <stdlib.h>
00224 #include <stdio.h>
00225 #include <assert.h>
00226 
00227 #include <qstring.h>
00228 
00229 #define AMP_ENTITY "&amp;"
00230 #define YYERROR_VERBOSE
00231 
00232 extern int yylex();
00233 
00234 // extern QString idl_lexFile;
00235 extern int idl_line_no;
00236 extern int function_mode;
00237 
00238 static int dcop_area = 0;
00239 static int dcop_signal_area = 0;
00240 
00241 static QString in_namespace( "" );
00242 
00243 void dcopidlInitFlex( const char *_code );
00244 
00245 void yyerror( const char *s )
00246 {
00247     qDebug( "In line %i : %s", idl_line_no, s );
00248         exit(1);
00249     //   theParser->parse_error( idl_lexFile, s, idl_line_no );
00250 }
00251 
00252 
00253 
00254 /* Enabling traces.  */
00255 #ifndef YYDEBUG
00256 # define YYDEBUG 1
00257 #endif
00258 
00259 /* Enabling verbose error messages.  */
00260 #ifdef YYERROR_VERBOSE
00261 # undef YYERROR_VERBOSE
00262 # define YYERROR_VERBOSE 1
00263 #else
00264 # define YYERROR_VERBOSE 0
00265 #endif
00266 
00267 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
00268 #line 67 "yacc.yy"
00269 typedef union YYSTYPE {
00270   long   _int;
00271   QString        *_str;
00272   unsigned short          _char;
00273   double _float;
00274 } YYSTYPE;
00275 /* Line 191 of yacc.c.  */
00276 #line 277 "yacc.cc"
00277 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00278 # define YYSTYPE_IS_DECLARED 1
00279 # define YYSTYPE_IS_TRIVIAL 1
00280 #endif
00281 
00282 
00283 
00284 /* Copy the second part of user declarations.  */
00285 
00286 
00287 /* Line 214 of yacc.c.  */
00288 #line 289 "yacc.cc"
00289 
00290 #if ! defined (yyoverflow) || YYERROR_VERBOSE
00291 
00292 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00293 
00294 # if YYSTACK_USE_ALLOCA
00295 #  define YYSTACK_ALLOC alloca
00296 # else
00297 #  ifndef YYSTACK_USE_ALLOCA
00298 #   if defined (alloca) || defined (_ALLOCA_H)
00299 #    define YYSTACK_ALLOC alloca
00300 #   else
00301 #    ifdef __GNUC__
00302 #     define YYSTACK_ALLOC __builtin_alloca
00303 #    endif
00304 #   endif
00305 #  endif
00306 # endif
00307 
00308 # ifdef YYSTACK_ALLOC
00309    /* Pacify GCC's `empty if-body' warning. */
00310 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
00311 # else
00312 #  if defined (__STDC__) || defined (__cplusplus)
00313 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00314 #   define YYSIZE_T size_t
00315 #  endif
00316 #  define YYSTACK_ALLOC malloc
00317 #  define YYSTACK_FREE free
00318 # endif
00319 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
00320 
00321 
00322 #if (! defined (yyoverflow) \
00323      && (! defined (__cplusplus) \
00324      || (YYSTYPE_IS_TRIVIAL)))
00325 
00326 /* A type that is properly aligned for any stack member.  */
00327 union yyalloc
00328 {
00329   short yyss;
00330   YYSTYPE yyvs;
00331   };
00332 
00333 /* The size of the maximum gap between one aligned stack and the next.  */
00334 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00335 
00336 /* The size of an array large to enough to hold all stacks, each with
00337    N elements.  */
00338 # define YYSTACK_BYTES(N) \
00339      ((N) * (sizeof (short) + sizeof (YYSTYPE))             \
00340       + YYSTACK_GAP_MAXIMUM)
00341 
00342 /* Copy COUNT objects from FROM to TO.  The source and destination do
00343    not overlap.  */
00344 # ifndef YYCOPY
00345 #  if 1 < __GNUC__
00346 #   define YYCOPY(To, From, Count) \
00347       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00348 #  else
00349 #   define YYCOPY(To, From, Count)      \
00350       do                    \
00351     {                   \
00352       register YYSIZE_T yyi;        \
00353       for (yyi = 0; yyi < (Count); yyi++)   \
00354         (To)[yyi] = (From)[yyi];        \
00355     }                   \
00356       while (0)
00357 #  endif
00358 # endif
00359 
00360 /* Relocate STACK from its old location to the new one.  The
00361    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00362    elements in the stack, and YYPTR gives the new location of the
00363    stack.  Advance YYPTR to a properly aligned location for the next
00364    stack.  */
00365 # define YYSTACK_RELOCATE(Stack)                    \
00366     do                                  \
00367       {                                 \
00368     YYSIZE_T yynewbytes;                        \
00369     YYCOPY (&yyptr->Stack, Stack, yysize);              \
00370     Stack = &yyptr->Stack;                      \
00371     yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00372     yyptr += yynewbytes / sizeof (*yyptr);              \
00373       }                                 \
00374     while (0)
00375 
00376 #endif
00377 
00378 #if defined (__STDC__) || defined (__cplusplus)
00379    typedef signed char yysigned_char;
00380 #else
00381    typedef short yysigned_char;
00382 #endif
00383 
00384 /* YYFINAL -- State number of the termination state. */
00385 #define YYFINAL  7
00386 /* YYLAST -- Last index in YYTABLE.  */
00387 #define YYLAST   556
00388 
00389 /* YYNTOKENS -- Number of terminals. */
00390 #define YYNTOKENS  66
00391 /* YYNNTS -- Number of nonterminals. */
00392 #define YYNNTS  53
00393 /* YYNRULES -- Number of rules. */
00394 #define YYNRULES  182
00395 /* YYNRULES -- Number of states. */
00396 #define YYNSTATES  369
00397 
00398 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00399 #define YYUNDEFTOK  2
00400 #define YYMAXUTOK   320
00401 
00402 #define YYTRANSLATE(YYX)                        \
00403   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00404 
00405 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00406 static const unsigned char yytranslate[] =
00407 {
00408        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00409        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00410        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00411        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00412        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00413        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00414        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00415        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00416        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00417        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00418        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00419        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00420        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00421        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00422        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00423        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00424        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00425        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00426        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00427        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00428        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00429        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00430        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00431        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00432        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00433        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00434        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00435       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
00436       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
00437       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
00438       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
00439       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
00440       65
00441 };
00442 
00443 #if YYDEBUG
00444 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00445    YYRHS.  */
00446 static const unsigned short yyprhs[] =
00447 {
00448        0,     0,     3,     7,     8,    11,    16,    17,    19,    20,
00449       27,    35,    39,    43,    49,    50,    58,    63,    69,    72,
00450       77,    85,    94,    97,    99,   101,   103,   106,   107,   109,
00451      111,   113,   115,   117,   119,   121,   122,   126,   129,   132,
00452      135,   137,   141,   143,   148,   152,   154,   157,   161,   164,
00453      166,   167,   169,   171,   174,   178,   181,   184,   187,   190,
00454      193,   196,   202,   207,   212,   217,   224,   229,   236,   243,
00455      251,   258,   265,   271,   275,   277,   281,   283,   285,   287,
00456      290,   292,   294,   296,   300,   304,   312,   322,   323,   325,
00457      327,   330,   332,   335,   338,   342,   345,   349,   352,   356,
00458      359,   363,   365,   367,   370,   372,   375,   377,   380,   383,
00459      386,   388,   389,   391,   395,   397,   399,   402,   405,   410,
00460      417,   421,   423,   426,   428,   432,   436,   439,   442,   444,
00461      447,   451,   453,   457,   460,   462,   463,   466,   472,   474,
00462      476,   478,   480,   485,   486,   488,   490,   492,   494,   496,
00463      498,   505,   513,   515,   519,   520,   525,   527,   531,   534,
00464      540,   544,   550,   558,   565,   569,   571,   573,   577,   582,
00465      585,   586,   588,   591,   592,   594,   598,   601,   604,   608,
00466      614,   620,   626
00467 };
00468 
00469 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
00470 static const yysigned_char yyrhs[] =
00471 {
00472       67,     0,    -1,    68,    70,    67,    -1,    -1,     8,    68,
00473       -1,    38,    11,    67,    13,    -1,    -1,    56,    -1,    -1,
00474        9,    79,    83,    69,    85,    16,    -1,     9,     5,    79,
00475       83,    69,    85,    16,    -1,     9,    79,    16,    -1,    10,
00476       79,    16,    -1,    10,    79,    83,    85,    16,    -1,    -1,
00477       41,     5,    11,    71,    67,    13,    84,    -1,    42,    41,
00478        5,    16,    -1,    42,     5,    50,     5,    16,    -1,    37,
00479       16,    -1,    28,    99,    79,    16,    -1,    28,    10,    11,
00480       72,    13,    79,    16,    -1,    28,    10,    79,    11,    72,
00481       13,    79,    16,    -1,    23,   110,    -1,   110,    -1,   118,
00482       -1,    86,    -1,   118,    72,    -1,    -1,    45,    -1,    46,
00483       -1,    20,    -1,    18,    -1,    17,    -1,    26,    -1,    27,
00484       -1,    -1,    74,    75,    15,    -1,    75,    15,    -1,    57,
00485       15,    -1,    58,    15,    -1,     5,    -1,     5,    50,    79,
00486       -1,    79,    -1,    79,    34,   100,    35,    -1,   104,    17,
00487       80,    -1,    80,    -1,    81,    11,    -1,    81,    31,    82,
00488       -1,    15,    82,    -1,    11,    -1,    -1,    16,    -1,    13,
00489       -1,    91,    85,    -1,    23,   110,    85,    -1,   110,    85,
00490       -1,    78,    85,    -1,    86,    85,    -1,    77,    85,    -1,
00491       76,    85,    -1,   118,    85,    -1,    24,     9,    79,    16,
00492       85,    -1,    24,    79,    16,    85,    -1,    24,   106,    16,
00493       85,    -1,     9,    79,    16,    85,    -1,     9,    79,    83,
00494       85,    16,    85,    -1,    10,    79,    16,    85,    -1,    10,
00495       79,    83,    85,    16,    85,    -1,    42,     5,    50,     5,
00496       16,    85,    -1,    40,     5,    11,    87,    13,     5,    16,
00497       -1,    40,     5,    11,    87,    13,    16,    -1,    40,    11,
00498       87,    13,     5,    16,    -1,    40,    11,    87,    13,    16,
00499       -1,    88,    31,    87,    -1,    88,    -1,     5,    49,    90,
00500       -1,     5,    -1,     3,    -1,     6,    -1,    30,     6,    -1,
00501       51,    -1,    79,    -1,    89,    -1,    89,    29,    89,    -1,
00502       89,    65,    89,    -1,    28,    79,    34,   100,    35,    79,
00503       16,    -1,    28,    79,    34,   100,    35,    50,     5,    79,
00504       16,    -1,    -1,    22,    -1,    59,    -1,    59,    52,    -1,
00505       60,    -1,    60,    52,    -1,    59,    62,    -1,    59,    62,
00506       52,    -1,    59,    61,    -1,    59,    61,    52,    -1,    60,
00507       62,    -1,    60,    62,    52,    -1,    60,    61,    -1,    60,
00508       61,    52,    -1,    52,    -1,    61,    -1,    61,    52,    -1,
00509       62,    -1,    62,    52,    -1,    55,    -1,    59,    55,    -1,
00510       60,    55,    -1,    32,    94,    -1,    32,    -1,    -1,   101,
00511       -1,    95,    31,   101,    -1,    93,    -1,    79,    -1,    10,
00512       79,    -1,     9,    79,    -1,    79,    34,    97,    35,    -1,
00513       79,    34,    97,    35,    50,    79,    -1,    98,    31,    97,
00514       -1,    98,    -1,    96,    94,    -1,    96,    -1,    22,    96,
00515       94,    -1,    22,    96,    36,    -1,    22,    96,    -1,    96,
00516       36,    -1,    96,    -1,    96,    94,    -1,    99,    31,   100,
00517       -1,    99,    -1,    99,    79,   102,    -1,    99,   102,    -1,
00518       44,    -1,    -1,    49,   103,    -1,    49,    12,    99,    14,
00519      103,    -1,     7,    -1,    90,    -1,     4,    -1,    73,    -1,
00520       79,    12,    95,    14,    -1,    -1,    21,    -1,    64,    -1,
00521       65,    -1,    35,    -1,    34,    -1,    49,    -1,    99,    79,
00522       12,    95,    14,    92,    -1,    99,    63,   105,    12,    95,
00523       14,    92,    -1,   103,    -1,   103,    31,   107,    -1,    -1,
00524        5,    12,   107,    14,    -1,   108,    -1,   108,    31,   109,
00525       -1,   106,   112,    -1,    21,   106,    49,    51,   112,    -1,
00526       21,   106,   112,    -1,    79,    12,    95,    14,   112,    -1,
00527       79,    12,    95,    14,    15,   109,   112,    -1,   104,    33,
00528       79,    12,    14,   112,    -1,    47,   106,   112,    -1,    11,
00529       -1,    16,    -1,   111,   113,    13,    -1,   111,   113,    13,
00530       16,    -1,   114,   113,    -1,    -1,    16,    -1,    31,   117,
00531       -1,    -1,     5,    -1,     5,    49,   103,    -1,    94,     5,
00532       -1,   116,   115,    -1,    99,   117,    16,    -1,    99,    79,
00533       15,     6,    16,    -1,    47,    99,     5,   102,    16,    -1,
00534       48,    99,     5,   102,    16,    -1,    99,     5,    53,    90,
00535       54,    16,    -1
00536 };
00537 
00538 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00539 static const unsigned short yyrline[] =
00540 {
00541        0,   163,   163,   166,   170,   174,   178,   183,   184,   188,
00542      197,   206,   209,   212,   216,   215,   227,   230,   233,   236,
00543      239,   242,   245,   248,   251,   254,   260,   261,   264,   264,
00544      266,   266,   266,   268,   268,   268,   271,   276,   284,   292,
00545      304,   307,   315,   321,   330,   334,   341,   345,   353,   357,
00546      365,   367,   371,   375,   379,   383,   387,   391,   395,   399,
00547      403,   407,   411,   415,   419,   423,   427,   431,   435,   442,
00548      443,   444,   445,   449,   450,   454,   455,   459,   460,   461,
00549      462,   463,   467,   468,   469,   473,   483,   492,   495,   502,
00550      503,   504,   505,   506,   507,   508,   509,   510,   511,   512,
00551      513,   514,   515,   516,   517,   518,   519,   520,   521,   525,
00552      526,   531,   534,   535,   543,   544,   545,   546,   547,   553,
00553      564,   568,   576,   581,   590,   595,   602,   607,   612,   617,
00554      625,   629,   636,   645,   653,   663,   665,   668,   675,   678,
00555      681,   684,   687,   693,   694,   698,   698,   698,   698,   698,
00556      702,   724,   735,   736,   737,   742,   747,   748,   752,   756,
00557      760,   764,   770,   776,   782,   795,   802,   803,   804,   808,
00558      809,   813,   817,   818,   821,   822,   823,   826,   830,   831,
00559      832,   833,   834
00560 };
00561 #endif
00562 
00563 #if YYDEBUG || YYERROR_VERBOSE
00564 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00565    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
00566 static const char *const yytname[] =
00567 {
00568   "$end", "error", "$undefined", "T_CHARACTER_LITERAL", "T_DOUBLE_LITERAL", 
00569   "T_IDENTIFIER", "T_INTEGER_LITERAL", "T_STRING_LITERAL", "T_INCLUDE", 
00570   "T_CLASS", "T_STRUCT", "T_LEFT_CURLY_BRACKET", "T_LEFT_PARANTHESIS", 
00571   "T_RIGHT_CURLY_BRACKET", "T_RIGHT_PARANTHESIS", "T_COLON", 
00572   "T_SEMICOLON", "T_PUBLIC", "T_PROTECTED", "T_TRIPE_DOT", "T_PRIVATE", 
00573   "T_VIRTUAL", "T_CONST", "T_INLINE", "T_FRIEND", "T_RETURN", "T_SIGNAL", 
00574   "T_SLOT", "T_TYPEDEF", "T_PLUS", "T_MINUS", "T_COMMA", "T_ASTERISK", 
00575   "T_TILDE", "T_LESS", "T_GREATER", "T_AMPERSAND", "T_EXTERN", 
00576   "T_EXTERN_C", "T_ACCESS", "T_ENUM", "T_NAMESPACE", "T_USING", 
00577   "T_UNKNOWN", "T_TRIPLE_DOT", "T_TRUE", "T_FALSE", "T_STATIC", 
00578   "T_MUTABLE", "T_EQUAL", "T_SCOPE", "T_NULL", "T_INT", "T_ARRAY_OPEN", 
00579   "T_ARRAY_CLOSE", "T_CHAR", "T_DCOP", "T_DCOP_AREA", 
00580   "T_DCOP_SIGNAL_AREA", "T_SIGNED", "T_UNSIGNED", "T_LONG", "T_SHORT", 
00581   "T_FUNOPERATOR", "T_MISCOPERATOR", "T_SHIFT", "$accept", "main", 
00582   "includes", "dcoptag", "declaration", "@1", "member_list", "bool_value", 
00583   "nodcop_area", "sigslot", "nodcop_area_begin", "dcop_area_begin", 
00584   "dcop_signal_area_begin", "Identifier", "super_class_name", 
00585   "super_class", "super_classes", "class_header", "opt_semicolon", "body", 
00586   "enum", "enum_list", "enum_item", "number", "int_expression", "typedef", 
00587   "const_qualifier", "int_type", "asterisks", "params", "type_name", 
00588   "templ_type_list", "templ_type", "type", "type_list", "param", 
00589   "default", "value", "virtual_qualifier", "operator", "function_header", 
00590   "values", "init_item", "init_list", "function", "function_begin", 
00591   "function_body", "function_lines", "function_line", 
00592   "Identifier_list_rest", "Identifier_list_entry", "Identifier_list", 
00593   "member", 0
00594 };
00595 #endif
00596 
00597 # ifdef YYPRINT
00598 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00599    token YYLEX-NUM.  */
00600 static const unsigned short yytoknum[] =
00601 {
00602        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00603      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
00604      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
00605      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
00606      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
00607      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
00608      315,   316,   317,   318,   319,   320
00609 };
00610 # endif
00611 
00612 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00613 static const unsigned char yyr1[] =
00614 {
00615        0,    66,    67,    67,    68,    68,    68,    69,    69,    70,
00616       70,    70,    70,    70,    71,    70,    70,    70,    70,    70,
00617       70,    70,    70,    70,    70,    70,    72,    72,    73,    73,
00618       74,    74,    74,    75,    75,    75,    76,    76,    77,    78,
00619       79,    79,    80,    80,    81,    81,    82,    82,    83,    83,
00620       84,    84,    85,    85,    85,    85,    85,    85,    85,    85,
00621       85,    85,    85,    85,    85,    85,    85,    85,    85,    86,
00622       86,    86,    86,    87,    87,    88,    88,    89,    89,    89,
00623       89,    89,    90,    90,    90,    91,    91,    92,    92,    93,
00624       93,    93,    93,    93,    93,    93,    93,    93,    93,    93,
00625       93,    93,    93,    93,    93,    93,    93,    93,    93,    94,
00626       94,    95,    95,    95,    96,    96,    96,    96,    96,    96,
00627       97,    97,    98,    98,    99,    99,    99,    99,    99,    99,
00628      100,   100,   101,   101,   101,   102,   102,   102,   103,   103,
00629      103,   103,   103,   104,   104,   105,   105,   105,   105,   105,
00630      106,   106,   107,   107,   107,   108,   109,   109,   110,   110,
00631      110,   110,   110,   110,   110,   111,   112,   112,   112,   113,
00632      113,   114,   115,   115,   116,   116,   116,   117,   118,   118,
00633      118,   118,   118
00634 };
00635 
00636 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00637 static const unsigned char yyr2[] =
00638 {
00639        0,     2,     3,     0,     2,     4,     0,     1,     0,     6,
00640        7,     3,     3,     5,     0,     7,     4,     5,     2,     4,
00641        7,     8,     2,     1,     1,     1,     2,     0,     1,     1,
00642        1,     1,     1,     1,     1,     0,     3,     2,     2,     2,
00643        1,     3,     1,     4,     3,     1,     2,     3,     2,     1,
00644        0,     1,     1,     2,     3,     2,     2,     2,     2,     2,
00645        2,     5,     4,     4,     4,     6,     4,     6,     6,     7,
00646        6,     6,     5,     3,     1,     3,     1,     1,     1,     2,
00647        1,     1,     1,     3,     3,     7,     9,     0,     1,     1,
00648        2,     1,     2,     2,     3,     2,     3,     2,     3,     2,
00649        3,     1,     1,     2,     1,     2,     1,     2,     2,     2,
00650        1,     0,     1,     3,     1,     1,     2,     2,     4,     6,
00651        3,     1,     2,     1,     3,     3,     2,     2,     1,     2,
00652        3,     1,     3,     2,     1,     0,     2,     5,     1,     1,
00653        1,     1,     4,     0,     1,     1,     1,     1,     1,     1,
00654        6,     7,     1,     3,     0,     4,     1,     3,     2,     5,
00655        3,     5,     7,     6,     3,     1,     1,     3,     4,     2,
00656        0,     1,     2,     0,     1,     3,     2,     2,     3,     5,
00657        5,     5,     6
00658 };
00659 
00660 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00661    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
00662    means the default is an error.  */
00663 static const unsigned char yydefact[] =
00664 {
00665        6,     6,     0,     0,   143,     4,     6,     1,    40,     0,
00666        0,   144,     0,   143,     0,     0,     0,     0,     0,     0,
00667        0,   101,   106,    89,    91,   102,   104,     6,   115,    25,
00668      114,   128,     0,     0,     0,    23,    24,     0,     0,    40,
00669      117,   116,     0,     0,   115,     0,     0,   126,     0,    22,
00670        0,     0,    18,     0,     0,     0,     0,     0,     0,     0,
00671        0,    90,   107,    95,    93,    92,   108,    99,    97,   103,
00672      105,     2,   111,     0,   110,   127,   129,    40,     0,     0,
00673        0,   173,     0,     0,   165,   166,   170,   158,     5,    41,
00674        0,    49,   143,    11,     8,    12,    35,   117,   116,     0,
00675        0,   160,   125,   124,    27,   116,     0,     0,    76,     0,
00676       74,    14,     0,     0,    40,   164,   135,    96,    94,   100,
00677       98,   134,     0,   135,   112,   123,     0,   121,   109,     0,
00678        0,   148,   147,   149,   145,   146,     0,   111,     0,   176,
00679        0,   177,   178,     0,   171,     0,   170,     8,   144,    42,
00680       45,     0,    48,     0,     7,    35,     0,     0,    52,    32,
00681       31,    30,   143,     0,    33,    34,     0,     0,     0,     0,
00682       35,     0,    35,    35,    35,     0,    35,    35,    35,    35,
00683        0,     0,     0,     0,    27,    27,    19,     0,     0,     0,
00684        0,     6,     0,    16,     0,     0,     0,     0,     0,   135,
00685      133,   122,   118,     0,    77,   140,    78,   138,     0,    28,
00686       29,    80,   141,    81,    82,   139,   175,    81,     0,   111,
00687        0,     0,   174,   172,     0,   167,   169,    35,     0,    46,
00688      143,     0,     0,   117,   116,    35,     0,   115,     0,     0,
00689        0,    38,    39,     0,    37,    59,    58,    56,    13,    57,
00690       53,    55,    60,   159,     0,     0,     0,    26,     0,     0,
00691       75,     0,    72,    73,     0,    17,     0,   136,   180,   181,
00692        0,   161,   113,   132,     0,   120,    79,   111,     0,     0,
00693        0,     0,    87,   179,     0,   168,     0,   131,     0,    47,
00694       44,     9,    35,    35,    35,    35,    54,   117,    35,    35,
00695        0,     0,    36,   135,     0,     0,     0,    70,    71,    50,
00696        0,     0,   156,     0,   119,     0,    83,    84,   182,    87,
00697       88,   150,   163,    10,     0,    43,    64,     0,    66,     0,
00698       35,    62,    63,     0,     0,    20,     0,    69,    51,    15,
00699        0,   154,     0,   162,   142,   151,   130,    35,    35,    61,
00700        0,    35,    21,   137,   152,     0,   157,    65,    67,     0,
00701        0,    68,   154,   155,     0,    85,   153,     0,    86
00702 };
00703 
00704 /* YYDEFGOTO[NTERM-NUM]. */
00705 static const short yydefgoto[] =
00706 {
00707       -1,     3,     4,   155,    27,   191,   182,   212,   170,   171,
00708      172,   173,   174,    28,   150,   151,   152,    94,   339,   175,
00709      176,   109,   110,   214,   215,   177,   321,    30,    80,   122,
00710       31,   126,   127,    32,   288,   124,   195,   354,    33,   136,
00711       34,   355,   312,   313,   178,    86,    87,   145,   146,   141,
00712       81,    82,   179
00713 };
00714 
00715 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00716    STATE-NUM.  */
00717 #define YYPACT_NINF -185
00718 static const short yypact[] =
00719 {
00720       99,    95,    89,   145,   219,  -185,   121,  -185,    92,   165,
00721      179,   391,   435,   103,   405,   136,   172,   203,    46,   391,
00722      391,  -185,  -185,   232,   237,   174,   185,    98,   107,  -185,
00723     -185,   182,    30,   190,   177,  -185,  -185,   225,   179,    41,
00724      228,   247,   179,   179,   214,    22,    37,   213,   391,  -185,
00725      175,   179,  -185,   241,   250,   253,   226,   270,    33,   177,
00726      280,  -185,  -185,   234,   236,  -185,  -185,   238,   243,  -185,
00727     -185,  -185,   376,   435,   277,  -185,  -185,    73,   171,   120,
00728      305,   281,   295,   179,  -185,  -185,   297,  -185,  -185,  -185,
00729      262,  -185,    47,  -185,   258,  -185,   316,  -185,  -185,   304,
00730      266,  -185,  -185,  -185,   357,   307,   303,   250,   271,   309,
00731      293,  -185,   318,   311,    21,  -185,   279,  -185,  -185,  -185,
00732     -185,  -185,   125,    45,  -185,   277,   300,   314,  -185,   505,
00733       54,  -185,  -185,  -185,  -185,  -185,   334,   376,   341,  -185,
00734       85,  -185,  -185,   336,  -185,   337,   297,   258,  -185,   317,
00735     -185,   142,  -185,   335,  -185,   316,   179,   179,  -185,  -185,
00736     -185,  -185,   103,   420,  -185,  -185,   179,   349,   342,   344,
00737      155,   345,   316,   316,   316,   353,   316,   316,   316,   316,
00738      177,   391,   348,   139,   357,   357,  -185,   352,    54,    50,
00739      250,   121,   354,  -185,   495,   356,   364,   286,   376,   279,
00740     -185,  -185,   332,   435,  -185,  -185,  -185,  -185,   377,  -185,
00741     -185,  -185,  -185,   372,    36,  -185,  -185,  -185,   333,   376,
00742      147,   373,   339,  -185,   378,   374,  -185,   316,   391,  -185,
00743       47,   179,   375,   289,   292,   316,   179,    93,   379,   359,
00744      347,  -185,  -185,   384,  -185,  -185,  -185,  -185,  -185,  -185,
00745     -185,  -185,  -185,  -185,   389,   179,   387,  -185,   390,    56,
00746     -185,   392,  -185,  -185,   393,  -185,   391,  -185,  -185,  -185,
00747      402,  -185,  -185,  -185,   179,  -185,  -185,   376,    54,    54,
00748      395,   178,   399,  -185,   177,  -185,   406,   401,   388,  -185,
00749     -185,  -185,   316,   316,   316,   316,  -185,   408,   316,   316,
00750      391,   421,  -185,   279,   417,   179,   418,  -185,  -185,   423,
00751      427,   436,   416,   177,  -185,   199,  -185,  -185,  -185,   399,
00752     -185,  -185,  -185,  -185,   391,  -185,  -185,   433,  -185,   438,
00753      316,  -185,  -185,   424,   439,  -185,   440,  -185,  -185,  -185,
00754      505,   505,   402,  -185,  -185,  -185,  -185,   316,   316,  -185,
00755       42,   316,  -185,  -185,   430,   444,  -185,  -185,  -185,   457,
00756      447,  -185,   505,  -185,   179,  -185,  -185,   452,  -185
00757 };
00758 
00759 /* YYPGOTO[NTERM-NUM].  */
00760 static const short yypgoto[] =
00761 {
00762     -185,    16,   468,   323,  -185,  -185,    32,  -185,  -185,   301,
00763     -185,  -185,  -185,    -9,   242,  -185,   244,   -34,  -185,   -97,
00764      472,   -75,  -185,   -47,   -86,  -185,   158,  -185,    -7,  -131,
00765        0,   275,  -185,     6,  -184,   285,  -102,  -125,   -79,  -185,
00766       -3,   122,  -185,   143,     5,  -185,   -31,   340,  -185,  -185,
00767     -185,   351,    27
00768 };
00769 
00770 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00771    positive, shift that token.  If negative, reduce the rule which
00772    number is the opposite.  If zero, do what YYDEFACT says.
00773    If YYTABLE_NINF, syntax error.  */
00774 #define YYTABLE_NINF -175
00775 static const short yytable[] =
00776 {
00777       40,    41,    44,    44,   216,    44,   220,    96,    46,    35,
00778       44,    44,    47,   153,   196,   101,    59,    45,    49,    45,
00779       51,   200,    37,    79,    76,    58,    60,     8,   115,    89,
00780       90,    36,   187,    97,    98,    77,    99,  -135,   114,    44,
00781      103,   105,   106,    71,   218,    59,     8,     8,    84,    99,
00782        8,    56,     8,    85,    45,   261,   147,   204,   232,     8,
00783      206,   306,    74,    44,    44,   278,   262,   128,   148,   267,
00784      194,    38,   307,   125,   143,   245,   246,   247,   123,   249,
00785      250,   251,   252,   149,   208,    78,   100,    57,   281,  -174,
00786      222,    38,   359,    78,   194,    44,    78,   273,    -3,    -3,
00787        6,   279,   260,     1,  -174,   211,     1,     1,     8,   298,
00788      183,    -3,    42,    43,   199,   263,   333,    74,   201,    72,
00789      213,   217,   129,    38,    11,    12,   130,    73,    44,     1,
00790      286,   184,   137,     2,    -3,   138,     2,     2,   296,   197,
00791      346,    73,    38,   123,    77,     7,   315,   233,   234,   253,
00792       48,   153,    52,   229,   237,    21,   198,   239,    22,     2,
00793      238,   282,    23,    24,    25,    26,   271,   235,    45,    45,
00794       39,    74,    44,   230,   256,    44,    44,    53,   198,   217,
00795        8,   164,   165,    54,     8,   213,   104,   254,    84,    44,
00796      183,   183,   319,    85,    44,   326,   327,   328,   329,   293,
00797      295,   331,   332,   125,   123,   131,   132,   264,    55,   198,
00798       44,   184,   184,   344,    74,   353,   257,   258,    75,    44,
00799      133,   149,   149,    83,     8,   123,    69,   297,     9,    10,
00800      198,   316,   317,   349,   287,   134,   135,    70,    88,    91,
00801       11,    12,    13,    92,    93,    74,   304,    14,    73,   102,
00802      357,   358,   107,   322,   361,   108,    15,    44,    91,    16,
00803       17,    18,    92,    95,   111,   314,    19,    20,    44,   217,
00804      217,    21,   310,    91,    22,   113,   112,    92,    23,    24,
00805       25,    26,   343,   123,    61,   116,   117,    62,   118,    65,
00806      119,    44,    66,    63,    64,   120,   336,    84,    67,    68,
00807       91,   270,    85,    91,    92,   292,   287,    92,   294,    74,
00808      139,   142,   140,   144,   154,    44,   137,   180,   185,   186,
00809      188,     8,   189,   192,   190,   156,   157,   193,   194,   158,
00810      287,   213,   213,   159,   160,   202,   161,    11,    12,   162,
00811      163,   360,   164,   165,   166,   203,   219,   221,   224,  -143,
00812      225,   228,   231,   213,   240,   367,    16,   241,   167,   242,
00813      244,   255,     8,    19,    20,   259,    42,    43,    21,   248,
00814      265,    22,   268,   168,   169,    23,    24,    25,    26,    12,
00815      269,     8,   274,   276,   277,    42,    43,   280,   129,   283,
00816      285,   291,   284,   300,   303,   299,     8,   301,    12,   302,
00817       42,    43,   138,   305,   181,    20,   309,   311,   308,    21,
00818        8,   318,    22,    12,    42,    50,    23,    24,    25,    26,
00819      121,   320,   323,   325,   330,     8,   334,    12,    21,   236,
00820       43,    22,   324,   335,   337,    23,    24,    25,    26,   338,
00821        8,   340,    12,    21,    42,    43,    22,   342,   341,   347,
00822       23,    24,    25,    26,   348,   351,   352,    21,   363,   350,
00823       22,   362,   364,   365,    23,    24,    25,    26,   368,     5,
00824      227,   243,    21,   290,   289,    22,    29,   345,   275,    23,
00825       24,    25,    26,   272,   366,   356,   226,    21,     0,     0,
00826       22,   223,     0,     0,    23,    24,    25,    26,   204,   205,
00827        8,   206,   207,     0,     0,     0,     0,   266,   204,   205,
00828        8,   206,   207,     0,     0,     0,     0,     0,     0,     0,
00829        0,     0,     0,     0,     0,   208,     0,     0,     0,     0,
00830        0,     0,     0,     0,     0,   208,     0,     0,     0,     0,
00831      209,   210,     0,     0,     0,     0,   211,     0,     0,     0,
00832      209,   210,     0,     0,     0,     0,   211
00833 };
00834 
00835 static const short yycheck[] =
00836 {
00837        9,    10,    11,    12,   129,    14,   137,    41,    11,     4,
00838       19,    20,    12,    92,   116,    46,    19,    11,    13,    13,
00839       14,   123,     6,    32,    31,    19,    20,     5,    59,    38,
00840       39,     4,   107,    42,    43,     5,    45,    16,     5,    48,
00841       47,    50,    51,    27,   130,    48,     5,     5,    11,    58,
00842        5,     5,     5,    16,    48,     5,    90,     3,   155,     5,
00843        6,     5,    32,    72,    73,    29,    16,    74,    21,   194,
00844       49,    50,    16,    73,    83,   172,   173,   174,    72,   176,
00845      177,   178,   179,    92,    30,    63,    49,    41,   219,    16,
00846        5,    50,    50,    63,    49,   104,    63,   199,     0,     0,
00847       11,    65,   188,     8,    31,    51,     8,     8,     5,    16,
00848      104,    13,     9,    10,   123,   190,   300,    32,   125,    12,
00849      129,   130,    49,    50,    21,    22,    53,    34,   137,     8,
00850      227,   104,    12,    38,    13,    15,    38,    38,   235,    14,
00851      324,    34,    50,   137,     5,     0,   277,   156,   157,   180,
00852       47,   230,    16,    11,   163,    52,    31,   166,    55,    38,
00853      163,    14,    59,    60,    61,    62,   197,   162,   162,   163,
00854        5,    32,   181,    31,   183,   184,   185,     5,    31,   188,
00855        5,    26,    27,    11,     5,   194,    11,   181,    11,   198,
00856      184,   185,    14,    16,   203,   292,   293,   294,   295,   233,
00857      234,   298,   299,   203,   198,    34,    35,   191,     5,    31,
00858      219,   184,   185,    14,    32,   340,   184,   185,    36,   228,
00859       49,   230,   231,    33,     5,   219,    52,   236,     9,    10,
00860       31,   278,   279,   330,   228,    64,    65,    52,    13,    11,
00861       21,    22,    23,    15,    16,    32,   255,    28,    34,    36,
00862      347,   348,    11,   284,   351,     5,    37,   266,    11,    40,
00863       41,    42,    15,    16,    11,   274,    47,    48,   277,   278,
00864      279,    52,   266,    11,    55,     5,    50,    15,    59,    60,
00865       61,    62,   313,   277,    52,     5,    52,    55,    52,    52,
00866       52,   300,    55,    61,    62,    52,   305,    11,    61,    62,
00867       11,    15,    16,    11,    15,    16,   300,    15,    16,    32,
00868        5,    16,    31,    16,    56,   324,    12,    51,    11,    16,
00869       49,     5,    13,     5,    31,     9,    10,    16,    49,    13,
00870      324,   340,   341,    17,    18,    35,    20,    21,    22,    23,
00871       24,   350,    26,    27,    28,    31,    12,     6,    12,    33,
00872       13,    34,    17,   362,     5,   364,    40,    15,    42,    15,
00873       15,    13,     5,    47,    48,    13,     9,    10,    52,    16,
00874       16,    55,    16,    57,    58,    59,    60,    61,    62,    22,
00875       16,     5,    50,     6,    12,     9,    10,    54,    49,    16,
00876       16,    16,    14,    34,     5,    16,     5,    50,    22,    15,
00877        9,    10,    15,    13,    47,    48,    13,     5,    16,    52,
00878        5,    16,    55,    22,     9,    10,    59,    60,    61,    62,
00879       44,    22,    16,    35,    16,     5,     5,    22,    52,     9,
00880       10,    55,    31,    16,    16,    59,    60,    61,    62,    16,
00881        5,    14,    22,    52,     9,    10,    55,    31,    12,    16,
00882       59,    60,    61,    62,    16,    16,    16,    52,    14,    35,
00883       55,    31,     5,    16,    59,    60,    61,    62,    16,     1,
00884      147,   170,    52,   231,   230,    55,     4,   319,   203,    59,
00885       60,    61,    62,   198,   362,   342,   146,    52,    -1,    -1,
00886       55,   140,    -1,    -1,    59,    60,    61,    62,     3,     4,
00887        5,     6,     7,    -1,    -1,    -1,    -1,    12,     3,     4,
00888        5,     6,     7,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00889       -1,    -1,    -1,    -1,    -1,    30,    -1,    -1,    -1,    -1,
00890       -1,    -1,    -1,    -1,    -1,    30,    -1,    -1,    -1,    -1,
00891       45,    46,    -1,    -1,    -1,    -1,    51,    -1,    -1,    -1,
00892       45,    46,    -1,    -1,    -1,    -1,    51
00893 };
00894 
00895 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00896    symbol of state STATE-NUM.  */
00897 static const unsigned char yystos[] =
00898 {
00899        0,     8,    38,    67,    68,    68,    11,     0,     5,     9,
00900       10,    21,    22,    23,    28,    37,    40,    41,    42,    47,
00901       48,    52,    55,    59,    60,    61,    62,    70,    79,    86,
00902       93,    96,    99,   104,   106,   110,   118,    67,    50,     5,
00903       79,    79,     9,    10,    79,    99,   106,    96,    47,   110,
00904       10,    99,    16,     5,    11,     5,     5,    41,    99,   106,
00905       99,    52,    55,    61,    62,    52,    55,    61,    62,    52,
00906       52,    67,    12,    34,    32,    36,    94,     5,    63,    79,
00907       94,   116,   117,    33,    11,    16,   111,   112,    13,    79,
00908       79,    11,    15,    16,    83,    16,    83,    79,    79,    79,
00909       49,   112,    36,    94,    11,    79,    79,    11,     5,    87,
00910       88,    11,    50,     5,     5,   112,     5,    52,    52,    52,
00911       52,    44,    95,    99,   101,    96,    97,    98,    94,    49,
00912       53,    34,    35,    49,    64,    65,   105,    12,    15,     5,
00913       31,   115,    16,    79,    16,   113,   114,    83,    21,    79,
00914       80,    81,    82,   104,    56,    69,     9,    10,    13,    17,
00915       18,    20,    23,    24,    26,    27,    28,    42,    57,    58,
00916       74,    75,    76,    77,    78,    85,    86,    91,   110,   118,
00917       51,    47,    72,    99,   118,    11,    16,    87,    49,    13,
00918       31,    71,     5,    16,    49,   102,   102,    14,    31,    79,
00919      102,    94,    35,    31,     3,     4,     6,     7,    30,    45,
00920       46,    51,    73,    79,    89,    90,   103,    79,    90,    12,
00921       95,     6,     5,   117,    12,    13,   113,    69,    34,    11,
00922       31,    17,    85,    79,    79,   110,     9,    79,   106,    79,
00923        5,    15,    15,    75,    15,    85,    85,    85,    16,    85,
00924       85,    85,    85,   112,    99,    13,    79,    72,    72,    13,
00925       90,     5,    16,    87,    67,    16,    12,   103,    16,    16,
00926       15,   112,   101,   102,    50,    97,     6,    12,    29,    65,
00927       54,    95,    14,    16,    14,    16,    85,    99,   100,    82,
00928       80,    16,    16,    83,    16,    83,    85,    79,    16,    16,
00929       34,    50,    15,     5,    79,    13,     5,    16,    16,    13,
00930       99,     5,   108,   109,    79,    95,    89,    89,    16,    14,
00931       22,    92,   112,    16,    31,    35,    85,    85,    85,    85,
00932       16,    85,    85,   100,     5,    16,    79,    16,    16,    84,
00933       14,    12,    31,   112,    14,    92,   100,    16,    16,    85,
00934       35,    16,    16,   103,   103,   107,   109,    85,    85,    50,
00935       79,    85,    31,    14,     5,    16,   107,    79,    16
00936 };
00937 
00938 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
00939 # define YYSIZE_T __SIZE_TYPE__
00940 #endif
00941 #if ! defined (YYSIZE_T) && defined (size_t)
00942 # define YYSIZE_T size_t
00943 #endif
00944 #if ! defined (YYSIZE_T)
00945 # if defined (__STDC__) || defined (__cplusplus)
00946 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00947 #  define YYSIZE_T size_t
00948 # endif
00949 #endif
00950 #if ! defined (YYSIZE_T)
00951 # define YYSIZE_T unsigned int
00952 #endif
00953 
00954 #define yyerrok     (yyerrstatus = 0)
00955 #define yyclearin   (yychar = YYEMPTY)
00956 #define YYEMPTY     (-2)
00957 #define YYEOF       0
00958 
00959 #define YYACCEPT    goto yyacceptlab
00960 #define YYABORT     goto yyabortlab
00961 #define YYERROR     goto yyerrlab1
00962 
00963 
00964 /* Like YYERROR except do call yyerror.  This remains here temporarily
00965    to ease the transition to the new meaning of YYERROR, for GCC.
00966    Once GCC version 2 has supplanted version 1, this can go.  */
00967 
00968 #define YYFAIL      goto yyerrlab
00969 
00970 #define YYRECOVERING()  (!!yyerrstatus)
00971 
00972 #define YYBACKUP(Token, Value)                  \
00973 do                              \
00974   if (yychar == YYEMPTY && yylen == 1)              \
00975     {                               \
00976       yychar = (Token);                     \
00977       yylval = (Value);                     \
00978       yytoken = YYTRANSLATE (yychar);               \
00979       YYPOPSTACK;                       \
00980       goto yybackup;                        \
00981     }                               \
00982   else                              \
00983     {                               \
00984       yyerror ("syntax error: cannot back up");\
00985       YYERROR;                          \
00986     }                               \
00987 while (0)
00988 
00989 #define YYTERROR    1
00990 #define YYERRCODE   256
00991 
00992 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
00993    are run).  */
00994 
00995 #ifndef YYLLOC_DEFAULT
00996 # define YYLLOC_DEFAULT(Current, Rhs, N)         \
00997   Current.first_line   = Rhs[1].first_line;      \
00998   Current.first_column = Rhs[1].first_column;    \
00999   Current.last_line    = Rhs[N].last_line;       \
01000   Current.last_column  = Rhs[N].last_column;
01001 #endif
01002 
01003 /* YYLEX -- calling `yylex' with the right arguments.  */
01004 
01005 #ifdef YYLEX_PARAM
01006 # define YYLEX yylex (YYLEX_PARAM)
01007 #else
01008 # define YYLEX yylex ()
01009 #endif
01010 
01011 /* Enable debugging if requested.  */
01012 #if YYDEBUG
01013 
01014 # ifndef YYFPRINTF
01015 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
01016 #  define YYFPRINTF fprintf
01017 # endif
01018 
01019 # define YYDPRINTF(Args)            \
01020 do {                        \
01021   if (yydebug)                  \
01022     YYFPRINTF Args;             \
01023 } while (0)
01024 
01025 # define YYDSYMPRINT(Args)          \
01026 do {                        \
01027   if (yydebug)                  \
01028     yysymprint Args;                \
01029 } while (0)
01030 
01031 # define YYDSYMPRINTF(Title, Token, Value, Location)        \
01032 do {                                \
01033   if (yydebug)                          \
01034     {                               \
01035       YYFPRINTF (stderr, "%s ", Title);             \
01036       yysymprint (stderr,                   \
01037                   Token, Value);    \
01038       YYFPRINTF (stderr, "\n");                 \
01039     }                               \
01040 } while (0)
01041 
01042 /*------------------------------------------------------------------.
01043 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
01044 | TOP (cinluded).                                                   |
01045 `------------------------------------------------------------------*/
01046 
01047 #if defined (__STDC__) || defined (__cplusplus)
01048 static void
01049 yy_stack_print (short *bottom, short *top)
01050 #else
01051 static void
01052 yy_stack_print (bottom, top)
01053     short *bottom;
01054     short *top;
01055 #endif
01056 {
01057   YYFPRINTF (stderr, "Stack now");
01058   for (/* Nothing. */; bottom <= top; ++bottom)
01059     YYFPRINTF (stderr, " %d", *bottom);
01060   YYFPRINTF (stderr, "\n");
01061 }
01062 
01063 # define YY_STACK_PRINT(Bottom, Top)                \
01064 do {                                \
01065   if (yydebug)                          \
01066     yy_stack_print ((Bottom), (Top));               \
01067 } while (0)
01068 
01069 
01070 /*------------------------------------------------.
01071 | Report that the YYRULE is going to be reduced.  |
01072 `------------------------------------------------*/
01073 
01074 #if defined (__STDC__) || defined (__cplusplus)
01075 static void
01076 yy_reduce_print (int yyrule)
01077 #else
01078 static void
01079 yy_reduce_print (yyrule)
01080     int yyrule;
01081 #endif
01082 {
01083   int yyi;
01084   unsigned int yylineno = yyrline[yyrule];
01085   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
01086              yyrule - 1, yylineno);
01087   /* Print the symbols being reduced, and their result.  */
01088   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
01089     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
01090   YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
01091 }
01092 
01093 # define YY_REDUCE_PRINT(Rule)      \
01094 do {                    \
01095   if (yydebug)              \
01096     yy_reduce_print (Rule);     \
01097 } while (0)
01098 
01099 /* Nonzero means print parse trace.  It is left uninitialized so that
01100    multiple parsers can coexist.  */
01101 int yydebug;
01102 #else /* !YYDEBUG */
01103 # define YYDPRINTF(Args)
01104 # define YYDSYMPRINT(Args)
01105 # define YYDSYMPRINTF(Title, Token, Value, Location)
01106 # define YY_STACK_PRINT(Bottom, Top)
01107 # define YY_REDUCE_PRINT(Rule)
01108 #endif /* !YYDEBUG */
01109 
01110 
01111 /* YYINITDEPTH -- initial size of the parser's stacks.  */
01112 #ifndef YYINITDEPTH
01113 # define YYINITDEPTH 200
01114 #endif
01115 
01116 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
01117    if the built-in stack extension method is used).
01118 
01119    Do not make this value too large; the results are undefined if
01120    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
01121    evaluated with infinite-precision integer arithmetic.  */
01122 
01123 #if YYMAXDEPTH == 0
01124 # undef YYMAXDEPTH
01125 #endif
01126 
01127 #ifndef YYMAXDEPTH
01128 # define YYMAXDEPTH 10000
01129 #endif
01130 
01131 
01132 
01133 #if YYERROR_VERBOSE
01134 
01135 # ifndef yystrlen
01136 #  if defined (__GLIBC__) && defined (_STRING_H)
01137 #   define yystrlen strlen
01138 #  else
01139 /* Return the length of YYSTR.  */
01140 static YYSIZE_T
01141 #   if defined (__STDC__) || defined (__cplusplus)
01142 yystrlen (const char *yystr)
01143 #   else
01144 yystrlen (yystr)
01145      const char *yystr;
01146 #   endif
01147 {
01148   register const char *yys = yystr;
01149 
01150   while (*yys++ != '\0')
01151     continue;
01152 
01153   return yys - yystr - 1;
01154 }
01155 #  endif
01156 # endif
01157 
01158 # ifndef yystpcpy
01159 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
01160 #   define yystpcpy stpcpy
01161 #  else
01162 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
01163    YYDEST.  */
01164 static char *
01165 #   if defined (__STDC__) || defined (__cplusplus)
01166 yystpcpy (char *yydest, const char *yysrc)
01167 #   else
01168 yystpcpy (yydest, yysrc)
01169      char *yydest;
01170      const char *yysrc;
01171 #   endif
01172 {
01173   register char *yyd = yydest;
01174   register const char *yys = yysrc;
01175 
01176   while ((*yyd++ = *yys++) != '\0')
01177     continue;
01178 
01179   return yyd - 1;
01180 }
01181 #  endif
01182 # endif
01183 
01184 #endif /* !YYERROR_VERBOSE */
01185 
01186 
01187 
01188 #if YYDEBUG
01189 /*--------------------------------.
01190 | Print this symbol on YYOUTPUT.  |
01191 `--------------------------------*/
01192 
01193 #if defined (__STDC__) || defined (__cplusplus)
01194 static void
01195 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
01196 #else
01197 static void
01198 yysymprint (yyoutput, yytype, yyvaluep)
01199     FILE *yyoutput;
01200     int yytype;
01201     YYSTYPE *yyvaluep;
01202 #endif
01203 {
01204   /* Pacify ``unused variable'' warnings.  */
01205   (void) yyvaluep;
01206 
01207   if (yytype < YYNTOKENS)
01208     {
01209       YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
01210 # ifdef YYPRINT
01211       YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
01212 # endif
01213     }
01214   else
01215     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
01216 
01217   switch (yytype)
01218     {
01219       default:
01220         break;
01221     }
01222   YYFPRINTF (yyoutput, ")");
01223 }
01224 
01225 #endif /* ! YYDEBUG */
01226 /*-----------------------------------------------.
01227 | Release the memory associated to this symbol.  |
01228 `-----------------------------------------------*/
01229 
01230 #if defined (__STDC__) || defined (__cplusplus)
01231 static void
01232 yydestruct (int yytype, YYSTYPE *yyvaluep)
01233 #else
01234 static void
01235 yydestruct (yytype, yyvaluep)
01236     int yytype;
01237     YYSTYPE *yyvaluep;
01238 #endif
01239 {
01240   /* Pacify ``unused variable'' warnings.  */
01241   (void) yyvaluep;
01242 
01243   switch (yytype)
01244     {
01245 
01246       default:
01247         break;
01248     }
01249 }
01250 
01251 
01252 /* Prevent warnings from -Wmissing-prototypes.  */
01253 
01254 #ifdef YYPARSE_PARAM
01255 # if defined (__STDC__) || defined (__cplusplus)
01256 int yyparse (void *YYPARSE_PARAM);
01257 # else
01258 int yyparse ();
01259 # endif
01260 #else /* ! YYPARSE_PARAM */
01261 #if defined (__STDC__) || defined (__cplusplus)
01262 int yyparse (void);
01263 #else
01264 int yyparse ();
01265 #endif
01266 #endif /* ! YYPARSE_PARAM */
01267 
01268 
01269 
01270 /* The lookahead symbol.  */
01271 int yychar;
01272 
01273 /* The semantic value of the lookahead symbol.  */
01274 YYSTYPE yylval;
01275 
01276 /* Number of syntax errors so far.  */
01277 int yynerrs;
01278 
01279 
01280 
01281 /*----------.
01282 | yyparse.  |
01283 `----------*/
01284 
01285 #ifdef YYPARSE_PARAM
01286 # if defined (__STDC__) || defined (__cplusplus)
01287 int yyparse (void *YYPARSE_PARAM)
01288 # else
01289 int yyparse (YYPARSE_PARAM)
01290   void *YYPARSE_PARAM;
01291 # endif
01292 #else /* ! YYPARSE_PARAM */
01293 #if defined (__STDC__) || defined (__cplusplus)
01294 int
01295 yyparse (void)
01296 #else
01297 int
01298 yyparse ()
01299 
01300 #endif
01301 #endif
01302 {
01303   
01304   register int yystate;
01305   register int yyn;
01306   int yyresult;
01307   /* Number of tokens to shift before error messages enabled.  */
01308   int yyerrstatus;
01309   /* Lookahead token as an internal (translated) token number.  */
01310   int yytoken = 0;
01311 
01312   /* Three stacks and their tools:
01313      `yyss': related to states,
01314      `yyvs': related to semantic values,
01315      `yyls': related to locations.
01316 
01317      Refer to the stacks thru separate pointers, to allow yyoverflow
01318      to reallocate them elsewhere.  */
01319 
01320   /* The state stack.  */
01321   short yyssa[YYINITDEPTH];
01322   short *yyss = yyssa;
01323   register short *yyssp;
01324 
01325   /* The semantic value stack.  */
01326   YYSTYPE yyvsa[YYINITDEPTH];
01327   YYSTYPE *yyvs = yyvsa;
01328   register YYSTYPE *yyvsp;
01329 
01330 
01331 
01332 #define YYPOPSTACK   (yyvsp--, yyssp--)
01333 
01334   YYSIZE_T yystacksize = YYINITDEPTH;
01335 
01336   /* The variables used to return semantic value and location from the
01337      action routines.  */
01338   YYSTYPE yyval;
01339 
01340 
01341   /* When reducing, the number of symbols on the RHS of the reduced
01342      rule.  */
01343   int yylen;
01344 
01345   YYDPRINTF ((stderr, "Starting parse\n"));
01346 
01347   yystate = 0;
01348   yyerrstatus = 0;
01349   yynerrs = 0;
01350   yychar = YYEMPTY;     /* Cause a token to be read.  */
01351 
01352   /* Initialize stack pointers.
01353      Waste one element of value and location stack
01354      so that they stay on the same level as the state stack.
01355      The wasted elements are never initialized.  */
01356 
01357   yyssp = yyss;
01358   yyvsp = yyvs;
01359 
01360   goto yysetstate;
01361 
01362 /*------------------------------------------------------------.
01363 | yynewstate -- Push a new state, which is found in yystate.  |
01364 `------------------------------------------------------------*/
01365  yynewstate:
01366   /* In all cases, when you get here, the value and location stacks
01367      have just been pushed. so pushing a state here evens the stacks.
01368      */
01369   yyssp++;
01370 
01371  yysetstate:
01372   *yyssp = yystate;
01373 
01374   if (yyss + yystacksize - 1 <= yyssp)
01375     {
01376       /* Get the current used size of the three stacks, in elements.  */
01377       YYSIZE_T yysize = yyssp - yyss + 1;
01378 
01379 #ifdef yyoverflow
01380       {
01381     /* Give user a chance to reallocate the stack. Use copies of
01382        these so that the &'s don't force the real ones into
01383        memory.  */
01384     YYSTYPE *yyvs1 = yyvs;
01385     short *yyss1 = yyss;
01386 
01387 
01388     /* Each stack pointer address is followed by the size of the
01389        data in use in that stack, in bytes.  This used to be a
01390        conditional around just the two extra args, but that might
01391        be undefined if yyoverflow is a macro.  */
01392     yyoverflow ("parser stack overflow",
01393             &yyss1, yysize * sizeof (*yyssp),
01394             &yyvs1, yysize * sizeof (*yyvsp),
01395 
01396             &yystacksize);
01397 
01398     yyss = yyss1;
01399     yyvs = yyvs1;
01400       }
01401 #else /* no yyoverflow */
01402 # ifndef YYSTACK_RELOCATE
01403       goto yyoverflowlab;
01404 # else
01405       /* Extend the stack our own way.  */
01406       if (YYMAXDEPTH <= yystacksize)
01407     goto yyoverflowlab;
01408       yystacksize *= 2;
01409       if (YYMAXDEPTH < yystacksize)
01410     yystacksize = YYMAXDEPTH;
01411 
01412       {
01413     short *yyss1 = yyss;
01414     union yyalloc *yyptr =
01415       (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01416     if (! yyptr)
01417       goto yyoverflowlab;
01418     YYSTACK_RELOCATE (yyss);
01419     YYSTACK_RELOCATE (yyvs);
01420 
01421 #  undef YYSTACK_RELOCATE
01422     if (yyss1 != yyssa)
01423       YYSTACK_FREE (yyss1);
01424       }
01425 # endif
01426 #endif /* no yyoverflow */
01427 
01428       yyssp = yyss + yysize - 1;
01429       yyvsp = yyvs + yysize - 1;
01430 
01431 
01432       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01433           (unsigned long int) yystacksize));
01434 
01435       if (yyss + yystacksize - 1 <= yyssp)
01436     YYABORT;
01437     }
01438 
01439   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01440 
01441   goto yybackup;
01442 
01443 /*-----------.
01444 | yybackup.  |
01445 `-----------*/
01446 yybackup:
01447 
01448 /* Do appropriate processing given the current state.  */
01449 /* Read a lookahead token if we need one and don't already have one.  */
01450 /* yyresume: */
01451 
01452   /* First try to decide what to do without reference to lookahead token.  */
01453 
01454   yyn = yypact[yystate];
01455   if (yyn == YYPACT_NINF)
01456     goto yydefault;
01457 
01458   /* Not known => get a lookahead token if don't already have one.  */
01459 
01460   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
01461   if (yychar == YYEMPTY)
01462     {
01463       YYDPRINTF ((stderr, "Reading a token: "));
01464       yychar = YYLEX;
01465     }
01466 
01467   if (yychar <= YYEOF)
01468     {
01469       yychar = yytoken = YYEOF;
01470       YYDPRINTF ((stderr, "Now at end of input.\n"));
01471     }
01472   else
01473     {
01474       yytoken = YYTRANSLATE (yychar);
01475       YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
01476     }
01477 
01478   /* If the proper action on seeing token YYTOKEN is to reduce or to
01479      detect an error, take that action.  */
01480   yyn += yytoken;
01481   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01482     goto yydefault;
01483   yyn = yytable[yyn];
01484   if (yyn <= 0)
01485     {
01486       if (yyn == 0 || yyn == YYTABLE_NINF)
01487     goto yyerrlab;
01488       yyn = -yyn;
01489       goto yyreduce;
01490     }
01491 
01492   if (yyn == YYFINAL)
01493     YYACCEPT;
01494 
01495   /* Shift the lookahead token.  */
01496   YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
01497 
01498   /* Discard the token being shifted unless it is eof.  */
01499   if (yychar != YYEOF)
01500     yychar = YYEMPTY;
01501 
01502   *++yyvsp = yylval;
01503 
01504 
01505   /* Count tokens shifted since error; after three, turn off error
01506      status.  */
01507   if (yyerrstatus)
01508     yyerrstatus--;
01509 
01510   yystate = yyn;
01511   goto yynewstate;
01512 
01513 
01514 /*-----------------------------------------------------------.
01515 | yydefault -- do the default action for the current state.  |
01516 `-----------------------------------------------------------*/
01517 yydefault:
01518   yyn = yydefact[yystate];
01519   if (yyn == 0)
01520     goto yyerrlab;
01521   goto yyreduce;
01522 
01523 
01524 /*-----------------------------.
01525 | yyreduce -- Do a reduction.  |
01526 `-----------------------------*/
01527 yyreduce:
01528   /* yyn is the number of a rule to reduce with.  */
01529   yylen = yyr2[yyn];
01530 
01531   /* If YYLEN is nonzero, implement the default value of the action:
01532      `$$ = $1'.
01533 
01534      Otherwise, the following line sets YYVAL to garbage.
01535      This behavior is undocumented and Bison
01536      users should not rely upon it.  Assigning to YYVAL
01537      unconditionally makes the parser a bit smaller, and it avoids a
01538      GCC warning that YYVAL may be used uninitialized.  */
01539   yyval = yyvsp[1-yylen];
01540 
01541 
01542   YY_REDUCE_PRINT (yyn);
01543   switch (yyn)
01544     {
01545         case 2:
01546 #line 164 "yacc.yy"
01547     {
01548       ;}
01549     break;
01550 
01551   case 4:
01552 #line 171 "yacc.yy"
01553     {
01554         printf("<INCLUDE>%s</INCLUDE>\n", yyvsp[-1]._str->latin1() );
01555       ;}
01556     break;
01557 
01558   case 5:
01559 #line 175 "yacc.yy"
01560     {
01561       ;}
01562     break;
01563 
01564   case 6:
01565 #line 178 "yacc.yy"
01566     {
01567           ;}
01568     break;
01569 
01570   case 7:
01571 #line 183 "yacc.yy"
01572     { yyval._int = 1; ;}
01573     break;
01574 
01575   case 8:
01576 #line 184 "yacc.yy"
01577     { yyval._int = 0; ;}
01578     break;
01579 
01580   case 9:
01581 #line 189 "yacc.yy"
01582     {
01583         if (yyvsp[-2]._int)
01584               printf("<CLASS>\n    <NAME>%s</NAME>\n%s%s</CLASS>\n", ( in_namespace + *yyvsp[-4]._str ).latin1(), yyvsp[-3]._str->latin1(), yyvsp[-1]._str->latin1() );
01585         // default C++ visibility specifier is 'private'
01586         dcop_area = 0;
01587         dcop_signal_area = 0;
01588 
01589       ;}
01590     break;
01591 
01592   case 10:
01593 #line 198 "yacc.yy"
01594     {
01595         if (yyvsp[-2]._int)
01596               printf("<CLASS>\n    <NAME>%s</NAME>\n    <LINK_SCOPE>%s</LINK_SCOPE>\n%s%s</CLASS>\n", ( in_namespace + *yyvsp[-4]._str ).latin1(),yyvsp[-5]._str->latin1(),  yyvsp[-3]._str->latin1(), yyvsp[-1]._str->latin1() );
01597         // default C++ visibility specifier is 'private'
01598         dcop_area = 0;
01599         dcop_signal_area = 0;
01600 
01601       ;}
01602     break;
01603 
01604   case 11:
01605 #line 207 "yacc.yy"
01606     {
01607       ;}
01608     break;
01609 
01610   case 12:
01611 #line 210 "yacc.yy"
01612     {
01613       ;}
01614     break;
01615 
01616   case 13:
01617 #line 213 "yacc.yy"
01618     {
01619       ;}
01620     break;
01621 
01622   case 14:
01623 #line 216 "yacc.yy"
01624     {
01625                       in_namespace += *yyvsp[-1]._str; in_namespace += "::";
01626                   ;}
01627     break;
01628 
01629   case 15:
01630 #line 220 "yacc.yy"
01631     {
01632                       int pos = in_namespace.findRev( "::", -3 );
01633                       if( pos >= 0 )
01634                           in_namespace = in_namespace.left( pos + 2 );
01635                       else
01636                           in_namespace = "";
01637                   ;}
01638     break;
01639 
01640   case 16:
01641 #line 228 "yacc.yy"
01642     {
01643           ;}
01644     break;
01645 
01646   case 17:
01647 #line 231 "yacc.yy"
01648     {
01649           ;}
01650     break;
01651 
01652   case 18:
01653 #line 234 "yacc.yy"
01654     {
01655       ;}
01656     break;
01657 
01658   case 19:
01659 #line 237 "yacc.yy"
01660     {
01661       ;}
01662     break;
01663 
01664   case 20:
01665 #line 240 "yacc.yy"
01666     {
01667       ;}
01668     break;
01669 
01670   case 21:
01671 #line 243 "yacc.yy"
01672     {
01673       ;}
01674     break;
01675 
01676   case 22:
01677 #line 246 "yacc.yy"
01678     {
01679       ;}
01680     break;
01681 
01682   case 23:
01683 #line 249 "yacc.yy"
01684     {
01685       ;}
01686     break;
01687 
01688   case 24:
01689 #line 252 "yacc.yy"
01690     {
01691       ;}
01692     break;
01693 
01694   case 25:
01695 #line 255 "yacc.yy"
01696     {
01697       ;}
01698     break;
01699 
01700   case 36:
01701 #line 272 "yacc.yy"
01702     {
01703       dcop_area = 0;
01704       dcop_signal_area = 0;
01705     ;}
01706     break;
01707 
01708   case 37:
01709 #line 277 "yacc.yy"
01710     {
01711       dcop_area = 0;
01712       dcop_signal_area = 0;
01713     ;}
01714     break;
01715 
01716   case 38:
01717 #line 285 "yacc.yy"
01718     {
01719       dcop_area = 1;
01720       dcop_signal_area = 0;
01721     ;}
01722     break;
01723 
01724   case 39:
01725 #line 293 "yacc.yy"
01726     {
01727       /*
01728       A dcop signals area needs all dcop area capabilities,
01729       e.g. parsing of function parameters.
01730       */
01731       dcop_area = 1;
01732       dcop_signal_area = 1;
01733     ;}
01734     break;
01735 
01736   case 40:
01737 #line 304 "yacc.yy"
01738     {
01739       yyval._str = yyvsp[0]._str;
01740     ;}
01741     break;
01742 
01743   case 41:
01744 #line 307 "yacc.yy"
01745     {
01746        QString* tmp = new QString( "%1::%2" );
01747            *tmp = tmp->arg(*(yyvsp[-2]._str)).arg(*(yyvsp[0]._str));
01748            yyval._str = tmp;
01749     ;}
01750     break;
01751 
01752   case 42:
01753 #line 316 "yacc.yy"
01754     {
01755         QString* tmp = new QString( "    <SUPER>%1</SUPER>\n" );
01756         *tmp = tmp->arg( *(yyvsp[0]._str) );
01757         yyval._str = tmp;
01758       ;}
01759     break;
01760 
01761   case 43:
01762 #line 322 "yacc.yy"
01763     {
01764         QString* tmp = new QString( "    <SUPER>%1</SUPER>\n" );
01765         *tmp = tmp->arg( *(yyvsp[-3]._str) + "&lt;" + *(yyvsp[-1]._str) + "&gt;" );
01766         yyval._str = tmp;
01767       ;}
01768     break;
01769 
01770   case 44:
01771 #line 331 "yacc.yy"
01772     {
01773         yyval._str = yyvsp[0]._str;
01774       ;}
01775     break;
01776 
01777   case 45:
01778 #line 335 "yacc.yy"
01779     {
01780         yyval._str = yyvsp[0]._str;
01781       ;}
01782     break;
01783 
01784   case 46:
01785 #line 342 "yacc.yy"
01786     {
01787         yyval._str = yyvsp[-1]._str;
01788       ;}
01789     break;
01790 
01791   case 47:
01792 #line 346 "yacc.yy"
01793     {
01794         /* $$ = $1; */
01795         yyval._str = new QString( *(yyvsp[-2]._str) + *(yyvsp[0]._str) );
01796       ;}
01797     break;
01798 
01799   case 48:
01800 #line 354 "yacc.yy"
01801     {
01802         yyval._str = yyvsp[0]._str;
01803       ;}
01804     break;
01805 
01806   case 49:
01807 #line 358 "yacc.yy"
01808     {
01809         yyval._str = new QString( "" );
01810       ;}
01811     break;
01812 
01813   case 50:
01814 #line 365 "yacc.yy"
01815     {
01816           ;}
01817     break;
01818 
01819   case 52:
01820 #line 372 "yacc.yy"
01821     {
01822         yyval._str = new QString( "" );
01823       ;}
01824     break;
01825 
01826   case 53:
01827 #line 376 "yacc.yy"
01828     {
01829         yyval._str = new QString( *(yyvsp[-1]._str) + *(yyvsp[0]._str) );
01830       ;}
01831     break;
01832 
01833   case 54:
01834 #line 380 "yacc.yy"
01835     {
01836         yyval._str = new QString( *(yyvsp[-1]._str) + *(yyvsp[0]._str) );
01837       ;}
01838     break;
01839 
01840   case 55:
01841 #line 384 "yacc.yy"
01842     {
01843         yyval._str = new QString( *(yyvsp[-1]._str) + *(yyvsp[0]._str) );
01844       ;}
01845     break;
01846 
01847   case 56:
01848 #line 388 "yacc.yy"
01849     {
01850         yyval._str = yyvsp[0]._str;
01851       ;}
01852     break;
01853 
01854   case 57:
01855 #line 392 "yacc.yy"
01856     {
01857         yyval._str = yyvsp[0]._str;
01858       ;}
01859     break;
01860 
01861   case 58:
01862 #line 396 "yacc.yy"
01863     {
01864         yyval._str = yyvsp[0]._str;
01865       ;}
01866     break;
01867 
01868   case 59:
01869 #line 400 "yacc.yy"
01870     {   
01871             yyval._str = yyvsp[0]._str;
01872       ;}
01873     break;
01874 
01875   case 60:
01876 #line 404 "yacc.yy"
01877     {
01878             yyval._str = yyvsp[0]._str;
01879       ;}
01880     break;
01881 
01882   case 61:
01883 #line 408 "yacc.yy"
01884     {
01885         yyval._str = yyvsp[0]._str;
01886       ;}
01887     break;
01888 
01889   case 62:
01890 #line 412 "yacc.yy"
01891     {
01892         yyval._str = yyvsp[0]._str;
01893       ;}
01894     break;
01895 
01896   case 63:
01897 #line 416 "yacc.yy"
01898     {
01899         yyval._str = yyvsp[0]._str;
01900       ;}
01901     break;
01902 
01903   case 64:
01904 #line 420 "yacc.yy"
01905     {
01906         yyval._str = yyvsp[0]._str;
01907       ;}
01908     break;
01909 
01910   case 65:
01911 #line 424 "yacc.yy"
01912     {
01913                 yyval._str = yyvsp[0]._str;
01914           ;}
01915     break;
01916 
01917   case 66:
01918 #line 428 "yacc.yy"
01919     {
01920         yyval._str = yyvsp[0]._str;
01921       ;}
01922     break;
01923 
01924   case 67:
01925 #line 432 "yacc.yy"
01926     {
01927                 yyval._str = yyvsp[0]._str;
01928           ;}
01929     break;
01930 
01931   case 68:
01932 #line 436 "yacc.yy"
01933     {
01934                 yyval._str = yyvsp[0]._str;
01935           ;}
01936     break;
01937 
01938   case 75:
01939 #line 454 "yacc.yy"
01940     {;}
01941     break;
01942 
01943   case 76:
01944 #line 455 "yacc.yy"
01945     {;}
01946     break;
01947 
01948   case 77:
01949 #line 459 "yacc.yy"
01950     {;}
01951     break;
01952 
01953   case 78:
01954 #line 460 "yacc.yy"
01955     {;}
01956     break;
01957 
01958   case 79:
01959 #line 461 "yacc.yy"
01960     {;}
01961     break;
01962 
01963   case 80:
01964 #line 462 "yacc.yy"
01965     {;}
01966     break;
01967 
01968   case 81:
01969 #line 463 "yacc.yy"
01970     {;}
01971     break;
01972 
01973   case 82:
01974 #line 467 "yacc.yy"
01975     {;}
01976     break;
01977 
01978   case 83:
01979 #line 468 "yacc.yy"
01980     {;}
01981     break;
01982 
01983   case 84:
01984 #line 469 "yacc.yy"
01985     {;}
01986     break;
01987 
01988   case 85:
01989 #line 474 "yacc.yy"
01990     {
01991         if (dcop_area) {
01992           QString* tmp = new QString("<TYPEDEF name=\"%1\" template=\"%2\"><PARAM %3</TYPEDEF>\n");
01993           *tmp = tmp->arg( *(yyvsp[-1]._str) ).arg( *(yyvsp[-5]._str) ).arg( *(yyvsp[-3]._str) );
01994           yyval._str = tmp;
01995         } else {
01996           yyval._str = new QString("");
01997         }
01998       ;}
01999     break;
02000 
02001   case 86:
02002 #line 484 "yacc.yy"
02003     {
02004         if (dcop_area)
02005           yyerror("scoped template typedefs are not supported in dcop areas!");
02006       ;}
02007     break;
02008 
02009   case 87:
02010 #line 492 "yacc.yy"
02011     {
02012         yyval._int = 0;
02013       ;}
02014     break;
02015 
02016   case 88:
02017 #line 496 "yacc.yy"
02018     {
02019         yyval._int = 1;
02020       ;}
02021     break;
02022 
02023   case 89:
02024 #line 502 "yacc.yy"
02025     { yyval._str = new QString("signed int"); ;}
02026     break;
02027 
02028   case 90:
02029 #line 503 "yacc.yy"
02030     { yyval._str = new QString("signed int"); ;}
02031     break;
02032 
02033   case 91:
02034 #line 504 "yacc.yy"
02035     { yyval._str = new QString("unsigned int"); ;}
02036     break;
02037 
02038   case 92:
02039 #line 505 "yacc.yy"
02040     { yyval._str = new QString("unsigned int"); ;}
02041     break;
02042 
02043   case 93:
02044 #line 506 "yacc.yy"
02045     { yyval._str = new QString("signed short int"); ;}
02046     break;
02047 
02048   case 94:
02049 #line 507 "yacc.yy"
02050     { yyval._str = new QString("signed short int"); ;}
02051     break;
02052 
02053   case 95:
02054 #line 508 "yacc.yy"
02055     { yyval._str = new QString("signed long int"); ;}
02056     break;
02057 
02058   case 96:
02059 #line 509 "yacc.yy"
02060     { yyval._str = new QString("signed long int"); ;}
02061     break;
02062 
02063   case 97:
02064 #line 510 "yacc.yy"
02065     { yyval._str = new QString("unsigned short int"); ;}
02066     break;
02067 
02068   case 98:
02069 #line 511 "yacc.yy"
02070     { yyval._str = new QString("unsigned short int"); ;}
02071     break;
02072 
02073   case 99:
02074 #line 512 "yacc.yy"
02075     { yyval._str = new QString("unsigned long int"); ;}
02076     break;
02077 
02078   case 100:
02079 #line 513 "yacc.yy"
02080     { yyval._str = new QString("unsigned long int"); ;}
02081     break;
02082 
02083   case 101:
02084 #line 514 "yacc.yy"
02085     { yyval._str = new QString("int"); ;}
02086     break;
02087 
02088   case 102:
02089 #line 515 "yacc.yy"
02090     { yyval._str = new QString("long int"); ;}
02091     break;
02092 
02093   case 103:
02094 #line 516 "yacc.yy"
02095     { yyval._str = new QString("long int"); ;}
02096     break;
02097 
02098   case 104:
02099 #line 517 "yacc.yy"
02100     { yyval._str = new QString("short int"); ;}
02101     break;
02102 
02103   case 105:
02104 #line 518 "yacc.yy"
02105     { yyval._str = new QString("short int"); ;}
02106     break;
02107 
02108   case 106:
02109 #line 519 "yacc.yy"
02110     { yyval._str = new QString("char"); ;}
02111     break;
02112 
02113   case 107:
02114 #line 520 "yacc.yy"
02115     { yyval._str = new QString("signed char"); ;}
02116     break;
02117 
02118   case 108:
02119 #line 521 "yacc.yy"
02120     { yyval._str = new QString("unsigned char"); ;}
02121     break;
02122 
02123   case 111:
02124 #line 531 "yacc.yy"
02125     {
02126         yyval._str = new QString( "" );
02127       ;}
02128     break;
02129 
02130   case 113:
02131 #line 536 "yacc.yy"
02132     {
02133         yyval._str = new QString( *(yyvsp[-2]._str) + *(yyvsp[0]._str) );
02134       ;}
02135     break;
02136 
02137   case 115:
02138 #line 544 "yacc.yy"
02139     { yyval._str = yyvsp[0]._str; ;}
02140     break;
02141 
02142   case 116:
02143 #line 545 "yacc.yy"
02144     { yyval._str = yyvsp[0]._str; ;}
02145     break;
02146 
02147   case 117:
02148 #line 546 "yacc.yy"
02149     { yyval._str = yyvsp[0]._str; ;}
02150     break;
02151 
02152   case 118:
02153 #line 547 "yacc.yy"
02154     {
02155         QString *tmp = new QString("%1&lt;%2&gt;");
02156         *tmp = tmp->arg(*(yyvsp[-3]._str));
02157         *tmp = tmp->arg(*(yyvsp[-1]._str));
02158         yyval._str = tmp;
02159      ;}
02160     break;
02161 
02162   case 119:
02163 #line 553 "yacc.yy"
02164     {
02165         QString *tmp = new QString("%1&lt;%2&gt;::%3");
02166         *tmp = tmp->arg(*(yyvsp[-5]._str));
02167         *tmp = tmp->arg(*(yyvsp[-3]._str));
02168         *tmp = tmp->arg(*(yyvsp[0]._str));
02169         yyval._str = tmp;
02170      ;}
02171     break;
02172 
02173   case 120:
02174 #line 565 "yacc.yy"
02175     {
02176         yyval._str = new QString(*(yyvsp[-2]._str) + "," + *(yyvsp[0]._str));
02177       ;}
02178     break;
02179 
02180   case 121:
02181 #line 569 "yacc.yy"
02182     {
02183         yyval._str = yyvsp[0]._str;
02184       ;}
02185     break;
02186 
02187   case 122:
02188 #line 577 "yacc.yy"
02189     {
02190         if (dcop_area)
02191           yyerror("in dcop areas are no pointers allowed");
02192       ;}
02193     break;
02194 
02195   case 123:
02196 #line 582 "yacc.yy"
02197     {
02198         yyval._str = yyvsp[0]._str;
02199       ;}
02200     break;
02201 
02202   case 124:
02203 #line 591 "yacc.yy"
02204     {
02205         if (dcop_area)
02206           yyerror("in dcop areas are no pointers allowed");
02207       ;}
02208     break;
02209 
02210   case 125:
02211 #line 595 "yacc.yy"
02212     {
02213          if (dcop_area) {
02214         QString* tmp = new QString("<TYPE  qleft=\"const\" qright=\"" AMP_ENTITY "\">%1</TYPE>");
02215         *tmp = tmp->arg( *(yyvsp[-1]._str) );
02216         yyval._str = tmp;
02217          }
02218       ;}
02219     break;
02220 
02221   case 126:
02222 #line 602 "yacc.yy"
02223     {
02224         QString* tmp = new QString("<TYPE>%1</TYPE>");
02225         *tmp = tmp->arg( *(yyvsp[0]._str) );
02226         yyval._str = tmp;
02227     ;}
02228     break;
02229 
02230   case 127:
02231 #line 607 "yacc.yy"
02232     {
02233          if (dcop_area)
02234         yyerror("in dcop areas are only const references allowed!");
02235       ;}
02236     break;
02237 
02238   case 128:
02239 #line 612 "yacc.yy"
02240     {
02241         QString* tmp = new QString("<TYPE>%1</TYPE>");
02242         *tmp = tmp->arg( *(yyvsp[0]._str) );
02243         yyval._str = tmp;
02244     ;}
02245     break;
02246 
02247   case 129:
02248 #line 618 "yacc.yy"
02249     {
02250         if (dcop_area)
02251           yyerror("in dcop areas are no pointers allowed");
02252       ;}
02253     break;
02254 
02255   case 130:
02256 #line 626 "yacc.yy"
02257     {
02258         yyval._str = new QString(*(yyvsp[-2]._str) + "," + *(yyvsp[0]._str));
02259       ;}
02260     break;
02261 
02262   case 131:
02263 #line 630 "yacc.yy"
02264     {
02265         yyval._str = yyvsp[0]._str;
02266       ;}
02267     break;
02268 
02269   case 132:
02270 #line 637 "yacc.yy"
02271     {
02272         if (dcop_area) {
02273            QString* tmp = new QString("\n        <ARG>%1<NAME>%2</NAME></ARG>");
02274            *tmp = tmp->arg( *(yyvsp[-2]._str) );
02275            *tmp = tmp->arg( *(yyvsp[-1]._str) );
02276            yyval._str = tmp;        
02277         } else yyval._str = new QString();
02278       ;}
02279     break;
02280 
02281   case 133:
02282 #line 646 "yacc.yy"
02283     {
02284         if (dcop_area) {
02285            QString* tmp = new QString("\n        <ARG>%1</ARG>");
02286            *tmp = tmp->arg( *(yyvsp[-1]._str) );
02287            yyval._str = tmp;        
02288         } else yyval._str = new QString();
02289       ;}
02290     break;
02291 
02292   case 134:
02293 #line 654 "yacc.yy"
02294     {
02295         if (dcop_area)
02296             yyerror("variable arguments not supported in dcop area.");
02297         yyval._str = new QString("");
02298       ;}
02299     break;
02300 
02301   case 135:
02302 #line 663 "yacc.yy"
02303     {
02304       ;}
02305     break;
02306 
02307   case 136:
02308 #line 666 "yacc.yy"
02309     {
02310       ;}
02311     break;
02312 
02313   case 137:
02314 #line 669 "yacc.yy"
02315     {
02316       ;}
02317     break;
02318 
02319   case 138:
02320 #line 676 "yacc.yy"
02321     {
02322           ;}
02323     break;
02324 
02325   case 139:
02326 #line 679 "yacc.yy"
02327     {
02328           ;}
02329     break;
02330 
02331   case 140:
02332 #line 682 "yacc.yy"
02333     {
02334           ;}
02335     break;
02336 
02337   case 141:
02338 #line 685 "yacc.yy"
02339     {
02340           ;}
02341     break;
02342 
02343   case 142:
02344 #line 688 "yacc.yy"
02345     {
02346           ;}
02347     break;
02348 
02349   case 143:
02350 #line 693 "yacc.yy"
02351     { yyval._int = 0; ;}
02352     break;
02353 
02354   case 144:
02355 #line 694 "yacc.yy"
02356     { yyval._int = 1; ;}
02357     break;
02358 
02359   case 150:
02360 #line 703 "yacc.yy"
02361     {
02362          if (dcop_area || dcop_signal_area) {
02363         QString* tmp = 0;
02364                 tmp = new QString(
02365                         "    <%4>\n"
02366                         "        %2\n"
02367                         "        <NAME>%1</NAME>"
02368                         "%3\n"
02369                         "     </%5>\n");
02370         *tmp = tmp->arg( *(yyvsp[-4]._str) );
02371         *tmp = tmp->arg( *(yyvsp[-5]._str) );
02372                 *tmp = tmp->arg( *(yyvsp[-2]._str) );
02373                 
02374                 QString tagname = (dcop_signal_area) ? "SIGNAL" : "FUNC";
02375                 QString attr = (yyvsp[0]._int) ? " qual=\"const\"" : "";
02376                 *tmp = tmp->arg( QString("%1%2").arg(tagname).arg(attr) );
02377                 *tmp = tmp->arg( QString("%1").arg(tagname) );
02378         yyval._str = tmp;
02379          } else
02380             yyval._str = new QString("");
02381       ;}
02382     break;
02383 
02384   case 151:
02385 #line 725 "yacc.yy"
02386     {
02387          if (dcop_area)
02388         yyerror("operators aren't allowed in dcop areas!");
02389          yyval._str = new QString("");
02390       ;}
02391     break;
02392 
02393   case 152:
02394 #line 735 "yacc.yy"
02395     {;}
02396     break;
02397 
02398   case 153:
02399 #line 736 "yacc.yy"
02400     {;}
02401     break;
02402 
02403   case 154:
02404 #line 737 "yacc.yy"
02405     {;}
02406     break;
02407 
02408   case 155:
02409 #line 742 "yacc.yy"
02410     {;}
02411     break;
02412 
02413   case 156:
02414 #line 747 "yacc.yy"
02415     {;}
02416     break;
02417 
02418   case 157:
02419 #line 748 "yacc.yy"
02420     {;}
02421     break;
02422 
02423   case 158:
02424 #line 753 "yacc.yy"
02425     {
02426             yyval._str = yyvsp[-1]._str;
02427       ;}
02428     break;
02429 
02430   case 159:
02431 #line 757 "yacc.yy"
02432     {
02433         yyval._str = yyvsp[-3]._str;
02434       ;}
02435     break;
02436 
02437   case 160:
02438 #line 761 "yacc.yy"
02439     {
02440         yyval._str = yyvsp[-1]._str;
02441       ;}
02442     break;
02443 
02444   case 161:
02445 #line 765 "yacc.yy"
02446     {
02447           /* The constructor */
02448           assert(!dcop_area);
02449               yyval._str = new QString("");
02450       ;}
02451     break;
02452 
02453   case 162:
02454 #line 771 "yacc.yy"
02455     {
02456           /* The constructor */
02457           assert(!dcop_area);
02458               yyval._str = new QString("");
02459       ;}
02460     break;
02461 
02462   case 163:
02463 #line 777 "yacc.yy"
02464     {
02465           /* The destructor */
02466           assert(!dcop_area);
02467               yyval._str = new QString("");
02468       ;}
02469     break;
02470 
02471   case 164:
02472 #line 783 "yacc.yy"
02473     {
02474               if (dcop_area) {
02475                  if (dcop_signal_area)
02476                      yyerror("DCOP signals cannot be static");
02477                  else
02478                      yyerror("DCOP functions cannot be static");
02479               } else {
02480                  yyval._str = new QString();
02481               }  
02482       ;}
02483     break;
02484 
02485   case 165:
02486 #line 796 "yacc.yy"
02487     {
02488         function_mode = 1;
02489     ;}
02490     break;
02491 
02492   case 169:
02493 #line 808 "yacc.yy"
02494     {;}
02495     break;
02496 
02497   case 170:
02498 #line 809 "yacc.yy"
02499     {;}
02500     break;
02501 
02502   case 174:
02503 #line 821 "yacc.yy"
02504     {;}
02505     break;
02506 
02507   case 175:
02508 #line 822 "yacc.yy"
02509     {;}
02510     break;
02511 
02512   case 176:
02513 #line 823 "yacc.yy"
02514     {;}
02515     break;
02516 
02517   case 177:
02518 #line 826 "yacc.yy"
02519     {;}
02520     break;
02521 
02522   case 178:
02523 #line 830 "yacc.yy"
02524     {;}
02525     break;
02526 
02527   case 179:
02528 #line 831 "yacc.yy"
02529     {;}
02530     break;
02531 
02532   case 180:
02533 #line 832 "yacc.yy"
02534     {;}
02535     break;
02536 
02537   case 181:
02538 #line 833 "yacc.yy"
02539     {;}
02540     break;
02541 
02542   case 182:
02543 #line 834 "yacc.yy"
02544     {;}
02545     break;
02546 
02547 
02548     }
02549 
02550 /* Line 999 of yacc.c.  */
02551 #line 2552 "yacc.cc"
02552 
02553   yyvsp -= yylen;
02554   yyssp -= yylen;
02555 
02556 
02557   YY_STACK_PRINT (yyss, yyssp);
02558 
02559   *++yyvsp = yyval;
02560 
02561 
02562   /* Now `shift' the result of the reduction.  Determine what state
02563      that goes to, based on the state we popped back to and the rule
02564      number reduced by.  */
02565 
02566   yyn = yyr1[yyn];
02567 
02568   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
02569   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
02570     yystate = yytable[yystate];
02571   else
02572     yystate = yydefgoto[yyn - YYNTOKENS];
02573 
02574   goto yynewstate;
02575 
02576 
02577 /*------------------------------------.
02578 | yyerrlab -- here on detecting error |
02579 `------------------------------------*/
02580 yyerrlab:
02581   /* If not already recovering from an error, report this error.  */
02582   if (!yyerrstatus)
02583     {
02584       ++yynerrs;
02585 #if YYERROR_VERBOSE
02586       yyn = yypact[yystate];
02587 
02588       if (YYPACT_NINF < yyn && yyn < YYLAST)
02589     {
02590       YYSIZE_T yysize = 0;
02591       int yytype = YYTRANSLATE (yychar);
02592       char *yymsg;
02593       int yyx, yycount;
02594 
02595       yycount = 0;
02596       /* Start YYX at -YYN if negative to avoid negative indexes in
02597          YYCHECK.  */
02598       for (yyx = yyn < 0 ? -yyn : 0;
02599            yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
02600         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
02601           yysize += yystrlen (yytname[yyx]) + 15, yycount++;
02602       yysize += yystrlen ("syntax error, unexpected ") + 1;
02603       yysize += yystrlen (yytname[yytype]);
02604       yymsg = (char *) YYSTACK_ALLOC (yysize);
02605       if (yymsg != 0)
02606         {
02607           char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
02608           yyp = yystpcpy (yyp, yytname[yytype]);
02609 
02610           if (yycount < 5)
02611         {
02612           yycount = 0;
02613           for (yyx = yyn < 0 ? -yyn : 0;
02614                yyx < (int) (sizeof (yytname) / sizeof (char *));
02615                yyx++)
02616             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
02617               {
02618             const char *yyq = ! yycount ? ", expecting " : " or ";
02619             yyp = yystpcpy (yyp, yyq);
02620             yyp = yystpcpy (yyp, yytname[yyx]);
02621             yycount++;
02622               }
02623         }
02624           yyerror (yymsg);
02625           YYSTACK_FREE (yymsg);
02626         }
02627       else
02628         yyerror ("syntax error; also virtual memory exhausted");
02629     }
02630       else
02631 #endif /* YYERROR_VERBOSE */
02632     yyerror ("syntax error");
02633     }
02634 
02635 
02636 
02637   if (yyerrstatus == 3)
02638     {
02639       /* If just tried and failed to reuse lookahead token after an
02640      error, discard it.  */
02641 
02642       /* Return failure if at end of input.  */
02643       if (yychar == YYEOF)
02644         {
02645       /* Pop the error token.  */
02646           YYPOPSTACK;
02647       /* Pop the rest of the stack.  */
02648       while (yyss < yyssp)
02649         {
02650           YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
02651           yydestruct (yystos[*yyssp], yyvsp);
02652           YYPOPSTACK;
02653         }
02654       YYABORT;
02655         }
02656 
02657       YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
02658       yydestruct (yytoken, &yylval);
02659       yychar = YYEMPTY;
02660 
02661     }
02662 
02663   /* Else will try to reuse lookahead token after shifting the error
02664      token.  */
02665   goto yyerrlab1;
02666 
02667 
02668 /*----------------------------------------------------.
02669 | yyerrlab1 -- error raised explicitly by an action.  |
02670 `----------------------------------------------------*/
02671 yyerrlab1:
02672   yyerrstatus = 3;  /* Each real token shifted decrements this.  */
02673 
02674   for (;;)
02675     {
02676       yyn = yypact[yystate];
02677       if (yyn != YYPACT_NINF)
02678     {
02679       yyn += YYTERROR;
02680       if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
02681         {
02682           yyn = yytable[yyn];
02683           if (0 < yyn)
02684         break;
02685         }
02686     }
02687 
02688       /* Pop the current state because it cannot handle the error token.  */
02689       if (yyssp == yyss)
02690     YYABORT;
02691 
02692       YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
02693       yydestruct (yystos[yystate], yyvsp);
02694       yyvsp--;
02695       yystate = *--yyssp;
02696 
02697       YY_STACK_PRINT (yyss, yyssp);
02698     }
02699 
02700   if (yyn == YYFINAL)
02701     YYACCEPT;
02702 
02703   YYDPRINTF ((stderr, "Shifting error token, "));
02704 
02705   *++yyvsp = yylval;
02706 
02707 
02708   yystate = yyn;
02709   goto yynewstate;
02710 
02711 
02712 /*-------------------------------------.
02713 | yyacceptlab -- YYACCEPT comes here.  |
02714 `-------------------------------------*/
02715 yyacceptlab:
02716   yyresult = 0;
02717   goto yyreturn;
02718 
02719 /*-----------------------------------.
02720 | yyabortlab -- YYABORT comes here.  |
02721 `-----------------------------------*/
02722 yyabortlab:
02723   yyresult = 1;
02724   goto yyreturn;
02725 
02726 #ifndef yyoverflow
02727 /*----------------------------------------------.
02728 | yyoverflowlab -- parser overflow comes here.  |
02729 `----------------------------------------------*/
02730 yyoverflowlab:
02731   yyerror ("parser stack overflow");
02732   yyresult = 2;
02733   /* Fall through.  */
02734 #endif
02735 
02736 yyreturn:
02737 #ifndef yyoverflow
02738   if (yyss != yyssa)
02739     YYSTACK_FREE (yyss);
02740 #endif
02741   return yyresult;
02742 }
02743 
02744 
02745 #line 837 "yacc.yy"
02746 
02747 
02748 void dcopidlParse( const char *_code )
02749 {
02750     dcopidlInitFlex( _code );
02751     yyparse();
02752 }
02753 
KDE Logo
This file is part of the documentation for dcop Library Version 3.2.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sun May 16 22:00:43 2004 by doxygen 1.2.15 written by Dimitri van Heesch, © 1997-2003