1 /* A Bison parser, made by GNU Bison 2.3. */
3 /* Skeleton implementation for Bison LALR(1) parsers in C++
5 Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
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)
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.
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. */
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.
32 This special exception was added by the Free Software Foundation in
33 version 2.2 of Bison. */
36 #include "json_parser.hh"
38 /* User implementation prologue. */
41 /* Line 317 of lalr1.cc. */
42 #line 43 "json_parser.cc"
47 # include <libintl.h> /* FIXME: INFRINGES ON USER NAME SPACE */
48 # define YY_(msgid) dgettext ("bison-runtime", msgid)
52 # define YY_(msgid) msgid
56 /* Suppress unused-variable warnings by "using" E. */
57 #define YYUSE(e) ((void) (e))
59 /* A pseudo ostream that takes yydebug_ into account. */
61 for (bool yydebugcond_ = yydebug_; yydebugcond_; yydebugcond_ = false) \
64 /* Enable debugging if requested. */
67 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
71 *yycdebug_ << Title << ' '; \
72 yy_symbol_print_ ((Type), (Value), (Location)); \
73 *yycdebug_ << std::endl; \
77 # define YY_REDUCE_PRINT(Rule) \
80 yy_reduce_print_ (Rule); \
83 # define YY_STACK_PRINT() \
91 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
92 # define YY_REDUCE_PRINT(Rule)
93 # define YY_STACK_PRINT()
97 #define YYACCEPT goto yyacceptlab
98 #define YYABORT goto yyabortlab
99 #define YYERROR goto yyerrorlab
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. */
111 json_parser::yytnamerr_ (const char *yystr)
115 std::string yyr = "";
116 char const *yyp = yystr;
123 goto do_not_strip_quotes;
127 goto do_not_strip_quotes;
136 do_not_strip_quotes: ;
144 /// Build a parser object.
145 json_parser::json_parser (QJson::ParserPrivate* driver_yyarg)
147 yycdebug_ (&std::cerr),
148 driver (driver_yyarg)
152 json_parser::~json_parser ()
157 /*--------------------------------.
158 | Print this symbol on YYOUTPUT. |
159 `--------------------------------*/
162 json_parser::yy_symbol_value_print_ (int yytype,
163 const semantic_type* yyvaluep, const location_type* yylocationp)
176 json_parser::yy_symbol_print_ (int yytype,
177 const semantic_type* yyvaluep, const location_type* yylocationp)
179 *yycdebug_ << (yytype < yyntokens_ ? "token" : "nterm")
180 << ' ' << yytname_[yytype] << " ("
181 << *yylocationp << ": ";
182 yy_symbol_value_print_ (yytype, yyvaluep, yylocationp);
185 #endif /* ! YYDEBUG */
188 json_parser::yydestruct_ (const char* yymsg,
189 int yytype, semantic_type* yyvaluep, location_type* yylocationp)
195 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
206 json_parser::yypop_ (unsigned int n)
208 yystate_stack_.pop (n);
209 yysemantic_stack_.pop (n);
210 yylocation_stack_.pop (n);
214 json_parser::debug_stream () const
220 json_parser::set_debug_stream (std::ostream& o)
226 json_parser::debug_level_type
227 json_parser::debug_level () const
233 json_parser::set_debug_level (debug_level_type l)
240 json_parser::parse ()
242 /// Look-ahead and look-ahead in internal form.
243 int yychar = yyempty_;
251 /* Error handling. */
253 int yyerrstatus_ = 0;
255 /// Semantic value of the look-ahead.
256 semantic_type yylval;
257 /// Location of the look-ahead.
258 location_type yylloc;
259 /// The locations where the error started and ended.
260 location yyerror_range[2];
269 YYCDEBUG << "Starting parse" << std::endl;
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);
284 yystate_stack_.push (yystate);
285 YYCDEBUG << "Entering state " << yystate << std::endl;
291 /* Try to take a decision without look-ahead. */
292 yyn = yypact_[yystate];
293 if (yyn == yypact_ninf_)
296 /* Read a look-ahead token. */
297 if (yychar == yyempty_)
299 YYCDEBUG << "Reading a token: ";
300 yychar = yylex (&yylval, &yylloc, driver);
304 /* Convert token to internal form. */
305 if (yychar <= yyeof_)
307 yychar = yytoken = yyeof_;
308 YYCDEBUG << "Now at end of input." << std::endl;
312 yytoken = yytranslate_ (yychar);
313 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
316 /* If the proper action on seeing token YYTOKEN is to reduce or to
317 detect an error, take that action. */
319 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
322 /* Reduce or error. */
326 if (yyn == 0 || yyn == yytable_ninf_)
336 /* Shift the look-ahead token. */
337 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
339 /* Discard the token being shifted unless it is eof. */
340 if (yychar != yyeof_)
343 yysemantic_stack_.push (yylval);
344 yylocation_stack_.push (yylloc);
346 /* Count tokens shifted since error; after three, turn off error
354 /*-----------------------------------------------------------.
355 | yydefault -- do the default action for the current state. |
356 `-----------------------------------------------------------*/
358 yyn = yydefact_[yystate];
363 /*-----------------------------.
364 | yyreduce -- Do a reduction. |
365 `-----------------------------*/
368 /* If YYLEN is nonzero, implement the default value of the action:
369 `$$ = $1'. Otherwise, use the top of the stack.
371 Otherwise, the following line sets YYVAL to garbage.
372 This behavior is undocumented and Bison
373 users should not rely upon it. */
375 yyval = yysemantic_stack_[yylen - 1];
377 yyval = yysemantic_stack_[0];
380 slice<location_type, location_stack_type> slice (yylocation_stack_, yylen);
381 YYLLOC_DEFAULT (yyloc, slice, yylen);
383 YY_REDUCE_PRINT (yyn);
387 #line 84 "json_parser.yy"
389 driver->m_result = (yysemantic_stack_[(1) - (1)]);
390 qjsonDebug() << "json_parser - parsing finished";
395 #line 89 "json_parser.yy"
396 { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
400 #line 91 "json_parser.yy"
402 qCritical()<< "json_parser - syntax error found, "
403 << "forcing abort, Line" << (yyloc).begin.line << "Column" << (yyloc).begin.column;
409 #line 98 "json_parser.yy"
410 { (yyval) = (yysemantic_stack_[(3) - (2)]); ;}
414 #line 100 "json_parser.yy"
415 { (yyval) = QVariant (QVariantMap()); ;}
419 #line 101 "json_parser.yy"
421 QVariantMap members = (yysemantic_stack_[(2) - (2)]).toMap();
422 (yysemantic_stack_[(2) - (2)]) = QVariant(); // Allow reuse of map
423 (yyval) = QVariant(members.unite ((yysemantic_stack_[(2) - (1)]).toMap()));
428 #line 107 "json_parser.yy"
429 { (yyval) = QVariant (QVariantMap()); ;}
433 #line 108 "json_parser.yy"
435 QVariantMap members = (yysemantic_stack_[(3) - (3)]).toMap();
436 (yysemantic_stack_[(3) - (3)]) = QVariant(); // Allow reuse of map
437 (yyval) = QVariant(members.unite ((yysemantic_stack_[(3) - (2)]).toMap()));
442 #line 114 "json_parser.yy"
445 pair.insert ((yysemantic_stack_[(3) - (1)]).toString(), QVariant((yysemantic_stack_[(3) - (3)])));
446 (yyval) = QVariant (pair);
451 #line 120 "json_parser.yy"
452 { (yyval) = (yysemantic_stack_[(3) - (2)]); ;}
456 #line 122 "json_parser.yy"
457 { (yyval) = QVariant (QVariantList()); ;}
461 #line 123 "json_parser.yy"
463 QVariantList members = (yysemantic_stack_[(2) - (2)]).toList();
464 (yysemantic_stack_[(2) - (2)]) = QVariant(); // Allow reuse of list
465 members.prepend ((yysemantic_stack_[(2) - (1)]));
466 (yyval) = QVariant(members);
471 #line 130 "json_parser.yy"
472 { (yyval) = QVariant (QVariantList()); ;}
476 #line 131 "json_parser.yy"
478 QVariantList members = (yysemantic_stack_[(3) - (3)]).toList();
479 (yysemantic_stack_[(3) - (3)]) = QVariant(); // Allow reuse of list
480 members.prepend ((yysemantic_stack_[(3) - (2)]));
481 (yyval) = QVariant(members);
486 #line 138 "json_parser.yy"
487 { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
491 #line 139 "json_parser.yy"
492 { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
496 #line 140 "json_parser.yy"
497 { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
501 #line 141 "json_parser.yy"
502 { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
506 #line 142 "json_parser.yy"
507 { (yyval) = QVariant (true); ;}
511 #line 143 "json_parser.yy"
512 { (yyval) = QVariant (false); ;}
516 #line 144 "json_parser.yy"
518 QVariant null_variant;
519 (yyval) = null_variant;
524 #line 149 "json_parser.yy"
525 { (yyval) = QVariant(QVariant::Double); (yyval).setValue( -std::numeric_limits<double>::infinity() ); ;}
529 #line 150 "json_parser.yy"
530 { (yyval) = QVariant(QVariant::Double); (yyval).setValue( std::numeric_limits<double>::infinity() ); ;}
534 #line 151 "json_parser.yy"
535 { (yyval) = QVariant(QVariant::Double); (yyval).setValue( std::numeric_limits<double>::quiet_NaN() ); ;}
539 #line 154 "json_parser.yy"
541 if ((yysemantic_stack_[(1) - (1)]).toByteArray().startsWith('-')) {
542 (yyval) = QVariant (QVariant::LongLong);
543 (yyval).setValue((yysemantic_stack_[(1) - (1)]).toLongLong());
546 (yyval) = QVariant (QVariant::ULongLong);
547 (yyval).setValue((yysemantic_stack_[(1) - (1)]).toULongLong());
553 #line 164 "json_parser.yy"
555 const QByteArray value = (yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray();
556 (yyval) = QVariant(QVariant::Double);
557 (yyval).setValue(value.toDouble());
562 #line 169 "json_parser.yy"
563 { (yyval) = QVariant ((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray()); ;}
567 #line 170 "json_parser.yy"
569 const QByteArray value = (yysemantic_stack_[(3) - (1)]).toByteArray() + (yysemantic_stack_[(3) - (2)]).toByteArray() + (yysemantic_stack_[(3) - (3)]).toByteArray();
570 (yyval) = QVariant (value);
575 #line 175 "json_parser.yy"
576 { (yyval) = QVariant ((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray()); ;}
580 #line 176 "json_parser.yy"
581 { (yyval) = QVariant (QByteArray("-") + (yysemantic_stack_[(3) - (2)]).toByteArray() + (yysemantic_stack_[(3) - (3)]).toByteArray()); ;}
585 #line 178 "json_parser.yy"
586 { (yyval) = QVariant (QByteArray("")); ;}
590 #line 179 "json_parser.yy"
592 (yyval) = QVariant((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray());
597 #line 183 "json_parser.yy"
599 (yyval) = QVariant(QByteArray(".") + (yysemantic_stack_[(2) - (2)]).toByteArray());
604 #line 187 "json_parser.yy"
605 { (yyval) = QVariant((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray()); ;}
609 #line 189 "json_parser.yy"
610 { (yyval) = (yysemantic_stack_[(3) - (2)]); ;}
614 #line 191 "json_parser.yy"
615 { (yyval) = QVariant (QString(QLatin1String(""))); ;}
619 #line 192 "json_parser.yy"
621 (yyval) = (yysemantic_stack_[(1) - (1)]);
626 /* Line 675 of lalr1.cc. */
627 #line 628 "json_parser.cc"
630 YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
636 yysemantic_stack_.push (yyval);
637 yylocation_stack_.push (yyloc);
639 /* Shift the result of the reduction. */
641 yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
642 if (0 <= yystate && yystate <= yylast_
643 && yycheck_[yystate] == yystate_stack_[0])
644 yystate = yytable_[yystate];
646 yystate = yydefgoto_[yyn - yyntokens_];
649 /*------------------------------------.
650 | yyerrlab -- here on detecting error |
651 `------------------------------------*/
653 /* If not already recovering from an error, report this error. */
657 error (yylloc, yysyntax_error_ (yystate, yytoken));
660 yyerror_range[0] = yylloc;
661 if (yyerrstatus_ == 3)
663 /* If just tried and failed to reuse look-ahead token after an
664 error, discard it. */
666 if (yychar <= yyeof_)
668 /* Return failure if at end of input. */
669 if (yychar == yyeof_)
674 yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
679 /* Else will try to reuse look-ahead token after shifting the error
684 /*---------------------------------------------------.
685 | yyerrorlab -- error raised explicitly by YYERROR. |
686 `---------------------------------------------------*/
689 /* Pacify compilers like GCC when the user code never invokes
690 YYERROR and the label yyerrorlab therefore never appears in user
695 yyerror_range[0] = yylocation_stack_[yylen - 1];
696 /* Do not reclaim the symbols of the rule which action triggered
700 yystate = yystate_stack_[0];
703 /*-------------------------------------------------------------.
704 | yyerrlab1 -- common code for both syntax error and YYERROR. |
705 `-------------------------------------------------------------*/
707 yyerrstatus_ = 3; /* Each real token shifted decrements this. */
711 yyn = yypact_[yystate];
712 if (yyn != yypact_ninf_)
715 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
723 /* Pop the current state because it cannot handle the error token. */
724 if (yystate_stack_.height () == 1)
727 yyerror_range[0] = yylocation_stack_[0];
728 yydestruct_ ("Error: popping",
730 &yysemantic_stack_[0], &yylocation_stack_[0]);
732 yystate = yystate_stack_[0];
739 yyerror_range[1] = yylloc;
740 // Using YYLLOC is tempting, but would change the location of
741 // the look-ahead. YYLOC is available though.
742 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
743 yysemantic_stack_.push (yylval);
744 yylocation_stack_.push (yyloc);
746 /* Shift the error token. */
747 YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
748 &yysemantic_stack_[0], &yylocation_stack_[0]);
764 if (yychar != yyeof_ && yychar != yyempty_)
765 yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
767 /* Do not reclaim the symbols of the rule which action triggered
768 this YYABORT or YYACCEPT. */
770 while (yystate_stack_.height () != 1)
772 yydestruct_ ("Cleanup: popping",
773 yystos_[yystate_stack_[0]],
774 &yysemantic_stack_[0],
775 &yylocation_stack_[0]);
782 // Generate an error message.
784 json_parser::yysyntax_error_ (int yystate, int tok)
789 int yyn = yypact_[yystate];
790 if (yypact_ninf_ < yyn && yyn <= yylast_)
792 /* Start YYX at -YYN if negative to avoid negative indexes in
794 int yyxbegin = yyn < 0 ? -yyn : 0;
796 /* Stay within bounds of both yycheck and yytname. */
797 int yychecklim = yylast_ - yyn + 1;
798 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
800 for (int x = yyxbegin; x < yyxend; ++x)
801 if (yycheck_[x + yyn] == x && x != yyterror_)
804 // FIXME: This method of building the message is not compatible
805 // with internationalization. It should work like yacc.c does it.
806 // That is, first build a string that looks like this:
807 // "syntax error, unexpected %s or %s or %s"
808 // Then, invoke YY_ on this string.
809 // Finally, use the string as a format to output
810 // yytname_[tok], etc.
811 // Until this gets fixed, this message appears in English only.
812 res = "syntax error, unexpected ";
813 res += yytnamerr_ (yytname_[tok]);
817 for (int x = yyxbegin; x < yyxend; ++x)
818 if (yycheck_[x + yyn] == x && x != yyterror_)
820 res += (!count++) ? ", expecting " : " or ";
821 res += yytnamerr_ (yytname_[x]);
827 res = YY_("syntax error");
832 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
834 const signed char json_parser::yypact_ninf_ = -21;
836 json_parser::yypact_[] =
838 3, -21, -21, -6, 31, -10, 0, -21, -21, -21,
839 6, -21, -21, 25, -21, -21, -21, -21, -21, -21,
840 -5, -21, 22, 19, 21, 23, 24, 0, -21, 0,
841 -21, -21, 13, -21, 0, 0, 29, -21, -21, -6,
842 -21, 31, -21, 31, -21, -21, -21, -21, -21, -21,
843 -21, 19, -21, 24, -21, -21
846 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
847 doesn't specify something else to do. Zero means the default is an
850 json_parser::yydefact_[] =
852 0, 5, 4, 7, 13, 0, 34, 21, 22, 23,
853 39, 25, 26, 0, 2, 19, 20, 3, 18, 27,
854 28, 17, 0, 9, 0, 0, 15, 34, 24, 34,
855 32, 40, 0, 1, 34, 34, 29, 30, 6, 0,
856 8, 0, 12, 0, 14, 33, 35, 38, 36, 37,
857 31, 9, 11, 15, 10, 16
860 /* YYPGOTO[NTERM-NUM]. */
862 json_parser::yypgoto_[] =
864 -21, -21, -21, -21, -21, -20, 4, -21, -21, -18,
865 -4, -21, -21, -21, -14, -21, -3, -1, -21
868 /* YYDEFGOTO[NTERM-NUM]. */
870 json_parser::yydefgoto_[] =
872 -1, 13, 14, 15, 22, 40, 23, 16, 25, 44,
873 17, 18, 19, 20, 30, 36, 37, 21, 32
876 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
877 positive, shift that token. If negative, reduce the rule which
878 number is the opposite. If zero, do what YYDEFACT says. */
879 const signed char json_parser::yytable_ninf_ = -1;
881 json_parser::yytable_[] =
883 26, 27, 24, 1, 2, 34, 3, 35, 4, 28,
884 10, 29, 5, 45, 6, 46, 7, 8, 9, 10,
885 48, 49, 11, 12, 31, 33, 38, 39, 41, 42,
886 47, 54, 43, 50, 3, 55, 4, 52, 24, 53,
887 5, 35, 6, 51, 7, 8, 9, 10, 0, 0,
893 json_parser::yycheck_[] =
895 4, 11, 3, 0, 1, 10, 3, 12, 5, 19,
896 16, 11, 9, 27, 11, 29, 13, 14, 15, 16,
897 34, 35, 19, 20, 18, 0, 4, 8, 7, 6,
898 17, 51, 8, 36, 3, 53, 5, 41, 39, 43,
899 9, 12, 11, 39, 13, 14, 15, 16, -1, -1,
903 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
904 symbol of state STATE-NUM. */
906 json_parser::yystos_[] =
908 0, 0, 1, 3, 5, 9, 11, 13, 14, 15,
909 16, 19, 20, 22, 23, 24, 28, 31, 32, 33,
910 34, 38, 25, 27, 38, 29, 31, 11, 19, 11,
911 35, 18, 39, 0, 10, 12, 36, 37, 4, 8,
912 26, 7, 6, 8, 30, 35, 35, 17, 35, 35,
913 37, 27, 31, 31, 26, 30
917 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
919 const unsigned short int
920 json_parser::yytoken_number_[] =
922 0, 256, 257, 1, 2, 3, 4, 5, 6, 7,
923 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
928 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
930 json_parser::yyr1_[] =
932 0, 21, 22, 23, 23, 23, 24, 25, 25, 26,
933 26, 27, 28, 29, 29, 30, 30, 31, 31, 31,
934 31, 31, 31, 31, 32, 32, 32, 32, 33, 33,
935 33, 33, 34, 34, 35, 35, 36, 37, 38, 39,
939 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
941 json_parser::yyr2_[] =
943 0, 2, 1, 1, 1, 1, 3, 0, 2, 0,
944 3, 3, 3, 0, 2, 0, 3, 1, 1, 1,
945 1, 1, 1, 1, 2, 1, 1, 1, 1, 2,
946 2, 3, 2, 3, 0, 2, 2, 2, 3, 0,
950 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
951 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
952 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
954 const json_parser::yytname_[] =
956 "\"end of file\"", "error", "$undefined", "\"{\"", "\"}\"", "\"[\"",
957 "\"]\"", "\":\"", "\",\"", "\"-\"", "\".\"", "\"digit\"",
958 "\"exponential\"", "\"true\"", "\"false\"", "\"null\"",
959 "\"open quotation mark\"", "\"close quotation mark\"", "\"string\"",
960 "\"Infinity\"", "\"NaN\"", "$accept", "start", "data", "object",
961 "members", "r_members", "pair", "array", "values", "r_values", "value",
962 "special_or_number", "number", "int", "digits", "fract", "exp", "string",
968 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
969 const json_parser::rhs_number_type
970 json_parser::yyrhs_[] =
972 22, 0, -1, 23, -1, 31, -1, 1, -1, 0,
973 -1, 3, 25, 4, -1, -1, 27, 26, -1, -1,
974 8, 27, 26, -1, 38, 7, 31, -1, 5, 29,
975 6, -1, -1, 31, 30, -1, -1, 8, 31, 30,
976 -1, 38, -1, 32, -1, 24, -1, 28, -1, 13,
977 -1, 14, -1, 15, -1, 9, 19, -1, 19, -1,
978 20, -1, 33, -1, 34, -1, 34, 36, -1, 34,
979 37, -1, 34, 36, 37, -1, 11, 35, -1, 9,
980 11, 35, -1, -1, 11, 35, -1, 10, 35, -1,
981 12, 35, -1, 16, 39, 17, -1, -1, 18, -1
984 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
987 json_parser::yyprhs_[] =
989 0, 0, 3, 5, 7, 9, 11, 15, 16, 19,
990 20, 24, 28, 32, 33, 36, 37, 41, 43, 45,
991 47, 49, 51, 53, 55, 58, 60, 62, 64, 66,
992 69, 72, 76, 79, 83, 84, 87, 90, 93, 97,
996 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
998 json_parser::yyrline_[] =
1000 0, 84, 84, 89, 90, 96, 98, 100, 101, 107,
1001 108, 114, 120, 122, 123, 130, 131, 138, 139, 140,
1002 141, 142, 143, 144, 149, 150, 151, 152, 154, 164,
1003 169, 170, 175, 176, 178, 179, 183, 187, 189, 191,
1007 // Print the state stack on the debug stream.
1009 json_parser::yystack_print_ ()
1011 *yycdebug_ << "Stack now";
1012 for (state_stack_type::const_iterator i = yystate_stack_.begin ();
1013 i != yystate_stack_.end (); ++i)
1014 *yycdebug_ << ' ' << *i;
1015 *yycdebug_ << std::endl;
1018 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1020 json_parser::yy_reduce_print_ (int yyrule)
1022 unsigned int yylno = yyrline_[yyrule];
1023 int yynrhs = yyr2_[yyrule];
1024 /* Print the symbols being reduced, and their result. */
1025 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
1026 << " (line " << yylno << "), ";
1027 /* The symbols being reduced. */
1028 for (int yyi = 0; yyi < yynrhs; yyi++)
1029 YY_SYMBOL_PRINT (" $" << yyi + 1 << " =",
1030 yyrhs_[yyprhs_[yyrule] + yyi],
1031 &(yysemantic_stack_[(yynrhs) - (yyi + 1)]),
1032 &(yylocation_stack_[(yynrhs) - (yyi + 1)]));
1036 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1037 json_parser::token_number_type
1038 json_parser::yytranslate_ (int t)
1041 const token_number_type
1044 0, 3, 4, 5, 6, 7, 8, 9, 10, 11,
1045 12, 13, 14, 15, 16, 17, 18, 19, 20, 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, 2, 2, 2, 2,
1050 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1051 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1052 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1053 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1054 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1055 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1056 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1057 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1058 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1059 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1060 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1061 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1062 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1063 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1064 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1065 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1066 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1067 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1068 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1069 2, 2, 2, 2, 2, 2, 1, 2
1071 if ((unsigned int) t <= yyuser_token_number_max_)
1072 return translate_table[t];
1074 return yyundef_token_;
1077 const int json_parser::yyeof_ = 0;
1078 const int json_parser::yylast_ = 51;
1079 const int json_parser::yynnts_ = 19;
1080 const int json_parser::yyempty_ = -2;
1081 const int json_parser::yyfinal_ = 33;
1082 const int json_parser::yyterror_ = 1;
1083 const int json_parser::yyerrcode_ = 256;
1084 const int json_parser::yyntokens_ = 21;
1086 const unsigned int json_parser::yyuser_token_number_max_ = 257;
1087 const json_parser::token_number_type json_parser::yyundef_token_ = 2;
1091 #line 196 "json_parser.yy"
1094 int yy::yylex(YYSTYPE *yylval, yy::location *yylloc, QJson::ParserPrivate* driver)
1096 JSonScanner* scanner = driver->m_scanner;
1098 int ret = scanner->yylex(yylval, yylloc);
1100 qjsonDebug() << "json_parser::yylex - calling scanner yylval==|"
1101 << yylval->toByteArray() << "|, ret==|" << QString::number(ret) << "|";
1106 void yy::json_parser::error (const yy::location& yyloc,
1107 const std::string& error)
1109 /*qjsonDebug() << yyloc.begin.line;
1110 qjsonDebug() << yyloc.begin.column;
1111 qjsonDebug() << yyloc.end.line;
1112 qjsonDebug() << yyloc.end.column;*/
1113 qjsonDebug() << "json_parser::error [line" << yyloc.end.line << "] -" << error.c_str() ;
1114 driver->setError(QString::fromLatin1(error.c_str()), yyloc.end.line);