faustparser.cpp File Reference

#include "tree.hh"
#include "xtended.hh"
#include "boxes.hh"
#include "prim2.hh"
#include "signals.hh"
#include "errormsg.hh"
#include "sourcereader.hh"
#include <string>
#include <set>
#include <vector>
#include "doc.hh"
#include "ppbox.hh"
#include <list>
#include <stdio.h>
Include dependency graph for faustparser.cpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

union  YYSTYPE
union  yyalloc

Defines

#define YYBISON   1
#define YYBISON_VERSION   "2.4.1"
#define YYSKELETON_NAME   "yacc.c"
#define YYPURE   0
#define YYPUSH   0
#define YYPULL   1
#define YYLSP_NEEDED   0
#define YYDEBUG   1
#define YYERROR_VERBOSE   1
#define YYMAXDEPTH   100000
#define YYERROR_VERBOSE   1
#define YYTOKEN_TABLE   0
#define YYTOKENTYPE
#define YYSTYPE_IS_TRIVIAL   1
#define yystype   YYSTYPE
#define YYSTYPE_IS_DECLARED   1
#define YYSIZE_T   unsigned int
#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)
#define YY_(msgid)   msgid
#define YYUSE(e)   ((void) (e))
#define YYID(n)   (n)
#define YYSTACK_ALLOC   YYMALLOC
#define YYSTACK_FREE   YYFREE
#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM
#define YYMALLOC   malloc
#define YYFREE   free
#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)
#define YYSTACK_BYTES(N)
#define YYCOPY(To, From, Count)
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
#define YYFINAL   3
#define YYLAST   569
#define YYNTOKENS   108
#define YYNNTS   48
#define YYNRULES   178
#define YYNSTATES   379
#define YYUNDEFTOK   2
#define YYMAXUTOK   362
#define YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
#define YYPACT_NINF   -131
#define YYTABLE_NINF   -3
#define yyerrok   (yyerrstatus = 0)
#define yyclearin   (yychar = YYEMPTY)
#define YYEMPTY   (-2)
#define YYEOF   0
#define YYACCEPT   goto yyacceptlab
#define YYABORT   goto yyabortlab
#define YYERROR   goto yyerrorlab
#define YYFAIL   goto yyerrlab
#define YYRECOVERING()   (!!yyerrstatus)
#define YYBACKUP(Token, Value)
#define YYTERROR   1
#define YYERRCODE   256
#define YYRHSLOC(Rhs, K)   ((Rhs)[K])
#define YYLLOC_DEFAULT(Current, Rhs, N)
#define YY_LOCATION_PRINT(File, Loc)   ((void) 0)
#define YYLEX   yylex ()
#define YYFPRINTF   fprintf
#define YYDPRINTF(Args)
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
#define YY_STACK_PRINT(Bottom, Top)
#define YY_REDUCE_PRINT(Rule)
#define YYINITDEPTH   200
#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))

Typedefs

typedef union YYSTYPE YYSTYPE
typedef unsigned char yytype_uint8
typedef short int yytype_int8
typedef unsigned short int yytype_uint16
typedef short int yytype_int16

Enumerations

