← Back to branch summary

~ubuntu-branches/ubuntu/wily/freefem++/wily

« back to all changes in this revision

Viewing changes to src/lglib/lg.tab.cpp

  • Committer: Package Import Robot
  • Author(s): Dimitrios Eftaxiopoulos, Dimitrios Eftaxiopoulos, Christophe Trophime
  • Date: 2013-09-12 00:02:58 UTC
  • mfrom: (1.2.1) (11.1.1 experimental)
  • Revision ID: package-import@ubuntu.com-20130912000258-aclq2zfa1svt0p3x
Tags: 3.25-1
http://bugs.debian.org/701161
[ Dimitrios Eftaxiopoulos ]
* Imported Upstream version 3.25 (Closes: #701161 #706714)
* Change installation directory of header-like *.idp files
  from /usr/lib/freefem++ to /usr/include/freefem++, in order
  to fix a lintian warning
* Update patch to examples++-load/Makefile.am in order to enable
  functioning of load *.so and include *.idp commands in *.edp
  scripts
* Delete patches to src/Graphics/sansgraph.cpp and
  src/Graphics/xglrgraph.cpp because they are not needed any more
* Fix lintian warning about missing LDFLAGS
* Override dh_auto_test in debian/rules, such that in case it is 
  used, it completes executing all *.edp example files, regardless
  of aborting on some of them
* Add libmetis-dev to build-deps in d/control
* Remove libparmetis-dev from build deps
* Add --parallel option to dh $@ in debian/rules
* Add hardening compilation flags to mpic++
* Allow testing of compiling and running the example files after build

[ Christophe Trophime ]
* update C. Trophime email
* add support for nlopt, ipopt - simplify debian/rules
* upload CT changes to 3.20
* add patch for configure
* add patch for examples++-mpi
* fix bamg install
* add corrected scripts to build plugins
* add patch for properly build examples++-load
* add lintian overrides for libfreefem++
* add some missing files
* update patches
* update rules
* reorder BuildDepends - comment out unsupported libs

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lglib/lg.tab.cpp
1
 
/* A Bison parser, made by GNU Bison 2.3.  */
2
 
 
3
 
/* Skeleton implementation for Bison's Yacc-like parsers in C
4
 
 
5
 
   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6
 
   Free Software Foundation, Inc.
7
 
 
8
 
   This program is free software; you can redistribute it and/or modify
 
1
/* A Bison parser, made by GNU Bison 2.7.12-4996.  */
 
2
 
 
3
/* Bison implementation for Yacc-like parsers in C
 
4
   
 
5
      Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
 
6
   
 
7
   This program is free software: you can redistribute it and/or modify
9
8
   it under the terms of the GNU General Public License as published by
10
 
   the Free Software Foundation; either version 2, or (at your option)
11
 
   any later version.
12
 
 
 
9
   the Free Software Foundation, either version 3 of the License, or
 
10
   (at your option) any later version.
 
11
   
13
12
   This program is distributed in the hope that it will be useful,
14
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
15
   GNU General Public License for more details.
17
 
 
 
16
   
18
17
   You should have received a copy of the GNU General Public License
19
 
   along with this program; if not, write to the Free Software
20
 
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
21
 
   Boston, MA 02110-1301, USA.  */
 
18
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
19
 
23
20
/* As a special exception, you may create a larger work that contains
24
21
   part or all of the Bison parser skeleton and distribute that work
29
26
   special exception, which will cause the skeleton and the resulting
30
27
   Bison output files to be licensed under the GNU General Public
31
28
   License without this special exception.
32
 
 
 
29
   
33
30
   This special exception was added by the Free Software Foundation in
34
31
   version 2.2 of Bison.  */
35
32
 
47
44
#define YYBISON 1
48
45
 
49
46
/* Bison version.  */
50
 
#define YYBISON_VERSION "2.3"
 
47
#define YYBISON_VERSION "2.7.12-4996"
51
48
 
52
49
/* Skeleton name.  */
53
50
#define YYSKELETON_NAME "yacc.c"
55
52
/* Pure parsers.  */
56
53
#define YYPURE 0
57
54
 
58
 
/* Using locations.  */
59
 
#define YYLSP_NEEDED 0
 
55
/* Push parsers.  */
 
56
#define YYPUSH 0
 
57
 
 
58
/* Pull parsers.  */
 
59
#define YYPULL 1
 
60
 
60
61
 
61
62
/* Substitute the variable and function names.  */
62
 
#define yyparse lgparse
63
 
#define yylex   lglex
64
 
#define yyerror lgerror
65
 
#define yylval  lglval
66
 
#define yychar  lgchar
67
 
#define yydebug lgdebug
68
 
#define yynerrs lgnerrs
69
 
 
70
 
 
71
 
/* Tokens.  */
72
 
#ifndef YYTOKENTYPE
73
 
# define YYTOKENTYPE
74
 
   /* Put the tokens into the symbol table, so that GDB and other debuggers
75
 
      know about them.  */
76
 
   enum yytokentype {
77
 
     IF = 258,
78
 
     ELSE = 259,
79
 
     SET = 260,
80
 
     GTGT = 261,
81
 
     LTLT = 262,
82
 
     OR = 263,
83
 
     AND = 264,
84
 
     NE = 265,
85
 
     EQ = 266,
86
 
     GE = 267,
87
 
     LE = 268,
88
 
     DOTSLASH = 269,
89
 
     DOTSTAR = 270,
90
 
     MOINSMOINS = 271,
91
 
     PLUSPLUS = 272,
92
 
     UNARY = 273,
93
 
     LNUM = 274,
94
 
     DNUM = 275,
95
 
     CNUM = 276,
96
 
     ID = 277,
97
 
     FESPACEID = 278,
98
 
     IDPARAM = 279,
99
 
     STRING = 280,
100
 
     ENDOFFILE = 281,
101
 
     INCLUDE = 282,
102
 
     LOAD = 283,
103
 
     BIDON = 284,
104
 
     FOR = 285,
105
 
     WHILE = 286,
106
 
     BREAK = 287,
107
 
     CONTINUE = 288,
108
 
     RETURN = 289,
109
 
     TRY = 290,
110
 
     CATCH = 291,
111
 
     THROW = 292,
112
 
     TYPE = 293,
113
 
     FUNCTION = 294,
114
 
     FESPACE = 295,
115
 
     FESPACE1 = 296,
116
 
     FESPACE3 = 297,
117
 
     PLUSEQ = 298,
118
 
     MOINSEQ = 299,
119
 
     MULEQ = 300,
120
 
     DIVEQ = 301,
121
 
     DOTMULEQ = 302,
122
 
     DOTDIVEQ = 303,
123
 
     ARROW = 304,
124
 
     BORDER = 305,
125
 
     CURVE = 306,
126
 
     SOLVE = 307
127
 
   };
128
 
#endif
129
 
/* Tokens.  */
130
 
#define IF 258
131
 
#define ELSE 259
132
 
#define SET 260
133
 
#define GTGT 261
134
 
#define LTLT 262
135
 
#define OR 263
136
 
#define AND 264
137
 
#define NE 265
138
 
#define EQ 266
139
 
#define GE 267
140
 
#define LE 268
141
 
#define DOTSLASH 269
142
 
#define DOTSTAR 270
143
 
#define MOINSMOINS 271
144
 
#define PLUSPLUS 272
145
 
#define UNARY 273
146
 
#define LNUM 274
147
 
#define DNUM 275
148
 
#define CNUM 276
149
 
#define ID 277
150
 
#define FESPACEID 278
151
 
#define IDPARAM 279
152
 
#define STRING 280
153
 
#define ENDOFFILE 281
154
 
#define INCLUDE 282
155
 
#define LOAD 283
156
 
#define BIDON 284
157
 
#define FOR 285
158
 
#define WHILE 286
159
 
#define BREAK 287
160
 
#define CONTINUE 288
161
 
#define RETURN 289
162
 
#define TRY 290
163
 
#define CATCH 291
164
 
#define THROW 292
165
 
#define TYPE 293
166
 
#define FUNCTION 294
167
 
#define FESPACE 295
168
 
#define FESPACE1 296
169
 
#define FESPACE3 297
170
 
#define PLUSEQ 298
171
 
#define MOINSEQ 299
172
 
#define MULEQ 300
173
 
#define DIVEQ 301
174
 
#define DOTMULEQ 302
175
 
#define DOTDIVEQ 303
176
 
#define ARROW 304
177
 
#define BORDER 305
178
 
#define CURVE 306
179
 
#define SOLVE 307
180
 
 
181
 
 
182
 
 
 
63
#define yyparse         lgparse
 
64
#define yylex           lglex
 
65
#define yyerror         lgerror
 
66
#define yylval          lglval
 
67
#define yychar          lgchar
 
68
#define yydebug         lgdebug
 
69
#define yynerrs         lgnerrs
183
70
 
184
71
/* Copy the first part of user declarations.  */
 
72
/* Line 371 of yacc.c  */
185
73
#line 1 "lg.ypp"
186
74
 
187
75
    // -*- Mode : c++ -*-
305
193
void (*init_lgparallele)()=0;
306
194
void (*end_parallele)()=0;
307
195
 
 
196
/* Line 371 of yacc.c  */
 
197
#line 198 "lg.tab.cpp"
308
198
 
309
 
/* Enabling traces.  */
310
 
#ifndef YYDEBUG
311
 
# define YYDEBUG 1
312
 
#endif
 
199
# ifndef YY_NULL
 
200
#  if defined __cplusplus && 201103L <= __cplusplus
 
201
#   define YY_NULL nullptr
 
202
#  else
 
203
#   define YY_NULL 0
 
204
#  endif
 
205
# endif
313
206
 
314
207
/* Enabling verbose error messages.  */
315
208
#ifdef YYERROR_VERBOSE
319
212
# define YYERROR_VERBOSE 0
320
213
#endif
321
214
 
322
 
/* Enabling the token table.  */
323
 
#ifndef YYTOKEN_TABLE
324
 
# define YYTOKEN_TABLE 0
325
 
#endif
 
215
/* In a future release of Bison, this section will be replaced
 
216
   by #include "lg.tab.hpp".  */
 
217
#ifndef YY_LG_LG_TAB_HPP_INCLUDED
 
218
# define YY_LG_LG_TAB_HPP_INCLUDED
 
219
/* Enabling traces.  */
 
220
#ifndef YYDEBUG
 
221
# define YYDEBUG 1
 
222
#endif
 
223
#if YYDEBUG
 
224
extern int lgdebug;
 
225
#endif
 
226
 
 
227
/* Tokens.  */
 
228
#ifndef YYTOKENTYPE
 
229
# define YYTOKENTYPE
 
230
   /* Put the tokens into the symbol table, so that GDB and other debuggers
 
231
      know about them.  */
 
232
   enum yytokentype {
 
233
     IF = 258,
 
234
     ELSE = 259,
 
235
     SET = 260,
 
236
     GTGT = 261,
 
237
     LTLT = 262,
 
238
     OR = 263,
 
239
     AND = 264,
 
240
     NE = 265,
 
241
     EQ = 266,
 
242
     GE = 267,
 
243
     LE = 268,
 
244
     DOTSLASH = 269,
 
245
     DOTSTAR = 270,
 
246
     MOINSMOINS = 271,
 
247
     PLUSPLUS = 272,
 
248
     UNARY = 273,
 
249
     LNUM = 274,
 
250
     DNUM = 275,
 
251
     CNUM = 276,
 
252
     ID = 277,
 
253
     FESPACEID = 278,
 
254
     IDPARAM = 279,
 
255
     STRING = 280,
 
256
     ENDOFFILE = 281,
 
257
     INCLUDE = 282,
 
258
     LOAD = 283,
 
259
     BIDON = 284,
 
260
     FOR = 285,
 
261
     WHILE = 286,
 
262
     BREAK = 287,
 
263
     CONTINUE = 288,
 
264
     RETURN = 289,
 
265
     TRY = 290,
 
266
     CATCH = 291,
 
267
     THROW = 292,
 
268
     TYPE = 293,
 
269
     FUNCTION = 294,
 
270
     FESPACE = 295,
 
271
     FESPACE1 = 296,
 
272
     FESPACE3 = 297,
 
273
     PLUSEQ = 298,
 
274
     MOINSEQ = 299,
 
275
     MULEQ = 300,
 
276
     DIVEQ = 301,
 
277
     DOTMULEQ = 302,
 
278
     DOTDIVEQ = 303,
 
279
     ARROW = 304,
 
280
     BORDER = 305,
 
281
     CURVE = 306,
 
282
     SOLVE = 307
 
283
   };
 
284
#endif
 
285
 
326
286
 
327
287
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
328
288
typedef union YYSTYPE
 
289
{
 
290
/* Line 387 of yacc.c  */
329
291
#line 124 "lg.ypp"
330
 
{ 
 
292
 
331
293
 double dnum;
332
294
 long lnum;
333
295
 char * str;
340
302
 Block * block; 
341
303
 ListOfId *clist_id;
342
304
/* ListCatch * clist_Catchs;*/
343
 
}
344
 
/* Line 193 of yacc.c.  */
345
 
#line 346 "lg.tab.cpp"
346
 
        YYSTYPE;
 
305
 
 
306
 
 
307
/* Line 387 of yacc.c  */
 
308
#line 309 "lg.tab.cpp"
 
309
} YYSTYPE;
 
310
# define YYSTYPE_IS_TRIVIAL 1
347
311
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
348
312
# define YYSTYPE_IS_DECLARED 1
349
 
# define YYSTYPE_IS_TRIVIAL 1
350
 
#endif
351
 
 
352
 
 
 
313
#endif
 
314
 
 
315
extern YYSTYPE lglval;
 
316
 
 
317
#ifdef YYPARSE_PARAM
 
318
#if defined __STDC__ || defined __cplusplus
 
319
int lgparse (void *YYPARSE_PARAM);
 
320
#else
 
321
int lgparse ();
 
322
#endif
 
323
#else /* ! YYPARSE_PARAM */
 
324
#if defined __STDC__ || defined __cplusplus
 
325
int lgparse (void);
 
326
#else
 
327
int lgparse ();
 
328
#endif
 
329
#endif /* ! YYPARSE_PARAM */
 
330
 
 
331
#endif /* !YY_LG_LG_TAB_HPP_INCLUDED  */
353
332
 
354
333
/* Copy the second part of user declarations.  */
355
334
 
356
 
 
357
 
/* Line 216 of yacc.c.  */
358
 
#line 359 "lg.tab.cpp"
 
335
/* Line 390 of yacc.c  */
 
336
#line 337 "lg.tab.cpp"
359
337
 
360
338
#ifdef short
361
339
# undef short
408
386
# if defined YYENABLE_NLS && YYENABLE_NLS
409
387
#  if ENABLE_NLS
410
388
#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
411
 
#   define YY_(msgid) dgettext ("bison-runtime", msgid)
 
389
#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
412
390
#  endif
413
391
# endif
414
392
# ifndef YY_
415
 
#  define YY_(msgid) msgid
 
393
#  define YY_(Msgid) Msgid
 
394
# endif
 
395
#endif
 
396
 
 
397
#ifndef __attribute__
 
398
/* This feature is available in gcc versions 2.5 and later.  */
 
399
# if (! defined __GNUC__ || __GNUC__ < 2 \
 
400
      || (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
 
401
#  define __attribute__(Spec) /* empty */
416
402
# endif
417
403
#endif
418
404
 
419
405
/* Suppress unused-variable warnings by "using" E.  */
420
406
#if ! defined lint || defined __GNUC__
421
 
# define YYUSE(e) ((void) (e))
 
407
# define YYUSE(E) ((void) (E))
422
408
#else
423
 
# define YYUSE(e) /* empty */
 
409
# define YYUSE(E) /* empty */
424
410
#endif
425
411
 
 
412
 
426
413
/* Identity function, used to suppress warnings about constant conditions.  */
427
414
#ifndef lint
428
 
# define YYID(n) (n)
 
415
# define YYID(N) (N)
429
416
#else
430
417
#if (defined __STDC__ || defined __C99__FUNC__ \
431
418
     || defined __cplusplus || defined _MSC_VER)
432
419
static int
433
 
YYID (int i)
 
420
YYID (int yyi)
434
421
#else
435
422
static int
436
 
YYID (i)
437
 
    int i;
 
423
YYID (yyi)
 
424
    int yyi;
438
425
#endif
439
426
{
440
 
  return i;
 
427
  return yyi;
441
428
}
442
429
#endif
443
430
 
458
445
#    define alloca _alloca
459
446
#   else
460
447
#    define YYSTACK_ALLOC alloca
461
 
#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 
448
#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
462
449
     || defined __cplusplus || defined _MSC_VER)
