2
/* A Bison parser, made by GNU Bison 2.4.1. */
4
/* Skeleton implementation for Bison's Yacc-like parsers in C
6
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7
Free Software Foundation, Inc.
9
This program is free software: you can redistribute it and/or modify
10
it under the terms of the GNU General Public License as published by
11
the Free Software Foundation, either version 3 of the License, or
12
(at your option) any later version.
14
This program is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17
GNU General Public License for more details.
19
You should have received a copy of the GNU General Public License
20
along with this program. If not, see <http://www.gnu.org/licenses/>. */
22
/* As a special exception, you may create a larger work that contains
23
part or all of the Bison parser skeleton and distribute that work
24
under terms of your choice, so long as that work isn't itself a
25
parser generator using the skeleton or a modified version thereof
26
as a parser skeleton. Alternatively, if you modify or redistribute
27
the parser skeleton itself, you may (at your option) remove this
28
special exception, which will cause the skeleton and the resulting
29
Bison output files to be licensed under the GNU General Public
30
License without this special exception.
32
This special exception was added by the Free Software Foundation in
33
version 2.2 of Bison. */
35
/* C LALR(1) parser skeleton written by Richard Stallman, by
36
simplifying the original so-called "semantic" parser. */
38
/* All symbols defined below should begin with yy or YY, to avoid
39
infringing on user name space. This should be done even for local
40
variables, as they might otherwise be expanded by user macros.
41
There are some unavoidable exceptions within include files to
42
define necessary library symbols; they are noted "INFRINGES ON
43
USER NAME SPACE" below. */
45
/* Identify Bison output. */
49
#define YYBISON_VERSION "2.4.1"
52
#define YYSKELETON_NAME "yacc.c"
63
/* Using locations. */
64
#define YYLSP_NEEDED 0
68
/* Copy the first part of user declarations. */
70
/* Line 189 of yacc.c */
71
#line 1 "mei_parser.y"
73
/*============================================================================
74
* Define the grammar for the mathematical expression
75
*============================================================================*/
78
This file is part of the "Mathematical Expression Interpreter" library.
80
Copyright (C) 2008-2010 EDF
82
This library is free software; you can redistribute it and/or
83
modify it under the terms of the GNU Lesser General Public
84
License as published by the Free Software Foundation; either
85
version 2.1 of the License, or (at your option) any later version.
87
This library is distributed in the hope that it will be useful,
88
but WITHOUT ANY WARRANTY; without even the implied warranty of
89
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
90
Lesser General Public License for more details.
92
You should have received a copy of the GNU Lesser General Public
93
License along with this library; if not, write to the Free Software
94
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
97
/*----------------------------------------------------------------------------
98
* Standard C library headers
99
*----------------------------------------------------------------------------*/
103
/*----------------------------------------------------------------------------
105
*----------------------------------------------------------------------------*/
107
#include "mei_node.h"
108
#include "mei_parser_glob.h"
110
/*----------------------------------------------------------------------------
111
* BFT library headers
112
*----------------------------------------------------------------------------*/
115
#include <bft_printf.h>
119
/* Line 189 of yacc.c */
120
#line 121 "mei_parser.c"
122
/* Enabling traces. */
127
/* Enabling verbose error messages. */
128
#ifdef YYERROR_VERBOSE
129
# undef YYERROR_VERBOSE
130
# define YYERROR_VERBOSE 1
132
# define YYERROR_VERBOSE 0
135
/* Enabling the token table. */
136
#ifndef YYTOKEN_TABLE
137
# define YYTOKEN_TABLE 0
144
/* Put the tokens into the symbol table, so that GDB and other debuggers
192
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
193
typedef union YYSTYPE
196
/* Line 214 of yacc.c */
197
#line 52 "mei_parser.y"
199
double iValue; /* double value */
200
char sIndex[200]; /* variable, constant or function identifier */
201
mei_node_t *nPtr; /* node pointer */
205
/* Line 214 of yacc.c */
206
#line 207 "mei_parser.c"
208
# define YYSTYPE_IS_TRIVIAL 1
209
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
210
# define YYSTYPE_IS_DECLARED 1
214
/* Copy the second part of user declarations. */
217
/* Line 264 of yacc.c */
218
#line 219 "mei_parser.c"
225
typedef YYTYPE_UINT8 yytype_uint8;
227
typedef unsigned char yytype_uint8;
231
typedef YYTYPE_INT8 yytype_int8;
232
#elif (defined __STDC__ || defined __C99__FUNC__ \
233
|| defined __cplusplus || defined _MSC_VER)
234
typedef signed char yytype_int8;
236
typedef short int yytype_int8;
240
typedef YYTYPE_UINT16 yytype_uint16;
242
typedef unsigned short int yytype_uint16;
246
typedef YYTYPE_INT16 yytype_int16;
248
typedef short int yytype_int16;
252
# ifdef __SIZE_TYPE__
253
# define YYSIZE_T __SIZE_TYPE__
254
# elif defined size_t
255
# define YYSIZE_T size_t
256
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
257
|| defined __cplusplus || defined _MSC_VER)
258
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
259
# define YYSIZE_T size_t
261
# define YYSIZE_T unsigned int
265
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
270
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
271
# define YY_(msgid) dgettext ("bison-runtime", msgid)
275
# define YY_(msgid) msgid
279
/* Suppress unused-variable warnings by "using" E. */
280
#if ! defined lint || defined __GNUC__
281
# define YYUSE(e) ((void) (e))
283
# define YYUSE(e) /* empty */
286
/* Identity function, used to suppress warnings about constant conditions. */
290
#if (defined __STDC__ || defined __C99__FUNC__ \
291
|| defined __cplusplus || defined _MSC_VER)
304
#if ! defined yyoverflow || YYERROR_VERBOSE
306
/* The parser invokes alloca or malloc; define the necessary symbols. */
308
# ifdef YYSTACK_USE_ALLOCA
309
# if YYSTACK_USE_ALLOCA
311
# define YYSTACK_ALLOC __builtin_alloca
312
# elif defined __BUILTIN_VA_ARG_INCR
313
# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
315
# define YYSTACK_ALLOC __alloca
316
# elif defined _MSC_VER
317
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
318
# define alloca _alloca
320
# define YYSTACK_ALLOC alloca
321
# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
322
|| defined __cplusplus || defined _MSC_VER)
323
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
332
# ifdef YYSTACK_ALLOC
333
/* Pacify GCC's `empty if-body' warning. */
334
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
335
# ifndef YYSTACK_ALLOC_MAXIMUM
336
/* The OS might guarantee only one guard page at the bottom of the stack,
337
and a page size can be as small as 4096 bytes. So we cannot safely
338
invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
339
to allow for a few compiler-allocated temporary stack slots. */
340
# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
343
# define YYSTACK_ALLOC YYMALLOC
344
# define YYSTACK_FREE YYFREE
345
# ifndef YYSTACK_ALLOC_MAXIMUM
346
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
348
# if (defined __cplusplus && ! defined _STDLIB_H \
349
&& ! ((defined YYMALLOC || defined malloc) \
350
&& (defined YYFREE || defined free)))
351
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
357
# define YYMALLOC malloc
358
# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
359
|| defined __cplusplus || defined _MSC_VER)
360
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
365
# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
366
|| defined __cplusplus || defined _MSC_VER)
367
void free (void *); /* INFRINGES ON USER NAME SPACE */
371
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
374
#if (! defined yyoverflow \
375
&& (! defined __cplusplus \
376
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
378
/* A type that is properly aligned for any stack member. */
381
yytype_int16 yyss_alloc;
385
/* The size of the maximum gap between one aligned stack and the next. */
386
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
388
/* The size of an array large to enough to hold all stacks, each with
390
# define YYSTACK_BYTES(N) \
391
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
392
+ YYSTACK_GAP_MAXIMUM)
394
/* Copy COUNT objects from FROM to TO. The source and destination do
397
# if defined __GNUC__ && 1 < __GNUC__
398
# define YYCOPY(To, From, Count) \
399
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
401
# define YYCOPY(To, From, Count) \
405
for (yyi = 0; yyi < (Count); yyi++) \
406
(To)[yyi] = (From)[yyi]; \
412
/* Relocate STACK from its old location to the new one. The
413
local variables YYSIZE and YYSTACKSIZE give the old and new number of
414
elements in the stack, and YYPTR gives the new location of the
415
stack. Advance YYPTR to a properly aligned location for the next
417
# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
420
YYSIZE_T yynewbytes; \
421
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
422
Stack = &yyptr->Stack_alloc; \
423
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
424
yyptr += yynewbytes / sizeof (*yyptr); \
430
/* YYFINAL -- State number of the termination state. */
432
/* YYLAST -- Last index in YYTABLE. */
435
/* YYNTOKENS -- Number of terminals. */
437
/* YYNNTS -- Number of nonterminals. */
439
/* YYNRULES -- Number of rules. */
441
/* YYNRULES -- Number of states. */
444
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
446
#define YYMAXUTOK 276
448
#define YYTRANSLATE(YYX) \
449
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
451
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
452
static const yytype_uint8 yytranslate[] =
454
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
455
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
456
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
457
2, 2, 2, 27, 2, 2, 2, 2, 2, 2,
458
32, 33, 25, 23, 36, 24, 2, 26, 2, 2,
459
2, 2, 2, 2, 2, 2, 2, 2, 2, 31,
460
20, 14, 19, 2, 2, 2, 2, 2, 2, 2,
461
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
462
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
463
2, 2, 2, 2, 30, 2, 2, 2, 2, 2,
464
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
465
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
466
2, 2, 2, 34, 2, 35, 2, 2, 2, 2,
467
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
468
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
469
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
470
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
471
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
472
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
473
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
474
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
475
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
476
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
477
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
478
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
479
2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
480
5, 6, 7, 8, 9, 10, 11, 12, 13, 15,
481
16, 17, 18, 21, 22, 28, 29
485
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
487
static const yytype_uint8 yyprhs[] =
489
0, 0, 3, 4, 6, 9, 11, 13, 16, 20,
490
25, 31, 37, 45, 49, 52, 54, 56, 61, 68,
491
77, 88, 91, 94, 97, 101, 105, 109, 113, 117,
492
121, 125, 129, 133, 137, 141, 145, 149, 153
495
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
496
static const yytype_int8 yyrhs[] =
498
38, 0, -1, -1, 39, -1, 39, 40, -1, 40,
499
-1, 31, -1, 41, 31, -1, 11, 41, 31, -1,
500
4, 14, 41, 31, -1, 9, 32, 41, 33, 40,
501
-1, 10, 32, 41, 33, 40, -1, 10, 32, 41,
502
33, 40, 13, 40, -1, 34, 39, 35, -1, 40,
503
1, -1, 3, -1, 4, -1, 5, 32, 41, 33,
504
-1, 6, 32, 41, 36, 41, 33, -1, 7, 32,
505
41, 36, 41, 36, 41, 33, -1, 8, 32, 41,
506
36, 41, 36, 41, 36, 41, 33, -1, 27, 41,
507
-1, 24, 41, -1, 23, 41, -1, 41, 23, 41,
508
-1, 41, 24, 41, -1, 41, 25, 41, -1, 41,
509
26, 41, -1, 41, 30, 41, -1, 41, 20, 41,
510
-1, 41, 19, 41, -1, 41, 22, 41, -1, 41,
511
21, 41, -1, 41, 17, 41, -1, 41, 18, 41,
512
-1, 41, 15, 41, -1, 41, 16, 41, -1, 32,
513
41, 33, -1, 41, 1, -1
516
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
517
static const yytype_uint8 yyrline[] =
519
0, 87, 87, 88, 92, 93, 97, 98, 99, 100,
520
101, 102, 103, 104, 105, 109, 110, 111, 112, 113,
521
114, 115, 116, 117, 118, 119, 120, 121, 122, 123,
522
124, 125, 126, 127, 128, 129, 130, 131, 132
526
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
527
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
528
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
529
static const char *const yytname[] =
531
"$end", "error", "$undefined", "NUMBER", "VAR", "FUN1", "FUN2", "FUN3",
532
"FUN4", "WHILE", "IF", "PRINT", "IFX", "ELSE", "'='", "OR", "AND", "NE",
533
"EQ", "'>'", "'<'", "LE", "GE", "'+'", "'-'", "'*'", "'/'", "'!'",
534
"UMINUS", "UPLUS", "'^'", "';'", "'('", "')'", "'{'", "'}'", "','",
535
"$accept", "program", "stmt_list", "stmt", "expr", 0
540
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
542
static const yytype_uint16 yytoknum[] =
544
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
545
265, 266, 267, 268, 61, 269, 270, 271, 272, 62,
546
60, 273, 274, 43, 45, 42, 47, 33, 275, 276,
547
94, 59, 40, 41, 123, 125, 44
551
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
552
static const yytype_uint8 yyr1[] =
554
0, 37, 38, 38, 39, 39, 40, 40, 40, 40,
555
40, 40, 40, 40, 40, 41, 41, 41, 41, 41,
556
41, 41, 41, 41, 41, 41, 41, 41, 41, 41,
557
41, 41, 41, 41, 41, 41, 41, 41, 41
560
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
561
static const yytype_uint8 yyr2[] =
563
0, 2, 0, 1, 2, 1, 1, 2, 3, 4,
564
5, 5, 7, 3, 2, 1, 1, 4, 6, 8,
565
10, 2, 2, 2, 3, 3, 3, 3, 3, 3,
566
3, 3, 3, 3, 3, 3, 3, 3, 2
569
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
570
STATE-NUM when YYTABLE doesn't specify something else to do. Zero
571
means the default is an error. */
572
static const yytype_uint8 yydefact[] =
574
2, 15, 16, 0, 0, 0, 0, 0, 0, 0,
575
0, 0, 0, 6, 0, 0, 0, 3, 0, 0,
576
0, 0, 0, 0, 0, 0, 0, 16, 0, 0,
577
0, 0, 0, 0, 1, 0, 14, 38, 0, 0,
578
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
579
0, 7, 0, 0, 0, 0, 0, 0, 0, 8,
580
37, 13, 0, 0, 0, 0, 0, 0, 0, 0,
581
0, 0, 0, 0, 0, 9, 17, 0, 0, 0,
582
0, 0, 0, 0, 0, 0, 0, 18, 0, 0,
583
0, 0, 0, 0, 19, 0, 0, 20
586
/* YYDEFGOTO[NTERM-NUM]. */
587
static const yytype_int8 yydefgoto[] =
592
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
594
#define YYPACT_NINF -27
595
static const yytype_int16 yypact[] =
597
1011, -27, -10, -26, -25, -24, -22, -14, -13, 855,
598
855, 855, 855, -27, 855, 1011, 20, 1011, 192, 1031,
599
855, 855, 855, 855, 855, 855, 855, -27, 1057, 27,
600
249, 275, 824, 803, -27, 228, -27, -27, 855, 855,
601
855, 855, 855, 855, 855, 855, 855, 855, 855, 855,
602
855, -27, 1083, 850, 639, 665, 691, 876, 902, -27,
603
-27, -27, 301, 327, 353, 379, 405, 431, 457, 483,
604
509, 535, 561, 587, 613, -27, -27, 855, 855, 855,
605
1011, 1011, 928, 717, 743, 84, 120, -27, 855, 855,
606
1011, 954, 769, 156, -27, 855, 980, -27
609
/* YYPGOTO[NTERM-NUM]. */
610
static const yytype_int8 yypgoto[] =
615
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
616
positive, shift that token. If negative, reduce the rule which
617
number is the opposite. If zero, do what YYDEFACT says.
618
If YYTABLE_NINF, syntax error. */
619
#define YYTABLE_NINF -37
620
static const yytype_int8 yytable[] =
622
28, 29, 30, 31, 20, 32, 21, 22, 23, 35,
623
24, 52, 53, 54, 55, 56, 57, 58, 25, 26,
624
34, 33, 0, 0, 0, 35, 0, 0, 37, 62,
625
63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
626
73, 74, -23, -23, -23, -23, -23, -23, -23, -23,
627
-23, -23, -23, -23, 0, 0, 0, 50, -23, 0,
628
-23, 0, 0, -23, 0, 0, 0, 0, 82, 83,
629
84, 0, 85, 86, 0, 0, 0, 0, 0, 91,
630
92, 0, 93, 0, -10, 36, 96, -10, -10, -10,
631
-10, -10, -10, -10, -10, -10, 0, -10, 0, 0,
632
0, 0, 0, 0, 0, 0, 0, -10, -10, 0,
633
0, -10, 0, 0, 0, -10, -10, 0, -10, -10,
634
-11, 36, 0, -11, -11, -11, -11, -11, -11, -11,
635
-11, -11, 0, 90, 0, 0, 0, 0, 0, 0,
636
0, 0, 0, -11, -11, 0, 0, -11, 0, 0,
637
0, -11, -11, 0, -11, -11, -12, 36, 0, -12,
638
-12, -12, -12, -12, -12, -12, -12, -12, 0, -12,
639
0, 0, 0, 0, 0, 0, 0, 0, 0, -12,
640
-12, 0, 0, -12, 0, 0, 0, -12, -12, 0,
641
-12, -12, -5, 36, 0, -5, -5, -5, -5, -5,
642
-5, -5, -5, -5, 0, 0, 0, 0, 0, 0,
643
0, 0, 0, 0, 0, -5, -5, 0, 0, -5,
644
0, 0, 0, -5, -5, 0, -5, -5, -4, 36,
645
0, -4, -4, -4, -4, -4, -4, -4, -4, -4,
646
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
647
37, -4, -4, 0, 0, -4, 0, 0, 0, -4,
648
-4, 0, -4, -4, -22, -22, -22, -22, -22, -22,
649
-22, -22, -22, -22, -22, -22, 37, 0, 0, 50,
650
-22, 0, -22, 0, 0, -22, 0, 0, 0, 0,
651
-21, -21, -21, -21, -21, -21, -21, -21, -21, -21,
652
-21, -21, 37, 0, 0, 50, -21, 0, -21, 0,
653
0, -21, 0, 0, 0, 0, -35, 39, 40, 41,
654
42, 43, 44, 45, 46, 47, 48, 49, 37, 0,
655
0, 50, -35, 0, -35, 0, 0, -35, 0, 0,
656
0, 0, -36, -36, 40, 41, 42, 43, 44, 45,
657
46, 47, 48, 49, 37, 0, 0, 50, -36, 0,
658
-36, 0, 0, -36, 0, 0, 0, 0, -33, -33,
659
-33, -33, 42, 43, 44, 45, 46, 47, 48, 49,
660
37, 0, 0, 50, -33, 0, -33, 0, 0, -33,
661
0, 0, 0, 0, -34, -34, -34, -34, 42, 43,
662
44, 45, 46, 47, 48, 49, 37, 0, 0, 50,
663
-34, 0, -34, 0, 0, -34, 0, 0, 0, 0,
664
-30, -30, -30, -30, -30, -30, -30, -30, 46, 47,
665
48, 49, 37, 0, 0, 50, -30, 0, -30, 0,
666
0, -30, 0, 0, 0, 0, -29, -29, -29, -29,
667
-29, -29, -29, -29, 46, 47, 48, 49, 37, 0,
668
0, 50, -29, 0, -29, 0, 0, -29, 0, 0,
669
0, 0, -32, -32, -32, -32, -32, -32, -32, -32,
670
46, 47, 48, 49, 37, 0, 0, 50, -32, 0,
671
-32, 0, 0, -32, 0, 0, 0, 0, -31, -31,
672
-31, -31, -31, -31, -31, -31, 46, 47, 48, 49,
673
37, 0, 0, 50, -31, 0, -31, 0, 0, -31,
674
0, 0, 0, 0, -24, -24, -24, -24, -24, -24,
675
-24, -24, -24, -24, 48, 49, 37, 0, 0, 50,
676
-24, 0, -24, 0, 0, -24, 0, 0, 0, 0,
677
-25, -25, -25, -25, -25, -25, -25, -25, -25, -25,
678
48, 49, 37, 0, 0, 50, -25, 0, -25, 0,
679
0, -25, 0, 0, 0, 0, -26, -26, -26, -26,
680
-26, -26, -26, -26, -26, -26, -26, -26, 37, 0,
681
0, 50, -26, 0, -26, 0, 0, -26, 0, 0,
682
0, 0, -27, -27, -27, -27, -27, -27, -27, -27,
683
-27, -27, -27, -27, 37, 0, 0, 50, -27, 0,
684
-27, 0, 0, -27, 0, 0, 0, 0, -28, -28,
685
-28, -28, -28, -28, -28, -28, -28, -28, -28, -28,
686
37, 0, 0, 50, -28, 0, -28, 0, 0, -28,
687
0, 0, 0, 0, 38, 39, 40, 41, 42, 43,
688
44, 45, 46, 47, 48, 49, 37, 0, 0, 50,
689
0, 0, 0, 0, 0, 77, 0, 0, 0, 0,
690
38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
691
48, 49, 37, 0, 0, 50, 0, 0, 0, 0,
692
0, 78, 0, 0, 0, 0, 38, 39, 40, 41,
693
42, 43, 44, 45, 46, 47, 48, 49, 37, 0,
694
0, 50, 0, 0, 0, 0, 0, 79, 0, 0,
695
0, 0, 38, 39, 40, 41, 42, 43, 44, 45,
696
46, 47, 48, 49, 37, 0, 0, 50, 0, 0,
697
0, 0, 0, 88, 0, 0, 0, 0, 38, 39,
698
40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
699
37, 0, 0, 50, 0, 0, 0, 0, 0, 89,
700
0, 0, 0, 0, 38, 39, 40, 41, 42, 43,
701
44, 45, 46, 47, 48, 49, 0, 0, 0, 50,
702
0, 0, 0, 0, 0, 95, 1, 2, 3, 4,
703
5, 6, 7, 8, 9, 0, 0, 0, 0, 0,
704
0, 0, 0, 0, 0, 37, 10, 11, 0, 0,
705
12, 0, 0, 0, 13, 14, 0, 15, 61, 38,
706
39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
707
49, 37, 0, 0, 50, 0, 0, 60, 1, 27,
708
3, 4, 5, 6, 0, 38, 39, 40, 41, 42,
709
43, 44, 45, 46, 47, 48, 49, 37, 10, 11,
710
50, 0, 12, 76, 0, 0, 0, 14, 0, 0,
711
0, 38, 39, 40, 41, 42, 43, 44, 45, 46,
712
47, 48, 49, 37, 0, 0, 50, 0, 0, 80,
713
0, 0, 0, 0, 0, 0, 0, 38, 39, 40,
714
41, 42, 43, 44, 45, 46, 47, 48, 49, 37,
715
0, 0, 50, 0, 0, 81, 0, 0, 0, 0,
716
0, 0, 0, 38, 39, 40, 41, 42, 43, 44,
717
45, 46, 47, 48, 49, 37, 0, 0, 50, 0,
718
0, 87, 0, 0, 0, 0, 0, 0, 0, 38,
719
39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
720
49, 37, 0, 0, 50, 0, 0, 94, 0, 0,
721
0, 0, 0, 0, 0, 38, 39, 40, 41, 42,
722
43, 44, 45, 46, 47, 48, 49, 0, 0, 0,
723
50, 0, 0, 97, 1, 2, 3, 4, 5, 6,
724
7, 8, 9, 0, 0, 0, 0, 0, 0, 0,
725
0, 0, 37, 0, 10, 11, 0, 0, 12, 0,
726
0, 0, 13, 14, 0, 15, 38, 39, 40, 41,
727
42, 43, 44, 45, 46, 47, 48, 49, 37, 0,
728
0, 50, 51, 0, 0, 0, 0, 0, 0, 0,
729
0, 0, 38, 39, 40, 41, 42, 43, 44, 45,
730
46, 47, 48, 49, 37, 0, 0, 50, 59, 0,
731
0, 0, 0, 0, 0, 0, 0, 0, 38, 39,
732
40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
736
static const yytype_int8 yycheck[] =
738
9, 10, 11, 12, 14, 14, 32, 32, 32, 17,
739
32, 20, 21, 22, 23, 24, 25, 26, 32, 32,
740
0, 15, -1, -1, -1, 33, -1, -1, 1, 38,
741
39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
742
49, 50, 15, 16, 17, 18, 19, 20, 21, 22,
743
23, 24, 25, 26, -1, -1, -1, 30, 31, -1,
744
33, -1, -1, 36, -1, -1, -1, -1, 77, 78,
745
79, -1, 80, 81, -1, -1, -1, -1, -1, 88,
746
89, -1, 90, -1, 0, 1, 95, 3, 4, 5,
747
6, 7, 8, 9, 10, 11, -1, 13, -1, -1,
748
-1, -1, -1, -1, -1, -1, -1, 23, 24, -1,
749
-1, 27, -1, -1, -1, 31, 32, -1, 34, 35,
750
0, 1, -1, 3, 4, 5, 6, 7, 8, 9,
751
10, 11, -1, 13, -1, -1, -1, -1, -1, -1,
752
-1, -1, -1, 23, 24, -1, -1, 27, -1, -1,
753
-1, 31, 32, -1, 34, 35, 0, 1, -1, 3,
754
4, 5, 6, 7, 8, 9, 10, 11, -1, 13,
755
-1, -1, -1, -1, -1, -1, -1, -1, -1, 23,
756
24, -1, -1, 27, -1, -1, -1, 31, 32, -1,
757
34, 35, 0, 1, -1, 3, 4, 5, 6, 7,
758
8, 9, 10, 11, -1, -1, -1, -1, -1, -1,
759
-1, -1, -1, -1, -1, 23, 24, -1, -1, 27,
760
-1, -1, -1, 31, 32, -1, 34, 35, 0, 1,
761
-1, 3, 4, 5, 6, 7, 8, 9, 10, 11,
762
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
763
1, 23, 24, -1, -1, 27, -1, -1, -1, 31,
764
32, -1, 34, 35, 15, 16, 17, 18, 19, 20,
765
21, 22, 23, 24, 25, 26, 1, -1, -1, 30,
766
31, -1, 33, -1, -1, 36, -1, -1, -1, -1,
767
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
768
25, 26, 1, -1, -1, 30, 31, -1, 33, -1,
769
-1, 36, -1, -1, -1, -1, 15, 16, 17, 18,
770
19, 20, 21, 22, 23, 24, 25, 26, 1, -1,
771
-1, 30, 31, -1, 33, -1, -1, 36, -1, -1,
772
-1, -1, 15, 16, 17, 18, 19, 20, 21, 22,
773
23, 24, 25, 26, 1, -1, -1, 30, 31, -1,
774
33, -1, -1, 36, -1, -1, -1, -1, 15, 16,
775
17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
776
1, -1, -1, 30, 31, -1, 33, -1, -1, 36,
777
-1, -1, -1, -1, 15, 16, 17, 18, 19, 20,
778
21, 22, 23, 24, 25, 26, 1, -1, -1, 30,
779
31, -1, 33, -1, -1, 36, -1, -1, -1, -1,
780
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
781
25, 26, 1, -1, -1, 30, 31, -1, 33, -1,
782
-1, 36, -1, -1, -1, -1, 15, 16, 17, 18,
783
19, 20, 21, 22, 23, 24, 25, 26, 1, -1,
784
-1, 30, 31, -1, 33, -1, -1, 36, -1, -1,
785
-1, -1, 15, 16, 17, 18, 19, 20, 21, 22,
786
23, 24, 25, 26, 1, -1, -1, 30, 31, -1,
787
33, -1, -1, 36, -1, -1, -1, -1, 15, 16,
788
17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
789
1, -1, -1, 30, 31, -1, 33, -1, -1, 36,
790
-1, -1, -1, -1, 15, 16, 17, 18, 19, 20,
791
21, 22, 23, 24, 25, 26, 1, -1, -1, 30,
792
31, -1, 33, -1, -1, 36, -1, -1, -1, -1,
793
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
794
25, 26, 1, -1, -1, 30, 31, -1, 33, -1,
795
-1, 36, -1, -1, -1, -1, 15, 16, 17, 18,
796
19, 20, 21, 22, 23, 24, 25, 26, 1, -1,
797
-1, 30, 31, -1, 33, -1, -1, 36, -1, -1,
798
-1, -1, 15, 16, 17, 18, 19, 20, 21, 22,
799
23, 24, 25, 26, 1, -1, -1, 30, 31, -1,
800
33, -1, -1, 36, -1, -1, -1, -1, 15, 16,
801
17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
802
1, -1, -1, 30, 31, -1, 33, -1, -1, 36,
803
-1, -1, -1, -1, 15, 16, 17, 18, 19, 20,
804
21, 22, 23, 24, 25, 26, 1, -1, -1, 30,
805
-1, -1, -1, -1, -1, 36, -1, -1, -1, -1,
806
15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
807
25, 26, 1, -1, -1, 30, -1, -1, -1, -1,
808
-1, 36, -1, -1, -1, -1, 15, 16, 17, 18,
809
19, 20, 21, 22, 23, 24, 25, 26, 1, -1,
810
-1, 30, -1, -1, -1, -1, -1, 36, -1, -1,
811
-1, -1, 15, 16, 17, 18, 19, 20, 21, 22,
812
23, 24, 25, 26, 1, -1, -1, 30, -1, -1,
813
-1, -1, -1, 36, -1, -1, -1, -1, 15, 16,
814
17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
815
1, -1, -1, 30, -1, -1, -1, -1, -1, 36,
816
-1, -1, -1, -1, 15, 16, 17, 18, 19, 20,
817
21, 22, 23, 24, 25, 26, -1, -1, -1, 30,
818
-1, -1, -1, -1, -1, 36, 3, 4, 5, 6,
819
7, 8, 9, 10, 11, -1, -1, -1, -1, -1,
820
-1, -1, -1, -1, -1, 1, 23, 24, -1, -1,
821
27, -1, -1, -1, 31, 32, -1, 34, 35, 15,
822
16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
823
26, 1, -1, -1, 30, -1, -1, 33, 3, 4,
824
5, 6, 7, 8, -1, 15, 16, 17, 18, 19,
825
20, 21, 22, 23, 24, 25, 26, 1, 23, 24,
826
30, -1, 27, 33, -1, -1, -1, 32, -1, -1,
827
-1, 15, 16, 17, 18, 19, 20, 21, 22, 23,
828
24, 25, 26, 1, -1, -1, 30, -1, -1, 33,
829
-1, -1, -1, -1, -1, -1, -1, 15, 16, 17,
830
18, 19, 20, 21, 22, 23, 24, 25, 26, 1,
831
-1, -1, 30, -1, -1, 33, -1, -1, -1, -1,
832
-1, -1, -1, 15, 16, 17, 18, 19, 20, 21,
833
22, 23, 24, 25, 26, 1, -1, -1, 30, -1,
834
-1, 33, -1, -1, -1, -1, -1, -1, -1, 15,
835
16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
836
26, 1, -1, -1, 30, -1, -1, 33, -1, -1,
837
-1, -1, -1, -1, -1, 15, 16, 17, 18, 19,
838
20, 21, 22, 23, 24, 25, 26, -1, -1, -1,
839
30, -1, -1, 33, 3, 4, 5, 6, 7, 8,
840
9, 10, 11, -1, -1, -1, -1, -1, -1, -1,
841
-1, -1, 1, -1, 23, 24, -1, -1, 27, -1,
842
-1, -1, 31, 32, -1, 34, 15, 16, 17, 18,
843
19, 20, 21, 22, 23, 24, 25, 26, 1, -1,
844
-1, 30, 31, -1, -1, -1, -1, -1, -1, -1,
845
-1, -1, 15, 16, 17, 18, 19, 20, 21, 22,
846
23, 24, 25, 26, 1, -1, -1, 30, 31, -1,
847
-1, -1, -1, -1, -1, -1, -1, -1, 15, 16,
848
17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
852
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
853
symbol of state STATE-NUM. */
854
static const yytype_uint8 yystos[] =
856
0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
857
23, 24, 27, 31, 32, 34, 38, 39, 40, 41,
858
14, 32, 32, 32, 32, 32, 32, 4, 41, 41,
859
41, 41, 41, 39, 0, 40, 1, 1, 15, 16,
860
17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
861
30, 31, 41, 41, 41, 41, 41, 41, 41, 31,
862
33, 35, 41, 41, 41, 41, 41, 41, 41, 41,
863
41, 41, 41, 41, 41, 31, 33, 36, 36, 36,
864
33, 33, 41, 41, 41, 40, 40, 33, 36, 36,
865
13, 41, 41, 40, 33, 36, 41, 33
868
#define yyerrok (yyerrstatus = 0)
869
#define yyclearin (yychar = YYEMPTY)
873
#define YYACCEPT goto yyacceptlab
874
#define YYABORT goto yyabortlab
875
#define YYERROR goto yyerrorlab
878
/* Like YYERROR except do call yyerror. This remains here temporarily
879
to ease the transition to the new meaning of YYERROR, for GCC.
880
Once GCC version 2 has supplanted version 1, this can go. */
882
#define YYFAIL goto yyerrlab
884
#define YYRECOVERING() (!!yyerrstatus)
886
#define YYBACKUP(Token, Value) \
888
if (yychar == YYEMPTY && yylen == 1) \
892
yytoken = YYTRANSLATE (yychar); \
898
yyerror (YY_("syntax error: cannot back up")); \
905
#define YYERRCODE 256
908
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
909
If N is 0, then set CURRENT to the empty location which ends
910
the previous symbol: RHS[0] (always defined). */
912
#define YYRHSLOC(Rhs, K) ((Rhs)[K])
913
#ifndef YYLLOC_DEFAULT
914
# define YYLLOC_DEFAULT(Current, Rhs, N) \
918
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
919
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
920
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
921
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
925
(Current).first_line = (Current).last_line = \
926
YYRHSLOC (Rhs, 0).last_line; \
927
(Current).first_column = (Current).last_column = \
928
YYRHSLOC (Rhs, 0).last_column; \
934
/* YY_LOCATION_PRINT -- Print the location on the stream.
935
This macro was not mandated originally: define only if we know
936
we won't break user code: when these are the locations we know. */
938
#ifndef YY_LOCATION_PRINT
939
# if YYLTYPE_IS_TRIVIAL
940
# define YY_LOCATION_PRINT(File, Loc) \
941
fprintf (File, "%d.%d-%d.%d", \
942
(Loc).first_line, (Loc).first_column, \
943
(Loc).last_line, (Loc).last_column)
945
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
950
/* YYLEX -- calling `yylex' with the right arguments. */
953
# define YYLEX yylex (YYLEX_PARAM)
955
# define YYLEX yylex ()
958
/* Enable debugging if requested. */
962
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
963
# define YYFPRINTF fprintf
966
# define YYDPRINTF(Args) \
972
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
976
YYFPRINTF (stderr, "%s ", Title); \
977
yy_symbol_print (stderr, \
979
YYFPRINTF (stderr, "\n"); \
984
/*--------------------------------.
985
| Print this symbol on YYOUTPUT. |
986
`--------------------------------*/
989
#if (defined __STDC__ || defined __C99__FUNC__ \
990
|| defined __cplusplus || defined _MSC_VER)
992
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
995
yy_symbol_value_print (yyoutput, yytype, yyvaluep)
998
YYSTYPE const * const yyvaluep;
1004
if (yytype < YYNTOKENS)
1005
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1017
/*--------------------------------.
1018
| Print this symbol on YYOUTPUT. |
1019
`--------------------------------*/
1021
#if (defined __STDC__ || defined __C99__FUNC__ \
1022
|| defined __cplusplus || defined _MSC_VER)
1024
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1027
yy_symbol_print (yyoutput, yytype, yyvaluep)
1030
YYSTYPE const * const yyvaluep;
1033
if (yytype < YYNTOKENS)
1034
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1036
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1038
yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1039
YYFPRINTF (yyoutput, ")");
1042
/*------------------------------------------------------------------.
1043
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1045
`------------------------------------------------------------------*/
1047
#if (defined __STDC__ || defined __C99__FUNC__ \
1048
|| defined __cplusplus || defined _MSC_VER)
1050
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1053
yy_stack_print (yybottom, yytop)
1054
yytype_int16 *yybottom;
1055
yytype_int16 *yytop;
1058
YYFPRINTF (stderr, "Stack now");
1059
for (; yybottom <= yytop; yybottom++)
1061
int yybot = *yybottom;
1062
YYFPRINTF (stderr, " %d", yybot);
1064
YYFPRINTF (stderr, "\n");
1067
# define YY_STACK_PRINT(Bottom, Top) \
1070
yy_stack_print ((Bottom), (Top)); \
1074
/*------------------------------------------------.
1075
| Report that the YYRULE is going to be reduced. |
1076
`------------------------------------------------*/
1078
#if (defined __STDC__ || defined __C99__FUNC__ \
1079
|| defined __cplusplus || defined _MSC_VER)
1081
yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1084
yy_reduce_print (yyvsp, yyrule)
1089
int yynrhs = yyr2[yyrule];
1091
unsigned long int yylno = yyrline[yyrule];
1092
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1094
/* The symbols being reduced. */
1095
for (yyi = 0; yyi < yynrhs; yyi++)
1097
YYFPRINTF (stderr, " $%d = ", yyi + 1);
1098
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1099
&(yyvsp[(yyi + 1) - (yynrhs)])
1101
YYFPRINTF (stderr, "\n");
1105
# define YY_REDUCE_PRINT(Rule) \
1108
yy_reduce_print (yyvsp, Rule); \
1111
/* Nonzero means print parse trace. It is left uninitialized so that
1112
multiple parsers can coexist. */
1114
#else /* !YYDEBUG */
1115
# define YYDPRINTF(Args)
1116
# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1117
# define YY_STACK_PRINT(Bottom, Top)
1118
# define YY_REDUCE_PRINT(Rule)
1119
#endif /* !YYDEBUG */
1122
/* YYINITDEPTH -- initial size of the parser's stacks. */
1124
# define YYINITDEPTH 200
1127
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1128
if the built-in stack extension method is used).
1130
Do not make this value too large; the results are undefined if
1131
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1132
evaluated with infinite-precision integer arithmetic. */
1135
# define YYMAXDEPTH 10000
1143
# if defined __GLIBC__ && defined _STRING_H
1144
# define yystrlen strlen
1146
/* Return the length of YYSTR. */
1147
#if (defined __STDC__ || defined __C99__FUNC__ \
1148
|| defined __cplusplus || defined _MSC_VER)
1150
yystrlen (const char *yystr)
1158
for (yylen = 0; yystr[yylen]; yylen++)
1166
# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1167
# define yystpcpy stpcpy
1169
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1171
#if (defined __STDC__ || defined __C99__FUNC__ \
1172
|| defined __cplusplus || defined _MSC_VER)
1174
yystpcpy (char *yydest, const char *yysrc)
1177
yystpcpy (yydest, yysrc)
1183
const char *yys = yysrc;
1185
while ((*yyd++ = *yys++) != '\0')
1194
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1195
quotes and backslashes, so that it's suitable for yyerror. The
1196
heuristic is that double-quoting is unnecessary unless the string
1197
contains an apostrophe, a comma, or backslash (other than
1198
backslash-backslash). YYSTR is taken from yytname. If YYRES is
1199
null, do not copy; instead, return the length of what the result
1202
yytnamerr (char *yyres, const char *yystr)
1207
char const *yyp = yystr;
1214
goto do_not_strip_quotes;
1218
goto do_not_strip_quotes;
1231
do_not_strip_quotes: ;
1235
return yystrlen (yystr);
1237
return yystpcpy (yyres, yystr) - yyres;
1241
/* Copy into YYRESULT an error message about the unexpected token
1242
YYCHAR while in state YYSTATE. Return the number of bytes copied,
1243
including the terminating null byte. If YYRESULT is null, do not
1244
copy anything; just return the number of bytes that would be
1245
copied. As a special case, return 0 if an ordinary "syntax error"
1246
message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1247
size calculation. */
1249
yysyntax_error (char *yyresult, int yystate, int yychar)
1251
int yyn = yypact[yystate];
1253
if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1257
int yytype = YYTRANSLATE (yychar);
1258
YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1259
YYSIZE_T yysize = yysize0;
1261
int yysize_overflow = 0;
1262
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1263
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1267
/* This is so xgettext sees the translatable formats that are
1268
constructed on the fly. */
1269
YY_("syntax error, unexpected %s");
1270
YY_("syntax error, unexpected %s, expecting %s");
1271
YY_("syntax error, unexpected %s, expecting %s or %s");
1272
YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1273
YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1277
static char const yyunexpected[] = "syntax error, unexpected %s";
1278
static char const yyexpecting[] = ", expecting %s";
1279
static char const yyor[] = " or %s";
1280
char yyformat[sizeof yyunexpected
1281
+ sizeof yyexpecting - 1
1282
+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1283
* (sizeof yyor - 1))];
1284
char const *yyprefix = yyexpecting;
1286
/* Start YYX at -YYN if negative to avoid negative indexes in
1288
int yyxbegin = yyn < 0 ? -yyn : 0;
1290
/* Stay within bounds of both yycheck and yytname. */
1291
int yychecklim = YYLAST - yyn + 1;
1292
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1295
yyarg[0] = yytname[yytype];
1296
yyfmt = yystpcpy (yyformat, yyunexpected);
1298
for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1299
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1301
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1305
yyformat[sizeof yyunexpected - 1] = '\0';
1308
yyarg[yycount++] = yytname[yyx];
1309
yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1310
yysize_overflow |= (yysize1 < yysize);
1312
yyfmt = yystpcpy (yyfmt, yyprefix);
1316
yyf = YY_(yyformat);
1317
yysize1 = yysize + yystrlen (yyf);
1318
yysize_overflow |= (yysize1 < yysize);
1321
if (yysize_overflow)
1322
return YYSIZE_MAXIMUM;
1326
/* Avoid sprintf, as that infringes on the user's name space.
1327
Don't have undefined behavior even if the translation
1328
produced a string with the wrong number of "%s"s. */
1329
char *yyp = yyresult;
1331
while ((*yyp = *yyf) != '\0')
1333
if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1335
yyp += yytnamerr (yyp, yyarg[yyi++]);
1348
#endif /* YYERROR_VERBOSE */
1351
/*-----------------------------------------------.
1352
| Release the memory associated to this symbol. |
1353
`-----------------------------------------------*/
1356
#if (defined __STDC__ || defined __C99__FUNC__ \
1357
|| defined __cplusplus || defined _MSC_VER)
1359
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1362
yydestruct (yymsg, yytype, yyvaluep)
1372
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1382
/* Prevent warnings from -Wmissing-prototypes. */
1383
#ifdef YYPARSE_PARAM
1384
#if defined __STDC__ || defined __cplusplus
1385
int yyparse (void *YYPARSE_PARAM);
1389
#else /* ! YYPARSE_PARAM */
1390
#if defined __STDC__ || defined __cplusplus
1395
#endif /* ! YYPARSE_PARAM */
1398
/* The lookahead symbol. */
1401
/* The semantic value of the lookahead symbol. */
1404
/* Number of syntax errors so far. */
1409
/*-------------------------.
1410
| yyparse or yypush_parse. |
1411
`-------------------------*/
1413
#ifdef YYPARSE_PARAM
1414
#if (defined __STDC__ || defined __C99__FUNC__ \
1415
|| defined __cplusplus || defined _MSC_VER)
1417
yyparse (void *YYPARSE_PARAM)
1420
yyparse (YYPARSE_PARAM)
1421
void *YYPARSE_PARAM;
1423
#else /* ! YYPARSE_PARAM */
1424
#if (defined __STDC__ || defined __C99__FUNC__ \
1425
|| defined __cplusplus || defined _MSC_VER)
1438
/* Number of tokens to shift before error messages enabled. */
1441
/* The stacks and their tools:
1442
`yyss': related to states.
1443
`yyvs': related to semantic values.
1445
Refer to the stacks thru separate pointers, to allow yyoverflow
1446
to reallocate them elsewhere. */
1448
/* The state stack. */
1449
yytype_int16 yyssa[YYINITDEPTH];
1451
yytype_int16 *yyssp;
1453
/* The semantic value stack. */
1454
YYSTYPE yyvsa[YYINITDEPTH];
1458
YYSIZE_T yystacksize;
1462
/* Lookahead token as an internal (translated) token number. */
1464
/* The variables used to return semantic value and location from the
1469
/* Buffer for error messages, and its allocated size. */
1471
char *yymsg = yymsgbuf;
1472
YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1475
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1477
/* The number of symbols on the RHS of the reduced rule.
1478
Keep to zero when no symbol should be popped. */
1484
yystacksize = YYINITDEPTH;
1486
YYDPRINTF ((stderr, "Starting parse\n"));
1491
yychar = YYEMPTY; /* Cause a token to be read. */
1493
/* Initialize stack pointers.
1494
Waste one element of value and location stack
1495
so that they stay on the same level as the state stack.
1496
The wasted elements are never initialized. */
1502
/*------------------------------------------------------------.
1503
| yynewstate -- Push a new state, which is found in yystate. |
1504
`------------------------------------------------------------*/
1506
/* In all cases, when you get here, the value and location stacks
1507
have just been pushed. So pushing a state here evens the stacks. */
1513
if (yyss + yystacksize - 1 <= yyssp)
1515
/* Get the current used size of the three stacks, in elements. */
1516
YYSIZE_T yysize = yyssp - yyss + 1;
1520
/* Give user a chance to reallocate the stack. Use copies of
1521
these so that the &'s don't force the real ones into
1523
YYSTYPE *yyvs1 = yyvs;
1524
yytype_int16 *yyss1 = yyss;
1526
/* Each stack pointer address is followed by the size of the
1527
data in use in that stack, in bytes. This used to be a
1528
conditional around just the two extra args, but that might
1529
be undefined if yyoverflow is a macro. */
1530
yyoverflow (YY_("memory exhausted"),
1531
&yyss1, yysize * sizeof (*yyssp),
1532
&yyvs1, yysize * sizeof (*yyvsp),
1538
#else /* no yyoverflow */
1539
# ifndef YYSTACK_RELOCATE
1540
goto yyexhaustedlab;
1542
/* Extend the stack our own way. */
1543
if (YYMAXDEPTH <= yystacksize)
1544
goto yyexhaustedlab;
1546
if (YYMAXDEPTH < yystacksize)
1547
yystacksize = YYMAXDEPTH;
1550
yytype_int16 *yyss1 = yyss;
1551
union yyalloc *yyptr =
1552
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1554
goto yyexhaustedlab;
1555
YYSTACK_RELOCATE (yyss_alloc, yyss);
1556
YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1557
# undef YYSTACK_RELOCATE
1559
YYSTACK_FREE (yyss1);
1562
#endif /* no yyoverflow */
1564
yyssp = yyss + yysize - 1;
1565
yyvsp = yyvs + yysize - 1;
1567
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1568
(unsigned long int) yystacksize));
1570
if (yyss + yystacksize - 1 <= yyssp)
1574
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1576
if (yystate == YYFINAL)
1586
/* Do appropriate processing given the current state. Read a
1587
lookahead token if we need one and don't already have one. */
1589
/* First try to decide what to do without reference to lookahead token. */
1590
yyn = yypact[yystate];
1591
if (yyn == YYPACT_NINF)
1594
/* Not known => get a lookahead token if don't already have one. */
1596
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1597
if (yychar == YYEMPTY)
1599
YYDPRINTF ((stderr, "Reading a token: "));
1603
if (yychar <= YYEOF)
1605
yychar = yytoken = YYEOF;
1606
YYDPRINTF ((stderr, "Now at end of input.\n"));
1610
yytoken = YYTRANSLATE (yychar);
1611
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1614
/* If the proper action on seeing token YYTOKEN is to reduce or to
1615
detect an error, take that action. */
1617
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1622
if (yyn == 0 || yyn == YYTABLE_NINF)
1628
/* Count tokens shifted since error; after three, turn off error
1633
/* Shift the lookahead token. */
1634
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1636
/* Discard the shifted token. */
1645
/*-----------------------------------------------------------.
1646
| yydefault -- do the default action for the current state. |
1647
`-----------------------------------------------------------*/
1649
yyn = yydefact[yystate];
1655
/*-----------------------------.
1656
| yyreduce -- Do a reduction. |
1657
`-----------------------------*/
1659
/* yyn is the number of a rule to reduce with. */
1662
/* If YYLEN is nonzero, implement the default value of the action:
1665
Otherwise, the following line sets YYVAL to garbage.
1666
This behavior is undocumented and Bison
1667
users should not rely upon it. Assigning to YYVAL
1668
unconditionally makes the parser a bit smaller, and it avoids a
1669
GCC warning that YYVAL may be used uninitialized. */
1670
yyval = yyvsp[1-yylen];
1673
YY_REDUCE_PRINT (yyn);
1678
/* Line 1455 of yacc.c */
1679
#line 87 "mei_parser.y"
1685
/* Line 1455 of yacc.c */
1686
#line 88 "mei_parser.y"
1687
{ mei_glob_root = (yyvsp[(1) - (1)].nPtr); return 1; }
1692
/* Line 1455 of yacc.c */
1693
#line 92 "mei_parser.y"
1694
{ (yyval.nPtr) = mei_opr_node(';', 2, (yyvsp[(1) - (2)].nPtr), (yyvsp[(2) - (2)].nPtr)); }
1699
/* Line 1455 of yacc.c */
1700
#line 93 "mei_parser.y"
1701
{ (yyval.nPtr) = (yyvsp[(1) - (1)].nPtr); }
1706
/* Line 1455 of yacc.c */
1707
#line 97 "mei_parser.y"
1708
{ (yyval.nPtr) = mei_opr_node(';', 2, NULL, NULL); }
1713
/* Line 1455 of yacc.c */
1714
#line 98 "mei_parser.y"
1715
{ (yyval.nPtr) = (yyvsp[(1) - (2)].nPtr); }
1720
/* Line 1455 of yacc.c */
1721
#line 99 "mei_parser.y"
1722
{ (yyval.nPtr) = mei_opr_node(PRINT, 1, (yyvsp[(2) - (3)].nPtr)); }
1727
/* Line 1455 of yacc.c */
1728
#line 100 "mei_parser.y"
1729
{ (yyval.nPtr) = mei_opr_node('=', 2, mei_id_node((yyvsp[(1) - (4)].sIndex)), (yyvsp[(3) - (4)].nPtr)); }
1734
/* Line 1455 of yacc.c */
1735
#line 101 "mei_parser.y"
1736
{ (yyval.nPtr) = mei_opr_node(WHILE, 2, (yyvsp[(3) - (5)].nPtr), (yyvsp[(5) - (5)].nPtr)); }
1741
/* Line 1455 of yacc.c */
1742
#line 102 "mei_parser.y"
1743
{ (yyval.nPtr) = mei_opr_node(IF, 2, (yyvsp[(3) - (5)].nPtr), (yyvsp[(5) - (5)].nPtr)); }
1748
/* Line 1455 of yacc.c */
1749
#line 103 "mei_parser.y"
1750
{ (yyval.nPtr) = mei_opr_node(IF, 3, (yyvsp[(3) - (7)].nPtr), (yyvsp[(5) - (7)].nPtr), (yyvsp[(7) - (7)].nPtr)); }
1755
/* Line 1455 of yacc.c */
1756
#line 104 "mei_parser.y"
1757
{ (yyval.nPtr) = (yyvsp[(2) - (3)].nPtr); }
1762
/* Line 1455 of yacc.c */
1763
#line 105 "mei_parser.y"
1764
{ yyerror(mei_label_node((yyvsp[(1) - (2)].nPtr))); return 0; }
1769
/* Line 1455 of yacc.c */
1770
#line 109 "mei_parser.y"
1771
{ (yyval.nPtr) = mei_const_node((yyvsp[(1) - (1)].iValue)); }
1776
/* Line 1455 of yacc.c */
1777
#line 110 "mei_parser.y"
1778
{ (yyval.nPtr) = mei_id_node((yyvsp[(1) - (1)].sIndex)); }
1783
/* Line 1455 of yacc.c */
1784
#line 111 "mei_parser.y"
1785
{ (yyval.nPtr) = mei_func_node((yyvsp[(1) - (4)].sIndex), (yyvsp[(3) - (4)].nPtr)); }
1790
/* Line 1455 of yacc.c */
1791
#line 112 "mei_parser.y"
1792
{ (yyval.nPtr) = mei_funcx_node((yyvsp[(1) - (6)].sIndex), 2, (yyvsp[(3) - (6)].nPtr), (yyvsp[(5) - (6)].nPtr)); }
1797
/* Line 1455 of yacc.c */
1798
#line 113 "mei_parser.y"
1799
{ (yyval.nPtr) = mei_funcx_node((yyvsp[(1) - (8)].sIndex), 3, (yyvsp[(3) - (8)].nPtr), (yyvsp[(5) - (8)].nPtr), (yyvsp[(7) - (8)].nPtr)); }
1804
/* Line 1455 of yacc.c */
1805
#line 114 "mei_parser.y"
1806
{ (yyval.nPtr) = mei_funcx_node((yyvsp[(1) - (10)].sIndex), 4, (yyvsp[(3) - (10)].nPtr), (yyvsp[(5) - (10)].nPtr), (yyvsp[(7) - (10)].nPtr), (yyvsp[(9) - (10)].nPtr)); }
1811
/* Line 1455 of yacc.c */
1812
#line 115 "mei_parser.y"
1813
{ (yyval.nPtr) = mei_opr_node('!', 1, (yyvsp[(2) - (2)].nPtr)); }
1818
/* Line 1455 of yacc.c */
1819
#line 116 "mei_parser.y"
1820
{ (yyval.nPtr) = mei_opr_node(UMINUS, 1, (yyvsp[(2) - (2)].nPtr)); }
1825
/* Line 1455 of yacc.c */
1826
#line 117 "mei_parser.y"
1827
{ (yyval.nPtr) = mei_opr_node(UPLUS, 1, (yyvsp[(2) - (2)].nPtr)); }
1832
/* Line 1455 of yacc.c */
1833
#line 118 "mei_parser.y"
1834
{ (yyval.nPtr) = mei_opr_node('+', 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1839
/* Line 1455 of yacc.c */
1840
#line 119 "mei_parser.y"
1841
{ (yyval.nPtr) = mei_opr_node('-', 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1846
/* Line 1455 of yacc.c */
1847
#line 120 "mei_parser.y"
1848
{ (yyval.nPtr) = mei_opr_node('*', 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1853
/* Line 1455 of yacc.c */
1854
#line 121 "mei_parser.y"
1855
{ (yyval.nPtr) = mei_opr_node('/', 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1860
/* Line 1455 of yacc.c */
1861
#line 122 "mei_parser.y"
1862
{ (yyval.nPtr) = mei_opr_node('^', 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1867
/* Line 1455 of yacc.c */
1868
#line 123 "mei_parser.y"
1869
{ (yyval.nPtr) = mei_opr_node('<', 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1874
/* Line 1455 of yacc.c */
1875
#line 124 "mei_parser.y"
1876
{ (yyval.nPtr) = mei_opr_node('>', 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1881
/* Line 1455 of yacc.c */
1882
#line 125 "mei_parser.y"
1883
{ (yyval.nPtr) = mei_opr_node(GE, 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1888
/* Line 1455 of yacc.c */
1889
#line 126 "mei_parser.y"
1890
{ (yyval.nPtr) = mei_opr_node(LE, 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1895
/* Line 1455 of yacc.c */
1896
#line 127 "mei_parser.y"
1897
{ (yyval.nPtr) = mei_opr_node(NE, 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1902
/* Line 1455 of yacc.c */
1903
#line 128 "mei_parser.y"
1904
{ (yyval.nPtr) = mei_opr_node(EQ, 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1909
/* Line 1455 of yacc.c */
1910
#line 129 "mei_parser.y"
1911
{ (yyval.nPtr) = mei_opr_node(OR, 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1916
/* Line 1455 of yacc.c */
1917
#line 130 "mei_parser.y"
1918
{ (yyval.nPtr) = mei_opr_node(AND, 2, (yyvsp[(1) - (3)].nPtr), (yyvsp[(3) - (3)].nPtr)); }
1923
/* Line 1455 of yacc.c */
1924
#line 131 "mei_parser.y"
1925
{ (yyval.nPtr) = (yyvsp[(2) - (3)].nPtr); }
1930
/* Line 1455 of yacc.c */
1931
#line 132 "mei_parser.y"
1932
{ yyerror(mei_label_node((yyvsp[(1) - (2)].nPtr))); return 0; }
1937
/* Line 1455 of yacc.c */
1938
#line 1939 "mei_parser.c"
1941
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1945
YY_STACK_PRINT (yyss, yyssp);
1949
/* Now `shift' the result of the reduction. Determine what state
1950
that goes to, based on the state we popped back to and the rule
1951
number reduced by. */
1955
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1956
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1957
yystate = yytable[yystate];
1959
yystate = yydefgoto[yyn - YYNTOKENS];
1964
/*------------------------------------.
1965
| yyerrlab -- here on detecting error |
1966
`------------------------------------*/
1968
/* If not already recovering from an error, report this error. */
1972
#if ! YYERROR_VERBOSE
1973
yyerror (YY_("syntax error"));
1976
YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1977
if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1979
YYSIZE_T yyalloc = 2 * yysize;
1980
if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1981
yyalloc = YYSTACK_ALLOC_MAXIMUM;
1982
if (yymsg != yymsgbuf)
1983
YYSTACK_FREE (yymsg);
1984
yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1986
yymsg_alloc = yyalloc;
1990
yymsg_alloc = sizeof yymsgbuf;
1994
if (0 < yysize && yysize <= yymsg_alloc)
1996
(void) yysyntax_error (yymsg, yystate, yychar);
2001
yyerror (YY_("syntax error"));
2003
goto yyexhaustedlab;
2011
if (yyerrstatus == 3)
2013
/* If just tried and failed to reuse lookahead token after an
2014
error, discard it. */
2016
if (yychar <= YYEOF)
2018
/* Return failure if at end of input. */
2019
if (yychar == YYEOF)
2024
yydestruct ("Error: discarding",
2030
/* Else will try to reuse lookahead token after shifting the error
2035
/*---------------------------------------------------.
2036
| yyerrorlab -- error raised explicitly by YYERROR. |
2037
`---------------------------------------------------*/
2040
/* Pacify compilers like GCC when the user code never invokes
2041
YYERROR and the label yyerrorlab therefore never appears in user
2043
if (/*CONSTCOND*/ 0)
2046
/* Do not reclaim the symbols of the rule which action triggered
2050
YY_STACK_PRINT (yyss, yyssp);
2055
/*-------------------------------------------------------------.
2056
| yyerrlab1 -- common code for both syntax error and YYERROR. |
2057
`-------------------------------------------------------------*/
2059
yyerrstatus = 3; /* Each real token shifted decrements this. */
2063
yyn = yypact[yystate];
2064
if (yyn != YYPACT_NINF)
2067
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2075
/* Pop the current state because it cannot handle the error token. */
2080
yydestruct ("Error: popping",
2081
yystos[yystate], yyvsp);
2084
YY_STACK_PRINT (yyss, yyssp);
2090
/* Shift the error token. */
2091
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2097
/*-------------------------------------.
2098
| yyacceptlab -- YYACCEPT comes here. |
2099
`-------------------------------------*/
2104
/*-----------------------------------.
2105
| yyabortlab -- YYABORT comes here. |
2106
`-----------------------------------*/
2111
#if !defined(yyoverflow) || YYERROR_VERBOSE
2112
/*-------------------------------------------------.
2113
| yyexhaustedlab -- memory exhaustion comes here. |
2114
`-------------------------------------------------*/
2116
yyerror (YY_("memory exhausted"));
2122
if (yychar != YYEMPTY)
2123
yydestruct ("Cleanup: discarding lookahead",
2125
/* Do not reclaim the symbols of the rule which action triggered
2126
this YYABORT or YYACCEPT. */
2128
YY_STACK_PRINT (yyss, yyssp);
2129
while (yyssp != yyss)
2131
yydestruct ("Cleanup: popping",
2132
yystos[*yyssp], yyvsp);
2137
YYSTACK_FREE (yyss);
2140
if (yymsg != yymsgbuf)
2141
YYSTACK_FREE (yymsg);
2143
/* Make sure YYID is used. */
2144
return YYID (yyresult);
2149
/* Line 1675 of yacc.c */
2150
#line 135 "mei_parser.y"
2153
/*----------------------------------------------------------------------------
2154
* Parsing error management
2155
*----------------------------------------------------------------------------*/
2158
yyerror(const char *s)
2162
mei_free_node(mei_glob_root);
2165
/* bft_printf("Warning: %s\n", s); */
2166
/* bft_printf("line %i column %i \n", line, column); */
2168
BFT_REALLOC(mei_glob_label_list, mei_glob_ierr_list+1, char*);
2169
BFT_REALLOC(mei_glob_line_list, mei_glob_ierr_list+1, int);
2170
BFT_REALLOC(mei_glob_column_list, mei_glob_ierr_list+1, int);
2172
l = strlen("Warning: ") +1;
2173
BFT_MALLOC(mei_glob_label_list[mei_glob_ierr_list], l, char);
2174
strncpy(mei_glob_label_list[mei_glob_ierr_list], "Error: ", l);
2177
BFT_REALLOC(mei_glob_label_list[mei_glob_ierr_list], l, char);
2178
strncat(mei_glob_label_list[mei_glob_ierr_list], s, l);
2181
BFT_REALLOC(mei_glob_label_list[mei_glob_ierr_list], l, char);
2182
strncat(mei_glob_label_list[mei_glob_ierr_list], " \n", l);
2184
mei_glob_line_list[mei_glob_ierr_list] = mei_glob_line;
2185
mei_glob_column_list[mei_glob_ierr_list] = mei_glob_column;
2187
mei_glob_ierr_list++;
2192
/*----------------------------------------------------------------------------*/
added
removed
src/mei/mei_parser.c
