/home/coin/SVN-release/OS-2.0.1/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 

Generated on Thu Oct 8 03:03:00 2009 by  doxygen 1.4.7