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

Generated on Mon May 3 03:05:29 2010 by  doxygen 1.4.7