enum  yytokentype {
  WITH = 258, MIX = 259, SPLIT = 260, SEQ = 261,
  PAR = 262, REC = 263, NE = 264, GE = 265,
  GT = 266, EQ = 267, LE = 268, LT = 269,
  OR = 270, SUB = 271, ADD = 272, RSH = 273,
  LSH = 274, XOR = 275, AND = 276, MOD = 277,
  DIV = 278, MUL = 279, POWOP = 280, FDELAY = 281,
  DELAY1 = 282, DOT = 283, APPL = 284, MEM = 285,
  PREFIX = 286, INTCAST = 287, FLOATCAST = 288, FFUNCTION = 289,
  FCONSTANT = 290, FVARIABLE = 291, BUTTON = 292, CHECKBOX = 293,
  VSLIDER = 294, HSLIDER = 295, NENTRY = 296, VGROUP = 297,
  HGROUP = 298, TGROUP = 299, HBARGRAPH = 300, VBARGRAPH = 301,
  ATTACH = 302, ACOS = 303, ASIN = 304, ATAN = 305,
  ATAN2 = 306, COS = 307, SIN = 308, TAN = 309,
  EXP = 310, LOG = 311, LOG10 = 312, POWFUN = 313,
  SQRT = 314, ABS = 315, MIN = 316, MAX = 317,
  FMOD = 318, REMAINDER = 319, FLOOR = 320, CEIL = 321,
  RINT = 322, RDTBL = 323, RWTBL = 324, SELECT2 = 325,
  SELECT3 = 326, INT = 327, FLOAT = 328, LAMBDA = 329,
  WIRE = 330, CUT = 331, ENDDEF = 332, VIRG = 333,
  LPAR = 334, RPAR = 335, LBRAQ = 336, RBRAQ = 337,
  DEF = 338, IMPORT = 339, COMPONENT = 340, LIBRARY = 341,
  ENVIRONMENT = 342, IPAR = 343, ISEQ = 344, ISUM = 345,
  IPROD = 346, STRING = 347, FSTRING = 348, IDENT = 349,
  EXTRA = 350, DECLARE = 351, CASE = 352, ARROW = 353,
  BDOC = 354, EDOC = 355, BEQN = 356, EEQN = 357,
  BDGM = 358, EDGM = 359, DOCCHAR = 360, NOTICE = 361,
  LISTING = 362
}

Functions

int yylex ()
Tree unquote (char *str)
static void yy_symbol_value_print (yyoutput, yytype, yyvaluep) FILE *yyoutput
static YYSIZE_T yystrlen (yystr) const char *yystr
int yyparse ()

Variables

char * yytext
const char * yyfilename
int yylineno
int yyerr
Tree gResult
map< Tree, set< Tree > > gMetaDataSet
vector< TreegDocVector
 Contains <mdoc> parsed trees: DOCTXT, DOCEQN, DOCDGM.
static string doctxtString = ""
static const yytype_uint8 yytranslate []
static const yytype_uint16 yyprhs []
static const yytype_int16 yyrhs []
static const yytype_uint16 yyrline []
static const char *const yytname []
static const yytype_uint8 yyr1 []
static const yytype_uint8 yyr2 []
static const yytype_uint8 yydefact []
static const yytype_int16 yydefgoto []
static const yytype_int16 yypact []
static const yytype_int16 yypgoto []
static const yytype_int16 yytable []
static const yytype_uint16 yycheck []
static const yytype_uint8 yystos []
int yytype
YYSTYPE const *const yyvaluep
yytype_int16yytop
int yyrule
const char * yysrc
int yychar
YYSTYPE yylval
int yynerrs

Define Documentation

#define YY_ ( msgid   )     msgid

Definition at line 350 of file faustparser.cpp.

Referenced by yyparse().

#define YY_LOCATION_PRINT ( File,
Loc   )     ((void) 0)

Definition at line 1136 of file faustparser.cpp.

#define YY_REDUCE_PRINT ( Rule   ) 
Value:
do {                    \
  if (yydebug)              \
    yy_reduce_print (yyvsp, Rule); \
} while (YYID (0))

Referenced by yyparse().

#define YY_STACK_PRINT ( Bottom,
Top   ) 
Value:
do {                                \
  if (yydebug)                          \
    yy_stack_print ((Bottom), (Top));               \
} while (YYID (0))

Referenced by yyparse().

#define YY_SYMBOL_PRINT ( Title,
Type,
Value,
Location   ) 
Value:
do {                                      \
  if (yydebug)                                \
    {                                     \
      YYFPRINTF (stderr, "%s ", Title);                   \
      yy_symbol_print (stderr,                        \
          Type, Value); \
      YYFPRINTF (stderr, "\n");                       \
    }                                     \
} while (YYID (0))

Definition at line 1163 of file faustparser.cpp.

Referenced by yyparse().

#define YYABORT   goto yyabortlab

Definition at line 1065 of file faustparser.cpp.

Referenced by yyparse().

#define YYACCEPT   goto yyacceptlab

Definition at line 1064 of file faustparser.cpp.

Referenced by yyparse().

