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 "doc.hh"
#include "ppbox.hh"
#include <string>
#include <list>
#include <stdio.h>

Include dependency graph for faustparser.cpp:

Go to the source code of this file.

Classes
union	YYSTYPE
union	yyalloc

Macros
#define	YYBISON   1
#define	YYBISON_VERSION   "2.7.12-4996"
#define	YYSKELETON_NAME   "yacc.c"
#define	YYPURE   0
#define	YYPUSH   0
#define	YYPULL   1
#define	YYDEBUG   1
#define	YYERROR_VERBOSE   1
#define	YYMAXDEPTH   100000
#define	YY_NULL   0
#define	YYERROR_VERBOSE   1
#define	YY_YY_PARSER_FAUSTPARSER_HPP_INCLUDED
#define	YYTOKENTYPE
#define	YYSTYPE_IS_TRIVIAL   1
#define	yystype   YYSTYPE /* obsolescent; will be withdrawn */
#define	YYSTYPE_IS_DECLARED   1
#define	YYSIZE_T   unsigned int
#define	YYSIZE_MAXIMUM   ((YYSIZE_T) -1)
#define	YY_(Msgid)   Msgid
#define	__attribute__(Spec)   /* empty */
#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_NEEDED   1
#define	YYSTACK_RELOCATE(Stack_alloc, Stack)
#define	YYCOPY(Dst, Src, Count)
#define	YYFINAL   3
#define	YYLAST   657
#define	YYNTOKENS   124
#define	YYNNTS   56
#define	YYNRULES   205
#define	YYNSTATES   443
#define	YYUNDEFTOK   2
#define	YYMAXUTOK   378
#define	YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
#define	YYPACT_NINF   -319
#define	YYTABLE_NINF   -3
#define	yypact_value_is_default(Yystate)   (!!((Yystate) == (-319)))
#define	yytable_value_is_error(Yytable_value)   YYID (0)
#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	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	YYCASE_(N, S)
#define	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define	YY_IGNORE_MAYBE_UNINITIALIZED_END
#define	YY_INITIAL_VALUE(Value)   /* Nothing. */
#define	YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
#define	YYSYNTAX_ERROR

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,   LCROC = 338, RCROC = 339, DEF = 340, IMPORT = 341,   COMPONENT = 342, LIBRARY = 343, ENVIRONMENT = 344, WAVEFORM = 345,   IPAR = 346, ISEQ = 347, ISUM = 348, IPROD = 349,   INPUTS = 350, OUTPUTS = 351, STRING = 352, FSTRING = 353,   IDENT = 354, EXTRA = 355, DECLARE = 356, CASE = 357,   ARROW = 358, BDOC = 359, EDOC = 360, BEQN = 361,   EEQN = 362, BDGM = 363, EDGM = 364, BLST = 365,   ELST = 366, BMETADATA = 367, EMETADATA = 368, DOCCHAR = 369,   NOTICE = 370, LISTING = 371, LSTTRUE = 372, LSTFALSE = 373,   LSTDEPENDENCIES = 374, LSTMDOCTAGS = 375, LSTDISTRIBUTED = 376, LSTEQ = 377,   LSTQ = 378 }

Functions
int	yylex ()
char	replaceCR (char c)
Tree	unquote (char *str)
int	yyparse ()
static void	yy_symbol_value_print (yyoutput, yytype, yyvaluep) FILE *yyoutput
	YYUSE (yyo)
	if (!yyvaluep) return = "Deleting"
	YYUSE (yyoutput)
	YYUSE (yytype)
static void	yy_symbol_print (yyoutput, yytype, yyvaluep) FILE *yyoutput
else	YYFPRINTF (yyoutput,"nterm %s (", yytname[yytype])
	YYFPRINTF (yyoutput,")")
static void	yy_stack_print (yybottom, yytop) yytype_int16 *yybottom
	for (;yybottom<=yytop;yybottom++)
	YYFPRINTF (stderr,"\n")
static void	yy_reduce_print (yyvsp, yyrule) YYSTYPE *yyvsp
	YYFPRINTF (stderr,"Reducing stack by rule %d (line %lu):\n", yyrule-1, yylno)
	for (yyi=0;yyi< yynrhs;yyi++)
static YYSIZE_T	yystrlen (yystr) const char *yystr
	for (yylen=0;yystr[yylen];yylen++) continue
static char *	yystpcpy (yydest, yysrc) char *yydest
	while ((*yyd++=*yys++)!= '\0') continue
static YYSIZE_T	yytnamerr (char *yyres, const char *yystr)
static int	yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
static void	yydestruct (yymsg, yytype, yyvaluep) const char *yymsg
	YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp)
YYSTYPE yylval	YY_INITIAL_VALUE (yyval_default)

Variables
char *	yytext
const char *	yyfilename
int	yylineno
int	yyerr
Tree	gResult
bool	gStripDocSwitch
bool	gLstDependenciesSwitch
	mdoc listing management. More...
bool	gLstDistributedSwitch
	mdoc listing management. More...
bool	gLstMdocTagsSwitch
	mdoc listing management. More...
map< Tree, set< Tree > >	gMetaDataSet
vector< Tree >	gDocVector
	Contains <mdoc> parsed trees: DOCTXT, DOCEQN, DOCDGM. More...
tvec	gWaveForm
int	yydebug
YYSTYPE	yylval
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_int16	yycheck []
static const yytype_uint8	yystos []
int	yytype
YYSTYPE const *const	yyvaluep
yytype_int16 *	yytop
int	yyrule
int	yyi
unsigned long int	yylno = yyrline[yyrule]
return	yylen
const char *	yysrc
const char *	yys = yysrc
return	yyd
int	yychar
int	yynerrs

Macro Definition Documentation

#define __attribute__

(

Spec

)

/* empty */

Definition at line 406 of file faustparser.cpp.

#define YY_

(

Msgid

)

Msgid

Definition at line 398 of file faustparser.cpp.

Referenced by yyparse(), and yysyntax_error().

#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Definition at line 1713 of file faustparser.cpp.

Referenced by yyparse().

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Definition at line 1714 of file faustparser.cpp.

Referenced by yyparse().

#define YY_INITIAL_VALUE

(

Value

)

/* Nothing. */

Definition at line 1717 of file faustparser.cpp.

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

Definition at line 1248 of file faustparser.cpp.

#define YY_NULL   0

Definition at line 145 of file faustparser.cpp.

Referenced by yysyntax_error().

#define YY_REDUCE_PRINT

(

Rule

)

Value:

do {                    \
  if (yydebug)              \
    yy_reduce_print (yyvsp, Rule); \
} while (YYID (0))

Definition at line 1404 of file faustparser.cpp.

Referenced by yyparse().

#define YY_STACK_PRINT	(		Bottom,
			Top
	)

Value:

do {                                \
  if (yydebug)                          \
    yy_stack_print ((Bottom), (Top));               \
} while (YYID (0))

Definition at line 1366 of file faustparser.cpp.

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 1273 of file faustparser.cpp.

Referenced by yyparse().

#define YY_YY_PARSER_FAUSTPARSER_HPP_INCLUDED

Definition at line 160 of file faustparser.cpp.

#define YYABORT   goto yyabortlab

Definition at line 1203 of file faustparser.cpp.

Referenced by yyparse().

#define YYACCEPT   goto yyacceptlab

Definition at line 1202 of file faustparser.cpp.

Referenced by yyparse().

#define YYBACKUP	(		Token,
			Value
	)

Value:

do                                                              \
  if (yychar == YYEMPTY)                                        \
    {                                                           \
      yychar = (Token);                                         \
      yylval = (Value);                                         \
      YYPOPSTACK (yylen);                                       \
      yystate = *yyssp;                                         \
      goto yybackup;                                            \
    }                                                           \
  else                                                          \
    {                                                           \
      yyerror (YY_("syntax error: cannot back up")); \
      YYERROR;                          \
    }                               \
while (YYID (0))

Definition at line 1224 of file faustparser.cpp.

#define YYBISON   1

Definition at line 44 of file faustparser.cpp.

#define YYBISON_VERSION   "2.7.12-4996"

Definition at line 47 of file faustparser.cpp.

#define YYCASE_	(		N,
			S
	)

Value:

case N:                               \
        yyformat = S;                       \
      break

Referenced by yysyntax_error().

#define yyclearin   (yychar = YYEMPTY)

Definition at line 1198 of file faustparser.cpp.

#define YYCOPY	(		Dst,
			Src,
			Count
	)

Value:

do                                        \
        {                                       \
          YYSIZE_T yyi;                         \
          for (yyi = 0; yyi < (Count); yyi++)   \
            (Dst)[yyi] = (Src)[yyi];            \
        }                                       \
      while (YYID (0))

Definition at line 555 of file faustparser.cpp.

#define YYCOPY_NEEDED   1

Definition at line 527 of file faustparser.cpp.

#define YYDEBUG   1

Definition at line 82 of file faustparser.cpp.

#define YYDPRINTF

(

Args

)

Value:

do {                        \
  if (yydebug)                  \
    YYFPRINTF Args;             \
} while (YYID (0))

Definition at line 1267 of file faustparser.cpp.

Referenced by yyparse().

#define YYEMPTY   (-2)

Definition at line 1199 of file faustparser.cpp.

Referenced by yyparse(), and yysyntax_error().

#define YYEOF   0

Definition at line 1200 of file faustparser.cpp.

Referenced by yyparse().

#define YYERRCODE   256

Definition at line 1243 of file faustparser.cpp.

#define yyerrok   (yyerrstatus = 0)

Definition at line 1197 of file faustparser.cpp.

#define YYERROR   goto yyerrorlab

Definition at line 1204 of file faustparser.cpp.

#define YYERROR_VERBOSE   1

Definition at line 152 of file faustparser.cpp.

#define YYERROR_VERBOSE   1

Definition at line 152 of file faustparser.cpp.

#define YYFAIL   goto yyerrlab

Definition at line 1214 of file faustparser.cpp.

#define YYFINAL   3

Definition at line 568 of file faustparser.cpp.

Referenced by yyparse().

#define YYFPRINTF   fprintf

Definition at line 1264 of file faustparser.cpp.

Referenced by for().

#define YYFREE   free

Definition at line 497 of file faustparser.cpp.

