Svc_Conf_y.cpp

Go to the documentation of this file.
00001 /* A Bison parser, made by GNU Bison 2.0.  */
00002  
00003 /* Skeleton parser for Yacc-like parsing with Bison,
00004    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
00005 
00006    This program is free software; you can redistribute it and/or modify
00007    it under the terms of the GNU General Public License as published by
00008    the Free Software Foundation; either version 2, or (at your option)
00009    any later version.
00010 
00011    This program is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014    GNU General Public License for more details.
00015 
00016    You should have received a copy of the GNU General Public License
00017    along with this program; if not, write to the Free Software
00018    Foundation, Inc., 59 Temple Place - Suite 330,
00019    Boston, MA 02111-1307, USA.  */
00020 
00021 /* As a special exception, when this file is copied by Bison into a
00022    Bison output file, you may use that output file without restriction.
00023    This special exception was added by the Free Software Foundation
00024    in version 1.24 of Bison.  */
00025 
00026 /* Written by Richard Stallman by simplifying the original so called
00027    ``semantic'' parser.  */
00028 
00029 /* All symbols defined below should begin with ace_yy or ACE_YY, to avoid
00030    infringing on user name space.  This should be done even for local
00031    variables, as they might otherwise be expanded by user macros.
00032    There are some unavoidable exceptions within include files to
00033    define necessary library symbols; they are noted "INFRINGES ON
00034    USER NAME SPACE" below.  */
00035 
00036 /* Identify Bison output.  */
00037 #define ACE_YYBISON 1
00038 
00039 /* Skeleton name.  */
00040 #define ACE_YYSKELETON_NAME "yacc.c"
00041 
00042 /* Pure parsers.  */
00043 #define ACE_YYPURE 1
00044 
00045 /* Using locations.  */
00046 #define ACE_YYLSP_NEEDED 0
00047 
00048 /* On HP-UX aC++ on Itanium, disable warning 2111, statement is unreachable. */
00049 #if defined (__HP_aCC) && defined (__ia64)
00050 #  pragma diag_suppress 2111
00051 #endif
00052 
00053 /* Tokens.  */
00054 #ifndef ACE_YYTOKENTYPE
00055 # define ACE_YYTOKENTYPE
00056    /* Put the tokens into the symbol table, so that GDB and other debuggers
00057       know about them.  */
00058    enum ace_yytokentype {
00059      ACE_DYNAMIC = 258,
00060      ACE_STATIC = 259,
00061      ACE_SUSPEND = 260,
00062      ACE_RESUME = 261,
00063      ACE_REMOVE = 262,
00064      ACE_USTREAM = 263,
00065      ACE_MODULE_T = 264,
00066      ACE_STREAM_T = 265,
00067      ACE_SVC_OBJ_T = 266,
00068      ACE_ACTIVE = 267,
00069      ACE_INACTIVE = 268,
00070      ACE_PATHNAME = 269,
00071      ACE_IDENT = 270,
00072      ACE_STRING = 271
00073    };
00074 #endif
00075 #define ACE_DYNAMIC 258
00076 #define ACE_STATIC 259
00077 #define ACE_SUSPEND 260
00078 #define ACE_RESUME 261
00079 #define ACE_REMOVE 262
00080 #define ACE_USTREAM 263
00081 #define ACE_MODULE_T 264
00082 #define ACE_STREAM_T 265
00083 #define ACE_SVC_OBJ_T 266
00084 #define ACE_ACTIVE 267
00085 #define ACE_INACTIVE 268
00086 #define ACE_PATHNAME 269
00087 #define ACE_IDENT 270
00088 #define ACE_STRING 271
00089 
00090 
00091 
00092 
00093 /* Copy the first part of user declarations.  */
00094 
00095 
00096 // $Id: Svc_Conf_y.cpp 79341 2007-08-14 18:09:18Z sowayaa $
00097 
00098 #include "ace/Svc_Conf.h"
00099 
00100 #if (ACE_USES_CLASSIC_SVC_CONF == 1)
00101 
00102 #include "ace/ARGV.h"
00103 #include "ace/Module.h"
00104 #include "ace/Stream.h"
00105 #include "ace/Service_Types.h"
00106 #include "ace/OS_NS_string.h"
00107 
00108 
00109 #include "ace/ace_wchar.h"
00110 
00111 ACE_RCSID (ace,
00112            Svc_Conf_y,
00113            "$Id: Svc_Conf_y.cpp 79341 2007-08-14 18:09:18Z sowayaa $")
00114 
00115 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00116 
00117 // Prototypes.
00118 
00119 static ACE_Module_Type *ace_get_module (const ACE_Service_Type *sr,
00120                                          const ACE_Service_Type *sv,
00121                                          int & ace_ace_yyerrno);
00122 
00123 static ACE_Module_Type *ace_get_module (const ACE_Service_Type *sr,
00124                                         const ACE_TCHAR *svc_name,
00125                                          int & ace_ace_yyerrno);
00126 
00127 #define ACE_YYDEBUG_LEXER_TEXT (ace_yytext[ace_yyleng] = '\0', ace_yytext)
00128 
00129 // Force the pretty debugging code to compile.
00130 // #define ACE_YYDEBUG 1
00131 
00132 ACE_END_VERSIONED_NAMESPACE_DECL
00133 
00134 
00135 /* Enabling traces.  */
00136 #ifndef ACE_YYDEBUG
00137 # define ACE_YYDEBUG 0
00138 #endif
00139 
00140 /* Enabling verbose error messages.  */
00141 #ifdef ACE_YYERROR_VERBOSE
00142 # undef ACE_YYERROR_VERBOSE
00143 # define ACE_YYERROR_VERBOSE 1
00144 #else
00145 # define ACE_YYERROR_VERBOSE 0
00146 #endif
00147 
00148 #if ! defined (ACE_YYSTYPE) && ! defined (ACE_YYSTYPE_IS_DECLARED)
00149 typedef int ACE_YYSTYPE;
00150 # define ace_yystype ACE_YYSTYPE /* obsolescent; will be withdrawn */
00151 # define ACE_YYSTYPE_IS_DECLARED 1
00152 # define ACE_YYSTYPE_IS_TRIVIAL 1
00153 #endif
00154 
00155 
00156 
00157 /* Copy the second part of user declarations.  */
00158 
00159 
00160 /* Line 213 of yacc.c.  */
00161 
00162 
00163 #if ! defined (ace_yyoverflow) || ACE_YYERROR_VERBOSE
00164 
00165 # ifndef ACE_YYFREE
00166 #  define ACE_YYFREE free
00167 # endif
00168 # ifndef ACE_YYMALLOC
00169 #  define ACE_YYMALLOC malloc
00170 # endif
00171 
00172 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00173 
00174 # ifdef ACE_YYSTACK_USE_ALLOCA
00175 #  if ACE_YYSTACK_USE_ALLOCA
00176 #   ifdef __GNUC__
00177 #    define ACE_YYSTACK_ALLOC __builtin_alloca
00178 #   else
00179 #    define ACE_YYSTACK_ALLOC alloca
00180 #   endif
00181 #  endif
00182 # endif
00183 
00184 # ifdef ACE_YYSTACK_ALLOC
00185    /* Pacify GCC's `empty if-body' warning. */
00186 #  define ACE_YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
00187 # else
00188 #  if defined (__STDC__) || defined (__cplusplus)
00189 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00190 #   define ACE_YYSIZE_T size_t
00191 #  endif
00192 #  define ACE_YYSTACK_ALLOC ACE_YYMALLOC
00193 #  define ACE_YYSTACK_FREE ACE_YYFREE
00194 # endif
00195 #endif /* ! defined (ace_yyoverflow) || ACE_YYERROR_VERBOSE */
00196 
00197 
00198 #if (! defined (ace_yyoverflow) \
00199      && (! defined (__cplusplus) \
00200    || (defined (ACE_YYSTYPE_IS_TRIVIAL) && ACE_YYSTYPE_IS_TRIVIAL)))
00201 
00202 /* A type that is properly aligned for any stack member.  */
00203 union ace_yyalloc
00204 {
00205   short int ace_yyss;
00206   ACE_YYSTYPE ace_yyvs;
00207   };
00208 
00209 /* The size of the maximum gap between one aligned stack and the next.  */
00210 # define ACE_YYSTACK_GAP_MAXIMUM (sizeof (union ace_yyalloc) - 1)
00211 
00212 /* The size of an array large to enough to hold all stacks, each with
00213    N elements.  */
00214 # define ACE_YYSTACK_BYTES(N) \
00215      ((N) * (sizeof (short int) + sizeof (ACE_YYSTYPE)) \
00216       + ACE_YYSTACK_GAP_MAXIMUM)
00217 
00218 /* Copy COUNT objects from FROM to TO.  The source and destination do
00219    not overlap.  */
00220 # ifndef ACE_YYCOPY
00221 #  if defined (__GNUC__) && 1 < __GNUC__
00222 #   define ACE_YYCOPY(To, From, Count) \
00223       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00224 #  else
00225 #   define ACE_YYCOPY(To, From, Count)                    \
00226       do                                                  \
00227         {                                                 \
00228           register ACE_YYSIZE_T ace_yyi;                  \
00229           for (ace_yyi = 0; ace_yyi < (Count); ace_yyi++) \
00230             (To)[ace_yyi] = (From)[ace_yyi];              \
00231         }                                                 \
00232       while (0)
00233 #  endif
00234 # endif
00235 
00236 /* Relocate STACK from its old location to the new one.  The
00237    local variables ACE_YYSIZE and ACE_YYSTACKSIZE give the old and new number of
00238    elements in the stack, and ACE_YYPTR gives the new location of the
00239    stack.  Advance ACE_YYPTR to a properly aligned location for the next
00240    stack.  */
00241 # define ACE_YYSTACK_RELOCATE(Stack)                                                  \
00242     do                                                                                \
00243       {                                                                               \
00244         ACE_YYSIZE_T ace_yynewbytes;                                                  \
00245         ACE_YYCOPY (&ace_yyptr->Stack, Stack, ace_yysize);                            \
00246         Stack = &ace_yyptr->Stack;                                                    \
00247         ace_yynewbytes = ace_yystacksize * sizeof (*Stack) + ACE_YYSTACK_GAP_MAXIMUM; \
00248         ace_yyptr += ace_yynewbytes / sizeof (*ace_yyptr);                            \
00249       }                                                                               \
00250     while (0)
00251 
00252 #endif
00253 
00254 #if defined (__STDC__) || defined (__cplusplus)
00255    typedef signed char ace_yysigned_char;
00256 #else
00257    typedef short int ace_yysigned_char;
00258 #endif
00259 
00260 /* ACE_YYFINAL -- State number of the termination state. */
00261 #define ACE_YYFINAL  2
00262 /* ACE_YYLAST -- Last index in ACE_YYTABLE.  */
00263 #define ACE_YYLAST   62
00264 
00265 /* ACE_YYNTOKENS -- Number of terminals. */
00266 #define ACE_YYNTOKENS  23
00267 /* ACE_YYNNTS -- Number of nonterminals. */
00268 #define ACE_YYNNTS  21
00269 /* ACE_YYNRULES -- Number of rules. */
00270 #define ACE_YYNRULES  45
00271 /* ACE_YYNRULES -- Number of states. */
00272 #define ACE_YYNSTATES  66
00273 
00274 /* ACE_YYTRANSLATE(ACE_YYLEX) -- Bison symbol number corresponding to ACE_YYLEX.  */
00275 #define ACE_YYUNDEFTOK  2
00276 #define ACE_YYMAXUTOK   271
00277 
00278 #define ACE_YYTRANSLATE(ACE_YYX)  \
00279   ((unsigned int) (ACE_YYX) <= ACE_YYMAXUTOK ? ace_yytranslate[ACE_YYX] : ACE_YYUNDEFTOK)
00280 
00281 /* ACE_YYTRANSLATE[ACE_YYLEX] -- Bison symbol number corresponding to ACE_YYLEX.  */
00282 static const unsigned char ace_yytranslate[] =
00283 {
00284        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00285        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00286        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00287        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00288       20,    21,    22,     2,     2,     2,     2,     2,     2,     2,
00289        2,     2,     2,     2,     2,     2,     2,     2,    19,     2,
00290        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00291        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00292        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00293        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00294        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00295        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00296        2,     2,     2,    17,     2,    18,     2,     2,     2,     2,
00297        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00298        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00299        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00300        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00301        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00302        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00303        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00304        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00305        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00306        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00307        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00308        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00309        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00310        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00311       15,    16
00312 };
00313 
00314 #if ACE_YYDEBUG
00315 /* ACE_YYPRHS[ACE_YYN] -- Index of the first RHS symbol of rule number ACE_YYN in
00316    ACE_YYRHS.  */
00317 static const unsigned char ace_yyprhs[] =
00318 {
00319        0,     0,     3,     6,     9,    10,    12,    14,    16,    18,
00320       20,    22,    26,    30,    33,    36,    39,    43,    44,    49,
00321       51,    53,    54,    59,    60,    63,    64,    66,    68,    70,
00322       72,    74,    79,    81,    83,    84,    88,    94,    99,   102,
00323      105,   108,   110,   111,   113,   115
00324 };
00325 
00326 /* ACE_YYRHS -- A `-1'-separated list of the rules' RHS. */
00327 static const ace_yysigned_char ace_yyrhs[] =
00328 {
00329       24,     0,    -1,    24,    25,    -1,    24,     1,    -1,    -1,
00330       26,    -1,    27,    -1,    28,    -1,    29,    -1,    30,    -1,
00331       31,    -1,     3,    38,    42,    -1,     4,    15,    42,    -1,
00332        5,    15,    -1,     6,    15,    -1,     7,    15,    -1,     8,
00333       33,    34,    -1,    -1,     8,    15,    32,    34,    -1,    26,
00334       -1,    27,    -1,    -1,    17,    35,    36,    18,    -1,    -1,
00335       36,    37,    -1,    -1,    26,    -1,    27,    -1,    28,    -1,
00336       29,    -1,    30,    -1,    15,    41,    40,    39,    -1,    12,
00337       -1,    13,    -1,    -1,    43,    19,    15,    -1,    43,    19,
00338       15,    20,    21,    -1,    19,    15,    20,    21,    -1,     9,
00339       22,    -1,    11,    22,    -1,    10,    22,    -1,    16,    -1,
00340       -1,    14,    -1,    15,    -1,    16,    -1
00341 };
00342 
00343 /* ACE_YYRLINE[ACE_YYN] -- source line where rule number ACE_YYN was defined.  */
00344 static const unsigned short int ace_yyrline[] =
00345 {
00346        0,    62,    62,    71,    75,    79,    80,    81,    82,    83,
00347       84,    88,    98,   105,   112,   119,   126,   130,   130,   137,
00348      140,   147,   146,   155,   159,   167,   171,   196,   210,   219,
00349      228,   250,   257,   261,   266,   272,   276,   280,   287,   291,
00350      295,   302,   303,   307,   308,   309
00351 };
00352 #endif
00353 
00354 #if ACE_YYDEBUG || ACE_YYERROR_VERBOSE
00355 /* ACE_YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00356    First, the terminals, then, starting at ACE_YYNTOKENS, nonterminals. */
00357 static const char *const ace_yytname[] =
00358 {
00359   "$end", "error", "$undefined", "ACE_DYNAMIC", "ACE_STATIC",
00360   "ACE_SUSPEND", "ACE_RESUME", "ACE_REMOVE", "ACE_USTREAM", "ACE_MODULE_T",
00361   "ACE_STREAM_T", "ACE_SVC_OBJ_T", "ACE_ACTIVE", "ACE_INACTIVE",
00362   "ACE_PATHNAME", "ACE_IDENT", "ACE_STRING", "'{'", "'}'", "':'", "'('",
00363   "')'", "'*'", "$accept", "svc_config_entries", "svc_config_entry",
00364   "dynamic", "static", "suspend", "resume", "remove", "stream", "@1",
00365   "stream_ops", "stream_modules", "@2", "module_list", "module",
00366   "svc_location", "status", "svc_initializer", "type", "parameters_opt",
00367   "pathname", 0
00368 };
00369 #endif
00370 
00371 # ifdef ACE_YYPRINT
00372 /* ACE_YYTOKNUM[ACE_YYLEX-NUM] -- Internal token number corresponding to
00373    token ACE_YYLEX-NUM.  */
00374 static const unsigned short int ace_yytoknum[] =
00375 {
00376        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00377      265,   266,   267,   268,   269,   270,   271,   123,   125,    58,
00378       40,    41,    42
00379 };
00380 # endif
00381 
00382 /* ACE_YYR1[ACE_YYN] -- Symbol number of symbol that rule ACE_YYN derives.  */
00383 static const unsigned char ace_yyr1[] =
00384 {
00385        0,    23,    24,    24,    24,    25,    25,    25,    25,    25,
00386       25,    26,    27,    28,    29,    30,    31,    32,    31,    33,
00387       33,    35,    34,    34,    36,    36,    37,    37,    37,    37,
00388       37,    38,    39,    39,    39,    40,    40,    40,    41,    41,
00389       41,    42,    42,    43,    43,    43
00390 };
00391 
00392 /* ACE_YYR2[ACE_YYN] -- Number of symbols composing right hand side of rule ACE_YYN.  */
00393 static const unsigned char ace_yyr2[] =
00394 {
00395        0,     2,     2,     2,     0,     1,     1,     1,     1,     1,
00396        1,     3,     3,     2,     2,     2,     3,     0,     4,     1,
00397        1,     0,     4,     0,     2,     0,     1,     1,     1,     1,
00398        1,     4,     1,     1,     0,     3,     5,     4,     2,     2,
00399        2,     1,     0,     1,     1,     1
00400 };
00401 
00402 /* ACE_YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00403    STATE-NUM when ACE_YYTABLE doesn't specify something else to do.  Zero
00404    means the default is an error.  */
00405 static const unsigned char ace_yydefact[] =
00406 {
00407        4,     0,     1,     3,     0,     0,     0,     0,     0,     0,
00408        2,     5,     6,     7,     8,     9,    10,     0,    42,    42,
00409       13,    14,    15,    17,    19,    20,    23,     0,     0,     0,
00410        0,    41,    11,    12,    23,    21,    16,    38,    40,    39,
00411       43,    44,    45,     0,    34,     0,    18,    25,     0,    32,
00412       33,    31,     0,     0,     0,    35,    22,    26,    27,    28,
00413       29,    30,    24,    37,     0,    36
00414 };
00415 
00416 /* ACE_YYDEFGOTO[NTERM-NUM]. */
00417 static const ace_yysigned_char ace_yydefgoto[] =
00418 {
00419       -1,     1,    10,    11,    12,    13,    14,    15,    16,    34,
00420       26,    36,    47,    53,    62,    18,    51,    44,    30,    32,
00421       45
00422 };
00423 
00424 /* ACE_YYPACT[STATE-NUM] -- Index in ACE_YYTABLE of the portion describing
00425    STATE-NUM.  */
00426 #define ACE_YYPACT_NINF -13
00427 static const ace_yysigned_char ace_yypact[] =
00428 {
00429      -13,    20,   -13,   -13,     1,     3,     7,    14,    18,     4,
00430      -13,   -13,   -13,   -13,   -13,   -13,   -13,    21,    19,    19,
00431      -13,   -13,   -13,   -13,   -13,   -13,    -2,    12,    15,    16,
00432       -5,   -13,   -13,   -13,    -2,   -13,   -13,   -13,   -13,   -13,
00433      -13,   -13,   -13,    24,     0,    17,   -13,   -13,    22,   -13,
00434      -13,   -13,    25,    -1,    26,    23,   -13,   -13,   -13,   -13,
00435      -13,   -13,   -13,   -13,    27,   -13
00436 };
00437 
00438 /* ACE_YYPGOTO[NTERM-NUM].  */
00439 static const ace_yysigned_char ace_yypgoto[] =
00440 {
00441      -13,   -13,   -13,    -9,    -8,   -12,    -7,    -4,   -13,   -13,
00442      -13,    28,   -13,   -13,   -13,   -13,   -13,   -13,   -13,    31,
00443      -13
00444 };
00445 
00446 /* ACE_YYTABLE[ACE_YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00447    positive, shift that token.  If negative, reduce the rule which
00448    number is the opposite.  If zero, do what ACE_YYDEFACT says.
00449    If ACE_YYTABLE_NINF, syntax error.  */
00450 #define ACE_YYTABLE_NINF -1
00451 static const unsigned char ace_yytable[] =
00452 {
00453       24,    25,     4,     5,     6,     7,     8,     4,     5,    40,
00454       41,    42,    49,    50,    43,    35,    17,    56,    19,    23,
00455        2,     3,    20,     4,     5,     6,     7,     8,     9,    21,
00456       27,    28,    29,    22,    37,    31,    52,    38,    39,    48,
00457       55,    59,    54,    64,    57,    58,    60,    63,    65,    61,
00458       33,     0,     0,     0,     0,     0,     0,     0,     0,     0,
00459        0,     0,    46
00460 };
00461 
00462 static const ace_yysigned_char ace_yycheck[] =
00463 {
00464        9,     9,     3,     4,     5,     6,     7,     3,     4,    14,
00465       15,    16,    12,    13,    19,    17,    15,    18,    15,    15,
00466        0,     1,    15,     3,     4,     5,     6,     7,     8,    15,
00467        9,    10,    11,    15,    22,    16,    19,    22,    22,    15,
00468       15,    53,    20,    20,    53,    53,    53,    21,    21,    53,
00469       19,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
00470       -1,    -1,    34
00471 };
00472 
00473 /* ACE_YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00474    symbol of state STATE-NUM.  */
00475 static const unsigned char ace_yystos[] =
00476 {
00477        0,    24,     0,     1,     3,     4,     5,     6,     7,     8,
00478       25,    26,    27,    28,    29,    30,    31,    15,    38,    15,
00479       15,    15,    15,    15,    26,    27,    33,     9,    10,    11,
00480       41,    16,    42,    42,    32,    17,    34,    22,    22,    22,
00481       14,    15,    16,    19,    40,    43,    34,    35,    15,    12,
00482       13,    39,    19,    36,    20,    15,    18,    26,    27,    28,
00483       29,    30,    37,    21,    20,    21
00484 };
00485 
00486 #if ! defined (ACE_YYSIZE_T) && defined (__SIZE_TYPE__)
00487 # define ACE_YYSIZE_T __SIZE_TYPE__
00488 #endif
00489 #if ! defined (ACE_YYSIZE_T) && defined (size_t)
00490 # define ACE_YYSIZE_T size_t
00491 #endif
00492 #if ! defined (ACE_YYSIZE_T)
00493 # if defined (__STDC__) || defined (__cplusplus)
00494 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00495 #  define ACE_YYSIZE_T size_t
00496 # endif
00497 #endif
00498 #if ! defined (ACE_YYSIZE_T)
00499 # define ACE_YYSIZE_T unsigned int
00500 #endif
00501 
00502 #define ace_yyerrok   (ace_yyerrstatus = 0)
00503 #define ace_yyclearin (ace_yychar = ACE_YYEMPTY)
00504 #define ACE_YYEMPTY   (-2)
00505 #define ACE_YYEOF     0
00506 
00507 #define ACE_YYACCEPT  goto ace_yyacceptlab
00508 #define ACE_YYABORT   goto ace_yyabortlab
00509 #define ACE_YYERROR   goto ace_yyerrorlab
00510 
00511 
00512 /* Like ACE_YYERROR except do call ace_yyerror.  This remains here temporarily
00513    to ease the transition to the new meaning of ACE_YYERROR, for GCC.
00514    Once GCC version 2 has supplanted version 1, this can go.  */
00515 
00516 #define ACE_YYFAIL    goto ace_yyerrlab
00517 
00518 #define ACE_YYRECOVERING()  (!!ace_yyerrstatus)
00519 
00520 #define ACE_YYBACKUP(Token, Value)                   \
00521   do                                                 \
00522     if (ace_yychar == ACE_YYEMPTY && ace_yylen == 1) \
00523       {                                              \
00524         ace_yychar = (Token);                        \
00525         ace_yylval = (Value);                        \
00526         ace_yytoken = ACE_YYTRANSLATE (ace_yychar);  \
00527         ACE_YYPOPSTACK;                              \
00528         goto ace_yybackup;                           \
00529       }                                              \
00530     else                                             \
00531       {                                              \
00532         ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "syntax error: cannot back up");\
00533         ACE_YYERROR;                                 \
00534       }                                              \
00535   while (0)
00536 
00537 
00538 #define ACE_YYTERROR  1
00539 #define ACE_YYERRCODE 256
00540 
00541 
00542 /* ACE_YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
00543    If N is 0, then set CURRENT to the empty location which ends
00544    the previous symbol: RHS[0] (always defined).  */
00545 
00546 #define ACE_YYRHSLOC(Rhs, K) ((Rhs)[K])
00547 #ifndef ACE_YYLLOC_DEFAULT
00548 # define ACE_YYLLOC_DEFAULT(Current, Rhs, N)                            \
00549     do                                                                  \
00550       if (N)                                                            \
00551         {                                                               \
00552           (Current).first_line   = ACE_YYRHSLOC (Rhs, 1).first_line;    \
00553           (Current).first_column = ACE_YYRHSLOC (Rhs, 1).first_column;  \
00554           (Current).last_line    = ACE_YYRHSLOC (Rhs, N).last_line;     \
00555           (Current).last_column  = ACE_YYRHSLOC (Rhs, N).last_column;   \
00556         }                                                               \
00557       else                                                              \
00558         {                                                               \
00559           (Current).first_line   = (Current).last_line   =              \
00560             ACE_YYRHSLOC (Rhs, 0).last_line;                            \
00561           (Current).first_column = (Current).last_column =              \
00562             ACE_YYRHSLOC (Rhs, 0).last_column;                          \
00563         }                                                               \
00564     while (0)
00565 #endif
00566 
00567 
00568 /* ACE_YY_LOCATION_PRINT -- Print the location on the stream.
00569    This macro was not mandated originally: define only if we know
00570    we won't break user code: when these are the locations we know.  */
00571 
00572 #ifndef ACE_YY_LOCATION_PRINT
00573 # if ACE_YYLTYPE_IS_TRIVIAL
00574 #  define ACE_YY_LOCATION_PRINT(File, Loc)                  \
00575      ACE_OS::fprintf (File, "%d.%d-%d.%d",                  \
00576                       (Loc).first_line, (Loc).first_column, \
00577                       (Loc).last_line,  (Loc).last_column)
00578 # else
00579 #  define ACE_YY_LOCATION_PRINT(File, Loc) ((void) 0)
00580 # endif
00581 #endif
00582 
00583 
00584 /* ACE_YYLEX -- calling `ace_yylex' with the right arguments.  */
00585 
00586 #ifdef ACE_YYLEX_PARAM
00587 # define ACE_YYLEX ace_yylex (&ace_yylval, ACE_YYLEX_PARAM)
00588 #else
00589 # define ACE_YYLEX ace_yylex (&ace_yylval)
00590 #endif
00591 
00592 /* Enable debugging if requested.  */
00593 #if ACE_YYDEBUG
00594 
00595 # ifndef ACE_YYFPRINTF
00596 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
00597 #  define ACE_YYFPRINTF ACE_OS::fprintf
00598 # endif
00599 
00600 # define ACE_YYDPRINTF(Args) \
00601   do                         \
00602     {                        \
00603       if (ace_yydebug)       \
00604         ACE_YYFPRINTF Args;  \
00605     }                        \
00606   while (0)
00607 
00608 # define ACE_YY_SYMBOL_PRINT(Title, Type, Value, Location)  \
00609   do                                                        \
00610     {                                                       \
00611       if (ace_yydebug)                                      \
00612         {                                                   \
00613           ACE_YYFPRINTF (stderr, "%s ", Title);             \
00614           ace_yysymprint (stderr,                           \
00615                           Type, Value);                     \
00616           ACE_YYFPRINTF (stderr, "\n");                     \
00617         }                                                   \
00618     }                                                       \
00619   while (0)
00620 
00621 /*------------------------------------------------------------------.
00622 | ace_yy_stack_print -- Print the state stack from its BOTTOM up to its |
00623 | TOP (included).                                                   |
00624 `------------------------------------------------------------------*/
00625 
00626 #if defined (__STDC__) || defined (__cplusplus)
00627 static void
00628 ace_yy_stack_print (short int *bottom, short int *top)
00629 #else
00630 static void
00631 ace_yy_stack_print (bottom, top)
00632     short int *bottom;
00633     short int *top;
00634 #endif
00635 {
00636   ACE_YYFPRINTF (stderr, "Stack now");
00637   for (/* Nothing. */; bottom <= top; ++bottom)
00638     ACE_YYFPRINTF (stderr, " %d", *bottom);
00639   ACE_YYFPRINTF (stderr, "\n");
00640 }
00641 
00642 # define ACE_YY_STACK_PRINT(Bottom, Top)      \
00643   do                                          \
00644     {                                         \
00645       if (ace_yydebug)                        \
00646         ace_yy_stack_print ((Bottom), (Top)); \
00647     }                                         \
00648   while (0)
00649 
00650 
00651 /*------------------------------------------------.
00652 | Report that the ACE_YYRULE is going to be reduced.  |
00653 `------------------------------------------------*/
00654 
00655 #if defined (__STDC__) || defined (__cplusplus)
00656 static void
00657 ace_yy_reduce_print (int ace_yyrule)
00658 #else
00659 static void
00660 ace_yy_reduce_print (ace_yyrule)
00661     int ace_yyrule;
00662 #endif
00663 {
00664   int ace_yyi;
00665   unsigned int ace_yylno = ace_yyrline[ace_yyrule];
00666   ACE_YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
00667              ace_yyrule - 1, ace_yylno);
00668   /* Print the symbols being reduced, and their result.  */
00669   for (ace_yyi = ace_yyprhs[ace_yyrule]; 0 <= ace_yyrhs[ace_yyi]; ace_yyi++)
00670     ACE_YYFPRINTF (stderr, "%s ", ace_yytname [ace_yyrhs[ace_yyi]]);
00671   ACE_YYFPRINTF (stderr, "-> %s\n", ace_yytname [ace_yyr1[ace_yyrule]]);
00672 }
00673 
00674 # define ACE_YY_REDUCE_PRINT(Rule)  \
00675   do                                \
00676     {                               \
00677       if (ace_yydebug)              \
00678         ace_yy_reduce_print (Rule); \
00679     }                               \
00680   while (0)
00681 
00682 /* Nonzero means print parse trace.  It is left uninitialized so that
00683    multiple parsers can coexist.  */
00684 int ace_yydebug;
00685 #else /* !ACE_YYDEBUG */
00686 # define ACE_YYDPRINTF(Args)
00687 # define ACE_YY_SYMBOL_PRINT(Title, Type, Value, Location)
00688 # define ACE_YY_STACK_PRINT(Bottom, Top)
00689 # define ACE_YY_REDUCE_PRINT(Rule)
00690 #endif /* !ACE_YYDEBUG */
00691 
00692 
00693 /* ACE_YYINITDEPTH -- initial size of the parser's stacks.  */
00694 #ifndef  ACE_YYINITDEPTH
00695 # define ACE_YYINITDEPTH 200
00696 #endif
00697 
00698 /* ACE_YYMAXDEPTH -- maximum size the stacks can grow to (effective only
00699    if the built-in stack extension method is used).
00700 
00701    Do not make this value too large; the results are undefined if
00702    SIZE_MAX < ACE_YYSTACK_BYTES (ACE_YYMAXDEPTH)
00703    evaluated with infinite-precision integer arithmetic.  */
00704 
00705 #ifndef ACE_YYMAXDEPTH
00706 # define ACE_YYMAXDEPTH 10000
00707 #endif
00708 
00709 
00710 
00711 #if ACE_YYERROR_VERBOSE
00712 
00713 # ifndef ace_yystrlen
00714 #  if defined (__GLIBC__) && defined (_STRING_H)
00715 #   define ace_yystrlen strlen
00716 #  else
00717 /* Return the length of ACE_YYSTR.  */
00718 static ACE_YYSIZE_T
00719 #   if defined (__STDC__) || defined (__cplusplus)
00720 ace_yystrlen (const char *ace_yystr)
00721 #   else
00722 ace_yystrlen (ace_yystr)
00723      const char *ace_yystr;
00724 #   endif
00725 {
00726   register const char *ace_yys = ace_yystr;
00727 
00728   while (*ace_yys++ != '\0')
00729     continue;
00730 
00731   return ace_yys - ace_yystr - 1;
00732 }
00733 #  endif
00734 # endif
00735 
00736 # ifndef ace_yystpcpy
00737 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
00738 #   define ace_yystpcpy stpcpy
00739 #  else
00740 /* Copy ACE_YYSRC to ACE_YYDEST, returning the address of the terminating '\0' in
00741    ACE_YYDEST.  */
00742 static char *
00743 #   if defined (__STDC__) || defined (__cplusplus)
00744 ace_yystpcpy (ACE_TCHAR *ace_yydest, const char *ace_yysrc)
00745 #   else
00746 ace_yystpcpy (ace_yydest, ace_yysrc)
00747      char *ace_yydest;
00748      const char *ace_yysrc;
00749 #   endif
00750 {
00751   register char *ace_yyd = ace_yydest;
00752   register const char *ace_yys = ace_yysrc;
00753 
00754   while ((*ace_yyd++ = *ace_yys++) != '\0')
00755     continue;
00756 
00757   return ace_yyd - 1;
00758 }
00759 #  endif
00760 # endif
00761 
00762 #endif /* !ACE_YYERROR_VERBOSE */
00763 
00764 
00765 
00766 #if ACE_YYDEBUG
00767 /*--------------------------------.
00768 | Print this symbol on ACE_YYOUTPUT.  |
00769 `--------------------------------*/
00770 
00771 #if defined (__STDC__) || defined (__cplusplus)
00772 static void
00773 ace_yysymprint (FILE *ace_yyoutput, int ace_yytype, ACE_YYSTYPE *ace_yyvaluep)
00774 #else
00775 static void
00776 ace_yysymprint (ace_yyoutput, ace_yytype, ace_yyvaluep)
00777     FILE *ace_yyoutput;
00778     int ace_yytype;
00779     ACE_YYSTYPE *ace_yyvaluep;
00780 #endif
00781 {
00782   /* Pacify ``unused variable'' warnings.  */
00783   (void) ace_yyvaluep;
00784 
00785   if (ace_yytype < ACE_YYNTOKENS)
00786     ACE_YYFPRINTF (ace_yyoutput, "token %s (", ace_yytname[ace_yytype]);
00787   else
00788     ACE_YYFPRINTF (ace_yyoutput, "nterm %s (", ace_yytname[ace_yytype]);
00789 
00790 
00791 # ifdef ACE_YYPRINT
00792   if (ace_yytype < ACE_YYNTOKENS)
00793     ACE_YYPRINT (ace_yyoutput, ace_yytoknum[ace_yytype], *ace_yyvaluep);
00794 # endif
00795   switch (ace_yytype)
00796     {
00797       default:
00798         break;
00799     }
00800   ACE_YYFPRINTF (ace_yyoutput, ")");
00801 }
00802 
00803 #endif /* ! ACE_YYDEBUG */
00804 /*-----------------------------------------------.
00805 | Release the memory associated to this symbol.  |
00806 `-----------------------------------------------*/
00807 
00808 #if defined (__STDC__) || defined (__cplusplus)
00809 static void
00810 ace_yydestruct (const char *ace_yymsg, int ace_yytype, ACE_YYSTYPE *ace_yyvaluep)
00811 #else
00812 static void
00813 ace_yydestruct (ace_yymsg, ace_yytype, ace_yyvaluep)
00814     const char *ace_yymsg;
00815     int ace_yytype;
00816     ACE_YYSTYPE *ace_yyvaluep;
00817 #endif
00818 {
00819   /* Pacify ``unused variable'' warnings.  */
00820   (void) ace_yyvaluep;
00821   (void) ace_yytype;
00822 
00823   if (!ace_yymsg)
00824     ace_yymsg = "Deleting";
00825   ACE_YY_SYMBOL_PRINT (ace_yymsg, ace_yytype, ace_yyvaluep, ace_yylocationp);
00826 }
00827 
00828 
00829 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00830 
00831 /* Prevent warnings from -Wmissing-prototypes.  */
00832 
00833 #ifdef ACE_YYPARSE_PARAM
00834 # if defined (__STDC__) || defined (__cplusplus)
00835 int ace_yyparse (void *ACE_YYPARSE_PARAM);
00836 # else
00837 int ace_yyparse ();
00838 # endif
00839 #else /* ! ACE_YYPARSE_PARAM */
00840 #if defined (__STDC__) || defined (__cplusplus)
00841 int ace_yyparse (void);
00842 #else
00843 int ace_yyparse ();
00844 #endif
00845 #endif /* ! ACE_YYPARSE_PARAM */
00846 
00847 
00848 /*----------.
00849 | ace_yyparse.  |
00850 `----------*/
00851 
00852 #ifdef ACE_YYPARSE_PARAM
00853 # if defined (__STDC__) || defined (__cplusplus)
00854 int ace_yyparse (void *ACE_YYPARSE_PARAM)
00855 # else
00856 int ace_yyparse (ACE_YYPARSE_PARAM)
00857   void *ACE_YYPARSE_PARAM;
00858 # endif
00859 #else /* ! ACE_YYPARSE_PARAM */
00860 #if defined (__STDC__) || defined (__cplusplus)
00861 int
00862 ace_yyparse (void)
00863 #else
00864 int
00865 ace_yyparse ()
00866 
00867 #endif
00868 #endif
00869 {
00870   /* The look-ahead symbol.  */
00871 int ace_yychar;
00872 
00873 /* The semantic value of the look-ahead symbol.  */
00874 ACE_YYSTYPE ace_yylval;
00875 
00876 #if defined (ACE_YYSTYPE_IS_TRIVIAL)
00877   ace_yylval = 0;
00878 #else
00879   ace_yylval.type_ = 0;
00880 #endif /* ACE_YYSTYPE_IS_TRIVIAL */
00881 
00882 /* Number of syntax errors so far.  */
00883 int ace_yynerrs;
00884 
00885   register int ace_yystate;
00886   register int ace_yyn;
00887   int ace_yyresult;
00888   /* Number of tokens to shift before error messages enabled.  */
00889   int ace_yyerrstatus;
00890   /* Look-ahead token as an internal (translated) token number.  */
00891   int ace_yytoken = 0;
00892 
00893   /* Three stacks and their tools:
00894      `ace_yyss': related to states,
00895      `ace_yyvs': related to semantic values,
00896      `ace_yyls': related to locations.
00897 
00898      Refer to the stacks thru separate pointers, to allow ace_yyoverflow
00899      to reallocate them elsewhere.  */
00900 
00901   /* The state stack.  */
00902   short int ace_yyssa[ACE_YYINITDEPTH];
00903   short int *ace_yyss = ace_yyssa;
00904   register short int *ace_yyssp;
00905 
00906   /* The semantic value stack.  */
00907   ACE_YYSTYPE ace_yyvsa[ACE_YYINITDEPTH];
00908   ACE_YYSTYPE *ace_yyvs = ace_yyvsa;
00909   register ACE_YYSTYPE *ace_yyvsp;
00910 
00911 
00912 
00913 #define ACE_YYPOPSTACK   (ace_yyvsp--, ace_yyssp--)
00914 
00915   ACE_YYSIZE_T ace_yystacksize = ACE_YYINITDEPTH;
00916 
00917   /* The variables used to return semantic value and location from the
00918      action routines.  */
00919   ACE_YYSTYPE ace_yyval;
00920 
00921 
00922   /* When reducing, the number of symbols on the RHS of the reduced
00923      rule.  */
00924   int ace_yylen;
00925 
00926   ACE_YYDPRINTF ((stderr, "Starting parse\n"));
00927 
00928   ace_yystate = 0;
00929   ace_yyerrstatus = 0;
00930   ace_yynerrs = 0;
00931   ace_yychar = ACE_YYEMPTY; /* Cause a token to be read.  */
00932 
00933   /* Initialize stack pointers.
00934      Waste one element of value and location stack
00935      so that they stay on the same level as the state stack.
00936      The wasted elements are never initialized.  */
00937 
00938   ace_yyssp = ace_yyss;
00939   ace_yyvsp = ace_yyvs;
00940 
00941 
00942   ace_yyvsp[0] = ace_yylval;
00943 
00944   goto ace_yysetstate;
00945 
00946 /*------------------------------------------------------------.
00947 | ace_yynewstate -- Push a new state, which is found in ace_yystate.  |
00948 `------------------------------------------------------------*/
00949  ace_yynewstate:
00950   /* In all cases, when you get here, the value and location stacks
00951      have just been pushed. so pushing a state here evens the stacks.
00952      */
00953   ace_yyssp++;
00954 
00955  ace_yysetstate:
00956   *ace_yyssp = ace_yystate;
00957 
00958   if (ace_yyss + ace_yystacksize - 1 <= ace_yyssp)
00959     {
00960       /* Get the current used size of the three stacks, in elements.  */
00961       ACE_YYSIZE_T ace_yysize = ace_yyssp - ace_yyss + 1;
00962 
00963 #ifdef ace_yyoverflow
00964       {
00965   /* Give user a chance to reallocate the stack. Use copies of
00966      these so that the &'s don't force the real ones into
00967      memory.  */
00968   ACE_YYSTYPE *ace_yyvs1 = ace_yyvs;
00969   short int *ace_yyss1 = ace_yyss;
00970 
00971 
00972   /* Each stack pointer address is followed by the size of the
00973      data in use in that stack, in bytes.  This used to be a
00974      conditional around just the two extra args, but that might
00975      be undefined if ace_yyoverflow is a macro.  */
00976   ace_yyoverflow ("parser stack overflow",
00977         &ace_yyss1, ace_yysize * sizeof (*ace_yyssp),
00978         &ace_yyvs1, ace_yysize * sizeof (*ace_yyvsp),
00979 
00980         &ace_yystacksize);
00981 
00982   ace_yyss = ace_yyss1;
00983   ace_yyvs = ace_yyvs1;
00984       }
00985 #else /* no ace_yyoverflow */
00986 # ifndef ACE_YYSTACK_RELOCATE
00987       goto ace_yyoverflowlab;
00988 # else
00989       /* Extend the stack our own way.  */
00990       if (ACE_YYMAXDEPTH <= ace_yystacksize)
00991   goto ace_yyoverflowlab;
00992       ace_yystacksize *= 2;
00993       if (ACE_YYMAXDEPTH < ace_yystacksize)
00994   ace_yystacksize = ACE_YYMAXDEPTH;
00995 
00996       {
00997   short int *ace_yyss1 = ace_yyss;
00998   union ace_yyalloc *ace_yyptr =
00999     (union ace_yyalloc *) ACE_YYSTACK_ALLOC (ACE_YYSTACK_BYTES (ace_yystacksize));
01000   if (! ace_yyptr)
01001     goto ace_yyoverflowlab;
01002   ACE_YYSTACK_RELOCATE (ace_yyss);
01003   ACE_YYSTACK_RELOCATE (ace_yyvs);
01004 
01005 #  undef ACE_YYSTACK_RELOCATE
01006   if (ace_yyss1 != ace_yyssa)
01007     ACE_YYSTACK_FREE (ace_yyss1);
01008       }
01009 # endif
01010 #endif /* no ace_yyoverflow */
01011 
01012       ace_yyssp = ace_yyss + ace_yysize - 1;
01013       ace_yyvsp = ace_yyvs + ace_yysize - 1;
01014 
01015 
01016       ACE_YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01017       (unsigned long int) ace_yystacksize));
01018 
01019       if (ace_yyss + ace_yystacksize - 1 <= ace_yyssp)
01020   ACE_YYABORT;
01021     }
01022 
01023   ACE_YYDPRINTF ((stderr, "Entering state %d\n", ace_yystate));
01024 
01025   goto ace_yybackup;
01026 
01027 /*-----------.
01028 | ace_yybackup.  |
01029 `-----------*/
01030 ace_yybackup:
01031 
01032 /* Do appropriate processing given the current state.  */
01033 /* Read a look-ahead token if we need one and don't already have one.  */
01034 /* ace_yyresume: */
01035 
01036   /* First try to decide what to do without reference to look-ahead token.  */
01037 
01038   ace_yyn = ace_yypact[ace_yystate];
01039   if (ace_yyn == ACE_YYPACT_NINF)
01040     goto ace_yydefault;
01041 
01042   /* Not known => get a look-ahead token if don't already have one.  */
01043 
01044   /* ACE_YYCHAR is either ACE_YYEMPTY or ACE_YYEOF or a valid look-ahead symbol.  */
01045   if (ace_yychar == ACE_YYEMPTY)
01046     {
01047       ACE_YYDPRINTF ((stderr, "Reading a token: "));
01048       ace_yychar = ACE_YYLEX;
01049     }
01050 
01051   if (ace_yychar <= ACE_YYEOF)
01052     {
01053       ace_yychar = ace_yytoken = ACE_YYEOF;
01054       ACE_YYDPRINTF ((stderr, "Now at end of input.\n"));
01055     }
01056   else
01057     {
01058       ace_yytoken = ACE_YYTRANSLATE (ace_yychar);
01059       ACE_YY_SYMBOL_PRINT ("Next token is", ace_yytoken, &ace_yylval, &ace_yylloc);
01060     }
01061 
01062   /* If the proper action on seeing token ACE_YYTOKEN is to reduce or to
01063      detect an error, take that action.  */
01064   ace_yyn += ace_yytoken;
01065   if (ace_yyn < 0 || ACE_YYLAST < ace_yyn || ace_yycheck[ace_yyn] != ace_yytoken)
01066     goto ace_yydefault;
01067   ace_yyn = ace_yytable[ace_yyn];
01068   if (ace_yyn <= 0)
01069     {
01070       if (ace_yyn == 0 || ace_yyn == ACE_YYTABLE_NINF)
01071   goto ace_yyerrlab;
01072       ace_yyn = -ace_yyn;
01073       goto ace_yyreduce;
01074     }
01075 
01076   if (ace_yyn == ACE_YYFINAL)
01077     ACE_YYACCEPT;
01078 
01079   /* Shift the look-ahead token.  */
01080   ACE_YY_SYMBOL_PRINT ("Shifting", ace_yytoken, &ace_yylval, &ace_yylloc);
01081 
01082   /* Discard the token being shifted unless it is eof.  */
01083   if (ace_yychar != ACE_YYEOF)
01084     ace_yychar = ACE_YYEMPTY;
01085 
01086   *++ace_yyvsp = ace_yylval;
01087 
01088 
01089   /* Count tokens shifted since error; after three, turn off error
01090      status.  */
01091   if (ace_yyerrstatus)
01092     ace_yyerrstatus--;
01093 
01094   ace_yystate = ace_yyn;
01095   goto ace_yynewstate;
01096 
01097 
01098 /*-----------------------------------------------------------.
01099 | ace_yydefault -- do the default action for the current state.  |
01100 `-----------------------------------------------------------*/
01101 ace_yydefault:
01102   ace_yyn = ace_yydefact[ace_yystate];
01103   if (ace_yyn == 0)
01104     goto ace_yyerrlab;
01105   goto ace_yyreduce;
01106 
01107 
01108 /*-----------------------------.
01109 | ace_yyreduce -- Do a reduction.  |
01110 `-----------------------------*/
01111 ace_yyreduce:
01112   /* ace_yyn is the number of a rule to reduce with.  */
01113   ace_yylen = ace_yyr2[ace_yyn];
01114 
01115   /* If ACE_YYLEN is nonzero, implement the default value of the action:
01116      `$$ = $1'.
01117 
01118      Otherwise, the following line sets ACE_YYVAL to garbage.
01119      This behavior is undocumented and Bison
01120      users should not rely upon it.  Assigning to ACE_YYVAL
01121      unconditionally makes the parser a bit smaller, and it avoids a
01122      GCC warning that ACE_YYVAL may be used uninitialized.  */
01123   ace_yyval = ace_yyvsp[1-ace_yylen];
01124 
01125 
01126   ACE_YY_REDUCE_PRINT (ace_yyn);
01127   switch (ace_yyn)
01128     {
01129         case 2:
01130 
01131     {
01132       if ((ace_yyvsp[0].parse_node_) != 0)
01133       {
01134         (ace_yyvsp[0].parse_node_)->apply (ACE_SVC_CONF_PARAM->config, ACE_SVC_CONF_PARAM->yyerrno);
01135         delete (ace_yyvsp[0].parse_node_);
01136       }
01137       ACE_SVC_CONF_PARAM->obstack.release ();
01138     ;}
01139     break;
01140 
01141   case 3:
01142 
01143     {
01144       ACE_SVC_CONF_PARAM->obstack.release ();
01145     ;}
01146     break;
01147 
01148   case 11:
01149 
01150     {
01151       if ((ace_yyvsp[-1].svc_record_) != 0)
01152         (ace_yyval.parse_node_) = new ACE_Dynamic_Node ((ace_yyvsp[-1].svc_record_), (ace_yyvsp[0].ident_));
01153       else
01154         (ace_yyval.parse_node_) = 0;
01155     ;}
01156     break;
01157 
01158   case 12:
01159 
01160     {
01161       (ace_yyval.parse_node_) = new ACE_Static_Node ((ace_yyvsp[-1].ident_), (ace_yyvsp[0].ident_));
01162     ;}
01163     break;
01164 
01165   case 13:
01166 
01167     {
01168       (ace_yyval.parse_node_) = new ACE_Suspend_Node ((ace_yyvsp[0].ident_));
01169     ;}
01170     break;
01171 
01172   case 14:
01173 
01174     {
01175       (ace_yyval.parse_node_) = new ACE_Resume_Node ((ace_yyvsp[0].ident_));
01176     ;}
01177     break;
01178 
01179   case 15:
01180 
01181     {
01182       (ace_yyval.parse_node_) = new ACE_Remove_Node ((ace_yyvsp[0].ident_));
01183     ;}
01184     break;
01185 
01186   case 16:
01187 
01188     {
01189       (ace_yyval.parse_node_) = new ACE_Stream_Node ((ace_yyvsp[-1].static_node_), (ace_yyvsp[0].parse_node_));
01190     ;}
01191     break;
01192 
01193   case 17:
01194 
01195     { (ace_yyval.static_node_) = new ACE_Static_Node ((ace_yyvsp[0].ident_)); ;}
01196     break;
01197 
01198   case 18:
01199 
01200     {
01201       (ace_yyval.parse_node_) = new ACE_Dummy_Node ((ace_yyvsp[-1].static_node_), (ace_yyvsp[0].parse_node_));
01202     ;}
01203     break;
01204 
01205   case 19:
01206 
01207     {
01208     ;}
01209     break;
01210 
01211   case 20:
01212 
01213     {
01214     ;}
01215     break;
01216 
01217   case 21:
01218 
01219     {
01220       // Initialize left context...
01221       (ace_yyval.static_node_) = (ace_yyvsp[-1].static_node_);
01222     ;}
01223     break;
01224 
01225   case 22:
01226 
01227     {
01228       (ace_yyval.parse_node_) = (ace_yyvsp[-1].parse_node_);
01229     ;}
01230     break;
01231 
01232   case 23:
01233 
01234     { (ace_yyval.parse_node_) = 0; ;}
01235     break;
01236 
01237   case 24:
01238 
01239     {
01240       if ((ace_yyvsp[0].parse_node_) != 0)
01241         {
01242           (ace_yyvsp[0].parse_node_)->link ((ace_yyvsp[-1].parse_node_));
01243           (ace_yyval.parse_node_) = (ace_yyvsp[0].parse_node_);
01244         }
01245     ;}
01246     break;
01247 
01248   case 25:
01249 
01250     { (ace_yyval.parse_node_) = 0; ;}
01251     break;
01252 
01253   case 26:
01254 
01255     {
01256       ACE_Static_Node *svc_type = (ace_yyvsp[0].static_node_);
01257 
01258       if (svc_type != 0)
01259         {
01260           ACE_Static_Node *module = (ace_yyvsp[-2].static_node_);
01261 
01262           ACE_ARGV args (svc_type->parameters ());
01263           ACE_Module_Type *mt = ace_get_module (module->record (ACE_SVC_CONF_PARAM->config),
01264                                                 svc_type->record (ACE_SVC_CONF_PARAM->config),
01265                                                 ACE_SVC_CONF_PARAM->yyerrno);
01266           ACE_Stream_Type *st =
01267             dynamic_cast<ACE_Stream_Type *> (const_cast<ACE_Service_Type_Impl *> (module->record (ACE_SVC_CONF_PARAM->config)->type ()));
01268 
01269           if (!st
01270               || !mt
01271               || mt->init (args.argc (), args.argv ()) == -1
01272               || st->push (mt) == -1)
01273             {
01274               ACE_ERROR ((LM_ERROR,
01275                           ACE_TEXT ("dynamic initialization failed for Module %s\n"),
01276                           svc_type->name ()));
01277               ACE_SVC_CONF_PARAM->yyerrno++;
01278             }
01279         }
01280     ;}
01281     break;
01282 
01283   case 27:
01284 
01285     {
01286       ACE_Static_Node *sn = (ace_yyvsp[-2].static_node_);
01287       ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
01288                                             (ace_yyvsp[0].static_node_)->name (),
01289                                             ACE_SVC_CONF_PARAM->yyerrno);
01290 
01291       if (((ACE_Stream_Type *) sn->record (ACE_SVC_CONF_PARAM->config)->type ())->push (mt) == -1)
01292         {
01293           ACE_ERROR ((LM_ERROR,
01294                       ACE_TEXT ("Problem with static\n")));
01295           ACE_SVC_CONF_PARAM->yyerrno++;
01296         }
01297     ;}
01298     break;
01299 
01300   case 28:
01301 
01302     {
01303       ACE_Static_Node *sn = (ace_yyvsp[-2].static_node_);
01304       ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
01305                                             sn->name (),
01306                                             ACE_SVC_CONF_PARAM->yyerrno);
01307       if (mt != 0)
01308         mt->suspend ();
01309     ;}
01310     break;
01311 
01312   case 29:
01313 
01314     {
01315       ACE_Static_Node *sn = (ace_yyvsp[-2].static_node_);
01316       ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
01317                                             (ace_yyvsp[0].static_node_)->name (),
01318                                             ACE_SVC_CONF_PARAM->yyerrno);
01319       if (mt != 0)
01320         mt->resume ();
01321     ;}
01322     break;
01323 
01324   case 30:
01325 
01326     {
01327       ACE_Static_Node *stream = (ace_yyvsp[-2].static_node_);
01328       ACE_Static_Node *module = (ace_yyvsp[0].static_node_);
01329       ACE_Module_Type *mt = ace_get_module (stream->record (ACE_SVC_CONF_PARAM->config),
01330                                             module->name (),
01331                                             ACE_SVC_CONF_PARAM->yyerrno);
01332 
01333       ACE_Stream_Type *st =
01334         dynamic_cast<ACE_Stream_Type *> (const_cast<ACE_Service_Type_Impl *> (stream->record (ACE_SVC_CONF_PARAM->config)->type ()));
01335       if (!st || (mt != 0 && st->remove (mt) == -1))
01336         {
01337           ACE_ERROR ((LM_ERROR,
01338                       ACE_TEXT ("cannot remove Module_Type %s from STREAM_Type %s\n"),
01339                       module->name (),
01340                       stream->name ()));
01341           ACE_SVC_CONF_PARAM->yyerrno++;
01342         }
01343     ;}
01344     break;
01345 
01346   case 31:
01347 
01348     {
01349       (ace_yyval.svc_record_) = new ACE_Service_Type_Factory ((ace_yyvsp[-3].ident_), (ace_yyvsp[-2].type_), (ace_yyvsp[-1].location_node_), (ace_yyvsp[0].type_));
01350     ;}
01351     break;
01352 
01353   case 32:
01354 
01355     {
01356       (ace_yyval.type_) = 1;
01357     ;}
01358     break;
01359 
01360   case 33:
01361 
01362     {
01363       (ace_yyval.type_) = 0;
01364     ;}
01365     break;
01366 
01367   case 34:
01368 
01369     {
01370       (ace_yyval.type_) = 1;
01371     ;}
01372     break;
01373 
01374   case 35:
01375 
01376     {
01377       (ace_yyval.location_node_) = new ACE_Object_Node ((ace_yyvsp[-2].ident_), (ace_yyvsp[0].ident_));
01378     ;}
01379     break;
01380 
01381   case 36:
01382 
01383     {
01384       (ace_yyval.location_node_) = new ACE_Function_Node ((ace_yyvsp[-4].ident_), (ace_yyvsp[-2].ident_));
01385     ;}
01386     break;
01387 
01388   case 37:
01389 
01390     {
01391       (ace_yyval.location_node_) = new ACE_Static_Function_Node ((ace_yyvsp[-2].ident_));
01392     ;}
01393     break;
01394 
01395   case 38:
01396 
01397     {
01398       (ace_yyval.type_) = ACE_MODULE_T;
01399     ;}
01400     break;
01401 
01402   case 39:
01403 
01404     {
01405       (ace_yyval.type_) = ACE_SVC_OBJ_T;
01406     ;}
01407     break;
01408 
01409   case 40:
01410 
01411     {
01412       (ace_yyval.type_) = ACE_STREAM_T;
01413     ;}
01414     break;
01415 
01416   case 42:
01417 
01418     { (ace_yyval.ident_) = 0; ;}
01419     break;
01420 
01421 
01422     }
01423 
01424 /* Line 1037 of yacc.c.  */
01425 
01426 
01427   ace_yyvsp -= ace_yylen;
01428   ace_yyssp -= ace_yylen;
01429 
01430 
01431   ACE_YY_STACK_PRINT (ace_yyss, ace_yyssp);
01432 
01433   *++ace_yyvsp = ace_yyval;
01434 
01435 
01436   /* Now `shift' the result of the reduction.  Determine what state
01437      that goes to, based on the state we popped back to and the rule
01438      number reduced by.  */
01439 
01440   ace_yyn = ace_yyr1[ace_yyn];
01441 
01442   ace_yystate = ace_yypgoto[ace_yyn - ACE_YYNTOKENS] + *ace_yyssp;
01443   if (0 <= ace_yystate && ace_yystate <= ACE_YYLAST && ace_yycheck[ace_yystate] == *ace_yyssp)
01444     ace_yystate = ace_yytable[ace_yystate];
01445   else
01446     ace_yystate = ace_yydefgoto[ace_yyn - ACE_YYNTOKENS];
01447 
01448   goto ace_yynewstate;
01449 
01450 
01451 /*------------------------------------.
01452 | ace_yyerrlab -- here on detecting error |
01453 `------------------------------------*/
01454 ace_yyerrlab:
01455   /* If not already recovering from an error, report this error.  */
01456   if (!ace_yyerrstatus)
01457     {
01458       ++ace_yynerrs;
01459 #if ACE_YYERROR_VERBOSE
01460       ace_yyn = ace_yypact[ace_yystate];
01461 
01462       if (ACE_YYPACT_NINF < ace_yyn && ace_yyn < ACE_YYLAST)
01463   {
01464     ACE_YYSIZE_T ace_yysize = 0;
01465     int ace_yytype = ACE_YYTRANSLATE (ace_yychar);
01466     const char* ace_yyprefix;
01467     char *ace_yymsg;
01468     int ace_yyx;
01469 
01470     /* Start ACE_YYX at -ACE_YYN if negative to avoid negative indexes in
01471        ACE_YYCHECK.  */
01472     int ace_yyxbegin = ace_yyn < 0 ? -ace_yyn : 0;
01473 
01474     /* Stay within bounds of both ace_yycheck and ace_yytname.  */
01475     int ace_yychecklim = ACE_YYLAST - ace_yyn;
01476     int ace_yyxend = ace_yychecklim < ACE_YYNTOKENS ? ace_yychecklim : ACE_YYNTOKENS;
01477     int ace_yycount = 0;
01478 
01479     ace_yyprefix = ", expecting ";
01480     for (ace_yyx = ace_yyxbegin; ace_yyx < ace_yyxend; ++ace_yyx)
01481       if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx && ace_yyx != ACE_YYTERROR)
01482         {
01483     ace_yysize += ace_yystrlen (ace_yyprefix) + ace_yystrlen (ace_yytname [ace_yyx]);
01484     ace_yycount += 1;
01485     if (ace_yycount == 5)
01486       {
01487         ace_yysize = 0;
01488         break;
01489       }
01490         }
01491     ace_yysize += (sizeof ("syntax error, unexpected ")
01492          + ace_yystrlen (ace_yytname[ace_yytype]));
01493     ace_yymsg = (ACE_TCHAR *) ACE_YYSTACK_ALLOC (ace_yysize);
01494     if (ace_yymsg != 0)
01495       {
01496         char *ace_yyp = ace_yystpcpy (ace_yymsg, "syntax error, unexpected ");
01497         ace_yyp = ace_yystpcpy (ace_yyp, ace_yytname[ace_yytype]);
01498 
01499         if (ace_yycount < 5)
01500     {
01501       ace_yyprefix = ", expecting ";
01502       for (ace_yyx = ace_yyxbegin; ace_yyx < ace_yyxend; ++ace_yyx)
01503         if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx && ace_yyx != ACE_YYTERROR)
01504           {
01505       ace_yyp = ace_yystpcpy (ace_yyp, ace_yyprefix);
01506       ace_yyp = ace_yystpcpy (ace_yyp, ace_yytname[ace_yyx]);
01507       ace_yyprefix = " or ";
01508           }
01509     }
01510         ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ace_yymsg);
01511         ACE_YYSTACK_FREE (ace_yymsg);
01512       }
01513     else
01514       ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "syntax error; also virtual memory exhausted");
01515   }
01516       else
01517 #endif /* ACE_YYERROR_VERBOSE */
01518   ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "syntax error");
01519     }
01520 
01521 
01522 
01523   if (ace_yyerrstatus == 3)
01524     {
01525       /* If just tried and failed to reuse look-ahead token after an
01526    error, discard it.  */
01527 
01528       if (ace_yychar <= ACE_YYEOF)
01529         {
01530           /* If at end of input, pop the error token,
01531        then the rest of the stack, then return failure.  */
01532     if (ace_yychar == ACE_YYEOF)
01533        for (;;)
01534          {
01535 
01536      ACE_YYPOPSTACK;
01537      if (ace_yyssp == ace_yyss)
01538        ACE_YYABORT;
01539      ace_yydestruct ("Error: popping",
01540                              ace_yystos[*ace_yyssp], ace_yyvsp);
01541          }
01542         }
01543       else
01544   {
01545     ace_yydestruct ("Error: discarding", ace_yytoken, &ace_yylval);
01546     ace_yychar = ACE_YYEMPTY;
01547   }
01548     }
01549 
01550   /* Else will try to reuse look-ahead token after shifting the error
01551      token.  */
01552   goto ace_yyerrlab1;
01553 
01554 
01555 /*---------------------------------------------------.
01556 | ace_yyerrorlab -- error raised explicitly by ACE_YYERROR.  |
01557 `---------------------------------------------------*/
01558 ace_yyerrorlab:
01559 
01560 #if defined (__GNUC__) || defined (ACE_WIN32) || defined (__HP_aCC) || defined (__DECCXX)
01561   /* Pacify GCC when the user code never invokes ACE_YYERROR and the label
01562      ace_yyerrorlab therefore never appears in user code.  */
01563   if (0)
01564      goto ace_yyerrorlab;
01565 #endif
01566 
01567 ace_yyvsp -= ace_yylen;
01568   ace_yyssp -= ace_yylen;
01569   ace_yystate = *ace_yyssp;
01570   goto ace_yyerrlab1;
01571 
01572 
01573 /*-------------------------------------------------------------.
01574 | ace_yyerrlab1 -- common code for both syntax error and ACE_YYERROR.  |
01575 `-------------------------------------------------------------*/
01576 ace_yyerrlab1:
01577   ace_yyerrstatus = 3; /* Each real token shifted decrements this.  */
01578 
01579   for (;;)
01580     {
01581       ace_yyn = ace_yypact[ace_yystate];
01582       if (ace_yyn != ACE_YYPACT_NINF)
01583   {
01584     ace_yyn += ACE_YYTERROR;
01585     if (0 <= ace_yyn && ace_yyn <= ACE_YYLAST && ace_yycheck[ace_yyn] == ACE_YYTERROR)
01586       {
01587         ace_yyn = ace_yytable[ace_yyn];
01588         if (0 < ace_yyn)
01589     break;
01590       }
01591   }
01592 
01593       /* Pop the current state because it cannot handle the error token.  */
01594       if (ace_yyssp == ace_yyss)
01595   ACE_YYABORT;
01596 
01597 
01598       ace_yydestruct ("Error: popping", ace_yystos[ace_yystate], ace_yyvsp);
01599       ACE_YYPOPSTACK;
01600       ace_yystate = *ace_yyssp;
01601       ACE_YY_STACK_PRINT (ace_yyss, ace_yyssp);
01602     }
01603 
01604   if (ace_yyn == ACE_YYFINAL)
01605     ACE_YYACCEPT;
01606 
01607   *++ace_yyvsp = ace_yylval;
01608 
01609 
01610   /* Shift the error token. */
01611   ACE_YY_SYMBOL_PRINT ("Shifting", ace_yystos[ace_yyn], ace_yyvsp, ace_yylsp);
01612 
01613   ace_yystate = ace_yyn;
01614   goto ace_yynewstate;
01615 
01616 
01617 /*-------------------------------------.
01618 | ace_yyacceptlab -- ACE_YYACCEPT comes here.  |
01619 `-------------------------------------*/
01620 ace_yyacceptlab:
01621   ace_yyresult = 0;
01622   goto ace_yyreturn;
01623 
01624 /*-----------------------------------.
01625 | ace_yyabortlab -- ACE_YYABORT comes here.  |
01626 `-----------------------------------*/
01627 ace_yyabortlab:
01628   ace_yydestruct ("Error: discarding lookahead",
01629               ace_yytoken, &ace_yylval);
01630   ace_yychar = ACE_YYEMPTY;
01631   ace_yyresult = 1;
01632   goto ace_yyreturn;
01633 
01634 #ifndef ace_yyoverflow
01635 /*----------------------------------------------.
01636 | ace_yyoverflowlab -- parser overflow comes here.  |
01637 `----------------------------------------------*/
01638 ace_yyoverflowlab:
01639   ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "parser stack overflow");
01640   ace_yyresult = 2;
01641   /* Fall through.  */
01642 #endif
01643 
01644 ace_yyreturn:
01645 #ifndef ace_yyoverflow
01646   if (ace_yyss != ace_yyssa)
01647     ACE_YYSTACK_FREE (ace_yyss);
01648 #endif
01649   return ace_yyresult;
01650 }
01651 
01652 // Prints the error string to standard output.  Cleans up the error
01653 // messages.
01654 
01655 void
01656 ace_yyerror (int ace_yyerrno, int ace_yylineno, char const *s)
01657 {
01658 #if defined (ACE_NLOGGING)
01659   ACE_UNUSED_ARG (ace_yyerrno);
01660   ACE_UNUSED_ARG (ace_yylineno);
01661   ACE_UNUSED_ARG (s);
01662 #endif /* ACE_NLOGGING */
01663 
01664   ACE_ERROR ((LM_ERROR,
01665               ACE_TEXT ("ACE (%P|%t) [error %d] on line %d: %s\n"),
01666               ace_yyerrno,
01667               ace_yylineno,
01668               ACE_TEXT_CHAR_TO_TCHAR (s)));
01669 }
01670 
01671 // Note that SRC_REC represents left context, which is the STREAM *
01672 // record.
01673 
01674 static ACE_Module_Type *
01675 ace_get_module (ACE_Service_Type const * sr,
01676                 ACE_TCHAR const * svc_name,
01677                 int & ace_yyerrno)
01678 {
01679   ACE_Service_Type_Impl const * const type = sr->type ();
01680   ACE_Stream_Type const * const st =
01681     (sr == 0
01682      ? 0
01683      : dynamic_cast<ACE_Stream_Type const *> (type));
01684   ACE_Module_Type const * const mt = (st == 0 ? 0 : st->find (svc_name));
01685 
01686   if (sr == 0 || st == 0 || mt == 0)
01687     {
01688       ACE_ERROR ((LM_ERROR,
01689                   ACE_TEXT ("cannot locate Module_Type %s ")
01690                   ACE_TEXT ("in STREAM_Type %s\n"),
01691                   svc_name,
01692                   (sr ? sr->name () : ACE_TEXT ("(nil)"))));
01693       ++ace_yyerrno;
01694     }
01695 
01696   return const_cast<ACE_Module_Type *> (mt);
01697 }
01698 
01699 static ACE_Module_Type *
01700 ace_get_module (ACE_Service_Type const * sr,
01701                 ACE_Service_Type const * sv,
01702                 int & ace_yyerrno)
01703 {
01704   ACE_Stream_Type const * const st =
01705     (sr == 0
01706      ? 0
01707      : static_cast<ACE_Stream_Type const *> (sr->type ()));
01708 
01709   ACE_Module_Type const * const mt =
01710     static_cast <ACE_Module_Type const *> (sv->type ());
01711 
01712   ACE_TCHAR const * const module_type_name =
01713     (mt ? mt->name () : ACE_TEXT ("(nil)"));
01714 
01715   if (sr == 0 || st == 0 || mt == 0)
01716     {
01717       ACE_ERROR ((LM_ERROR,
01718                   ACE_TEXT ("cannot locate Module_Type %s or STREAM_Type %s\n"),
01719                   module_type_name,
01720                   (sr ? sr->name () : ACE_TEXT ("(nil)"))));
01721       ++ace_yyerrno;
01722     }
01723 
01724   // Make sure that the Module has the same name as the
01725   // Module_Type object from the svc.conf file.
01726   ACE_Module<ACE_SYNCH> * const mp =
01727     static_cast<ACE_Module<ACE_SYNCH> *> (mt ? mt->object () : 0);
01728 
01729   if (mp && ACE_OS::strcmp (mp->name (), module_type_name) != 0)
01730     {
01731       ACE_DEBUG ((LM_DEBUG,
01732                   ACE_TEXT ("warning: assigning Module_Type name %s to Module %s since names differ\n"),
01733                   module_type_name,
01734                   mp->name ()));
01735       mp->name (module_type_name);
01736     }
01737 
01738   return const_cast<ACE_Module_Type *> (mt);
01739 }
01740 
01741 #if defined (DEBUGGING)
01742 // Main driver program.
01743 
01744 int
01745 main (int argc, char *argv[])
01746 {
01747   ACE_Svc_Conf_Param param (stdin);
01748 
01749   // Try to reopen any filename argument to use ACE_YYIN.
01750   if (argc > 1 && (ace_yyin = freopen (argv[1], "r", stdin)) == 0)
01751     (void) ACE_OS::ACE_OS::fprintf (stderr, ACE_TEXT ("usage: %s [file]\n"), argv[0]), ACE_OS::exit (1);
01752 
01753   return ::ace_yyparse (&param);
01754 }
01755 #endif /* DEBUGGING */
01756 
01757 ACE_END_VERSIONED_NAMESPACE_DECL
01758 
01759 #endif  /* ACE_USES_CLASSIC_SVC_CONF == 1 */

Generated on Sun Jan 27 12:05:40 2008 for ACE by doxygen 1.3.6