Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

Svc_Conf_l.cpp

Go to the documentation of this file.
00001 #include "ace_pch.h"
00002 #define ACE_YY_NO_UNPUT
00003 
00004 /* A lexical scanner generated by flex */
00005 
00006 /* Scanner skeleton version:
00007  * $Header: /cvs/ocitao/ACE_wrappers/ace/Svc_Conf_l.cpp,v 1.1.1.4.2.1 2003/03/13 19:44:22 chad Exp $
00008  */
00009 
00010 #define FLEX_SCANNER
00011 #define ACE_YY_FLEX_MAJOR_VERSION 2
00012 #define ACE_YY_FLEX_MINOR_VERSION 5
00013 
00014 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
00015 #ifdef c_plusplus
00016 #ifndef __cplusplus
00017 #define __cplusplus
00018 #endif
00019 #endif
00020 
00021 
00022 #ifdef __cplusplus
00023 
00024 #include "ace/OS.h"
00025 #include "ace/Object_Manager.h"
00026 
00027 /* Use prototypes in function declarations. */
00028 #define ACE_YY_USE_PROTOS
00029 
00030 /* The "const" storage-class-modifier is valid. */
00031 #define ACE_YY_USE_CONST
00032 
00033 #else   /* ! __cplusplus */
00034 
00035 #if __STDC__
00036 
00037 #define ACE_YY_USE_PROTOS
00038 #define ACE_YY_USE_CONST
00039 
00040 #endif  /* __STDC__ */
00041 #endif  /* ! __cplusplus */
00042 
00043 #if (ACE_USES_CLASSIC_SVC_CONF == 1)
00044 
00045 #ifdef __TURBOC__
00046  #pragma warn -rch
00047  #pragma warn -use
00048 #include /**/ <io.h>
00049 #include /**/ <stdlib.h>
00050 #define ACE_YY_USE_CONST
00051 #define ACE_YY_USE_PROTOS
00052 #endif
00053 
00054 #ifdef ACE_YY_USE_CONST
00055 #define ace_yyconst const
00056 #else
00057 #define ace_yyconst
00058 #endif
00059 
00060 
00061 #ifdef ACE_YY_USE_PROTOS
00062 #define ACE_YY_PROTO(proto) proto
00063 #else
00064 #define ACE_YY_PROTO(proto) ()
00065 #endif
00066 
00067 /* Returned upon end-of-file. */
00068 #define ACE_YY_NULL 0
00069 
00070 /* Promotes a possibly negative, possibly signed char to an unsigned
00071  * integer for use as an array index.  If the signed char is negative,
00072  * we want to instead treat it as an 8-bit unsigned char, hence the
00073  * double cast.
00074  */
00075 #define ACE_YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00076 
00077 /* Enter a start condition.  This macro really ought to take a parameter,
00078  * but we do it the disgusting crufty way forced on us by the ()-less
00079  * definition of BEGIN.
00080  */
00081 #define BEGIN ace_yy_start = 1 + 2 *
00082 
00083 /* Translate the current start state into a value that can be later handed
00084  * to BEGIN to return to the state.  The ACE_YYSTATE alias is for lex
00085  * compatibility.
00086  */
00087 #define ACE_YY_START ((ace_yy_start - 1) / 2)
00088 #define ACE_YYSTATE ACE_YY_START
00089 
00090 /* Action number for EOF rule of a given start state. */
00091 #define ACE_YY_STATE_EOF(state) (ACE_YY_END_OF_BUFFER + state + 1)
00092 
00093 /* Special action meaning "start processing a new file". */
00094 #define ACE_YY_NEW_FILE ace_yyrestart( ace_yyin )
00095 
00096 #define ACE_YY_END_OF_BUFFER_CHAR 0
00097 
00098 /* Size of default input buffer. */
00099 #define ACE_YY_BUF_SIZE 16384
00100 
00101 typedef struct ace_yy_buffer_state *ACE_YY_BUFFER_STATE;
00102 
00103 extern int ace_yyleng;
00104 extern FILE *ace_yyin, *ace_yyout;
00105 
00106 #define EOB_ACT_CONTINUE_SCAN 0
00107 #define EOB_ACT_END_OF_FILE 1
00108 #define EOB_ACT_LAST_MATCH 2
00109 
00110 /* The funky do-while in the following #define is used to turn the definition
00111  * int a single C statement (which needs a semi-colon terminator).  This
00112  * avoids problems with code like:
00113  *
00114  *      if ( condition_holds )
00115  *              ace_yyless( 5 );
00116  *      else
00117  *              do_something_else();
00118  *
00119  * Prior to using the do-while the compiler would get upset at the
00120  * "else" because it interpreted the "if" statement as being all
00121  * done when it reached the ';' after the ace_yyless() call.
00122  */
00123 
00124 /* Return all but the first 'n' matched characters back to the input stream. */
00125 
00126 #define ace_yyless(n) \
00127         do \
00128                 { \
00129                 /* Undo effects of setting up ace_yytext. */ \
00130                 *ace_yy_cp = ace_yy_hold_char; \
00131                 ACE_YY_RESTORE_ACE_YY_MORE_OFFSET \
00132                 ace_yy_c_buf_p = ace_yy_cp = ace_yy_bp + n - ACE_YY_MORE_ADJ; \
00133                 ACE_YY_DO_BEFORE_ACTION; /* set up ace_yytext again */ \
00134                 } \
00135         while ( 0 )
00136 
00137 #if 0
00138 #define unput(c) ace_yyunput( c, ace_yytext_ptr )
00139 #endif /* 0 */
00140 
00141 /* The following is because we cannot portably get our hands on size_t
00142  * (without autoconf's help, which isn't available because we want
00143  * flex-generated scanners to compile on their own).
00144  */
00145 typedef unsigned int ace_yy_size_t;
00146 
00147 
00148 struct ace_yy_buffer_state
00149         {
00150         FILE *ace_yy_input_file;
00151 
00152         ACE_TCHAR *ace_yy_ch_buf;       /* input buffer */
00153         ACE_TCHAR *ace_yy_buf_pos;      /* current position in input buffer */
00154 
00155         /* Size of input buffer in bytes, not including room for EOB
00156          * characters.
00157          */
00158         ace_yy_size_t ace_yy_buf_size;
00159 
00160         /* Number of characters read into ace_yy_ch_buf, not including EOB
00161          * characters.
00162          */
00163         int ace_yy_n_chars;
00164 
00165         /* Whether we "own" the buffer - i.e., we know we created it,
00166          * and can realloc() it to grow it, and should free() it to
00167          * delete it.
00168          */
00169         int ace_yy_is_our_buffer;
00170 
00171         /* Whether this is an "interactive" input source; if so, and
00172          * if we're using stdio for input, then we want to use getc()
00173          * instead of fread(), to make sure we stop fetching input after
00174          * each newline.
00175          */
00176         int ace_yy_is_interactive;
00177 
00178         /* Whether we're considered to be at the beginning of a line.
00179          * If so, '^' rules will be active on the next match, otherwise
00180          * not.
00181          */
00182         int ace_yy_at_bol;
00183 
00184         /* Whether to try to fill the input buffer when we reach the
00185          * end of it.
00186          */
00187         int ace_yy_fill_buffer;
00188 
00189         int ace_yy_buffer_status;
00190 #define ACE_YY_BUFFER_NEW 0
00191 #define ACE_YY_BUFFER_NORMAL 1
00192         /* When an EOF's been seen but there's still some text to process
00193          * then we mark the buffer as ACE_YY_EOF_PENDING, to indicate that we
00194          * shouldn't try reading from the input source any more.  We might
00195          * still have a bunch of tokens to match, though, because of
00196          * possible backing-up.
00197          *
00198          * When we actually see the EOF, we change the status to "new"
00199          * (via ace_yyrestart()), so that the user can continue scanning by
00200          * just pointing ace_yyin at a new input file.
00201          */
00202 #define ACE_YY_BUFFER_EOF_PENDING 2
00203         };
00204 
00205 static ACE_YY_BUFFER_STATE ace_yy_current_buffer = 0;
00206 
00207 /* We provide macros for accessing buffer states in case in the
00208  * future we want to put the buffer states in a more general
00209  * "scanner state".
00210  */
00211 #define ACE_YY_CURRENT_BUFFER ace_yy_current_buffer
00212 
00213 
00214 /* ace_yy_hold_char holds the character lost when ace_yytext is formed. */
00215 static ACE_TCHAR ace_yy_hold_char;
00216 
00217 static int ace_yy_n_chars;              /* number of characters read into ace_yy_ch_buf */
00218 
00219 
00220 int ace_yyleng;
00221 
00222 /* Points to current character in buffer. */
00223 static ACE_TCHAR *ace_yy_c_buf_p = (ACE_TCHAR *) 0;
00224 static int ace_yy_init = 1;             /* whether we need to initialize */
00225 static int ace_yy_start = 0;    /* start state number */
00226 
00227 /* Flag which is used to allow ace_yywrap()'s to do buffer switches
00228  * instead of setting up a fresh ace_yyin.  A bit of a hack ...
00229  */
00230 static int ace_yy_did_buffer_switch_on_eof;
00231 
00232 void ace_yyrestart ACE_YY_PROTO(( FILE *input_file ));
00233 
00234 void ace_yy_switch_to_buffer ACE_YY_PROTO(( ACE_YY_BUFFER_STATE new_buffer ));
00235 void ace_yy_load_buffer_state ACE_YY_PROTO(( void ));
00236 ACE_YY_BUFFER_STATE ace_yy_create_buffer ACE_YY_PROTO(( FILE *file, int size ));
00237 void ace_yy_delete_buffer ACE_YY_PROTO(( ACE_YY_BUFFER_STATE b ));
00238 void ace_yy_init_buffer ACE_YY_PROTO(( ACE_YY_BUFFER_STATE b, FILE *file ));
00239 void ace_yy_flush_buffer ACE_YY_PROTO(( ACE_YY_BUFFER_STATE b ));
00240 #define ACE_YY_FLUSH_BUFFER ace_yy_flush_buffer( ace_yy_current_buffer )
00241 
00242 ACE_YY_BUFFER_STATE ace_yy_scan_buffer ACE_YY_PROTO(( ACE_TCHAR *base, ace_yy_size_t size ));
00243 ACE_YY_BUFFER_STATE ace_yy_scan_string ACE_YY_PROTO(( ace_yyconst ACE_TCHAR *ace_yy_str ));
00244 ACE_YY_BUFFER_STATE ace_yy_scan_bytes ACE_YY_PROTO(( ace_yyconst ACE_TCHAR *bytes, int len ));
00245 
00246 static void *ace_yy_flex_alloc ACE_YY_PROTO(( ace_yy_size_t ));
00247 static void *ace_yy_flex_realloc ACE_YY_PROTO(( void *, ace_yy_size_t ));
00248 static void ace_yy_flex_free ACE_YY_PROTO(( void * ));
00249 
00250 #define ace_yy_new_buffer ace_yy_create_buffer
00251 
00252 #define ace_yy_set_interactive(is_interactive) \
00253         { \
00254         if ( ! ace_yy_current_buffer ) \
00255                 ace_yy_current_buffer = ace_yy_create_buffer( ace_yyin, ACE_YY_BUF_SIZE ); \
00256         ace_yy_current_buffer->ace_yy_is_interactive = is_interactive; \
00257         }
00258 
00259 #define ace_yy_set_bol(at_bol) \
00260         { \
00261         if ( ! ace_yy_current_buffer ) \
00262                 ace_yy_current_buffer = ace_yy_create_buffer( ace_yyin, ACE_YY_BUF_SIZE ); \
00263         ace_yy_current_buffer->ace_yy_at_bol = at_bol; \
00264         }
00265 
00266 #define ACE_YY_AT_BOL() (ace_yy_current_buffer->ace_yy_at_bol)
00267 
00268 typedef ACE_TCHAR ACE_YY_CHAR;
00269 FILE *ace_yyin = (FILE *) 0, *ace_yyout = (FILE *) 0;
00270 typedef int ace_yy_state_type;
00271 extern ACE_TCHAR *ace_yytext;
00272 #define ace_yytext_ptr ace_yytext
00273 
00274 static ace_yy_state_type ace_yy_get_previous_state ACE_YY_PROTO(( void ));
00275 static ace_yy_state_type ace_yy_try_NUL_trans ACE_YY_PROTO(( ace_yy_state_type current_state ));
00276 static int ace_yy_get_next_buffer ACE_YY_PROTO(( void ));
00277 static void ace_yy_fatal_error ACE_YY_PROTO(( ace_yyconst ACE_TCHAR msg[] ));
00278 
00279 /* Done after the current pattern has been matched and before the
00280  * corresponding action - sets up ace_yytext.
00281  */
00282 #define ACE_YY_DO_BEFORE_ACTION \
00283         ace_yytext_ptr = ace_yy_bp; \
00284         ace_yyleng = (int) (ace_yy_cp - ace_yy_bp); \
00285         ace_yy_hold_char = *ace_yy_cp; \
00286         *ace_yy_cp = '\0'; \
00287         ace_yy_c_buf_p = ace_yy_cp;
00288 
00289 #define ACE_YY_NUM_RULES 26
00290 #define ACE_YY_END_OF_BUFFER 27
00291 static ace_yyconst short int ace_yy_accept[108] =
00292     {   0,
00293         0,    0,    0,    0,    0,    0,   27,   25,   22,   24,
00294        23,   25,   21,   25,   15,   16,   14,   21,   13,   20,
00295        20,   20,   20,   20,   20,   20,   20,   20,   17,   18,
00296        25,   22,    0,   19,   21,    0,    0,   19,   20,   20,
00297        20,   20,   20,   20,   20,   20,   20,   20,    0,    1,
00298        20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
00299        20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
00300        20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
00301        20,   20,   20,    8,   10,   20,   11,   20,   20,    6,
00302         5,    3,    7,   20,   20,    2,   20,    4,   20,   12,
00303 
00304        20,   20,   20,   20,   20,    9,    0
00305     } ;
00306 
00307 static ace_yyconst int ace_yy_ec[256] =
00308     {   0,
00309         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
00310         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
00311         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00312         1,    5,    6,    7,    8,    6,    9,    6,   10,   11,
00313        12,   13,    6,    6,   14,   14,   14,   15,   15,   15,
00314        15,   15,   15,   15,   15,   15,   15,   16,    6,    6,
00315         6,    6,    6,    6,   17,   18,   18,   18,   19,   18,
00316        18,   18,   18,   18,   18,   18,   20,   18,   21,   18,
00317        18,   22,   23,   24,   18,   18,   18,   18,   18,   18,
00318         6,   14,    6,    6,   25,    6,   26,   27,   28,   29,
00319 
00320        30,   18,   18,   18,   31,   32,   18,   33,   34,   35,
00321        36,   37,   18,   38,   39,   40,   41,   42,   18,   18,
00322        43,   18,   44,    6,   45,   14,    1,    1,    1,    1,
00323         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00324         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00325         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00326         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00327         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00328         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00329         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00330 
00331         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00332         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00333         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00334         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00335         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00336         1,    1,    1,    1,    1
00337     } ;
00338 
00339 static ace_yyconst int ace_yy_meta[46] =
00340     {   0,
00341         1,    1,    1,    1,    2,    2,    2,    2,    3,    2,
00342         2,    2,    2,    3,    3,    3,    3,    3,    3,    3,
00343         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
00344         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
00345         3,    3,    3,    2,    2
00346     } ;
00347 
00348 static ace_yyconst short int ace_yy_base[113] =
00349     {   0,
00350         0,  127,    0,  118,    0,  117,  124,  438,   44,  438,
00351       438,  115,  100,   93,  438,  438,  438,   86,  438,   38,
00352        39,   42,   48,   51,   54,   60,   64,   68,  438,  438,
00353        98,   81,   86,   82,   72,   71,   71,   61,   76,   82,
00354        90,   91,  101,  104,  105,  114,  118,  124,   58,  438,
00355       133,  136,  145,  148,  151,  157,  166,  167,  175,  179,
00356       183,  189,  197,  203,  207,  216,  215,  219,  228,  227,
00357       231,  237,  250,  254,  262,  263,  272,  273,  282,  283,
00358       286,  292,  301,  302,  311,  314,  315,  323,  324,  332,
00359       333,  336,  344,  345,  348,  354,  362,  363,  366,  372,
00360 
00361       375,  381,  384,  387,  390,  396,  438,  429,   56,  431,
00362        47,  434
00363     } ;
00364 
00365 static ace_yyconst short int ace_yy_def[113] =
00366     {   0,
00367       107,    1,    1,    1,    1,    1,  107,  107,  107,  107,
00368       107,  108,  109,  110,  107,  107,  107,  109,  107,  111,
00369       111,  111,  111,  111,  111,  111,  111,  111,  107,  107,
00370       112,  107,  108,  108,  109,  109,  110,  110,  111,  111,
00371       111,  111,  111,  111,  111,  111,  111,  111,  112,  107,
00372       111,  111,  111,  111,  111,  111,  111,  111,  111,  111,
00373       111,  111,  111,  111,  111,  111,  111,  111,  111,  111,
00374       111,  111,  111,  111,  111,  111,  111,  111,  111,  111,
00375       111,  111,  111,  111,  111,  111,  111,  111,  111,  111,
00376       111,  111,  111,  111,  111,  111,  111,  111,  111,  111,
00377 
00378       111,  111,  111,  111,  111,  111,    0,  107,  107,  107,
00379       107,  107
00380     } ;
00381 
00382 static ace_yyconst short int ace_yy_nxt[484] =
00383     {   0,
00384         8,    9,   10,   11,    9,    8,   12,    8,   13,   14,
00385        15,   16,   17,   18,   18,   19,   20,   20,   20,   21,
00386        20,   20,   22,   20,   23,   24,   20,   20,   25,   20,
00387        26,   20,   20,   20,   20,   20,   20,   27,   28,   20,
00388        20,   20,   20,   29,   30,   32,   35,   35,   32,   39,
00389        35,   35,   35,   36,   36,   35,   35,   36,   35,   35,
00390        50,   35,   35,  107,   35,   41,   36,   35,   35,   36,
00391        38,   42,   35,   35,   40,   36,   35,   35,   43,   36,
00392        38,   35,   32,   36,   35,   32,  107,  107,   34,   35,
00393        35,  107,   34,   46,   45,   35,   44,  107,   35,   35,
00394 
00395        50,  107,   38,   35,   35,  107,  107,   47,   48,   35,
00396        51,   52,   35,   35,   35,   36,  107,   35,   35,  107,
00397       107,   34,   35,  107,   31,   31,   35,   35,   53,  107,
00398        56,   35,   35,  107,   31,  107,  107,   35,   55,  107,
00399        54,   35,  107,   59,   35,  107,   35,   57,  107,   35,
00400       107,  107,   58,   35,   63,   60,   35,  107,   35,   35,
00401       107,   35,   61,  107,   35,   35,  107,  107,  107,  107,
00402        35,  107,  107,   62,   35,   35,   66,  107,   65,   35,
00403        35,  107,  107,   35,   67,  107,   64,   35,   35,  107,
00404       107,   35,   35,  107,  107,  107,   35,   35,  107,  107,
00405 
00406       107,   68,   35,  107,  107,   35,  107,   69,   71,  107,
00407        35,   35,  107,   74,   70,   35,   35,  107,  107,   72,
00408        35,   73,  107,   35,   35,  107,  107,   35,   35,   35,
00409       107,  107,   35,   75,  107,   35,   35,  107,  107,   35,
00410        35,   35,  107,  107,   35,   35,  107,  107,   76,   77,
00411        35,  107,  107,  107,   78,  107,   82,   81,   35,  107,
00412        79,   80,   35,   35,  107,  107,   83,   35,  107,  107,
00413        35,   35,  107,   85,  107,   35,   35,  107,  107,   84,
00414        35,   35,  107,  107,  107,   35,   35,  107,  107,   86,
00415        35,   35,   87,  107,   35,   35,   35,  107,  107,   35,
00416 
00417        35,  107,   88,   89,  107,   35,  107,  107,  107,   35,
00418        35,   90,   91,   92,   35,   35,  107,  107,  107,   35,
00419       107,  107,   35,   35,   35,   93,  107,   35,   35,  107,
00420       107,   35,   35,  107,  107,   94,   35,   35,  107,  107,
00421        35,   35,  107,   95,   35,   35,   35,  107,  107,   35,
00422        96,  107,   35,   35,  107,  107,   35,   35,   35,  107,
00423       107,   35,   35,  107,  107,   97,  107,   35,  107,  107,
00424        35,   35,   99,   98,   35,   35,   35,  107,  107,   35,
00425        35,  107,  107,   35,  107,   35,  101,  107,   35,   35,
00426       107,  100,   35,  107,   35,   35,  107,   35,   35,  107,
00427 
00428        35,  102,  107,   35,   35,  107,  107,  107,  107,   35,
00429       107,  107,  103,  104,  105,  107,  107,  107,  107,  107,
00430       107,  107,  107,  107,  107,  107,  107,  107,  107,  106,
00431        33,   33,   37,   37,   49,   49,   49,    7,  107,  107,
00432       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
00433       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
00434       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
00435       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
00436       107,  107,  107
00437     } ;
00438 
00439 static ace_yyconst short int ace_yy_chk[484] =
00440     {   0,
00441         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00442         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00443         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00444         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00445         1,    1,    1,    1,    1,    9,   20,   21,    9,  111,
00446        22,   20,   21,   20,   21,   22,   23,   22,  109,   24,
00447        49,   23,   25,   23,   24,   22,   24,   25,   26,   25,
00448        38,   22,   27,   26,   21,   26,   28,   27,   24,   27,
00449        37,   28,   32,   28,   39,   32,   36,   35,   34,   39,
00450        40,   39,   33,   27,   26,   40,   25,   40,   41,   42,
00451 
00452        31,   18,   14,   41,   42,   41,   42,   28,   28,   43,
00453        40,   41,   44,   45,   43,   13,   43,   44,   45,   44,
00454        45,   12,   46,    7,    6,    4,   47,   46,   42,   46,
00455        45,   47,   48,   47,    2,    0,    0,   48,   44,   48,
00456        43,   51,    0,   47,   52,    0,   51,   46,   51,   52,
00457         0,   52,   46,   53,   52,   47,   54,    0,   53,   55,
00458        53,   54,   48,   54,   55,   56,   55,    0,    0,    0,
00459        56,    0,   56,   51,   57,   58,   55,    0,   54,   57,
00460        58,   57,   58,   59,   56,    0,   53,   60,   59,    0,
00461        59,   61,   60,    0,   60,    0,   61,   62,   61,    0,
00462 
00463         0,   57,   62,    0,   62,   63,    0,   58,   60,    0,
00464        63,   64,   63,   63,   59,   65,   64,    0,   64,   61,
00465        65,   62,   65,   67,   66,    0,    0,   68,   67,   66,
00466        67,   66,   68,   64,   68,   70,   69,    0,    0,   71,
00467        70,   69,   70,   69,   71,   72,   71,    0,   65,   66,
00468        72,    0,   72,    0,   67,    0,   71,   70,   73,    0,
00469        68,   69,   74,   73,    0,   73,   72,   74,    0,   74,
00470        75,   76,    0,   74,    0,   75,   76,   75,   76,   73,
00471        77,   78,    0,    0,    0,   77,   78,   77,   78,   75,
00472        79,   80,   76,    0,   81,   79,   80,   79,   80,   81,
00473 
00474        82,   81,   77,   78,    0,   82,    0,   82,    0,   83,
00475        84,   79,   80,   81,   83,   84,   83,   84,    0,   85,
00476         0,    0,   86,   87,   85,   82,   85,   86,   87,   86,
00477        87,   88,   89,    0,    0,   83,   88,   89,   88,   89,
00478        90,   91,    0,   86,   92,   90,   91,   90,   91,   92,
00479        88,   92,   93,   94,    0,    0,   95,   93,   94,   93,
00480        94,   95,   96,   95,    0,   89,    0,   96,    0,   96,
00481        97,   98,   95,   94,   99,   97,   98,   97,   98,   99,
00482       100,   99,    0,  101,    0,  100,   99,  100,  101,  102,
00483       101,   97,  103,    0,  102,  104,  102,  103,  105,  103,
00484 
00485       104,  101,  104,  105,  106,  105,    0,    0,    0,  106,
00486         0,  106,  102,  103,  104,    0,    0,    0,    0,    0,
00487         0,    0,    0,    0,    0,    0,    0,    0,    0,  105,
00488       108,  108,  110,  110,  112,  112,  112,  107,  107,  107,
00489       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
00490       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
00491       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
00492       107,  107,  107,  107,  107,  107,  107,  107,  107,  107,
00493       107,  107,  107
00494     } ;
00495 
00496 static ace_yy_state_type ace_yy_last_accepting_state;
00497 static ACE_TCHAR *ace_yy_last_accepting_cpos;
00498 
00499 /* The intent behind this definition is that it'll catch
00500  * any uses of REJECT which flex missed.
00501  */
00502 #define REJECT reject_used_but_not_detected
00503 #define ace_yymore() ace_yymore_used_but_not_detected
00504 #define ACE_YY_MORE_ADJ 0
00505 #define ACE_YY_RESTORE_ACE_YY_MORE_OFFSET
00506 ACE_TCHAR *ace_yytext;
00507 #define INITIAL 0
00508 // $Id: Svc_Conf_l.cpp,v 1.1.1.4.2.1 2003/03/13 19:44:22 chad Exp $
00509 // Sample lexical analysis for regular expression subset.  Must be
00510 // compiled with FLEX and an ANSI C++ compiler.
00511 
00512 // Lexical tokens values defined by YACC.
00513 #include "ace/Svc_Conf.h"
00514 #include "ace/Svc_Conf_Tokens.h"
00515 #include "ace/Svc_Conf_Lexer_Guard.h"
00516 
00517 ACE_RCSID (ace,
00518            Svc_Conf_l,
00519            "$Id: Svc_Conf_l.cpp,v 1.1.1.4.2.1 2003/03/13 19:44:22 chad Exp $")
00520 
00521 #define token(x)  x
00522 #define PARAMETERS 1
00523 
00524 #define NORMAL 2
00525 
00526 
00527 /* Macros after this point can all be overridden by user definitions in
00528  * section 1.
00529  */
00530 
00531 #ifndef ACE_YY_SKIP_ACE_YYWRAP
00532 #ifdef __cplusplus
00533 extern "C" int ace_yywrap ACE_YY_PROTO(( void ));
00534 #else
00535 extern int ace_yywrap ACE_YY_PROTO(( void ));
00536 #endif
00537 #endif
00538 
00539 #ifndef ACE_YY_NO_UNPUT
00540 static void ace_yyunput ACE_YY_PROTO(( int c, ACE_TCHAR *buf_ptr ));
00541 #endif
00542 
00543 #ifndef ace_yytext_ptr
00544 static void ace_yy_flex_strncpy ACE_YY_PROTO(( ACE_TCHAR *, ace_yyconst ACE_TCHAR *, int ));
00545 #endif
00546 
00547 #ifdef ACE_YY_NEED_STRLEN
00548 static int ace_yy_flex_strlen ACE_YY_PROTO(( ace_yyconst ACE_TCHAR * ));
00549 #endif
00550 
00551 #ifndef ACE_YY_NO_INPUT
00552 #ifdef __cplusplus
00553 static int ace_yyinput ACE_YY_PROTO(( void ));
00554 #else
00555 static int input ACE_YY_PROTO(( void ));
00556 #endif
00557 #endif
00558 
00559 #if ACE_YY_STACK_USED
00560 static int ace_yy_start_stack_ptr = 0;
00561 static int ace_yy_start_stack_depth = 0;
00562 static int *ace_yy_start_stack = 0;
00563 #ifndef ACE_YY_NO_PUSH_STATE
00564 static void ace_yy_push_state ACE_YY_PROTO(( int new_state ));
00565 #endif
00566 #ifndef ACE_YY_NO_POP_STATE
00567 static void ace_yy_pop_state ACE_YY_PROTO(( void ));
00568 #endif
00569 #ifndef ACE_YY_NO_TOP_STATE
00570 static int ace_yy_top_state ACE_YY_PROTO(( void ));
00571 #endif
00572 
00573 #else
00574 #define ACE_YY_NO_PUSH_STATE 1
00575 #define ACE_YY_NO_POP_STATE 1
00576 #define ACE_YY_NO_TOP_STATE 1
00577 #endif
00578 
00579 #ifdef ACE_YY_MALLOC_DECL
00580 ACE_YY_MALLOC_DECL
00581 #else
00582 #if __STDC__
00583 #ifndef __cplusplus
00584 #include /**/ <stdlib.h>
00585 #endif
00586 #else
00587 /* Just try to get by without declaring the routines.  This will fail
00588  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
00589  * or sizeof(void*) != sizeof(int).
00590  */
00591 #endif
00592 #endif
00593 
00594 /* Amount of stuff to slurp up with each read. */
00595 #ifndef ACE_YY_READ_BUF_SIZE
00596 #define ACE_YY_READ_BUF_SIZE 8192
00597 #endif
00598 
00599 /* Copy whatever the last rule matched to the standard output. */
00600 
00601 #ifndef ACE_SVC_CONF_ECHO
00602 /* This used to be an fputs(), but since the string might contain NUL's,
00603  * we now use fwrite().
00604  */
00605 #define ACE_SVC_CONF_ECHO (void) fwrite( ace_yytext, ace_yyleng, 1, ace_yyout )
00606 #endif
00607 
00608 /* Gets input and stuffs it into "buf".  number of characters read, or ACE_YY_NULL,
00609  * is returned in "result".
00610  */
00611 #ifndef ACE_YY_INPUT
00612 #define ACE_YY_INPUT(buf,result,max_size) \
00613         if ( ace_yy_current_buffer->ace_yy_is_interactive ) \
00614                 { \
00615                 int c = '*', n; \
00616                 for ( n = 0; n < max_size && \
00617                              (c = getc( ace_yyin )) != EOF && c != '\n'; ++n ) \
00618                         buf[n] = (ACE_TCHAR) c; \
00619                 if ( c == '\n' ) \
00620                         buf[n++] = (ACE_TCHAR) c; \
00621                 if ( c == EOF && ferror( ace_yyin ) ) \
00622                         ACE_YY_FATAL_ERROR( ACE_LIB_TEXT ("input in flex scanner failed") ); \
00623                 result = n; \
00624                 } \
00625         else \
00626                 { \
00627                 errno=0; \
00628                 while ( (result = fread(buf, sizeof (ACE_TCHAR), max_size, ace_yyin))==0 && ferror(ace_yyin)) \
00629                         { \
00630                         if( errno != EINTR) \
00631                                 { \
00632                                 ACE_YY_FATAL_ERROR( ACE_LIB_TEXT ("input in flex scanner failed") ); \
00633                                 break; \
00634                                 } \
00635                         errno=0; \
00636                         clearerr(ace_yyin); \
00637                         } \
00638                 }
00639 #endif
00640 
00641 /* No semi-colon after return; correct usage is to write "ace_yyterminate();" -
00642  * we don't want an extra ';' after the "return" because that will cause
00643  * some compilers to complain about unreachable statements.
00644  */
00645 #ifndef ace_yyterminate
00646 #define ace_yyterminate() return ACE_YY_NULL
00647 #endif
00648 
00649 /* Number of entries by which start-condition stack grows. */
00650 #ifndef ACE_YY_START_STACK_INCR
00651 #define ACE_YY_START_STACK_INCR 25
00652 #endif
00653 
00654 /* Report a fatal error. */
00655 #ifndef ACE_YY_FATAL_ERROR
00656 #define ACE_YY_FATAL_ERROR(msg) ace_yy_fatal_error( msg )
00657 #endif
00658 
00659 /* Default declaration of generated scanner - a define so the user can
00660  * easily add parameters.
00661  */
00662 #ifndef ACE_YY_DECL
00663 #define ACE_YY_DECL int ace_yylex ACE_YY_PROTO(( void ))
00664 #endif
00665 
00666 /* Code executed at the beginning of each rule, after ace_yytext and ace_yyleng
00667  * have been set up.
00668  */
00669 #ifndef ACE_YY_USER_ACTION
00670 #define ACE_YY_USER_ACTION
00671 #endif
00672 
00673 /* Code executed at the end of each rule. */
00674 #ifndef ACE_YY_BREAK
00675 #define ACE_YY_BREAK break;
00676 #endif
00677 
00678 #define ACE_YY_RULE_SETUP \
00679         if ( ace_yyleng > 0 ) \
00680                 ace_yy_current_buffer->ace_yy_at_bol = \
00681                                 (ace_yytext[ace_yyleng - 1] == '\n'); \
00682         ACE_YY_USER_ACTION
00683 
00684 ACE_YY_DECL
00685         {
00686         register ace_yy_state_type ace_yy_current_state;
00687         register ACE_TCHAR *ace_yy_cp=0, *ace_yy_bp=0;
00688         register int ace_yy_act;
00689 
00690         ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX,
00691                                   ace_mon,
00692                                   *ACE_Static_Object_Lock::instance (),
00693                                   -1));
00694 
00695         ACE_Svc_Conf_Lexer_Guard ace_lexer_guard (ACE_SVC_CONF_PARAM);
00696 
00697         if ( ace_yy_init )
00698                 {
00699                 ace_yy_init = 0;
00700 
00701 #ifdef ACE_YY_USER_INIT
00702                 ACE_YY_USER_INIT;
00703 #endif
00704 
00705                 if ( ! ace_yy_start )
00706                         ace_yy_start = 1;       /* first start state */
00707 
00708                 if ( ! ace_yyin )
00709                         ace_yyin = stdin;
00710 
00711                 if ( ! ace_yyout )
00712                         ace_yyout = stdout;
00713 
00714                 if ( ! ace_yy_current_buffer )
00715                         ace_yy_current_buffer =
00716                                 ace_yy_create_buffer( ace_yyin, ACE_YY_BUF_SIZE );
00717 
00718                 ace_yy_load_buffer_state();
00719                 }
00720 
00721         while ( 1 )             /* loops until end-of-file is reached */
00722                 {
00723                 ace_yy_cp = ace_yy_c_buf_p;
00724 
00725                 /* Support of ace_yytext. */
00726                 *ace_yy_cp = ace_yy_hold_char;
00727 
00728                 /* ace_yy_bp points to the position in ace_yy_ch_buf of the start of
00729                  * the current run.
00730                  */
00731                 ace_yy_bp = ace_yy_cp;
00732 
00733                 ace_yy_current_state = ace_yy_start;
00734                 ace_yy_current_state += ACE_YY_AT_BOL();
00735 ace_yy_match:
00736                 do
00737                         {
00738                         register ACE_YY_CHAR ace_yy_c = ace_yy_ec[ACE_YY_SC_TO_UI(*ace_yy_cp)];
00739                         if ( ace_yy_accept[ace_yy_current_state] )
00740                                 {
00741                                 ace_yy_last_accepting_state = ace_yy_current_state;
00742                                 ace_yy_last_accepting_cpos = ace_yy_cp;
00743                                 }
00744                         while ( ace_yy_chk[ace_yy_base[ace_yy_current_state] + ace_yy_c] != ace_yy_current_state )
00745                                 {
00746                                 ace_yy_current_state = (int) ace_yy_def[ace_yy_current_state];
00747                                 if ( ace_yy_current_state >= 108 )
00748                                         ace_yy_c = ace_yy_meta[(unsigned int) ace_yy_c];
00749                                 }
00750                         ace_yy_current_state = ace_yy_nxt[ace_yy_base[ace_yy_current_state] + (unsigned int) ace_yy_c];
00751                         ++ace_yy_cp;
00752                         }
00753                 while ( ace_yy_base[ace_yy_current_state] != 438 );
00754 
00755 ace_yy_find_action:
00756                 ace_yy_act = ace_yy_accept[ace_yy_current_state];
00757                 if ( ace_yy_act == 0 )
00758                         { /* have to back up */
00759                         ace_yy_cp = ace_yy_last_accepting_cpos;
00760                         ace_yy_current_state = ace_yy_last_accepting_state;
00761                         ace_yy_act = ace_yy_accept[ace_yy_current_state];
00762                         }
00763 
00764                 ACE_YY_DO_BEFORE_ACTION;
00765 
00766 
00767 do_action:      /* This label is used only to access EOF actions. */
00768 
00769 
00770                 switch ( ace_yy_act )
00771         { /* beginning of action switch */
00772                         case 0: /* must back up */
00773                         /* undo the effects of ACE_YY_DO_BEFORE_ACTION */
00774                         *ace_yy_cp = ace_yy_hold_char;
00775                         ace_yy_cp = ace_yy_last_accepting_cpos;
00776                         ace_yy_current_state = ace_yy_last_accepting_state;
00777                         goto ace_yy_find_action;
00778 
00779 case 1:
00780 *ace_yy_cp = ace_yy_hold_char; /* undo effects of setting up ace_yytext */
00781 ace_yy_c_buf_p = ace_yy_cp -= 1;
00782 ACE_YY_DO_BEFORE_ACTION; /* set up ace_yytext again */
00783 ACE_YY_RULE_SETUP
00784 ; /* EMPTY */
00785         ACE_YY_BREAK
00786 case 2:
00787 ACE_YY_RULE_SETUP
00788 { return token (ACE_DYNAMIC); }
00789         //      ACE_YY_BREAK
00790 case 3:
00791 ACE_YY_RULE_SETUP
00792 { return token (ACE_STATIC); }
00793         //      ACE_YY_BREAK
00794 case 4:
00795 ACE_YY_RULE_SETUP
00796 { return token (ACE_SUSPEND); }
00797         //      ACE_YY_BREAK
00798 case 5:
00799 ACE_YY_RULE_SETUP
00800 { return token (ACE_RESUME); }
00801         //      ACE_YY_BREAK
00802 case 6:
00803 ACE_YY_RULE_SETUP
00804 { return token (ACE_REMOVE); }
00805         //      ACE_YY_BREAK
00806 case 7:
00807 ACE_YY_RULE_SETUP
00808 { return token (ACE_USTREAM); }
00809         //      ACE_YY_BREAK
00810 case 8:
00811 ACE_YY_RULE_SETUP
00812 { return token (ACE_MODULE_T); }
00813         //      ACE_YY_BREAK
00814 case 9:
00815 ACE_YY_RULE_SETUP
00816 { return token (ACE_SVC_OBJ_T); }
00817         //      ACE_YY_BREAK
00818 case 10:
00819 ACE_YY_RULE_SETUP
00820 { return token (ACE_STREAM_T); }
00821         //      ACE_YY_BREAK
00822 case 11:
00823 ACE_YY_RULE_SETUP
00824 { return token (ACE_ACTIVE); }
00825         //      ACE_YY_BREAK
00826 case 12:
00827 ACE_YY_RULE_SETUP
00828 { return token (ACE_INACTIVE); }
00829         //      ACE_YY_BREAK
00830 case 13:
00831 ACE_YY_RULE_SETUP
00832 { return token (':'); }
00833         //      ACE_YY_BREAK
00834 case 14:
00835 ACE_YY_RULE_SETUP
00836 { return token ('*'); }
00837         //      ACE_YY_BREAK
00838 case 15:
00839 ACE_YY_RULE_SETUP
00840 { return token ('('); }
00841         //      ACE_YY_BREAK
00842 case 16:
00843 ACE_YY_RULE_SETUP
00844 { return token (')'); }
00845         //      ACE_YY_BREAK
00846 case 17:
00847 ACE_YY_RULE_SETUP
00848 { return token ('{'); }
00849         //      ACE_YY_BREAK
00850 case 18:
00851 ACE_YY_RULE_SETUP
00852 { return token ('}'); }
00853         //      ACE_YY_BREAK
00854 case 19:
00855 ACE_YY_RULE_SETUP
00856 {
00857                         // Remove tailaing quote character (' or ")
00858                         ACE_TCHAR *s = ACE_OS::strrchr (ace_yytext, ace_yytext[0]);
00859 
00860                         ACE_ASSERT (s != 0);
00861                         // Eliminate the opening and closing double or
00862                         // single quotes.
00863                         *s = '\0';
00864                         ace_yyleng -= 1;
00865                         ace_yylval->ident_ = ACE_SVC_CONF_PARAM->obstack.copy (ace_yytext + 1, ace_yyleng);
00866                         return token (ACE_STRING); }
00867 //      ACE_YY_BREAK
00868 case 20:
00869 ACE_YY_RULE_SETUP
00870 {
00871                         ace_yylval->ident_ = ACE_SVC_CONF_PARAM->obstack.copy (ace_yytext, ace_yyleng);
00872                         return token (ACE_IDENT);
00873                       }
00874 //      ACE_YY_BREAK
00875 case 21:
00876 ACE_YY_RULE_SETUP
00877 {
00878                         ace_yylval->ident_ = ACE_SVC_CONF_PARAM->obstack.copy (ace_yytext, ace_yyleng);
00879                         return token (ACE_PATHNAME);
00880                       }
00881 //      ACE_YY_BREAK
00882 case 22:
00883 ACE_YY_RULE_SETUP
00884 ; /* EMPTY */
00885         ACE_YY_BREAK
00886 case 23:
00887 ACE_YY_RULE_SETUP
00888 ; /* EMPTY */
00889         ACE_YY_BREAK
00890 case 24:
00891 ACE_YY_RULE_SETUP
00892 { ACE_SVC_CONF_PARAM->yylineno++; }
00893         ACE_YY_BREAK
00894 case 25:
00895 ACE_YY_RULE_SETUP
00896 {
00897                          ACE_ERROR ((LM_ERROR,
00898                                      ACE_LIB_TEXT ("unknown character = (%d"),
00899                                                    *ace_yytext));
00900                         if (ACE_OS::ace_isprint (*ace_yytext))
00901                           ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("|%c"), *ace_yytext));
00902                         ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT (")\n")));
00903                       }
00904         ACE_YY_BREAK
00905 case ACE_YY_STATE_EOF(INITIAL):
00906 case ACE_YY_STATE_EOF(PARAMETERS):
00907 case ACE_YY_STATE_EOF(NORMAL):
00908 { ace_yyterminate (); }
00909         ACE_YY_BREAK
00910 case 26:
00911 ACE_YY_RULE_SETUP
00912 ACE_SVC_CONF_ECHO;
00913         ACE_YY_BREAK
00914 
00915         case ACE_YY_END_OF_BUFFER:
00916                 {
00917                 /* Amount of text matched not including the EOB ACE_TCHAR. */
00918                 int ace_yy_amount_of_matched_text = (int) (ace_yy_cp - ace_yytext_ptr) - 1;
00919 
00920                 /* Undo the effects of ACE_YY_DO_BEFORE_ACTION. */
00921                 *ace_yy_cp = ace_yy_hold_char;
00922                 ACE_YY_RESTORE_ACE_YY_MORE_OFFSET
00923 
00924                 if ( ace_yy_current_buffer->ace_yy_buffer_status == ACE_YY_BUFFER_NEW )
00925                         {
00926                         /* We're scanning a new file or input source.  It's
00927                          * possible that this happened because the user
00928                          * just pointed ace_yyin at a new source and called
00929                          * ace_yylex().  If so, then we have to assure
00930                          * consistency between ace_yy_current_buffer and our
00931                          * globals.  Here is the right place to do so, because
00932                          * this is the first action (other than possibly a
00933                          * back-up) that will match for the new input source.
00934                          */
00935                         ace_yy_n_chars = ace_yy_current_buffer->ace_yy_n_chars;
00936                         ace_yy_current_buffer->ace_yy_input_file = ace_yyin;
00937                         ace_yy_current_buffer->ace_yy_buffer_status = ACE_YY_BUFFER_NORMAL;
00938                         }
00939 
00940                 /* Note that here we test for ace_yy_c_buf_p "<=" to the position
00941                  * of the first EOB in the buffer, since ace_yy_c_buf_p will
00942                  * already have been incremented past the NUL character
00943                  * (since all states make transitions on EOB to the
00944                  * end-of-buffer state).  Contrast this with the test
00945                  * in input().
00946                  */
00947                 if ( ace_yy_c_buf_p <= &ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars] )
00948                         { /* This was really a NUL. */
00949                         ace_yy_state_type ace_yy_next_state;
00950 
00951                         ace_yy_c_buf_p = ace_yytext_ptr + ace_yy_amount_of_matched_text;
00952 
00953                         ace_yy_current_state = ace_yy_get_previous_state();
00954 
00955                         /* Okay, we're now positioned to make the NUL
00956                          * transition.  We couldn't have
00957                          * ace_yy_get_previous_state() go ahead and do it
00958                          * for us because it doesn't know how to deal
00959                          * with the possibility of jamming (and we don't
00960                          * want to build jamming into it because then it
00961                          * will run more slowly).
00962                          */
00963 
00964                         ace_yy_next_state = ace_yy_try_NUL_trans( ace_yy_current_state );
00965 
00966                         ace_yy_bp = ace_yytext_ptr + ACE_YY_MORE_ADJ;
00967 
00968                         if ( ace_yy_next_state )
00969                                 {
00970                                 /* Consume the NUL. */
00971                                 ace_yy_cp = ++ace_yy_c_buf_p;
00972                                 ace_yy_current_state = ace_yy_next_state;
00973                                 goto ace_yy_match;
00974                                 }
00975 
00976                         else
00977                                 {
00978                                 ace_yy_cp = ace_yy_c_buf_p;
00979                                 goto ace_yy_find_action;
00980                                 }
00981                         }
00982 
00983                 else switch ( ace_yy_get_next_buffer() )
00984                         {
00985                         case EOB_ACT_END_OF_FILE:
00986                                 {
00987                                 ace_yy_did_buffer_switch_on_eof = 0;
00988 
00989                                 if ( ace_yywrap() )
00990                                         {
00991                                         /* Note: because we've taken care in
00992                                          * ace_yy_get_next_buffer() to have set up
00993                                          * ace_yytext, we can now set up
00994                                          * ace_yy_c_buf_p so that if some total
00995                                          * hoser (like flex itself) wants to
00996                                          * call the scanner after we return the
00997                                          * ACE_YY_NULL, it'll still work - another
00998                                          * ACE_YY_NULL will get returned.
00999                                          */
01000                                         ace_yy_c_buf_p = ace_yytext_ptr + ACE_YY_MORE_ADJ;
01001 
01002                                         ace_yy_act = ACE_YY_STATE_EOF(ACE_YY_START);
01003                                         goto do_action;
01004                                         }
01005 
01006                                 else
01007                                         {
01008                                         if ( ! ace_yy_did_buffer_switch_on_eof )
01009                                                 ACE_YY_NEW_FILE;
01010                                         }
01011                                 break;
01012                                 }
01013 
01014                         case EOB_ACT_CONTINUE_SCAN:
01015                                 ace_yy_c_buf_p =
01016                                         ace_yytext_ptr + ace_yy_amount_of_matched_text;
01017 
01018                                 ace_yy_current_state = ace_yy_get_previous_state();
01019 
01020                                 ace_yy_cp = ace_yy_c_buf_p;
01021                                 ace_yy_bp = ace_yytext_ptr + ACE_YY_MORE_ADJ;
01022                                 goto ace_yy_match;
01023 
01024                         case EOB_ACT_LAST_MATCH:
01025                                 ace_yy_c_buf_p =
01026                                 &ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars];
01027 
01028                                 ace_yy_current_state = ace_yy_get_previous_state();
01029 
01030                                 ace_yy_cp = ace_yy_c_buf_p;
01031                                 ace_yy_bp = ace_yytext_ptr + ACE_YY_MORE_ADJ;
01032                                 goto ace_yy_find_action;
01033                         }
01034                 break;
01035                 }
01036 
01037         default:
01038                 ACE_YY_FATAL_ERROR(
01039                         ACE_LIB_TEXT("fatal flex scanner internal error--no action found") );
01040         } /* end of action switch */
01041                 } /* end of scanning one token */
01042         } /* end of ace_yylex */
01043 
01044 
01045 /* ace_yy_get_next_buffer - try to read in a new buffer
01046  *
01047  * Returns a code representing an action:
01048  *      EOB_ACT_LAST_MATCH -
01049  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
01050  *      EOB_ACT_END_OF_FILE - end of file
01051  */
01052 
01053 static int ace_yy_get_next_buffer()
01054         {
01055         register ACE_TCHAR *dest = ace_yy_current_buffer->ace_yy_ch_buf;
01056         register ACE_TCHAR *source = ace_yytext_ptr;
01057         register int number_to_move, i;
01058         int ret_val;
01059 
01060         if ( ace_yy_c_buf_p > &ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars + 1] )
01061                 ACE_YY_FATAL_ERROR(
01062                 ACE_LIB_TEXT("fatal flex scanner internal error--end of buffer missed") );
01063 
01064         if ( ace_yy_current_buffer->ace_yy_fill_buffer == 0 )
01065                 { /* Don't try to fill the buffer, so this is an EOF. */
01066                 if ( ace_yy_c_buf_p - ace_yytext_ptr - ACE_YY_MORE_ADJ == 1 )
01067                         {
01068                         /* We matched a single character, the EOB, so
01069                          * treat this as a final EOF.
01070                          */
01071                         return EOB_ACT_END_OF_FILE;
01072                         }
01073 
01074                 else
01075                         {
01076                         /* We matched some text prior to the EOB, first
01077                          * process it.
01078                          */
01079                         return EOB_ACT_LAST_MATCH;
01080                         }
01081                 }
01082 
01083         /* Try to read more data. */
01084 
01085         /* First move last chars to start of buffer. */
01086         number_to_move = (int) (ace_yy_c_buf_p - ace_yytext_ptr) - 1;
01087 
01088         for ( i = 0; i < number_to_move; ++i )
01089                 *(dest++) = *(source++);
01090 
01091         if ( ace_yy_current_buffer->ace_yy_buffer_status == ACE_YY_BUFFER_EOF_PENDING )
01092                 /* don't do the read, it's not guaranteed to return an EOF,
01093                  * just force an EOF
01094                  */
01095                 ace_yy_current_buffer->ace_yy_n_chars = ace_yy_n_chars = 0;
01096 
01097         else
01098                 {
01099                 int num_to_read =
01100                         ace_yy_current_buffer->ace_yy_buf_size - number_to_move - 1;
01101 
01102                 while ( num_to_read <= 0 )
01103                         { /* Not enough room in the buffer - grow it. */
01104 #ifdef ACE_YY_USES_REJECT
01105                           ACE_YY_FATAL_ERROR(ACE_LIB_TEXT(
01106 "input buffer overflow, can't enlarge buffer because scanner uses REJECT") );
01107 #else
01108 
01109                         /* just a shorter name for the current buffer */
01110                         ACE_YY_BUFFER_STATE b = ace_yy_current_buffer;
01111 
01112                         int ace_yy_c_buf_p_offset =
01113                                 (int) (ace_yy_c_buf_p - b->ace_yy_ch_buf);
01114 
01115                         if ( b->ace_yy_is_our_buffer )
01116                                 {
01117                                 int new_size = b->ace_yy_buf_size * 2;
01118 
01119                                 if ( new_size <= 0 )
01120                                         b->ace_yy_buf_size += b->ace_yy_buf_size / 8;
01121                                 else
01122                                         b->ace_yy_buf_size *= 2;
01123 
01124                                 b->ace_yy_ch_buf = (ACE_TCHAR *)
01125                                         /* Include room in for 2 EOB chars. */
01126                                         ace_yy_flex_realloc( (void *) b->ace_yy_ch_buf,
01127                                                       (b->ace_yy_buf_size + 2)*sizeof(ACE_TCHAR));
01128                                 }
01129                         else
01130                                 /* Can't grow it, we don't own it. */
01131                                 b->ace_yy_ch_buf = 0;
01132 
01133                         if ( ! b->ace_yy_ch_buf )
01134                           ACE_YY_FATAL_ERROR(ACE_LIB_TEXT(
01135                                 "fatal error - scanner input buffer overflow") );
01136 
01137                         ace_yy_c_buf_p = &b->ace_yy_ch_buf[ace_yy_c_buf_p_offset];
01138 
01139                         num_to_read = ace_yy_current_buffer->ace_yy_buf_size -
01140                                                 number_to_move - 1;
01141 #endif
01142                         }
01143 
01144                 if ( num_to_read * sizeof (ACE_TCHAR) > ACE_YY_READ_BUF_SIZE )
01145                         num_to_read = ACE_YY_READ_BUF_SIZE/sizeof (ACE_TCHAR);
01146 
01147                 /* Read in more data. */
01148                 ACE_YY_INPUT( (&ace_yy_current_buffer->ace_yy_ch_buf[number_to_move]),
01149                         ace_yy_n_chars, num_to_read );
01150 
01151                 ace_yy_current_buffer->ace_yy_n_chars = ace_yy_n_chars;
01152                 }
01153 
01154         if ( ace_yy_n_chars == 0 )
01155                 {
01156                 if ( number_to_move == ACE_YY_MORE_ADJ )
01157                         {
01158                         ret_val = EOB_ACT_END_OF_FILE;
01159                         ace_yyrestart( ace_yyin );
01160                         }
01161 
01162                 else
01163                         {
01164                         ret_val = EOB_ACT_LAST_MATCH;
01165                         ace_yy_current_buffer->ace_yy_buffer_status =
01166                                 ACE_YY_BUFFER_EOF_PENDING;
01167                         }
01168                 }
01169 
01170         else
01171                 ret_val = EOB_ACT_CONTINUE_SCAN;
01172 
01173         ace_yy_n_chars += number_to_move;
01174         ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars] = ACE_YY_END_OF_BUFFER_CHAR;
01175         ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars + 1] = ACE_YY_END_OF_BUFFER_CHAR;
01176 
01177         ace_yytext_ptr = &ace_yy_current_buffer->ace_yy_ch_buf[0];
01178 
01179         return ret_val;
01180         }
01181 
01182 
01183 /* ace_yy_get_previous_state - get the state just before the EOB ACE_TCHAR was reached */
01184 
01185 static ace_yy_state_type ace_yy_get_previous_state()
01186         {
01187         register ace_yy_state_type ace_yy_current_state;
01188         register ACE_TCHAR *ace_yy_cp;
01189 
01190         ace_yy_current_state = ace_yy_start;
01191         ace_yy_current_state += ACE_YY_AT_BOL();
01192 
01193         for ( ace_yy_cp = ace_yytext_ptr + ACE_YY_MORE_ADJ; ace_yy_cp < ace_yy_c_buf_p; ++ace_yy_cp )
01194                 {
01195                 register ACE_YY_CHAR ace_yy_c = (*ace_yy_cp ? ace_yy_ec[ACE_YY_SC_TO_UI(*ace_yy_cp)] : 1);
01196                 if ( ace_yy_accept[ace_yy_current_state] )
01197                         {
01198                         ace_yy_last_accepting_state = ace_yy_current_state;
01199                         ace_yy_last_accepting_cpos = ace_yy_cp;
01200                         }
01201                 while ( ace_yy_chk[ace_yy_base[ace_yy_current_state] + ace_yy_c] != ace_yy_current_state )
01202                         {
01203                         ace_yy_current_state = (int) ace_yy_def[ace_yy_current_state];
01204                         if ( ace_yy_current_state >= 108 )
01205                                 ace_yy_c = ace_yy_meta[(unsigned int) ace_yy_c];
01206                         }
01207                 ace_yy_current_state = ace_yy_nxt[ace_yy_base[ace_yy_current_state] + (unsigned int) ace_yy_c];
01208                 }
01209 
01210         return ace_yy_current_state;
01211         }
01212 
01213 
01214 /* ace_yy_try_NUL_trans - try to make a transition on the NUL character
01215  *
01216  * synopsis
01217  *      next_state = ace_yy_try_NUL_trans( current_state );
01218  */
01219 
01220 #ifdef ACE_YY_USE_PROTOS
01221 static ace_yy_state_type ace_yy_try_NUL_trans( ace_yy_state_type ace_yy_current_state )
01222 #else
01223 static ace_yy_state_type ace_yy_try_NUL_trans( ace_yy_current_state )
01224 ace_yy_state_type ace_yy_current_state;
01225 #endif
01226         {
01227         register int ace_yy_is_jam;
01228         register ACE_TCHAR *ace_yy_cp = ace_yy_c_buf_p;
01229 
01230         register ACE_YY_CHAR ace_yy_c = 1;
01231         if ( ace_yy_accept[ace_yy_current_state] )
01232                 {
01233                 ace_yy_last_accepting_state = ace_yy_current_state;
01234                 ace_yy_last_accepting_cpos = ace_yy_cp;
01235                 }
01236         while ( ace_yy_chk[ace_yy_base[ace_yy_current_state] + ace_yy_c] != ace_yy_current_state )
01237                 {
01238                 ace_yy_current_state = (int) ace_yy_def[ace_yy_current_state];
01239                 if ( ace_yy_current_state >= 108 )
01240                         ace_yy_c = ace_yy_meta[(unsigned int) ace_yy_c];
01241                 }
01242         ace_yy_current_state = ace_yy_nxt[ace_yy_base[ace_yy_current_state] + (unsigned int) ace_yy_c];
01243         ace_yy_is_jam = (ace_yy_current_state == 107);
01244 
01245         return ace_yy_is_jam ? 0 : ace_yy_current_state;
01246         }
01247 
01248 
01249 #ifndef ACE_YY_NO_UNPUT
01250 #ifdef ACE_YY_USE_PROTOS
01251 static void ace_yyunput( int c, register ACE_TCHAR *ace_yy_bp )
01252 #else
01253 static void ace_yyunput( c, ace_yy_bp )
01254 int c;
01255 register ACE_TCHAR *ace_yy_bp;
01256 #endif
01257         {
01258         register ACE_TCHAR *ace_yy_cp = ace_yy_c_buf_p;
01259 
01260         /* undo effects of setting up ace_yytext */
01261         *ace_yy_cp = ace_yy_hold_char;
01262 
01263         if ( ace_yy_cp < ace_yy_current_buffer->ace_yy_ch_buf + 2 )
01264                 { /* need to shift things up to make room */
01265                 /* +2 for EOB chars. */
01266                 register int number_to_move = ace_yy_n_chars + 2;
01267                 register ACE_TCHAR *dest = &ace_yy_current_buffer->ace_yy_ch_buf[
01268                                         ace_yy_current_buffer->ace_yy_buf_size + 2];
01269                 register ACE_TCHAR *source =
01270                                 &ace_yy_current_buffer->ace_yy_ch_buf[number_to_move];
01271 
01272                 while ( source > ace_yy_current_buffer->ace_yy_ch_buf )
01273                         *--dest = *--source;
01274 
01275                 ace_yy_cp += (int) (dest - source);
01276                 ace_yy_bp += (int) (dest - source);
01277                 ace_yy_current_buffer->ace_yy_n_chars =
01278                         ace_yy_n_chars = ace_yy_current_buffer->ace_yy_buf_size;
01279 
01280                 if ( ace_yy_cp < ace_yy_current_buffer->ace_yy_ch_buf + 2 )
01281                         ACE_YY_FATAL_ERROR(ACE_LIB_TEXT( "flex scanner push-back overflow") );
01282                 }
01283 
01284         *--ace_yy_cp = (ACE_TCHAR) c;
01285 
01286 
01287         ace_yytext_ptr = ace_yy_bp;
01288         ace_yy_hold_char = *ace_yy_cp;
01289         ace_yy_c_buf_p = ace_yy_cp;
01290         }
01291 #endif  /* ifndef ACE_YY_NO_UNPUT */
01292 
01293 
01294 #ifdef __cplusplus
01295 static int ace_yyinput()
01296 #else
01297 static int input()
01298 #endif
01299         {
01300         int c;
01301 
01302         *ace_yy_c_buf_p = ace_yy_hold_char;
01303 
01304         if ( *ace_yy_c_buf_p == ACE_YY_END_OF_BUFFER_CHAR )
01305                 {
01306                 /* ace_yy_c_buf_p now points to the character we want to return.
01307                  * If this occurs *before* the EOB characters, then it's a
01308                  * valid NUL; if not, then we've hit the end of the buffer.
01309                  */
01310                 if ( ace_yy_c_buf_p < &ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars] )
01311                         /* This was really a NUL. */
01312                         *ace_yy_c_buf_p = '\0';
01313 
01314                 else
01315                         { /* need more input */
01316                         int offset = ace_yy_c_buf_p - ace_yytext_ptr;
01317                         ++ace_yy_c_buf_p;
01318 
01319                         switch ( ace_yy_get_next_buffer() )
01320                                 {
01321                                 case EOB_ACT_LAST_MATCH:
01322                                         /* This happens because ace_yy_g_n_b()
01323                                          * sees that we've accumulated a
01324                                          * token and flags that we need to
01325                                          * try matching the token before
01326                                          * proceeding.  But for input(),
01327                                          * there's no matching to consider.
01328                                          * So convert the EOB_ACT_LAST_MATCH
01329                                          * to EOB_ACT_END_OF_FILE.
01330                                          */
01331 
01332                                         /* Reset buffer status. */
01333                                         ace_yyrestart( ace_yyin );
01334 
01335                                         /* fall through */
01336 
01337                                 case EOB_ACT_END_OF_FILE:
01338                                         {
01339                                         if ( ace_yywrap() )
01340                                                 return EOF;
01341 
01342                                         if ( ! ace_yy_did_buffer_switch_on_eof )
01343                                                 ACE_YY_NEW_FILE;
01344 #ifdef __cplusplus
01345                                         return ace_yyinput();
01346 #else
01347                                         return input();
01348 #endif
01349                                         }
01350 
01351                                 case EOB_ACT_CONTINUE_SCAN:
01352                                         ace_yy_c_buf_p = ace_yytext_ptr + offset;
01353                                         break;
01354                                 }
01355                         }
01356                 }
01357 
01358         c = *(unsigned char *) ace_yy_c_buf_p;  /* cast for 8-bit char's */
01359         *ace_yy_c_buf_p = '\0'; /* preserve ace_yytext */
01360         ace_yy_hold_char = *++ace_yy_c_buf_p;
01361 
01362         ace_yy_current_buffer->ace_yy_at_bol = (c == '\n');
01363 
01364         return c;
01365         }
01366 
01367 
01368 #ifdef ACE_YY_USE_PROTOS
01369 void ace_yyrestart( FILE *input_file )
01370 #else
01371 void ace_yyrestart( input_file )
01372 FILE *input_file;
01373 #endif
01374         {
01375         if ( ! ace_yy_current_buffer )
01376                 ace_yy_current_buffer = ace_yy_create_buffer( ace_yyin, ACE_YY_BUF_SIZE );
01377 
01378         ace_yy_init_buffer( ace_yy_current_buffer, input_file );
01379         ace_yy_load_buffer_state();
01380         }
01381 
01382 
01383 #ifdef ACE_YY_USE_PROTOS
01384 void ace_yy_switch_to_buffer( ACE_YY_BUFFER_STATE new_buffer )
01385 #else
01386 void ace_yy_switch_to_buffer( new_buffer )
01387 ACE_YY_BUFFER_STATE new_buffer;
01388 #endif
01389         {
01390         if ( ace_yy_current_buffer == new_buffer )
01391                 return;
01392 
01393         if ( ace_yy_current_buffer )
01394                 {
01395                 /* Flush out information for old buffer. */
01396                 *ace_yy_c_buf_p = ace_yy_hold_char;
01397                 ace_yy_current_buffer->ace_yy_buf_pos = ace_yy_c_buf_p;
01398                 ace_yy_current_buffer->ace_yy_n_chars = ace_yy_n_chars;
01399                 }
01400 
01401         ace_yy_current_buffer = new_buffer;
01402         ace_yy_load_buffer_state();
01403 
01404         /* We don't actually know whether we did this switch during
01405          * EOF (ace_yywrap()) processing, but the only time this flag
01406          * is looked at is after ace_yywrap() is called, so it's safe
01407          * to go ahead and always set it.
01408          */
01409         ace_yy_did_buffer_switch_on_eof = 1;
01410         }
01411 
01412 
01413 #ifdef ACE_YY_USE_PROTOS
01414 void ace_yy_load_buffer_state( void )
01415 #else
01416 void ace_yy_load_buffer_state()
01417 #endif
01418         {
01419         ace_yy_n_chars = ace_yy_current_buffer->ace_yy_n_chars;
01420         ace_yytext_ptr = ace_yy_c_buf_p = ace_yy_current_buffer->ace_yy_buf_pos;
01421         ace_yyin = ace_yy_current_buffer->ace_yy_input_file;
01422         ace_yy_hold_char = *ace_yy_c_buf_p;
01423         }
01424 
01425 
01426 #ifdef ACE_YY_USE_PROTOS
01427 ACE_YY_BUFFER_STATE ace_yy_create_buffer( FILE *file, int size )
01428 #else
01429 ACE_YY_BUFFER_STATE ace_yy_create_buffer( file, size )
01430 FILE *file;
01431 int size;
01432 #endif
01433         {
01434         ACE_YY_BUFFER_STATE b;
01435 
01436         b = (ACE_YY_BUFFER_STATE) ace_yy_flex_alloc( sizeof( struct ace_yy_buffer_state ) );
01437         if ( ! b )
01438                 ACE_YY_FATAL_ERROR(ACE_LIB_TEXT( "out of dynamic memory in ace_yy_create_buffer()") );
01439 
01440         b->ace_yy_buf_size = size;
01441 
01442         /* ace_yy_ch_buf has to be 2 characters longer than the size given because
01443          * we need to put in 2 end-of-buffer characters.
01444          */
01445         b->ace_yy_ch_buf = (ACE_TCHAR *) ace_yy_flex_alloc( (b->ace_yy_buf_size + 2 ) * sizeof (ACE_TCHAR));
01446         if ( ! b->ace_yy_ch_buf )
01447                 ACE_YY_FATAL_ERROR(ACE_LIB_TEXT( "out of dynamic memory in ace_yy_create_buffer()") );
01448 
01449         b->ace_yy_is_our_buffer = 1;
01450 
01451         ace_yy_init_buffer( b, file );
01452 
01453         return b;
01454         }
01455 
01456 
01457 #ifdef ACE_YY_USE_PROTOS
01458 void ace_yy_delete_buffer( ACE_YY_BUFFER_STATE b )
01459 #else
01460 void ace_yy_delete_buffer( b )
01461 ACE_YY_BUFFER_STATE b;
01462 #endif
01463         {
01464         if ( ! b )
01465                 return;
01466 
01467         if ( b == ace_yy_current_buffer )
01468                 ace_yy_current_buffer = (ACE_YY_BUFFER_STATE) 0;
01469 
01470         if ( b->ace_yy_is_our_buffer )
01471                 ace_yy_flex_free( (void *) b->ace_yy_ch_buf );
01472 
01473         ace_yy_flex_free( (void *) b );
01474         }
01475 
01476 #ifndef ACE_YY_ALWAYS_INTERACTIVE
01477 #ifndef ACE_YY_NEVER_INTERACTIVE
01478 extern int nop_isatty ACE_YY_PROTO(( int ));
01479 #endif
01480 #endif
01481 
01482 #ifndef ACE_YY_ALWAYS_INTERACTIVE
01483 #ifndef ACE_YY_NEVER_INTERACTIVE
01484 extern int nop_isatty ACE_YY_PROTO(( int ));
01485 #endif
01486 #endif
01487 
01488 #ifdef ACE_YY_USE_PROTOS
01489 void ace_yy_init_buffer( ACE_YY_BUFFER_STATE b, FILE *file )
01490 #else
01491 void ace_yy_init_buffer( b, file )
01492 ACE_YY_BUFFER_STATE b;
01493 FILE *file;
01494 #endif
01495 
01496 
01497         {
01498         ace_yy_flush_buffer( b );
01499 
01500         b->ace_yy_input_file = file;
01501         b->ace_yy_fill_buffer = 1;
01502 
01503 #if ACE_YY_ALWAYS_INTERACTIVE
01504         b->ace_yy_is_interactive = 1;
01505 #else
01506 #if ACE_YY_NEVER_INTERACTIVE
01507         b->ace_yy_is_interactive = 0;
01508 #else
01509         b->ace_yy_is_interactive = file ? (ACE_OS::isatty( fileno (file) ) > 0) : 0;
01510 #endif
01511 #endif
01512         }
01513 
01514 
01515 #ifdef ACE_YY_USE_PROTOS
01516 void ace_yy_flush_buffer( ACE_YY_BUFFER_STATE b )
01517 #else
01518 void ace_yy_flush_buffer( b )
01519 ACE_YY_BUFFER_STATE b;
01520 #endif
01521 
01522         {
01523         if ( ! b )
01524                 return;
01525 
01526         b->ace_yy_n_chars = 0;
01527 
01528         /* We always need two end-of-buffer characters.  The first causes
01529          * a transition to the end-of-buffer state.  The second causes
01530          * a jam in that state.
01531          */
01532         b->ace_yy_ch_buf[0] = ACE_YY_END_OF_BUFFER_CHAR;
01533         b->ace_yy_ch_buf[1] = ACE_YY_END_OF_BUFFER_CHAR;
01534 
01535         b->ace_yy_buf_pos = &b->ace_yy_ch_buf[0];
01536 
01537         b->ace_yy_at_bol = 1;
01538         b->ace_yy_buffer_status = ACE_YY_BUFFER_NEW;
01539 
01540         if ( b == ace_yy_current_buffer )
01541                 ace_yy_load_buffer_state();
01542         }
01543 
01544 
01545 #ifndef ACE_YY_NO_SCAN_BUFFER
01546 #ifdef ACE_YY_USE_PROTOS
01547 ACE_YY_BUFFER_STATE ace_yy_scan_buffer( ACE_TCHAR *base, ace_yy_size_t size )
01548 #else
01549 ACE_YY_BUFFER_STATE ace_yy_scan_buffer( base, size )
01550 ACE_TCHAR *base;
01551 ace_yy_size_t size;
01552 #endif
01553         {
01554         ACE_YY_BUFFER_STATE b;
01555 
01556         if ( size < 2 ||
01557              base[size-2] != ACE_YY_END_OF_BUFFER_CHAR ||
01558              base[size-1] != ACE_YY_END_OF_BUFFER_CHAR )
01559                 /* They forgot to leave room for the EOB's. */
01560                 return 0;
01561 
01562         b = (ACE_YY_BUFFER_STATE) ace_yy_flex_alloc( sizeof( struct ace_yy_buffer_state ) );
01563         if ( ! b )
01564                 ACE_YY_FATAL_ERROR(ACE_LIB_TEXT( "out of dynamic memory in ace_yy_scan_buffer()" ));
01565 
01566         b->ace_yy_buf_size = size - 2;  /* "- 2" to take care of EOB's */
01567         b->ace_yy_buf_pos = b->ace_yy_ch_buf = base;
01568         b->ace_yy_is_our_buffer = 0;
01569         b->ace_yy_input_file = 0;
01570         b->ace_yy_n_chars = b->ace_yy_buf_size;
01571         b->ace_yy_is_interactive = 0;
01572         b->ace_yy_at_bol = 1;
01573         b->ace_yy_fill_buffer = 0;
01574         b->ace_yy_buffer_status = ACE_YY_BUFFER_NEW;
01575 
01576         ace_yy_switch_to_buffer( b );
01577 
01578         return b;
01579         }
01580 #endif
01581 
01582 
01583 #ifndef ACE_YY_NO_SCAN_STRING
01584 #ifdef ACE_YY_USE_PROTOS
01585 ACE_YY_BUFFER_STATE ace_yy_scan_string( ace_yyconst ACE_TCHAR *ace_yy_str )
01586 #else
01587 ACE_YY_BUFFER_STATE ace_yy_scan_string( ace_yy_str )
01588 ace_yyconst ACE_TCHAR *ace_yy_str;
01589 #endif
01590         {
01591         int len;
01592         for ( len = 0; ace_yy_str[len]; ++len )
01593                 ;
01594 
01595         return ace_yy_scan_bytes( ace_yy_str, len );
01596         }
01597 #endif
01598 
01599 
01600 #ifndef ACE_YY_NO_SCAN_BYTES
01601 #ifdef ACE_YY_USE_PROTOS
01602 ACE_YY_BUFFER_STATE ace_yy_scan_bytes( ace_yyconst ACE_TCHAR *bytes, int len )
01603 #else
01604 ACE_YY_BUFFER_STATE ace_yy_scan_bytes( bytes, len )
01605 ace_yyconst ACE_TCHAR *bytes;
01606 int len;
01607 #endif
01608         {
01609         ACE_YY_BUFFER_STATE b;
01610         ACE_TCHAR *buf;
01611         ace_yy_size_t n;
01612         int i;
01613 
01614         /* Get memory for full buffer, including space for trailing EOB's. */
01615         n = len + 2;
01616         buf = (ACE_TCHAR *) ace_yy_flex_alloc( n * sizeof (ACE_TCHAR));
01617         if ( ! buf )
01618                 ACE_YY_FATAL_ERROR(ACE_LIB_TEXT( "out of dynamic memory in ace_yy_scan_bytes()" ));
01619 
01620         for ( i = 0; i < len; ++i )
01621                 buf[i] = bytes[i];
01622 
01623         buf[len] = buf[len+1] = ACE_YY_END_OF_BUFFER_CHAR;
01624 
01625         b = ace_yy_scan_buffer( buf, n );
01626         if ( ! b )
01627                 ACE_YY_FATAL_ERROR(ACE_LIB_TEXT( "bad buffer in ace_yy_scan_bytes()") );
01628 
01629         /* It's okay to grow etc. this buffer, and we should throw it
01630          * away when we're done.
01631          */
01632         b->ace_yy_is_our_buffer = 1;
01633 
01634         return b;
01635         }
01636 #endif
01637 
01638 
01639 #ifndef ACE_YY_NO_PUSH_STATE
01640 #ifdef ACE_YY_USE_PROTOS
01641 static void ace_yy_push_state( int new_state )
01642 #else
01643 static void ace_yy_push_state( new_state )
01644 int new_state;
01645 #endif
01646         {
01647         if ( ace_yy_start_stack_ptr >= ace_yy_start_stack_depth )
01648                 {
01649                 ace_yy_size_t new_size;
01650 
01651                 ace_yy_start_stack_depth += ACE_YY_START_STACK_INCR;
01652                 new_size = ace_yy_start_stack_depth * sizeof( int );
01653 
01654                 if ( ! ace_yy_start_stack )
01655                         ace_yy_start_stack = (int *) ace_yy_flex_alloc( new_size );
01656 
01657                 else
01658                         ace_yy_start_stack = (int *) ace_yy_flex_realloc(
01659                                         (void *) ace_yy_start_stack, new_size );
01660 
01661                 if ( ! ace_yy_start_stack )
01662                   ACE_YY_FATAL_ERROR(ACE_LIB_TEXT(
01663                         "out of memory expanding start-condition stack" ));
01664                 }
01665 
01666         ace_yy_start_stack[ace_yy_start_stack_ptr++] = ACE_YY_START;
01667 
01668         BEGIN(new_state);
01669         }
01670 #endif
01671 
01672 
01673 #ifndef ACE_YY_NO_POP_STATE
01674 static void ace_yy_pop_state()
01675         {
01676         if ( --ace_yy_start_stack_ptr < 0 )
01677                 ACE_YY_FATAL_ERROR(ACE_LIB_TEXT( "start-condition stack underflow" ));
01678 
01679         BEGIN(ace_yy_start_stack[ace_yy_start_stack_ptr]);
01680         }
01681 #endif
01682 
01683 
01684 #ifndef ACE_YY_NO_TOP_STATE
01685 static int ace_yy_top_state()
01686         {
01687         return ace_yy_start_stack[ace_yy_start_stack_ptr - 1];
01688         }
01689 #endif
01690 
01691 #ifndef ACE_YY_EXIT_FAILURE
01692 #define ACE_YY_EXIT_FAILURE 2
01693 #endif
01694 
01695 #ifdef ACE_YY_USE_PROTOS
01696 static void ace_yy_fatal_error( ace_yyconst ACE_TCHAR msg[] )
01697 #else
01698 static void ace_yy_fatal_error( msg )
01699 ACE_TCHAR msg[];
01700 #endif
01701         {
01702         (void) ACE_OS::fprintf( stderr, ACE_LIB_TEXT("%s\n"), msg );
01703         exit( ACE_YY_EXIT_FAILURE );
01704         }
01705 
01706 
01707 
01708 /* Redefine ace_yyless() so it works in section 3 code. */
01709 
01710 #undef ace_yyless
01711 #define ace_yyless(n) \
01712         do \
01713                 { \
01714                 /* Undo effects of setting up ace_yytext. */ \
01715                 ace_yytext[ace_yyleng] = ace_yy_hold_char; \
01716                 ace_yy_c_buf_p = ace_yytext + n; \
01717                 ace_yy_hold_char = *ace_yy_c_buf_p; \
01718                 *ace_yy_c_buf_p = '\0'; \
01719                 ace_yyleng = n; \
01720                 } \
01721         while ( 0 )
01722 
01723 
01724 /* Internal utility routines. */
01725 
01726 #ifndef ace_yytext_ptr
01727 #ifdef ACE_YY_USE_PROTOS
01728 static void ace_yy_flex_strncpy( ACE_TCHAR *s1, ace_yyconst ACE_TCHAR *s2, int n )
01729 #else
01730 static void ace_yy_flex_strncpy( s1, s2, n )
01731 ACE_TCHAR *s1;
01732 ace_yyconst ACE_TCHAR *s2;
01733 int n;
01734 #endif
01735         {
01736         register int i;
01737         for ( i = 0; i < n; ++i )
01738                 s1[i] = s2[i];
01739         }
01740 #endif
01741 
01742 #ifdef ACE_YY_NEED_STRLEN
01743 #ifdef ACE_YY_USE_PROTOS
01744 static int ace_yy_flex_strlen( ace_yyconst ACE_TCHAR *s )
01745 #else
01746 static int ace_yy_flex_strlen( s )
01747 ace_yyconst ACE_TCHAR *s;
01748 #endif
01749         {
01750         register int n;
01751         for ( n = 0; s[n]; ++n )
01752                 ;
01753 
01754         return n;
01755         }
01756 #endif
01757 
01758 
01759 #ifdef ACE_YY_USE_PROTOS
01760 static void *ace_yy_flex_alloc( ace_yy_size_t size )
01761 #else
01762 static void *ace_yy_flex_alloc( size )
01763 ace_yy_size_t size;
01764 #endif
01765         {
01766         return (void *) malloc( size );
01767         }
01768 
01769 #ifdef ACE_YY_USE_PROTOS
01770 static void *ace_yy_flex_realloc( void *ptr, ace_yy_size_t size )
01771 #else
01772 static void *ace_yy_flex_realloc( ptr, size )
01773 void *ptr;
01774 ace_yy_size_t size;
01775 #endif
01776         {
01777         /* The cast to (char *) in the following accommodates both
01778          * implementations that use char* generic pointers, and those
01779          * that use void* generic pointers.  It works with the latter
01780          * because both ANSI C and C++ allow castless assignment from
01781          * any pointer type to void*, and deal with argument conversions
01782          * as though doing an assignment.
01783          */
01784         return (void *) realloc( (char *) ptr, size );
01785         }
01786 
01787 #ifdef ACE_YY_USE_PROTOS
01788 static void ace_yy_flex_free( void *ptr )
01789 #else
01790 static void ace_yy_flex_free( ptr )
01791 void *ptr;
01792 #endif
01793         {
01794         free( ACE_MALLOC_T (ptr) );
01795         }
01796 
01797 #if ACE_YY_MAIN
01798 int main()
01799         {
01800         ace_yylex();
01801         return 0;
01802         }
01803 #endif
01804 
01805 int
01806 ace_yywrap (void)
01807 {
01808   ACE_OS::fflush (ace_yyin);
01809   ace_yytext[0] = '#';
01810   ace_yyleng = 0;
01811 
01812   return 1;
01813 }
01814 
01815 void
01816 ace_yy_push_buffer (FILE *file, ace_yy_buffer_state *&buffer)
01817 {
01818   // External synchronization is required.
01819 
01820   if (buffer == 0)
01821     buffer = ace_yy_create_buffer (file, ACE_YY_BUF_SIZE);
01822 
01823   ace_yy_switch_to_buffer (buffer);
01824 }
01825 
01826 void
01827 ace_yy_push_buffer (const ACE_TCHAR *directive, ace_yy_buffer_state *&buffer)
01828 {
01829   // External synchronization is required.
01830 
01831   // ace_yyparse() may invoke ace_yylex() multiple times when parsing
01832   // a single directive.  Prevent a new buffer from created during
01833   // each call to ace_yylex().
01834   if (ACE_YY_CURRENT_BUFFER != 0
01835       && directive == ACE_YY_CURRENT_BUFFER->ace_yy_ch_buf)
01836     return;
01837 
01838   if (buffer == 0)
01839     {
01840       // ace_yy_scan_string() already switches the buffer so there is
01841       // no need to explicitly make the switch.
01842       buffer = ace_yy_scan_string (directive);
01843     }
01844   else
01845     ace_yy_switch_to_buffer (buffer);
01846 }
01847 
01848 void
01849 ace_yy_pop_buffer (ace_yy_buffer_state *buffer)
01850 {
01851   // External synchronization is required.
01852 
01853   ace_yy_switch_to_buffer (buffer);
01854 }
01855 
01856 #endif /* ACE_USES_CLASSIC_SVC_CONF = 1 */

Generated on Mon Jun 16 11:21:34 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002