source: palm/trunk/UTIL/chemistry/gasphase_preproc/kpp/src/y.tab.c @ 2696

Last change on this file since 2696 was 2696, checked in by kanani, 5 years ago

Merge of branch palm4u into trunk

File size: 73.0 KB
Line 
1/* A Bison parser, made by GNU Bison 2.7.  */
2
3/* Bison implementation for Yacc-like parsers in C
4   
5      Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
6   
7   This program is free software: you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation, either version 3 of the License, or
10   (at your option) any later version.
11   
12   This program is distributed in the hope that it will be useful,
13   but WITHOUT ANY WARRANTY; without even the implied warranty of
14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   GNU General Public License for more details.
16   
17   You should have received a copy of the GNU General Public License
18   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20/* As a special exception, you may create a larger work that contains
21   part or all of the Bison parser skeleton and distribute that work
22   under terms of your choice, so long as that work isn't itself a
23   parser generator using the skeleton or a modified version thereof
24   as a parser skeleton.  Alternatively, if you modify or redistribute
25   the parser skeleton itself, you may (at your option) remove this
26   special exception, which will cause the skeleton and the resulting
27   Bison output files to be licensed under the GNU General Public
28   License without this special exception.
29   
30   This special exception was added by the Free Software Foundation in
31   version 2.2 of Bison.  */
32
33/* C LALR(1) parser skeleton written by Richard Stallman, by
34   simplifying the original so-called "semantic" parser.  */
35
36/* All symbols defined below should begin with yy or YY, to avoid
37   infringing on user name space.  This should be done even for local
38   variables, as they might otherwise be expanded by user macros.
39   There are some unavoidable exceptions within include files to
40   define necessary library symbols; they are noted "INFRINGES ON
41   USER NAME SPACE" below.  */
42
43/* Identify Bison output.  */
44#define YYBISON 1
45
46/* Bison version.  */
47#define YYBISON_VERSION "2.7"
48
49/* Skeleton name.  */
50#define YYSKELETON_NAME "yacc.c"
51
52/* Pure parsers.  */
53#define YYPURE 0
54
55/* Push parsers.  */
56#define YYPUSH 0
57
58/* Pull parsers.  */
59#define YYPULL 1
60
61
62
63
64/* Copy the first part of user declarations.  */
65/* Line 371 of yacc.c  */
66#line 37 "scan.y"
67
68  #include <stdio.h>
69  #include <stdlib.h>
70  #include <malloc.h>
71  #include <string.h>
72  #include <unistd.h>
73  #include "scan.h"
74
75  #define __YYSCLASS
76
77  #define YYDEBUG 1
78  extern char yytext[];
79  extern FILE * yyin;
80 
81  int nError   = 0;
82  int nWarning = 0;
83
84  int crt_section;
85  int eqState;
86  int isPhoto = 0;
87
88  char crt_term[ 30 ];
89  char crt_coef[ 30 ];
90
91  char * InlineBuf;
92  int InlineLen;
93
94  void SemicolonError();
95  int yyerrflag=0;
96
97  void ParserErrorMessage();
98  void yyerror(char *);
99
100
101/* Line 371 of yacc.c  */
102#line 103 "y.tab.c"
103
104# ifndef YY_NULL
105#  if defined __cplusplus && 201103L <= __cplusplus
106#   define YY_NULL nullptr
107#  else
108#   define YY_NULL 0
109#  endif
110# endif
111
112/* Enabling verbose error messages.  */
113#ifdef YYERROR_VERBOSE
114# undef YYERROR_VERBOSE
115# define YYERROR_VERBOSE 1
116#else
117# define YYERROR_VERBOSE 0
118#endif
119
120/* In a future release of Bison, this section will be replaced
121   by #include "y.tab.h".  */
122#ifndef YY_YY_Y_TAB_H_INCLUDED
123# define YY_YY_Y_TAB_H_INCLUDED
124/* Enabling traces.  */
125#ifndef YYDEBUG
126# define YYDEBUG 0
127#endif
128#if YYDEBUG
129extern int yydebug;
130#endif
131
132/* Tokens.  */
133#ifndef YYTOKENTYPE
134# define YYTOKENTYPE
135   /* Put the tokens into the symbol table, so that GDB and other debuggers
136      know about them.  */
137   enum yytokentype {
138     JACOBIAN = 258,
139     DOUBLE = 259,
140     FUNCTION = 260,
141     DEFVAR = 261,
142     DEFRAD = 262,
143     DEFFIX = 263,
144     SETVAR = 264,
145     SETRAD = 265,
146     SETFIX = 266,
147     HESSIAN = 267,
148     STOICMAT = 268,
149     STOCHASTIC = 269,
150     DECLARE = 270,
151     INITVALUES = 271,
152     EQUATIONS = 272,
153     LUMP = 273,
154     INIEQUAL = 274,
155     EQNEQUAL = 275,
156     EQNCOLON = 276,
157     LMPCOLON = 277,
158     LMPPLUS = 278,
159     SPCPLUS = 279,
160     SPCEQUAL = 280,
161     ATOMDECL = 281,
162     CHECK = 282,
163     CHECKALL = 283,
164     REORDER = 284,
165     MEX = 285,
166     DUMMYINDEX = 286,
167     EQNTAGS = 287,
168     LOOKAT = 288,
169     LOOKATALL = 289,
170     TRANSPORT = 290,
171     TRANSPORTALL = 291,
172     MONITOR = 292,
173     USES = 293,
174     SPARSEDATA = 294,
175     WRITE_ATM = 295,
176     WRITE_SPC = 296,
177     WRITE_MAT = 297,
178     WRITE_OPT = 298,
179     INITIALIZE = 299,
180     XGRID = 300,
181     YGRID = 301,
182     ZGRID = 302,
183     USE = 303,
184     LANGUAGE = 304,
185     INTFILE = 305,
186     DRIVER = 306,
187     RUN = 307,
188     INLINE = 308,
189     ENDINLINE = 309,
190     PARAMETER = 310,
191     SPCSPC = 311,
192     INISPC = 312,
193     INIVALUE = 313,
194     EQNSPC = 314,
195     EQNSIGN = 315,
196     EQNCOEF = 316,
197     RATE = 317,
198     LMPSPC = 318,
199     SPCNR = 319,
200     ATOMID = 320,
201     LKTID = 321,
202     MNIID = 322,
203     INLCTX = 323,
204     INCODE = 324,
205     SSPID = 325,
206     EQNLESS = 326,
207     EQNTAG = 327,
208     EQNGREATER = 328,
209     TPTID = 329,
210     USEID = 330
211   };
212#endif
213
214
215#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
216typedef union YYSTYPE
217{
218/* Line 387 of yacc.c  */
219#line 72 "scan.y"
220
221  char str[80];
222
223
224/* Line 387 of yacc.c  */
225#line 226 "y.tab.c"
226} YYSTYPE;
227# define YYSTYPE_IS_TRIVIAL 1
228# define yystype YYSTYPE /* obsolescent; will be withdrawn */
229# define YYSTYPE_IS_DECLARED 1
230#endif
231
232extern YYSTYPE yylval;
233
234#ifdef YYPARSE_PARAM
235#if defined __STDC__ || defined __cplusplus
236int yyparse (void *YYPARSE_PARAM);
237#else
238int yyparse ();
239#endif
240#else /* ! YYPARSE_PARAM */
241#if defined __STDC__ || defined __cplusplus
242int yyparse (void);
243#else
244int yyparse ();
245#endif
246#endif /* ! YYPARSE_PARAM */
247
248#endif /* !YY_YY_Y_TAB_H_INCLUDED  */
249
250/* Copy the second part of user declarations.  */
251
252/* Line 390 of yacc.c  */
253#line 254 "y.tab.c"
254
255#ifdef short
256# undef short
257#endif
258
259#ifdef YYTYPE_UINT8
260typedef YYTYPE_UINT8 yytype_uint8;
261#else
262typedef unsigned char yytype_uint8;
263#endif
264
265#ifdef YYTYPE_INT8
266typedef YYTYPE_INT8 yytype_int8;
267#elif (defined __STDC__ || defined __C99__FUNC__ \
268     || defined __cplusplus || defined _MSC_VER)
269typedef signed char yytype_int8;
270#else
271typedef short int yytype_int8;
272#endif
273
274#ifdef YYTYPE_UINT16
275typedef YYTYPE_UINT16 yytype_uint16;
276#else
277typedef unsigned short int yytype_uint16;
278#endif
279
280#ifdef YYTYPE_INT16
281typedef YYTYPE_INT16 yytype_int16;
282#else
283typedef short int yytype_int16;
284#endif
285
286#ifndef YYSIZE_T
287# ifdef __SIZE_TYPE__
288#  define YYSIZE_T __SIZE_TYPE__
289# elif defined size_t
290#  define YYSIZE_T size_t
291# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
292     || defined __cplusplus || defined _MSC_VER)
293#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
294#  define YYSIZE_T size_t
295# else
296#  define YYSIZE_T unsigned int
297# endif
298#endif
299
300#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
301
302#ifndef YY_
303# if defined YYENABLE_NLS && YYENABLE_NLS
304#  if ENABLE_NLS
305#   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
306#   define YY_(Msgid) dgettext ("bison-runtime", Msgid)
307#  endif
308# endif
309# ifndef YY_
310#  define YY_(Msgid) Msgid
311# endif
312#endif
313
314/* Suppress unused-variable warnings by "using" E.  */
315#if ! defined lint || defined __GNUC__
316# define YYUSE(E) ((void) (E))
317#else
318# define YYUSE(E) /* empty */
319#endif
320
321/* Identity function, used to suppress warnings about constant conditions.  */
322#ifndef lint
323# define YYID(N) (N)
324#else
325#if (defined __STDC__ || defined __C99__FUNC__ \
326     || defined __cplusplus || defined _MSC_VER)
327static int
328YYID (int yyi)
329#else
330static int
331YYID (yyi)
332    int yyi;
333#endif
334{
335  return yyi;
336}
337#endif
338
339#if ! defined yyoverflow || YYERROR_VERBOSE
340
341/* The parser invokes alloca or malloc; define the necessary symbols.  */
342
343# ifdef YYSTACK_USE_ALLOCA
344#  if YYSTACK_USE_ALLOCA
345#   ifdef __GNUC__
346#    define YYSTACK_ALLOC __builtin_alloca
347#   elif defined __BUILTIN_VA_ARG_INCR
348#    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
349#   elif defined _AIX
350#    define YYSTACK_ALLOC __alloca
351#   elif defined _MSC_VER
352#    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
353#    define alloca _alloca
354#   else
355#    define YYSTACK_ALLOC alloca
356#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
357     || defined __cplusplus || defined _MSC_VER)
358#     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
359      /* Use EXIT_SUCCESS as a witness for stdlib.h.  */
360#     ifndef EXIT_SUCCESS
361#      define EXIT_SUCCESS 0
362#     endif
363#    endif
364#   endif
365#  endif
366# endif
367
368# ifdef YYSTACK_ALLOC
369   /* Pacify GCC's `empty if-body' warning.  */
370#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
371#  ifndef YYSTACK_ALLOC_MAXIMUM
372    /* The OS might guarantee only one guard page at the bottom of the stack,
373       and a page size can be as small as 4096 bytes.  So we cannot safely
374       invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
375       to allow for a few compiler-allocated temporary stack slots.  */
376#   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
377#  endif
378# else
379#  define YYSTACK_ALLOC YYMALLOC
380#  define YYSTACK_FREE YYFREE
381#  ifndef YYSTACK_ALLOC_MAXIMUM
382#   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
383#  endif
384#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
385       && ! ((defined YYMALLOC || defined malloc) \
386             && (defined YYFREE || defined free)))
387#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
388#   ifndef EXIT_SUCCESS
389#    define EXIT_SUCCESS 0
390#   endif
391#  endif
392#  ifndef YYMALLOC
393#   define YYMALLOC malloc
394#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
395     || defined __cplusplus || defined _MSC_VER)
396void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
397#   endif
398#  endif
399#  ifndef YYFREE
400#   define YYFREE free
401#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
402     || defined __cplusplus || defined _MSC_VER)
403void free (void *); /* INFRINGES ON USER NAME SPACE */
404#   endif
405#  endif
406# endif
407#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
408
409
410#if (! defined yyoverflow \
411     && (! defined __cplusplus \
412         || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
413
414/* A type that is properly aligned for any stack member.  */
415union yyalloc
416{
417  yytype_int16 yyss_alloc;
418  YYSTYPE yyvs_alloc;
419};
420
421/* The size of the maximum gap between one aligned stack and the next.  */
422# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
423
424/* The size of an array large to enough to hold all stacks, each with
425   N elements.  */
426# define YYSTACK_BYTES(N) \
427     ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
428      + YYSTACK_GAP_MAXIMUM)
429
430# define YYCOPY_NEEDED 1
431
432/* Relocate STACK from its old location to the new one.  The
433   local variables YYSIZE and YYSTACKSIZE give the old and new number of
434   elements in the stack, and YYPTR gives the new location of the
435   stack.  Advance YYPTR to a properly aligned location for the next
436   stack.  */
437# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
438    do                                                                  \
439      {                                                                 \
440        YYSIZE_T yynewbytes;                                            \
441        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
442        Stack = &yyptr->Stack_alloc;                                    \
443        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
444        yyptr += yynewbytes / sizeof (*yyptr);                          \
445      }                                                                 \
446    while (YYID (0))
447
448#endif
449
450#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
451/* Copy COUNT objects from SRC to DST.  The source and destination do
452   not overlap.  */
453# ifndef YYCOPY
454#  if defined __GNUC__ && 1 < __GNUC__
455#   define YYCOPY(Dst, Src, Count) \
456      __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
457#  else
458#   define YYCOPY(Dst, Src, Count)              \
459      do                                        \
460        {                                       \
461          YYSIZE_T yyi;                         \
462          for (yyi = 0; yyi < (Count); yyi++)   \
463            (Dst)[yyi] = (Src)[yyi];            \
464        }                                       \
465      while (YYID (0))
466#  endif
467# endif
468#endif /* !YYCOPY_NEEDED */
469
470/* YYFINAL -- State number of the termination state.  */
471#define YYFINAL  124
472/* YYLAST -- Last index in YYTABLE.  */
473#define YYLAST   192
474
475/* YYNTOKENS -- Number of terminals.  */
476#define YYNTOKENS  77
477/* YYNNTS -- Number of nonterminals.  */
478#define YYNNTS  35
479/* YYNRULES -- Number of rules.  */
480#define YYNRULES  111
481/* YYNRULES -- Number of states.  */
482#define YYNSTATES  202
483
484/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
485#define YYUNDEFTOK  2
486#define YYMAXUTOK   330
487
488#define YYTRANSLATE(YYX)                                                \
489  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
490
491/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
492static const yytype_uint8 yytranslate[] =
493{
494       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
495       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
496       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
497       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
498       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
499       2,     2,     2,     2,     2,     2,     2,     2,     2,    76,
500       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
501       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
502       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
503       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
504       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
505       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
506       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
507       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
508       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
509       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
510       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
511       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
512       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
513       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
514       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
515       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
516       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
517       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
518       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
519       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
520       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
521      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
522      25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
523      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
524      45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
525      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
526      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
527      75
528};
529
530#if YYDEBUG
531/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
532   YYRHS.  */
533static const yytype_uint16 yyprhs[] =
534{
535       0,     0,     3,     5,     8,    11,    14,    17,    20,    23,
536      26,    29,    32,    35,    38,    41,    44,    47,    50,    53,
537      56,    59,    62,    65,    68,    71,    74,    77,    80,    83,
538      85,    87,    89,    91,    93,    95,    97,   100,   103,   106,
539     109,   112,   115,   120,   123,   126,   129,   132,   135,   138,
540     141,   143,   147,   150,   153,   155,   159,   162,   165,   167,
541     171,   174,   177,   179,   183,   186,   189,   191,   195,   198,
542     201,   203,   207,   210,   213,   215,   219,   222,   225,   227,
543     229,   233,   235,   239,   241,   244,   246,   250,   253,   256,
544     260,   264,   267,   270,   275,   279,   282,   284,   288,   291,
545     294,   298,   301,   303,   306,   308,   312,   315,   318,   322,
546     326,   329
547};
548
549/* YYRHS -- A `-1'-separated list of the rules' RHS.  */
550static const yytype_int8 yyrhs[] =
551{
552      78,     0,    -1,    79,    -1,    79,    78,    -1,     3,    55,
553      -1,    12,    55,    -1,    15,    55,    -1,    13,    55,    -1,
554       4,    55,    -1,    29,    55,    -1,    30,    55,    -1,    31,
555      55,    -1,    32,    55,    -1,     5,    55,    -1,    14,    55,
556      -1,    26,    81,    -1,    27,    81,    -1,     6,    93,    -1,
557       7,    93,    -1,     8,    93,    -1,     9,    91,    -1,    10,
558      91,    -1,    11,    91,    -1,    16,    99,    -1,    17,   101,
559      -1,    18,   109,    -1,    33,    83,    -1,    37,    85,    -1,
560      35,    87,    -1,    28,    -1,    34,    -1,    36,    -1,    40,
561      -1,    41,    -1,    42,    -1,    43,    -1,    48,    55,    -1,
562      49,    55,    -1,    44,    55,    -1,    45,    55,    -1,    46,
563      55,    -1,    47,    55,    -1,    53,    68,   111,    54,    -1,
564      53,     1,    -1,    50,    55,    -1,    51,    55,    -1,    52,
565      55,    -1,    38,    89,    -1,    39,    55,    -1,    80,    76,
566      -1,    76,    -1,    81,    82,    80,    -1,    82,    80,    -1,
567       1,    80,    -1,    65,    -1,    83,    84,    80,    -1,    84,
568      80,    -1,     1,    80,    -1,    66,    -1,    85,    86,    80,
569      -1,    86,    80,    -1,     1,    80,    -1,    67,    -1,    87,
570      88,    80,    -1,    88,    80,    -1,     1,    80,    -1,    74,
571      -1,    89,    90,    80,    -1,    90,    80,    -1,     1,    80,
572      -1,    75,    -1,    91,    92,    80,    -1,    92,    80,    -1,
573       1,    80,    -1,    70,    -1,    93,    94,    80,    -1,    94,
574      80,    -1,     1,    80,    -1,    95,    -1,    96,    -1,    56,
575      25,    97,    -1,    56,    -1,    97,    24,    98,    -1,    98,
576      -1,    64,    56,    -1,    56,    -1,    99,   100,    80,    -1,
577     100,    80,    -1,     1,    80,    -1,    57,    19,    58,    -1,
578     101,   102,    80,    -1,   102,    80,    -1,     1,    80,    -1,
579     104,   105,   106,   103,    -1,   105,   106,   103,    -1,    62,
580     103,    -1,    62,    -1,    71,    72,    73,    -1,   107,    20,
581      -1,   107,    21,    -1,   107,    60,   108,    -1,    60,   108,
582      -1,   108,    -1,    61,    59,    -1,    59,    -1,   109,   110,
583      80,    -1,   110,    80,    -1,     1,    80,    -1,    63,    23,
584     110,    -1,    63,    22,    63,    -1,   111,    69,    -1,    69,
585      -1
586};
587
588/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
589static const yytype_uint16 yyrline[] =
590{
591       0,    96,    96,    97,    99,   102,   105,   108,   111,   114,
592     117,   120,   123,   126,   129,   132,   134,   136,   138,   140,
593     142,   144,   146,   148,   150,   152,   154,   156,   158,   160,
594     162,   164,   166,   168,   170,   172,   174,   176,   178,   180,
595     182,   184,   186,   191,   193,   195,   197,   199,   201,   205,
596     208,   210,   211,   212,   215,   222,   223,   224,   227,   231,
597     232,   233,   236,   240,   241,   242,   245,   249,   250,   251,
598     254,   258,   259,   260,   263,   271,   272,   273,   276,   277,
599     279,   287,   295,   296,   298,   301,   305,   306,   307,   310,
600     313,   314,   315,   320,   325,   330,   334,   338,   342,   345,
601     348,   351,   354,   358,   362,   367,   368,   369,   372,   375,
602     380,   384
603};
604#endif
605
606#if YYDEBUG || YYERROR_VERBOSE || 0
607/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
608   First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
609static const char *const yytname[] =
610{
611  "$end", "error", "$undefined", "JACOBIAN", "DOUBLE", "FUNCTION",
612  "DEFVAR", "DEFRAD", "DEFFIX", "SETVAR", "SETRAD", "SETFIX", "HESSIAN",
613  "STOICMAT", "STOCHASTIC", "DECLARE", "INITVALUES", "EQUATIONS", "LUMP",
614  "INIEQUAL", "EQNEQUAL", "EQNCOLON", "LMPCOLON", "LMPPLUS", "SPCPLUS",
615  "SPCEQUAL", "ATOMDECL", "CHECK", "CHECKALL", "REORDER", "MEX",
616  "DUMMYINDEX", "EQNTAGS", "LOOKAT", "LOOKATALL", "TRANSPORT",
617  "TRANSPORTALL", "MONITOR", "USES", "SPARSEDATA", "WRITE_ATM",
618  "WRITE_SPC", "WRITE_MAT", "WRITE_OPT", "INITIALIZE", "XGRID", "YGRID",
619  "ZGRID", "USE", "LANGUAGE", "INTFILE", "DRIVER", "RUN", "INLINE",
620  "ENDINLINE", "PARAMETER", "SPCSPC", "INISPC", "INIVALUE", "EQNSPC",
621  "EQNSIGN", "EQNCOEF", "RATE", "LMPSPC", "SPCNR", "ATOMID", "LKTID",
622  "MNIID", "INLCTX", "INCODE", "SSPID", "EQNLESS", "EQNTAG", "EQNGREATER",
623  "TPTID", "USEID", "';'", "$accept", "program", "section", "semicolon",
624  "atomlist", "atomdef", "lookatlist", "lookatspc", "monitorlist",
625  "monitorspc", "translist", "transspc", "uselist", "usefile",
626  "setspclist", "setspcspc", "species", "spc", "spcname", "spcdef",
627  "atoms", "atom", "initvalues", "assignment", "equations", "equation",
628  "rate", "eqntag", "lefths", "righths", "expresion", "term", "lumps",
629  "lump", "inlinecode", YY_NULL
630};
631#endif
632
633# ifdef YYPRINT
634/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
635   token YYLEX-NUM.  */
636static const yytype_uint16 yytoknum[] =
637{
638       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
639     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
640     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
641     285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
642     295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
643     305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
644     315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
645     325,   326,   327,   328,   329,   330,    59
646};
647# endif
648
649/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
650static const yytype_uint8 yyr1[] =
651{
652       0,    77,    78,    78,    79,    79,    79,    79,    79,    79,
653      79,    79,    79,    79,    79,    79,    79,    79,    79,    79,
654      79,    79,    79,    79,    79,    79,    79,    79,    79,    79,
655      79,    79,    79,    79,    79,    79,    79,    79,    79,    79,
656      79,    79,    79,    79,    79,    79,    79,    79,    79,    80,
657      80,    81,    81,    81,    82,    83,    83,    83,    84,    85,
658      85,    85,    86,    87,    87,    87,    88,    89,    89,    89,
659      90,    91,    91,    91,    92,    93,    93,    93,    94,    94,
660      95,    96,    97,    97,    98,    98,    99,    99,    99,   100,
661     101,   101,   101,   102,   102,   103,   103,   104,   105,   106,
662     107,   107,   107,   108,   108,   109,   109,   109,   110,   110,
663     111,   111
664};
665
666/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
667static const yytype_uint8 yyr2[] =
668{
669       0,     2,     1,     2,     2,     2,     2,     2,     2,     2,
670       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
671       2,     2,     2,     2,     2,     2,     2,     2,     2,     1,
672       1,     1,     1,     1,     1,     1,     2,     2,     2,     2,
673       2,     2,     4,     2,     2,     2,     2,     2,     2,     2,
674       1,     3,     2,     2,     1,     3,     2,     2,     1,     3,
675       2,     2,     1,     3,     2,     2,     1,     3,     2,     2,
676       1,     3,     2,     2,     1,     3,     2,     2,     1,     1,
677       3,     1,     3,     1,     2,     1,     3,     2,     2,     3,
678       3,     2,     2,     4,     3,     2,     1,     3,     2,     2,
679       3,     2,     1,     2,     1,     3,     2,     2,     3,     3,
680       2,     1
681};
682
683/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
684   Performed when YYTABLE doesn't specify something else to do.  Zero
685   means the default is an error.  */
686static const yytype_uint8 yydefact[] =
687{
688       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
689       0,     0,     0,     0,     0,     0,     0,     0,     0,    29,
690       0,     0,     0,     0,     0,    30,     0,    31,     0,     0,
691       0,    32,    33,    34,    35,     0,     0,     0,     0,     0,
692       0,     0,     0,     0,     0,     0,     2,     4,     8,    13,
693       0,    81,    17,     0,    78,    79,    18,    19,     0,    74,
694      20,     0,    21,    22,     5,     7,    14,     6,     0,     0,
695      23,     0,     0,   104,     0,     0,     0,    24,     0,     0,
696       0,     0,   102,     0,     0,    25,     0,     0,    54,    15,
697       0,    16,     9,    10,    11,    12,     0,    58,    26,     0,
698       0,    66,    28,     0,     0,    62,    27,     0,     0,    70,
699      47,     0,    48,    38,    39,    40,    41,    36,    37,    44,
700      45,    46,    43,     0,     1,     3,    50,    77,     0,     0,
701      76,    73,     0,    72,    88,     0,     0,    87,    92,   101,
702     103,     0,     0,    91,     0,     0,     0,    98,     0,   107,
703       0,     0,     0,   106,    53,     0,    52,    57,     0,    56,
704      65,     0,    64,    61,     0,    60,    69,     0,    68,   111,
705       0,    49,    85,     0,    80,    83,    75,    71,    89,    86,
706      97,    90,     0,    96,    94,    99,   100,   109,   108,   105,
707      51,    55,    63,    59,    67,    42,   110,    84,     0,    93,
708      95,    82
709};
710
711/* YYDEFGOTO[NTERM-NUM].  */
712static const yytype_int16 yydefgoto[] =
713{
714      -1,    45,    46,   127,    89,    90,    98,    99,   106,   107,
715     102,   103,   110,   111,    60,    61,    52,    53,    54,    55,
716     174,   175,    70,    71,    77,    78,   184,    79,    80,   145,
717      81,    82,    85,    86,   170
718};
719
720/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
721   STATE-NUM.  */
722#define YYPACT_NINF -91
723static const yytype_int16 yypact[] =
724{
725     112,    -6,    -3,     4,    11,    11,    11,     3,     3,     3,
726      30,    33,    39,    40,     8,     1,    21,     9,     9,   -91,
727      41,    42,    43,    45,     5,   -91,     6,   -91,    15,     0,
728      46,   -91,   -91,   -91,   -91,    48,    49,    51,    52,    54,
729      55,    57,    58,    76,    10,    63,   112,   -91,   -91,   -91,
730      56,   108,    14,    56,   -91,   -91,    14,    14,    56,   -91,
731      64,    56,    64,    64,   -91,   -91,   -91,   -91,    56,   116,
732      79,    56,    56,   -91,   -38,    78,    94,   -33,    56,   -20,
733     -20,    -7,   -91,    56,    34,   104,    56,    56,   -91,   103,
734      56,   103,   -91,   -91,   -91,   -91,    56,   -91,   105,    56,
735      56,   -91,    95,    56,    56,   -91,   106,    56,    56,   -91,
736      97,    56,   -91,   -91,   -91,   -91,   -91,   -91,   -91,   -91,
737     -91,   -91,   -91,   101,   -91,   -91,   -91,    98,   -32,    56,
738      98,    98,    56,    98,    98,   117,    56,    98,    98,   -91,
739     -91,   107,    56,    98,   -20,   114,    27,   -91,   -38,    98,
740     115,   104,    56,    98,    98,    56,    98,    98,    56,    98,
741      98,    56,    98,    98,    56,    98,    98,    56,    98,   -91,
742     -40,   -91,   -91,   121,   155,   -91,    98,    98,   -91,    98,
743     -91,    98,   114,   114,   -91,   -91,   -91,   -91,   -91,    98,
744      98,    98,    98,    98,    98,   -91,   -91,   -91,   -32,   -91,
745     -91,   -91
746};
747
748/* YYPGOTO[NTERM-NUM].  */
749static const yytype_int16 yypgoto[] =
750{
751     -91,   135,   -91,   -53,   164,   -25,   -91,    86,   -91,    77,
752     -91,    83,   -91,    80,    60,   -18,    85,   -21,   -91,   -91,
753     -91,   -12,   -91,   118,   -91,   110,   -90,   -91,   113,    47,
754     -63,   -71,   -91,   -65,   -91
755};
756
757/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
758   positive, shift that token.  If negative, reduce the rule which
759   number is the opposite.  If YYTABLE_NINF, syntax error.  */
760#define YYTABLE_NINF -1
761static const yytype_uint8 yytable[] =
762{
763     130,   108,    72,   139,    58,   131,    96,   100,   133,    68,
764      87,   122,    50,   147,   195,   134,   104,   146,   137,   138,
765     152,    73,    83,    75,   172,   143,    73,    74,    75,   196,
766     149,   129,   173,   153,   154,   129,   129,   156,    76,    73,
767      74,    75,   132,   157,   132,   132,   159,   160,   185,    47,
768     162,   163,    48,   148,   165,   166,   150,   151,   168,    49,
769      73,    74,    75,   124,   155,    69,   155,    51,    62,    63,
770      51,    97,    76,    59,    88,   109,   176,   186,   123,   177,
771     101,   146,   105,   179,    84,    64,   188,   148,    65,   181,
772      56,    57,   199,   200,    66,    67,    92,    93,    94,   189,
773      95,   112,   190,   113,   114,   191,   115,   116,   192,   117,
774     118,   193,   119,   120,   194,     1,     2,     3,     4,     5,
775       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
776      16,   121,   126,   128,    59,   135,    69,   140,    17,    18,
777      19,    20,    21,    22,    23,    24,    25,    26,    27,    28,
778      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
779      39,    40,    41,    42,    43,    44,   141,    84,    88,   101,
780     169,    97,   109,   105,   171,   178,   183,   197,   187,   198,
781     180,   125,    91,   164,   158,   161,   201,   142,   136,     0,
782     167,   182,   144
783};
784
785#define yypact_value_is_default(Yystate) \
786  (!!((Yystate) == (-91)))
787
788#define yytable_value_is_error(Yytable_value) \
789  YYID (0)
790
791static const yytype_int16 yycheck[] =
792{
793      53,     1,     1,    74,     1,    58,     1,     1,    61,     1,
794       1,     1,     1,    20,    54,    68,     1,    80,    71,    72,
795      85,    59,     1,    61,    56,    78,    59,    60,    61,    69,
796      83,    52,    64,    86,    87,    56,    57,    90,    71,    59,
797      60,    61,    60,    96,    62,    63,    99,   100,    21,    55,
798     103,   104,    55,    60,   107,   108,    22,    23,   111,    55,
799      59,    60,    61,     0,    89,    57,    91,    56,     8,     9,
800      56,    66,    71,    70,    65,    75,   129,   148,    68,   132,
801      74,   144,    67,   136,    63,    55,   151,    60,    55,   142,
802       5,     6,   182,   183,    55,    55,    55,    55,    55,   152,
803      55,    55,   155,    55,    55,   158,    55,    55,   161,    55,
804      55,   164,    55,    55,   167,     3,     4,     5,     6,     7,
805       8,     9,    10,    11,    12,    13,    14,    15,    16,    17,
806      18,    55,    76,    25,    70,    19,    57,    59,    26,    27,
807      28,    29,    30,    31,    32,    33,    34,    35,    36,    37,
808      38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
809      48,    49,    50,    51,    52,    53,    72,    63,    65,    74,
810      69,    66,    75,    67,    76,    58,    62,    56,    63,    24,
811      73,    46,    18,   106,    98,   102,   198,    77,    70,    -1,
812     110,   144,    79
813};
814
815/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
816   symbol of state STATE-NUM.  */
817static const yytype_uint8 yystos[] =
818{
819       0,     3,     4,     5,     6,     7,     8,     9,    10,    11,
820      12,    13,    14,    15,    16,    17,    18,    26,    27,    28,
821      29,    30,    31,    32,    33,    34,    35,    36,    37,    38,
822      39,    40,    41,    42,    43,    44,    45,    46,    47,    48,
823      49,    50,    51,    52,    53,    78,    79,    55,    55,    55,
824       1,    56,    93,    94,    95,    96,    93,    93,     1,    70,
825      91,    92,    91,    91,    55,    55,    55,    55,     1,    57,
826      99,   100,     1,    59,    60,    61,    71,   101,   102,   104,
827     105,   107,   108,     1,    63,   109,   110,     1,    65,    81,
828      82,    81,    55,    55,    55,    55,     1,    66,    83,    84,
829       1,    74,    87,    88,     1,    67,    85,    86,     1,    75,
830      89,    90,    55,    55,    55,    55,    55,    55,    55,    55,
831      55,    55,     1,    68,     0,    78,    76,    80,    25,    94,
832      80,    80,    92,    80,    80,    19,   100,    80,    80,   108,
833      59,    72,   102,    80,   105,   106,   107,    20,    60,    80,
834      22,    23,   110,    80,    80,    82,    80,    80,    84,    80,
835      80,    88,    80,    80,    86,    80,    80,    90,    80,    69,
836     111,    76,    56,    64,    97,    98,    80,    80,    58,    80,
837      73,    80,   106,    62,   103,    21,   108,    63,   110,    80,
838      80,    80,    80,    80,    80,    54,    69,    56,    24,   103,
839     103,    98
840};
841
842#define yyerrok         (yyerrstatus = 0)
843#define yyclearin       (yychar = YYEMPTY)
844#define YYEMPTY         (-2)
845#define YYEOF           0
846
847#define YYACCEPT        goto yyacceptlab
848#define YYABORT         goto yyabortlab
849#define YYERROR         goto yyerrorlab
850
851
852/* Like YYERROR except do call yyerror.  This remains here temporarily
853   to ease the transition to the new meaning of YYERROR, for GCC.
854   Once GCC version 2 has supplanted version 1, this can go.  However,
855   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
856   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
857   discussed.  */
858
859#define YYFAIL          goto yyerrlab
860#if defined YYFAIL
861  /* This is here to suppress warnings from the GCC cpp's
862     -Wunused-macros.  Normally we don't worry about that warning, but
863     some users do, and we want to make it easy for users to remove
864     YYFAIL uses, which will produce warnings from Bison 2.5.  */
865#endif
866
867#define YYRECOVERING()  (!!yyerrstatus)
868
869#define YYBACKUP(Token, Value)                                  \
870do                                                              \
871  if (yychar == YYEMPTY)                                        \
872    {                                                           \
873      yychar = (Token);                                         \
874      yylval = (Value);                                         \
875      YYPOPSTACK (yylen);                                       \
876      yystate = *yyssp;                                         \
877      goto yybackup;                                            \
878    }                                                           \
879  else                                                          \
880    {                                                           \
881      yyerror (YY_("syntax error: cannot back up")); \
882      YYERROR;                                                  \
883    }                                                           \
884while (YYID (0))
885
886/* Error token number */
887#define YYTERROR        1
888#define YYERRCODE       256
889
890
891/* This macro is provided for backward compatibility. */
892#ifndef YY_LOCATION_PRINT
893# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
894#endif
895
896
897/* YYLEX -- calling `yylex' with the right arguments.  */
898#ifdef YYLEX_PARAM
899# define YYLEX yylex (YYLEX_PARAM)
900#else
901# define YYLEX yylex ()
902#endif
903
904/* Enable debugging if requested.  */
905#if YYDEBUG
906
907# ifndef YYFPRINTF
908#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
909#  define YYFPRINTF fprintf
910# endif
911
912# define YYDPRINTF(Args)                        \
913do {                                            \
914  if (yydebug)                                  \
915    YYFPRINTF Args;                             \
916} while (YYID (0))
917
918# define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
919do {                                                                      \
920  if (yydebug)                                                            \
921    {                                                                     \
922      YYFPRINTF (stderr, "%s ", Title);                                   \
923      yy_symbol_print (stderr,                                            \
924                  Type, Value); \
925      YYFPRINTF (stderr, "\n");                                           \
926    }                                                                     \
927} while (YYID (0))
928
929
930/*--------------------------------.
931| Print this symbol on YYOUTPUT.  |
932`--------------------------------*/
933
934/*ARGSUSED*/
935#if (defined __STDC__ || defined __C99__FUNC__ \
936     || defined __cplusplus || defined _MSC_VER)
937static void
938yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
939#else
940static void
941yy_symbol_value_print (yyoutput, yytype, yyvaluep)
942    FILE *yyoutput;
943    int yytype;
944    YYSTYPE const * const yyvaluep;
945#endif
946{
947  FILE *yyo = yyoutput;
948  YYUSE (yyo);
949  if (!yyvaluep)
950    return;
951# ifdef YYPRINT
952  if (yytype < YYNTOKENS)
953    YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
954# else
955  YYUSE (yyoutput);
956# endif
957  switch (yytype)
958    {
959      default:
960        break;
961    }
962}
963
964
965/*--------------------------------.
966| Print this symbol on YYOUTPUT.  |
967`--------------------------------*/
968
969#if (defined __STDC__ || defined __C99__FUNC__ \
970     || defined __cplusplus || defined _MSC_VER)
971static void
972yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
973#else
974static void
975yy_symbol_print (yyoutput, yytype, yyvaluep)
976    FILE *yyoutput;
977    int yytype;
978    YYSTYPE const * const yyvaluep;
979#endif
980{
981  if (yytype < YYNTOKENS)
982    YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
983  else
984    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
985
986  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
987  YYFPRINTF (yyoutput, ")");
988}
989
990/*------------------------------------------------------------------.
991| yy_stack_print -- Print the state stack from its BOTTOM up to its |
992| TOP (included).                                                   |
993`------------------------------------------------------------------*/
994
995#if (defined __STDC__ || defined __C99__FUNC__ \
996     || defined __cplusplus || defined _MSC_VER)
997static void
998yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
999#else
1000static void
1001yy_stack_print (yybottom, yytop)
1002    yytype_int16 *yybottom;
1003    yytype_int16 *yytop;
1004#endif
1005{
1006  YYFPRINTF (stderr, "Stack now");
1007  for (; yybottom <= yytop; yybottom++)
1008    {
1009      int yybot = *yybottom;
1010      YYFPRINTF (stderr, " %d", yybot);
1011    }
1012  YYFPRINTF (stderr, "\n");
1013}
1014
1015# define YY_STACK_PRINT(Bottom, Top)                            \
1016do {                                                            \
1017  if (yydebug)                                                  \
1018    yy_stack_print ((Bottom), (Top));                           \
1019} while (YYID (0))
1020
1021
1022/*------------------------------------------------.
1023| Report that the YYRULE is going to be reduced.  |
1024`------------------------------------------------*/
1025
1026#if (defined __STDC__ || defined __C99__FUNC__ \
1027     || defined __cplusplus || defined _MSC_VER)
1028static void
1029yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1030#else
1031static void
1032yy_reduce_print (yyvsp, yyrule)
1033    YYSTYPE *yyvsp;
1034    int yyrule;
1035#endif
1036{
1037  int yynrhs = yyr2[yyrule];
1038  int yyi;
1039  unsigned long int yylno = yyrline[yyrule];
1040  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1041             yyrule - 1, yylno);
1042  /* The symbols being reduced.  */
1043  for (yyi = 0; yyi < yynrhs; yyi++)
1044    {
1045      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1046      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1047                       &(yyvsp[(yyi + 1) - (yynrhs)])
1048                                       );
1049      YYFPRINTF (stderr, "\n");
1050    }
1051}
1052
1053# define YY_REDUCE_PRINT(Rule)          \
1054do {                                    \
1055  if (yydebug)                          \
1056    yy_reduce_print (yyvsp, Rule); \
1057} while (YYID (0))
1058
1059/* Nonzero means print parse trace.  It is left uninitialized so that
1060   multiple parsers can coexist.  */
1061int yydebug;
1062#else /* !YYDEBUG */
1063# define YYDPRINTF(Args)
1064# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1065# define YY_STACK_PRINT(Bottom, Top)
1066# define YY_REDUCE_PRINT(Rule)
1067#endif /* !YYDEBUG */
1068
1069
1070/* YYINITDEPTH -- initial size of the parser's stacks.  */
1071#ifndef YYINITDEPTH
1072# define YYINITDEPTH 200
1073#endif
1074
1075/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1076   if the built-in stack extension method is used).
1077
1078   Do not make this value too large; the results are undefined if
1079   YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1080   evaluated with infinite-precision integer arithmetic.  */
1081
1082#ifndef YYMAXDEPTH
1083# define YYMAXDEPTH 10000
1084#endif
1085
1086
1087#if YYERROR_VERBOSE
1088
1089# ifndef yystrlen
1090#  if defined __GLIBC__ && defined _STRING_H
1091#   define yystrlen strlen
1092#  else
1093/* Return the length of YYSTR.  */
1094#if (defined __STDC__ || defined __C99__FUNC__ \
1095     || defined __cplusplus || defined _MSC_VER)
1096static YYSIZE_T
1097yystrlen (const char *yystr)
1098#else
1099static YYSIZE_T
1100yystrlen (yystr)
1101    const char *yystr;
1102#endif
1103{
1104  YYSIZE_T yylen;
1105  for (yylen = 0; yystr[yylen]; yylen++)
1106    continue;
1107  return yylen;
1108}
1109#  endif
1110# endif
1111
1112# ifndef yystpcpy
1113#  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1114#   define yystpcpy stpcpy
1115#  else
1116/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1117   YYDEST.  */
1118#if (defined __STDC__ || defined __C99__FUNC__ \
1119     || defined __cplusplus || defined _MSC_VER)
1120static char *
1121yystpcpy (char *yydest, const char *yysrc)
1122#else
1123static char *
1124yystpcpy (yydest, yysrc)
1125    char *yydest;
1126    const char *yysrc;
1127#endif
1128{
1129  char *yyd = yydest;
1130  const char *yys = yysrc;
1131
1132  while ((*yyd++ = *yys++) != '\0')
1133    continue;
1134
1135  return yyd - 1;
1136}
1137#  endif
1138# endif
1139
1140# ifndef yytnamerr
1141/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1142   quotes and backslashes, so that it's suitable for yyerror.  The
1143   heuristic is that double-quoting is unnecessary unless the string
1144   contains an apostrophe, a comma, or backslash (other than
1145   backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1146   null, do not copy; instead, return the length of what the result
1147   would have been.  */
1148static YYSIZE_T
1149yytnamerr (char *yyres, const char *yystr)
1150{
1151  if (*yystr == '"')
1152    {
1153      YYSIZE_T yyn = 0;
1154      char const *yyp = yystr;
1155
1156      for (;;)
1157        switch (*++yyp)
1158          {
1159          case '\'':
1160          case ',':
1161            goto do_not_strip_quotes;
1162
1163          case '\\':
1164            if (*++yyp != '\\')
1165              goto do_not_strip_quotes;
1166            /* Fall through.  */
1167          default:
1168            if (yyres)
1169              yyres[yyn] = *yyp;
1170            yyn++;
1171            break;
1172
1173          case '"':
1174            if (yyres)
1175              yyres[yyn] = '\0';
1176            return yyn;
1177          }
1178    do_not_strip_quotes: ;
1179    }
1180
1181  if (! yyres)
1182    return yystrlen (yystr);
1183
1184  return yystpcpy (yyres, yystr) - yyres;
1185}
1186# endif
1187
1188/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1189   about the unexpected token YYTOKEN for the state stack whose top is
1190   YYSSP.
1191
1192   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
1193   not large enough to hold the message.  In that case, also set
1194   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
1195   required number of bytes is too large to store.  */
1196static int
1197yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1198                yytype_int16 *yyssp, int yytoken)
1199{
1200  YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
1201  YYSIZE_T yysize = yysize0;
1202  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1203  /* Internationalized format string. */
1204  const char *yyformat = YY_NULL;
1205  /* Arguments of yyformat. */
1206  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1207  /* Number of reported tokens (one for the "unexpected", one per
1208     "expected"). */
1209  int yycount = 0;
1210
1211  /* There are many possibilities here to consider:
1212     - Assume YYFAIL is not used.  It's too flawed to consider.  See
1213       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1214       for details.  YYERROR is fine as it does not invoke this
1215       function.
1216     - If this state is a consistent state with a default action, then
1217       the only way this function was invoked is if the default action
1218       is an error action.  In that case, don't check for expected
1219       tokens because there are none.
1220     - The only way there can be no lookahead present (in yychar) is if
1221       this state is a consistent state with a default action.  Thus,
1222       detecting the absence of a lookahead is sufficient to determine
1223       that there is no unexpected or expected token to report.  In that
1224       case, just report a simple "syntax error".
1225     - Don't assume there isn't a lookahead just because this state is a
1226       consistent state with a default action.  There might have been a
1227       previous inconsistent state, consistent state with a non-default
1228       action, or user semantic action that manipulated yychar.
1229     - Of course, the expected token list depends on states to have
1230       correct lookahead information, and it depends on the parser not
1231       to perform extra reductions after fetching a lookahead from the
1232       scanner and before detecting a syntax error.  Thus, state merging
1233       (from LALR or IELR) and default reductions corrupt the expected
1234       token list.  However, the list is correct for canonical LR with
1235       one exception: it will still contain any token that will not be
1236       accepted due to an error action in a later state.
1237  */
1238  if (yytoken != YYEMPTY)
1239    {
1240      int yyn = yypact[*yyssp];
1241      yyarg[yycount++] = yytname[yytoken];
1242      if (!yypact_value_is_default (yyn))
1243        {
1244          /* Start YYX at -YYN if negative to avoid negative indexes in
1245             YYCHECK.  In other words, skip the first -YYN actions for
1246             this state because they are default actions.  */
1247          int yyxbegin = yyn < 0 ? -yyn : 0;
1248          /* Stay within bounds of both yycheck and yytname.  */
1249          int yychecklim = YYLAST - yyn + 1;
1250          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1251          int yyx;
1252
1253          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1254            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1255                && !yytable_value_is_error (yytable[yyx + yyn]))
1256              {
1257                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1258                  {
1259                    yycount = 1;
1260                    yysize = yysize0;
1261                    break;
1262                  }
1263                yyarg[yycount++] = yytname[yyx];
1264                {
1265                  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
1266                  if (! (yysize <= yysize1
1267                         && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1268                    return 2;
1269                  yysize = yysize1;
1270                }
1271              }
1272        }
1273    }
1274
1275  switch (yycount)
1276    {
1277# define YYCASE_(N, S)                      \
1278      case N:                               \
1279        yyformat = S;                       \
1280      break
1281      YYCASE_(0, YY_("syntax error"));
1282      YYCASE_(1, YY_("syntax error, unexpected %s"));
1283      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1284      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1285      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1286      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1287# undef YYCASE_
1288    }
1289
1290  {
1291    YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1292    if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1293      return 2;
1294    yysize = yysize1;
1295  }
1296
1297  if (*yymsg_alloc < yysize)
1298    {
1299      *yymsg_alloc = 2 * yysize;
1300      if (! (yysize <= *yymsg_alloc
1301             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1302        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1303      return 1;
1304    }
1305
1306  /* Avoid sprintf, as that infringes on the user's name space.
1307     Don't have undefined behavior even if the translation
1308     produced a string with the wrong number of "%s"s.  */
1309  {
1310    char *yyp = *yymsg;
1311    int yyi = 0;
1312    while ((*yyp = *yyformat) != '\0')
1313      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1314        {
1315          yyp += yytnamerr (yyp, yyarg[yyi++]);
1316          yyformat += 2;
1317        }
1318      else
1319        {
1320          yyp++;
1321          yyformat++;
1322        }
1323  }
1324  return 0;
1325}
1326#endif /* YYERROR_VERBOSE */
1327
1328/*-----------------------------------------------.
1329| Release the memory associated to this symbol.  |
1330`-----------------------------------------------*/
1331
1332/*ARGSUSED*/
1333#if (defined __STDC__ || defined __C99__FUNC__ \
1334     || defined __cplusplus || defined _MSC_VER)
1335static void
1336yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1337#else
1338static void
1339yydestruct (yymsg, yytype, yyvaluep)
1340    const char *yymsg;
1341    int yytype;
1342    YYSTYPE *yyvaluep;
1343#endif
1344{
1345  YYUSE (yyvaluep);
1346
1347  if (!yymsg)
1348    yymsg = "Deleting";
1349  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1350
1351  switch (yytype)
1352    {
1353
1354      default:
1355        break;
1356    }
1357}
1358
1359
1360
1361
1362/* The lookahead symbol.  */
1363int yychar;
1364
1365
1366#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1367# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1368# define YY_IGNORE_MAYBE_UNINITIALIZED_END
1369#endif
1370#ifndef YY_INITIAL_VALUE
1371# define YY_INITIAL_VALUE(Value) /* Nothing. */
1372#endif
1373
1374/* The semantic value of the lookahead symbol.  */
1375YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
1376
1377/* Number of syntax errors so far.  */
1378int yynerrs;
1379
1380
1381/*----------.
1382| yyparse.  |
1383`----------*/
1384
1385#ifdef YYPARSE_PARAM
1386#if (defined __STDC__ || defined __C99__FUNC__ \
1387     || defined __cplusplus || defined _MSC_VER)
1388int
1389yyparse (void *YYPARSE_PARAM)
1390#else
1391int
1392yyparse (YYPARSE_PARAM)
1393    void *YYPARSE_PARAM;
1394#endif
1395#else /* ! YYPARSE_PARAM */
1396#if (defined __STDC__ || defined __C99__FUNC__ \
1397     || defined __cplusplus || defined _MSC_VER)
1398int
1399yyparse (void)
1400#else
1401int
1402yyparse ()
1403
1404#endif
1405#endif
1406{
1407    int yystate;
1408    /* Number of tokens to shift before error messages enabled.  */
1409    int yyerrstatus;
1410
1411    /* The stacks and their tools:
1412       `yyss': related to states.
1413       `yyvs': related to semantic values.
1414
1415       Refer to the stacks through separate pointers, to allow yyoverflow
1416       to reallocate them elsewhere.  */
1417
1418    /* The state stack.  */
1419    yytype_int16 yyssa[YYINITDEPTH];
1420    yytype_int16 *yyss;
1421    yytype_int16 *yyssp;
1422
1423    /* The semantic value stack.  */
1424    YYSTYPE yyvsa[YYINITDEPTH];
1425    YYSTYPE *yyvs;
1426    YYSTYPE *yyvsp;
1427
1428    YYSIZE_T yystacksize;
1429
1430  int yyn;
1431  int yyresult;
1432  /* Lookahead token as an internal (translated) token number.  */
1433  int yytoken = 0;
1434  /* The variables used to return semantic value and location from the
1435     action routines.  */
1436  YYSTYPE yyval;
1437
1438#if YYERROR_VERBOSE
1439  /* Buffer for error messages, and its allocated size.  */
1440  char yymsgbuf[128];
1441  char *yymsg = yymsgbuf;
1442  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1443#endif
1444
1445#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1446
1447  /* The number of symbols on the RHS of the reduced rule.
1448     Keep to zero when no symbol should be popped.  */
1449  int yylen = 0;
1450
1451  yyssp = yyss = yyssa;
1452  yyvsp = yyvs = yyvsa;
1453  yystacksize = YYINITDEPTH;
1454
1455  YYDPRINTF ((stderr, "Starting parse\n"));
1456
1457  yystate = 0;
1458  yyerrstatus = 0;
1459  yynerrs = 0;
1460  yychar = YYEMPTY; /* Cause a token to be read.  */
1461  goto yysetstate;
1462
1463/*------------------------------------------------------------.
1464| yynewstate -- Push a new state, which is found in yystate.  |
1465`------------------------------------------------------------*/
1466 yynewstate:
1467  /* In all cases, when you get here, the value and location stacks
1468     have just been pushed.  So pushing a state here evens the stacks.  */
1469  yyssp++;
1470
1471 yysetstate:
1472  *yyssp = yystate;
1473
1474  if (yyss + yystacksize - 1 <= yyssp)
1475    {
1476      /* Get the current used size of the three stacks, in elements.  */
1477      YYSIZE_T yysize = yyssp - yyss + 1;
1478
1479#ifdef yyoverflow
1480      {
1481        /* Give user a chance to reallocate the stack.  Use copies of
1482           these so that the &'s don't force the real ones into
1483           memory.  */
1484        YYSTYPE *yyvs1 = yyvs;
1485        yytype_int16 *yyss1 = yyss;
1486
1487        /* Each stack pointer address is followed by the size of the
1488           data in use in that stack, in bytes.  This used to be a
1489           conditional around just the two extra args, but that might
1490           be undefined if yyoverflow is a macro.  */
1491        yyoverflow (YY_("memory exhausted"),
1492                    &yyss1, yysize * sizeof (*yyssp),
1493                    &yyvs1, yysize * sizeof (*yyvsp),
1494                    &yystacksize);
1495
1496        yyss = yyss1;
1497        yyvs = yyvs1;
1498      }
1499#else /* no yyoverflow */
1500# ifndef YYSTACK_RELOCATE
1501      goto yyexhaustedlab;
1502# else
1503      /* Extend the stack our own way.  */
1504      if (YYMAXDEPTH <= yystacksize)
1505        goto yyexhaustedlab;
1506      yystacksize *= 2;
1507      if (YYMAXDEPTH < yystacksize)
1508        yystacksize = YYMAXDEPTH;
1509
1510      {
1511        yytype_int16 *yyss1 = yyss;
1512        union yyalloc *yyptr =
1513          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1514        if (! yyptr)
1515          goto yyexhaustedlab;
1516        YYSTACK_RELOCATE (yyss_alloc, yyss);
1517        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1518#  undef YYSTACK_RELOCATE
1519        if (yyss1 != yyssa)
1520          YYSTACK_FREE (yyss1);
1521      }
1522# endif
1523#endif /* no yyoverflow */
1524
1525      yyssp = yyss + yysize - 1;
1526      yyvsp = yyvs + yysize - 1;
1527
1528      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1529                  (unsigned long int) yystacksize));
1530
1531      if (yyss + yystacksize - 1 <= yyssp)
1532        YYABORT;
1533    }
1534
1535  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1536
1537  if (yystate == YYFINAL)
1538    YYACCEPT;
1539
1540  goto yybackup;
1541
1542/*-----------.
1543| yybackup.  |
1544`-----------*/
1545yybackup:
1546
1547  /* Do appropriate processing given the current state.  Read a
1548     lookahead token if we need one and don't already have one.  */
1549
1550  /* First try to decide what to do without reference to lookahead token.  */
1551  yyn = yypact[yystate];
1552  if (yypact_value_is_default (yyn))
1553    goto yydefault;
1554
1555  /* Not known => get a lookahead token if don't already have one.  */
1556
1557  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1558  if (yychar == YYEMPTY)
1559    {
1560      YYDPRINTF ((stderr, "Reading a token: "));
1561      yychar = YYLEX;
1562    }
1563
1564  if (yychar <= YYEOF)
1565    {
1566      yychar = yytoken = YYEOF;
1567      YYDPRINTF ((stderr, "Now at end of input.\n"));
1568    }
1569  else
1570    {
1571      yytoken = YYTRANSLATE (yychar);
1572      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1573    }
1574
1575  /* If the proper action on seeing token YYTOKEN is to reduce or to
1576     detect an error, take that action.  */
1577  yyn += yytoken;
1578  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1579    goto yydefault;
1580  yyn = yytable[yyn];
1581  if (yyn <= 0)
1582    {
1583      if (yytable_value_is_error (yyn))
1584        goto yyerrlab;
1585      yyn = -yyn;
1586      goto yyreduce;
1587    }
1588
1589  /* Count tokens shifted since error; after three, turn off error
1590     status.  */
1591  if (yyerrstatus)
1592    yyerrstatus--;
1593
1594  /* Shift the lookahead token.  */
1595  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1596
1597  /* Discard the shifted token.  */
1598  yychar = YYEMPTY;
1599
1600  yystate = yyn;
1601  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1602  *++yyvsp = yylval;
1603  YY_IGNORE_MAYBE_UNINITIALIZED_END
1604
1605  goto yynewstate;
1606
1607
1608/*-----------------------------------------------------------.
1609| yydefault -- do the default action for the current state.  |
1610`-----------------------------------------------------------*/
1611yydefault:
1612  yyn = yydefact[yystate];
1613  if (yyn == 0)
1614    goto yyerrlab;
1615  goto yyreduce;
1616
1617
1618/*-----------------------------.
1619| yyreduce -- Do a reduction.  |
1620`-----------------------------*/
1621yyreduce:
1622  /* yyn is the number of a rule to reduce with.  */
1623  yylen = yyr2[yyn];
1624
1625  /* If YYLEN is nonzero, implement the default value of the action:
1626     `$$ = $1'.
1627
1628     Otherwise, the following line sets YYVAL to garbage.
1629     This behavior is undocumented and Bison
1630     users should not rely upon it.  Assigning to YYVAL
1631     unconditionally makes the parser a bit smaller, and it avoids a
1632     GCC warning that YYVAL may be used uninitialized.  */
1633  yyval = yyvsp[1-yylen];
1634
1635
1636  YY_REDUCE_PRINT (yyn);
1637  switch (yyn)
1638    {
1639        case 4:
1640/* Line 1792 of yacc.c  */
1641#line 100 "scan.y"
1642    { CmdJacobian( (yyvsp[(2) - (2)].str) );
1643                  }
1644    break;
1645
1646  case 5:
1647/* Line 1792 of yacc.c  */
1648#line 103 "scan.y"
1649    { CmdHessian( (yyvsp[(2) - (2)].str) );
1650                  }
1651    break;
1652
1653  case 6:
1654/* Line 1792 of yacc.c  */
1655#line 106 "scan.y"
1656    { CmdDeclareValues( (yyvsp[(2) - (2)].str) );
1657                  }
1658    break;
1659
1660  case 7:
1661/* Line 1792 of yacc.c  */
1662#line 109 "scan.y"
1663    { CmdStoicmat( (yyvsp[(2) - (2)].str) );
1664                  }
1665    break;
1666
1667  case 8:
1668/* Line 1792 of yacc.c  */
1669#line 112 "scan.y"
1670    { CmdDouble( (yyvsp[(2) - (2)].str) );
1671                  }
1672    break;
1673
1674  case 9:
1675/* Line 1792 of yacc.c  */
1676#line 115 "scan.y"
1677    { CmdReorder( (yyvsp[(2) - (2)].str) );
1678                  }
1679    break;
1680
1681  case 10:
1682/* Line 1792 of yacc.c  */
1683#line 118 "scan.y"
1684    { CmdMex( (yyvsp[(2) - (2)].str) );
1685                  }
1686    break;
1687
1688  case 11:
1689/* Line 1792 of yacc.c  */
1690#line 121 "scan.y"
1691    { CmdDummyindex( (yyvsp[(2) - (2)].str) );
1692                  }
1693    break;
1694
1695  case 12:
1696/* Line 1792 of yacc.c  */
1697#line 124 "scan.y"
1698    { CmdEqntags( (yyvsp[(2) - (2)].str) );
1699                  }
1700    break;
1701
1702  case 13:
1703/* Line 1792 of yacc.c  */
1704#line 127 "scan.y"
1705    { CmdFunction( (yyvsp[(2) - (2)].str) );
1706                  }
1707    break;
1708
1709  case 14:
1710/* Line 1792 of yacc.c  */
1711#line 130 "scan.y"
1712    { CmdStochastic( (yyvsp[(2) - (2)].str) );
1713                  }
1714    break;
1715
1716  case 15:
1717/* Line 1792 of yacc.c  */
1718#line 133 "scan.y"
1719    {}
1720    break;
1721
1722  case 16:
1723/* Line 1792 of yacc.c  */
1724#line 135 "scan.y"
1725    {}
1726    break;
1727
1728  case 17:
1729/* Line 1792 of yacc.c  */
1730#line 137 "scan.y"
1731    {}
1732    break;
1733
1734  case 18:
1735/* Line 1792 of yacc.c  */
1736#line 139 "scan.y"
1737    {}
1738    break;
1739
1740  case 19:
1741/* Line 1792 of yacc.c  */
1742#line 141 "scan.y"
1743    {}
1744    break;
1745
1746  case 20:
1747/* Line 1792 of yacc.c  */
1748#line 143 "scan.y"
1749    {}
1750    break;
1751
1752  case 21:
1753/* Line 1792 of yacc.c  */
1754#line 145 "scan.y"
1755    {}
1756    break;
1757
1758  case 22:
1759/* Line 1792 of yacc.c  */
1760#line 147 "scan.y"
1761    {}
1762    break;
1763
1764  case 23:
1765/* Line 1792 of yacc.c  */
1766#line 149 "scan.y"
1767    {}
1768    break;
1769
1770  case 24:
1771/* Line 1792 of yacc.c  */
1772#line 151 "scan.y"
1773    {}
1774    break;
1775
1776  case 25:
1777/* Line 1792 of yacc.c  */
1778#line 153 "scan.y"
1779    {}
1780    break;
1781
1782  case 26:
1783/* Line 1792 of yacc.c  */
1784#line 155 "scan.y"
1785    {}
1786    break;
1787
1788  case 27:
1789/* Line 1792 of yacc.c  */
1790#line 157 "scan.y"
1791    {}
1792    break;
1793
1794  case 28:
1795/* Line 1792 of yacc.c  */
1796#line 159 "scan.y"
1797    {}
1798    break;
1799
1800  case 29:
1801/* Line 1792 of yacc.c  */
1802#line 161 "scan.y"
1803    { CheckAll(); }
1804    break;
1805
1806  case 30:
1807/* Line 1792 of yacc.c  */
1808#line 163 "scan.y"
1809    { LookAtAll(); }
1810    break;
1811
1812  case 31:
1813/* Line 1792 of yacc.c  */
1814#line 165 "scan.y"
1815    { TransportAll(); }
1816    break;
1817
1818  case 32:
1819/* Line 1792 of yacc.c  */
1820#line 167 "scan.y"
1821    { WriteAtoms(); }
1822    break;
1823
1824  case 33:
1825/* Line 1792 of yacc.c  */
1826#line 169 "scan.y"
1827    { WriteSpecies(); }
1828    break;
1829
1830  case 34:
1831/* Line 1792 of yacc.c  */
1832#line 171 "scan.y"
1833    { WriteMatrices(); }
1834    break;
1835
1836  case 35:
1837/* Line 1792 of yacc.c  */
1838#line 173 "scan.y"
1839    { WriteOptions(); }
1840    break;
1841
1842  case 36:
1843/* Line 1792 of yacc.c  */
1844#line 175 "scan.y"
1845    { CmdUse( (yyvsp[(2) - (2)].str) ); }
1846    break;
1847
1848  case 37:
1849/* Line 1792 of yacc.c  */
1850#line 177 "scan.y"
1851    { CmdLanguage( (yyvsp[(2) - (2)].str) ); }
1852    break;
1853
1854  case 38:
1855/* Line 1792 of yacc.c  */
1856#line 179 "scan.y"
1857    { DefineInitializeNbr( (yyvsp[(2) - (2)].str) ); }
1858    break;
1859
1860  case 39:
1861/* Line 1792 of yacc.c  */
1862#line 181 "scan.y"
1863    { DefineXGrid( (yyvsp[(2) - (2)].str) ); }
1864    break;
1865
1866  case 40:
1867/* Line 1792 of yacc.c  */
1868#line 183 "scan.y"
1869    { DefineYGrid( (yyvsp[(2) - (2)].str) ); }
1870    break;
1871
1872  case 41:
1873/* Line 1792 of yacc.c  */
1874#line 185 "scan.y"
1875    { DefineZGrid( (yyvsp[(2) - (2)].str) ); }
1876    break;
1877
1878  case 42:
1879/* Line 1792 of yacc.c  */
1880#line 187 "scan.y"
1881    { 
1882                    AddInlineCode( (yyvsp[(2) - (4)].str), InlineBuf );
1883                    free( InlineBuf );
1884                  }
1885    break;
1886
1887  case 43:
1888/* Line 1792 of yacc.c  */
1889#line 192 "scan.y"
1890    { ParserErrorMessage(); }
1891    break;
1892
1893  case 44:
1894/* Line 1792 of yacc.c  */
1895#line 194 "scan.y"
1896    { CmdIntegrator( (yyvsp[(2) - (2)].str) ); }
1897    break;
1898
1899  case 45:
1900/* Line 1792 of yacc.c  */
1901#line 196 "scan.y"
1902    { CmdDriver( (yyvsp[(2) - (2)].str) ); }
1903    break;
1904
1905  case 46:
1906/* Line 1792 of yacc.c  */
1907#line 198 "scan.y"
1908    { CmdRun( (yyvsp[(2) - (2)].str) ); }
1909    break;
1910
1911  case 47:
1912/* Line 1792 of yacc.c  */
1913#line 200 "scan.y"
1914    {}
1915    break;
1916
1917  case 48:
1918/* Line 1792 of yacc.c  */
1919#line 202 "scan.y"
1920    { SparseData( (yyvsp[(2) - (2)].str) );
1921                  }
1922    break;
1923
1924  case 49:
1925/* Line 1792 of yacc.c  */
1926#line 206 "scan.y"
1927    { ScanWarning("Unnecessary ';'");
1928                  }
1929    break;
1930
1931  case 53:
1932/* Line 1792 of yacc.c  */
1933#line 213 "scan.y"
1934    { ParserErrorMessage(); }
1935    break;
1936
1937  case 54:
1938/* Line 1792 of yacc.c  */
1939#line 216 "scan.y"
1940    { switch( crt_section ) {
1941                      case ATOMDECL: DeclareAtom( (yyvsp[(1) - (1)].str) ); break;
1942                      case CHECK:    SetAtomType( (yyvsp[(1) - (1)].str), DO_CHECK ); break;
1943                    }
1944                  }
1945    break;
1946
1947  case 57:
1948/* Line 1792 of yacc.c  */
1949#line 225 "scan.y"
1950    { ParserErrorMessage(); }
1951    break;
1952
1953  case 58:
1954/* Line 1792 of yacc.c  */
1955#line 228 "scan.y"
1956    { AddLookAt( (yyvsp[(1) - (1)].str) );
1957                  }
1958    break;
1959
1960  case 61:
1961/* Line 1792 of yacc.c  */
1962#line 234 "scan.y"
1963    { ParserErrorMessage(); }
1964    break;
1965
1966  case 62:
1967/* Line 1792 of yacc.c  */
1968#line 237 "scan.y"
1969    { AddMonitor( (yyvsp[(1) - (1)].str) );
1970                  }
1971    break;
1972
1973  case 65:
1974/* Line 1792 of yacc.c  */
1975#line 243 "scan.y"
1976    { ParserErrorMessage(); }
1977    break;
1978
1979  case 66:
1980/* Line 1792 of yacc.c  */
1981#line 246 "scan.y"
1982    { AddTransport( (yyvsp[(1) - (1)].str) );
1983                  }
1984    break;
1985
1986  case 69:
1987/* Line 1792 of yacc.c  */
1988#line 252 "scan.y"
1989    { ParserErrorMessage(); }
1990    break;
1991
1992  case 70:
1993/* Line 1792 of yacc.c  */
1994#line 255 "scan.y"
1995    { AddUseFile( (yyvsp[(1) - (1)].str) );
1996                  }
1997    break;
1998
1999  case 73:
2000/* Line 1792 of yacc.c  */
2001#line 261 "scan.y"
2002    { ParserErrorMessage(); }
2003    break;
2004
2005  case 74:
2006/* Line 1792 of yacc.c  */
2007#line 264 "scan.y"
2008    { switch( crt_section ) {
2009                      case SETVAR: SetSpcType( VAR_SPC, (yyvsp[(1) - (1)].str) ); break;
2010                      case SETRAD: SetSpcType( RAD_SPC, (yyvsp[(1) - (1)].str) ); break;
2011                      case SETFIX: SetSpcType( FIX_SPC, (yyvsp[(1) - (1)].str) ); break;
2012                    }
2013                  }
2014    break;
2015
2016  case 77:
2017/* Line 1792 of yacc.c  */
2018#line 274 "scan.y"
2019    { ParserErrorMessage(); }
2020    break;
2021
2022  case 80:
2023/* Line 1792 of yacc.c  */
2024#line 280 "scan.y"
2025    { switch( crt_section ) {
2026                      case DEFVAR: DeclareSpecies( VAR_SPC, (yyvsp[(1) - (3)].str) ); break;
2027                      case DEFRAD: DeclareSpecies( RAD_SPC, (yyvsp[(1) - (3)].str) ); break;
2028                      case DEFFIX: DeclareSpecies( FIX_SPC, (yyvsp[(1) - (3)].str) ); break;
2029                    } 
2030                  }
2031    break;
2032
2033  case 81:
2034/* Line 1792 of yacc.c  */
2035#line 288 "scan.y"
2036    { switch( crt_section ) {
2037                      case DEFVAR: DeclareSpecies( VAR_SPC, (yyvsp[(1) - (1)].str) ); break;
2038                      case DEFRAD: DeclareSpecies( RAD_SPC, (yyvsp[(1) - (1)].str) ); break;
2039                      case DEFFIX: DeclareSpecies( FIX_SPC, (yyvsp[(1) - (1)].str) ); break;
2040                    } 
2041                  }
2042    break;
2043
2044  case 84:
2045/* Line 1792 of yacc.c  */
2046#line 299 "scan.y"
2047    { AddAtom( (yyvsp[(2) - (2)].str), (yyvsp[(1) - (2)].str) );
2048                  }
2049    break;
2050
2051  case 85:
2052/* Line 1792 of yacc.c  */
2053#line 302 "scan.y"
2054    { AddAtom( (yyvsp[(1) - (1)].str), "1" );
2055                  }
2056    break;
2057
2058  case 88:
2059/* Line 1792 of yacc.c  */
2060#line 308 "scan.y"
2061    { ParserErrorMessage(); }
2062    break;
2063
2064  case 89:
2065/* Line 1792 of yacc.c  */
2066#line 311 "scan.y"
2067    { AssignInitialValue( (yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].str) ); }
2068    break;
2069
2070  case 92:
2071/* Line 1792 of yacc.c  */
2072#line 316 "scan.y"
2073    { ParserErrorMessage();
2074                    eqState = LHS; 
2075                  }
2076    break;
2077
2078  case 93:
2079/* Line 1792 of yacc.c  */
2080#line 321 "scan.y"
2081    { eqState = LHS;
2082                    StoreEquationRate( (yyvsp[(4) - (4)].str), (yyvsp[(1) - (4)].str) ); 
2083                    CheckEquation();
2084                  }
2085    break;
2086
2087  case 94:
2088/* Line 1792 of yacc.c  */
2089#line 326 "scan.y"
2090    { eqState = LHS;
2091                    StoreEquationRate( (yyvsp[(3) - (3)].str), "          " ); 
2092                    CheckEquation();
2093                  }
2094    break;
2095
2096  case 95:
2097/* Line 1792 of yacc.c  */
2098#line 331 "scan.y"
2099    { strcpy( (yyval.str), (yyvsp[(1) - (2)].str) );
2100                    strcat( (yyval.str), (yyvsp[(2) - (2)].str) ); 
2101                  }
2102    break;
2103
2104  case 96:
2105/* Line 1792 of yacc.c  */
2106#line 335 "scan.y"
2107    { strcpy( (yyval.str), (yyvsp[(1) - (1)].str) );
2108                  }
2109    break;
2110
2111  case 97:
2112/* Line 1792 of yacc.c  */
2113#line 339 "scan.y"
2114    { strcpy( (yyval.str), (yyvsp[(2) - (3)].str) );
2115                  }
2116    break;
2117
2118  case 98:
2119/* Line 1792 of yacc.c  */
2120#line 343 "scan.y"
2121    { eqState = RHS; }
2122    break;
2123
2124  case 99:
2125/* Line 1792 of yacc.c  */
2126#line 346 "scan.y"
2127    { eqState = RAT; }
2128    break;
2129
2130  case 100:
2131/* Line 1792 of yacc.c  */
2132#line 349 "scan.y"
2133    { ProcessTerm( eqState, (yyvsp[(2) - (3)].str), crt_coef, crt_term ); 
2134                  }
2135    break;
2136
2137  case 101:
2138/* Line 1792 of yacc.c  */
2139#line 352 "scan.y"
2140    { ProcessTerm( eqState, (yyvsp[(1) - (2)].str), crt_coef, crt_term );
2141                  }
2142    break;
2143
2144  case 102:
2145/* Line 1792 of yacc.c  */
2146#line 355 "scan.y"
2147    { ProcessTerm( eqState, "+", crt_coef, crt_term );
2148                  }
2149    break;
2150
2151  case 103:
2152/* Line 1792 of yacc.c  */
2153#line 359 "scan.y"
2154    { strcpy( crt_term, (yyvsp[(2) - (2)].str) );
2155                    strcpy( crt_coef, (yyvsp[(1) - (2)].str) ); 
2156                  }
2157    break;
2158
2159  case 104:
2160/* Line 1792 of yacc.c  */
2161#line 363 "scan.y"
2162    { strcpy( crt_term, (yyvsp[(1) - (1)].str) );         
2163                    strcpy( crt_coef, "1" ); 
2164                  }
2165    break;
2166
2167  case 107:
2168/* Line 1792 of yacc.c  */
2169#line 370 "scan.y"
2170    { ParserErrorMessage(); }
2171    break;
2172
2173  case 108:
2174/* Line 1792 of yacc.c  */
2175#line 373 "scan.y"
2176    { AddLumpSpecies( (yyvsp[(1) - (3)].str) );
2177                  }
2178    break;
2179
2180  case 109:
2181/* Line 1792 of yacc.c  */
2182#line 376 "scan.y"
2183    {
2184                    AddLumpSpecies( (yyvsp[(1) - (3)].str) );
2185                    CheckLump( (yyvsp[(3) - (3)].str) ); 
2186                  }
2187    break;
2188
2189  case 110:
2190/* Line 1792 of yacc.c  */
2191#line 381 "scan.y"
2192    {
2193                    InlineBuf = AppendString( InlineBuf, (yyvsp[(2) - (2)].str), &InlineLen, MAX_INLINE );
2194                  }
2195    break;
2196
2197  case 111:
2198/* Line 1792 of yacc.c  */
2199#line 385 "scan.y"
2200    {
2201                    InlineBuf = malloc( MAX_INLINE ); 
2202                    InlineLen = MAX_INLINE;
2203                    strcpy( InlineBuf, (yyvsp[(1) - (1)].str));
2204                  }
2205    break;
2206
2207
2208/* Line 1792 of yacc.c  */
2209#line 2210 "y.tab.c"
2210      default: break;
2211    }
2212  /* User semantic actions sometimes alter yychar, and that requires
2213     that yytoken be updated with the new translation.  We take the
2214     approach of translating immediately before every use of yytoken.
2215     One alternative is translating here after every semantic action,
2216     but that translation would be missed if the semantic action invokes
2217     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2218     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
2219     incorrect destructor might then be invoked immediately.  In the
2220     case of YYERROR or YYBACKUP, subsequent parser actions might lead
2221     to an incorrect destructor call or verbose syntax error message
2222     before the lookahead is translated.  */
2223  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2224
2225  YYPOPSTACK (yylen);
2226  yylen = 0;
2227  YY_STACK_PRINT (yyss, yyssp);
2228
2229  *++yyvsp = yyval;
2230
2231  /* Now `shift' the result of the reduction.  Determine what state
2232     that goes to, based on the state we popped back to and the rule
2233     number reduced by.  */
2234
2235  yyn = yyr1[yyn];
2236
2237  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2238  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2239    yystate = yytable[yystate];
2240  else
2241    yystate = yydefgoto[yyn - YYNTOKENS];
2242
2243  goto yynewstate;
2244
2245
2246/*------------------------------------.
2247| yyerrlab -- here on detecting error |
2248`------------------------------------*/
2249yyerrlab:
2250  /* Make sure we have latest lookahead translation.  See comments at
2251     user semantic actions for why this is necessary.  */
2252  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2253
2254  /* If not already recovering from an error, report this error.  */
2255  if (!yyerrstatus)
2256    {
2257      ++yynerrs;
2258#if ! YYERROR_VERBOSE
2259      yyerror (YY_("syntax error"));
2260#else
2261# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2262                                        yyssp, yytoken)
2263      {
2264        char const *yymsgp = YY_("syntax error");
2265        int yysyntax_error_status;
2266        yysyntax_error_status = YYSYNTAX_ERROR;
2267        if (yysyntax_error_status == 0)
2268          yymsgp = yymsg;
2269        else if (yysyntax_error_status == 1)
2270          {
2271            if (yymsg != yymsgbuf)
2272              YYSTACK_FREE (yymsg);
2273            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2274            if (!yymsg)
2275              {
2276                yymsg = yymsgbuf;
2277                yymsg_alloc = sizeof yymsgbuf;
2278                yysyntax_error_status = 2;
2279              }
2280            else
2281              {
2282                yysyntax_error_status = YYSYNTAX_ERROR;
2283                yymsgp = yymsg;
2284              }
2285          }
2286        yyerror (yymsgp);
2287        if (yysyntax_error_status == 2)
2288          goto yyexhaustedlab;
2289      }
2290# undef YYSYNTAX_ERROR
2291#endif
2292    }
2293
2294
2295
2296  if (yyerrstatus == 3)
2297    {
2298      /* If just tried and failed to reuse lookahead token after an
2299         error, discard it.  */
2300
2301      if (yychar <= YYEOF)
2302        {
2303          /* Return failure if at end of input.  */
2304          if (yychar == YYEOF)
2305            YYABORT;
2306        }
2307      else
2308        {
2309          yydestruct ("Error: discarding",
2310                      yytoken, &yylval);
2311          yychar = YYEMPTY;
2312        }
2313    }
2314
2315  /* Else will try to reuse lookahead token after shifting the error
2316     token.  */
2317  goto yyerrlab1;
2318
2319
2320/*---------------------------------------------------.
2321| yyerrorlab -- error raised explicitly by YYERROR.  |
2322`---------------------------------------------------*/
2323yyerrorlab:
2324
2325  /* Pacify compilers like GCC when the user code never invokes
2326     YYERROR and the label yyerrorlab therefore never appears in user
2327     code.  */
2328  if (/*CONSTCOND*/ 0)
2329     goto yyerrorlab;
2330
2331  /* Do not reclaim the symbols of the rule which action triggered
2332     this YYERROR.  */
2333  YYPOPSTACK (yylen);
2334  yylen = 0;
2335  YY_STACK_PRINT (yyss, yyssp);
2336  yystate = *yyssp;
2337  goto yyerrlab1;
2338
2339
2340/*-------------------------------------------------------------.
2341| yyerrlab1 -- common code for both syntax error and YYERROR.  |
2342`-------------------------------------------------------------*/
2343yyerrlab1:
2344  yyerrstatus = 3;      /* Each real token shifted decrements this.  */
2345
2346  for (;;)
2347    {
2348      yyn = yypact[yystate];
2349      if (!yypact_value_is_default (yyn))
2350        {
2351          yyn += YYTERROR;
2352          if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2353            {
2354              yyn = yytable[yyn];
2355              if (0 < yyn)
2356                break;
2357            }
2358        }
2359
2360      /* Pop the current state because it cannot handle the error token.  */
2361      if (yyssp == yyss)
2362        YYABORT;
2363
2364
2365      yydestruct ("Error: popping",
2366                  yystos[yystate], yyvsp);
2367      YYPOPSTACK (1);
2368      yystate = *yyssp;
2369      YY_STACK_PRINT (yyss, yyssp);
2370    }
2371
2372  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2373  *++yyvsp = yylval;
2374  YY_IGNORE_MAYBE_UNINITIALIZED_END
2375
2376
2377  /* Shift the error token.  */
2378  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2379
2380  yystate = yyn;
2381  goto yynewstate;
2382
2383
2384/*-------------------------------------.
2385| yyacceptlab -- YYACCEPT comes here.  |
2386`-------------------------------------*/
2387yyacceptlab:
2388  yyresult = 0;
2389  goto yyreturn;
2390
2391/*-----------------------------------.
2392| yyabortlab -- YYABORT comes here.  |
2393`-----------------------------------*/
2394yyabortlab:
2395  yyresult = 1;
2396  goto yyreturn;
2397
2398#if !defined yyoverflow || YYERROR_VERBOSE
2399/*-------------------------------------------------.
2400| yyexhaustedlab -- memory exhaustion comes here.  |
2401`-------------------------------------------------*/
2402yyexhaustedlab:
2403  yyerror (YY_("memory exhausted"));
2404  yyresult = 2;
2405  /* Fall through.  */
2406#endif
2407
2408yyreturn:
2409  if (yychar != YYEMPTY)
2410    {
2411      /* Make sure we have latest lookahead translation.  See comments at
2412         user semantic actions for why this is necessary.  */
2413      yytoken = YYTRANSLATE (yychar);
2414      yydestruct ("Cleanup: discarding lookahead",
2415                  yytoken, &yylval);
2416    }
2417  /* Do not reclaim the symbols of the rule which action triggered
2418     this YYABORT or YYACCEPT.  */
2419  YYPOPSTACK (yylen);
2420  YY_STACK_PRINT (yyss, yyssp);
2421  while (yyssp != yyss)
2422    {
2423      yydestruct ("Cleanup: popping",
2424                  yystos[*yyssp], yyvsp);
2425      YYPOPSTACK (1);
2426    }
2427#ifndef yyoverflow
2428  if (yyss != yyssa)
2429    YYSTACK_FREE (yyss);
2430#endif
2431#if YYERROR_VERBOSE
2432  if (yymsg != yymsgbuf)
2433    YYSTACK_FREE (yymsg);
2434#endif
2435  /* Make sure YYID is used.  */
2436  return YYID (yyresult);
2437}
2438
2439
2440/* Line 2055 of yacc.c  */
2441#line 391 "scan.y"
2442
2443
2444void yyerror( char * str )
2445{
2446}
2447
2448void ParserErrorMessage()
2449{
2450  /* yyerrok; */
2451/*
2452  Message("[%d,%s] -> [%d,%s]", crtTokType, crtToken, nextTokType, nextToken ); 
2453*/
2454  if( crtToken[0] == ';' ) {
2455    ParserError("Misplaced ';'");
2456    return;
2457  }
2458  switch( crtTokType ) {
2459    case ATOMID:
2460      ParserError("Missing ';' after '%s'", crtToken );
2461      break; 
2462
2463    case SPCSPC:
2464      ParserError("Missing ';' or '+' after '%s'", crtToken );
2465      break; 
2466    case SPCNR:
2467      ParserError("Missing species after '%s'", crtToken );
2468      break; 
2469    case SPCPLUS:
2470      ParserError("Missing atom after '%s'", crtToken );
2471      break; 
2472    case SPCEQUAL:
2473      ParserError("Invalid '=' after '%s'", crtToken );
2474      break; 
2475
2476    case INISPC:
2477      ParserError("Missing '=' after '%s'", crtToken );
2478      break; 
2479    case INIEQUAL:
2480      ParserError("Missing value after '%s'", crtToken );
2481      break; 
2482    case INIVALUE:
2483      ParserError("Missing ';' after '%s'", crtToken );
2484      break; 
2485
2486    case EQNSPC:
2487      ParserError("Missing '+' or '=' after '%s'", crtToken );
2488      break; 
2489    case EQNEQUAL:
2490      ParserError("Invalid right hand side of equation");
2491      break; 
2492    case EQNCOLON:
2493      ParserError("Missing rate after '%s'", crtToken );
2494      break; 
2495    case EQNSIGN:
2496      ParserError("Missing coeficient after '%s'", crtToken );
2497      break; 
2498    case EQNCOEF:
2499      ParserError("Missing species after '%s'", crtToken );
2500      break; 
2501    case RATE:
2502      ParserError("Missing ';' after '%s'", crtToken );
2503      break; 
2504
2505    case LMPSPC:
2506      ParserError("Missing '+' or ':' or ';' after '%s'", crtToken );
2507      break; 
2508    case LMPPLUS:
2509      ParserError("Missing species after '%s'", crtToken );
2510      break; 
2511    case LMPCOLON:
2512      ParserError("Missing species after '%s'", crtToken );
2513      break; 
2514    case INLINE:
2515      ParserError("Missing inline option after '%s'", crtToken );
2516      break;
2517
2518    default:
2519      ParserError("Syntax error after '%s'", crtToken ); 
2520  }
2521}
2522
2523
2524int Parser( char * filename )
2525{
2526extern int yydebug;
2527FILE *f;
2528
2529  crt_filename = filename;
2530
2531  f = fopen( crt_filename, "r" );
2532  if( f == 0 ) {
2533    FatalError(7,"%s: File not found", crt_filename);
2534  } 
2535 
2536  yyin = f;
2537  nError   = 0;
2538  nWarning = 0;
2539  yydebug = 0;
2540
2541  yyparse();
2542
2543  fclose( f );
2544
2545  return nError;
2546}         
2547
Note: See TracBrowser for help on using the repository browser.