dcop Library API Documentation

yacc.cc

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