Main Page   Namespace List   Class Hierarchy   Compound List   File List   Namespace Members   Compound Members   File Members  

y.tab.cc

Go to the documentation of this file.
00001 /* A Bison parser, made from oep.yy
00002    by GNU bison 1.35.  */
00003 
00004 #define YYBISON 1  /* Identify Bison output.  */
00005 
00006 # define        CHANNELFACTORY_LABEL    257
00007 # define        EVENTCHANNEL_LABEL      258
00008 # define        CONSUMERADMIN_LABEL     259
00009 # define        SUPPLIERADMIN_LABEL     260
00010 # define        PROXYPUSHSUPP_LABEL     261
00011 # define        PROXYPUSHCONS_LABEL     262
00012 # define        PROXYPULLSUPP_LABEL     263
00013 # define        PROXYPULLCONS_LABEL     264
00014 # define        NAME_LABEL      265
00015 # define        IOR_LABEL       266
00016 # define        KEY_LABEL       267
00017 # define        PORT_LABEL      268
00018 # define        PULLRETRYPERIOD_LABEL   269
00019 # define        MAXQUEUELENGTH_LABEL    270
00020 # define        MAXEVENTSPERCONSUMER_LABEL      271
00021 # define        IOR_VALUE       272
00022 # define        KEY_VALUE       273
00023 # define        INTEGER_LITERAL 274
00024 # define        STRING_LITERAL  275
00025 # define        TRUETOK 276
00026 # define        FALSETOK        277
00027 
00028 #line 62 "oep.yy"
00029 
00030 #ifdef HAVE_CONFIG_H
00031 #  include "config.h"
00032 #endif
00033 
00034 #ifdef HAVE_IOSTREAM
00035 #  include <iostream>
00036 #else
00037 #  include <iostream.h>
00038 #endif
00039 
00040 #include "oep_types.h"
00041 #include "oep_global.h"
00042 
00043 #ifdef __cplusplus
00044 #ifndef __EXTERN_C__
00045 #define __EXTERN_C__
00046 #endif
00047 extern  "C" int yywrap();
00048 extern  "C" void yyerror(const char*);
00049 #endif
00050 
00051 extern int yylex();
00052 extern char* yytext;
00053 
00054 #ifndef alloca
00055 #define alloca malloc
00056 #endif
00057 
00058 #define YYDEBUG 1
00059 
00060 #line 98 "oep.yy"
00061 #ifndef YYSTYPE
00062 typedef union {
00063   long                  ival;           /* Long value                   */
00064   double                dval;           /* Double value                 */
00065   float                 fval;           /* Float value                  */
00066   char                  cval;           /* Char value                   */
00067   char                  *sval;          /* string value                 */
00068   char                  *kval;          /* key value                    */
00069   OEP_cfps              *cfps;          /* Channel Factory params       */
00070   OEP_ecps              *ecps;          /* Event Channel params         */
00071   OEP_caps              *caps;          /* Consumer Admin params        */
00072   OEP_saps              *saps;          /* Supplier Admin params        */
00073   OEP_prxy              *prxy;          /* Proxy params                 */
00074 } yystype;
00075 # define YYSTYPE yystype
00076 # define YYSTYPE_IS_TRIVIAL 1
00077 #endif
00078 #ifndef YYDEBUG
00079 # define YYDEBUG 0
00080 #endif
00081 
00082 
00083 
00084 #define YYFINAL         75
00085 #define YYFLAG          -32768
00086 #define YYNTBASE        26
00087 
00088 /* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
00089 #define YYTRANSLATE(x) ((unsigned)(x) <= 277 ? yytranslate[x] : 52)
00090 
00091 /* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
00092 static const char yytranslate[] =
00093 {
00094        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00095        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00096        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00097        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00098        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00099        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00100        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00101        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00102        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00103        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00104        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00105        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00106        2,     2,     2,    24,     2,    25,     2,     2,     2,     2,
00107        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00108        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00109        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00110        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00111        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00112        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00113        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00114        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00115        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00116        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00117        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00118        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00119        2,     2,     2,     2,     2,     2,     1,     3,     4,     5,
00120        6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
00121       16,    17,    18,    19,    20,    21,    22,    23
00122 };
00123 
00124 #if YYDEBUG
00125 static const short yyprhs[] =
00126 {
00127        0,     0,     2,     5,    10,    13,    16,    19,    20,    25,
00128       28,    31,    34,    37,    40,    43,    44,    49,    52,    55,
00129       58,    59,    64,    67,    70,    73,    74,    79,    82,    85,
00130       86,    91,    94,    97,    98,   103,   106,   109,   110,   115,
00131      118,   121,   122,   125,   128,   131,   134,   137,   140,   142,
00132      144,   146
00133 };
00134 static const short yyrhs[] =
00135 {
00136       27,     0,    26,    27,     0,     3,    24,    28,    25,     0,
00137       28,    46,     0,    28,    48,     0,    28,    29,     0,     0,
00138        4,    24,    30,    25,     0,    30,    48,     0,    30,    43,
00139        0,    30,    44,     0,    30,    45,     0,    30,    33,     0,
00140       30,    31,     0,     0,     5,    24,    32,    25,     0,    32,
00141       48,     0,    32,    37,     0,    32,    41,     0,     0,     6,
00142       24,    34,    25,     0,    34,    48,     0,    34,    35,     0,
00143       34,    39,     0,     0,     8,    24,    36,    25,     0,    36,
00144       48,     0,    36,    47,     0,     0,     7,    24,    38,    25,
00145        0,    38,    48,     0,    38,    47,     0,     0,    10,    24,
00146       40,    25,     0,    40,    48,     0,    40,    47,     0,     0,
00147        9,    24,    42,    25,     0,    42,    48,     0,    42,    47,
00148        0,     0,    15,    51,     0,    16,    51,     0,    17,    51,
00149        0,    14,    51,     0,    12,    49,     0,    13,    50,     0,
00150       18,     0,    19,     0,    20,     0,    21,     0
00151 };
00152 
00153 #endif
00154 
00155 #if YYDEBUG
00156 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
00157 static const short yyrline[] =
00158 {
00159        0,   177,   182,   188,   204,   214,   223,   227,   234,   250,
00160      260,   264,   268,   272,   276,   280,   287,   303,   313,   317,
00161      321,   328,   344,   354,   358,   362,   369,   385,   395,   404,
00162      411,   427,   437,   446,   453,   469,   479,   488,   495,   511,
00163      521,   530,   537,   544,   551,   558,   565,   572,   579,   586,
00164      593,   600
00165 };
00166 #endif
00167 
00168 
00169 #if (YYDEBUG) || defined YYERROR_VERBOSE
00170 
00171 /* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
00172 static const char *const yytname[] =
00173 {
00174   "$", "error", "$undefined.", "CHANNELFACTORY_LABEL", "EVENTCHANNEL_LABEL", 
00175   "CONSUMERADMIN_LABEL", "SUPPLIERADMIN_LABEL", "PROXYPUSHSUPP_LABEL", 
00176   "PROXYPUSHCONS_LABEL", "PROXYPULLSUPP_LABEL", "PROXYPULLCONS_LABEL", 
00177   "NAME_LABEL", "IOR_LABEL", "KEY_LABEL", "PORT_LABEL", 
00178   "PULLRETRYPERIOD_LABEL", "MAXQUEUELENGTH_LABEL", 
00179   "MAXEVENTSPERCONSUMER_LABEL", "IOR_VALUE", "KEY_VALUE", 
00180   "INTEGER_LITERAL", "STRING_LITERAL", "TRUETOK", "FALSETOK", "'{'", 
00181   "'}'", "start", "channelFactory", "channelFactoryParams", 
00182   "eventChannel", "eventChannelParams", "consumerAdmin", 
00183   "consumerAdminParams", "supplierAdmin", "supplierAdminParams", 
00184   "proxyPushCons", "proxyPushConsParams", "proxyPushSupp", 
00185   "proxyPushSuppParams", "proxyPullCons", "proxyPullConsParams", 
00186   "proxyPullSupp", "proxyPullSuppParams", "pullRetryPeriod", 
00187   "maxQueueLength", "maxEventsPerConsumer", "port", "ior", "key", 
00188   "ior_value", "key_value", "integer_literal", 0
00189 };
00190 #endif
00191 
00192 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
00193 static const short yyr1[] =
00194 {
00195        0,    26,    26,    27,    28,    28,    28,    28,    29,    30,
00196       30,    30,    30,    30,    30,    30,    31,    32,    32,    32,
00197       32,    33,    34,    34,    34,    34,    35,    36,    36,    36,
00198       37,    38,    38,    38,    39,    40,    40,    40,    41,    42,
00199       42,    42,    43,    44,    45,    46,    47,    48,    49,    50,
00200       51,    52
00201 };
00202 
00203 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
00204 static const short yyr2[] =
00205 {
00206        0,     1,     2,     4,     2,     2,     2,     0,     4,     2,
00207        2,     2,     2,     2,     2,     0,     4,     2,     2,     2,
00208        0,     4,     2,     2,     2,     0,     4,     2,     2,     0,
00209        4,     2,     2,     0,     4,     2,     2,     0,     4,     2,
00210        2,     0,     2,     2,     2,     2,     2,     2,     1,     1,
00211        1,     1
00212 };
00213 
00214 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
00215    doesn't specify something else to do.  Zero means the default is an
00216    error. */
00217 static const short yydefact[] =
00218 {
00219        0,     0,     0,     1,     7,     2,     0,     0,     0,     0,
00220        3,     6,     4,     5,    15,    49,    47,    50,    45,     0,
00221        0,     0,     0,     0,     0,     8,    14,    13,    10,    11,
00222       12,     9,    20,    25,    42,    43,    44,     0,     0,     0,
00223        0,    16,    18,    19,    17,     0,     0,    21,    23,    24,
00224       22,    33,    41,    29,    37,     0,     0,     0,     0,     0,
00225       30,    32,    31,    38,    40,    39,    26,    28,    27,    34,
00226       36,    35,    48,    46,     0,     0
00227 };
00228 
00229 static const short yydefgoto[] =
00230 {
00231        2,     3,     6,    11,    19,    26,    37,    27,    38,    48,
00232       57,    42,    55,    49,    58,    43,    56,    28,    29,    30,
00233       12,    61,    13,    73,    16,    18
00234 };
00235 
00236 static const short yypact[] =
00237 {
00238        5,   -22,     3,-32768,-32768,-32768,    -3,    -7,     4,     7,
00239   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,    -1,
00240       27,    30,     7,     7,     7,-32768,-32768,-32768,-32768,-32768,
00241   -32768,-32768,-32768,-32768,-32768,-32768,-32768,     0,    18,    31,
00242       32,-32768,-32768,-32768,-32768,    33,    34,-32768,-32768,-32768,
00243   -32768,-32768,-32768,-32768,-32768,     8,    17,    22,    28,    14,
00244   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
00245   -32768,-32768,-32768,-32768,    52,-32768
00246 };
00247 
00248 static const short yypgoto[] =
00249 {
00250   -32768,    57,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
00251   -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
00252   -32768,   -12,   -19,-32768,-32768,    26
00253 };
00254 
00255 
00256 #define YYLAST          59
00257 
00258 
00259 static const short yytable[] =
00260 {
00261       31,     7,     4,    74,    20,    21,     1,    39,     1,    40,
00262        8,     9,     8,     8,    22,    23,    24,    14,    44,    50,
00263       59,     8,    10,    15,    25,    41,    45,    17,    46,    59,
00264        8,     8,    72,    60,    59,     8,    62,    65,    68,    71,
00265       59,     8,    63,    47,    64,    67,    70,    66,    34,    35,
00266       36,    32,    75,    69,    33,    51,    52,    53,    54,     5
00267 };
00268 
00269 static const short yycheck[] =
00270 {
00271       19,     4,    24,     0,     5,     6,     3,     7,     3,     9,
00272       13,    14,    13,    13,    15,    16,    17,    24,    37,    38,
00273       12,    13,    25,    19,    25,    25,     8,    20,    10,    12,
00274       13,    13,    18,    25,    12,    13,    55,    56,    57,    58,
00275       12,    13,    25,    25,    56,    57,    58,    25,    22,    23,
00276       24,    24,     0,    25,    24,    24,    24,    24,    24,     2
00277 };
00278 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
00279 #line 3 "/usr/share/bison/bison.simple"
00280 
00281 /* Skeleton output parser for bison,
00282 
00283    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
00284    Foundation, Inc.
00285 
00286    This program is free software; you can redistribute it and/or modify
00287    it under the terms of the GNU General Public License as published by
00288    the Free Software Foundation; either version 2, or (at your option)
00289    any later version.
00290 
00291    This program is distributed in the hope that it will be useful,
00292    but WITHOUT ANY WARRANTY; without even the implied warranty of
00293    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00294    GNU General Public License for more details.
00295 
00296    You should have received a copy of the GNU General Public License
00297    along with this program; if not, write to the Free Software
00298    Foundation, Inc., 59 Temple Place - Suite 330,
00299    Boston, MA 02111-1307, USA.  */
00300 
00301 /* As a special exception, when this file is copied by Bison into a
00302    Bison output file, you may use that output file without restriction.
00303    This special exception was added by the Free Software Foundation
00304    in version 1.24 of Bison.  */
00305 
00306 /* This is the parser code that is written into each bison parser when
00307    the %semantic_parser declaration is not specified in the grammar.
00308    It was written by Richard Stallman by simplifying the hairy parser
00309    used when %semantic_parser is specified.  */
00310 
00311 /* All symbols defined below should begin with yy or YY, to avoid
00312    infringing on user name space.  This should be done even for local
00313    variables, as they might otherwise be expanded by user macros.
00314    There are some unavoidable exceptions within include files to
00315    define necessary library symbols; they are noted "INFRINGES ON
00316    USER NAME SPACE" below.  */
00317 
00318 #if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
00319 
00320 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00321 
00322 # if YYSTACK_USE_ALLOCA
00323 #  define YYSTACK_ALLOC alloca
00324 # else
00325 #  ifndef YYSTACK_USE_ALLOCA
00326 #   if defined (alloca) || defined (_ALLOCA_H)
00327 #    define YYSTACK_ALLOC alloca
00328 #   else
00329 #    ifdef __GNUC__
00330 #     define YYSTACK_ALLOC __builtin_alloca
00331 #    endif
00332 #   endif
00333 #  endif
00334 # endif
00335 
00336 # ifdef YYSTACK_ALLOC
00337    /* Pacify GCC's `empty if-body' warning. */
00338 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
00339 # else
00340 #  if defined (__STDC__) || defined (__cplusplus)
00341 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00342 #   define YYSIZE_T size_t
00343 #  endif
00344 #  define YYSTACK_ALLOC malloc
00345 #  define YYSTACK_FREE free
00346 # endif
00347 #endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
00348 
00349 
00350 #if (! defined (yyoverflow) \
00351      && (! defined (__cplusplus) \
00352          || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00353 
00354 /* A type that is properly aligned for any stack member.  */
00355 union yyalloc
00356 {
00357   short yyss;
00358   YYSTYPE yyvs;
00359 # if YYLSP_NEEDED
00360   YYLTYPE yyls;
00361 # endif
00362 };
00363 
00364 /* The size of the maximum gap between one aligned stack and the next.  */
00365 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
00366 
00367 /* The size of an array large to enough to hold all stacks, each with
00368    N elements.  */
00369 # if YYLSP_NEEDED
00370 #  define YYSTACK_BYTES(N) \
00371      ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))      \
00372       + 2 * YYSTACK_GAP_MAX)
00373 # else
00374 #  define YYSTACK_BYTES(N) \
00375      ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
00376       + YYSTACK_GAP_MAX)
00377 # endif
00378 
00379 /* Copy COUNT objects from FROM to TO.  The source and destination do
00380    not overlap.  */
00381 # ifndef YYCOPY
00382 #  if 1 < __GNUC__
00383 #   define YYCOPY(To, From, Count) \
00384       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00385 #  else
00386 #   define YYCOPY(To, From, Count)              \
00387       do                                        \
00388         {                                       \
00389           register YYSIZE_T yyi;                \
00390           for (yyi = 0; yyi < (Count); yyi++)   \
00391             (To)[yyi] = (From)[yyi];            \
00392         }                                       \
00393       while (0)
00394 #  endif
00395 # endif
00396 
00397 /* Relocate STACK from its old location to the new one.  The
00398    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00399    elements in the stack, and YYPTR gives the new location of the
00400    stack.  Advance YYPTR to a properly aligned location for the next
00401    stack.  */
00402 # define YYSTACK_RELOCATE(Stack)                                        \
00403     do                                                                  \
00404       {                                                                 \
00405         YYSIZE_T yynewbytes;                                            \
00406         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
00407         Stack = &yyptr->Stack;                                          \
00408         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;   \
00409         yyptr += yynewbytes / sizeof (*yyptr);                          \
00410       }                                                                 \
00411     while (0)
00412 
00413 #endif
00414 
00415 
00416 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
00417 # define YYSIZE_T __SIZE_TYPE__
00418 #endif
00419 #if ! defined (YYSIZE_T) && defined (size_t)
00420 # define YYSIZE_T size_t
00421 #endif
00422 #if ! defined (YYSIZE_T)
00423 # if defined (__STDC__) || defined (__cplusplus)
00424 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00425 #  define YYSIZE_T size_t
00426 # endif
00427 #endif
00428 #if ! defined (YYSIZE_T)
00429 # define YYSIZE_T unsigned int
00430 #endif
00431 
00432 #define yyerrok         (yyerrstatus = 0)
00433 #define yyclearin       (yychar = YYEMPTY)
00434 #define YYEMPTY         -2
00435 #define YYEOF           0
00436 #define YYACCEPT        goto yyacceptlab
00437 #define YYABORT         goto yyabortlab
00438 #define YYERROR         goto yyerrlab1
00439 /* Like YYERROR except do call yyerror.  This remains here temporarily
00440    to ease the transition to the new meaning of YYERROR, for GCC.
00441    Once GCC version 2 has supplanted version 1, this can go.  */
00442 #define YYFAIL          goto yyerrlab
00443 #define YYRECOVERING()  (!!yyerrstatus)
00444 #define YYBACKUP(Token, Value)                                  \
00445 do                                                              \
00446   if (yychar == YYEMPTY && yylen == 1)                          \
00447     {                                                           \
00448       yychar = (Token);                                         \
00449       yylval = (Value);                                         \
00450       yychar1 = YYTRANSLATE (yychar);                           \
00451       YYPOPSTACK;                                               \
00452       goto yybackup;                                            \
00453     }                                                           \
00454   else                                                          \
00455     {                                                           \
00456       yyerror ("syntax error: cannot back up");                 \
00457       YYERROR;                                                  \
00458     }                                                           \
00459 while (0)
00460 
00461 #define YYTERROR        1
00462 #define YYERRCODE       256
00463 
00464 
00465 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
00466    are run).
00467 
00468    When YYLLOC_DEFAULT is run, CURRENT is set the location of the
00469    first token.  By default, to implement support for ranges, extend
00470    its range to the last symbol.  */
00471 
00472 #ifndef YYLLOC_DEFAULT
00473 # define YYLLOC_DEFAULT(Current, Rhs, N)        \
00474    Current.last_line   = Rhs[N].last_line;      \
00475    Current.last_column = Rhs[N].last_column;
00476 #endif
00477 
00478 
00479 /* YYLEX -- calling `yylex' with the right arguments.  */
00480 
00481 #if YYPURE
00482 # if YYLSP_NEEDED
00483 #  ifdef YYLEX_PARAM
00484 #   define YYLEX                yylex (&yylval, &yylloc, YYLEX_PARAM)
00485 #  else
00486 #   define YYLEX                yylex (&yylval, &yylloc)
00487 #  endif
00488 # else /* !YYLSP_NEEDED */
00489 #  ifdef YYLEX_PARAM
00490 #   define YYLEX                yylex (&yylval, YYLEX_PARAM)
00491 #  else
00492 #   define YYLEX                yylex (&yylval)
00493 #  endif
00494 # endif /* !YYLSP_NEEDED */
00495 #else /* !YYPURE */
00496 # define YYLEX                  yylex ()
00497 #endif /* !YYPURE */
00498 
00499 
00500 /* Enable debugging if requested.  */
00501 #if YYDEBUG
00502 
00503 # ifndef YYFPRINTF
00504 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
00505 #  define YYFPRINTF fprintf
00506 # endif
00507 
00508 # define YYDPRINTF(Args)                        \
00509 do {                                            \
00510   if (yydebug)                                  \
00511     YYFPRINTF Args;                             \
00512 } while (0)
00513 /* Nonzero means print parse trace.  It is left uninitialized so that
00514    multiple parsers can coexist.  */
00515 int yydebug;
00516 #else /* !YYDEBUG */
00517 # define YYDPRINTF(Args)
00518 #endif /* !YYDEBUG */
00519 
00520 /* YYINITDEPTH -- initial size of the parser's stacks.  */
00521 #ifndef YYINITDEPTH
00522 # define YYINITDEPTH 200
00523 #endif
00524 
00525 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
00526    if the built-in stack extension method is used).
00527 
00528    Do not make this value too large; the results are undefined if
00529    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
00530    evaluated with infinite-precision integer arithmetic.  */
00531 
00532 #if YYMAXDEPTH == 0
00533 # undef YYMAXDEPTH
00534 #endif
00535 
00536 #ifndef YYMAXDEPTH
00537 # define YYMAXDEPTH 10000
00538 #endif
00539 
00540 #ifdef YYERROR_VERBOSE
00541 
00542 # ifndef yystrlen
00543 #  if defined (__GLIBC__) && defined (_STRING_H)
00544 #   define yystrlen strlen
00545 #  else
00546 /* Return the length of YYSTR.  */
00547 static YYSIZE_T
00548 #   if defined (__STDC__) || defined (__cplusplus)
00549 yystrlen (const char *yystr)
00550 #   else
00551 yystrlen (yystr)
00552      const char *yystr;
00553 #   endif
00554 {
00555   register const char *yys = yystr;
00556 
00557   while (*yys++ != '\0')
00558     continue;
00559 
00560   return yys - yystr - 1;
00561 }
00562 #  endif
00563 # endif
00564 
00565 # ifndef yystpcpy
00566 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
00567 #   define yystpcpy stpcpy
00568 #  else
00569 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
00570    YYDEST.  */
00571 static char *
00572 #   if defined (__STDC__) || defined (__cplusplus)
00573 yystpcpy (char *yydest, const char *yysrc)
00574 #   else
00575 yystpcpy (yydest, yysrc)
00576      char *yydest;
00577      const char *yysrc;
00578 #   endif
00579 {
00580   register char *yyd = yydest;
00581   register const char *yys = yysrc;
00582 
00583   while ((*yyd++ = *yys++) != '\0')
00584     continue;
00585 
00586   return yyd - 1;
00587 }
00588 #  endif
00589 # endif
00590 #endif
00591 
00592 #line 315 "/usr/share/bison/bison.simple"
00593 
00594 
00595 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
00596    into yyparse.  The argument should have type void *.
00597    It should actually point to an object.
00598    Grammar actions can access the variable by casting it
00599    to the proper pointer type.  */
00600 
00601 #ifdef YYPARSE_PARAM
00602 # if defined (__STDC__) || defined (__cplusplus)
00603 #  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
00604 #  define YYPARSE_PARAM_DECL
00605 # else
00606 #  define YYPARSE_PARAM_ARG YYPARSE_PARAM
00607 #  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
00608 # endif
00609 #else /* !YYPARSE_PARAM */
00610 # define YYPARSE_PARAM_ARG
00611 # define YYPARSE_PARAM_DECL
00612 #endif /* !YYPARSE_PARAM */
00613 
00614 /* Prevent warning if -Wstrict-prototypes.  */
00615 #ifdef __GNUC__
00616 # ifdef YYPARSE_PARAM
00617 int yyparse (void *);
00618 # else
00619 int yyparse (void);
00620 # endif
00621 #endif
00622 
00623 /* YY_DECL_VARIABLES -- depending whether we use a pure parser,
00624    variables are global, or local to YYPARSE.  */
00625 
00626 #define YY_DECL_NON_LSP_VARIABLES                       \
00627 /* The lookahead symbol.  */                            \
00628 int yychar;                                             \
00629                                                         \
00630 /* The semantic value of the lookahead symbol. */       \
00631 YYSTYPE yylval;                                         \
00632                                                         \
00633 /* Number of parse errors so far.  */                   \
00634 int yynerrs;
00635 
00636 #if YYLSP_NEEDED
00637 # define YY_DECL_VARIABLES                      \
00638 YY_DECL_NON_LSP_VARIABLES                       \
00639                                                 \
00640 /* Location data for the lookahead symbol.  */  \
00641 YYLTYPE yylloc;
00642 #else
00643 # define YY_DECL_VARIABLES                      \
00644 YY_DECL_NON_LSP_VARIABLES
00645 #endif
00646 
00647 
00648 /* If nonreentrant, generate the variables here. */
00649 
00650 #if !YYPURE
00651 YY_DECL_VARIABLES
00652 #endif  /* !YYPURE */
00653 
00654 int
00655 yyparse (YYPARSE_PARAM_ARG)
00656      YYPARSE_PARAM_DECL
00657 {
00658   /* If reentrant, generate the variables here. */
00659 #if YYPURE
00660   YY_DECL_VARIABLES
00661 #endif  /* !YYPURE */
00662 
00663   register int yystate;
00664   register int yyn;
00665   int yyresult;
00666   /* Number of tokens to shift before error messages enabled.  */
00667   int yyerrstatus;
00668   /* Lookahead token as an internal (translated) token number.  */
00669   int yychar1 = 0;
00670 
00671   /* Three stacks and their tools:
00672      `yyss': related to states,
00673      `yyvs': related to semantic values,
00674      `yyls': related to locations.
00675 
00676      Refer to the stacks thru separate pointers, to allow yyoverflow
00677      to reallocate them elsewhere.  */
00678 
00679   /* The state stack. */
00680   short yyssa[YYINITDEPTH];
00681   short *yyss = yyssa;
00682   register short *yyssp;
00683 
00684   /* The semantic value stack.  */
00685   YYSTYPE yyvsa[YYINITDEPTH];
00686   YYSTYPE *yyvs = yyvsa;
00687   register YYSTYPE *yyvsp;
00688 
00689 #if YYLSP_NEEDED
00690   /* The location stack.  */
00691   YYLTYPE yylsa[YYINITDEPTH];
00692   YYLTYPE *yyls = yylsa;
00693   YYLTYPE *yylsp;
00694 #endif
00695 
00696 #if YYLSP_NEEDED
00697 # define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
00698 #else
00699 # define YYPOPSTACK   (yyvsp--, yyssp--)
00700 #endif
00701 
00702   YYSIZE_T yystacksize = YYINITDEPTH;
00703 
00704 
00705   /* The variables used to return semantic value and location from the
00706      action routines.  */
00707   YYSTYPE yyval;
00708 #if YYLSP_NEEDED
00709   YYLTYPE yyloc;
00710 #endif
00711 
00712   /* When reducing, the number of symbols on the RHS of the reduced
00713      rule. */
00714   int yylen;
00715 
00716   YYDPRINTF ((stderr, "Starting parse\n"));
00717 
00718   yystate = 0;
00719   yyerrstatus = 0;
00720   yynerrs = 0;
00721   yychar = YYEMPTY;             /* Cause a token to be read.  */
00722 
00723   /* Initialize stack pointers.
00724      Waste one element of value and location stack
00725      so that they stay on the same level as the state stack.
00726      The wasted elements are never initialized.  */
00727 
00728   yyssp = yyss;
00729   yyvsp = yyvs;
00730 #if YYLSP_NEEDED
00731   yylsp = yyls;
00732 #endif
00733   goto yysetstate;
00734 
00735 /*------------------------------------------------------------.
00736 | yynewstate -- Push a new state, which is found in yystate.  |
00737 `------------------------------------------------------------*/
00738  yynewstate:
00739   /* In all cases, when you get here, the value and location stacks
00740      have just been pushed. so pushing a state here evens the stacks.
00741      */
00742   yyssp++;
00743 
00744  yysetstate:
00745   *yyssp = yystate;
00746 
00747   if (yyssp >= yyss + yystacksize - 1)
00748     {
00749       /* Get the current used size of the three stacks, in elements.  */
00750       YYSIZE_T yysize = yyssp - yyss + 1;
00751 
00752 #ifdef yyoverflow
00753       {
00754         /* Give user a chance to reallocate the stack. Use copies of
00755            these so that the &'s don't force the real ones into
00756            memory.  */
00757         YYSTYPE *yyvs1 = yyvs;
00758         short *yyss1 = yyss;
00759 
00760         /* Each stack pointer address is followed by the size of the
00761            data in use in that stack, in bytes.  */
00762 # if YYLSP_NEEDED
00763         YYLTYPE *yyls1 = yyls;
00764         /* This used to be a conditional around just the two extra args,
00765            but that might be undefined if yyoverflow is a macro.  */
00766         yyoverflow ("parser stack overflow",
00767                     &yyss1, yysize * sizeof (*yyssp),
00768                     &yyvs1, yysize * sizeof (*yyvsp),
00769                     &yyls1, yysize * sizeof (*yylsp),
00770                     &yystacksize);
00771         yyls = yyls1;
00772 # else
00773         yyoverflow ("parser stack overflow",
00774                     &yyss1, yysize * sizeof (*yyssp),
00775                     &yyvs1, yysize * sizeof (*yyvsp),
00776                     &yystacksize);
00777 # endif
00778         yyss = yyss1;
00779         yyvs = yyvs1;
00780       }
00781 #else /* no yyoverflow */
00782 # ifndef YYSTACK_RELOCATE
00783       goto yyoverflowlab;
00784 # else
00785       /* Extend the stack our own way.  */
00786       if (yystacksize >= YYMAXDEPTH)
00787         goto yyoverflowlab;
00788       yystacksize *= 2;
00789       if (yystacksize > YYMAXDEPTH)
00790         yystacksize = YYMAXDEPTH;
00791 
00792       {
00793         short *yyss1 = yyss;
00794         union yyalloc *yyptr =
00795           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
00796         if (! yyptr)
00797           goto yyoverflowlab;
00798         YYSTACK_RELOCATE (yyss);
00799         YYSTACK_RELOCATE (yyvs);
00800 # if YYLSP_NEEDED
00801         YYSTACK_RELOCATE (yyls);
00802 # endif
00803 # undef YYSTACK_RELOCATE
00804         if (yyss1 != yyssa)
00805           YYSTACK_FREE (yyss1);
00806       }
00807 # endif
00808 #endif /* no yyoverflow */
00809 
00810       yyssp = yyss + yysize - 1;
00811       yyvsp = yyvs + yysize - 1;
00812 #if YYLSP_NEEDED
00813       yylsp = yyls + yysize - 1;
00814 #endif
00815 
00816       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
00817                   (unsigned long int) yystacksize));
00818 
00819       if (yyssp >= yyss + yystacksize - 1)
00820         YYABORT;
00821     }
00822 
00823   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
00824 
00825   goto yybackup;
00826 
00827 
00828 /*-----------.
00829 | yybackup.  |
00830 `-----------*/
00831 yybackup:
00832 
00833 /* Do appropriate processing given the current state.  */
00834 /* Read a lookahead token if we need one and don't already have one.  */
00835 /* yyresume: */
00836 
00837   /* First try to decide what to do without reference to lookahead token.  */
00838 
00839   yyn = yypact[yystate];
00840   if (yyn == YYFLAG)
00841     goto yydefault;
00842 
00843   /* Not known => get a lookahead token if don't already have one.  */
00844 
00845   /* yychar is either YYEMPTY or YYEOF
00846      or a valid token in external form.  */
00847 
00848   if (yychar == YYEMPTY)
00849     {
00850       YYDPRINTF ((stderr, "Reading a token: "));
00851       yychar = YYLEX;
00852     }
00853 
00854   /* Convert token to internal form (in yychar1) for indexing tables with */
00855 
00856   if (yychar <= 0)              /* This means end of input. */
00857     {
00858       yychar1 = 0;
00859       yychar = YYEOF;           /* Don't call YYLEX any more */
00860 
00861       YYDPRINTF ((stderr, "Now at end of input.\n"));
00862     }
00863   else
00864     {
00865       yychar1 = YYTRANSLATE (yychar);
00866 
00867 #if YYDEBUG
00868      /* We have to keep this `#if YYDEBUG', since we use variables
00869         which are defined only if `YYDEBUG' is set.  */
00870       if (yydebug)
00871         {
00872           YYFPRINTF (stderr, "Next token is %d (%s",
00873                      yychar, yytname[yychar1]);
00874           /* Give the individual parser a way to print the precise
00875              meaning of a token, for further debugging info.  */
00876 # ifdef YYPRINT
00877           YYPRINT (stderr, yychar, yylval);
00878 # endif
00879           YYFPRINTF (stderr, ")\n");
00880         }
00881 #endif
00882     }
00883 
00884   yyn += yychar1;
00885   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
00886     goto yydefault;
00887 
00888   yyn = yytable[yyn];
00889 
00890   /* yyn is what to do for this token type in this state.
00891      Negative => reduce, -yyn is rule number.
00892      Positive => shift, yyn is new state.
00893        New state is final state => don't bother to shift,
00894        just return success.
00895      0, or most negative number => error.  */
00896 
00897   if (yyn < 0)
00898     {
00899       if (yyn == YYFLAG)
00900         goto yyerrlab;
00901       yyn = -yyn;
00902       goto yyreduce;
00903     }
00904   else if (yyn == 0)
00905     goto yyerrlab;
00906 
00907   if (yyn == YYFINAL)
00908     YYACCEPT;
00909 
00910   /* Shift the lookahead token.  */
00911   YYDPRINTF ((stderr, "Shifting token %d (%s), ",
00912               yychar, yytname[yychar1]));
00913 
00914   /* Discard the token being shifted unless it is eof.  */
00915   if (yychar != YYEOF)
00916     yychar = YYEMPTY;
00917 
00918   *++yyvsp = yylval;
00919 #if YYLSP_NEEDED
00920   *++yylsp = yylloc;
00921 #endif
00922 
00923   /* Count tokens shifted since error; after three, turn off error
00924      status.  */
00925   if (yyerrstatus)
00926     yyerrstatus--;
00927 
00928   yystate = yyn;
00929   goto yynewstate;
00930 
00931 
00932 /*-----------------------------------------------------------.
00933 | yydefault -- do the default action for the current state.  |
00934 `-----------------------------------------------------------*/
00935 yydefault:
00936   yyn = yydefact[yystate];
00937   if (yyn == 0)
00938     goto yyerrlab;
00939   goto yyreduce;
00940 
00941 
00942 /*-----------------------------.
00943 | yyreduce -- Do a reduction.  |
00944 `-----------------------------*/
00945 yyreduce:
00946   /* yyn is the number of a rule to reduce with.  */
00947   yylen = yyr2[yyn];
00948 
00949   /* If YYLEN is nonzero, implement the default value of the action:
00950      `$$ = $1'.
00951 
00952      Otherwise, the following line sets YYVAL to the semantic value of
00953      the lookahead token.  This behavior is undocumented and Bison
00954      users should not rely upon it.  Assigning to YYVAL
00955      unconditionally makes the parser a bit smaller, and it avoids a
00956      GCC warning that YYVAL may be used uninitialized.  */
00957   yyval = yyvsp[1-yylen];
00958 
00959 #if YYLSP_NEEDED
00960   /* Similarly for the default location.  Let the user run additional
00961      commands if for instance locations are ranges.  */
00962   yyloc = yylsp[1-yylen];
00963   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
00964 #endif
00965 
00966 #if YYDEBUG
00967   /* We have to keep this `#if YYDEBUG', since we use variables which
00968      are defined only if `YYDEBUG' is set.  */
00969   if (yydebug)
00970     {
00971       int yyi;
00972 
00973       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
00974                  yyn, yyrline[yyn]);
00975 
00976       /* Print the symbols being reduced, and their result.  */
00977       for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
00978         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
00979       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
00980     }
00981 #endif
00982 
00983   switch (yyn) {
00984 
00985 case 1:
00986 #line 179 "oep.yy"
00987 {
00988           oep_global->setFactory(yyvsp[0].cfps);
00989         ;
00990     break;}
00991 case 2:
00992 #line 183 "oep.yy"
00993 {
00994           oep_global->setFactory(yyvsp[0].cfps);
00995         ;
00996     break;}
00997 case 3:
00998 #line 193 "oep.yy"
00999 {
01000           /* check mandatory parameters */
01001           if (yyvsp[-1].cfps->getKey() == NULL)
01002           {
01003             yyerror("missing mandatory parameter");
01004             YYABORT;
01005           }
01006           yyval.cfps = yyvsp[-1].cfps;
01007         ;
01008     break;}
01009 case 4:
01010 #line 206 "oep.yy"
01011 {
01012            if (yyval.cfps->getPort())
01013            {
01014               yyerror("duplicate parameter");
01015               YYABORT;
01016            }
01017            yyval.cfps->setPort(yyvsp[0].ival);
01018         ;
01019     break;}
01020 case 5:
01021 #line 215 "oep.yy"
01022 {
01023            if (yyval.cfps->getKey())
01024            {
01025               yyerror("duplicate parameter");
01026               YYABORT;
01027            }
01028            yyval.cfps->setKey(yyvsp[0].kval);
01029         ;
01030     break;}
01031 case 6:
01032 #line 224 "oep.yy"
01033 {
01034            yyval.cfps->addChannel(yyvsp[0].ecps);
01035         ;
01036     break;}
01037 case 7:
01038 #line 228 "oep.yy"
01039 {
01040            /* allocate and initialise */
01041            yyval.cfps = new OEP_cfps();
01042         ;
01043     break;}
01044 case 8:
01045 #line 239 "oep.yy"
01046 {
01047           /* check mandatory parameters */
01048           if (yyvsp[-1].ecps->getKey() == NULL)
01049           {
01050             yyerror("missing mandatory parameter");
01051             YYABORT;
01052           }
01053           yyval.ecps = yyvsp[-1].ecps;
01054         ;
01055     break;}
01056 case 9:
01057 #line 252 "oep.yy"
01058 {
01059            if (yyval.ecps->getKey())
01060            {
01061               yyerror("duplicate parameter");
01062               YYABORT;
01063            }
01064            yyval.ecps->setKey(yyvsp[0].kval);
01065         ;
01066     break;}
01067 case 10:
01068 #line 261 "oep.yy"
01069 {
01070            yyval.ecps->setPullRetryPeriod(yyvsp[0].ival);
01071         ;
01072     break;}
01073 case 11:
01074 #line 265 "oep.yy"
01075 {
01076            yyval.ecps->setMaxQueueLength(yyvsp[0].ival);
01077         ;
01078     break;}
01079 case 12:
01080 #line 269 "oep.yy"
01081 {
01082            yyval.ecps->setMaxEventsPerConsumer(yyvsp[0].ival);
01083         ;
01084     break;}
01085 case 13:
01086 #line 273 "oep.yy"
01087 {
01088            yyval.ecps->addSupplierAdmin(yyvsp[0].saps);
01089         ;
01090     break;}
01091 case 14:
01092 #line 277 "oep.yy"
01093 {
01094            yyval.ecps->addConsumerAdmin(yyvsp[0].caps);
01095         ;
01096     break;}
01097 case 15:
01098 #line 281 "oep.yy"
01099 {
01100            /* allocate and initialise */
01101            yyval.ecps = new OEP_ecps;
01102         ;
01103     break;}
01104 case 16:
01105 #line 292 "oep.yy"
01106 {
01107           /* check mandatory parameters */
01108           if (yyvsp[-1].caps->getKey() == NULL)
01109           {
01110             yyerror("missing mandatory parameter");
01111             YYABORT;
01112           }
01113           yyval.caps = yyvsp[-1].caps;
01114         ;
01115     break;}
01116 case 17:
01117 #line 305 "oep.yy"
01118 {
01119            if (yyval.caps->getKey())
01120            {
01121               yyerror("duplicate parameter");
01122               YYABORT;
01123            }
01124            yyval.caps->setKey(yyvsp[0].kval);
01125         ;
01126     break;}
01127 case 18:
01128 #line 314 "oep.yy"
01129 {
01130            yyval.caps->addProxyPushSupplier(yyvsp[0].prxy);
01131         ;
01132     break;}
01133 case 19:
01134 #line 318 "oep.yy"
01135 {
01136            yyval.caps->addProxyPullSupplier(yyvsp[0].prxy);
01137         ;
01138     break;}
01139 case 20:
01140 #line 322 "oep.yy"
01141 {
01142            /* allocate and initialise */
01143            yyval.caps = new OEP_caps;
01144         ;
01145     break;}
01146 case 21:
01147 #line 333 "oep.yy"
01148 {
01149           /* check mandatory parameters */
01150           if (yyvsp[-1].saps->getKey() == NULL)
01151           {
01152             yyerror("missing mandatory parameter");
01153             YYABORT;
01154           }
01155           yyval.saps = yyvsp[-1].saps;
01156         ;
01157     break;}
01158 case 22:
01159 #line 346 "oep.yy"
01160 {
01161            if (yyval.saps->getKey())
01162            {
01163               yyerror("duplicate parameter");
01164               YYABORT;
01165            }
01166            yyval.saps->setKey(yyvsp[0].kval);
01167         ;
01168     break;}
01169 case 23:
01170 #line 355 "oep.yy"
01171 {
01172            yyval.saps->addProxyPushConsumer(yyvsp[0].prxy);
01173         ;
01174     break;}
01175 case 24:
01176 #line 359 "oep.yy"
01177 {
01178            yyval.saps->addProxyPullConsumer(yyvsp[0].prxy);
01179         ;
01180     break;}
01181 case 25:
01182 #line 363 "oep.yy"
01183 {
01184            /* allocate and initialise */
01185            yyval.saps = new OEP_saps;
01186         ;
01187     break;}
01188 case 26:
01189 #line 374 "oep.yy"
01190 {
01191           /* check mandatory parameters */
01192           if (yyvsp[-1].prxy->getKey() == NULL)
01193           {
01194             yyerror("missing mandatory parameter");
01195             YYABORT;
01196           }
01197           yyval.prxy = yyvsp[-1].prxy;
01198         ;
01199     break;}
01200 case 27:
01201 #line 387 "oep.yy"
01202 {
01203            if (yyval.prxy->getKey())
01204            {
01205               yyerror("duplicate parameter");
01206               YYABORT;
01207            }
01208            yyval.prxy->setKey(yyvsp[0].kval);
01209         ;
01210     break;}
01211 case 28:
01212 #line 396 "oep.yy"
01213 {
01214            if (yyval.prxy->getIor())
01215            {
01216               yyerror("duplicate parameter");
01217               YYABORT;
01218            }
01219            yyval.prxy->setIor(yyvsp[0].sval);
01220         ;
01221     break;}
01222 case 29:
01223 #line 405 "oep.yy"
01224 {
01225            /* allocate and initialise */
01226            yyval.prxy = new OEP_prxy;
01227         ;
01228     break;}
01229 case 30:
01230 #line 416 "oep.yy"
01231 {
01232           /* check mandatory parameters */
01233           if (yyvsp[-1].prxy->getKey() == NULL)
01234           {
01235             yyerror("missing mandatory parameter");
01236             YYABORT;
01237           }
01238           yyval.prxy = yyvsp[-1].prxy;
01239         ;
01240     break;}
01241 case 31:
01242 #line 429 "oep.yy"
01243 {
01244            if (yyval.prxy->getKey())
01245            {
01246               yyerror("duplicate parameter");
01247               YYABORT;
01248            }
01249            yyval.prxy->setKey(yyvsp[0].kval);
01250         ;
01251     break;}
01252 case 32:
01253 #line 438 "oep.yy"
01254 {
01255            if (yyval.prxy->getIor())
01256            {
01257               yyerror("duplicate parameter");
01258               YYABORT;
01259            }
01260            yyval.prxy->setIor(yyvsp[0].sval);
01261         ;
01262     break;}
01263 case 33:
01264 #line 447 "oep.yy"
01265 {
01266            /* allocate and initialise */
01267            yyval.prxy = new OEP_prxy;
01268         ;
01269     break;}
01270 case 34:
01271 #line 458 "oep.yy"
01272 {
01273           /* check mandatory parameters */
01274           if (yyvsp[-1].prxy->getKey() == NULL)
01275           {
01276             yyerror("missing mandatory parameter");
01277             YYABORT;
01278           }
01279           yyval.prxy = yyvsp[-1].prxy;
01280         ;
01281     break;}
01282 case 35:
01283 #line 471 "oep.yy"
01284 {
01285            if (yyval.prxy->getKey())
01286            {
01287               yyerror("duplicate parameter");
01288               YYABORT;
01289            }
01290            yyval.prxy->setKey(yyvsp[0].kval);
01291         ;
01292     break;}
01293 case 36:
01294 #line 480 "oep.yy"
01295 {
01296            if (yyval.prxy->getIor())
01297            {
01298               yyerror("duplicate parameter");
01299               YYABORT;
01300            }
01301            yyval.prxy->setIor(yyvsp[0].sval);
01302         ;
01303     break;}
01304 case 37:
01305 #line 489 "oep.yy"
01306 {
01307            /* allocate and initialise */
01308            yyval.prxy = new OEP_prxy;
01309         ;
01310     break;}
01311 case 38:
01312 #line 500 "oep.yy"
01313 {
01314           /* check mandatory parameters */
01315           if (yyvsp[-1].prxy->getKey() == NULL)
01316           {
01317             yyerror("missing mandatory parameter");
01318             YYABORT;
01319           }
01320           yyval.prxy = yyvsp[-1].prxy;
01321         ;
01322     break;}
01323 case 39:
01324 #line 513 "oep.yy"
01325 {
01326            if (yyval.prxy->getKey())
01327            {
01328               yyerror("duplicate parameter");
01329               YYABORT;
01330            }
01331            yyval.prxy->setKey(yyvsp[0].kval);
01332         ;
01333     break;}
01334 case 40:
01335 #line 522 "oep.yy"
01336 {
01337            if (yyval.prxy->getIor())
01338            {
01339               yyerror("duplicate parameter");
01340               YYABORT;
01341            }
01342            yyval.prxy->setIor(yyvsp[0].sval);
01343         ;
01344     break;}
01345 case 41:
01346 #line 531 "oep.yy"
01347 {
01348            /* allocate and initialise */
01349            yyval.prxy = new OEP_prxy;
01350         ;
01351     break;}
01352 case 42:
01353 #line 539 "oep.yy"
01354 {
01355            yyval.ival = yyvsp[0].ival;
01356         ;
01357     break;}
01358 case 43:
01359 #line 546 "oep.yy"
01360 {
01361            yyval.ival = yyvsp[0].ival;
01362         ;
01363     break;}
01364 case 44:
01365 #line 553 "oep.yy"
01366 {
01367            yyval.ival = yyvsp[0].ival;
01368         ;
01369     break;}
01370 case 45:
01371 #line 560 "oep.yy"
01372 {
01373            yyval.ival = yyvsp[0].ival;
01374         ;
01375     break;}
01376 case 46:
01377 #line 567 "oep.yy"
01378 {
01379            yyval.sval = yyvsp[0].sval;
01380         ;
01381     break;}
01382 case 47:
01383 #line 574 "oep.yy"
01384 {
01385            yyval.kval = yyvsp[0].kval;
01386         ;
01387     break;}
01388 case 48:
01389 #line 581 "oep.yy"
01390 {
01391            yyval.sval = yyvsp[0].sval;
01392         ;
01393     break;}
01394 case 49:
01395 #line 588 "oep.yy"
01396 {
01397            yyval.kval = yyvsp[0].kval;
01398         ;
01399     break;}
01400 case 50:
01401 #line 595 "oep.yy"
01402 {
01403            yyval.ival = yyvsp[0].ival;
01404         ;
01405     break;}
01406 case 51:
01407 #line 602 "oep.yy"
01408 {
01409            yyval.sval = yyvsp[0].sval;
01410         ;
01411     break;}
01412 }
01413 
01414 #line 705 "/usr/share/bison/bison.simple"
01415 
01416 
01417   yyvsp -= yylen;
01418   yyssp -= yylen;
01419 #if YYLSP_NEEDED
01420   yylsp -= yylen;
01421 #endif
01422 
01423 #if YYDEBUG
01424   if (yydebug)
01425     {
01426       short *yyssp1 = yyss - 1;
01427       YYFPRINTF (stderr, "state stack now");
01428       while (yyssp1 != yyssp)
01429         YYFPRINTF (stderr, " %d", *++yyssp1);
01430       YYFPRINTF (stderr, "\n");
01431     }
01432 #endif
01433 
01434   *++yyvsp = yyval;
01435 #if YYLSP_NEEDED
01436   *++yylsp = yyloc;
01437 #endif
01438 
01439   /* Now `shift' the result of the reduction.  Determine what state
01440      that goes to, based on the state we popped back to and the rule
01441      number reduced by.  */
01442 
01443   yyn = yyr1[yyn];
01444 
01445   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
01446   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01447     yystate = yytable[yystate];
01448   else
01449     yystate = yydefgoto[yyn - YYNTBASE];
01450 
01451   goto yynewstate;
01452 
01453 
01454 /*------------------------------------.
01455 | yyerrlab -- here on detecting error |
01456 `------------------------------------*/
01457 yyerrlab:
01458   /* If not already recovering from an error, report this error.  */
01459   if (!yyerrstatus)
01460     {
01461       ++yynerrs;
01462 
01463 #ifdef YYERROR_VERBOSE
01464       yyn = yypact[yystate];
01465 
01466       if (yyn > YYFLAG && yyn < YYLAST)
01467         {
01468           YYSIZE_T yysize = 0;
01469           char *yymsg;
01470           int yyx, yycount;
01471 
01472           yycount = 0;
01473           /* Start YYX at -YYN if negative to avoid negative indexes in
01474              YYCHECK.  */
01475           for (yyx = yyn < 0 ? -yyn : 0;
01476                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
01477             if (yycheck[yyx + yyn] == yyx)
01478               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
01479           yysize += yystrlen ("parse error, unexpected ") + 1;
01480           yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
01481           yymsg = (char *) YYSTACK_ALLOC (yysize);
01482           if (yymsg != 0)
01483             {
01484               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
01485               yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
01486 
01487               if (yycount < 5)
01488                 {
01489                   yycount = 0;
01490                   for (yyx = yyn < 0 ? -yyn : 0;
01491                        yyx < (int) (sizeof (yytname) / sizeof (char *));
01492                        yyx++)
01493                     if (yycheck[yyx + yyn] == yyx)
01494                       {
01495                         const char *yyq = ! yycount ? ", expecting " : " or ";
01496                         yyp = yystpcpy (yyp, yyq);
01497                         yyp = yystpcpy (yyp, yytname[yyx]);
01498                         yycount++;
01499                       }
01500                 }
01501               yyerror (yymsg);
01502               YYSTACK_FREE (yymsg);
01503             }
01504           else
01505             yyerror ("parse error; also virtual memory exhausted");
01506         }
01507       else
01508 #endif /* defined (YYERROR_VERBOSE) */
01509         yyerror ("parse error");
01510     }
01511   goto yyerrlab1;
01512 
01513 
01514 /*--------------------------------------------------.
01515 | yyerrlab1 -- error raised explicitly by an action |
01516 `--------------------------------------------------*/
01517 yyerrlab1:
01518   if (yyerrstatus == 3)
01519     {
01520       /* If just tried and failed to reuse lookahead token after an
01521          error, discard it.  */
01522 
01523       /* return failure if at end of input */
01524       if (yychar == YYEOF)
01525         YYABORT;
01526       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
01527                   yychar, yytname[yychar1]));
01528       yychar = YYEMPTY;
01529     }
01530 
01531   /* Else will try to reuse lookahead token after shifting the error
01532      token.  */
01533 
01534   yyerrstatus = 3;              /* Each real token shifted decrements this */
01535 
01536   goto yyerrhandle;
01537 
01538 
01539 /*-------------------------------------------------------------------.
01540 | yyerrdefault -- current state does not do anything special for the |
01541 | error token.                                                       |
01542 `-------------------------------------------------------------------*/
01543 yyerrdefault:
01544 #if 0
01545   /* This is wrong; only states that explicitly want error tokens
01546      should shift them.  */
01547 
01548   /* If its default is to accept any token, ok.  Otherwise pop it.  */
01549   yyn = yydefact[yystate];
01550   if (yyn)
01551     goto yydefault;
01552 #endif
01553 
01554 
01555 /*---------------------------------------------------------------.
01556 | yyerrpop -- pop the current state because it cannot handle the |
01557 | error token                                                    |
01558 `---------------------------------------------------------------*/
01559 yyerrpop:
01560   if (yyssp == yyss)
01561     YYABORT;
01562   yyvsp--;
01563   yystate = *--yyssp;
01564 #if YYLSP_NEEDED
01565   yylsp--;
01566 #endif
01567 
01568 #if YYDEBUG
01569   if (yydebug)
01570     {
01571       short *yyssp1 = yyss - 1;
01572       YYFPRINTF (stderr, "Error: state stack now");
01573       while (yyssp1 != yyssp)
01574         YYFPRINTF (stderr, " %d", *++yyssp1);
01575       YYFPRINTF (stderr, "\n");
01576     }
01577 #endif
01578 
01579 /*--------------.
01580 | yyerrhandle.  |
01581 `--------------*/
01582 yyerrhandle:
01583   yyn = yypact[yystate];
01584   if (yyn == YYFLAG)
01585     goto yyerrdefault;
01586 
01587   yyn += YYTERROR;
01588   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
01589     goto yyerrdefault;
01590 
01591   yyn = yytable[yyn];
01592   if (yyn < 0)
01593     {
01594       if (yyn == YYFLAG)
01595         goto yyerrpop;
01596       yyn = -yyn;
01597       goto yyreduce;
01598     }
01599   else if (yyn == 0)
01600     goto yyerrpop;
01601 
01602   if (yyn == YYFINAL)
01603     YYACCEPT;
01604 
01605   YYDPRINTF ((stderr, "Shifting error token, "));
01606 
01607   *++yyvsp = yylval;
01608 #if YYLSP_NEEDED
01609   *++yylsp = yylloc;
01610 #endif
01611 
01612   yystate = yyn;
01613   goto yynewstate;
01614 
01615 
01616 /*-------------------------------------.
01617 | yyacceptlab -- YYACCEPT comes here.  |
01618 `-------------------------------------*/
01619 yyacceptlab:
01620   yyresult = 0;
01621   goto yyreturn;
01622 
01623 /*-----------------------------------.
01624 | yyabortlab -- YYABORT comes here.  |
01625 `-----------------------------------*/
01626 yyabortlab:
01627   yyresult = 1;
01628   goto yyreturn;
01629 
01630 /*---------------------------------------------.
01631 | yyoverflowab -- parser overflow comes here.  |
01632 `---------------------------------------------*/
01633 yyoverflowlab:
01634   yyerror ("parser stack overflow");
01635   yyresult = 2;
01636   /* Fall through.  */
01637 
01638 yyreturn:
01639 #ifndef yyoverflow
01640   if (yyss != yyssa)
01641     YYSTACK_FREE (yyss);
01642 #endif
01643   return yyresult;
01644 }
01645 #line 607 "oep.yy"
01646 
01647 /* programs */
01648 
01649 /*
01650  * ???
01651  */
01652 int
01653 yywrap()
01654 {
01655   return 1;
01656 }
01657 
01658 /*
01659  * Report an error situation discovered in a production
01660  */
01661 void
01662 yyerror(const char * text)
01663 {
01664    cerr << text << " at line "
01665         << ((OEP_GlobalData *) oep_global)->getLineNo() + 1
01666         << endl;
01667 }

Generated on Fri Dec 12 10:53:03 2003 for OmniEvents by doxygen1.2.15