PPCallbacks.h Source File (original) (raw)

14#ifndef LLVM_CLANG_LEX_PPCALLBACKS_H

15#define LLVM_CLANG_LEX_PPCALLBACKS_H

22#include "llvm/ADT/StringRef.h"

25class Token;

26class IdentifierInfo;

27class MacroDefinition;

28class MacroDirective;

29class MacroArgs;

30struct LexEmbedParametersResult;

37public:

52 }

84 const Token &FilenameTok,

100

101

102

103

104

105

106

107

108

109

110

114

115

116

117

118

119

120

121

122

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

172 StringRef SearchPath, StringRef RelativePath,

173 const Module *SuggestedModule,

174 bool ModuleImported,

176

177

178

179

180

181

182

183

184

186 bool ForPragma) { }

187

188

189

190

191

192

193

194

195

197 bool ForPragma) { }

198

199

200

201

202

203

204

205

206

207

208

211 const Module *Imported) {

212 }

213

214

215

216

218 }

219

220

221

222

223

225 }

226

227

230 }

231

232

234 StringRef Str) {

235 }

236

237

239 }

240

241

242

244 StringRef Value) {

245 }

246

247

248

249

251 }

252

253

255

257

258

260

261

264

265

266

267

268

269

272 }

273

274

275

277 StringRef Namespace) {

278 }

279

280

281

283 StringRef Namespace) {

284 }

285

286

289

290

291

295 }

296

297

308 };

312

313

315 }

316

317

319 }

320

321

322

324

325

326

328

329

330

332

333

334

336

337

338

342

343

346 }

347

348

349

350

351

352

353

357 }

358

359

360

363 }

364

365

368

369

370

374

375

376

377

378

379

380

382 }

383

387

388

389

390

391

392

393

396 }

397

398

399

400

401

402

403

406 }

407

408

409

410

411

414 }

415

416

417

418

419

422 }

423

424

425

426

427

430 }

431

432

433

434

435

438 }

439

440

441

442

443

446 }

447

448

449

450

451

454 }

455

456

457

458

460 }

461

462

463

464

466 }

467};

468

469

471 std::unique_ptr First, Second;

472

473public:

475 std::unique_ptr _Second)

476 : First(std::move(_First)), Second(std::move(_Second)) {}

477

479

482 FileID PrevFID) override {

484 Second->FileChanged(Loc, Reason, FileType, PrevFID);

485 }

486

490 First->LexedFileChanged(FID, Reason, FileType, PrevFID, Loc);

491 Second->LexedFileChanged(FID, Reason, FileType, PrevFID, Loc);

492 }

493

496 First->FileSkipped(SkippedFile, FilenameTok, FileType);

497 Second->FileSkipped(SkippedFile, FilenameTok, FileType);

498 }

499

502

503

506 }

507

511 First->EmbedDirective(HashLoc, FileName, IsAngled, File, Params);

512 Second->EmbedDirective(HashLoc, FileName, IsAngled, File, Params);

513 }

514

517

518

521 }

522

524 StringRef FileName, bool IsAngled,

527 StringRef RelativePath, const Module *SuggestedModule,

528 bool ModuleImported,

530 First->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,

531 FilenameRange, File, SearchPath, RelativePath,

532 SuggestedModule, ModuleImported, FileType);

533 Second->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,

534 FilenameRange, File, SearchPath, RelativePath,

535 SuggestedModule, ModuleImported, FileType);

536 }

537

539 bool ForPragma) override {

540 First->EnteredSubmodule(M, ImportLoc, ForPragma);

541 Second->EnteredSubmodule(M, ImportLoc, ForPragma);

542 }

543

545 bool ForPragma) override {

546 First->LeftSubmodule(M, ImportLoc, ForPragma);

547 Second->LeftSubmodule(M, ImportLoc, ForPragma);

548 }

549

551 const Module *Imported) override {

552 First->moduleImport(ImportLoc, Path, Imported);

553 Second->moduleImport(ImportLoc, Path, Imported);

554 }

555

557 First->EndOfMainFile();

558 Second->EndOfMainFile();

559 }

560

563 Second->Ident(Loc, str);

564 }

565

568 First->PragmaDirective(Loc, Introducer);

569 Second->PragmaDirective(Loc, Introducer);

570 }

571

