Ruby  1.9.3p448(2013-06-27revision41675)
gram.c
Go to the documentation of this file.
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 1
44 
45 /* Using locations. */
46 #define YYLSP_NEEDED 0
47 
48 /* If NAME_PREFIX is specified substitute the variables and functions
49  names. */
50 #define yyparse syckparse
51 #define yylex sycklex
52 #define yyerror syckerror
53 #define yylval sycklval
54 #define yychar syckchar
55 #define yydebug syckdebug
56 #define yynerrs sycknerrs
57 
58 
59 /* Tokens. */
60 #ifndef YYTOKENTYPE
61 # define YYTOKENTYPE
62  /* Put the tokens into the symbol table, so that GDB and other debuggers
63  know about them. */
64  enum yytokentype {
65  YAML_ANCHOR = 258,
66  YAML_ALIAS = 259,
68  YAML_TAGURI = 261,
70  YAML_WORD = 263,
71  YAML_PLAIN = 264,
72  YAML_BLOCK = 265,
73  YAML_DOCSEP = 266,
74  YAML_IOPEN = 267,
75  YAML_INDENT = 268,
76  YAML_IEND = 269
77  };
78 #endif
79 #define YAML_ANCHOR 258
80 #define YAML_ALIAS 259
81 #define YAML_TRANSFER 260
82 #define YAML_TAGURI 261
83 #define YAML_ITRANSFER 262
84 #define YAML_WORD 263
85 #define YAML_PLAIN 264
86 #define YAML_BLOCK 265
87 #define YAML_DOCSEP 266
88 #define YAML_IOPEN 267
89 #define YAML_INDENT 268
90 #define YAML_IEND 269
91 
92 
93 
94 
95 /* Copy the first part of user declarations. */
96 #line 14 "gram.y"
97 
98 
99 #include "syck.h"
100 
101 void apply_seq_in_map( SyckParser *parser, SyckNode *n );
102 
103 #define YYPARSE_PARAM parser
104 #define YYLEX_PARAM parser
105 
106 #define NULL_NODE(parser, node) \
107  SyckNode *node = syck_new_str( "", scalar_plain ); \
108  if ( ((SyckParser *)parser)->taguri_expansion == 1 ) \
109  { \
110  node->type_id = syck_taguri( YAML_DOMAIN, "null", 4 ); \
111  } \
112  else \
113  { \
114  node->type_id = syck_strndup( "null", 4 ); \
115  }
116 
117 
118 /* Enabling traces. */
119 #ifndef YYDEBUG
120 # define YYDEBUG 1
121 #endif
122 
123 /* Enabling verbose error messages. */
124 #ifdef YYERROR_VERBOSE
125 # undef YYERROR_VERBOSE
126 # define YYERROR_VERBOSE 1
127 #else
128 # define YYERROR_VERBOSE 0
129 #endif
130 
131 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
132 #line 35 "gram.y"
133 typedef union YYSTYPE {
136  char *name;
137 } YYSTYPE;
138 /* Line 191 of yacc.c. */
139 #line 140 "gram.c"
140 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
141 # define YYSTYPE_IS_DECLARED 1
142 # define YYSTYPE_IS_TRIVIAL 1
143 #endif
144 
145 
146 
147 /* Copy the second part of user declarations. */
148 
149 
150 /* Line 214 of yacc.c. */
151 #line 152 "gram.c"
152 
153 #if ! defined (yyoverflow) || YYERROR_VERBOSE
154 
155 # ifndef YYFREE
156 # define YYFREE free
157 # endif
158 # ifndef YYMALLOC
159 # define YYMALLOC malloc
160 # endif
161 
162 /* The parser invokes alloca or malloc; define the necessary symbols. */
163 
164 # ifdef YYSTACK_USE_ALLOCA
165 # if YYSTACK_USE_ALLOCA
166 # define YYSTACK_ALLOC alloca
167 # endif
168 # else
169 # if defined (alloca) || defined (_ALLOCA_H)
170 # define YYSTACK_ALLOC alloca
171 # else
172 # ifdef __GNUC__
173 # define YYSTACK_ALLOC __builtin_alloca
174 # endif
175 # endif
176 # endif
177 
178 # ifdef YYSTACK_ALLOC
179  /* Pacify GCC's `empty if-body' warning. */
180 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
181 # else
182 # if defined (__STDC__) || defined (__cplusplus)
183 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
184 # define YYSIZE_T size_t
185 # endif
186 # define YYSTACK_ALLOC YYMALLOC
187 # define YYSTACK_FREE YYFREE
188 # endif
189 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
190 
191 
192 #if (! defined (yyoverflow) \
193  && (! defined (__cplusplus) \
194  || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
195 
196 /* A type that is properly aligned for any stack member. */
197 union yyalloc
198 {
199  short int yyss;
200  YYSTYPE yyvs;
201  };
202 
203 /* The size of the maximum gap between one aligned stack and the next. */
204 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
205 
206 /* The size of an array large to enough to hold all stacks, each with
207  N elements. */
208 # define YYSTACK_BYTES(N) \
209  ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
210  + YYSTACK_GAP_MAXIMUM)
211 
212 /* Copy COUNT objects from FROM to TO. The source and destination do
213  not overlap. */
214 # ifndef YYCOPY
215 # if defined (__GNUC__) && 1 < __GNUC__
216 # define YYCOPY(To, From, Count) \
217  __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
218 # else
219 # define YYCOPY(To, From, Count) \
220  do \
221  { \
222  register YYSIZE_T yyi; \
223  for (yyi = 0; yyi < (Count); yyi++) \
224  (To)[yyi] = (From)[yyi]; \
225  } \
226  while (0)
227 # endif
228 # endif
229 
230 /* Relocate STACK from its old location to the new one. The
231  local variables YYSIZE and YYSTACKSIZE give the old and new number of
232  elements in the stack, and YYPTR gives the new location of the
233  stack. Advance YYPTR to a properly aligned location for the next
234  stack. */
235 # define YYSTACK_RELOCATE(Stack) \
236  do \
237  { \
238  YYSIZE_T yynewbytes; \
239  YYCOPY (&yyptr->Stack, Stack, yysize); \
240  Stack = &yyptr->Stack; \
241  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
242  yyptr += yynewbytes / sizeof (*yyptr); \
243  } \
244  while (0)
245 
246 #endif
247 
248 #if defined (__STDC__) || defined (__cplusplus)
249  typedef signed char yysigned_char;
250 #else
251  typedef short int yysigned_char;
252 #endif
253 
254 /* YYFINAL -- State number of the termination state. */
255 #define YYFINAL 52
256 /* YYLAST -- Last index in YYTABLE. */
257 #define YYLAST 396
258 
259 /* YYNTOKENS -- Number of terminals. */
260 #define YYNTOKENS 23
261 /* YYNNTS -- Number of nonterminals. */
262 #define YYNNTS 29
263 /* YYNRULES -- Number of rules. */
264 #define YYNRULES 79
265 /* YYNRULES -- Number of states. */
266 #define YYNSTATES 128
267 
268 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
269 #define YYUNDEFTOK 2
270 #define YYMAXUTOK 269
271 
272 #define YYTRANSLATE(YYX) \
273  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
274 
275 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
276 static const unsigned char yytranslate[] =
277 {
278  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
279  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
280  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
281  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
282  2, 2, 2, 2, 21, 15, 2, 2, 2, 2,
283  2, 2, 2, 2, 2, 2, 2, 2, 16, 2,
284  2, 2, 2, 22, 2, 2, 2, 2, 2, 2,
285  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
286  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
287  2, 17, 2, 18, 2, 2, 2, 2, 2, 2,
288  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
289  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
290  2, 2, 2, 19, 2, 20, 2, 2, 2, 2,
291  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
292  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
293  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
294  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
295  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
296  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
297  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
298  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
299  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
300  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
301  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
302  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
303  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
304  5, 6, 7, 8, 9, 10, 11, 12, 13, 14
305 };
306 
307 #if YYDEBUG
308 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
309  YYRHS. */
310 static const unsigned char yyprhs[] =
311 {
312  0, 0, 3, 5, 8, 9, 11, 13, 15, 18,
313  21, 24, 28, 30, 32, 36, 37, 40, 43, 46,
314  49, 51, 54, 56, 58, 60, 63, 66, 69, 72,
315  75, 77, 79, 81, 85, 87, 89, 91, 93, 95,
316  99, 103, 106, 110, 113, 117, 120, 124, 127, 129,
317  133, 136, 140, 143, 145, 149, 151, 153, 157, 161,
318  165, 168, 172, 175, 179, 182, 184, 188, 190, 194,
319  196, 200, 204, 207, 211, 215, 218, 220, 224, 226
320 };
321 
322 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
323 static const yysigned_char yyrhs[] =
324 {
325  24, 0, -1, 25, -1, 11, 27, -1, -1, 33,
326  -1, 26, -1, 34, -1, 5, 26, -1, 6, 26,
327  -1, 3, 26, -1, 29, 26, 32, -1, 25, -1,
328  28, -1, 29, 28, 30, -1, -1, 7, 28, -1,
329  5, 28, -1, 6, 28, -1, 3, 28, -1, 12,
330  -1, 29, 13, -1, 14, -1, 13, -1, 14, -1,
331  31, 32, -1, 5, 33, -1, 6, 33, -1, 7,
332  33, -1, 3, 33, -1, 4, -1, 8, -1, 9,
333  -1, 29, 33, 32, -1, 10, -1, 35, -1, 39,
334  -1, 42, -1, 49, -1, 29, 37, 30, -1, 29,
335  38, 30, -1, 15, 27, -1, 5, 31, 38, -1,
336  5, 37, -1, 6, 31, 38, -1, 6, 37, -1,
337  3, 31, 38, -1, 3, 37, -1, 36, -1, 38,
338  31, 36, -1, 38, 31, -1, 17, 40, 18, -1,
339  17, 18, -1, 41, -1, 40, 21, 41, -1, 25,
340  -1, 48, -1, 29, 43, 30, -1, 29, 47, 30,
341  -1, 5, 31, 47, -1, 5, 43, -1, 6, 31,
342  47, -1, 6, 43, -1, 3, 31, 47, -1, 3,
343  43, -1, 33, -1, 22, 25, 31, -1, 27, -1,
344  44, 16, 45, -1, 46, -1, 47, 31, 36, -1,
345  47, 31, 46, -1, 47, 31, -1, 25, 16, 27,
346  -1, 19, 50, 20, -1, 19, 20, -1, 51, -1,
347  50, 21, 51, -1, 25, -1, 48, -1
348 };
349 
350 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
351 static const unsigned short int yyrline[] =
352 {
353  0, 56, 56, 60, 65, 70, 71, 74, 75, 80,
354  85, 94, 100, 101, 104, 109, 113, 121, 126, 131,
355  145, 146, 149, 152, 155, 156, 164, 169, 174, 182,
356  186, 194, 207, 208, 218, 219, 220, 221, 222, 228,
357  232, 238, 244, 249, 254, 259, 264, 268, 274, 278,
358  283, 292, 296, 302, 306, 313, 314, 320, 325, 332,
359  337, 342, 347, 352, 356, 362, 363, 369, 379, 396,
360  397, 409, 417, 426, 434, 438, 444, 445, 454, 461
361 };
362 #endif
363 
364 #if YYDEBUG || YYERROR_VERBOSE
365 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
366  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
367 static const char *const yytname[] =
368 {
369  "$end", "error", "$undefined", "YAML_ANCHOR", "YAML_ALIAS",
370  "YAML_TRANSFER", "YAML_TAGURI", "YAML_ITRANSFER", "YAML_WORD",
371  "YAML_PLAIN", "YAML_BLOCK", "YAML_DOCSEP", "YAML_IOPEN", "YAML_INDENT",
372  "YAML_IEND", "'-'", "':'", "'['", "']'", "'{'", "'}'", "','", "'?'",
373  "$accept", "doc", "atom", "ind_rep", "atom_or_empty", "empty",
374  "indent_open", "indent_end", "indent_sep", "indent_flex_end", "word_rep",
375  "struct_rep", "implicit_seq", "basic_seq", "top_imp_seq",
376  "in_implicit_seq", "inline_seq", "in_inline_seq", "inline_seq_atom",
377  "implicit_map", "top_imp_map", "complex_key", "complex_value",
378  "complex_mapping", "in_implicit_map", "basic_mapping", "inline_map",
379  "in_inline_map", "inline_map_atom", 0
380 };
381 #endif
382 
383 # ifdef YYPRINT
384 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
385  token YYLEX-NUM. */
386 static const unsigned short int yytoknum[] =
387 {
388  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
389  265, 266, 267, 268, 269, 45, 58, 91, 93, 123,
390  125, 44, 63
391 };
392 # endif
393 
394 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
395 static const unsigned char yyr1[] =
396 {
397  0, 23, 24, 24, 24, 25, 25, 26, 26, 26,
398  26, 26, 27, 27, 28, 28, 28, 28, 28, 28,
399  29, 29, 30, 31, 32, 32, 33, 33, 33, 33,
400  33, 33, 33, 33, 34, 34, 34, 34, 34, 35,
401  35, 36, 37, 37, 37, 37, 37, 37, 38, 38,
402  38, 39, 39, 40, 40, 41, 41, 42, 42, 43,
403  43, 43, 43, 43, 43, 44, 44, 45, 46, 47,
404  47, 47, 47, 48, 49, 49, 50, 50, 51, 51
405 };
406 
407 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
408 static const unsigned char yyr2[] =
409 {
410  0, 2, 1, 2, 0, 1, 1, 1, 2, 2,
411  2, 3, 1, 1, 3, 0, 2, 2, 2, 2,
412  1, 2, 1, 1, 1, 2, 2, 2, 2, 2,
413  1, 1, 1, 3, 1, 1, 1, 1, 1, 3,
414  3, 2, 3, 2, 3, 2, 3, 2, 1, 3,
415  2, 3, 2, 1, 3, 1, 1, 3, 3, 3,
416  2, 3, 2, 3, 2, 1, 3, 1, 3, 1,
417  3, 3, 2, 3, 3, 2, 1, 3, 1, 1
418 };
419 
420 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
421  STATE-NUM when YYTABLE doesn't specify something else to do. Zero
422  means the default is an error. */
423 static const unsigned char yydefact[] =
424 {
425  4, 0, 30, 0, 0, 0, 31, 32, 34, 15,
426  20, 0, 0, 0, 2, 6, 0, 5, 7, 35,
427  36, 37, 38, 10, 29, 8, 26, 9, 27, 0,
428  0, 0, 0, 28, 15, 15, 15, 15, 12, 3,
429  13, 15, 52, 55, 0, 53, 56, 75, 78, 79,
430  0, 76, 1, 0, 0, 0, 21, 15, 0, 0,
431  65, 48, 0, 0, 0, 0, 69, 0, 0, 19,
432  17, 18, 15, 15, 15, 16, 15, 15, 15, 15,
433  0, 15, 51, 0, 74, 0, 23, 0, 47, 64,
434  0, 43, 60, 0, 45, 62, 41, 0, 24, 0,
435  11, 33, 22, 39, 40, 50, 57, 15, 58, 72,
436  14, 73, 54, 77, 65, 46, 63, 42, 59, 44,
437  61, 66, 25, 49, 67, 68, 70, 71
438 };
439 
440 /* YYDEFGOTO[NTERM-NUM]. */
441 static const yysigned_char yydefgoto[] =
442 {
443  -1, 13, 38, 15, 39, 40, 16, 103, 99, 101,
444  17, 18, 19, 61, 62, 63, 20, 44, 45, 21,
445  64, 65, 125, 66, 67, 46, 22, 50, 51
446 };
447 
448 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
449  STATE-NUM. */
450 #define YYPACT_NINF -97
451 static const short int yypact[] =
452 {
453  250, 318, -97, 318, 318, 374, -97, -97, -97, 335,
454  -97, 267, 232, 7, -97, -97, 192, -97, -97, -97,
455  -97, -97, -97, -97, -97, -97, -97, -97, -97, 374,
456  374, 374, 352, -97, 335, 335, 335, 384, -97, -97,
457  -97, 212, -97, 10, 0, -97, -97, -97, 10, -97,
458  -4, -97, -97, 284, 284, 284, -97, 335, 318, 30,
459  30, -97, -2, 36, -2, 16, -97, 36, 30, -97,
460  -97, -97, 384, 384, 384, -97, 363, 301, 301, 301,
461  -2, 335, -97, 318, -97, 318, -97, 158, -97, -97,
462  158, -97, -97, 158, -97, -97, -97, 24, -97, 30,
463  -97, -97, -97, -97, -97, 26, -97, 335, -97, 158,
464  -97, -97, -97, -97, -97, 24, 24, 24, 24, 24,
465  24, -97, -97, -97, -97, -97, -97, -97
466 };
467 
468 /* YYPGOTO[NTERM-NUM]. */
469 static const yysigned_char yypgoto[] =
470 {
471  -97, -97, 8, 81, -56, 109, 33, -53, 74, -54,
472  -1, -97, -97, -96, -31, -32, -97, -97, -44, -97,
473  77, -97, -97, -52, 9, -6, -97, -97, -29
474 };
475 
476 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
477  positive, shift that token. If negative, reduce the rule which
478  number is the opposite. If zero, do what YYDEFACT says.
479  If YYTABLE_NINF, syntax error. */
480 #define YYTABLE_NINF -1
481 static const unsigned char yytable[] =
482 {
483  24, 96, 26, 28, 33, 100, 49, 52, 14, 123,
484  104, 106, 102, 126, 108, 60, 84, 85, 82, 43,
485  48, 83, 88, 91, 94, 111, 81, 110, 24, 26,
486  28, 68, 107, 24, 26, 28, 33, 86, 32, 112,
487  60, 57, 41, 86, 98, 122, 88, 91, 94, 86,
488  102, 124, 24, 26, 28, 115, 113, 127, 117, 0,
489  0, 119, 32, 32, 32, 32, 97, 41, 41, 41,
490  76, 24, 26, 28, 41, 68, 24, 26, 28, 49,
491  0, 0, 23, 0, 25, 27, 114, 0, 0, 114,
492  41, 43, 114, 48, 0, 0, 116, 59, 0, 118,
493  0, 0, 120, 0, 0, 76, 76, 76, 114, 76,
494  41, 41, 41, 0, 41, 23, 25, 27, 0, 0,
495  32, 0, 59, 32, 0, 0, 32, 87, 90, 93,
496  89, 92, 95, 0, 23, 25, 27, 105, 0, 0,
497  41, 109, 32, 69, 70, 71, 75, 0, 0, 0,
498  80, 87, 90, 93, 89, 92, 95, 0, 23, 25,
499  27, 29, 2, 30, 31, 5, 6, 7, 0, 0,
500  10, 121, 0, 57, 0, 0, 0, 0, 0, 0,
501  58, 69, 70, 71, 0, 80, 69, 70, 71, 105,
502  109, 105, 109, 105, 109, 53, 2, 54, 55, 5,
503  6, 7, 8, 0, 10, 56, 0, 57, 0, 11,
504  0, 12, 0, 0, 58, 77, 2, 78, 79, 37,
505  6, 7, 8, 0, 10, 56, 0, 57, 0, 11,
506  0, 12, 0, 0, 58, 1, 2, 3, 4, 5,
507  6, 7, 8, 0, 10, 0, 0, 0, 0, 11,
508  0, 12, 47, 1, 2, 3, 4, 5, 6, 7,
509  8, 9, 10, 0, 0, 0, 0, 11, 0, 12,
510  1, 2, 3, 4, 5, 6, 7, 8, 0, 10,
511  0, 0, 0, 0, 11, 42, 12, 53, 2, 54,
512  55, 5, 6, 7, 8, 0, 10, 86, 0, 0,
513  0, 11, 0, 12, 77, 2, 78, 79, 37, 6,
514  7, 8, 0, 10, 86, 0, 0, 0, 11, 0,
515  12, 1, 2, 3, 4, 5, 6, 7, 8, 0,
516  10, 0, 0, 0, 0, 11, 0, 12, 34, 2,
517  35, 36, 37, 6, 7, 8, 0, 10, 0, 0,
518  0, 0, 11, 0, 12, 29, 2, 30, 31, 5,
519  6, 7, 0, 0, 10, 56, 72, 2, 73, 74,
520  37, 6, 7, 0, 0, 10, 56, 29, 2, 30,
521  31, 5, 6, 7, 0, 0, 10, 72, 2, 73,
522  74, 37, 6, 7, 0, 0, 10
523 };
524 
525 static const yysigned_char yycheck[] =
526 {
527  1, 57, 3, 4, 5, 59, 12, 0, 0, 105,
528  63, 64, 14, 109, 67, 16, 20, 21, 18, 11,
529  12, 21, 53, 54, 55, 81, 16, 80, 29, 30,
530  31, 32, 16, 34, 35, 36, 37, 13, 5, 83,
531  41, 15, 9, 13, 14, 99, 77, 78, 79, 13,
532  14, 107, 53, 54, 55, 87, 85, 109, 90, -1,
533  -1, 93, 29, 30, 31, 32, 58, 34, 35, 36,
534  37, 72, 73, 74, 41, 76, 77, 78, 79, 85,
535  -1, -1, 1, -1, 3, 4, 87, -1, -1, 90,
536  57, 83, 93, 85, -1, -1, 87, 16, -1, 90,
537  -1, -1, 93, -1, -1, 72, 73, 74, 109, 76,
538  77, 78, 79, -1, 81, 34, 35, 36, -1, -1,
539  87, -1, 41, 90, -1, -1, 93, 53, 54, 55,
540  53, 54, 55, -1, 53, 54, 55, 63, -1, -1,
541  107, 67, 109, 34, 35, 36, 37, -1, -1, -1,
542  41, 77, 78, 79, 77, 78, 79, -1, 77, 78,
543  79, 3, 4, 5, 6, 7, 8, 9, -1, -1,
544  12, 97, -1, 15, -1, -1, -1, -1, -1, -1,
545  22, 72, 73, 74, -1, 76, 77, 78, 79, 115,
546  116, 117, 118, 119, 120, 3, 4, 5, 6, 7,
547  8, 9, 10, -1, 12, 13, -1, 15, -1, 17,
548  -1, 19, -1, -1, 22, 3, 4, 5, 6, 7,
549  8, 9, 10, -1, 12, 13, -1, 15, -1, 17,
550  -1, 19, -1, -1, 22, 3, 4, 5, 6, 7,
551  8, 9, 10, -1, 12, -1, -1, -1, -1, 17,
552  -1, 19, 20, 3, 4, 5, 6, 7, 8, 9,
553  10, 11, 12, -1, -1, -1, -1, 17, -1, 19,
554  3, 4, 5, 6, 7, 8, 9, 10, -1, 12,
555  -1, -1, -1, -1, 17, 18, 19, 3, 4, 5,
556  6, 7, 8, 9, 10, -1, 12, 13, -1, -1,
557  -1, 17, -1, 19, 3, 4, 5, 6, 7, 8,
558  9, 10, -1, 12, 13, -1, -1, -1, 17, -1,
559  19, 3, 4, 5, 6, 7, 8, 9, 10, -1,
560  12, -1, -1, -1, -1, 17, -1, 19, 3, 4,
561  5, 6, 7, 8, 9, 10, -1, 12, -1, -1,
562  -1, -1, 17, -1, 19, 3, 4, 5, 6, 7,
563  8, 9, -1, -1, 12, 13, 3, 4, 5, 6,
564  7, 8, 9, -1, -1, 12, 13, 3, 4, 5,
565  6, 7, 8, 9, -1, -1, 12, 3, 4, 5,
566  6, 7, 8, 9, -1, -1, 12
567 };
568 
569 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
570  symbol of state STATE-NUM. */
571 static const unsigned char yystos[] =
572 {
573  0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
574  12, 17, 19, 24, 25, 26, 29, 33, 34, 35,
575  39, 42, 49, 26, 33, 26, 33, 26, 33, 3,
576  5, 6, 29, 33, 3, 5, 6, 7, 25, 27,
577  28, 29, 18, 25, 40, 41, 48, 20, 25, 48,
578  50, 51, 0, 3, 5, 6, 13, 15, 22, 26,
579  33, 36, 37, 38, 43, 44, 46, 47, 33, 28,
580  28, 28, 3, 5, 6, 28, 29, 3, 5, 6,
581  28, 16, 18, 21, 20, 21, 13, 31, 37, 43,
582  31, 37, 43, 31, 37, 43, 27, 25, 14, 31,
583  32, 32, 14, 30, 30, 31, 30, 16, 30, 31,
584  30, 27, 41, 51, 33, 38, 47, 38, 47, 38,
585  47, 31, 32, 36, 27, 45, 36, 46
586 };
587 
588 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
589 # define YYSIZE_T __SIZE_TYPE__
590 #endif
591 #if ! defined (YYSIZE_T) && defined (size_t)
592 # define YYSIZE_T size_t
593 #endif
594 #if ! defined (YYSIZE_T)
595 # if defined (__STDC__) || defined (__cplusplus)
596 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
597 # define YYSIZE_T size_t
598 # endif
599 #endif
600 #if ! defined (YYSIZE_T)
601 # define YYSIZE_T unsigned int
602 #endif
603 
604 #define yyerrok (yyerrstatus = 0)
605 #define yyclearin (yychar = YYEMPTY)
606 #define YYEMPTY (-2)
607 #define YYEOF 0
608 
609 #define YYACCEPT goto yyacceptlab
610 #define YYABORT goto yyabortlab
611 #define YYERROR goto yyerrorlab
612 
613 
614 /* Like YYERROR except do call yyerror. This remains here temporarily
615  to ease the transition to the new meaning of YYERROR, for GCC.
616  Once GCC version 2 has supplanted version 1, this can go. */
617 
618 #define YYFAIL goto yyerrlab
619 
620 #define YYRECOVERING() (!!yyerrstatus)
621 
622 #define YYBACKUP(Token, Value) \
623 do \
624  if (yychar == YYEMPTY && yylen == 1) \
625  { \
626  yychar = (Token); \
627  yylval = (Value); \
628  yytoken = YYTRANSLATE (yychar); \
629  YYPOPSTACK; \
630  goto yybackup; \
631  } \
632  else \
633  { \
634  yyerror ("syntax error: cannot back up");\
635  YYERROR; \
636  } \
637 while (0)
638 
639 #define YYTERROR 1
640 #define YYERRCODE 256
641 
642 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
643  are run). */
644 
645 #ifndef YYLLOC_DEFAULT
646 # define YYLLOC_DEFAULT(Current, Rhs, N) \
647  ((Current).first_line = (Rhs)[1].first_line, \
648  (Current).first_column = (Rhs)[1].first_column, \
649  (Current).last_line = (Rhs)[N].last_line, \
650  (Current).last_column = (Rhs)[N].last_column)
651 #endif
652 
653 /* YYLEX -- calling `yylex' with the right arguments. */
654 
655 #ifdef YYLEX_PARAM
656 # define YYLEX yylex (&yylval, YYLEX_PARAM)
657 #else
658 # define YYLEX yylex (&yylval)
659 #endif
660 
661 /* Enable debugging if requested. */
662 #if YYDEBUG
663 
664 # ifndef YYFPRINTF
665 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
666 # define YYFPRINTF fprintf
667 # endif
668 
669 # define YYDPRINTF(Args) \
670 do { \
671  if (yydebug) \
672  YYFPRINTF Args; \
673 } while (0)
674 
675 # define YYDSYMPRINT(Args) \
676 do { \
677  if (yydebug) \
678  yysymprint Args; \
679 } while (0)
680 
681 # define YYDSYMPRINTF(Title, Token, Value, Location) \
682 do { \
683  if (yydebug) \
684  { \
685  YYFPRINTF (stderr, "%s ", Title); \
686  yysymprint (stderr, \
687  Token, Value); \
688  YYFPRINTF (stderr, "\n"); \
689  } \
690 } while (0)
691 
692 /*------------------------------------------------------------------.
693 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
694 | TOP (included). |
695 `------------------------------------------------------------------*/
696 
697 #if defined (__STDC__) || defined (__cplusplus)
698 static void
699 yy_stack_print (short int *bottom, short int *top)
700 #else
701 static void
702 yy_stack_print (bottom, top)
703  short int *bottom;
704  short int *top;
705 #endif
706 {
707  YYFPRINTF (stderr, "Stack now");
708  for (/* Nothing. */; bottom <= top; ++bottom)
709  YYFPRINTF (stderr, " %d", *bottom);
710  YYFPRINTF (stderr, "\n");
711 }
712 
713 # define YY_STACK_PRINT(Bottom, Top) \
714 do { \
715  if (yydebug) \
716  yy_stack_print ((Bottom), (Top)); \
717 } while (0)
718 
719 
720 /*------------------------------------------------.
721 | Report that the YYRULE is going to be reduced. |
722 `------------------------------------------------*/
723 
724 #if defined (__STDC__) || defined (__cplusplus)
725 static void
726 yy_reduce_print (int yyrule)
727 #else
728 static void
730  int yyrule;
731 #endif
732 {
733  int yyi;
734  unsigned int yylno = yyrline[yyrule];
735  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
736  yyrule - 1, yylno);
737  /* Print the symbols being reduced, and their result. */
738  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
739  YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
740  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
741 }
742 
743 # define YY_REDUCE_PRINT(Rule) \
744 do { \
745  if (yydebug) \
746  yy_reduce_print (Rule); \
747 } while (0)
748 
749 /* Nonzero means print parse trace. It is left uninitialized so that
750  multiple parsers can coexist. */
752 #else /* !YYDEBUG */
753 # define YYDPRINTF(Args)
754 # define YYDSYMPRINT(Args)
755 # define YYDSYMPRINTF(Title, Token, Value, Location)
756 # define YY_STACK_PRINT(Bottom, Top)
757 # define YY_REDUCE_PRINT(Rule)
758 #endif /* !YYDEBUG */
759 
760 
761 /* YYINITDEPTH -- initial size of the parser's stacks. */
762 #ifndef YYINITDEPTH
763 # define YYINITDEPTH 200
764 #endif
765 
766 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
767  if the built-in stack extension method is used).
768 
769  Do not make this value too large; the results are undefined if
770  SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
771  evaluated with infinite-precision integer arithmetic. */
772 
773 #if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
774 # undef YYMAXDEPTH
775 #endif
776 
777 #ifndef YYMAXDEPTH
778 # define YYMAXDEPTH 10000
779 #endif
780 
781 
782 
783 #if YYERROR_VERBOSE
784 
785 # ifndef yystrlen
786 # if defined (__GLIBC__) && defined (_STRING_H)
787 # define yystrlen strlen
788 # else
789 /* Return the length of YYSTR. */
790 static YYSIZE_T
791 # if defined (__STDC__) || defined (__cplusplus)
792 yystrlen (const char *yystr)
793 # else
794 yystrlen (yystr)
795  const char *yystr;
796 # endif
797 {
798  register const char *yys = yystr;
799 
800  while (*yys++ != '\0')
801  continue;
802 
803  return yys - yystr - 1;
804 }
805 # endif
806 # endif
807 
808 # ifndef yystpcpy
809 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
810 # define yystpcpy stpcpy
811 # else
812 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
813  YYDEST. */
814 static char *
815 # if defined (__STDC__) || defined (__cplusplus)
816 yystpcpy (char *yydest, const char *yysrc)
817 # else
818 yystpcpy (yydest, yysrc)
819  char *yydest;
820  const char *yysrc;
821 # endif
822 {
823  register char *yyd = yydest;
824  register const char *yys = yysrc;
825 
826  while ((*yyd++ = *yys++) != '\0')
827  continue;
828 
829  return yyd - 1;
830 }
831 # endif
832 # endif
833 
834 #endif /* !YYERROR_VERBOSE */
835 
836 
837 
838 #if YYDEBUG
839 /*--------------------------------.
840 | Print this symbol on YYOUTPUT. |
841 `--------------------------------*/
842 
843 #if defined (__STDC__) || defined (__cplusplus)
844 static void
845 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
846 #else
847 static void
848 yysymprint (yyoutput, yytype, yyvaluep)
849  FILE *yyoutput;
850  int yytype;
851  YYSTYPE *yyvaluep;
852 #endif
853 {
854  /* Pacify ``unused variable'' warnings. */
855  (void) yyvaluep;
856 
857  if (yytype < YYNTOKENS)
858  {
859  YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
860 # ifdef YYPRINT
861  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
862 # endif
863  }
864  else
865  YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
866 
867  switch (yytype)
868  {
869  default:
870  break;
871  }
872  YYFPRINTF (yyoutput, ")");
873 }
874 
875 #endif /* ! YYDEBUG */
876 /*-----------------------------------------------.
877 | Release the memory associated to this symbol. |
878 `-----------------------------------------------*/
879 
880 #if defined (__STDC__) || defined (__cplusplus)
881 static void
882 yydestruct (int yytype, YYSTYPE *yyvaluep)
883 #else
884 static void
885 yydestruct (yytype, yyvaluep)
886  int yytype;
887  YYSTYPE *yyvaluep;
888 #endif
889 {
890  /* Pacify ``unused variable'' warnings. */
891  (void) yyvaluep;
892 
893  switch (yytype)
894  {
895 
896  default:
897  break;
898  }
899 }
900 
901 
902 /* Prevent warnings from -Wmissing-prototypes. */
903 
904 #ifdef YYPARSE_PARAM
905 # if defined (__STDC__) || defined (__cplusplus)
906 int yyparse (void *YYPARSE_PARAM);
907 # else
908 int yyparse ();
909 # endif
910 #else /* ! YYPARSE_PARAM */
911 #if defined (__STDC__) || defined (__cplusplus)
912 int yyparse (void);
913 #else
914 int yyparse ();
915 #endif
916 #endif /* ! YYPARSE_PARAM */
917 
918 
919 
920 
921 
922 
923 /*----------.
924 | yyparse. |
925 `----------*/
926 
927 #ifdef YYPARSE_PARAM
928 # if defined (__STDC__) || defined (__cplusplus)
929 int yyparse (void *YYPARSE_PARAM)
930 # else
931 int yyparse (YYPARSE_PARAM)
932  void *YYPARSE_PARAM;
933 # endif
934 #else /* ! YYPARSE_PARAM */
935 #if defined (__STDC__) || defined (__cplusplus)
936 int
937 yyparse (void)
938 #else
939 int
940 yyparse ()
941 
942 #endif
943 #endif
944 {
945  /* The lookahead symbol. */
946 int yychar;
947 
948 /* The semantic value of the lookahead symbol. */
950 
951 /* Number of syntax errors so far. */
952 int yynerrs;
953 
954  register int yystate;
955  register int yyn;
956  int yyresult;
957  /* Number of tokens to shift before error messages enabled. */
958  int yyerrstatus;
959  /* Lookahead token as an internal (translated) token number. */
960  int yytoken = 0;
961 
962  /* Three stacks and their tools:
963  `yyss': related to states,
964  `yyvs': related to semantic values,
965  `yyls': related to locations.
966 
967  Refer to the stacks thru separate pointers, to allow yyoverflow
968  to reallocate them elsewhere. */
969 
970  /* The state stack. */
971  short int yyssa[YYINITDEPTH];
972  short int *yyss = yyssa;
973  register short int *yyssp;
974 
975  /* The semantic value stack. */
976  YYSTYPE yyvsa[YYINITDEPTH];
977  YYSTYPE *yyvs = yyvsa;
978  register YYSTYPE *yyvsp;
979 
980 
981 
982 #define YYPOPSTACK (yyvsp--, yyssp--)
983 
984  YYSIZE_T yystacksize = YYINITDEPTH;
985 
986  /* The variables used to return semantic value and location from the
987  action routines. */
988  YYSTYPE yyval;
989 
990 
991  /* When reducing, the number of symbols on the RHS of the reduced
992  rule. */
993  int yylen;
994 
995  YYDPRINTF ((stderr, "Starting parse\n"));
996 
997  yystate = 0;
998  yyerrstatus = 0;
999  yynerrs = 0;
1000  yychar = YYEMPTY; /* Cause a token to be read. */
1001 
1002  /* Initialize stack pointers.
1003  Waste one element of value and location stack
1004  so that they stay on the same level as the state stack.
1005  The wasted elements are never initialized. */
1006 
1007  yyssp = yyss;
1008  yyvsp = yyvs;
1009 
1010 
1011  goto yysetstate;
1012 
1013 /*------------------------------------------------------------.
1014 | yynewstate -- Push a new state, which is found in yystate. |
1015 `------------------------------------------------------------*/
1016  yynewstate:
1017  /* In all cases, when you get here, the value and location stacks
1018  have just been pushed. so pushing a state here evens the stacks.
1019  */
1020  yyssp++;
1021 
1022  yysetstate:
1023  *yyssp = yystate;
1024 
1025  if (yyss + yystacksize - 1 <= yyssp)
1026  {
1027  /* Get the current used size of the three stacks, in elements. */
1028  YYSIZE_T yysize = yyssp - yyss + 1;
1029 
1030 #ifdef yyoverflow
1031  {
1032  /* Give user a chance to reallocate the stack. Use copies of
1033  these so that the &'s don't force the real ones into
1034  memory. */
1035  YYSTYPE *yyvs1 = yyvs;
1036  short int *yyss1 = yyss;
1037 
1038 
1039  /* Each stack pointer address is followed by the size of the
1040  data in use in that stack, in bytes. This used to be a
1041  conditional around just the two extra args, but that might
1042  be undefined if yyoverflow is a macro. */
1043  yyoverflow ("parser stack overflow",
1044  &yyss1, yysize * sizeof (*yyssp),
1045  &yyvs1, yysize * sizeof (*yyvsp),
1046 
1047  &yystacksize);
1048 
1049  yyss = yyss1;
1050  yyvs = yyvs1;
1051  }
1052 #else /* no yyoverflow */
1053 # ifndef YYSTACK_RELOCATE
1054  goto yyoverflowlab;
1055 # else
1056  /* Extend the stack our own way. */
1057  if (YYMAXDEPTH <= yystacksize)
1058  goto yyoverflowlab;
1059  yystacksize *= 2;
1060  if (YYMAXDEPTH < yystacksize)
1061  yystacksize = YYMAXDEPTH;
1062 
1063  {
1064  short int *yyss1 = yyss;
1065  union yyalloc *yyptr =
1066  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1067  if (! yyptr)
1068  goto yyoverflowlab;
1069  YYSTACK_RELOCATE (yyss);
1070  YYSTACK_RELOCATE (yyvs);
1071 
1072 # undef YYSTACK_RELOCATE
1073  if (yyss1 != yyssa)
1074  YYSTACK_FREE (yyss1);
1075  }
1076 # endif
1077 #endif /* no yyoverflow */
1078 
1079  yyssp = yyss + yysize - 1;
1080  yyvsp = yyvs + yysize - 1;
1081 
1082 
1083  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1084  (unsigned long int) yystacksize));
1085 
1086  if (yyss + yystacksize - 1 <= yyssp)
1087  YYABORT;
1088  }
1089 
1090  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1091 
1092  goto yybackup;
1093 
1094 /*-----------.
1095 | yybackup. |
1096 `-----------*/
1097 yybackup:
1098 
1099 /* Do appropriate processing given the current state. */
1100 /* Read a lookahead token if we need one and don't already have one. */
1101 /* yyresume: */
1102 
1103  /* First try to decide what to do without reference to lookahead token. */
1104 
1105  yyn = yypact[yystate];
1106  if (yyn == YYPACT_NINF)
1107  goto yydefault;
1108 
1109  /* Not known => get a lookahead token if don't already have one. */
1110 
1111  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1112  if (yychar == YYEMPTY)
1113  {
1114  YYDPRINTF ((stderr, "Reading a token: "));
1115  yychar = YYLEX;
1116  }
1117 
1118  if (yychar <= YYEOF)
1119  {
1120  yychar = yytoken = YYEOF;
1121  YYDPRINTF ((stderr, "Now at end of input.\n"));
1122  }
1123  else
1124  {
1125  yytoken = YYTRANSLATE (yychar);
1126  YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
1127  }
1128 
1129  /* If the proper action on seeing token YYTOKEN is to reduce or to
1130  detect an error, take that action. */
1131  yyn += yytoken;
1132  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1133  goto yydefault;
1134  yyn = yytable[yyn];
1135  if (yyn <= 0)
1136  {
1137  if (yyn == 0 || yyn == YYTABLE_NINF)
1138  goto yyerrlab;
1139  yyn = -yyn;
1140  goto yyreduce;
1141  }
1142 
1143  if (yyn == YYFINAL)
1144  YYACCEPT;
1145 
1146  /* Shift the lookahead token. */
1147  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
1148 
1149  /* Discard the token being shifted unless it is eof. */
1150  if (yychar != YYEOF)
1151  yychar = YYEMPTY;
1152 
1153  *++yyvsp = yylval;
1154 
1155 
1156  /* Count tokens shifted since error; after three, turn off error
1157  status. */
1158  if (yyerrstatus)
1159  yyerrstatus--;
1160 
1161  yystate = yyn;
1162  goto yynewstate;
1163 
1164 
1165 /*-----------------------------------------------------------.
1166 | yydefault -- do the default action for the current state. |
1167 `-----------------------------------------------------------*/
1168 yydefault:
1169  yyn = yydefact[yystate];
1170  if (yyn == 0)
1171  goto yyerrlab;
1172  goto yyreduce;
1173 
1174 
1175 /*-----------------------------.
1176 | yyreduce -- Do a reduction. |
1177 `-----------------------------*/
1178 yyreduce:
1179  /* yyn is the number of a rule to reduce with. */
1180  yylen = yyr2[yyn];
1181 
1182  /* If YYLEN is nonzero, implement the default value of the action:
1183  `$$ = $1'.
1184 
1185  Otherwise, the following line sets YYVAL to garbage.
1186  This behavior is undocumented and Bison
1187  users should not rely upon it. Assigning to YYVAL
1188  unconditionally makes the parser a bit smaller, and it avoids a
1189  GCC warning that YYVAL may be used uninitialized. */
1190  yyval = yyvsp[1-yylen];
1191 
1192 
1193  YY_REDUCE_PRINT (yyn);
1194  switch (yyn)
1195  {
1196  case 2:
1197 #line 57 "gram.y"
1198  {
1199  ((SyckParser *)parser)->root = syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData );
1200  }
1201  break;
1202 
1203  case 3:
1204 #line 61 "gram.y"
1205  {
1206  ((SyckParser *)parser)->root = syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData );
1207  }
1208  break;
1209 
1210  case 4:
1211 #line 65 "gram.y"
1212  {
1213  ((SyckParser *)parser)->eof = 1;
1214  }
1215  break;
1216 
1217  case 8:
1218 #line 76 "gram.y"
1219  {
1220  syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );
1221  yyval.nodeData = yyvsp[0].nodeData;
1222  }
1223  break;
1224 
1225  case 9:
1226 #line 81 "gram.y"
1227  {
1228  syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, 0 );
1229  yyval.nodeData = yyvsp[0].nodeData;
1230  }
1231  break;
1232 
1233  case 10:
1234 #line 86 "gram.y"
1235  {
1236  /*
1237  * _Anchors_: The language binding must keep a separate symbol table
1238  * for anchors. The actual ID in the symbol table is returned to the
1239  * higher nodes, though.
1240  */
1241  yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-1].name, yyvsp[0].nodeData );
1242  }
1243  break;
1244 
1245  case 11:
1246 #line 95 "gram.y"
1247  {
1248  yyval.nodeData = yyvsp[-1].nodeData;
1249  }
1250  break;
1251 
1252  case 14:
1253 #line 105 "gram.y"
1254  {
1255  yyval.nodeData = yyvsp[-1].nodeData;
1256  }
1257  break;
1258 
1259  case 15:
1260 #line 109 "gram.y"
1261  {
1262  NULL_NODE( parser, n );
1263  yyval.nodeData = n;
1264  }
1265  break;
1266 
1267  case 16:
1268 #line 114 "gram.y"
1269  {
1270  if ( ((SyckParser *)parser)->implicit_typing == 1 )
1271  {
1272  try_tag_implicit( yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );
1273  }
1274  yyval.nodeData = yyvsp[0].nodeData;
1275  }
1276  break;
1277 
1278  case 17:
1279 #line 122 "gram.y"
1280  {
1281  syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );
1282  yyval.nodeData = yyvsp[0].nodeData;
1283  }
1284  break;
1285 
1286  case 18:
1287 #line 127 "gram.y"
1288  {
1289  syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, 0 );
1290  yyval.nodeData = yyvsp[0].nodeData;
1291  }
1292  break;
1293 
1294  case 19:
1295 #line 132 "gram.y"
1296  {
1297  /*
1298  * _Anchors_: The language binding must keep a separate symbol table
1299  * for anchors. The actual ID in the symbol table is returned to the
1300  * higher nodes, though.
1301  */
1302  yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-1].name, yyvsp[0].nodeData );
1303  }
1304  break;
1305 
1306  case 26:
1307 #line 165 "gram.y"
1308  {
1309  syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );
1310  yyval.nodeData = yyvsp[0].nodeData;
1311  }
1312  break;
1313 
1314  case 27:
1315 #line 170 "gram.y"
1316  {
1317  syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, 0 );
1318  yyval.nodeData = yyvsp[0].nodeData;
1319  }
1320  break;
1321 
1322  case 28:
1323 #line 175 "gram.y"
1324  {
1325  if ( ((SyckParser *)parser)->implicit_typing == 1 )
1326  {
1327  try_tag_implicit( yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );
1328  }
1329  yyval.nodeData = yyvsp[0].nodeData;
1330  }
1331  break;
1332 
1333  case 29:
1334 #line 183 "gram.y"
1335  {
1336  yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-1].name, yyvsp[0].nodeData );
1337  }
1338  break;
1339 
1340  case 30:
1341 #line 187 "gram.y"
1342  {
1343  /*
1344  * _Aliases_: The anchor symbol table is scanned for the anchor name.
1345  * The anchor's ID in the language's symbol table is returned.
1346  */
1347  yyval.nodeData = syck_hdlr_get_anchor( (SyckParser *)parser, yyvsp[0].name );
1348  }
1349  break;
1350 
1351  case 31:
1352 #line 195 "gram.y"
1353  {
1354  SyckNode *n = yyvsp[0].nodeData;
1355  if ( ((SyckParser *)parser)->taguri_expansion == 1 )
1356  {
1357  n->type_id = syck_taguri( YAML_DOMAIN, "str", 3 );
1358  }
1359  else
1360  {
1361  n->type_id = syck_strndup( "str", 3 );
1362  }
1363  yyval.nodeData = n;
1364  }
1365  break;
1366 
1367  case 33:
1368 #line 209 "gram.y"
1369  {
1370  yyval.nodeData = yyvsp[-1].nodeData;
1371  }
1372  break;
1373 
1374  case 39:
1375 #line 229 "gram.y"
1376  {
1377  yyval.nodeData = yyvsp[-1].nodeData;
1378  }
1379  break;
1380 
1381  case 40:
1382 #line 233 "gram.y"
1383  {
1384  yyval.nodeData = yyvsp[-1].nodeData;
1385  }
1386  break;
1387 
1388  case 41:
1389 #line 239 "gram.y"
1390  {
1391  yyval.nodeId = syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData );
1392  }
1393  break;
1394 
1395  case 42:
1396 #line 245 "gram.y"
1397  {
1398  syck_add_transfer( yyvsp[-2].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );
1399  yyval.nodeData = yyvsp[0].nodeData;
1400  }
1401  break;
1402 
1403  case 43:
1404 #line 250 "gram.y"
1405  {
1406  syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );
1407  yyval.nodeData = yyvsp[0].nodeData;
1408  }
1409  break;
1410 
1411  case 44:
1412 #line 255 "gram.y"
1413  {
1414  syck_add_transfer( yyvsp[-2].name, yyvsp[0].nodeData, 0 );
1415  yyval.nodeData = yyvsp[0].nodeData;
1416  }
1417  break;
1418 
1419  case 45:
1420 #line 260 "gram.y"
1421  {
1422  syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, 0 );
1423  yyval.nodeData = yyvsp[0].nodeData;
1424  }
1425  break;
1426 
1427  case 46:
1428 #line 265 "gram.y"
1429  {
1430  yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-2].name, yyvsp[0].nodeData );
1431  }
1432  break;
1433 
1434  case 47:
1435 #line 269 "gram.y"
1436  {
1437  yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-1].name, yyvsp[0].nodeData );
1438  }
1439  break;
1440 
1441  case 48:
1442 #line 275 "gram.y"
1443  {
1444  yyval.nodeData = syck_new_seq( yyvsp[0].nodeId );
1445  }
1446  break;
1447 
1448  case 49:
1449 #line 279 "gram.y"
1450  {
1451  syck_seq_add( yyvsp[-2].nodeData, yyvsp[0].nodeId );
1452  yyval.nodeData = yyvsp[-2].nodeData;
1453  }
1454  break;
1455 
1456  case 50:
1457 #line 284 "gram.y"
1458  {
1459  yyval.nodeData = yyvsp[-1].nodeData;
1460  }
1461  break;
1462 
1463  case 51:
1464 #line 293 "gram.y"
1465  {
1466  yyval.nodeData = yyvsp[-1].nodeData;
1467  }
1468  break;
1469 
1470  case 52:
1471 #line 297 "gram.y"
1472  {
1473  yyval.nodeData = syck_alloc_seq();
1474  }
1475  break;
1476 
1477  case 53:
1478 #line 303 "gram.y"
1479  {
1480  yyval.nodeData = syck_new_seq( syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData ) );
1481  }
1482  break;
1483 
1484  case 54:
1485 #line 307 "gram.y"
1486  {
1487  syck_seq_add( yyvsp[-2].nodeData, syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData ) );
1488  yyval.nodeData = yyvsp[-2].nodeData;
1489  }
1490  break;
1491 
1492  case 57:
1493 #line 321 "gram.y"
1494  {
1495  apply_seq_in_map( (SyckParser *)parser, yyvsp[-1].nodeData );
1496  yyval.nodeData = yyvsp[-1].nodeData;
1497  }
1498  break;
1499 
1500  case 58:
1501 #line 326 "gram.y"
1502  {
1503  apply_seq_in_map( (SyckParser *)parser, yyvsp[-1].nodeData );
1504  yyval.nodeData = yyvsp[-1].nodeData;
1505  }
1506  break;
1507 
1508  case 59:
1509 #line 333 "gram.y"
1510  {
1511  syck_add_transfer( yyvsp[-2].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );
1512  yyval.nodeData = yyvsp[0].nodeData;
1513  }
1514  break;
1515 
1516  case 60:
1517 #line 338 "gram.y"
1518  {
1519  syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, ((SyckParser *)parser)->taguri_expansion );
1520  yyval.nodeData = yyvsp[0].nodeData;
1521  }
1522  break;
1523 
1524  case 61:
1525 #line 343 "gram.y"
1526  {
1527  syck_add_transfer( yyvsp[-2].name, yyvsp[0].nodeData, 0 );
1528  yyval.nodeData = yyvsp[0].nodeData;
1529  }
1530  break;
1531 
1532  case 62:
1533 #line 348 "gram.y"
1534  {
1535  syck_add_transfer( yyvsp[-1].name, yyvsp[0].nodeData, 0 );
1536  yyval.nodeData = yyvsp[0].nodeData;
1537  }
1538  break;
1539 
1540  case 63:
1541 #line 353 "gram.y"
1542  {
1543  yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-2].name, yyvsp[0].nodeData );
1544  }
1545  break;
1546 
1547  case 64:
1548 #line 357 "gram.y"
1549  {
1550  yyval.nodeData = syck_hdlr_add_anchor( (SyckParser *)parser, yyvsp[-1].name, yyvsp[0].nodeData );
1551  }
1552  break;
1553 
1554  case 66:
1555 #line 364 "gram.y"
1556  {
1557  yyval.nodeData = yyvsp[-1].nodeData;
1558  }
1559  break;
1560 
1561  case 68:
1562 #line 380 "gram.y"
1563  {
1564  yyval.nodeData = syck_new_map(
1565  syck_hdlr_add_node( (SyckParser *)parser, yyvsp[-2].nodeData ),
1566  syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData ) );
1567  }
1568  break;
1569 
1570  case 70:
1571 #line 398 "gram.y"
1572  {
1573  if ( yyvsp[-2].nodeData->shortcut == NULL )
1574  {
1575  yyvsp[-2].nodeData->shortcut = syck_new_seq( yyvsp[0].nodeId );
1576  }
1577  else
1578  {
1579  syck_seq_add( yyvsp[-2].nodeData->shortcut, yyvsp[0].nodeId );
1580  }
1581  yyval.nodeData = yyvsp[-2].nodeData;
1582  }
1583  break;
1584 
1585  case 71:
1586 #line 410 "gram.y"
1587  {
1588  apply_seq_in_map( (SyckParser *)parser, yyvsp[-2].nodeData );
1589  syck_map_update( yyvsp[-2].nodeData, yyvsp[0].nodeData );
1590  syck_free_node( yyvsp[0].nodeData );
1591  yyvsp[0].nodeData = NULL;
1592  yyval.nodeData = yyvsp[-2].nodeData;
1593  }
1594  break;
1595 
1596  case 72:
1597 #line 418 "gram.y"
1598  {
1599  yyval.nodeData = yyvsp[-1].nodeData;
1600  }
1601  break;
1602 
1603  case 73:
1604 #line 427 "gram.y"
1605  {
1606  yyval.nodeData = syck_new_map(
1607  syck_hdlr_add_node( (SyckParser *)parser, yyvsp[-2].nodeData ),
1608  syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData ) );
1609  }
1610  break;
1611 
1612  case 74:
1613 #line 435 "gram.y"
1614  {
1615  yyval.nodeData = yyvsp[-1].nodeData;
1616  }
1617  break;
1618 
1619  case 75:
1620 #line 439 "gram.y"
1621  {
1622  yyval.nodeData = syck_alloc_map();
1623  }
1624  break;
1625 
1626  case 77:
1627 #line 446 "gram.y"
1628  {
1629  syck_map_update( yyvsp[-2].nodeData, yyvsp[0].nodeData );
1630  syck_free_node( yyvsp[0].nodeData );
1631  yyvsp[0].nodeData = NULL;
1632  yyval.nodeData = yyvsp[-2].nodeData;
1633  }
1634  break;
1635 
1636  case 78:
1637 #line 455 "gram.y"
1638  {
1639  NULL_NODE( parser, n );
1640  yyval.nodeData = syck_new_map(
1641  syck_hdlr_add_node( (SyckParser *)parser, yyvsp[0].nodeData ),
1642  syck_hdlr_add_node( (SyckParser *)parser, n ) );
1643  }
1644  break;
1645 
1646 
1647  }
1648 
1649 /* Line 1010 of yacc.c. */
1650 #line 1651 "gram.c"
1651 
1652  yyvsp -= yylen;
1653  yyssp -= yylen;
1654 
1655 
1656  YY_STACK_PRINT (yyss, yyssp);
1657 
1658  *++yyvsp = yyval;
1659 
1660 
1661  /* Now `shift' the result of the reduction. Determine what state
1662  that goes to, based on the state we popped back to and the rule
1663  number reduced by. */
1664 
1665  yyn = yyr1[yyn];
1666 
1667  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1668  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1669  yystate = yytable[yystate];
1670  else
1671  yystate = yydefgoto[yyn - YYNTOKENS];
1672 
1673  goto yynewstate;
1674 
1675 
1676 /*------------------------------------.
1677 | yyerrlab -- here on detecting error |
1678 `------------------------------------*/
1679 yyerrlab:
1680  /* If not already recovering from an error, report this error. */
1681  if (!yyerrstatus)
1682  {
1683  ++yynerrs;
1684 #if YYERROR_VERBOSE
1685  yyn = yypact[yystate];
1686 
1687  if (YYPACT_NINF < yyn && yyn < YYLAST)
1688  {
1689  YYSIZE_T yysize = 0;
1690  int yytype = YYTRANSLATE (yychar);
1691  const char* yyprefix;
1692  char *yymsg;
1693  int yyx;
1694 
1695  /* Start YYX at -YYN if negative to avoid negative indexes in
1696  YYCHECK. */
1697  int yyxbegin = yyn < 0 ? -yyn : 0;
1698 
1699  /* Stay within bounds of both yycheck and yytname. */
1700  int yychecklim = YYLAST - yyn;
1701  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1702  int yycount = 0;
1703 
1704  yyprefix = ", expecting ";
1705  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1706  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1707  {
1708  yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
1709  yycount += 1;
1710  if (yycount == 5)
1711  {
1712  yysize = 0;
1713  break;
1714  }
1715  }
1716  yysize += (sizeof ("syntax error, unexpected ")
1717  + yystrlen (yytname[yytype]));
1718  yymsg = (char *) YYSTACK_ALLOC (yysize);
1719  if (yymsg != 0)
1720  {
1721  char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1722  yyp = yystpcpy (yyp, yytname[yytype]);
1723 
1724  if (yycount < 5)
1725  {
1726  yyprefix = ", expecting ";
1727  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1728  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1729  {
1730  yyp = yystpcpy (yyp, yyprefix);
1731  yyp = yystpcpy (yyp, yytname[yyx]);
1732  yyprefix = " or ";
1733  }
1734  }
1735  yyerror (yymsg);
1736  YYSTACK_FREE (yymsg);
1737  }
1738  else
1739  yyerror ("syntax error; also virtual memory exhausted");
1740  }
1741  else
1742 #endif /* YYERROR_VERBOSE */
1743  yyerror ("syntax error");
1744  }
1745 
1746 
1747 
1748  if (yyerrstatus == 3)
1749  {
1750  /* If just tried and failed to reuse lookahead token after an
1751  error, discard it. */
1752 
1753  if (yychar <= YYEOF)
1754  {
1755  /* If at end of input, pop the error token,
1756  then the rest of the stack, then return failure. */
1757  if (yychar == YYEOF)
1758  for (;;)
1759  {
1760  YYPOPSTACK;
1761  if (yyssp == yyss)
1762  YYABORT;
1763  YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1764  yydestruct (yystos[*yyssp], yyvsp);
1765  }
1766  }
1767  else
1768  {
1769  YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
1770  yydestruct (yytoken, &yylval);
1771  yychar = YYEMPTY;
1772 
1773  }
1774  }
1775 
1776  /* Else will try to reuse lookahead token after shifting the error
1777  token. */
1778  goto yyerrlab1;
1779 
1780 
1781 /*---------------------------------------------------.
1782 | yyerrorlab -- error raised explicitly by YYERROR. |
1783 `---------------------------------------------------*/
1784 yyerrorlab:
1785 
1786 #ifdef __GNUC__
1787  /* Pacify GCC when the user code never invokes YYERROR and the label
1788  yyerrorlab therefore never appears in user code. */
1789  if (0)
1790  goto yyerrorlab;
1791 #endif
1792 
1793  yyvsp -= yylen;
1794  yyssp -= yylen;
1795  yystate = *yyssp;
1796  goto yyerrlab1;
1797 
1798 
1799 /*-------------------------------------------------------------.
1800 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1801 `-------------------------------------------------------------*/
1802 yyerrlab1:
1803  yyerrstatus = 3; /* Each real token shifted decrements this. */
1804 
1805  for (;;)
1806  {
1807  yyn = yypact[yystate];
1808  if (yyn != YYPACT_NINF)
1809  {
1810  yyn += YYTERROR;
1811  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1812  {
1813  yyn = yytable[yyn];
1814  if (0 < yyn)
1815  break;
1816  }
1817  }
1818 
1819  /* Pop the current state because it cannot handle the error token. */
1820  if (yyssp == yyss)
1821  YYABORT;
1822 
1823  YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1824  yydestruct (yystos[yystate], yyvsp);
1825  YYPOPSTACK;
1826  yystate = *yyssp;
1827  YY_STACK_PRINT (yyss, yyssp);
1828  }
1829 
1830  if (yyn == YYFINAL)
1831  YYACCEPT;
1832 
1833  YYDPRINTF ((stderr, "Shifting error token, "));
1834 
1835  *++yyvsp = yylval;
1836 
1837 
1838  yystate = yyn;
1839  goto yynewstate;
1840 
1841 
1842 /*-------------------------------------.
1843 | yyacceptlab -- YYACCEPT comes here. |
1844 `-------------------------------------*/
1845 yyacceptlab:
1846  yyresult = 0;
1847  goto yyreturn;
1848 
1849 /*-----------------------------------.
1850 | yyabortlab -- YYABORT comes here. |
1851 `-----------------------------------*/
1852 yyabortlab:
1853  yyresult = 1;
1854  goto yyreturn;
1855 
1856 #ifndef yyoverflow
1857 /*----------------------------------------------.
1858 | yyoverflowlab -- parser overflow comes here. |
1859 `----------------------------------------------*/
1860 yyoverflowlab:
1861  yyerror ("parser stack overflow");
1862  yyresult = 2;
1863  /* Fall through. */
1864 #endif
1865 
1866 yyreturn:
1867 #ifndef yyoverflow
1868  if (yyss != yyssa)
1869  YYSTACK_FREE (yyss);
1870 #endif
1871  return yyresult;
1872 }
1873 
1874 
1875 #line 464 "gram.y"
1876 
1877 
1878 void
1880 {
1881  long map_len;
1882  if ( n->shortcut == NULL )
1883  {
1884  return;
1885  }
1886 
1887  map_len = syck_map_count( n );
1888  syck_map_assign( n, map_value, map_len - 1,
1889  syck_hdlr_add_node( parser, n->shortcut ) );
1890 
1891  n->shortcut = NULL;
1892 }
1893 
1894 
1895