FAUST compiler  0.9.9.6b8
faustparser.cpp
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 2.7.12-4996. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
6 
7  This program is free software: you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation, either version 3 of the License, or
10  (at your option) any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 
20 /* As a special exception, you may create a larger work that contains
21  part or all of the Bison parser skeleton and distribute that work
22  under terms of your choice, so long as that work isn't itself a
23  parser generator using the skeleton or a modified version thereof
24  as a parser skeleton. Alternatively, if you modify or redistribute
25  the parser skeleton itself, you may (at your option) remove this
26  special exception, which will cause the skeleton and the resulting
27  Bison output files to be licensed under the GNU General Public
28  License without this special exception.
29 
30  This special exception was added by the Free Software Foundation in
31  version 2.2 of Bison. */
32 
33 /* C LALR(1) parser skeleton written by Richard Stallman, by
34  simplifying the original so-called "semantic" parser. */
35 
36 /* All symbols defined below should begin with yy or YY, to avoid
37  infringing on user name space. This should be done even for local
38  variables, as they might otherwise be expanded by user macros.
39  There are some unavoidable exceptions within include files to
40  define necessary library symbols; they are noted "INFRINGES ON
41  USER NAME SPACE" below. */
42 
43 /* Identify Bison output. */
44 #define YYBISON 1
45 
46 /* Bison version. */
47 #define YYBISON_VERSION "2.7.12-4996"
48 
49 /* Skeleton name. */
50 #define YYSKELETON_NAME "yacc.c"
51 
52 /* Pure parsers. */
53 #define YYPURE 0
54 
55 /* Push parsers. */
56 #define YYPUSH 0
57 
58 /* Pull parsers. */
59 #define YYPULL 1
60 
61 
62 
63 
64 /* Copy the first part of user declarations. */
65 /* Line 371 of yacc.c */
66 #line 5 "parser/faustparser.y"
67 
68 
69 #include "tree.hh"
70 #include "xtended.hh"
71 #include "boxes.hh"
72 #include "prim2.hh"
73 #include "signals.hh"
74 #include "errormsg.hh"
75 #include "sourcereader.hh"
76 #include "doc.hh"
77 #include "ppbox.hh"
78 
79 #include <string>
80 #include <list>
81 
82 #define YYDEBUG 1
83 #define YYERROR_VERBOSE 1
84 #define YYMAXDEPTH 100000
85 
86 using namespace std;
87 
88 extern char* yytext;
89 extern const char* yyfilename;
90 extern int yylineno;
91 extern int yyerr;
92 extern Tree gResult;
93 extern bool gStripDocSwitch;
94 extern bool gLstDependenciesSwitch;
95 extern bool gLstDistributedSwitch;
96 extern bool gLstMdocTagsSwitch;
97 
98 extern map<Tree, set<Tree> > gMetaDataSet;
99 extern vector<Tree> gDocVector;
100 extern tvec gWaveForm;
101 
102 int yylex();
103 
104 //----------------------------------------------------------
105 // unquote() : remove enclosing quotes and carriage return
106 // characters from string. Returns a Tree
107 //----------------------------------------------------------
108 char replaceCR(char c)
109 {
110  return (c!='\n') ? c : ' ';
111 }
112 
113 Tree unquote(char* str)
114 {
115  //-----------copy unquoted filename-------------
116  char buf[512];
117  int j=0;
118 
119  if (str[0] == '"') {
120  //it is a quoted string, we remove the quotes
121  for (int i=1; j<511 && str[i];) {
122  buf[j++] = replaceCR(str[i++]);
123  }
124  // remove last quote
125  if (j>0) buf[j-1] = 0;
126  } else {
127  for (int i=0; j<511 && str[i];) {
128  buf[j++] = replaceCR(str[i++]);
129  }
130  }
131  buf[j] = 0;
132 
133  return tree(buf);
134  //----------------------------------------------
135 }
136 
137 
138 /* Line 371 of yacc.c */
139 #line 140 "parser/faustparser.cpp"
140 
141 # ifndef YY_NULL
142 # if defined __cplusplus && 201103L <= __cplusplus
143 # define YY_NULL nullptr
144 # else
145 # define YY_NULL 0
146 # endif
147 # endif
148 
149 /* Enabling verbose error messages. */
150 #ifdef YYERROR_VERBOSE
151 # undef YYERROR_VERBOSE
152 # define YYERROR_VERBOSE 1
153 #else
154 # define YYERROR_VERBOSE 0
155 #endif
156 
157 /* In a future release of Bison, this section will be replaced
158  by #include "faustparser.hpp". */
159 #ifndef YY_YY_PARSER_FAUSTPARSER_HPP_INCLUDED
160 # define YY_YY_PARSER_FAUSTPARSER_HPP_INCLUDED
161 /* Enabling traces. */
162 #ifndef YYDEBUG
163 # define YYDEBUG 0
164 #endif
165 #if YYDEBUG
166 extern int yydebug;
167 #endif
168 
169 /* Tokens. */
170 #ifndef YYTOKENTYPE
171 # define YYTOKENTYPE
172  /* Put the tokens into the symbol table, so that GDB and other debuggers
173  know about them. */
174  enum yytokentype {
175  WITH = 258,
176  MIX = 259,
177  SPLIT = 260,
178  SEQ = 261,
179  PAR = 262,
180  REC = 263,
181  NE = 264,
182  GE = 265,
183  GT = 266,
184  EQ = 267,
185  LE = 268,
186  LT = 269,
187  OR = 270,
188  SUB = 271,
189  ADD = 272,
190  RSH = 273,
191  LSH = 274,
192  XOR = 275,
193  AND = 276,
194  MOD = 277,
195  DIV = 278,
196  MUL = 279,
197  POWOP = 280,
198  FDELAY = 281,
199  DELAY1 = 282,
200  DOT = 283,
201  APPL = 284,
202  MEM = 285,
203  PREFIX = 286,
204  INTCAST = 287,
205  FLOATCAST = 288,
206  FFUNCTION = 289,
207  FCONSTANT = 290,
208  FVARIABLE = 291,
209  BUTTON = 292,
210  CHECKBOX = 293,
211  VSLIDER = 294,
212  HSLIDER = 295,
213  NENTRY = 296,
214  VGROUP = 297,
215  HGROUP = 298,
216  TGROUP = 299,
217  HBARGRAPH = 300,
218  VBARGRAPH = 301,
219  ATTACH = 302,
220  ACOS = 303,
221  ASIN = 304,
222  ATAN = 305,
223  ATAN2 = 306,
224  COS = 307,
225  SIN = 308,
226  TAN = 309,
227  EXP = 310,
228  LOG = 311,
229  LOG10 = 312,
230  POWFUN = 313,
231  SQRT = 314,
232  ABS = 315,
233  MIN = 316,
234  MAX = 317,
235  FMOD = 318,
236  REMAINDER = 319,
237  FLOOR = 320,
238  CEIL = 321,
239  RINT = 322,
240  RDTBL = 323,
241  RWTBL = 324,
242  SELECT2 = 325,
243  SELECT3 = 326,
244  INT = 327,
245  FLOAT = 328,
246  LAMBDA = 329,
247  WIRE = 330,
248  CUT = 331,
249  ENDDEF = 332,
250  VIRG = 333,
251  LPAR = 334,
252  RPAR = 335,
253  LBRAQ = 336,
254  RBRAQ = 337,
255  LCROC = 338,
256  RCROC = 339,
257  DEF = 340,
258  IMPORT = 341,
259  COMPONENT = 342,
260  LIBRARY = 343,
261  ENVIRONMENT = 344,
262  WAVEFORM = 345,
263  IPAR = 346,
264  ISEQ = 347,
265  ISUM = 348,
266  IPROD = 349,
267  INPUTS = 350,
268  OUTPUTS = 351,
269  STRING = 352,
270  FSTRING = 353,
271  IDENT = 354,
272  EXTRA = 355,
273  DECLARE = 356,
274  CASE = 357,
275  ARROW = 358,
276  BDOC = 359,
277  EDOC = 360,
278  BEQN = 361,
279  EEQN = 362,
280  BDGM = 363,
281  EDGM = 364,
282  BLST = 365,
283  ELST = 366,
284  BMETADATA = 367,
285  EMETADATA = 368,
286  DOCCHAR = 369,
287  NOTICE = 370,
288  LISTING = 371,
289  LSTTRUE = 372,
290  LSTFALSE = 373,
291  LSTDEPENDENCIES = 374,
292  LSTMDOCTAGS = 375,
293  LSTDISTRIBUTED = 376,
294  LSTEQ = 377,
295  LSTQ = 378
296  };
297 #endif
298 
299 
300 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
301 typedef union YYSTYPE
302 {
303 /* Line 387 of yacc.c */
304 #line 78 "parser/faustparser.y"
305 
306  CTree* exp;
307  char* str;
308  string* cppstr;
309  bool b;
310 
311 
312 /* Line 387 of yacc.c */
313 #line 314 "parser/faustparser.cpp"
314 } YYSTYPE;
315 # define YYSTYPE_IS_TRIVIAL 1
316 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
317 # define YYSTYPE_IS_DECLARED 1
318 #endif
319 
320 extern YYSTYPE yylval;
321 
322 #ifdef YYPARSE_PARAM
323 #if defined __STDC__ || defined __cplusplus
324 int yyparse (void *YYPARSE_PARAM);
325 #else
326 int yyparse ();
327 #endif
328 #else /* ! YYPARSE_PARAM */
329 #if defined __STDC__ || defined __cplusplus
330 int yyparse (void);
331 #else
332 int yyparse ();
333 #endif
334 #endif /* ! YYPARSE_PARAM */
335 
336 #endif /* !YY_YY_PARSER_FAUSTPARSER_HPP_INCLUDED */
337 
338 /* Copy the second part of user declarations. */
339 
340 /* Line 390 of yacc.c */
341 #line 342 "parser/faustparser.cpp"
342 
343 #ifdef short
344 # undef short
345 #endif
346 
347 #ifdef YYTYPE_UINT8
348 typedef YYTYPE_UINT8 yytype_uint8;
349 #else
350 typedef unsigned char yytype_uint8;
351 #endif
352 
353 #ifdef YYTYPE_INT8
354 typedef YYTYPE_INT8 yytype_int8;
355 #elif (defined __STDC__ || defined __C99__FUNC__ \
356  || defined __cplusplus || defined _MSC_VER)
357 typedef signed char yytype_int8;
358 #else
359 typedef short int yytype_int8;
360 #endif
361 
362 #ifdef YYTYPE_UINT16
363 typedef YYTYPE_UINT16 yytype_uint16;
364 #else
365 typedef unsigned short int yytype_uint16;
366 #endif
367 
368 #ifdef YYTYPE_INT16
369 typedef YYTYPE_INT16 yytype_int16;
370 #else
371 typedef short int yytype_int16;
372 #endif
373 
374 #ifndef YYSIZE_T
375 # ifdef __SIZE_TYPE__
376 # define YYSIZE_T __SIZE_TYPE__
377 # elif defined size_t
378 # define YYSIZE_T size_t
379 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
380  || defined __cplusplus || defined _MSC_VER)
381 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
382 # define YYSIZE_T size_t
383 # else
384 # define YYSIZE_T unsigned int
385 # endif
386 #endif
387 
388 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
389 
390 #ifndef YY_
391 # if defined YYENABLE_NLS && YYENABLE_NLS
392 # if ENABLE_NLS
393 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
394 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
395 # endif
396 # endif
397 # ifndef YY_
398 # define YY_(Msgid) Msgid
399 # endif
400 #endif
401 
402 #ifndef __attribute__
403 /* This feature is available in gcc versions 2.5 and later. */
404 # if (! defined __GNUC__ || __GNUC__ < 2 \
405  || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
406 # define __attribute__(Spec) /* empty */
407 # endif
408 #endif
409 
410 /* Suppress unused-variable warnings by "using" E. */
411 #if ! defined lint || defined __GNUC__
412 # define YYUSE(E) ((void) (E))
413 #else
414 # define YYUSE(E) /* empty */
415 #endif
416 
417 
418 /* Identity function, used to suppress warnings about constant conditions. */
419 #ifndef lint
420 # define YYID(N) (N)
421 #else
422 #if (defined __STDC__ || defined __C99__FUNC__ \
423  || defined __cplusplus || defined _MSC_VER)
424 static int
425 YYID (int yyi)
426 #else
427 static int
428 YYID (yyi)
429  int yyi;
430 #endif
431 {
432  return yyi;
433 }
434 #endif
435 
436 #if ! defined yyoverflow || YYERROR_VERBOSE
437 
438 /* The parser invokes alloca or malloc; define the necessary symbols. */
439 
440 # ifdef YYSTACK_USE_ALLOCA
441 # if YYSTACK_USE_ALLOCA
442 # ifdef __GNUC__
443 # define YYSTACK_ALLOC __builtin_alloca
444 # elif defined __BUILTIN_VA_ARG_INCR
445 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
446 # elif defined _AIX
447 # define YYSTACK_ALLOC __alloca
448 # elif defined _MSC_VER
449 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
450 # define alloca _alloca
451 # else
452 # define YYSTACK_ALLOC alloca
453 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
454  || defined __cplusplus || defined _MSC_VER)
455 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
456  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
457 # ifndef EXIT_SUCCESS
458 # define EXIT_SUCCESS 0
459 # endif
460 # endif
461 # endif
462 # endif
463 # endif
464 
465 # ifdef YYSTACK_ALLOC
466  /* Pacify GCC's `empty if-body' warning. */
467 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
468 # ifndef YYSTACK_ALLOC_MAXIMUM
469  /* The OS might guarantee only one guard page at the bottom of the stack,
470  and a page size can be as small as 4096 bytes. So we cannot safely
471  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
472  to allow for a few compiler-allocated temporary stack slots. */
473 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
474 # endif
475 # else
476 # define YYSTACK_ALLOC YYMALLOC
477 # define YYSTACK_FREE YYFREE
478 # ifndef YYSTACK_ALLOC_MAXIMUM
479 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
480 # endif
481 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
482  && ! ((defined YYMALLOC || defined malloc) \
483  && (defined YYFREE || defined free)))
484 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
485 # ifndef EXIT_SUCCESS
486 # define EXIT_SUCCESS 0
487 # endif
488 # endif
489 # ifndef YYMALLOC
490 # define YYMALLOC malloc
491 # if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
492  || defined __cplusplus || defined _MSC_VER)
493 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
494 # endif
495 # endif
496 # ifndef YYFREE
497 # define YYFREE free
498 # if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
499  || defined __cplusplus || defined _MSC_VER)
500 void free (void *); /* INFRINGES ON USER NAME SPACE */
501 # endif
502 # endif
503 # endif
504 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
505 
506 
507 #if (! defined yyoverflow \
508  && (! defined __cplusplus \
509  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
510 
511 /* A type that is properly aligned for any stack member. */
512 union yyalloc
513 {
514  yytype_int16 yyss_alloc;
515  YYSTYPE yyvs_alloc;
516 };
517 
518 /* The size of the maximum gap between one aligned stack and the next. */
519 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
520 
521 /* The size of an array large to enough to hold all stacks, each with
522  N elements. */
523 # define YYSTACK_BYTES(N) \
524  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
525  + YYSTACK_GAP_MAXIMUM)
526 
527 # define YYCOPY_NEEDED 1
528 
529 /* Relocate STACK from its old location to the new one. The
530  local variables YYSIZE and YYSTACKSIZE give the old and new number of
531  elements in the stack, and YYPTR gives the new location of the
532  stack. Advance YYPTR to a properly aligned location for the next
533  stack. */
534 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
535  do \
536  { \
537  YYSIZE_T yynewbytes; \
538  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
539  Stack = &yyptr->Stack_alloc; \
540  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
541  yyptr += yynewbytes / sizeof (*yyptr); \
542  } \
543  while (YYID (0))
544 
545 #endif
546 
547 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
548 /* Copy COUNT objects from SRC to DST. The source and destination do
549  not overlap. */
550 # ifndef YYCOPY
551 # if defined __GNUC__ && 1 < __GNUC__
552 # define YYCOPY(Dst, Src, Count) \
553  __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
554 # else
555 # define YYCOPY(Dst, Src, Count) \
556  do \
557  { \
558  YYSIZE_T yyi; \
559  for (yyi = 0; yyi < (Count); yyi++) \
560  (Dst)[yyi] = (Src)[yyi]; \
561  } \
562  while (YYID (0))
563 # endif
564 # endif
565 #endif /* !YYCOPY_NEEDED */
566 
567 /* YYFINAL -- State number of the termination state. */
568 #define YYFINAL 3
569 /* YYLAST -- Last index in YYTABLE. */
570 #define YYLAST 657
571 
572 /* YYNTOKENS -- Number of terminals. */
573 #define YYNTOKENS 124
574 /* YYNNTS -- Number of nonterminals. */
575 #define YYNNTS 56
576 /* YYNRULES -- Number of rules. */
577 #define YYNRULES 205
578 /* YYNRULES -- Number of states. */
579 #define YYNSTATES 443
580 
581 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
582 #define YYUNDEFTOK 2
583 #define YYMAXUTOK 378
584 
585 #define YYTRANSLATE(YYX) \
586  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
587 
588 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
589 static const yytype_uint8 yytranslate[] =
590 {
591  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
592  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
593  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
594  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
595  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
596  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
597  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
598  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
599  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
600  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
601  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
602  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
603  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
604  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
605  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
606  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
607  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
608  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
609  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
610  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
611  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
612  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
613  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
614  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
615  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
616  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
617  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
618  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
619  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
620  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
621  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
622  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
623  65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
624  75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
625  85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
626  95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
627  105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
628  115, 116, 117, 118, 119, 120, 121, 122, 123
629 };
630 
631 #if YYDEBUG
632 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
633  YYRHS. */
634 static const yytype_uint16 yyprhs[] =
635 {
636  0, 0, 3, 5, 6, 9, 10, 13, 15, 19,
637  21, 23, 26, 29, 32, 35, 41, 46, 48, 52,
638  53, 56, 58, 60, 62, 64, 66, 68, 69, 72,
639  76, 80, 82, 86, 87, 90, 96, 102, 108, 110,
640  112, 116, 124, 129, 132, 134, 136, 140, 146, 150,
641  154, 158, 162, 166, 168, 172, 176, 180, 184, 188,
642  192, 196, 199, 203, 207, 211, 215, 219, 223, 227,
643  231, 235, 239, 243, 247, 252, 257, 259, 261, 263,
644  266, 269, 272, 275, 277, 279, 281, 283, 285, 287,
645  289, 291, 293, 295, 297, 299, 301, 303, 305, 307,
646  309, 311, 313, 315, 317, 319, 321, 323, 325, 327,
647  329, 331, 333, 335, 337, 339, 341, 343, 345, 347,
648  349, 351, 353, 355, 357, 359, 361, 363, 365, 367,
649  369, 371, 373, 375, 378, 382, 391, 396, 398, 400,
650  402, 407, 412, 417, 422, 424, 426, 428, 430, 432,
651  434, 436, 438, 440, 442, 444, 446, 448, 450, 452,
652  454, 456, 458, 460, 464, 468, 472, 476, 480, 482,
653  484, 486, 488, 490, 499, 508, 517, 526, 531, 536,
654  545, 553, 561, 566, 571, 584, 597, 610, 617, 624,
655  631, 640, 649, 655, 663, 673, 678, 685, 694, 696,
656  698, 702, 704, 707, 714, 716
657 };
658 
659 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
660 static const yytype_int16 yyrhs[] =
661 {
662  125, 0, -1, 126, -1, -1, 126, 130, -1, -1,
663  127, 142, -1, 129, -1, 128, 7, 129, -1, 72,
664  -1, 73, -1, 17, 72, -1, 17, 73, -1, 16,
665  72, -1, 16, 73, -1, 86, 79, 153, 80, 77,
666  -1, 101, 149, 152, 77, -1, 142, -1, 104, 131,
667  105, -1, -1, 131, 132, -1, 133, -1, 134, -1,
668  135, -1, 136, -1, 137, -1, 141, -1, -1, 133,
669  114, -1, 106, 145, 107, -1, 108, 145, 109, -1,
670  115, -1, 110, 138, 111, -1, -1, 138, 139, -1,
671  119, 122, 123, 140, 123, -1, 120, 122, 123, 140,
672  123, -1, 121, 122, 123, 140, 123, -1, 117, -1,
673  118, -1, 112, 149, 113, -1, 143, 79, 150, 80,
674  85, 145, 77, -1, 143, 85, 145, 77, -1, 1,
675  77, -1, 148, -1, 148, -1, 144, 7, 148, -1,
676  145, 3, 81, 127, 82, -1, 145, 7, 145, -1,
677  145, 6, 145, -1, 145, 5, 145, -1, 145, 4,
678  145, -1, 145, 8, 145, -1, 146, -1, 146, 17,
679  146, -1, 146, 16, 146, -1, 146, 24, 146, -1,
680  146, 23, 146, -1, 146, 22, 146, -1, 146, 25,
681  146, -1, 146, 26, 146, -1, 146, 27, -1, 146,
682  28, 148, -1, 146, 21, 146, -1, 146, 15, 146,
683  -1, 146, 20, 146, -1, 146, 19, 146, -1, 146,
684  18, 146, -1, 146, 14, 146, -1, 146, 13, 146,
685  -1, 146, 11, 146, -1, 146, 10, 146, -1, 146,
686  12, 146, -1, 146, 9, 146, -1, 146, 79, 150,
687  80, -1, 146, 83, 127, 84, -1, 147, -1, 72,
688  -1, 73, -1, 17, 72, -1, 17, 73, -1, 16,
689  72, -1, 16, 73, -1, 75, -1, 76, -1, 30,
690  -1, 31, -1, 32, -1, 33, -1, 17, -1, 16,
691  -1, 24, -1, 23, -1, 22, -1, 26, -1, 21,
692  -1, 15, -1, 20, -1, 19, -1, 18, -1, 14,
693  -1, 13, -1, 11, -1, 10, -1, 12, -1, 9,
694  -1, 47, -1, 48, -1, 49, -1, 50, -1, 51,
695  -1, 52, -1, 53, -1, 54, -1, 55, -1, 56,
696  -1, 57, -1, 25, -1, 58, -1, 59, -1, 60,
697  -1, 61, -1, 62, -1, 63, -1, 64, -1, 65,
698  -1, 66, -1, 67, -1, 68, -1, 69, -1, 70,
699  -1, 71, -1, 148, -1, 16, 148, -1, 79, 145,
700  80, -1, 74, 79, 144, 80, 28, 79, 145, 80,
701  -1, 102, 81, 177, 82, -1, 161, -1, 162, -1,
702  163, -1, 87, 79, 153, 80, -1, 88, 79, 153,
703  80, -1, 89, 81, 127, 82, -1, 90, 81, 128,
704  82, -1, 164, -1, 165, -1, 166, -1, 167, -1,
705  168, -1, 169, -1, 170, -1, 171, -1, 172, -1,
706  173, -1, 155, -1, 156, -1, 157, -1, 158, -1,
707  159, -1, 160, -1, 99, -1, 99, -1, 151, -1,
708  150, 7, 151, -1, 151, 6, 151, -1, 151, 5,
709  151, -1, 151, 4, 151, -1, 151, 8, 151, -1,
710  146, -1, 97, -1, 97, -1, 97, -1, 98, -1,
711  91, 79, 148, 7, 151, 7, 145, 80, -1, 92,
712  79, 148, 7, 151, 7, 145, 80, -1, 93, 79,
713  148, 7, 151, 7, 145, 80, -1, 94, 79, 148,
714  7, 151, 7, 145, 80, -1, 95, 79, 145, 80,
715  -1, 96, 79, 145, 80, -1, 34, 79, 174, 7,
716  154, 7, 152, 80, -1, 35, 79, 179, 149, 7,
717  154, 80, -1, 36, 79, 179, 149, 7, 154, 80,
718  -1, 37, 79, 153, 80, -1, 38, 79, 153, 80,
719  -1, 39, 79, 153, 7, 151, 7, 151, 7, 151,
720  7, 151, 80, -1, 40, 79, 153, 7, 151, 7,
721  151, 7, 151, 7, 151, 80, -1, 41, 79, 153,
722  7, 151, 7, 151, 7, 151, 7, 151, 80, -1,
723  42, 79, 153, 7, 145, 80, -1, 43, 79, 153,
724  7, 145, 80, -1, 44, 79, 153, 7, 145, 80,
725  -1, 46, 79, 153, 7, 151, 7, 151, 80, -1,
726  45, 79, 153, 7, 151, 7, 151, 80, -1, 179,
727  175, 79, 176, 80, -1, 179, 175, 15, 175, 79,
728  176, 80, -1, 179, 175, 15, 175, 15, 175, 79,
729  176, 80, -1, 179, 175, 79, 80, -1, 179, 175,
730  15, 175, 79, 80, -1, 179, 175, 15, 175, 15,
731  175, 79, 80, -1, 99, -1, 179, -1, 176, 7,
732  179, -1, 178, -1, 177, 178, -1, 79, 150, 80,
733  103, 145, 77, -1, 32, -1, 33, -1
734 };
735 
736 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
737 static const yytype_uint16 yyrline[] =
738 {
739  0, 310, 310, 313, 314, 316, 317, 324, 325, 328,
740  329, 330, 331, 332, 333, 337, 338, 339, 340, 343,
741  344, 347, 348, 349, 350, 351, 352, 355, 356, 359,
742  362, 365, 368, 371, 372, 375, 376, 377, 380, 381,
743  384, 387, 388, 389, 392, 395, 396, 399, 400, 401,
744  402, 403, 404, 405, 408, 409, 410, 411, 412, 413,
745  414, 415, 416, 418, 419, 420, 422, 423, 425, 426,
746  427, 428, 429, 430, 432, 433, 435, 438, 439, 441,
747  442, 444, 445, 447, 448, 450, 451, 453, 454, 456,
748  457, 458, 459, 460, 461, 463, 464, 465, 467, 468,
749  470, 471, 472, 473, 474, 475, 477, 479, 480, 481,
750  482, 483, 484, 485, 487, 488, 489, 490, 491, 492,
751  494, 495, 496, 498, 499, 501, 502, 503, 506, 507,
752  509, 510, 512, 513, 515, 516, 519, 521, 522, 523,
753  524, 525, 526, 527, 529, 530, 531, 532, 533, 534,
754  535, 536, 537, 538, 540, 541, 542, 543, 545, 546,
755  551, 554, 559, 560, 563, 564, 565, 566, 567, 570,
756  573, 576, 577, 582, 586, 590, 594, 599, 602, 609,
757  613, 616, 621, 624, 627, 630, 633, 636, 639, 642,
758  646, 649, 656, 657, 658, 660, 661, 662, 665, 668,
759  669, 672, 673, 676, 680, 681
760 };
761 #endif
762 
763 #if YYDEBUG || YYERROR_VERBOSE || 0
764 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
765  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
766 static const char *const yytname[] =
767 {
768  "$end", "error", "$undefined", "WITH", "MIX", "SPLIT", "SEQ", "PAR",
769  "REC", "NE", "GE", "GT", "EQ", "LE", "LT", "OR", "SUB", "ADD", "RSH",
770  "LSH", "XOR", "AND", "MOD", "DIV", "MUL", "POWOP", "FDELAY", "DELAY1",
771  "DOT", "APPL", "MEM", "PREFIX", "INTCAST", "FLOATCAST", "FFUNCTION",
772  "FCONSTANT", "FVARIABLE", "BUTTON", "CHECKBOX", "VSLIDER", "HSLIDER",
773  "NENTRY", "VGROUP", "HGROUP", "TGROUP", "HBARGRAPH", "VBARGRAPH",
774  "ATTACH", "ACOS", "ASIN", "ATAN", "ATAN2", "COS", "SIN", "TAN", "EXP",
775  "LOG", "LOG10", "POWFUN", "SQRT", "ABS", "MIN", "MAX", "FMOD",
776  "REMAINDER", "FLOOR", "CEIL", "RINT", "RDTBL", "RWTBL", "SELECT2",
777  "SELECT3", "INT", "FLOAT", "LAMBDA", "WIRE", "CUT", "ENDDEF", "VIRG",
778  "LPAR", "RPAR", "LBRAQ", "RBRAQ", "LCROC", "RCROC", "DEF", "IMPORT",
779  "COMPONENT", "LIBRARY", "ENVIRONMENT", "WAVEFORM", "IPAR", "ISEQ",
780  "ISUM", "IPROD", "INPUTS", "OUTPUTS", "STRING", "FSTRING", "IDENT",
781  "EXTRA", "DECLARE", "CASE", "ARROW", "BDOC", "EDOC", "BEQN", "EEQN",
782  "BDGM", "EDGM", "BLST", "ELST", "BMETADATA", "EMETADATA", "DOCCHAR",
783  "NOTICE", "LISTING", "LSTTRUE", "LSTFALSE", "LSTDEPENDENCIES",
784  "LSTMDOCTAGS", "LSTDISTRIBUTED", "LSTEQ", "LSTQ", "$accept", "program",
785  "stmtlist", "deflist", "vallist", "number", "statement", "doc",
786  "docelem", "doctxt", "doceqn", "docdgm", "docntc", "doclst",
787  "lstattrlist", "lstattrdef", "lstattrval", "docmtd", "definition",
788  "defname", "params", "expression", "infixexp", "primitive", "ident",
789  "name", "arglist", "argument", "string", "uqstring", "fstring", "fpar",
790  "fseq", "fsum", "fprod", "finputs", "foutputs", "ffunction", "fconst",
791  "fvariable", "button", "checkbox", "vslider", "hslider", "nentry",
792  "vgroup", "hgroup", "tgroup", "vbargraph", "hbargraph", "signature",
793  "fun", "typelist", "rulelist", "rule", "type", YY_NULL
794 };
795 #endif
796 
797 # ifdef YYPRINT
798 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
799  token YYLEX-NUM. */
800 static const yytype_uint16 yytoknum[] =
801 {
802  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
803  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
804  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
805  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
806  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
807  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
808  315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
809  325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
810  335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
811  345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
812  355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
813  365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
814  375, 376, 377, 378
815 };
816 # endif
817 
818 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
819 static const yytype_uint8 yyr1[] =
820 {
821  0, 124, 125, 126, 126, 127, 127, 128, 128, 129,
822  129, 129, 129, 129, 129, 130, 130, 130, 130, 131,
823  131, 132, 132, 132, 132, 132, 132, 133, 133, 134,
824  135, 136, 137, 138, 138, 139, 139, 139, 140, 140,
825  141, 142, 142, 142, 143, 144, 144, 145, 145, 145,
826  145, 145, 145, 145, 146, 146, 146, 146, 146, 146,
827  146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
828  146, 146, 146, 146, 146, 146, 146, 147, 147, 147,
829  147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
830  147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
831  147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
832  147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
833  147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
834  147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
835  147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
836  147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
837  148, 149, 150, 150, 151, 151, 151, 151, 151, 152,
838  153, 154, 154, 155, 156, 157, 158, 159, 160, 161,
839  162, 163, 164, 165, 166, 167, 168, 169, 170, 171,
840  172, 173, 174, 174, 174, 174, 174, 174, 175, 176,
841  176, 177, 177, 178, 179, 179
842 };
843 
844 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
845 static const yytype_uint8 yyr2[] =
846 {
847  0, 2, 1, 0, 2, 0, 2, 1, 3, 1,
848  1, 2, 2, 2, 2, 5, 4, 1, 3, 0,
849  2, 1, 1, 1, 1, 1, 1, 0, 2, 3,
850  3, 1, 3, 0, 2, 5, 5, 5, 1, 1,
851  3, 7, 4, 2, 1, 1, 3, 5, 3, 3,
852  3, 3, 3, 1, 3, 3, 3, 3, 3, 3,
853  3, 2, 3, 3, 3, 3, 3, 3, 3, 3,
854  3, 3, 3, 3, 4, 4, 1, 1, 1, 2,
855  2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
856  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
857  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
858  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
859  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
860  1, 1, 1, 2, 3, 8, 4, 1, 1, 1,
861  4, 4, 4, 4, 1, 1, 1, 1, 1, 1,
862  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
863  1, 1, 1, 3, 3, 3, 3, 3, 1, 1,
864  1, 1, 1, 8, 8, 8, 8, 4, 4, 8,
865  7, 7, 4, 4, 12, 12, 12, 6, 6, 6,
866  8, 8, 5, 7, 9, 4, 6, 8, 1, 1,
867  3, 1, 2, 6, 1, 1
868 };
869 
870 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
871  Performed when YYTABLE doesn't specify something else to do. Zero
872  means the default is an error. */
873 static const yytype_uint8 yydefact[] =
874 {
875  3, 0, 0, 1, 0, 0, 160, 0, 19, 4,
876  17, 0, 44, 43, 0, 161, 0, 27, 0, 0,
877  170, 0, 169, 0, 18, 0, 0, 33, 0, 31,
878  20, 21, 22, 23, 24, 25, 26, 105, 103, 102,
879  104, 101, 100, 96, 90, 89, 99, 98, 97, 95,
880  93, 92, 91, 117, 94, 85, 86, 87, 88, 0,
881  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
882  0, 0, 106, 107, 108, 109, 110, 111, 112, 113,
883  114, 115, 116, 118, 119, 120, 121, 122, 123, 124,
884  125, 126, 127, 128, 129, 130, 131, 77, 78, 0,
885  83, 84, 0, 0, 0, 0, 0, 0, 0, 0,
886  0, 0, 0, 0, 168, 76, 132, 0, 162, 154,
887  155, 156, 157, 158, 159, 137, 138, 139, 144, 145,
888  146, 147, 148, 149, 150, 151, 152, 153, 0, 53,
889  0, 16, 0, 0, 0, 0, 28, 81, 82, 133,
890  79, 80, 0, 0, 0, 0, 0, 0, 0, 0,
891  0, 0, 0, 0, 0, 0, 0, 0, 0, 5,
892  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
893  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
894  0, 0, 0, 0, 0, 0, 61, 0, 0, 5,
895  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
896  0, 0, 42, 15, 29, 30, 32, 0, 0, 0,
897  34, 40, 204, 205, 0, 0, 0, 0, 0, 0,
898  0, 0, 0, 0, 0, 0, 0, 0, 0, 45,
899  134, 0, 0, 0, 0, 0, 9, 10, 0, 7,
900  0, 0, 0, 0, 0, 0, 0, 0, 201, 73,
901  71, 70, 72, 69, 68, 64, 55, 54, 67, 66,
902  65, 63, 58, 57, 56, 59, 60, 62, 0, 0,
903  163, 0, 166, 165, 164, 167, 5, 51, 50, 49,
904  48, 52, 0, 0, 0, 0, 198, 0, 0, 0,
905  182, 183, 0, 0, 0, 0, 0, 0, 0, 0,
906  0, 0, 140, 141, 142, 6, 13, 14, 11, 12,
907  0, 143, 0, 0, 0, 0, 177, 178, 0, 136,
908  202, 74, 75, 0, 0, 0, 0, 0, 171, 172,
909  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
910  0, 0, 0, 46, 0, 8, 0, 0, 0, 0,
911  0, 41, 47, 38, 39, 0, 0, 0, 0, 0,
912  195, 0, 199, 0, 0, 0, 0, 0, 187, 188,
913  189, 0, 0, 0, 0, 0, 0, 0, 0, 35,
914  36, 37, 0, 0, 0, 0, 192, 180, 181, 0,
915  0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
916  179, 0, 196, 0, 200, 0, 0, 0, 191, 190,
917  135, 173, 174, 175, 176, 203, 0, 193, 0, 0,
918  0, 197, 0, 0, 0, 0, 194, 0, 0, 0,
919  184, 185, 186
920 };
921 
922 /* YYDEFGOTO[NTERM-NUM]. */
923 static const yytype_int16 yydefgoto[] =
924 {
925  -1, 1, 2, 243, 248, 249, 9, 17, 30, 31,
926  32, 33, 34, 35, 144, 220, 365, 36, 315, 11,
927  238, 138, 114, 115, 116, 16, 117, 118, 23, 21,
928  340, 119, 120, 121, 122, 123, 124, 125, 126, 127,
929  128, 129, 130, 131, 132, 133, 134, 135, 136, 137,
930  224, 297, 371, 257, 258, 372
931 };
932 
933 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
934  STATE-NUM. */
935 #define YYPACT_NINF -319
936 static const yytype_int16 yypact[] =
937 {
938  -319, 86, 20, -319, -13, 32, -319, 1, -319, -319,
939  -319, 12, -319, -319, 29, -319, 38, 218, 382, 382,
940  -319, 52, -319, 81, -319, 382, 382, -319, 1, -319,
941  -319, 92, -319, -319, -319, -319, -319, -319, -319, -319,
942  -319, -319, -319, -319, 242, 82, -319, -319, -319, -319,
943  -319, -319, -319, -319, -319, -319, -319, -319, -319, 136,
944  156, 169, 190, 195, 200, 237, 238, 243, 246, 248,
945  252, 255, -319, -319, -319, -319, -319, -319, -319, -319,
946  -319, -319, -319, -319, -319, -319, -319, -319, -319, -319,
947  -319, -319, -319, -319, -319, -319, -319, -319, -319, 269,
948  -319, -319, 382, 275, 278, 140, 176, 279, 281, 282,
949  283, 284, 292, 208, 476, -319, -319, 19, 212, -319,
950  -319, -319, -319, -319, -319, -319, -319, -319, -319, -319,
951  -319, -319, -319, -319, -319, -319, -319, -319, 332, 476,
952  214, -319, 11, 5, -27, 186, -319, -319, -319, -319,
953  -319, -319, 151, 151, 151, 29, 29, 29, 29, 29,
954  29, 29, 29, 29, 29, 206, 27, 29, 29, -319,
955  191, 206, 206, 206, 206, 382, 382, 293, 382, 382,
956  382, 382, 382, 382, 382, 382, 382, 382, 382, 382,
957  382, 382, 382, 382, 382, 382, -319, 206, 382, -319,
958  382, 235, 382, 382, 382, 382, 265, 382, 382, 382,
959  382, 382, -319, -319, -319, -319, -319, 251, 288, 289,
960  -319, -319, -319, -319, 452, 361, 1, 1, 388, 399,
961  473, 475, 504, 546, 547, 549, 550, 551, 35, -319,
962  -319, 403, 490, 3, 178, 183, -319, -319, 16, -319,
963  564, 567, 568, 570, 33, 42, 382, 8, -319, 497,
964  497, 497, 497, 497, 497, 519, 519, 519, 270, 270,
965  270, 270, 270, 270, 270, 276, 291, -319, 36, 21,
966  212, 382, 212, 212, 95, -319, -319, 371, 371, 337,
967  67, -319, 455, 474, 477, 100, -319, 73, 589, 592,
968  -319, -319, 382, 382, 382, 382, 382, 382, 382, 382,
969  206, 573, -319, -319, -319, -319, -319, -319, -319, -319,
970  191, -319, 382, 382, 382, 382, -319, -319, 37, -319,
971  -319, -319, -319, 459, 28, 143, 143, 143, -319, -319,
972  636, 361, 63, 100, 100, 376, 522, 527, 48, 54,
973  64, 544, 577, -319, 565, -319, 582, 587, 599, 604,
974  542, -319, -319, -319, -319, 523, 524, 525, 38, 74,
975  -319, 56, -319, 569, 571, 382, 382, 382, -319, -319,
976  -319, 382, 382, 382, 382, 382, 382, 382, 382, -319,
977  -319, -319, 572, 361, 210, 151, -319, -319, -319, 609,
978  614, 619, 125, 241, 134, 142, 220, 226, 233, 502,
979  -319, 574, -319, 71, -319, 382, 382, 382, -319, -319,
980  -319, -319, -319, -319, -319, -319, 249, -319, 624, 629,
981  634, -319, 102, 382, 382, 382, -319, 262, 267, 272,
982  -319, -319, -319
983 };
984 
985 /* YYPGOTO[NTERM-NUM]. */
986 static const yytype_int16 yypgoto[] =
987 {
988  -319, -319, -319, -174, -319, 330, -319, -319, -319, -319,
989  -319, -319, -319, -319, -319, -319, -52, -319, 652, -319,
990  -319, 2, -19, -319, 22, -23, -133, -123, 287, 405,
991  7, -319, -319, -319, -319, -319, -319, -319, -319, -319,
992  -319, -319, -319, -319, -319, -319, -319, -319, -319, -319,
993  -319, -268, -318, -319, 400, -151
994 };
995 
996 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
997  positive, shift that token. If negative, reduce the rule which
998  number is the opposite. If YYTABLE_NINF, syntax error. */
999 #define YYTABLE_NINF -3
1000 static const yytype_int16 yytable[] =
1001 {
1002  139, 225, 226, 227, 4, 145, 139, 139, 206, 207,
1003  208, 209, 210, 211, 206, 207, 208, 209, 210, 211,
1004  -2, 4, 4, 320, 12, 279, 200, 142, 143, 4,
1005  206, 207, 208, 209, 210, 211, 206, 207, 208, 209,
1006  210, 211, 310, 200, 200, 206, 207, 208, 209, 210,
1007  211, 206, 207, 208, 209, 210, 211, 206, 207, 208,
1008  209, 210, 211, 395, 13, 278, 149, 206, 207, 208,
1009  209, 210, 211, 369, 210, 211, 413, 280, 395, 282,
1010  283, 284, 285, 139, 216, 314, 3, 256, 341, 393,
1011  329, 18, 217, 218, 219, 222, 223, 19, 321, 201,
1012  15, 204, 6, 205, 166, 332, 5, 240, 432, 395,
1013  362, 14, 334, 326, 215, 311, 331, 360, 214, 6,
1014  6, 7, 327, 328, 8, 411, 20, 6, 378, 202,
1015  203, 204, 140, 205, 379, 22, 396, 206, 207, 208,
1016  209, 210, 211, 370, 380, 206, 207, 208, 209, 210,
1017  211, 427, 342, 394, 150, 151, 139, 139, 141, 259,
1018  260, 261, 262, 263, 264, 265, 266, 267, 268, 269,
1019  270, 271, 272, 273, 274, 275, 276, 254, 255, 345,
1020  346, 347, 436, 222, 223, 351, 352, 239, 139, 139,
1021  139, 139, 139, 250, 251, 252, 253, 338, 339, 356,
1022  357, 358, 359, 298, 299, 418, 146, 244, 245, 287,
1023  288, 289, 290, 291, 420, 152, 202, 203, 204, 277,
1024  205, 169, 421, 206, 207, 208, 209, 210, 211, 206,
1025  207, 208, 209, 210, 211, 153, 206, 207, 208, 209,
1026  210, 211, 222, 223, 414, 202, 203, 204, 154, 205,
1027  316, 317, 399, 400, 401, 318, 319, 170, 402, 403,
1028  363, 364, 139, 246, 247, 12, 202, 203, 204, 155,
1029  205, 202, 203, 204, 156, 205, 202, 203, 204, 157,
1030  205, 222, 223, 333, 366, 367, 139, 139, 139, 177,
1031  412, 213, 428, 429, 430, 194, 195, 196, 197, 221,
1032  422, 12, 195, 196, 197, 6, 423, 348, 349, 350,
1033  437, 438, 439, 424, 147, 148, 158, 159, 196, 197,
1034  281, 419, 160, 24, 25, 161, 26, 162, 27, 431,
1035  28, 163, 353, 29, 164, 206, 207, 208, 209, 210,
1036  211, 6, 440, 209, 210, 211, 286, 441, 165, 198,
1037  373, 374, 442, 199, 167, 198, 12, 168, 171, 199,
1038  172, 173, 174, 175, 139, 139, 139, 139, 139, 139,
1039  198, 176, 256, 292, 199, 207, 208, 209, 210, 211,
1040  202, 203, 204, 375, 205, 404, 405, 406, 407, 408,
1041  409, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1042  46, 47, 48, 49, 50, 51, 52, 53, 54, 212,
1043  293, 294, 55, 56, 57, 58, 59, 60, 61, 62,
1044  63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
1045  73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
1046  83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
1047  93, 94, 95, 96, 97, 98, 99, 100, 101, 295,
1048  296, 102, 206, 207, 208, 209, 210, 211, 300, 103,
1049  104, 105, 106, 107, 108, 109, 110, 111, 112, 301,
1050  302, 6, 303, 312, 113, 178, 179, 180, 181, 182,
1051  183, 184, 185, 186, 187, 188, 189, 190, 191, 192,
1052  193, 194, 195, 196, 197, 206, 207, 208, 209, 210,
1053  211, 304, 184, 185, 186, 187, 188, 189, 190, 191,
1054  192, 193, 194, 195, 196, 197, 202, 203, 204, 376,
1055  205, 202, 203, 204, 377, 205, 361, 187, 188, 189,
1056  190, 191, 192, 193, 194, 195, 196, 197, 202, 203,
1057  204, 381, 205, 305, 306, 198, 307, 308, 309, 199,
1058  228, 229, 230, 231, 232, 233, 234, 235, 236, 237,
1059  313, 322, 241, 242, 323, 324, 198, 325, 335, 425,
1060  199, 202, 203, 204, 382, 205, 202, 203, 204, 384,
1061  205, 202, 203, 204, 385, 205, 343, 336, 198, 344,
1062  337, 354, 199, 202, 203, 204, 386, 205, 202, 203,
1063  204, 387, 205, 202, 203, 204, 415, 205, 202, 203,
1064  204, 416, 205, 202, 203, 204, 417, 205, 202, 203,
1065  204, 433, 205, 202, 203, 204, 434, 205, 202, 203,
1066  204, 435, 205, 368, 383, 388, 389, 390, 391, 397,
1067  355, 398, 410, 426, 10, 392, 0, 330
1068 };
1069 
1070 #define yypact_value_is_default(Yystate) \
1071  (!!((Yystate) == (-319)))
1072 
1073 #define yytable_value_is_error(Yytable_value) \
1074  YYID (0)
1075 
1076 static const yytype_int16 yycheck[] =
1077 {
1078  19, 152, 153, 154, 1, 28, 25, 26, 3, 4,
1079  5, 6, 7, 8, 3, 4, 5, 6, 7, 8,
1080  0, 1, 1, 7, 2, 199, 7, 25, 26, 1,
1081  3, 4, 5, 6, 7, 8, 3, 4, 5, 6,
1082  7, 8, 7, 7, 7, 3, 4, 5, 6, 7,
1083  8, 3, 4, 5, 6, 7, 8, 3, 4, 5,
1084  6, 7, 8, 7, 77, 198, 44, 3, 4, 5,
1085  6, 7, 8, 341, 7, 8, 394, 200, 7, 202,
1086  203, 204, 205, 102, 111, 82, 0, 79, 15, 15,
1087  82, 79, 119, 120, 121, 32, 33, 85, 82, 80,
1088  99, 6, 99, 8, 102, 84, 86, 80, 426, 7,
1089  82, 79, 286, 80, 109, 80, 80, 80, 107, 99,
1090  99, 101, 80, 256, 104, 393, 97, 99, 80, 4,
1091  5, 6, 80, 8, 80, 97, 80, 3, 4, 5,
1092  6, 7, 8, 80, 80, 3, 4, 5, 6, 7,
1093  8, 80, 79, 79, 72, 73, 175, 176, 77, 178,
1094  179, 180, 181, 182, 183, 184, 185, 186, 187, 188,
1095  189, 190, 191, 192, 193, 194, 195, 175, 176, 302,
1096  303, 304, 80, 32, 33, 308, 309, 165, 207, 208,
1097  209, 210, 211, 171, 172, 173, 174, 97, 98, 322,
1098  323, 324, 325, 226, 227, 80, 114, 16, 17, 207,
1099  208, 209, 210, 211, 80, 79, 4, 5, 6, 197,
1100  8, 81, 80, 3, 4, 5, 6, 7, 8, 3,
1101  4, 5, 6, 7, 8, 79, 3, 4, 5, 6,
1102  7, 8, 32, 33, 395, 4, 5, 6, 79, 8,
1103  72, 73, 375, 376, 377, 72, 73, 81, 381, 382,
1104  117, 118, 281, 72, 73, 243, 4, 5, 6, 79,
1105  8, 4, 5, 6, 79, 8, 4, 5, 6, 79,
1106  8, 32, 33, 281, 336, 337, 305, 306, 307, 81,
1107  80, 77, 415, 416, 417, 25, 26, 27, 28, 113,
1108  80, 279, 26, 27, 28, 99, 80, 305, 306, 307,
1109  433, 434, 435, 80, 72, 73, 79, 79, 27, 28,
1110  85, 80, 79, 105, 106, 79, 108, 79, 110, 80,
1111  112, 79, 310, 115, 79, 3, 4, 5, 6, 7,
1112  8, 99, 80, 6, 7, 8, 81, 80, 79, 79,
1113  343, 344, 80, 83, 79, 79, 334, 79, 79, 83,
1114  79, 79, 79, 79, 383, 384, 385, 386, 387, 388,
1115  79, 79, 79, 122, 83, 4, 5, 6, 7, 8,
1116  4, 5, 6, 7, 8, 383, 384, 385, 386, 387,
1117  388, 9, 10, 11, 12, 13, 14, 15, 16, 17,
1118  18, 19, 20, 21, 22, 23, 24, 25, 26, 77,
1119  122, 122, 30, 31, 32, 33, 34, 35, 36, 37,
1120  38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
1121  48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
1122  58, 59, 60, 61, 62, 63, 64, 65, 66, 67,
1123  68, 69, 70, 71, 72, 73, 74, 75, 76, 7,
1124  99, 79, 3, 4, 5, 6, 7, 8, 80, 87,
1125  88, 89, 90, 91, 92, 93, 94, 95, 96, 80,
1126  7, 99, 7, 80, 102, 9, 10, 11, 12, 13,
1127  14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1128  24, 25, 26, 27, 28, 3, 4, 5, 6, 7,
1129  8, 7, 15, 16, 17, 18, 19, 20, 21, 22,
1130  23, 24, 25, 26, 27, 28, 4, 5, 6, 7,
1131  8, 4, 5, 6, 7, 8, 77, 18, 19, 20,
1132  21, 22, 23, 24, 25, 26, 27, 28, 4, 5,
1133  6, 7, 8, 7, 7, 79, 7, 7, 7, 83,
1134  155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
1135  80, 7, 167, 168, 7, 7, 79, 7, 123, 77,
1136  83, 4, 5, 6, 7, 8, 4, 5, 6, 7,
1137  8, 4, 5, 6, 7, 8, 7, 123, 79, 7,
1138  123, 28, 83, 4, 5, 6, 7, 8, 4, 5,
1139  6, 7, 8, 4, 5, 6, 7, 8, 4, 5,
1140  6, 7, 8, 4, 5, 6, 7, 8, 4, 5,
1141  6, 7, 8, 4, 5, 6, 7, 8, 4, 5,
1142  6, 7, 8, 7, 79, 103, 123, 123, 123, 80,
1143  320, 80, 80, 79, 2, 368, -1, 257
1144 };
1145 
1146 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1147  symbol of state STATE-NUM. */
1148 static const yytype_uint8 yystos[] =
1149 {
1150  0, 125, 126, 0, 1, 86, 99, 101, 104, 130,
1151  142, 143, 148, 77, 79, 99, 149, 131, 79, 85,
1152  97, 153, 97, 152, 105, 106, 108, 110, 112, 115,
1153  132, 133, 134, 135, 136, 137, 141, 9, 10, 11,
1154  12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1155  22, 23, 24, 25, 26, 30, 31, 32, 33, 34,
1156  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1157  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1158  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
1159  65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
1160  75, 76, 79, 87, 88, 89, 90, 91, 92, 93,
1161  94, 95, 96, 102, 146, 147, 148, 150, 151, 155,
1162  156, 157, 158, 159, 160, 161, 162, 163, 164, 165,
1163  166, 167, 168, 169, 170, 171, 172, 173, 145, 146,
1164  80, 77, 145, 145, 138, 149, 114, 72, 73, 148,
1165  72, 73, 79, 79, 79, 79, 79, 79, 79, 79,
1166  79, 79, 79, 79, 79, 79, 145, 79, 79, 81,
1167  81, 79, 79, 79, 79, 79, 79, 81, 9, 10,
1168  11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1169  21, 22, 23, 24, 25, 26, 27, 28, 79, 83,
1170  7, 80, 4, 5, 6, 8, 3, 4, 5, 6,
1171  7, 8, 77, 77, 107, 109, 111, 119, 120, 121,
1172  139, 113, 32, 33, 174, 179, 179, 179, 153, 153,
1173  153, 153, 153, 153, 153, 153, 153, 153, 144, 148,
1174  80, 153, 153, 127, 16, 17, 72, 73, 128, 129,
1175  148, 148, 148, 148, 145, 145, 79, 177, 178, 146,
1176  146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
1177  146, 146, 146, 146, 146, 146, 146, 148, 150, 127,
1178  151, 85, 151, 151, 151, 151, 81, 145, 145, 145,
1179  145, 145, 122, 122, 122, 7, 99, 175, 149, 149,
1180  80, 80, 7, 7, 7, 7, 7, 7, 7, 7,
1181  7, 80, 80, 80, 82, 142, 72, 73, 72, 73,
1182  7, 82, 7, 7, 7, 7, 80, 80, 150, 82,
1183  178, 80, 84, 145, 127, 123, 123, 123, 97, 98,
1184  154, 15, 79, 7, 7, 151, 151, 151, 145, 145,
1185  145, 151, 151, 148, 28, 129, 151, 151, 151, 151,
1186  80, 77, 82, 117, 118, 140, 140, 140, 7, 175,
1187  80, 176, 179, 154, 154, 7, 7, 7, 80, 80,
1188  80, 7, 7, 79, 7, 7, 7, 7, 103, 123,
1189  123, 123, 152, 15, 79, 7, 80, 80, 80, 151,
1190  151, 151, 151, 151, 145, 145, 145, 145, 145, 145,
1191  80, 175, 80, 176, 179, 7, 7, 7, 80, 80,
1192  80, 80, 80, 80, 80, 77, 79, 80, 151, 151,
1193  151, 80, 176, 7, 7, 7, 80, 151, 151, 151,
1194  80, 80, 80
1195 };
1196 
1197 #define yyerrok (yyerrstatus = 0)
1198 #define yyclearin (yychar = YYEMPTY)
1199 #define YYEMPTY (-2)
1200 #define YYEOF 0
1201 
1202 #define YYACCEPT goto yyacceptlab
1203 #define YYABORT goto yyabortlab
1204 #define YYERROR goto yyerrorlab
1205 
1206 
1207 /* Like YYERROR except do call yyerror. This remains here temporarily
1208  to ease the transition to the new meaning of YYERROR, for GCC.
1209  Once GCC version 2 has supplanted version 1, this can go. However,
1210  YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1211  in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1212  discussed. */
1213 
1214 #define YYFAIL goto yyerrlab
1215 #if defined YYFAIL
1216  /* This is here to suppress warnings from the GCC cpp's
1217  -Wunused-macros. Normally we don't worry about that warning, but
1218  some users do, and we want to make it easy for users to remove
1219  YYFAIL uses, which will produce warnings from Bison 2.5. */
1220 #endif
1221 
1222 #define YYRECOVERING() (!!yyerrstatus)
1223 
1224 #define YYBACKUP(Token, Value) \
1225 do \
1226  if (yychar == YYEMPTY) \
1227  { \
1228  yychar = (Token); \
1229  yylval = (Value); \
1230  YYPOPSTACK (yylen); \
1231  yystate = *yyssp; \
1232  goto yybackup; \
1233  } \
1234  else \
1235  { \
1236  yyerror (YY_("syntax error: cannot back up")); \
1237  YYERROR; \
1238  } \
1239 while (YYID (0))
1240 
1241 /* Error token number */
1242 #define YYTERROR 1
1243 #define YYERRCODE 256
1244 
1245 
1246 /* This macro is provided for backward compatibility. */
1247 #ifndef YY_LOCATION_PRINT
1248 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1249 #endif
1250 
1251 
1252 /* YYLEX -- calling `yylex' with the right arguments. */
1253 #ifdef YYLEX_PARAM
1254 # define YYLEX yylex (YYLEX_PARAM)
1255 #else
1256 # define YYLEX yylex ()
1257 #endif
1258 
1259 /* Enable debugging if requested. */
1260 #if YYDEBUG
1261 
1262 # ifndef YYFPRINTF
1263 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1264 # define YYFPRINTF fprintf
1265 # endif
1266 
1267 # define YYDPRINTF(Args) \
1268 do { \
1269  if (yydebug) \
1270  YYFPRINTF Args; \
1271 } while (YYID (0))
1272 
1273 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1274 do { \
1275  if (yydebug) \
1276  { \
1277  YYFPRINTF (stderr, "%s ", Title); \
1278  yy_symbol_print (stderr, \
1279  Type, Value); \
1280  YYFPRINTF (stderr, "\n"); \
1281  } \
1282 } while (YYID (0))
1283 
1284 
1285 /*--------------------------------.
1286 | Print this symbol on YYOUTPUT. |
1287 `--------------------------------*/
1288 
1289 /*ARGSUSED*/
1290 #if (defined __STDC__ || defined __C99__FUNC__ \
1291  || defined __cplusplus || defined _MSC_VER)
1292 static void
1293 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1294 #else
1295 static void
1296 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1297  FILE *yyoutput;
1298  int yytype;
1299  YYSTYPE const * const yyvaluep;
1300 #endif
1301 {
1302  FILE *yyo = yyoutput;
1303  YYUSE (yyo);
1304  if (!yyvaluep)
1305  return;
1306 # ifdef YYPRINT
1307  if (yytype < YYNTOKENS)
1308  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1309 # else
1310  YYUSE (yyoutput);
1311 # endif
1312  YYUSE (yytype);
1313 }
1314 
1315 
1316 /*--------------------------------.
1317 | Print this symbol on YYOUTPUT. |
1318 `--------------------------------*/
1319 
1320 #if (defined __STDC__ || defined __C99__FUNC__ \
1321  || defined __cplusplus || defined _MSC_VER)
1322 static void
1323 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1324 #else
1325 static void
1326 yy_symbol_print (yyoutput, yytype, yyvaluep)
1327  FILE *yyoutput;
1328  int yytype;
1329  YYSTYPE const * const yyvaluep;
1330 #endif
1331 {
1332  if (yytype < YYNTOKENS)
1333  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1334  else
1335  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1336 
1337  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1338  YYFPRINTF (yyoutput, ")");
1339 }
1340 
1341 /*------------------------------------------------------------------.
1342 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1343 | TOP (included). |
1344 `------------------------------------------------------------------*/
1345 
1346 #if (defined __STDC__ || defined __C99__FUNC__ \
1347  || defined __cplusplus || defined _MSC_VER)
1348 static void
1349 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1350 #else
1351 static void
1352 yy_stack_print (yybottom, yytop)
1353  yytype_int16 *yybottom;
1354  yytype_int16 *yytop;
1355 #endif
1356 {
1357  YYFPRINTF (stderr, "Stack now");
1358  for (; yybottom <= yytop; yybottom++)
1359  {
1360  int yybot = *yybottom;
1361  YYFPRINTF (stderr, " %d", yybot);
1362  }
1363  YYFPRINTF (stderr, "\n");
1364 }
1365 
1366 # define YY_STACK_PRINT(Bottom, Top) \
1367 do { \
1368  if (yydebug) \
1369  yy_stack_print ((Bottom), (Top)); \
1370 } while (YYID (0))
1371 
1372 
1373 /*------------------------------------------------.
1374 | Report that the YYRULE is going to be reduced. |
1375 `------------------------------------------------*/
1376 
1377 #if (defined __STDC__ || defined __C99__FUNC__ \
1378  || defined __cplusplus || defined _MSC_VER)
1379 static void
1380 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1381 #else
1382 static void
1383 yy_reduce_print (yyvsp, yyrule)
1384  YYSTYPE *yyvsp;
1385  int yyrule;
1386 #endif
1387 {
1388  int yynrhs = yyr2[yyrule];
1389  int yyi;
1390  unsigned long int yylno = yyrline[yyrule];
1391  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1392  yyrule - 1, yylno);
1393  /* The symbols being reduced. */
1394  for (yyi = 0; yyi < yynrhs; yyi++)
1395  {
1396  YYFPRINTF (stderr, " $%d = ", yyi + 1);
1397  yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1398  &(yyvsp[(yyi + 1) - (yynrhs)])
1399  );
1400  YYFPRINTF (stderr, "\n");
1401  }
1402 }
1403 
1404 # define YY_REDUCE_PRINT(Rule) \
1405 do { \
1406  if (yydebug) \
1407  yy_reduce_print (yyvsp, Rule); \
1408 } while (YYID (0))
1409 
1410 /* Nonzero means print parse trace. It is left uninitialized so that
1411  multiple parsers can coexist. */
1412 int yydebug;
1413 #else /* !YYDEBUG */
1414 # define YYDPRINTF(Args)
1415 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1416 # define YY_STACK_PRINT(Bottom, Top)
1417 # define YY_REDUCE_PRINT(Rule)
1418 #endif /* !YYDEBUG */
1419 
1420 
1421 /* YYINITDEPTH -- initial size of the parser's stacks. */
1422 #ifndef YYINITDEPTH
1423 # define YYINITDEPTH 200
1424 #endif
1425 
1426 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1427  if the built-in stack extension method is used).
1428 
1429  Do not make this value too large; the results are undefined if
1430  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1431  evaluated with infinite-precision integer arithmetic. */
1432 
1433 #ifndef YYMAXDEPTH
1434 # define YYMAXDEPTH 10000
1435 #endif
1436 
1437 
1438 #if YYERROR_VERBOSE
1439 
1440 # ifndef yystrlen
1441 # if defined __GLIBC__ && defined _STRING_H
1442 # define yystrlen strlen
1443 # else
1444 /* Return the length of YYSTR. */
1445 #if (defined __STDC__ || defined __C99__FUNC__ \
1446  || defined __cplusplus || defined _MSC_VER)
1447 static YYSIZE_T
1448 yystrlen (const char *yystr)
1449 #else
1450 static YYSIZE_T
1451 yystrlen (yystr)
1452  const char *yystr;
1453 #endif
1454 {
1455  YYSIZE_T yylen;
1456  for (yylen = 0; yystr[yylen]; yylen++)
1457  continue;
1458  return yylen;
1459 }
1460 # endif
1461 # endif
1462 
1463 # ifndef yystpcpy
1464 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1465 # define yystpcpy stpcpy
1466 # else
1467 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1468  YYDEST. */
1469 #if (defined __STDC__ || defined __C99__FUNC__ \
1470  || defined __cplusplus || defined _MSC_VER)
1471 static char *
1472 yystpcpy (char *yydest, const char *yysrc)
1473 #else
1474 static char *
1475 yystpcpy (yydest, yysrc)
1476  char *yydest;
1477  const char *yysrc;
1478 #endif
1479 {
1480  char *yyd = yydest;
1481  const char *yys = yysrc;
1482 
1483  while ((*yyd++ = *yys++) != '\0')
1484  continue;
1485 
1486  return yyd - 1;
1487 }
1488 # endif
1489 # endif
1490 
1491 # ifndef yytnamerr
1492 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1493  quotes and backslashes, so that it's suitable for yyerror. The
1494  heuristic is that double-quoting is unnecessary unless the string
1495  contains an apostrophe, a comma, or backslash (other than
1496  backslash-backslash). YYSTR is taken from yytname. If YYRES is
1497  null, do not copy; instead, return the length of what the result
1498  would have been. */
1499 static YYSIZE_T
1500 yytnamerr (char *yyres, const char *yystr)
1501 {
1502  if (*yystr == '"')
1503  {
1504  YYSIZE_T yyn = 0;
1505  char const *yyp = yystr;
1506 
1507  for (;;)
1508  switch (*++yyp)
1509  {
1510  case '\'':
1511  case ',':
1512  goto do_not_strip_quotes;
1513 
1514  case '\\':
1515  if (*++yyp != '\\')
1516  goto do_not_strip_quotes;
1517  /* Fall through. */
1518  default:
1519  if (yyres)
1520  yyres[yyn] = *yyp;
1521  yyn++;
1522  break;
1523 
1524  case '"':
1525  if (yyres)
1526  yyres[yyn] = '\0';
1527  return yyn;
1528  }
1529  do_not_strip_quotes: ;
1530  }
1531 
1532  if (! yyres)
1533  return yystrlen (yystr);
1534 
1535  return yystpcpy (yyres, yystr) - yyres;
1536 }
1537 # endif
1538 
1539 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1540  about the unexpected token YYTOKEN for the state stack whose top is
1541  YYSSP.
1542 
1543  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1544  not large enough to hold the message. In that case, also set
1545  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1546  required number of bytes is too large to store. */
1547 static int
1548 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1549  yytype_int16 *yyssp, int yytoken)
1550 {
1551  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
1552  YYSIZE_T yysize = yysize0;
1553  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1554  /* Internationalized format string. */
1555  const char *yyformat = YY_NULL;
1556  /* Arguments of yyformat. */
1557  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1558  /* Number of reported tokens (one for the "unexpected", one per
1559  "expected"). */
1560  int yycount = 0;
1561 
1562  /* There are many possibilities here to consider:
1563  - Assume YYFAIL is not used. It's too flawed to consider. See
1564  <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1565  for details. YYERROR is fine as it does not invoke this
1566  function.
1567  - If this state is a consistent state with a default action, then
1568  the only way this function was invoked is if the default action
1569  is an error action. In that case, don't check for expected
1570  tokens because there are none.
1571  - The only way there can be no lookahead present (in yychar) is if
1572  this state is a consistent state with a default action. Thus,
1573  detecting the absence of a lookahead is sufficient to determine
1574  that there is no unexpected or expected token to report. In that
1575  case, just report a simple "syntax error".
1576  - Don't assume there isn't a lookahead just because this state is a
1577  consistent state with a default action. There might have been a
1578  previous inconsistent state, consistent state with a non-default
1579  action, or user semantic action that manipulated yychar.
1580  - Of course, the expected token list depends on states to have
1581  correct lookahead information, and it depends on the parser not
1582  to perform extra reductions after fetching a lookahead from the
1583  scanner and before detecting a syntax error. Thus, state merging
1584  (from LALR or IELR) and default reductions corrupt the expected
1585  token list. However, the list is correct for canonical LR with
1586  one exception: it will still contain any token that will not be
1587  accepted due to an error action in a later state.
1588  */
1589  if (yytoken != YYEMPTY)
1590  {
1591  int yyn = yypact[*yyssp];
1592  yyarg[yycount++] = yytname[yytoken];
1593  if (!yypact_value_is_default (yyn))
1594  {
1595  /* Start YYX at -YYN if negative to avoid negative indexes in
1596  YYCHECK. In other words, skip the first -YYN actions for
1597  this state because they are default actions. */
1598  int yyxbegin = yyn < 0 ? -yyn : 0;
1599  /* Stay within bounds of both yycheck and yytname. */
1600  int yychecklim = YYLAST - yyn + 1;
1601  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1602  int yyx;
1603 
1604  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1605  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1606  && !yytable_value_is_error (yytable[yyx + yyn]))
1607  {
1608  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1609  {
1610  yycount = 1;
1611  yysize = yysize0;
1612  break;
1613  }
1614  yyarg[yycount++] = yytname[yyx];
1615  {
1616  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
1617  if (! (yysize <= yysize1
1618  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1619  return 2;
1620  yysize = yysize1;
1621  }
1622  }
1623  }
1624  }
1625 
1626  switch (yycount)
1627  {
1628 # define YYCASE_(N, S) \
1629  case N: \
1630  yyformat = S; \
1631  break
1632  YYCASE_(0, YY_("syntax error"));
1633  YYCASE_(1, YY_("syntax error, unexpected %s"));
1634  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1635  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1636  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1637  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1638 # undef YYCASE_
1639  }
1640 
1641  {
1642  YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1643  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1644  return 2;
1645  yysize = yysize1;
1646  }
1647 
1648  if (*yymsg_alloc < yysize)
1649  {
1650  *yymsg_alloc = 2 * yysize;
1651  if (! (yysize <= *yymsg_alloc
1652  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1653  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1654  return 1;
1655  }
1656 
1657  /* Avoid sprintf, as that infringes on the user's name space.
1658  Don't have undefined behavior even if the translation
1659  produced a string with the wrong number of "%s"s. */
1660  {
1661  char *yyp = *yymsg;
1662  int yyi = 0;
1663  while ((*yyp = *yyformat) != '\0')
1664  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1665  {
1666  yyp += yytnamerr (yyp, yyarg[yyi++]);
1667  yyformat += 2;
1668  }
1669  else
1670  {
1671  yyp++;
1672  yyformat++;
1673  }
1674  }
1675  return 0;
1676 }
1677 #endif /* YYERROR_VERBOSE */
1678 
1679 /*-----------------------------------------------.
1680 | Release the memory associated to this symbol. |
1681 `-----------------------------------------------*/
1682 
1683 /*ARGSUSED*/
1684 #if (defined __STDC__ || defined __C99__FUNC__ \
1685  || defined __cplusplus || defined _MSC_VER)
1686 static void
1687 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1688 #else
1689 static void
1690 yydestruct (yymsg, yytype, yyvaluep)
1691  const char *yymsg;
1692  int yytype;
1693  YYSTYPE *yyvaluep;
1694 #endif
1695 {
1696  YYUSE (yyvaluep);
1697 
1698  if (!yymsg)
1699  yymsg = "Deleting";
1700  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1701 
1702  YYUSE (yytype);
1703 }
1704 
1705 
1706 
1707 
1708 /* The lookahead symbol. */
1709 int yychar;
1710 
1711 
1712 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1713 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1714 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
1715 #endif
1716 #ifndef YY_INITIAL_VALUE
1717 # define YY_INITIAL_VALUE(Value) /* Nothing. */
1718 #endif
1719 
1720 /* The semantic value of the lookahead symbol. */
1721 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
1722 
1723 /* Number of syntax errors so far. */
1724 int yynerrs;
1725 
1726 
1727 /*----------.
1728 | yyparse. |
1729 `----------*/
1730 
1731 #ifdef YYPARSE_PARAM
1732 #if (defined __STDC__ || defined __C99__FUNC__ \
1733  || defined __cplusplus || defined _MSC_VER)
1734 int
1735 yyparse (void *YYPARSE_PARAM)
1736 #else
1737 int
1738 yyparse (YYPARSE_PARAM)
1739  void *YYPARSE_PARAM;
1740 #endif
1741 #else /* ! YYPARSE_PARAM */
1742 #if (defined __STDC__ || defined __C99__FUNC__ \
1743  || defined __cplusplus || defined _MSC_VER)
1744 int
1745 yyparse (void)
1746 #else
1747 int
1748 yyparse ()
1749 
1750 #endif
1751 #endif
1752 {
1753  int yystate;
1754  /* Number of tokens to shift before error messages enabled. */
1755  int yyerrstatus;
1756 
1757  /* The stacks and their tools:
1758  `yyss': related to states.
1759  `yyvs': related to semantic values.
1760 
1761  Refer to the stacks through separate pointers, to allow yyoverflow
1762  to reallocate them elsewhere. */
1763 
1764  /* The state stack. */
1765  yytype_int16 yyssa[YYINITDEPTH];
1766  yytype_int16 *yyss;
1767  yytype_int16 *yyssp;
1768 
1769  /* The semantic value stack. */
1770  YYSTYPE yyvsa[YYINITDEPTH];
1771  YYSTYPE *yyvs;
1772  YYSTYPE *yyvsp;
1773 
1774  YYSIZE_T yystacksize;
1775 
1776  int yyn;
1777  int yyresult;
1778  /* Lookahead token as an internal (translated) token number. */
1779  int yytoken = 0;
1780  /* The variables used to return semantic value and location from the
1781  action routines. */
1782  YYSTYPE yyval;
1783 
1784 #if YYERROR_VERBOSE
1785  /* Buffer for error messages, and its allocated size. */
1786  char yymsgbuf[128];
1787  char *yymsg = yymsgbuf;
1788  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1789 #endif
1790 
1791 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1792 
1793  /* The number of symbols on the RHS of the reduced rule.
1794  Keep to zero when no symbol should be popped. */
1795  int yylen = 0;
1796 
1797  yyssp = yyss = yyssa;
1798  yyvsp = yyvs = yyvsa;
1799  yystacksize = YYINITDEPTH;
1800 
1801  YYDPRINTF ((stderr, "Starting parse\n"));
1802 
1803  yystate = 0;
1804  yyerrstatus = 0;
1805  yynerrs = 0;
1806  yychar = YYEMPTY; /* Cause a token to be read. */
1807  goto yysetstate;
1808 
1809 /*------------------------------------------------------------.
1810 | yynewstate -- Push a new state, which is found in yystate. |
1811 `------------------------------------------------------------*/
1812  yynewstate:
1813  /* In all cases, when you get here, the value and location stacks
1814  have just been pushed. So pushing a state here evens the stacks. */
1815  yyssp++;
1816 
1817  yysetstate:
1818  *yyssp = yystate;
1819 
1820  if (yyss + yystacksize - 1 <= yyssp)
1821  {
1822  /* Get the current used size of the three stacks, in elements. */
1823  YYSIZE_T yysize = yyssp - yyss + 1;
1824 
1825 #ifdef yyoverflow
1826  {
1827  /* Give user a chance to reallocate the stack. Use copies of
1828  these so that the &'s don't force the real ones into
1829  memory. */
1830  YYSTYPE *yyvs1 = yyvs;
1831  yytype_int16 *yyss1 = yyss;
1832 
1833  /* Each stack pointer address is followed by the size of the
1834  data in use in that stack, in bytes. This used to be a
1835  conditional around just the two extra args, but that might
1836  be undefined if yyoverflow is a macro. */
1837  yyoverflow (YY_("memory exhausted"),
1838  &yyss1, yysize * sizeof (*yyssp),
1839  &yyvs1, yysize * sizeof (*yyvsp),
1840  &yystacksize);
1841 
1842  yyss = yyss1;
1843  yyvs = yyvs1;
1844  }
1845 #else /* no yyoverflow */
1846 # ifndef YYSTACK_RELOCATE
1847  goto yyexhaustedlab;
1848 # else
1849  /* Extend the stack our own way. */
1850  if (YYMAXDEPTH <= yystacksize)
1851  goto yyexhaustedlab;
1852  yystacksize *= 2;
1853  if (YYMAXDEPTH < yystacksize)
1854  yystacksize = YYMAXDEPTH;
1855 
1856  {
1857  yytype_int16 *yyss1 = yyss;
1858  union yyalloc *yyptr =
1859  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1860  if (! yyptr)
1861  goto yyexhaustedlab;
1862  YYSTACK_RELOCATE (yyss_alloc, yyss);
1863  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1864 # undef YYSTACK_RELOCATE
1865  if (yyss1 != yyssa)
1866  YYSTACK_FREE (yyss1);
1867  }
1868 # endif
1869 #endif /* no yyoverflow */
1870 
1871  yyssp = yyss + yysize - 1;
1872  yyvsp = yyvs + yysize - 1;
1873 
1874  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1875  (unsigned long int) yystacksize));
1876 
1877  if (yyss + yystacksize - 1 <= yyssp)
1878  YYABORT;
1879  }
1880 
1881  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1882 
1883  if (yystate == YYFINAL)
1884  YYACCEPT;
1885 
1886  goto yybackup;
1887 
1888 /*-----------.
1889 | yybackup. |
1890 `-----------*/
1891 yybackup:
1892 
1893  /* Do appropriate processing given the current state. Read a
1894  lookahead token if we need one and don't already have one. */
1895 
1896  /* First try to decide what to do without reference to lookahead token. */
1897  yyn = yypact[yystate];
1898  if (yypact_value_is_default (yyn))
1899  goto yydefault;
1900 
1901  /* Not known => get a lookahead token if don't already have one. */
1902 
1903  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1904  if (yychar == YYEMPTY)
1905  {
1906  YYDPRINTF ((stderr, "Reading a token: "));
1907  yychar = YYLEX;
1908  }
1909 
1910  if (yychar <= YYEOF)
1911  {
1912  yychar = yytoken = YYEOF;
1913  YYDPRINTF ((stderr, "Now at end of input.\n"));
1914  }
1915  else
1916  {
1917  yytoken = YYTRANSLATE (yychar);
1918  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1919  }
1920 
1921  /* If the proper action on seeing token YYTOKEN is to reduce or to
1922  detect an error, take that action. */
1923  yyn += yytoken;
1924  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1925  goto yydefault;
1926  yyn = yytable[yyn];
1927  if (yyn <= 0)
1928  {
1929  if (yytable_value_is_error (yyn))
1930  goto yyerrlab;
1931  yyn = -yyn;
1932  goto yyreduce;
1933  }
1934 
1935  /* Count tokens shifted since error; after three, turn off error
1936  status. */
1937  if (yyerrstatus)
1938  yyerrstatus--;
1939 
1940  /* Shift the lookahead token. */
1941  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1942 
1943  /* Discard the shifted token. */
1944  yychar = YYEMPTY;
1945 
1946  yystate = yyn;
1947  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1948  *++yyvsp = yylval;
1949  YY_IGNORE_MAYBE_UNINITIALIZED_END
1950 
1951  goto yynewstate;
1952 
1953 
1954 /*-----------------------------------------------------------.
1955 | yydefault -- do the default action for the current state. |
1956 `-----------------------------------------------------------*/
1957 yydefault:
1958  yyn = yydefact[yystate];
1959  if (yyn == 0)
1960  goto yyerrlab;
1961  goto yyreduce;
1962 
1963 
1964 /*-----------------------------.
1965 | yyreduce -- Do a reduction. |
1966 `-----------------------------*/
1967 yyreduce:
1968  /* yyn is the number of a rule to reduce with. */
1969  yylen = yyr2[yyn];
1970 
1971  /* If YYLEN is nonzero, implement the default value of the action:
1972  `$$ = $1'.
1973 
1974  Otherwise, the following line sets YYVAL to garbage.
1975  This behavior is undocumented and Bison
1976  users should not rely upon it. Assigning to YYVAL
1977  unconditionally makes the parser a bit smaller, and it avoids a
1978  GCC warning that YYVAL may be used uninitialized. */
1979  yyval = yyvsp[1-yylen];
1980 
1981 
1982  YY_REDUCE_PRINT (yyn);
1983  switch (yyn)
1984  {
1985  case 2:
1986 /* Line 1787 of yacc.c */
1987 #line 310 "parser/faustparser.y"
1988  { (yyval.exp) = (yyvsp[(1) - (1)].exp); gResult = formatDefinitions((yyval.exp)); }
1989  break;
1990 
1991  case 3:
1992 /* Line 1787 of yacc.c */
1993 #line 313 "parser/faustparser.y"
1994  { (yyval.exp) = nil; }
1995  break;
1996 
1997  case 4:
1998 /* Line 1787 of yacc.c */
1999 #line 314 "parser/faustparser.y"
2000  { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); }
2001  break;
2002 
2003  case 5:
2004 /* Line 1787 of yacc.c */
2005 #line 316 "parser/faustparser.y"
2006  { (yyval.exp) = nil; }
2007  break;
2008 
2009  case 6:
2010 /* Line 1787 of yacc.c */
2011 #line 317 "parser/faustparser.y"
2012  { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); }
2013  break;
2014 
2015  case 7:
2016 /* Line 1787 of yacc.c */
2017 #line 324 "parser/faustparser.y"
2018  { gWaveForm.push_back((yyvsp[(1) - (1)].exp)); }
2019  break;
2020 
2021  case 8:
2022 /* Line 1787 of yacc.c */
2023 #line 325 "parser/faustparser.y"
2024  { gWaveForm.push_back((yyvsp[(3) - (3)].exp)); }
2025  break;
2026 
2027  case 9:
2028 /* Line 1787 of yacc.c */
2029 #line 328 "parser/faustparser.y"
2030  { (yyval.exp) = boxInt(atoi(yytext)); }
2031  break;
2032 
2033  case 10:
2034 /* Line 1787 of yacc.c */
2035 #line 329 "parser/faustparser.y"
2036  { (yyval.exp) = boxReal(atof(yytext)); }
2037  break;
2038 
2039  case 11:
2040 /* Line 1787 of yacc.c */
2041 #line 330 "parser/faustparser.y"
2042  { (yyval.exp) = boxInt (atoi(yytext)); }
2043  break;
2044 
2045  case 12:
2046 /* Line 1787 of yacc.c */
2047 #line 331 "parser/faustparser.y"
2048  { (yyval.exp) = boxReal(atof(yytext)); }
2049  break;
2050 
2051  case 13:
2052 /* Line 1787 of yacc.c */
2053 #line 332 "parser/faustparser.y"
2054  { (yyval.exp) = boxInt ( -atoi(yytext) ); }
2055  break;
2056 
2057  case 14:
2058 /* Line 1787 of yacc.c */
2059 #line 333 "parser/faustparser.y"
2060  { (yyval.exp) = boxReal( -atof(yytext) ); }
2061  break;
2062 
2063  case 15:
2064 /* Line 1787 of yacc.c */
2065 #line 337 "parser/faustparser.y"
2066  { (yyval.exp) = importFile((yyvsp[(3) - (5)].exp)); }
2067  break;
2068 
2069  case 16:
2070 /* Line 1787 of yacc.c */
2071 #line 338 "parser/faustparser.y"
2072  { declareMetadata((yyvsp[(2) - (4)].exp),(yyvsp[(3) - (4)].exp)); (yyval.exp) = nil; }
2073  break;
2074 
2075  case 17:
2076 /* Line 1787 of yacc.c */
2077 #line 339 "parser/faustparser.y"
2078  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2079  break;
2080 
2081  case 18:
2082 /* Line 1787 of yacc.c */
2083 #line 340 "parser/faustparser.y"
2084  { declareDoc((yyvsp[(2) - (3)].exp)); (yyval.exp) = nil; /* cerr << "Yacc : doc : " << *$2 << endl; */ }
2085  break;
2086 
2087  case 19:
2088 /* Line 1787 of yacc.c */
2089 #line 343 "parser/faustparser.y"
2090  { (yyval.exp) = nil; }
2091  break;
2092 
2093  case 20:
2094 /* Line 1787 of yacc.c */
2095 #line 344 "parser/faustparser.y"
2096  { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); }
2097  break;
2098 
2099  case 21:
2100 /* Line 1787 of yacc.c */
2101 #line 347 "parser/faustparser.y"
2102  { (yyval.exp) = docTxt((yyvsp[(1) - (1)].cppstr)->c_str()); delete (yyvsp[(1) - (1)].cppstr); }
2103  break;
2104 
2105  case 22:
2106 /* Line 1787 of yacc.c */
2107 #line 348 "parser/faustparser.y"
2108  { (yyval.exp) = docEqn((yyvsp[(1) - (1)].exp)); }
2109  break;
2110 
2111  case 23:
2112 /* Line 1787 of yacc.c */
2113 #line 349 "parser/faustparser.y"
2114  { (yyval.exp) = docDgm((yyvsp[(1) - (1)].exp)); }
2115  break;
2116 
2117  case 24:
2118 /* Line 1787 of yacc.c */
2119 #line 350 "parser/faustparser.y"
2120  { (yyval.exp) = docNtc(); }
2121  break;
2122 
2123  case 25:
2124 /* Line 1787 of yacc.c */
2125 #line 351 "parser/faustparser.y"
2126  { (yyval.exp) = docLst(); }
2127  break;
2128 
2129  case 26:
2130 /* Line 1787 of yacc.c */
2131 #line 352 "parser/faustparser.y"
2132  { (yyval.exp) = docMtd((yyvsp[(1) - (1)].exp)); }
2133  break;
2134 
2135  case 27:
2136 /* Line 1787 of yacc.c */
2137 #line 355 "parser/faustparser.y"
2138  { (yyval.cppstr) = new string(); }
2139  break;
2140 
2141  case 28:
2142 /* Line 1787 of yacc.c */
2143 #line 356 "parser/faustparser.y"
2144  { (yyval.cppstr) = &((yyvsp[(1) - (2)].cppstr)->append(yytext)); }
2145  break;
2146 
2147  case 29:
2148 /* Line 1787 of yacc.c */
2149 #line 359 "parser/faustparser.y"
2150  { (yyval.exp) = (yyvsp[(2) - (3)].exp); }
2151  break;
2152 
2153  case 30:
2154 /* Line 1787 of yacc.c */
2155 #line 362 "parser/faustparser.y"
2156  { (yyval.exp) = (yyvsp[(2) - (3)].exp); }
2157  break;
2158 
2159  case 31:
2160 /* Line 1787 of yacc.c */
2161 #line 365 "parser/faustparser.y"
2162  { }
2163  break;
2164 
2165  case 32:
2166 /* Line 1787 of yacc.c */
2167 #line 368 "parser/faustparser.y"
2168  { }
2169  break;
2170 
2171  case 33:
2172 /* Line 1787 of yacc.c */
2173 #line 371 "parser/faustparser.y"
2174  { }
2175  break;
2176 
2177  case 34:
2178 /* Line 1787 of yacc.c */
2179 #line 372 "parser/faustparser.y"
2180  { }
2181  break;
2182 
2183  case 35:
2184 /* Line 1787 of yacc.c */
2185 #line 375 "parser/faustparser.y"
2186  { gLstDependenciesSwitch = (yyvsp[(4) - (5)].b); }
2187  break;
2188 
2189  case 36:
2190 /* Line 1787 of yacc.c */
2191 #line 376 "parser/faustparser.y"
2192  { gStripDocSwitch = (yyvsp[(4) - (5)].b); gStripDocSwitch==true ? gStripDocSwitch=false : gStripDocSwitch=true; }
2193  break;
2194 
2195  case 37:
2196 /* Line 1787 of yacc.c */
2197 #line 377 "parser/faustparser.y"
2198  { gLstDistributedSwitch = (yyvsp[(4) - (5)].b); }
2199  break;
2200 
2201  case 38:
2202 /* Line 1787 of yacc.c */
2203 #line 380 "parser/faustparser.y"
2204  { (yyval.b) = true; }
2205  break;
2206 
2207  case 39:
2208 /* Line 1787 of yacc.c */
2209 #line 381 "parser/faustparser.y"
2210  { (yyval.b) = false; }
2211  break;
2212 
2213  case 40:
2214 /* Line 1787 of yacc.c */
2215 #line 384 "parser/faustparser.y"
2216  { (yyval.exp) = (yyvsp[(2) - (3)].exp); }
2217  break;
2218 
2219  case 41:
2220 /* Line 1787 of yacc.c */
2221 #line 387 "parser/faustparser.y"
2222  { (yyval.exp) = cons((yyvsp[(1) - (7)].exp),cons((yyvsp[(3) - (7)].exp),(yyvsp[(6) - (7)].exp))); }
2223  break;
2224 
2225  case 42:
2226 /* Line 1787 of yacc.c */
2227 #line 388 "parser/faustparser.y"
2228  { (yyval.exp) = cons((yyvsp[(1) - (4)].exp),cons(nil,(yyvsp[(3) - (4)].exp))); }
2229  break;
2230 
2231  case 43:
2232 /* Line 1787 of yacc.c */
2233 #line 389 "parser/faustparser.y"
2234  { (yyval.exp) = nil; yyerr++; }
2235  break;
2236 
2237  case 44:
2238 /* Line 1787 of yacc.c */
2239 #line 392 "parser/faustparser.y"
2240  { (yyval.exp)=(yyvsp[(1) - (1)].exp); setDefProp((yyvsp[(1) - (1)].exp), yyfilename, yylineno); }
2241  break;
2242 
2243  case 45:
2244 /* Line 1787 of yacc.c */
2245 #line 395 "parser/faustparser.y"
2246  { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); }
2247  break;
2248 
2249  case 46:
2250 /* Line 1787 of yacc.c */
2251 #line 396 "parser/faustparser.y"
2252  { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); }
2253  break;
2254 
2255  case 47:
2256 /* Line 1787 of yacc.c */
2257 #line 399 "parser/faustparser.y"
2258  { (yyval.exp) = boxWithLocalDef((yyvsp[(1) - (5)].exp),formatDefinitions((yyvsp[(4) - (5)].exp))); }
2259  break;
2260 
2261  case 48:
2262 /* Line 1787 of yacc.c */
2263 #line 400 "parser/faustparser.y"
2264  { (yyval.exp) = boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
2265  break;
2266 
2267  case 49:
2268 /* Line 1787 of yacc.c */
2269 #line 401 "parser/faustparser.y"
2270  { (yyval.exp) = boxSeq((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
2271  break;
2272 
2273  case 50:
2274 /* Line 1787 of yacc.c */
2275 #line 402 "parser/faustparser.y"
2276  { (yyval.exp) = boxSplit((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
2277  break;
2278 
2279  case 51:
2280 /* Line 1787 of yacc.c */
2281 #line 403 "parser/faustparser.y"
2282  { (yyval.exp) = boxMerge((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
2283  break;
2284 
2285  case 52:
2286 /* Line 1787 of yacc.c */
2287 #line 404 "parser/faustparser.y"
2288  { (yyval.exp) = boxRec((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
2289  break;
2290 
2291  case 53:
2292 /* Line 1787 of yacc.c */
2293 #line 405 "parser/faustparser.y"
2294  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2295  break;
2296 
2297  case 54:
2298 /* Line 1787 of yacc.c */
2299 #line 408 "parser/faustparser.y"
2300  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigAdd)); }
2301  break;
2302 
2303  case 55:
2304 /* Line 1787 of yacc.c */
2305 #line 409 "parser/faustparser.y"
2306  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigSub)); }
2307  break;
2308 
2309  case 56:
2310 /* Line 1787 of yacc.c */
2311 #line 410 "parser/faustparser.y"
2312  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigMul)); }
2313  break;
2314 
2315  case 57:
2316 /* Line 1787 of yacc.c */
2317 #line 411 "parser/faustparser.y"
2318  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigDiv)); }
2319  break;
2320 
2321  case 58:
2322 /* Line 1787 of yacc.c */
2323 #line 412 "parser/faustparser.y"
2324  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigRem)); }
2325  break;
2326 
2327  case 59:
2328 /* Line 1787 of yacc.c */
2329 #line 413 "parser/faustparser.y"
2330  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),gPowPrim->box()); }
2331  break;
2332 
2333  case 60:
2334 /* Line 1787 of yacc.c */
2335 #line 414 "parser/faustparser.y"
2336  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigFixDelay)); }
2337  break;
2338 
2339  case 61:
2340 /* Line 1787 of yacc.c */
2341 #line 415 "parser/faustparser.y"
2342  { (yyval.exp) = boxSeq((yyvsp[(1) - (2)].exp),boxPrim1(sigDelay1)); }
2343  break;
2344 
2345  case 62:
2346 /* Line 1787 of yacc.c */
2347 #line 416 "parser/faustparser.y"
2348  { (yyval.exp) = boxAccess((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
2349  break;
2350 
2351  case 63:
2352 /* Line 1787 of yacc.c */
2353 #line 418 "parser/faustparser.y"
2354  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigAND)); }
2355  break;
2356 
2357  case 64:
2358 /* Line 1787 of yacc.c */
2359 #line 419 "parser/faustparser.y"
2360  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigOR)); }
2361  break;
2362 
2363  case 65:
2364 /* Line 1787 of yacc.c */
2365 #line 420 "parser/faustparser.y"
2366  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigXOR)); }
2367  break;
2368 
2369  case 66:
2370 /* Line 1787 of yacc.c */
2371 #line 422 "parser/faustparser.y"
2372  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLeftShift)); }
2373  break;
2374 
2375  case 67:
2376 /* Line 1787 of yacc.c */
2377 #line 423 "parser/faustparser.y"
2378  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigRightShift)); }
2379  break;
2380 
2381  case 68:
2382 /* Line 1787 of yacc.c */
2383 #line 425 "parser/faustparser.y"
2384  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLT)); }
2385  break;
2386 
2387  case 69:
2388 /* Line 1787 of yacc.c */
2389 #line 426 "parser/faustparser.y"
2390  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLE)); }
2391  break;
2392 
2393  case 70:
2394 /* Line 1787 of yacc.c */
2395 #line 427 "parser/faustparser.y"
2396  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigGT)); }
2397  break;
2398 
2399  case 71:
2400 /* Line 1787 of yacc.c */
2401 #line 428 "parser/faustparser.y"
2402  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigGE)); }
2403  break;
2404 
2405  case 72:
2406 /* Line 1787 of yacc.c */
2407 #line 429 "parser/faustparser.y"
2408  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigEQ)); }
2409  break;
2410 
2411  case 73:
2412 /* Line 1787 of yacc.c */
2413 #line 430 "parser/faustparser.y"
2414  { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigNE)); }
2415  break;
2416 
2417  case 74:
2418 /* Line 1787 of yacc.c */
2419 #line 432 "parser/faustparser.y"
2420  { (yyval.exp) = buildBoxAppl((yyvsp[(1) - (4)].exp),(yyvsp[(3) - (4)].exp)); }
2421  break;
2422 
2423  case 75:
2424 /* Line 1787 of yacc.c */
2425 #line 433 "parser/faustparser.y"
2426  { (yyval.exp) = boxModifLocalDef((yyvsp[(1) - (4)].exp),formatDefinitions((yyvsp[(3) - (4)].exp))); }
2427  break;
2428 
2429  case 76:
2430 /* Line 1787 of yacc.c */
2431 #line 435 "parser/faustparser.y"
2432  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2433  break;
2434 
2435  case 77:
2436 /* Line 1787 of yacc.c */
2437 #line 438 "parser/faustparser.y"
2438  { (yyval.exp) = boxInt(atoi(yytext)); }
2439  break;
2440 
2441  case 78:
2442 /* Line 1787 of yacc.c */
2443 #line 439 "parser/faustparser.y"
2444  { (yyval.exp) = boxReal(atof(yytext)); }
2445  break;
2446 
2447  case 79:
2448 /* Line 1787 of yacc.c */
2449 #line 441 "parser/faustparser.y"
2450  { (yyval.exp) = boxInt (atoi(yytext)); }
2451  break;
2452 
2453  case 80:
2454 /* Line 1787 of yacc.c */
2455 #line 442 "parser/faustparser.y"
2456  { (yyval.exp) = boxReal(atof(yytext)); }
2457  break;
2458 
2459  case 81:
2460 /* Line 1787 of yacc.c */
2461 #line 444 "parser/faustparser.y"
2462  { (yyval.exp) = boxInt ( -atoi(yytext) ); }
2463  break;
2464 
2465  case 82:
2466 /* Line 1787 of yacc.c */
2467 #line 445 "parser/faustparser.y"
2468  { (yyval.exp) = boxReal( -atof(yytext) ); }
2469  break;
2470 
2471  case 83:
2472 /* Line 1787 of yacc.c */
2473 #line 447 "parser/faustparser.y"
2474  { (yyval.exp) = boxWire(); }
2475  break;
2476 
2477  case 84:
2478 /* Line 1787 of yacc.c */
2479 #line 448 "parser/faustparser.y"
2480  { (yyval.exp) = boxCut(); }
2481  break;
2482 
2483  case 85:
2484 /* Line 1787 of yacc.c */
2485 #line 450 "parser/faustparser.y"
2486  { (yyval.exp) = boxPrim1(sigDelay1); }
2487  break;
2488 
2489  case 86:
2490 /* Line 1787 of yacc.c */
2491 #line 451 "parser/faustparser.y"
2492  { (yyval.exp) = boxPrim2(sigPrefix); }
2493  break;
2494 
2495  case 87:
2496 /* Line 1787 of yacc.c */
2497 #line 453 "parser/faustparser.y"
2498  { (yyval.exp) = boxPrim1(sigIntCast); }
2499  break;
2500 
2501  case 88:
2502 /* Line 1787 of yacc.c */
2503 #line 454 "parser/faustparser.y"
2504  { (yyval.exp) = boxPrim1(sigFloatCast); }
2505  break;
2506 
2507  case 89:
2508 /* Line 1787 of yacc.c */
2509 #line 456 "parser/faustparser.y"
2510  { (yyval.exp) = boxPrim2(sigAdd); }
2511  break;
2512 
2513  case 90:
2514 /* Line 1787 of yacc.c */
2515 #line 457 "parser/faustparser.y"
2516  { (yyval.exp) = boxPrim2(sigSub); }
2517  break;
2518 
2519  case 91:
2520 /* Line 1787 of yacc.c */
2521 #line 458 "parser/faustparser.y"
2522  { (yyval.exp) = boxPrim2(sigMul); }
2523  break;
2524 
2525  case 92:
2526 /* Line 1787 of yacc.c */
2527 #line 459 "parser/faustparser.y"
2528  { (yyval.exp) = boxPrim2(sigDiv); }
2529  break;
2530 
2531  case 93:
2532 /* Line 1787 of yacc.c */
2533 #line 460 "parser/faustparser.y"
2534  { (yyval.exp) = boxPrim2(sigRem); }
2535  break;
2536 
2537  case 94:
2538 /* Line 1787 of yacc.c */
2539 #line 461 "parser/faustparser.y"
2540  { (yyval.exp) = boxPrim2(sigFixDelay); }
2541  break;
2542 
2543  case 95:
2544 /* Line 1787 of yacc.c */
2545 #line 463 "parser/faustparser.y"
2546  { (yyval.exp) = boxPrim2(sigAND); }
2547  break;
2548 
2549  case 96:
2550 /* Line 1787 of yacc.c */
2551 #line 464 "parser/faustparser.y"
2552  { (yyval.exp) = boxPrim2(sigOR); }
2553  break;
2554 
2555  case 97:
2556 /* Line 1787 of yacc.c */
2557 #line 465 "parser/faustparser.y"
2558  { (yyval.exp) = boxPrim2(sigXOR); }
2559  break;
2560 
2561  case 98:
2562 /* Line 1787 of yacc.c */
2563 #line 467 "parser/faustparser.y"
2564  { (yyval.exp) = boxPrim2(sigLeftShift); }
2565  break;
2566 
2567  case 99:
2568 /* Line 1787 of yacc.c */
2569 #line 468 "parser/faustparser.y"
2570  { (yyval.exp) = boxPrim2(sigRightShift); }
2571  break;
2572 
2573  case 100:
2574 /* Line 1787 of yacc.c */
2575 #line 470 "parser/faustparser.y"
2576  { (yyval.exp) = boxPrim2(sigLT); }
2577  break;
2578 
2579  case 101:
2580 /* Line 1787 of yacc.c */
2581 #line 471 "parser/faustparser.y"
2582  { (yyval.exp) = boxPrim2(sigLE); }
2583  break;
2584 
2585  case 102:
2586 /* Line 1787 of yacc.c */
2587 #line 472 "parser/faustparser.y"
2588  { (yyval.exp) = boxPrim2(sigGT); }
2589  break;
2590 
2591  case 103:
2592 /* Line 1787 of yacc.c */
2593 #line 473 "parser/faustparser.y"
2594  { (yyval.exp) = boxPrim2(sigGE); }
2595  break;
2596 
2597  case 104:
2598 /* Line 1787 of yacc.c */
2599 #line 474 "parser/faustparser.y"
2600  { (yyval.exp) = boxPrim2(sigEQ); }
2601  break;
2602 
2603  case 105:
2604 /* Line 1787 of yacc.c */
2605 #line 475 "parser/faustparser.y"
2606  { (yyval.exp) = boxPrim2(sigNE); }
2607  break;
2608 
2609  case 106:
2610 /* Line 1787 of yacc.c */
2611 #line 477 "parser/faustparser.y"
2612  { (yyval.exp) = boxPrim2(sigAttach); }
2613  break;
2614 
2615  case 107:
2616 /* Line 1787 of yacc.c */
2617 #line 479 "parser/faustparser.y"
2618  { (yyval.exp) = gAcosPrim->box(); }
2619  break;
2620 
2621  case 108:
2622 /* Line 1787 of yacc.c */
2623 #line 480 "parser/faustparser.y"
2624  { (yyval.exp) = gAsinPrim->box(); }
2625  break;
2626 
2627  case 109:
2628 /* Line 1787 of yacc.c */
2629 #line 481 "parser/faustparser.y"
2630  { (yyval.exp) = gAtanPrim->box(); }
2631  break;
2632 
2633  case 110:
2634 /* Line 1787 of yacc.c */
2635 #line 482 "parser/faustparser.y"
2636  { (yyval.exp) = gAtan2Prim->box(); }
2637  break;
2638 
2639  case 111:
2640 /* Line 1787 of yacc.c */
2641 #line 483 "parser/faustparser.y"
2642  { (yyval.exp) = gCosPrim->box(); }
2643  break;
2644 
2645  case 112:
2646 /* Line 1787 of yacc.c */
2647 #line 484 "parser/faustparser.y"
2648  { (yyval.exp) = gSinPrim->box(); }
2649  break;
2650 
2651  case 113:
2652 /* Line 1787 of yacc.c */
2653 #line 485 "parser/faustparser.y"
2654  { (yyval.exp) = gTanPrim->box(); }
2655  break;
2656 
2657  case 114:
2658 /* Line 1787 of yacc.c */
2659 #line 487 "parser/faustparser.y"
2660  { (yyval.exp) = gExpPrim->box(); }
2661  break;
2662 
2663  case 115:
2664 /* Line 1787 of yacc.c */
2665 #line 488 "parser/faustparser.y"
2666  { (yyval.exp) = gLogPrim->box(); }
2667  break;
2668 
2669  case 116:
2670 /* Line 1787 of yacc.c */
2671 #line 489 "parser/faustparser.y"
2672  { (yyval.exp) = gLog10Prim->box(); }
2673  break;
2674 
2675  case 117:
2676 /* Line 1787 of yacc.c */
2677 #line 490 "parser/faustparser.y"
2678  { (yyval.exp) = gPowPrim->box(); }
2679  break;
2680 
2681  case 118:
2682 /* Line 1787 of yacc.c */
2683 #line 491 "parser/faustparser.y"
2684  { (yyval.exp) = gPowPrim->box(); }
2685  break;
2686 
2687  case 119:
2688 /* Line 1787 of yacc.c */
2689 #line 492 "parser/faustparser.y"
2690  { (yyval.exp) = gSqrtPrim->box(); }
2691  break;
2692 
2693  case 120:
2694 /* Line 1787 of yacc.c */
2695 #line 494 "parser/faustparser.y"
2696  { (yyval.exp) = gAbsPrim->box(); }
2697  break;
2698 
2699  case 121:
2700 /* Line 1787 of yacc.c */
2701 #line 495 "parser/faustparser.y"
2702  { (yyval.exp) = gMinPrim->box(); }
2703  break;
2704 
2705  case 122:
2706 /* Line 1787 of yacc.c */
2707 #line 496 "parser/faustparser.y"
2708  { (yyval.exp) = gMaxPrim->box(); }
2709  break;
2710 
2711  case 123:
2712 /* Line 1787 of yacc.c */
2713 #line 498 "parser/faustparser.y"
2714  { (yyval.exp) = gFmodPrim->box(); }
2715  break;
2716 
2717  case 124:
2718 /* Line 1787 of yacc.c */
2719 #line 499 "parser/faustparser.y"
2720  { (yyval.exp) = gRemainderPrim->box(); }
2721  break;
2722 
2723  case 125:
2724 /* Line 1787 of yacc.c */
2725 #line 501 "parser/faustparser.y"
2726  { (yyval.exp) = gFloorPrim->box(); }
2727  break;
2728 
2729  case 126:
2730 /* Line 1787 of yacc.c */
2731 #line 502 "parser/faustparser.y"
2732  { (yyval.exp) = gCeilPrim->box(); }
2733  break;
2734 
2735  case 127:
2736 /* Line 1787 of yacc.c */
2737 #line 503 "parser/faustparser.y"
2738  { (yyval.exp) = gRintPrim->box(); }
2739  break;
2740 
2741  case 128:
2742 /* Line 1787 of yacc.c */
2743 #line 506 "parser/faustparser.y"
2744  { (yyval.exp) = boxPrim3(sigReadOnlyTable); }
2745  break;
2746 
2747  case 129:
2748 /* Line 1787 of yacc.c */
2749 #line 507 "parser/faustparser.y"
2750  { (yyval.exp) = boxPrim5(sigWriteReadTable); }
2751  break;
2752 
2753  case 130:
2754 /* Line 1787 of yacc.c */
2755 #line 509 "parser/faustparser.y"
2756  { (yyval.exp) = boxPrim3(sigSelect2); }
2757  break;
2758 
2759  case 131:
2760 /* Line 1787 of yacc.c */
2761 #line 510 "parser/faustparser.y"
2762  { (yyval.exp) = boxPrim4(sigSelect3); }
2763  break;
2764 
2765  case 132:
2766 /* Line 1787 of yacc.c */
2767 #line 512 "parser/faustparser.y"
2768  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2769  break;
2770 
2771  case 133:
2772 /* Line 1787 of yacc.c */
2773 #line 513 "parser/faustparser.y"
2774  { (yyval.exp) = boxSeq(boxPar(boxInt(0),(yyvsp[(2) - (2)].exp)),boxPrim2(sigSub)); }
2775  break;
2776 
2777  case 134:
2778 /* Line 1787 of yacc.c */
2779 #line 515 "parser/faustparser.y"
2780  { (yyval.exp) = (yyvsp[(2) - (3)].exp); }
2781  break;
2782 
2783  case 135:
2784 /* Line 1787 of yacc.c */
2785 #line 517 "parser/faustparser.y"
2786  { (yyval.exp) = buildBoxAbstr((yyvsp[(3) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
2787  break;
2788 
2789  case 136:
2790 /* Line 1787 of yacc.c */
2791 #line 519 "parser/faustparser.y"
2792  { (yyval.exp) = boxCase(checkRulelist((yyvsp[(3) - (4)].exp))); }
2793  break;
2794 
2795  case 137:
2796 /* Line 1787 of yacc.c */
2797 #line 521 "parser/faustparser.y"
2798  { (yyval.exp) = boxFFun((yyvsp[(1) - (1)].exp)); }
2799  break;
2800 
2801  case 138:
2802 /* Line 1787 of yacc.c */
2803 #line 522 "parser/faustparser.y"
2804  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2805  break;
2806 
2807  case 139:
2808 /* Line 1787 of yacc.c */
2809 #line 523 "parser/faustparser.y"
2810  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2811  break;
2812 
2813  case 140:
2814 /* Line 1787 of yacc.c */
2815 #line 524 "parser/faustparser.y"
2816  { (yyval.exp) = boxComponent((yyvsp[(3) - (4)].exp)); }
2817  break;
2818 
2819  case 141:
2820 /* Line 1787 of yacc.c */
2821 #line 525 "parser/faustparser.y"
2822  { (yyval.exp) = boxLibrary((yyvsp[(3) - (4)].exp)); }
2823  break;
2824 
2825  case 142:
2826 /* Line 1787 of yacc.c */
2827 #line 526 "parser/faustparser.y"
2828  { (yyval.exp) = boxWithLocalDef(boxEnvironment(),formatDefinitions((yyvsp[(3) - (4)].exp))); }
2829  break;
2830 
2831  case 143:
2832 /* Line 1787 of yacc.c */
2833 #line 527 "parser/faustparser.y"
2834  { (yyval.exp) = boxWaveform(gWaveForm); gWaveForm.clear(); }
2835  break;
2836 
2837  case 144:
2838 /* Line 1787 of yacc.c */
2839 #line 529 "parser/faustparser.y"
2840  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2841  break;
2842 
2843  case 145:
2844 /* Line 1787 of yacc.c */
2845 #line 530 "parser/faustparser.y"
2846  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2847  break;
2848 
2849  case 146:
2850 /* Line 1787 of yacc.c */
2851 #line 531 "parser/faustparser.y"
2852  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2853  break;
2854 
2855  case 147:
2856 /* Line 1787 of yacc.c */
2857 #line 532 "parser/faustparser.y"
2858  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2859  break;
2860 
2861  case 148:
2862 /* Line 1787 of yacc.c */
2863 #line 533 "parser/faustparser.y"
2864  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2865  break;
2866 
2867  case 149:
2868 /* Line 1787 of yacc.c */
2869 #line 534 "parser/faustparser.y"
2870  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2871  break;
2872 
2873  case 150:
2874 /* Line 1787 of yacc.c */
2875 #line 535 "parser/faustparser.y"
2876  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2877  break;
2878 
2879  case 151:
2880 /* Line 1787 of yacc.c */
2881 #line 536 "parser/faustparser.y"
2882  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2883  break;
2884 
2885  case 152:
2886 /* Line 1787 of yacc.c */
2887 #line 537 "parser/faustparser.y"
2888  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2889  break;
2890 
2891  case 153:
2892 /* Line 1787 of yacc.c */
2893 #line 538 "parser/faustparser.y"
2894  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2895  break;
2896 
2897  case 154:
2898 /* Line 1787 of yacc.c */
2899 #line 540 "parser/faustparser.y"
2900  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2901  break;
2902 
2903  case 155:
2904 /* Line 1787 of yacc.c */
2905 #line 541 "parser/faustparser.y"
2906  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2907  break;
2908 
2909  case 156:
2910 /* Line 1787 of yacc.c */
2911 #line 542 "parser/faustparser.y"
2912  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2913  break;
2914 
2915  case 157:
2916 /* Line 1787 of yacc.c */
2917 #line 543 "parser/faustparser.y"
2918  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2919  break;
2920 
2921  case 158:
2922 /* Line 1787 of yacc.c */
2923 #line 545 "parser/faustparser.y"
2924  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2925  break;
2926 
2927  case 159:
2928 /* Line 1787 of yacc.c */
2929 #line 546 "parser/faustparser.y"
2930  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2931  break;
2932 
2933  case 160:
2934 /* Line 1787 of yacc.c */
2935 #line 551 "parser/faustparser.y"
2936  { (yyval.exp) = boxIdent(yytext); }
2937  break;
2938 
2939  case 161:
2940 /* Line 1787 of yacc.c */
2941 #line 554 "parser/faustparser.y"
2942  { (yyval.exp) = tree(yytext); }
2943  break;
2944 
2945  case 162:
2946 /* Line 1787 of yacc.c */
2947 #line 559 "parser/faustparser.y"
2948  { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); }
2949  break;
2950 
2951  case 163:
2952 /* Line 1787 of yacc.c */
2953 #line 560 "parser/faustparser.y"
2954  { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); }
2955  break;
2956 
2957  case 164:
2958 /* Line 1787 of yacc.c */
2959 #line 563 "parser/faustparser.y"
2960  { (yyval.exp) = boxSeq((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
2961  break;
2962 
2963  case 165:
2964 /* Line 1787 of yacc.c */
2965 #line 564 "parser/faustparser.y"
2966  { (yyval.exp) = boxSplit((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
2967  break;
2968 
2969  case 166:
2970 /* Line 1787 of yacc.c */
2971 #line 565 "parser/faustparser.y"
2972  { (yyval.exp) = boxMerge((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
2973  break;
2974 
2975  case 167:
2976 /* Line 1787 of yacc.c */
2977 #line 566 "parser/faustparser.y"
2978  { (yyval.exp) = boxRec((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); }
2979  break;
2980 
2981  case 168:
2982 /* Line 1787 of yacc.c */
2983 #line 567 "parser/faustparser.y"
2984  { (yyval.exp) = (yyvsp[(1) - (1)].exp); }
2985  break;
2986 
2987  case 169:
2988 /* Line 1787 of yacc.c */
2989 #line 570 "parser/faustparser.y"
2990  { (yyval.exp) = tree(yytext); }
2991  break;
2992 
2993  case 170:
2994 /* Line 1787 of yacc.c */
2995 #line 573 "parser/faustparser.y"
2996  { (yyval.exp) = unquote(yytext); }
2997  break;
2998 
2999  case 171:
3000 /* Line 1787 of yacc.c */
3001 #line 576 "parser/faustparser.y"
3002  { (yyval.exp) = tree(yytext); }
3003  break;
3004 
3005  case 172:
3006 /* Line 1787 of yacc.c */
3007 #line 577 "parser/faustparser.y"
3008  { (yyval.exp) = tree(yytext); }
3009  break;
3010 
3011  case 173:
3012 /* Line 1787 of yacc.c */
3013 #line 583 "parser/faustparser.y"
3014  { (yyval.exp) = boxIPar((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
3015  break;
3016 
3017  case 174:
3018 /* Line 1787 of yacc.c */
3019 #line 587 "parser/faustparser.y"
3020  { (yyval.exp) = boxISeq((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
3021  break;
3022 
3023  case 175:
3024 /* Line 1787 of yacc.c */
3025 #line 591 "parser/faustparser.y"
3026  { (yyval.exp) = boxISum((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
3027  break;
3028 
3029  case 176:
3030 /* Line 1787 of yacc.c */
3031 #line 595 "parser/faustparser.y"
3032  { (yyval.exp) = boxIProd((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
3033  break;
3034 
3035  case 177:
3036 /* Line 1787 of yacc.c */
3037 #line 599 "parser/faustparser.y"
3038  { (yyval.exp) = boxInputs((yyvsp[(3) - (4)].exp)); }
3039  break;
3040 
3041  case 178:
3042 /* Line 1787 of yacc.c */
3043 #line 602 "parser/faustparser.y"
3044  { (yyval.exp) = boxOutputs((yyvsp[(3) - (4)].exp)); }
3045  break;
3046 
3047  case 179:
3048 /* Line 1787 of yacc.c */
3049 #line 610 "parser/faustparser.y"
3050  { (yyval.exp) = ffunction((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
3051  break;
3052 
3053  case 180:
3054 /* Line 1787 of yacc.c */
3055 #line 614 "parser/faustparser.y"
3056  { (yyval.exp) = boxFConst((yyvsp[(3) - (7)].exp),(yyvsp[(4) - (7)].exp),(yyvsp[(6) - (7)].exp)); }
3057  break;
3058 
3059  case 181:
3060 /* Line 1787 of yacc.c */
3061 #line 617 "parser/faustparser.y"
3062  { (yyval.exp) = boxFVar((yyvsp[(3) - (7)].exp),(yyvsp[(4) - (7)].exp),(yyvsp[(6) - (7)].exp)); }
3063  break;
3064 
3065  case 182:
3066 /* Line 1787 of yacc.c */
3067 #line 621 "parser/faustparser.y"
3068  { (yyval.exp) = boxButton((yyvsp[(3) - (4)].exp)); }
3069  break;
3070 
3071  case 183:
3072 /* Line 1787 of yacc.c */
3073 #line 624 "parser/faustparser.y"
3074  { (yyval.exp) = boxCheckbox((yyvsp[(3) - (4)].exp)); }
3075  break;
3076 
3077  case 184:
3078 /* Line 1787 of yacc.c */
3079 #line 628 "parser/faustparser.y"
3080  { (yyval.exp) = boxVSlider((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); }
3081  break;
3082 
3083  case 185:
3084 /* Line 1787 of yacc.c */
3085 #line 631 "parser/faustparser.y"
3086  { (yyval.exp) = boxHSlider((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); }
3087  break;
3088 
3089  case 186:
3090 /* Line 1787 of yacc.c */
3091 #line 634 "parser/faustparser.y"
3092  { (yyval.exp) = boxNumEntry((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); }
3093  break;
3094 
3095  case 187:
3096 /* Line 1787 of yacc.c */
3097 #line 637 "parser/faustparser.y"
3098  { (yyval.exp) = boxVGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); }
3099  break;
3100 
3101  case 188:
3102 /* Line 1787 of yacc.c */
3103 #line 640 "parser/faustparser.y"
3104  { (yyval.exp) = boxHGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); }
3105  break;
3106 
3107  case 189:
3108 /* Line 1787 of yacc.c */
3109 #line 643 "parser/faustparser.y"
3110  { (yyval.exp) = boxTGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); }
3111  break;
3112 
3113  case 190:
3114 /* Line 1787 of yacc.c */
3115 #line 647 "parser/faustparser.y"
3116  { (yyval.exp) = boxVBargraph((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
3117  break;
3118 
3119  case 191:
3120 /* Line 1787 of yacc.c */
3121 #line 650 "parser/faustparser.y"
3122  { (yyval.exp) = boxHBargraph((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); }
3123  break;
3124 
3125  case 192:
3126 /* Line 1787 of yacc.c */
3127 #line 656 "parser/faustparser.y"
3128  { (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))); }
3129  break;
3130 
3131  case 193:
3132 /* Line 1787 of yacc.c */
3133 #line 657 "parser/faustparser.y"
3134  { (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))); }
3135  break;
3136 
3137  case 194:
3138 /* Line 1787 of yacc.c */
3139 #line 658 "parser/faustparser.y"
3140  { (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))); }
3141  break;
3142 
3143  case 195:
3144 /* Line 1787 of yacc.c */
3145 #line 660 "parser/faustparser.y"
3146  { (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)); }
3147  break;
3148 
3149  case 196:
3150 /* Line 1787 of yacc.c */
3151 #line 661 "parser/faustparser.y"
3152  { (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)); }
3153  break;
3154 
3155  case 197:
3156 /* Line 1787 of yacc.c */
3157 #line 662 "parser/faustparser.y"
3158  { (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)); }
3159  break;
3160 
3161  case 198:
3162 /* Line 1787 of yacc.c */
3163 #line 665 "parser/faustparser.y"
3164  { (yyval.exp) = tree(yytext); }
3165  break;
3166 
3167  case 199:
3168 /* Line 1787 of yacc.c */
3169 #line 668 "parser/faustparser.y"
3170  { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); }
3171  break;
3172 
3173  case 200:
3174 /* Line 1787 of yacc.c */
3175 #line 669 "parser/faustparser.y"
3176  { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); }
3177  break;
3178 
3179  case 201:
3180 /* Line 1787 of yacc.c */
3181 #line 672 "parser/faustparser.y"
3182  { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); }
3183  break;
3184 
3185  case 202:
3186 /* Line 1787 of yacc.c */
3187 #line 673 "parser/faustparser.y"
3188  { (yyval.exp) = cons((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); }
3189  break;
3190 
3191  case 203:
3192 /* Line 1787 of yacc.c */
3193 #line 677 "parser/faustparser.y"
3194  { (yyval.exp) = cons((yyvsp[(2) - (6)].exp),(yyvsp[(5) - (6)].exp)); }
3195  break;
3196 
3197  case 204:
3198 /* Line 1787 of yacc.c */
3199 #line 680 "parser/faustparser.y"
3200  { (yyval.exp) = tree(0); }
3201  break;
3202 
3203  case 205:
3204 /* Line 1787 of yacc.c */
3205 #line 681 "parser/faustparser.y"
3206  { (yyval.exp) = tree(1); }
3207  break;
3208 
3209 
3210 /* Line 1787 of yacc.c */
3211 #line 3212 "parser/faustparser.cpp"
3212  default: break;
3213  }
3214  /* User semantic actions sometimes alter yychar, and that requires
3215  that yytoken be updated with the new translation. We take the
3216  approach of translating immediately before every use of yytoken.
3217  One alternative is translating here after every semantic action,
3218  but that translation would be missed if the semantic action invokes
3219  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
3220  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
3221  incorrect destructor might then be invoked immediately. In the
3222  case of YYERROR or YYBACKUP, subsequent parser actions might lead
3223  to an incorrect destructor call or verbose syntax error message
3224  before the lookahead is translated. */
3225  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3226 
3227  YYPOPSTACK (yylen);
3228  yylen = 0;
3229  YY_STACK_PRINT (yyss, yyssp);
3230 
3231  *++yyvsp = yyval;
3232 
3233  /* Now `shift' the result of the reduction. Determine what state
3234  that goes to, based on the state we popped back to and the rule
3235  number reduced by. */
3236 
3237  yyn = yyr1[yyn];
3238 
3239  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3240  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3241  yystate = yytable[yystate];
3242  else
3243  yystate = yydefgoto[yyn - YYNTOKENS];
3244 
3245  goto yynewstate;
3246 
3247 
3248 /*------------------------------------.
3249 | yyerrlab -- here on detecting error |
3250 `------------------------------------*/
3251 yyerrlab:
3252  /* Make sure we have latest lookahead translation. See comments at
3253  user semantic actions for why this is necessary. */
3254  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
3255 
3256  /* If not already recovering from an error, report this error. */
3257  if (!yyerrstatus)
3258  {
3259  ++yynerrs;
3260 #if ! YYERROR_VERBOSE
3261  yyerror (YY_("syntax error"));
3262 #else
3263 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
3264  yyssp, yytoken)
3265  {
3266  char const *yymsgp = YY_("syntax error");
3267  int yysyntax_error_status;
3268  yysyntax_error_status = YYSYNTAX_ERROR;
3269  if (yysyntax_error_status == 0)
3270  yymsgp = yymsg;
3271  else if (yysyntax_error_status == 1)
3272  {
3273  if (yymsg != yymsgbuf)
3274  YYSTACK_FREE (yymsg);
3275  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
3276  if (!yymsg)
3277  {
3278  yymsg = yymsgbuf;
3279  yymsg_alloc = sizeof yymsgbuf;
3280  yysyntax_error_status = 2;
3281  }
3282  else
3283  {
3284  yysyntax_error_status = YYSYNTAX_ERROR;
3285  yymsgp = yymsg;
3286  }
3287  }
3288  yyerror (yymsgp);
3289  if (yysyntax_error_status == 2)
3290  goto yyexhaustedlab;
3291  }
3292 # undef YYSYNTAX_ERROR
3293 #endif
3294  }
3295 
3296 
3297 
3298  if (yyerrstatus == 3)
3299  {
3300  /* If just tried and failed to reuse lookahead token after an
3301  error, discard it. */
3302 
3303  if (yychar <= YYEOF)
3304  {
3305  /* Return failure if at end of input. */
3306  if (yychar == YYEOF)
3307  YYABORT;
3308  }
3309  else
3310  {
3311  yydestruct ("Error: discarding",
3312  yytoken, &yylval);
3313  yychar = YYEMPTY;
3314  }
3315  }
3316 
3317  /* Else will try to reuse lookahead token after shifting the error
3318  token. */
3319  goto yyerrlab1;
3320 
3321 
3322 /*---------------------------------------------------.
3323 | yyerrorlab -- error raised explicitly by YYERROR. |
3324 `---------------------------------------------------*/
3325 yyerrorlab:
3326 
3327  /* Pacify compilers like GCC when the user code never invokes
3328  YYERROR and the label yyerrorlab therefore never appears in user
3329  code. */
3330  if (/*CONSTCOND*/ 0)
3331  goto yyerrorlab;
3332 
3333  /* Do not reclaim the symbols of the rule which action triggered
3334  this YYERROR. */
3335  YYPOPSTACK (yylen);
3336  yylen = 0;
3337  YY_STACK_PRINT (yyss, yyssp);
3338  yystate = *yyssp;
3339  goto yyerrlab1;
3340 
3341 
3342 /*-------------------------------------------------------------.
3343 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3344 `-------------------------------------------------------------*/
3345 yyerrlab1:
3346  yyerrstatus = 3; /* Each real token shifted decrements this. */
3347 
3348  for (;;)
3349  {
3350  yyn = yypact[yystate];
3351  if (!yypact_value_is_default (yyn))
3352  {
3353  yyn += YYTERROR;
3354  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3355  {
3356  yyn = yytable[yyn];
3357  if (0 < yyn)
3358  break;
3359  }
3360  }
3361 
3362  /* Pop the current state because it cannot handle the error token. */
3363  if (yyssp == yyss)
3364  YYABORT;
3365 
3366 
3367  yydestruct ("Error: popping",
3368  yystos[yystate], yyvsp);
3369  YYPOPSTACK (1);
3370  yystate = *yyssp;
3371  YY_STACK_PRINT (yyss, yyssp);
3372  }
3373 
3374  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3375  *++yyvsp = yylval;
3376  YY_IGNORE_MAYBE_UNINITIALIZED_END
3377 
3378 
3379  /* Shift the error token. */
3380  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3381 
3382  yystate = yyn;
3383  goto yynewstate;
3384 
3385 
3386 /*-------------------------------------.
3387 | yyacceptlab -- YYACCEPT comes here. |
3388 `-------------------------------------*/
3389 yyacceptlab:
3390  yyresult = 0;
3391  goto yyreturn;
3392 
3393 /*-----------------------------------.
3394 | yyabortlab -- YYABORT comes here. |
3395 `-----------------------------------*/
3396 yyabortlab:
3397  yyresult = 1;
3398  goto yyreturn;
3399 
3400 #if !defined yyoverflow || YYERROR_VERBOSE
3401 /*-------------------------------------------------.
3402 | yyexhaustedlab -- memory exhaustion comes here. |
3403 `-------------------------------------------------*/
3404 yyexhaustedlab:
3405  yyerror (YY_("memory exhausted"));
3406  yyresult = 2;
3407  /* Fall through. */
3408 #endif
3409 
3410 yyreturn:
3411  if (yychar != YYEMPTY)
3412  {
3413  /* Make sure we have latest lookahead translation. See comments at
3414  user semantic actions for why this is necessary. */
3415  yytoken = YYTRANSLATE (yychar);
3416  yydestruct ("Cleanup: discarding lookahead",
3417  yytoken, &yylval);
3418  }
3419  /* Do not reclaim the symbols of the rule which action triggered
3420  this YYABORT or YYACCEPT. */
3421  YYPOPSTACK (yylen);
3422  YY_STACK_PRINT (yyss, yyssp);
3423  while (yyssp != yyss)
3424  {
3425  yydestruct ("Cleanup: popping",
3426  yystos[*yyssp], yyvsp);
3427  YYPOPSTACK (1);
3428  }
3429 #ifndef yyoverflow
3430  if (yyss != yyssa)
3431  YYSTACK_FREE (yyss);
3432 #endif
3433 #if YYERROR_VERBOSE
3434  if (yymsg != yymsgbuf)
3435  YYSTACK_FREE (yymsg);
3436 #endif
3437  /* Make sure YYID is used. */
3438  return YYID (yyresult);
3439 }
3440 
3441 
3442 /* Line 2050 of yacc.c */
3443 #line 684 "parser/faustparser.y"
3444 
3445 
YYABORT
#define YYABORT
Definition: faustparser.cpp:1203
tree.hh
A tree library with hashconsing and maximal sharing capabilities.
yyrhs
static const yytype_int16 yyrhs[]
Definition: faustparser.cpp:660
sigIntCast
Tree sigIntCast(Tree t)
Definition: signals.cpp:159
boxFVar
Tree boxFVar(Tree type, Tree name, Tree file)
Definition: boxes.cpp:355
sigAND
Tree sigAND(Tree x, Tree y)
Definition: signals.hh:158
yy_symbol_value_print
static void yy_symbol_value_print(yyoutput, yytype, yyvaluep) FILE *yyoutput
yytnamerr
static YYSIZE_T yytnamerr(char *yyres, const char *yystr)
Definition: faustparser.cpp:1500
YYTERROR
#define YYTERROR
Definition: faustparser.cpp:1242
yy_reduce_print
static void yy_reduce_print(yyvsp, yyrule) YYSTYPE *yyvsp
YYDPRINTF
#define YYDPRINTF(Args)
Definition: faustparser.cpp:1267
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition: faustparser.cpp:479
declareMetadata
void declareMetadata(Tree key, Tree value)
Definition: sourcereader.cpp:338
YYPOPSTACK
#define YYPOPSTACK(N)
docMtd
Tree docMtd(Tree x)
Definition: doc.cpp:201
gExpPrim
xtended * gExpPrim
Definition: expprim.cpp:61
ffunction
Tree ffunction(Tree signature, Tree incfile, Tree libfile)
Definition: prim2.cpp:30
yyvaluep
YYSTYPE const *const yyvaluep
Definition: faustparser.cpp:1299
boxPrim5
Tree boxPrim5(prim5 foo)
Definition: boxes.cpp:334
formatDefinitions
Tree formatDefinitions(Tree rldef)
Formats a list of raw definitions represented by triplets into abstractions or pa...
Definition: sourcereader.cpp:149
gLstDistributedSwitch
bool gLstDistributedSwitch
mdoc listing management.
Definition: doc.cpp:115
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: faustparser.cpp:1404
yydefgoto
static const yytype_int16 yydefgoto[]
Definition: faustparser.cpp:923
yylno
unsigned long int yylno
Definition: faustparser.cpp:1390
YYFPRINTF
#define YYFPRINTF
Definition: faustparser.cpp:1264
gRemainderPrim
xtended * gRemainderPrim
Definition: remainderprim.cpp:62
boxCheckbox
Tree boxCheckbox(Tree lbl)
Definition: boxes.cpp:371
boxHBargraph
Tree boxHBargraph(Tree lbl, Tree min, Tree max)
Definition: boxes.cpp:454
gWaveForm
tvec gWaveForm
Definition: main.cpp:94
cons
Tree cons(Tree a, Tree b)
Definition: list.hh:124
sigEQ
Tree sigEQ(Tree x, Tree y)
Definition: signals.hh:169
declareDoc
void declareDoc(Tree t)
Definition: sourcereader.cpp:353
YYFINAL
#define YYFINAL
Definition: faustparser.cpp:568
yytype_uint8
unsigned char yytype_uint8
Definition: faustparser.cpp:350
yyr1
static const yytype_uint8 yyr1[]
Definition: faustparser.cpp:819
boxRec
Tree boxRec(Tree x, Tree y)
Definition: boxes.cpp:143
gAsinPrim
xtended * gAsinPrim
Definition: asinprim.cpp:59
YYSTACK_FREE
#define YYSTACK_FREE
Definition: faustparser.cpp:477
yytable_value_is_error
#define yytable_value_is_error(Yytable_value)
Definition: faustparser.cpp:1073
yyparse
int yyparse()
Definition: faustparser.cpp:1748
YYSTYPE
union YYSTYPE YYSTYPE
sigXOR
Tree sigXOR(Tree x, Tree y)
Definition: signals.hh:160
yy_symbol_print
static void yy_symbol_print(yyoutput, yytype, yyvaluep) FILE *yyoutput
boxNumEntry
Tree boxNumEntry(Tree lbl, Tree cur, Tree min, Tree max, Tree step)
Definition: boxes.cpp:416
boxEnvironment
Tree boxEnvironment()
Definition: boxes.cpp:284
sigGT
Tree sigGT(Tree x, Tree y)
Definition: signals.hh:165
gCosPrim
xtended * gCosPrim
Definition: cosprim.cpp:59
yylex
int yylex()
boxISeq
Tree boxISeq(Tree x, Tree y, Tree z)
Definition: boxes.cpp:165
yyfilename
const char * yyfilename
Definition: errormsg.cpp:30
sigGE
Tree sigGE(Tree x, Tree y)
Definition: signals.hh:167
YYSTYPE::exp
CTree * exp
Definition: faustparser.cpp:306
boxPrim1
Tree boxPrim1(prim1 foo)
Definition: boxes.cpp:314
tvec
vector< Tree > tvec
Definition: tree.hh:90
boxFFun
Tree boxFFun(Tree ff)
Definition: boxes.cpp:343
YYLEX
#define YYLEX
Definition: faustparser.cpp:1256
YYNTOKENS
#define YYNTOKENS
Definition: faustparser.cpp:573
boxPrim3
Tree boxPrim3(prim3 foo)
Definition: boxes.cpp:324
sigSelect2
Tree sigSelect2(Tree selector, Tree s1, Tree s2)
Definition: signals.cpp:115
boxISum
Tree boxISum(Tree x, Tree y, Tree z)
Definition: boxes.cpp:166
CTree
A CTree = (Node x [CTree]) is a Node associated with a list of subtrees called branches.
Definition: tree.hh:109
YYINITDEPTH
#define YYINITDEPTH
Definition: faustparser.cpp:1423
sigWriteReadTable
Tree sigWriteReadTable(Tree n, Tree init, Tree widx, Tree wsig, Tree ridx)
Definition: signals.hh:99
yytype_uint16
unsigned short int yytype_uint16
Definition: faustparser.cpp:365
replaceCR
char replaceCR(char c)
Definition: faustparser.cpp:108
boxVSlider
Tree boxVSlider(Tree lbl, Tree cur, Tree min, Tree max, Tree step)
Definition: boxes.cpp:397
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: faustparser.cpp:1366
boxIdent
Tree boxIdent(const char *name)
Definition: boxes.cpp:57
sigPrefix
Tree sigPrefix(Tree t0, Tree t1)
Definition: signals.cpp:65
YYEMPTY
#define YYEMPTY
Definition: faustparser.cpp:1199
boxHSlider
Tree boxHSlider(Tree lbl, Tree cur, Tree min, Tree max, Tree step)
Definition: boxes.cpp:377
docTxt
Tree docTxt(const char *name)
Definition: doc.cpp:171
yytype_int16
short int yytype_int16
Definition: faustparser.cpp:371
yytranslate
static const yytype_uint8 yytranslate[]
Definition: faustparser.cpp:589
yys
const char * yys
Definition: faustparser.cpp:1481
boxInt
Tree boxInt(int n)
Definition: boxes.cpp:75
yyerr
int yyerr
Definition: main.cpp:83
YY_NULL
#define YY_NULL
Definition: faustparser.cpp:145
gSqrtPrim
xtended * gSqrtPrim
Definition: sqrtprim.cpp:67
boxWire
Tree boxWire()
Definition: boxes.cpp:108
setDefProp
void setDefProp(Tree sym, const char *filename, int lineno)
Definition: errormsg.cpp:66
yydestruct
static void yydestruct(yymsg, yytype, yyvaluep) const char *yymsg
docEqn
Tree docEqn(Tree x)
Definition: doc.cpp:185
gAbsPrim
xtended * gAbsPrim
Definition: absprim.cpp:77
boxVBargraph
Tree boxVBargraph(Tree lbl, Tree min, Tree max)
Definition: boxes.cpp:460
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: faustparser.cpp:534
gRintPrim
xtended * gRintPrim
Definition: rintprim.cpp:67
gStripDocSwitch
bool gStripDocSwitch
Definition: main.cpp:124
gLstDependenciesSwitch
bool gLstDependenciesSwitch
mdoc listing management.
Definition: doc.cpp:113
yy_stack_print
static void yy_stack_print(yybottom, yytop) yytype_int16 *yybottom
yyprhs
static const yytype_uint16 yyprhs[]
Definition: faustparser.cpp:634
sigSub
Tree sigSub(Tree x, Tree y)
Definition: signals.hh:153
YYCASE_
#define YYCASE_(N, S)
YYUSE
#define YYUSE(E)
Definition: faustparser.cpp:412
yyalloc::yyss_alloc
yytype_int16 yyss_alloc
Definition: faustparser.cpp:514
yyr2
static const yytype_uint8 yyr2[]
Definition: faustparser.cpp:845
yystrlen
static YYSIZE_T yystrlen(yystr) const char *yystr
boxButton
Tree boxButton(Tree lbl)
Definition: boxes.cpp:365
gMinPrim
xtended * gMinPrim
Definition: minprim.cpp:147
sigLeftShift
Tree sigLeftShift(Tree x, Tree y)
Definition: signals.hh:162
docLst
Tree docLst()
Definition: doc.cpp:197
yyd
return yyd
Definition: faustparser.cpp:1486
boxWithLocalDef
Tree boxWithLocalDef(Tree body, Tree ldef)
Definition: boxes.cpp:264
boxCut
Tree boxCut()
Definition: boxes.cpp:104
sigRightShift
Tree sigRightShift(Tree x, Tree y)
Definition: signals.hh:163
yyalloc::yyvs_alloc
YYSTYPE yyvs_alloc
Definition: faustparser.cpp:515
unquote
Tree unquote(char *str)
Definition: faustparser.cpp:113
gAtan2Prim
xtended * gAtan2Prim
Definition: atan2prim.cpp:61
YYSTYPE::cppstr
string * cppstr
Definition: faustparser.cpp:308
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: faustparser.cpp:1713
yycheck
static const yytype_int16 yycheck[]
Definition: faustparser.cpp:1076
YYACCEPT
#define YYACCEPT
Definition: faustparser.cpp:1202
gMetaDataSet
map< Tree, set< Tree > > gMetaDataSet
Definition: main.cpp:91
yytext
char * yytext
gAtanPrim
xtended * gAtanPrim
Definition: atanprim.cpp:59
yypgoto
static const yytype_int16 yypgoto[]
Definition: faustparser.cpp:986
sigNE
Tree sigNE(Tree x, Tree y)
Definition: signals.hh:170
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: faustparser.cpp:585
boxMerge
Tree boxMerge(Tree x, Tree y)
Definition: boxes.cpp:151
yytype_int8
short int yytype_int8
Definition: faustparser.cpp:359
gFloorPrim
xtended * gFloorPrim
Definition: floorprim.cpp:61
importFile
Tree importFile(Tree filename)
Definition: boxes.cpp:300
sigAdd
Tree sigAdd(Tree x, Tree y)
Definition: signals.hh:152
sigAttach
Tree sigAttach(Tree t0, Tree t1)
Definition: signals.cpp:290
checkRulelist
Tree checkRulelist(Tree lr)
Definition: sourcereader.cpp:76
boxReal
Tree boxReal(double n)
Definition: boxes.cpp:76
gTanPrim
xtended * gTanPrim
Definition: tanprim.cpp:59
yystpcpy
static char * yystpcpy(yydest, yysrc) char *yydest
yypact
static const yytype_int16 yypact[]
Definition: faustparser.cpp:936
boxPrim2
Tree boxPrim2(prim2 foo)
Definition: boxes.cpp:319
yytype
int yytype
Definition: faustparser.cpp:1298
yychar
int yychar
Definition: faustparser.cpp:1709
YYSTYPE::str
char * str
Definition: faustparser.cpp:307
boxWaveform
Tree boxWaveform(const tvec &br)
Definition: boxes.cpp:92
boxAccess
Tree boxAccess(Tree exp, Tree id)
Definition: boxes.cpp:255
boxLibrary
Tree boxLibrary(Tree filename)
Definition: boxes.cpp:294
sigLE
Tree sigLE(Tree x, Tree y)
Definition: signals.hh:168
sigFloatCast
Tree sigFloatCast(Tree t)
Definition: signals.cpp:170
sigFixDelay
Tree sigFixDelay(Tree t0, Tree t1)
Definition: signals.cpp:61
yystos
static const yytype_uint8 yystos[]
Definition: faustparser.cpp:1148
sigLT
Tree sigLT(Tree x, Tree y)
Definition: signals.hh:166
yysyntax_error
static int yysyntax_error(YYSIZE_T *yymsg_alloc, char **yymsg, yytype_int16 *yyssp, int yytoken)
Definition: faustparser.cpp:1548
boxSeq
Tree boxSeq(Tree x, Tree y)
Definition: boxes.cpp:135
yypact_value_is_default
#define yypact_value_is_default(Yystate)
Definition: faustparser.cpp:1070
boxFConst
Tree boxFConst(Tree type, Tree name, Tree file)
Definition: boxes.cpp:349
sigRem
Tree sigRem(Tree x, Tree y)
Definition: signals.hh:156
yytname
static const char *const yytname[]
Definition: faustparser.cpp:766
tree
Tree tree(const Node &n)
Definition: tree.hh:186
docNtc
Tree docNtc()
Definition: doc.cpp:193
YYMAXDEPTH
#define YYMAXDEPTH
Definition: faustparser.cpp:84
boxIPar
Tree boxIPar(Tree x, Tree y, Tree z)
Definition: boxes.cpp:164
YYSYNTAX_ERROR
#define YYSYNTAX_ERROR
boxHGroup
Tree boxHGroup(Tree lbl, Tree x)
Definition: boxes.cpp:436
YYLAST
#define YYLAST
Definition: faustparser.cpp:570
yylval
YYSTYPE yylval
gAcosPrim
xtended * gAcosPrim
Definition: acosprim.cpp:58
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
Definition: faustparser.cpp:523
yyrline
static const yytype_uint16 yyrline[]
Definition: faustparser.cpp:737
xtended::box
Tree box()
Definition: xtended.hh:27
boxTGroup
Tree boxTGroup(Tree lbl, Tree x)
Definition: boxes.cpp:448
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: faustparser.cpp:476
yyerror
void yyerror(const char *msg)
Definition: errormsg.cpp:34
boxPar
Tree boxPar(Tree x, Tree y)
Definition: boxes.cpp:139
YY_INITIAL_VALUE
#define YY_INITIAL_VALUE(Value)
Definition: faustparser.cpp:1717
gResult
Tree gResult
Definition: main.cpp:86
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: faustparser.cpp:1273
docDgm
Tree docDgm(Tree x)
Definition: doc.cpp:189
gDocVector
vector< Tree > gDocVector
Contains parsed trees: DOCTXT, DOCEQN, DOCDGM.
Definition: doc.cpp:109
YYEOF
#define YYEOF
Definition: faustparser.cpp:1200
nil
Tree nil
Definition: list.cpp:116
sigMul
Tree sigMul(Tree x, Tree y)
Definition: signals.hh:154
sigSelect3
Tree sigSelect3(Tree selector, Tree s1, Tree s2, Tree s3)
Definition: signals.cpp:118
boxPrim4
Tree boxPrim4(prim4 foo)
Definition: boxes.cpp:329
sigOR
Tree sigOR(Tree x, Tree y)
Definition: signals.hh:159
gCeilPrim
xtended * gCeilPrim
Definition: ceilprim.cpp:61
boxModifLocalDef
Tree boxModifLocalDef(Tree body, Tree ldef)
Definition: boxes.cpp:274
buildBoxAbstr
Tree buildBoxAbstr(Tree largs, Tree body)
Definition: boxes.cpp:208
gPowPrim
xtended * gPowPrim
Definition: powprim.cpp:77
boxInputs
Tree boxInputs(Tree x)
Definition: boxes.cpp:182
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: faustparser.cpp:1714
yytokentype
yytokentype
Definition: faustparser.cpp:174
yyi
int yyi
Definition: faustparser.cpp:1387
boxOutputs
Tree boxOutputs(Tree x)
Definition: boxes.cpp:183
yytable
static const yytype_int16 yytable[]
Definition: faustparser.cpp:1000
YY_
#define YY_(Msgid)
Definition: faustparser.cpp:398
gLog10Prim
xtended * gLog10Prim
Definition: log10prim.cpp:67
boxComponent
Tree boxComponent(Tree filename)
Definition: boxes.cpp:289
yydefact
static const yytype_uint8 yydefact[]
Definition: faustparser.cpp:873
yysrc
const char * yysrc
Definition: faustparser.cpp:1477
sigReadOnlyTable
Tree sigReadOnlyTable(Tree n, Tree init, Tree ridx)
Definition: signals.hh:104
sigDiv
Tree sigDiv(Tree x, Tree y)
Definition: signals.hh:155
yylineno
int yylineno
boxSplit
Tree boxSplit(Tree x, Tree y)
Definition: boxes.cpp:147
YYID
#define YYID(N)
Definition: faustparser.cpp:420
boxCase
Tree boxCase(Tree rules)
Definition: boxes.cpp:615
yynerrs
int yynerrs
Definition: faustparser.cpp:1724
boxVGroup
Tree boxVGroup(Tree lbl, Tree x)
Definition: boxes.cpp:442
yytop
yytype_int16 * yytop
Definition: faustparser.cpp:1354
gFmodPrim
xtended * gFmodPrim
Definition: fmodprim.cpp:61
yydebug
int yydebug
Definition: faustparser.cpp:1412
gSinPrim
xtended * gSinPrim
Definition: sinprim.cpp:59
gMaxPrim
xtended * gMaxPrim
Definition: maxprim.cpp:121
gLstMdocTagsSwitch
bool gLstMdocTagsSwitch
mdoc listing management.
Definition: doc.cpp:114
YYSIZE_T
#define YYSIZE_T
Definition: faustparser.cpp:384
sigDelay1
Tree sigDelay1(Tree t0)
Definition: signals.cpp:57
buildBoxAppl
Tree buildBoxAppl(Tree fun, Tree revarglist)
Definition: boxes.cpp:227
boxIProd
Tree boxIProd(Tree x, Tree y, Tree z)
Definition: boxes.cpp:167
yylen
return yylen
Definition: faustparser.cpp:1458
gLogPrim
xtended * gLogPrim
Definition: logprim.cpp:66
yyrule
int yyrule
Definition: faustparser.cpp:1385
Generated on Fri Sep 5 2014 18:06:36 for FAUST compiler by   doxygen 1.8.7