463
450
#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
464
 
#     ifndef _STDLIB_H
465
 
#      define _STDLIB_H 1
 
451
      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
 
452
#     ifndef EXIT_SUCCESS
 
453
#      define EXIT_SUCCESS 0
466
454
#     endif
467
455
#    endif
468
456
#   endif
485
473
#  ifndef YYSTACK_ALLOC_MAXIMUM
486
474
#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
487
475
#  endif
488
 
#  if (defined __cplusplus && ! defined _STDLIB_H \
 
476
#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
489
477
       && ! ((defined YYMALLOC || defined malloc) \
490
478
             && (defined YYFREE || defined free)))
491
479
#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
492
 
#   ifndef _STDLIB_H
493
 
#    define _STDLIB_H 1
 
480
#   ifndef EXIT_SUCCESS
 
481
#    define EXIT_SUCCESS 0
494
482
#   endif
495
483
#  endif
496
484
#  ifndef YYMALLOC
497
485
#   define YYMALLOC malloc
498
 
#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 
486
#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
499
487
     || defined __cplusplus || defined _MSC_VER)
500
488
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
501
489
#   endif
502
490
#  endif
503
491
#  ifndef YYFREE
504
492
#   define YYFREE free
505
 
#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 
493
#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
506
494
     || defined __cplusplus || defined _MSC_VER)
507
495
void free (void *); /* INFRINGES ON USER NAME SPACE */
508
496
#   endif
518
506
/* A type that is properly aligned for any stack member.  */
519
507
union yyalloc
520
508
{
521
 
  yytype_int16 yyss;
522
 
  YYSTYPE yyvs;
523
 
  };
 
509
  yytype_int16 yyss_alloc;
 
510
  YYSTYPE yyvs_alloc;
 
511
};
524
512
 
525
513
/* The size of the maximum gap between one aligned stack and the next.  */
526
514
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
531
519
     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
532
520
      + YYSTACK_GAP_MAXIMUM)
533
521
 
534
 
/* Copy COUNT objects from FROM to TO.  The source and destination do
535
 
   not overlap.  */
536
 
# ifndef YYCOPY
537
 
#  if defined __GNUC__ && 1 < __GNUC__
538
 
#   define YYCOPY(To, From, Count) \
539
 
      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
540
 
#  else
541
 
#   define YYCOPY(To, From, Count)              \
542
 
      do                                        \
543
 
        {                                       \
544
 
          YYSIZE_T yyi;                         \
545
 
          for (yyi = 0; yyi < (Count); yyi++)   \
546
 
            (To)[yyi] = (From)[yyi];            \
547
 
        }                                       \
548
 
      while (YYID (0))
549
 
#  endif
550
 
# endif
 
522
# define YYCOPY_NEEDED 1
551
523
 
552
524
/* Relocate STACK from its old location to the new one.  The
553
525
   local variables YYSIZE and YYSTACKSIZE give the old and new number of
554
526
   elements in the stack, and YYPTR gives the new location of the
555
527
   stack.  Advance YYPTR to a properly aligned location for the next
556
528
   stack.  */
557
 
# define YYSTACK_RELOCATE(Stack)                                        \
 
529
# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
558
530
    do                                                                  \
559
531
      {                                                                 \
560
532
        YYSIZE_T yynewbytes;                                            \
561
 
        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
562
 
        Stack = &yyptr->Stack;                                          \
 
533
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 
534
        Stack = &yyptr->Stack_alloc;                                    \
563
535
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
564
536
        yyptr += yynewbytes / sizeof (*yyptr);                          \
565
537
      }                                                                 \
567
539
 
568
540
#endif
569
541
 
 
542
#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
 
543
/* Copy COUNT objects from SRC to DST.  The source and destination do
 
544
   not overlap.  */
 
545
# ifndef YYCOPY
 
546
#  if defined __GNUC__ && 1 < __GNUC__
 
547
#   define YYCOPY(Dst, Src, Count) \
 
548
      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
 
549
#  else
 
550
#   define YYCOPY(Dst, Src, Count)              \
 
551
      do                                        \
 
552
        {                                       \
 
553
          YYSIZE_T yyi;                         \
 
554
          for (yyi = 0; yyi < (Count); yyi++)   \
 
555
            (Dst)[yyi] = (Src)[yyi];            \
 
556
        }                                       \
 
557
      while (YYID (0))
 
558
#  endif
 
559
# endif
 
560
#endif /* !YYCOPY_NEEDED */
 
561
 
570
562
/* YYFINAL -- State number of the termination state.  */
571
563
#define YYFINAL  81
572
564
/* YYLAST -- Last index in YYTABLE.  */
734
726
/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
735
727
static const yytype_uint16 yyrline[] =
736
728
{
737
 
       0,   257,   257,   299,   302,   303,   306,   307,   308,   309,
738
 
     310,   311,   312,   313,   314,   315,   316,   317,   318,   319,
739
 
     320,   321,   322,   323,   324,   327,   328,   331,   331,   331,
740
 
     331,   333,   334,   335,   337,   344,   345,   346,   347,   348,
741
 
     349,   350,   353,   354,   355,   356,   357,   358,   359,   360,
742
 
     367,   368,   369,   370,   371,   372,   375,   376,   380,   380,
743
 
     380,   381,   382,   387,   388,   390,   391,   393,   394,   398,
744
 
     401,   402,   405,   405,   406,   407,   408,   410,   409,   426,
745
 
     425,   434,   435,   437,   439,   444,   444,   447,   449,   450,
746
 
     451,   452,   453,   454,   455,   456,   460,   461,   462,   463,
747
 
     465,   467,   470,   474,   478,   485,   488,   494,   500,   501,
748
 
     506,   507,   508,   509,   510,   514,   515,   516,   517,   518,
749
 
     519,   520,   521,   526,   527,   528,   529,   533,   534,   535,
750
 
     536,   537,   538,   539,   540,   541,   542,   543,   544,   545,
751
 
     546,   547,   548,   549,   550,   551,   552,   557,   558,   559,
752
 
     560,   564,   565,   566,   567,   568,   569,   570,   571,   572,
753
 
     573,   574,   577,   578,   582,   583,   586,   587,   588,   589,
754
 
     593,   594,   595,   596,   597,   598,   599,   600,   601,   602,
755
 
     603,   604,   605,   606,   607,   608,   609,   610,   611,   620,
756
 
     621
 
729
       0,   257,   257,   301,   304,   305,   310,   311,   312,   313,
 
730
     314,   315,   316,   317,   318,   319,   320,   321,   322,   323,
 
731
     324,   325,   326,   327,   328,   331,   332,   335,   335,   335,
 
732
     335,   339,   340,   341,   343,   350,   351,   352,   353,   354,
 
733
     355,   356,   361,   362,   363,   364,   365,   366,   367,   368,
 
734
     376,   377,   378,   379,   380,   381,   384,   385,   391,   391,
 
735
     391,   392,   393,   398,   399,   401,   402,   404,   405,   411,
 
736
     414,   415,   420,   420,   421,   422,   423,   425,   424,   441,
 
737
     440,   449,   450,   452,   454,   459,   459,   462,   466,   467,
 
738
     468,   469,   470,   471,   472,   473,   477,   478,   479,   480,
 
739
     482,   484,   487,   491,   495,   502,   505,   514,   520,   521,
 
740
     526,   527,   528,   529,   530,   534,   535,   536,   537,   538,
 
741
     539,   540,   541,   546,   547,   548,   549,   553,   554,   555,
 
742
     556,   557,   558,   559,   560,   561,   562,   563,   564,   565,
 
743
     566,   567,   568,   569,   570,   571,   572,   577,   578,   579,
 
744
     580,   584,   585,   586,   587,   588,   589,   590,   591,   592,
 
745
     593,   594,   597,   598,   602,   603,   606,   607,   608,   609,
 
746
     613,   614,   615,   616,   617,   618,   619,   620,   621,   622,
 
747
     623,   624,   625,   626,   627,   628,   629,   630,   631,   640,
 
748
     641
757
749
};
758
750
#endif
759
751
 
760
 
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 
752
#if YYDEBUG || YYERROR_VERBOSE || 0
761
753
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
762
754
   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
763
755
static const char *const yytname[] =
765
757
  "$end", "error", "$undefined", "IF", "ELSE", "','", "'='", "SET",
766
758
  "GTGT", "LTLT", "'|'", "OR", "'&'", "AND", "NE", "EQ", "'<'", "'>'",
767
759
  "GE", "LE", "'+'", "'-'", "'*'", "'/'", "'%'", "DOTSLASH", "DOTSTAR",
768
 
  "'!'", "MOINSMOINS", "PLUSPLUS", "UNARY", "'^'", "'''", "'_'", "'('",
 
760
  "'!'", "MOINSMOINS", "PLUSPLUS", "UNARY", "'^'", "'\\''", "'_'", "'('",
769
761
  "'['", "'.'", "')'", "']'", "LNUM", "DNUM", "CNUM", "ID", "FESPACEID",
770
762
  "IDPARAM", "STRING", "ENDOFFILE", "INCLUDE", "LOAD", "BIDON", "FOR",
771
763
  "WHILE", "BREAK", "CONTINUE", "RETURN", "TRY", "CATCH", "THROW", "TYPE",
775
767
  "instructions", "list_of_id_args", "list_of_id1", "id", "list_of_dcls",
776
768
  "parameters_list", "type_of_dcl", "ID_space", "ID_array_space",
777
769
  "fespace123", "fespace", "spaceIDa", "spaceIDb", "spaceIDs",
778
 
  "fespace_def", "fespace_def_list", "declaration", "@1", "@2", "@3",
779
 
  "begin", "end", "for_loop", "while_loop", "declaration_for", "@4", "try",
780
 
  "instruction", "catchs", "bornes", "border_expr", "Expr", "unop",
 
770
  "fespace_def", "fespace_def_list", "declaration", "$@1", "$@2", "$@3",
 
771
  "begin", "end", "for_loop", "while_loop", "declaration_for", "$@4",
 
772
  "try", "instruction", "catchs", "bornes", "border_expr", "Expr", "unop",
781
773
  "no_comma_expr", "no_set_expr", "no_ternary_expr", "sub_script_expr",
782
 
  "parameters", "array", "unary_expr", "pow_expr", "primary", 0
 
774
  "parameters", "array", "unary_expr", "pow_expr", "primary", YY_NULL
783
775
};
784
776
#endif
785
777
 
849
841
       3
850
842
};
851
843
 
852
 
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
853
 
   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 
844
/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
 
845
   Performed when YYTABLE doesn't specify something else to do.  Zero
854
846
   means the default is an error.  */
