- Main Page
- Namespaces
- Classes
- Files
- Related Pages

- File List
- File Members

# /home/coin/SVN-release/OS-2.3.5/OS/v2.0/OSParseosrl.tab.cpp

Go to the documentation of this file.

    00001 /* A Bison parser, made by GNU Bison 2.3.  */
    00002
    00003 /* Skeleton implementation for Bison's Yacc-like parsers in C
    00004
    00005    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
    00006    Free Software Foundation, Inc.
    00007
    00008    This program is free software; you can redistribute it and/or modify
    00009    it under the terms of the GNU General Public License as published by
    00010    the Free Software Foundation; either version 2, or (at your option)
    00011    any later version.
    00012
    00013    This program is distributed in the hope that it will be useful,
    00014    but WITHOUT ANY WARRANTY; without even the implied warranty of
    00015    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00016    GNU General Public License for more details.
    00017
    00018    You should have received a copy of the GNU General Public License
    00019    along with this program; if not, write to the Free Software
    00020    Foundation, Inc., 51 Franklin Street, Fifth Floor,
    00021    Boston, MA 02110-1301, USA.  */
    00022
    00023 /* As a special exception, you may create a larger work that contains
    00024    part or all of the Bison parser skeleton and distribute that work
    00025    under terms of your choice, so long as that work isn't itself a
    00026    parser generator using the skeleton or a modified version thereof
    00027    as a parser skeleton.  Alternatively, if you modify or redistribute
    00028    the parser skeleton itself, you may (at your option) remove this
    00029    special exception, which will cause the skeleton and the resulting
    00030    Bison output files to be licensed under the GNU General Public
    00031    License without this special exception.
    00032
    00033    This special exception was added by the Free Software Foundation in
    00034    version 2.2 of Bison.  */
    00035
    00036 /* C LALR(1) parser skeleton written by Richard Stallman, by
    00037    simplifying the original so-called "semantic" parser.  */
    00038
    00039 /* All symbols defined below should begin with yy or YY, to avoid
    00040    infringing on user name space.  This should be done even for local
    00041    variables, as they might otherwise be expanded by user macros.
    00042    There are some unavoidable exceptions within include files to
    00043    define necessary library symbols; they are noted "INFRINGES ON
    00044    USER NAME SPACE" below.  */
    00045
    00046 /* Identify Bison output.  */
    00047 #define YYBISON 1
    00048
    00049 /* Bison version.  */
    00050 #define YYBISON_VERSION "2.3"
    00051
    00052 /* Skeleton name.  */
    00053 #define YYSKELETON_NAME "yacc.c"
    00054
    00055 /* Pure parsers.  */
    00056 #define YYPURE 1
    00057
    00058 /* Using locations.  */
    00059 #define YYLSP_NEEDED 1
    00060
    00061 /* Substitute the variable and function names.  */
    00062 #define yyparse osrlparse
    00063 #define yylex   osrllex
    00064 #define yyerror osrlerror
    00065 #define yylval  osrllval
    00066 #define yychar  osrlchar
    00067 #define yydebug osrldebug
    00068 #define yynerrs osrlnerrs
    00069 #define yylloc osrllloc
    00070
    00071 /* Tokens.  */
    00072 #ifndef YYTOKENTYPE
    00073 # define YYTOKENTYPE
    00074    /* Put the tokens into the symbol table, so that GDB and other debuggers
    00075       know about them.  */
    00076    enum yytokentype {
    00077      ATTRIBUTETEXT = 258,
    00078      ELEMENTTEXT = 259,
    00079      INTEGER = 260,
    00080      DOUBLE = 261,
    00081      QUOTE = 262,
    00082      TWOQUOTES = 263,
    00083      GREATERTHAN = 264,
    00084      ENDOFELEMENT = 265,
    00085      OSRLSTART = 266,
    00086      OSRLSTARTEMPTY = 267,
    00087      OSRLATTRIBUTETEXT = 268,
    00088      OSRLEND = 269,
    00089      GENERALSTART = 270,
    00090      GENERALEND = 271,
    00091      SYSTEMSTART = 272,
    00092      SYSTEMEND = 273,
    00093      SERVICESTART = 274,
    00094      SERVICEEND = 275,
    00095      JOBSTART = 276,
    00096      JOBEND = 277,
    00097      SERVICEURISTARTANDEND = 278,
    00098      SERVICEURISTART = 279,
    00099      SERVICEURIEND = 280,
    00100      SERVICENAMESTARTANDEND = 281,
    00101      SERVICENAMESTART = 282,
    00102      SERVICENAMEEND = 283,
    00103      INSTANCENAMESTARTANDEND = 284,
    00104      INSTANCENAMESTART = 285,
    00105      INSTANCENAMEEND = 286,
    00106      JOBIDSTARTANDEND = 287,
    00107      JOBIDSTART = 288,
    00108      JOBIDEND = 289,
    00109      TIMINGINFORMATIONSTART = 290,
    00110      TIMINGINFORMATIONEND = 291,
    00111      TIMESTARTANDEND = 292,
    00112      TIMESTART = 293,
    00113      TIMEEND = 294,
    00114      OPTIMIZATIONSTART = 295,
    00115      OPTIMIZATIONEND = 296,
    00116      SOLUTIONSTART = 297,
    00117      SOLUTIONEND = 298,
    00118      VALUESSTART = 299,
    00119      VALUESEND = 300,
    00120      DUALVALUESSTART = 301,
    00121      DUALVALUESEND = 302,
    00122      VARIABLESSTART = 303,
    00123      VARIABLESEND = 304,
    00124      VARSTART = 305,
    00125      VAREND = 306,
    00126      OBJECTIVESSTART = 307,
    00127      OBJECTIVESEND = 308,
    00128      OBJSTART = 309,
    00129      OBJEND = 310,
    00130      CONSTRAINTSSTART = 311,
    00131      CONSTRAINTSEND = 312,
    00132      CONSTART = 313,
    00133      CONEND = 314,
    00134      STATUSSTART = 315,
    00135      STATUSEND = 316,
    00136      GENERALSTATUSSTART = 317,
    00137      GENERALSTATUSEND = 318,
    00138      MESSAGESTART = 319,
    00139      MESSAGEEND = 320,
    00140      MESSAGESTARTANDEND = 321,
    00141      OTHERSTART = 322,
    00142      OTHEREND = 323,
    00143      NUMBEROFTIMESATT = 324,
    00144      NUMBEROFSOLUTIONSATT = 325,
    00145      NUMBEROFVARIABLESATT = 326,
    00146      NUMBEROFCONSTRAINTSATT = 327,
    00147      NUMBEROFOBJECTIVESATT = 328,
    00148      NUMBEROFOTHERVARIABLERESULTSATT = 329,
    00149      NUMBEROFOTHEROBJECTIVERESULTSATT = 330,
    00150      NUMBEROFOTHERCONSTRAINTRESULTSATT = 331,
    00151      NUMBEROFVARATT = 332,
    00152      NUMBEROFOBJATT = 333,
    00153      NUMBEROFCONATT = 334,
    00154      TARGETOBJECTIVEIDXATT = 335,
    00155      IDXATT = 336,
    00156      TYPEATT = 337,
    00157      EMPTYTYPEATT = 338,
    00158      DESCRIPTIONATT = 339,
    00159      EMPTYDESCRIPTIONATT = 340,
    00160      NAMEATT = 341,
    00161      EMPTYNAMEATT = 342,
    00162      CATEGORYATT = 343,
    00163      EMPTYCATEGORYATT = 344,
    00164      UNITATT = 345,
    00165      EMPTYUNITATT = 346,
    00166      VALUEATT = 347,
    00167      EMPTYVALUEATT = 348,
    00168      DUMMY = 349
    00169    };
    00170 #endif
    00171 /* Tokens.  */
    00172 #define ATTRIBUTETEXT 258
    00173 #define ELEMENTTEXT 259
    00174 #define INTEGER 260
    00175 #define DOUBLE 261
    00176 #define QUOTE 262
    00177 #define TWOQUOTES 263
    00178 #define GREATERTHAN 264
    00179 #define ENDOFELEMENT 265
    00180 #define OSRLSTART 266
    00181 #define OSRLSTARTEMPTY 267
    00182 #define OSRLATTRIBUTETEXT 268
    00183 #define OSRLEND 269
    00184 #define GENERALSTART 270
    00185 #define GENERALEND 271
    00186 #define SYSTEMSTART 272
    00187 #define SYSTEMEND 273
    00188 #define SERVICESTART 274
    00189 #define SERVICEEND 275
    00190 #define JOBSTART 276
    00191 #define JOBEND 277
    00192 #define SERVICEURISTARTANDEND 278
    00193 #define SERVICEURISTART 279
    00194 #define SERVICEURIEND 280
    00195 #define SERVICENAMESTARTANDEND 281
    00196 #define SERVICENAMESTART 282
    00197 #define SERVICENAMEEND 283
    00198 #define INSTANCENAMESTARTANDEND 284
    00199 #define INSTANCENAMESTART 285
    00200 #define INSTANCENAMEEND 286
    00201 #define JOBIDSTARTANDEND 287
    00202 #define JOBIDSTART 288
    00203 #define JOBIDEND 289
    00204 #define TIMINGINFORMATIONSTART 290
    00205 #define TIMINGINFORMATIONEND 291
    00206 #define TIMESTARTANDEND 292
    00207 #define TIMESTART 293
    00208 #define TIMEEND 294
    00209 #define OPTIMIZATIONSTART 295
    00210 #define OPTIMIZATIONEND 296
    00211 #define SOLUTIONSTART 297
    00212 #define SOLUTIONEND 298
    00213 #define VALUESSTART 299
    00214 #define VALUESEND 300
    00215 #define DUALVALUESSTART 301
    00216 #define DUALVALUESEND 302
    00217 #define VARIABLESSTART 303
    00218 #define VARIABLESEND 304
    00219 #define VARSTART 305
    00220 #define VAREND 306
    00221 #define OBJECTIVESSTART 307
    00222 #define OBJECTIVESEND 308
    00223 #define OBJSTART 309
    00224 #define OBJEND 310
    00225 #define CONSTRAINTSSTART 311
    00226 #define CONSTRAINTSEND 312
    00227 #define CONSTART 313
    00228 #define CONEND 314
    00229 #define STATUSSTART 315
    00230 #define STATUSEND 316
    00231 #define GENERALSTATUSSTART 317
    00232 #define GENERALSTATUSEND 318
    00233 #define MESSAGESTART 319
    00234 #define MESSAGEEND 320
    00235 #define MESSAGESTARTANDEND 321
    00236 #define OTHERSTART 322
    00237 #define OTHEREND 323
    00238 #define NUMBEROFTIMESATT 324
    00239 #define NUMBEROFSOLUTIONSATT 325
    00240 #define NUMBEROFVARIABLESATT 326
    00241 #define NUMBEROFCONSTRAINTSATT 327
    00242 #define NUMBEROFOBJECTIVESATT 328
    00243 #define NUMBEROFOTHERVARIABLERESULTSATT 329
    00244 #define NUMBEROFOTHEROBJECTIVERESULTSATT 330
    00245 #define NUMBEROFOTHERCONSTRAINTRESULTSATT 331
    00246 #define NUMBEROFVARATT 332
    00247 #define NUMBEROFOBJATT 333
    00248 #define NUMBEROFCONATT 334
    00249 #define TARGETOBJECTIVEIDXATT 335
    00250 #define IDXATT 336
    00251 #define TYPEATT 337
    00252 #define EMPTYTYPEATT 338
    00253 #define DESCRIPTIONATT 339
    00254 #define EMPTYDESCRIPTIONATT 340
    00255 #define NAMEATT 341
    00256 #define EMPTYNAMEATT 342
    00257 #define CATEGORYATT 343
    00258 #define EMPTYCATEGORYATT 344
    00259 #define UNITATT 345
    00260 #define EMPTYUNITATT 346
    00261 #define VALUEATT 347
    00262 #define EMPTYVALUEATT 348
    00263 #define DUMMY 349
    00264
    00265
    00266
    00267
    00268 /* Copy the first part of user declarations.  */
    00269
    00270
    00271
    00272
    00273 #include "OSDataStructures.h"
    00274 #include "OSMathUtil.h"
    00275 #include "OSParameters.h"
    00276 #include "OSConfig.h"
    00277 #include "OSErrorClass.h"
    00278 #include "OSResult.h"
    00279 #include "OSrLParserData.h"
    00280 #include <iostream>
    00281 #include <sstream>
    00282 #include <stdio.h>
    00283
    00284
    00285 typedef struct yy_buffer_state *YY_BUFFER_STATE;
    00286 YY_BUFFER_STATE osrl_scan_string (const char *yy_str , void* yyscanner  );
    00287 int osrllex_init(void** ptr_yy_globals);
    00288 int osrllex_destroy (void* yyscanner );
    00289 int osrlget_lineno( void* yyscanner);
    00290 char *osrlget_text (void* yyscanner );
    00291 void osrlset_lineno (int line_number , void* yyscanner );
    00292 void osrlset_extra (OSrLParserData* parserData , void* yyscanner );
    00293 void  yygetOSResult(const char *ch, OSResult* m_osresult, OSrLParserData *m_parserData ) throw(ErrorClass);
    00294
    00295
    00296
    00297
    00298 /* Enabling traces.  */
    00299 #ifndef YYDEBUG
    00300 # define YYDEBUG 0
    00301 #endif
    00302
    00303 /* Enabling verbose error messages.  */
    00304 #ifdef YYERROR_VERBOSE
    00305 # undef YYERROR_VERBOSE
    00306 # define YYERROR_VERBOSE 1
    00307 #else
    00308 # define YYERROR_VERBOSE 0
    00309 #endif
    00310
    00311 /* Enabling the token table.  */
    00312 #ifndef YYTOKEN_TABLE
    00313 # define YYTOKEN_TABLE 0
    00314 #endif
    00315
    00316 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
    00317 typedef union YYSTYPE
    00318
    00319 {
    00320         double dval;
    00321         int ival;
    00322         char* sval;
    00323 }
    00324 /* Line 187 of yacc.c.  */
    00325
    00326         YYSTYPE;
    00327 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
    00328 # define YYSTYPE_IS_DECLARED 1
    00329 # define YYSTYPE_IS_TRIVIAL 1
    00330 #endif
    00331
    00332 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
    00333 typedef struct YYLTYPE
    00334 {
    00335   int first_line;
    00336   int first_column;
    00337   int last_line;
    00338   int last_column;
    00339 } YYLTYPE;
    00340 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
    00341 # define YYLTYPE_IS_DECLARED 1
    00342 # define YYLTYPE_IS_TRIVIAL 1
    00343 #endif
    00344
    00345
    00346 /* Copy the second part of user declarations.  */
    00347
    00348
    00349
    00350 void osrlerror(YYLTYPE* type, OSResult *osresult,  OSrLParserData *parserData ,const char* errormsg ) ;
    00351 int osrllex(YYSTYPE* lvalp,  YYLTYPE* llocp, void* scanner);
    00352
    00353 #define scanner parserData->scanner
    00354
    00355
    00356 /* Line 216 of yacc.c.  */
    00357
    00358
    00359 #ifdef short
    00360 # undef short
    00361 #endif
    00362
    00363 #ifdef YYTYPE_UINT8
    00364 typedef YYTYPE_UINT8 yytype_uint8;
    00365 #else
    00366 typedef unsigned char yytype_uint8;
    00367 #endif
    00368
    00369 #ifdef YYTYPE_INT8
    00370 typedef YYTYPE_INT8 yytype_int8;
    00371 #elif (defined __STDC__ || defined __C99__FUNC__ \
    00372      || defined __cplusplus || defined _MSC_VER)
    00373 typedef signed char yytype_int8;
    00374 #else
    00375 typedef short int yytype_int8;
    00376 #endif
    00377
    00378 #ifdef YYTYPE_UINT16
    00379 typedef YYTYPE_UINT16 yytype_uint16;
    00380 #else
    00381 typedef unsigned short int yytype_uint16;
    00382 #endif
    00383
    00384 #ifdef YYTYPE_INT16
    00385 typedef YYTYPE_INT16 yytype_int16;
    00386 #else
    00387 typedef short int yytype_int16;
    00388 #endif
    00389
    00390 #ifndef YYSIZE_T
    00391 # ifdef __SIZE_TYPE__
    00392 #  define YYSIZE_T __SIZE_TYPE__
    00393 # elif defined size_t
    00394 #  define YYSIZE_T size_t
    00395 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
    00396      || defined __cplusplus || defined _MSC_VER)
    00397 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
    00398 #  define YYSIZE_T size_t
    00399 # else
    00400 #  define YYSIZE_T unsigned int
    00401 # endif
    00402 #endif
    00403
    00404 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
    00405
    00406 #ifndef YY_
    00407 # if YYENABLE_NLS
    00408 #  if ENABLE_NLS
    00409 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
    00410 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
    00411 #  endif
    00412 # endif
    00413 # ifndef YY_
    00414 #  define YY_(msgid) msgid
    00415 # endif
    00416 #endif
    00417
    00418 /* Suppress unused-variable warnings by "using" E.  */
    00419 #if ! defined lint || defined __GNUC__
    00420 # define YYUSE(e) ((void) (e))
    00421 #else
    00422 # define YYUSE(e) /* empty */
    00423 #endif
    00424
    00425 /* Identity function, used to suppress warnings about constant conditions.  */
    00426 #ifndef lint
    00427 # define YYID(n) (n)
    00428 #else
    00429 #if (defined __STDC__ || defined __C99__FUNC__ \
    00430      || defined __cplusplus || defined _MSC_VER)
    00431 static int
    00432 YYID (int i)
    00433 #else
    00434 static int
    00435 YYID (i)
    00436     int i;
    00437 #endif
    00438 {
    00439   return i;
    00440 }
    00441 #endif
    00442
    00443 #if ! defined yyoverflow || YYERROR_VERBOSE
    00444
    00445 /* The parser invokes alloca or malloc; define the necessary symbols.  */
    00446
    00447 # ifdef YYSTACK_USE_ALLOCA
    00448 #  if YYSTACK_USE_ALLOCA
    00449 #   ifdef __GNUC__
    00450 #    define YYSTACK_ALLOC __builtin_alloca
    00451 #   elif defined __BUILTIN_VA_ARG_INCR
    00452 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
    00453 #   elif defined _AIX
    00454 #    define YYSTACK_ALLOC __alloca
    00455 #   elif defined _MSC_VER
    00456 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
    00457 #    define alloca _alloca
    00458 #   else
    00459 #    define YYSTACK_ALLOC alloca
    00460 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
    00461      || defined __cplusplus || defined _MSC_VER)
    00462 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
    00463 #     ifndef _STDLIB_H
    00464 #      define _STDLIB_H 1
    00465 #     endif
    00466 #    endif
    00467 #   endif
    00468 #  endif
    00469 # endif
    00470
    00471 # ifdef YYSTACK_ALLOC
    00472    /* Pacify GCC's `empty if-body' warning.  */
    00473 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
    00474 #  ifndef YYSTACK_ALLOC_MAXIMUM
    00475     /* The OS might guarantee only one guard page at the bottom of the stack,
    00476        and a page size can be as small as 4096 bytes.  So we cannot safely
    00477        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
    00478        to allow for a few compiler-allocated temporary stack slots.  */
    00479 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
    00480 #  endif
    00481 # else
    00482 #  define YYSTACK_ALLOC YYMALLOC
    00483 #  define YYSTACK_FREE YYFREE
    00484 #  ifndef YYSTACK_ALLOC_MAXIMUM
    00485 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
    00486 #  endif
    00487 #  if (defined __cplusplus && ! defined _STDLIB_H \
    00488        && ! ((defined YYMALLOC || defined malloc) \
    00489              && (defined YYFREE || defined free)))
    00490 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
    00491 #   ifndef _STDLIB_H
    00492 #    define _STDLIB_H 1
    00493 #   endif
    00494 #  endif
    00495 #  ifndef YYMALLOC
    00496 #   define YYMALLOC malloc
    00497 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
    00498      || defined __cplusplus || defined _MSC_VER)
    00499 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
    00500 #   endif
    00501 #  endif
    00502 #  ifndef YYFREE
    00503 #   define YYFREE free
    00504 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
    00505      || defined __cplusplus || defined _MSC_VER)
    00506 void free (void *); /* INFRINGES ON USER NAME SPACE */
    00507 #   endif
    00508 #  endif
    00509 # endif
    00510 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
    00511
    00512
    00513 #if (! defined yyoverflow \
    00514      && (! defined __cplusplus \
    00515          || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
    00516              && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
    00517
    00518 /* A type that is properly aligned for any stack member.  */
    00519 union yyalloc
    00520 {
    00521   yytype_int16 yyss;
    00522   YYSTYPE yyvs;
    00523     YYLTYPE yyls;
    00524 };
    00525
    00526 /* The size of the maximum gap between one aligned stack and the next.  */
    00527 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
    00528
    00529 /* The size of an array large to enough to hold all stacks, each with
    00530    N elements.  */
    00531 # define YYSTACK_BYTES(N) \
    00532      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
    00533       + 2 * YYSTACK_GAP_MAXIMUM)
    00534
    00535 /* Copy COUNT objects from FROM to TO.  The source and destination do
    00536    not overlap.  */
    00537 # ifndef YYCOPY
    00538 #  if defined __GNUC__ && 1 < __GNUC__
    00539 #   define YYCOPY(To, From, Count) \
    00540       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
    00541 #  else
    00542 #   define YYCOPY(To, From, Count)              \
    00543       do                                        \
    00544         {                                       \
    00545           YYSIZE_T yyi;                         \
    00546           for (yyi = 0; yyi < (Count); yyi++)   \
    00547             (To)[yyi] = (From)[yyi];            \
    00548         }                                       \
    00549       while (YYID (0))
    00550 #  endif
    00551 # endif
    00552
    00553 /* Relocate STACK from its old location to the new one.  The
    00554    local variables YYSIZE and YYSTACKSIZE give the old and new number of
    00555    elements in the stack, and YYPTR gives the new location of the
    00556    stack.  Advance YYPTR to a properly aligned location for the next
    00557    stack.  */
    00558 # define YYSTACK_RELOCATE(Stack)                                        \
    00559     do                                                                  \
    00560       {                                                                 \
    00561         YYSIZE_T yynewbytes;                                            \
    00562         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
    00563         Stack = &yyptr->Stack;                                          \
    00564         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
    00565         yyptr += yynewbytes / sizeof (*yyptr);                          \
    00566       }                                                                 \
    00567     while (YYID (0))
    00568
    00569 #endif
    00570
    00571 /* YYFINAL -- State number of the termination state.  */
    00572 #define YYFINAL  6
    00573 /* YYLAST -- Last index in YYTABLE.  */
    00574 #define YYLAST   252
    00575
    00576 /* YYNTOKENS -- Number of terminals.  */
    00577 #define YYNTOKENS  99
    00578 /* YYNNTS -- Number of nonterminals.  */
    00579 #define YYNNTS  80
    00580 /* YYNRULES -- Number of rules.  */
    00581 #define YYNRULES  160
    00582 /* YYNRULES -- Number of states.  */
    00583 #define YYNSTATES  299
    00584
    00585 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
    00586 #define YYUNDEFTOK  2
    00587 #define YYMAXUTOK   349
    00588
    00589 #define YYTRANSLATE(YYX)                                                \
    00590   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
    00591
    00592 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
    00593 static const yytype_uint8 yytranslate[] =
    00594 {
    00595        0,     2,     2,     2,     2,     2,     2,     2,     2,    96,
    00596       98,     2,     2,    97,     2,     2,     2,     2,     2,     2,
    00597        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00598        2,     2,    95,     2,     2,     2,     2,     2,     2,     2,
    00599        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00600        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00601        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00602        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00603        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00604        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00605        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00606        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00607        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00608        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00609        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00610        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00611        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00612        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00613        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00614        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00615        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00616        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00617        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00618        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00619        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
    00620        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
    00621        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
    00622       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
    00623       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
    00624       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
    00625       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
    00626       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
    00627       65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
    00628       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
    00629       85,    86,    87,    88,    89,    90,    91,    92,    93,    94
    00630 };
    00631
    00632 #if YYDEBUG
    00633 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
    00634    YYRHS.  */
    00635 static const yytype_uint16 yyprhs[] =
    00636 {
    00637        0,     0,     3,    11,    14,    18,    19,    28,    33,    37,
    00638       39,    42,    46,    48,    52,    54,    55,    57,    61,    64,
    00639       65,    67,    71,    74,    75,    77,    81,    84,    85,    87,
    00640       91,    94,    95,    97,   101,   104,   105,   108,   109,   112,
    00641      113,   117,   118,   122,   127,   129,   133,   134,   137,   139,
    00642      145,   146,   149,   151,   153,   155,   157,   161,   163,   167,
    00643      169,   173,   175,   179,   181,   183,   185,   186,   187,   192,
    00644      193,   197,   199,   202,   203,   206,   209,   212,   215,   218,
    00645      222,   226,   230,   234,   235,   238,   248,   249,   254,   259,
    00646      263,   265,   268,   272,   274,   278,   280,   281,   285,   288,
    00647      289,   300,   301,   306,   311,   313,   316,   322,   324,   326,
    00648      327,   330,   336,   338,   339,   342,   344,   346,   348,   350,
    00649      355,   357,   361,   363,   367,   371,   372,   375,   381,   383,
    00650      385,   387,   389,   390,   400,   405,   406,   409,   415,   421,
    00651      422,   423,   434,   439,   441,   444,   450,   456,   460,   461,
    00652      463,   464,   466,   468,   471,   474,   476,   478,   480,   482,
    00653      483
    00654 };
    00655
    00656 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
    00657 static const yytype_int16 yyrhs[] =
    00658 {
    00659      100,     0,    -1,   101,   102,   111,   112,   113,   126,    14,
    00660       -1,    11,     9,    -1,    11,    13,     9,    -1,    -1,    15,
    00661      103,   106,   107,   108,   109,   110,    16,    -1,    62,   104,
    00662        9,    63,    -1,    62,   104,    10,    -1,   105,    -1,   104,
    00663      105,    -1,    82,     3,   176,    -1,    83,    -1,    84,     3,
    00664      176,    -1,    85,    -1,    -1,    23,    -1,    24,     4,    25,
    00665       -1,    24,    25,    -1,    -1,    26,    -1,    27,     4,    28,
    00666       -1,    27,    28,    -1,    -1,    29,    -1,    30,     4,    31,
    00667       -1,    30,    31,    -1,    -1,    32,    -1,    33,     4,    34,
    00668       -1,    33,    34,    -1,    -1,    66,    -1,    64,     4,    65,
    00669       -1,    64,    65,    -1,    -1,    17,    18,    -1,    -1,    19,
    00670       20,    -1,    -1,    21,   114,    22,    -1,    -1,    35,   115,
    00671      116,    -1,    69,     7,     5,     7,    -1,    10,    -1,     9,
    00672      117,    36,    -1,    -1,   117,   118,    -1,    37,    -1,    38,
    00673      119,     9,   125,    39,    -1,    -1,   119,   120,    -1,   121,
    00674       -1,   122,    -1,   123,    -1,   124,    -1,    82,     3,     7,
    00675       -1,    83,    -1,    88,     3,     7,    -1,    89,    -1,    90,
    00676        3,     7,    -1,    91,    -1,    84,     3,     7,    -1,    85,
    00677       -1,     6,    -1,     5,    -1,    -1,    -1,    40,   128,   127,
    00678       41,    -1,    -1,   131,   129,   130,    -1,    10,    -1,     9,
    00679      137,    -1,    -1,   131,   132,    -1,   133,   176,    -1,   134,
    00680      176,    -1,   135,   176,    -1,   136,   176,    -1,    70,   176,
    00681        5,    -1,    71,   176,     5,    -1,    72,   176,     5,    -1,
    00682       73,   176,     5,    -1,    -1,   137,   138,    -1,    42,   139,
    00683        9,   140,   143,   144,   163,   167,   175,    -1,    -1,    80,
    00684      176,     5,   176,    -1,    60,   141,     9,    61,    -1,    60,
    00685      141,    10,    -1,   142,    -1,   141,   142,    -1,    82,     3,
    00686      176,    -1,    83,    -1,    84,     3,   176,    -1,    85,    -1,
    00687       -1,    64,     4,    65,    -1,    64,    65,    -1,    -1,    48,
    00688      145,     9,    44,   146,     9,   147,    45,   150,    49,    -1,
    00689       -1,    74,   176,     5,   176,    -1,    77,   176,     5,   176,
    00690       -1,   148,    -1,   147,   148,    -1,    50,   172,     9,   149,
    00691       51,    -1,     5,    -1,     6,    -1,    -1,   150,   151,    -1,
    00692      152,   153,     9,   159,    68,    -1,    67,    -1,    -1,   154,
    00693      153,    -1,   155,    -1,   156,    -1,   157,    -1,   158,    -1,
    00694       77,   176,     5,   176,    -1,    93,    -1,    92,     3,   176,
    00695       -1,    87,    -1,    86,     3,   176,    -1,    84,     3,   176,
    00696       -1,    -1,   160,   159,    -1,   162,   172,     9,   161,    51,
    00697       -1,     4,    -1,     5,    -1,     6,    -1,    50,    -1,    -1,
    00698       52,     9,    44,   164,     9,   165,    45,   173,    53,    -1,
    00699       78,   176,     5,   176,    -1,    -1,   165,   166,    -1,    54,
    00700      172,     9,     6,    55,    -1,    54,   172,     9,     5,    55,
    00701       -1,    -1,    -1,    56,     9,    46,   169,   168,     9,   170,
    00702       47,   174,    57,    -1,    79,   176,     5,   176,    -1,   171,
    00703       -1,   170,   171,    -1,    58,   172,     9,     6,    59,    -1,
    00704       58,   172,     9,     5,    59,    -1,    81,     5,   176,    -1,
    00705       -1,    94,    -1,    -1,    94,    -1,    43,    -1,    94,    43,
    00706       -1,   178,     7,    -1,    95,    -1,    96,    -1,    97,    -1,
    00707       98,    -1,    -1,   178,   177,    -1
    00708 };
    00709
    00710 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
    00711 static const yytype_uint16 yyrline[] =
    00712 {
    00713        0,   116,   116,   119,   120,   124,   124,   126,   127,   129,
    00714      130,   132,   133,   134,   135,   138,   139,   140,   141,   144,
    00715      145,   146,   147,   149,   150,   151,   152,   154,   155,   156,
    00716      157,   159,   160,   161,   162,   164,   164,   166,   166,   168,
    00717      168,   170,   171,   173,   179,   179,   181,   181,   183,   184,
    00718      196,   196,   198,   198,   198,   198,   200,   201,   203,   204,
    00719      206,   207,   209,   210,   213,   214,   218,   218,   218,   221,
    00720      220,   248,   249,   251,   252,   254,   255,   256,   257,   261,
    00721      263,   265,   267,   271,   272,   275,   282,   283,   286,   287,
    00722      290,   291,   293,   294,   295,   296,   298,   299,   301,   305,
    00723      306,   309,   310,   321,   327,   328,   330,   349,   350,   353,
    00724      354,   356,   401,   410,   413,   415,   415,   415,   415,   417,
    00725      423,   424,   428,   432,   437,   445,   446,   448,   469,   470,
    00726      471,   473,   478,   479,   481,   483,   484,   486,   488,   491,
    00727      493,   492,   504,   506,   507,   509,   512,   519,   525,   526,
    00728      528,   529,   531,   532,   538,   540,   541,   542,   543,   545,
    00729      546
    00730 };
    00731 #endif
    00732
    00733 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
    00734 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
    00735    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
    00736 static const char *const yytname[] =
    00737 {
    00738   "$end", "error", "$undefined", "ATTRIBUTETEXT", "ELEMENTTEXT",
    00739   "INTEGER", "DOUBLE", "QUOTE", "TWOQUOTES", "GREATERTHAN", "ENDOFELEMENT",
    00740   "OSRLSTART", "OSRLSTARTEMPTY", "OSRLATTRIBUTETEXT", "OSRLEND",
    00741   "GENERALSTART", "GENERALEND", "SYSTEMSTART", "SYSTEMEND", "SERVICESTART",
    00742   "SERVICEEND", "JOBSTART", "JOBEND", "SERVICEURISTARTANDEND",
    00743   "SERVICEURISTART", "SERVICEURIEND", "SERVICENAMESTARTANDEND",
    00744   "SERVICENAMESTART", "SERVICENAMEEND", "INSTANCENAMESTARTANDEND",
    00745   "INSTANCENAMESTART", "INSTANCENAMEEND", "JOBIDSTARTANDEND", "JOBIDSTART",
    00746   "JOBIDEND", "TIMINGINFORMATIONSTART", "TIMINGINFORMATIONEND",
    00747   "TIMESTARTANDEND", "TIMESTART", "TIMEEND", "OPTIMIZATIONSTART",
    00748   "OPTIMIZATIONEND", "SOLUTIONSTART", "SOLUTIONEND", "VALUESSTART",
    00749   "VALUESEND", "DUALVALUESSTART", "DUALVALUESEND", "VARIABLESSTART",
    00750   "VARIABLESEND", "VARSTART", "VAREND", "OBJECTIVESSTART", "OBJECTIVESEND",
    00751   "OBJSTART", "OBJEND", "CONSTRAINTSSTART", "CONSTRAINTSEND", "CONSTART",
    00752   "CONEND", "STATUSSTART", "STATUSEND", "GENERALSTATUSSTART",
    00753   "GENERALSTATUSEND", "MESSAGESTART", "MESSAGEEND", "MESSAGESTARTANDEND",
    00754   "OTHERSTART", "OTHEREND", "NUMBEROFTIMESATT", "NUMBEROFSOLUTIONSATT",
    00755   "NUMBEROFVARIABLESATT", "NUMBEROFCONSTRAINTSATT",
    00756   "NUMBEROFOBJECTIVESATT", "NUMBEROFOTHERVARIABLERESULTSATT",
    00757   "NUMBEROFOTHEROBJECTIVERESULTSATT", "NUMBEROFOTHERCONSTRAINTRESULTSATT",
    00758   "NUMBEROFVARATT", "NUMBEROFOBJATT", "NUMBEROFCONATT",
    00759   "TARGETOBJECTIVEIDXATT", "IDXATT", "TYPEATT", "EMPTYTYPEATT",
    00760   "DESCRIPTIONATT", "EMPTYDESCRIPTIONATT", "NAMEATT", "EMPTYNAMEATT",
    00761   "CATEGORYATT", "EMPTYCATEGORYATT", "UNITATT", "EMPTYUNITATT", "VALUEATT",
    00762   "EMPTYVALUEATT", "DUMMY", "' '", "'\\t'", "'\\r'", "'\\n'", "$accept",
    00763   "osrldoc", "osrlstart", "generalElement", "generalStatus",
    00764   "anotherGeneralStatusATT", "generalstatusatt", "serviceURI",
    00765   "serviceName", "instanceName", "jobID", "headerMessage", "systemElement",
    00766   "serviceElement", "jobElement", "timingInformation", "numberoftimes",
    00767   "timingContent", "listOfTimes", "time", "timeAttList", "timeAtt",
    00768   "timeType", "timeCategory", "timeUnit", "timeDescription", "timeValue",
    00769   "optimizationElement", "@1", "optimizationContent", "@2", "optend",
    00770   "anotherOptATT", "optatt", "optnumsolatt", "optnumvaratt",
    00771   "optnumconatt", "optnumobjatt", "solution", "anothersolution",
    00772   "targetObjectiveIDXATT", "status", "anotherStatusATT", "statusatt",
    00773   "message", "variables", "numberOfOtherVariableResults", "numberOfVarATT",
    00774   "var", "anothervar", "DoubleOrInt", "otherVariables",
    00775   "otherVariableResult", "otherVariableStart", "otherVariableATTlist",
    00776   "othervariableATT", "numberOfOtherVarATT", "otherVarValueATT",
    00777   "otherVarNameATT", "otherVarDescriptionATT", "othervarlist", "othervar",
    00778   "ElementValue", "othervarstart", "objectives", "numberOfObjATT", "obj",
    00779   "anotherobj", "constraints", "@3", "numberOfConATT", "con", "anothercon",
    00780   "anIDXATT", "otherObjectives", "otherConstraints", "otherSolution",
    00781   "quote", "xmlWhiteSpaceChar", "xmlWhiteSpace", 0
    00782 };
    00783 #endif
    00784
    00785 # ifdef YYPRINT
    00786 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
    00787    token YYLEX-NUM.  */
    00788 static const yytype_uint16 yytoknum[] =
    00789 {
    00790        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
    00791      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
    00792      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
    00793      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
    00794      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
    00795      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
    00796      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
    00797      325,   326,   327,   328,   329,   330,   331,   332,   333,   334,
    00798      335,   336,   337,   338,   339,   340,   341,   342,   343,   344,
    00799      345,   346,   347,   348,   349,    32,     9,    13,    10
    00800 };
    00801 # endif
    00802
    00803 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
    00804 static const yytype_uint8 yyr1[] =
    00805 {
    00806        0,    99,   100,   101,   101,   102,   102,   103,   103,   104,
    00807      104,   105,   105,   105,   105,   106,   106,   106,   106,   107,
    00808      107,   107,   107,   108,   108,   108,   108,   109,   109,   109,
    00809      109,   110,   110,   110,   110,   111,   111,   112,   112,   113,
    00810      113,   114,   114,   115,   116,   116,   117,   117,   118,   118,
    00811      119,   119,   120,   120,   120,   120,   121,   121,   122,   122,
    00812      123,   123,   124,   124,   125,   125,   126,   127,   126,   129,
    00813      128,   130,   130,   131,   131,   132,   132,   132,   132,   133,
    00814      134,   135,   136,   137,   137,   138,   139,   139,   140,   140,
    00815      141,   141,   142,   142,   142,   142,   143,   143,   143,   144,
    00816      144,   145,   145,   146,   147,   147,   148,   149,   149,   150,
    00817      150,   151,   152,   153,   153,   154,   154,   154,   154,   155,
    00818      156,   156,   157,   157,   158,   159,   159,   160,   161,   161,
    00819      161,   162,   163,   163,   164,   165,   165,   166,   166,   167,
    00820      168,   167,   169,   170,   170,   171,   171,   172,   173,   173,
    00821      174,   174,   175,   175,   176,   177,   177,   177,   177,   178,
    00822      178
    00823 };
    00824
    00825 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
    00826 static const yytype_uint8 yyr2[] =
    00827 {
    00828        0,     2,     7,     2,     3,     0,     8,     4,     3,     1,
    00829        2,     3,     1,     3,     1,     0,     1,     3,     2,     0,
    00830        1,     3,     2,     0,     1,     3,     2,     0,     1,     3,
    00831        2,     0,     1,     3,     2,     0,     2,     0,     2,     0,
    00832        3,     0,     3,     4,     1,     3,     0,     2,     1,     5,
    00833        0,     2,     1,     1,     1,     1,     3,     1,     3,     1,
    00834        3,     1,     3,     1,     1,     1,     0,     0,     4,     0,
    00835        3,     1,     2,     0,     2,     2,     2,     2,     2,     3,
    00836        3,     3,     3,     0,     2,     9,     0,     4,     4,     3,
    00837        1,     2,     3,     1,     3,     1,     0,     3,     2,     0,
    00838       10,     0,     4,     4,     1,     2,     5,     1,     1,     0,
    00839        2,     5,     1,     0,     2,     1,     1,     1,     1,     4,
    00840        1,     3,     1,     3,     3,     0,     2,     5,     1,     1,
    00841        1,     1,     0,     9,     4,     0,     2,     5,     5,     0,
    00842        0,    10,     4,     1,     2,     5,     5,     3,     0,     1,
    00843        0,     1,     1,     2,     2,     1,     1,     1,     1,     0,
    00844        2
    00845 };
    00846
    00847 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
    00848    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
    00849    means the default is an error.  */
    00850 static const yytype_uint8 yydefact[] =
    00851 {
    00852        0,     0,     0,     5,     3,     0,     1,     0,    35,     4,
    00853        0,    15,     0,    37,     0,    12,     0,    14,     0,     9,
    00854       16,     0,    19,    36,     0,    39,   159,   159,     0,     8,
    00855       10,     0,    18,    20,     0,    23,    38,    41,    66,    11,
    00856        0,    13,     7,    17,     0,    22,    24,     0,    27,     0,
    00857        0,    73,     0,   154,   155,   156,   157,   158,   160,    21,
    00858        0,    26,    28,     0,    31,     0,     0,    40,    67,    69,
    00859        2,    25,     0,    30,     0,    32,     0,     0,    46,    44,
    00860       42,     0,   159,   159,   159,   159,     0,    74,   159,   159,
    00861      159,   159,    29,     0,    34,     6,     0,     0,    68,     0,
    00862        0,     0,     0,    83,    71,    70,    75,    76,    77,    78,
    00863       33,    43,    45,    48,    50,    47,    79,    80,    81,    82,
    00864       72,     0,    86,    84,     0,     0,    57,     0,    63,     0,
    00865       59,     0,    61,    51,    52,    53,    54,    55,   159,     0,
    00866       65,    64,     0,     0,     0,     0,     0,     0,     0,    49,
    00867       56,    62,    58,    60,   159,     0,    96,    87,     0,    93,
    00868        0,    95,     0,    90,     0,    99,   159,   159,     0,    89,
    00869       91,     0,    98,   101,   132,    92,    94,    88,    97,   159,
    00870        0,     0,   139,     0,     0,     0,     0,     0,   159,     0,
    00871        0,     0,   152,     0,    85,   102,   159,     0,   159,     0,
    00872        0,   153,     0,     0,     0,   135,   159,   140,   159,     0,
    00873        0,   104,   159,     0,     0,     0,   103,     0,     0,   109,
    00874      105,   134,   148,     0,   136,   159,     0,   159,     0,     0,
    00875      149,     0,     0,   142,     0,     0,   143,   147,   107,   108,
    00876        0,   100,   112,   110,   113,   133,     0,     0,   150,   144,
    00877      106,   159,     0,     0,   122,     0,   120,     0,   113,   115,
    00878      116,   117,   118,     0,     0,     0,   151,     0,     0,   159,
    00879      159,   159,   125,   114,   138,   137,     0,     0,   141,   159,
    00880      124,   123,   121,   131,     0,   125,     0,   146,   145,   119,
    00881      111,   126,     0,     0,   128,   129,   130,     0,   127
    00882 };
    00883
    00884 /* YYDEFGOTO[NTERM-NUM].  */
    00885 static const yytype_int16 yydefgoto[] =
    00886 {
    00887       -1,     2,     3,     8,    11,    18,    19,    22,    35,    48,
    00888       64,    76,    13,    25,    38,    50,    66,    80,    97,   115,
    00889      121,   133,   134,   135,   136,   137,   142,    52,    81,    68,
    00890       86,   105,    69,    87,    88,    89,    90,    91,   120,   123,
    00891      139,   156,   162,   163,   165,   174,   180,   197,   210,   211,
    00892      240,   229,   243,   244,   257,   258,   259,   260,   261,   262,
    00893      284,   285,   297,   286,   182,   199,   213,   224,   187,   215,
    00894      207,   235,   236,   218,   231,   267,   194,    39,    58,    40
    00895 };
    00896
    00897 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    00898    STATE-NUM.  */
    00899 #define YYPACT_NINF -221
    00900 static const yytype_int16 yypact[] =
    00901 {
    00902       13,    14,    29,    16,  -221,    24,  -221,   -24,    43,  -221,
    00903      -41,    56,    98,    55,   114,  -221,   115,  -221,     3,  -221,
    00904     -221,     7,    71,  -221,    99,   100,  -221,  -221,    57,  -221,
    00905     -221,    97,  -221,  -221,     6,    70,  -221,    88,    84,  -221,
    00906       -6,  -221,  -221,  -221,   101,  -221,  -221,     5,    69,    59,
    00907      103,  -221,   112,  -221,  -221,  -221,  -221,  -221,  -221,  -221,
    00908      105,  -221,  -221,     1,   -48,   123,    94,  -221,  -221,   -23,
    00909     -221,  -221,   108,  -221,     0,  -221,   116,   126,  -221,  -221,
    00910     -221,    92,  -221,  -221,  -221,  -221,    96,  -221,  -221,  -221,
    00911     -221,  -221,  -221,    72,  -221,  -221,   127,    32,  -221,   130,
    00912      133,   136,   138,  -221,  -221,  -221,  -221,  -221,  -221,  -221,
    00913     -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,
    00914      106,    -7,    64,  -221,   102,   142,  -221,   143,  -221,   144,
    00915     -221,   146,  -221,  -221,  -221,  -221,  -221,  -221,  -221,   141,
    00916     -221,  -221,   117,   147,   148,   150,   151,   154,    91,  -221,
    00917     -221,  -221,  -221,  -221,  -221,   -31,    89,  -221,   157,  -221,
    00918      159,  -221,    11,  -221,     2,   118,  -221,  -221,   111,  -221,
    00919     -221,   110,  -221,    90,   113,  -221,  -221,  -221,  -221,  -221,
    00920      158,   161,   120,   163,   119,   129,   165,   -35,  -221,   122,
    00921      124,   131,  -221,   135,  -221,  -221,  -221,   171,  -221,   173,
    00922      125,  -221,   178,   134,   181,  -221,  -221,  -221,  -221,   128,
    00923      -28,  -221,  -221,   -26,   182,   179,  -221,   184,   183,  -221,
    00924     -221,  -221,   121,   128,  -221,  -221,   132,  -221,   104,   -42,
    00925     -221,   140,   185,  -221,   128,   -32,  -221,  -221,  -221,  -221,
    00926      145,  -221,  -221,  -221,   -47,  -221,   107,   186,   137,  -221,
    00927     -221,  -221,   188,   194,  -221,   198,  -221,   196,   -47,  -221,
    00928     -221,  -221,  -221,   152,   153,   109,  -221,   149,   205,  -221,
    00929     -221,  -221,   162,  -221,  -221,  -221,   155,   160,  -221,  -221,
    00930     -221,  -221,  -221,  -221,   164,   162,   128,  -221,  -221,  -221,
    00931     -221,  -221,   202,    67,  -221,  -221,  -221,   166,  -221
    00932 };
    00933
    00934 /* YYPGOTO[NTERM-NUM].  */
    00935 static const yytype_int16 yypgoto[] =
    00936 {
    00937     -221,  -221,  -221,  -221,  -221,  -221,   195,  -221,  -221,  -221,
    00938     -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,
    00939     -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,
    00940     -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,
    00941     -221,  -221,  -221,    41,  -221,  -221,  -221,  -221,  -221,     8,
    00942     -221,  -221,  -221,  -221,   -38,  -221,  -221,  -221,  -221,  -221,
    00943      -69,  -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,  -221,
    00944     -221,  -221,   -14,  -220,  -221,  -221,  -221,   -27,  -221,  -221
    00945 };
    00946
    00947 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    00948    positive, shift that token.  If negative, reduce the rule which
    00949    number is the opposite.  If zero, do what YYDEFACT says.
    00950    If YYTABLE_NINF, syntax error.  */
    00951 #define YYTABLE_NINF -1
    00952 static const yytype_uint16 yytable[] =
    00953 {
    00954       41,    53,   124,   232,    93,    72,   171,   241,   192,    60,
    00955       44,    31,    28,    29,   247,   248,    74,   219,    75,   222,
    00956      168,   169,   209,     4,     1,   242,   234,     5,   223,     6,
    00957      251,     7,    32,     9,    45,    73,    61,   252,    10,   253,
    00958      254,    14,    15,    16,    17,   255,   256,    82,    83,    84,
    00959       85,   158,   159,   160,   161,    99,   100,   101,   102,   193,
    00960       12,   106,   107,   108,   109,    94,   292,   172,   112,   113,
    00961      114,   294,   295,   296,    24,   125,   126,   127,   128,    20,
    00962       21,   129,   130,   131,   132,    14,    15,    16,    17,    54,
    00963       55,    56,    57,   158,   159,   160,   161,    33,    34,    46,
    00964       47,    62,    63,    78,    79,   103,   104,   140,   141,   238,
    00965      239,   147,   263,   264,   276,   277,    23,    26,    27,    36,
    00966       42,    37,    43,    49,    51,    67,    70,   157,    65,    59,
    00967       77,    96,    95,    98,   111,   116,    71,   110,   117,   175,
    00968      176,   118,    92,   119,   138,   143,   144,   145,   122,   146,
    00969      148,   155,   183,   164,   150,   151,   149,   152,   153,   154,
    00970      166,   195,   167,   189,   179,   181,   173,   184,   188,   202,
    00971      185,   204,   177,   190,   191,   178,   186,   200,   201,   214,
    00972      203,   216,   205,   208,   209,   221,   212,   225,   226,   227,
    00973      234,   269,   228,   245,   246,   265,   250,   270,   233,   196,
    00974      237,   271,   198,   170,   206,   272,   278,   274,   275,   217,
    00975      279,   293,   283,    30,   287,   230,   291,   298,   220,   288,
    00976      273,   249,     0,     0,   268,     0,     0,     0,     0,     0,
    00977        0,   266,   290,     0,     0,     0,     0,     0,     0,     0,
    00978        0,     0,   280,   281,   282,     0,     0,     0,     0,     0,
    00979        0,     0,   289
    00980 };
    00981
    00982 static const yytype_int16 yycheck[] =
    00983 {
    00984       27,     7,     9,   223,     4,     4,     4,    49,    43,     4,
    00985        4,     4,     9,    10,   234,    47,    64,    45,    66,    45,
    00986        9,    10,    50,     9,    11,    67,    58,    13,    54,     0,
    00987       77,    15,    25,     9,    28,    34,    31,    84,    62,    86,
    00988       87,    82,    83,    84,    85,    92,    93,    70,    71,    72,
    00989       73,    82,    83,    84,    85,    82,    83,    84,    85,    94,
    00990       17,    88,    89,    90,    91,    65,   286,    65,    36,    37,
    00991       38,     4,     5,     6,    19,    82,    83,    84,    85,    23,
    00992       24,    88,    89,    90,    91,    82,    83,    84,    85,    95,
    00993       96,    97,    98,    82,    83,    84,    85,    26,    27,    29,
    00994       30,    32,    33,     9,    10,     9,    10,     5,     6,     5,
    00995        6,   138,     5,     6,     5,     6,    18,     3,     3,    20,
    00996       63,    21,    25,    35,    40,    22,    14,   154,    69,    28,
    00997        7,     5,    16,    41,     7,     5,    31,    65,     5,   166,
    00998      167,     5,    34,     5,    80,     3,     3,     3,    42,     3,
    00999        9,    60,   179,    64,     7,     7,    39,     7,     7,     5,
    01000        3,   188,     3,    44,    74,    52,    48,     9,     5,   196,
    01001        9,   198,    61,    44,     9,    65,    56,    46,    43,   206,
    01002        9,   208,     9,     5,    50,   212,     5,     5,     9,     5,
    01003       58,     3,     9,    53,     9,     9,    51,     3,   225,    77,
    01004      227,     3,    78,   162,    79,     9,    57,    55,    55,    81,
    01005        5,     9,    50,    18,    59,    94,   285,    51,   210,    59,
    01006      258,   235,    -1,    -1,   251,    -1,    -1,    -1,    -1,    -1,
    01007       -1,    94,    68,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
    01008       -1,    -1,   269,   270,   271,    -1,    -1,    -1,    -1,    -1,
    01009       -1,    -1,   279
    01010 };
    01011
    01012 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    01013    symbol of state STATE-NUM.  */
    01014 static const yytype_uint8 yystos[] =
    01015 {
    01016        0,    11,   100,   101,     9,    13,     0,    15,   102,     9,
    01017       62,   103,    17,   111,    82,    83,    84,    85,   104,   105,
    01018       23,    24,   106,    18,    19,   112,     3,     3,     9,    10,
    01019      105,     4,    25,    26,    27,   107,    20,    21,   113,   176,
    01020      178,   176,    63,    25,     4,    28,    29,    30,   108,    35,
    01021      114,    40,   126,     7,    95,    96,    97,    98,   177,    28,
    01022        4,    31,    32,    33,   109,    69,   115,    22,   128,   131,
    01023       14,    31,     4,    34,    64,    66,   110,     7,     9,    10,
    01024      116,   127,    70,    71,    72,    73,   129,   132,   133,   134,
    01025      135,   136,    34,     4,    65,    16,     5,   117,    41,   176,
    01026      176,   176,   176,     9,    10,   130,   176,   176,   176,   176,
    01027       65,     7,    36,    37,    38,   118,     5,     5,     5,     5,
    01028      137,   119,    42,   138,     9,    82,    83,    84,    85,    88,
    01029       89,    90,    91,   120,   121,   122,   123,   124,    80,   139,
    01030        5,     6,   125,     3,     3,     3,     3,   176,     9,    39,
    01031        7,     7,     7,     7,     5,    60,   140,   176,    82,    83,
    01032       84,    85,   141,   142,    64,   143,     3,     3,     9,    10,
    01033      142,     4,    65,    48,   144,   176,   176,    61,    65,    74,
    01034      145,    52,   163,   176,     9,     9,    56,   167,     5,    44,
    01035       44,     9,    43,    94,   175,   176,    77,   146,    78,   164,
    01036       46,    43,   176,     9,   176,     9,    79,   169,     5,    50,
    01037      147,   148,     5,   165,   176,   168,   176,    81,   172,    45,
    01038      148,   176,    45,    54,   166,     5,     9,     5,     9,   150,
    01039       94,   173,   172,   176,    58,   170,   171,   176,     5,     6,
    01040      149,    49,    67,   151,   152,    53,     9,   172,    47,   171,
    01041       51,    77,    84,    86,    87,    92,    93,   153,   154,   155,
    01042      156,   157,   158,     5,     6,     9,    94,   174,   176,     3,
    01043        3,     3,     9,   153,    55,    55,     5,     6,    57,     5,
    01044      176,   176,   176,    50,   159,   160,   162,    59,    59,   176,
    01045       68,   159,   172,     9,     4,     5,     6,   161,    51
    01046 };
    01047
    01048 #define yyerrok         (yyerrstatus = 0)
    01049 #define yyclearin       (yychar = YYEMPTY)
    01050 #define YYEMPTY         (-2)
    01051 #define YYEOF           0
    01052
    01053 #define YYACCEPT        goto yyacceptlab
    01054 #define YYABORT         goto yyabortlab
    01055 #define YYERROR         goto yyerrorlab
    01056
    01057
    01058 /* Like YYERROR except do call yyerror.  This remains here temporarily
    01059    to ease the transition to the new meaning of YYERROR, for GCC.
    01060    Once GCC version 2 has supplanted version 1, this can go.  */
    01061
    01062 #define YYFAIL          goto yyerrlab
    01063
    01064 #define YYRECOVERING()  (!!yyerrstatus)
    01065
    01066 #define YYBACKUP(Token, Value)                                  \
    01067 do                                                              \
    01068   if (yychar == YYEMPTY && yylen == 1)                          \
    01069     {                                                           \
    01070       yychar = (Token);                                         \
    01071       yylval = (Value);                                         \
    01072       yytoken = YYTRANSLATE (yychar);                           \
    01073       YYPOPSTACK (1);                                           \
    01074       goto yybackup;                                            \
    01075     }                                                           \
    01076   else                                                          \
    01077     {                                                           \
    01078       yyerror (&yylloc, osresult, parserData, YY_("syntax error: cannot back up")); \
    01079       YYERROR;                                                  \
    01080     }                                                           \
    01081 while (YYID (0))
    01082
    01083
    01084 #define YYTERROR        1
    01085 #define YYERRCODE       256
    01086
    01087
    01088 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
    01089    If N is 0, then set CURRENT to the empty location which ends
    01090    the previous symbol: RHS[0] (always defined).  */
    01091
    01092 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
    01093 #ifndef YYLLOC_DEFAULT
    01094 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
    01095     do                                                                  \
    01096       if (YYID (N))                                                    \
    01097         {                                                               \
    01098           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
    01099           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
    01100           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
    01101           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
    01102         }                                                               \
    01103       else                                                              \
    01104         {                                                               \
    01105           (Current).first_line   = (Current).last_line   =              \
    01106             YYRHSLOC (Rhs, 0).last_line;                                \
    01107           (Current).first_column = (Current).last_column =              \
    01108             YYRHSLOC (Rhs, 0).last_column;                              \
    01109         }                                                               \
    01110     while (YYID (0))
    01111 #endif
    01112
    01113
    01114 /* YY_LOCATION_PRINT -- Print the location on the stream.
    01115    This macro was not mandated originally: define only if we know
    01116    we won't break user code: when these are the locations we know.  */
    01117
    01118 #ifndef YY_LOCATION_PRINT
    01119 # if YYLTYPE_IS_TRIVIAL
    01120 #  define YY_LOCATION_PRINT(File, Loc)                  \
    01121      fprintf (File, "%d.%d-%d.%d",                      \
    01122               (Loc).first_line, (Loc).first_column,     \
    01123               (Loc).last_line,  (Loc).last_column)
    01124 # else
    01125 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
    01126 # endif
    01127 #endif
    01128
    01129
    01130 /* YYLEX -- calling `yylex' with the right arguments.  */
    01131
    01132 #ifdef YYLEX_PARAM
    01133 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
    01134 #else
    01135 # define YYLEX yylex (&yylval, &yylloc, scanner)
    01136 #endif
    01137
    01138 /* Enable debugging if requested.  */
    01139 #if YYDEBUG
    01140
    01141 # ifndef YYFPRINTF
    01142 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
    01143 #  define YYFPRINTF fprintf
    01144 # endif
    01145
    01146 # define YYDPRINTF(Args)                        \
    01147 do {                                            \
    01148   if (yydebug)                                  \
    01149     YYFPRINTF Args;                             \
    01150 } while (YYID (0))
    01151
    01152 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
    01153 do {                                                                      \
    01154   if (yydebug)                                                            \
    01155     {                                                                     \
    01156       YYFPRINTF (stderr, "%s ", Title);                                   \
    01157       yy_symbol_print (stderr,                                            \
    01158                   Type, Value, Location, osresult, parserData); \
    01159       YYFPRINTF (stderr, "\n");                                           \
    01160     }                                                                     \
    01161 } while (YYID (0))
    01162
    01163
    01164 /*--------------------------------.
    01165 | Print this symbol on YYOUTPUT.  |
    01166 `--------------------------------*/
    01167
    01168 /*ARGSUSED*/
    01169 #if (defined __STDC__ || defined __C99__FUNC__ \
    01170      || defined __cplusplus || defined _MSC_VER)
    01171 static void
    01172 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, OSResult *osresult, OSrLParserData *parserData)
    01173 #else
    01174 static void
    01175 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, osresult, parserData)
    01176     FILE *yyoutput;
    01177     int yytype;
    01178     YYSTYPE const * const yyvaluep;
    01179     YYLTYPE const * const yylocationp;
    01180     OSResult *osresult;
    01181     OSrLParserData *parserData;
    01182 #endif
    01183 {
    01184   if (!yyvaluep)
    01185     return;
    01186   YYUSE (yylocationp);
    01187   YYUSE (osresult);
    01188   YYUSE (parserData);
    01189 # ifdef YYPRINT
    01190   if (yytype < YYNTOKENS)
    01191     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
    01192 # else
    01193   YYUSE (yyoutput);
    01194 # endif
    01195   switch (yytype)
    01196     {
    01197       default:
    01198         break;
    01199     }
    01200 }
    01201
    01202
    01203 /*--------------------------------.
    01204 | Print this symbol on YYOUTPUT.  |
    01205 `--------------------------------*/
    01206
    01207 #if (defined __STDC__ || defined __C99__FUNC__ \
    01208      || defined __cplusplus || defined _MSC_VER)
    01209 static void
    01210 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, OSResult *osresult, OSrLParserData *parserData)
    01211 #else
    01212 static void
    01213 yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, osresult, parserData)
    01214     FILE *yyoutput;
    01215     int yytype;
    01216     YYSTYPE const * const yyvaluep;
    01217     YYLTYPE const * const yylocationp;
    01218     OSResult *osresult;
    01219     OSrLParserData *parserData;
    01220 #endif
    01221 {
    01222   if (yytype < YYNTOKENS)
    01223     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
    01224   else
    01225     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
    01226
    01227   YY_LOCATION_PRINT (yyoutput, *yylocationp);
    01228   YYFPRINTF (yyoutput, ": ");
    01229   yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, osresult, parserData);
    01230   YYFPRINTF (yyoutput, ")");
    01231 }
    01232
    01233 /*------------------------------------------------------------------.
    01234 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
    01235 | TOP (included).                                                   |
    01236 `------------------------------------------------------------------*/
    01237
    01238 #if (defined __STDC__ || defined __C99__FUNC__ \
    01239      || defined __cplusplus || defined _MSC_VER)
    01240 static void
    01241 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
    01242 #else
    01243 static void
    01244 yy_stack_print (bottom, top)
    01245     yytype_int16 *bottom;
    01246     yytype_int16 *top;
    01247 #endif
    01248 {
    01249   YYFPRINTF (stderr, "Stack now");
    01250   for (; bottom <= top; ++bottom)
    01251     YYFPRINTF (stderr, " %d", *bottom);
    01252   YYFPRINTF (stderr, "\n");
    01253 }
    01254
    01255 # define YY_STACK_PRINT(Bottom, Top)                            \
    01256 do {                                                            \
    01257   if (yydebug)                                                  \
    01258     yy_stack_print ((Bottom), (Top));                           \
    01259 } while (YYID (0))
    01260
    01261
    01262 /*------------------------------------------------.
    01263 | Report that the YYRULE is going to be reduced.  |
    01264 `------------------------------------------------*/
    01265
    01266 #if (defined __STDC__ || defined __C99__FUNC__ \
    01267      || defined __cplusplus || defined _MSC_VER)
    01268 static void
    01269 yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, OSResult *osresult, OSrLParserData *parserData)
    01270 #else
    01271 static void
    01272 yy_reduce_print (yyvsp, yylsp, yyrule, osresult, parserData)
    01273     YYSTYPE *yyvsp;
    01274     YYLTYPE *yylsp;
    01275     int yyrule;
    01276     OSResult *osresult;
    01277     OSrLParserData *parserData;
    01278 #endif
    01279 {
    01280   int yynrhs = yyr2[yyrule];
    01281   int yyi;
    01282   unsigned long int yylno = yyrline[yyrule];
    01283   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
    01284              yyrule - 1, yylno);
    01285   /* The symbols being reduced.  */
    01286   for (yyi = 0; yyi < yynrhs; yyi++)
    01287     {
    01288       fprintf (stderr, "   $%d = ", yyi + 1);
    01289       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
    01290                        &(yyvsp[(yyi + 1) - (yynrhs)])
    01291                        , &(yylsp[(yyi + 1) - (yynrhs)])                , osresult, parserData);
    01292       fprintf (stderr, "\n");
    01293     }
    01294 }
    01295
    01296 # define YY_REDUCE_PRINT(Rule)          \
    01297 do {                                    \
    01298   if (yydebug)                          \
    01299     yy_reduce_print (yyvsp, yylsp, Rule, osresult, parserData); \
    01300 } while (YYID (0))
    01301
    01302 /* Nonzero means print parse trace.  It is left uninitialized so that
    01303    multiple parsers can coexist.  */
    01304 int yydebug;
    01305 #else /* !YYDEBUG */
    01306 # define YYDPRINTF(Args)
    01307 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
    01308 # define YY_STACK_PRINT(Bottom, Top)
    01309 # define YY_REDUCE_PRINT(Rule)
    01310 #endif /* !YYDEBUG */
    01311
    01312
    01313 /* YYINITDEPTH -- initial size of the parser's stacks.  */
    01314 #ifndef YYINITDEPTH
    01315 # define YYINITDEPTH 200
    01316 #endif
    01317
    01318 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
    01319    if the built-in stack extension method is used).
    01320
    01321    Do not make this value too large; the results are undefined if
    01322    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
    01323    evaluated with infinite-precision integer arithmetic.  */
    01324
    01325 #ifndef YYMAXDEPTH
    01326 # define YYMAXDEPTH 10000
    01327 #endif
    01328
    01329
    01330
    01331 #if YYERROR_VERBOSE
    01332
    01333 # ifndef yystrlen
    01334 #  if defined __GLIBC__ && defined _STRING_H
    01335 #   define yystrlen strlen
    01336 #  else
    01337 /* Return the length of YYSTR.  */
    01338 #if (defined __STDC__ || defined __C99__FUNC__ \
    01339      || defined __cplusplus || defined _MSC_VER)
    01340 static YYSIZE_T
    01341 yystrlen (const char *yystr)
    01342 #else
    01343 static YYSIZE_T
    01344 yystrlen (yystr)
    01345     const char *yystr;
    01346 #endif
    01347 {
    01348   YYSIZE_T yylen;
    01349   for (yylen = 0; yystr[yylen]; yylen++)
    01350     continue;
    01351   return yylen;
    01352 }
    01353 #  endif
    01354 # endif
    01355
    01356 # ifndef yystpcpy
    01357 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
    01358 #   define yystpcpy stpcpy
    01359 #  else
    01360 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
    01361    YYDEST.  */
    01362 #if (defined __STDC__ || defined __C99__FUNC__ \
    01363      || defined __cplusplus || defined _MSC_VER)
    01364 static char *
    01365 yystpcpy (char *yydest, const char *yysrc)
    01366 #else
    01367 static char *
    01368 yystpcpy (yydest, yysrc)
    01369     char *yydest;
    01370     const char *yysrc;
    01371 #endif
    01372 {
    01373   char *yyd = yydest;
    01374   const char *yys = yysrc;
    01375
    01376   while ((*yyd++ = *yys++) != '\0')
    01377     continue;
    01378
    01379   return yyd - 1;
    01380 }
    01381 #  endif
    01382 # endif
    01383
    01384 # ifndef yytnamerr
    01385 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
    01386    quotes and backslashes, so that it's suitable for yyerror.  The
    01387    heuristic is that double-quoting is unnecessary unless the string
    01388    contains an apostrophe, a comma, or backslash (other than
    01389    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
    01390    null, do not copy; instead, return the length of what the result
    01391    would have been.  */
    01392 static YYSIZE_T
    01393 yytnamerr (char *yyres, const char *yystr)
    01394 {
    01395   if (*yystr == '"')
    01396     {
    01397       YYSIZE_T yyn = 0;
    01398       char const *yyp = yystr;
    01399
    01400       for (;;)
    01401         switch (*++yyp)
    01402           {
    01403           case '\'':
    01404           case ',':
    01405             goto do_not_strip_quotes;
    01406
    01407           case '\\':
    01408             if (*++yyp != '\\')
    01409               goto do_not_strip_quotes;
    01410             /* Fall through.  */
    01411           default:
    01412             if (yyres)
    01413               yyres[yyn] = *yyp;
    01414             yyn++;
    01415             break;
    01416
    01417           case '"':
    01418             if (yyres)
    01419               yyres[yyn] = '\0';
    01420             return yyn;
    01421           }
    01422     do_not_strip_quotes: ;
    01423     }
    01424
    01425   if (! yyres)
    01426     return yystrlen (yystr);
    01427
    01428   return yystpcpy (yyres, yystr) - yyres;
    01429 }
    01430 # endif
    01431
    01432 /* Copy into YYRESULT an error message about the unexpected token
    01433    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
    01434    including the terminating null byte.  If YYRESULT is null, do not
    01435    copy anything; just return the number of bytes that would be
    01436    copied.  As a special case, return 0 if an ordinary "syntax error"
    01437    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
    01438    size calculation.  */
    01439 static YYSIZE_T
    01440 yysyntax_error (char *yyresult, int yystate, int yychar)
    01441 {
    01442   int yyn = yypact[yystate];
    01443
    01444   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
    01445     return 0;
    01446   else
    01447     {
    01448       int yytype = YYTRANSLATE (yychar);
    01449       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
    01450       YYSIZE_T yysize = yysize0;
    01451       YYSIZE_T yysize1;
    01452       int yysize_overflow = 0;
    01453       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
    01454       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
    01455       int yyx;
    01456
    01457 # if 0
    01458       /* This is so xgettext sees the translatable formats that are
    01459          constructed on the fly.  */
    01460       YY_("syntax error, unexpected %s");
    01461       YY_("syntax error, unexpected %s, expecting %s");
    01462       YY_("syntax error, unexpected %s, expecting %s or %s");
    01463       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
    01464       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
    01465 # endif
    01466       char *yyfmt;
    01467       char const *yyf;
    01468       static char const yyunexpected[] = "syntax error, unexpected %s";
    01469       static char const yyexpecting[] = ", expecting %s";
    01470       static char const yyor[] = " or %s";
    01471       char yyformat[sizeof yyunexpected
    01472                     + sizeof yyexpecting - 1
    01473                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
    01474                        * (sizeof yyor - 1))];
    01475       char const *yyprefix = yyexpecting;
    01476
    01477       /* Start YYX at -YYN if negative to avoid negative indexes in
    01478          YYCHECK.  */
    01479       int yyxbegin = yyn < 0 ? -yyn : 0;
    01480
    01481       /* Stay within bounds of both yycheck and yytname.  */
    01482       int yychecklim = YYLAST - yyn + 1;
    01483       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
    01484       int yycount = 1;
    01485
    01486       yyarg[0] = yytname[yytype];
    01487       yyfmt = yystpcpy (yyformat, yyunexpected);
    01488
    01489       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
    01490         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
    01491           {
    01492             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
    01493               {
    01494                 yycount = 1;
    01495                 yysize = yysize0;
    01496                 yyformat[sizeof yyunexpected - 1] = '\0';
    01497                 break;
    01498               }
    01499             yyarg[yycount++] = yytname[yyx];
    01500             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
    01501             yysize_overflow |= (yysize1 < yysize);
    01502             yysize = yysize1;
    01503             yyfmt = yystpcpy (yyfmt, yyprefix);
    01504             yyprefix = yyor;
    01505           }
    01506
    01507       yyf = YY_(yyformat);
    01508       yysize1 = yysize + yystrlen (yyf);
    01509       yysize_overflow |= (yysize1 < yysize);
    01510       yysize = yysize1;
    01511
    01512       if (yysize_overflow)
    01513         return YYSIZE_MAXIMUM;
    01514
    01515       if (yyresult)
    01516         {
    01517           /* Avoid sprintf, as that infringes on the user's name space.
    01518              Don't have undefined behavior even if the translation
    01519              produced a string with the wrong number of "%s"s.  */
    01520           char *yyp = yyresult;
    01521           int yyi = 0;
    01522           while ((*yyp = *yyf) != '\0')
    01523             {
    01524               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
    01525                 {
    01526                   yyp += yytnamerr (yyp, yyarg[yyi++]);
    01527                   yyf += 2;
    01528                 }
    01529               else
    01530                 {
    01531                   yyp++;
    01532                   yyf++;
    01533                 }
    01534             }
    01535         }
    01536       return yysize;
    01537     }
    01538 }
    01539 #endif /* YYERROR_VERBOSE */
    01540
    01541
    01542 /*-----------------------------------------------.
    01543 | Release the memory associated to this symbol.  |
    01544 `-----------------------------------------------*/
    01545
    01546 /*ARGSUSED*/
    01547 #if (defined __STDC__ || defined __C99__FUNC__ \
    01548      || defined __cplusplus || defined _MSC_VER)
    01549 static void
    01550 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, OSResult *osresult, OSrLParserData *parserData)
    01551 #else
    01552 static void
    01553 yydestruct (yymsg, yytype, yyvaluep, yylocationp, osresult, parserData)
    01554     const char *yymsg;
    01555     int yytype;
    01556     YYSTYPE *yyvaluep;
    01557     YYLTYPE *yylocationp;
    01558     OSResult *osresult;
    01559     OSrLParserData *parserData;
    01560 #endif
    01561 {
    01562   YYUSE (yyvaluep);
    01563   YYUSE (yylocationp);
    01564   YYUSE (osresult);
    01565   YYUSE (parserData);
    01566
    01567   if (!yymsg)
    01568     yymsg = "Deleting";
    01569   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
    01570
    01571   switch (yytype)
    01572     {
    01573
    01574       default:
    01575         break;
    01576     }
    01577 }
    01578
    01579
    01580 /* Prevent warnings from -Wmissing-prototypes.  */
    01581
    01582 #ifdef YYPARSE_PARAM
    01583 #if defined __STDC__ || defined __cplusplus
    01584 int yyparse (void *YYPARSE_PARAM);
    01585 #else
    01586 int yyparse ();
    01587 #endif
    01588 #else /* ! YYPARSE_PARAM */
    01589 #if defined __STDC__ || defined __cplusplus
    01590 int yyparse (OSResult *osresult, OSrLParserData *parserData);
    01591 #else
    01592 int yyparse ();
    01593 #endif
    01594 #endif /* ! YYPARSE_PARAM */
    01595
    01596
    01597
    01598
    01599
    01600
    01601 /*----------.
    01602 | yyparse.  |
    01603 `----------*/
    01604
    01605 #ifdef YYPARSE_PARAM
    01606 #if (defined __STDC__ || defined __C99__FUNC__ \
    01607      || defined __cplusplus || defined _MSC_VER)
    01608 int
    01609 yyparse (void *YYPARSE_PARAM)
    01610 #else
    01611 int
    01612 yyparse (YYPARSE_PARAM)
    01613     void *YYPARSE_PARAM;
    01614 #endif
    01615 #else /* ! YYPARSE_PARAM */
    01616 #if (defined __STDC__ || defined __C99__FUNC__ \
    01617      || defined __cplusplus || defined _MSC_VER)
    01618 int
    01619 yyparse (OSResult *osresult, OSrLParserData *parserData)
    01620 #else
    01621 int
    01622 yyparse (osresult, parserData)
    01623     OSResult *osresult;
    01624     OSrLParserData *parserData;
    01625 #endif
    01626 #endif
    01627 {
    01628   /* The look-ahead symbol.  */
    01629 int yychar;
    01630
    01631 /* The semantic value of the look-ahead symbol.  */
    01632 YYSTYPE yylval;
    01633
    01634 /* Number of syntax errors so far.  */
    01635 int yynerrs;
    01636 /* Location data for the look-ahead symbol.  */
    01637 YYLTYPE yylloc;
    01638
    01639   int yystate;
    01640   int yyn;
    01641   int yyresult;
    01642   /* Number of tokens to shift before error messages enabled.  */
    01643   int yyerrstatus;
    01644   /* Look-ahead token as an internal (translated) token number.  */
    01645   int yytoken = 0;
    01646 #if YYERROR_VERBOSE
    01647   /* Buffer for error messages, and its allocated size.  */
    01648   char yymsgbuf[128];
    01649   char *yymsg = yymsgbuf;
    01650   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
    01651 #endif
    01652
    01653   /* Three stacks and their tools:
    01654      `yyss': related to states,
    01655      `yyvs': related to semantic values,
    01656      `yyls': related to locations.
    01657
    01658      Refer to the stacks thru separate pointers, to allow yyoverflow
    01659      to reallocate them elsewhere.  */
    01660
    01661   /* The state stack.  */
    01662   yytype_int16 yyssa[YYINITDEPTH];
    01663   yytype_int16 *yyss = yyssa;
    01664   yytype_int16 *yyssp;
    01665
    01666   /* The semantic value stack.  */
    01667   YYSTYPE yyvsa[YYINITDEPTH];
    01668   YYSTYPE *yyvs = yyvsa;
    01669   YYSTYPE *yyvsp;
    01670
    01671   /* The location stack.  */
    01672   YYLTYPE yylsa[YYINITDEPTH];
    01673   YYLTYPE *yyls = yylsa;
    01674   YYLTYPE *yylsp;
    01675   /* The locations where the error started and ended.  */
    01676   YYLTYPE yyerror_range[2];
    01677
    01678 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
    01679
    01680   YYSIZE_T yystacksize = YYINITDEPTH;
    01681
    01682   /* The variables used to return semantic value and location from the
    01683      action routines.  */
    01684   YYSTYPE yyval;
    01685   YYLTYPE yyloc;
    01686
    01687   /* The number of symbols on the RHS of the reduced rule.
    01688      Keep to zero when no symbol should be popped.  */
    01689   int yylen = 0;
    01690
    01691   YYDPRINTF ((stderr, "Starting parse\n"));
    01692
    01693   yystate = 0;
    01694   yyerrstatus = 0;
    01695   yynerrs = 0;
    01696   yychar = YYEMPTY;             /* Cause a token to be read.  */
    01697
    01698   /* Initialize stack pointers.
    01699      Waste one element of value and location stack
    01700      so that they stay on the same level as the state stack.
    01701      The wasted elements are never initialized.  */
    01702
    01703   yyssp = yyss;
    01704   yyvsp = yyvs;
    01705   yylsp = yyls;
    01706 #if YYLTYPE_IS_TRIVIAL
    01707   /* Initialize the default location before parsing starts.  */
    01708   yylloc.first_line   = yylloc.last_line   = 1;
    01709   yylloc.first_column = yylloc.last_column = 0;
    01710 #endif
    01711
    01712   goto yysetstate;
    01713
    01714 /*------------------------------------------------------------.
    01715 | yynewstate -- Push a new state, which is found in yystate.  |
    01716 `------------------------------------------------------------*/
    01717  yynewstate:
    01718   /* In all cases, when you get here, the value and location stacks
    01719      have just been pushed.  So pushing a state here evens the stacks.  */
    01720   yyssp++;
    01721
    01722  yysetstate:
    01723   *yyssp = yystate;
    01724
    01725   if (yyss + yystacksize - 1 <= yyssp)
    01726     {
    01727       /* Get the current used size of the three stacks, in elements.  */
    01728       YYSIZE_T yysize = yyssp - yyss + 1;
    01729
    01730 #ifdef yyoverflow
    01731       {
    01732         /* Give user a chance to reallocate the stack.  Use copies of
    01733            these so that the &'s don't force the real ones into
    01734            memory.  */
    01735         YYSTYPE *yyvs1 = yyvs;
    01736         yytype_int16 *yyss1 = yyss;
    01737         YYLTYPE *yyls1 = yyls;
    01738
    01739         /* Each stack pointer address is followed by the size of the
    01740            data in use in that stack, in bytes.  This used to be a
    01741            conditional around just the two extra args, but that might
    01742            be undefined if yyoverflow is a macro.  */
    01743         yyoverflow (YY_("memory exhausted"),
    01744                     &yyss1, yysize * sizeof (*yyssp),
    01745                     &yyvs1, yysize * sizeof (*yyvsp),
    01746                     &yyls1, yysize * sizeof (*yylsp),
    01747                     &yystacksize);
    01748         yyls = yyls1;
    01749         yyss = yyss1;
    01750         yyvs = yyvs1;
    01751       }
    01752 #else /* no yyoverflow */
    01753 # ifndef YYSTACK_RELOCATE
    01754       goto yyexhaustedlab;
    01755 # else
    01756       /* Extend the stack our own way.  */
    01757       if (YYMAXDEPTH <= yystacksize)
    01758         goto yyexhaustedlab;
    01759       yystacksize *= 2;
    01760       if (YYMAXDEPTH < yystacksize)
    01761         yystacksize = YYMAXDEPTH;
    01762
    01763       {
    01764         yytype_int16 *yyss1 = yyss;
    01765         union yyalloc *yyptr =
    01766           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
    01767         if (! yyptr)
    01768           goto yyexhaustedlab;
    01769         YYSTACK_RELOCATE (yyss);
    01770         YYSTACK_RELOCATE (yyvs);
    01771         YYSTACK_RELOCATE (yyls);
    01772 #  undef YYSTACK_RELOCATE
    01773         if (yyss1 != yyssa)
    01774           YYSTACK_FREE (yyss1);
    01775       }
    01776 # endif
    01777 #endif /* no yyoverflow */
    01778
    01779       yyssp = yyss + yysize - 1;
    01780       yyvsp = yyvs + yysize - 1;
    01781       yylsp = yyls + yysize - 1;
    01782
    01783       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
    01784                   (unsigned long int) yystacksize));
    01785
    01786       if (yyss + yystacksize - 1 <= yyssp)
    01787         YYABORT;
    01788     }
    01789
    01790   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
    01791
    01792   goto yybackup;
    01793
    01794 /*-----------.
    01795 | yybackup.  |
    01796 `-----------*/
    01797 yybackup:
    01798
    01799   /* Do appropriate processing given the current state.  Read a
    01800      look-ahead token if we need one and don't already have one.  */
    01801
    01802   /* First try to decide what to do without reference to look-ahead token.  */
    01803   yyn = yypact[yystate];
    01804   if (yyn == YYPACT_NINF)
    01805     goto yydefault;
    01806
    01807   /* Not known => get a look-ahead token if don't already have one.  */
    01808
    01809   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
    01810   if (yychar == YYEMPTY)
    01811     {
    01812       YYDPRINTF ((stderr, "Reading a token: "));
    01813       yychar = YYLEX;
    01814     }
    01815
    01816   if (yychar <= YYEOF)
    01817     {
    01818       yychar = yytoken = YYEOF;
    01819       YYDPRINTF ((stderr, "Now at end of input.\n"));
    01820     }
    01821   else
    01822     {
    01823       yytoken = YYTRANSLATE (yychar);
    01824       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    01825     }
    01826
    01827   /* If the proper action on seeing token YYTOKEN is to reduce or to
    01828      detect an error, take that action.  */
    01829   yyn += yytoken;
    01830   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    01831     goto yydefault;
    01832   yyn = yytable[yyn];
    01833   if (yyn <= 0)
    01834     {
    01835       if (yyn == 0 || yyn == YYTABLE_NINF)
    01836         goto yyerrlab;
    01837       yyn = -yyn;
    01838       goto yyreduce;
    01839     }
    01840
    01841   if (yyn == YYFINAL)
    01842     YYACCEPT;
    01843
    01844   /* Count tokens shifted since error; after three, turn off error
    01845      status.  */
    01846   if (yyerrstatus)
    01847     yyerrstatus--;
    01848
    01849   /* Shift the look-ahead token.  */
    01850   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
    01851
    01852   /* Discard the shifted token unless it is eof.  */
    01853   if (yychar != YYEOF)
    01854     yychar = YYEMPTY;
    01855
    01856   yystate = yyn;
    01857   *++yyvsp = yylval;
    01858   *++yylsp = yylloc;
    01859   goto yynewstate;
    01860
    01861
    01862 /*-----------------------------------------------------------.
    01863 | yydefault -- do the default action for the current state.  |
    01864 `-----------------------------------------------------------*/
    01865 yydefault:
    01866   yyn = yydefact[yystate];
    01867   if (yyn == 0)
    01868     goto yyerrlab;
    01869   goto yyreduce;
    01870
    01871
    01872 /*-----------------------------.
    01873 | yyreduce -- Do a reduction.  |
    01874 `-----------------------------*/
    01875 yyreduce:
    01876   /* yyn is the number of a rule to reduce with.  */
    01877   yylen = yyr2[yyn];
    01878
    01879   /* If YYLEN is nonzero, implement the default value of the action:
    01880      `$$ = $1'.
    01881
    01882      Otherwise, the following line sets YYVAL to garbage.
    01883      This behavior is undocumented and Bison
    01884      users should not rely upon it.  Assigning to YYVAL
    01885      unconditionally makes the parser a bit smaller, and it avoids a
    01886      GCC warning that YYVAL may be used uninitialized.  */
    01887   yyval = yyvsp[1-yylen];
    01888
    01889   /* Default location.  */
    01890   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
    01891   YY_REDUCE_PRINT (yyn);
    01892   switch (yyn)
    01893     {
    01894         case 7:
    01895
    01896     {if(parserData->generalStatusTypePresent == false) osrlerror(NULL, NULL, NULL, "a type attribute required for generalStatus element");}
    01897     break;
    01898
    01899   case 8:
    01900
    01901     {if(parserData->generalStatusTypePresent == false) osrlerror(NULL, NULL, NULL, "a type attribute required for generalStatus element"); parserData->generalStatusTypePresent = false;}
    01902     break;
    01903
    01904   case 11:
    01905
    01906     { osresult->setGeneralStatusType((yyvsp[(2) - (3)].sval));  free((yyvsp[(2) - (3)].sval));  ; parserData->generalStatusTypePresent = true;}
    01907     break;
    01908
    01909   case 12:
    01910
    01911     { osresult->setGeneralStatusType("");               parserData->generalStatusTypePresent = true;}
    01912     break;
    01913
    01914   case 13:
    01915
    01916     { osresult->setGeneralStatusDescription((yyvsp[(2) - (3)].sval));    free((yyvsp[(2) - (3)].sval));}
    01917     break;
    01918
    01919   case 14:
    01920
    01921     { osresult->setGeneralStatusDescription("");}
    01922     break;
    01923
    01924   case 17:
    01925
    01926     {osresult->setServiceURI( (yyvsp[(2) - (3)].sval)); free((yyvsp[(2) - (3)].sval)); parserData->errorText = NULL;}
    01927     break;
    01928
    01929   case 21:
    01930
    01931     {osresult->setServiceName( (yyvsp[(2) - (3)].sval));  free((yyvsp[(2) - (3)].sval));   parserData->errorText = NULL;}
    01932     break;
    01933
    01934   case 25:
    01935
    01936     {osresult->setInstanceName( (yyvsp[(2) - (3)].sval)) ;  free((yyvsp[(2) - (3)].sval));   parserData->errorText = NULL;}
    01937     break;
    01938
    01939   case 29:
    01940
    01941     {osresult->setJobID( (yyvsp[(2) - (3)].sval)); free((yyvsp[(2) - (3)].sval));  parserData->errorText = NULL;}
    01942     break;
    01943
    01944   case 33:
    01945
    01946     {osresult->setGeneralMessage( (yyvsp[(2) - (3)].sval));  free((yyvsp[(2) - (3)].sval));  parserData->errorText = NULL;}
    01947     break;
    01948
    01949   case 43:
    01950
    01951     {   if ((yyvsp[(3) - (4)].ival) < 0) osrlerror(NULL, NULL, NULL, "number of time measurements cannot be negative");
    01952         parserData->numberOfTimes = (yyvsp[(3) - (4)].ival);
    01953         parserData->ivar = 0;
    01954 }
    01955     break;
    01956
    01957   case 49:
    01958
    01959     {if (parserData->ivar == parserData->numberOfTimes)
    01960            osrlerror(NULL, NULL, NULL, "Too many time measurements");
    01961        osresult->addTimingInformation(parserData->timeType, parserData->timeCategory,
    01962                                       parserData->timeUnit, parserData->timeDescription, parserData->timeValue);
    01963        parserData->ivar++;
    01964        parserData->timeType = "elapsedTime";
    01965        parserData->timeCategory = "total";
    01966        parserData->timeUnit = "second";
    01967        parserData->timeDescription = "";
    01968       }
    01969     break;
    01970
    01971   case 56:
    01972
    01973     {parserData->timeType = (yyvsp[(2) - (3)].sval);  free((yyvsp[(2) - (3)].sval));}
    01974     break;
    01975
    01976   case 58:
    01977
    01978     {parserData->timeCategory = (yyvsp[(2) - (3)].sval);  free((yyvsp[(2) - (3)].sval));}
    01979     break;
    01980
    01981   case 60:
    01982
    01983     {parserData->timeUnit = (yyvsp[(2) - (3)].sval);   free((yyvsp[(2) - (3)].sval));}
    01984     break;
    01985
    01986   case 62:
    01987
    01988     {parserData->timeDescription = (yyvsp[(2) - (3)].sval);  free((yyvsp[(2) - (3)].sval));}
    01989     break;
    01990
    01991   case 64:
    01992
    01993     { parserData->timeValue = (yyvsp[(1) - (1)].dval); }
    01994     break;
    01995
    01996   case 65:
    01997
    01998     { parserData->timeValue = (yyvsp[(1) - (1)].ival); }
    01999     break;
    02000
    02001   case 67:
    02002
    02003     {printf("\nbefore OPTIMIZATIONEND\n");}
    02004     break;
    02005
    02006   case 69:
    02007
    02008     {
    02009 // we now have the basic problem parameters
    02010         if(parserData->numberOfSolutions > 0){
    02011                         if( parserData->numberOfVariables > 0){
    02012                                 parserData->primalSolution = new double* [parserData->numberOfSolutions];
    02013                                 for(int i = 0; i < parserData->numberOfSolutions; i++){
    02014                                         parserData->primalSolution[ i] = new double[ parserData->numberOfVariables];
    02015                                 }
    02016                         }
    02017                         //if( parserData->numberOfConstraints > 0){
    02018                         //      parserData->dualSolution = new double*[ parserData->numberOfSolutions];
    02019                         //      for(int i = 0; i < parserData->numberOfSolutions; i++){
    02020                         //              parserData->dualSolution[ i] = new double[ parserData->numberOfConstraints];
    02021                         //      }
    02022                         //}
    02023                         if( parserData->numberOfObjectives > 0){
    02024                                 parserData->objectiveValues = new double*[ parserData->numberOfSolutions];
    02025                                 parserData->objectiveIdx = new int[ parserData->numberOfSolutions];
    02026                                 for(int i = 0; i < parserData->numberOfSolutions; i++){
    02027                                         parserData->objectiveValues[ i] = new double[ parserData->numberOfObjectives];
    02028                                 }
    02029                         }
    02030         }
    02031 }
    02032     break;
    02033
    02034   case 72:
    02035
    02036     {printf("\nat optend\n");}
    02037     break;
    02038
    02039   case 79:
    02040
    02041     { parserData->numberOfSolutions = (yyvsp[(3) - (3)].ival); osresult->setSolutionNumber((yyvsp[(3) - (3)].ival));}
    02042     break;
    02043
    02044   case 80:
    02045
    02046     {parserData->numberOfVariables = (yyvsp[(3) - (3)].ival); osresult->setVariableNumber((yyvsp[(3) - (3)].ival)); }
    02047     break;
    02048
    02049   case 81:
    02050
    02051     {parserData->numberOfConstraints = (yyvsp[(3) - (3)].ival); osresult->setConstraintNumber((yyvsp[(3) - (3)].ival));}
    02052     break;
    02053
    02054   case 82:
    02055
    02056     {parserData->numberOfObjectives = (yyvsp[(3) - (3)].ival); osresult->setObjectiveNumber((yyvsp[(3) - (3)].ival));}
    02057     break;
    02058
    02059   case 85:
    02060
    02061     {printf("\ncompleted solution %d out of %d\n",parserData->solutionIdx,parserData->numberOfSolutions);
    02062    if (parserData->solutionIdx == parserData->numberOfSolutions)
    02063         osrlerror(NULL, NULL, NULL, "too many solutions");
    02064     parserData->solutionIdx++;
    02065    }
    02066     break;
    02067
    02068   case 87:
    02069
    02070     {if((yyvsp[(3) - (4)].ival) >= 0) osrlerror(NULL, NULL, NULL, "target objective index must be negative");
    02071 *(parserData->objectiveIdx + parserData->solutionIdx) = (yyvsp[(3) - (4)].ival);}
    02072     break;
    02073
    02074   case 88:
    02075
    02076     {if(parserData->statusTypePresent == false) osrlerror(NULL, NULL, NULL, "a type attribute required for status element");  osresult->setSolutionStatus(parserData->solutionIdx, parserData->statusType, parserData->statusDescription);}
    02077     break;
    02078
    02079   case 89:
    02080
    02081     {if(parserData->statusTypePresent == false) osrlerror(NULL, NULL, NULL, "a type attribute required for status element"); parserData->statusTypePresent = false; osresult->setSolutionStatus(parserData->solutionIdx, parserData->statusType, parserData->statusDescription);}
    02082     break;
    02083
    02084   case 92:
    02085
    02086     {parserData->statusType = (yyvsp[(2) - (3)].sval); parserData->statusTypePresent = true; free((yyvsp[(2) - (3)].sval));}
    02087     break;
    02088
    02089   case 93:
    02090
    02091     {parserData->statusType = ""; parserData->statusTypePresent = true;}
    02092     break;
    02093
    02094   case 94:
    02095
    02096     {parserData->statusDescription = (yyvsp[(2) - (3)].sval);  free((yyvsp[(2) - (3)].sval));}
    02097     break;
    02098
    02099   case 95:
    02100
    02101     {parserData->statusDescription = "";}
    02102     break;
    02103
    02104   case 97:
    02105
    02106     {osresult->optimization->solution[parserData->solutionIdx]->message = (yyvsp[(2) - (3)].sval); free((yyvsp[(2) - (3)].sval));}
    02107     break;
    02108
    02109   case 98:
    02110
    02111     {osresult->optimization->solution[parserData->solutionIdx]->message = "";}
    02112     break;
    02113
    02114   case 101:
    02115
    02116     { parserData->kounter = 0;}
    02117     break;
    02118
    02119   case 102:
    02120
    02121     {  osresult->setNumberOfOtherVariableResults(parserData->solutionIdx, (yyvsp[(3) - (4)].ival));
    02122         /*osresult->optimization->solution[parserData->solutionIdx]->variables->numberOfOtherVariableResults = $3*/;
    02123          parserData->kounter = 0;
    02124          parserData->iOther = 0;
    02125          parserData->tmpOtherValue = "";
    02126          parserData->tmpOtherName = "";
    02127          parserData->tmpOtherDescription = "";
    02128         }
    02129     break;
    02130
    02131   case 103:
    02132
    02133     {osresult->setNumberOfPrimalVariableValues(parserData->solutionIdx, (yyvsp[(3) - (4)].ival));
    02134          /*osresult->optimization->solution[parserData->solutionIdx]->variables->values->numberOfVar = $3;*/
    02135         }
    02136     break;
    02137
    02138   case 106:
    02139
    02140     {
    02141    if (parserData->kounter == osresult->optimization->solution[parserData->solutionIdx]->variables->values->numberOfVar)
    02142         osrlerror(NULL, NULL, NULL, "too many variables");
    02143
    02144         if (parserData->ivar < 0 || parserData->ivar > parserData->numberOfVariables - 1)
    02145             osrlerror(NULL, NULL, NULL, "index must be greater than 0 and less than the number of variables");
    02146
    02147
    02148         *(parserData->primalSolution[parserData->solutionIdx] + parserData->ivar ) = parserData->tempVal;
    02149         osresult->optimization->solution[parserData->solutionIdx]->variables->values->var.push_back(new VarValue());
    02150         osresult->optimization->solution[parserData->solutionIdx]->variables->values->var[parserData->kounter]->idx   = parserData->ivar;
    02151         osresult->optimization->solution[parserData->solutionIdx]->variables->values->var[parserData->kounter]->value = parserData->tempVal;
    02152
    02153
    02154     parserData->kounter++;
    02155 }
    02156     break;
    02157
    02158   case 107:
    02159
    02160     {parserData->tempVal = (yyvsp[(1) - (1)].ival);}
    02161     break;
    02162
    02163   case 108:
    02164
    02165     {parserData->tempVal = (yyvsp[(1) - (1)].dval);}
    02166     break;
    02167
    02168   case 111:
    02169
    02170     {
    02171
    02172                 parserData->otherVarVec.push_back( parserData->otherVarStruct);
    02173                 parserData->numberOfOtherVariableResults++;
    02174                 parserData->otherNamePresent = false;
    02175
    02176
    02177                 osresult->setAnOtherVariableResult(parserData->solutionIdx, parserData->iOther,  parserData->otherVarStruct->name,
    02178                         parserData->otherVarStruct->description, parserData->otherVarStruct->otherVarIndex, parserData->otherVarStruct->otherVarText,
    02179                         parserData->otherVarStruct->numberOfVar );
    02180
    02181
    02182                 std::cout  << "Other Name = " << parserData->otherVarStruct->name << std::endl;
    02183                 std::cout  << "Description  = " << parserData->otherVarStruct->description << std::endl;
    02184
    02185
    02186                 parserData->iOther++;
    02187                 parserData->tmpOtherName = "";
    02188                 parserData->tmpOtherValue = "";
    02189                 parserData->tmpOtherDescription = "";
    02190
    02191                 /*
    02192                 if (osresult->optimization == NULL)
    02193                         osresult->optimization = new OptimizationResult();
    02194
    02195                 if (osresult->optimization->solution == NULL)
    02196                 {       osresult->optimization->solution = new OptimizationSolution*();
    02197                         for (int i = 0; i < parserData->numberOfSolutions; i++)
    02198                                 osresult->optimization->solution[i] = new OptimizationSolution();
    02199                 }
    02200                 if (osresult->optimization->solution[parserData->solutionIdx]->variables == NULL){
    02201                         osresult->optimization->solution[parserData->solutionIdx]->variables = new VariableSolution();
    02202                         osresult->optimization->solution[parserData->solutionIdx]->variables->other = new OtherVariableResult*[osresult->getNumberOfOtherVariableResults(parserData->solutionIdx)];
    02203                 }
    02204                 osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther] = new OtherVariableResult();
    02205                 osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->name        = parserData->tmpOtherName;
    02206                 osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->value       = parserData->tmpOtherValue;
    02207                 osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->description = parserData->tmpOtherDescription;
    02208                 osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->numberOfVar = parserData->otherVarStruct->numberOfVar;
    02209                 */
    02210
    02211
    02212         }
    02213     break;
    02214
    02215   case 112:
    02216
    02217     {  // parserData->numberOfOtherVariableResults++;
    02218                 parserData->otherVarStruct = new OtherVariableResultStruct();
    02219                 parserData->otherVarStruct->otherVarText  = new std::string[parserData->numberOfVariables];
    02220                 parserData->otherVarStruct->otherVarIndex = new int[parserData->numberOfVariables];
    02221                 parserData->kounter = 0;
    02222         }
    02223     break;
    02224
    02225   case 113:
    02226
    02227     {   if(parserData->otherNamePresent == false)
    02228                         osrlerror(NULL, NULL, NULL, "other element requires name attribute");
    02229         }
    02230     break;
    02231
    02232   case 119:
    02233
    02234     {parserData->otherVarStruct->numberOfVar = (yyvsp[(3) - (4)].ival);
    02235  osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->numberOfVar = (yyvsp[(3) - (4)].ival);
    02236 }
    02237     break;
    02238
    02239   case 120:
    02240
    02241     {parserData->tmpOtherValue=""; parserData->otherVarStruct->value = "";  osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->value = "";}
    02242     break;
    02243
    02244   case 121:
    02245
    02246     {printf("\nset tmpOtherValue: %s\n",(yyvsp[(2) - (3)].sval)); parserData->tmpOtherValue=(yyvsp[(2) - (3)].sval); parserData->otherVarStruct->value = (yyvsp[(2) - (3)].sval);  osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->value = (yyvsp[(2) - (3)].sval); free((yyvsp[(2) - (3)].sval));}
    02247     break;
    02248
    02249   case 122:
    02250
    02251     { parserData->tmpOtherName=""; parserData->otherNamePresent = true; parserData->otherVarStruct->name = "";
    02252  // osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->name = "";
    02253 }
    02254     break;
    02255
    02256   case 123:
    02257
    02258     {printf("\nset tmpOtherName: %s\n",(yyvsp[(2) - (3)].sval));  parserData->tmpOtherName=(yyvsp[(2) - (3)].sval); parserData->otherNamePresent = true; parserData->otherVarStruct->name = (yyvsp[(2) - (3)].sval);  free((yyvsp[(2) - (3)].sval));
    02259  // osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->name = $2;
    02260 }
    02261     break;
    02262
    02263   case 124:
    02264
    02265     {printf("\nset tmpOtherDescription: %s\n",(yyvsp[(2) - (3)].sval));  parserData->tmpOtherDescription=(yyvsp[(2) - (3)].sval); parserData->otherVarStruct->description = (yyvsp[(2) - (3)].sval);  free((yyvsp[(2) - (3)].sval));
    02266   //osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->description = $2;
    02267 }
    02268     break;
    02269
    02270   case 127:
    02271
    02272     {
    02273 parserData->otherVarStruct->otherVarText[parserData->kounter] =  parserData->outStr.str();
    02274 //reset the buffer;
    02275 parserData->outStr.str("");
    02276 parserData->otherVarStruct->otherVarIndex[parserData->kounter] =  parserData->ivar;
    02277 parserData->errorText = NULL;
    02278 if (parserData->kounter == osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->numberOfVar)
    02279     osrlerror(NULL, NULL, NULL, "too many variables");
    02280 if (parserData->ivar < 0 || parserData->ivar > parserData->numberOfVariables - 1)
    02281     osrlerror(NULL, NULL, NULL, "index must be greater than 0 and less than the number of variables");
    02282
    02283 //osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->var.push_back(new OtherVarResult());
    02284 //osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->var[parserData->kounter]->idx   = parserData->ivar;
    02285 //osresult->optimization->solution[parserData->solutionIdx]->variables->other[parserData->iOther]->var[parserData->kounter]->value = parserData->tempVal;
    02286
    02287
    02288
    02289 parserData->kounter++;
    02290 }
    02291     break;
    02292
    02293   case 128:
    02294
    02295     {/*std::cout << "FOUND OTHER ELEMENT TEXT"  << std::endl;*/  parserData->outStr << (yyvsp[(1) - (1)].sval); /*free($1);*/ }
    02296     break;
    02297
    02298   case 129:
    02299
    02300     {/*std::cout << "FOUND OTHER ELEMENT INTEGER"  << std::endl;*/  parserData->outStr << (yyvsp[(1) - (1)].ival); /*free($1);*/ }
    02301     break;
    02302
    02303   case 130:
    02304
    02305     {/*std::cout << "FOUND OTHER ELEMENT DOUBLE"  << std::endl;*/ parserData->outStr << (yyvsp[(1) - (1)].dval); /*free($1);*/ }
    02306     break;
    02307
    02308   case 131:
    02309
    02310     {   if(parserData->otherVarStruct->numberOfVar <= 0)
    02311                         osrlerror(NULL, NULL,  parserData, "must specify the number of variables") ;
    02312         }
    02313     break;
    02314
    02315   case 137:
    02316
    02317     { /* *( parserData->objectiveValues[parserData->solutionIdx] + (parserData->kounter + parserData->numberOfObjectives)) = $4;*/
    02318 }
    02319     break;
    02320
    02321   case 138:
    02322
    02323     {/*  *(parserData->objectiveValues[parserData->solutionIdx] +  (parserData->kounter + parserData->numberOfObjectives)) = $4; */}
    02324     break;
    02325
    02326   case 140:
    02327
    02328     {
    02329                         if( parserData->numberOfConstraints > 0){
    02330                                 parserData->dualSolution = new double*[ parserData->numberOfSolutions];
    02331                                 for(int i = 0; i < parserData->numberOfSolutions; i++){
    02332                                         parserData->dualSolution[ i] = new double[ parserData->numberOfConstraints];
    02333                                 }
    02334                         }
    02335 }
    02336     break;
    02337
    02338   case 145:
    02339
    02340     {
    02341         if(parserData->kounter < 0 || parserData->kounter > parserData->numberOfConstraints- 1) osrlerror(NULL, NULL, NULL, "index must be greater than 0 and less than the number of constraints");
    02342         *(parserData->dualSolution[parserData->solutionIdx] + parserData->kounter) = (yyvsp[(4) - (5)].dval);}
    02343     break;
    02344
    02345   case 146:
    02346
    02347     {
    02348         if(parserData->kounter < 0 || parserData->kounter > parserData->numberOfConstraints- 1) osrlerror(NULL, NULL, NULL, "index must be greater than 0 and less than the number of constraints");
    02349         *(parserData->dualSolution[parserData->solutionIdx] + parserData->kounter) = (yyvsp[(4) - (5)].ival);}
    02350     break;
    02351
    02352   case 147:
    02353
    02354     {parserData->ivar = (yyvsp[(2) - (3)].ival);}
    02355     break;
    02356
    02357   case 152:
    02358
    02359     {printf("\nprocessed SOLUTIONEND\n");}
    02360     break;
    02361
    02362   case 153:
    02363
    02364     {printf("\nprocessed SOLUTIONEND\n");}
    02365     break;
    02366
    02367
    02368 /* Line 1267 of yacc.c.  */
    02369
    02370       default: break;
    02371     }
    02372   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
    02373
    02374   YYPOPSTACK (yylen);
    02375   yylen = 0;
    02376   YY_STACK_PRINT (yyss, yyssp);
    02377
    02378   *++yyvsp = yyval;
    02379   *++yylsp = yyloc;
    02380
    02381   /* Now `shift' the result of the reduction.  Determine what state
    02382      that goes to, based on the state we popped back to and the rule
    02383      number reduced by.  */
    02384
    02385   yyn = yyr1[yyn];
    02386
    02387   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
    02388   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    02389     yystate = yytable[yystate];
    02390   else
    02391     yystate = yydefgoto[yyn - YYNTOKENS];
    02392
    02393   goto yynewstate;
    02394
    02395
    02396 /*------------------------------------.
    02397 | yyerrlab -- here on detecting error |
    02398 `------------------------------------*/
    02399 yyerrlab:
    02400   /* If not already recovering from an error, report this error.  */
    02401   if (!yyerrstatus)
    02402     {
    02403       ++yynerrs;
    02404 #if ! YYERROR_VERBOSE
    02405       yyerror (&yylloc, osresult, parserData, YY_("syntax error"));
    02406 #else
    02407       {
    02408         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
    02409         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
    02410           {
    02411             YYSIZE_T yyalloc = 2 * yysize;
    02412             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
    02413               yyalloc = YYSTACK_ALLOC_MAXIMUM;
    02414             if (yymsg != yymsgbuf)
    02415               YYSTACK_FREE (yymsg);
    02416             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
    02417             if (yymsg)
    02418               yymsg_alloc = yyalloc;
    02419             else
    02420               {
    02421                 yymsg = yymsgbuf;
    02422                 yymsg_alloc = sizeof yymsgbuf;
    02423               }
    02424           }
    02425
    02426         if (0 < yysize && yysize <= yymsg_alloc)
    02427           {
    02428             (void) yysyntax_error (yymsg, yystate, yychar);
    02429             yyerror (&yylloc, osresult, parserData, yymsg);
    02430           }
    02431         else
    02432           {
    02433             yyerror (&yylloc, osresult, parserData, YY_("syntax error"));
    02434             if (yysize != 0)
    02435               goto yyexhaustedlab;
    02436           }
    02437       }
    02438 #endif
    02439     }
    02440
    02441   yyerror_range[0] = yylloc;
    02442
    02443   if (yyerrstatus == 3)
    02444     {
    02445       /* If just tried and failed to reuse look-ahead token after an
    02446          error, discard it.  */
    02447
    02448       if (yychar <= YYEOF)
    02449         {
    02450           /* Return failure if at end of input.  */
    02451           if (yychar == YYEOF)
    02452             YYABORT;
    02453         }
    02454       else
    02455         {
    02456           yydestruct ("Error: discarding",
    02457                       yytoken, &yylval, &yylloc, osresult, parserData);
    02458           yychar = YYEMPTY;
    02459         }
    02460     }
    02461
    02462   /* Else will try to reuse look-ahead token after shifting the error
    02463      token.  */
    02464   goto yyerrlab1;
    02465
    02466
    02467 /*---------------------------------------------------.
    02468 | yyerrorlab -- error raised explicitly by YYERROR.  |
    02469 `---------------------------------------------------*/
    02470 yyerrorlab:
    02471
    02472   /* Pacify compilers like GCC when the user code never invokes
    02473      YYERROR and the label yyerrorlab therefore never appears in user
    02474      code.  */
    02475   if (/*CONSTCOND*/ 0)
    02476      goto yyerrorlab;
    02477
    02478   yyerror_range[0] = yylsp[1-yylen];
    02479   /* Do not reclaim the symbols of the rule which action triggered
    02480      this YYERROR.  */
    02481   YYPOPSTACK (yylen);
    02482   yylen = 0;
    02483   YY_STACK_PRINT (yyss, yyssp);
    02484   yystate = *yyssp;
    02485   goto yyerrlab1;
    02486
    02487
    02488 /*-------------------------------------------------------------.
    02489 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
    02490 `-------------------------------------------------------------*/
    02491 yyerrlab1:
    02492   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
    02493
    02494   for (;;)
    02495     {
    02496       yyn = yypact[yystate];
    02497       if (yyn != YYPACT_NINF)
    02498         {
    02499           yyn += YYTERROR;
    02500           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
    02501             {
    02502               yyn = yytable[yyn];
    02503               if (0 < yyn)
    02504                 break;
    02505             }
    02506         }
    02507
    02508       /* Pop the current state because it cannot handle the error token.  */
    02509       if (yyssp == yyss)
    02510         YYABORT;
    02511
    02512       yyerror_range[0] = *yylsp;
    02513       yydestruct ("Error: popping",
    02514                   yystos[yystate], yyvsp, yylsp, osresult, parserData);
    02515       YYPOPSTACK (1);
    02516       yystate = *yyssp;
    02517       YY_STACK_PRINT (yyss, yyssp);
    02518     }
    02519
    02520   if (yyn == YYFINAL)
    02521     YYACCEPT;
    02522
    02523   *++yyvsp = yylval;
    02524
    02525   yyerror_range[1] = yylloc;
    02526   /* Using YYLLOC is tempting, but would change the location of
    02527      the look-ahead.  YYLOC is available though.  */
    02528   YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
    02529   *++yylsp = yyloc;
    02530
    02531   /* Shift the error token.  */
    02532   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
    02533
    02534   yystate = yyn;
    02535   goto yynewstate;
    02536
    02537
    02538 /*-------------------------------------.
    02539 | yyacceptlab -- YYACCEPT comes here.  |
    02540 `-------------------------------------*/
    02541 yyacceptlab:
    02542   yyresult = 0;
    02543   goto yyreturn;
    02544
    02545 /*-----------------------------------.
    02546 | yyabortlab -- YYABORT comes here.  |
    02547 `-----------------------------------*/
    02548 yyabortlab:
    02549   yyresult = 1;
    02550   goto yyreturn;
    02551
    02552 #ifndef yyoverflow
    02553 /*-------------------------------------------------.
    02554 | yyexhaustedlab -- memory exhaustion comes here.  |
    02555 `-------------------------------------------------*/
    02556 yyexhaustedlab:
    02557   yyerror (&yylloc, osresult, parserData, YY_("memory exhausted"));
    02558   yyresult = 2;
    02559   /* Fall through.  */
    02560 #endif
    02561
    02562 yyreturn:
    02563   if (yychar != YYEOF && yychar != YYEMPTY)
    02564      yydestruct ("Cleanup: discarding lookahead",
    02565                  yytoken, &yylval, &yylloc, osresult, parserData);
    02566   /* Do not reclaim the symbols of the rule which action triggered
    02567      this YYABORT or YYACCEPT.  */
    02568   YYPOPSTACK (yylen);
    02569   YY_STACK_PRINT (yyss, yyssp);
    02570   while (yyssp != yyss)
    02571     {
    02572       yydestruct ("Cleanup: popping",
    02573                   yystos[*yyssp], yyvsp, yylsp, osresult, parserData);
    02574       YYPOPSTACK (1);
    02575     }
    02576 #ifndef yyoverflow
    02577   if (yyss != yyssa)
    02578     YYSTACK_FREE (yyss);
    02579 #endif
    02580 #if YYERROR_VERBOSE
    02581   if (yymsg != yymsgbuf)
    02582     YYSTACK_FREE (yymsg);
    02583 #endif
    02584   /* Make sure YYID is used.  */
    02585   return YYID (yyresult);
    02586 }
    02587
    02588
    02589
    02590
    02591
    02592 void osrlerror(YYLTYPE* mytype, OSResult *osresult, OSrLParserData* parserData, const char* errormsg )
    02593 {
    02594         std::ostringstream outStr;
    02595         std::string error = errormsg;
    02596         error = "Input is either not valid or well formed: "  + error;
    02597         outStr << error << std::endl;
    02598         outStr << "See line number: " << osrlget_lineno( scanner) << std::endl;
    02599         outStr << "The offending text is: " << osrlget_text ( scanner ) << std::endl;
    02600         error = outStr.str();
    02601         //printf("THIS DID NOT GET DESTROYED:   %s\n", parserData->errorText);
    02602         //if( (parserData->errorText != NULL) &&  (strlen(parserData->errorText) > 0) ) free(  parserData->errorText);
    02603         //osrllex_destroy( scanner);
    02604         throw ErrorClass( error);
    02605 } //end osrlerror
    02606
    02607 void  yygetOSResult(const char *parsestring, OSResult *osresult, OSrLParserData *parserData) throw(ErrorClass){
    02608         try{
    02609                 osrl_scan_string( parsestring, scanner);
    02610                 osrlset_lineno (1 , scanner );
    02611                 //
    02612                 // call the Bison parser
    02613                 //
    02614                 if(  osrlparse( osresult,  parserData) != 0) {
    02615                         //osrllex_destroy(scanner);
    02616                         throw ErrorClass(  "Error parsing the OSrL");
    02617                  }
    02618         }
    02619         catch(const ErrorClass& eclass){
    02620                 throw ErrorClass(  eclass.errormsg);
    02621         }
    02622 } //end yygetOSResult
    02623
    02624