#define YYBACKUP ( Token,
Value   ) 
Value:
do                              \
  if (yychar == YYEMPTY && yylen == 1)              \
    {                               \
      yychar = (Token);                     \
      yylval = (Value);                     \
      yytoken = YYTRANSLATE (yychar);               \
      YYPOPSTACK (1);                       \
      goto yybackup;                        \
    }                               \
  else                              \
    {                               \
      yyerror (YY_("syntax error: cannot back up")); \
      YYERROR;                          \
    }                               \
while (YYID (0))

Definition at line 1077 of file faustparser.cpp.

#define YYBISON   1

Definition at line 46 of file faustparser.cpp.

#define YYBISON_VERSION   "2.4.1"

Definition at line 49 of file faustparser.cpp.

#define yyclearin   (yychar = YYEMPTY)

Definition at line 1060 of file faustparser.cpp.

#define YYCOPY ( To,
From,
Count   ) 
Value:
do                  \
    {                   \
      YYSIZE_T yyi;             \
      for (yyi = 0; yyi < (Count); yyi++)   \
        (To)[yyi] = (From)[yyi];        \
    }                   \
      while (YYID (0))

Definition at line 476 of file faustparser.cpp.

#define YYDEBUG   1

Definition at line 87 of file faustparser.cpp.

#define YYDPRINTF ( Args   ) 
Value:
do {                        \
  if (yydebug)                  \
    YYFPRINTF Args;             \
} while (YYID (0))

Definition at line 1157 of file faustparser.cpp.

Referenced by yyparse().

#define YYEMPTY   (-2)

Definition at line 1061 of file faustparser.cpp.

Referenced by yyparse().

#define YYEOF   0

Definition at line 1062 of file faustparser.cpp.

Referenced by yyparse().

#define YYERRCODE   256

Definition at line 1096 of file faustparser.cpp.

#define yyerrok   (yyerrstatus = 0)

Definition at line 1059 of file faustparser.cpp.

#define YYERROR   goto yyerrorlab

Definition at line 1066 of file faustparser.cpp.

#define YYERROR_VERBOSE   1

Definition at line 141 of file faustparser.cpp.

#define YYERROR_VERBOSE   1

Definition at line 141 of file faustparser.cpp.

#define YYFAIL   goto yyerrlab

Definition at line 1073 of file faustparser.cpp.

#define YYFINAL   3

Definition at line 506 of file faustparser.cpp.

Referenced by yyparse().

#define YYFPRINTF   fprintf

Definition at line 1154 of file faustparser.cpp.

#define YYFREE   free

Definition at line 439 of file faustparser.cpp.

#define YYID (  )     (n)

Definition at line 363 of file faustparser.cpp.

Referenced by yyparse().

#define YYINITDEPTH   200

Definition at line 1315 of file faustparser.cpp.

Referenced by yyparse().

#define YYLAST   569

Definition at line 508 of file faustparser.cpp.

Referenced by yyparse().

#define YYLEX   yylex ()

Definition at line 1146 of file faustparser.cpp.

Referenced by yyparse().

#define YYLLOC_DEFAULT ( Current,
Rhs,
 ) 
Value:
do                                  \
      if (YYID (N))                                                    \
    {                               \
      (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;    \
      (Current).first_column = YYRHSLOC (Rhs, 1).first_column;  \
      (Current).last_line    = YYRHSLOC (Rhs, N).last_line;     \
      (Current).last_column  = YYRHSLOC (Rhs, N).last_column;   \
    }                               \
      else                              \
    {                               \
      (Current).first_line   = (Current).last_line   =      \
        YYRHSLOC (Rhs, 0).last_line;                \
      (Current).first_column = (Current).last_column =      \
        YYRHSLOC (Rhs, 0).last_column;              \
    }                               \
    while (YYID (0))

Definition at line 1105 of file faustparser.cpp.

#define YYLSP_NEEDED   0

Definition at line 64 of file faustparser.cpp.

#define YYMALLOC   malloc

Definition at line 432 of file faustparser.cpp.

#define YYMAXDEPTH   100000

Definition at line 89 of file faustparser.cpp.

Referenced by yyparse().

#define YYMAXUTOK   362

Definition at line 521 of file faustparser.cpp.

#define YYNNTS   48

Definition at line 513 of file faustparser.cpp.

#define YYNRULES   178

Definition at line 515 of file faustparser.cpp.

#define YYNSTATES   379

Definition at line 517 of file faustparser.cpp.

#define YYNTOKENS   108

Definition at line 511 of file faustparser.cpp.

Referenced by yyparse().

#define YYPACT_NINF   -131

Definition at line 835 of file faustparser.cpp.

Referenced by yyparse().

#define YYPOPSTACK (  )     (yyvsp -= (N), yyssp -= (N))

Referenced by yyparse().

#define YYPULL   1

Definition at line 61 of file faustparser.cpp.

#define YYPURE   0

Definition at line 55 of file faustparser.cpp.

#define YYPUSH   0

Definition at line 58 of file faustparser.cpp.

 
#define YYRECOVERING (  )     (!!yyerrstatus)

Definition at line 1075 of file faustparser.cpp.

#define YYRHSLOC ( Rhs,
 )     ((Rhs)[K])

