contrib/llvm/tools/lldb/source/Utility/JSON.cpp

   1 //===--------------------- JSON.cpp -----------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/Utility/JSON.h"
  11
  12 #include <limits.h>
  13 #include "lldb/Core/StreamString.h"
  14 #include "lldb/Host/StringConvert.h"
  15 #include "llvm/Support/ErrorHandling.h"
  16
  17 using namespace lldb_private;
  18
  19 std::string
  20 JSONString::json_string_quote_metachars (const std::string &s)
  21 {
  22     if (s.find('"') == std::string::npos)
  23         return s;
  24
  25     std::string output;
  26     const size_t s_size = s.size();
  27     const char *s_chars = s.c_str();
  28     for (size_t i = 0; i < s_size; i++)
  29     {
  30         unsigned char ch = *(s_chars + i);
  31         if (ch == '"')
  32         {
  33             output.push_back ('\\');
  34         }
  35         output.push_back (ch);
  36     }
  37     return output;
  38 }
  39
  40 JSONString::JSONString () :
  41     JSONValue(JSONValue::Kind::String),
  42     m_data()
  43 {
  44 }
  45
  46 JSONString::JSONString (const char* s) :
  47     JSONValue(JSONValue::Kind::String),
  48     m_data(s ? s : "")
  49 {
  50 }
  51
  52 JSONString::JSONString (const std::string& s) :
  53     JSONValue(JSONValue::Kind::String),
  54     m_data(s)
  55 {
  56 }
  57
  58 void
  59 JSONString::Write (Stream& s)
  60 {
  61     s.Printf("\"%s\"", json_string_quote_metachars(m_data).c_str());
  62 }
  63
  64 uint64_t
  65 JSONNumber::GetAsUnsigned() const
  66 {
  67     switch (m_data_type)
  68     {
  69         case DataType::Unsigned:
  70             return m_data.m_unsigned;
  71         case DataType::Signed:
  72             return (uint64_t)m_data.m_signed;
  73         case DataType::Double:
  74             return (uint64_t)m_data.m_double;
  75     }
  76     llvm_unreachable("Unhandled data type");
  77 }
  78
  79 int64_t
  80 JSONNumber::GetAsSigned() const
  81 {
  82     switch (m_data_type)
  83     {
  84         case DataType::Unsigned:
  85             return (int64_t)m_data.m_unsigned;
  86         case DataType::Signed:
  87             return m_data.m_signed;
  88         case DataType::Double:
  89             return (int64_t)m_data.m_double;
  90     }
  91     llvm_unreachable("Unhandled data type");
  92 }
  93
  94 double
  95 JSONNumber::GetAsDouble() const
  96 {
  97     switch (m_data_type)
  98     {
  99         case DataType::Unsigned:
 100             return (double)m_data.m_unsigned;
 101         case DataType::Signed:
 102             return (double)m_data.m_signed;
 103         case DataType::Double:
 104             return m_data.m_double;
 105     }
 106     llvm_unreachable("Unhandled data type");
 107 }
 108
 109 void
 110 JSONNumber::Write (Stream& s)
 111 {
 112     switch (m_data_type)
 113     {
 114         case DataType::Unsigned:
 115             s.Printf("%" PRIu64, m_data.m_unsigned);
 116             break;
 117         case DataType::Signed:
 118             s.Printf("%" PRId64, m_data.m_signed);
 119             break;
 120         case DataType::Double:
 121             s.Printf("%g", m_data.m_double);
 122             break;
 123     }
 124 }
 125
 126 JSONTrue::JSONTrue () :
 127     JSONValue(JSONValue::Kind::True)
 128 {
 129 }
 130
 131 void
 132 JSONTrue::Write(Stream& s)
 133 {
 134     s.Printf("true");
 135 }
 136
 137 JSONFalse::JSONFalse () :
 138     JSONValue(JSONValue::Kind::False)
 139 {
 140 }
 141
 142 void
 143 JSONFalse::Write(Stream& s)
 144 {
 145     s.Printf("false");
 146 }
 147
 148 JSONNull::JSONNull () :
 149     JSONValue(JSONValue::Kind::Null)
 150 {
 151 }
 152
 153 void
 154 JSONNull::Write(Stream& s)
 155 {
 156     s.Printf("null");
 157 }
 158
 159 JSONObject::JSONObject () :
 160     JSONValue(JSONValue::Kind::Object)
 161 {
 162 }
 163
 164 void
 165 JSONObject::Write (Stream& s)
 166 {
 167     bool first = true;
 168     s.PutChar('{');
 169     auto iter = m_elements.begin(), end = m_elements.end();
 170     for (;iter != end; iter++)
 171     {
 172         if (first)
 173             first = false;
 174         else
 175             s.PutChar(',');
 176         JSONString key(iter->first);
 177         JSONValue::SP value(iter->second);
 178         key.Write(s);
 179         s.PutChar(':');
 180         value->Write(s);
 181     }
 182     s.PutChar('}');
 183 }
 184
 185 bool
 186 JSONObject::SetObject (const std::string& key,
 187                        JSONValue::SP value)
 188 {
 189     if (key.empty() || nullptr == value.get())
 190         return false;
 191     m_elements[key] = value;
 192     return true;
 193 }
 194
 195 JSONValue::SP
 196 JSONObject::GetObject (const std::string& key)
 197 {
 198     auto iter = m_elements.find(key), end = m_elements.end();
 199     if (iter == end)
 200         return JSONValue::SP();
 201     return iter->second;
 202 }
 203
 204 JSONArray::JSONArray () :
 205     JSONValue(JSONValue::Kind::Array)
 206 {
 207 }
 208
 209 void
 210 JSONArray::Write (Stream& s)
 211 {
 212     bool first = true;
 213     s.PutChar('[');
 214     auto iter = m_elements.begin(), end = m_elements.end();
 215     for (;iter != end; iter++)
 216     {
 217         if (first)
 218             first = false;
 219         else
 220             s.PutChar(',');
 221         (*iter)->Write(s);
 222     }
 223     s.PutChar(']');
 224 }
 225
 226 bool
 227 JSONArray::SetObject (Index i,
 228                       JSONValue::SP value)
 229 {
 230     if (value.get() == nullptr)
 231         return false;
 232     if (i < m_elements.size())
 233     {
 234         m_elements[i] = value;
 235         return true;
 236     }
 237     if (i == m_elements.size())
 238     {
 239         m_elements.push_back(value);
 240         return true;
 241     }
 242     return false;
 243 }
 244
 245 bool
 246 JSONArray::AppendObject (JSONValue::SP value)
 247 {
 248     if (value.get() == nullptr)
 249         return false;
 250     m_elements.push_back(value);
 251     return true;
 252 }
 253
 254 JSONValue::SP
 255 JSONArray::GetObject (Index i)
 256 {
 257     if (i < m_elements.size())
 258         return m_elements[i];
 259     return JSONValue::SP();
 260 }
 261
 262 JSONArray::Size
 263 JSONArray::GetNumElements ()
 264 {
 265     return m_elements.size();
 266 }
 267
 268
 269 JSONParser::JSONParser (const char *cstr) :
 270     StringExtractor(cstr)
 271 {
 272 }
 273
 274 JSONParser::Token
 275 JSONParser::GetToken (std::string &value)
 276 {
 277     StreamString error;
 278
 279     value.clear();
 280     SkipSpaces ();
 281     const uint64_t start_index = m_index;
 282     const char ch = GetChar();
 283     switch (ch)
 284     {
 285         case '{': return Token::ObjectStart;
 286         case '}': return Token::ObjectEnd;
 287         case '[': return Token::ArrayStart;
 288         case ']': return Token::ArrayEnd;
 289         case ',': return Token::Comma;
 290         case ':': return Token::Colon;
 291         case '\0': return Token::EndOfFile;
 292         case 't':
 293             if (GetChar() == 'r')
 294                 if (GetChar() == 'u')
 295                     if (GetChar() == 'e')
 296                         return Token::True;
 297             break;
 298
 299         case 'f':
 300             if (GetChar() == 'a')
 301                 if (GetChar() == 'l')
 302                     if (GetChar() == 's')
 303                         if (GetChar() == 'e')
 304                             return Token::False;
 305             break;
 306
 307         case 'n':
 308             if (GetChar() == 'u')
 309                 if (GetChar() == 'l')
 310                     if (GetChar() == 'l')
 311                         return Token::Null;
 312             break;
 313
 314         case '"':
 315             {
 316                 while (1)
 317                 {
 318                     bool was_escaped = false;
 319                     int escaped_ch = GetEscapedChar(was_escaped);
 320                     if (escaped_ch == -1)
 321                     {
 322                         error.Printf("error: an error occurred getting a character from offset %" PRIu64, start_index);
 323                         value = std::move(error.GetString());
 324                         return Token::Error;
 325
 326                     }
 327                     else
 328                     {
 329                         const bool is_end_quote = escaped_ch == '"';
 330                         const bool is_null = escaped_ch == 0;
 331                         if (was_escaped || (!is_end_quote && !is_null))
 332                         {
 333                             if (CHAR_MIN <= escaped_ch && escaped_ch <= CHAR_MAX)
 334                             {
 335                                 value.append(1, (char)escaped_ch);
 336                             }
 337                             else
 338                             {
 339                                 error.Printf("error: wide character support is needed for unicode character 0x%4.4x at offset %" PRIu64, escaped_ch, start_index);
 340                                 value = std::move(error.GetString());
 341                                 return Token::Error;
 342                             }
 343                         }
 344                         else if (is_end_quote)
 345                         {
 346                             return Token::String;
 347                         }
 348                         else if (is_null)
 349                         {
 350                             value = "error: missing end quote for string";
 351                             return Token::Error;
 352                         }
 353                     }
 354                 }
 355             }
 356             break;
 357
 358         case '-':
 359         case '0':
 360         case '1':
 361         case '2':
 362         case '3':
 363         case '4':
 364         case '5':
 365         case '6':
 366         case '7':
 367         case '8':
 368         case '9':
 369             {
 370                 bool done = false;
 371                 bool got_decimal_point = false;
 372                 uint64_t exp_index = 0;
 373                 bool got_int_digits = (ch >= '0') && (ch <= '9');
 374                 bool got_frac_digits = false;
 375                 bool got_exp_digits = false;
 376                 while (!done)
 377                 {
 378                     const char next_ch = PeekChar();
 379                     switch (next_ch)
 380                     {
 381                         case '0':
 382                         case '1':
 383                         case '2':
 384                         case '3':
 385                         case '4':
 386                         case '5':
 387                         case '6':
 388                         case '7':
 389                         case '8':
 390                         case '9':
 391                             if (exp_index != 0)
 392                             {
 393                                 got_exp_digits = true;
 394                             }
 395                             else if (got_decimal_point)
 396                             {
 397                                 got_frac_digits = true;
 398                             }
 399                             else
 400                             {
 401                                 got_int_digits = true;
 402                             }
 403                             ++m_index; // Skip this character
 404                             break;
 405
 406                         case '.':
 407                             if (got_decimal_point)
 408                             {
 409                                 error.Printf("error: extra decimal point found at offset %" PRIu64, start_index);
 410                                 value = std::move(error.GetString());
 411                                 return Token::Error;
 412                             }
 413                             else
 414                             {
 415                                 got_decimal_point = true;
 416                                 ++m_index; // Skip this character
 417                             }
 418                             break;
 419
 420                         case 'e':
 421                         case 'E':
 422                             if (exp_index != 0)
 423                             {
 424                                 error.Printf("error: extra exponent character found at offset %" PRIu64, start_index);
 425                                 value = std::move(error.GetString());
 426                                 return Token::Error;
 427                             }
 428                             else
 429                             {
 430                                 exp_index = m_index;
 431                                 ++m_index; // Skip this character
 432                             }
 433                             break;
 434
 435                         case '+':
 436                         case '-':
 437                             // The '+' and '-' can only come after an exponent character...
 438                             if (exp_index == m_index - 1)
 439                             {
 440                                 ++m_index; // Skip the exponent sign character
 441                             }
 442                             else
 443                             {
 444                                 error.Printf("error: unexpected %c character at offset %" PRIu64, next_ch, start_index);
 445                                 value = std::move(error.GetString());
 446                                 return Token::Error;
 447                             }
 448                             break;
 449
 450                         default:
 451                             done = true;
 452                             break;
 453                     }
 454                 }
 455
 456                 if (m_index > start_index)
 457                 {
 458                     value = m_packet.substr(start_index, m_index - start_index);
 459                     if (got_decimal_point)
 460                     {
 461                         if (exp_index != 0)
 462                         {
 463                             // We have an exponent, make sure we got exponent digits
 464                             if (got_exp_digits)
 465                             {
 466                                 return Token::Float;
 467                             }
 468                             else
 469                             {
 470                                 error.Printf("error: got exponent character but no exponent digits at offset in float value \"%s\"", value.c_str());
 471                                 value = std::move(error.GetString());
 472                                 return Token::Error;
 473                             }
 474                         }
 475                         else
 476                         {
 477                             // No exponent, but we need at least one decimal after the decimal point
 478                             if (got_frac_digits)
 479                             {
 480                                 return Token::Float;
 481                             }
 482                             else
 483                             {
 484                                 error.Printf("error: no digits after decimal point \"%s\"", value.c_str());
 485                                 value = std::move(error.GetString());
 486                                 return Token::Error;
 487                             }
 488                         }
 489                     }
 490                     else
 491                     {
 492                         // No decimal point
 493                         if (got_int_digits)
 494                         {
 495                             // We need at least some integer digits to make an integer
 496                             return Token::Integer;
 497                         }
 498                         else
 499                         {
 500                             error.Printf("error: no digits negate sign \"%s\"", value.c_str());
 501                             value = std::move(error.GetString());
 502                             return Token::Error;
 503                         }
 504                     }
 505                 }
 506                 else
 507                 {
 508                     error.Printf("error: invalid number found at offset %" PRIu64, start_index);
 509                     value = std::move(error.GetString());
 510                     return Token::Error;
 511                 }
 512             }
 513             break;
 514         default:
 515             break;
 516     }
 517     error.Printf("error: failed to parse token at offset %" PRIu64 " (around character '%c')", start_index, ch);
 518     value = std::move(error.GetString());
 519     return Token::Error;
 520 }
 521
 522 int
 523 JSONParser::GetEscapedChar(bool &was_escaped)
 524 {
 525     was_escaped = false;
 526     const char ch = GetChar();
 527     if (ch == '\\')
 528     {
 529         was_escaped = true;
 530         const char ch2 = GetChar();
 531         switch (ch2)
 532         {
 533             case '"':
 534             case '\\':
 535             case '/':
 536             default:
 537                 break;
 538
 539             case 'b': return '\b';
 540             case 'f': return '\f';
 541             case 'n': return '\n';
 542             case 'r': return '\r';
 543             case 't': return '\t';
 544             case 'u':
 545                 {
 546                     const int hi_byte = DecodeHexU8();
 547                     const int lo_byte = DecodeHexU8();
 548                     if (hi_byte >=0 && lo_byte >= 0)
 549                         return hi_byte << 8 | lo_byte;
 550                     return -1;
 551                 }
 552                 break;
 553         }
 554         return ch2;
 555     }
 556     return ch;
 557 }
 558
 559 JSONValue::SP
 560 JSONParser::ParseJSONObject ()
 561 {
 562     // The "JSONParser::Token::ObjectStart" token should have already been consumed
 563     // by the time this function is called
 564     std::unique_ptr<JSONObject> dict_up(new JSONObject());
 565
 566     std::string value;
 567     std::string key;
 568     while (1)
 569     {
 570         JSONParser::Token token = GetToken(value);
 571
 572         if (token == JSONParser::Token::String)
 573         {
 574             key.swap(value);
 575             token = GetToken(value);
 576             if (token == JSONParser::Token::Colon)
 577             {
 578                 JSONValue::SP value_sp = ParseJSONValue();
 579                 if (value_sp)
 580                     dict_up->SetObject(key, value_sp);
 581                 else
 582                     break;
 583             }
 584         }
 585         else if (token == JSONParser::Token::ObjectEnd)
 586         {
 587             return JSONValue::SP(dict_up.release());
 588         }
 589         else if (token == JSONParser::Token::Comma)
 590         {
 591             continue;
 592         }
 593         else
 594         {
 595             break;
 596         }
 597     }
 598     return JSONValue::SP();
 599 }
 600
 601 JSONValue::SP
 602 JSONParser::ParseJSONArray ()
 603 {
 604     // The "JSONParser::Token::ObjectStart" token should have already been consumed
 605     // by the time this function is called
 606     std::unique_ptr<JSONArray> array_up(new JSONArray());
 607
 608     std::string value;
 609     std::string key;
 610     while (1)
 611     {
 612         JSONValue::SP value_sp = ParseJSONValue();
 613         if (value_sp)
 614             array_up->AppendObject(value_sp);
 615         else
 616             break;
 617
 618         JSONParser::Token token = GetToken(value);
 619         if (token == JSONParser::Token::Comma)
 620         {
 621             continue;
 622         }
 623         else if (token == JSONParser::Token::ArrayEnd)
 624         {
 625             return JSONValue::SP(array_up.release());
 626         }
 627         else
 628         {
 629             break;
 630         }
 631     }
 632     return JSONValue::SP();
 633 }
 634
 635 JSONValue::SP
 636 JSONParser::ParseJSONValue ()
 637 {
 638     std::string value;
 639     const JSONParser::Token token = GetToken(value);
 640     switch (token)
 641     {
 642         case JSONParser::Token::ObjectStart:
 643             return ParseJSONObject();
 644
 645         case JSONParser::Token::ArrayStart:
 646             return ParseJSONArray();
 647
 648         case JSONParser::Token::Integer:
 649         {
 650             if (value.front() == '-')
 651             {
 652                 bool success = false;
 653                 int64_t sval = StringConvert::ToSInt64(value.c_str(), 0, 0, &success);
 654                 if (success)
 655                     return JSONValue::SP(new JSONNumber(sval));
 656             }
 657             else
 658             {
 659                 bool success = false;
 660                 uint64_t uval = StringConvert::ToUInt64(value.c_str(), 0, 0, &success);
 661                 if (success)
 662                     return JSONValue::SP(new JSONNumber(uval));
 663             }
 664         }
 665             break;
 666
 667         case JSONParser::Token::Float:
 668         {
 669             bool success = false;
 670             double val = StringConvert::ToDouble(value.c_str(), 0.0, &success);
 671             if (success)
 672                 return JSONValue::SP(new JSONNumber(val));
 673         }
 674             break;
 675
 676         case JSONParser::Token::String:
 677             return JSONValue::SP(new JSONString(value));
 678
 679         case JSONParser::Token::True:
 680             return JSONValue::SP(new JSONTrue());
 681
 682         case JSONParser::Token::False:
 683             return JSONValue::SP(new JSONFalse());
 684
 685         case JSONParser::Token::Null:
 686             return JSONValue::SP(new JSONNull());
 687
 688         default:
 689             break;
 690     }
 691     return JSONValue::SP();
 692
 693 }