ChangeLogTag: Mon Nov 12 20:26:35 2001 Krishnakumar B <kitty@cs.wustl.edu>

6 files changed, 796 insertions, 756 deletions

diff --git a/TAO/orbsvcs/tests/Concurrency/CC_command.tab.cpp b/TAO/orbsvcs/tests/Concurrency/CC_command.tab.cpp
index a2c608b30b0..6c5c63bf5f8 100644
--- a/TAO/orbsvcs/tests/Concurrency/CC_command.tab.cpp
+++ b/TAO/orbsvcs/tests/Concurrency/CC_command.tab.cpp
@@ -1,9 +1,4 @@
 // $Id$
-#ifndef lint
-char ace_cc_yysccsid[] = "@(#)yaccpar	1.4 (Berkeley) 02/25/90 \n\
- Modified 5/2/90 by J. Roskind to support graphic debugging modes";
-#endif
-#line 19 "CC_command.y"
 #include "CC_command.h"
 #include "ace/ACE.h"
 #include "orbsvcs/CosConcurrencyControlC.h"
@@ -15,172 +10,90 @@ extern int line_no;
 extern char line_buf[500];
 extern char *ace_cc_yytext;
 extern CC_CommandList *cmdlist;
-#line 32 "CC_command.y"
-typedef union {
+typedef union
+#ifdef __cplusplus
+	ACE_CC_YYSTYPE
+#endif
+ {
   CC_Command *command;
   CosConcurrencyControl::lock_mode lock_mode;
   char *id;
   int num;
 } ACE_CC_YYSTYPE;
-#line 25 "CC_command.tab.cpp"
-#define T_START_CMD 257
-#define T_CREATE_CMD 258
-#define T_LOCK_CMD 259
-#define T_UNLOCK_CMD 260
-#define T_TRYLOCK_CMD 261
-#define T_CHANGEMODE_CMD 262
-#define T_SLEEP_CMD 263
-#define T_WAIT_CMD 264
-#define T_REPEAT_CMD 265
-#define T_EXCEP_CMD 266
-#define T_PRINT_CMD 267
-#define T_LOOKUP_CMD 268
-#define T_TERM 269
-#define T_READ 270
-#define T_IREAD 271
-#define T_UPGRADE 272
-#define T_WRITE 273
-#define T_IWRITE 274
-#define T_IDENT 275
-#define Q_STRING 276
-#define T_NUM 277
-#define ACE_CC_YYERRCODE 256
-short ace_cc_yylhs[] = {                                        -1,
-    0,    0,    6,    6,    1,    1,    1,    1,    1,    1,
-    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-    1,    1,    2,    3,    4,    5,    5,    5,    5,    5,
-};
-short ace_cc_yylen[] = {                                         2,
-    0,    1,    2,    1,    3,    3,    2,    4,    3,    4,
-    3,    4,    3,    5,    4,    3,    2,    3,    3,    3,
-    3,    3,    1,    1,    1,    1,    1,    1,    1,    1,
-};
-short ace_cc_yydefred[] = {                                      0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    4,    0,   23,    0,    7,   24,    0,
-   26,   27,   28,   29,   30,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,   17,    0,    0,   25,    0,    0,
-    0,    3,    5,    6,    0,    9,    0,   11,    0,   13,
-    0,    0,   16,   18,   21,   22,   19,   20,    8,   10,
-   12,    0,   15,   14,
-};
-short ace_cc_yydgoto[] = {                                      13,
-   14,   17,   20,   39,   27,   15,
-};
-short ace_cc_yysindex[] = {                                   -254,
- -260, -239, -233, -233, -233, -233, -256, -249, -246, -252,
- -244, -242,    0,    0, -254,    0, -235,    0,    0, -234,
-    0,    0,    0,    0,    0, -222, -226, -222, -225, -222,
- -224, -222, -222, -223,    0, -216, -215,    0, -214, -213,
- -212,    0,    0,    0, -211,    0, -210,    0, -209,    0,
- -222, -208,    0,    0,    0,    0,    0,    0,    0,    0,
-    0, -207,    0,    0,
-};
-short ace_cc_yyrindex[] = {                                     63,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,   64,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,
-};
-short ace_cc_yygindex[] = {                                      0,
-   50,    0,   13,    0,   -4,    0,
-};
-#define ACE_CC_YYTABLESIZE 65
-short ace_cc_yytable[] = {                                      29,
-   31,   33,    1,    2,    3,    4,    5,    6,    7,    8,
-    9,   10,   11,   12,   16,   26,   28,   30,   32,   35,
-   34,   45,   38,   47,   41,   49,   36,   51,   52,   18,
-   37,   40,   19,   43,   44,   19,   21,   22,   23,   24,
-   25,   19,   46,   48,   50,   53,   62,   21,   22,   23,
-   24,   25,   54,   55,   56,   57,   58,   59,   60,   61,
-   63,   64,    1,    2,   42,
-};
-short ace_cc_yycheck[] = {                                       4,
-    5,    6,  257,  258,  259,  260,  261,  262,  263,  264,
-  265,  266,  267,  268,  275,    3,    4,    5,    6,  269,
-  277,   26,  275,   28,   12,   30,  276,   32,   33,  269,
-  277,  276,  275,  269,  269,  275,  270,  271,  272,  273,
-  274,  275,  269,  269,  269,  269,   51,  270,  271,  272,
-  273,  274,  269,  269,  269,  269,  269,  269,  269,  269,
-  269,  269,    0,    0,   15,
-};
-#define ACE_CC_YYFINAL 13
-#ifndef ACE_CC_YYDEBUG
-#define ACE_CC_YYDEBUG 0
+# define T_START_CMD 257
+# define T_CREATE_CMD 258
+# define T_LOCK_CMD 259
+# define T_UNLOCK_CMD 260
+# define T_TRYLOCK_CMD 261
+# define T_CHANGEMODE_CMD 262
+# define T_SLEEP_CMD 263
+# define T_WAIT_CMD 264
+# define T_REPEAT_CMD 265
+# define T_EXCEP_CMD 266
+# define T_PRINT_CMD 267
+# define T_LOOKUP_CMD 268
+# define T_TERM 269
+# define T_READ 270
+# define T_IREAD 271
+# define T_UPGRADE 272
+# define T_WRITE 273
+# define T_IWRITE 274
+# define T_IDENT 275
+# define Q_STRING 276
+# define T_NUM 277
+
+#include <inttypes.h>
+
+#ifdef __STDC__
+#include <stdlib.h>
+#include <string.h>
+#else
+#include <malloc.h>
+#include <memory.h>
 #endif
-#define ACE_CC_YYMAXTOKEN 277
-#if ACE_CC_YYDEBUG
-char *ace_cc_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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"T_START_CMD","T_CREATE_CMD",
-"T_LOCK_CMD","T_UNLOCK_CMD","T_TRYLOCK_CMD","T_CHANGEMODE_CMD","T_SLEEP_CMD",
-"T_WAIT_CMD","T_REPEAT_CMD","T_EXCEP_CMD","T_PRINT_CMD","T_LOOKUP_CMD","T_TERM",
-"T_READ","T_IREAD","T_UPGRADE","T_WRITE","T_IWRITE","T_IDENT","Q_STRING",
-"T_NUM",
-};
-char *ace_cc_yyrule[] = {
-"$accept : start",
-"start :",
-"start : cmd_list",
-"cmd_list : cmd_list cmd",
-"cmd_list : cmd",
-"cmd : T_START_CMD config_file_name T_TERM",
-"cmd : T_CREATE_CMD lock_set_name T_TERM",
-"cmd : T_CREATE_CMD T_TERM",
-"cmd : T_LOCK_CMD lock_set_name lock_mode T_TERM",
-"cmd : T_LOCK_CMD lock_mode T_TERM",
-"cmd : T_UNLOCK_CMD lock_set_name lock_mode T_TERM",
-"cmd : T_UNLOCK_CMD lock_mode T_TERM",
-"cmd : T_TRYLOCK_CMD lock_set_name lock_mode T_TERM",
-"cmd : T_TRYLOCK_CMD lock_mode T_TERM",
-"cmd : T_CHANGEMODE_CMD lock_set_name lock_mode lock_mode T_TERM",
-"cmd : T_CHANGEMODE_CMD lock_mode lock_mode T_TERM",
-"cmd : T_SLEEP_CMD T_NUM T_TERM",
-"cmd : T_WAIT_CMD T_TERM",
-"cmd : T_WAIT_CMD Q_STRING T_TERM",
-"cmd : T_PRINT_CMD Q_STRING T_TERM",
-"cmd : T_LOOKUP_CMD lock_set_name T_TERM",
-"cmd : T_REPEAT_CMD T_NUM T_TERM",
-"cmd : T_EXCEP_CMD exception_name T_TERM",
-"config_file_name : T_IDENT",
-"lock_set_name : T_IDENT",
-"exception_name : T_IDENT",
-"lock_mode : T_READ",
-"lock_mode : T_IREAD",
-"lock_mode : T_UPGRADE",
-"lock_mode : T_WRITE",
-"lock_mode : T_IWRITE",
-};
+
+#include <values.h>
+
+#if defined(__cplusplus) || defined(__STDC__)
+
+#if defined(__cplusplus) && defined(__EXTERN_C__)
+extern "C" {
 #endif
-#define ace_cc_yyclearin (ace_cc_yychar=(-1))
-#define ace_cc_yyerrok (ace_cc_yyerrflag=0)
-#ifndef ACE_CC_YYSTACKSIZE
-#ifdef ACE_CC_YYMAXDEPTH
-#define ACE_CC_YYSTACKSIZE ACE_CC_YYMAXDEPTH
-#else
-#define ACE_CC_YYSTACKSIZE 300
+#ifndef ace_cc_yyerror
+#if defined(__cplusplus)
+	void ace_cc_yyerror(const char *);
 #endif
 #endif
-int ace_cc_yydebug;
-int ace_cc_yynerrs;
-int ace_cc_yyerrflag;
-int ace_cc_yychar;
-short *ace_cc_yyssp;
-ACE_CC_YYSTYPE *ace_cc_yyvsp;
-ACE_CC_YYSTYPE ace_cc_yyval;
+#ifndef ace_cc_yylex
+	int ace_cc_yylex(void);
+#endif
+	int ace_cc_yyparse(void);
+#if defined(__cplusplus) && defined(__EXTERN_C__)
+}
+#endif
+
+#endif
+
+#define ace_cc_yyclearin ace_cc_yychar = -1
+#define ace_cc_yyerrok ace_cc_yyerrflag = 0
+extern int ace_cc_yychar;
+extern int ace_cc_yyerrflag;
 ACE_CC_YYSTYPE ace_cc_yylval;
