diff options
Diffstat (limited to 'ace/Svcconf/Svc_Conf_y.cpp')
-rw-r--r-- | ace/Svcconf/Svc_Conf_y.cpp | 1406 |
1 files changed, 1406 insertions, 0 deletions
diff --git a/ace/Svcconf/Svc_Conf_y.cpp b/ace/Svcconf/Svc_Conf_y.cpp new file mode 100644 index 00000000000..5c76230b920 --- /dev/null +++ b/ace/Svcconf/Svc_Conf_y.cpp @@ -0,0 +1,1406 @@ + +/* A Bison parser, made from Svc_Conf.y + by GNU Bison version 1.28 */ + +#define ACE_YYBISON 1 /* Identify Bison output. */ + +#define ACE_DYNAMIC 257 +#define ACE_STATIC 258 +#define ACE_SUSPEND 259 +#define ACE_RESUME 260 +#define ACE_REMOVE 261 +#define ACE_USTREAM 262 +#define ACE_MODULE_T 263 +#define ACE_STREAM_T 264 +#define ACE_SVC_OBJ_T 265 +#define ACE_ACTIVE 266 +#define ACE_INACTIVE 267 +#define ACE_PATHNAME 268 +#define ACE_IDENT 269 +#define ACE_STRING 270 + + +// $Id$ + +#include "ace/ARGV.h" +#include "ace/Svc_Conf.h" +#include "ace/Module.h" +#include "ace/Stream.h" + +ACE_RCSID (ace, + Svc_Conf_y, + "$Id$") + +// Prototypes. +static ACE_Module_Type *ace_get_module (ACE_Static_Node *str_rec, + ACE_Static_Node *svc_type); +static ACE_Module_Type *ace_get_module (ACE_Static_Node *str_rec, + const ACE_TCHAR *svc_name); + +#define ACE_YYDEBUG_LEXER_TEXT (ace_yytext[ace_yyleng] = '\0', ace_yytext) + +// Force the pretty debugging code to compile. +// #define ACE_YYDEBUG 1 + +// Keeps track of the number of errors encountered so far. +int ace_yyerrno = 0; + +#include <stdio.h> + +#ifndef __cplusplus +#ifndef __STDC__ +#define const +#endif +#endif + + + +#define ACE_YYFINAL 66 +#define ACE_YYFLAG -32768 +#define ACE_YYNTBASE 23 + +#define ACE_YYTRANSLATE(x) ((unsigned)(x) <= 270 ? ace_yytranslate[x] : 43) + +static const ACE_TCHAR ace_yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 20, + 21, 22, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 19, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 17, 2, 18, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 +}; + +#if ACE_YYDEBUG != 0 +static const short ace_yyprhs[] = { 0, + 0, 3, 6, 7, 9, 11, 13, 15, 17, 19, + 23, 27, 30, 33, 36, 40, 41, 46, 48, 50, + 51, 56, 57, 60, 61, 63, 65, 67, 69, 71, + 76, 78, 80, 81, 85, 91, 96, 99, 102, 105, + 107, 108, 110, 112 +}; + +static const short ace_yyrhs[] = { 23, + 24, 0, 23, 1, 0, 0, 25, 0, 26, 0, + 27, 0, 28, 0, 29, 0, 30, 0, 3, 37, + 41, 0, 4, 15, 41, 0, 5, 15, 0, 6, + 15, 0, 7, 15, 0, 8, 32, 33, 0, 0, + 8, 15, 31, 33, 0, 25, 0, 26, 0, 0, + 17, 34, 35, 18, 0, 0, 35, 36, 0, 0, + 25, 0, 26, 0, 27, 0, 28, 0, 29, 0, + 15, 40, 39, 38, 0, 12, 0, 13, 0, 0, + 42, 19, 15, 0, 42, 19, 15, 20, 21, 0, + 19, 15, 20, 21, 0, 9, 22, 0, 11, 22, + 0, 10, 22, 0, 16, 0, 0, 14, 0, 15, + 0, 16, 0 +}; + +#endif + +#if ACE_YYDEBUG != 0 +static const short ace_yyrline[] = { 0, + 49, 57, 61, 65, 66, 67, 68, 69, 70, 74, + 84, 91, 98, 105, 112, 116, 117, 123, 126, 132, + 137, 141, 145, 153, 157, 183, 194, 201, 208, 231, + 265, 269, 273, 280, 284, 288, 295, 299, 303, 310, + 311, 315, 316, 317 +}; +#endif + + +#if ACE_YYDEBUG != 0 || defined (ACE_YYERROR_VERBOSE) + +static const ACE_TCHAR * const ace_yytname[] = { ACE_LIB_TEXT("$"), + ACE_LIB_TEXT("error"), + ACE_LIB_TEXT("$undefined."), + ACE_LIB_TEXT("ACE_DYNAMIC"), + ACE_LIB_TEXT("ACE_STATIC"), + ACE_LIB_TEXT("ACE_SUSPEND"), + ACE_LIB_TEXT("ACE_RESUME"), + ACE_LIB_TEXT("ACE_REMOVE"), + ACE_LIB_TEXT("ACE_USTREAM"), + ACE_LIB_TEXT("ACE_MODULE_T"), + ACE_LIB_TEXT("ACE_STREAM_T"), + ACE_LIB_TEXT("ACE_SVC_OBJ_T"), + ACE_LIB_TEXT("ACE_ACTIVE"), + ACE_LIB_TEXT("ACE_INACTIVE"), + ACE_LIB_TEXT("ACE_PATHNAME"), + ACE_LIB_TEXT("ACE_IDENT"), + ACE_LIB_TEXT("ACE_STRING"), + ACE_LIB_TEXT("'{'"), + ACE_LIB_TEXT("'}'"), + ACE_LIB_TEXT("':'"), + ACE_LIB_TEXT("'('"), + ACE_LIB_TEXT("')'"), + ACE_LIB_TEXT("'*'"), + ACE_LIB_TEXT("svc_config_entries"), + ACE_LIB_TEXT("svc_config_entry"), + ACE_LIB_TEXT("dynamic"), + ACE_LIB_TEXT("static"), + ACE_LIB_TEXT("suspend"), + ACE_LIB_TEXT("resume"), + ACE_LIB_TEXT("remove"), + ACE_LIB_TEXT("stream"), + ACE_LIB_TEXT("@1"), + ACE_LIB_TEXT("stream_ops"), + ACE_LIB_TEXT("stream_modules"), + + ACE_LIB_TEXT("@2"), + ACE_LIB_TEXT("module_list"), + ACE_LIB_TEXT("module"), + ACE_LIB_TEXT("svc_location"), + ACE_LIB_TEXT("status"), + ACE_LIB_TEXT("svc_initializer"), + ACE_LIB_TEXT("type"), + ACE_LIB_TEXT("parameters_opt"), + ACE_LIB_TEXT("pathname"), + NULL +}; +#endif + +static const short ace_yyr1[] = { 0, + 23, 23, 23, 24, 24, 24, 24, 24, 24, 25, + 26, 27, 28, 29, 30, 31, 30, 32, 32, 34, + 33, 33, 35, 35, 36, 36, 36, 36, 36, 37, + 38, 38, 38, 39, 39, 39, 40, 40, 40, 41, + 41, 42, 42, 42 +}; + +static const short ace_yyr2[] = { 0, + 2, 2, 0, 1, 1, 1, 1, 1, 1, 3, + 3, 2, 2, 2, 3, 0, 4, 1, 1, 0, + 4, 0, 2, 0, 1, 1, 1, 1, 1, 4, + 1, 1, 0, 3, 5, 4, 2, 2, 2, 1, + 0, 1, 1, 1 +}; + +static const short ace_yydefact[] = { 3, + 0, 2, 0, 0, 0, 0, 0, 0, 1, 4, + 5, 6, 7, 8, 9, 0, 41, 41, 12, 13, + 14, 16, 18, 19, 22, 0, 0, 0, 0, 40, + 10, 11, 22, 20, 15, 37, 39, 38, 42, 43, + 44, 0, 33, 0, 17, 24, 0, 31, 32, 30, + 0, 0, 0, 34, 21, 25, 26, 27, 28, 29, + 23, 36, 0, 35, 0, 0 +}; + +static const short ace_yydefgoto[] = { 1, + 9, 10, 11, 12, 13, 14, 15, 33, 25, 35, + 46, 52, 61, 17, 50, 43, 29, 31, 44 +}; + +static const short ace_yypact[] = {-32768, + 20,-32768, 1, 3, 7, 14, 18, 4,-32768,-32768, +-32768,-32768,-32768,-32768,-32768, 21, 19, 19,-32768,-32768, +-32768,-32768,-32768,-32768, -2, 12, 15, 16, -5,-32768, +-32768,-32768, -2,-32768,-32768,-32768,-32768,-32768,-32768,-32768, +-32768, 24, 0, 17,-32768,-32768, 22,-32768,-32768,-32768, + 25, -1, 26, 23,-32768,-32768,-32768,-32768,-32768,-32768, +-32768,-32768, 27,-32768, 41,-32768 +}; + +static const short ace_yypgoto[] = {-32768, +-32768, -8, -7, -6, -3, 2,-32768,-32768,-32768, 28, +-32768,-32768,-32768,-32768,-32768,-32768,-32768, 32,-32768 +}; + + +#define ACE_YYLAST 61 + + +static const short ace_yytable[] = { 23, + 24, 3, 4, 5, 6, 7, 3, 4, 39, 40, + 41, 48, 49, 42, 34, 16, 55, 18, 22, 65, + 2, 19, 3, 4, 5, 6, 7, 8, 20, 26, + 27, 28, 21, 36, 30, 51, 37, 38, 47, 54, + 66, 53, 63, 56, 57, 58, 62, 64, 59, 32, + 0, 0, 0, 60, 0, 0, 0, 0, 0, 0, + 45 +}; + +static const short ace_yycheck[] = { 8, + 8, 3, 4, 5, 6, 7, 3, 4, 14, 15, + 16, 12, 13, 19, 17, 15, 18, 15, 15, 0, + 1, 15, 3, 4, 5, 6, 7, 8, 15, 9, + 10, 11, 15, 22, 16, 19, 22, 22, 15, 15, + 0, 20, 20, 52, 52, 52, 21, 21, 52, 18, + -1, -1, -1, 52, -1, -1, -1, -1, -1, -1, + 33 +}; +#define ACE_YYPURE 1 + +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ + +/* This file comes from bison-1.28. */ + +/* Skeleton output parser for bison, + Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +/* As a special exception, when this file is copied by Bison into a + Bison output file, you may use that output file without restriction. + This special exception was added by the Free Software Foundation + in version 1.24 of Bison. */ + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +#ifndef ACE_YYSTACK_USE_ALLOCA +#ifdef alloca +#define ACE_YYSTACK_USE_ALLOCA +#else /* alloca not defined */ +#ifdef __GNUC__ +#define ACE_YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#else /* not GNU C. */ +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) +#define ACE_YYSTACK_USE_ALLOCA +#include <alloca.h> +#else /* not sparc */ +/* We think this test detects Watcom and Microsoft C. */ +/* This used to test MSDOS, but that is a bad idea + since that symbol is in the user namespace. */ +#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) +#if 0 /* No need for malloc.h, which pollutes the namespace; + instead, just don't use alloca. */ +#include <malloc.h> +#endif +#else /* not MSDOS, or __TURBOC__ */ +#if defined(_AIX) +/* I don't know what this was needed for, but it pollutes the namespace. + So I turned it off. rms, 2 May 1997. */ +/* #include <malloc.h> */ + #pragma alloca +#define ACE_YYSTACK_USE_ALLOCA +#else /* not MSDOS, or __TURBOC__, or _AIX */ +#if 0 +#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, + and on HPUX 10. Eventually we can turn this on. */ +#define ACE_YYSTACK_USE_ALLOCA +#define alloca __builtin_alloca +#endif /* __hpux */ +#endif +#endif /* not _AIX */ +#endif /* not MSDOS, or __TURBOC__ */ +#endif /* not sparc */ +#endif /* not GNU C */ +#endif /* alloca not defined */ +#endif /* ACE_YYSTACK_USE_ALLOCA not defined */ + +#ifdef ACE_YYSTACK_USE_ALLOCA +#define ACE_YYSTACK_ALLOC alloca +#else +#define ACE_YYSTACK_ALLOC malloc +#endif + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define ace_yyerrok (ace_yyerrstatus = 0) +#define ace_yyclearin (ace_yychar = ACE_YYEMPTY) +#define ACE_YYEMPTY -2 +#define ACE_YYEOF 0 +#define ACE_YYACCEPT goto ace_yyacceptlab +#define ACE_YYABORT goto ace_yyabortlab +#define ACE_YYERROR goto ace_yyerrlab1 +/* Like ACE_YYERROR except do call ace_yyerror. + This remains here temporarily to ease the + transition to the new meaning of ACE_YYERROR, for GCC. + Once GCC version 2 has supplanted version 1, this can go. */ +#define ACE_YYFAIL goto ace_yyerrlab +#define ACE_YYRECOVERING() (!!ace_yyerrstatus) +#define ACE_YYBACKUP(token, value) \ +do \ + if (ace_yychar == ACE_YYEMPTY && ace_yylen == 1) \ + { ace_yychar = (token), ace_yylval = (value); \ + ace_yychar1 = ACE_YYTRANSLATE (ace_yychar); \ + ACE_YYPOPSTACK; \ + goto ace_yybackup; \ + } \ + else \ + { ace_yyerror (ACE_LIB_TEXT("syntax error: cannot back up")); ACE_YYERROR; } \ +while (0) + +#define ACE_YYTERROR 1 +#define ACE_YYERRCODE 256 + +#ifndef ACE_YYPURE +#define ACE_YYLEX ace_yylex() +#endif + +#ifdef ACE_YYPURE +#ifdef ACE_YYLSP_NEEDED +#ifdef ACE_YYLEX_PARAM +#define ACE_YYLEX ace_yylex(&ace_yylval, &ace_yylloc, ACE_YYLEX_PARAM) +#else +#define ACE_YYLEX ace_yylex(&ace_yylval, &ace_yylloc) +#endif +#else /* not ACE_YYLSP_NEEDED */ +#ifdef ACE_YYLEX_PARAM +#define ACE_YYLEX ace_yylex(&ace_yylval, ACE_YYLEX_PARAM) +#else +#define ACE_YYLEX ace_yylex(&ace_yylval) +#endif +#endif /* not ACE_YYLSP_NEEDED */ +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef ACE_YYPURE + +int ace_yychar; /* the lookahead symbol */ +ACE_YYSTYPE ace_yylval; /* the semantic value of the */ + /* lookahead symbol */ + +#ifdef ACE_YYLSP_NEEDED +ACE_YYLTYPE ace_yylloc; /* location data for the lookahead */ + /* symbol */ +#endif + +int ace_yynerrs; /* number of parse errors so far */ +#endif /* not ACE_YYPURE */ + +#if ACE_YYDEBUG != 0 +int ace_yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* ACE_YYINITDEPTH indicates the initial size of the parser's stacks */ + +#ifndef ACE_YYINITDEPTH +#define ACE_YYINITDEPTH 200 +#endif + +/* ACE_YYMAXDEPTH is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#if ACE_YYMAXDEPTH == 0 +#undef ACE_YYMAXDEPTH +#endif + +#ifndef ACE_YYMAXDEPTH +#define ACE_YYMAXDEPTH 10000 +#endif + +/* Define __ace_yy_memcpy. Note that the size argument + should be passed with type unsigned int, because that is what the non-GCC + definitions require. With GCC, __builtin_memcpy takes an arg + of type size_t, but it can handle unsigned int. */ + +#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ +#define __ace_yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) +#else /* not GNU C or C++ */ +#ifndef __cplusplus + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__ace_yy_memcpy (to, from, count) + ACE_TCHAR *to; + ACE_TCHAR *from; + unsigned int count; +{ + register ACE_TCHAR *f = from; + register ACE_TCHAR *t = to; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#else /* __cplusplus */ + +/* This is the most reliable way to avoid incompatibilities + in available built-in functions on various systems. */ +static void +__ace_yy_memcpy (ACE_TCHAR *to, ACE_TCHAR *from, unsigned int count) +{ + register ACE_TCHAR *t = to; + register ACE_TCHAR *f = from; + register int i = count; + + while (i-- > 0) + *t++ = *f++; +} + +#endif +#endif + + + +/* The user can define ACE_YYPARSE_PARAM as the name of an argument to be passed + into ace_yyparse. The argument should have type void *. + It should actually point to an object. + Grammar actions can access the variable by casting it + to the proper pointer type. */ + +#ifdef ACE_YYPARSE_PARAM +#ifdef __cplusplus +#define ACE_YYPARSE_PARAM_ARG void *ACE_YYPARSE_PARAM +#define ACE_YYPARSE_PARAM_DECL +#else /* not __cplusplus */ +#define ACE_YYPARSE_PARAM_ARG ACE_YYPARSE_PARAM +#define ACE_YYPARSE_PARAM_DECL void *ACE_YYPARSE_PARAM; +#endif /* not __cplusplus */ +#else /* not ACE_YYPARSE_PARAM */ +#define ACE_YYPARSE_PARAM_ARG +#define ACE_YYPARSE_PARAM_DECL +#endif /* not ACE_YYPARSE_PARAM */ + +/* Prevent warning if -Wstrict-prototypes. */ +#ifdef __GNUC__ +#ifdef ACE_YYPARSE_PARAM +int ace_yyparse (void *); +#else +int ace_yyparse (void); +#endif +#endif + +int +ace_yyparse(ACE_YYPARSE_PARAM_ARG) + ACE_YYPARSE_PARAM_DECL +{ + register int ace_yystate; + register int ace_yyn; + register short *ace_yyssp; + register ACE_YYSTYPE *ace_yyvsp; + int ace_yyerrstatus; /* number of tokens to shift before error messages enabled */ + int ace_yychar1 = 0; /* lookahead token as an internal (translated) token number */ + + short ace_yyssa[ACE_YYINITDEPTH]; /* the state stack */ + ACE_YYSTYPE ace_yyvsa[ACE_YYINITDEPTH]; /* the semantic value stack */ + + short *ace_yyss = ace_yyssa; /* refer to the stacks thru separate pointers */ + ACE_YYSTYPE *ace_yyvs = ace_yyvsa; /* to allow ace_yyoverflow to reallocate them elsewhere */ + +#ifdef ACE_YYLSP_NEEDED + ACE_YYLTYPE ace_yylsa[ACE_YYINITDEPTH]; /* the location stack */ + ACE_YYLTYPE *ace_yyls = ace_yylsa; + ACE_YYLTYPE *ace_yylsp; + +#define ACE_YYPOPSTACK (ace_yyvsp--, ace_yyssp--, ace_yylsp--) +#else +#define ACE_YYPOPSTACK (ace_yyvsp--, ace_yyssp--) +#endif + + int ace_yystacksize = ACE_YYINITDEPTH; + int ace_yyfree_stacks = 0; + +#ifdef ACE_YYPURE + int ace_yychar; + ACE_YYSTYPE ace_yylval; + int ace_yynerrs; +#ifdef ACE_YYLSP_NEEDED + ACE_YYLTYPE ace_yylloc; +#endif +#endif + + ACE_YYSTYPE ace_yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int ace_yylen; + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + ACE_OS::fprintf(stderr, ACE_LIB_TEXT("Starting parse\n")); +#endif + + ace_yystate = 0; + ace_yyerrstatus = 0; + ace_yynerrs = 0; + ace_yychar = ACE_YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. + The wasted elements are never initialized. */ + + ace_yyssp = ace_yyss - 1; + ace_yyvsp = ace_yyvs; +#ifdef ACE_YYLSP_NEEDED + ace_yylsp = ace_yyls; +#endif + +/* Push a new state, which is found in ace_yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +ace_yynewstate: + + *++ace_yyssp = ace_yystate; + + if (ace_yyssp >= ace_yyss + ace_yystacksize - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + ACE_YYSTYPE *ace_yyvs1 = ace_yyvs; + short *ace_yyss1 = ace_yyss; +#ifdef ACE_YYLSP_NEEDED + ACE_YYLTYPE *ace_yyls1 = ace_yyls; +#endif + + /* Get the current used size of the three stacks, in elements. */ + int size = ace_yyssp - ace_yyss + 1; + +#ifdef ace_yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ +#ifdef ACE_YYLSP_NEEDED + /* This used to be a conditional around just the two extra args, + but that might be undefined if ace_yyoverflow is a macro. */ + ace_yyoverflow(ACE_LIB_TEXT("parser stack overflow"), + &ace_yyss1, size * sizeof (*ace_yyssp), + &ace_yyvs1, size * sizeof (*ace_yyvsp), + &ace_yyls1, size * sizeof (*ace_yylsp), + &ace_yystacksize); +#else + ace_yyoverflow(ACE_LIB_TEXT("parser stack overflow"), + &ace_yyss1, size * sizeof (*ace_yyssp), + &ace_yyvs1, size * sizeof (*ace_yyvsp), + &ace_yystacksize); +#endif + + ace_yyss = ace_yyss1; ace_yyvs = ace_yyvs1; +#ifdef ACE_YYLSP_NEEDED + ace_yyls = ace_yyls1; +#endif +#else /* no ace_yyoverflow */ + /* Extend the stack our own way. */ + if (ace_yystacksize >= ACE_YYMAXDEPTH) + { + ace_yyerror(ACE_LIB_TEXT("parser stack overflow")); + if (ace_yyfree_stacks) + { + free (ace_yyss); + free (ace_yyvs); +#ifdef ACE_YYLSP_NEEDED + free (ace_yyls); +#endif + } + return 2; + } + ace_yystacksize *= 2; + if (ace_yystacksize > ACE_YYMAXDEPTH) + ace_yystacksize = ACE_YYMAXDEPTH; +#ifndef ACE_YYSTACK_USE_ALLOCA + ace_yyfree_stacks = 1; +#endif + ace_yyss = (short *) ACE_YYSTACK_ALLOC (ace_yystacksize * sizeof (*ace_yyssp)); + __ace_yy_memcpy ((ACE_TCHAR *)ace_yyss, (ACE_TCHAR *)ace_yyss1, + size * (unsigned int) sizeof (*ace_yyssp)); + ace_yyvs = (ACE_YYSTYPE *) ACE_YYSTACK_ALLOC (ace_yystacksize * sizeof (*ace_yyvsp)); + __ace_yy_memcpy ((ACE_TCHAR *)ace_yyvs, (ACE_TCHAR *)ace_yyvs1, + size * (unsigned int) sizeof (*ace_yyvsp)); +#ifdef ACE_YYLSP_NEEDED + ace_yyls = (ACE_YYLTYPE *) ACE_YYSTACK_ALLOC (ace_yystacksize * sizeof (*ace_yylsp)); + __ace_yy_memcpy ((ACE_TCHAR *)ace_yyls, (ACE_TCHAR *)ace_yyls1, + size * (unsigned int) sizeof (*ace_yylsp)); +#endif +#endif /* no ace_yyoverflow */ + + ace_yyssp = ace_yyss + size - 1; + ace_yyvsp = ace_yyvs + size - 1; +#ifdef ACE_YYLSP_NEEDED + ace_yylsp = ace_yyls + size - 1; +#endif + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + ACE_OS::fprintf(stderr, ACE_LIB_TEXT("Stack size increased to %d\n"), ace_yystacksize); +#endif + + if (ace_yyssp >= ace_yyss + ace_yystacksize - 1) + ACE_YYABORT; + } + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + ACE_OS::fprintf(stderr, ACE_LIB_TEXT("Entering state %d\n"), ace_yystate); +#endif + + goto ace_yybackup; + ace_yybackup: + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +/* ace_yyresume: */ + + /* First try to decide what to do without reference to lookahead token. */ + + ace_yyn = ace_yypact[ace_yystate]; + if (ace_yyn == ACE_YYFLAG) + goto ace_yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* ace_yychar is either ACE_YYEMPTY or ACE_YYEOF + or a valid token in external form. */ + + if (ace_yychar == ACE_YYEMPTY) + { +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + ACE_OS::fprintf(stderr, ACE_LIB_TEXT("Reading a token: ")); +#endif + ace_yychar = ACE_YYLEX; + } + + /* Convert token to internal form (in ace_yychar1) for indexing tables with */ + + if (ace_yychar <= 0) /* This means end of input. */ + { + ace_yychar1 = 0; + ace_yychar = ACE_YYEOF; /* Don't call ACE_YYLEX any more */ + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + ACE_OS::fprintf(stderr, ACE_LIB_TEXT("Now at end of input.\n")); +#endif + } + else + { + ace_yychar1 = ACE_YYTRANSLATE(ace_yychar); + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + { + ACE_OS::fprintf (stderr, ACE_LIB_TEXT("Next token is %d (%s"), ace_yychar, ace_yytname[ace_yychar1]); + /* Give the individual parser a way to print the precise meaning + of a token, for further debugging info. */ +#ifdef ACE_YYPRINT + ACE_YYPRINT (stderr, ace_yychar, ace_yylval); +#endif + ACE_OS::fprintf (stderr, ACE_LIB_TEXT(")\n")); + } +#endif + } + + ace_yyn += ace_yychar1; + if (ace_yyn < 0 || ace_yyn > ACE_YYLAST || ace_yycheck[ace_yyn] != ace_yychar1) + goto ace_yydefault; + + ace_yyn = ace_yytable[ace_yyn]; + + /* ace_yyn is what to do for this token type in this state. + Negative => reduce, -ace_yyn is rule number. + Positive => shift, ace_yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (ace_yyn < 0) + { + if (ace_yyn == ACE_YYFLAG) + goto ace_yyerrlab; + ace_yyn = -ace_yyn; + goto ace_yyreduce; + } + else if (ace_yyn == 0) + goto ace_yyerrlab; + + if (ace_yyn == ACE_YYFINAL) + ACE_YYACCEPT; + + /* Shift the lookahead token. */ + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + ACE_OS::fprintf(stderr, ACE_LIB_TEXT("Shifting token %d (%s), "), ace_yychar, ace_yytname[ace_yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (ace_yychar != ACE_YYEOF) + ace_yychar = ACE_YYEMPTY; + + *++ace_yyvsp = ace_yylval; +#ifdef ACE_YYLSP_NEEDED + *++ace_yylsp = ace_yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (ace_yyerrstatus) ace_yyerrstatus--; + + ace_yystate = ace_yyn; + goto ace_yynewstate; + +/* Do the default action for the current state. */ +ace_yydefault: + + ace_yyn = ace_yydefact[ace_yystate]; + if (ace_yyn == 0) + goto ace_yyerrlab; + +/* Do a reduction. ace_yyn is the number of a rule to reduce with. */ +ace_yyreduce: + ace_yylen = ace_yyr2[ace_yyn]; + if (ace_yylen > 0) + ace_yyval = ace_yyvsp[1-ace_yylen]; /* implement default value of the action */ + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + { + int i; + + ACE_OS::fprintf (stderr, ACE_LIB_TEXT("Reducing via rule %d (line %d), "), + ace_yyn, ace_yyrline[ace_yyn]); + + /* Print the symbols being reduced, and their result. */ + for (i = ace_yyprhs[ace_yyn]; ace_yyrhs[i] > 0; i++) + ACE_OS::fprintf (stderr, ACE_LIB_TEXT("%s "), ace_yytname[ace_yyrhs[i]]); + ACE_OS::fprintf (stderr, ACE_LIB_TEXT(" -> %s\n"), ace_yytname[ace_yyr1[ace_yyn]]); + } +#endif + + + switch (ace_yyn) { + +case 1: +{ + if (ace_yyvsp[0].parse_node_ != 0) + { + ace_yyvsp[0].parse_node_->apply (); delete ace_yyvsp[0].parse_node_; + } + ACE_SVC_CONF_PARAM->obstack.release (); + ; + break;} +case 2: +{ + ACE_SVC_CONF_PARAM->obstack.release (); + ; + break;} +case 10: +{ + if (ace_yyvsp[-1].svc_record_ != 0) + ace_yyval.parse_node_ = new ACE_Dynamic_Node (ace_yyvsp[-1].svc_record_, ace_yyvsp[0].ident_); + else + ace_yyval.parse_node_ = 0; + ; + break;} +case 11: +{ + ace_yyval.parse_node_ = new ACE_Static_Node (ace_yyvsp[-1].ident_, ace_yyvsp[0].ident_); + ; + break;} +case 12: +{ + ace_yyval.parse_node_ = new ACE_Suspend_Node (ace_yyvsp[0].ident_); + ; + break;} +case 13: +{ + ace_yyval.parse_node_ = new ACE_Resume_Node (ace_yyvsp[0].ident_); + ; + break;} +case 14: +{ + ace_yyval.parse_node_ = new ACE_Remove_Node (ace_yyvsp[0].ident_); + ; + break;} +case 15: +{ + ace_yyval.parse_node_ = new ACE_Stream_Node (ace_yyvsp[-1].static_node_, ace_yyvsp[0].parse_node_); + ; + break;} +case 16: +{ ace_yyval.static_node_ = new ACE_Static_Node (ace_yyvsp[0].ident_); ; + break;} +case 17: +{ + ace_yyval.parse_node_ = new ACE_Dummy_Node (ace_yyvsp[-1].static_node_, ace_yyvsp[0].parse_node_); + ; + break;} +case 18: +{ + ; + break;} +case 19: +{ + ; + break;} +case 20: +{ + // Initialize left context... + ace_yyval.static_node_ = ace_yyvsp[-1].static_node_; + ; + break;} +case 21: +{ + ace_yyval.parse_node_ = ace_yyvsp[-1].parse_node_; + ; + break;} +case 22: +{ ace_yyval.parse_node_ = 0; ; + break;} +case 23: +{ + if (ace_yyvsp[0].parse_node_ != 0) + { + ace_yyvsp[0].parse_node_->link (ace_yyvsp[-1].parse_node_); + ace_yyval.parse_node_ = ace_yyvsp[0].parse_node_; + } + ; + break;} +case 24: +{ ace_yyval.parse_node_ = 0; ; + break;} +case 25: +{ + ACE_Static_Node *svc_type = ace_yyvsp[0].static_node_; + + if (svc_type != 0) + { + ACE_Static_Node *module = ace_yyvsp[-2].static_node_; + + ACE_ARGV args (svc_type->parameters ()); + ACE_Module_Type *mt = ace_get_module (module, + svc_type); + ACE_Stream_Type *st = + ACE_dynamic_cast (ACE_Stream_Type *, + ACE_const_cast (ACE_Service_Type_Impl *, + module->record ()->type ())); + + if (mt->init (args.argc (), args.argv ()) == -1 + || st->push (mt) == -1) + { + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("dynamic initialization failed for Module %s\n"), + svc_type->name ())); + ACE_SVC_CONF_PARAM->yyerrno++; + } + } + ; + break;} +case 26: +{ + ACE_Module_Type *mt = ace_get_module (ace_yyvsp[-2].static_node_, ace_yyvsp[0].static_node_->name ()); + + if (((ACE_Stream_Type *) (ace_yyvsp[-2].static_node_)->record ()->type ())->push (mt) == -1) + { + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("Problem with static\n"))); + ACE_SVC_CONF_PARAM->yyerrno++; + } + ; + break;} +case 27: +{ + ACE_Module_Type *mt = ace_get_module (ace_yyvsp[-2].static_node_, + ace_yyvsp[0].static_node_->name ()); + if (mt != 0) + mt->suspend (); + ; + break;} +case 28: +{ + ACE_Module_Type *mt = ace_get_module (ace_yyvsp[-2].static_node_, + ace_yyvsp[0].static_node_->name ()); + if (mt != 0) + mt->resume (); + ; + break;} +case 29: +{ + ACE_Static_Node *stream = ace_yyvsp[-2].static_node_; + ACE_Static_Node *module = ace_yyvsp[0].static_node_; + ACE_Module_Type *mt = ace_get_module (stream, + module->name ()); + + ACE_Stream_Type *st = + ACE_dynamic_cast (ACE_Stream_Type *, + ACE_const_cast (ACE_Service_Type_Impl *, + stream->record ()->type ())); + if (mt != 0 && st->remove (mt) == -1) + { + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("cannot remove Module_Type %s from STREAM_Type %s\n"), + module->name (), + stream->name ())); + ACE_SVC_CONF_PARAM->yyerrno++; + } + ; + break;} +case 30: +{ + u_int flags + = ACE_Service_Type::DELETE_THIS + | (ace_yyvsp[-1].location_node_->dispose () == 0 ? 0 : ACE_Service_Type::DELETE_OBJ); + ACE_Service_Object_Exterminator gobbler = 0; + void *sym = ace_yyvsp[-1].location_node_->symbol (&gobbler); + + if (sym != 0) + { + ACE_Service_Type_Impl *stp + = ace_create_service_type (ace_yyvsp[-3].ident_, + ace_yyvsp[-2].type_, + sym, + flags, + gobbler); + ace_yyval.svc_record_ = new ACE_Service_Type (ace_yyvsp[-3].ident_, + stp, + ace_yyvsp[-1].location_node_->handle (), + ace_yyvsp[0].type_); + } + else + { + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("Unable to find service: %s\n"), + ace_yyvsp[-3].ident_)); + ++ACE_SVC_CONF_PARAM->yyerrno; + ace_yyval.svc_record_ = 0; + } + delete ace_yyvsp[-1].location_node_; + ; + break;} +case 31: +{ + ace_yyval.type_ = 1; + ; + break;} +case 32: +{ + ace_yyval.type_ = 0; + ; + break;} +case 33: +{ + ace_yyval.type_ = 1; + ; + break;} +case 34: +{ + ace_yyval.location_node_ = new ACE_Object_Node (ace_yyvsp[-2].ident_, ace_yyvsp[0].ident_); + ; + break;} +case 35: +{ + ace_yyval.location_node_ = new ACE_Function_Node (ace_yyvsp[-4].ident_, ace_yyvsp[-2].ident_); + ; + break;} +case 36: +{ + ace_yyval.location_node_ = new ACE_Static_Function_Node (ace_yyvsp[-2].ident_); + ; + break;} +case 37: +{ + ace_yyval.type_ = ACE_MODULE_T; + ; + break;} +case 38: +{ + ace_yyval.type_ = ACE_SVC_OBJ_T; + ; + break;} +case 39: +{ + ace_yyval.type_ = ACE_STREAM_T; + ; + break;} +case 41: +{ ace_yyval.ident_ = 0; ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ + + + ace_yyvsp -= ace_yylen; + ace_yyssp -= ace_yylen; +#ifdef ACE_YYLSP_NEEDED + ace_yylsp -= ace_yylen; +#endif + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + { + short *ssp1 = ace_yyss - 1; + ACE_OS::fprintf (stderr, ACE_LIB_TEXT("state stack now")); + while (ssp1 != ace_yyssp) + ACE_OS::fprintf (stderr, ACE_LIB_TEXT(" %d"), *++ssp1); + ACE_OS::fprintf (stderr, ACE_LIB_TEXT("\n")); + } +#endif + + *++ace_yyvsp = ace_yyval; + +#ifdef ACE_YYLSP_NEEDED + ace_yylsp++; + if (ace_yylen == 0) + { + ace_yylsp->first_line = ace_yylloc.first_line; + ace_yylsp->first_column = ace_yylloc.first_column; + ace_yylsp->last_line = (ace_yylsp-1)->last_line; + ace_yylsp->last_column = (ace_yylsp-1)->last_column; + ace_yylsp->text = 0; + } + else + { + ace_yylsp->last_line = (ace_yylsp+ace_yylen-1)->last_line; + ace_yylsp->last_column = (ace_yylsp+ace_yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + ace_yyn = ace_yyr1[ace_yyn]; + + ace_yystate = ace_yypgoto[ace_yyn - ACE_YYNTBASE] + *ace_yyssp; + if (ace_yystate >= 0 && ace_yystate <= ACE_YYLAST && ace_yycheck[ace_yystate] == *ace_yyssp) + ace_yystate = ace_yytable[ace_yystate]; + else + ace_yystate = ace_yydefgoto[ace_yyn - ACE_YYNTBASE]; + + goto ace_yynewstate; + +ace_yyerrlab: /* here on detecting error */ + + if (! ace_yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++ace_yynerrs; + +#ifdef ACE_YYERROR_VERBOSE + ace_yyn = ace_yypact[ace_yystate]; + + if (ace_yyn > ACE_YYFLAG && ace_yyn < ACE_YYLAST) + { + int size = 0; + ACE_TCHAR *msg; + int x, count; + + count = 0; + /* Start X at -ace_yyn if nec to avoid negative indexes in ace_yycheck. */ + for (x = (ace_yyn < 0 ? -ace_yyn : 0); + x < (sizeof(ace_yytname) / sizeof(ACE_TCHAR *)); x++) + if (ace_yycheck[x + ace_yyn] == x) + size += ACE_OS::strlen(ace_yytname[x]) + 15, count++; + msg = new ACE_TCHAR[size + 15]; + if (msg != 0) + { + ACE_OS::strcpy(msg, ACE_LIB_TEXT("parse error")); + + if (count < 5) + { + count = 0; + for (x = (ace_yyn < 0 ? -ace_yyn : 0); + x < (sizeof(ace_yytname) / sizeof(ACE_TCHAR *)); x++) + if (ace_yycheck[x + ace_yyn] == x) + { + ACE_OS::strcat(msg, count == 0 ? ACE_LIB_TEXT(", expecting `") : ACE_LIB_TEXT(" or `")); + ACE_OS::strcat(msg, ACE_TEXT_CHAR_TO_TCHAR (ace_yytname[x])); + ACE_OS::strcat(msg, ACE_LIB_TEXT("'")); + count++; + } + } + ace_yyerror(msg); + delete [] msg; + } + else + ace_yyerror (ACE_LIB_TEXT("parse error; also virtual memory exceeded")); + } + else +#endif /* ACE_YYERROR_VERBOSE */ + ace_yyerror(ACE_LIB_TEXT("parse error")); + } + + goto ace_yyerrlab1; +ace_yyerrlab1: /* here on error raised explicitly by an action */ + + if (ace_yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (ace_yychar == ACE_YYEOF) + ACE_YYABORT; + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + ACE_OS::fprintf(stderr, ACE_LIB_TEXT("Discarding token %d (%s).\n"), ace_yychar, ace_yytname[ace_yychar1]); +#endif + + ace_yychar = ACE_YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + ace_yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto ace_yyerrhandle; + +ace_yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + ace_yyn = ace_yydefact[ace_yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (ace_yyn) goto ace_yydefault; +#endif + +ace_yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (ace_yyssp == ace_yyss) ACE_YYABORT; + ace_yyvsp--; + ace_yystate = *--ace_yyssp; +#ifdef ACE_YYLSP_NEEDED + ace_yylsp--; +#endif + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + { + short *ssp1 = ace_yyss - 1; + ACE_OS::fprintf (stderr, ACE_LIB_TEXT("Error: state stack now")); + while (ssp1 != ace_yyssp) + ACE_OS::fprintf (stderr, ACE_LIB_TEXT(" %d"), *++ssp1); + ACE_OS::fprintf (stderr, ACE_LIB_TEXT("\n")); + } +#endif + +ace_yyerrhandle: + + ace_yyn = ace_yypact[ace_yystate]; + if (ace_yyn == ACE_YYFLAG) + goto ace_yyerrdefault; + + ace_yyn += ACE_YYTERROR; + if (ace_yyn < 0 || ace_yyn > ACE_YYLAST || ace_yycheck[ace_yyn] != ACE_YYTERROR) + goto ace_yyerrdefault; + + ace_yyn = ace_yytable[ace_yyn]; + if (ace_yyn < 0) + { + if (ace_yyn == ACE_YYFLAG) + goto ace_yyerrpop; + ace_yyn = -ace_yyn; + goto ace_yyreduce; + } + else if (ace_yyn == 0) + goto ace_yyerrpop; + + if (ace_yyn == ACE_YYFINAL) + ACE_YYACCEPT; + +#if ACE_YYDEBUG != 0 + if (ace_yydebug) + ACE_OS::fprintf(stderr, ACE_LIB_TEXT("Shifting error token, ")); +#endif + + *++ace_yyvsp = ace_yylval; +#ifdef ACE_YYLSP_NEEDED + *++ace_yylsp = ace_yylloc; +#endif + + ace_yystate = ace_yyn; + goto ace_yynewstate; + + ace_yyacceptlab: + /* ACE_YYACCEPT comes here. */ + if (ace_yyfree_stacks) + { + free (ace_yyss); + free (ace_yyvs); +#ifdef ACE_YYLSP_NEEDED + free (ace_yyls); +#endif + } + return 0; + + ace_yyabortlab: + /* ACE_YYABORT comes here. */ + if (ace_yyfree_stacks) + { + free (ace_yyss); + free (ace_yyvs); +#ifdef ACE_YYLSP_NEEDED + free (ace_yyls); +#endif + } + return 1; +} + +// Prints the error string to standard output. Cleans up the error +// messages. + +void +ace_yyerror (const ACE_TCHAR *s) +{ +#if defined (ACE_NLOGGING) + ACE_UNUSED_ARG (s); +#endif /* ACE_NLOGGING */ + + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("[error %d] on line %d: %s\n"), + ace_yyerrno, + ace_yylineno, + s)); +} + +// Note that SRC_REC represents left context, which is the STREAM * +// record. + +static ACE_Module_Type * +ace_get_module (ACE_Static_Node *str_rec, + const ACE_TCHAR *svc_name) +{ + const ACE_Service_Type *sr = str_rec->record (); + const ACE_Service_Type_Impl *type = sr->type (); + ACE_Stream_Type *st = sr == 0 + ? 0 + : ACE_dynamic_cast (ACE_Stream_Type *, + ACE_const_cast (ACE_Service_Type_Impl *, + type)); + ACE_Module_Type *mt = st == 0 ? 0 : st->find (svc_name); + + if (sr == 0 || st == 0 || mt == 0) + { + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("cannot locate Module_Type %s in STREAM_Type %s\n"), + svc_name, + str_rec->name ())); + ace_yyerrno++; + } + + return mt; +} + +static ACE_Module_Type * +ace_get_module (ACE_Static_Node *str_rec, + ACE_Static_Node *svc_type) +{ + const ACE_Service_Type *sr = str_rec->record (); + const ACE_Service_Type_Impl *type = sr->type (); + ACE_Stream_Type *st = sr == 0 ? 0 : (ACE_Stream_Type *) type; + const ACE_Service_Type *sv = svc_type->record (); + type = sv->type (); + ACE_Module_Type *mt = (ACE_Module_Type *) type; + const ACE_TCHAR *module_type_name = svc_type->name (); + + if (sr == 0 || st == 0 || mt == 0) + { + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("cannot locate Module_Type %s or STREAM_Type %s\n"), + module_type_name, + str_rec->name ())); + ace_yyerrno++; + } + + // Make sure that the Module has the same name as the + // Module_Type object from the svc.conf file. + ACE_Module<ACE_SYNCH> *mp = (ACE_Module<ACE_SYNCH> *) mt->object (); + + if (ACE_OS::strcmp (mp->name (), module_type_name) != 0) + { + ACE_DEBUG ((LM_DEBUG, + ACE_LIB_TEXT ("warning: assigning Module_Type name %s to Module %s since names differ\n"), + module_type_name, + mp->name ())); + mp->name (module_type_name); + } + + return mt; +} + +ACE_Service_Type_Impl * +ace_create_service_type (const ACE_TCHAR *name, + int type, + void *symbol, + u_int flags, + ACE_Service_Object_Exterminator gobbler) +{ + ACE_Service_Type_Impl *stp = 0; + + // Note, the only place we need to put a case statement. This is + // also the place where we'd put the RTTI tests, if the compiler + // actually supported them! + + switch (type) + { + case ACE_SVC_OBJ_T: + ACE_NEW_RETURN (stp, + ACE_Service_Object_Type ((ACE_Service_Object *) symbol, + name, flags, + gobbler), + 0); + break; + case ACE_MODULE_T: + ACE_NEW_RETURN (stp, + ACE_Module_Type (symbol, name, flags), + 0); + break; + case ACE_STREAM_T: + ACE_NEW_RETURN (stp, + ACE_Stream_Type (symbol, name, flags), + 0); + break; + default: + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("unknown case\n"))); + ace_yyerrno++; + break; + } + return stp; +} + +#if defined (DEBUGGING) +// Current line number. +int ace_yylineno = 1; + +// Name given on the command-line to envoke the program. +ACE_TCHAR *program_name; + +// Main driver program. + +int +main (int argc, ACE_TCHAR *argv[]) +{ + ACE_Svc_Conf_Param param (stdin); + + // Try to reopen any filename argument to use ACE_YYIN. + if (argc > 1 && (ace_yyin = freopen (argv[1], ACE_LIB_TEXT("r"), stdin)) == 0) + ACE_OS::fprintf (stderr, ACE_LIB_TEXT("usage: %s [file]\n"), argv[0]), ACE_OS::exit (1); + + return ace_yyparse (¶m); +} +#endif /* DEBUGGING */ |