855
847
static const yytype_uint8 yydefact[] =
856
848
{
969
961
 
970
962
/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
971
963
   positive, shift that token.  If negative, reduce the rule which
972
 
   number is the opposite.  If zero, do what YYDEFACT says.
973
 
   If YYTABLE_NINF, syntax error.  */
 
964
   number is the opposite.  If YYTABLE_NINF, syntax error.  */
974
965
#define YYTABLE_NINF -31
975
966
static const yytype_int16 yytable[] =
976
967
{
1082
1073
     115,   116,   117,   118,   119,   120,   121,   122,   123
1083
1074
};
1084
1075
 
 
1076
#define yypact_value_is_default(Yystate) \
 
1077
  (!!((Yystate) == (-230)))
 
1078
 
 
1079
#define yytable_value_is_error(Yytable_value) \
 
1080
  YYID (0)
 
1081
 
1085
1082
static const yytype_int16 yycheck[] =
1086
1083
{
1087
1084
      33,    39,     7,    24,   132,     8,   235,     5,     5,     5,
1252
1249
 
1253
1250
/* Like YYERROR except do call yyerror.  This remains here temporarily
1254
1251
   to ease the transition to the new meaning of YYERROR, for GCC.
1255
 
   Once GCC version 2 has supplanted version 1, this can go.  */
 
1252
   Once GCC version 2 has supplanted version 1, this can go.  However,
 
1253
   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
 
1254
   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
 
1255
   discussed.  */
1256
1256
 
1257
1257
#define YYFAIL          goto yyerrlab
 
1258
#if defined YYFAIL
 
1259
  /* This is here to suppress warnings from the GCC cpp's
 
1260
     -Wunused-macros.  Normally we don't worry about that warning, but
 
1261
     some users do, and we want to make it easy for users to remove
 
1262
     YYFAIL uses, which will produce warnings from Bison 2.5.  */
 
1263
#endif
1258
1264
 
1259
1265
#define YYRECOVERING()  (!!yyerrstatus)
1260
1266
 
1261
 
#define YYBACKUP(Token, Value)                                  \
1262
 
do                                                              \
1263
 
  if (yychar == YYEMPTY && yylen == 1)                          \
1264
 
    {                                                           \
1265
 
      yychar = (Token);                                         \
1266
 
      yylval = (Value);                                         \
1267
 
      yytoken = YYTRANSLATE (yychar);                           \
1268
 
      YYPOPSTACK (1);                                           \
1269
 
      goto yybackup;                                            \
1270
 
    }                                                           \
1271
 
  else                                                          \
1272
 
    {                                                           \
 
1267
#define YYBACKUP(Token, Value)                                  \
 
1268
do                                                              \
 
1269
  if (yychar == YYEMPTY)                                        \
 
1270
    {                                                           \
 
1271
      yychar = (Token);                                         \
 
1272
      yylval = (Value);                                         \
 
1273
      YYPOPSTACK (yylen);                                       \
 
1274
      yystate = *yyssp;                                         \
 
1275
      goto yybackup;                                            \
 
1276
    }                                                           \
 
1277
  else                                                          \
 
1278
    {                                                           \
1273
1279
      yyerror (YY_("syntax error: cannot back up")); \
1274
1280
      YYERROR;                                                  \
1275
1281
    }                                                           \
1276
1282
while (YYID (0))
1277
1283
 
1278
 
 
 
1284
/* Error token number */
1279
1285
#define YYTERROR        1
1280
1286
#define YYERRCODE       256
1281
1287
 
1282
1288
 
1283
 
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1284
 
   If N is 0, then set CURRENT to the empty location which ends
1285
 
   the previous symbol: RHS[0] (always defined).  */
1286
 
 
1287
 
#define YYRHSLOC(Rhs, K) ((Rhs)[K])
1288
 
#ifndef YYLLOC_DEFAULT
1289
 
# define YYLLOC_DEFAULT(Current, Rhs, N)                                \
1290
 
    do                                                                  \
1291
 
      if (YYID (N))                                                    \
1292
 
        {                                                               \
1293
 
          (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
1294
 
          (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
1295
 
          (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
1296
 
          (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
1297
 
        }                                                               \
1298
 
      else                                                              \
1299
 
        {                                                               \
1300
 
          (Current).first_line   = (Current).last_line   =              \
1301
 
            YYRHSLOC (Rhs, 0).last_line;                                \
1302
 
          (Current).first_column = (Current).last_column =              \
1303
 
            YYRHSLOC (Rhs, 0).last_column;                              \
1304
 
        }                                                               \
1305
 
    while (YYID (0))
1306
 
#endif
1307
 
 
1308
 
 
1309
 
/* YY_LOCATION_PRINT -- Print the location on the stream.
1310
 
   This macro was not mandated originally: define only if we know
1311
 
   we won't break user code: when these are the locations we know.  */
1312
 
 
 
1289
/* This macro is provided for backward compatibility. */
1313
1290
#ifndef YY_LOCATION_PRINT
1314
 
# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1315
 
#  define YY_LOCATION_PRINT(File, Loc)                  \
1316
 
     fprintf (File, "%d.%d-%d.%d",                      \
1317
 
              (Loc).first_line, (Loc).first_column,     \
1318
 
              (Loc).last_line,  (Loc).last_column)
1319
 
# else
1320
 
#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1321
 
# endif
 
1291
# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1322
1292
#endif
1323
1293
 
1324
1294
 
1325
1295
/* YYLEX -- calling `yylex' with the right arguments.  */
1326
 
 
1327
1296
#ifdef YYLEX_PARAM
1328
1297
# define YYLEX yylex (YYLEX_PARAM)
1329
1298
#else
1373
1342
    YYSTYPE const * const yyvaluep;
1374
1343
#endif
1375
1344
{
 
1345
  FILE *yyo = yyoutput;
 
1346
  YYUSE (yyo);
1376
1347
  if (!yyvaluep)
1377
1348
    return;
1378
1349
# ifdef YYPRINT
1381
1352
# else
1382
1353
  YYUSE (yyoutput);
1383
1354
# endif
1384
 
  switch (yytype)
1385
 
    {
1386
 
      default:
1387
 
        break;
1388
 
    }
 
1355
  YYUSE (yytype);
1389
1356
}
1390
1357
 
1391
1358
 
1422
1389
#if (defined __STDC__ || defined __C99__FUNC__ \
1423
1390
     || defined __cplusplus || defined _MSC_VER)
1424
1391
static void
1425
 
yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
 
1392
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1426
1393
#else
1427
1394
static void
1428
 
yy_stack_print (bottom, top)
1429
 
    yytype_int16 *bottom;
1430
 
    yytype_int16 *top;
 
1395
yy_stack_print (yybottom, yytop)
 
1396
    yytype_int16 *yybottom;
 
1397
    yytype_int16 *yytop;
1431
1398
#endif
1432
1399
{
1433
1400
  YYFPRINTF (stderr, "Stack now");
1434
 
  for (; bottom <= top; ++bottom)
1435
 
    YYFPRINTF (stderr, " %d", *bottom);
 
1401
  for (; yybottom <= yytop; yybottom++)
 
1402
    {
 
1403
      int yybot = *yybottom;
 
1404
      YYFPRINTF (stderr, " %d", yybot);
 
1405
    }
1436
1406
  YYFPRINTF (stderr, "\n");
1437
1407
}
1438
1408
 
1466
1436
  /* The symbols being reduced.  */
1467
1437
  for (yyi = 0; yyi < yynrhs; yyi++)
1468
1438
    {
1469
 
      fprintf (stderr, "   $%d = ", yyi + 1);
 
1439
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1470
1440
      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1471
1441
                       &(yyvsp[(yyi + 1) - (yynrhs)])
1472
1442
                                       );
1473
 
      fprintf (stderr, "\n");
 
1443
      YYFPRINTF (stderr, "\n");
1474
1444
    }
1475
1445
}
1476
1446
 
1507
1477
# define YYMAXDEPTH 10000
1508
1478
#endif
1509
1479
 
1510
 
 
1511
1480
 
1512
1481
#if YYERROR_VERBOSE
1513
1482
 
1610
1579
}
1611
1580
# endif
1612
1581
 
1613
 
/* Copy into YYRESULT an error message about the unexpected token
1614
 
   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1615
 
   including the terminating null byte.  If YYRESULT is null, do not
1616
 
   copy anything; just return the number of bytes that would be
1617
 
   copied.  As a special case, return 0 if an ordinary "syntax error"
1618
 
   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1619
 
   size calculation.  */
1620
 
static YYSIZE_T
1621
 
yysyntax_error (char *yyresult, int yystate, int yychar)
 
1582
/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
 
1583
   about the unexpected token YYTOKEN for the state stack whose top is
 
1584
   YYSSP.
 
1585
 
 
1586
   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
 
1587
   not large enough to hold the message.  In that case, also set
 
1588
   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
 
1589
   required number of bytes is too large to store.  */
 
1590
static int
 
1591
yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
 
1592
                yytype_int16 *yyssp, int yytoken)
1622
1593
{
1623
 
  int yyn = yypact[yystate];
1624
 
 
1625
 
  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1626
 
    return 0;
1627
 
  else
1628
 
    {
1629
 
      int yytype = YYTRANSLATE (yychar);
1630
 
      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1631
 
      YYSIZE_T yysize = yysize0;
1632
 
      YYSIZE_T yysize1;
1633
 
      int yysize_overflow = 0;
1634
 
      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1635
 
      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1636
 
      int yyx;
1637
 
 
1638
 
# if 0
1639
 
      /* This is so xgettext sees the translatable formats that are
1640
 
         constructed on the fly.  */
1641
 
      YY_("syntax error, unexpected %s");
1642
 
      YY_("syntax error, unexpected %s, expecting %s");
1643
 
      YY_("syntax error, unexpected %s, expecting %s or %s");
1644
 
      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1645
 
      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1646
 
# endif
1647
 
      char *yyfmt;
1648
 
      char const *yyf;
1649
 
      static char const yyunexpected[] = "syntax error, unexpected %s";
1650
 
      static char const yyexpecting[] = ", expecting %s";
1651
 
      static char const yyor[] = " or %s";
1652
 
      char yyformat[sizeof yyunexpected
1653
 
                    + sizeof yyexpecting - 1
1654
 
                    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1655
 
                       * (sizeof yyor - 1))];
1656
 
      char const *yyprefix = yyexpecting;
1657
 
 
1658
 
      /* Start YYX at -YYN if negative to avoid negative indexes in
1659
 
         YYCHECK.  */
1660
 
      int yyxbegin = yyn < 0 ? -yyn : 0;
1661
 
 
1662
 
      /* Stay within bounds of both yycheck and yytname.  */
1663
 
      int yychecklim = YYLAST - yyn + 1;
1664
 
      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1665
 
      int yycount = 1;
1666
 
 
1667
 
      yyarg[0] = yytname[yytype];
1668
 
      yyfmt = yystpcpy (yyformat, yyunexpected);
1669
 
 
1670
 
      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1671
 
        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1672
 
          {
1673
 
            if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1674
 
              {
1675
 
                yycount = 1;
1676
 
                yysize = yysize0;
1677
 
                yyformat[sizeof yyunexpected - 1] = '\0';
1678
 
                break;
1679
 
              }
1680
 
            yyarg[yycount++] = yytname[yyx];
1681
 
            yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1682
 
            yysize_overflow |= (yysize1 < yysize);
1683
 
            yysize = yysize1;
1684
 
            yyfmt = yystpcpy (yyfmt, yyprefix);
1685
 
            yyprefix = yyor;
1686
 
          }
1687
 
 
1688
 
      yyf = YY_(yyformat);
1689
 
      yysize1 = yysize + yystrlen (yyf);
1690
 
      yysize_overflow |= (yysize1 < yysize);
1691
 
      yysize = yysize1;
1692
 
 
1693
 
      if (yysize_overflow)
1694
 
        return YYSIZE_MAXIMUM;
1695
 
 
1696
 
      if (yyresult)
1697
 
        {
1698
 
          /* Avoid sprintf, as that infringes on the user's name space.
1699
 
             Don't have undefined behavior even if the translation
1700
 
             produced a string with the wrong number of "%s"s.  */
1701
 
          char *yyp = yyresult;
1702
 
          int yyi = 0;
1703
 
          while ((*yyp = *yyf) != '\0')
1704
 
            {
1705
 
              if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1706
 
                {
1707
 
                  yyp += yytnamerr (yyp, yyarg[yyi++]);
1708
 
                  yyf += 2;
1709
 
                }
1710
 
              else
1711
 
                {
1712
 
                  yyp++;
1713
 
                  yyf++;
1714
 
                }
1715
 
            }
1716
 
        }
1717
 
      return yysize;
1718
 
    }
 
1594
  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
 
1595
  YYSIZE_T yysize = yysize0;
 
1596
  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
 
1597
  /* Internationalized format string. */
 
1598
  const char *yyformat = YY_NULL;
 
1599
  /* Arguments of yyformat. */
 
1600
  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
 
1601
  /* Number of reported tokens (one for the "unexpected", one per
 
1602
     "expected"). */
 
1603
  int yycount = 0;
 
1604
 
 
1605
  /* There are many possibilities here to consider:
 
1606
     - Assume YYFAIL is not used.  It's too flawed to consider.  See
 
1607
       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
 
1608
       for details.  YYERROR is fine as it does not invoke this
 
1609
       function.
 
1610
     - If this state is a consistent state with a default action, then
 
1611
       the only way this function was invoked is if the default action
 
1612
       is an error action.  In that case, don't check for expected
 
1613
       tokens because there are none.
 
1614
     - The only way there can be no lookahead present (in yychar) is if
 
1615
       this state is a consistent state with a default action.  Thus,
 
1616
       detecting the absence of a lookahead is sufficient to determine
 
1617
       that there is no unexpected or expected token to report.  In that
 
1618
       case, just report a simple "syntax error".
 
1619
     - Don't assume there isn't a lookahead just because this state is a
 
1620
       consistent state with a default action.  There might have been a
 
1621
       previous inconsistent state, consistent state with a non-default
 
1622
       action, or user semantic action that manipulated yychar.
 
1623
     - Of course, the expected token list depends on states to have
 
1624
       correct lookahead information, and it depends on the parser not
 
1625
       to perform extra reductions after fetching a lookahead from the
 
1626
       scanner and before detecting a syntax error.  Thus, state merging
 
1627
       (from LALR or IELR) and default reductions corrupt the expected
 
1628
       token list.  However, the list is correct for canonical LR with
 
1629
       one exception: it will still contain any token that will not be
 
1630
       accepted due to an error action in a later state.
 
1631
  */
 
1632
  if (yytoken != YYEMPTY)
 
1633
    {
 
1634
      int yyn = yypact[*yyssp];
 
1635
      yyarg[yycount++] = yytname[yytoken];
 
1636
      if (!yypact_value_is_default (yyn))
 
1637
        {
 
1638
          /* Start YYX at -YYN if negative to avoid negative indexes in
 
1639
             YYCHECK.  In other words, skip the first -YYN actions for
 
1640
             this state because they are default actions.  */
 
1641
          int yyxbegin = yyn < 0 ? -yyn : 0;
 
1642
          /* Stay within bounds of both yycheck and yytname.  */
 
1643
          int yychecklim = YYLAST - yyn + 1;
 
1644
          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
 
1645
          int yyx;
 
1646
 
 
1647
          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
 
1648
            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
 
1649
                && !yytable_value_is_error (yytable[yyx + yyn]))
 
1650
              {
 
1651
                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
 
1652
                  {
 
1653
                    yycount = 1;
 
1654
                    yysize = yysize0;
 
1655
                    break;
 
1656
                  }
 
1657
                yyarg[yycount++] = yytname[yyx];
 
1658
                {
 
1659
                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
 
1660
                  if (! (yysize <= yysize1
 
1661
                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
 
1662
                    return 2;
 
1663
                  yysize = yysize1;
 
1664
                }
 
1665
              }
 
1666
        }
 
1667
    }
 
1668
 
 
1669
  switch (yycount)
 
1670
    {
 
1671
# define YYCASE_(N, S)                      \
 
1672
      case N:                               \
 
1673
        yyformat = S;                       \
 
1674
      break
 
1675
      YYCASE_(0, YY_("syntax error"));
 
1676
      YYCASE_(1, YY_("syntax error, unexpected %s"));
 
1677
      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
 
1678
      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
 
1679
      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
 
1680
      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
 
1681
# undef YYCASE_
 
1682
    }
 
1683
 
 
1684
  {
 
1685
    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
 
1686
    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
 
1687
      return 2;
 
1688
    yysize = yysize1;
 
1689
  }
 
1690
 
 
1691
  if (*yymsg_alloc < yysize)
 
1692
    {
 
1693
      *yymsg_alloc = 2 * yysize;
 
1694
      if (! (yysize <= *yymsg_alloc
 
1695
             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
 
1696
        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
 
1697
      return 1;
 
1698
    }
 
1699
 
 
1700
  /* Avoid sprintf, as that infringes on the user's name space.
 
1701
     Don't have undefined behavior even if the translation
 
1702
     produced a string with the wrong number of "%s"s.  */
 
1703
  {
 
1704
    char *yyp = *yymsg;
 
1705
    int yyi = 0;
 
1706
    while ((*yyp = *yyformat) != '\0')
 
1707
      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
 
1708
        {
 
1709
          yyp += yytnamerr (yyp, yyarg[yyi++]);
 
1710
          yyformat += 2;
 
1711
        }
 
1712
      else
 
1713
        {
 
1714
          yyp++;
 
1715
          yyformat++;
 
1716
        }
 
1717
  }
 
1718
  return 0;
1719
1719
}
1720
1720
#endif /* YYERROR_VERBOSE */
1721
 
 
1722
1721
 
1723
1722
/*-----------------------------------------------.
1724
1723
| Release the memory associated to this symbol.  |
1743
1742
    yymsg = "Deleting";
1744
1743
  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1745
1744
 
1746
 
  switch (yytype)
1747
 
    {
1748
 
 
1749
 
      default:
1750
 
        break;
1751
 
    }
 
1745
  YYUSE (yytype);
1752
1746
}
1753
 
 
1754
 
 
1755
 
/* Prevent warnings from -Wmissing-prototypes.  */
1756
 
 
1757
 
#ifdef YYPARSE_PARAM
1758
 
#if defined __STDC__ || defined __cplusplus
1759
 
int yyparse (void *YYPARSE_PARAM);
1760
 
#else
1761
 
int yyparse ();
1762
 
#endif
1763
 
#else /* ! YYPARSE_PARAM */
1764
 
#if defined __STDC__ || defined __cplusplus
1765
 
int yyparse (void);
1766
 
#else
1767
 
int yyparse ();
1768
 
#endif
1769
 
#endif /* ! YYPARSE_PARAM */
1770
 
 
1771
 
 
1772
 
 
1773
 
/* The look-ahead symbol.  */
 
1747
 
 
1748
 
 
1749
 
 
1750
 
 
1751
/* The lookahead symbol.  */
1774
1752
int yychar;
1775
1753
 
1776
 
/* The semantic value of the look-ahead symbol.  */
1777
 
YYSTYPE yylval;
 
1754
 
 
1755
#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 
1756
# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 
1757
# define YY_IGNORE_MAYBE_UNINITIALIZED_END
 
1758
#endif
 
1759
#ifndef YY_INITIAL_VALUE
 
1760
# define YY_INITIAL_VALUE(Value) /* Nothing. */
 
1761
#endif
 
1762
 
 
1763
/* The semantic value of the lookahead symbol.  */
 
1764
YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
1778
1765
 
1779
1766
/* Number of syntax errors so far.  */
1780
1767
int yynerrs;
1781
1768
 
1782
1769
 
1783
 
 
1784
1770
/*----------.
1785
1771
| yyparse.  |
1786
1772
`----------*/
1807
1793
#endif
1808
1794
#endif
1809
1795
{
1810
 
  
1811
 
  int yystate;
 
1796
    int yystate;
 
1797
    /* Number of tokens to shift before error messages enabled.  */
 
1798
    int yyerrstatus;
 
1799
 
 
1800
    /* The stacks and their tools:
 
1801
       `yyss': related to states.
 
1802
       `yyvs': related to semantic values.
 
1803
 
 
1804
       Refer to the stacks through separate pointers, to allow yyoverflow
 
1805
       to reallocate them elsewhere.  */
 
1806
 
 
1807
    /* The state stack.  */
 
1808
    yytype_int16 yyssa[YYINITDEPTH];
 
1809
    yytype_int16 *yyss;
 
1810
    yytype_int16 *yyssp;
 
1811
 
 
1812
    /* The semantic value stack.  */
 
1813
    YYSTYPE yyvsa[YYINITDEPTH];
 
1814
    YYSTYPE *yyvs;
 
1815
    YYSTYPE *yyvsp;
 
1816
 
 
1817
    YYSIZE_T yystacksize;
 
1818
 
1812
1819
  int yyn;
1813
1820
  int yyresult;
1814
 
  /* Number of tokens to shift before error messages enabled.  */
1815
 
  int yyerrstatus;
1816
 
  /* Look-ahead token as an internal (translated) token number.  */
 
1821
  /* Lookahead token as an internal (translated) token number.  */
1817
1822
  int yytoken = 0;
 
1823
  /* The variables used to return semantic value and location from the
 
1824
     action routines.  */
 
1825
  YYSTYPE yyval;
 
1826
 
1818
1827
#if YYERROR_VERBOSE
1819
1828
  /* Buffer for error messages, and its allocated size.  */
1820
1829
  char yymsgbuf[128];
1822
1831
  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1823
1832
#endif
1824
1833
 
1825
 
  /* Three stacks and their tools:
1826
 
     `yyss': related to states,
1827
 
     `yyvs': related to semantic values,
1828
 
     `yyls': related to locations.
1829
 
 
1830
 
     Refer to the stacks thru separate pointers, to allow yyoverflow
1831
 
     to reallocate them elsewhere.  */
1832
 
 
1833
 
  /* The state stack.  */
1834
 
  yytype_int16 yyssa[YYINITDEPTH];
1835
 
  yytype_int16 *yyss = yyssa;
1836
 
  yytype_int16 *yyssp;
1837
 
 
1838
 
  /* The semantic value stack.  */
1839
 
  YYSTYPE yyvsa[YYINITDEPTH];
1840
 
  YYSTYPE *yyvs = yyvsa;
1841
 
  YYSTYPE *yyvsp;
1842
 
 
1843
 
 
1844
 
 
1845
1834
#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1846
1835
 
1847
 
  YYSIZE_T yystacksize = YYINITDEPTH;
1848
 
 
1849
 
  /* The variables used to return semantic value and location from the
1850
 
     action routines.  */
1851
 
  YYSTYPE yyval;
1852
 
 
1853
 
 
1854
1836
  /* The number of symbols on the RHS of the reduced rule.
1855
1837
     Keep to zero when no symbol should be popped.  */
1856
1838
  int yylen = 0;
1857
1839
 
 
1840
  yyssp = yyss = yyssa;
 
1841
  yyvsp = yyvs = yyvsa;
 
1842
  yystacksize = YYINITDEPTH;
 
1843
 
1858
1844
  YYDPRINTF ((stderr, "Starting parse\n"));
1859
1845
 
1860
1846
  yystate = 0;
1861
1847
  yyerrstatus = 0;
1862
1848
  yynerrs = 0;
1863
 
  yychar = YYEMPTY;             /* Cause a token to be read.  */
1864
 
 
1865
 
  /* Initialize stack pointers.
1866
 
     Waste one element of value and location stack
1867
 
     so that they stay on the same level as the state stack.
1868
 
     The wasted elements are never initialized.  */
1869
 
 
1870
 
  yyssp = yyss;
1871
 
  yyvsp = yyvs;
1872
 
 
 
1849
  yychar = YYEMPTY; /* Cause a token to be read.  */
1873
1850
  goto yysetstate;
1874
1851
 
1875
1852
/*------------------------------------------------------------.
1896
1873
        YYSTYPE *yyvs1 = yyvs;
1897
1874
        yytype_int16 *yyss1 = yyss;
1898
1875
 
1899
 
 
1900
1876
        /* Each stack pointer address is followed by the size of the
1901
1877
           data in use in that stack, in bytes.  This used to be a
1902
1878
           conditional around just the two extra args, but that might
1904
1880
        yyoverflow (YY_("memory exhausted"),
1905
1881
                    &yyss1, yysize * sizeof (*yyssp),
1906
1882
                    &yyvs1, yysize * sizeof (*yyvsp),
1907
 
 
1908
1883
                    &yystacksize);
1909
1884
 
1910
1885
        yyss = yyss1;
1927
1902
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1928
1903
        if (! yyptr)
1929
1904
          goto yyexhaustedlab;
1930
 
        YYSTACK_RELOCATE (yyss);
1931
 
        YYSTACK_RELOCATE (yyvs);
1932
 
 
 
1905
        YYSTACK_RELOCATE (yyss_alloc, yyss);
 
1906
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1933
1907
#  undef YYSTACK_RELOCATE
1934
1908
        if (yyss1 != yyssa)
1935
1909
          YYSTACK_FREE (yyss1);
1940
1914
      yyssp = yyss + yysize - 1;
1941
1915
      yyvsp = yyvs + yysize - 1;
1942
1916
 
1943
 
 
1944
1917
      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1945
1918
                  (unsigned long int) yystacksize));
1946
1919
 
1950
1923
 
1951
1924
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1952
1925
 
 
1926
  if (yystate == YYFINAL)
 
1927
    YYACCEPT;
 
1928
 
1953
1929
  goto yybackup;
1954
1930
 
1955
1931
/*-----------.
1958
1934
yybackup:
1959
1935
 
1960
1936
  /* Do appropriate processing given the current state.  Read a
1961
 
     look-ahead token if we need one and don't already have one.  */
 
1937
     lookahead token if we need one and don't already have one.  */
1962
1938
 
1963
 
  /* First try to decide what to do without reference to look-ahead token.  */
 
1939
  /* First try to decide what to do without reference to lookahead token.  */
1964
1940
  yyn = yypact[yystate];
1965
 
  if (yyn == YYPACT_NINF)
 
1941
  if (yypact_value_is_default (yyn))
1966
1942
    goto yydefault;
1967
1943
 
1968
 
  /* Not known => get a look-ahead token if don't already have one.  */
 
1944
  /* Not known => get a lookahead token if don't already have one.  */
1969
1945
 
1970
 
  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
 
1946
  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1971
1947
  if (yychar == YYEMPTY)
1972
1948
    {
1973
1949
      YYDPRINTF ((stderr, "Reading a token: "));
1993
1969
  yyn = yytable[yyn];
1994
1970
  if (yyn <= 0)
1995
1971
    {
1996
 
      if (yyn == 0 || yyn == YYTABLE_NINF)
1997
 
        goto yyerrlab;
 
1972
      if (yytable_value_is_error (yyn))
 
1973
        goto yyerrlab;
1998
1974
      yyn = -yyn;
1999
1975
      goto yyreduce;
2000
1976
    }
2001
1977
 
2002
 
  if (yyn == YYFINAL)
2003
 
    YYACCEPT;
2004
 
 
2005
1978
  /* Count tokens shifted since error; after three, turn off error
2006
1979
     status.  */
2007
1980
  if (yyerrstatus)
2008
1981
    yyerrstatus--;
2009
1982
 
2010
 
  /* Shift the look-ahead token.  */
 
1983
  /* Shift the lookahead token.  */
2011
1984
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2012
1985
 
2013
 
  /* Discard the shifted token unless it is eof.  */
2014
 
  if (yychar != YYEOF)
2015
 
    yychar = YYEMPTY;
 
1986
  /* Discard the shifted token.  */
 
1987
  yychar = YYEMPTY;
2016
1988
 
2017
1989
  yystate = yyn;
 
1990
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2018
1991
  *++yyvsp = yylval;
 
1992
  YY_IGNORE_MAYBE_UNINITIALIZED_END
2019
1993
 
2020
1994
  goto yynewstate;
2021
1995
 
2052
2026
  switch (yyn)
2053
2027
    {
2054
2028
        case 2:
 
2029
/* Line 1787 of yacc.c  */
2055
2030
#line 257 "lg.ypp"
2056
2031
    {
2057
2032
                        const char *  magicffglut="#!ffglutdata3.1\n";// for complex and vector 3d plot 
2058
 
                        if(ThePlotStream) fwrite(magicffglut,strlen(magicffglut),1,ThePlotStream);                  
 
2033
                        //FFCS: divert stream to FFCS
 
2034
                        if(ThePlotStream) ffapi::fwriteinit(magicffglut,strlen(magicffglut),1,ThePlotStream);               
2059
2035
                        size_t sizestack = currentblock->size()+1024 ; //  before close 
2060
2036
                        (yyvsp[(1) - (2)].cinst)+=currentblock->close(currentblock);
2061
2037
                        if(verbosity>2 || mpirank==0) cout << " sizestack + 1024 =" << sizestack << "  ( " << sizestack-1024 <<" )\n" ;   
2086
2062
                        //debugstack.clear() 
2087
2063
                        } 
2088
2064
                        fingraphique();
2089
 
                        if(ThePlotStream) {pclose(ThePlotStream); ThePlotStream=0;}
 
2065
                        //FFCS: divert stream to FFCS
 
2066
                        if(ThePlotStream) {ffapi::ff_pclose(ThePlotStream); ThePlotStream=0;}
2090
2067
                        UnShowAlloc =1;
2091
2068
                        NbPtr = ShowAlloc("end execution -- ",lg1) - NbPtr;
2092
2069
                        
2093
2070
                            if (NbPtr) { cout << " ######## We forget of deleting   " << NbPtr 
2094
2071
                                              << " Nb pointer,   " <<  lg1-lg0 << "Bytes " << " ,  mpirank " << mpirank <<endl;}
2095
 
  return 0;;}
 
2072
  return 0;}
2096
2073
    break;
2097
2074
 
2098
2075
  case 4:
2099
 
#line 302 "lg.ypp"
2100
 
    {(yyval.cinst)=(yyvsp[(1) - (1)].cexp);;;;}
 
2076
/* Line 1787 of yacc.c  */
 
2077
#line 304 "lg.ypp"
 
2078
    {(yyval.cinst)=(yyvsp[(1) - (1)].cexp);;;}
2101
2079
    break;
2102
2080
 
2103
2081
  case 5:
2104
 
#line 303 "lg.ypp"
 
2082
/* Line 1787 of yacc.c  */
 
2083
#line 305 "lg.ypp"
2105
2084
    { (yyval.cinst)= ((yyvsp[(1) - (2)].cinst)+=(yyvsp[(2) - (2)].cexp)) ;}
2106
2085
    break;
2107
2086
 
2108
2087
  case 6:
2109
 
#line 306 "lg.ypp"
2110
 
    { (yyval.clist_id)=new ListOfId();;}
 
2088
/* Line 1787 of yacc.c  */
 
2089
#line 310 "lg.ypp"
 
2090
    { (yyval.clist_id)=new ListOfId();}
2111
2091
    break;
2112
2092
 
2113
2093
  case 7:
2114
 
#line 307 "lg.ypp"
 
2094
/* Line 1787 of yacc.c  */
 
2095
#line 311 "lg.ypp"
2115
2096
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(1) - (1)].str)));}
2116
2097
    break;