Definition at line 1103 of file faustparser.cpp.

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

Definition at line 340 of file faustparser.cpp.

#define YYSIZE_T   unsigned int

Definition at line 336 of file faustparser.cpp.

Referenced by yyparse().

#define YYSKELETON_NAME   "yacc.c"

Definition at line 52 of file faustparser.cpp.

#define YYSTACK_ALLOC   YYMALLOC

Definition at line 418 of file faustparser.cpp.

Referenced by yyparse().

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 421 of file faustparser.cpp.

Referenced by yyparse().

#define YYSTACK_BYTES (  ) 
Value:
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
      + YYSTACK_GAP_MAXIMUM)

Definition at line 465 of file faustparser.cpp.

Referenced by yyparse().

#define YYSTACK_FREE   YYFREE

Definition at line 419 of file faustparser.cpp.

Referenced by yyparse().

#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)

Definition at line 461 of file faustparser.cpp.

#define YYSTACK_RELOCATE ( Stack_alloc,
Stack   ) 
Value:
do                                  \
      {                                 \
    YYSIZE_T yynewbytes;                        \
    YYCOPY (&yyptr->Stack_alloc, Stack, yysize);            \
    Stack = &yyptr->Stack_alloc;                    \
    yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
    yyptr += yynewbytes / sizeof (*yyptr);              \
      }                                 \
    while (YYID (0))

Definition at line 492 of file faustparser.cpp.

Referenced by yyparse().

#define yystype   YYSTYPE

Definition at line 284 of file faustparser.cpp.

#define YYSTYPE_IS_DECLARED   1

Definition at line 285 of file faustparser.cpp.

#define YYSTYPE_IS_TRIVIAL   1

Definition at line 283 of file faustparser.cpp.

#define YYTABLE_NINF   -3

Definition at line 892 of file faustparser.cpp.

Referenced by yyparse().

#define YYTERROR   1

Definition at line 1095 of file faustparser.cpp.

Referenced by yyparse().

#define YYTOKEN_TABLE   0

Definition at line 148 of file faustparser.cpp.

#define YYTOKENTYPE

Definition at line 154 of file faustparser.cpp.

#define YYTRANSLATE ( YYX   )     ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

Definition at line 523 of file faustparser.cpp.

Referenced by yyparse().

#define YYUNDEFTOK   2

Definition at line 520 of file faustparser.cpp.

#define YYUSE (  )     ((void) (e))

Definition at line 356 of file faustparser.cpp.


Typedef Documentation

typedef union YYSTYPE YYSTYPE
typedef short int yytype_int16

Definition at line 323 of file faustparser.cpp.

typedef short int yytype_int8

Definition at line 311 of file faustparser.cpp.

typedef unsigned short int yytype_uint16

Definition at line 317 of file faustparser.cpp.

typedef unsigned char yytype_uint8

Definition at line 302 of file faustparser.cpp.


Enumeration Type Documentation

