QJson project page QJson home page

json_parser.cc
1 /* A Bison parser, made by GNU Bison 2.3. */
2 
3 /* Skeleton implementation for Bison LALR(1) parsers in C++
4 
5  Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
6 
7  This program is free software; you can redistribute it and/or modify
8  it under the terms of the GNU General Public License as published by
9  the Free Software Foundation; either version 2, or (at your option)
10  any later version.
11 
12  This program is distributed in the hope that it will be useful,
13  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  GNU General Public License for more details.
16 
17  You should have received a copy of the GNU General Public License
18  along with this program; if not, write to the Free Software
19  Foundation, Inc., 51 Franklin Street, Fifth Floor,
20  Boston, MA 02110-1301, USA. */
21 
22 /* As a special exception, you may create a larger work that contains
23  part or all of the Bison parser skeleton and distribute that work
24  under terms of your choice, so long as that work isn't itself a
25  parser generator using the skeleton or a modified version thereof
26  as a parser skeleton. Alternatively, if you modify or redistribute
27  the parser skeleton itself, you may (at your option) remove this
28  special exception, which will cause the skeleton and the resulting
29  Bison output files to be licensed under the GNU General Public
30  License without this special exception.
31 
32  This special exception was added by the Free Software Foundation in
33  version 2.2 of Bison. */
34 
35 
36 #include "json_parser.hh"
37 
38 /* User implementation prologue. */
39 
40 
41 /* Line 317 of lalr1.cc. */
42 #line 43 "json_parser.cc"
43 
44 #ifndef YY_
45 # if defined YYENABLE_NLS && YYENABLE_NLS
46 # if ENABLE_NLS
47 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
48 # define YY_(msgid) dgettext ("bison-runtime", msgid)
49 # endif
50 # endif
51 # ifndef YY_
52 # define YY_(msgid) msgid
53 # endif
54 #endif
55 
56 /* Suppress unused-variable warnings by "using" E. */
57 #define YYUSE(e) ((void) (e))
58 
59 /* A pseudo ostream that takes yydebug_ into account. */
60 # define YYCDEBUG \
61  for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false) \
62  (*yycdebug_)
63 
64 /* Enable debugging if requested. */
65 #if YYDEBUG
66 
67 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
68 do { \
69  if (yydebug_) \
70  { \
71  *yycdebug_ << Title << ' '; \
72  yy_symbol_print_ ((Type), (Value), (Location)); \
73  *yycdebug_ << std::endl; \
74  } \
75 } while (false)
76 
77 # define YY_REDUCE_PRINT(Rule) \
78 do { \
79  if (yydebug_) \
80  yy_reduce_print_ (Rule); \
81 } while (false)
82 
83 # define YY_STACK_PRINT() \
84 do { \
85  if (yydebug_) \
86  yystack_print_ (); \
87 } while (false)
88 
89 #else /* !YYDEBUG */
90 
91 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
92 # define YY_REDUCE_PRINT(Rule)
93 # define YY_STACK_PRINT()
94 
95 #endif /* !YYDEBUG */
96 
97 #define YYACCEPT goto yyacceptlab
98 #define YYABORT goto yyabortlab
99 #define YYERROR goto yyerrorlab
100 
101 namespace yy
102 {
103 #if YYERROR_VERBOSE
104 
105  /* Return YYSTR after stripping away unnecessary quotes and
106  backslashes, so that it's suitable for yyerror. The heuristic is
107  that double-quoting is unnecessary unless the string contains an
108  apostrophe, a comma, or backslash (other than backslash-backslash).
109  YYSTR is taken from yytname. */
110  std::string
111  json_parser::yytnamerr_ (const char *yystr)
112  {
113  if (*yystr == '"')
114  {
115  std::string yyr = "";
116  char const *yyp = yystr;
117 
118  for (;;)
119  switch (*++yyp)
120  {
121  case '\'':
122  case ',':
123  goto do_not_strip_quotes;
124 
125  case '\\':
126  if (*++yyp != '\\')
127  goto do_not_strip_quotes;
128  /* Fall through. */
129  default:
130  yyr += *yyp;
131  break;
132 
133  case '"':
134  return yyr;
135  }
136  do_not_strip_quotes: ;
137  }
138 
139  return yystr;
140  }
141 
142 #endif
143 
145  json_parser::json_parser (QJson::ParserPrivate* driver_yyarg)
146  : yydebug_ (false),
147  yycdebug_ (&std::cerr),
148  driver (driver_yyarg)
149  {
150  }
151 
152  json_parser::~json_parser ()
153  {
154  }
155 
156 #if YYDEBUG
157  /*--------------------------------.
158  | Print this symbol on YYOUTPUT. |
159  `--------------------------------*/
160 
161  inline void
162  json_parser::yy_symbol_value_print_ (int yytype,
163  const semantic_type* yyvaluep, const location_type* yylocationp)
164  {
165  YYUSE (yylocationp);
166  YYUSE (yyvaluep);
167  switch (yytype)
168  {
169  default:
170  break;
171  }
172  }
173 
174 
175  void
176  json_parser::yy_symbol_print_ (int yytype,
177  const semantic_type* yyvaluep, const location_type* yylocationp)
178  {
179  *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
180  << ' ' << yytname_[yytype] << " ("
181  << *yylocationp << ": ";
182  yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);
183  *yycdebug_ << ')';
184  }
185 #endif /* ! YYDEBUG */
186 
187  void
188  json_parser::yydestruct_ (const char* yymsg,
189  int yytype, semantic_type* yyvaluep, location_type* yylocationp)
190  {
191  YYUSE (yylocationp);
192  YYUSE (yymsg);
193  YYUSE (yyvaluep);
194 
195  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
196 
197  switch (yytype)
198  {
199 
200  default:
201  break;
202  }
203  }
204 
205  void
206  json_parser::yypop_ (unsigned int n)
207  {
208  yystate_stack_.pop (n);
209  yysemantic_stack_.pop (n);
210  yylocation_stack_.pop (n);
211  }
212 
213  std::ostream&
215  {
216  return *yycdebug_;
217  }
218 
219  void
221  {
222  yycdebug_ = &o;
223  }
224 
225 
228  {
229  return yydebug_;
230  }
231 
232  void
234  {
235  yydebug_ = l;
236  }
237 
238 
239  int
241  {
243  int yychar = yyempty_;
244  int yytoken = 0;
245 
246  /* State. */
247  int yyn;
248  int yylen = 0;
249  int yystate = 0;
250 
251  /* Error handling. */
252  int yynerrs_ = 0;
253  int yyerrstatus_ = 0;
254 
256  semantic_type yylval;
258  location_type yylloc;
260  location yyerror_range[2];
261 
263  semantic_type yyval;
265  location_type yyloc;
266 
267  int yyresult;
268 
269  YYCDEBUG << "Starting parse" << std::endl;
270 
271 
272  /* Initialize the stacks. The initial state will be pushed in
273  yynewstate, since the latter expects the semantical and the
274  location values to have been already stored, initialize these
275  stacks with a primary value. */
276  yystate_stack_ = state_stack_type (0);
277  yysemantic_stack_ = semantic_stack_type (0);
278  yylocation_stack_ = location_stack_type (0);
279  yysemantic_stack_.push (yylval);
280  yylocation_stack_.push (yylloc);
281 
282  /* New state. */
283  yynewstate:
284  yystate_stack_.push (yystate);
285  YYCDEBUG << "Entering state " << yystate << std::endl;
286  goto yybackup;
287 
288  /* Backup. */
289  yybackup:
290 
291  /* Try to take a decision without look-ahead. */
292  yyn = yypact_[yystate];
293  if (yyn == yypact_ninf_)
294  goto yydefault;
295 
296  /* Read a look-ahead token. */
297  if (yychar == yyempty_)
298  {
299  YYCDEBUG << "Reading a token: ";
300  yychar = yylex (&yylval, &yylloc, driver);
301  }
302 
303 
304  /* Convert token to internal form. */
305  if (yychar <= yyeof_)
306  {
307  yychar = yytoken = yyeof_;
308  YYCDEBUG << "Now at end of input." << std::endl;
309  }
310  else
311  {
312  yytoken = yytranslate_ (yychar);
313  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
314  }
315 
316  /* If the proper action on seeing token YYTOKEN is to reduce or to
317  detect an error, take that action. */
318  yyn += yytoken;
319  if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
320  goto yydefault;
321 
322  /* Reduce or error. */
323  yyn = yytable_[yyn];
324  if (yyn <= 0)
325  {
326  if (yyn == 0 || yyn == yytable_ninf_)
327  goto yyerrlab;
328  yyn = -yyn;
329  goto yyreduce;
330  }
331 
332  /* Accept? */
333  if (yyn == yyfinal_)
334  goto yyacceptlab;
335 
336  /* Shift the look-ahead token. */
337  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
338 
339  /* Discard the token being shifted unless it is eof. */
340  if (yychar != yyeof_)
341  yychar = yyempty_;
342 
343  yysemantic_stack_.push (yylval);
344  yylocation_stack_.push (yylloc);
345 
346  /* Count tokens shifted since error; after three, turn off error
347  status. */
348  if (yyerrstatus_)
349  --yyerrstatus_;
350 
351  yystate = yyn;
352  goto yynewstate;
353 
354  /*-----------------------------------------------------------.
355  | yydefault -- do the default action for the current state. |
356  `-----------------------------------------------------------*/
357  yydefault:
358  yyn = yydefact_[yystate];
359  if (yyn == 0)
360  goto yyerrlab;
361  goto yyreduce;
362 
363  /*-----------------------------.
364  | yyreduce -- Do a reduction. |
365  `-----------------------------*/
366  yyreduce:
367  yylen = yyr2_[yyn];
368  /* If YYLEN is nonzero, implement the default value of the action:
369  `$$ = $1'. Otherwise, use the top of the stack.
370 
371  Otherwise, the following line sets YYVAL to garbage.
372  This behavior is undocumented and Bison
373  users should not rely upon it. */
374  if (yylen)
375  yyval = yysemantic_stack_[yylen - 1];
376  else
377  yyval = yysemantic_stack_[0];
378 
379  {
380  slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
381  YYLLOC_DEFAULT (yyloc, slice, yylen);
382  }
383  YY_REDUCE_PRINT (yyn);
384  switch (yyn)
385  {
386  case 2:
387 #line 80 "json_parser.yy"
388  {
389  driver->m_result = (yysemantic_stack_[(1) - (1)]);
390  qjsonDebug() << "json_parser - parsing finished";
391  ;}
392  break;
393 
394  case 3:
395 #line 85 "json_parser.yy"
396  {(yyval) = (yysemantic_stack_[(1) - (1)]); ;}
397  break;
398 
399  case 4:
400 #line 86 "json_parser.yy"
401  {(yyval) = (yysemantic_stack_[(1) - (1)]); ;}
402  break;
403 
404  case 5:
405 #line 88 "json_parser.yy"
406  {
407  qCritical()<< "json_parser - syntax error found, "
408  << "forcing abort";
409  YYABORT;
410  ;}
411  break;
412 
413  case 7:
414 #line 95 "json_parser.yy"
415  { (yyval) = (yysemantic_stack_[(3) - (2)]); ;}
416  break;
417 
418  case 8:
419 #line 97 "json_parser.yy"
420  { (yyval) = QVariant (QVariantMap()); ;}
421  break;
422 
423  case 9:
424 #line 98 "json_parser.yy"
425  {
426  QVariantMap members = (yysemantic_stack_[(2) - (2)]).toMap();
427  (yysemantic_stack_[(2) - (2)]) = QVariant(); // Allow reuse of map
428  (yyval) = QVariant(members.unite ((yysemantic_stack_[(2) - (1)]).toMap()));
429  ;}
430  break;
431 
432  case 10:
433 #line 104 "json_parser.yy"
434  { (yyval) = QVariant (QVariantMap()); ;}
435  break;
436 
437  case 11:
438 #line 105 "json_parser.yy"
439  {
440  QVariantMap members = (yysemantic_stack_[(3) - (3)]).toMap();
441  (yysemantic_stack_[(3) - (3)]) = QVariant(); // Allow reuse of map
442  (yyval) = QVariant(members.unite ((yysemantic_stack_[(3) - (2)]).toMap()));
443  ;}
444  break;
445 
446  case 12:
447 #line 111 "json_parser.yy"
448  {
449  QVariantMap pair;
450  pair.insert ((yysemantic_stack_[(3) - (1)]).toString(), QVariant((yysemantic_stack_[(3) - (3)])));
451  (yyval) = QVariant (pair);
452  ;}
453  break;
454 
455  case 13:
456 #line 117 "json_parser.yy"
457  { (yyval) = (yysemantic_stack_[(3) - (2)]); ;}
458  break;
459 
460  case 14:
461 #line 119 "json_parser.yy"
462  { (yyval) = QVariant (QVariantList()); ;}
463  break;
464 
465  case 15:
466 #line 120 "json_parser.yy"
467  {
468  QVariantList members = (yysemantic_stack_[(2) - (2)]).toList();
469  (yysemantic_stack_[(2) - (2)]) = QVariant(); // Allow reuse of list
470  members.prepend ((yysemantic_stack_[(2) - (1)]));
471  (yyval) = QVariant(members);
472  ;}
473  break;
474 
475  case 16:
476 #line 127 "json_parser.yy"
477  { (yyval) = QVariant (QVariantList()); ;}
478  break;
479 
480  case 17:
481 #line 128 "json_parser.yy"
482  {
483  QVariantList members = (yysemantic_stack_[(3) - (3)]).toList();
484  (yysemantic_stack_[(3) - (3)]) = QVariant(); // Allow reuse of list
485  members.prepend ((yysemantic_stack_[(3) - (2)]));
486  (yyval) = QVariant(members);
487  ;}
488  break;
489 
490  case 18:
491 #line 135 "json_parser.yy"
492  { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
493  break;
494 
495  case 19:
496 #line 136 "json_parser.yy"
497  { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
498  break;
499 
500  case 20:
501 #line 137 "json_parser.yy"
502  { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
503  break;
504 
505  case 21:
506 #line 138 "json_parser.yy"
507  { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
508  break;
509 
510  case 22:
511 #line 139 "json_parser.yy"
512  { (yyval) = QVariant (true); ;}
513  break;
514 
515  case 23:
516 #line 140 "json_parser.yy"
517  { (yyval) = QVariant (false); ;}
518  break;
519 
520  case 24:
521 #line 141 "json_parser.yy"
522  {
523  QVariant null_variant;
524  (yyval) = null_variant;
525  ;}
526  break;
527 
528  case 25:
529 #line 146 "json_parser.yy"
530  {
531  if ((yysemantic_stack_[(1) - (1)]).toByteArray().startsWith('-')) {
532  (yyval) = QVariant (QVariant::LongLong);
533  (yyval).setValue((yysemantic_stack_[(1) - (1)]).toLongLong());
534  }
535  else {
536  (yyval) = QVariant (QVariant::ULongLong);
537  (yyval).setValue((yysemantic_stack_[(1) - (1)]).toULongLong());
538  }
539  ;}
540  break;
541 
542  case 26:
543 #line 156 "json_parser.yy"
544  {
545  const QByteArray value = (yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray();
546  (yyval) = QVariant(QVariant::Double);
547  (yyval).setValue(value.toDouble());
548  ;}
549  break;
550 
551  case 27:
552 #line 161 "json_parser.yy"
553  { (yyval) = QVariant ((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray()); ;}
554  break;
555 
556  case 28:
557 #line 162 "json_parser.yy"
558  {
559  const QByteArray value = (yysemantic_stack_[(3) - (1)]).toByteArray() + (yysemantic_stack_[(3) - (2)]).toByteArray() + (yysemantic_stack_[(3) - (3)]).toByteArray();
560  (yyval) = QVariant (value);
561  ;}
562  break;
563 
564  case 29:
565 #line 167 "json_parser.yy"
566  { (yyval) = QVariant ((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray()); ;}
567  break;
568 
569  case 30:
570 #line 168 "json_parser.yy"
571  { (yyval) = QVariant (QByteArray("-") + (yysemantic_stack_[(3) - (2)]).toByteArray() + (yysemantic_stack_[(3) - (3)]).toByteArray()); ;}
572  break;
573 
574  case 31:
575 #line 170 "json_parser.yy"
576  { (yyval) = QVariant (QByteArray("")); ;}
577  break;
578 
579  case 32:
580 #line 171 "json_parser.yy"
581  {
582  (yyval) = QVariant((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray());
583  ;}
584  break;
585 
586  case 33:
587 #line 175 "json_parser.yy"
588  {
589  (yyval) = QVariant(QByteArray(".") + (yysemantic_stack_[(2) - (2)]).toByteArray());
590  ;}
591  break;
592 
593  case 34:
594 #line 179 "json_parser.yy"
595  { (yyval) = QVariant((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray()); ;}
596  break;
597 
598  case 35:
599 #line 181 "json_parser.yy"
600  { (yyval) = (yysemantic_stack_[(3) - (2)]); ;}
601  break;
602 
603  case 36:
604 #line 183 "json_parser.yy"
605  { (yyval) = QVariant (QString(QLatin1String(""))); ;}
606  break;
607 
608  case 37:
609 #line 184 "json_parser.yy"
610  {
611  (yyval) = (yysemantic_stack_[(1) - (1)]);
612  ;}
613  break;
614 
615 
616  /* Line 675 of lalr1.cc. */
617 #line 618 "json_parser.cc"
618  default: break;
619  }
620  YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
621 
622  yypop_ (yylen);
623  yylen = 0;
624  YY_STACK_PRINT ();
625 
626  yysemantic_stack_.push (yyval);
627  yylocation_stack_.push (yyloc);
628 
629  /* Shift the result of the reduction. */
630  yyn = yyr1_[yyn];
631  yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
632  if (0 <= yystate && yystate <= yylast_
633  && yycheck_[yystate] == yystate_stack_[0])
634  yystate = yytable_[yystate];
635  else
636  yystate = yydefgoto_[yyn - yyntokens_];
637  goto yynewstate;
638 
639  /*------------------------------------.
640  | yyerrlab -- here on detecting error |
641  `------------------------------------*/
642  yyerrlab:
643  /* If not already recovering from an error, report this error. */
644  if (!yyerrstatus_)
645  {
646  ++yynerrs_;
647  error (yylloc, yysyntax_error_ (yystate, yytoken));
648  }
649 
650  yyerror_range[0] = yylloc;
651  if (yyerrstatus_ == 3)
652  {
653  /* If just tried and failed to reuse look-ahead token after an
654  error, discard it. */
655 
656  if (yychar <= yyeof_)
657  {
658  /* Return failure if at end of input. */
659  if (yychar == yyeof_)
660  YYABORT;
661  }
662  else
663  {
664  yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
665  yychar = yyempty_;
666  }
667  }
668 
669  /* Else will try to reuse look-ahead token after shifting the error
670  token. */
671  goto yyerrlab1;
672 
673 
674  /*---------------------------------------------------.
675  | yyerrorlab -- error raised explicitly by YYERROR. |
676  `---------------------------------------------------*/
677  yyerrorlab:
678 
679  /* Pacify compilers like GCC when the user code never invokes
680  YYERROR and the label yyerrorlab therefore never appears in user
681  code. */
682  if (false)
683  goto yyerrorlab;
684 
685  yyerror_range[0] = yylocation_stack_[yylen - 1];
686  /* Do not reclaim the symbols of the rule which action triggered
687  this YYERROR. */
688  yypop_ (yylen);
689  yylen = 0;
690  yystate = yystate_stack_[0];
691  goto yyerrlab1;
692 
693  /*-------------------------------------------------------------.
694  | yyerrlab1 -- common code for both syntax error and YYERROR. |
695  `-------------------------------------------------------------*/
696  yyerrlab1:
697  yyerrstatus_ = 3; /* Each real token shifted decrements this. */
698 
699  for (;;)
700  {
701  yyn = yypact_[yystate];
702  if (yyn != yypact_ninf_)
703  {
704  yyn += yyterror_;
705  if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
706  {
707  yyn = yytable_[yyn];
708  if (0 < yyn)
709  break;
710  }
711  }
712 
713  /* Pop the current state because it cannot handle the error token. */
714  if (yystate_stack_.height () == 1)
715  YYABORT;
716 
717  yyerror_range[0] = yylocation_stack_[0];
718  yydestruct_ ("Error: popping",
719  yystos_[yystate],
720  &yysemantic_stack_[0], &yylocation_stack_[0]);
721  yypop_ ();
722  yystate = yystate_stack_[0];
723  YY_STACK_PRINT ();
724  }
725 
726  if (yyn == yyfinal_)
727  goto yyacceptlab;
728 
729  yyerror_range[1] = yylloc;
730  // Using YYLLOC is tempting, but would change the location of
731  // the look-ahead. YYLOC is available though.
732  YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
733  yysemantic_stack_.push (yylval);
734  yylocation_stack_.push (yyloc);
735 
736  /* Shift the error token. */
737  YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
738  &yysemantic_stack_[0], &yylocation_stack_[0]);
739 
740  yystate = yyn;
741  goto yynewstate;
742 
743  /* Accept. */
744  yyacceptlab:
745  yyresult = 0;
746  goto yyreturn;
747 
748  /* Abort. */
749  yyabortlab:
750  yyresult = 1;
751  goto yyreturn;
752 
753  yyreturn:
754  if (yychar != yyeof_ && yychar != yyempty_)
755  yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
756 
757  /* Do not reclaim the symbols of the rule which action triggered
758  this YYABORT or YYACCEPT. */
759  yypop_ (yylen);
760  while (yystate_stack_.height () != 1)
761  {
762  yydestruct_ ("Cleanup: popping",
763  yystos_[yystate_stack_[0]],
764  &yysemantic_stack_[0],
765  &yylocation_stack_[0]);
766  yypop_ ();
767  }
768 
769  return yyresult;
770  }
771 
772  // Generate an error message.
773  std::string
774  json_parser::yysyntax_error_ (int yystate, int tok)
775  {
776  std::string res;
777  YYUSE (yystate);
778 #if YYERROR_VERBOSE
779  int yyn = yypact_[yystate];
780  if (yypact_ninf_ < yyn && yyn <= yylast_)
781  {
782  /* Start YYX at -YYN if negative to avoid negative indexes in
783  YYCHECK. */
784  int yyxbegin = yyn < 0 ? -yyn : 0;
785 
786  /* Stay within bounds of both yycheck and yytname. */
787  int yychecklim = yylast_ - yyn + 1;
788  int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
789  int count = 0;
790  for (int x = yyxbegin; x < yyxend; ++x)
791  if (yycheck_[x + yyn] == x && x != yyterror_)
792  ++count;
793 
794  // FIXME: This method of building the message is not compatible
795  // with internationalization. It should work like yacc.c does it.
796  // That is, first build a string that looks like this:
797  // "syntax error, unexpected %s or %s or %s"
798  // Then, invoke YY_ on this string.
799  // Finally, use the string as a format to output
800  // yytname_[tok], etc.
801  // Until this gets fixed, this message appears in English only.
802  res = "syntax error, unexpected ";
803  res += yytnamerr_ (yytname_[tok]);
804  if (count < 5)
805  {
806  count = 0;
807  for (int x = yyxbegin; x < yyxend; ++x)
808  if (yycheck_[x + yyn] == x && x != yyterror_)
809  {
810  res += (!count++) ? ", expecting " : " or ";
811  res += yytnamerr_ (yytname_[x]);
812  }
813  }
814  }
815  else
816 #endif
817  res = YY_("syntax error");
818  return res;
819  }
820 
821 
822  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
823  STATE-NUM. */
824  const signed char json_parser::yypact_ninf_ = -18;
825  const signed char
826  json_parser::yypact_[] =
827  {
828  5, -18, -18, 1, -2, 19, -18, -18, -18, 2,
829  20, 17, 21, 16, 18, -18, -18, -18, -18, -18,
830  24, 23, -18, -8, -18, -18, -18, 15, -18, 1,
831  -18, -2, 18, 18, -18, -18, -2, -18, 18, 18,
832  22, -18, -18, 17, -18, -18, -18, 23, -18, -18,
833  -18, -18, -18
834  };
835 
836  /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
837  doesn't specify something else to do. Zero means the default is an
838  error. */
839  const unsigned char
840  json_parser::yydefact_[] =
841  {
842  0, 6, 5, 8, 14, 0, 2, 3, 4, 36,
843  0, 10, 0, 0, 31, 22, 23, 24, 20, 21,
844  0, 16, 19, 25, 18, 1, 37, 0, 7, 0,
845  9, 0, 31, 31, 29, 13, 0, 15, 31, 31,
846  26, 27, 35, 10, 12, 30, 32, 16, 33, 34,
847  28, 11, 17
848  };
849 
850  /* YYPGOTO[NTERM-NUM]. */
851  const signed char
852  json_parser::yypgoto_[] =
853  {
854  -18, -18, -18, 33, -18, -7, 6, 37, -18, -9,
855  -13, -18, -18, -17, -18, -1, -3, -18
856  };
857 
858  /* YYDEFGOTO[NTERM-NUM]. */
859  const signed char
860  json_parser::yydefgoto_[] =
861  {
862  -1, 5, 6, 18, 10, 30, 11, 19, 20, 37,
863  21, 22, 23, 34, 40, 41, 24, 27
864  };
865 
866  /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
867  positive, shift that token. If negative, reduce the rule which
868  number is the opposite. If zero, do what YYDEFACT says. */
869  const signed char json_parser::yytable_ninf_ = -1;
870  const unsigned char
871  json_parser::yytable_[] =
872  {
873  12, 3, 38, 4, 39, 1, 2, 13, 3, 14,
874  4, 15, 16, 17, 9, 45, 46, 9, 44, 25,
875  26, 48, 49, 47, 28, 29, 12, 32, 31, 33,
876  35, 36, 42, 7, 39, 43, 51, 8, 52, 50
877  };
878 
879  /* YYCHECK. */
880  const unsigned char
881  json_parser::yycheck_[] =
882  {
883  3, 3, 10, 5, 12, 0, 1, 9, 3, 11,
884  5, 13, 14, 15, 16, 32, 33, 16, 31, 0,
885  18, 38, 39, 36, 4, 8, 29, 11, 7, 11,
886  6, 8, 17, 0, 12, 29, 43, 0, 47, 40
887  };
888 
889  /* STOS_[STATE-NUM] -- The (internal number of the) accessing
890  symbol of state STATE-NUM. */
891  const unsigned char
892  json_parser::yystos_[] =
893  {
894  0, 0, 1, 3, 5, 20, 21, 22, 26, 16,
895  23, 25, 35, 9, 11, 13, 14, 15, 22, 26,
896  27, 29, 30, 31, 35, 0, 18, 36, 4, 8,
897  24, 7, 11, 11, 32, 6, 8, 28, 10, 12,
898  33, 34, 17, 25, 29, 32, 32, 29, 32, 32,
899  34, 24, 28
900  };
901 
902 #if YYDEBUG
903  /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
904  to YYLEX-NUM. */
905  const unsigned short int
906  json_parser::yytoken_number_[] =
907  {
908  0, 256, 257, 1, 2, 3, 4, 5, 6, 7,
909  8, 9, 10, 11, 12, 13, 14, 15, 16
910  };
911 #endif
912 
913  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
914  const unsigned char
915  json_parser::yyr1_[] =
916  {
917  0, 19, 20, 21, 21, 21, 21, 22, 23, 23,
918  24, 24, 25, 26, 27, 27, 28, 28, 29, 29,
919  29, 29, 29, 29, 29, 30, 30, 30, 30, 31,
920  31, 32, 32, 33, 34, 35, 36, 36
921  };
922 
923  /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
924  const unsigned char
925  json_parser::yyr2_[] =
926  {
927  0, 2, 1, 1, 1, 1, 1, 3, 0, 2,
928  0, 3, 3, 3, 0, 2, 0, 3, 1, 1,
929  1, 1, 1, 1, 1, 1, 2, 2, 3, 2,
930  3, 0, 2, 2, 2, 3, 0, 1
931  };
932 
933 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
934  /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
935  First, the terminals, then, starting at \a yyntokens_, nonterminals. */
936  const char*
937  const json_parser::yytname_[] =
938  {
939  "\"end of file\"", "error", "$undefined", "\"{\"", "\"}\"", "\"[\"",
940  "\"]\"", "\":\"", "\",\"", "\"-\"", "\".\"", "\"digit\"",
941  "\"exponential\"", "\"true\"", "\"false\"", "\"null\"",
942  "\"open quotation mark\"", "\"close quotation mark\"", "\"string\"",
943  "$accept", "start", "data", "object", "members", "r_members", "pair",
944  "array", "values", "r_values", "value", "number", "int", "digits",
945  "fract", "exp", "string", "string_arg", 0
946  };
947 #endif
948 
949 #if YYDEBUG
950  /* YYRHS -- A `-1'-separated list of the rules' RHS. */
951  const json_parser::rhs_number_type
952  json_parser::yyrhs_[] =
953  {
954  20, 0, -1, 21, -1, 22, -1, 26, -1, 1,
955  -1, 0, -1, 3, 23, 4, -1, -1, 25, 24,
956  -1, -1, 8, 25, 24, -1, 35, 7, 29, -1,
957  5, 27, 6, -1, -1, 29, 28, -1, -1, 8,
958  29, 28, -1, 35, -1, 30, -1, 22, -1, 26,
959  -1, 13, -1, 14, -1, 15, -1, 31, -1, 31,
960  33, -1, 31, 34, -1, 31, 33, 34, -1, 11,
961  32, -1, 9, 11, 32, -1, -1, 11, 32, -1,
962  10, 32, -1, 12, 32, -1, 16, 36, 17, -1,
963  -1, 18, -1
964  };
965 
966  /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
967  YYRHS. */
968  const unsigned char
969  json_parser::yyprhs_[] =
970  {
971  0, 0, 3, 5, 7, 9, 11, 13, 17, 18,
972  21, 22, 26, 30, 34, 35, 38, 39, 43, 45,
973  47, 49, 51, 53, 55, 57, 59, 62, 65, 69,
974  72, 76, 77, 80, 83, 86, 90, 91
975  };
976 
977  /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
978  const unsigned char
979  json_parser::yyrline_[] =
980  {
981  0, 80, 80, 85, 86, 87, 93, 95, 97, 98,
982  104, 105, 111, 117, 119, 120, 127, 128, 135, 136,
983  137, 138, 139, 140, 141, 146, 156, 161, 162, 167,
984  168, 170, 171, 175, 179, 181, 183, 184
985  };
986 
987  // Print the state stack on the debug stream.
988  void
989  json_parser::yystack_print_ ()
990  {
991  *yycdebug_ << "Stack now";
992  for (state_stack_type::const_iterator i = yystate_stack_.begin ();
993  i != yystate_stack_.end (); ++i)
994  *yycdebug_ << ' ' << *i;
995  *yycdebug_ << std::endl;
996  }
997 
998  // Report on the debug stream that the rule \a yyrule is going to be reduced.
999  void
1000  json_parser::yy_reduce_print_ (int yyrule)
1001  {
1002  unsigned int yylno = yyrline_[yyrule];
1003  int yynrhs = yyr2_[yyrule];
1004  /* Print the symbols being reduced, and their result. */
1005  *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1006  << " (line " << yylno << "), ";
1007  /* The symbols being reduced. */
1008  for (int yyi = 0; yyi < yynrhs; yyi++)
1009  YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
1010  yyrhs_[yyprhs_[yyrule] + yyi],
1011  &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
1012  &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
1013  }
1014 #endif // YYDEBUG
1015 
1016  /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1017  json_parser::token_number_type
1018  json_parser::yytranslate_ (int t)
1019  {
1020  static
1021  const token_number_type
1022  translate_table[] =
1023  {
1024  0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
1025  12, 13, 14, 15, 16, 17, 18, 2, 2, 2,
1026  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1027  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1028  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1029  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1030  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1031  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1032  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1033  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1034  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1035  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1036  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1037  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1038  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1039  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1040  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1041  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1042  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1043  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1044  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1045  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1046  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1047  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1048  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1049  2, 2, 2, 2, 2, 2, 1, 2
1050  };
1051  if ((unsigned int) t <= yyuser_token_number_max_)
1052  return translate_table[t];
1053  else
1054  return yyundef_token_;
1055  }
1056 
1057  const int json_parser::yyeof_ = 0;
1058  const int json_parser::yylast_ = 39;
1059  const int json_parser::yynnts_ = 18;
1060  const int json_parser::yyempty_ = -2;
1061  const int json_parser::yyfinal_ = 25;
1062  const int json_parser::yyterror_ = 1;
1063  const int json_parser::yyerrcode_ = 256;
1064  const int json_parser::yyntokens_ = 19;
1065 
1066  const unsigned int json_parser::yyuser_token_number_max_ = 257;
1067  const json_parser::token_number_type json_parser::yyundef_token_ = 2;
1068 
1069 } // namespace yy
1070 
1071 #line 188 "json_parser.yy"
1072 
1073 
1074 int yy::yylex(YYSTYPE *yylval, yy::location *yylloc, QJson::ParserPrivate* driver)
1075 {
1076  JSonScanner* scanner = driver->m_scanner;
1077  yylval->clear();
1078  int ret = scanner->yylex(yylval, yylloc);
1079 
1080  qjsonDebug() << "json_parser::yylex - calling scanner yylval==|"
1081  << yylval->toByteArray() << "|, ret==|" << QString::number(ret) << "|";
1082 
1083  return ret;
1084 }
1085 
1086 void yy::json_parser::error (const yy::location& yyloc,
1087  const std::string& error)
1088 {
1089  /*qjsonDebug() << yyloc.begin.line;
1090  qjsonDebug() << yyloc.begin.column;
1091  qjsonDebug() << yyloc.end.line;
1092  qjsonDebug() << yyloc.end.column;*/
1093  qjsonDebug() << "json_parser::error [line" << yyloc.end.line << "] -" << error.c_str() ;
1094  driver->setError(QString::fromLatin1(error.c_str()), yyloc.end.line);
1095 }
1096 

SourceForge Logo hosts this site. Send comments to:
QJson Developers