JSON.cpp Source File (original) (raw)

17#include

18#include

19#include

21namespace llvm {

22namespace json {

25 return try_emplace(K, nullptr).first->getSecond();

26}

28 return try_emplace(std::move(K), nullptr).first->getSecond();

29}

32 if (I == end())

33 return nullptr;

34 return &I->second;

35}

38 if (I == end())

39 return nullptr;

40 return &I->second;

41}

43 if (auto *V = get(K))

44 return V->getAsNull();

45 return std::nullopt;

46}

48 if (auto *V = get(K))

49 return V->getAsBoolean();

50 return std::nullopt;

51}

53 if (auto *V = get(K))

54 return V->getAsNumber();

55 return std::nullopt;

56}

58 if (auto *V = get(K))

59 return V->getAsInteger();

60 return std::nullopt;

61}

63 if (auto *V = get(K))

64 return V->getAsString();

65 return std::nullopt;

66}

68 if (auto *V = get(K))

69 return V->getAsObject();

70 return nullptr;

71}

73 if (auto *V = get(K))

74 return V->getAsObject();

75 return nullptr;

76}

78 if (auto *V = get(K))

79 return V->getAsArray();

80 return nullptr;

81}

83 if (auto *V = get(K))

84 return V->getAsArray();

85 return nullptr;

86}

90 V.reserve(Elements.size());

91 for (const Value &V : Elements) {

93 back().moveFrom(std::move(V));

94 }

95}

100void Value::copyFrom(const Value &M) {

102 switch (Type) {

103 case T_Null:

104 case T_Boolean:

105 case T_Double:

106 case T_Integer:

107 case T_UINT64:

108 memcpy(&Union, &M.Union, sizeof(Union));

109 break;

110 case T_StringRef:

111 create(M.as<StringRef>());

112 break;

113 case T_String:

114 createstd::string(M.asstd::string());

115 break;

116 case T_Object:

118 break;

119 case T_Array:

120 createjson::Array(M.as<json::Array>());

121 break;

122 }

123}

124

125void Value::moveFrom(const Value &&M) {

126 Type = M.Type;

127 switch (Type) {

128 case T_Null:

129 case T_Boolean:

130 case T_Double:

131 case T_Integer:

132 case T_UINT64:

133 memcpy(&Union, &M.Union, sizeof(Union));

134 break;

135 case T_StringRef:

136 create(M.as());

137 break;

138 case T_String:

139 createstd::string(std::move(M.asstd::string()));

140 M.Type = T_Null;

141 break;

142 case T_Object:

143 createjson::Object(std::move(M.asjson::Object()));

144 M.Type = T_Null;

145 break;

146 case T_Array:

147 createjson::Array(std::move(M.asjson::Array()));

148 M.Type = T_Null;

149 break;

150 }

151}

152

153void Value::destroy() {

154 switch (Type) {

155 case T_Null:

156 case T_Boolean:

157 case T_Double:

158 case T_Integer:

159 case T_UINT64:

160 break;

161 case T_StringRef:

162 as().~StringRef();

163 break;

164 case T_String:

165 asstd::string().~basic_string();

166 break;

167 case T_Object:

168 asjson::Object().~Object();

169 break;

170 case T_Array:

171 asjson::Array().~Array();

172 break;

173 }

174}

175

177

179 if (L.kind() != R.kind())

180 return false;

181 switch (L.kind()) {

183 return *L.getAsNull() == *R.getAsNull();

185 return *L.getAsBoolean() == *R.getAsBoolean();

187

188

189

190

191 if (L.Type == Value::T_Integer || R.Type == Value::T_Integer)

192 return L.getAsInteger() == R.getAsInteger();

193 return *L.getAsNumber() == *R.getAsNumber();

195 return *L.getAsString() == *R.getAsString();

197 return *L.getAsArray() == *R.getAsArray();

199 return *L.getAsObject() == *R.getAsObject();

200 }

202}

203

205

206 unsigned Count = 0;

208 for (P = this; P->Parent != nullptr; P = P->Parent)

211

