*** empty log message ***

13 files changed, 3251 insertions, 4729 deletions

diff --git a/ChangeLog-98a b/ChangeLog-98a
index 0c5f83a0018..f69542c5818 100644
--- a/ChangeLog-98a
+++ b/ChangeLog-98a
@@ -1,4 +1,21 @@
-Thu Apr 23 11:21:46 1998  Douglas C. Schmidt  <schmidt@flamenco.cs.wustl.edu>
+Thu Apr 23 17:52:31 1998  Douglas C. Schmidt  <schmidt@tango.cs.wustl.edu>
+
+	* ace/Parse_Node.cpp (open_handle),
+	  ace/Svc_Conf.l: The line for the service object for the service
+	  configurator contains the DLL specifications.  Previously, it
+	  was possible to specify either the absolute path name of the DLL
+	  or only the name of the DLL itself.  For the latter, the service
+	  configurator is searching for the DLL using the PATH environment
+	  variable.  If we used the absolute path name it was not
+	  possible to use environment variables in the string.  It is now
+	  possible to do this for Win32 using their %foo% notation.
+	  Thanks to Andreas Schuelke <Andreas.Schuelke@med.siemens.de> for
+	  providing these fixes.
+
+	* etc/Svc_Conf_y.cpp.diff,
+	  etc/Svc_Conf_l.cpp.diff,
+	  ace/Makefile: Change the YY* symbols to ACE_YY* symbols to
+	  avoid clashes if we link with other flex/yacc generated code.
 
 	* apps/Gateway/Gateway/gatewayd.cpp,
 	  apps/Gateway/Peer/peerd.cpp: Added a check to see if the
diff --git a/README b/README
index e12b769e222..635ec46cb74 100644
--- a/README
+++ b/README
@@ -531,6 +531,7 @@ Tom Brusehaver <tgb@cozy.netco.com>
 Dave Tallman <tallman@acsys.com>
 Monish Rajpal <monish@cs.jhu.edu>
 Garry Brother <gmbroth@romulus.ncsc.mil>
+Andreas Schuelke <Andreas.Schuelke@med.siemens.de>
 
 I would particularly like to thank Paul Stephenson, who worked with me
 at Ericsson and is now at ObjectSpace.  Paul devised the recursive
diff --git a/TAO/ChangeLog-98c b/TAO/ChangeLog-98c
index 3280833a9a5..482745ae3f0 100644
--- a/TAO/ChangeLog-98c
+++ b/TAO/ChangeLog-98c
@@ -1,7 +1,7 @@
 Thu Apr 23 16:20:58 1998  Douglas C. Schmidt  <schmidt@flamenco.cs.wustl.edu>
 
-	* TAO_IDL/fe/Makefile (LFLAGS): Added a -Ptao_ prefix
-	  to the lexer to avoid conflicts.
+	* TAO/TAO_IDL/Makefile: Change the YY* symbols to ACE_YY* symbols
+ 	  to avoid clashes if we link with other flex/yacc generated code.
 
 Thu Apr 23 15:48:29 1998  Aniruddha Gokhale  <gokhale@mambo.cs.wustl.edu>
 
diff --git a/TAO/TAO_IDL/fe/Makefile b/TAO/TAO_IDL/fe/Makefile
index 0aa2c6b4ae7..1aec28e49c3 100644
--- a/TAO/TAO_IDL/fe/Makefile
+++ b/TAO/TAO_IDL/fe/Makefile
@@ -57,21 +57,24 @@ CPPFLAGS += -D_REENTRANT -I../include -I. -DCPP_LOCATION=\"$(CXX)\" -DIDL_CFE_VE
 YACC   = yacc
 LEX	= flex
 YFLAGS	= -t -d
-LFLAGS	= -t -Ptao_
+LFLAGS	= -t 
 
 # Create the parser and lexer
 y.tab.h y.tab.cpp: idl.yy
 	@-$(RM) -f $@
 	$(YACC) $(YFLAGS) idl.yy
-	@mv -f y.tab.c y.tab.cpp
+	sed -e "s/yy/tao_yy/g" \
+	    -e "s/YY/TAO_YY/g" < y.tab.c > y.tab.cpp
 	@patch < y.tab.cpp.diff
-	@-$(RM) -f y.tab.cpp.orig
+	@-$(RM) -f y.tab.cpp.orig y.tab.c 
 
 lex.yy.cpp: idl.ll y.tab.h
 	$(LEX) $(LFLAGS) idl.ll > /tmp/$@
 	@#### Replace #includes of standard headers with #include of ace/OS.h,
 	@#### so that ace/config.h is #included first.
 	@sed -e 's%#include.*<stdio.h>%#include "ace/OS.h"%g' \
+             -e "s/yy/tao_yy/g" \
+             -e "s/YY/TAO_YY/g" \
 	     -e '/#include.*stdlib.h/D' \
 	     -e '/#include.*unistd.h/D' \
 	     -e 's/ECHO/TAO_ECHO/g' < /tmp/$@ > $@
diff --git a/TAO/TAO_IDL/fe/lex.yy.cpp b/TAO/TAO_IDL/fe/lex.yy.cpp
index 39fc0908496..55ca14680cc 100644
--- a/TAO/TAO_IDL/fe/lex.yy.cpp
+++ b/TAO/TAO_IDL/fe/lex.yy.cpp
@@ -1,3 +1,4 @@
+// $Id$
 /* A lexical scanner generated by flex */
 
 /* Scanner skeleton version:
@@ -21,83 +22,83 @@
 
 
 /* Use prototypes in function declarations. */
-#define YY_USE_PROTOS
+#define TAO_YY_USE_PROTOS
 
 /* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
+#define TAO_YY_USE_CONST
 
 #else	/* ! __cplusplus */
 
 #ifdef __STDC__
 
-#define YY_USE_PROTOS
-#define YY_USE_CONST
+#define TAO_YY_USE_PROTOS
+#define TAO_YY_USE_CONST
 
 #endif	/* __STDC__ */
 #endif	/* ! __cplusplus */
 
 
 #ifdef __TURBOC__
-#define YY_USE_CONST
+#define TAO_YY_USE_CONST
 #endif
 
 
-#ifndef YY_USE_CONST
+#ifndef TAO_YY_USE_CONST
 #ifndef const
 #define const
 #endif
 #endif
 
 
-#ifdef YY_USE_PROTOS
-#define YY_PROTO(proto) proto
+#ifdef TAO_YY_USE_PROTOS
+#define TAO_YY_PROTO(proto) proto
 #else
-#define YY_PROTO(proto) ()
+#define TAO_YY_PROTO(proto) ()
 #endif
 
 /* Returned upon end-of-file. */
-#define YY_NULL 0
+#define TAO_YY_NULL 0
 
 /* Promotes a possibly negative, possibly signed char to an unsigned
  * integer for use as an array index.  If the signed char is negative,
  * we want to instead treat it as an 8-bit unsigned char, hence the
  * double cast.
  */
-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+#define TAO_YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 
 /* Enter a start condition.  This macro really ought to take a parameter,
  * but we do it the disgusting crufty way forced on us by the ()-less
  * definition of BEGIN.
  */
-#define BEGIN yy_start = 1 + 2 *
+#define BEGIN tao_yy_start = 1 + 2 *
 
 /* Translate the current start state into a value that can be later handed
  * to BEGIN to return to the state.
  */
-#define YY_START ((yy_start - 1) / 2)
+#define TAO_YY_START ((tao_yy_start - 1) / 2)
 
 /* Action number for EOF rule of a given start state. */
-#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+#define TAO_YY_STATE_EOF(state) (TAO_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.
  */
-#define YY_NEW_FILE yyrestart( yyin )
+#define TAO_YY_NEW_FILE tao_yyrestart( tao_yyin )
 
-#define YY_END_OF_BUFFER_CHAR 0
+#define TAO_YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */
-#define YY_BUF_SIZE 16384
+#define TAO_YY_BUF_SIZE 16384
 
-typedef struct yy_buffer_state *YY_BUFFER_STATE;
+typedef struct tao_yy_buffer_state *TAO_YY_BUFFER_STATE;
 
-extern int yyleng;
-extern FILE *yyin, *yyout;
+extern int tao_yyleng;
+extern FILE *tao_yyin, *tao_yyout;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int yywrap YY_PROTO(( void ));
+	extern int tao_yywrap TAO_YY_PROTO(( void ));
 #ifdef __cplusplus
 	}
 #endif
@@ -111,162 +112,162 @@ extern "C" {
  * avoids problems with code like:
  *
  * 	if ( condition_holds )
- *		yyless( 5 );
+ *		tao_yyless( 5 );
  *	else
  *		do_something_else();
  *
  * Prior to using the do-while the compiler would get upset at the
  * "else" because it interpreted the "if" statement as being all
- * done when it reached the ';' after the yyless() call.
+ * done when it reached the ';' after the tao_yyless() call.
  */
 
 /* Return all but the first 'n' matched characters back to the input stream. */
 
-#define yyless(n) \
+#define tao_yyless(n) \
 	do \
 		{ \
-		/* Undo effects of setting up yytext. */ \
-		*yy_cp = yy_hold_char; \
-		yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
-		YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+		/* Undo effects of setting up tao_yytext. */ \
+		*tao_yy_cp = tao_yy_hold_char; \
+		tao_yy_c_buf_p = tao_yy_cp = tao_yy_bp + n - TAO_YY_MORE_ADJ; \
+		TAO_YY_DO_BEFORE_ACTION; /* set up tao_yytext again */ \
 		} \
 	while ( 0 )
 
-#define unput(c) yyunput( c, yytext_ptr )
+#define unput(c) tao_yyunput( c, tao_yytext_ptr )
 
 
-struct yy_buffer_state
+struct tao_yy_buffer_state
 	{
-	FILE *yy_input_file;
+	FILE *tao_yy_input_file;
 
-	char *yy_ch_buf;		/* input buffer */
-	char *yy_buf_pos;		/* current position in input buffer */
+	char *tao_yy_ch_buf;		/* input buffer */
+	char *tao_yy_buf_pos;		/* current position in input buffer */
 
 	/* Size of input buffer in bytes, not including room for EOB
 	 * characters.
 	 */
-	int yy_buf_size;
+	int tao_yy_buf_size;
 
-	/* Number of characters read into yy_ch_buf, not including EOB
+	/* Number of characters read into tao_yy_ch_buf, not including EOB
 	 * characters.
 	 */
-	int yy_n_chars;
+	int tao_yy_n_chars;
 
 	/* 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
 	 * each newline.
 	 */
-	int yy_is_interactive;
+	int tao_yy_is_interactive;
 
 	/* Whether to try to fill the input buffer when we reach the
 	 * end of it.
 	 */
-	int yy_fill_buffer;
+	int tao_yy_fill_buffer;
 
-	int yy_buffer_status;
-#define YY_BUFFER_NEW 0
-#define YY_BUFFER_NORMAL 1
+	int tao_yy_buffer_status;
+#define TAO_YY_BUFFER_NEW 0
+#define TAO_YY_BUFFER_NORMAL 1
 	/* When an EOF's been seen but there's still some text to process
-	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * then we mark the buffer as TAO_YY_EOF_PENDING, to indicate that we
 	 * shouldn't try reading from the input source any more.  We might
 	 * still have a bunch of tokens to match, though, because of
 	 * possible backing-up.
 	 *
 	 * When we actually see the EOF, we change the status to "new"
-	 * (via yyrestart()), so that the user can continue scanning by
-	 * just pointing yyin at a new input file.
+	 * (via tao_yyrestart()), so that the user can continue scanning by
+	 * just pointing tao_yyin at a new input file.
 	 */
-#define YY_BUFFER_EOF_PENDING 2
+#define TAO_YY_BUFFER_EOF_PENDING 2
 	};
 
-static YY_BUFFER_STATE yy_current_buffer = 0;
+static TAO_YY_BUFFER_STATE tao_yy_current_buffer = 0;
 
 /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general
  * "scanner state".
  */
-#define YY_CURRENT_BUFFER yy_current_buffer
+#define TAO_YY_CURRENT_BUFFER tao_yy_current_buffer
 
 
-/* yy_hold_char holds the character lost when yytext is formed. */
-static char yy_hold_char;
+/* tao_yy_hold_char holds the character lost when tao_yytext is formed. */
+static char tao_yy_hold_char;
 
-static int yy_n_chars;		/* number of characters read into yy_ch_buf */
+static int tao_yy_n_chars;		/* number of characters read into tao_yy_ch_buf */
 
 
-int yyleng;
+int tao_yyleng;
 
 /* Points to current character in buffer. */
-static char *yy_c_buf_p = (char *) 0;
-static int yy_init = 1;		/* whether we need to initialize */
-static int yy_start = 0;	/* start state number */
+static char *tao_yy_c_buf_p = (char *) 0;
+static int tao_yy_init = 1;		/* whether we need to initialize */
+static int tao_yy_start = 0;	/* start state number */
 
-/* Flag which is used to allow yywrap()'s to do buffer switches
- * instead of setting up a fresh yyin.  A bit of a hack ...
+/* Flag which is used to allow tao_yywrap()'s to do buffer switches
+ * instead of setting up a fresh tao_yyin.  A bit of a hack ...
  */
-static int yy_did_buffer_switch_on_eof;
+static int tao_yy_did_buffer_switch_on_eof;
 
-static void yyunput YY_PROTO(( int c, char *buf_ptr ));
-void yyrestart YY_PROTO(( FILE *input_file ));
-void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
-void yy_load_buffer_state YY_PROTO(( void ));
-YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
-void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
-void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+static void tao_yyunput TAO_YY_PROTO(( int c, char *buf_ptr ));
+void tao_yyrestart TAO_YY_PROTO(( FILE *input_file ));
+void tao_yy_switch_to_buffer TAO_YY_PROTO(( TAO_YY_BUFFER_STATE new_buffer ));
+void tao_yy_load_buffer_state TAO_YY_PROTO(( void ));
+TAO_YY_BUFFER_STATE tao_yy_create_buffer TAO_YY_PROTO(( FILE *file, int size ));
+void tao_yy_delete_buffer TAO_YY_PROTO(( TAO_YY_BUFFER_STATE b ));
+void tao_yy_init_buffer TAO_YY_PROTO(( TAO_YY_BUFFER_STATE b, FILE *file ));
 
 #if 0
-static int yy_start_stack_ptr = 0;
-static int yy_start_stack_depth = 0;
-static int *yy_start_stack = 0;
-static void yy_push_state YY_PROTO(( int new_state ));
-static void yy_pop_state YY_PROTO(( void ));
-static int yy_top_state YY_PROTO(( void ));
+static int tao_yy_start_stack_ptr = 0;
+static int tao_yy_start_stack_depth = 0;
+static int *tao_yy_start_stack = 0;
+static void tao_yy_push_state TAO_YY_PROTO(( int new_state ));
+static void tao_yy_pop_state TAO_YY_PROTO(( void ));
+static int tao_yy_top_state TAO_YY_PROTO(( void ));
 #endif /* 0 */
 
-static void *yy_flex_alloc YY_PROTO(( unsigned int ));
-static void *yy_flex_realloc YY_PROTO(( void *, unsigned int ));
-static void yy_flex_free YY_PROTO(( void * ));
+static void *tao_yy_flex_alloc TAO_YY_PROTO(( unsigned int ));
+static void *tao_yy_flex_realloc TAO_YY_PROTO(( void *, unsigned int ));
+static void tao_yy_flex_free TAO_YY_PROTO(( void * ));
 
-#define yy_new_buffer yy_create_buffer
+#define tao_yy_new_buffer tao_yy_create_buffer
 
 #define INITIAL 0
-typedef unsigned char YY_CHAR;
-typedef int yy_state_type;
-FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
-extern char yytext[];
+typedef unsigned char TAO_YY_CHAR;
+typedef int tao_yy_state_type;
+FILE *tao_yyin = (FILE *) 0, *tao_yyout = (FILE *) 0;
+extern char tao_yytext[];
 
 
-#ifndef yytext_ptr
-static void yy_flex_strncpy YY_PROTO(( char *, const char *, int ));
+#ifndef tao_yytext_ptr
+static void tao_yy_flex_strncpy TAO_YY_PROTO(( char *, const char *, int ));
 #endif
 
 #ifdef __cplusplus
-static int yyinput YY_PROTO(( void ));
+static int tao_yyinput TAO_YY_PROTO(( void ));
 #else
-static int input YY_PROTO(( void ));
+static int input TAO_YY_PROTO(( void ));
 #endif
 
-static yy_state_type yy_get_previous_state YY_PROTO(( void ));
-static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
-static int yy_get_next_buffer YY_PROTO(( void ));
-static void yy_fatal_error YY_PROTO(( const char msg[] ));
+static tao_yy_state_type tao_yy_get_previous_state TAO_YY_PROTO(( void ));
+static tao_yy_state_type tao_yy_try_NUL_trans TAO_YY_PROTO(( tao_yy_state_type current_state ));
+static int tao_yy_get_next_buffer TAO_YY_PROTO(( void ));
+static void tao_yy_fatal_error TAO_YY_PROTO(( const char msg[] ));
 
 /* Done after the current pattern has been matched and before the
- * corresponding action - sets up yytext.
+ * corresponding action - sets up tao_yytext.
  */
-#define YY_DO_BEFORE_ACTION \
-	yytext_ptr = yy_bp; \
-	yyleng = yy_cp - yy_bp; \
-	yy_hold_char = *yy_cp; \
-	*yy_cp = '\0'; \
-	if ( yyleng >= YYLMAX ) \
-		YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
-	yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \
-	yy_c_buf_p = yy_cp;
-
-#define YY_END_OF_BUFFER 62
-static const short int yy_accept[284] =
+#define TAO_YY_DO_BEFORE_ACTION \
+	tao_yytext_ptr = tao_yy_bp; \
+	tao_yyleng = tao_yy_cp - tao_yy_bp; \
+	tao_yy_hold_char = *tao_yy_cp; \
+	*tao_yy_cp = '\0'; \
+	if ( tao_yyleng >= TAO_YYLMAX ) \
+		TAO_YY_FATAL_ERROR( "token too large, exceeds TAO_YYLMAX" ); \
+	tao_yy_flex_strncpy( tao_yytext, tao_yytext_ptr, tao_yyleng + 1 ); \
+	tao_yy_c_buf_p = tao_yy_cp;
+
+#define TAO_YY_END_OF_BUFFER 62
+static const short int tao_yy_accept[284] =
     {   0,
        58,   58,   62,   60,   58,   59,   60,   60,   60,   60,
        45,   43,   60,   60,   60,   40,   40,   40,   40,   40,
@@ -301,7 +302,7 @@ static const short int yy_accept[284] =
         0,   50,    0
     } ;
 
-static const int yy_ec[256] =
+static const int tao_yy_ec[256] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -333,7 +334,7 @@ static const int yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static const int yy_meta[55] =
+static const int tao_yy_meta[55] =
     {   0,
         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    3,    3,    3,    1,    1,    1,    3,    3,
@@ -343,7 +344,7 @@ static const int yy_meta[55] =
         4,    4,    4,    4
     } ;
 
-static const short int yy_base[294] =
+static const short int tao_yy_base[294] =
     {   0,
         0,  444,  449,  451,   53,  451,  443,  417,   45,   53,
        53,   58,  430,  428,  426,    0,  424,  417,   13,  397,
@@ -380,7 +381,7 @@ static const short int yy_base[294] =
 
     } ;
 
-static const short int yy_def[294] =
+static const short int tao_yy_def[294] =
     {   0,
       283,    1,  283,  283,  283,  283,  284,  285,  283,  283,
       283,  283,  283,  283,  283,  286,  286,  286,  286,  286,
@@ -417,7 +418,7 @@ static const short int yy_def[294] =
 
     } ;
 
-static const short int yy_nxt[506] =
+static const short int tao_yy_nxt[506] =
     {   0,
         4,    5,    6,    5,    7,    4,    8,    4,    4,    9,
         4,   10,   11,   12,   12,   13,   14,   15,   16,   16,
@@ -477,7 +478,7 @@ static const short int yy_nxt[506] =
       283,  283,  283,  283,  283
     } ;
 
-static const short int yy_chk[506] =
+static const short int tao_yy_chk[506] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -537,21 +538,21 @@ static const short int yy_chk[506] =
       283,  283,  283,  283,  283
     } ;
 
-static yy_state_type yy_last_accepting_state;
-static char *yy_last_accepting_cpos;
+static tao_yy_state_type tao_yy_last_accepting_state;
+static char *tao_yy_last_accepting_cpos;
 
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
  */
 #define REJECT reject_used_but_not_detected
-#define yymore() yymore_used_but_not_detected
-#define YY_MORE_ADJ 0
-#ifndef YYLMAX
-#define YYLMAX 8192
+#define tao_yymore() tao_yymore_used_but_not_detected
+#define TAO_YY_MORE_ADJ 0
+#ifndef TAO_YYLMAX
+#define TAO_YYLMAX 8192
 #endif
 
-char yytext[YYLMAX];
-char *yytext_ptr;
+char tao_yytext[TAO_YYLMAX];
+char *tao_yytext_ptr;
 # line 1 "idl.ll"
 # line 3 "idl.ll"
 /*
@@ -634,26 +635,26 @@ static void	idl_parse_line_and_file(char *);
 static void	idl_store_pragma(char *);
 
 #if 0 /* defined (HPUX) */
-// HPUX has yytext typed to unsigned char *. We make sure here that
-// we'll always use char * static char* __yytext = (char*) yytext;
-// NOTE: This will not work under flex(1) were yytext is not a fixed
+// HPUX has tao_yytext typed to unsigned char *. We make sure here that
+// we'll always use char * static char* __tao_yytext = (char*) tao_yytext;
+// NOTE: This will not work under flex(1) were tao_yytext is not a fixed
 // buffer, but a dynamically allocated one. This function should do
 // the trick for us.
-inline char *__yytext()
+inline char *__tao_yytext()
 {
-  return (char *) yytext;
+  return (char *) tao_yytext;
 }
-#define ace_yytext __yytext()
+#define ace_tao_yytext __tao_yytext()
 #else
-#define ace_yytext yytext
+#define ace_tao_yytext tao_yytext
 #endif /* 0 */
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
  */
 
-#ifdef YY_MALLOC_DECL
-YY_MALLOC_DECL
+#ifdef TAO_YY_MALLOC_DECL
+TAO_YY_MALLOC_DECL
 #else
 #if __STDC__
 #ifndef __cplusplus
@@ -667,8 +668,8 @@ YY_MALLOC_DECL
 #endif
 
 /* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#define YY_READ_BUF_SIZE 8192
+#ifndef TAO_YY_READ_BUF_SIZE
+#define TAO_YY_READ_BUF_SIZE 8192
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
@@ -677,660 +678,660 @@ YY_MALLOC_DECL
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define TAO_ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#define TAO_ECHO (void) fwrite( tao_yytext, tao_yyleng, 1, tao_yyout )
 #endif
 
-/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+/* Gets input and stuffs it into "buf".  number of characters read, or TAO_YY_NULL,
  * is returned in "result".
  */
-#ifndef YY_INPUT
-#define YY_INPUT(buf,result,max_size) \
-	if ( yy_current_buffer->yy_is_interactive ) \
+#ifndef TAO_YY_INPUT
+#define TAO_YY_INPUT(buf,result,max_size) \
+	if ( tao_yy_current_buffer->tao_yy_is_interactive ) \
 		{ \
-		int c = getc( yyin ); \
+		int c = getc( tao_yyin ); \
 		result = c == EOF ? 0 : 1; \
 		buf[0] = (char) c; \
 		} \
-	else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
-		  && ferror( yyin ) ) \
-		YY_FATAL_ERROR( "input in flex scanner failed" );
+	else if ( ((result = fread( buf, 1, max_size, tao_yyin )) == 0) \
+		  && ferror( tao_yyin ) ) \
+		TAO_YY_FATAL_ERROR( "input in flex scanner failed" );
 #endif
 
-/* No semi-colon after return; correct usage is to write "yyterminate();" -
+/* No semi-colon after return; correct usage is to write "tao_yyterminate();" -
  * we don't want an extra ';' after the "return" because that will cause
  * some compilers to complain about unreachable statements.
  */
-#ifndef yyterminate
-#define yyterminate() return YY_NULL
+#ifndef tao_yyterminate
+#define tao_yyterminate() return TAO_YY_NULL
 #endif
 
 /* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
+#ifndef TAO_YY_START_STACK_INCR
+#define TAO_YY_START_STACK_INCR 25
 #endif
 
 /* Report a fatal error. */
-#ifndef YY_FATAL_ERROR
-#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#ifndef TAO_YY_FATAL_ERROR
+#define TAO_YY_FATAL_ERROR(msg) tao_yy_fatal_error( msg )
 #endif
 
 /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.
  */
-#ifndef YY_DECL
-#define YY_DECL int yylex YY_PROTO(( void ))
+#ifndef TAO_YY_DECL
+#define TAO_YY_DECL int tao_yylex TAO_YY_PROTO(( void ))
 #endif
 
-/* Code executed at the beginning of each rule, after yytext and yyleng
+/* Code executed at the beginning of each rule, after tao_yytext and tao_yyleng
  * have been set up.
  */
-#ifndef YY_USER_ACTION
-#define YY_USER_ACTION
+#ifndef TAO_YY_USER_ACTION
+#define TAO_YY_USER_ACTION
 #endif
 
 /* Code executed at the end of each rule. */
-#ifndef YY_BREAK
-#define YY_BREAK break;
+#ifndef TAO_YY_BREAK
+#define TAO_YY_BREAK break;
 #endif
 
-YY_DECL
+TAO_YY_DECL
 	{
-	register yy_state_type yy_current_state;
-	register char *yy_cp, *yy_bp;
-	register int yy_act;
+	register tao_yy_state_type tao_yy_current_state;
+	register char *tao_yy_cp, *tao_yy_bp;
+	register int tao_yy_act;
 
 # line 100 "idl.ll"
 
 
 
-	if ( yy_init )
+	if ( tao_yy_init )
 		{
-#ifdef YY_USER_INIT
-		YY_USER_INIT;
+#ifdef TAO_YY_USER_INIT
+		TAO_YY_USER_INIT;
 #endif
 
-		if ( ! yy_start )
-			yy_start = 1;	/* first start state */
+		if ( ! tao_yy_start )
+			tao_yy_start = 1;	/* first start state */
 
-		if ( ! yyin )
-			yyin = stdin;
+		if ( ! tao_yyin )
+			tao_yyin = stdin;
 
-		if ( ! yyout )
-			yyout = stdout;
+		if ( ! tao_yyout )
+			tao_yyout = stdout;
 
-		if ( yy_current_buffer )
-			yy_init_buffer( yy_current_buffer, yyin );
+		if ( tao_yy_current_buffer )
+			tao_yy_init_buffer( tao_yy_current_buffer, tao_yyin );
 		else
-			yy_current_buffer =
-				yy_create_buffer( yyin, YY_BUF_SIZE );
+			tao_yy_current_buffer =
+				tao_yy_create_buffer( tao_yyin, TAO_YY_BUF_SIZE );
 
-		yy_load_buffer_state();
+		tao_yy_load_buffer_state();
 
-		yy_init = 0;
+		tao_yy_init = 0;
 		}
 
 	while ( 1 )		/* loops until end-of-file is reached */
 		{
-		yy_cp = yy_c_buf_p;
+		tao_yy_cp = tao_yy_c_buf_p;
 
-		/* Support of yytext. */
-		*yy_cp = yy_hold_char;
+		/* Support of tao_yytext. */
+		*tao_yy_cp = tao_yy_hold_char;
 
-		/* yy_bp points to the position in yy_ch_buf of the start of
+		/* tao_yy_bp points to the position in tao_yy_ch_buf of the start of
 		 * the current run.
 		 */
-		yy_bp = yy_cp;
+		tao_yy_bp = tao_yy_cp;
 
-		yy_current_state = yy_start;
-		if ( yy_bp[-1] == '\n' )
-			++yy_current_state;
-yy_match:
+		tao_yy_current_state = tao_yy_start;
+		if ( tao_yy_bp[-1] == '\n' )
+			++tao_yy_current_state;
+tao_yy_match:
 		do
 			{
-			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
-			if ( yy_accept[yy_current_state] )
+			register TAO_YY_CHAR tao_yy_c = tao_yy_ec[TAO_YY_SC_TO_UI(*tao_yy_cp)];
+			if ( tao_yy_accept[tao_yy_current_state] )
 				{
-				yy_last_accepting_state = yy_current_state;
-				yy_last_accepting_cpos = yy_cp;
+				tao_yy_last_accepting_state = tao_yy_current_state;
+				tao_yy_last_accepting_cpos = tao_yy_cp;
 				}
-			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+			while ( tao_yy_chk[tao_yy_base[tao_yy_current_state] + tao_yy_c] != tao_yy_current_state )
 				{
-				yy_current_state = (int) yy_def[yy_current_state];
-				if ( yy_current_state >= 284 )
-					yy_c = yy_meta[(unsigned int) yy_c];
+				tao_yy_current_state = (int) tao_yy_def[tao_yy_current_state];
+				if ( tao_yy_current_state >= 284 )
+					tao_yy_c = tao_yy_meta[(unsigned int) tao_yy_c];
 				}
-			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-			++yy_cp;
+			tao_yy_current_state = tao_yy_nxt[tao_yy_base[tao_yy_current_state] + (unsigned int) tao_yy_c];
+			++tao_yy_cp;
 			}
-		while ( yy_base[yy_current_state] != 451 );
+		while ( tao_yy_base[tao_yy_current_state] != 451 );
 
-yy_find_action:
-		yy_act = yy_accept[yy_current_state];
+tao_yy_find_action:
+		tao_yy_act = tao_yy_accept[tao_yy_current_state];
 
-		YY_DO_BEFORE_ACTION;
+		TAO_YY_DO_BEFORE_ACTION;
 
 
 do_action:	/* This label is used only to access EOF actions. */
 
 
-		switch ( yy_act )
+		switch ( tao_yy_act )
 	{ /* beginning of action switch */
 			case 0: /* must back up */
-			/* undo the effects of YY_DO_BEFORE_ACTION */
-			*yy_cp = yy_hold_char;
-			yy_cp = yy_last_accepting_cpos;
-			yy_current_state = yy_last_accepting_state;
-			goto yy_find_action;
+			/* undo the effects of TAO_YY_DO_BEFORE_ACTION */
+			*tao_yy_cp = tao_yy_hold_char;
+			tao_yy_cp = tao_yy_last_accepting_cpos;
+			tao_yy_current_state = tao_yy_last_accepting_state;
+			goto tao_yy_find_action;
 
 case 1:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 102 "idl.ll"
 return IDL_ANY;
-	YY_BREAK
+	TAO_YY_BREAK
 case 2:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 103 "idl.ll"
 return IDL_MODULE;
-	YY_BREAK
+	TAO_YY_BREAK
 case 3:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 104 "idl.ll"
 return IDL_RAISES;
-	YY_BREAK
+	TAO_YY_BREAK
 case 4:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 105 "idl.ll"
 return IDL_READONLY;
-	YY_BREAK
+	TAO_YY_BREAK
 case 5:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 106 "idl.ll"
 return IDL_ATTRIBUTE;
-	YY_BREAK
+	TAO_YY_BREAK
 case 6:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 107 "idl.ll"
 return IDL_EXCEPTION;
-	YY_BREAK
+	TAO_YY_BREAK
 case 7:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 108 "idl.ll"
 return IDL_CONTEXT;
-	YY_BREAK
+	TAO_YY_BREAK
 case 8:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 109 "idl.ll"
 return IDL_INTERFACE;
-	YY_BREAK
+	TAO_YY_BREAK
 case 9:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 110 "idl.ll"
 return IDL_CONST;
-	YY_BREAK
+	TAO_YY_BREAK
 case 10:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 111 "idl.ll"
 return IDL_TYPEDEF;
-	YY_BREAK
+	TAO_YY_BREAK
 case 11:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 112 "idl.ll"
 return IDL_STRUCT;
-	YY_BREAK
+	TAO_YY_BREAK
 case 12:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 113 "idl.ll"
 return IDL_ENUM;
-	YY_BREAK
+	TAO_YY_BREAK
 case 13:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 114 "idl.ll"
 return IDL_STRING;
-	YY_BREAK
+	TAO_YY_BREAK
 case 14:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 115 "idl.ll"
 return IDL_WSTRING;
-	YY_BREAK
+	TAO_YY_BREAK
 case 15:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 116 "idl.ll"
 return IDL_SEQUENCE;
-	YY_BREAK
+	TAO_YY_BREAK
 case 16:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 117 "idl.ll"
 return IDL_UNION;
-	YY_BREAK
+	TAO_YY_BREAK
 case 17:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 118 "idl.ll"
 return IDL_SWITCH;
-	YY_BREAK
+	TAO_YY_BREAK
 case 18:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 119 "idl.ll"
 return IDL_CASE;
-	YY_BREAK
+	TAO_YY_BREAK
 case 19:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 120 "idl.ll"
 return IDL_DEFAULT;
-	YY_BREAK
+	TAO_YY_BREAK
 case 20:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 121 "idl.ll"
 return IDL_FLOAT;
-	YY_BREAK
+	TAO_YY_BREAK
 case 21:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 122 "idl.ll"
 return IDL_DOUBLE;
-	YY_BREAK
+	TAO_YY_BREAK
 case 22:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 123 "idl.ll"
 return IDL_LONG;
-	YY_BREAK
+	TAO_YY_BREAK
 case 23:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 124 "idl.ll"
 return IDL_SHORT;
-	YY_BREAK
+	TAO_YY_BREAK
 case 24:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 125 "idl.ll"
 return IDL_UNSIGNED;
-	YY_BREAK
+	TAO_YY_BREAK
 case 25:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 126 "idl.ll"
 return IDL_CHAR;
-	YY_BREAK
+	TAO_YY_BREAK
 case 26:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 127 "idl.ll"
 return IDL_WCHAR;
-	YY_BREAK
+	TAO_YY_BREAK
 case 27:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 128 "idl.ll"
 return IDL_BOOLEAN;
-	YY_BREAK
+	TAO_YY_BREAK
 case 28:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 129 "idl.ll"
 return IDL_OCTET;
-	YY_BREAK
+	TAO_YY_BREAK
 case 29:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 130 "idl.ll"
 return IDL_VOID;
-	YY_BREAK
+	TAO_YY_BREAK
 case 30:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 131 "idl.ll"
 return IDL_NATIVE;
-	YY_BREAK
+	TAO_YY_BREAK
 case 31:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 133 "idl.ll"
 return IDL_TRUETOK;
-	YY_BREAK
+	TAO_YY_BREAK
 case 32:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 134 "idl.ll"
 return IDL_FALSETOK;
-	YY_BREAK
+	TAO_YY_BREAK
 case 33:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 136 "idl.ll"
 return IDL_INOUT;
-	YY_BREAK
+	TAO_YY_BREAK
 case 34:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 137 "idl.ll"
 return IDL_IN;
-	YY_BREAK
+	TAO_YY_BREAK
 case 35:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 138 "idl.ll"
 return IDL_OUT;
-	YY_BREAK
+	TAO_YY_BREAK
 case 36:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 139 "idl.ll"
 return IDL_ONEWAY;
-	YY_BREAK
+	TAO_YY_BREAK
 case 37:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 141 "idl.ll"
 return IDL_LEFT_SHIFT;
-	YY_BREAK
+	TAO_YY_BREAK
 case 38:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 142 "idl.ll"
 return IDL_RIGHT_SHIFT;
-	YY_BREAK
+	TAO_YY_BREAK
 case 39:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 143 "idl.ll"
 {
-		  yylval.strval = "::";
+		  tao_yylval.strval = "::";
 		  return IDL_SCOPE_DELIMITOR;
 		}
-	YY_BREAK
+	TAO_YY_BREAK
 case 40:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 148 "idl.ll"
 {
-    char *z = (char *) malloc(strlen(ace_yytext) + 1);
-    strcpy(z, ace_yytext);
-    yylval.strval = z;
+    char *z = (char *) malloc(strlen(ace_tao_yytext) + 1);
+    strcpy(z, ace_tao_yytext);
+    tao_yylval.strval = z;
     return IDENTIFIER;
 }
-	YY_BREAK
+	TAO_YY_BREAK
 case 41:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 155 "idl.ll"
 {
-                  yylval.dval = idl_atof(ace_yytext);
+                  tao_yylval.dval = idl_atof(ace_tao_yytext);
                   return IDL_FLOATING_PT_LITERAL;
                 }
-	YY_BREAK
+	TAO_YY_BREAK
 case 42:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 159 "idl.ll"
 {
-                  yylval.dval = idl_atof(ace_yytext);
+                  tao_yylval.dval = idl_atof(ace_tao_yytext);
                   return IDL_FLOATING_PT_LITERAL;
                 }
-	YY_BREAK
+	TAO_YY_BREAK
 case 43:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 164 "idl.ll"
 {
-		  yylval.ival = idl_atoi(ace_yytext, 10);
+		  tao_yylval.ival = idl_atoi(ace_tao_yytext, 10);
 		  return IDL_INTEGER_LITERAL;
 	        }
-	YY_BREAK
+	TAO_YY_BREAK
 case 44:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 168 "idl.ll"
 {
-		  yylval.ival = idl_atoi(ace_yytext, 16);
+		  tao_yylval.ival = idl_atoi(ace_tao_yytext, 16);
 		  return IDL_INTEGER_LITERAL;
 	        }
-	YY_BREAK
+	TAO_YY_BREAK
 case 45:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 172 "idl.ll"
 {
-		  yylval.ival = idl_atoi(ace_yytext, 8);
+		  tao_yylval.ival = idl_atoi(ace_tao_yytext, 8);
 		  return IDL_INTEGER_LITERAL;
 	      	}
-	YY_BREAK
+	TAO_YY_BREAK
 case 46:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 177 "idl.ll"
 {
 		  /* Skip the quotes */
-		  char *tmp = ace_yytext;
+		  char *tmp = ace_tao_yytext;
 		  tmp[strlen(tmp)-1] = '\0';
-		  yylval.sval = new String(tmp + 1);
+		  tao_yylval.sval = new String(tmp + 1);
 		  return IDL_STRING_LITERAL;
 	      	}
-	YY_BREAK
+	TAO_YY_BREAK
 case 47:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 184 "idl.ll"
 {
-		  yylval.cval = ace_yytext [1];
+		  tao_yylval.cval = ace_tao_yytext [1];
 		  return IDL_CHARACTER_LITERAL;
 	      	}
-	YY_BREAK
+	TAO_YY_BREAK
 case 48:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 188 "idl.ll"
 {
 		  // octal character constant
-		  yylval.cval = idl_escape_reader(ace_yytext + 1);
+		  tao_yylval.cval = idl_escape_reader(ace_tao_yytext + 1);
 		  return IDL_CHARACTER_LITERAL;
 		}
-	YY_BREAK
+	TAO_YY_BREAK
 case 49:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 193 "idl.ll"
 {
-		  yylval.cval = idl_escape_reader(ace_yytext + 1);
+		  tao_yylval.cval = idl_escape_reader(ace_tao_yytext + 1);
 		  return IDL_CHARACTER_LITERAL;
 		}
-	YY_BREAK
+	TAO_YY_BREAK
 case 50:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 197 "idl.ll"
 {/* remember pragma */
   		  idl_global->set_lineno(idl_global->lineno() + 1);
-		  idl_store_pragma(ace_yytext);
+		  idl_store_pragma(ace_tao_yytext);
 		}
-	YY_BREAK
+	TAO_YY_BREAK
 case 51:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 201 "idl.ll"
 {
-		  idl_parse_line_and_file(ace_yytext);
+		  idl_parse_line_and_file(ace_tao_yytext);
 		}
-	YY_BREAK
+	TAO_YY_BREAK
 case 52:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 204 "idl.ll"
 {
-		  idl_parse_line_and_file(ace_yytext);
+		  idl_parse_line_and_file(ace_tao_yytext);
 		}
-	YY_BREAK
+	TAO_YY_BREAK
 case 53:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 207 "idl.ll"
 {
-		  idl_parse_line_and_file(ace_yytext);
+		  idl_parse_line_and_file(ace_tao_yytext);
 		}
-	YY_BREAK
+	TAO_YY_BREAK
 case 54:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 210 "idl.ll"
 {
-		  idl_parse_line_and_file(ace_yytext);
+		  idl_parse_line_and_file(ace_tao_yytext);
 	        }
-	YY_BREAK
+	TAO_YY_BREAK
 case 55:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 213 "idl.ll"
 {
 		  /* ignore cpp ident */
   		  idl_global->set_lineno(idl_global->lineno() + 1);
 		}
-	YY_BREAK
+	TAO_YY_BREAK
 case 56:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 217 "idl.ll"
 {
 		  /* ignore comments */
   		  idl_global->set_lineno(idl_global->lineno() + 1);
 		}
-	YY_BREAK
+	TAO_YY_BREAK
 case 57:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 221 "idl.ll"
 {
 		  for(;;) {
-		    char c = yyinput();
+		    char c = tao_yyinput();
 		    if (c == '*') {
-		      char next = yyinput();
+		      char next = tao_yyinput();
 		      if (next == '/')
 			break;
 		      else
-			yyunput(c, NULL);
+			tao_yyunput(c, NULL);
 	              if (c == '\n')
 		        idl_global->set_lineno(idl_global->lineno() + 1);
 		    }
 	          }
 	        }
-	YY_BREAK
+	TAO_YY_BREAK
 case 58:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 235 "idl.ll"
 ;
-	YY_BREAK
+	TAO_YY_BREAK
 case 59:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 236 "idl.ll"
 {
   		  idl_global->set_lineno(idl_global->lineno() + 1);
 		}
-	YY_BREAK
+	TAO_YY_BREAK
 case 60:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 239 "idl.ll"
-return ace_yytext [0];
-	YY_BREAK
+return ace_tao_yytext [0];
+	TAO_YY_BREAK
 case 61:
-YY_USER_ACTION
+TAO_YY_USER_ACTION
 # line 241 "idl.ll"
 TAO_ECHO;
-	YY_BREAK
-case YY_STATE_EOF(INITIAL):
-	yyterminate();
+	TAO_YY_BREAK
+case TAO_YY_STATE_EOF(INITIAL):
+	tao_yyterminate();
 
-	case YY_END_OF_BUFFER:
+	case TAO_YY_END_OF_BUFFER:
 		{
 		/* Amount of text matched not including the EOB char. */
-		int yy_amount_of_matched_text = yy_cp - yytext_ptr - 1;
+		int tao_yy_amount_of_matched_text = tao_yy_cp - tao_yytext_ptr - 1;
 
-		/* Undo the effects of YY_DO_BEFORE_ACTION. */
-		*yy_cp = yy_hold_char;
+		/* Undo the effects of TAO_YY_DO_BEFORE_ACTION. */
+		*tao_yy_cp = tao_yy_hold_char;
 
-		if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+		if ( tao_yy_current_buffer->tao_yy_buffer_status == TAO_YY_BUFFER_NEW )
 			{
 			/* We're scanning a new file or input source.  It's
 			 * possible that this happened because the user
-			 * just pointed yyin at a new source and called
-			 * yylex().  If so, then we have to assure
-			 * consistency between yy_current_buffer and our
+			 * just pointed tao_yyin at a new source and called
+			 * tao_yylex().  If so, then we have to assure
+			 * consistency between tao_yy_current_buffer and our
 			 * globals.  Here is the right place to do so, because
 			 * this is the first action (other than possibly a
 			 * back-up) that will match for the new input source.
 			 */
-			yy_n_chars = yy_current_buffer->yy_n_chars;
-			yy_current_buffer->yy_input_file = yyin;
-			yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+			tao_yy_n_chars = tao_yy_current_buffer->tao_yy_n_chars;
+			tao_yy_current_buffer->tao_yy_input_file = tao_yyin;
+			tao_yy_current_buffer->tao_yy_buffer_status = TAO_YY_BUFFER_NORMAL;
 			}
 
-		/* Note that here we test for yy_c_buf_p "<=" to the position
-		 * of the first EOB in the buffer, since yy_c_buf_p will
+		/* Note that here we test for tao_yy_c_buf_p "<=" to the position
+		 * of the first EOB in the buffer, since tao_yy_c_buf_p will
 		 * already have been incremented past the NUL character
 		 * (since all states make transitions on EOB to the
 		 * end-of-buffer state).  Contrast this with the test
 		 * in input().
 		 */
-		if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+		if ( tao_yy_c_buf_p <= &tao_yy_current_buffer->tao_yy_ch_buf[tao_yy_n_chars] )
 			{ /* This was really a NUL. */
-			yy_state_type yy_next_state;
+			tao_yy_state_type tao_yy_next_state;
 
-			yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+			tao_yy_c_buf_p = tao_yytext_ptr + tao_yy_amount_of_matched_text;
 
-			yy_current_state = yy_get_previous_state();
+			tao_yy_current_state = tao_yy_get_previous_state();
 
 			/* Okay, we're now positioned to make the NUL
 			 * transition.  We couldn't have
-			 * yy_get_previous_state() go ahead and do it
+			 * tao_yy_get_previous_state() go ahead and do it
 			 * for us because it doesn't know how to deal
 			 * with the possibility of jamming (and we don't
 			 * want to build jamming into it because then it
 			 * will run more slowly).
 			 */
 
-			yy_next_state = yy_try_NUL_trans( yy_current_state );
+			tao_yy_next_state = tao_yy_try_NUL_trans( tao_yy_current_state );
 
-			yy_bp = yytext_ptr + YY_MORE_ADJ;
+			tao_yy_bp = tao_yytext_ptr + TAO_YY_MORE_ADJ;
 
-			if ( yy_next_state )
+			if ( tao_yy_next_state )
 				{
 				/* Consume the NUL. */
-				yy_cp = ++yy_c_buf_p;
-				yy_current_state = yy_next_state;
-				goto yy_match;
+				tao_yy_cp = ++tao_yy_c_buf_p;
+				tao_yy_current_state = tao_yy_next_state;
+				goto tao_yy_match;
 				}
 
 			else
 				{
-							yy_cp = yy_c_buf_p;
-				goto yy_find_action;
+							tao_yy_cp = tao_yy_c_buf_p;
+				goto tao_yy_find_action;
 				}
 			}
 
-		else switch ( yy_get_next_buffer() )
+		else switch ( tao_yy_get_next_buffer() )
 			{
 			case EOB_ACT_END_OF_FILE:
 				{
-				yy_did_buffer_switch_on_eof = 0;
+				tao_yy_did_buffer_switch_on_eof = 0;
 
-				if ( yywrap() )
+				if ( tao_yywrap() )
 					{
 					/* Note: because we've taken care in
-					 * yy_get_next_buffer() to have set up
-					 * yytext, we can now set up
-					 * yy_c_buf_p so that if some total
+					 * tao_yy_get_next_buffer() to have set up
+					 * tao_yytext, we can now set up
+					 * tao_yy_c_buf_p so that if some total
 					 * hoser (like flex itself) wants to
 					 * call the scanner after we return the
-					 * YY_NULL, it'll still work - another
-					 * YY_NULL will get returned.
+					 * TAO_YY_NULL, it'll still work - another
+					 * TAO_YY_NULL will get returned.
 					 */
-					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+					tao_yy_c_buf_p = tao_yytext_ptr + TAO_YY_MORE_ADJ;
 
-					yy_act = YY_STATE_EOF(YY_START);
+					tao_yy_act = TAO_YY_STATE_EOF(TAO_YY_START);
 					goto do_action;
 					}
 
 				else
 					{
-					if ( ! yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
+					if ( ! tao_yy_did_buffer_switch_on_eof )
+						TAO_YY_NEW_FILE;
 					}
 				break;
 				}
 
 			case EOB_ACT_CONTINUE_SCAN:
-				yy_c_buf_p =
-					yytext_ptr + yy_amount_of_matched_text;
+				tao_yy_c_buf_p =
+					tao_yytext_ptr + tao_yy_amount_of_matched_text;
 
-				yy_current_state = yy_get_previous_state();
+				tao_yy_current_state = tao_yy_get_previous_state();
 
-				yy_cp = yy_c_buf_p;
-				yy_bp = yytext_ptr + YY_MORE_ADJ;
-				goto yy_match;
+				tao_yy_cp = tao_yy_c_buf_p;
+				tao_yy_bp = tao_yytext_ptr + TAO_YY_MORE_ADJ;
+				goto tao_yy_match;
 
 			case EOB_ACT_LAST_MATCH:
-				yy_c_buf_p =
-				&yy_current_buffer->yy_ch_buf[yy_n_chars];
+				tao_yy_c_buf_p =
+				&tao_yy_current_buffer->tao_yy_ch_buf[tao_yy_n_chars];
 
-				yy_current_state = yy_get_previous_state();
+				tao_yy_current_state = tao_yy_get_previous_state();
 
-				yy_cp = yy_c_buf_p;
-				yy_bp = yytext_ptr + YY_MORE_ADJ;
-				goto yy_find_action;
+				tao_yy_cp = tao_yy_c_buf_p;
+				tao_yy_bp = tao_yytext_ptr + TAO_YY_MORE_ADJ;
+				goto tao_yy_find_action;
 			}
 		break;
 		}
 
 	default:
-		YY_FATAL_ERROR(
+		TAO_YY_FATAL_ERROR(
 			"fatal flex scanner internal error--no action found" );
 	} /* end of action switch */
 		} /* end of scanning one token */
-	} /* end of yylex */
+	} /* end of tao_yylex */
 
 
-/* yy_get_next_buffer - try to read in a new buffer
+/* tao_yy_get_next_buffer - try to read in a new buffer
  *
  * Returns a code representing an action:
  *	EOB_ACT_LAST_MATCH -
@@ -1338,20 +1339,20 @@ case YY_STATE_EOF(INITIAL):
  *	EOB_ACT_END_OF_FILE - end of file
  */
 
-static int yy_get_next_buffer()
+static int tao_yy_get_next_buffer()
 	{
-	register char *dest = yy_current_buffer->yy_ch_buf;
-	register char *source = yytext_ptr - 1; /* copy prev. char, too */
+	register char *dest = tao_yy_current_buffer->tao_yy_ch_buf;
+	register char *source = tao_yytext_ptr - 1; /* copy prev. char, too */
 	register int number_to_move, i;
 	int ret_val;
 
-	if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
-		YY_FATAL_ERROR(
+	if ( tao_yy_c_buf_p > &tao_yy_current_buffer->tao_yy_ch_buf[tao_yy_n_chars + 1] )
+		TAO_YY_FATAL_ERROR(
 		"fatal flex scanner internal error--end of buffer missed" );
 
-	if ( yy_current_buffer->yy_fill_buffer == 0 )
+	if ( tao_yy_current_buffer->tao_yy_fill_buffer == 0 )
 		{ /* Don't try to fill the buffer, so this is an EOF. */
-		if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+		if ( tao_yy_c_buf_p - tao_yytext_ptr - TAO_YY_MORE_ADJ == 1 )
 			{
 			/* We matched a singled characater, the EOB, so
 			 * treat this as a final EOF.
@@ -1371,466 +1372,466 @@ static int yy_get_next_buffer()
 	/* Try to read more data. */
 
 	/* First move last chars to start of buffer. */
-	number_to_move = yy_c_buf_p - yytext_ptr;
+	number_to_move = tao_yy_c_buf_p - tao_yytext_ptr;
 
 	for ( i = 0; i < number_to_move; ++i )
 		*(dest++) = *(source++);
 
-	if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+	if ( tao_yy_current_buffer->tao_yy_buffer_status == TAO_YY_BUFFER_EOF_PENDING )
 		/* don't do the read, it's not guaranteed to return an EOF,
 		 * just force an EOF
 		 */
-		yy_n_chars = 0;
+		tao_yy_n_chars = 0;
 
 	else
 		{
 		int num_to_read =
-			yy_current_buffer->yy_buf_size - number_to_move - 1;
+			tao_yy_current_buffer->tao_yy_buf_size - number_to_move - 1;
 
 		while ( num_to_read <= 0 )
 			{ /* Not enough room in the buffer - grow it. */
-#ifdef YY_USES_REJECT
-			YY_FATAL_ERROR(
+#ifdef TAO_YY_USES_REJECT
+			TAO_YY_FATAL_ERROR(
 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
 #else
 
 			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = yy_current_buffer;
+			TAO_YY_BUFFER_STATE b = tao_yy_current_buffer;
 
-			int yy_c_buf_p_offset = yy_c_buf_p - b->yy_ch_buf;
+			int tao_yy_c_buf_p_offset = tao_yy_c_buf_p - b->tao_yy_ch_buf;
 
-			b->yy_buf_size *= 2;
-			b->yy_ch_buf = (char *)
-				yy_flex_realloc( (void *) b->yy_ch_buf,
-						 b->yy_buf_size );
+			b->tao_yy_buf_size *= 2;
+			b->tao_yy_ch_buf = (char *)
+				tao_yy_flex_realloc( (void *) b->tao_yy_ch_buf,
+						 b->tao_yy_buf_size );
 
-			if ( ! b->yy_ch_buf )
-				YY_FATAL_ERROR(
+			if ( ! b->tao_yy_ch_buf )
+				TAO_YY_FATAL_ERROR(
 				"fatal error - scanner input buffer overflow" );
 
-			yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+			tao_yy_c_buf_p = &b->tao_yy_ch_buf[tao_yy_c_buf_p_offset];
 
-			num_to_read = yy_current_buffer->yy_buf_size -
+			num_to_read = tao_yy_current_buffer->tao_yy_buf_size -
 						number_to_move - 1;
 #endif
 			}
 
-		if ( num_to_read > YY_READ_BUF_SIZE )
-			num_to_read = YY_READ_BUF_SIZE;
+		if ( num_to_read > TAO_YY_READ_BUF_SIZE )
+			num_to_read = TAO_YY_READ_BUF_SIZE;
 
 		/* Read in more data. */
-		YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
-			yy_n_chars, num_to_read );
+		TAO_YY_INPUT( (&tao_yy_current_buffer->tao_yy_ch_buf[number_to_move]),
+			tao_yy_n_chars, num_to_read );
 		}
 
-	if ( yy_n_chars == 0 )
+	if ( tao_yy_n_chars == 0 )
 		{
-		if ( number_to_move - YY_MORE_ADJ == 1 )
+		if ( number_to_move - TAO_YY_MORE_ADJ == 1 )
 			{
 			ret_val = EOB_ACT_END_OF_FILE;
-			yyrestart( yyin );
+			tao_yyrestart( tao_yyin );
 			}
 
 		else
 			{
 			ret_val = EOB_ACT_LAST_MATCH;
-			yy_current_buffer->yy_buffer_status =
-				YY_BUFFER_EOF_PENDING;
+			tao_yy_current_buffer->tao_yy_buffer_status =
+				TAO_YY_BUFFER_EOF_PENDING;
 			}
 		}
 
 	else
 		ret_val = EOB_ACT_CONTINUE_SCAN;
 
-	yy_n_chars += number_to_move;
-	yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
-	yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+	tao_yy_n_chars += number_to_move;
+	tao_yy_current_buffer->tao_yy_ch_buf[tao_yy_n_chars] = TAO_YY_END_OF_BUFFER_CHAR;
+	tao_yy_current_buffer->tao_yy_ch_buf[tao_yy_n_chars + 1] = TAO_YY_END_OF_BUFFER_CHAR;
 
-	/* yytext begins at the second character in yy_ch_buf; the first
+	/* tao_yytext begins at the second character in tao_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
-	 * yy_get_previous_state() will have with '^' rules active.
+	 * tao_yy_get_previous_state() will have with '^' rules active.
 	 */
 
-	yytext_ptr = &yy_current_buffer->yy_ch_buf[1];
+	tao_yytext_ptr = &tao_yy_current_buffer->tao_yy_ch_buf[1];
 
 	return ret_val;
 	}
 
 
-/* yy_get_previous_state - get the state just before the EOB char was reached */
+/* tao_yy_get_previous_state - get the state just before the EOB char was reached */
 
-static yy_state_type yy_get_previous_state()
+static tao_yy_state_type tao_yy_get_previous_state()
 	{
-	register yy_state_type yy_current_state;
-	register char *yy_cp;
+	register tao_yy_state_type tao_yy_current_state;
+	register char *tao_yy_cp;
 
-	register char *yy_bp = yytext_ptr;
+	register char *tao_yy_bp = tao_yytext_ptr;
 
-	yy_current_state = yy_start;
-	if ( yy_bp[-1] == '\n' )
-		++yy_current_state;
+	tao_yy_current_state = tao_yy_start;
+	if ( tao_yy_bp[-1] == '\n' )
+		++tao_yy_current_state;
 
-	for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+	for ( tao_yy_cp = tao_yytext_ptr + TAO_YY_MORE_ADJ; tao_yy_cp < tao_yy_c_buf_p; ++tao_yy_cp )
 		{
-		register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
-		if ( yy_accept[yy_current_state] )
+		register TAO_YY_CHAR tao_yy_c = (*tao_yy_cp ? tao_yy_ec[TAO_YY_SC_TO_UI(*tao_yy_cp)] : 1);
+		if ( tao_yy_accept[tao_yy_current_state] )
 			{
-			yy_last_accepting_state = yy_current_state;
-			yy_last_accepting_cpos = yy_cp;
+			tao_yy_last_accepting_state = tao_yy_current_state;
+			tao_yy_last_accepting_cpos = tao_yy_cp;
 			}
-		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+		while ( tao_yy_chk[tao_yy_base[tao_yy_current_state] + tao_yy_c] != tao_yy_current_state )
 			{
-			yy_current_state = (int) yy_def[yy_current_state];
-			if ( yy_current_state >= 284 )
-				yy_c = yy_meta[(unsigned int) yy_c];
+			tao_yy_current_state = (int) tao_yy_def[tao_yy_current_state];
+			if ( tao_yy_current_state >= 284 )
+				tao_yy_c = tao_yy_meta[(unsigned int) tao_yy_c];
 			}
-		yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+		tao_yy_current_state = tao_yy_nxt[tao_yy_base[tao_yy_current_state] + (unsigned int) tao_yy_c];
 		}
 
-	return yy_current_state;
+	return tao_yy_current_state;
 	}
 
 
-/* yy_try_NUL_trans - try to make a transition on the NUL character
+/* tao_yy_try_NUL_trans - try to make a transition on the NUL character
  *
  * synopsis
- *	next_state = yy_try_NUL_trans( current_state );
+ *	next_state = tao_yy_try_NUL_trans( current_state );
  */
 
-#ifdef YY_USE_PROTOS
-static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+#ifdef TAO_YY_USE_PROTOS
+static tao_yy_state_type tao_yy_try_NUL_trans( tao_yy_state_type tao_yy_current_state )
 #else
-static yy_state_type yy_try_NUL_trans( yy_current_state )
-yy_state_type yy_current_state;
+static tao_yy_state_type tao_yy_try_NUL_trans( tao_yy_current_state )
+tao_yy_state_type tao_yy_current_state;
 #endif
 	{
-	register int yy_is_jam;
-	register char *yy_cp = yy_c_buf_p;
+	register int tao_yy_is_jam;
+	register char *tao_yy_cp = tao_yy_c_buf_p;
 
-	register YY_CHAR yy_c = 1;
-	if ( yy_accept[yy_current_state] )
+	register TAO_YY_CHAR tao_yy_c = 1;
+	if ( tao_yy_accept[tao_yy_current_state] )
 		{
-		yy_last_accepting_state = yy_current_state;
-		yy_last_accepting_cpos = yy_cp;
+		tao_yy_last_accepting_state = tao_yy_current_state;
+		tao_yy_last_accepting_cpos = tao_yy_cp;
 		}
-	while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+	while ( tao_yy_chk[tao_yy_base[tao_yy_current_state] + tao_yy_c] != tao_yy_current_state )
 		{
-		yy_current_state = (int) yy_def[yy_current_state];
-		if ( yy_current_state >= 284 )
-			yy_c = yy_meta[(unsigned int) yy_c];
+		tao_yy_current_state = (int) tao_yy_def[tao_yy_current_state];
+		if ( tao_yy_current_state >= 284 )
+			tao_yy_c = tao_yy_meta[(unsigned int) tao_yy_c];
 		}
-	yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-	yy_is_jam = (yy_current_state == 283);
+	tao_yy_current_state = tao_yy_nxt[tao_yy_base[tao_yy_current_state] + (unsigned int) tao_yy_c];
+	tao_yy_is_jam = (tao_yy_current_state == 283);
 
-	return yy_is_jam ? 0 : yy_current_state;
+	return tao_yy_is_jam ? 0 : tao_yy_current_state;
 	}
 
 
-#ifdef YY_USE_PROTOS
-static void yyunput( int c, register char *yy_bp )
+#ifdef TAO_YY_USE_PROTOS
+static void tao_yyunput( int c, register char *tao_yy_bp )
 #else
-static void yyunput( c, yy_bp )
+static void tao_yyunput( c, tao_yy_bp )
 int c;
-register char *yy_bp;
+register char *tao_yy_bp;
 #endif
 	{
-	register char *yy_cp = yy_c_buf_p;
+	register char *tao_yy_cp = tao_yy_c_buf_p;
 
-	/* undo effects of setting up yytext */
-	*yy_cp = yy_hold_char;
+	/* undo effects of setting up tao_yytext */
+	*tao_yy_cp = tao_yy_hold_char;
 
-	if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+	if ( tao_yy_cp < tao_yy_current_buffer->tao_yy_ch_buf + 2 )
 		{ /* need to shift things up to make room */
 		/* +2 for EOB chars. */
-		register int number_to_move = yy_n_chars + 2;
-		register char *dest = &yy_current_buffer->yy_ch_buf[
-					yy_current_buffer->yy_buf_size + 2];
+		register int number_to_move = tao_yy_n_chars + 2;
+		register char *dest = &tao_yy_current_buffer->tao_yy_ch_buf[
+					tao_yy_current_buffer->tao_yy_buf_size + 2];
 		register char *source =
-				&yy_current_buffer->yy_ch_buf[number_to_move];
+				&tao_yy_current_buffer->tao_yy_ch_buf[number_to_move];
 
-		while ( source > yy_current_buffer->yy_ch_buf )
+		while ( source > tao_yy_current_buffer->tao_yy_ch_buf )
 			*--dest = *--source;
 
-		yy_cp += dest - source;
-		yy_bp += dest - source;
-		yy_n_chars = yy_current_buffer->yy_buf_size;
+		tao_yy_cp += dest - source;
+		tao_yy_bp += dest - source;
+		tao_yy_n_chars = tao_yy_current_buffer->tao_yy_buf_size;
 
-		if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
-			YY_FATAL_ERROR( "flex scanner push-back overflow" );
+		if ( tao_yy_cp < tao_yy_current_buffer->tao_yy_ch_buf + 2 )
+			TAO_YY_FATAL_ERROR( "flex scanner push-back overflow" );
 		}
 
-	if ( yy_cp > yy_bp && yy_cp[-1] == '\n' )
-		yy_cp[-2] = '\n';
+	if ( tao_yy_cp > tao_yy_bp && tao_yy_cp[-1] == '\n' )
+		tao_yy_cp[-2] = '\n';
 
-	*--yy_cp = (char) c;
+	*--tao_yy_cp = (char) c;
 
 
-	/* Note: the formal parameter *must* be called "yy_bp" for this
+	/* Note: the formal parameter *must* be called "tao_yy_bp" for this
 	 * macro to now work correctly.
 	 */
-	YY_DO_BEFORE_ACTION; /* set up yytext again */
+	TAO_YY_DO_BEFORE_ACTION; /* set up tao_yytext again */
 	}
 
 
 #ifdef __cplusplus
-static int yyinput()
+static int tao_yyinput()
 #else
 static int input()
 #endif
 	{
 	int c;
 
-	*yy_c_buf_p = yy_hold_char;
+	*tao_yy_c_buf_p = tao_yy_hold_char;
 
-	if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+	if ( *tao_yy_c_buf_p == TAO_YY_END_OF_BUFFER_CHAR )
 		{
-		/* yy_c_buf_p now points to the character we want to return.
+		/* tao_yy_c_buf_p now points to the character we want to return.
 		 * If this occurs *before* the EOB characters, then it's a
 		 * valid NUL; if not, then we've hit the end of the buffer.
 		 */
-		if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+		if ( tao_yy_c_buf_p < &tao_yy_current_buffer->tao_yy_ch_buf[tao_yy_n_chars] )
 			/* This was really a NUL. */
-			*yy_c_buf_p = '\0';
+			*tao_yy_c_buf_p = '\0';
 
 		else
 			{ /* need more input */
-			yytext_ptr = yy_c_buf_p;
-			++yy_c_buf_p;
+			tao_yytext_ptr = tao_yy_c_buf_p;
+			++tao_yy_c_buf_p;
 
-			switch ( yy_get_next_buffer() )
+			switch ( tao_yy_get_next_buffer() )
 				{
 				case EOB_ACT_END_OF_FILE:
 					{
-					if ( yywrap() )
+					if ( tao_yywrap() )
 						{
-						yy_c_buf_p =
-						yytext_ptr + YY_MORE_ADJ;
+						tao_yy_c_buf_p =
+						tao_yytext_ptr + TAO_YY_MORE_ADJ;
 						return EOF;
 						}
 
-					YY_NEW_FILE;
+					TAO_YY_NEW_FILE;
 #ifdef __cplusplus
-					return yyinput();
+					return tao_yyinput();
 #else
 					return input();
 #endif
 					}
 
 				case EOB_ACT_CONTINUE_SCAN:
-					yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+					tao_yy_c_buf_p = tao_yytext_ptr + TAO_YY_MORE_ADJ;
 					break;
 
 				case EOB_ACT_LAST_MATCH:
 #ifdef __cplusplus
-					YY_FATAL_ERROR(
-					"unexpected last match in yyinput()" );
+					TAO_YY_FATAL_ERROR(
+					"unexpected last match in tao_yyinput()" );
 #else
-					YY_FATAL_ERROR(
+					TAO_YY_FATAL_ERROR(
 					"unexpected last match in input()" );
 #endif
 				}
 			}
 		}
 
-	c = *(unsigned char *) yy_c_buf_p;	/* cast for 8-bit char's */
-	*yy_c_buf_p = '\0';	/* preserve yytext */
-	yy_hold_char = *++yy_c_buf_p;
+	c = *(unsigned char *) tao_yy_c_buf_p;	/* cast for 8-bit char's */
+	*tao_yy_c_buf_p = '\0';	/* preserve tao_yytext */
+	tao_yy_hold_char = *++tao_yy_c_buf_p;
 
 	return c;
 	}
 
 
-#ifdef YY_USE_PROTOS
-void yyrestart( FILE *input_file )
+#ifdef TAO_YY_USE_PROTOS
+void tao_yyrestart( FILE *input_file )
 #else
-void yyrestart( input_file )
+void tao_yyrestart( input_file )
 FILE *input_file;
 #endif
 	{
-	if ( ! yy_current_buffer )
-		yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+	if ( ! tao_yy_current_buffer )
+		tao_yy_current_buffer = tao_yy_create_buffer( tao_yyin, TAO_YY_BUF_SIZE );
 
-	yy_init_buffer( yy_current_buffer, input_file );
-	yy_load_buffer_state();
+	tao_yy_init_buffer( tao_yy_current_buffer, input_file );
+	tao_yy_load_buffer_state();
 	}
 
 
-#ifdef YY_USE_PROTOS
-void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#ifdef TAO_YY_USE_PROTOS
+void tao_yy_switch_to_buffer( TAO_YY_BUFFER_STATE new_buffer )
 #else
-void yy_switch_to_buffer( new_buffer )
-YY_BUFFER_STATE new_buffer;
+void tao_yy_switch_to_buffer( new_buffer )
+TAO_YY_BUFFER_STATE new_buffer;
 #endif
 	{
-	if ( yy_current_buffer == new_buffer )
+	if ( tao_yy_current_buffer == new_buffer )
 		return;
 
-	if ( yy_current_buffer )
+	if ( tao_yy_current_buffer )
 		{
 		/* Flush out information for old buffer. */
-		*yy_c_buf_p = yy_hold_char;
-		yy_current_buffer->yy_buf_pos = yy_c_buf_p;
-		yy_current_buffer->yy_n_chars = yy_n_chars;
+		*tao_yy_c_buf_p = tao_yy_hold_char;
+		tao_yy_current_buffer->tao_yy_buf_pos = tao_yy_c_buf_p;
+		tao_yy_current_buffer->tao_yy_n_chars = tao_yy_n_chars;
 		}
 
-	yy_current_buffer = new_buffer;
-	yy_load_buffer_state();
+	tao_yy_current_buffer = new_buffer;
+	tao_yy_load_buffer_state();
 
 	/* We don't actually know whether we did this switch during
-	 * EOF (yywrap()) processing, but the only time this flag
-	 * is looked at is after yywrap() is called, so it's safe
+	 * EOF (tao_yywrap()) processing, but the only time this flag
+	 * is looked at is after tao_yywrap() is called, so it's safe
 	 * to go ahead and always set it.
 	 */
-	yy_did_buffer_switch_on_eof = 1;
+	tao_yy_did_buffer_switch_on_eof = 1;
 	}
 
 
-#ifdef YY_USE_PROTOS
-void yy_load_buffer_state( void )
+#ifdef TAO_YY_USE_PROTOS
+void tao_yy_load_buffer_state( void )
 #else
-void yy_load_buffer_state()
+void tao_yy_load_buffer_state()
 #endif
 	{
-	yy_n_chars = yy_current_buffer->yy_n_chars;
-	yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
-	yyin = yy_current_buffer->yy_input_file;
-	yy_hold_char = *yy_c_buf_p;
+	tao_yy_n_chars = tao_yy_current_buffer->tao_yy_n_chars;
+	tao_yytext_ptr = tao_yy_c_buf_p = tao_yy_current_buffer->tao_yy_buf_pos;
+	tao_yyin = tao_yy_current_buffer->tao_yy_input_file;
+	tao_yy_hold_char = *tao_yy_c_buf_p;
 	}
 
 
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#ifdef TAO_YY_USE_PROTOS
+TAO_YY_BUFFER_STATE tao_yy_create_buffer( FILE *file, int size )
 #else
-YY_BUFFER_STATE yy_create_buffer( file, size )
+TAO_YY_BUFFER_STATE tao_yy_create_buffer( file, size )
 FILE *file;
 int size;
 #endif
 	{
-	YY_BUFFER_STATE b;
+	TAO_YY_BUFFER_STATE b;
 
-	b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+	b = (TAO_YY_BUFFER_STATE) tao_yy_flex_alloc( sizeof( struct tao_yy_buffer_state ) );
 
 	if ( ! b )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+		TAO_YY_FATAL_ERROR( "out of dynamic memory in tao_yy_create_buffer()" );
 
-	b->yy_buf_size = size;
+	b->tao_yy_buf_size = size;
 
-	/* yy_ch_buf has to be 2 characters longer than the size given because
+	/* tao_yy_ch_buf has to be 2 characters longer than the size given because
 	 * we need to put in 2 end-of-buffer characters.
 	 */
-	b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+	b->tao_yy_ch_buf = (char *) tao_yy_flex_alloc( b->tao_yy_buf_size + 2 );
 
-	if ( ! b->yy_ch_buf )
-		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+	if ( ! b->tao_yy_ch_buf )
+		TAO_YY_FATAL_ERROR( "out of dynamic memory in tao_yy_create_buffer()" );
 
-	yy_init_buffer( b, file );
+	tao_yy_init_buffer( b, file );
 
 	return b;
 	}
 
 
-#ifdef YY_USE_PROTOS
-void yy_delete_buffer( YY_BUFFER_STATE b )
+#ifdef TAO_YY_USE_PROTOS
+void tao_yy_delete_buffer( TAO_YY_BUFFER_STATE b )
 #else
-void yy_delete_buffer( b )
-YY_BUFFER_STATE b;
+void tao_yy_delete_buffer( b )
+TAO_YY_BUFFER_STATE b;
 #endif
 	{
-	if ( b == yy_current_buffer )
-		yy_current_buffer = (YY_BUFFER_STATE) 0;
+	if ( b == tao_yy_current_buffer )
+		tao_yy_current_buffer = (TAO_YY_BUFFER_STATE) 0;
 
-	yy_flex_free( (void *) b->yy_ch_buf );
-	yy_flex_free( (void *) b );
+	tao_yy_flex_free( (void *) b->tao_yy_ch_buf );
+	tao_yy_flex_free( (void *) b );
 	}
 
 
-#ifdef YY_USE_PROTOS
-void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#ifdef TAO_YY_USE_PROTOS
+void tao_yy_init_buffer( TAO_YY_BUFFER_STATE b, FILE *file )
 #else
-void yy_init_buffer( b, file )
-YY_BUFFER_STATE b;
+void tao_yy_init_buffer( b, file )
+TAO_YY_BUFFER_STATE b;
 FILE *file;
 #endif
 	{
-	b->yy_input_file = file;
+	b->tao_yy_input_file = file;
 
 	/* We put in the '\n' and start reading from [1] so that an
 	 * initial match-at-newline will be true.
 	 */
 
-	b->yy_ch_buf[0] = '\n';
-	b->yy_n_chars = 1;
+	b->tao_yy_ch_buf[0] = '\n';
+	b->tao_yy_n_chars = 1;
 
 	/* 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->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
-	b->yy_ch_buf[2] = YY_END_OF_BUFFER_CHAR;
+	b->tao_yy_ch_buf[1] = TAO_YY_END_OF_BUFFER_CHAR;
+	b->tao_yy_ch_buf[2] = TAO_YY_END_OF_BUFFER_CHAR;
 
-	b->yy_buf_pos = &b->yy_ch_buf[1];
+	b->tao_yy_buf_pos = &b->tao_yy_ch_buf[1];
 
-	b->yy_is_interactive = file ? isatty( fileno(file) ) : 0;
+	b->tao_yy_is_interactive = file ? isatty( fileno(file) ) : 0;
 
-	b->yy_fill_buffer = 1;
+	b->tao_yy_fill_buffer = 1;
 
-	b->yy_buffer_status = YY_BUFFER_NEW;
+	b->tao_yy_buffer_status = TAO_YY_BUFFER_NEW;
 	}
 
 
 #if 0
-#ifdef YY_USE_PROTOS
-static void yy_push_state( int new_state )
+#ifdef TAO_YY_USE_PROTOS
+static void tao_yy_push_state( int new_state )
 #else
-static void yy_push_state( new_state )
+static void tao_yy_push_state( new_state )
 int new_state;
 #endif
 	{
-	if ( yy_start_stack_ptr >= yy_start_stack_depth )
+	if ( tao_yy_start_stack_ptr >= tao_yy_start_stack_depth )
 		{
 		int new_size;
 
-		yy_start_stack_depth += YY_START_STACK_INCR;
-		new_size = yy_start_stack_depth * sizeof( int );
+		tao_yy_start_stack_depth += TAO_YY_START_STACK_INCR;
+		new_size = tao_yy_start_stack_depth * sizeof( int );
 
-		if ( ! yy_start_stack )
-			yy_start_stack = (int *) yy_flex_alloc( new_size );
+		if ( ! tao_yy_start_stack )
+			tao_yy_start_stack = (int *) tao_yy_flex_alloc( new_size );
 
 		else
-			yy_start_stack = (int *) yy_flex_realloc(
-					(void *) yy_start_stack, new_size );
+			tao_yy_start_stack = (int *) tao_yy_flex_realloc(
+					(void *) tao_yy_start_stack, new_size );
 
-		if ( ! yy_start_stack )
-			YY_FATAL_ERROR(
+		if ( ! tao_yy_start_stack )
+			TAO_YY_FATAL_ERROR(
 			"out of memory expanding start-condition stack" );
 		}
 
-	yy_start_stack[yy_start_stack_ptr++] = YY_START;
+	tao_yy_start_stack[tao_yy_start_stack_ptr++] = TAO_YY_START;
 
 	BEGIN(new_state);
 	}
 
 
-static void yy_pop_state()
+static void tao_yy_pop_state()
 	{
-	if ( --yy_start_stack_ptr < 0 )
-		YY_FATAL_ERROR( "start-condition stack underflow" );
+	if ( --tao_yy_start_stack_ptr < 0 )
+		TAO_YY_FATAL_ERROR( "start-condition stack underflow" );
 
-	BEGIN(yy_start_stack[yy_start_stack_ptr]);
+	BEGIN(tao_yy_start_stack[tao_yy_start_stack_ptr]);
 	}
 
 
-static int yy_top_state()
+static int tao_yy_top_state()
 	{
-	return yy_start_stack[yy_start_stack_ptr - 1];
+	return tao_yy_start_stack[tao_yy_start_stack_ptr - 1];
 	}
 #endif /* 0 */
 
-#ifdef YY_USE_PROTOS
-static void yy_fatal_error( const char msg[] )
+#ifdef TAO_YY_USE_PROTOS
+static void tao_yy_fatal_error( const char msg[] )
 #else
-static void yy_fatal_error( msg )
+static void tao_yy_fatal_error( msg )
 char msg[];
 #endif
 	{
@@ -1840,29 +1841,29 @@ char msg[];
 
 
 
-/* Redefine yyless() so it works in section 3 code. */
+/* Redefine tao_yyless() so it works in section 3 code. */
 
-#undef yyless
-#define yyless(n) \
+#undef tao_yyless
+#define tao_yyless(n) \
 	do \
 		{ \
-		/* Undo effects of setting up yytext. */ \
-		yytext[yyleng] = yy_hold_char; \
-		yy_c_buf_p = yytext + n - YY_MORE_ADJ; \
-		yy_hold_char = *yy_c_buf_p; \
-		*yy_c_buf_p = '\0'; \
-		yyleng = n; \
+		/* Undo effects of setting up tao_yytext. */ \
+		tao_yytext[tao_yyleng] = tao_yy_hold_char; \
+		tao_yy_c_buf_p = tao_yytext + n - TAO_YY_MORE_ADJ; \
+		tao_yy_hold_char = *tao_yy_c_buf_p; \
+		*tao_yy_c_buf_p = '\0'; \
+		tao_yyleng = n; \
 		} \
 	while ( 0 )
 
 
 /* Internal utility routines. */
 
-#ifndef yytext_ptr
-#ifdef YY_USE_PROTOS
-static void yy_flex_strncpy( char *s1, const char *s2, int n )
+#ifndef tao_yytext_ptr
+#ifdef TAO_YY_USE_PROTOS
+static void tao_yy_flex_strncpy( char *s1, const char *s2, int n )
 #else
-static void yy_flex_strncpy( s1, s2, n )
+static void tao_yy_flex_strncpy( s1, s2, n )
 char *s1;
 const char *s2;
 int n;
@@ -1875,20 +1876,20 @@ int n;
 #endif
 
 
-#ifdef YY_USE_PROTOS
-static void *yy_flex_alloc( unsigned int size )
+#ifdef TAO_YY_USE_PROTOS
+static void *tao_yy_flex_alloc( unsigned int size )
 #else
-static void *yy_flex_alloc( size )
+static void *tao_yy_flex_alloc( size )
 unsigned int size;
 #endif
 	{
 	return (void *) malloc( size );
 	}
 
-#ifdef YY_USE_PROTOS
-static void *yy_flex_realloc( void *ptr, unsigned int size )
+#ifdef TAO_YY_USE_PROTOS
+static void *tao_yy_flex_realloc( void *ptr, unsigned int size )
 #else
-static void *yy_flex_realloc( ptr, size )
+static void *tao_yy_flex_realloc( ptr, size )
 void *ptr;
 unsigned int size;
 #endif
@@ -1896,10 +1897,10 @@ unsigned int size;
 	return (void *) realloc( ptr, size );
 	}
 
-#ifdef YY_USE_PROTOS
-static void yy_flex_free( void *ptr )
+#ifdef TAO_YY_USE_PROTOS
+static void tao_yy_flex_free( void *ptr )
 #else
-static void yy_flex_free( ptr )
+static void tao_yy_flex_free( ptr )
 void *ptr;
 #endif
 	{
diff --git a/TAO/TAO_IDL/fe/lex.yy.cpp.diff b/TAO/TAO_IDL/fe/lex.yy.cpp.diff
index bd03e464bb7..755fc736937 100644
--- a/TAO/TAO_IDL/fe/lex.yy.cpp.diff
+++ b/TAO/TAO_IDL/fe/lex.yy.cpp.diff
@@ -1,34 +1,34 @@
 --- lex.yy.cpp.orig	Mon Mar 23 15:30:42 1998
 +++ lex.yy.cpp	Mon Mar 23 15:30:42 1998
 @@ -215,12 +215,14 @@
- void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
- void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+ void tao_yy_delete_buffer TAO_YY_PROTO(( TAO_YY_BUFFER_STATE b ));
+ void tao_yy_init_buffer TAO_YY_PROTO(( TAO_YY_BUFFER_STATE b, FILE *file ));
  
 +#if 0
- static int yy_start_stack_ptr = 0;
- static int yy_start_stack_depth = 0;
- static int *yy_start_stack = 0;
- static void yy_push_state YY_PROTO(( int new_state ));
- static void yy_pop_state YY_PROTO(( void ));
- static int yy_top_state YY_PROTO(( void ));
+ static int tao_yy_start_stack_ptr = 0;
+ static int tao_yy_start_stack_depth = 0;
+ static int *tao_yy_start_stack = 0;
+ static void tao_yy_push_state TAO_YY_PROTO(( int new_state ));
+ static void tao_yy_pop_state TAO_YY_PROTO(( void ));
+ static int tao_yy_top_state TAO_YY_PROTO(( void ));
 +#endif /* 0 */
  
- static void *yy_flex_alloc YY_PROTO(( unsigned int ));
- static void *yy_flex_realloc YY_PROTO(( void *, unsigned int ));
+ static void *tao_yy_flex_alloc TAO_YY_PROTO(( unsigned int ));
+ static void *tao_yy_flex_realloc TAO_YY_PROTO(( void *, unsigned int ));
 @@ -1777,6 +1779,7 @@
  	}
  
  
 +#if 0
- #ifdef YY_USE_PROTOS
- static void yy_push_state( int new_state )
+ #ifdef TAO_YY_USE_PROTOS
+ static void tao_yy_push_state( int new_state )
  #else
 @@ -1822,7 +1825,7 @@
  	{
- 	return yy_start_stack[yy_start_stack_ptr - 1];
+ 	return tao_yy_start_stack[tao_yy_start_stack_ptr - 1];
  	}
 -
 +#endif /* 0 */
  
- #ifdef YY_USE_PROTOS
- static void yy_fatal_error( const char msg[] )
+ #ifdef TAO_YY_USE_PROTOS
+ static void tao_yy_fatal_error( const char msg[] )
diff --git a/TAO/TAO_IDL/fe/y.tab.cpp b/TAO/TAO_IDL/fe/y.tab.cpp
index f9e59cce461..25e4ae2e8dc 100644
--- a/TAO/TAO_IDL/fe/y.tab.cpp
+++ b/TAO/TAO_IDL/fe/y.tab.cpp
@@ -1,27 +1,29 @@
-#ifndef lint
-char yysccsid[] = "@(#)yaccpar	1.4 (Berkeley) 02/25/90 \n\
- Modified 5/2/90 by J. Roskind to support graphic debugging modes";
-#endif
-#line 74 "idl.yy"
+// $Id$
+# line 74 "idl.tao_yy"
 #include "idl.h"
 #include "idl_extern.h"
 #include "fe_private.h"
 #include <stdio.h>
 
 #if (defined(apollo) || defined(hpux)) && defined(__cplusplus)
-extern	"C" int yywrap();
-#endif	/* (defined(apollo) || defined(hpux)) && defined(__cplusplus)*/
-
-void yyerror (char *);
-int yylex (void);
-extern "C" int yywrap (void);
-extern char yytext[];
-extern int yyleng;
-#define YYDEBUG_LEXER_TEXT (yytext[yyleng] = '\0', yytext)
-/* Force the pretty debugging code to compile.*/
-#define YYDEBUG 1
-#line 97 "idl.yy"
-typedef union {
+extern	"C" int tao_yywrap();
+#endif	// (defined(apollo) || defined(hpux)) && defined(__cplusplus)
+
+void tao_yyerror (char *);
+int tao_yylex (void);
+extern "C" int tao_yywrap (void);
+extern char tao_yytext[];
+extern int tao_yyleng;
+#define TAO_YYDEBUG_LEXER_TEXT (tao_yytext[tao_yyleng] = '\0', tao_yytext)
+// Force the pretty debugging code to compile.
+#define TAO_YYDEBUG 1
+
+# line 97 "idl.tao_yy"
+typedef union
+#ifdef __cplusplus
+	TAO_YYSTYPE
+#endif
+ {
   AST_Decl		*dcval;		/* Decl value		*/
   UTL_StrList		*slval;		/* String list		*/
   UTL_NameList		*nlval;		/* Name list		*/
@@ -46,757 +48,108 @@ typedef union {
   char			*strval;	/* char * value		*/
   Identifier		*idval;		/* Identifier		*/
   UTL_IdList		*idlist;	/* Identifier list	*/
-} YYSTYPE;
-#line 51 "y.tab.c"
-#define IDENTIFIER 257
-#define IDL_CONST 258
-#define IDL_MODULE 259
-#define IDL_INTERFACE 260
-#define IDL_TYPEDEF 261
-#define IDL_LONG 262
-#define IDL_SHORT 263
-#define IDL_UNSIGNED 264
-#define IDL_DOUBLE 265
-#define IDL_FLOAT 266
-#define IDL_CHAR 267
-#define IDL_WCHAR 268
-#define IDL_OCTET 269
-#define IDL_BOOLEAN 270
-#define IDL_ANY 271
-#define IDL_STRUCT 272
-#define IDL_UNION 273
-#define IDL_SWITCH 274
-#define IDL_ENUM 275
-#define IDL_SEQUENCE 276
-#define IDL_STRING 277
-#define IDL_WSTRING 278
-#define IDL_EXCEPTION 279
-#define IDL_CASE 280
-#define IDL_DEFAULT 281
-#define IDL_READONLY 282
-#define IDL_ATTRIBUTE 283
-#define IDL_ONEWAY 284
-#define IDL_IDEMPOTENT 285
-#define IDL_VOID 286
-#define IDL_IN 287
-#define IDL_OUT 288
-#define IDL_INOUT 289
-#define IDL_RAISES 290
-#define IDL_CONTEXT 291
-#define IDL_NATIVE 292
-#define IDL_INTEGER_LITERAL 293
-#define IDL_STRING_LITERAL 294
-#define IDL_CHARACTER_LITERAL 295
-#define IDL_FLOATING_PT_LITERAL 296
-#define IDL_TRUETOK 297
-#define IDL_FALSETOK 298
-#define IDL_SCOPE_DELIMITOR 299
-#define IDL_LEFT_SHIFT 300
-#define IDL_RIGHT_SHIFT 301
-#define YYERRCODE 256
-short yylhs[] = {                                        -1,
-    0,   67,   67,   69,   68,   71,   68,   73,   68,   75,
-   68,   77,   68,   78,   68,   79,   80,   81,   82,   76,
-   74,   74,   85,   87,   88,   83,   89,   64,   32,   90,
-   22,   22,   86,   86,   92,   91,   93,   91,   94,   91,
-   96,   91,   98,   91,   99,   91,   20,  100,   21,   21,
-   16,  101,   16,  102,   16,   65,   84,  103,  104,  105,
-  106,   70,   48,   48,   48,   48,   48,   48,   48,   48,
-   33,   34,   35,   35,   36,   36,   37,   37,   38,   38,
-   38,   39,   39,   39,   40,   40,   40,   40,   41,   41,
-   41,   41,   42,   42,   42,   43,   43,   43,   43,   43,
-   43,   44,  108,   66,   66,   66,   66,   66,  109,  107,
-    1,    1,    2,    2,    2,   56,   56,   56,   56,   56,
-   56,    4,    4,    4,    3,    3,    3,   28,  110,   29,
-   29,   60,   60,   30,  111,   31,   31,   61,   62,   49,
-   49,   54,   54,   54,   55,   55,   55,   52,   52,   52,
-   50,   50,   57,   51,   53,  112,  113,  115,  116,    7,
-  114,  118,  118,  119,  120,  117,  121,  117,  122,  123,
-  124,  125,  126,  127,  129,  130,   10,    9,    9,    9,
-    9,    9,    9,  128,  132,  132,  133,  134,  131,  135,
-  131,   26,   27,   27,  136,   46,  137,  138,   46,  139,
-   47,  140,  141,  143,  144,    8,  142,  147,  146,  146,
-  145,  148,  149,    5,    5,  150,  151,   13,  153,  154,
-    6,    6,  152,  156,  157,   14,   14,  155,  158,   11,
-   24,   25,   25,  159,  160,   45,  161,  162,   95,   63,
-   63,  163,  164,  165,  166,   72,  167,  169,  170,  171,
-   97,   59,   59,   59,   12,   12,  172,  168,  174,  168,
-  173,  177,  176,  176,  178,  179,  175,   15,   15,   15,
-   58,   58,   58,  180,  181,   23,   23,  182,  183,   17,
-   17,   18,  184,   19,   19,
-};
-short yylen[] = {                                         2,
-    1,    2,    0,    0,    3,    0,    3,    0,    3,    0,
-    3,    0,    3,    0,    3,    0,    0,    0,    0,    9,
-    1,    1,    0,    0,    0,    7,    0,    3,    2,    0,
-    3,    0,    2,    0,    0,    3,    0,    3,    0,    3,
-    0,    3,    0,    3,    0,    3,    2,    0,    4,    0,
-    1,    0,    3,    0,    4,    1,    1,    0,    0,    0,
-    0,    9,    1,    1,    1,    1,    1,    1,    1,    1,
-    1,    1,    1,    3,    1,    3,    1,    3,    1,    3,
-    3,    1,    3,    3,    1,    3,    3,    3,    1,    2,
-    2,    2,    1,    1,    3,    1,    1,    1,    1,    1,
-    1,    1,    0,    3,    1,    1,    1,    2,    0,    3,
-    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-    1,    1,    1,    1,    1,    1,    1,    2,    0,    4,
-    0,    1,    1,    2,    0,    4,    0,    1,    1,    1,
-    1,    1,    2,    1,    2,    3,    2,    1,    1,    2,
-    1,    1,    1,    1,    1,    0,    0,    0,    0,    9,
-    2,    2,    0,    0,    0,    5,    0,    3,    0,    0,
-    0,    0,    0,    0,    0,    0,   17,    1,    1,    1,
-    1,    1,    1,    2,    2,    0,    0,    0,    5,    0,
-    3,    2,    2,    0,    0,    3,    0,    0,    5,    0,
-    3,    0,    0,    0,    0,    9,    2,    0,    4,    0,
-    1,    0,    0,    6,    2,    0,    0,    5,    0,    0,
-    6,    1,    1,    0,    0,    6,    1,    1,    0,    3,
-    2,    2,    0,    0,    0,    5,    0,    0,    6,    1,
-    0,    0,    0,    0,    0,    9,    0,    0,    0,    0,
-   10,    1,    1,    0,    1,    1,    0,    3,    0,    4,
-    2,    0,    4,    0,    0,    0,    5,    1,    1,    1,
-    1,    1,    1,    0,    0,    6,    0,    0,    0,    6,
-    0,    2,    0,    4,    0,
-};
-short yydefred[] = {                                      0,
-   14,   58,   16,   27,  103,  156,  169,  202,  242,    0,
-    0,  105,  107,  106,   23,    0,    4,    1,    0,    6,
-    8,   10,   12,   21,   22,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,   56,  108,  138,    0,   30,   29,
-    0,    2,    0,    0,    0,    0,   15,    0,  144,    0,
-  148,  149,  151,  152,  153,  154,  223,  228,   52,   68,
-   69,    0,   59,   63,   64,   66,   67,  140,  141,   65,
-   51,    0,    0,   17,   28,  155,  216,  109,  111,  112,
-  114,  122,  123,  125,  127,  126,    0,  124,    0,  116,
-  118,  119,  117,  121,  113,  120,  104,  157,  170,  203,
-  243,   24,    0,    5,    7,    9,   11,   13,  143,  150,
-    0,  147,    0,   54,    0,  219,  224,    0,    0,    0,
-  212,  215,    0,    0,    0,    0,   34,    0,   31,  146,
-   53,    0,   60,    0,    0,   18,  217,  139,  110,  131,
-  132,  133,    0,    0,  158,  171,  204,  244,    0,    0,
-   55,    0,   96,   97,   98,   99,  100,  101,    0,    0,
-    0,    0,    0,  102,    0,    0,    0,    0,    0,    0,
-   85,   89,   94,  220,  225,    0,    0,    0,    0,  213,
-    0,    0,    0,  163,   45,  240,  252,  253,    0,    0,
-   35,   37,   39,    0,   33,   41,   43,   48,   61,   90,
-   91,   92,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,   19,  218,  129,  234,  230,
-  233,    0,  167,  164,  159,  163,  172,  211,  205,  210,
-    0,    0,  256,  269,  247,  255,    0,  268,  237,    0,
-    0,    0,   26,    0,    0,    0,    0,   95,    0,    0,
-    0,    0,    0,    0,    0,   86,   87,   88,  221,  226,
-    0,    0,    0,    0,  214,    0,    0,    0,    0,    0,
-    0,    0,  162,    0,   46,    0,    0,   36,   38,   40,
-   42,   44,    0,   62,   71,   20,  130,  235,  232,  168,
-  165,  160,    0,  182,  173,    0,  178,  179,  181,  180,
-  206,  208,  246,  248,  238,    0,    0,    0,    0,    0,
-    0,  236,  166,  174,  209,    0,  249,  239,  137,    0,
-    0,    0,    0,    0,  175,  258,  271,  272,  273,  265,
-    0,  264,  274,  250,  135,    0,    0,  260,    0,    0,
-    0,    0,  190,  197,  195,  187,  194,  176,  186,  266,
-  262,  275,  278,  251,  136,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,  191,  198,  196,  200,
-  188,  193,  177,  185,  267,  263,    0,  279,    0,    0,
-    0,  276,    0,  199,  201,  189,  285,    0,    0,  280,
-  283,    0,  284,
-};
-short yydgoto[] = {                                      11,
-  224,   79,   80,   81,   82,   83,   84,   85,  295,   86,
-  138,  235,   87,   88,  236,  163,  354,  388,  389,  129,
-  150,   40,  334,  220,  264,  346,  360,  139,  178,  318,
-  324,   15,  284,  164,  165,  166,  167,  168,  169,  170,
-  171,  172,  173,  174,  221,  347,  371,   63,   90,   91,
-   92,   93,   94,   68,   69,   95,   96,  330,  189,  140,
-  141,  142,  190,   16,   71,   17,   18,   19,   41,   20,
-   43,   21,   44,   22,   45,   23,   46,   26,   28,  118,
-  176,  261,   24,   25,   38,  149,  127,  194,   29,  103,
-  195,  240,  241,  242,  196,  244,  197,  245,  232,  246,
-  113,  132,   27,  115,  152,  247,   97,   30,  120,  262,
-  342,   31,  123,  225,  181,  268,  273,  231,  267,  307,
-  266,   32,  124,  182,  270,  308,  320,  348,  336,  361,
-  349,  362,  359,  381,  356,  358,  357,  379,  380,   33,
-  125,  229,  183,  271,  230,  272,  309,  144,  222,  119,
-  177,   72,  134,  214,   73,  135,  215,  179,  263,  306,
-  277,  311,   34,  126,  184,  274,  276,  317,  310,  323,
-  341,  321,  331,  322,  332,  339,  364,  337,  363,  340,
-  365,  366,  383,  392,
-};
-short yysindex[] = {                                    333,
-    0,    0,    0,    0,    0,    0,    0,    0,    0, -194,
-    0,    0,    0,    0,    0,   10,    0,    0,  333,    0,
-    0,    0,    0,    0,    0,   25,  254, -177, -194,  162,
- -194, -194, -194, -194,    0,    0,    0,  -34,    0,    0,
-   47,    0,   52,   61,   78,  103,    0,  -54,    0, -187,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0, -131,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  126,  150,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,   77,    0, -131,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0, -183,    0,    0,    0,    0,    0,    0,    0,
-  -90,    0, -194,    0, -194,    0,    0,   72,  152, -194,
-    0,    0,   95,  -53,  119,  122,    0, -131,    0,    0,
-    0, -194,    0,   26,   26,    0,    0,    0,    0,    0,
-    0,    0,    0,   26,    0,    0,    0,    0,  303,  212,
-    0,  209,    0,    0,    0,    0,    0,    0,  -30,  -30,
-  -30,   26, -131,    0,  156,  182,  246, -154,  159,   89,
-    0,    0,    0,    0,    0,  333,  211,  242,  196,    0,
-  137,  248,   32,    0,    0,    0,    0,    0,  228,   13,
-    0,    0,    0,  165,    0,    0,    0,    0,    0,    0,
-    0,    0,  250,   26,   26,   26,   26,   26,   26,   26,
-   26,   26,   26,  230,  235,    0,    0,    0,    0,    0,
-    0,  236,    0,    0,    0,    0,    0,    0,    0,    0,
-  137,  243,    0,    0,    0,    0, -131,    0,    0,  245,
-  247,  249,    0,  251,  253, -183,   26,    0,  182,  246,
- -154,  159,  159,   89,   89,    0,    0,    0,    0,    0,
-  180, -194,   26,  196,    0,  257, -194,  188,  137,  287,
-  192,  263,    0,  193,    0,   71,  271,    0,    0,    0,
-    0,    0, -131,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,   67,    0,    0, -131,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,  238,  277,  296,   32,  298,
- -194,    0,    0,    0,    0,    0,    0,    0,    0,  219,
-  302,  -63,   55,  300,    0,    0,    0,    0,    0,    0,
-  305,    0,    0,    0,    0,  -74,  271,    0,  304,  307,
-   58, -194,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,  293,   26,  297,  162, -102,
-  229,  -74, -194,  -63, -183,  318,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,  319,    0,  301, -194,
-  306,    0,   69,    0,    0,    0,    0,  323,  324,    0,
-    0,   79,    0,
-};
-short yyrindex[] = {                                    371,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,  -27,    0,    0,   17,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,  -19,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  115,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,   28,   38,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,   57,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    5,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    4,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,   94,    0,    0,    0,    0,    0,  112,    9,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,  -29,    0,   99,  129,  155,  107,   50,   -7,
-    0,    0,    0,    0,    0,  259,    0,  326,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-  261,    0,    0,    0,    0,    0,  130,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,  157,  268,
-  135,   56,   66,   -1,   40,    0,    0,    0,    0,    0,
-    0,    0,    0,  140,    0,    0,    0,    0,  265,    0,
-    0,  266,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,   18,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,  347,    0,    0,  355,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,  -14,    0,    0,    0,    0,
-    0,    0,  -56,  338,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,  375,    0,
-  251,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  187,
-    0,  292,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,  377,    0,
-    0,    0,    0,
-};
-short yygindex[] = {                                      0,
-  -24,  244,    0,    0,    0,  -22,   54,    7,    0,   60,
-    0,    0,    0,  393, -207,  -26,    0,    0,    0,   76,
-    0,    0,    0,    0,    0,    0,    0,  175,    0,    0,
-    0,    0,    0, -134,    0,  218,  240,  217,   39,   51,
-   21,   80,    0,  -88,  179,   86,    0,    0,  -16,  -12,
-    8,  420,    0,    0,    0, -148,   12,    0,    0, -209,
-   -8,    0,    0,    0,  -10,  299,    1,    0,    0,  317,
-    0,  320,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,  286,  258,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-  108,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  163,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  136,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,
-};
-#define YYTABLESIZE 625
-short yytable[] = {                                      37,
-   62,   36,  277,   89,   60,   78,   13,   93,   93,  162,
-   64,   93,   93,   93,   65,   93,    3,   93,   75,   42,
-   98,   99,  100,  101,  142,   13,  257,  203,   93,   93,
-   82,   57,   93,   82,   66,   82,   83,   82,   70,   83,
-  238,   83,  142,   83,   50,  145,  175,   50,  145,   47,
-   82,   82,  287,   12,   82,  180,   83,   83,   49,   14,
-   83,   49,   35,   93,   93,  162,  145,   39,  159,  305,
-  160,  222,   12,   35,  111,  112,  128,   84,   14,   74,
-   84,  227,   84,   47,   84,   82,   82,   79,  102,  222,
-   79,   83,   83,   80,   93,   32,   80,   84,   84,  227,
-  115,   84,  131,   81,  133,  104,   81,   79,   79,  143,
-  105,   79,  285,   80,   80,   59,   82,   80,  115,  106,
-  121,  151,   83,   81,   81,  213,   50,   81,  238,  350,
-  211,   47,   84,   84,  138,  212,  107,  138,  122,   72,
-   49,    3,   79,   79,   77,  207,  208,   77,   80,   80,
-   89,  161,  138,  375,   89,   13,   72,   72,   81,   81,
-   72,  108,  237,   84,   77,   77,  234,  114,   77,   73,
-  385,  130,   78,   79,  288,   78,  216,  344,  345,   80,
-  231,  343,   13,  231,  229,  116,   73,   73,  238,   81,
-   73,   72,   78,   78,  136,   75,   78,   74,  231,   77,
-   77,  209,   12,  210,   89,  344,  345,  109,   14,  117,
-  110,  137,   75,   75,   74,   74,   75,  145,   74,  283,
-  146,   73,  368,  327,  328,  329,   35,   78,   78,   12,
-   77,  256,  257,  258,  277,   14,   25,  142,  200,  201,
-  202,  147,   89,  296,  148,  252,  253,   75,   75,   74,
-  237,  143,   73,  297,  234,  198,  143,  298,   78,  254,
-  255,  145,  153,  154,  155,  156,  157,  158,   59,  199,
-   93,   93,  259,  259,  259,  205,  294,  299,   75,  204,
-   74,  300,   35,  206,  222,  218,  219,  227,  228,  243,
-  248,  259,   82,   82,  227,  239,  260,  265,   83,   83,
-   37,  275,  319,  278,  286,  279,  302,  280,   76,  281,
-  237,  282,  292,  115,  234,  290,  301,  303,  153,  154,
-  155,  156,  157,  158,   59,   76,   76,  304,  109,   76,
-  312,   37,   89,  355,  370,  313,  314,  316,  128,   84,
-   84,  325,  326,  335,  333,  338,  352,  351,  353,   79,
-   79,  367,  143,  373,  369,   80,   80,  378,  384,  382,
-   76,   76,  387,  390,  386,   81,   81,  391,  254,  143,
-    3,   70,  393,  254,  254,  254,  254,  254,  254,  254,
-  254,  254,  254,    3,  128,  245,  270,  142,  254,  161,
-  207,   76,  223,   35,  241,  183,  134,  254,   48,   49,
-   50,   51,   52,   53,   54,   55,   56,   76,    6,    7,
-  254,    8,   77,   57,   58,  261,  184,  282,   35,   61,
-  217,  249,  251,   48,   49,   50,   51,   52,   53,   54,
-   55,   56,   76,    6,    7,   59,    8,   77,   57,   58,
-  377,  291,  289,  192,  250,  372,   67,  191,  192,  192,
-  192,  192,  192,  192,  192,  192,  192,  192,  192,  192,
-   59,  192,  192,  192,  192,  192,  226,   35,  193,  374,
-    0,  315,   48,   49,   50,   51,   52,   53,   54,   55,
-   56,   76,    0,  269,   35,  192,   77,   57,   58,   48,
-   49,   50,   51,   52,   53,   54,   55,   56,   76,  376,
-    0,    0,    0,    0,   57,    0,    0,    0,    0,   59,
-   35,    0,    0,  233,    0,   48,   49,   50,   51,   52,
-   53,   54,   55,   56,    0,    0,   59,   35,    0,    0,
-   57,   58,   48,   49,   50,   51,   52,   53,   54,   55,
-   56,   76,    0,   35,    0,    0,    0,   57,  293,   49,
-   50,    0,   59,   53,   54,   55,   56,    0,  185,    0,
-    2,    8,    0,    5,    0,    0,    0,    0,    0,   59,
-    0,    0,    0,    0,    6,    7,    0,    8,    0,    0,
-    0,    9,    0,    0,  186,   59,  187,  188,    1,    0,
-    2,    3,    4,    5,   10,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    6,    7,    0,    8,    0,    0,
-    0,    9,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,   10,
-};
-short yycheck[] = {                                      10,
-   27,   10,   59,   30,   27,   30,    0,   37,   38,   40,
-   27,   41,   42,   43,   27,   45,    0,   47,   29,   19,
-   31,   32,   33,   34,   44,   19,   41,  162,   58,   59,
-   38,   59,   62,   41,   27,   43,   38,   45,   27,   41,
-  189,   43,   62,   45,   41,   41,  135,   44,   44,   41,
-   58,   59,  262,    0,   62,  144,   58,   59,   41,    0,
-   62,   44,  257,   93,   94,   40,   62,   58,   43,  277,
-   45,   44,   19,  257,  262,  263,  103,   38,   19,  257,
-   41,   44,   43,   59,   45,   93,   94,   38,  123,   62,
-   41,   93,   94,   38,  124,  123,   41,   58,   59,   62,
-   44,   62,  113,   38,  115,   59,   41,   58,   59,  120,
-   59,   62,  247,   58,   59,  299,  124,   62,   62,   59,
-   44,  132,  124,   58,   59,   37,  123,   62,  277,  337,
-   42,  123,   93,   94,   41,   47,   59,   44,   62,   41,
-  123,  125,   93,   94,   38,  300,  301,   41,   93,   94,
-  177,  126,   59,  363,  181,  149,   58,   59,   93,   94,
-   62,   59,  189,  124,   58,   59,  189,  299,   62,   41,
-  380,  262,   38,  124,  263,   41,  176,  280,  281,  124,
-   41,  256,  176,   44,   91,   60,   58,   59,  337,  124,
-   62,   93,   58,   59,  123,   41,   62,   41,   59,   93,
-   94,   43,  149,   45,  231,  280,  281,  262,  149,   60,
-  265,   60,   58,   59,   58,   59,   62,  123,   62,  246,
-  274,   93,  357,  287,  288,  289,  257,   93,   94,  176,
-  124,  211,  212,  213,  291,  176,  125,  257,  159,  160,
-  161,  123,  269,  270,  123,  207,  208,   93,   94,   93,
-  277,  262,  124,  270,  277,   44,  267,  270,  124,  209,
-  210,  257,  293,  294,  295,  296,  297,  298,  299,   61,
-  300,  301,  287,  288,  289,   94,  270,  270,  124,  124,
-  124,  270,  257,   38,  257,   44,   91,   40,  257,  125,
-   41,   62,  300,  301,  257,  283,   62,   62,  300,  301,
-  311,   59,  311,   59,  125,   59,   44,   59,   41,   59,
-  337,   59,  125,  257,  337,   59,  125,  125,  293,  294,
-  295,  296,  297,  298,  299,   58,   59,  257,  262,   62,
-   93,  342,  359,  342,  359,   59,   41,   40,  365,  300,
-  301,  123,   41,   44,  290,   41,   40,   44,  291,  300,
-  301,   59,  363,  125,   58,  300,  301,   40,   58,   41,
-   93,   94,  294,   41,   59,  300,  301,   44,  257,  380,
-    0,  257,  294,  262,  263,  264,  265,  266,  267,  268,
-  269,  270,  271,  125,   59,  125,  257,   41,  277,  125,
-  125,  124,  256,  257,  283,   41,   59,  286,  262,  263,
-  264,  265,  266,  267,  268,  269,  270,  271,  272,  273,
-  299,  275,  276,  277,  278,   41,  125,   41,  257,   27,
-  177,  204,  206,  262,  263,  264,  265,  266,  267,  268,
-  269,  270,  271,  272,  273,  299,  275,  276,  277,  278,
-  365,  267,  264,  257,  205,  360,   27,  149,  262,  263,
-  264,  265,  266,  267,  268,  269,  270,  271,  272,  273,
-  299,  275,  276,  277,  278,  149,  181,  257,  149,  362,
-   -1,  309,  262,  263,  264,  265,  266,  267,  268,  269,
-  270,  271,   -1,  226,  257,  299,  276,  277,  278,  262,
-  263,  264,  265,  266,  267,  268,  269,  270,  271,  364,
-   -1,   -1,   -1,   -1,  277,   -1,   -1,   -1,   -1,  299,
-  257,   -1,   -1,  286,   -1,  262,  263,  264,  265,  266,
-  267,  268,  269,  270,   -1,   -1,  299,  257,   -1,   -1,
-  277,  278,  262,  263,  264,  265,  266,  267,  268,  269,
-  270,  271,   -1,  257,   -1,   -1,   -1,  277,  262,  263,
-  264,   -1,  299,  267,  268,  269,  270,   -1,  256,   -1,
-  258,  275,   -1,  261,   -1,   -1,   -1,   -1,   -1,  299,
-   -1,   -1,   -1,   -1,  272,  273,   -1,  275,   -1,   -1,
-   -1,  279,   -1,   -1,  282,  299,  284,  285,  256,   -1,
-  258,  259,  260,  261,  292,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  272,  273,   -1,  275,   -1,   -1,
-   -1,  279,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  292,
-};
-#define YYFINAL 11
-#ifndef YYDEBUG
-#define YYDEBUG 0
+} TAO_YYSTYPE;
+# define IDENTIFIER 257
+# define IDL_CONST 258
+# define IDL_MODULE 259
+# define IDL_INTERFACE 260
+# define IDL_TYPEDEF 261
+# define IDL_LONG 262
+# define IDL_SHORT 263
+# define IDL_UNSIGNED 264
+# define IDL_DOUBLE 265
+# define IDL_FLOAT 266
+# define IDL_CHAR 267
+# define IDL_WCHAR 268
+# define IDL_OCTET 269
+# define IDL_BOOLEAN 270
+# define IDL_ANY 271
+# define IDL_STRUCT 272
+# define IDL_UNION 273
+# define IDL_SWITCH 274
+# define IDL_ENUM 275
+# define IDL_SEQUENCE 276
+# define IDL_STRING 277
+# define IDL_WSTRING 278
+# define IDL_EXCEPTION 279
+# define IDL_CASE 280
+# define IDL_DEFAULT 281
+# define IDL_READONLY 282
+# define IDL_ATTRIBUTE 283
+# define IDL_ONEWAY 284
+# define IDL_IDEMPOTENT 285
+# define IDL_VOID 286
+# define IDL_IN 287
+# define IDL_OUT 288
+# define IDL_INOUT 289
+# define IDL_RAISES 290
+# define IDL_CONTEXT 291
+# define IDL_NATIVE 292
+# define IDL_INTEGER_LITERAL 293
+# define IDL_STRING_LITERAL 294
+# define IDL_CHARACTER_LITERAL 295
+# define IDL_FLOATING_PT_LITERAL 296
+# define IDL_TRUETOK 297
+# define IDL_FALSETOK 298
+# define IDL_SCOPE_DELIMITOR 299
+# define IDL_LEFT_SHIFT 300
+# define IDL_RIGHT_SHIFT 301
+
+#ifdef __STDC__
+#include <stdlib.h>
+// #include <string.h>
+#else
+#include <malloc.h>
+#include <memory.h>
 #endif
-#define YYMAXTOKEN 301
-#if YYDEBUG
-char *yyname[] = {
-"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,
-0,0,"':'","';'","'<'","'='","'>'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,"'{'","'|'","'}'","'~'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
-0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"IDENTIFIER","IDL_CONST",
-"IDL_MODULE","IDL_INTERFACE","IDL_TYPEDEF","IDL_LONG","IDL_SHORT",
-"IDL_UNSIGNED","IDL_DOUBLE","IDL_FLOAT","IDL_CHAR","IDL_WCHAR","IDL_OCTET",
-"IDL_BOOLEAN","IDL_ANY","IDL_STRUCT","IDL_UNION","IDL_SWITCH","IDL_ENUM",
-"IDL_SEQUENCE","IDL_STRING","IDL_WSTRING","IDL_EXCEPTION","IDL_CASE",
-"IDL_DEFAULT","IDL_READONLY","IDL_ATTRIBUTE","IDL_ONEWAY","IDL_IDEMPOTENT",
-"IDL_VOID","IDL_IN","IDL_OUT","IDL_INOUT","IDL_RAISES","IDL_CONTEXT",
-"IDL_NATIVE","IDL_INTEGER_LITERAL","IDL_STRING_LITERAL","IDL_CHARACTER_LITERAL",
-"IDL_FLOATING_PT_LITERAL","IDL_TRUETOK","IDL_FALSETOK","IDL_SCOPE_DELIMITOR",
-"IDL_LEFT_SHIFT","IDL_RIGHT_SHIFT",
-};
-char *yyrule[] = {
-"$accept : start",
-"start : definitions",
-"definitions : definition definitions",
-"definitions :",
-"$$1 :",
-"definition : type_dcl $$1 ';'",
-"$$2 :",
-"definition : const_dcl $$2 ';'",
-"$$3 :",
-"definition : exception $$3 ';'",
-"$$4 :",
-"definition : interface_def $$4 ';'",
-"$$5 :",
-"definition : module $$5 ';'",
-"$$6 :",
-"definition : error $$6 ';'",
-"$$7 :",
-"$$8 :",
-"$$9 :",
-"$$10 :",
-"module : IDL_MODULE $$7 IDENTIFIER $$8 '{' $$9 definitions $$10 '}'",
-"interface_def : interface",
-"interface_def : forward",
-"$$11 :",
-"$$12 :",
-"$$13 :",
-"interface : interface_header $$11 '{' $$12 exports $$13 '}'",
-"$$14 :",
-"interface_decl : IDL_INTERFACE $$14 id",
-"interface_header : interface_decl inheritance_spec",
-"$$15 :",
-"inheritance_spec : ':' $$15 at_least_one_scoped_name",
-"inheritance_spec :",
-"exports : exports export",
-"exports :",
-"$$16 :",
-"export : type_dcl $$16 ';'",
-"$$17 :",
-"export : const_dcl $$17 ';'",
-"$$18 :",
-"export : exception $$18 ';'",
-"$$19 :",
-"export : attribute $$19 ';'",
-"$$20 :",
-"export : operation $$20 ';'",
-"$$21 :",
-"export : error $$21 ';'",
-"at_least_one_scoped_name : scoped_name scoped_names",
-"$$22 :",
-"scoped_names : scoped_names ',' $$22 scoped_name",
-"scoped_names :",
-"scoped_name : id",
-"$$23 :",
-"scoped_name : IDL_SCOPE_DELIMITOR $$23 id",
-"$$24 :",
-"scoped_name : scoped_name IDL_SCOPE_DELIMITOR $$24 id",
-"id : IDENTIFIER",
-"forward : interface_decl",
-"$$25 :",
-"$$26 :",
-"$$27 :",
-"$$28 :",
-"const_dcl : IDL_CONST $$25 const_type $$26 id $$27 '=' $$28 expression",
-"const_type : integer_type",
-"const_type : char_type",
-"const_type : octet_type",
-"const_type : boolean_type",
-"const_type : floating_pt_type",
-"const_type : string_type_spec",
-"const_type : wstring_type_spec",
-"const_type : scoped_name",
-"expression : const_expr",
-"const_expr : or_expr",
-"or_expr : xor_expr",
-"or_expr : or_expr '|' xor_expr",
-"xor_expr : and_expr",
-"xor_expr : xor_expr '^' and_expr",
-"and_expr : shift_expr",
-"and_expr : and_expr '&' shift_expr",
-"shift_expr : add_expr",
-"shift_expr : shift_expr IDL_LEFT_SHIFT add_expr",
-"shift_expr : shift_expr IDL_RIGHT_SHIFT add_expr",
-"add_expr : mult_expr",
-"add_expr : add_expr '+' mult_expr",
-"add_expr : add_expr '-' mult_expr",
-"mult_expr : unary_expr",
-"mult_expr : mult_expr '*' unary_expr",
-"mult_expr : mult_expr '/' unary_expr",
-"mult_expr : mult_expr '%' unary_expr",
-"unary_expr : primary_expr",
-"unary_expr : '+' primary_expr",
-"unary_expr : '-' primary_expr",
-"unary_expr : '~' primary_expr",
-"primary_expr : scoped_name",
-"primary_expr : literal",
-"primary_expr : '(' const_expr ')'",
-"literal : IDL_INTEGER_LITERAL",
-"literal : IDL_STRING_LITERAL",
-"literal : IDL_CHARACTER_LITERAL",
-"literal : IDL_FLOATING_PT_LITERAL",
-"literal : IDL_TRUETOK",
-"literal : IDL_FALSETOK",
-"positive_int_expr : const_expr",
-"$$29 :",
-"type_dcl : IDL_TYPEDEF $$29 type_declarator",
-"type_dcl : struct_type",
-"type_dcl : union_type",
-"type_dcl : enum_type",
-"type_dcl : IDL_NATIVE simple_declarator",
-"$$30 :",
-"type_declarator : type_spec $$30 at_least_one_declarator",
-"type_spec : simple_type_spec",
-"type_spec : constructed_type_spec",
-"simple_type_spec : base_type_spec",
-"simple_type_spec : template_type_spec",
-"simple_type_spec : scoped_name",
-"base_type_spec : integer_type",
-"base_type_spec : floating_pt_type",
-"base_type_spec : char_type",
-"base_type_spec : boolean_type",
-"base_type_spec : octet_type",
-"base_type_spec : any_type",
-"template_type_spec : sequence_type_spec",
-"template_type_spec : string_type_spec",
-"template_type_spec : wstring_type_spec",
-"constructed_type_spec : struct_type",
-"constructed_type_spec : union_type",
-"constructed_type_spec : enum_type",
-"at_least_one_declarator : declarator declarators",
-"$$31 :",
-"declarators : declarators ',' $$31 declarator",
-"declarators :",
-"declarator : simple_declarator",
-"declarator : complex_declarator",
-"at_least_one_simple_declarator : simple_declarator simple_declarators",
-"$$32 :",
-"simple_declarators : simple_declarators ',' $$32 simple_declarator",
-"simple_declarators :",
-"simple_declarator : id",
-"complex_declarator : array_declarator",
-"integer_type : signed_int",
-"integer_type : unsigned_int",
-"signed_int : IDL_LONG",
-"signed_int : IDL_LONG IDL_LONG",
-"signed_int : IDL_SHORT",
-"unsigned_int : IDL_UNSIGNED IDL_LONG",
-"unsigned_int : IDL_UNSIGNED IDL_LONG IDL_LONG",
-"unsigned_int : IDL_UNSIGNED IDL_SHORT",
-"floating_pt_type : IDL_DOUBLE",
-"floating_pt_type : IDL_FLOAT",
-"floating_pt_type : IDL_LONG IDL_DOUBLE",
-"char_type : IDL_CHAR",
-"char_type : IDL_WCHAR",
-"octet_type : IDL_OCTET",
-"boolean_type : IDL_BOOLEAN",
-"any_type : IDL_ANY",
-"$$33 :",
-"$$34 :",
-"$$35 :",
-"$$36 :",
-"struct_type : IDL_STRUCT $$33 id $$34 '{' $$35 at_least_one_member $$36 '}'",
-"at_least_one_member : member members",
-"members : members member",
-"members :",
-"$$37 :",
-"$$38 :",
-"member : type_spec $$37 at_least_one_declarator $$38 ';'",
-"$$39 :",
-"member : error $$39 ';'",
-"$$40 :",
-"$$41 :",
-"$$42 :",
-"$$43 :",
-"$$44 :",
-"$$45 :",
-"$$46 :",
-"$$47 :",
-"union_type : IDL_UNION $$40 id $$41 IDL_SWITCH $$42 '(' $$43 switch_type_spec $$44 ')' $$45 '{' $$46 at_least_one_case_branch $$47 '}'",
-"switch_type_spec : integer_type",
-"switch_type_spec : char_type",
-"switch_type_spec : octet_type",
-"switch_type_spec : boolean_type",
-"switch_type_spec : enum_type",
-"switch_type_spec : scoped_name",
-"at_least_one_case_branch : case_branch case_branches",
-"case_branches : case_branches case_branch",
-"case_branches :",
-"$$48 :",
-"$$49 :",
-"case_branch : at_least_one_case_label $$48 element_spec $$49 ';'",
-"$$50 :",
-"case_branch : error $$50 ';'",
-"at_least_one_case_label : case_label case_labels",
-"case_labels : case_labels case_label",
-"case_labels :",
-"$$51 :",
-"case_label : IDL_DEFAULT $$51 ':'",
-"$$52 :",
-"$$53 :",
-"case_label : IDL_CASE $$52 const_expr $$53 ':'",
-"$$54 :",
-"element_spec : type_spec $$54 declarator",
-"$$55 :",
-"$$56 :",
-"$$57 :",
-"$$58 :",
-"enum_type : IDL_ENUM $$55 id $$56 '{' $$57 at_least_one_enumerator $$58 '}'",
-"at_least_one_enumerator : enumerator enumerators",
-"$$59 :",
-"enumerators : enumerators ',' $$59 enumerator",
-"enumerators :",
-"enumerator : IDENTIFIER",
-"$$60 :",
-"$$61 :",
-"sequence_type_spec : seq_head ',' $$60 positive_int_expr $$61 '>'",
-"sequence_type_spec : seq_head '>'",
-"$$62 :",
-"$$63 :",
-"seq_head : IDL_SEQUENCE $$62 '<' $$63 simple_type_spec",
-"$$64 :",
-"$$65 :",
-"string_type_spec : string_head '<' $$64 positive_int_expr $$65 '>'",
-"string_type_spec : string_head",
-"string_head : IDL_STRING",
-"$$66 :",
-"$$67 :",
-"wstring_type_spec : wstring_head '<' $$66 positive_int_expr $$67 '>'",
-"wstring_type_spec : wstring_head",
-"wstring_head : IDL_WSTRING",
-"$$68 :",
-"array_declarator : id $$68 at_least_one_array_dim",
-"at_least_one_array_dim : array_dim array_dims",
-"array_dims : array_dims array_dim",
-"array_dims :",
-"$$69 :",
-"$$70 :",
-"array_dim : '[' $$69 positive_int_expr $$70 ']'",
-"$$71 :",
-"$$72 :",
-"attribute : opt_readonly IDL_ATTRIBUTE $$71 param_type_spec $$72 at_least_one_simple_declarator",
-"opt_readonly : IDL_READONLY",
-"opt_readonly :",
-"$$73 :",
-"$$74 :",
-"$$75 :",
-"$$76 :",
-"exception : IDL_EXCEPTION $$73 id $$74 '{' $$75 members $$76 '}'",
-"$$77 :",
-"$$78 :",
-"$$79 :",
-"$$80 :",
-"operation : opt_op_attribute op_type_spec $$77 IDENTIFIER $$78 parameter_list $$79 opt_raises $$80 opt_context",
-"opt_op_attribute : IDL_ONEWAY",
-"opt_op_attribute : IDL_IDEMPOTENT",
-"opt_op_attribute :",
-"op_type_spec : param_type_spec",
-"op_type_spec : IDL_VOID",
-"$$81 :",
-"parameter_list : '(' $$81 ')'",
-"$$82 :",
-"parameter_list : '(' $$82 at_least_one_parameter ')'",
-"at_least_one_parameter : parameter parameters",
-"$$83 :",
-"parameters : parameters ',' $$83 parameter",
-"parameters :",
-"$$84 :",
-"$$85 :",
-"parameter : direction $$84 param_type_spec $$85 declarator",
-"param_type_spec : base_type_spec",
-"param_type_spec : string_type_spec",
-"param_type_spec : scoped_name",
-"direction : IDL_IN",
-"direction : IDL_OUT",
-"direction : IDL_INOUT",
-"$$86 :",
-"$$87 :",
-"opt_raises : IDL_RAISES $$86 '(' $$87 at_least_one_scoped_name ')'",
-"opt_raises :",
-"$$88 :",
-"$$89 :",
-"opt_context : IDL_CONTEXT $$88 '(' $$89 at_least_one_string_literal ')'",
-"opt_context :",
-"at_least_one_string_literal : IDL_STRING_LITERAL string_literals",
-"$$90 :",
-"string_literals : string_literals ',' $$90 IDL_STRING_LITERAL",
-"string_literals :",
-};
+
+// #include <values.h>
+
+#ifdef __cplusplus
+
+#ifndef tao_yyerror
+	void tao_yyerror(const char *);
 #endif
-#define yyclearin (yychar=(-1))
-#define yyerrok (yyerrflag=0)
-#ifndef YYSTACKSIZE
-#ifdef YYMAXDEPTH
-#define YYSTACKSIZE YYMAXDEPTH
+
+#ifndef tao_yylex
+#ifdef __EXTERN_C__
+	extern "C" { int tao_yylex(void); }
 #else
-#define YYSTACKSIZE 300
+	int tao_yylex(void);
+#endif
+#endif
+	int tao_yyparse(void);
+
 #endif
+#define tao_yyclearin tao_yychar = -1
+#define tao_yyerrok tao_yyerrflag = 0
+extern int tao_yychar;
+extern int tao_yyerrflag;
+TAO_YYSTYPE tao_yylval;
+TAO_YYSTYPE tao_yyval;
+typedef int tao_yytabelem;
+#ifndef TAO_YYMAXDEPTH
+#define TAO_YYMAXDEPTH 150
 #endif
-int yydebug;
-int yynerrs;
-int yyerrflag;
-int yychar;
-short *yyssp;
-YYSTYPE *yyvsp;
-YYSTYPE yyval;
-YYSTYPE yylval;
-#define yystacksize YYSTACKSIZE
-short yyss[YYSTACKSIZE];
-YYSTYPE yyvs[YYSTACKSIZE];
-#line 2277 "idl.yy"
+#if TAO_YYMAXDEPTH > 0
+int tao_yy_tao_yys[TAO_YYMAXDEPTH], *tao_yys = tao_yy_tao_yys;
+TAO_YYSTYPE tao_yy_tao_yyv[TAO_YYMAXDEPTH], *tao_yyv = tao_yy_tao_yyv;
+#else	/* user does initial allocation */
+int *tao_yys;
+TAO_YYSTYPE *tao_yyv;
+#endif
+static int tao_yymaxdepth = TAO_YYMAXDEPTH;
+# define TAO_YYERRCODE 256
+
+# line 2276 "idl.tao_yy"
+
 /* programs */
 
 /*
  * ???
  */
 int
-yywrap()
+tao_yywrap()
 {
   return 1;
 }
@@ -808,399 +161,1282 @@ yywrap()
  * idl_global->err() operations
  */
 void
-yyerror(char *)
+tao_yyerror(char *)
 {
 }
-#line 815 "y.tab.c"
-#define YYABORT goto yyabort
-#define YYACCEPT goto yyaccept
-#define YYERROR goto yyerrlab
-#ifdef YYDEBUG
-#ifndef YYDEBUG_LEXER_TEXT /* pointer to the text isolated by the lexer*/
-#define YYDEBUG_LEXER_TEXT "YYDEBUG_LEXER_TEXT not defined"
-#endif
-#ifndef YYDEBUG_INDENT_STRING
-#define YYDEBUG_INDENT_STRING  "|       "
-#endif
-#ifndef YYDEBUG_REDUCE_STRING
-#define YYDEBUG_REDUCE_STRING  "+-------"
-#endif
-#ifndef YYDEBUG_INDENT
-#ifdef __cplusplus
-void YYDEBUG_INDENT(int yyindent)
-#else
-YYDEBUG_INDENT(yyindent)
-int yyindent;
-#endif
-{
-    while(yyindent-- > 0)
-        printf("%s", YYDEBUG_INDENT_STRING);
-}
-#endif /* YYDEBUG_INDENT */
-#ifndef YYDEBUG_REDUCE
+tao_yytabelem tao_yyexca[] ={
+-1, 0,
+	0, 3,
+	-2, 0,
+-1, 1,
+	0, -1,
+	-2, 0,
+-1, 3,
+	0, 3,
+	125, 3,
+	-2, 0,
+-1, 24,
+	123, 32,
+	-2, 57,
+-1, 134,
+	91, 229,
+	-2, 138,
+-1, 149,
+	257, 254,
+	262, 254,
+	263, 254,
+	264, 254,
+	265, 254,
+	266, 254,
+	267, 254,
+	268, 254,
+	269, 254,
+	270, 254,
+	271, 254,
+	277, 254,
+	283, 241,
+	286, 254,
+	299, 254,
+	125, 25,
+	-2, 0,
+-1, 181,
+	125, 3,
+	-2, 0,
+-1, 222,
+	125, 245,
+	-2, 0,
+-1, 269,
+	125, 161,
+	-2, 0,
+-1, 319,
+	41, 257,
+	-2, 259,
+-1, 357,
+	125, 184,
+	-2, 0,
+	};
+# define TAO_YYNPROD 286
+# define TAO_YYLAST 528
+tao_yytabelem tao_yyact[]={
+
+    72,   131,   347,   331,   344,    57,   167,   155,   128,   241,
+    70,   230,   132,   207,   208,    35,   226,   110,   393,   388,
+   333,   334,   335,   352,   328,   239,   147,    34,   349,   348,
+   130,   112,   118,   119,   113,   112,   141,    36,    36,   101,
+    59,   103,   104,   105,   100,   227,    36,   108,    98,   169,
+    54,    78,    87,    88,    76,    77,    79,    80,    82,    81,
+    83,    20,    21,    36,    22,    89,    90,    91,    78,    87,
+    88,    76,    77,    79,    80,    82,    81,    83,    20,    21,
+    73,    22,    89,    90,    91,   231,   305,    36,    73,   102,
+   201,   346,    78,    87,    88,    76,    77,    79,    80,    82,
+    81,    83,   162,   222,   160,    73,    89,    90,    91,   161,
+   134,   154,   137,    36,   129,   349,   348,   159,   301,    87,
+    88,    67,   143,    79,    80,    82,    81,   158,     2,    73,
+   157,    22,    26,    36,   265,     6,     5,   153,    78,    87,
+    88,    76,    77,    79,    80,    82,    81,    83,    55,   169,
+    66,   367,   164,    90,   165,    73,   302,   291,   290,    95,
+    36,   289,   242,   232,   204,    78,    87,    88,    76,    77,
+    79,    80,    82,    81,    83,    73,    65,   217,    62,    13,
+    90,    63,    13,   325,     4,    59,    36,   148,    96,    59,
+   163,    78,    87,    88,    76,    77,    79,    80,    82,    81,
+   243,   245,    73,   146,   145,   244,    90,    91,   192,   144,
+    15,   106,   205,    10,    94,   312,   202,   263,   262,    93,
+   250,   114,   221,   142,    20,    21,   117,    22,    73,    59,
+   116,    16,   384,   371,   195,   166,   196,   197,     9,   115,
+    15,    19,    25,    10,    14,   313,    61,    12,   134,   284,
+    12,   176,   177,   283,    20,    21,   293,    22,   280,    60,
+    11,    16,   279,    11,   278,   277,    36,   276,   275,    52,
+    51,   134,   288,    50,    14,    49,    59,    48,    47,   300,
+   386,   373,    45,   391,   213,   189,   188,   243,   245,   211,
+   354,   304,   244,   209,   212,   210,   326,   303,   199,   198,
+   389,   292,   170,   171,   172,   173,   174,   175,    73,   383,
+   223,    35,   254,   255,   258,   259,   260,   225,   340,   256,
+   257,   315,   329,   317,   253,   314,   261,   220,    13,   269,
+   375,   353,   319,   252,   187,   251,   228,   206,    35,   285,
+    64,    71,   392,   382,   363,   364,   339,   366,   243,   245,
+   350,   342,   355,   244,   365,   214,   215,   216,   341,   330,
+    13,   286,   368,   372,   324,    59,    36,   134,   378,   377,
+   374,   129,   323,   376,   338,   370,   322,   318,    97,    99,
+   311,   134,   385,   282,   266,   180,   122,    38,   310,   281,
+   306,   249,   152,   219,   297,   140,    12,    86,   218,   139,
+    85,   178,   170,   171,   172,   173,   174,   175,    73,    11,
+   120,   203,   138,   309,   274,   273,   229,   184,   126,    42,
+   380,   381,   362,   298,   361,   359,   379,   358,    12,   357,
+   356,   343,   336,   320,   308,   272,   183,   125,    41,   271,
+   307,    11,   270,   268,   224,   182,   124,    40,   337,   296,
+   247,   299,   109,    53,   295,    33,   264,   179,   121,    37,
+   136,   111,   246,   238,   237,   191,   236,   190,   235,   234,
+   233,   186,   107,    46,   185,   149,   127,    43,    18,    17,
+   267,   181,   123,    39,    32,    31,     8,    30,     7,    29,
+    28,    27,     3,     1,    24,   193,   133,   194,   332,    75,
+    74,    68,    92,   369,   168,   156,   287,    23,   321,   316,
+   151,   360,   345,   248,   200,   327,    44,   150,   390,   387,
+   351,    84,   240,   135,   294,    69,    58,    56 };
+tao_yytabelem tao_yypact[]={
+
+   -18,-10000000,-10000000,   -18,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
+-10000000,-10000000,-10000000,-10000000,  -220,-10000000,-10000000,-10000000,-10000000,-10000000,
+-10000000,-10000000,-10000000,-10000000,   224,-10000000,-10000000,   219,   218,   216,
+   214,   211,   210,  -194,-10000000,-10000000,-10000000,   -71,  -220,  -168,
+  -220,  -220,  -220,    88,-10000000,-10000000,  -220,-10000000,-10000000,-10000000,
+-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,  -282,
+-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
+-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,  -231,-10000000,
+-10000000,-10000000,-10000000,-10000000,   177,   170,   166,-10000000,  -230,-10000000,
+-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
+  -282,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,  -219,-10000000,  -220,
+-10000000,  -220,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,  -226,-10000000,
+   163,  -220,    86,    81,    80,  -248,    64,-10000000,-10000000,  -282,
+-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,  -220,-10000000,   109,   109,
+   109,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,   -48,
+   255,   254,   125,-10000000,-10000000,-10000000,    40,   118,   299,  -287,
+   250,   247,-10000000,-10000000,     9,     9,     9,  -282,-10000000,   109,
+-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,  -170,   161,
+-10000000,   -18,  -211,   296,  -172,    38,-10000000,-10000000,-10000000,-10000000,
+-10000000,-10000000,-10000000,  -258,  -124,-10000000,-10000000,-10000000,-10000000,-10000000,
+-10000000,-10000000,-10000000,   158,   109,   109,   109,   109,   109,   109,
+   109,   109,   109,   109,-10000000,-10000000,-10000000,   285,   156,   155,
+-10000000,-10000000,  -211,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
+-10000000,-10000000,-10000000,   209,   208,   206,   205,   203,   199,-10000000,
+-10000000,-10000000,-10000000,-10000000,-10000000,  -282,  -219,  -220,   125,   109,
+-10000000,   118,   299,  -287,   250,   250,   247,   247,-10000000,-10000000,
+-10000000,-10000000,-10000000,-10000000,   109,-10000000,    36,    33,    32,  -211,
+  -220,   197,  -144,    31,   253,-10000000,-10000000,-10000000,-10000000,-10000000,
+-10000000,   -97,  -171,  -282,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
+-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
+  -282,  -227,-10000000,-10000000,-10000000,-10000000,   122,   186,   284,  -172,
+  -220,   292,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
+    60,   252,  -266,   281,  -267,-10000000,-10000000,-10000000,-10000000,-10000000,
+   277,-10000000,-10000000,-10000000,-10000000,-10000000,  -165,  -220,  -268,   291,
+-10000000,   246,   -97,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
+-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,    26,  -165,  -194,   174,
+  -252,   223,   109,   290,  -219,  -267,  -220,-10000000,-10000000,-10000000,
+-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,   268,-10000000,-10000000,   173,
+  -220,   222,  -275,-10000000,-10000000,-10000000,-10000000,   259,-10000000,-10000000,
+   239,-10000000,  -276,-10000000 };
+tao_yytabelem tao_yypgo[]={
+
+     0,    16,   148,   527,   526,   525,    10,   259,   178,   524,
+   246,   523,   522,   521,   341,     9,     6,   520,   519,   518,
+     8,   517,   516,   515,   514,   513,   512,   511,    30,   510,
+   509,   508,   507,   506,     7,   505,   130,   127,   117,   104,
+   109,   102,   190,   504,   111,    90,     2,   503,   502,   181,
+   176,   150,   340,   501,   500,   499,     5,   121,   498,   497,
+     1,    12,   496,   495,   494,     0,   184,   493,   128,   492,
+   491,   136,   490,   135,   489,   488,   487,   486,   485,   484,
+   483,   482,   481,   480,   479,   478,   477,   476,   475,   474,
+   473,   472,   471,   470,   469,   468,   467,   466,   465,   464,
+   463,   462,   461,   460,   459,   458,   457,   456,   455,   453,
+   452,   450,   448,   447,   446,   445,   444,   443,   134,   103,
+   442,   440,   439,   438,   437,   436,   435,   434,   433,   432,
+   431,   430,     4,   429,   427,   426,   425,   424,   422,   421,
+   420,   419,   418,   417,   416,   415,    11,   414,   413,   412,
+   411,   410,   401,   400,   399,   398,   397,   395,   393,   392,
+   391,   390,   389,   388,   387,   386,   385,   384,   383,   380,
+   377,   376,   374,   372,   364,   359,     3,   358,   354,   351,
+   347,   346,   345,   344,   343,   342 };
+tao_yytabelem tao_yyr1[]={
+
+     0,    67,    68,    68,    70,    69,    72,    69,    74,    69,
+    76,    69,    78,    69,    79,    69,    80,    81,    82,    83,
+    77,    75,    75,    86,    87,    89,    84,    90,    64,    32,
+    91,    22,    22,    88,    88,    93,    92,    94,    92,    95,
+    92,    97,    92,    99,    92,   100,    92,    20,   101,    21,
+    21,    16,   102,    16,   103,    16,    65,    85,   104,   105,
+   106,   107,    71,    48,    48,    48,    48,    48,    48,    48,
+    48,    33,    34,    35,    35,    36,    36,    37,    37,    38,
+    38,    38,    39,    39,    39,    40,    40,    40,    40,    41,
+    41,    41,    41,    42,    42,    42,    43,    43,    43,    43,
+    43,    43,    44,   108,    66,    66,    66,    66,    66,   110,
+   109,     1,     1,     2,     2,     2,    56,    56,    56,    56,
+    56,    56,     4,     4,     4,     3,     3,     3,    28,   111,
+    29,    29,    60,    60,    30,   112,    31,    31,    61,    62,
+    49,    49,    54,    54,    54,    55,    55,    55,    52,    52,
+    52,    50,    50,    57,    51,    53,   113,   114,   115,   117,
+     7,   116,   119,   119,   120,   121,   118,   122,   118,   123,
+   124,   125,   126,   127,   128,   129,   131,    10,     9,     9,
+     9,     9,     9,     9,   130,   133,   133,   134,   135,   132,
+   136,   132,    26,    27,    27,   137,    46,   138,   139,    46,
+   140,    47,   141,   142,   143,   145,     8,   144,   148,   147,
+   147,   146,   149,   150,     5,     5,   151,   152,    13,   154,
+   155,     6,     6,   153,   157,   158,    14,    14,   156,   159,
+    11,    24,    25,    25,   160,   161,    45,   162,   163,    96,
+    63,    63,   164,   165,   166,   167,    73,   168,   169,   171,
+   172,    98,    59,    59,    59,    12,    12,   173,   170,   174,
+   170,   175,   178,   177,   177,   179,   180,   176,    15,    15,
+    15,    58,    58,    58,   181,   182,    23,    23,   183,   184,
+    17,    17,    18,   185,    19,    19 };
+tao_yytabelem tao_yyr2[]={
+
+     0,     2,     4,     0,     1,     7,     1,     7,     1,     7,
+     1,     7,     1,     7,     1,     7,     1,     1,     1,     1,
+    19,     2,     2,     1,     1,     1,    15,     1,     7,     5,
+     1,     7,     1,     4,     0,     1,     7,     1,     7,     1,
+     7,     1,     7,     1,     7,     1,     7,     5,     1,     9,
+     1,     3,     1,     7,     1,     9,     3,     3,     1,     1,
+     1,     1,    19,     2,     2,     2,     2,     2,     3,     3,
+     3,     2,     2,     2,     7,     2,     7,     2,     7,     2,
+     7,     7,     2,     7,     7,     2,     7,     7,     7,     2,
+     5,     5,     5,     3,     2,     7,     3,     3,     3,     3,
+     3,     3,     3,     1,     7,     3,     3,     3,     5,     1,
+     7,     2,     2,     3,     2,     3,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     5,     1,
+     9,     1,     2,     2,     5,     1,     9,     1,     3,     3,
+     2,     2,     3,     5,     3,     5,     7,     5,     3,     3,
+     5,     3,     3,     3,     3,     3,     1,     1,     1,     1,
+    19,     4,     4,     0,     1,     1,    11,     1,     7,     1,
+     1,     1,     1,     1,     1,     1,     1,    35,     3,     3,
+     3,     3,     2,     3,     4,     4,     0,     1,     1,    11,
+     1,     7,     5,     5,     1,     1,     7,     1,     1,    11,
+     1,     7,     1,     1,     1,     1,    19,     4,     1,     8,
+     0,     3,     1,     1,    13,     5,     1,     1,    11,     1,
+     1,    13,     3,     3,     1,     1,    13,     3,     3,     1,
+     7,     5,     5,     1,     1,     1,    11,     1,     1,    13,
+     3,     1,     1,     1,     1,     1,    19,     1,     1,     1,
+     1,    21,     3,     3,     1,     2,     3,     1,     7,     1,
+     9,     4,     1,     8,     0,     1,     1,    11,     3,     2,
+     3,     3,     3,     3,     1,     1,    13,     1,     1,     1,
+    13,     1,     5,     1,     9,     1 };
+tao_yytabelem tao_yychk[]={
+
+-10000000,   -67,   -68,   -69,   -66,   -71,   -73,   -75,   -77,   256,
+   261,    -7,   -10,    -8,   292,   258,   279,   -84,   -85,   259,
+   272,   273,   275,   -32,   -64,   260,   -68,   -70,   -72,   -74,
+   -76,   -78,   -79,  -108,   -61,   -65,   257,  -104,  -164,   -80,
+  -113,  -123,  -141,   -86,   -22,    58,   -90,    59,    59,    59,
+    59,    59,    59,  -109,    -1,    -2,    -3,   -56,    -4,   -16,
+    -7,   -10,    -8,   -49,   -52,   -50,   -51,   -57,   -53,    -5,
+    -6,   -14,   -65,   299,   -54,   -55,   265,   266,   262,   267,
+   268,   270,   269,   271,   -13,  -153,  -156,   263,   264,   276,
+   277,   278,   -48,   -49,   -50,   -57,   -51,   -52,    -6,   -14,
+   -16,   -65,   257,   -65,   -65,   -65,   123,   -91,   -65,  -110,
+   299,  -102,   262,   265,    44,    62,    60,    60,   262,   263,
+  -151,  -105,  -165,   -81,  -114,  -124,  -142,   -87,   -20,   -16,
+   -28,   -60,   -61,   -62,   -65,   -11,  -103,   -65,  -149,  -154,
+  -157,   262,    60,   -65,   123,   123,   123,   274,   123,   -88,
+   -21,   -29,  -159,   -65,   -44,   -34,   -35,   -36,   -37,   -38,
+   -39,   -40,   -41,   -42,    43,    45,   126,   -16,   -43,    40,
+   293,   294,   295,   296,   297,   298,   -44,   -44,  -152,  -106,
+  -166,   -82,  -115,  -125,  -143,   -89,   -92,   -66,   -71,   -73,
+   -96,   -98,   256,   -63,   -59,   282,   284,   285,    44,    44,
+   -24,   -45,    91,  -150,   124,    94,    38,   300,   301,    43,
+    45,    42,    47,    37,   -42,   -42,   -42,   -34,  -155,  -158,
+    -2,    61,  -119,   -68,  -116,  -118,    -1,   256,    40,  -144,
+  -146,   257,   125,   -93,   -94,   -95,   -97,   -99,  -100,   283,
+   -12,   -15,   286,   -56,    -6,   -16,  -101,  -111,   -25,  -160,
+    62,   -36,   -37,   -38,   -39,   -39,   -40,   -40,   -41,   -41,
+   -41,    41,    62,    62,  -107,  -118,  -167,   -83,  -117,  -119,
+  -120,  -122,  -126,  -145,  -147,    59,    59,    59,    59,    59,
+    59,  -162,  -168,   -16,   -60,   -45,   -44,   -33,   -34,   125,
+   125,   125,   -28,    59,    -9,   -49,   -50,   -57,   -51,    -8,
+   -16,   262,   125,    44,   -15,   257,  -161,  -121,  -127,  -148,
+  -163,  -169,    93,    59,    41,  -146,   -30,   -61,  -170,    40,
+  -128,   -31,  -171,  -173,  -174,   123,    44,   -23,   290,    41,
+  -175,  -176,   -58,   287,   288,   289,  -129,  -112,  -172,  -181,
+    41,  -177,  -179,  -130,  -132,   -26,   256,   -46,   281,   280,
+   -61,   -17,   291,    40,    44,   -15,  -131,  -133,  -134,  -136,
+   -27,  -137,  -138,  -183,  -182,  -178,  -180,   125,  -132,   -47,
+    -1,    59,   -46,    58,   -34,    40,   -20,  -176,   -60,  -135,
+  -140,  -139,  -184,    41,    59,   -60,    58,   -18,   294,    41,
+   -19,    44,  -185,   294 };
+tao_yytabelem tao_yydef[]={
+
+    -2,    -2,     1,    -2,     4,     6,     8,    10,    12,    14,
+   103,   105,   106,   107,     0,    58,   242,    21,    22,    16,
+   156,   169,   202,    23,    -2,    27,     2,     0,     0,     0,
+     0,     0,     0,     0,   108,   138,    56,     0,     0,     0,
+     0,     0,     0,     0,    29,    30,     0,     5,     7,     9,
+    11,    13,    15,   104,   109,   111,   112,   113,   114,   115,
+   125,   126,   127,   116,   117,   118,   119,   120,   121,   122,
+   123,   124,    51,    52,   140,   141,   148,   149,   142,   151,
+   152,   154,   153,   155,     0,   222,   227,   144,     0,   216,
+   223,   228,    59,    63,    64,    65,    66,    67,    68,    69,
+    70,   243,    17,   157,   170,   203,    24,     0,    28,     0,
+    54,     0,   143,   150,   212,   215,   219,   224,   145,   147,
+     0,     0,     0,     0,     0,     0,     0,    34,    31,    50,
+   110,   131,   132,   133,    -2,   139,     0,    53,     0,     0,
+     0,   146,   217,    60,   244,    18,   158,   171,   204,    -2,
+    47,   128,     0,    55,   213,   102,    72,    73,    75,    77,
+    79,    82,    85,    89,     0,     0,     0,    93,    94,     0,
+    96,    97,    98,    99,   100,   101,   220,   225,     0,     0,
+   163,    -2,     0,     0,     0,     0,    33,    35,    37,    39,
+    41,    43,    45,     0,     0,   240,   252,   253,    48,   129,
+   230,   233,   234,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,    90,    91,    92,     0,     0,     0,
+   218,    61,    -2,    19,   159,   163,   164,   167,   172,   205,
+   210,   211,    26,     0,     0,     0,     0,     0,     0,   237,
+   247,   255,   256,   268,   269,   270,     0,     0,   231,     0,
+   214,    74,    76,    78,    80,    81,    83,    84,    86,    87,
+    88,    95,   221,   226,     0,   162,     0,     0,     0,    -2,
+     0,     0,     0,     0,   207,    36,    38,    40,    42,    44,
+    46,     0,     0,    49,   130,   232,   235,    62,    71,   246,
+    20,   160,   165,   168,   173,   178,   179,   180,   181,   182,
+   183,   142,   206,   208,   238,   248,     0,     0,     0,     0,
+     0,     0,   236,   166,   174,   209,   239,   137,   249,    -2,
+     0,   134,   277,     0,     0,   175,   135,   250,   274,   258,
+     0,   264,   265,   271,   272,   273,     0,     0,   281,     0,
+   260,   261,     0,   176,   186,   187,   190,   194,   195,   197,
+   136,   251,   278,   275,   262,   266,     0,    -2,     0,     0,
+   192,     0,     0,     0,     0,     0,     0,   177,   185,   188,
+   200,   191,   193,   196,   198,   279,     0,   263,   267,     0,
+     0,     0,     0,   276,   189,   201,   199,     0,   285,   280,
+   282,   283,     0,   284 };
+typedef struct
 #ifdef __cplusplus
-void YYDEBUG_REDUCE(int yynew_state, int yyrule_num, char *yyrule_string, int yynew_indent, int yyrhs_count)
-#else
-YYDEBUG_REDUCE(yynew_state, yyrule_num, yyrule_string, yynew_indent, yyrhs_count)
-int yynew_state;
-int yyrule_num;
-char * yyrule_string;
-int yynew_indent;
-int yyrhs_count;
+	tao_yytoktype
 #endif
-{
-    if (1 < yyrhs_count)
-    {  /* draw the graphics for the reduction */
-        YYDEBUG_INDENT(yynew_indent);
-        while(1 < yyrhs_count--)
-            printf("%s", YYDEBUG_REDUCE_STRING);
-        putchar('+'); /* left rotated L would look nice */
-        putchar('\n');
-        YYDEBUG_INDENT(yynew_indent);
-        putchar('|'); /* down arrow would look nice */
-        putchar('\n');
-    }
-    YYDEBUG_INDENT(yynew_indent);
-    /* Only print the resulting token name */
-    while (*yyrule_string)
-        putchar(*yyrule_string++);
-    putchar('\n');
-}
-#endif /* YYDEBUG_REDUCE */
-#ifndef YYDEBUG_SHIFT_LEXEME
-#ifdef __cplusplus
-void YYDEBUG_SHIFT_LEXEME(int yyold_state, int yynew_state, char *yytoken_string, int yynew_indent)
-#else
-YYDEBUG_SHIFT_LEXEME(yyold_state, yynew_state, yytoken_string, yynew_indent)
-int yyold_state;
-int yynew_state;
-char * yytoken_string;
-int yynew_indent;
+{ char *t_name; int t_val; } tao_yytoktype;
+#ifndef TAO_YYDEBUG
+#	define TAO_YYDEBUG	1	/* allow debugging */
 #endif
-{
-    YYDEBUG_INDENT(yynew_indent);
-    printf("%s <-- `%s'\n", yytoken_string, YYDEBUG_LEXER_TEXT);
-}
-#endif /*  YYDEBUG_SHIFT_LEXEME */
-#ifndef YYDEBUG_LOOK_AHEAD
-#ifdef __cplusplus
-void YYDEBUG_LOOK_AHEAD(int yynew_state, int yytoken_num, char *yytoken_string, int yyindent)
-#else
-YYDEBUG_LOOK_AHEAD(yynew_state, yytoken_num, yytoken_string, yyindent)
-int yynew_state;
-int yytoken_num;
-char * yytoken_string;
-int yyindent;
-#endif
-{
-    YYDEBUG_INDENT(yyindent);
-    printf("          .... look ahead at %s   `%s'\n",
-           yytoken_string,
-           (0 == yytoken_num)? "\0": YYDEBUG_LEXER_TEXT);
+
+#if TAO_YYDEBUG
+
+tao_yytoktype tao_yytoks[] =
+{
+	{"IDENTIFIER",	257},
+	{"IDL_CONST",	258},
+	{"IDL_MODULE",	259},
+	{"IDL_INTERFACE",	260},
+	{"IDL_TYPEDEF",	261},
+	{"IDL_LONG",	262},
+	{"IDL_SHORT",	263},
+	{"IDL_UNSIGNED",	264},
+	{"IDL_DOUBLE",	265},
+	{"IDL_FLOAT",	266},
+	{"IDL_CHAR",	267},
+	{"IDL_WCHAR",	268},
+	{"IDL_OCTET",	269},
+	{"IDL_BOOLEAN",	270},
+	{"IDL_ANY",	271},
+	{"IDL_STRUCT",	272},
+	{"IDL_UNION",	273},
+	{"IDL_SWITCH",	274},
+	{"IDL_ENUM",	275},
+	{"IDL_SEQUENCE",	276},
+	{"IDL_STRING",	277},
+	{"IDL_WSTRING",	278},
+	{"IDL_EXCEPTION",	279},
+	{"IDL_CASE",	280},
+	{"IDL_DEFAULT",	281},
+	{"IDL_READONLY",	282},
+	{"IDL_ATTRIBUTE",	283},
+	{"IDL_ONEWAY",	284},
+	{"IDL_IDEMPOTENT",	285},
+	{"IDL_VOID",	286},
+	{"IDL_IN",	287},
+	{"IDL_OUT",	288},
+	{"IDL_INOUT",	289},
+	{"IDL_RAISES",	290},
+	{"IDL_CONTEXT",	291},
+	{"IDL_NATIVE",	292},
+	{"IDL_INTEGER_LITERAL",	293},
+	{"IDL_STRING_LITERAL",	294},
+	{"IDL_CHARACTER_LITERAL",	295},
+	{"IDL_FLOATING_PT_LITERAL",	296},
+	{"IDL_TRUETOK",	297},
+	{"IDL_FALSETOK",	298},
+	{"IDL_SCOPE_DELIMITOR",	299},
+	{"IDL_LEFT_SHIFT",	300},
+	{"IDL_RIGHT_SHIFT",	301},
+	{"-unknown-",	-1}	/* ends search */
+};
+
+char * tao_yyreds[] =
+{
+	"-no such reduction-",
+	"start : definitions",
+	"definitions : definition definitions",
+	"definitions : /* empty */",
+	"definition : type_dcl",
+	"definition : type_dcl ';'",
+	"definition : const_dcl",
+	"definition : const_dcl ';'",
+	"definition : exception",
+	"definition : exception ';'",
+	"definition : interface_def",
+	"definition : interface_def ';'",
+	"definition : module",
+	"definition : module ';'",
+	"definition : error",
+	"definition : error ';'",
+	"module : IDL_MODULE",
+	"module : IDL_MODULE IDENTIFIER",
+	"module : IDL_MODULE IDENTIFIER '{'",
+	"module : IDL_MODULE IDENTIFIER '{' definitions",
+	"module : IDL_MODULE IDENTIFIER '{' definitions '}'",
+	"interface_def : interface",
+	"interface_def : forward",
+	"interface : interface_header",
+	"interface : interface_header '{'",
+	"interface : interface_header '{' exports",
+	"interface : interface_header '{' exports '}'",
+	"interface_decl : IDL_INTERFACE",
+	"interface_decl : IDL_INTERFACE id",
+	"interface_header : interface_decl inheritance_spec",
+	"inheritance_spec : ':'",
+	"inheritance_spec : ':' at_least_one_scoped_name",
+	"inheritance_spec : /* empty */",
+	"exports : exports export",
+	"exports : /* empty */",
+	"export : type_dcl",
+	"export : type_dcl ';'",
+	"export : const_dcl",
+	"export : const_dcl ';'",
+	"export : exception",
+	"export : exception ';'",
+	"export : attribute",
+	"export : attribute ';'",
+	"export : operation",
+	"export : operation ';'",
+	"export : error",
+	"export : error ';'",
+	"at_least_one_scoped_name : scoped_name scoped_names",
+	"scoped_names : scoped_names ','",
+	"scoped_names : scoped_names ',' scoped_name",
+	"scoped_names : /* empty */",
+	"scoped_name : id",
+	"scoped_name : IDL_SCOPE_DELIMITOR",
+	"scoped_name : IDL_SCOPE_DELIMITOR id",
+	"scoped_name : scoped_name IDL_SCOPE_DELIMITOR",
+	"scoped_name : scoped_name IDL_SCOPE_DELIMITOR id",
+	"id : IDENTIFIER",
+	"forward : interface_decl",
+	"const_dcl : IDL_CONST",
+	"const_dcl : IDL_CONST const_type",
+	"const_dcl : IDL_CONST const_type id",
+	"const_dcl : IDL_CONST const_type id '='",
+	"const_dcl : IDL_CONST const_type id '=' expression",
+	"const_type : integer_type",
+	"const_type : char_type",
+	"const_type : octet_type",
+	"const_type : boolean_type",
+	"const_type : floating_pt_type",
+	"const_type : string_type_spec",
+	"const_type : wstring_type_spec",
+	"const_type : scoped_name",
+	"expression : const_expr",
+	"const_expr : or_expr",
+	"or_expr : xor_expr",
+	"or_expr : or_expr '|' xor_expr",
+	"xor_expr : and_expr",
+	"xor_expr : xor_expr '^' and_expr",
+	"and_expr : shift_expr",
+	"and_expr : and_expr '&' shift_expr",
+	"shift_expr : add_expr",
+	"shift_expr : shift_expr IDL_LEFT_SHIFT add_expr",
+	"shift_expr : shift_expr IDL_RIGHT_SHIFT add_expr",
+	"add_expr : mult_expr",
+	"add_expr : add_expr '+' mult_expr",
+	"add_expr : add_expr '-' mult_expr",
+	"mult_expr : unary_expr",
+	"mult_expr : mult_expr '*' unary_expr",
+	"mult_expr : mult_expr '/' unary_expr",
+	"mult_expr : mult_expr '%' unary_expr",
+	"unary_expr : primary_expr",
+	"unary_expr : '+' primary_expr",
+	"unary_expr : '-' primary_expr",
+	"unary_expr : '~' primary_expr",
+	"primary_expr : scoped_name",
+	"primary_expr : literal",
+	"primary_expr : '(' const_expr ')'",
+	"literal : IDL_INTEGER_LITERAL",
+	"literal : IDL_STRING_LITERAL",
+	"literal : IDL_CHARACTER_LITERAL",
+	"literal : IDL_FLOATING_PT_LITERAL",
+	"literal : IDL_TRUETOK",
+	"literal : IDL_FALSETOK",
+	"positive_int_expr : const_expr",
+	"type_dcl : IDL_TYPEDEF",
+	"type_dcl : IDL_TYPEDEF type_declarator",
+	"type_dcl : struct_type",
+	"type_dcl : union_type",
+	"type_dcl : enum_type",
+	"type_dcl : IDL_NATIVE simple_declarator",
+	"type_declarator : type_spec",
+	"type_declarator : type_spec at_least_one_declarator",
+	"type_spec : simple_type_spec",
+	"type_spec : constructed_type_spec",
+	"simple_type_spec : base_type_spec",
+	"simple_type_spec : template_type_spec",
+	"simple_type_spec : scoped_name",
+	"base_type_spec : integer_type",
+	"base_type_spec : floating_pt_type",
+	"base_type_spec : char_type",
+	"base_type_spec : boolean_type",
+	"base_type_spec : octet_type",
+	"base_type_spec : any_type",
+	"template_type_spec : sequence_type_spec",
+	"template_type_spec : string_type_spec",
+	"template_type_spec : wstring_type_spec",
+	"constructed_type_spec : struct_type",
+	"constructed_type_spec : union_type",
+	"constructed_type_spec : enum_type",
+	"at_least_one_declarator : declarator declarators",
+	"declarators : declarators ','",
+	"declarators : declarators ',' declarator",
+	"declarators : /* empty */",
+	"declarator : simple_declarator",
+	"declarator : complex_declarator",
+	"at_least_one_simple_declarator : simple_declarator simple_declarators",
+	"simple_declarators : simple_declarators ','",
+	"simple_declarators : simple_declarators ',' simple_declarator",
+	"simple_declarators : /* empty */",
+	"simple_declarator : id",
+	"complex_declarator : array_declarator",
+	"integer_type : signed_int",
+	"integer_type : unsigned_int",
+	"signed_int : IDL_LONG",
+	"signed_int : IDL_LONG IDL_LONG",
+	"signed_int : IDL_SHORT",
+	"unsigned_int : IDL_UNSIGNED IDL_LONG",
+	"unsigned_int : IDL_UNSIGNED IDL_LONG IDL_LONG",
+	"unsigned_int : IDL_UNSIGNED IDL_SHORT",
+	"floating_pt_type : IDL_DOUBLE",
+	"floating_pt_type : IDL_FLOAT",
+	"floating_pt_type : IDL_LONG IDL_DOUBLE",
+	"char_type : IDL_CHAR",
+	"char_type : IDL_WCHAR",
+	"octet_type : IDL_OCTET",
+	"boolean_type : IDL_BOOLEAN",
+	"any_type : IDL_ANY",
+	"struct_type : IDL_STRUCT",
+	"struct_type : IDL_STRUCT id",
+	"struct_type : IDL_STRUCT id '{'",
+	"struct_type : IDL_STRUCT id '{' at_least_one_member",
+	"struct_type : IDL_STRUCT id '{' at_least_one_member '}'",
+	"at_least_one_member : member members",
+	"members : members member",
+	"members : /* empty */",
+	"member : type_spec",
+	"member : type_spec at_least_one_declarator",
+	"member : type_spec at_least_one_declarator ';'",
+	"member : error",
+	"member : error ';'",
+	"union_type : IDL_UNION",
+	"union_type : IDL_UNION id",
+	"union_type : IDL_UNION id IDL_SWITCH",
+	"union_type : IDL_UNION id IDL_SWITCH '('",
+	"union_type : IDL_UNION id IDL_SWITCH '(' switch_type_spec",
+	"union_type : IDL_UNION id IDL_SWITCH '(' switch_type_spec ')'",
+	"union_type : IDL_UNION id IDL_SWITCH '(' switch_type_spec ')' '{'",
+	"union_type : IDL_UNION id IDL_SWITCH '(' switch_type_spec ')' '{' at_least_one_case_branch",
+	"union_type : IDL_UNION id IDL_SWITCH '(' switch_type_spec ')' '{' at_least_one_case_branch '}'",
+	"switch_type_spec : integer_type",
+	"switch_type_spec : char_type",
+	"switch_type_spec : octet_type",
+	"switch_type_spec : boolean_type",
+	"switch_type_spec : enum_type",
+	"switch_type_spec : scoped_name",
+	"at_least_one_case_branch : case_branch case_branches",
+	"case_branches : case_branches case_branch",
+	"case_branches : /* empty */",
+	"case_branch : at_least_one_case_label",
+	"case_branch : at_least_one_case_label element_spec",
+	"case_branch : at_least_one_case_label element_spec ';'",
+	"case_branch : error",
+	"case_branch : error ';'",
+	"at_least_one_case_label : case_label case_labels",
+	"case_labels : case_labels case_label",
+	"case_labels : /* empty */",
+	"case_label : IDL_DEFAULT",
+	"case_label : IDL_DEFAULT ':'",
+	"case_label : IDL_CASE",
+	"case_label : IDL_CASE const_expr",
+	"case_label : IDL_CASE const_expr ':'",
+	"element_spec : type_spec",
+	"element_spec : type_spec declarator",
+	"enum_type : IDL_ENUM",
+	"enum_type : IDL_ENUM id",
+	"enum_type : IDL_ENUM id '{'",
+	"enum_type : IDL_ENUM id '{' at_least_one_enumerator",
+	"enum_type : IDL_ENUM id '{' at_least_one_enumerator '}'",
+	"at_least_one_enumerator : enumerator enumerators",
+	"enumerators : enumerators ','",
+	"enumerators : enumerators ',' enumerator",
+	"enumerators : /* empty */",
+	"enumerator : IDENTIFIER",
+	"sequence_type_spec : seq_head ','",
+	"sequence_type_spec : seq_head ',' positive_int_expr",
+	"sequence_type_spec : seq_head ',' positive_int_expr '>'",
+	"sequence_type_spec : seq_head '>'",
+	"seq_head : IDL_SEQUENCE",
+	"seq_head : IDL_SEQUENCE '<'",
+	"seq_head : IDL_SEQUENCE '<' simple_type_spec",
+	"string_type_spec : string_head '<'",
+	"string_type_spec : string_head '<' positive_int_expr",
+	"string_type_spec : string_head '<' positive_int_expr '>'",
+	"string_type_spec : string_head",
+	"string_head : IDL_STRING",
+	"wstring_type_spec : wstring_head '<'",
+	"wstring_type_spec : wstring_head '<' positive_int_expr",
+	"wstring_type_spec : wstring_head '<' positive_int_expr '>'",
+	"wstring_type_spec : wstring_head",
+	"wstring_head : IDL_WSTRING",
+	"array_declarator : id",
+	"array_declarator : id at_least_one_array_dim",
+	"at_least_one_array_dim : array_dim array_dims",
+	"array_dims : array_dims array_dim",
+	"array_dims : /* empty */",
+	"array_dim : '['",
+	"array_dim : '[' positive_int_expr",
+	"array_dim : '[' positive_int_expr ']'",
+	"attribute : opt_readonly IDL_ATTRIBUTE",
+	"attribute : opt_readonly IDL_ATTRIBUTE param_type_spec",
+	"attribute : opt_readonly IDL_ATTRIBUTE param_type_spec at_least_one_simple_declarator",
+	"opt_readonly : IDL_READONLY",
+	"opt_readonly : /* empty */",
+	"exception : IDL_EXCEPTION",
+	"exception : IDL_EXCEPTION id",
+	"exception : IDL_EXCEPTION id '{'",
+	"exception : IDL_EXCEPTION id '{' members",
+	"exception : IDL_EXCEPTION id '{' members '}'",
+	"operation : opt_op_attribute op_type_spec",
+	"operation : opt_op_attribute op_type_spec IDENTIFIER",
+	"operation : opt_op_attribute op_type_spec IDENTIFIER parameter_list",
+	"operation : opt_op_attribute op_type_spec IDENTIFIER parameter_list opt_raises",
+	"operation : opt_op_attribute op_type_spec IDENTIFIER parameter_list opt_raises opt_context",
+	"opt_op_attribute : IDL_ONEWAY",
+	"opt_op_attribute : IDL_IDEMPOTENT",
+	"opt_op_attribute : /* empty */",
+	"op_type_spec : param_type_spec",
+	"op_type_spec : IDL_VOID",
+	"parameter_list : '('",
+	"parameter_list : '(' ')'",
+	"parameter_list : '('",
+	"parameter_list : '(' at_least_one_parameter ')'",
+	"at_least_one_parameter : parameter parameters",
+	"parameters : parameters ','",
+	"parameters : parameters ',' parameter",
+	"parameters : /* empty */",
+	"parameter : direction",
+	"parameter : direction param_type_spec",
+	"parameter : direction param_type_spec declarator",
+	"param_type_spec : base_type_spec",
+	"param_type_spec : string_type_spec",
+	"param_type_spec : scoped_name",
+	"direction : IDL_IN",
+	"direction : IDL_OUT",
+	"direction : IDL_INOUT",
+	"opt_raises : IDL_RAISES",
+	"opt_raises : IDL_RAISES '('",
+	"opt_raises : IDL_RAISES '(' at_least_one_scoped_name ')'",
+	"opt_raises : /* empty */",
+	"opt_context : IDL_CONTEXT",
+	"opt_context : IDL_CONTEXT '('",
+	"opt_context : IDL_CONTEXT '(' at_least_one_string_literal ')'",
+	"opt_context : /* empty */",
+	"at_least_one_string_literal : IDL_STRING_LITERAL string_literals",
+	"string_literals : string_literals ','",
+	"string_literals : string_literals ',' IDL_STRING_LITERAL",
+	"string_literals : /* empty */",
+};
+#endif /* TAO_YYDEBUG */
+# line	1 "/usr/ccs/bin/yaccpar"
+/*
+ * Copyright (c) 1993 by Sun Microsystems, Inc.
+ */
+
+#if !defined (ACE_WIN32)
+#pragma ident	"@(#)yaccpar	6.12	93/06/07 SMI"
+#endif /* ACE_WIN32 */
+
+/*
+** Skeleton parser driver for yacc output
+*/
+
+/*
+** yacc user known macros and defines
+*/
+#define TAO_YYERROR		goto tao_yyerrlab
+#define TAO_YYACCEPT	return(0)
+#define TAO_YYABORT		return(1)
+#define TAO_YYBACKUP( newtoken, newvalue )\
+{\
+	if ( tao_yychar >= 0 || ( tao_yyr2[ tao_yytmp ] >> 1 ) != 1 )\
+	{\
+		tao_yyerror( "syntax error - cannot backup" );\
+		goto tao_yyerrlab;\
+	}\
+	tao_yychar = newtoken;\
+	tao_yystate = *tao_yyps;\
+	tao_yylval = newvalue;\
+	goto tao_yynewstate;\
 }
-#endif /* YYDEBUG_LOOK_AHEAD */
-#ifndef YYDEBUG_DISCARD_STATE
-#ifdef __cplusplus
-void YYDEBUG_DISCARD_STATE(int yynew_state, int yyindent)
-#else
-YYDEBUG_DISCARD_STATE(yynew_state, yyindent)
-int yynew_state;
-int yyindent;
+#define TAO_YYRECOVERING()	(!!tao_yyerrflag)
+#define TAO_YYNEW(type)	malloc(sizeof(type) * tao_yynewmax)
+#define TAO_YYCOPY(to, from, type) \
+	(type *) memcpy(to, (char *) from, tao_yynewmax * sizeof(type))
+#define TAO_YYENLARGE( from, type) \
+	(type *) realloc((char *) from, tao_yynewmax * sizeof(type))
+#ifndef TAO_YYDEBUG
+#	define TAO_YYDEBUG	1	/* make debugging available */
 #endif
-{
-    if (0 < yyindent)
-    {  /* draw the graphics for the reduction */
-        YYDEBUG_INDENT(yyindent-1);
-        printf("%s", YYDEBUG_REDUCE_STRING);
-        putchar('+'); /* left rotated L would look nice */
-        printf("  discarding state\n");
-        YYDEBUG_INDENT(yyindent-1);
-        putchar('|'); /* down arrow would look nice */
-        putchar('\n');
-    }
-    else
-    {
-        if (0 == yyindent)
-            printf("discarding state\n");
-        else
-            printf("no more states to discard: parser will abort\n");
-    }
-}
-#endif /* YYDEBUG_DISCARD_STATE */
-#ifndef YYDEBUG_DISCARD_TOKEN
-#ifdef __cplusplus
-void YYDEBUG_DISCARD_TOKEN(int yynew_state, int yytoken_num, char *yytoken_string, int yyindent)
+
+/*
+** user known globals
+*/
+int tao_yydebug;			/* set to 1 to get debugging */
+
+/*
+** driver internal defines
+*/
+#define TAO_YYFLAG		(-10000000)
+
+/*
+** global variables used by the parser
+*/
+TAO_YYSTYPE *tao_yypv;			/* top of value stack */
+int *tao_yyps;			/* top of state stack */
+
+int tao_yystate;			/* current state */
+int tao_yytmp;			/* extra var (lasts between blocks) */
+
+int tao_yynerrs;			/* number of errors */
+int tao_yyerrflag;			/* error recovery flag */
+int tao_yychar;			/* current input token number */
+
+
+
+#ifdef TAO_YYNMBCHARS
+#define TAO_YYLEX()		tao_yycvtok(tao_yylex())
+/*
+** tao_yycvtok - return a token if i is a wchar_t value that exceeds 255.
+**	If i<255, i itself is the token.  If i>255 but the neither 
+**	of the 30th or 31st bit is on, i is already a token.
+*/
+#if defined(__STDC__) || defined(__cplusplus)
+int tao_yycvtok(int i)
 #else
-YYDEBUG_DISCARD_TOKEN(yynew_state, yytoken_num, yytoken_string, yyindent)
-int yynew_state;
-int yytoken_num;
-char * yytoken_string;
-int yyindent;
+int tao_yycvtok(i) int i;
 #endif
 {
-    YYDEBUG_INDENT(yyindent);
-    printf("discarding token %s\n", yytoken_string);
+	int first = 0;
+	int last = TAO_YYNMBCHARS - 1;
+	int mid;
+	wchar_t j;
+
+	if(i&0x60000000){/*Must convert to a token. */
+		if( tao_yymbchars[last].character < i ){
+			return i;/*Giving up*/
+		}
+		while ((last>=first)&&(first>=0)) {/*Binary search loop*/
+			mid = (first+last)/2;
+			j = tao_yymbchars[mid].character;
+			if( j==i ){/*Found*/ 
+				return tao_yymbchars[mid].tvalue;
+			}else if( j<i ){
+				first = mid + 1;
+			}else{
+				last = mid -1;
+			}
+		}
+		/*No entry in the table.*/
+		return i;/* Giving up.*/
+	}else{/* i is already a token. */
+		return i;
+	}
 }
-#endif /* YYDEBUG_DISCARD_TOKEN */
-#ifndef YYDEBUG_SHIFT_ERROR_LEXEME
-#ifdef __cplusplus
-void YYDEBUG_SHIFT_ERROR_LEXEME(int yyold_state, int yynew_state, int yyindent)
+#else/*!TAO_YYNMBCHARS*/
+#define TAO_YYLEX()		tao_yylex()
+#endif/*!TAO_YYNMBCHARS*/
+
+/*
+** tao_yyparse - return 0 if worked, 1 if syntax error not recovered from
+*/
+#if defined(__STDC__) || defined(__cplusplus)
+int tao_yyparse(void)
 #else
-YYDEBUG_SHIFT_ERROR_LEXEME(yyold_state, yynew_state, yyindent)
-int yyold_state;
-int yynew_state;
-int yyindent;
+int tao_yyparse()
 #endif
 {
-    YYDEBUG_INDENT(yyindent);
-    printf("error\n");
-}
-#endif /* YYDEBUG_SHIFT_ERROR_LEXEME */
-#endif /* YYDEBUG */
-#ifdef __cplusplus
-extern "C" { extern char *getenv(const char *); }
-#endif
-int
-yyparse()
-{
-    register int yym, yyn, yystate;
-#if YYDEBUG
-    register char *yys;
-#ifndef __cplusplus
-    extern char *getenv();
-#endif
+	register TAO_YYSTYPE *tao_yypvt;	/* top of value stack for $vars */
 
-    if ((yys = getenv("YYDEBUG")))
-    {
-        yyn = *yys;
-        if (yyn >= '0' && yyn <= '9')
-            yydebug = yyn - '0';
-    }
+#if defined(__cplusplus) || defined(lint)
+/*
+	hacks to please C++ and lint - goto's inside switch should never be
+	executed; tao_yypvt is set to 0 to avoid "used before set" warning.
+*/
+	static int __yaccpar_lint_hack__ = 0;
+	switch (__yaccpar_lint_hack__)
+	{
+		case 1: goto tao_yyerrlab;
+		case 2: goto tao_yynewstate;
+	}
+	tao_yypvt = 0;
 #endif
 
-    yynerrs = 0;
-    yyerrflag = 0;
-    yychar = (-1);
-
-    yyssp = yyss;
-    yyvsp = yyvs;
-    *yyssp = yystate = 0;
-
-yyloop:
-    if ((yyn = yydefred[yystate])) goto yyreduce;
-    if (yychar < 0)
-    {
-        if ((yychar = yylex()) < 0) yychar = 0;
-#if YYDEBUG
-        if (yydebug)
-        {
-            yys = 0;
-            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
-            if (!yys) yys = "illegal-symbol";
-            if (5 < yydebug)
-                printf("yydebug: state %d, reading %d (%s)\n", yystate,
-                        yychar, yys);
-            else
-                YYDEBUG_LOOK_AHEAD(yystate, yychar, yys, yyssp-yyss);
-        }
-#endif
-    }
-    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
-            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
-    {
-#if YYDEBUG
-        if (yydebug)
-            if (5 < yydebug)
-                printf("yydebug: state %d, shifting to state %d\n",
-                        yystate, yytable[yyn]);
-            else
-                YYDEBUG_SHIFT_LEXEME(yystate, yytable[yyn], yys, yyssp-yyss);
-#endif
-        if (yyssp >= yyss + yystacksize - 1)
-        {
-            goto yyoverflow;
-        }
-        *++yyssp = yystate = yytable[yyn];
-        *++yyvsp = yylval;
-        yychar = (-1);
-        if (yyerrflag > 0)  --yyerrflag;
-        goto yyloop;
-    }
-    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
-            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
-    {
-        yyn = yytable[yyn];
-        goto yyreduce;
-    }
-    if (yyerrflag) goto yyinrecovery;
-#ifdef lint
-    goto yynewerror;
+	/*
+	** Initialize externals - tao_yyparse may be called more than once
+	*/
+	tao_yypv = &tao_yyv[-1];
+	tao_yyps = &tao_yys[-1];
+	tao_yystate = 0;
+	tao_yytmp = 0;
+	tao_yynerrs = 0;
+	tao_yyerrflag = 0;
+	tao_yychar = -1;
+
+#if TAO_YYMAXDEPTH <= 0
+	if (tao_yymaxdepth <= 0)
+	{
+		if ((tao_yymaxdepth = TAO_YYEXPAND(0)) <= 0)
+		{
+			tao_yyerror("yacc initialization error");
+			TAO_YYABORT;
+		}
+	}
 #endif
-yynewerror:
-    yyerror("syntax error");
-#ifdef lint
-    goto yyerrlab;
+
+	{
+		register TAO_YYSTYPE *tao_yy_pv;	/* top of value stack */
+		register int *tao_yy_ps;		/* top of state stack */
+		register int tao_yy_state;		/* current state */
+		register int  tao_yy_n;		/* internal state number info */
+	goto tao_yystack;	/* moved from 6 lines above to here to please C++ */
+
+		/*
+		** get globals into registers.
+		** branch to here only if TAO_YYBACKUP was called.
+		*/
+	tao_yynewstate:
+		tao_yy_pv = tao_yypv;
+		tao_yy_ps = tao_yyps;
+		tao_yy_state = tao_yystate;
+		goto tao_yy_newstate;
+
+		/*
+		** get globals into registers.
+		** either we just started, or we just finished a reduction
+		*/
+	tao_yystack:
+		tao_yy_pv = tao_yypv;
+		tao_yy_ps = tao_yyps;
+		tao_yy_state = tao_yystate;
+
+		/*
+		** top of for (;;) loop while no reductions done
+		*/
+	tao_yy_stack:
+		/*
+		** put a state and value onto the stacks
+		*/
+#if TAO_YYDEBUG
+		/*
+		** if debugging, look up token value in list of value vs.
+		** name pairs.  0 and negative (-1) are special values.
+		** Note: linear search is used since time is not a real
+		** consideration while debugging.
+		*/
+		if ( tao_yydebug )
+		{
+			register int tao_yy_i;
+
+			printf( "State %d, token ", tao_yy_state );
+			if ( tao_yychar == 0 )
+				printf( "end-of-file\n" );
+			else if ( tao_yychar < 0 )
+				printf( "-none-\n" );
+			else
+			{
+				for ( tao_yy_i = 0; tao_yytoks[tao_yy_i].t_val >= 0;
+					tao_yy_i++ )
+				{
+					if ( tao_yytoks[tao_yy_i].t_val == tao_yychar )
+						break;
+				}
+				printf( "%s\n", tao_yytoks[tao_yy_i].t_name );
+			}
+		}
+#endif /* TAO_YYDEBUG */
+		if ( ++tao_yy_ps >= &tao_yys[ tao_yymaxdepth ] )	/* room on stack? */
+		{
+			/*
+			** reallocate and recover.  Note that pointers
+			** have to be reset, or bad things will happen
+			*/
+			int tao_yyps_index = (tao_yy_ps - tao_yys);
+			int tao_yypv_index = (tao_yy_pv - tao_yyv);
+			int tao_yypvt_index = (tao_yypvt - tao_yyv);
+			int tao_yynewmax;
+#ifdef TAO_YYEXPAND
+			tao_yynewmax = TAO_YYEXPAND(tao_yymaxdepth);
+#else
+			tao_yynewmax = 2 * tao_yymaxdepth;	/* double table size */
+			if (tao_yymaxdepth == TAO_YYMAXDEPTH)	/* first time growth */
+			{
+				char *newtao_yys = (char *)TAO_YYNEW(int);
+				char *newtao_yyv = (char *)TAO_YYNEW(TAO_YYSTYPE);
+				if (newtao_yys != 0 && newtao_yyv != 0)
+				{
+					tao_yys = TAO_YYCOPY(newtao_yys, tao_yys, int);
+					tao_yyv = TAO_YYCOPY(newtao_yyv, tao_yyv, TAO_YYSTYPE);
+				}
+				else
+					tao_yynewmax = 0;	/* failed */
+			}
+			else				/* not first time */
+			{
+				tao_yys = TAO_YYENLARGE(tao_yys, int);
+				tao_yyv = TAO_YYENLARGE(tao_yyv, TAO_YYSTYPE);
+				if (tao_yys == 0 || tao_yyv == 0)
+					tao_yynewmax = 0;	/* failed */
+			}
 #endif
-yyerrlab:
-    ++yynerrs;
-yyinrecovery:
-    if (yyerrflag < 3)
-    {
-        yyerrflag = 3;
-        for (;;)
-        {
-            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
-                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
-            {
-#if YYDEBUG
-                if (yydebug)
-                    if (5 < yydebug)
-                        printf("yydebug: state %d, error recovery shifting\
- to state %d\n", *yyssp, yytable[yyn]);
-                    else
-                        YYDEBUG_SHIFT_ERROR_LEXEME(*yyssp, yytable[yyn], yyssp-yyss);
+			if (tao_yynewmax <= tao_yymaxdepth)	/* tables not expanded */
+			{
+				tao_yyerror( "yacc stack overflow" );
+				TAO_YYABORT;
+			}
+			tao_yymaxdepth = tao_yynewmax;
+
+			tao_yy_ps = tao_yys + tao_yyps_index;
+			tao_yy_pv = tao_yyv + tao_yypv_index;
+			tao_yypvt = tao_yyv + tao_yypvt_index;
+		}
+		*tao_yy_ps = tao_yy_state;
+		*++tao_yy_pv = tao_yyval;
+
+		/*
+		** we have a new state - find out what to do
+		*/
+	tao_yy_newstate:
+		if ( ( tao_yy_n = tao_yypact[ tao_yy_state ] ) <= TAO_YYFLAG )
+			goto tao_yydefault;		/* simple state */
+#if TAO_YYDEBUG
+		/*
+		** if debugging, need to mark whether new token grabbed
+		*/
+		tao_yytmp = tao_yychar < 0;
 #endif
-                if (yyssp >= yyss + yystacksize - 1)
-                {
-                    goto yyoverflow;
-                }
-                *++yyssp = yystate = yytable[yyn];
-                *++yyvsp = yylval;
-                goto yyloop;
-            }
-            else
-            {
-#if YYDEBUG
-                if (yydebug)
-                    if (5 < yydebug)
-                        printf("yydebug: error recovery discarding state %d\
-",
-                            *yyssp);
-                    else
-                        YYDEBUG_DISCARD_STATE(*yyssp, yyssp-yyss-1);
+		if ( ( tao_yychar < 0 ) && ( ( tao_yychar = TAO_YYLEX() ) < 0 ) )
+			tao_yychar = 0;		/* reached EOF */
+#if TAO_YYDEBUG
+		if ( tao_yydebug && tao_yytmp )
+		{
+			register int tao_yy_i;
+
+			printf( "Received token " );
+			if ( tao_yychar == 0 )
+				printf( "end-of-file\n" );
+			else if ( tao_yychar < 0 )
+				printf( "-none-\n" );
+			else
+			{
+				for ( tao_yy_i = 0; tao_yytoks[tao_yy_i].t_val >= 0;
+					tao_yy_i++ )
+				{
+					if ( tao_yytoks[tao_yy_i].t_val == tao_yychar )
+						break;
+				}
+				printf( "%s\n", tao_yytoks[tao_yy_i].t_name );
+			}
+		}
+#endif /* TAO_YYDEBUG */
+		if ( ( ( tao_yy_n += tao_yychar ) < 0 ) || ( tao_yy_n >= TAO_YYLAST ) )
+			goto tao_yydefault;
+		if ( tao_yychk[ tao_yy_n = tao_yyact[ tao_yy_n ] ] == tao_yychar )	/*valid shift*/
+		{
+			tao_yychar = -1;
+			tao_yyval = tao_yylval;
+			tao_yy_state = tao_yy_n;
+			if ( tao_yyerrflag > 0 )
+				tao_yyerrflag--;
+			goto tao_yy_stack;
+		}
+
+	tao_yydefault:
+		if ( ( tao_yy_n = tao_yydef[ tao_yy_state ] ) == -2 )
+		{
+#if TAO_YYDEBUG
+			tao_yytmp = tao_yychar < 0;
 #endif
-                if (yyssp <= yyss) goto yyabort;
-                --yyssp;
-                --yyvsp;
-            }
-        }
-    }
-    else
-    {
-        if (yychar == 0) goto yyabort;
-#if YYDEBUG
-        if (yydebug)
-        {
-            yys = 0;
-            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
-            if (!yys) yys = "illegal-symbol";
-            if (5 < yydebug)
-                printf("yydebug: state %d, error recovery discards token %d (%s)\n",
-                    yystate, yychar, yys);
-            else 
-                YYDEBUG_DISCARD_TOKEN(yystate, yychar, yys, yyssp-yyss);
-        }
+			if ( ( tao_yychar < 0 ) && ( ( tao_yychar = TAO_YYLEX() ) < 0 ) )
+				tao_yychar = 0;		/* reached EOF */
+#if TAO_YYDEBUG
+			if ( tao_yydebug && tao_yytmp )
+			{
+				register int tao_yy_i;
+
+				printf( "Received token " );
+				if ( tao_yychar == 0 )
+					printf( "end-of-file\n" );
+				else if ( tao_yychar < 0 )
+					printf( "-none-\n" );
+				else
+				{
+					for ( tao_yy_i = 0;
+						tao_yytoks[tao_yy_i].t_val >= 0;
+						tao_yy_i++ )
+					{
+						if ( tao_yytoks[tao_yy_i].t_val
+							== tao_yychar )
+						{
+							break;
+						}
+					}
+					printf( "%s\n", tao_yytoks[tao_yy_i].t_name );
+				}
+			}
+#endif /* TAO_YYDEBUG */
+			/*
+			** look through exception table
+			*/
+			{
+				register int *tao_yyxi = tao_yyexca;
+
+				while ( ( *tao_yyxi != -1 ) ||
+					( tao_yyxi[1] != tao_yy_state ) )
+				{
+					tao_yyxi += 2;
+				}
+				while ( ( *(tao_yyxi += 2) >= 0 ) &&
+					( *tao_yyxi != tao_yychar ) )
+					;
+				if ( ( tao_yy_n = tao_yyxi[1] ) < 0 )
+					TAO_YYACCEPT;
+			}
+		}
+
+		/*
+		** check for syntax error
+		*/
+		if ( tao_yy_n == 0 )	/* have an error */
+		{
+			/* no worry about speed here! */
+			switch ( tao_yyerrflag )
+			{
+			case 0:		/* new error */
+				tao_yyerror( "syntax error" );
+				goto skip_init;
+			tao_yyerrlab:
+				/*
+				** get globals into registers.
+				** we have a user generated syntax type error
+				*/
+				tao_yy_pv = tao_yypv;
+				tao_yy_ps = tao_yyps;
+				tao_yy_state = tao_yystate;
+			skip_init:
+				tao_yynerrs++;
+				/* FALLTHRU */
+			case 1:
+			case 2:		/* incompletely recovered error */
+					/* try again... */
+				tao_yyerrflag = 3;
+				/*
+				** find state where "error" is a legal
+				** shift action
+				*/
+				while ( tao_yy_ps >= tao_yys )
+				{
+					tao_yy_n = tao_yypact[ *tao_yy_ps ] + TAO_YYERRCODE;
+					if ( tao_yy_n >= 0 && tao_yy_n < TAO_YYLAST &&
+						tao_yychk[tao_yyact[tao_yy_n]] == TAO_YYERRCODE)					{
+						/*
+						** simulate shift of "error"
+						*/
+						tao_yy_state = tao_yyact[ tao_yy_n ];
+						goto tao_yy_stack;
+					}
+					/*
+					** current state has no shift on
+					** "error", pop stack
+					*/
+#if TAO_YYDEBUG
+#	define _POP_ "Error recovery pops state %d, uncovers state %d\n"
+					if ( tao_yydebug )
+						printf( _POP_, *tao_yy_ps,
+							tao_yy_ps[-1] );
+#	undef _POP_
 #endif
-        yychar = (-1);
-        goto yyloop;
-    }
-yyreduce:
-    yym = yylen[yyn];
-    yyval = yyvsp[1-yym];
-#if YYDEBUG
-    if (yydebug)
-        if (5 < yydebug)
-            printf("yydebug: state %d, reducing by rule %d (%s)\n",
-                    yystate, yyn, yyrule[yyn]);
-        else
-            YYDEBUG_REDUCE(yystate, yyn, yyrule[yyn], yyssp-yyss-yym, yym);
+					tao_yy_ps--;
+					tao_yy_pv--;
+				}
+				/*
+				** there is no state on stack with "error" as
+				** a valid shift.  give up.
+				*/
+				TAO_YYABORT;
+			case 3:		/* no shift yet; eat a token */
+#if TAO_YYDEBUG
+				/*
+				** if debugging, look up token in list of
+				** pairs.  0 and negative shouldn't occur,
+				** but since timing doesn't matter when
+				** debugging, it doesn't hurt to leave the
+				** tests here.
+				*/
+				if ( tao_yydebug )
+				{
+					register int tao_yy_i;
+
+					printf( "Error recovery discards " );
+					if ( tao_yychar == 0 )
+						printf( "token end-of-file\n" );
+					else if ( tao_yychar < 0 )
+						printf( "token -none-\n" );
+					else
+					{
+						for ( tao_yy_i = 0;
+							tao_yytoks[tao_yy_i].t_val >= 0;
+							tao_yy_i++ )
+						{
+							if ( tao_yytoks[tao_yy_i].t_val
+								== tao_yychar )
+							{
+								break;
+							}
+						}
+						printf( "token %s\n",
+							tao_yytoks[tao_yy_i].t_name );
+					}
+				}
+#endif /* TAO_YYDEBUG */
+				if ( tao_yychar == 0 )	/* reached EOF. quit */
+					TAO_YYABORT;
+				tao_yychar = -1;
+				goto tao_yy_newstate;
+			}
+		}/* end if ( tao_yy_n == 0 ) */
+		/*
+		** reduction by production tao_yy_n
+		** put stack tops, etc. so things right after switch
+		*/
+#if TAO_YYDEBUG
+		/*
+		** if debugging, print the string that is the user's
+		** specification of the reduction which is just about
+		** to be done.
+		*/
+		if ( tao_yydebug )
+			printf( "Reduce by (%d) \"%s\"\n",
+				tao_yy_n, tao_yyreds[ tao_yy_n ] );
 #endif
-    switch (yyn)
-    {
+		tao_yytmp = tao_yy_n;			/* value to switch over */
+		tao_yypvt = tao_yy_pv;			/* $vars top of value stack */
+		/*
+		** Look in goto table for next state
+		** Sorry about using tao_yy_state here as temporary
+		** register variable, but why not, if it works...
+		** If tao_yyr2[ tao_yy_n ] doesn't have the low order bit
+		** set, then there is no action to be done for
+		** this reduction.  So, no saving & unsaving of
+		** registers done.  The only difference between the
+		** code just after the if and the body of the if is
+		** the goto tao_yy_stack in the body.  This way the test
+		** can be made before the choice of what to do is needed.
+		*/
+		{
+			/* length of production doubled with extra bit */
+			register int tao_yy_len = tao_yyr2[ tao_yy_n ];
+
+			if ( !( tao_yy_len & 01 ) )
+			{
+				tao_yy_len >>= 1;
+				tao_yyval = ( tao_yy_pv -= tao_yy_len )[1];	/* $$ = $1 */
+				tao_yy_state = tao_yypgo[ tao_yy_n = tao_yyr1[ tao_yy_n ] ] +
+					*( tao_yy_ps -= tao_yy_len ) + 1;
+				if ( tao_yy_state >= TAO_YYLAST ||
+					tao_yychk[ tao_yy_state =
+					tao_yyact[ tao_yy_state ] ] != -tao_yy_n )
+				{
+					tao_yy_state = tao_yyact[ tao_yypgo[ tao_yy_n ] ];
+				}
+				goto tao_yy_stack;
+			}
+			tao_yy_len >>= 1;
+			tao_yyval = ( tao_yy_pv -= tao_yy_len )[1];	/* $$ = $1 */
+			tao_yy_state = tao_yypgo[ tao_yy_n = tao_yyr1[ tao_yy_n ] ] +
+				*( tao_yy_ps -= tao_yy_len ) + 1;
+			if ( tao_yy_state >= TAO_YYLAST ||
+				tao_yychk[ tao_yy_state = tao_yyact[ tao_yy_state ] ] != -tao_yy_n )
+			{
+				tao_yy_state = tao_yyact[ tao_yypgo[ tao_yy_n ] ];
+			}
+		}
+					/* save until reenter driver code */
+		tao_yystate = tao_yy_state;
+		tao_yyps = tao_yy_ps;
+		tao_yypv = tao_yy_pv;
+	}
+	/*
+	** code supplied by user is placed in this switch
+	*/
+	switch( tao_yytmp )
+	{
+		
 case 4:
-#line 240 "idl.yy"
+# line 240 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_TypeDeclSeen);
-        }
-break;
+        } break;
 case 5:
-#line 244 "idl.yy"
+# line 244 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-        }
-break;
+        } break;
 case 6:
-#line 248 "idl.yy"
+# line 248 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ConstDeclSeen);
-        }
-break;
+        } break;
 case 7:
-#line 252 "idl.yy"
+# line 252 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-        }
-break;
+        } break;
 case 8:
-#line 256 "idl.yy"
+# line 256 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ExceptDeclSeen);
-        }
-break;
+        } break;
 case 9:
-#line 260 "idl.yy"
+# line 260 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-        }
-break;
+        } break;
 case 10:
-#line 264 "idl.yy"
+# line 264 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_InterfaceDeclSeen);
-        }
-break;
+        } break;
 case 11:
-#line 268 "idl.yy"
+# line 268 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-        }
-break;
+        } break;
 case 12:
-#line 272 "idl.yy"
+# line 272 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ModuleDeclSeen);
-        }
-break;
+        } break;
 case 13:
-#line 276 "idl.yy"
+# line 276 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-        }
-break;
+        } break;
 case 14:
-#line 280 "idl.yy"
+# line 280 "idl.tao_yy"
 {
 	  idl_global->err()->syntax_error(idl_global->parse_state());
-	}
-break;
+	} break;
 case 15:
-#line 284 "idl.yy"
+# line 284 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-	  yyerrok;
-	}
-break;
+	  tao_yyerrok;
+	} break;
 case 16:
-#line 291 "idl.yy"
+# line 291 "idl.tao_yy"
 {
 	    idl_global->set_parse_state(IDL_GlobalData::PS_ModuleSeen);
-	  }
-break;
+	  } break;
 case 17:
-#line 295 "idl.yy"
+# line 295 "idl.tao_yy"
 {
 	    UTL_ScopedName 	*n =
-		new UTL_ScopedName(new Identifier(yyvsp[0].strval, 1, 0, I_FALSE), NULL);
+		new UTL_ScopedName(new Identifier(tao_yypvt[-0].strval, 1, 0, I_FALSE), NULL);
 	    AST_Module		*m = NULL;
 	    UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	    UTL_StrList		*p = idl_global->pragmas();
@@ -1217,32 +1453,28 @@ case 17:
 	     * Push it on the stack
 	     */
 	    idl_global->scopes()->push(m);
-	  }
-break;
+	  } break;
 case 18:
-#line 316 "idl.yy"
+# line 316 "idl.tao_yy"
 {
 	    idl_global->set_parse_state(IDL_GlobalData::PS_ModuleSqSeen);
-	  }
-break;
+	  } break;
 case 19:
-#line 320 "idl.yy"
+# line 320 "idl.tao_yy"
 {
 	    idl_global->set_parse_state(IDL_GlobalData::PS_ModuleBodySeen);
-	  }
-break;
+	  } break;
 case 20:
-#line 324 "idl.yy"
+# line 324 "idl.tao_yy"
 {
 	    idl_global->set_parse_state(IDL_GlobalData::PS_ModuleQsSeen);
 	    /*
 	     * Finished with this module - pop it from the scope stack
 	     */
 	    idl_global->scopes()->pop();
-	  }
-break;
+	  } break;
 case 23:
-#line 340 "idl.yy"
+# line 340 "idl.tao_yy"
 {
 	  UTL_Scope     *s = idl_global->scopes()->top_non_null();
 	  AST_Interface *i = NULL;
@@ -1256,10 +1488,10 @@ case 23:
 	  /*
 	   * Make a new interface node and add it to its enclosing scope
 	   */
-	  if (s != NULL && yyvsp[0].ihval != NULL) {
-	    i = idl_global->gen()->create_interface(yyvsp[0].ihval->interface_name(),
-						    yyvsp[0].ihval->inherits(),
-						    yyvsp[0].ihval->n_inherits(),
+	  if (s != NULL && tao_yypvt[-0].ihval != NULL) {
+	    i = idl_global->gen()->create_interface(tao_yypvt[-0].ihval->interface_name(),
+						    tao_yypvt[-0].ihval->inherits(),
+						    tao_yypvt[-0].ihval->n_inherits(),
 						    p);
 	    if (i != NULL &&
 		(d = s->lookup_by_name(i->name(), I_FALSE)) != NULL) {
@@ -1297,8 +1529,8 @@ case 23:
 		   * All OK, do the redefinition
 		   */
 		  else {
-		    fd->set_inherits(yyvsp[0].ihval->inherits());
-		    fd->set_n_inherits(yyvsp[0].ihval->n_inherits());
+		    fd->set_inherits(tao_yypvt[-0].ihval->inherits());
+		    fd->set_n_inherits(tao_yypvt[-0].ihval->n_inherits());
 		    /*
 		     * Update place of definition
 		     */
@@ -1325,45 +1557,39 @@ case 23:
 	   * Push it on the scope stack
 	   */
 	  idl_global->scopes()->push(i);
-        }
-break;
+        } break;
 case 24:
-#line 424 "idl.yy"
+# line 424 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_InterfaceSqSeen);
-	}
-break;
+	} break;
 case 25:
-#line 428 "idl.yy"
+# line 428 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_InterfaceBodySeen);
-	}
-break;
+	} break;
 case 26:
-#line 432 "idl.yy"
+# line 432 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_InterfaceQsSeen);
 	  /*
 	   * Done with this interface - pop it off the scopes stack
 	   */
 	  idl_global->scopes()->pop();
-	}
-break;
+	} break;
 case 27:
-#line 443 "idl.yy"
+# line 443 "idl.tao_yy"
 {
 	   idl_global->set_parse_state(IDL_GlobalData::PS_InterfaceSeen);
-	 }
-break;
+	 } break;
 case 28:
-#line 447 "idl.yy"
+# line 447 "idl.tao_yy"
 {
 	   idl_global->set_parse_state(IDL_GlobalData::PS_InterfaceIDSeen);
-	   yyval.idval = yyvsp[0].idval;
-	 }
-break;
+	   tao_yyval.idval = tao_yypvt[-0].idval;
+	 } break;
 case 29:
-#line 455 "idl.yy"
+# line 455 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_InheritSpecSeen);
 	  /*
@@ -1372,180 +1598,154 @@ case 29:
 	   * list of all interfaces which this interface inherits from,
 	   * recursively
 	   */
-	  yyval.ihval = new FE_InterfaceHeader(new UTL_ScopedName(yyvsp[-1].idval, NULL), yyvsp[0].nlval);
-	}
-break;
+	  tao_yyval.ihval = new FE_InterfaceHeader(new UTL_ScopedName(tao_yypvt[-1].idval, NULL), tao_yypvt[-0].nlval);
+	} break;
 case 30:
-#line 469 "idl.yy"
+# line 469 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_InheritColonSeen);
-        }
-break;
+        } break;
 case 31:
-#line 473 "idl.yy"
+# line 473 "idl.tao_yy"
 {
-	  yyval.nlval = yyvsp[0].nlval;
-	}
-break;
+	  tao_yyval.nlval = tao_yypvt[-0].nlval;
+	} break;
 case 32:
-#line 477 "idl.yy"
+# line 477 "idl.tao_yy"
 {
-	  yyval.nlval = NULL;
-	}
-break;
+	  tao_yyval.nlval = NULL;
+	} break;
 case 35:
-#line 489 "idl.yy"
+# line 489 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_TypeDeclSeen);
-        }
-break;
+        } break;
 case 36:
-#line 493 "idl.yy"
+# line 493 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-        }
-break;
+        } break;
 case 37:
-#line 497 "idl.yy"
+# line 497 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ConstDeclSeen);
-        }
-break;
+        } break;
 case 38:
-#line 501 "idl.yy"
+# line 501 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-        }
-break;
+        } break;
 case 39:
-#line 505 "idl.yy"
+# line 505 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ExceptDeclSeen);
-        }
-break;
+        } break;
 case 40:
-#line 509 "idl.yy"
+# line 509 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-        }
-break;
+        } break;
 case 41:
-#line 513 "idl.yy"
+# line 513 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_AttrDeclSeen);
-        }
-break;
+        } break;
 case 42:
-#line 517 "idl.yy"
+# line 517 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-        }
-break;
+        } break;
 case 43:
-#line 521 "idl.yy"
+# line 521 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpDeclSeen);
-        }
-break;
+        } break;
 case 44:
-#line 525 "idl.yy"
+# line 525 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-        }
-break;
+        } break;
 case 45:
-#line 529 "idl.yy"
+# line 529 "idl.tao_yy"
 {
 	  idl_global->err()->syntax_error(idl_global->parse_state());
-	}
-break;
+	} break;
 case 46:
-#line 533 "idl.yy"
+# line 533 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-	  yyerrok;
-	}
-break;
+	  tao_yyerrok;
+	} break;
 case 47:
-#line 541 "idl.yy"
+# line 541 "idl.tao_yy"
 {
-	  yyval.nlval = new UTL_NameList(yyvsp[-1].idlist, yyvsp[0].nlval);
-	}
-break;
+	  tao_yyval.nlval = new UTL_NameList(tao_yypvt[-1].idlist, tao_yypvt[-0].nlval);
+	} break;
 case 48:
-#line 549 "idl.yy"
+# line 549 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SNListCommaSeen);
-        }
-break;
+        } break;
 case 49:
-#line 553 "idl.yy"
+# line 553 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ScopedNameSeen);
 
-	  if (yyvsp[-3].nlval == NULL)
-	    yyval.nlval = new UTL_NameList(yyvsp[0].idlist, NULL);
+	  if (tao_yypvt[-3].nlval == NULL)
+	    tao_yyval.nlval = new UTL_NameList(tao_yypvt[-0].idlist, NULL);
 	  else {
-	    yyvsp[-3].nlval->nconc(new UTL_NameList(yyvsp[0].idlist, NULL));
-	    yyval.nlval = yyvsp[-3].nlval;
+	    tao_yypvt[-3].nlval->nconc(new UTL_NameList(tao_yypvt[-0].idlist, NULL));
+	    tao_yyval.nlval = tao_yypvt[-3].nlval;
 	  }
-	}
-break;
+	} break;
 case 50:
-#line 564 "idl.yy"
+# line 564 "idl.tao_yy"
 {
-	  yyval.nlval = NULL;
-	}
-break;
+	  tao_yyval.nlval = NULL;
+	} break;
 case 51:
-#line 571 "idl.yy"
+# line 571 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SN_IDSeen);
 
-	  yyval.idlist = new UTL_IdList(yyvsp[0].idval, NULL);
-	}
-break;
+	  tao_yyval.idlist = new UTL_IdList(tao_yypvt[-0].idval, NULL);
+	} break;
 case 52:
-#line 577 "idl.yy"
+# line 577 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ScopeDelimSeen);
-        }
-break;
+        } break;
 case 53:
-#line 581 "idl.yy"
+# line 581 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SN_IDSeen);
 
-	  yyval.idlist = new UTL_IdList(new Identifier(yyvsp[-2].strval, 1, 0, I_FALSE),
-			      new UTL_IdList(yyvsp[0].idval, NULL));
-	}
-break;
+	  tao_yyval.idlist = new UTL_IdList(new Identifier(tao_yypvt[-2].strval, 1, 0, I_FALSE),
+			      new UTL_IdList(tao_yypvt[-0].idval, NULL));
+	} break;
 case 54:
-#line 589 "idl.yy"
+# line 589 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ScopeDelimSeen);
-        }
-break;
+        } break;
 case 55:
-#line 593 "idl.yy"
+# line 593 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SN_IDSeen);
 
-	  yyvsp[-3].idlist->nconc(new UTL_IdList(yyvsp[0].idval, NULL));
-	  yyval.idlist = yyvsp[-3].idlist;
-	}
-break;
+	  tao_yypvt[-3].idlist->nconc(new UTL_IdList(tao_yypvt[-0].idval, NULL));
+	  tao_yyval.idlist = tao_yypvt[-3].idlist;
+	} break;
 case 56:
-#line 602 "idl.yy"
+# line 602 "idl.tao_yy"
 {
-            yyval.idval = new Identifier(yyvsp[0].strval, 1, 0, I_FALSE);
-        }
-break;
+            tao_yyval.idval = new Identifier(tao_yypvt[-0].strval, 1, 0, I_FALSE);
+        } break;
 case 57:
-#line 609 "idl.yy"
+# line 609 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
-	  UTL_ScopedName	*n = new UTL_ScopedName(yyvsp[0].idval, NULL);
+	  UTL_ScopedName	*n = new UTL_ScopedName(tao_yypvt[-0].idval, NULL);
 	  AST_InterfaceFwd	*f = NULL;
 	  UTL_StrList		*p = idl_global->pragmas();
 
@@ -1558,36 +1758,31 @@ case 57:
 	    f = idl_global->gen()->create_interface_fwd(n, p);
 	    (void) s->fe_add_interface_fwd(f);
 	  }
-	}
-break;
+	} break;
 case 58:
-#line 629 "idl.yy"
+# line 629 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ConstSeen);
-        }
-break;
+        } break;
 case 59:
-#line 633 "idl.yy"
+# line 633 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ConstTypeSeen);
-        }
-break;
+        } break;
 case 60:
-#line 637 "idl.yy"
+# line 637 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ConstIDSeen);
-        }
-break;
+        } break;
 case 61:
-#line 641 "idl.yy"
+# line 641 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ConstAssignSeen);
-        }
-break;
+        } break;
 case 62:
-#line 645 "idl.yy"
+# line 645 "idl.tao_yy"
 {
-	  UTL_ScopedName	*n = new UTL_ScopedName(yyvsp[-4].idval, NULL);
+	  UTL_ScopedName	*n = new UTL_ScopedName(tao_yypvt[-4].idval, NULL);
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  AST_Constant		*c = NULL;
 	  UTL_StrList		*p = idl_global->pragmas();
@@ -1600,31 +1795,28 @@ case 62:
 	   * Create a node representing a constant declaration. Store
 	   * it in the enclosing scope
 	   */
-	  if (yyvsp[0].exval != NULL && s != NULL) {
-	    if (yyvsp[0].exval->coerce(yyvsp[-6].etval) == NULL)
-	      idl_global->err()->coercion_error(yyvsp[0].exval, yyvsp[-6].etval);
+	  if (tao_yypvt[-0].exval != NULL && s != NULL) {
+	    if (tao_yypvt[-0].exval->coerce(tao_yypvt[-6].etval) == NULL)
+	      idl_global->err()->coercion_error(tao_yypvt[-0].exval, tao_yypvt[-6].etval);
 	    else {
 	      c =
-		idl_global->gen()->create_constant(yyvsp[-6].etval, yyvsp[0].exval, n, p);
+		idl_global->gen()->create_constant(tao_yypvt[-6].etval, tao_yypvt[-0].exval, n, p);
 	      (void) s->fe_add_constant(c);
 	    }
 	  }
-	}
-break;
+	} break;
 case 68:
-#line 678 "idl.yy"
+# line 678 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_string;
-	}
-break;
+	  tao_yyval.etval = AST_Expression::EV_string;
+	} break;
 case 69:
-#line 682 "idl.yy"
+# line 682 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_wstring;
-        }
-break;
+	  tao_yyval.etval = AST_Expression::EV_wstring;
+        } break;
 case 70:
-#line 686 "idl.yy"
+# line 686 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  AST_Decl		*d = NULL;
@@ -1635,7 +1827,7 @@ case 70:
 	   * If the constant's type is a scoped name, it must resolve
 	   * to a scalar constant type
 	   */
-	  if (s != NULL && (d = s->lookup_by_name(yyvsp[0].idlist, I_TRUE)) != NULL) {
+	  if (s != NULL && (d = s->lookup_by_name(tao_yypvt[-0].idlist, I_TRUE)) != NULL) {
 	    /*
 	     * Look through typedefs
 	     */
@@ -1646,190 +1838,162 @@ case 70:
 	      d = t->base_type();
 	    }
 	    if (d == NULL)
-	      yyval.etval = AST_Expression::EV_any;
+	      tao_yyval.etval = AST_Expression::EV_any;
 	    else if (d->node_type() == AST_Decl::NT_pre_defined) {
 	      c = AST_PredefinedType::narrow_from_decl(d);
 	      if (c != NULL) {
-	         yyval.etval = idl_global->PredefinedTypeToExprType(c->pt());
+	         tao_yyval.etval = idl_global->PredefinedTypeToExprType(c->pt());
 	      } else {
-	         yyval.etval = AST_Expression::EV_any;
+	         tao_yyval.etval = AST_Expression::EV_any;
 	      }
 	    } else
-	      yyval.etval = AST_Expression::EV_any;
+	      tao_yyval.etval = AST_Expression::EV_any;
 	  } else
-	    yyval.etval = AST_Expression::EV_any;
-	}
-break;
+	    tao_yyval.etval = AST_Expression::EV_any;
+	} break;
 case 74:
-#line 728 "idl.yy"
+# line 728 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_or, yyvsp[-2].exval, yyvsp[0].exval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_or, tao_yypvt[-2].exval, tao_yypvt[-0].exval);
+	} break;
 case 76:
-#line 736 "idl.yy"
+# line 736 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_xor, yyvsp[-2].exval, yyvsp[0].exval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_xor, tao_yypvt[-2].exval, tao_yypvt[-0].exval);
+	} break;
 case 78:
-#line 744 "idl.yy"
+# line 744 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_and, yyvsp[-2].exval, yyvsp[0].exval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_and, tao_yypvt[-2].exval, tao_yypvt[-0].exval);
+	} break;
 case 80:
-#line 752 "idl.yy"
+# line 752 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_right,yyvsp[-2].exval,yyvsp[0].exval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_right,tao_yypvt[-2].exval,tao_yypvt[-0].exval);
+	} break;
 case 81:
-#line 756 "idl.yy"
+# line 756 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_left,yyvsp[-2].exval,yyvsp[0].exval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_left,tao_yypvt[-2].exval,tao_yypvt[-0].exval);
+	} break;
 case 83:
-#line 764 "idl.yy"
+# line 764 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_add, yyvsp[-2].exval, yyvsp[0].exval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_add, tao_yypvt[-2].exval, tao_yypvt[-0].exval);
+	} break;
 case 84:
-#line 768 "idl.yy"
+# line 768 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_minus,yyvsp[-2].exval,yyvsp[0].exval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_minus,tao_yypvt[-2].exval,tao_yypvt[-0].exval);
+	} break;
 case 86:
-#line 776 "idl.yy"
+# line 776 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_mul, yyvsp[-2].exval, yyvsp[0].exval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_mul, tao_yypvt[-2].exval, tao_yypvt[-0].exval);
+	} break;
 case 87:
-#line 780 "idl.yy"
+# line 780 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_div, yyvsp[-2].exval, yyvsp[0].exval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_div, tao_yypvt[-2].exval, tao_yypvt[-0].exval);
+	} break;
 case 88:
-#line 784 "idl.yy"
+# line 784 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_mod, yyvsp[-2].exval, yyvsp[0].exval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_mod, tao_yypvt[-2].exval, tao_yypvt[-0].exval);
+	} break;
 case 90:
-#line 792 "idl.yy"
+# line 792 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_u_plus,
-					      yyvsp[0].exval,
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_u_plus,
+					      tao_yypvt[-0].exval,
 					      NULL);
-	}
-break;
+	} break;
 case 91:
-#line 798 "idl.yy"
+# line 798 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_u_minus,
-					      yyvsp[0].exval,
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_u_minus,
+					      tao_yypvt[-0].exval,
 					      NULL);
-	}
-break;
+	} break;
 case 92:
-#line 804 "idl.yy"
+# line 804 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_bit_neg,
-					      yyvsp[0].exval,
+	  tao_yyval.exval = idl_global->gen()->create_expr(AST_Expression::EC_bit_neg,
+					      tao_yypvt[-0].exval,
 					      NULL);
-	}
-break;
+	} break;
 case 93:
-#line 813 "idl.yy"
+# line 813 "idl.tao_yy"
 {
 	  /*
 	   * An expression which is a scoped name is not resolved now,
 	   * but only when it is evaluated (such as when it is assigned
 	   * as a constant value)
 	   */
-	  yyval.exval = idl_global->gen()->create_expr(yyvsp[0].idlist);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(tao_yypvt[-0].idlist);
+	} break;
 case 95:
-#line 823 "idl.yy"
+# line 823 "idl.tao_yy"
 {
-	  yyval.exval = yyvsp[-1].exval;
-	}
-break;
+	  tao_yyval.exval = tao_yypvt[-1].exval;
+	} break;
 case 96:
-#line 830 "idl.yy"
+# line 830 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(yyvsp[0].ival);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(tao_yypvt[-0].ival);
+	} break;
 case 97:
-#line 834 "idl.yy"
+# line 834 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(yyvsp[0].sval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(tao_yypvt[-0].sval);
+	} break;
 case 98:
-#line 838 "idl.yy"
+# line 838 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(yyvsp[0].cval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(tao_yypvt[-0].cval);
+	} break;
 case 99:
-#line 842 "idl.yy"
+# line 842 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr(yyvsp[0].dval);
-	}
-break;
+	  tao_yyval.exval = idl_global->gen()->create_expr(tao_yypvt[-0].dval);
+	} break;
 case 100:
-#line 846 "idl.yy"
+# line 846 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr((idl_bool) I_TRUE,
+	  tao_yyval.exval = idl_global->gen()->create_expr((idl_bool) I_TRUE,
 					    AST_Expression::EV_bool);
-	}
-break;
+	} break;
 case 101:
-#line 851 "idl.yy"
+# line 851 "idl.tao_yy"
 {
-	  yyval.exval = idl_global->gen()->create_expr((idl_bool) I_FALSE,
+	  tao_yyval.exval = idl_global->gen()->create_expr((idl_bool) I_FALSE,
 					    AST_Expression::EV_bool);
-	}
-break;
+	} break;
 case 102:
-#line 859 "idl.yy"
+# line 859 "idl.tao_yy"
 {
-	    yyvsp[0].exval->evaluate(AST_Expression::EK_const);
-	    yyval.exval = idl_global->gen()->create_expr(yyvsp[0].exval, AST_Expression::EV_ulong);
-	}
-break;
+	    tao_yypvt[-0].exval->evaluate(AST_Expression::EK_const);
+	    tao_yyval.exval = idl_global->gen()->create_expr(tao_yypvt[-0].exval, AST_Expression::EV_ulong);
+	} break;
 case 103:
-#line 867 "idl.yy"
+# line 867 "idl.tao_yy"
 {
 	    idl_global->set_parse_state(IDL_GlobalData::PS_TypedefSeen);
-	  }
-break;
+	  } break;
 case 104:
-#line 870 "idl.yy"
-{yyval.ival = 0;}
-break;
+# line 870 "idl.tao_yy"
+{tao_yyval.ival = 0;} break;
 case 105:
-#line 871 "idl.yy"
-{ yyval.ival = 0;}
-break;
+# line 871 "idl.tao_yy"
+{ tao_yyval.ival = 0;} break;
 case 106:
-#line 872 "idl.yy"
-{ yyval.ival = 0;}
-break;
+# line 872 "idl.tao_yy"
+{ tao_yyval.ival = 0;} break;
 case 107:
-#line 873 "idl.yy"
-{ yyval.ival = 0;}
-break;
+# line 873 "idl.tao_yy"
+{ tao_yyval.ival = 0;} break;
 case 108:
-#line 875 "idl.yy"
+# line 875 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  AST_Native		*node = NULL;
@@ -1844,22 +2008,20 @@ case 108:
 	   * enclosing scope
 	   */
 	  if (s != NULL) {
-	    node = idl_global->gen()->create_native (yyvsp[0].deval->name (), p);
+	    node = idl_global->gen()->create_native (tao_yypvt[-0].deval->name (), p);
 	    /*
 	     * Add it to its defining scope
 	     */
 	    (void) s->fe_add_native (node);
 	  }
-	}
-break;
+	} break;
 case 109:
-#line 900 "idl.yy"
+# line 900 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_TypeSpecSeen);
-        }
-break;
+        } break;
 case 110:
-#line 904 "idl.yy"
+# line 904 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  UTL_DecllistActiveIterator *l;
@@ -1875,21 +2037,21 @@ case 110:
 	   * Create a list of type renamings. Add them to the
 	   * enclosing scope
 	   */
-	  if (s != NULL && yyvsp[-2].dcval != NULL && yyvsp[0].dlval != NULL) {
-	    l = new UTL_DecllistActiveIterator(yyvsp[0].dlval);
+	  if (s != NULL && tao_yypvt[-2].dcval != NULL && tao_yypvt[-0].dlval != NULL) {
+	    l = new UTL_DecllistActiveIterator(tao_yypvt[-0].dlval);
 	    for (;!(l->is_done()); l->next()) {
 	      d = l->item();
 	      if (d == NULL)
 		      continue;
-              AST_Type * tp = d->compose(yyvsp[-2].dcval);
+              AST_Type * tp = d->compose(tao_yypvt[-2].dcval);
               if (tp == NULL)
 		     continue;
 	      t = idl_global->gen()->create_typedef(tp, d->name(), p);
-              /* if this is a sequence, it is a named one and hence we*/
-	      /* set its name to the same as the declarator. However*/
-	      /* @@ (ASG) note that if we had a scenario of the kind*/
-              /* typedef sequence<...> X, Y, Z; then we must make a*/
-	      /* new sequence node for each name. Not handled currently.*/
+              // if this is a sequence, it is a named one and hence we
+	      // set its name to the same as the declarator. However
+	      // @@ (ASG) note that if we had a scenario of the kind
+              // typedef sequence<...> X, Y, Z; then we must make a
+	      // new sequence node for each name. Not handled currently.
               if (tp->node_type () == AST_Decl::NT_sequence)
                {
                  tp->set_name (d->name ());
@@ -1898,199 +2060,171 @@ case 110:
 	    }
 	    delete l;
 	  }
-	}
-break;
+	} break;
 case 113:
-#line 952 "idl.yy"
+# line 952 "idl.tao_yy"
 {
-	  yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(yyvsp[0].etval);
-	}
-break;
+	  tao_yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(tao_yypvt[-0].etval);
+	} break;
 case 115:
-#line 957 "idl.yy"
+# line 957 "idl.tao_yy"
 {
 	  UTL_Scope	*s = idl_global->scopes()->top_non_null();
 	  AST_Decl	*d = NULL;
 
 	  if (s != NULL)
-	    d = s->lookup_by_name(yyvsp[0].idlist, I_TRUE);
+	    d = s->lookup_by_name(tao_yypvt[-0].idlist, I_TRUE);
 	  if (d == NULL)
-	    idl_global->err()->lookup_error(yyvsp[0].idlist);
-	  yyval.dcval = d;
-	}
-break;
+	    idl_global->err()->lookup_error(tao_yypvt[-0].idlist);
+	  tao_yyval.dcval = d;
+	} break;
 case 128:
-#line 992 "idl.yy"
+# line 992 "idl.tao_yy"
 {
-	  yyval.dlval = new UTL_DeclList(yyvsp[-1].deval, yyvsp[0].dlval);
-	}
-break;
+	  tao_yyval.dlval = new UTL_DeclList(tao_yypvt[-1].deval, tao_yypvt[-0].dlval);
+	} break;
 case 129:
-#line 1000 "idl.yy"
+# line 1000 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_DeclsCommaSeen);
-        }
-break;
+        } break;
 case 130:
-#line 1004 "idl.yy"
+# line 1004 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_DeclsDeclSeen);
 
-	  if (yyvsp[-3].dlval == NULL)
-	    yyval.dlval = new UTL_DeclList(yyvsp[0].deval, NULL);
+	  if (tao_yypvt[-3].dlval == NULL)
+	    tao_yyval.dlval = new UTL_DeclList(tao_yypvt[-0].deval, NULL);
 	  else {
-	    yyvsp[-3].dlval->nconc(new UTL_DeclList(yyvsp[0].deval, NULL));
-	    yyval.dlval = yyvsp[-3].dlval;
+	    tao_yypvt[-3].dlval->nconc(new UTL_DeclList(tao_yypvt[-0].deval, NULL));
+	    tao_yyval.dlval = tao_yypvt[-3].dlval;
 	  }
-	}
-break;
+	} break;
 case 131:
-#line 1015 "idl.yy"
+# line 1015 "idl.tao_yy"
 {
-	  yyval.dlval = NULL;
-	}
-break;
+	  tao_yyval.dlval = NULL;
+	} break;
 case 134:
-#line 1027 "idl.yy"
+# line 1027 "idl.tao_yy"
 {
-	  yyval.dlval = new UTL_DeclList(yyvsp[-1].deval, yyvsp[0].dlval);
-	}
-break;
+	  tao_yyval.dlval = new UTL_DeclList(tao_yypvt[-1].deval, tao_yypvt[-0].dlval);
+	} break;
 case 135:
-#line 1035 "idl.yy"
+# line 1035 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_DeclsCommaSeen);
-        }
-break;
+        } break;
 case 136:
-#line 1039 "idl.yy"
+# line 1039 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_DeclsDeclSeen);
 
-	  if (yyvsp[-3].dlval == NULL)
-	    yyval.dlval = new UTL_DeclList(yyvsp[0].deval, NULL);
+	  if (tao_yypvt[-3].dlval == NULL)
+	    tao_yyval.dlval = new UTL_DeclList(tao_yypvt[-0].deval, NULL);
 	  else {
-	    yyvsp[-3].dlval->nconc(new UTL_DeclList(yyvsp[0].deval, NULL));
-	    yyval.dlval = yyvsp[-3].dlval;
+	    tao_yypvt[-3].dlval->nconc(new UTL_DeclList(tao_yypvt[-0].deval, NULL));
+	    tao_yyval.dlval = tao_yypvt[-3].dlval;
 	  }
-	}
-break;
+	} break;
 case 137:
-#line 1050 "idl.yy"
+# line 1050 "idl.tao_yy"
 {
-	  yyval.dlval = NULL;
-	}
-break;
+	  tao_yyval.dlval = NULL;
+	} break;
 case 138:
-#line 1057 "idl.yy"
+# line 1057 "idl.tao_yy"
 {
-	  yyval.deval = new FE_Declarator(new UTL_ScopedName(yyvsp[0].idval, NULL),
+	  tao_yyval.deval = new FE_Declarator(new UTL_ScopedName(tao_yypvt[-0].idval, NULL),
 				 FE_Declarator::FD_simple, NULL);
-	}
-break;
+	} break;
 case 139:
-#line 1065 "idl.yy"
+# line 1065 "idl.tao_yy"
 {
-	  yyval.deval = new FE_Declarator(new UTL_ScopedName(yyvsp[0].dcval->local_name(), NULL),
+	  tao_yyval.deval = new FE_Declarator(new UTL_ScopedName(tao_yypvt[-0].dcval->local_name(), NULL),
 				 FE_Declarator::FD_complex,
-				 yyvsp[0].dcval);
-	}
-break;
+				 tao_yypvt[-0].dcval);
+	} break;
 case 142:
-#line 1079 "idl.yy"
+# line 1079 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_long;
-	}
-break;
+	  tao_yyval.etval = AST_Expression::EV_long;
+	} break;
 case 143:
-#line 1083 "idl.yy"
+# line 1083 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_longlong;
-        }
-break;
+	  tao_yyval.etval = AST_Expression::EV_longlong;
+        } break;
 case 144:
-#line 1087 "idl.yy"
+# line 1087 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_short;
-	}
-break;
+	  tao_yyval.etval = AST_Expression::EV_short;
+	} break;
 case 145:
-#line 1094 "idl.yy"
+# line 1094 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_ulong;
-	}
-break;
+	  tao_yyval.etval = AST_Expression::EV_ulong;
+	} break;
 case 146:
-#line 1098 "idl.yy"
+# line 1098 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_ulonglong;
-        }
-break;
+	  tao_yyval.etval = AST_Expression::EV_ulonglong;
+        } break;
 case 147:
-#line 1102 "idl.yy"
+# line 1102 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_ushort;
-	}
-break;
+	  tao_yyval.etval = AST_Expression::EV_ushort;
+	} break;
 case 148:
-#line 1109 "idl.yy"
+# line 1109 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_double;
-	}
-break;
+	  tao_yyval.etval = AST_Expression::EV_double;
+	} break;
 case 149:
-#line 1113 "idl.yy"
+# line 1113 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_float;
-	}
-break;
+	  tao_yyval.etval = AST_Expression::EV_float;
+	} break;
 case 150:
-#line 1117 "idl.yy"
+# line 1117 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_longdouble;
-        }
-break;
+	  tao_yyval.etval = AST_Expression::EV_longdouble;
+        } break;
 case 151:
-#line 1124 "idl.yy"
+# line 1124 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_char;
-	}
-break;
+	  tao_yyval.etval = AST_Expression::EV_char;
+	} break;
 case 152:
-#line 1128 "idl.yy"
+# line 1128 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_wchar;
-        }
-break;
+	  tao_yyval.etval = AST_Expression::EV_wchar;
+        } break;
 case 153:
-#line 1135 "idl.yy"
+# line 1135 "idl.tao_yy"
 {
-          yyval.etval = AST_Expression::EV_octet;
-	}
-break;
+          tao_yyval.etval = AST_Expression::EV_octet;
+	} break;
 case 154:
-#line 1142 "idl.yy"
+# line 1142 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_bool;
-        }
-break;
+	  tao_yyval.etval = AST_Expression::EV_bool;
+        } break;
 case 155:
-#line 1149 "idl.yy"
+# line 1149 "idl.tao_yy"
 {
-	  yyval.etval = AST_Expression::EV_any;
-	}
-break;
+	  tao_yyval.etval = AST_Expression::EV_any;
+	} break;
 case 156:
-#line 1156 "idl.yy"
+# line 1156 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StructSeen);
-        }
-break;
+        } break;
 case 157:
-#line 1160 "idl.yy"
+# line 1160 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
-	  UTL_ScopedName	*n = new UTL_ScopedName(yyvsp[0].idval, NULL);
+	  UTL_ScopedName	*n = new UTL_ScopedName(tao_yypvt[-0].idval, NULL);
 	  AST_Structure		*d = NULL;
 	  UTL_StrList		*p = idl_global->pragmas();
 	  AST_Decl		*v = NULL;
@@ -2110,51 +2244,45 @@ case 157:
 	   * Push the scope of the struct on the scopes stack
 	   */
 	  idl_global->scopes()->push(d);
-	}
-break;
+	} break;
 case 158:
-#line 1184 "idl.yy"
+# line 1184 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StructSqSeen);
-        }
-break;
+        } break;
 case 159:
-#line 1188 "idl.yy"
+# line 1188 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StructBodySeen);
-        }
-break;
+        } break;
 case 160:
-#line 1192 "idl.yy"
+# line 1192 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StructQsSeen);
 	  /*
 	   * Done with this struct. Pop its scope off the scopes stack
 	   */
 	  if (idl_global->scopes()->top() == NULL)
-	    yyval.dcval = NULL;
+	    tao_yyval.dcval = NULL;
 	  else {
-	    yyval.dcval =
+	    tao_yyval.dcval =
 	      AST_Structure::narrow_from_scope(
 				   idl_global->scopes()->top_non_null());
 	    idl_global->scopes()->pop();
 	  }
-	}
-break;
+	} break;
 case 164:
-#line 1217 "idl.yy"
+# line 1217 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_MemberTypeSeen);
-        }
-break;
+        } break;
 case 165:
-#line 1221 "idl.yy"
+# line 1221 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_MemberDeclsSeen);
-        }
-break;
+        } break;
 case 166:
-#line 1225 "idl.yy"
+# line 1225 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  UTL_DecllistActiveIterator *l = NULL;
@@ -2166,19 +2294,19 @@ case 166:
 	  /*
 	   * Check for illegal recursive use of type
 	   */
-	  if (yyvsp[-4].dcval != NULL && AST_illegal_recursive_type(yyvsp[-4].dcval))
-	    idl_global->err()->error1(UTL_Error::EIDL_RECURSIVE_TYPE, yyvsp[-4].dcval);
+	  if (tao_yypvt[-4].dcval != NULL && AST_illegal_recursive_type(tao_yypvt[-4].dcval))
+	    idl_global->err()->error1(UTL_Error::EIDL_RECURSIVE_TYPE, tao_yypvt[-4].dcval);
 	  /*
 	   * Create a node representing a struct or exception member
 	   * Add it to the enclosing scope
 	   */
-	  else if (s != NULL && yyvsp[-4].dcval != NULL && yyvsp[-2].dlval != NULL) {
-	    l = new UTL_DecllistActiveIterator(yyvsp[-2].dlval);
+	  else if (s != NULL && tao_yypvt[-4].dcval != NULL && tao_yypvt[-2].dlval != NULL) {
+	    l = new UTL_DecllistActiveIterator(tao_yypvt[-2].dlval);
 	    for (;!(l->is_done()); l->next()) {
 	      d = l->item();
 	      if (d == NULL)
 		continue;
- 	      AST_Type *tp = d->compose(yyvsp[-4].dcval);
+ 	      AST_Type *tp = d->compose(tao_yypvt[-4].dcval);
 	      if (tp == NULL)
 		continue;
 	      f = idl_global->gen()->create_field(tp, d->name(), p);
@@ -2186,56 +2314,48 @@ case 166:
 	    }
 	    delete l;
 	  }
-	}
-break;
+	} break;
 case 167:
-#line 1258 "idl.yy"
+# line 1258 "idl.tao_yy"
 {
 	  idl_global->err()->syntax_error(idl_global->parse_state());
-	}
-break;
+	} break;
 case 168:
-#line 1262 "idl.yy"
+# line 1262 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-	  yyerrok;
-	}
-break;
+	  tao_yyerrok;
+	} break;
 case 169:
-#line 1270 "idl.yy"
+# line 1270 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_UnionSeen);
-        }
-break;
+        } break;
 case 170:
-#line 1274 "idl.yy"
+# line 1274 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_UnionIDSeen);
-        }
-break;
+        } break;
 case 171:
-#line 1278 "idl.yy"
+# line 1278 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SwitchSeen);
-        }
-break;
+        } break;
 case 172:
-#line 1282 "idl.yy"
+# line 1282 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SwitchOpenParSeen);
-        }
-break;
+        } break;
 case 173:
-#line 1286 "idl.yy"
+# line 1286 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SwitchTypeSeen);
-        }
-break;
+        } break;
 case 174:
-#line 1290 "idl.yy"
+# line 1290 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
-	  UTL_ScopedName	*n = new UTL_ScopedName(yyvsp[-8].idval, NULL);
+	  UTL_ScopedName	*n = new UTL_ScopedName(tao_yypvt[-8].idval, NULL);
 	  AST_Union		*u = NULL;
 	  AST_Decl		*v = NULL;
 	  UTL_StrList		*p = idl_global->pragmas();
@@ -2247,10 +2367,10 @@ case 174:
 	   * Create a node representing a union. Add it to its enclosing
 	   * scope
 	   */
-	  if (yyvsp[-2].dcval != NULL && s != NULL) {
- 	    AST_ConcreteType    *tp = AST_ConcreteType::narrow_from_decl(yyvsp[-2].dcval);
+	  if (tao_yypvt[-2].dcval != NULL && s != NULL) {
+ 	    AST_ConcreteType    *tp = AST_ConcreteType::narrow_from_decl(tao_yypvt[-2].dcval);
             if (tp == NULL) {
-              idl_global->err()->not_a_type(yyvsp[-2].dcval);
+              idl_global->err()->not_a_type(tao_yypvt[-2].dcval);
             } else {
 	      u = idl_global->gen()->create_union(tp, n, p);
 	      (void) s->fe_add_union(u);
@@ -2260,63 +2380,55 @@ case 174:
 	   * Push the scope of the union on the scopes stack
 	   */
 	  idl_global->scopes()->push(u);
-	}
-break;
+	} break;
 case 175:
-#line 1319 "idl.yy"
+# line 1319 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_UnionSqSeen);
-        }
-break;
+        } break;
 case 176:
-#line 1323 "idl.yy"
+# line 1323 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_UnionBodySeen);
-        }
-break;
+        } break;
 case 177:
-#line 1327 "idl.yy"
+# line 1327 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_UnionQsSeen);
 	  /*
 	   * Done with this union. Pop its scope from the scopes stack
 	   */
 	  if (idl_global->scopes()->top() == NULL)
-	    yyval.dcval = NULL;
+	    tao_yyval.dcval = NULL;
 	  else {
-	    yyval.dcval =
+	    tao_yyval.dcval =
 	      AST_Union::narrow_from_scope(
 				idl_global->scopes()->top_non_null());
 	    idl_global->scopes()->pop();
 	  }
-	}
-break;
+	} break;
 case 178:
-#line 1345 "idl.yy"
+# line 1345 "idl.tao_yy"
 {
-	  yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(yyvsp[0].etval);
-	}
-break;
+	  tao_yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(tao_yypvt[-0].etval);
+	} break;
 case 179:
-#line 1349 "idl.yy"
+# line 1349 "idl.tao_yy"
 {
-	  yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(yyvsp[0].etval);
-	}
-break;
+	  tao_yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(tao_yypvt[-0].etval);
+	} break;
 case 180:
-#line 1353 "idl.yy"
+# line 1353 "idl.tao_yy"
 {
-	  yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(yyvsp[0].etval);
-	}
-break;
+	  tao_yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(tao_yypvt[-0].etval);
+	} break;
 case 181:
-#line 1357 "idl.yy"
+# line 1357 "idl.tao_yy"
 {
-	  yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(yyvsp[0].etval);
-	}
-break;
+	  tao_yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(tao_yypvt[-0].etval);
+	} break;
 case 183:
-#line 1362 "idl.yy"
+# line 1362 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  AST_Decl		*d = NULL;
@@ -2330,11 +2442,11 @@ case 183:
 	   * typedef's to arrive at the base type at the end of the
 	   * chain
 	   */
-	  if (s != NULL && (d = s->lookup_by_name(yyvsp[0].idlist, I_TRUE)) != NULL) {
+	  if (s != NULL && (d = s->lookup_by_name(tao_yypvt[-0].idlist, I_TRUE)) != NULL) {
 	    while (!found) {
 	      switch (d->node_type()) {
 	      case AST_Decl::NT_enum:
-		yyval.dcval = d;
+		tao_yyval.dcval = d;
 		found = I_TRUE;
 		break;
 	      case AST_Decl::NT_pre_defined:
@@ -2350,11 +2462,11 @@ case 183:
 		  case AST_PredefinedType::PT_wchar:
 		  case AST_PredefinedType::PT_octet:
 		  case AST_PredefinedType::PT_boolean:
-		    yyval.dcval = p;
+		    tao_yyval.dcval = p;
 		    found = I_TRUE;
 		    break;
 		  default:
-		    yyval.dcval = NULL;
+		    tao_yyval.dcval = NULL;
 		    found = I_TRUE;
 		    break;
 		  }
@@ -2365,46 +2477,43 @@ case 183:
 		if (t != NULL) d = t->base_type();
 		break;
 	      default:
-		yyval.dcval = NULL;
+		tao_yyval.dcval = NULL;
 		found = I_TRUE;
 		break;
 	      }
 	    }
 	  } else
-	    yyval.dcval = NULL;
+	    tao_yyval.dcval = NULL;
 
-	  if (yyval.dcval == NULL)
-	    idl_global->err()->lookup_error(yyvsp[0].idlist);
-	}
-break;
+	  if (tao_yyval.dcval == NULL)
+	    idl_global->err()->lookup_error(tao_yypvt[-0].idlist);
+	} break;
 case 187:
-#line 1432 "idl.yy"
+# line 1432 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_UnionLabelSeen);
-        }
-break;
+        } break;
 case 188:
-#line 1436 "idl.yy"
+# line 1436 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_UnionElemSeen);
-        }
-break;
+        } break;
 case 189:
-#line 1440 "idl.yy"
+# line 1440 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  UTL_LabellistActiveIterator *l = NULL;
 	  AST_UnionLabel	*d = NULL;
 	  AST_UnionBranch	*b = NULL;
-	  AST_Field		*f = yyvsp[-2].ffval;
+	  AST_Field		*f = tao_yypvt[-2].ffval;
 
 	  idl_global->set_parse_state(IDL_GlobalData::PS_UnionElemCompleted);
 	  /*
 	   * Create several nodes representing branches of a union.
 	   * Add them to the enclosing scope (the union scope)
 	   */
-	  if (s != NULL && yyvsp[-4].llval != NULL && yyvsp[-2].ffval != NULL) {
-	    l = new UTL_LabellistActiveIterator(yyvsp[-4].llval);
+	  if (s != NULL && tao_yypvt[-4].llval != NULL && tao_yypvt[-2].ffval != NULL) {
+	    l = new UTL_LabellistActiveIterator(tao_yypvt[-4].llval);
 	    for (;!(l->is_done()); l->next()) {
 	      d = l->item();
 	      if (d == NULL)
@@ -2417,123 +2526,109 @@ case 189:
 	    }
 	    delete l;
 	  }
-	}
-break;
+	} break;
 case 190:
-#line 1468 "idl.yy"
+# line 1468 "idl.tao_yy"
 {
 	  idl_global->err()->syntax_error(idl_global->parse_state());
-	}
-break;
+	} break;
 case 191:
-#line 1473 "idl.yy"
+# line 1473 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_NoState);
-	  yyerrok;
-	}
-break;
+	  tao_yyerrok;
+	} break;
 case 192:
-#line 1481 "idl.yy"
+# line 1481 "idl.tao_yy"
 {
-	  yyval.llval = new UTL_LabelList(yyvsp[-1].ulval, yyvsp[0].llval);
-	}
-break;
+	  tao_yyval.llval = new UTL_LabelList(tao_yypvt[-1].ulval, tao_yypvt[-0].llval);
+	} break;
 case 193:
-#line 1488 "idl.yy"
+# line 1488 "idl.tao_yy"
 {
-	  if (yyvsp[-1].llval == NULL)
-	    yyval.llval = new UTL_LabelList(yyvsp[0].ulval, NULL);
+	  if (tao_yypvt[-1].llval == NULL)
+	    tao_yyval.llval = new UTL_LabelList(tao_yypvt[-0].ulval, NULL);
 	  else {
-	    yyvsp[-1].llval->nconc(new UTL_LabelList(yyvsp[0].ulval, NULL));
-	    yyval.llval = yyvsp[-1].llval;
+	    tao_yypvt[-1].llval->nconc(new UTL_LabelList(tao_yypvt[-0].ulval, NULL));
+	    tao_yyval.llval = tao_yypvt[-1].llval;
 	  }
-	}
-break;
+	} break;
 case 194:
-#line 1497 "idl.yy"
+# line 1497 "idl.tao_yy"
 {
-	  yyval.llval = NULL;
-	}
-break;
+	  tao_yyval.llval = NULL;
+	} break;
 case 195:
-#line 1504 "idl.yy"
+# line 1504 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_DefaultSeen);
-        }
-break;
+        } break;
 case 196:
-#line 1508 "idl.yy"
+# line 1508 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_LabelColonSeen);
 
-	  yyval.ulval = idl_global->gen()->
+	  tao_yyval.ulval = idl_global->gen()->
 	            create_union_label(AST_UnionLabel::UL_default,
 				       NULL);
-	}
-break;
+	} break;
 case 197:
-#line 1516 "idl.yy"
+# line 1516 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_CaseSeen);
-        }
-break;
+        } break;
 case 198:
-#line 1520 "idl.yy"
+# line 1520 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_LabelExprSeen);
-        }
-break;
+        } break;
 case 199:
-#line 1524 "idl.yy"
+# line 1524 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_LabelColonSeen);
 
-	  yyval.ulval = idl_global->gen()->create_union_label(AST_UnionLabel::UL_label,
-						     yyvsp[-2].exval);
-	}
-break;
+	  tao_yyval.ulval = idl_global->gen()->create_union_label(AST_UnionLabel::UL_label,
+						     tao_yypvt[-2].exval);
+	} break;
 case 200:
-#line 1534 "idl.yy"
+# line 1534 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_UnionElemTypeSeen);
-        }
-break;
+        } break;
 case 201:
-#line 1538 "idl.yy"
+# line 1538 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_UnionElemDeclSeen);
 	  /*
 	   * Check for illegal recursive use of type
 	   */
-	  if (yyvsp[-2].dcval != NULL && AST_illegal_recursive_type(yyvsp[-2].dcval))
-	    idl_global->err()->error1(UTL_Error::EIDL_RECURSIVE_TYPE, yyvsp[-2].dcval);
+	  if (tao_yypvt[-2].dcval != NULL && AST_illegal_recursive_type(tao_yypvt[-2].dcval))
+	    idl_global->err()->error1(UTL_Error::EIDL_RECURSIVE_TYPE, tao_yypvt[-2].dcval);
 	  /*
 	   * Create a field in a union branch
 	   */
-	  else if (yyvsp[-2].dcval == NULL || yyvsp[0].deval == NULL)
-	    yyval.ffval = NULL;
+	  else if (tao_yypvt[-2].dcval == NULL || tao_yypvt[-0].deval == NULL)
+	    tao_yyval.ffval = NULL;
 	  else {
-	    AST_Type *tp = yyvsp[0].deval->compose(yyvsp[-2].dcval);
+	    AST_Type *tp = tao_yypvt[-0].deval->compose(tao_yypvt[-2].dcval);
 	    if (tp == NULL)
-	      yyval.ffval = NULL;
+	      tao_yyval.ffval = NULL;
  	    else
-	      yyval.ffval = idl_global->gen()->create_field(tp,
-			        		   yyvsp[0].deval->name(),
+	      tao_yyval.ffval = idl_global->gen()->create_field(tp,
+			        		   tao_yypvt[-0].deval->name(),
 			        		   idl_global->pragmas());
 	  }
-	}
-break;
+	} break;
 case 202:
-#line 1564 "idl.yy"
+# line 1564 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_EnumSeen);
-        }
-break;
+        } break;
 case 203:
-#line 1568 "idl.yy"
+# line 1568 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
-	  UTL_ScopedName	*n = new UTL_ScopedName(yyvsp[0].idval, NULL);
+	  UTL_ScopedName	*n = new UTL_ScopedName(tao_yypvt[-0].idval, NULL);
 	  AST_Enum		*e = NULL;
 	  AST_Decl		*v = NULL;
 	  UTL_StrList		*p = idl_global->pragmas();
@@ -2556,47 +2651,42 @@ case 203:
 	   * Push the enum scope on the scopes stack
 	   */
 	  idl_global->scopes()->push(e);
-	}
-break;
+	} break;
 case 204:
-#line 1595 "idl.yy"
+# line 1595 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_EnumSqSeen);
-        }
-break;
+        } break;
 case 205:
-#line 1599 "idl.yy"
+# line 1599 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_EnumBodySeen);
-        }
-break;
+        } break;
 case 206:
-#line 1603 "idl.yy"
+# line 1603 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_EnumQsSeen);
 	  /*
 	   * Done with this enum. Pop its scope from the scopes stack
 	   */
 	  if (idl_global->scopes()->top() == NULL)
-	    yyval.dcval = NULL;
+	    tao_yyval.dcval = NULL;
 	  else {
-	    yyval.dcval = AST_Enum::narrow_from_scope(idl_global->scopes()->top_non_null());
+	    tao_yyval.dcval = AST_Enum::narrow_from_scope(idl_global->scopes()->top_non_null());
 	    idl_global->scopes()->pop();
 	  }
-	}
-break;
+	} break;
 case 208:
-#line 1622 "idl.yy"
+# line 1622 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_EnumCommaSeen);
-        }
-break;
+        } break;
 case 211:
-#line 1631 "idl.yy"
+# line 1631 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  UTL_ScopedName	*n =
-		new UTL_ScopedName(new Identifier(yyvsp[0].strval, 1, 0, I_FALSE), NULL);
+		new UTL_ScopedName(new Identifier(tao_yypvt[-0].strval, 1, 0, I_FALSE), NULL);
 	  AST_EnumVal		*e = NULL;
 	  AST_Enum		*c = NULL;
 	  UTL_StrList		*p = idl_global->pragmas();
@@ -2611,22 +2701,19 @@ case 211:
 	      e = idl_global->gen()->create_enum_val(c->next_enum_val(), n, p);
 	    (void) s->fe_add_enum_val(e);
 	  }
-	}
-break;
+	} break;
 case 212:
-#line 1655 "idl.yy"
+# line 1655 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SequenceCommaSeen);
-        }
-break;
+        } break;
 case 213:
-#line 1659 "idl.yy"
+# line 1659 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SequenceExprSeen);
-        }
-break;
+        } break;
 case 214:
-#line 1663 "idl.yy"
+# line 1663 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SequenceQsSeen);
 	  /*
@@ -2637,28 +2724,27 @@ case 214:
 	  /*
 	   * Create a node representing a sequence
 	   */
-	  if (yyvsp[-2].exval == NULL || yyvsp[-2].exval->coerce(AST_Expression::EV_ulong) == NULL) {
-	    idl_global->err()->coercion_error(yyvsp[-2].exval, AST_Expression::EV_ulong);
-	    yyval.dcval = NULL;
-	  } else if (yyvsp[-5].dcval == NULL) {
-	    yyval.dcval = NULL;
+	  if (tao_yypvt[-2].exval == NULL || tao_yypvt[-2].exval->coerce(AST_Expression::EV_ulong) == NULL) {
+	    idl_global->err()->coercion_error(tao_yypvt[-2].exval, AST_Expression::EV_ulong);
+	    tao_yyval.dcval = NULL;
+	  } else if (tao_yypvt[-5].dcval == NULL) {
+	    tao_yyval.dcval = NULL;
 	  } else {
- 	    AST_Type *tp = AST_Type::narrow_from_decl(yyvsp[-5].dcval);
+ 	    AST_Type *tp = AST_Type::narrow_from_decl(tao_yypvt[-5].dcval);
 	    if (tp == NULL)
-	      yyval.dcval = NULL;
+	      tao_yyval.dcval = NULL;
 	    else {
-	      yyval.dcval = idl_global->gen()->create_sequence(yyvsp[-2].exval, tp);
+	      tao_yyval.dcval = idl_global->gen()->create_sequence(tao_yypvt[-2].exval, tp);
 	      /*
 	       * Add this AST_Sequence to the types defined in the global scope
 	       */
 	      (void) idl_global->root()
-		        ->fe_add_sequence(AST_Sequence::narrow_from_decl(yyval.dcval));
+		        ->fe_add_sequence(AST_Sequence::narrow_from_decl(tao_yyval.dcval));
  	    }
 	  }
-	}
-break;
+	} break;
 case 215:
-#line 1694 "idl.yy"
+# line 1694 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SequenceQsSeen);
 	  /*
@@ -2669,14 +2755,14 @@ case 215:
 	  /*
 	   * Create a node representing a sequence
 	   */
-	  if (yyvsp[-1].dcval == NULL)
-	    yyval.dcval = NULL;
+	  if (tao_yypvt[-1].dcval == NULL)
+	    tao_yyval.dcval = NULL;
 	  else {
-	    AST_Type *tp = AST_Type::narrow_from_decl(yyvsp[-1].dcval);
+	    AST_Type *tp = AST_Type::narrow_from_decl(tao_yypvt[-1].dcval);
 	    if (tp == NULL)
-	      yyval.dcval = NULL;
+	      tao_yyval.dcval = NULL;
             else {
-	      yyval.dcval =
+	      tao_yyval.dcval =
 	        idl_global->gen()->create_sequence(
 		  	     idl_global->gen()->create_expr((unsigned long) 0),
 			     tp);
@@ -2684,227 +2770,203 @@ case 215:
 	       * Add this AST_Sequence to the types defined in the global scope
 	       */
 	      (void) idl_global->root()
-		        ->fe_add_sequence(AST_Sequence::narrow_from_decl(yyval.dcval));
+		        ->fe_add_sequence(AST_Sequence::narrow_from_decl(tao_yyval.dcval));
 	    }
 	  }
-	}
-break;
+	} break;
 case 216:
-#line 1727 "idl.yy"
+# line 1727 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SequenceSeen);
 	  /*
 	   * Push a sequence marker on scopes stack
 	   */
 	  idl_global->scopes()->push(NULL);
-	}
-break;
+	} break;
 case 217:
-#line 1735 "idl.yy"
+# line 1735 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SequenceSqSeen);
-        }
-break;
+        } break;
 case 218:
-#line 1739 "idl.yy"
+# line 1739 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_SequenceTypeSeen);
-	  yyval.dcval = yyvsp[0].dcval;
-        }
-break;
+	  tao_yyval.dcval = tao_yypvt[-0].dcval;
+        } break;
 case 219:
-#line 1748 "idl.yy"
+# line 1748 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StringSqSeen);
-        }
-break;
+        } break;
 case 220:
-#line 1752 "idl.yy"
+# line 1752 "idl.tao_yy"
 {
 	   idl_global->set_parse_state(IDL_GlobalData::PS_StringExprSeen);
-        }
-break;
+        } break;
 case 221:
-#line 1756 "idl.yy"
+# line 1756 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StringQsSeen);
 	  /*
 	   * Create a node representing a string
 	   */
-	  if (yyvsp[-2].exval == NULL || yyvsp[-2].exval->coerce(AST_Expression::EV_ulong) == NULL) {
-	    idl_global->err()->coercion_error(yyvsp[-2].exval, AST_Expression::EV_ulong);
-	    yyval.dcval = NULL;
+	  if (tao_yypvt[-2].exval == NULL || tao_yypvt[-2].exval->coerce(AST_Expression::EV_ulong) == NULL) {
+	    idl_global->err()->coercion_error(tao_yypvt[-2].exval, AST_Expression::EV_ulong);
+	    tao_yyval.dcval = NULL;
 	  } else {
-	    yyval.dcval = idl_global->gen()->create_string(yyvsp[-2].exval);
+	    tao_yyval.dcval = idl_global->gen()->create_string(tao_yypvt[-2].exval);
 	    /*
 	     * Add this AST_String to the types defined in the global scope
 	     */
 	    (void) idl_global->root()
-		      ->fe_add_string(AST_String::narrow_from_decl(yyval.dcval));
+		      ->fe_add_string(AST_String::narrow_from_decl(tao_yyval.dcval));
 	  }
-	}
-break;
+	} break;
 case 222:
-#line 1774 "idl.yy"
+# line 1774 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StringCompleted);
 	  /*
 	   * Create a node representing a string
 	   */
-	  yyval.dcval =
+	  tao_yyval.dcval =
 	    idl_global->gen()->create_string(
 			 idl_global->gen()->create_expr((unsigned long) 0));
 	  /*
 	   * Add this AST_String to the types defined in the global scope
 	   */
 	  (void) idl_global->root()
-                    ->fe_add_string(AST_String::narrow_from_decl(yyval.dcval));
-	}
-break;
+                    ->fe_add_string(AST_String::narrow_from_decl(tao_yyval.dcval));
+	} break;
 case 223:
-#line 1792 "idl.yy"
+# line 1792 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StringSeen);
-        }
-break;
+        } break;
 case 224:
-#line 1800 "idl.yy"
+# line 1800 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StringSqSeen);
-        }
-break;
+        } break;
 case 225:
-#line 1804 "idl.yy"
+# line 1804 "idl.tao_yy"
 {
 	   idl_global->set_parse_state(IDL_GlobalData::PS_StringExprSeen);
-        }
-break;
+        } break;
 case 226:
-#line 1808 "idl.yy"
+# line 1808 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StringQsSeen);
 	  /*
 	   * Create a node representing a string
 	   */
-	  if (yyvsp[-2].exval == NULL || yyvsp[-2].exval->coerce(AST_Expression::EV_ulong) == NULL) {
-	    idl_global->err()->coercion_error(yyvsp[-2].exval, AST_Expression::EV_ulong);
-	    yyval.dcval = NULL;
+	  if (tao_yypvt[-2].exval == NULL || tao_yypvt[-2].exval->coerce(AST_Expression::EV_ulong) == NULL) {
+	    idl_global->err()->coercion_error(tao_yypvt[-2].exval, AST_Expression::EV_ulong);
+	    tao_yyval.dcval = NULL;
 	  } else {
-	    yyval.dcval = idl_global->gen()->create_wstring(yyvsp[-2].exval);
+	    tao_yyval.dcval = idl_global->gen()->create_wstring(tao_yypvt[-2].exval);
 	    /*
 	     * Add this AST_String to the types defined in the global scope
 	     */
 	    (void) idl_global->root()
-		      ->fe_add_string(AST_String::narrow_from_decl(yyval.dcval));
+		      ->fe_add_string(AST_String::narrow_from_decl(tao_yyval.dcval));
 	  }
-	}
-break;
+	} break;
 case 227:
-#line 1826 "idl.yy"
+# line 1826 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StringCompleted);
 	  /*
 	   * Create a node representing a string
 	   */
-	  yyval.dcval =
+	  tao_yyval.dcval =
 	    idl_global->gen()->create_wstring(
 			 idl_global->gen()->create_expr((unsigned long) 0));
 	  /*
 	   * Add this AST_String to the types defined in the global scope
 	   */
 	  (void) idl_global->root()
-                    ->fe_add_string(AST_String::narrow_from_decl(yyval.dcval));
-	}
-break;
+                    ->fe_add_string(AST_String::narrow_from_decl(tao_yyval.dcval));
+	} break;
 case 228:
-#line 1844 "idl.yy"
+# line 1844 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_StringSeen);
-        }
-break;
+        } break;
 case 229:
-#line 1851 "idl.yy"
+# line 1851 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ArrayIDSeen);
-        }
-break;
+        } break;
 case 230:
-#line 1855 "idl.yy"
+# line 1855 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ArrayCompleted);
 	  /*
 	   * Create a node representing an array
 	   */
-	  if (yyvsp[0].elval != NULL) {
-	     yyval.dcval = idl_global->gen()->create_array(new UTL_ScopedName(yyvsp[-2].idval, NULL),
-						  yyvsp[0].elval->length(), yyvsp[0].elval);
+	  if (tao_yypvt[-0].elval != NULL) {
+	     tao_yyval.dcval = idl_global->gen()->create_array(new UTL_ScopedName(tao_yypvt[-2].idval, NULL),
+						  tao_yypvt[-0].elval->length(), tao_yypvt[-0].elval);
 	  }
-	}
-break;
+	} break;
 case 231:
-#line 1869 "idl.yy"
+# line 1869 "idl.tao_yy"
 {
-	  yyval.elval = new UTL_ExprList(yyvsp[-1].exval, yyvsp[0].elval);
-	}
-break;
+	  tao_yyval.elval = new UTL_ExprList(tao_yypvt[-1].exval, tao_yypvt[-0].elval);
+	} break;
 case 232:
-#line 1876 "idl.yy"
+# line 1876 "idl.tao_yy"
 {
-	  if (yyvsp[-1].elval == NULL)
-	    yyval.elval = new UTL_ExprList(yyvsp[0].exval, NULL);
+	  if (tao_yypvt[-1].elval == NULL)
+	    tao_yyval.elval = new UTL_ExprList(tao_yypvt[-0].exval, NULL);
 	  else {
-	    yyvsp[-1].elval->nconc(new UTL_ExprList(yyvsp[0].exval, NULL));
-	    yyval.elval = yyvsp[-1].elval;
+	    tao_yypvt[-1].elval->nconc(new UTL_ExprList(tao_yypvt[-0].exval, NULL));
+	    tao_yyval.elval = tao_yypvt[-1].elval;
 	  }
-	}
-break;
+	} break;
 case 233:
-#line 1885 "idl.yy"
+# line 1885 "idl.tao_yy"
 {
-	  yyval.elval = NULL;
-	}
-break;
+	  tao_yyval.elval = NULL;
+	} break;
 case 234:
-#line 1892 "idl.yy"
+# line 1892 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_DimSqSeen);
-        }
-break;
+        } break;
 case 235:
-#line 1896 "idl.yy"
+# line 1896 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_DimExprSeen);
-        }
-break;
+        } break;
 case 236:
-#line 1900 "idl.yy"
+# line 1900 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_DimQsSeen);
 	  /*
 	   * Array dimensions are expressions which must be coerced to
 	   * positive integers
 	   */
-	  if (yyvsp[-2].exval == NULL || yyvsp[-2].exval->coerce(AST_Expression::EV_ulong) == NULL) {
-	    idl_global->err()->coercion_error(yyvsp[-2].exval, AST_Expression::EV_ulong);
-	    yyval.exval = NULL;
+	  if (tao_yypvt[-2].exval == NULL || tao_yypvt[-2].exval->coerce(AST_Expression::EV_ulong) == NULL) {
+	    idl_global->err()->coercion_error(tao_yypvt[-2].exval, AST_Expression::EV_ulong);
+	    tao_yyval.exval = NULL;
 	  } else
-	    yyval.exval = yyvsp[-2].exval;
-	}
-break;
+	    tao_yyval.exval = tao_yypvt[-2].exval;
+	} break;
 case 237:
-#line 1917 "idl.yy"
+# line 1917 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_AttrSeen);
-        }
-break;
+        } break;
 case 238:
-#line 1921 "idl.yy"
+# line 1921 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_AttrTypeSeen);
-        }
-break;
+        } break;
 case 239:
-#line 1925 "idl.yy"
+# line 1925 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  UTL_DecllistActiveIterator *l = NULL;
@@ -2917,16 +2979,16 @@ case 239:
 	   * Create nodes representing attributes and add them to the
 	   * enclosing scope
 	   */
-	  if (s != NULL && yyvsp[-2].dcval != NULL && yyvsp[0].dlval != NULL) {
-	    l = new UTL_DecllistActiveIterator(yyvsp[0].dlval);
+	  if (s != NULL && tao_yypvt[-2].dcval != NULL && tao_yypvt[-0].dlval != NULL) {
+	    l = new UTL_DecllistActiveIterator(tao_yypvt[-0].dlval);
 	    for (;!(l->is_done()); l->next()) {
 	      d = l->item();
 	      if (d == NULL)
 		continue;
-	      AST_Type *tp = d->compose(yyvsp[-2].dcval);
+	      AST_Type *tp = d->compose(tao_yypvt[-2].dcval);
  	      if (tp == NULL)
 	 	continue;
-	      a = idl_global->gen()->create_attribute(yyvsp[-5].bval, tp, d->name(), p);
+	      a = idl_global->gen()->create_attribute(tao_yypvt[-5].bval, tp, d->name(), p);
 	      /*
 	       * Add one attribute to the enclosing scope
 	       */
@@ -2934,32 +2996,28 @@ case 239:
 	    }
 	    delete l;
 	  }
-	}
-break;
+	} break;
 case 240:
-#line 1959 "idl.yy"
+# line 1959 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_AttrROSeen);
-	  yyval.bval = I_TRUE;
-	}
-break;
+	  tao_yyval.bval = I_TRUE;
+	} break;
 case 241:
-#line 1964 "idl.yy"
+# line 1964 "idl.tao_yy"
 {
-	  yyval.bval = I_FALSE;
-	}
-break;
+	  tao_yyval.bval = I_FALSE;
+	} break;
 case 242:
-#line 1971 "idl.yy"
+# line 1971 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ExceptSeen);
-	}
-break;
+	} break;
 case 243:
-#line 1975 "idl.yy"
+# line 1975 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
-	  UTL_ScopedName	*n = new UTL_ScopedName(yyvsp[0].idval, NULL);
+	  UTL_ScopedName	*n = new UTL_ScopedName(tao_yypvt[-0].idval, NULL);
 	  AST_Exception		*e = NULL;
 	  UTL_StrList		*p = idl_global->pragmas();
 	  AST_Decl		*v = NULL;
@@ -2979,42 +3037,37 @@ case 243:
 	   * Push the exception scope on the scope stack
 	   */
 	  idl_global->scopes()->push(e);
-	}
-break;
+	} break;
 case 244:
-#line 1999 "idl.yy"
+# line 1999 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ExceptSqSeen);
-        }
-break;
+        } break;
 case 245:
-#line 2003 "idl.yy"
+# line 2003 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ExceptBodySeen);
-        }
-break;
+        } break;
 case 246:
-#line 2007 "idl.yy"
+# line 2007 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_ExceptQsSeen);
 	  /*
 	   * Done with this exception. Pop its scope from the scope stack
 	   */
 	  idl_global->scopes()->pop();
-	}
-break;
+	} break;
 case 247:
-#line 2019 "idl.yy"
+# line 2019 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpTypeSeen);
-        }
-break;
+        } break;
 case 248:
-#line 2023 "idl.yy"
+# line 2023 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  UTL_ScopedName	*n =
-		new UTL_ScopedName(new Identifier(yyvsp[0].strval, 1, 0, I_FALSE), NULL);
+		new UTL_ScopedName(new Identifier(tao_yypvt[-0].strval, 1, 0, I_FALSE), NULL);
 	  AST_Operation		*o = NULL;
 	  UTL_StrList		*p = idl_global->pragmas();
 
@@ -3023,14 +3076,14 @@ case 248:
 	   * Create a node representing an operation on an interface
 	   * and add it to its enclosing scope
 	   */
-	  if (s != NULL && yyvsp[-2].dcval != NULL) {
-	    AST_Type *tp = AST_Type::narrow_from_decl(yyvsp[-2].dcval);
+	  if (s != NULL && tao_yypvt[-2].dcval != NULL) {
+	    AST_Type *tp = AST_Type::narrow_from_decl(tao_yypvt[-2].dcval);
             if (tp == NULL) {
-              idl_global->err()->not_a_type(yyvsp[-2].dcval);
+              idl_global->err()->not_a_type(tao_yypvt[-2].dcval);
             } else if (tp->node_type() == AST_Decl::NT_except) {
-              idl_global->err()->not_a_type(yyvsp[-2].dcval);
+              idl_global->err()->not_a_type(tao_yypvt[-2].dcval);
             } else {
-	      o = idl_global->gen()->create_operation(tp, yyvsp[-3].ofval, n, p);
+	      o = idl_global->gen()->create_operation(tp, tao_yypvt[-3].ofval, n, p);
 	      (void) s->fe_add_operation(o);
 	    }
 	  }
@@ -3038,22 +3091,19 @@ case 248:
 	   * Push the operation scope onto the scopes stack
 	   */
 	  idl_global->scopes()->push(o);
-	}
-break;
+	} break;
 case 249:
-#line 2052 "idl.yy"
+# line 2052 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpParsCompleted);
-        }
-break;
+        } break;
 case 250:
-#line 2056 "idl.yy"
+# line 2056 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpRaiseCompleted);
-        }
-break;
+        } break;
 case 251:
-#line 2060 "idl.yy"
+# line 2060 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  AST_Operation		*o = NULL;
@@ -3065,89 +3115,77 @@ case 251:
 	  if (s != NULL && s->scope_node_type() == AST_Decl::NT_op) {
 	    o = AST_Operation::narrow_from_scope(s);
 
-	    if (yyvsp[-2].nlval != NULL && o != NULL)
-	      (void) o->fe_add_exceptions(yyvsp[-2].nlval);
-	    if (yyvsp[0].slval != NULL)
-	      (void) o->fe_add_context(yyvsp[0].slval);
+	    if (tao_yypvt[-2].nlval != NULL && o != NULL)
+	      (void) o->fe_add_exceptions(tao_yypvt[-2].nlval);
+	    if (tao_yypvt[-0].slval != NULL)
+	      (void) o->fe_add_context(tao_yypvt[-0].slval);
 	  }
 	  /*
 	   * Done with this operation. Pop its scope from the scopes stack
 	   */
 	  idl_global->scopes()->pop();
-	}
-break;
+	} break;
 case 252:
-#line 2085 "idl.yy"
+# line 2085 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpAttrSeen);
-	  yyval.ofval = AST_Operation::OP_oneway;
-	}
-break;
+	  tao_yyval.ofval = AST_Operation::OP_oneway;
+	} break;
 case 253:
-#line 2090 "idl.yy"
+# line 2090 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpAttrSeen);
-	  yyval.ofval = AST_Operation::OP_idempotent;
-	}
-break;
+	  tao_yyval.ofval = AST_Operation::OP_idempotent;
+	} break;
 case 254:
-#line 2095 "idl.yy"
+# line 2095 "idl.tao_yy"
 {
-	  yyval.ofval = AST_Operation::OP_noflags;
-	}
-break;
+	  tao_yyval.ofval = AST_Operation::OP_noflags;
+	} break;
 case 256:
-#line 2103 "idl.yy"
+# line 2103 "idl.tao_yy"
 {
-	  yyval.dcval =
+	  tao_yyval.dcval =
 	    idl_global->scopes()->bottom()
 	       ->lookup_primitive_type(AST_Expression::EV_void);
-	}
-break;
+	} break;
 case 257:
-#line 2112 "idl.yy"
+# line 2112 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpSqSeen);
-        }
-break;
+        } break;
 case 258:
-#line 2116 "idl.yy"
+# line 2116 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpQsSeen);
-        }
-break;
+        } break;
 case 259:
-#line 2120 "idl.yy"
+# line 2120 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpSqSeen);
-        }
-break;
+        } break;
 case 260:
-#line 2125 "idl.yy"
+# line 2125 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpQsSeen);
-        }
-break;
+        } break;
 case 262:
-#line 2135 "idl.yy"
+# line 2135 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpParCommaSeen);
-        }
-break;
+        } break;
 case 265:
-#line 2144 "idl.yy"
+# line 2144 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpParDirSeen);
-        }
-break;
+        } break;
 case 266:
-#line 2148 "idl.yy"
+# line 2148 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpParTypeSeen);
-        }
-break;
+        } break;
 case 267:
-#line 2152 "idl.yy"
+# line 2152 "idl.tao_yy"
 {
 	  UTL_Scope		*s = idl_global->scopes()->top_non_null();
 	  AST_Argument		*a = NULL;
@@ -3158,188 +3196,115 @@ case 267:
 	   * Create a node representing an argument to an operation
 	   * Add it to the enclosing scope (the operation scope)
 	   */
-	  if (yyvsp[-2].dcval != NULL && yyvsp[0].deval != NULL && s != NULL) {
-	    AST_Type *tp = yyvsp[0].deval->compose(yyvsp[-2].dcval);
+	  if (tao_yypvt[-2].dcval != NULL && tao_yypvt[-0].deval != NULL && s != NULL) {
+	    AST_Type *tp = tao_yypvt[-0].deval->compose(tao_yypvt[-2].dcval);
 	    if (tp != NULL) {
-	      a = idl_global->gen()->create_argument(yyvsp[-4].dival, tp, yyvsp[0].deval->name(), p);
+	      a = idl_global->gen()->create_argument(tao_yypvt[-4].dival, tp, tao_yypvt[-0].deval->name(), p);
 	      (void) s->fe_add_argument(a);
 	    }
 	  }
-	}
-break;
+	} break;
 case 268:
-#line 2174 "idl.yy"
+# line 2174 "idl.tao_yy"
 {
-	  yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(yyvsp[0].etval);
-	}
-break;
+	  tao_yyval.dcval = idl_global->scopes()->bottom()->lookup_primitive_type(tao_yypvt[-0].etval);
+	} break;
 case 270:
-#line 2179 "idl.yy"
+# line 2179 "idl.tao_yy"
 {
 	  UTL_Scope	*s = idl_global->scopes()->top_non_null();
 	  AST_Decl	*d = NULL;
 
 	  if (s != NULL)
-	    d = s->lookup_by_name(yyvsp[0].idlist, I_TRUE);
+	    d = s->lookup_by_name(tao_yypvt[-0].idlist, I_TRUE);
 	  if (d == NULL)
-	    idl_global->err()->lookup_error(yyvsp[0].idlist);
-	  yyval.dcval = d;
-	}
-break;
+	    idl_global->err()->lookup_error(tao_yypvt[-0].idlist);
+	  tao_yyval.dcval = d;
+	} break;
 case 271:
-#line 2193 "idl.yy"
+# line 2193 "idl.tao_yy"
 {
-	  yyval.dival = AST_Argument::dir_IN;
-	}
-break;
+	  tao_yyval.dival = AST_Argument::dir_IN;
+	} break;
 case 272:
-#line 2197 "idl.yy"
+# line 2197 "idl.tao_yy"
 {
-	  yyval.dival = AST_Argument::dir_OUT;
-	}
-break;
+	  tao_yyval.dival = AST_Argument::dir_OUT;
+	} break;
 case 273:
-#line 2201 "idl.yy"
+# line 2201 "idl.tao_yy"
 {
-	  yyval.dival = AST_Argument::dir_INOUT;
-	}
-break;
+	  tao_yyval.dival = AST_Argument::dir_INOUT;
+	} break;
 case 274:
-#line 2208 "idl.yy"
+# line 2208 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpRaiseSeen);
-        }
-break;
+        } break;
 case 275:
-#line 2212 "idl.yy"
+# line 2212 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpRaiseSqSeen);
-        }
-break;
+        } break;
 case 276:
-#line 2217 "idl.yy"
+# line 2217 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpRaiseQsSeen);
-	  yyval.nlval = yyvsp[-1].nlval;
-	}
-break;
+	  tao_yyval.nlval = tao_yypvt[-1].nlval;
+	} break;
 case 277:
-#line 2222 "idl.yy"
+# line 2222 "idl.tao_yy"
 {
-	  yyval.nlval = NULL;
-	}
-break;
+	  tao_yyval.nlval = NULL;
+	} break;
 case 278:
-#line 2229 "idl.yy"
+# line 2229 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpContextSeen);
-        }
-break;
+        } break;
 case 279:
-#line 2233 "idl.yy"
+# line 2233 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpContextSqSeen);
-        }
-break;
+        } break;
 case 280:
-#line 2238 "idl.yy"
+# line 2238 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpContextQsSeen);
-	  yyval.slval = yyvsp[-1].slval;
-	}
-break;
+	  tao_yyval.slval = tao_yypvt[-1].slval;
+	} break;
 case 281:
-#line 2243 "idl.yy"
+# line 2243 "idl.tao_yy"
 {
-	  yyval.slval = NULL;
-	}
-break;
+	  tao_yyval.slval = NULL;
+	} break;
 case 282:
-#line 2250 "idl.yy"
+# line 2250 "idl.tao_yy"
 {
-	  yyval.slval = new UTL_StrList(yyvsp[-1].sval, yyvsp[0].slval);
-	}
-break;
+	  tao_yyval.slval = new UTL_StrList(tao_yypvt[-1].sval, tao_yypvt[-0].slval);
+	} break;
 case 283:
-#line 2258 "idl.yy"
+# line 2258 "idl.tao_yy"
 {
 	  idl_global->set_parse_state(IDL_GlobalData::PS_OpContextCommaSeen);
-        }
-break;
+        } break;
 case 284:
-#line 2262 "idl.yy"
+# line 2262 "idl.tao_yy"
 {
-	  if (yyvsp[-3].slval == NULL)
-	    yyval.slval = new UTL_StrList(yyvsp[0].sval, NULL);
+	  if (tao_yypvt[-3].slval == NULL)
+	    tao_yyval.slval = new UTL_StrList(tao_yypvt[-0].sval, NULL);
 	  else {
-	    yyvsp[-3].slval->nconc(new UTL_StrList(yyvsp[0].sval, NULL));
-	    yyval.slval = yyvsp[-3].slval;
+	    tao_yypvt[-3].slval->nconc(new UTL_StrList(tao_yypvt[-0].sval, NULL));
+	    tao_yyval.slval = tao_yypvt[-3].slval;
 	  }
-	}
-break;
+	} break;
 case 285:
-#line 2271 "idl.yy"
+# line 2271 "idl.tao_yy"
 {
-	  yyval.slval = NULL;
+	  tao_yyval.slval = NULL;
+	} break;
+# line	532 "/usr/ccs/bin/yaccpar"
 	}
-break;
-#line 3286 "y.tab.c"
-    }
-    yyssp -= yym;
-    yystate = *yyssp;
-    yyvsp -= yym;
-    yym = yylhs[yyn];
-    if (yystate == 0 && yym == 0)
-    {
-#ifdef YYDEBUG
-        if (5 < yydebug)
-            printf("yydebug: after reduction, shifting from state 0 to\
- state %d\n", YYFINAL);
-#endif
-        yystate = YYFINAL;
-        *++yyssp = YYFINAL;
-        *++yyvsp = yyval;
-        if (yychar < 0)
-        {
-            if ((yychar = yylex()) < 0) yychar = 0;
-#if YYDEBUG
-            if (yydebug)
-            {
-                yys = 0;
-                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
-                if (!yys) yys = "illegal-symbol";
-                if (5 < yydebug)
-                    printf("yydebug: state %d, reading %d (%s)\n",
-                        YYFINAL, yychar, yys);
-                else
-                    YYDEBUG_LOOK_AHEAD(YYFINAL, yychar, yys, yyssp-yyss);
-            }
-#endif
-        }
-        if (yychar == 0) goto yyaccept;
-        goto yyloop;
-    }
-    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
-            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
-        yystate = yytable[yyn];
-    else
-        yystate = yydgoto[yym];
-#ifdef YYDEBUG
-    if (5 < yydebug)
-        printf("yydebug: after reduction, shifting from state %d \
-to state %d\n", *yyssp, yystate);
-#endif
-    if (yyssp >= yyss + yystacksize - 1)
-    {
-        goto yyoverflow;
-    }
-    *++yyssp = yystate;
-    *++yyvsp = yyval;
-    goto yyloop;
-yyoverflow:
-    yyerror("yacc stack overflow");
-yyabort:
-    return (1);
-yyaccept:
-    return (0);
+	goto tao_yystack;		/* reset registers in driver code */
 }
+
diff --git a/ace/Parse_Node.cpp b/ace/Parse_Node.cpp
index 03fd2d685be..5ecf3469e47 100644
--- a/ace/Parse_Node.cpp
+++ b/ace/Parse_Node.cpp
@@ -372,10 +372,19 @@ ACE_Location_Node::open_handle (void)
   ACE_TRACE ("ACE_Location_Node::open_handle");
 
   ASYS_TCHAR dl_pathname[MAXPATHLEN + 1];
+  ASYS_TCHAR *name = ASYS_WIDE_STRING (this->pathname ());
+
+#if defined (ACE_WIN32)
+  ASYS_TCHAR dl_exppathname[MAXPATHLEN];
+  if (::ExpandEnvironmentStringsA (name,
+                                   dl_exppathname,
+                                   MAXPATHLEN)) 
+    name = dl_exppathname;
+#endif /* ACE_WIN32 */
 
   // Transform the pathname into the appropriate dynamic link library
   // by searching the ACE_LD_SEARCH_PATH.
-  ACE::ldfind (ASYS_WIDE_STRING (this->pathname ()),
+  ACE::ldfind (name,
                dl_pathname,
                (sizeof dl_pathname / sizeof (ASYS_TCHAR)));
 
diff --git a/ace/Svc_Conf.l b/ace/Svc_Conf.l
index 3fad8fabd65..a4e6f5b4735 100644
--- a/ace/Svc_Conf.l
+++ b/ace/Svc_Conf.l
@@ -22,7 +22,7 @@ letter	        [a-zA-Z_]
 letter_or_digit	[a-zA-Z_0-9]
 digit           [0-9]
 ident           {letter}{letter_or_digit}*
-pathname        ([A-Za-z]:)?[a-zA-Z_0-9/\.\\-]+
+pathname        ([A-Za-z\%]:)?[a-zA-Z_0-9/\%\.\\-]+
 symbol		[ -~]
 string		\"{symbol}*\"
 white_space	[ \t]
diff --git a/ace/Svc_Conf_l.cpp b/ace/Svc_Conf_l.cpp
index 9849ce985b6..80a6e38c9e1 100644
--- a/ace/Svc_Conf_l.cpp
+++ b/ace/Svc_Conf_l.cpp
@@ -26,49 +26,49 @@
 #include "ace/OS.h"
 
 /* Use prototypes in function declarations. */
-#define YY_USE_PROTOS
+#define ACE_YY_USE_PROTOS
 
 /* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
+#define ACE_YY_USE_CONST
 
 #else	/* ! __cplusplus */
 
 #ifdef __STDC__
 
-#define YY_USE_PROTOS
-#define YY_USE_CONST
+#define ACE_YY_USE_PROTOS
+#define ACE_YY_USE_CONST
 
 #endif	/* __STDC__ */
 #endif	/* ! __cplusplus */
 
 
 #ifdef __TURBOC__
-#define YY_USE_CONST
+#define ACE_YY_USE_CONST
 #endif
 
 
-#ifndef YY_USE_CONST
+#ifndef ACE_YY_USE_CONST
 #ifndef const
 #define const
 #endif
 #endif
 
 
-#ifdef YY_USE_PROTOS
-#define YY_PROTO(proto) proto
+#ifdef ACE_YY_USE_PROTOS
+#define ACE_YY_PROTO(proto) proto
 #else
-#define YY_PROTO(proto) ()
+#define ACE_YY_PROTO(proto) ()
 #endif
 
 /* Returned upon end-of-file. */
-#define YY_NULL 0
+#define ACE_YY_NULL 0
 
 /* Promotes a possibly negative, possibly signed char to an unsigned
  * integer for use as an array index.  If the signed char is negative,
  * we want to instead treat it as an 8-bit unsigned char, hence the
  * double cast.
  */
-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+#define ACE_YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
 
 /* Enter a start condition.  This macro really ought to take a parameter,
  * but we do it the disgusting crufty way forced on us by the ()-less
@@ -79,22 +79,22 @@
 /* Translate the current start state into a value that can be later handed
  * to BEGIN to return to the state.
  */
-#define YY_START ((ace_yy_start - 1) / 2)
+#define ACE_YY_START ((ace_yy_start - 1) / 2)
 
 /* Action number for EOF rule of a given start state. */
-#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+#define ACE_YY_STATE_EOF(state) (ACE_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.
  */
-#define YY_NEW_FILE ace_yyrestart( ace_yyin )
+#define ACE_YY_NEW_FILE ace_yyrestart( ace_yyin )
 
-#define YY_END_OF_BUFFER_CHAR 0
+#define ACE_YY_END_OF_BUFFER_CHAR 0
 
 /* Size of default input buffer. */
-#define YY_BUF_SIZE 16384
+#define ACE_YY_BUF_SIZE 16384
 
-typedef struct ace_yy_buffer_state *YY_BUFFER_STATE;
+typedef struct ace_yy_buffer_state *ACE_YY_BUFFER_STATE;
 
 extern int ace_yyleng;
 extern FILE *ace_yyin, *ace_yyout;
@@ -102,7 +102,7 @@ extern FILE *ace_yyin, *ace_yyout;
 #ifdef __cplusplus
 extern "C" {
 #endif
-	extern int ace_yywrap YY_PROTO(( void ));
+	extern int ace_yywrap ACE_YY_PROTO(( void ));
 #ifdef __cplusplus
 	}
 #endif
@@ -132,8 +132,8 @@ extern "C" {
 		{ \
 		/* Undo effects of setting up ace_yytext. */ \
 		*ace_yy_cp = ace_yy_hold_char; \
-		ace_yy_c_buf_p = ace_yy_cp = ace_yy_bp + n - YY_MORE_ADJ; \
-		YY_DO_BEFORE_ACTION; /* set up ace_yytext again */ \
+		ace_yy_c_buf_p = ace_yy_cp = ace_yy_bp + n - ACE_YY_MORE_ADJ; \
+		ACE_YY_DO_BEFORE_ACTION; /* set up ace_yytext again */ \
 		} \
 	while ( 0 )
 
@@ -172,10 +172,10 @@ struct ace_yy_buffer_state
 	int ace_yy_fill_buffer;
 
 	int ace_yy_buffer_status;
-#define YY_BUFFER_NEW 0
-#define YY_BUFFER_NORMAL 1
+#define ACE_YY_BUFFER_NEW 0
+#define ACE_YY_BUFFER_NORMAL 1
 	/* When an EOF's been seen but there's still some text to process
-	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+	 * then we mark the buffer as ACE_YY_EOF_PENDING, to indicate that we
 	 * shouldn't try reading from the input source any more.  We might
 	 * still have a bunch of tokens to match, though, because of
 	 * possible backing-up.
@@ -184,16 +184,16 @@ struct ace_yy_buffer_state
 	 * (via ace_yyrestart()), so that the user can continue scanning by
 	 * just pointing ace_yyin at a new input file.
 	 */
-#define YY_BUFFER_EOF_PENDING 2
+#define ACE_YY_BUFFER_EOF_PENDING 2
 	};
 
-static YY_BUFFER_STATE ace_yy_current_buffer = 0;
+static ACE_YY_BUFFER_STATE ace_yy_current_buffer = 0;
 
 /* We provide macros for accessing buffer states in case in the
  * future we want to put the buffer states in a more general
  * "scanner state".
  */
-#define YY_CURRENT_BUFFER ace_yy_current_buffer
+#define ACE_YY_CURRENT_BUFFER ace_yy_current_buffer
 
 
 /* ace_yy_hold_char holds the character lost when ace_yytext is formed. */
@@ -215,79 +215,79 @@ 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 ));
+static void ace_yyunput ACE_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_yyrestart ACE_YY_PROTO(( FILE *input_file ));
+void ace_yy_switch_to_buffer ACE_YY_PROTO(( ACE_YY_BUFFER_STATE new_buffer ));
+void ace_yy_load_buffer_state ACE_YY_PROTO(( void ));
+ACE_YY_BUFFER_STATE ace_yy_create_buffer ACE_YY_PROTO(( FILE *file, int size ));
+void ace_yy_delete_buffer ACE_YY_PROTO(( ACE_YY_BUFFER_STATE b ));
+void ace_yy_init_buffer ACE_YY_PROTO(( ACE_YY_BUFFER_STATE b, FILE *file ));
 
 #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 ));
+static void ace_yy_push_state ACE_YY_PROTO(( int new_state ));
+static void ace_yy_pop_state ACE_YY_PROTO(( void ));
+static int ace_yy_top_state ACE_YY_PROTO(( void ));
 #endif /* 0 */
 
-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_free YY_PROTO(( void * ));
+static void *ace_yy_flex_alloc ACE_YY_PROTO(( unsigned int ));
+static void *ace_yy_flex_realloc ACE_YY_PROTO(( void *, unsigned int ));
+static void ace_yy_flex_free ACE_YY_PROTO(( void * ));
 
 #define ace_yy_new_buffer ace_yy_create_buffer
 
 #define INITIAL 0
 #define PARAMETERS 1
 #define NORMAL 2
-typedef unsigned char YY_CHAR;
+typedef unsigned char ACE_YY_CHAR;
 typedef int ace_yy_state_type;
 FILE *ace_yyin = (FILE *) 0, *ace_yyout = (FILE *) 0;
 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 ));
+static void ace_yy_flex_strncpy ACE_YY_PROTO(( char *, const char *, int ));
 #endif
 
 #ifdef __cplusplus
-static int ace_yyinput YY_PROTO(( void ));
+static int ace_yyinput ACE_YY_PROTO(( void ));
 #else
-static int input YY_PROTO(( void ));
+static int input ACE_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 ace_yy_state_type ace_yy_get_previous_state ACE_YY_PROTO(( void ));
+static ace_yy_state_type ace_yy_try_NUL_trans ACE_YY_PROTO(( ace_yy_state_type current_state ));
+static int ace_yy_get_next_buffer ACE_YY_PROTO(( void ));
+static void ace_yy_fatal_error ACE_YY_PROTO(( const char msg[] ));
 
 /* Done after the current pattern has been matched and before the
  * corresponding action - sets up ace_yytext.
  */
-#define YY_DO_BEFORE_ACTION \
+#define ACE_YY_DO_BEFORE_ACTION \
 	ace_yytext_ptr = ace_yy_bp; \
 	ace_yyleng = 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_END_OF_BUFFER 26
-static const short int ace_yy_accept[103] =
+#define ACE_YY_END_OF_BUFFER 26
+static const short int ace_yy_accept[104] =
     {   0,
         0,    0,    0,    0,    0,    0,   26,   24,   22,   23,
-       24,   15,   16,   14,   21,   13,   20,   20,   20,   20,
-       20,   20,   20,   20,   20,   17,   18,   24,   22,    0,
-       19,   21,   20,    0,   20,   20,   20,   20,   20,   20,
-       20,   20,   20,    0,    1,   20,   20,   20,   20,   20,
+       24,   21,   15,   16,   14,   21,   13,   20,   20,   20,
+       20,   20,   20,   20,   20,   20,   17,   18,   24,   22,
+        0,   19,   21,    0,   20,   20,   20,   20,   20,   20,
+       20,   20,   20,   20,    0,    1,   20,   20,   20,   20,
        20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
        20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
-       20,   20,   20,   20,   20,   20,   20,   20,    8,   10,
-       20,   11,   20,   20,    6,    5,    3,    7,   20,   20,
-        2,   20,    4,   20,   12,   20,   20,   20,   20,   20,
+       20,   20,   20,   20,   20,   20,   20,   20,   20,    8,
+       10,   20,   11,   20,   20,    6,    5,    3,    7,   20,
+       20,    2,   20,    4,   20,   12,   20,   20,   20,   20,
 
-        9,    0
+       20,    9,    0
     } ;
 
 static const int ace_yy_ec[256] =
@@ -295,17 +295,17 @@ static const int ace_yy_ec[256] =
         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    4,    5,    6,    7,    5,    5,    5,    5,    8,
-        9,   10,    5,    5,   11,   11,   11,   12,   12,   12,
-       12,   12,   12,   12,   12,   12,   12,   13,    5,    5,
-        5,    5,    5,    5,   14,   15,   15,   15,   16,   15,
-       15,   15,   15,   15,   15,   15,   17,   15,   18,   15,
-       15,   19,   20,   21,   15,   15,   15,   15,   15,   15,
-        5,   11,    5,    5,   22,    5,   23,   24,   25,   26,
-
-       27,   15,   15,   15,   28,   29,   15,   30,   31,   32,
-       33,   34,   15,   35,   36,   37,   38,   39,   15,   15,
-       40,   15,   41,    5,   42,    5,    1,    1,    1,    1,
+        1,    4,    5,    6,    7,    5,    8,    5,    5,    9,
+       10,   11,    5,    5,   12,   12,   12,   13,   13,   13,
+       13,   13,   13,   13,   13,   13,   13,   14,    5,    5,
+        5,    5,    5,    5,   15,   16,   16,   16,   17,   16,
+       16,   16,   16,   16,   16,   16,   18,   16,   19,   16,
+       16,   20,   21,   22,   16,   16,   16,   16,   16,   16,
+        5,   12,    5,    5,   23,    5,   24,   25,   26,   27,
+
+       28,   16,   16,   16,   29,   30,   16,   31,   32,   33,
+       34,   35,   16,   36,   37,   38,   39,   40,   16,   16,
+       41,   16,   42,    5,   43,    5,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -322,131 +322,159 @@ static const int ace_yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static const int ace_yy_meta[43] =
+static const int ace_yy_meta[44] =
     {   0,
-        1,    1,    1,    2,    2,    2,    2,    2,    2,    2,
-        3,    3,    4,    3,    3,    3,    3,    3,    3,    3,
+        1,    1,    1,    2,    2,    2,    2,    3,    2,    2,
+        2,    3,    3,    3,    3,    3,    3,    3,    3,    3,
         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
-        2,    2
+        3,    2,    2
     } ;
 
-static const short int ace_yy_base[107] =
+static const short int ace_yy_base[108] =
     {   0,
-        0,  112,    0,  111,    0,  107,   97,  313,   41,  313,
-       85,  313,  313,  313,    0,  313,   33,   36,   37,   40,
-       41,   44,   48,   49,   52,  313,  313,   82,   66,   76,
-       72,    0,   60,    0,   61,   64,   68,   75,   81,   82,
-       85,   88,   89,   64,  313,   93,  104,   96,  111,  115,
-      116,   97,  121,  129,  133,  134,  137,  138,  142,  143,
-      150,  151,  158,  161,  162,  166,  167,  172,  185,  180,
-      173,  190,  193,  196,  197,  200,  201,  204,  209,  215,
-      216,  220,  224,  227,  228,  231,  234,  235,  239,  240,
-      243,  244,  247,  250,  256,  259,  262,  263,  267,  266,
-
-      271,  313,  302,   53,  304,  308
+        0,  112,    0,  107,    0,   99,  104,  439,   42,  439,
+       95,   79,  439,  439,  439,   77,  439,   37,   40,   45,
+       48,   56,   57,   64,   67,   72,  439,  439,   87,   59,
+       79,   71,   52,   44,   75,   80,   88,   91,  101,  104,
+      109,  112,  117,  120,   52,  439,  128,  138,  146,  151,
+      154,  161,  162,  169,  176,  177,  185,  186,  195,  204,
+      207,  214,  215,  222,  223,  230,  237,  240,  252,  255,
+      262,  263,  270,  271,  278,  281,  289,  290,  299,  300,
+      309,  312,  317,  322,  325,  330,  333,  338,  341,  346,
+      349,  354,  362,  363,  370,  371,  379,  380,  387,  388,
+
+      395,  404,  439,  432,   47,   44,  435
     } ;
 
-static const short int ace_yy_def[107] =
+static const short int ace_yy_def[108] =
     {   0,
-      102,    1,    1,    1,    1,    1,  102,  102,  102,  102,
-      103,  102,  102,  102,  104,  102,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  102,  102,  106,  102,  103,
-      103,  104,  105,  104,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  106,  102,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-
-      105,    0,  102,  102,  102,  102
+      103,    1,    1,    1,    1,    1,  103,  103,  103,  103,
+      104,  105,  103,  103,  103,  105,  103,  106,  106,  106,
+      106,  106,  106,  106,  106,  106,  103,  103,  107,  103,
+      104,  104,  105,  105,  106,  106,  106,  106,  106,  106,
+      106,  106,  106,  106,  107,  103,  106,  106,  106,  106,
+      106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
+      106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
+      106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
+      106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
+      106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
+
+      106,  106,    0,  103,  103,  103,  103
     } ;
 
-static const short int ace_yy_nxt[356] =
+static const short int ace_yy_nxt[483] =
     {   0,
         8,    9,   10,    9,    8,   11,    8,   12,   13,   14,
-       15,   15,   16,   17,   17,   17,   18,   17,   17,   19,
-       17,   20,   21,   17,   17,   22,   17,   23,   17,   17,
-       17,   17,   17,   17,   24,   25,   17,   17,   17,   17,
-       26,   27,   29,   32,   29,   34,   32,   32,   34,   34,
-       32,   32,  102,   34,   32,   32,   34,   36,   32,   32,
-       34,   34,   32,   37,   34,   38,   45,   29,   35,   29,
-       32,   32,  102,  102,   32,   41,  102,   31,   32,   40,
-      102,   31,   47,   39,   45,   32,   46,  102,   42,   43,
-       31,   32,   32,  102,  102,   32,  102,  102,   32,   32,
-
-      102,  102,   48,   32,   51,  102,   32,   32,  102,  102,
-       54,   49,   50,   28,   32,   52,  102,   28,   28,   58,
-       53,   32,   55,  102,   56,   32,   32,  102,  102,   63,
-       57,   32,  102,  102,   59,  102,  102,   61,   60,   32,
-       62,  102,  102,   32,   32,  102,  102,   32,   32,  102,
-      102,   69,   32,   32,  102,  102,  102,  102,   64,   66,
-       32,   32,  102,  102,  102,   65,   68,   67,   32,   70,
-      102,   32,   32,  102,  102,  102,   32,   32,  102,  102,
-       72,   71,   32,   32,  102,  102,  102,   73,   77,   76,
-       32,   75,  102,   78,  102,   32,   74,  102,   79,   82,
-
-       32,   80,  102,   32,   81,  102,   32,   32,  102,  102,
-       32,   32,  102,  102,   32,  102,  102,   83,  102,   32,
-       84,  102,   85,   86,   87,   32,   32,  102,  102,  102,
-       32,   88,  102,  102,   32,   89,  102,   32,   32,  102,
-      102,   32,   90,  102,   32,   32,  102,  102,   91,   32,
-       32,  102,  102,   32,   32,  102,  102,   32,  102,  102,
-       32,   94,  102,  102,   93,   92,   32,   96,  102,   32,
-       95,  102,   32,   32,  102,  102,   32,   32,  102,  102,
-      102,   32,   97,  102,  102,  102,  102,  102,  102,   99,
-       98,  100,  102,  102,  102,  102,  102,  102,  102,  102,
-
-      102,  102,  101,   30,   30,   30,   33,   33,   44,   44,
-       44,   44,    7,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102
+       15,   16,   16,   17,   18,   18,   18,   19,   18,   18,
+       20,   18,   21,   22,   18,   18,   23,   18,   24,   18,
+       18,   18,   18,   18,   18,   25,   26,   18,   18,   18,
+       18,   27,   28,   30,   33,   30,   35,   33,   33,   33,
+       34,   33,   33,   34,   46,   33,   33,  103,   34,   33,
+       30,  103,   30,   33,   33,  103,   37,   33,   33,   34,
+       34,   33,   38,   36,   33,   33,   32,   34,   33,   33,
+       34,   39,   33,   33,   32,   34,   33,   33,  103,   46,
+      103,   33,   34,  103,   42,   33,   41,   40,   33,   33,
+
+       32,  103,   33,  103,  103,   29,   47,   48,   33,   43,
+       44,   33,   33,   29,  103,   33,   33,  103,   29,   33,
+       33,  103,  103,   33,   33,  103,   49,   33,   33,  103,
+      103,   33,   52,  103,  103,   33,   51,  103,   50,   33,
+       55,  103,  103,   53,  103,   33,  103,  103,   54,   33,
+      103,  103,   56,   33,   59,  103,   57,   33,   33,  103,
+      103,   33,   33,  103,  103,   33,   58,  103,   33,   33,
+      103,  103,   33,   33,  103,  103,   33,   62,  103,   61,
+       33,  103,  103,   33,   33,   60,   63,   33,   33,  103,
+      103,  103,   33,   33,  103,   64,   33,   33,  103,  103,
+
+      103,  103,   33,  103,   67,  103,   33,   65,  103,   70,
+      103,   33,  103,   66,   33,   33,   69,  103,   33,   68,
+      103,   33,   33,  103,  103,   33,   33,  103,  103,   33,
+       33,  103,   71,   33,   33,  103,  103,   33,  103,  103,
+      103,   33,  103,  103,   33,   73,   72,   33,   33,  103,
+      103,   33,   74,  103,   76,  103,  103,  103,   77,   33,
+       78,   75,   33,   33,  103,  103,   33,   79,  103,   33,
+       33,  103,   81,   33,   33,  103,  103,   33,   33,   80,
+      103,   33,   33,  103,  103,   33,  103,   82,   33,   33,
+       83,  103,   33,  103,  103,  103,   33,   33,   84,   85,
+
+       33,   33,  103,  103,  103,   86,   33,   33,   87,  103,
+       33,   33,  103,  103,   88,  103,   33,  103,  103,   33,
+       33,   89,  103,   33,   33,  103,  103,  103,   33,   33,
+      103,   90,   33,   33,  103,  103,   33,   33,  103,   91,
+       33,   33,  103,  103,   33,   33,  103,   92,   33,   33,
+      103,  103,   33,   33,  103,  103,   33,   33,  103,  103,
+       33,   33,  103,  103,   93,   33,  103,  103,  103,   33,
+       33,   95,   94,   33,   33,  103,  103,   33,   33,  103,
+      103,   33,   33,  103,  103,  103,   33,   33,   97,   96,
+       33,   33,  103,  103,   33,   33,  103,  103,   33,   33,
+
+      103,  103,   33,   98,  103,  103,   33,  103,  103,   99,
+      103,   33,  103,  101,  100,   33,  103,  103,  103,  103,
+      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
+      103,  103,  102,   31,   31,   45,   45,   45,    7,  103,
+      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
+      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
+      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
+      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
+      103,  103
     } ;
 
-static const short int ace_yy_chk[356] =
+static const short int ace_yy_chk[483] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    9,   17,    9,   17,   18,   19,   18,   19,
-       20,   21,   20,   21,   22,  104,   22,   19,   23,   24,
-       23,   24,   25,   19,   25,   21,   44,   29,   18,   29,
-       33,   35,   33,   35,   36,   24,   36,   31,   37,   23,
-       37,   30,   36,   22,   28,   38,   35,   38,   25,   25,
-       11,   39,   40,   39,   40,   41,    7,   41,   42,   43,
-
-       42,   43,   37,   46,   40,   46,   48,   52,   48,   52,
-       42,   38,   39,    6,   47,   41,   47,    4,    2,   47,
-       41,   49,   42,   49,   43,   50,   51,   50,   51,   52,
-       46,   53,    0,   53,   48,    0,    0,   50,   49,   54,
-       51,   54,    0,   55,   56,   55,   56,   57,   58,   57,
-       58,   58,   59,   60,   59,   60,    0,    0,   53,   55,
-       61,   62,   61,   62,    0,   54,   57,   56,   63,   59,
-       63,   64,   65,   64,   65,    0,   66,   67,   66,   67,
-       61,   60,   68,   71,   68,   71,    0,   62,   66,   65,
-       70,   64,   70,   67,    0,   69,   63,   69,   68,   71,
-
-       72,   69,   72,   73,   70,   73,   74,   75,   74,   75,
-       76,   77,   76,   77,   78,    0,   78,   72,    0,   79,
-       73,   79,   74,   75,   76,   80,   81,   80,   81,    0,
-       82,   77,   82,    0,   83,   78,   83,   84,   85,   84,
-       85,   86,   81,   86,   87,   88,   87,   88,   83,   89,
-       90,   89,   90,   91,   92,   91,   92,   93,    0,   93,
-       94,   90,   94,    0,   89,   84,   95,   94,   95,   96,
-       92,   96,   97,   98,   97,   98,  100,   99,  100,   99,
-        0,  101,   96,  101,    0,    0,    0,    0,    0,   98,
-       97,   99,    0,    0,    0,    0,    0,    0,    0,    0,
-
-        0,    0,  100,  103,  103,  103,  105,  105,  106,  106,
-      106,  106,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102
+        1,    1,    1,    9,   18,    9,  106,   19,   18,  105,
+       18,   19,   20,   19,   45,   21,   20,   34,   20,   21,
+       30,   21,   30,   22,   23,   33,   20,   22,   23,   22,
+       23,   24,   20,   19,   25,   24,   32,   24,   25,   26,
+       25,   22,   35,   26,   31,   26,   35,   36,   35,   29,
+       16,   36,   12,   36,   25,   37,   24,   23,   38,   37,
+
+       11,   37,   38,    7,   38,    6,   36,   37,   39,   26,
+       26,   40,   39,    4,   39,   40,   41,   40,    2,   42,
+       41,    0,   41,   42,   43,   42,   38,   44,   43,    0,
+       43,   44,   41,   44,    0,   47,   40,    0,   39,   47,
+       43,   47,    0,   42,    0,   48,    0,    0,   42,   48,
+        0,   48,   43,   49,   48,    0,   44,   49,   50,   49,
+        0,   51,   50,    0,   50,   51,   47,   51,   52,   53,
+        0,    0,   52,   53,   52,   53,   54,   51,    0,   50,
+       54,    0,   54,   55,   56,   49,   52,   55,   56,   55,
+       56,    0,   57,   58,    0,   53,   57,   58,   57,   58,
+
+        0,    0,   59,    0,   56,    0,   59,   54,   59,   59,
+        0,   60,    0,   55,   61,   60,   58,   60,   61,   57,
+       61,   62,   63,    0,    0,   62,   63,   62,   63,   64,
+       65,    0,   60,   64,   65,   64,   65,   66,    0,    0,
+        0,   66,    0,   66,   67,   62,   61,   68,   67,    0,
+       67,   68,   63,   68,   65,    0,    0,    0,   66,   69,
+       67,   64,   70,   69,    0,   69,   70,   68,   70,   71,
+       72,    0,   70,   71,   72,   71,   72,   73,   74,   69,
+        0,   73,   74,   73,   74,   75,    0,   71,   76,   75,
+       72,   75,   76,    0,   76,    0,   77,   78,   73,   74,
+
+       77,   78,   77,   78,    0,   75,   79,   80,   76,    0,
+       79,   80,   79,   80,   77,    0,   81,    0,    0,   82,
+       81,   78,   81,   82,   83,   82,    0,    0,   83,   84,
+       83,   79,   85,   84,    0,   84,   85,   86,   85,   82,
+       87,   86,    0,   86,   87,   88,   87,   84,   89,   88,
+        0,   88,   89,   90,   89,    0,   91,   90,    0,   90,
+       91,   92,   91,    0,   85,   92,    0,   92,    0,   93,
+       94,   91,   90,   93,   94,   93,   94,   95,   96,    0,
+        0,   95,   96,   95,   96,    0,   97,   98,   95,   93,
+       97,   98,   97,   98,   99,  100,    0,    0,   99,  100,
+
+       99,  100,  101,   97,    0,    0,  101,    0,  101,   98,
+        0,  102,    0,  100,   99,  102,    0,  102,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,  101,  104,  104,  107,  107,  107,  103,  103,
+      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
+      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
+      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
+      103,  103,  103,  103,  103,  103,  103,  103,  103,  103,
+      103,  103
     } ;
 
 static ace_yy_state_type ace_yy_last_accepting_state;
@@ -457,7 +485,7 @@ 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 ACE_YY_MORE_ADJ 0
 char *ace_yytext;
 # line 1 "Svc_Conf.l"
 # line 2 "Svc_Conf.l"
@@ -480,8 +508,8 @@ int ace_yyerrno = 0;
  * section 1.
  */
 
-#ifdef YY_MALLOC_DECL
-YY_MALLOC_DECL
+#ifdef ACE_YY_MALLOC_DECL
+ACE_YY_MALLOC_DECL
 #else
 #if __STDC__
 #ifndef __cplusplus
@@ -496,8 +524,8 @@ YY_MALLOC_DECL
 #endif
 
 /* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#define YY_READ_BUF_SIZE 8192
+#ifndef ACE_YY_READ_BUF_SIZE
+#define ACE_YY_READ_BUF_SIZE 8192
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
@@ -509,11 +537,11 @@ YY_MALLOC_DECL
 #define ACE_SVC_CONF_ECHO (void) fwrite( ace_yytext, ace_yyleng, 1, ace_yyout )
 #endif
 
-/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+/* Gets input and stuffs it into "buf".  number of characters read, or ACE_YY_NULL,
  * is returned in "result".
  */
-#ifndef YY_INPUT
-#define YY_INPUT(buf,result,max_size) \
+#ifndef ACE_YY_INPUT
+#define ACE_YY_INPUT(buf,result,max_size) \
 	if ( ace_yy_current_buffer->ace_yy_is_interactive ) \
 		{ \
 		int c = getc( ace_yyin ); \
@@ -522,7 +550,7 @@ YY_MALLOC_DECL
 		} \
 	else if ( ((result = fread( buf, 1, max_size, ace_yyin )) == 0) \
 		  && ferror( ace_yyin ) ) \
-		YY_FATAL_ERROR( "input in flex scanner failed" );
+		ACE_YY_FATAL_ERROR( "input in flex scanner failed" );
 #endif
 
 /* No semi-colon after return; correct usage is to write "ace_yyterminate();" -
@@ -530,39 +558,39 @@ YY_MALLOC_DECL
  * some compilers to complain about unreachable statements.
  */
 #ifndef ace_yyterminate
-#define ace_yyterminate() return YY_NULL
+#define ace_yyterminate() return ACE_YY_NULL
 #endif
 
 /* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
+#ifndef ACE_YY_START_STACK_INCR
+#define ACE_YY_START_STACK_INCR 25
 #endif
 
 /* Report a fatal error. */
-#ifndef YY_FATAL_ERROR
-#define YY_FATAL_ERROR(msg) ace_yy_fatal_error( msg )
+#ifndef ACE_YY_FATAL_ERROR
+#define ACE_YY_FATAL_ERROR(msg) ace_yy_fatal_error( msg )
 #endif
 
 /* Default declaration of generated scanner - a define so the user can
  * easily add parameters.
  */
-#ifndef YY_DECL
-#define YY_DECL int ace_yylex YY_PROTO(( void ))
+#ifndef ACE_YY_DECL
+#define ACE_YY_DECL int ace_yylex ACE_YY_PROTO(( void ))
 #endif
 
 /* Code executed at the beginning of each rule, after ace_yytext and ace_yyleng
  * have been set up.
  */
-#ifndef YY_USER_ACTION
-#define YY_USER_ACTION
+#ifndef ACE_YY_USER_ACTION
+#define ACE_YY_USER_ACTION
 #endif
 
 /* Code executed at the end of each rule. */
-#ifndef YY_BREAK
-#define YY_BREAK break;
+#ifndef ACE_YY_BREAK
+#define ACE_YY_BREAK break;
 #endif
 
-YY_DECL
+ACE_YY_DECL
 	{
 	register ace_yy_state_type ace_yy_current_state;
 	register char *ace_yy_cp, *ace_yy_bp;
@@ -574,8 +602,8 @@ YY_DECL
 
 	if ( ace_yy_init )
 		{
-#ifdef YY_USER_INIT
-		YY_USER_INIT;
+#ifdef ACE_YY_USER_INIT
+		ACE_YY_USER_INIT;
 #endif
 
 		if ( ! ace_yy_start )
@@ -591,7 +619,7 @@ YY_DECL
 			ace_yy_init_buffer( ace_yy_current_buffer, ace_yyin );
 		else
 			ace_yy_current_buffer =
-				ace_yy_create_buffer( ace_yyin, YY_BUF_SIZE );
+				ace_yy_create_buffer( ace_yyin, ACE_YY_BUF_SIZE );
 
 		ace_yy_load_buffer_state();
 
@@ -616,7 +644,7 @@ YY_DECL
 ace_yy_match:
 		do
 			{
-			register YY_CHAR ace_yy_c = ace_yy_ec[YY_SC_TO_UI(*ace_yy_cp)];
+			register ACE_YY_CHAR ace_yy_c = ace_yy_ec[ACE_YY_SC_TO_UI(*ace_yy_cp)];
 			if ( ace_yy_accept[ace_yy_current_state] )
 				{
 				ace_yy_last_accepting_state = ace_yy_current_state;
@@ -625,18 +653,18 @@ ace_yy_match:
 			while ( ace_yy_chk[ace_yy_base[ace_yy_current_state] + ace_yy_c] != ace_yy_current_state )
 				{
 				ace_yy_current_state = (int) ace_yy_def[ace_yy_current_state];
-				if ( ace_yy_current_state >= 103 )
+				if ( ace_yy_current_state >= 104 )
 					ace_yy_c = ace_yy_meta[(unsigned int) ace_yy_c];
 				}
 			ace_yy_current_state = ace_yy_nxt[ace_yy_base[ace_yy_current_state] + (unsigned int) ace_yy_c];
 			++ace_yy_cp;
 			}
-		while ( ace_yy_base[ace_yy_current_state] != 313 );
+		while ( ace_yy_base[ace_yy_current_state] != 439 );
 
 ace_yy_find_action:
 		ace_yy_act = ace_yy_accept[ace_yy_current_state];
 
-		YY_DO_BEFORE_ACTION;
+		ACE_YY_DO_BEFORE_ACTION;
 
 
 do_action:	/* This label is used only to access EOF actions. */
@@ -645,7 +673,7 @@ do_action:	/* This label is used only to access EOF actions. */
 		switch ( ace_yy_act )
 	{ /* beginning of action switch */
 			case 0: /* must back up */
-			/* undo the effects of YY_DO_BEFORE_ACTION */
+			/* undo the effects of ACE_YY_DO_BEFORE_ACTION */
 			*ace_yy_cp = ace_yy_hold_char;
 			ace_yy_cp = ace_yy_last_accepting_cpos;
 			ace_yy_current_state = ace_yy_last_accepting_state;
@@ -654,157 +682,157 @@ do_action:	/* This label is used only to access EOF actions. */
 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
+ACE_YY_DO_BEFORE_ACTION; /* set up ace_yytext again */
+ACE_YY_USER_ACTION
 # line 34 "Svc_Conf.l"
 ; /* EMPTY */
-	YY_BREAK
+	ACE_YY_BREAK
 case 2:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 35 "Svc_Conf.l"
 { return token (ACE_DYNAMIC); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 3:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 36 "Svc_Conf.l"
 { return token (ACE_STATIC); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 4:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 37 "Svc_Conf.l"
 { return token (ACE_SUSPEND); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 5:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 38 "Svc_Conf.l"
 { return token (ACE_RESUME); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 6:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 39 "Svc_Conf.l"
 { return token (ACE_REMOVE); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 7:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 40 "Svc_Conf.l"
 { return token (ACE_USTREAM); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 8:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 41 "Svc_Conf.l"
 { return token (ACE_MODULE_T); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 9:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 42 "Svc_Conf.l"
 { return token (ACE_SVC_OBJ_T); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 10:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 43 "Svc_Conf.l"
 { return token (ACE_STREAM_T); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 11:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 44 "Svc_Conf.l"
 { return token (ACE_ACTIVE); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 12:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 45 "Svc_Conf.l"
 { return token (ACE_INACTIVE); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 13:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 46 "Svc_Conf.l"
 { return token (ACE_COLON); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 14:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 47 "Svc_Conf.l"
 { return token (ACE_STAR); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 15:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 48 "Svc_Conf.l"
 { return token (ACE_LPAREN); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 16:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 49 "Svc_Conf.l"
 { return token (ACE_RPAREN); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 17:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 50 "Svc_Conf.l"
 { return token (ACE_LBRACE); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 18:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 51 "Svc_Conf.l"
 { return token (ACE_RBRACE); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 19:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # 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);
 			return token (ACE_STRING); }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 20:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 57 "Svc_Conf.l"
 {
 		        ace_yylval.ident_ = ace_obstack->copy (ace_yytext, ace_yyleng);
 			return token (ACE_IDENT);
 		      }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 21:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 61 "Svc_Conf.l"
 {
 		        ace_yylval.ident_ = ace_obstack->copy (ace_yytext, ace_yyleng);
 			return token (ACE_PATHNAME);
 		      }
-	/* YY_BREAK */
+	/* ACE_YY_BREAK */
 case 22:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 65 "Svc_Conf.l"
 ; /* EMPTY */
-	YY_BREAK
+	ACE_YY_BREAK
 case 23:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 66 "Svc_Conf.l"
 { ace_yylineno++; }
-	YY_BREAK
+	ACE_YY_BREAK
 case 24:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # 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):
+	ACE_YY_BREAK
+case ACE_YY_STATE_EOF(INITIAL):
+case ACE_YY_STATE_EOF(PARAMETERS):
+case ACE_YY_STATE_EOF(NORMAL):
 # line 68 "Svc_Conf.l"
-{ YY_NEW_FILE; ace_yyterminate(); }
-	/* YY_BREAK */
+{ ACE_YY_NEW_FILE; ace_yyterminate(); }
+	/* ACE_YY_BREAK */
 case 25:
-YY_USER_ACTION
+ACE_YY_USER_ACTION
 # line 69 "Svc_Conf.l"
 ACE_SVC_CONF_ECHO;
-	YY_BREAK
+	ACE_YY_BREAK
 
-	case YY_END_OF_BUFFER:
+	case ACE_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;
 
-		/* Undo the effects of YY_DO_BEFORE_ACTION. */
+		/* Undo the effects of ACE_YY_DO_BEFORE_ACTION. */
 		*ace_yy_cp = ace_yy_hold_char;
 
-		if ( ace_yy_current_buffer->ace_yy_buffer_status == YY_BUFFER_NEW )
+		if ( ace_yy_current_buffer->ace_yy_buffer_status == ACE_YY_BUFFER_NEW )
 			{
 			/* We're scanning a new file or input source.  It's
 			 * possible that this happened because the user
@@ -817,7 +845,7 @@ ACE_SVC_CONF_ECHO;
 			 */
 			ace_yy_n_chars = ace_yy_current_buffer->ace_yy_n_chars;
 			ace_yy_current_buffer->ace_yy_input_file = ace_yyin;
-			ace_yy_current_buffer->ace_yy_buffer_status = YY_BUFFER_NORMAL;
+			ace_yy_current_buffer->ace_yy_buffer_status = ACE_YY_BUFFER_NORMAL;
 			}
 
 		/* Note that here we test for ace_yy_c_buf_p "<=" to the position
@@ -846,7 +874,7 @@ ACE_SVC_CONF_ECHO;
 
 			ace_yy_next_state = ace_yy_try_NUL_trans( ace_yy_current_state );
 
-			ace_yy_bp = ace_yytext_ptr + YY_MORE_ADJ;
+			ace_yy_bp = ace_yytext_ptr + ACE_YY_MORE_ADJ;
 
 			if ( ace_yy_next_state )
 				{
@@ -877,19 +905,19 @@ ACE_SVC_CONF_ECHO;
 					 * ace_yy_c_buf_p so that if some total
 					 * hoser (like flex itself) wants to
 					 * call the scanner after we return the
-					 * YY_NULL, it'll still work - another
-					 * YY_NULL will get returned.
+					 * ACE_YY_NULL, it'll still work - another
+					 * ACE_YY_NULL will get returned.
 					 */
-					ace_yy_c_buf_p = ace_yytext_ptr + YY_MORE_ADJ;
+					ace_yy_c_buf_p = ace_yytext_ptr + ACE_YY_MORE_ADJ;
 
-					ace_yy_act = YY_STATE_EOF(YY_START);
+					ace_yy_act = ACE_YY_STATE_EOF(ACE_YY_START);
 					goto do_action;
 					}
 
 				else
 					{
 					if ( ! ace_yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
+						ACE_YY_NEW_FILE;
 					}
 				break;
 				}
@@ -901,7 +929,7 @@ ACE_SVC_CONF_ECHO;
 				ace_yy_current_state = ace_yy_get_previous_state();
 
 				ace_yy_cp = ace_yy_c_buf_p;
-				ace_yy_bp = ace_yytext_ptr + YY_MORE_ADJ;
+				ace_yy_bp = ace_yytext_ptr + ACE_YY_MORE_ADJ;
 				goto ace_yy_match;
 
 			case EOB_ACT_LAST_MATCH:
@@ -911,14 +939,14 @@ ACE_SVC_CONF_ECHO;
 				ace_yy_current_state = ace_yy_get_previous_state();
 
 				ace_yy_cp = ace_yy_c_buf_p;
-				ace_yy_bp = ace_yytext_ptr + YY_MORE_ADJ;
+				ace_yy_bp = ace_yytext_ptr + ACE_YY_MORE_ADJ;
 				goto ace_yy_find_action;
 			}
 		break;
 		}
 
 	default:
-		YY_FATAL_ERROR(
+		ACE_YY_FATAL_ERROR(
 			"fatal flex scanner internal error--no action found" );
 	} /* end of action switch */
 		} /* end of scanning one token */
@@ -941,12 +969,12 @@ static int ace_yy_get_next_buffer()
 	int ret_val;
 
 	if ( ace_yy_c_buf_p > &ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars + 1] )
-		YY_FATAL_ERROR(
+		ACE_YY_FATAL_ERROR(
 		"fatal flex scanner internal error--end of buffer missed" );
 
 	if ( ace_yy_current_buffer->ace_yy_fill_buffer == 0 )
 		{ /* 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 )
+		if ( ace_yy_c_buf_p - ace_yytext_ptr - ACE_YY_MORE_ADJ == 1 )
 			{
 			/* We matched a singled characater, the EOB, so
 			 * treat this as a final EOF.
@@ -971,7 +999,7 @@ static int ace_yy_get_next_buffer()
 	for ( i = 0; i < number_to_move; ++i )
 		*(dest++) = *(source++);
 
-	if ( ace_yy_current_buffer->ace_yy_buffer_status == YY_BUFFER_EOF_PENDING )
+	if ( ace_yy_current_buffer->ace_yy_buffer_status == ACE_YY_BUFFER_EOF_PENDING )
 		/* don't do the read, it's not guaranteed to return an EOF,
 		 * just force an EOF
 		 */
@@ -984,13 +1012,13 @@ static int ace_yy_get_next_buffer()
 
 		while ( num_to_read <= 0 )
 			{ /* Not enough room in the buffer - grow it. */
-#ifdef YY_USES_REJECT
-			YY_FATAL_ERROR(
+#ifdef ACE_YY_USES_REJECT
+			ACE_YY_FATAL_ERROR(
 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
 #else
 
 			/* just a shorter name for the current buffer */
-			YY_BUFFER_STATE b = ace_yy_current_buffer;
+			ACE_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;
 
@@ -1000,7 +1028,7 @@ static int ace_yy_get_next_buffer()
 						 b->ace_yy_buf_size );
 
 			if ( ! b->ace_yy_ch_buf )
-				YY_FATAL_ERROR(
+				ACE_YY_FATAL_ERROR(
 				"fatal error - scanner input buffer overflow" );
 
 			ace_yy_c_buf_p = &b->ace_yy_ch_buf[ace_yy_c_buf_p_offset];
@@ -1010,17 +1038,17 @@ static int ace_yy_get_next_buffer()
 #endif
 			}
 
-		if ( num_to_read > YY_READ_BUF_SIZE )
-			num_to_read = YY_READ_BUF_SIZE;
+		if ( num_to_read > ACE_YY_READ_BUF_SIZE )
+			num_to_read = ACE_YY_READ_BUF_SIZE;
 
 		/* Read in more data. */
-		YY_INPUT( (&ace_yy_current_buffer->ace_yy_ch_buf[number_to_move]),
+		ACE_YY_INPUT( (&ace_yy_current_buffer->ace_yy_ch_buf[number_to_move]),
 			ace_yy_n_chars, num_to_read );
 		}
 
 	if ( ace_yy_n_chars == 0 )
 		{
-		if ( number_to_move - YY_MORE_ADJ == 1 )
+		if ( number_to_move - ACE_YY_MORE_ADJ == 1 )
 			{
 			ret_val = EOB_ACT_END_OF_FILE;
 			ace_yyrestart( ace_yyin );
@@ -1030,7 +1058,7 @@ static int ace_yy_get_next_buffer()
 			{
 			ret_val = EOB_ACT_LAST_MATCH;
 			ace_yy_current_buffer->ace_yy_buffer_status =
-				YY_BUFFER_EOF_PENDING;
+				ACE_YY_BUFFER_EOF_PENDING;
 			}
 		}
 
@@ -1038,8 +1066,8 @@ static int ace_yy_get_next_buffer()
 		ret_val = EOB_ACT_CONTINUE_SCAN;
 
 	ace_yy_n_chars += number_to_move;
-	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_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars] = ACE_YY_END_OF_BUFFER_CHAR;
+	ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars + 1] = ACE_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
@@ -1066,9 +1094,9 @@ static ace_yy_state_type ace_yy_get_previous_state()
 	if ( ace_yy_bp[-1] == '\n' )
 		++ace_yy_current_state;
 
-	for ( ace_yy_cp = ace_yytext_ptr + YY_MORE_ADJ; ace_yy_cp < ace_yy_c_buf_p; ++ace_yy_cp )
+	for ( ace_yy_cp = ace_yytext_ptr + ACE_YY_MORE_ADJ; ace_yy_cp < ace_yy_c_buf_p; ++ace_yy_cp )
 		{
-		register YY_CHAR ace_yy_c = (*ace_yy_cp ? ace_yy_ec[YY_SC_TO_UI(*ace_yy_cp)] : 1);
+		register ACE_YY_CHAR ace_yy_c = (*ace_yy_cp ? ace_yy_ec[ACE_YY_SC_TO_UI(*ace_yy_cp)] : 1);
 		if ( ace_yy_accept[ace_yy_current_state] )
 			{
 			ace_yy_last_accepting_state = ace_yy_current_state;
@@ -1077,7 +1105,7 @@ static ace_yy_state_type ace_yy_get_previous_state()
 		while ( ace_yy_chk[ace_yy_base[ace_yy_current_state] + ace_yy_c] != ace_yy_current_state )
 			{
 			ace_yy_current_state = (int) ace_yy_def[ace_yy_current_state];
-			if ( ace_yy_current_state >= 103 )
+			if ( ace_yy_current_state >= 104 )
 				ace_yy_c = ace_yy_meta[(unsigned int) ace_yy_c];
 			}
 		ace_yy_current_state = ace_yy_nxt[ace_yy_base[ace_yy_current_state] + (unsigned int) ace_yy_c];
@@ -1093,7 +1121,7 @@ static ace_yy_state_type ace_yy_get_previous_state()
  *	next_state = ace_yy_try_NUL_trans( current_state );
  */
 
-#ifdef YY_USE_PROTOS
+#ifdef ACE_YY_USE_PROTOS
 static ace_yy_state_type ace_yy_try_NUL_trans( ace_yy_state_type ace_yy_current_state )
 #else
 static ace_yy_state_type ace_yy_try_NUL_trans( ace_yy_current_state )
@@ -1103,7 +1131,7 @@ ace_yy_state_type ace_yy_current_state;
 	register int ace_yy_is_jam;
 	register char *ace_yy_cp = ace_yy_c_buf_p;
 
-	register YY_CHAR ace_yy_c = 1;
+	register ACE_YY_CHAR ace_yy_c = 1;
 	if ( ace_yy_accept[ace_yy_current_state] )
 		{
 		ace_yy_last_accepting_state = ace_yy_current_state;
@@ -1112,18 +1140,18 @@ ace_yy_state_type ace_yy_current_state;
 	while ( ace_yy_chk[ace_yy_base[ace_yy_current_state] + ace_yy_c] != ace_yy_current_state )
 		{
 		ace_yy_current_state = (int) ace_yy_def[ace_yy_current_state];
-		if ( ace_yy_current_state >= 103 )
+		if ( ace_yy_current_state >= 104 )
 			ace_yy_c = ace_yy_meta[(unsigned int) ace_yy_c];
 		}
 	ace_yy_current_state = ace_yy_nxt[ace_yy_base[ace_yy_current_state] + (unsigned int) ace_yy_c];
-	ace_yy_is_jam = (ace_yy_current_state == 102);
+	ace_yy_is_jam = (ace_yy_current_state == 103);
 
 	return ace_yy_is_jam ? 0 : ace_yy_current_state;
 	}
 
 
 #if 0
-#ifdef YY_USE_PROTOS
+#ifdef ACE_YY_USE_PROTOS
 static void ace_yyunput( int c, register char *ace_yy_bp )
 #else
 static void ace_yyunput( c, ace_yy_bp )
@@ -1153,7 +1181,7 @@ register char *ace_yy_bp;
 		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" );
+			ACE_YY_FATAL_ERROR( "flex scanner push-back overflow" );
 		}
 
 	if ( ace_yy_cp > ace_yy_bp && ace_yy_cp[-1] == '\n' )
@@ -1165,7 +1193,7 @@ register char *ace_yy_bp;
 	/* 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_YY_DO_BEFORE_ACTION; /* set up ace_yytext again */
 	}
 #endif /* 0 */
 
@@ -1179,7 +1207,7 @@ static int input()
 
 	*ace_yy_c_buf_p = ace_yy_hold_char;
 
-	if ( *ace_yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+	if ( *ace_yy_c_buf_p == ACE_YY_END_OF_BUFFER_CHAR )
 		{
 		/* ace_yy_c_buf_p now points to the character we want to return.
 		 * If this occurs *before* the EOB characters, then it's a
@@ -1201,11 +1229,11 @@ static int input()
 					if ( ace_yywrap() )
 						{
 						ace_yy_c_buf_p =
-						ace_yytext_ptr + YY_MORE_ADJ;
+						ace_yytext_ptr + ACE_YY_MORE_ADJ;
 						return EOF;
 						}
 
-					YY_NEW_FILE;
+					ACE_YY_NEW_FILE;
 #ifdef __cplusplus
 					return ace_yyinput();
 #else
@@ -1214,15 +1242,15 @@ 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 + ACE_YY_MORE_ADJ;
 					break;
 
 				case EOB_ACT_LAST_MATCH:
 #ifdef __cplusplus
-					YY_FATAL_ERROR(
+					ACE_YY_FATAL_ERROR(
 					"unexpected last match in ace_yyinput()" );
 #else
-					YY_FATAL_ERROR(
+					ACE_YY_FATAL_ERROR(
 					"unexpected last match in input()" );
 #endif
 				}
@@ -1237,7 +1265,7 @@ static int input()
 	}
 
 
-#ifdef YY_USE_PROTOS
+#ifdef ACE_YY_USE_PROTOS
 void ace_yyrestart( FILE *input_file )
 #else
 void ace_yyrestart( input_file )
@@ -1245,18 +1273,18 @@ FILE *input_file;
 #endif
 	{
 	if ( ! ace_yy_current_buffer )
-		ace_yy_current_buffer = ace_yy_create_buffer( ace_yyin, YY_BUF_SIZE );
+		ace_yy_current_buffer = ace_yy_create_buffer( ace_yyin, ACE_YY_BUF_SIZE );
 
 	ace_yy_init_buffer( ace_yy_current_buffer, input_file );
 	ace_yy_load_buffer_state();
 	}
 
 
-#ifdef YY_USE_PROTOS
-void ace_yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#ifdef ACE_YY_USE_PROTOS
+void ace_yy_switch_to_buffer( ACE_YY_BUFFER_STATE new_buffer )
 #else
 void ace_yy_switch_to_buffer( new_buffer )
-YY_BUFFER_STATE new_buffer;
+ACE_YY_BUFFER_STATE new_buffer;
 #endif
 	{
 	if ( ace_yy_current_buffer == new_buffer )
@@ -1282,7 +1310,7 @@ YY_BUFFER_STATE new_buffer;
 	}
 
 
-#ifdef YY_USE_PROTOS
+#ifdef ACE_YY_USE_PROTOS
 void ace_yy_load_buffer_state( void )
 #else
 void ace_yy_load_buffer_state()
@@ -1295,20 +1323,20 @@ void ace_yy_load_buffer_state()
 	}
 
 
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE ace_yy_create_buffer( FILE *file, int size )
+#ifdef ACE_YY_USE_PROTOS
+ACE_YY_BUFFER_STATE ace_yy_create_buffer( FILE *file, int size )
 #else
-YY_BUFFER_STATE ace_yy_create_buffer( file, size )
+ACE_YY_BUFFER_STATE ace_yy_create_buffer( file, size )
 FILE *file;
 int size;
 #endif
 	{
-	YY_BUFFER_STATE b;
+	ACE_YY_BUFFER_STATE b;
 
-	b = (YY_BUFFER_STATE) ace_yy_flex_alloc( sizeof( struct ace_yy_buffer_state ) );
+	b = (ACE_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()" );
+		ACE_YY_FATAL_ERROR( "out of dynamic memory in ace_yy_create_buffer()" );
 
 	b->ace_yy_buf_size = size;
 
@@ -1318,7 +1346,7 @@ int size;
 	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()" );
+		ACE_YY_FATAL_ERROR( "out of dynamic memory in ace_yy_create_buffer()" );
 
 	ace_yy_init_buffer( b, file );
 
@@ -1326,26 +1354,26 @@ int size;
 	}
 
 
-#ifdef YY_USE_PROTOS
-void ace_yy_delete_buffer( YY_BUFFER_STATE b )
+#ifdef ACE_YY_USE_PROTOS
+void ace_yy_delete_buffer( ACE_YY_BUFFER_STATE b )
 #else
 void ace_yy_delete_buffer( b )
-YY_BUFFER_STATE b;
+ACE_YY_BUFFER_STATE b;
 #endif
 	{
 	if ( b == ace_yy_current_buffer )
-		ace_yy_current_buffer = (YY_BUFFER_STATE) 0;
+		ace_yy_current_buffer = (ACE_YY_BUFFER_STATE) 0;
 
 	ace_yy_flex_free( (void *) b->ace_yy_ch_buf );
 	ace_yy_flex_free( (void *) b );
 	}
 
 
-#ifdef YY_USE_PROTOS
-void ace_yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#ifdef ACE_YY_USE_PROTOS
+void ace_yy_init_buffer( ACE_YY_BUFFER_STATE b, FILE *file )
 #else
 void ace_yy_init_buffer( b, file )
-YY_BUFFER_STATE b;
+ACE_YY_BUFFER_STATE b;
 FILE *file;
 #endif
 	{
@@ -1362,8 +1390,8 @@ FILE *file;
 	 * a transition to the end-of-buffer state.  The second causes
 	 * a jam in that state.
 	 */
-	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_ch_buf[1] = ACE_YY_END_OF_BUFFER_CHAR;
+	b->ace_yy_ch_buf[2] = ACE_YY_END_OF_BUFFER_CHAR;
 
 	b->ace_yy_buf_pos = &b->ace_yy_ch_buf[1];
 
@@ -1371,12 +1399,12 @@ FILE *file;
 
 	b->ace_yy_fill_buffer = 1;
 
-	b->ace_yy_buffer_status = YY_BUFFER_NEW;
+	b->ace_yy_buffer_status = ACE_YY_BUFFER_NEW;
 	}
 
 
 #if 0
-#ifdef YY_USE_PROTOS
+#ifdef ACE_YY_USE_PROTOS
 static void ace_yy_push_state( int new_state )
 #else
 static void ace_yy_push_state( new_state )
@@ -1387,7 +1415,7 @@ int new_state;
 		{
 		int new_size;
 
-		ace_yy_start_stack_depth += YY_START_STACK_INCR;
+		ace_yy_start_stack_depth += ACE_YY_START_STACK_INCR;
 		new_size = ace_yy_start_stack_depth * sizeof( int );
 
 		if ( ! ace_yy_start_stack )
@@ -1398,11 +1426,11 @@ int new_state;
 					(void *) ace_yy_start_stack, new_size );
 
 		if ( ! ace_yy_start_stack )
-			YY_FATAL_ERROR(
+			ACE_YY_FATAL_ERROR(
 			"out of memory expanding start-condition stack" );
 		}
 
-	ace_yy_start_stack[ace_yy_start_stack_ptr++] = YY_START;
+	ace_yy_start_stack[ace_yy_start_stack_ptr++] = ACE_YY_START;
 
 	BEGIN(new_state);
 	}
@@ -1411,7 +1439,7 @@ int new_state;
 static void ace_yy_pop_state()
 	{
 	if ( --ace_yy_start_stack_ptr < 0 )
-		YY_FATAL_ERROR( "start-condition stack underflow" );
+		ACE_YY_FATAL_ERROR( "start-condition stack underflow" );
 
 	BEGIN(ace_yy_start_stack[ace_yy_start_stack_ptr]);
 	}
@@ -1423,7 +1451,7 @@ static int ace_yy_top_state()
 	}
 #endif /* 0 */
 
-#ifdef YY_USE_PROTOS
+#ifdef ACE_YY_USE_PROTOS
 static void ace_yy_fatal_error( const char msg[] )
 #else
 static void ace_yy_fatal_error( msg )
@@ -1444,7 +1472,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_MORE_ADJ; \
 		ace_yy_hold_char = *ace_yy_c_buf_p; \
 		*ace_yy_c_buf_p = '\0'; \
 		ace_yyleng = n; \
@@ -1455,7 +1483,7 @@ char msg[];
 /* Internal utility routines. */
 
 #ifndef ace_yytext_ptr
-#ifdef YY_USE_PROTOS
+#ifdef ACE_YY_USE_PROTOS
 static void ace_yy_flex_strncpy( char *s1, const char *s2, int n )
 #else
 static void ace_yy_flex_strncpy( s1, s2, n )
@@ -1471,7 +1499,7 @@ int n;
 #endif
 
 
-#ifdef YY_USE_PROTOS
+#ifdef ACE_YY_USE_PROTOS
 static void *ace_yy_flex_alloc( unsigned int size )
 #else
 static void *ace_yy_flex_alloc( size )
@@ -1481,7 +1509,7 @@ unsigned int size;
 	return (void *) malloc( size );
 	}
 
-#ifdef YY_USE_PROTOS
+#ifdef ACE_YY_USE_PROTOS
 static void *ace_yy_flex_realloc( void *ptr, unsigned int size )
 #else
 static void *ace_yy_flex_realloc( ptr, size )
@@ -1492,7 +1520,7 @@ unsigned int size;
 	return (void *) realloc( ACE_MALLOC_T (ptr), size );
 	}
 
-#ifdef YY_USE_PROTOS
+#ifdef ACE_YY_USE_PROTOS
 static void ace_yy_flex_free( void *ptr )
 #else
 static void ace_yy_flex_free( ptr )
@@ -1511,1505 +1539,3 @@ ace_yywrap (void)
   ace_yyleng = 0;
   return 1;
 }
-/* A lexical scanner generated by flex */
-
-/* Scanner skeleton version:
- * $Header$
- */
-
-#define FLEX_SCANNER
-
-#include "ace/OS.h"
-
-
-/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
-#ifdef c_plusplus
-#ifndef __cplusplus
-#define __cplusplus
-#endif
-#endif
-
-
-#ifdef __cplusplus
-
-#include /**/ <stdlib.h>
-#include "ace/OS.h"
-
-/* Use prototypes in function declarations. */
-#define YY_USE_PROTOS
-
-/* The "const" storage-class-modifier is valid. */
-#define YY_USE_CONST
-
-#else	/* ! __cplusplus */
-
-#ifdef __STDC__
-
-#define YY_USE_PROTOS
-#define YY_USE_CONST
-
-#endif	/* __STDC__ */
-#endif	/* ! __cplusplus */
-
-
-#ifdef __TURBOC__
-#define YY_USE_CONST
-#endif
-
-
-#ifndef YY_USE_CONST
-#ifndef const
-#define const
-#endif
-#endif
-
-
-#ifdef YY_USE_PROTOS
-#define YY_PROTO(proto) proto
-#else
-#define YY_PROTO(proto) ()
-#endif
-
-/* Returned upon end-of-file. */
-#define YY_NULL 0
-
-/* Promotes a possibly negative, possibly signed char to an unsigned
- * integer for use as an array index.  If the signed char is negative,
- * we want to instead treat it as an 8-bit unsigned char, hence the
- * double cast.
- */
-#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
-
-/* Enter a start condition.  This macro really ought to take a parameter,
- * but we do it the disgusting crufty way forced on us by the ()-less
- * definition of BEGIN.
- */
-#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.
- */
-#define YY_START ((ace_yy_start - 1) / 2)
-
-/* 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.
- */
-#define YY_NEW_FILE ace_yyrestart( ace_yyin )
-
-#define YY_END_OF_BUFFER_CHAR 0
-
-/* Size of default input buffer. */
-#define YY_BUF_SIZE 16384
-
-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
-
-/* The funky do-while in the following #define is used to turn the definition
- * int a single C statement (which needs a semi-colon terminator).  This
- * avoids problems with code like:
- *
- * 	if ( condition_holds )
- *		ace_yyless( 5 );
- *	else
- *		do_something_else();
- *
- * Prior to using the do-while the compiler would get upset at the
- * "else" because it interpreted the "if" statement as being all
- * done when it reached the ';' after the ace_yyless() call.
- */
-
-/* Return all but the first 'n' matched characters back to the input stream. */
-
-#define ace_yyless(n) \
-	do \
-		{ \
-		/* Undo effects of setting up ace_yytext. */ \
-		*ace_yy_cp = ace_yy_hold_char; \
-		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 )
-
-#define unput(c) ace_yyunput( c, ace_yytext_ptr )
-
-
-struct ace_yy_buffer_state
-	{
-	FILE *ace_yy_input_file;
-
-	char *ace_yy_ch_buf;		/* input buffer */
-	char *ace_yy_buf_pos;		/* current position in input buffer */
-
-	/* Size of input buffer in bytes, not including room for EOB
-	 * characters.
-	 */
-	int ace_yy_buf_size;
-
-	/* Number of characters read into ace_yy_ch_buf, not including EOB
-	 * characters.
-	 */
-	int ace_yy_n_chars;
-
-	/* 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
-	 * each newline.
-	 */
-	int ace_yy_is_interactive;
-
-	/* Whether to try to fill the input buffer when we reach the
-	 * end of it.
-	 */
-	int ace_yy_fill_buffer;
-
-	int ace_yy_buffer_status;
-#define YY_BUFFER_NEW 0
-#define YY_BUFFER_NORMAL 1
-	/* When an EOF's been seen but there's still some text to process
-	 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
-	 * shouldn't try reading from the input source any more.  We might
-	 * still have a bunch of tokens to match, though, because of
-	 * possible backing-up.
-	 *
-	 * When we actually see the EOF, we change the status to "new"
-	 * (via ace_yyrestart()), so that the user can continue scanning by
-	 * just pointing ace_yyin at a new input file.
-	 */
-#define YY_BUFFER_EOF_PENDING 2
-	};
-
-static YY_BUFFER_STATE ace_yy_current_buffer = 0;
-
-/* We provide macros for accessing buffer states in case in the
- * future we want to put the buffer states in a more general
- * "scanner state".
- */
-#define YY_CURRENT_BUFFER ace_yy_current_buffer
-
-
-/* ace_yy_hold_char holds the character lost when ace_yytext is formed. */
-static char ace_yy_hold_char;
-
-static int ace_yy_n_chars;		/* number of characters read into ace_yy_ch_buf */
-
-
-int ace_yyleng;
-
-/* Points to current character in buffer. */
-static char *ace_yy_c_buf_p = (char *) 0;
-static int ace_yy_init = 1;		/* whether we need to initialize */
-static int ace_yy_start = 0;	/* start state number */
-
-/* Flag which is used to allow ace_yywrap()'s to do buffer switches
- * instead of setting up a fresh ace_yyin.  A bit of a hack ...
- */
-static int ace_yy_did_buffer_switch_on_eof;
-
-static void ace_yyunput YY_PROTO(( int c, char *buf_ptr ));
-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 ));
-
-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 ));
-
-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_free YY_PROTO(( void * ));
-
-#define ace_yy_new_buffer ace_yy_create_buffer
-
-#define INITIAL 0
-#define PARAMETERS 1
-#define NORMAL 2
-typedef unsigned char YY_CHAR;
-typedef int ace_yy_state_type;
-FILE *ace_yyin = (FILE *) 0, *ace_yyout = (FILE *) 0;
-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[] ));
-
-/* 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_yy_hold_char = *ace_yy_cp; \
-	*ace_yy_cp = '\0'; \
-	ace_yy_c_buf_p = ace_yy_cp;
-
-#define YY_END_OF_BUFFER 26
-static const 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,
-       20,   20,   20,   20,   20,   17,   18,   24,   22,    0,
-       19,   21,   20,    0,   20,   20,   20,   20,   20,   20,
-       20,   20,   20,    0,    1,   20,   20,   20,   20,   20,
-       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
-       20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
-       20,   20,   20,   20,   20,   20,   20,   20,    8,   10,
-       20,   11,   20,   20,    6,    5,    3,    7,   20,   20,
-        2,   20,    4,   20,   12,   20,   20,   20,   20,   20,
-
-        9,    0
-    } ;
-
-static const 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,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    4,    5,    6,    7,    5,    5,    5,    5,    8,
-        9,   10,    5,    5,   11,   11,   11,   12,   12,   12,
-       12,   12,   12,   12,   12,   12,   12,   13,    5,    5,
-        5,    5,    5,    5,   14,   15,   15,   15,   16,   15,
-       15,   15,   15,   15,   15,   15,   17,   15,   18,   15,
-       15,   19,   20,   21,   15,   15,   15,   15,   15,   15,
-        5,   11,    5,    5,   22,    5,   23,   24,   25,   26,
-
-       27,   15,   15,   15,   28,   29,   15,   30,   31,   32,
-       33,   34,   15,   35,   36,   37,   38,   39,   15,   15,
-       40,   15,   41,    5,   42,    5,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1
-    } ;
-
-static const 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,
-        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
-        3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
-        2,    2
-    } ;
-
-static const 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,
-       41,   44,   48,   49,   52,  313,  313,   82,   66,   76,
-       72,    0,   60,    0,   61,   64,   68,   75,   81,   82,
-       85,   88,   89,   64,  313,   93,  104,   96,  111,  115,
-      116,   97,  121,  129,  133,  134,  137,  138,  142,  143,
-      150,  151,  158,  161,  162,  166,  167,  172,  185,  180,
-      173,  190,  193,  196,  197,  200,  201,  204,  209,  215,
-      216,  220,  224,  227,  228,  231,  234,  235,  239,  240,
-      243,  244,  247,  250,  256,  259,  262,  263,  267,  266,
-
-      271,  313,  302,   53,  304,  308
-    } ;
-
-static const 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,
-      105,  105,  105,  105,  105,  102,  102,  106,  102,  103,
-      103,  104,  105,  104,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  106,  102,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-      105,  105,  105,  105,  105,  105,  105,  105,  105,  105,
-
-      105,    0,  102,  102,  102,  102
-    } ;
-
-static const 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,
-       17,   20,   21,   17,   17,   22,   17,   23,   17,   17,
-       17,   17,   17,   17,   24,   25,   17,   17,   17,   17,
-       26,   27,   29,   32,   29,   34,   32,   32,   34,   34,
-       32,   32,  102,   34,   32,   32,   34,   36,   32,   32,
-       34,   34,   32,   37,   34,   38,   45,   29,   35,   29,
-       32,   32,  102,  102,   32,   41,  102,   31,   32,   40,
-      102,   31,   47,   39,   45,   32,   46,  102,   42,   43,
-       31,   32,   32,  102,  102,   32,  102,  102,   32,   32,
-
-      102,  102,   48,   32,   51,  102,   32,   32,  102,  102,
-       54,   49,   50,   28,   32,   52,  102,   28,   28,   58,
-       53,   32,   55,  102,   56,   32,   32,  102,  102,   63,
-       57,   32,  102,  102,   59,  102,  102,   61,   60,   32,
-       62,  102,  102,   32,   32,  102,  102,   32,   32,  102,
-      102,   69,   32,   32,  102,  102,  102,  102,   64,   66,
-       32,   32,  102,  102,  102,   65,   68,   67,   32,   70,
-      102,   32,   32,  102,  102,  102,   32,   32,  102,  102,
-       72,   71,   32,   32,  102,  102,  102,   73,   77,   76,
-       32,   75,  102,   78,  102,   32,   74,  102,   79,   82,
-
-       32,   80,  102,   32,   81,  102,   32,   32,  102,  102,
-       32,   32,  102,  102,   32,  102,  102,   83,  102,   32,
-       84,  102,   85,   86,   87,   32,   32,  102,  102,  102,
-       32,   88,  102,  102,   32,   89,  102,   32,   32,  102,
-      102,   32,   90,  102,   32,   32,  102,  102,   91,   32,
-       32,  102,  102,   32,   32,  102,  102,   32,  102,  102,
-       32,   94,  102,  102,   93,   92,   32,   96,  102,   32,
-       95,  102,   32,   32,  102,  102,   32,   32,  102,  102,
-      102,   32,   97,  102,  102,  102,  102,  102,  102,   99,
-       98,  100,  102,  102,  102,  102,  102,  102,  102,  102,
-
-      102,  102,  101,   30,   30,   30,   33,   33,   44,   44,
-       44,   44,    7,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102
-    } ;
-
-static const 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,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        1,    1,    9,   17,    9,   17,   18,   19,   18,   19,
-       20,   21,   20,   21,   22,  104,   22,   19,   23,   24,
-       23,   24,   25,   19,   25,   21,   44,   29,   18,   29,
-       33,   35,   33,   35,   36,   24,   36,   31,   37,   23,
-       37,   30,   36,   22,   28,   38,   35,   38,   25,   25,
-       11,   39,   40,   39,   40,   41,    7,   41,   42,   43,
-
-       42,   43,   37,   46,   40,   46,   48,   52,   48,   52,
-       42,   38,   39,    6,   47,   41,   47,    4,    2,   47,
-       41,   49,   42,   49,   43,   50,   51,   50,   51,   52,
-       46,   53,    0,   53,   48,    0,    0,   50,   49,   54,
-       51,   54,    0,   55,   56,   55,   56,   57,   58,   57,
-       58,   58,   59,   60,   59,   60,    0,    0,   53,   55,
-       61,   62,   61,   62,    0,   54,   57,   56,   63,   59,
-       63,   64,   65,   64,   65,    0,   66,   67,   66,   67,
-       61,   60,   68,   71,   68,   71,    0,   62,   66,   65,
-       70,   64,   70,   67,    0,   69,   63,   69,   68,   71,
-
-       72,   69,   72,   73,   70,   73,   74,   75,   74,   75,
-       76,   77,   76,   77,   78,    0,   78,   72,    0,   79,
-       73,   79,   74,   75,   76,   80,   81,   80,   81,    0,
-       82,   77,   82,    0,   83,   78,   83,   84,   85,   84,
-       85,   86,   81,   86,   87,   88,   87,   88,   83,   89,
-       90,   89,   90,   91,   92,   91,   92,   93,    0,   93,
-       94,   90,   94,    0,   89,   84,   95,   94,   95,   96,
-       92,   96,   97,   98,   97,   98,  100,   99,  100,   99,
-        0,  101,   96,  101,    0,    0,    0,    0,    0,   98,
-       97,   99,    0,    0,    0,    0,    0,    0,    0,    0,
-
-        0,    0,  100,  103,  103,  103,  105,  105,  106,  106,
-      106,  106,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102,  102,  102,  102,  102,  102,
-      102,  102,  102,  102,  102
-    } ;
-
-static ace_yy_state_type ace_yy_last_accepting_state;
-static char *ace_yy_last_accepting_cpos;
-
-/* The intent behind this definition is that it'll catch
- * any uses of REJECT which flex missed.
- */
-#define REJECT reject_used_but_not_detected
-#define ace_yymore() ace_yymore_used_but_not_detected
-#define YY_MORE_ADJ 0
-char *ace_yytext;
-# line 1 "Svc_Conf.l"
-# line 2 "Svc_Conf.l"
-// Sample lexical analysis for regular expression subset.  Must be
-// compiled with FLEX and an ANSI C++ compiler.
-
-// Lexical tokens values defined by YACC.
-#include "ace/Svc_Conf.h"
-#include "ace/Svc_Conf_Tokens.h"
-
-// 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
-
-/* Macros after this point can all be overridden by user definitions in
- * section 1.
- */
-
-#ifdef YY_MALLOC_DECL
-YY_MALLOC_DECL
-#else
-#if __STDC__
-#ifndef __cplusplus
-#include /**/ <stdlib.h>
-#endif
-#else
-/* Just try to get by without declaring the routines.  This will fail
- * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
- * or sizeof(void*) != sizeof(int).
- */
-#endif
-#endif
-
-/* Amount of stuff to slurp up with each read. */
-#ifndef YY_READ_BUF_SIZE
-#define YY_READ_BUF_SIZE 8192
-#endif
-
-/* Copy whatever the last rule matched to the standard output. */
-
-#ifndef ACE_SVC_CONF_ECHO
-/* This used to be an fputs(), but since the string might contain NUL's,
- * we now use fwrite().
- */
-#define ACE_SVC_CONF_ECHO (void) fwrite( ace_yytext, ace_yyleng, 1, ace_yyout )
-#endif
-
-/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
- * is returned in "result".
- */
-#ifndef YY_INPUT
-#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; \
-		} \
-	else if ( ((result = fread( buf, 1, max_size, ace_yyin )) == 0) \
-		  && ferror( ace_yyin ) ) \
-		YY_FATAL_ERROR( "input in flex scanner failed" );
-#endif
-
-/* No semi-colon after return; correct usage is to write "ace_yyterminate();" -
- * we don't want an extra ';' after the "return" because that will cause
- * some compilers to complain about unreachable statements.
- */
-#ifndef ace_yyterminate
-#define ace_yyterminate() return YY_NULL
-#endif
-
-/* Number of entries by which start-condition stack grows. */
-#ifndef YY_START_STACK_INCR
-#define YY_START_STACK_INCR 25
-#endif
-
-/* Report a fatal error. */
-#ifndef YY_FATAL_ERROR
-#define YY_FATAL_ERROR(msg) ace_yy_fatal_error( msg )
-#endif
-
-/* Default declaration of generated scanner - a define so the user can
- * easily add parameters.
- */
-#ifndef YY_DECL
-#define YY_DECL int ace_yylex YY_PROTO(( void ))
-#endif
-
-/* Code executed at the beginning of each rule, after ace_yytext and ace_yyleng
- * have been set up.
- */
-#ifndef YY_USER_ACTION
-#define YY_USER_ACTION
-#endif
-
-/* Code executed at the end of each rule. */
-#ifndef YY_BREAK
-#define YY_BREAK break;
-#endif
-
-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"
-
-
-
-	if ( ace_yy_init )
-		{
-#ifdef YY_USER_INIT
-		YY_USER_INIT;
-#endif
-
-		if ( ! ace_yy_start )
-			ace_yy_start = 1;	/* first start state */
-
-		if ( ! ace_yyin )
-			ace_yyin = stdin;
-
-		if ( ! ace_yyout )
-			ace_yyout = stdout;
-
-		if ( ace_yy_current_buffer )
-			ace_yy_init_buffer( ace_yy_current_buffer, ace_yyin );
-		else
-			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 */
-		{
-		ace_yy_cp = ace_yy_c_buf_p;
-
-		/* Support of ace_yytext. */
-		*ace_yy_cp = ace_yy_hold_char;
-
-		/* ace_yy_bp points to the position in ace_yy_ch_buf of the start of
-		 * the current run.
-		 */
-		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_match:
-		do
-			{
-			register YY_CHAR ace_yy_c = ace_yy_ec[YY_SC_TO_UI(*ace_yy_cp)];
-			if ( ace_yy_accept[ace_yy_current_state] )
-				{
-				ace_yy_last_accepting_state = ace_yy_current_state;
-				ace_yy_last_accepting_cpos = ace_yy_cp;
-				}
-			while ( ace_yy_chk[ace_yy_base[ace_yy_current_state] + ace_yy_c] != ace_yy_current_state )
-				{
-				ace_yy_current_state = (int) ace_yy_def[ace_yy_current_state];
-				if ( ace_yy_current_state >= 103 )
-					ace_yy_c = ace_yy_meta[(unsigned int) ace_yy_c];
-				}
-			ace_yy_current_state = ace_yy_nxt[ace_yy_base[ace_yy_current_state] + (unsigned int) ace_yy_c];
-			++ace_yy_cp;
-			}
-		while ( ace_yy_base[ace_yy_current_state] != 313 );
-
-ace_yy_find_action:
-		ace_yy_act = ace_yy_accept[ace_yy_current_state];
-
-		YY_DO_BEFORE_ACTION;
-
-
-do_action:	/* This label is used only to access EOF actions. */
-
-
-		switch ( ace_yy_act )
-	{ /* beginning of action switch */
-			case 0: /* must back up */
-			/* undo the effects of YY_DO_BEFORE_ACTION */
-			*ace_yy_cp = ace_yy_hold_char;
-			ace_yy_cp = ace_yy_last_accepting_cpos;
-			ace_yy_current_state = ace_yy_last_accepting_state;
-			goto ace_yy_find_action;
-
-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"
-; /* EMPTY */
-	YY_BREAK
-case 2:
-YY_USER_ACTION
-# line 35 "Svc_Conf.l"
-{ return token (ACE_DYNAMIC); }
-	YY_BREAK
-case 3:
-YY_USER_ACTION
-# line 36 "Svc_Conf.l"
-{ return token (ACE_STATIC); }
-	YY_BREAK
-case 4:
-YY_USER_ACTION
-# line 37 "Svc_Conf.l"
-{ return token (ACE_SUSPEND); }
-	YY_BREAK
-case 5:
-YY_USER_ACTION
-# line 38 "Svc_Conf.l"
-{ return token (ACE_RESUME); }
-	YY_BREAK
-case 6:
-YY_USER_ACTION
-# line 39 "Svc_Conf.l"
-{ return token (ACE_REMOVE); }
-	YY_BREAK
-case 7:
-YY_USER_ACTION
-# line 40 "Svc_Conf.l"
-{ return token (ACE_USTREAM); }
-	YY_BREAK
-case 8:
-YY_USER_ACTION
-# line 41 "Svc_Conf.l"
-{ return token (ACE_MODULE_T); }
-	YY_BREAK
-case 9:
-YY_USER_ACTION
-# line 42 "Svc_Conf.l"
-{ return token (ACE_SVC_OBJ_T); }
-	YY_BREAK
-case 10:
-YY_USER_ACTION
-# line 43 "Svc_Conf.l"
-{ return token (ACE_STREAM_T); }
-	YY_BREAK
-case 11:
-YY_USER_ACTION
-# line 44 "Svc_Conf.l"
-{ return token (ACE_ACTIVE); }
-	YY_BREAK
-case 12:
-YY_USER_ACTION
-# line 45 "Svc_Conf.l"
-{ return token (ACE_INACTIVE); }
-	YY_BREAK
-case 13:
-YY_USER_ACTION
-# line 46 "Svc_Conf.l"
-{ return token (ACE_COLON); }
-	YY_BREAK
-case 14:
-YY_USER_ACTION
-# line 47 "Svc_Conf.l"
-{ return token (ACE_STAR); }
-	YY_BREAK
-case 15:
-YY_USER_ACTION
-# line 48 "Svc_Conf.l"
-{ return token (ACE_LPAREN); }
-	YY_BREAK
-case 16:
-YY_USER_ACTION
-# line 49 "Svc_Conf.l"
-{ return token (ACE_RPAREN); }
-	YY_BREAK
-case 17:
-YY_USER_ACTION
-# line 50 "Svc_Conf.l"
-{ return token (ACE_LBRACE); }
-	YY_BREAK
-case 18:
-YY_USER_ACTION
-# line 51 "Svc_Conf.l"
-{ return token (ACE_RBRACE); }
-	YY_BREAK
-case 19:
-YY_USER_ACTION
-# 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); 
-			return token (ACE_STRING); }
-	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_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_BREAK
-case 22:
-YY_USER_ACTION
-# line 65 "Svc_Conf.l"
-; /* EMPTY */
-	YY_BREAK
-case 23:
-YY_USER_ACTION
-# line 66 "Svc_Conf.l"
-{ ace_yylineno++; }
-	YY_BREAK
-case 24:
-YY_USER_ACTION
-# 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"
-{ YY_NEW_FILE; ace_yyterminate(); }
-	YY_BREAK
-case 25:
-YY_USER_ACTION
-# 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;
-
-		/* Undo the effects of YY_DO_BEFORE_ACTION. */
-		*ace_yy_cp = ace_yy_hold_char;
-
-		if ( ace_yy_current_buffer->ace_yy_buffer_status == YY_BUFFER_NEW )
-			{
-			/* We're scanning a new file or input source.  It's
-			 * possible that this happened because the user
-			 * just pointed ace_yyin at a new source and called
-			 * ace_yylex().  If so, then we have to assure
-			 * consistency between ace_yy_current_buffer and our
-			 * globals.  Here is the right place to do so, because
-			 * this is the first action (other than possibly a
-			 * back-up) that will match for the new input source.
-			 */
-			ace_yy_n_chars = ace_yy_current_buffer->ace_yy_n_chars;
-			ace_yy_current_buffer->ace_yy_input_file = ace_yyin;
-			ace_yy_current_buffer->ace_yy_buffer_status = YY_BUFFER_NORMAL;
-			}
-
-		/* Note that here we test for ace_yy_c_buf_p "<=" to the position
-		 * of the first EOB in the buffer, since ace_yy_c_buf_p will
-		 * already have been incremented past the NUL character
-		 * (since all states make transitions on EOB to the
-		 * end-of-buffer state).  Contrast this with the test
-		 * in input().
-		 */
-		if ( ace_yy_c_buf_p <= &ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars] )
-			{ /* This was really a NUL. */
-			ace_yy_state_type ace_yy_next_state;
-
-			ace_yy_c_buf_p = ace_yytext_ptr + ace_yy_amount_of_matched_text;
-
-			ace_yy_current_state = ace_yy_get_previous_state();
-
-			/* Okay, we're now positioned to make the NUL
-			 * transition.  We couldn't have
-			 * ace_yy_get_previous_state() go ahead and do it
-			 * for us because it doesn't know how to deal
-			 * with the possibility of jamming (and we don't
-			 * want to build jamming into it because then it
-			 * will run more slowly).
-			 */
-
-			ace_yy_next_state = ace_yy_try_NUL_trans( ace_yy_current_state );
-
-			ace_yy_bp = ace_yytext_ptr + YY_MORE_ADJ;
-
-			if ( ace_yy_next_state )
-				{
-				/* Consume the NUL. */
-				ace_yy_cp = ++ace_yy_c_buf_p;
-				ace_yy_current_state = ace_yy_next_state;
-				goto ace_yy_match;
-				}
-
-			else
-				{
-							ace_yy_cp = ace_yy_c_buf_p;
-				goto ace_yy_find_action;
-				}
-			}
-
-		else switch ( ace_yy_get_next_buffer() )
-			{
-			case EOB_ACT_END_OF_FILE:
-				{
-				ace_yy_did_buffer_switch_on_eof = 0;
-
-				if ( ace_yywrap() )
-					{
-					/* Note: because we've taken care in
-					 * ace_yy_get_next_buffer() to have set up
-					 * ace_yytext, we can now set up
-					 * ace_yy_c_buf_p so that if some total
-					 * hoser (like flex itself) wants to
-					 * call the scanner after we return the
-					 * YY_NULL, it'll still work - another
-					 * YY_NULL will get returned.
-					 */
-					ace_yy_c_buf_p = ace_yytext_ptr + YY_MORE_ADJ;
-
-					ace_yy_act = YY_STATE_EOF(YY_START);
-					goto do_action;
-					}
-
-				else
-					{
-					if ( ! ace_yy_did_buffer_switch_on_eof )
-						YY_NEW_FILE;
-					}
-				break;
-				}
-
-			case EOB_ACT_CONTINUE_SCAN:
-				ace_yy_c_buf_p =
-					ace_yytext_ptr + ace_yy_amount_of_matched_text;
-
-				ace_yy_current_state = ace_yy_get_previous_state();
-
-				ace_yy_cp = ace_yy_c_buf_p;
-				ace_yy_bp = ace_yytext_ptr + YY_MORE_ADJ;
-				goto ace_yy_match;
-
-			case EOB_ACT_LAST_MATCH:
-				ace_yy_c_buf_p =
-				&ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars];
-
-				ace_yy_current_state = ace_yy_get_previous_state();
-
-				ace_yy_cp = ace_yy_c_buf_p;
-				ace_yy_bp = ace_yytext_ptr + YY_MORE_ADJ;
-				goto ace_yy_find_action;
-			}
-		break;
-		}
-
-	default:
-		YY_FATAL_ERROR(
-			"fatal flex scanner internal error--no action found" );
-	} /* end of action switch */
-		} /* end of scanning one token */
-	} /* end of ace_yylex */
-
-
-/* ace_yy_get_next_buffer - try to read in a new buffer
- *
- * Returns a code representing an action:
- *	EOB_ACT_LAST_MATCH -
- *	EOB_ACT_CONTINUE_SCAN - continue scanning from current position
- *	EOB_ACT_END_OF_FILE - end of file
- */
-
-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 int number_to_move, i;
-	int ret_val;
-
-	if ( ace_yy_c_buf_p > &ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars + 1] )
-		YY_FATAL_ERROR(
-		"fatal flex scanner internal error--end of buffer missed" );
-
-	if ( ace_yy_current_buffer->ace_yy_fill_buffer == 0 )
-		{ /* 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
-			 * treat this as a final EOF.
-			 */
-			return EOB_ACT_END_OF_FILE;
-			}
-
-		else
-			{
-			/* We matched some text prior to the EOB, first
-			 * process it.
-			 */
-			return EOB_ACT_LAST_MATCH;
-			}
-		}
-
-	/* Try to read more data. */
-
-	/* First move last chars to start of buffer. */
-	number_to_move = ace_yy_c_buf_p - ace_yytext_ptr;
-
-	for ( i = 0; i < number_to_move; ++i )
-		*(dest++) = *(source++);
-
-	if ( ace_yy_current_buffer->ace_yy_buffer_status == YY_BUFFER_EOF_PENDING )
-		/* don't do the read, it's not guaranteed to return an EOF,
-		 * just force an EOF
-		 */
-		ace_yy_n_chars = 0;
-
-	else
-		{
-		int num_to_read =
-			ace_yy_current_buffer->ace_yy_buf_size - number_to_move - 1;
-
-		while ( num_to_read <= 0 )
-			{ /* Not enough room in the buffer - grow it. */
-#ifdef YY_USES_REJECT
-			YY_FATAL_ERROR(
-"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
-#else
-
-			/* 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;
-
-			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 );
-
-			if ( ! b->ace_yy_ch_buf )
-				YY_FATAL_ERROR(
-				"fatal error - scanner input buffer overflow" );
-
-			ace_yy_c_buf_p = &b->ace_yy_ch_buf[ace_yy_c_buf_p_offset];
-
-			num_to_read = ace_yy_current_buffer->ace_yy_buf_size -
-						number_to_move - 1;
-#endif
-			}
-
-		if ( num_to_read > YY_READ_BUF_SIZE )
-			num_to_read = YY_READ_BUF_SIZE;
-
-		/* Read in more data. */
-		YY_INPUT( (&ace_yy_current_buffer->ace_yy_ch_buf[number_to_move]),
-			ace_yy_n_chars, num_to_read );
-		}
-
-	if ( ace_yy_n_chars == 0 )
-		{
-		if ( number_to_move - YY_MORE_ADJ == 1 )
-			{
-			ret_val = EOB_ACT_END_OF_FILE;
-			ace_yyrestart( ace_yyin );
-			}
-
-		else
-			{
-			ret_val = EOB_ACT_LAST_MATCH;
-			ace_yy_current_buffer->ace_yy_buffer_status =
-				YY_BUFFER_EOF_PENDING;
-			}
-		}
-
-	else
-		ret_val = EOB_ACT_CONTINUE_SCAN;
-
-	ace_yy_n_chars += number_to_move;
-	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];
-
-	return ret_val;
-	}
-
-
-/* ace_yy_get_previous_state - get the state just before the EOB char was reached */
-
-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;
-
-	for ( ace_yy_cp = ace_yytext_ptr + YY_MORE_ADJ; ace_yy_cp < ace_yy_c_buf_p; ++ace_yy_cp )
-		{
-		register YY_CHAR ace_yy_c = (*ace_yy_cp ? ace_yy_ec[YY_SC_TO_UI(*ace_yy_cp)] : 1);
-		if ( ace_yy_accept[ace_yy_current_state] )
-			{
-			ace_yy_last_accepting_state = ace_yy_current_state;
-			ace_yy_last_accepting_cpos = ace_yy_cp;
-			}
-		while ( ace_yy_chk[ace_yy_base[ace_yy_current_state] + ace_yy_c] != ace_yy_current_state )
-			{
-			ace_yy_current_state = (int) ace_yy_def[ace_yy_current_state];
-			if ( ace_yy_current_state >= 103 )
-				ace_yy_c = ace_yy_meta[(unsigned int) ace_yy_c];
-			}
-		ace_yy_current_state = ace_yy_nxt[ace_yy_base[ace_yy_current_state] + (unsigned int) ace_yy_c];
-		}
-
-	return ace_yy_current_state;
-	}
-
-
-/* ace_yy_try_NUL_trans - try to make a transition on the NUL character
- *
- * synopsis
- *	next_state = ace_yy_try_NUL_trans( current_state );
- */
-
-#ifdef YY_USE_PROTOS
-static ace_yy_state_type ace_yy_try_NUL_trans( ace_yy_state_type ace_yy_current_state )
-#else
-static ace_yy_state_type ace_yy_try_NUL_trans( ace_yy_current_state )
-ace_yy_state_type ace_yy_current_state;
-#endif
-	{
-	register int ace_yy_is_jam;
-	register char *ace_yy_cp = ace_yy_c_buf_p;
-
-	register YY_CHAR ace_yy_c = 1;
-	if ( ace_yy_accept[ace_yy_current_state] )
-		{
-		ace_yy_last_accepting_state = ace_yy_current_state;
-		ace_yy_last_accepting_cpos = ace_yy_cp;
-		}
-	while ( ace_yy_chk[ace_yy_base[ace_yy_current_state] + ace_yy_c] != ace_yy_current_state )
-		{
-		ace_yy_current_state = (int) ace_yy_def[ace_yy_current_state];
-		if ( ace_yy_current_state >= 103 )
-			ace_yy_c = ace_yy_meta[(unsigned int) ace_yy_c];
-		}
-	ace_yy_current_state = ace_yy_nxt[ace_yy_base[ace_yy_current_state] + (unsigned int) ace_yy_c];
-	ace_yy_is_jam = (ace_yy_current_state == 102);
-
-	return ace_yy_is_jam ? 0 : ace_yy_current_state;
-	}
-
-
-#ifdef YY_USE_PROTOS
-static void ace_yyunput( int c, register char *ace_yy_bp )
-#else
-static void ace_yyunput( c, ace_yy_bp )
-int c;
-register char *ace_yy_bp;
-#endif
-	{
-	register char *ace_yy_cp = ace_yy_c_buf_p;
-
-	/* undo effects of setting up ace_yytext */
-	*ace_yy_cp = ace_yy_hold_char;
-
-	if ( ace_yy_cp < ace_yy_current_buffer->ace_yy_ch_buf + 2 )
-		{ /* need to shift things up to make room */
-		/* +2 for EOB chars. */
-		register int number_to_move = ace_yy_n_chars + 2;
-		register char *dest = &ace_yy_current_buffer->ace_yy_ch_buf[
-					ace_yy_current_buffer->ace_yy_buf_size + 2];
-		register char *source =
-				&ace_yy_current_buffer->ace_yy_ch_buf[number_to_move];
-
-		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;
-
-		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 */
-	}
-
-
-#ifdef __cplusplus
-static int ace_yyinput()
-#else
-static int input()
-#endif
-	{
-	int c;
-
-	*ace_yy_c_buf_p = ace_yy_hold_char;
-
-	if ( *ace_yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
-		{
-		/* ace_yy_c_buf_p now points to the character we want to return.
-		 * If this occurs *before* the EOB characters, then it's a
-		 * valid NUL; if not, then we've hit the end of the buffer.
-		 */
-		if ( ace_yy_c_buf_p < &ace_yy_current_buffer->ace_yy_ch_buf[ace_yy_n_chars] )
-			/* This was really a NUL. */
-			*ace_yy_c_buf_p = '\0';
-
-		else
-			{ /* need more input */
-			ace_yytext_ptr = ace_yy_c_buf_p;
-			++ace_yy_c_buf_p;
-
-			switch ( ace_yy_get_next_buffer() )
-				{
-				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;
-#ifdef __cplusplus
-					return ace_yyinput();
-#else
-					return input();
-#endif
-					}
-
-				case EOB_ACT_CONTINUE_SCAN:
-					ace_yy_c_buf_p = ace_yytext_ptr + YY_MORE_ADJ;
-					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
-				}
-			}
-		}
-
-	c = *(unsigned char *) ace_yy_c_buf_p;	/* cast for 8-bit char's */
-	*ace_yy_c_buf_p = '\0';	/* preserve ace_yytext */
-	ace_yy_hold_char = *++ace_yy_c_buf_p;
-
-	return c;
-	}
-
-
-#ifdef YY_USE_PROTOS
-void ace_yyrestart( FILE *input_file )
-#else
-void ace_yyrestart( input_file )
-FILE *input_file;
-#endif
-	{
-	if ( ! ace_yy_current_buffer )
-		ace_yy_current_buffer = ace_yy_create_buffer( ace_yyin, YY_BUF_SIZE );
-
-	ace_yy_init_buffer( ace_yy_current_buffer, input_file );
-	ace_yy_load_buffer_state();
-	}
-
-
-#ifdef YY_USE_PROTOS
-void ace_yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
-#else
-void ace_yy_switch_to_buffer( new_buffer )
-YY_BUFFER_STATE new_buffer;
-#endif
-	{
-	if ( ace_yy_current_buffer == new_buffer )
-		return;
-
-	if ( ace_yy_current_buffer )
-		{
-		/* Flush out information for old buffer. */
-		*ace_yy_c_buf_p = ace_yy_hold_char;
-		ace_yy_current_buffer->ace_yy_buf_pos = ace_yy_c_buf_p;
-		ace_yy_current_buffer->ace_yy_n_chars = ace_yy_n_chars;
-		}
-
-	ace_yy_current_buffer = new_buffer;
-	ace_yy_load_buffer_state();
-
-	/* We don't actually know whether we did this switch during
-	 * EOF (ace_yywrap()) processing, but the only time this flag
-	 * is looked at is after ace_yywrap() is called, so it's safe
-	 * to go ahead and always set it.
-	 */
-	ace_yy_did_buffer_switch_on_eof = 1;
-	}
-
-
-#ifdef YY_USE_PROTOS
-void ace_yy_load_buffer_state( void )
-#else
-void ace_yy_load_buffer_state()
-#endif
-	{
-	ace_yy_n_chars = ace_yy_current_buffer->ace_yy_n_chars;
-	ace_yytext_ptr = ace_yy_c_buf_p = ace_yy_current_buffer->ace_yy_buf_pos;
-	ace_yyin = ace_yy_current_buffer->ace_yy_input_file;
-	ace_yy_hold_char = *ace_yy_c_buf_p;
-	}
-
-
-#ifdef YY_USE_PROTOS
-YY_BUFFER_STATE ace_yy_create_buffer( FILE *file, int size )
-#else
-YY_BUFFER_STATE ace_yy_create_buffer( file, size )
-FILE *file;
-int size;
-#endif
-	{
-	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()" );
-
-	b->ace_yy_buf_size = size;
-
-	/* ace_yy_ch_buf has to be 2 characters longer than the size given because
-	 * 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()" );
-
-	ace_yy_init_buffer( b, file );
-
-	return b;
-	}
-
-
-#ifdef YY_USE_PROTOS
-void ace_yy_delete_buffer( YY_BUFFER_STATE b )
-#else
-void ace_yy_delete_buffer( b )
-YY_BUFFER_STATE b;
-#endif
-	{
-	if ( b == ace_yy_current_buffer )
-		ace_yy_current_buffer = (YY_BUFFER_STATE) 0;
-
-	ace_yy_flex_free( (void *) b->ace_yy_ch_buf );
-	ace_yy_flex_free( (void *) b );
-	}
-
-
-#ifdef YY_USE_PROTOS
-void ace_yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
-#else
-void ace_yy_init_buffer( b, file )
-YY_BUFFER_STATE b;
-FILE *file;
-#endif
-	{
-	b->ace_yy_input_file = file;
-
-	/* 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;
-
-	/* 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[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_is_interactive = file ? isatty( fileno(file) ) : 0;
-
-	b->ace_yy_fill_buffer = 1;
-
-	b->ace_yy_buffer_status = YY_BUFFER_NEW;
-	}
-
-
-#ifdef YY_USE_PROTOS
-static void ace_yy_push_state( int new_state )
-#else
-static void ace_yy_push_state( new_state )
-int new_state;
-#endif
-	{
-	if ( ace_yy_start_stack_ptr >= ace_yy_start_stack_depth )
-		{
-		int new_size;
-
-		ace_yy_start_stack_depth += YY_START_STACK_INCR;
-		new_size = ace_yy_start_stack_depth * sizeof( int );
-
-		if ( ! ace_yy_start_stack )
-			ace_yy_start_stack = (int *) ace_yy_flex_alloc( new_size );
-
-		else
-			ace_yy_start_stack = (int *) ace_yy_flex_realloc(
-					(void *) ace_yy_start_stack, new_size );
-
-		if ( ! ace_yy_start_stack )
-			YY_FATAL_ERROR(
-			"out of memory expanding start-condition stack" );
-		}
-
-	ace_yy_start_stack[ace_yy_start_stack_ptr++] = YY_START;
-
-	BEGIN(new_state);
-	}
-
-
-static void ace_yy_pop_state()
-	{
-	if ( --ace_yy_start_stack_ptr < 0 )
-		YY_FATAL_ERROR( "start-condition stack underflow" );
-
-	BEGIN(ace_yy_start_stack[ace_yy_start_stack_ptr]);
-	}
-
-
-static int ace_yy_top_state()
-	{
-	return ace_yy_start_stack[ace_yy_start_stack_ptr - 1];
-	}
-
-
-#ifdef YY_USE_PROTOS
-static void ace_yy_fatal_error( const char msg[] )
-#else
-static void ace_yy_fatal_error( msg )
-char msg[];
-#endif
-	{
-	(void) fprintf( stderr, "%s\n", msg );
-	exit( 1 );
-	}
-
-
-
-/* Redefine ace_yyless() so it works in section 3 code. */
-
-#undef ace_yyless
-#define ace_yyless(n) \
-	do \
-		{ \
-		/* 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_hold_char = *ace_yy_c_buf_p; \
-		*ace_yy_c_buf_p = '\0'; \
-		ace_yyleng = n; \
-		} \
-	while ( 0 )
-
-
-/* Internal utility routines. */
-
-#ifndef ace_yytext_ptr
-#ifdef YY_USE_PROTOS
-static void ace_yy_flex_strncpy( char *s1, const char *s2, int n )
-#else
-static void ace_yy_flex_strncpy( s1, s2, n )
-char *s1;
-const char *s2;
-int n;
-#endif
-	{
-	register int i;
-	for ( i = 0; i < n; ++i )
-		s1[i] = s2[i];
-	}
-#endif
-
-
-#ifdef YY_USE_PROTOS
-static void *ace_yy_flex_alloc( unsigned int size )
-#else
-static void *ace_yy_flex_alloc( size )
-unsigned int size;
-#endif
-	{
-	return (void *) malloc( size );
-	}
-
-#ifdef YY_USE_PROTOS
-static void *ace_yy_flex_realloc( void *ptr, unsigned int size )
-#else
-static void *ace_yy_flex_realloc( ptr, size )
-void *ptr;
-unsigned int size;
-#endif
-	{
-	return (void *) realloc( ACE_MALLOC_T (ptr), size );
-	}
-
-#ifdef YY_USE_PROTOS
-static void ace_yy_flex_free( void *ptr )
-#else
-static void ace_yy_flex_free( ptr )
-void *ptr;
-#endif
-	{
-	free( ACE_MALLOC_T (ptr) );
-	}
-# line 69 "Svc_Conf.l"
-
-int
-ace_yywrap (void)
-{
-  ::fflush (ace_yyin);
-  ace_yytext[0] = '#';
-  ace_yyleng = 0;    
-  return 1;
-}
diff --git a/ace/Svc_Conf_y.cpp b/ace/Svc_Conf_y.cpp
index 71c7e9518cc..f0cdbfd5a10 100644
--- a/ace/Svc_Conf_y.cpp
+++ b/ace/Svc_Conf_y.cpp
@@ -13,9 +13,9 @@ char ace_yysccsid[] = "@(#)yaccpar	1.4 (Berkeley) 02/25/90 \n\
 static ACE_Module_Type *get_module (ACE_Static_Node *str_rec, ACE_Static_Node *svc_type);
 static ACE_Module_Type *get_module (ACE_Static_Node *str_rec, const char *svc_name);
 
-#define YYDEBUG_LEXER_TEXT (ace_yytext[ace_yyleng] = '\0', ace_yytext)
+#define ACE_YYDEBUG_LEXER_TEXT (ace_yytext[ace_yyleng] = '\0', ace_yytext)
 /* Force the pretty debugging code to compile.*/
-#define YYDEBUG 1
+#define ACE_YYDEBUG 1
 
 /* Efficient memory allocation technique.*/
 ACE_Obstack *ace_obstack;
@@ -41,7 +41,7 @@ ACE_Obstack *ace_obstack;
 #define ACE_RBRACE 274
 #define ACE_STAR 275
 #define ACE_COLON 276
-#define YYERRCODE 256
+#define ACE_YYERRCODE 256
 short ace_yylhs[] = {                                        -1,
     0,    0,    0,   14,   14,   14,   14,   14,   14,    5,
     6,    7,    8,    9,   11,   18,   11,   15,   15,   19,
@@ -91,7 +91,7 @@ short ace_yygindex[] = {                                      0,
     0,   31,    0,    0,   -8,   -6,   -1,    2,    3,    0,
     0,   18,    0,    0,    0,    0,    0,    0,    0,
 };
-#define YYTABLESIZE 308
+#define ACE_YYTABLESIZE 308
 short ace_yytable[] = {                                      23,
    34,   24,   16,    3,    4,    5,    6,    7,   18,    3,
     4,   26,   27,   28,   19,   39,   40,   48,   49,   33,
@@ -158,12 +158,12 @@ short ace_yycheck[] = {                                       8,
    -1,   -1,  273,  274,   -1,   -1,   -1,   -1,   -1,  273,
   274,  256,  257,  258,  259,  260,  261,  262,
 };
-#define YYFINAL 1
-#ifndef YYDEBUG
-#define YYDEBUG 0
+#define ACE_YYFINAL 1
+#ifndef ACE_YYDEBUG
+#define ACE_YYDEBUG 0
 #endif
-#define YYMAXTOKEN 276
-#if YYDEBUG
+#define ACE_YYMAXTOKEN 276
+#if ACE_YYDEBUG
 char *ace_yyname[] = {
 "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
@@ -226,11 +226,11 @@ char *ace_yyrule[] = {
 #endif
 #define ace_yyclearin (ace_yychar=(-1))
 #define ace_yyerrok (ace_yyerrflag=0)
-#ifndef YYSTACKSIZE
-#ifdef YYMAXDEPTH
-#define YYSTACKSIZE YYMAXDEPTH
+#ifndef ACE_YYSTACKSIZE
+#ifdef ACE_YYMAXDEPTH
+#define ACE_YYSTACKSIZE ACE_YYMAXDEPTH
 #else
-#define YYSTACKSIZE 300
+#define ACE_YYSTACKSIZE 300
 #endif
 #endif
 int ace_yydebug;
@@ -238,12 +238,12 @@ int ace_yynerrs;
 int ace_yyerrflag;
 int ace_yychar;
 short *ace_yyssp;
-YYSTYPE *ace_yyvsp;
-YYSTYPE ace_yyval;
-YYSTYPE ace_yylval;
-#define ace_yystacksize YYSTACKSIZE
-short ace_yyss[YYSTACKSIZE];
-YYSTYPE ace_yyvs[YYSTACKSIZE];
+ACE_YYSTYPE *ace_yyvsp;
+ACE_YYSTYPE ace_yyval;
+ACE_YYSTYPE ace_yylval;
+#define ace_yystacksize ACE_YYSTACKSIZE
+short ace_yyss[ACE_YYSTACKSIZE];
+ACE_YYSTYPE ace_yyvs[ACE_YYSTACKSIZE];
 #line 275 "Svc_Conf.y"
 // Prints the error string to standard output.  Cleans up the error
 // messages.
@@ -368,7 +368,7 @@ main (int argc, char *argv[])
   ace_yyin = stdin;
   ace_obstack = new ACE_Obstack;
 
-  // Try to reopen any filename argument to use YYIN.
+  // Try to reopen any filename argument to use ACE_YYIN.
   if (argc > 1 && (ace_yyin = freopen (argv[1], "r", stdin)) == 0)
     (void) ::fprintf (stderr, "usage: %s [file]\n", argv[0]), exit (1);
 
@@ -376,36 +376,36 @@ main (int argc, char *argv[])
 }
 #endif /* DEBUGGING */
 #line 379 "Svc_Conf_y.cpp"
-#define YYABORT goto ace_yyabort
-#define YYACCEPT goto ace_yyaccept
-#define YYERROR goto ace_yyerrlab
-#ifdef YYDEBUG
-#ifndef YYDEBUG_LEXER_TEXT /* pointer to the text isolated by the lexer*/
-#define YYDEBUG_LEXER_TEXT "YYDEBUG_LEXER_TEXT not defined"
+#define ACE_YYABORT goto ace_yyabort
+#define ACE_YYACCEPT goto ace_yyaccept
+#define ACE_YYERROR goto ace_yyerrlab
+#ifdef ACE_YYDEBUG
+#ifndef ACE_YYDEBUG_LEXER_TEXT /* pointer to the text isolated by the lexer*/
+#define ACE_YYDEBUG_LEXER_TEXT "ACE_YYDEBUG_LEXER_TEXT not defined"
 #endif
-#ifndef YYDEBUG_INDENT_STRING
-#define YYDEBUG_INDENT_STRING  "|       "
+#ifndef ACE_YYDEBUG_INDENT_STRING
+#define ACE_YYDEBUG_INDENT_STRING  "|       "
 #endif
-#ifndef YYDEBUG_REDUCE_STRING
-#define YYDEBUG_REDUCE_STRING  "+-------"
+#ifndef ACE_YYDEBUG_REDUCE_STRING
+#define ACE_YYDEBUG_REDUCE_STRING  "+-------"
 #endif
-#ifndef YYDEBUG_INDENT
+#ifndef ACE_YYDEBUG_INDENT
 #ifdef __cplusplus
-void YYDEBUG_INDENT(int ace_yyindent)
+void ACE_YYDEBUG_INDENT(int ace_yyindent)
 #else
-YYDEBUG_INDENT(ace_yyindent)
+ACE_YYDEBUG_INDENT(ace_yyindent)
 int ace_yyindent;
 #endif
 {
     while(ace_yyindent-- > 0)
-        printf("%s", YYDEBUG_INDENT_STRING);
+        printf("%s", ACE_YYDEBUG_INDENT_STRING);
 }
-#endif /* YYDEBUG_INDENT */
-#ifndef YYDEBUG_REDUCE
+#endif /* ACE_YYDEBUG_INDENT */
+#ifndef ACE_YYDEBUG_REDUCE
 #ifdef __cplusplus
-void YYDEBUG_REDUCE(int /* ace_yynew_state */, int /* ace_yyrule_num */, char *ace_yyrule_string, int ace_yynew_indent, int ace_yyrhs_count)
+void ACE_YYDEBUG_REDUCE(int /* ace_yynew_state */, int /* ace_yyrule_num */, char *ace_yyrule_string, int ace_yynew_indent, int ace_yyrhs_count)
 #else
-YYDEBUG_REDUCE(ace_yynew_state, ace_yyrule_num, ace_yyrule_string, ace_yynew_indent, ace_yyrhs_count)
+ACE_YYDEBUG_REDUCE(ace_yynew_state, ace_yyrule_num, ace_yyrule_string, ace_yynew_indent, ace_yyrhs_count)
 int ace_yynew_state;
 int ace_yyrule_num;
 char * ace_yyrule_string;
@@ -415,70 +415,70 @@ int ace_yyrhs_count;
 {
     if (1 < ace_yyrhs_count)
     {  /* draw the graphics for the reduction */
-        YYDEBUG_INDENT(ace_yynew_indent);
+        ACE_YYDEBUG_INDENT(ace_yynew_indent);
         while(1 < ace_yyrhs_count--)
-            printf("%s", YYDEBUG_REDUCE_STRING);
+            printf("%s", ACE_YYDEBUG_REDUCE_STRING);
         putchar('+'); /* left rotated L would look nice */
         putchar('\n');
-        YYDEBUG_INDENT(ace_yynew_indent);
+        ACE_YYDEBUG_INDENT(ace_yynew_indent);
         putchar('|'); /* down arrow would look nice */
         putchar('\n');
     }
-    YYDEBUG_INDENT(ace_yynew_indent);
+    ACE_YYDEBUG_INDENT(ace_yynew_indent);
     /* Only print the resulting token name */
     while (*ace_yyrule_string)
         putchar(*ace_yyrule_string++);
     putchar('\n');
 }
-#endif /* YYDEBUG_REDUCE */
-#ifndef YYDEBUG_SHIFT_LEXEME
+#endif /* ACE_YYDEBUG_REDUCE */
+#ifndef ACE_YYDEBUG_SHIFT_LEXEME
 #ifdef __cplusplus
-void YYDEBUG_SHIFT_LEXEME(int /* ace_yyold_state */, int /* ace_yynew_state */, char *ace_yytoken_string, int ace_yynew_indent)
+void ACE_YYDEBUG_SHIFT_LEXEME(int /* ace_yyold_state */, int /* ace_yynew_state */, char *ace_yytoken_string, int ace_yynew_indent)
 #else
-YYDEBUG_SHIFT_LEXEME(ace_yyold_state, ace_yynew_state, ace_yytoken_string, ace_yynew_indent)
+ACE_YYDEBUG_SHIFT_LEXEME(ace_yyold_state, ace_yynew_state, ace_yytoken_string, ace_yynew_indent)
 int ace_yyold_state;
 int ace_yynew_state;
 char * ace_yytoken_string;
 int ace_yynew_indent;
 #endif
 {
-    YYDEBUG_INDENT(ace_yynew_indent);
-    printf("%s <-- `%s'\n", ace_yytoken_string, YYDEBUG_LEXER_TEXT);
+    ACE_YYDEBUG_INDENT(ace_yynew_indent);
+    printf("%s <-- `%s'\n", ace_yytoken_string, ACE_YYDEBUG_LEXER_TEXT);
 }
-#endif /*  YYDEBUG_SHIFT_LEXEME */
-#ifndef YYDEBUG_LOOK_AHEAD
+#endif /*  ACE_YYDEBUG_SHIFT_LEXEME */
+#ifndef ACE_YYDEBUG_LOOK_AHEAD
 #ifdef __cplusplus
-void YYDEBUG_LOOK_AHEAD(int /* ace_yynew_state */, int ace_yytoken_num, char *ace_yytoken_string, int ace_yyindent)
+void ACE_YYDEBUG_LOOK_AHEAD(int /* ace_yynew_state */, int ace_yytoken_num, char *ace_yytoken_string, int ace_yyindent)
 #else
-YYDEBUG_LOOK_AHEAD(ace_yynew_state, ace_yytoken_num, ace_yytoken_string, ace_yyindent)
+ACE_YYDEBUG_LOOK_AHEAD(ace_yynew_state, ace_yytoken_num, ace_yytoken_string, ace_yyindent)
 int ace_yynew_state;
 int ace_yytoken_num;
 char * ace_yytoken_string;
 int ace_yyindent;
 #endif
 {
-    YYDEBUG_INDENT(ace_yyindent);
+    ACE_YYDEBUG_INDENT(ace_yyindent);
     printf("          .... look ahead at %s   `%s'\n",
            ace_yytoken_string,
-           (0 == ace_yytoken_num)? "\0": YYDEBUG_LEXER_TEXT);
+           (0 == ace_yytoken_num)? "\0": ACE_YYDEBUG_LEXER_TEXT);
 }
-#endif /* YYDEBUG_LOOK_AHEAD */
-#ifndef YYDEBUG_DISCARD_STATE
+#endif /* ACE_YYDEBUG_LOOK_AHEAD */
+#ifndef ACE_YYDEBUG_DISCARD_STATE
 #ifdef __cplusplus
-void YYDEBUG_DISCARD_STATE(int /* ace_yynew_state */, int ace_yyindent)
+void ACE_YYDEBUG_DISCARD_STATE(int /* ace_yynew_state */, int ace_yyindent)
 #else
-YYDEBUG_DISCARD_STATE(ace_yynew_state, ace_yyindent)
+ACE_YYDEBUG_DISCARD_STATE(ace_yynew_state, ace_yyindent)
 int ace_yynew_state;
 int ace_yyindent;
 #endif
 {
     if (0 < ace_yyindent)
     {  /* draw the graphics for the reduction */
-        YYDEBUG_INDENT(ace_yyindent-1);
-        printf("%s", YYDEBUG_REDUCE_STRING);
+        ACE_YYDEBUG_INDENT(ace_yyindent-1);
+        printf("%s", ACE_YYDEBUG_REDUCE_STRING);
         putchar('+'); /* left rotated L would look nice */
         printf("  discarding state\n");
-        YYDEBUG_INDENT(ace_yyindent-1);
+        ACE_YYDEBUG_INDENT(ace_yyindent-1);
         putchar('|'); /* down arrow would look nice */
         putchar('\n');
     }
@@ -490,37 +490,37 @@ int ace_yyindent;
             printf("no more states to discard: parser will abort\n");
     }
 }
-#endif /* YYDEBUG_DISCARD_STATE */
-#ifndef YYDEBUG_DISCARD_TOKEN
+#endif /* ACE_YYDEBUG_DISCARD_STATE */
+#ifndef ACE_YYDEBUG_DISCARD_TOKEN
 #ifdef __cplusplus
-void YYDEBUG_DISCARD_TOKEN(int /* ace_yynew_state */, int /* ace_yytoken_num */, char *ace_yytoken_string, int ace_yyindent)
+void ACE_YYDEBUG_DISCARD_TOKEN(int /* ace_yynew_state */, int /* ace_yytoken_num */, char *ace_yytoken_string, int ace_yyindent)
 #else
-YYDEBUG_DISCARD_TOKEN(ace_yynew_state, ace_yytoken_num, ace_yytoken_string, ace_yyindent)
+ACE_YYDEBUG_DISCARD_TOKEN(ace_yynew_state, ace_yytoken_num, ace_yytoken_string, ace_yyindent)
 int ace_yynew_state;
 int ace_yytoken_num;
 char * ace_yytoken_string;
 int ace_yyindent;
 #endif
 {
-    YYDEBUG_INDENT(ace_yyindent);
+    ACE_YYDEBUG_INDENT(ace_yyindent);
     printf("discarding token %s\n", ace_yytoken_string);
 }
-#endif /* YYDEBUG_DISCARD_TOKEN */
-#ifndef YYDEBUG_SHIFT_ERROR_LEXEME
+#endif /* ACE_YYDEBUG_DISCARD_TOKEN */
+#ifndef ACE_YYDEBUG_SHIFT_ERROR_LEXEME
 #ifdef __cplusplus
-void YYDEBUG_SHIFT_ERROR_LEXEME(int /* ace_yyold_state */, int /* ace_yynew_state */, int ace_yyindent)
+void ACE_YYDEBUG_SHIFT_ERROR_LEXEME(int /* ace_yyold_state */, int /* ace_yynew_state */, int ace_yyindent)
 #else
-YYDEBUG_SHIFT_ERROR_LEXEME(ace_yyold_state, ace_yynew_state, ace_yyindent)
+ACE_YYDEBUG_SHIFT_ERROR_LEXEME(ace_yyold_state, ace_yynew_state, ace_yyindent)
 int ace_yyold_state;
 int ace_yynew_state;
 int ace_yyindent;
 #endif
 {
-    YYDEBUG_INDENT(ace_yyindent);
+    ACE_YYDEBUG_INDENT(ace_yyindent);
     printf("error\n");
 }
-#endif /* YYDEBUG_SHIFT_ERROR_LEXEME */
-#endif /* YYDEBUG */
+#endif /* ACE_YYDEBUG_SHIFT_ERROR_LEXEME */
+#endif /* ACE_YYDEBUG */
 #ifdef __cplusplus
 extern "C" { extern char *ace_foo(const char *); }
 #endif
@@ -528,13 +528,13 @@ int
 ace_yyparse()
 {
     register int ace_yym, ace_yyn, ace_yystate;
-#if YYDEBUG
+#if ACE_YYDEBUG
     register char *ace_yys;
 #ifndef __cplusplus
     extern char *ace_foo();
 #endif
 
-    if ((ace_yys = ACE_OS::getenv("YYDEBUG")))
+    if ((ace_yys = ACE_OS::getenv("ACE_YYDEBUG")))
     {
         ace_yyn = *ace_yys;
         if (ace_yyn >= '0' && ace_yyn <= '9')
@@ -555,30 +555,30 @@ ace_yyloop:
     if (ace_yychar < 0)
     {
         if ((ace_yychar = ace_yylex()) < 0) ace_yychar = 0;
-#if YYDEBUG
+#if ACE_YYDEBUG
         if (ace_yydebug)
         {
             ace_yys = 0;
-            if (ace_yychar <= YYMAXTOKEN) ace_yys = ace_yyname[ace_yychar];
+            if (ace_yychar <= ACE_YYMAXTOKEN) ace_yys = ace_yyname[ace_yychar];
             if (!ace_yys) ace_yys = "illegal-symbol";
             if (5 < ace_yydebug)
                 printf("ace_yydebug: state %d, reading %d (%s)\n", ace_yystate,
                         ace_yychar, ace_yys);
             else
-                YYDEBUG_LOOK_AHEAD(ace_yystate, ace_yychar, ace_yys, ace_yyssp-ace_yyss);
+                ACE_YYDEBUG_LOOK_AHEAD(ace_yystate, ace_yychar, ace_yys, ace_yyssp-ace_yyss);
         }
 #endif
     }
     if ((ace_yyn = ace_yysindex[ace_yystate]) && (ace_yyn += ace_yychar) >= 0 &&
-            ace_yyn <= YYTABLESIZE && ace_yycheck[ace_yyn] == ace_yychar)
+            ace_yyn <= ACE_YYTABLESIZE && ace_yycheck[ace_yyn] == ace_yychar)
     {
-#if YYDEBUG
+#if ACE_YYDEBUG
         if (ace_yydebug)
             if (5 < ace_yydebug)
                 printf("ace_yydebug: state %d, shifting to state %d\n",
                         ace_yystate, ace_yytable[ace_yyn]);
             else
-                YYDEBUG_SHIFT_LEXEME(ace_yystate, ace_yytable[ace_yyn], ace_yys, ace_yyssp-ace_yyss);
+                ACE_YYDEBUG_SHIFT_LEXEME(ace_yystate, ace_yytable[ace_yyn], ace_yys, ace_yyssp-ace_yyss);
 #endif
         if (ace_yyssp >= ace_yyss + ace_yystacksize - 1)
         {
@@ -591,7 +591,7 @@ ace_yyloop:
         goto ace_yyloop;
     }
     if ((ace_yyn = ace_yyrindex[ace_yystate]) && (ace_yyn += ace_yychar) >= 0 &&
-            ace_yyn <= YYTABLESIZE && ace_yycheck[ace_yyn] == ace_yychar)
+            ace_yyn <= ACE_YYTABLESIZE && ace_yycheck[ace_yyn] == ace_yychar)
     {
         ace_yyn = ace_yytable[ace_yyn];
         goto ace_yyreduce;
@@ -613,16 +613,16 @@ ace_yyinrecovery:
         ace_yyerrflag = 3;
         for (;;)
         {
-            if ((ace_yyn = ace_yysindex[*ace_yyssp]) && (ace_yyn += YYERRCODE) >= 0 &&
-                    ace_yyn <= YYTABLESIZE && ace_yycheck[ace_yyn] == YYERRCODE)
+            if ((ace_yyn = ace_yysindex[*ace_yyssp]) && (ace_yyn += ACE_YYERRCODE) >= 0 &&
+                    ace_yyn <= ACE_YYTABLESIZE && ace_yycheck[ace_yyn] == ACE_YYERRCODE)
             {
-#if YYDEBUG
+#if ACE_YYDEBUG
                 if (ace_yydebug)
                     if (5 < ace_yydebug)
                         printf("ace_yydebug: state %d, error recovery shifting\
  to state %d\n", *ace_yyssp, ace_yytable[ace_yyn]);
                     else
-                        YYDEBUG_SHIFT_ERROR_LEXEME(*ace_yyssp, ace_yytable[ace_yyn], ace_yyssp-ace_yyss);
+                        ACE_YYDEBUG_SHIFT_ERROR_LEXEME(*ace_yyssp, ace_yytable[ace_yyn], ace_yyssp-ace_yyss);
 #endif
                 if (ace_yyssp >= ace_yyss + ace_yystacksize - 1)
                 {
@@ -634,14 +634,14 @@ ace_yyinrecovery:
             }
             else
             {
-#if YYDEBUG
+#if ACE_YYDEBUG
                 if (ace_yydebug)
                     if (5 < ace_yydebug)
                         printf("ace_yydebug: error recovery discarding state %d\
 ",
                             *ace_yyssp);
                     else
-                        YYDEBUG_DISCARD_STATE(*ace_yyssp, ace_yyssp-ace_yyss-1);
+                        ACE_YYDEBUG_DISCARD_STATE(*ace_yyssp, ace_yyssp-ace_yyss-1);
 #endif
                 if (ace_yyssp <= ace_yyss) goto ace_yyabort;
                 --ace_yyssp;
@@ -652,17 +652,17 @@ ace_yyinrecovery:
     else
     {
         if (ace_yychar == 0) goto ace_yyabort;
-#if YYDEBUG
+#if ACE_YYDEBUG
         if (ace_yydebug)
         {
             ace_yys = 0;
-            if (ace_yychar <= YYMAXTOKEN) ace_yys = ace_yyname[ace_yychar];
+            if (ace_yychar <= ACE_YYMAXTOKEN) ace_yys = ace_yyname[ace_yychar];
             if (!ace_yys) ace_yys = "illegal-symbol";
             if (5 < ace_yydebug)
                 printf("ace_yydebug: state %d, error recovery discards token %d (%s)\n",
                     ace_yystate, ace_yychar, ace_yys);
             else 
-                YYDEBUG_DISCARD_TOKEN(ace_yystate, ace_yychar, ace_yys, ace_yyssp-ace_yyss);
+                ACE_YYDEBUG_DISCARD_TOKEN(ace_yystate, ace_yychar, ace_yys, ace_yyssp-ace_yyss);
         }
 #endif
         ace_yychar = (-1);
@@ -671,13 +671,13 @@ ace_yyinrecovery:
 ace_yyreduce:
     ace_yym = ace_yylen[ace_yyn];
     ace_yyval = ace_yyvsp[1-ace_yym];
-#if YYDEBUG
+#if ACE_YYDEBUG
     if (ace_yydebug)
         if (5 < ace_yydebug)
             printf("ace_yydebug: state %d, reducing by rule %d (%s)\n",
                     ace_yystate, ace_yyn, ace_yyrule[ace_yyn]);
         else
-            YYDEBUG_REDUCE(ace_yystate, ace_yyn, ace_yyrule[ace_yyn], ace_yyssp-ace_yyss-ace_yym, ace_yym);
+            ACE_YYDEBUG_REDUCE(ace_yystate, ace_yyn, ace_yyrule[ace_yyn], ace_yyssp-ace_yyss-ace_yym, ace_yym);
 #endif
     switch (ace_yyn)
     {
@@ -933,28 +933,28 @@ break;
     ace_yym = ace_yylhs[ace_yyn];
     if (ace_yystate == 0 && ace_yym == 0)
     {
-#ifdef YYDEBUG
+#ifdef ACE_YYDEBUG
         if (5 < ace_yydebug)
             printf("ace_yydebug: after reduction, shifting from state 0 to\
- state %d\n", YYFINAL);
+ state %d\n", ACE_YYFINAL);
 #endif
-        ace_yystate = YYFINAL;
-        *++ace_yyssp = YYFINAL;
+        ace_yystate = ACE_YYFINAL;
+        *++ace_yyssp = ACE_YYFINAL;
         *++ace_yyvsp = ace_yyval;
         if (ace_yychar < 0)
         {
             if ((ace_yychar = ace_yylex()) < 0) ace_yychar = 0;
-#if YYDEBUG
+#if ACE_YYDEBUG
             if (ace_yydebug)
             {
                 ace_yys = 0;
-                if (ace_yychar <= YYMAXTOKEN) ace_yys = ace_yyname[ace_yychar];
+                if (ace_yychar <= ACE_YYMAXTOKEN) ace_yys = ace_yyname[ace_yychar];
                 if (!ace_yys) ace_yys = "illegal-symbol";
                 if (5 < ace_yydebug)
                     printf("ace_yydebug: state %d, reading %d (%s)\n",
-                        YYFINAL, ace_yychar, ace_yys);
+                        ACE_YYFINAL, ace_yychar, ace_yys);
                 else
-                    YYDEBUG_LOOK_AHEAD(YYFINAL, ace_yychar, ace_yys, ace_yyssp-ace_yyss);
+                    ACE_YYDEBUG_LOOK_AHEAD(ACE_YYFINAL, ace_yychar, ace_yys, ace_yyssp-ace_yyss);
             }
 #endif
         }
@@ -962,11 +962,11 @@ break;
         goto ace_yyloop;
     }
     if ((ace_yyn = ace_yygindex[ace_yym]) && (ace_yyn += ace_yystate) >= 0 &&
-            ace_yyn <= YYTABLESIZE && ace_yycheck[ace_yyn] == ace_yystate)
+            ace_yyn <= ACE_YYTABLESIZE && ace_yycheck[ace_yyn] == ace_yystate)
         ace_yystate = ace_yytable[ace_yyn];
     else
         ace_yystate = ace_yydgoto[ace_yym];
-#ifdef YYDEBUG
+#ifdef ACE_YYDEBUG
     if (5 < ace_yydebug)
         printf("ace_yydebug: after reduction, shifting from state %d \
 to state %d\n", *ace_yyssp, ace_yystate);
diff --git a/etc/Svc_Conf_l.cpp.diff b/etc/Svc_Conf_l.cpp.diff
index 61559490d3a..226b606d1cc 100644
--- a/etc/Svc_Conf_l.cpp.diff
+++ b/etc/Svc_Conf_l.cpp.diff
@@ -31,26 +31,26 @@
  static int ace_yy_did_buffer_switch_on_eof;
  
 +#if 0
- static void ace_yyunput YY_PROTO(( int c, char *buf_ptr ));
+ static void ace_yyunput ACE_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 ));
+ void ace_yyrestart ACE_YY_PROTO(( FILE *input_file ));
+ void ace_yy_switch_to_buffer ACE_YY_PROTO(( ACE_YY_BUFFER_STATE new_buffer ));
+ void ace_yy_load_buffer_state ACE_YY_PROTO(( void ));
 @@ -224,12 +231,14 @@
- 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_delete_buffer ACE_YY_PROTO(( ACE_YY_BUFFER_STATE b ));
+ void ace_yy_init_buffer ACE_YY_PROTO(( ACE_YY_BUFFER_STATE b, FILE *file ));
  
 +#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 ));
+ static void ace_yy_push_state ACE_YY_PROTO(( int new_state ));
+ static void ace_yy_pop_state ACE_YY_PROTO(( void ));
+ static int ace_yy_top_state ACE_YY_PROTO(( void ));
 +#endif /* 0 */
  
- 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 ACE_YY_PROTO(( unsigned int ));
+ static void *ace_yy_flex_realloc ACE_YY_PROTO(( void *, unsigned int ));
 @@ -466,7 +475,7 @@
  #include "ace/Svc_Conf.h"
  #include "ace/Svc_Conf_Tokens.h"
@@ -61,109 +61,109 @@
  
  // Keeps track of the number of errors encountered so far.
 @@ -661,112 +670,112 @@
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 35 "Svc_Conf.l"
  { return token (ACE_DYNAMIC); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 3:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 36 "Svc_Conf.l"
  { return token (ACE_STATIC); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 4:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 37 "Svc_Conf.l"
  { return token (ACE_SUSPEND); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 5:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 38 "Svc_Conf.l"
  { return token (ACE_RESUME); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 6:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 39 "Svc_Conf.l"
  { return token (ACE_REMOVE); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 7:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 40 "Svc_Conf.l"
  { return token (ACE_USTREAM); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 8:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 41 "Svc_Conf.l"
  { return token (ACE_MODULE_T); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 9:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 42 "Svc_Conf.l"
  { return token (ACE_SVC_OBJ_T); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 10:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 43 "Svc_Conf.l"
  { return token (ACE_STREAM_T); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 11:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 44 "Svc_Conf.l"
  { return token (ACE_ACTIVE); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 12:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 45 "Svc_Conf.l"
  { return token (ACE_INACTIVE); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 13:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 46 "Svc_Conf.l"
  { return token (ACE_COLON); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 14:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 47 "Svc_Conf.l"
  { return token (ACE_STAR); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 15:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 48 "Svc_Conf.l"
  { return token (ACE_LPAREN); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 16:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 49 "Svc_Conf.l"
  { return token (ACE_RPAREN); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 17:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 50 "Svc_Conf.l"
  { return token (ACE_LBRACE); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 18:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 51 "Svc_Conf.l"
  { return token (ACE_RBRACE); }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 19:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 52 "Svc_Conf.l"
  { // Eliminate the opening and closing double quotes
  		        *strrchr (ace_yytext, '"') = '\0';
@@ -171,10 +171,10 @@
 -                        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 */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 20:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 57 "Svc_Conf.l"
 -{ 
 -		        ace_yylval.ident_ = ace_obstack->copy (ace_yytext, ace_yyleng); 
@@ -183,10 +183,10 @@
 +		        ace_yylval.ident_ = ace_obstack->copy (ace_yytext, ace_yyleng);
 +			return token (ACE_IDENT);
  		      }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 21:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 61 "Svc_Conf.l"
 -{ 
 -		        ace_yylval.ident_ = ace_obstack->copy (ace_yytext, ace_yyleng); 
@@ -195,31 +195,31 @@
 +		        ace_yylval.ident_ = ace_obstack->copy (ace_yytext, ace_yyleng);
 +			return token (ACE_PATHNAME);
  		      }
--	YY_BREAK
-+	/* YY_BREAK */
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 22:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 65 "Svc_Conf.l"
 @@ -787,7 +796,7 @@
- case YY_STATE_EOF(NORMAL):
+ case ACE_YY_STATE_EOF(NORMAL):
  # line 68 "Svc_Conf.l"
- { YY_NEW_FILE; ace_yyterminate(); }
--	YY_BREAK
-+	/* YY_BREAK */
+ { ACE_YY_NEW_FILE; ace_yyterminate(); }
+-	ACE_YY_BREAK
++	/* ACE_YY_BREAK */
  case 25:
- YY_USER_ACTION
+ ACE_YY_USER_ACTION
  # line 69 "Svc_Conf.l"
 @@ -1120,6 +1129,7 @@
  	}
  
  
 +#if 0
- #ifdef YY_USE_PROTOS
+ #ifdef ACE_YY_USE_PROTOS
  static void ace_yyunput( int c, register char *ace_yy_bp )
  #else
 @@ -1164,7 +1174,7 @@
  	 */
- 	YY_DO_BEFORE_ACTION; /* set up ace_yytext again */
+ 	ACE_YY_DO_BEFORE_ACTION; /* set up ace_yytext again */
  	}
 -
 +#endif /* 0 */
@@ -231,7 +231,7 @@
  
  
 +#if 0
- #ifdef YY_USE_PROTOS
+ #ifdef ACE_YY_USE_PROTOS
  static void ace_yy_push_state( int new_state )
  #else
 @@ -1417,7 +1428,7 @@
@@ -241,7 +241,7 @@
 -
 +#endif /* 0 */
  
- #ifdef YY_USE_PROTOS
+ #ifdef ACE_YY_USE_PROTOS
  static void ace_yy_fatal_error( const char msg[] )
 @@ -1504,6 +1515,6 @@
  {
diff --git a/etc/Svc_Conf_y.cpp.diff b/etc/Svc_Conf_y.cpp.diff
index ab3e0c5ed36..91cc08ebc50 100644
--- a/etc/Svc_Conf_y.cpp.diff
+++ b/etc/Svc_Conf_y.cpp.diff
@@ -1,65 +1,65 @@
 --- Svc_Conf_y.cpp.orig	Mon Feb 23 09:14:42 1998
 +++ Svc_Conf_y.cpp	Mon Feb 23 09:24:51 1998
 @@ -395,7 +397,7 @@
- #endif /* YYDEBUG_INDENT */
- #ifndef YYDEBUG_REDUCE
+ #endif /* ACE_YYDEBUG_INDENT */
+ #ifndef ACE_YYDEBUG_REDUCE
  #ifdef __cplusplus
--void YYDEBUG_REDUCE(int ace_yynew_state, int ace_yyrule_num, char *ace_yyrule_string, int ace_yynew_indent, int ace_yyrhs_count)
-+void YYDEBUG_REDUCE(int /* ace_yynew_state */, int /* ace_yyrule_num */, char *ace_yyrule_string, int ace_yynew_indent, int ace_yyrhs_count)
+-void ACE_YYDEBUG_REDUCE(int ace_yynew_state, int ace_yyrule_num, char *ace_yyrule_string, int ace_yynew_indent, int ace_yyrhs_count)
++void ACE_YYDEBUG_REDUCE(int /* ace_yynew_state */, int /* ace_yyrule_num */, char *ace_yyrule_string, int ace_yynew_indent, int ace_yyrhs_count)
  #else
- YYDEBUG_REDUCE(ace_yynew_state, ace_yyrule_num, ace_yyrule_string, ace_yynew_indent, ace_yyrhs_count)
+ ACE_YYDEBUG_REDUCE(ace_yynew_state, ace_yyrule_num, ace_yyrule_string, ace_yynew_indent, ace_yyrhs_count)
  int ace_yynew_state;
 @@ -425,7 +427,7 @@
- #endif /* YYDEBUG_REDUCE */
- #ifndef YYDEBUG_SHIFT_LEXEME
+ #endif /* ACE_YYDEBUG_REDUCE */
+ #ifndef ACE_YYDEBUG_SHIFT_LEXEME
  #ifdef __cplusplus
--void YYDEBUG_SHIFT_LEXEME(int ace_yyold_state, int ace_yynew_state, char *ace_yytoken_string, int ace_yynew_indent)
-+void YYDEBUG_SHIFT_LEXEME(int /* ace_yyold_state */, int /* ace_yynew_state */, char *ace_yytoken_string, int ace_yynew_indent)
+-void ACE_YYDEBUG_SHIFT_LEXEME(int ace_yyold_state, int ace_yynew_state, char *ace_yytoken_string, int ace_yynew_indent)
++void ACE_YYDEBUG_SHIFT_LEXEME(int /* ace_yyold_state */, int /* ace_yynew_state */, char *ace_yytoken_string, int ace_yynew_indent)
  #else
- YYDEBUG_SHIFT_LEXEME(ace_yyold_state, ace_yynew_state, ace_yytoken_string, ace_yynew_indent)
+ ACE_YYDEBUG_SHIFT_LEXEME(ace_yyold_state, ace_yynew_state, ace_yytoken_string, ace_yynew_indent)
  int ace_yyold_state;
 @@ -440,7 +442,7 @@
- #endif /*  YYDEBUG_SHIFT_LEXEME */
- #ifndef YYDEBUG_LOOK_AHEAD
+ #endif /*  ACE_YYDEBUG_SHIFT_LEXEME */
+ #ifndef ACE_YYDEBUG_LOOK_AHEAD
  #ifdef __cplusplus
--void YYDEBUG_LOOK_AHEAD(int ace_yynew_state, int ace_yytoken_num, char *ace_yytoken_string, int ace_yyindent)
-+void YYDEBUG_LOOK_AHEAD(int /* ace_yynew_state */, int ace_yytoken_num, char *ace_yytoken_string, int ace_yyindent)
+-void ACE_YYDEBUG_LOOK_AHEAD(int ace_yynew_state, int ace_yytoken_num, char *ace_yytoken_string, int ace_yyindent)
++void ACE_YYDEBUG_LOOK_AHEAD(int /* ace_yynew_state */, int ace_yytoken_num, char *ace_yytoken_string, int ace_yyindent)
  #else
- YYDEBUG_LOOK_AHEAD(ace_yynew_state, ace_yytoken_num, ace_yytoken_string, ace_yyindent)
+ ACE_YYDEBUG_LOOK_AHEAD(ace_yynew_state, ace_yytoken_num, ace_yytoken_string, ace_yyindent)
  int ace_yynew_state;
 @@ -457,7 +459,7 @@
- #endif /* YYDEBUG_LOOK_AHEAD */
- #ifndef YYDEBUG_DISCARD_STATE
+ #endif /* ACE_YYDEBUG_LOOK_AHEAD */
+ #ifndef ACE_YYDEBUG_DISCARD_STATE
  #ifdef __cplusplus
--void YYDEBUG_DISCARD_STATE(int ace_yynew_state, int ace_yyindent)
-+void YYDEBUG_DISCARD_STATE(int /* ace_yynew_state */, int ace_yyindent)
+-void ACE_YYDEBUG_DISCARD_STATE(int ace_yynew_state, int ace_yyindent)
++void ACE_YYDEBUG_DISCARD_STATE(int /* ace_yynew_state */, int ace_yyindent)
  #else
- YYDEBUG_DISCARD_STATE(ace_yynew_state, ace_yyindent)
+ ACE_YYDEBUG_DISCARD_STATE(ace_yynew_state, ace_yyindent)
  int ace_yynew_state;
 @@ -485,7 +487,7 @@
- #endif /* YYDEBUG_DISCARD_STATE */
- #ifndef YYDEBUG_DISCARD_TOKEN
+ #endif /* ACE_YYDEBUG_DISCARD_STATE */
+ #ifndef ACE_YYDEBUG_DISCARD_TOKEN
  #ifdef __cplusplus
--void YYDEBUG_DISCARD_TOKEN(int ace_yynew_state, int ace_yytoken_num, char *ace_yytoken_string, int ace_yyindent)
-+void YYDEBUG_DISCARD_TOKEN(int /* ace_yynew_state */, int /* ace_yytoken_num */, char *ace_yytoken_string, int ace_yyindent)
+-void ACE_YYDEBUG_DISCARD_TOKEN(int ace_yynew_state, int ace_yytoken_num, char *ace_yytoken_string, int ace_yyindent)
++void ACE_YYDEBUG_DISCARD_TOKEN(int /* ace_yynew_state */, int /* ace_yytoken_num */, char *ace_yytoken_string, int ace_yyindent)
  #else
- YYDEBUG_DISCARD_TOKEN(ace_yynew_state, ace_yytoken_num, ace_yytoken_string, ace_yyindent)
+ ACE_YYDEBUG_DISCARD_TOKEN(ace_yynew_state, ace_yytoken_num, ace_yytoken_string, ace_yyindent)
  int ace_yynew_state;
 @@ -500,7 +502,7 @@
- #endif /* YYDEBUG_DISCARD_TOKEN */
- #ifndef YYDEBUG_SHIFT_ERROR_LEXEME
+ #endif /* ACE_YYDEBUG_DISCARD_TOKEN */
+ #ifndef ACE_YYDEBUG_SHIFT_ERROR_LEXEME
  #ifdef __cplusplus
--void YYDEBUG_SHIFT_ERROR_LEXEME(int ace_yyold_state, int ace_yynew_state, int ace_yyindent)
-+void YYDEBUG_SHIFT_ERROR_LEXEME(int /* ace_yyold_state */, int /* ace_yynew_state */, int ace_yyindent)
+-void ACE_YYDEBUG_SHIFT_ERROR_LEXEME(int ace_yyold_state, int ace_yynew_state, int ace_yyindent)
++void ACE_YYDEBUG_SHIFT_ERROR_LEXEME(int /* ace_yyold_state */, int /* ace_yynew_state */, int ace_yyindent)
  #else
- YYDEBUG_SHIFT_ERROR_LEXEME(ace_yyold_state, ace_yynew_state, ace_yyindent)
+ ACE_YYDEBUG_SHIFT_ERROR_LEXEME(ace_yyold_state, ace_yynew_state, ace_yyindent)
  int ace_yyold_state;
 @@ -526,7 +528,7 @@
      extern char *ace_foo();
  #endif
  
--    if (ace_yys = ACE_OS::getenv("YYDEBUG"))
-+    if ((ace_yys = ACE_OS::getenv("YYDEBUG")))
+-    if (ace_yys = ACE_OS::getenv("ACE_YYDEBUG"))
++    if ((ace_yys = ACE_OS::getenv("ACE_YYDEBUG")))
      {
          ace_yyn = *ace_yys;
          if (ace_yyn >= '0' && ace_yyn <= '9')