2117
2098
 
2118
2099
  case 8:
2119
 
#line 308 "lg.ypp"
 
2100
/* Line 1787 of yacc.c  */
 
2101
#line 312 "lg.ypp"
2120
2102
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(1) - (3)].str),(yyvsp[(3) - (3)].cexp))) ;}
2121
2103
    break;
2122
2104
 
2123
2105
  case 9:
2124
 
#line 309 "lg.ypp"
 
2106
/* Line 1787 of yacc.c  */
 
2107
#line 313 "lg.ypp"
2125
2108
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(2) - (2)].str),Find((yyvsp[(1) - (2)].str)),atype<FE<double,2> **>()));}
2126
2109
    break;
2127
2110
 
2128
2111
  case 10:
2129
 
#line 310 "lg.ypp"
 
2112
/* Line 1787 of yacc.c  */
 
2113
#line 314 "lg.ypp"
2130
2114
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(3) - (3)].str),Find((yyvsp[(1) - (3)].str)),atype<FE<double,2> **>(),true));}
2131
2115
    break;
2132
2116
 
2133
2117
  case 11:
2134
 
#line 311 "lg.ypp"
 
2118
/* Line 1787 of yacc.c  */
 
2119
#line 315 "lg.ypp"
2135
2120
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(2) - (2)].str),Find((yyvsp[(1) - (2)].str)),atype<FE<double,3> **>()));}
2136
2121
    break;
2137
2122
 
2138
2123
  case 12:
2139
 
#line 312 "lg.ypp"
 
2124
/* Line 1787 of yacc.c  */
 
2125
#line 316 "lg.ypp"
2140
2126
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(3) - (3)].str),Find((yyvsp[(1) - (3)].str)),atype<FE<double,3> **>(),true));}
2141
2127
    break;
2142
2128
 
2143
2129
  case 13:
2144
 
#line 313 "lg.ypp"
 
2130
/* Line 1787 of yacc.c  */
 
2131
#line 317 "lg.ypp"
2145
2132
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(2) - (2)].str),C_F0(),(yyvsp[(1) - (2)].type)->right())) ;}
2146
2133
    break;
2147
2134
 
2148
2135
  case 14:
2149
 
#line 314 "lg.ypp"
 
2136
/* Line 1787 of yacc.c  */
 
2137
#line 318 "lg.ypp"
2150
2138
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(3) - (3)].str),C_F0(),(yyvsp[(1) - (3)].type),true)) ;}
2151
2139
    break;
2152
2140
 
2153
2141
  case 15:
2154
 
#line 315 "lg.ypp"
 
2142
/* Line 1787 of yacc.c  */
 
2143
#line 319 "lg.ypp"
2155
2144
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(2) - (3)].clist_id))) ;}
2156
2145
    break;
2157
2146
 
2158
2147
  case 16:
2159
 
#line 316 "lg.ypp"
 
2148
/* Line 1787 of yacc.c  */
 
2149
#line 320 "lg.ypp"
2160
2150
    { (yyval.clist_id) = (yyvsp[(1) - (3)].clist_id); (yyval.clist_id)->push_back(UnId((yyvsp[(3) - (3)].str))) ;}
2161
2151
    break;
2162
2152
 
2163
2153
  case 17:
2164
 
#line 317 "lg.ypp"
 
2154
/* Line 1787 of yacc.c  */
 
2155
#line 321 "lg.ypp"
2165
2156
    { (yyval.clist_id) = (yyvsp[(1) - (5)].clist_id); (yyval.clist_id)->push_back(UnId((yyvsp[(4) - (5)].clist_id))) ;}
2166
2157
    break;
2167
2158
 
2168
2159
  case 18:
2169
 
#line 318 "lg.ypp"
 
2160
/* Line 1787 of yacc.c  */
 
2161
#line 322 "lg.ypp"
2170
2162
    { (yyval.clist_id) = (yyvsp[(1) - (5)].clist_id); (yyval.clist_id)->push_back(UnId((yyvsp[(3) - (5)].str),(yyvsp[(5) - (5)].cexp))) ;}
2171
2163
    break;
2172
2164
 
2173
2165
  case 19:
2174
 
#line 319 "lg.ypp"
 
2166
/* Line 1787 of yacc.c  */
 
2167
#line 323 "lg.ypp"
2175
2168
    { (yyval.clist_id) = (yyvsp[(1) - (4)].clist_id); (yyval.clist_id)->push_back(UnId((yyvsp[(4) - (4)].str),Find((yyvsp[(3) - (4)].str)),atype<FE<double,2> **>())) ;}
2176
2169
    break;
2177
2170
 
2178
2171
  case 20:
2179
 
#line 320 "lg.ypp"
 
2172
/* Line 1787 of yacc.c  */
 
2173
#line 324 "lg.ypp"
2180
2174
    { (yyval.clist_id) = (yyvsp[(1) - (5)].clist_id); (yyval.clist_id)->push_back(UnId((yyvsp[(5) - (5)].str),Find((yyvsp[(3) - (5)].str)),atype<FE<double,2> **>(),true)) ;}
2181
2175
    break;
2182
2176
 
2183
2177
  case 21:
2184
 
#line 321 "lg.ypp"
 
2178
/* Line 1787 of yacc.c  */
 
2179
#line 325 "lg.ypp"
2185
2180
    { (yyval.clist_id) = (yyvsp[(1) - (4)].clist_id); (yyval.clist_id)->push_back(UnId((yyvsp[(4) - (4)].str),Find((yyvsp[(3) - (4)].str)),atype<FE<double,3> **>())) ;}
2186
2181
    break;
2187
2182
 
2188
2183
  case 22:
2189
 
#line 322 "lg.ypp"
 
2184
/* Line 1787 of yacc.c  */
 
2185
#line 326 "lg.ypp"
2190
2186
    { (yyval.clist_id) = (yyvsp[(1) - (5)].clist_id); (yyval.clist_id)->push_back(UnId((yyvsp[(5) - (5)].str),Find((yyvsp[(3) - (5)].str)),atype<FE<double,3> **>(),true)) ;}
2191
2187
    break;
2192
2188
 
2193
2189
  case 23:
2194
 
#line 323 "lg.ypp"
 
2190
/* Line 1787 of yacc.c  */
 
2191
#line 327 "lg.ypp"
2195
2192
    { (yyval.clist_id) = (yyvsp[(1) - (4)].clist_id); (yyval.clist_id)->push_back(UnId((yyvsp[(4) - (4)].str),C_F0(),(yyvsp[(3) - (4)].type)->right())) ;}
2196
2193
    break;
2197
2194
 
2198
2195
  case 24:
2199
 
#line 324 "lg.ypp"
 
2196
/* Line 1787 of yacc.c  */
 
2197
#line 328 "lg.ypp"
2200
2198
    { (yyval.clist_id) = (yyvsp[(1) - (5)].clist_id); (yyval.clist_id)->push_back(UnId((yyvsp[(5) - (5)].str),C_F0(),(yyvsp[(3) - (5)].type),true)) ;}
2201
2199
    break;
2202
2200
 
2203
2201
  case 25:
2204
 
#line 327 "lg.ypp"
2205
 
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(1) - (1)].str))); ;}
 
2202
/* Line 1787 of yacc.c  */
 
2203
#line 331 "lg.ypp"
 
2204
    { (yyval.clist_id) = new ListOfId(); (yyval.clist_id)->push_back(UnId((yyvsp[(1) - (1)].str))); }
2206
2205
    break;
2207
2206
 
2208
2207
  case 26:
2209
 
#line 328 "lg.ypp"
2210
 
    { (yyval.clist_id)=(yyvsp[(1) - (3)].clist_id)  ; (yyval.clist_id)->push_back(UnId((yyvsp[(3) - (3)].str))); ;}
 