212 R->ErrorMessage = Msg;

213 R->ErrorPath.resize(Count);

214 auto It = R->ErrorPath.begin();

215 for (P = this; P->Parent != nullptr; P = P->Parent)

216 *It++ = P->Seg;

217}

218

220 std::string S;

222 OS << (ErrorMessage.empty() ? "invalid JSON contents" : ErrorMessage);

223 if (ErrorPath.empty()) {

224 if (!Name.empty())

225 OS << " when parsing " << Name;

226 } else {

227 OS << " at " << (Name.empty() ? "(root)" : Name);

228 for (const Path::Segment &S : llvm::reverse(ErrorPath)) {

229 if (S.isField())

230 OS << '.' << S.field();

231 else

232 OS << '[' << S.index() << ']';

233 }

234 }

236}

237

239 std::vector<const Object::value_type *> Elements;

240 for (const auto &E : O)

241 Elements.push_back(&E);

244 return L->first < R->first;

245 });

246 return Elements;

247}

248

249

250

251

253 switch (V.kind()) {

255 JOS.rawValue(V.getAsArray()->empty() ? "[]" : "[ ... ]");

256 break;

258 JOS.rawValue(V.getAsObject()->empty() ? "{}" : "{ ... }");

259 break;

262 if (S.size() < 40) {

264 } else {

266 Truncated.append("...");

267 JOS.value(Truncated);

268 }

269 break;

270 }

271 default:

273 }

274}

275

276

277

279 switch (V.kind()) {

282 for (const auto &I : *V.getAsArray())

284 });

285 break;

288 for (const auto *KV : sortedElements(*V.getAsObject())) {

292 }

293 });

294 break;

295 default:

297 }

298}

299

301 OStream JOS(OS, 2);

302

303

304

305

307

308

309

310 auto HighlightCurrent = [&] {

311 std::string Comment = "error: ";

312 Comment.append(ErrorMessage.data(), ErrorMessage.size());

315 };

316 if (Path.empty())

317 return HighlightCurrent();

318 const Segment &S = Path.back();

319 if (S.isField()) {

320

322 const Object *O = V.getAsObject();

323 if (!O || !O->get(FieldName))

324 return HighlightCurrent();

328 if (FieldName == StringRef(KV->first))

329 Recurse(KV->second, Path.drop_back(), Recurse);

330 else

333 }

334 });

335 } else {

336

337 const Array *A = V.getAsArray();

338 if ( || S.index() >= A->size())

339 return HighlightCurrent();

341 unsigned Current = 0;

342 for (const auto &V : *A) {

343 if (Current++ == S.index())

344 Recurse(V, Path.drop_back(), Recurse);

345 else

347 }

348 });

349 }

350 };

351 PrintValue(R, ErrorPath, PrintValue);

352}

353

354namespace {

355

356class Parser {

357public:

359 : Start(JSON.begin()), P(JSON.begin()), End(JSON.end()) {}

360

361 bool checkUTF8() {

362 size_t ErrOffset;

364 return true;

365 P = Start + ErrOffset;

366 return parseError("Invalid UTF-8 sequence");

367 }

368

369 bool parseValue(Value &Out);

370

371 bool assertEnd() {

372 eatWhitespace();

373 if (P == End)

374 return true;

375 return parseError("Text after end of document");

376 }

377

378 Error takeError() {

380 return std::move(*Err);

381 }

382

383private:

384 void eatWhitespace() {

385 while (P != End && (*P == ' ' || *P == '\r' || *P == '\n' || *P == '\t'))

386 ++P;

387 }

388

389

390 bool parseNumber(char First, Value &Out);

391 bool parseString(std::string &Out);

392 bool parseUnicode(std::string &Out);

393 bool parseError(const char *Msg);

394

395 char next() { return P == End ? 0 : *P++; }

396 char peek() { return P == End ? 0 : *P; }

397 static bool isNumber(char C) {

398 return C == '0' || C == '1' || C == '2' || C == '3' || C == '4' ||

399 C == '5' || C == '6' || C == '7' || C == '8' || C == '9' ||

400 C == 'e' || C == 'E' || C == '+' || C == '-' || C == '.';

401 }

402

403 std::optional Err;

404 const char *Start, *P, *End;

405};

406}