#define YYID

(

N

)

(N)

Definition at line 420 of file faustparser.cpp.

Referenced by yyparse().

#define YYINITDEPTH   200

Definition at line 1423 of file faustparser.cpp.

Referenced by yyparse().

#define YYLAST   657

Definition at line 570 of file faustparser.cpp.

Referenced by yyparse(), and yysyntax_error().

#define YYLEX   yylex ()

Definition at line 1256 of file faustparser.cpp.

Referenced by yyparse().

#define YYMALLOC   malloc

Definition at line 490 of file faustparser.cpp.

#define YYMAXDEPTH   100000

Definition at line 84 of file faustparser.cpp.

Referenced by yyparse().

#define YYMAXUTOK   378

Definition at line 583 of file faustparser.cpp.

#define YYNNTS   56

Definition at line 575 of file faustparser.cpp.

#define YYNRULES   205

Definition at line 577 of file faustparser.cpp.

#define YYNSTATES   443

Definition at line 579 of file faustparser.cpp.

#define YYNTOKENS   124

Definition at line 573 of file faustparser.cpp.

Referenced by yyparse(), and yysyntax_error().

#define YYPACT_NINF   -319

Definition at line 935 of file faustparser.cpp.

#define yypact_value_is_default

(

Yystate

)

(!!((Yystate) == (-319)))

Definition at line 1070 of file faustparser.cpp.

Referenced by yyparse(), and yysyntax_error().

#define YYPOPSTACK

(

N

)

(yyvsp -= (N), yyssp -= (N))

Referenced by yyparse().

#define YYPULL   1

Definition at line 59 of file faustparser.cpp.

#define YYPURE   0

Definition at line 53 of file faustparser.cpp.

#define YYPUSH   0

Definition at line 56 of file faustparser.cpp.

#define YYRECOVERING

(

)

(!!yyerrstatus)

Definition at line 1222 of file faustparser.cpp.

#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)

Definition at line 388 of file faustparser.cpp.

#define YYSIZE_T   unsigned int

Definition at line 384 of file faustparser.cpp.

Referenced by yyparse(), yysyntax_error(), and yytnamerr().

#define YYSKELETON_NAME   "yacc.c"

Definition at line 50 of file faustparser.cpp.

#define YYSTACK_ALLOC   YYMALLOC

Definition at line 476 of file faustparser.cpp.

Referenced by yyparse().

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM

Definition at line 479 of file faustparser.cpp.

Referenced by yysyntax_error().

#define YYSTACK_BYTES

(

N

)

Value:

((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
      + YYSTACK_GAP_MAXIMUM)

Definition at line 523 of file faustparser.cpp.

Referenced by yyparse().

#define YYSTACK_FREE   YYFREE

Definition at line 477 of file faustparser.cpp.

Referenced by yyparse().

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

Definition at line 519 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 534 of file faustparser.cpp.

Referenced by yyparse().

#define yystype   YYSTYPE /* obsolescent; will be withdrawn */

Definition at line 316 of file faustparser.cpp.

#define YYSTYPE_IS_DECLARED   1

Definition at line 317 of file faustparser.cpp.

#define YYSTYPE_IS_TRIVIAL   1

Definition at line 315 of file faustparser.cpp.

#define YYSYNTAX_ERROR

Value:

yysyntax_error (&yymsg_alloc, &yymsg, \
                                        yyssp, yytoken)

Referenced by yyparse().

#define YYTABLE_NINF   -3

Definition at line 999 of file faustparser.cpp.

#define yytable_value_is_error

(

Yytable_value

)

YYID (0)

Definition at line 1073 of file faustparser.cpp.

Referenced by yyparse(), and yysyntax_error().

#define YYTERROR   1

Definition at line 1242 of file faustparser.cpp.

Referenced by yyparse(), and yysyntax_error().

#define YYTOKENTYPE

Definition at line 171 of file faustparser.cpp.

#define YYTRANSLATE

(

YYX

)

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

Definition at line 585 of file faustparser.cpp.

Referenced by yyparse().

#define YYUNDEFTOK   2

Definition at line 582 of file faustparser.cpp.

#define YYUSE

(

E

)

((void) (E))

Definition at line 412 of file faustparser.cpp.

Typedef Documentation

typedef union YYSTYPE YYSTYPE

typedef short int yytype_int16

Definition at line 371 of file faustparser.cpp.

typedef short int yytype_int8

Definition at line 359 of file faustparser.cpp.

typedef unsigned short int yytype_uint16

Definition at line 365 of file faustparser.cpp.

typedef unsigned char yytype_uint8

Definition at line 350 of file faustparser.cpp.

Enumeration Type Documentation

enum yytokentype

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
LCROC
RCROC
DEF
IMPORT
COMPONENT
LIBRARY
ENVIRONMENT
WAVEFORM
IPAR
ISEQ
ISUM
IPROD
INPUTS
OUTPUTS
STRING
FSTRING
IDENT
EXTRA
DECLARE
CASE
ARROW
BDOC
EDOC
BEQN
EEQN
BDGM
EDGM
BLST
ELST
BMETADATA
EMETADATA
DOCCHAR
NOTICE
LISTING
LSTTRUE
LSTFALSE
LSTDEPENDENCIES
LSTMDOCTAGS
LSTDISTRIBUTED
LSTEQ
LSTQ

Definition at line 174 of file faustparser.cpp.

                    {
     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,
     LCROC = 338,
     RCROC = 339,
     DEF = 340,
     IMPORT = 341,
     COMPONENT = 342,
     LIBRARY = 343,
     ENVIRONMENT = 344,
     WAVEFORM = 345,
     IPAR = 346,
     ISEQ = 347,
     ISUM = 348,
     IPROD = 349,
     INPUTS = 350,
     OUTPUTS = 351,
     STRING = 352,
     FSTRING = 353,
     IDENT = 354,
     EXTRA = 355,
     DECLARE = 356,
     CASE = 357,
     ARROW = 358,
     BDOC = 359,
     EDOC = 360,
     BEQN = 361,
     EEQN = 362,
     BDGM = 363,
     EDGM = 364,
     BLST = 365,
     ELST = 366,
     BMETADATA = 367,
     EMETADATA = 368,
     DOCCHAR = 369,
     NOTICE = 370,
     LISTING = 371,
     LSTTRUE = 372,
     LSTFALSE = 373,
     LSTDEPENDENCIES = 374,
     LSTMDOCTAGS = 375,
     LSTDISTRIBUTED = 376,
     LSTEQ = 377,
     LSTQ = 378
   };

Function Documentation

for

(

;yybottom<=yytop;yybottom++

)

Definition at line 1358 of file faustparser.cpp.

References YYFPRINTF.

    {
      int yybot = *yybottom;
      YYFPRINTF (stderr, " %d", yybot);
    }

for

(

)

Definition at line 1394 of file faustparser.cpp.

References yy_symbol_print(), YYFPRINTF, yyprhs, and yyrhs.

    {
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
               &(yyvsp[(yyi + 1) - (yynrhs)])
                           );
      YYFPRINTF (stderr, "\n");
    }

Here is the call graph for this function:

for

(

yylen

= 0;yystr[yylen];yylen++

)

if

(

!

yyvaluep

)

= "Deleting"

char replaceCR

(

char

c

)

Definition at line 108 of file faustparser.cpp.

Referenced by unquote().

{
    return (c!='\n') ? c : ' ';
}

Here is the caller graph for this function:

Tree unquote

(

char *

str

)

Definition at line 113 of file faustparser.cpp.

References replaceCR(), and tree().

Referenced by yyparse().

{
    //-----------copy unquoted filename-------------
    char buf[512];
    int j=0;

    if (str[0] == '"') {
        //it is a quoted string, we remove the quotes
        for (int i=1; j<511 && str[i];) {
            buf[j++] = replaceCR(str[i++]);
        }
        // remove last quote
        if (j>0) buf[j-1] = 0;
    } else {
        for (int i=0; j<511 && str[i];) {
            buf[j++] = replaceCR(str[i++]);
        }
    }
    buf[j] = 0;

    return tree(buf);
    //----------------------------------------------
}

Here is the call graph for this function:

Here is the caller graph for this function:

while

(

*++=*++yys!

= '\0'

)

YYSTYPE yylval YY_INITIAL_VALUE

(

yyval_default

)

static void yy_reduce_print ( yyvsp  , yyrule    )

static

static void yy_stack_print ( yybottom  , yytop    )

static

static void yy_symbol_print ( yyoutput  , yytype  , yyvaluep    )

static

Referenced by for().

Here is the caller graph for this function:

YY_SYMBOL_PRINT	(	yymsg	,
		yytype	,
		yyvaluep	,
		yylocationp
	)

yy_symbol_value_print ( yyoutput  , yytype  , yyvaluep    )

static

static void yydestruct ( yymsg  , yytype  , yyvaluep    ) const

static

Referenced by yyparse().

Here is the caller graph for this function:

else YYFPRINTF

(

yyoutput

)

YYFPRINTF	(	yyoutput	,
		"
	)

YYFPRINTF	(	stderr	,
		"\n"
	)

YYFPRINTF	(	stderr	,
		"Reducing stack by rule %d (line %lu):\n"	,
		yyrule-	1,
		yylno
	)

int yylex

(

)

int yyparse

(

)

Definition at line 1748 of file faustparser.cpp.

