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

- File List
- File Members

# /home/coin/SVN-release/OS-2.3.5/OS/src/OSParsers/OSParseosss.cpp

Go to the documentation of this file.

    00001 #line 2 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
    00002
    00003 #line 4 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
    00004
    00005 #define  YY_INT_ALIGNED short int
    00006
    00007 /* A lexical scanner generated by flex */
    00008
    00009 #define FLEX_SCANNER
    00010 #define YY_FLEX_MAJOR_VERSION 2
    00011 #define YY_FLEX_MINOR_VERSION 5
    00012 #define YY_FLEX_SUBMINOR_VERSION 35
    00013 #if YY_FLEX_SUBMINOR_VERSION > 0
    00014 #define FLEX_BETA
    00015 #endif
    00016
    00017 /* First, we deal with  platform-specific or compiler-specific issues. */
    00018
    00019 /* begin standard C headers. */
    00020 #include <stdio.h>
    00021 #include <string.h>
    00022 #include <errno.h>
    00023 #include <stdlib.h>
    00024
    00025 /* end standard C headers. */
    00026
    00027 /* flex integer type definitions */
    00028
    00029 #ifndef FLEXINT_H
    00030 #define FLEXINT_H
    00031
    00032 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
    00033
    00034 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    00035
    00036 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
    00037  * if you want the limit (max/min) macros for int types.
    00038  */
    00039 #ifndef __STDC_LIMIT_MACROS
    00040 #define __STDC_LIMIT_MACROS 1
    00041 #endif
    00042
    00043 #include <inttypes.h>
    00044 typedef int8_t flex_int8_t;
    00045 typedef uint8_t flex_uint8_t;
    00046 typedef int16_t flex_int16_t;
    00047 typedef uint16_t flex_uint16_t;
    00048 typedef int32_t flex_int32_t;
    00049 typedef uint32_t flex_uint32_t;
    00050 #else
    00051 typedef signed char flex_int8_t;
    00052 typedef short int flex_int16_t;
    00053 typedef int flex_int32_t;
    00054 typedef unsigned char flex_uint8_t;
    00055 typedef unsigned short int flex_uint16_t;
    00056 typedef unsigned int flex_uint32_t;
    00057
    00058 /* Limits of integral types. */
    00059 #ifndef INT8_MIN
    00060 #define INT8_MIN               (-128)
    00061 #endif
    00062 #ifndef INT16_MIN
    00063 #define INT16_MIN              (-32767-1)
    00064 #endif
    00065 #ifndef INT32_MIN
    00066 #define INT32_MIN              (-2147483647-1)
    00067 #endif
    00068 #ifndef INT8_MAX
    00069 #define INT8_MAX               (127)
    00070 #endif
    00071 #ifndef INT16_MAX
    00072 #define INT16_MAX              (32767)
    00073 #endif
    00074 #ifndef INT32_MAX
    00075 #define INT32_MAX              (2147483647)
    00076 #endif
    00077 #ifndef UINT8_MAX
    00078 #define UINT8_MAX              (255U)
    00079 #endif
    00080 #ifndef UINT16_MAX
    00081 #define UINT16_MAX             (65535U)
    00082 #endif
    00083 #ifndef UINT32_MAX
    00084 #define UINT32_MAX             (4294967295U)
    00085 #endif
    00086
    00087 #endif /* ! C99 */
    00088
    00089 #endif /* ! FLEXINT_H */
    00090
    00091 #ifdef __cplusplus
    00092
    00093 /* The "const" storage-class-modifier is valid. */
    00094 #define YY_USE_CONST
    00095
    00096 #else   /* ! __cplusplus */
    00097
    00098 /* C99 requires __STDC__ to be defined as 1. */
    00099 #if defined (__STDC__)
    00100
    00101 #define YY_USE_CONST
    00102
    00103 #endif  /* defined (__STDC__) */
    00104 #endif  /* ! __cplusplus */
    00105
    00106 #ifdef YY_USE_CONST
    00107 #define yyconst const
    00108 #else
    00109 #define yyconst
    00110 #endif
    00111
    00112 /* Returned upon end-of-file. */
    00113 #define YY_NULL 0
    00114
    00115 /* Promotes a possibly negative, possibly signed char to an unsigned
    00116  * integer for use as an array index.  If the signed char is negative,
    00117  * we want to instead treat it as an 8-bit unsigned char, hence the
    00118  * double cast.
    00119  */
    00120 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
    00121
    00122 /* An opaque pointer. */
    00123 #ifndef YY_TYPEDEF_YY_SCANNER_T
    00124 #define YY_TYPEDEF_YY_SCANNER_T
    00125 typedef void* yyscan_t;
    00126 #endif
    00127
    00128 /* For convenience, these vars (plus the bison vars far below)
    00129    are macros in the reentrant scanner. */
    00130 #define yyin yyg->yyin_r
    00131 #define yyout yyg->yyout_r
    00132 #define yyextra yyg->yyextra_r
    00133 #define yyleng yyg->yyleng_r
    00134 #define yytext yyg->yytext_r
    00135 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
    00136 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
    00137 #define yy_flex_debug yyg->yy_flex_debug_r
    00138
    00139 /* Enter a start condition.  This macro really ought to take a parameter,
    00140  * but we do it the disgusting crufty way forced on us by the ()-less
    00141  * definition of BEGIN.
    00142  */
    00143 #define BEGIN yyg->yy_start = 1 + 2 *
    00144
    00145 /* Translate the current start state into a value that can be later handed
    00146  * to BEGIN to return to the state.  The YYSTATE alias is for lex
    00147  * compatibility.
    00148  */
    00149 #define YY_START ((yyg->yy_start - 1) / 2)
    00150 #define YYSTATE YY_START
    00151
    00152 /* Action number for EOF rule of a given start state. */
    00153 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
    00154
    00155 /* Special action meaning "start processing a new file". */
    00156 #define YY_NEW_FILE osssrestart(yyin ,yyscanner )
    00157
    00158 #define YY_END_OF_BUFFER_CHAR 0
    00159
    00160 /* Size of default input buffer. */
    00161 #ifndef YY_BUF_SIZE
    00162 #ifdef __ia64__
    00163 /* On IA-64, the buffer size is 16k, not 8k.
    00164  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
    00165  * Ditto for the __ia64__ case accordingly.
    00166  */
    00167 #define YY_BUF_SIZE 32768
    00168 #else
    00169 #define YY_BUF_SIZE 16384
    00170 #endif /* __ia64__ */
    00171 #endif
    00172
    00173 /* The state buf must be large enough to hold one state per character in the main buffer.
    00174  */
    00175 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
    00176
    00177 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
    00178 #define YY_TYPEDEF_YY_BUFFER_STATE
    00179 typedef struct yy_buffer_state *YY_BUFFER_STATE;
    00180 #endif
    00181
    00182 #define EOB_ACT_CONTINUE_SCAN 0
    00183 #define EOB_ACT_END_OF_FILE 1
    00184 #define EOB_ACT_LAST_MATCH 2
    00185
    00186     /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
    00187      *       access to the local variable yy_act. Since yyless() is a macro, it would break
    00188      *       existing scanners that call yyless() from OUTSIDE ossslex.
    00189      *       One obvious solution it to make yy_act a global. I tried that, and saw
    00190      *       a 5% performance hit in a non-yylineno scanner, because yy_act is
    00191      *       normally declared as a register variable-- so it is not worth it.
    00192      */
    00193     #define  YY_LESS_LINENO(n) \
    00194             do { \
    00195                 int yyl;\
    00196                 for ( yyl = n; yyl < yyleng; ++yyl )\
    00197                     if ( yytext[yyl] == '\n' )\
    00198                         --yylineno;\
    00199             }while(0)
    00200
    00201 /* Return all but the first "n" matched characters back to the input stream. */
    00202 #define yyless(n) \
    00203         do \
    00204                 { \
    00205                 /* Undo effects of setting up yytext. */ \
    00206         int yyless_macro_arg = (n); \
    00207         YY_LESS_LINENO(yyless_macro_arg);\
    00208                 *yy_cp = yyg->yy_hold_char; \
    00209                 YY_RESTORE_YY_MORE_OFFSET \
    00210                 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
    00211                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
    00212                 } \
    00213         while ( 0 )
    00214
    00215 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
    00216
    00217 #ifndef YY_TYPEDEF_YY_SIZE_T
    00218 #define YY_TYPEDEF_YY_SIZE_T
    00219 typedef size_t yy_size_t;
    00220 #endif
    00221
    00222 #ifndef YY_STRUCT_YY_BUFFER_STATE
    00223 #define YY_STRUCT_YY_BUFFER_STATE
    00224 struct yy_buffer_state
    00225         {
    00226         FILE *yy_input_file;
    00227
    00228         char *yy_ch_buf;                /* input buffer */
    00229         char *yy_buf_pos;               /* current position in input buffer */
    00230
    00231         /* Size of input buffer in bytes, not including room for EOB
    00232          * characters.
    00233          */
    00234         yy_size_t yy_buf_size;
    00235
    00236         /* Number of characters read into yy_ch_buf, not including EOB
    00237          * characters.
    00238          */
    00239         int yy_n_chars;
    00240
    00241         /* Whether we "own" the buffer - i.e., we know we created it,
    00242          * and can realloc() it to grow it, and should free() it to
    00243          * delete it.
    00244          */
    00245         int yy_is_our_buffer;
    00246
    00247         /* Whether this is an "interactive" input source; if so, and
    00248          * if we're using stdio for input, then we want to use getc()
    00249          * instead of fread(), to make sure we stop fetching input after
    00250          * each newline.
    00251          */
    00252         int yy_is_interactive;
    00253
    00254         /* Whether we're considered to be at the beginning of a line.
    00255          * If so, '^' rules will be active on the next match, otherwise
    00256          * not.
    00257          */
    00258         int yy_at_bol;
    00259
    00260     int yy_bs_lineno;
    00261     int yy_bs_column;
    00263         /* Whether to try to fill the input buffer when we reach the
    00264          * end of it.
    00265          */
    00266         int yy_fill_buffer;
    00267
    00268         int yy_buffer_status;
    00269
    00270 #define YY_BUFFER_NEW 0
    00271 #define YY_BUFFER_NORMAL 1
    00272         /* When an EOF's been seen but there's still some text to process
    00273          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
    00274          * shouldn't try reading from the input source any more.  We might
    00275          * still have a bunch of tokens to match, though, because of
    00276          * possible backing-up.
    00277          *
    00278          * When we actually see the EOF, we change the status to "new"
    00279          * (via osssrestart()), so that the user can continue scanning by
    00280          * just pointing yyin at a new input file.
    00281          */
    00282 #define YY_BUFFER_EOF_PENDING 2
    00283
    00284         };
    00285 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
    00286
    00287 /* We provide macros for accessing buffer states in case in the
    00288  * future we want to put the buffer states in a more general
    00289  * "scanner state".
    00290  *
    00291  * Returns the top of the stack, or NULL.
    00292  */
    00293 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
    00294                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
    00295                           : NULL)
    00296
    00297 /* Same as previous macro, but useful when we know that the buffer stack is not
    00298  * NULL or when we need an lvalue. For internal use only.
    00299  */
    00300 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
    00301
    00302 void osssrestart (FILE *input_file ,yyscan_t yyscanner );
    00303 void osss_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
    00304 YY_BUFFER_STATE osss_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
    00305 void osss_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
    00306 void osss_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
    00307 void ossspush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
    00308 void ossspop_buffer_state (yyscan_t yyscanner );
    00309
    00310 static void osssensure_buffer_stack (yyscan_t yyscanner );
    00311 static void osss_load_buffer_state (yyscan_t yyscanner );
    00312 static void osss_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
    00313
    00314 #define YY_FLUSH_BUFFER osss_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
    00315
    00316 YY_BUFFER_STATE osss_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
    00317 YY_BUFFER_STATE osss_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
    00318 YY_BUFFER_STATE osss_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
    00319
    00320 void *osssalloc (yy_size_t ,yyscan_t yyscanner );
    00321 void *osssrealloc (void *,yy_size_t ,yyscan_t yyscanner );
    00322 void osssfree (void * ,yyscan_t yyscanner );
    00323
    00324 #define yy_new_buffer osss_create_buffer
    00325
    00326 #define yy_set_interactive(is_interactive) \
    00327         { \
    00328         if ( ! YY_CURRENT_BUFFER ){ \
    00329         osssensure_buffer_stack (yyscanner); \
    00330                 YY_CURRENT_BUFFER_LVALUE =    \
    00331             osss_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
    00332         } \
    00333         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    00334         }
    00335
    00336 #define yy_set_bol(at_bol) \
    00337         { \
    00338         if ( ! YY_CURRENT_BUFFER ){\
    00339         osssensure_buffer_stack (yyscanner); \
    00340                 YY_CURRENT_BUFFER_LVALUE =    \
    00341             osss_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
    00342         } \
    00343         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    00344         }
    00345
    00346 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
    00347
    00348 /* Begin user sect3 */
    00349
    00350 #define ossswrap(n) 1
    00351 #define YY_SKIP_YYWRAP
    00352
    00353 typedef unsigned char YY_CHAR;
    00354
    00355 typedef int yy_state_type;
    00356
    00357 #define yytext_ptr yytext_r
    00358
    00359 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
    00360 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  ,yyscan_t yyscanner);
    00361 static int yy_get_next_buffer (yyscan_t yyscanner );
    00362 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
    00363
    00364 /* Done after the current pattern has been matched and before the
    00365  * corresponding action - sets up yytext.
    00366  */
    00367 #define YY_DO_BEFORE_ACTION \
    00368         yyg->yytext_ptr = yy_bp; \
    00369         yyleng = (size_t) (yy_cp - yy_bp); \
    00370         yyg->yy_hold_char = *yy_cp; \
    00371         *yy_cp = '\0'; \
    00372         yyg->yy_c_buf_p = yy_cp;
    00373
    00374 #define YY_NUM_RULES 47
    00375 #define YY_END_OF_BUFFER 48
    00376 /* This struct is not used in this scanner,
    00377    but its presence is necessary. */
    00378 struct yy_trans_info
    00379         {
    00380         flex_int32_t yy_verify;
    00381         flex_int32_t yy_nxt;
    00382         };
    00383 static yyconst flex_int16_t yy_accept[347] =
    00384     {   0,
    00385         1,    1,   48,   46,    1,    1,   46,   46,   46,   46,
    00386        46,   46,   46,   46,   46,   46,    1,    0,    0,    0,
    00387         0,    5,    0,    0,    0,    0,    0,    7,    0,    0,
    00388         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    00389         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    00390         0,    0,    0,    0,   36,    0,    0,    0,    0,    0,
    00391         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    00392         0,    0,    0,    0,    0,    0,    0,   39,    4,    0,
    00393        33,   35,    0,    0,    0,    0,    0,    8,    0,    0,
    00394         0,    0,    0,    0,    0,    0,    0,   34,    0,    0,
    00395
    00396         0,    0,    0,    0,    0,    0,   38,    0,    0,   32,
    00397         0,    0,   35,   11,   20,    0,   14,    0,    0,    3,
    00398         0,    0,    0,   37,    0,    0,   31,    0,    0,   34,
    00399         0,    0,    0,    0,    0,    0,    0,    0,    0,   38,
    00400         0,    0,   32,    0,   10,    0,   19,    0,    0,   13,
    00401         0,    0,    0,    0,    0,    0,    0,   37,    0,    0,
    00402        31,    9,    0,   18,    0,    0,    0,   12,    0,    0,
    00403         0,    0,    0,    0,   10,    0,   19,    0,    0,   13,
    00404         0,   42,    0,    0,    0,    0,    0,    9,    0,   18,
    00405         0,    0,    0,   12,    0,    0,   45,    0,    0,    0,
    00406
    00407         0,   41,    0,    6,    0,    2,    0,    0,    0,    0,
    00408         0,    0,   40,    0,   44,    0,   16,    0,    0,    0,
    00409         0,    0,   41,   43,    0,    0,    2,   15,    0,    0,
    00410         0,    0,    0,    0,   40,    0,   44,    0,   16,   23,
    00411         0,    0,    0,   43,    0,   15,    0,    0,    0,    0,
    00412        22,    0,    0,    0,   21,    0,    0,    0,    0,    0,
    00413        22,    0,    0,    0,   21,   24,    0,    0,    0,    0,
    00414         0,    0,   24,    0,    0,    0,   27,    0,    0,    0,
    00415         0,    0,    0,    0,    0,    0,    0,    0,    0,   30,
    00416         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    00417
    00418         0,    0,    0,   29,    0,    0,    0,    0,    0,    0,
    00419         0,   28,    0,    0,    0,    0,    0,    0,    0,    0,
    00420        29,    0,   26,    0,    0,    0,    0,   28,    0,   25,
    00421         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    00422         0,    0,    0,    0,    0,    0
    00423     } ;
    00424
    00425 static yyconst flex_int32_t yy_ec[256] =
    00426     {   0,
    00427         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
    00428         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
    00429         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00430         1,    2,    4,    5,    4,    4,    1,    4,    1,    4,
    00431         4,    4,    4,    1,    6,    4,    4,    4,    4,    4,
    00432         4,    4,    4,    4,    4,    4,    4,    4,    1,    1,
    00433         1,    1,    4,    4,    4,    4,    4,    7,    4,    4,
    00434         4,    4,    8,    9,    4,   10,   11,    4,   12,    4,
    00435         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
    00436         1,    4,    1,    1,    4,    1,   13,   14,   15,   16,
    00437
    00438        17,   18,   19,   20,   21,    4,   22,   23,   24,   25,
    00439        26,   27,   28,   29,   30,   31,   32,   33,   34,    4,
    00440         4,    4,    1,    1,    1,    4,    1,    1,    1,    1,
    00441         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00442         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00443         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00444         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00445         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00446         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00447         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00448
    00449         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00450         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00451         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00452         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00453         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00454         1,    1,    1,    1,    1
    00455     } ;
    00456
    00457 static yyconst flex_int32_t yy_meta[35] =
    00458     {   0,
    00459         1,    2,    3,    2,    2,    2,    2,    2,    2,    2,
    00460         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
    00461         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
    00462         2,    2,    2,    2
    00463     } ;
    00464
    00465 static yyconst flex_int16_t yy_base[396] =
    00466     {   0,
    00467         0,   29,  598,  599,    2,    5,   54,  568,  583,  578,
    00468       569,  566,  569,  561,  558,    1,    7,    3,  560,  562,
    00469       574,  599,  561,  558,  561,  553,   12,  599,  556,  550,
    00470       557,  549,  548,    9,   13,  556,  547,  552,  557,  556,
    00471       546,  546,  539,  539,  538,   44,   35,  538,  543,  531,
    00472        49,  537,  553,   63,   80,  539,  538,  537,  536,  527,
    00473       524,  523,  532,  525,  519,  534,   69,  541,   74,   86,
    00474       527,  526,  525,  524,  513,  512,  514,   90,  599,  522,
    00475        94,   98,  537,  102,  104,  533,  106,  599,  519,  522,
    00476       511,  507,  506,  514,  108,  513,  112,  116,  528,  120,
    00477
    00478       122,    5,  124,  511,  514,  513,  126,  524,  498,  130,
    00479       522,  521,  599,  134,  138,  500,  142,  509,  494,  599,
    00480       501,  504,  501,  146,  514,  488,  150,  512,  511,  599,
    00481       154,  158,  490,  482,  162,  498,  483,  482,  505,  599,
    00482       478,  503,  599,  166,  170,  502,  174,  501,  478,  178,
    00483       499,  486,  182,  476,  472,  184,  495,  599,  468,  493,
    00484       599,  186,  492,  190,  491,  468,  463,  194,  488,  475,
    00485       198,  200,  202,  486,  599,  485,  599,  457,  483,  599,
    00486       196,  206,  462,  210,  212,  216,  481,  599,  480,  599,
    00487       452,  456,  477,  599,  210,  220,  224,  228,  450,  454,
    00488
    00489       462,  232,  473,  599,  236,  240,  472,  244,  445,  443,
    00490       448,  456,  248,  467,  252,  466,  256,  465,  260,  454,
    00491       437,  462,  599,  262,  461,  460,  599,  266,  459,  270,
    00492       432,  447,  430,  354,  599,  353,  599,  352,  599,  272,
    00493       343,  335,  349,  599,  347,  599,  276,  280,  338,  329,
    00494       282,  343,  316,  320,  286,  340,  290,  313,  317,  337,
    00495       599,  320,  324,  334,  599,  294,  333,  316,  320,  309,
    00496       298,  325,  599,  303,  300,  302,  302,  298,  331,  304,
    00497       301,   12,  299,   41,  306,  295,   23,  281,   64,  308,
    00498       263,  267,  260,  249,  251,  247,  312,  235,  237,  230,
    00499
    00500       221,  223,  221,  317,  235,  227,  209,  213,  195,  200,
    00501       177,  323,  193,  185,  167,  167,  149,  158,  137,  161,
    00502       599,  136,  599,  136,  133,  133,  141,  599,  116,  599,
    00503       116,  113,  113,  106,   99,   98,   85,   90,   61,   78,
    00504        40,   56,   24,   15,    2,  599,  361,  363,  365,  367,
    00505       369,  372,  373,  375,  378,  380,  382,  383,  385,  387,
    00506       390,  392,  393,  395,  397,  400,  402,  404,  406,  408,
    00507       410,  411,  413,  415,  417,  419,  422,  423,  426,  427,
    00508       430,  432,  434,  436,  438,  439,  441,  444,  446,  447,
    00509       450,  451,  453,  456,  458
    00510
    00511     } ;
    00512
    00513 static yyconst flex_int16_t yy_def[396] =
    00514     {   0,
    00515       347,  347,  346,  346,  346,  346,  346,  346,  346,  346,
    00516       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00517       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00518       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00519       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00520       346,  346,  346,  346,  348,  346,  346,  346,  346,  346,
    00521       346,  346,  346,  346,  346,  346,  346,  346,  346,  349,
    00522       346,  346,  346,  346,  346,  346,  346,  350,  346,  346,
    00523       351,  348,  352,  346,  346,  346,  346,  346,  346,  346,
    00524       346,  346,  346,  346,  353,  346,  354,  349,  355,  346,
    00525
    00526       346,  346,  346,  346,  346,  346,  350,  356,  346,  351,
    00527       357,  352,  346,  358,  359,  346,  360,  346,  346,  346,
    00528       346,  346,  346,  353,  361,  346,  354,  362,  355,  346,
    00529       363,  364,  346,  346,  365,  346,  346,  346,  356,  346,
    00530       346,  357,  346,  358,  358,  366,  359,  367,  346,  360,
    00531       368,  346,  346,  346,  346,  346,  361,  346,  346,  362,
    00532       346,  363,  369,  364,  370,  346,  346,  365,  371,  346,
    00533       346,  346,  346,  366,  346,  367,  346,  346,  368,  346,
    00534       346,  372,  346,  346,  373,  346,  369,  346,  370,  346,
    00535       346,  346,  371,  346,  346,  374,  375,  376,  346,  346,
    00536
    00537       346,  372,  377,  346,  378,  373,  379,  380,  346,  346,
    00538       346,  346,  374,  381,  375,  382,  376,  383,  346,  346,
    00539       346,  377,  346,  378,  384,  379,  346,  380,  385,  346,
    00540       346,  346,  346,  381,  346,  382,  346,  383,  346,  386,
    00541       346,  346,  384,  346,  385,  346,  387,  346,  346,  346,
    00542       386,  388,  346,  346,  387,  389,  390,  346,  346,  388,
    00543       346,  346,  346,  389,  346,  390,  391,  346,  346,  346,
    00544       346,  391,  346,  346,  346,  346,  346,  346,  346,  346,
    00545       346,  346,  346,  346,  346,  346,  346,  346,  346,  392,
    00546       346,  346,  346,  346,  346,  346,  393,  346,  346,  346,
    00547
    00548       346,  346,  346,  392,  394,  346,  346,  346,  346,  346,
    00549       346,  393,  395,  346,  346,  346,  346,  346,  346,  394,
    00550       346,  346,  346,  346,  346,  346,  395,  346,  346,  346,
    00551       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00552       346,  346,  346,  346,  346,    0,  346,  346,  346,  346,
    00553       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00554       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00555       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00556       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00557       346,  346,  346,  346,  346
    00558
    00559     } ;
    00560
    00561 static yyconst flex_int16_t yy_nxt[634] =
    00562     {   0,
    00563       346,    5,    6,   17,   17,    7,   17,   17,   17,   17,
    00564        55,   55,  133,    8,  346,    9,  134,   37,  330,   10,
    00565        11,  330,   39,   12,   13,   14,   38,   15,   48,   16,
    00566         5,    6,  292,   56,    7,   40,  293,   49,   57,   58,
    00567       323,   59,    8,  299,    9,   70,   70,  300,   10,   11,
    00568        78,   78,   12,   13,   14,   71,   15,  295,   16,   18,
    00569        72,   73,  323,   74,   81,   81,  296,   19,   20,   21,
    00570        95,   95,  345,   22,   23,   97,   97,   24,   25,   26,
    00571       302,   55,   55,   27,   83,  344,   28,   70,   70,  303,
    00572        99,   78,   78,  343,  108,   81,   81,  342,  111,  346,
    00573
    00574       346,  341,  346,  114,  114,  115,  115,  117,  117,   95,
    00575        95,  340,  125,   97,   97,  339,  128,  346,  346,  338,
    00576       346,  131,  131,  132,  132,  135,  135,  346,  346,  330,
    00577       346,  346,  346,  337,  346,  144,  144,  330,  146,  115,
    00578       115,  336,  148,  117,  117,  328,  151,  346,  346,  323,
    00579       346,  346,  346,  335,  346,  131,  131,  323,  163,  132,
    00580       132,  334,  165,  135,  135,  321,  169,  144,  144,  333,
    00581       146,  346,  346,  330,  346,  346,  346,  332,  346,  346,
    00582       346,  331,  346,  182,  182,  185,  185,  346,  346,  330,
    00583       346,  346,  346,  329,  346,  346,  346,  328,  346,  196,
    00584
    00585       196,  197,  197,  198,  198,  200,  201,  182,  182,  326,
    00586       203,  205,  205,  185,  185,  323,  207,  208,  208,  211,
    00587       212,  196,  196,  325,  214,  197,  197,  324,  216,  198,
    00588       198,  323,  218,  346,  346,  322,  346,  205,  205,  321,
    00589       225,  346,  346,  319,  346,  208,  208,  318,  229,  346,
    00590       346,  317,  346,  346,  346,  316,  346,  346,  346,  315,
    00591       346,  240,  240,  346,  346,  314,  346,  346,  346,  311,
    00592       346,  247,  247,  240,  240,  310,  252,  247,  247,  309,
    00593       256,  257,  257,  346,  346,  308,  346,  346,  346,  307,
    00594       346,  257,  257,  306,  267,  346,  346,  301,  346,  277,
    00595
    00596       277,  279,  279,  277,  277,  290,  290,  297,  297,  290,
    00597       290,  298,  305,  297,  297,  294,  313,  291,  346,  346,
    00598       281,  346,  285,  282,  346,  346,  280,  346,  278,  273,
    00599       283,  284,  279,  279,  276,  275,  274,  273,  265,  271,
    00600       270,  261,  269,  268,  265,  263,  262,  261,  259,  286,
    00601       258,  246,  287,  244,  254,  253,  239,  237,  235,  288,
    00602       289,    4,    4,    4,   82,   82,   98,   98,  107,  107,
    00603       110,  110,  112,  112,  124,  124,  127,  127,  129,  129,
    00604       139,  139,  142,  142,  145,  145,  147,  147,  150,  150,
    00605       157,  157,  160,  160,  162,  162,  164,  164,  168,  168,
    00606
    00607       174,  174,  176,  176,  179,  179,  187,  187,  189,  189,
    00608       193,  193,  202,  202,  206,  206,  213,  213,  215,  215,
    00609       217,  217,  222,  222,  224,  224,  226,  226,  228,  228,
    00610       234,  234,  236,  236,  238,  238,  243,  243,  245,  245,
    00611       251,  251,  255,  255,  260,  260,  264,  264,  266,  266,
    00612       272,  272,  304,  304,  312,  312,  320,  320,  327,  327,
    00613       250,  249,  248,  246,  227,  244,  223,  242,  241,  239,
    00614       237,  235,  233,  232,  231,  230,  227,  223,  221,  220,
    00615       219,  194,  210,  209,  190,  188,  204,  180,  199,  177,
    00616       175,  195,  194,  192,  191,  190,  188,  161,  186,  158,
    00617
    00618       184,  183,  181,  180,  178,  177,  175,  143,  173,  140,
    00619       172,  171,  170,  167,  166,  130,  161,  159,  158,  156,
    00620       155,  154,  153,  152,  149,  113,  143,  141,  140,  138,
    00621       137,  136,  130,  126,  123,  122,  121,  120,  119,  118,
    00622       116,  113,  109,  106,  105,  104,  103,  102,  101,  100,
    00623        96,   94,   93,   92,   91,   90,   89,   88,   87,   86,
    00624        85,   84,   80,   79,   77,   76,   75,   69,   68,   67,
    00625        66,   65,   64,   63,   62,   61,   60,   54,   53,   52,
    00626        51,   50,   47,   46,   45,   44,   43,   42,   41,   36,
    00627        35,   34,   33,   32,   31,   30,   29,  346,    3,  346,
    00628
    00629       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00630       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00631       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00632       346,  346,  346
    00633     } ;
    00634
    00635 static yyconst flex_int16_t yy_chk[634] =
    00636     {   0,
    00637         0,    1,    1,    5,    5,    1,    6,    6,   17,   17,
    00638        34,   34,  102,    1,    0,    1,  102,   16,  345,    1,
    00639         1,  344,   18,    1,    1,    1,   16,    1,   27,    1,
    00640         2,    2,  282,   35,    2,   18,  282,   27,   35,   35,
    00641       343,   35,    2,  287,    2,   46,   46,  287,    2,    2,
    00642        51,   51,    2,    2,    2,   47,    2,  284,    2,    7,
    00643        47,   47,  342,   47,   54,   54,  284,    7,    7,    7,
    00644        67,   67,  341,    7,    7,   69,   69,    7,    7,    7,
    00645       289,   55,   55,    7,   55,  340,    7,   70,   70,  289,
    00646        70,   78,   78,  339,   78,   81,   81,  338,   81,   82,
    00647
    00648        82,  337,   82,   84,   84,   85,   85,   87,   87,   95,
    00649        95,  336,   95,   97,   97,  335,   97,   98,   98,  334,
    00650        98,  100,  100,  101,  101,  103,  103,  107,  107,  333,
    00651       107,  110,  110,  332,  110,  114,  114,  331,  114,  115,
    00652       115,  329,  115,  117,  117,  327,  117,  124,  124,  326,
    00653       124,  127,  127,  325,  127,  131,  131,  324,  131,  132,
    00654       132,  322,  132,  135,  135,  320,  135,  144,  144,  319,
    00655       144,  145,  145,  318,  145,  147,  147,  317,  147,  150,
    00656       150,  316,  150,  153,  153,  156,  156,  162,  162,  315,
    00657       162,  164,  164,  314,  164,  168,  168,  313,  168,  171,
    00658
    00659       171,  172,  172,  173,  173,  181,  181,  182,  182,  311,
    00660       182,  184,  184,  185,  185,  310,  185,  186,  186,  195,
    00661       195,  196,  196,  309,  196,  197,  197,  308,  197,  198,
    00662       198,  307,  198,  202,  202,  306,  202,  205,  205,  305,
    00663       205,  206,  206,  303,  206,  208,  208,  302,  208,  213,
    00664       213,  301,  213,  215,  215,  300,  215,  217,  217,  299,
    00665       217,  219,  219,  224,  224,  298,  224,  228,  228,  296,
    00666       228,  230,  230,  240,  240,  295,  240,  247,  247,  294,
    00667       247,  248,  248,  251,  251,  293,  251,  255,  255,  292,
    00668       255,  257,  257,  291,  257,  266,  266,  288,  266,  271,
    00669
    00670       271,  275,  275,  277,  277,  280,  280,  285,  285,  290,
    00671       290,  286,  290,  297,  297,  283,  297,  281,  304,  304,
    00672       277,  304,  278,  277,  312,  312,  276,  312,  274,  272,
    00673       277,  277,  279,  279,  270,  269,  268,  267,  264,  263,
    00674       262,  260,  259,  258,  256,  254,  253,  252,  250,  279,
    00675       249,  245,  279,  243,  242,  241,  238,  236,  234,  279,
    00676       279,  347,  347,  347,  348,  348,  349,  349,  350,  350,
    00677       351,  351,  352,  352,  353,  353,  354,  354,  355,  355,
    00678       356,  356,  357,  357,  358,  358,  359,  359,  360,  360,
    00679       361,  361,  362,  362,  363,  363,  364,  364,  365,  365,
    00680
    00681       366,  366,  367,  367,  368,  368,  369,  369,  370,  370,
    00682       371,  371,  372,  372,  373,  373,  374,  374,  375,  375,
    00683       376,  376,  377,  377,  378,  378,  379,  379,  380,  380,
    00684       381,  381,  382,  382,  383,  383,  384,  384,  385,  385,
    00685       386,  386,  387,  387,  388,  388,  389,  389,  390,  390,
    00686       391,  391,  392,  392,  393,  393,  394,  394,  395,  395,
    00687       233,  232,  231,  229,  226,  225,  222,  221,  220,  218,
    00688       216,  214,  212,  211,  210,  209,  207,  203,  201,  200,
    00689       199,  193,  192,  191,  189,  187,  183,  179,  178,  176,
    00690       174,  170,  169,  167,  166,  165,  163,  160,  159,  157,
    00691
    00692       155,  154,  152,  151,  149,  148,  146,  142,  141,  139,
    00693       138,  137,  136,  134,  133,  129,  128,  126,  125,  123,
    00694       122,  121,  119,  118,  116,  112,  111,  109,  108,  106,
    00695       105,  104,   99,   96,   94,   93,   92,   91,   90,   89,
    00696        86,   83,   80,   77,   76,   75,   74,   73,   72,   71,
    00697        68,   66,   65,   64,   63,   62,   61,   60,   59,   58,
    00698        57,   56,   53,   52,   50,   49,   48,   45,   44,   43,
    00699        42,   41,   40,   39,   38,   37,   36,   33,   32,   31,
    00700        30,   29,   26,   25,   24,   23,   21,   20,   19,   15,
    00701        14,   13,   12,   11,   10,    9,    8,    3,  346,  346,
    00702
    00703       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00704       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00705       346,  346,  346,  346,  346,  346,  346,  346,  346,  346,
    00706       346,  346,  346
    00707     } ;
    00708
    00709 /* Table of booleans, true if rule could match eol. */
    00710 static yyconst flex_int32_t yy_rule_can_match_eol[48] =
    00711     {   0,
    00712 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    00713     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    00714     1, 1, 1, 1, 1, 1, 0, 0,     };
    00715
    00716 /* The intent behind this definition is that it'll catch
    00717  * any uses of REJECT which flex missed.
    00718  */
    00719 #define REJECT reject_used_but_not_detected
    00720 #define yymore() yymore_used_but_not_detected
    00721 #define YY_MORE_ADJ 0
    00722 #define YY_RESTORE_YY_MORE_OFFSET
    00723 #line 1 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    00724 /* $Id: OSParseosss.cpp 4120 2011-03-30 06:28:16Z kmartin $ */
    00739 #line 18 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    00740
    00741
    00742 #include <iostream>
    00743 #include "OSConfig.h"
    00744
    00745
    00746 #ifdef HAVE_CSTRING
    00747 # include <cstring>
    00748 #else
    00749 # ifdef HAVE_STRING_H
    00750 #  include <string.h>
    00751 # else
    00752 #  error "don't have header file for string"
    00753 # endif
    00754 #endif
    00755
    00756 #ifdef HAVE_CSTDIO
    00757 # include <cstdio>
    00758 #else
    00759 # ifdef HAVE_STDIO_H
    00760 #  include <stdio.h>
    00761 # else
    00762 #  error "don't have header file for stdio"
    00763 # endif
    00764 #endif
    00765 #include "OSErrorClass.h"
    00766 #include <sstream>
    00767 #include "OSOptionsStruc.h"
    00768
    00769
    00770 using std::cout;
    00771 using std::endl;
    00772 using std::ostringstream;
    00773
    00774 //#define PARSERDEBUG
    00775 #ifdef PARSERDEBUG
    00776         #define YY_PRINT  printf("Found option:  %s\n", yytext);
    00777 #else
    00778         #define YY_PRINT  ;
    00779 #endif
    00780
    00781
    00782 #ifdef WIN_
    00783   #define YY_NO_UNISTD_H
    00784   #include <io.h>
    00785   #include <process.h>
    00786   #ifdef USE_OLD_UNISTD
    00787      #include<sys/unistd.h>
    00788   #endif
    00789 #endif
    00790
    00791
    00792 #define YY_EXTRA_TYPE struct osOptionsStruc*
    00793
    00794 void setyyextra( osOptionsStruc *osoptions, void* scanner);
    00795
    00796  /*
    00797  * INPUTS:
    00798  * -osil xxx.osil (file name on local machine of optimization instance,
    00799  *       this is "" by default, however if this remains "" a problem
    00800  *               instance must be specified in the osol file)
    00801  * -osol xxx.osol (file name on local machine of solver options,
    00802  *       default default value is "")
    00803  * -osrl xxx.osrl (file name on local machine where the optimization
    00804  *       result is put, default is "")
    00805  * -serviceLocation location URL (the URL  of the server that is called
    00806  *       remotely if the problem not solved locally, default is "")
    00807  * -serviceMethod  (send, solve, kill, knock, getJobID, retrieve,
    00808  *       default value is solve)
    00809  * -osplInput xxx.ospl  (Not used for now -- ignore)
    00810  * -osplOutput xxx.ospl (Not used for now -- ignore)
    00811  * -mps xxxx.mps (converts mps format to osil and has same effect as -osil)
    00812  * -nl xxxx.nl (converts nl format to osil and has same effect as -osil)
    00813  * -solver solverName (the name of the solver to be invoked)
    00814  * -browser path location to browser e.g.
    00815  *       /Applications/Firefox.app/Contents/MacOS/firefox (default is "")
    00816  * -config pathToConfigFile is the path to a configure file with the problem
    00817  *           parameters
    00818  * -insList xxx.dat (used only for LINDO, file location on local
    00819  *       machine of LINDO instruction list)
    00820 */
    00821
    00822
    00823 #line 824 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
    00824
    00825 #define INITIAL 0
    00826
    00827 #ifndef YY_NO_UNISTD_H
    00828 /* Special case for "unistd.h", since it is non-ANSI. We include it way
    00829  * down here because we want the user's section 1 to have been scanned first.
    00830  * The user has a chance to override it with an option.
    00831  */
    00832 #include <unistd.h>
    00833 #endif
    00834
    00835 #ifndef YY_EXTRA_TYPE
    00836 #define YY_EXTRA_TYPE void *
    00837 #endif
    00838
    00839 /* Holds the entire state of the reentrant scanner. */
    00840 struct yyguts_t
    00841     {
    00842
    00843     /* User-defined. Not touched by flex. */
    00844     YY_EXTRA_TYPE yyextra_r;
    00845
    00846     /* The rest are the same as the globals declared in the non-reentrant scanner. */
    00847     FILE *yyin_r, *yyout_r;
    00848     size_t yy_buffer_stack_top;
    00849     size_t yy_buffer_stack_max;
    00850     YY_BUFFER_STATE * yy_buffer_stack;
    00851     char yy_hold_char;
    00852     int yy_n_chars;
    00853     int yyleng_r;
    00854     char *yy_c_buf_p;
    00855     int yy_init;
    00856     int yy_start;
    00857     int yy_did_buffer_switch_on_eof;
    00858     int yy_start_stack_ptr;
    00859     int yy_start_stack_depth;
    00860     int *yy_start_stack;
    00861     yy_state_type yy_last_accepting_state;
    00862     char* yy_last_accepting_cpos;
    00863
    00864     int yylineno_r;
    00865     int yy_flex_debug_r;
    00866
    00867     char *yytext_r;
    00868     int yy_more_flag;
    00869     int yy_more_len;
    00870
    00871     }; /* end struct yyguts_t */
    00872
    00873 static int yy_init_globals (yyscan_t yyscanner );
    00874
    00875 int ossslex_init (yyscan_t* scanner);
    00876
    00877 int ossslex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
    00878
    00879 /* Accessor methods to globals.
    00880    These are made visible to non-reentrant scanners for convenience. */
    00881
    00882 int ossslex_destroy (yyscan_t yyscanner );
    00883
    00884 int osssget_debug (yyscan_t yyscanner );
    00885
    00886 void osssset_debug (int debug_flag ,yyscan_t yyscanner );
    00887
    00888 YY_EXTRA_TYPE osssget_extra (yyscan_t yyscanner );
    00889
    00890 void osssset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
    00891
    00892 FILE *osssget_in (yyscan_t yyscanner );
    00893
    00894 void osssset_in  (FILE * in_str ,yyscan_t yyscanner );
    00895
    00896 FILE *osssget_out (yyscan_t yyscanner );
    00897
    00898 void osssset_out  (FILE * out_str ,yyscan_t yyscanner );
    00899
    00900 int osssget_leng (yyscan_t yyscanner );
    00901
    00902 char *osssget_text (yyscan_t yyscanner );
    00903
    00904 int osssget_lineno (yyscan_t yyscanner );
    00905
    00906 void osssset_lineno (int line_number ,yyscan_t yyscanner );
    00907
    00908 /* Macros after this point can all be overridden by user definitions in
    00909  * section 1.
    00910  */
    00911
    00912 #ifndef YY_SKIP_YYWRAP
    00913 #ifdef __cplusplus
    00914 extern "C" int ossswrap (yyscan_t yyscanner );
    00915 #else
    00916 extern int ossswrap (yyscan_t yyscanner );
    00917 #endif
    00918 #endif
    00919
    00920 #ifndef yytext_ptr
    00921 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
    00922 #endif
    00923
    00924 #ifdef YY_NEED_STRLEN
    00925 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
    00926 #endif
    00927
    00928 #ifndef YY_NO_INPUT
    00929
    00930 #ifdef __cplusplus
    00931 static int yyinput (yyscan_t yyscanner );
    00932 #else
    00933 static int input (yyscan_t yyscanner );
    00934 #endif
    00935
    00936 #endif
    00937
    00938 /* Amount of stuff to slurp up with each read. */
    00939 #ifndef YY_READ_BUF_SIZE
    00940 #ifdef __ia64__
    00941 /* On IA-64, the buffer size is 16k, not 8k */
    00942 #define YY_READ_BUF_SIZE 16384
    00943 #else
    00944 #define YY_READ_BUF_SIZE 8192
    00945 #endif /* __ia64__ */
    00946 #endif
    00947
    00948 /* Copy whatever the last rule matched to the standard output. */
    00949 #ifndef ECHO
    00950 /* This used to be an fputs(), but since the string might contain NUL's,
    00951  * we now use fwrite().
    00952  */
    00953 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
    00954 #endif
    00955
    00956 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
    00957  * is returned in "result".
    00958  */
    00959 #ifndef YY_INPUT
    00960 #define YY_INPUT(buf,result,max_size) \
    00961         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
    00962                 { \
    00963                 int c = '*'; \
    00964                 size_t n; \
    00965                 for ( n = 0; n < max_size && \
    00966                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
    00967                         buf[n] = (char) c; \
    00968                 if ( c == '\n' ) \
    00969                         buf[n++] = (char) c; \
    00970                 if ( c == EOF && ferror( yyin ) ) \
    00971                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
    00972                 result = n; \
    00973                 } \
    00974         else \
    00975                 { \
    00976                 errno=0; \
    00977                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
    00978                         { \
    00979                         if( errno != EINTR) \
    00980                                 { \
    00981                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
    00982                                 break; \
    00983                                 } \
    00984                         errno=0; \
    00985                         clearerr(yyin); \
    00986                         } \
    00987                 }\
    00988 \
    00989
    00990 #endif
    00991
    00992 /* No semi-colon after return; correct usage is to write "yyterminate();" -
    00993  * we don't want an extra ';' after the "return" because that will cause
    00994  * some compilers to complain about unreachable statements.
    00995  */
    00996 #ifndef yyterminate
    00997 #define yyterminate() return YY_NULL
    00998 #endif
    00999
    01000 /* Number of entries by which start-condition stack grows. */
    01001 #ifndef YY_START_STACK_INCR
    01002 #define YY_START_STACK_INCR 25
    01003 #endif
    01004
    01005 /* Report a fatal error. */
    01006 #ifndef YY_FATAL_ERROR
    01007 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
    01008 #endif
    01009
    01010 /* end tables serialization structures and prototypes */
    01011
    01012 /* Default declaration of generated scanner - a define so the user can
    01013  * easily add parameters.
    01014  */
    01015 #ifndef YY_DECL
    01016 #define YY_DECL_IS_OURS 1
    01017
    01018 extern int ossslex (yyscan_t yyscanner);
    01019
    01020 #define YY_DECL int ossslex (yyscan_t yyscanner)
    01021 #endif /* !YY_DECL */
    01022
    01023 /* Code executed at the beginning of each rule, after yytext and yyleng
    01024  * have been set up.
    01025  */
    01026 #ifndef YY_USER_ACTION
    01027 #define YY_USER_ACTION
    01028 #endif
    01029
    01030 /* Code executed at the end of each rule. */
    01031 #ifndef YY_BREAK
    01032 #define YY_BREAK break;
    01033 #endif
    01034
    01035 #define YY_RULE_SETUP \
    01036         YY_USER_ACTION
    01037
    01040 YY_DECL
    01041 {
    01042         register yy_state_type yy_current_state;
    01043         register char *yy_cp, *yy_bp;
    01044         register int yy_act;
    01045     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    01046
    01047 #line 114 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01048
    01049
    01050 #line 1051 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
    01051
    01052         if ( !yyg->yy_init )
    01053                 {
    01054                 yyg->yy_init = 1;
    01055
    01056 #ifdef YY_USER_INIT
    01057                 YY_USER_INIT;
    01058 #endif
    01059
    01060                 if ( ! yyg->yy_start )
    01061                         yyg->yy_start = 1;      /* first start state */
    01062
    01063                 if ( ! yyin )
    01064                         yyin = stdin;
    01065
    01066                 if ( ! yyout )
    01067                         yyout = stdout;
    01068
    01069                 if ( ! YY_CURRENT_BUFFER ) {
    01070                         osssensure_buffer_stack (yyscanner);
    01071                         YY_CURRENT_BUFFER_LVALUE =
    01072                                 osss_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
    01073                 }
    01074
    01075                 osss_load_buffer_state(yyscanner );
    01076                 }
    01077
    01078         while ( 1 )             /* loops until end-of-file is reached */
    01079                 {
    01080                 yy_cp = yyg->yy_c_buf_p;
    01081
    01082                 /* Support of yytext. */
    01083                 *yy_cp = yyg->yy_hold_char;
    01084
    01085                 /* yy_bp points to the position in yy_ch_buf of the start of
    01086                  * the current run.
    01087                  */
    01088                 yy_bp = yy_cp;
    01089
    01090                 yy_current_state = yyg->yy_start;
    01091 yy_match:
    01092                 do
    01093                         {
    01094                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
    01095                         if ( yy_accept[yy_current_state] )
    01096                                 {
    01097                                 yyg->yy_last_accepting_state = yy_current_state;
    01098                                 yyg->yy_last_accepting_cpos = yy_cp;
    01099                                 }
    01100                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    01101                                 {
    01102                                 yy_current_state = (int) yy_def[yy_current_state];
    01103                                 if ( yy_current_state >= 347 )
    01104                                         yy_c = yy_meta[(unsigned int) yy_c];
    01105                                 }
    01106                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    01107                         ++yy_cp;
    01108                         }
    01109                 while ( yy_base[yy_current_state] != 599 );
    01110
    01111 yy_find_action:
    01112                 yy_act = yy_accept[yy_current_state];
    01113                 if ( yy_act == 0 )
    01114                         { /* have to back up */
    01115                         yy_cp = yyg->yy_last_accepting_cpos;
    01116                         yy_current_state = yyg->yy_last_accepting_state;
    01117                         yy_act = yy_accept[yy_current_state];
    01118                         }
    01119
    01120                 YY_DO_BEFORE_ACTION;
    01121
    01122                 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
    01123                         {
    01124                         int yyl;
    01125                         for ( yyl = 0; yyl < yyleng; ++yyl )
    01126                                 if ( yytext[yyl] == '\n' )
    01127
    01128     do{ yylineno++;
    01129         yycolumn=0;
    01130     }while(0)
    01131 ;
    01132                         }
    01133
    01134 do_action:      /* This label is used only to access EOF actions. */
    01135
    01136                 switch ( yy_act )
    01137         { /* beginning of action switch */
    01138                         case 0: /* must back up */
    01139                         /* undo the effects of YY_DO_BEFORE_ACTION */
    01140                         *yy_cp = yyg->yy_hold_char;
    01141                         yy_cp = yyg->yy_last_accepting_cpos;
    01142                         yy_current_state = yyg->yy_last_accepting_state;
    01143                         goto yy_find_action;
    01144
    01145 case 1:
    01146 /* rule 1 can match eol */
    01147 YY_RULE_SETUP
    01148 #line 116 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01149
    01150         YY_BREAK
    01151 case 2:
    01152 /* rule 2 can match eol */
    01153 YY_RULE_SETUP
    01154 #line 120 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01155 {
    01156         YY_PRINT
    01157         //char *ch = strdup(yytext);
    01158         char *ch = yytext;
    01159         // move past -config
    01160         ch+=7;
    01161         for(; isspace(*ch); ch++);
    01162         std::string str(  ch);
    01163         yyextra->configFile = str;
    01164
    01165 }
    01166         YY_BREAK
    01167 case 3:
    01168 YY_RULE_SETUP
    01169 #line 133 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01170 {
    01171         YY_PRINT
    01172         yyextra->invokeHelp = true;
    01173
    01174 }
    01175         YY_BREAK
    01176 case 4:
    01177 YY_RULE_SETUP
    01178 #line 139 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01179 {
    01180     YY_PRINT
    01181     yyextra->invokeHelp = true;
    01182
    01183  }
    01184         YY_BREAK
    01185 case 5:
    01186 YY_RULE_SETUP
    01187 #line 145 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01188 {
    01189         YY_PRINT
    01190         yyextra->invokeHelp = true;
    01191
    01192
    01193 }
    01194         YY_BREAK
    01195 case 6:
    01196 YY_RULE_SETUP
    01197 #line 158 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01198 {
    01199         YY_PRINT
    01200         yyextra->writeVersion = true;
    01201
    01202 }
    01203         YY_BREAK
    01204 case 7:
    01205 YY_RULE_SETUP
    01206 #line 164 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01207 {
    01208         YY_PRINT
    01209         yyextra->writeVersion = true;
    01210
    01211
    01212 }
    01213         YY_BREAK
    01214 case 8:
    01215 YY_RULE_SETUP
    01216 #line 172 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01217 {
    01218    YY_PRINT
    01219    yyextra->quit = true;
    01220
    01221 }
    01222         YY_BREAK
    01223 case 9:
    01224 /* rule 9 can match eol */
    01225 YY_RULE_SETUP
    01226 #line 179 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01227 {
    01228         //if(yyextra->osilFile == ""){
    01229                 YY_PRINT
    01230                 //char *ch = strdup(yytext);
    01231                 char *ch = yytext;
    01232                 // move past -osil
    01233                 ch+=5;
    01234                 for(; isspace(*ch); ch++);
    01235                 std::string str(  ch);
    01236                 yyextra->osilFile = str;
    01237         //}
    01238 }
    01239         YY_BREAK
    01240 case 10:
    01241 /* rule 10 can match eol */
    01242 YY_RULE_SETUP
    01243 #line 195 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01244 {
    01245         // if(yyextra->osilFile == ""){
    01246                  YY_PRINT
    01247                  //char *ch = strdup(yytext);
    01248                  char *ch = yytext;
    01249                  // move past osil
    01250                  ch+=4;
    01251                  for(; isspace(*ch); ch++);
    01252                  std::string str(  ch);
    01253                  yyextra->osilFile = str;
    01254         // }
    01255  }
    01256         YY_BREAK
    01257 case 11:
    01258 /* rule 11 can match eol */
    01259 YY_RULE_SETUP
    01260 #line 209 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01261 {
    01262         // if(yyextra->osilFile == ""){
    01263                  YY_PRINT
    01264                  //char *ch = strdup(yytext);
    01265                  char *ch = yytext;
    01266                  // move past osil
    01267                  ch+=4;
    01268                  for(; isspace(*ch); ch++);
    01269                  std::string str(  ch);
    01270                  yyextra->osilFile = str;
    01271         // }
    01272  }
    01273         YY_BREAK
    01274 case 12:
    01275 /* rule 12 can match eol */
    01276 YY_RULE_SETUP
    01277 #line 222 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01278 {
    01279         //if(yyextra->osrlFile == ""){
    01280                 YY_PRINT
    01281                 //char *ch = strdup(yytext);
    01282                 char *ch = yytext;
    01283                 // move past -osrl
    01284                 ch+=5;
    01285                 for(; isspace(*ch); ch++);
    01286                 std::string str(  ch);
    01287                 yyextra->osrlFile = str;
    01288         //}
    01289 }
    01290         YY_BREAK
    01291 case 13:
    01292 /* rule 13 can match eol */
    01293 YY_RULE_SETUP
    01294 #line 235 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01295 {
    01296          //if(yyextra->osrlFile == ""){
    01297                  YY_PRINT
    01298                  //char *ch = strdup(yytext);
    01299                  char *ch = yytext;
    01300                  // move past -osrl
    01301                  ch+=4;
    01302                  for(; isspace(*ch); ch++);
    01303                  std::string str(  ch);
    01304                  yyextra->osrlFile = str;
    01305          //}
    01306  }
    01307         YY_BREAK
    01308 case 14:
    01309 /* rule 14 can match eol */
    01310 YY_RULE_SETUP
    01311 #line 249 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01312 {
    01313         // if(yyextra->osrlFile == ""){
    01314                  YY_PRINT
    01315                  //char *ch = strdup(yytext);
    01316                  char *ch = yytext;
    01317                  // move past -osrl
    01318                  ch+=4;
    01319                  for(; isspace(*ch); ch++);
    01320                  std::string str(  ch);
    01321                  yyextra->osrlFile = str;
    01322         // }
    01323  }
    01324         YY_BREAK
    01325 case 15:
    01326 /* rule 15 can match eol */
    01327 YY_RULE_SETUP
    01328 #line 264 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01329 {
    01330         //if(yyextra->insListFile == ""){
    01331                 YY_PRINT
    01332                 //char *ch = strdup(yytext);
    01333                 char *ch = yytext;
    01334                 // move past -insList
    01335                 ch+=8;
    01336                 for(; isspace(*ch); ch++);
    01337                 std::string str(  ch);
    01338                 yyextra->insListFile = str;
    01339         //}
    01340 }
    01341         YY_BREAK
    01342 case 16:
    01343 /* rule 16 can match eol */
    01344 YY_RULE_SETUP
    01345 #line 279 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01346 {
    01347          //if(yyextra->insListFile == ""){
    01348                  YY_PRINT
    01349                  //char *ch = strdup(yytext);
    01350                  char *ch = yytext;
    01351                  // move past -insList
    01352                  ch+=7;
    01353                  for(; isspace(*ch); ch++);
    01354                  std::string str(  ch);
    01355                  yyextra->insListFile = str;
    01356         // }
    01357  }
    01358         YY_BREAK
    01359 case 17:
    01360 /* rule 17 can match eol */
    01361 YY_RULE_SETUP
    01362 #line 293 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01363 {
    01364         // if(yyextra->insListFile == ""){
    01365                  YY_PRINT
    01366                  //char *ch = strdup(yytext);
    01367                  char *ch = yytext;
    01368                  // move past -insList
    01369                  ch+=7;
    01370                  for(; isspace(*ch); ch++);
    01371                  std::string str(  ch);
    01372                  yyextra->insListFile = str;
    01373         // }
    01374  }
    01375         YY_BREAK
    01376 case 18:
    01377 /* rule 18 can match eol */
    01378 YY_RULE_SETUP
    01379 #line 307 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01380 {
    01381         //if(yyextra->osolFile == ""){
    01382                 YY_PRINT
    01383                 //char *ch = strdup(yytext);
    01384                 char *ch = yytext;
    01385                 // move past -osol
    01386                 ch+=5;
    01387                 for(; isspace(*ch); ch++);
    01388                 std::string str(  ch);
    01389                 yyextra->osolFile = str;
    01390         //}
    01391 }
    01392         YY_BREAK
    01393 case 19:
    01394 /* rule 19 can match eol */
    01395 YY_RULE_SETUP
    01396 #line 322 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01397 {
    01398         //if(yyextra->osolFile == ""){
    01399                  YY_PRINT
    01400                  //char *ch = strdup(yytext);
    01401                  char *ch = yytext;
    01402                  // move past -osol
    01403                  ch+=4;
    01404                  for(; isspace(*ch); ch++);
    01405                  std::string str(  ch);
    01406                  yyextra->osolFile = str;
    01407         //}
    01408 }
    01409         YY_BREAK
    01410 case 20:
    01411 /* rule 20 can match eol */
    01412 YY_RULE_SETUP
    01413 #line 336 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01414 {
    01415          //if(yyextra->osolFile == ""){
    01416                  YY_PRINT
    01417                  //char *ch = strdup(yytext);
    01418                  char *ch = yytext;
    01419                  // move past -osol
    01420                  ch+=4;
    01421                  for(; isspace(*ch); ch++);
    01422                  std::string str(  ch);
    01423                  yyextra->osolFile = str;
    01424         // }
    01425  }
    01426         YY_BREAK
    01427 case 21:
    01428 /* rule 21 can match eol */
    01429 YY_RULE_SETUP
    01430 #line 351 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01431 {
    01432         //if(yyextra->osplInputFile == ""){
    01433                 YY_PRINT
    01434                 //char *ch = strdup(yytext);
    01435                 char *ch = yytext;
    01436                 // move past -osplInput
    01437                 ch+=10;
    01438                 for(; isspace(*ch); ch++);
    01439                 std::string str(  ch);
    01440                 yyextra->osplInputFile = str;
    01441         //}
    01442 }
    01443         YY_BREAK
    01444 case 22:
    01445 /* rule 22 can match eol */
    01446 YY_RULE_SETUP
    01447 #line 365 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01448 {
    01449                         // if(yyextra->osplInputFile == ""){
    01450                          YY_PRINT
    01451                          //char *ch = strdup(yytext);
    01452                          char *ch = yytext;
    01453                          // move past -osplInput
    01454                          ch+=9;
    01455                          for(; isspace(*ch); ch++);
    01456                          std::string str(  ch);
    01457                          yyextra->osplInputFile = str;
    01458                         // }
    01459                          }
    01460         YY_BREAK
    01461 case 23:
    01462 /* rule 23 can match eol */
    01463 YY_RULE_SETUP
    01464 #line 378 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01465 {
    01466                         // if(yyextra->osplInputFile == ""){
    01467                          YY_PRINT
    01468                          //char *ch = strdup(yytext);
    01469                          char *ch = yytext;
    01470                          // move past -osplInput
    01471                          ch+=9;
    01472                          for(; isspace(*ch); ch++);
    01473                          std::string str(  ch);
    01474                          yyextra->osplInputFile = str;
    01475                         // }
    01476                          }
    01477         YY_BREAK
    01478 case 24:
    01479 /* rule 24 can match eol */
    01480 YY_RULE_SETUP
    01481 #line 391 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01482 {
    01483         //if(yyextra->osplOutputFile == ""){
    01484                 YY_PRINT
    01485                 //char *ch = strdup(yytext);
    01486                 char *ch = yytext;
    01487                 // move past -osplInput
    01488                 ch+=11;
    01489                 for(; isspace(*ch); ch++);
    01490                 std::string str(  ch);
    01491                 yyextra->osplOutputFile = str;
    01492         //}
    01493 }
    01494         YY_BREAK
    01495 case 25:
    01496 /* rule 25 can match eol */
    01497 YY_RULE_SETUP
    01498 #line 404 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01499 {
    01500         //if(yyextra->serviceMethod == ""){
    01501                 YY_PRINT
    01502                 //char *ch = strdup(yytext);
    01503                 char *ch = yytext;
    01504                 // move past -serviceMethod
    01505                 ch+=14;
    01506                 for(; isspace(*ch); ch++);
    01507                 std::string str(  ch);
    01508                 yyextra->serviceMethod = str;
    01509         //}
    01510 }
    01511         YY_BREAK
    01512 case 26:
    01513 /* rule 26 can match eol */
    01514 YY_RULE_SETUP
    01515 #line 417 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01516 {
    01517                         // if(yyextra->serviceMethod == ""){
    01518                          YY_PRINT
    01519                          //char *ch = strdup(yytext);
    01520                          char *ch = yytext;
    01521                          // move past -serviceMethod
    01522                          ch+=13;
    01523                          for(; isspace(*ch); ch++);
    01524                          std::string str(  ch);
    01525                          yyextra->serviceMethod = str;
    01526                         // }
    01527                          }
    01528         YY_BREAK
    01529 case 27:
    01530 /* rule 27 can match eol */
    01531 YY_RULE_SETUP
    01532 #line 430 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01533 {
    01534                         // if(yyextra->serviceMethod == ""){
    01535                          YY_PRINT
    01536                          //char *ch = strdup(yytext);
    01537                          char *ch = yytext;
    01538                          // move past -serviceMethod
    01539                          ch+=13;
    01540                          for(; isspace(*ch); ch++);
    01541                          std::string str(  ch);
    01542                          yyextra->serviceMethod = str;
    01543                         // }
    01544                          }
    01545         YY_BREAK
    01546 case 28:
    01547 /* rule 28 can match eol */
    01548 YY_RULE_SETUP
    01549 #line 443 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01550 {
    01551         //if(yyextra->serviceLocation == ""){
    01552                 YY_PRINT
    01553                 //yyextra->serviceLocation = strdup(yytext);
    01554                 yyextra->serviceLocation =  yytext;
    01555                 //char *ch = strdup(yytext);
    01556                 char *ch = yytext;
    01557                 // move past -serviceLocation
    01558                 ch+=16;
    01559                 for(; isspace(*ch); ch++);
    01560                 std::string str(  ch);
    01561                 yyextra->serviceLocation = str;
    01562         //}
    01563 }
    01564         YY_BREAK
    01565 case 29:
    01566 /* rule 29 can match eol */
    01567 YY_RULE_SETUP
    01568 #line 460 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01569 {
    01570                         // if(yyextra->serviceLocation == ""){
    01571                          YY_PRINT
    01572                          //yyextra->serviceLocation = strdup(yytext);
    01573                          yyextra->serviceLocation =  yytext;
    01574                          //char *ch = strdup(yytext);
    01575                          char *ch = yytext;
    01576                          // move past -serviceLocation
    01577                          ch+=15;
    01578                          for(; isspace(*ch); ch++);
    01579                          std::string str(  ch);
    01580                          yyextra->serviceLocation = str;
    01581                         // }
    01582                          }
    01583         YY_BREAK
    01584 case 30:
    01585 /* rule 30 can match eol */
    01586 YY_RULE_SETUP
    01587 #line 476 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01588 {
    01589                         // if(yyextra->serviceLocation == ""){
    01590                          YY_PRINT
    01591                          //yyextra->serviceLocation = strdup(yytext);
    01592                          yyextra->serviceLocation =  yytext;
    01593                          //char *ch = strdup(yytext);
    01594                          char *ch = yytext;
    01595                          // move past -serviceLocation
    01596                          ch+=15;
    01597                          for(; isspace(*ch); ch++);
    01598                          std::string str(  ch);
    01599                          yyextra->serviceLocation = str;
    01600                         // }
    01601                          }
    01602         YY_BREAK
    01603 case 31:
    01604 /* rule 31 can match eol */
    01605 YY_RULE_SETUP
    01606 #line 492 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01607 {
    01608         //if(yyextra->mpsFile == ""){
    01609                 YY_PRINT
    01610                 //char *ch = strdup(yytext);
    01611                 char *ch = yytext;
    01612                 // move past -mps
    01613                 ch+=4;
    01614                 for(; isspace(*ch); ch++);
    01615                 std::string str(  ch);
    01616                 yyextra->mpsFile = str;
    01617         //}
    01618 }
    01619         YY_BREAK
    01620 case 32:
    01621 /* rule 32 can match eol */
    01622 YY_RULE_SETUP
    01623 #line 508 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01624 {
    01625                         // if(yyextra->mpsFile == ""){
    01626                          YY_PRINT
    01627                          //char *ch = strdup(yytext);
    01628                          char *ch = yytext;
    01629                          // move past -mps
    01630                          ch+=3;
    01631                          for(; isspace(*ch); ch++);
    01632                          std::string str(  ch);
    01633                          yyextra->mpsFile = str;
    01634                         // }
    01635                          }
    01636         YY_BREAK
    01637 case 33:
    01638 /* rule 33 can match eol */
    01639 YY_RULE_SETUP
    01640 #line 523 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01641 {
    01642                         // if(yyextra->mpsFile == ""){
    01643                          YY_PRINT
    01644                          //char *ch = strdup(yytext);
    01645                          char *ch = yytext;
    01646                          // move past -mps
    01647                          ch+=3;
    01648                          for(; isspace(*ch); ch++);
    01649                          std::string str(  ch);
    01650                          yyextra->mpsFile = str;
    01651                         // }
    01652                          }
    01653         YY_BREAK
    01654 case 34:
    01655 /* rule 34 can match eol */
    01656 YY_RULE_SETUP
    01657 #line 536 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01658 {
    01659         //if(yyextra->nlFile == ""){
    01660                 YY_PRINT
    01661                 //char *ch = strdup(yytext);
    01662                 char *ch = yytext;
    01663                 // move past -nl
    01664                 ch+=3;
    01665                 for(; isspace(*ch); ch++);
    01666                 std::string str(  ch);
    01667                 yyextra->nlFile = str;
    01668         //}
    01669 }
    01670         YY_BREAK
    01671 case 35:
    01672 /* rule 35 can match eol */
    01673 YY_RULE_SETUP
    01674 #line 552 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01675 {
    01676                         // if(yyextra->nlFile == ""){
    01677                          YY_PRINT
    01678                          //char *ch = strdup(yytext);
    01679                          char *ch = yytext;
    01680                          // move past -nl
    01681                          ch+=2;
    01682                          for(; isspace(*ch); ch++);
    01683                          std::string str(  ch);
    01684                          yyextra->nlFile = str;
    01685                         // }
    01686                          }
    01687         YY_BREAK
    01688 case 36:
    01689 /* rule 36 can match eol */
    01690 YY_RULE_SETUP
    01691 #line 566 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01692 {
    01693                         // if(yyextra->nlFile == ""){
    01694                          YY_PRINT
    01695                          //char *ch = strdup(yytext);
    01696                          char *ch = yytext;
    01697                          // move past -nl
    01698                          ch+=2;
    01699                          for(; isspace(*ch); ch++);
    01700                          std::string str(  ch);
    01701                          yyextra->nlFile = str;
    01702                         // }
    01703                          }
    01704         YY_BREAK
    01705 case 37:
    01706 /* rule 37 can match eol */
    01707 YY_RULE_SETUP
    01708 #line 582 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01709 {
    01710         //if(yyextra->gamsControlFile == ""){
    01711                 YY_PRINT
    01712                 //char *ch = strdup(yytext);
    01713                 char *ch = yytext;
    01714                 // move past -dat
    01715                 ch+=4;
    01716                 for(; isspace(*ch); ch++);
    01717                 std::string str(  ch);
    01718                 yyextra->gamsControlFile = str;
    01719         //}
    01720 }
    01721         YY_BREAK
    01722 case 38:
    01723 /* rule 38 can match eol */
    01724 YY_RULE_SETUP
    01725 #line 597 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01726 {
    01727                         // if(yyextra->gamsControlFile == ""){
    01728                          YY_PRINT
    01729                          //char *ch = strdup(yytext);
    01730                          char *ch = yytext;
    01731                          // move past -dat
    01732                          ch+=3;
    01733                          for(; isspace(*ch); ch++);
    01734                          std::string str(  ch);
    01735                          yyextra->gamsControlFile = str;
    01736                         // }
    01737                          }
    01738         YY_BREAK
    01739 case 39:
    01740 /* rule 39 can match eol */
    01741 YY_RULE_SETUP
    01742 #line 610 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01743 {
    01744                          //if(yyextra->gamsControlFile == ""){
    01745                          YY_PRINT
    01746                          //char *ch = strdup(yytext);
    01747                          char *ch = yytext;
    01748                          // move past -dat
    01749                          ch+=3;
    01750                          for(; isspace(*ch); ch++);
    01751                          std::string str(  ch);
    01752                          yyextra->gamsControlFile = str;
    01753                         // }
    01754                          }
    01755         YY_BREAK
    01756 case 40:
    01757 /* rule 40 can match eol */
    01758 YY_RULE_SETUP
    01759 #line 623 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01760 {
    01761         //if(yyextra->solverName == ""){
    01762                 YY_PRINT
    01763                 //char *ch = strdup(yytext);
    01764                 char *ch = yytext;
    01765                 // move past -solver
    01766                 ch+=7;
    01767                 for(; isspace(*ch); ch++);
    01768                 std::string str(  ch);
    01769                 yyextra->solverName = str;
    01770         //}
    01771 }
    01772         YY_BREAK
    01773 case 41:
    01774 /* rule 41 can match eol */
    01775 YY_RULE_SETUP
    01776 #line 637 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01777 {
    01778                          //if(yyextra->solverName == ""){
    01779                          YY_PRINT
    01780                          //char *ch = strdup(yytext);
    01781                          char *ch = yytext;
    01782                          // move past -solver
    01783                          ch+=6;
    01784                          for(; isspace(*ch); ch++);
    01785                          std::string str(  ch);
    01786                          yyextra->solverName = str;
    01787                         // }
    01788                          }
    01789         YY_BREAK
    01790 case 42:
    01791 /* rule 42 can match eol */
    01792 YY_RULE_SETUP
    01793 #line 650 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01794 {
    01795                         // if(yyextra->solverName == ""){
    01796                          YY_PRINT
    01797                          //char *ch = strdup(yytext);
    01798                          char *ch = yytext;
    01799                          // move past -solver
    01800                          ch+=6;
    01801                          for(; isspace(*ch); ch++);
    01802                          std::string str(  ch);
    01803                          yyextra->solverName = str;
    01804                         // }
    01805                          }
    01806         YY_BREAK
    01807 case 43:
    01808 /* rule 43 can match eol */
    01809 YY_RULE_SETUP
    01810 #line 663 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01811 {
    01812         //if(yyextra->browser == ""){
    01813                 YY_PRINT
    01814                 //char *ch = strdup(yytext);
    01815                 char *ch = yytext;
    01816                 // move past -browser
    01817                 ch+=8;
    01818                 for(; isspace(*ch); ch++);
    01819                 std::string str(  ch);
    01820                 yyextra->browser = str;
    01821         //}
    01822 }
    01823         YY_BREAK
    01824 case 44:
    01825 /* rule 44 can match eol */
    01826 YY_RULE_SETUP
    01827 #line 677 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01828 {
    01829                         // if(yyextra->browser == ""){
    01830                          YY_PRINT
    01831                          //char *ch = strdup(yytext);
    01832                          char *ch = yytext;
    01833                          // move past -browser
    01834                          ch+=7;
    01835                          for(; isspace(*ch); ch++);
    01836                          std::string str(  ch);
    01837                          yyextra->browser = str;
    01838                         // }
    01839                          }
    01840         YY_BREAK
    01841 case 45:
    01842 /* rule 45 can match eol */
    01843 YY_RULE_SETUP
    01844 #line 691 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01845 {
    01846                         // if(yyextra->browser == ""){
    01847                          YY_PRINT
    01848                          //char *ch = strdup(yytext);
    01849                          char *ch = yytext;
    01850                          // move past -browser
    01851                          ch+=7;
    01852                          for(; isspace(*ch); ch++);
    01853                          std::string str(  ch);
    01854                          yyextra->browser = str;
    01855                         // }
    01856                          }
    01857         YY_BREAK
    01858 case 46:
    01859 YY_RULE_SETUP
    01860 #line 704 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01861 {
    01862         std::string error;
    01863         std::ostringstream outStr;
    01864         outStr << "encountered a spurious character in the lexer" << endl;
    01865         outStr << "The first character is: ";
    01866         outStr <<  yytext;
    01867         outStr << endl;
    01868         //outStr << "See line number: " << yylineno << endl;
    01869         error = outStr.str();
    01870         throw ErrorClass( error);
    01871 }
    01872         YY_BREAK
    01873 case 47:
    01874 YY_RULE_SETUP
    01875 #line 715 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    01876 ECHO;
    01877         YY_BREAK
    01878 #line 1879 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
    01879 case YY_STATE_EOF(INITIAL):
    01880         yyterminate();
    01881
    01882         case YY_END_OF_BUFFER:
    01883                 {
    01884                 /* Amount of text matched not including the EOB char. */
    01885                 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
    01886
    01887                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
    01888                 *yy_cp = yyg->yy_hold_char;
    01889                 YY_RESTORE_YY_MORE_OFFSET
    01890
    01891                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
    01892                         {
    01893                         /* We're scanning a new file or input source.  It's
    01894                          * possible that this happened because the user
    01895                          * just pointed yyin at a new source and called
    01896                          * ossslex().  If so, then we have to assure
    01897                          * consistency between YY_CURRENT_BUFFER and our
    01898                          * globals.  Here is the right place to do so, because
    01899                          * this is the first action (other than possibly a
    01900                          * back-up) that will match for the new input source.
    01901                          */
    01902                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    01903                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
    01904                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
    01905                         }
    01906
    01907                 /* Note that here we test for yy_c_buf_p "<=" to the position
    01908                  * of the first EOB in the buffer, since yy_c_buf_p will
    01909                  * already have been incremented past the NUL character
    01910                  * (since all states make transitions on EOB to the
    01911                  * end-of-buffer state).  Contrast this with the test
    01912                  * in input().
    01913                  */
    01914                 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
    01915                         { /* This was really a NUL. */
    01916                         yy_state_type yy_next_state;
    01917
    01918                         yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
    01919
    01920                         yy_current_state = yy_get_previous_state( yyscanner );
    01921
    01922                         /* Okay, we're now positioned to make the NUL
    01923                          * transition.  We couldn't have
    01924                          * yy_get_previous_state() go ahead and do it
    01925                          * for us because it doesn't know how to deal
    01926                          * with the possibility of jamming (and we don't
    01927                          * want to build jamming into it because then it
    01928                          * will run more slowly).
    01929                          */
    01930
    01931                         yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
    01932
    01933                         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
    01934
    01935                         if ( yy_next_state )
    01936                                 {
    01937                                 /* Consume the NUL. */
    01938                                 yy_cp = ++yyg->yy_c_buf_p;
    01939                                 yy_current_state = yy_next_state;
    01940                                 goto yy_match;
    01941                                 }
    01942
    01943                         else
    01944                                 {
    01945                                 yy_cp = yyg->yy_c_buf_p;
    01946                                 goto yy_find_action;
    01947                                 }
    01948                         }
    01949
    01950                 else switch ( yy_get_next_buffer( yyscanner ) )
    01951                         {
    01952                         case EOB_ACT_END_OF_FILE:
    01953                                 {
    01954                                 yyg->yy_did_buffer_switch_on_eof = 0;
    01955
    01956                                 if ( ossswrap(yyscanner ) )
    01957                                         {
    01958                                         /* Note: because we've taken care in
    01959                                          * yy_get_next_buffer() to have set up
    01960                                          * yytext, we can now set up
    01961                                          * yy_c_buf_p so that if some total
    01962                                          * hoser (like flex itself) wants to
    01963                                          * call the scanner after we return the
    01964                                          * YY_NULL, it'll still work - another
    01965                                          * YY_NULL will get returned.
    01966                                          */
    01967                                         yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
    01968
    01969                                         yy_act = YY_STATE_EOF(YY_START);
    01970                                         goto do_action;
    01971                                         }
    01972
    01973                                 else
    01974                                         {
    01975                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
    01976                                                 YY_NEW_FILE;
    01977                                         }
    01978                                 break;
    01979                                 }
    01980
    01981                         case EOB_ACT_CONTINUE_SCAN:
    01982                                 yyg->yy_c_buf_p =
    01983                                         yyg->yytext_ptr + yy_amount_of_matched_text;
    01984
    01985                                 yy_current_state = yy_get_previous_state( yyscanner );
    01986
    01987                                 yy_cp = yyg->yy_c_buf_p;
    01988                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
    01989                                 goto yy_match;
    01990
    01991                         case EOB_ACT_LAST_MATCH:
    01992                                 yyg->yy_c_buf_p =
    01993                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
    01994
    01995                                 yy_current_state = yy_get_previous_state( yyscanner );
    01996
    01997                                 yy_cp = yyg->yy_c_buf_p;
    01998                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
    01999                                 goto yy_find_action;
    02000                         }
    02001                 break;
    02002                 }
    02003
    02004         default:
    02005                 YY_FATAL_ERROR(
    02006                         "fatal flex scanner internal error--no action found" );
    02007         } /* end of action switch */
    02008                 } /* end of scanning one token */
    02009 } /* end of ossslex */
    02010
    02011 /* yy_get_next_buffer - try to read in a new buffer
    02012  *
    02013  * Returns a code representing an action:
    02014  *      EOB_ACT_LAST_MATCH -
    02015  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
    02016  *      EOB_ACT_END_OF_FILE - end of file
    02017  */
    02018 static int yy_get_next_buffer (yyscan_t yyscanner)
    02019 {
    02020     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02021         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    02022         register char *source = yyg->yytext_ptr;
    02023         register int number_to_move, i;
    02024         int ret_val;
    02025
    02026         if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
    02027                 YY_FATAL_ERROR(
    02028                 "fatal flex scanner internal error--end of buffer missed" );
    02029
    02030         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
    02031                 { /* Don't try to fill the buffer, so this is an EOF. */
    02032                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
    02033                         {
    02034                         /* We matched a single character, the EOB, so
    02035                          * treat this as a final EOF.
    02036                          */
    02037                         return EOB_ACT_END_OF_FILE;
    02038                         }
    02039
    02040                 else
    02041                         {
    02042                         /* We matched some text prior to the EOB, first
    02043                          * process it.
    02044                          */
    02045                         return EOB_ACT_LAST_MATCH;
    02046                         }
    02047                 }
    02048
    02049         /* Try to read more data. */
    02050
    02051         /* First move last chars to start of buffer. */
    02052         number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
    02053
    02054         for ( i = 0; i < number_to_move; ++i )
    02055                 *(dest++) = *(source++);
    02056
    02057         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    02058                 /* don't do the read, it's not guaranteed to return an EOF,
    02059                  * just force an EOF
    02060                  */
    02061                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
    02062
    02063         else
    02064                 {
    02065                         int num_to_read =
    02066                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
    02067
    02068                 while ( num_to_read <= 0 )
    02069                         { /* Not enough room in the buffer - grow it. */
    02070
    02071                         /* just a shorter name for the current buffer */
    02072                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
    02073
    02074                         int yy_c_buf_p_offset =
    02075                                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
    02076
    02077                         if ( b->yy_is_our_buffer )
    02078                                 {
    02079                                 int new_size = b->yy_buf_size * 2;
    02080
    02081                                 if ( new_size <= 0 )
    02082                                         b->yy_buf_size += b->yy_buf_size / 8;
    02083                                 else
    02084                                         b->yy_buf_size *= 2;
    02085
    02086                                 b->yy_ch_buf = (char *)
    02087                                         /* Include room in for 2 EOB chars. */
    02088                                         osssrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
    02089                                 }
    02090                         else
    02091                                 /* Can't grow it, we don't own it. */
    02092                                 b->yy_ch_buf = 0;
    02093
    02094                         if ( ! b->yy_ch_buf )
    02095                                 YY_FATAL_ERROR(
    02096                                 "fatal error - scanner input buffer overflow" );
    02097
    02098                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
    02099
    02100                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
    02101                                                 number_to_move - 1;
    02102
    02103                         }
    02104
    02105                 if ( num_to_read > YY_READ_BUF_SIZE )
    02106                         num_to_read = YY_READ_BUF_SIZE;
    02107
    02108                 /* Read in more data. */
    02109                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
    02110                         yyg->yy_n_chars, (size_t) num_to_read );
    02111
    02112                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
    02113                 }
    02114
    02115         if ( yyg->yy_n_chars == 0 )
    02116                 {
    02117                 if ( number_to_move == YY_MORE_ADJ )
    02118                         {
    02119                         ret_val = EOB_ACT_END_OF_FILE;
    02120                         osssrestart(yyin  ,yyscanner);
    02121                         }
    02122
    02123                 else
    02124                         {
    02125                         ret_val = EOB_ACT_LAST_MATCH;
    02126                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
    02127                                 YY_BUFFER_EOF_PENDING;
    02128                         }
    02129                 }
    02130
    02131         else
    02132                 ret_val = EOB_ACT_CONTINUE_SCAN;
    02133
    02134         if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
    02135                 /* Extend the array by 50%, plus the number we really need. */
    02136                 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
    02137                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) osssrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
    02138                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
    02139                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
    02140         }
    02141
    02142         yyg->yy_n_chars += number_to_move;
    02143         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
    02144         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
    02145
    02146         yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
    02147
    02148         return ret_val;
    02149 }
    02150
    02151 /* yy_get_previous_state - get the state just before the EOB char was reached */
    02152
    02153     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
    02154 {
    02155         register yy_state_type yy_current_state;
    02156         register char *yy_cp;
    02157     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02158
    02159         yy_current_state = yyg->yy_start;
    02160
    02161         for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
    02162                 {
    02163                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
    02164                 if ( yy_accept[yy_current_state] )
    02165                         {
    02166                         yyg->yy_last_accepting_state = yy_current_state;
    02167                         yyg->yy_last_accepting_cpos = yy_cp;
    02168                         }
    02169                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    02170                         {
    02171                         yy_current_state = (int) yy_def[yy_current_state];
    02172                         if ( yy_current_state >= 347 )
    02173                                 yy_c = yy_meta[(unsigned int) yy_c];
    02174                         }
    02175                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    02176                 }
    02177
    02178         return yy_current_state;
    02179 }
    02180
    02181 /* yy_try_NUL_trans - try to make a transition on the NUL character
    02182  *
    02183  * synopsis
    02184  *      next_state = yy_try_NUL_trans( current_state );
    02185  */
    02186     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
    02187 {
    02188         register int yy_is_jam;
    02189     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
    02190         register char *yy_cp = yyg->yy_c_buf_p;
    02191
    02192         register YY_CHAR yy_c = 1;
    02193         if ( yy_accept[yy_current_state] )
    02194                 {
    02195                 yyg->yy_last_accepting_state = yy_current_state;
    02196                 yyg->yy_last_accepting_cpos = yy_cp;
    02197                 }
    02198         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    02199                 {
    02200                 yy_current_state = (int) yy_def[yy_current_state];
    02201                 if ( yy_current_state >= 347 )
    02202                         yy_c = yy_meta[(unsigned int) yy_c];
    02203                 }
    02204         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    02205         yy_is_jam = (yy_current_state == 346);
    02206
    02207         return yy_is_jam ? 0 : yy_current_state;
    02208 }
    02209
    02210 #ifndef YY_NO_INPUT
    02211 #ifdef __cplusplus
    02212     static int yyinput (yyscan_t yyscanner)
    02213 #else
    02214     static int input  (yyscan_t yyscanner)
    02215 #endif
    02216
    02217 {
    02218         int c;
    02219     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02220
    02221         *yyg->yy_c_buf_p = yyg->yy_hold_char;
    02222
    02223         if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
    02224                 {
    02225                 /* yy_c_buf_p now points to the character we want to return.
    02226                  * If this occurs *before* the EOB characters, then it's a
    02227                  * valid NUL; if not, then we've hit the end of the buffer.
    02228                  */
    02229                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
    02230                         /* This was really a NUL. */
    02231                         *yyg->yy_c_buf_p = '\0';
    02232
    02233                 else
    02234                         { /* need more input */
    02235                         int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
    02236                         ++yyg->yy_c_buf_p;
    02237
    02238                         switch ( yy_get_next_buffer( yyscanner ) )
    02239                                 {
    02240                                 case EOB_ACT_LAST_MATCH:
    02241                                         /* This happens because yy_g_n_b()
    02242                                          * sees that we've accumulated a
    02243                                          * token and flags that we need to
    02244                                          * try matching the token before
    02245                                          * proceeding.  But for input(),
    02246                                          * there's no matching to consider.
    02247                                          * So convert the EOB_ACT_LAST_MATCH
    02248                                          * to EOB_ACT_END_OF_FILE.
    02249                                          */
    02250
    02251                                         /* Reset buffer status. */
    02252                                         osssrestart(yyin ,yyscanner);
    02253
    02254                                         /*FALLTHROUGH*/
    02255
    02256                                 case EOB_ACT_END_OF_FILE:
    02257                                         {
    02258                                         if ( ossswrap(yyscanner ) )
    02259                                                 return EOF;
    02260
    02261                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
    02262                                                 YY_NEW_FILE;
    02263 #ifdef __cplusplus
    02264                                         return yyinput(yyscanner);
    02265 #else
    02266                                         return input(yyscanner);
    02267 #endif
    02268                                         }
    02269
    02270                                 case EOB_ACT_CONTINUE_SCAN:
    02271                                         yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
    02272                                         break;
    02273                                 }
    02274                         }
    02275                 }
    02276
    02277         c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
    02278         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
    02279         yyg->yy_hold_char = *++yyg->yy_c_buf_p;
    02280
    02281         if ( c == '\n' )
    02282
    02283     do{ yylineno++;
    02284         yycolumn=0;
    02285     }while(0)
    02286 ;
    02287
    02288         return c;
    02289 }
    02290 #endif  /* ifndef YY_NO_INPUT */
    02291
    02297     void osssrestart  (FILE * input_file , yyscan_t yyscanner)
    02298 {
    02299     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02300
    02301         if ( ! YY_CURRENT_BUFFER ){
    02302         osssensure_buffer_stack (yyscanner);
    02303                 YY_CURRENT_BUFFER_LVALUE =
    02304             osss_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
    02305         }
    02306
    02307         osss_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
    02308         osss_load_buffer_state(yyscanner );
    02309 }
    02310
    02315     void osss_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
    02316 {
    02317     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02318
    02319         /* TODO. We should be able to replace this entire function body
    02320          * with
    02321          *              ossspop_buffer_state();
    02322          *              ossspush_buffer_state(new_buffer);
    02323      */
    02324         osssensure_buffer_stack (yyscanner);
    02325         if ( YY_CURRENT_BUFFER == new_buffer )
    02326                 return;
    02327
    02328         if ( YY_CURRENT_BUFFER )
    02329                 {
    02330                 /* Flush out information for old buffer. */
    02331                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
    02332                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
    02333                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
    02334                 }
    02335
    02336         YY_CURRENT_BUFFER_LVALUE = new_buffer;
    02337         osss_load_buffer_state(yyscanner );
    02338
    02339         /* We don't actually know whether we did this switch during
    02340          * EOF (ossswrap()) processing, but the only time this flag
    02341          * is looked at is after ossswrap() is called, so it's safe
    02342          * to go ahead and always set it.
    02343          */
    02344         yyg->yy_did_buffer_switch_on_eof = 1;
    02345 }
    02346
    02347 static void osss_load_buffer_state  (yyscan_t yyscanner)
    02348 {
    02349     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02350         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    02351         yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
    02352         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
    02353         yyg->yy_hold_char = *yyg->yy_c_buf_p;
    02354 }
    02355
    02362     YY_BUFFER_STATE osss_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
    02363 {
    02364         YY_BUFFER_STATE b;
    02365
    02366         b = (YY_BUFFER_STATE) osssalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
    02367         if ( ! b )
    02368                 YY_FATAL_ERROR( "out of dynamic memory in osss_create_buffer()" );
    02369
    02370         b->yy_buf_size = size;
    02371
    02372         /* yy_ch_buf has to be 2 characters longer than the size given because
    02373          * we need to put in 2 end-of-buffer characters.
    02374          */
    02375         b->yy_ch_buf = (char *) osssalloc(b->yy_buf_size + 2 ,yyscanner );
    02376         if ( ! b->yy_ch_buf )
    02377                 YY_FATAL_ERROR( "out of dynamic memory in osss_create_buffer()" );
    02378
    02379         b->yy_is_our_buffer = 1;
    02380
    02381         osss_init_buffer(b,file ,yyscanner);
    02382
    02383         return b;
    02384 }
    02385
    02390     void osss_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
    02391 {
    02392     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02393
    02394         if ( ! b )
    02395                 return;
    02396
    02397         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
    02398                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
    02399
    02400         if ( b->yy_is_our_buffer )
    02401                 osssfree((void *) b->yy_ch_buf ,yyscanner );
    02402
    02403         osssfree((void *) b ,yyscanner );
    02404 }
    02405
    02406 #ifndef __cplusplus
    02407 extern int isatty (int );
    02408 #endif /* __cplusplus */
    02409
    02410 /* Initializes or reinitializes a buffer.
    02411  * This function is sometimes called more than once on the same buffer,
    02412  * such as during a osssrestart() or at EOF.
    02413  */
    02414     static void osss_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
    02415
    02416 {
    02417         int oerrno = errno;
    02418     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02419
    02420         osss_flush_buffer(b ,yyscanner);
    02421
    02422         b->yy_input_file = file;
    02423         b->yy_fill_buffer = 1;
    02424
    02425     /* If b is the current buffer, then osss_init_buffer was _probably_
    02426      * called from osssrestart() or through yy_get_next_buffer.
    02427      * In that case, we don't want to reset the lineno or column.
    02428      */
    02429     if (b != YY_CURRENT_BUFFER){
    02430         b->yy_bs_lineno = 1;
    02431         b->yy_bs_column = 0;
    02432     }
    02433
    02434         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    02435
    02436         errno = oerrno;
    02437 }
    02438
    02443     void osss_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
    02444 {
    02445     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02446         if ( ! b )
    02447                 return;
    02448
    02449         b->yy_n_chars = 0;
    02450
    02451         /* We always need two end-of-buffer characters.  The first causes
    02452          * a transition to the end-of-buffer state.  The second causes
    02453          * a jam in that state.
    02454          */
    02455         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    02456         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
    02457
    02458         b->yy_buf_pos = &b->yy_ch_buf[0];
    02459
    02460         b->yy_at_bol = 1;
    02461         b->yy_buffer_status = YY_BUFFER_NEW;
    02462
    02463         if ( b == YY_CURRENT_BUFFER )
    02464                 osss_load_buffer_state(yyscanner );
    02465 }
    02466
    02473 void ossspush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
    02474 {
    02475     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02476         if (new_buffer == NULL)
    02477                 return;
    02478
    02479         osssensure_buffer_stack(yyscanner);
    02480
    02481         /* This block is copied from osss_switch_to_buffer. */
    02482         if ( YY_CURRENT_BUFFER )
    02483                 {
    02484                 /* Flush out information for old buffer. */
    02485                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
    02486                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
    02487                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
    02488                 }
    02489
    02490         /* Only push if top exists. Otherwise, replace top. */
    02491         if (YY_CURRENT_BUFFER)
    02492                 yyg->yy_buffer_stack_top++;
    02493         YY_CURRENT_BUFFER_LVALUE = new_buffer;
    02494
    02495         /* copied from osss_switch_to_buffer. */
    02496         osss_load_buffer_state(yyscanner );
    02497         yyg->yy_did_buffer_switch_on_eof = 1;
    02498 }
    02499
    02504 void ossspop_buffer_state (yyscan_t yyscanner)
    02505 {
    02506     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02507         if (!YY_CURRENT_BUFFER)
    02508                 return;
    02509
    02510         osss_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
    02511         YY_CURRENT_BUFFER_LVALUE = NULL;
    02512         if (yyg->yy_buffer_stack_top > 0)
    02513                 --yyg->yy_buffer_stack_top;
    02514
    02515         if (YY_CURRENT_BUFFER) {
    02516                 osss_load_buffer_state(yyscanner );
    02517                 yyg->yy_did_buffer_switch_on_eof = 1;
    02518         }
    02519 }
    02520
    02521 /* Allocates the stack if it does not exist.
    02522  *  Guarantees space for at least one push.
    02523  */
    02524 static void osssensure_buffer_stack (yyscan_t yyscanner)
    02525 {
    02526         int num_to_alloc;
    02527     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02528
    02529         if (!yyg->yy_buffer_stack) {
    02530
    02531                 /* First allocation is just for 2 elements, since we don't know if this
    02532                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
    02533                  * immediate realloc on the next call.
    02534          */
    02535                 num_to_alloc = 1;
    02536                 yyg->yy_buffer_stack = (struct yy_buffer_state**)osssalloc
    02537                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
    02538                                                                 , yyscanner);
    02539                 if ( ! yyg->yy_buffer_stack )
    02540                         YY_FATAL_ERROR( "out of dynamic memory in osssensure_buffer_stack()" );
    02541
    02542                 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
    02543
    02544                 yyg->yy_buffer_stack_max = num_to_alloc;
    02545                 yyg->yy_buffer_stack_top = 0;
    02546                 return;
    02547         }
    02548
    02549         if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
    02550
    02551                 /* Increase the buffer to prepare for a possible push. */
    02552                 int grow_size = 8 /* arbitrary grow size */;
    02553
    02554                 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
    02555                 yyg->yy_buffer_stack = (struct yy_buffer_state**)osssrealloc
    02556                                                                 (yyg->yy_buffer_stack,
    02557                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
    02558                                                                 , yyscanner);
    02559                 if ( ! yyg->yy_buffer_stack )
    02560                         YY_FATAL_ERROR( "out of dynamic memory in osssensure_buffer_stack()" );
    02561
    02562                 /* zero only the new slots.*/
    02563                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
    02564                 yyg->yy_buffer_stack_max = num_to_alloc;
    02565         }
    02566 }
    02567
    02574 YY_BUFFER_STATE osss_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
    02575 {
    02576         YY_BUFFER_STATE b;
    02577
    02578         if ( size < 2 ||
    02579              base[size-2] != YY_END_OF_BUFFER_CHAR ||
    02580              base[size-1] != YY_END_OF_BUFFER_CHAR )
    02581                 /* They forgot to leave room for the EOB's. */
    02582                 return 0;
    02583
    02584         b = (YY_BUFFER_STATE) osssalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
    02585         if ( ! b )
    02586                 YY_FATAL_ERROR( "out of dynamic memory in osss_scan_buffer()" );
    02587
    02588         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
    02589         b->yy_buf_pos = b->yy_ch_buf = base;
    02590         b->yy_is_our_buffer = 0;
    02591         b->yy_input_file = 0;
    02592         b->yy_n_chars = b->yy_buf_size;
    02593         b->yy_is_interactive = 0;
    02594         b->yy_at_bol = 1;
    02595         b->yy_fill_buffer = 0;
    02596         b->yy_buffer_status = YY_BUFFER_NEW;
    02597
    02598         osss_switch_to_buffer(b ,yyscanner );
    02599
    02600         return b;
    02601 }
    02602
    02611 YY_BUFFER_STATE osss_scan_string (yyconst char * yystr , yyscan_t yyscanner)
    02612 {
    02613
    02614         return osss_scan_bytes(yystr,strlen(yystr) ,yyscanner);
    02615 }
    02616
    02624 YY_BUFFER_STATE osss_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
    02625 {
    02626         YY_BUFFER_STATE b;
    02627         char *buf;
    02628         yy_size_t n;
    02629         int i;
    02630
    02631         /* Get memory for full buffer, including space for trailing EOB's. */
    02632         n = _yybytes_len + 2;
    02633         buf = (char *) osssalloc(n ,yyscanner );
    02634         if ( ! buf )
    02635                 YY_FATAL_ERROR( "out of dynamic memory in osss_scan_bytes()" );
    02636
    02637         for ( i = 0; i < _yybytes_len; ++i )
    02638                 buf[i] = yybytes[i];
    02639
    02640         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
    02641
    02642         b = osss_scan_buffer(buf,n ,yyscanner);
    02643         if ( ! b )
    02644                 YY_FATAL_ERROR( "bad buffer in osss_scan_bytes()" );
    02645
    02646         /* It's okay to grow etc. this buffer, and we should throw it
    02647          * away when we're done.
    02648          */
    02649         b->yy_is_our_buffer = 1;
    02650
    02651         return b;
    02652 }
    02653
    02654 #ifndef YY_EXIT_FAILURE
    02655 #define YY_EXIT_FAILURE 2
    02656 #endif
    02657
    02658 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
    02659 {
    02660         (void) fprintf( stderr, "%s\n", msg );
    02661         exit( YY_EXIT_FAILURE );
    02662 }
    02663
    02664 /* Redefine yyless() so it works in section 3 code. */
    02665
    02666 #undef yyless
    02667 #define yyless(n) \
    02668         do \
    02669                 { \
    02670                 /* Undo effects of setting up yytext. */ \
    02671         int yyless_macro_arg = (n); \
    02672         YY_LESS_LINENO(yyless_macro_arg);\
    02673                 yytext[yyleng] = yyg->yy_hold_char; \
    02674                 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
    02675                 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
    02676                 *yyg->yy_c_buf_p = '\0'; \
    02677                 yyleng = yyless_macro_arg; \
    02678                 } \
    02679         while ( 0 )
    02680
    02681 /* Accessor  methods (get/set functions) to struct members. */
    02682
    02686 YY_EXTRA_TYPE osssget_extra  (yyscan_t yyscanner)
    02687 {
    02688     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02689     return yyextra;
    02690 }
    02691
    02695 int osssget_lineno  (yyscan_t yyscanner)
    02696 {
    02697     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02698
    02699         if (! YY_CURRENT_BUFFER)
    02700             return 0;
    02701
    02702     return yylineno;
    02703 }
    02704
    02708 int osssget_column  (yyscan_t yyscanner)
    02709 {
    02710     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02711
    02712         if (! YY_CURRENT_BUFFER)
    02713             return 0;
    02714
    02715     return yycolumn;
    02716 }
    02717
    02721 FILE *osssget_in  (yyscan_t yyscanner)
    02722 {
    02723     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02724     return yyin;
    02725 }
    02726
    02730 FILE *osssget_out  (yyscan_t yyscanner)
    02731 {
    02732     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02733     return yyout;
    02734 }
    02735
    02739 int osssget_leng  (yyscan_t yyscanner)
    02740 {
    02741     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02742     return yyleng;
    02743 }
    02744
    02749 char *osssget_text  (yyscan_t yyscanner)
    02750 {
    02751     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02752     return yytext;
    02753 }
    02754
    02759 void osssset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
    02760 {
    02761     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02762     yyextra = user_defined ;
    02763 }
    02764
    02769 void osssset_lineno (int  line_number , yyscan_t yyscanner)
    02770 {
    02771     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02772
    02773         /* lineno is only valid if an input buffer exists. */
    02774         if (! YY_CURRENT_BUFFER )
    02775            yy_fatal_error( "osssset_lineno called with no buffer" , yyscanner);
    02776
    02777     yylineno = line_number;
    02778 }
    02779
    02784 void osssset_column (int  column_no , yyscan_t yyscanner)
    02785 {
    02786     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02787
    02788         /* column is only valid if an input buffer exists. */
    02789         if (! YY_CURRENT_BUFFER )
    02790            yy_fatal_error( "osssset_column called with no buffer" , yyscanner);
    02791
    02792     yycolumn = column_no;
    02793 }
    02794
    02801 void osssset_in (FILE *  in_str , yyscan_t yyscanner)
    02802 {
    02803     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02804     yyin = in_str ;
    02805 }
    02806
    02807 void osssset_out (FILE *  out_str , yyscan_t yyscanner)
    02808 {
    02809     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02810     yyout = out_str ;
    02811 }
    02812
    02813 int osssget_debug  (yyscan_t yyscanner)
    02814 {
    02815     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02816     return yy_flex_debug;
    02817 }
    02818
    02819 void osssset_debug (int  bdebug , yyscan_t yyscanner)
    02820 {
    02821     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02822     yy_flex_debug = bdebug ;
    02823 }
    02824
    02825 /* Accessor methods for yylval and yylloc */
    02826
    02827 /* User-visible API */
    02828
    02829 /* ossslex_init is special because it creates the scanner itself, so it is
    02830  * the ONLY reentrant function that doesn't take the scanner as the last argument.
    02831  * That's why we explicitly handle the declaration, instead of using our macros.
    02832  */
    02833
    02834 int ossslex_init(yyscan_t* ptr_yy_globals)
    02835
    02836 {
    02837     if (ptr_yy_globals == NULL){
    02838         errno = EINVAL;
    02839         return 1;
    02840     }
    02841
    02842     *ptr_yy_globals = (yyscan_t) osssalloc ( sizeof( struct yyguts_t ), NULL );
    02843
    02844     if (*ptr_yy_globals == NULL){
    02845         errno = ENOMEM;
    02846         return 1;
    02847     }
    02848
    02849     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
    02850     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
    02851
    02852     return yy_init_globals ( *ptr_yy_globals );
    02853 }
    02854
    02855 /* ossslex_init_extra has the same functionality as ossslex_init, but follows the
    02856  * convention of taking the scanner as the last argument. Note however, that
    02857  * this is a *pointer* to a scanner, as it will be allocated by this call (and
    02858  * is the reason, too, why this function also must handle its own declaration).
    02859  * The user defined value in the first argument will be available to osssalloc in
    02860  * the yyextra field.
    02861  */
    02862
    02863 int ossslex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
    02864
    02865 {
    02866     struct yyguts_t dummy_yyguts;
    02867
    02868     osssset_extra (yy_user_defined, &dummy_yyguts);
    02869
    02870     if (ptr_yy_globals == NULL){
    02871         errno = EINVAL;
    02872         return 1;
    02873     }
    02874
    02875     *ptr_yy_globals = (yyscan_t) osssalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
    02876
    02877     if (*ptr_yy_globals == NULL){
    02878         errno = ENOMEM;
    02879         return 1;
    02880     }
    02881
    02882     /* By setting to 0xAA, we expose bugs in
    02883     yy_init_globals. Leave at 0x00 for releases. */
    02884     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
    02885
    02886     osssset_extra (yy_user_defined, *ptr_yy_globals);
    02887
    02888     return yy_init_globals ( *ptr_yy_globals );
    02889 }
    02890
    02891 static int yy_init_globals (yyscan_t yyscanner)
    02892 {
    02893     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02894     /* Initialization is the same as for the non-reentrant scanner.
    02895      * This function is called from ossslex_destroy(), so don't allocate here.
    02896      */
    02897
    02898     yyg->yy_buffer_stack = 0;
    02899     yyg->yy_buffer_stack_top = 0;
    02900     yyg->yy_buffer_stack_max = 0;
    02901     yyg->yy_c_buf_p = (char *) 0;
    02902     yyg->yy_init = 0;
    02903     yyg->yy_start = 0;
    02904
    02905     yyg->yy_start_stack_ptr = 0;
    02906     yyg->yy_start_stack_depth = 0;
    02907     yyg->yy_start_stack =  NULL;
    02908
    02909 /* Defined in main.c */
    02910 #ifdef YY_STDINIT
    02911     yyin = stdin;
    02912     yyout = stdout;
    02913 #else
    02914     yyin = (FILE *) 0;
    02915     yyout = (FILE *) 0;
    02916 #endif
    02917
    02918     /* For future reference: Set errno on error, since we are called by
    02919      * ossslex_init()
    02920      */
    02921     return 0;
    02922 }
    02923
    02924 /* ossslex_destroy is for both reentrant and non-reentrant scanners. */
    02925 int ossslex_destroy  (yyscan_t yyscanner)
    02926 {
    02927     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
    02928
    02929     /* Pop the buffer stack, destroying each element. */
    02930         while(YY_CURRENT_BUFFER){
    02931                 osss_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
    02932                 YY_CURRENT_BUFFER_LVALUE = NULL;
    02933                 ossspop_buffer_state(yyscanner);
    02934         }
    02935
    02936         /* Destroy the stack itself. */
    02937         osssfree(yyg->yy_buffer_stack ,yyscanner);
    02938         yyg->yy_buffer_stack = NULL;
    02939
    02940     /* Destroy the start condition stack. */
    02941         osssfree(yyg->yy_start_stack ,yyscanner );
    02942         yyg->yy_start_stack = NULL;
    02943
    02944     /* Reset the globals. This is important in a non-reentrant scanner so the next time
    02945      * ossslex() is called, initialization will occur. */
    02946     yy_init_globals( yyscanner);
    02947
    02948     /* Destroy the main struct (reentrant only). */
    02949     osssfree ( yyscanner , yyscanner );
    02950     yyscanner = NULL;
    02951     return 0;
    02952 }
    02953
    02954 /*
    02955  * Internal utility routines.
    02956  */
    02957
    02958 #ifndef yytext_ptr
    02959 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
    02960 {
    02961         register int i;
    02962         for ( i = 0; i < n; ++i )
    02963                 s1[i] = s2[i];
    02964 }
    02965 #endif
    02966
    02967 #ifdef YY_NEED_STRLEN
    02968 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
    02969 {
    02970         register int n;
    02971         for ( n = 0; s[n]; ++n )
    02972                 ;
    02973
    02974         return n;
    02975 }
    02976 #endif
    02977
    02978 void *osssalloc (yy_size_t  size , yyscan_t yyscanner)
    02979 {
    02980         return (void *) malloc( size );
    02981 }
    02982
    02983 void *osssrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
    02984 {
    02985         /* The cast to (char *) in the following accommodates both
    02986          * implementations that use char* generic pointers, and those
    02987          * that use void* generic pointers.  It works with the latter
    02988          * because both ANSI C and C++ allow castless assignment from
    02989          * any pointer type to void*, and deal with argument conversions
    02990          * as though doing an assignment.
    02991          */
    02992         return (void *) realloc( (char *) ptr, size );
    02993 }
    02994
    02995 void osssfree (void * ptr , yyscan_t yyscanner)
    02996 {
    02997         free( (char *) ptr );   /* see osssrealloc() for (char *) cast */
    02998 }
    02999
    03000 #define YYTABLES_NAME "yytables"
    03001
    03002 #line 715 "/home/kmartin/Documents/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
    03003
    03004
    03005
    03006 void setyyextra(osOptionsStruc *osoptions, void* scanner){
    03007         osssset_extra(osoptions, scanner);
    03008 }
    03009
    03010
    03011