dep/ACE_wrappers/ace/Svc_Conf_y.cpp

   1 /* A Bison parser, made by GNU Bison 2.3.  */
   2
   3 /* Skeleton implementation for Bison's Yacc-like parsers in C
   4
   5    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   6    Free Software Foundation, Inc.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 /* As a special exception, you may create a larger work that contains
  24    part or all of the Bison parser skeleton and distribute that work
  25    under terms of your choice, so long as that work isn't itself a
  26    parser generator using the skeleton or a modified version thereof
  27    as a parser skeleton.  Alternatively, if you modify or redistribute
  28    the parser skeleton itself, you may (at your option) remove this
  29    special exception, which will cause the skeleton and the resulting
  30    Bison output files to be licensed under the GNU General Public
  31    License without this special exception.
  32
  33    This special exception was added by the Free Software Foundation in
  34    version 2.2 of Bison.  */
  35
  36 /* C LALR(1) parser skeleton written by Richard Stallman, by
  37    simplifying the original so-called "semantic" parser.  */
  38
  39 /* All symbols defined below should begin with ace_yy or YY, to avoid
  40    infringing on user name space.  This should be done even for local
  41    variables, as they might otherwise be expanded by user macros.
  42    There are some unavoidable exceptions within include files to
  43    define necessary library symbols; they are noted "INFRINGES ON
  44    USER NAME SPACE" below.  */
  45
  46 /* Identify Bison output.  */
  47 #define YYBISON 1
  48
  49 /* Bison version.  */
  50 #define YYBISON_VERSION "2.3"
  51
  52 /* Skeleton name.  */
  53 #define YYSKELETON_NAME "yacc.c"
  54
  55 /* Pure parsers.  */
  56 #define YYPURE 1
  57
  58 /* Using locations.  */
  59 #define YYLSP_NEEDED 0
  60
  61
  62
  63 /* Tokens.  */
  64 #ifndef YYTOKENTYPE
  65 # define YYTOKENTYPE
  66    /* Put the tokens into the symbol table, so that GDB and other debuggers
  67       know about them.  */
  68    enum ace_yytokentype {
  69      ACE_DYNAMIC = 258,
  70      ACE_STATIC = 259,
  71      ACE_SUSPEND = 260,
  72      ACE_RESUME = 261,
  73      ACE_REMOVE = 262,
  74      ACE_USTREAM = 263,
  75      ACE_MODULE_T = 264,
  76      ACE_STREAM_T = 265,
  77      ACE_SVC_OBJ_T = 266,
  78      ACE_ACTIVE = 267,
  79      ACE_INACTIVE = 268,
  80      ACE_PATHNAME = 269,
  81      ACE_IDENT = 270,
  82      ACE_STRING = 271
  83    };
  84 #endif
  85 /* Tokens.  */
  86 #define ACE_DYNAMIC 258
  87 #define ACE_STATIC 259
  88 #define ACE_SUSPEND 260
  89 #define ACE_RESUME 261
  90 #define ACE_REMOVE 262
  91 #define ACE_USTREAM 263
  92 #define ACE_MODULE_T 264
  93 #define ACE_STREAM_T 265
  94 #define ACE_SVC_OBJ_T 266
  95 #define ACE_ACTIVE 267
  96 #define ACE_INACTIVE 268
  97 #define ACE_PATHNAME 269
  98 #define ACE_IDENT 270
  99 #define ACE_STRING 271
 100
 101
 102
 103
 104 /* Copy the first part of user declarations.  */
 105
 106
 107 // $Id: Svc_Conf_y.cpp 82137 2008-06-23 15:30:20Z sma $
 108
 109 #include "ace/Svc_Conf.h"
 110
 111 #if (ACE_USES_CLASSIC_SVC_CONF == 1)
 112
 113 #include "ace/Module.h"
 114 #include "ace/Stream.h"
 115 #include "ace/Service_Types.h"
 116 #include "ace/ace_wchar.h"
 117
 118 ACE_RCSID (ace,
 119            Svc_Conf_y,
 120            "$Id: Svc_Conf_y.cpp 82137 2008-06-23 15:30:20Z sma $")
 121
 122 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 123
 124 // Prototypes.
 125
 126 static ACE_Module_Type *
 127   ace_get_module (ACE_Service_Type const * sr,
 128                   ACE_TCHAR const * svc_name,
 129                   int & ace_ace_yyerrno);
 130
 131 #define YYDEBUG_LEXER_TEXT (ace_yytext[ace_yyleng] = '\0', ace_yytext)
 132
 133 // Force the pretty debugging code to compile.
 134 // #define YYDEBUG 1
 135
 136 // Bison 2.3 template contains switch statement with a "default:", but
 137 // without a "case:" label. Suppressing a compiler warning for Visual
 138 // C++.
 139 #if defined (_MSC_VER)
 140 #   pragma warning ( disable : 4065 )
 141 #endif
 142
 143 // Normalize the message literal's type to match ace_yyerror() prototype
 144 #define YY_ ACE_TEXT
 145
 146 // Prevent yacc(1) from declaring a trivial YYSTYPE just because
 147 // YYSTYPE is not a macro definition. On the other hand we want
 148 // YYSTYPE_IS_DECLARED to be as localized as possible to avoid
 149 // poluting the global namespace - there may be other yacc(1) parsers
 150 // that want to play nice with ACE
 151 #define YYSTYPE_IS_DECLARED
 152
 153 ACE_END_VERSIONED_NAMESPACE_DECL
 154
 155
 156
 157 /* Enabling traces.  */
 158 #ifndef YYDEBUG
 159 # define YYDEBUG 0
 160 #endif
 161
 162 /* Enabling verbose error messages.  */
 163 #ifdef YYERROR_VERBOSE
 164 # undef YYERROR_VERBOSE
 165 # define YYERROR_VERBOSE 1
 166 #else
 167 # define YYERROR_VERBOSE 0
 168 #endif
 169
 170 /* Enabling the token table.  */
 171 #ifndef YYTOKEN_TABLE
 172 # define YYTOKEN_TABLE 0
 173 #endif
 174
 175 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 176 typedef int YYSTYPE;
 177 # define ace_yystype YYSTYPE /* obsolescent; will be withdrawn */
 178 # define YYSTYPE_IS_DECLARED 1
 179 # define YYSTYPE_IS_TRIVIAL 1
 180 #endif
 181
 182
 183
 184 /* Copy the second part of user declarations.  */
 185
 186
 187 /* Line 216 of yacc.c.  */
 188
 189
 190 #ifdef short
 191 # undef short
 192 #endif
 193
 194 #ifdef YYTYPE_UINT8
 195 typedef YYTYPE_UINT8 ace_yytype_uint8;
 196 #else
 197 typedef unsigned char ace_yytype_uint8;
 198 #endif
 199
 200 #ifdef YYTYPE_INT8
 201 typedef YYTYPE_INT8 ace_yytype_int8;
 202 #elif (defined __STDC__ || defined __C99__FUNC__ \
 203      || defined __cplusplus || defined _MSC_VER)
 204 typedef signed char ace_yytype_int8;
 205 #else
 206 typedef short int ace_yytype_int8;
 207 #endif
 208
 209 #ifdef YYTYPE_UINT16
 210 typedef YYTYPE_UINT16 ace_yytype_uint16;
 211 #else
 212 typedef unsigned short int ace_yytype_uint16;
 213 #endif
 214
 215 #ifdef YYTYPE_INT16
 216 typedef YYTYPE_INT16 ace_yytype_int16;
 217 #else
 218 typedef short int ace_yytype_int16;
 219 #endif
 220
 221 #ifndef YYSIZE_T
 222 # ifdef __SIZE_TYPE__
 223 #  define YYSIZE_T __SIZE_TYPE__
 224 # elif defined size_t
 225 #  define YYSIZE_T size_t
 226 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 227      || defined __cplusplus || defined _MSC_VER)
 228 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 229 #  define YYSIZE_T size_t
 230 # else
 231 #  define YYSIZE_T unsigned int
 232 # endif
 233 #endif
 234
 235 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 236
 237 #ifndef YY_
 238 # if YYENABLE_NLS
 239 #  if ENABLE_NLS
 240 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 241 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 242 #  endif
 243 # endif
 244 # ifndef YY_
 245 #  define YY_(msgid) msgid
 246 # endif
 247 #endif
 248
 249 /* Suppress unused-variable warnings by "using" E.  */
 250 #if ! defined lint || defined __GNUC__
 251 # define YYUSE(e) ((void) (e))
 252 #else
 253 # define YYUSE(e) /* empty */
 254 #endif
 255
 256 /* Identity function, used to suppress warnings about constant conditions.  */
 257 #ifndef lint
 258 # define YYID(n) (n)
 259 #else
 260 #if (defined __STDC__ || defined __C99__FUNC__ \
 261      || defined __cplusplus || defined _MSC_VER)
 262 static int
 263 YYID (int i)
 264 #else
 265 static int
 266 YYID (i)
 267     int i;
 268 #endif
 269 {
 270   return i;
 271 }
 272 #endif
 273
 274 #if ! defined ace_yyoverflow || YYERROR_VERBOSE
 275
 276 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 277
 278 # ifdef YYSTACK_USE_ALLOCA
 279 #  if YYSTACK_USE_ALLOCA
 280 #   ifdef __GNUC__
 281 #    define YYSTACK_ALLOC __builtin_alloca
 282 #   elif defined __BUILTIN_VA_ARG_INCR
 283 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 284 #   elif defined _AIX
 285 #    define YYSTACK_ALLOC __alloca
 286 #   elif defined _MSC_VER
 287 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 288 #    define alloca _alloca
 289 #   else
 290 #    define YYSTACK_ALLOC alloca
 291 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 292      || defined __cplusplus || defined _MSC_VER)
 293 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 294 #     ifndef _STDLIB_H
 295 #      define _STDLIB_H 1
 296 #     endif
 297 #    endif
 298 #   endif
 299 #  endif
 300 # endif
 301
 302 # ifdef YYSTACK_ALLOC
 303    /* Pacify GCC's `empty if-body' warning.  */
 304 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 305 #  ifndef YYSTACK_ALLOC_MAXIMUM
 306     /* The OS might guarantee only one guard page at the bottom of the stack,
 307        and a page size can be as small as 4096 bytes.  So we cannot safely
 308        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 309        to allow for a few compiler-allocated temporary stack slots.  */
 310 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 311 #  endif
 312 # else
 313 #  define YYSTACK_ALLOC YYMALLOC
 314 #  define YYSTACK_FREE YYFREE
 315 #  ifndef YYSTACK_ALLOC_MAXIMUM
 316 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 317 #  endif
 318 #  if (defined __cplusplus && ! defined _STDLIB_H \
 319        && ! ((defined YYMALLOC || defined malloc) \
 320        && (defined YYFREE || defined free)))
 321 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 322 #   ifndef _STDLIB_H
 323 #    define _STDLIB_H 1
 324 #   endif
 325 #  endif
 326 #  ifndef YYMALLOC
 327 #   define YYMALLOC malloc
 328 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 329      || defined __cplusplus || defined _MSC_VER)
 330 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 331 #   endif
 332 #  endif
 333 #  ifndef YYFREE
 334 #   define YYFREE free
 335 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 336      || defined __cplusplus || defined _MSC_VER)
 337 void free (void *); /* INFRINGES ON USER NAME SPACE */
 338 #   endif
 339 #  endif
 340 # endif
 341 #endif /* ! defined ace_yyoverflow || YYERROR_VERBOSE */
 342
 343
 344 #if (! defined ace_yyoverflow \
 345      && (! defined __cplusplus \
 346    || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 347
 348 /* A type that is properly aligned for any stack member.  */
 349 union ace_yyalloc
 350 {
 351   ace_yytype_int16 ace_yyss;
 352   YYSTYPE ace_yyvs;
 353   };
 354
 355 /* The size of the maximum gap between one aligned stack and the next.  */
 356 # define YYSTACK_GAP_MAXIMUM (sizeof (union ace_yyalloc) - 1)
 357
 358 /* The size of an array large to enough to hold all stacks, each with
 359    N elements.  */
 360 # define YYSTACK_BYTES(N) \
 361      ((N) * (sizeof (ace_yytype_int16) + sizeof (YYSTYPE)) \
 362       + YYSTACK_GAP_MAXIMUM)
 363
 364 /* Copy COUNT objects from FROM to TO.  The source and destination do
 365    not overlap.  */
 366 # ifndef YYCOPY
 367 #  if defined __GNUC__ && 1 < __GNUC__
 368 #   define YYCOPY(To, From, Count) \
 369       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 370 #  else
 371 #   define YYCOPY(To, From, Count)    \
 372       do          \
 373   {          \
 374     YYSIZE_T ace_yyi;        \
 375     for (ace_yyi = 0; ace_yyi < (Count); ace_yyi++)  \
 376       (To)[ace_yyi] = (From)[ace_yyi];    \
 377   }          \
 378       while (YYID (0))
 379 #  endif
 380 # endif
 381
 382 /* Relocate STACK from its old location to the new one.  The
 383    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 384    elements in the stack, and YYPTR gives the new location of the
 385    stack.  Advance YYPTR to a properly aligned location for the next
 386    stack.  */
 387 # define YYSTACK_RELOCATE(Stack)          \
 388     do                  \
 389       {                  \
 390   YYSIZE_T ace_yynewbytes;            \
 391   YYCOPY (&ace_yyptr->Stack, Stack, ace_yysize);        \
 392   Stack = &ace_yyptr->Stack;            \
 393   ace_yynewbytes = ace_yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 394   ace_yyptr += ace_yynewbytes / sizeof (*ace_yyptr);        \
 395       }                  \
 396     while (YYID (0))
 397
 398 #endif
 399
 400 /* YYFINAL -- State number of the termination state.  */
 401 #define YYFINAL  2
 402 /* YYLAST -- Last index in YYTABLE.  */
 403 #define YYLAST   62
 404
 405 /* YYNTOKENS -- Number of terminals.  */
 406 #define YYNTOKENS  23
 407 /* YYNNTS -- Number of nonterminals.  */
 408 #define YYNNTS  21
 409 /* YYNRULES -- Number of rules.  */
 410 #define YYNRULES  45
 411 /* YYNRULES -- Number of states.  */
 412 #define YYNSTATES  66
 413
 414 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 415 #define YYUNDEFTOK  2
 416 #define YYMAXUTOK   271
 417
 418 #define YYTRANSLATE(YYX)            \
 419   ((unsigned int) (YYX) <= YYMAXUTOK ? ace_yytranslate[YYX] : YYUNDEFTOK)
 420
 421 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 422 static const ace_yytype_uint8 ace_yytranslate[] =
 423 {
 424        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 425        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 426        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 427        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 428       20,    21,    22,     2,     2,     2,     2,     2,     2,     2,
 429        2,     2,     2,     2,     2,     2,     2,     2,    19,     2,
 430        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 431        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 432        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 433        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 434        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 435        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 436        2,     2,     2,    17,     2,    18,     2,     2,     2,     2,
 437        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 438        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 439        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 440        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 441        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 442        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 443        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 444        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 445        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 446        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 447        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 448        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 449        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 450        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 451       15,    16
 452 };
 453
 454 #if YYDEBUG
 455 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 456    YYRHS.  */
 457 static const ace_yytype_uint8 ace_yyprhs[] =
 458 {
 459        0,     0,     3,     6,     9,    10,    12,    14,    16,    18,
 460       20,    22,    26,    30,    33,    36,    39,    43,    44,    49,
 461       51,    53,    54,    59,    60,    63,    64,    66,    68,    70,
 462       72,    74,    79,    81,    83,    84,    88,    94,    99,   102,
 463      105,   108,   110,   111,   113,   115
 464 };
 465
 466 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 467 static const ace_yytype_int8 ace_yyrhs[] =
 468 {
 469       24,     0,    -1,    24,    25,    -1,    24,     1,    -1,    -1,
 470       26,    -1,    27,    -1,    28,    -1,    29,    -1,    30,    -1,
 471       31,    -1,     3,    38,    42,    -1,     4,    15,    42,    -1,
 472        5,    15,    -1,     6,    15,    -1,     7,    15,    -1,     8,
 473       33,    34,    -1,    -1,     8,    15,    32,    34,    -1,    26,
 474       -1,    27,    -1,    -1,    17,    35,    36,    18,    -1,    -1,
 475       36,    37,    -1,    -1,    26,    -1,    27,    -1,    28,    -1,
 476       29,    -1,    30,    -1,    15,    41,    40,    39,    -1,    12,
 477       -1,    13,    -1,    -1,    43,    19,    15,    -1,    43,    19,
 478       15,    20,    21,    -1,    19,    15,    20,    21,    -1,     9,
 479       22,    -1,    11,    22,    -1,    10,    22,    -1,    16,    -1,
 480       -1,    14,    -1,    15,    -1,    16,    -1
 481 };
 482
 483 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 484 static const ace_yytype_uint16 ace_yyrline[] =
 485 {
 486        0,    72,    72,    81,    85,    89,    90,    91,    92,    93,
 487       94,    98,   108,   115,   122,   129,   136,   140,   140,   147,
 488      150,   157,   156,   166,   170,   178,   182,   185,   199,   208,
 489      217,   239,   246,   250,   255,   261,   265,   269,   276,   280,
 490      284,   291,   292,   296,   297,   298
 491 };
 492 #endif
 493
 494 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 495 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 496    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 497 static const char *const ace_yytname[] =
 498 {
 499   "$end", "error", "$undefined", "ACE_DYNAMIC", "ACE_STATIC",
 500   "ACE_SUSPEND", "ACE_RESUME", "ACE_REMOVE", "ACE_USTREAM", "ACE_MODULE_T",
 501   "ACE_STREAM_T", "ACE_SVC_OBJ_T", "ACE_ACTIVE", "ACE_INACTIVE",
 502   "ACE_PATHNAME", "ACE_IDENT", "ACE_STRING", "'{'", "'}'", "':'", "'('",
 503   "')'", "'*'", "$accept", "svc_config_entries", "svc_config_entry",
 504   "dynamic", "static", "suspend", "resume", "remove", "stream", "@1",
 505   "stream_ops", "stream_modules", "@2", "module_list", "module",
 506   "svc_location", "status", "svc_initializer", "type", "parameters_opt",
 507   "pathname", 0
 508 };
 509 #endif
 510
 511 # ifdef YYPRINT
 512 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 513    token YYLEX-NUM.  */
 514 static const ace_yytype_uint16 ace_yytoknum[] =
 515 {
 516        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 517      265,   266,   267,   268,   269,   270,   271,   123,   125,    58,
 518       40,    41,    42
 519 };
 520 # endif
 521
 522 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 523 static const ace_yytype_uint8 ace_yyr1[] =
 524 {
 525        0,    23,    24,    24,    24,    25,    25,    25,    25,    25,
 526       25,    26,    27,    28,    29,    30,    31,    32,    31,    33,
 527       33,    35,    34,    34,    36,    36,    37,    37,    37,    37,
 528       37,    38,    39,    39,    39,    40,    40,    40,    41,    41,
 529       41,    42,    42,    43,    43,    43
 530 };
 531
 532 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 533 static const ace_yytype_uint8 ace_yyr2[] =
 534 {
 535        0,     2,     2,     2,     0,     1,     1,     1,     1,     1,
 536        1,     3,     3,     2,     2,     2,     3,     0,     4,     1,
 537        1,     0,     4,     0,     2,     0,     1,     1,     1,     1,
 538        1,     4,     1,     1,     0,     3,     5,     4,     2,     2,
 539        2,     1,     0,     1,     1,     1
 540 };
 541
 542 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 543    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 544    means the default is an error.  */
 545 static const ace_yytype_uint8 ace_yydefact[] =
 546 {
 547        4,     0,     1,     3,     0,     0,     0,     0,     0,     0,
 548        2,     5,     6,     7,     8,     9,    10,     0,    42,    42,
 549       13,    14,    15,    17,    19,    20,    23,     0,     0,     0,
 550        0,    41,    11,    12,    23,    21,    16,    38,    40,    39,
 551       43,    44,    45,     0,    34,     0,    18,    25,     0,    32,
 552       33,    31,     0,     0,     0,    35,    22,    26,    27,    28,
 553       29,    30,    24,    37,     0,    36
 554 };
 555
 556 /* YYDEFGOTO[NTERM-NUM].  */
 557 static const ace_yytype_int8 ace_yydefgoto[] =
 558 {
 559       -1,     1,    10,    11,    12,    13,    14,    15,    16,    34,
 560       26,    36,    47,    53,    62,    18,    51,    44,    30,    32,
 561       45
 562 };
 563
 564 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
 565    STATE-NUM.  */
 566 #define YYPACT_NINF -13
 567 static const ace_yytype_int8 ace_yypact[] =
 568 {
 569      -13,    20,   -13,   -13,     1,     3,     7,    14,    18,     4,
 570      -13,   -13,   -13,   -13,   -13,   -13,   -13,    21,    19,    19,
 571      -13,   -13,   -13,   -13,   -13,   -13,    -2,    12,    15,    16,
 572       -5,   -13,   -13,   -13,    -2,   -13,   -13,   -13,   -13,   -13,
 573      -13,   -13,   -13,    24,     0,    17,   -13,   -13,    22,   -13,
 574      -13,   -13,    25,    -1,    26,    23,   -13,   -13,   -13,   -13,
 575      -13,   -13,   -13,   -13,    27,   -13
 576 };
 577
 578 /* YYPGOTO[NTERM-NUM].  */
 579 static const ace_yytype_int8 ace_yypgoto[] =
 580 {
 581      -13,   -13,   -13,    -9,    -8,   -12,    -7,    -4,   -13,   -13,
 582      -13,    28,   -13,   -13,   -13,   -13,   -13,   -13,   -13,    31,
 583      -13
 584 };
 585
 586 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
 587    positive, shift that token.  If negative, reduce the rule which
 588    number is the opposite.  If zero, do what YYDEFACT says.
 589    If YYTABLE_NINF, syntax error.  */
 590 #define YYTABLE_NINF -1
 591 static const ace_yytype_uint8 ace_yytable[] =
 592 {
 593       24,    25,     4,     5,     6,     7,     8,     4,     5,    40,
 594       41,    42,    49,    50,    43,    35,    17,    56,    19,    23,
 595        2,     3,    20,     4,     5,     6,     7,     8,     9,    21,
 596       27,    28,    29,    22,    37,    31,    52,    38,    39,    48,
 597       55,    59,    54,    64,    57,    58,    60,    63,    65,    61,
 598       33,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 599        0,     0,    46
 600 };
 601
 602 static const ace_yytype_int8 ace_yycheck[] =
 603 {
 604        9,     9,     3,     4,     5,     6,     7,     3,     4,    14,
 605       15,    16,    12,    13,    19,    17,    15,    18,    15,    15,
 606        0,     1,    15,     3,     4,     5,     6,     7,     8,    15,
 607        9,    10,    11,    15,    22,    16,    19,    22,    22,    15,
 608       15,    53,    20,    20,    53,    53,    53,    21,    21,    53,
 609       19,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
 610       -1,    -1,    34
 611 };
 612
 613 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
 614    symbol of state STATE-NUM.  */
 615 static const ace_yytype_uint8 ace_yystos[] =
 616 {
 617        0,    24,     0,     1,     3,     4,     5,     6,     7,     8,
 618       25,    26,    27,    28,    29,    30,    31,    15,    38,    15,
 619       15,    15,    15,    15,    26,    27,    33,     9,    10,    11,
 620       41,    16,    42,    42,    32,    17,    34,    22,    22,    22,
 621       14,    15,    16,    19,    40,    43,    34,    35,    15,    12,
 622       13,    39,    19,    36,    20,    15,    18,    26,    27,    28,
 623       29,    30,    37,    21,    20,    21
 624 };
 625
 626 #define ace_yyerrok    (ace_yyerrstatus = 0)
 627 #define ace_yyclearin  (ace_yychar = YYEMPTY)
 628 #define YYEMPTY    (-2)
 629 #define YYEOF    0
 630
 631 #define YYACCEPT  goto ace_yyacceptlab
 632 #define YYABORT    goto ace_yyabortlab
 633 #define YYERROR    goto ace_yyerrorlab
 634
 635
 636 /* Like YYERROR except do call ace_yyerror.  This remains here temporarily
 637    to ease the transition to the new meaning of YYERROR, for GCC.
 638    Once GCC version 2 has supplanted version 1, this can go.  */
 639
 640 #define YYFAIL    goto ace_yyerrlab
 641
 642 #define YYRECOVERING()  (!!ace_yyerrstatus)
 643
 644 #define YYBACKUP(Token, Value)          \
 645 do                \
 646   if (ace_yychar == YYEMPTY && ace_yylen == 1)        \
 647     {                \
 648       ace_yychar = (Token);            \
 649       ace_yylval = (Value);            \
 650       ace_yytoken = YYTRANSLATE (ace_yychar);        \
 651       YYPOPSTACK (1);            \
 652       goto ace_yybackup;            \
 653     }                \
 654   else                \
 655     {                \
 656       ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, YY_("syntax error: cannot back up")); \
 657       YYERROR;              \
 658     }                \
 659 while (YYID (0))
 660
 661
 662 #define YYTERROR  1
 663 #define YYERRCODE  256
 664
 665
 666 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
 667    If N is 0, then set CURRENT to the empty location which ends
 668    the previous symbol: RHS[0] (always defined).  */
 669
 670 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
 671 #ifndef YYLLOC_DEFAULT
 672 # define YYLLOC_DEFAULT(Current, Rhs, N)        \
 673     do                  \
 674       if (YYID (N))                                                    \
 675   {                \
 676     (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;  \
 677     (Current).first_column = YYRHSLOC (Rhs, 1).first_column;  \
 678     (Current).last_line    = YYRHSLOC (Rhs, N).last_line;    \
 679     (Current).last_column  = YYRHSLOC (Rhs, N).last_column;  \
 680   }                \
 681       else                \
 682   {                \
 683     (Current).first_line   = (Current).last_line   =    \
 684       YYRHSLOC (Rhs, 0).last_line;        \
 685     (Current).first_column = (Current).last_column =    \
 686       YYRHSLOC (Rhs, 0).last_column;        \
 687   }                \
 688     while (YYID (0))
 689 #endif
 690
 691
 692 /* YY_LOCATION_PRINT -- Print the location on the stream.
 693    This macro was not mandated originally: define only if we know
 694    we won't break user code: when these are the locations we know.  */
 695
 696 #ifndef YY_LOCATION_PRINT
 697 # if YYLTYPE_IS_TRIVIAL
 698 #  define YY_LOCATION_PRINT(File, Loc)      \
 699      ACE_OS::fprintf (File, "%d.%d-%d.%d",      \
 700         (Loc).first_line, (Loc).first_column,  \
 701         (Loc).last_line,  (Loc).last_column)
 702 # else
 703 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 704 # endif
 705 #endif
 706
 707
 708 /* YYLEX -- calling `ace_yylex' with the right arguments.  */
 709
 710 #ifdef YYLEX_PARAM
 711 # define YYLEX ace_yylex (&ace_yylval, YYLEX_PARAM)
 712 #else
 713 # define YYLEX ace_yylex (&ace_yylval)
 714 #endif
 715
 716 /* Enable debugging if requested.  */
 717 #if YYDEBUG
 718
 719 # ifndef YYFPRINTF
 720 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
 721 #  define YYFPRINTF ACE_OS::fprintf
 722 # endif
 723
 724 # define YYDPRINTF(Args)      \
 725 do {            \
 726   if (ace_yydebug)          \
 727     YYFPRINTF Args;        \
 728 } while (YYID (0))
 729
 730 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)        \
 731 do {                    \
 732   if (ace_yydebug)                  \
 733     {                    \
 734       YYFPRINTF (stderr, "%s ", Title);            \
 735       ace_yy_symbol_print (stderr,              \
 736       Type, Value); \
 737       YYFPRINTF (stderr, "\n");              \
 738     }                    \
 739 } while (YYID (0))
 740
 741
 742 /*--------------------------------.
 743 | Print this symbol on YYOUTPUT.  |
 744 `--------------------------------*/
 745
 746 /*ARGSUSED*/
 747 #if (defined __STDC__ || defined __C99__FUNC__ \
 748      || defined __cplusplus || defined _MSC_VER)
 749 static void
 750 ace_yy_symbol_value_print (FILE *ace_yyoutput, int ace_yytype, YYSTYPE const * const ace_yyvaluep)
 751 #else
 752 static void
 753 ace_yy_symbol_value_print (ace_yyoutput, ace_yytype, ace_yyvaluep)
 754     FILE *ace_yyoutput;
 755     int ace_yytype;
 756     YYSTYPE const * const ace_yyvaluep;
 757 #endif
 758 {
 759   if (!ace_yyvaluep)
 760     return;
 761 # ifdef YYPRINT
 762   if (ace_yytype < YYNTOKENS)
 763     YYPRINT (ace_yyoutput, ace_yytoknum[ace_yytype], *ace_yyvaluep);
 764 # else
 765   YYUSE (ace_yyoutput);
 766 # endif
 767   switch (ace_yytype)
 768     {
 769       default:
 770   break;
 771     }
 772 }
 773
 774
 775 /*--------------------------------.
 776 | Print this symbol on YYOUTPUT.  |
 777 `--------------------------------*/
 778
 779 #if (defined __STDC__ || defined __C99__FUNC__ \
 780      || defined __cplusplus || defined _MSC_VER)
 781 static void
 782 ace_yy_symbol_print (FILE *ace_yyoutput, int ace_yytype, YYSTYPE const * const ace_yyvaluep)
 783 #else
 784 static void
 785 ace_yy_symbol_print (ace_yyoutput, ace_yytype, ace_yyvaluep)
 786     FILE *ace_yyoutput;
 787     int ace_yytype;
 788     YYSTYPE const * const ace_yyvaluep;
 789 #endif
 790 {
 791   if (ace_yytype < YYNTOKENS)
 792     YYFPRINTF (ace_yyoutput, "token %s (", ace_yytname[ace_yytype]);
 793   else
 794     YYFPRINTF (ace_yyoutput, "nterm %s (", ace_yytname[ace_yytype]);
 795
 796   ace_yy_symbol_value_print (ace_yyoutput, ace_yytype, ace_yyvaluep);
 797   YYFPRINTF (ace_yyoutput, ")");
 798 }
 799
 800 /*------------------------------------------------------------------.
 801 | ace_yy_stack_print -- Print the state stack from its BOTTOM up to its |
 802 | TOP (included).                                                   |
 803 `------------------------------------------------------------------*/
 804
 805 #if (defined __STDC__ || defined __C99__FUNC__ \
 806      || defined __cplusplus || defined _MSC_VER)
 807 static void
 808 ace_yy_stack_print (ace_yytype_int16 *bottom, ace_yytype_int16 *top)
 809 #else
 810 static void
 811 ace_yy_stack_print (bottom, top)
 812     ace_yytype_int16 *bottom;
 813     ace_yytype_int16 *top;
 814 #endif
 815 {
 816   YYFPRINTF (stderr, "Stack now");
 817   for (; bottom <= top; ++bottom)
 818     YYFPRINTF (stderr, " %d", *bottom);
 819   YYFPRINTF (stderr, "\n");
 820 }
 821
 822 # define YY_STACK_PRINT(Bottom, Top)        \
 823 do {                \
 824   if (ace_yydebug)              \
 825     ace_yy_stack_print ((Bottom), (Top));        \
 826 } while (YYID (0))
 827
 828
 829 /*------------------------------------------------.
 830 | Report that the YYRULE is going to be reduced.  |
 831 `------------------------------------------------*/
 832
 833 #if (defined __STDC__ || defined __C99__FUNC__ \
 834      || defined __cplusplus || defined _MSC_VER)
 835 static void
 836 ace_yy_reduce_print (YYSTYPE *ace_yyvsp, int ace_yyrule)
 837 #else
 838 static void
 839 ace_yy_reduce_print (ace_yyvsp, ace_yyrule)
 840     YYSTYPE *ace_yyvsp;
 841     int ace_yyrule;
 842 #endif
 843 {
 844   int ace_yynrhs = ace_yyr2[ace_yyrule];
 845   int ace_yyi;
 846   unsigned long int ace_yylno = ace_yyrline[ace_yyrule];
 847   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
 848        ace_yyrule - 1, ace_yylno);
 849   /* The symbols being reduced.  */
 850   for (ace_yyi = 0; ace_yyi < ace_yynrhs; ace_yyi++)
 851     {
 852       ACE_OS::fprintf (stderr, "   $%d = ", ace_yyi + 1);
 853       ace_yy_symbol_print (stderr, ace_yyrhs[ace_yyprhs[ace_yyrule] + ace_yyi],
 854            &(ace_yyvsp[(ace_yyi + 1) - (ace_yynrhs)])
 855                       );
 856       ACE_OS::fprintf (stderr, "\n");
 857     }
 858 }
 859
 860 # define YY_REDUCE_PRINT(Rule)    \
 861 do {          \
 862   if (ace_yydebug)        \
 863     ace_yy_reduce_print (ace_yyvsp, Rule); \
 864 } while (YYID (0))
 865
 866 /* Nonzero means print parse trace.  It is left uninitialized so that
 867    multiple parsers can coexist.  */
 868 int ace_yydebug;
 869 #else /* !YYDEBUG */
 870 # define YYDPRINTF(Args)
 871 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 872 # define YY_STACK_PRINT(Bottom, Top)
 873 # define YY_REDUCE_PRINT(Rule)
 874 #endif /* !YYDEBUG */
 875
 876
 877 /* YYINITDEPTH -- initial size of the parser's stacks.  */
 878 #ifndef  YYINITDEPTH
 879 # define YYINITDEPTH 200
 880 #endif
 881
 882 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
 883    if the built-in stack extension method is used).
 884
 885    Do not make this value too large; the results are undefined if
 886    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
 887    evaluated with infinite-precision integer arithmetic.  */
 888
 889 #ifndef YYMAXDEPTH
 890 # define YYMAXDEPTH 10000
 891 #endif
 892
 893
 894
 895 #if YYERROR_VERBOSE
 896
 897 # ifndef ace_yystrlen
 898 #  if defined __GLIBC__ && defined _STRING_H
 899 #   define ace_yystrlen strlen
 900 #  else
 901 /* Return the length of YYSTR.  */
 902 #if (defined __STDC__ || defined __C99__FUNC__ \
 903      || defined __cplusplus || defined _MSC_VER)
 904 static YYSIZE_T
 905 ace_yystrlen (const char *ace_yystr)
 906 #else
 907 static YYSIZE_T
 908 ace_yystrlen (ace_yystr)
 909     const char *ace_yystr;
 910 #endif
 911 {
 912   YYSIZE_T ace_yylen;
 913   for (ace_yylen = 0; ace_yystr[ace_yylen]; ace_yylen++)
 914     continue;
 915   return ace_yylen;
 916 }
 917 #  endif
 918 # endif
 919
 920 # ifndef ace_yystpcpy
 921 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
 922 #   define ace_yystpcpy stpcpy
 923 #  else
 924 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
 925    YYDEST.  */
 926 #if (defined __STDC__ || defined __C99__FUNC__ \
 927      || defined __cplusplus || defined _MSC_VER)
 928 static char *
 929 ace_yystpcpy (char *ace_yydest, const char *ace_yysrc)
 930 #else
 931 static char *
 932 ace_yystpcpy (ace_yydest, ace_yysrc)
 933     char *ace_yydest;
 934     const char *ace_yysrc;
 935 #endif
 936 {
 937   char *ace_yyd = ace_yydest;
 938   const char *ace_yys = ace_yysrc;
 939
 940   while ((*ace_yyd++ = *ace_yys++) != '\0')
 941     continue;
 942
 943   return ace_yyd - 1;
 944 }
 945 #  endif
 946 # endif
 947
 948 # ifndef ace_yytnamerr
 949 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
 950    quotes and backslashes, so that it's suitable for ace_yyerror.  The
 951    heuristic is that double-quoting is unnecessary unless the string
 952    contains an apostrophe, a comma, or backslash (other than
 953    backslash-backslash).  YYSTR is taken from ace_yytname.  If YYRES is
 954    null, do not copy; instead, return the length of what the result
 955    would have been.  */
 956 static YYSIZE_T
 957 ace_yytnamerr (char *ace_yyres, const char *ace_yystr)
 958 {
 959   if (*ace_yystr == '"')
 960     {
 961       YYSIZE_T ace_yyn = 0;
 962       char const *ace_yyp = ace_yystr;
 963
 964       for (;;)
 965   switch (*++ace_yyp)
 966     {
 967     case '\'':
 968     case ',':
 969       goto do_not_strip_quotes;
 970
 971     case '\\':
 972       if (*++ace_yyp != '\\')
 973         goto do_not_strip_quotes;
 974       /* Fall through.  */
 975     default:
 976       if (ace_yyres)
 977         ace_yyres[ace_yyn] = *ace_yyp;
 978       ace_yyn++;
 979       break;
 980
 981     case '"':
 982       if (ace_yyres)
 983         ace_yyres[ace_yyn] = '\0';
 984       return ace_yyn;
 985     }
 986     do_not_strip_quotes: ;
 987     }
 988
 989   if (! ace_yyres)
 990     return ace_yystrlen (ace_yystr);
 991
 992   return ace_yystpcpy (ace_yyres, ace_yystr) - ace_yyres;
 993 }
 994 # endif
 995
 996 /* Copy into YYRESULT an error message about the unexpected token
 997    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
 998    including the terminating null byte.  If YYRESULT is null, do not
 999    copy anything; just return the number of bytes that would be
1000    copied.  As a special case, return 0 if an ordinary "syntax error"
1001    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1002    size calculation.  */
1003 static YYSIZE_T
1004 ace_yysyntax_error (char *ace_yyresult, int ace_yystate, int ace_yychar)
1005 {
1006   int ace_yyn = ace_yypact[ace_yystate];
1007
1008   if (! (YYPACT_NINF < ace_yyn && ace_yyn <= YYLAST))
1009     return 0;
1010   else
1011     {
1012       int ace_yytype = YYTRANSLATE (ace_yychar);
1013       YYSIZE_T ace_yysize0 = ace_yytnamerr (0, ace_yytname[ace_yytype]);
1014       YYSIZE_T ace_yysize = ace_yysize0;
1015       YYSIZE_T ace_yysize1;
1016       int ace_yysize_overflow = 0;
1017       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1018       char const *ace_yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1019       int ace_yyx;
1020
1021 # if 0
1022       /* This is so xgettext sees the translatable formats that are
1023    constructed on the fly.  */
1024       YY_("syntax error, unexpected %s");
1025       YY_("syntax error, unexpected %s, expecting %s");
1026       YY_("syntax error, unexpected %s, expecting %s or %s");
1027       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1028       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1029 # endif
1030       char *ace_yyfmt;
1031       char const *ace_yyf;
1032       static char const ace_yyunexpected[] = "syntax error, unexpected %s";
1033       static char const ace_yyexpecting[] = ", expecting %s";
1034       static char const ace_yyor[] = " or %s";
1035       char ace_yyformat[sizeof ace_yyunexpected
1036         + sizeof ace_yyexpecting - 1
1037         + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1038            * (sizeof ace_yyor - 1))];
1039       char const *ace_yyprefix = ace_yyexpecting;
1040
1041       /* Start YYX at -YYN if negative to avoid negative indexes in
1042    YYCHECK.  */
1043       int ace_yyxbegin = ace_yyn < 0 ? -ace_yyn : 0;
1044
1045       /* Stay within bounds of both ace_yycheck and ace_yytname.  */
1046       int ace_yychecklim = YYLAST - ace_yyn + 1;
1047       int ace_yyxend = ace_yychecklim < YYNTOKENS ? ace_yychecklim : YYNTOKENS;
1048       int ace_yycount = 1;
1049
1050       ace_yyarg[0] = ace_yytname[ace_yytype];
1051       ace_yyfmt = ace_yystpcpy (ace_yyformat, ace_yyunexpected);
1052
1053       for (ace_yyx = ace_yyxbegin; ace_yyx < ace_yyxend; ++ace_yyx)
1054   if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx && ace_yyx != YYTERROR)
1055     {
1056       if (ace_yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1057         {
1058     ace_yycount = 1;
1059     ace_yysize = ace_yysize0;
1060     ace_yyformat[sizeof ace_yyunexpected - 1] = '\0';
1061     break;
1062         }
1063       ace_yyarg[ace_yycount++] = ace_yytname[ace_yyx];
1064       ace_yysize1 = ace_yysize + ace_yytnamerr (0, ace_yytname[ace_yyx]);
1065       ace_yysize_overflow |= (ace_yysize1 < ace_yysize);
1066       ace_yysize = ace_yysize1;
1067       ace_yyfmt = ace_yystpcpy (ace_yyfmt, ace_yyprefix);
1068       ace_yyprefix = ace_yyor;
1069     }
1070
1071       ace_yyf = YY_(ace_yyformat);
1072       ace_yysize1 = ace_yysize + ace_yystrlen (ace_yyf);
1073       ace_yysize_overflow |= (ace_yysize1 < ace_yysize);
1074       ace_yysize = ace_yysize1;
1075
1076       if (ace_yysize_overflow)
1077   return YYSIZE_MAXIMUM;
1078
1079       if (ace_yyresult)
1080   {
1081     /* Avoid sprintf, as that infringes on the user's name space.
1082        Don't have undefined behavior even if the translation
1083        produced a string with the wrong number of "%s"s.  */
1084     char *ace_yyp = ace_yyresult;
1085     int ace_yyi = 0;
1086     while ((*ace_yyp = *ace_yyf) != '\0')
1087       {
1088         if (*ace_yyp == '%' && ace_yyf[1] == 's' && ace_yyi < ace_yycount)
1089     {
1090       ace_yyp += ace_yytnamerr (ace_yyp, ace_yyarg[ace_yyi++]);
1091       ace_yyf += 2;
1092     }
1093         else
1094     {
1095       ace_yyp++;
1096       ace_yyf++;
1097     }
1098       }
1099   }
1100       return ace_yysize;
1101     }
1102 }
1103 #endif /* YYERROR_VERBOSE */
1104
1105
1106 /*-----------------------------------------------.
1107 | Release the memory associated to this symbol.  |
1108 `-----------------------------------------------*/
1109
1110 /*ARGSUSED*/
1111 #if (defined __STDC__ || defined __C99__FUNC__ \
1112      || defined __cplusplus || defined _MSC_VER)
1113 static void
1114 ace_yydestruct (const char *ace_yymsg, int ace_yytype, YYSTYPE *ace_yyvaluep)
1115 #else
1116 static void
1117 ace_yydestruct (ace_yymsg, ace_yytype, ace_yyvaluep)
1118     const char *ace_yymsg;
1119     int ace_yytype;
1120     YYSTYPE *ace_yyvaluep;
1121 #endif
1122 {
1123   YYUSE (ace_yyvaluep);
1124
1125   if (!ace_yymsg)
1126     ace_yymsg = "Deleting";
1127   YY_SYMBOL_PRINT (ace_yymsg, ace_yytype, ace_yyvaluep, ace_yylocationp);
1128
1129   switch (ace_yytype)
1130     {
1131
1132       default:
1133   break;
1134     }
1135 }
1136
1137
1138 /* Prevent warnings from -Wmissing-prototypes.  */
1139
1140 #ifdef YYPARSE_PARAM
1141 #if defined __STDC__ || defined __cplusplus
1142 int ace_yyparse (void *YYPARSE_PARAM);
1143 #else
1144 int ace_yyparse ();
1145 #endif
1146 #else /* ! YYPARSE_PARAM */
1147 #if defined __STDC__ || defined __cplusplus
1148 int ace_yyparse (void);
1149 #else
1150 int ace_yyparse ();
1151 #endif
1152 #endif /* ! YYPARSE_PARAM */
1153
1154
1155
1156
1157
1158
1159 /*----------.
1160 | ace_yyparse.  |
1161 `----------*/
1162
1163 #ifdef YYPARSE_PARAM
1164 #if (defined __STDC__ || defined __C99__FUNC__ \
1165      || defined __cplusplus || defined _MSC_VER)
1166 int
1167 ace_yyparse (void *YYPARSE_PARAM)
1168 #else
1169 int
1170 ace_yyparse (YYPARSE_PARAM)
1171     void *YYPARSE_PARAM;
1172 #endif
1173 #else /* ! YYPARSE_PARAM */
1174 #if (defined __STDC__ || defined __C99__FUNC__ \
1175      || defined __cplusplus || defined _MSC_VER)
1176 int
1177 ace_yyparse (void)
1178 #else
1179 int
1180 ace_yyparse ()
1181
1182 #endif
1183 #endif
1184 {
1185   /* The look-ahead symbol.  */
1186 int ace_yychar;
1187
1188 /* The semantic value of the look-ahead symbol.  */
1189 YYSTYPE ace_yylval;
1190
1191 /* Number of syntax errors so far.  */
1192 int ace_yynerrs;
1193
1194   int ace_yystate;
1195   int ace_yyn;
1196   int ace_yyresult;
1197   /* Number of tokens to shift before error messages enabled.  */
1198   int ace_yyerrstatus;
1199   /* Look-ahead token as an internal (translated) token number.  */
1200   int ace_yytoken = 0;
1201 #if YYERROR_VERBOSE
1202   /* Buffer for error messages, and its allocated size.  */
1203   char ace_yymsgbuf[128];
1204   char *ace_yymsg = ace_yymsgbuf;
1205   YYSIZE_T ace_yymsg_alloc = sizeof ace_yymsgbuf;
1206 #endif
1207
1208   /* Three stacks and their tools:
1209      `ace_yyss': related to states,
1210      `ace_yyvs': related to semantic values,
1211      `ace_yyls': related to locations.
1212
1213      Refer to the stacks thru separate pointers, to allow ace_yyoverflow
1214      to reallocate them elsewhere.  */
1215
1216   /* The state stack.  */
1217   ace_yytype_int16 ace_yyssa[YYINITDEPTH];
1218   ace_yytype_int16 *ace_yyss = ace_yyssa;
1219   ace_yytype_int16 *ace_yyssp;
1220
1221   /* The semantic value stack.  */
1222   YYSTYPE ace_yyvsa[YYINITDEPTH];
1223   YYSTYPE *ace_yyvs = ace_yyvsa;
1224   YYSTYPE *ace_yyvsp;
1225
1226
1227
1228 #define YYPOPSTACK(N)   (ace_yyvsp -= (N), ace_yyssp -= (N))
1229
1230   YYSIZE_T ace_yystacksize = YYINITDEPTH;
1231
1232   /* The variables used to return semantic value and location from the
1233      action routines.  */
1234   YYSTYPE ace_yyval;
1235
1236
1237   /* The number of symbols on the RHS of the reduced rule.
1238      Keep to zero when no symbol should be popped.  */
1239   int ace_yylen = 0;
1240
1241   YYDPRINTF ((stderr, "Starting parse\n"));
1242
1243   ace_yystate = 0;
1244   ace_yyerrstatus = 0;
1245   ace_yynerrs = 0;
1246   ace_yychar = YYEMPTY;    /* Cause a token to be read.  */
1247
1248   /* Initialize stack pointers.
1249      Waste one element of value and location stack
1250      so that they stay on the same level as the state stack.
1251      The wasted elements are never initialized.  */
1252
1253   ace_yyssp = ace_yyss;
1254   ace_yyvsp = ace_yyvs;
1255
1256   goto ace_yysetstate;
1257
1258 /*------------------------------------------------------------.
1259 | ace_yynewstate -- Push a new state, which is found in ace_yystate.  |
1260 `------------------------------------------------------------*/
1261  ace_yynewstate:
1262   /* In all cases, when you get here, the value and location stacks
1263      have just been pushed.  So pushing a state here evens the stacks.  */
1264   ace_yyssp++;
1265
1266  ace_yysetstate:
1267   *ace_yyssp = ace_yystate;
1268
1269   if (ace_yyss + ace_yystacksize - 1 <= ace_yyssp)
1270     {
1271       /* Get the current used size of the three stacks, in elements.  */
1272       YYSIZE_T ace_yysize = ace_yyssp - ace_yyss + 1;
1273
1274 #ifdef ace_yyoverflow
1275       {
1276   /* Give user a chance to reallocate the stack.  Use copies of
1277      these so that the &'s don't force the real ones into
1278      memory.  */
1279   YYSTYPE *ace_yyvs1 = ace_yyvs;
1280   ace_yytype_int16 *ace_yyss1 = ace_yyss;
1281
1282
1283   /* Each stack pointer address is followed by the size of the
1284      data in use in that stack, in bytes.  This used to be a
1285      conditional around just the two extra args, but that might
1286      be undefined if ace_yyoverflow is a macro.  */
1287   ace_yyoverflow (YY_("memory exhausted"),
1288         &ace_yyss1, ace_yysize * sizeof (*ace_yyssp),
1289         &ace_yyvs1, ace_yysize * sizeof (*ace_yyvsp),
1290
1291         &ace_yystacksize);
1292
1293   ace_yyss = ace_yyss1;
1294   ace_yyvs = ace_yyvs1;
1295       }
1296 #else /* no ace_yyoverflow */
1297 # ifndef YYSTACK_RELOCATE
1298       goto ace_yyexhaustedlab;
1299 # else
1300       /* Extend the stack our own way.  */
1301       if (YYMAXDEPTH <= ace_yystacksize)
1302   goto ace_yyexhaustedlab;
1303       ace_yystacksize *= 2;
1304       if (YYMAXDEPTH < ace_yystacksize)
1305   ace_yystacksize = YYMAXDEPTH;
1306
1307       {
1308   ace_yytype_int16 *ace_yyss1 = ace_yyss;
1309   union ace_yyalloc *ace_yyptr =
1310     (union ace_yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (ace_yystacksize));
1311   if (! ace_yyptr)
1312     goto ace_yyexhaustedlab;
1313   YYSTACK_RELOCATE (ace_yyss);
1314   YYSTACK_RELOCATE (ace_yyvs);
1315
1316 #  undef YYSTACK_RELOCATE
1317   if (ace_yyss1 != ace_yyssa)
1318     YYSTACK_FREE (ace_yyss1);
1319       }
1320 # endif
1321 #endif /* no ace_yyoverflow */
1322
1323       ace_yyssp = ace_yyss + ace_yysize - 1;
1324       ace_yyvsp = ace_yyvs + ace_yysize - 1;
1325
1326
1327       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1328       (unsigned long int) ace_yystacksize));
1329
1330       if (ace_yyss + ace_yystacksize - 1 <= ace_yyssp)
1331   YYABORT;
1332     }
1333
1334   YYDPRINTF ((stderr, "Entering state %d\n", ace_yystate));
1335
1336   goto ace_yybackup;
1337
1338 /*-----------.
1339 | ace_yybackup.  |
1340 `-----------*/
1341 ace_yybackup:
1342
1343   /* Do appropriate processing given the current state.  Read a
1344      look-ahead token if we need one and don't already have one.  */
1345
1346   /* First try to decide what to do without reference to look-ahead token.  */
1347   ace_yyn = ace_yypact[ace_yystate];
1348   if (ace_yyn == YYPACT_NINF)
1349     goto ace_yydefault;
1350
1351   /* Not known => get a look-ahead token if don't already have one.  */
1352
1353   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
1354   if (ace_yychar == YYEMPTY)
1355     {
1356       YYDPRINTF ((stderr, "Reading a token: "));
1357       ace_yychar = YYLEX;
1358     }
1359
1360   if (ace_yychar <= YYEOF)
1361     {
1362       ace_yychar = ace_yytoken = YYEOF;
1363       YYDPRINTF ((stderr, "Now at end of input.\n"));
1364     }
1365   else
1366     {
1367       ace_yytoken = YYTRANSLATE (ace_yychar);
1368       YY_SYMBOL_PRINT ("Next token is", ace_yytoken, &ace_yylval, &ace_yylloc);
1369     }
1370
1371   /* If the proper action on seeing token YYTOKEN is to reduce or to
1372      detect an error, take that action.  */
1373   ace_yyn += ace_yytoken;
1374   if (ace_yyn < 0 || YYLAST < ace_yyn || ace_yycheck[ace_yyn] != ace_yytoken)
1375     goto ace_yydefault;
1376   ace_yyn = ace_yytable[ace_yyn];
1377   if (ace_yyn <= 0)
1378     {
1379       if (ace_yyn == 0 || ace_yyn == YYTABLE_NINF)
1380   goto ace_yyerrlab;
1381       ace_yyn = -ace_yyn;
1382       goto ace_yyreduce;
1383     }
1384
1385   if (ace_yyn == YYFINAL)
1386     YYACCEPT;
1387
1388   /* Count tokens shifted since error; after three, turn off error
1389      status.  */
1390   if (ace_yyerrstatus)
1391     ace_yyerrstatus--;
1392
1393   /* Shift the look-ahead token.  */
1394   YY_SYMBOL_PRINT ("Shifting", ace_yytoken, &ace_yylval, &ace_yylloc);
1395
1396   /* Discard the shifted token unless it is eof.  */
1397   if (ace_yychar != YYEOF)
1398     ace_yychar = YYEMPTY;
1399
1400   ace_yystate = ace_yyn;
1401   *++ace_yyvsp = ace_yylval;
1402
1403   goto ace_yynewstate;
1404
1405
1406 /*-----------------------------------------------------------.
1407 | ace_yydefault -- do the default action for the current state.  |
1408 `-----------------------------------------------------------*/
1409 ace_yydefault:
1410   ace_yyn = ace_yydefact[ace_yystate];
1411   if (ace_yyn == 0)
1412     goto ace_yyerrlab;
1413   goto ace_yyreduce;
1414
1415
1416 /*-----------------------------.
1417 | ace_yyreduce -- Do a reduction.  |
1418 `-----------------------------*/
1419 ace_yyreduce:
1420   /* ace_yyn is the number of a rule to reduce with.  */
1421   ace_yylen = ace_yyr2[ace_yyn];
1422
1423   /* If YYLEN is nonzero, implement the default value of the action:
1424      `$$ = $1'.
1425
1426      Otherwise, the following line sets YYVAL to garbage.
1427      This behavior is undocumented and Bison
1428      users should not rely upon it.  Assigning to YYVAL
1429      unconditionally makes the parser a bit smaller, and it avoids a
1430      GCC warning that YYVAL may be used uninitialized.  */
1431   ace_yyval = ace_yyvsp[1-ace_yylen];
1432
1433
1434   YY_REDUCE_PRINT (ace_yyn);
1435   switch (ace_yyn)
1436     {
1437         case 2:
1438
1439     {
1440       if ((ace_yyvsp[(2) - (2)].parse_node_) != 0)
1441       {
1442         (ace_yyvsp[(2) - (2)].parse_node_)->apply (ACE_SVC_CONF_PARAM->config, ACE_SVC_CONF_PARAM->yyerrno);
1443         delete (ace_yyvsp[(2) - (2)].parse_node_);
1444       }
1445       ACE_SVC_CONF_PARAM->obstack.release ();
1446     ;}
1447     break;
1448
1449   case 3:
1450
1451     {
1452       ACE_SVC_CONF_PARAM->obstack.release ();
1453     ;}
1454     break;
1455
1456   case 11:
1457
1458     {
1459       if ((ace_yyvsp[(2) - (3)].svc_record_) != 0)
1460         (ace_yyval.parse_node_) = new ACE_Dynamic_Node ((ace_yyvsp[(2) - (3)].svc_record_), (ace_yyvsp[(3) - (3)].ident_));
1461       else
1462         (ace_yyval.parse_node_) = 0;
1463     ;}
1464     break;
1465
1466   case 12:
1467
1468     {
1469       (ace_yyval.parse_node_) = new ACE_Static_Node ((ace_yyvsp[(2) - (3)].ident_), (ace_yyvsp[(3) - (3)].ident_));
1470     ;}
1471     break;
1472
1473   case 13:
1474
1475     {
1476       (ace_yyval.parse_node_) = new ACE_Suspend_Node ((ace_yyvsp[(2) - (2)].ident_));
1477     ;}
1478     break;
1479
1480   case 14:
1481
1482     {
1483       (ace_yyval.parse_node_) = new ACE_Resume_Node ((ace_yyvsp[(2) - (2)].ident_));
1484     ;}
1485     break;
1486
1487   case 15:
1488
1489     {
1490       (ace_yyval.parse_node_) = new ACE_Remove_Node ((ace_yyvsp[(2) - (2)].ident_));
1491     ;}
1492     break;
1493
1494   case 16:
1495
1496     {
1497       (ace_yyval.parse_node_) = new ACE_Stream_Node ((ace_yyvsp[(2) - (3)].static_node_), (ace_yyvsp[(3) - (3)].parse_node_));
1498     ;}
1499     break;
1500
1501   case 17:
1502
1503     { (ace_yyval.static_node_) = new ACE_Static_Node ((ace_yyvsp[(2) - (2)].ident_)); ;}
1504     break;
1505
1506   case 18:
1507
1508     {
1509       (ace_yyval.parse_node_) = new ACE_Dummy_Node ((ace_yyvsp[(3) - (4)].static_node_), (ace_yyvsp[(4) - (4)].parse_node_));
1510     ;}
1511     break;
1512
1513   case 19:
1514
1515     {
1516     ;}
1517     break;
1518
1519   case 20:
1520
1521     {
1522     ;}
1523     break;
1524
1525   case 21:
1526
1527     {
1528       // Initialize left context...
1529       (ace_yyval.static_node_) = (ace_yyvsp[(0) - (1)].static_node_);
1530     ;}
1531     break;
1532
1533   case 22:
1534
1535     {
1536       ACE_UNUSED_ARG ((ace_yyvsp[(2) - (4)]));
1537       (ace_yyval.parse_node_) = (ace_yyvsp[(3) - (4)].parse_node_);
1538     ;}
1539     break;
1540
1541   case 23:
1542
1543     { (ace_yyval.parse_node_) = 0; ;}
1544     break;
1545
1546   case 24:
1547
1548     {
1549       if ((ace_yyvsp[(2) - (2)].parse_node_) != 0)
1550         {
1551           (ace_yyvsp[(2) - (2)].parse_node_)->link ((ace_yyvsp[(1) - (2)].parse_node_));
1552           (ace_yyval.parse_node_) = (ace_yyvsp[(2) - (2)].parse_node_);
1553         }
1554     ;}
1555     break;
1556
1557   case 25:
1558
1559     { (ace_yyval.parse_node_) = 0; ;}
1560     break;
1561
1562   case 26:
1563
1564     {
1565             ;}
1566     break;
1567
1568   case 27:
1569
1570     {
1571       ACE_Static_Node *sn = (ace_yyvsp[(-1) - (1)].static_node_);
1572       ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
1573                                             (ace_yyvsp[(1) - (1)].static_node_)->name (),
1574                                             ACE_SVC_CONF_PARAM->yyerrno);
1575
1576       if (((ACE_Stream_Type *) sn->record (ACE_SVC_CONF_PARAM->config)->type ())->push (mt) == -1)
1577         {
1578           ACE_ERROR ((LM_ERROR,
1579                       ACE_TEXT ("Problem with static\n")));
1580           ACE_SVC_CONF_PARAM->yyerrno++;
1581         }
1582     ;}
1583     break;
1584
1585   case 28:
1586
1587     {
1588       ACE_Static_Node *sn = (ace_yyvsp[(-1) - (1)].static_node_);
1589       ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
1590                                             sn->name (),
1591                                             ACE_SVC_CONF_PARAM->yyerrno);
1592       if (mt != 0)
1593         mt->suspend ();
1594     ;}
1595     break;
1596
1597   case 29:
1598
1599     {
1600       ACE_Static_Node *sn = (ace_yyvsp[(-1) - (1)].static_node_);
1601       ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config),
1602                                             (ace_yyvsp[(1) - (1)].static_node_)->name (),
1603                                             ACE_SVC_CONF_PARAM->yyerrno);
1604       if (mt != 0)
1605         mt->resume ();
1606     ;}
1607     break;
1608
1609   case 30:
1610
1611     {
1612       ACE_Static_Node *stream = (ace_yyvsp[(-1) - (1)].static_node_);
1613       ACE_Static_Node *module = (ace_yyvsp[(1) - (1)].static_node_);
1614       ACE_Module_Type *mt = ace_get_module (stream->record (ACE_SVC_CONF_PARAM->config),
1615                                             module->name (),
1616                                             ACE_SVC_CONF_PARAM->yyerrno);
1617
1618       ACE_Stream_Type *st =
1619         dynamic_cast<ACE_Stream_Type *> (const_cast<ACE_Service_Type_Impl *> (stream->record (ACE_SVC_CONF_PARAM->config)->type ()));
1620       if (!st || (mt != 0 && st->remove (mt) == -1))
1621         {
1622           ACE_ERROR ((LM_ERROR,
1623                       ACE_TEXT ("cannot remove Module_Type %s from STREAM_Type %s\n"),
1624                       module->name (),
1625                       stream->name ()));
1626           ACE_SVC_CONF_PARAM->yyerrno++;
1627         }
1628     ;}
1629     break;
1630
1631   case 31:
1632
1633     {
1634       (ace_yyval.svc_record_) = new ACE_Service_Type_Factory ((ace_yyvsp[(1) - (4)].ident_), (ace_yyvsp[(2) - (4)].type_), (ace_yyvsp[(3) - (4)].location_node_), (ace_yyvsp[(4) - (4)].type_));
1635     ;}
1636     break;
1637
1638   case 32:
1639
1640     {
1641       (ace_yyval.type_) = 1;
1642     ;}
1643     break;
1644
1645   case 33:
1646
1647     {
1648       (ace_yyval.type_) = 0;
1649     ;}
1650     break;
1651
1652   case 34:
1653
1654     {
1655       (ace_yyval.type_) = 1;
1656     ;}
1657     break;
1658
1659   case 35:
1660
1661     {
1662       (ace_yyval.location_node_) = new ACE_Object_Node ((ace_yyvsp[(1) - (3)].ident_), (ace_yyvsp[(3) - (3)].ident_));
1663     ;}
1664     break;
1665
1666   case 36:
1667
1668     {
1669       (ace_yyval.location_node_) = new ACE_Function_Node ((ace_yyvsp[(1) - (5)].ident_), (ace_yyvsp[(3) - (5)].ident_));
1670     ;}
1671     break;
1672
1673   case 37:
1674
1675     {
1676       (ace_yyval.location_node_) = new ACE_Static_Function_Node ((ace_yyvsp[(2) - (4)].ident_));
1677     ;}
1678     break;
1679
1680   case 38:
1681
1682     {
1683       (ace_yyval.type_) = ACE_MODULE_T;
1684     ;}
1685     break;
1686
1687   case 39:
1688
1689     {
1690       (ace_yyval.type_) = ACE_SVC_OBJ_T;
1691     ;}
1692     break;
1693
1694   case 40:
1695
1696     {
1697       (ace_yyval.type_) = ACE_STREAM_T;
1698     ;}
1699     break;
1700
1701   case 42:
1702
1703     { (ace_yyval.ident_) = 0; ;}
1704     break;
1705
1706
1707 /* Line 1267 of yacc.c.  */
1708
1709       default: break;
1710     }
1711   YY_SYMBOL_PRINT ("-> $$ =", ace_yyr1[ace_yyn], &ace_yyval, &ace_yyloc);
1712
1713   YYPOPSTACK (ace_yylen);
1714   ace_yylen = 0;
1715   YY_STACK_PRINT (ace_yyss, ace_yyssp);
1716
1717   *++ace_yyvsp = ace_yyval;
1718
1719
1720   /* Now `shift' the result of the reduction.  Determine what state
1721      that goes to, based on the state we popped back to and the rule
1722      number reduced by.  */
1723
1724   ace_yyn = ace_yyr1[ace_yyn];
1725
1726   ace_yystate = ace_yypgoto[ace_yyn - YYNTOKENS] + *ace_yyssp;
1727   if (0 <= ace_yystate && ace_yystate <= YYLAST && ace_yycheck[ace_yystate] == *ace_yyssp)
1728     ace_yystate = ace_yytable[ace_yystate];
1729   else
1730     ace_yystate = ace_yydefgoto[ace_yyn - YYNTOKENS];
1731
1732   goto ace_yynewstate;
1733
1734
1735 /*------------------------------------.
1736 | ace_yyerrlab -- here on detecting error |
1737 `------------------------------------*/
1738 ace_yyerrlab:
1739   /* If not already recovering from an error, report this error.  */
1740   if (!ace_yyerrstatus)
1741     {
1742       ++ace_yynerrs;
1743 #if ! YYERROR_VERBOSE
1744       ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, YY_("syntax error"));
1745 #else
1746       {
1747   YYSIZE_T ace_yysize = ace_yysyntax_error (0, ace_yystate, ace_yychar);
1748   if (ace_yymsg_alloc < ace_yysize && ace_yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1749     {
1750       YYSIZE_T ace_yyalloc = 2 * ace_yysize;
1751       if (! (ace_yysize <= ace_yyalloc && ace_yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1752         ace_yyalloc = YYSTACK_ALLOC_MAXIMUM;
1753       if (ace_yymsg != ace_yymsgbuf)
1754         YYSTACK_FREE (ace_yymsg);
1755       ace_yymsg = (char *) YYSTACK_ALLOC (ace_yyalloc);
1756       if (ace_yymsg)
1757         ace_yymsg_alloc = ace_yyalloc;
1758       else
1759         {
1760     ace_yymsg = ace_yymsgbuf;
1761     ace_yymsg_alloc = sizeof ace_yymsgbuf;
1762         }
1763     }
1764
1765   if (0 < ace_yysize && ace_yysize <= ace_yymsg_alloc)
1766     {
1767       (void) ace_yysyntax_error (ace_yymsg, ace_yystate, ace_yychar);
1768       ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ace_yymsg);
1769     }
1770   else
1771     {
1772       ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, YY_("syntax error"));
1773       if (ace_yysize != 0)
1774         goto ace_yyexhaustedlab;
1775     }
1776       }
1777 #endif
1778     }
1779
1780
1781
1782   if (ace_yyerrstatus == 3)
1783     {
1784       /* If just tried and failed to reuse look-ahead token after an
1785    error, discard it.  */
1786
1787       if (ace_yychar <= YYEOF)
1788   {
1789     /* Return failure if at end of input.  */
1790     if (ace_yychar == YYEOF)
1791       YYABORT;
1792   }
1793       else
1794   {
1795     ace_yydestruct ("Error: discarding",
1796           ace_yytoken, &ace_yylval);
1797     ace_yychar = YYEMPTY;
1798   }
1799     }
1800
1801   /* Else will try to reuse look-ahead token after shifting the error
1802      token.  */
1803   goto ace_yyerrlab1;
1804
1805
1806 /*---------------------------------------------------.
1807 | ace_yyerrorlab -- error raised explicitly by YYERROR.  |
1808 `---------------------------------------------------*/
1809 ace_yyerrorlab:
1810
1811   /* Pacify compilers like GCC when the user code never invokes
1812      YYERROR and the label ace_yyerrorlab therefore never appears in user
1813      code.  */
1814   if (/*CONSTCOND*/ 0)
1815      goto ace_yyerrorlab;
1816
1817   /* Do not reclaim the symbols of the rule which action triggered
1818      this YYERROR.  */
1819   YYPOPSTACK (ace_yylen);
1820   ace_yylen = 0;
1821   YY_STACK_PRINT (ace_yyss, ace_yyssp);
1822   ace_yystate = *ace_yyssp;
1823   goto ace_yyerrlab1;
1824
1825
1826 /*-------------------------------------------------------------.
1827 | ace_yyerrlab1 -- common code for both syntax error and YYERROR.  |
1828 `-------------------------------------------------------------*/
1829 ace_yyerrlab1:
1830   ace_yyerrstatus = 3;  /* Each real token shifted decrements this.  */
1831
1832   for (;;)
1833     {
1834       ace_yyn = ace_yypact[ace_yystate];
1835       if (ace_yyn != YYPACT_NINF)
1836   {
1837     ace_yyn += YYTERROR;
1838     if (0 <= ace_yyn && ace_yyn <= YYLAST && ace_yycheck[ace_yyn] == YYTERROR)
1839       {
1840         ace_yyn = ace_yytable[ace_yyn];
1841         if (0 < ace_yyn)
1842     break;
1843       }
1844   }
1845
1846       /* Pop the current state because it cannot handle the error token.  */
1847       if (ace_yyssp == ace_yyss)
1848   YYABORT;
1849
1850
1851       ace_yydestruct ("Error: popping",
1852       ace_yystos[ace_yystate], ace_yyvsp);
1853       YYPOPSTACK (1);
1854       ace_yystate = *ace_yyssp;
1855       YY_STACK_PRINT (ace_yyss, ace_yyssp);
1856     }
1857
1858   if (ace_yyn == YYFINAL)
1859     YYACCEPT;
1860
1861   *++ace_yyvsp = ace_yylval;
1862
1863
1864   /* Shift the error token.  */
1865   YY_SYMBOL_PRINT ("Shifting", ace_yystos[ace_yyn], ace_yyvsp, ace_yylsp);
1866
1867   ace_yystate = ace_yyn;
1868   goto ace_yynewstate;
1869
1870
1871 /*-------------------------------------.
1872 | ace_yyacceptlab -- YYACCEPT comes here.  |
1873 `-------------------------------------*/
1874 ace_yyacceptlab:
1875   ace_yyresult = 0;
1876   goto ace_yyreturn;
1877
1878 /*-----------------------------------.
1879 | ace_yyabortlab -- YYABORT comes here.  |
1880 `-----------------------------------*/
1881 ace_yyabortlab:
1882   ace_yyresult = 1;
1883   goto ace_yyreturn;
1884
1885 #ifndef ace_yyoverflow
1886 /*-------------------------------------------------.
1887 | ace_yyexhaustedlab -- memory exhaustion comes here.  |
1888 `-------------------------------------------------*/
1889 ace_yyexhaustedlab:
1890   ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, YY_("memory exhausted"));
1891   ace_yyresult = 2;
1892   /* Fall through.  */
1893 #endif
1894
1895 ace_yyreturn:
1896   if (ace_yychar != YYEOF && ace_yychar != YYEMPTY)
1897      ace_yydestruct ("Cleanup: discarding lookahead",
1898      ace_yytoken, &ace_yylval);
1899   /* Do not reclaim the symbols of the rule which action triggered
1900      this YYABORT or YYACCEPT.  */
1901   YYPOPSTACK (ace_yylen);
1902   YY_STACK_PRINT (ace_yyss, ace_yyssp);
1903   while (ace_yyssp != ace_yyss)
1904     {
1905       ace_yydestruct ("Cleanup: popping",
1906       ace_yystos[*ace_yyssp], ace_yyvsp);
1907       YYPOPSTACK (1);
1908     }
1909 #ifndef ace_yyoverflow
1910   if (ace_yyss != ace_yyssa)
1911     YYSTACK_FREE (ace_yyss);
1912 #endif
1913 #if YYERROR_VERBOSE
1914   if (ace_yymsg != ace_yymsgbuf)
1915     YYSTACK_FREE (ace_yymsg);
1916 #endif
1917   /* Make sure YYID is used.  */
1918   return YYID (ace_yyresult);
1919 }
1920
1921
1922
1923
1924
1925 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
1926
1927 // Prints the error string to standard output.  Cleans up the error
1928 // messages.
1929
1930 void
1931 ace_yyerror (int ace_yyerrno, int ace_yylineno, ACE_TCHAR const * s)
1932 {
1933 #if defined (ACE_NLOGGING)
1934   ACE_UNUSED_ARG (ace_yyerrno);
1935   ACE_UNUSED_ARG (ace_yylineno);
1936   ACE_UNUSED_ARG (s);
1937 #endif /* ACE_NLOGGING */
1938
1939   ACE_ERROR ((LM_ERROR,
1940               ACE_TEXT ("ACE (%P|%t) [error %d] on line %d: %C\n"),
1941               ace_yyerrno,
1942               ace_yylineno,
1943               s));
1944 }
1945
1946 void
1947 ace_yyerror (ACE_TCHAR const * s)
1948 {
1949   ace_yyerror (-1, -1, s);
1950 }
1951
1952 // Note that SRC_REC represents left context, which is the STREAM *
1953 // record.
1954
1955 static ACE_Module_Type *
1956 ace_get_module (ACE_Service_Type const * sr,
1957                 ACE_TCHAR const * svc_name,
1958                 int & ace_yyerrno)
1959 {
1960   ACE_Service_Type_Impl const * const type = sr->type ();
1961   ACE_Stream_Type const * const st =
1962     (sr == 0
1963      ? 0
1964      : dynamic_cast<ACE_Stream_Type const *> (type));
1965   ACE_Module_Type const * const mt = (st == 0 ? 0 : st->find (svc_name));
1966
1967   if (sr == 0 || st == 0 || mt == 0)
1968     {
1969       ACE_ERROR ((LM_ERROR,
1970                   ACE_TEXT ("cannot locate Module_Type %s ")
1971                   ACE_TEXT ("in STREAM_Type %s\n"),
1972                   svc_name,
1973                   (sr ? sr->name () : ACE_TEXT ("(nil)"))));
1974       ++ace_yyerrno;
1975     }
1976
1977   return const_cast<ACE_Module_Type *> (mt);
1978 }
1979
1980 #if defined (SVC_CONF_Y_DEBUGGING)
1981 // Main driver program.
1982
1983 int
1984 ACE_TMAIN (int argc, ACE_TCHAR *argv[])
1985 {
1986   ACE_Svc_Conf_Param param (0, stdin);
1987
1988   // Try to reopen any filename argument to use YYIN.
1989   if (argc > 1 && (ace_yyin = freopen (argv[1], "r", stdin)) == 0)
1990     (void) ACE_OS::ACE_OS::fprintf (stderr, ACE_TEXT ("usage: %s [file]\n"), argv[0]), ACE_OS::exit (1);
1991
1992   return ::ace_yyparse (&param);
1993 }
1994 #endif /* SVC_CONF_Y_DEBUGGING */
1995
1996 ACE_END_VERSIONED_NAMESPACE_DECL
1997
1998 #endif  /* ACE_USES_CLASSIC_SVC_CONF == 1 */