source: src/bin/mpqc/parse.cc@ 5d30c1

Last change on this file since 5d30c1 was 5d30c1, checked in by Frederik Heber <heber@…>, 13 years ago

Initial commit based on 3.0.0alpha (here claimed as 2.4).

  • simply added all files.
  • Property mode set to 100644
File size: 43.3 KB
Line 
1/* A Bison parser, made by GNU Bison 1.875d. */
2
3/* Skeleton parser for Yacc-like parsing with Bison,
4 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
20
21/* As a special exception, when this file is copied by Bison into a
22 Bison output file, you may use that output file without restriction.
23 This special exception was added by the Free Software Foundation
24 in version 1.24 of Bison. */
25
26/* Written by Richard Stallman by simplifying the original so called
27 ``semantic'' parser. */
28
29/* All symbols defined below should begin with yy or YY, to avoid
30 infringing on user name space. This should be done even for local
31 variables, as they might otherwise be expanded by user macros.
32 There are some unavoidable exceptions within include files to
33 define necessary library symbols; they are noted "INFRINGES ON
34 USER NAME SPACE" below. */
35
36/* Identify Bison output. */
37#define YYBISON 1
38
39/* Skeleton name. */
40#define YYSKELETON_NAME "yacc.c"
41
42/* Pure parsers. */
43#define YYPURE 0
44
45/* Using locations. */
46#define YYLSP_NEEDED 0
47
48
49
50/* Tokens. */
51#ifndef YYTOKENTYPE
52# define YYTOKENTYPE
53 /* Put the tokens into the symbol table, so that GDB and other debuggers
54 know about them. */
55 enum yytokentype {
56 T_EBC = 258,
57 T_GBC = 259,
58 T_CABS = 260,
59 T_CABSP = 261,
60 T_ABS = 262,
61 T_ABSP = 263,
62 T_NOT = 264,
63 T_MOLECULE = 265,
64 T_MULTIPLICITY = 266,
65 T_CHARGE = 267,
66 T_METHOD = 268,
67 T_BASIS = 269,
68 T_AUXBASIS = 270,
69 T_EQUALS = 271,
70 T_OPTIMIZE = 272,
71 T_GRADIENT = 273,
72 T_BEG_OPT = 274,
73 T_END_OPT = 275,
74 T_CARTESIAN = 276,
75 T_INTERNAL = 277,
76 T_REDUNDANT = 278,
77 T_RESTART = 279,
78 T_CHECKPOINT = 280,
79 T_COLON = 281,
80 T_XC = 282,
81 T_SYMMETRY = 283,
82 T_MEMORY = 284,
83 T_BOHR = 285,
84 T_ANGSTROM = 286,
85 T_GRID = 287,
86 T_FREQUENCIES = 288,
87 T_DOCC = 289,
88 T_SOCC = 290,
89 T_FROZEN_DOCC = 291,
90 T_FROZEN_UOCC = 292,
91 T_ALPHA = 293,
92 T_BETA = 294,
93 T_OO_INPUT_KEYWORD = 295,
94 T_STRING = 296,
95 T_BOOL = 297
96 };
97#endif
98#define T_EBC 258
99#define T_GBC 259
100#define T_CABS 260
101#define T_CABSP 261
102#define T_ABS 262
103#define T_ABSP 263
104#define T_NOT 264
105#define T_MOLECULE 265
106#define T_MULTIPLICITY 266
107#define T_CHARGE 267
108#define T_METHOD 268
109#define T_BASIS 269
110#define T_AUXBASIS 270
111#define T_EQUALS 271
112#define T_OPTIMIZE 272
113#define T_GRADIENT 273
114#define T_BEG_OPT 274
115#define T_END_OPT 275
116#define T_CARTESIAN 276
117#define T_INTERNAL 277
118#define T_REDUNDANT 278
119#define T_RESTART 279
120#define T_CHECKPOINT 280
121#define T_COLON 281
122#define T_XC 282
123#define T_SYMMETRY 283
124#define T_MEMORY 284
125#define T_BOHR 285
126#define T_ANGSTROM 286
127#define T_GRID 287
128#define T_FREQUENCIES 288
129#define T_DOCC 289
130#define T_SOCC 290
131#define T_FROZEN_DOCC 291
132#define T_FROZEN_UOCC 292
133#define T_ALPHA 293
134#define T_BETA 294
135#define T_OO_INPUT_KEYWORD 295
136#define T_STRING 296
137#define T_BOOL 297
138
139
140
141
142/* Copy the first part of user declarations. */
143#line 1 "parse.yy"
144
145#ifdef DEC
146#include <math.h>
147#else
148#include <stdlib.h>
149#endif
150#include <string.h>
151#ifdef BISON
152#define YYDEBUG 0
153#if YYDEBUG != 0
154int yydebug =1;
155#endif /* YYDEBUG != 0 */
156#endif /* BISON */
157#if defined(SABER)
158#define xmalloc malloc
159#endif
160#if defined(SGI)
161#include <alloca.h>
162#endif
163#include "mpqcin.h"
164#define yyerror sc::MPQCIn::yerror
165#define yyparse sc::MPQCIn::yparse
166#define yylex sc::MPQCIn::ylex
167#define yynerrs MPQCInyynerrs
168#define yychar MPQCInyychar
169
170
171/* Enabling traces. */
172#ifndef YYDEBUG
173# define YYDEBUG 0
174#endif
175
176/* Enabling verbose error messages. */
177#ifdef YYERROR_VERBOSE
178# undef YYERROR_VERBOSE
179# define YYERROR_VERBOSE 1
180#else
181# define YYERROR_VERBOSE 0
182#endif
183
184#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
185#line 28 "parse.yy"
186typedef union YYSTYPE {
187 char *str;
188 int i;
189 std::vector<int> *nniv;
190 } YYSTYPE;
191/* Line 191 of yacc.c. */
192#line 193 "parse.tmp.cc"
193# define yystype YYSTYPE /* obsolescent; will be withdrawn */
194# define YYSTYPE_IS_DECLARED 1
195# define YYSTYPE_IS_TRIVIAL 1
196#endif
197
198
199
200/* Copy the second part of user declarations. */
201
202
203/* Line 214 of yacc.c. */
204#line 205 "parse.tmp.cc"
205
206#if ! defined (yyoverflow) || YYERROR_VERBOSE
207
208# ifndef YYFREE
209# define YYFREE free
210# endif
211# ifndef YYMALLOC
212# define YYMALLOC malloc
213# endif
214
215/* The parser invokes alloca or malloc; define the necessary symbols. */
216
217# ifdef YYSTACK_USE_ALLOCA
218# if YYSTACK_USE_ALLOCA
219# define YYSTACK_ALLOC alloca
220# endif
221# else
222# if defined (alloca) || defined (_ALLOCA_H)
223# define YYSTACK_ALLOC alloca
224# else
225# ifdef __GNUC__
226# define YYSTACK_ALLOC __builtin_alloca
227# endif
228# endif
229# endif
230
231# ifdef YYSTACK_ALLOC
232 /* Pacify GCC's `empty if-body' warning. */
233# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
234# else
235# if defined (__STDC__) || defined (__cplusplus)
236# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
237# define YYSIZE_T size_t
238# endif
239# define YYSTACK_ALLOC YYMALLOC
240# define YYSTACK_FREE YYFREE
241# endif
242#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
243
244
245#if (! defined (yyoverflow) \
246 && (! defined (__cplusplus) \
247 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
248
249/* A type that is properly aligned for any stack member. */
250union yyalloc
251{
252 short int yyss;
253 YYSTYPE yyvs;
254 };
255
256/* The size of the maximum gap between one aligned stack and the next. */
257# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
258
259/* The size of an array large to enough to hold all stacks, each with
260 N elements. */
261# define YYSTACK_BYTES(N) \
262 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
263 + YYSTACK_GAP_MAXIMUM)
264
265/* Copy COUNT objects from FROM to TO. The source and destination do
266 not overlap. */
267# ifndef YYCOPY
268# if defined (__GNUC__) && 1 < __GNUC__
269# define YYCOPY(To, From, Count) \
270 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
271# else
272# define YYCOPY(To, From, Count) \
273 do \
274 { \
275 register YYSIZE_T yyi; \
276 for (yyi = 0; yyi < (Count); yyi++) \
277 (To)[yyi] = (From)[yyi]; \
278 } \
279 while (0)
280# endif
281# endif
282
283/* Relocate STACK from its old location to the new one. The
284 local variables YYSIZE and YYSTACKSIZE give the old and new number of
285 elements in the stack, and YYPTR gives the new location of the
286 stack. Advance YYPTR to a properly aligned location for the next
287 stack. */
288# define YYSTACK_RELOCATE(Stack) \
289 do \
290 { \
291 YYSIZE_T yynewbytes; \
292 YYCOPY (&yyptr->Stack, Stack, yysize); \
293 Stack = &yyptr->Stack; \
294 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
295 yyptr += yynewbytes / sizeof (*yyptr); \
296 } \
297 while (0)
298
299#endif
300
301#if defined (__STDC__) || defined (__cplusplus)
302 typedef signed char yysigned_char;
303#else
304 typedef short int yysigned_char;
305#endif
306
307/* YYFINAL -- State number of the termination state. */
308#define YYFINAL 3
309/* YYLAST -- Last index in YYTABLE. */
310#define YYLAST 96
311
312/* YYNTOKENS -- Number of terminals. */
313#define YYNTOKENS 43
314/* YYNNTS -- Number of nonterminals. */
315#define YYNNTS 24
316/* YYNRULES -- Number of rules. */
317#define YYNRULES 66
318/* YYNRULES -- Number of states. */
319#define YYNSTATES 119
320
321/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
322#define YYUNDEFTOK 2
323#define YYMAXUTOK 297
324
325#define YYTRANSLATE(YYX) \
326 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
327
328/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
329static const unsigned char yytranslate[] =
330{
331 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
332 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
333 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
334 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
335 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
336 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
337 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
338 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
339 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
340 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
341 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
342 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
343 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
344 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
345 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
346 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
347 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
348 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
349 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
350 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
351 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
352 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
353 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
354 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
355 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
356 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
357 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
358 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
359 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
360 35, 36, 37, 38, 39, 40, 41, 42
361};
362
363#if YYDEBUG
364/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
365 YYRHS. */
366static const unsigned char yyprhs[] =
367{
368 0, 0, 3, 5, 8, 9, 10, 15, 19, 23,
369 27, 32, 36, 40, 45, 49, 53, 57, 61, 65,
370 69, 73, 77, 81, 85, 89, 91, 95, 98, 99,
371 103, 104, 107, 108, 110, 112, 114, 117, 120, 121,
372 127, 131, 132, 135, 136, 140, 144, 145, 148, 149,
373 151, 153, 157, 158, 161, 162, 166, 170, 172, 174,
374 177, 180, 182, 184, 186, 188, 190
375};
376
377/* YYRHS -- A `-1'-separated list of the rules' RHS. */
378static const yysigned_char yyrhs[] =
379{
380 44, 0, -1, 45, -1, 45, 46, -1, -1, -1,
381 10, 26, 47, 53, -1, 11, 26, 65, -1, 29,
382 26, 65, -1, 12, 26, 65, -1, 13, 26, 65,
383 62, -1, 14, 26, 65, -1, 15, 26, 65, -1,
384 17, 26, 66, 50, -1, 18, 26, 66, -1, 33,
385 26, 66, -1, 24, 26, 66, -1, 25, 26, 66,
386 -1, 28, 26, 65, -1, 34, 26, 48, -1, 35,
387 26, 48, -1, 38, 26, 48, -1, 39, 26, 48,
388 -1, 36, 26, 48, -1, 37, 26, 48, -1, 65,
389 -1, 19, 49, 20, -1, 49, 65, -1, -1, 19,
390 51, 20, -1, -1, 51, 52, -1, -1, 21, -1,
391 22, -1, 23, -1, 59, 54, -1, 54, 55, -1,
392 -1, 65, 65, 65, 65, 56, -1, 19, 57, 20,
393 -1, -1, 57, 58, -1, -1, 12, 16, 65, -1,
394 19, 60, 20, -1, -1, 60, 61, -1, -1, 30,
395 -1, 31, -1, 19, 63, 20, -1, -1, 63, 64,
396 -1, -1, 27, 16, 65, -1, 32, 16, 65, -1,
397 3, -1, 4, -1, 9, 3, -1, 9, 4, -1,
398 5, -1, 7, -1, 6, -1, 8, -1, 41, -1,
399 42, -1
400};
401
402/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
403static const unsigned char yyrline[] =
404{
405 0, 50, 50, 53, 54, 57, 57, 59, 61, 63,
406 65, 67, 69, 71, 73, 75, 77, 79, 81, 83,
407 85, 87, 89, 91, 93, 98, 99, 104, 105, 109,
408 110, 114, 115, 119, 120, 121, 124, 127, 128, 131,
409 136, 137, 141, 142, 146, 150, 151, 155, 156, 160,
410 161, 165, 166, 170, 171, 175, 176, 177, 178, 179,
411 180, 181, 182, 183, 184, 187, 190
412};
413#endif
414
415#if YYDEBUG || YYERROR_VERBOSE
416/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
417 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
418static const char *const yytname[] =
419{
420 "$end", "error", "$undefined", "T_EBC", "T_GBC", "T_CABS", "T_CABSP",
421 "T_ABS", "T_ABSP", "T_NOT", "T_MOLECULE", "T_MULTIPLICITY", "T_CHARGE",
422 "T_METHOD", "T_BASIS", "T_AUXBASIS", "T_EQUALS", "T_OPTIMIZE",
423 "T_GRADIENT", "T_BEG_OPT", "T_END_OPT", "T_CARTESIAN", "T_INTERNAL",
424 "T_REDUNDANT", "T_RESTART", "T_CHECKPOINT", "T_COLON", "T_XC",
425 "T_SYMMETRY", "T_MEMORY", "T_BOHR", "T_ANGSTROM", "T_GRID",
426 "T_FREQUENCIES", "T_DOCC", "T_SOCC", "T_FROZEN_DOCC", "T_FROZEN_UOCC",
427 "T_ALPHA", "T_BETA", "T_OO_INPUT_KEYWORD", "T_STRING", "T_BOOL",
428 "$accept", "input", "assignments", "assignment", "@1",
429 "nonnegative_int_vector", "nonnegative_int_sequence",
430 "optimize_options_list", "optimize_options", "optimize_option",
431 "molecule", "atoms", "atom", "atom_options_list", "atom_options",
432 "atom_option", "molecule_options_list", "molecule_options",
433 "molecule_option", "method_options_list", "method_options",
434 "method_option", "string", "bool", 0
435};
436#endif
437
438# ifdef YYPRINT
439/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
440 token YYLEX-NUM. */
441static const unsigned short int yytoknum[] =
442{
443 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
444 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
445 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
446 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
447 295, 296, 297
448};
449# endif
450
451/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
452static const unsigned char yyr1[] =
453{
454 0, 43, 44, 45, 45, 47, 46, 46, 46, 46,
455 46, 46, 46, 46, 46, 46, 46, 46, 46, 46,
456 46, 46, 46, 46, 46, 48, 48, 49, 49, 50,
457 50, 51, 51, 52, 52, 52, 53, 54, 54, 55,
458 56, 56, 57, 57, 58, 59, 59, 60, 60, 61,
459 61, 62, 62, 63, 63, 64, 64, 64, 64, 64,
460 64, 64, 64, 64, 64, 65, 66
461};
462
463/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
464static const unsigned char yyr2[] =
465{
466 0, 2, 1, 2, 0, 0, 4, 3, 3, 3,
467 4, 3, 3, 4, 3, 3, 3, 3, 3, 3,
468 3, 3, 3, 3, 3, 1, 3, 2, 0, 3,
469 0, 2, 0, 1, 1, 1, 2, 2, 0, 5,
470 3, 0, 2, 0, 3, 3, 0, 2, 0, 1,
471 1, 3, 0, 2, 0, 3, 3, 1, 1, 2,
472 2, 1, 1, 1, 1, 1, 1
473};
474
475/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
476 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
477 means the default is an error. */
478static const unsigned char yydefact[] =
479{
480 4, 0, 2, 1, 0, 0, 0, 0, 0, 0,
481 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
482 0, 0, 0, 3, 5, 0, 0, 0, 0, 0,
483 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
484 0, 0, 0, 46, 65, 7, 9, 52, 11, 12,
485 66, 30, 14, 16, 17, 18, 8, 15, 28, 19,
486 25, 20, 23, 24, 21, 22, 48, 6, 38, 54,
487 10, 32, 13, 0, 0, 36, 0, 0, 26, 27,
488 45, 49, 50, 47, 37, 0, 57, 58, 61, 63,
489 62, 64, 0, 51, 0, 0, 53, 29, 33, 34,
490 35, 31, 0, 59, 60, 0, 0, 0, 55, 56,
491 41, 43, 39, 0, 0, 40, 42, 0, 44
492};
493
494/* YYDEFGOTO[NTERM-NUM]. */
495static const yysigned_char yydefgoto[] =
496{
497 -1, 1, 2, 23, 43, 59, 73, 72, 77, 101,
498 67, 75, 84, 112, 113, 116, 68, 74, 83, 70,
499 76, 96, 60, 51
500};
501
502/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
503 STATE-NUM. */
504#define YYPACT_NINF -26
505static const yysigned_char yypact[] =
506{
507 -26, 6, 1, -26, -18, -9, -2, 23, 28, 29,
508 31, 40, 42, 43, 50, 52, 53, 57, 58, 59,
509 60, 61, 62, -26, -26, 18, 18, 18, 18, 18,
510 25, 25, 25, 25, 18, 18, 25, -14, -14, -14,
511 -14, -14, -14, 70, -26, -26, -26, 71, -26, -26,
512 -26, 72, -26, -26, -26, -26, -26, -26, -26, -26,
513 -26, -26, -26, -26, -26, -26, -26, -26, -26, -26,
514 -26, -26, -26, -13, 2, 18, 38, 41, -26, -26,
515 -26, -26, -26, -26, -26, 18, -26, -26, -26, -26,
516 -26, -26, 17, -26, 77, 78, -26, -26, -26, -26,
517 -26, -26, 18, -26, -26, 18, 18, 18, -26, -26,
518 76, -26, -26, 11, 80, -26, -26, 18, -26
519};
520
521/* YYPGOTO[NTERM-NUM]. */
522static const yysigned_char yypgoto[] =
523{
524 -26, -26, -26, -26, -26, 33, -26, -26, -26, -26,
525 -26, -26, -26, -26, -26, -26, -26, -26, -26, -26,
526 -26, -26, -25, 20
527};
528
529/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
530 positive, shift that token. If negative, reduce the rule which
531 number is the opposite. If zero, do what YYDEFACT says.
532 If YYTABLE_NINF, syntax error. */
533#define YYTABLE_NINF -1
534static const unsigned char yytable[] =
535{
536 45, 46, 47, 48, 49, 58, 3, 78, 24, 55,
537 56, 4, 5, 6, 7, 8, 9, 25, 10, 11,
538 103, 104, 80, 114, 26, 12, 13, 44, 44, 14,
539 15, 115, 81, 82, 16, 17, 18, 19, 20, 21,
540 22, 86, 87, 88, 89, 90, 91, 92, 79, 27,
541 85, 52, 53, 54, 28, 29, 57, 30, 93, 44,
542 102, 97, 98, 99, 100, 94, 31, 50, 32, 33,
543 95, 61, 62, 63, 64, 65, 34, 107, 35, 36,
544 108, 109, 110, 37, 38, 39, 40, 41, 42, 66,
545 69, 71, 118, 105, 106, 111, 117
546};
547
548static const unsigned char yycheck[] =
549{
550 25, 26, 27, 28, 29, 19, 0, 20, 26, 34,
551 35, 10, 11, 12, 13, 14, 15, 26, 17, 18,
552 3, 4, 20, 12, 26, 24, 25, 41, 41, 28,
553 29, 20, 30, 31, 33, 34, 35, 36, 37, 38,
554 39, 3, 4, 5, 6, 7, 8, 9, 73, 26,
555 75, 31, 32, 33, 26, 26, 36, 26, 20, 41,
556 85, 20, 21, 22, 23, 27, 26, 42, 26, 26,
557 32, 38, 39, 40, 41, 42, 26, 102, 26, 26,
558 105, 106, 107, 26, 26, 26, 26, 26, 26, 19,
559 19, 19, 117, 16, 16, 19, 16
560};
561
562/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
563 symbol of state STATE-NUM. */
564static const unsigned char yystos[] =
565{
566 0, 44, 45, 0, 10, 11, 12, 13, 14, 15,
567 17, 18, 24, 25, 28, 29, 33, 34, 35, 36,
568 37, 38, 39, 46, 26, 26, 26, 26, 26, 26,
569 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
570 26, 26, 26, 47, 41, 65, 65, 65, 65, 65,
571 42, 66, 66, 66, 66, 65, 65, 66, 19, 48,
572 65, 48, 48, 48, 48, 48, 19, 53, 59, 19,
573 62, 19, 50, 49, 60, 54, 63, 51, 20, 65,
574 20, 30, 31, 61, 55, 65, 3, 4, 5, 6,
575 7, 8, 9, 20, 27, 32, 64, 20, 21, 22,
576 23, 52, 65, 3, 4, 16, 16, 65, 65, 65,
577 65, 19, 56, 57, 12, 20, 58, 16, 65
578};
579
580#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
581# define YYSIZE_T __SIZE_TYPE__
582#endif
583#if ! defined (YYSIZE_T) && defined (size_t)
584# define YYSIZE_T size_t
585#endif
586#if ! defined (YYSIZE_T)
587# if defined (__STDC__) || defined (__cplusplus)
588# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
589# define YYSIZE_T size_t
590# endif
591#endif
592#if ! defined (YYSIZE_T)
593# define YYSIZE_T unsigned int
594#endif
595
596#define yyerrok (yyerrstatus = 0)
597#define yyclearin (yychar = YYEMPTY)
598#define YYEMPTY (-2)
599#define YYEOF 0
600
601#define YYACCEPT goto yyacceptlab
602#define YYABORT goto yyabortlab
603#define YYERROR goto yyerrorlab
604
605
606/* Like YYERROR except do call yyerror. This remains here temporarily
607 to ease the transition to the new meaning of YYERROR, for GCC.
608 Once GCC version 2 has supplanted version 1, this can go. */
609
610#define YYFAIL goto yyerrlab
611
612#define YYRECOVERING() (!!yyerrstatus)
613
614#define YYBACKUP(Token, Value) \
615do \
616 if (yychar == YYEMPTY && yylen == 1) \
617 { \
618 yychar = (Token); \
619 MPQCInylval = (Value); \
620 yytoken = YYTRANSLATE (yychar); \
621 YYPOPSTACK; \
622 goto yybackup; \
623 } \
624 else \
625 { \
626 yyerror ("syntax error: cannot back up");\
627 YYERROR; \
628 } \
629while (0)
630
631#define YYTERROR 1
632#define YYERRCODE 256
633
634/* YYLLOC_DEFAULT -- Compute the default location (before the actions
635 are run). */
636
637#ifndef YYLLOC_DEFAULT
638# define YYLLOC_DEFAULT(Current, Rhs, N) \
639 ((Current).first_line = (Rhs)[1].first_line, \
640 (Current).first_column = (Rhs)[1].first_column, \
641 (Current).last_line = (Rhs)[N].last_line, \
642 (Current).last_column = (Rhs)[N].last_column)
643#endif
644
645/* YYLEX -- calling `yylex' with the right arguments. */
646
647#ifdef YYLEX_PARAM
648# define YYLEX yylex (YYLEX_PARAM)
649#else
650# define YYLEX yylex ()
651#endif
652
653/* Enable debugging if requested. */
654#if YYDEBUG
655
656# ifndef YYFPRINTF
657# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
658# define YYFPRINTF fprintf
659# endif
660
661# define YYDPRINTF(Args) \
662do { \
663 if (yydebug) \
664 YYFPRINTF Args; \
665} while (0)
666
667# define YYDSYMPRINT(Args) \
668do { \
669 if (yydebug) \
670 yysymprint Args; \
671} while (0)
672
673# define YYDSYMPRINTF(Title, Token, Value, Location) \
674do { \
675 if (yydebug) \
676 { \
677 YYFPRINTF (stderr, "%s ", Title); \
678 yysymprint (stderr, \
679 Token, Value); \
680 YYFPRINTF (stderr, "\n"); \
681 } \
682} while (0)
683
684/*------------------------------------------------------------------.
685| yy_stack_print -- Print the state stack from its BOTTOM up to its |
686| TOP (included). |
687`------------------------------------------------------------------*/
688
689#if defined (__STDC__) || defined (__cplusplus)
690static void
691yy_stack_print (short int *bottom, short int *top)
692#else
693static void
694yy_stack_print (bottom, top)
695 short int *bottom;
696 short int *top;
697#endif
698{
699 YYFPRINTF (stderr, "Stack now");
700 for (/* Nothing. */; bottom <= top; ++bottom)
701 YYFPRINTF (stderr, " %d", *bottom);
702 YYFPRINTF (stderr, "\n");
703}
704
705# define YY_STACK_PRINT(Bottom, Top) \
706do { \
707 if (yydebug) \
708 yy_stack_print ((Bottom), (Top)); \
709} while (0)
710
711
712/*------------------------------------------------.
713| Report that the YYRULE is going to be reduced. |
714`------------------------------------------------*/
715
716#if defined (__STDC__) || defined (__cplusplus)
717static void
718yy_reduce_print (int yyrule)
719#else
720static void
721yy_reduce_print (yyrule)
722 int yyrule;
723#endif
724{
725 int yyi;
726 unsigned int yylno = yyrline[yyrule];
727 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
728 yyrule - 1, yylno);
729 /* Print the symbols being reduced, and their result. */
730 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
731 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
732 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
733}
734
735# define YY_REDUCE_PRINT(Rule) \
736do { \
737 if (yydebug) \
738 yy_reduce_print (Rule); \
739} while (0)
740
741/* Nonzero means print parse trace. It is left uninitialized so that
742 multiple parsers can coexist. */
743int yydebug;
744#else /* !YYDEBUG */
745# define YYDPRINTF(Args)
746# define YYDSYMPRINT(Args)
747# define YYDSYMPRINTF(Title, Token, Value, Location)
748# define YY_STACK_PRINT(Bottom, Top)
749# define YY_REDUCE_PRINT(Rule)
750#endif /* !YYDEBUG */
751
752
753/* YYINITDEPTH -- initial size of the parser's stacks. */
754#ifndef YYINITDEPTH
755# define YYINITDEPTH 200
756#endif
757
758/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
759 if the built-in stack extension method is used).
760
761 Do not make this value too large; the results are undefined if
762 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
763 evaluated with infinite-precision integer arithmetic. */
764
765#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
766# undef YYMAXDEPTH
767#endif
768
769#ifndef YYMAXDEPTH
770# define YYMAXDEPTH 10000
771#endif
772
773
774
775
776#if YYERROR_VERBOSE
777
778# ifndef yystrlen
779# if defined (__GLIBC__) && defined (_STRING_H)
780# define yystrlen strlen
781# else
782/* Return the length of YYSTR. */
783static YYSIZE_T
784# if defined (__STDC__) || defined (__cplusplus)
785yystrlen (const char *yystr)
786# else
787yystrlen (yystr)
788 const char *yystr;
789# endif
790{
791 register const char *yys = yystr;
792
793 while (*yys++ != '\0')
794 continue;
795
796 return yys - yystr - 1;
797}
798# endif
799# endif
800
801# ifndef yystpcpy
802# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
803# define yystpcpy stpcpy
804# else
805/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
806 YYDEST. */
807static char *
808# if defined (__STDC__) || defined (__cplusplus)
809yystpcpy (char *yydest, const char *yysrc)
810# else
811yystpcpy (yydest, yysrc)
812 char *yydest;
813 const char *yysrc;
814# endif
815{
816 register char *yyd = yydest;
817 register const char *yys = yysrc;
818
819 while ((*yyd++ = *yys++) != '\0')
820 continue;
821
822 return yyd - 1;
823}
824# endif
825# endif
826
827#endif /* !YYERROR_VERBOSE */
828
829
830
831
832#if YYDEBUG
833/*--------------------------------.
834| Print this symbol on YYOUTPUT. |
835`--------------------------------*/
836
837#if defined (__STDC__) || defined (__cplusplus)
838static void
839yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
840#else
841static void
842yysymprint (yyoutput, yytype, yyvaluep)
843 FILE *yyoutput;
844 int yytype;
845 YYSTYPE *yyvaluep;
846#endif
847{
848 /* Pacify ``unused variable'' warnings. */
849 (void) yyvaluep;
850
851 if (yytype < YYNTOKENS)
852 {
853 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
854# ifdef YYPRINT
855 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
856# endif
857 }
858 else
859 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
860
861 switch (yytype)
862 {
863 default:
864 break;
865 }
866 YYFPRINTF (yyoutput, ")");
867}
868
869#endif /* ! YYDEBUG */
870/*-----------------------------------------------.
871| Release the memory associated to this symbol. |
872`-----------------------------------------------*/
873
874#if defined (__STDC__) || defined (__cplusplus)
875static void
876yydestruct (int yytype, YYSTYPE *yyvaluep)
877#else
878static void
879yydestruct (yytype, yyvaluep)
880 int yytype;
881 YYSTYPE *yyvaluep;
882#endif
883{
884 /* Pacify ``unused variable'' warnings. */
885 (void) yyvaluep;
886
887 switch (yytype)
888 {
889
890 default:
891 break;
892 }
893}
894
895
896
897/* Prevent warnings from -Wmissing-prototypes. */
898
899#ifdef YYPARSE_PARAM
900# if defined (__STDC__) || defined (__cplusplus)
901
902# else
903
904# endif
905#else /* ! YYPARSE_PARAM */
906#if defined (__STDC__) || defined (__cplusplus)
907
908#else
909
910#endif
911#endif /* ! YYPARSE_PARAM */
912
913
914
915/* The lookahead symbol. */
916int yychar;
917
918/* The semantic value of the lookahead symbol. */
919YYSTYPE MPQCInylval;
920
921/* Number of syntax errors so far. */
922int yynerrs;
923
924
925
926/*----------.
927| yyparse. |
928`----------*/
929
930#ifdef YYPARSE_PARAM
931# if defined (__STDC__) || defined (__cplusplus)
932int yyparse (void *YYPARSE_PARAM)
933# else
934int yyparse (YYPARSE_PARAM)
935 void *YYPARSE_PARAM;
936# endif
937#else /* ! YYPARSE_PARAM */
938#if defined (__STDC__) || defined (__cplusplus)
939int
940yyparse (void)
941#else
942int
943yyparse ()
944
945#endif
946#endif
947{
948
949 register int yystate;
950 register int yyn;
951 int yyresult;
952 /* Number of tokens to shift before error messages enabled. */
953 int yyerrstatus;
954 /* Lookahead token as an internal (translated) token number. */
955 int yytoken = 0;
956
957 /* Three stacks and their tools:
958 `yyss': related to states,
959 `yyvs': related to semantic values,
960 `yyls': related to locations.
961
962 Refer to the stacks thru separate pointers, to allow yyoverflow
963 to reallocate them elsewhere. */
964
965 /* The state stack. */
966 short int yyssa[YYINITDEPTH];
967 short int *yyss = yyssa;
968 register short int *yyssp;
969
970 /* The semantic value stack. */
971 YYSTYPE yyvsa[YYINITDEPTH];
972 YYSTYPE *yyvs = yyvsa;
973 register YYSTYPE *yyvsp;
974
975
976
977#define YYPOPSTACK (yyvsp--, yyssp--)
978
979 YYSIZE_T yystacksize = YYINITDEPTH;
980
981 /* The variables used to return semantic value and location from the
982 action routines. */
983 YYSTYPE yyval;
984
985
986 /* When reducing, the number of symbols on the RHS of the reduced
987 rule. */
988 int yylen;
989
990 YYDPRINTF ((stderr, "Starting parse\n"));
991
992 yystate = 0;
993 yyerrstatus = 0;
994 yynerrs = 0;
995 yychar = YYEMPTY; /* Cause a token to be read. */
996
997 /* Initialize stack pointers.
998 Waste one element of value and location stack
999 so that they stay on the same level as the state stack.
1000 The wasted elements are never initialized. */
1001
1002 yyssp = yyss;
1003 yyvsp = yyvs;
1004
1005
1006 goto yysetstate;
1007
1008/*------------------------------------------------------------.
1009| yynewstate -- Push a new state, which is found in yystate. |
1010`------------------------------------------------------------*/
1011 yynewstate:
1012 /* In all cases, when you get here, the value and location stacks
1013 have just been pushed. so pushing a state here evens the stacks.
1014 */
1015 yyssp++;
1016
1017 yysetstate:
1018 *yyssp = yystate;
1019
1020 if (yyss + yystacksize - 1 <= yyssp)
1021 {
1022 /* Get the current used size of the three stacks, in elements. */
1023 YYSIZE_T yysize = yyssp - yyss + 1;
1024
1025#ifdef yyoverflow
1026 {
1027 /* Give user a chance to reallocate the stack. Use copies of
1028 these so that the &'s don't force the real ones into
1029 memory. */
1030 YYSTYPE *yyvs1 = yyvs;
1031 short int *yyss1 = yyss;
1032
1033
1034 /* Each stack pointer address is followed by the size of the
1035 data in use in that stack, in bytes. This used to be a
1036 conditional around just the two extra args, but that might
1037 be undefined if yyoverflow is a macro. */
1038 yyoverflow ("parser stack overflow",
1039 &yyss1, yysize * sizeof (*yyssp),
1040 &yyvs1, yysize * sizeof (*yyvsp),
1041
1042 &yystacksize);
1043
1044 yyss = yyss1;
1045 yyvs = yyvs1;
1046 }
1047#else /* no yyoverflow */
1048# ifndef YYSTACK_RELOCATE
1049 goto yyoverflowlab;
1050# else
1051 /* Extend the stack our own way. */
1052 if (YYMAXDEPTH <= yystacksize)
1053 goto yyoverflowlab;
1054 yystacksize *= 2;
1055 if (YYMAXDEPTH < yystacksize)
1056 yystacksize = YYMAXDEPTH;
1057
1058 {
1059 short int *yyss1 = yyss;
1060 union yyalloc *yyptr =
1061 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1062 if (! yyptr)
1063 goto yyoverflowlab;
1064 YYSTACK_RELOCATE (yyss);
1065 YYSTACK_RELOCATE (yyvs);
1066
1067# undef YYSTACK_RELOCATE
1068 if (yyss1 != yyssa)
1069 YYSTACK_FREE (yyss1);
1070 }
1071# endif
1072#endif /* no yyoverflow */
1073
1074 yyssp = yyss + yysize - 1;
1075 yyvsp = yyvs + yysize - 1;
1076
1077
1078 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1079 (unsigned long int) yystacksize));
1080
1081 if (yyss + yystacksize - 1 <= yyssp)
1082 YYABORT;
1083 }
1084
1085 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1086
1087 goto yybackup;
1088
1089/*-----------.
1090| yybackup. |
1091`-----------*/
1092yybackup:
1093
1094/* Do appropriate processing given the current state. */
1095/* Read a lookahead token if we need one and don't already have one. */
1096/* yyresume: */
1097
1098 /* First try to decide what to do without reference to lookahead token. */
1099
1100 yyn = yypact[yystate];
1101 if (yyn == YYPACT_NINF)
1102 goto yydefault;
1103
1104 /* Not known => get a lookahead token if don't already have one. */
1105
1106 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1107 if (yychar == YYEMPTY)
1108 {
1109 YYDPRINTF ((stderr, "Reading a token: "));
1110 yychar = YYLEX;
1111 }
1112
1113 if (yychar <= YYEOF)
1114 {
1115 yychar = yytoken = YYEOF;
1116 YYDPRINTF ((stderr, "Now at end of input.\n"));
1117 }
1118 else
1119 {
1120 yytoken = YYTRANSLATE (yychar);
1121 YYDSYMPRINTF ("Next token is", yytoken, &MPQCInylval, &yylloc);
1122 }
1123
1124 /* If the proper action on seeing token YYTOKEN is to reduce or to
1125 detect an error, take that action. */
1126 yyn += yytoken;
1127 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1128 goto yydefault;
1129 yyn = yytable[yyn];
1130 if (yyn <= 0)
1131 {
1132 if (yyn == 0 || yyn == YYTABLE_NINF)
1133 goto yyerrlab;
1134 yyn = -yyn;
1135 goto yyreduce;
1136 }
1137
1138 if (yyn == YYFINAL)
1139 YYACCEPT;
1140
1141 /* Shift the lookahead token. */
1142 YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
1143
1144 /* Discard the token being shifted unless it is eof. */
1145 if (yychar != YYEOF)
1146 yychar = YYEMPTY;
1147
1148 *++yyvsp = MPQCInylval;
1149
1150
1151 /* Count tokens shifted since error; after three, turn off error
1152 status. */
1153 if (yyerrstatus)
1154 yyerrstatus--;
1155
1156 yystate = yyn;
1157 goto yynewstate;
1158
1159
1160/*-----------------------------------------------------------.
1161| yydefault -- do the default action for the current state. |
1162`-----------------------------------------------------------*/
1163yydefault:
1164 yyn = yydefact[yystate];
1165 if (yyn == 0)
1166 goto yyerrlab;
1167 goto yyreduce;
1168
1169
1170/*-----------------------------.
1171| yyreduce -- Do a reduction. |
1172`-----------------------------*/
1173yyreduce:
1174 /* yyn is the number of a rule to reduce with. */
1175 yylen = yyr2[yyn];
1176
1177 /* If YYLEN is nonzero, implement the default value of the action:
1178 `$$ = $1'.
1179
1180 Otherwise, the following line sets YYVAL to garbage.
1181 This behavior is undocumented and Bison
1182 users should not rely upon it. Assigning to YYVAL
1183 unconditionally makes the parser a bit smaller, and it avoids a
1184 GCC warning that YYVAL may be used uninitialized. */
1185 yyval = yyvsp[1-yylen];
1186
1187
1188 YY_REDUCE_PRINT (yyn);
1189 switch (yyn)
1190 {
1191 case 5:
1192#line 57 "parse.yy"
1193 { begin_molecule(); ;}
1194 break;
1195
1196 case 6:
1197#line 58 "parse.yy"
1198 { end_molecule(); ;}
1199 break;
1200
1201 case 7:
1202#line 60 "parse.yy"
1203 { set_multiplicity(yyvsp[0].str); ;}
1204 break;
1205
1206 case 8:
1207#line 62 "parse.yy"
1208 { set_memory(yyvsp[0].str); ;}
1209 break;
1210
1211 case 9:
1212#line 64 "parse.yy"
1213 { set_charge(yyvsp[0].str); ;}
1214 break;
1215
1216 case 10:
1217#line 66 "parse.yy"
1218 { set_method(yyvsp[-1].str); ;}
1219 break;
1220
1221 case 11:
1222#line 68 "parse.yy"
1223 { set_basis(yyvsp[0].str); ;}
1224 break;
1225
1226 case 12:
1227#line 70 "parse.yy"
1228 { set_auxbasis(yyvsp[0].str); ;}
1229 break;
1230
1231 case 13:
1232#line 72 "parse.yy"
1233 { set_optimize(yyvsp[-1].i); ;}
1234 break;
1235
1236 case 14:
1237#line 74 "parse.yy"
1238 { set_gradient(yyvsp[0].i); ;}
1239 break;
1240
1241 case 15:
1242#line 76 "parse.yy"
1243 { set_frequencies(yyvsp[0].i); ;}
1244 break;
1245
1246 case 16:
1247#line 78 "parse.yy"
1248 { set_restart(yyvsp[0].i); ;}
1249 break;
1250
1251 case 17:
1252#line 80 "parse.yy"
1253 { set_checkpoint(yyvsp[0].i); ;}
1254 break;
1255
1256 case 18:
1257#line 82 "parse.yy"
1258 { set_symmetry(yyvsp[0].str); ;}
1259 break;
1260
1261 case 19:
1262#line 84 "parse.yy"
1263 { set_docc(yyvsp[0].nniv); ;}
1264 break;
1265
1266 case 20:
1267#line 86 "parse.yy"
1268 { set_socc(yyvsp[0].nniv); ;}
1269 break;
1270
1271 case 21:
1272#line 88 "parse.yy"
1273 { set_alpha(yyvsp[0].nniv); ;}
1274 break;
1275
1276 case 22:
1277#line 90 "parse.yy"
1278 { set_beta(yyvsp[0].nniv); ;}
1279 break;
1280
1281 case 23:
1282#line 92 "parse.yy"
1283 { set_frozen_docc(yyvsp[0].nniv); ;}
1284 break;
1285
1286 case 24:
1287#line 94 "parse.yy"
1288 { set_frozen_uocc(yyvsp[0].nniv); ;}
1289 break;
1290
1291 case 25:
1292#line 98 "parse.yy"
1293 { yyval.nniv = make_nnivec(0,yyvsp[0].str); ;}
1294 break;
1295
1296 case 26:
1297#line 100 "parse.yy"
1298 { yyval.nniv = yyvsp[-1].nniv; ;}
1299 break;
1300
1301 case 27:
1302#line 104 "parse.yy"
1303 { yyval.nniv = make_nnivec(yyvsp[-1].nniv,yyvsp[0].str); ;}
1304 break;
1305
1306 case 28:
1307#line 105 "parse.yy"
1308 { yyval.nniv = make_nnivec(0,0); ;}
1309 break;
1310
1311 case 33:
1312#line 119 "parse.yy"
1313 { set_opt_type(T_CARTESIAN); ;}
1314 break;
1315
1316 case 34:
1317#line 120 "parse.yy"
1318 { set_opt_type(T_INTERNAL); ;}
1319 break;
1320
1321 case 35:
1322#line 121 "parse.yy"
1323 { set_redund_coor(1); ;}
1324 break;
1325
1326 case 39:
1327#line 132 "parse.yy"
1328 { add_atom(yyvsp[-4].str,yyvsp[-3].str,yyvsp[-2].str,yyvsp[-1].str); ;}
1329 break;
1330
1331 case 44:
1332#line 146 "parse.yy"
1333 { set_atom_charge(yyvsp[0].str); ;}
1334 break;
1335
1336 case 49:
1337#line 160 "parse.yy"
1338 { set_molecule_bohr(1); ;}
1339 break;
1340
1341 case 50:
1342#line 161 "parse.yy"
1343 { set_molecule_bohr(0); ;}
1344 break;
1345
1346 case 55:
1347#line 175 "parse.yy"
1348 { set_method_xc(yyvsp[0].str); ;}
1349 break;
1350
1351 case 56:
1352#line 176 "parse.yy"
1353 { set_method_grid(yyvsp[0].str); ;}
1354 break;
1355
1356 case 57:
1357#line 177 "parse.yy"
1358 { set_method_ebc("true"); ;}
1359 break;
1360
1361 case 58:
1362#line 178 "parse.yy"
1363 { set_method_gbc("true"); ;}
1364 break;
1365
1366 case 59:
1367#line 179 "parse.yy"
1368 { set_method_ebc("false"); ;}
1369 break;
1370
1371 case 60:
1372#line 180 "parse.yy"
1373 { set_method_gbc("false"); ;}
1374 break;
1375
1376 case 61:
1377#line 181 "parse.yy"
1378 { set_method_absmethod("cabs"); ;}
1379 break;
1380
1381 case 62:
1382#line 182 "parse.yy"
1383 { set_method_absmethod("abs"); ;}
1384 break;
1385
1386 case 63:
1387#line 183 "parse.yy"
1388 { set_method_absmethod("cabs+"); ;}
1389 break;
1390
1391 case 64:
1392#line 184 "parse.yy"
1393 { set_method_absmethod("abs+"); ;}
1394 break;
1395
1396 case 65:
1397#line 187 "parse.yy"
1398 { yyval.str = yyvsp[0].str; ;}
1399 break;
1400
1401 case 66:
1402#line 190 "parse.yy"
1403 { yyval.i = yyvsp[0].i; ;}
1404 break;
1405
1406
1407 }
1408
1409/* Line 1010 of yacc.c. */
1410#line 1408 "parse.tmp.cc"
1411
1412
1413 yyvsp -= yylen;
1414 yyssp -= yylen;
1415
1416
1417 YY_STACK_PRINT (yyss, yyssp);
1418
1419 *++yyvsp = yyval;
1420
1421
1422 /* Now `shift' the result of the reduction. Determine what state
1423 that goes to, based on the state we popped back to and the rule
1424 number reduced by. */
1425
1426 yyn = yyr1[yyn];
1427
1428 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1429 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1430 yystate = yytable[yystate];
1431 else
1432 yystate = yydefgoto[yyn - YYNTOKENS];
1433
1434 goto yynewstate;
1435
1436
1437/*------------------------------------.
1438| yyerrlab -- here on detecting error |
1439`------------------------------------*/
1440yyerrlab:
1441 /* If not already recovering from an error, report this error. */
1442 if (!yyerrstatus)
1443 {
1444 ++yynerrs;
1445#if YYERROR_VERBOSE
1446 yyn = yypact[yystate];
1447
1448 if (YYPACT_NINF < yyn && yyn < YYLAST)
1449 {
1450 YYSIZE_T yysize = 0;
1451 int yytype = YYTRANSLATE (yychar);
1452 const char* yyprefix;
1453 char *yymsg;
1454 int yyx;
1455
1456 /* Start YYX at -YYN if negative to avoid negative indexes in
1457 YYCHECK. */
1458 int yyxbegin = yyn < 0 ? -yyn : 0;
1459
1460 /* Stay within bounds of both yycheck and yytname. */
1461 int yychecklim = YYLAST - yyn;
1462 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1463 int yycount = 0;
1464
1465 yyprefix = ", expecting ";
1466 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1467 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1468 {
1469 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
1470 yycount += 1;
1471 if (yycount == 5)
1472 {
1473 yysize = 0;
1474 break;
1475 }
1476 }
1477 yysize += (sizeof ("syntax error, unexpected ")
1478 + yystrlen (yytname[yytype]));
1479 yymsg = (char *) YYSTACK_ALLOC (yysize);
1480 if (yymsg != 0)
1481 {
1482 char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1483 yyp = yystpcpy (yyp, yytname[yytype]);
1484
1485 if (yycount < 5)
1486 {
1487 yyprefix = ", expecting ";
1488 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1489 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1490 {
1491 yyp = yystpcpy (yyp, yyprefix);
1492 yyp = yystpcpy (yyp, yytname[yyx]);
1493 yyprefix = " or ";
1494 }
1495 }
1496 yyerror (yymsg);
1497 YYSTACK_FREE (yymsg);
1498 }
1499 else
1500 yyerror ("syntax error; also virtual memory exhausted");
1501 }
1502 else
1503#endif /* YYERROR_VERBOSE */
1504 yyerror ("syntax error");
1505 }
1506
1507
1508
1509 if (yyerrstatus == 3)
1510 {
1511 /* If just tried and failed to reuse lookahead token after an
1512 error, discard it. */
1513
1514 if (yychar <= YYEOF)
1515 {
1516 /* If at end of input, pop the error token,
1517 then the rest of the stack, then return failure. */
1518 if (yychar == YYEOF)
1519 for (;;)
1520 {
1521 YYPOPSTACK;
1522 if (yyssp == yyss)
1523 YYABORT;
1524 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1525 yydestruct (yystos[*yyssp], yyvsp);
1526 }
1527 }
1528 else
1529 {
1530 YYDSYMPRINTF ("Error: discarding", yytoken, &MPQCInylval, &yylloc);
1531 yydestruct (yytoken, &MPQCInylval);
1532 yychar = YYEMPTY;
1533
1534 }
1535 }
1536
1537 /* Else will try to reuse lookahead token after shifting the error
1538 token. */
1539 goto yyerrlab1;
1540
1541
1542/*---------------------------------------------------.
1543| yyerrorlab -- error raised explicitly by YYERROR. |
1544`---------------------------------------------------*/
1545yyerrorlab:
1546
1547#ifdef __GNUC__
1548 /* Pacify GCC when the user code never invokes YYERROR and the label
1549 yyerrorlab therefore never appears in user code. */
1550 if (0)
1551 goto yyerrorlab;
1552#endif
1553
1554 yyvsp -= yylen;
1555 yyssp -= yylen;
1556 yystate = *yyssp;
1557 goto yyerrlab1;
1558
1559
1560/*-------------------------------------------------------------.
1561| yyerrlab1 -- common code for both syntax error and YYERROR. |
1562`-------------------------------------------------------------*/
1563yyerrlab1:
1564 yyerrstatus = 3; /* Each real token shifted decrements this. */
1565
1566 for (;;)
1567 {
1568 yyn = yypact[yystate];
1569 if (yyn != YYPACT_NINF)
1570 {
1571 yyn += YYTERROR;
1572 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1573 {
1574 yyn = yytable[yyn];
1575 if (0 < yyn)
1576 break;
1577 }
1578 }
1579
1580 /* Pop the current state because it cannot handle the error token. */
1581 if (yyssp == yyss)
1582 YYABORT;
1583
1584 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1585 yydestruct (yystos[yystate], yyvsp);
1586 YYPOPSTACK;
1587 yystate = *yyssp;
1588 YY_STACK_PRINT (yyss, yyssp);
1589 }
1590
1591 if (yyn == YYFINAL)
1592 YYACCEPT;
1593
1594 YYDPRINTF ((stderr, "Shifting error token, "));
1595
1596 *++yyvsp = MPQCInylval;
1597
1598
1599 yystate = yyn;
1600 goto yynewstate;
1601
1602
1603/*-------------------------------------.
1604| yyacceptlab -- YYACCEPT comes here. |
1605`-------------------------------------*/
1606yyacceptlab:
1607 yyresult = 0;
1608 goto yyreturn;
1609
1610/*-----------------------------------.
1611| yyabortlab -- YYABORT comes here. |
1612`-----------------------------------*/
1613yyabortlab:
1614 yyresult = 1;
1615 goto yyreturn;
1616
1617#ifndef yyoverflow
1618/*----------------------------------------------.
1619| yyoverflowlab -- parser overflow comes here. |
1620`----------------------------------------------*/
1621yyoverflowlab:
1622 yyerror ("parser stack overflow");
1623 yyresult = 2;
1624 /* Fall through. */
1625#endif
1626
1627yyreturn:
1628#ifndef yyoverflow
1629 if (yyss != yyssa)
1630 YYSTACK_FREE (yyss);
1631#endif
1632 return yyresult;
1633}
1634
1635
1636#line 193 "parse.yy"
1637
1638
Note: See TracBrowser for help on using the repository browser.