-#define ace_cc_yystacksize ACE_CC_YYSTACKSIZE
-short ace_cc_yyss[ACE_CC_YYSTACKSIZE];
-ACE_CC_YYSTYPE ace_cc_yyvs[ACE_CC_YYSTACKSIZE];
-#line 116 "CC_command.y"
+ACE_CC_YYSTYPE ace_cc_yyval;
+typedef int ace_cc_yytabelem;
+#ifndef ACE_CC_YYMAXDEPTH
+#define ACE_CC_YYMAXDEPTH 150
+#endif
+#if ACE_CC_YYMAXDEPTH > 0
+int ace_cc_yy_ace_cc_yys[ACE_CC_YYMAXDEPTH], *ace_cc_yys = ace_cc_yy_ace_cc_yys;
+ACE_CC_YYSTYPE ace_cc_yy_ace_cc_yyv[ACE_CC_YYMAXDEPTH], *ace_cc_yyv = ace_cc_yy_ace_cc_yyv;
+#else	/* user does initial allocation */
+int *ace_cc_yys;
+ACE_CC_YYSTYPE *ace_cc_yyv;
+#endif
+static int ace_cc_yymaxdepth = ACE_CC_YYMAXDEPTH;
+# define ACE_CC_YYERRCODE 256
+
 
 void
 ace_cc_yyerror (const char *s)
@@ -192,506 +105,706 @@ ace_cc_yyerror (const char *s)
                   line_buf);
   ACE_OS::exit (-1);
 }
-#line 195 "CC_command.tab.cpp"
-#define ACE_CC_YYABORT goto ace_cc_yyabort
-#define ACE_CC_YYACCEPT goto ace_cc_yyaccept
-#define ACE_CC_YYERROR goto ace_cc_yyerrlab
-#ifdef ACE_CC_YYDEBUG
-#ifndef ACE_CC_YYDEBUG_LEXER_TEXT /* pointer to the text isolated by the lexer*/
-#define ACE_CC_YYDEBUG_LEXER_TEXT "ACE_CC_YYDEBUG_LEXER_TEXT not defined"
-#endif
-#ifndef ACE_CC_YYDEBUG_INDENT_STRING
-#define ACE_CC_YYDEBUG_INDENT_STRING  "|       "
-#endif
-#ifndef ACE_CC_YYDEBUG_REDUCE_STRING
-#define ACE_CC_YYDEBUG_REDUCE_STRING  "+-------"
-#endif
-#ifndef ACE_CC_YYDEBUG_INDENT
-#ifdef __cplusplus
-void ACE_CC_YYDEBUG_INDENT(int ace_cc_yyindent)
-#else
-ACE_CC_YYDEBUG_INDENT(ace_cc_yyindent)
-int ace_cc_yyindent;
-#endif
-{
-    while(ace_cc_yyindent-- > 0)
-        printf("%s", ACE_CC_YYDEBUG_INDENT_STRING);
-}
-#endif /* ACE_CC_YYDEBUG_INDENT */
-#ifndef ACE_CC_YYDEBUG_REDUCE
+static const ace_cc_yytabelem ace_cc_yyexca[] ={
+-1, 1,
+	0, -1,
+	-2, 0,
+	};
+# define ACE_CC_YYNPROD 31
+# define ACE_CC_YYLAST 102
+static const ace_cc_yytabelem ace_cc_yyact[]={
+
+    24,    25,    26,    27,    28,    21,     4,     5,     6,     7,
+     8,     9,    10,    11,    14,    15,    12,    13,    24,    25,
+    26,    27,    28,    40,    36,    64,    20,    35,    38,    42,
+    63,    37,    21,    21,    18,    61,    60,    59,    58,    57,
+    56,    55,    54,    53,    50,    48,    46,    44,    43,    23,
+     2,     3,     1,    19,    16,    41,    17,    30,    32,    34,
+    22,    29,    31,    33,     0,     0,     0,    39,     0,     0,
+     0,     0,    45,     0,     0,     0,     0,     0,     0,    47,
+     0,    49,     0,    51,    52,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,    62 };
+static const ace_cc_yytabelem ace_cc_yypact[]={
+
+  -251,-10000000,  -251,-10000000,  -241,  -243,  -270,  -270,  -270,  -270,
+  -250,  -245,  -248,  -242,  -254,  -246,-10000000,  -221,-10000000,  -222,
+-10000000,-10000000,  -252,  -223,-10000000,-10000000,-10000000,-10000000,-10000000,  -252,
+  -224,  -252,  -225,  -252,  -252,  -226,-10000000,  -227,  -228,  -229,
+  -230,  -231,-10000000,-10000000,-10000000,  -232,-10000000,  -233,-10000000,  -234,
+-10000000,  -252,  -239,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,-10000000,
+-10000000,-10000000,  -244,-10000000,-10000000 };
+static const ace_cc_yytabelem ace_cc_yypgo[]={
+
+     0,    51,    56,    53,    55,    49,    52,    50 };
+static const ace_cc_yytabelem ace_cc_yyr1[]={
+
+     0,     6,     6,     7,     7,     1,     1,     1,     1,     1,
+     1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
+     1,     1,     1,     2,     3,     4,     5,     5,     5,     5,
+     5 };
+static const ace_cc_yytabelem ace_cc_yyr2[]={
+
+     0,     0,     3,     5,     3,     7,     7,     5,     9,     7,
+     9,     7,     9,     7,    11,     9,     7,     5,     7,     7,
+     7,     7,     7,     3,     3,     3,     3,     3,     3,     3,
+     3 };
+static const ace_cc_yytabelem ace_cc_yychk[]={
+
+-10000000,    -6,    -7,    -1,   257,   258,   259,   260,   261,   262,
+   263,   264,   267,   268,   265,   266,    -1,    -2,   275,    -3,
+   269,   275,    -3,    -5,   270,   271,   272,   273,   274,    -3,
+    -5,    -3,    -5,    -3,    -5,   277,   269,   276,   276,    -3,
+   277,    -4,   275,   269,   269,    -5,   269,    -5,   269,    -5,
+   269,    -5,    -5,   269,   269,   269,   269,   269,   269,   269,
+   269,   269,    -5,   269,   269 };
+static const ace_cc_yytabelem ace_cc_yydef[]={
+
+     1,    -2,     2,     4,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     3,     0,    23,     0,
+     7,    24,     0,     0,    26,    27,    28,    29,    30,     0,
+     0,     0,     0,     0,     0,     0,    17,     0,     0,     0,
+     0,     0,    25,     5,     6,     0,     9,     0,    11,     0,
+    13,     0,     0,    16,    18,    19,    20,    21,    22,     8,
+    10,    12,     0,    15,    14 };
+typedef struct
 #ifdef __cplusplus
-void ACE_CC_YYDEBUG_REDUCE(int /* ace_cc_yynew_state */, 
-                           int /* ace_cc_yyrule_num */, 
-                           char *ace_cc_yyrule_string, 
-                           int ace_cc_yynew_indent, 
-                           int ace_cc_yyrhs_count)
-#else
-ACE_CC_YYDEBUG_REDUCE(ace_cc_yynew_state, ace_cc_yyrule_num, ace_cc_yyrule_string, ace_cc_yynew_indent, ace_cc_yyrhs_count)
-int ace_cc_yynew_state;
-int ace_cc_yyrule_num;
-char * ace_cc_yyrule_string;
-int ace_cc_yynew_indent;
-int ace_cc_yyrhs_count;
+	ace_cc_yytoktype
 #endif
-{
-    if (1 < ace_cc_yyrhs_count)
-    {  /* draw the graphics for the reduction */
-        ACE_CC_YYDEBUG_INDENT(ace_cc_yynew_indent);
-        while(1 < ace_cc_yyrhs_count--)
-            printf("%s", ACE_CC_YYDEBUG_REDUCE_STRING);
-        putchar('+'); /* left rotated L would look nice */
-        putchar('\n');
-        ACE_CC_YYDEBUG_INDENT(ace_cc_yynew_indent);
-        putchar('|'); /* down arrow would look nice */
-        putchar('\n');
-    }
-    ACE_CC_YYDEBUG_INDENT(ace_cc_yynew_indent);
-    /* Only print the resulting token name */
-    while (*ace_cc_yyrule_string)
-        putchar(*ace_cc_yyrule_string++);
-    putchar('\n');
-}
-#endif /* ACE_CC_YYDEBUG_REDUCE */
-#ifndef ACE_CC_YYDEBUG_SHIFT_LEXEME
-#ifdef __cplusplus
-void ACE_CC_YYDEBUG_SHIFT_LEXEME(int /* ace_cc_yyold_state */, 
-                                 int /* ace_cc_yynew_state */, 
-                                 char *ace_cc_yytoken_string, 
-                                 int ace_cc_yynew_indent)
-#else
-ACE_CC_YYDEBUG_SHIFT_LEXEME(ace_cc_yyold_state, ace_cc_yynew_state, ace_cc_yytoken_string, ace_cc_yynew_indent)
-int ace_cc_yyold_state;
-int ace_cc_yynew_state;
-char * ace_cc_yytoken_string;
-int ace_cc_yynew_indent;
+{ char *t_name; int t_val; } ace_cc_yytoktype;
+#ifndef ACE_CC_YYDEBUG
+#	define ACE_CC_YYDEBUG	0	/* don't allow debugging */
 #endif