Enumerator:
WITH 
MIX 
SPLIT 
SEQ 
PAR 
REC 
NE 
GE 
GT 
EQ 
LE 
LT 
OR 
SUB 
ADD 
RSH 
LSH 
XOR 
AND 
MOD 
DIV 
MUL 
POWOP 
FDELAY 
DELAY1 
DOT 
APPL 
MEM 
PREFIX 
INTCAST 
FLOATCAST 
FFUNCTION 
FCONSTANT 
FVARIABLE 
BUTTON 
CHECKBOX 
VSLIDER 
HSLIDER 
NENTRY 
VGROUP 
HGROUP 
TGROUP 
HBARGRAPH 
VBARGRAPH 
ATTACH 
ACOS 
ASIN 
ATAN 
ATAN2 
COS 
SIN 
TAN 
EXP 
LOG 
LOG10 
POWFUN 
SQRT 
ABS 
MIN 
MAX 
FMOD 
REMAINDER 
FLOOR 
CEIL 
RINT 
RDTBL 
RWTBL 
SELECT2 
SELECT3 
INT 
FLOAT 
LAMBDA 
WIRE 
CUT 
ENDDEF 
VIRG 
LPAR 
RPAR 
LBRAQ 
RBRAQ 
DEF 
IMPORT 
COMPONENT 
LIBRARY 
ENVIRONMENT 
IPAR 
ISEQ 
ISUM 
IPROD 
STRING 
FSTRING 
IDENT 
EXTRA 
DECLARE 
CASE 
ARROW 
BDOC 
EDOC 
BEQN 
EEQN 
BDGM 
EDGM 
DOCCHAR 
NOTICE 
LISTING 

Definition at line 157 of file faustparser.cpp.

00157                     {
00158      WITH = 258,
00159      MIX = 259,
00160      SPLIT = 260,
00161      SEQ = 261,
00162      PAR = 262,
00163      REC = 263,
00164      NE = 264,
00165      GE = 265,
00166      GT = 266,
00167      EQ = 267,
00168      LE = 268,
00169      LT = 269,
00170      OR = 270,
00171      SUB = 271,
00172      ADD = 272,
00173      RSH = 273,
00174      LSH = 274,
00175      XOR = 275,
00176      AND = 276,
00177      MOD = 277,
00178      DIV = 278,
00179      MUL = 279,
00180      POWOP = 280,
00181      FDELAY = 281,
00182      DELAY1 = 282,
00183      DOT = 283,
00184      APPL = 284,
00185      MEM = 285,
00186      PREFIX = 286,
00187      INTCAST = 287,
00188      FLOATCAST = 288,
00189      FFUNCTION = 289,
00190      FCONSTANT = 290,
00191      FVARIABLE = 291,
00192      BUTTON = 292,
00193      CHECKBOX = 293,
00194      VSLIDER = 294,
00195      HSLIDER = 295,
00196      NENTRY = 296,
00197      VGROUP = 297,
00198      HGROUP = 298,
00199      TGROUP = 299,
00200      HBARGRAPH = 300,
00201      VBARGRAPH = 301,
00202      ATTACH = 302,
00203      ACOS = 303,
00204      ASIN = 304,
00205      ATAN = 305,
00206      ATAN2 = 306,
00207      COS = 307,
00208      SIN = 308,
00209      TAN = 309,
00210      EXP = 310,
00211      LOG = 311,
00212      LOG10 = 312,
00213      POWFUN = 313,
00214      SQRT = 314,
00215      ABS = 315,
00216      MIN = 316,
00217      MAX = 317,
00218      FMOD = 318,
00219      REMAINDER = 319,
00220      FLOOR = 320,
00221      CEIL = 321,
00222      RINT = 322,
00223      RDTBL = 323,
00224      RWTBL = 324,
00225      SELECT2 = 325,
00226      SELECT3 = 326,
00227      INT = 327,
00228      FLOAT = 328,
00229      LAMBDA = 329,
00230      WIRE = 330,
00231      CUT = 331,
00232      ENDDEF = 332,
00233      VIRG = 333,
00234      LPAR = 334,
00235      RPAR = 335,
00236      LBRAQ = 336,
00237      RBRAQ = 337,
00238      DEF = 338,
00239      IMPORT = 339,
00240      COMPONENT = 340,
00241      LIBRARY = 341,
00242      ENVIRONMENT = 342,
00243      IPAR = 343,
00244      ISEQ = 344,
00245      ISUM = 345,
00246      IPROD = 346,
00247      STRING = 347,
00248      FSTRING = 348,
00249      IDENT = 349,
00250      EXTRA = 350,
00251      DECLARE = 351,
00252      CASE = 352,
00253      ARROW = 353,
00254      BDOC = 354,
00255      EDOC = 355,
00256      BEQN = 356,
00257      EEQN = 357,
00258      BDGM = 358,
00259      EDGM = 359,
00260      DOCCHAR = 360,
00261      NOTICE = 361,
00262      LISTING = 362
00263    };


