*** empty log message ***

1 files changed, 492 insertions, 234 deletions

diff --git a/ace/Svc_Conf_l.cpp b/ace/Svc_Conf_l.cpp
index 627786f8772..4a0c0fb80d4 100644
--- a/ace/Svc_Conf_l.cpp
+++ b/ace/Svc_Conf_l.cpp
@@ -1,6 +1,3 @@
-// $Id$
-
-#define ACE_BUILD_DLL
 /* A lexical scanner generated by flex */
 
 /* Scanner skeleton version:
@@ -8,8 +5,10 @@
  */
 
 #define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
 
-#include "ace/stdcpp.h"
+#include "ace/OS.h"
 
 
 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
@@ -23,7 +22,7 @@
 #ifdef __cplusplus
 
 #include /**/ <stdlib.h>
-#include "ace/stdcpp.h"
+#include "ace/OS.h"
 
 /* Use prototypes in function declarations. */
 #define YY_USE_PROTOS
@@ -33,7 +32,7 @@
 
 #else	/* ! __cplusplus */
 
-#ifdef __STDC__
+#if __STDC__
 
 #define YY_USE_PROTOS
 #define YY_USE_CONST
@@ -41,16 +40,19 @@
 #endif	/* __STDC__ */
 #endif	/* ! __cplusplus */
 
-
 #ifdef __TURBOC__
+ #pragma warn -rch
+ #pragma warn -use
+#include /**/ <io.h>
+#include /**/ <stdlib.h>
 #define YY_USE_CONST
+#define YY_USE_PROTOS
 #endif
 
-
-#ifndef YY_USE_CONST
-#ifndef const
-#define const
-#endif
+#ifdef YY_USE_CONST
+#define ace_yyconst const
+#else
+#define ace_yyconst
 #endif
 
 
@@ -77,16 +79,16 @@
 #define BEGIN ace_yy_start = 1 + 2 *
 
 /* Translate the current start state into a value that can be later handed
- * to BEGIN to return to the state.
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
  */
 #define YY_START ((ace_yy_start - 1) / 2)
+#define YYSTATE YY_START
 
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 
-/* Special action meaning "start processing a new file".  Now included
- * only for backward compatibility with previous versions of flex.
- */
+/* Special action meaning "start processing a new file". */
 #define YY_NEW_FILE ace_yyrestart( ace_yyin )
 
 #define YY_END_OF_BUFFER_CHAR 0
@@ -99,14 +101,6 @@ typedef struct ace_yy_buffer_state *YY_BUFFER_STATE;
 extern int ace_yyleng;
 extern FILE *ace_yyin, *ace_yyout;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-	extern int ace_yywrap YY_PROTO(( void ));
-#ifdef __cplusplus
-	}
-#endif
-
 #define EOB_ACT_CONTINUE_SCAN 0
 #define EOB_ACT_END_OF_FILE 1
 #define EOB_ACT_LAST_MATCH 2