References YYSTYPE::b, xtended::box(), boxAccess(), boxButton(), boxCase(), boxCheckbox(), boxComponent(), boxCut(), boxEnvironment(), boxFConst(), boxFFun(), boxFVar(), boxHBargraph(), boxHGroup(), boxHSlider(), boxIdent(), boxInputs(), boxInt(), boxIPar(), boxIProd(), boxISeq(), boxISum(), boxLibrary(), boxMerge(), boxModifLocalDef(), boxNumEntry(), boxOutputs(), boxPar(), boxPrim1(), boxPrim2(), boxPrim3(), boxPrim4(), boxPrim5(), boxReal(), boxRec(), boxSeq(), boxSplit(), boxTGroup(), boxVBargraph(), boxVGroup(), boxVSlider(), boxWaveform(), boxWire(), boxWithLocalDef(), buildBoxAbstr(), buildBoxAppl(), checkRulelist(), cons(), YYSTYPE::cppstr, declareDoc(), declareMetadata(), docDgm(), docEqn(), docLst(), docMtd(), docNtc(), docTxt(), YYSTYPE::exp, ffunction(), formatDefinitions(), gAbsPrim, gAcosPrim, gAsinPrim, gAtan2Prim, gAtanPrim, gCeilPrim, gCosPrim, gExpPrim, gFloorPrim, gFmodPrim, gLog10Prim, gLogPrim, gLstDependenciesSwitch, gLstDistributedSwitch, gMaxPrim, gMinPrim, gPowPrim, gRemainderPrim, gResult, gRintPrim, gSinPrim, gSqrtPrim, gStripDocSwitch, gTanPrim, gWaveForm, 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_IGNORE_MAYBE_UNINITIALIZED_BEGIN, YY_IGNORE_MAYBE_UNINITIALIZED_END, YY_REDUCE_PRINT, YY_STACK_PRINT, YY_SYMBOL_PRINT, YYABORT, YYACCEPT, yychar, yycheck, yydefact, yydefgoto, yydestruct(), YYDPRINTF, YYEMPTY, YYEOF, yyerr, yyerror(), yyfilename, YYFINAL, YYID, YYINITDEPTH, YYLAST, yylen, YYLEX, yylineno, yylval, YYMAXDEPTH, yynerrs, YYNTOKENS, yypact, yypact_value_is_default, yypgoto, YYPOPSTACK, yyr1, yyr2, YYSIZE_T, yyalloc::yyss_alloc, YYSTACK_ALLOC, YYSTACK_BYTES, YYSTACK_FREE, YYSTACK_RELOCATE, yystos, YYSYNTAX_ERROR, yytable, yytable_value_is_error, YYTERROR, yytext, YYTRANSLATE, and yyalloc::yyvs_alloc.

Referenced by SourceReader::parse().

{
    int yystate;
    /* Number of tokens to shift before error messages enabled.  */
    int yyerrstatus;

    /* The stacks and their tools:
       `yyss': related to states.
       `yyvs': related to semantic values.

       Refer to the stacks through separate pointers, to allow yyoverflow
       to reallocate them elsewhere.  */

    /* The state stack.  */
    yytype_int16 yyssa[YYINITDEPTH];
    yytype_int16 *yyss;
    yytype_int16 *yyssp;

    /* The semantic value stack.  */
    YYSTYPE yyvsa[YYINITDEPTH];
    YYSTYPE *yyvs;
    YYSTYPE *yyvsp;

    YYSIZE_T yystacksize;

  int yyn;
  int yyresult;
  /* Lookahead token as an internal (translated) token number.  */
  int yytoken = 0;
  /* The variables used to return semantic value and location from the
     action routines.  */
  YYSTYPE yyval;

#if YYERROR_VERBOSE
  /* Buffer for error messages, and its allocated size.  */
  char yymsgbuf[128];
  char *yymsg = yymsgbuf;
  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
#endif

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

  /* The number of symbols on the RHS of the reduced rule.
     Keep to zero when no symbol should be popped.  */
  int yylen = 0;

  yyssp = yyss = yyssa;
  yyvsp = yyvs = yyvsa;
  yystacksize = YYINITDEPTH;

  YYDPRINTF ((stderr, "Starting parse\n"));

  yystate = 0;
  yyerrstatus = 0;
  yynerrs = 0;
  yychar = YYEMPTY; /* Cause a token to be read.  */
  goto yysetstate;

/*------------------------------------------------------------.
| yynewstate -- Push a new state, which is found in yystate.  |
`------------------------------------------------------------*/
 yynewstate:
  /* In all cases, when you get here, the value and location stacks
     have just been pushed.  So pushing a state here evens the stacks.  */
  yyssp++;

 yysetstate:
  *yyssp = yystate;

  if (yyss + yystacksize - 1 <= yyssp)
    {
      /* Get the current used size of the three stacks, in elements.  */
      YYSIZE_T yysize = yyssp - yyss + 1;

#ifdef yyoverflow
      {
    /* Give user a chance to reallocate the stack.  Use copies of
       these so that the &'s don't force the real ones into
       memory.  */
    YYSTYPE *yyvs1 = yyvs;
    yytype_int16 *yyss1 = yyss;

    /* Each stack pointer address is followed by the size of the
       data in use in that stack, in bytes.  This used to be a
       conditional around just the two extra args, but that might
       be undefined if yyoverflow is a macro.  */
    yyoverflow (YY_("memory exhausted"),
            &yyss1, yysize * sizeof (*yyssp),
            &yyvs1, yysize * sizeof (*yyvsp),
            &yystacksize);

    yyss = yyss1;
    yyvs = yyvs1;
      }
#else /* no yyoverflow */
# ifndef YYSTACK_RELOCATE
      goto yyexhaustedlab;
# else
      /* Extend the stack our own way.  */
      if (YYMAXDEPTH <= yystacksize)
    goto yyexhaustedlab;
      yystacksize *= 2;
      if (YYMAXDEPTH < yystacksize)
    yystacksize = YYMAXDEPTH;

      {
    yytype_int16 *yyss1 = yyss;
    union yyalloc *yyptr =
      (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
    if (! yyptr)
      goto yyexhaustedlab;
    YYSTACK_RELOCATE (yyss_alloc, yyss);
    YYSTACK_RELOCATE (yyvs_alloc, yyvs);
#  undef YYSTACK_RELOCATE
    if (yyss1 != yyssa)
      YYSTACK_FREE (yyss1);
      }
# endif
#endif /* no yyoverflow */

      yyssp = yyss + yysize - 1;
      yyvsp = yyvs + yysize - 1;

      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
          (unsigned long int) yystacksize));

      if (yyss + yystacksize - 1 <= yyssp)
    YYABORT;
    }

  YYDPRINTF ((stderr, "Entering state %d\n", yystate));

  if (yystate == YYFINAL)
    YYACCEPT;

  goto yybackup;

/*-----------.
| yybackup.  |
`-----------*/
yybackup:

  /* Do appropriate processing given the current state.  Read a
     lookahead token if we need one and don't already have one.  */

  /* First try to decide what to do without reference to lookahead token.  */
  yyn = yypact[yystate];
  if (yypact_value_is_default (yyn))
    goto yydefault;

  /* Not known => get a lookahead token if don't already have one.  */

  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
  if (yychar == YYEMPTY)
    {
      YYDPRINTF ((stderr, "Reading a token: "));
      yychar = YYLEX;
    }

  if (yychar <= YYEOF)
    {
      yychar = yytoken = YYEOF;
      YYDPRINTF ((stderr, "Now at end of input.\n"));
    }
  else
    {
      yytoken = YYTRANSLATE (yychar);
      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
    }

  /* If the proper action on seeing token YYTOKEN is to reduce or to
     detect an error, take that action.  */
  yyn += yytoken;
  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
    goto yydefault;
  yyn = yytable[yyn];
  if (yyn <= 0)
    {
      if (yytable_value_is_error (yyn))
        goto yyerrlab;
      yyn = -yyn;
      goto yyreduce;
    }

  /* Count tokens shifted since error; after three, turn off error
     status.  */
  if (yyerrstatus)
    yyerrstatus--;

  /* Shift the lookahead token.  */
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);

  /* Discard the shifted token.  */
  yychar = YYEMPTY;

  yystate = yyn;
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END

  goto yynewstate;


