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