573 StringRef Str) override {

575 Second->PragmaComment(Loc, Kind, Str);

576 }

577

579 First->PragmaMark(Loc, Trivia);

580 Second->PragmaMark(Loc, Trivia);

581 }

582

584 StringRef Value) override {

586 Second->PragmaDetectMismatch(Loc, Name, Value);

587 }

588

590 First->PragmaDebug(Loc, DebugType);

591 Second->PragmaDebug(Loc, DebugType);

592 }

593

596 First->PragmaMessage(Loc, Namespace, Kind, Str);

597 Second->PragmaMessage(Loc, Namespace, Kind, Str);

598 }

599

601 First->PragmaDiagnosticPush(Loc, Namespace);

602 Second->PragmaDiagnosticPush(Loc, Namespace);

603 }

604

606 First->PragmaDiagnosticPop(Loc, Namespace);

607 Second->PragmaDiagnosticPop(Loc, Namespace);

608 }

609

612 First->PragmaDiagnostic(Loc, Namespace, mapping, Str);

613 Second->PragmaDiagnostic(Loc, Namespace, mapping, Str);

614 }

615

620 }

621

625

628 First->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);

629 Second->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);

630 }

631

634 First->PragmaWarning(Loc, WarningSpec, Ids);

635 Second->PragmaWarning(Loc, WarningSpec, Ids);

636 }

637

639 First->PragmaWarningPush(Loc, Level);

640 Second->PragmaWarningPush(Loc, Level);

641 }

642

644 First->PragmaWarningPop(Loc);

645 Second->PragmaWarningPop(Loc);

646 }

647

649 First->PragmaExecCharsetPush(Loc, Str);

650 Second->PragmaExecCharsetPush(Loc, Str);

651 }

652

654 First->PragmaExecCharsetPop(Loc);

655 Second->PragmaExecCharsetPop(Loc);

656 }

657

659 First->PragmaAssumeNonNullBegin(Loc);

660 Second->PragmaAssumeNonNullBegin(Loc);

661 }

662

664 First->PragmaAssumeNonNullEnd(Loc);

665 Second->PragmaAssumeNonNullEnd(Loc);

666 }

667

670 First->MacroExpands(MacroNameTok, MD, Range, Args);

671 Second->MacroExpands(MacroNameTok, MD, Range, Args);

672 }

673

676 First->MacroDefined(MacroNameTok, MD);

677 Second->MacroDefined(MacroNameTok, MD);

678 }

679

683 First->MacroUndefined(MacroNameTok, MD, Undef);

684 Second->MacroUndefined(MacroNameTok, MD, Undef);

685 }

686

689 First->Defined(MacroNameTok, MD, Range);

690 Second->Defined(MacroNameTok, MD, Range);

691 }

692

694 First->SourceRangeSkipped(Range, EndifLoc);

695 Second->SourceRangeSkipped(Range, EndifLoc);

696 }

697

698

701 First->If(Loc, ConditionRange, ConditionValue);

702 Second->If(Loc, ConditionRange, ConditionValue);

703 }

704

705

708 First->Elif(Loc, ConditionRange, ConditionValue, IfLoc);

709 Second->Elif(Loc, ConditionRange, ConditionValue, IfLoc);

710 }

711

712

715 First->Ifdef(Loc, MacroNameTok, MD);

716 Second->Ifdef(Loc, MacroNameTok, MD);

717 }

718

719

722 First->Elifdef(Loc, MacroNameTok, MD);

723 Second->Elifdef(Loc, MacroNameTok, MD);

724 }

725

728 First->Elifdef(Loc, ConditionRange, IfLoc);

729 Second->Elifdef(Loc, ConditionRange, IfLoc);

730 }

731

732

735 First->Ifndef(Loc, MacroNameTok, MD);

736 Second->Ifndef(Loc, MacroNameTok, MD);

737 }

738

739

742 First->Elifndef(Loc, MacroNameTok, MD);

743 Second->Elifndef(Loc, MacroNameTok, MD);

744 }

745

748 First->Elifndef(Loc, ConditionRange, IfLoc);

749 Second->Elifndef(Loc, ConditionRange, IfLoc);

750 }

751

752

755 Second->Else(Loc, IfLoc);

756 }

757

758

761 Second->Endif(Loc, IfLoc);

762 }

763};

764

765}

766

767#endif