/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- Do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     `$$ = $1'.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];


  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
        case 2:
/* Line 1787 of yacc.c  */
#line 310 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); gResult = formatDefinitions((yyval.exp)); }
    break;

  case 3:
/* Line 1787 of yacc.c  */
#line 313 "parser/faustparser.y"
    { (yyval.exp) = nil; }
    break;

  case 4:
/* Line 1787 of yacc.c  */
#line 314 "parser/faustparser.y"
    { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); }
    break;

  case 5:
/* Line 1787 of yacc.c  */
#line 316 "parser/faustparser.y"
    { (yyval.exp) = nil; }
    break;

  case 6:
/* Line 1787 of yacc.c  */
#line 317 "parser/faustparser.y"
    { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); }
    break;

  case 7:
/* Line 1787 of yacc.c  */
#line 324 "parser/faustparser.y"
    { gWaveForm.push_back((yyvsp[(1) - (1)].exp)); }
    break;

  case 8:
/* Line 1787 of yacc.c  */
#line 325 "parser/faustparser.y"
    { gWaveForm.push_back((yyvsp[(3) - (3)].exp)); }
    break;

  case 9:
/* Line 1787 of yacc.c  */
#line 328 "parser/faustparser.y"
    { (yyval.exp) = boxInt(atoi(yytext)); }
    break;

  case 10:
/* Line 1787 of yacc.c  */
#line 329 "parser/faustparser.y"
    { (yyval.exp) = boxReal(atof(yytext)); }
    break;

  case 11:
/* Line 1787 of yacc.c  */
#line 330 "parser/faustparser.y"
    { (yyval.exp) = boxInt (atoi(yytext)); }
    break;

  case 12:
/* Line 1787 of yacc.c  */
#line 331 "parser/faustparser.y"
    { (yyval.exp) = boxReal(atof(yytext)); }
    break;

  case 13:
/* Line 1787 of yacc.c  */
#line 332 "parser/faustparser.y"
    { (yyval.exp) = boxInt ( -atoi(yytext) ); }
    break;

  case 14:
/* Line 1787 of yacc.c  */
#line 333 "parser/faustparser.y"
    { (yyval.exp) = boxReal( -atof(yytext) ); }
    break;

  case 15:
/* Line 1787 of yacc.c  */
#line 337 "parser/faustparser.y"
    { (yyval.exp) = importFile((yyvsp[(3) - (5)].exp)); }
    break;

  case 16:
/* Line 1787 of yacc.c  */
#line 338 "parser/faustparser.y"
    { declareMetadata((yyvsp[(2) - (4)].exp),(yyvsp[(3) - (4)].exp)); (yyval.exp) = nil; }
    break;

  case 17:
/* Line 1787 of yacc.c  */
#line 339 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 18:
/* Line 1787 of yacc.c  */
#line 340 "parser/faustparser.y"
    { declareDoc((yyvsp[(2) - (3)].exp)); (yyval.exp) = nil; /* cerr << "Yacc : doc : " << *$2 << endl; */ }
    break;

  case 19:
/* Line 1787 of yacc.c  */
#line 343 "parser/faustparser.y"
    { (yyval.exp) = nil; }
    break;

  case 20:
/* Line 1787 of yacc.c  */
#line 344 "parser/faustparser.y"
    { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); }
    break;

  case 21:
/* Line 1787 of yacc.c  */
#line 347 "parser/faustparser.y"
    { (yyval.exp) = docTxt((yyvsp[(1) - (1)].cppstr)->c_str()); delete (yyvsp[(1) - (1)].cppstr); }
    break;

  case 22:
/* Line 1787 of yacc.c  */
#line 348 "parser/faustparser.y"
    { (yyval.exp) = docEqn((yyvsp[(1) - (1)].exp)); }
    break;

  case 23:
/* Line 1787 of yacc.c  */
#line 349 "parser/faustparser.y"
    { (yyval.exp) = docDgm((yyvsp[(1) - (1)].exp)); }
    break;

  case 24:
/* Line 1787 of yacc.c  */
#line 350 "parser/faustparser.y"
    { (yyval.exp) = docNtc(); }
    break;

  case 25:
/* Line 1787 of yacc.c  */
#line 351 "parser/faustparser.y"
    { (yyval.exp) = docLst(); }
    break;

  case 26:
/* Line 1787 of yacc.c  */
#line 352 "parser/faustparser.y"
    { (yyval.exp) = docMtd((yyvsp[(1) - (1)].exp)); }
    break;

  case 27:
/* Line 1787 of yacc.c  */
#line 355 "parser/faustparser.y"
    { (yyval.cppstr) = new string(); }
    break;

  case 28:
/* Line 1787 of yacc.c  */
#line 356 "parser/faustparser.y"
    { (yyval.cppstr) = &((yyvsp[(1) - (2)].cppstr)->append(yytext)); }
    break;

  case 29:
/* Line 1787 of yacc.c  */
#line 359 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(2) - (3)].exp); }
    break;

  case 30:
/* Line 1787 of yacc.c  */
#line 362 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(2) - (3)].exp); }
    break;

  case 31:
/* Line 1787 of yacc.c  */
#line 365 "parser/faustparser.y"
    { }
    break;

  case 32:
/* Line 1787 of yacc.c  */
#line 368 "parser/faustparser.y"
    { }
    break;

  case 33:
/* Line 1787 of yacc.c  */
#line 371 "parser/faustparser.y"
    { }
    break;

  case 34:
/* Line 1787 of yacc.c  */
#line 372 "parser/faustparser.y"
    { }
    break;

  case 35:
/* Line 1787 of yacc.c  */
#line 375 "parser/faustparser.y"
    { gLstDependenciesSwitch = (yyvsp[(4) - (5)].b); }
    break;

  case 36:
/* Line 1787 of yacc.c  */
#line 376 "parser/faustparser.y"
    { gStripDocSwitch = (yyvsp[(4) - (5)].b); gStripDocSwitch==true ? gStripDocSwitch=false : gStripDocSwitch=true; }
    break;

  case 37:
/* Line 1787 of yacc.c  */
#line 377 "parser/faustparser.y"
    { gLstDistributedSwitch = (yyvsp[(4) - (5)].b); }
    break;

  case 38:
/* Line 1787 of yacc.c  */
#line 380 "parser/faustparser.y"
    { (yyval.b) = true; }
    break;

  case 39:
/* Line 1787 of yacc.c  */
#line 381 "parser/faustparser.y"
    { (yyval.b) = false; }
    break;

  case 40:
/* Line 1787 of yacc.c  */
#line 384 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(2) - (3)].exp); }
    break;

  case 41:
/* Line 1787 of yacc.c  */
#line 387 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (7)].exp),cons((yyvsp[(3) - (7)].exp),(yyvsp[(6) - (7)].exp))); }
    break;

  case 42:
/* Line 1787 of yacc.c  */
#line 388 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (4)].exp),cons(nil,(yyvsp[(3) - (4)].exp))); }
    break;

  case 43:
/* Line 1787 of yacc.c  */
#line 389 "parser/faustparser.y"
    { (yyval.exp) = nil; yyerr++; }
    break;

  case 44:
/* Line 1787 of yacc.c  */
#line 392 "parser/faustparser.y"
    { (yyval.exp)=(yyvsp[(1) - (1)].exp); setDefProp((yyvsp[(1) - (1)].exp), yyfilename, yylineno); }
    break;

  case 45:
/* Line 1787 of yacc.c  */
#line 395 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); }
    break;

  case 46:
/* Line 1787 of yacc.c  */
#line 396 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); }
    break;

  case 47:
/* Line 1787 of yacc.c  */
#line 399 "parser/faustparser.y"
    { (yyval.exp) = boxWithLocalDef((yyvsp[(1) - (5)].exp),formatDefinitions((yyvsp[(4) - (5)].exp))); }
    break;

  case 48:
/* Line 1787 of yacc.c  */
#line 400 "parser/faustparser.y"
    { (yyval.exp) = boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
    break;

  case 49:
/* Line 1787 of yacc.c  */
#line 401 "parser/faustparser.y"
    { (yyval.exp) = boxSeq((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
    break;

  case 50:
/* Line 1787 of yacc.c  */
#line 402 "parser/faustparser.y"
    { (yyval.exp) = boxSplit((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
    break;

  case 51:
/* Line 1787 of yacc.c  */
#line 403 "parser/faustparser.y"
    { (yyval.exp) = boxMerge((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
    break;

  case 52:
/* Line 1787 of yacc.c  */
#line 404 "parser/faustparser.y"
    { (yyval.exp) = boxRec((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
    break;

  case 53:
/* Line 1787 of yacc.c  */
#line 405 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 54:
/* Line 1787 of yacc.c  */
#line 408 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigAdd)); }
    break;

  case 55:
/* Line 1787 of yacc.c  */
#line 409 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigSub)); }
    break;

  case 56:
/* Line 1787 of yacc.c  */
#line 410 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigMul)); }
    break;

  case 57:
/* Line 1787 of yacc.c  */
#line 411 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigDiv)); }
    break;

  case 58:
/* Line 1787 of yacc.c  */
#line 412 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigRem)); }
    break;

  case 59:
/* Line 1787 of yacc.c  */
#line 413 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),gPowPrim->box()); }
    break;

  case 60:
/* Line 1787 of yacc.c  */
#line 414 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigFixDelay)); }
    break;

  case 61:
/* Line 1787 of yacc.c  */
#line 415 "parser/faustparser.y"
    { (yyval.exp) = boxSeq((yyvsp[(1) - (2)].exp),boxPrim1(sigDelay1)); }
    break;

  case 62:
/* Line 1787 of yacc.c  */
#line 416 "parser/faustparser.y"
    { (yyval.exp) = boxAccess((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
    break;

  case 63:
/* Line 1787 of yacc.c  */
#line 418 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigAND)); }
    break;

  case 64:
/* Line 1787 of yacc.c  */
#line 419 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigOR)); }
    break;

  case 65:
/* Line 1787 of yacc.c  */
#line 420 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigXOR)); }
    break;

  case 66:
/* Line 1787 of yacc.c  */
#line 422 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLeftShift)); }
    break;

  case 67:
/* Line 1787 of yacc.c  */
#line 423 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigRightShift)); }
    break;

  case 68:
/* Line 1787 of yacc.c  */
#line 425 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLT)); }
    break;

  case 69:
/* Line 1787 of yacc.c  */
#line 426 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLE)); }
    break;

  case 70:
/* Line 1787 of yacc.c  */
#line 427 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigGT)); }
    break;

  case 71:
/* Line 1787 of yacc.c  */
#line 428 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigGE)); }
    break;

  case 72:
/* Line 1787 of yacc.c  */
#line 429 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigEQ)); }
    break;

  case 73:
/* Line 1787 of yacc.c  */
#line 430 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigNE)); }
    break;

  case 74:
/* Line 1787 of yacc.c  */
#line 432 "parser/faustparser.y"
    { (yyval.exp) = buildBoxAppl((yyvsp[(1) - (4)].exp),(yyvsp[(3) - (4)].exp)); }
    break;

  case 75:
/* Line 1787 of yacc.c  */
#line 433 "parser/faustparser.y"
    { (yyval.exp) = boxModifLocalDef((yyvsp[(1) - (4)].exp),formatDefinitions((yyvsp[(3) - (4)].exp))); }
    break;

  case 76:
/* Line 1787 of yacc.c  */
#line 435 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 77:
/* Line 1787 of yacc.c  */
#line 438 "parser/faustparser.y"
    { (yyval.exp) = boxInt(atoi(yytext)); }
    break;

  case 78:
/* Line 1787 of yacc.c  */
#line 439 "parser/faustparser.y"
    { (yyval.exp) = boxReal(atof(yytext)); }
    break;

  case 79:
/* Line 1787 of yacc.c  */
#line 441 "parser/faustparser.y"
    { (yyval.exp) = boxInt (atoi(yytext)); }
    break;

  case 80:
/* Line 1787 of yacc.c  */
#line 442 "parser/faustparser.y"
    { (yyval.exp) = boxReal(atof(yytext)); }
    break;

  case 81:
/* Line 1787 of yacc.c  */
#line 444 "parser/faustparser.y"
    { (yyval.exp) = boxInt ( -atoi(yytext) ); }
    break;

  case 82:
/* Line 1787 of yacc.c  */
#line 445 "parser/faustparser.y"
    { (yyval.exp) = boxReal( -atof(yytext) ); }
    break;

  case 83:
/* Line 1787 of yacc.c  */
#line 447 "parser/faustparser.y"
    { (yyval.exp) = boxWire(); }
    break;

  case 84:
/* Line 1787 of yacc.c  */
#line 448 "parser/faustparser.y"
    { (yyval.exp) = boxCut(); }
    break;

  case 85:
/* Line 1787 of yacc.c  */
#line 450 "parser/faustparser.y"
    { (yyval.exp) = boxPrim1(sigDelay1); }
    break;

  case 86:
/* Line 1787 of yacc.c  */
#line 451 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigPrefix); }
    break;

  case 87:
/* Line 1787 of yacc.c  */
#line 453 "parser/faustparser.y"
    { (yyval.exp) = boxPrim1(sigIntCast); }
    break;

  case 88:
/* Line 1787 of yacc.c  */
#line 454 "parser/faustparser.y"
    { (yyval.exp) = boxPrim1(sigFloatCast); }
    break;

  case 89:
/* Line 1787 of yacc.c  */
#line 456 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigAdd); }
    break;

  case 90:
/* Line 1787 of yacc.c  */
#line 457 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigSub); }
    break;

  case 91:
/* Line 1787 of yacc.c  */
#line 458 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigMul); }
    break;

  case 92:
/* Line 1787 of yacc.c  */
#line 459 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigDiv); }
    break;

  case 93:
/* Line 1787 of yacc.c  */
#line 460 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigRem); }
    break;

  case 94:
/* Line 1787 of yacc.c  */
#line 461 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigFixDelay); }
    break;

  case 95:
/* Line 1787 of yacc.c  */
#line 463 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigAND); }
    break;

  case 96:
/* Line 1787 of yacc.c  */
#line 464 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigOR); }
    break;

  case 97:
/* Line 1787 of yacc.c  */
#line 465 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigXOR); }
    break;

  case 98:
/* Line 1787 of yacc.c  */
#line 467 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigLeftShift); }
    break;

  case 99:
/* Line 1787 of yacc.c  */
#line 468 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigRightShift); }
    break;

  case 100:
/* Line 1787 of yacc.c  */
#line 470 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigLT); }
    break;

  case 101:
/* Line 1787 of yacc.c  */
#line 471 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigLE); }
    break;

  case 102:
/* Line 1787 of yacc.c  */
#line 472 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigGT); }
    break;

  case 103:
/* Line 1787 of yacc.c  */
#line 473 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigGE); }
    break;

  case 104:
/* Line 1787 of yacc.c  */
#line 474 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigEQ); }
    break;

  case 105:
/* Line 1787 of yacc.c  */
#line 475 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigNE); }
    break;

  case 106:
/* Line 1787 of yacc.c  */
#line 477 "parser/faustparser.y"
    { (yyval.exp) = boxPrim2(sigAttach); }
    break;

  case 107:
/* Line 1787 of yacc.c  */
#line 479 "parser/faustparser.y"
    { (yyval.exp) = gAcosPrim->box(); }
    break;

  case 108:
/* Line 1787 of yacc.c  */
#line 480 "parser/faustparser.y"
    { (yyval.exp) = gAsinPrim->box(); }
    break;

  case 109:
/* Line 1787 of yacc.c  */
#line 481 "parser/faustparser.y"
    { (yyval.exp) = gAtanPrim->box(); }
    break;

  case 110:
/* Line 1787 of yacc.c  */
#line 482 "parser/faustparser.y"
    { (yyval.exp) = gAtan2Prim->box(); }
    break;

  case 111:
/* Line 1787 of yacc.c  */
#line 483 "parser/faustparser.y"
    { (yyval.exp) = gCosPrim->box(); }
    break;

  case 112:
/* Line 1787 of yacc.c  */
#line 484 "parser/faustparser.y"
    { (yyval.exp) = gSinPrim->box(); }
    break;

  case 113:
/* Line 1787 of yacc.c  */
#line 485 "parser/faustparser.y"
    { (yyval.exp) = gTanPrim->box(); }
    break;

  case 114:
/* Line 1787 of yacc.c  */
#line 487 "parser/faustparser.y"
    { (yyval.exp) = gExpPrim->box(); }
    break;

  case 115:
/* Line 1787 of yacc.c  */
#line 488 "parser/faustparser.y"
    { (yyval.exp) = gLogPrim->box(); }
    break;

  case 116:
/* Line 1787 of yacc.c  */
#line 489 "parser/faustparser.y"
    { (yyval.exp) = gLog10Prim->box(); }
    break;

  case 117:
/* Line 1787 of yacc.c  */
#line 490 "parser/faustparser.y"
    { (yyval.exp) = gPowPrim->box(); }
    break;

  case 118:
/* Line 1787 of yacc.c  */
#line 491 "parser/faustparser.y"
    { (yyval.exp) = gPowPrim->box(); }
    break;

  case 119:
/* Line 1787 of yacc.c  */
#line 492 "parser/faustparser.y"
    { (yyval.exp) = gSqrtPrim->box(); }
    break;

  case 120:
/* Line 1787 of yacc.c  */
#line 494 "parser/faustparser.y"
    { (yyval.exp) = gAbsPrim->box(); }
    break;

  case 121:
/* Line 1787 of yacc.c  */
#line 495 "parser/faustparser.y"
    { (yyval.exp) = gMinPrim->box(); }
    break;

  case 122:
/* Line 1787 of yacc.c  */
#line 496 "parser/faustparser.y"
    { (yyval.exp) = gMaxPrim->box(); }
    break;

  case 123:
/* Line 1787 of yacc.c  */
#line 498 "parser/faustparser.y"
    { (yyval.exp) = gFmodPrim->box(); }
    break;

  case 124:
/* Line 1787 of yacc.c  */
#line 499 "parser/faustparser.y"
    { (yyval.exp) = gRemainderPrim->box(); }
    break;

  case 125:
/* Line 1787 of yacc.c  */
#line 501 "parser/faustparser.y"
    { (yyval.exp) = gFloorPrim->box(); }
    break;

  case 126:
/* Line 1787 of yacc.c  */
#line 502 "parser/faustparser.y"
    { (yyval.exp) = gCeilPrim->box(); }
    break;

  case 127:
/* Line 1787 of yacc.c  */
#line 503 "parser/faustparser.y"
    { (yyval.exp) = gRintPrim->box(); }
    break;

  case 128:
/* Line 1787 of yacc.c  */
#line 506 "parser/faustparser.y"
    { (yyval.exp) = boxPrim3(sigReadOnlyTable); }
    break;

  case 129:
/* Line 1787 of yacc.c  */
#line 507 "parser/faustparser.y"
    { (yyval.exp) = boxPrim5(sigWriteReadTable); }
    break;

  case 130:
/* Line 1787 of yacc.c  */
#line 509 "parser/faustparser.y"
    { (yyval.exp) = boxPrim3(sigSelect2); }
    break;

  case 131:
/* Line 1787 of yacc.c  */
#line 510 "parser/faustparser.y"
    { (yyval.exp) = boxPrim4(sigSelect3); }
    break;

  case 132:
/* Line 1787 of yacc.c  */
#line 512 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 133:
/* Line 1787 of yacc.c  */
#line 513 "parser/faustparser.y"
    { (yyval.exp) = boxSeq(boxPar(boxInt(0),(yyvsp[(2) - (2)].exp)),boxPrim2(sigSub)); }
    break;

  case 134:
/* Line 1787 of yacc.c  */
#line 515 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(2) - (3)].exp); }
    break;

  case 135:
/* Line 1787 of yacc.c  */
#line 517 "parser/faustparser.y"
    { (yyval.exp) = buildBoxAbstr((yyvsp[(3) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
    break;

  case 136:
/* Line 1787 of yacc.c  */
#line 519 "parser/faustparser.y"
    { (yyval.exp) = boxCase(checkRulelist((yyvsp[(3) - (4)].exp))); }
    break;

  case 137:
/* Line 1787 of yacc.c  */
#line 521 "parser/faustparser.y"
    { (yyval.exp) = boxFFun((yyvsp[(1) - (1)].exp)); }
    break;

  case 138:
/* Line 1787 of yacc.c  */
#line 522 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 139:
/* Line 1787 of yacc.c  */
#line 523 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 140:
/* Line 1787 of yacc.c  */
#line 524 "parser/faustparser.y"
    { (yyval.exp) = boxComponent((yyvsp[(3) - (4)].exp)); }
    break;

  case 141:
/* Line 1787 of yacc.c  */
#line 525 "parser/faustparser.y"
    { (yyval.exp) = boxLibrary((yyvsp[(3) - (4)].exp)); }
    break;

  case 142:
/* Line 1787 of yacc.c  */
#line 526 "parser/faustparser.y"
    { (yyval.exp) = boxWithLocalDef(boxEnvironment(),formatDefinitions((yyvsp[(3) - (4)].exp))); }
    break;

  case 143:
/* Line 1787 of yacc.c  */
#line 527 "parser/faustparser.y"
    { (yyval.exp) = boxWaveform(gWaveForm); gWaveForm.clear(); }
    break;

  case 144:
/* Line 1787 of yacc.c  */
#line 529 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 145:
/* Line 1787 of yacc.c  */
#line 530 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 146:
/* Line 1787 of yacc.c  */
#line 531 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 147:
/* Line 1787 of yacc.c  */
#line 532 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 148:
/* Line 1787 of yacc.c  */
#line 533 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 149:
/* Line 1787 of yacc.c  */
#line 534 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 150:
/* Line 1787 of yacc.c  */
#line 535 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 151:
/* Line 1787 of yacc.c  */
#line 536 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 152:
/* Line 1787 of yacc.c  */
#line 537 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 153:
/* Line 1787 of yacc.c  */
#line 538 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 154:
/* Line 1787 of yacc.c  */
#line 540 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 155:
/* Line 1787 of yacc.c  */
#line 541 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 156:
/* Line 1787 of yacc.c  */
#line 542 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 157:
/* Line 1787 of yacc.c  */
#line 543 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 158:
/* Line 1787 of yacc.c  */
#line 545 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 159:
/* Line 1787 of yacc.c  */
#line 546 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 160:
/* Line 1787 of yacc.c  */
#line 551 "parser/faustparser.y"
    { (yyval.exp) = boxIdent(yytext); }
    break;

  case 161:
/* Line 1787 of yacc.c  */
#line 554 "parser/faustparser.y"
    { (yyval.exp) = tree(yytext); }
    break;

  case 162:
/* Line 1787 of yacc.c  */
#line 559 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); }
    break;

  case 163:
/* Line 1787 of yacc.c  */
#line 560 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); }
    break;

  case 164:
/* Line 1787 of yacc.c  */
#line 563 "parser/faustparser.y"
    { (yyval.exp) = boxSeq((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
    break;

  case 165:
/* Line 1787 of yacc.c  */
#line 564 "parser/faustparser.y"
    { (yyval.exp) = boxSplit((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
    break;

  case 166:
/* Line 1787 of yacc.c  */
#line 565 "parser/faustparser.y"
    { (yyval.exp) = boxMerge((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
    break;

  case 167:
/* Line 1787 of yacc.c  */
#line 566 "parser/faustparser.y"
    { (yyval.exp) = boxRec((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
    break;

  case 168:
/* Line 1787 of yacc.c  */
#line 567 "parser/faustparser.y"
    { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
    break;

  case 169:
/* Line 1787 of yacc.c  */
#line 570 "parser/faustparser.y"
    { (yyval.exp) = tree(yytext); }
    break;

  case 170:
/* Line 1787 of yacc.c  */
#line 573 "parser/faustparser.y"
    { (yyval.exp) = unquote(yytext); }
    break;

  case 171:
/* Line 1787 of yacc.c  */
#line 576 "parser/faustparser.y"
    { (yyval.exp) = tree(yytext); }
    break;

  case 172:
/* Line 1787 of yacc.c  */
#line 577 "parser/faustparser.y"
    { (yyval.exp) = tree(yytext); }
    break;

  case 173:
/* Line 1787 of yacc.c  */
#line 583 "parser/faustparser.y"
    { (yyval.exp) = boxIPar((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
    break;

  case 174:
/* Line 1787 of yacc.c  */
#line 587 "parser/faustparser.y"
    { (yyval.exp) = boxISeq((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
    break;

  case 175:
/* Line 1787 of yacc.c  */
#line 591 "parser/faustparser.y"
    { (yyval.exp) = boxISum((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
    break;

  case 176:
/* Line 1787 of yacc.c  */
#line 595 "parser/faustparser.y"
    { (yyval.exp) = boxIProd((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
    break;

  case 177:
/* Line 1787 of yacc.c  */
#line 599 "parser/faustparser.y"
    { (yyval.exp) = boxInputs((yyvsp[(3) - (4)].exp)); }
    break;

  case 178:
/* Line 1787 of yacc.c  */
#line 602 "parser/faustparser.y"
    { (yyval.exp) = boxOutputs((yyvsp[(3) - (4)].exp)); }
    break;

  case 179:
/* Line 1787 of yacc.c  */
#line 610 "parser/faustparser.y"
    { (yyval.exp) = ffunction((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
    break;

  case 180:
/* Line 1787 of yacc.c  */
#line 614 "parser/faustparser.y"
    { (yyval.exp) = boxFConst((yyvsp[(3) - (7)].exp),(yyvsp[(4) - (7)].exp),(yyvsp[(6) - (7)].exp)); }
    break;

  case 181:
/* Line 1787 of yacc.c  */
#line 617 "parser/faustparser.y"
    { (yyval.exp) = boxFVar((yyvsp[(3) - (7)].exp),(yyvsp[(4) - (7)].exp),(yyvsp[(6) - (7)].exp)); }
    break;

  case 182:
/* Line 1787 of yacc.c  */
#line 621 "parser/faustparser.y"
    { (yyval.exp) = boxButton((yyvsp[(3) - (4)].exp)); }
    break;

  case 183:
/* Line 1787 of yacc.c  */
#line 624 "parser/faustparser.y"
    { (yyval.exp) = boxCheckbox((yyvsp[(3) - (4)].exp)); }
    break;

  case 184:
/* Line 1787 of yacc.c  */
#line 628 "parser/faustparser.y"
    { (yyval.exp) = boxVSlider((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); }
    break;

  case 185:
/* Line 1787 of yacc.c  */
#line 631 "parser/faustparser.y"
    { (yyval.exp) = boxHSlider((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); }
    break;

  case 186:
/* Line 1787 of yacc.c  */
#line 634 "parser/faustparser.y"
    { (yyval.exp) = boxNumEntry((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); }
    break;

  case 187:
/* Line 1787 of yacc.c  */
#line 637 "parser/faustparser.y"
    { (yyval.exp) = boxVGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); }
    break;

  case 188:
/* Line 1787 of yacc.c  */
#line 640 "parser/faustparser.y"
    { (yyval.exp) = boxHGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); }
    break;

  case 189:
/* Line 1787 of yacc.c  */
#line 643 "parser/faustparser.y"
    { (yyval.exp) = boxTGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); }
    break;

  case 190:
/* Line 1787 of yacc.c  */
#line 647 "parser/faustparser.y"
    { (yyval.exp) = boxVBargraph((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
    break;

  case 191:
/* Line 1787 of yacc.c  */
#line 650 "parser/faustparser.y"
    { (yyval.exp) = boxHBargraph((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
    break;

  case 192:
/* Line 1787 of yacc.c  */
#line 656 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (5)].exp), cons(cons((yyvsp[(2) - (5)].exp),cons((yyvsp[(2) - (5)].exp),cons((yyvsp[(2) - (5)].exp),nil))), (yyvsp[(4) - (5)].exp))); }
    break;

  case 193:
/* Line 1787 of yacc.c  */
#line 657 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (7)].exp), cons(cons((yyvsp[(2) - (7)].exp),cons((yyvsp[(4) - (7)].exp),cons((yyvsp[(4) - (7)].exp),nil))), (yyvsp[(6) - (7)].exp))); }
    break;

  case 194:
/* Line 1787 of yacc.c  */
#line 658 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (9)].exp), cons(cons((yyvsp[(2) - (9)].exp),cons((yyvsp[(4) - (9)].exp),cons((yyvsp[(6) - (9)].exp),nil))), (yyvsp[(8) - (9)].exp))); }
    break;

  case 195:
/* Line 1787 of yacc.c  */
#line 660 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (4)].exp), cons(cons((yyvsp[(2) - (4)].exp),cons((yyvsp[(2) - (4)].exp),cons((yyvsp[(2) - (4)].exp),nil))), nil)); }
    break;

  case 196:
/* Line 1787 of yacc.c  */
#line 661 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (6)].exp), cons(cons((yyvsp[(2) - (6)].exp),cons((yyvsp[(4) - (6)].exp),cons((yyvsp[(4) - (6)].exp),nil))), nil)); }
    break;

  case 197:
/* Line 1787 of yacc.c  */
#line 662 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (8)].exp), cons(cons((yyvsp[(2) - (8)].exp),cons((yyvsp[(4) - (8)].exp),cons((yyvsp[(6) - (8)].exp),nil))), nil)); }
    break;

  case 198:
/* Line 1787 of yacc.c  */
#line 665 "parser/faustparser.y"
    { (yyval.exp) = tree(yytext); }
    break;

  case 199:
/* Line 1787 of yacc.c  */
#line 668 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); }
    break;

  case 200:
/* Line 1787 of yacc.c  */
#line 669 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); }
    break;

  case 201:
/* Line 1787 of yacc.c  */
#line 672 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); }
    break;

  case 202:
/* Line 1787 of yacc.c  */
#line 673 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); }
    break;

  case 203:
/* Line 1787 of yacc.c  */
#line 677 "parser/faustparser.y"
    { (yyval.exp) = cons((yyvsp[(2) - (6)].exp),(yyvsp[(5) - (6)].exp)); }
    break;

  case 204:
/* Line 1787 of yacc.c  */
#line 680 "parser/faustparser.y"
    { (yyval.exp) = tree(0); }
    break;

  case 205:
/* Line 1787 of yacc.c  */
#line 681 "parser/faustparser.y"
    { (yyval.exp) = tree(1); }
    break;


/* Line 1787 of yacc.c  */
#line 3212 "parser/faustparser.cpp"
      default: break;
    }
  /* User semantic actions sometimes alter yychar, and that requires
     that yytoken be updated with the new translation.  We take the
     approach of translating immediately before every use of yytoken.
     One alternative is translating here after every semantic action,
     but that translation would be missed if the semantic action invokes
     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
     incorrect destructor might then be invoked immediately.  In the
     case of YYERROR or YYBACKUP, subsequent parser actions might lead
     to an incorrect destructor call or verbose syntax error message
     before the lookahead is translated.  */
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);

  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);

  *++yyvsp = yyval;

  /* Now `shift' the result of the reduction.  Determine what state
     that goes to, based on the state we popped back to and the rule
     number reduced by.  */

  yyn = yyr1[yyn];

  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    yystate = yytable[yystate];
  else
    yystate = yydefgoto[yyn - YYNTOKENS];

  goto yynewstate;