407

408bool Parser::parseValue(Value &Out) {

409 eatWhitespace();

410 if (P == End)

411 return parseError("Unexpected EOF");

412 switch (char C = next()) {

413

414 case 'n':

415 Out = nullptr;

416 return (next() == 'u' && next() == 'l' && next() == 'l') ||

417 parseError("Invalid JSON value (null?)");

418 case 't':

419 Out = true;

420 return (next() == 'r' && next() == 'u' && next() == 'e') ||

421 parseError("Invalid JSON value (true?)");

422 case 'f':

423 Out = false;

424 return (next() == 'a' && next() == 'l' && next() == 's' && next() == 'e') ||

425 parseError("Invalid JSON value (false?)");

426 case '"': {

427 std::string S;

428 if (parseString(S)) {

429 Out = std::move(S);

430 return true;

431 }

432 return false;

433 }

434 case '[': {

436 Array &A = *Out.getAsArray();

437 eatWhitespace();

438 if (peek() == ']') {

439 ++P;

440 return true;

441 }

442 for (;;) {

443 A.emplace_back(nullptr);

444 if (!parseValue(A.back()))

445 return false;

446 eatWhitespace();

447 switch (next()) {

448 case ',':

449 eatWhitespace();

450 continue;

451 case ']':

452 return true;

453 default:

454 return parseError("Expected , or ] after array element");

455 }

456 }

457 }

458 case '{': {

460 Object &O = *Out.getAsObject();

461 eatWhitespace();

462 if (peek() == '}') {

463 ++P;

464 return true;

465 }

466 for (;;) {

467 if (next() != '"')

468 return parseError("Expected object key");

469 std::string K;

470 if (!parseString(K))

471 return false;

472 eatWhitespace();

473 if (next() != ':')

474 return parseError("Expected : after object key");

475 eatWhitespace();

476 if (!parseValue(O[std::move(K)]))

477 return false;

478 eatWhitespace();

479 switch (next()) {

480 case ',':

481 eatWhitespace();

482 continue;

483 case '}':

484 return true;

485 default:

486 return parseError("Expected , or } after object property");

487 }

488 }

489 }

490 default:

491 if (isNumber(C))

492 return parseNumber(C, Out);

493 return parseError("Invalid JSON value");

494 }

495}

496

497bool Parser::parseNumber(char First, Value &Out) {

498

499 SmallString<24> S;

500 S.push_back(First);

501 while (isNumber(peek()))

502 S.push_back(next());

503 char *End;

504

505

506

507 errno = 0;

508 int64_t I = std::strtoll(S.c_str(), &End, 10);

509 if (End == S.end() && errno != ERANGE) {

510 Out = I;

511 return true;

512 }

513

514

515

516 if (First != '-') {

517 errno = 0;

518 uint64_t UI = std::strtoull(S.c_str(), &End, 10);

519 if (End == S.end() && errno != ERANGE) {

520 Out = UI;

521 return true;

522 }

523 }

524

525 Out = std::strtod(S.c_str(), &End);

526 return End == S.end() || parseError("Invalid JSON value (number?)");

527}

528

529bool Parser::parseString(std::string &Out) {

530

531 for (char C = next(); C != '"'; C = next()) {

533 return parseError("Unterminated string");

535 return parseError("Control character in string");

537 Out.push_back(C);

538 continue;

539 }

540

541 switch (C = next()) {

542 case '"':

543 case '\\':

544 case '/':

545 Out.push_back(C);

546 break;

547 case 'b':

548 Out.push_back('\b');

549 break;

550 case 'f':

551 Out.push_back('\f');

552 break;

553 case 'n':

554 Out.push_back('\n');

555 break;

556 case 'r':

557 Out.push_back('\r');

558 break;

559 case 't':

560 Out.push_back('\t');

561 break;

562 case 'u':

563 if (!parseUnicode(Out))

564 return false;

565 break;

566 default:

567 return parseError("Invalid escape sequence");

568 }

569 }

