00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037 #define YYBISON 1
00038
00039
00040 #define YYBISON_VERSION "2.1"
00041
00042
00043 #define YYSKELETON_NAME "yacc.c"
00044
00045
00046 #define YYPURE 0
00047
00048
00049 #define YYLSP_NEEDED 0
00050
00051
00052
00053
00054 #ifndef YYTOKENTYPE
00055 # define YYTOKENTYPE
00056
00057
00058 enum yytokentype {
00059 END_OF_FILE = 258,
00060 EOL = 259,
00061 AND = 260,
00062 OR = 261,
00063 EQUAL = 262,
00064 EQUAL2 = 263,
00065 LEFT_PAR = 264,
00066 RIGHT_PAR = 265,
00067 POWER = 266,
00068 LEFT_BRA = 267,
00069 RIGHT_BRA = 268,
00070 HOLE = 269,
00071 COMMA = 270,
00072 MAJ = 271,
00073 MIN = 272,
00074 INT = 273,
00075 PLUS = 274,
00076 TIMES = 275,
00077 RUN = 276,
00078 DOT = 277,
00079 SET = 278,
00080 HELP = 279,
00081 STEP = 280,
00082 INFO = 281,
00083 ZERO = 282,
00084 BEEP = 283
00085 };
00086 #endif
00087
00088 #define END_OF_FILE 258
00089 #define EOL 259
00090 #define AND 260
00091 #define OR 261
00092 #define EQUAL 262
00093 #define EQUAL2 263
00094 #define LEFT_PAR 264
00095 #define RIGHT_PAR 265
00096 #define POWER 266
00097 #define LEFT_BRA 267
00098 #define RIGHT_BRA 268
00099 #define HOLE 269
00100 #define COMMA 270
00101 #define MAJ 271
00102 #define MIN 272
00103 #define INT 273
00104 #define PLUS 274
00105 #define TIMES 275
00106 #define RUN 276
00107 #define DOT 277
00108 #define SET 278
00109 #define HELP 279
00110 #define STEP 280
00111 #define INFO 281
00112 #define ZERO 282
00113 #define BEEP 283
00114
00115
00116
00117
00118
00119 #line 1 "parser.yy"
00120
00121
00122 #include "FlexLexer.h"
00123 #include <stdio.h>
00124 #include <string>
00125 #include <vector>
00126 #include "parser.h"
00127 #include "config.h"
00128
00129 int yylex();
00130
00131 extern Node **result;
00132 extern Parser* extParser;
00133 extern void set_extParser(Parser* extP);
00134 extern int yyerror(char *s);
00135 extern void set_result(Node **r);
00136 extern yyFlexLexer* lexer;
00137 extern int numLine;
00138
00139
00140
00141
00142
00143 #ifndef YYDEBUG
00144 # define YYDEBUG 0
00145 #endif
00146
00147
00148 #ifdef YYERROR_VERBOSE
00149 # undef YYERROR_VERBOSE
00150 # define YYERROR_VERBOSE 1
00151 #else
00152 # define YYERROR_VERBOSE 0
00153 #endif
00154
00155
00156 #ifndef YYTOKEN_TABLE
00157 # define YYTOKEN_TABLE 0
00158 #endif
00159
00160 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
00161 #line 26 "parser.yy"
00162 typedef union YYSTYPE {
00163 int integerVal;
00164 std::string* stringVal;
00165 Node* node;
00166 Condition* cond;
00167 NumericalVar* numvar;
00168 } YYSTYPE;
00169
00170 #line 171 "parser.tab.cc"
00171 # define yystype YYSTYPE
00172 # define YYSTYPE_IS_DECLARED 1
00173 # define YYSTYPE_IS_TRIVIAL 1
00174 #endif
00175
00176
00177
00178
00179
00180
00181
00182 #line 183 "parser.tab.cc"
00183
00184 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
00185 # define YYSIZE_T __SIZE_TYPE__
00186 #endif
00187 #if ! defined (YYSIZE_T) && defined (size_t)
00188 # define YYSIZE_T size_t
00189 #endif
00190 #if ! defined (YYSIZE_T) && (defined (__STDC__) || defined (__cplusplus))
00191 # include <stddef.h>
00192 # define YYSIZE_T size_t
00193 #endif
00194 #if ! defined (YYSIZE_T)
00195 # define YYSIZE_T unsigned int
00196 #endif
00197
00198 #ifndef YY_
00199 # if YYENABLE_NLS
00200 # if ENABLE_NLS
00201 # include <libintl.h>
00202 # define YY_(msgid) dgettext ("bison-runtime", msgid)
00203 # endif
00204 # endif
00205 # ifndef YY_
00206 # define YY_(msgid) msgid
00207 # endif
00208 #endif
00209
00210 #if ! defined (yyoverflow) || YYERROR_VERBOSE
00211
00212
00213
00214 # ifdef YYSTACK_USE_ALLOCA
00215 # if YYSTACK_USE_ALLOCA
00216 # ifdef __GNUC__
00217 # define YYSTACK_ALLOC __builtin_alloca
00218 # else
00219 # define YYSTACK_ALLOC alloca
00220 # if defined (__STDC__) || defined (__cplusplus)
00221 # include <stdlib.h>
00222 # define YYINCLUDED_STDLIB_H
00223 # endif
00224 # endif
00225 # endif
00226 # endif
00227
00228 # ifdef YYSTACK_ALLOC
00229
00230 # define YYSTACK_FREE(Ptr) do { ; } while (0)
00231 # ifndef YYSTACK_ALLOC_MAXIMUM
00232
00233
00234
00235
00236 # define YYSTACK_ALLOC_MAXIMUM 4032
00237 # endif
00238 # else
00239 # define YYSTACK_ALLOC YYMALLOC
00240 # define YYSTACK_FREE YYFREE
00241 # ifndef YYSTACK_ALLOC_MAXIMUM
00242 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
00243 # endif
00244 # ifdef __cplusplus
00245 extern "C" {
00246 # endif
00247 # ifndef YYMALLOC
00248 # define YYMALLOC malloc
00249 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
00250 && (defined (__STDC__) || defined (__cplusplus)))
00251 void *malloc (YYSIZE_T);
00252 # endif
00253 # endif
00254 # ifndef YYFREE
00255 # define YYFREE free
00256 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
00257 && (defined (__STDC__) || defined (__cplusplus)))
00258 void free (void *);
00259 # endif
00260 # endif
00261 # ifdef __cplusplus
00262 }
00263 # endif
00264 # endif
00265 #endif
00266
00267
00268 #if (! defined (yyoverflow) \
00269 && (! defined (__cplusplus) \
00270 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
00271
00272
00273 union yyalloc
00274 {
00275 short int yyss;
00276 YYSTYPE yyvs;
00277 };
00278
00279
00280 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00281
00282
00283
00284 # define YYSTACK_BYTES(N) \
00285 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
00286 + YYSTACK_GAP_MAXIMUM)
00287
00288
00289
00290 # ifndef YYCOPY
00291 # if defined (__GNUC__) && 1 < __GNUC__
00292 # define YYCOPY(To, From, Count) \
00293 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00294 # else
00295 # define YYCOPY(To, From, Count) \
00296 do \
00297 { \
00298 YYSIZE_T yyi; \
00299 for (yyi = 0; yyi < (Count); yyi++) \
00300 (To)[yyi] = (From)[yyi]; \
00301 } \
00302 while (0)
00303 # endif
00304 # endif
00305
00306
00307
00308
00309
00310
00311 # define YYSTACK_RELOCATE(Stack) \
00312 do \
00313 { \
00314 YYSIZE_T yynewbytes; \
00315 YYCOPY (&yyptr->Stack, Stack, yysize); \
00316 Stack = &yyptr->Stack; \
00317 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00318 yyptr += yynewbytes / sizeof (*yyptr); \
00319 } \
00320 while (0)
00321
00322 #endif
00323
00324 #if defined (__STDC__) || defined (__cplusplus)
00325 typedef signed char yysigned_char;
00326 #else
00327 typedef short int yysigned_char;
00328 #endif
00329
00330
00331 #define YYFINAL 28
00332
00333 #define YYLAST 112
00334
00335
00336 #define YYNTOKENS 29
00337
00338 #define YYNNTS 15
00339
00340 #define YYNRULES 44
00341
00342 #define YYNSTATES 78
00343
00344
00345 #define YYUNDEFTOK 2
00346 #define YYMAXUTOK 283
00347
00348 #define YYTRANSLATE(YYX) \
00349 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00350
00351
00352 static const unsigned char yytranslate[] =
00353 {
00354 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00355 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00356 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00357 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00358 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00359 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00360 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00361 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00362 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00363 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00364 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00365 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00366 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00367 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00368 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00369 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00370 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00371 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00372 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00373 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00374 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00375 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00376 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00377 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00378 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00379 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
00380 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
00381 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
00382 25, 26, 27, 28
00383 };
00384
00385 #if YYDEBUG
00386
00387
00388 static const unsigned char yyprhs[] =
00389 {
00390 0, 0, 3, 5, 8, 10, 13, 16, 20, 23,
00391 25, 27, 29, 31, 33, 37, 41, 43, 45, 49,
00392 53, 55, 59, 63, 65, 69, 71, 76, 78, 80,
00393 88, 96, 100, 105, 107, 109, 111, 113, 115, 119,
00394 127, 133, 139, 143, 145
00395 };
00396
00397
00398 static const yysigned_char yyrhs[] =
00399 {
00400 30, 0, -1, 31, -1, 30, 31, -1, 4, -1,
00401 21, 4, -1, 24, 4, -1, 23, 32, 4, -1,
00402 33, 4, -1, 25, -1, 26, -1, 27, -1, 28,
00403 -1, 36, -1, 34, 5, 36, -1, 35, 6, 36,
00404 -1, 36, -1, 42, -1, 34, 5, 42, -1, 34,
00405 5, 36, -1, 36, -1, 35, 6, 36, -1, 9,
00406 33, 10, -1, 37, -1, 38, 7, 38, -1, 14,
00407 -1, 40, 9, 41, 10, -1, 17, -1, 16, -1,
00408 38, 11, 12, 43, 13, 22, 39, -1, 38, 11,
00409 12, 18, 13, 22, 39, -1, 9, 38, 10, -1,
00410 40, 9, 41, 10, -1, 17, -1, 16, -1, 16,
00411 -1, 17, -1, 38, -1, 41, 15, 38, -1, 43,
00412 8, 18, 20, 43, 19, 18, -1, 43, 8, 18,
00413 20, 43, -1, 43, 8, 43, 19, 43, -1, 43,
00414 8, 43, -1, 16, -1, 17, -1
00415 };
00416
00417
00418 static const unsigned char yyrline[] =
00419 {
00420 0, 71, 71, 72, 76, 77, 78, 79, 80, 84,
00421 85, 86, 87, 91, 92, 93, 98, 99, 100, 101,
00422 105, 106, 110, 111, 115, 118, 119, 120, 121, 122,
00423 123, 128, 129, 130, 131, 135, 136, 140, 141, 145,
00424 146, 147, 148, 152, 153
00425 };
00426 #endif
00427
00428 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00429
00430
00431 static const char *const yytname[] =
00432 {
00433 "$end", "error", "$undefined", "\"end of file\"", "\"end of line\"",
00434 "\"and\"", "\"or\"", "\"equal\"", "\"equal equal\"",
00435 "\"left parenthesis\"", "\"right parenthesis\"", "\"^ ie power\"",
00436 "\"{ ie left brace\"", "\"} ie right braces\"", "\"@ ie hole\"",
00437 "\", ie comma\"", "\"strings beginning by a high case char\"",
00438 "\"strings beginning by a low case char\"", "\"integer\"", "\"+\"",
00439 "\"*\"", "\"run\"", "DOT", "SET", "HELP", "STEP", "INFO", "ZERO", "BEEP",
00440 "$accept", "Input", "Ligne", "OPTION", "T", "Tand", "Tor", "Tf", "Teq",
00441 "Tp", "Tpf", "FUNC", "A", "Cond", "NumV", 0
00442 };
00443 #endif
00444
00445 # ifdef YYPRINT
00446
00447
00448 static const unsigned short int yytoknum[] =
00449 {
00450 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
00451 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
00452 275, 276, 277, 278, 279, 280, 281, 282, 283
00453 };
00454 # endif
00455
00456
00457 static const unsigned char yyr1[] =
00458 {
00459 0, 29, 30, 30, 31, 31, 31, 31, 31, 32,
00460 32, 32, 32, 33, 33, 33, 34, 34, 34, 34,
00461 35, 35, 36, 36, 37, 38, 38, 38, 38, 38,
00462 38, 39, 39, 39, 39, 40, 40, 41, 41, 42,
00463 42, 42, 42, 43, 43
00464 };
00465
00466
00467 static const unsigned char yyr2[] =
00468 {
00469 0, 2, 1, 2, 1, 2, 2, 3, 2, 1,
00470 1, 1, 1, 1, 3, 3, 1, 1, 3, 3,
00471 1, 3, 3, 1, 3, 1, 4, 1, 1, 7,
00472 7, 3, 4, 1, 1, 1, 1, 1, 3, 7,
00473 5, 5, 3, 1, 1
00474 };
00475
00476
00477
00478
00479 static const unsigned char yydefact[] =
00480 {
00481 0, 4, 0, 25, 28, 27, 0, 0, 0, 0,
00482 2, 0, 0, 0, 13, 23, 0, 0, 17, 0,
00483 0, 5, 9, 10, 11, 12, 0, 6, 1, 3,
00484 8, 0, 0, 0, 0, 0, 0, 22, 7, 14,
00485 18, 28, 27, 15, 24, 0, 37, 0, 43, 44,
00486 0, 42, 0, 0, 26, 0, 0, 0, 0, 0,
00487 38, 40, 41, 0, 0, 0, 0, 34, 33, 30,
00488 0, 29, 39, 0, 0, 31, 0, 32
00489 };
00490
00491
00492 static const yysigned_char yydefgoto[] =
00493 {
00494 -1, 9, 10, 26, 11, 12, 13, 14, 15, 16,
00495 69, 17, 47, 18, 19
00496 };
00497
00498
00499
00500 #define YYPACT_NINF -34
00501 static const yysigned_char yypact[] =
00502 {
00503 28, -34, -3, -34, 26, 57, 0, 29, 36, 3,
00504 -34, 39, -4, 47, 62, -34, 14, 41, -34, 51,
00505 67, -34, -34, -34, -34, -34, 74, -34, -34, -34,
00506 -34, -3, 22, 44, 68, 44, 30, -34, -34, 76,
00507 -34, 70, 73, 77, 75, 46, 75, -5, -34, -34,
00508 64, 66, 78, 79, -34, 44, 53, 53, 65, 71,
00509 75, 69, -34, -1, -1, 72, 44, 70, 73, -34,
00510 80, -34, -34, 61, 44, -34, 13, -34
00511 };
00512
00513
00514 static const yysigned_char yypgoto[] =
00515 {
00516 -34, -34, 85, -34, 93, -34, -34, 42, -34, -33,
00517 32, 12, 23, 81, -27
00518 };
00519
00520
00521
00522
00523
00524 #define YYTABLE_NINF -45
00525 static const yysigned_char yytable[] =
00526 {
00527 44, 31, 46, 28, 21, 54, 2, 1, 66, 51,
00528 55, 3, 2, 4, 5, 67, 68, 3, 53, 4,
00529 5, 33, 60, 77, 6, 34, 7, 8, 55, 61,
00530 62, 2, 1, 73, -43, -35, 3, 2, 41, 42,
00531 27, 46, 3, 30, 4, 5, 48, 49, 50, 6,
00532 35, 7, 8, 32, 22, 23, 24, 25, 3, 36,
00533 41, 42, 48, 49, 52, -44, -36, -16, -20, 48,
00534 49, 75, 34, 39, 43, 70, 70, 37, 38, -35,
00535 45, -19, -36, -21, 56, 57, 34, 63, 65, 74,
00536 72, 58, 59, 64, 29, 20, 71, 76, 0, 0,
00537 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
00538 0, 0, 40
00539 };
00540
00541 static const yysigned_char yycheck[] =
00542 {
00543 33, 5, 35, 0, 4, 10, 9, 4, 9, 36,
00544 15, 14, 9, 16, 17, 16, 17, 14, 45, 16,
00545 17, 7, 55, 10, 21, 11, 23, 24, 15, 56,
00546 57, 9, 4, 66, 8, 9, 14, 9, 16, 17,
00547 4, 74, 14, 4, 16, 17, 16, 17, 18, 21,
00548 9, 23, 24, 6, 25, 26, 27, 28, 14, 8,
00549 16, 17, 16, 17, 18, 8, 9, 5, 6, 16,
00550 17, 10, 11, 31, 32, 63, 64, 10, 4, 9,
00551 12, 5, 9, 6, 20, 19, 11, 22, 19, 9,
00552 18, 13, 13, 22, 9, 2, 64, 74, -1, -1,
00553 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
00554 -1, -1, 31
00555 };
00556
00557
00558
00559 static const unsigned char yystos[] =
00560 {
00561 0, 4, 9, 14, 16, 17, 21, 23, 24, 30,
00562 31, 33, 34, 35, 36, 37, 38, 40, 42, 43,
00563 33, 4, 25, 26, 27, 28, 32, 4, 0, 31,
00564 4, 5, 6, 7, 11, 9, 8, 10, 4, 36,
00565 42, 16, 17, 36, 38, 12, 38, 41, 16, 17,
00566 18, 43, 18, 43, 10, 15, 20, 19, 13, 13,
00567 38, 43, 43, 22, 22, 19, 9, 16, 17, 39,
00568 40, 39, 18, 38, 9, 10, 41, 10
00569 };
00570
00571 #define yyerrok (yyerrstatus = 0)
00572 #define yyclearin (yychar = YYEMPTY)
00573 #define YYEMPTY (-2)
00574 #define YYEOF 0
00575
00576 #define YYACCEPT goto yyacceptlab
00577 #define YYABORT goto yyabortlab
00578 #define YYERROR goto yyerrorlab
00579
00580
00581
00582
00583
00584
00585 #define YYFAIL goto yyerrlab
00586
00587 #define YYRECOVERING() (!!yyerrstatus)
00588
00589 #define YYBACKUP(Token, Value) \
00590 do \
00591 if (yychar == YYEMPTY && yylen == 1) \
00592 { \
00593 yychar = (Token); \
00594 yylval = (Value); \
00595 yytoken = YYTRANSLATE (yychar); \
00596 YYPOPSTACK; \
00597 goto yybackup; \
00598 } \
00599 else \
00600 { \
00601 yyerror (YY_("syntax error: cannot back up")); \
00602 YYERROR; \
00603 } \
00604 while (0)
00605
00606
00607 #define YYTERROR 1
00608 #define YYERRCODE 256
00609
00610
00611
00612
00613
00614
00615 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00616 #ifndef YYLLOC_DEFAULT
00617 # define YYLLOC_DEFAULT(Current, Rhs, N) \
00618 do \
00619 if (N) \
00620 { \
00621 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
00622 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
00623 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
00624 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
00625 } \
00626 else \
00627 { \
00628 (Current).first_line = (Current).last_line = \
00629 YYRHSLOC (Rhs, 0).last_line; \
00630 (Current).first_column = (Current).last_column = \
00631 YYRHSLOC (Rhs, 0).last_column; \
00632 } \
00633 while (0)
00634 #endif
00635
00636
00637
00638
00639
00640
00641 #ifndef YY_LOCATION_PRINT
00642 # if YYLTYPE_IS_TRIVIAL
00643 # define YY_LOCATION_PRINT(File, Loc) \
00644 fprintf (File, "%d.%d-%d.%d", \
00645 (Loc).first_line, (Loc).first_column, \
00646 (Loc).last_line, (Loc).last_column)
00647 # else
00648 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
00649 # endif
00650 #endif
00651
00652
00653
00654
00655 #ifdef YYLEX_PARAM
00656 # define YYLEX yylex (YYLEX_PARAM)
00657 #else
00658 # define YYLEX yylex ()
00659 #endif
00660
00661
00662 #if YYDEBUG
00663
00664 # ifndef YYFPRINTF
00665 # include <stdio.h>
00666 # define YYFPRINTF fprintf
00667 # endif
00668
00669 # define YYDPRINTF(Args) \
00670 do { \
00671 if (yydebug) \
00672 YYFPRINTF Args; \
00673 } while (0)
00674
00675 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
00676 do { \
00677 if (yydebug) \
00678 { \
00679 YYFPRINTF (stderr, "%s ", Title); \
00680 yysymprint (stderr, \
00681 Type, Value); \
00682 YYFPRINTF (stderr, "\n"); \
00683 } \
00684 } while (0)
00685
00686
00687
00688
00689
00690
00691 #if defined (__STDC__) || defined (__cplusplus)
00692 static void
00693 yy_stack_print (short int *bottom, short int *top)
00694 #else
00695 static void
00696 yy_stack_print (bottom, top)
00697 short int *bottom;
00698 short int *top;
00699 #endif
00700 {
00701 YYFPRINTF (stderr, "Stack now");
00702 for (; bottom <= top; ++bottom)
00703 YYFPRINTF (stderr, " %d", *bottom);
00704 YYFPRINTF (stderr, "\n");
00705 }
00706
00707 # define YY_STACK_PRINT(Bottom, Top) \
00708 do { \
00709 if (yydebug) \
00710 yy_stack_print ((Bottom), (Top)); \
00711 } while (0)
00712
00713
00714
00715
00716
00717
00718 #if defined (__STDC__) || defined (__cplusplus)
00719 static void
00720 yy_reduce_print (int yyrule)
00721 #else
00722 static void
00723 yy_reduce_print (yyrule)
00724 int yyrule;
00725 #endif
00726 {
00727 int yyi;
00728 unsigned long int yylno = yyrline[yyrule];
00729 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
00730 yyrule - 1, yylno);
00731
00732 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
00733 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
00734 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
00735 }
00736
00737 # define YY_REDUCE_PRINT(Rule) \
00738 do { \
00739 if (yydebug) \
00740 yy_reduce_print (Rule); \
00741 } while (0)
00742
00743
00744
00745 int yydebug;
00746 #else
00747 # define YYDPRINTF(Args)
00748 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
00749 # define YY_STACK_PRINT(Bottom, Top)
00750 # define YY_REDUCE_PRINT(Rule)
00751 #endif
00752
00753
00754
00755 #ifndef YYINITDEPTH
00756 # define YYINITDEPTH 200
00757 #endif
00758
00759
00760
00761
00762
00763
00764
00765
00766 #ifndef YYMAXDEPTH
00767 # define YYMAXDEPTH 10000
00768 #endif
00769
00770
00771
00772 #if YYERROR_VERBOSE
00773
00774 # ifndef yystrlen
00775 # if defined (__GLIBC__) && defined (_STRING_H)
00776 # define yystrlen strlen
00777 # else
00778
00779 static YYSIZE_T
00780 # if defined (__STDC__) || defined (__cplusplus)
00781 yystrlen (const char *yystr)
00782 # else
00783 yystrlen (yystr)
00784 const char *yystr;
00785 # endif
00786 {
00787 const char *yys = yystr;
00788
00789 while (*yys++ != '\0')
00790 continue;
00791
00792 return yys - yystr - 1;
00793 }
00794 # endif
00795 # endif
00796
00797 # ifndef yystpcpy
00798 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
00799 # define yystpcpy stpcpy
00800 # else
00801
00802
00803 static char *
00804 # if defined (__STDC__) || defined (__cplusplus)
00805 yystpcpy (char *yydest, const char *yysrc)
00806 # else
00807 yystpcpy (yydest, yysrc)
00808 char *yydest;
00809 const char *yysrc;
00810 # endif
00811 {
00812 char *yyd = yydest;
00813 const char *yys = yysrc;
00814
00815 while ((*yyd++ = *yys++) != '\0')
00816 continue;
00817
00818 return yyd - 1;
00819 }
00820 # endif
00821 # endif
00822
00823 # ifndef yytnamerr
00824
00825
00826
00827
00828
00829
00830
00831 static YYSIZE_T
00832 yytnamerr (char *yyres, const char *yystr)
00833 {
00834 if (*yystr == '"')
00835 {
00836 size_t yyn = 0;
00837 char const *yyp = yystr;
00838
00839 for (;;)
00840 switch (*++yyp)
00841 {
00842 case '\'':
00843 case ',':
00844 goto do_not_strip_quotes;
00845
00846 case '\\':
00847 if (*++yyp != '\\')
00848 goto do_not_strip_quotes;
00849
00850 default:
00851 if (yyres)
00852 yyres[yyn] = *yyp;
00853 yyn++;
00854 break;
00855
00856 case '"':
00857 if (yyres)
00858 yyres[yyn] = '\0';
00859 return yyn;
00860 }
00861 do_not_strip_quotes: ;
00862 }
00863
00864 if (! yyres)
00865 return yystrlen (yystr);
00866
00867 return yystpcpy (yyres, yystr) - yyres;
00868 }
00869 # endif
00870
00871 #endif
00872
00873
00874
00875 #if YYDEBUG
00876
00877
00878
00879
00880 #if defined (__STDC__) || defined (__cplusplus)
00881 static void
00882 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
00883 #else
00884 static void
00885 yysymprint (yyoutput, yytype, yyvaluep)
00886 FILE *yyoutput;
00887 int yytype;
00888 YYSTYPE *yyvaluep;
00889 #endif
00890 {
00891
00892 (void) yyvaluep;
00893
00894 if (yytype < YYNTOKENS)
00895 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
00896 else
00897 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
00898
00899
00900 # ifdef YYPRINT
00901 if (yytype < YYNTOKENS)
00902 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
00903 # endif
00904 switch (yytype)
00905 {
00906 default:
00907 break;
00908 }
00909 YYFPRINTF (yyoutput, ")");
00910 }
00911
00912 #endif
00913
00914
00915
00916
00917 #if defined (__STDC__) || defined (__cplusplus)
00918 static void
00919 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
00920 #else
00921 static void
00922 yydestruct (yymsg, yytype, yyvaluep)
00923 const char *yymsg;
00924 int yytype;
00925 YYSTYPE *yyvaluep;
00926 #endif
00927 {
00928
00929 (void) yyvaluep;
00930
00931 if (!yymsg)
00932 yymsg = "Deleting";
00933 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
00934
00935 switch (yytype)
00936 {
00937
00938 default:
00939 break;
00940 }
00941 }
00942
00943
00944
00945
00946 #ifdef YYPARSE_PARAM
00947 # if defined (__STDC__) || defined (__cplusplus)
00948 int yyparse (void *YYPARSE_PARAM);
00949 # else
00950 int yyparse ();
00951 # endif
00952 #else
00953 #if defined (__STDC__) || defined (__cplusplus)
00954 int yyparse (void);
00955 #else
00956 int yyparse ();
00957 #endif
00958 #endif
00959
00960
00961
00962
00963 int yychar;
00964
00965
00966 YYSTYPE yylval;
00967
00968
00969 int yynerrs;
00970
00971
00972
00973
00974
00975
00976
00977 #ifdef YYPARSE_PARAM
00978 # if defined (__STDC__) || defined (__cplusplus)
00979 int yyparse (void *YYPARSE_PARAM)
00980 # else
00981 int yyparse (YYPARSE_PARAM)
00982 void *YYPARSE_PARAM;
00983 # endif
00984 #else
00985 #if defined (__STDC__) || defined (__cplusplus)
00986 int
00987 yyparse (void)
00988 #else
00989 int
00990 yyparse ()
00991 ;
00992 #endif
00993 #endif
00994 {
00995
00996 int yystate;
00997 int yyn;
00998 int yyresult;
00999
01000 int yyerrstatus;
01001
01002 int yytoken = 0;
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013 short int yyssa[YYINITDEPTH];
01014 short int *yyss = yyssa;
01015 short int *yyssp;
01016
01017
01018 YYSTYPE yyvsa[YYINITDEPTH];
01019 YYSTYPE *yyvs = yyvsa;
01020 YYSTYPE *yyvsp;
01021
01022
01023
01024 #define YYPOPSTACK (yyvsp--, yyssp--)
01025
01026 YYSIZE_T yystacksize = YYINITDEPTH;
01027
01028
01029
01030 YYSTYPE yyval;
01031
01032
01033
01034
01035 int yylen;
01036
01037 YYDPRINTF ((stderr, "Starting parse\n"));
01038
01039 yystate = 0;
01040 yyerrstatus = 0;
01041 yynerrs = 0;
01042 yychar = YYEMPTY;
01043
01044
01045
01046
01047
01048
01049 yyssp = yyss;
01050 yyvsp = yyvs;
01051
01052 goto yysetstate;
01053
01054
01055
01056
01057 yynewstate:
01058
01059
01060
01061 yyssp++;
01062
01063 yysetstate:
01064 *yyssp = yystate;
01065
01066 if (yyss + yystacksize - 1 <= yyssp)
01067 {
01068
01069 YYSIZE_T yysize = yyssp - yyss + 1;
01070
01071 #ifdef yyoverflow
01072 {
01073
01074
01075
01076 YYSTYPE *yyvs1 = yyvs;
01077 short int *yyss1 = yyss;
01078
01079
01080
01081
01082
01083
01084 yyoverflow (YY_("memory exhausted"),
01085 &yyss1, yysize * sizeof (*yyssp),
01086 &yyvs1, yysize * sizeof (*yyvsp),
01087
01088 &yystacksize);
01089
01090 yyss = yyss1;
01091 yyvs = yyvs1;
01092 }
01093 #else
01094 # ifndef YYSTACK_RELOCATE
01095 goto yyexhaustedlab;
01096 # else
01097
01098 if (YYMAXDEPTH <= yystacksize)
01099 goto yyexhaustedlab;
01100 yystacksize *= 2;
01101 if (YYMAXDEPTH < yystacksize)
01102 yystacksize = YYMAXDEPTH;
01103
01104 {
01105 short int *yyss1 = yyss;
01106 union yyalloc *yyptr =
01107 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01108 if (! yyptr)
01109 goto yyexhaustedlab;
01110 YYSTACK_RELOCATE (yyss);
01111 YYSTACK_RELOCATE (yyvs);
01112
01113 # undef YYSTACK_RELOCATE
01114 if (yyss1 != yyssa)
01115 YYSTACK_FREE (yyss1);
01116 }
01117 # endif
01118 #endif
01119
01120 yyssp = yyss + yysize - 1;
01121 yyvsp = yyvs + yysize - 1;
01122
01123
01124 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01125 (unsigned long int) yystacksize));
01126
01127 if (yyss + yystacksize - 1 <= yyssp)
01128 YYABORT;
01129 }
01130
01131 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01132
01133 goto yybackup;
01134
01135
01136
01137
01138 yybackup:
01139
01140
01141
01142
01143
01144
01145
01146 yyn = yypact[yystate];
01147 if (yyn == YYPACT_NINF)
01148 goto yydefault;
01149
01150
01151
01152
01153 if (yychar == YYEMPTY)
01154 {
01155 YYDPRINTF ((stderr, "Reading a token: "));
01156 yychar = YYLEX;
01157 }
01158
01159 if (yychar <= YYEOF)
01160 {
01161 yychar = yytoken = YYEOF;
01162 YYDPRINTF ((stderr, "Now at end of input.\n"));
01163 }
01164 else
01165 {
01166 yytoken = YYTRANSLATE (yychar);
01167 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01168 }
01169
01170
01171
01172 yyn += yytoken;
01173 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01174 goto yydefault;
01175 yyn = yytable[yyn];
01176 if (yyn <= 0)
01177 {
01178 if (yyn == 0 || yyn == YYTABLE_NINF)
01179 goto yyerrlab;
01180 yyn = -yyn;
01181 goto yyreduce;
01182 }
01183
01184 if (yyn == YYFINAL)
01185 YYACCEPT;
01186
01187
01188 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01189
01190
01191 if (yychar != YYEOF)
01192 yychar = YYEMPTY;
01193
01194 *++yyvsp = yylval;
01195
01196
01197
01198
01199 if (yyerrstatus)
01200 yyerrstatus--;
01201
01202 yystate = yyn;
01203 goto yynewstate;
01204
01205
01206
01207
01208
01209 yydefault:
01210 yyn = yydefact[yystate];
01211 if (yyn == 0)
01212 goto yyerrlab;
01213 goto yyreduce;
01214
01215
01216
01217
01218
01219 yyreduce:
01220
01221 yylen = yyr2[yyn];
01222
01223
01224
01225
01226
01227
01228
01229
01230
01231 yyval = yyvsp[1-yylen];
01232
01233
01234 YY_REDUCE_PRINT (yyn);
01235 switch (yyn)
01236 {
01237 case 2:
01238 #line 71 "parser.yy"
01239 { if((yyvsp[0].node)) { (yyval.node) = new And(); ((And*)(yyval.node))->addBranch((yyvsp[0].node)); *result = (yyval.node);} else {(yyval.node) = NULL; *result = (yyval.node); } ;}
01240 break;
01241
01242 case 3:
01243 #line 72 "parser.yy"
01244 { if((yyvsp[-1].node)) (yyval.node) = (yyvsp[-1].node); else { (yyval.node) = new And(); *result = (yyval.node);} if((yyvsp[0].node)) ((And*)(yyval.node))->addBranch((yyvsp[0].node)); ;}
01245 break;
01246
01247 case 4:
01248 #line 76 "parser.yy"
01249 { (yyval.node) = NULL; ;}
01250 break;
01251
01252 case 5:
01253 #line 77 "parser.yy"
01254 { (yyval.node) = NULL; return 0;;}
01255 break;
01256
01257 case 6:
01258 #line 78 "parser.yy"
01259 { Configuration::printConsol(); (yyval.node) = NULL; ;}
01260 break;
01261
01262 case 7:
01263 #line 79 "parser.yy"
01264 { (yyval.node) = NULL; ;}
01265 break;
01266
01267 case 8:
01268 #line 80 "parser.yy"
01269 { (yyval.node) = (yyvsp[-1].node);;}
01270 break;
01271
01272 case 9:
01273 #line 84 "parser.yy"
01274 { extParser->config->pauseEveryStep = true; ;}
01275 break;
01276
01277 case 10:
01278 #line 85 "parser.yy"
01279 { extParser->config->printRule = true; ;}
01280 break;
01281
01282 case 11:
01283 #line 86 "parser.yy"
01284 { ;}
01285 break;
01286
01287 case 12:
01288 #line 87 "parser.yy"
01289 { extParser->config->beep = 1; ;}
01290 break;
01291
01292 case 14:
01293 #line 92 "parser.yy"
01294 { (yyval.node) = (yyvsp[-2].node); ((And*)(yyval.node))->addBranch((yyvsp[0].node));;}
01295 break;
01296
01297 case 15:
01298 #line 93 "parser.yy"
01299 { (yyval.node) = (yyvsp[-2].node); ((Or*)(yyval.node))->addBranch((yyvsp[0].node)); ;}
01300 break;
01301
01302 case 16:
01303 #line 98 "parser.yy"
01304 { (yyval.node) = new And(); ((And*)(yyval.node))->addBranch((yyvsp[0].node)); ;}
01305 break;
01306
01307 case 17:
01308 #line 99 "parser.yy"
01309 { (yyval.node) = new And(); ((And*)(yyval.node))->addCondition((yyvsp[0].cond)); ;}
01310 break;
01311
01312 case 18:
01313 #line 100 "parser.yy"
01314 { (yyval.node) = (yyvsp[-2].node); ((And*)(yyval.node))->addCondition((yyvsp[0].cond)); ;}
01315 break;
01316
01317 case 19:
01318 #line 101 "parser.yy"
01319 { (yyval.node) = (yyvsp[-2].node); ((And*)(yyval.node))->addBranch((yyvsp[0].node)); ;}
01320 break;
01321
01322 case 20:
01323 #line 105 "parser.yy"
01324 { (yyval.node) = new Or(); ((Or*)(yyval.node))->addBranch((yyvsp[0].node)); ;}
01325 break;
01326
01327 case 21:
01328 #line 106 "parser.yy"
01329 { (yyval.node) = (yyvsp[-2].node); ((Or*)(yyval.node))->addBranch((yyvsp[0].node));;}
01330 break;
01331
01332 case 22:
01333 #line 110 "parser.yy"
01334 { (yyval.node) = (yyvsp[-1].node);;}
01335 break;
01336
01337 case 23:
01338 #line 111 "parser.yy"
01339 {(yyval.node) = (yyvsp[0].node);;}
01340 break;
01341
01342 case 24:
01343 #line 115 "parser.yy"
01344 { (yyval.node) = new Equal((yyvsp[-2].node), (yyvsp[0].node)); ;}
01345 break;
01346
01347 case 25:
01348 #line 118 "parser.yy"
01349 { (yyval.node) = new Hole();;}
01350 break;
01351
01352 case 26:
01353 #line 119 "parser.yy"
01354 { (yyval.node) = (yyvsp[-1].node); ((Function*)(yyval.node))->setName((yyvsp[-3].stringVal)->c_str(), extParser); delete (yyvsp[-3].stringVal);;}
01355 break;
01356
01357 case 27:
01358 #line 120 "parser.yy"
01359 { (yyval.node) = new Function((yyvsp[0].stringVal)->c_str(), extParser ); delete (yyvsp[0].stringVal);;}
01360 break;
01361
01362 case 28:
01363 #line 121 "parser.yy"
01364 { (yyval.node) = new Variable((yyvsp[0].stringVal)->c_str(), extParser ); delete (yyvsp[0].stringVal);;}
01365 break;
01366
01367 case 29:
01368 #line 122 "parser.yy"
01369 { (yyval.node) = new Expo((yyvsp[-6].node),(yyvsp[-3].numvar),(yyvsp[0].node)); ;}
01370 break;
01371
01372 case 30:
01373 #line 123 "parser.yy"
01374 { (yyval.node) = new Expo((yyvsp[-6].node),(yyvsp[-3].integerVal),(yyvsp[0].node)); ;}
01375 break;
01376
01377 case 31:
01378 #line 128 "parser.yy"
01379 { (yyval.node) = (yyvsp[-1].node); ;}
01380 break;
01381
01382 case 32:
01383 #line 129 "parser.yy"
01384 { (yyval.node) = (yyvsp[-1].node); ((Function*)(yyval.node))->setName((yyvsp[-3].stringVal)->c_str(), extParser); delete (yyvsp[-3].stringVal);;}
01385 break;
01386
01387 case 33:
01388 #line 130 "parser.yy"
01389 { (yyval.node) = new Function((yyvsp[0].stringVal)->c_str(), extParser ); delete (yyvsp[0].stringVal);;}
01390 break;
01391
01392 case 34:
01393 #line 131 "parser.yy"
01394 { (yyval.node) = new Variable((yyvsp[0].stringVal)->c_str(), extParser ); delete (yyvsp[0].stringVal);;}
01395 break;
01396
01397 case 35:
01398 #line 135 "parser.yy"
01399 { (yyval.stringVal) = (yyvsp[0].stringVal); ;}
01400 break;
01401
01402 case 36:
01403 #line 136 "parser.yy"
01404 { (yyval.stringVal) = (yyvsp[0].stringVal); ;}
01405 break;
01406
01407 case 37:
01408 #line 140 "parser.yy"
01409 { (yyval.node) = new Function(); ((Function*)(yyval.node))->addArgument((yyvsp[0].node));;}
01410 break;
01411
01412 case 38:
01413 #line 141 "parser.yy"
01414 { (yyval.node) = (yyvsp[-2].node); ((Function*)(yyval.node))->addArgument((yyvsp[0].node)); ;}
01415 break;
01416
01417 case 39:
01418 #line 145 "parser.yy"
01419 {(yyval.cond) = new CondANplusB((yyvsp[-6].numvar), (yyvsp[-4].integerVal), (yyvsp[-2].numvar), (yyvsp[0].integerVal)); ;}
01420 break;
01421
01422 case 40:
01423 #line 146 "parser.yy"
01424 { (yyval.cond) = new CondANplusB((yyvsp[-4].numvar), (yyvsp[-2].integerVal), (yyvsp[0].numvar), 0); ;}
01425 break;
01426
01427 case 41:
01428 #line 147 "parser.yy"
01429 { (yyval.cond) = new CondNplusN((yyvsp[-4].numvar), (yyvsp[-2].numvar), (yyvsp[0].numvar)); ;}
01430 break;
01431
01432 case 42:
01433 #line 148 "parser.yy"
01434 { (yyval.cond) = new CondN((yyvsp[-2].numvar), (yyvsp[0].numvar)); ;}
01435 break;
01436
01437 case 43:
01438 #line 152 "parser.yy"
01439 { (yyval.numvar) = new NumericalVar((yyvsp[0].stringVal)->c_str(), extParser ,false); delete (yyvsp[0].stringVal);;}
01440 break;
01441
01442 case 44:
01443 #line 153 "parser.yy"
01444 { (yyval.numvar) = new NumericalVar((yyvsp[0].stringVal)->c_str(), extParser ,false); delete (yyvsp[0].stringVal);;}
01445 break;
01446
01447
01448 default: break;
01449 }
01450
01451
01452 #line 1453 "parser.tab.cc"
01453
01454 yyvsp -= yylen;
01455 yyssp -= yylen;
01456
01457
01458 YY_STACK_PRINT (yyss, yyssp);
01459
01460 *++yyvsp = yyval;
01461
01462
01463
01464
01465
01466
01467 yyn = yyr1[yyn];
01468
01469 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
01470 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01471 yystate = yytable[yystate];
01472 else
01473 yystate = yydefgoto[yyn - YYNTOKENS];
01474
01475 goto yynewstate;
01476
01477
01478
01479
01480
01481 yyerrlab:
01482
01483 if (!yyerrstatus)
01484 {
01485 ++yynerrs;
01486 #if YYERROR_VERBOSE
01487 yyn = yypact[yystate];
01488
01489 if (YYPACT_NINF < yyn && yyn < YYLAST)
01490 {
01491 int yytype = YYTRANSLATE (yychar);
01492 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
01493 YYSIZE_T yysize = yysize0;
01494 YYSIZE_T yysize1;
01495 int yysize_overflow = 0;
01496 char *yymsg = 0;
01497 # define YYERROR_VERBOSE_ARGS_MAXIMUM 5
01498 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
01499 int yyx;
01500
01501 #if 0
01502
01503
01504 YY_("syntax error, unexpected %s");
01505 YY_("syntax error, unexpected %s, expecting %s");
01506 YY_("syntax error, unexpected %s, expecting %s or %s");
01507 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
01508 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
01509 #endif
01510 char *yyfmt;
01511 char const *yyf;
01512 static char const yyunexpected[] = "syntax error, unexpected %s";
01513 static char const yyexpecting[] = ", expecting %s";
01514 static char const yyor[] = " or %s";
01515 char yyformat[sizeof yyunexpected
01516 + sizeof yyexpecting - 1
01517 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
01518 * (sizeof yyor - 1))];
01519 char const *yyprefix = yyexpecting;
01520
01521
01522
01523 int yyxbegin = yyn < 0 ? -yyn : 0;
01524
01525
01526 int yychecklim = YYLAST - yyn;
01527 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01528 int yycount = 1;
01529
01530 yyarg[0] = yytname[yytype];
01531 yyfmt = yystpcpy (yyformat, yyunexpected);
01532
01533 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01534 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01535 {
01536 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01537 {
01538 yycount = 1;
01539 yysize = yysize0;
01540 yyformat[sizeof yyunexpected - 1] = '\0';
01541 break;
01542 }
01543 yyarg[yycount++] = yytname[yyx];
01544 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01545 yysize_overflow |= yysize1 < yysize;
01546 yysize = yysize1;
01547 yyfmt = yystpcpy (yyfmt, yyprefix);
01548 yyprefix = yyor;
01549 }
01550
01551 yyf = YY_(yyformat);
01552 yysize1 = yysize + yystrlen (yyf);
01553 yysize_overflow |= yysize1 < yysize;
01554 yysize = yysize1;
01555
01556 if (!yysize_overflow && yysize <= YYSTACK_ALLOC_MAXIMUM)
01557 yymsg = (char *) YYSTACK_ALLOC (yysize);
01558 if (yymsg)
01559 {
01560
01561
01562
01563 char *yyp = yymsg;
01564 int yyi = 0;
01565 while ((*yyp = *yyf))
01566 {
01567 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
01568 {
01569 yyp += yytnamerr (yyp, yyarg[yyi++]);
01570 yyf += 2;
01571 }
01572 else
01573 {
01574 yyp++;
01575 yyf++;
01576 }
01577 }
01578 yyerror (yymsg);
01579 YYSTACK_FREE (yymsg);
01580 }
01581 else
01582 {
01583 yyerror (YY_("syntax error"));
01584 goto yyexhaustedlab;
01585 }
01586 }
01587 else
01588 #endif
01589 yyerror (YY_("syntax error"));
01590 }
01591
01592
01593
01594 if (yyerrstatus == 3)
01595 {
01596
01597
01598
01599 if (yychar <= YYEOF)
01600 {
01601
01602 if (yychar == YYEOF)
01603 YYABORT;
01604 }
01605 else
01606 {
01607 yydestruct ("Error: discarding", yytoken, &yylval);
01608 yychar = YYEMPTY;
01609 }
01610 }
01611
01612
01613
01614 goto yyerrlab1;
01615
01616
01617
01618
01619
01620 yyerrorlab:
01621
01622
01623
01624
01625 if (0)
01626 goto yyerrorlab;
01627
01628 yyvsp -= yylen;
01629 yyssp -= yylen;
01630 yystate = *yyssp;
01631 goto yyerrlab1;
01632
01633
01634
01635
01636
01637 yyerrlab1:
01638 yyerrstatus = 3;
01639
01640 for (;;)
01641 {
01642 yyn = yypact[yystate];
01643 if (yyn != YYPACT_NINF)
01644 {
01645 yyn += YYTERROR;
01646 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
01647 {
01648 yyn = yytable[yyn];
01649 if (0 < yyn)
01650 break;
01651 }
01652 }
01653
01654
01655 if (yyssp == yyss)
01656 YYABORT;
01657
01658
01659 yydestruct ("Error: popping", yystos[yystate], yyvsp);
01660 YYPOPSTACK;
01661 yystate = *yyssp;
01662 YY_STACK_PRINT (yyss, yyssp);
01663 }
01664
01665 if (yyn == YYFINAL)
01666 YYACCEPT;
01667
01668 *++yyvsp = yylval;
01669
01670
01671
01672 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
01673
01674 yystate = yyn;
01675 goto yynewstate;
01676
01677
01678
01679
01680
01681 yyacceptlab:
01682 yyresult = 0;
01683 goto yyreturn;
01684
01685
01686
01687
01688 yyabortlab:
01689 yyresult = 1;
01690 goto yyreturn;
01691
01692 #ifndef yyoverflow
01693
01694
01695
01696 yyexhaustedlab:
01697 yyerror (YY_("memory exhausted"));
01698 yyresult = 2;
01699
01700 #endif
01701
01702 yyreturn:
01703 if (yychar != YYEOF && yychar != YYEMPTY)
01704 yydestruct ("Cleanup: discarding lookahead",
01705 yytoken, &yylval);
01706 while (yyssp != yyss)
01707 {
01708 yydestruct ("Cleanup: popping",
01709 yystos[*yyssp], yyvsp);
01710 YYPOPSTACK;
01711 }
01712 #ifndef yyoverflow
01713 if (yyss != yyssa)
01714 YYSTACK_FREE (yyss);
01715 #endif
01716 return yyresult;
01717 }
01718
01719
01720 #line 156 "parser.yy"
01721
01722
01723 Parser* extParser;
01724 Node **result;
01725 yyFlexLexer* lexer;
01726 int numLine;
01727
01728 void set_result(Node **r)
01729 {
01730 result = r;
01731 }
01732
01733 void set_extParser(Parser* extP)
01734 {
01735 extParser = extP;
01736 }
01737
01738 int yyerror(char *s)
01739 {
01740 printf("\nErreur : %s (line : %i)\n",s,numLine);
01741 return 1;
01742 }
01743
01744 int yylex(void)
01745 {
01746 return lexer->yylex();
01747 }
01748