/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
yyerrlab:
  /* Make sure we have latest lookahead translation.  See comments at
     user semantic actions for why this is necessary.  */
  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);

  /* If not already recovering from an error, report this error.  */
  if (!yyerrstatus)
    {
      ++yynerrs;
#if ! YYERROR_VERBOSE
      yyerror (YY_("syntax error"));
#else
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
                                        yyssp, yytoken)
      {
        char const *yymsgp = YY_("syntax error");
        int yysyntax_error_status;
        yysyntax_error_status = YYSYNTAX_ERROR;
        if (yysyntax_error_status == 0)
          yymsgp = yymsg;
        else if (yysyntax_error_status == 1)
          {
            if (yymsg != yymsgbuf)
              YYSTACK_FREE (yymsg);
            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
            if (!yymsg)
              {
                yymsg = yymsgbuf;
                yymsg_alloc = sizeof yymsgbuf;
                yysyntax_error_status = 2;
              }
            else
              {
                yysyntax_error_status = YYSYNTAX_ERROR;
                yymsgp = yymsg;
              }
          }
        yyerror (yymsgp);
        if (yysyntax_error_status == 2)
          goto yyexhaustedlab;
      }
# undef YYSYNTAX_ERROR
#endif
    }



  if (yyerrstatus == 3)
    {
      /* If just tried and failed to reuse lookahead token after an
     error, discard it.  */

      if (yychar <= YYEOF)
    {
      /* Return failure if at end of input.  */
      if (yychar == YYEOF)
        YYABORT;
    }
      else
    {
      yydestruct ("Error: discarding",
              yytoken, &yylval);
      yychar = YYEMPTY;
    }
    }

  /* Else will try to reuse lookahead token after shifting the error
     token.  */
  goto yyerrlab1;