2208
/* Line 1787 of yacc.c  */
 
2209
#line 332 "lg.ypp"
 
2210
    { (yyval.clist_id)=(yyvsp[(1) - (3)].clist_id)  ; (yyval.clist_id)->push_back(UnId((yyvsp[(3) - (3)].str))); }
2211
2211
    break;
2212
2212
 
2213
2213
  case 31:
2214
 
#line 333 "lg.ypp"
 
2214
/* Line 1787 of yacc.c  */
 
2215
#line 339 "lg.ypp"
2215
2216
    {(yyval.cexp)=currentblock->NewVar<LocalVariable>((yyvsp[(1) - (1)].str),dcltype);}
2216
2217
    break;
2217
2218
 
2218
2219
  case 32:
2219
 
#line 334 "lg.ypp"
 
2220
/* Line 1787 of yacc.c  */
 
2221
#line 340 "lg.ypp"
2220
2222
    {(yyval.cexp)=currentblock->NewVar<LocalVariable>((yyvsp[(1) - (3)].str),dcltype,(yyvsp[(3) - (3)].cexp));}
2221
2223
    break;
2222
2224
 
2223
2225
  case 33:
2224
 
#line 335 "lg.ypp"
 
2226
/* Line 1787 of yacc.c  */
 
2227
#line 341 "lg.ypp"
2225
2228
    {(yyval.cexp)=currentblock->NewVar<LocalVariable>((yyvsp[(1) - (4)].str),dcltype,(yyvsp[(3) - (4)].args));
2226
2229
                                              (yyvsp[(3) - (4)].args).destroy();}
2227
2230
    break;
2228
2231
 
2229
2232
  case 34:
2230
 
#line 337 "lg.ypp"
 
2233
/* Line 1787 of yacc.c  */
 