+
+#if ACE_CC_YYDEBUG
+
+ace_cc_yytoktype ace_cc_yytoks[] =
 {
-    ACE_CC_YYDEBUG_INDENT(ace_cc_yynew_indent);
-    printf("%s <-- `%s'\n", ace_cc_yytoken_string, ACE_CC_YYDEBUG_LEXER_TEXT);
-}
-#endif /*  ACE_CC_YYDEBUG_SHIFT_LEXEME */
-#ifndef ACE_CC_YYDEBUG_LOOK_AHEAD
-#ifdef __cplusplus
-void ACE_CC_YYDEBUG_LOOK_AHEAD(int /* ace_cc_yynew_state */, 
-                               int ace_cc_yytoken_num, 
-                               char *ace_cc_yytoken_string, 
-                               int ace_cc_yyindent)
-#else
-ACE_CC_YYDEBUG_LOOK_AHEAD(ace_cc_yynew_state, ace_cc_yytoken_num, ace_cc_yytoken_string, ace_cc_yyindent)
-int ace_cc_yynew_state;
-int ace_cc_yytoken_num;
-char * ace_cc_yytoken_string;
-int ace_cc_yyindent;
-#endif
+	"T_START_CMD",	257,
+	"T_CREATE_CMD",	258,
+	"T_LOCK_CMD",	259,
+	"T_UNLOCK_CMD",	260,
+	"T_TRYLOCK_CMD",	261,
+	"T_CHANGEMODE_CMD",	262,
+	"T_SLEEP_CMD",	263,
+	"T_WAIT_CMD",	264,
+	"T_REPEAT_CMD",	265,
+	"T_EXCEP_CMD",	266,
+	"T_PRINT_CMD",	267,
+	"T_LOOKUP_CMD",	268,
+	"T_TERM",	269,
+	"T_READ",	270,
+	"T_IREAD",	271,
+	"T_UPGRADE",	272,
+	"T_WRITE",	273,
+	"T_IWRITE",	274,
+	"T_IDENT",	275,
+	"Q_STRING",	276,
+	"T_NUM",	277,
+	"-unknown-",	-1	/* ends search */
+};
+
+char * ace_cc_yyreds[] =
 {
-    ACE_CC_YYDEBUG_INDENT(ace_cc_yyindent);
-    printf("          .... look ahead at %s   `%s'\n",
-           ace_cc_yytoken_string,
-           (0 == ace_cc_yytoken_num)? "\0": ACE_CC_YYDEBUG_LEXER_TEXT);
+	"-no such reduction-",
+	"start : /* empty */",
+	"start : cmd_list",
+	"cmd_list : cmd_list cmd",
+	"cmd_list : cmd",
+	"cmd : T_START_CMD config_file_name T_TERM",
+	"cmd : T_CREATE_CMD lock_set_name T_TERM",
+	"cmd : T_CREATE_CMD T_TERM",
+	"cmd : T_LOCK_CMD lock_set_name lock_mode T_TERM",
+	"cmd : T_LOCK_CMD lock_mode T_TERM",
+	"cmd : T_UNLOCK_CMD lock_set_name lock_mode T_TERM",
+	"cmd : T_UNLOCK_CMD lock_mode T_TERM",
+	"cmd : T_TRYLOCK_CMD lock_set_name lock_mode T_TERM",
+	"cmd : T_TRYLOCK_CMD lock_mode T_TERM",
+	"cmd : T_CHANGEMODE_CMD lock_set_name lock_mode lock_mode T_TERM",
+	"cmd : T_CHANGEMODE_CMD lock_mode lock_mode T_TERM",
+	"cmd : T_SLEEP_CMD T_NUM T_TERM",
+	"cmd : T_WAIT_CMD T_TERM",
+	"cmd : T_WAIT_CMD Q_STRING T_TERM",
+	"cmd : T_PRINT_CMD Q_STRING T_TERM",
+	"cmd : T_LOOKUP_CMD lock_set_name T_TERM",
+	"cmd : T_REPEAT_CMD T_NUM T_TERM",
+	"cmd : T_EXCEP_CMD exception_name T_TERM",
+	"config_file_name : T_IDENT",
+	"lock_set_name : T_IDENT",
+	"exception_name : T_IDENT",
+	"lock_mode : T_READ",
+	"lock_mode : T_IREAD",
+	"lock_mode : T_UPGRADE",
+	"lock_mode : T_WRITE",
+	"lock_mode : T_IWRITE",
+};
+#endif /* ACE_CC_YYDEBUG */
+/*
+ * Copyright (c) 1993 by Sun Microsystems, Inc.
+ */
+
+#pragma ident	"@(#)yaccpar	6.15	97/12/08 SMI"
+
+/*
+** Skeleton parser driver for yacc output
+*/
+
+/*
+** yacc user known macros and defines
+*/
+#define ACE_CC_YYERROR		goto ace_cc_yyerrlab
+#define ACE_CC_YYACCEPT	return(0)
+#define ACE_CC_YYABORT		return(1)
+#define ACE_CC_YYBACKUP( newtoken, newvalue )\
+{\
+	if ( ace_cc_yychar >= 0 || ( ace_cc_yyr2[ ace_cc_yytmp ] >> 1 ) != 1 )\
+	{\
+		ace_cc_yyerror( "syntax error - cannot backup" );\
+		goto ace_cc_yyerrlab;\
+	}\
+	ace_cc_yychar = newtoken;\
+	ace_cc_yystate = *ace_cc_yyps;\
+	ace_cc_yylval = newvalue;\
+	goto ace_cc_yynewstate;\
 }
-#endif /* ACE_CC_YYDEBUG_LOOK_AHEAD */
-#ifndef ACE_CC_YYDEBUG_DISCARD_STATE
-#ifdef __cplusplus
-void ACE_CC_YYDEBUG_DISCARD_STATE(int /* ace_cc_yynew_state */, int ace_cc_yyindent)
-#else
-ACE_CC_YYDEBUG_DISCARD_STATE(ace_cc_yynew_state, ace_cc_yyindent)
-int ace_cc_yynew_state;
-int ace_cc_yyindent;
+#define ACE_CC_YYRECOVERING()	(!!ace_cc_yyerrflag)
+#define ACE_CC_YYNEW(type)	malloc(sizeof(type) * ace_cc_yynewmax)
+#define ACE_CC_YYCOPY(to, from, type) \
+	(type *) memcpy(to, (char *) from, ace_cc_yymaxdepth * sizeof (type))
+#define ACE_CC_YYENLARGE( from, type) \
+	(type *) realloc((char *) from, ace_cc_yynewmax * sizeof(type))
+#ifndef ACE_CC_YYDEBUG
+#	define ACE_CC_YYDEBUG	1	/* make debugging available */
 #endif