/*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR.  |
`---------------------------------------------------*/
yyerrorlab:

  /* Pacify compilers like GCC when the user code never invokes
     YYERROR and the label yyerrorlab therefore never appears in user
     code.  */
  if (/*CONSTCOND*/ 0)
     goto yyerrorlab;

  /* Do not reclaim the symbols of the rule which action triggered
     this YYERROR.  */
  YYPOPSTACK (yylen);
  yylen = 0;
  YY_STACK_PRINT (yyss, yyssp);
  yystate = *yyssp;
  goto yyerrlab1;


/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR.  |
`-------------------------------------------------------------*/
yyerrlab1:
  yyerrstatus = 3;  /* Each real token shifted decrements this.  */

  for (;;)
    {
      yyn = yypact[yystate];
      if (!yypact_value_is_default (yyn))
    {
      yyn += YYTERROR;
      if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
        {
          yyn = yytable[yyn];
          if (0 < yyn)
        break;
        }
    }

      /* Pop the current state because it cannot handle the error token.  */
      if (yyssp == yyss)
    YYABORT;


      yydestruct ("Error: popping",
          yystos[yystate], yyvsp);
      YYPOPSTACK (1);
      yystate = *yyssp;
      YY_STACK_PRINT (yyss, yyssp);
    }

  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
  *++yyvsp = yylval;
  YY_IGNORE_MAYBE_UNINITIALIZED_END


  /* Shift the error token.  */
  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);

  yystate = yyn;
  goto yynewstate;


/*-------------------------------------.
| yyacceptlab -- YYACCEPT comes here.  |
`-------------------------------------*/
yyacceptlab:
  yyresult = 0;
  goto yyreturn;

