TAO_PSS: PSDL_y.cpp File Reference

01397 {
01398   /* If reentrant, generate the variables here. */
01399 #if YYPURE
01400   YY_DECL_VARIABLES
01401 #endif  /* !YYPURE */
01402 
01403   register int yystate;
01404   register int yyn;
01405   int yyresult;
01406   /* Number of tokens to shift before error messages enabled.  */
01407   int yyerrstatus;
01408   /* Lookahead token as an internal (translated) token number.  */
01409   int yychar1 = 0;
01410 
01411   /* Three stacks and their tools:
01412      `yyss': related to states,
01413      `yyvs': related to semantic values,
01414      `yyls': related to locations.
01415 
01416      Refer to the stacks thru separate pointers, to allow yyoverflow
01417      to reallocate them elsewhere.  */
01418 
01419   /* The state stack. */
01420   short yyssa[YYINITDEPTH];
01421   short *yyss = yyssa;
01422   register short *yyssp;
01423 
01424   /* The semantic value stack.  */
01425   YYSTYPE yyvsa[YYINITDEPTH];
01426   YYSTYPE *yyvs = yyvsa;
01427   register YYSTYPE *yyvsp;
01428 
01429 #if YYLSP_NEEDED
01430   /* The location stack.  */
01431   YYLTYPE yylsa[YYINITDEPTH];
01432   YYLTYPE *yyls = yylsa;
01433   YYLTYPE *yylsp;
01434 #endif
01435 
01436 #if YYLSP_NEEDED
01437 # define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
01438 #else
01439 # define YYPOPSTACK   (yyvsp--, yyssp--)
01440 #endif
01441 
01442   YYSIZE_T yystacksize = YYINITDEPTH;
01443 
01444 
01445   /* When reducing, the number of symbols on the RHS of the reduced
01446      rule. */
01447   int yylen;
01448 
01449   YYDPRINTF ((stderr, "Starting parse\n"));
01450 
01451   yystate = 0;
01452   yyerrstatus = 0;
01453   yynerrs = 0;
01454   yychar = YYEMPTY;             /* Cause a token to be read.  */
01455 
01456   /* Initialize stack pointers.
01457      Waste one element of value and location stack
01458      so that they stay on the same level as the state stack.
01459      The wasted elements are never initialized.  */
01460 
01461   yyssp = yyss;
01462   yyvsp = yyvs;
01463 #if YYLSP_NEEDED
01464   yylsp = yyls;
01465 #endif
01466   goto yysetstate;
01467 
01468 /*------------------------------------------------------------.
01469 | yynewstate -- Push a new state, which is found in yystate.  |
01470 `------------------------------------------------------------*/
01471  yynewstate:
01472   /* In all cases, when you get here, the value and location stacks
01473      have just been pushed. so pushing a state here evens the stacks.
01474      */
01475   yyssp++;
01476 
01477  yysetstate:
01478   *yyssp = yystate;
01479 
01480   if (yyssp >= yyss + yystacksize - 1)
01481     {
01482       /* Get the current used size of the three stacks, in elements.  */
01483       YYSIZE_T yysize = yyssp - yyss + 1;
01484 
01485 #ifdef yyoverflow
01486       {
01487         /* Give user a chance to reallocate the stack. Use copies of
01488            these so that the &'s don't force the real ones into
01489            memory.  */
01490         YYSTYPE *yyvs1 = yyvs;
01491         short *yyss1 = yyss;
01492 
01493         /* Each stack pointer address is followed by the size of the
01494            data in use in that stack, in bytes.  */
01495 # if YYLSP_NEEDED
01496         YYLTYPE *yyls1 = yyls;
01497         /* This used to be a conditional around just the two extra args,
01498            but that might be undefined if yyoverflow is a macro.  */
01499         yyoverflow ("parser stack overflow",
01500                     &yyss1, yysize * sizeof (*yyssp),
01501                     &yyvs1, yysize * sizeof (*yyvsp),
01502                     &yyls1, yysize * sizeof (*yylsp),
01503                     &yystacksize);
01504         yyls = yyls1;
01505 # else
01506         yyoverflow ("parser stack overflow",
01507                     &yyss1, yysize * sizeof (*yyssp),
01508                     &yyvs1, yysize * sizeof (*yyvsp),
01509                     &yystacksize);
01510 # endif
01511         yyss = yyss1;
01512         yyvs = yyvs1;
01513       }
01514 #else /* no yyoverflow */
01515 # ifndef YYSTACK_RELOCATE
01516       goto yyoverflowlab;
01517 # else
01518       /* Extend the stack our own way.  */
01519       if (yystacksize >= YYMAXDEPTH)
01520         goto yyoverflowlab;
01521       yystacksize *= 2;
01522       if (yystacksize > YYMAXDEPTH)
01523         yystacksize = YYMAXDEPTH;
01524 
01525       {
01526         short *yyss1 = yyss;
01527         union yyalloc *yyptr =
01528           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01529         if (! yyptr)
01530           goto yyoverflowlab;
01531         YYSTACK_RELOCATE (yyss);
01532         YYSTACK_RELOCATE (yyvs);
01533 # if YYLSP_NEEDED
01534         YYSTACK_RELOCATE (yyls);
01535 # endif
01536 # undef YYSTACK_RELOCATE
01537         if (yyss1 != yyssa)
01538           YYSTACK_FREE (yyss1);
01539       }
01540 # endif
01541 #endif /* no yyoverflow */
01542 
01543       yyssp = yyss + yysize - 1;
01544       yyvsp = yyvs + yysize - 1;
01545 #if YYLSP_NEEDED
01546       yylsp = yyls + yysize - 1;
01547 #endif
01548 
01549       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01550                   (unsigned long int) yystacksize));
01551 
01552       if (yyssp >= yyss + yystacksize - 1)
01553         YYABORT;
01554     }
01555 
01556   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01557 
01558   goto yybackup;
01559 
01560 
01561 /*-----------.
01562 | yybackup.  |
01563 `-----------*/
01564 yybackup:
01565 
01566 /* Do appropriate processing given the current state.  */
01567 /* Read a lookahead token if we need one and don't already have one.  */
01568 /* yyresume: */
01569 
01570   /* First try to decide what to do without reference to lookahead token.  */
01571 
01572   yyn = yypact[yystate];
01573   if (yyn == YYFLAG)
01574     goto yydefault;
01575 
01576   /* Not known => get a lookahead token if don't already have one.  */
01577 
01578   /* yychar is either YYEMPTY or YYEOF
01579      or a valid token in external form.  */
01580 
01581   if (yychar == YYEMPTY)
01582     {
01583       YYDPRINTF ((stderr, "Reading a token: "));
01584       yychar = YYLEX;
01585     }
01586 
01587   /* Convert token to internal form (in yychar1) for indexing tables with */
01588 
01589   if (yychar <= 0)              /* This means end of input. */
01590     {
01591       yychar1 = 0;
01592       yychar = YYEOF;           /* Don't call YYLEX any more */
01593 
01594       YYDPRINTF ((stderr, "Now at end of input.\n"));
01595     }
01596   else
01597     {
01598       yychar1 = YYTRANSLATE (yychar);
01599 
01600 #if YYDEBUG
01601      /* We have to keep this `#if YYDEBUG', since we use variables
01602         which are defined only if `YYDEBUG' is set.  */
01603       if (yydebug)
01604         {
01605           YYFPRINTF (stderr, "Next token is %d (%s",
01606                      yychar, yytname[yychar1]);
01607           /* Give the individual parser a way to print the precise
01608              meaning of a token, for further debugging info.  */
01609 # ifdef YYPRINT
01610           YYPRINT (stderr, yychar, yylval);
01611 # endif
01612           YYFPRINTF (stderr, ")\n");
01613         }
01614 #endif
01615     }
01616 
01617   yyn += yychar1;
01618   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
01619     goto yydefault;
01620 
01621   yyn = yytable[yyn];
01622 
01623   /* yyn is what to do for this token type in this state.
01624      Negative => reduce, -yyn is rule number.
01625      Positive => shift, yyn is new state.
01626        New state is final state => don't bother to shift,
01627        just return success.
01628      0, or most negative number => error.  */
01629 
01630   if (yyn < 0)
01631     {
01632       if (yyn == YYFLAG)
01633         goto yyerrlab;
01634       yyn = -yyn;
01635       goto yyreduce;
01636     }
01637   else if (yyn == 0)
01638     goto yyerrlab;
01639 
01640   if (yyn == YYFINAL)
01641     YYACCEPT;
01642 
01643   /* Shift the lookahead token.  */
01644   YYDPRINTF ((stderr, "Shifting token %d (%s), ",
01645               yychar, yytname[yychar1]));
01646 
01647   /* Discard the token being shifted unless it is eof.  */
01648   if (yychar != YYEOF)
01649     yychar = YYEMPTY;
01650 
01651   *++yyvsp = yylval;
01652 #if YYLSP_NEEDED
01653   *++yylsp = yylloc;
01654 #endif
01655 
01656   /* Count tokens shifted since error; after three, turn off error
01657      status.  */
01658   if (yyerrstatus)
01659     yyerrstatus--;
01660 
01661   yystate = yyn;
01662   goto yynewstate;
01663 
01664 
01665 /*-----------------------------------------------------------.
01666 | yydefault -- do the default action for the current state.  |
01667 `-----------------------------------------------------------*/
01668 yydefault:
01669   yyn = yydefact[yystate];
01670   if (yyn == 0)
01671     goto yyerrlab;
01672   goto yyreduce;
01673 
01674 
01675 /*-----------------------------.
01676 | yyreduce -- Do a reduction.  |
01677 `-----------------------------*/
01678 yyreduce:
01679   /* yyn is the number of a rule to reduce with.  */
01680   yylen = yyr2[yyn];
01681 
01682   /* If YYLEN is nonzero, implement the default value of the action:
01683      `$$ = $1'.
01684 
01685      Otherwise, the following line sets YYVAL to the semantic value of
01686      the lookahead token.  This behavior is undocumented and Bison
01687      users should not rely upon it.  Assigning to YYVAL
01688      unconditionally makes the parser a bit smaller, and it avoids a
01689      GCC warning that YYVAL may be used uninitialized.  */
01690   yyval = yyvsp[1-yylen];
01691 
01692 #if YYLSP_NEEDED
01693   /* Similarly for the default location.  Let the user run additional
01694      commands if for instance locations are ranges.  */
01695   yyloc = yylsp[1-yylen];
01696   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
01697 #endif
01698 
01699 #if YYDEBUG
01700   /* We have to keep this `#if YYDEBUG', since we use variables which
01701      are defined only if `YYDEBUG' is set.  */
01702   if (yydebug)
01703     {
01704       int yyi;
01705 
01706       YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
01707                  yyn, yyrline[yyn]);
01708 
01709       /* Print the symbols being reduced, and their result.  */
01710       for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
01711         YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
01712       YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
01713     }
01714 #endif
01715 
01716   switch (yyn) {
01717 
01718 case 1:
01719 #line 79 "PSDL.yy"
01720 { yyval = new TAO_PSDL_Specification (yyvsp[0]); ;
01721     break;}
01722 case 2:
01723 #line 82 "PSDL.yy"
01724 { yyval = new TAO_PSDL_Specification (yyvsp[-1], yyvsp[0]); ;
01725     break;}
01726 case 3:
01727 #line 86 "PSDL.yy"
01728 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01729     break;}
01730 case 4:
01731 #line 89 "PSDL.yy"
01732 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01733     break;}
01734 case 5:
01735 #line 92 "PSDL.yy"
01736 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01737     break;}
01738 case 6:
01739 #line 95 "PSDL.yy"
01740 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01741     break;}
01742 case 7:
01743 #line 98 "PSDL.yy"
01744 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01745     break;}
01746 case 8:
01747 #line 101 "PSDL.yy"
01748 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01749     break;}
01750 case 9:
01751 #line 104 "PSDL.yy"
01752 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01753     break;}
01754 case 10:
01755 #line 107 "PSDL.yy"
01756 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01757     break;}
01758 case 11:
01759 #line 110 "PSDL.yy"
01760 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01761     break;}
01762 case 12:
01763 #line 113 "PSDL.yy"
01764 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01765     break;}
01766 case 13:
01767 #line 116 "PSDL.yy"
01768 { yyval = new TAO_PSDL_Definition (yyvsp[-1]); ;
01769     break;}
01770 case 14:
01771 #line 120 "PSDL.yy"
01772 {
01773   int good_module_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_module (TAO_PSDL_Scope::instance ()->get_identifier ());
01774   if (good_module_name == -1)
01775     YYABORT;
01776   ;
01777     break;}
01778 case 15:
01779 #line 126 "PSDL.yy"
01780 {
01781                   TAO_PSDL_Scope::instance ()->set_module_scope ();
01782                   yyval = new TAO_PSDL_Module (TAO_PSDL_MODULE, yyvsp[-4], yyvsp[-1]); ;
01783     break;}
01784 case 16:
01785 #line 132 "PSDL.yy"
01786 { TAO_PSDL_Scope::instance ()->set_scope ();
01787                   yyval = new TAO_PSDL_Abstract_Storagetype (yyvsp[0]); ;
01788     break;}
01789 case 17:
01790 #line 136 "PSDL.yy"
01791 { yyval = new TAO_PSDL_Abstract_Storagetype (yyvsp[0]); ;
01792     break;}
01793 case 18:
01794 #line 140 "PSDL.yy"
01795 { yyval = new TAO_PSDL_Abstract_Storagetype_Dcl (yyvsp[-3], yyvsp[-1]); ;
01796     break;}
01797 case 19:
01798 #line 143 "PSDL.yy"
01799 { yyval = new TAO_PSDL_Abstract_Storagetype_Dcl (yyvsp[-2]); ;
01800     break;}
01801 case 20:
01802 #line 147 "PSDL.yy"
01803 { yyval = new TAO_PSDL_Abstract_Storagetype_Fwd_Dcl (yyvsp[0]); ;
01804     break;}
01805 case 21:
01806 #line 151 "PSDL.yy"
01807 {
01808                   int good_storagetype_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_interface (TAO_PSDL_Scope::instance ()->get_identifier ());
01809                   if (good_storagetype_name == -1)
01810                       YYABORT;
01811 
01812                   yyval = yyvsp[0];
01813                 ;
01814     break;}
01815 case 22:
01816 #line 162 "PSDL.yy"
01817 { yyval = new TAO_PSDL_Abstract_Storagetype_Header (yyvsp[-1], yyvsp[0]); ;
01818     break;}
01819 case 23:
01820 #line 165 "PSDL.yy"
01821 { yyval = new TAO_PSDL_Abstract_Storagetype_Header (yyvsp[0]); ;
01822     break;}
01823 case 24:
01824 #line 170 "PSDL.yy"
01825 { yyval = new TAO_PSDL_Abstract_Storagetype_Body (yyvsp[0]); ;
01826     break;}
01827 case 25:
01828 #line 173 "PSDL.yy"
01829 { yyval = new TAO_PSDL_Abstract_Storagetype_Body (yyvsp[-1], yyvsp[0]); ;
01830     break;}
01831 case 26:
01832 #line 178 "PSDL.yy"
01833 { yyval = new TAO_PSDL_Abstract_Storagetype_Member (yyvsp[-1]); ;
01834     break;}
01835 case 27:
01836 #line 181 "PSDL.yy"
01837 { yyval = new TAO_PSDL_Abstract_Storagetype_Member (yyvsp[-1]); ;
01838     break;}
01839 case 28:
01840 #line 186 "PSDL.yy"
01841 { yyval = new TAO_PSDL_Abstract_Storagetype_Inh_Spec (yyvsp[0]); ;
01842     break;}
01843 case 29:
01844 #line 191 "PSDL.yy"
01845 { yyval = new TAO_PSDL_Abstract_Storagetype_Name (yyvsp[0]); ;
01846     break;}
01847 case 30:
01848 #line 194 "PSDL.yy"
01849 { yyval = new TAO_PSDL_Abstract_Storagetype_Name (yyvsp[-2], yyvsp[0]); ;
01850     break;}
01851 case 31:
01852 #line 198 "PSDL.yy"
01853 { yyval = new TAO_PSDL_Psdl_State_Dcl (yyvsp[-3], yyvsp[-1], yyvsp[0]); ;
01854     break;}
01855 case 32:
01856 #line 201 "PSDL.yy"
01857 { yyval = new TAO_PSDL_Psdl_State_Dcl (yyvsp[-1], yyvsp[0]); ;
01858     break;}
01859 case 33:
01860 #line 205 "PSDL.yy"
01861 { yyval = new TAO_PSDL_Psdl_State_Type_Spec (yyvsp[0]); ;
01862     break;}
01863 case 34:
01864 #line 208 "PSDL.yy"
01865 { yyval = new TAO_PSDL_Psdl_State_Type_Spec (yyvsp[0]); ;
01866     break;}
01867 case 35:
01868 #line 211 "PSDL.yy"
01869 { yyval = new TAO_PSDL_Psdl_State_Type_Spec (yyvsp[0]); ;
01870     break;}
01871 case 36:
01872 #line 214 "PSDL.yy"
01873 { yyval = new TAO_PSDL_Psdl_State_Type_Spec (yyvsp[0]); ;
01874     break;}
01875 case 37:
01876 #line 217 "PSDL.yy"
01877 { yyval = new TAO_PSDL_Psdl_State_Type_Spec (yyvsp[0]); ;
01878     break;}
01879 case 38:
01880 #line 222 "PSDL.yy"
01881 { yyval = new TAO_PSDL_Abstract_Storagetype_Ref_Type (yyvsp[-4], yyvsp[-1]); ;
01882     break;}
01883 case 39:
01884 #line 225 "PSDL.yy"
01885 { yyval = new TAO_PSDL_Abstract_Storagetype_Ref_Type (yyvsp[-1]); ;
01886     break;}
01887 case 40:
01888 #line 229 "PSDL.yy"
01889 { yyval = new TAO_PSDL_Abstract_Storagehome (yyvsp[0]); ;
01890     break;}
01891 case 41:
01892 #line 232 "PSDL.yy"
01893 { yyval = new TAO_PSDL_Abstract_Storagehome (yyvsp[0]); ;
01894     break;}
01895 case 42:
01896 #line 237 "PSDL.yy"
01897 { yyval = new TAO_PSDL_Abstract_Storagehome_Fwd_Dcl (yyvsp[0]); ;
01898     break;}
01899 case 43:
01900 #line 242 "PSDL.yy"
01901 { yyval = new TAO_PSDL_Abstract_Storagehome_Dcl (yyvsp[-3], yyvsp[-1]); ;
01902     break;}
01903 case 44:
01904 #line 245 "PSDL.yy"
01905 { yyval = new TAO_PSDL_Abstract_Storagehome_Dcl (yyvsp[-2]); ;
01906     break;}
01907 case 45:
01908 #line 250 "PSDL.yy"
01909 { yyval = new TAO_PSDL_Abstract_Storagehome_Header (yyvsp[-3], yyvsp[-1], yyvsp[0]); ;
01910     break;}
01911 case 46:
01912 #line 253 "PSDL.yy"
01913 { yyval = new TAO_PSDL_Abstract_Storagehome_Header (yyvsp[-2], yyvsp[0]); ;
01914     break;}
01915 case 47:
01916 #line 258 "PSDL.yy"
01917 { yyval = new TAO_PSDL_Abstract_Storagehome_Body (yyvsp[0]); ;
01918     break;}
01919 case 48:
01920 #line 261 "PSDL.yy"
01921 { yyval = new TAO_PSDL_Abstract_Storagehome_Body (yyvsp[-1], yyvsp[0]); ;
01922     break;}
01923 case 49:
01924 #line 266 "PSDL.yy"
01925 { yyval = new TAO_PSDL_Abstract_Storagehome_Member (yyvsp[-1]); ;
01926     break;}
01927 case 50:
01928 #line 269 "PSDL.yy"
01929 { yyval = new TAO_PSDL_Abstract_Storagehome_Member (yyvsp[-1]); ;
01930     break;}
01931 case 51:
01932 #line 272 "PSDL.yy"
01933 { yyval = new TAO_PSDL_Abstract_Storagehome_Member (yyvsp[-1]); ;
01934     break;}
01935 case 52:
01936 #line 277 "PSDL.yy"
01937 { yyval = new TAO_PSDL_Abstract_Storagehome_Inh_Spec (yyvsp[0]); ;
01938     break;}
01939 case 53:
01940 #line 282 "PSDL.yy"
01941 { yyval = new TAO_PSDL_Abstract_Storagehome_Name (yyvsp[0]); ;
01942     break;}
01943 case 54:
01944 #line 285 "PSDL.yy"
01945 { yyval = new TAO_PSDL_Abstract_Storagehome_Name (yyvsp[-2], yyvsp[0]); ;
01946     break;}
01947 case 55:
01948 #line 289 "PSDL.yy"
01949 { TAO_PSDL_Scope::instance ()->set_scope ();
01950                   yyval = new TAO_PSDL_Op_Dcl (yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
01951     break;}
01952 case 56:
01953 #line 293 "PSDL.yy"
01954 { TAO_PSDL_Scope::instance ()->set_scope ();
01955                   yyval = new TAO_PSDL_Op_Dcl (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
01956     break;}
01957 case 57:
01958 #line 298 "PSDL.yy"
01959 { yyval = new TAO_PSDL_Key_Dcl (yyvsp[-3], yyvsp[-1]); ;
01960     break;}
01961 case 58:
01962 #line 301 "PSDL.yy"
01963 { yyval = new TAO_PSDL_Key_Dcl (yyvsp[0]); ;
01964     break;}
01965 case 59:
01966 #line 305 "PSDL.yy"
01967 { yyval = new TAO_PSDL_Catalog (yyvsp[-4], yyvsp[-3], yyvsp[-1]); ;
01968     break;}
01969 case 60:
01970 #line 308 "PSDL.yy"
01971 { yyval = new TAO_PSDL_Catalog (yyvsp[-3], yyvsp[-1]); ;
01972     break;}
01973 case 61:
01974 #line 311 "PSDL.yy"
01975 { yyval = new TAO_PSDL_Catalog (yyvsp[-2]); ;
01976     break;}
01977 case 62:
01978 #line 314 "PSDL.yy"
01979 { yyval = new TAO_PSDL_Catalog (yyvsp[-3], yyvsp[-2]); ;
01980     break;}
01981 case 63:
01982 #line 318 "PSDL.yy"
01983 { yyval = new TAO_PSDL_Catalog_Inh_Spec (yyvsp[0]); ;
01984     break;}
01985 case 64:
01986 #line 322 "PSDL.yy"
01987 { yyval = new TAO_PSDL_Catalog_Name (yyvsp[0]); ;
01988     break;}
01989 case 65:
01990 #line 325 "PSDL.yy"
01991 { yyval = new TAO_PSDL_Catalog_Name (yyvsp[-2], yyvsp[0]); ;
01992     break;}
01993 case 66:
01994 #line 329 "PSDL.yy"
01995 { yyval = new TAO_PSDL_Catalog_Body (yyvsp[0]); ;
01996     break;}
01997 case 67:
01998 #line 332 "PSDL.yy"
01999 { yyval = new TAO_PSDL_Catalog_Body (yyvsp[-1], yyvsp[0]); ;
02000     break;}
02001 case 68:
02002 #line 336 "PSDL.yy"
02003 { yyval = new TAO_PSDL_Catalog_Member (yyvsp[-1]); ;
02004     break;}
02005 case 69:
02006 #line 339 "PSDL.yy"
02007 { yyval = new TAO_PSDL_Catalog_Member (yyvsp[-1]); ;
02008     break;}
02009 case 70:
02010 #line 343 "PSDL.yy"
02011 { yyval = new TAO_PSDL_Provides_Dcl (yyvsp[-1], yyvsp[0]); ;
02012     break;}
02013 case 71:
02014 #line 347 "PSDL.yy"
02015 { yyval = new TAO_PSDL_Storagetype (yyvsp[0]); ;
02016     break;}
02017 case 72:
02018 #line 350 "PSDL.yy"
02019 { yyval = new TAO_PSDL_Storagetype (yyvsp[0]); ;
02020     break;}
02021 case 73:
02022 #line 354 "PSDL.yy"
02023 { yyval = new TAO_PSDL_Storagetype_Dcl (yyvsp[-3], yyvsp[-1]); ;
02024     break;}
02025 case 74:
02026 #line 357 "PSDL.yy"
02027 { yyval = new TAO_PSDL_Storagetype_Dcl (yyvsp[-2]); ;
02028     break;}
02029 case 75:
02030 #line 361 "PSDL.yy"
02031 { yyval = new TAO_PSDL_Storagetype_Fwd_Dcl (yyvsp[0]); ;
02032     break;}
02033 case 76:
02034 #line 365 "PSDL.yy"
02035 { yyval = new TAO_PSDL_Storagetype_Header (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02036     break;}
02037 case 77:
02038 #line 368 "PSDL.yy"
02039 { yyval = new TAO_PSDL_Storagetype_Header (yyvsp[-1], yyvsp[0]); ;
02040     break;}
02041 case 78:
02042 #line 371 "PSDL.yy"
02043 { yyval = new TAO_PSDL_Storagetype_Header (yyvsp[-1], yyvsp[0]); ;
02044     break;}
02045 case 79:
02046 #line 375 "PSDL.yy"
02047 { yyval = new TAO_PSDL_Storagetype_Body (yyvsp[0]); ;
02048     break;}
02049 case 80:
02050 #line 378 "PSDL.yy"
02051 { yyval = new TAO_PSDL_Storagetype_Body (yyvsp[-1], yyvsp[0]); ;
02052     break;}
02053 case 81:
02054 #line 382 "PSDL.yy"
02055 { yyval = new TAO_PSDL_Storagetype_Member (yyvsp[-1]); ;
02056     break;}
02057 case 82:
02058 #line 385 "PSDL.yy"
02059 { yyval = new TAO_PSDL_Storagetype_Member (yyvsp[-1]); ;
02060     break;}
02061 case 83:
02062 #line 388 "PSDL.yy"
02063 { yyval = new TAO_PSDL_Storagetype_Member (yyvsp[-1]); ;
02064     break;}
02065 case 84:
02066 #line 392 "PSDL.yy"
02067 { yyval = new TAO_PSDL_Storagetype_Inh_Spec (yyvsp[0]); ;
02068     break;}
02069 case 85:
02070 #line 396 "PSDL.yy"
02071 { yyval = new TAO_PSDL_Storagetype_Name (yyvsp[0]); ;
02072     break;}
02073 case 86:
02074 #line 400 "PSDL.yy"
02075 { yyval = new TAO_PSDL_Storagetype_Impl_Spec (yyvsp[0]); ;
02076     break;}
02077 case 87:
02078 #line 404 "PSDL.yy"
02079 { yyval = new TAO_PSDL_Storagetype_Ref_Type (yyvsp[-1]); ;
02080     break;}
02081 case 88:
02082 #line 408 "PSDL.yy"
02083 { yyval = new TAO_PSDL_Storagehome_Scope (yyvsp[0]); ;
02084     break;}
02085 case 89:
02086 #line 412 "PSDL.yy"
02087 { yyval = new TAO_PSDL_Store_Directive (yyvsp[-3], yyvsp[-1], yyvsp[0]); ;
02088     break;}
02089 case 90:
02090 #line 415 "PSDL.yy"
02091 { yyval = new TAO_PSDL_Store_Directive (yyvsp[-2], yyvsp[0]); ;
02092     break;}
02093 case 91:
02094 #line 420 "PSDL.yy"
02095 { yyval = new TAO_PSDL_Psdl_Concrete_State_Type (yyvsp[0]); ;
02096     break;}
02097 case 92:
02098 #line 423 "PSDL.yy"
02099 { yyval = new TAO_PSDL_Psdl_Concrete_State_Type (yyvsp[0]); ;
02100     break;}
02101 case 93:
02102 #line 427 "PSDL.yy"
02103 { yyval = new TAO_PSDL_Ref_Rep_Directive (yyvsp[-1]); ;
02104     break;}
02105 case 94:
02106 #line 431 "PSDL.yy"
02107 { yyval = new TAO_PSDL_Storagehome (yyvsp[-3], yyvsp[-1]); ;
02108     break;}
02109 case 95:
02110 #line 434 "PSDL.yy"
02111 { yyval = new TAO_PSDL_Storagehome (yyvsp[-2]); ;
02112     break;}
02113 case 96:
02114 #line 438 "PSDL.yy"
02115 { yyval = new TAO_PSDL_Storagehome_Header (yyvsp[-4], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02116     break;}
02117 case 97:
02118 #line 441 "PSDL.yy"
02119 { yyval = new TAO_PSDL_Storagehome_Header (yyvsp[-3], yyvsp[-1], yyvsp[0]); ;
02120     break;}
02121 case 98:
02122 #line 444 "PSDL.yy"
02123 { yyval = new TAO_PSDL_Storagehome_Header (yyvsp[-3], yyvsp[-1], yyvsp[0]); ;
02124     break;}
02125 case 99:
02126 #line 447 "PSDL.yy"
02127 { yyval = new TAO_PSDL_Storagehome_Header (yyvsp[-2], yyvsp[0]); ;
02128     break;}
02129 case 100:
02130 #line 451 "PSDL.yy"
02131 { yyval = new TAO_PSDL_Storagehome_Body (yyvsp[0]); ;
02132     break;}
02133 case 101:
02134 #line 454 "PSDL.yy"
02135 { yyval = new TAO_PSDL_Storagehome_Body (yyvsp[-1], yyvsp[0]); ;
02136     break;}
02137 case 102:
02138 #line 458 "PSDL.yy"
02139 { yyval = new TAO_PSDL_Storagehome_Member (yyvsp[-1]); ;
02140     break;}
02141 case 103:
02142 #line 461 "PSDL.yy"
02143 { yyval = new TAO_PSDL_Storagehome_Member (yyvsp[-1]); ;
02144     break;}
02145 case 104:
02146 #line 465 "PSDL.yy"
02147 { yyval = new TAO_PSDL_Storagehome_Inh_Spec (yyvsp[0]); ;
02148     break;}
02149 case 105:
02150 #line 469 "PSDL.yy"
02151 { yyval = new TAO_PSDL_Storagehome_Name (yyvsp[0]); ;
02152     break;}
02153 case 106:
02154 #line 473 "PSDL.yy"
02155 { yyval = new TAO_PSDL_Storagehome_Impl_Spec (yyvsp[0]); ;
02156     break;}
02157 case 107:
02158 #line 477 "PSDL.yy"
02159 { yyval = new TAO_PSDL_Primary_Key_Dcl (yyvsp[0]); ;
02160     break;}
02161 case 108:
02162 #line 480 "PSDL.yy"
02163 { yyval = new TAO_PSDL_Primary_Key_Dcl (); ;
02164     break;}
02165 case 109:
02166 #line 484 "PSDL.yy"
02167 { yyval = yyvsp[0]; ;
02168     break;}
02169 case 110:
02170 #line 488 "PSDL.yy"
02171 { yyval = new TAO_PSDL_Type_Dcl (TAO_PSDL_TYPEDEF, yyvsp[0]); ;
02172     break;}
02173 case 111:
02174 #line 491 "PSDL.yy"
02175 { yyval = new TAO_PSDL_Type_Dcl (yyvsp[0]); ;
02176     break;}
02177 case 112:
02178 #line 494 "PSDL.yy"
02179 { yyval = new TAO_PSDL_Type_Dcl (yyvsp[0]); ;
02180     break;}
02181 case 113:
02182 #line 497 "PSDL.yy"
02183 { yyval = new TAO_PSDL_Type_Dcl (yyvsp[0]); ;
02184     break;}
02185 case 114:
02186 #line 500 "PSDL.yy"
02187 { yyval = new TAO_PSDL_Type_Dcl (TAO_PSDL_NATIVE, yyvsp[0]); ;
02188     break;}
02189 case 115:
02190 #line 503 "PSDL.yy"
02191 { yyval = new TAO_PSDL_Type_Dcl (yyvsp[0]); ;
02192     break;}
02193 case 116:
02194 #line 507 "PSDL.yy"
02195 { yyval = new TAO_PSDL_Type_Declarator (yyvsp[-1], yyvsp[0]); ;
02196     break;}
02197 case 117:
02198 #line 511 "PSDL.yy"
02199 { yyval = new TAO_PSDL_Type_Spec (yyvsp[0]); ;
02200     break;}
02201 case 118:
02202 #line 514 "PSDL.yy"
02203 { yyval = new TAO_PSDL_Type_Spec (yyvsp[0]); ;
02204     break;}
02205 case 119:
02206 #line 518 "PSDL.yy"
02207 { yyval = new TAO_PSDL_Simple_Type_Spec (yyvsp[0]); ;
02208     break;}
02209 case 120:
02210 #line 521 "PSDL.yy"
02211 { yyval = new TAO_PSDL_Simple_Type_Spec (yyvsp[0]); ;
02212     break;}
02213 case 121:
02214 #line 524 "PSDL.yy"
02215 { yyval = new TAO_PSDL_Simple_Type_Spec (yyvsp[0]); ;
02216     break;}
02217 case 122:
02218 #line 528 "PSDL.yy"
02219 { yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
02220     break;}
02221 case 123:
02222 #line 531 "PSDL.yy"
02223 { yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
02224     break;}
02225 case 124:
02226 #line 534 "PSDL.yy"
02227 { yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
02228     break;}
02229 case 125:
02230 #line 537 "PSDL.yy"
02231 { yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
02232     break;}
02233 case 126:
02234 #line 540 "PSDL.yy"
02235 { yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
02236     break;}
02237 case 127:
02238 #line 543 "PSDL.yy"
02239 { yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
02240     break;}
02241 case 128:
02242 #line 546 "PSDL.yy"
02243 { yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
02244     break;}
02245 case 129:
02246 #line 549 "PSDL.yy"
02247 { yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
02248     break;}
02249 case 130:
02250 #line 552 "PSDL.yy"
02251 { yyval = new TAO_PSDL_Base_Type_Spec (yyvsp[0]); ;
02252     break;}
02253 case 131:
02254 #line 556 "PSDL.yy"
02255 { yyval = new TAO_PSDL_Template_Type_Spec (yyvsp[0]); ;
02256     break;}
02257 case 132:
02258 #line 559 "PSDL.yy"
02259 { yyval = new TAO_PSDL_Template_Type_Spec (yyvsp[0]); ;
02260     break;}
02261 case 133:
02262 #line 562 "PSDL.yy"
02263 { yyval = new TAO_PSDL_Template_Type_Spec (yyvsp[0]); ;
02264     break;}
02265 case 134:
02266 #line 565 "PSDL.yy"
02267 { yyval = new TAO_PSDL_Template_Type_Spec (yyvsp[0]); ;
02268     break;}
02269 case 135:
02270 #line 569 "PSDL.yy"
02271 { yyval = new TAO_PSDL_Constr_Type_Spec (yyvsp[0]); ;
02272     break;}
02273 case 136:
02274 #line 572 "PSDL.yy"
02275 { yyval = new TAO_PSDL_Constr_Type_Spec (yyvsp[0]); ;
02276     break;}
02277 case 137:
02278 #line 575 "PSDL.yy"
02279 { yyval = new TAO_PSDL_Constr_Type_Spec (yyvsp[0]); ;
02280     break;}
02281 case 138:
02282 #line 579 "PSDL.yy"
02283 { yyval = new TAO_PSDL_Declarators (yyvsp[0]); ;
02284     break;}
02285 case 139:
02286 #line 582 "PSDL.yy"
02287 { yyval = new TAO_PSDL_Declarators (yyvsp[-2], yyvsp[0]); ;
02288     break;}
02289 case 140:
02290 #line 586 "PSDL.yy"
02291 { yyval = new TAO_PSDL_Declarator (yyvsp[0]); ;
02292     break;}
02293 case 141:
02294 #line 589 "PSDL.yy"
02295 { yyval = new TAO_PSDL_Declarator (yyvsp[0]); ;
02296     break;}
02297 case 142:
02298 #line 593 "PSDL.yy"
02299 { yyval = yyvsp[0]; ;
02300     break;}
02301 case 143:
02302 #line 597 "PSDL.yy"
02303 { yyval = new TAO_PSDL_Simple_Declarator_List (yyvsp[0]); ;
02304     break;}
02305 case 144:
02306 #line 600 "PSDL.yy"
02307 { yyval = new TAO_PSDL_Simple_Declarator_List (yyvsp[-2], yyvsp[0]); ;
02308     break;}
02309 case 145:
02310 #line 604 "PSDL.yy"
02311 { yyval = new TAO_PSDL_Complex_Declarator (yyvsp[0]); ;
02312     break;}
02313 case 146:
02314 #line 608 "PSDL.yy"
02315 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_FLOAT); ;
02316     break;}
02317 case 147:
02318 #line 611 "PSDL.yy"
02319 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_DOUBLE); ;
02320     break;}
02321 case 148:
02322 #line 614 "PSDL.yy"
02323 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_LONG, TAO_PSDL_DOUBLE); ;
02324     break;}
02325 case 149:
02326 #line 618 "PSDL.yy"
02327 { yyval = yyvsp[0]; ;
02328     break;}
02329 case 150:
02330 #line 621 "PSDL.yy"
02331 { yyval = yyvsp[0]; ;
02332     break;}
02333 case 151:
02334 #line 625 "PSDL.yy"
02335 { yyval = yyvsp[0]; ;
02336     break;}
02337 case 152:
02338 #line 628 "PSDL.yy"
02339 { yyval = yyvsp[0]; ;
02340     break;}
02341 case 153:
02342 #line 631 "PSDL.yy"
02343 { yyval = yyvsp[0]; ;
02344     break;}
02345 case 154:
02346 #line 635 "PSDL.yy"
02347 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_SHORT); ;
02348     break;}
02349 case 155:
02350 #line 639 "PSDL.yy"
02351 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_LONG); ;
02352     break;}
02353 case 156:
02354 #line 643 "PSDL.yy"
02355 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_LONG, TAO_PSDL_LONG); ;
02356     break;}
02357 case 157:
02358 #line 647 "PSDL.yy"
02359 { yyval = new TAO_PSDL_Predefined_Type (yyvsp[0]); ;
02360     break;}
02361 case 158:
02362 #line 650 "PSDL.yy"
02363 { yyval = new TAO_PSDL_Predefined_Type (yyvsp[0]); ;
02364     break;}
02365 case 159:
02366 #line 653 "PSDL.yy"
02367 { yyval = new TAO_PSDL_Predefined_Type (yyvsp[0]); ;
02368     break;}
02369 case 160:
02370 #line 657 "PSDL.yy"
02371 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_UNSIGNED, TAO_PSDL_SHORT); ;
02372     break;}
02373 case 161:
02374 #line 661 "PSDL.yy"
02375 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_UNSIGNED, TAO_PSDL_LONG); ;
02376     break;}
02377 case 162:
02378 #line 665 "PSDL.yy"
02379 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_UNSIGNED, TAO_PSDL_LONG, TAO_PSDL_LONG); ;
02380     break;}
02381 case 163:
02382 #line 669 "PSDL.yy"
02383 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_CHAR); ;
02384     break;}
02385 case 164:
02386 #line 673 "PSDL.yy"
02387 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_WCHAR); ;
02388     break;}
02389 case 165:
02390 #line 677 "PSDL.yy"
02391 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_BOOLEAN); ;
02392     break;}
02393 case 166:
02394 #line 681 "PSDL.yy"
02395 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_OCTET); ;
02396     break;}
02397 case 167:
02398 #line 685 "PSDL.yy"
02399 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_ANY); ;
02400     break;}
02401 case 168:
02402 #line 689 "PSDL.yy"
02403 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_OBJECT); ;
02404     break;}
02405 case 169:
02406 #line 693 "PSDL.yy"
02407 {
02408                   int good_struct_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_struct (TAO_PSDL_Scope::instance ()->get_identifier ());
02409 
02410                   if (good_struct_name == -1)
02411                         YYABORT;
02412                 ;
02413     break;}
02414 case 170:
02415 #line 700 "PSDL.yy"
02416 {
02417                   TAO_PSDL_Scope::instance ()->set_scope ();
02418                   yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_STRUCT, yyvsp[-4], yyvsp[-1]); ;
02419     break;}
02420 case 171:
02421 #line 706 "PSDL.yy"
02422 { yyval = new TAO_PSDL_Member_List (yyvsp[0]); ;
02423     break;}
02424 case 172:
02425 #line 709 "PSDL.yy"
02426 { yyval = new TAO_PSDL_Member_List (yyvsp[-1], yyvsp[0]); ;
02427     break;}
02428 case 173:
02429 #line 713 "PSDL.yy"
02430 { yyval = new TAO_PSDL_Member (yyvsp[-2], yyvsp[-1]); ;
02431     break;}
02432 case 174:
02433 #line 717 "PSDL.yy"
02434 { yyval = new TAO_PSDL_Predefined_Type (yyvsp[-7], yyvsp[-4], yyvsp[-1]); ;
02435     break;}
02436 case 175:
02437 #line 721 "PSDL.yy"
02438 { yyval = new TAO_PSDL_Switch_Type_Spec (yyvsp[0]); ;
02439     break;}
02440 case 176:
02441 #line 724 "PSDL.yy"
02442 { yyval = new TAO_PSDL_Switch_Type_Spec (yyvsp[0]); ;
02443     break;}
02444 case 177:
02445 #line 727 "PSDL.yy"
02446 { yyval = new TAO_PSDL_Switch_Type_Spec (yyvsp[0]); ;
02447     break;}
02448 case 178:
02449 #line 730 "PSDL.yy"
02450 { yyval = new TAO_PSDL_Switch_Type_Spec (yyvsp[0]); ;
02451     break;}
02452 case 179:
02453 #line 733 "PSDL.yy"
02454 { yyval = new TAO_PSDL_Switch_Type_Spec (yyvsp[0]); ;
02455     break;}
02456 case 180:
02457 #line 737 "PSDL.yy"
02458 { yyval = new TAO_PSDL_Switch_Body (yyvsp[0]); ;
02459     break;}
02460 case 181:
02461 #line 740 "PSDL.yy"
02462 { yyval = new TAO_PSDL_Switch_Body (yyvsp[-1], yyvsp[0]); ;
02463     break;}
02464 case 182:
02465 #line 744 "PSDL.yy"
02466 { yyval = new TAO_PSDL_Case (yyvsp[-2], yyvsp[-1]); ;
02467     break;}
02468 case 183:
02469 #line 748 "PSDL.yy"
02470 { yyval = new TAO_PSDL_Case_Label (yyvsp[-2], yyvsp[-1]); ;
02471     break;}
02472 case 184:
02473 #line 751 "PSDL.yy"
02474 { yyval = new TAO_PSDL_Case_Label (yyvsp[-1]); ;
02475     break;}
02476 case 185:
02477 #line 754 "PSDL.yy"
02478 { yyval = new TAO_PSDL_Case_Label (yyvsp[-3], yyvsp[-2], yyvsp[0]); ;
02479     break;}
02480 case 186:
02481 #line 757 "PSDL.yy"
02482 { yyval = new TAO_PSDL_Case_Label (yyvsp[-2], yyvsp[0]); ;
02483     break;}
02484 case 187:
02485 #line 761 "PSDL.yy"
02486 { yyval = new TAO_PSDL_Element_Spec (yyvsp[-1], yyvsp[0]); ;
02487     break;}
02488 case 188:
02489 #line 765 "PSDL.yy"
02490 { yyval = new TAO_PSDL_Const_Dcl (yyvsp[-3], yyvsp[-2], yyvsp[0]); ;
02491     break;}
02492 case 189:
02493 #line 769 "PSDL.yy"
02494 { yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
02495     break;}
02496 case 190:
02497 #line 772 "PSDL.yy"
02498 { yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
02499     break;}
02500 case 191:
02501 #line 775 "PSDL.yy"
02502 { yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
02503     break;}
02504 case 192:
02505 #line 778 "PSDL.yy"
02506 { yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
02507     break;}
02508 case 193:
02509 #line 781 "PSDL.yy"
02510 { yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
02511     break;}
02512 case 194:
02513 #line 784 "PSDL.yy"
02514 { yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
02515     break;}
02516 case 195:
02517 #line 787 "PSDL.yy"
02518 { yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
02519     break;}
02520 case 196:
02521 #line 790 "PSDL.yy"
02522 { yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
02523     break;}
02524 case 197:
02525 #line 793 "PSDL.yy"
02526 { yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
02527     break;}
02528 case 198:
02529 #line 796 "PSDL.yy"
02530 { yyval = new TAO_PSDL_Predefined_Type(yyvsp[0]); ;
02531     break;}
02532 case 199:
02533 #line 800 "PSDL.yy"
02534 { yyval = new TAO_PSDL_Const_Exp (yyvsp[0]); ;
02535     break;}
02536 case 200:
02537 #line 804 "PSDL.yy"
02538 { yyval = new TAO_PSDL_Or_Expr (yyvsp[0]); ;
02539     break;}
02540 case 201:
02541 #line 807 "PSDL.yy"
02542 { yyval = new TAO_PSDL_Or_Expr (yyvsp[-2], yyvsp[0]); ;
02543     break;}
02544 case 202:
02545 #line 811 "PSDL.yy"
02546 { yyval = new TAO_PSDL_Xor_Expr (yyvsp[0]); ;
02547     break;}
02548 case 203:
02549 #line 814 "PSDL.yy"
02550 { yyval = new TAO_PSDL_Xor_Expr (yyvsp[-2], yyvsp[0]); ;
02551     break;}
02552 case 204:
02553 #line 818 "PSDL.yy"
02554 { yyval = new TAO_PSDL_And_Expr (yyvsp[0]); ;
02555     break;}
02556 case 205:
02557 #line 821 "PSDL.yy"
02558 { yyval = new TAO_PSDL_And_Expr (yyvsp[-2], yyvsp[0]); ;
02559     break;}
02560 case 206:
02561 #line 825 "PSDL.yy"
02562 { yyval = new TAO_PSDL_Shift_Expr (yyvsp[0]); ;
02563     break;}
02564 case 207:
02565 #line 828 "PSDL.yy"
02566 { yyval = new TAO_PSDL_Shift_Expr (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02567     break;}
02568 case 208:
02569 #line 831 "PSDL.yy"
02570 { yyval = new TAO_PSDL_Shift_Expr (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02571     break;}
02572 case 209:
02573 #line 835 "PSDL.yy"
02574 { yyval = new TAO_PSDL_Add_Expr (yyvsp[0]); ;
02575     break;}
02576 case 210:
02577 #line 838 "PSDL.yy"
02578 { yyval = new TAO_PSDL_Add_Expr (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02579     break;}
02580 case 211:
02581 #line 841 "PSDL.yy"
02582 { yyval = new TAO_PSDL_Add_Expr (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02583     break;}
02584 case 212:
02585 #line 845 "PSDL.yy"
02586 { yyval = new TAO_PSDL_Mult_Expr (yyvsp[0]); ;
02587     break;}
02588 case 213:
02589 #line 848 "PSDL.yy"
02590 { yyval = new TAO_PSDL_Mult_Expr (yyvsp[-2], yyvsp[0]); ;
02591     break;}
02592 case 214:
02593 #line 851 "PSDL.yy"
02594 { yyval = new TAO_PSDL_Mult_Expr (yyvsp[-2], yyvsp[0]); ;
02595     break;}
02596 case 215:
02597 #line 854 "PSDL.yy"
02598 { yyval = new TAO_PSDL_Mult_Expr (yyvsp[-2], yyvsp[0]); ;
02599     break;}
02600 case 216:
02601 #line 858 "PSDL.yy"
02602 { yyval = new TAO_PSDL_Unary_Expr (yyvsp[-1], yyvsp[0]); ;
02603     break;}
02604 case 217:
02605 #line 861 "PSDL.yy"
02606 { yyval = new TAO_PSDL_Unary_Expr (yyvsp[0]); ;
02607     break;}
02608 case 218:
02609 #line 865 "PSDL.yy"
02610 { yyval = yyvsp[0]; ;
02611     break;}
02612 case 219:
02613 #line 868 "PSDL.yy"
02614 { yyval = yyvsp[0]; ;
02615     break;}
02616 case 220:
02617 #line 871 "PSDL.yy"
02618 { yyval = yyvsp[0]; ;
02619     break;}
02620 case 221:
02621 #line 875 "PSDL.yy"
02622 { yyval = new TAO_PSDL_Primary_Expr (yyvsp[0]); ;
02623     break;}
02624 case 222:
02625 #line 878 "PSDL.yy"
02626 { yyval = new TAO_PSDL_Primary_Expr (yyvsp[0]); ;
02627     break;}
02628 case 223:
02629 #line 881 "PSDL.yy"
02630 { yyval = new TAO_PSDL_Primary_Expr (yyvsp[-1]); ;
02631     break;}
02632 case 224:
02633 #line 885 "PSDL.yy"
02634 {
02635                   int good_except_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_exception (TAO_PSDL_Scope::instance ()->get_identifier ());
02636                   if (good_except_name == -1)
02637                     YYABORT;
02638                   yyval = yyvsp[0];
02639                 ;
02640     break;}
02641 case 225:
02642 #line 894 "PSDL.yy"
02643 {
02644                   TAO_PSDL_Scope::instance ()->set_scope ();
02645                   yyval = new TAO_PSDL_Except_Dcl (yyvsp[-3], yyvsp[-1]);
02646                 ;
02647     break;}
02648 case 226:
02649 #line 900 "PSDL.yy"
02650 {
02651                   TAO_PSDL_Scope::instance ()->set_scope ();
02652                   yyval = new TAO_PSDL_Except_Dcl (yyvsp[-2]);
02653                 ;
02654     break;}
02655 case 227:
02656 #line 907 "PSDL.yy"
02657 {
02658                   int good_op_dcl_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_op_dcl (TAO_PSDL_Scope::instance ()->get_identifier ());
02659 
02660                   if (good_op_dcl_name == -1)
02661                     YYABORT;
02662 
02663                   yyval = yyvsp[0];
02664                 ;
02665     break;}
02666 case 228:
02667 #line 918 "PSDL.yy"
02668 { TAO_PSDL_Scope::instance ()->set_scope ();
02669                   yyval = new TAO_PSDL_Op_Dcl (yyvsp[-5], yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02670     break;}
02671 case 229:
02672 #line 922 "PSDL.yy"
02673 { TAO_PSDL_Scope::instance ()->set_scope ();
02674                   yyval = new TAO_PSDL_Op_Dcl (yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02675     break;}
02676 case 230:
02677 #line 926 "PSDL.yy"
02678 { TAO_PSDL_Scope::instance ()->set_scope ();
02679                   yyval = new TAO_PSDL_Op_Dcl (yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02680     break;}
02681 case 231:
02682 #line 930 "PSDL.yy"
02683 { TAO_PSDL_Scope::instance ()->set_scope ();
02684                   yyval = new TAO_PSDL_Op_Dcl (yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02685     break;}
02686 case 232:
02687 #line 934 "PSDL.yy"
02688 { TAO_PSDL_Scope::instance ()->set_scope ();
02689                   yyval = new TAO_PSDL_Op_Dcl (yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02690     break;}
02691 case 233:
02692 #line 938 "PSDL.yy"
02693 { TAO_PSDL_Scope::instance ()->set_scope ();
02694                   yyval = new TAO_PSDL_Op_Dcl (yyvsp[-3], yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02695     break;}
02696 case 234:
02697 #line 942 "PSDL.yy"
02698 { TAO_PSDL_Scope::instance ()->set_scope ();
02699                   yyval = new TAO_PSDL_Op_Dcl (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02700     break;}
02701 case 235:
02702 #line 947 "PSDL.yy"
02703 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_ONEWAY); ;
02704     break;}
02705 case 236:
02706 #line 951 "PSDL.yy"
02707 { yyval = new TAO_PSDL_Op_Type_Spec (yyvsp[0]); ;
02708     break;}
02709 case 237:
02710 #line 954 "PSDL.yy"
02711 { yyval = new TAO_PSDL_Op_Type_Spec (TAO_PSDL_VOID); ;
02712     break;}
02713 case 238:
02714 #line 958 "PSDL.yy"
02715 { yyval = new TAO_PSDL_Parameter_Dcls (yyvsp[-1]); ;
02716     break;}
02717 case 239:
02718 #line 961 "PSDL.yy"
02719 { yyval = new TAO_PSDL_Parameter_Dcls (); ;
02720     break;}
02721 case 240:
02722 #line 965 "PSDL.yy"
02723 { yyval = new TAO_PSDL_Param_Dcl (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02724     break;}
02725 case 241:
02726 #line 968 "PSDL.yy"
02727 { yyval = new TAO_PSDL_Param_Dcl (yyvsp[-4], yyvsp[-3], yyvsp[-2], yyvsp[0]); ;
02728     break;}
02729 case 242:
02730 #line 972 "PSDL.yy"
02731 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_IN); ;
02732     break;}
02733 case 243:
02734 #line 975 "PSDL.yy"
02735 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_OUT); ;
02736     break;}
02737 case 244:
02738 #line 978 "PSDL.yy"
02739 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_INOUT); ;
02740     break;}
02741 case 245:
02742 #line 982 "PSDL.yy"
02743 { yyval = new TAO_PSDL_Raises_Expr (yyvsp[-1]); ;
02744     break;}
02745 case 246:
02746 #line 985 "PSDL.yy"
02747 { yyval = new TAO_PSDL_Raises_Expr (yyvsp[-3], yyvsp[-2]); ;
02748     break;}
02749 case 247:
02750 #line 989 "PSDL.yy"
02751 { yyval = new TAO_PSDL_Context_Expr (yyvsp[-1]); ;
02752     break;}
02753 case 248:
02754 #line 993 "PSDL.yy"
02755 { yyval = new TAO_PSDL_Param_Type_Spec (yyvsp[0]); ;
02756     break;}
02757 case 249:
02758 #line 996 "PSDL.yy"
02759 { yyval = new TAO_PSDL_Param_Type_Spec (yyvsp[0]); ;
02760     break;}
02761 case 250:
02762 #line 999 "PSDL.yy"
02763 { yyval = new TAO_PSDL_Param_Type_Spec (yyvsp[0]); ;
02764     break;}
02765 case 251:
02766 #line 1002 "PSDL.yy"
02767 { yyval = new TAO_PSDL_Param_Type_Spec (yyvsp[0]); ;
02768     break;}
02769 case 252:
02770 #line 1006 "PSDL.yy"
02771 { yyval = new TAO_PSDL_Predefined_Type (yyvsp[-3], yyvsp[-1]); ;
02772     break;}
02773 case 253:
02774 #line 1010 "PSDL.yy"
02775 { yyval = yyvsp[0]; ;
02776     break;}
02777 case 254:
02778 #line 1014 "PSDL.yy"
02779 { yyval = yyvsp[0]; ;
02780     break;}
02781 case 255:
02782 #line 1018 "PSDL.yy"
02783 { yyval = new TAO_PSDL_Constr_Forward_Decl (yyvsp[-1], yyvsp[0]); ;
02784     break;}
02785 case 256:
02786 #line 1021 "PSDL.yy"
02787 { yyval = new TAO_PSDL_Constr_Forward_Decl (yyvsp[-1], yyvsp[0]); ;
02788     break;}
02789 case 257:
02790 #line 1025 "PSDL.yy"
02791 { yyval = new TAO_PSDL_Interface (yyvsp[0]); ;
02792     break;}
02793 case 258:
02794 #line 1028 "PSDL.yy"
02795 { yyval = new TAO_PSDL_Interface (yyvsp[0]); ;
02796     break;}
02797 case 259:
02798 #line 1032 "PSDL.yy"
02799 {
02800                   TAO_PSDL_Scope::instance ()->set_interface_scope ();
02801                   yyval = new TAO_PSDL_Interface_Dcl (yyvsp[-3], yyvsp[-1]);
02802                 ;
02803     break;}
02804 case 260:
02805 #line 1038 "PSDL.yy"
02806 {
02807                   TAO_PSDL_Scope::instance ()->set_interface_scope ();
02808                   yyval = new TAO_PSDL_Interface_Dcl (yyvsp[-2]);
02809                 ;
02810     break;}
02811 case 261:
02812 #line 1045 "PSDL.yy"
02813 { yyval = new TAO_PSDL_Forward_Dcl (TAO_PSDL_ABSTRACT, yyvsp[0]); ;
02814     break;}
02815 case 262:
02816 #line 1048 "PSDL.yy"
02817 { yyval = new TAO_PSDL_Forward_Dcl (TAO_PSDL_LOCAL, yyvsp[0]); ;
02818     break;}
02819 case 263:
02820 #line 1051 "PSDL.yy"
02821 { yyval = new TAO_PSDL_Forward_Dcl (yyvsp[0]); ;
02822     break;}
02823 case 264:
02824 #line 1055 "PSDL.yy"
02825 {
02826                   int good_interface_name = TAO_PSDL_Scope::instance ()->pop_top_scope ()->add_interface (TAO_PSDL_Scope::instance ()->get_identifier ());
02827                   if (good_interface_name == -1)
02828                       YYABORT;
02829 
02830                   yyval = yyvsp[0];
02831                 ;
02832     break;}
02833 case 265:
02834 #line 1065 "PSDL.yy"
02835 { yyval = new TAO_PSDL_Interface_Header (yyvsp[-1], yyvsp[0]); ;
02836     break;}
02837 case 266:
02838 #line 1068 "PSDL.yy"
02839 { yyval = new TAO_PSDL_Interface_Header (yyvsp[-1], yyvsp[0]); ;
02840     break;}
02841 case 267:
02842 #line 1071 "PSDL.yy"
02843 { yyval = new TAO_PSDL_Interface_Header (yyvsp[0]); ;
02844     break;}
02845 case 268:
02846 #line 1074 "PSDL.yy"
02847 { yyval = new TAO_PSDL_Interface_Header (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02848     break;}
02849 case 269:
02850 #line 1077 "PSDL.yy"
02851 { yyval = new TAO_PSDL_Interface_Header (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02852     break;}
02853 case 270:
02854 #line 1080 "PSDL.yy"
02855 { yyval = new TAO_PSDL_Interface_Header (yyvsp[0], yyvsp[-1]); ;
02856     break;}
02857 case 271:
02858 #line 1084 "PSDL.yy"
02859 { yyval = new TAO_PSDL_Interface_Body (yyvsp[0]); ;
02860     break;}
02861 case 272:
02862 #line 1087 "PSDL.yy"
02863 { yyval = new TAO_PSDL_Interface_Body (yyvsp[-1], yyvsp[0]); ;
02864     break;}
02865 case 273:
02866 #line 1091 "PSDL.yy"
02867 { yyval = new TAO_PSDL_Export_Dcl (yyvsp[-1]); ;
02868     break;}
02869 case 274:
02870 #line 1094 "PSDL.yy"
02871 { yyval = new TAO_PSDL_Export_Dcl (yyvsp[-1]); ;
02872     break;}
02873 case 275:
02874 #line 1097 "PSDL.yy"
02875 { yyval = new TAO_PSDL_Export_Dcl (yyvsp[-1]); ;
02876     break;}
02877 case 276:
02878 #line 1100 "PSDL.yy"
02879 { yyval = new TAO_PSDL_Export_Dcl (yyvsp[-1]); ;
02880     break;}
02881 case 277:
02882 #line 1103 "PSDL.yy"
02883 { yyval = new TAO_PSDL_Export_Dcl (yyvsp[-1]); ;
02884     break;}
02885 case 278:
02886 #line 1108 "PSDL.yy"
02887 { yyval = new TAO_PSDL_Interface_Inheritance_Spec (yyvsp[0]); ;
02888     break;}
02889 case 279:
02890 #line 1112 "PSDL.yy"
02891 { yyval = new TAO_PSDL_Interface_Name (yyvsp[0]); ;
02892     break;}
02893 case 280:
02894 #line 1115 "PSDL.yy"
02895 { yyval = new TAO_PSDL_Interface_Name (yyvsp[-2], yyvsp[-1]); ;
02896     break;}
02897 case 281:
02898 #line 1119 "PSDL.yy"
02899 { yyval = new TAO_PSDL_Scoped_Name (yyvsp[-2], yyvsp[0]); ;
02900     break;}
02901 case 282:
02902 #line 1122 "PSDL.yy"
02903 { yyval = yyvsp[0]; ;
02904     break;}
02905 case 283:
02906 #line 1126 "PSDL.yy"
02907 { yyval = new TAO_PSDL_Scoped_Name (yyvsp[-2], yyvsp[0]); ;
02908     break;}
02909 case 284:
02910 #line 1129 "PSDL.yy"
02911 { yyval = yyvsp[0]; ;
02912     break;}
02913 case 285:
02914 #line 1133 "PSDL.yy"
02915 { yyval = new TAO_PSDL_Value (yyvsp[0]); ;
02916     break;}
02917 case 286:
02918 #line 1136 "PSDL.yy"
02919 { yyval = new TAO_PSDL_Value (yyvsp[0]); ;
02920     break;}
02921 case 287:
02922 #line 1139 "PSDL.yy"
02923 { yyval = new TAO_PSDL_Value (yyvsp[0]); ;
02924     break;}
02925 case 288:
02926 #line 1142 "PSDL.yy"
02927 { yyval = new TAO_PSDL_Value (yyvsp[0]); ;
02928     break;}
02929 case 289:
02930 #line 1146 "PSDL.yy"
02931 { yyval = new TAO_PSDL_Value_Common_Base (yyvsp[0]); ;
02932     break;}
02933 case 290:
02934 #line 1150 "PSDL.yy"
02935 { yyval = new TAO_PSDL_Value_Forward_Dcl (yyvsp[-1], yyvsp[0]); ;
02936     break;}
02937 case 291:
02938 #line 1153 "PSDL.yy"
02939 { yyval = new TAO_PSDL_Value_Forward_Dcl (yyvsp[0]); ;
02940     break;}
02941 case 292:
02942 #line 1157 "PSDL.yy"
02943 { yyval = new TAO_PSDL_Value_Box_Dcl (yyvsp[-1], yyvsp[0]); ;
02944     break;}
02945 case 293:
02946 #line 1161 "PSDL.yy"
02947 { yyval = new TAO_PSDL_Value_Abs_Dcl (yyvsp[-4], yyvsp[-3], yyvsp[-1]); ;
02948     break;}
02949 case 294:
02950 #line 1164 "PSDL.yy"
02951 { yyval = new TAO_PSDL_Value_Abs_Dcl (yyvsp[-3], yyvsp[-1]); ;
02952     break;}
02953 case 295:
02954 #line 1168 "PSDL.yy"
02955 { yyval = new TAO_PSDL_Value_Dcl (yyvsp[-3], yyvsp[-1]); ;
02956     break;}
02957 case 296:
02958 #line 1172 "PSDL.yy"
02959 { yyval = new TAO_PSDL_Value_Header (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
02960     break;}
02961 case 297:
02962 #line 1175 "PSDL.yy"
02963 { yyval = new TAO_PSDL_Value_Header (yyvsp[-1], yyvsp[0]); ;
02964     break;}
02965 case 298:
02966 #line 1178 "PSDL.yy"
02967 { yyval = new TAO_PSDL_Value_Header (yyvsp[-1], yyvsp[0]); ;
02968     break;}
02969 case 299:
02970 #line 1182 "PSDL.yy"
02971 { yyval = new TAO_PSDL_Value_Inheritance_Spec (yyvsp[-3], yyvsp[-2], yyvsp[0]); ;
02972     break;}
02973 case 300:
02974 #line 1185 "PSDL.yy"
02975 { yyval = new TAO_PSDL_Value_Inheritance_Spec (yyvsp[-2], yyvsp[0]); ;
02976     break;}
02977 case 301:
02978 #line 1188 "PSDL.yy"
02979 { yyval = new TAO_PSDL_Value_Inheritance_Spec (yyvsp[0]); ;
02980     break;}
02981 case 302:
02982 #line 1191 "PSDL.yy"
02983 { yyval = new TAO_PSDL_Value_Inheritance_Spec (yyvsp[-1], yyvsp[0]); ;
02984     break;}
02985 case 303:
02986 #line 1194 "PSDL.yy"
02987 { yyval = new TAO_PSDL_Value_Inheritance_Spec (yyvsp[0]); ;
02988     break;}
02989 case 304:
02990 #line 1199 "PSDL.yy"
02991 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_STRING, yyvsp[-1]); ;
02992     break;}
02993 case 305:
02994 #line 1202 "PSDL.yy"
02995 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_STRING); ;
02996     break;}
02997 case 306:
02998 #line 1206 "PSDL.yy"
02999 { yyval = new TAO_PSDL_Predefined_Type (yyvsp[-1]); ;
03000     break;}
03001 case 307:
03002 #line 1209 "PSDL.yy"
03003 { yyval = yyvsp[0]; ;
03004     break;}
03005 case 308:
03006 #line 1213 "PSDL.yy"
03007 { yyval = new TAO_PSDL_Array_Declarator (yyvsp[-1], yyvsp[0]); ;
03008     break;}
03009 case 309:
03010 #line 1217 "PSDL.yy"
03011 { yyval = new TAO_PSDL_Fixed_Array_Size (yyvsp[-1]); ;
03012     break;}
03013 case 310:
03014 #line 1221 "PSDL.yy"
03015 { yyval = new TAO_PSDL_Attr_Dcl (TAO_PSDL_READONLY, yyvsp[-1], yyvsp[0]); ;
03016     break;}
03017 case 311:
03018 #line 1224 "PSDL.yy"
03019 { yyval = new TAO_PSDL_Attr_Dcl (yyvsp[-1], yyvsp[0]); ;
03020     break;}
03021 case 312:
03022 #line 1228 "PSDL.yy"
03023 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_ENUM, yyvsp[-3], yyvsp[-1]); ;
03024     break;}
03025 case 313:
03026 #line 1232 "PSDL.yy"
03027 { yyval = new TAO_PSDL_Enumerator (yyvsp[0]); ;
03028     break;}
03029 case 314:
03030 #line 1235 "PSDL.yy"
03031 { yyval = new TAO_PSDL_Enumerator (yyvsp[-2], yyvsp[0]); ;
03032     break;}
03033 case 315:
03034 #line 1239 "PSDL.yy"
03035 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_SEQUENCE, yyvsp[-3], yyvsp[-1]); ;
03036     break;}
03037 case 316:
03038 #line 1242 "PSDL.yy"
03039 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_SEQUENCE, yyvsp[-1]); ;
03040     break;}
03041 case 317:
03042 #line 1246 "PSDL.yy"
03043 { yyval = yyvsp[0]; ;
03044     break;}
03045 case 318:
03046 #line 1249 "PSDL.yy"
03047 { yyval = yyvsp[0]; ;
03048     break;}
03049 case 319:
03050 #line 1252 "PSDL.yy"
03051 { yyval = yyvsp[0]; ;
03052     break;}
03053 case 320:
03054 #line 1255 "PSDL.yy"
03055 { yyval = yyvsp[0]; ;
03056     break;}
03057 case 321:
03058 #line 1258 "PSDL.yy"
03059 { yyval = yyvsp[0]; ;
03060     break;}
03061 case 322:
03062 #line 1261 "PSDL.yy"
03063 { yyval = yyvsp[0]; ;
03064     break;}
03065 case 323:
03066 #line 1264 "PSDL.yy"
03067 { yyval = yyvsp[0]; ;
03068     break;}
03069 case 324:
03070 #line 1267 "PSDL.yy"
03071 { yyval = yyvsp[0]; ;
03072     break;}
03073 case 325:
03074 #line 1271 "PSDL.yy"
03075 { yyval = yyvsp[0]; ;
03076     break;}
03077 case 326:
03078 #line 1274 "PSDL.yy"
03079 { yyval = yyvsp[0]; ;
03080     break;}
03081 case 327:
03082 #line 1278 "PSDL.yy"
03083 { yyval = yyvsp[0]; ;
03084     break;}
03085 case 328:
03086 #line 1282 "PSDL.yy"
03087 { yyval = yyvsp[0]; ;
03088     break;}
03089 case 329:
03090 #line 1286 "PSDL.yy"
03091 { yyval = yyvsp[0]; ;
03092     break;}
03093 case 330:
03094 #line 1290 "PSDL.yy"
03095 { yyval = yyvsp[0]; ;
03096     break;}
03097 case 331:
03098 #line 1294 "PSDL.yy"
03099 { yyval = yyvsp[0]; ;
03100     break;}
03101 case 332:
03102 #line 1298 "PSDL.yy"
03103 { yyval = yyvsp[0]; ;
03104     break;}
03105 case 333:
03106 #line 1302 "PSDL.yy"
03107 { yyval = yyvsp[0]; ;
03108     break;}
03109 case 334:
03110 #line 1306 "PSDL.yy"
03111 { yyval = new TAO_PSDL_Value_Name (yyvsp[0]); ;
03112     break;}
03113 case 335:
03114 #line 1309 "PSDL.yy"
03115 { yyval = new TAO_PSDL_Value_Name (yyvsp[-2], yyvsp[0]); ;
03116     break;}
03117 case 336:
03118 #line 1313 "PSDL.yy"
03119 { yyval = new TAO_PSDL_Value_Element (yyvsp[0]); ;
03120     break;}
03121 case 337:
03122 #line 1316 "PSDL.yy"
03123 { yyval = new TAO_PSDL_Value_Element (yyvsp[0]); ;
03124     break;}
03125 case 338:
03126 #line 1319 "PSDL.yy"
03127 { yyval = new TAO_PSDL_Value_Element (yyvsp[0]); ;
03128     break;}
03129 case 339:
03130 #line 1323 "PSDL.yy"
03131 { yyval = new TAO_PSDL_State_Member (yyvsp[-3], yyvsp[-2], yyvsp[-1]); ;
03132     break;}
03133 case 340:
03134 #line 1326 "PSDL.yy"
03135 { yyval = new TAO_PSDL_State_Member (yyvsp[-3], yyvsp[-2], yyvsp[-1]); ;
03136     break;}
03137 case 341:
03138 #line 1330 "PSDL.yy"
03139 { yyval = new TAO_PSDL_Init_Dcl (yyvsp[-4], yyvsp[-2]); ;
03140     break;}
03141 case 342:
03142 #line 1333 "PSDL.yy"
03143 { yyval = new TAO_PSDL_Init_Dcl (yyvsp[-3]); ;
03144     break;}
03145 case 343:
03146 #line 1337 "PSDL.yy"
03147 { yyval = new TAO_PSDL_Init_Param_Decls (yyvsp[0]); ;
03148     break;}
03149 case 344:
03150 #line 1340 "PSDL.yy"
03151 { yyval = new TAO_PSDL_Init_Param_Decls (yyvsp[-2], yyvsp[-1]); ;
03152     break;}
03153 case 345:
03154 #line 1344 "PSDL.yy"
03155 { yyval = new TAO_PSDL_Init_Param_Decl (yyvsp[-2], yyvsp[-1], yyvsp[0]); ;
03156     break;}
03157 case 346:
03158 #line 1348 "PSDL.yy"
03159 { yyval = new TAO_PSDL_Predefined_Type (TAO_PSDL_IN); ;
03160     break;}
03161 case 347:
03162 #line 1352 "PSDL.yy"
03163 { yyval = new TAO_PSDL_Positive_Int_Const (yyvsp[0]); ;
03164     break;}
03165 case 348:
03166 #line 1356 "PSDL.yy"
03167 { yyval = new TAO_PSDL_Factory_Dcl (yyvsp[-1], yyvsp[0]); ;
03168     break;}
03169 case 349:
03170 #line 1360 "PSDL.yy"
03171 { yyval = new TAO_PSDL_Factory_Parameters (yyvsp[-1]); ;
03172     break;}
03173 case 350:
03174 #line 1363 "PSDL.yy"
03175 { yyval = new TAO_PSDL_Factory_Parameters (); ;
03176     break;}
03177 }
03178 
03179 #line 705 "/usr/share/bison/bison.simple"
03180 
03181 
03182   yyvsp -= yylen;
03183   yyssp -= yylen;
03184 #if YYLSP_NEEDED
03185   yylsp -= yylen;
03186 #endif
03187 
03188 #if YYDEBUG
03189   if (yydebug)
03190     {
03191       short *yyssp1 = yyss - 1;
03192       YYFPRINTF (stderr, "state stack now");
03193       while (yyssp1 != yyssp)
03194         YYFPRINTF (stderr, " %d", *++yyssp1);
03195       YYFPRINTF (stderr, "\n");
03196     }
03197 #endif
03198 
03199   *++yyvsp = yyval;
03200 #if YYLSP_NEEDED
03201   *++yylsp = yyloc;
03202 #endif
03203 
03204   /* Now `shift' the result of the reduction.  Determine what state
03205      that goes to, based on the state we popped back to and the rule
03206      number reduced by.  */
03207 
03208   yyn = yyr1[yyn];
03209 
03210   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
03211   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
03212     yystate = yytable[yystate];
03213   else
03214     yystate = yydefgoto[yyn - YYNTBASE];
03215 
03216   goto yynewstate;
03217 
03218 
03219 /*------------------------------------.
03220 | yyerrlab -- here on detecting error |
03221 `------------------------------------*/
03222 yyerrlab:
03223   /* If not already recovering from an error, report this error.  */
03224   if (!yyerrstatus)
03225     {
03226       ++yynerrs;
03227 
03228 #ifdef YYERROR_VERBOSE
03229       yyn = yypact[yystate];
03230 
03231       if (yyn > YYFLAG && yyn < YYLAST)
03232         {
03233           YYSIZE_T yysize = 0;
03234           char *yymsg;
03235           int yyx, yycount;
03236 
03237           yycount = 0;
03238           /* Start YYX at -YYN if negative to avoid negative indexes in
03239              YYCHECK.  */
03240           for (yyx = yyn < 0 ? -yyn : 0;
03241                yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
03242             if (yycheck[yyx + yyn] == yyx)
03243               yysize += yystrlen (yytname[yyx]) + 15, yycount++;
03244           yysize += yystrlen ("parse error, unexpected ") + 1;
03245           yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
03246           yymsg = (char *) YYSTACK_ALLOC (yysize);
03247           if (yymsg != 0)
03248             {
03249               char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
03250               yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
03251 
03252               if (yycount < 5)
03253                 {
03254                   yycount = 0;
03255                   for (yyx = yyn < 0 ? -yyn : 0;
03256                        yyx < (int) (sizeof (yytname) / sizeof (char *));
03257                        yyx++)
03258                     if (yycheck[yyx + yyn] == yyx)
03259                       {
03260                         const char *yyq = ! yycount ? ", expecting " : " or ";
03261                         yyp = yystpcpy (yyp, yyq);
03262                         yyp = yystpcpy (yyp, yytname[yyx]);
03263                         yycount++;
03264                       }
03265                 }
03266               yyerror (yymsg);
03267               YYSTACK_FREE (yymsg);
03268             }
03269           else
03270             yyerror ("parse error; also virtual memory exhausted");
03271         }
03272       else
03273 #endif /* defined (YYERROR_VERBOSE) */
03274         yyerror ("parse error");
03275     }
03276   goto yyerrlab1;
03277 
03278 
03279 /*--------------------------------------------------.
03280 | yyerrlab1 -- error raised explicitly by an action |
03281 `--------------------------------------------------*/
03282 yyerrlab1:
03283   if (yyerrstatus == 3)
03284     {
03285       /* If just tried and failed to reuse lookahead token after an
03286          error, discard it.  */
03287 
03288       /* return failure if at end of input */
03289       if (yychar == YYEOF)
03290         YYABORT;
03291       YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
03292                   yychar, yytname[yychar1]));
03293       yychar = YYEMPTY;
03294     }
03295 
03296   /* Else will try to reuse lookahead token after shifting the error
03297      token.  */
03298 
03299   yyerrstatus = 3;              /* Each real token shifted decrements this */
03300 
03301   goto yyerrhandle;
03302 
03303 
03304 /*-------------------------------------------------------------------.
03305 | yyerrdefault -- current state does not do anything special for the |
03306 | error token.                                                       |
03307 `-------------------------------------------------------------------*/
03308 yyerrdefault:
03309 #if 0
03310   /* This is wrong; only states that explicitly want error tokens
03311      should shift them.  */
03312 
03313   /* If its default is to accept any token, ok.  Otherwise pop it.  */
03314   yyn = yydefact[yystate];
03315   if (yyn)
03316     goto yydefault;
03317 #endif
03318 
03319 
03320 /*---------------------------------------------------------------.
03321 | yyerrpop -- pop the current state because it cannot handle the |
03322 | error token                                                    |
03323 `---------------------------------------------------------------*/
03324 yyerrpop:
03325   if (yyssp == yyss)
03326     YYABORT;
03327   yyvsp--;
03328   yystate = *--yyssp;
03329 #if YYLSP_NEEDED
03330   yylsp--;
03331 #endif
03332 
03333 #if YYDEBUG
03334   if (yydebug)
03335     {
03336       short *yyssp1 = yyss - 1;
03337       YYFPRINTF (stderr, "Error: state stack now");
03338       while (yyssp1 != yyssp)
03339         YYFPRINTF (stderr, " %d", *++yyssp1);
03340       YYFPRINTF (stderr, "\n");
03341     }
03342 #endif
03343 
03344 /*--------------.
03345 | yyerrhandle.  |
03346 `--------------*/
03347 yyerrhandle:
03348   yyn = yypact[yystate];
03349   if (yyn == YYFLAG)
03350     goto yyerrdefault;
03351 
03352   yyn += YYTERROR;
03353   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
03354     goto yyerrdefault;
03355 
03356   yyn = yytable[yyn];
03357   if (yyn < 0)
03358     {
03359       if (yyn == YYFLAG)
03360         goto yyerrpop;
03361       yyn = -yyn;
03362       goto yyreduce;
03363     }
03364   else if (yyn == 0)
03365     goto yyerrpop;
03366 
03367   if (yyn == YYFINAL)
03368     YYACCEPT;
03369 
03370   YYDPRINTF ((stderr, "Shifting error token, "));
03371 
03372   *++yyvsp = yylval;
03373 #if YYLSP_NEEDED
03374   *++yylsp = yylloc;
03375 #endif
03376 
03377   yystate = yyn;
03378   goto yynewstate;
03379 
03380 
03381 /*-------------------------------------.
03382 | yyacceptlab -- YYACCEPT comes here.  |
03383 `-------------------------------------*/
03384 yyacceptlab:
03385   yyresult = 0;
03386   goto yyreturn;
03387 
03388 /*-----------------------------------.
03389 | yyabortlab -- YYABORT comes here.  |
03390 `-----------------------------------*/
03391 yyabortlab:
03392   yyresult = 1;
03393   goto yyreturn;
03394 
03395 /*---------------------------------------------.
03396 | yyoverflowab -- parser overflow comes here.  |
03397 `---------------------------------------------*/
03398 yyoverflowlab:
03399   yyerror ("parser stack overflow");
03400   yyresult = 2;
03401   /* Fall through.  */
03402 
03403 yyreturn:
03404 #ifndef yyoverflow
03405   if (yyss != yyssa)
03406     YYSTACK_FREE (yyss);
03407 #endif
03408   return yyresult;
03409 }

