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"
45 # if defined YYENABLE_NLS && YYENABLE_NLS
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 80 "json_parser.yy"
389 driver->m_result = (yysemantic_stack_[(1) - (1)]);
390 qjsonDebug() << "json_parser - parsing finished";
395 #line 85 "json_parser.yy"
396 {(yyval) = (yysemantic_stack_[(1) - (1)]); ;}
400 #line 86 "json_parser.yy"
401 {(yyval) = (yysemantic_stack_[(1) - (1)]); ;}
405 #line 88 "json_parser.yy"
407 qCritical()<< "json_parser - syntax error found, "
414 #line 95 "json_parser.yy"
415 { (yyval) = (yysemantic_stack_[(3) - (2)]); ;}
419 #line 97 "json_parser.yy"
420 { (yyval) = QVariant (QVariantMap()); ;}
424 #line 98 "json_parser.yy"
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()));
433 #line 104 "json_parser.yy"
434 { (yyval) = QVariant (QVariantMap()); ;}
438 #line 105 "json_parser.yy"
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()));
447 #line 111 "json_parser.yy"
450 pair.insert ((yysemantic_stack_[(3) - (1)]).toString(), QVariant((yysemantic_stack_[(3) - (3)])));
451 (yyval) = QVariant (pair);
456 #line 117 "json_parser.yy"
457 { (yyval) = (yysemantic_stack_[(3) - (2)]); ;}
461 #line 119 "json_parser.yy"
462 { (yyval) = QVariant (QVariantList()); ;}
466 #line 120 "json_parser.yy"
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);
476 #line 127 "json_parser.yy"
477 { (yyval) = QVariant (QVariantList()); ;}
481 #line 128 "json_parser.yy"
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);
491 #line 135 "json_parser.yy"
492 { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
496 #line 136 "json_parser.yy"
497 { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
501 #line 137 "json_parser.yy"
502 { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
506 #line 138 "json_parser.yy"
507 { (yyval) = (yysemantic_stack_[(1) - (1)]); ;}
511 #line 139 "json_parser.yy"
512 { (yyval) = QVariant (true); ;}
516 #line 140 "json_parser.yy"
517 { (yyval) = QVariant (false); ;}
521 #line 141 "json_parser.yy"
523 QVariant null_variant;
524 (yyval) = null_variant;
529 #line 146 "json_parser.yy"
531 if ((yysemantic_stack_[(1) - (1)]).toByteArray().startsWith('-')) {
532 (yyval) = QVariant (QVariant::LongLong);
533 (yyval).setValue((yysemantic_stack_[(1) - (1)]).toLongLong());
536 (yyval) = QVariant (QVariant::ULongLong);
537 (yyval).setValue((yysemantic_stack_[(1) - (1)]).toULongLong());
543 #line 156 "json_parser.yy"
545 const QByteArray value = (yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray();
546 (yyval) = QVariant(QVariant::Double);
547 (yyval).setValue(value.toDouble());
552 #line 161 "json_parser.yy"
553 { (yyval) = QVariant ((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray()); ;}
557 #line 162 "json_parser.yy"
559 const QByteArray value = (yysemantic_stack_[(3) - (1)]).toByteArray() + (yysemantic_stack_[(3) - (2)]).toByteArray() + (yysemantic_stack_[(3) - (3)]).toByteArray();
560 (yyval) = QVariant (value);
565 #line 167 "json_parser.yy"
566 { (yyval) = QVariant ((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray()); ;}
570 #line 168 "json_parser.yy"
571 { (yyval) = QVariant (QByteArray("-") + (yysemantic_stack_[(3) - (2)]).toByteArray() + (yysemantic_stack_[(3) - (3)]).toByteArray()); ;}
575 #line 170 "json_parser.yy"
576 { (yyval) = QVariant (QByteArray("")); ;}
580 #line 171 "json_parser.yy"
582 (yyval) = QVariant((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray());
587 #line 175 "json_parser.yy"
589 (yyval) = QVariant(QByteArray(".") + (yysemantic_stack_[(2) - (2)]).toByteArray());
594 #line 179 "json_parser.yy"
595 { (yyval) = QVariant((yysemantic_stack_[(2) - (1)]).toByteArray() + (yysemantic_stack_[(2) - (2)]).toByteArray()); ;}
599 #line 181 "json_parser.yy"
600 { (yyval) = (yysemantic_stack_[(3) - (2)]); ;}
604 #line 183 "json_parser.yy"
605 { (yyval) = QVariant (QString(QLatin1String(""))); ;}
609 #line 184 "json_parser.yy"
611 (yyval) = (yysemantic_stack_[(1) - (1)]);
616 /* Line 675 of lalr1.cc. */
617 #line 618 "json_parser.cc"
620 YY_SYMBOL_PRINT ("-> $$ =", yyr1_[yyn], &yyval, &yyloc);
626 yysemantic_stack_.push (yyval);
627 yylocation_stack_.push (yyloc);
629 /* Shift the result of the reduction. */
631 yystate = yypgoto_[yyn - yyntokens_] + yystate_stack_[0];
632 if (0 <= yystate && yystate <= yylast_
633 && yycheck_[yystate] == yystate_stack_[0])
634 yystate = yytable_[yystate];
636 yystate = yydefgoto_[yyn - yyntokens_];
639 /*------------------------------------.
640 | yyerrlab -- here on detecting error |
641 `------------------------------------*/
643 /* If not already recovering from an error, report this error. */
647 error (yylloc, yysyntax_error_ (yystate, yytoken));
650 yyerror_range[0] = yylloc;
651 if (yyerrstatus_ == 3)
653 /* If just tried and failed to reuse look-ahead token after an
654 error, discard it. */
656 if (yychar <= yyeof_)
658 /* Return failure if at end of input. */
659 if (yychar == yyeof_)
664 yydestruct_ ("Error: discarding", yytoken, &yylval, &yylloc);
669 /* Else will try to reuse look-ahead token after shifting the error
674 /*---------------------------------------------------.
675 | yyerrorlab -- error raised explicitly by YYERROR. |
676 `---------------------------------------------------*/
679 /* Pacify compilers like GCC when the user code never invokes
680 YYERROR and the label yyerrorlab therefore never appears in user
685 yyerror_range[0] = yylocation_stack_[yylen - 1];
686 /* Do not reclaim the symbols of the rule which action triggered
690 yystate = yystate_stack_[0];
693 /*-------------------------------------------------------------.
694 | yyerrlab1 -- common code for both syntax error and YYERROR. |
695 `-------------------------------------------------------------*/
697 yyerrstatus_ = 3; /* Each real token shifted decrements this. */
701 yyn = yypact_[yystate];
702 if (yyn != yypact_ninf_)
705 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
713 /* Pop the current state because it cannot handle the error token. */
714 if (yystate_stack_.height () == 1)
717 yyerror_range[0] = yylocation_stack_[0];
718 yydestruct_ ("Error: popping",
720 &yysemantic_stack_[0], &yylocation_stack_[0]);
722 yystate = yystate_stack_[0];
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);
736 /* Shift the error token. */
737 YY_SYMBOL_PRINT ("Shifting", yystos_[yyn],
738 &yysemantic_stack_[0], &yylocation_stack_[0]);
754 if (yychar != yyeof_ && yychar != yyempty_)
755 yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
757 /* Do not reclaim the symbols of the rule which action triggered
758 this YYABORT or YYACCEPT. */
760 while (yystate_stack_.height () != 1)
762 yydestruct_ ("Cleanup: popping",
763 yystos_[yystate_stack_[0]],
764 &yysemantic_stack_[0],
765 &yylocation_stack_[0]);
772 // Generate an error message.
774 json_parser::yysyntax_error_ (int yystate, int tok)
779 int yyn = yypact_[yystate];
780 if (yypact_ninf_ < yyn && yyn <= yylast_)
782 /* Start YYX at -YYN if negative to avoid negative indexes in
784 int yyxbegin = yyn < 0 ? -yyn : 0;
786 /* Stay within bounds of both yycheck and yytname. */
787 int yychecklim = yylast_ - yyn + 1;
788 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
790 for (int x = yyxbegin; x < yyxend; ++x)
791 if (yycheck_[x + yyn] == x && x != yyterror_)
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]);
807 for (int x = yyxbegin; x < yyxend; ++x)
808 if (yycheck_[x + yyn] == x && x != yyterror_)
810 res += (!count++) ? ", expecting " : " or ";
811 res += yytnamerr_ (yytname_[x]);
817 res = YY_("syntax error");
822 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
824 const signed char json_parser::yypact_ninf_ = -18;
826 json_parser::yypact_[] =
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,
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
840 json_parser::yydefact_[] =
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,
850 /* YYPGOTO[NTERM-NUM]. */
852 json_parser::yypgoto_[] =
854 -18, -18, -18, 33, -18, -7, 6, 37, -18, -9,
855 -13, -18, -18, -17, -18, -1, -3, -18
858 /* YYDEFGOTO[NTERM-NUM]. */
860 json_parser::yydefgoto_[] =
862 -1, 5, 6, 18, 10, 30, 11, 19, 20, 37,
863 21, 22, 23, 34, 40, 41, 24, 27
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;
871 json_parser::yytable_[] =
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
881 json_parser::yycheck_[] =
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
889 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
890 symbol of state STATE-NUM. */
892 json_parser::yystos_[] =
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,
903 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
905 const unsigned short int
906 json_parser::yytoken_number_[] =
908 0, 256, 257, 1, 2, 3, 4, 5, 6, 7,
909 8, 9, 10, 11, 12, 13, 14, 15, 16
913 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
915 json_parser::yyr1_[] =
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
923 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
925 json_parser::yyr2_[] =
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
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. */
937 const json_parser::yytname_[] =
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
950 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
951 const json_parser::rhs_number_type
952 json_parser::yyrhs_[] =
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,
966 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
969 json_parser::yyprhs_[] =
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
977 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
979 json_parser::yyrline_[] =
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
987 // Print the state stack on the debug stream.
989 json_parser::yystack_print_ ()
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;
998 // Report on the debug stream that the rule \a yyrule is going to be reduced.
1000 json_parser::yy_reduce_print_ (int yyrule)
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)]));
1016 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
1017 json_parser::token_number_type
1018 json_parser::yytranslate_ (int t)
1021 const token_number_type
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
1051 if ((unsigned int) t <= yyuser_token_number_max_)
1052 return translate_table[t];
1054 return yyundef_token_;
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;
1066 const unsigned int json_parser::yyuser_token_number_max_ = 257;
1067 const json_parser::token_number_type json_parser::yyundef_token_ = 2;
1071 #line 188 "json_parser.yy"
1074 int yy::yylex(YYSTYPE *yylval, yy::location *yylloc, QJson::ParserPrivate* driver)
1076 JSonScanner* scanner = driver->m_scanner;
1078 int ret = scanner->yylex(yylval, yylloc);
1080 qjsonDebug() << "json_parser::yylex - calling scanner yylval==|"
1081 << yylval->toByteArray() << "|, ret==|" << QString::number(ret) << "|";
1086 void yy::json_parser::error (const yy::location& yyloc,
1087 const std::string& error)
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);