/usr/include/clang/Frontend/CompilerInstance.h is in libclang-dev 3.0-6ubuntu3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 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 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 | //===-- CompilerInstance.h - Clang Compiler Instance ------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_FRONTEND_COMPILERINSTANCE_H_
#define LLVM_CLANG_FRONTEND_COMPILERINSTANCE_H_
#include "clang/Frontend/CompilerInvocation.h"
#include "clang/Lex/ModuleLoader.h"
#include "llvm/ADT/IntrusiveRefCntPtr.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/OwningPtr.h"
#include <cassert>
#include <list>
#include <string>
namespace llvm {
class raw_fd_ostream;
class Timer;
}
namespace clang {
class ASTContext;
class ASTConsumer;
class ASTReader;
class CodeCompleteConsumer;
class DiagnosticsEngine;
class DiagnosticConsumer;
class ExternalASTSource;
class FileManager;
class FrontendAction;
class Preprocessor;
class Sema;
class SourceManager;
class TargetInfo;
/// CompilerInstance - Helper class for managing a single instance of the Clang
/// compiler.
///
/// The CompilerInstance serves two purposes:
/// (1) It manages the various objects which are necessary to run the compiler,
/// for example the preprocessor, the target information, and the AST
/// context.
/// (2) It provides utility routines for constructing and manipulating the
/// common Clang objects.
///
/// The compiler instance generally owns the instance of all the objects that it
/// manages. However, clients can still share objects by manually setting the
/// object and retaking ownership prior to destroying the CompilerInstance.
///
/// The compiler instance is intended to simplify clients, but not to lock them
/// in to the compiler instance for everything. When possible, utility functions
/// come in two forms; a short form that reuses the CompilerInstance objects,
/// and a long form that takes explicit instances of any required objects.
class CompilerInstance : public ModuleLoader {
/// The options used in this compiler instance.
llvm::IntrusiveRefCntPtr<CompilerInvocation> Invocation;
/// The diagnostics engine instance.
llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diagnostics;
/// The target being compiled for.
llvm::IntrusiveRefCntPtr<TargetInfo> Target;
/// The file manager.
llvm::IntrusiveRefCntPtr<FileManager> FileMgr;
/// The source manager.
llvm::IntrusiveRefCntPtr<SourceManager> SourceMgr;
/// The preprocessor.
llvm::IntrusiveRefCntPtr<Preprocessor> PP;
/// The AST context.
llvm::IntrusiveRefCntPtr<ASTContext> Context;
/// The AST consumer.
llvm::OwningPtr<ASTConsumer> Consumer;
/// The code completion consumer.
llvm::OwningPtr<CodeCompleteConsumer> CompletionConsumer;
/// \brief The semantic analysis object.
llvm::OwningPtr<Sema> TheSema;
/// \brief The frontend timer
llvm::OwningPtr<llvm::Timer> FrontendTimer;
/// \brief Non-owning reference to the ASTReader, if one exists.
ASTReader *ModuleManager;
/// \brief Holds information about the output file.
///
/// If TempFilename is not empty we must rename it to Filename at the end.
/// TempFilename may be empty and Filename non empty if creating the temporary
/// failed.
struct OutputFile {
std::string Filename;
std::string TempFilename;
raw_ostream *OS;
OutputFile(const std::string &filename, const std::string &tempFilename,
raw_ostream *os)
: Filename(filename), TempFilename(tempFilename), OS(os) { }
};
/// The list of active output files.
std::list<OutputFile> OutputFiles;
void operator=(const CompilerInstance &); // DO NOT IMPLEMENT
CompilerInstance(const CompilerInstance&); // DO NOT IMPLEMENT
public:
CompilerInstance();
~CompilerInstance();
/// @name High-Level Operations
/// {
/// ExecuteAction - Execute the provided action against the compiler's
/// CompilerInvocation object.
///
/// This function makes the following assumptions:
///
/// - The invocation options should be initialized. This function does not
/// handle the '-help' or '-version' options, clients should handle those
/// directly.
///
/// - The diagnostics engine should have already been created by the client.
///
/// - No other CompilerInstance state should have been initialized (this is
/// an unchecked error).
///
/// - Clients should have initialized any LLVM target features that may be
/// required.
///
/// - Clients should eventually call llvm_shutdown() upon the completion of
/// this routine to ensure that any managed objects are properly destroyed.
///
/// Note that this routine may write output to 'stderr'.
///
/// \param Act - The action to execute.
/// \return - True on success.
//
// FIXME: This function should take the stream to write any debugging /
// verbose output to as an argument.
//
// FIXME: Eliminate the llvm_shutdown requirement, that should either be part
// of the context or else not CompilerInstance specific.
bool ExecuteAction(FrontendAction &Act);
/// }
/// @name Compiler Invocation and Options
/// {
bool hasInvocation() const { return Invocation != 0; }
CompilerInvocation &getInvocation() {
assert(Invocation && "Compiler instance has no invocation!");
return *Invocation;
}
/// setInvocation - Replace the current invocation.
void setInvocation(CompilerInvocation *Value);
/// }
/// @name Forwarding Methods
/// {
AnalyzerOptions &getAnalyzerOpts() {
return Invocation->getAnalyzerOpts();
}
const AnalyzerOptions &getAnalyzerOpts() const {
return Invocation->getAnalyzerOpts();
}
CodeGenOptions &getCodeGenOpts() {
return Invocation->getCodeGenOpts();
}
const CodeGenOptions &getCodeGenOpts() const {
return Invocation->getCodeGenOpts();
}
DependencyOutputOptions &getDependencyOutputOpts() {
return Invocation->getDependencyOutputOpts();
}
const DependencyOutputOptions &getDependencyOutputOpts() const {
return Invocation->getDependencyOutputOpts();
}
DiagnosticOptions &getDiagnosticOpts() {
return Invocation->getDiagnosticOpts();
}
const DiagnosticOptions &getDiagnosticOpts() const {
return Invocation->getDiagnosticOpts();
}
const FileSystemOptions &getFileSystemOpts() const {
return Invocation->getFileSystemOpts();
}
FrontendOptions &getFrontendOpts() {
return Invocation->getFrontendOpts();
}
const FrontendOptions &getFrontendOpts() const {
return Invocation->getFrontendOpts();
}
HeaderSearchOptions &getHeaderSearchOpts() {
return Invocation->getHeaderSearchOpts();
}
const HeaderSearchOptions &getHeaderSearchOpts() const {
return Invocation->getHeaderSearchOpts();
}
LangOptions &getLangOpts() {
return Invocation->getLangOpts();
}
const LangOptions &getLangOpts() const {
return Invocation->getLangOpts();
}
PreprocessorOptions &getPreprocessorOpts() {
return Invocation->getPreprocessorOpts();
}
const PreprocessorOptions &getPreprocessorOpts() const {
return Invocation->getPreprocessorOpts();
}
PreprocessorOutputOptions &getPreprocessorOutputOpts() {
return Invocation->getPreprocessorOutputOpts();
}
const PreprocessorOutputOptions &getPreprocessorOutputOpts() const {
return Invocation->getPreprocessorOutputOpts();
}
TargetOptions &getTargetOpts() {
return Invocation->getTargetOpts();
}
const TargetOptions &getTargetOpts() const {
return Invocation->getTargetOpts();
}
/// }
/// @name Diagnostics Engine
/// {
bool hasDiagnostics() const { return Diagnostics != 0; }
/// Get the current diagnostics engine.
DiagnosticsEngine &getDiagnostics() const {
assert(Diagnostics && "Compiler instance has no diagnostics!");
return *Diagnostics;
}
/// setDiagnostics - Replace the current diagnostics engine.
void setDiagnostics(DiagnosticsEngine *Value);
DiagnosticConsumer &getDiagnosticClient() const {
assert(Diagnostics && Diagnostics->getClient() &&
"Compiler instance has no diagnostic client!");
return *Diagnostics->getClient();
}
/// }
/// @name Target Info
/// {
bool hasTarget() const { return Target != 0; }
TargetInfo &getTarget() const {
assert(Target && "Compiler instance has no target!");
return *Target;
}
/// Replace the current diagnostics engine.
void setTarget(TargetInfo *Value);
/// }
/// @name File Manager
/// {
bool hasFileManager() const { return FileMgr != 0; }
/// Return the current file manager to the caller.
FileManager &getFileManager() const {
assert(FileMgr && "Compiler instance has no file manager!");
return *FileMgr;
}
void resetAndLeakFileManager() {
FileMgr.resetWithoutRelease();
}
/// setFileManager - Replace the current file manager.
void setFileManager(FileManager *Value);
/// }
/// @name Source Manager
/// {
bool hasSourceManager() const { return SourceMgr != 0; }
/// Return the current source manager.
SourceManager &getSourceManager() const {
assert(SourceMgr && "Compiler instance has no source manager!");
return *SourceMgr;
}
void resetAndLeakSourceManager() {
SourceMgr.resetWithoutRelease();
}
/// setSourceManager - Replace the current source manager.
void setSourceManager(SourceManager *Value);
/// }
/// @name Preprocessor
/// {
bool hasPreprocessor() const { return PP != 0; }
/// Return the current preprocessor.
Preprocessor &getPreprocessor() const {
assert(PP && "Compiler instance has no preprocessor!");
return *PP;
}
void resetAndLeakPreprocessor() {
PP.resetWithoutRelease();
}
/// Replace the current preprocessor.
void setPreprocessor(Preprocessor *Value);
/// }
/// @name ASTContext
/// {
bool hasASTContext() const { return Context != 0; }
ASTContext &getASTContext() const {
assert(Context && "Compiler instance has no AST context!");
return *Context;
}
void resetAndLeakASTContext() {
Context.resetWithoutRelease();
}
/// setASTContext - Replace the current AST context.
void setASTContext(ASTContext *Value);
/// \brief Replace the current Sema; the compiler instance takes ownership
/// of S.
void setSema(Sema *S);
/// }
/// @name ASTConsumer
/// {
bool hasASTConsumer() const { return Consumer != 0; }
ASTConsumer &getASTConsumer() const {
assert(Consumer && "Compiler instance has no AST consumer!");
return *Consumer;
}
/// takeASTConsumer - Remove the current AST consumer and give ownership to
/// the caller.
ASTConsumer *takeASTConsumer() { return Consumer.take(); }
/// setASTConsumer - Replace the current AST consumer; the compiler instance
/// takes ownership of \arg Value.
void setASTConsumer(ASTConsumer *Value);
/// }
/// @name Semantic analysis
/// {
bool hasSema() const { return TheSema != 0; }
Sema &getSema() const {
assert(TheSema && "Compiler instance has no Sema object!");
return *TheSema;
}
Sema *takeSema() { return TheSema.take(); }
/// }
/// @name Module Management
/// {
ASTReader *getModuleManager() const { return ModuleManager; }
/// }
/// @name Code Completion
/// {
bool hasCodeCompletionConsumer() const { return CompletionConsumer != 0; }
CodeCompleteConsumer &getCodeCompletionConsumer() const {
assert(CompletionConsumer &&
"Compiler instance has no code completion consumer!");
return *CompletionConsumer;
}
/// takeCodeCompletionConsumer - Remove the current code completion consumer
/// and give ownership to the caller.
CodeCompleteConsumer *takeCodeCompletionConsumer() {
return CompletionConsumer.take();
}
/// setCodeCompletionConsumer - Replace the current code completion consumer;
/// the compiler instance takes ownership of \arg Value.
void setCodeCompletionConsumer(CodeCompleteConsumer *Value);
/// }
/// @name Frontend timer
/// {
bool hasFrontendTimer() const { return FrontendTimer != 0; }
llvm::Timer &getFrontendTimer() const {
assert(FrontendTimer && "Compiler instance has no frontend timer!");
return *FrontendTimer;
}
/// }
/// @name Output Files
/// {
/// addOutputFile - Add an output file onto the list of tracked output files.
///
/// \param OutFile - The output file info.
void addOutputFile(const OutputFile &OutFile);
/// clearOutputFiles - Clear the output file list, destroying the contained
/// output streams.
///
/// \param EraseFiles - If true, attempt to erase the files from disk.
void clearOutputFiles(bool EraseFiles);
/// }
/// @name Construction Utility Methods
/// {
/// Create the diagnostics engine using the invocation's diagnostic options
/// and replace any existing one with it.
///
/// Note that this routine also replaces the diagnostic client,
/// allocating one if one is not provided.
///
/// \param Client If non-NULL, a diagnostic client that will be
/// attached to (and, then, owned by) the DiagnosticsEngine inside this AST
/// unit.
///
/// \param ShouldOwnClient If Client is non-NULL, specifies whether
/// the diagnostic object should take ownership of the client.
///
/// \param ShouldCloneClient If Client is non-NULL, specifies whether that
/// client should be cloned.
void createDiagnostics(int Argc, const char* const *Argv,
DiagnosticConsumer *Client = 0,
bool ShouldOwnClient = true,
bool ShouldCloneClient = true);
/// Create a DiagnosticsEngine object with a the TextDiagnosticPrinter.
///
/// The \arg Argc and \arg Argv arguments are used only for logging purposes,
/// when the diagnostic options indicate that the compiler should output
/// logging information.
///
/// If no diagnostic client is provided, this creates a
/// DiagnosticConsumer that is owned by the returned diagnostic
/// object, if using directly the caller is responsible for
/// releasing the returned DiagnosticsEngine's client eventually.
///
/// \param Opts - The diagnostic options; note that the created text
/// diagnostic object contains a reference to these options and its lifetime
/// must extend past that of the diagnostic engine.
///
/// \param Client If non-NULL, a diagnostic client that will be
/// attached to (and, then, owned by) the returned DiagnosticsEngine
/// object.
///
/// \param CodeGenOpts If non-NULL, the code gen options in use, which may be
/// used by some diagnostics printers (for logging purposes only).
///
/// \return The new object on success, or null on failure.
static llvm::IntrusiveRefCntPtr<DiagnosticsEngine>
createDiagnostics(const DiagnosticOptions &Opts, int Argc,
const char* const *Argv,
DiagnosticConsumer *Client = 0,
bool ShouldOwnClient = true,
bool ShouldCloneClient = true,
const CodeGenOptions *CodeGenOpts = 0);
/// Create the file manager and replace any existing one with it.
void createFileManager();
/// Create the source manager and replace any existing one with it.
void createSourceManager(FileManager &FileMgr);
/// Create the preprocessor, using the invocation, file, and source managers,
/// and replace any existing one with it.
void createPreprocessor();
/// Create the AST context.
void createASTContext();
/// Create an external AST source to read a PCH file and attach it to the AST
/// context.
void createPCHExternalASTSource(StringRef Path,
bool DisablePCHValidation,
bool DisableStatCache,
void *DeserializationListener);
/// Create an external AST source to read a PCH file.
///
/// \return - The new object on success, or null on failure.
static ExternalASTSource *
createPCHExternalASTSource(StringRef Path, const std::string &Sysroot,
bool DisablePCHValidation,
bool DisableStatCache,
Preprocessor &PP, ASTContext &Context,
void *DeserializationListener, bool Preamble);
/// Create a code completion consumer using the invocation; note that this
/// will cause the source manager to truncate the input source file at the
/// completion point.
void createCodeCompletionConsumer();
/// Create a code completion consumer to print code completion results, at
/// \arg Filename, \arg Line, and \arg Column, to the given output stream \arg
/// OS.
static CodeCompleteConsumer *
createCodeCompletionConsumer(Preprocessor &PP, const std::string &Filename,
unsigned Line, unsigned Column,
bool ShowMacros,
bool ShowCodePatterns, bool ShowGlobals,
raw_ostream &OS);
/// \brief Create the Sema object to be used for parsing.
void createSema(TranslationUnitKind TUKind,
CodeCompleteConsumer *CompletionConsumer);
/// Create the frontend timer and replace any existing one with it.
void createFrontendTimer();
/// Create the default output file (from the invocation's options) and add it
/// to the list of tracked output files.
///
/// \return - Null on error.
llvm::raw_fd_ostream *
createDefaultOutputFile(bool Binary = true, StringRef BaseInput = "",
StringRef Extension = "");
/// Create a new output file and add it to the list of tracked output files,
/// optionally deriving the output path name.
///
/// \return - Null on error.
llvm::raw_fd_ostream *
createOutputFile(StringRef OutputPath,
bool Binary = true, bool RemoveFileOnSignal = true,
StringRef BaseInput = "",
StringRef Extension = "",
bool UseTemporary = false);
/// Create a new output file, optionally deriving the output path name.
///
/// If \arg OutputPath is empty, then createOutputFile will derive an output
/// path location as \arg BaseInput, with any suffix removed, and \arg
/// Extension appended. If OutputPath is not stdout and \arg UseTemporary
/// is true, createOutputFile will create a new temporary file that must be
/// renamed to OutputPath in the end.
///
/// \param OutputPath - If given, the path to the output file.
/// \param Error [out] - On failure, the error message.
/// \param BaseInput - If \arg OutputPath is empty, the input path name to use
/// for deriving the output path.
/// \param Extension - The extension to use for derived output names.
/// \param Binary - The mode to open the file in.
/// \param RemoveFileOnSignal - Whether the file should be registered with
/// llvm::sys::RemoveFileOnSignal. Note that this is not safe for
/// multithreaded use, as the underlying signal mechanism is not reentrant
/// \param UseTemporary - Create a new temporary file that must be renamed to
/// OutputPath in the end
/// \param ResultPathName [out] - If given, the result path name will be
/// stored here on success.
/// \param TempPathName [out] - If given, the temporary file path name
/// will be stored here on success.
static llvm::raw_fd_ostream *
createOutputFile(StringRef OutputPath, std::string &Error,
bool Binary = true, bool RemoveFileOnSignal = true,
StringRef BaseInput = "",
StringRef Extension = "",
bool UseTemporary = false,
std::string *ResultPathName = 0,
std::string *TempPathName = 0);
/// }
/// @name Initialization Utility Methods
/// {
/// InitializeSourceManager - Initialize the source manager to set InputFile
/// as the main file.
///
/// \return True on success.
bool InitializeSourceManager(StringRef InputFile);
/// InitializeSourceManager - Initialize the source manager to set InputFile
/// as the main file.
///
/// \return True on success.
static bool InitializeSourceManager(StringRef InputFile,
DiagnosticsEngine &Diags,
FileManager &FileMgr,
SourceManager &SourceMgr,
const FrontendOptions &Opts);
/// }
virtual ModuleKey loadModule(SourceLocation ImportLoc,
IdentifierInfo &ModuleName,
SourceLocation ModuleNameLoc);
};
} // end namespace clang
#endif
|