/home/coin/SVN-release/OS-2.1.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 21
00375 #define YY_END_OF_BUFFER 22
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[192] =
00384     {   0,
00385         1,    1,   22,   20,    1,    1,   20,    1,    0,    0,
00386         0,    0,    4,    0,    0,    0,    0,    0,    6,    0,
00387         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00388         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00389         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00390         0,    0,   16,    0,    0,    0,    0,    0,    0,    3,
00391         0,    0,    0,    0,   17,    0,    0,   15,    0,   16,
00392         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00393         0,   17,    0,    0,   15,    0,    7,    0,   10,    0,
00394         0,    0,    8,    0,    0,    0,    0,    0,    0,    0,
00395 
00396         7,    0,   10,    0,    0,    0,    8,    0,    0,    5,
00397         0,    0,    2,    0,    0,    0,    0,    0,    0,   18,
00398         0,   19,    0,    2,    0,    9,    0,    0,    0,    0,
00399         0,   18,    0,   19,    0,    9,    0,    0,    0,    0,
00400         0,   11,    0,    0,    0,    0,   11,    0,   12,    0,
00401         0,    0,   12,    0,    0,    0,    0,    0,    0,    0,
00402         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00403        14,    0,    0,    0,    0,    0,    0,    0,   14,    0,
00404        13,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00405         0
00406 
00407     } ;
00408 
00409 static yyconst flex_int32_t yy_ec[256] =
00410     {   0,
00411         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
00412         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
00413         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00414         1,    2,    1,    4,    1,    5,    1,    1,    1,    1,
00415         1,    1,    1,    1,    6,    5,    5,    5,    5,    5,
00416         5,    5,    5,    5,    5,    5,    5,    5,    1,    1,
00417         1,    1,    1,    1,    5,    5,    5,    7,    5,    5,
00418         5,    5,    8,    9,    5,   10,   11,    5,   12,    5,
00419         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
00420         1,    1,    1,    1,    5,    1,   13,   14,   15,   16,
00421 
00422        17,   18,   19,   20,   21,    5,   22,   23,   24,   25,
00423        26,   27,    5,   28,   29,   30,   31,   32,   33,    5,
00424         5,    5,    1,    1,    1,    5,    1,    1,    1,    1,
00425         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00426         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00427         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00428         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00429         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00430         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00431         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00432 
00433         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00434         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00435         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00436         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00437         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00438         1,    1,    1,    1,    1
00439     } ;
00440 
00441 static yyconst flex_int32_t yy_meta[34] =
00442     {   0,
00443         1,    2,    2,    2,    2,    2,    2,    2,    2,    2,
00444         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
00445         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
00446         2,    2,    2
00447     } ;
00448 
00449 static yyconst flex_int16_t yy_base[219] =
00450     {   0,
00451         0,    2,  336,  337,    7,    9,    7,   12,    5,  307,
00452       308,  320,  337,  307,  304,  307,  300,    0,  337,  311,
00453       310,  300,  300,  294,  294,  293,   16,   14,  293,  297,
00454       296,  290,  284,  298,   27,  305,   41,   43,  291,  290,
00455       289,  288,  278,  277,  281,  278,  277,  284,   46,  283,
00456        49,   51,   54,   57,   59,    8,   61,  282,  285,  337,
00457       280,  283,  280,   62,   65,  269,   67,   70,   72,  337,
00458        75,   78,  272,  265,   81,  280,  266,  267,  264,   84,
00459        85,  337,  261,   87,  337,   89,   92,   94,   97,  263,
00460       259,   99,  102,  271,  105,  262,  107,  109,  112,  113,
00461 
00462       337,  115,  337,  255,  258,  117,  337,  112,  122,  337,
00463       125,  127,  130,  133,  254,  252,  256,  264,  135,  138,
00464       140,  143,  145,  337,  147,  150,  153,  250,  264,  248,
00465       154,  337,  156,  337,  158,  337,  161,  164,  264,  256,
00466       165,  168,  171,  245,  248,  173,  337,  175,  178,  252,
00467       256,  180,  337,  245,  183,  245,  185,  187,  252,   13,
00468       251,  174,  190,  237,  243,  239,  234,  238,  239,  192,
00469       195,  252,  237,  244,  230,  241,  224,  198,  337,  229,
00470       337,  232,  232,  235,  237,  233,  241,  216,  240,  229,
00471       337,  214,  243,  242,  241,  216,  218,  220,  210,  209,
00472 
00473       208,  222,  224,  226,  207,  206,  204,  228,  203,  230,
00474       232,  234,  201,  236,   22,  238,    5,  240
00475     } ;
00476 
00477 static yyconst flex_int16_t yy_def[219] =
00478     {   0,
00479       192,  192,  191,  191,  191,  191,  191,  191,  191,  191,
00480       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
00481       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
00482       191,  191,  191,  191,  191,  191,  191,  193,  191,  191,
00483       191,  191,  191,  191,  191,  191,  191,  191,  194,  191,
00484       195,  196,  193,  191,  191,  191,  191,  191,  191,  191,
00485       191,  191,  191,  197,  194,  191,  198,  195,  196,  191,
00486       199,  200,  191,  191,  201,  191,  191,  191,  191,  191,
00487       197,  191,  191,  198,  191,  202,  199,  203,  200,  191,
00488       191,  204,  201,  191,  191,  191,  191,  205,  191,  202,
00489 
00490       191,  203,  191,  191,  191,  204,  191,  191,  206,  191,
00491       207,  208,  205,  209,  191,  191,  191,  191,  210,  206,
00492       211,  207,  208,  191,  212,  209,  191,  191,  191,  191,
00493       210,  191,  211,  191,  212,  191,  213,  191,  191,  191,
00494       214,  213,  215,  191,  191,  214,  191,  216,  215,  191,
00495       191,  216,  191,  191,  191,  191,  191,  191,  191,  191,
00496       191,  191,  217,  191,  191,  191,  191,  191,  191,  218,
00497       217,  191,  191,  191,  191,  191,  191,  218,  191,  191,
00498       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
00499         0,  191,  191,  191,  191,  191,  191,  191,  191,  191,
00500 
00501       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
00502       191,  191,  191,  191,  191,  191,  191,  191
00503     } ;
00504 
00505 static yyconst flex_int16_t yy_nxt[371] =
00506     {   0,
00507       191,    5,    6,    5,    6,    7,  171,    7,    8,    8,
00508         8,    8,    9,    8,    8,   73,   29,   38,   38,   74,
00509        10,   11,   12,  149,   20,   30,   13,   14,   49,   49,
00510        15,   16,   17,  165,   39,   18,   21,  166,   19,   40,
00511        41,   42,   51,   51,   38,   38,   52,   49,   49,   64,
00512        51,   51,   67,   70,   70,  191,  191,  191,   71,   71,
00513        72,   72,   75,   75,   82,   82,  191,  191,  191,   85,
00514        85,  191,  191,  191,   70,   70,   71,   71,   86,   72,
00515        72,   88,   75,   75,   92,   98,   98,   82,   82,   85,
00516        85,  101,  101,  191,  191,  191,  103,  103,  191,  191,
00517 
00518       191,  107,  107,  191,  191,  191,  109,  109,  111,  111,
00519        98,   98,  112,  114,  114,  101,  101,  103,  103,  107,
00520       107,  117,  118,  109,  109,  119,  111,  111,  121,  124,
00521       124,  191,  191,  191,  114,  114,  125,  132,  132,  191,
00522       191,  191,  134,  134,  191,  191,  191,  124,  124,  136,
00523       136,  191,  191,  191,  137,  137,  132,  132,  134,  134,
00524       136,  136,  137,  137,  141,  143,  143,  147,  147,  191,
00525       191,  191,  143,  143,  148,  147,  147,  153,  153,  191,
00526       191,  191,  153,  153,  157,  157,  157,  157,  163,  163,
00527       168,  163,  163,  170,  179,  179,  191,  191,  191,  169,
00528 
00529       179,  179,  142,  159,  126,  122,  160,  120,  113,   93,
00530        89,   87,  161,  162,    4,    4,   69,   69,   81,   81,
00531        84,   84,  100,  100,  102,  102,  106,  106,  123,  123,
00532       131,  131,  133,  133,  135,  135,  146,  146,  152,  152,
00533       178,  178,   68,   65,   53,  181,  181,  190,  189,  188,
00534       187,  181,  186,  181,  185,  184,  181,  183,  182,  181,
00535       180,  177,  176,  175,  174,  173,  172,  167,  164,  158,
00536       156,  155,  154,  151,  150,  145,  144,  140,  139,  138,
00537       130,  129,  128,  127,  116,  115,  110,  108,  105,  104,
00538        99,   97,   96,   95,   94,   91,   90,   83,   80,   79,
00539 
00540        78,   77,   76,   66,   63,   62,   61,   60,   59,   58,
00541        57,   56,   55,   54,   50,   48,   47,   46,   45,   44,
00542        43,   37,   36,   35,   34,   33,   32,   31,   28,   27,
00543        26,   25,   24,   23,   22,  191,    3,  191,  191,  191,
00544       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
00545       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
00546       191,  191,  191,  191,  191,  191,  191,  191,  191,  191
00547     } ;
00548 
00549 static yyconst flex_int16_t yy_chk[371] =
00550     {   0,
00551         0,    1,    1,    2,    2,    1,  217,    2,    5,    5,
00552         6,    6,    7,    8,    8,   56,   18,   27,   27,   56,
00553         7,    7,    7,  215,    9,   18,    7,    7,   35,   35,
00554         7,    7,    7,  160,   28,    7,    9,  160,    7,   28,
00555        28,   28,   37,   37,   38,   38,   38,   49,   49,   49,
00556        51,   51,   51,   52,   52,   53,   53,   53,   54,   54,
00557        55,   55,   57,   57,   64,   64,   65,   65,   65,   67,
00558        67,   68,   68,   68,   69,   69,   71,   71,   71,   72,
00559        72,   72,   75,   75,   75,   80,   80,   81,   81,   84,
00560        84,   86,   86,   87,   87,   87,   88,   88,   89,   89,
00561 
00562        89,   92,   92,   93,   93,   93,   95,   95,   97,   97,
00563        98,   98,   98,   99,   99,  100,  100,  102,  102,  106,
00564       106,  108,  108,  109,  109,  109,  111,  111,  111,  112,
00565       112,  113,  113,  113,  114,  114,  114,  119,  119,  120,
00566       120,  120,  121,  121,  122,  122,  122,  123,  123,  125,
00567       125,  126,  126,  126,  127,  127,  131,  131,  133,  133,
00568       135,  135,  137,  137,  137,  138,  138,  141,  141,  142,
00569       142,  142,  143,  143,  143,  146,  146,  148,  148,  149,
00570       149,  149,  152,  152,  155,  155,  157,  157,  158,  158,
00571       162,  163,  163,  163,  170,  170,  171,  171,  171,  162,
00572 
00573       178,  178,  213,  157,  209,  207,  157,  206,  205,  201,
00574       200,  199,  157,  157,  192,  192,  196,  196,  197,  197,
00575       198,  198,  202,  202,  203,  203,  204,  204,  208,  208,
00576       210,  210,  211,  211,  212,  212,  214,  214,  216,  216,
00577       218,  218,  195,  194,  193,  190,  189,  188,  187,  186,
00578       185,  184,  183,  182,  180,  177,  176,  175,  174,  173,
00579       172,  169,  168,  167,  166,  165,  164,  161,  159,  156,
00580       154,  151,  150,  145,  144,  140,  139,  130,  129,  128,
00581       118,  117,  116,  115,  105,  104,   96,   94,   91,   90,
00582        83,   79,   78,   77,   76,   74,   73,   66,   63,   62,
00583 
00584        61,   59,   58,   50,   48,   47,   46,   45,   44,   43,
00585        42,   41,   40,   39,   36,   34,   33,   32,   31,   30,
00586        29,   26,   25,   24,   23,   22,   21,   20,   17,   16,
00587        15,   14,   12,   11,   10,    3,  191,  191,  191,  191,
00588       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
00589       191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
00590       191,  191,  191,  191,  191,  191,  191,  191,  191,  191
00591     } ;
00592 
00593 /* Table of booleans, true if rule could match eol. */
00594 static yyconst flex_int32_t yy_rule_can_match_eol[22] =
00595     {   0,
00596 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
00597     0, 0,     };
00598 
00599 /* The intent behind this definition is that it'll catch
00600  * any uses of REJECT which flex missed.
00601  */
00602 #define REJECT reject_used_but_not_detected
00603 #define yymore() yymore_used_but_not_detected
00604 #define YY_MORE_ADJ 0
00605 #define YY_RESTORE_YY_MORE_OFFSET
00606 #line 1 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
00607 /* $Id: OSParseosss.cpp 3128 2010-01-10 19:12:37Z kmartin $ */
00622 #line 18 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
00623 
00624 
00625 #include <iostream>
00626 #include "OSConfig.h"
00627 
00628 
00629 #ifdef HAVE_CSTRING
00630 # include <cstring>
00631 #else
00632 # ifdef HAVE_STRING_H
00633 #  include <string.h>
00634 # else
00635 #  error "don't have header file for string"
00636 # endif
00637 #endif
00638 
00639 #ifdef HAVE_CSTDIO
00640 # include <cstdio>
00641 #else
00642 # ifdef HAVE_STDIO_H
00643 #  include <stdio.h>
00644 # else
00645 #  error "don't have header file for stdio"
00646 # endif
00647 #endif
00648 #include "OSErrorClass.h"
00649 #include <sstream>   
00650 #include "OSOptionsStruc.h" 
00651 
00652 
00653 using std::cout;
00654 using std::endl;
00655 using std::ostringstream;
00656 
00657 //#define PARSERDEBUG
00658 #ifdef PARSERDEBUG
00659         #define YY_PRINT  printf("Found option:  %s\n", yytext);
00660 #else     
00661         #define YY_PRINT  ;
00662 #endif
00663 
00664 
00665 #ifdef WIN_
00666   #define YY_NO_UNISTD_H
00667   #include <io.h>
00668   #include <process.h>
00669   #ifdef USE_OLD_UNISTD
00670      #include<sys/unistd.h>  
00671   #endif
00672 #endif
00673 
00674 
00675 #define YY_EXTRA_TYPE struct osOptionsStruc*
00676 
00677 void setyyextra( osOptionsStruc *osoptions, void* scanner);
00678 
00679  /*
00680  * INPUTS:
00681  * -osil xxx.osil (file name on local machine of optimization instance, 
00682  *       this is "" by default, however if this remains "" a problem
00683  *               instance must be specified in the osol file)
00684  * -osol xxx.osol (file name on local machine of solver options, 
00685  *       default default value is "")
00686  * -osrl xxx.osrl (file name on local machine where the optimization 
00687  *       result is put, default is "")
00688  * -serviceLocation location URL (the URL  of the server that is called 
00689  *       remotely if the problem not solved locally, default is "")
00690  * -serviceMethod  (send, solve, kill, knock, getJobID, retrieve, 
00691  *       default value is solve)
00692  * -osplInput xxx.ospl  (Not used for now -- ignore)
00693  * -osplOutput xxx.ospl (Not used for now -- ignore)
00694  * -mps xxxx.mps (converts mps format to osil and has same effect as -osil)
00695  * -nl xxxx.nl (converts nl format to osil and has same effect as -osil)
00696  * -solver solverName (the name of the solver to be invoked)
00697  * -browser path location to browser e.g. 
00698  *       /Applications/Firefox.app/Contents/MacOS/firefox (default is "")
00699  * -config pathToConfigFile is the path to a configure file with the problem 
00700  *           parameters
00701  * -insList xxx.dat (used only for LINDO, file location on local 
00702  *       machine of LINDO instruction list)
00703 */
00704 
00705 
00706 #line 707 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
00707 
00708 #define INITIAL 0
00709 
00710 #ifndef YY_NO_UNISTD_H
00711 /* Special case for "unistd.h", since it is non-ANSI. We include it way
00712  * down here because we want the user's section 1 to have been scanned first.
00713  * The user has a chance to override it with an option.
00714  */
00715 #include <unistd.h>
00716 #endif
00717 
00718 #ifndef YY_EXTRA_TYPE
00719 #define YY_EXTRA_TYPE void *
00720 #endif
00721 
00722 /* Holds the entire state of the reentrant scanner. */
00723 struct yyguts_t
00724     {
00725 
00726     /* User-defined. Not touched by flex. */
00727     YY_EXTRA_TYPE yyextra_r;
00728 
00729     /* The rest are the same as the globals declared in the non-reentrant scanner. */
00730     FILE *yyin_r, *yyout_r;
00731     size_t yy_buffer_stack_top; 
00732     size_t yy_buffer_stack_max; 
00733     YY_BUFFER_STATE * yy_buffer_stack; 
00734     char yy_hold_char;
00735     int yy_n_chars;
00736     int yyleng_r;
00737     char *yy_c_buf_p;
00738     int yy_init;
00739     int yy_start;
00740     int yy_did_buffer_switch_on_eof;
00741     int yy_start_stack_ptr;
00742     int yy_start_stack_depth;
00743     int *yy_start_stack;
00744     yy_state_type yy_last_accepting_state;
00745     char* yy_last_accepting_cpos;
00746 
00747     int yylineno_r;
00748     int yy_flex_debug_r;
00749 
00750     char *yytext_r;
00751     int yy_more_flag;
00752     int yy_more_len;
00753 
00754     }; /* end struct yyguts_t */
00755 
00756 static int yy_init_globals (yyscan_t yyscanner );
00757 
00758 int ossslex_init (yyscan_t* scanner);
00759 
00760 int ossslex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
00761 
00762 /* Accessor methods to globals.
00763    These are made visible to non-reentrant scanners for convenience. */
00764 
00765 int ossslex_destroy (yyscan_t yyscanner );
00766 
00767 int osssget_debug (yyscan_t yyscanner );
00768 
00769 void osssset_debug (int debug_flag ,yyscan_t yyscanner );
00770 
00771 YY_EXTRA_TYPE osssget_extra (yyscan_t yyscanner );
00772 
00773 void osssset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
00774 
00775 FILE *osssget_in (yyscan_t yyscanner );
00776 
00777 void osssset_in  (FILE * in_str ,yyscan_t yyscanner );
00778 
00779 FILE *osssget_out (yyscan_t yyscanner );
00780 
00781 void osssset_out  (FILE * out_str ,yyscan_t yyscanner );
00782 
00783 int osssget_leng (yyscan_t yyscanner );
00784 
00785 char *osssget_text (yyscan_t yyscanner );
00786 
00787 int osssget_lineno (yyscan_t yyscanner );
00788 
00789 void osssset_lineno (int line_number ,yyscan_t yyscanner );
00790 
00791 /* Macros after this point can all be overridden by user definitions in
00792  * section 1.
00793  */
00794 
00795 #ifndef YY_SKIP_YYWRAP
00796 #ifdef __cplusplus
00797 extern "C" int ossswrap (yyscan_t yyscanner );
00798 #else
00799 extern int ossswrap (yyscan_t yyscanner );
00800 #endif
00801 #endif
00802 
00803 #ifndef yytext_ptr
00804 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
00805 #endif
00806 
00807 #ifdef YY_NEED_STRLEN
00808 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
00809 #endif
00810 
00811 #ifndef YY_NO_INPUT
00812 
00813 #ifdef __cplusplus
00814 static int yyinput (yyscan_t yyscanner );
00815 #else
00816 static int input (yyscan_t yyscanner );
00817 #endif
00818 
00819 #endif
00820 
00821 /* Amount of stuff to slurp up with each read. */
00822 #ifndef YY_READ_BUF_SIZE
00823 #ifdef __ia64__
00824 /* On IA-64, the buffer size is 16k, not 8k */
00825 #define YY_READ_BUF_SIZE 16384
00826 #else
00827 #define YY_READ_BUF_SIZE 8192
00828 #endif /* __ia64__ */
00829 #endif
00830 
00831 /* Copy whatever the last rule matched to the standard output. */
00832 #ifndef ECHO
00833 /* This used to be an fputs(), but since the string might contain NUL's,
00834  * we now use fwrite().
00835  */
00836 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
00837 #endif
00838 
00839 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
00840  * is returned in "result".
00841  */
00842 #ifndef YY_INPUT
00843 #define YY_INPUT(buf,result,max_size) \
00844         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
00845                 { \
00846                 int c = '*'; \
00847                 size_t n; \
00848                 for ( n = 0; n < max_size && \
00849                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00850                         buf[n] = (char) c; \
00851                 if ( c == '\n' ) \
00852                         buf[n++] = (char) c; \
00853                 if ( c == EOF && ferror( yyin ) ) \
00854                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
00855                 result = n; \
00856                 } \
00857         else \
00858                 { \
00859                 errno=0; \
00860                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
00861                         { \
00862                         if( errno != EINTR) \
00863                                 { \
00864                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
00865                                 break; \
00866                                 } \
00867                         errno=0; \
00868                         clearerr(yyin); \
00869                         } \
00870                 }\
00871 \
00872 
00873 #endif
00874 
00875 /* No semi-colon after return; correct usage is to write "yyterminate();" -
00876  * we don't want an extra ';' after the "return" because that will cause
00877  * some compilers to complain about unreachable statements.
00878  */
00879 #ifndef yyterminate
00880 #define yyterminate() return YY_NULL
00881 #endif
00882 
00883 /* Number of entries by which start-condition stack grows. */
00884 #ifndef YY_START_STACK_INCR
00885 #define YY_START_STACK_INCR 25
00886 #endif
00887 
00888 /* Report a fatal error. */
00889 #ifndef YY_FATAL_ERROR
00890 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
00891 #endif
00892 
00893 /* end tables serialization structures and prototypes */
00894 
00895 /* Default declaration of generated scanner - a define so the user can
00896  * easily add parameters.
00897  */
00898 #ifndef YY_DECL
00899 #define YY_DECL_IS_OURS 1
00900 
00901 extern int ossslex (yyscan_t yyscanner);
00902 
00903 #define YY_DECL int ossslex (yyscan_t yyscanner)
00904 #endif /* !YY_DECL */
00905 
00906 /* Code executed at the beginning of each rule, after yytext and yyleng
00907  * have been set up.
00908  */
00909 #ifndef YY_USER_ACTION
00910 #define YY_USER_ACTION
00911 #endif
00912 
00913 /* Code executed at the end of each rule. */
00914 #ifndef YY_BREAK
00915 #define YY_BREAK break;
00916 #endif
00917 
00918 #define YY_RULE_SETUP \
00919         YY_USER_ACTION
00920 
00923 YY_DECL
00924 {
00925         register yy_state_type yy_current_state;
00926         register char *yy_cp, *yy_bp;
00927         register int yy_act;
00928     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
00929 
00930 #line 114 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
00931 
00932 
00933 #line 934 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
00934 
00935         if ( !yyg->yy_init )
00936                 {
00937                 yyg->yy_init = 1;
00938 
00939 #ifdef YY_USER_INIT
00940                 YY_USER_INIT;
00941 #endif
00942 
00943                 if ( ! yyg->yy_start )
00944                         yyg->yy_start = 1;      /* first start state */
00945 
00946                 if ( ! yyin )
00947                         yyin = stdin;
00948 
00949                 if ( ! yyout )
00950                         yyout = stdout;
00951 
00952                 if ( ! YY_CURRENT_BUFFER ) {
00953                         osssensure_buffer_stack (yyscanner);
00954                         YY_CURRENT_BUFFER_LVALUE =
00955                                 osss_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
00956                 }
00957 
00958                 osss_load_buffer_state(yyscanner );
00959                 }
00960 
00961         while ( 1 )             /* loops until end-of-file is reached */
00962                 {
00963                 yy_cp = yyg->yy_c_buf_p;
00964 
00965                 /* Support of yytext. */
00966                 *yy_cp = yyg->yy_hold_char;
00967 
00968                 /* yy_bp points to the position in yy_ch_buf of the start of
00969                  * the current run.
00970                  */
00971                 yy_bp = yy_cp;
00972 
00973                 yy_current_state = yyg->yy_start;
00974 yy_match:
00975                 do
00976                         {
00977                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00978                         if ( yy_accept[yy_current_state] )
00979                                 {
00980                                 yyg->yy_last_accepting_state = yy_current_state;
00981                                 yyg->yy_last_accepting_cpos = yy_cp;
00982                                 }
00983                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00984                                 {
00985                                 yy_current_state = (int) yy_def[yy_current_state];
00986                                 if ( yy_current_state >= 192 )
00987                                         yy_c = yy_meta[(unsigned int) yy_c];
00988                                 }
00989                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00990                         ++yy_cp;
00991                         }
00992                 while ( yy_base[yy_current_state] != 337 );
00993 
00994 yy_find_action:
00995                 yy_act = yy_accept[yy_current_state];
00996                 if ( yy_act == 0 )
00997                         { /* have to back up */
00998                         yy_cp = yyg->yy_last_accepting_cpos;
00999                         yy_current_state = yyg->yy_last_accepting_state;
01000                         yy_act = yy_accept[yy_current_state];
01001                         }
01002 
01003                 YY_DO_BEFORE_ACTION;
01004 
01005                 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
01006                         {
01007                         int yyl;
01008                         for ( yyl = 0; yyl < yyleng; ++yyl )
01009                                 if ( yytext[yyl] == '\n' )
01010                                            
01011     do{ yylineno++;
01012         yycolumn=0;
01013     }while(0)
01014 ;
01015                         }
01016 
01017 do_action:      /* This label is used only to access EOF actions. */
01018 
01019                 switch ( yy_act )
01020         { /* beginning of action switch */
01021                         case 0: /* must back up */
01022                         /* undo the effects of YY_DO_BEFORE_ACTION */
01023                         *yy_cp = yyg->yy_hold_char;
01024                         yy_cp = yyg->yy_last_accepting_cpos;
01025                         yy_current_state = yyg->yy_last_accepting_state;
01026                         goto yy_find_action;
01027 
01028 case 1:
01029 /* rule 1 can match eol */
01030 YY_RULE_SETUP
01031 #line 116 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01032 
01033         YY_BREAK
01034 case 2:
01035 /* rule 2 can match eol */
01036 YY_RULE_SETUP
01037 #line 120 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01038 {
01039         YY_PRINT  
01040         //char *ch = strdup(yytext);
01041         char *ch = yytext;
01042         // move past -config
01043         ch+=7;
01044         for(; isspace(*ch); ch++);
01045         std::string str(  ch);
01046         yyextra->configFile = str;
01047         //printf("gsgersdf= %d\n", gster);
01048 }
01049         YY_BREAK
01050 case 3:
01051 YY_RULE_SETUP
01052 #line 133 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01053 {
01054         YY_PRINT  
01055         yyextra->invokeHelp = true;
01056         //printf("gsgersdf= %d\n", gster);
01057 }
01058         YY_BREAK
01059 case 4:
01060 YY_RULE_SETUP
01061 #line 139 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01062 {
01063         YY_PRINT
01064         yyextra->invokeHelp = true;
01065         //printf("gsgersdf= %d\n", gster); 
01066         
01067 }
01068         YY_BREAK
01069 case 5:
01070 YY_RULE_SETUP
01071 #line 146 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01072 {
01073         YY_PRINT  
01074         yyextra->writeVersion = true;
01075         //printf("gsgersdf= %d\n", gster);
01076 }
01077         YY_BREAK
01078 case 6:
01079 YY_RULE_SETUP
01080 #line 152 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01081 {
01082         YY_PRINT 
01083         yyextra->writeVersion = true;
01084         //printf("gsgersdf= %d\n", gster); 
01085         
01086 }
01087         YY_BREAK
01088 case 7:
01089 /* rule 7 can match eol */
01090 YY_RULE_SETUP
01091 #line 161 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01092 {
01093         if(yyextra->osilFile == ""){
01094                 YY_PRINT  
01095                 //char *ch = strdup(yytext);
01096                 char *ch = yytext;
01097                 // move past -osil
01098                 ch+=5;
01099                 for(; isspace(*ch); ch++);
01100                 std::string str(  ch);
01101                 yyextra->osilFile = str;
01102         } 
01103 }
01104         YY_BREAK
01105 case 8:
01106 /* rule 8 can match eol */
01107 YY_RULE_SETUP
01108 #line 174 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01109 {
01110         if(yyextra->osrlFile == ""){
01111                 YY_PRINT 
01112                 //char *ch = strdup(yytext);
01113                 char *ch = yytext;
01114                 // move past -osrl
01115                 ch+=5;
01116                 for(; isspace(*ch); ch++);
01117                 std::string str(  ch);
01118                 yyextra->osrlFile = str;
01119         }  
01120 }  
01121         YY_BREAK
01122 case 9:
01123 /* rule 9 can match eol */
01124 YY_RULE_SETUP
01125 #line 187 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01126 {
01127         if(yyextra->insListFile == ""){
01128                 YY_PRINT
01129                 //char *ch = strdup(yytext);
01130                 char *ch = yytext;
01131                 // move past -insList
01132                 ch+=8;
01133                 for(; isspace(*ch); ch++);
01134                 std::string str(  ch);
01135                 yyextra->insListFile = str;
01136         }  
01137 }  
01138         YY_BREAK
01139 case 10:
01140 /* rule 10 can match eol */
01141 YY_RULE_SETUP
01142 #line 200 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01143 {
01144         if(yyextra->osolFile == ""){
01145                 YY_PRINT 
01146                 //char *ch = strdup(yytext);
01147                 char *ch = yytext;
01148                 // move past -osol
01149                 ch+=5;
01150                 for(; isspace(*ch); ch++);
01151                 std::string str(  ch);
01152                 yyextra->osolFile = str;  
01153         }
01154 }
01155         YY_BREAK
01156 case 11:
01157 /* rule 11 can match eol */
01158 YY_RULE_SETUP
01159 #line 215 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01160 {
01161         if(yyextra->osplInputFile == ""){
01162                 YY_PRINT 
01163                 //char *ch = strdup(yytext);
01164                 char *ch = yytext;
01165                 // move past -osplInput
01166                 ch+=10;
01167                 for(; isspace(*ch); ch++);
01168                 std::string str(  ch);
01169                 yyextra->osplInputFile = str;  
01170         }
01171 }
01172         YY_BREAK
01173 case 12:
01174 /* rule 12 can match eol */
01175 YY_RULE_SETUP
01176 #line 228 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01177 {
01178         if(yyextra->osplOutputFile == ""){
01179                 YY_PRINT 
01180                 //char *ch = strdup(yytext);
01181                 char *ch = yytext;
01182                 // move past -osplInput
01183                 ch+=11;
01184                 for(; isspace(*ch); ch++);
01185                 std::string str(  ch);
01186                 yyextra->osplOutputFile = str;  
01187         }
01188 }
01189         YY_BREAK
01190 case 13:
01191 /* rule 13 can match eol */
01192 YY_RULE_SETUP
01193 #line 241 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01194 {
01195         if(yyextra->serviceMethod == ""){
01196                 YY_PRINT
01197                 //char *ch = strdup(yytext);
01198                 char *ch = yytext;
01199                 // move past -serviceMethod
01200                 ch+=14;
01201                 for(; isspace(*ch); ch++);
01202                 std::string str(  ch);
01203                 yyextra->serviceMethod = str; 
01204         }
01205 }
01206         YY_BREAK
01207 case 14:
01208 /* rule 14 can match eol */
01209 YY_RULE_SETUP
01210 #line 254 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01211 {
01212         if(yyextra->serviceLocation == ""){
01213                 YY_PRINT 
01214                 //yyextra->serviceLocation = strdup(yytext);
01215                 yyextra->serviceLocation =  yytext;
01216                 //char *ch = strdup(yytext);
01217                 char *ch = yytext;
01218                 // move past -serviceLocation
01219                 ch+=16;
01220                 for(; isspace(*ch); ch++);
01221                 std::string str(  ch);
01222                 yyextra->serviceLocation = str; 
01223         }
01224 }
01225         YY_BREAK
01226 case 15:
01227 /* rule 15 can match eol */
01228 YY_RULE_SETUP
01229 #line 269 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01230 {
01231         if(yyextra->mpsFile == ""){
01232                 YY_PRINT 
01233                 //char *ch = strdup(yytext);
01234                 char *ch = yytext;
01235                 // move past -mps
01236                 ch+=4;
01237                 for(; isspace(*ch); ch++);
01238                 std::string str(  ch);
01239                 yyextra->mpsFile = str; 
01240         }
01241 }
01242         YY_BREAK
01243 case 16:
01244 /* rule 16 can match eol */
01245 YY_RULE_SETUP
01246 #line 282 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01247 {
01248         if(yyextra->nlFile == ""){
01249                 YY_PRINT
01250                 //char *ch = strdup(yytext);
01251                 char *ch = yytext;
01252                 // move past -nl
01253                 ch+=3;
01254                 for(; isspace(*ch); ch++);
01255                 std::string str(  ch);
01256                 yyextra->nlFile = str; 
01257         } 
01258 }
01259         YY_BREAK
01260 case 17:
01261 /* rule 17 can match eol */
01262 YY_RULE_SETUP
01263 #line 297 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01264 {
01265         if(yyextra->gamsControlFile == ""){
01266                 YY_PRINT
01267                 //char *ch = strdup(yytext);
01268                 char *ch = yytext;
01269                 // move past -dat
01270                 ch+=4;
01271                 for(; isspace(*ch); ch++);
01272                 std::string str(  ch);
01273                 yyextra->gamsControlFile = str;
01274         } 
01275 }
01276         YY_BREAK
01277 case 18:
01278 /* rule 18 can match eol */
01279 YY_RULE_SETUP
01280 #line 310 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01281 {
01282         if(yyextra->solverName == ""){
01283                 YY_PRINT 
01284                 //char *ch = strdup(yytext);
01285                 char *ch = yytext;
01286                 // move past -solver
01287                 ch+=7;
01288                 for(; isspace(*ch); ch++);
01289                 std::string str(  ch);
01290                 yyextra->solverName = str;
01291         } 
01292 }
01293         YY_BREAK
01294 case 19:
01295 /* rule 19 can match eol */
01296 YY_RULE_SETUP
01297 #line 323 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01298 {
01299         if(yyextra->browser == ""){
01300                 YY_PRINT  
01301                 //char *ch = strdup(yytext);
01302                 char *ch = yytext;
01303                 // move past -browser
01304                 ch+=8;
01305                 for(; isspace(*ch); ch++);
01306                 std::string str(  ch);
01307                 yyextra->browser = str; 
01308         }
01309 }
01310         YY_BREAK
01311 case 20:
01312 YY_RULE_SETUP
01313 #line 336 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01314 {
01315         std::string error;
01316         std::ostringstream outStr;
01317         outStr << "encountered a spurious character in the lexer" << endl;
01318         outStr << "The first character is: ";
01319         outStr <<  yytext;
01320         outStr << endl;
01321         //outStr << "See line number: " << yylineno << endl;  
01322         error = outStr.str();
01323         throw ErrorClass( error);  
01324 }
01325         YY_BREAK
01326 case 21:
01327 YY_RULE_SETUP
01328 #line 347 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01329 ECHO;
01330         YY_BREAK
01331 #line 1332 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
01332 case YY_STATE_EOF(INITIAL):
01333         yyterminate();
01334 
01335         case YY_END_OF_BUFFER:
01336                 {
01337                 /* Amount of text matched not including the EOB char. */
01338                 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
01339 
01340                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
01341                 *yy_cp = yyg->yy_hold_char;
01342                 YY_RESTORE_YY_MORE_OFFSET
01343 
01344                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
01345                         {
01346                         /* We're scanning a new file or input source.  It's
01347                          * possible that this happened because the user
01348                          * just pointed yyin at a new source and called
01349                          * ossslex().  If so, then we have to assure
01350                          * consistency between YY_CURRENT_BUFFER and our
01351                          * globals.  Here is the right place to do so, because
01352                          * this is the first action (other than possibly a
01353                          * back-up) that will match for the new input source.
01354                          */
01355                         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
01356                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
01357                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
01358                         }
01359 
01360                 /* Note that here we test for yy_c_buf_p "<=" to the position
01361                  * of the first EOB in the buffer, since yy_c_buf_p will
01362                  * already have been incremented past the NUL character
01363                  * (since all states make transitions on EOB to the
01364                  * end-of-buffer state).  Contrast this with the test
01365                  * in input().
01366                  */
01367                 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
01368                         { /* This was really a NUL. */
01369                         yy_state_type yy_next_state;
01370 
01371                         yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
01372 
01373                         yy_current_state = yy_get_previous_state( yyscanner );
01374 
01375                         /* Okay, we're now positioned to make the NUL
01376                          * transition.  We couldn't have
01377                          * yy_get_previous_state() go ahead and do it
01378                          * for us because it doesn't know how to deal
01379                          * with the possibility of jamming (and we don't
01380                          * want to build jamming into it because then it
01381                          * will run more slowly).
01382                          */
01383 
01384                         yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
01385 
01386                         yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
01387 
01388                         if ( yy_next_state )
01389                                 {
01390                                 /* Consume the NUL. */
01391                                 yy_cp = ++yyg->yy_c_buf_p;
01392                                 yy_current_state = yy_next_state;
01393                                 goto yy_match;
01394                                 }
01395 
01396                         else
01397                                 {
01398                                 yy_cp = yyg->yy_c_buf_p;
01399                                 goto yy_find_action;
01400                                 }
01401                         }
01402 
01403                 else switch ( yy_get_next_buffer( yyscanner ) )
01404                         {
01405                         case EOB_ACT_END_OF_FILE:
01406                                 {
01407                                 yyg->yy_did_buffer_switch_on_eof = 0;
01408 
01409                                 if ( ossswrap(yyscanner ) )
01410                                         {
01411                                         /* Note: because we've taken care in
01412                                          * yy_get_next_buffer() to have set up
01413                                          * yytext, we can now set up
01414                                          * yy_c_buf_p so that if some total
01415                                          * hoser (like flex itself) wants to
01416                                          * call the scanner after we return the
01417                                          * YY_NULL, it'll still work - another
01418                                          * YY_NULL will get returned.
01419                                          */
01420                                         yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
01421 
01422                                         yy_act = YY_STATE_EOF(YY_START);
01423                                         goto do_action;
01424                                         }
01425 
01426                                 else
01427                                         {
01428                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
01429                                                 YY_NEW_FILE;
01430                                         }
01431                                 break;
01432                                 }
01433 
01434                         case EOB_ACT_CONTINUE_SCAN:
01435                                 yyg->yy_c_buf_p =
01436                                         yyg->yytext_ptr + yy_amount_of_matched_text;
01437 
01438                                 yy_current_state = yy_get_previous_state( yyscanner );
01439 
01440                                 yy_cp = yyg->yy_c_buf_p;
01441                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
01442                                 goto yy_match;
01443 
01444                         case EOB_ACT_LAST_MATCH:
01445                                 yyg->yy_c_buf_p =
01446                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
01447 
01448                                 yy_current_state = yy_get_previous_state( yyscanner );
01449 
01450                                 yy_cp = yyg->yy_c_buf_p;
01451                                 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
01452                                 goto yy_find_action;
01453                         }
01454                 break;
01455                 }
01456 
01457         default:
01458                 YY_FATAL_ERROR(
01459                         "fatal flex scanner internal error--no action found" );
01460         } /* end of action switch */
01461                 } /* end of scanning one token */
01462 } /* end of ossslex */
01463 
01464 /* yy_get_next_buffer - try to read in a new buffer
01465  *
01466  * Returns a code representing an action:
01467  *      EOB_ACT_LAST_MATCH -
01468  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
01469  *      EOB_ACT_END_OF_FILE - end of file
01470  */
01471 static int yy_get_next_buffer (yyscan_t yyscanner)
01472 {
01473     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01474         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
01475         register char *source = yyg->yytext_ptr;
01476         register int number_to_move, i;
01477         int ret_val;
01478 
01479         if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
01480                 YY_FATAL_ERROR(
01481                 "fatal flex scanner internal error--end of buffer missed" );
01482 
01483         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
01484                 { /* Don't try to fill the buffer, so this is an EOF. */
01485                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
01486                         {
01487                         /* We matched a single character, the EOB, so
01488                          * treat this as a final EOF.
01489                          */
01490                         return EOB_ACT_END_OF_FILE;
01491                         }
01492 
01493                 else
01494                         {
01495                         /* We matched some text prior to the EOB, first
01496                          * process it.
01497                          */
01498                         return EOB_ACT_LAST_MATCH;
01499                         }
01500                 }
01501 
01502         /* Try to read more data. */
01503 
01504         /* First move last chars to start of buffer. */
01505         number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
01506 
01507         for ( i = 0; i < number_to_move; ++i )
01508                 *(dest++) = *(source++);
01509 
01510         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01511                 /* don't do the read, it's not guaranteed to return an EOF,
01512                  * just force an EOF
01513                  */
01514                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
01515 
01516         else
01517                 {
01518                         int num_to_read =
01519                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
01520 
01521                 while ( num_to_read <= 0 )
01522                         { /* Not enough room in the buffer - grow it. */
01523 
01524                         /* just a shorter name for the current buffer */
01525                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
01526 
01527                         int yy_c_buf_p_offset =
01528                                 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
01529 
01530                         if ( b->yy_is_our_buffer )
01531                                 {
01532                                 int new_size = b->yy_buf_size * 2;
01533 
01534                                 if ( new_size <= 0 )
01535                                         b->yy_buf_size += b->yy_buf_size / 8;
01536                                 else
01537                                         b->yy_buf_size *= 2;
01538 
01539                                 b->yy_ch_buf = (char *)
01540                                         /* Include room in for 2 EOB chars. */
01541                                         osssrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
01542                                 }
01543                         else
01544                                 /* Can't grow it, we don't own it. */
01545                                 b->yy_ch_buf = 0;
01546 
01547                         if ( ! b->yy_ch_buf )
01548                                 YY_FATAL_ERROR(
01549                                 "fatal error - scanner input buffer overflow" );
01550 
01551                         yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
01552 
01553                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
01554                                                 number_to_move - 1;
01555 
01556                         }
01557 
01558                 if ( num_to_read > YY_READ_BUF_SIZE )
01559                         num_to_read = YY_READ_BUF_SIZE;
01560 
01561                 /* Read in more data. */
01562                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
01563                         yyg->yy_n_chars, (size_t) num_to_read );
01564 
01565                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01566                 }
01567 
01568         if ( yyg->yy_n_chars == 0 )
01569                 {
01570                 if ( number_to_move == YY_MORE_ADJ )
01571                         {
01572                         ret_val = EOB_ACT_END_OF_FILE;
01573                         osssrestart(yyin  ,yyscanner);
01574                         }
01575 
01576                 else
01577                         {
01578                         ret_val = EOB_ACT_LAST_MATCH;
01579                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
01580                                 YY_BUFFER_EOF_PENDING;
01581                         }
01582                 }
01583 
01584         else
01585                 ret_val = EOB_ACT_CONTINUE_SCAN;
01586 
01587         if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
01588                 /* Extend the array by 50%, plus the number we really need. */
01589                 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
01590                 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) osssrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
01591                 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
01592                         YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
01593         }
01594 
01595         yyg->yy_n_chars += number_to_move;
01596         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
01597         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
01598 
01599         yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
01600 
01601         return ret_val;
01602 }
01603 
01604 /* yy_get_previous_state - get the state just before the EOB char was reached */
01605 
01606     static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
01607 {
01608         register yy_state_type yy_current_state;
01609         register char *yy_cp;
01610     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01611 
01612         yy_current_state = yyg->yy_start;
01613 
01614         for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
01615                 {
01616                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01617                 if ( yy_accept[yy_current_state] )
01618                         {
01619                         yyg->yy_last_accepting_state = yy_current_state;
01620                         yyg->yy_last_accepting_cpos = yy_cp;
01621                         }
01622                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01623                         {
01624                         yy_current_state = (int) yy_def[yy_current_state];
01625                         if ( yy_current_state >= 192 )
01626                                 yy_c = yy_meta[(unsigned int) yy_c];
01627                         }
01628                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01629                 }
01630 
01631         return yy_current_state;
01632 }
01633 
01634 /* yy_try_NUL_trans - try to make a transition on the NUL character
01635  *
01636  * synopsis
01637  *      next_state = yy_try_NUL_trans( current_state );
01638  */
01639     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state , yyscan_t yyscanner)
01640 {
01641         register int yy_is_jam;
01642     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
01643         register char *yy_cp = yyg->yy_c_buf_p;
01644 
01645         register YY_CHAR yy_c = 1;
01646         if ( yy_accept[yy_current_state] )
01647                 {
01648                 yyg->yy_last_accepting_state = yy_current_state;
01649                 yyg->yy_last_accepting_cpos = yy_cp;
01650                 }
01651         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01652                 {
01653                 yy_current_state = (int) yy_def[yy_current_state];
01654                 if ( yy_current_state >= 192 )
01655                         yy_c = yy_meta[(unsigned int) yy_c];
01656                 }
01657         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01658         yy_is_jam = (yy_current_state == 191);
01659 
01660         return yy_is_jam ? 0 : yy_current_state;
01661 }
01662 
01663 #ifndef YY_NO_INPUT
01664 #ifdef __cplusplus
01665     static int yyinput (yyscan_t yyscanner)
01666 #else
01667     static int input  (yyscan_t yyscanner)
01668 #endif
01669 
01670 {
01671         int c;
01672     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01673 
01674         *yyg->yy_c_buf_p = yyg->yy_hold_char;
01675 
01676         if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
01677                 {
01678                 /* yy_c_buf_p now points to the character we want to return.
01679                  * If this occurs *before* the EOB characters, then it's a
01680                  * valid NUL; if not, then we've hit the end of the buffer.
01681                  */
01682                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
01683                         /* This was really a NUL. */
01684                         *yyg->yy_c_buf_p = '\0';
01685 
01686                 else
01687                         { /* need more input */
01688                         int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
01689                         ++yyg->yy_c_buf_p;
01690 
01691                         switch ( yy_get_next_buffer( yyscanner ) )
01692                                 {
01693                                 case EOB_ACT_LAST_MATCH:
01694                                         /* This happens because yy_g_n_b()
01695                                          * sees that we've accumulated a
01696                                          * token and flags that we need to
01697                                          * try matching the token before
01698                                          * proceeding.  But for input(),
01699                                          * there's no matching to consider.
01700                                          * So convert the EOB_ACT_LAST_MATCH
01701                                          * to EOB_ACT_END_OF_FILE.
01702                                          */
01703 
01704                                         /* Reset buffer status. */
01705                                         osssrestart(yyin ,yyscanner);
01706 
01707                                         /*FALLTHROUGH*/
01708 
01709                                 case EOB_ACT_END_OF_FILE:
01710                                         {
01711                                         if ( ossswrap(yyscanner ) )
01712                                                 return EOF;
01713 
01714                                         if ( ! yyg->yy_did_buffer_switch_on_eof )
01715                                                 YY_NEW_FILE;
01716 #ifdef __cplusplus
01717                                         return yyinput(yyscanner);
01718 #else
01719                                         return input(yyscanner);
01720 #endif
01721                                         }
01722 
01723                                 case EOB_ACT_CONTINUE_SCAN:
01724                                         yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
01725                                         break;
01726                                 }
01727                         }
01728                 }
01729 
01730         c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
01731         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
01732         yyg->yy_hold_char = *++yyg->yy_c_buf_p;
01733 
01734         if ( c == '\n' )
01735                    
01736     do{ yylineno++;
01737         yycolumn=0;
01738     }while(0)
01739 ;
01740 
01741         return c;
01742 }
01743 #endif  /* ifndef YY_NO_INPUT */
01744 
01750     void osssrestart  (FILE * input_file , yyscan_t yyscanner)
01751 {
01752     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01753 
01754         if ( ! YY_CURRENT_BUFFER ){
01755         osssensure_buffer_stack (yyscanner);
01756                 YY_CURRENT_BUFFER_LVALUE =
01757             osss_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
01758         }
01759 
01760         osss_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
01761         osss_load_buffer_state(yyscanner );
01762 }
01763 
01768     void osss_switch_to_buffer  (YY_BUFFER_STATE  new_buffer , yyscan_t yyscanner)
01769 {
01770     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01771 
01772         /* TODO. We should be able to replace this entire function body
01773          * with
01774          *              ossspop_buffer_state();
01775          *              ossspush_buffer_state(new_buffer);
01776      */
01777         osssensure_buffer_stack (yyscanner);
01778         if ( YY_CURRENT_BUFFER == new_buffer )
01779                 return;
01780 
01781         if ( YY_CURRENT_BUFFER )
01782                 {
01783                 /* Flush out information for old buffer. */
01784                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01785                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
01786                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01787                 }
01788 
01789         YY_CURRENT_BUFFER_LVALUE = new_buffer;
01790         osss_load_buffer_state(yyscanner );
01791 
01792         /* We don't actually know whether we did this switch during
01793          * EOF (ossswrap()) processing, but the only time this flag
01794          * is looked at is after ossswrap() is called, so it's safe
01795          * to go ahead and always set it.
01796          */
01797         yyg->yy_did_buffer_switch_on_eof = 1;
01798 }
01799 
01800 static void osss_load_buffer_state  (yyscan_t yyscanner)
01801 {
01802     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01803         yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
01804         yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
01805         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
01806         yyg->yy_hold_char = *yyg->yy_c_buf_p;
01807 }
01808 
01815     YY_BUFFER_STATE osss_create_buffer  (FILE * file, int  size , yyscan_t yyscanner)
01816 {
01817         YY_BUFFER_STATE b;
01818     
01819         b = (YY_BUFFER_STATE) osssalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
01820         if ( ! b )
01821                 YY_FATAL_ERROR( "out of dynamic memory in osss_create_buffer()" );
01822 
01823         b->yy_buf_size = size;
01824 
01825         /* yy_ch_buf has to be 2 characters longer than the size given because
01826          * we need to put in 2 end-of-buffer characters.
01827          */
01828         b->yy_ch_buf = (char *) osssalloc(b->yy_buf_size + 2 ,yyscanner );
01829         if ( ! b->yy_ch_buf )
01830                 YY_FATAL_ERROR( "out of dynamic memory in osss_create_buffer()" );
01831 
01832         b->yy_is_our_buffer = 1;
01833 
01834         osss_init_buffer(b,file ,yyscanner);
01835 
01836         return b;
01837 }
01838 
01843     void osss_delete_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
01844 {
01845     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01846 
01847         if ( ! b )
01848                 return;
01849 
01850         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
01851                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
01852 
01853         if ( b->yy_is_our_buffer )
01854                 osssfree((void *) b->yy_ch_buf ,yyscanner );
01855 
01856         osssfree((void *) b ,yyscanner );
01857 }
01858 
01859 #ifndef __cplusplus
01860 extern int isatty (int );
01861 #endif /* __cplusplus */
01862     
01863 /* Initializes or reinitializes a buffer.
01864  * This function is sometimes called more than once on the same buffer,
01865  * such as during a osssrestart() or at EOF.
01866  */
01867     static void osss_init_buffer  (YY_BUFFER_STATE  b, FILE * file , yyscan_t yyscanner)
01868 
01869 {
01870         int oerrno = errno;
01871     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01872 
01873         osss_flush_buffer(b ,yyscanner);
01874 
01875         b->yy_input_file = file;
01876         b->yy_fill_buffer = 1;
01877 
01878     /* If b is the current buffer, then osss_init_buffer was _probably_
01879      * called from osssrestart() or through yy_get_next_buffer.
01880      * In that case, we don't want to reset the lineno or column.
01881      */
01882     if (b != YY_CURRENT_BUFFER){
01883         b->yy_bs_lineno = 1;
01884         b->yy_bs_column = 0;
01885     }
01886 
01887         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
01888     
01889         errno = oerrno;
01890 }
01891 
01896     void osss_flush_buffer (YY_BUFFER_STATE  b , yyscan_t yyscanner)
01897 {
01898     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01899         if ( ! b )
01900                 return;
01901 
01902         b->yy_n_chars = 0;
01903 
01904         /* We always need two end-of-buffer characters.  The first causes
01905          * a transition to the end-of-buffer state.  The second causes
01906          * a jam in that state.
01907          */
01908         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01909         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01910 
01911         b->yy_buf_pos = &b->yy_ch_buf[0];
01912 
01913         b->yy_at_bol = 1;
01914         b->yy_buffer_status = YY_BUFFER_NEW;
01915 
01916         if ( b == YY_CURRENT_BUFFER )
01917                 osss_load_buffer_state(yyscanner );
01918 }
01919 
01926 void ossspush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
01927 {
01928     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01929         if (new_buffer == NULL)
01930                 return;
01931 
01932         osssensure_buffer_stack(yyscanner);
01933 
01934         /* This block is copied from osss_switch_to_buffer. */
01935         if ( YY_CURRENT_BUFFER )
01936                 {
01937                 /* Flush out information for old buffer. */
01938                 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01939                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
01940                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01941                 }
01942 
01943         /* Only push if top exists. Otherwise, replace top. */
01944         if (YY_CURRENT_BUFFER)
01945                 yyg->yy_buffer_stack_top++;
01946         YY_CURRENT_BUFFER_LVALUE = new_buffer;
01947 
01948         /* copied from osss_switch_to_buffer. */
01949         osss_load_buffer_state(yyscanner );
01950         yyg->yy_did_buffer_switch_on_eof = 1;
01951 }
01952 
01957 void ossspop_buffer_state (yyscan_t yyscanner)
01958 {
01959     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01960         if (!YY_CURRENT_BUFFER)
01961                 return;
01962 
01963         osss_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
01964         YY_CURRENT_BUFFER_LVALUE = NULL;
01965         if (yyg->yy_buffer_stack_top > 0)
01966                 --yyg->yy_buffer_stack_top;
01967 
01968         if (YY_CURRENT_BUFFER) {
01969                 osss_load_buffer_state(yyscanner );
01970                 yyg->yy_did_buffer_switch_on_eof = 1;
01971         }
01972 }
01973 
01974 /* Allocates the stack if it does not exist.
01975  *  Guarantees space for at least one push.
01976  */
01977 static void osssensure_buffer_stack (yyscan_t yyscanner)
01978 {
01979         int num_to_alloc;
01980     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01981 
01982         if (!yyg->yy_buffer_stack) {
01983 
01984                 /* First allocation is just for 2 elements, since we don't know if this
01985                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
01986                  * immediate realloc on the next call.
01987          */
01988                 num_to_alloc = 1;
01989                 yyg->yy_buffer_stack = (struct yy_buffer_state**)osssalloc
01990                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
01991                                                                 , yyscanner);
01992                 if ( ! yyg->yy_buffer_stack )
01993                         YY_FATAL_ERROR( "out of dynamic memory in osssensure_buffer_stack()" );
01994                                                                   
01995                 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
01996                                 
01997                 yyg->yy_buffer_stack_max = num_to_alloc;
01998                 yyg->yy_buffer_stack_top = 0;
01999                 return;
02000         }
02001 
02002         if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
02003 
02004                 /* Increase the buffer to prepare for a possible push. */
02005                 int grow_size = 8 /* arbitrary grow size */;
02006 
02007                 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
02008                 yyg->yy_buffer_stack = (struct yy_buffer_state**)osssrealloc
02009                                                                 (yyg->yy_buffer_stack,
02010                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
02011                                                                 , yyscanner);
02012                 if ( ! yyg->yy_buffer_stack )
02013                         YY_FATAL_ERROR( "out of dynamic memory in osssensure_buffer_stack()" );
02014 
02015                 /* zero only the new slots.*/
02016                 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
02017                 yyg->yy_buffer_stack_max = num_to_alloc;
02018         }
02019 }
02020 
02027 YY_BUFFER_STATE osss_scan_buffer  (char * base, yy_size_t  size , yyscan_t yyscanner)
02028 {
02029         YY_BUFFER_STATE b;
02030     
02031         if ( size < 2 ||
02032              base[size-2] != YY_END_OF_BUFFER_CHAR ||
02033              base[size-1] != YY_END_OF_BUFFER_CHAR )
02034                 /* They forgot to leave room for the EOB's. */
02035                 return 0;
02036 
02037         b = (YY_BUFFER_STATE) osssalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
02038         if ( ! b )
02039                 YY_FATAL_ERROR( "out of dynamic memory in osss_scan_buffer()" );
02040 
02041         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
02042         b->yy_buf_pos = b->yy_ch_buf = base;
02043         b->yy_is_our_buffer = 0;
02044         b->yy_input_file = 0;
02045         b->yy_n_chars = b->yy_buf_size;
02046         b->yy_is_interactive = 0;
02047         b->yy_at_bol = 1;
02048         b->yy_fill_buffer = 0;
02049         b->yy_buffer_status = YY_BUFFER_NEW;
02050 
02051         osss_switch_to_buffer(b ,yyscanner );
02052 
02053         return b;
02054 }
02055 
02064 YY_BUFFER_STATE osss_scan_string (yyconst char * yystr , yyscan_t yyscanner)
02065 {
02066     
02067         return osss_scan_bytes(yystr,strlen(yystr) ,yyscanner);
02068 }
02069 
02077 YY_BUFFER_STATE osss_scan_bytes  (yyconst char * yybytes, int  _yybytes_len , yyscan_t yyscanner)
02078 {
02079         YY_BUFFER_STATE b;
02080         char *buf;
02081         yy_size_t n;
02082         int i;
02083     
02084         /* Get memory for full buffer, including space for trailing EOB's. */
02085         n = _yybytes_len + 2;
02086         buf = (char *) osssalloc(n ,yyscanner );
02087         if ( ! buf )
02088                 YY_FATAL_ERROR( "out of dynamic memory in osss_scan_bytes()" );
02089 
02090         for ( i = 0; i < _yybytes_len; ++i )
02091                 buf[i] = yybytes[i];
02092 
02093         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
02094 
02095         b = osss_scan_buffer(buf,n ,yyscanner);
02096         if ( ! b )
02097                 YY_FATAL_ERROR( "bad buffer in osss_scan_bytes()" );
02098 
02099         /* It's okay to grow etc. this buffer, and we should throw it
02100          * away when we're done.
02101          */
02102         b->yy_is_our_buffer = 1;
02103 
02104         return b;
02105 }
02106 
02107 #ifndef YY_EXIT_FAILURE
02108 #define YY_EXIT_FAILURE 2
02109 #endif
02110 
02111 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
02112 {
02113         (void) fprintf( stderr, "%s\n", msg );
02114         exit( YY_EXIT_FAILURE );
02115 }
02116 
02117 /* Redefine yyless() so it works in section 3 code. */
02118 
02119 #undef yyless
02120 #define yyless(n) \
02121         do \
02122                 { \
02123                 /* Undo effects of setting up yytext. */ \
02124         int yyless_macro_arg = (n); \
02125         YY_LESS_LINENO(yyless_macro_arg);\
02126                 yytext[yyleng] = yyg->yy_hold_char; \
02127                 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
02128                 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
02129                 *yyg->yy_c_buf_p = '\0'; \
02130                 yyleng = yyless_macro_arg; \
02131                 } \
02132         while ( 0 )
02133 
02134 /* Accessor  methods (get/set functions) to struct members. */
02135 
02139 YY_EXTRA_TYPE osssget_extra  (yyscan_t yyscanner)
02140 {
02141     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02142     return yyextra;
02143 }
02144 
02148 int osssget_lineno  (yyscan_t yyscanner)
02149 {
02150     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02151     
02152         if (! YY_CURRENT_BUFFER)
02153             return 0;
02154     
02155     return yylineno;
02156 }
02157 
02161 int osssget_column  (yyscan_t yyscanner)
02162 {
02163     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02164     
02165         if (! YY_CURRENT_BUFFER)
02166             return 0;
02167     
02168     return yycolumn;
02169 }
02170 
02174 FILE *osssget_in  (yyscan_t yyscanner)
02175 {
02176     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02177     return yyin;
02178 }
02179 
02183 FILE *osssget_out  (yyscan_t yyscanner)
02184 {
02185     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02186     return yyout;
02187 }
02188 
02192 int osssget_leng  (yyscan_t yyscanner)
02193 {
02194     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02195     return yyleng;
02196 }
02197 
02202 char *osssget_text  (yyscan_t yyscanner)
02203 {
02204     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02205     return yytext;
02206 }
02207 
02212 void osssset_extra (YY_EXTRA_TYPE  user_defined , yyscan_t yyscanner)
02213 {
02214     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02215     yyextra = user_defined ;
02216 }
02217 
02222 void osssset_lineno (int  line_number , yyscan_t yyscanner)
02223 {
02224     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02225 
02226         /* lineno is only valid if an input buffer exists. */
02227         if (! YY_CURRENT_BUFFER )
02228            yy_fatal_error( "osssset_lineno called with no buffer" , yyscanner); 
02229     
02230     yylineno = line_number;
02231 }
02232 
02237 void osssset_column (int  column_no , yyscan_t yyscanner)
02238 {
02239     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02240 
02241         /* column is only valid if an input buffer exists. */
02242         if (! YY_CURRENT_BUFFER )
02243            yy_fatal_error( "osssset_column called with no buffer" , yyscanner); 
02244     
02245     yycolumn = column_no;
02246 }
02247 
02254 void osssset_in (FILE *  in_str , yyscan_t yyscanner)
02255 {
02256     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02257     yyin = in_str ;
02258 }
02259 
02260 void osssset_out (FILE *  out_str , yyscan_t yyscanner)
02261 {
02262     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02263     yyout = out_str ;
02264 }
02265 
02266 int osssget_debug  (yyscan_t yyscanner)
02267 {
02268     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02269     return yy_flex_debug;
02270 }
02271 
02272 void osssset_debug (int  bdebug , yyscan_t yyscanner)
02273 {
02274     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02275     yy_flex_debug = bdebug ;
02276 }
02277 
02278 /* Accessor methods for yylval and yylloc */
02279 
02280 /* User-visible API */
02281 
02282 /* ossslex_init is special because it creates the scanner itself, so it is
02283  * the ONLY reentrant function that doesn't take the scanner as the last argument.
02284  * That's why we explicitly handle the declaration, instead of using our macros.
02285  */
02286 
02287 int ossslex_init(yyscan_t* ptr_yy_globals)
02288 
02289 {
02290     if (ptr_yy_globals == NULL){
02291         errno = EINVAL;
02292         return 1;
02293     }
02294 
02295     *ptr_yy_globals = (yyscan_t) osssalloc ( sizeof( struct yyguts_t ), NULL );
02296 
02297     if (*ptr_yy_globals == NULL){
02298         errno = ENOMEM;
02299         return 1;
02300     }
02301 
02302     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
02303     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
02304 
02305     return yy_init_globals ( *ptr_yy_globals );
02306 }
02307 
02308 /* ossslex_init_extra has the same functionality as ossslex_init, but follows the
02309  * convention of taking the scanner as the last argument. Note however, that
02310  * this is a *pointer* to a scanner, as it will be allocated by this call (and
02311  * is the reason, too, why this function also must handle its own declaration).
02312  * The user defined value in the first argument will be available to osssalloc in
02313  * the yyextra field.
02314  */
02315 
02316 int ossslex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
02317 
02318 {
02319     struct yyguts_t dummy_yyguts;
02320 
02321     osssset_extra (yy_user_defined, &dummy_yyguts);
02322 
02323     if (ptr_yy_globals == NULL){
02324         errno = EINVAL;
02325         return 1;
02326     }
02327         
02328     *ptr_yy_globals = (yyscan_t) osssalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
02329         
02330     if (*ptr_yy_globals == NULL){
02331         errno = ENOMEM;
02332         return 1;
02333     }
02334     
02335     /* By setting to 0xAA, we expose bugs in
02336     yy_init_globals. Leave at 0x00 for releases. */
02337     memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
02338     
02339     osssset_extra (yy_user_defined, *ptr_yy_globals);
02340     
02341     return yy_init_globals ( *ptr_yy_globals );
02342 }
02343 
02344 static int yy_init_globals (yyscan_t yyscanner)
02345 {
02346     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02347     /* Initialization is the same as for the non-reentrant scanner.
02348      * This function is called from ossslex_destroy(), so don't allocate here.
02349      */
02350 
02351     yyg->yy_buffer_stack = 0;
02352     yyg->yy_buffer_stack_top = 0;
02353     yyg->yy_buffer_stack_max = 0;
02354     yyg->yy_c_buf_p = (char *) 0;
02355     yyg->yy_init = 0;
02356     yyg->yy_start = 0;
02357 
02358     yyg->yy_start_stack_ptr = 0;
02359     yyg->yy_start_stack_depth = 0;
02360     yyg->yy_start_stack =  NULL;
02361 
02362 /* Defined in main.c */
02363 #ifdef YY_STDINIT
02364     yyin = stdin;
02365     yyout = stdout;
02366 #else
02367     yyin = (FILE *) 0;
02368     yyout = (FILE *) 0;
02369 #endif
02370 
02371     /* For future reference: Set errno on error, since we are called by
02372      * ossslex_init()
02373      */
02374     return 0;
02375 }
02376 
02377 /* ossslex_destroy is for both reentrant and non-reentrant scanners. */
02378 int ossslex_destroy  (yyscan_t yyscanner)
02379 {
02380     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02381 
02382     /* Pop the buffer stack, destroying each element. */
02383         while(YY_CURRENT_BUFFER){
02384                 osss_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
02385                 YY_CURRENT_BUFFER_LVALUE = NULL;
02386                 ossspop_buffer_state(yyscanner);
02387         }
02388 
02389         /* Destroy the stack itself. */
02390         osssfree(yyg->yy_buffer_stack ,yyscanner);
02391         yyg->yy_buffer_stack = NULL;
02392 
02393     /* Destroy the start condition stack. */
02394         osssfree(yyg->yy_start_stack ,yyscanner );
02395         yyg->yy_start_stack = NULL;
02396 
02397     /* Reset the globals. This is important in a non-reentrant scanner so the next time
02398      * ossslex() is called, initialization will occur. */
02399     yy_init_globals( yyscanner);
02400 
02401     /* Destroy the main struct (reentrant only). */
02402     osssfree ( yyscanner , yyscanner );
02403     yyscanner = NULL;
02404     return 0;
02405 }
02406 
02407 /*
02408  * Internal utility routines.
02409  */
02410 
02411 #ifndef yytext_ptr
02412 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
02413 {
02414         register int i;
02415         for ( i = 0; i < n; ++i )
02416                 s1[i] = s2[i];
02417 }
02418 #endif
02419 
02420 #ifdef YY_NEED_STRLEN
02421 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
02422 {
02423         register int n;
02424         for ( n = 0; s[n]; ++n )
02425                 ;
02426 
02427         return n;
02428 }
02429 #endif
02430 
02431 void *osssalloc (yy_size_t  size , yyscan_t yyscanner)
02432 {
02433         return (void *) malloc( size );
02434 }
02435 
02436 void *osssrealloc  (void * ptr, yy_size_t  size , yyscan_t yyscanner)
02437 {
02438         /* The cast to (char *) in the following accommodates both
02439          * implementations that use char* generic pointers, and those
02440          * that use void* generic pointers.  It works with the latter
02441          * because both ANSI C and C++ allow castless assignment from
02442          * any pointer type to void*, and deal with argument conversions
02443          * as though doing an assignment.
02444          */
02445         return (void *) realloc( (char *) ptr, size );
02446 }
02447 
02448 void osssfree (void * ptr , yyscan_t yyscanner)
02449 {
02450         free( (char *) ptr );   /* see osssrealloc() for (char *) cast */
02451 }
02452 
02453 #define YYTABLES_NAME "yytables"
02454 
02455 #line 347 "/Users/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
02456 
02457 
02458 
02459 void setyyextra(osOptionsStruc *osoptions, void* scanner){
02460         osssset_extra(osoptions, scanner);
02461 }
02462 
02463 
02464 

Generated on Tue Mar 30 03:04:41 2010 by  doxygen 1.4.7