sourcereader.cpp File Reference

#include <iostream>
#include <map>
#include <list>
#include <string>
#include "sourcereader.hh"
#include "enrobage.hh"
#include "ppbox.hh"
Include dependency graph for sourcereader.cpp:

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< TreegDocVector
 Contains <mdoc> parsed trees: DOCTXT, DOCEQN, DOCDGM.
bool gLatexDocSwitch
int yyerr
int yydebug
FILE * yyin
int yylineno
const char * yyfilename
Tree gResult
Tree gResult2

Function Documentation

Tree checkRulelist ( Tree  lr  ) 

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 }

Here is the call graph for this function:

Here is the caller graph for this function:

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 }

Here is the caller graph for this function:

void declareMetadata ( Tree  key,
Tree  value 
)

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 }

Here is the call graph for this function:

Here is the caller graph for this function:

Tree formatDefinitions ( Tree  rldef  ) 

Formats a list of raw definitions represented by triplets <name,arglist,body> into abstractions or pattern matching rules when appropriate.

Parameters:
rldef list of raw definitions in reverse order
Returns:
the list of formatted definitions

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 }

Here is the call graph for this function:

Here is the caller graph for this function:

static Tree makeDefinition ( list< Tree > &  variants  )  [static]

Transforms a list of variants (arglist.body) into an abstraction or a boxCase.

Parameters:
variants list of variants (arglist.body)
Returns:
the corresponding box expression

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 }

Here is the call graph for this function:

Here is the caller graph for this function:

static void printPatternError ( Tree  lhs1,
Tree  rhs1,
Tree  lhs2,
Tree  rhs2 
) [static]

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 }

Here is the call graph for this function:

Here is the caller graph for this function:

static bool standardArgList ( Tree  args  )  [static]

Checks an argument list for containing only standard identifiers, no patterns and is linear.

Parameters:
args the argument list to check
Returns:
true if it contains only identifiers

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 }

Here is the call graph for this function:

Here is the caller graph for this function:

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 }


Variable Documentation

vector<Tree> gDocVector

Contains <mdoc> parsed trees: DOCTXT, DOCEQN, DOCDGM.

Definition at line 108 of file doc.cpp.

Referenced by declareDoc(), and printDoc().

Definition at line 116 of file main.cpp.

Referenced by main().

Definition at line 100 of file main.cpp.

map<Tree, set<Tree> > gMetaDataSet

Definition at line 87 of file main.cpp.

Definition at line 82 of file main.cpp.

Definition at line 83 of file main.cpp.

int yydebug
int yyerr

Definition at line 79 of file main.cpp.

Referenced by main(), SourceReader::parse(), and yyparse().

const char* yyfilename
FILE* yyin
int yylineno
Generated on Thu Apr 29 00:00:15 2010 for FAUST compiler by  doxygen 1.6.3