00001 #line 2 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.cpp"
00002
00003 #line 4 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.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 33
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 __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 #endif
00058
00059
00060 #ifndef INT8_MIN
00061 #define INT8_MIN (-128)
00062 #endif
00063 #ifndef INT16_MIN
00064 #define INT16_MIN (-32767-1)
00065 #endif
00066 #ifndef INT32_MIN
00067 #define INT32_MIN (-2147483647-1)
00068 #endif
00069 #ifndef INT8_MAX
00070 #define INT8_MAX (127)
00071 #endif
00072 #ifndef INT16_MAX
00073 #define INT16_MAX (32767)
00074 #endif
00075 #ifndef INT32_MAX
00076 #define INT32_MAX (2147483647)
00077 #endif
00078 #ifndef UINT8_MAX
00079 #define UINT8_MAX (255U)
00080 #endif
00081 #ifndef UINT16_MAX
00082 #define UINT16_MAX (65535U)
00083 #endif
00084 #ifndef UINT32_MAX
00085 #define UINT32_MAX (4294967295U)
00086 #endif
00087
00088 #endif
00089
00090 #ifdef __cplusplus
00091
00092
00093 #define YY_USE_CONST
00094
00095 #else
00096
00097 #if __STDC__
00098
00099 #define YY_USE_CONST
00100
00101 #endif
00102 #endif
00103
00104 #ifdef YY_USE_CONST
00105 #define yyconst const
00106 #else
00107 #define yyconst
00108 #endif
00109
00110
00111 #define YY_NULL 0
00112
00113
00114
00115
00116
00117
00118 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00119
00120
00121 #ifndef YY_TYPEDEF_YY_SCANNER_T
00122 #define YY_TYPEDEF_YY_SCANNER_T
00123 typedef void* yyscan_t;
00124 #endif
00125
00126
00127
00128 #define yyin yyg->yyin_r
00129 #define yyout yyg->yyout_r
00130 #define yyextra yyg->yyextra_r
00131 #define yyleng yyg->yyleng_r
00132 #define yytext yyg->yytext_r
00133 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
00134 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
00135 #define yy_flex_debug yyg->yy_flex_debug_r
00136
00137 int osollex_init (yyscan_t* scanner);
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 osolrestart(yyin ,yyscanner )
00157
00158 #define YY_END_OF_BUFFER_CHAR 0
00159
00160
00161 #ifndef YY_BUF_SIZE
00162 #define YY_BUF_SIZE 16384
00163 #endif
00164
00165
00166
00167 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
00168
00169 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
00170 #define YY_TYPEDEF_YY_BUFFER_STATE
00171 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00172 #endif
00173
00174 #define EOB_ACT_CONTINUE_SCAN 0
00175 #define EOB_ACT_END_OF_FILE 1
00176 #define EOB_ACT_LAST_MATCH 2
00177
00178
00179
00180
00181
00182
00183
00184
00185 #define YY_LESS_LINENO(n) \
00186 do { \
00187 int yyl;\
00188 for ( yyl = n; yyl < yyleng; ++yyl )\
00189 if ( yytext[yyl] == '\n' )\
00190 --yylineno;\
00191 }while(0)
00192
00193
00194 #define yyless(n) \
00195 do \
00196 { \
00197 \
00198 int yyless_macro_arg = (n); \
00199 YY_LESS_LINENO(yyless_macro_arg);\
00200 *yy_cp = yyg->yy_hold_char; \
00201 YY_RESTORE_YY_MORE_OFFSET \
00202 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
00203 YY_DO_BEFORE_ACTION; \
00204 } \
00205 while ( 0 )
00206
00207 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
00208
00209
00210
00211
00212
00213
00214 #ifndef YY_TYPEDEF_YY_SIZE_T
00215 #define YY_TYPEDEF_YY_SIZE_T
00216 typedef unsigned int yy_size_t;
00217 #endif
00218
00219 #ifndef YY_STRUCT_YY_BUFFER_STATE
00220 #define YY_STRUCT_YY_BUFFER_STATE
00221 struct yy_buffer_state
00222 {
00223 FILE *yy_input_file;
00224
00225 char *yy_ch_buf;
00226 char *yy_buf_pos;
00227
00228
00229
00230
00231 yy_size_t yy_buf_size;
00232
00233
00234
00235
00236 int yy_n_chars;
00237
00238
00239
00240
00241
00242 int yy_is_our_buffer;
00243
00244
00245
00246
00247
00248
00249 int yy_is_interactive;
00250
00251
00252
00253
00254
00255 int yy_at_bol;
00256
00257 int yy_bs_lineno;
00258 int yy_bs_column;
00260
00261
00262
00263 int yy_fill_buffer;
00264
00265 int yy_buffer_status;
00266
00267 #define YY_BUFFER_NEW 0
00268 #define YY_BUFFER_NORMAL 1
00269
00270
00271
00272
00273
00274
00275
00276
00277
00278
00279 #define YY_BUFFER_EOF_PENDING 2
00280
00281 };
00282 #endif
00283
00284
00285
00286
00287
00288
00289
00290 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
00291 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
00292 : NULL)
00293
00294
00295
00296
00297 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
00298
00299 void osolrestart (FILE *input_file ,yyscan_t yyscanner );
00300 void osol_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
00301 YY_BUFFER_STATE osol_create_buffer (FILE *file,int size ,yyscan_t yyscanner );
00302 void osol_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
00303 void osol_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
00304 void osolpush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
00305 void osolpop_buffer_state (yyscan_t yyscanner );
00306
00307 static void osolensure_buffer_stack (yyscan_t yyscanner );
00308 static void osol_load_buffer_state (yyscan_t yyscanner );
00309 static void osol_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
00310
00311 #define YY_FLUSH_BUFFER osol_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
00312
00313 YY_BUFFER_STATE osol_scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
00314 YY_BUFFER_STATE osol_scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
00315 YY_BUFFER_STATE osol_scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
00316
00317 void *osolalloc (yy_size_t ,yyscan_t yyscanner );
00318 void *osolrealloc (void *,yy_size_t ,yyscan_t yyscanner );
00319 void osolfree (void * ,yyscan_t yyscanner );
00320
00321 #define yy_new_buffer osol_create_buffer
00322
00323 #define yy_set_interactive(is_interactive) \
00324 { \
00325 if ( ! YY_CURRENT_BUFFER ){ \
00326 osolensure_buffer_stack (yyscanner); \
00327 YY_CURRENT_BUFFER_LVALUE = \
00328 osol_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
00329 } \
00330 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
00331 }
00332
00333 #define yy_set_bol(at_bol) \
00334 { \
00335 if ( ! YY_CURRENT_BUFFER ){\
00336 osolensure_buffer_stack (yyscanner); \
00337 YY_CURRENT_BUFFER_LVALUE = \
00338 osol_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
00339 } \
00340 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
00341 }
00342
00343 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
00344
00345
00346
00347 #define osolwrap(n) 1
00348 #define YY_SKIP_YYWRAP
00349
00350 typedef unsigned char YY_CHAR;
00351
00352 typedef int yy_state_type;
00353
00354 #define yytext_ptr yytext_r
00355
00356 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
00357 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
00358 static int yy_get_next_buffer (yyscan_t yyscanner );
00359 static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
00360
00361
00362
00363
00364 #define YY_DO_BEFORE_ACTION \
00365 yyg->yytext_ptr = yy_bp; \
00366 yyleng = (size_t) (yy_cp - yy_bp); \
00367 yyg->yy_hold_char = *yy_cp; \
00368 *yy_cp = '\0'; \
00369 yyg->yy_c_buf_p = yy_cp;
00370
00371 #define YY_NUM_RULES 3
00372 #define YY_END_OF_BUFFER 4
00373
00374
00375 struct yy_trans_info
00376 {
00377 flex_int32_t yy_verify;
00378 flex_int32_t yy_nxt;
00379 };
00380 static yyconst flex_int16_t yy_accept[17] =
00381 { 0,
00382 1, 1, 4, 3, 1, 3, 3, 2, 1, 0,
00383 2, 2, 0, 0, 2, 0
00384 } ;
00385
00386 static yyconst flex_int32_t yy_ec[256] =
00387 { 0,
00388 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,
00389 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
00390 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00391 1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
00392 1, 1, 3, 1, 4, 5, 1, 6, 6, 6,
00393 6, 6, 6, 6, 6, 6, 6, 1, 1, 1,
00394 1, 1, 1, 1, 1, 1, 1, 1, 7, 1,
00395 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00396 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00397 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00398
00399 7, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00400 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00401 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00402 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00403 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00406 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00407 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00409
00410 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00412 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00414 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
00415 1, 1, 1, 1, 1
00416 } ;
00417
00418 static yyconst flex_int32_t yy_meta[8] =
00419 { 0,
00420 1, 1, 2, 2, 1, 2, 1
00421 } ;
00422
00423 static yyconst flex_int16_t yy_base[18] =
00424 { 0,
00425 0, 0, 21, 22, 18, 3, 13, 11, 15, 10,
00426 0, 4, 9, 8, 7, 22, 10
00427 } ;
00428
00429 static yyconst flex_int16_t yy_def[18] =
00430 { 0,
00431 16, 1, 16, 16, 16, 16, 16, 6, 16, 16,
00432 8, 16, 17, 16, 16, 0, 16
00433 } ;
00434
00435 static yyconst flex_int16_t yy_nxt[30] =
00436 { 0,
00437 4, 5, 4, 6, 7, 8, 4, 10, 11, 12,
00438 13, 14, 15, 15, 15, 12, 9, 13, 12, 9,
00439 16, 3, 16, 16, 16, 16, 16, 16, 16
00440 } ;
00441
00442 static yyconst flex_int16_t yy_chk[30] =
00443 { 0,
00444 1, 1, 1, 1, 1, 1, 1, 6, 6, 12,
00445 12, 17, 15, 14, 13, 10, 9, 8, 7, 5,
00446 3, 16, 16, 16, 16, 16, 16, 16, 16
00447 } ;
00448
00449
00450 static yyconst flex_int32_t yy_rule_can_match_eol[4] =
00451 { 0,
00452 1, 0, 0, };
00453
00454
00455
00456
00457 #define REJECT reject_used_but_not_detected
00458 #define yymore() yymore_used_but_not_detected
00459 #define YY_MORE_ADJ 0
00460 #define YY_RESTORE_YY_MORE_OFFSET
00461 #line 1 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.l"
00462
00476 #line 16 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.l"
00477
00478 #include <iostream>
00479 #include "OSConfig.h"
00480 #ifdef HAVE_CSTDIO
00481 # include <cstdio>
00482 #else
00483 # ifdef HAVE_STDIO_H
00484 # include <stdio.h>
00485 # else
00486 # error "don't have header file for stdio"
00487 # endif
00488 #endif
00489
00490 #ifdef PARSERDEBUG
00491 #define YY_PRINT printf("%s", osoltext);
00492 #else
00493 #define YY_PRINT ;
00494 #endif
00495 #ifdef WIN_
00496 #define YY_NO_UNISTD_H
00497 #include <io.h>
00498 #include <process.h>
00499 #endif
00500
00501 #line 502 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.cpp"
00502
00503 #define INITIAL 0
00504
00505 #ifndef YY_NO_UNISTD_H
00506
00507
00508
00509
00510 #include <unistd.h>
00511 #endif
00512
00513 #ifndef YY_EXTRA_TYPE
00514 #define YY_EXTRA_TYPE void *
00515 #endif
00516
00517
00518 struct yyguts_t
00519 {
00520
00521
00522 YY_EXTRA_TYPE yyextra_r;
00523
00524
00525 FILE *yyin_r, *yyout_r;
00526 size_t yy_buffer_stack_top;
00527 size_t yy_buffer_stack_max;
00528 YY_BUFFER_STATE * yy_buffer_stack;
00529 char yy_hold_char;
00530 int yy_n_chars;
00531 int yyleng_r;
00532 char *yy_c_buf_p;
00533 int yy_init;
00534 int yy_start;
00535 int yy_did_buffer_switch_on_eof;
00536 int yy_start_stack_ptr;
00537 int yy_start_stack_depth;
00538 int *yy_start_stack;
00539 yy_state_type yy_last_accepting_state;
00540 char* yy_last_accepting_cpos;
00541
00542 int yylineno_r;
00543 int yy_flex_debug_r;
00544
00545 char *yytext_r;
00546 int yy_more_flag;
00547 int yy_more_len;
00548
00549 };
00550
00551 static int yy_init_globals (yyscan_t yyscanner );
00552
00553
00554
00555
00556 int osollex_destroy (yyscan_t yyscanner );
00557
00558 int osolget_debug (yyscan_t yyscanner );
00559
00560 void osolset_debug (int debug_flag ,yyscan_t yyscanner );
00561
00562 YY_EXTRA_TYPE osolget_extra (yyscan_t yyscanner );
00563
00564 void osolset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
00565
00566 FILE *osolget_in (yyscan_t yyscanner );
00567
00568 void osolset_in (FILE * in_str ,yyscan_t yyscanner );
00569
00570 FILE *osolget_out (yyscan_t yyscanner );
00571
00572 void osolset_out (FILE * out_str ,yyscan_t yyscanner );
00573
00574 int osolget_leng (yyscan_t yyscanner );
00575
00576 char *osolget_text (yyscan_t yyscanner );
00577
00578 int osolget_lineno (yyscan_t yyscanner );
00579
00580 void osolset_lineno (int line_number ,yyscan_t yyscanner );
00581
00582
00583
00584
00585
00586 #ifndef YY_SKIP_YYWRAP
00587 #ifdef __cplusplus
00588 extern "C" int osolwrap (yyscan_t yyscanner );
00589 #else
00590 extern int osolwrap (yyscan_t yyscanner );
00591 #endif
00592 #endif
00593
00594 static void yyunput (int c,char *buf_ptr ,yyscan_t yyscanner);
00595
00596 #ifndef yytext_ptr
00597 static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
00598 #endif
00599
00600 #ifdef YY_NEED_STRLEN
00601 static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
00602 #endif
00603
00604 #ifndef YY_NO_INPUT
00605
00606 #ifdef __cplusplus
00607 static int yyinput (yyscan_t yyscanner );
00608 #else
00609 static int input (yyscan_t yyscanner );
00610 #endif
00611
00612 #endif
00613
00614
00615 #ifndef YY_READ_BUF_SIZE
00616 #define YY_READ_BUF_SIZE 8192
00617 #endif
00618
00619
00620 #ifndef ECHO
00621
00622
00623
00624 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
00625 #endif
00626
00627
00628
00629
00630 #ifndef YY_INPUT
00631 #define YY_INPUT(buf,result,max_size) \
00632 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
00633 { \
00634 int c = '*'; \
00635 size_t n; \
00636 for ( n = 0; n < max_size && \
00637 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00638 buf[n] = (char) c; \
00639 if ( c == '\n' ) \
00640 buf[n++] = (char) c; \
00641 if ( c == EOF && ferror( yyin ) ) \
00642 YY_FATAL_ERROR( "input in flex scanner failed" ); \
00643 result = n; \
00644 } \
00645 else \
00646 { \
00647 errno=0; \
00648 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
00649 { \
00650 if( errno != EINTR) \
00651 { \
00652 YY_FATAL_ERROR( "input in flex scanner failed" ); \
00653 break; \
00654 } \
00655 errno=0; \
00656 clearerr(yyin); \
00657 } \
00658 }\
00659 \
00660
00661 #endif
00662
00663
00664
00665
00666
00667 #ifndef yyterminate
00668 #define yyterminate() return YY_NULL
00669 #endif
00670
00671
00672 #ifndef YY_START_STACK_INCR
00673 #define YY_START_STACK_INCR 25
00674 #endif
00675
00676
00677 #ifndef YY_FATAL_ERROR
00678 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
00679 #endif
00680
00681
00682
00683
00684
00685
00686 #ifndef YY_DECL
00687 #define YY_DECL_IS_OURS 1
00688
00689 extern int osollex (yyscan_t yyscanner);
00690
00691 #define YY_DECL int osollex (yyscan_t yyscanner)
00692 #endif
00693
00694
00695
00696
00697 #ifndef YY_USER_ACTION
00698 #define YY_USER_ACTION
00699 #endif
00700
00701
00702 #ifndef YY_BREAK
00703 #define YY_BREAK break;
00704 #endif
00705
00706 #define YY_RULE_SETUP \
00707 YY_USER_ACTION
00708
00711 YY_DECL
00712 {
00713 register yy_state_type yy_current_state;
00714 register char *yy_cp, *yy_bp;
00715 register int yy_act;
00716 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
00717
00718 #line 54 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.l"
00719
00720
00721 #line 722 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.cpp"
00722
00723 if ( !yyg->yy_init )
00724 {
00725 yyg->yy_init = 1;
00726
00727 #ifdef YY_USER_INIT
00728 YY_USER_INIT;
00729 #endif
00730
00731 if ( ! yyg->yy_start )
00732 yyg->yy_start = 1;
00733
00734 if ( ! yyin )
00735 yyin = stdin;
00736
00737 if ( ! yyout )
00738 yyout = stdout;
00739
00740 if ( ! YY_CURRENT_BUFFER ) {
00741 osolensure_buffer_stack (yyscanner);
00742 YY_CURRENT_BUFFER_LVALUE =
00743 osol_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
00744 }
00745
00746 osol_load_buffer_state(yyscanner );
00747 }
00748
00749 while ( 1 )
00750 {
00751 yy_cp = yyg->yy_c_buf_p;
00752
00753
00754 *yy_cp = yyg->yy_hold_char;
00755
00756
00757
00758
00759 yy_bp = yy_cp;
00760
00761 yy_current_state = yyg->yy_start;
00762 yy_match:
00763 do
00764 {
00765 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00766 if ( yy_accept[yy_current_state] )
00767 {
00768 yyg->yy_last_accepting_state = yy_current_state;
00769 yyg->yy_last_accepting_cpos = yy_cp;
00770 }
00771 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00772 {
00773 yy_current_state = (int) yy_def[yy_current_state];
00774 if ( yy_current_state >= 17 )
00775 yy_c = yy_meta[(unsigned int) yy_c];
00776 }
00777 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00778 ++yy_cp;
00779 }
00780 while ( yy_base[yy_current_state] != 22 );
00781
00782 yy_find_action:
00783 yy_act = yy_accept[yy_current_state];
00784 if ( yy_act == 0 )
00785 {
00786 yy_cp = yyg->yy_last_accepting_cpos;
00787 yy_current_state = yyg->yy_last_accepting_state;
00788 yy_act = yy_accept[yy_current_state];
00789 }
00790
00791 YY_DO_BEFORE_ACTION;
00792
00793 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
00794 {
00795 int yyl;
00796 for ( yyl = 0; yyl < yyleng; ++yyl )
00797 if ( yytext[yyl] == '\n' )
00798
00799 do{ yylineno++;
00800 yycolumn=0;
00801 }while(0)
00802 ;
00803 }
00804
00805 do_action:
00806
00807 switch ( yy_act )
00808 {
00809 case 0:
00810
00811 *yy_cp = yyg->yy_hold_char;
00812 yy_cp = yyg->yy_last_accepting_cpos;
00813 yy_current_state = yyg->yy_last_accepting_state;
00814 goto yy_find_action;
00815
00816 case 1:
00817
00818 YY_RULE_SETUP
00819 #line 56 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.l"
00820
00821 YY_BREAK
00822 case 2:
00823 YY_RULE_SETUP
00824 #line 58 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.l"
00825
00826 YY_BREAK
00827 case 3:
00828 YY_RULE_SETUP
00829 #line 60 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.l"
00830 ECHO;
00831 YY_BREAK
00832 #line 833 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.cpp"
00833 case YY_STATE_EOF(INITIAL):
00834 yyterminate();
00835
00836 case YY_END_OF_BUFFER:
00837 {
00838
00839 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
00840
00841
00842 *yy_cp = yyg->yy_hold_char;
00843 YY_RESTORE_YY_MORE_OFFSET
00844
00845 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
00846 {
00847
00848
00849
00850
00851
00852
00853
00854
00855
00856 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
00857 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
00858 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
00859 }
00860
00861
00862
00863
00864
00865
00866
00867
00868 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
00869 {
00870 yy_state_type yy_next_state;
00871
00872 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
00873
00874 yy_current_state = yy_get_previous_state( yyscanner );
00875
00876
00877
00878
00879
00880
00881
00882
00883
00884
00885 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
00886
00887 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
00888
00889 if ( yy_next_state )
00890 {
00891
00892 yy_cp = ++yyg->yy_c_buf_p;
00893 yy_current_state = yy_next_state;
00894 goto yy_match;
00895 }
00896
00897 else
00898 {
00899 yy_cp = yyg->yy_c_buf_p;
00900 goto yy_find_action;
00901 }
00902 }
00903
00904 else switch ( yy_get_next_buffer( yyscanner ) )
00905 {
00906 case EOB_ACT_END_OF_FILE:
00907 {
00908 yyg->yy_did_buffer_switch_on_eof = 0;
00909
00910 if ( osolwrap(yyscanner ) )
00911 {
00912
00913
00914
00915
00916
00917
00918
00919
00920
00921 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
00922
00923 yy_act = YY_STATE_EOF(YY_START);
00924 goto do_action;
00925 }
00926
00927 else
00928 {
00929 if ( ! yyg->yy_did_buffer_switch_on_eof )
00930 YY_NEW_FILE;
00931 }
00932 break;
00933 }
00934
00935 case EOB_ACT_CONTINUE_SCAN:
00936 yyg->yy_c_buf_p =
00937 yyg->yytext_ptr + yy_amount_of_matched_text;
00938
00939 yy_current_state = yy_get_previous_state( yyscanner );
00940
00941 yy_cp = yyg->yy_c_buf_p;
00942 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
00943 goto yy_match;
00944
00945 case EOB_ACT_LAST_MATCH:
00946 yyg->yy_c_buf_p =
00947 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
00948
00949 yy_current_state = yy_get_previous_state( yyscanner );
00950
00951 yy_cp = yyg->yy_c_buf_p;
00952 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
00953 goto yy_find_action;
00954 }
00955 break;
00956 }
00957
00958 default:
00959 YY_FATAL_ERROR(
00960 "fatal flex scanner internal error--no action found" );
00961 }
00962 }
00963 }
00964
00965
00966
00967
00968
00969
00970
00971
00972 static int yy_get_next_buffer (yyscan_t yyscanner)
00973 {
00974 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
00975 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
00976 register char *source = yyg->yytext_ptr;
00977 register int number_to_move, i;
00978 int ret_val;
00979
00980 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
00981 YY_FATAL_ERROR(
00982 "fatal flex scanner internal error--end of buffer missed" );
00983
00984 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
00985 {
00986 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
00987 {
00988
00989
00990
00991 return EOB_ACT_END_OF_FILE;
00992 }
00993
00994 else
00995 {
00996
00997
00998
00999 return EOB_ACT_LAST_MATCH;
01000 }
01001 }
01002
01003
01004
01005
01006 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
01007
01008 for ( i = 0; i < number_to_move; ++i )
01009 *(dest++) = *(source++);
01010
01011 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01012
01013
01014
01015 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
01016
01017 else
01018 {
01019 int num_to_read =
01020 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
01021
01022 while ( num_to_read <= 0 )
01023 {
01024
01025
01026 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
01027
01028 int yy_c_buf_p_offset =
01029 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
01030
01031 if ( b->yy_is_our_buffer )
01032 {
01033 int new_size = b->yy_buf_size * 2;
01034
01035 if ( new_size <= 0 )
01036 b->yy_buf_size += b->yy_buf_size / 8;
01037 else
01038 b->yy_buf_size *= 2;
01039
01040 b->yy_ch_buf = (char *)
01041
01042 osolrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
01043 }
01044 else
01045
01046 b->yy_ch_buf = 0;
01047
01048 if ( ! b->yy_ch_buf )
01049 YY_FATAL_ERROR(
01050 "fatal error - scanner input buffer overflow" );
01051
01052 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
01053
01054 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
01055 number_to_move - 1;
01056
01057 }
01058
01059 if ( num_to_read > YY_READ_BUF_SIZE )
01060 num_to_read = YY_READ_BUF_SIZE;
01061
01062
01063 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
01064 yyg->yy_n_chars, num_to_read );
01065
01066 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01067 }
01068
01069 if ( yyg->yy_n_chars == 0 )
01070 {
01071 if ( number_to_move == YY_MORE_ADJ )
01072 {
01073 ret_val = EOB_ACT_END_OF_FILE;
01074 osolrestart(yyin ,yyscanner);
01075 }
01076
01077 else
01078 {
01079 ret_val = EOB_ACT_LAST_MATCH;
01080 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
01081 YY_BUFFER_EOF_PENDING;
01082 }
01083 }
01084
01085 else
01086 ret_val = EOB_ACT_CONTINUE_SCAN;
01087
01088 yyg->yy_n_chars += number_to_move;
01089 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
01090 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
01091
01092 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
01093
01094 return ret_val;
01095 }
01096
01097
01098
01099 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
01100 {
01101 register yy_state_type yy_current_state;
01102 register char *yy_cp;
01103 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01104
01105 yy_current_state = yyg->yy_start;
01106
01107 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
01108 {
01109 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01110 if ( yy_accept[yy_current_state] )
01111 {
01112 yyg->yy_last_accepting_state = yy_current_state;
01113 yyg->yy_last_accepting_cpos = yy_cp;
01114 }
01115 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01116 {
01117 yy_current_state = (int) yy_def[yy_current_state];
01118 if ( yy_current_state >= 17 )
01119 yy_c = yy_meta[(unsigned int) yy_c];
01120 }
01121 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01122 }
01123
01124 return yy_current_state;
01125 }
01126
01127
01128
01129
01130
01131
01132 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
01133 {
01134 register int yy_is_jam;
01135 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01136 register char *yy_cp = yyg->yy_c_buf_p;
01137
01138 register YY_CHAR yy_c = 1;
01139 if ( yy_accept[yy_current_state] )
01140 {
01141 yyg->yy_last_accepting_state = yy_current_state;
01142 yyg->yy_last_accepting_cpos = yy_cp;
01143 }
01144 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01145 {
01146 yy_current_state = (int) yy_def[yy_current_state];
01147 if ( yy_current_state >= 17 )
01148 yy_c = yy_meta[(unsigned int) yy_c];
01149 }
01150 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01151 yy_is_jam = (yy_current_state == 16);
01152
01153 return yy_is_jam ? 0 : yy_current_state;
01154 }
01155
01156 static void yyunput (int c, register char * yy_bp , yyscan_t yyscanner)
01157 {
01158 register char *yy_cp;
01159 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01160
01161 yy_cp = yyg->yy_c_buf_p;
01162
01163
01164 *yy_cp = yyg->yy_hold_char;
01165
01166 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
01167 {
01168
01169 register int number_to_move = yyg->yy_n_chars + 2;
01170 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
01171 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
01172 register char *source =
01173 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
01174
01175 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
01176 *--dest = *--source;
01177
01178 yy_cp += (int) (dest - source);
01179 yy_bp += (int) (dest - source);
01180 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
01181 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
01182
01183 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
01184 YY_FATAL_ERROR( "flex scanner push-back overflow" );
01185 }
01186
01187 *--yy_cp = (char) c;
01188
01189 if ( c == '\n' ){
01190 --yylineno;
01191 }
01192
01193 yyg->yytext_ptr = yy_bp;
01194 yyg->yy_hold_char = *yy_cp;
01195 yyg->yy_c_buf_p = yy_cp;
01196 }
01197
01198 #ifndef YY_NO_INPUT
01199 #ifdef __cplusplus
01200 static int yyinput (yyscan_t yyscanner)
01201 #else
01202 static int input (yyscan_t yyscanner)
01203 #endif
01204
01205 {
01206 int c;
01207 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01208
01209 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01210
01211 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
01212 {
01213
01214
01215
01216
01217 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
01218
01219 *yyg->yy_c_buf_p = '\0';
01220
01221 else
01222 {
01223 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
01224 ++yyg->yy_c_buf_p;
01225
01226 switch ( yy_get_next_buffer( yyscanner ) )
01227 {
01228 case EOB_ACT_LAST_MATCH:
01229
01230
01231
01232
01233
01234
01235
01236
01237
01238
01239
01240 osolrestart(yyin ,yyscanner);
01241
01242
01243
01244 case EOB_ACT_END_OF_FILE:
01245 {
01246 if ( osolwrap(yyscanner ) )
01247 return EOF;
01248
01249 if ( ! yyg->yy_did_buffer_switch_on_eof )
01250 YY_NEW_FILE;
01251 #ifdef __cplusplus
01252 return yyinput(yyscanner);
01253 #else
01254 return input(yyscanner);
01255 #endif
01256 }
01257
01258 case EOB_ACT_CONTINUE_SCAN:
01259 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
01260 break;
01261 }
01262 }
01263 }
01264
01265 c = *(unsigned char *) yyg->yy_c_buf_p;
01266 *yyg->yy_c_buf_p = '\0';
01267 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
01268
01269 if ( c == '\n' )
01270
01271 do{ yylineno++;
01272 yycolumn=0;
01273 }while(0)
01274 ;
01275
01276 return c;
01277 }
01278 #endif
01279
01285 void osolrestart (FILE * input_file , yyscan_t yyscanner)
01286 {
01287 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01288
01289 if ( ! YY_CURRENT_BUFFER ){
01290 osolensure_buffer_stack (yyscanner);
01291 YY_CURRENT_BUFFER_LVALUE =
01292 osol_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
01293 }
01294
01295 osol_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
01296 osol_load_buffer_state(yyscanner );
01297 }
01298
01303 void osol_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
01304 {
01305 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01306
01307
01308
01309
01310
01311
01312 osolensure_buffer_stack (yyscanner);
01313 if ( YY_CURRENT_BUFFER == new_buffer )
01314 return;
01315
01316 if ( YY_CURRENT_BUFFER )
01317 {
01318
01319 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01320 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
01321 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01322 }
01323
01324 YY_CURRENT_BUFFER_LVALUE = new_buffer;
01325 osol_load_buffer_state(yyscanner );
01326
01327
01328
01329
01330
01331
01332 yyg->yy_did_buffer_switch_on_eof = 1;
01333 }
01334
01335 static void osol_load_buffer_state (yyscan_t yyscanner)
01336 {
01337 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01338 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
01339 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
01340 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
01341 yyg->yy_hold_char = *yyg->yy_c_buf_p;
01342 }
01343
01350 YY_BUFFER_STATE osol_create_buffer (FILE * file, int size , yyscan_t yyscanner)
01351 {
01352 YY_BUFFER_STATE b;
01353
01354 b = (YY_BUFFER_STATE) osolalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
01355 if ( ! b )
01356 YY_FATAL_ERROR( "out of dynamic memory in osol_create_buffer()" );
01357
01358 b->yy_buf_size = size;
01359
01360
01361
01362
01363 b->yy_ch_buf = (char *) osolalloc(b->yy_buf_size + 2 ,yyscanner );
01364 if ( ! b->yy_ch_buf )
01365 YY_FATAL_ERROR( "out of dynamic memory in osol_create_buffer()" );
01366
01367 b->yy_is_our_buffer = 1;
01368
01369 osol_init_buffer(b,file ,yyscanner);
01370
01371 return b;
01372 }
01373
01378 void osol_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
01379 {
01380 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01381
01382 if ( ! b )
01383 return;
01384
01385 if ( b == YY_CURRENT_BUFFER )
01386 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
01387
01388 if ( b->yy_is_our_buffer )
01389 osolfree((void *) b->yy_ch_buf ,yyscanner );
01390
01391 osolfree((void *) b ,yyscanner );
01392 }
01393
01394 #ifndef __cplusplus
01395 extern int isatty (int );
01396 #endif
01397
01398
01399
01400
01401
01402 static void osol_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
01403
01404 {
01405 int oerrno = errno;
01406 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01407
01408 osol_flush_buffer(b ,yyscanner);
01409
01410 b->yy_input_file = file;
01411 b->yy_fill_buffer = 1;
01412
01413
01414
01415
01416
01417 if (b != YY_CURRENT_BUFFER){
01418 b->yy_bs_lineno = 1;
01419 b->yy_bs_column = 0;
01420 }
01421
01422 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
01423
01424 errno = oerrno;
01425 }
01426
01431 void osol_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
01432 {
01433 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01434 if ( ! b )
01435 return;
01436
01437 b->yy_n_chars = 0;
01438
01439
01440
01441
01442
01443 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
01444 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
01445
01446 b->yy_buf_pos = &b->yy_ch_buf[0];
01447
01448 b->yy_at_bol = 1;
01449 b->yy_buffer_status = YY_BUFFER_NEW;
01450
01451 if ( b == YY_CURRENT_BUFFER )
01452 osol_load_buffer_state(yyscanner );
01453 }
01454
01461 void osolpush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
01462 {
01463 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01464 if (new_buffer == NULL)
01465 return;
01466
01467 osolensure_buffer_stack(yyscanner);
01468
01469
01470 if ( YY_CURRENT_BUFFER )
01471 {
01472
01473 *yyg->yy_c_buf_p = yyg->yy_hold_char;
01474 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
01475 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
01476 }
01477
01478
01479 if (YY_CURRENT_BUFFER)
01480 yyg->yy_buffer_stack_top++;
01481 YY_CURRENT_BUFFER_LVALUE = new_buffer;
01482
01483
01484 osol_load_buffer_state(yyscanner );
01485 yyg->yy_did_buffer_switch_on_eof = 1;
01486 }
01487
01492 void osolpop_buffer_state (yyscan_t yyscanner)
01493 {
01494 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01495 if (!YY_CURRENT_BUFFER)
01496 return;
01497
01498 osol_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
01499 YY_CURRENT_BUFFER_LVALUE = NULL;
01500 if (yyg->yy_buffer_stack_top > 0)
01501 --yyg->yy_buffer_stack_top;
01502
01503 if (YY_CURRENT_BUFFER) {
01504 osol_load_buffer_state(yyscanner );
01505 yyg->yy_did_buffer_switch_on_eof = 1;
01506 }
01507 }
01508
01509
01510
01511
01512 static void osolensure_buffer_stack (yyscan_t yyscanner)
01513 {
01514 int num_to_alloc;
01515 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01516
01517 if (!yyg->yy_buffer_stack) {
01518
01519
01520
01521
01522
01523 num_to_alloc = 1;
01524 yyg->yy_buffer_stack = (struct yy_buffer_state**)osolalloc
01525 (num_to_alloc * sizeof(struct yy_buffer_state*)
01526 , yyscanner);
01527
01528 memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
01529
01530 yyg->yy_buffer_stack_max = num_to_alloc;
01531 yyg->yy_buffer_stack_top = 0;
01532 return;
01533 }
01534
01535 if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
01536
01537
01538 int grow_size = 8 ;
01539
01540 num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
01541 yyg->yy_buffer_stack = (struct yy_buffer_state**)osolrealloc
01542 (yyg->yy_buffer_stack,
01543 num_to_alloc * sizeof(struct yy_buffer_state*)
01544 , yyscanner);
01545
01546
01547 memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct yy_buffer_state*));
01548 yyg->yy_buffer_stack_max = num_to_alloc;
01549 }
01550 }
01551
01558 YY_BUFFER_STATE osol_scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
01559 {
01560 YY_BUFFER_STATE b;
01561
01562 if ( size < 2 ||
01563 base[size-2] != YY_END_OF_BUFFER_CHAR ||
01564 base[size-1] != YY_END_OF_BUFFER_CHAR )
01565
01566 return 0;
01567
01568 b = (YY_BUFFER_STATE) osolalloc(sizeof( struct yy_buffer_state ) ,yyscanner );
01569 if ( ! b )
01570 YY_FATAL_ERROR( "out of dynamic memory in osol_scan_buffer()" );
01571
01572 b->yy_buf_size = size - 2;
01573 b->yy_buf_pos = b->yy_ch_buf = base;
01574 b->yy_is_our_buffer = 0;
01575 b->yy_input_file = 0;
01576 b->yy_n_chars = b->yy_buf_size;
01577 b->yy_is_interactive = 0;
01578 b->yy_at_bol = 1;
01579 b->yy_fill_buffer = 0;
01580 b->yy_buffer_status = YY_BUFFER_NEW;
01581
01582 osol_switch_to_buffer(b ,yyscanner );
01583
01584 return b;
01585 }
01586
01595 YY_BUFFER_STATE osol_scan_string (yyconst char * yystr , yyscan_t yyscanner)
01596 {
01597
01598 return osol_scan_bytes(yystr,strlen(yystr) ,yyscanner);
01599 }
01600
01608 YY_BUFFER_STATE osol_scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner)
01609 {
01610 YY_BUFFER_STATE b;
01611 char *buf;
01612 yy_size_t n;
01613 int i;
01614
01615
01616 n = _yybytes_len + 2;
01617 buf = (char *) osolalloc(n ,yyscanner );
01618 if ( ! buf )
01619 YY_FATAL_ERROR( "out of dynamic memory in osol_scan_bytes()" );
01620
01621 for ( i = 0; i < _yybytes_len; ++i )
01622 buf[i] = yybytes[i];
01623
01624 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
01625
01626 b = osol_scan_buffer(buf,n ,yyscanner);
01627 if ( ! b )
01628 YY_FATAL_ERROR( "bad buffer in osol_scan_bytes()" );
01629
01630
01631
01632
01633 b->yy_is_our_buffer = 1;
01634
01635 return b;
01636 }
01637
01638 #ifndef YY_EXIT_FAILURE
01639 #define YY_EXIT_FAILURE 2
01640 #endif
01641
01642 static void yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
01643 {
01644 (void) fprintf( stderr, "%s\n", msg );
01645 exit( YY_EXIT_FAILURE );
01646 }
01647
01648
01649
01650 #undef yyless
01651 #define yyless(n) \
01652 do \
01653 { \
01654 \
01655 int yyless_macro_arg = (n); \
01656 YY_LESS_LINENO(yyless_macro_arg);\
01657 yytext[yyleng] = yyg->yy_hold_char; \
01658 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
01659 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
01660 *yyg->yy_c_buf_p = '\0'; \
01661 yyleng = yyless_macro_arg; \
01662 } \
01663 while ( 0 )
01664
01665
01666
01670 YY_EXTRA_TYPE osolget_extra (yyscan_t yyscanner)
01671 {
01672 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01673 return yyextra;
01674 }
01675
01679 int osolget_lineno (yyscan_t yyscanner)
01680 {
01681 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01682
01683 if (! YY_CURRENT_BUFFER)
01684 return 0;
01685
01686 return yylineno;
01687 }
01688
01692 int osolget_column (yyscan_t yyscanner)
01693 {
01694 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01695
01696 if (! YY_CURRENT_BUFFER)
01697 return 0;
01698
01699 return yycolumn;
01700 }
01701
01705 FILE *osolget_in (yyscan_t yyscanner)
01706 {
01707 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01708 return yyin;
01709 }
01710
01714 FILE *osolget_out (yyscan_t yyscanner)
01715 {
01716 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01717 return yyout;
01718 }
01719
01723 int osolget_leng (yyscan_t yyscanner)
01724 {
01725 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01726 return yyleng;
01727 }
01728
01733 char *osolget_text (yyscan_t yyscanner)
01734 {
01735 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01736 return yytext;
01737 }
01738
01743 void osolset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
01744 {
01745 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01746 yyextra = user_defined ;
01747 }
01748
01753 void osolset_lineno (int line_number , yyscan_t yyscanner)
01754 {
01755 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01756
01757
01758 if (! YY_CURRENT_BUFFER )
01759 yy_fatal_error( "osolset_lineno called with no buffer" , yyscanner);
01760
01761 yylineno = line_number;
01762 }
01763
01768 void osolset_column (int column_no , yyscan_t yyscanner)
01769 {
01770 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01771
01772
01773 if (! YY_CURRENT_BUFFER )
01774 yy_fatal_error( "osolset_column called with no buffer" , yyscanner);
01775
01776 yycolumn = column_no;
01777 }
01778
01785 void osolset_in (FILE * in_str , yyscan_t yyscanner)
01786 {
01787 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01788 yyin = in_str ;
01789 }
01790
01791 void osolset_out (FILE * out_str , yyscan_t yyscanner)
01792 {
01793 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01794 yyout = out_str ;
01795 }
01796
01797 int osolget_debug (yyscan_t yyscanner)
01798 {
01799 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01800 return yy_flex_debug;
01801 }
01802
01803 void osolset_debug (int bdebug , yyscan_t yyscanner)
01804 {
01805 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01806 yy_flex_debug = bdebug ;
01807 }
01808
01809
01810
01811
01812
01813
01814
01815
01816
01817
01818 int osollex_init(yyscan_t* ptr_yy_globals)
01819
01820 {
01821 if (ptr_yy_globals == NULL){
01822 errno = EINVAL;
01823 return 1;
01824 }
01825
01826 *ptr_yy_globals = (yyscan_t) osolalloc ( sizeof( struct yyguts_t ), NULL );
01827
01828 if (*ptr_yy_globals == NULL){
01829 errno = ENOMEM;
01830 return 1;
01831 }
01832
01833
01834 memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
01835
01836 return yy_init_globals ( *ptr_yy_globals );
01837 }
01838
01839 static int yy_init_globals (yyscan_t yyscanner)
01840 {
01841 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01842
01843
01844
01845
01846 yyg->yy_buffer_stack = 0;
01847 yyg->yy_buffer_stack_top = 0;
01848 yyg->yy_buffer_stack_max = 0;
01849 yyg->yy_c_buf_p = (char *) 0;
01850 yyg->yy_init = 0;
01851 yyg->yy_start = 0;
01852
01853 yyg->yy_start_stack_ptr = 0;
01854 yyg->yy_start_stack_depth = 0;
01855 yyg->yy_start_stack = NULL;
01856
01857
01858 #ifdef YY_STDINIT
01859 yyin = stdin;
01860 yyout = stdout;
01861 #else
01862 yyin = (FILE *) 0;
01863 yyout = (FILE *) 0;
01864 #endif
01865
01866
01867
01868
01869 return 0;
01870 }
01871
01872
01873 int osollex_destroy (yyscan_t yyscanner)
01874 {
01875 struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01876
01877
01878 while(YY_CURRENT_BUFFER){
01879 osol_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
01880 YY_CURRENT_BUFFER_LVALUE = NULL;
01881 osolpop_buffer_state(yyscanner);
01882 }
01883
01884
01885 osolfree(yyg->yy_buffer_stack ,yyscanner);
01886 yyg->yy_buffer_stack = NULL;
01887
01888
01889 osolfree(yyg->yy_start_stack ,yyscanner );
01890 yyg->yy_start_stack = NULL;
01891
01892
01893
01894 yy_init_globals( yyscanner);
01895
01896
01897 osolfree ( yyscanner , yyscanner );
01898 yyscanner = NULL;
01899 return 0;
01900 }
01901
01902
01903
01904
01905
01906 #ifndef yytext_ptr
01907 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
01908 {
01909 register int i;
01910 for ( i = 0; i < n; ++i )
01911 s1[i] = s2[i];
01912 }
01913 #endif
01914
01915 #ifdef YY_NEED_STRLEN
01916 static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
01917 {
01918 register int n;
01919 for ( n = 0; s[n]; ++n )
01920 ;
01921
01922 return n;
01923 }
01924 #endif
01925
01926 void *osolalloc (yy_size_t size , yyscan_t yyscanner)
01927 {
01928 return (void *) malloc( size );
01929 }
01930
01931 void *osolrealloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
01932 {
01933
01934
01935
01936
01937
01938
01939
01940 return (void *) realloc( (char *) ptr, size );
01941 }
01942
01943 void osolfree (void * ptr , yyscan_t yyscanner)
01944 {
01945 free( (char *) ptr );
01946 }
01947
01948 #define YYTABLES_NAME "yytables"
01949
01950 #line 60 "/Users/kmartin/Documents/files/code/cpp/OScpp/COIN-OS/OS/src/OSParsers/parseosol.l"
01951
01952
01953
01954
01955