Function Documentation

Tree unquote ( char *  str  ) 

Definition at line 104 of file faustparser.cpp.

References tree().

00105 {
00106     //-----------copy unquoted filename-------------
00107     char buf[512];
00108     int j=0;
00109 
00110     if (str[0] == '"') {
00111         //it is a quoted string, we remove the quotes
00112         for (int i=1; j<511 && str[i];) {
00113             buf[j++] = str[i++];
00114         }
00115         // remove last quote
00116         if (j>0) buf[j-1] = 0;
00117     } else {
00118         for (int i=0; j<511 && str[i];) {
00119             buf[j++] = str[i++];
00120         }
00121     }
00122     buf[j] = 0;
00123 
00124     return tree(buf);
00125     //----------------------------------------------
00126 }

Here is the call graph for this function:

static void yy_symbol_value_print ( yyoutput  ,
yytype  ,
yyvaluep   
) [static]
int yylex (  ) 
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.

Referenced by SourceReader::parse().

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 }

Here is the caller graph for this function:

static YYSIZE_T yystrlen ( yystr   )  const [static]

Variable Documentation

string doctxtString = "" [static]

Definition at line 99 of file faustparser.cpp.

Referenced by yyparse().

vector<Tree> gDocVector

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

Definition at line 108 of file doc.cpp.

map<Tree, set<Tree> > gMetaDataSet

Definition at line 87 of file main.cpp.

Definition at line 82 of file main.cpp.

int yychar

Definition at line 1584 of file faustparser.cpp.

const yytype_uint16 yycheck[] [static]

Definition at line 954 of file faustparser.cpp.

const yytype_uint8 yydefact[] [static]

Definition at line 781 of file faustparser.cpp.

const yytype_int16 yydefgoto[] [static]
Initial value:
{
      -1,     1,     2,   224,     9,    17,    29,    30,    31,    32,
      33,    34,   284,    11,   219,   131,   109,   110,   111,    16,
     112,   113,    23,    21,   297,   114,   115,   116,   117,   118,
     119,   120,   121,   122,   123,   124,   125,   126,   127,   128,
     129,   130,   205,   266,   320,   230,   231,   206
}

Definition at line 824 of file faustparser.cpp.

int yyerr

Definition at line 79 of file main.cpp.

const char* yyfilename

Definition at line 30 of file errormsg.cpp.

int yylineno

Definition at line 1593 of file faustparser.cpp.

int yynerrs

Definition at line 1596 of file faustparser.cpp.

const yytype_int16 yypact[] [static]

Definition at line 836 of file faustparser.cpp.

const yytype_int16 yypgoto[] [static]
Initial value:
{
    -131,  -131,  -131,   307,  -131,  -131,  -131,  -131,  -131,  -131,
    -131,  -131,   565,  -131,  -131,   -13,   -19,  -131,     9,    39,
    -110,   -81,   250,   326,   -48,  -131,  -131,  -131,  -131,  -131,
    -131,  -131,  -131,  -131,  -131,  -131,  -131,  -131,  -131,  -131,
    -131,  -131,  -131,  -131,  -131,  -131,   339,  -130
}

Definition at line 879 of file faustparser.cpp.