2234
#line 343 "lg.ypp"
2231
2235
    {(yyval.cexp)=C_F0((yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2232
2236
    break;
2233
2237
 
2234
2238
  case 35:
2235
 
#line 344 "lg.ypp"
 
2239
/* Line 1787 of yacc.c  */
 
2240
#line 350 "lg.ypp"
2236
2241
    {(yyval.args)=(yyvsp[(1) - (1)].cexp);}
2237
2242
    break;
2238
2243
 
2239
2244
  case 36:
2240
 
#line 345 "lg.ypp"
 
2245
/* Line 1787 of yacc.c  */
 
2246
#line 351 "lg.ypp"
2241
2247
    {(yyval.args)=Find((yyvsp[(1) - (2)].str));}
2242
2248
    break;
2243
2249
 
2244
2250
  case 37:
2245
 
#line 346 "lg.ypp"
 
2251
/* Line 1787 of yacc.c  */
 
2252
#line 352 "lg.ypp"
2246
2253
    {(yyval.args)=Find((yyvsp[(1) - (2)].str));}
2247
2254
    break;
2248
2255
 
2249
2256
  case 38:
2250
 
#line 347 "lg.ypp"
 
2257
/* Line 1787 of yacc.c  */
 
2258
#line 353 "lg.ypp"
2251
2259
    {(yyval.args)=Find((yyvsp[(1) - (2)].str));}
2252
2260
    break;
2253
2261
 
2254
2262
  case 39:
2255
 
#line 348 "lg.ypp"
 
2263
/* Line 1787 of yacc.c  */
 
2264
#line 354 "lg.ypp"
2256
2265
    { (yyval.args)=make_pair<const char *,const C_F0>((yyvsp[(1) - (3)].str),(yyvsp[(3) - (3)].cexp));}
2257
2266
    break;
2258
2267
 
2259
2268
  case 40:
2260
 
#line 349 "lg.ypp"
 
2269
/* Line 1787 of yacc.c  */
 
2270
#line 355 "lg.ypp"
2261
2271
    { (yyval.args) = ((yyvsp[(1) - (3)].args) += (yyvsp[(3) - (3)].cexp)) ;}
2262
2272
    break;
2263
2273
 
2264
2274
  case 41:
2265
 
#line 350 "lg.ypp"
 
2275
/* Line 1787 of yacc.c  */
 
2276
#line 356 "lg.ypp"
2266
2277
    { (yyval.args)= ((yyvsp[(1) - (5)].args)+= make_pair<const char *,const C_F0>((yyvsp[(3) - (5)].str),(yyvsp[(5) - (5)].cexp)));}
2267
2278
    break;
2268
2279
 
2269
2280
  case 43:
2270
 
#line 354 "lg.ypp"
 
2281
/* Line 1787 of yacc.c  */
 
2282
#line 362 "lg.ypp"
2271
2283
    {(yyval.type)=TypeArray((yyvsp[(1) - (4)].type),(yyvsp[(3) - (4)].type));}
2272
2284
    break;
2273
2285
 
2274
2286
  case 44:
2275
 
#line 355 "lg.ypp"
 
2287
/* Line 1787 of yacc.c  */
 
2288
#line 363 "lg.ypp"
2276
2289
    {(yyval.type)=TypeArray(TypeArray((yyvsp[(1) - (7)].type),(yyvsp[(3) - (7)].type)),(yyvsp[(6) - (7)].type));}
2277
2290
    break;
2278
2291
 
2279
2292
  case 45:
2280
 
#line 356 "lg.ypp"
 
2293
/* Line 1787 of yacc.c  */
 
2294
#line 364 "lg.ypp"
2281
2295
    {(yyval.type)=TypeArray((yyvsp[(1) - (6)].type),(yyvsp[(3) - (6)].type),(yyvsp[(5) - (6)].type));}
2282
2296
    break;
2283
2297
 
2284
2298
  case 46:
2285
 
#line 357 "lg.ypp"
 
2299
/* Line 1787 of yacc.c  */
 
2300
#line 365 "lg.ypp"
2286
2301
    {(yyval.type)=TypeArray(TypeArray((yyvsp[(1) - (9)].type),(yyvsp[(3) - (9)].type),(yyvsp[(5) - (9)].type)),(yyvsp[(8) - (9)].type));}
2287
2302
    break;
2288
2303
 
2289
2304
  case 47:
2290
 
#line 358 "lg.ypp"
 
2305
/* Line 1787 of yacc.c  */
 
2306
#line 366 "lg.ypp"
2291
2307
    {(yyval.type)=TypeTemplate((yyvsp[(1) - (4)].type),(yyvsp[(3) - (4)].type));}
2292
2308
    break;
2293
2309
 
2294
2310
  case 48:
2295
 
#line 359 "lg.ypp"
 
2311
/* Line 1787 of yacc.c  */
 
2312
#line 367 "lg.ypp"
2296
2313
    {(yyval.type)=TypeArray(TypeTemplate((yyvsp[(1) - (7)].type),(yyvsp[(3) - (7)].type)),(yyvsp[(6) - (7)].type));}
2297
2314
    break;
2298
2315
 
2299
2316
  case 49:
2300
 
#line 360 "lg.ypp"
 
2317
/* Line 1787 of yacc.c  */
 
2318
#line 368 "lg.ypp"
2301
2319
    {(yyval.type)=TypeArray(TypeTemplate((yyvsp[(1) - (9)].type),(yyvsp[(3) - (9)].type)),(yyvsp[(6) - (9)].type),(yyvsp[(8) - (9)].type));}
2302
2320
    break;
2303
2321
 
2304
2322
  case 50:
2305
 
#line 367 "lg.ypp"
2306
 
    { (yyval.cexp) =  NewFEvariable((yyvsp[(1) - (1)].str),currentblock,fespacetype,fespacecomplex,fespacedim); ;}
 
2323
/* Line 1787 of yacc.c  */
 
2324
#line 376 "lg.ypp"
 
2325
    { (yyval.cexp) =  NewFEvariable((yyvsp[(1) - (1)].str),currentblock,fespacetype,fespacecomplex,fespacedim); }
2307
2326
    break;
2308
2327
 
2309
2328
  case 51:
2310
 
#line 368 "lg.ypp"
2311
 
    { (yyval.cexp) =  NewFEarray((yyvsp[(1) - (4)].str),currentblock,fespacetype,(yyvsp[(3) - (4)].cexp),fespacecomplex,fespacedim); ;}
 
2329
/* Line 1787 of yacc.c  */
 
2330
#line 377 "lg.ypp"
 
2331
    { (yyval.cexp) =  NewFEarray((yyvsp[(1) - (4)].str),currentblock,fespacetype,(yyvsp[(3) - (4)].cexp),fespacecomplex,fespacedim); }
2312
2332
    break;
2313
2333
 
2314
2334
  case 52:
2315
 
#line 369 "lg.ypp"
 
2335
/* Line 1787 of yacc.c  */
 
2336
#line 378 "lg.ypp"
2316
2337
    { (yyval.cexp) =  NewFEvariable((yyvsp[(1) - (3)].str),currentblock,fespacetype,(yyvsp[(3) - (3)].cexp),fespacecomplex,fespacedim) ;}
2317
2338
    break;
2318
2339
 
2319
2340
  case 53:
2320
 
#line 370 "lg.ypp"
 
2341
/* Line 1787 of yacc.c  */
 
2342
#line 379 "lg.ypp"
2321
2343
    { (yyval.cexp) =  NewFEvariable((yyvsp[(2) - (3)].clist_id),currentblock,fespacetype,fespacecomplex,fespacedim) ;}
2322
2344
    break;
2323
2345
 
2324
2346
  case 54:
2325
 
#line 371 "lg.ypp"
 
2347
/* Line 1787 of yacc.c  */
 
2348
#line 380 "lg.ypp"
2326
2349
    { (yyval.cexp) =  NewFEarray((yyvsp[(2) - (6)].clist_id),currentblock,fespacetype,(yyvsp[(5) - (6)].cexp),fespacecomplex,fespacedim) ;}
2327
2350
    break;
2328
2351
 
2329
2352
  case 55:
2330
 
#line 372 "lg.ypp"
 
2353
/* Line 1787 of yacc.c  */
 
2354
#line 381 "lg.ypp"
2331
2355
    { (yyval.cexp) =  NewFEvariable((yyvsp[(2) - (5)].clist_id),currentblock,fespacetype,(yyvsp[(5) - (5)].cexp),fespacecomplex,fespacedim) ;}
2332
2356
    break;
2333
2357
 
2334
2358
  case 56:
2335
 
#line 375 "lg.ypp"
2336
 
    { (yyval.cexp) =  NewFEarray((yyvsp[(1) - (4)].str),currentblock,fespacetype,(yyvsp[(3) - (4)].cexp),fespacecomplex,fespacedim); ;}
 
2359
/* Line 1787 of yacc.c  */
 
2360
#line 384 "lg.ypp"
 
2361
    { (yyval.cexp) =  NewFEarray((yyvsp[(1) - (4)].str),currentblock,fespacetype,(yyvsp[(3) - (4)].cexp),fespacecomplex,fespacedim); }
2337
2362
    break;
2338
2363
 
2339
2364
  case 57:
2340
 
#line 376 "lg.ypp"
 
2365
/* Line 1787 of yacc.c  */
 
2366
#line 385 "lg.ypp"
2341
2367
    { (yyval.cexp) =  NewFEarray((yyvsp[(2) - (6)].clist_id),currentblock,fespacetype,(yyvsp[(5) - (6)].cexp),fespacecomplex,fespacedim) ;}
2342
2368
    break;
2343
2369
 
2344
2370
  case 58:
2345
 
#line 380 "lg.ypp"
 
2371
/* Line 1787 of yacc.c  */
 
2372
#line 391 "lg.ypp"
2346
2373
    { fespacedim=2;}
2347
2374
    break;
2348
2375
 
2349
2376
  case 59:
2350
 
#line 380 "lg.ypp"
 
2377
/* Line 1787 of yacc.c  */
 
2378
#line 391 "lg.ypp"
2351
2379
    { fespacedim=1;}
2352
2380
    break;
2353
2381
 
2354
2382
  case 60:
2355
 
#line 380 "lg.ypp"
 
2383
/* Line 1787 of yacc.c  */
 
2384
#line 391 "lg.ypp"
2356
2385
    { fespacedim=3;}
2357
2386
    break;
2358
2387
 
2359
2388
  case 61:
2360
 
#line 381 "lg.ypp"
2361
 
    {fespacecomplex=false;  fespacetype = Find((yyvsp[(1) - (1)].str));;}
 
2389
/* Line 1787 of yacc.c  */
 
2390
#line 392 "lg.ypp"
 
2391
    {fespacecomplex=false;  fespacetype = Find((yyvsp[(1) - (1)].str));}
2362
2392
    break;
2363
2393
 
2364
2394
  case 62:
2365
 
#line 382 "lg.ypp"
 
2395
/* Line 1787 of yacc.c  */
 
2396
#line 393 "lg.ypp"
2366
2397
    {
2367
2398
             if ((yyvsp[(3) - (4)].type) != typevarreal && (yyvsp[(3) - (4)].type) != typevarcomplex) lgerror (" type of finite element <real> or <complex>");
2368
2399
             fespacecomplex=((yyvsp[(3) - (4)].type)==typevarcomplex);
2369
 
             fespacetype = Find((yyvsp[(1) - (4)].str));;}
 
2400
             fespacetype = Find((yyvsp[(1) - (4)].str));}
2370
2401
    break;
2371
2402
 
2372
2403
  case 63:
2373
 
#line 387 "lg.ypp"
 
2404
/* Line 1787 of yacc.c  */
 
2405
#line 398 "lg.ypp"
2374
2406
    {  (yyval.cexp) = (yyvsp[(1) - (1)].cexp)  ;}
2375
2407
    break;
2376
2408
 
2377
2409
  case 64:
2378
 
#line 388 "lg.ypp"
2379
 
    { (yyval.cexp)=C_F0((yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));;}
 
2410
/* Line 1787 of yacc.c  */
 
2411
#line 399 "lg.ypp"
 
2412
    { (yyval.cexp)=C_F0((yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2380
2413
    break;
2381
2414
 
2382
2415
  case 65:
2383
 
#line 390 "lg.ypp"
 
2416
/* Line 1787 of yacc.c  */
 
2417
#line 401 "lg.ypp"
2384
2418
    {  (yyval.cexp) = (yyvsp[(1) - (1)].cexp)  ;}
2385
2419
    break;
2386
2420
 
2387
2421
  case 66:
2388
 
#line 391 "lg.ypp"
2389
 
    { (yyval.cexp)=C_F0((yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));;}
 
2422
/* Line 1787 of yacc.c  */
 
2423
#line 402 "lg.ypp"
 
2424
    { (yyval.cexp)=C_F0((yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2390
2425
    break;
2391
2426
 
2392
2427
  case 67:
2393
 
#line 393 "lg.ypp"
 
2428
/* Line 1787 of yacc.c  */
 
2429
#line 404 "lg.ypp"
2394
2430
    { (yyval.cexp)=0;  (yyval.cexp) = (yyvsp[(2) - (2)].cexp);}
2395
2431
    break;
2396
2432
 
2397
2433
  case 68:
2398
 
#line 394 "lg.ypp"
 
2434
/* Line 1787 of yacc.c  */
 
2435
#line 405 "lg.ypp"
2399
2436
    { (yyval.cexp)=0;  (yyval.cexp) = (yyvsp[(5) - (5)].cexp);}
2400
2437
    break;
2401
2438
 
2402
2439
  case 69:
2403
 
#line 398 "lg.ypp"
 
2440
/* Line 1787 of yacc.c  */
 
2441
#line 411 "lg.ypp"
2404
2442
    {(yyval.cexp)=currentblock->NewVar<LocalVariableFES,size_t>((yyvsp[(1) - (4)].str),typeFESpace((yyvsp[(3) - (4)].args)),(yyvsp[(3) - (4)].args),dimFESpaceImage((yyvsp[(3) - (4)].args)));
2405
 
     (yyvsp[(3) - (4)].args).destroy(); ;}
 
2443
     (yyvsp[(3) - (4)].args).destroy(); }
2406
2444
    break;
2407
2445
 
2408
2446
  case 71:
2409
 
#line 402 "lg.ypp"
 
2447
/* Line 1787 of yacc.c  */
 
2448
#line 415 "lg.ypp"
2410
2449
    {(yyval.cexp)=C_F0((yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2411
2450
    break;
2412
2451
 
2413
2452
  case 72:
2414
 
#line 405 "lg.ypp"
 
2453
/* Line 1787 of yacc.c  */
 
2454
#line 420 "lg.ypp"
2415
2455
    {dcltype=(yyvsp[(1) - (1)].type);}
2416
2456
    break;
2417
2457
 
2418
2458
  case 73:
2419
 
#line 405 "lg.ypp"
 
2459
/* Line 1787 of yacc.c  */
 
2460
#line 420 "lg.ypp"
2420
2461
    {(yyval.cexp)=(yyvsp[(3) - (4)].cexp);}
2421
2462
    break;
2422
2463
 
2423
2464
  case 74:
2424
 
#line 406 "lg.ypp"
 
2465
/* Line 1787 of yacc.c  */
 
2466
#line 421 "lg.ypp"
2425
2467
    {(yyval.cexp)=(yyvsp[(2) - (3)].cexp);}
2426
2468
    break;
2427
2469
 
2428
2470
  case 75:
2429
 
#line 407 "lg.ypp"
 
2471
/* Line 1787 of yacc.c  */
 
2472
#line 422 "lg.ypp"
2430
2473
    { (yyval.cexp)=(yyvsp[(1) - (2)].cexp);}
2431
2474
    break;
2432
2475
 
2433
2476
  case 76:
2434
 
#line 408 "lg.ypp"
2435
 
    {(yyval.cexp)=currentblock->NewID((yyvsp[(1) - (5)].type),(yyvsp[(2) - (5)].str),(yyvsp[(4) - (5)].cexp));;}
 
2477
/* Line 1787 of yacc.c  */
 
2478
#line 423 "lg.ypp"
 
2479
    {(yyval.cexp)=currentblock->NewID((yyvsp[(1) - (5)].type),(yyvsp[(2) - (5)].str),(yyvsp[(4) - (5)].cexp));}
2436
2480
    break;
2437
2481
 
2438
2482
  case 77:
2439
 
#line 410 "lg.ypp"
 
2483
/* Line 1787 of yacc.c  */
 
2484
#line 425 "lg.ypp"
2440
2485
    {   /* use the stack to store the prev return type*/
2441
2486
                      assert(kkembtype+1<nbembtype);
2442
2487
                      rettype[++kkembtype] = (yyvsp[(2) - (6)].type)->right();
2444
2489
                      (yyvsp[(5) - (6)].routine)=new Routine((yyvsp[(1) - (6)].type),(yyvsp[(2) - (6)].type)->right(),(yyvsp[(3) - (6)].str),(yyvsp[(5) - (6)].clist_id),currentblock);
2445
2490
                      // routineinblock[kkembtype]->Add($3,"(",$<routine>5); //pas recursif pour l'instanat test  FH 27 dec 2008
2446
2491
                     // cout << " \n after new routine \n " << endl;                      
2447
 
                      ;}
 
2492
                      }
2448
2493
    break;
2449
2494
 
2450
2495
  case 78:
2451
 
#line 419 "lg.ypp"
 
2496
/* Line 1787 of yacc.c  */
 
2497
#line 434 "lg.ypp"
2452
2498
    { currentblock=(yyvsp[(5) - (10)].routine)->Set((yyvsp[(9) - (10)].cinst));
2453
2499
                       currentblock->Add((yyvsp[(3) - (10)].str),"(",(yyvsp[(5) - (10)].routine)); //pas recursif pour l'instant test  FH 27 dec 2008
2454
2500
                       kkembtype--;
2455
2501
                       (yyval.cexp)=0;
2456
2502
                    
2457
 
                        ;}
 
2503
                        }
2458
2504
    break;
2459
2505
 
2460
2506
  case 79:
2461
 
#line 426 "lg.ypp"
2462
 
    {Block::open(currentblock); (yyvsp[(1) - (5)].type)->SetArgs((yyvsp[(4) - (5)].clist_id));;}
 
2507
/* Line 1787 of yacc.c  */
 
2508
#line 441 "lg.ypp"
 
2509
    {Block::open(currentblock); (yyvsp[(1) - (5)].type)->SetArgs((yyvsp[(4) - (5)].clist_id));}
2463
2510
    break;
2464
2511
 
2465
2512
  case 80:
2466
 
#line 428 "lg.ypp"
 
2513
/* Line 1787 of yacc.c  */
 
2514
#line 443 "lg.ypp"
2467
2515
    {  (yyval.cinst)=currentblock->close(currentblock);
2468
2516
                         (yyval.cexp)=currentblock->NewID((yyvsp[(1) - (9)].type),(yyvsp[(2) - (9)].str),(yyvsp[(8) - (9)].cexp),*(yyvsp[(4) - (9)].clist_id));
2469
2517
                         delete (yyvsp[(4) - (9)].clist_id); //  FH 23032005
2470
 
                         ;}
 
2518
                         }
2471
2519
    break;
2472
2520
 
2473
2521
  case 81:
2474
 
#line 434 "lg.ypp"
 
2522
/* Line 1787 of yacc.c  */
 
2523
#line 449 "lg.ypp"
2475
2524
    {  Block::open(currentblock);}
2476
2525
    break;
2477
2526
 
2478
2527
  case 82:
2479
 
#line 435 "lg.ypp"
 
2528
/* Line 1787 of yacc.c  */
 
2529
#line 450 "lg.ypp"
2480
2530
    {  (yyval.cexp)=currentblock->close(currentblock);}
2481
2531
    break;
2482
2532
 
2483
2533
  case 83:
2484
 
#line 437 "lg.ypp"
 
2534
/* Line 1787 of yacc.c  */
 
2535
#line 452 "lg.ypp"
2485
2536
    {ffassert(inloopcount<sizeStackOfLoop);  // modif FH july 2005
2486
 
                StackOfLoop[inloopcount++]=currentblock;;}
 
2537
                StackOfLoop[inloopcount++]=currentblock;}
2487
2538
    break;
2488
2539
 
2489
2540
  case 84:
2490
 
#line 439 "lg.ypp"
 
2541
/* Line 1787 of yacc.c  */
 
2542
#line 454 "lg.ypp"
2491
2543
    {ffassert(inloopcount<sizeStackOfLoop);
2492
 
                StackOfLoop[inloopcount++]=currentblock;;}
 
2544
                StackOfLoop[inloopcount++]=currentblock;}
2493
2545
    break;
2494
2546
 
2495
2547
  case 85:
2496
 
#line 444 "lg.ypp"
2497
 
    {dcltype=(yyvsp[(1) - (1)].type); Block::open(currentblock);  ;}
 
2548
/* Line 1787 of yacc.c  */
 
2549
#line 459 "lg.ypp"
 
2550
    {dcltype=(yyvsp[(1) - (1)].type); Block::open(currentblock);  }
2498
2551
    break;
2499
2552
 
2500
2553
  case 86:
2501
 
#line 445 "lg.ypp"
 
2554
/* Line 1787 of yacc.c  */
 
2555
#line 460 "lg.ypp"
2502
2556
    {(yyval.cexp)=(yyvsp[(3) - (3)].cexp);}
2503
2557
    break;
2504
2558
 
2505
2559
  case 87:
2506
 
#line 447 "lg.ypp"
 
2560
/* Line 1787 of yacc.c  */
 
2561
#line 462 "lg.ypp"
2507
2562
    { Block::open(currentblock) ;}
2508
2563
    break;
2509
2564
 
2510
2565
  case 88:
2511
 
#line 449 "lg.ypp"
2512
 
    {(yyval.cexp)=0;;}
 
2566
/* Line 1787 of yacc.c  */
 
2567
#line 466 "lg.ypp"
 
2568
    {(yyval.cexp)=0;}
2513
2569
    break;
2514
2570
 
2515
2571
  case 89:
2516
 
#line 450 "lg.ypp"
2517
 
    {zzzfff->input((yyvsp[(2) - (2)].str));(yyval.cexp)= 0; ;}
 
2572
/* Line 1787 of yacc.c  */
 
2573
#line 467 "lg.ypp"
 
2574
    {zzzfff->input((yyvsp[(2) - (2)].str));(yyval.cexp)= 0; }
2518
2575
    break;
2519
2576
 
2520
2577
  case 90:
2521
 
#line 451 "lg.ypp"
2522
 
    {load((yyvsp[(2) - (2)].str));(yyval.cexp)= 0; ;}
 
2578
/* Line 1787 of yacc.c  */
 
2579
#line 468 "lg.ypp"
 
2580
    {load((yyvsp[(2) - (2)].str));(yyval.cexp)= 0; }
2523
2581
    break;
2524
2582
 
2525
2583
  case 91:
2526
 
#line 452 "lg.ypp"
2527
 
    {(yyval.cexp)=Try((yyvsp[(3) - (5)].cinst),(yyvsp[(5) - (5)].cexp),currentblock->close(currentblock));;}
 
2584
/* Line 1787 of yacc.c  */
 
2585
#line 469 "lg.ypp"
 
2586
    {(yyval.cexp)=Try((yyvsp[(3) - (5)].cinst),(yyvsp[(5) - (5)].cexp),currentblock->close(currentblock));}
2528
2587
    break;
2529
2588
 
2530
2589
  case 92:
2531
 
#line 453 "lg.ypp"
 
2590
/* Line 1787 of yacc.c  */
 
2591
#line 470 "lg.ypp"
2532
2592
    {(yyval.cexp)=(yyvsp[(1) - (2)].cexp);}
2533
2593
    break;
2534
2594
 
2535
2595
  case 93:
2536
 
#line 454 "lg.ypp"
 
2596
/* Line 1787 of yacc.c  */
 
2597
#line 471 "lg.ypp"
2537
2598
    {(yyval.cexp)=(yyvsp[(1) - (1)].cexp);}
2538
2599
    break;
2539
2600
 
2540
2601
  case 94:
2541
 
#line 455 "lg.ypp"
 
2602
/* Line 1787 of yacc.c  */
 
2603
#line 472 "lg.ypp"
2542
2604
    {inloopcount--; (yyval.cexp)=For((yyvsp[(3) - (9)].cexp),(yyvsp[(5) - (9)].cexp),(yyvsp[(7) - (9)].cexp),(yyvsp[(9) - (9)].cexp));}
2543
2605
    break;
2544
2606
 
2545
2607
  case 95:
2546
 
#line 457 "lg.ypp"
 
2608
/* Line 1787 of yacc.c  */
 
2609
#line 474 "lg.ypp"
2547
2610
    {inloopcount--; 
2548
2611
                (yyval.cexp)=C_F0(For((yyvsp[(3) - (9)].cexp),(yyvsp[(5) - (9)].cexp),(yyvsp[(7) - (9)].cexp),(yyvsp[(9) - (9)].cexp)),currentblock->close(currentblock));}
2549
2612
    break;
2550
2613
 
2551
2614
  case 96:
2552
 
#line 460 "lg.ypp"
 
2615
/* Line 1787 of yacc.c  */
 
2616
#line 477 "lg.ypp"
2553
2617
    {inloopcount--;(yyval.cexp)=While((yyvsp[(3) - (5)].cexp),(yyvsp[(5) - (5)].cexp));}
2554
2618
    break;
2555
2619
 
2556
2620
  case 97:
2557
 
#line 461 "lg.ypp"
 
2621
/* Line 1787 of yacc.c  */
 
2622
#line 478 "lg.ypp"
2558
2623
    {(yyval.cexp)=FIf((yyvsp[(3) - (5)].cexp),(yyvsp[(5) - (5)].cexp));}
2559
2624
    break;
2560
2625
 
2561
2626
  case 98:
2562
 
#line 462 "lg.ypp"
 
2627
/* Line 1787 of yacc.c  */
 
2628
#line 479 "lg.ypp"
2563
2629
    {(yyval.cexp)=FIf((yyvsp[(3) - (7)].cexp),(yyvsp[(5) - (7)].cexp),(yyvsp[(7) - (7)].cexp));}
2564
2630
    break;
2565
2631
 
2566
2632
  case 99:
2567
 
#line 463 "lg.ypp"
 
2633
/* Line 1787 of yacc.c  */
 
2634
#line 480 "lg.ypp"
2568
2635
    { 
2569
2636
                      (yyval.cexp)=C_F0(new E_block((yyvsp[(2) - (3)].cinst),(yyvsp[(3) - (3)].cexp)),atype<void>()) ;}
2570
2637
    break;
2571
2638
 
2572
2639
  case 100:
2573
 
#line 465 "lg.ypp"
2574
 
    {
 
2640
/* Line 1787 of yacc.c  */
 
2641
#line 482 "lg.ypp"
 
2642
    { /* <<BORDER_ID>> */
2575
2643
                      (yyval.cexp)=0;currentblock->NewID(atype<const E_Border *>(),(yyvsp[(2) - (3)].str),C_F0(TheOperators,"[border]",(yyvsp[(3) - (3)].args)));}
2576
2644
    break;
2577
2645
 
2578
2646
  case 101:
2579
 
#line 467 "lg.ypp"
 
2647
/* Line 1787 of yacc.c  */
 
2648
#line 484 "lg.ypp"
2580
2649
    {
2581
2650
                      (yyval.cexp)=0;currentblock->NewID(atype<const E_Border *>(),(yyvsp[(2) - (6)].str),C_F0(TheOperators,"[border]",(yyvsp[(4) - (6)].args)));}
2582
2651
    break;
2583
2652
 
2584
2653
  case 102:
2585
 
#line 470 "lg.ypp"
 
2654
/* Line 1787 of yacc.c  */
 
2655
#line 487 "lg.ypp"
2586
2656
    {
2587
2657
                    if(inloopcount) 
2588
2658
                      (yyval.cexp)= C_F0(new E_throw(E_exception::e_break),atype<void>()); 
2590
2660
    break;
2591
2661
 
2592
2662
  case 103:
2593
 
#line 474 "lg.ypp"
 
2663
/* Line 1787 of yacc.c  */
 
2664
#line 491 "lg.ypp"
2594
2665
    { 
2595
2666
                    if(inloopcount)
2596
2667
                        (yyval.cexp)= C_F0(new E_throw(E_exception::e_continue),atype<void>()) ;
2598
2669
    break;
2599
2670
 
2600
2671
  case 104:
2601
 
#line 478 "lg.ypp"
 
2672
/* Line 1787 of yacc.c  */
 
2673
#line 495 "lg.ypp"
2602
2674
    { 
2603
2675
                    if (kkembtype>=0)
2604
2676
                      (yyval.cexp)= C_F0(new E_throw(E_exception::e_return,(rettype[kkembtype]->CastTo((yyvsp[(2) - (3)].cexp))).OnReturn()) ,atype<void>());
2606
2678
    break;
2607
2679
 
2608
2680
  case 105:
2609
 
#line 485 "lg.ypp"
2610
 
    {(yyval.cexp) =  (yyvsp[(7) - (7)].cexp); ;}
 
2681
/* Line 1787 of yacc.c  */
 
2682
#line 502 "lg.ypp"
 
2683
    {(yyval.cexp) =  (yyvsp[(7) - (7)].cexp); }
2611
2684
    break;
2612
2685
 
2613
2686
  case 106:
2614
 
#line 488 "lg.ypp"
 
2687
/* Line 1787 of yacc.c  */
 
2688
#line 505 "lg.ypp"
2615
2689
    { 
2616
2690
   Block::open(currentblock);
2617
2691
   (yyval.args) = currentblock->NewVar<LocalVariable>((yyvsp[(2) - (7)].str),atype<double*>());
2620
2694
    break;
2621
2695
 
2622
2696
  case 107:
2623
 
#line 494 "lg.ypp"
 
2697
/* Line 1787 of yacc.c  */
 
2698
#line 514 "lg.ypp"
2624
2699
    {   
2625
2700
   (yyval.args) = ((yyvsp[(1) - (2)].args) += (yyvsp[(2) - (2)].cexp));
2626
2701
   currentblock->close(currentblock);}
2627
2702
    break;
2628
2703
 
2629
2704
  case 109:
2630
 
#line 501 "lg.ypp"
2631
 
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));;}
 
2705
/* Line 1787 of yacc.c  */
 
2706
#line 521 "lg.ypp"
 
2707
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2632
2708
    break;
2633
2709
 
2634
2710
  case 116:
2635
 
#line 515 "lg.ypp"
 
2711
/* Line 1787 of yacc.c  */
 
2712
#line 535 "lg.ypp"
2636
2713
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2637
2714
    break;
2638
2715
 
2639
2716
  case 117:
2640
 
#line 516 "lg.ypp"
 
2717
/* Line 1787 of yacc.c  */
 
2718
#line 536 "lg.ypp"
2641
2719
    {(yyval.cexp)=C_F0(TheOperators,"+=",(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2642
2720
    break;
2643
2721
 
2644
2722
  case 118:
2645
 
#line 517 "lg.ypp"
 
2723
/* Line 1787 of yacc.c  */
 
2724
#line 537 "lg.ypp"
2646
2725
    {(yyval.cexp)=C_F0(TheOperators,"-=",(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2647
2726
    break;
2648
2727
 
2649
2728
  case 119:
2650
 
#line 518 "lg.ypp"
 
2729
/* Line 1787 of yacc.c  */
 
2730
#line 538 "lg.ypp"
2651
2731
    {(yyval.cexp)=C_F0(TheOperators,"*=",(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2652
2732
    break;
2653
2733
 
2654
2734
  case 120:
2655
 
#line 519 "lg.ypp"
 
2735
/* Line 1787 of yacc.c  */
 
2736
#line 539 "lg.ypp"
2656
2737
    {(yyval.cexp)=C_F0(TheOperators,"/=",(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2657
2738
    break;
2658
2739
 
2659
2740
  case 121:
2660
 
#line 520 "lg.ypp"
 
2741
/* Line 1787 of yacc.c  */
 
2742
#line 540 "lg.ypp"
2661
2743
    {(yyval.cexp)=C_F0(TheOperators,".*=",(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2662
2744
    break;
2663
2745
 
2664
2746
  case 122:
2665
 
#line 521 "lg.ypp"
 
2747
/* Line 1787 of yacc.c  */
 
2748
#line 541 "lg.ypp"
2666
2749
    {(yyval.cexp)=C_F0(TheOperators,"./=",(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2667
2750
    break;
2668
2751
 
2669
2752
  case 124:
2670
 
#line 527 "lg.ypp"
 
2753
/* Line 1787 of yacc.c  */
 
2754
#line 547 "lg.ypp"
2671
2755
    {(yyval.cexp)=C_F0(TheOperators,"?:",(yyvsp[(1) - (5)].cexp),(yyvsp[(3) - (5)].cexp),(yyvsp[(5) - (5)].cexp));}
2672
2756
    break;
2673
2757
 
2674
2758
  case 125:
2675
 
#line 528 "lg.ypp"
 
2759
/* Line 1787 of yacc.c  */
 
2760
#line 548 "lg.ypp"
2676
2761
    {(yyval.cexp)=C_F0(TheOperators,"::",(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2677
2762
    break;
2678
2763
 
2679
2764
  case 126:
2680
 
#line 529 "lg.ypp"
 
2765
/* Line 1787 of yacc.c  */
 
2766
#line 549 "lg.ypp"
2681
2767
    {(yyval.cexp)=C_F0(TheOperators,"::",(yyvsp[(1) - (5)].cexp),(yyvsp[(3) - (5)].cexp),(yyvsp[(5) - (5)].cexp));}
2682
2768
    break;
2683
2769
 
2684
2770
  case 128:
2685
 
#line 534 "lg.ypp"
 
2771
/* Line 1787 of yacc.c  */
 
2772
#line 554 "lg.ypp"
2686
2773
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2687
2774
    break;
2688
2775
 
2689
2776
  case 129:
2690
 
#line 535 "lg.ypp"
 
2777
/* Line 1787 of yacc.c  */
 
2778
#line 555 "lg.ypp"
2691
2779
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2692
2780
    break;
2693
2781
 
2694
2782
  case 130:
2695
 
#line 536 "lg.ypp"
 
2783
/* Line 1787 of yacc.c  */
 
2784
#line 556 "lg.ypp"
2696
2785
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2697
2786
    break;
2698
2787
 
2699
2788
  case 131:
2700
 
#line 537 "lg.ypp"
 
2789
/* Line 1787 of yacc.c  */
 
2790
#line 557 "lg.ypp"
2701
2791
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2702
2792
    break;
2703
2793
 
2704
2794
  case 132:
2705
 
#line 538 "lg.ypp"
 
2795
/* Line 1787 of yacc.c  */
 
2796
#line 558 "lg.ypp"
2706
2797
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2707
2798
    break;
2708
2799
 
2709
2800
  case 133:
2710
 
#line 539 "lg.ypp"
 
2801
/* Line 1787 of yacc.c  */
 
2802
#line 559 "lg.ypp"
2711
2803
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2712
2804
    break;
2713
2805
 
2714
2806
  case 134:
2715
 
#line 540 "lg.ypp"
 
2807
/* Line 1787 of yacc.c  */
 
2808
#line 560 "lg.ypp"
2716
2809
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2717
2810
    break;
2718
2811
 
2719
2812
  case 135:
2720
 
#line 541 "lg.ypp"
 
2813
/* Line 1787 of yacc.c  */
 
2814
#line 561 "lg.ypp"
2721
2815
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2722
2816
    break;
2723
2817
 
2724
2818
  case 136:
2725
 
#line 542 "lg.ypp"
 
2819
/* Line 1787 of yacc.c  */
 
2820
#line 562 "lg.ypp"
2726
2821
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2727
2822
    break;
2728
2823
 
2729
2824
  case 137:
2730
 
#line 543 "lg.ypp"
 
2825
/* Line 1787 of yacc.c  */
 
2826
#line 563 "lg.ypp"
2731
2827
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2732
2828
    break;
2733
2829
 
2734
2830
  case 138:
2735
 
#line 544 "lg.ypp"
 
2831
/* Line 1787 of yacc.c  */
 
2832
#line 564 "lg.ypp"
2736
2833
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2737
2834
    break;
2738
2835
 
2739
2836
  case 139:
2740
 
#line 545 "lg.ypp"
 
2837
/* Line 1787 of yacc.c  */
 
2838
#line 565 "lg.ypp"
2741
2839
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2742
2840
    break;
2743
2841
 
2744
2842
  case 140:
2745
 
#line 546 "lg.ypp"
 
2843
/* Line 1787 of yacc.c  */
 
2844
#line 566 "lg.ypp"
2746
2845
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2747
2846
    break;
2748
2847
 
2749
2848
  case 141:
2750
 
#line 547 "lg.ypp"
 
2849
/* Line 1787 of yacc.c  */
 
2850
#line 567 "lg.ypp"
2751
2851
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2752
2852
    break;
2753
2853
 
2754
2854
  case 142:
2755
 
#line 548 "lg.ypp"
 
2855
/* Line 1787 of yacc.c  */
 
2856
#line 568 "lg.ypp"
2756
2857
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2757
2858
    break;
2758
2859
 
2759
2860
  case 143:
2760
 
#line 549 "lg.ypp"
 
2861
/* Line 1787 of yacc.c  */
 
2862
#line 569 "lg.ypp"
2761
2863
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2762
2864
    break;
2763
2865
 
2764
2866
  case 144:
2765
 
#line 550 "lg.ypp"
 
2867
/* Line 1787 of yacc.c  */
 
2868
#line 570 "lg.ypp"
2766
2869
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2767
2870
    break;
2768
2871
 
2769
2872
  case 145:
2770
 
#line 551 "lg.ypp"
 
2873
/* Line 1787 of yacc.c  */
 
2874
#line 571 "lg.ypp"
2771
2875
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2772
2876
    break;
2773
2877
 
2774
2878
  case 146:
2775
 
#line 552 "lg.ypp"
 
2879
/* Line 1787 of yacc.c  */
 
2880
#line 572 "lg.ypp"
2776
2881
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2777
2882
    break;
2778
2883
 
2779
2884
  case 147:
2780
 
#line 557 "lg.ypp"
 
2885
/* Line 1787 of yacc.c  */
 
2886
#line 577 "lg.ypp"
2781
2887
    {(yyval.cexp)=(yyvsp[(1) - (1)].cexp);}
2782
2888
    break;
2783
2889
 
2784
2890
  case 148:
2785
 
#line 558 "lg.ypp"
 
2891
/* Line 1787 of yacc.c  */
 
2892
#line 578 "lg.ypp"
2786
2893
    {(yyval.cexp)=C_F0(TheOperators,":");}
2787
2894
    break;
2788
2895
 
2789
2896
  case 149:
2790
 
#line 559 "lg.ypp"
 
2897
/* Line 1787 of yacc.c  */
 
2898
#line 579 "lg.ypp"
2791
2899
    {(yyval.cexp)=C_F0(TheOperators,":",(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2792
2900
    break;
2793
2901
 
2794
2902
  case 150:
2795
 
#line 560 "lg.ypp"
 
2903
/* Line 1787 of yacc.c  */
 
2904
#line 580 "lg.ypp"
2796
2905
    {(yyval.cexp)=C_F0(TheOperators,":",(yyvsp[(1) - (5)].cexp),(yyvsp[(3) - (5)].cexp),(yyvsp[(5) - (5)].cexp));}
2797
2906
    break;
2798
2907
 
2799
2908
  case 151:
2800
 
#line 564 "lg.ypp"
 
2909
/* Line 1787 of yacc.c  */
 
2910
#line 584 "lg.ypp"
2801
2911
    {(yyval.args)=0;}
2802
2912
    break;
2803
2913
 
2804
2914
  case 152:
2805
 
#line 565 "lg.ypp"
 
2915
/* Line 1787 of yacc.c  */
 
2916
#line 585 "lg.ypp"
2806
2917
    {(yyval.args)=Find((yyvsp[(1) - (1)].str));}
2807
2918
    break;
2808
2919
 
2809
2920
  case 153:
2810
 
#line 566 "lg.ypp"
 
2921
/* Line 1787 of yacc.c  */
 
2922
#line 586 "lg.ypp"
2811
2923
    {(yyval.args)=Find((yyvsp[(1) - (1)].str));}
2812
2924
    break;
2813
2925
 
2814
2926
  case 154:
2815
 
#line 567 "lg.ypp"
 
2927
/* Line 1787 of yacc.c  */
 
2928
#line 587 "lg.ypp"
2816
2929
    {(yyval.args)=Find((yyvsp[(1) - (1)].str));}
2817
2930
    break;
2818
2931
 
2819
2932
  case 155:
2820
 
#line 568 "lg.ypp"
 
2933
/* Line 1787 of yacc.c  */
 
2934
#line 588 "lg.ypp"
2821
2935
    { (yyval.args)=make_pair<const char *,const C_F0>((yyvsp[(1) - (3)].str),(yyvsp[(3) - (3)].cexp));}
2822
2936
    break;
2823
2937
 
2824
2938
  case 156:
2825
 
#line 569 "lg.ypp"
 
2939
/* Line 1787 of yacc.c  */
 
2940
#line 589 "lg.ypp"
2826
2941
    {(yyval.args)=(yyvsp[(1) - (1)].cexp);}
2827
2942
    break;
2828
2943
 
2829
2944
  case 157:
2830
 
#line 570 "lg.ypp"
 
2945
/* Line 1787 of yacc.c  */
 
2946
#line 590 "lg.ypp"
2831
2947
    { (yyval.args) = ((yyvsp[(1) - (3)].args) += Find((yyvsp[(3) - (3)].str))) ;}
2832
2948
    break;
2833
2949
 
2834
2950
  case 158:
2835
 
#line 571 "lg.ypp"
 
2951
/* Line 1787 of yacc.c  */
 
2952
#line 591 "lg.ypp"
2836
2953
    { (yyval.args) = ((yyvsp[(1) - (3)].args) += Find((yyvsp[(3) - (3)].str))) ;}
2837
2954
    break;
2838
2955
 
2839
2956
  case 159:
2840
 
#line 572 "lg.ypp"
 
2957
/* Line 1787 of yacc.c  */
 
2958
#line 592 "lg.ypp"
2841
2959
    { (yyval.args) = ((yyvsp[(1) - (3)].args) += Find((yyvsp[(3) - (3)].str))) ;}
2842
2960
    break;
2843
2961
 
2844
2962
  case 160:
2845
 
#line 573 "lg.ypp"
 
2963
/* Line 1787 of yacc.c  */
 
2964
#line 593 "lg.ypp"
2846
2965
    { (yyval.args) = ((yyvsp[(1) - (3)].args) += (yyvsp[(3) - (3)].cexp)) ;}
2847
2966
    break;
2848
2967
 
2849
2968
  case 161:
2850
 
#line 574 "lg.ypp"
 
2969
/* Line 1787 of yacc.c  */
 
2970
#line 594 "lg.ypp"
2851
2971
    { (yyval.args)= ((yyvsp[(1) - (5)].args)+= make_pair<const char *,const C_F0>((yyvsp[(3) - (5)].str),(yyvsp[(5) - (5)].cexp))) ;}
2852
2972
    break;
2853
2973
 
2854
2974
  case 162:
2855
 
#line 577 "lg.ypp"
 
2975
/* Line 1787 of yacc.c  */
 
2976
#line 597 "lg.ypp"
2856
2977
    {(yyval.args)=(yyvsp[(1) - (1)].cexp);}
2857
2978
    break;
2858
2979
 
2859
2980
  case 163:
2860
 
#line 578 "lg.ypp"
 
2981
/* Line 1787 of yacc.c  */
 
2982
#line 598 "lg.ypp"
2861
2983
    {(yyval.args) = ((yyvsp[(1) - (3)].args) += (yyvsp[(3) - (3)].cexp)) ;}
2862
2984
    break;
2863
2985
 
2864
2986
  case 165:
2865
 
#line 583 "lg.ypp"
 
2987
/* Line 1787 of yacc.c  */
 
2988
#line 603 "lg.ypp"
2866
2989
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(1) - (2)].oper),(yyvsp[(2) - (2)].cexp));}
2867
2990
    break;
2868
2991
 
2869
2992
  case 167:
2870
 
#line 587 "lg.ypp"
 
2993
/* Line 1787 of yacc.c  */
 
2994
#line 607 "lg.ypp"
2871
2995
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2872
2996
    break;
2873
2997
 
2874
2998
  case 168:
2875
 
#line 588 "lg.ypp"
 
2999
/* Line 1787 of yacc.c  */
 
3000
#line 608 "lg.ypp"
2876
3001
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (3)].oper),(yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].cexp));}
2877
3002
    break;
2878
3003
 
2879
3004
  case 169:
2880
 
#line 589 "lg.ypp"
 
3005
/* Line 1787 of yacc.c  */
 
3006
#line 609 "lg.ypp"
2881
3007
    {(yyval.cexp)=C_F0(TheOperators,(yyvsp[(2) - (2)].oper),(yyvsp[(1) - (2)].cexp));}
2882
3008
    break;
2883
3009
 
2884
3010
  case 170:
2885
 
#line 593 "lg.ypp"
2886
 
    {(yyval.cexp)=Find((yyvsp[(1) - (1)].str));;}
 
3011
/* Line 1787 of yacc.c  */
 
3012
#line 613 "lg.ypp"
 
3013
    {(yyval.cexp)=Find((yyvsp[(1) - (1)].str));}
2887
3014
    break;
2888
3015
 
2889
3016
  case 171:
2890
 
#line 594 "lg.ypp"
 
3017
/* Line 1787 of yacc.c  */
 
3018
#line 614 "lg.ypp"
2891
3019
    {(yyval.cexp)= CConstant((yyvsp[(1) - (1)].lnum));}
2892
3020
    break;
2893
3021
 
2894
3022
  case 172:
2895
 
#line 595 "lg.ypp"
 
3023
/* Line 1787 of yacc.c  */
 
3024
#line 615 "lg.ypp"
2896
3025
    {(yyval.cexp)= CConstant((yyvsp[(1) - (1)].dnum));}
2897
3026
    break;
2898
3027
 
2899
3028
  case 173:
2900
 
#line 596 "lg.ypp"
 
3029
/* Line 1787 of yacc.c  */
 
3030
#line 616 "lg.ypp"
2901
3031
    {(yyval.cexp)= CConstant(complex<double>(0,(yyvsp[(1) - (1)].dnum)));}
2902
3032
    break;
2903
3033
 
2904
3034
  case 174:
2905
 
#line 597 "lg.ypp"
 
3035
/* Line 1787 of yacc.c  */
 
3036
#line 617 "lg.ypp"
2906
3037
    {(yyval.cexp)= CConstant<const char *>((yyvsp[(1) - (1)].str));}
2907
3038
    break;
2908
3039
 
2909
3040
  case 175:
2910
 
#line 598 "lg.ypp"
2911
 
    {(yyval.cexp)=C_F0((yyvsp[(1) - (4)].cexp),(yyvsp[(2) - (4)].oper),(yyvsp[(3) - (4)].args));;}
 
3041
/* Line 1787 of yacc.c  */
 
3042
#line 618 "lg.ypp"
 
3043
    {(yyval.cexp)=C_F0((yyvsp[(1) - (4)].cexp),(yyvsp[(2) - (4)].oper),(yyvsp[(3) - (4)].args));}
2912
3044
    break;
2913
3045
 
2914
3046
  case 176:
2915
 
#line 599 "lg.ypp"
 
3047
/* Line 1787 of yacc.c  */
 
3048
#line 619 "lg.ypp"
2916
3049
    {(yyval.cexp)=C_F0((yyvsp[(1) - (4)].cexp),(yyvsp[(2) - (4)].oper),(yyvsp[(3) - (4)].cexp));}
2917
3050
    break;
2918
3051
 
2919
3052
  case 177:
2920
 
#line 600 "lg.ypp"
 
3053
/* Line 1787 of yacc.c  */
 
3054
#line 620 "lg.ypp"
2921
3055
    {(yyval.cexp)=C_F0((yyvsp[(1) - (6)].cexp),(yyvsp[(2) - (6)].oper),(yyvsp[(3) - (6)].cexp),(yyvsp[(5) - (6)].cexp));}
2922
3056
    break;
2923
3057
 
2924
3058
  case 178:
2925
 
#line 601 "lg.ypp"
 
3059
/* Line 1787 of yacc.c  */
 
3060
#line 621 "lg.ypp"
2926
3061
    {(yyval.cexp)=C_F0((yyvsp[(1) - (3)].cexp),"[]");}
2927
3062
    break;
2928
3063
 
2929
3064
  case 179:
2930
 
#line 602 "lg.ypp"
2931
 
    { (yyval.cexp)=C_F0((yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].str)) ;;}
 
3065
/* Line 1787 of yacc.c  */
 
3066
#line 622 "lg.ypp"
 
3067
    { (yyval.cexp)=C_F0((yyvsp[(1) - (3)].cexp),(yyvsp[(3) - (3)].str)) ;}
2932
3068
    break;
2933
3069
 
2934
3070
  case 180:
2935
 
#line 603 "lg.ypp"
2936
 
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (3)].str)),(yyvsp[(3) - (3)].str)) ;;}
 
3071
/* Line 1787 of yacc.c  */
 
3072
#line 623 "lg.ypp"
 
3073
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (3)].str)),(yyvsp[(3) - (3)].str)) ;}
2937
3074
    break;
2938
3075
 
2939
3076
  case 181:
2940
 
#line 604 "lg.ypp"
2941
 
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (4)].str)),(yyvsp[(2) - (4)].oper),(yyvsp[(3) - (4)].args)) ;;}
 
3077
/* Line 1787 of yacc.c  */
 
3078
#line 624 "lg.ypp"
 
3079
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (4)].str)),(yyvsp[(2) - (4)].oper),(yyvsp[(3) - (4)].args)) ;}
2942
3080
    break;
2943
3081
 
2944
3082
  case 182:
2945
 
#line 605 "lg.ypp"
2946
 
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (3)].str)),(yyvsp[(3) - (3)].str)) ;;}
 
