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

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

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