const yytype_uint16 yyprhs[] [static]
Initial value:
{
       0,     0,     3,     5,     6,     9,    10,    13,    19,    24,
      26,    30,    31,    34,    36,    38,    40,    42,    44,    45,
      48,    52,    56,    58,    60,    68,    73,    76,    78,    80,
      84,    90,    94,    98,   102,   106,   110,   112,   116,   120,
     124,   128,   132,   136,   140,   143,   147,   151,   155,   159,
     163,   167,   171,   175,   179,   183,   187,   191,   196,   198,
     200,   202,   205,   208,   211,   214,   216,   218,   220,   222,
     224,   226,   228,   230,   232,   234,   236,   238,   240,   242,
     244,   246,   248,   250,   252,   254,   256,   258,   260,   262,
     264,   266,   268,   270,   272,   274,   276,   278,   280,   282,
     284,   286,   288,   290,   292,   294,   296,   298,   300,   302,
     304,   306,   308,   310,   312,   314,   317,   321,   330,   335,
     337,   339,   341,   346,   351,   356,   358,   360,   362,   364,
     366,   368,   370,   372,   374,   376,   378,   380,   382,   384,
     386,   388,   390,   394,   398,   402,   406,   410,   412,   414,
     416,   418,   420,   429,   438,   447,   456,   465,   473,   481,
     486,   491,   504,   517,   530,   537,   544,   551,   560,   569,
     575,   580,   582,   584,   588,   590,   593,   600,   602
}

Definition at line 571 of file faustparser.cpp.

const yytype_uint8 yyr1[] [static]
Initial value:
{
       0,   108,   109,   110,   110,   111,   111,   112,   112,   112,
     112,   113,   113,   114,   114,   114,   114,   114,   115,   115,
     116,   117,   118,   119,   120,   120,   120,   121,   122,   122,
     123,   123,   123,   123,   123,   123,   123,   124,   124,   124,
     124,   124,   124,   124,   124,   124,   124,   124,   124,   124,
     124,   124,   124,   124,   124,   124,   124,   124,   124,   125,
     125,   125,   125,   125,   125,   125,   125,   125,   125,   125,
     125,   125,   125,   125,   125,   125,   125,   125,   125,   125,
     125,   125,   125,   125,   125,   125,   125,   125,   125,   125,
     125,   125,   125,   125,   125,   125,   125,   125,   125,   125,
     125,   125,   125,   125,   125,   125,   125,   125,   125,   125,
     125,   125,   125,   125,   125,   125,   125,   125,   125,   125,
     125,   125,   125,   125,   125,   125,   125,   125,   125,   125,
     125,   125,   125,   125,   125,   125,   125,   125,   125,   126,
     127,   128,   128,   129,   129,   129,   129,   129,   130,   131,
     132,   132,   133,   134,   135,   136,   137,   138,   139,   140,
     141,   142,   143,   144,   145,   146,   147,   148,   149,   150,
     150,   151,   152,   152,   153,   153,   154,   155,   155
}

Definition at line 733 of file faustparser.cpp.

const yytype_uint8 yyr2[] [static]
Initial value:
{
       0,     2,     1,     0,     2,     0,     2,     5,     4,     1,
       3,     0,     2,     1,     1,     1,     1,     1,     0,     2,
       3,     3,     1,     1,     7,     4,     2,     1,     1,     3,
       5,     3,     3,     3,     3,     3,     1,     3,     3,     3,
       3,     3,     3,     3,     2,     3,     3,     3,     3,     3,
       3,     3,     3,     3,     3,     3,     3,     4,     1,     1,
       1,     2,     2,     2,     2,     1,     1,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
       1,     1,     1,     1,     1,     2,     3,     8,     4,     1,
       1,     1,     4,     4,     4,     1,     1,     1,     1,     1,
       1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
       1,     1,     3,     3,     3,     3,     3,     1,     1,     1,
       1,     1,     8,     8,     8,     8,     8,     7,     7,     4,
       4,    12,    12,    12,     6,     6,     6,     8,     8,     5,
       4,     1,     1,     3,     1,     2,     6,     1,     1
}

Definition at line 756 of file faustparser.cpp.

const yytype_int16 yyrhs[] [static]

Definition at line 594 of file faustparser.cpp.