570 return true;

571}

572

574 if (Rune < 0x80) {

575 Out.push_back(Rune & 0x7F);

576 } else if (Rune < 0x800) {

577 uint8_t FirstByte = 0xC0 | ((Rune & 0x7C0) >> 6);

578 uint8_t SecondByte = 0x80 | (Rune & 0x3F);

579 Out.push_back(FirstByte);

580 Out.push_back(SecondByte);

581 } else if (Rune < 0x10000) {

582 uint8_t FirstByte = 0xE0 | ((Rune & 0xF000) >> 12);

583 uint8_t SecondByte = 0x80 | ((Rune & 0xFC0) >> 6);

584 uint8_t ThirdByte = 0x80 | (Rune & 0x3F);

585 Out.push_back(FirstByte);

586 Out.push_back(SecondByte);

587 Out.push_back(ThirdByte);

588 } else if (Rune < 0x110000) {

589 uint8_t FirstByte = 0xF0 | ((Rune & 0x1F0000) >> 18);

590 uint8_t SecondByte = 0x80 | ((Rune & 0x3F000) >> 12);

591 uint8_t ThirdByte = 0x80 | ((Rune & 0xFC0) >> 6);

592 uint8_t FourthByte = 0x80 | (Rune & 0x3F);

593 Out.push_back(FirstByte);

594 Out.push_back(SecondByte);

595 Out.push_back(ThirdByte);

596 Out.push_back(FourthByte);

597 } else {

599 }

600}

601

602

603

604

605

606bool Parser::parseUnicode(std::string &Out) {

607

608 auto Invalid = [&] { Out.append( {'\xef', '\xbf', '\xbd'}); };

609

610 auto Parse4Hex = [this](uint16_t &Out) -> bool {

611 Out = 0;

612 char Bytes[] = {next(), next(), next(), next()};

613 for (unsigned char C : Bytes) {

614 if (!std::isxdigit(C))

615 return parseError("Invalid \\u escape sequence");

616 Out <<= 4;

617 Out |= (C > '9') ? (C & ~0x20) - 'A' + 10 : (C - '0');

618 }

619 return true;

620 };

621 uint16_t First;

622 if (!Parse4Hex(First))

623 return false;

624

625

626 while (true) {

627

630 return true;

631 }

632

633

636 return true;

637 }

638

639

640

641 if (LLVM_UNLIKELY(P + 2 > End || *P != '\\' || *(P + 1) != 'u')) {

642 Invalid();

643 return true;

644 }

645 P += 2;

646 uint16_t Second;

647 if (!Parse4Hex(Second))

648 return false;

649

650 if (LLVM_UNLIKELY(Second < 0xDC00 || Second >= 0xE000)) {

651 Invalid();

652 First = Second;

653 continue;

654 }

655

656 encodeUtf8(0x10000 | ((First - 0xD800) << 10) | (Second - 0xDC00), Out);

657 return true;

658 }

659}

660

661bool Parser::parseError(const char *Msg) {

662 int Line = 1;

663 const char *StartOfLine = Start;

664 for (const char *X = Start; X < P; ++X) {

665 if (*X == 0x0A) {

667 StartOfLine = X + 1;

668 }

669 }

670 Err.emplace(

671 std::make_unique(Msg, Line, P - StartOfLine, P - Start));

672 return false;

673}

674

676 Parser P(JSON);

678 if (P.checkUTF8())

679 if (P.parseValue(E))

680 if (P.assertEnd())

681 return std::move(E);

682 return P.takeError();

683}

685

687

689 return true;

690

693 return true;

694

695 if (ErrOffset)

696 *ErrOffset = Rest - Data;

697 return false;

698}

699

701

702 std::vector Codepoints(S.size());

703 const UTF8 *In8 = reinterpret_cast<const UTF8 *>(S.data());

704 UTF32 *Out32 = Codepoints.data();

707 Codepoints.resize(Out32 - Codepoints.data());

708 std::string Res(4 * Codepoints.size(), 0);