enum clang::sema::@1727::IndirectLocalPathEntry::EntryKind Kind

Defines the Diagnostic IDs-related interfaces.

llvm::MachO::FileType FileType

Defines the clang::SourceLocation class and associated facilities.

Defines the SourceManager interface.

Represents a character-granular source range.

A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...

An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...

One of these records is kept for each identifier that is lexed.

MacroArgs - An instance of this class captures information about the formal arguments specified to a ...

A description of the current definition of a macro.

Encapsulates changes to the "macros namespace" (the location where the macro name became active,...

Describes a module or submodule.

This interface provides a way to observe the actions of the preprocessor as it does its thing.

virtual void HasEmbed(SourceLocation Loc, StringRef FileName, bool IsAngled, OptionalFileEntryRef File)

Hook called when a '__has_embed' directive is read.

virtual void PragmaExecCharsetPop(SourceLocation Loc)

Callback invoked when a #pragma execution_character_set(pop) directive is read.

virtual void PragmaDirective(SourceLocation Loc, PragmaIntroducerKind Introducer)

Callback invoked when start reading any pragma directive.

virtual void Defined(const Token &MacroNameTok, const MacroDefinition &MD, SourceRange Range)

Hook called whenever the 'defined' operator is seen.

virtual void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace)

Callback invoked when a #pragma gcc diagnostic push directive is read.

virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind, StringRef Str)

Callback invoked when a #pragma comment directive is read.

virtual void Elifndef(SourceLocation Loc, SourceRange ConditionRange, SourceLocation IfLoc)

Hook called whenever an #elifndef is skipped.

virtual void PragmaWarning(SourceLocation Loc, PragmaWarningSpecifier WarningSpec, ArrayRef< int > Ids)

virtual void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD, SourceRange Range, const MacroArgs *Args)

Called by Preprocessor::HandleMacroExpandedIdentifier when a macro invocation is found.

virtual void Elifndef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD)

Hook called whenever an #elifndef branch is taken.

virtual void EnteredSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma)

Callback invoked whenever a submodule was entered.

virtual void Elif(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind ConditionValue, SourceLocation IfLoc)

Hook called whenever an #elif is seen.

virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType)

Callback invoked when a #pragma clang __debug directive is read.

virtual void EndOfMainFile()

Callback invoked when the end of the main file is reached.

virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID=FileID())

Callback invoked whenever a source file is entered or exited.

virtual void Ifndef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD)

Hook called whenever an #ifndef is seen.

virtual void If(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind ConditionValue)

Hook called whenever an #if is seen.

virtual void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok, SrcMgr::CharacteristicKind FileType)

Callback invoked whenever a source file is skipped as the result of header guard optimization.

virtual void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD, const MacroDirective *Undef)

Hook called whenever a macro #undef is seen.

virtual void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD)

Hook called whenever a macro definition is seen.

virtual void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace, diag::Severity mapping, StringRef Str)

Callback invoked when a #pragma gcc diagnostic directive is read.

virtual void Ifdef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD)

Hook called whenever an #ifdef is seen.

virtual void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name, SourceLocation StateLoc, unsigned State)

Called when an OpenCL extension is either disabled or enabled with a pragma.

PragmaWarningSpecifier

Callback invoked when a #pragma warning directive is read.

virtual void PragmaDetectMismatch(SourceLocation Loc, StringRef Name, StringRef Value)

Callback invoked when a #pragma detect_mismatch directive is read.

virtual void PragmaAssumeNonNullEnd(SourceLocation Loc)

Callback invoked when a #pragma clang assume_nonnull end directive is read.

virtual void PragmaAssumeNonNullBegin(SourceLocation Loc)

Callback invoked when a #pragma clang assume_nonnull begin directive is read.

virtual void PragmaMark(SourceLocation Loc, StringRef Trivia)

Callback invoked when a #pragma mark comment is read.

virtual void EmbedDirective(SourceLocation HashLoc, StringRef FileName, bool IsAngled, OptionalFileEntryRef File, const LexEmbedParametersResult &Params)

Callback invoked whenever an embed directive has been processed, regardless of whether the embed will...

virtual void Ident(SourceLocation Loc, StringRef str)

Callback invoked when a #ident or #sccs directive is read.

virtual void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled, OptionalFileEntryRef File, SrcMgr::CharacteristicKind FileType)