@@ -132,14 +126,19 @@ extern "C" {
 		{ \
 		/* Undo effects of setting up ace_yytext. */ \
 		*ace_yy_cp = ace_yy_hold_char; \
+		YY_RESTORE_YY_MORE_OFFSET \
 		ace_yy_c_buf_p = ace_yy_cp = ace_yy_bp + n - YY_MORE_ADJ; \
 		YY_DO_BEFORE_ACTION; /* set up ace_yytext again */ \
 		} \
 	while ( 0 )
 
-#if 0
 #define unput(c) ace_yyunput( c, ace_yytext_ptr )
-#endif /* 0 */
+
+/* The following is because we cannot portably get our hands on size_t
+ * (without autoconf's help, which isn't available because we want
+ * flex-generated scanners to compile on their own).
+ */
+typedef unsigned int ace_yy_size_t;
 
 
 struct ace_yy_buffer_state
@@ -152,13 +151,19 @@ struct ace_yy_buffer_state
 	/* Size of input buffer in bytes, not including room for EOB
 	 * characters.
 	 */
-	int ace_yy_buf_size;
+	ace_yy_size_t ace_yy_buf_size;
 
 	/* Number of characters read into ace_yy_ch_buf, not including EOB
 	 * characters.
 	 */
 	int ace_yy_n_chars;
 
+	/* Whether we "own" the buffer - i.e., we know we created it,
+	 * and can realloc() it to grow it, and should free() it to
+	 * delete it.
+	 */
+	int ace_yy_is_our_buffer;
+
 	/* Whether this is an "interactive" input source; if so, and
 	 * if we're using stdio for input, then we want to use getc()
 	 * instead of fread(), to make sure we stop fetching input after
@@ -166,6 +171,12 @@ struct ace_yy_buffer_state
 	 */
 	int ace_yy_is_interactive;
 
+	/* Whether we're considered to be at the beginning of a line.
+	 * If so, '^' rules will be active on the next match, otherwise
+	 * not.
+	 */
+	int ace_yy_at_bol;
+
 	/* Whether to try to fill the input buffer when we reach the
 	 * end of it.
 	 */
@@ -214,67 +225,66 @@ static int ace_yy_start = 0;	/* start state number */
  */
 static int ace_yy_did_buffer_switch_on_eof;
 
-#if 0
-static void ace_yyunput YY_PROTO(( int c, char *buf_ptr ));
-#endif /* 0 */
 void ace_yyrestart YY_PROTO(( FILE *input_file ));
+
 void ace_yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 void ace_yy_load_buffer_state YY_PROTO(( void ));
 YY_BUFFER_STATE ace_yy_create_buffer YY_PROTO(( FILE *file, int size ));
 void ace_yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 void ace_yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+void ace_yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+#define YY_FLUSH_BUFFER ace_yy_flush_buffer( ace_yy_current_buffer )
 
-#if 0
-static int ace_yy_start_stack_ptr = 0;
-static int ace_yy_start_stack_depth = 0;
-static int *ace_yy_start_stack = 0;
-static void ace_yy_push_state YY_PROTO(( int new_state ));
-static void ace_yy_pop_state YY_PROTO(( void ));
-static int ace_yy_top_state YY_PROTO(( void ));
-#endif /* 0 */
+YY_BUFFER_STATE ace_yy_scan_buffer YY_PROTO(( char *base, ace_yy_size_t size ));
+YY_BUFFER_STATE ace_yy_scan_string YY_PROTO(( ace_yyconst char *ace_yy_str ));
+YY_BUFFER_STATE ace_yy_scan_bytes YY_PROTO(( ace_yyconst char *bytes, int len ));
 
-static void *ace_yy_flex_alloc YY_PROTO(( unsigned int ));
-static void *ace_yy_flex_realloc YY_PROTO(( void *, unsigned int ));
+static void *ace_yy_flex_alloc YY_PROTO(( ace_yy_size_t ));
+static void *ace_yy_flex_realloc YY_PROTO(( void *, ace_yy_size_t ));
 static void ace_yy_flex_free YY_PROTO(( void * ));
 
 #define ace_yy_new_buffer ace_yy_create_buffer
 
-#define INITIAL 0
-#define PARAMETERS 1
-#define NORMAL 2
+#define ace_yy_set_interactive(is_interactive) \
+	{ \
+	if ( ! ace_yy_current_buffer ) \
+		ace_yy_current_buffer = ace_yy_create_buffer( ace_yyin, YY_BUF_SIZE ); \
+	ace_yy_current_buffer->ace_yy_is_interactive = is_interactive; \
+	}
+
+#define ace_yy_set_bol(at_bol) \
+	{ \
+	if ( ! ace_yy_current_buffer ) \
+		ace_yy_current_buffer = ace_yy_create_buffer( ace_yyin, YY_BUF_SIZE ); \
+	ace_yy_current_buffer->ace_yy_at_bol = at_bol; \
+	}
+
+#define YY_AT_BOL() (ace_yy_current_buffer->ace_yy_at_bol)
+
 typedef unsigned char YY_CHAR;
-typedef int ace_yy_state_type;
 FILE *ace_yyin = (FILE *) 0, *ace_yyout = (FILE *) 0;
+typedef int ace_yy_state_type;
 extern char *ace_yytext;
 #define ace_yytext_ptr ace_yytext
 
-#ifndef ace_yytext_ptr
-static void ace_yy_flex_strncpy YY_PROTO(( char *, const char *, int ));
-#endif
-
-#ifdef __cplusplus
-static int ace_yyinput YY_PROTO(( void ));
-#else
-static int input YY_PROTO(( void ));
-#endif
-
 static ace_yy_state_type ace_yy_get_previous_state YY_PROTO(( void ));
 static ace_yy_state_type ace_yy_try_NUL_trans YY_PROTO(( ace_yy_state_type current_state ));
 static int ace_yy_get_next_buffer YY_PROTO(( void ));
-static void ace_yy_fatal_error YY_PROTO(( const char msg[] ));
+static void ace_yy_fatal_error YY_PROTO(( ace_yyconst char msg[] ));
 
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up ace_yytext.
  */
 #define YY_DO_BEFORE_ACTION \
 	ace_yytext_ptr = ace_yy_bp; \
-	ace_yyleng = ace_yy_cp - ace_yy_bp; \
+	ace_yyleng = (int) (ace_yy_cp - ace_yy_bp); \
 	ace_yy_hold_char = *ace_yy_cp; \
 	*ace_yy_cp = '\0'; \
 	ace_yy_c_buf_p = ace_yy_cp;
 
+#define YY_NUM_RULES 25
 #define YY_END_OF_BUFFER 26
-static const short int ace_yy_accept[103] =
+static ace_yyconst short int ace_yy_accept[103] =
     {   0,
         0,    0,    0,    0,    0,    0,   26,   24,   22,   23,
        24,   15,   16,   14,   21,   13,   20,   20,   20,   20,
@@ -290,7 +300,7 @@ static const short int ace_yy_accept[103] =
         9,    0
     } ;
 
-static const int ace_yy_ec[256] =
+static ace_yyconst int ace_yy_ec[256] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -322,7 +332,7 @@ static const int ace_yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static const int ace_yy_meta[43] =
+static ace_yyconst int ace_yy_meta[43] =
     {   0,
         1,    1,    1,    2,    2,    2,    2,    2,    2,    2,
         3,    3,    4,    3,    3,    3,    3,    3,    3,    3,
@@ -331,7 +341,7 @@ static const int ace_yy_meta[43] =
         2,    2
     } ;
 
-static const short int ace_yy_base[107] =
+static ace_yyconst short int ace_yy_base[107] =
     {   0,
         0,  112,    0,  111,    0,  107,   97,  313,   41,  313,
        85,  313,  313,  313,    0,  313,   33,   36,   37,   40,
@@ -347,7 +357,7 @@ static const short int ace_yy_base[107] =
       271,  313,  302,   53,  304,  308
     } ;
 
-static const short int ace_yy_def[107] =
+static ace_yyconst short int ace_yy_def[107] =
     {   0,
       102,    1,    1,    1,    1,    1,  102,  102,  102,  102,
       103,  102,  102,  102,  104,  102,  105,  105,  105,  105,
@@ -363,7 +373,7 @@ static const short int ace_yy_def[107] =
       105,    0,  102,  102,  102,  102
     } ;
 
-static const short int ace_yy_nxt[356] =
+static ace_yyconst short int ace_yy_nxt[356] =
     {   0,
         8,    9,   10,    9,    8,   11,    8,   12,   13,   14,
        15,   15,   16,   17,   17,   17,   18,   17,   17,   19,
@@ -406,7 +416,7 @@ static const short int ace_yy_nxt[356] =
       102,  102,  102,  102,  102
     } ;
 
-static const short int ace_yy_chk[356] =
+static ace_yyconst short int ace_yy_chk[356] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -458,9 +468,11 @@ static char *ace_yy_last_accepting_cpos;
 #define REJECT reject_used_but_not_detected
 #define ace_yymore() ace_yymore_used_but_not_detected
 #define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
 char *ace_yytext;
-# line 1 "Svc_Conf.l"
-# line 2 "Svc_Conf.l"
+#line 1 "Svc_Conf.l"
+#define INITIAL 0
+#line 2 "Svc_Conf.l"
 // Sample lexical analysis for regular expression subset.  Must be
 // compiled with FLEX and an ANSI C++ compiler.
 
@@ -468,18 +480,70 @@ char *ace_yytext;
 #include "ace/Svc_Conf.h"
 #include "ace/Svc_Conf_Tokens.h"
 
-// Keeps track of the current line for debugging output.
+// Keeps track of the current line for debugging output. 
 int ace_yylineno = 1;
 
 // Keeps track of the number of errors encountered so far.
 int ace_yyerrno = 0;
 
 #define token(x)  x
+#define PARAMETERS 1
+
+#define NORMAL 2
+
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
  */
 
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int ace_yywrap YY_PROTO(( void ));
+#else
+extern int ace_yywrap YY_PROTO(( void ));
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+static void ace_yyunput YY_PROTO(( int c, char *buf_ptr ));
+#endif
+
+#ifndef ace_yytext_ptr
+static void ace_yy_flex_strncpy YY_PROTO(( char *, ace_yyconst char *, int ));
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int ace_yy_flex_strlen YY_PROTO(( ace_yyconst char * ));
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int ace_yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+#endif
+
+#if YY_STACK_USED
+static int ace_yy_start_stack_ptr = 0;
+static int ace_yy_start_stack_depth = 0;
+static int *ace_yy_start_stack = 0;
+#ifndef YY_NO_PUSH_STATE
+static void ace_yy_push_state YY_PROTO(( int new_state ));
+#endif
+#ifndef YY_NO_POP_STATE
+static void ace_yy_pop_state YY_PROTO(( void ));
+#endif
+#ifndef YY_NO_TOP_STATE
+static int ace_yy_top_state YY_PROTO(( void ));
+#endif
+
+#else
+#define YY_NO_PUSH_STATE 1
+#define YY_NO_POP_STATE 1
+#define YY_NO_TOP_STATE 1
+#endif
+
 #ifdef YY_MALLOC_DECL
 YY_MALLOC_DECL
 #else
@@ -516,9 +580,15 @@ YY_MALLOC_DECL
 #define YY_INPUT(buf,result,max_size) \
 	if ( ace_yy_current_buffer->ace_yy_is_interactive ) \
 		{ \
-		int c = getc( ace_yyin ); \
-		result = c == EOF ? 0 : 1; \
-		buf[0] = (char) c; \
+		int c = '*', n; \
+		for ( n = 0; n < max_size && \
+			     (c = getc( ace_yyin )) != EOF && c != '\n'; ++n ) \
+			buf[n] = (char) c; \
+		if ( c == '\n' ) \
+			buf[n++] = (char) c; \
+		if ( c == EOF && ferror( ace_yyin ) ) \
+			YY_FATAL_ERROR( "input in flex scanner failed" ); \
+		result = n; \
 		} \
 	else if ( ((result = fread( buf, 1, max_size, ace_yyin )) == 0) \
 		  && ferror( ace_yyin ) ) \
@@ -562,18 +632,26 @@ YY_MALLOC_DECL
 #define YY_BREAK break;
 #endif
 
+#define YY_RULE_SETUP \
+	if ( ace_yyleng > 0 ) \
+		ace_yy_current_buffer->ace_yy_at_bol = \
+				(ace_yytext[ace_yyleng - 1] == '\n'); \
+	YY_USER_ACTION
+
 YY_DECL
 	{
 	register ace_yy_state_type ace_yy_current_state;
 	register char *ace_yy_cp, *ace_yy_bp;
 	register int ace_yy_act;
 
-# line 32 "Svc_Conf.l"
+#line 32 "Svc_Conf.l"
 
 
 
 	if ( ace_yy_init )
 		{
+		ace_yy_init = 0;
+
 #ifdef YY_USER_INIT
 		YY_USER_INIT;
 #endif
@@ -587,15 +665,11 @@ YY_DECL
 		if ( ! ace_yyout )
 			ace_yyout = stdout;
 
-		if ( ace_yy_current_buffer )
-			ace_yy_init_buffer( ace_yy_current_buffer, ace_yyin );
-		else
+		if ( ! ace_yy_current_buffer )
 			ace_yy_current_buffer =
 				ace_yy_create_buffer( ace_yyin, YY_BUF_SIZE );
 
 		ace_yy_load_buffer_state();
-
-		ace_yy_init = 0;
 		}
 
 	while ( 1 )		/* loops until end-of-file is reached */
@@ -611,8 +685,7 @@ YY_DECL
 		ace_yy_bp = ace_yy_cp;
 
 		ace_yy_current_state = ace_yy_start;
-		if ( ace_yy_bp[-1] == '\n' )
-			++ace_yy_current_state;
+		ace_yy_current_state += YY_AT_BOL();
 ace_yy_match:
 		do
 			{
@@ -635,6 +708,12 @@ ace_yy_match:
 
 ace_yy_find_action:
 		ace_yy_act = ace_yy_accept[ace_yy_current_state];
+		if ( ace_yy_act == 0 )
+			{ /* have to back up */
+			ace_yy_cp = ace_yy_last_accepting_cpos;
+			ace_yy_current_state = ace_yy_last_accepting_state;
+			ace_yy_act = ace_yy_accept[ace_yy_current_state];
+			}
 
 		YY_DO_BEFORE_ACTION;
 
@@ -655,154 +734,155 @@ case 1:
 *ace_yy_cp = ace_yy_hold_char; /* undo effects of setting up ace_yytext */
 ace_yy_c_buf_p = ace_yy_cp -= 1;
 YY_DO_BEFORE_ACTION; /* set up ace_yytext again */
-YY_USER_ACTION
-# line 34 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 34 "Svc_Conf.l"
 ; /* EMPTY */
 	YY_BREAK
 case 2:
-YY_USER_ACTION
-# line 35 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 35 "Svc_Conf.l"
 { return token (ACE_DYNAMIC); }
-	/* YY_BREAK */
+	YY_BREAK
 case 3:
-YY_USER_ACTION
-# line 36 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 36 "Svc_Conf.l"
 { return token (ACE_STATIC); }
-	/* YY_BREAK */
+	YY_BREAK
 case 4:
-YY_USER_ACTION
-# line 37 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 37 "Svc_Conf.l"
 { return token (ACE_SUSPEND); }
-	/* YY_BREAK */
+	YY_BREAK
 case 5:
-YY_USER_ACTION
-# line 38 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 38 "Svc_Conf.l"
 { return token (ACE_RESUME); }
-	/* YY_BREAK */
+	YY_BREAK
 case 6:
-YY_USER_ACTION
-# line 39 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 39 "Svc_Conf.l"
 { return token (ACE_REMOVE); }
-	/* YY_BREAK */
+	YY_BREAK
 case 7:
-YY_USER_ACTION
-# line 40 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 40 "Svc_Conf.l"
 { return token (ACE_USTREAM); }
-	/* YY_BREAK */
+	YY_BREAK
 case 8:
-YY_USER_ACTION
-# line 41 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 41 "Svc_Conf.l"
 { return token (ACE_MODULE_T); }
-	/* YY_BREAK */
+	YY_BREAK
 case 9:
-YY_USER_ACTION
-# line 42 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 42 "Svc_Conf.l"
 { return token (ACE_SVC_OBJ_T); }
-	/* YY_BREAK */
+	YY_BREAK
 case 10:
-YY_USER_ACTION
-# line 43 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 43 "Svc_Conf.l"
 { return token (ACE_STREAM_T); }
-	/* YY_BREAK */
+	YY_BREAK
 case 11:
-YY_USER_ACTION
-# line 44 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 44 "Svc_Conf.l"
 { return token (ACE_ACTIVE); }
-	/* YY_BREAK */
+	YY_BREAK
 case 12:
-YY_USER_ACTION
-# line 45 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 45 "Svc_Conf.l"
 { return token (ACE_INACTIVE); }
-	/* YY_BREAK */
+	YY_BREAK
 case 13:
-YY_USER_ACTION
-# line 46 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 46 "Svc_Conf.l"
 { return token (ACE_COLON); }
-	/* YY_BREAK */
+	YY_BREAK
 case 14:
-YY_USER_ACTION
-# line 47 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 47 "Svc_Conf.l"
 { return token (ACE_STAR); }
-	/* YY_BREAK */
+	YY_BREAK
 case 15:
-YY_USER_ACTION
-# line 48 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 48 "Svc_Conf.l"
 { return token (ACE_LPAREN); }
-	/* YY_BREAK */
+	YY_BREAK
 case 16:
-YY_USER_ACTION
-# line 49 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 49 "Svc_Conf.l"
 { return token (ACE_RPAREN); }
-	/* YY_BREAK */
+	YY_BREAK
 case 17:
-YY_USER_ACTION
-# line 50 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 50 "Svc_Conf.l"
 { return token (ACE_LBRACE); }
-	/* YY_BREAK */
+	YY_BREAK
 case 18:
-YY_USER_ACTION
-# line 51 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 51 "Svc_Conf.l"
 { return token (ACE_RBRACE); }
-	/* YY_BREAK */
+	YY_BREAK
 case 19:
-YY_USER_ACTION
-# line 52 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 52 "Svc_Conf.l"
 { // Eliminate the opening and closing double quotes
 		        *strrchr (ace_yytext, '"') = '\0';
 			ace_yyleng -= 1;
-                        ace_yylval.ident_ = ace_obstack->copy (ace_yytext + 1, ace_yyleng);
+                        ace_yylval.ident_ = ace_obstack->copy (ace_yytext + 1, ace_yyleng); 
 			return token (ACE_STRING); }
-	/* YY_BREAK */
+	YY_BREAK
 case 20:
-YY_USER_ACTION
-# line 57 "Svc_Conf.l"
-{
-		        ace_yylval.ident_ = ace_obstack->copy (ace_yytext, ace_yyleng);
-			return token (ACE_IDENT);
+YY_RULE_SETUP
+#line 57 "Svc_Conf.l"
+{ 
+		        ace_yylval.ident_ = ace_obstack->copy (ace_yytext, ace_yyleng); 
+			return token (ACE_IDENT); 
 		      }
-	/* YY_BREAK */
+	YY_BREAK
 case 21:
-YY_USER_ACTION
-# line 61 "Svc_Conf.l"
-{
-		        ace_yylval.ident_ = ace_obstack->copy (ace_yytext, ace_yyleng);
-			return token (ACE_PATHNAME);
+YY_RULE_SETUP
+#line 61 "Svc_Conf.l"
+{ 
+		        ace_yylval.ident_ = ace_obstack->copy (ace_yytext, ace_yyleng); 
+			return token (ACE_PATHNAME); 
 		      }
-	/* YY_BREAK */
+	YY_BREAK
 case 22:
-YY_USER_ACTION
-# line 65 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 65 "Svc_Conf.l"
 ; /* EMPTY */
 	YY_BREAK
 case 23:
-YY_USER_ACTION
-# line 66 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 66 "Svc_Conf.l"
 { ace_yylineno++; }
 	YY_BREAK
 case 24:
-YY_USER_ACTION
-# line 67 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 67 "Svc_Conf.l"
 { ACE_ERROR ((LM_ERROR, "unknown char = %d\n", *ace_yytext)); }
 	YY_BREAK
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(PARAMETERS):
 case YY_STATE_EOF(NORMAL):
-# line 68 "Svc_Conf.l"
+#line 68 "Svc_Conf.l"
 { YY_NEW_FILE; ace_yyterminate(); }
-	/* YY_BREAK */
+	YY_BREAK
 case 25:
-YY_USER_ACTION
-# line 69 "Svc_Conf.l"
+YY_RULE_SETUP
+#line 69 "Svc_Conf.l"
 ACE_SVC_CONF_ECHO;
 	YY_BREAK
 
 	case YY_END_OF_BUFFER:
 		{
 		/* Amount of text matched not including the EOB char. */
-		int ace_yy_amount_of_matched_text = ace_yy_cp - ace_yytext_ptr - 1;
+		int ace_yy_amount_of_matched_text = (int) (ace_yy_cp - ace_yytext_ptr) - 1;
 
 		/* Undo the effects of YY_DO_BEFORE_ACTION. */
 		*ace_yy_cp = ace_yy_hold_char;
+		YY_RESTORE_YY_MORE_OFFSET
 
 		if ( ace_yy_current_buffer->ace_yy_buffer_status == YY_BUFFER_NEW )
 			{
@@ -858,7 +938,7 @@ ACE_SVC_CONF_ECHO;
 
 			else
 				{
-							ace_yy_cp = ace_yy_c_buf_p;
+				ace_yy_cp = ace_yy_c_buf_p;
 				goto ace_yy_find_action;
 				}
 			}
@@ -936,7 +1016,7 @@ ACE_SVC_CONF_ECHO;
 static int ace_yy_get_next_buffer()
 	{
 	register char *dest = ace_yy_current_buffer->ace_yy_ch_buf;
-	register char *source = ace_yytext_ptr - 1; /* copy prev. char, too */
+	register char *source = ace_yytext_ptr;
 	register int number_to_move, i;
 	int ret_val;
 
@@ -948,7 +1028,7 @@ static int ace_yy_get_next_buffer()
 		{ /* Don't try to fill the buffer, so this is an EOF. */
 		if ( ace_yy_c_buf_p - ace_yytext_ptr - YY_MORE_ADJ == 1 )
 			{
-			/* We matched a singled characater, the EOB, so
+			/* We matched a single character, the EOB, so
 			 * treat this as a final EOF.
 			 */
 			return EOB_ACT_END_OF_FILE;
@@ -966,7 +1046,7 @@ static int ace_yy_get_next_buffer()
 	/* Try to read more data. */
 
 	/* First move last chars to start of buffer. */
-	number_to_move = ace_yy_c_buf_p - ace_yytext_ptr;
+	number_to_move = (int) (ace_yy_c_buf_p - ace_yytext_ptr) - 1;
 
 	for ( i = 0; i < number_to_move; ++i )
 		*(dest++) = *(source++);
@@ -975,7 +1055,7 @@ static int ace_yy_get_next_buffer()
 		/* don't do the read, it's not guaranteed to return an EOF,
 		 * just force an EOF
 		 */
-		ace_yy_n_chars = 0;
+		ace_yy_current_buffer->ace_yy_n_chars = ace_yy_n_chars = 0;
 
 	else
 		{
@@ -992,12 +1072,26 @@ static int ace_yy_get_next_buffer()
 			/* just a shorter name for the current buffer */
 			YY_BUFFER_STATE b = ace_yy_current_buffer;
 
-			int ace_yy_c_buf_p_offset = ace_yy_c_buf_p - b->ace_yy_ch_buf;
+			int ace_yy_c_buf_p_offset =
+				(int) (ace_yy_c_buf_p - b->ace_yy_ch_buf);
+
+			if ( b->ace_yy_is_our_buffer )
+				{
+				int new_size = b->ace_yy_buf_size * 2;
+
+				if ( new_size <= 0 )
+					b->ace_yy_buf_size += b->ace_yy_buf_size / 8;
+				else
+					b->ace_yy_buf_size *= 2;
 
-			b->ace_yy_buf_size *= 2;
-			b->ace_yy_ch_buf = (char *)
-				ace_yy_flex_realloc( (void *) b->ace_yy_ch_buf,
-						 b->ace_yy_buf_size );
+				b->ace_yy_ch_buf = (char *)
+					/* Include room in for 2 EOB chars. */
+					ace_yy_flex_realloc( (void *) b->ace_yy_ch_buf,
+							 b->ace_yy_buf_size + 2 );
+				}
+			else
+				/* Can't grow it, we don't own it. */
+				b->ace_yy_ch_buf = 0;
 
 			if ( ! b->ace_yy_ch_buf )
 				YY_FATAL_ERROR(
@@ -1016,11 +1110,13 @@ static int ace_yy_get_next_buffer()
 		/* Read in more data. */
 		YY_INPUT( (&ace_yy_current_buffer->ace_yy_ch_buf[number_to_move]),
 			ace_yy_n_chars, num_to_read );
+
+		ace_yy_current_buffer->ace_yy_n_chars = ace_yy_n_chars;
 		}
 
 	if ( ace_yy_n_chars == 0 )
 		{
-		if ( number_to_move - YY_MORE_ADJ == 1 )
+		if ( number_to_move == YY_MORE_ADJ )
 			{
 			ret_val = EOB_ACT_END_OF_FILE;
 			ace_yyrestart( ace_yyin );
@@ -1041,13 +1137,7 @@ static int ace_yy_get_next_buffer()
 	ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars] = YY_END_OF_BUFFER_CHAR;
 	ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
 
-	/* ace_yytext begins at the second character in ace_yy_ch_buf; the first
-	 * character is the one which preceded it before reading in the latest
-	 * buffer; it needs to be kept around in case it's a newline, so
-	 * ace_yy_get_previous_state() will have with '^' rules active.
-	 */
-
-	ace_yytext_ptr = &ace_yy_current_buffer->ace_yy_ch_buf[1];
+	ace_yytext_ptr = &ace_yy_current_buffer->ace_yy_ch_buf[0];
 
 	return ret_val;
 	}
@@ -1060,11 +1150,8 @@ static ace_yy_state_type ace_yy_get_previous_state()
 	register ace_yy_state_type ace_yy_current_state;
 	register char *ace_yy_cp;
 
-	register char *ace_yy_bp = ace_yytext_ptr;
-
 	ace_yy_current_state = ace_yy_start;
-	if ( ace_yy_bp[-1] == '\n' )
-		++ace_yy_current_state;
+	ace_yy_current_state += YY_AT_BOL();
 
 	for ( ace_yy_cp = ace_yytext_ptr + YY_MORE_ADJ; ace_yy_cp < ace_yy_c_buf_p; ++ace_yy_cp )
 		{
@@ -1122,7 +1209,7 @@ ace_yy_state_type ace_yy_current_state;
 	}
 
 
-#if 0
+#ifndef YY_NO_UNPUT
 #ifdef YY_USE_PROTOS
 static void ace_yyunput( int c, register char *ace_yy_bp )
 #else
@@ -1148,26 +1235,24 @@ register char *ace_yy_bp;
 		while ( source > ace_yy_current_buffer->ace_yy_ch_buf )
 			*--dest = *--source;
 
-		ace_yy_cp += dest - source;
-		ace_yy_bp += dest - source;
-		ace_yy_n_chars = ace_yy_current_buffer->ace_yy_buf_size;
+		ace_yy_cp += (int) (dest - source);
+		ace_yy_bp += (int) (dest - source);
+		ace_yy_current_buffer->ace_yy_n_chars =
+			ace_yy_n_chars = ace_yy_current_buffer->ace_yy_buf_size;
 
 		if ( ace_yy_cp < ace_yy_current_buffer->ace_yy_ch_buf + 2 )
 			YY_FATAL_ERROR( "flex scanner push-back overflow" );
 		}
 
-	if ( ace_yy_cp > ace_yy_bp && ace_yy_cp[-1] == '\n' )
-		ace_yy_cp[-2] = '\n';
-
 	*--ace_yy_cp = (char) c;
 
 
-	/* Note: the formal parameter *must* be called "ace_yy_bp" for this
-	 * macro to now work correctly.
-	 */
-	YY_DO_BEFORE_ACTION; /* set up ace_yytext again */
+	ace_yytext_ptr = ace_yy_bp;
+	ace_yy_hold_char = *ace_yy_cp;
+	ace_yy_c_buf_p = ace_yy_cp;
 	}
-#endif /* 0 */
+#endif	/* ifndef YY_NO_UNPUT */
+
 
 #ifdef __cplusplus
 static int ace_yyinput()
@@ -1191,21 +1276,34 @@ static int input()
 
 		else
 			{ /* need more input */
-			ace_yytext_ptr = ace_yy_c_buf_p;
+			int offset = ace_yy_c_buf_p - ace_yytext_ptr;
 			++ace_yy_c_buf_p;
 
 			switch ( ace_yy_get_next_buffer() )
 				{
+				case EOB_ACT_LAST_MATCH:
+					/* This happens because ace_yy_g_n_b()
+					 * sees that we've accumulated a
+					 * token and flags that we need to
+					 * try matching the token before
+					 * proceeding.  But for input(),
+					 * there's no matching to consider.
+					 * So convert the EOB_ACT_LAST_MATCH
+					 * to EOB_ACT_END_OF_FILE.
+					 */
+
+					/* Reset buffer status. */
+					ace_yyrestart( ace_yyin );
+
+					/* fall through */
+
 				case EOB_ACT_END_OF_FILE:
 					{
 					if ( ace_yywrap() )
-						{
-						ace_yy_c_buf_p =
-						ace_yytext_ptr + YY_MORE_ADJ;
 						return EOF;
-						}
 
-					YY_NEW_FILE;
+					if ( ! ace_yy_did_buffer_switch_on_eof )
+						YY_NEW_FILE;
 #ifdef __cplusplus
 					return ace_yyinput();
 #else
@@ -1214,17 +1312,8 @@ static int input()
 					}
 
 				case EOB_ACT_CONTINUE_SCAN:
-					ace_yy_c_buf_p = ace_yytext_ptr + YY_MORE_ADJ;
+					ace_yy_c_buf_p = ace_yytext_ptr + offset;
 					break;
-
-				case EOB_ACT_LAST_MATCH:
-#ifdef __cplusplus
-					YY_FATAL_ERROR(
-					"unexpected last match in ace_yyinput()" );
-#else
-					YY_FATAL_ERROR(
-					"unexpected last match in input()" );
-#endif
 				}
 			}
 		}
@@ -1233,6 +1322,8 @@ static int input()
 	*ace_yy_c_buf_p = '\0';	/* preserve ace_yytext */
 	ace_yy_hold_char = *++ace_yy_c_buf_p;
 
+	ace_yy_current_buffer->ace_yy_at_bol = (c == '\n');
+
 	return c;
 	}
 
@@ -1306,7 +1397,6 @@ int size;
 	YY_BUFFER_STATE b;
 
 	b = (YY_BUFFER_STATE) ace_yy_flex_alloc( sizeof( struct ace_yy_buffer_state ) );
-
 	if ( ! b )
 		YY_FATAL_ERROR( "out of dynamic memory in ace_yy_create_buffer()" );
 
@@ -1316,10 +1406,11 @@ int size;
 	 * we need to put in 2 end-of-buffer characters.
 	 */
 	b->ace_yy_ch_buf = (char *) ace_yy_flex_alloc( b->ace_yy_buf_size + 2 );
-
 	if ( ! b->ace_yy_ch_buf )
 		YY_FATAL_ERROR( "out of dynamic memory in ace_yy_create_buffer()" );
 
+	b->ace_yy_is_our_buffer = 1;
+
 	ace_yy_init_buffer( b, file );
 
 	return b;
@@ -1333,14 +1424,25 @@ void ace_yy_delete_buffer( b )
 YY_BUFFER_STATE b;
 #endif
 	{
+	if ( ! b )
+		return;
+
 	if ( b == ace_yy_current_buffer )
 		ace_yy_current_buffer = (YY_BUFFER_STATE) 0;
 
-	ace_yy_flex_free( (void *) b->ace_yy_ch_buf );
+	if ( b->ace_yy_is_our_buffer )
+		ace_yy_flex_free( (void *) b->ace_yy_ch_buf );
+
 	ace_yy_flex_free( (void *) b );
 	}
 
 
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+extern int isatty YY_PROTO(( int ));
+#endif
+#endif
+
 #ifdef YY_USE_PROTOS
 void ace_yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
 #else
@@ -1348,34 +1450,151 @@ void ace_yy_init_buffer( b, file )
 YY_BUFFER_STATE b;
 FILE *file;
 #endif
+
+
 	{
+	ace_yy_flush_buffer( b );
+
 	b->ace_yy_input_file = file;
+	b->ace_yy_fill_buffer = 1;
+
+#if YY_ALWAYS_INTERACTIVE
+	b->ace_yy_is_interactive = 1;
+#else
+#if YY_NEVER_INTERACTIVE
+	b->ace_yy_is_interactive = 0;
+#else
+	b->ace_yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+#endif
+#endif
+	}
 
-	/* We put in the '\n' and start reading from [1] so that an
-	 * initial match-at-newline will be true.
-	 */
 
-	b->ace_yy_ch_buf[0] = '\n';
-	b->ace_yy_n_chars = 1;
+#ifdef YY_USE_PROTOS
+void ace_yy_flush_buffer( YY_BUFFER_STATE b )
+#else
+void ace_yy_flush_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+
+	{
+	if ( ! b )
+		return;
+
+	b->ace_yy_n_chars = 0;
 
 	/* We always need two end-of-buffer characters.  The first causes
 	 * a transition to the end-of-buffer state.  The second causes
 	 * a jam in that state.
 	 */
+	b->ace_yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
 	b->ace_yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-	b->ace_yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
 
-	b->ace_yy_buf_pos = &b->ace_yy_ch_buf[1];
+	b->ace_yy_buf_pos = &b->ace_yy_ch_buf[0];
 
-	b->ace_yy_is_interactive = file ? isatty( fileno(file) ) : 0;
+	b->ace_yy_at_bol = 1;
+	b->ace_yy_buffer_status = YY_BUFFER_NEW;
 
-	b->ace_yy_fill_buffer = 1;
+	if ( b == ace_yy_current_buffer )
+		ace_yy_load_buffer_state();
+	}
+
+
+#ifndef YY_NO_SCAN_BUFFER
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE ace_yy_scan_buffer( char *base, ace_yy_size_t size )
+#else
+YY_BUFFER_STATE ace_yy_scan_buffer( base, size )
+char *base;
+ace_yy_size_t size;
+#endif
+	{
+	YY_BUFFER_STATE b;
 
+	if ( size < 2 ||
+	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
+	     base[size-1] != YY_END_OF_BUFFER_CHAR )
+		/* They forgot to leave room for the EOB's. */
+		return 0;
+
+	b = (YY_BUFFER_STATE) ace_yy_flex_alloc( sizeof( struct ace_yy_buffer_state ) );
+	if ( ! b )
+		YY_FATAL_ERROR( "out of dynamic memory in ace_yy_scan_buffer()" );
+
+	b->ace_yy_buf_size = size - 2;	/* "- 2" to take care of EOB's */
+	b->ace_yy_buf_pos = b->ace_yy_ch_buf = base;
+	b->ace_yy_is_our_buffer = 0;
+	b->ace_yy_input_file = 0;
+	b->ace_yy_n_chars = b->ace_yy_buf_size;
+	b->ace_yy_is_interactive = 0;
+	b->ace_yy_at_bol = 1;
+	b->ace_yy_fill_buffer = 0;
 	b->ace_yy_buffer_status = YY_BUFFER_NEW;
+
+	ace_yy_switch_to_buffer( b );
+
+	return b;
+	}
+#endif
+
+
+#ifndef YY_NO_SCAN_STRING
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE ace_yy_scan_string( ace_yyconst char *ace_yy_str )
+#else
+YY_BUFFER_STATE ace_yy_scan_string( ace_yy_str )
+ace_yyconst char *ace_yy_str;
+#endif
+	{
+	int len;
+	for ( len = 0; ace_yy_str[len]; ++len )
+		;
+
+	return ace_yy_scan_bytes( ace_yy_str, len );
+	}
+#endif
+
+
+#ifndef YY_NO_SCAN_BYTES
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE ace_yy_scan_bytes( ace_yyconst char *bytes, int len )
+#else
+YY_BUFFER_STATE ace_yy_scan_bytes( bytes, len )
+ace_yyconst char *bytes;
+int len;
+#endif
+	{
+	YY_BUFFER_STATE b;
+	char *buf;
+	ace_yy_size_t n;
+	int i;
+
+	/* Get memory for full buffer, including space for trailing EOB's. */
+	n = len + 2;
+	buf = (char *) ace_yy_flex_alloc( n );
+	if ( ! buf )
+		YY_FATAL_ERROR( "out of dynamic memory in ace_yy_scan_bytes()" );
+
+	for ( i = 0; i < len; ++i )
+		buf[i] = bytes[i];
+
+	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+
+	b = ace_yy_scan_buffer( buf, n );
+	if ( ! b )
+		YY_FATAL_ERROR( "bad buffer in ace_yy_scan_bytes()" );
+
+	/* It's okay to grow etc. this buffer, and we should throw it
+	 * away when we're done.
+	 */
+	b->ace_yy_is_our_buffer = 1;
+
+	return b;
 	}
+#endif
 
 
-#if 0
+#ifndef YY_NO_PUSH_STATE
 #ifdef YY_USE_PROTOS
 static void ace_yy_push_state( int new_state )
 #else
@@ -1385,7 +1604,7 @@ int new_state;
 	{
 	if ( ace_yy_start_stack_ptr >= ace_yy_start_stack_depth )
 		{
-		int new_size;
+		ace_yy_size_t new_size;
 
 		ace_yy_start_stack_depth += YY_START_STACK_INCR;
 		new_size = ace_yy_start_stack_depth * sizeof( int );
@@ -1406,8 +1625,10 @@ int new_state;
 
 	BEGIN(new_state);
 	}
+#endif
 
 
+#ifndef YY_NO_POP_STATE
 static void ace_yy_pop_state()
 	{
 	if ( --ace_yy_start_stack_ptr < 0 )
@@ -1415,23 +1636,29 @@ static void ace_yy_pop_state()
 
 	BEGIN(ace_yy_start_stack[ace_yy_start_stack_ptr]);
 	}
+#endif
 
 
+#ifndef YY_NO_TOP_STATE
 static int ace_yy_top_state()
 	{
 	return ace_yy_start_stack[ace_yy_start_stack_ptr - 1];
 	}
-#endif /* 0 */
+#endif
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
 
 #ifdef YY_USE_PROTOS
-static void ace_yy_fatal_error( const char msg[] )
+static void ace_yy_fatal_error( ace_yyconst char msg[] )
 #else
 static void ace_yy_fatal_error( msg )
 char msg[];
 #endif
 	{
 	(void) fprintf( stderr, "%s\n", msg );
-	exit( 1 );
+	exit( YY_EXIT_FAILURE );
 	}
 
 
@@ -1444,7 +1671,7 @@ char msg[];
 		{ \
 		/* Undo effects of setting up ace_yytext. */ \
 		ace_yytext[ace_yyleng] = ace_yy_hold_char; \
-		ace_yy_c_buf_p = ace_yytext + n - YY_MORE_ADJ; \
+		ace_yy_c_buf_p = ace_yytext + n; \
 		ace_yy_hold_char = *ace_yy_c_buf_p; \
 		*ace_yy_c_buf_p = '\0'; \
 		ace_yyleng = n; \
@@ -1456,11 +1683,11 @@ char msg[];
 
 #ifndef ace_yytext_ptr
 #ifdef YY_USE_PROTOS
-static void ace_yy_flex_strncpy( char *s1, const char *s2, int n )
+static void ace_yy_flex_strncpy( char *s1, ace_yyconst char *s2, int n )
 #else
 static void ace_yy_flex_strncpy( s1, s2, n )
 char *s1;
-const char *s2;
+ace_yyconst char *s2;
 int n;
 #endif
 	{
@@ -1470,26 +1697,49 @@ int n;
 	}
 #endif
 
+#ifdef YY_NEED_STRLEN
+#ifdef YY_USE_PROTOS
+static int ace_yy_flex_strlen( ace_yyconst char *s )
+#else
+static int ace_yy_flex_strlen( s )
+ace_yyconst char *s;
+#endif
+	{
+	register int n;
+	for ( n = 0; s[n]; ++n )
+		;
+
+	return n;
+	}
+#endif
+
 
 #ifdef YY_USE_PROTOS
-static void *ace_yy_flex_alloc( unsigned int size )
+static void *ace_yy_flex_alloc( ace_yy_size_t size )
 #else
 static void *ace_yy_flex_alloc( size )
-unsigned int size;
+ace_yy_size_t size;
 #endif
 	{
 	return (void *) malloc( size );
 	}
 
 #ifdef YY_USE_PROTOS
-static void *ace_yy_flex_realloc( void *ptr, unsigned int size )
+static void *ace_yy_flex_realloc( void *ptr, ace_yy_size_t size )
 #else
 static void *ace_yy_flex_realloc( ptr, size )
 void *ptr;
-unsigned int size;
+ace_yy_size_t size;
 #endif
 	{
-	return (void *) realloc( ACE_MALLOC_T (ptr), size );
+	/* The cast to (char *) in the following accommodates both
+	 * implementations that use char* generic pointers, and those
+	 * that use void* generic pointers.  It works with the latter
+	 * because both ANSI C and C++ allow castless assignment from
+	 * any pointer type to void*, and deal with argument conversions
+	 * as though doing an assignment.
+	 */
+	return (void *) realloc( (char *) ptr, size );
 	}
 
 #ifdef YY_USE_PROTOS
@@ -1501,13 +1751,21 @@ void *ptr;
 	{
 	free( ACE_MALLOC_T (ptr) );
 	}
-# line 69 "Svc_Conf.l"
+
+#if YY_MAIN
+int main()
+	{
+	ace_yylex();
+	return 0;
+	}
+#endif
+#line 69 "Svc_Conf.l"
 
 int
 ace_yywrap (void)
 {
   ::fflush (ace_yyin);
   ace_yytext[0] = '#';
-  ace_yyleng = 0;
+  ace_yyleng = 0;    
   return 1;
 }