709 const UTF32 *In32 = Codepoints.data();

710 UTF8 *Out8 = reinterpret_cast<UTF8 *>(&Res[0]);

711 ConvertUTF32toUTF8(&In32, In32 + Codepoints.size(), &Out8, Out8 + Res.size(),

713 Res.resize(reinterpret_cast<char *>(Out8) - Res.data());

714 return Res;

715}

716

718 OS << '\"';

719 for (unsigned char C : S) {

720 if (C == 0x22 || C == 0x5C)

721 OS << '\\';

722 if (C >= 0x20) {

723 OS << C;

724 continue;

725 }

726 OS << '\\';

727 switch (C) {

728

729 case '\t':

730 OS << 't';

731 break;

732 case '\n':

733 OS << 'n';

734 break;

735 case '\r':

736 OS << 'r';

737 break;

738 default:

739 OS << 'u';

741 break;

742 }

743 }

744 OS << '\"';

745}

746

748 switch (V.kind()) {

750 valueBegin();

751 OS << "null";

752 return;

754 valueBegin();

755 OS << (*V.getAsBoolean() ? "true" : "false");

756 return;

758 valueBegin();

759 if (V.Type == Value::T_Integer)

760 OS << *V.getAsInteger();

761 else if (V.Type == Value::T_UINT64)

762 OS << *V.getAsUINT64();

763 else

764 OS << format("%.*g", std::numeric_limits::max_digits10,

765 *V.getAsNumber());

766 return;

768 valueBegin();

769 quote(OS, *V.getAsString());

770 return;

772 return array([&] {

773 for (const Value &E : *V.getAsArray())

775 });

780 });

781 }

782}

783

784void llvm::json::OStream::valueBegin() {

785 assert(Stack.back().Ctx != Object && "Only attributes allowed here");

786 if (Stack.back().HasValue) {

787 assert(Stack.back().Ctx != Singleton && "Only one value allowed here");

788 OS << ',';

789 }

790 if (Stack.back().Ctx == Array)

791 newline();

792 flushComment();

793 Stack.back().HasValue = true;

794}

795

797 assert(PendingComment.empty() && "Only one comment per value!");

798 PendingComment = Comment;

799}

800

801void OStream::flushComment() {

802 if (PendingComment.empty())

803 return;

804 OS << (IndentSize ? "/* " : "/*");

805

806 while (!PendingComment.empty()) {

807 auto Pos = PendingComment.find("*/");

809 OS << PendingComment;

810 PendingComment = "";

811 } else {

812 OS << PendingComment.take_front(Pos) << "* /";

813 PendingComment = PendingComment.drop_front(Pos + 2);

814 }

815 }

816 OS << (IndentSize ? " */" : "*/");

817

818 if (Stack.size() > 1 && Stack.back().Ctx == Singleton) {

819 if (IndentSize)

820 OS << ' ';

821 } else {

822 newline();

823 }

824}

825

826void llvm::json::OStream::newline() {

827 if (IndentSize) {

828 OS.write('\n');

829 OS.indent(Indent);

830 }

831}

832

834 valueBegin();

835 Stack.emplace_back();

836 Stack.back().Ctx = Array;

837 Indent += IndentSize;

838 OS << '[';

839}

840

842 assert(Stack.back().Ctx == Array);

843 Indent -= IndentSize;

844 if (Stack.back().HasValue)

845 newline();

846 OS << ']';

847 assert(PendingComment.empty());

848 Stack.pop_back();

849 assert(!Stack.empty());

850}

851

853 valueBegin();

854 Stack.emplace_back();

855 Stack.back().Ctx = Object;

856 Indent += IndentSize;

857 OS << '{';

858}

859

861 assert(Stack.back().Ctx == Object);

862 Indent -= IndentSize;

863 if (Stack.back().HasValue)

864 newline();

865 OS << '}';

866 assert(PendingComment.empty());

867 Stack.pop_back();

868 assert(!Stack.empty());

869}

870

872 assert(Stack.back().Ctx == Object);

873 if (Stack.back().HasValue)

