/home/coin/SVN-release/OS-1.0.0/OS/src/OSParsers/parseosol.cpp

Go to the documentation of this file.
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 /* A lexical scanner generated by flex */
00008 
00009 #define FLEX_SCANNER
00010 #define YY_FLEX_MAJOR_VERSION 2
00011 #define YY_FLEX_MINOR_VERSION 5
00012 #define YY_FLEX_SUBMINOR_VERSION 33
00013 #if YY_FLEX_SUBMINOR_VERSION > 0
00014 #define FLEX_BETA
00015 #endif
00016 
00017 /* First, we deal with  platform-specific or compiler-specific issues. */
00018 
00019 /* begin standard C headers. */
00020 #include <stdio.h>
00021 #include <string.h>
00022 #include <errno.h>
00023 #include <stdlib.h>
00024 
00025 /* end standard C headers. */
00026 
00027 /* flex integer type definitions */
00028 
00029 #ifndef FLEXINT_H
00030 #define FLEXINT_H
00031 
00032 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
00033 
00034 #if __STDC_VERSION__ >= 199901L
00035 
00036 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
00037  * if you want the limit (max/min) macros for int types. 
00038  */
00039 #ifndef __STDC_LIMIT_MACROS
00040 #define __STDC_LIMIT_MACROS 1
00041 #endif
00042 
00043 #include <inttypes.h>
00044 typedef int8_t flex_int8_t;
00045 typedef uint8_t flex_uint8_t;
00046 typedef int16_t flex_int16_t;
00047 typedef uint16_t flex_uint16_t;
00048 typedef int32_t flex_int32_t;
00049 typedef uint32_t flex_uint32_t;
00050 #else
00051 typedef signed char flex_int8_t;
00052 typedef short int flex_int16_t;
00053 typedef int flex_int32_t;
00054 typedef unsigned char flex_uint8_t; 
00055 typedef unsigned short int flex_uint16_t;
00056 typedef unsigned int flex_uint32_t;
00057 #endif /* ! C99 */
00058 
00059 /* Limits of integral types. */
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 /* ! FLEXINT_H */
00089 
00090 #ifdef __cplusplus
00091 
00092 /* The "const" storage-class-modifier is valid. */
00093 #define YY_USE_CONST
00094 
00095 #else   /* ! __cplusplus */
00096 
00097 #if __STDC__
00098 
00099 #define YY_USE_CONST
00100 
00101 #endif  /* __STDC__ */
00102 #endif  /* ! __cplusplus */
00103 
00104 #ifdef YY_USE_CONST
00105 #define yyconst const
00106 #else
00107 #define yyconst
00108 #endif
00109 
00110 /* Returned upon end-of-file. */
00111 #define YY_NULL 0
00112 
00113 /* Promotes a possibly negative, possibly signed char to an unsigned
00114  * integer for use as an array index.  If the signed char is negative,
00115  * we want to instead treat it as an 8-bit unsigned char, hence the
00116  * double cast.
00117  */
00118 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00119 
00120 /* An opaque pointer. */
00121 #ifndef YY_TYPEDEF_YY_SCANNER_T
00122 #define YY_TYPEDEF_YY_SCANNER_T
00123 typedef void* yyscan_t;
00124 #endif
00125 
00126 /* For convenience, these vars (plus the bison vars far below)
00127    are macros in the reentrant scanner. */
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 /* Enter a start condition.  This macro really ought to take a parameter,
00140  * but we do it the disgusting crufty way forced on us by the ()-less
00141  * definition of BEGIN.
00142  */
00143 #define BEGIN yyg->yy_start = 1 + 2 *
00144 
00145 /* Translate the current start state into a value that can be later handed
00146  * to BEGIN to return to the state.  The YYSTATE alias is for lex
00147  * compatibility.
00148  */
00149 #define YY_START ((yyg->yy_start - 1) / 2)
00150 #define YYSTATE YY_START
00151 
00152 /* Action number for EOF rule of a given start state. */
00153 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00154 
00155 /* Special action meaning "start processing a new file". */
00156 #define YY_NEW_FILE osolrestart(yyin ,yyscanner )
00157 
00158 #define YY_END_OF_BUFFER_CHAR 0
00159 
00160 /* Size of default input buffer. */
00161 #ifndef YY_BUF_SIZE
00162 #define YY_BUF_SIZE 16384
00163 #endif
00164 
00165 /* The state buf must be large enough to hold one state per character in the main buffer.
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     /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
00179      *       access to the local variable yy_act. Since yyless() is a macro, it would break
00180      *       existing scanners that call yyless() from OUTSIDE osollex. 
00181      *       One obvious solution it to make yy_act a global. I tried that, and saw
00182      *       a 5% performance hit in a non-yylineno scanner, because yy_act is
00183      *       normally declared as a register variable-- so it is not worth it.
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 /* Return all but the first "n" matched characters back to the input stream. */
00194 #define yyless(n) \
00195         do \
00196                 { \
00197                 /* Undo effects of setting up yytext. */ \
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; /* set up yytext again */ \
00204                 } \
00205         while ( 0 )
00206 
00207 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
00208 
00209 /* The following is because we cannot portably get our hands on size_t
00210  * (without autoconf's help, which isn't available because we want
00211  * flex-generated scanners to compile on their own).
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;                /* input buffer */
00226         char *yy_buf_pos;               /* current position in input buffer */
00227 
00228         /* Size of input buffer in bytes, not including room for EOB
00229          * characters.
00230          */
00231         yy_size_t yy_buf_size;
00232 
00233         /* Number of characters read into yy_ch_buf, not including EOB
00234          * characters.
00235          */
00236         int yy_n_chars;
00237 
00238         /* Whether we "own" the buffer - i.e., we know we created it,
00239          * and can realloc() it to grow it, and should free() it to
00240          * delete it.
00241          */
00242         int yy_is_our_buffer;
00243 
00244         /* Whether this is an "interactive" input source; if so, and
00245          * if we're using stdio for input, then we want to use getc()
00246          * instead of fread(), to make sure we stop fetching input after
00247          * each newline.
00248          */
00249         int yy_is_interactive;
00250 
00251         /* Whether we're considered to be at the beginning of a line.
00252          * If so, '^' rules will be active on the next match, otherwise
00253          * not.
00254          */
00255         int yy_at_bol;
00256 
00257     int yy_bs_lineno; 
00258     int yy_bs_column; 
00260         /* Whether to try to fill the input buffer when we reach the
00261          * end of it.
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         /* When an EOF's been seen but there's still some text to process
00270          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
00271          * shouldn't try reading from the input source any more.  We might
00272          * still have a bunch of tokens to match, though, because of
00273          * possible backing-up.
00274          *
00275          * When we actually see the EOF, we change the status to "new"
00276          * (via osolrestart()), so that the user can continue scanning by
00277          * just pointing yyin at a new input file.
00278          */
00279 #define YY_BUFFER_EOF_PENDING 2
00280 
00281         };
00282 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
00283 
00284 /* We provide macros for accessing buffer states in case in the
00285  * future we want to put the buffer states in a more general
00286  * "scanner state".
00287  *
00288  * Returns the top of the stack, or NULL.
00289  */
00290 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
00291                           ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
00292                           : NULL)
00293 
00294 /* Same as previous macro, but useful when we know that the buffer stack is not
00295  * NULL or when we need an lvalue. For internal use only.
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 /* Begin user sect3 */
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 /* Done after the current pattern has been matched and before the
00362  * corresponding action - sets up yytext.
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 /* This struct is not used in this scanner,
00374    but its presence is necessary. */
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 /* Table of booleans, true if rule could match eol. */
00450 static yyconst flex_int32_t yy_rule_can_match_eol[4] =
00451     {   0,
00452 1, 0, 0,     };
00453 
00454 /* The intent behind this definition is that it'll catch
00455  * any uses of REJECT which flex missed.
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 /* Special case for "unistd.h", since it is non-ANSI. We include it way
00507  * down here because we want the user's section 1 to have been scanned first.
00508  * The user has a chance to override it with an option.
00509  */
00510 #include <unistd.h>
00511 #endif
00512 
00513 #ifndef YY_EXTRA_TYPE
00514 #define YY_EXTRA_TYPE void *
00515 #endif
00516 
00517 /* Holds the entire state of the reentrant scanner. */
00518 struct yyguts_t
00519     {
00520 
00521     /* User-defined. Not touched by flex. */
00522     YY_EXTRA_TYPE yyextra_r;
00523 
00524     /* The rest are the same as the globals declared in the non-reentrant scanner. */
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     }; /* end struct yyguts_t */
00550 
00551 static int yy_init_globals (yyscan_t yyscanner );
00552 
00553 /* Accessor methods to globals.
00554    These are made visible to non-reentrant scanners for convenience. */
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 /* Macros after this point can all be overridden by user definitions in
00583  * section 1.
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 /* Amount of stuff to slurp up with each read. */
00615 #ifndef YY_READ_BUF_SIZE
00616 #define YY_READ_BUF_SIZE 8192
00617 #endif
00618 
00619 /* Copy whatever the last rule matched to the standard output. */
00620 #ifndef ECHO
00621 /* This used to be an fputs(), but since the string might contain NUL's,
00622  * we now use fwrite().
00623  */
00624 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
00625 #endif
00626 
00627 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
00628  * is returned in "result".
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 /* No semi-colon after return; correct usage is to write "yyterminate();" -
00664  * we don't want an extra ';' after the "return" because that will cause
00665  * some compilers to complain about unreachable statements.
00666  */
00667 #ifndef yyterminate
00668 #define yyterminate() return YY_NULL
00669 #endif
00670 
00671 /* Number of entries by which start-condition stack grows. */
00672 #ifndef YY_START_STACK_INCR
00673 #define YY_START_STACK_INCR 25
00674 #endif
00675 
00676 /* Report a fatal error. */
00677 #ifndef YY_FATAL_ERROR
00678 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
00679 #endif
00680 
00681 /* end tables serialization structures and prototypes */
00682 
00683 /* Default declaration of generated scanner - a define so the user can
00684  * easily add parameters.
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 /* !YY_DECL */
00693 
00694 /* Code executed at the beginning of each rule, after yytext and yyleng
00695  * have been set up.
00696  */
00697 #ifndef YY_USER_ACTION
00698 #define YY_USER_ACTION
00699 #endif
00700 
00701 /* Code executed at the end of each rule. */
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;      /* first start state */
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 )             /* loops until end-of-file is reached */
00750                 {
00751                 yy_cp = yyg->yy_c_buf_p;
00752 
00753                 /* Support of yytext. */
00754                 *yy_cp = yyg->yy_hold_char;
00755 
00756                 /* yy_bp points to the position in yy_ch_buf of the start of
00757                  * the current run.
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                         { /* have to back up */
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:      /* This label is used only to access EOF actions. */
00806 
00807                 switch ( yy_act )
00808         { /* beginning of action switch */
00809                         case 0: /* must back up */
00810                         /* undo the effects of YY_DO_BEFORE_ACTION */
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 /* rule 1 can match eol */
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                 /* Amount of text matched not including the EOB char. */
00839                 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
00840 
00841                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
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                         /* We're scanning a new file or input source.  It's
00848                          * possible that this happened because the user
00849                          * just pointed yyin at a new source and called
00850                          * osollex().  If so, then we have to assure
00851                          * consistency between YY_CURRENT_BUFFER and our
00852                          * globals.  Here is the right place to do so, because
00853                          * this is the first action (other than possibly a
00854                          * back-up) that will match for the new input source.
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                 /* Note that here we test for yy_c_buf_p "<=" to the position
00862                  * of the first EOB in the buffer, since yy_c_buf_p will
00863                  * already have been incremented past the NUL character
00864                  * (since all states make transitions on EOB to the
00865                  * end-of-buffer state).  Contrast this with the test
00866                  * in input().
00867                  */
00868                 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
00869                         { /* This was really a NUL. */
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                         /* Okay, we're now positioned to make the NUL
00877                          * transition.  We couldn't have
00878                          * yy_get_previous_state() go ahead and do it
00879                          * for us because it doesn't know how to deal
00880                          * with the possibility of jamming (and we don't
00881                          * want to build jamming into it because then it
00882                          * will run more slowly).
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                                 /* Consume the NUL. */
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                                         /* Note: because we've taken care in
00913                                          * yy_get_next_buffer() to have set up
00914                                          * yytext, we can now set up
00915                                          * yy_c_buf_p so that if some total
00916                                          * hoser (like flex itself) wants to
00917                                          * call the scanner after we return the
00918                                          * YY_NULL, it'll still work - another
00919                                          * YY_NULL will get returned.
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         } /* end of action switch */
00962                 } /* end of scanning one token */
00963 } /* end of osollex */
00964 
00965 /* yy_get_next_buffer - try to read in a new buffer
00966  *
00967  * Returns a code representing an action:
00968  *      EOB_ACT_LAST_MATCH -
00969  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
00970  *      EOB_ACT_END_OF_FILE - end of file
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                 { /* Don't try to fill the buffer, so this is an EOF. */
00986                 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
00987                         {
00988                         /* We matched a single character, the EOB, so
00989                          * treat this as a final EOF.
00990                          */
00991                         return EOB_ACT_END_OF_FILE;
00992                         }
00993 
00994                 else
00995                         {
00996                         /* We matched some text prior to the EOB, first
00997                          * process it.
00998                          */
00999                         return EOB_ACT_LAST_MATCH;
01000                         }
01001                 }
01002 
01003         /* Try to read more data. */
01004 
01005         /* First move last chars to start of buffer. */
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                 /* don't do the read, it's not guaranteed to return an EOF,
01013                  * just force an EOF
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                         { /* Not enough room in the buffer - grow it. */
01024 
01025                         /* just a shorter name for the current buffer */
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                                         /* Include room in for 2 EOB chars. */
01042                                         osolrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
01043                                 }
01044                         else
01045                                 /* Can't grow it, we don't own it. */
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                 /* Read in more data. */
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 /* yy_get_previous_state - get the state just before the EOB char was reached */
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 /* yy_try_NUL_trans - try to make a transition on the NUL character
01128  *
01129  * synopsis
01130  *      next_state = yy_try_NUL_trans( current_state );
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; /* This var may be unused depending upon options. */
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         /* undo effects of setting up yytext */
01164         *yy_cp = yyg->yy_hold_char;
01165 
01166         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
01167                 { /* need to shift things up to make room */
01168                 /* +2 for EOB chars. */
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                 /* yy_c_buf_p now points to the character we want to return.
01214                  * If this occurs *before* the EOB characters, then it's a
01215                  * valid NUL; if not, then we've hit the end of the buffer.
01216                  */
01217                 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
01218                         /* This was really a NUL. */
01219                         *yyg->yy_c_buf_p = '\0';
01220 
01221                 else
01222                         { /* need more input */
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                                         /* This happens because yy_g_n_b()
01230                                          * sees that we've accumulated a
01231                                          * token and flags that we need to
01232                                          * try matching the token before
01233                                          * proceeding.  But for input(),
01234                                          * there's no matching to consider.
01235                                          * So convert the EOB_ACT_LAST_MATCH
01236                                          * to EOB_ACT_END_OF_FILE.
01237                                          */
01238 
01239                                         /* Reset buffer status. */
01240                                         osolrestart(yyin ,yyscanner);
01241 
01242                                         /*FALLTHROUGH*/
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; /* cast for 8-bit char's */
01266         *yyg->yy_c_buf_p = '\0';        /* preserve yytext */
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  /* ifndef YY_NO_INPUT */
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         /* TODO. We should be able to replace this entire function body
01308          * with
01309          *              osolpop_buffer_state();
01310          *              osolpush_buffer_state(new_buffer);
01311      */
01312         osolensure_buffer_stack (yyscanner);
01313         if ( YY_CURRENT_BUFFER == new_buffer )
01314                 return;
01315 
01316         if ( YY_CURRENT_BUFFER )
01317                 {
01318                 /* Flush out information for old buffer. */
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         /* We don't actually know whether we did this switch during
01328          * EOF (osolwrap()) processing, but the only time this flag
01329          * is looked at is after osolwrap() is called, so it's safe
01330          * to go ahead and always set it.
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         /* yy_ch_buf has to be 2 characters longer than the size given because
01361          * we need to put in 2 end-of-buffer characters.
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 ) /* Not sure if we should pop here. */
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 /* __cplusplus */
01397     
01398 /* Initializes or reinitializes a buffer.
01399  * This function is sometimes called more than once on the same buffer,
01400  * such as during a osolrestart() or at EOF.
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     /* If b is the current buffer, then osol_init_buffer was _probably_
01414      * called from osolrestart() or through yy_get_next_buffer.
01415      * In that case, we don't want to reset the lineno or column.
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         /* We always need two end-of-buffer characters.  The first causes
01440          * a transition to the end-of-buffer state.  The second causes
01441          * a jam in that state.
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         /* This block is copied from osol_switch_to_buffer. */
01470         if ( YY_CURRENT_BUFFER )
01471                 {
01472                 /* Flush out information for old buffer. */
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         /* Only push if top exists. Otherwise, replace top. */
01479         if (YY_CURRENT_BUFFER)
01480                 yyg->yy_buffer_stack_top++;
01481         YY_CURRENT_BUFFER_LVALUE = new_buffer;
01482 
01483         /* copied from osol_switch_to_buffer. */
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 /* Allocates the stack if it does not exist.
01510  *  Guarantees space for at least one push.
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                 /* First allocation is just for 2 elements, since we don't know if this
01520                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
01521                  * immediate realloc on the next call.
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                 /* Increase the buffer to prepare for a possible push. */
01538                 int grow_size = 8 /* arbitrary grow size */;
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                 /* zero only the new slots.*/
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                 /* They forgot to leave room for the EOB's. */
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;      /* "- 2" to take care of EOB's */
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         /* Get memory for full buffer, including space for trailing EOB's. */
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         /* It's okay to grow etc. this buffer, and we should throw it
01631          * away when we're done.
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 /* Redefine yyless() so it works in section 3 code. */
01649 
01650 #undef yyless
01651 #define yyless(n) \
01652         do \
01653                 { \
01654                 /* Undo effects of setting up yytext. */ \
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 /* Accessor  methods (get/set functions) to struct members. */
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         /* lineno is only valid if an input buffer exists. */
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         /* column is only valid if an input buffer exists. */
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 /* Accessor methods for yylval and yylloc */
01810 
01811 /* User-visible API */
01812 
01813 /* osollex_init is special because it creates the scanner itself, so it is
01814  * the ONLY reentrant function that doesn't take the scanner as the last argument.
01815  * That's why we explicitly handle the declaration, instead of using our macros.
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     /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
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     /* Initialization is the same as for the non-reentrant scanner.
01843      * This function is called from osollex_destroy(), so don't allocate here.
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 /* Defined in main.c */
01858 #ifdef YY_STDINIT
01859     yyin = stdin;
01860     yyout = stdout;
01861 #else
01862     yyin = (FILE *) 0;
01863     yyout = (FILE *) 0;
01864 #endif
01865 
01866     /* For future reference: Set errno on error, since we are called by
01867      * osollex_init()
01868      */
01869     return 0;
01870 }
01871 
01872 /* osollex_destroy is for both reentrant and non-reentrant scanners. */
01873 int osollex_destroy  (yyscan_t yyscanner)
01874 {
01875     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
01876 
01877     /* Pop the buffer stack, destroying each element. */
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         /* Destroy the stack itself. */
01885         osolfree(yyg->yy_buffer_stack ,yyscanner);
01886         yyg->yy_buffer_stack = NULL;
01887 
01888     /* Destroy the start condition stack. */
01889         osolfree(yyg->yy_start_stack ,yyscanner );
01890         yyg->yy_start_stack = NULL;
01891 
01892     /* Reset the globals. This is important in a non-reentrant scanner so the next time
01893      * osollex() is called, initialization will occur. */
01894     yy_init_globals( yyscanner);
01895 
01896     /* Destroy the main struct (reentrant only). */
01897     osolfree ( yyscanner , yyscanner );
01898     yyscanner = NULL;
01899     return 0;
01900 }
01901 
01902 /*
01903  * Internal utility routines.
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         /* The cast to (char *) in the following accommodates both
01934          * implementations that use char* generic pointers, and those
01935          * that use void* generic pointers.  It works with the latter
01936          * because both ANSI C and C++ allow castless assignment from
01937          * any pointer type to void*, and deal with argument conversions
01938          * as though doing an assignment.
01939          */
01940         return (void *) realloc( (char *) ptr, size );
01941 }
01942 
01943 void osolfree (void * ptr , yyscan_t yyscanner)
01944 {
01945         free( (char *) ptr );   /* see osolrealloc() for (char *) cast */
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 

Generated on Thu May 15 22:15:05 2008 by  doxygen 1.4.7