-{
-    if (0 < ace_cc_yyindent)
-    {  /* draw the graphics for the reduction */
-        ACE_CC_YYDEBUG_INDENT(ace_cc_yyindent-1);
-        printf("%s", ACE_CC_YYDEBUG_REDUCE_STRING);
-        putchar('+'); /* left rotated L would look nice */
-        printf("  discarding state\n");
-        ACE_CC_YYDEBUG_INDENT(ace_cc_yyindent-1);
-        putchar('|'); /* down arrow would look nice */
-        putchar('\n');
-    }
-    else
-    {
-        if (0 == ace_cc_yyindent)
-            printf("discarding state\n");
-        else
-            printf("no more states to discard: parser will abort\n");
-    }
-}
-#endif /* ACE_CC_YYDEBUG_DISCARD_STATE */
-#ifndef ACE_CC_YYDEBUG_DISCARD_TOKEN
-#ifdef __cplusplus
-void ACE_CC_YYDEBUG_DISCARD_TOKEN(int /* ace_cc_yynew_state */, 
-                                  int /* ace_cc_yytoken_num */, 
-                                  char *ace_cc_yytoken_string, 
-                                  int ace_cc_yyindent)
+
+/*
+** user known globals
+*/
+int ace_cc_yydebug;			/* set to 1 to get debugging */
+
+/*
+** driver internal defines
+*/
+#define ACE_CC_YYFLAG		(-10000000)
+
+/*
+** global variables used by the parser
+*/
+ACE_CC_YYSTYPE *ace_cc_yypv;			/* top of value stack */
+int *ace_cc_yyps;			/* top of state stack */
+
+int ace_cc_yystate;			/* current state */
+int ace_cc_yytmp;			/* extra var (lasts between blocks) */
+
+int ace_cc_yynerrs;			/* number of errors */
+int ace_cc_yyerrflag;			/* error recovery flag */
+int ace_cc_yychar;			/* current input token number */
+
+
+
+#ifdef ACE_CC_YYNMBCHARS
+#define ACE_CC_YYLEX()		ace_cc_yycvtok(ace_cc_yylex())
+/*
+** ace_cc_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 ace_cc_yycvtok(int i)
 #else
-ACE_CC_YYDEBUG_DISCARD_TOKEN(ace_cc_yynew_state, ace_cc_yytoken_num, ace_cc_yytoken_string, ace_cc_yyindent)
-int ace_cc_yynew_state;
-int ace_cc_yytoken_num;
-char * ace_cc_yytoken_string;
-int ace_cc_yyindent;
+int ace_cc_yycvtok(i) int i;
 #endif
 {
-    ACE_CC_YYDEBUG_INDENT(ace_cc_yyindent);
-    printf("discarding token %s\n", ace_cc_yytoken_string);
+	int first = 0;
+	int last = ACE_CC_YYNMBCHARS - 1;
+	int mid;
+	wchar_t j;
+
+	if(i&0x60000000){/*Must convert to a token. */
+		if( ace_cc_yymbchars[last].character < i ){
+			return i;/*Giving up*/
+		}
+		while ((last>=first)&&(first>=0)) {/*Binary search loop*/
+			mid = (first+last)/2;
+			j = ace_cc_yymbchars[mid].character;
+			if( j==i ){/*Found*/ 
+				return ace_cc_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 /* ACE_CC_YYDEBUG_DISCARD_TOKEN */
-#ifndef ACE_CC_YYDEBUG_SHIFT_ERROR_LEXEME
-#ifdef __cplusplus
-void ACE_CC_YYDEBUG_SHIFT_ERROR_LEXEME(int /* ace_cc_yyold_state */, 
-                                       int /* ace_cc_yynew_state */, 
-                                       int ace_cc_yyindent)
+#else/*!ACE_CC_YYNMBCHARS*/
+#define ACE_CC_YYLEX()		ace_cc_yylex()
+#endif/*!ACE_CC_YYNMBCHARS*/
+
+/*
+** ace_cc_yyparse - return 0 if worked, 1 if syntax error not recovered from
+*/
+#if defined(__STDC__) || defined(__cplusplus)
+int ace_cc_yyparse(void)
 #else
-ACE_CC_YYDEBUG_SHIFT_ERROR_LEXEME(ace_cc_yyold_state, ace_cc_yynew_state, ace_cc_yyindent)
-int ace_cc_yyold_state;
-int ace_cc_yynew_state;
-int ace_cc_yyindent;
+int ace_cc_yyparse()
 #endif
 {
-    ACE_CC_YYDEBUG_INDENT(ace_cc_yyindent);
-    printf("error\n");
-}
-#endif /* ACE_CC_YYDEBUG_SHIFT_ERROR_LEXEME */
-#endif /* ACE_CC_YYDEBUG */
-#ifdef __cplusplus
-extern "C" { extern char *ace_foo(const char *); }
-#endif
-int
-ace_cc_yyparse()
-{
-    register int ace_cc_yym, ace_cc_yyn, ace_cc_yystate;
-#if ACE_CC_YYDEBUG
-    register char *ace_cc_yys;
-#ifndef __cplusplus
-    extern char *ace_foo();
+	register ACE_CC_YYSTYPE *ace_cc_yypvt = 0;	/* top of value stack for $vars */
+
+#if defined(__cplusplus) || defined(lint)
+/*
+	hacks to please C++ and lint - goto's inside
+	switch should never be executed
+*/
+	static int __yaccpar_lint_hack__ = 0;
+	switch (__yaccpar_lint_hack__)
+	{
+		case 1: goto ace_cc_yyerrlab;
+		case 2: goto ace_cc_yynewstate;
+	}
 #endif
 
-    if (ace_cc_yys = ACE_OS::getenv("ACE_CC_YYDEBUG"))
-    {
-        ace_cc_yyn = *ace_cc_yys;
-        if (ace_cc_yyn >= '0' && ace_cc_yyn <= '9')
-            ace_cc_yydebug = ace_cc_yyn - '0';
-    }
+	/*
+	** Initialize externals - ace_cc_yyparse may be called more than once
+	*/
+	ace_cc_yypv = &ace_cc_yyv[-1];
+	ace_cc_yyps = &ace_cc_yys[-1];
+	ace_cc_yystate = 0;
+	ace_cc_yytmp = 0;
+	ace_cc_yynerrs = 0;
+	ace_cc_yyerrflag = 0;
+	ace_cc_yychar = -1;
+
+#if ACE_CC_YYMAXDEPTH <= 0
+	if (ace_cc_yymaxdepth <= 0)
+	{
+		if ((ace_cc_yymaxdepth = ACE_CC_YYEXPAND(0)) <= 0)
+		{
+			ace_cc_yyerror("yacc initialization error");
+			ACE_CC_YYABORT;
+		}
+	}
 #endif
 
-    ace_cc_yynerrs = 0;
-    ace_cc_yyerrflag = 0;
-    ace_cc_yychar = (-1);
+	{
+		register ACE_CC_YYSTYPE *ace_cc_yy_pv;	/* top of value stack */
+		register int *ace_cc_yy_ps;		/* top of state stack */
+		register int ace_cc_yy_state;		/* current state */
+		register int  ace_cc_yy_n;		/* internal state number info */
+	goto ace_cc_yystack;	/* moved from 6 lines above to here to please C++ */
+
+		/*
+		** get globals into registers.
+		** branch to here only if ACE_CC_YYBACKUP was called.
+		*/
+	ace_cc_yynewstate:
+		ace_cc_yy_pv = ace_cc_yypv;
+		ace_cc_yy_ps = ace_cc_yyps;
+		ace_cc_yy_state = ace_cc_yystate;
+		goto ace_cc_yy_newstate;
 
-    ace_cc_yyssp = ace_cc_yyss;
-    ace_cc_yyvsp = ace_cc_yyvs;
-    *ace_cc_yyssp = ace_cc_yystate = 0;
+		/*
+		** get globals into registers.
+		** either we just started, or we just finished a reduction
+		*/
+	ace_cc_yystack:
+		ace_cc_yy_pv = ace_cc_yypv;
+		ace_cc_yy_ps = ace_cc_yyps;
+		ace_cc_yy_state = ace_cc_yystate;
 
-ace_cc_yyloop:
-    if ((ace_cc_yyn = ace_cc_yydefred[ace_cc_yystate])) goto ace_cc_yyreduce;
-    if (ace_cc_yychar < 0)
-    {
-        if ((ace_cc_yychar = ace_cc_yylex()) < 0) ace_cc_yychar = 0;
+		/*
+		** top of for (;;) loop while no reductions done
+		*/
+	ace_cc_yy_stack:
+		/*
+		** put a state and value onto the stacks
+		*/
 #if ACE_CC_YYDEBUG
-        if (ace_cc_yydebug)
-        {
-            ace_cc_yys = 0;
-            if (ace_cc_yychar <= ACE_CC_YYMAXTOKEN) ace_cc_yys = ace_cc_yyname[ace_cc_yychar];
-            if (!ace_cc_yys) ace_cc_yys = "illegal-symbol";
-            if (5 < ace_cc_yydebug)
-                printf("ace_cc_yydebug: state %d, reading %d (%s)\n", ace_cc_yystate,
-                        ace_cc_yychar, ace_cc_yys);
-            else
-                ACE_CC_YYDEBUG_LOOK_AHEAD(ace_cc_yystate, ace_cc_yychar, ace_cc_yys, ace_cc_yyssp-ace_cc_yyss);
-        }
+		/*
+		** 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 ( ace_cc_yydebug )
+		{
+			register int ace_cc_yy_i;
+
+			printf( "State %d, token ", ace_cc_yy_state );
+			if ( ace_cc_yychar == 0 )
+				printf( "end-of-file\n" );
+			else if ( ace_cc_yychar < 0 )
+				printf( "-none-\n" );
+			else
+			{
+				for ( ace_cc_yy_i = 0; ace_cc_yytoks[ace_cc_yy_i].t_val >= 0;
+					ace_cc_yy_i++ )
+				{
+					if ( ace_cc_yytoks[ace_cc_yy_i].t_val == ace_cc_yychar )
+						break;
+				}
+				printf( "%s\n", ace_cc_yytoks[ace_cc_yy_i].t_name );
+			}
+		}
+#endif /* ACE_CC_YYDEBUG */
+		if ( ++ace_cc_yy_ps >= &ace_cc_yys[ ace_cc_yymaxdepth ] )	/* room on stack? */
+		{
+			/*
+			** reallocate and recover.  Note that pointers
+			** have to be reset, or bad things will happen
+			*/
+			long ace_cc_yyps_index = (ace_cc_yy_ps - ace_cc_yys);
+			long ace_cc_yypv_index = (ace_cc_yy_pv - ace_cc_yyv);
+			long ace_cc_yypvt_index = (ace_cc_yypvt - ace_cc_yyv);
+			int ace_cc_yynewmax;
+#ifdef ACE_CC_YYEXPAND
+			ace_cc_yynewmax = ACE_CC_YYEXPAND(ace_cc_yymaxdepth);
+#else
+			ace_cc_yynewmax = 2 * ace_cc_yymaxdepth;	/* double table size */
+			if (ace_cc_yymaxdepth == ACE_CC_YYMAXDEPTH)	/* first time growth */
+			{
+				char *newace_cc_yys = (char *)ACE_CC_YYNEW(int);
+				char *newace_cc_yyv = (char *)ACE_CC_YYNEW(ACE_CC_YYSTYPE);
+				if (newace_cc_yys != 0 && newace_cc_yyv != 0)
+				{
+					ace_cc_yys = ACE_CC_YYCOPY(newace_cc_yys, ace_cc_yys, int);
+					ace_cc_yyv = ACE_CC_YYCOPY(newace_cc_yyv, ace_cc_yyv, ACE_CC_YYSTYPE);
+				}
+				else
+					ace_cc_yynewmax = 0;	/* failed */
+			}
+			else				/* not first time */
+			{
+				ace_cc_yys = ACE_CC_YYENLARGE(ace_cc_yys, int);
+				ace_cc_yyv = ACE_CC_YYENLARGE(ace_cc_yyv, ACE_CC_YYSTYPE);
+				if (ace_cc_yys == 0 || ace_cc_yyv == 0)
+					ace_cc_yynewmax = 0;	/* failed */
+			}
 #endif
-    }
-    if ((ace_cc_yyn = ace_cc_yysindex[ace_cc_yystate]) && (ace_cc_yyn += ace_cc_yychar) >= 0 &&
-            ace_cc_yyn <= ACE_CC_YYTABLESIZE && ace_cc_yycheck[ace_cc_yyn] == ace_cc_yychar)
-    {
+			if (ace_cc_yynewmax <= ace_cc_yymaxdepth)	/* tables not expanded */
+			{
+				ace_cc_yyerror( "yacc stack overflow" );
+				ACE_CC_YYABORT;
+			}
+			ace_cc_yymaxdepth = ace_cc_yynewmax;
+
+			ace_cc_yy_ps = ace_cc_yys + ace_cc_yyps_index;
+			ace_cc_yy_pv = ace_cc_yyv + ace_cc_yypv_index;
+			ace_cc_yypvt = ace_cc_yyv + ace_cc_yypvt_index;
+		}
+		*ace_cc_yy_ps = ace_cc_yy_state;
+		*++ace_cc_yy_pv = ace_cc_yyval;
+
+		/*
+		** we have a new state - find out what to do
+		*/
+	ace_cc_yy_newstate:
+		if ( ( ace_cc_yy_n = ace_cc_yypact[ ace_cc_yy_state ] ) <= ACE_CC_YYFLAG )
+			goto ace_cc_yydefault;		/* simple state */
 #if ACE_CC_YYDEBUG
-        if (ace_cc_yydebug)
-            if (5 < ace_cc_yydebug)
-                printf("ace_cc_yydebug: state %d, shifting to state %d\n",
-                        ace_cc_yystate, ace_cc_yytable[ace_cc_yyn]);
-            else
-                ACE_CC_YYDEBUG_SHIFT_LEXEME(ace_cc_yystate, ace_cc_yytable[ace_cc_yyn], ace_cc_yys, ace_cc_yyssp-ace_cc_yyss);
-#endif
-        if (ace_cc_yyssp >= ace_cc_yyss + ace_cc_yystacksize - 1)
-        {
-            goto ace_cc_yyoverflow;
-        }
-        *++ace_cc_yyssp = ace_cc_yystate = ace_cc_yytable[ace_cc_yyn];
-        *++ace_cc_yyvsp = ace_cc_yylval;
-        ace_cc_yychar = (-1);
-        if (ace_cc_yyerrflag > 0)  --ace_cc_yyerrflag;
-        goto ace_cc_yyloop;
-    }
-    if ((ace_cc_yyn = ace_cc_yyrindex[ace_cc_yystate]) && (ace_cc_yyn += ace_cc_yychar) >= 0 &&
-            ace_cc_yyn <= ACE_CC_YYTABLESIZE && ace_cc_yycheck[ace_cc_yyn] == ace_cc_yychar)
-    {
-        ace_cc_yyn = ace_cc_yytable[ace_cc_yyn];
-        goto ace_cc_yyreduce;
-    }
-    if (ace_cc_yyerrflag) goto ace_cc_yyinrecovery;
-#ifdef lint
-    goto ace_cc_yynewerror;
+		/*
+		** if debugging, need to mark whether new token grabbed
+		*/
+		ace_cc_yytmp = ace_cc_yychar < 0;
 #endif
+		if ( ( ace_cc_yychar < 0 ) && ( ( ace_cc_yychar = ACE_CC_YYLEX() ) < 0 ) )
+			ace_cc_yychar = 0;		/* reached EOF */
+#if ACE_CC_YYDEBUG
+		if ( ace_cc_yydebug && ace_cc_yytmp )
+		{
+			register int ace_cc_yy_i;
 
-    ace_cc_yyerror("syntax error");
-#ifdef lint
-    goto ace_cc_yyerrlab;
-#endif
+			printf( "Received token " );
+			if ( ace_cc_yychar == 0 )
+				printf( "end-of-file\n" );
+			else if ( ace_cc_yychar < 0 )
+				printf( "-none-\n" );
+			else
+			{
+				for ( ace_cc_yy_i = 0; ace_cc_yytoks[ace_cc_yy_i].t_val >= 0;
+					ace_cc_yy_i++ )
+				{
+					if ( ace_cc_yytoks[ace_cc_yy_i].t_val == ace_cc_yychar )
+						break;
+				}
+				printf( "%s\n", ace_cc_yytoks[ace_cc_yy_i].t_name );
+			}
+		}
+#endif /* ACE_CC_YYDEBUG */
+		if ( ( ( ace_cc_yy_n += ace_cc_yychar ) < 0 ) || ( ace_cc_yy_n >= ACE_CC_YYLAST ) )
+			goto ace_cc_yydefault;
+		if ( ace_cc_yychk[ ace_cc_yy_n = ace_cc_yyact[ ace_cc_yy_n ] ] == ace_cc_yychar )	/*valid shift*/
+		{
+			ace_cc_yychar = -1;
+			ace_cc_yyval = ace_cc_yylval;
+			ace_cc_yy_state = ace_cc_yy_n;
+			if ( ace_cc_yyerrflag > 0 )
+				ace_cc_yyerrflag--;
+			goto ace_cc_yy_stack;
+		}
 
-    ++ace_cc_yynerrs;
-ace_cc_yyinrecovery:
-    if (ace_cc_yyerrflag < 3)
-    {
-        ace_cc_yyerrflag = 3;
-        for (;;)
-        {
-            if ((ace_cc_yyn = ace_cc_yysindex[*ace_cc_yyssp]) && (ace_cc_yyn += ACE_CC_YYERRCODE) >= 0 &&
-                    ace_cc_yyn <= ACE_CC_YYTABLESIZE && ace_cc_yycheck[ace_cc_yyn] == ACE_CC_YYERRCODE)
-            {
+	ace_cc_yydefault:
+		if ( ( ace_cc_yy_n = ace_cc_yydef[ ace_cc_yy_state ] ) == -2 )
+		{
 #if ACE_CC_YYDEBUG
-                if (ace_cc_yydebug)
-                    if (5 < ace_cc_yydebug)
-                        printf("ace_cc_yydebug: state %d, error recovery shifting\
- to state %d\n", *ace_cc_yyssp, ace_cc_yytable[ace_cc_yyn]);
-                    else
-                        ACE_CC_YYDEBUG_SHIFT_ERROR_LEXEME(*ace_cc_yyssp, ace_cc_yytable[ace_cc_yyn], ace_cc_yyssp-ace_cc_yyss);
+			ace_cc_yytmp = ace_cc_yychar < 0;
 #endif
-                if (ace_cc_yyssp >= ace_cc_yyss + ace_cc_yystacksize - 1)
-                {
-                    goto ace_cc_yyoverflow;
-                }
-                *++ace_cc_yyssp = ace_cc_yystate = ace_cc_yytable[ace_cc_yyn];
-                *++ace_cc_yyvsp = ace_cc_yylval;
-                goto ace_cc_yyloop;
-            }
-            else
-            {
+			if ( ( ace_cc_yychar < 0 ) && ( ( ace_cc_yychar = ACE_CC_YYLEX() ) < 0 ) )
+				ace_cc_yychar = 0;		/* reached EOF */
 #if ACE_CC_YYDEBUG
-                if (ace_cc_yydebug)
-                    if (5 < ace_cc_yydebug)
-                        printf("ace_cc_yydebug: error recovery discarding state %d\
-",
-                            *ace_cc_yyssp);
-                    else
-                        ACE_CC_YYDEBUG_DISCARD_STATE(*ace_cc_yyssp, ace_cc_yyssp-ace_cc_yyss-1);
-#endif
-                if (ace_cc_yyssp <= ace_cc_yyss) goto ace_cc_yyabort;
-                --ace_cc_yyssp;
-                --ace_cc_yyvsp;
-            }
-        }
-    }
-    else
-    {
-        if (ace_cc_yychar == 0) goto ace_cc_yyabort;
+			if ( ace_cc_yydebug && ace_cc_yytmp )
+			{
+				register int ace_cc_yy_i;
+
+				printf( "Received token " );
+				if ( ace_cc_yychar == 0 )
+					printf( "end-of-file\n" );
+				else if ( ace_cc_yychar < 0 )
+					printf( "-none-\n" );
+				else
+				{
+					for ( ace_cc_yy_i = 0;
+						ace_cc_yytoks[ace_cc_yy_i].t_val >= 0;
+						ace_cc_yy_i++ )
+					{
+						if ( ace_cc_yytoks[ace_cc_yy_i].t_val
+							== ace_cc_yychar )
+						{
+							break;
+						}
+					}
+					printf( "%s\n", ace_cc_yytoks[ace_cc_yy_i].t_name );
+				}
+			}
+#endif /* ACE_CC_YYDEBUG */
+			/*
+			** look through exception table
+			*/
+			{
+				register const int *ace_cc_yyxi = ace_cc_yyexca;
+
+				while ( ( *ace_cc_yyxi != -1 ) ||
+					( ace_cc_yyxi[1] != ace_cc_yy_state ) )
+				{
+					ace_cc_yyxi += 2;
+				}
+				while ( ( *(ace_cc_yyxi += 2) >= 0 ) &&
+					( *ace_cc_yyxi != ace_cc_yychar ) )
+					;
+				if ( ( ace_cc_yy_n = ace_cc_yyxi[1] ) < 0 )
+					ACE_CC_YYACCEPT;
+			}
+		}
+
+		/*
+		** check for syntax error
+		*/
+		if ( ace_cc_yy_n == 0 )	/* have an error */
+		{
+			/* no worry about speed here! */
+			switch ( ace_cc_yyerrflag )
+			{
+			case 0:		/* new error */
+				ace_cc_yyerror( "syntax error" );
+				goto skip_init;
+			ace_cc_yyerrlab:
+				/*
+				** get globals into registers.
+				** we have a user generated syntax type error
+				*/
+				ace_cc_yy_pv = ace_cc_yypv;
+				ace_cc_yy_ps = ace_cc_yyps;
+				ace_cc_yy_state = ace_cc_yystate;
+			skip_init:
+				ace_cc_yynerrs++;
+				/* FALLTHRU */
+			case 1:
+			case 2:		/* incompletely recovered error */
+					/* try again... */
+				ace_cc_yyerrflag = 3;
+				/*
+				** find state where "error" is a legal
+				** shift action
+				*/
+				while ( ace_cc_yy_ps >= ace_cc_yys )
+				{
+					ace_cc_yy_n = ace_cc_yypact[ *ace_cc_yy_ps ] + ACE_CC_YYERRCODE;
+					if ( ace_cc_yy_n >= 0 && ace_cc_yy_n < ACE_CC_YYLAST &&
+						ace_cc_yychk[ace_cc_yyact[ace_cc_yy_n]] == ACE_CC_YYERRCODE)					{
+						/*
+						** simulate shift of "error"
+						*/
+						ace_cc_yy_state = ace_cc_yyact[ ace_cc_yy_n ];
+						goto ace_cc_yy_stack;
+					}
+					/*
+					** current state has no shift on
+					** "error", pop stack
+					*/
 #if ACE_CC_YYDEBUG
-        if (ace_cc_yydebug)
-        {
-            ace_cc_yys = 0;
-            if (ace_cc_yychar <= ACE_CC_YYMAXTOKEN) ace_cc_yys = ace_cc_yyname[ace_cc_yychar];
-            if (!ace_cc_yys) ace_cc_yys = "illegal-symbol";
-            if (5 < ace_cc_yydebug)
-                printf("ace_cc_yydebug: state %d, error recovery discards token %d (%s)\n",
-                    ace_cc_yystate, ace_cc_yychar, ace_cc_yys);
-            else 
-                ACE_CC_YYDEBUG_DISCARD_TOKEN(ace_cc_yystate, ace_cc_yychar, ace_cc_yys, ace_cc_yyssp-ace_cc_yyss);
-        }
+#	define _POP_ "Error recovery pops state %d, uncovers state %d\n"
+					if ( ace_cc_yydebug )
+						printf( _POP_, *ace_cc_yy_ps,
+							ace_cc_yy_ps[-1] );
+#	undef _POP_
 #endif
-        ace_cc_yychar = (-1);
-        goto ace_cc_yyloop;
-    }
-ace_cc_yyreduce:
-    ace_cc_yym = ace_cc_yylen[ace_cc_yyn];
-    ace_cc_yyval = ace_cc_yyvsp[1-ace_cc_yym];
+					ace_cc_yy_ps--;
+					ace_cc_yy_pv--;
+				}
+				/*
+				** there is no state on stack with "error" as
+				** a valid shift.  give up.
+				*/
+				ACE_CC_YYABORT;
+			case 3:		/* no shift yet; eat a token */
+#if ACE_CC_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 ( ace_cc_yydebug )
+				{
+					register int ace_cc_yy_i;
+
+					printf( "Error recovery discards " );
+					if ( ace_cc_yychar == 0 )
+						printf( "token end-of-file\n" );
+					else if ( ace_cc_yychar < 0 )
+						printf( "token -none-\n" );
+					else
+					{
+						for ( ace_cc_yy_i = 0;
+							ace_cc_yytoks[ace_cc_yy_i].t_val >= 0;
+							ace_cc_yy_i++ )
+						{
+							if ( ace_cc_yytoks[ace_cc_yy_i].t_val
+								== ace_cc_yychar )
+							{
+								break;
+							}
+						}
+						printf( "token %s\n",
+							ace_cc_yytoks[ace_cc_yy_i].t_name );
+					}
+				}
+#endif /* ACE_CC_YYDEBUG */
+				if ( ace_cc_yychar == 0 )	/* reached EOF. quit */
+					ACE_CC_YYABORT;
+				ace_cc_yychar = -1;
+				goto ace_cc_yy_newstate;
+			}
+		}/* end if ( ace_cc_yy_n == 0 ) */
+		/*
+		** reduction by production ace_cc_yy_n
+		** put stack tops, etc. so things right after switch
+		*/
 #if ACE_CC_YYDEBUG
-    if (ace_cc_yydebug)
-        if (5 < ace_cc_yydebug)
-            printf("ace_cc_yydebug: state %d, reducing by rule %d (%s)\n",
-                    ace_cc_yystate, ace_cc_yyn, ace_cc_yyrule[ace_cc_yyn]);
-        else
-            ACE_CC_YYDEBUG_REDUCE(ace_cc_yystate, ace_cc_yyn, ace_cc_yyrule[ace_cc_yyn], ace_cc_yyssp-ace_cc_yyss-ace_cc_yym, ace_cc_yym);
+		/*
+		** if debugging, print the string that is the user's
+		** specification of the reduction which is just about
+		** to be done.
+		*/
+		if ( ace_cc_yydebug )
+			printf( "Reduce by (%d) \"%s\"\n",
+				ace_cc_yy_n, ace_cc_yyreds[ ace_cc_yy_n ] );
 #endif
-    switch (ace_cc_yyn)
-    {
-case 2:
-#line 52 "CC_command.y"
-{ cmdlist->add(new CC_Sleep_Cmd(0));
+		ace_cc_yytmp = ace_cc_yy_n;			/* value to switch over */
+		ace_cc_yypvt = ace_cc_yy_pv;			/* $vars top of value stack */
+		/*
+		** Look in goto table for next state
+		** Sorry about using ace_cc_yy_state here as temporary
+		** register variable, but why not, if it works...
+		** If ace_cc_yyr2[ ace_cc_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 ace_cc_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 ace_cc_yy_len = ace_cc_yyr2[ ace_cc_yy_n ];
+
+			if ( !( ace_cc_yy_len & 01 ) )
+			{
+				ace_cc_yy_len >>= 1;
+				ace_cc_yyval = ( ace_cc_yy_pv -= ace_cc_yy_len )[1];	/* $$ = $1 */
+				ace_cc_yy_state = ace_cc_yypgo[ ace_cc_yy_n = ace_cc_yyr1[ ace_cc_yy_n ] ] +
+					*( ace_cc_yy_ps -= ace_cc_yy_len ) + 1;
+				if ( ace_cc_yy_state >= ACE_CC_YYLAST ||
+					ace_cc_yychk[ ace_cc_yy_state =
+					ace_cc_yyact[ ace_cc_yy_state ] ] != -ace_cc_yy_n )
+				{
+					ace_cc_yy_state = ace_cc_yyact[ ace_cc_yypgo[ ace_cc_yy_n ] ];
+				}
+				goto ace_cc_yy_stack;
+			}
+			ace_cc_yy_len >>= 1;
+			ace_cc_yyval = ( ace_cc_yy_pv -= ace_cc_yy_len )[1];	/* $$ = $1 */
+			ace_cc_yy_state = ace_cc_yypgo[ ace_cc_yy_n = ace_cc_yyr1[ ace_cc_yy_n ] ] +
+				*( ace_cc_yy_ps -= ace_cc_yy_len ) + 1;
+			if ( ace_cc_yy_state >= ACE_CC_YYLAST ||
+				ace_cc_yychk[ ace_cc_yy_state = ace_cc_yyact[ ace_cc_yy_state ] ] != -ace_cc_yy_n )
+			{
+				ace_cc_yy_state = ace_cc_yyact[ ace_cc_yypgo[ ace_cc_yy_n ] ];
+			}
+		}
+					/* save until reenter driver code */
+		ace_cc_yystate = ace_cc_yy_state;
+		ace_cc_yyps = ace_cc_yy_ps;
+		ace_cc_yypv = ace_cc_yy_pv;
+	}
+	/*
+	** code supplied by user is placed in this switch
+	*/
+	switch( ace_cc_yytmp )
+	{
+		
+case 2:{ cmdlist->add(new CC_Sleep_Cmd(0));
 			   /* dummy to check exeption in the last command */
-		  if(cmdlist->execute()!=0) /*CC_FAIL*/
+		  if(cmdlist->execute()!=0) //CC_FAIL
                     { printf(" ** Test succeded!!\n"); }
                   else
-                    { printf(" ** Test FAILED!!\n"); } }
-break;
-case 3:
-#line 60 "CC_command.y"
-{ cmdlist->add(ace_cc_yyvsp[0].command); }
-break;
-case 4:
-#line 61 "CC_command.y"
-{ cmdlist->add(ace_cc_yyvsp[0].command); }
-break;
-case 5:
-#line 65 "CC_command.y"
-{ ace_cc_yyval.command = new CC_Start_Cmd(ace_cc_yyvsp[-1].id); }
-break;
-case 6:
-#line 67 "CC_command.y"
-{ ace_cc_yyval.command = new CC_CreateLockSet_Cmd(ace_cc_yyvsp[-1].id); }
-break;
-case 7:
-#line 69 "CC_command.y"
-{ ace_cc_yyval.command = new CC_CreateLockSet_Cmd(""); }
-break;
-case 8:
-#line 71 "CC_command.y"
-{ ace_cc_yyval.command = new CC_Lock_Cmd(ace_cc_yyvsp[-2].id, ace_cc_yyvsp[-1].lock_mode); }
-break;
-case 9:
-#line 73 "CC_command.y"
-{ ace_cc_yyval.command = new CC_Lock_Cmd("", ace_cc_yyvsp[-1].lock_mode); }
-break;
-case 10:
-#line 75 "CC_command.y"
-{ ace_cc_yyval.command = new CC_UnLock_Cmd(ace_cc_yyvsp[-2].id, ace_cc_yyvsp[-1].lock_mode); }
-break;
-case 11:
-#line 77 "CC_command.y"
-{ ace_cc_yyval.command = new CC_UnLock_Cmd("", ace_cc_yyvsp[-1].lock_mode); }
-break;
-case 12:
-#line 79 "CC_command.y"
-{ ace_cc_yyval.command = new CC_TryLock_Cmd(ace_cc_yyvsp[-2].id, ace_cc_yyvsp[-1].lock_mode); }
-break;
-case 13:
-#line 81 "CC_command.y"
-{ ace_cc_yyval.command = new CC_TryLock_Cmd("", ace_cc_yyvsp[-1].lock_mode); }
-break;
-case 14:
-#line 83 "CC_command.y"
-{ ace_cc_yyval.command = new CC_ChangeMode_Cmd(ace_cc_yyvsp[-3].id, ace_cc_yyvsp[-2].lock_mode, ace_cc_yyvsp[-1].lock_mode); }
-break;
-case 15:
-#line 85 "CC_command.y"
-{ ace_cc_yyval.command = new CC_ChangeMode_Cmd("", ace_cc_yyvsp[-2].lock_mode, ace_cc_yyvsp[-1].lock_mode); }
-break;
-case 16:
-#line 87 "CC_command.y"
-{ ace_cc_yyval.command = new CC_Sleep_Cmd(ace_cc_yyvsp[-1].num); }
-break;
-case 17:
-#line 89 "CC_command.y"
-{ ace_cc_yyval.command = new CC_Wait_Cmd(""); }
-break;
-case 18:
-#line 91 "CC_command.y"
-{ ace_cc_yyval.command = new CC_Wait_Cmd(ace_cc_yyvsp[-1].id); }
-break;
-case 19:
-#line 93 "CC_command.y"
-{ ace_cc_yyval.command = new CC_Print_Cmd(ace_cc_yyvsp[-1].id); }
-break;
-case 20:
-#line 95 "CC_command.y"
-{ ace_cc_yyval.command = new CC_Lookup_Cmd(ace_cc_yyvsp[-1].id); }
-break;
-case 21:
-#line 97 "CC_command.y"
-{ cmdlist->setrepeat(ace_cc_yyvsp[-1].num);
-                          ace_cc_yyval.command = new CC_Dummy_Cmd();}
-break;
-case 22:
-#line 100 "CC_command.y"
-{ ace_cc_yyval.command = new CC_Excep_Cmd(ace_cc_yyvsp[-1].id); }
-break;
-case 23:
-#line 103 "CC_command.y"
-{ace_cc_yyval.id = ace_cc_yyvsp[0].id; }
-break;
-case 24:
-#line 105 "CC_command.y"
-{ace_cc_yyval.id = ace_cc_yyvsp[0].id; }
-break;
-case 25:
-#line 107 "CC_command.y"
-{ace_cc_yyval.id = ace_cc_yyvsp[0].id; }
-break;
-case 26:
-#line 109 "CC_command.y"
-{ ace_cc_yyval.lock_mode = CosConcurrencyControl::read; }
-break;
-case 27:
-#line 110 "CC_command.y"
-{ ace_cc_yyval.lock_mode = CosConcurrencyControl::intention_read; }
-break;
-case 28:
-#line 111 "CC_command.y"
-{ ace_cc_yyval.lock_mode = CosConcurrencyControl::upgrade; }
-break;
-case 29:
-#line 112 "CC_command.y"
-{ ace_cc_yyval.lock_mode = CosConcurrencyControl::write; }
-break;
-case 30:
-#line 113 "CC_command.y"
-{ ace_cc_yyval.lock_mode = CosConcurrencyControl::intention_write; }
-break;
-#line 622 "CC_command.tab.cpp"
-    }
-    ace_cc_yyssp -= ace_cc_yym;
-    ace_cc_yystate = *ace_cc_yyssp;
-    ace_cc_yyvsp -= ace_cc_yym;
-    ace_cc_yym = ace_cc_yylhs[ace_cc_yyn];
-    if (ace_cc_yystate == 0 && ace_cc_yym == 0)
-    {
-#ifdef ACE_CC_YYDEBUG
-        if (5 < ace_cc_yydebug)
-            printf("ace_cc_yydebug: after reduction, shifting from state 0 to\
- state %d\n", ACE_CC_YYFINAL);
-#endif
-        ace_cc_yystate = ACE_CC_YYFINAL;
-        *++ace_cc_yyssp = ACE_CC_YYFINAL;
-        *++ace_cc_yyvsp = ace_cc_yyval;
-        if (ace_cc_yychar < 0)
-        {
-            if ((ace_cc_yychar = ace_cc_yylex()) < 0) ace_cc_yychar = 0;
-#if ACE_CC_YYDEBUG
-            if (ace_cc_yydebug)
-            {
-                ace_cc_yys = 0;
-                if (ace_cc_yychar <= ACE_CC_YYMAXTOKEN) ace_cc_yys = ace_cc_yyname[ace_cc_yychar];
-                if (!ace_cc_yys) ace_cc_yys = "illegal-symbol";
-                if (5 < ace_cc_yydebug)
-                    printf("ace_cc_yydebug: state %d, reading %d (%s)\n",
-                        ACE_CC_YYFINAL, ace_cc_yychar, ace_cc_yys);
-                else
-                    ACE_CC_YYDEBUG_LOOK_AHEAD(ACE_CC_YYFINAL, ace_cc_yychar, ace_cc_yys, ace_cc_yyssp-ace_cc_yyss);
-            }
-#endif
-        }
-        if (ace_cc_yychar == 0) goto ace_cc_yyaccept;
-        goto ace_cc_yyloop;
-    }
-    if ((ace_cc_yyn = ace_cc_yygindex[ace_cc_yym]) && (ace_cc_yyn += ace_cc_yystate) >= 0 &&
-            ace_cc_yyn <= ACE_CC_YYTABLESIZE && ace_cc_yycheck[ace_cc_yyn] == ace_cc_yystate)
-        ace_cc_yystate = ace_cc_yytable[ace_cc_yyn];
-    else
-        ace_cc_yystate = ace_cc_yydgoto[ace_cc_yym];
-#ifdef ACE_CC_YYDEBUG
-    if (5 < ace_cc_yydebug)
-        printf("ace_cc_yydebug: after reduction, shifting from state %d \
-to state %d\n", *ace_cc_yyssp, ace_cc_yystate);
-#endif
-    if (ace_cc_yyssp >= ace_cc_yyss + ace_cc_yystacksize - 1)
-    {
-        goto ace_cc_yyoverflow;
-    }
-    *++ace_cc_yyssp = ace_cc_yystate;
-    *++ace_cc_yyvsp = ace_cc_yyval;
-    goto ace_cc_yyloop;
-ace_cc_yyoverflow:
-    ace_cc_yyerror("yacc stack overflow");
-ace_cc_yyabort:
-    return (1);
-ace_cc_yyaccept:
-    return (0);
+                    { printf(" ** Test FAILED!!\n"); } } break;
+case 3:{ cmdlist->add(ace_cc_yypvt[-0].command); } break;
+case 4:{ cmdlist->add(ace_cc_yypvt[-0].command); } break;
+case 5:{ ace_cc_yyval.command = new CC_Start_Cmd(ace_cc_yypvt[-1].id); } break;
+case 6:{ ace_cc_yyval.command = new CC_CreateLockSet_Cmd(ace_cc_yypvt[-1].id); } break;
+case 7:{ ace_cc_yyval.command = new CC_CreateLockSet_Cmd(""); } break;
+case 8:{ ace_cc_yyval.command = new CC_Lock_Cmd(ace_cc_yypvt[-2].id, ace_cc_yypvt[-1].lock_mode); } break;
+case 9:{ ace_cc_yyval.command = new CC_Lock_Cmd("", ace_cc_yypvt[-1].lock_mode); } break;
+case 10:{ ace_cc_yyval.command = new CC_UnLock_Cmd(ace_cc_yypvt[-2].id, ace_cc_yypvt[-1].lock_mode); } break;
+case 11:{ ace_cc_yyval.command = new CC_UnLock_Cmd("", ace_cc_yypvt[-1].lock_mode); } break;
+case 12:{ ace_cc_yyval.command = new CC_TryLock_Cmd(ace_cc_yypvt[-2].id, ace_cc_yypvt[-1].lock_mode); } break;
+case 13:{ ace_cc_yyval.command = new CC_TryLock_Cmd("", ace_cc_yypvt[-1].lock_mode); } break;
+case 14:{ ace_cc_yyval.command = new CC_ChangeMode_Cmd(ace_cc_yypvt[-3].id, ace_cc_yypvt[-2].lock_mode, ace_cc_yypvt[-1].lock_mode); } break;
+case 15:{ ace_cc_yyval.command = new CC_ChangeMode_Cmd("", ace_cc_yypvt[-2].lock_mode, ace_cc_yypvt[-1].lock_mode); } break;
+case 16:{ ace_cc_yyval.command = new CC_Sleep_Cmd(ace_cc_yypvt[-1].num); } break;
+case 17:{ ace_cc_yyval.command = new CC_Wait_Cmd(""); } break;
+case 18:{ ace_cc_yyval.command = new CC_Wait_Cmd(ace_cc_yypvt[-1].id); } break;
+case 19:{ ace_cc_yyval.command = new CC_Print_Cmd(ace_cc_yypvt[-1].id); } break;
+case 20:{ ace_cc_yyval.command = new CC_Lookup_Cmd(ace_cc_yypvt[-1].id); } break;
+case 21:{ cmdlist->setrepeat(ace_cc_yypvt[-1].num);
+                          ace_cc_yyval.command = new CC_Dummy_Cmd();} break;
+case 22:{ ace_cc_yyval.command = new CC_Excep_Cmd(ace_cc_yypvt[-1].id); } break;
+case 23:{ace_cc_yyval.id = ace_cc_yypvt[-0].id; } break;
+case 24:{ace_cc_yyval.id = ace_cc_yypvt[-0].id; } break;
+case 25:{ace_cc_yyval.id = ace_cc_yypvt[-0].id; } break;
+case 26:{ ace_cc_yyval.lock_mode = CosConcurrencyControl::read; } break;
+case 27:{ ace_cc_yyval.lock_mode = CosConcurrencyControl::intention_read; } break;
+case 28:{ ace_cc_yyval.lock_mode = CosConcurrencyControl::upgrade; } break;
+case 29:{ ace_cc_yyval.lock_mode = CosConcurrencyControl::write; } break;
+case 30:{ ace_cc_yyval.lock_mode = CosConcurrencyControl::intention_write; } break;
+	}
+	goto ace_cc_yystack;		/* reset registers in driver code */
 }