874 OS << ',';

875 newline();

876 flushComment();

877 Stack.back().HasValue = true;

878 Stack.emplace_back();

879 Stack.back().Ctx = Singleton;

882 } else {

883 assert(false && "Invalid UTF-8 in attribute key");

885 }

886 OS.write(':');

887 if (IndentSize)

888 OS.write(' ');

889}

890

892 assert(Stack.back().Ctx == Singleton);

893 assert(Stack.back().HasValue && "Attribute must have a value");

894 assert(PendingComment.empty());

895 Stack.pop_back();

896 assert(Stack.back().Ctx == Object);

897}

898

900 valueBegin();

901 Stack.emplace_back();

902 Stack.back().Ctx = RawValue;

903 return OS;

904}

905

907 assert(Stack.back().Ctx == RawValue);

908 Stack.pop_back();

909}

910

911}

912}

913

916 unsigned IndentAmount = 0;

917 if ( Options .empty() && Options.getAsInteger(10, IndentAmount))

918 llvm_unreachable("json::Value format options should be an integer");

920}

921

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

#define LLVM_UNLIKELY(EXPR)

#define LLVM_LIKELY(EXPR)

This file supports working with JSON data.

static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")

static bool peek(struct InternalInstruction *insn, uint8_t &byte)

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

Lightweight error class with error context and mandatory checking.

Tagged union holding either a T or a Error.

A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...

StringRef - Represent a constant reference to a string, i.e.

static constexpr size_t npos

constexpr size_t size() const

size - Get the string size.

constexpr const char * data() const

data - Get a pointer to the start of the string (which may not be null terminated).

StringRef take_front(size_t N=1) const

Return a StringRef equal to 'this' but with only the first N elements remaining.

The instances of the Type class are immutable: once they are created, they are never changed.

Type(LLVMContext &C, TypeID tid)

LLVM Value Representation.

An Array is a JSON array, which contains heterogeneous JSON values.

void emplace_back(Args &&...A)

json::OStream allows writing well-formed JSON without materializing all structures as json::Value ahe...

void object(Block Contents)

Emit an object whose elements are emitted in the provided Block.

void rawValue(llvm::function_ref< void(raw_ostream &)> Contents)

Emit an externally-serialized value.

LLVM_ABI void attributeBegin(llvm::StringRef Key)

Definition JSON.cpp:871

void attribute(llvm::StringRef Key, const Value &Contents)

Emit an attribute whose value is self-contained (number, vector etc).

LLVM_ABI void arrayBegin()

Definition JSON.cpp:833

LLVM_ABI void objectBegin()

Definition JSON.cpp:852

LLVM_ABI raw_ostream & rawValueBegin()

Definition JSON.cpp:899

LLVM_ABI void comment(llvm::StringRef)

Emit a JavaScript comment associated with the next printed value.

Definition JSON.cpp:796

void array(Block Contents)

Emit an array whose elements are emitted in the provided Block.

LLVM_ABI void arrayEnd()

Definition JSON.cpp:841

LLVM_ABI void attributeEnd()

Definition JSON.cpp:891

LLVM_ABI void value(const Value &V)

Emit a self-contained value (number, string, vector etc).

Definition JSON.cpp:747

LLVM_ABI void rawValueEnd()

Definition JSON.cpp:906

LLVM_ABI void objectEnd()

Definition JSON.cpp:860

ObjectKey is a used to capture keys in Object.

An Object is a JSON object, which maps strings to heterogenous JSON values.

LLVM_ABI std::optional< bool > getBoolean(StringRef K) const

Definition JSON.cpp:47

LLVM_ABI Value & operator[](const ObjectKey &K)

Definition JSON.cpp:24

LLVM_ABI std::optional< double > getNumber(StringRef K) const

Definition JSON.cpp:52

LLVM_ABI const json::Object * getObject(StringRef K) const

Definition JSON.cpp:67

LLVM_ABI std::optional< llvm::StringRef > getString(StringRef K) const

Definition JSON.cpp:62

Storage::value_type value_type

LLVM_ABI Value * get(StringRef K)

