Svc_Conf_y.cpp File Reference

00649 {
00650   /* If reentrant, generate the variables here. */
00651 #if ACE_YYPURE
00652   ACE_YY_DECL_VARIABLES
00653 #endif  /* !ACE_YYPURE */
00654 
00655   register int ace_yystate;
00656   register int ace_yyn;
00657   int ace_yyresult;
00658   /* Number of tokens to shift before error messages enabled.  */
00659   int ace_yyerrstatus;
00660   /* Lookahead token as an internal (translated) token number.  */
00661   int ace_yychar1 = 0;
00662 
00663   /* Three stacks and their tools:
00664      `ace_yyss': related to states,
00665      `ace_yyvs': related to semantic values,
00666      `ace_yyls': related to locations.
00667 
00668      Refer to the stacks thru separate pointers, to allow ace_yyoverflow
00669      to reallocate them elsewhere.  */
00670 
00671   /* The state stack. */
00672   short ace_yyssa[ACE_YYINITDEPTH];
00673   short *ace_yyss = ace_yyssa;
00674   register short *ace_yyssp;
00675 
00676   /* The semantic value stack.  */
00677   ACE_YYSTYPE ace_yyvsa[ACE_YYINITDEPTH];
00678   ACE_YYSTYPE *ace_yyvs = ace_yyvsa;
00679   register ACE_YYSTYPE *ace_yyvsp;
00680 
00681 #if ACE_YYLSP_NEEDED
00682   /* The location stack.  */
00683   ACE_YYLTYPE ace_yylsa[ACE_YYINITDEPTH];
00684   ACE_YYLTYPE *ace_yyls = ace_yylsa;
00685   ACE_YYLTYPE *ace_yylsp;
00686 #endif
00687 
00688 #if ACE_YYLSP_NEEDED
00689 # define ACE_YYPOPSTACK   (ace_yyvsp--, ace_yyssp--, ace_yylsp--)
00690 #else
00691 # define ACE_YYPOPSTACK   (ace_yyvsp--, ace_yyssp--)
00692 #endif
00693 
00694   ACE_YYSIZE_T ace_yystacksize = ACE_YYINITDEPTH;
00695 
00696 
00697   /* The variables used to return semantic value and location from the
00698      action routines.  */
00699   ACE_YYSTYPE ace_yyval;
00700 #if ACE_YYLSP_NEEDED
00701   ACE_YYLTYPE ace_yyloc;
00702 #endif
00703 
00704   /* When reducing, the number of symbols on the RHS of the reduced
00705      rule. */
00706   int ace_yylen;
00707 
00708   ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Starting parse\n")));
00709 
00710   ace_yystate = 0;
00711   ace_yyerrstatus = 0;
00712   ace_yynerrs = 0;
00713   ace_yychar = ACE_YYEMPTY;             /* Cause a token to be read.  */
00714 
00715   /* Initialize stack pointers.
00716      Waste one element of value and location stack
00717      so that they stay on the same level as the state stack.
00718      The wasted elements are never initialized.  */
00719 
00720   ace_yyssp = ace_yyss;
00721   ace_yyvsp = ace_yyvs;
00722 #if ACE_YYLSP_NEEDED
00723   ace_yylsp = ace_yyls;
00724 #endif
00725   goto ace_yysetstate;
00726 
00727 /*------------------------------------------------------------.
00728 | ace_yynewstate -- Push a new state, which is found in ace_yystate.  |
00729 `------------------------------------------------------------*/
00730  ace_yynewstate:
00731   /* In all cases, when you get here, the value and location stacks
00732      have just been pushed. so pushing a state here evens the stacks.
00733      */
00734   ace_yyssp++;
00735 
00736  ace_yysetstate:
00737   *ace_yyssp = ace_yystate;
00738 
00739   if (ace_yyssp >= ace_yyss + ace_yystacksize - 1)
00740     {
00741       /* Get the current used size of the three stacks, in elements.  */
00742       ACE_YYSIZE_T ace_yysize = ace_yyssp - ace_yyss + 1;
00743 
00744 #ifdef ace_yyoverflow
00745       {
00746         /* Give user a chance to reallocate the stack. Use copies of
00747            these so that the &'s don't force the real ones into
00748            memory.  */
00749         ACE_YYSTYPE *ace_yyvs1 = ace_yyvs;
00750         short *ace_yyss1 = ace_yyss;
00751 
00752         /* Each stack pointer address is followed by the size of the
00753            data in use in that stack, in bytes.  */
00754 # if ACE_YYLSP_NEEDED
00755         ACE_YYLTYPE *ace_yyls1 = ace_yyls;
00756         /* This used to be a conditional around just the two extra args,
00757            but that might be undefined if ace_yyoverflow is a macro.  */
00758         ace_yyoverflow (ACE_LIB_TEXT ("parser stack overflow"),
00759                     &ace_yyss1, ace_yysize * sizeof (*ace_yyssp),
00760                     &ace_yyvs1, ace_yysize * sizeof (*ace_yyvsp),
00761                     &ace_yyls1, ace_yysize * sizeof (*ace_yylsp),
00762                     &ace_yystacksize);
00763         ace_yyls = ace_yyls1;
00764 # else
00765         ace_yyoverflow (ACE_LIB_TEXT ("parser stack overflow"),
00766                     &ace_yyss1, ace_yysize * sizeof (*ace_yyssp),
00767                     &ace_yyvs1, ace_yysize * sizeof (*ace_yyvsp),
00768                     &ace_yystacksize);
00769 # endif
00770         ace_yyss = ace_yyss1;
00771         ace_yyvs = ace_yyvs1;
00772       }
00773 #else /* no ace_yyoverflow */
00774 # ifndef ACE_YYSTACK_RELOCATE
00775       goto ace_yyoverflowlab;
00776 # else
00777       /* Extend the stack our own way.  */
00778       if (ace_yystacksize >= ACE_YYMAXDEPTH)
00779         goto ace_yyoverflowlab;
00780       ace_yystacksize *= 2;
00781       if (ace_yystacksize > ACE_YYMAXDEPTH)
00782         ace_yystacksize = ACE_YYMAXDEPTH;
00783 
00784       {
00785         short *ace_yyss1 = ace_yyss;
00786         union ace_yyalloc *ace_yyptr =
00787           (union ace_yyalloc *) ACE_YYSTACK_ALLOC (ACE_YYSTACK_BYTES (ace_yystacksize));
00788         if (! ace_yyptr)
00789           goto ace_yyoverflowlab;
00790         ACE_YYSTACK_RELOCATE (ace_yyss);
00791         ACE_YYSTACK_RELOCATE (ace_yyvs);
00792 # if ACE_YYLSP_NEEDED
00793         ACE_YYSTACK_RELOCATE (ace_yyls);
00794 # endif
00795 # undef ACE_YYSTACK_RELOCATE
00796         if (ace_yyss1 != ace_yyssa)
00797           ACE_YYSTACK_FREE (ace_yyss1);
00798       }
00799 # endif
00800 #endif /* no ace_yyoverflow */
00801 
00802       ace_yyssp = ace_yyss + ace_yysize - 1;
00803       ace_yyvsp = ace_yyvs + ace_yysize - 1;
00804 #if ACE_YYLSP_NEEDED
00805       ace_yylsp = ace_yyls + ace_yysize - 1;
00806 #endif
00807 
00808       ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Stack size increased to %lu\n"),
00809                   (unsigned long int) ace_yystacksize));
00810 
00811       if (ace_yyssp >= ace_yyss + ace_yystacksize - 1)
00812         ACE_YYABORT;
00813     }
00814 
00815   ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Entering state %d\n"), ace_yystate));
00816 
00817   goto ace_yybackup;
00818 
00819 
00820 /*-----------.
00821 | ace_yybackup.  |
00822 `-----------*/
00823 ace_yybackup:
00824 
00825 /* Do appropriate processing given the current state.  */
00826 /* Read a lookahead token if we need one and don't already have one.  */
00827 /* ace_yyresume: */
00828 
00829   /* First try to decide what to do without reference to lookahead token.  */
00830 
00831   ace_yyn = ace_yypact[ace_yystate];
00832   if (ace_yyn == ACE_YYFLAG)
00833     goto ace_yydefault;
00834 
00835   /* Not known => get a lookahead token if don't already have one.  */
00836 
00837   /* ace_yychar is either ACE_YYEMPTY or ACE_YYEOF
00838      or a valid token in external form.  */
00839 
00840   if (ace_yychar == ACE_YYEMPTY)
00841     {
00842       ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Reading a token: ")));
00843       ace_yychar = ACE_YYLEX;
00844     }
00845 
00846   /* Convert token to internal form (in ace_yychar1) for indexing tables with */
00847 
00848   if (ace_yychar <= 0)          /* This means end of input. */
00849     {
00850       ace_yychar1 = 0;
00851       ace_yychar = ACE_YYEOF;           /* Don't call ACE_YYLEX any more */
00852 
00853       ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Now at end of input.\n")));
00854     }
00855   else
00856     {
00857       ace_yychar1 = ACE_YYTRANSLATE (ace_yychar);
00858 
00859 #if ACE_YYDEBUG
00860      /* We have to keep this `#if ACE_YYDEBUG', since we use variables
00861         which are defined only if `ACE_YYDEBUG' is set.  */
00862       if (ace_yydebug)
00863         {
00864           ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("Next token is %d (%s"),
00865                      ace_yychar, ace_yytname[ace_yychar1]);
00866           /* Give the individual parser a way to print the precise
00867              meaning of a token, for further debugging info.  */
00868 # ifdef ACE_YYPRINT
00869           ACE_YYPRINT (stderr, ace_yychar, ace_yylval);
00870 # endif
00871           ACE_YYFPRINTF (stderr, ACE_LIB_TEXT (")\n"));
00872         }
00873 #endif
00874     }
00875 
00876   ace_yyn += ace_yychar1;
00877   if (ace_yyn < 0 || ace_yyn > ACE_YYLAST || ace_yycheck[ace_yyn] != ace_yychar1)
00878     goto ace_yydefault;
00879 
00880   ace_yyn = ace_yytable[ace_yyn];
00881 
00882   /* ace_yyn is what to do for this token type in this state.
00883      Negative => reduce, -ace_yyn is rule number.
00884      Positive => shift, ace_yyn is new state.
00885        New state is final state => don't bother to shift,
00886        just return success.
00887      0, or most negative number => error.  */
00888 
00889   if (ace_yyn < 0)
00890     {
00891       if (ace_yyn == ACE_YYFLAG)
00892         goto ace_yyerrlab;
00893       ace_yyn = -ace_yyn;
00894       goto ace_yyreduce;
00895     }
00896   else if (ace_yyn == 0)
00897     goto ace_yyerrlab;
00898 
00899   if (ace_yyn == ACE_YYFINAL)
00900     ACE_YYACCEPT;
00901 
00902   /* Shift the lookahead token.  */
00903   ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Shifting token %d (%s), "),
00904               ace_yychar, ace_yytname[ace_yychar1]));
00905 
00906   /* Discard the token being shifted unless it is eof.  */
00907   if (ace_yychar != ACE_YYEOF)
00908     ace_yychar = ACE_YYEMPTY;
00909 
00910   *++ace_yyvsp = ace_yylval;
00911 #if ACE_YYLSP_NEEDED
00912   *++ace_yylsp = ace_yylloc;
00913 #endif
00914 
00915   /* Count tokens shifted since error; after three, turn off error
00916      status.  */
00917   if (ace_yyerrstatus)
00918     ace_yyerrstatus--;
00919 
00920   ace_yystate = ace_yyn;
00921   goto ace_yynewstate;
00922 
00923 
00924 /*-----------------------------------------------------------.
00925 | ace_yydefault -- do the default action for the current state.  |
00926 `-----------------------------------------------------------*/
00927 ace_yydefault:
00928   ace_yyn = ace_yydefact[ace_yystate];
00929   if (ace_yyn == 0)
00930     goto ace_yyerrlab;
00931   goto ace_yyreduce;
00932 
00933 
00934 /*-----------------------------.
00935 | ace_yyreduce -- Do a reduction.  |
00936 `-----------------------------*/
00937 ace_yyreduce:
00938   /* ace_yyn is the number of a rule to reduce with.  */
00939   ace_yylen = ace_yyr2[ace_yyn];
00940 
00941   /* If ACE_YYLEN is nonzero, implement the default value of the action:
00942      `$$ = $1'.
00943 
00944      Otherwise, the following line sets ACE_YYVAL to the semantic value of
00945      the lookahead token.  This behavior is undocumented and Bison
00946      users should not rely upon it.  Assigning to ACE_YYVAL
00947      unconditionally makes the parser a bit smaller, and it avoids a
00948      GCC warning that ACE_YYVAL may be used uninitialized.  */
00949   ace_yyval = ace_yyvsp[1-ace_yylen];
00950 
00951 #if ACE_YYLSP_NEEDED
00952   /* Similarly for the default location.  Let the user run additional
00953      commands if for instance locations are ranges.  */
00954   ace_yyloc = ace_yylsp[1-ace_yylen];
00955   ACE_YYLLOC_DEFAULT (ace_yyloc, (ace_yylsp - ace_yylen), ace_yylen);
00956 #endif
00957 
00958 #if ACE_YYDEBUG
00959   /* We have to keep this `#if ACE_YYDEBUG', since we use variables which
00960      are defined only if `ACE_YYDEBUG' is set.  */
00961   if (ace_yydebug)
00962     {
00963       int ace_yyi;
00964 
00965       ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("Reducing via rule %d (line %d), "),
00966                  ace_yyn, ace_yyrline[ace_yyn]);
00967 
00968       /* Print the symbols being reduced, and their result.  */
00969       for (ace_yyi = ace_yyprhs[ace_yyn]; ace_yyrhs[ace_yyi] > 0; ace_yyi++)
00970         ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("%s "), ace_yytname[ace_yyrhs[ace_yyi]]);
00971       ACE_YYFPRINTF (stderr, ACE_LIB_TEXT (" -> %s\n"), ace_yytname[ace_yyr1[ace_yyn]]);
00972     }
00973 #endif
00974 
00975   switch (ace_yyn) {
00976 
00977 case 1:
00978 {
00979       if (ace_yyvsp[0].parse_node_ != 0)
00980       {
00981         ace_yyvsp[0].parse_node_->apply (ACE_SVC_CONF_PARAM->yyerrno); delete ace_yyvsp[0].parse_node_;
00982       }
00983       ACE_SVC_CONF_PARAM->obstack.release ();
00984     ;
00985     break;}
00986 case 2:
00987 {
00988       ACE_SVC_CONF_PARAM->obstack.release ();
00989     ;
00990     break;}
00991 case 10:
00992 {
00993       if (ace_yyvsp[-1].svc_record_ != 0)
00994         ace_yyval.parse_node_ = new ACE_Dynamic_Node (ace_yyvsp[-1].svc_record_, ace_yyvsp[0].ident_);
00995       else
00996         ace_yyval.parse_node_ = 0;
00997     ;
00998     break;}
00999 case 11:
01000 {
01001       ace_yyval.parse_node_ = new ACE_Static_Node (ace_yyvsp[-1].ident_, ace_yyvsp[0].ident_);
01002     ;
01003     break;}
01004 case 12:
01005 {
01006       ace_yyval.parse_node_ = new ACE_Suspend_Node (ace_yyvsp[0].ident_);
01007     ;
01008     break;}
01009 case 13:
01010 {
01011       ace_yyval.parse_node_ = new ACE_Resume_Node (ace_yyvsp[0].ident_);
01012     ;
01013     break;}
01014 case 14:
01015 {
01016       ace_yyval.parse_node_ = new ACE_Remove_Node (ace_yyvsp[0].ident_);
01017     ;
01018     break;}
01019 case 15:
01020 {
01021       ace_yyval.parse_node_ = new ACE_Stream_Node (ace_yyvsp[-1].static_node_, ace_yyvsp[0].parse_node_);
01022     ;
01023     break;}
01024 case 16:
01025 { ace_yyval.static_node_ = new ACE_Static_Node (ace_yyvsp[0].ident_); ;
01026     break;}
01027 case 17:
01028 {
01029       ace_yyval.parse_node_ = new ACE_Dummy_Node (ace_yyvsp[-1].static_node_, ace_yyvsp[0].parse_node_);
01030     ;
01031     break;}
01032 case 18:
01033 {
01034     ;
01035     break;}
01036 case 19:
01037 {
01038     ;
01039     break;}
01040 case 20:
01041 {
01042       // Initialize left context...
01043       ace_yyval.static_node_ = ace_yyvsp[-1].static_node_;
01044     ;
01045     break;}
01046 case 21:
01047 {
01048       ace_yyval.parse_node_ = ace_yyvsp[-1].parse_node_;
01049     ;
01050     break;}
01051 case 22:
01052 { ace_yyval.parse_node_ = 0; ;
01053     break;}
01054 case 23:
01055 {
01056       if (ace_yyvsp[0].parse_node_ != 0)
01057         {
01058           ace_yyvsp[0].parse_node_->link (ace_yyvsp[-1].parse_node_);
01059           ace_yyval.parse_node_ = ace_yyvsp[0].parse_node_;
01060         }
01061     ;
01062     break;}
01063 case 24:
01064 { ace_yyval.parse_node_ = 0; ;
01065     break;}
01066 case 25:
01067 {
01068       ACE_Static_Node *svc_type = ace_yyvsp[0].static_node_;
01069 
01070       if (svc_type != 0)
01071         {
01072           ACE_Static_Node *module = ace_yyvsp[-2].static_node_;
01073 
01074           ACE_ARGV args (svc_type->parameters ());
01075           ACE_Module_Type *mt = ace_get_module (module,
01076                                                 svc_type,
01077                                                 ACE_SVC_CONF_PARAM->yyerrno);
01078           ACE_Stream_Type *st =
01079             ACE_dynamic_cast (ACE_Stream_Type *,
01080                               ACE_const_cast (ACE_Service_Type_Impl *,
01081                                               module->record ()->type ()));
01082 
01083           if (mt->init (args.argc (), args.argv ()) == -1
01084               || st->push (mt) == -1)
01085             {
01086               ACE_ERROR ((LM_ERROR,
01087                           ACE_LIB_TEXT ("dynamic initialization failed for Module %s\n"),
01088                           svc_type->name ()));
01089               ACE_SVC_CONF_PARAM->yyerrno++;
01090             }
01091         }
01092     ;
01093     break;}
01094 case 26:
01095 {
01096       ACE_Module_Type *mt = ace_get_module (ace_yyvsp[-2].static_node_,
01097                                             ace_yyvsp[0].static_node_->name (),
01098                                             ACE_SVC_CONF_PARAM->yyerrno);
01099 
01100       if (((ACE_Stream_Type *) (ace_yyvsp[-2].static_node_)->record ()->type ())->push (mt) == -1)
01101         {
01102           ACE_ERROR ((LM_ERROR,
01103                       ACE_LIB_TEXT ("Problem with static\n")));
01104           ACE_SVC_CONF_PARAM->yyerrno++;
01105         }
01106     ;
01107     break;}
01108 case 27:
01109 {
01110       ACE_Module_Type *mt = ace_get_module (ace_yyvsp[-2].static_node_,
01111                                             ace_yyvsp[0].static_node_->name (),
01112                                             ACE_SVC_CONF_PARAM->yyerrno);
01113       if (mt != 0)
01114         mt->suspend ();
01115     ;
01116     break;}
01117 case 28:
01118 {
01119       ACE_Module_Type *mt = ace_get_module (ace_yyvsp[-2].static_node_,
01120                                             ace_yyvsp[0].static_node_->name (),
01121                                             ACE_SVC_CONF_PARAM->yyerrno);
01122       if (mt != 0)
01123         mt->resume ();
01124     ;
01125     break;}
01126 case 29:
01127 {
01128       ACE_Static_Node *stream = ace_yyvsp[-2].static_node_;
01129       ACE_Static_Node *module = ace_yyvsp[0].static_node_;
01130       ACE_Module_Type *mt = ace_get_module (stream,
01131                                             module->name (),
01132                                             ACE_SVC_CONF_PARAM->yyerrno);
01133 
01134       ACE_Stream_Type *st =
01135         ACE_dynamic_cast (ACE_Stream_Type *,
01136                           ACE_const_cast (ACE_Service_Type_Impl *,
01137                                           stream->record ()->type ()));
01138       if (mt != 0 && st->remove (mt) == -1)
01139         {
01140           ACE_ERROR ((LM_ERROR,
01141                       ACE_LIB_TEXT ("cannot remove Module_Type %s from STREAM_Type %s\n"),
01142                       module->name (),
01143                       stream->name ()));
01144           ACE_SVC_CONF_PARAM->yyerrno++;
01145         }
01146     ;
01147     break;}
01148 case 30:
01149 {
01150       u_int flags
01151         = ACE_Service_Type::DELETE_THIS
01152         | (ace_yyvsp[-1].location_node_->dispose () == 0 ? 0 : ACE_Service_Type::DELETE_OBJ);
01153       ACE_Service_Object_Exterminator gobbler = 0;
01154       void *sym = ace_yyvsp[-1].location_node_->symbol (ACE_SVC_CONF_PARAM->yyerrno, &gobbler);
01155 
01156       if (sym != 0)
01157         {
01158           ACE_Service_Type_Impl *stp
01159             = ACE_Service_Config::create_service_type_impl (ace_yyvsp[-3].ident_,
01160                                                             ace_yyvsp[-2].type_,
01161                                                             sym,
01162                                                             flags,
01163                                                             gobbler);
01164           if (stp == 0)
01165             ++ACE_SVC_CONF_PARAM->yyerrno;
01166 
01167           ace_yyval.svc_record_ = new ACE_Service_Type (ace_yyvsp[-3].ident_,
01168                                      stp,
01169                                      ace_yyvsp[-1].location_node_->dll (),
01170                                      ace_yyvsp[0].type_);
01171         }
01172       else
01173         {
01174           ACE_ERROR ((LM_ERROR,
01175                       ACE_LIB_TEXT ("Unable to find service: %s\n"),
01176                       ace_yyvsp[-3].ident_));
01177           ++ACE_SVC_CONF_PARAM->yyerrno;
01178           ace_yyval.svc_record_ = 0;
01179         }
01180       delete ace_yyvsp[-1].location_node_;
01181     ;
01182     break;}
01183 case 31:
01184 {
01185       ace_yyval.type_ = 1;
01186     ;
01187     break;}
01188 case 32:
01189 {
01190       ace_yyval.type_ = 0;
01191     ;
01192     break;}
01193 case 33:
01194 {
01195       ace_yyval.type_ = 1;
01196     ;
01197     break;}
01198 case 34:
01199 {
01200       ace_yyval.location_node_ = new ACE_Object_Node (ace_yyvsp[-2].ident_, ace_yyvsp[0].ident_);
01201     ;
01202     break;}
01203 case 35:
01204 {
01205       ace_yyval.location_node_ = new ACE_Function_Node (ace_yyvsp[-4].ident_, ace_yyvsp[-2].ident_);
01206     ;
01207     break;}
01208 case 36:
01209 {
01210       ace_yyval.location_node_ = new ACE_Static_Function_Node (ace_yyvsp[-2].ident_);
01211     ;
01212     break;}
01213 case 37:
01214 {
01215       ace_yyval.type_ = ACE_MODULE_T;
01216     ;
01217     break;}
01218 case 38:
01219 {
01220       ace_yyval.type_ = ACE_SVC_OBJ_T;
01221     ;
01222     break;}
01223 case 39:
01224 {
01225       ace_yyval.type_ = ACE_STREAM_T;
01226     ;
01227     break;}
01228 case 41:
01229 { ace_yyval.ident_ = 0; ;
01230     break;}
01231 }
01232 
01233 
01234 
01235   ace_yyvsp -= ace_yylen;
01236   ace_yyssp -= ace_yylen;
01237 #if ACE_YYLSP_NEEDED
01238   ace_yylsp -= ace_yylen;
01239 #endif
01240 
01241 #if ACE_YYDEBUG
01242   if (ace_yydebug)
01243     {
01244       short *ace_yyssp1 = ace_yyss - 1;
01245       ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("state stack now"));
01246       while (ace_yyssp1 != ace_yyssp)
01247         ACE_YYFPRINTF (stderr, ACE_LIB_TEXT (" %d"), *++ace_yyssp1);
01248       ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("\n"));
01249     }
01250 #endif
01251 
01252   *++ace_yyvsp = ace_yyval;
01253 #if ACE_YYLSP_NEEDED
01254   *++ace_yylsp = ace_yyloc;
01255 #endif
01256 
01257   /* Now `shift' the result of the reduction.  Determine what state
01258      that goes to, based on the state we popped back to and the rule
01259      number reduced by.  */
01260 
01261   ace_yyn = ace_yyr1[ace_yyn];
01262 
01263   ace_yystate = ace_yypgoto[ace_yyn - ACE_YYNTBASE] + *ace_yyssp;
01264   if (ace_yystate >= 0 && ace_yystate <= ACE_YYLAST && ace_yycheck[ace_yystate] == *ace_yyssp)
01265     ace_yystate = ace_yytable[ace_yystate];
01266   else
01267     ace_yystate = ace_yydefgoto[ace_yyn - ACE_YYNTBASE];
01268 
01269   goto ace_yynewstate;
01270 
01271 
01272 /*------------------------------------.
01273 | ace_yyerrlab -- here on detecting error |
01274 `------------------------------------*/
01275 ace_yyerrlab:
01276   /* If not already recovering from an error, report this error.  */
01277   if (!ace_yyerrstatus)
01278     {
01279       ++ace_yynerrs;
01280 
01281 #ifdef ACE_YYERROR_VERBOSE
01282       ace_yyn = ace_yypact[ace_yystate];
01283 
01284       if (ace_yyn > ACE_YYFLAG && ace_yyn < ACE_YYLAST)
01285         {
01286           ACE_YYSIZE_T ace_yysize = 0;
01287           ACE_TCHAR *ace_yymsg;
01288           int ace_yyx, ace_yycount;
01289 
01290           ace_yycount = 0;
01291           /* Start ACE_YYX at -ACE_YYN if negative to avoid negative indexes in
01292              ACE_YYCHECK.  */
01293           for (ace_yyx = ace_yyn < 0 ? -ace_yyn : 0;
01294                ace_yyx < (int) (sizeof (ace_yytname) / sizeof (ACE_TCHAR *)); ace_yyx++)
01295             if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx)
01296               ace_yysize += ace_yystrlen (ace_yytname[ace_yyx]) + 15, ace_yycount++;
01297           ace_yysize += ace_yystrlen (ACE_LIB_TEXT ("parse error, unexpected ")) + 1;
01298           ace_yysize += ace_yystrlen (ace_yytname[ACE_YYTRANSLATE (ace_yychar)]);
01299           ace_yymsg = (ACE_TCHAR *) ACE_YYSTACK_ALLOC (ace_yysize);
01300           if (ace_yymsg != 0)
01301             {
01302               ACE_TCHAR *ace_yyp = ace_yystpcpy (ace_yymsg, ACE_LIB_TEXT ("parse error, unexpected "));
01303               ace_yyp = ace_yystpcpy (ace_yyp, ace_yytname[ACE_YYTRANSLATE (ace_yychar)]);
01304 
01305               if (ace_yycount < 5)
01306                 {
01307                   ace_yycount = 0;
01308                   for (ace_yyx = ace_yyn < 0 ? -ace_yyn : 0;
01309                        ace_yyx < (int) (sizeof (ace_yytname) / sizeof (ACE_TCHAR *));
01310                        ace_yyx++)
01311                     if (ace_yycheck[ace_yyx + ace_yyn] == ace_yyx)
01312                       {
01313                         const ACE_TCHAR *ace_yyq = ! ace_yycount ? ACE_LIB_TEXT (", expecting ") : ACE_LIB_TEXT (" or ");
01314                         ace_yyp = ace_yystpcpy (ace_yyp, ace_yyq);
01315                         ace_yyp = ace_yystpcpy (ace_yyp, ace_yytname[ace_yyx]);
01316                         ace_yycount++;
01317                       }
01318                 }
01319               ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ace_yymsg);
01320               ACE_YYSTACK_FREE (ace_yymsg);
01321             }
01322           else
01323             ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ACE_LIB_TEXT ("parse error; also virtual memory exhausted"));
01324         }
01325       else
01326 #endif /* defined (ACE_YYERROR_VERBOSE) */
01327         ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ACE_LIB_TEXT ("parse error"));
01328     }
01329   goto ace_yyerrlab1;
01330 
01331 
01332 /*--------------------------------------------------.
01333 | ace_yyerrlab1 -- error raised explicitly by an action |
01334 `--------------------------------------------------*/
01335 ace_yyerrlab1:
01336   if (ace_yyerrstatus == 3)
01337     {
01338       /* If just tried and failed to reuse lookahead token after an
01339          error, discard it.  */
01340 
01341       /* return failure if at end of input */
01342       if (ace_yychar == ACE_YYEOF)
01343         ACE_YYABORT;
01344       ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Discarding token %d (%s).\n"),
01345                   ace_yychar, ace_yytname[ace_yychar1]));
01346       ace_yychar = ACE_YYEMPTY;
01347     }
01348 
01349   /* Else will try to reuse lookahead token after shifting the error
01350      token.  */
01351 
01352   ace_yyerrstatus = 3;          /* Each real token shifted decrements this */
01353 
01354   goto ace_yyerrhandle;
01355 
01356 
01357 /*-------------------------------------------------------------------.
01358 | ace_yyerrdefault -- current state does not do anything special for the |
01359 | error token.                                                       |
01360 `-------------------------------------------------------------------*/
01361 ace_yyerrdefault:
01362 #if 0
01363   /* This is wrong; only states that explicitly want error tokens
01364      should shift them.  */
01365 
01366   /* If its default is to accept any token, ok.  Otherwise pop it.  */
01367   ace_yyn = ace_yydefact[ace_yystate];
01368   if (ace_yyn)
01369     goto ace_yydefault;
01370 #endif
01371 
01372 
01373 /*---------------------------------------------------------------.
01374 | ace_yyerrpop -- pop the current state because it cannot handle the |
01375 | error token                                                    |
01376 `---------------------------------------------------------------*/
01377 ace_yyerrpop:
01378   if (ace_yyssp == ace_yyss)
01379     ACE_YYABORT;
01380   ace_yyvsp--;
01381   ace_yystate = *--ace_yyssp;
01382 #if ACE_YYLSP_NEEDED
01383   ace_yylsp--;
01384 #endif
01385 
01386 #if ACE_YYDEBUG
01387   if (ace_yydebug)
01388     {
01389       short *ace_yyssp1 = ace_yyss - 1;
01390       ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("Error: state stack now"));
01391       while (ace_yyssp1 != ace_yyssp)
01392         ACE_YYFPRINTF (stderr, ACE_LIB_TEXT (" %d"), *++ace_yyssp1);
01393       ACE_YYFPRINTF (stderr, ACE_LIB_TEXT ("\n"));
01394     }
01395 #endif
01396 
01397 /*--------------.
01398 | ace_yyerrhandle.  |
01399 `--------------*/
01400 ace_yyerrhandle:
01401   ace_yyn = ace_yypact[ace_yystate];
01402   if (ace_yyn == ACE_YYFLAG)
01403     goto ace_yyerrdefault;
01404 
01405   ace_yyn += ACE_YYTERROR;
01406   if (ace_yyn < 0 || ace_yyn > ACE_YYLAST || ace_yycheck[ace_yyn] != ACE_YYTERROR)
01407     goto ace_yyerrdefault;
01408 
01409   ace_yyn = ace_yytable[ace_yyn];
01410   if (ace_yyn < 0)
01411     {
01412       if (ace_yyn == ACE_YYFLAG)
01413         goto ace_yyerrpop;
01414       ace_yyn = -ace_yyn;
01415       goto ace_yyreduce;
01416     }
01417   else if (ace_yyn == 0)
01418     goto ace_yyerrpop;
01419 
01420   if (ace_yyn == ACE_YYFINAL)
01421     ACE_YYACCEPT;
01422 
01423   ACE_YYDPRINTF ((stderr, ACE_LIB_TEXT ("Shifting error token, ")));
01424 
01425   *++ace_yyvsp = ace_yylval;
01426 #if ACE_YYLSP_NEEDED
01427   *++ace_yylsp = ace_yylloc;
01428 #endif
01429 
01430   ace_yystate = ace_yyn;
01431   goto ace_yynewstate;
01432 
01433 
01434 /*-------------------------------------.
01435 | ace_yyacceptlab -- ACE_YYACCEPT comes here.  |
01436 `-------------------------------------*/
01437 ace_yyacceptlab:
01438   ace_yyresult = 0;
01439   goto ace_yyreturn;
01440 
01441 /*-----------------------------------.
01442 | ace_yyabortlab -- ACE_YYABORT comes here.  |
01443 `-----------------------------------*/
01444 ace_yyabortlab:
01445   ace_yyresult = 1;
01446   goto ace_yyreturn;
01447 
01448 /*---------------------------------------------.
01449 | ace_yyoverflowab -- parser overflow comes here.  |
01450 `---------------------------------------------*/
01451 ace_yyoverflowlab:
01452   ace_yyerror (ACE_SVC_CONF_PARAM->yyerrno, ACE_SVC_CONF_PARAM->yylineno, ACE_LIB_TEXT ("parser stack overflow"));
01453   ace_yyresult = 2;
01454   /* Fall through.  */
01455 
01456 ace_yyreturn:
01457 #ifndef ace_yyoverflow
01458   if (ace_yyss != ace_yyssa)
01459     ACE_YYSTACK_FREE (ace_yyss);
01460 #endif
01461   return ace_yyresult;
01462 }
Defines
#define	ACE_YYBISON 1
#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
#define	ACE_YYDEBUG_LEXER_TEXT (ace_yytext[ace_yyleng] = '\0', ace_yytext)
#define	ACE_YYDEBUG 0
#define	ACE_YYFINAL 66
#define	ACE_YYFLAG -32768
#define	ACE_YYNTBASE 23
#define	ACE_YYTRANSLATE(x) ((unsigned)(x) <= 270 ? ace_yytranslate[x] : 43)
#define	ACE_YYLAST 61
#define	ACE_YYPURE 1
#define	ACE_YYSIZE_T size_t
#define	ACE_YYSTACK_ALLOC malloc
#define	ACE_YYSTACK_FREE free
#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
#define	ACE_YYFAIL goto ace_yyerrlab
#define	ACE_YYRECOVERING() (!!ace_yyerrstatus)
#define	ACE_YYBACKUP(Token, Value)
#define	ACE_YYTERROR 1
#define	ACE_YYERRCODE 256
#define	ACE_YYLLOC_DEFAULT(Current, Rhs, N)
#define	ACE_YYLEX ace_yylex (&ace_yylval, ACE_YYLEX_PARAM)
#define	ACE_YYDPRINTF(Args)
#define	ACE_YYINITDEPTH 200
#define	ACE_YYMAXDEPTH 10000
#define	ACE_YYPARSE_PARAM_ARG void *ACE_YYPARSE_PARAM
#define	ACE_YYPARSE_PARAM_DECL
#define	ACE_YY_DECL_NON_LSP_VARIABLES
#define	ACE_YY_DECL_VARIABLES ACE_YY_DECL_NON_LSP_VARIABLES
#define	ACE_YYPOPSTACK (ace_yyvsp--, ace_yyssp--)
Functions
const char *	get_rcsid_ace_Svc_Conf_y (const char *)
ACE_Module_Type *	ace_get_module (ACE_Static_Node str_rec, ACE_Static_Node svc_type, int &ace_yyerrno)
ACE_Module_Type *	ace_get_module (ACE_Static_Node str_rec, const ACE_TCHAR svc_name, int &ace_yyerrno)
int	ace_yyparse (ACE_YYPARSE_PARAM_ARG) ACE_YYPARSE_PARAM_DECL
void	ace_yyerror (int ace_yyerrno, int ace_yylineno, const ACE_TCHAR *s)
	Error handling routine required by YACC or BISON. More...
Variables
const char *	rcsid_ace_Svc_Conf_y = get_rcsid_ace_Svc_Conf_y ( rcsid_ace_Svc_Conf_y )
const ACE_TCHAR	ace_yytranslate []
const short	ace_yyr1 []
const short	ace_yyr2 []
const short	ace_yydefact []
const short	ace_yydefgoto []
const short	ace_yypact []
const short	ace_yypgoto []
const short	ace_yytable []
const short	ace_yycheck []
Svc_Conf_y.cpp File Reference

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation
