|
FAUST compiler
0.9.9.6b8
|
00001 00002 /* A Bison parser, made by GNU Bison 2.4.1. */ 00003 00004 /* Skeleton implementation for Bison's Yacc-like parsers in C 00005 00006 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 00007 Free Software Foundation, Inc. 00008 00009 This program is free software: you can redistribute it and/or modify 00010 it under the terms of the GNU General Public License as published by 00011 the Free Software Foundation, either version 3 of the License, or 00012 (at your option) any later version. 00013 00014 This program is distributed in the hope that it will be useful, 00015 but WITHOUT ANY WARRANTY; without even the implied warranty of 00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00017 GNU General Public License for more details. 00018 00019 You should have received a copy of the GNU General Public License 00020 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 00021 00022 /* As a special exception, you may create a larger work that contains 00023 part or all of the Bison parser skeleton and distribute that work 00024 under terms of your choice, so long as that work isn't itself a 00025 parser generator using the skeleton or a modified version thereof 00026 as a parser skeleton. Alternatively, if you modify or redistribute 00027 the parser skeleton itself, you may (at your option) remove this 00028 special exception, which will cause the skeleton and the resulting 00029 Bison output files to be licensed under the GNU General Public 00030 License without this special exception. 00031 00032 This special exception was added by the Free Software Foundation in 00033 version 2.2 of Bison. */ 00034 00035 /* C LALR(1) parser skeleton written by Richard Stallman, by 00036 simplifying the original so-called "semantic" parser. */ 00037 00038 /* All symbols defined below should begin with yy or YY, to avoid 00039 infringing on user name space. This should be done even for local 00040 variables, as they might otherwise be expanded by user macros. 00041 There are some unavoidable exceptions within include files to 00042 define necessary library symbols; they are noted "INFRINGES ON 00043 USER NAME SPACE" below. */ 00044 00045 /* Identify Bison output. */ 00046 #define YYBISON 1 00047 00048 /* Bison version. */ 00049 #define YYBISON_VERSION "2.4.1" 00050 00051 /* Skeleton name. */ 00052 #define YYSKELETON_NAME "yacc.c" 00053 00054 /* Pure parsers. */ 00055 #define YYPURE 0 00056 00057 /* Push parsers. */ 00058 #define YYPUSH 0 00059 00060 /* Pull parsers. */ 00061 #define YYPULL 1 00062 00063 /* Using locations. */ 00064 #define YYLSP_NEEDED 0 00065 00066 00067 00068 /* Copy the first part of user declarations. */ 00069 00070 /* Line 189 of yacc.c */ 00071 #line 5 "parser/faustparser.y" 00072 00073 00074 #include "tree.hh" 00075 #include "xtended.hh" 00076 #include "boxes.hh" 00077 #include "prim2.hh" 00078 #include "signals.hh" 00079 #include "errormsg.hh" 00080 #include "sourcereader.hh" 00081 #include "doc.hh" 00082 #include "ppbox.hh" 00083 00084 #include <string> 00085 #include <list> 00086 00087 #define YYDEBUG 1 00088 #define YYERROR_VERBOSE 1 00089 #define YYMAXDEPTH 100000 00090 00091 using namespace std; 00092 00093 extern char* yytext; 00094 extern const char* yyfilename; 00095 extern int yylineno; 00096 extern int yyerr; 00097 extern Tree gResult; 00098 extern bool gStripDocSwitch; 00099 extern bool gLstDependenciesSwitch; 00100 extern bool gLstDistributedSwitch; 00101 extern bool gLstMdocTagsSwitch; 00102 00103 extern map<Tree, set<Tree> > gMetaDataSet; 00104 extern vector<Tree> gDocVector; 00105 00106 00107 int yylex(); 00108 00109 //---------------------------------------------------------- 00110 // unquote() : remove enclosing quotes and carriage return 00111 // characters from string. Returns a Tree 00112 //---------------------------------------------------------- 00113 char replaceCR(char c) 00114 { 00115 return (c!='\n') ? c : ' '; 00116 } 00117 00118 Tree unquote(char* str) 00119 { 00120 //-----------copy unquoted filename------------- 00121 char buf[512]; 00122 int j=0; 00123 00124 if (str[0] == '"') { 00125 //it is a quoted string, we remove the quotes 00126 for (int i=1; j<511 && str[i];) { 00127 buf[j++] = replaceCR(str[i++]); 00128 } 00129 // remove last quote 00130 if (j>0) buf[j-1] = 0; 00131 } else { 00132 for (int i=0; j<511 && str[i];) { 00133 buf[j++] = replaceCR(str[i++]); 00134 } 00135 } 00136 buf[j] = 0; 00137 00138 return tree(buf); 00139 //---------------------------------------------- 00140 } 00141 00142 00143 00144 /* Line 189 of yacc.c */ 00145 #line 146 "parser/faustparser.cpp" 00146 00147 /* Enabling traces. */ 00148 #ifndef YYDEBUG 00149 # define YYDEBUG 0 00150 #endif 00151 00152 /* Enabling verbose error messages. */ 00153 #ifdef YYERROR_VERBOSE 00154 # undef YYERROR_VERBOSE 00155 # define YYERROR_VERBOSE 1 00156 #else 00157 # define YYERROR_VERBOSE 0 00158 #endif 00159 00160 /* Enabling the token table. */ 00161 #ifndef YYTOKEN_TABLE 00162 # define YYTOKEN_TABLE 0 00163 #endif 00164 00165 00166 /* Tokens. */ 00167 #ifndef YYTOKENTYPE 00168 # define YYTOKENTYPE 00169 /* Put the tokens into the symbol table, so that GDB and other debuggers 00170 know about them. */ 00171 enum yytokentype { 00172 WITH = 258, 00173 MIX = 259, 00174 SPLIT = 260, 00175 SEQ = 261, 00176 PAR = 262, 00177 REC = 263, 00178 NE = 264, 00179 GE = 265, 00180 GT = 266, 00181 EQ = 267, 00182 LE = 268, 00183 LT = 269, 00184 OR = 270, 00185 SUB = 271, 00186 ADD = 272, 00187 RSH = 273, 00188 LSH = 274, 00189 XOR = 275, 00190 AND = 276, 00191 MOD = 277, 00192 DIV = 278, 00193 MUL = 279, 00194 POWOP = 280, 00195 FDELAY = 281, 00196 DELAY1 = 282, 00197 DOT = 283, 00198 APPL = 284, 00199 MEM = 285, 00200 PREFIX = 286, 00201 INTCAST = 287, 00202 FLOATCAST = 288, 00203 FFUNCTION = 289, 00204 FCONSTANT = 290, 00205 FVARIABLE = 291, 00206 BUTTON = 292, 00207 CHECKBOX = 293, 00208 VSLIDER = 294, 00209 HSLIDER = 295, 00210 NENTRY = 296, 00211 VGROUP = 297, 00212 HGROUP = 298, 00213 TGROUP = 299, 00214 HBARGRAPH = 300, 00215 VBARGRAPH = 301, 00216 ATTACH = 302, 00217 ACOS = 303, 00218 ASIN = 304, 00219 ATAN = 305, 00220 ATAN2 = 306, 00221 COS = 307, 00222 SIN = 308, 00223 TAN = 309, 00224 EXP = 310, 00225 LOG = 311, 00226 LOG10 = 312, 00227 POWFUN = 313, 00228 SQRT = 314, 00229 ABS = 315, 00230 MIN = 316, 00231 MAX = 317, 00232 FMOD = 318, 00233 REMAINDER = 319, 00234 FLOOR = 320, 00235 CEIL = 321, 00236 RINT = 322, 00237 RDTBL = 323, 00238 RWTBL = 324, 00239 SELECT2 = 325, 00240 SELECT3 = 326, 00241 INT = 327, 00242 FLOAT = 328, 00243 LAMBDA = 329, 00244 WIRE = 330, 00245 CUT = 331, 00246 ENDDEF = 332, 00247 VIRG = 333, 00248 LPAR = 334, 00249 RPAR = 335, 00250 LBRAQ = 336, 00251 RBRAQ = 337, 00252 LCROC = 338, 00253 RCROC = 339, 00254 DEF = 340, 00255 IMPORT = 341, 00256 COMPONENT = 342, 00257 LIBRARY = 343, 00258 ENVIRONMENT = 344, 00259 IPAR = 345, 00260 ISEQ = 346, 00261 ISUM = 347, 00262 IPROD = 348, 00263 STRING = 349, 00264 FSTRING = 350, 00265 IDENT = 351, 00266 EXTRA = 352, 00267 DECLARE = 353, 00268 CASE = 354, 00269 ARROW = 355, 00270 BDOC = 356, 00271 EDOC = 357, 00272 BEQN = 358, 00273 EEQN = 359, 00274 BDGM = 360, 00275 EDGM = 361, 00276 BLST = 362, 00277 ELST = 363, 00278 BMETADATA = 364, 00279 EMETADATA = 365, 00280 DOCCHAR = 366, 00281 NOTICE = 367, 00282 LISTING = 368, 00283 LSTTRUE = 369, 00284 LSTFALSE = 370, 00285 LSTDEPENDENCIES = 371, 00286 LSTMDOCTAGS = 372, 00287 LSTDISTRIBUTED = 373, 00288 LSTEQ = 374, 00289 LSTQ = 375 00290 }; 00291 #endif 00292 00293 00294 00295 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED 00296 typedef union YYSTYPE 00297 { 00298 00299 /* Line 214 of yacc.c */ 00300 #line 78 "parser/faustparser.y" 00301 00302 CTree* exp; 00303 char* str; 00304 string* cppstr; 00305 bool b; 00306 00307 00308 00309 /* Line 214 of yacc.c */ 00310 #line 311 "parser/faustparser.cpp" 00311 } YYSTYPE; 00312 # define YYSTYPE_IS_TRIVIAL 1 00313 # define yystype YYSTYPE /* obsolescent; will be withdrawn */ 00314 # define YYSTYPE_IS_DECLARED 1 00315 #endif 00316 00317 00318 /* Copy the second part of user declarations. */ 00319 00320 00321 /* Line 264 of yacc.c */ 00322 #line 323 "parser/faustparser.cpp" 00323 00324 #ifdef short 00325 # undef short 00326 #endif 00327 00328 #ifdef YYTYPE_UINT8 00329 typedef YYTYPE_UINT8 yytype_uint8; 00330 #else 00331 typedef unsigned char yytype_uint8; 00332 #endif 00333 00334 #ifdef YYTYPE_INT8 00335 typedef YYTYPE_INT8 yytype_int8; 00336 #elif (defined __STDC__ || defined __C99__FUNC__ \ 00337 || defined __cplusplus || defined _MSC_VER) 00338 typedef signed char yytype_int8; 00339 #else 00340 typedef short int yytype_int8; 00341 #endif 00342 00343 #ifdef YYTYPE_UINT16 00344 typedef YYTYPE_UINT16 yytype_uint16; 00345 #else 00346 typedef unsigned short int yytype_uint16; 00347 #endif 00348 00349 #ifdef YYTYPE_INT16 00350 typedef YYTYPE_INT16 yytype_int16; 00351 #else 00352 typedef short int yytype_int16; 00353 #endif 00354 00355 #ifndef YYSIZE_T 00356 # ifdef __SIZE_TYPE__ 00357 # define YYSIZE_T __SIZE_TYPE__ 00358 # elif defined size_t 00359 # define YYSIZE_T size_t 00360 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ 00361 || defined __cplusplus || defined _MSC_VER) 00362 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */ 00363 # define YYSIZE_T size_t 00364 # else 00365 # define YYSIZE_T unsigned int 00366 # endif 00367 #endif 00368 00369 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1) 00370 00371 #ifndef YY_ 00372 # if YYENABLE_NLS 00373 # if ENABLE_NLS 00374 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */ 00375 # define YY_(msgid) dgettext ("bison-runtime", msgid) 00376 # endif 00377 # endif 00378 # ifndef YY_ 00379 # define YY_(msgid) msgid 00380 # endif 00381 #endif 00382 00383 /* Suppress unused-variable warnings by "using" E. */ 00384 #if ! defined lint || defined __GNUC__ 00385 # define YYUSE(e) ((void) (e)) 00386 #else 00387 # define YYUSE(e) /* empty */ 00388 #endif 00389 00390 /* Identity function, used to suppress warnings about constant conditions. */ 00391 #ifndef lint 00392 # define YYID(n) (n) 00393 #else 00394 #if (defined __STDC__ || defined __C99__FUNC__ \ 00395 || defined __cplusplus || defined _MSC_VER) 00396 static int 00397 YYID (int yyi) 00398 #else 00399 static int 00400 YYID (yyi) 00401 int yyi; 00402 #endif 00403 { 00404 return yyi; 00405 } 00406 #endif 00407 00408 #if ! defined yyoverflow || YYERROR_VERBOSE 00409 00410 /* The parser invokes alloca or malloc; define the necessary symbols. */ 00411 00412 # ifdef YYSTACK_USE_ALLOCA 00413 # if YYSTACK_USE_ALLOCA 00414 # ifdef __GNUC__ 00415 # define YYSTACK_ALLOC __builtin_alloca 00416 # elif defined __BUILTIN_VA_ARG_INCR 00417 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */ 00418 # elif defined _AIX 00419 # define YYSTACK_ALLOC __alloca 00420 # elif defined _MSC_VER 00421 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */ 00422 # define alloca _alloca 00423 # else 00424 # define YYSTACK_ALLOC alloca 00425 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 00426 || defined __cplusplus || defined _MSC_VER) 00427 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 00428 # ifndef _STDLIB_H 00429 # define _STDLIB_H 1 00430 # endif 00431 # endif 00432 # endif 00433 # endif 00434 # endif 00435 00436 # ifdef YYSTACK_ALLOC 00437 /* Pacify GCC's `empty if-body' warning. */ 00438 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) 00439 # ifndef YYSTACK_ALLOC_MAXIMUM 00440 /* The OS might guarantee only one guard page at the bottom of the stack, 00441 and a page size can be as small as 4096 bytes. So we cannot safely 00442 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number 00443 to allow for a few compiler-allocated temporary stack slots. */ 00444 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ 00445 # endif 00446 # else 00447 # define YYSTACK_ALLOC YYMALLOC 00448 # define YYSTACK_FREE YYFREE 00449 # ifndef YYSTACK_ALLOC_MAXIMUM 00450 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM 00451 # endif 00452 # if (defined __cplusplus && ! defined _STDLIB_H \ 00453 && ! ((defined YYMALLOC || defined malloc) \ 00454 && (defined YYFREE || defined free))) 00455 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ 00456 # ifndef _STDLIB_H 00457 # define _STDLIB_H 1 00458 # endif 00459 # endif 00460 # ifndef YYMALLOC 00461 # define YYMALLOC malloc 00462 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 00463 || defined __cplusplus || defined _MSC_VER) 00464 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ 00465 # endif 00466 # endif 00467 # ifndef YYFREE 00468 # define YYFREE free 00469 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ 00470 || defined __cplusplus || defined _MSC_VER) 00471 void free (void *); /* INFRINGES ON USER NAME SPACE */ 00472 # endif 00473 # endif 00474 # endif 00475 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */ 00476 00477 00478 #if (! defined yyoverflow \ 00479 && (! defined __cplusplus \ 00480 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) 00481 00482 /* A type that is properly aligned for any stack member. */ 00483 union yyalloc 00484 { 00485 yytype_int16 yyss_alloc; 00486 YYSTYPE yyvs_alloc; 00487 }; 00488 00489 /* The size of the maximum gap between one aligned stack and the next. */ 00490 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) 00491 00492 /* The size of an array large to enough to hold all stacks, each with 00493 N elements. */ 00494 # define YYSTACK_BYTES(N) \ 00495 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \ 00496 + YYSTACK_GAP_MAXIMUM) 00497 00498 /* Copy COUNT objects from FROM to TO. The source and destination do 00499 not overlap. */ 00500 # ifndef YYCOPY 00501 # if defined __GNUC__ && 1 < __GNUC__ 00502 # define YYCOPY(To, From, Count) \ 00503 __builtin_memcpy (To, From, (Count) * sizeof (*(From))) 00504 # else 00505 # define YYCOPY(To, From, Count) \ 00506 do \ 00507 { \ 00508 YYSIZE_T yyi; \ 00509 for (yyi = 0; yyi < (Count); yyi++) \ 00510 (To)[yyi] = (From)[yyi]; \ 00511 } \ 00512 while (YYID (0)) 00513 # endif 00514 # endif 00515 00516 /* Relocate STACK from its old location to the new one. The 00517 local variables YYSIZE and YYSTACKSIZE give the old and new number of 00518 elements in the stack, and YYPTR gives the new location of the 00519 stack. Advance YYPTR to a properly aligned location for the next 00520 stack. */ 00521 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \ 00522 do \ 00523 { \ 00524 YYSIZE_T yynewbytes; \ 00525 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \ 00526 Stack = &yyptr->Stack_alloc; \ 00527 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ 00528 yyptr += yynewbytes / sizeof (*yyptr); \ 00529 } \ 00530 while (YYID (0)) 00531 00532 #endif 00533 00534 /* YYFINAL -- State number of the termination state. */ 00535 #define YYFINAL 3 00536 /* YYLAST -- Last index in YYTABLE. */ 00537 #define YYLAST 603 00538 00539 /* YYNTOKENS -- Number of terminals. */ 00540 #define YYNTOKENS 121 00541 /* YYNNTS -- Number of nonterminals. */ 00542 #define YYNNTS 52 00543 /* YYNRULES -- Number of rules. */ 00544 #define YYNRULES 188 00545 /* YYNRULES -- Number of states. */ 00546 #define YYNSTATES 406 00547 00548 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ 00549 #define YYUNDEFTOK 2 00550 #define YYMAXUTOK 375 00551 00552 #define YYTRANSLATE(YYX) \ 00553 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) 00554 00555 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ 00556 static const yytype_uint8 yytranslate[] = 00557 { 00558 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00559 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00560 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00561 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00562 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00565 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00566 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00567 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00568 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00569 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00570 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00571 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00572 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00574 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00575 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00576 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00577 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00578 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00579 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00580 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00581 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00582 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 00583 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 00584 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 00585 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 00586 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 00587 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 00588 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 00589 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 00590 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 00591 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 00592 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 00593 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 00594 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 00595 115, 116, 117, 118, 119, 120 00596 }; 00597 00598 #if YYDEBUG 00599 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in 00600 YYRHS. */ 00601 static const yytype_uint16 yyprhs[] = 00602 { 00603 0, 0, 3, 5, 6, 9, 10, 13, 19, 24, 00604 26, 30, 31, 34, 36, 38, 40, 42, 44, 46, 00605 47, 50, 54, 58, 60, 64, 65, 68, 74, 80, 00606 86, 88, 90, 94, 102, 107, 110, 112, 114, 118, 00607 124, 128, 132, 136, 140, 144, 146, 150, 154, 158, 00608 162, 166, 170, 174, 177, 181, 185, 189, 193, 197, 00609 201, 205, 209, 213, 217, 221, 225, 230, 235, 237, 00610 239, 241, 244, 247, 250, 253, 255, 257, 259, 261, 00611 263, 265, 267, 269, 271, 273, 275, 277, 279, 281, 00612 283, 285, 287, 289, 291, 293, 295, 297, 299, 301, 00613 303, 305, 307, 309, 311, 313, 315, 317, 319, 321, 00614 323, 325, 327, 329, 331, 333, 335, 337, 339, 341, 00615 343, 345, 347, 349, 351, 353, 356, 360, 369, 374, 00616 376, 378, 380, 385, 390, 395, 397, 399, 401, 403, 00617 405, 407, 409, 411, 413, 415, 417, 419, 421, 423, 00618 425, 427, 429, 433, 437, 441, 445, 449, 451, 453, 00619 455, 457, 459, 468, 477, 486, 495, 504, 512, 520, 00620 525, 530, 543, 556, 569, 576, 583, 590, 599, 608, 00621 614, 619, 621, 623, 627, 629, 632, 639, 641 00622 }; 00623 00624 /* YYRHS -- A `-1'-separated list of the rules' RHS. */ 00625 static const yytype_int16 yyrhs[] = 00626 { 00627 122, 0, -1, 123, -1, -1, 123, 125, -1, -1, 00628 124, 137, -1, 86, 79, 148, 80, 77, -1, 98, 00629 144, 147, 77, -1, 137, -1, 101, 126, 102, -1, 00630 -1, 126, 127, -1, 128, -1, 129, -1, 130, -1, 00631 131, -1, 132, -1, 136, -1, -1, 128, 111, -1, 00632 103, 140, 104, -1, 105, 140, 106, -1, 112, -1, 00633 107, 133, 108, -1, -1, 133, 134, -1, 116, 119, 00634 120, 135, 120, -1, 117, 119, 120, 135, 120, -1, 00635 118, 119, 120, 135, 120, -1, 114, -1, 115, -1, 00636 109, 144, 110, -1, 138, 79, 145, 80, 85, 140, 00637 77, -1, 138, 85, 140, 77, -1, 1, 77, -1, 00638 143, -1, 143, -1, 139, 7, 143, -1, 140, 3, 00639 81, 124, 82, -1, 140, 7, 140, -1, 140, 6, 00640 140, -1, 140, 5, 140, -1, 140, 4, 140, -1, 00641 140, 8, 140, -1, 141, -1, 141, 17, 141, -1, 00642 141, 16, 141, -1, 141, 24, 141, -1, 141, 23, 00643 141, -1, 141, 22, 141, -1, 141, 25, 141, -1, 00644 141, 26, 141, -1, 141, 27, -1, 141, 28, 143, 00645 -1, 141, 21, 141, -1, 141, 15, 141, -1, 141, 00646 20, 141, -1, 141, 19, 141, -1, 141, 18, 141, 00647 -1, 141, 14, 141, -1, 141, 13, 141, -1, 141, 00648 11, 141, -1, 141, 10, 141, -1, 141, 12, 141, 00649 -1, 141, 9, 141, -1, 141, 79, 145, 80, -1, 00650 141, 83, 124, 84, -1, 142, -1, 72, -1, 73, 00651 -1, 17, 72, -1, 17, 73, -1, 16, 72, -1, 00652 16, 73, -1, 75, -1, 76, -1, 30, -1, 31, 00653 -1, 32, -1, 33, -1, 17, -1, 16, -1, 24, 00654 -1, 23, -1, 22, -1, 26, -1, 21, -1, 15, 00655 -1, 20, -1, 19, -1, 18, -1, 14, -1, 13, 00656 -1, 11, -1, 10, -1, 12, -1, 9, -1, 47, 00657 -1, 48, -1, 49, -1, 50, -1, 51, -1, 52, 00658 -1, 53, -1, 54, -1, 55, -1, 56, -1, 57, 00659 -1, 25, -1, 58, -1, 59, -1, 60, -1, 61, 00660 -1, 62, -1, 63, -1, 64, -1, 65, -1, 66, 00661 -1, 67, -1, 68, -1, 69, -1, 70, -1, 71, 00662 -1, 143, -1, 16, 143, -1, 79, 140, 80, -1, 00663 74, 79, 139, 80, 28, 79, 140, 80, -1, 99, 00664 81, 170, 82, -1, 154, -1, 155, -1, 156, -1, 00665 87, 79, 148, 80, -1, 88, 79, 148, 80, -1, 00666 89, 81, 124, 82, -1, 157, -1, 158, -1, 159, 00667 -1, 160, -1, 161, -1, 162, -1, 163, -1, 164, 00668 -1, 165, -1, 166, -1, 150, -1, 151, -1, 152, 00669 -1, 153, -1, 96, -1, 96, -1, 146, -1, 145, 00670 7, 146, -1, 146, 6, 146, -1, 146, 5, 146, 00671 -1, 146, 4, 146, -1, 146, 8, 146, -1, 141, 00672 -1, 94, -1, 94, -1, 94, -1, 95, -1, 90, 00673 79, 143, 7, 146, 7, 140, 80, -1, 91, 79, 00674 143, 7, 146, 7, 140, 80, -1, 92, 79, 143, 00675 7, 146, 7, 140, 80, -1, 93, 79, 143, 7, 00676 146, 7, 140, 80, -1, 34, 79, 167, 7, 149, 00677 7, 147, 80, -1, 35, 79, 172, 144, 7, 149, 00678 80, -1, 36, 79, 172, 144, 7, 149, 80, -1, 00679 37, 79, 148, 80, -1, 38, 79, 148, 80, -1, 00680 39, 79, 148, 7, 146, 7, 146, 7, 146, 7, 00681 146, 80, -1, 40, 79, 148, 7, 146, 7, 146, 00682 7, 146, 7, 146, 80, -1, 41, 79, 148, 7, 00683 146, 7, 146, 7, 146, 7, 146, 80, -1, 42, 00684 79, 148, 7, 140, 80, -1, 43, 79, 148, 7, 00685 140, 80, -1, 44, 79, 148, 7, 140, 80, -1, 00686 46, 79, 148, 7, 146, 7, 146, 80, -1, 45, 00687 79, 148, 7, 146, 7, 146, 80, -1, 172, 168, 00688 79, 169, 80, -1, 172, 168, 79, 80, -1, 96, 00689 -1, 172, -1, 169, 7, 172, -1, 171, -1, 170, 00690 171, -1, 79, 145, 80, 100, 140, 77, -1, 32, 00691 -1, 33, -1 00692 }; 00693 00694 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */ 00695 static const yytype_uint16 yyrline[] = 00696 { 00697 0, 301, 301, 304, 305, 307, 308, 311, 312, 313, 00698 314, 317, 318, 321, 322, 323, 324, 325, 326, 329, 00699 330, 333, 336, 339, 342, 345, 346, 349, 350, 351, 00700 354, 355, 358, 361, 362, 363, 366, 369, 370, 373, 00701 374, 375, 376, 377, 378, 379, 382, 383, 384, 385, 00702 386, 387, 388, 389, 390, 392, 393, 394, 396, 397, 00703 399, 400, 401, 402, 403, 404, 406, 407, 409, 412, 00704 413, 415, 416, 418, 419, 421, 422, 424, 425, 427, 00705 428, 430, 431, 432, 433, 434, 435, 437, 438, 439, 00706 441, 442, 444, 445, 446, 447, 448, 449, 451, 453, 00707 454, 455, 456, 457, 458, 459, 461, 462, 463, 464, 00708 465, 466, 468, 469, 470, 472, 473, 475, 476, 477, 00709 480, 481, 483, 484, 486, 487, 489, 490, 493, 495, 00710 496, 497, 498, 499, 500, 502, 503, 504, 505, 506, 00711 507, 508, 509, 510, 511, 513, 514, 515, 516, 520, 00712 523, 528, 529, 532, 533, 534, 535, 536, 539, 542, 00713 545, 546, 551, 555, 559, 563, 570, 574, 577, 582, 00714 585, 588, 591, 594, 597, 600, 603, 607, 610, 616, 00715 617, 620, 623, 624, 627, 628, 631, 635, 636 00716 }; 00717 #endif 00718 00719 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE 00720 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. 00721 First, the terminals, then, starting at YYNTOKENS, nonterminals. */ 00722 static const char *const yytname[] = 00723 { 00724 "$end", "error", "$undefined", "WITH", "MIX", "SPLIT", "SEQ", "PAR", 00725 "REC", "NE", "GE", "GT", "EQ", "LE", "LT", "OR", "SUB", "ADD", "RSH", 00726 "LSH", "XOR", "AND", "MOD", "DIV", "MUL", "POWOP", "FDELAY", "DELAY1", 00727 "DOT", "APPL", "MEM", "PREFIX", "INTCAST", "FLOATCAST", "FFUNCTION", 00728 "FCONSTANT", "FVARIABLE", "BUTTON", "CHECKBOX", "VSLIDER", "HSLIDER", 00729 "NENTRY", "VGROUP", "HGROUP", "TGROUP", "HBARGRAPH", "VBARGRAPH", 00730 "ATTACH", "ACOS", "ASIN", "ATAN", "ATAN2", "COS", "SIN", "TAN", "EXP", 00731 "LOG", "LOG10", "POWFUN", "SQRT", "ABS", "MIN", "MAX", "FMOD", 00732 "REMAINDER", "FLOOR", "CEIL", "RINT", "RDTBL", "RWTBL", "SELECT2", 00733 "SELECT3", "INT", "FLOAT", "LAMBDA", "WIRE", "CUT", "ENDDEF", "VIRG", 00734 "LPAR", "RPAR", "LBRAQ", "RBRAQ", "LCROC", "RCROC", "DEF", "IMPORT", 00735 "COMPONENT", "LIBRARY", "ENVIRONMENT", "IPAR", "ISEQ", "ISUM", "IPROD", 00736 "STRING", "FSTRING", "IDENT", "EXTRA", "DECLARE", "CASE", "ARROW", 00737 "BDOC", "EDOC", "BEQN", "EEQN", "BDGM", "EDGM", "BLST", "ELST", 00738 "BMETADATA", "EMETADATA", "DOCCHAR", "NOTICE", "LISTING", "LSTTRUE", 00739 "LSTFALSE", "LSTDEPENDENCIES", "LSTMDOCTAGS", "LSTDISTRIBUTED", "LSTEQ", 00740 "LSTQ", "$accept", "program", "stmtlist", "deflist", "statement", "doc", 00741 "docelem", "doctxt", "doceqn", "docdgm", "docntc", "doclst", 00742 "lstattrlist", "lstattrdef", "lstattrval", "docmtd", "definition", 00743 "defname", "params", "expression", "infixexp", "primitive", "ident", 00744 "name", "arglist", "argument", "string", "uqstring", "fstring", "fpar", 00745 "fseq", "fsum", "fprod", "ffunction", "fconst", "fvariable", "button", 00746 "checkbox", "vslider", "hslider", "nentry", "vgroup", "hgroup", "tgroup", 00747 "vbargraph", "hbargraph", "signature", "fun", "typelist", "rulelist", 00748 "rule", "type", 0 00749 }; 00750 #endif 00751 00752 # ifdef YYPRINT 00753 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to 00754 token YYLEX-NUM. */ 00755 static const yytype_uint16 yytoknum[] = 00756 { 00757 0, 256, 257, 258, 259, 260, 261, 262, 263, 264, 00758 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 00759 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 00760 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 00761 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 00762 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 00763 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 00764 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 00765 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 00766 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 00767 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 00768 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 00769 375 00770 }; 00771 # endif 00772 00773 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ 00774 static const yytype_uint8 yyr1[] = 00775 { 00776 0, 121, 122, 123, 123, 124, 124, 125, 125, 125, 00777 125, 126, 126, 127, 127, 127, 127, 127, 127, 128, 00778 128, 129, 130, 131, 132, 133, 133, 134, 134, 134, 00779 135, 135, 136, 137, 137, 137, 138, 139, 139, 140, 00780 140, 140, 140, 140, 140, 140, 141, 141, 141, 141, 00781 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 00782 141, 141, 141, 141, 141, 141, 141, 141, 141, 142, 00783 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 00784 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 00785 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 00786 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 00787 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 00788 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 00789 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, 00790 142, 142, 142, 142, 142, 142, 142, 142, 142, 143, 00791 144, 145, 145, 146, 146, 146, 146, 146, 147, 148, 00792 149, 149, 150, 151, 152, 153, 154, 155, 156, 157, 00793 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 00794 167, 168, 169, 169, 170, 170, 171, 172, 172 00795 }; 00796 00797 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ 00798 static const yytype_uint8 yyr2[] = 00799 { 00800 0, 2, 1, 0, 2, 0, 2, 5, 4, 1, 00801 3, 0, 2, 1, 1, 1, 1, 1, 1, 0, 00802 2, 3, 3, 1, 3, 0, 2, 5, 5, 5, 00803 1, 1, 3, 7, 4, 2, 1, 1, 3, 5, 00804 3, 3, 3, 3, 3, 1, 3, 3, 3, 3, 00805 3, 3, 3, 2, 3, 3, 3, 3, 3, 3, 00806 3, 3, 3, 3, 3, 3, 4, 4, 1, 1, 00807 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 00808 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00809 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00810 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00811 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00812 1, 1, 1, 1, 1, 2, 3, 8, 4, 1, 00813 1, 1, 4, 4, 4, 1, 1, 1, 1, 1, 00814 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 00815 1, 1, 3, 3, 3, 3, 3, 1, 1, 1, 00816 1, 1, 8, 8, 8, 8, 8, 7, 7, 4, 00817 4, 12, 12, 12, 6, 6, 6, 8, 8, 5, 00818 4, 1, 1, 3, 1, 2, 6, 1, 1 00819 }; 00820 00821 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state 00822 STATE-NUM when YYTABLE doesn't specify something else to do. Zero 00823 means the default is an error. */ 00824 static const yytype_uint8 yydefact[] = 00825 { 00826 3, 0, 0, 1, 0, 0, 149, 0, 11, 4, 00827 9, 0, 36, 35, 0, 150, 0, 19, 0, 0, 00828 159, 0, 158, 0, 10, 0, 0, 25, 0, 23, 00829 12, 13, 14, 15, 16, 17, 18, 97, 95, 94, 00830 96, 93, 92, 88, 82, 81, 91, 90, 89, 87, 00831 85, 84, 83, 109, 86, 77, 78, 79, 80, 0, 00832 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00833 0, 0, 98, 99, 100, 101, 102, 103, 104, 105, 00834 106, 107, 108, 110, 111, 112, 113, 114, 115, 116, 00835 117, 118, 119, 120, 121, 122, 123, 69, 70, 0, 00836 75, 76, 0, 0, 0, 0, 0, 0, 0, 0, 00837 0, 157, 68, 124, 0, 151, 145, 146, 147, 148, 00838 129, 130, 131, 135, 136, 137, 138, 139, 140, 141, 00839 142, 143, 144, 0, 45, 0, 8, 0, 0, 0, 00840 0, 20, 73, 74, 125, 71, 72, 0, 0, 0, 00841 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00842 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 00843 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00844 0, 0, 0, 0, 0, 0, 0, 0, 53, 0, 00845 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 00846 0, 0, 0, 0, 34, 7, 21, 22, 24, 0, 00847 0, 0, 26, 32, 187, 188, 0, 0, 0, 0, 00848 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00849 0, 37, 126, 0, 0, 0, 0, 0, 0, 0, 00850 0, 0, 184, 65, 63, 62, 64, 61, 60, 56, 00851 47, 46, 59, 58, 57, 55, 50, 49, 48, 51, 00852 52, 54, 0, 0, 152, 0, 155, 154, 153, 156, 00853 5, 43, 42, 41, 40, 44, 0, 0, 0, 0, 00854 181, 0, 0, 0, 169, 170, 0, 0, 0, 0, 00855 0, 0, 0, 0, 0, 0, 132, 133, 134, 6, 00856 0, 0, 0, 0, 0, 128, 185, 66, 67, 0, 00857 0, 0, 0, 0, 160, 161, 0, 0, 0, 0, 00858 0, 0, 0, 0, 0, 0, 0, 0, 38, 0, 00859 0, 0, 0, 0, 0, 33, 39, 30, 31, 0, 00860 0, 0, 0, 180, 0, 182, 0, 0, 0, 0, 00861 0, 174, 175, 176, 0, 0, 0, 0, 0, 0, 00862 0, 0, 27, 28, 29, 0, 0, 179, 167, 168, 00863 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 00864 0, 166, 183, 0, 0, 0, 178, 177, 127, 162, 00865 163, 164, 165, 186, 0, 0, 0, 0, 0, 0, 00866 0, 0, 0, 171, 172, 173 00867 }; 00868 00869 /* YYDEFGOTO[NTERM-NUM]. */ 00870 static const yytype_int16 yydefgoto[] = 00871 { 00872 -1, 1, 2, 235, 9, 17, 30, 31, 32, 33, 00873 34, 35, 139, 212, 339, 36, 299, 11, 230, 133, 00874 111, 112, 113, 16, 114, 115, 23, 21, 316, 116, 00875 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 00876 127, 128, 129, 130, 131, 132, 216, 281, 344, 241, 00877 242, 217 00878 }; 00879 00880 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing 00881 STATE-NUM. */ 00882 #define YYPACT_NINF -189 00883 static const yytype_int16 yypact[] = 00884 { 00885 -189, 36, 8, -189, -66, -25, -189, -9, -189, -189, 00886 -189, 13, -189, -189, -4, -189, 3, 178, 342, 342, 00887 -189, 30, -189, 60, -189, 342, 342, -189, -9, -189, 00888 -189, 31, -189, -189, -189, -189, -189, -189, -189, -189, 00889 -189, -189, -189, -189, 23, -29, -189, -189, -189, -189, 00890 -189, -189, -189, -189, -189, -189, -189, -189, -189, 172, 00891 183, 195, 200, 203, 205, 210, 212, 214, 220, 226, 00892 248, 249, -189, -189, -189, -189, -189, -189, -189, -189, 00893 -189, -189, -189, -189, -189, -189, -189, -189, -189, -189, 00894 -189, -189, -189, -189, -189, -189, -189, -189, -189, 252, 00895 -189, -189, 342, 253, 254, 118, 257, 270, 292, 340, 00896 225, 440, -189, -189, 19, 296, -189, -189, -189, -189, 00897 -189, -189, -189, -189, -189, -189, -189, -189, -189, -189, 00898 -189, -189, -189, 25, 440, 241, -189, 17, 11, 61, 00899 219, -189, -189, -189, -189, -189, -189, 101, 101, 101, 00900 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, 00901 273, 43, -4, -4, -189, 273, 273, 273, 273, 341, 00902 342, 342, 342, 342, 342, 342, 342, 342, 342, 342, 00903 342, 342, 342, 342, 342, 342, 342, 342, -189, 273, 00904 342, -189, 342, 343, 342, 342, 342, 342, 344, 342, 00905 342, 342, 342, 342, -189, -189, -189, -189, -189, 308, 00906 317, 320, -189, -189, -189, -189, 430, 349, -9, -9, 00907 360, 367, 441, 487, 488, 489, 490, 507, 508, 509, 00908 27, -189, -189, 437, 442, 4, 513, 514, 522, 523, 00909 342, 6, -189, 454, 454, 454, 454, 454, 454, 465, 00910 465, 465, 190, 190, 190, 190, 190, 190, 190, 41, 00911 209, -189, 38, 9, 296, 342, 296, 296, 95, -189, 00912 -189, 260, 260, 133, 120, -189, 411, 412, 414, 107, 00913 -189, 456, 529, 536, -189, -189, 342, 342, 342, 342, 00914 342, 342, 342, 342, 273, 517, -189, -189, -189, -189, 00915 342, 342, 342, 342, 45, -189, -189, -189, -189, 73, 00916 26, 89, 89, 89, -189, -189, 539, 116, 107, 107, 00917 318, 495, 500, 52, 58, 67, 505, 520, -189, 468, 00918 534, 545, 550, 555, 494, -189, -189, -189, -189, 475, 00919 476, 477, 3, -189, 46, -189, 518, 519, 342, 342, 00920 342, -189, -189, -189, 342, 342, 342, 342, 342, 342, 00921 342, 342, -189, -189, -189, 521, 101, -189, -189, -189, 00922 560, 565, 570, 239, 255, 168, 206, 217, 227, 250, 00923 108, -189, -189, 342, 342, 342, -189, -189, -189, -189, 00924 -189, -189, -189, -189, 575, 580, 585, 342, 342, 342, 00925 290, 418, 438, -189, -189, -189 00926 }; 00927 00928 /* YYPGOTO[NTERM-NUM]. */ 00929 static const yytype_int16 yypgoto[] = 00930 { 00931 -189, -189, -189, -188, -189, -189, -189, -189, -189, -189, 00932 -189, -189, -189, -189, -74, -189, 598, -189, -189, -13, 00933 -19, -189, 40, -24, -149, -157, 261, 158, -69, -189, 00934 -189, -189, -189, -189, -189, -189, -189, -189, -189, -189, 00935 -189, -189, -189, -189, -189, -189, -189, -189, -189, -189, 00936 361, -147 00937 }; 00938 00939 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If 00940 positive, shift that token. If negative, reduce the rule which 00941 number is the opposite. If zero, do what YYDEFACT says. 00942 If YYTABLE_NINF, syntax error. */ 00943 #define YYTABLE_NINF -3 00944 static const yytype_int16 yytable[] = 00945 { 00946 134, 218, 219, 263, 140, 4, 134, 134, -2, 4, 00947 4, 13, 137, 138, 198, 199, 200, 201, 202, 203, 00948 198, 199, 200, 201, 202, 203, 192, 4, 198, 199, 00949 200, 201, 202, 203, 294, 264, 3, 266, 267, 268, 00950 269, 262, 12, 145, 146, 192, 198, 199, 200, 201, 00951 202, 203, 192, 366, 14, 198, 199, 200, 201, 202, 00952 203, 198, 199, 200, 201, 202, 203, 187, 188, 189, 00953 198, 199, 200, 201, 202, 203, 198, 199, 200, 201, 00954 202, 203, 310, 134, 144, 240, 298, 15, 305, 161, 00955 20, 304, 18, 308, 5, 142, 143, 22, 19, 193, 00956 6, 196, 204, 197, 6, 6, 7, 295, 336, 8, 00957 135, 198, 199, 200, 201, 202, 203, 207, 307, 6, 00958 190, 206, 6, 232, 191, 334, 367, 202, 203, 320, 00959 321, 322, 351, 214, 215, 326, 327, 136, 352, 201, 00960 202, 203, 141, 330, 331, 332, 333, 353, 214, 215, 00961 335, 243, 244, 245, 246, 247, 248, 249, 250, 251, 00962 252, 253, 254, 255, 256, 257, 258, 259, 260, 208, 00963 345, 198, 199, 200, 201, 202, 203, 209, 210, 211, 00964 134, 134, 134, 134, 134, 393, 271, 272, 273, 274, 00965 275, 370, 371, 372, 282, 283, 343, 373, 374, 164, 00966 231, 314, 315, 337, 338, 236, 237, 238, 239, 198, 00967 199, 200, 201, 202, 203, 186, 187, 188, 189, 382, 00968 198, 199, 200, 201, 202, 203, 394, 395, 396, 261, 00969 198, 199, 200, 201, 202, 203, 188, 189, 340, 341, 00970 400, 401, 402, 194, 195, 196, 134, 197, 388, 346, 00971 347, 147, 309, 198, 199, 200, 201, 202, 203, 194, 00972 195, 196, 148, 197, 199, 200, 201, 202, 203, 190, 00973 134, 134, 134, 191, 149, 12, 323, 324, 325, 150, 00974 24, 25, 151, 26, 152, 27, 389, 28, 190, 153, 00975 29, 154, 191, 155, 194, 195, 196, 390, 197, 156, 00976 194, 195, 196, 12, 197, 157, 169, 391, 220, 221, 00977 222, 223, 224, 225, 226, 227, 228, 229, 205, 386, 00978 233, 234, 194, 195, 196, 348, 197, 158, 159, 213, 00979 392, 160, 162, 163, 328, 387, 165, 134, 134, 134, 00980 134, 134, 134, 375, 376, 377, 378, 379, 380, 166, 00981 12, 37, 38, 39, 40, 41, 42, 43, 44, 45, 00982 46, 47, 48, 49, 50, 51, 52, 53, 54, 6, 00983 403, 167, 55, 56, 57, 58, 59, 60, 61, 62, 00984 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 00985 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 00986 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 00987 93, 94, 95, 96, 97, 98, 99, 100, 101, 168, 00988 240, 102, 194, 195, 196, 270, 197, 276, 265, 103, 00989 104, 105, 106, 107, 108, 109, 277, 279, 6, 278, 00990 284, 110, 194, 195, 196, 280, 197, 285, 286, 170, 00991 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 00992 181, 182, 183, 184, 185, 186, 187, 188, 189, 176, 00993 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 00994 187, 188, 189, 179, 180, 181, 182, 183, 184, 185, 00995 186, 187, 188, 189, 287, 288, 289, 290, 404, 194, 00996 195, 196, 349, 197, 194, 195, 196, 350, 197, 194, 00997 195, 196, 354, 197, 291, 292, 293, 296, 405, 190, 00998 300, 301, 297, 191, 194, 195, 196, 355, 197, 302, 00999 303, 311, 312, 190, 313, 317, 318, 191, 194, 195, 01000 196, 357, 197, 319, 190, 329, 342, 356, 191, 194, 01001 195, 196, 358, 197, 194, 195, 196, 359, 197, 194, 01002 195, 196, 360, 197, 194, 195, 196, 383, 197, 194, 01003 195, 196, 384, 197, 194, 195, 196, 385, 197, 194, 01004 195, 196, 397, 197, 194, 195, 196, 398, 197, 194, 01005 195, 196, 399, 197, 361, 362, 363, 364, 368, 369, 01006 10, 381, 306, 365 01007 }; 01008 01009 static const yytype_uint16 yycheck[] = 01010 { 01011 19, 148, 149, 191, 28, 1, 25, 26, 0, 1, 01012 1, 77, 25, 26, 3, 4, 5, 6, 7, 8, 01013 3, 4, 5, 6, 7, 8, 7, 1, 3, 4, 01014 5, 6, 7, 8, 7, 192, 0, 194, 195, 196, 01015 197, 190, 2, 72, 73, 7, 3, 4, 5, 6, 01016 7, 8, 7, 7, 79, 3, 4, 5, 6, 7, 01017 8, 3, 4, 5, 6, 7, 8, 26, 27, 28, 01018 3, 4, 5, 6, 7, 8, 3, 4, 5, 6, 01019 7, 8, 270, 102, 44, 79, 82, 96, 82, 102, 01020 94, 240, 79, 84, 86, 72, 73, 94, 85, 80, 01021 96, 6, 77, 8, 96, 96, 98, 80, 82, 101, 01022 80, 3, 4, 5, 6, 7, 8, 106, 80, 96, 01023 79, 104, 96, 80, 83, 80, 80, 7, 8, 286, 01024 287, 288, 80, 32, 33, 292, 293, 77, 80, 6, 01025 7, 8, 111, 300, 301, 302, 303, 80, 32, 33, 01026 77, 170, 171, 172, 173, 174, 175, 176, 177, 178, 01027 179, 180, 181, 182, 183, 184, 185, 186, 187, 108, 01028 317, 3, 4, 5, 6, 7, 8, 116, 117, 118, 01029 199, 200, 201, 202, 203, 77, 199, 200, 201, 202, 01030 203, 348, 349, 350, 218, 219, 80, 354, 355, 81, 01031 160, 94, 95, 114, 115, 165, 166, 167, 168, 3, 01032 4, 5, 6, 7, 8, 25, 26, 27, 28, 366, 01033 3, 4, 5, 6, 7, 8, 383, 384, 385, 189, 01034 3, 4, 5, 6, 7, 8, 27, 28, 312, 313, 01035 397, 398, 399, 4, 5, 6, 265, 8, 80, 318, 01036 319, 79, 265, 3, 4, 5, 6, 7, 8, 4, 01037 5, 6, 79, 8, 4, 5, 6, 7, 8, 79, 01038 289, 290, 291, 83, 79, 235, 289, 290, 291, 79, 01039 102, 103, 79, 105, 79, 107, 80, 109, 79, 79, 01040 112, 79, 83, 79, 4, 5, 6, 80, 8, 79, 01041 4, 5, 6, 263, 8, 79, 81, 80, 150, 151, 01042 152, 153, 154, 155, 156, 157, 158, 159, 77, 80, 01043 162, 163, 4, 5, 6, 7, 8, 79, 79, 110, 01044 80, 79, 79, 79, 294, 80, 79, 356, 357, 358, 01045 359, 360, 361, 356, 357, 358, 359, 360, 361, 79, 01046 310, 9, 10, 11, 12, 13, 14, 15, 16, 17, 01047 18, 19, 20, 21, 22, 23, 24, 25, 26, 96, 01048 80, 79, 30, 31, 32, 33, 34, 35, 36, 37, 01049 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 01050 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 01051 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 01052 68, 69, 70, 71, 72, 73, 74, 75, 76, 79, 01053 79, 79, 4, 5, 6, 81, 8, 119, 85, 87, 01054 88, 89, 90, 91, 92, 93, 119, 7, 96, 119, 01055 80, 99, 4, 5, 6, 96, 8, 80, 7, 9, 01056 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 01057 20, 21, 22, 23, 24, 25, 26, 27, 28, 15, 01058 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 01059 26, 27, 28, 18, 19, 20, 21, 22, 23, 24, 01060 25, 26, 27, 28, 7, 7, 7, 7, 80, 4, 01061 5, 6, 7, 8, 4, 5, 6, 7, 8, 4, 01062 5, 6, 7, 8, 7, 7, 7, 80, 80, 79, 01063 7, 7, 80, 83, 4, 5, 6, 7, 8, 7, 01064 7, 120, 120, 79, 120, 79, 7, 83, 4, 5, 01065 6, 7, 8, 7, 79, 28, 7, 79, 83, 4, 01066 5, 6, 7, 8, 4, 5, 6, 7, 8, 4, 01067 5, 6, 7, 8, 4, 5, 6, 7, 8, 4, 01068 5, 6, 7, 8, 4, 5, 6, 7, 8, 4, 01069 5, 6, 7, 8, 4, 5, 6, 7, 8, 4, 01070 5, 6, 7, 8, 100, 120, 120, 120, 80, 80, 01071 2, 80, 241, 342 01072 }; 01073 01074 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing 01075 symbol of state STATE-NUM. */ 01076 static const yytype_uint8 yystos[] = 01077 { 01078 0, 122, 123, 0, 1, 86, 96, 98, 101, 125, 01079 137, 138, 143, 77, 79, 96, 144, 126, 79, 85, 01080 94, 148, 94, 147, 102, 103, 105, 107, 109, 112, 01081 127, 128, 129, 130, 131, 132, 136, 9, 10, 11, 01082 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 01083 22, 23, 24, 25, 26, 30, 31, 32, 33, 34, 01084 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 01085 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 01086 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 01087 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 01088 75, 76, 79, 87, 88, 89, 90, 91, 92, 93, 01089 99, 141, 142, 143, 145, 146, 150, 151, 152, 153, 01090 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 01091 164, 165, 166, 140, 141, 80, 77, 140, 140, 133, 01092 144, 111, 72, 73, 143, 72, 73, 79, 79, 79, 01093 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 01094 79, 140, 79, 79, 81, 79, 79, 79, 79, 81, 01095 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 01096 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 01097 79, 83, 7, 80, 4, 5, 6, 8, 3, 4, 01098 5, 6, 7, 8, 77, 77, 104, 106, 108, 116, 01099 117, 118, 134, 110, 32, 33, 167, 172, 172, 172, 01100 148, 148, 148, 148, 148, 148, 148, 148, 148, 148, 01101 139, 143, 80, 148, 148, 124, 143, 143, 143, 143, 01102 79, 170, 171, 141, 141, 141, 141, 141, 141, 141, 01103 141, 141, 141, 141, 141, 141, 141, 141, 141, 141, 01104 141, 143, 145, 124, 146, 85, 146, 146, 146, 146, 01105 81, 140, 140, 140, 140, 140, 119, 119, 119, 7, 01106 96, 168, 144, 144, 80, 80, 7, 7, 7, 7, 01107 7, 7, 7, 7, 7, 80, 80, 80, 82, 137, 01108 7, 7, 7, 7, 145, 82, 171, 80, 84, 140, 01109 124, 120, 120, 120, 94, 95, 149, 79, 7, 7, 01110 146, 146, 146, 140, 140, 140, 146, 146, 143, 28, 01111 146, 146, 146, 146, 80, 77, 82, 114, 115, 135, 01112 135, 135, 7, 80, 169, 172, 149, 149, 7, 7, 01113 7, 80, 80, 80, 7, 7, 79, 7, 7, 7, 01114 7, 100, 120, 120, 120, 147, 7, 80, 80, 80, 01115 146, 146, 146, 146, 146, 140, 140, 140, 140, 140, 01116 140, 80, 172, 7, 7, 7, 80, 80, 80, 80, 01117 80, 80, 80, 77, 146, 146, 146, 7, 7, 7, 01118 146, 146, 146, 80, 80, 80 01119 }; 01120 01121 #define yyerrok (yyerrstatus = 0) 01122 #define yyclearin (yychar = YYEMPTY) 01123 #define YYEMPTY (-2) 01124 #define YYEOF 0 01125 01126 #define YYACCEPT goto yyacceptlab 01127 #define YYABORT goto yyabortlab 01128 #define YYERROR goto yyerrorlab 01129 01130 01131 /* Like YYERROR except do call yyerror. This remains here temporarily 01132 to ease the transition to the new meaning of YYERROR, for GCC. 01133 Once GCC version 2 has supplanted version 1, this can go. */ 01134 01135 #define YYFAIL goto yyerrlab 01136 01137 #define YYRECOVERING() (!!yyerrstatus) 01138 01139 #define YYBACKUP(Token, Value) \ 01140 do \ 01141 if (yychar == YYEMPTY && yylen == 1) \ 01142 { \ 01143 yychar = (Token); \ 01144 yylval = (Value); \ 01145 yytoken = YYTRANSLATE (yychar); \ 01146 YYPOPSTACK (1); \ 01147 goto yybackup; \ 01148 } \ 01149 else \ 01150 { \ 01151 yyerror (YY_("syntax error: cannot back up")); \ 01152 YYERROR; \ 01153 } \ 01154 while (YYID (0)) 01155 01156 01157 #define YYTERROR 1 01158 #define YYERRCODE 256 01159 01160 01161 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. 01162 If N is 0, then set CURRENT to the empty location which ends 01163 the previous symbol: RHS[0] (always defined). */ 01164 01165 #define YYRHSLOC(Rhs, K) ((Rhs)[K]) 01166 #ifndef YYLLOC_DEFAULT 01167 # define YYLLOC_DEFAULT(Current, Rhs, N) \ 01168 do \ 01169 if (YYID (N)) \ 01170 { \ 01171 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ 01172 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ 01173 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \ 01174 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \ 01175 } \ 01176 else \ 01177 { \ 01178 (Current).first_line = (Current).last_line = \ 01179 YYRHSLOC (Rhs, 0).last_line; \ 01180 (Current).first_column = (Current).last_column = \ 01181 YYRHSLOC (Rhs, 0).last_column; \ 01182 } \ 01183 while (YYID (0)) 01184 #endif 01185 01186 01187 /* YY_LOCATION_PRINT -- Print the location on the stream. 01188 This macro was not mandated originally: define only if we know 01189 we won't break user code: when these are the locations we know. */ 01190 01191 #ifndef YY_LOCATION_PRINT 01192 # if YYLTYPE_IS_TRIVIAL 01193 # define YY_LOCATION_PRINT(File, Loc) \ 01194 fprintf (File, "%d.%d-%d.%d", \ 01195 (Loc).first_line, (Loc).first_column, \ 01196 (Loc).last_line, (Loc).last_column) 01197 # else 01198 # define YY_LOCATION_PRINT(File, Loc) ((void) 0) 01199 # endif 01200 #endif 01201 01202 01203 /* YYLEX -- calling `yylex' with the right arguments. */ 01204 01205 #ifdef YYLEX_PARAM 01206 # define YYLEX yylex (YYLEX_PARAM) 01207 #else 01208 # define YYLEX yylex () 01209 #endif 01210 01211 /* Enable debugging if requested. */ 01212 #if YYDEBUG 01213 01214 # ifndef YYFPRINTF 01215 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */ 01216 # define YYFPRINTF fprintf 01217 # endif 01218 01219 # define YYDPRINTF(Args) \ 01220 do { \ 01221 if (yydebug) \ 01222 YYFPRINTF Args; \ 01223 } while (YYID (0)) 01224 01225 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ 01226 do { \ 01227 if (yydebug) \ 01228 { \ 01229 YYFPRINTF (stderr, "%s ", Title); \ 01230 yy_symbol_print (stderr, \ 01231 Type, Value); \ 01232 YYFPRINTF (stderr, "\n"); \ 01233 } \ 01234 } while (YYID (0)) 01235 01236 01237 /*--------------------------------. 01238 | Print this symbol on YYOUTPUT. | 01239 `--------------------------------*/ 01240 01241 /*ARGSUSED*/ 01242 #if (defined __STDC__ || defined __C99__FUNC__ \ 01243 || defined __cplusplus || defined _MSC_VER) 01244 static void 01245 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 01246 #else 01247 static void 01248 yy_symbol_value_print (yyoutput, yytype, yyvaluep) 01249 FILE *yyoutput; 01250 int yytype; 01251 YYSTYPE const * const yyvaluep; 01252 #endif 01253 { 01254 if (!yyvaluep) 01255 return; 01256 # ifdef YYPRINT 01257 if (yytype < YYNTOKENS) 01258 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); 01259 # else 01260 YYUSE (yyoutput); 01261 # endif 01262 switch (yytype) 01263 { 01264 default: 01265 break; 01266 } 01267 } 01268 01269 01270 /*--------------------------------. 01271 | Print this symbol on YYOUTPUT. | 01272 `--------------------------------*/ 01273 01274 #if (defined __STDC__ || defined __C99__FUNC__ \ 01275 || defined __cplusplus || defined _MSC_VER) 01276 static void 01277 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) 01278 #else 01279 static void 01280 yy_symbol_print (yyoutput, yytype, yyvaluep) 01281 FILE *yyoutput; 01282 int yytype; 01283 YYSTYPE const * const yyvaluep; 01284 #endif 01285 { 01286 if (yytype < YYNTOKENS) 01287 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); 01288 else 01289 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); 01290 01291 yy_symbol_value_print (yyoutput, yytype, yyvaluep); 01292 YYFPRINTF (yyoutput, ")"); 01293 } 01294 01295 /*------------------------------------------------------------------. 01296 | yy_stack_print -- Print the state stack from its BOTTOM up to its | 01297 | TOP (included). | 01298 `------------------------------------------------------------------*/ 01299 01300 #if (defined __STDC__ || defined __C99__FUNC__ \ 01301 || defined __cplusplus || defined _MSC_VER) 01302 static void 01303 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop) 01304 #else 01305 static void 01306 yy_stack_print (yybottom, yytop) 01307 yytype_int16 *yybottom; 01308 yytype_int16 *yytop; 01309 #endif 01310 { 01311 YYFPRINTF (stderr, "Stack now"); 01312 for (; yybottom <= yytop; yybottom++) 01313 { 01314 int yybot = *yybottom; 01315 YYFPRINTF (stderr, " %d", yybot); 01316 } 01317 YYFPRINTF (stderr, "\n"); 01318 } 01319 01320 # define YY_STACK_PRINT(Bottom, Top) \ 01321 do { \ 01322 if (yydebug) \ 01323 yy_stack_print ((Bottom), (Top)); \ 01324 } while (YYID (0)) 01325 01326 01327 /*------------------------------------------------. 01328 | Report that the YYRULE is going to be reduced. | 01329 `------------------------------------------------*/ 01330 01331 #if (defined __STDC__ || defined __C99__FUNC__ \ 01332 || defined __cplusplus || defined _MSC_VER) 01333 static void 01334 yy_reduce_print (YYSTYPE *yyvsp, int yyrule) 01335 #else 01336 static void 01337 yy_reduce_print (yyvsp, yyrule) 01338 YYSTYPE *yyvsp; 01339 int yyrule; 01340 #endif 01341 { 01342 int yynrhs = yyr2[yyrule]; 01343 int yyi; 01344 unsigned long int yylno = yyrline[yyrule]; 01345 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", 01346 yyrule - 1, yylno); 01347 /* The symbols being reduced. */ 01348 for (yyi = 0; yyi < yynrhs; yyi++) 01349 { 01350 YYFPRINTF (stderr, " $%d = ", yyi + 1); 01351 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], 01352 &(yyvsp[(yyi + 1) - (yynrhs)]) 01353 ); 01354 YYFPRINTF (stderr, "\n"); 01355 } 01356 } 01357 01358 # define YY_REDUCE_PRINT(Rule) \ 01359 do { \ 01360 if (yydebug) \ 01361 yy_reduce_print (yyvsp, Rule); \ 01362 } while (YYID (0)) 01363 01364 /* Nonzero means print parse trace. It is left uninitialized so that 01365 multiple parsers can coexist. */ 01366 int yydebug; 01367 #else /* !YYDEBUG */ 01368 # define YYDPRINTF(Args) 01369 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) 01370 # define YY_STACK_PRINT(Bottom, Top) 01371 # define YY_REDUCE_PRINT(Rule) 01372 #endif /* !YYDEBUG */ 01373 01374 01375 /* YYINITDEPTH -- initial size of the parser's stacks. */ 01376 #ifndef YYINITDEPTH 01377 # define YYINITDEPTH 200 01378 #endif 01379 01380 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only 01381 if the built-in stack extension method is used). 01382 01383 Do not make this value too large; the results are undefined if 01384 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) 01385 evaluated with infinite-precision integer arithmetic. */ 01386 01387 #ifndef YYMAXDEPTH 01388 # define YYMAXDEPTH 10000 01389 #endif 01390 01391 01392 01393 #if YYERROR_VERBOSE 01394 01395 # ifndef yystrlen 01396 # if defined __GLIBC__ && defined _STRING_H 01397 # define yystrlen strlen 01398 # else 01399 /* Return the length of YYSTR. */ 01400 #if (defined __STDC__ || defined __C99__FUNC__ \ 01401 || defined __cplusplus || defined _MSC_VER) 01402 static YYSIZE_T 01403 yystrlen (const char *yystr) 01404 #else 01405 static YYSIZE_T 01406 yystrlen (yystr) 01407 const char *yystr; 01408 #endif 01409 { 01410 YYSIZE_T yylen; 01411 for (yylen = 0; yystr[yylen]; yylen++) 01412 continue; 01413 return yylen; 01414 } 01415 # endif 01416 # endif 01417 01418 # ifndef yystpcpy 01419 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE 01420 # define yystpcpy stpcpy 01421 # else 01422 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in 01423 YYDEST. */ 01424 #if (defined __STDC__ || defined __C99__FUNC__ \ 01425 || defined __cplusplus || defined _MSC_VER) 01426 static char * 01427 yystpcpy (char *yydest, const char *yysrc) 01428 #else 01429 static char * 01430 yystpcpy (yydest, yysrc) 01431 char *yydest; 01432 const char *yysrc; 01433 #endif 01434 { 01435 char *yyd = yydest; 01436 const char *yys = yysrc; 01437 01438 while ((*yyd++ = *yys++) != '\0') 01439 continue; 01440 01441 return yyd - 1; 01442 } 01443 # endif 01444 # endif 01445 01446 # ifndef yytnamerr 01447 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary 01448 quotes and backslashes, so that it's suitable for yyerror. The 01449 heuristic is that double-quoting is unnecessary unless the string 01450 contains an apostrophe, a comma, or backslash (other than 01451 backslash-backslash). YYSTR is taken from yytname. If YYRES is 01452 null, do not copy; instead, return the length of what the result 01453 would have been. */ 01454 static YYSIZE_T 01455 yytnamerr (char *yyres, const char *yystr) 01456 { 01457 if (*yystr == '"') 01458 { 01459 YYSIZE_T yyn = 0; 01460 char const *yyp = yystr; 01461 01462 for (;;) 01463 switch (*++yyp) 01464 { 01465 case '\'': 01466 case ',': 01467 goto do_not_strip_quotes; 01468 01469 case '\\': 01470 if (*++yyp != '\\') 01471 goto do_not_strip_quotes; 01472 /* Fall through. */ 01473 default: 01474 if (yyres) 01475 yyres[yyn] = *yyp; 01476 yyn++; 01477 break; 01478 01479 case '"': 01480 if (yyres) 01481 yyres[yyn] = '\0'; 01482 return yyn; 01483 } 01484 do_not_strip_quotes: ; 01485 } 01486 01487 if (! yyres) 01488 return yystrlen (yystr); 01489 01490 return yystpcpy (yyres, yystr) - yyres; 01491 } 01492 # endif 01493 01494 /* Copy into YYRESULT an error message about the unexpected token 01495 YYCHAR while in state YYSTATE. Return the number of bytes copied, 01496 including the terminating null byte. If YYRESULT is null, do not 01497 copy anything; just return the number of bytes that would be 01498 copied. As a special case, return 0 if an ordinary "syntax error" 01499 message will do. Return YYSIZE_MAXIMUM if overflow occurs during 01500 size calculation. */ 01501 static YYSIZE_T 01502 yysyntax_error (char *yyresult, int yystate, int yychar) 01503 { 01504 int yyn = yypact[yystate]; 01505 01506 if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) 01507 return 0; 01508 else 01509 { 01510 int yytype = YYTRANSLATE (yychar); 01511 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); 01512 YYSIZE_T yysize = yysize0; 01513 YYSIZE_T yysize1; 01514 int yysize_overflow = 0; 01515 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; 01516 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; 01517 int yyx; 01518 01519 # if 0 01520 /* This is so xgettext sees the translatable formats that are 01521 constructed on the fly. */ 01522 YY_("syntax error, unexpected %s"); 01523 YY_("syntax error, unexpected %s, expecting %s"); 01524 YY_("syntax error, unexpected %s, expecting %s or %s"); 01525 YY_("syntax error, unexpected %s, expecting %s or %s or %s"); 01526 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); 01527 # endif 01528 char *yyfmt; 01529 char const *yyf; 01530 static char const yyunexpected[] = "syntax error, unexpected %s"; 01531 static char const yyexpecting[] = ", expecting %s"; 01532 static char const yyor[] = " or %s"; 01533 char yyformat[sizeof yyunexpected 01534 + sizeof yyexpecting - 1 01535 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) 01536 * (sizeof yyor - 1))]; 01537 char const *yyprefix = yyexpecting; 01538 01539 /* Start YYX at -YYN if negative to avoid negative indexes in 01540 YYCHECK. */ 01541 int yyxbegin = yyn < 0 ? -yyn : 0; 01542 01543 /* Stay within bounds of both yycheck and yytname. */ 01544 int yychecklim = YYLAST - yyn + 1; 01545 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; 01546 int yycount = 1; 01547 01548 yyarg[0] = yytname[yytype]; 01549 yyfmt = yystpcpy (yyformat, yyunexpected); 01550 01551 for (yyx = yyxbegin; yyx < yyxend; ++yyx) 01552 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) 01553 { 01554 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) 01555 { 01556 yycount = 1; 01557 yysize = yysize0; 01558 yyformat[sizeof yyunexpected - 1] = '\0'; 01559 break; 01560 } 01561 yyarg[yycount++] = yytname[yyx]; 01562 yysize1 = yysize + yytnamerr (0, yytname[yyx]); 01563 yysize_overflow |= (yysize1 < yysize); 01564 yysize = yysize1; 01565 yyfmt = yystpcpy (yyfmt, yyprefix); 01566 yyprefix = yyor; 01567 } 01568 01569 yyf = YY_(yyformat); 01570 yysize1 = yysize + yystrlen (yyf); 01571 yysize_overflow |= (yysize1 < yysize); 01572 yysize = yysize1; 01573 01574 if (yysize_overflow) 01575 return YYSIZE_MAXIMUM; 01576 01577 if (yyresult) 01578 { 01579 /* Avoid sprintf, as that infringes on the user's name space. 01580 Don't have undefined behavior even if the translation 01581 produced a string with the wrong number of "%s"s. */ 01582 char *yyp = yyresult; 01583 int yyi = 0; 01584 while ((*yyp = *yyf) != '\0') 01585 { 01586 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) 01587 { 01588 yyp += yytnamerr (yyp, yyarg[yyi++]); 01589 yyf += 2; 01590 } 01591 else 01592 { 01593 yyp++; 01594 yyf++; 01595 } 01596 } 01597 } 01598 return yysize; 01599 } 01600 } 01601 #endif /* YYERROR_VERBOSE */ 01602 01603 01604 /*-----------------------------------------------. 01605 | Release the memory associated to this symbol. | 01606 `-----------------------------------------------*/ 01607 01608 /*ARGSUSED*/ 01609 #if (defined __STDC__ || defined __C99__FUNC__ \ 01610 || defined __cplusplus || defined _MSC_VER) 01611 static void 01612 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) 01613 #else 01614 static void 01615 yydestruct (yymsg, yytype, yyvaluep) 01616 const char *yymsg; 01617 int yytype; 01618 YYSTYPE *yyvaluep; 01619 #endif 01620 { 01621 YYUSE (yyvaluep); 01622 01623 if (!yymsg) 01624 yymsg = "Deleting"; 01625 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); 01626 01627 switch (yytype) 01628 { 01629 01630 default: 01631 break; 01632 } 01633 } 01634 01635 /* Prevent warnings from -Wmissing-prototypes. */ 01636 #ifdef YYPARSE_PARAM 01637 #if defined __STDC__ || defined __cplusplus 01638 int yyparse (void *YYPARSE_PARAM); 01639 #else 01640 int yyparse (); 01641 #endif 01642 #else /* ! YYPARSE_PARAM */ 01643 #if defined __STDC__ || defined __cplusplus 01644 int yyparse (void); 01645 #else 01646 int yyparse (); 01647 #endif 01648 #endif /* ! YYPARSE_PARAM */ 01649 01650 01651 /* The lookahead symbol. */ 01652 int yychar; 01653 01654 /* The semantic value of the lookahead symbol. */ 01655 YYSTYPE yylval; 01656 01657 /* Number of syntax errors so far. */ 01658 int yynerrs; 01659 01660 01661 01662 /*-------------------------. 01663 | yyparse or yypush_parse. | 01664 `-------------------------*/ 01665 01666 #ifdef YYPARSE_PARAM 01667 #if (defined __STDC__ || defined __C99__FUNC__ \ 01668 || defined __cplusplus || defined _MSC_VER) 01669 int 01670 yyparse (void *YYPARSE_PARAM) 01671 #else 01672 int 01673 yyparse (YYPARSE_PARAM) 01674 void *YYPARSE_PARAM; 01675 #endif 01676 #else /* ! YYPARSE_PARAM */ 01677 #if (defined __STDC__ || defined __C99__FUNC__ \ 01678 || defined __cplusplus || defined _MSC_VER) 01679 int 01680 yyparse (void) 01681 #else 01682 int 01683 yyparse () 01684 01685 #endif 01686 #endif 01687 { 01688 01689 01690 int yystate; 01691 /* Number of tokens to shift before error messages enabled. */ 01692 int yyerrstatus; 01693 01694 /* The stacks and their tools: 01695 `yyss': related to states. 01696 `yyvs': related to semantic values. 01697 01698 Refer to the stacks thru separate pointers, to allow yyoverflow 01699 to reallocate them elsewhere. */ 01700 01701 /* The state stack. */ 01702 yytype_int16 yyssa[YYINITDEPTH]; 01703 yytype_int16 *yyss; 01704 yytype_int16 *yyssp; 01705 01706 /* The semantic value stack. */ 01707 YYSTYPE yyvsa[YYINITDEPTH]; 01708 YYSTYPE *yyvs; 01709 YYSTYPE *yyvsp; 01710 01711 YYSIZE_T yystacksize; 01712 01713 int yyn; 01714 int yyresult; 01715 /* Lookahead token as an internal (translated) token number. */ 01716 int yytoken; 01717 /* The variables used to return semantic value and location from the 01718 action routines. */ 01719 YYSTYPE yyval; 01720 01721 #if YYERROR_VERBOSE 01722 /* Buffer for error messages, and its allocated size. */ 01723 char yymsgbuf[128]; 01724 char *yymsg = yymsgbuf; 01725 YYSIZE_T yymsg_alloc = sizeof yymsgbuf; 01726 #endif 01727 01728 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) 01729 01730 /* The number of symbols on the RHS of the reduced rule. 01731 Keep to zero when no symbol should be popped. */ 01732 int yylen = 0; 01733 01734 yytoken = 0; 01735 yyss = yyssa; 01736 yyvs = yyvsa; 01737 yystacksize = YYINITDEPTH; 01738 01739 YYDPRINTF ((stderr, "Starting parse\n")); 01740 01741 yystate = 0; 01742 yyerrstatus = 0; 01743 yynerrs = 0; 01744 yychar = YYEMPTY; /* Cause a token to be read. */ 01745 01746 /* Initialize stack pointers. 01747 Waste one element of value and location stack 01748 so that they stay on the same level as the state stack. 01749 The wasted elements are never initialized. */ 01750 yyssp = yyss; 01751 yyvsp = yyvs; 01752 01753 goto yysetstate; 01754 01755 /*------------------------------------------------------------. 01756 | yynewstate -- Push a new state, which is found in yystate. | 01757 `------------------------------------------------------------*/ 01758 yynewstate: 01759 /* In all cases, when you get here, the value and location stacks 01760 have just been pushed. So pushing a state here evens the stacks. */ 01761 yyssp++; 01762 01763 yysetstate: 01764 *yyssp = yystate; 01765 01766 if (yyss + yystacksize - 1 <= yyssp) 01767 { 01768 /* Get the current used size of the three stacks, in elements. */ 01769 YYSIZE_T yysize = yyssp - yyss + 1; 01770 01771 #ifdef yyoverflow 01772 { 01773 /* Give user a chance to reallocate the stack. Use copies of 01774 these so that the &'s don't force the real ones into 01775 memory. */ 01776 YYSTYPE *yyvs1 = yyvs; 01777 yytype_int16 *yyss1 = yyss; 01778 01779 /* Each stack pointer address is followed by the size of the 01780 data in use in that stack, in bytes. This used to be a 01781 conditional around just the two extra args, but that might 01782 be undefined if yyoverflow is a macro. */ 01783 yyoverflow (YY_("memory exhausted"), 01784 &yyss1, yysize * sizeof (*yyssp), 01785 &yyvs1, yysize * sizeof (*yyvsp), 01786 &yystacksize); 01787 01788 yyss = yyss1; 01789 yyvs = yyvs1; 01790 } 01791 #else /* no yyoverflow */ 01792 # ifndef YYSTACK_RELOCATE 01793 goto yyexhaustedlab; 01794 # else 01795 /* Extend the stack our own way. */ 01796 if (YYMAXDEPTH <= yystacksize) 01797 goto yyexhaustedlab; 01798 yystacksize *= 2; 01799 if (YYMAXDEPTH < yystacksize) 01800 yystacksize = YYMAXDEPTH; 01801 01802 { 01803 yytype_int16 *yyss1 = yyss; 01804 union yyalloc *yyptr = 01805 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); 01806 if (! yyptr) 01807 goto yyexhaustedlab; 01808 YYSTACK_RELOCATE (yyss_alloc, yyss); 01809 YYSTACK_RELOCATE (yyvs_alloc, yyvs); 01810 # undef YYSTACK_RELOCATE 01811 if (yyss1 != yyssa) 01812 YYSTACK_FREE (yyss1); 01813 } 01814 # endif 01815 #endif /* no yyoverflow */ 01816 01817 yyssp = yyss + yysize - 1; 01818 yyvsp = yyvs + yysize - 1; 01819 01820 YYDPRINTF ((stderr, "Stack size increased to %lu\n", 01821 (unsigned long int) yystacksize)); 01822 01823 if (yyss + yystacksize - 1 <= yyssp) 01824 YYABORT; 01825 } 01826 01827 YYDPRINTF ((stderr, "Entering state %d\n", yystate)); 01828 01829 if (yystate == YYFINAL) 01830 YYACCEPT; 01831 01832 goto yybackup; 01833 01834 /*-----------. 01835 | yybackup. | 01836 `-----------*/ 01837 yybackup: 01838 01839 /* Do appropriate processing given the current state. Read a 01840 lookahead token if we need one and don't already have one. */ 01841 01842 /* First try to decide what to do without reference to lookahead token. */ 01843 yyn = yypact[yystate]; 01844 if (yyn == YYPACT_NINF) 01845 goto yydefault; 01846 01847 /* Not known => get a lookahead token if don't already have one. */ 01848 01849 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ 01850 if (yychar == YYEMPTY) 01851 { 01852 YYDPRINTF ((stderr, "Reading a token: ")); 01853 yychar = YYLEX; 01854 } 01855 01856 if (yychar <= YYEOF) 01857 { 01858 yychar = yytoken = YYEOF; 01859 YYDPRINTF ((stderr, "Now at end of input.\n")); 01860 } 01861 else 01862 { 01863 yytoken = YYTRANSLATE (yychar); 01864 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); 01865 } 01866 01867 /* If the proper action on seeing token YYTOKEN is to reduce or to 01868 detect an error, take that action. */ 01869 yyn += yytoken; 01870 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) 01871 goto yydefault; 01872 yyn = yytable[yyn]; 01873 if (yyn <= 0) 01874 { 01875 if (yyn == 0 || yyn == YYTABLE_NINF) 01876 goto yyerrlab; 01877 yyn = -yyn; 01878 goto yyreduce; 01879 } 01880 01881 /* Count tokens shifted since error; after three, turn off error 01882 status. */ 01883 if (yyerrstatus) 01884 yyerrstatus--; 01885 01886 /* Shift the lookahead token. */ 01887 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); 01888 01889 /* Discard the shifted token. */ 01890 yychar = YYEMPTY; 01891 01892 yystate = yyn; 01893 *++yyvsp = yylval; 01894 01895 goto yynewstate; 01896 01897 01898 /*-----------------------------------------------------------. 01899 | yydefault -- do the default action for the current state. | 01900 `-----------------------------------------------------------*/ 01901 yydefault: 01902 yyn = yydefact[yystate]; 01903 if (yyn == 0) 01904 goto yyerrlab; 01905 goto yyreduce; 01906 01907 01908 /*-----------------------------. 01909 | yyreduce -- Do a reduction. | 01910 `-----------------------------*/ 01911 yyreduce: 01912 /* yyn is the number of a rule to reduce with. */ 01913 yylen = yyr2[yyn]; 01914 01915 /* If YYLEN is nonzero, implement the default value of the action: 01916 `$$ = $1'. 01917 01918 Otherwise, the following line sets YYVAL to garbage. 01919 This behavior is undocumented and Bison 01920 users should not rely upon it. Assigning to YYVAL 01921 unconditionally makes the parser a bit smaller, and it avoids a 01922 GCC warning that YYVAL may be used uninitialized. */ 01923 yyval = yyvsp[1-yylen]; 01924 01925 01926 YY_REDUCE_PRINT (yyn); 01927 switch (yyn) 01928 { 01929 case 2: 01930 01931 /* Line 1455 of yacc.c */ 01932 #line 301 "parser/faustparser.y" 01933 { (yyval.exp) = (yyvsp[(1) - (1)].exp); gResult = formatDefinitions((yyval.exp)); ;} 01934 break; 01935 01936 case 3: 01937 01938 /* Line 1455 of yacc.c */ 01939 #line 304 "parser/faustparser.y" 01940 { (yyval.exp) = nil; ;} 01941 break; 01942 01943 case 4: 01944 01945 /* Line 1455 of yacc.c */ 01946 #line 305 "parser/faustparser.y" 01947 { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); ;} 01948 break; 01949 01950 case 5: 01951 01952 /* Line 1455 of yacc.c */ 01953 #line 307 "parser/faustparser.y" 01954 { (yyval.exp) = nil; ;} 01955 break; 01956 01957 case 6: 01958 01959 /* Line 1455 of yacc.c */ 01960 #line 308 "parser/faustparser.y" 01961 { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); ;} 01962 break; 01963 01964 case 7: 01965 01966 /* Line 1455 of yacc.c */ 01967 #line 311 "parser/faustparser.y" 01968 { (yyval.exp) = importFile((yyvsp[(3) - (5)].exp)); ;} 01969 break; 01970 01971 case 8: 01972 01973 /* Line 1455 of yacc.c */ 01974 #line 312 "parser/faustparser.y" 01975 { declareMetadata((yyvsp[(2) - (4)].exp),(yyvsp[(3) - (4)].exp)); (yyval.exp) = nil; ;} 01976 break; 01977 01978 case 9: 01979 01980 /* Line 1455 of yacc.c */ 01981 #line 313 "parser/faustparser.y" 01982 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 01983 break; 01984 01985 case 10: 01986 01987 /* Line 1455 of yacc.c */ 01988 #line 314 "parser/faustparser.y" 01989 { declareDoc((yyvsp[(2) - (3)].exp)); (yyval.exp) = nil; /* cerr << "Yacc : doc : " << *$2 << endl; */ ;} 01990 break; 01991 01992 case 11: 01993 01994 /* Line 1455 of yacc.c */ 01995 #line 317 "parser/faustparser.y" 01996 { (yyval.exp) = nil; ;} 01997 break; 01998 01999 case 12: 02000 02001 /* Line 1455 of yacc.c */ 02002 #line 318 "parser/faustparser.y" 02003 { (yyval.exp) = cons ((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); ;} 02004 break; 02005 02006 case 13: 02007 02008 /* Line 1455 of yacc.c */ 02009 #line 321 "parser/faustparser.y" 02010 { (yyval.exp) = docTxt((yyvsp[(1) - (1)].cppstr)->c_str()); delete (yyvsp[(1) - (1)].cppstr); ;} 02011 break; 02012 02013 case 14: 02014 02015 /* Line 1455 of yacc.c */ 02016 #line 322 "parser/faustparser.y" 02017 { (yyval.exp) = docEqn((yyvsp[(1) - (1)].exp)); ;} 02018 break; 02019 02020 case 15: 02021 02022 /* Line 1455 of yacc.c */ 02023 #line 323 "parser/faustparser.y" 02024 { (yyval.exp) = docDgm((yyvsp[(1) - (1)].exp)); ;} 02025 break; 02026 02027 case 16: 02028 02029 /* Line 1455 of yacc.c */ 02030 #line 324 "parser/faustparser.y" 02031 { (yyval.exp) = docNtc(); ;} 02032 break; 02033 02034 case 17: 02035 02036 /* Line 1455 of yacc.c */ 02037 #line 325 "parser/faustparser.y" 02038 { (yyval.exp) = docLst(); ;} 02039 break; 02040 02041 case 18: 02042 02043 /* Line 1455 of yacc.c */ 02044 #line 326 "parser/faustparser.y" 02045 { (yyval.exp) = docMtd((yyvsp[(1) - (1)].exp)); ;} 02046 break; 02047 02048 case 19: 02049 02050 /* Line 1455 of yacc.c */ 02051 #line 329 "parser/faustparser.y" 02052 { (yyval.cppstr) = new string(); ;} 02053 break; 02054 02055 case 20: 02056 02057 /* Line 1455 of yacc.c */ 02058 #line 330 "parser/faustparser.y" 02059 { (yyval.cppstr) = &((yyvsp[(1) - (2)].cppstr)->append(yytext)); ;} 02060 break; 02061 02062 case 21: 02063 02064 /* Line 1455 of yacc.c */ 02065 #line 333 "parser/faustparser.y" 02066 { (yyval.exp) = (yyvsp[(2) - (3)].exp); ;} 02067 break; 02068 02069 case 22: 02070 02071 /* Line 1455 of yacc.c */ 02072 #line 336 "parser/faustparser.y" 02073 { (yyval.exp) = (yyvsp[(2) - (3)].exp); ;} 02074 break; 02075 02076 case 23: 02077 02078 /* Line 1455 of yacc.c */ 02079 #line 339 "parser/faustparser.y" 02080 { ;} 02081 break; 02082 02083 case 24: 02084 02085 /* Line 1455 of yacc.c */ 02086 #line 342 "parser/faustparser.y" 02087 { ;} 02088 break; 02089 02090 case 25: 02091 02092 /* Line 1455 of yacc.c */ 02093 #line 345 "parser/faustparser.y" 02094 { ;} 02095 break; 02096 02097 case 26: 02098 02099 /* Line 1455 of yacc.c */ 02100 #line 346 "parser/faustparser.y" 02101 { ;} 02102 break; 02103 02104 case 27: 02105 02106 /* Line 1455 of yacc.c */ 02107 #line 349 "parser/faustparser.y" 02108 { gLstDependenciesSwitch = (yyvsp[(4) - (5)].b); ;} 02109 break; 02110 02111 case 28: 02112 02113 /* Line 1455 of yacc.c */ 02114 #line 350 "parser/faustparser.y" 02115 { gStripDocSwitch = (yyvsp[(4) - (5)].b); gStripDocSwitch==true ? gStripDocSwitch=false : gStripDocSwitch=true; ;} 02116 break; 02117 02118 case 29: 02119 02120 /* Line 1455 of yacc.c */ 02121 #line 351 "parser/faustparser.y" 02122 { gLstDistributedSwitch = (yyvsp[(4) - (5)].b); ;} 02123 break; 02124 02125 case 30: 02126 02127 /* Line 1455 of yacc.c */ 02128 #line 354 "parser/faustparser.y" 02129 { (yyval.b) = true; ;} 02130 break; 02131 02132 case 31: 02133 02134 /* Line 1455 of yacc.c */ 02135 #line 355 "parser/faustparser.y" 02136 { (yyval.b) = false; ;} 02137 break; 02138 02139 case 32: 02140 02141 /* Line 1455 of yacc.c */ 02142 #line 358 "parser/faustparser.y" 02143 { (yyval.exp) = (yyvsp[(2) - (3)].exp); ;} 02144 break; 02145 02146 case 33: 02147 02148 /* Line 1455 of yacc.c */ 02149 #line 361 "parser/faustparser.y" 02150 { (yyval.exp) = cons((yyvsp[(1) - (7)].exp),cons((yyvsp[(3) - (7)].exp),(yyvsp[(6) - (7)].exp))); ;} 02151 break; 02152 02153 case 34: 02154 02155 /* Line 1455 of yacc.c */ 02156 #line 362 "parser/faustparser.y" 02157 { (yyval.exp) = cons((yyvsp[(1) - (4)].exp),cons(nil,(yyvsp[(3) - (4)].exp))); ;} 02158 break; 02159 02160 case 35: 02161 02162 /* Line 1455 of yacc.c */ 02163 #line 363 "parser/faustparser.y" 02164 { (yyval.exp) = nil; yyerr++; ;} 02165 break; 02166 02167 case 36: 02168 02169 /* Line 1455 of yacc.c */ 02170 #line 366 "parser/faustparser.y" 02171 { (yyval.exp)=(yyvsp[(1) - (1)].exp); setDefProp((yyvsp[(1) - (1)].exp), yyfilename, yylineno); ;} 02172 break; 02173 02174 case 37: 02175 02176 /* Line 1455 of yacc.c */ 02177 #line 369 "parser/faustparser.y" 02178 { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); ;} 02179 break; 02180 02181 case 38: 02182 02183 /* Line 1455 of yacc.c */ 02184 #line 370 "parser/faustparser.y" 02185 { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); ;} 02186 break; 02187 02188 case 39: 02189 02190 /* Line 1455 of yacc.c */ 02191 #line 373 "parser/faustparser.y" 02192 { (yyval.exp) = boxWithLocalDef((yyvsp[(1) - (5)].exp),formatDefinitions((yyvsp[(4) - (5)].exp))); ;} 02193 break; 02194 02195 case 40: 02196 02197 /* Line 1455 of yacc.c */ 02198 #line 374 "parser/faustparser.y" 02199 { (yyval.exp) = boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02200 break; 02201 02202 case 41: 02203 02204 /* Line 1455 of yacc.c */ 02205 #line 375 "parser/faustparser.y" 02206 { (yyval.exp) = boxSeq((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02207 break; 02208 02209 case 42: 02210 02211 /* Line 1455 of yacc.c */ 02212 #line 376 "parser/faustparser.y" 02213 { (yyval.exp) = boxSplit((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02214 break; 02215 02216 case 43: 02217 02218 /* Line 1455 of yacc.c */ 02219 #line 377 "parser/faustparser.y" 02220 { (yyval.exp) = boxMerge((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02221 break; 02222 02223 case 44: 02224 02225 /* Line 1455 of yacc.c */ 02226 #line 378 "parser/faustparser.y" 02227 { (yyval.exp) = boxRec((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02228 break; 02229 02230 case 45: 02231 02232 /* Line 1455 of yacc.c */ 02233 #line 379 "parser/faustparser.y" 02234 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02235 break; 02236 02237 case 46: 02238 02239 /* Line 1455 of yacc.c */ 02240 #line 382 "parser/faustparser.y" 02241 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigAdd)); ;} 02242 break; 02243 02244 case 47: 02245 02246 /* Line 1455 of yacc.c */ 02247 #line 383 "parser/faustparser.y" 02248 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigSub)); ;} 02249 break; 02250 02251 case 48: 02252 02253 /* Line 1455 of yacc.c */ 02254 #line 384 "parser/faustparser.y" 02255 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigMul)); ;} 02256 break; 02257 02258 case 49: 02259 02260 /* Line 1455 of yacc.c */ 02261 #line 385 "parser/faustparser.y" 02262 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigDiv)); ;} 02263 break; 02264 02265 case 50: 02266 02267 /* Line 1455 of yacc.c */ 02268 #line 386 "parser/faustparser.y" 02269 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigRem)); ;} 02270 break; 02271 02272 case 51: 02273 02274 /* Line 1455 of yacc.c */ 02275 #line 387 "parser/faustparser.y" 02276 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),gPowPrim->box()); ;} 02277 break; 02278 02279 case 52: 02280 02281 /* Line 1455 of yacc.c */ 02282 #line 388 "parser/faustparser.y" 02283 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigFixDelay)); ;} 02284 break; 02285 02286 case 53: 02287 02288 /* Line 1455 of yacc.c */ 02289 #line 389 "parser/faustparser.y" 02290 { (yyval.exp) = boxSeq((yyvsp[(1) - (2)].exp),boxPrim1(sigDelay1)); ;} 02291 break; 02292 02293 case 54: 02294 02295 /* Line 1455 of yacc.c */ 02296 #line 390 "parser/faustparser.y" 02297 { (yyval.exp) = boxAccess((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02298 break; 02299 02300 case 55: 02301 02302 /* Line 1455 of yacc.c */ 02303 #line 392 "parser/faustparser.y" 02304 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigAND)); ;} 02305 break; 02306 02307 case 56: 02308 02309 /* Line 1455 of yacc.c */ 02310 #line 393 "parser/faustparser.y" 02311 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigOR)); ;} 02312 break; 02313 02314 case 57: 02315 02316 /* Line 1455 of yacc.c */ 02317 #line 394 "parser/faustparser.y" 02318 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigXOR)); ;} 02319 break; 02320 02321 case 58: 02322 02323 /* Line 1455 of yacc.c */ 02324 #line 396 "parser/faustparser.y" 02325 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLeftShift)); ;} 02326 break; 02327 02328 case 59: 02329 02330 /* Line 1455 of yacc.c */ 02331 #line 397 "parser/faustparser.y" 02332 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigRightShift)); ;} 02333 break; 02334 02335 case 60: 02336 02337 /* Line 1455 of yacc.c */ 02338 #line 399 "parser/faustparser.y" 02339 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLT)); ;} 02340 break; 02341 02342 case 61: 02343 02344 /* Line 1455 of yacc.c */ 02345 #line 400 "parser/faustparser.y" 02346 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigLE)); ;} 02347 break; 02348 02349 case 62: 02350 02351 /* Line 1455 of yacc.c */ 02352 #line 401 "parser/faustparser.y" 02353 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigGT)); ;} 02354 break; 02355 02356 case 63: 02357 02358 /* Line 1455 of yacc.c */ 02359 #line 402 "parser/faustparser.y" 02360 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigGE)); ;} 02361 break; 02362 02363 case 64: 02364 02365 /* Line 1455 of yacc.c */ 02366 #line 403 "parser/faustparser.y" 02367 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigEQ)); ;} 02368 break; 02369 02370 case 65: 02371 02372 /* Line 1455 of yacc.c */ 02373 #line 404 "parser/faustparser.y" 02374 { (yyval.exp) = boxSeq(boxPar((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)),boxPrim2(sigNE)); ;} 02375 break; 02376 02377 case 66: 02378 02379 /* Line 1455 of yacc.c */ 02380 #line 406 "parser/faustparser.y" 02381 { (yyval.exp) = buildBoxAppl((yyvsp[(1) - (4)].exp),(yyvsp[(3) - (4)].exp)); ;} 02382 break; 02383 02384 case 67: 02385 02386 /* Line 1455 of yacc.c */ 02387 #line 407 "parser/faustparser.y" 02388 { (yyval.exp) = boxModifLocalDef((yyvsp[(1) - (4)].exp),formatDefinitions((yyvsp[(3) - (4)].exp))); ;} 02389 break; 02390 02391 case 68: 02392 02393 /* Line 1455 of yacc.c */ 02394 #line 409 "parser/faustparser.y" 02395 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02396 break; 02397 02398 case 69: 02399 02400 /* Line 1455 of yacc.c */ 02401 #line 412 "parser/faustparser.y" 02402 { (yyval.exp) = boxInt(atoi(yytext)); ;} 02403 break; 02404 02405 case 70: 02406 02407 /* Line 1455 of yacc.c */ 02408 #line 413 "parser/faustparser.y" 02409 { (yyval.exp) = boxReal(atof(yytext)); ;} 02410 break; 02411 02412 case 71: 02413 02414 /* Line 1455 of yacc.c */ 02415 #line 415 "parser/faustparser.y" 02416 { (yyval.exp) = boxInt (atoi(yytext)); ;} 02417 break; 02418 02419 case 72: 02420 02421 /* Line 1455 of yacc.c */ 02422 #line 416 "parser/faustparser.y" 02423 { (yyval.exp) = boxReal(atof(yytext)); ;} 02424 break; 02425 02426 case 73: 02427 02428 /* Line 1455 of yacc.c */ 02429 #line 418 "parser/faustparser.y" 02430 { (yyval.exp) = boxInt ( -atoi(yytext) ); ;} 02431 break; 02432 02433 case 74: 02434 02435 /* Line 1455 of yacc.c */ 02436 #line 419 "parser/faustparser.y" 02437 { (yyval.exp) = boxReal( -atof(yytext) ); ;} 02438 break; 02439 02440 case 75: 02441 02442 /* Line 1455 of yacc.c */ 02443 #line 421 "parser/faustparser.y" 02444 { (yyval.exp) = boxWire(); ;} 02445 break; 02446 02447 case 76: 02448 02449 /* Line 1455 of yacc.c */ 02450 #line 422 "parser/faustparser.y" 02451 { (yyval.exp) = boxCut(); ;} 02452 break; 02453 02454 case 77: 02455 02456 /* Line 1455 of yacc.c */ 02457 #line 424 "parser/faustparser.y" 02458 { (yyval.exp) = boxPrim1(sigDelay1); ;} 02459 break; 02460 02461 case 78: 02462 02463 /* Line 1455 of yacc.c */ 02464 #line 425 "parser/faustparser.y" 02465 { (yyval.exp) = boxPrim2(sigPrefix); ;} 02466 break; 02467 02468 case 79: 02469 02470 /* Line 1455 of yacc.c */ 02471 #line 427 "parser/faustparser.y" 02472 { (yyval.exp) = boxPrim1(sigIntCast); ;} 02473 break; 02474 02475 case 80: 02476 02477 /* Line 1455 of yacc.c */ 02478 #line 428 "parser/faustparser.y" 02479 { (yyval.exp) = boxPrim1(sigFloatCast); ;} 02480 break; 02481 02482 case 81: 02483 02484 /* Line 1455 of yacc.c */ 02485 #line 430 "parser/faustparser.y" 02486 { (yyval.exp) = boxPrim2(sigAdd); ;} 02487 break; 02488 02489 case 82: 02490 02491 /* Line 1455 of yacc.c */ 02492 #line 431 "parser/faustparser.y" 02493 { (yyval.exp) = boxPrim2(sigSub); ;} 02494 break; 02495 02496 case 83: 02497 02498 /* Line 1455 of yacc.c */ 02499 #line 432 "parser/faustparser.y" 02500 { (yyval.exp) = boxPrim2(sigMul); ;} 02501 break; 02502 02503 case 84: 02504 02505 /* Line 1455 of yacc.c */ 02506 #line 433 "parser/faustparser.y" 02507 { (yyval.exp) = boxPrim2(sigDiv); ;} 02508 break; 02509 02510 case 85: 02511 02512 /* Line 1455 of yacc.c */ 02513 #line 434 "parser/faustparser.y" 02514 { (yyval.exp) = boxPrim2(sigRem); ;} 02515 break; 02516 02517 case 86: 02518 02519 /* Line 1455 of yacc.c */ 02520 #line 435 "parser/faustparser.y" 02521 { (yyval.exp) = boxPrim2(sigFixDelay); ;} 02522 break; 02523 02524 case 87: 02525 02526 /* Line 1455 of yacc.c */ 02527 #line 437 "parser/faustparser.y" 02528 { (yyval.exp) = boxPrim2(sigAND); ;} 02529 break; 02530 02531 case 88: 02532 02533 /* Line 1455 of yacc.c */ 02534 #line 438 "parser/faustparser.y" 02535 { (yyval.exp) = boxPrim2(sigOR); ;} 02536 break; 02537 02538 case 89: 02539 02540 /* Line 1455 of yacc.c */ 02541 #line 439 "parser/faustparser.y" 02542 { (yyval.exp) = boxPrim2(sigXOR); ;} 02543 break; 02544 02545 case 90: 02546 02547 /* Line 1455 of yacc.c */ 02548 #line 441 "parser/faustparser.y" 02549 { (yyval.exp) = boxPrim2(sigLeftShift); ;} 02550 break; 02551 02552 case 91: 02553 02554 /* Line 1455 of yacc.c */ 02555 #line 442 "parser/faustparser.y" 02556 { (yyval.exp) = boxPrim2(sigRightShift); ;} 02557 break; 02558 02559 case 92: 02560 02561 /* Line 1455 of yacc.c */ 02562 #line 444 "parser/faustparser.y" 02563 { (yyval.exp) = boxPrim2(sigLT); ;} 02564 break; 02565 02566 case 93: 02567 02568 /* Line 1455 of yacc.c */ 02569 #line 445 "parser/faustparser.y" 02570 { (yyval.exp) = boxPrim2(sigLE); ;} 02571 break; 02572 02573 case 94: 02574 02575 /* Line 1455 of yacc.c */ 02576 #line 446 "parser/faustparser.y" 02577 { (yyval.exp) = boxPrim2(sigGT); ;} 02578 break; 02579 02580 case 95: 02581 02582 /* Line 1455 of yacc.c */ 02583 #line 447 "parser/faustparser.y" 02584 { (yyval.exp) = boxPrim2(sigGE); ;} 02585 break; 02586 02587 case 96: 02588 02589 /* Line 1455 of yacc.c */ 02590 #line 448 "parser/faustparser.y" 02591 { (yyval.exp) = boxPrim2(sigEQ); ;} 02592 break; 02593 02594 case 97: 02595 02596 /* Line 1455 of yacc.c */ 02597 #line 449 "parser/faustparser.y" 02598 { (yyval.exp) = boxPrim2(sigNE); ;} 02599 break; 02600 02601 case 98: 02602 02603 /* Line 1455 of yacc.c */ 02604 #line 451 "parser/faustparser.y" 02605 { (yyval.exp) = boxPrim2(sigAttach); ;} 02606 break; 02607 02608 case 99: 02609 02610 /* Line 1455 of yacc.c */ 02611 #line 453 "parser/faustparser.y" 02612 { (yyval.exp) = gAcosPrim->box(); ;} 02613 break; 02614 02615 case 100: 02616 02617 /* Line 1455 of yacc.c */ 02618 #line 454 "parser/faustparser.y" 02619 { (yyval.exp) = gAsinPrim->box(); ;} 02620 break; 02621 02622 case 101: 02623 02624 /* Line 1455 of yacc.c */ 02625 #line 455 "parser/faustparser.y" 02626 { (yyval.exp) = gAtanPrim->box(); ;} 02627 break; 02628 02629 case 102: 02630 02631 /* Line 1455 of yacc.c */ 02632 #line 456 "parser/faustparser.y" 02633 { (yyval.exp) = gAtan2Prim->box(); ;} 02634 break; 02635 02636 case 103: 02637 02638 /* Line 1455 of yacc.c */ 02639 #line 457 "parser/faustparser.y" 02640 { (yyval.exp) = gCosPrim->box(); ;} 02641 break; 02642 02643 case 104: 02644 02645 /* Line 1455 of yacc.c */ 02646 #line 458 "parser/faustparser.y" 02647 { (yyval.exp) = gSinPrim->box(); ;} 02648 break; 02649 02650 case 105: 02651 02652 /* Line 1455 of yacc.c */ 02653 #line 459 "parser/faustparser.y" 02654 { (yyval.exp) = gTanPrim->box(); ;} 02655 break; 02656 02657 case 106: 02658 02659 /* Line 1455 of yacc.c */ 02660 #line 461 "parser/faustparser.y" 02661 { (yyval.exp) = gExpPrim->box(); ;} 02662 break; 02663 02664 case 107: 02665 02666 /* Line 1455 of yacc.c */ 02667 #line 462 "parser/faustparser.y" 02668 { (yyval.exp) = gLogPrim->box(); ;} 02669 break; 02670 02671 case 108: 02672 02673 /* Line 1455 of yacc.c */ 02674 #line 463 "parser/faustparser.y" 02675 { (yyval.exp) = gLog10Prim->box(); ;} 02676 break; 02677 02678 case 109: 02679 02680 /* Line 1455 of yacc.c */ 02681 #line 464 "parser/faustparser.y" 02682 { (yyval.exp) = gPowPrim->box(); ;} 02683 break; 02684 02685 case 110: 02686 02687 /* Line 1455 of yacc.c */ 02688 #line 465 "parser/faustparser.y" 02689 { (yyval.exp) = gPowPrim->box(); ;} 02690 break; 02691 02692 case 111: 02693 02694 /* Line 1455 of yacc.c */ 02695 #line 466 "parser/faustparser.y" 02696 { (yyval.exp) = gSqrtPrim->box(); ;} 02697 break; 02698 02699 case 112: 02700 02701 /* Line 1455 of yacc.c */ 02702 #line 468 "parser/faustparser.y" 02703 { (yyval.exp) = gAbsPrim->box(); ;} 02704 break; 02705 02706 case 113: 02707 02708 /* Line 1455 of yacc.c */ 02709 #line 469 "parser/faustparser.y" 02710 { (yyval.exp) = gMinPrim->box(); ;} 02711 break; 02712 02713 case 114: 02714 02715 /* Line 1455 of yacc.c */ 02716 #line 470 "parser/faustparser.y" 02717 { (yyval.exp) = gMaxPrim->box(); ;} 02718 break; 02719 02720 case 115: 02721 02722 /* Line 1455 of yacc.c */ 02723 #line 472 "parser/faustparser.y" 02724 { (yyval.exp) = gFmodPrim->box(); ;} 02725 break; 02726 02727 case 116: 02728 02729 /* Line 1455 of yacc.c */ 02730 #line 473 "parser/faustparser.y" 02731 { (yyval.exp) = gRemainderPrim->box(); ;} 02732 break; 02733 02734 case 117: 02735 02736 /* Line 1455 of yacc.c */ 02737 #line 475 "parser/faustparser.y" 02738 { (yyval.exp) = gFloorPrim->box(); ;} 02739 break; 02740 02741 case 118: 02742 02743 /* Line 1455 of yacc.c */ 02744 #line 476 "parser/faustparser.y" 02745 { (yyval.exp) = gCeilPrim->box(); ;} 02746 break; 02747 02748 case 119: 02749 02750 /* Line 1455 of yacc.c */ 02751 #line 477 "parser/faustparser.y" 02752 { (yyval.exp) = gRintPrim->box(); ;} 02753 break; 02754 02755 case 120: 02756 02757 /* Line 1455 of yacc.c */ 02758 #line 480 "parser/faustparser.y" 02759 { (yyval.exp) = boxPrim3(sigReadOnlyTable); ;} 02760 break; 02761 02762 case 121: 02763 02764 /* Line 1455 of yacc.c */ 02765 #line 481 "parser/faustparser.y" 02766 { (yyval.exp) = boxPrim5(sigWriteReadTable); ;} 02767 break; 02768 02769 case 122: 02770 02771 /* Line 1455 of yacc.c */ 02772 #line 483 "parser/faustparser.y" 02773 { (yyval.exp) = boxPrim3(sigSelect2); ;} 02774 break; 02775 02776 case 123: 02777 02778 /* Line 1455 of yacc.c */ 02779 #line 484 "parser/faustparser.y" 02780 { (yyval.exp) = boxPrim4(sigSelect3); ;} 02781 break; 02782 02783 case 124: 02784 02785 /* Line 1455 of yacc.c */ 02786 #line 486 "parser/faustparser.y" 02787 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02788 break; 02789 02790 case 125: 02791 02792 /* Line 1455 of yacc.c */ 02793 #line 487 "parser/faustparser.y" 02794 { (yyval.exp) = boxSeq(boxPar(boxInt(0),(yyvsp[(2) - (2)].exp)),boxPrim2(sigSub)); ;} 02795 break; 02796 02797 case 126: 02798 02799 /* Line 1455 of yacc.c */ 02800 #line 489 "parser/faustparser.y" 02801 { (yyval.exp) = (yyvsp[(2) - (3)].exp); ;} 02802 break; 02803 02804 case 127: 02805 02806 /* Line 1455 of yacc.c */ 02807 #line 491 "parser/faustparser.y" 02808 { (yyval.exp) = buildBoxAbstr((yyvsp[(3) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 02809 break; 02810 02811 case 128: 02812 02813 /* Line 1455 of yacc.c */ 02814 #line 493 "parser/faustparser.y" 02815 { (yyval.exp) = boxCase(checkRulelist((yyvsp[(3) - (4)].exp))); ;} 02816 break; 02817 02818 case 129: 02819 02820 /* Line 1455 of yacc.c */ 02821 #line 495 "parser/faustparser.y" 02822 { (yyval.exp) = boxFFun((yyvsp[(1) - (1)].exp)); ;} 02823 break; 02824 02825 case 130: 02826 02827 /* Line 1455 of yacc.c */ 02828 #line 496 "parser/faustparser.y" 02829 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02830 break; 02831 02832 case 131: 02833 02834 /* Line 1455 of yacc.c */ 02835 #line 497 "parser/faustparser.y" 02836 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02837 break; 02838 02839 case 132: 02840 02841 /* Line 1455 of yacc.c */ 02842 #line 498 "parser/faustparser.y" 02843 { (yyval.exp) = boxComponent((yyvsp[(3) - (4)].exp)); ;} 02844 break; 02845 02846 case 133: 02847 02848 /* Line 1455 of yacc.c */ 02849 #line 499 "parser/faustparser.y" 02850 { (yyval.exp) = boxLibrary((yyvsp[(3) - (4)].exp)); ;} 02851 break; 02852 02853 case 134: 02854 02855 /* Line 1455 of yacc.c */ 02856 #line 500 "parser/faustparser.y" 02857 { (yyval.exp) = boxWithLocalDef(boxEnvironment(),formatDefinitions((yyvsp[(3) - (4)].exp))); ;} 02858 break; 02859 02860 case 135: 02861 02862 /* Line 1455 of yacc.c */ 02863 #line 502 "parser/faustparser.y" 02864 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02865 break; 02866 02867 case 136: 02868 02869 /* Line 1455 of yacc.c */ 02870 #line 503 "parser/faustparser.y" 02871 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02872 break; 02873 02874 case 137: 02875 02876 /* Line 1455 of yacc.c */ 02877 #line 504 "parser/faustparser.y" 02878 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02879 break; 02880 02881 case 138: 02882 02883 /* Line 1455 of yacc.c */ 02884 #line 505 "parser/faustparser.y" 02885 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02886 break; 02887 02888 case 139: 02889 02890 /* Line 1455 of yacc.c */ 02891 #line 506 "parser/faustparser.y" 02892 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02893 break; 02894 02895 case 140: 02896 02897 /* Line 1455 of yacc.c */ 02898 #line 507 "parser/faustparser.y" 02899 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02900 break; 02901 02902 case 141: 02903 02904 /* Line 1455 of yacc.c */ 02905 #line 508 "parser/faustparser.y" 02906 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02907 break; 02908 02909 case 142: 02910 02911 /* Line 1455 of yacc.c */ 02912 #line 509 "parser/faustparser.y" 02913 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02914 break; 02915 02916 case 143: 02917 02918 /* Line 1455 of yacc.c */ 02919 #line 510 "parser/faustparser.y" 02920 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02921 break; 02922 02923 case 144: 02924 02925 /* Line 1455 of yacc.c */ 02926 #line 511 "parser/faustparser.y" 02927 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02928 break; 02929 02930 case 145: 02931 02932 /* Line 1455 of yacc.c */ 02933 #line 513 "parser/faustparser.y" 02934 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02935 break; 02936 02937 case 146: 02938 02939 /* Line 1455 of yacc.c */ 02940 #line 514 "parser/faustparser.y" 02941 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02942 break; 02943 02944 case 147: 02945 02946 /* Line 1455 of yacc.c */ 02947 #line 515 "parser/faustparser.y" 02948 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02949 break; 02950 02951 case 148: 02952 02953 /* Line 1455 of yacc.c */ 02954 #line 516 "parser/faustparser.y" 02955 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 02956 break; 02957 02958 case 149: 02959 02960 /* Line 1455 of yacc.c */ 02961 #line 520 "parser/faustparser.y" 02962 { (yyval.exp) = boxIdent(yytext); ;} 02963 break; 02964 02965 case 150: 02966 02967 /* Line 1455 of yacc.c */ 02968 #line 523 "parser/faustparser.y" 02969 { (yyval.exp) = tree(yytext); ;} 02970 break; 02971 02972 case 151: 02973 02974 /* Line 1455 of yacc.c */ 02975 #line 528 "parser/faustparser.y" 02976 { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); ;} 02977 break; 02978 02979 case 152: 02980 02981 /* Line 1455 of yacc.c */ 02982 #line 529 "parser/faustparser.y" 02983 { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); ;} 02984 break; 02985 02986 case 153: 02987 02988 /* Line 1455 of yacc.c */ 02989 #line 532 "parser/faustparser.y" 02990 { (yyval.exp) = boxSeq((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02991 break; 02992 02993 case 154: 02994 02995 /* Line 1455 of yacc.c */ 02996 #line 533 "parser/faustparser.y" 02997 { (yyval.exp) = boxSplit((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 02998 break; 02999 03000 case 155: 03001 03002 /* Line 1455 of yacc.c */ 03003 #line 534 "parser/faustparser.y" 03004 { (yyval.exp) = boxMerge((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 03005 break; 03006 03007 case 156: 03008 03009 /* Line 1455 of yacc.c */ 03010 #line 535 "parser/faustparser.y" 03011 { (yyval.exp) = boxRec((yyvsp[(1) - (3)].exp),(yyvsp[(3) - (3)].exp)); ;} 03012 break; 03013 03014 case 157: 03015 03016 /* Line 1455 of yacc.c */ 03017 #line 536 "parser/faustparser.y" 03018 { (yyval.exp) = (yyvsp[(1) - (1)].exp); ;} 03019 break; 03020 03021 case 158: 03022 03023 /* Line 1455 of yacc.c */ 03024 #line 539 "parser/faustparser.y" 03025 { (yyval.exp) = tree(yytext); ;} 03026 break; 03027 03028 case 159: 03029 03030 /* Line 1455 of yacc.c */ 03031 #line 542 "parser/faustparser.y" 03032 { (yyval.exp) = unquote(yytext); ;} 03033 break; 03034 03035 case 160: 03036 03037 /* Line 1455 of yacc.c */ 03038 #line 545 "parser/faustparser.y" 03039 { (yyval.exp) = tree(yytext); ;} 03040 break; 03041 03042 case 161: 03043 03044 /* Line 1455 of yacc.c */ 03045 #line 546 "parser/faustparser.y" 03046 { (yyval.exp) = tree(yytext); ;} 03047 break; 03048 03049 case 162: 03050 03051 /* Line 1455 of yacc.c */ 03052 #line 552 "parser/faustparser.y" 03053 { (yyval.exp) = boxIPar((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 03054 break; 03055 03056 case 163: 03057 03058 /* Line 1455 of yacc.c */ 03059 #line 556 "parser/faustparser.y" 03060 { (yyval.exp) = boxISeq((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 03061 break; 03062 03063 case 164: 03064 03065 /* Line 1455 of yacc.c */ 03066 #line 560 "parser/faustparser.y" 03067 { (yyval.exp) = boxISum((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 03068 break; 03069 03070 case 165: 03071 03072 /* Line 1455 of yacc.c */ 03073 #line 564 "parser/faustparser.y" 03074 { (yyval.exp) = boxIProd((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 03075 break; 03076 03077 case 166: 03078 03079 /* Line 1455 of yacc.c */ 03080 #line 571 "parser/faustparser.y" 03081 { (yyval.exp) = ffunction((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 03082 break; 03083 03084 case 167: 03085 03086 /* Line 1455 of yacc.c */ 03087 #line 575 "parser/faustparser.y" 03088 { (yyval.exp) = boxFConst((yyvsp[(3) - (7)].exp),(yyvsp[(4) - (7)].exp),(yyvsp[(6) - (7)].exp)); ;} 03089 break; 03090 03091 case 168: 03092 03093 /* Line 1455 of yacc.c */ 03094 #line 578 "parser/faustparser.y" 03095 { (yyval.exp) = boxFVar((yyvsp[(3) - (7)].exp),(yyvsp[(4) - (7)].exp),(yyvsp[(6) - (7)].exp)); ;} 03096 break; 03097 03098 case 169: 03099 03100 /* Line 1455 of yacc.c */ 03101 #line 582 "parser/faustparser.y" 03102 { (yyval.exp) = boxButton((yyvsp[(3) - (4)].exp)); ;} 03103 break; 03104 03105 case 170: 03106 03107 /* Line 1455 of yacc.c */ 03108 #line 585 "parser/faustparser.y" 03109 { (yyval.exp) = boxCheckbox((yyvsp[(3) - (4)].exp)); ;} 03110 break; 03111 03112 case 171: 03113 03114 /* Line 1455 of yacc.c */ 03115 #line 589 "parser/faustparser.y" 03116 { (yyval.exp) = boxVSlider((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); ;} 03117 break; 03118 03119 case 172: 03120 03121 /* Line 1455 of yacc.c */ 03122 #line 592 "parser/faustparser.y" 03123 { (yyval.exp) = boxHSlider((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); ;} 03124 break; 03125 03126 case 173: 03127 03128 /* Line 1455 of yacc.c */ 03129 #line 595 "parser/faustparser.y" 03130 { (yyval.exp) = boxNumEntry((yyvsp[(3) - (12)].exp),(yyvsp[(5) - (12)].exp),(yyvsp[(7) - (12)].exp),(yyvsp[(9) - (12)].exp),(yyvsp[(11) - (12)].exp)); ;} 03131 break; 03132 03133 case 174: 03134 03135 /* Line 1455 of yacc.c */ 03136 #line 598 "parser/faustparser.y" 03137 { (yyval.exp) = boxVGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); ;} 03138 break; 03139 03140 case 175: 03141 03142 /* Line 1455 of yacc.c */ 03143 #line 601 "parser/faustparser.y" 03144 { (yyval.exp) = boxHGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); ;} 03145 break; 03146 03147 case 176: 03148 03149 /* Line 1455 of yacc.c */ 03150 #line 604 "parser/faustparser.y" 03151 { (yyval.exp) = boxTGroup((yyvsp[(3) - (6)].exp), (yyvsp[(5) - (6)].exp)); ;} 03152 break; 03153 03154 case 177: 03155 03156 /* Line 1455 of yacc.c */ 03157 #line 608 "parser/faustparser.y" 03158 { (yyval.exp) = boxVBargraph((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 03159 break; 03160 03161 case 178: 03162 03163 /* Line 1455 of yacc.c */ 03164 #line 611 "parser/faustparser.y" 03165 { (yyval.exp) = boxHBargraph((yyvsp[(3) - (8)].exp),(yyvsp[(5) - (8)].exp),(yyvsp[(7) - (8)].exp)); ;} 03166 break; 03167 03168 case 179: 03169 03170 /* Line 1455 of yacc.c */ 03171 #line 616 "parser/faustparser.y" 03172 { (yyval.exp) = cons((yyvsp[(1) - (5)].exp), cons((yyvsp[(2) - (5)].exp), (yyvsp[(4) - (5)].exp))); ;} 03173 break; 03174 03175 case 180: 03176 03177 /* Line 1455 of yacc.c */ 03178 #line 617 "parser/faustparser.y" 03179 { (yyval.exp) = cons((yyvsp[(1) - (4)].exp), cons((yyvsp[(2) - (4)].exp), nil)); ;} 03180 break; 03181 03182 case 181: 03183 03184 /* Line 1455 of yacc.c */ 03185 #line 620 "parser/faustparser.y" 03186 { (yyval.exp) = tree(yytext); ;} 03187 break; 03188 03189 case 182: 03190 03191 /* Line 1455 of yacc.c */ 03192 #line 623 "parser/faustparser.y" 03193 { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); ;} 03194 break; 03195 03196 case 183: 03197 03198 /* Line 1455 of yacc.c */ 03199 #line 624 "parser/faustparser.y" 03200 { (yyval.exp) = cons((yyvsp[(3) - (3)].exp),(yyvsp[(1) - (3)].exp)); ;} 03201 break; 03202 03203 case 184: 03204 03205 /* Line 1455 of yacc.c */ 03206 #line 627 "parser/faustparser.y" 03207 { (yyval.exp) = cons((yyvsp[(1) - (1)].exp),nil); ;} 03208 break; 03209 03210 case 185: 03211 03212 /* Line 1455 of yacc.c */ 03213 #line 628 "parser/faustparser.y" 03214 { (yyval.exp) = cons((yyvsp[(2) - (2)].exp),(yyvsp[(1) - (2)].exp)); ;} 03215 break; 03216 03217 case 186: 03218 03219 /* Line 1455 of yacc.c */ 03220 #line 632 "parser/faustparser.y" 03221 { (yyval.exp) = cons((yyvsp[(2) - (6)].exp),(yyvsp[(5) - (6)].exp)); ;} 03222 break; 03223 03224 case 187: 03225 03226 /* Line 1455 of yacc.c */ 03227 #line 635 "parser/faustparser.y" 03228 { (yyval.exp) = tree(0); ;} 03229 break; 03230 03231 case 188: 03232 03233 /* Line 1455 of yacc.c */ 03234 #line 636 "parser/faustparser.y" 03235 { (yyval.exp) = tree(1); ;} 03236 break; 03237 03238 03239 03240 /* Line 1455 of yacc.c */ 03241 #line 3242 "parser/faustparser.cpp" 03242 default: break; 03243 } 03244 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); 03245 03246 YYPOPSTACK (yylen); 03247 yylen = 0; 03248 YY_STACK_PRINT (yyss, yyssp); 03249 03250 *++yyvsp = yyval; 03251 03252 /* Now `shift' the result of the reduction. Determine what state 03253 that goes to, based on the state we popped back to and the rule 03254 number reduced by. */ 03255 03256 yyn = yyr1[yyn]; 03257 03258 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; 03259 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) 03260 yystate = yytable[yystate]; 03261 else 03262 yystate = yydefgoto[yyn - YYNTOKENS]; 03263 03264 goto yynewstate; 03265 03266 03267 /*------------------------------------. 03268 | yyerrlab -- here on detecting error | 03269 `------------------------------------*/ 03270 yyerrlab: 03271 /* If not already recovering from an error, report this error. */ 03272 if (!yyerrstatus) 03273 { 03274 ++yynerrs; 03275 #if ! YYERROR_VERBOSE 03276 yyerror (YY_("syntax error")); 03277 #else 03278 { 03279 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); 03280 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) 03281 { 03282 YYSIZE_T yyalloc = 2 * yysize; 03283 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) 03284 yyalloc = YYSTACK_ALLOC_MAXIMUM; 03285 if (yymsg != yymsgbuf) 03286 YYSTACK_FREE (yymsg); 03287 yymsg = (char *) YYSTACK_ALLOC (yyalloc); 03288 if (yymsg) 03289 yymsg_alloc = yyalloc; 03290 else 03291 { 03292 yymsg = yymsgbuf; 03293 yymsg_alloc = sizeof yymsgbuf; 03294 } 03295 } 03296 03297 if (0 < yysize && yysize <= yymsg_alloc) 03298 { 03299 (void) yysyntax_error (yymsg, yystate, yychar); 03300 yyerror (yymsg); 03301 } 03302 else 03303 { 03304 yyerror (YY_("syntax error")); 03305 if (yysize != 0) 03306 goto yyexhaustedlab; 03307 } 03308 } 03309 #endif 03310 } 03311 03312 03313 03314 if (yyerrstatus == 3) 03315 { 03316 /* If just tried and failed to reuse lookahead token after an 03317 error, discard it. */ 03318 03319 if (yychar <= YYEOF) 03320 { 03321 /* Return failure if at end of input. */ 03322 if (yychar == YYEOF) 03323 YYABORT; 03324 } 03325 else 03326 { 03327 yydestruct ("Error: discarding", 03328 yytoken, &yylval); 03329 yychar = YYEMPTY; 03330 } 03331 } 03332 03333 /* Else will try to reuse lookahead token after shifting the error 03334 token. */ 03335 goto yyerrlab1; 03336 03337 03338 /*---------------------------------------------------. 03339 | yyerrorlab -- error raised explicitly by YYERROR. | 03340 `---------------------------------------------------*/ 03341 yyerrorlab: 03342 03343 /* Pacify compilers like GCC when the user code never invokes 03344 YYERROR and the label yyerrorlab therefore never appears in user 03345 code. */ 03346 if (/*CONSTCOND*/ 0) 03347 goto yyerrorlab; 03348 03349 /* Do not reclaim the symbols of the rule which action triggered 03350 this YYERROR. */ 03351 YYPOPSTACK (yylen); 03352 yylen = 0; 03353 YY_STACK_PRINT (yyss, yyssp); 03354 yystate = *yyssp; 03355 goto yyerrlab1; 03356 03357 03358 /*-------------------------------------------------------------. 03359 | yyerrlab1 -- common code for both syntax error and YYERROR. | 03360 `-------------------------------------------------------------*/ 03361 yyerrlab1: 03362 yyerrstatus = 3; /* Each real token shifted decrements this. */ 03363 03364 for (;;) 03365 { 03366 yyn = yypact[yystate]; 03367 if (yyn != YYPACT_NINF) 03368 { 03369 yyn += YYTERROR; 03370 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) 03371 { 03372 yyn = yytable[yyn]; 03373 if (0 < yyn) 03374 break; 03375 } 03376 } 03377 03378 /* Pop the current state because it cannot handle the error token. */ 03379 if (yyssp == yyss) 03380 YYABORT; 03381 03382 03383 yydestruct ("Error: popping", 03384 yystos[yystate], yyvsp); 03385 YYPOPSTACK (1); 03386 yystate = *yyssp; 03387 YY_STACK_PRINT (yyss, yyssp); 03388 } 03389 03390 *++yyvsp = yylval; 03391 03392 03393 /* Shift the error token. */ 03394 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); 03395 03396 yystate = yyn; 03397 goto yynewstate; 03398 03399 03400 /*-------------------------------------. 03401 | yyacceptlab -- YYACCEPT comes here. | 03402 `-------------------------------------*/ 03403 yyacceptlab: 03404 yyresult = 0; 03405 goto yyreturn; 03406 03407 /*-----------------------------------. 03408 | yyabortlab -- YYABORT comes here. | 03409 `-----------------------------------*/ 03410 yyabortlab: 03411 yyresult = 1; 03412 goto yyreturn; 03413 03414 #if !defined(yyoverflow) || YYERROR_VERBOSE 03415 /*-------------------------------------------------. 03416 | yyexhaustedlab -- memory exhaustion comes here. | 03417 `-------------------------------------------------*/ 03418 yyexhaustedlab: 03419 yyerror (YY_("memory exhausted")); 03420 yyresult = 2; 03421 /* Fall through. */ 03422 #endif 03423 03424 yyreturn: 03425 if (yychar != YYEMPTY) 03426 yydestruct ("Cleanup: discarding lookahead", 03427 yytoken, &yylval); 03428 /* Do not reclaim the symbols of the rule which action triggered 03429 this YYABORT or YYACCEPT. */ 03430 YYPOPSTACK (yylen); 03431 YY_STACK_PRINT (yyss, yyssp); 03432 while (yyssp != yyss) 03433 { 03434 yydestruct ("Cleanup: popping", 03435 yystos[*yyssp], yyvsp); 03436 YYPOPSTACK (1); 03437 } 03438 #ifndef yyoverflow 03439 if (yyss != yyssa) 03440 YYSTACK_FREE (yyss); 03441 #endif 03442 #if YYERROR_VERBOSE 03443 if (yymsg != yymsgbuf) 03444 YYSTACK_FREE (yymsg); 03445 #endif 03446 /* Make sure YYID is used. */ 03447 return YYID (yyresult); 03448 } 03449 03450 03451 03452 /* Line 1675 of yacc.c */ 03453 #line 639 "parser/faustparser.y" 03454 03455 03456
1.8.0