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