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

Go to the documentation of this file.
00001 #line 2 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
00002 
00003 #line 4 "/Users/kmartin/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 48
00375 #define YY_END_OF_BUFFER 49
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[358] =
00384     {   0,
00385         1,    1,   49,   47,    1,    1,   47,   47,   47,   47,
00386        47,   47,   47,   47,   47,   47,   47,    1,    0,    0,
00387         0,    0,    6,    0,    0,    0,    0,    0,    8,    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,    0,    0,    0,   37,    0,    0,
00391         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00392         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00393         0,   40,    5,    0,   34,   36,    0,    0,    0,    0,
00394         0,    9,    0,    0,    0,    0,    0,    0,    0,    0,
00395 
00396         0,   35,    0,    0,    0,    0,    0,    0,    0,    0,
00397         0,   39,    0,    0,   33,    0,    0,   36,   12,   21,
00398         0,   15,    0,    0,    4,    0,    0,    0,   38,    0,
00399         0,   32,    0,    0,   35,    0,    0,    0,    0,    0,
00400         0,    0,    0,    0,    0,   39,    0,    0,   33,    0,
00401        11,    0,   20,    0,    0,   14,    0,    0,    0,    0,
00402         0,    0,    0,   38,    0,    0,   32,   10,    0,   19,
00403         0,    0,    0,   13,    0,    0,    0,    0,    0,    0,
00404         0,   11,    0,   20,    0,    0,   14,    0,   43,    0,
00405         0,    0,    0,    0,   10,    0,   19,    0,    0,    0,
00406 
00407        13,    0,    0,   46,    3,    0,    0,    0,    0,    0,
00408        42,    0,    7,    0,    2,    0,    0,    0,    0,    0,
00409         0,   41,    0,   45,    0,    0,    3,   17,    0,    0,
00410         0,    0,    0,   42,   44,    0,    0,    2,   16,    0,
00411         0,    0,    0,    0,    0,   41,    0,   45,    0,   17,
00412        24,    0,    0,    0,   44,    0,   16,    0,    0,    0,
00413         0,   23,    0,    0,    0,   22,    0,    0,    0,    0,
00414         0,   23,    0,    0,    0,   22,   25,    0,    0,    0,
00415         0,    0,    0,   25,    0,    0,    0,   28,    0,    0,
00416         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00417 
00418        31,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00419         0,    0,    0,    0,   30,    0,    0,    0,    0,    0,
00420         0,    0,   29,    0,    0,    0,    0,    0,    0,    0,
00421         0,   30,    0,   27,    0,    0,    0,    0,   29,    0,
00422        26,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00423         0,    0,    0,    0,    0,    0,    0
00424     } ;
00425 
00426 static yyconst flex_int32_t yy_ec[256] =
00427     {   0,
00428         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
00429         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
00430         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00431         1,    2,    4,    5,    4,    4,    1,    4,    1,    4,
00432         4,    4,    4,    1,    6,    4,    4,    4,    4,    4,
00433         4,    4,    4,    4,    4,    4,    4,    4,    1,    1,
00434         1,    1,    4,    4,    4,    4,    4,    7,    4,    4,
00435         4,    4,    8,    9,    4,   10,   11,    4,   12,    4,
00436         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
00437         1,    4,    1,    1,    4,    1,   13,   14,   15,   16,
00438 
00439        17,   18,   19,   20,   21,    4,   22,   23,   24,   25,
00440        26,   27,   28,   29,   30,   31,   32,   33,   34,    4,
00441         4,    4,    1,    1,    1,    4,    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         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00449 
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,    1,    1,    1,    1,    1,
00455         1,    1,    1,    1,    1
00456     } ;
00457 
00458 static yyconst flex_int32_t yy_meta[35] =
00459     {   0,
00460         1,    2,    3,    2,    2,    2,    2,    2,    2,    2,
00461         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
00462         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
00463         2,    2,    2,    2
00464     } ;
00465 
00466 static yyconst flex_int16_t yy_base[409] =
00467     {   0,
00468         0,   29,  618,  619,    2,    5,   54,  588,  590,  602,
00469       597,  588,  585,  588,  580,  577,    1,    7,    3,  579,
00470       581,  593,  619,  580,  577,  580,  572,   12,  619,  575,
00471       575,  568,  575,  567,  566,    9,   13,  574,  565,  570,
00472       575,  574,  564,  564,  557,  557,  556,   44,   35,  556,
00473       561,  549,  564,   49,  554,  570,   63,   80,  556,  555,
00474       554,  553,  544,  541,  540,  549,  542,  536,  551,   69,
00475       558,   74,   86,  544,  543,  542,  541,  530,  529,  531,
00476       539,   90,  619,  538,   94,   98,  553,  102,  104,  549,
00477       106,  619,  535,  538,  527,  523,  522,  530,  108,  529,
00478 
00479       112,  116,  544,  120,  122,    5,  124,  527,  530,  529,
00480       526,  126,  539,  513,  130,  537,  536,  619,  134,  138,
00481       515,  142,  524,  509,  619,  516,  519,  516,  146,  529,
00482       503,  150,  527,  526,  619,  154,  158,  505,  497,  162,
00483       513,  498,  497,  166,  520,  619,  493,  518,  619,  168,
00484       172,  517,  176,  516,  493,  180,  514,  501,  184,  491,
00485       487,  186,  510,  619,  483,  508,  619,  188,  507,  192,
00486       506,  483,  478,  196,  503,  490,  200,  202,  204,  208,
00487       501,  619,  500,  619,  472,  498,  619,  202,  212,  477,
00488       216,  218,  222,  496,  619,  495,  619,  467,  471,  492,
00489 
00490       619,  216,  226,  230,  234,  491,  238,  464,  468,  476,
00491       242,  487,  619,  246,  250,  486,  254,  459,  457,  462,
00492       470,  258,  481,  262,  480,  479,  619,  266,  478,  270,
00493       467,  450,  475,  619,  272,  474,  473,  619,  276,  472,
00494       280,  445,  460,  338,  363,  619,  362,  619,  361,  619,
00495       282,  352,  344,  357,  619,  356,  619,  286,  290,  346,
00496       338,  292,  352,  325,  329,  296,  349,  300,  322,  326,
00497       346,  619,  329,  333,  343,  619,  304,  342,  325,  329,
00498       314,  308,  333,  619,  304,  310,  302,  312,  298,  341,
00499       314,  291,   12,  287,   41,  316,  283,   65,  279,  303,
00500 
00501       319,  259,  263,  254,  245,  245,  243,  323,  231,  235,
00502       228,  219,  221,  219,  330,  233,  225,  207,  207,  187,
00503       192,  167,  334,  191,  183,  161,  165,  147,  156,  133,
00504       157,  619,  132,  619,  132,  129,  129,  137,  619,  112,
00505       619,  112,  109,  103,  102,   95,   88,   81,   86,   48,
00506        65,   30,   41,   24,   15,    2,  619,  371,  373,  375,
00507       377,  379,  382,  383,  385,  388,  390,  392,  393,  395,
00508       397,  400,  402,  403,  405,  407,  410,  412,  414,  416,
00509       418,  420,  421,  423,  425,  427,  429,  432,  433,  436,
00510       437,  440,  441,  444,  446,  448,  450,  452,  453,  455,
00511 
00512       458,  460,  461,  464,  465,  467,  470,  472
00513     } ;
00514 
00515 static yyconst flex_int16_t yy_def[409] =
00516     {   0,
00517       358,  358,  357,  357,  357,  357,  357,  357,  357,  357,
00518       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00519       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00520       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00521       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00522       357,  357,  357,  357,  357,  357,  357,  359,  357,  357,
00523       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00524       357,  357,  360,  357,  357,  357,  357,  357,  357,  357,
00525       357,  361,  357,  357,  362,  359,  363,  357,  357,  357,
00526       357,  357,  357,  357,  357,  357,  357,  357,  364,  357,
00527 
00528       365,  360,  366,  357,  357,  357,  357,  357,  357,  357,
00529       357,  361,  367,  357,  362,  368,  363,  357,  369,  370,
00530       357,  371,  357,  357,  357,  357,  357,  357,  364,  372,
00531       357,  365,  373,  366,  357,  374,  375,  357,  357,  376,
00532       357,  357,  357,  357,  367,  357,  357,  368,  357,  369,
00533       369,  377,  370,  378,  357,  371,  379,  357,  357,  357,
00534       357,  357,  372,  357,  357,  373,  357,  374,  380,  375,
00535       381,  357,  357,  376,  382,  357,  357,  357,  383,  357,
00536       377,  357,  378,  357,  357,  379,  357,  357,  384,  357,
00537       357,  385,  357,  380,  357,  381,  357,  357,  357,  382,
00538 
00539       357,  357,  386,  387,  383,  388,  389,  357,  357,  357,
00540       384,  390,  357,  391,  385,  392,  393,  357,  357,  357,
00541       357,  386,  394,  387,  395,  388,  357,  389,  396,  357,
00542       357,  357,  390,  357,  391,  397,  392,  357,  393,  398,
00543       357,  357,  357,  357,  394,  357,  395,  357,  396,  357,
00544       399,  357,  357,  397,  357,  398,  357,  400,  357,  357,
00545       357,  399,  401,  357,  357,  400,  402,  403,  357,  357,
00546       401,  357,  357,  357,  402,  357,  403,  404,  357,  357,
00547       357,  357,  404,  357,  357,  357,  357,  357,  357,  357,
00548       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00549 
00550       405,  357,  357,  357,  357,  357,  357,  406,  357,  357,
00551       357,  357,  357,  357,  405,  407,  357,  357,  357,  357,
00552       357,  357,  406,  408,  357,  357,  357,  357,  357,  357,
00553       407,  357,  357,  357,  357,  357,  357,  408,  357,  357,
00554       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00555       357,  357,  357,  357,  357,  357,    0,  357,  357,  357,
00556       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00557       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00558       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00559       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00560 
00561       357,  357,  357,  357,  357,  357,  357,  357
00562     } ;
00563 
00564 static yyconst flex_int16_t yy_nxt[654] =
00565     {   0,
00566       357,    5,    6,   18,   18,    7,   18,   18,   18,   18,
00567        58,   58,  138,    8,    9,   10,  139,   39,  341,   11,
00568        12,  341,   41,   13,   14,   15,   40,   16,   50,   17,
00569         5,    6,  303,   59,    7,   42,  304,   51,   60,   61,
00570       334,   62,    8,    9,   10,   73,   73,  334,   11,   12,
00571        82,   82,   13,   14,   15,   74,   16,  306,   17,   19,
00572        75,   76,  356,   77,   85,   85,  307,   20,   21,   22,
00573        99,   99,  355,   23,   24,  101,  101,   25,   26,   27,
00574       354,   58,   58,   28,   87,  310,   29,   73,   73,  311,
00575       103,   82,   82,  353,  113,   85,   85,  352,  116,  357,
00576 
00577       357,  351,  357,  119,  119,  120,  120,  122,  122,   99,
00578        99,  350,  130,  101,  101,  349,  133,  357,  357,  341,
00579       357,  136,  136,  137,  137,  140,  140,  357,  357,  348,
00580       357,  357,  357,  341,  357,  150,  150,  347,  152,  120,
00581       120,  339,  154,  122,  122,  334,  157,  357,  357,  346,
00582       357,  357,  357,  334,  357,  136,  136,  345,  169,  137,
00583       137,  332,  171,  140,  140,  344,  175,  179,  179,  150,
00584       150,  341,  152,  357,  357,  343,  357,  357,  357,  342,
00585       357,  357,  357,  341,  357,  189,  189,  192,  192,  357,
00586       357,  340,  357,  357,  357,  339,  357,  357,  357,  337,
00587 
00588       357,  203,  203,  204,  204,  179,  179,  334,  206,  207,
00589       207,  209,  210,  189,  189,  336,  212,  214,  214,  192,
00590       192,  335,  216,  217,  217,  220,  221,  203,  203,  334,
00591       223,  204,  204,  333,  225,  357,  357,  332,  357,  207,
00592       207,  330,  229,  357,  357,  329,  357,  214,  214,  328,
00593       236,  357,  357,  327,  357,  217,  217,  326,  240,  357,
00594       357,  325,  357,  357,  357,  322,  357,  357,  357,  321,
00595       357,  251,  251,  357,  357,  320,  357,  357,  357,  319,
00596       357,  258,  258,  251,  251,  318,  263,  258,  258,  317,
00597       267,  268,  268,  357,  357,  312,  357,  357,  357,  309,
00598 
00599       357,  268,  268,  305,  278,  357,  357,  302,  357,  288,
00600       288,  290,  290,  288,  288,  301,  301,  308,  308,  313,
00601       301,  301,  296,  316,  308,  308,  291,  324,  314,  289,
00602       292,  357,  357,  293,  357,  357,  357,  284,  357,  287,
00603       294,  295,  290,  290,  286,  285,  284,  276,  282,  281,
00604       272,  280,  279,  276,  274,  273,  272,  270,  269,  297,
00605       257,  255,  298,  265,  264,  250,  248,  246,  261,  299,
00606       300,    4,    4,    4,   86,   86,  102,  102,  112,  112,
00607       115,  115,  117,  117,  129,  129,  132,  132,  134,  134,
00608       145,  145,  148,  148,  151,  151,  153,  153,  156,  156,
00609 
00610       163,  163,  166,  166,  168,  168,  170,  170,  174,  174,
00611       181,  181,  183,  183,  186,  186,  194,  194,  196,  196,
00612       200,  200,  205,  205,  211,  211,  215,  215,  222,  222,
00613       224,  224,  226,  226,  228,  228,  233,  233,  235,  235,
00614       237,  237,  239,  239,  245,  245,  247,  247,  249,  249,
00615       254,  254,  256,  256,  262,  262,  266,  266,  271,  271,
00616       275,  275,  277,  277,  283,  283,  315,  315,  323,  323,
00617       331,  331,  338,  338,  260,  259,  257,  238,  255,  234,
00618       253,  252,  250,  227,  248,  246,  244,  243,  242,  241,
00619       238,  234,  232,  231,  230,  227,  201,  219,  218,  197,
00620 
00621       195,  213,  187,  208,  184,  182,  202,  201,  199,  198,
00622       197,  195,  167,  193,  164,  191,  190,  188,  187,  185,
00623       184,  182,  149,  180,  146,  178,  177,  176,  173,  172,
00624       135,  167,  165,  164,  162,  161,  160,  159,  158,  155,
00625       118,  149,  147,  146,  144,  143,  142,  141,  135,  131,
00626       128,  127,  126,  125,  124,  123,  121,  118,  114,  111,
00627       110,  109,  108,  107,  106,  105,  104,  100,   98,   97,
00628        96,   95,   94,   93,   92,   91,   90,   89,   88,   84,
00629        83,   81,   80,   79,   78,   72,   71,   70,   69,   68,
00630        67,   66,   65,   64,   63,   57,   56,   55,   54,   53,
00631 
00632        52,   49,   48,   47,   46,   45,   44,   43,   38,   37,
00633        36,   35,   34,   33,   32,   31,   30,  357,    3,  357,
00634       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00635       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00636       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00637       357,  357,  357
00638     } ;
00639 
00640 static yyconst flex_int16_t yy_chk[654] =
00641     {   0,
00642         0,    1,    1,    5,    5,    1,    6,    6,   18,   18,
00643        36,   36,  106,    1,    1,    1,  106,   17,  356,    1,
00644         1,  355,   19,    1,    1,    1,   17,    1,   28,    1,
00645         2,    2,  293,   37,    2,   19,  293,   28,   37,   37,
00646       354,   37,    2,    2,    2,   48,   48,  353,    2,    2,
00647        54,   54,    2,    2,    2,   49,    2,  295,    2,    7,
00648        49,   49,  352,   49,   57,   57,  295,    7,    7,    7,
00649        70,   70,  351,    7,    7,   72,   72,    7,    7,    7,
00650       350,   58,   58,    7,   58,  298,    7,   73,   73,  298,
00651        73,   82,   82,  349,   82,   85,   85,  348,   85,   86,
00652 
00653        86,  347,   86,   88,   88,   89,   89,   91,   91,   99,
00654        99,  346,   99,  101,  101,  345,  101,  102,  102,  344,
00655       102,  104,  104,  105,  105,  107,  107,  112,  112,  343,
00656       112,  115,  115,  342,  115,  119,  119,  340,  119,  120,
00657       120,  338,  120,  122,  122,  337,  122,  129,  129,  336,
00658       129,  132,  132,  335,  132,  136,  136,  333,  136,  137,
00659       137,  331,  137,  140,  140,  330,  140,  144,  144,  150,
00660       150,  329,  150,  151,  151,  328,  151,  153,  153,  327,
00661       153,  156,  156,  326,  156,  159,  159,  162,  162,  168,
00662       168,  325,  168,  170,  170,  324,  170,  174,  174,  322,
00663 
00664       174,  177,  177,  178,  178,  179,  179,  321,  179,  180,
00665       180,  188,  188,  189,  189,  320,  189,  191,  191,  192,
00666       192,  319,  192,  193,  193,  202,  202,  203,  203,  318,
00667       203,  204,  204,  317,  204,  205,  205,  316,  205,  207,
00668       207,  314,  207,  211,  211,  313,  211,  214,  214,  312,
00669       214,  215,  215,  311,  215,  217,  217,  310,  217,  222,
00670       222,  309,  222,  224,  224,  307,  224,  228,  228,  306,
00671       228,  230,  230,  235,  235,  305,  235,  239,  239,  304,
00672       239,  241,  241,  251,  251,  303,  251,  258,  258,  302,
00673       258,  259,  259,  262,  262,  299,  262,  266,  266,  297,
00674 
00675       266,  268,  268,  294,  268,  277,  277,  292,  277,  282,
00676       282,  286,  286,  288,  288,  291,  291,  296,  296,  300,
00677       301,  301,  289,  301,  308,  308,  287,  308,  300,  285,
00678       288,  315,  315,  288,  315,  323,  323,  283,  323,  281,
00679       288,  288,  290,  290,  280,  279,  278,  275,  274,  273,
00680       271,  270,  269,  267,  265,  264,  263,  261,  260,  290,
00681       256,  254,  290,  253,  252,  249,  247,  245,  244,  290,
00682       290,  358,  358,  358,  359,  359,  360,  360,  361,  361,
00683       362,  362,  363,  363,  364,  364,  365,  365,  366,  366,
00684       367,  367,  368,  368,  369,  369,  370,  370,  371,  371,
00685 
00686       372,  372,  373,  373,  374,  374,  375,  375,  376,  376,
00687       377,  377,  378,  378,  379,  379,  380,  380,  381,  381,
00688       382,  382,  383,  383,  384,  384,  385,  385,  386,  386,
00689       387,  387,  388,  388,  389,  389,  390,  390,  391,  391,
00690       392,  392,  393,  393,  394,  394,  395,  395,  396,  396,
00691       397,  397,  398,  398,  399,  399,  400,  400,  401,  401,
00692       402,  402,  403,  403,  404,  404,  405,  405,  406,  406,
00693       407,  407,  408,  408,  243,  242,  240,  237,  236,  233,
00694       232,  231,  229,  226,  225,  223,  221,  220,  219,  218,
00695       216,  212,  210,  209,  208,  206,  200,  199,  198,  196,
00696 
00697       194,  190,  186,  185,  183,  181,  176,  175,  173,  172,
00698       171,  169,  166,  165,  163,  161,  160,  158,  157,  155,
00699       154,  152,  148,  147,  145,  143,  142,  141,  139,  138,
00700       134,  133,  131,  130,  128,  127,  126,  124,  123,  121,
00701       117,  116,  114,  113,  111,  110,  109,  108,  103,  100,
00702        98,   97,   96,   95,   94,   93,   90,   87,   84,   81,
00703        80,   79,   78,   77,   76,   75,   74,   71,   69,   68,
00704        67,   66,   65,   64,   63,   62,   61,   60,   59,   56,
00705        55,   53,   52,   51,   50,   47,   46,   45,   44,   43,
00706        42,   41,   40,   39,   38,   35,   34,   33,   32,   31,
00707 
00708        30,   27,   26,   25,   24,   22,   21,   20,   16,   15,
00709        14,   13,   12,   11,   10,    9,    8,    3,  357,  357,
00710       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00711       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00712       357,  357,  357,  357,  357,  357,  357,  357,  357,  357,
00713       357,  357,  357
00714     } ;
00715 
00716 /* Table of booleans, true if rule could match eol. */
00717 static yyconst flex_int32_t yy_rule_can_match_eol[49] =
00718     {   0,
00719 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
00720     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
00721     1, 1, 1, 1, 1, 1, 1, 0, 0,     };
00722 
00723 /* The intent behind this definition is that it'll catch
00724  * any uses of REJECT which flex missed.
00725  */
00726 #define REJECT reject_used_but_not_detected
00727 #define yymore() yymore_used_but_not_detected
00728 #define YY_MORE_ADJ 0
00729 #define YY_RESTORE_YY_MORE_OFFSET
00730 #line 1 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
00731 /* $Id: OSParseosss.cpp 4292 2011-09-21 05:47:18Z kmartin $ */
00746 #line 18 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
00747 
00748 
00749 #include <iostream>
00750 #include "OSConfig.h"
00751 
00752 
00753 #ifdef HAVE_CSTRING
00754 # include <cstring>
00755 #else
00756 # ifdef HAVE_STRING_H
00757 #  include <string.h>
00758 # else
00759 #  error "don't have header file for string"
00760 # endif
00761 #endif
00762 
00763 #ifdef HAVE_CSTDIO
00764 # include <cstdio>
00765 #else
00766 # ifdef HAVE_STDIO_H
00767 #  include <stdio.h>
00768 # else
00769 #  error "don't have header file for stdio"
00770 # endif
00771 #endif
00772 #include "OSErrorClass.h"
00773 #include <sstream>   
00774 #include "OSOptionsStruc.h" 
00775 
00776 
00777 using std::cout;
00778 using std::endl;
00779 using std::ostringstream;
00780 
00781 //#define PARSERDEBUG
00782 #ifdef PARSERDEBUG
00783         #define YY_PRINT  printf("Found option:  %s\n", yytext);
00784 #else     
00785         #define YY_PRINT  ;
00786 #endif
00787 
00788 
00789 #ifdef WIN_
00790   #define YY_NO_UNISTD_H
00791   #include <io.h>
00792   #include <process.h>
00793   #ifdef USE_OLD_UNISTD
00794      #include<sys/unistd.h>  
00795   #endif
00796 #endif
00797 
00798 
00799 #define YY_EXTRA_TYPE struct osOptionsStruc*
00800 
00801 void setyyextra( osOptionsStruc *osoptions, void* scanner);
00802 
00803  /*
00804  * INPUTS:
00805  * -osil xxx.osil (file name on local machine of optimization instance, 
00806  *       this is "" by default, however if this remains "" a problem
00807  *               instance must be specified in the osol file)
00808  * -osol xxx.osol (file name on local machine of solver options, 
00809  *       default default value is "")
00810  * -osrl xxx.osrl (file name on local machine where the optimization 
00811  *       result is put, default is "")
00812  * -serviceLocation location URL (the URL  of the server that is called 
00813  *       remotely if the problem not solved locally, default is "")
00814  * -serviceMethod  (send, solve, kill, knock, getJobID, retrieve, 
00815  *       default value is solve)
00816  * -osplInput xxx.ospl  (Not used for now -- ignore)
00817  * -osplOutput xxx.ospl (Not used for now -- ignore)
00818  * -mps xxxx.mps (converts mps format to osil and has same effect as -osil)
00819  * -nl xxxx.nl (converts nl format to osil and has same effect as -osil)
00820  * -solver solverName (the name of the solver to be invoked)
00821  * -browser path location to browser e.g. 
00822  *       /Applications/Firefox.app/Contents/MacOS/firefox (default is "")
00823  * -config pathToConfigFile is the path to a configure file with the problem 
00824  *           parameters
00825  * -insList xxx.dat (used only for LINDO, file location on local 
00826  *       machine of LINDO instruction list)
00827 */
00828 
00829 
00830 #line 831 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
00831 
00832 #define INITIAL 0
00833 
00834 #ifndef YY_NO_UNISTD_H
00835 /* Special case for "unistd.h", since it is non-ANSI. We include it way
00836  * down here because we want the user's section 1 to have been scanned first.
00837  * The user has a chance to override it with an option.
00838  */
00839 #include <unistd.h>
00840 #endif
00841 
00842 #ifndef YY_EXTRA_TYPE
00843 #define YY_EXTRA_TYPE void *
00844 #endif
00845 
00846 /* Holds the entire state of the reentrant scanner. */
00847 struct yyguts_t
00848     {
00849 
00850     /* User-defined. Not touched by flex. */
00851     YY_EXTRA_TYPE yyextra_r;
00852 
00853     /* The rest are the same as the globals declared in the non-reentrant scanner. */
00854     FILE *yyin_r, *yyout_r;
00855     size_t yy_buffer_stack_top; 
00856     size_t yy_buffer_stack_max; 
00857     YY_BUFFER_STATE * yy_buffer_stack; 
00858     char yy_hold_char;
00859     int yy_n_chars;
00860     int yyleng_r;
00861     char *yy_c_buf_p;
00862     int yy_init;
00863     int yy_start;
00864     int yy_did_buffer_switch_on_eof;
00865     int yy_start_stack_ptr;
00866     int yy_start_stack_depth;
00867     int *yy_start_stack;
00868     yy_state_type yy_last_accepting_state;
00869     char* yy_last_accepting_cpos;
00870 
00871     int yylineno_r;
00872     int yy_flex_debug_r;
00873 
00874     char *yytext_r;
00875     int yy_more_flag;
00876     int yy_more_len;
00877 
00878     }; /* end struct yyguts_t */
00879 
00880 static int yy_init_globals (yyscan_t yyscanner );
00881 
00882 int ossslex_init (yyscan_t* scanner);
00883 
00884 int ossslex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
00885 
00886 /* Accessor methods to globals.
00887    These are made visible to non-reentrant scanners for convenience. */
00888 
00889 int ossslex_destroy (yyscan_t yyscanner );
00890 
00891 int osssget_debug (yyscan_t yyscanner );
00892 
00893 void osssset_debug (int debug_flag ,yyscan_t yyscanner );
00894 
00895 YY_EXTRA_TYPE osssget_extra (yyscan_t yyscanner );
00896 
00897 void osssset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
00898 
00899 FILE *osssget_in (yyscan_t yyscanner );
00900 
00901 void osssset_in  (FILE * in_str ,yyscan_t yyscanner );
00902 
00903 FILE *osssget_out (yyscan_t yyscanner );
00904 
00905 void osssset_out  (FILE * out_str ,yyscan_t yyscanner );
00906 
00907 int osssget_leng (yyscan_t yyscanner );
00908 
00909 char *osssget_text (yyscan_t yyscanner );
00910 
00911 int osssget_lineno (yyscan_t yyscanner );
00912 
00913 void osssset_lineno (int line_number ,yyscan_t yyscanner );
00914 
00915 /* Macros after this point can all be overridden by user definitions in
00916  * section 1.
00917  */
00918 
00919 #ifndef YY_SKIP_YYWRAP
00920 #ifdef __cplusplus
00921 extern "C" int ossswrap (yyscan_t yyscanner );
00922 #else
00923 extern int ossswrap (yyscan_t yyscanner );
00924 #endif
00925 #endif
00926 
00927 #ifndef yytext_ptr
00928 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
00929 #endif
00930 
00931 #ifdef YY_NEED_STRLEN
00932 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
00933 #endif
00934 
00935 #ifndef YY_NO_INPUT
00936 
00937 #ifdef __cplusplus
00938 static int yyinput (yyscan_t yyscanner );
00939 #else
00940 static int input (yyscan_t yyscanner );
00941 #endif
00942 
00943 #endif
00944 
00945 /* Amount of stuff to slurp up with each read. */
00946 #ifndef YY_READ_BUF_SIZE
00947 #ifdef __ia64__
00948 /* On IA-64, the buffer size is 16k, not 8k */
00949 #define YY_READ_BUF_SIZE 16384
00950 #else
00951 #define YY_READ_BUF_SIZE 8192
00952 #endif /* __ia64__ */
00953 #endif
00954 
00955 /* Copy whatever the last rule matched to the standard output. */
00956 #ifndef ECHO
00957 /* This used to be an fputs(), but since the string might contain NUL's,
00958  * we now use fwrite().
00959  */
00960 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
00961 #endif
00962 
00963 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
00964  * is returned in "result".
00965  */
00966 #ifndef YY_INPUT
00967 #define YY_INPUT(buf,result,max_size) \
00968         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
00969                 { \
00970                 int c = '*'; \
00971                 size_t n; \
00972                 for ( n = 0; n < max_size && \
00973                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00974                         buf[n] = (char) c; \
00975                 if ( c == '\n' ) \
00976                         buf[n++] = (char) c; \
00977                 if ( c == EOF && ferror( yyin ) ) \
00978                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
00979                 result = n; \
00980                 } \
00981         else \
00982                 { \
00983                 errno=0; \
00984                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
00985                         { \
00986                         if( errno != EINTR) \
00987                                 { \
00988                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
00989                                 break; \
00990                                 } \
00991                         errno=0; \
00992                         clearerr(yyin); \
00993                         } \
00994                 }\
00995 \
00996 
00997 #endif
00998 
00999 /* No semi-colon after return; correct usage is to write "yyterminate();" -
01000  * we don't want an extra ';' after the "return" because that will cause
01001  * some compilers to complain about unreachable statements.
01002  */
01003 #ifndef yyterminate
01004 #define yyterminate() return YY_NULL
01005 #endif
01006 
01007 /* Number of entries by which start-condition stack grows. */
01008 #ifndef YY_START_STACK_INCR
01009 #define YY_START_STACK_INCR 25
01010 #endif
01011 
01012 /* Report a fatal error. */
01013 #ifndef YY_FATAL_ERROR
01014 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
01015 #endif
01016 
01017 /* end tables serialization structures and prototypes */
01018 
01019 /* Default declaration of generated scanner - a define so the user can
01020  * easily add parameters.
01021  */
01022 #ifndef YY_DECL
01023 #define YY_DECL_IS_OURS 1
01024 
01025 extern int ossslex (yyscan_t yyscanner);
01026 
01027 #define YY_DECL int ossslex (yyscan_t yyscanner)
01028 #endif /* !YY_DECL */
01029 
01030 /* Code executed at the beginning of each rule, after yytext and yyleng
01031  * have been set up.
01032  */
01033 #ifndef YY_USER_ACTION
01034 #define YY_USER_ACTION
01035 #endif
01036 
01037 /* Code executed at the end of each rule. */
01038 #ifndef YY_BREAK
01039 #define YY_BREAK break;
01040 #endif
01041 
01042 #define YY_RULE_SETUP \
01043         YY_USER_ACTION
01044 
01047 YY_DECL
01048 {
01049         register yy_state_type yy_current_state;
01050         register char *yy_cp, *yy_bp;
01051         register int yy_act;
01052     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01053 
01054 #line 114 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01055 
01056 
01057 #line 1058 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
01058 
01059         if ( !yyg->yy_init )
01060                 {
01061                 yyg->yy_init = 1;
01062 
01063 #ifdef YY_USER_INIT
01064                 YY_USER_INIT;
01065 #endif
01066 
01067                 if ( ! yyg->yy_start )
01068                         yyg->yy_start = 1;      /* first start state */
01069 
01070                 if ( ! yyin )
01071                         yyin = stdin;
01072 
01073                 if ( ! yyout )
01074                         yyout = stdout;
01075 
01076                 if ( ! YY_CURRENT_BUFFER ) {
01077                         osssensure_buffer_stack (yyscanner);
01078                         YY_CURRENT_BUFFER_LVALUE =
01079                                 osss_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
01080                 }
01081 
01082                 osss_load_buffer_state(yyscanner );
01083                 }
01084 
01085         while ( 1 )             /* loops until end-of-file is reached */
01086                 {
01087                 yy_cp = yyg->yy_c_buf_p;
01088 
01089                 /* Support of yytext. */
01090                 *yy_cp = yyg->yy_hold_char;
01091 
01092                 /* yy_bp points to the position in yy_ch_buf of the start of
01093                  * the current run.
01094                  */
01095                 yy_bp = yy_cp;
01096 
01097                 yy_current_state = yyg->yy_start;
01098 yy_match:
01099                 do
01100                         {
01101                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
01102                         if ( yy_accept[yy_current_state] )
01103                                 {
01104                                 yyg->yy_last_accepting_state = yy_current_state;
01105                                 yyg->yy_last_accepting_cpos = yy_cp;
01106                                 }
01107                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01108                                 {
01109                                 yy_current_state = (int) yy_def[yy_current_state];
01110                                 if ( yy_current_state >= 358 )
01111                                         yy_c = yy_meta[(unsigned int) yy_c];
01112                                 }
01113                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01114                         ++yy_cp;
01115                         }
01116                 while ( yy_base[yy_current_state] != 619 );
01117 
01118 yy_find_action:
01119                 yy_act = yy_accept[yy_current_state];
01120                 if ( yy_act == 0 )
01121                         { /* have to back up */
01122                         yy_cp = yyg->yy_last_accepting_cpos;
01123                         yy_current_state = yyg->yy_last_accepting_state;
01124                         yy_act = yy_accept[yy_current_state];
01125                         }
01126 
01127                 YY_DO_BEFORE_ACTION;
01128 
01129                 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
01130                         {
01131                         int yyl;
01132                         for ( yyl = 0; yyl < yyleng; ++yyl )
01133                                 if ( yytext[yyl] == '\n' )
01134                                            
01135     do{ yylineno++;
01136         yycolumn=0;
01137     }while(0)
01138 ;
01139                         }
01140 
01141 do_action:      /* This label is used only to access EOF actions. */
01142 
01143                 switch ( yy_act )
01144         { /* beginning of action switch */
01145                         case 0: /* must back up */
01146                         /* undo the effects of YY_DO_BEFORE_ACTION */
01147                         *yy_cp = yyg->yy_hold_char;
01148                         yy_cp = yyg->yy_last_accepting_cpos;
01149                         yy_current_state = yyg->yy_last_accepting_state;
01150                         goto yy_find_action;
01151 
01152 case 1:
01153 /* rule 1 can match eol */
01154 YY_RULE_SETUP
01155 #line 116 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01156 
01157         YY_BREAK
01158 case 2:
01159 /* rule 2 can match eol */
01160 YY_RULE_SETUP
01161 #line 120 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01162 {
01163         YY_PRINT  
01164         //char *ch = strdup(yytext);
01165         char *ch = yytext;
01166         // move past -config
01167         ch+=7;
01168         for(; isspace(*ch); ch++);
01169         std::string str(  ch);
01170         yyextra->configFile = str;
01171 
01172 }
01173         YY_BREAK
01174 case 3:
01175 /* rule 3 can match eol */
01176 YY_RULE_SETUP
01177 #line 134 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01178 {
01179         YY_PRINT  
01180         //char *ch = strdup(yytext);
01181         char *ch = yytext;
01182         // move past -config
01183         ch+=6;
01184         for(; isspace(*ch); ch++);
01185         std::string str(  ch);
01186         yyextra->configFile = str;
01187 
01188 }
01189         YY_BREAK
01190 case 4:
01191 YY_RULE_SETUP
01192 #line 148 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01193 {
01194         YY_PRINT  
01195         yyextra->invokeHelp = true;
01196 
01197 }
01198         YY_BREAK
01199 case 5:
01200 YY_RULE_SETUP
01201 #line 154 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01202 {
01203     YY_PRINT  
01204     yyextra->invokeHelp = true;
01205  
01206  }
01207         YY_BREAK
01208 case 6:
01209 YY_RULE_SETUP
01210 #line 160 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01211 {
01212         YY_PRINT
01213         yyextra->invokeHelp = true;
01214         
01215         
01216 }
01217         YY_BREAK
01218 case 7:
01219 YY_RULE_SETUP
01220 #line 173 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01221 {
01222         YY_PRINT  
01223         yyextra->writeVersion = true;
01224         
01225 }
01226         YY_BREAK
01227 case 8:
01228 YY_RULE_SETUP
01229 #line 179 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01230 {
01231         YY_PRINT 
01232         yyextra->writeVersion = true;
01233         
01234         
01235 }
01236         YY_BREAK
01237 case 9:
01238 YY_RULE_SETUP
01239 #line 187 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01240 {
01241    YY_PRINT  
01242    yyextra->quit = true;
01243  
01244 }
01245         YY_BREAK
01246 case 10:
01247 /* rule 10 can match eol */
01248 YY_RULE_SETUP
01249 #line 194 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01250 {
01251         //if(yyextra->osilFile == ""){
01252                 YY_PRINT  
01253                 //char *ch = strdup(yytext);
01254                 char *ch = yytext;
01255                 // move past -osil
01256                 ch+=5;
01257                 for(; isspace(*ch); ch++);
01258                 std::string str(  ch);
01259                 yyextra->osilFile = str;
01260         //} 
01261 }
01262         YY_BREAK
01263 case 11:
01264 /* rule 11 can match eol */
01265 YY_RULE_SETUP
01266 #line 210 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01267 {
01268         // if(yyextra->osilFile == ""){
01269                  YY_PRINT  
01270                  //char *ch = strdup(yytext);
01271                  char *ch = yytext;
01272                  // move past osil
01273                  ch+=4;
01274                  for(; isspace(*ch); ch++);
01275                  std::string str(  ch);
01276                  yyextra->osilFile = str;
01277         // } 
01278  }
01279         YY_BREAK
01280 case 12:
01281 /* rule 12 can match eol */
01282 YY_RULE_SETUP
01283 #line 224 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01284 {
01285         // if(yyextra->osilFile == ""){
01286                  YY_PRINT  
01287                  //char *ch = strdup(yytext);
01288                  char *ch = yytext;
01289                  // move past osil
01290                  ch+=4;
01291                  for(; isspace(*ch); ch++);
01292                  std::string str(  ch);
01293                  yyextra->osilFile = str;
01294         // } 
01295  }
01296         YY_BREAK
01297 case 13:
01298 /* rule 13 can match eol */
01299 YY_RULE_SETUP
01300 #line 237 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01301 {
01302         //if(yyextra->osrlFile == ""){
01303                 YY_PRINT 
01304                 //char *ch = strdup(yytext);
01305                 char *ch = yytext;
01306                 // move past -osrl
01307                 ch+=5;
01308                 for(; isspace(*ch); ch++);
01309                 std::string str(  ch);
01310                 yyextra->osrlFile = str;
01311         //}  
01312 }  
01313         YY_BREAK
01314 case 14:
01315 /* rule 14 can match eol */
01316 YY_RULE_SETUP
01317 #line 250 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01318 {
01319          //if(yyextra->osrlFile == ""){
01320                  YY_PRINT 
01321                  //char *ch = strdup(yytext);
01322                  char *ch = yytext;
01323                  // move past -osrl
01324                  ch+=4;
01325                  for(; isspace(*ch); ch++);
01326                  std::string str(  ch);
01327                  yyextra->osrlFile = str;
01328          //}  
01329  }                       
01330         YY_BREAK
01331 case 15:
01332 /* rule 15 can match eol */
01333 YY_RULE_SETUP
01334 #line 264 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01335 {
01336         // if(yyextra->osrlFile == ""){
01337                  YY_PRINT 
01338                  //char *ch = strdup(yytext);
01339                  char *ch = yytext;
01340                  // move past -osrl
01341                  ch+=4;
01342                  for(; isspace(*ch); ch++);
01343                  std::string str(  ch);
01344                  yyextra->osrlFile = str;
01345         // }  
01346  }                       
01347         YY_BREAK
01348 case 16:
01349 /* rule 16 can match eol */
01350 YY_RULE_SETUP
01351 #line 279 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01352 {
01353         //if(yyextra->insListFile == ""){
01354                 YY_PRINT
01355                 //char *ch = strdup(yytext);
01356                 char *ch = yytext;
01357                 // move past -insList
01358                 ch+=8;
01359                 for(; isspace(*ch); ch++);
01360                 std::string str(  ch);
01361                 yyextra->insListFile = str;
01362         //}  
01363 }  
01364         YY_BREAK
01365 case 17:
01366 /* rule 17 can match eol */
01367 YY_RULE_SETUP
01368 #line 294 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01369 {
01370          //if(yyextra->insListFile == ""){
01371                  YY_PRINT
01372                  //char *ch = strdup(yytext);
01373                  char *ch = yytext;
01374                  // move past -insList
01375                  ch+=7;
01376                  for(; isspace(*ch); ch++);
01377                  std::string str(  ch);
01378                  yyextra->insListFile = str;
01379         // }  
01380  }
01381         YY_BREAK
01382 case 18:
01383 /* rule 18 can match eol */
01384 YY_RULE_SETUP
01385 #line 308 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01386 {
01387         // if(yyextra->insListFile == ""){
01388                  YY_PRINT
01389                  //char *ch = strdup(yytext);
01390                  char *ch = yytext;
01391                  // move past -insList
01392                  ch+=7;
01393                  for(; isspace(*ch); ch++);
01394                  std::string str(  ch);
01395                  yyextra->insListFile = str;
01396         // }  
01397  }
01398         YY_BREAK
01399 case 19:
01400 /* rule 19 can match eol */
01401 YY_RULE_SETUP
01402 #line 322 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01403 {
01404         //if(yyextra->osolFile == ""){
01405                 YY_PRINT 
01406                 //char *ch = strdup(yytext);
01407                 char *ch = yytext;
01408                 // move past -osol
01409                 ch+=5;
01410                 for(; isspace(*ch); ch++);
01411                 std::string str(  ch);
01412                 yyextra->osolFile = str;  
01413         //}
01414 }
01415         YY_BREAK
01416 case 20:
01417 /* rule 20 can match eol */
01418 YY_RULE_SETUP
01419 #line 337 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01420 {
01421         //if(yyextra->osolFile == ""){
01422                  YY_PRINT 
01423                  //char *ch = strdup(yytext);
01424                  char *ch = yytext;
01425                  // move past -osol
01426                  ch+=4;
01427                  for(; isspace(*ch); ch++);
01428                  std::string str(  ch);
01429                  yyextra->osolFile = str;  
01430         //}
01431 }
01432         YY_BREAK
01433 case 21:
01434 /* rule 21 can match eol */
01435 YY_RULE_SETUP
01436 #line 351 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01437 {
01438          //if(yyextra->osolFile == ""){
01439                  YY_PRINT 
01440                  //char *ch = strdup(yytext);
01441                  char *ch = yytext;
01442                  // move past -osol
01443                  ch+=4;
01444                  for(; isspace(*ch); ch++);
01445                  std::string str(  ch);
01446                  yyextra->osolFile = str;  
01447         // }
01448  }
01449         YY_BREAK
01450 case 22:
01451 /* rule 22 can match eol */
01452 YY_RULE_SETUP
01453 #line 366 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01454 {
01455         //if(yyextra->osplInputFile == ""){
01456                 YY_PRINT 
01457                 //char *ch = strdup(yytext);
01458                 char *ch = yytext;
01459                 // move past -osplInput
01460                 ch+=10;
01461                 for(; isspace(*ch); ch++);
01462                 std::string str(  ch);
01463                 yyextra->osplInputFile = str;  
01464         //}
01465 }
01466         YY_BREAK
01467 case 23:
01468 /* rule 23 can match eol */
01469 YY_RULE_SETUP
01470 #line 380 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01471 {
01472                         // if(yyextra->osplInputFile == ""){
01473                          YY_PRINT 
01474                          //char *ch = strdup(yytext);
01475                          char *ch = yytext;
01476                          // move past -osplInput
01477                          ch+=9;
01478                          for(; isspace(*ch); ch++);
01479                          std::string str(  ch);
01480                          yyextra->osplInputFile = str;  
01481                         // }
01482                          }
01483         YY_BREAK
01484 case 24:
01485 /* rule 24 can match eol */
01486 YY_RULE_SETUP
01487 #line 393 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01488 {
01489                         // if(yyextra->osplInputFile == ""){
01490                          YY_PRINT 
01491                          //char *ch = strdup(yytext);
01492                          char *ch = yytext;
01493                          // move past -osplInput
01494                          ch+=9;
01495                          for(; isspace(*ch); ch++);
01496                          std::string str(  ch);
01497                          yyextra->osplInputFile = str;  
01498                         // }
01499                          }
01500         YY_BREAK
01501 case 25:
01502 /* rule 25 can match eol */
01503 YY_RULE_SETUP
01504 #line 406 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01505 {
01506         //if(yyextra->osplOutputFile == ""){
01507                 YY_PRINT 
01508                 //char *ch = strdup(yytext);
01509                 char *ch = yytext;
01510                 // move past -osplInput
01511                 ch+=11;
01512                 for(; isspace(*ch); ch++);
01513                 std::string str(  ch);
01514                 yyextra->osplOutputFile = str;  
01515         //}
01516 }
01517         YY_BREAK
01518 case 26:
01519 /* rule 26 can match eol */
01520 YY_RULE_SETUP
01521 #line 419 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01522 {
01523         //if(yyextra->serviceMethod == ""){
01524                 YY_PRINT
01525                 //char *ch = strdup(yytext);
01526                 char *ch = yytext;
01527                 // move past -serviceMethod
01528                 ch+=14;
01529                 for(; isspace(*ch); ch++);
01530                 std::string str(  ch);
01531                 yyextra->serviceMethod = str; 
01532         //}
01533 }
01534         YY_BREAK
01535 case 27:
01536 /* rule 27 can match eol */
01537 YY_RULE_SETUP
01538 #line 432 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01539 {
01540                         // if(yyextra->serviceMethod == ""){
01541                          YY_PRINT
01542                          //char *ch = strdup(yytext);
01543                          char *ch = yytext;
01544                          // move past -serviceMethod
01545                          ch+=13;
01546                          for(; isspace(*ch); ch++);
01547                          std::string str(  ch);
01548                          yyextra->serviceMethod = str; 
01549                         // }
01550                          }
01551         YY_BREAK
01552 case 28:
01553 /* rule 28 can match eol */
01554 YY_RULE_SETUP
01555 #line 445 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01556 {
01557                         // if(yyextra->serviceMethod == ""){
01558                          YY_PRINT
01559                          //char *ch = strdup(yytext);
01560                          char *ch = yytext;
01561                          // move past -serviceMethod
01562                          ch+=13;
01563                          for(; isspace(*ch); ch++);
01564                          std::string str(  ch);
01565                          yyextra->serviceMethod = str; 
01566                         // }
01567                          }
01568         YY_BREAK
01569 case 29:
01570 /* rule 29 can match eol */
01571 YY_RULE_SETUP
01572 #line 458 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01573 {
01574         //if(yyextra->serviceLocation == ""){
01575                 YY_PRINT 
01576                 //yyextra->serviceLocation = strdup(yytext);
01577                 yyextra->serviceLocation =  yytext;
01578                 //char *ch = strdup(yytext);
01579                 char *ch = yytext;
01580                 // move past -serviceLocation
01581                 ch+=16;
01582                 for(; isspace(*ch); ch++);
01583                 std::string str(  ch);
01584                 yyextra->serviceLocation = str; 
01585         //}
01586 }
01587         YY_BREAK
01588 case 30:
01589 /* rule 30 can match eol */
01590 YY_RULE_SETUP
01591 #line 475 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01592 {
01593                         // if(yyextra->serviceLocation == ""){
01594                          YY_PRINT 
01595                          //yyextra->serviceLocation = strdup(yytext);
01596                          yyextra->serviceLocation =  yytext;
01597                          //char *ch = strdup(yytext);
01598                          char *ch = yytext;
01599                          // move past -serviceLocation
01600                          ch+=15;
01601                          for(; isspace(*ch); ch++);
01602                          std::string str(  ch);
01603                          yyextra->serviceLocation = str; 
01604                         // }
01605                          }
01606         YY_BREAK
01607 case 31:
01608 /* rule 31 can match eol */
01609 YY_RULE_SETUP
01610 #line 491 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01611 {
01612                         // if(yyextra->serviceLocation == ""){
01613                          YY_PRINT 
01614                          //yyextra->serviceLocation = strdup(yytext);
01615                          yyextra->serviceLocation =  yytext;
01616                          //char *ch = strdup(yytext);
01617                          char *ch = yytext;
01618                          // move past -serviceLocation
01619                          ch+=15;
01620                          for(; isspace(*ch); ch++);
01621                          std::string str(  ch);
01622                          yyextra->serviceLocation = str; 
01623                         // }
01624                          }
01625         YY_BREAK
01626 case 32:
01627 /* rule 32 can match eol */
01628 YY_RULE_SETUP
01629 #line 507 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01630 {
01631         //if(yyextra->mpsFile == ""){
01632                 YY_PRINT 
01633                 //char *ch = strdup(yytext);
01634                 char *ch = yytext;
01635                 // move past -mps
01636                 ch+=4;
01637                 for(; isspace(*ch); ch++);
01638                 std::string str(  ch);
01639                 yyextra->mpsFile = str; 
01640         //}
01641 }
01642         YY_BREAK
01643 case 33:
01644 /* rule 33 can match eol */
01645 YY_RULE_SETUP
01646 #line 523 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01647 {
01648                         // if(yyextra->mpsFile == ""){
01649                          YY_PRINT 
01650                          //char *ch = strdup(yytext);
01651                          char *ch = yytext;
01652                          // move past -mps
01653                          ch+=3;
01654                          for(; isspace(*ch); ch++);
01655                          std::string str(  ch);
01656                          yyextra->mpsFile = str; 
01657                         // }
01658                          }
01659         YY_BREAK
01660 case 34:
01661 /* rule 34 can match eol */
01662 YY_RULE_SETUP
01663 #line 538 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01664 {
01665                         // if(yyextra->mpsFile == ""){
01666                          YY_PRINT 
01667                          //char *ch = strdup(yytext);
01668                          char *ch = yytext;
01669                          // move past -mps
01670                          ch+=3;
01671                          for(; isspace(*ch); ch++);
01672                          std::string str(  ch);
01673                          yyextra->mpsFile = str; 
01674                         // }
01675                          }
01676         YY_BREAK
01677 case 35:
01678 /* rule 35 can match eol */
01679 YY_RULE_SETUP
01680 #line 551 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01681 {
01682         //if(yyextra->nlFile == ""){
01683                 YY_PRINT
01684                 //char *ch = strdup(yytext);
01685                 char *ch = yytext;
01686                 // move past -nl
01687                 ch+=3;
01688                 for(; isspace(*ch); ch++);
01689                 std::string str(  ch);
01690                 yyextra->nlFile = str; 
01691         //} 
01692 }
01693         YY_BREAK
01694 case 36:
01695 /* rule 36 can match eol */
01696 YY_RULE_SETUP
01697 #line 567 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01698 {
01699                         // if(yyextra->nlFile == ""){
01700                          YY_PRINT
01701                          //char *ch = strdup(yytext);
01702                          char *ch = yytext;
01703                          // move past -nl
01704                          ch+=2;
01705                          for(; isspace(*ch); ch++);
01706                          std::string str(  ch);
01707                          yyextra->nlFile = str; 
01708                         // } 
01709                          }
01710         YY_BREAK
01711 case 37:
01712 /* rule 37 can match eol */
01713 YY_RULE_SETUP
01714 #line 581 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01715 {
01716                         // if(yyextra->nlFile == ""){
01717                          YY_PRINT
01718                          //char *ch = strdup(yytext);
01719                          char *ch = yytext;
01720                          // move past -nl
01721                          ch+=2;
01722                          for(; isspace(*ch); ch++);
01723                          std::string str(  ch);
01724                          yyextra->nlFile = str; 
01725                         // } 
01726                          }
01727         YY_BREAK
01728 case 38:
01729 /* rule 38 can match eol */
01730 YY_RULE_SETUP
01731 #line 597 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01732 {
01733         //if(yyextra->gamsControlFile == ""){
01734                 YY_PRINT
01735                 //char *ch = strdup(yytext);
01736                 char *ch = yytext;
01737                 // move past -dat
01738                 ch+=4;
01739                 for(; isspace(*ch); ch++);
01740                 std::string str(  ch);
01741                 yyextra->gamsControlFile = str;
01742         //} 
01743 }
01744         YY_BREAK
01745 case 39:
01746 /* rule 39 can match eol */
01747 YY_RULE_SETUP
01748 #line 612 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01749 {
01750                         // if(yyextra->gamsControlFile == ""){
01751                          YY_PRINT
01752                          //char *ch = strdup(yytext);
01753                          char *ch = yytext;
01754                          // move past -dat
01755                          ch+=3;
01756                          for(; isspace(*ch); ch++);
01757                          std::string str(  ch);
01758                          yyextra->gamsControlFile = str;
01759                         // } 
01760                          }
01761         YY_BREAK
01762 case 40:
01763 /* rule 40 can match eol */
01764 YY_RULE_SETUP
01765 #line 625 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01766 {
01767                          //if(yyextra->gamsControlFile == ""){
01768                          YY_PRINT
01769                          //char *ch = strdup(yytext);
01770                          char *ch = yytext;
01771                          // move past -dat
01772                          ch+=3;
01773                          for(; isspace(*ch); ch++);
01774                          std::string str(  ch);
01775                          yyextra->gamsControlFile = str;
01776                         // } 
01777                          }
01778         YY_BREAK
01779 case 41:
01780 /* rule 41 can match eol */
01781 YY_RULE_SETUP
01782 #line 638 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01783 {
01784         //if(yyextra->solverName == ""){
01785                 YY_PRINT 
01786                 //char *ch = strdup(yytext);
01787                 char *ch = yytext;
01788                 // move past -solver
01789                 ch+=7;
01790                 for(; isspace(*ch); ch++);
01791                 std::string str(  ch);
01792                 yyextra->solverName = str;
01793         //} 
01794 }
01795         YY_BREAK
01796 case 42:
01797 /* rule 42 can match eol */
01798 YY_RULE_SETUP
01799 #line 652 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01800 {
01801                          //if(yyextra->solverName == ""){
01802                          YY_PRINT 
01803                          //char *ch = strdup(yytext);
01804                          char *ch = yytext;
01805                          // move past -solver
01806                          ch+=6;
01807                          for(; isspace(*ch); ch++);
01808                          std::string str(  ch);
01809                          yyextra->solverName = str;
01810                         // } 
01811                          }
01812         YY_BREAK
01813 case 43:
01814 /* rule 43 can match eol */
01815 YY_RULE_SETUP
01816 #line 665 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01817 {
01818                         // if(yyextra->solverName == ""){
01819                          YY_PRINT 
01820                          //char *ch = strdup(yytext);
01821                          char *ch = yytext;
01822                          // move past -solver
01823                          ch+=6;
01824                          for(; isspace(*ch); ch++);
01825                          std::string str(  ch);
01826                          yyextra->solverName = str;
01827                         // } 
01828                          }
01829         YY_BREAK
01830 case 44:
01831 /* rule 44 can match eol */
01832 YY_RULE_SETUP
01833 #line 678 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01834 {
01835         //if(yyextra->browser == ""){
01836                 YY_PRINT  
01837                 //char *ch = strdup(yytext);
01838                 char *ch = yytext;
01839                 // move past -browser
01840                 ch+=8;
01841                 for(; isspace(*ch); ch++);
01842                 std::string str(  ch);
01843                 yyextra->browser = str; 
01844         //}
01845 }
01846         YY_BREAK
01847 case 45:
01848 /* rule 45 can match eol */
01849 YY_RULE_SETUP
01850 #line 692 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01851 {
01852                         // if(yyextra->browser == ""){
01853                          YY_PRINT  
01854                          //char *ch = strdup(yytext);
01855                          char *ch = yytext;
01856                          // move past -browser
01857                          ch+=7;
01858                          for(; isspace(*ch); ch++);
01859                          std::string str(  ch);
01860                          yyextra->browser = str; 
01861                         // }
01862                          }
01863         YY_BREAK
01864 case 46:
01865 /* rule 46 can match eol */
01866 YY_RULE_SETUP
01867 #line 706 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01868 {
01869                         // if(yyextra->browser == ""){
01870                          YY_PRINT  
01871                          //char *ch = strdup(yytext);
01872                          char *ch = yytext;
01873                          // move past -browser
01874                          ch+=7;
01875                          for(; isspace(*ch); ch++);
01876                          std::string str(  ch);
01877                          yyextra->browser = str; 
01878                         // }
01879                          }
01880         YY_BREAK
01881 case 47:
01882 YY_RULE_SETUP
01883 #line 719 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01884 {
01885         std::string error;
01886         std::ostringstream outStr;
01887         outStr << "encountered a spurious character in the lexer" << endl;
01888         outStr << "Please make sure your options are spelled correctly" << endl;
01889         outStr << "Type OSSolverService -h or OSSolverService --help for valid commands" << endl;
01890         outStr << "The first character is: ";
01891         outStr <<  yytext;
01892         outStr << endl;
01893         //outStr << "See line number: " << yylineno << endl;  
01894         error = outStr.str();
01895         throw ErrorClass( error);  
01896 }
01897         YY_BREAK
01898 case 48:
01899 YY_RULE_SETUP
01900 #line 732 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01901 ECHO;
01902         YY_BREAK
01903 #line 1904 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
01904 case YY_STATE_EOF(INITIAL):
01905         yyterminate();
01906 
01907         case YY_END_OF_BUFFER:
01908                 {
01909                 /* Amount of text matched not including the EOB char. */
01910                 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
01911 
01912                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
01913                 *yy_cp = yyg->yy_hold_char;
01914                 YY_RESTORE_YY_MORE_OFFSET
01915 
01916                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
01917                         {
01918                         /* We're scanning a new file or input source.  It's
01919                          * possible that this happened because the user
01920                          * just pointed yyin at a new source and called
01921                          * ossslex().  If so, then we have to assure
01922                          * consistency between YY_CURRENT_BUFFER and our
01923                          * globals.  Here is the right place to do so, because
01924                          * this is the first action (other than possibly a
01925                          * back-up) that will match for the new input source.
01926                          */
01927                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
01928                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
01929                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
01930                         }
01931 
01932                 /* Note that here we test for yy_c_buf_p "<=" to the position
01933                  * of the first EOB in the buffer, since yy_c_buf_p will
01934                  * already have been incremented past the NUL character
01935                  * (since all states make transitions on EOB to the
01936                  * end-of-buffer state).  Contrast this with the test
01937                  * in input().
01938                  */
01939                 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
01940                         { /* This was really a NUL. */
01941                         yy_state_type yy_next_state;
01942 
01943                         yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
01944 
01945                         yy_current_state = yy_get_previous_state( yyscanner );
01946 
01947                         /* Okay, we're now positioned to make the NUL
01948                          * transition.  We couldn't have
01949                          * yy_get_previous_state() go ahead and do it
01950                          * for us because it doesn't know how to deal
01951                          * with the possibility of jamming (and we don't
01952                          * want to build jamming into it because then it
01953                          * will run more slowly).
01954                          */
01955 
01956                         yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
01957 
01958                         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
01959 
01960                         if ( yy_next_state )
01961                                 {
01962                                 /* Consume the NUL. */
01963                                 yy_cp = ++yyg->yy_c_buf_p;
01964                                 yy_current_state = yy_next_state;
01965                                 goto yy_match;
01966                                 }
01967 
01968                         else
01969                                 {
01970                                 yy_cp = yyg->yy_c_buf_p;
01971                                 goto yy_find_action;
01972                                 }
01973                         }
01974 
01975                 else switch ( yy_get_next_buffer( yyscanner ) )
01976                         {
01977                         case EOB_ACT_END_OF_FILE:
01978                                 {
01979                                 yyg->yy_did_buffer_switch_on_eof = 0;
01980 
01981                                 if ( ossswrap(yyscanner ) )
01982                                         {
01983                                         /* Note: because we've taken care in
01984                                          * yy_get_next_buffer() to have set up
01985                                          * yytext, we can now set up
01986                                          * yy_c_buf_p so that if some total
01987                                          * hoser (like flex itself) wants to
01988                                          * call the scanner after we return the
01989                                          * YY_NULL, it'll still work - another
01990                                          * YY_NULL will get returned.
01991                                          */
01992                                         yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
01993 
01994                                         yy_act = YY_STATE_EOF(YY_START);
01995                                         goto do_action;
01996                                         }
01997 
01998                                 else
01999                                         {
02000                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
02001                                                 YY_NEW_FILE;
02002                                         }
02003                                 break;
02004                                 }
02005 
02006                         case EOB_ACT_CONTINUE_SCAN:
02007                                 yyg->yy_c_buf_p =
02008                                         yyg->yytext_ptr + yy_amount_of_matched_text;
02009 
02010                                 yy_current_state = yy_get_previous_state( yyscanner );
02011 
02012                                 yy_cp = yyg->yy_c_buf_p;
02013                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
02014                                 goto yy_match;
02015 
02016                         case EOB_ACT_LAST_MATCH:
02017                                 yyg->yy_c_buf_p =
02018                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
02019 
02020                                 yy_current_state = yy_get_previous_state( yyscanner );
02021 
02022                                 yy_cp = yyg->yy_c_buf_p;
02023                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
02024                                 goto yy_find_action;
02025                         }
02026                 break;
02027                 }
02028 
02029         default:
02030                 YY_FATAL_ERROR(
02031                         "fatal flex scanner internal error--no action found" );
02032         } /* end of action switch */
02033                 } /* end of scanning one token */
02034 } /* end of ossslex */
02035 
02036 /* yy_get_next_buffer - try to read in a new buffer
02037  *
02038  * Returns a code representing an action:
02039  *      EOB_ACT_LAST_MATCH -
02040  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
02041  *      EOB_ACT_END_OF_FILE - end of file
02042  */
02043 static int yy_get_next_buffer (yyscan_t yyscanner)
02044 {
02045     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02046         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
02047         register char *source = yyg->yytext_ptr;
02048         register int number_to_move, i;
02049         int ret_val;
02050 
02051         if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
02052                 YY_FATAL_ERROR(
02053                 "fatal flex scanner internal error--end of buffer missed" );
02054 
02055         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
02056                 { /* Don't try to fill the buffer, so this is an EOF. */
02057                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
02058                         {
02059                         /* We matched a single character, the EOB, so
02060                          * treat this as a final EOF.
02061                          */
02062                         return EOB_ACT_END_OF_FILE;
02063                         }
02064 
02065                 else
02066                         {
02067                         /* We matched some text prior to the EOB, first
02068                          * process it.
02069                          */
02070                         return EOB_ACT_LAST_MATCH;
02071                         }
02072                 }
02073 
02074         /* Try to read more data. */
02075 
02076         /* First move last chars to start of buffer. */
02077         number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
02078 
02079         for ( i = 0; i < number_to_move; ++i )
02080                 *(dest++) = *(source++);
02081 
02082         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
02083                 /* don't do the read, it's not guaranteed to return an EOF,
02084                  * just force an EOF
02085                  */
02086                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
02087 
02088         else
02089                 {
02090                         int num_to_read =
02091                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
02092 
02093                 while ( num_to_read <= 0 )
02094                         { /* Not enough room in the buffer - grow it. */
02095 
02096                         /* just a shorter name for the current buffer */
02097                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
02098 
02099                         int yy_c_buf_p_offset =
02100                                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
02101 
02102                         if ( b->yy_is_our_buffer )
02103                                 {
02104                                 int new_size = b->yy_buf_size * 2;
02105 
02106                                 if ( new_size <= 0 )
02107                                         b->yy_buf_size += b->yy_buf_size / 8;
02108                                 else
02109                                         b->yy_buf_size *= 2;
02110 
02111                                 b->yy_ch_buf = (char *)
02112                                         /* Include room in for 2 EOB chars. */
02113                                         osssrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
02114                                 }
02115                         else
02116                                 /* Can't grow it, we don't own it. */
02117                                 b->yy_ch_buf = 0;
02118 
02119                         if ( ! b->yy_ch_buf )
02120                                 YY_FATAL_ERROR(
02121                                 "fatal error - scanner input buffer overflow" );
02122 
02123                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
02124 
02125                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
02126                                                 number_to_move - 1;
02127 
02128                         }
02129 
02130                 if ( num_to_read > YY_READ_BUF_SIZE )
02131                         num_to_read = YY_READ_BUF_SIZE;
02132 
02133                 /* Read in more data. */
02134                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
02135                         yyg->yy_n_chars, (size_t) num_to_read );
02136 
02137                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
02138                 }
02139 
02140         if ( yyg->yy_n_chars == 0 )
02141                 {
02142                 if ( number_to_move == YY_MORE_ADJ )
02143                         {
02144                         ret_val = EOB_ACT_END_OF_FILE;
02145                         osssrestart(yyin  ,yyscanner);
02146                         }
02147 
02148                 else
02149                         {
02150                         ret_val = EOB_ACT_LAST_MATCH;
02151                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
02152                                 YY_BUFFER_EOF_PENDING;
02153                         }
02154                 }
02155 
02156         else
02157                 ret_val = EOB_ACT_CONTINUE_SCAN;
02158 
02159         if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
02160                 /* Extend the array by 50%, plus the number we really need. */
02161                 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
02162                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) osssrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
02163                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
02164                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
02165         }
02166 
02167         yyg->yy_n_chars += number_to_move;
02168         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
02169         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
02170 
02171         yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
02172 
02173         return ret_val;
02174 }
02175 
02176 /* yy_get_previous_state - get the state just before the EOB char was reached */
02177 
02178     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
02179 {
02180         register yy_state_type yy_current_state;
02181         register char *yy_cp;
02182     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02183 
02184         yy_current_state = yyg->yy_start;
02185 
02186         for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
02187                 {
02188                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
02189                 if ( yy_accept[yy_current_state] )
02190                         {
02191                         yyg->yy_last_accepting_state = yy_current_state;
02192                         yyg->yy_last_accepting_cpos = yy_cp;
02193                         }
02194                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
02195                         {
02196                         yy_current_state = (int) yy_def[yy_current_state];
02197                         if ( yy_current_state >= 358 )
02198                                 yy_c = yy_meta[(unsigned int) yy_c];
02199                         }
02200                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
02201                 }
02202 
02203         return yy_current_state;
02204 }
02205 
02206 /* yy_try_NUL_trans - try to make a transition on the NUL character
02207  *
02208  * synopsis
02209  *      next_state = yy_try_NUL_trans( current_state );
02210  */
02211     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
02212 {
02213         register int yy_is_jam;
02214     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
02215         register char *yy_cp = yyg->yy_c_buf_p;
02216 
02217         register YY_CHAR yy_c = 1;
02218         if ( yy_accept[yy_current_state] )
02219                 {
02220                 yyg->yy_last_accepting_state = yy_current_state;
02221                 yyg->yy_last_accepting_cpos = yy_cp;
02222                 }
02223         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
02224                 {
02225                 yy_current_state = (int) yy_def[yy_current_state];
02226                 if ( yy_current_state >= 358 )
02227                         yy_c = yy_meta[(unsigned int) yy_c];
02228                 }
02229         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
02230         yy_is_jam = (yy_current_state == 357);
02231 
02232         return yy_is_jam ? 0 : yy_current_state;
02233 }
02234 
02235 #ifndef YY_NO_INPUT
02236 #ifdef __cplusplus
02237     static int yyinput (yyscan_t yyscanner)
02238 #else
02239     static int input  (yyscan_t yyscanner)
02240 #endif
02241 
02242 {
02243         int c;
02244     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02245 
02246         *yyg->yy_c_buf_p = yyg->yy_hold_char;
02247 
02248         if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
02249                 {
02250                 /* yy_c_buf_p now points to the character we want to return.
02251                  * If this occurs *before* the EOB characters, then it's a
02252                  * valid NUL; if not, then we've hit the end of the buffer.
02253                  */
02254                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
02255                         /* This was really a NUL. */
02256                         *yyg->yy_c_buf_p = '\0';
02257 
02258                 else
02259                         { /* need more input */
02260                         int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
02261                         ++yyg->yy_c_buf_p;
02262 
02263                         switch ( yy_get_next_buffer( yyscanner ) )
02264                                 {
02265                                 case EOB_ACT_LAST_MATCH:
02266                                         /* This happens because yy_g_n_b()
02267                                          * sees that we've accumulated a
02268                                          * token and flags that we need to
02269                                          * try matching the token before
02270                                          * proceeding.  But for input(),
02271                                          * there's no matching to consider.
02272                                          * So convert the EOB_ACT_LAST_MATCH
02273                                          * to EOB_ACT_END_OF_FILE.
02274                                          */
02275 
02276                                         /* Reset buffer status. */
02277                                         osssrestart(yyin ,yyscanner);
02278 
02279                                         /*FALLTHROUGH*/
02280 
02281                                 case EOB_ACT_END_OF_FILE:
02282                                         {
02283                                         if ( ossswrap(yyscanner ) )
02284                                                 return EOF;
02285 
02286                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
02287                                                 YY_NEW_FILE;
02288 #ifdef __cplusplus
02289                                         return yyinput(yyscanner);
02290 #else
02291                                         return input(yyscanner);
02292 #endif
02293                                         }
02294 
02295                                 case EOB_ACT_CONTINUE_SCAN:
02296                                         yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
02297                                         break;
02298                                 }
02299                         }
02300                 }
02301 
02302         c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
02303         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
02304         yyg->yy_hold_char = *++yyg->yy_c_buf_p;
02305 
02306         if ( c == '\n' )
02307                    
02308     do{ yylineno++;
02309         yycolumn=0;
02310     }while(0)
02311 ;
02312 
02313         return c;
02314 }
02315 #endif  /* ifndef YY_NO_INPUT */
02316 
02322     void osssrestart  (FILE * input_file , yyscan_t yyscanner)
02323 {
02324     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02325 
02326         if ( ! YY_CURRENT_BUFFER ){
02327         osssensure_buffer_stack (yyscanner);
02328                 YY_CURRENT_BUFFER_LVALUE =
02329             osss_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
02330         }
02331 
02332         osss_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
02333         osss_load_buffer_state(yyscanner );
02334 }
02335 
02340     void osss_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
02341 {
02342     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02343 
02344         /* TODO. We should be able to replace this entire function body
02345          * with
02346          *              ossspop_buffer_state();
02347          *              ossspush_buffer_state(new_buffer);
02348      */
02349         osssensure_buffer_stack (yyscanner);
02350         if ( YY_CURRENT_BUFFER == new_buffer )
02351                 return;
02352 
02353         if ( YY_CURRENT_BUFFER )
02354                 {
02355                 /* Flush out information for old buffer. */
02356                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
02357                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
02358                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
02359                 }
02360 
02361         YY_CURRENT_BUFFER_LVALUE = new_buffer;
02362         osss_load_buffer_state(yyscanner );
02363 
02364         /* We don't actually know whether we did this switch during
02365          * EOF (ossswrap()) processing, but the only time this flag
02366          * is looked at is after ossswrap() is called, so it's safe
02367          * to go ahead and always set it.
02368          */
02369         yyg->yy_did_buffer_switch_on_eof = 1;
02370 }
02371 
02372 static void osss_load_buffer_state  (yyscan_t yyscanner)
02373 {
02374     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02375         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
02376         yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
02377         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
02378         yyg->yy_hold_char = *yyg->yy_c_buf_p;
02379 }
02380 
02387     YY_BUFFER_STATE osss_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
02388 {
02389         YY_BUFFER_STATE b;
02390     
02391         b = (YY_BUFFER_STATE) osssalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
02392         if ( ! b )
02393                 YY_FATAL_ERROR( "out of dynamic memory in osss_create_buffer()" );
02394 
02395         b->yy_buf_size = size;
02396 
02397         /* yy_ch_buf has to be 2 characters longer than the size given because
02398          * we need to put in 2 end-of-buffer characters.
02399          */
02400         b->yy_ch_buf = (char *) osssalloc(b->yy_buf_size + 2 ,yyscanner );
02401         if ( ! b->yy_ch_buf )
02402                 YY_FATAL_ERROR( "out of dynamic memory in osss_create_buffer()" );
02403 
02404         b->yy_is_our_buffer = 1;
02405 
02406         osss_init_buffer(b,file ,yyscanner);
02407 
02408         return b;
02409 }
02410 
02415     void osss_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
02416 {
02417     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02418 
02419         if ( ! b )
02420                 return;
02421 
02422         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
02423                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
02424 
02425         if ( b->yy_is_our_buffer )
02426                 osssfree((void *) b->yy_ch_buf ,yyscanner );
02427 
02428         osssfree((void *) b ,yyscanner );
02429 }
02430 
02431 #ifndef __cplusplus
02432 extern int isatty (int );
02433 #endif /* __cplusplus */
02434     
02435 /* Initializes or reinitializes a buffer.
02436  * This function is sometimes called more than once on the same buffer,
02437  * such as during a osssrestart() or at EOF.
02438  */
02439     static void osss_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
02440 
02441 {
02442         int oerrno = errno;
02443     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02444 
02445         osss_flush_buffer(b ,yyscanner);
02446 
02447         b->yy_input_file = file;
02448         b->yy_fill_buffer = 1;
02449 
02450     /* If b is the current buffer, then osss_init_buffer was _probably_
02451      * called from osssrestart() or through yy_get_next_buffer.
02452      * In that case, we don't want to reset the lineno or column.
02453      */
02454     if (b != YY_CURRENT_BUFFER){
02455         b->yy_bs_lineno = 1;
02456         b->yy_bs_column = 0;
02457     }
02458 
02459         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
02460     
02461         errno = oerrno;
02462 }
02463 
02468     void osss_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
02469 {
02470     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02471         if ( ! b )
02472                 return;
02473 
02474         b->yy_n_chars = 0;
02475 
02476         /* We always need two end-of-buffer characters.  The first causes
02477          * a transition to the end-of-buffer state.  The second causes
02478          * a jam in that state.
02479          */
02480         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
02481         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
02482 
02483         b->yy_buf_pos = &b->yy_ch_buf[0];
02484 
02485         b->yy_at_bol = 1;
02486         b->yy_buffer_status = YY_BUFFER_NEW;
02487 
02488         if ( b == YY_CURRENT_BUFFER )
02489                 osss_load_buffer_state(yyscanner );
02490 }
02491 
02498 void ossspush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
02499 {
02500     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02501         if (new_buffer == NULL)
02502                 return;
02503 
02504         osssensure_buffer_stack(yyscanner);
02505 
02506         /* This block is copied from osss_switch_to_buffer. */
02507         if ( YY_CURRENT_BUFFER )
02508                 {
02509                 /* Flush out information for old buffer. */
02510                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
02511                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
02512                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
02513                 }
02514 
02515         /* Only push if top exists. Otherwise, replace top. */
02516         if (YY_CURRENT_BUFFER)
02517                 yyg->yy_buffer_stack_top++;
02518         YY_CURRENT_BUFFER_LVALUE = new_buffer;
02519 
02520         /* copied from osss_switch_to_buffer. */
02521         osss_load_buffer_state(yyscanner );
02522         yyg->yy_did_buffer_switch_on_eof = 1;
02523 }
02524 
02529 void ossspop_buffer_state (yyscan_t yyscanner)
02530 {
02531     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02532         if (!YY_CURRENT_BUFFER)
02533                 return;
02534 
02535         osss_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
02536         YY_CURRENT_BUFFER_LVALUE = NULL;
02537         if (yyg->yy_buffer_stack_top > 0)
02538                 --yyg->yy_buffer_stack_top;
02539 
02540         if (YY_CURRENT_BUFFER) {
02541                 osss_load_buffer_state(yyscanner );
02542                 yyg->yy_did_buffer_switch_on_eof = 1;
02543         }
02544 }
02545 
02546 /* Allocates the stack if it does not exist.
02547  *  Guarantees space for at least one push.
02548  */
02549 static void osssensure_buffer_stack (yyscan_t yyscanner)
02550 {
02551         int num_to_alloc;
02552     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02553 
02554         if (!yyg->yy_buffer_stack) {
02555 
02556                 /* First allocation is just for 2 elements, since we don't know if this
02557                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
02558                  * immediate realloc on the next call.
02559          */
02560                 num_to_alloc = 1;
02561                 yyg->yy_buffer_stack = (struct yy_buffer_state**)osssalloc
02562                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
02563                                                                 , yyscanner);
02564                 if ( ! yyg->yy_buffer_stack )
02565                         YY_FATAL_ERROR( "out of dynamic memory in osssensure_buffer_stack()" );
02566                                                                   
02567                 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
02568                                 
02569                 yyg->yy_buffer_stack_max = num_to_alloc;
02570                 yyg->yy_buffer_stack_top = 0;
02571                 return;
02572         }
02573 
02574         if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
02575 
02576                 /* Increase the buffer to prepare for a possible push. */
02577                 int grow_size = 8 /* arbitrary grow size */;
02578 
02579                 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
02580                 yyg->yy_buffer_stack = (struct yy_buffer_state**)osssrealloc
02581                                                                 (yyg->yy_buffer_stack,
02582                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
02583                                                                 , yyscanner);
02584                 if ( ! yyg->yy_buffer_stack )
02585                         YY_FATAL_ERROR( "out of dynamic memory in osssensure_buffer_stack()" );
02586 
02587                 /* zero only the new slots.*/
02588                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
02589                 yyg->yy_buffer_stack_max = num_to_alloc;
02590         }
02591 }
02592 
02599 YY_BUFFER_STATE osss_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
02600 {
02601         YY_BUFFER_STATE b;
02602     
02603         if ( size < 2 ||
02604              base[size-2] != YY_END_OF_BUFFER_CHAR ||
02605              base[size-1] != YY_END_OF_BUFFER_CHAR )
02606                 /* They forgot to leave room for the EOB's. */
02607                 return 0;
02608 
02609         b = (YY_BUFFER_STATE) osssalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
02610         if ( ! b )
02611                 YY_FATAL_ERROR( "out of dynamic memory in osss_scan_buffer()" );
02612 
02613         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
02614         b->yy_buf_pos = b->yy_ch_buf = base;
02615         b->yy_is_our_buffer = 0;
02616         b->yy_input_file = 0;
02617         b->yy_n_chars = b->yy_buf_size;
02618         b->yy_is_interactive = 0;
02619         b->yy_at_bol = 1;
02620         b->yy_fill_buffer = 0;
02621         b->yy_buffer_status = YY_BUFFER_NEW;
02622 
02623         osss_switch_to_buffer(b ,yyscanner );
02624 
02625         return b;
02626 }
02627 
02636 YY_BUFFER_STATE osss_scan_string (yyconst char * yystr , yyscan_t yyscanner)
02637 {
02638     
02639         return osss_scan_bytes(yystr,strlen(yystr) ,yyscanner);
02640 }
02641 
02649 YY_BUFFER_STATE osss_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
02650 {
02651         YY_BUFFER_STATE b;
02652         char *buf;
02653         yy_size_t n;
02654         int i;
02655     
02656         /* Get memory for full buffer, including space for trailing EOB's. */
02657         n = _yybytes_len + 2;
02658         buf = (char *) osssalloc(n ,yyscanner );
02659         if ( ! buf )
02660                 YY_FATAL_ERROR( "out of dynamic memory in osss_scan_bytes()" );
02661 
02662         for ( i = 0; i < _yybytes_len; ++i )
02663                 buf[i] = yybytes[i];
02664 
02665         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
02666 
02667         b = osss_scan_buffer(buf,n ,yyscanner);
02668         if ( ! b )
02669                 YY_FATAL_ERROR( "bad buffer in osss_scan_bytes()" );
02670 
02671         /* It's okay to grow etc. this buffer, and we should throw it
02672          * away when we're done.
02673          */
02674         b->yy_is_our_buffer = 1;
02675 
02676         return b;
02677 }
02678 
02679 #ifndef YY_EXIT_FAILURE
02680 #define YY_EXIT_FAILURE 2
02681 #endif
02682 
02683 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
02684 {
02685         (void) fprintf( stderr, "%s\n", msg );
02686         exit( YY_EXIT_FAILURE );
02687 }
02688 
02689 /* Redefine yyless() so it works in section 3 code. */
02690 
02691 #undef yyless
02692 #define yyless(n) \
02693         do \
02694                 { \
02695                 /* Undo effects of setting up yytext. */ \
02696         int yyless_macro_arg = (n); \
02697         YY_LESS_LINENO(yyless_macro_arg);\
02698                 yytext[yyleng] = yyg->yy_hold_char; \
02699                 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
02700                 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
02701                 *yyg->yy_c_buf_p = '\0'; \
02702                 yyleng = yyless_macro_arg; \
02703                 } \
02704         while ( 0 )
02705 
02706 /* Accessor  methods (get/set functions) to struct members. */
02707 
02711 YY_EXTRA_TYPE osssget_extra  (yyscan_t yyscanner)
02712 {
02713     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02714     return yyextra;
02715 }
02716 
02720 int osssget_lineno  (yyscan_t yyscanner)
02721 {
02722     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02723     
02724         if (! YY_CURRENT_BUFFER)
02725             return 0;
02726     
02727     return yylineno;
02728 }
02729 
02733 int osssget_column  (yyscan_t yyscanner)
02734 {
02735     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02736     
02737         if (! YY_CURRENT_BUFFER)
02738             return 0;
02739     
02740     return yycolumn;
02741 }
02742 
02746 FILE *osssget_in  (yyscan_t yyscanner)
02747 {
02748     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02749     return yyin;
02750 }
02751 
02755 FILE *osssget_out  (yyscan_t yyscanner)
02756 {
02757     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02758     return yyout;
02759 }
02760 
02764 int osssget_leng  (yyscan_t yyscanner)
02765 {
02766     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02767     return yyleng;
02768 }
02769 
02774 char *osssget_text  (yyscan_t yyscanner)
02775 {
02776     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02777     return yytext;
02778 }
02779 
02784 void osssset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
02785 {
02786     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02787     yyextra = user_defined ;
02788 }
02789 
02794 void osssset_lineno (int  line_number , yyscan_t yyscanner)
02795 {
02796     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02797 
02798         /* lineno is only valid if an input buffer exists. */
02799         if (! YY_CURRENT_BUFFER )
02800            yy_fatal_error( "osssset_lineno called with no buffer" , yyscanner); 
02801     
02802     yylineno = line_number;
02803 }
02804 
02809 void osssset_column (int  column_no , yyscan_t yyscanner)
02810 {
02811     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02812 
02813         /* column is only valid if an input buffer exists. */
02814         if (! YY_CURRENT_BUFFER )
02815            yy_fatal_error( "osssset_column called with no buffer" , yyscanner); 
02816     
02817     yycolumn = column_no;
02818 }
02819 
02826 void osssset_in (FILE *  in_str , yyscan_t yyscanner)
02827 {
02828     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02829     yyin = in_str ;
02830 }
02831 
02832 void osssset_out (FILE *  out_str , yyscan_t yyscanner)
02833 {
02834     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02835     yyout = out_str ;
02836 }
02837 
02838 int osssget_debug  (yyscan_t yyscanner)
02839 {
02840     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02841     return yy_flex_debug;
02842 }
02843 
02844 void osssset_debug (int  bdebug , yyscan_t yyscanner)
02845 {
02846     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02847     yy_flex_debug = bdebug ;
02848 }
02849 
02850 /* Accessor methods for yylval and yylloc */
02851 
02852 /* User-visible API */
02853 
02854 /* ossslex_init is special because it creates the scanner itself, so it is
02855  * the ONLY reentrant function that doesn't take the scanner as the last argument.
02856  * That's why we explicitly handle the declaration, instead of using our macros.
02857  */
02858 
02859 int ossslex_init(yyscan_t* ptr_yy_globals)
02860 
02861 {
02862     if (ptr_yy_globals == NULL){
02863         errno = EINVAL;
02864         return 1;
02865     }
02866 
02867     *ptr_yy_globals = (yyscan_t) osssalloc ( sizeof( struct yyguts_t ), NULL );
02868 
02869     if (*ptr_yy_globals == NULL){
02870         errno = ENOMEM;
02871         return 1;
02872     }
02873 
02874     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
02875     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
02876 
02877     return yy_init_globals ( *ptr_yy_globals );
02878 }
02879 
02880 /* ossslex_init_extra has the same functionality as ossslex_init, but follows the
02881  * convention of taking the scanner as the last argument. Note however, that
02882  * this is a *pointer* to a scanner, as it will be allocated by this call (and
02883  * is the reason, too, why this function also must handle its own declaration).
02884  * The user defined value in the first argument will be available to osssalloc in
02885  * the yyextra field.
02886  */
02887 
02888 int ossslex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
02889 
02890 {
02891     struct yyguts_t dummy_yyguts;
02892 
02893     osssset_extra (yy_user_defined, &dummy_yyguts);
02894 
02895     if (ptr_yy_globals == NULL){
02896         errno = EINVAL;
02897         return 1;
02898     }
02899         
02900     *ptr_yy_globals = (yyscan_t) osssalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
02901         
02902     if (*ptr_yy_globals == NULL){
02903         errno = ENOMEM;
02904         return 1;
02905     }
02906     
02907     /* By setting to 0xAA, we expose bugs in
02908     yy_init_globals. Leave at 0x00 for releases. */
02909     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
02910     
02911     osssset_extra (yy_user_defined, *ptr_yy_globals);
02912     
02913     return yy_init_globals ( *ptr_yy_globals );
02914 }
02915 
02916 static int yy_init_globals (yyscan_t yyscanner)
02917 {
02918     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02919     /* Initialization is the same as for the non-reentrant scanner.
02920      * This function is called from ossslex_destroy(), so don't allocate here.
02921      */
02922 
02923     yyg->yy_buffer_stack = 0;
02924     yyg->yy_buffer_stack_top = 0;
02925     yyg->yy_buffer_stack_max = 0;
02926     yyg->yy_c_buf_p = (char *) 0;
02927     yyg->yy_init = 0;
02928     yyg->yy_start = 0;
02929 
02930     yyg->yy_start_stack_ptr = 0;
02931     yyg->yy_start_stack_depth = 0;
02932     yyg->yy_start_stack =  NULL;
02933 
02934 /* Defined in main.c */
02935 #ifdef YY_STDINIT
02936     yyin = stdin;
02937     yyout = stdout;
02938 #else
02939     yyin = (FILE *) 0;
02940     yyout = (FILE *) 0;
02941 #endif
02942 
02943     /* For future reference: Set errno on error, since we are called by
02944      * ossslex_init()
02945      */
02946     return 0;
02947 }
02948 
02949 /* ossslex_destroy is for both reentrant and non-reentrant scanners. */
02950 int ossslex_destroy  (yyscan_t yyscanner)
02951 {
02952     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02953 
02954     /* Pop the buffer stack, destroying each element. */
02955         while(YY_CURRENT_BUFFER){
02956                 osss_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
02957                 YY_CURRENT_BUFFER_LVALUE = NULL;
02958                 ossspop_buffer_state(yyscanner);
02959         }
02960 
02961         /* Destroy the stack itself. */
02962         osssfree(yyg->yy_buffer_stack ,yyscanner);
02963         yyg->yy_buffer_stack = NULL;
02964 
02965     /* Destroy the start condition stack. */
02966         osssfree(yyg->yy_start_stack ,yyscanner );
02967         yyg->yy_start_stack = NULL;
02968 
02969     /* Reset the globals. This is important in a non-reentrant scanner so the next time
02970      * ossslex() is called, initialization will occur. */
02971     yy_init_globals( yyscanner);
02972 
02973     /* Destroy the main struct (reentrant only). */
02974     osssfree ( yyscanner , yyscanner );
02975     yyscanner = NULL;
02976     return 0;
02977 }
02978 
02979 /*
02980  * Internal utility routines.
02981  */
02982 
02983 #ifndef yytext_ptr
02984 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
02985 {
02986         register int i;
02987         for ( i = 0; i < n; ++i )
02988                 s1[i] = s2[i];
02989 }
02990 #endif
02991 
02992 #ifdef YY_NEED_STRLEN
02993 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
02994 {
02995         register int n;
02996         for ( n = 0; s[n]; ++n )
02997                 ;
02998 
02999         return n;
03000 }
03001 #endif
03002 
03003 void *osssalloc (yy_size_t  size , yyscan_t yyscanner)
03004 {
03005         return (void *) malloc( size );
03006 }
03007 
03008 void *osssrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
03009 {
03010         /* The cast to (char *) in the following accommodates both
03011          * implementations that use char* generic pointers, and those
03012          * that use void* generic pointers.  It works with the latter
03013          * because both ANSI C and C++ allow castless assignment from
03014          * any pointer type to void*, and deal with argument conversions
03015          * as though doing an assignment.
03016          */
03017         return (void *) realloc( (char *) ptr, size );
03018 }
03019 
03020 void osssfree (void * ptr , yyscan_t yyscanner)
03021 {
03022         free( (char *) ptr );   /* see osssrealloc() for (char *) cast */
03023 }
03024 
03025 #define YYTABLES_NAME "yytables"
03026 
03027 #line 732 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
03028 
03029 
03030 
03031 void setyyextra(osOptionsStruc *osoptions, void* scanner){
03032         osssset_extra(osoptions, scanner);
03033 }
03034 
03035 
03036 

Generated on Thu Sep 22 03:06:04 2011 by  doxygen 1.4.7