git.cworth.org Git - apitrace/blob - thirdparty/qjson/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
 144   /// Build a parser object.
 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&
 214   json_parser::debug_stream () const
 215   {
 216     return *yycdebug_;
 217   }
 218
 219   void
 220   json_parser::set_debug_stream (std::ostream& o)
 221   {
 222     yycdebug_ = &o;
 223   }
 224
 225
 226   json_parser::debug_level_type
 227   json_parser::debug_level () const
 228   {
 229     return yydebug_;
 230   }
 231
 232   void
 233   json_parser::set_debug_level (debug_level_type l)
 234   {
 235     yydebug_ = l;
 236   }
 237
 238
 239   int
 240   json_parser::parse ()
 241   {
 242     /// Look-ahead and look-ahead in internal form.
 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
 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];
 261
 262     /// $$.
 263     semantic_type yyval;
 264     /// @$.
 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