3083
/* Line 1787 of yacc.c  */
 
3084
#line 625 "lg.ypp"
 
3085
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (3)].str)),(yyvsp[(3) - (3)].str)) ;}
2947
3086
    break;
2948
3087
 
2949
3088
  case 183:
2950
 
#line 606 "lg.ypp"
2951
 
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (4)].str)),(yyvsp[(2) - (4)].oper),(yyvsp[(3) - (4)].args)) ;;}
 
3089
/* Line 1787 of yacc.c  */
 
3090
#line 626 "lg.ypp"
 
3091
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (4)].str)),(yyvsp[(2) - (4)].oper),(yyvsp[(3) - (4)].args)) ;}
2952
3092
    break;
2953
3093
 
2954
3094
  case 184:
2955
 
#line 607 "lg.ypp"
2956
 
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (3)].str)),(yyvsp[(3) - (3)].str)) ;;}
 
3095
/* Line 1787 of yacc.c  */
 
3096
#line 627 "lg.ypp"
 
3097
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (3)].str)),(yyvsp[(3) - (3)].str)) ;}
2957
3098
    break;
2958
3099
 
2959
3100
  case 185:
2960
 
#line 608 "lg.ypp"
2961
 
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (4)].str)),(yyvsp[(2) - (4)].oper),(yyvsp[(3) - (4)].args)) ;;}
 