Defines
#define	YYBISON 1 /* Identify Bison output. */
#define	yyparse TAO_PSDL_yyparse
#define	yylex TAO_PSDL_yylex
#define	yyerror TAO_PSDL_yyerror
#define	yylval TAO_PSDL_yylval
#define	yychar TAO_PSDL_yychar
#define	yydebug TAO_PSDL_yydebug
#define	yynerrs TAO_PSDL_yynerrs
#define	TAO_PSDL_SEMI 257
#define	TAO_PSDL_MODULE 258
#define	TAO_PSDL_COLON 259
#define	TAO_PSDL_OPEN_CURLY_BRACE 260
#define	TAO_PSDL_CLOSE_CURLY_BRACE 261
#define	TAO_PSDL_OPEN_BRACE 262
#define	TAO_PSDL_CLOSE_BRACE 263
#define	TAO_PSDL_ABSTRACT 264
#define	TAO_PSDL_STORAGETYPE 265
#define	TAO_PSDL_STORAGEHOME 266
#define	TAO_PSDL_CATALOG 267
#define	TAO_PSDL_PROVIDES 268
#define	TAO_PSDL_IMPLEMENTS 269
#define	TAO_PSDL_SCOPE 270
#define	TAO_PSDL_STORES 271
#define	TAO_PSDL_STATE 272
#define	TAO_PSDL_AS 273
#define	TAO_PSDL_PRIMARY 274
#define	TAO_PSDL_STRONG 275
#define	TAO_PSDL_REF 276
#define	TAO_PSDL_OF 277
#define	TAO_PSDL_OPEN_ANGULAR_BRACE 278
#define	TAO_PSDL_CLOSE_ANGULAR_BRACE 279
#define	TAO_PSDL_COMMA 280
#define	TAO_PSDL_KEY 281
#define	TAO_PSDL_READONLY 282
#define	TAO_PSDL_UNION 283
#define	TAO_PSDL_SWITCH 284
#define	TAO_PSDL_CASE 285
#define	TAO_PSDL_WCHAR 286
#define	TAO_PSDL_BOOLEAN 287
#define	TAO_PSDL_OCTET 288
#define	TAO_PSDL_ANY 289
#define	TAO_PSDL_OBJECT 290
#define	TAO_PSDL_STRUCT 291
#define	TAO_PSDL_DEFAULT 292
#define	TAO_PSDL_FLOAT 293
#define	TAO_PSDL_DOUBLE 294
#define	TAO_PSDL_LONG 295
#define	TAO_PSDL_SHORT 296
#define	TAO_PSDL_UNSIGNED 297
#define	TAO_PSDL_CHAR 298
#define	TAO_PSDL_IDENT 299
#define	TAO_PSDL_TYPEDEF 300
#define	TAO_PSDL_NATIVE 301
#define	TAO_PSDL_PLUS 302
#define	TAO_PSDL_MINUS 303
#define	TAO_PSDL_XOR 304
#define	TAO_PSDL_AND 305
#define	TAO_PSDL_MULT 306
#define	TAO_PSDL_RIGHT_SHIFT 307
#define	TAO_PSDL_LEFT_SHIFT 308
#define	TAO_PSDL_DIV 309
#define	TAO_PSDL_PERCENT 310
#define	TAO_PSDL_TILDA 311
#define	TAO_PSDL_ONEWAY 312
#define	TAO_PSDL_CONST 313
#define	TAO_PSDL_EQUAL 314
#define	TAO_PSDL_OR 315
#define	TAO_PSDL_VOID 316
#define	TAO_PSDL_IN 317
#define	TAO_PSDL_OUT 318
#define	TAO_PSDL_INOUT 319
#define	TAO_PSDL_RAISES 320
#define	TAO_PSDL_CONTEXT 321
#define	TAO_PSDL_FIXED 322
#define	TAO_PSDL_VALUEBASE 323
#define	TAO_PSDL_EXCEPTION 324
#define	TAO_PSDL_INTERFACE 325
#define	TAO_PSDL_LOCAL 326
#define	TAO_PSDL_DOUBLE_COLON 327
#define	TAO_PSDL_VALUETYPE 328
#define	TAO_PSDL_CUSTOM 329
#define	TAO_PSDL_TRUNCATABLE 330
#define	TAO_PSDL_SUPPORTS 331
#define	TAO_PSDL_STRING 332
#define	TAO_PSDL_WSTRING 333
#define	TAO_PSDL_ATTRIBUTE 334
#define	TAO_PSDL_OPEN_SQUARE_BRACE 335
#define	TAO_PSDL_CLOSE_SQUARE_BRACE 336
#define	TAO_PSDL_ENUM 337
#define	TAO_PSDL_SEQUENCE 338
#define	TAO_PSDL_TRUE 339
#define	TAO_PSDL_FALSE 340
#define	TAO_PSDL_INTEGER 341
#define	TAO_PSDL_FLOATING 342
#define	TAO_PSDL_PRIVATE 343
#define	TAO_PSDL_PUBLIC 344
#define	TAO_PSDL_FACTORY 345
#define	TAO_PSDL_FLOATING_PT 346
#define	TAO_PSDL_CHAR_LITERAL 347
#define	TAO_PSDL_FIXED_PT 348
#define	YYPARSE_PARAM lex_state
#define	YYLEX_PARAM lex_state
#define	YYDEBUG 0
#define	YYFINAL 593
#define	YYFLAG -32768
#define	YYNTBASE 95
#define	YYTRANSLATE(x) ((unsigned)(x) <= 348 ? yytranslate[x] : 262)
#define	YYLAST 1288
#define	YYPURE 1
#define	YYSIZE_T size_t
#define	YYSTACK_ALLOC malloc
#define	YYSTACK_FREE free
#define	yyerrok (yyerrstatus = 0)
#define	yyclearin (yychar = YYEMPTY)
#define	YYEMPTY -2
#define	YYEOF 0
#define	YYACCEPT goto yyacceptlab
#define	YYABORT goto yyabortlab
#define	YYERROR goto yyerrlab1
#define	YYFAIL goto yyerrlab
#define	YYRECOVERING() (!!yyerrstatus)
#define	YYBACKUP(Token, Value)
#define	YYTERROR 1
#define	YYERRCODE 256
#define	YYLLOC_DEFAULT(Current, Rhs, N)
#define	YYLEX yylex (&yylval, YYLEX_PARAM)
#define	YYDPRINTF(Args)
#define	YYINITDEPTH 200
#define	YYMAXDEPTH 10000
#define	YYPARSE_PARAM_ARG void *YYPARSE_PARAM
#define	YYPARSE_PARAM_DECL
#define	YY_DECL_NON_LSP_VARIABLES
#define	YY_DECL_VARIABLES YY_DECL_NON_LSP_VARIABLES
#define	YYPOPSTACK (yyvsp--, yyssp--)
Functions
int	yylex (void)
void	yyerror (const char *error)
int	yyparse (YYPARSE_PARAM_ARG) YYPARSE_PARAM_DECL
Variables
const char	yytranslate []
const short	yyr1 []
const short	yyr2 []
const short	yydefact []
const short	yydefgoto []
const short	yypact []
const short	yypgoto []
const short	yytable []
const short	yycheck []
YYSTYPE	yyval
int	yynerrs
PSDL_y.cpp File Reference

Defines

Functions

Variables

Define Documentation

Function Documentation

Variable Documentation