Hook called when a '__has_include' or '__has_include_next' directive is read.

virtual void PragmaMessage(SourceLocation Loc, StringRef Namespace, PragmaMessageKind Kind, StringRef Str)

Callback invoked when a #pragma message directive is read.

virtual void Elifdef(SourceLocation Loc, SourceRange ConditionRange, SourceLocation IfLoc)

Hook called whenever an #elifdef is skipped.

virtual void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc)

Hook called when a source range is skipped.

virtual void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str)

Callback invoked when a #pragma execution_character_set(push) directive is read.

virtual void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace)

Callback invoked when a #pragma gcc diagnostic pop directive is read.

virtual void PragmaWarningPop(SourceLocation Loc)

Callback invoked when a #pragma warning(pop) directive is read.

virtual void Elifdef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD)

Hook called whenever an #elifdef branch is taken.

virtual void LexedFileChanged(FileID FID, LexedFileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID, SourceLocation Loc)

Callback invoked whenever the Lexer moves to a different file for lexing.

virtual void LeftSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma)

Callback invoked whenever a submodule was left.

virtual void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName, bool IsAngled, CharSourceRange FilenameRange, OptionalFileEntryRef File, StringRef SearchPath, StringRef RelativePath, const Module *SuggestedModule, bool ModuleImported, SrcMgr::CharacteristicKind FileType)

Callback invoked whenever an inclusion directive of any kind (#include, #import, etc....

virtual void Else(SourceLocation Loc, SourceLocation IfLoc)

Hook called whenever an #else is seen.

PragmaMessageKind

Determines the kind of #pragma invoking a call to PragmaMessage.

@ PMK_Warning

#pragma GCC warning has been invoked.

@ PMK_Error

#pragma GCC error has been invoked.

@ PMK_Message

#pragma message has been invoked.

virtual bool FileNotFound(StringRef FileName)

Callback invoked whenever the preprocessor cannot find a file for an inclusion directive.

virtual void PragmaWarningPush(SourceLocation Loc, int Level)

Callback invoked when a #pragma warning(push) directive is read.

virtual void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path, const Module *Imported)

Callback invoked whenever there was an explicit module-import syntax.

virtual bool EmbedFileNotFound(StringRef FileName)

Callback invoked whenever the preprocessor cannot find a file for an embed directive.

virtual void Endif(SourceLocation Loc, SourceLocation IfLoc)

Hook called whenever an #endif is seen.

Simple wrapper class for chaining callbacks.

void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD, const MacroDirective *Undef) override

Hook called whenever a macro #undef is seen.

void EnteredSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma) override

Callback invoked whenever a submodule was entered.

void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD, SourceRange Range, const MacroArgs *Args) override

Called by Preprocessor::HandleMacroExpandedIdentifier when a macro invocation is found.

void If(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind ConditionValue) override

Hook called whenever an #if is seen.

void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID) override

Callback invoked whenever a source file is entered or exited.

void Endif(SourceLocation Loc, SourceLocation IfLoc) override

Hook called whenever an #endif is seen.

bool EmbedFileNotFound(StringRef FileName) override

Callback invoked whenever the preprocessor cannot find a file for an embed directive.

void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override

Callback invoked when a #pragma execution_character_set(push) directive is read.

void Elifndef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD) override

Hook called whenever an #elifndef is taken.

void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled, OptionalFileEntryRef File, SrcMgr::CharacteristicKind FileType) override

Hook called when a '__has_include' or '__has_include_next' directive is read.

void PragmaAssumeNonNullEnd(SourceLocation Loc) override

Callback invoked when a #pragma clang assume_nonnull end directive is read.

void PragmaWarningPop(SourceLocation Loc) override

Callback invoked when a #pragma warning(pop) directive is read.

void EmbedDirective(SourceLocation HashLoc, StringRef FileName, bool IsAngled, OptionalFileEntryRef File, const LexEmbedParametersResult &Params) override

Callback invoked whenever an embed directive has been processed, regardless of whether the embed will...

void Elifndef(SourceLocation Loc, SourceRange ConditionRange, SourceLocation IfLoc) override

Hook called whenever an #elifndef is skipped.

void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override

Hook called when a source range is skipped.

void LeftSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma) override

Callback invoked whenever a submodule was left.

void PragmaWarningPush(SourceLocation Loc, int Level) override

