00001 #line 2 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
00002
00003 #line 4 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
00004
00005 #define YY_INT_ALIGNED short int
00006
00007
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
00018
00019
00020 #include <stdio.h>
00021 #include <string.h>
00022 #include <errno.h>
00023 #include <stdlib.h>
00024
00025
00026
00027
00028
00029 #ifndef FLEXINT_H
00030 #define FLEXINT_H
00031
00032
00033
00034 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
00035
00036
00037
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
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
00088
00089 #endif
00090
00091 #ifdef __cplusplus
00092
00093
00094 #define YY_USE_CONST
00095
00096 #else
00097
00098
00099 #if defined (__STDC__)
00100
00101 #define YY_USE_CONST
00102
00103 #endif
00104 #endif
00105
00106 #ifdef YY_USE_CONST
00107 #define yyconst const
00108 #else
00109 #define yyconst
00110 #endif
00111
00112
00113 #define YY_NULL 0
00114
00115
00116
00117
00118
00119
00120 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00121
00122
00123 #ifndef YY_TYPEDEF_YY_SCANNER_T
00124 #define YY_TYPEDEF_YY_SCANNER_T
00125 typedef void* yyscan_t;
00126 #endif
00127
00128
00129
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
00140
00141
00142
00143 #define BEGIN yyg->yy_start = 1 + 2 *
00144
00145
00146
00147
00148
00149 #define YY_START ((yyg->yy_start - 1) / 2)
00150 #define YYSTATE YY_START
00151
00152
00153 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00154
00155
00156 #define YY_NEW_FILE osssrestart(yyin ,yyscanner )
00157
00158 #define YY_END_OF_BUFFER_CHAR 0
00159
00160
00161 #ifndef YY_BUF_SIZE
00162 #ifdef __ia64__
00163
00164
00165
00166
00167 #define YY_BUF_SIZE 32768
00168 #else
00169 #define YY_BUF_SIZE 16384
00170 #endif
00171 #endif
00172
00173
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
00187
00188
00189
00190
00191
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
00202 #define yyless(n) \
00203 do \
00204 { \
00205 \
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; \
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;
00229 char *yy_buf_pos;
00230
00231
00232
00233
00234 yy_size_t yy_buf_size;
00235
00236
00237
00238
00239 int yy_n_chars;
00240
00241
00242
00243
00244
00245 int yy_is_our_buffer;
00246
00247
00248
00249
00250
00251
00252 int yy_is_interactive;
00253
00254
00255
00256
00257
00258 int yy_at_bol;
00259
00260 int yy_bs_lineno;
00261 int yy_bs_column;
00263
00264
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
00273
00274
00275
00276
00277
00278
00279
00280
00281
00282 #define YY_BUFFER_EOF_PENDING 2
00283
00284 };
00285 #endif
00286
00287
00288
00289
00290
00291
00292
00293 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
00294 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
00295 : NULL)
00296
00297
00298
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
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
00365
00366
00367 #define YY_DO_BEFORE_ACTION \
00368 yyg->yytext_ptr = yy_bp; \
00369 yyleng = (size_t) (yy_cp - yy_bp); \
00370 yyg->yy_hold_char = *yy_cp; \
00371 *yy_cp = '\0'; \
00372 yyg->yy_c_buf_p = yy_cp;
00373
00374 #define YY_NUM_RULES 20
00375 #define YY_END_OF_BUFFER 21
00376
00377
00378 struct yy_trans_info
00379 {
00380 flex_int32_t yy_verify;
00381 flex_int32_t yy_nxt;
00382 };
00383 static yyconst flex_int16_t yy_accept[184] =
00384 { 0,
00385 1, 1, 21, 19, 1, 1, 19, 1, 0, 0,
00386 0, 4, 0, 0, 0, 0, 0, 6, 0, 0,
00387 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00388 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00389 0, 0, 0, 0, 0, 0, 0, 0, 16, 0,
00390 0, 0, 0, 0, 0, 3, 0, 0, 0, 0,
00391 0, 15, 0, 16, 0, 0, 0, 0, 0, 0,
00392 0, 0, 0, 0, 0, 0, 15, 0, 7, 0,
00393 10, 0, 0, 0, 8, 0, 0, 0, 0, 0,
00394 0, 0, 7, 0, 10, 0, 0, 0, 8, 0,
00395
00396 0, 5, 0, 0, 2, 0, 0, 0, 0, 0,
00397 0, 17, 0, 18, 0, 2, 0, 9, 0, 0,
00398 0, 0, 0, 17, 0, 18, 0, 9, 0, 0,
00399 0, 0, 0, 11, 0, 0, 0, 0, 11, 0,
00400 12, 0, 0, 0, 12, 0, 0, 0, 0, 0,
00401 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00402 0, 0, 14, 0, 0, 0, 0, 0, 0, 0,
00403 14, 0, 13, 0, 0, 0, 0, 0, 0, 0,
00404 0, 0, 0
00405 } ;
00406
00407 static yyconst flex_int32_t yy_ec[256] =
00408 { 0,
00409 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
00410 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
00411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00412 1, 2, 1, 4, 1, 5, 1, 1, 1, 1,
00413 1, 1, 1, 1, 6, 5, 5, 5, 5, 5,
00414 5, 5, 5, 5, 5, 5, 5, 5, 1, 1,
00415 1, 1, 1, 1, 5, 5, 5, 7, 5, 5,
00416 5, 5, 8, 9, 5, 10, 11, 5, 12, 5,
00417 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
00418 1, 1, 1, 1, 5, 1, 13, 14, 15, 16,
00419
00420 17, 18, 19, 20, 21, 5, 22, 23, 24, 25,
00421 26, 27, 5, 28, 29, 30, 31, 32, 33, 5,
00422 5, 5, 1, 1, 1, 5, 1, 1, 1, 1,
00423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00424 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00425 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00426 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00427 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00428 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00430
00431 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00432 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00433 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00434 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00435 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00436 1, 1, 1, 1, 1
00437 } ;
00438
00439 static yyconst flex_int32_t yy_meta[34] =
00440 { 0,
00441 1, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00442 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00443 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00444 2, 2, 2
00445 } ;
00446
00447 static yyconst flex_int16_t yy_base[209] =
00448 { 0,
00449 0, 2, 318, 319, 7, 9, 7, 12, 3, 289,
00450 290, 319, 290, 287, 290, 283, 0, 319, 294, 293,
00451 283, 283, 278, 277, 16, 16, 277, 281, 280, 274,
00452 268, 282, 289, 22, 43, 275, 274, 273, 272, 262,
00453 261, 265, 262, 261, 268, 267, 46, 26, 49, 38,
00454 52, 8, 54, 266, 269, 319, 264, 267, 264, 253,
00455 55, 58, 60, 319, 63, 66, 256, 249, 69, 264,
00456 250, 251, 248, 72, 245, 73, 319, 75, 78, 80,
00457 83, 247, 243, 85, 88, 255, 91, 246, 93, 95,
00458 98, 99, 319, 101, 319, 239, 242, 103, 319, 98,
00459
00460 108, 319, 111, 113, 116, 119, 238, 236, 240, 248,
00461 121, 124, 126, 129, 131, 319, 133, 136, 139, 234,
00462 248, 232, 140, 319, 142, 319, 144, 319, 147, 150,
00463 248, 240, 151, 154, 157, 229, 232, 159, 319, 161,
00464 164, 236, 240, 166, 319, 229, 169, 229, 171, 173,
00465 236, 13, 235, 160, 176, 221, 227, 223, 218, 222,
00466 223, 178, 181, 236, 221, 228, 214, 225, 208, 184,
00467 319, 213, 319, 216, 216, 219, 221, 217, 225, 200,
00468 224, 213, 319, 200, 227, 226, 202, 204, 225, 196,
00469 195, 206, 208, 210, 194, 193, 192, 212, 190, 214,
00470
00471 216, 218, 189, 220, 187, 222, 5, 224
00472 } ;
00473
00474 static yyconst flex_int16_t yy_def[209] =
00475 { 0,
00476 184, 184, 183, 183, 183, 183, 183, 183, 183, 183,
00477 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00478 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00479 183, 183, 183, 183, 185, 183, 183, 183, 183, 183,
00480 183, 183, 183, 183, 183, 183, 186, 187, 185, 183,
00481 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00482 188, 186, 187, 183, 189, 190, 183, 183, 191, 183,
00483 183, 183, 183, 183, 183, 188, 183, 192, 189, 193,
00484 190, 183, 183, 194, 191, 183, 183, 183, 183, 195,
00485 183, 192, 183, 193, 183, 183, 183, 194, 183, 183,
00486
00487 196, 183, 197, 198, 195, 199, 183, 183, 183, 183,
00488 200, 196, 201, 197, 198, 183, 202, 199, 183, 183,
00489 183, 183, 200, 183, 201, 183, 202, 183, 203, 183,
00490 183, 183, 204, 203, 205, 183, 183, 204, 183, 206,
00491 205, 183, 183, 206, 183, 183, 183, 183, 183, 183,
00492 183, 183, 183, 183, 207, 183, 183, 183, 183, 183,
00493 183, 208, 207, 183, 183, 183, 183, 183, 183, 208,
00494 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00495 183, 183, 0, 183, 183, 183, 183, 183, 183, 183,
00496 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00497
00498 183, 183, 183, 183, 183, 183, 183, 183
00499 } ;
00500
00501 static yyconst flex_int16_t yy_nxt[353] =
00502 { 0,
00503 183, 5, 6, 5, 6, 7, 163, 7, 8, 8,
00504 8, 8, 9, 8, 8, 67, 27, 35, 35, 68,
00505 10, 11, 19, 47, 47, 28, 12, 13, 64, 64,
00506 14, 15, 16, 157, 20, 17, 36, 158, 18, 65,
00507 65, 37, 38, 39, 35, 35, 48, 47, 47, 61,
00508 183, 183, 183, 66, 66, 69, 69, 77, 77, 183,
00509 183, 183, 64, 64, 65, 65, 78, 66, 66, 80,
00510 69, 69, 84, 90, 90, 77, 77, 93, 93, 183,
00511 183, 183, 95, 95, 183, 183, 183, 99, 99, 183,
00512 183, 183, 101, 101, 103, 103, 90, 90, 104, 106,
00513
00514 106, 93, 93, 95, 95, 99, 99, 109, 110, 101,
00515 101, 111, 103, 103, 113, 116, 116, 183, 183, 183,
00516 106, 106, 117, 124, 124, 183, 183, 183, 126, 126,
00517 183, 183, 183, 116, 116, 128, 128, 183, 183, 183,
00518 129, 129, 124, 124, 126, 126, 128, 128, 129, 129,
00519 133, 135, 135, 139, 139, 183, 183, 183, 135, 135,
00520 140, 139, 139, 145, 145, 183, 183, 183, 145, 145,
00521 149, 149, 149, 149, 155, 155, 160, 155, 155, 162,
00522 171, 171, 183, 183, 183, 161, 171, 171, 141, 151,
00523 134, 118, 152, 114, 112, 105, 85, 81, 153, 154,
00524
00525 4, 4, 63, 63, 76, 76, 92, 92, 94, 94,
00526 98, 98, 115, 115, 123, 123, 125, 125, 127, 127,
00527 138, 138, 144, 144, 170, 170, 79, 62, 49, 173,
00528 173, 182, 181, 180, 179, 173, 178, 173, 177, 176,
00529 173, 175, 174, 173, 172, 169, 168, 167, 166, 165,
00530 164, 159, 156, 150, 148, 147, 146, 143, 142, 137,
00531 136, 132, 131, 130, 122, 121, 120, 119, 108, 107,
00532 102, 100, 97, 96, 91, 89, 88, 87, 86, 83,
00533 82, 75, 74, 73, 72, 71, 70, 60, 59, 58,
00534 57, 56, 55, 54, 53, 52, 51, 50, 46, 45,
00535
00536 44, 43, 42, 41, 40, 34, 33, 32, 31, 30,
00537 29, 26, 25, 24, 23, 22, 21, 183, 3, 183,
00538 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00539 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00540 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00541 183, 183
00542 } ;
00543
00544 static yyconst flex_int16_t yy_chk[353] =
00545 { 0,
00546 0, 1, 1, 2, 2, 1, 207, 2, 5, 5,
00547 6, 6, 7, 8, 8, 52, 17, 25, 25, 52,
00548 7, 7, 9, 34, 34, 17, 7, 7, 48, 48,
00549 7, 7, 7, 152, 9, 7, 26, 152, 7, 50,
00550 50, 26, 26, 26, 35, 35, 35, 47, 47, 47,
00551 49, 49, 49, 51, 51, 53, 53, 61, 61, 62,
00552 62, 62, 63, 63, 65, 65, 65, 66, 66, 66,
00553 69, 69, 69, 74, 74, 76, 76, 78, 78, 79,
00554 79, 79, 80, 80, 81, 81, 81, 84, 84, 85,
00555 85, 85, 87, 87, 89, 89, 90, 90, 90, 91,
00556
00557 91, 92, 92, 94, 94, 98, 98, 100, 100, 101,
00558 101, 101, 103, 103, 103, 104, 104, 105, 105, 105,
00559 106, 106, 106, 111, 111, 112, 112, 112, 113, 113,
00560 114, 114, 114, 115, 115, 117, 117, 118, 118, 118,
00561 119, 119, 123, 123, 125, 125, 127, 127, 129, 129,
00562 129, 130, 130, 133, 133, 134, 134, 134, 135, 135,
00563 135, 138, 138, 140, 140, 141, 141, 141, 144, 144,
00564 147, 147, 149, 149, 150, 150, 154, 155, 155, 155,
00565 162, 162, 163, 163, 163, 154, 170, 170, 205, 149,
00566 203, 199, 149, 197, 196, 195, 191, 190, 149, 149,
00567
00568 184, 184, 187, 187, 188, 188, 192, 192, 193, 193,
00569 194, 194, 198, 198, 200, 200, 201, 201, 202, 202,
00570 204, 204, 206, 206, 208, 208, 189, 186, 185, 182,
00571 181, 180, 179, 178, 177, 176, 175, 174, 172, 169,
00572 168, 167, 166, 165, 164, 161, 160, 159, 158, 157,
00573 156, 153, 151, 148, 146, 143, 142, 137, 136, 132,
00574 131, 122, 121, 120, 110, 109, 108, 107, 97, 96,
00575 88, 86, 83, 82, 75, 73, 72, 71, 70, 68,
00576 67, 60, 59, 58, 57, 55, 54, 46, 45, 44,
00577 43, 42, 41, 40, 39, 38, 37, 36, 33, 32,
00578
00579 31, 30, 29, 28, 27, 24, 23, 22, 21, 20,
00580 19, 16, 15, 14, 13, 11, 10, 3, 183, 183,
00581 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00582 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00583 183, 183, 183, 183, 183, 183, 183, 183, 183, 183,
00584 183, 183
00585 } ;
00586
00587
00588 static yyconst flex_int32_t yy_rule_can_match_eol[21] =
00589 { 0,
00590 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
00591 0, };
00592
00593
00594
00595
00596 #define REJECT reject_used_but_not_detected
00597 #define yymore() yymore_used_but_not_detected
00598 #define YY_MORE_ADJ 0
00599 #define YY_RESTORE_YY_MORE_OFFSET
00600 #line 1 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
00601
00616 #line 18 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
00617
00618
00619 #include <iostream>
00620 #include "OSConfig.h"
00621
00622
00623 #ifdef HAVE_CSTRING
00624 # include <cstring>
00625 #else
00626 # ifdef HAVE_STRING_H
00627 # include <string.h>
00628 # else
00629 # error "don't have header file for string"
00630 # endif
00631 #endif
00632
00633 #ifdef HAVE_CSTDIO
00634 # include <cstdio>
00635 #else
00636 # ifdef HAVE_STDIO_H
00637 # include <stdio.h>
00638 # else
00639 # error "don't have header file for stdio"
00640 # endif
00641 #endif
00642 #include "OSErrorClass.h"
00643 #include <sstream>
00644 #include "OSOptionsStruc.h"
00645
00646
00647 using std::cout;
00648 using std::endl;
00649 using std::ostringstream;
00650
00651
00652 #ifdef PARSERDEBUG
00653 #define YY_PRINT printf("Found option: %s\n", yytext);
00654 #else
00655 #define YY_PRINT ;
00656 #endif
00657
00658
00659 #ifdef WIN_
00660 #define YY_NO_UNISTD_H
00661 #include <io.h>
00662 #include <process.h>
00663 #ifdef USE_OLD_UNISTD
00664 #include<sys/unistd.h>
00665 #endif
00666 #endif
00667
00668
00669 #define YY_EXTRA_TYPE struct osOptionsStruc*
00670
00671 void setyyextra( osOptionsStruc *osoptions, void* scanner);
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695
00696
00697
00698
00699
00700 #line 701 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
00701
00702 #define INITIAL 0
00703
00704 #ifndef YY_NO_UNISTD_H
00705
00706
00707
00708
00709 #include <unistd.h>
00710 #endif
00711
00712 #ifndef YY_EXTRA_TYPE
00713 #define YY_EXTRA_TYPE void *
00714 #endif
00715
00716
00717 struct yyguts_t
00718 {
00719
00720
00721 YY_EXTRA_TYPE yyextra_r;
00722
00723
00724 FILE *yyin_r, *yyout_r;
00725 size_t yy_buffer_stack_top;
00726 size_t yy_buffer_stack_max;
00727 YY_BUFFER_STATE * yy_buffer_stack;
00728 char yy_hold_char;
00729 int yy_n_chars;
00730 int yyleng_r;
00731 char *yy_c_buf_p;
00732 int yy_init;
00733 int yy_start;
00734 int yy_did_buffer_switch_on_eof;
00735 int yy_start_stack_ptr;
00736 int yy_start_stack_depth;
00737 int *yy_start_stack;
00738 yy_state_type yy_last_accepting_state;
00739 char* yy_last_accepting_cpos;
00740
00741 int yylineno_r;
00742 int yy_flex_debug_r;
00743
00744 char *yytext_r;
00745 int yy_more_flag;
00746 int yy_more_len;
00747
00748 };
00749
00750 static int yy_init_globals (yyscan_t yyscanner );
00751
00752 int ossslex_init (yyscan_t* scanner);
00753
00754 int ossslex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
00755
00756
00757
00758
00759 int ossslex_destroy (yyscan_t yyscanner );
00760
00761 int osssget_debug (yyscan_t yyscanner );
00762
00763 void osssset_debug (int debug_flag ,yyscan_t yyscanner );
00764
00765 YY_EXTRA_TYPE osssget_extra (yyscan_t yyscanner );
00766
00767 void osssset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
00768
00769 FILE *osssget_in (yyscan_t yyscanner );
00770
00771 void osssset_in (FILE * in_str ,yyscan_t yyscanner );
00772
00773 FILE *osssget_out (yyscan_t yyscanner );
00774
00775 void osssset_out (FILE * out_str ,yyscan_t yyscanner );
00776
00777 int osssget_leng (yyscan_t yyscanner );
00778
00779 char *osssget_text (yyscan_t yyscanner );
00780
00781 int osssget_lineno (yyscan_t yyscanner );
00782
00783 void osssset_lineno (int line_number ,yyscan_t yyscanner );
00784
00785
00786
00787
00788
00789 #ifndef YY_SKIP_YYWRAP
00790 #ifdef __cplusplus
00791 extern "C" int ossswrap (yyscan_t yyscanner );
00792 #else
00793 extern int ossswrap (yyscan_t yyscanner );
00794 #endif
00795 #endif
00796
00797 #ifndef yytext_ptr
00798 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
00799 #endif
00800
00801 #ifdef YY_NEED_STRLEN
00802 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
00803 #endif
00804
00805 #ifndef YY_NO_INPUT
00806
00807 #ifdef __cplusplus
00808 static int yyinput (yyscan_t yyscanner );
00809 #else
00810 static int input (yyscan_t yyscanner );
00811 #endif
00812
00813 #endif
00814
00815
00816 #ifndef YY_READ_BUF_SIZE
00817 #ifdef __ia64__
00818
00819 #define YY_READ_BUF_SIZE 16384
00820 #else
00821 #define YY_READ_BUF_SIZE 8192
00822 #endif
00823 #endif
00824
00825
00826 #ifndef ECHO
00827
00828
00829
00830 #define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
00831 #endif
00832
00833
00834
00835
00836 #ifndef YY_INPUT
00837 #define YY_INPUT(buf,result,max_size) \
00838 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
00839 { \
00840 int c = '*'; \
00841 size_t n; \
00842 for ( n = 0; n < max_size && \
00843 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00844 buf[n] = (char) c; \
00845 if ( c == '\n' ) \
00846 buf[n++] = (char) c; \
00847 if ( c == EOF && ferror( yyin ) ) \
00848 YY_FATAL_ERROR( "input in flex scanner failed" ); \
00849 result = n; \
00850 } \
00851 else \
00852 { \
00853 errno=0; \
00854 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
00855 { \
00856 if( errno != EINTR) \
00857 { \
00858 YY_FATAL_ERROR( "input in flex scanner failed" ); \
00859 break; \
00860 } \
00861 errno=0; \
00862 clearerr(yyin); \
00863 } \
00864 }\
00865 \
00866
00867 #endif
00868
00869
00870
00871
00872
00873 #ifndef yyterminate
00874 #define yyterminate() return YY_NULL
00875 #endif
00876
00877
00878 #ifndef YY_START_STACK_INCR
00879 #define YY_START_STACK_INCR 25
00880 #endif
00881
00882
00883 #ifndef YY_FATAL_ERROR
00884 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
00885 #endif
00886
00887
00888
00889
00890
00891
00892 #ifndef YY_DECL
00893 #define YY_DECL_IS_OURS 1
00894
00895 extern int ossslex (yyscan_t yyscanner);
00896
00897 #define YY_DECL int ossslex (yyscan_t yyscanner)
00898 #endif
00899
00900
00901
00902
00903 #ifndef YY_USER_ACTION
00904 #define YY_USER_ACTION
00905 #endif
00906
00907
00908 #ifndef YY_BREAK
00909 #define YY_BREAK break;
00910 #endif
00911
00912 #define YY_RULE_SETUP \
00913 YY_USER_ACTION
00914
00917 YY_DECL
00918 {
00919 register yy_state_type yy_current_state;
00920 register char *yy_cp, *yy_bp;
00921 register int yy_act;
00922 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
00923
00924 #line 114 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
00925
00926
00927 #line 928 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
00928
00929 if ( !yyg->yy_init )
00930 {
00931 yyg->yy_init = 1;
00932
00933 #ifdef YY_USER_INIT
00934 YY_USER_INIT;
00935 #endif
00936
00937 if ( ! yyg->yy_start )
00938 yyg->yy_start = 1;
00939
00940 if ( ! yyin )
00941 yyin = stdin;
00942
00943 if ( ! yyout )
00944 yyout = stdout;
00945
00946 if ( ! YY_CURRENT_BUFFER ) {
00947 osssensure_buffer_stack (yyscanner);
00948 YY_CURRENT_BUFFER_LVALUE =
00949 osss_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
00950 }
00951
00952 osss_load_buffer_state(yyscanner );
00953 }
00954
00955 while ( 1 )
00956 {
00957 yy_cp = yyg->yy_c_buf_p;
00958
00959
00960 *yy_cp = yyg->yy_hold_char;
00961
00962
00963
00964
00965 yy_bp = yy_cp;
00966
00967 yy_current_state = yyg->yy_start;
00968 yy_match:
00969 do
00970 {
00971 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00972 if ( yy_accept[yy_current_state] )
00973 {
00974 yyg->yy_last_accepting_state = yy_current_state;
00975 yyg->yy_last_accepting_cpos = yy_cp;
00976 }
00977 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00978 {
00979 yy_current_state = (int) yy_def[yy_current_state];
00980 if ( yy_current_state >= 184 )
00981 yy_c = yy_meta[(unsigned int) yy_c];
00982 }
00983 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00984 ++yy_cp;
00985 }
00986 while ( yy_base[yy_current_state] != 319 );
00987
00988 yy_find_action:
00989 yy_act = yy_accept[yy_current_state];
00990 if ( yy_act == 0 )
00991 {
00992 yy_cp = yyg->yy_last_accepting_cpos;
00993 yy_current_state = yyg->yy_last_accepting_state;
00994 yy_act = yy_accept[yy_current_state];
00995 }
00996
00997 YY_DO_BEFORE_ACTION;
00998
00999 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
01000 {
01001 int yyl;
01002 for ( yyl = 0; yyl < yyleng; ++yyl )
01003 if ( yytext[yyl] == '\n' )
01004
01005 do{ yylineno++;
01006 yycolumn=0;
01007 }while(0)
01008 ;
01009 }
01010
01011 do_action:
01012
01013 switch ( yy_act )
01014 {
01015 case 0:
01016
01017 *yy_cp = yyg->yy_hold_char;
01018 yy_cp = yyg->yy_last_accepting_cpos;
01019 yy_current_state = yyg->yy_last_accepting_state;
01020 goto yy_find_action;
01021
01022 case 1:
01023
01024 YY_RULE_SETUP
01025 #line 116 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01026
01027 YY_BREAK
01028 case 2:
01029
01030 YY_RULE_SETUP
01031 #line 120 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01032 {
01033 YY_PRINT
01034
01035 char *ch = yytext;
01036
01037 ch+=7;
01038 for(; isspace(*ch); ch++);
01039 std::string str( ch);
01040 yyextra->configFile = str;
01041
01042 }
01043 YY_BREAK
01044 case 3:
01045 YY_RULE_SETUP
01046 #line 133 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01047 {
01048 YY_PRINT
01049 yyextra->invokeHelp = true;
01050
01051 }
01052 YY_BREAK
01053 case 4:
01054 YY_RULE_SETUP
01055 #line 139 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01056 {
01057 YY_PRINT
01058 yyextra->invokeHelp = true;
01059
01060
01061 }
01062 YY_BREAK
01063 case 5:
01064 YY_RULE_SETUP
01065 #line 146 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01066 {
01067 YY_PRINT
01068 yyextra->writeVersion = true;
01069
01070 }
01071 YY_BREAK
01072 case 6:
01073 YY_RULE_SETUP
01074 #line 152 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01075 {
01076 YY_PRINT
01077 yyextra->writeVersion = true;
01078
01079
01080 }
01081 YY_BREAK
01082 case 7:
01083
01084 YY_RULE_SETUP
01085 #line 161 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01086 {
01087 if(yyextra->osilFile == ""){
01088 YY_PRINT
01089
01090 char *ch = yytext;
01091
01092 ch+=5;
01093 for(; isspace(*ch); ch++);
01094 std::string str( ch);
01095 yyextra->osilFile = str;
01096 }
01097 }
01098 YY_BREAK
01099 case 8:
01100
01101 YY_RULE_SETUP
01102 #line 174 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01103 {
01104 if(yyextra->osrlFile == ""){
01105 YY_PRINT
01106
01107 char *ch = yytext;
01108
01109 ch+=5;
01110 for(; isspace(*ch); ch++);
01111 std::string str( ch);
01112 yyextra->osrlFile = str;
01113 }
01114 }
01115 YY_BREAK
01116 case 9:
01117
01118 YY_RULE_SETUP
01119 #line 187 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01120 {
01121 if(yyextra->insListFile == ""){
01122 YY_PRINT
01123
01124 char *ch = yytext;
01125
01126 ch+=8;
01127 for(; isspace(*ch); ch++);
01128 std::string str( ch);
01129 yyextra->insListFile = str;
01130 }
01131 }
01132 YY_BREAK
01133 case 10:
01134
01135 YY_RULE_SETUP
01136 #line 200 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01137 {
01138 if(yyextra->osolFile == ""){
01139 YY_PRINT
01140
01141 char *ch = yytext;
01142
01143 ch+=5;
01144 for(; isspace(*ch); ch++);
01145 std::string str( ch);
01146 yyextra->osolFile = str;
01147 }
01148 }
01149 YY_BREAK
01150 case 11:
01151
01152 YY_RULE_SETUP
01153 #line 215 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01154 {
01155 if(yyextra->osplInputFile == ""){
01156 YY_PRINT
01157
01158 char *ch = yytext;
01159
01160 ch+=10;
01161 for(; isspace(*ch); ch++);
01162 std::string str( ch);
01163 yyextra->osplInputFile = str;
01164 }
01165 }
01166 YY_BREAK
01167 case 12:
01168
01169 YY_RULE_SETUP
01170 #line 228 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01171 {
01172 if(yyextra->osplOutputFile == ""){
01173 YY_PRINT
01174
01175 char *ch = yytext;
01176
01177 ch+=11;
01178 for(; isspace(*ch); ch++);
01179 std::string str( ch);
01180 yyextra->osplOutputFile = str;
01181 }
01182 }
01183 YY_BREAK
01184 case 13:
01185
01186 YY_RULE_SETUP
01187 #line 241 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01188 {
01189 if(yyextra->serviceMethod == ""){
01190 YY_PRINT
01191
01192 char *ch = yytext;
01193
01194 ch+=14;
01195 for(; isspace(*ch); ch++);
01196 std::string str( ch);
01197 yyextra->serviceMethod = str;
01198 }
01199 }
01200 YY_BREAK
01201 case 14:
01202
01203 YY_RULE_SETUP
01204 #line 254 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01205 {
01206 if(yyextra->serviceLocation == ""){
01207 YY_PRINT
01208
01209 yyextra->serviceLocation = yytext;
01210
01211 char *ch = yytext;
01212
01213 ch+=16;
01214 for(; isspace(*ch); ch++);
01215 std::string str( ch);
01216 yyextra->serviceLocation = str;
01217 }
01218 }
01219 YY_BREAK
01220 case 15:
01221
01222 YY_RULE_SETUP
01223 #line 269 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01224 {
01225 if(yyextra->mpsFile == ""){
01226 YY_PRINT
01227
01228 char *ch = yytext;
01229
01230 ch+=4;
01231 for(; isspace(*ch); ch++);
01232 std::string str( ch);
01233 yyextra->mpsFile = str;
01234 }
01235 }
01236 YY_BREAK
01237 case 16:
01238
01239 YY_RULE_SETUP
01240 #line 282 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01241 {
01242 if(yyextra->nlFile == ""){
01243 YY_PRINT
01244
01245 char *ch = yytext;
01246
01247 ch+=3;
01248 for(; isspace(*ch); ch++);
01249 std::string str( ch);
01250 yyextra->nlFile = str;
01251 }
01252 }
01253 YY_BREAK
01254 case 17:
01255
01256 YY_RULE_SETUP
01257 #line 295 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01258 {
01259 if(yyextra->solverName == ""){
01260 YY_PRINT
01261
01262 char *ch = yytext;
01263
01264 ch+=7;
01265 for(; isspace(*ch); ch++);
01266 std::string str( ch);
01267 yyextra->solverName = str;
01268 }
01269 }
01270 YY_BREAK
01271 case 18:
01272
01273 YY_RULE_SETUP
01274 #line 308 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01275 {
01276 if(yyextra->browser == ""){
01277 YY_PRINT
01278
01279 char *ch = yytext;
01280
01281 ch+=8;
01282 for(; isspace(*ch); ch++);
01283 std::string str( ch);
01284 yyextra->browser = str;
01285 }
01286 }
01287 YY_BREAK
01288 case 19:
01289 YY_RULE_SETUP
01290 #line 321 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01291 {
01292 std::string error;
01293 std::ostringstream outStr;
01294 outStr << "ecountered a spurious character in the lexer" << endl;
01295 outStr << "The first character is: ";
01296 outStr << yytext;
01297 outStr << endl;
01298
01299 error = outStr.str();
01300 throw ErrorClass( error);
01301 }
01302 YY_BREAK
01303 case 20:
01304 YY_RULE_SETUP
01305 #line 332 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
01306 ECHO;
01307 YY_BREAK
01308 #line 1309 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.cpp"
01309 case YY_STATE_EOF(INITIAL):
01310 yyterminate();
01311
01312 case YY_END_OF_BUFFER:
01313 {
01314
01315 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
01316
01317
01318 *yy_cp = yyg->yy_hold_char;
01319 YY_RESTORE_YY_MORE_OFFSET
01320
01321 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
01322 {
01323
01324
01325
01326
01327
01328
01329
01330
01331
01332 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
01333 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
01334 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
01335 }
01336
01337
01338
01339
01340
01341
01342
01343
01344 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
01345 {
01346 yy_state_type yy_next_state;
01347
01348 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
01349
01350 yy_current_state = yy_get_previous_state( yyscanner );
01351
01352
01353
01354
01355
01356
01357
01358
01359
01360
01361 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
01362
01363 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
01364
01365 if ( yy_next_state )
01366 {
01367
01368 yy_cp = ++yyg->yy_c_buf_p;
01369 yy_current_state = yy_next_state;
01370 goto yy_match;
01371 }
01372
01373 else
01374 {
01375 yy_cp = yyg->yy_c_buf_p;
01376 goto yy_find_action;
01377 }
01378 }
01379
01380 else switch ( yy_get_next_buffer( yyscanner ) )
01381 {
01382 case EOB_ACT_END_OF_FILE:
01383 {
01384 yyg->yy_did_buffer_switch_on_eof = 0;
01385
01386 if ( ossswrap(yyscanner ) )
01387 {
01388
01389
01390
01391
01392
01393
01394
01395
01396
01397 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
01398
01399 yy_act = YY_STATE_EOF(YY_START);
01400 goto do_action;
01401 }
01402
01403 else
01404 {
01405 if ( ! yyg->yy_did_buffer_switch_on_eof )
01406 YY_NEW_FILE;
01407 }
01408 break;
01409 }
01410
01411 case EOB_ACT_CONTINUE_SCAN:
01412 yyg->yy_c_buf_p =
01413 yyg->yytext_ptr + yy_amount_of_matched_text;
01414
01415 yy_current_state = yy_get_previous_state( yyscanner );
01416
01417 yy_cp = yyg->yy_c_buf_p;
01418 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
01419 goto yy_match;
01420
01421 case EOB_ACT_LAST_MATCH:
01422 yyg->yy_c_buf_p =
01423 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
01424
01425 yy_current_state = yy_get_previous_state( yyscanner );
01426
01427 yy_cp = yyg->yy_c_buf_p;
01428 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
01429 goto yy_find_action;
01430 }
01431 break;
01432 }
01433
01434 default:
01435 YY_FATAL_ERROR(
01436 "fatal flex scanner internal error--no action found" );
01437 }
01438 }
01439 }
01440
01441
01442
01443
01444
01445
01446
01447
01448 static int yy_get_next_buffer (yyscan_t yyscanner)
01449 {
01450 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01451 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
01452 register char *source = yyg->yytext_ptr;
01453 register int number_to_move, i;
01454 int ret_val;
01455
01456 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
01457 YY_FATAL_ERROR(
01458 "fatal flex scanner internal error--end of buffer missed" );
01459
01460 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
01461 {
01462 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
01463 {
01464
01465
01466
01467 return EOB_ACT_END_OF_FILE;
01468 }
01469
01470 else
01471 {
01472
01473
01474
01475 return EOB_ACT_LAST_MATCH;
01476 }
01477 }
01478
01479
01480
01481
01482 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
01483
01484 for ( i = 0; i < number_to_move; ++i )
01485 *(dest++) = *(source++);
01486
01487 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01488
01489
01490
01491 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
01492
01493 else
01494 {
01495 int num_to_read =
01496 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
01497
01498 while ( num_to_read <= 0 )
01499 {
01500
01501
01502 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
01503
01504 int yy_c_buf_p_offset =
01505 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
01506
01507 if ( b->yy_is_our_buffer )
01508 {
01509 int new_size = b->yy_buf_size * 2;
01510
01511 if ( new_size <= 0 )
01512 b->yy_buf_size += b->yy_buf_size / 8;
01513 else
01514 b->yy_buf_size *= 2;
01515
01516 b->yy_ch_buf = (char *)
01517
01518 osssrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
01519 }
01520 else
01521
01522 b->yy_ch_buf = 0;
01523
01524 if ( ! b->yy_ch_buf )
01525 YY_FATAL_ERROR(
01526 "fatal error - scanner input buffer overflow" );
01527
01528 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
01529
01530 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
01531 number_to_move - 1;
01532
01533 }
01534
01535 if ( num_to_read > YY_READ_BUF_SIZE )
01536 num_to_read = YY_READ_BUF_SIZE;
01537
01538
01539 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
01540 yyg->yy_n_chars, (size_t) num_to_read );
01541
01542 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01543 }
01544
01545 if ( yyg->yy_n_chars == 0 )
01546 {
01547 if ( number_to_move == YY_MORE_ADJ )
01548 {
01549 ret_val = EOB_ACT_END_OF_FILE;
01550 osssrestart(yyin ,yyscanner);
01551 }
01552
01553 else
01554 {
01555 ret_val = EOB_ACT_LAST_MATCH;
01556 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
01557 YY_BUFFER_EOF_PENDING;
01558 }
01559 }
01560
01561 else
01562 ret_val = EOB_ACT_CONTINUE_SCAN;
01563
01564 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
01565
01566 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
01567 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) osssrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
01568 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
01569 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
01570 }
01571
01572 yyg->yy_n_chars += number_to_move;
01573 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
01574 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
01575
01576 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
01577
01578 return ret_val;
01579 }
01580
01581
01582
01583 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
01584 {
01585 register yy_state_type yy_current_state;
01586 register char *yy_cp;
01587 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01588
01589 yy_current_state = yyg->yy_start;
01590
01591 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
01592 {
01593 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01594 if ( yy_accept[yy_current_state] )
01595 {
01596 yyg->yy_last_accepting_state = yy_current_state;
01597 yyg->yy_last_accepting_cpos = yy_cp;
01598 }
01599 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01600 {
01601 yy_current_state = (int) yy_def[yy_current_state];
01602 if ( yy_current_state >= 184 )
01603 yy_c = yy_meta[(unsigned int) yy_c];
01604 }
01605 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01606 }
01607
01608 return yy_current_state;
01609 }
01610
01611
01612
01613
01614
01615
01616 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
01617 {
01618 register int yy_is_jam;
01619 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01620 register char *yy_cp = yyg->yy_c_buf_p;
01621
01622 register YY_CHAR yy_c = 1;
01623 if ( yy_accept[yy_current_state] )
01624 {
01625 yyg->yy_last_accepting_state = yy_current_state;
01626 yyg->yy_last_accepting_cpos = yy_cp;
01627 }
01628 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01629 {
01630 yy_current_state = (int) yy_def[yy_current_state];
01631 if ( yy_current_state >= 184 )
01632 yy_c = yy_meta[(unsigned int) yy_c];
01633 }
01634 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01635 yy_is_jam = (yy_current_state == 183);
01636
01637 return yy_is_jam ? 0 : yy_current_state;
01638 }
01639
01640 #ifndef YY_NO_INPUT
01641 #ifdef __cplusplus
01642 static int yyinput (yyscan_t yyscanner)
01643 #else
01644 static int input (yyscan_t yyscanner)
01645 #endif
01646
01647 {
01648 int c;
01649 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01650
01651 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01652
01653 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
01654 {
01655
01656
01657
01658
01659 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
01660
01661 *yyg->yy_c_buf_p = '\0';
01662
01663 else
01664 {
01665 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
01666 ++yyg->yy_c_buf_p;
01667
01668 switch ( yy_get_next_buffer( yyscanner ) )
01669 {
01670 case EOB_ACT_LAST_MATCH:
01671
01672
01673
01674
01675
01676
01677
01678
01679
01680
01681
01682 osssrestart(yyin ,yyscanner);
01683
01684
01685
01686 case EOB_ACT_END_OF_FILE:
01687 {
01688 if ( ossswrap(yyscanner ) )
01689 return EOF;
01690
01691 if ( ! yyg->yy_did_buffer_switch_on_eof )
01692 YY_NEW_FILE;
01693 #ifdef __cplusplus
01694 return yyinput(yyscanner);
01695 #else
01696 return input(yyscanner);
01697 #endif
01698 }
01699
01700 case EOB_ACT_CONTINUE_SCAN:
01701 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
01702 break;
01703 }
01704 }
01705 }
01706
01707 c = *(unsigned char *) yyg->yy_c_buf_p;
01708 *yyg->yy_c_buf_p = '\0';
01709 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
01710
01711 if ( c == '\n' )
01712
01713 do{ yylineno++;
01714 yycolumn=0;
01715 }while(0)
01716 ;
01717
01718 return c;
01719 }
01720 #endif
01721
01727 void osssrestart (FILE * input_file , yyscan_t yyscanner)
01728 {
01729 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01730
01731 if ( ! YY_CURRENT_BUFFER ){
01732 osssensure_buffer_stack (yyscanner);
01733 YY_CURRENT_BUFFER_LVALUE =
01734 osss_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
01735 }
01736
01737 osss_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
01738 osss_load_buffer_state(yyscanner );
01739 }
01740
01745 void osss_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
01746 {
01747 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01748
01749
01750
01751
01752
01753
01754 osssensure_buffer_stack (yyscanner);
01755 if ( YY_CURRENT_BUFFER == new_buffer )
01756 return;
01757
01758 if ( YY_CURRENT_BUFFER )
01759 {
01760
01761 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01762 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
01763 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01764 }
01765
01766 YY_CURRENT_BUFFER_LVALUE = new_buffer;
01767 osss_load_buffer_state(yyscanner );
01768
01769
01770
01771
01772
01773
01774 yyg->yy_did_buffer_switch_on_eof = 1;
01775 }
01776
01777 static void osss_load_buffer_state (yyscan_t yyscanner)
01778 {
01779 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01780 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
01781 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
01782 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
01783 yyg->yy_hold_char = *yyg->yy_c_buf_p;
01784 }
01785
01792 YY_BUFFER_STATE osss_create_buffer (FILE * file, int size , yyscan_t yyscanner)
01793 {
01794 YY_BUFFER_STATE b;
01795
01796 b = (YY_BUFFER_STATE) osssalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
01797 if ( ! b )
01798 YY_FATAL_ERROR( "out of dynamic memory in osss_create_buffer()" );
01799
01800 b->yy_buf_size = size;
01801
01802
01803
01804
01805 b->yy_ch_buf = (char *) osssalloc(b->yy_buf_size + 2 ,yyscanner );
01806 if ( ! b->yy_ch_buf )
01807 YY_FATAL_ERROR( "out of dynamic memory in osss_create_buffer()" );
01808
01809 b->yy_is_our_buffer = 1;
01810
01811 osss_init_buffer(b,file ,yyscanner);
01812
01813 return b;
01814 }
01815
01820 void osss_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
01821 {
01822 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01823
01824 if ( ! b )
01825 return;
01826
01827 if ( b == YY_CURRENT_BUFFER )
01828 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
01829
01830 if ( b->yy_is_our_buffer )
01831 osssfree((void *) b->yy_ch_buf ,yyscanner );
01832
01833 osssfree((void *) b ,yyscanner );
01834 }
01835
01836 #ifndef __cplusplus
01837 extern int isatty (int );
01838 #endif
01839
01840
01841
01842
01843
01844 static void osss_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
01845
01846 {
01847 int oerrno = errno;
01848 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01849
01850 osss_flush_buffer(b ,yyscanner);
01851
01852 b->yy_input_file = file;
01853 b->yy_fill_buffer = 1;
01854
01855
01856
01857
01858
01859 if (b != YY_CURRENT_BUFFER){
01860 b->yy_bs_lineno = 1;
01861 b->yy_bs_column = 0;
01862 }
01863
01864 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
01865
01866 errno = oerrno;
01867 }
01868
01873 void osss_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
01874 {
01875 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01876 if ( ! b )
01877 return;
01878
01879 b->yy_n_chars = 0;
01880
01881
01882
01883
01884
01885 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01886 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01887
01888 b->yy_buf_pos = &b->yy_ch_buf[0];
01889
01890 b->yy_at_bol = 1;
01891 b->yy_buffer_status = YY_BUFFER_NEW;
01892
01893 if ( b == YY_CURRENT_BUFFER )
01894 osss_load_buffer_state(yyscanner );
01895 }
01896
01903 void ossspush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
01904 {
01905 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01906 if (new_buffer == NULL)
01907 return;
01908
01909 osssensure_buffer_stack(yyscanner);
01910
01911
01912 if ( YY_CURRENT_BUFFER )
01913 {
01914
01915 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01916 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
01917 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01918 }
01919
01920
01921 if (YY_CURRENT_BUFFER)
01922 yyg->yy_buffer_stack_top++;
01923 YY_CURRENT_BUFFER_LVALUE = new_buffer;
01924
01925
01926 osss_load_buffer_state(yyscanner );
01927 yyg->yy_did_buffer_switch_on_eof = 1;
01928 }
01929
01934 void ossspop_buffer_state (yyscan_t yyscanner)
01935 {
01936 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01937 if (!YY_CURRENT_BUFFER)
01938 return;
01939
01940 osss_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
01941 YY_CURRENT_BUFFER_LVALUE = NULL;
01942 if (yyg->yy_buffer_stack_top > 0)
01943 --yyg->yy_buffer_stack_top;
01944
01945 if (YY_CURRENT_BUFFER) {
01946 osss_load_buffer_state(yyscanner );
01947 yyg->yy_did_buffer_switch_on_eof = 1;
01948 }
01949 }
01950
01951
01952
01953
01954 static void osssensure_buffer_stack (yyscan_t yyscanner)
01955 {
01956 int num_to_alloc;
01957 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01958
01959 if (!yyg->yy_buffer_stack) {
01960
01961
01962
01963
01964
01965 num_to_alloc = 1;
01966 yyg->yy_buffer_stack = (struct yy_buffer_state**)osssalloc
01967 (num_to_alloc * sizeof(struct yy_buffer_state*)
01968 , yyscanner);
01969 if ( ! yyg->yy_buffer_stack )
01970 YY_FATAL_ERROR( "out of dynamic memory in osssensure_buffer_stack()" );
01971
01972 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
01973
01974 yyg->yy_buffer_stack_max = num_to_alloc;
01975 yyg->yy_buffer_stack_top = 0;
01976 return;
01977 }
01978
01979 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
01980
01981
01982 int grow_size = 8 ;
01983
01984 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
01985 yyg->yy_buffer_stack = (struct yy_buffer_state**)osssrealloc
01986 (yyg->yy_buffer_stack,
01987 num_to_alloc * sizeof(struct yy_buffer_state*)
01988 , yyscanner);
01989 if ( ! yyg->yy_buffer_stack )
01990 YY_FATAL_ERROR( "out of dynamic memory in osssensure_buffer_stack()" );
01991
01992
01993 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
01994 yyg->yy_buffer_stack_max = num_to_alloc;
01995 }
01996 }
01997
02004 YY_BUFFER_STATE osss_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
02005 {
02006 YY_BUFFER_STATE b;
02007
02008 if ( size < 2 ||
02009 base[size-2] != YY_END_OF_BUFFER_CHAR ||
02010 base[size-1] != YY_END_OF_BUFFER_CHAR )
02011
02012 return 0;
02013
02014 b = (YY_BUFFER_STATE) osssalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
02015 if ( ! b )
02016 YY_FATAL_ERROR( "out of dynamic memory in osss_scan_buffer()" );
02017
02018 b->yy_buf_size = size - 2;
02019 b->yy_buf_pos = b->yy_ch_buf = base;
02020 b->yy_is_our_buffer = 0;
02021 b->yy_input_file = 0;
02022 b->yy_n_chars = b->yy_buf_size;
02023 b->yy_is_interactive = 0;
02024 b->yy_at_bol = 1;
02025 b->yy_fill_buffer = 0;
02026 b->yy_buffer_status = YY_BUFFER_NEW;
02027
02028 osss_switch_to_buffer(b ,yyscanner );
02029
02030 return b;
02031 }
02032
02041 YY_BUFFER_STATE osss_scan_string (yyconst char * yystr , yyscan_t yyscanner)
02042 {
02043
02044 return osss_scan_bytes(yystr,strlen(yystr) ,yyscanner);
02045 }
02046
02054 YY_BUFFER_STATE osss_scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner)
02055 {
02056 YY_BUFFER_STATE b;
02057 char *buf;
02058 yy_size_t n;
02059 int i;
02060
02061
02062 n = _yybytes_len + 2;
02063 buf = (char *) osssalloc(n ,yyscanner );
02064 if ( ! buf )
02065 YY_FATAL_ERROR( "out of dynamic memory in osss_scan_bytes()" );
02066
02067 for ( i = 0; i < _yybytes_len; ++i )
02068 buf[i] = yybytes[i];
02069
02070 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
02071
02072 b = osss_scan_buffer(buf,n ,yyscanner);
02073 if ( ! b )
02074 YY_FATAL_ERROR( "bad buffer in osss_scan_bytes()" );
02075
02076
02077
02078
02079 b->yy_is_our_buffer = 1;
02080
02081 return b;
02082 }
02083
02084 #ifndef YY_EXIT_FAILURE
02085 #define YY_EXIT_FAILURE 2
02086 #endif
02087
02088 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
02089 {
02090 (void) fprintf( stderr, "%s\n", msg );
02091 exit( YY_EXIT_FAILURE );
02092 }
02093
02094
02095
02096 #undef yyless
02097 #define yyless(n) \
02098 do \
02099 { \
02100 \
02101 int yyless_macro_arg = (n); \
02102 YY_LESS_LINENO(yyless_macro_arg);\
02103 yytext[yyleng] = yyg->yy_hold_char; \
02104 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
02105 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
02106 *yyg->yy_c_buf_p = '\0'; \
02107 yyleng = yyless_macro_arg; \
02108 } \
02109 while ( 0 )
02110
02111
02112
02116 YY_EXTRA_TYPE osssget_extra (yyscan_t yyscanner)
02117 {
02118 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02119 return yyextra;
02120 }
02121
02125 int osssget_lineno (yyscan_t yyscanner)
02126 {
02127 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02128
02129 if (! YY_CURRENT_BUFFER)
02130 return 0;
02131
02132 return yylineno;
02133 }
02134
02138 int osssget_column (yyscan_t yyscanner)
02139 {
02140 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02141
02142 if (! YY_CURRENT_BUFFER)
02143 return 0;
02144
02145 return yycolumn;
02146 }
02147
02151 FILE *osssget_in (yyscan_t yyscanner)
02152 {
02153 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02154 return yyin;
02155 }
02156
02160 FILE *osssget_out (yyscan_t yyscanner)
02161 {
02162 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02163 return yyout;
02164 }
02165
02169 int osssget_leng (yyscan_t yyscanner)
02170 {
02171 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02172 return yyleng;
02173 }
02174
02179 char *osssget_text (yyscan_t yyscanner)
02180 {
02181 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02182 return yytext;
02183 }
02184
02189 void osssset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
02190 {
02191 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02192 yyextra = user_defined ;
02193 }
02194
02199 void osssset_lineno (int line_number , yyscan_t yyscanner)
02200 {
02201 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02202
02203
02204 if (! YY_CURRENT_BUFFER )
02205 yy_fatal_error( "osssset_lineno called with no buffer" , yyscanner);
02206
02207 yylineno = line_number;
02208 }
02209
02214 void osssset_column (int column_no , yyscan_t yyscanner)
02215 {
02216 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02217
02218
02219 if (! YY_CURRENT_BUFFER )
02220 yy_fatal_error( "osssset_column called with no buffer" , yyscanner);
02221
02222 yycolumn = column_no;
02223 }
02224
02231 void osssset_in (FILE * in_str , yyscan_t yyscanner)
02232 {
02233 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02234 yyin = in_str ;
02235 }
02236
02237 void osssset_out (FILE * out_str , yyscan_t yyscanner)
02238 {
02239 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02240 yyout = out_str ;
02241 }
02242
02243 int osssget_debug (yyscan_t yyscanner)
02244 {
02245 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02246 return yy_flex_debug;
02247 }
02248
02249 void osssset_debug (int bdebug , yyscan_t yyscanner)
02250 {
02251 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02252 yy_flex_debug = bdebug ;
02253 }
02254
02255
02256
02257
02258
02259
02260
02261
02262
02263
02264 int ossslex_init(yyscan_t* ptr_yy_globals)
02265
02266 {
02267 if (ptr_yy_globals == NULL){
02268 errno = EINVAL;
02269 return 1;
02270 }
02271
02272 *ptr_yy_globals = (yyscan_t) osssalloc ( sizeof( struct yyguts_t ), NULL );
02273
02274 if (*ptr_yy_globals == NULL){
02275 errno = ENOMEM;
02276 return 1;
02277 }
02278
02279
02280 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
02281
02282 return yy_init_globals ( *ptr_yy_globals );
02283 }
02284
02285
02286
02287
02288
02289
02290
02291
02292
02293 int ossslex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
02294
02295 {
02296 struct yyguts_t dummy_yyguts;
02297
02298 osssset_extra (yy_user_defined, &dummy_yyguts);
02299
02300 if (ptr_yy_globals == NULL){
02301 errno = EINVAL;
02302 return 1;
02303 }
02304
02305 *ptr_yy_globals = (yyscan_t) osssalloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
02306
02307 if (*ptr_yy_globals == NULL){
02308 errno = ENOMEM;
02309 return 1;
02310 }
02311
02312
02313
02314 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
02315
02316 osssset_extra (yy_user_defined, *ptr_yy_globals);
02317
02318 return yy_init_globals ( *ptr_yy_globals );
02319 }
02320
02321 static int yy_init_globals (yyscan_t yyscanner)
02322 {
02323 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02324
02325
02326
02327
02328 yyg->yy_buffer_stack = 0;
02329 yyg->yy_buffer_stack_top = 0;
02330 yyg->yy_buffer_stack_max = 0;
02331 yyg->yy_c_buf_p = (char *) 0;
02332 yyg->yy_init = 0;
02333 yyg->yy_start = 0;
02334
02335 yyg->yy_start_stack_ptr = 0;
02336 yyg->yy_start_stack_depth = 0;
02337 yyg->yy_start_stack = NULL;
02338
02339
02340 #ifdef YY_STDINIT
02341 yyin = stdin;
02342 yyout = stdout;
02343 #else
02344 yyin = (FILE *) 0;
02345 yyout = (FILE *) 0;
02346 #endif
02347
02348
02349
02350
02351 return 0;
02352 }
02353
02354
02355 int ossslex_destroy (yyscan_t yyscanner)
02356 {
02357 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
02358
02359
02360 while(YY_CURRENT_BUFFER){
02361 osss_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
02362 YY_CURRENT_BUFFER_LVALUE = NULL;
02363 ossspop_buffer_state(yyscanner);
02364 }
02365
02366
02367 osssfree(yyg->yy_buffer_stack ,yyscanner);
02368 yyg->yy_buffer_stack = NULL;
02369
02370
02371 osssfree(yyg->yy_start_stack ,yyscanner );
02372 yyg->yy_start_stack = NULL;
02373
02374
02375
02376 yy_init_globals( yyscanner);
02377
02378
02379 osssfree ( yyscanner , yyscanner );
02380 yyscanner = NULL;
02381 return 0;
02382 }
02383
02384
02385
02386
02387
02388 #ifndef yytext_ptr
02389 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
02390 {
02391 register int i;
02392 for ( i = 0; i < n; ++i )
02393 s1[i] = s2[i];
02394 }
02395 #endif
02396
02397 #ifdef YY_NEED_STRLEN
02398 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
02399 {
02400 register int n;
02401 for ( n = 0; s[n]; ++n )
02402 ;
02403
02404 return n;
02405 }
02406 #endif
02407
02408 void *osssalloc (yy_size_t size , yyscan_t yyscanner)
02409 {
02410 return (void *) malloc( size );
02411 }
02412
02413 void *osssrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
02414 {
02415
02416
02417
02418
02419
02420
02421
02422 return (void *) realloc( (char *) ptr, size );
02423 }
02424
02425 void osssfree (void * ptr , yyscan_t yyscanner)
02426 {
02427 free( (char *) ptr );
02428 }
02429
02430 #define YYTABLES_NAME "yytables"
02431
02432 #line 332 "/home/kmartin/coin/os-trunk/OS/src/OSParsers/OSParseosss.l"
02433
02434
02435
02436 void setyyextra(osOptionsStruc *osoptions, void* scanner){
02437 osssset_extra(osoptions, scanner);
02438 }
02439
02440
02441