/*-----------------------------------.
| yyabortlab -- YYABORT comes here.  |
`-----------------------------------*/
yyabortlab:
  yyresult = 1;
  goto yyreturn;

#if !defined yyoverflow || YYERROR_VERBOSE
/*-------------------------------------------------.
| yyexhaustedlab -- memory exhaustion comes here.  |
`-------------------------------------------------*/
yyexhaustedlab:
  yyerror (YY_("memory exhausted"));
  yyresult = 2;
  /* Fall through.  */
#endif

yyreturn:
  if (yychar != YYEMPTY)
    {
      /* Make sure we have latest lookahead translation.  See comments at
         user semantic actions for why this is necessary.  */
      yytoken = YYTRANSLATE (yychar);
      yydestruct ("Cleanup: discarding lookahead",
                  yytoken, &yylval);
    }
  /* Do not reclaim the symbols of the rule which action triggered
     this YYABORT or YYACCEPT.  */
  YYPOPSTACK (yylen);
  YY_STACK_PRINT (yyss, yyssp);
  while (yyssp != yyss)
    {
      yydestruct ("Cleanup: popping",
          yystos[*yyssp], yyvsp);
      YYPOPSTACK (1);
    }
#ifndef yyoverflow
  if (yyss != yyssa)
    YYSTACK_FREE (yyss);
#endif
#if YYERROR_VERBOSE
  if (yymsg != yymsgbuf)
    YYSTACK_FREE (yymsg);
#endif
  /* Make sure YYID is used.  */
  return YYID (yyresult);
}

Here is the caller graph for this function:

static char* yystpcpy ( yydest  , yysrc    )

static

Referenced by yytnamerr().

Here is the caller graph for this function:

static YYSIZE_T yystrlen ( yystr  ) const

static

Referenced by yysyntax_error(), and yytnamerr().

Here is the caller graph for this function:

static int yysyntax_error ( YYSIZE_T *  yymsg_alloc, char **  yymsg, yytype_int16 *  yyssp, int  yytoken  )

static

Definition at line 1548 of file faustparser.cpp.

References YY_, YY_NULL, YYCASE_, yycheck, YYEMPTY, YYLAST, YYNTOKENS, yypact, yypact_value_is_default, YYSIZE_T, YYSTACK_ALLOC_MAXIMUM, yystrlen(), yytable, yytable_value_is_error, YYTERROR, yytname, and yytnamerr().