const yytype_uint16 yyrline[] [static]
Initial value:
{
       0,   265,   265,   268,   269,   271,   272,   275,   276,   277,
     278,   281,   282,   285,   286,   287,   288,   289,   292,   293,
     296,   299,   302,   305,   308,   309,   310,   313,   316,   317,
     320,   321,   322,   323,   324,   325,   326,   329,   330,   331,
     332,   333,   334,   335,   336,   337,   339,   340,   341,   343,
     344,   346,   347,   348,   349,   350,   351,   353,   355,   358,
     359,   361,   362,   364,   365,   367,   368,   370,   371,   373,
     374,   376,   377,   378,   379,   380,   381,   383,   384,   385,
     387,   388,   390,   391,   392,   393,   394,   395,   397,   399,
     400,   401,   402,   403,   404,   405,   407,   408,   409,   410,
     411,   412,   414,   415,   416,   418,   419,   421,   422,   423,
     426,   427,   429,   430,   432,   433,   435,   436,   439,   441,
     442,   443,   444,   445,   446,   448,   449,   450,   451,   452,
     453,   454,   455,   456,   457,   459,   460,   461,   462,   466,
     469,   474,   475,   478,   479,   480,   481,   482,   485,   488,
     491,   492,   497,   501,   505,   509,   516,   520,   523,   528,
     531,   534,   537,   540,   543,   546,   549,   553,   556,   562,
     563,   566,   569,   570,   573,   574,   577,   581,   582
}

Definition at line 660 of file faustparser.cpp.

int yyrule

Definition at line 1276 of file faustparser.cpp.

const char* yysrc

Definition at line 1369 of file faustparser.cpp.

const yytype_uint8 yystos[] [static]

Definition at line 1017 of file faustparser.cpp.

const yytype_int16 yytable[] [static]

Definition at line 893 of file faustparser.cpp.

char* yytext
const char* const yytname[] [static]
Initial value:
{
  "$end", "error", "$undefined", "WITH", "MIX", "SPLIT", "SEQ", "PAR",
  "REC", "NE", "GE", "GT", "EQ", "LE", "LT", "OR", "SUB", "ADD", "RSH",
  "LSH", "XOR", "AND", "MOD", "DIV", "MUL", "POWOP", "FDELAY", "DELAY1",
  "DOT", "APPL", "MEM", "PREFIX", "INTCAST", "FLOATCAST", "FFUNCTION",
  "FCONSTANT", "FVARIABLE", "BUTTON", "CHECKBOX", "VSLIDER", "HSLIDER",
  "NENTRY", "VGROUP", "HGROUP", "TGROUP", "HBARGRAPH", "VBARGRAPH",
  "ATTACH", "ACOS", "ASIN", "ATAN", "ATAN2", "COS", "SIN", "TAN", "EXP",
  "LOG", "LOG10", "POWFUN", "SQRT", "ABS", "MIN", "MAX", "FMOD",
  "REMAINDER", "FLOOR", "CEIL", "RINT", "RDTBL", "RWTBL", "SELECT2",
  "SELECT3", "INT", "FLOAT", "LAMBDA", "WIRE", "CUT", "ENDDEF", "VIRG",
  "LPAR", "RPAR", "LBRAQ", "RBRAQ", "DEF", "IMPORT", "COMPONENT",
  "LIBRARY", "ENVIRONMENT", "IPAR", "ISEQ", "ISUM", "IPROD", "STRING",
  "FSTRING", "IDENT", "EXTRA", "DECLARE", "CASE", "ARROW", "BDOC", "EDOC",
  "BEQN", "EEQN", "BDGM", "EDGM", "DOCCHAR", "NOTICE", "LISTING",
  "$accept", "program", "stmtlist", "deflist", "statement", "doc",
  "docelem", "doctxt", "doceqn", "docdgm", "docntc", "doclst",
  "definition", "defname", "params", "expression", "infixexp", "primitive",
  "ident", "name", "arglist", "argument", "string", "uqstring", "fstring",
  "fpar", "fseq", "fsum", "fprod", "ffunction", "fconst", "fvariable",
  "button", "checkbox", "vslider", "hslider", "nentry", "vgroup", "hgroup",
  "tgroup", "vbargraph", "hbargraph", "signature", "fun", "typelist",
  "rulelist", "rule", "type", 0
}

Definition at line 686 of file faustparser.cpp.

Definition at line 1245 of file faustparser.cpp.

const yytype_uint8 yytranslate[] [static]

Definition at line 527 of file faustparser.cpp.

int yytype

Definition at line 1188 of file faustparser.cpp.

Definition at line 1189 of file faustparser.cpp.

Generated on Wed Apr 28 23:45:49 2010 for FAUST compiler by  doxygen 1.6.3