Definition JSON.cpp:30

LLVM_ABI std::optional< int64_t > getInteger(StringRef K) const

Definition JSON.cpp:57

LLVM_ABI std::optional< std::nullptr_t > getNull(StringRef K) const

Definition JSON.cpp:42

std::pair< iterator, bool > try_emplace(const ObjectKey &K, Ts &&... Args)

iterator find(StringRef K)

LLVM_ABI const json::Array * getArray(StringRef K) const

Definition JSON.cpp:77

The root is the trivial Path to the root value.

LLVM_ABI void printErrorContext(const Value &, llvm::raw_ostream &) const

Print the root value with the error shown inline as a comment.

Definition JSON.cpp:300

LLVM_ABI Error getError() const

Returns the last error reported, or else a generic error.

Definition JSON.cpp:219

LLVM_ABI void report(llvm::StringLiteral Message)

Records that the value at the current path is invalid.

Definition JSON.cpp:204

Path(Root &R)

The root may be treated as a Path.

A Value is an JSON value of unknown type.

LLVM_ABI void print(llvm::raw_ostream &OS) const

Definition JSON.cpp:176

@ Number

Number values can store both int64s and doubles at full precision, depending on what they were constr...

This class implements an extremely fast bulk output stream that can only output to a stream.

A raw_ostream that writes to an std::string.

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ C

The default llvm calling convention, compatible with C.

static void abbreviateChildren(const Value &V, OStream &JOS)

Definition JSON.cpp:278

LLVM_ABI llvm::Expected< Value > parse(llvm::StringRef JSON)

Parses the provided JSON source, or returns a ParseError.

Definition JSON.cpp:675

static void abbreviate(const Value &V, OStream &JOS)

Definition JSON.cpp:252

LLVM_ABI bool operator==(const Object &LHS, const Object &RHS)

Definition JSON.cpp:87

LLVM_ABI bool isUTF8(llvm::StringRef S, size_t *ErrOffset=nullptr)

Returns true if S is valid UTF-8, which is required for use as JSON.

Definition JSON.cpp:686

LLVM_ABI std::vector< const Object::value_type * > sortedElements(const Object &O)

Definition JSON.cpp:238

static void quote(llvm::raw_ostream &OS, llvm::StringRef S)

Definition JSON.cpp:717

LLVM_ABI std::string fixUTF8(llvm::StringRef S)

Replaces invalid UTF-8 sequences in S with the replacement character (U+FFFD).

Definition JSON.cpp:700

static void encodeUtf8(uint32_t Rune, std::string &Out)

Definition JSON.cpp:573

This is an optimization pass for GlobalISel generic memory operations.

FunctionAddr VTableAddr Value

LLVM_ABI ConversionResult ConvertUTF8toUTF32(const UTF8 **sourceStart, const UTF8 *sourceEnd, UTF32 **targetStart, UTF32 *targetEnd, ConversionFlags flags)

Convert a partial UTF8 sequence to UTF32.

LLVM_ABI std::error_code inconvertibleErrorCode()

The value returned by this function can be returned from convertToErrorCode for Error values where no...

Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)

Create formatted StringError object.

auto reverse(ContainerTy &&C)

void sort(IteratorTy Start, IteratorTy End)

FunctionAddr VTableAddr Count

format_object< Ts... > format(const char *Fmt, const Ts &... Vals)

These are helper functions used to produce formatted output.

LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key

@ First

Helpers to iterate all locations in the MemoryEffectsBase class.

FunctionAddr VTableAddr uintptr_t uintptr_t Data

LLVM_ABI void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style, std::optional< size_t > Width=std::nullopt)

LLVM_ABI ConversionResult ConvertUTF32toUTF8(const UTF32 **sourceStart, const UTF32 *sourceEnd, UTF8 **targetStart, UTF8 *targetEnd, ConversionFlags flags)

bool isASCII(char C)

Checks whether character C is valid ASCII (high bit is zero).

LLVM_ABI Boolean isLegalUTF8String(const UTF8 **source, const UTF8 *sourceEnd)