{
  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
  YYSIZE_T yysize = yysize0;
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
  /* Internationalized format string. */
  const char *yyformat = YY_NULL;
  /* Arguments of yyformat. */
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
  /* Number of reported tokens (one for the "unexpected", one per
     "expected"). */
  int yycount = 0;

  /* There are many possibilities here to consider:
     - Assume YYFAIL is not used.  It's too flawed to consider.  See
       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
       for details.  YYERROR is fine as it does not invoke this
       function.
     - If this state is a consistent state with a default action, then
       the only way this function was invoked is if the default action
       is an error action.  In that case, don't check for expected
       tokens because there are none.
     - The only way there can be no lookahead present (in yychar) is if
       this state is a consistent state with a default action.  Thus,
       detecting the absence of a lookahead is sufficient to determine
       that there is no unexpected or expected token to report.  In that
       case, just report a simple "syntax error".
     - Don't assume there isn't a lookahead just because this state is a
       consistent state with a default action.  There might have been a
       previous inconsistent state, consistent state with a non-default
       action, or user semantic action that manipulated yychar.
     - Of course, the expected token list depends on states to have
       correct lookahead information, and it depends on the parser not
       to perform extra reductions after fetching a lookahead from the
       scanner and before detecting a syntax error.  Thus, state merging
       (from LALR or IELR) and default reductions corrupt the expected
       token list.  However, the list is correct for canonical LR with
       one exception: it will still contain any token that will not be
       accepted due to an error action in a later state.
  */
  if (yytoken != YYEMPTY)
    {
      int yyn = yypact[*yyssp];
      yyarg[yycount++] = yytname[yytoken];
      if (!yypact_value_is_default (yyn))
        {
          /* Start YYX at -YYN if negative to avoid negative indexes in
             YYCHECK.  In other words, skip the first -YYN actions for
             this state because they are default actions.  */
          int yyxbegin = yyn < 0 ? -yyn : 0;
          /* Stay within bounds of both yycheck and yytname.  */
          int yychecklim = YYLAST - yyn + 1;
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
          int yyx;

          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
                && !yytable_value_is_error (yytable[yyx + yyn]))
              {
                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
                  {
                    yycount = 1;
                    yysize = yysize0;
                    break;
                  }
                yyarg[yycount++] = yytname[yyx];
                {
                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
                  if (! (yysize <= yysize1
                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
                    return 2;
                  yysize = yysize1;
                }
              }
        }
    }

  switch (yycount)
    {
# define YYCASE_(N, S)                      \
      case N:                               \
        yyformat = S;                       \
      break
      YYCASE_(0, YY_("syntax error"));
      YYCASE_(1, YY_("syntax error, unexpected %s"));
      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
# undef YYCASE_
    }

  {
    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
      return 2;
    yysize = yysize1;
  }

  if (*yymsg_alloc < yysize)
    {
      *yymsg_alloc = 2 * yysize;
      if (! (yysize <= *yymsg_alloc
             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
      return 1;
    }

  /* Avoid sprintf, as that infringes on the user's name space.
     Don't have undefined behavior even if the translation
     produced a string with the wrong number of "%s"s.  */
  {
    char *yyp = *yymsg;
    int yyi = 0;
    while ((*yyp = *yyformat) != '\0')
      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
        {
          yyp += yytnamerr (yyp, yyarg[yyi++]);
          yyformat += 2;
        }
      else
        {
          yyp++;
          yyformat++;
        }
  }
  return 0;
}

Here is the call graph for this function:

static YYSIZE_T yytnamerr ( char *  yyres, const char *  yystr  )

static

Definition at line 1500 of file faustparser.cpp.

References YYSIZE_T, yystpcpy(), and yystrlen().

Referenced by yysyntax_error().

{
  if (*yystr == '"')
    {
      YYSIZE_T yyn = 0;
      char const *yyp = yystr;

      for (;;)
    switch (*++yyp)
      {
      case '\'':
      case ',':
        goto do_not_strip_quotes;

      case '\\':
        if (*++yyp != '\\')
          goto do_not_strip_quotes;
        /* Fall through.  */
      default:
        if (yyres)
          yyres[yyn] = *yyp;
        yyn++;
        break;

      case '"':
        if (yyres)
          yyres[yyn] = '\0';
        return yyn;
      }
    do_not_strip_quotes: ;
    }

  if (! yyres)
    return yystrlen (yystr);

  return yystpcpy (yyres, yystr) - yyres;
}

Here is the call graph for this function:

Here is the caller graph for this function:

YYUSE

(

yyo

)

YYUSE

(

yyoutput

)

YYUSE

(

yytype

)

Variable Documentation

vector<Tree> gDocVector

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

Definition at line 109 of file doc.cpp.

bool gLstDependenciesSwitch

mdoc listing management.

Definition at line 113 of file doc.cpp.

Referenced by printfaustlistings(), and yyparse().

bool gLstDistributedSwitch

mdoc listing management.

Definition at line 115 of file doc.cpp.

Referenced by printdoccontent(), and yyparse().

bool gLstMdocTagsSwitch

mdoc listing management.

Definition at line 114 of file doc.cpp.

map<Tree, set<Tree> > gMetaDataSet

Definition at line 91 of file main.cpp.

Tree gResult

Definition at line 86 of file main.cpp.

Referenced by yyparse().

bool gStripDocSwitch

Definition at line 124 of file main.cpp.

Referenced by process_cmdline(), and yyparse().

tvec gWaveForm

Definition at line 94 of file main.cpp.

Referenced by yyparse().

int yychar

Definition at line 1709 of file faustparser.cpp.

Referenced by yyparse().

const yytype_int16 yycheck[]

static

Definition at line 1076 of file faustparser.cpp.

Referenced by yyparse(), and yysyntax_error().

return yyd

Definition at line 1486 of file faustparser.cpp.

int yydebug

Definition at line 1412 of file faustparser.cpp.

const yytype_uint8 yydefact[]

static

Definition at line 873 of file faustparser.cpp.

Referenced by yyparse().

const yytype_int16 yydefgoto[]

static

Initial value:

=
{
      -1,     1,     2,   243,   248,   249,     9,    17,    30,    31,
      32,    33,    34,    35,   144,   220,   365,    36,   315,    11,
     238,   138,   114,   115,   116,    16,   117,   118,    23,    21,
     340,   119,   120,   121,   122,   123,   124,   125,   126,   127,
     128,   129,   130,   131,   132,   133,   134,   135,   136,   137,
     224,   297,   371,   257,   258,   372
}

Definition at line 923 of file faustparser.cpp.

Referenced by yyparse().

int yyerr

Definition at line 83 of file main.cpp.

Referenced by yyparse().

const char* yyfilename

Definition at line 30 of file errormsg.cpp.

Referenced by yyparse().

int yyi

Initial value:

{
  int yynrhs = yyr2[yyrule]

Definition at line 1387 of file faustparser.cpp.

return yylen

Definition at line 1458 of file faustparser.cpp.

Referenced by yyparse().

int yylineno

Referenced by yyparse().

unsigned long int yylno = yyrline[yyrule]

Definition at line 1390 of file faustparser.cpp.

YYSTYPE yylval

Referenced by yyparse().

int yynerrs

Definition at line 1724 of file faustparser.cpp.

Referenced by yyparse().

const yytype_int16 yypact[]

static

Definition at line 936 of file faustparser.cpp.

Referenced by yyparse(), and yysyntax_error().

const yytype_int16 yypgoto[]

static

Initial value:

=
{
    -319,  -319,  -319,  -174,  -319,   330,  -319,  -319,  -319,  -319,
    -319,  -319,  -319,  -319,  -319,  -319,   -52,  -319,   652,  -319,
    -319,     2,   -19,  -319,    22,   -23,  -133,  -123,   287,   405,
       7,  -319,  -319,  -319,  -319,  -319,  -319,  -319,  -319,  -319,
    -319,  -319,  -319,  -319,  -319,  -319,  -319,  -319,  -319,  -319,
    -319,  -268,  -318,  -319,   400,  -151
}

Definition at line 986 of file faustparser.cpp.

Referenced by yyparse().

const yytype_uint16 yyprhs[]

static

Initial value:

=
{
       0,     0,     3,     5,     6,     9,    10,    13,    15,    19,
      21,    23,    26,    29,    32,    35,    41,    46,    48,    52,
      53,    56,    58,    60,    62,    64,    66,    68,    69,    72,
      76,    80,    82,    86,    87,    90,    96,   102,   108,   110,
     112,   116,   124,   129,   132,   134,   136,   140,   146,   150,
     154,   158,   162,   166,   168,   172,   176,   180,   184,   188,
     192,   196,   199,   203,   207,   211,   215,   219,   223,   227,
     231,   235,   239,   243,   247,   252,   257,   259,   261,   263,
     266,   269,   272,   275,   277,   279,   281,   283,   285,   287,
     289,   291,   293,   295,   297,   299,   301,   303,   305,   307,
     309,   311,   313,   315,   317,   319,   321,   323,   325,   327,
     329,   331,   333,   335,   337,   339,   341,   343,   345,   347,
     349,   351,   353,   355,   357,   359,   361,   363,   365,   367,
     369,   371,   373,   375,   378,   382,   391,   396,   398,   400,
     402,   407,   412,   417,   422,   424,   426,   428,   430,   432,
     434,   436,   438,   440,   442,   444,   446,   448,   450,   452,
     454,   456,   458,   460,   464,   468,   472,   476,   480,   482,
     484,   486,   488,   490,   499,   508,   517,   526,   531,   536,
     545,   553,   561,   566,   571,   584,   597,   610,   617,   624,
     631,   640,   649,   655,   663,   673,   678,   685,   694,   696,
     698,   702,   704,   707,   714,   716
}

Definition at line 634 of file faustparser.cpp.

Referenced by for().

const yytype_uint8 yyr1[]

static

Initial value:

=
{
       0,   124,   125,   126,   126,   127,   127,   128,   128,   129,
     129,   129,   129,   129,   129,   130,   130,   130,   130,   131,
     131,   132,   132,   132,   132,   132,   132,   133,   133,   134,
     135,   136,   137,   138,   138,   139,   139,   139,   140,   140,
     141,   142,   142,   142,   143,   144,   144,   145,   145,   145,
     145,   145,   145,   145,   146,   146,   146,   146,   146,   146,
     146,   146,   146,   146,   146,   146,   146,   146,   146,   146,
     146,   146,   146,   146,   146,   146,   146,   147,   147,   147,
     147,   147,   147,   147,   147,   147,   147,   147,   147,   147,
     147,   147,   147,   147,   147,   147,   147,   147,   147,   147,
     147,   147,   147,   147,   147,   147,   147,   147,   147,   147,
     147,   147,   147,   147,   147,   147,   147,   147,   147,   147,
     147,   147,   147,   147,   147,   147,   147,   147,   147,   147,
     147,   147,   147,   147,   147,   147,   147,   147,   147,   147,
     147,   147,   147,   147,   147,   147,   147,   147,   147,   147,
     147,   147,   147,   147,   147,   147,   147,   147,   147,   147,
     148,   149,   150,   150,   151,   151,   151,   151,   151,   152,
     153,   154,   154,   155,   156,   157,   158,   159,   160,   161,
     162,   163,   164,   165,   166,   167,   168,   169,   170,   171,
     172,   173,   174,   174,   174,   174,   174,   174,   175,   176,
     176,   177,   177,   178,   179,   179
}

Definition at line 819 of file faustparser.cpp.

Referenced by yyparse().

const yytype_uint8 yyr2[]

static

Initial value:

=
{
       0,     2,     1,     0,     2,     0,     2,     1,     3,     1,
       1,     2,     2,     2,     2,     5,     4,     1,     3,     0,
       2,     1,     1,     1,     1,     1,     1,     0,     2,     3,
       3,     1,     3,     0,     2,     5,     5,     5,     1,     1,
       3,     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,     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,     4,     1,     1,     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,     4,     4,     8,
       7,     7,     4,     4,    12,    12,    12,     6,     6,     6,
       8,     8,     5,     7,     9,     4,     6,     8,     1,     1,
       3,     1,     2,     6,     1,     1
}

Definition at line 845 of file faustparser.cpp.

Referenced by yyparse().

const yytype_int16 yyrhs[]

static

Definition at line 660 of file faustparser.cpp.

Referenced by for().

const yytype_uint16 yyrline[]

static

Initial value:

=
{
       0,   310,   310,   313,   314,   316,   317,   324,   325,   328,
     329,   330,   331,   332,   333,   337,   338,   339,   340,   343,
     344,   347,   348,   349,   350,   351,   352,   355,   356,   359,
     362,   365,   368,   371,   372,   375,   376,   377,   380,   381,
     384,   387,   388,   389,   392,   395,   396,   399,   400,   401,
     402,   403,   404,   405,   408,   409,   410,   411,   412,   413,
     414,   415,   416,   418,   419,   420,   422,   423,   425,   426,
     427,   428,   429,   430,   432,   433,   435,   438,   439,   441,
     442,   444,   445,   447,   448,   450,   451,   453,   454,   456,
     457,   458,   459,   460,   461,   463,   464,   465,   467,   468,
     470,   471,   472,   473,   474,   475,   477,   479,   480,   481,
     482,   483,   484,   485,   487,   488,   489,   490,   491,   492,
     494,   495,   496,   498,   499,   501,   502,   503,   506,   507,
     509,   510,   512,   513,   515,   516,   519,   521,   522,   523,
     524,   525,   526,   527,   529,   530,   531,   532,   533,   534,
     535,   536,   537,   538,   540,   541,   542,   543,   545,   546,
     551,   554,   559,   560,   563,   564,   565,   566,   567,   570,
     573,   576,   577,   582,   586,   590,   594,   599,   602,   609,
     613,   616,   621,   624,   627,   630,   633,   636,   639,   642,
     646,   649,   656,   657,   658,   660,   661,   662,   665,   668,
     669,   672,   673,   676,   680,   681
}

Definition at line 737 of file faustparser.cpp.

int yyrule

Definition at line 1385 of file faustparser.cpp.

const char* yys = yysrc

Definition at line 1481 of file faustparser.cpp.

const char* yysrc

Definition at line 1477 of file faustparser.cpp.

const yytype_uint8 yystos[]

static

Definition at line 1148 of file faustparser.cpp.

Referenced by yyparse().

const yytype_int16 yytable[]

static

Definition at line 1000 of file faustparser.cpp.

Referenced by yyparse(), and yysyntax_error().

char* yytext

Referenced by yyparse().

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", "LCROC", "RCROC", "DEF", "IMPORT",
  "COMPONENT", "LIBRARY", "ENVIRONMENT", "WAVEFORM", "IPAR", "ISEQ",
  "ISUM", "IPROD", "INPUTS", "OUTPUTS", "STRING", "FSTRING", "IDENT",
  "EXTRA", "DECLARE", "CASE", "ARROW", "BDOC", "EDOC", "BEQN", "EEQN",
  "BDGM", "EDGM", "BLST", "ELST", "BMETADATA", "EMETADATA", "DOCCHAR",
  "NOTICE", "LISTING", "LSTTRUE", "LSTFALSE", "LSTDEPENDENCIES",
  "LSTMDOCTAGS", "LSTDISTRIBUTED", "LSTEQ", "LSTQ", "$accept", "program",
  "stmtlist", "deflist", "vallist", "number", "statement", "doc",
  "docelem", "doctxt", "doceqn", "docdgm", "docntc", "doclst",
  "lstattrlist", "lstattrdef", "lstattrval", "docmtd", "definition",
  "defname", "params", "expression", "infixexp", "primitive", "ident",
  "name", "arglist", "argument", "string", "uqstring", "fstring", "fpar",
  "fseq", "fsum", "fprod", "finputs", "foutputs", "ffunction", "fconst",
  "fvariable", "button", "checkbox", "vslider", "hslider", "nentry",
  "vgroup", "hgroup", "tgroup", "vbargraph", "hbargraph", "signature",
  "fun", "typelist", "rulelist", "rule", "type", YY_NULL
}

Definition at line 766 of file faustparser.cpp.

Referenced by yysyntax_error().

yytype_int16* yytop

Definition at line 1354 of file faustparser.cpp.

const yytype_uint8 yytranslate[]

static

Definition at line 589 of file faustparser.cpp.

int yytype

Definition at line 1298 of file faustparser.cpp.

YYSTYPE * yyvaluep

Definition at line 1299 of file faustparser.cpp.