Callback invoked when a #pragma warning(push) directive is read.

void PragmaDetectMismatch(SourceLocation Loc, StringRef Name, StringRef Value) override

Callback invoked when a #pragma detect_mismatch directive is read.

void PragmaDebug(SourceLocation Loc, StringRef DebugType) override

Callback invoked when a #pragma clang __debug directive is read.

void Defined(const Token &MacroNameTok, const MacroDefinition &MD, SourceRange Range) override

Hook called whenever the 'defined' operator is seen.

void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace, diag::Severity mapping, StringRef Str) override

Callback invoked when a #pragma gcc diagnostic directive is read.

~PPChainedCallbacks() override

void PragmaDirective(SourceLocation Loc, PragmaIntroducerKind Introducer) override

Callback invoked when start reading any pragma directive.

void PragmaAssumeNonNullBegin(SourceLocation Loc) override

Callback invoked when a #pragma clang assume_nonnull begin directive is read.

void Else(SourceLocation Loc, SourceLocation IfLoc) override

Hook called whenever an #else is seen.

void Ident(SourceLocation Loc, StringRef str) override

Callback invoked when a #ident or #sccs directive is read.

void HasEmbed(SourceLocation Loc, StringRef FileName, bool IsAngled, OptionalFileEntryRef File) override

Hook called when a '__has_embed' directive is read.

void Ifdef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD) override

Hook called whenever an #ifdef is seen.

void Elifdef(SourceLocation Loc, SourceRange ConditionRange, SourceLocation IfLoc) override

Hook called whenever an #elifdef is skipped.

void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) override

Callback invoked when a #pragma gcc diagnostic push directive is read.

void EndOfMainFile() override

Callback invoked when the end of the main file is reached.

void PragmaExecCharsetPop(SourceLocation Loc) override

Callback invoked when a #pragma execution_character_set(pop) directive is read.

bool FileNotFound(StringRef FileName) override

Callback invoked whenever the preprocessor cannot find a file for an inclusion directive.

void LexedFileChanged(FileID FID, LexedFileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID, SourceLocation Loc) override

Callback invoked whenever the Lexer moves to a different file for lexing.

void PragmaMark(SourceLocation Loc, StringRef Trivia) override

Callback invoked when a #pragma mark comment is read.

void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name, SourceLocation StateLoc, unsigned State) override

Called when an OpenCL extension is either disabled or enabled with a pragma.

PPChainedCallbacks(std::unique_ptr< PPCallbacks > _First, std::unique_ptr< PPCallbacks > _Second)

void Elifdef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD) override

Hook called whenever an #elifdef is taken.

void PragmaMessage(SourceLocation Loc, StringRef Namespace, PragmaMessageKind Kind, StringRef Str) override

Callback invoked when a #pragma message directive is read.

void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind, StringRef Str) override

Callback invoked when a #pragma comment directive is read.

void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) override

Callback invoked when a #pragma gcc diagnostic pop directive is read.

void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path, const Module *Imported) override

Callback invoked whenever there was an explicit module-import syntax.

void PragmaWarning(SourceLocation Loc, PragmaWarningSpecifier WarningSpec, ArrayRef< int > Ids) override

void Ifndef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD) override

Hook called whenever an #ifndef is seen.

void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok, SrcMgr::CharacteristicKind FileType) override

Callback invoked whenever a source file is skipped as the result of header guard optimization.

void Elif(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind ConditionValue, SourceLocation IfLoc) override

Hook called whenever an #elif is seen.

void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) override

Hook called whenever a macro definition is seen.

void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName, bool IsAngled, CharSourceRange FilenameRange, OptionalFileEntryRef File, StringRef SearchPath, StringRef RelativePath, const Module *SuggestedModule, bool ModuleImported, SrcMgr::CharacteristicKind FileType) override

Callback invoked whenever an inclusion directive of any kind (#include, #import, etc....

Encodes a location in the source.

A trivial tuple used to represent a source range.

Token - This structure provides full information about a lexed token.

CharacteristicKind

Indicates whether a file or directory holds normal user code, system code, or system code which is im...

Severity

Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing),...

The JSON file list parser is used to communicate input to InstallAPI.

PragmaIntroducerKind

Describes how the pragma was introduced, e.g., with #pragma, _Pragma, or __pragma.