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

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

Generated on Thu Aug 5 03:03:01 2010 by  doxygen 1.4.7