Svc_Conf.h File Reference

#include "ace/Obstack.h"
#include "ace/Service_Config.h"
#include "ace/Parse_Node.h"
#include "ace/Svc_Conf_Param.h"

Include dependency graph for Svc_Conf.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
union	ACE_YYSTYPE
Defines
#define	ACE_YY_DECL   extern "C" int ace_yylex (ACE_YYSTYPE *ace_yylval, void *ACE_YYLEX_PARAM)
Functions
int	ace_yyparse (void *)
	Performs the parsing.
void	ace_yyerror (int yyerrno, int yylineno, const char *)
	Error handling routine required by YACC or BISON.
ACE_Service_Type_Impl *	ace_create_service_type (const ACE_TCHAR *, int, void *, unsigned int, ACE_Service_Object_Exterminator=0)
	Factory that creates a new ACE_Service_Type_Impl.
Variables
	ACE_YY_DECL
	Performs the lexical analysis.
FILE *	ace_yyin
	Name of input stream.
ACE_TCHAR *	ace_yytext
	Holds the lexeme for the current token.
int	ace_yyleng
	Holds the length of the lexeme for the current token.

---

Detailed Description

Svc_Conf.h,v 4.40 2006/04/26 21:19:42 jeliazkov_i Exp

Author:

Doug Schmidt

Definition in file Svc_Conf.h.

---

Define Documentation

#define ACE_YY_DECL   extern "C" int ace_yylex (ACE_YYSTYPE *ace_yylval, void *ACE_YYLEX_PARAM)

Definition at line 45 of file Svc_Conf.h.

---

Function Documentation

ACE_Service_Type_Impl* ace_create_service_type (  const ACE_TCHAR *  , int  , void *  , unsigned  int, ACE_Service_Object_Exterminator  = 0 )

Factory that creates a new ACE_Service_Type_Impl.

void ace_yyerror (  int  yyerrno, int  yylineno, const char *  )