+
diff --git a/TAO/orbsvcs/tests/Concurrency/CC_command.tab.cpp.diff b/TAO/orbsvcs/tests/Concurrency/CC_command.tab.cpp.diff
index 1106e37cff4..04e1ca0e7b2 100644
--- a/TAO/orbsvcs/tests/Concurrency/CC_command.tab.cpp.diff
+++ b/TAO/orbsvcs/tests/Concurrency/CC_command.tab.cpp.diff
@@ -2,24 +2,3 @@
 +++ CC_command.tab.cpp	Mon Aug 17 11:06:24 1998
 @@ -1,3 +1,4 @@
 +// $Id$
- #ifndef lint
- char ace_cc_yysccsid[] = "@(#)yaccpar	1.4 (Berkeley) 02/25/90 \n\
-  Modified 5/2/90 by J. Roskind to support graphic debugging modes";
-@@ -367,7 +368,7 @@
-     *ace_cc_yyssp = ace_cc_yystate = 0;
- 
- ace_cc_yyloop:
--    if (ace_cc_yyn = ace_cc_yydefred[ace_cc_yystate]) goto ace_cc_yyreduce;
-+    if ((ace_cc_yyn = ace_cc_yydefred[ace_cc_yystate])) goto ace_cc_yyreduce;
-     if (ace_cc_yychar < 0)
-     {
-         if ((ace_cc_yychar = ace_cc_yylex()) < 0) ace_cc_yychar = 0;
-@@ -421,7 +422,7 @@
- #ifdef lint
-     goto ace_cc_yyerrlab;
- #endif
--ace_cc_yyerrlab:
-+
-     ++ace_cc_yynerrs;
- ace_cc_yyinrecovery:
-     if (ace_cc_yyerrflag < 3)
diff --git a/TAO/orbsvcs/tests/Concurrency/CC_command.tab.h b/TAO/orbsvcs/tests/Concurrency/CC_command.tab.h
index 31c03ff7ffc..045368d0674 100644
--- a/TAO/orbsvcs/tests/Concurrency/CC_command.tab.h
+++ b/TAO/orbsvcs/tests/Concurrency/CC_command.tab.h
@@ -1,29 +1,33 @@
 // $Id$
-#define T_START_CMD 257
-#define T_CREATE_CMD 258
-#define T_LOCK_CMD 259
-#define T_UNLOCK_CMD 260
-#define T_TRYLOCK_CMD 261
-#define T_CHANGEMODE_CMD 262
-#define T_SLEEP_CMD 263
-#define T_WAIT_CMD 264
-#define T_REPEAT_CMD 265
-#define T_EXCEP_CMD 266
-#define T_PRINT_CMD 267
-#define T_LOOKUP_CMD 268
-#define T_TERM 269
-#define T_READ 270
-#define T_IREAD 271
-#define T_UPGRADE 272
-#define T_WRITE 273
-#define T_IWRITE 274
-#define T_IDENT 275
-#define Q_STRING 276
-#define T_NUM 277
-typedef union {
+typedef union
+#ifdef __cplusplus
+	ACE_CC_YYSTYPE
+#endif
+ {
   CC_Command *command;
   CosConcurrencyControl::lock_mode lock_mode;
   char *id;
   int num;
 } ACE_CC_YYSTYPE;
 extern ACE_CC_YYSTYPE ace_cc_yylval;
+# define T_START_CMD 257
+# define T_CREATE_CMD 258
+# define T_LOCK_CMD 259
+# define T_UNLOCK_CMD 260
+# define T_TRYLOCK_CMD 261
+# define T_CHANGEMODE_CMD 262
+# define T_SLEEP_CMD 263
+# define T_WAIT_CMD 264
+# define T_REPEAT_CMD 265
+# define T_EXCEP_CMD 266
+# define T_PRINT_CMD 267
+# define T_LOOKUP_CMD 268
+# define T_TERM 269
+# define T_READ 270
+# define T_IREAD 271
+# define T_UPGRADE 272
+# define T_WRITE 273
+# define T_IWRITE 274
+# define T_IDENT 275
+# define Q_STRING 276
+# define T_NUM 277
diff --git a/TAO/orbsvcs/tests/Concurrency/Makefile b/TAO/orbsvcs/tests/Concurrency/Makefile
index c74623a8b21..a55b051975f 100644
--- a/TAO/orbsvcs/tests/Concurrency/Makefile
+++ b/TAO/orbsvcs/tests/Concurrency/Makefile
@@ -63,7 +63,7 @@ lex.CC_command.cpp:     CC_command.l CC_command.tab.h
 .PHONY: lex.CC_command.cpp.target
 
 lex.CC_command.cpp.target:
-		$(LEX) -t -I CC_command.l > /tmp/$(USER).CC_L1
+		$(LEX) -L -t -I CC_command.l > /tmp/$(USER).CC_L1
 		sed -e "s/unistd/stdio/g" \
 	        -e "s/\\$$\(Header[^$$]*\) \\$$/\\1/" \
 		-e "s/yy/ace_cc_yy/g" \
@@ -87,7 +87,7 @@ CC_command.tab.cpp CC_command.tab.h: CC_command.y
 .PHONY: CC_command.tab
 
 CC_command.tab: CC_command.y
-		$(YACC) -d CC_command.y
+		$(YACC) -d -l CC_command.y
 		sed -e "s/char \*getenv/char *ace_foo/g" \
 		    -e "s/= getenv/= ACE_OS::getenv/g" \
 		    -e "s/yynewerror://g" \
diff --git a/TAO/orbsvcs/tests/Concurrency/lex.CC_command.cpp b/TAO/orbsvcs/tests/Concurrency/lex.CC_command.cpp
index 10caa1379d4..c81ff1ae2ea 100644
--- a/TAO/orbsvcs/tests/Concurrency/lex.CC_command.cpp
+++ b/TAO/orbsvcs/tests/Concurrency/lex.CC_command.cpp
@@ -439,7 +439,6 @@ static char *ace_cc_yy_last_accepting_cpos;
 #define ACE_CC_YY_MORE_ADJ 0
 #define ACE_CC_YY_RESTORE_ACE_CC_YY_MORE_OFFSET
 char *ace_cc_yytext;
-#line 1 "CC_command.l"
 #define INITIAL 0
 /* $id$
  * ============================================================================
@@ -461,7 +460,6 @@ char *ace_cc_yytext;
 #define ACE_CC_YY_NO_UNPUT 1
 #define ACE_CC_YY_NO_INPUT 1
 #define ACE_CC_YY_ALWAYS_INTERACTIVE 1
-#line 20 "CC_command.l"
 #include "CC_command.h"
 #include "CC_command.tab.h"
 #include "ace/ACE.h"
@@ -621,7 +619,6 @@ ACE_CC_YY_DECL
 	register char *ace_cc_yy_cp, *ace_cc_yy_bp;
 	register int ace_cc_yy_act;
 
-#line 28 "CC_command.l"
 
 
 
@@ -711,132 +708,107 @@ do_action:	/* This label is used only to access EOF actions. */
 
 case 1:
 ACE_CC_YY_RULE_SETUP
-#line 30 "CC_command.l"
 return T_TERM;
 	/* ACE_CC_YY_BREAK */
 case 2:
 ACE_CC_YY_RULE_SETUP
-#line 31 "CC_command.l"
 return T_START_CMD;
 	/* ACE_CC_YY_BREAK */
 case 3:
 ACE_CC_YY_RULE_SETUP
-#line 32 "CC_command.l"
 return T_CREATE_CMD;
 	/* ACE_CC_YY_BREAK */
 case 4:
 ACE_CC_YY_RULE_SETUP
-#line 33 "CC_command.l"
 return T_LOCK_CMD;
 	/* ACE_CC_YY_BREAK */
 case 5:
 ACE_CC_YY_RULE_SETUP
-#line 34 "CC_command.l"
 return T_UNLOCK_CMD;
 	/* ACE_CC_YY_BREAK */
 case 6:
 ACE_CC_YY_RULE_SETUP
-#line 35 "CC_command.l"
 return T_TRYLOCK_CMD;
 	/* ACE_CC_YY_BREAK */
 case 7:
 ACE_CC_YY_RULE_SETUP
-#line 36 "CC_command.l"
 return T_CHANGEMODE_CMD;
 	/* ACE_CC_YY_BREAK */
 case 8:
 ACE_CC_YY_RULE_SETUP
-#line 37 "CC_command.l"
 return T_SLEEP_CMD;
 	/* ACE_CC_YY_BREAK */
 case 9:
 ACE_CC_YY_RULE_SETUP
-#line 38 "CC_command.l"
 return T_WAIT_CMD;
 	/* ACE_CC_YY_BREAK */
 case 10:
 ACE_CC_YY_RULE_SETUP
-#line 39 "CC_command.l"
 return T_PRINT_CMD;
 	/* ACE_CC_YY_BREAK */
 case 11:
 ACE_CC_YY_RULE_SETUP
-#line 40 "CC_command.l"
 return T_REPEAT_CMD;
 	/* ACE_CC_YY_BREAK */
 case 12:
 ACE_CC_YY_RULE_SETUP
-#line 41 "CC_command.l"
 return T_EXCEP_CMD;
 	/* ACE_CC_YY_BREAK */
 case 13:
 ACE_CC_YY_RULE_SETUP
-#line 42 "CC_command.l"
 return T_LOOKUP_CMD;
 	/* ACE_CC_YY_BREAK */
 case 14:
 ACE_CC_YY_RULE_SETUP
-#line 43 "CC_command.l"
 return T_READ;
 	/* ACE_CC_YY_BREAK */
 case 15:
 ACE_CC_YY_RULE_SETUP
-#line 44 "CC_command.l"
 return T_IREAD;
 	/* ACE_CC_YY_BREAK */
 case 16:
 ACE_CC_YY_RULE_SETUP
-#line 45 "CC_command.l"
 return T_UPGRADE;
 	/* ACE_CC_YY_BREAK */
 case 17:
 ACE_CC_YY_RULE_SETUP
-#line 46 "CC_command.l"
 return T_WRITE;
 	/* ACE_CC_YY_BREAK */
 case 18:
 ACE_CC_YY_RULE_SETUP
-#line 47 "CC_command.l"
 return T_IWRITE;
 	/* ACE_CC_YY_BREAK */
 case 19:
 ACE_CC_YY_RULE_SETUP
-#line 48 "CC_command.l"
 { ace_cc_yylval.id = ACE_OS::strdup(&ace_cc_yytext[1]);
 			 ace_cc_yylval.id[ace_cc_yyleng-2]='\0';
 			 return Q_STRING; }
 	/* ACE_CC_YY_BREAK */
 case 20:
 ACE_CC_YY_RULE_SETUP
-#line 51 "CC_command.l"
 { ace_cc_yylval.num = atoi(ace_cc_yytext); return T_NUM; }
 	/* ACE_CC_YY_BREAK */
 case 21:
 ACE_CC_YY_RULE_SETUP
-#line 52 "CC_command.l"
 { ace_cc_yylval.id = ACE_OS::strdup(ace_cc_yytext);
                            return T_IDENT; }
 	/* ACE_CC_YY_BREAK */
 case 22:
 ACE_CC_YY_RULE_SETUP
-#line 54 "CC_command.l"
 { }
 	ACE_CC_YY_BREAK
 case 23:
 ACE_CC_YY_RULE_SETUP
-#line 55 "CC_command.l"
 { }
 	ACE_CC_YY_BREAK
 case 24:
 ACE_CC_YY_RULE_SETUP
-#line 56 "CC_command.l"
 { line_no ++;
                            ACE_OS::strcpy(line_buf, ace_cc_yytext+1);
                            ace_cc_yyless(1); }
 	ACE_CC_YY_BREAK
 case 25:
 ACE_CC_YY_RULE_SETUP
-#line 59 "CC_command.l"
 ACE_CC_ECHO;
 	ACE_CC_YY_BREAK
 case ACE_CC_YY_STATE_EOF(INITIAL):
@@ -1733,4 +1705,3 @@ int main()
 	return 0;
 	}
 #endif
-#line 59 "CC_command.l"
diff --git a/TAO/orbsvcs/tests/Concurrency/lex.CC_command.cpp.diff b/TAO/orbsvcs/tests/Concurrency/lex.CC_command.cpp.diff
index 1ae48a74947..486f965868c 100644
--- a/TAO/orbsvcs/tests/Concurrency/lex.CC_command.cpp.diff
+++ b/TAO/orbsvcs/tests/Concurrency/lex.CC_command.cpp.diff
@@ -1,5 +1,5 @@
---- lex.CC_command.cpp.orig	Wed Apr 12 15:18:40 2000
-+++ lex.CC_command.cpp	Wed Apr 12 15:30:33 2000
+--- lex.CC_command.cpp.orig	Mon Nov 12 19:05:12 2001
++++ lex.CC_command.cpp	Mon Nov 12 19:14:49 2001
 @@ -1,5 +1,5 @@
  /* A lexical scanner generated by flex */
 -
@@ -10,7 +10,7 @@
 @@ -220,10 +220,13 @@
  static int ace_cc_yy_init = 1;		/* whether we need to initialize */
  static int ace_cc_yy_start = 0;	/* start state number */
-
+ 
 +#define ace_cc_yywrap() 1
  /* Flag which is used to allow ace_cc_yywrap()'s to do buffer switches
   * instead of setting up a fresh ace_cc_yyin.  A bit of a hack ...
@@ -18,146 +18,119 @@
 +#if (ace_cc_yywrap() != 1)
  static int ace_cc_yy_did_buffer_switch_on_eof;
 +#endif
-
+ 
  void ace_cc_yyrestart ACE_CC_YY_PROTO(( FILE *input_file ));
-
+ 
 @@ -262,7 +265,6 @@
  #define ACE_CC_YY_AT_BOL() (ace_cc_yy_current_buffer->ace_cc_yy_at_bol)
-
-
+ 
+ 
 -#define ace_cc_yywrap() 1
  #define ACE_CC_YY_SKIP_ACE_CC_YYWRAP
  typedef unsigned char ACE_CC_YY_CHAR;
  FILE *ace_cc_yyin = (FILE *) 0, *ace_cc_yyout = (FILE *) 0;
-@@ -616,7 +618,7 @@
- ACE_CC_YY_DECL
- 	{
- 	register ace_cc_yy_state_type ace_cc_yy_current_state;
--	register char *ace_cc_yy_cp = NULL, *ace_cc_yy_bp = NULL;
-+	register char *ace_cc_yy_cp, *ace_cc_yy_bp;
- 	register int ace_cc_yy_act;
-
- #line 28 "CC_command.l"
-@@ -647,6 +649,8 @@
+@@ -644,6 +646,8 @@
  		ace_cc_yy_load_buffer_state();
  		}
-
+ 
 +        ace_cc_yy_cp = ace_cc_yy_bp = 0; /* To avoid g++ warning about
 +                                            possible uninitialized use. */
  	while ( 1 )		/* loops until end-of-file is reached */
  		{
  		ace_cc_yy_cp = ace_cc_yy_c_buf_p;
-@@ -709,110 +713,110 @@
+@@ -705,90 +709,90 @@
+ case 1:
  ACE_CC_YY_RULE_SETUP
- #line 30 "CC_command.l"
  return T_TERM;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 2:
  ACE_CC_YY_RULE_SETUP
- #line 31 "CC_command.l"
  return T_START_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 3:
  ACE_CC_YY_RULE_SETUP
- #line 32 "CC_command.l"
  return T_CREATE_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 4:
  ACE_CC_YY_RULE_SETUP
- #line 33 "CC_command.l"
  return T_LOCK_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 5:
  ACE_CC_YY_RULE_SETUP
- #line 34 "CC_command.l"
  return T_UNLOCK_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 6:
  ACE_CC_YY_RULE_SETUP
- #line 35 "CC_command.l"
  return T_TRYLOCK_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 7:
  ACE_CC_YY_RULE_SETUP
- #line 36 "CC_command.l"
  return T_CHANGEMODE_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 8:
  ACE_CC_YY_RULE_SETUP
- #line 37 "CC_command.l"
  return T_SLEEP_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 9:
  ACE_CC_YY_RULE_SETUP
- #line 38 "CC_command.l"
  return T_WAIT_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 10:
  ACE_CC_YY_RULE_SETUP
- #line 39 "CC_command.l"
  return T_PRINT_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 11:
  ACE_CC_YY_RULE_SETUP
- #line 40 "CC_command.l"
  return T_REPEAT_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 12:
  ACE_CC_YY_RULE_SETUP
- #line 41 "CC_command.l"
  return T_EXCEP_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 13:
  ACE_CC_YY_RULE_SETUP
- #line 42 "CC_command.l"
  return T_LOOKUP_CMD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 14:
  ACE_CC_YY_RULE_SETUP
- #line 43 "CC_command.l"
  return T_READ;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 15:
  ACE_CC_YY_RULE_SETUP
- #line 44 "CC_command.l"
  return T_IREAD;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 16:
  ACE_CC_YY_RULE_SETUP
- #line 45 "CC_command.l"
  return T_UPGRADE;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 17:
  ACE_CC_YY_RULE_SETUP
- #line 46 "CC_command.l"
  return T_WRITE;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 18:
  ACE_CC_YY_RULE_SETUP
- #line 47 "CC_command.l"
  return T_IWRITE;
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 19:
  ACE_CC_YY_RULE_SETUP
- #line 48 "CC_command.l"
  { ace_cc_yylval.id = ACE_OS::strdup(&ace_cc_yytext[1]);
  			 ace_cc_yylval.id[ace_cc_yyleng-2]='\0';
  			 return Q_STRING; }
@@ -165,32 +138,30 @@
 +	/* ACE_CC_YY_BREAK */
  case 20:
  ACE_CC_YY_RULE_SETUP
- #line 51 "CC_command.l"
  { ace_cc_yylval.num = atoi(ace_cc_yytext); return T_NUM; }
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 21:
  ACE_CC_YY_RULE_SETUP
- #line 52 "CC_command.l"
  { ace_cc_yylval.id = ACE_OS::strdup(ace_cc_yytext);
                             return T_IDENT; }
 -	ACE_CC_YY_BREAK
 +	/* ACE_CC_YY_BREAK */
  case 22:
  ACE_CC_YY_RULE_SETUP
- #line 54 "CC_command.l"
-@@ -910,7 +914,9 @@
+ { }
+@@ -882,7 +886,9 @@
  			{
  			case EOB_ACT_END_OF_FILE:
  				{
 +#if (ace_cc_yywrap() != 1)
  				ace_cc_yy_did_buffer_switch_on_eof = 0;
 +#endif
-
+ 
  				if ( ace_cc_yywrap() )
  					{
-@@ -931,8 +937,10 @@
-
+@@ -903,8 +909,10 @@
+ 
  				else
  					{
 +#if (ace_cc_yywrap() != 1)
@@ -200,19 +171,19 @@
  					}
  				break;
  				}
-@@ -1216,7 +1224,7 @@
+@@ -1188,7 +1196,7 @@
  	}
  #endif	/* ifndef ACE_CC_YY_NO_UNPUT */
-
+ 
 -
 +#ifndef ACE_CC_YY_NO_INPUT
  #ifdef __cplusplus
  static int ace_cc_yyinput()
  #else
-@@ -1265,13 +1273,13 @@
+@@ -1237,13 +1245,13 @@
  					if ( ace_cc_yywrap() )
  						return EOF;
-
+ 
 -					if ( ! ace_cc_yy_did_buffer_switch_on_eof )
 +                                        /*					if ( ! ace_cc_yy_did_buffer_switch_on_eof )
  						ACE_CC_YY_NEW_FILE;
@@ -223,17 +194,17 @@
 -#endif
 +                                        #endif */
  					}
-
+ 
  				case EOB_ACT_CONTINUE_SCAN:
-@@ -1289,6 +1297,7 @@
-
+@@ -1261,6 +1269,7 @@
+ 
  	return c;
  	}
 +#endif /* ! ACE_CC_YY_NO_INPUT */
-
-
+ 
+ 
  #ifdef ACE_CC_YY_USE_PROTOS
-@@ -1332,7 +1341,9 @@
+@@ -1304,7 +1313,9 @@
  	 * is looked at is after ace_cc_yywrap() is called, so it's safe
  	 * to go ahead and always set it.
  	 */
@@ -241,3 +212,5 @@
  	ace_cc_yy_did_buffer_switch_on_eof = 1;
 +#endif
  	}
+ 
+