#include <iostream>
#include <map>
#include <list>
#include <string>
#include "sourcereader.hh"
#include "enrobage.hh"
#include "ppbox.hh"
Go to the source code of this file.
Functions | |
int | yyparse () |
static bool | standardArgList (Tree args) |
Checks an argument list for containing only standard identifiers, no patterns and is linear. | |
static void | printPatternError (Tree lhs1, Tree rhs1, Tree lhs2, Tree rhs2) |
Tree | checkRulelist (Tree lr) |
static Tree | makeDefinition (list< Tree > &variants) |
Transforms a list of variants (arglist.body) into an abstraction or a boxCase. | |
Tree | formatDefinitions (Tree rldef) |
Formats a list of raw definitions represented by triplets <name,arglist,body> into abstractions or pattern matching rules when appropriate. | |
void | declareMetadata (Tree key, Tree value) |
void | declareDoc (Tree t) |
Variables | |
map< Tree, set< Tree > > | gMetaDataSet |
string | gMasterDocument |
vector< Tree > | gDocVector |
Contains <mdoc> parsed trees: DOCTXT, DOCEQN, DOCDGM. | |
bool | gLatexDocSwitch |
int | yyerr |
int | yydebug |
FILE * | yyin |
int | yylineno |
const char * | yyfilename |
Tree | gResult |
Tree | gResult2 |
Definition at line 73 of file sourcereader.cpp.
References hd(), isNil(), len(), printPatternError(), and tl().
Referenced by yyparse().
00074 { 00075 Tree lrules = lr; 00076 if (isNil(lrules)) { cerr << "ERROR : a case expression can't be empty" << endl; exit(1); } 00077 // first pattern used as a reference 00078 Tree lhs1 = hd(hd(lrules)); 00079 Tree rhs1 = tl(hd(lrules)); 00080 int npat = len(lhs1); 00081 lrules = tl(lrules); 00082 while (! isNil(lrules)) { 00083 Tree lhs2 = hd(hd(lrules)); 00084 Tree rhs2 = tl(hd(lrules)); 00085 if (npat != len(lhs2)) { 00086 printPatternError(lhs1,rhs1,lhs2,rhs2); 00087 exit(1); 00088 } 00089 00090 lhs1 = lhs2; 00091 rhs1 = rhs2; 00092 lrules = tl(lrules); 00093 } 00094 return lr; 00095 }
void declareDoc | ( | Tree | t | ) |
Definition at line 321 of file sourcereader.cpp.
References gDocVector.
Referenced by declareAutoDoc(), and yyparse().
00322 { 00323 //gLatexDocSwitch = true; 00324 gDocVector.push_back(t); 00325 }
Definition at line 303 of file sourcereader.cpp.
References gMasterDocument, gMetaDataSet, tree(), tree2str(), and yyfilename.
Referenced by yyparse().
00304 { 00305 if (gMasterDocument == yyfilename) { 00306 // inside master document, no prefix needed to declare metadata 00307 gMetaDataSet[key].insert(value); 00308 } else { 00309 string fkey(yyfilename); 00310 fkey += "/"; 00311 fkey += tree2str(key); 00312 gMetaDataSet[tree(fkey.c_str())].insert(value); 00313 } 00314 }
Formats a list of raw definitions represented by triplets <name,arglist,body> into abstractions or pattern matching rules when appropriate.
rldef | list of raw definitions in reverse order |
Definition at line 146 of file sourcereader.cpp.
References cons(), hd(), isImportFile(), isNil(), makeDefinition(), nil, and tl().
Referenced by yyparse().
00147 { 00148 map<Tree,list<Tree> > dic; 00149 map<Tree,list<Tree> >::iterator p; 00150 Tree ldef2 = nil; 00151 Tree file; 00152 00153 //cout << "Format definitions " << *rldef << endl; 00154 // collects the definitions in a dictionnary 00155 while (!isNil(rldef)) { 00156 Tree def = hd(rldef); 00157 rldef = tl(rldef); 00158 if (isImportFile(def, file)) { 00159 ldef2 = cons(def,ldef2); 00160 } else if (!isNil(def)) { 00161 //cout << " def : " << *def << endl; 00162 dic[hd(def)].push_front(tl(def)); 00163 } 00164 } 00165 00166 // produce the definitions 00167 00168 for (p=dic.begin(); p!=dic.end(); p++) { 00169 ldef2 = cons (cons(p->first, makeDefinition(p->second)), ldef2); 00170 } 00171 00172 //cout << "list of definitions : " << *ldef2 << endl; 00173 return ldef2; 00174 00175 }
Transforms a list of variants (arglist.body) into an abstraction or a boxCase.
variants | list of variants (arglist.body) |
Definition at line 104 of file sourcereader.cpp.
References boxCase(), buildBoxAbstr(), cons(), hd(), isNil(), len(), nil, printPatternError(), standardArgList(), and tl().
Referenced by formatDefinitions().
00105 { 00106 if (variants.size() == 1) { 00107 Tree rhs = *(variants.begin()); 00108 Tree args= hd(rhs); 00109 Tree body= tl(rhs); 00110 00111 if (isNil(args)) { 00112 return body; 00113 } else if (standardArgList(args)) { 00114 return buildBoxAbstr(args, body); 00115 } else { 00116 return boxCase(cons(rhs,nil)); 00117 } 00118 } else { 00119 list<Tree>::iterator p; 00120 Tree l = nil; 00121 Tree prev = *variants.begin(); 00122 int npat = len(hd(prev)); 00123 for (p=variants.begin(); p!=variants.end(); p++) { 00124 Tree cur = *p; 00125 if (npat != len(hd(cur))) { 00126 printPatternError(hd(prev), tl(prev), hd(cur), tl(cur)); 00127 exit(1); 00128 } 00129 prev = cur; 00130 l = cons(*p,l); 00131 } 00132 return boxCase(l); 00133 } 00134 }
Definition at line 64 of file sourcereader.cpp.
References reverse().
Referenced by checkRulelist(), and makeDefinition().
00065 { 00066 cerr << "ERROR : inconsistent number of parameters in pattern-matching rule: " 00067 << boxpp(reverse(lhs2)) << " => " << boxpp(rhs2) << ";" 00068 << " previous rule was: " 00069 << boxpp(reverse(lhs1)) << " => " << boxpp(rhs1) << ";" 00070 << endl; 00071 }
static bool standardArgList | ( | Tree | args | ) | [static] |
Checks an argument list for containing only standard identifiers, no patterns and is linear.
args | the argument list to check |
Definition at line 52 of file sourcereader.cpp.
References hd(), isBoxIdent(), isList(), and tl().
Referenced by makeDefinition().
00053 { 00054 map<Tree,int> L; 00055 while (isList(args)) { 00056 if (!isBoxIdent(hd(args))) return false; 00057 if (++L[hd(args)] > 1) return false; 00058 args = tl(args); 00059 } 00060 return true; 00061 }
int yyparse | ( | ) |
Definition at line 1621 of file faustparser.cpp.
References xtended::box(), boxAccess(), boxButton(), boxCase(), boxCheckbox(), boxComponent(), boxCut(), boxEnvironment(), boxFConst(), boxFFun(), boxFVar(), boxHBargraph(), boxHGroup(), boxHSlider(), boxIdent(), boxInt(), boxIPar(), boxIProd(), boxISeq(), boxISum(), boxLibrary(), boxMerge(), boxNumEntry(), boxPar(), boxPrim1(), boxPrim2(), boxPrim3(), boxPrim4(), boxPrim5(), boxReal(), boxRec(), boxSeq(), boxSplit(), boxTGroup(), boxVBargraph(), boxVGroup(), boxVSlider(), boxWire(), boxWithLocalDef(), buildBoxAbstr(), buildBoxAppl(), checkRulelist(), cons(), declareDoc(), declareMetadata(), docDgm(), docEqn(), docLst(), docNtc(), docTxt(), doctxtString, YYSTYPE::exp, ffunction(), formatDefinitions(), gAbsPrim, gAcosPrim, gAsinPrim, gAtan2Prim, gAtanPrim, gCeilPrim, gCosPrim, gExpPrim, gFloorPrim, gFmodPrim, gLog10Prim, gLogPrim, gMaxPrim, gMinPrim, gPowPrim, gRemainderPrim, gRintPrim, gSinPrim, gSqrtPrim, gTanPrim, importFile(), nil, setDefProp(), sigAdd(), sigAND(), sigAttach(), sigDelay1(), sigDiv(), sigEQ(), sigFixDelay(), sigFloatCast(), sigGE(), sigGT(), sigIntCast(), sigLE(), sigLeftShift(), sigLT(), sigMul(), sigNE(), sigOR(), sigPrefix(), sigReadOnlyTable(), sigRem(), sigRightShift(), sigSelect2(), sigSelect3(), sigSub(), sigWriteReadTable(), sigXOR(), tree(), unquote(), YY_, YY_REDUCE_PRINT, YY_STACK_PRINT, YY_SYMBOL_PRINT, YYABORT, YYACCEPT, YYDPRINTF, YYEMPTY, YYEOF, yyerr, yyerror(), yyfilename, YYFINAL, YYID, YYINITDEPTH, YYLAST, YYLEX, yylineno, YYMAXDEPTH, YYNTOKENS, YYPACT_NINF, YYPOPSTACK, YYSIZE_T, yyalloc::yyss_alloc, YYSTACK_ALLOC, YYSTACK_ALLOC_MAXIMUM, YYSTACK_BYTES, YYSTACK_FREE, YYSTACK_RELOCATE, YYTABLE_NINF, YYTERROR, yytext, YYTRANSLATE, and yyalloc::yyvs_alloc.
01625 { 01626 01627 01628 int yystate; 01629 /* Number of tokens to shift before error messages enabled. */ 01630 int yyerrstatus; 01631 01632 /* The stacks and their tools: 01633 `yyss': related to states. 01634 `yyvs': related to semantic values. 01635 01636 Refer to the stacks thru separate pointers, to allow yyoverflow 01637 to reallocate them elsewhere. */ 01638 01639 /* The state stack. */ 01640 yytype_int16 yyssa[YYINITDEPTH]; 01641 yytype_int16 *yyss; 01642 yytype_int16 *yyssp; 01643 01644 /* The semantic value stack. */ 01645 YYSTYPE yyvsa[YYINITDEPTH]; 01646 YYSTYPE *yyvs; 01647 YYSTYPE *yyvsp; 01648 01649 YYSIZE_T yystacksize; 01650 01651 int yyn; 01652 int yyresult; 01653 /* Lookahead token as an internal (translated) token number. */ 01654 int yytoken; 01655 /* The variables used to return semantic value and location from the 01656 action routines. */ 01657 YYSTYPE yyval; 01658 01659 #if YYERROR_VERBOSE 01660 /* Buffer for error messages, and its allocated size. */ 01661 char yymsgbuf[128]; 01662 char *yymsg = yymsgbuf; 01663 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 01664 #endif 01665 01666 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 01667 01668 /* The number of symbols on the RHS of the reduced rule. 01669 Keep to zero when no symbol should be popped. */ 01670 int yylen = 0; 01671 01672 yytoken = 0; 01673 yyss = yyssa; 01674 yyvs = yyvsa; 01675 yystacksize = YYINITDEPTH; 01676 01677 YYDPRINTF ((stderr, "Starting parse\n")); 01678 01679 yystate = 0; 01680 yyerrstatus = 0; 01681 yynerrs = 0; 01682 yychar = YYEMPTY; /* Cause a token to be read. */ 01683 01684 /* Initialize stack pointers. 01685 Waste one element of value and location stack 01686 so that they stay on the same level as the state stack. 01687 The wasted elements are never initialized. */ 01688 yyssp = yyss; 01689 yyvsp = yyvs; 01690 01691 goto yysetstate; 01692 01693 /*------------------------------------------------------------. 01694 | yynewstate -- Push a new state, which is found in yystate. | 01695 `------------------------------------------------------------*/ 01696 yynewstate: 01697 /* In all cases, when you get here, the value and location stacks 01698 have just been pushed. So pushing a state here evens the stacks. */ 01699 yyssp++; 01700 01701 yysetstate: 01702 *yyssp = yystate; 01703 01704 if (yyss + yystacksize - 1 <= yyssp) 01705 { 01706 /* Get the current used size of the three stacks, in elements. */ 01707 YYSIZE_T yysize = yyssp - yyss + 1; 01708 01709 #ifdef yyoverflow 01710 { 01711 /* Give user a chance to reallocate the stack. Use copies of 01712 these so that the &'s don't force the real ones into 01713 memory. */ 01714 YYSTYPE *yyvs1 = yyvs; 01715 yytype_int16 *yyss1 = yyss; 01716 01717 /* Each stack pointer address is followed by the size of the 01718 data in use in that stack, in bytes. This used to be a 01719 conditional around just the two extra args, but that might 01720 be undefined if yyoverflow is a macro. */ 01721 yyoverflow (YY_("memory exhausted"), 01722 &yyss1, yysize * sizeof (*yyssp), 01723 &yyvs1, yysize * sizeof (*yyvsp), 01724 &yystacksize); 01725 01726 yyss = yyss1; 01727 yyvs = yyvs1; 01728 } 01729 #else /* no yyoverflow */ 01730 # ifndef YYSTACK_RELOCATE 01731 goto yyexhaustedlab; 01732 # else 01733 /* Extend the stack our own way. */ 01734 if (YYMAXDEPTH <= yystacksize) 01735 goto yyexhaustedlab; 01736 yystacksize *= 2; 01737 if (YYMAXDEPTH < yystacksize) 01738 yystacksize = YYMAXDEPTH; 01739 01740 { 01741 yytype_int16 *yyss1 = yyss; 01742 union yyalloc *yyptr = 01743 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 01744 if (! yyptr) 01745 goto yyexhaustedlab; 01746 YYSTACK_RELOCATE (yyss_alloc, yyss); 01747 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 01748 # undef YYSTACK_RELOCATE 01749 if (yyss1 != yyssa) 01750 YYSTACK_FREE (yyss1); 01751 } 01752 # endif 01753 #endif /* no yyoverflow */ 01754 01755 yyssp = yyss + yysize - 1; 01756 yyvsp = yyvs + yysize - 1; 01757 01758 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 01759 (unsigned long int) yystacksize)); 01760 01761 if (yyss + yystacksize - 1 <= yyssp) 01762 YYABORT; 01763 } 01764 01765 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 01766 01767 if (yystate == YYFINAL) 01768 YYACCEPT; 01769 01770 goto yybackup; 01771 01772 /*-----------. 01773 | yybackup. | 01774 `-----------*/ 01775 yybackup: 01776 01777 /* Do appropriate processing given the current state. Read a 01778 lookahead token if we need one and don't already have one. */ 01779 01780 /* First try to decide what to do without reference to lookahead token. */ 01781 yyn = yypact[yystate]; 01782 if (yyn == YYPACT_NINF) 01783 goto yydefault; 01784 01785 /* Not known => get a lookahead token if don't already have one. */ 01786 01787 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 01788 if (yychar == YYEMPTY) 01789 { 01790 YYDPRINTF ((stderr, "Reading a token: ")); 01791 yychar = YYLEX; 01792 } 01793 01794 if (yychar <= YYEOF) 01795 { 01796 yychar = yytoken = YYEOF; 01797 YYDPRINTF ((stderr, "Now at end of input.\n")); 01798 } 01799 else 01800 { 01801 yytoken = YYTRANSLATE (yychar); 01802 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 01803 } 01804 01805 /* If the proper action on seeing token YYTOKEN is to reduce or to 01806 detect an error, take that action. */ 01807 yyn += yytoken; 01808 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 01809 goto yydefault; 01810 yyn = yytable[yyn]; 01811 if (yyn <= 0) 01812 { 01813 if (yyn == 0 || yyn == YYTABLE_NINF) 01814 goto yyerrlab; 01815 yyn = -yyn; 01816 goto yyreduce; 01817 } 01818 01819 /* Count tokens shifted since error; after three, turn off error 01820 status. */ 01821 if (yyerrstatus) 01822 yyerrstatus--; 01823 01824 /* Shift the lookahead token. */ 01825 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 01826 01827 /* Discard the shifted token. */ 01828 yychar = YYEMPTY; 01829 01830 yystate = yyn; 01831 *++yyvsp = yylval; 01832 01833 goto yynewstate; 01834 01835 01836 /*-----------------------------------------------------------. 01837 | yydefault -- do the default action for the current state. | 01838 `-----------------------------------------------------------*/ 01839 yydefault: 01840 yyn = yydefact[yystate]; 01841 if (yyn == 0) 01842 goto yyerrlab; 01843 goto yyreduce; 01844 01845 01846 /*-----------------------------. 01847 | yyreduce -- Do a reduction. | 01848 `-----------------------------*/ 01849 yyreduce: 01850 /* yyn is the number of a rule to reduce with. */ 01851 yylen = yyr2[yyn]; 01852 01853 /* If YYLEN is nonzero, implement the default value of the action: 01854 `$$ = $1'. 01855 01856 Otherwise, the following line sets YYVAL to garbage. 01857 This behavior is undocumented and Bison 01858 users should not rely upon it. Assigning to YYVAL 01859 unconditionally makes the parser a bit smaller, and it avoids a 01860 GCC warning that YYVAL may be used uninitialized. */ 01861 yyval = yyvsp[1-yylen]; 01862 01863 01864 YY_REDUCE_PRINT (yyn); 01865 switch (yyn) 01866 { 01867 case 2: 01868 01869 /* Line 1455 of yacc.c */ 01870 #line 265 "parser/faustparser.y" 01871 { (yyval.exp) = (yyvsp[(1) - (1)].exp); gResult = formatDefinitions((yyval.exp)); ;} 01872 break; 01873 01874 case 3: 01875 01876 /* Line 1455 of yacc.c */ 01877 #line 268 "parser/faustparser.y" 01878 { (yyval.exp) = nil; ;} 01879 break; 01880 01881 case 4: 01882 01883 /* Line 1455 of yacc.c */ 01884 #line 269 "parser/faustparser.y" 01885 { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); ;} 01886 break; 01887 01888 case 5: 01889 01890 /* Line 1455 of yacc.c */ 01891 #line 271 "parser/faustparser.y" 01892 { (yyval.exp) = nil; ;} 01893 break; 01894 01895 case 6: 01896 01897 /* Line 1455 of yacc.c */ 01898 #line 272 "parser/faustparser.y" 01899 { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); ;} 01900 break; 01901 01902 case 7: 01903 01904 /* Line 1455 of yacc.c */ 01905 #line 275 "parser/faustparser.y" 01906 { (yyval.exp) = importFile((yyvsp[(3) - (5)].exp)); ;} 01907 break; 01908 01909 case 8: 01910 01911 /* Line 1455 of yacc.c */ 01912 #line 276 "parser/faustparser.y" 01913 { declareMetadata((yyvsp[(2) - (4)].exp),(yyvsp[(3) - (4)].exp)); (yyval.exp) = nil; ;} 01914 break; 01915 01916 case 9: 01917 01918 /* Line 1455 of yacc.c */ 01919 #line 277 "parser/faustparser.y" 01920 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 01921 break; 01922 01923 case 10: 01924 01925 /* Line 1455 of yacc.c */ 01926 #line 278 "parser/faustparser.y" 01927 { declareDoc((yyvsp[(2) - (3)].exp)); (yyval.exp) = nil; /*cerr << "Yacc : doc : " << *$2 << endl ; doctxtString = ""; */ ;} 01928 break; 01929 01930 case 11: 01931 01932 /* Line 1455 of yacc.c */ 01933 #line 281 "parser/faustparser.y" 01934 { (yyval.exp) = nil; ;} 01935 break; 01936 01937 case 12: 01938 01939 /* Line 1455 of yacc.c */ 01940 #line 282 "parser/faustparser.y" 01941 { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); ;} 01942 break; 01943 01944 case 13: 01945 01946 /* Line 1455 of yacc.c */ 01947 #line 285 "parser/faustparser.y" 01948 { (yyval.exp) = docTxt(doctxtString.c_str()); ;} 01949 break; 01950 01951 case 14: 01952 01953 /* Line 1455 of yacc.c */ 01954 #line 286 "parser/faustparser.y" 01955 { (yyval.exp) = docEqn((yyvsp[(1) - (1)].exp)); ;} 01956 break; 01957 01958 case 15: 01959 01960 /* Line 1455 of yacc.c */ 01961 #line 287 "parser/faustparser.y" 01962 { (yyval.exp) = docDgm((yyvsp[(1) - (1)].exp)); ;} 01963 break; 01964 01965 case 16: 01966 01967 /* Line 1455 of yacc.c */ 01968 #line 288 "parser/faustparser.y" 01969 { (yyval.exp) = docNtc(); ;} 01970 break; 01971 01972 case 17: 01973 01974 /* Line 1455 of yacc.c */ 01975 #line 289 "parser/faustparser.y" 01976 { (yyval.exp) = docLst(); ;} 01977 break; 01978 01979 case 18: 01980 01981 /* Line 1455 of yacc.c */ 01982 #line 292 "parser/faustparser.y" 01983 { ;} 01984 break; 01985 01986 case 19: 01987 01988 /* Line 1455 of yacc.c */ 01989 #line 293 "parser/faustparser.y" 01990 { (doctxtString += yytext); ;} 01991 break; 01992 01993 case 20: 01994 01995 /* Line 1455 of yacc.c */ 01996 #line 296 "parser/faustparser.y" 01997 { (yyval.exp) = (yyvsp[(2) - (3)].exp); doctxtString = ""; ;} 01998 break; 01999 02000 case 21: 02001 02002 /* Line 1455 of yacc.c */ 02003 #line 299 "parser/faustparser.y" 02004 { (yyval.exp) = (yyvsp[(2) - (3)].exp); doctxtString = ""; ;} 02005 break; 02006 02007 case 22: 02008 02009 /* Line 1455 of yacc.c */ 02010 #line 302 "parser/faustparser.y" 02011 { doctxtString = ""; ;} 02012 break; 02013 02014 case 23: 02015 02016 /* Line 1455 of yacc.c */ 02017 #line 305 "parser/faustparser.y" 02018 { doctxtString = ""; ;} 02019 break; 02020 02021 case 24: 02022 02023 /* Line 1455 of yacc.c */ 02024 #line 308 "parser/faustparser.y" 02025 { (yyval.exp) = cons((yyvsp[(1) - (7)].exp),cons((yyvsp[(3) - (7)].exp),(yyvsp[(6) - (7)].exp))); ;} 02026 break; 02027 02028 case 25: 02029 02030 /* Line 1455 of yacc.c */ 02031 #line 309 "parser/faustparser.y" 02032 { (yyval.exp) = cons((yyvsp[(1) - (4)].exp),cons(nil,(yyvsp[(3) - (4)].exp))); ;} 02033 break; 02034 02035 case 26: 02036 02037 /* Line 1455 of yacc.c */ 02038 #line 310 "parser/faustparser.y" 02039 { (yyval.exp) = nil; yyerr++; ;} 02040 break; 02041 02042 case 27: 02043 02044 /* Line 1455 of yacc.c */ 02045 #line 313 "parser/faustparser.y" 02046 { (yyval.exp)=(yyvsp[(1) - (1)].exp); setDefProp((yyvsp[(1) - (1)].exp), yyfilename, yylineno); ;} 02047 break; 02048 02049 case 28: 02050 02051 /* Line 1455 of yacc.c */ 02052 #line 316 "parser/faustparser.y" 02053 { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); ;} 02054 break; 02055 02056 case 29: 02057 02058 /* Line 1455 of yacc.c */ 02059 #line 317 "parser/faustparser.y" 02060 { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); ;} 02061 break; 02062 02063 case 30: 02064 02065 /* Line 1455 of yacc.c */ 02066 #line 320 "parser/faustparser.y" 02067 { (yyval.exp) = boxWithLocalDef((yyvsp[(1) - (5)].exp),formatDefinitions((yyvsp[(4) - (5)].exp))); ;} 02068 break; 02069 02070 case 31: 02071 02072 /* Line 1455 of yacc.c */ 02073 #line 321 "parser/faustparser.y" 02074 { (yyval.exp) = boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02075 break; 02076 02077 case 32: 02078 02079 /* Line 1455 of yacc.c */ 02080 #line 322 "parser/faustparser.y" 02081 { (yyval.exp) = boxSeq((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02082 break; 02083 02084 case 33: 02085 02086 /* Line 1455 of yacc.c */ 02087 #line 323 "parser/faustparser.y" 02088 { (yyval.exp) = boxSplit((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02089 break; 02090 02091 case 34: 02092 02093 /* Line 1455 of yacc.c */ 02094 #line 324 "parser/faustparser.y" 02095 { (yyval.exp) = boxMerge((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02096 break; 02097 02098 case 35: 02099 02100 /* Line 1455 of yacc.c */ 02101 #line 325 "parser/faustparser.y" 02102 { (yyval.exp) = boxRec((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02103 break; 02104 02105 case 36: 02106 02107 /* Line 1455 of yacc.c */ 02108 #line 326 "parser/faustparser.y" 02109 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02110 break; 02111 02112 case 37: 02113 02114 /* Line 1455 of yacc.c */ 02115 #line 329 "parser/faustparser.y" 02116 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigAdd)); ;} 02117 break; 02118 02119 case 38: 02120 02121 /* Line 1455 of yacc.c */ 02122 #line 330 "parser/faustparser.y" 02123 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigSub)); ;} 02124 break; 02125 02126 case 39: 02127 02128 /* Line 1455 of yacc.c */ 02129 #line 331 "parser/faustparser.y" 02130 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigMul)); ;} 02131 break; 02132 02133 case 40: 02134 02135 /* Line 1455 of yacc.c */ 02136 #line 332 "parser/faustparser.y" 02137 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigDiv)); ;} 02138 break; 02139 02140 case 41: 02141 02142 /* Line 1455 of yacc.c */ 02143 #line 333 "parser/faustparser.y" 02144 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigRem)); ;} 02145 break; 02146 02147 case 42: 02148 02149 /* Line 1455 of yacc.c */ 02150 #line 334 "parser/faustparser.y" 02151 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),gPowPrim->box()); ;} 02152 break; 02153 02154 case 43: 02155 02156 /* Line 1455 of yacc.c */ 02157 #line 335 "parser/faustparser.y" 02158 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigFixDelay)); ;} 02159 break; 02160 02161 case 44: 02162 02163 /* Line 1455 of yacc.c */ 02164 #line 336 "parser/faustparser.y" 02165 { (yyval.exp) = boxSeq((yyvsp[(1) - (2)].exp),boxPrim1(sigDelay1)); ;} 02166 break; 02167 02168 case 45: 02169 02170 /* Line 1455 of yacc.c */ 02171 #line 337 "parser/faustparser.y" 02172 { (yyval.exp) = boxAccess((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02173 break; 02174 02175 case 46: 02176 02177 /* Line 1455 of yacc.c */ 02178 #line 339 "parser/faustparser.y" 02179 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigAND)); ;} 02180 break; 02181 02182 case 47: 02183 02184 /* Line 1455 of yacc.c */ 02185 #line 340 "parser/faustparser.y" 02186 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigOR)); ;} 02187 break; 02188 02189 case 48: 02190 02191 /* Line 1455 of yacc.c */ 02192 #line 341 "parser/faustparser.y" 02193 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigXOR)); ;} 02194 break; 02195 02196 case 49: 02197 02198 /* Line 1455 of yacc.c */ 02199 #line 343 "parser/faustparser.y" 02200 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLeftShift)); ;} 02201 break; 02202 02203 case 50: 02204 02205 /* Line 1455 of yacc.c */ 02206 #line 344 "parser/faustparser.y" 02207 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigRightShift)); ;} 02208 break; 02209 02210 case 51: 02211 02212 /* Line 1455 of yacc.c */ 02213 #line 346 "parser/faustparser.y" 02214 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLT)); ;} 02215 break; 02216 02217 case 52: 02218 02219 /* Line 1455 of yacc.c */ 02220 #line 347 "parser/faustparser.y" 02221 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLE)); ;} 02222 break; 02223 02224 case 53: 02225 02226 /* Line 1455 of yacc.c */ 02227 #line 348 "parser/faustparser.y" 02228 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigGT)); ;} 02229 break; 02230 02231 case 54: 02232 02233 /* Line 1455 of yacc.c */ 02234 #line 349 "parser/faustparser.y" 02235 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigGE)); ;} 02236 break; 02237 02238 case 55: 02239 02240 /* Line 1455 of yacc.c */ 02241 #line 350 "parser/faustparser.y" 02242 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigEQ)); ;} 02243 break; 02244 02245 case 56: 02246 02247 /* Line 1455 of yacc.c */ 02248 #line 351 "parser/faustparser.y" 02249 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigNE)); ;} 02250 break; 02251 02252 case 57: 02253 02254 /* Line 1455 of yacc.c */ 02255 #line 353 "parser/faustparser.y" 02256 { (yyval.exp) = buildBoxAppl((yyvsp[(1) - (4)].exp),(yyvsp[(3) - (4)].exp)); ;} 02257 break; 02258 02259 case 58: 02260 02261 /* Line 1455 of yacc.c */ 02262 #line 355 "parser/faustparser.y" 02263 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02264 break; 02265 02266 case 59: 02267 02268 /* Line 1455 of yacc.c */ 02269 #line 358 "parser/faustparser.y" 02270 { (yyval.exp) = boxInt(atoi(yytext)); ;} 02271 break; 02272 02273 case 60: 02274 02275 /* Line 1455 of yacc.c */ 02276 #line 359 "parser/faustparser.y" 02277 { (yyval.exp) = boxReal(atof(yytext)); ;} 02278 break; 02279 02280 case 61: 02281 02282 /* Line 1455 of yacc.c */ 02283 #line 361 "parser/faustparser.y" 02284 { (yyval.exp) = boxInt (atoi(yytext)); ;} 02285 break; 02286 02287 case 62: 02288 02289 /* Line 1455 of yacc.c */ 02290 #line 362 "parser/faustparser.y" 02291 { (yyval.exp) = boxReal(atof(yytext)); ;} 02292 break; 02293 02294 case 63: 02295 02296 /* Line 1455 of yacc.c */ 02297 #line 364 "parser/faustparser.y" 02298 { (yyval.exp) = boxInt ( -atoi(yytext) ); ;} 02299 break; 02300 02301 case 64: 02302 02303 /* Line 1455 of yacc.c */ 02304 #line 365 "parser/faustparser.y" 02305 { (yyval.exp) = boxReal( -atof(yytext) ); ;} 02306 break; 02307 02308 case 65: 02309 02310 /* Line 1455 of yacc.c */ 02311 #line 367 "parser/faustparser.y" 02312 { (yyval.exp) = boxWire(); ;} 02313 break; 02314 02315 case 66: 02316 02317 /* Line 1455 of yacc.c */ 02318 #line 368 "parser/faustparser.y" 02319 { (yyval.exp) = boxCut(); ;} 02320 break; 02321 02322 case 67: 02323 02324 /* Line 1455 of yacc.c */ 02325 #line 370 "parser/faustparser.y" 02326 { (yyval.exp) = boxPrim1(sigDelay1); ;} 02327 break; 02328 02329 case 68: 02330 02331 /* Line 1455 of yacc.c */ 02332 #line 371 "parser/faustparser.y" 02333 { (yyval.exp) = boxPrim2(sigPrefix); ;} 02334 break; 02335 02336 case 69: 02337 02338 /* Line 1455 of yacc.c */ 02339 #line 373 "parser/faustparser.y" 02340 { (yyval.exp) = boxPrim1(sigIntCast); ;} 02341 break; 02342 02343 case 70: 02344 02345 /* Line 1455 of yacc.c */ 02346 #line 374 "parser/faustparser.y" 02347 { (yyval.exp) = boxPrim1(sigFloatCast); ;} 02348 break; 02349 02350 case 71: 02351 02352 /* Line 1455 of yacc.c */ 02353 #line 376 "parser/faustparser.y" 02354 { (yyval.exp) = boxPrim2(sigAdd); ;} 02355 break; 02356 02357 case 72: 02358 02359 /* Line 1455 of yacc.c */ 02360 #line 377 "parser/faustparser.y" 02361 { (yyval.exp) = boxPrim2(sigSub); ;} 02362 break; 02363 02364 case 73: 02365 02366 /* Line 1455 of yacc.c */ 02367 #line 378 "parser/faustparser.y" 02368 { (yyval.exp) = boxPrim2(sigMul); ;} 02369 break; 02370 02371 case 74: 02372 02373 /* Line 1455 of yacc.c */ 02374 #line 379 "parser/faustparser.y" 02375 { (yyval.exp) = boxPrim2(sigDiv); ;} 02376 break; 02377 02378 case 75: 02379 02380 /* Line 1455 of yacc.c */ 02381 #line 380 "parser/faustparser.y" 02382 { (yyval.exp) = boxPrim2(sigRem); ;} 02383 break; 02384 02385 case 76: 02386 02387 /* Line 1455 of yacc.c */ 02388 #line 381 "parser/faustparser.y" 02389 { (yyval.exp) = boxPrim2(sigFixDelay); ;} 02390 break; 02391 02392 case 77: 02393 02394 /* Line 1455 of yacc.c */ 02395 #line 383 "parser/faustparser.y" 02396 { (yyval.exp) = boxPrim2(sigAND); ;} 02397 break; 02398 02399 case 78: 02400 02401 /* Line 1455 of yacc.c */ 02402 #line 384 "parser/faustparser.y" 02403 { (yyval.exp) = boxPrim2(sigOR); ;} 02404 break; 02405 02406 case 79: 02407 02408 /* Line 1455 of yacc.c */ 02409 #line 385 "parser/faustparser.y" 02410 { (yyval.exp) = boxPrim2(sigXOR); ;} 02411 break; 02412 02413 case 80: 02414 02415 /* Line 1455 of yacc.c */ 02416 #line 387 "parser/faustparser.y" 02417 { (yyval.exp) = boxPrim2(sigLeftShift); ;} 02418 break; 02419 02420 case 81: 02421 02422 /* Line 1455 of yacc.c */ 02423 #line 388 "parser/faustparser.y" 02424 { (yyval.exp) = boxPrim2(sigRightShift); ;} 02425 break; 02426 02427 case 82: 02428 02429 /* Line 1455 of yacc.c */ 02430 #line 390 "parser/faustparser.y" 02431 { (yyval.exp) = boxPrim2(sigLT); ;} 02432 break; 02433 02434 case 83: 02435 02436 /* Line 1455 of yacc.c */ 02437 #line 391 "parser/faustparser.y" 02438 { (yyval.exp) = boxPrim2(sigLE); ;} 02439 break; 02440 02441 case 84: 02442 02443 /* Line 1455 of yacc.c */ 02444 #line 392 "parser/faustparser.y" 02445 { (yyval.exp) = boxPrim2(sigGT); ;} 02446 break; 02447 02448 case 85: 02449 02450 /* Line 1455 of yacc.c */ 02451 #line 393 "parser/faustparser.y" 02452 { (yyval.exp) = boxPrim2(sigGE); ;} 02453 break; 02454 02455 case 86: 02456 02457 /* Line 1455 of yacc.c */ 02458 #line 394 "parser/faustparser.y" 02459 { (yyval.exp) = boxPrim2(sigEQ); ;} 02460 break; 02461 02462 case 87: 02463 02464 /* Line 1455 of yacc.c */ 02465 #line 395 "parser/faustparser.y" 02466 { (yyval.exp) = boxPrim2(sigNE); ;} 02467 break; 02468 02469 case 88: 02470 02471 /* Line 1455 of yacc.c */ 02472 #line 397 "parser/faustparser.y" 02473 { (yyval.exp) = boxPrim2(sigAttach); ;} 02474 break; 02475 02476 case 89: 02477 02478 /* Line 1455 of yacc.c */ 02479 #line 399 "parser/faustparser.y" 02480 { (yyval.exp) = gAcosPrim->box(); ;} 02481 break; 02482 02483 case 90: 02484 02485 /* Line 1455 of yacc.c */ 02486 #line 400 "parser/faustparser.y" 02487 { (yyval.exp) = gAsinPrim->box(); ;} 02488 break; 02489 02490 case 91: 02491 02492 /* Line 1455 of yacc.c */ 02493 #line 401 "parser/faustparser.y" 02494 { (yyval.exp) = gAtanPrim->box(); ;} 02495 break; 02496 02497 case 92: 02498 02499 /* Line 1455 of yacc.c */ 02500 #line 402 "parser/faustparser.y" 02501 { (yyval.exp) = gAtan2Prim->box(); ;} 02502 break; 02503 02504 case 93: 02505 02506 /* Line 1455 of yacc.c */ 02507 #line 403 "parser/faustparser.y" 02508 { (yyval.exp) = gCosPrim->box(); ;} 02509 break; 02510 02511 case 94: 02512 02513 /* Line 1455 of yacc.c */ 02514 #line 404 "parser/faustparser.y" 02515 { (yyval.exp) = gSinPrim->box(); ;} 02516 break; 02517 02518 case 95: 02519 02520 /* Line 1455 of yacc.c */ 02521 #line 405 "parser/faustparser.y" 02522 { (yyval.exp) = gTanPrim->box(); ;} 02523 break; 02524 02525 case 96: 02526 02527 /* Line 1455 of yacc.c */ 02528 #line 407 "parser/faustparser.y" 02529 { (yyval.exp) = gExpPrim->box(); ;} 02530 break; 02531 02532 case 97: 02533 02534 /* Line 1455 of yacc.c */ 02535 #line 408 "parser/faustparser.y" 02536 { (yyval.exp) = gLogPrim->box(); ;} 02537 break; 02538 02539 case 98: 02540 02541 /* Line 1455 of yacc.c */ 02542 #line 409 "parser/faustparser.y" 02543 { (yyval.exp) = gLog10Prim->box(); ;} 02544 break; 02545 02546 case 99: 02547 02548 /* Line 1455 of yacc.c */ 02549 #line 410 "parser/faustparser.y" 02550 { (yyval.exp) = gPowPrim->box(); ;} 02551 break; 02552 02553 case 100: 02554 02555 /* Line 1455 of yacc.c */ 02556 #line 411 "parser/faustparser.y" 02557 { (yyval.exp) = gPowPrim->box(); ;} 02558 break; 02559 02560 case 101: 02561 02562 /* Line 1455 of yacc.c */ 02563 #line 412 "parser/faustparser.y" 02564 { (yyval.exp) = gSqrtPrim->box(); ;} 02565 break; 02566 02567 case 102: 02568 02569 /* Line 1455 of yacc.c */ 02570 #line 414 "parser/faustparser.y" 02571 { (yyval.exp) = gAbsPrim->box(); ;} 02572 break; 02573 02574 case 103: 02575 02576 /* Line 1455 of yacc.c */ 02577 #line 415 "parser/faustparser.y" 02578 { (yyval.exp) = gMinPrim->box(); ;} 02579 break; 02580 02581 case 104: 02582 02583 /* Line 1455 of yacc.c */ 02584 #line 416 "parser/faustparser.y" 02585 { (yyval.exp) = gMaxPrim->box(); ;} 02586 break; 02587 02588 case 105: 02589 02590 /* Line 1455 of yacc.c */ 02591 #line 418 "parser/faustparser.y" 02592 { (yyval.exp) = gFmodPrim->box(); ;} 02593 break; 02594 02595 case 106: 02596 02597 /* Line 1455 of yacc.c */ 02598 #line 419 "parser/faustparser.y" 02599 { (yyval.exp) = gRemainderPrim->box(); ;} 02600 break; 02601 02602 case 107: 02603 02604 /* Line 1455 of yacc.c */ 02605 #line 421 "parser/faustparser.y" 02606 { (yyval.exp) = gFloorPrim->box(); ;} 02607 break; 02608 02609 case 108: 02610 02611 /* Line 1455 of yacc.c */ 02612 #line 422 "parser/faustparser.y" 02613 { (yyval.exp) = gCeilPrim->box(); ;} 02614 break; 02615 02616 case 109: 02617 02618 /* Line 1455 of yacc.c */ 02619 #line 423 "parser/faustparser.y" 02620 { (yyval.exp) = gRintPrim->box(); ;} 02621 break; 02622 02623 case 110: 02624 02625 /* Line 1455 of yacc.c */ 02626 #line 426 "parser/faustparser.y" 02627 { (yyval.exp) = boxPrim3(sigReadOnlyTable); ;} 02628 break; 02629 02630 case 111: 02631 02632 /* Line 1455 of yacc.c */ 02633 #line 427 "parser/faustparser.y" 02634 { (yyval.exp) = boxPrim5(sigWriteReadTable); ;} 02635 break; 02636 02637 case 112: 02638 02639 /* Line 1455 of yacc.c */ 02640 #line 429 "parser/faustparser.y" 02641 { (yyval.exp) = boxPrim3(sigSelect2); ;} 02642 break; 02643 02644 case 113: 02645 02646 /* Line 1455 of yacc.c */ 02647 #line 430 "parser/faustparser.y" 02648 { (yyval.exp) = boxPrim4(sigSelect3); ;} 02649 break; 02650 02651 case 114: 02652 02653 /* Line 1455 of yacc.c */ 02654 #line 432 "parser/faustparser.y" 02655 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02656 break; 02657 02658 case 115: 02659 02660 /* Line 1455 of yacc.c */ 02661 #line 433 "parser/faustparser.y" 02662 { (yyval.exp) = boxSeq(boxPar(boxInt(0),(yyvsp[(2) - (2)].exp)),boxPrim2(sigSub)); ;} 02663 break; 02664 02665 case 116: 02666 02667 /* Line 1455 of yacc.c */ 02668 #line 435 "parser/faustparser.y" 02669 { (yyval.exp) = (yyvsp[(2) - (3)].exp); ;} 02670 break; 02671 02672 case 117: 02673 02674 /* Line 1455 of yacc.c */ 02675 #line 437 "parser/faustparser.y" 02676 { (yyval.exp) = buildBoxAbstr((yyvsp[(3) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 02677 break; 02678 02679 case 118: 02680 02681 /* Line 1455 of yacc.c */ 02682 #line 439 "parser/faustparser.y" 02683 { (yyval.exp) = boxCase(checkRulelist((yyvsp[(3) - (4)].exp))); ;} 02684 break; 02685 02686 case 119: 02687 02688 /* Line 1455 of yacc.c */ 02689 #line 441 "parser/faustparser.y" 02690 { (yyval.exp) = boxFFun((yyvsp[(1) - (1)].exp)); ;} 02691 break; 02692 02693 case 120: 02694 02695 /* Line 1455 of yacc.c */ 02696 #line 442 "parser/faustparser.y" 02697 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02698 break; 02699 02700 case 121: 02701 02702 /* Line 1455 of yacc.c */ 02703 #line 443 "parser/faustparser.y" 02704 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02705 break; 02706 02707 case 122: 02708 02709 /* Line 1455 of yacc.c */ 02710 #line 444 "parser/faustparser.y" 02711 { (yyval.exp) = boxComponent((yyvsp[(3) - (4)].exp)); ;} 02712 break; 02713 02714 case 123: 02715 02716 /* Line 1455 of yacc.c */ 02717 #line 445 "parser/faustparser.y" 02718 { (yyval.exp) = boxLibrary((yyvsp[(3) - (4)].exp)); ;} 02719 break; 02720 02721 case 124: 02722 02723 /* Line 1455 of yacc.c */ 02724 #line 446 "parser/faustparser.y" 02725 { (yyval.exp) = boxWithLocalDef(boxEnvironment(),formatDefinitions((yyvsp[(3) - (4)].exp))); ;} 02726 break; 02727 02728 case 125: 02729 02730 /* Line 1455 of yacc.c */ 02731 #line 448 "parser/faustparser.y" 02732 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02733 break; 02734 02735 case 126: 02736 02737 /* Line 1455 of yacc.c */ 02738 #line 449 "parser/faustparser.y" 02739 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02740 break; 02741 02742 case 127: 02743 02744 /* Line 1455 of yacc.c */ 02745 #line 450 "parser/faustparser.y" 02746 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02747 break; 02748 02749 case 128: 02750 02751 /* Line 1455 of yacc.c */ 02752 #line 451 "parser/faustparser.y" 02753 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02754 break; 02755 02756 case 129: 02757 02758 /* Line 1455 of yacc.c */ 02759 #line 452 "parser/faustparser.y" 02760 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02761 break; 02762 02763 case 130: 02764 02765 /* Line 1455 of yacc.c */ 02766 #line 453 "parser/faustparser.y" 02767 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02768 break; 02769 02770 case 131: 02771 02772 /* Line 1455 of yacc.c */ 02773 #line 454 "parser/faustparser.y" 02774 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02775 break; 02776 02777 case 132: 02778 02779 /* Line 1455 of yacc.c */ 02780 #line 455 "parser/faustparser.y" 02781 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02782 break; 02783 02784 case 133: 02785 02786 /* Line 1455 of yacc.c */ 02787 #line 456 "parser/faustparser.y" 02788 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02789 break; 02790 02791 case 134: 02792 02793 /* Line 1455 of yacc.c */ 02794 #line 457 "parser/faustparser.y" 02795 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02796 break; 02797 02798 case 135: 02799 02800 /* Line 1455 of yacc.c */ 02801 #line 459 "parser/faustparser.y" 02802 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02803 break; 02804 02805 case 136: 02806 02807 /* Line 1455 of yacc.c */ 02808 #line 460 "parser/faustparser.y" 02809 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02810 break; 02811 02812 case 137: 02813 02814 /* Line 1455 of yacc.c */ 02815 #line 461 "parser/faustparser.y" 02816 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02817 break; 02818 02819 case 138: 02820 02821 /* Line 1455 of yacc.c */ 02822 #line 462 "parser/faustparser.y" 02823 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02824 break; 02825 02826 case 139: 02827 02828 /* Line 1455 of yacc.c */ 02829 #line 466 "parser/faustparser.y" 02830 { (yyval.exp) = boxIdent(yytext); ;} 02831 break; 02832 02833 case 140: 02834 02835 /* Line 1455 of yacc.c */ 02836 #line 469 "parser/faustparser.y" 02837 { (yyval.exp) = tree(yytext); ;} 02838 break; 02839 02840 case 141: 02841 02842 /* Line 1455 of yacc.c */ 02843 #line 474 "parser/faustparser.y" 02844 { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); ;} 02845 break; 02846 02847 case 142: 02848 02849 /* Line 1455 of yacc.c */ 02850 #line 475 "parser/faustparser.y" 02851 { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); ;} 02852 break; 02853 02854 case 143: 02855 02856 /* Line 1455 of yacc.c */ 02857 #line 478 "parser/faustparser.y" 02858 { (yyval.exp) = boxSeq((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02859 break; 02860 02861 case 144: 02862 02863 /* Line 1455 of yacc.c */ 02864 #line 479 "parser/faustparser.y" 02865 { (yyval.exp) = boxSplit((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02866 break; 02867 02868 case 145: 02869 02870 /* Line 1455 of yacc.c */ 02871 #line 480 "parser/faustparser.y" 02872 { (yyval.exp) = boxMerge((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02873 break; 02874 02875 case 146: 02876 02877 /* Line 1455 of yacc.c */ 02878 #line 481 "parser/faustparser.y" 02879 { (yyval.exp) = boxRec((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02880 break; 02881 02882 case 147: 02883 02884 /* Line 1455 of yacc.c */ 02885 #line 482 "parser/faustparser.y" 02886 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02887 break; 02888 02889 case 148: 02890 02891 /* Line 1455 of yacc.c */ 02892 #line 485 "parser/faustparser.y" 02893 { (yyval.exp) = tree(yytext); ;} 02894 break; 02895 02896 case 149: 02897 02898 /* Line 1455 of yacc.c */ 02899 #line 488 "parser/faustparser.y" 02900 { (yyval.exp) = unquote(yytext); ;} 02901 break; 02902 02903 case 150: 02904 02905 /* Line 1455 of yacc.c */ 02906 #line 491 "parser/faustparser.y" 02907 { (yyval.exp) = tree(yytext); ;} 02908 break; 02909 02910 case 151: 02911 02912 /* Line 1455 of yacc.c */ 02913 #line 492 "parser/faustparser.y" 02914 { (yyval.exp) = tree(yytext); ;} 02915 break; 02916 02917 case 152: 02918 02919 /* Line 1455 of yacc.c */ 02920 #line 498 "parser/faustparser.y" 02921 { (yyval.exp) = boxIPar((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 02922 break; 02923 02924 case 153: 02925 02926 /* Line 1455 of yacc.c */ 02927 #line 502 "parser/faustparser.y" 02928 { (yyval.exp) = boxISeq((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 02929 break; 02930 02931 case 154: 02932 02933 /* Line 1455 of yacc.c */ 02934 #line 506 "parser/faustparser.y" 02935 { (yyval.exp) = boxISum((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 02936 break; 02937 02938 case 155: 02939 02940 /* Line 1455 of yacc.c */ 02941 #line 510 "parser/faustparser.y" 02942 { (yyval.exp) = boxIProd((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 02943 break; 02944 02945 case 156: 02946 02947 /* Line 1455 of yacc.c */ 02948 #line 517 "parser/faustparser.y" 02949 { (yyval.exp) = ffunction((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 02950 break; 02951 02952 case 157: 02953 02954 /* Line 1455 of yacc.c */ 02955 #line 521 "parser/faustparser.y" 02956 { (yyval.exp) = boxFConst((yyvsp[(3) - (7)].exp),(yyvsp[(4) - (7)].exp),(yyvsp[(6) - (7)].exp)); ;} 02957 break; 02958 02959 case 158: 02960 02961 /* Line 1455 of yacc.c */ 02962 #line 524 "parser/faustparser.y" 02963 { (yyval.exp) = boxFVar((yyvsp[(3) - (7)].exp),(yyvsp[(4) - (7)].exp),(yyvsp[(6) - (7)].exp)); ;} 02964 break; 02965 02966 case 159: 02967 02968 /* Line 1455 of yacc.c */ 02969 #line 528 "parser/faustparser.y" 02970 { (yyval.exp) = boxButton((yyvsp[(3) - (4)].exp)); ;} 02971 break; 02972 02973 case 160: 02974 02975 /* Line 1455 of yacc.c */ 02976 #line 531 "parser/faustparser.y" 02977 { (yyval.exp) = boxCheckbox((yyvsp[(3) - (4)].exp)); ;} 02978 break; 02979 02980 case 161: 02981 02982 /* Line 1455 of yacc.c */ 02983 #line 535 "parser/faustparser.y" 02984 { (yyval.exp) = boxVSlider((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); ;} 02985 break; 02986 02987 case 162: 02988 02989 /* Line 1455 of yacc.c */ 02990 #line 538 "parser/faustparser.y" 02991 { (yyval.exp) = boxHSlider((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); ;} 02992 break; 02993 02994 case 163: 02995 02996 /* Line 1455 of yacc.c */ 02997 #line 541 "parser/faustparser.y" 02998 { (yyval.exp) = boxNumEntry((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); ;} 02999 break; 03000 03001 case 164: 03002 03003 /* Line 1455 of yacc.c */ 03004 #line 544 "parser/faustparser.y" 03005 { (yyval.exp) = boxVGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); ;} 03006 break; 03007 03008 case 165: 03009 03010 /* Line 1455 of yacc.c */ 03011 #line 547 "parser/faustparser.y" 03012 { (yyval.exp) = boxHGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); ;} 03013 break; 03014 03015 case 166: 03016 03017 /* Line 1455 of yacc.c */ 03018 #line 550 "parser/faustparser.y" 03019 { (yyval.exp) = boxTGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); ;} 03020 break; 03021 03022 case 167: 03023 03024 /* Line 1455 of yacc.c */ 03025 #line 554 "parser/faustparser.y" 03026 { (yyval.exp) = boxVBargraph((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 03027 break; 03028 03029 case 168: 03030 03031 /* Line 1455 of yacc.c */ 03032 #line 557 "parser/faustparser.y" 03033 { (yyval.exp) = boxHBargraph((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 03034 break; 03035 03036 case 169: 03037 03038 /* Line 1455 of yacc.c */ 03039 #line 562 "parser/faustparser.y" 03040 { (yyval.exp) = cons((yyvsp[(1) - (5)].exp), cons((yyvsp[(2) - (5)].exp), (yyvsp[(4) - (5)].exp))); ;} 03041 break; 03042 03043 case 170: 03044 03045 /* Line 1455 of yacc.c */ 03046 #line 563 "parser/faustparser.y" 03047 { (yyval.exp) = cons((yyvsp[(1) - (4)].exp), cons((yyvsp[(2) - (4)].exp), nil)); ;} 03048 break; 03049 03050 case 171: 03051 03052 /* Line 1455 of yacc.c */ 03053 #line 566 "parser/faustparser.y" 03054 { (yyval.exp) = tree(yytext); ;} 03055 break; 03056 03057 case 172: 03058 03059 /* Line 1455 of yacc.c */ 03060 #line 569 "parser/faustparser.y" 03061 { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); ;} 03062 break; 03063 03064 case 173: 03065 03066 /* Line 1455 of yacc.c */ 03067 #line 570 "parser/faustparser.y" 03068 { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); ;} 03069 break; 03070 03071 case 174: 03072 03073 /* Line 1455 of yacc.c */ 03074 #line 573 "parser/faustparser.y" 03075 { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); ;} 03076 break; 03077 03078 case 175: 03079 03080 /* Line 1455 of yacc.c */ 03081 #line 574 "parser/faustparser.y" 03082 { (yyval.exp) = cons((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); ;} 03083 break; 03084 03085 case 176: 03086 03087 /* Line 1455 of yacc.c */ 03088 #line 578 "parser/faustparser.y" 03089 { (yyval.exp) = cons((yyvsp[(2) - (6)].exp),(yyvsp[(5) - (6)].exp)); ;} 03090 break; 03091 03092 case 177: 03093 03094 /* Line 1455 of yacc.c */ 03095 #line 581 "parser/faustparser.y" 03096 { (yyval.exp) = tree(0); ;} 03097 break; 03098 03099 case 178: 03100 03101 /* Line 1455 of yacc.c */ 03102 #line 582 "parser/faustparser.y" 03103 { (yyval.exp) = tree(1); ;} 03104 break; 03105 03106 03107 03108 /* Line 1455 of yacc.c */ 03109 #line 3110 "parser/faustparser.cpp" 03110 default: break; 03111 } 03112 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 03113 03114 YYPOPSTACK (yylen); 03115 yylen = 0; 03116 YY_STACK_PRINT (yyss, yyssp); 03117 03118 *++yyvsp = yyval; 03119 03120 /* Now `shift' the result of the reduction. Determine what state 03121 that goes to, based on the state we popped back to and the rule 03122 number reduced by. */ 03123 03124 yyn = yyr1[yyn]; 03125 03126 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 03127 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 03128 yystate = yytable[yystate]; 03129 else 03130 yystate = yydefgoto[yyn - YYNTOKENS]; 03131 03132 goto yynewstate; 03133 03134 03135 /*------------------------------------. 03136 | yyerrlab -- here on detecting error | 03137 `------------------------------------*/ 03138 yyerrlab: 03139 /* If not already recovering from an error, report this error. */ 03140 if (!yyerrstatus) 03141 { 03142 ++yynerrs; 03143 #if ! YYERROR_VERBOSE 03144 yyerror (YY_("syntax error")); 03145 #else 03146 { 03147 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 03148 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 03149 { 03150 YYSIZE_T yyalloc = 2 * yysize; 03151 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 03152 yyalloc = YYSTACK_ALLOC_MAXIMUM; 03153 if (yymsg != yymsgbuf) 03154 YYSTACK_FREE (yymsg); 03155 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 03156 if (yymsg) 03157 yymsg_alloc = yyalloc; 03158 else 03159 { 03160 yymsg = yymsgbuf; 03161 yymsg_alloc = sizeof yymsgbuf; 03162 } 03163 } 03164 03165 if (0 < yysize && yysize <= yymsg_alloc) 03166 { 03167 (void) yysyntax_error (yymsg, yystate, yychar); 03168 yyerror (yymsg); 03169 } 03170 else 03171 { 03172 yyerror (YY_("syntax error")); 03173 if (yysize != 0) 03174 goto yyexhaustedlab; 03175 } 03176 } 03177 #endif 03178 } 03179 03180 03181 03182 if (yyerrstatus == 3) 03183 { 03184 /* If just tried and failed to reuse lookahead token after an 03185 error, discard it. */ 03186 03187 if (yychar <= YYEOF) 03188 { 03189 /* Return failure if at end of input. */ 03190 if (yychar == YYEOF) 03191 YYABORT; 03192 } 03193 else 03194 { 03195 yydestruct ("Error: discarding", 03196 yytoken, &yylval); 03197 yychar = YYEMPTY; 03198 } 03199 } 03200 03201 /* Else will try to reuse lookahead token after shifting the error 03202 token. */ 03203 goto yyerrlab1; 03204 03205 03206 /*---------------------------------------------------. 03207 | yyerrorlab -- error raised explicitly by YYERROR. | 03208 `---------------------------------------------------*/ 03209 yyerrorlab: 03210 03211 /* Pacify compilers like GCC when the user code never invokes 03212 YYERROR and the label yyerrorlab therefore never appears in user 03213 code. */ 03214 if (/*CONSTCOND*/ 0) 03215 goto yyerrorlab; 03216 03217 /* Do not reclaim the symbols of the rule which action triggered 03218 this YYERROR. */ 03219 YYPOPSTACK (yylen); 03220 yylen = 0; 03221 YY_STACK_PRINT (yyss, yyssp); 03222 yystate = *yyssp; 03223 goto yyerrlab1; 03224 03225 03226 /*-------------------------------------------------------------. 03227 | yyerrlab1 -- common code for both syntax error and YYERROR. | 03228 `-------------------------------------------------------------*/ 03229 yyerrlab1: 03230 yyerrstatus = 3; /* Each real token shifted decrements this. */ 03231 03232 for (;;) 03233 { 03234 yyn = yypact[yystate]; 03235 if (yyn != YYPACT_NINF) 03236 { 03237 yyn += YYTERROR; 03238 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 03239 { 03240 yyn = yytable[yyn]; 03241 if (0 < yyn) 03242 break; 03243 } 03244 } 03245 03246 /* Pop the current state because it cannot handle the error token. */ 03247 if (yyssp == yyss) 03248 YYABORT; 03249 03250 03251 yydestruct ("Error: popping", 03252 yystos[yystate], yyvsp); 03253 YYPOPSTACK (1); 03254 yystate = *yyssp; 03255 YY_STACK_PRINT (yyss, yyssp); 03256 } 03257 03258 *++yyvsp = yylval; 03259 03260 03261 /* Shift the error token. */ 03262 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 03263 03264 yystate = yyn; 03265 goto yynewstate; 03266 03267 03268 /*-------------------------------------. 03269 | yyacceptlab -- YYACCEPT comes here. | 03270 `-------------------------------------*/ 03271 yyacceptlab: 03272 yyresult = 0; 03273 goto yyreturn; 03274 03275 /*-----------------------------------. 03276 | yyabortlab -- YYABORT comes here. | 03277 `-----------------------------------*/ 03278 yyabortlab: 03279 yyresult = 1; 03280 goto yyreturn; 03281 03282 #if !defined(yyoverflow) || YYERROR_VERBOSE 03283 /*-------------------------------------------------. 03284 | yyexhaustedlab -- memory exhaustion comes here. | 03285 `-------------------------------------------------*/ 03286 yyexhaustedlab: 03287 yyerror (YY_("memory exhausted")); 03288 yyresult = 2; 03289 /* Fall through. */ 03290 #endif 03291 03292 yyreturn: 03293 if (yychar != YYEMPTY) 03294 yydestruct ("Cleanup: discarding lookahead", 03295 yytoken, &yylval); 03296 /* Do not reclaim the symbols of the rule which action triggered 03297 this YYABORT or YYACCEPT. */ 03298 YYPOPSTACK (yylen); 03299 YY_STACK_PRINT (yyss, yyssp); 03300 while (yyssp != yyss) 03301 { 03302 yydestruct ("Cleanup: popping", 03303 yystos[*yyssp], yyvsp); 03304 YYPOPSTACK (1); 03305 } 03306 #ifndef yyoverflow 03307 if (yyss != yyssa) 03308 YYSTACK_FREE (yyss); 03309 #endif 03310 #if YYERROR_VERBOSE 03311 if (yymsg != yymsgbuf) 03312 YYSTACK_FREE (yymsg); 03313 #endif 03314 /* Make sure YYID is used. */ 03315 return YYID (yyresult); 03316 }
vector<Tree> gDocVector |
Contains <mdoc> parsed trees: DOCTXT, DOCEQN, DOCDGM.
Definition at line 108 of file doc.cpp.
Referenced by declareDoc(), and printDoc().
bool gLatexDocSwitch |
string gMasterDocument |
map<Tree, set<Tree> > gMetaDataSet |
int yydebug |
int yyerr |
Definition at line 79 of file main.cpp.
Referenced by main(), SourceReader::parse(), and yyparse().
const char* yyfilename |
Definition at line 30 of file errormsg.cpp.
Referenced by applyList(), declareMetadata(), eval2double(), eval2int(), larg2par(), SourceReader::parse(), real_a2sb(), yyerror(), and yyparse().
FILE* yyin |
int yylineno |