Error handling routine required by YACC or BISON. Definition at line 1643 of file Svc_Conf_y.cpp. References ACE_ERROR, ACE_LIB_TEXT, and LM_ERROR. Referenced by ace_yyparse(), ACE_Svc_Conf_Lexer::input(), ACE_Svc_Conf_Lexer::scan(), and ACE_Svc_Conf_Lexer::yylex(). { #if defined (ACE_NLOGGING) ACE_UNUSED_ARG (ace_yyerrno); ACE_UNUSED_ARG (ace_yylineno); 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)); }

int ace_yyparse (  void *   )

Performs the parsing. Definition at line 843 of file Svc_Conf_y.cpp. References ACE_ARGV, ACE_ERROR, ace_get_module(), ACE_LIB_TEXT, ACE_MODULE_T, ACE_Service_Type_Factory, ACE_STREAM_T, ACE_SVC_CONF_PARAM, ACE_SVC_OBJ_T, ACE_TCHAR, ACE_YY_REDUCE_PRINT, ACE_YY_STACK_PRINT, ACE_YY_SYMBOL_PRINT, ACE_YYABORT, ACE_YYACCEPT, ace_yycheck, ace_yydefact, ace_yydefgoto, ace_yydestruct(), ACE_YYDPRINTF, ACE_YYEMPTY, ACE_YYEOF, ace_yyerror(), ACE_YYFINAL, ACE_YYINITDEPTH, ACE_YYLAST, ACE_YYLEX, ACE_YYMAXDEPTH, ACE_YYNTOKENS, ace_yypact, ACE_YYPACT_NINF, ACE_YYPARSE_PARAM, ace_yypgoto, ACE_YYPOPSTACK, ace_yyr1, ace_yyr2, ACE_YYSIZE_T, ACE_YYSTACK_ALLOC, ACE_YYSTACK_FREE, ace_yystos, ace_yytable, ACE_YYTABLE_NINF, ACE_YYTERROR, ACE_YYTRANSLATE, ACE_ARGV_T< CHAR_TYPE >::argc(), ACE_ARGV_T< CHAR_TYPE >::argv(), ACE_YYSTYPE::ident_, ACE_Module_Type::init(), LM_ERROR, ACE_YYSTYPE::location_node_, ACE_Service_Type::name(), ACE_Parse_Node::name(), ACE_Static_Node::parameters(), ACE_YYSTYPE::parse_node_, ACE_Stream_Type::push(), ACE_Static_Node::record(), ACE_Stream_Type::remove(), ACE_Module_Type::resume(), ACE_YYSTYPE::static_node_, ACE_Module_Type::suspend(), ACE_YYSTYPE::svc_record_, ACE_Service_Type::type(), and ACE_YYSTYPE::type_. { /* The look-ahead symbol. */ int ace_yychar; /* The semantic value of the look-ahead symbol. */ ACE_YYSTYPE ace_yylval; #if defined (ACE_YYSTYPE_IS_TRIVIAL) ace_yylval = 0; #else ace_yylval.type_ = 0; #endif /* ACE_YYSTYPE_IS_TRIVIAL */ /* Number of syntax errors so far. */ int ace_yynerrs; register int ace_yystate; register int ace_yyn; int ace_yyresult; /* Number of tokens to shift before error messages enabled. */ int ace_yyerrstatus; /* Look-ahead token as an internal (translated) token number. */ int ace_yytoken = 0; /* Three stacks and their tools: `ace_yyss': related to states, `ace_yyvs': related to semantic values, `ace_yyls': related to locations. Refer to the stacks thru separate pointers, to allow ace_yyoverflow to reallocate them elsewhere. */ /* The state stack. */ short int ace_yyssa[ACE_YYINITDEPTH]; short int *ace_yyss = ace_yyssa; register short int *ace_yyssp; /* The semantic value stack. */ ACE_YYSTYPE ace_yyvsa[ACE_YYINITDEPTH]; ACE_YYSTYPE *ace_yyvs = ace_yyvsa; register ACE_YYSTYPE *ace_yyvsp; #define ACE_YYPOPSTACK (ace_yyvsp--, ace_yyssp--) ACE_YYSIZE_T ace_yystacksize = ACE_YYINITDEPTH; /* The variables used to return semantic value and location from the action routines. */ ACE_YYSTYPE ace_yyval; /* When reducing, the number of symbols on the RHS of the reduced rule. */ int ace_yylen; ACE_YYDPRINTF ((stderr, "Starting parse\n")); 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; ace_yyvsp = ace_yyvs; ace_yyvsp[0] = ace_yylval; goto ace_yysetstate; /*------------------------------------------------------------. | ace_yynewstate -- Push a new state, which is found in ace_yystate. | `------------------------------------------------------------*/ ace_yynewstate: /* 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_yyssp++; ace_yysetstate: *ace_yyssp = ace_yystate; if (ace_yyss + ace_yystacksize - 1 <= ace_yyssp) { /* Get the current used size of the three stacks, in elements. */ ACE_YYSIZE_T ace_yysize = ace_yyssp - ace_yyss + 1; #ifdef ace_yyoverflow { /* 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 int *ace_yyss1 = ace_yyss; /* Each stack pointer address is followed by the size of the data in use in that stack, in bytes. This used to be a conditional around just the two extra args, but that might be undefined if ace_yyoverflow is a macro. */ ace_yyoverflow ("parser stack overflow", &ace_yyss1, ace_yysize * sizeof (*ace_yyssp), &ace_yyvs1, ace_yysize * sizeof (*ace_yyvsp), &ace_yystacksize); ace_yyss = ace_yyss1; ace_yyvs = ace_yyvs1; } #else /* no ace_yyoverflow */ # ifndef ACE_YYSTACK_RELOCATE goto ace_yyoverflowlab; # else /* Extend the stack our own way. */ if (ACE_YYMAXDEPTH <= ace_yystacksize) goto ace_yyoverflowlab; ace_yystacksize *= 2; if (ACE_YYMAXDEPTH < ace_yystacksize) ace_yystacksize = ACE_YYMAXDEPTH; { short int *ace_yyss1 = ace_yyss; union ace_yyalloc *ace_yyptr = (union ace_yyalloc *) ACE_YYSTACK_ALLOC (ACE_YYSTACK_BYTES (ace_yystacksize)); if (! ace_yyptr) goto ace_yyoverflowlab; ACE_YYSTACK_RELOCATE (ace_yyss); ACE_YYSTACK_RELOCATE (ace_yyvs); # undef ACE_YYSTACK_RELOCATE if (ace_yyss1 != ace_yyssa) ACE_YYSTACK_FREE (ace_yyss1); } # endif #endif /* no ace_yyoverflow */ ace_yyssp = ace_yyss + ace_yysize - 1; ace_yyvsp = ace_yyvs + ace_yysize - 1; ACE_YYDPRINTF ((stderr, "Stack size increased to %lu\n", (unsigned long int) ace_yystacksize)); if (ace_yyss + ace_yystacksize - 1 <= ace_yyssp) ACE_YYABORT; } ACE_YYDPRINTF ((stderr, "Entering state %d\n", ace_yystate)); goto ace_yybackup; /*-----------. | ace_yybackup. | `-----------*/ ace_yybackup: /* Do appropriate processing given the current state. */ /* Read a look-ahead token if we need one and don't already have one. */ /* ace_yyresume: */ /* First try to decide what to do without reference to look-ahead token. */ ace_yyn = ace_yypact[ace_yystate]; if (ace_yyn == ACE_YYPACT_NINF) goto ace_yydefault; /* Not known => get a look-ahead token if don't already have one. */ /* ACE_YYCHAR is either ACE_YYEMPTY or ACE_YYEOF or a valid look-ahead symbol. */ if (ace_yychar == ACE_YYEMPTY) { ACE_YYDPRINTF ((stderr, "Reading a token: ")); ace_yychar = ACE_YYLEX; } if (ace_yychar <= ACE_YYEOF) { ace_yychar = ace_yytoken = ACE_YYEOF; ACE_YYDPRINTF ((stderr, "Now at end of input.\n")); } else { ace_yytoken = ACE_YYTRANSLATE (ace_yychar); ACE_YY_SYMBOL_PRINT ("Next token is", ace_yytoken, &ace_yylval, &ace_yylloc); } /* If the proper action on seeing token ACE_YYTOKEN is to reduce or to detect an error, take that action. */ ace_yyn += ace_yytoken; if (ace_yyn < 0 || ACE_YYLAST < ace_yyn || ace_yycheck[ace_yyn] != ace_yytoken) goto ace_yydefault; ace_yyn = ace_yytable[ace_yyn]; if (ace_yyn <= 0) { if (ace_yyn == 0 || ace_yyn == ACE_YYTABLE_NINF) goto ace_yyerrlab; ace_yyn = -ace_yyn; goto ace_yyreduce; } if (ace_yyn == ACE_YYFINAL) ACE_YYACCEPT; /* Shift the look-ahead token. */ ACE_YY_SYMBOL_PRINT ("Shifting", ace_yytoken, &ace_yylval, &ace_yylloc); /* Discard the token being shifted unless it is eof. */ if (ace_yychar != ACE_YYEOF) ace_yychar = ACE_YYEMPTY; *++ace_yyvsp = ace_yylval; /* Count tokens shifted since error; after three, turn off error status. */ if (ace_yyerrstatus) ace_yyerrstatus--; ace_yystate = ace_yyn; goto ace_yynewstate; /*-----------------------------------------------------------. | ace_yydefault -- do the default action for the current state. | `-----------------------------------------------------------*/ ace_yydefault: ace_yyn = ace_yydefact[ace_yystate]; if (ace_yyn == 0) goto ace_yyerrlab; goto ace_yyreduce; /*-----------------------------. | ace_yyreduce -- Do a reduction. | `-----------------------------*/ ace_yyreduce: /* ace_yyn is the number of a rule to reduce with. */ ace_yylen = ace_yyr2[ace_yyn]; /* If ACE_YYLEN is nonzero, implement the default value of the action: `$$ = $1'. Otherwise, the following line sets ACE_YYVAL to garbage. This behavior is undocumented and Bison users should not rely upon it. Assigning to ACE_YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that ACE_YYVAL may be used uninitialized. */ ace_yyval = ace_yyvsp[1-ace_yylen]; ACE_YY_REDUCE_PRINT (ace_yyn); switch (ace_yyn) { case 2: { if ((ace_yyvsp[0].parse_node_) != 0) { (ace_yyvsp[0].parse_node_)->apply (ACE_SVC_CONF_PARAM->config, ACE_SVC_CONF_PARAM->yyerrno); delete (ace_yyvsp[0].parse_node_); } ACE_SVC_CONF_PARAM->obstack.release (); ;} break; case 3: { ACE_SVC_CONF_PARAM->obstack.release (); ;} break; case 11: { 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 12: { (ace_yyval.parse_node_) = new ACE_Static_Node ((ace_yyvsp[-1].ident_), (ace_yyvsp[0].ident_)); ;} break; case 13: { (ace_yyval.parse_node_) = new ACE_Suspend_Node ((ace_yyvsp[0].ident_)); ;} break; case 14: { (ace_yyval.parse_node_) = new ACE_Resume_Node ((ace_yyvsp[0].ident_)); ;} break; case 15: { (ace_yyval.parse_node_) = new ACE_Remove_Node ((ace_yyvsp[0].ident_)); ;} break; case 16: { (ace_yyval.parse_node_) = new ACE_Stream_Node ((ace_yyvsp[-1].static_node_), (ace_yyvsp[0].parse_node_)); ;} break; case 17: { (ace_yyval.static_node_) = new ACE_Static_Node ((ace_yyvsp[0].ident_)); ;} break; case 18: { (ace_yyval.parse_node_) = new ACE_Dummy_Node ((ace_yyvsp[-1].static_node_), (ace_yyvsp[0].parse_node_)); ;} break; case 19: { ;} break; case 20: { ;} break; case 21: { // Initialize left context... (ace_yyval.static_node_) = (ace_yyvsp[-1].static_node_); ;} break; case 22: { (ace_yyval.parse_node_) = (ace_yyvsp[-1].parse_node_); ;} break; case 23: { (ace_yyval.parse_node_) = 0; ;} break; case 24: { 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 25: { (ace_yyval.parse_node_) = 0; ;} break; case 26: { 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->record (ACE_SVC_CONF_PARAM->config), svc_type->record (ACE_SVC_CONF_PARAM->config), ACE_SVC_CONF_PARAM->yyerrno); ACE_Stream_Type *st = dynamic_cast<ACE_Stream_Type *> (const_cast<ACE_Service_Type_Impl *> (module->record (ACE_SVC_CONF_PARAM->config)->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 27: { ACE_Static_Node *sn = (ace_yyvsp[-2].static_node_); ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config), (ace_yyvsp[0].static_node_)->name (), ACE_SVC_CONF_PARAM->yyerrno); if (((ACE_Stream_Type *) sn->record (ACE_SVC_CONF_PARAM->config)->type ())->push (mt) == -1) { ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("Problem with static\n"))); ACE_SVC_CONF_PARAM->yyerrno++; } ;} break; case 28: { ACE_Static_Node *sn = (ace_yyvsp[-2].static_node_); ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config), sn->name (), ACE_SVC_CONF_PARAM->yyerrno); if (mt != 0) mt->suspend (); ;} break; case 29: { ACE_Static_Node *sn = (ace_yyvsp[-2].static_node_); ACE_Module_Type *mt = ace_get_module (sn->record (ACE_SVC_CONF_PARAM->config), (ace_yyvsp[0].static_node_)->name (), ACE_SVC_CONF_PARAM->yyerrno); if (mt != 0) mt->resume (); ;} break; case 30: { 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->record (ACE_SVC_CONF_PARAM->config), module->name (), ACE_SVC_CONF_PARAM->yyerrno); ACE_Stream_Type *st = dynamic_cast<ACE_Stream_Type *> (const_cast<ACE_Service_Type_Impl *> (stream->record (ACE_SVC_CONF_PARAM->config)->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 31: { (ace_yyval.svc_record_) = new ACE_Service_Type_Factory ((ace_yyvsp[-3].ident_), (ace_yyvsp[-2].type_), (ace_yyvsp[-1].location_node_), (ace_yyvsp[0].type_)); ;} break; case 32: { (ace_yyval.type_) = 1; ;} break; case 33: { (ace_yyval.type_) = 0; ;} break; case 34: { (ace_yyval.type_) = 1; ;} break; case 35: { (ace_yyval.location_node_) = new ACE_Object_Node ((ace_yyvsp[-2].ident_), (ace_yyvsp[0].ident_)); ;} break; case 36: { (ace_yyval.location_node_) = new ACE_Function_Node ((ace_yyvsp[-4].ident_), (ace_yyvsp[-2].ident_)); ;} break; case 37: { (ace_yyval.location_node_) = new ACE_Static_Function_Node ((ace_yyvsp[-2].ident_)); ;} break; case 38: { (ace_yyval.type_) = ACE_MODULE_T; ;} break; case 39: { (ace_yyval.type_) = ACE_SVC_OBJ_T; ;} break; case 40: { (ace_yyval.type_) = ACE_STREAM_T; ;} break; case 42: { (ace_yyval.ident_) = 0; ;} break; } /* Line 1037 of yacc.c. */ ace_yyvsp -= ace_yylen; ace_yyssp -= ace_yylen; ACE_YY_STACK_PRINT (ace_yyss, ace_yyssp); *++ace_yyvsp = ace_yyval; /* 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_YYNTOKENS] + *ace_yyssp; if (0 <= ace_yystate && ace_yystate <= ACE_YYLAST && ace_yycheck[ace_yystate] == *ace_yyssp) ace_yystate = ace_yytable[ace_yystate]; else ace_yystate = ace_yydefgoto[ace_yyn - ACE_YYNTOKENS]; goto ace_yynewstate; /*------------------------------------. | ace_yyerrlab -- here on detecting error | `------------------------------------*/ ace_yyerrlab: /* If not already recovering from an error, report this error. */ if (!ace_yyerrstatus) { ++ace_yynerrs; #if ACE_YYERROR_VERBOSE ace_yyn = ace_yypact[ace_yystate]; if (ACE_YYPACT_NINF < ace_yyn && ace_yyn < ACE_YYLAST) { ACE_YYSIZE_T ace_yysize = 0; int ace_yytype = ACE_YYTRANSLATE (ace_yychar); const char* ace_yyprefix; char *ace_yymsg; int ace_yyx; /* Start ACE_YYX at -ACE_YYN if negative to avoid negative indexes in ACE_YYCHECK. */ int ace_yyxbegin = ace_yyn < 0 ? -ace_yyn : 0; /* Stay within bounds of both ace_yycheck and ace_yytname. */ int ace_yychecklim = ACE_YYLAST - ace_yyn; int ace_yyxend = ace_yychecklim < ACE_YYNTOKENS ? ace_yychecklim : ACE_YYNTOKENS; int ace_yycount = 0; ace_yyprefix = ", expecting "; for (ace_yyx = ace_yyxbegin; ace_yyx < ace_yyxend; ++ace_yyx) if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx && ace_yyx != ACE_YYTERROR) { ace_yysize += ace_yystrlen (ace_yyprefix) + ace_yystrlen (ace_yytname [ace_yyx]); ace_yycount += 1; if (ace_yycount == 5) { ace_yysize = 0; break; } } ace_yysize += (sizeof ("syntax error, unexpected ") + ace_yystrlen (ace_yytname[ace_yytype])); ace_yymsg = (ACE_TCHAR *) ACE_YYSTACK_ALLOC (ace_yysize); if (ace_yymsg != 0) { char *ace_yyp = ace_yystpcpy (ace_yymsg, "syntax error, unexpected "); ace_yyp = ace_yystpcpy (ace_yyp, ace_yytname[ace_yytype]); if (ace_yycount < 5) { ace_yyprefix = ", expecting "; for (ace_yyx = ace_yyxbegin; ace_yyx < ace_yyxend; ++ace_yyx) if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx && ace_yyx != ACE_YYTERROR) { ace_yyp = ace_yystpcpy (ace_yyp, ace_yyprefix); ace_yyp = ace_yystpcpy (ace_yyp, ace_yytname[ace_yyx]); ace_yyprefix = " or "; } } ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ace_yymsg); ACE_YYSTACK_FREE (ace_yymsg); } else ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "syntax error; also virtual memory exhausted"); } else #endif /* ACE_YYERROR_VERBOSE */ ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "syntax error"); } if (ace_yyerrstatus == 3) { /* If just tried and failed to reuse look-ahead token after an error, discard it. */ if (ace_yychar <= ACE_YYEOF) { /* If at end of input, pop the error token, then the rest of the stack, then return failure. */ if (ace_yychar == ACE_YYEOF) for (;;) { ACE_YYPOPSTACK; if (ace_yyssp == ace_yyss) ACE_YYABORT; ace_yydestruct ("Error: popping", ace_yystos[*ace_yyssp], ace_yyvsp); } } else { ace_yydestruct ("Error: discarding", ace_yytoken, &ace_yylval); ace_yychar = ACE_YYEMPTY; } } /* Else will try to reuse look-ahead token after shifting the error token. */ goto ace_yyerrlab1; /*---------------------------------------------------. | ace_yyerrorlab -- error raised explicitly by ACE_YYERROR. | `---------------------------------------------------*/ ace_yyerrorlab: #if defined (__GNUC__) || defined (ACE_WIN32) /* Pacify GCC when the user code never invokes ACE_YYERROR and the label ace_yyerrorlab therefore never appears in user code. */ if (0) goto ace_yyerrorlab; #endif ace_yyvsp -= ace_yylen; ace_yyssp -= ace_yylen; ace_yystate = *ace_yyssp; goto ace_yyerrlab1; /*-------------------------------------------------------------. | ace_yyerrlab1 -- common code for both syntax error and ACE_YYERROR. | `-------------------------------------------------------------*/ ace_yyerrlab1: ace_yyerrstatus = 3; /* Each real token shifted decrements this. */ for (;;) { ace_yyn = ace_yypact[ace_yystate]; if (ace_yyn != ACE_YYPACT_NINF) { ace_yyn += ACE_YYTERROR; if (0 <= ace_yyn && ace_yyn <= ACE_YYLAST && ace_yycheck[ace_yyn] == ACE_YYTERROR) { ace_yyn = ace_yytable[ace_yyn]; if (0 < ace_yyn) break; } } /* Pop the current state because it cannot handle the error token. */ if (ace_yyssp == ace_yyss) ACE_YYABORT; ace_yydestruct ("Error: popping", ace_yystos[ace_yystate], ace_yyvsp); ACE_YYPOPSTACK; ace_yystate = *ace_yyssp; ACE_YY_STACK_PRINT (ace_yyss, ace_yyssp); } if (ace_yyn == ACE_YYFINAL) ACE_YYACCEPT; *++ace_yyvsp = ace_yylval; /* Shift the error token. */ ACE_YY_SYMBOL_PRINT ("Shifting", ace_yystos[ace_yyn], ace_yyvsp, ace_yylsp); ace_yystate = ace_yyn; goto ace_yynewstate; /*-------------------------------------. | ace_yyacceptlab -- ACE_YYACCEPT comes here. | `-------------------------------------*/ ace_yyacceptlab: ace_yyresult = 0; goto ace_yyreturn; /*-----------------------------------. | ace_yyabortlab -- ACE_YYABORT comes here. | `-----------------------------------*/ ace_yyabortlab: ace_yydestruct ("Error: discarding lookahead", ace_yytoken, &ace_yylval); ace_yychar = ACE_YYEMPTY; ace_yyresult = 1; goto ace_yyreturn; #ifndef ace_yyoverflow /*----------------------------------------------. | ace_yyoverflowlab -- parser overflow comes here. | `----------------------------------------------*/ ace_yyoverflowlab: ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, "parser stack overflow"); ace_yyresult = 2; /* Fall through. */ #endif ace_yyreturn: #ifndef ace_yyoverflow if (ace_yyss != ace_yyssa) ACE_YYSTACK_FREE (ace_yyss); #endif return ace_yyresult; }

---

Variable Documentation

ACE_YY_DECL

Performs the lexical analysis. Definition at line 78 of file Svc_Conf.h.

FILE* ace_yyin

Name of input stream. Definition at line 81 of file Svc_Conf.h.

int ace_yyleng

Holds the length of the lexeme for the current token. Definition at line 90 of file Svc_Conf.h.

ACE_TCHAR* ace_yytext

Holds the lexeme for the current token. Definition at line 87 of file Svc_Conf.h.

---