3101
/* Line 1787 of yacc.c  */
 
3102
#line 628 "lg.ypp"
 
3103
    { (yyval.cexp)=C_F0(Find((yyvsp[(1) - (4)].str)),(yyvsp[(2) - (4)].oper),(yyvsp[(3) - (4)].args)) ;}
2962
3104
    break;
2963
3105
 
2964
3106
  case 186:
2965
 
#line 609 "lg.ypp"
 
3107
/* Line 1787 of yacc.c  */
 
3108
#line 629 "lg.ypp"
2966
3109
    {(yyval.cexp)=C_F0(TheRightOperators,(yyvsp[(2) - (2)].oper),(yyvsp[(1) - (2)].cexp));}
2967
3110
    break;
2968
3111
 
2969
3112
  case 187:
2970
 
#line 610 "lg.ypp"
 
3113
/* Line 1787 of yacc.c  */
 
3114
#line 630 "lg.ypp"
2971
3115
    {(yyval.cexp)=C_F0(TheRightOperators,(yyvsp[(2) - (2)].oper),(yyvsp[(1) - (2)].cexp));}
2972
3116
    break;
2973
3117
 
2974
3118
  case 188:
2975
 
#line 611 "lg.ypp"
 
3119
/* Line 1787 of yacc.c  */
 
3120
#line 631 "lg.ypp"
2976
3121
    {
2977
3122
             if ((yyvsp[(1) - (4)].type)->right()->CastingFrom((yyvsp[(3) - (4)].cexp).left()) ) 
2978
3123
                (yyval.cexp)=(yyvsp[(1) - (4)].type)->right()->CastTo((yyvsp[(3) - (4)].cexp))  ;
2981
3126
                                        (yyvsp[(1) - (4)].type)->right()->name() << endl;
2982
3127
                                CompileError(" Error in type(exp) "); }
2983
3128
             }
2984
 
            ;}
 
3129
            }
2985
3130
    break;
2986
3131
 
2987
3132
  case 189:
2988
 
#line 620 "lg.ypp"
 
3133
/* Line 1787 of yacc.c  */
 
3134
#line 640 "lg.ypp"
2989
3135
    {(yyval.cexp)=(yyvsp[(2) - (3)].cexp);}
2990
3136
    break;
2991
3137
 
2992
3138
  case 190:
2993
 
#line 621 "lg.ypp"
 
3139
/* Line 1787 of yacc.c  */
 
3140
#line 641 "lg.ypp"
2994
3141
    { (yyval.cexp)=C_F0(TheOperators,"[]",(yyvsp[(2) - (3)].args));}
2995
3142
    break;
2996
3143
 
2997
3144
 
2998
 
/* Line 1267 of yacc.c.  */
2999
 
#line 3000 "lg.tab.cpp"
 
3145
/* Line 1787 of yacc.c  */
 
3146
#line 3147 "lg.tab.cpp"
3000
3147
      default: break;
3001
3148
    }
 
3149
  /* User semantic actions sometimes alter yychar, and that requires
 
3150
     that yytoken be updated with the new translation.  We take the
 
3151
     approach of translating immediately before every use of yytoken.
 
3152
     One alternative is translating here after every semantic action,
 
3153
     but that translation would be missed if the semantic action invokes
 
3154
     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
 
3155
     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
 
3156
     incorrect destructor might then be invoked immediately.  In the
 
3157
     case of YYERROR or YYBACKUP, subsequent parser actions might lead
 
3158
     to an incorrect destructor call or verbose syntax error message
 
3159
     before the lookahead is translated.  */
3002
3160
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3003
3161
 
3004
3162
  YYPOPSTACK (yylen);
3007
3165
 
3008
3166
  *++yyvsp = yyval;
3009
3167
 
3010
 
 
3011
3168
  /* Now `shift' the result of the reduction.  Determine what state
3012
3169
     that goes to, based on the state we popped back to and the rule
3013
3170
     number reduced by.  */
3027
3184
| yyerrlab -- here on detecting error |
3028
3185
`------------------------------------*/
3029
3186
yyerrlab:
 
3187
  /* Make sure we have latest lookahead translation.  See comments at
 
3188
     user semantic actions for why this is necessary.  */
 
3189
  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
 
3190
 
3030
3191
  /* If not already recovering from an error, report this error.  */
3031
3192
  if (!yyerrstatus)
3032
3193
    {
3034
3195
#if ! YYERROR_VERBOSE
3035
3196
      yyerror (YY_("syntax error"));
3036
3197
#else
 
3198
# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
 
3199
                                        yyssp, yytoken)
3037
3200
      {
3038
 
        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3039
 
        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3040
 
          {
3041
 
            YYSIZE_T yyalloc = 2 * yysize;
3042
 
            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3043
 
              yyalloc = YYSTACK_ALLOC_MAXIMUM;
3044
 
            if (yymsg != yymsgbuf)
3045
 
              YYSTACK_FREE (yymsg);
3046
 
            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3047
 
            if (yymsg)
3048
 
              yymsg_alloc = yyalloc;
3049
 
            else
3050
 
              {
3051
 
                yymsg = yymsgbuf;
3052
 
                yymsg_alloc = sizeof yymsgbuf;
3053
 
              }
3054
 
          }
3055
 
 
3056
 
        if (0 < yysize && yysize <= yymsg_alloc)
3057
 
          {
3058
 
            (void) yysyntax_error (yymsg, yystate, yychar);
3059
 
            yyerror (yymsg);
3060
 
          }
3061
 
        else
3062
 
          {
3063
 
            yyerror (YY_("syntax error"));
3064
 
            if (yysize != 0)
3065
 
              goto yyexhaustedlab;
3066
 
          }
 
3201
        char const *yymsgp = YY_("syntax error");
 
3202
        int yysyntax_error_status;
 
3203
        yysyntax_error_status = YYSYNTAX_ERROR;
 
3204
        if (yysyntax_error_status == 0)
 
3205
          yymsgp = yymsg;
 
3206
        else if (yysyntax_error_status == 1)
 
3207
          {
 
3208
            if (yymsg != yymsgbuf)
 
3209
              YYSTACK_FREE (yymsg);
 
3210
            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
 
3211
            if (!yymsg)
 
3212
              {
 
3213
                yymsg = yymsgbuf;
 
3214
                yymsg_alloc = sizeof yymsgbuf;
 
3215
                yysyntax_error_status = 2;
 
3216
              }
 
3217
            else
 
3218
              {
 
3219
                yysyntax_error_status = YYSYNTAX_ERROR;
 
3220
                yymsgp = yymsg;
 
3221
              }
 
3222
          }
 
3223
        yyerror (yymsgp);
 
3224
        if (yysyntax_error_status == 2)
 
3225
          goto yyexhaustedlab;
3067
3226
      }
 
3227
# undef YYSYNTAX_ERROR
3068
3228
#endif
3069
3229
    }
3070
3230
 
3072
3232
 
3073
3233
  if (yyerrstatus == 3)
3074
3234
    {
3075
 
      /* If just tried and failed to reuse look-ahead token after an
 
3235
      /* If just tried and failed to reuse lookahead token after an
3076
3236
         error, discard it.  */
3077
3237
 
3078
3238
      if (yychar <= YYEOF)
3089
3249
        }
3090
3250
    }
3091
3251
 
3092
 
  /* Else will try to reuse look-ahead token after shifting the error
 
3252
  /* Else will try to reuse lookahead token after shifting the error
3093
3253
     token.  */
3094
3254
  goto yyerrlab1;
3095
3255
 
3123
3283
  for (;;)
3124
3284
    {
3125
3285
      yyn = yypact[yystate];
3126
 
      if (yyn != YYPACT_NINF)
 
3286
      if (!yypact_value_is_default (yyn))
3127
3287
        {
3128
3288
          yyn += YYTERROR;
3129
3289
          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3146
3306
      YY_STACK_PRINT (yyss, yyssp);
3147
3307
    }
3148
3308
 
3149
 
  if (yyn == YYFINAL)
3150
 
    YYACCEPT;
3151
 
 
 
3309
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3152
3310
  *++yyvsp = yylval;
 
3311
  YY_IGNORE_MAYBE_UNINITIALIZED_END
3153
3312
 
3154
3313
 
3155
3314
  /* Shift the error token.  */
3173
3332
  yyresult = 1;
3174
3333
  goto yyreturn;
3175
3334
 
3176
 
#ifndef yyoverflow
 
3335
#if !defined yyoverflow || YYERROR_VERBOSE
3177
3336
/*-------------------------------------------------.
3178
3337
| yyexhaustedlab -- memory exhaustion comes here.  |
3179
3338
`-------------------------------------------------*/
3184
3343
#endif
3185
3344
 
3186
3345
yyreturn:
3187
 
  if (yychar != YYEOF && yychar != YYEMPTY)
3188
 
     yydestruct ("Cleanup: discarding lookahead",
3189
 
                 yytoken, &yylval);
 
3346
  if (yychar != YYEMPTY)
 
3347
    {
 
3348
      /* Make sure we have latest lookahead translation.  See comments at
 
3349
         user semantic actions for why this is necessary.  */
 
3350
      yytoken = YYTRANSLATE (yychar);
 
3351
      yydestruct ("Cleanup: discarding lookahead",
 
3352
                  yytoken, &yylval);
 
3353
    }
3190
3354
  /* Do not reclaim the symbols of the rule which action triggered
3191
3355
     this YYABORT or YYACCEPT.  */
3192
3356
  YYPOPSTACK (yylen);
3210
3374
}
3211
3375
 
3212
3376
 
3213
 
#line 626 "lg.ypp"
 
3377
/* Line 2050 of yacc.c  */
 
3378
#line 646 "lg.ypp"
3214
3379
 
3215
3380
 
3216
3381
 
3233
3398
bool withrgraphique = false;
3234
3399
//string  StrVersionNumber();
3235
3400
 
 
3401
/// Called by mainff() and activates the bison parser by calling yyparse()
3236
3402
int Compile()
3237
3403
{
3238
3404
  extern   YYSTYPE *plglval;  // modif FH 
3301
3467
#endif
3302
3468
   ios::sync_with_stdio();
3303
3469
}
 
3470
 
3304
3471
// pour l'environement.
3305
3472
extern const char *  prognamearg;
3306
3473
extern  bool echo_edp;
 
3474
 
 
3475
/// Called by mymain() and calls Compile() to run the FF language parser
3307
3476
int mainff (int  argc, char **argv)
3308
3477
{
3309
3478
    
3313
3482
 
3314
3483
    int vvold=verbosity; 
3315
3484
    if(mpirank !=0) verbosity=0;
 
3485
 
 
3486
  // ALH - 14/10/8 - This breaks FFCS output redirection
 
3487
#ifndef ENABLE_FFCS
3316
3488
  SetcppIo();
 
3489
#endif
 
3490
 
3317
3491
  GetEnvironment();   
3318
3492
    vvold=verbosity; 
3319
3493
    if(mpirank !=0) verbosity=0; 
3336
3510
  if ( ! (getprog(cc,argc,argv) >0)  ) 
3337
3511
    {
3338
3512
      cout << "-- FreeFem++ v" << StrVersionNumber() << " (error parameter!)\n"  ;
 
3513
      if(ThePlotStream) {pclose(ThePlotStream); ThePlotStream=0;}  
3339
3514
      return 1; 
3340
3515
    }
3341
3516
   
3397
3572
  EnvironmentLoad(); // just before compile
3398
3573
  verbosity=vvold; 
3399
3574
    
3400
 
  retvalue= Compile(); 
3401
 
      
 
3575
  retvalue= Compile();
 
3576
   // cout << " xxxxx " <<  retvalue << " " << ThePlotStream << endl;
3402
3577
 
3403
3578
  if(end_parallele) end_parallele();
3404
3579
 
3405
3580
  //  currentblock->close(currentblock).eval(thestack);
3406
3581
  fingraphique();
3407
 
  if(ThePlotStream) {pclose(ThePlotStream); ThePlotStream=0;}  
 
3582
  // FFCS: divert stream to FFCS
 
3583
  if(ThePlotStream){
 
3584
    ffapi::ff_pclose(ThePlotStream);
 
3585
    ThePlotStream=0;
 
3586
  }
3408
3587
  Destroylex( zzzfff);
3409
3588
  
3410
3589
   // ClearMem();
3411
3590
  return retvalue;
3412
3591
}
3413
3592
 
3414
 
 
3415
 
 
3416
 
 
 
3593
/* FFCS: emacs configuration for this file */
 
3594
 
 
3595
/*!
 
3596
 * Local Variables:
 
3597
 * mode:antlr
 
3598
 * ispell-local-dictionary:"british"
 
3599
 * coding:utf-8
 
3600
 * End:
 
3601
 */