--- Svc_Conf_y.cpp.old	2002-07-30 08:29:40.000000000 -0700
+++ Svc_Conf_y.cpp	2002-07-30 08:31:11.000000000 -0700
@@ -60,7 +60,7 @@
 #define ACE_YYTRANSLATE(x) ((unsigned)(x) <= 270 ? ace_yytranslate[x] : 43)
 
 /* ACE_YYTRANSLATE[ACE_YYLEX] -- Bison token number corresponding to ACE_YYLEX. */
-static const char ace_yytranslate[] =
+static const ACE_TCHAR ace_yytranslate[] =
 {
        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
@@ -135,16 +135,52 @@
 #if (ACE_YYDEBUG) || defined ACE_YYERROR_VERBOSE
 
 /* ACE_YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
-static const char *const ace_yytname[] =
+static const ACE_TCHAR *const ace_yytname[] =
 {
-  "$", "error", "$undefined.", "ACE_DYNAMIC", "ACE_STATIC", "ACE_SUSPEND", 
-  "ACE_RESUME", "ACE_REMOVE", "ACE_USTREAM", "ACE_MODULE_T", 
-  "ACE_STREAM_T", "ACE_SVC_OBJ_T", "ACE_ACTIVE", "ACE_INACTIVE", 
-  "ACE_PATHNAME", "ACE_IDENT", "ACE_STRING", "'{'", "'}'", "':'", "'('", 
-  "')'", "'*'", "svc_config_entries", "svc_config_entry", "dynamic", 
-  "static", "suspend", "resume", "remove", "stream", "@1", "stream_ops", 
-  "stream_modules", "@2", "module_list", "module", "svc_location", 
-  "status", "svc_initializer", "type", "parameters_opt", "pathname", 0
+  ACE_LIB_TEXT ("$"),
+  ACE_LIB_TEXT ("error"),
+  ACE_LIB_TEXT ("$undefined."),
+  ACE_LIB_TEXT ("ACE_DYNAMIC"),
+  ACE_LIB_TEXT ("ACE_STATIC"),
+  ACE_LIB_TEXT ("ACE_SUSPEND"),
+  ACE_LIB_TEXT ("ACE_RESUME"),
+  ACE_LIB_TEXT ("ACE_REMOVE"),
+  ACE_LIB_TEXT ("ACE_USTREAM"),
+  ACE_LIB_TEXT ("ACE_MODULE_T",) 
+  ACE_LIB_TEXT ("ACE_STREAM_T"),
+  ACE_LIB_TEXT ("ACE_SVC_OBJ_T"),
+  ACE_LIB_TEXT ("ACE_ACTIVE"),
+  ACE_LIB_TEXT ("ACE_INACTIVE",) 
+  ACE_LIB_TEXT ("ACE_PATHNAME"),
+  ACE_LIB_TEXT ("ACE_IDENT"),
+  ACE_LIB_TEXT ("ACE_STRING"),
+  ACE_LIB_TEXT ("'{'"),
+  ACE_LIB_TEXT ("'}'"),
+  ACE_LIB_TEXT ("':'"),
+  ACE_LIB_TEXT ("'('"),
+  ACE_LIB_TEXT ("')'"),
+  ACE_LIB_TEXT ("'*'"),
+  ACE_LIB_TEXT ("svc_config_entries"),
+  ACE_LIB_TEXT ("svc_config_entry"),
+  ACE_LIB_TEXT ("dynamic",) 
+  ACE_LIB_TEXT ("static"),
+  ACE_LIB_TEXT ("suspend"),
+  ACE_LIB_TEXT ("resume"),
+  ACE_LIB_TEXT ("remove"),
+  ACE_LIB_TEXT ("stream"),
+  ACE_LIB_TEXT ("@1"),
+  ACE_LIB_TEXT ("stream_ops",) 
+  ACE_LIB_TEXT ("stream_modules"),
+  ACE_LIB_TEXT ("@2"),
+  ACE_LIB_TEXT ("module_list"),
+  ACE_LIB_TEXT ("module"),
+  ACE_LIB_TEXT ("svc_location",) 
+  ACE_LIB_TEXT ("status"),
+  ACE_LIB_TEXT ("svc_initializer"),
+  ACE_LIB_TEXT ("type"),
+  ACE_LIB_TEXT ("parameters_opt"),
+  ACE_LIB_TEXT ("pathname"),
+  0
 };
 #endif
 
@@ -409,7 +445,7 @@
     }								\
   else								\
     { 								\
-      ace_yyerror ("syntax error: cannot back up");			\
+      ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ACE_LIB_TEXT ("syntax error: cannot back up"));			\
       ACE_YYERROR;							\
     }								\
 while (0)
@@ -502,13 +538,13 @@
 /* Return the length of ACE_YYSTR.  */
 static ACE_YYSIZE_T
 #   if defined (__STDC__) || defined (__cplusplus)
-ace_yystrlen (const char *ace_yystr)
+ace_yystrlen (const ACE_TCHAR *ace_yystr)
 #   else
 ace_yystrlen (ace_yystr)
-     const char *ace_yystr;
+     const ACE_TCHAR *ace_yystr;
 #   endif
 {
-  register const char *ace_yys = ace_yystr;
+  register const ACE_TCHAR *ace_yys = ace_yystr;
 
   while (*ace_yys++ != '\0')
     continue;
@@ -526,15 +562,15 @@
    ACE_YYDEST.  */
 static char *
 #   if defined (__STDC__) || defined (__cplusplus)
-ace_yystpcpy (char *ace_yydest, const char *ace_yysrc)
+ace_yystpcpy (ACE_TCHAR *ace_yydest, const ACE_TCHAR *ace_yysrc)
 #   else
 ace_yystpcpy (ace_yydest, ace_yysrc)
-     char *ace_yydest;
-     const char *ace_yysrc;
+     ACE_TCHAR *ace_yydest;
+     const ACE_TCHAR *ace_yysrc;
 #   endif
 {
-  register char *ace_yyd = ace_yydest;
-  register const char *ace_yys = ace_yysrc;
+  register ACE_TCHAR *ace_yyd = ace_yydest;
+  register const ACE_TCHAR *ace_yys = ace_yysrc;
 
   while ((*ace_yyd++ = *ace_yys++) != '\0')
     continue;
@@ -668,7 +704,7 @@
      rule. */
   int ace_yylen;
 
-  ACE_YYDPRINTF ((stderr, "Starting parse\n"));
+  ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Starting parse\n")));
 
   ace_yystate = 0;
   ace_yyerrstatus = 0;
@@ -718,14 +754,14 @@
 	ACE_YYLTYPE *ace_yyls1 = ace_yyls;
 	/* This used to be a conditional around just the two extra args,
 	   but that might be undefined if ace_yyoverflow is a macro.  */
-	ace_yyoverflow ("parser stack overflow",
+	ace_yyoverflow (ACE_LIB_TEXT ("parser stack overflow"),
 		    &ace_yyss1, ace_yysize * sizeof (*ace_yyssp),
 		    &ace_yyvs1, ace_yysize * sizeof (*ace_yyvsp),
 		    &ace_yyls1, ace_yysize * sizeof (*ace_yylsp),
 		    &ace_yystacksize);
 	ace_yyls = ace_yyls1;
 # else
-	ace_yyoverflow ("parser stack overflow",
+	ace_yyoverflow (ACE_LIB_TEXT ("parser stack overflow"),
 		    &ace_yyss1, ace_yysize * sizeof (*ace_yyssp),
 		    &ace_yyvs1, ace_yysize * sizeof (*ace_yyvsp),
 		    &ace_yystacksize);
@@ -768,14 +804,14 @@
       ace_yylsp = ace_yyls + ace_yysize - 1;
 #endif
 
-      ACE_YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+      ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Stack size increased to %lu\n"),
 		  (unsigned long int) ace_yystacksize));
 
       if (ace_yyssp >= ace_yyss + ace_yystacksize - 1)
 	ACE_YYABORT;
     }
 
-  ACE_YYDPRINTF ((stderr, "Entering state %d\n", ace_yystate));
+  ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Entering state %d\n"), ace_yystate));
 
   goto ace_yybackup;
 
@@ -802,7 +838,7 @@
 
   if (ace_yychar == ACE_YYEMPTY)
     {
-      ACE_YYDPRINTF ((stderr, "Reading a token: "));
+      ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Reading a token: ")));
       ace_yychar = ACE_YYLEX;
     }
 
@@ -813,7 +849,7 @@
       ace_yychar1 = 0;
       ace_yychar = ACE_YYEOF;		/* Don't call ACE_YYLEX any more */
 
-      ACE_YYDPRINTF ((stderr, "Now at end of input.\n"));
+      ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Now at end of input.\n")));
     }
   else
     {
@@ -824,14 +860,14 @@
 	which are defined only if `ACE_YYDEBUG' is set.  */
       if (ace_yydebug)
 	{
-	  ACE_YYFPRINTF (stderr, "Next token is %d (%s",
+	  ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("Next token is %d (%s"),
 		     ace_yychar, ace_yytname[ace_yychar1]);
 	  /* Give the individual parser a way to print the precise
 	     meaning of a token, for further debugging info.  */
 # ifdef ACE_YYPRINT
 	  ACE_YYPRINT (stderr, ace_yychar, ace_yylval);
 # endif
-	  ACE_YYFPRINTF (stderr, ")\n");
+	  ACE_YYFPRINTF (stderr, ACE_LIB_TEXT (")\n"));
 	}
 #endif
     }
@@ -863,7 +899,7 @@
     ACE_YYACCEPT;
 
   /* Shift the lookahead token.  */
-  ACE_YYDPRINTF ((stderr, "Shifting token %d (%s), ",
+  ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Shifting token %d (%s), "),
 	      ace_yychar, ace_yytname[ace_yychar1]));
 
   /* Discard the token being shifted unless it is eof.  */
@@ -925,13 +961,13 @@
     {
       int ace_yyi;
 
-      ACE_YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
+      ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("Reducing via rule %d (line %d), "),
 		 ace_yyn, ace_yyrline[ace_yyn]);
 
       /* Print the symbols being reduced, and their result.  */
       for (ace_yyi = ace_yyprhs[ace_yyn]; ace_yyrhs[ace_yyi] > 0; ace_yyi++)
-	ACE_YYFPRINTF (stderr, "%s ", ace_yytname[ace_yyrhs[ace_yyi]]);
-      ACE_YYFPRINTF (stderr, " -> %s\n", ace_yytname[ace_yyr1[ace_yyn]]);
+	ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("%s "), ace_yytname[ace_yyrhs[ace_yyi]]);
+      ACE_YYFPRINTF (stderr, ACE_LIB_TEXT (" -> %s\n"), ace_yytname[ace_yyr1[ace_yyn]]);
     }
 #endif
 
@@ -1205,10 +1241,10 @@
   if (ace_yydebug)
     {
       short *ace_yyssp1 = ace_yyss - 1;
-      ACE_YYFPRINTF (stderr, "state stack now");
+      ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("state stack now"));
       while (ace_yyssp1 != ace_yyssp)
-	ACE_YYFPRINTF (stderr, " %d", *++ace_yyssp1);
-      ACE_YYFPRINTF (stderr, "\n");
+	ACE_YYFPRINTF (stderr, ACE_LIB_TEXT (" %d"), *++ace_yyssp1);
+      ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("\n"));
     }
 #endif
 
@@ -1247,47 +1283,47 @@
       if (ace_yyn > ACE_YYFLAG && ace_yyn < ACE_YYLAST)
 	{
 	  ACE_YYSIZE_T ace_yysize = 0;
-	  char *ace_yymsg;
+	  ACE_TCHAR *ace_yymsg;
 	  int ace_yyx, ace_yycount;
 
 	  ace_yycount = 0;
 	  /* Start ACE_YYX at -ACE_YYN if negative to avoid negative indexes in
 	     ACE_YYCHECK.  */
 	  for (ace_yyx = ace_yyn < 0 ? -ace_yyn : 0;
-	       ace_yyx < (int) (sizeof (ace_yytname) / sizeof (char *)); ace_yyx++)
+	       ace_yyx < (int) (sizeof (ace_yytname) / sizeof (ACE_TCHAR *)); ace_yyx++)
 	    if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx)
 	      ace_yysize += ace_yystrlen (ace_yytname[ace_yyx]) + 15, ace_yycount++;
-	  ace_yysize += ace_yystrlen ("parse error, unexpected ") + 1;
+	  ace_yysize += ace_yystrlen (ACE_LIB_TEXT ("parse error, unexpected ")) + 1;
 	  ace_yysize += ace_yystrlen (ace_yytname[ACE_YYTRANSLATE (ace_yychar)]);
-	  ace_yymsg = (char *) ACE_YYSTACK_ALLOC (ace_yysize);
+	  ace_yymsg = (ACE_TCHAR *) ACE_YYSTACK_ALLOC (ace_yysize);
 	  if (ace_yymsg != 0)
 	    {
-	      char *ace_yyp = ace_yystpcpy (ace_yymsg, "parse error, unexpected ");
+	      ACE_TCHAR *ace_yyp = ace_yystpcpy (ace_yymsg, ACE_LIB_TEXT ("parse error, unexpected "));
 	      ace_yyp = ace_yystpcpy (ace_yyp, ace_yytname[ACE_YYTRANSLATE (ace_yychar)]);
 
 	      if (ace_yycount < 5)
 		{
 		  ace_yycount = 0;
 		  for (ace_yyx = ace_yyn < 0 ? -ace_yyn : 0;
-		       ace_yyx < (int) (sizeof (ace_yytname) / sizeof (char *));
+		       ace_yyx < (int) (sizeof (ace_yytname) / sizeof (ACE_TCHAR *));
 		       ace_yyx++)
 		    if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx)
 		      {
-			const char *ace_yyq = ! ace_yycount ? ", expecting " : " or ";
+			const ACE_TCHAR *ace_yyq = ! ace_yycount ? ACE_LIB_TEXT (", expecting ") : ACE_LIB_TEXT (" or ");
 			ace_yyp = ace_yystpcpy (ace_yyp, ace_yyq);
 			ace_yyp = ace_yystpcpy (ace_yyp, ace_yytname[ace_yyx]);
 			ace_yycount++;
 		      }
 		}
-	      ace_yyerror (ace_yymsg);
+	      ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ace_yymsg);
 	      ACE_YYSTACK_FREE (ace_yymsg);
 	    }
 	  else
-	    ace_yyerror ("parse error; also virtual memory exhausted");
+	    ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ACE_LIB_TEXT ("parse error; also virtual memory exhausted"));
 	}
       else
 #endif /* defined (ACE_YYERROR_VERBOSE) */
-	ace_yyerror ("parse error");
+	ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ACE_LIB_TEXT ("parse error"));
     }
   goto ace_yyerrlab1;
 
@@ -1304,7 +1340,7 @@
       /* return failure if at end of input */
       if (ace_yychar == ACE_YYEOF)
 	ACE_YYABORT;
-      ACE_YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
+      ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Discarding token %d (%s).\n"),
 		  ace_yychar, ace_yytname[ace_yychar1]));
       ace_yychar = ACE_YYEMPTY;
     }
@@ -1350,10 +1386,10 @@
   if (ace_yydebug)
     {
       short *ace_yyssp1 = ace_yyss - 1;
-      ACE_YYFPRINTF (stderr, "Error: state stack now");
+      ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("Error: state stack now"));
       while (ace_yyssp1 != ace_yyssp)
-	ACE_YYFPRINTF (stderr, " %d", *++ace_yyssp1);
-      ACE_YYFPRINTF (stderr, "\n");
+	ACE_YYFPRINTF (stderr, ACE_LIB_TEXT (" %d"), *++ace_yyssp1);
+      ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("\n"));
     }
 #endif
 
@@ -1383,7 +1419,7 @@
   if (ace_yyn == ACE_YYFINAL)
     ACE_YYACCEPT;
 
-  ACE_YYDPRINTF ((stderr, "Shifting error token, "));
+  ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Shifting error token, ")));
 
   *++ace_yyvsp = ace_yylval;
 #if ACE_YYLSP_NEEDED
@@ -1412,7 +1448,7 @@
 | ace_yyoverflowab -- parser overflow comes here.  |
 `---------------------------------------------*/
 ace_yyoverflowlab:
-  ace_yyerror ("parser stack overflow");
+  ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ACE_LIB_TEXT ("parser stack overflow"));
   ace_yyresult = 2;
   /* Fall through.  */