diff options
Diffstat (limited to 'clang/lib/Frontend')
33 files changed, 1862 insertions, 1944 deletions
diff --git a/clang/lib/Frontend/ASTConsumers.cpp b/clang/lib/Frontend/ASTConsumers.cpp index 178f1bf8e1e..954ebd69973 100644 --- a/clang/lib/Frontend/ASTConsumers.cpp +++ b/clang/lib/Frontend/ASTConsumers.cpp @@ -12,7 +12,7 @@ //===----------------------------------------------------------------------===// #include "clang/Frontend/ASTConsumers.h" -#include "clang/Frontend/DocumentXML.h" +#include "clang/Frontend/DocumentXML.h" #include "clang/Frontend/PathDiagnosticClients.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/SourceManager.h" @@ -37,11 +37,11 @@ namespace { class ASTPrinter : public ASTConsumer { llvm::raw_ostream &Out; bool Dump; - + public: - ASTPrinter(llvm::raw_ostream* o = NULL, bool Dump = false) + ASTPrinter(llvm::raw_ostream* o = NULL, bool Dump = false) : Out(o? *o : llvm::errs()), Dump(Dump) { } - + virtual void HandleTranslationUnit(ASTContext &Context) { PrintingPolicy Policy = Context.PrintingPolicy; Policy.Dump = Dump; @@ -63,21 +63,19 @@ namespace { public: ASTPrinterXML(llvm::raw_ostream& o) : Doc("CLANG_XML", o) {} - + void Initialize(ASTContext &Context) { Doc.initialize(Context); } virtual void HandleTranslationUnit(ASTContext &Ctx) { Doc.addSubNode("TranslationUnit"); - for (DeclContext::decl_iterator + for (DeclContext::decl_iterator D = Ctx.getTranslationUnitDecl()->decls_begin(), DEnd = Ctx.getTranslationUnitDecl()->decls_end(); - D != DEnd; + D != DEnd; ++D) - { Doc.PrintDecl(*D); - } Doc.toParent(); Doc.finalize(); } @@ -88,9 +86,9 @@ namespace { ASTConsumer *clang::CreateASTPrinterXML(llvm::raw_ostream* out) { return new ASTPrinterXML(out ? *out : llvm::outs()); } - -ASTConsumer *clang::CreateASTDumper() { - return new ASTPrinter(0, true); + +ASTConsumer *clang::CreateASTDumper() { + return new ASTPrinter(0, true); } //===----------------------------------------------------------------------===// @@ -108,7 +106,7 @@ namespace { for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I) HandleTopLevelSingleDecl(*I); } - + void HandleTopLevelSingleDecl(Decl *D); }; } @@ -116,7 +114,7 @@ namespace { void ASTViewer::HandleTopLevelSingleDecl(Decl *D) { if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { FD->print(llvm::errs()); - + if (FD->getBodyIfAvailable()) { llvm::errs() << '\n'; FD->getBodyIfAvailable()->viewAST(); @@ -124,10 +122,10 @@ void ASTViewer::HandleTopLevelSingleDecl(Decl *D) { } return; } - + if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { MD->print(llvm::errs()); - + if (MD->getBody()) { llvm::errs() << '\n'; MD->getBody()->viewAST(); @@ -157,7 +155,7 @@ public: }; } // end anonymous namespace -void DeclContextPrinter::PrintDeclContext(const DeclContext* DC, +void DeclContextPrinter::PrintDeclContext(const DeclContext* DC, unsigned Indentation) { // Print DeclContext name. switch (DC->getDeclKind()) { @@ -231,7 +229,7 @@ void DeclContextPrinter::PrintDeclContext(const DeclContext* DC, // Print the parameters. Out << "("; bool PrintComma = false; - for (FunctionDecl::param_const_iterator I = FD->param_begin(), + for (FunctionDecl::param_const_iterator I = FD->param_begin(), E = FD->param_end(); I != E; ++I) { if (PrintComma) Out << ", "; @@ -254,7 +252,7 @@ void DeclContextPrinter::PrintDeclContext(const DeclContext* DC, // Print the parameters. Out << "("; bool PrintComma = false; - for (FunctionDecl::param_const_iterator I = D->param_begin(), + for (FunctionDecl::param_const_iterator I = D->param_begin(), E = D->param_end(); I != E; ++I) { if (PrintComma) Out << ", "; @@ -284,7 +282,7 @@ void DeclContextPrinter::PrintDeclContext(const DeclContext* DC, // Print the parameters. Out << "("; bool PrintComma = false; - for (FunctionDecl::param_const_iterator I = D->param_begin(), + for (FunctionDecl::param_const_iterator I = D->param_begin(), E = D->param_end(); I != E; ++I) { if (PrintComma) Out << ", "; @@ -354,7 +352,7 @@ void DeclContextPrinter::PrintDeclContext(const DeclContext* DC, case Decl::CXXRecord: case Decl::ObjCMethod: case Decl::ObjCInterface: - case Decl::ObjCCategory: + case Decl::ObjCCategory: case Decl::ObjCProtocol: case Decl::ObjCImplementation: case Decl::ObjCCategoryImpl: @@ -416,8 +414,8 @@ void DeclContextPrinter::PrintDeclContext(const DeclContext* DC, } } } -ASTConsumer *clang::CreateDeclContextPrinter() { - return new DeclContextPrinter(); +ASTConsumer *clang::CreateDeclContextPrinter() { + return new DeclContextPrinter(); } //===----------------------------------------------------------------------===// @@ -428,7 +426,7 @@ class InheritanceViewer : public ASTConsumer { const std::string clsname; public: InheritanceViewer(const std::string& cname) : clsname(cname) {} - + void HandleTranslationUnit(ASTContext &C) { for (ASTContext::type_iterator I=C.types_begin(),E=C.types_end(); I!=E; ++I) if (RecordType *T = dyn_cast<RecordType>(*I)) { @@ -436,12 +434,12 @@ public: // FIXME: This lookup needs to be generalized to handle namespaces and // (when we support them) templates. if (D->getNameAsString() == clsname) { - D->viewInheritance(C); + D->viewInheritance(C); } } } } -}; +}; } ASTConsumer *clang::CreateInheritanceViewer(const std::string& clsname) { diff --git a/clang/lib/Frontend/ASTUnit.cpp b/clang/lib/Frontend/ASTUnit.cpp index 4cd92808f50..609889aad9f 100644 --- a/clang/lib/Frontend/ASTUnit.cpp +++ b/clang/lib/Frontend/ASTUnit.cpp @@ -38,38 +38,38 @@ class VISIBILITY_HIDDEN PCHInfoCollector : public PCHReaderListener { std::string &TargetTriple; std::string &Predefines; unsigned &Counter; - + unsigned NumHeaderInfos; - + public: PCHInfoCollector(LangOptions &LangOpt, HeaderSearch &HSI, std::string &TargetTriple, std::string &Predefines, unsigned &Counter) : LangOpt(LangOpt), HSI(HSI), TargetTriple(TargetTriple), Predefines(Predefines), Counter(Counter), NumHeaderInfos(0) {} - + virtual bool ReadLanguageOptions(const LangOptions &LangOpts) { LangOpt = LangOpts; return false; } - + virtual bool ReadTargetTriple(const std::string &Triple) { TargetTriple = Triple; return false; } - - virtual bool ReadPredefinesBuffer(const char *PCHPredef, + + virtual bool ReadPredefinesBuffer(const char *PCHPredef, unsigned PCHPredefLen, FileID PCHBufferID, std::string &SuggestedPredefines) { Predefines = PCHPredef; return false; } - + virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI) { HSI.setHeaderFileInfoForUID(HFI, NumHeaderInfos++); } - + virtual void ReadCounter(unsigned Value) { Counter = Value; } @@ -88,7 +88,7 @@ FileManager &ASTUnit::getFileManager() { ASTUnit *ASTUnit::LoadFromPCHFile(const std::string &Filename, FileManager &FileMgr, std::string *ErrMsg) { - + llvm::OwningPtr<ASTUnit> AST(new ASTUnit()); AST->DiagClient.reset(new TextDiagnosticBuffer()); @@ -96,12 +96,12 @@ ASTUnit *ASTUnit::LoadFromPCHFile(const std::string &Filename, AST->HeaderInfo.reset(new HeaderSearch(FileMgr)); AST->SourceMgr.reset(new SourceManager()); - + Diagnostic &Diags = *AST->Diags.get(); SourceManager &SourceMgr = *AST->SourceMgr.get(); // Gather Info for preprocessor construction later on. - + LangOptions LangInfo; HeaderSearch &HeaderInfo = *AST->HeaderInfo.get(); std::string TargetTriple; @@ -118,16 +118,16 @@ ASTUnit *ASTUnit::LoadFromPCHFile(const std::string &Filename, switch (Reader->ReadPCH(Filename)) { case PCHReader::Success: break; - + case PCHReader::Failure: case PCHReader::IgnorePCH: if (ErrMsg) *ErrMsg = "Could not load PCH file"; return NULL; } - + // PCH loaded successfully. Now create the preprocessor. - + // Get information about the target being compiled for. AST->Target.reset(TargetInfo::CreateTargetInfo(TargetTriple)); AST->PP.reset(new Preprocessor(Diags, LangInfo, *AST->Target.get(), @@ -137,7 +137,7 @@ ASTUnit *ASTUnit::LoadFromPCHFile(const std::string &Filename, PP.setPredefines(Predefines); PP.setCounterValue(Counter); Reader->setPreprocessor(PP); - + // Create and initialize the ASTContext. AST->Ctx.reset(new ASTContext(LangInfo, @@ -149,14 +149,14 @@ ASTUnit *ASTUnit::LoadFromPCHFile(const std::string &Filename, /* FreeMemory = */ true, /* size_reserve = */0)); ASTContext &Context = *AST->Ctx.get(); - + Reader->InitializeContext(Context); - + // Attach the PCH reader to the AST context as an external AST // source, so that declarations will be deserialized from the // PCH file as needed. Source.reset(Reader.take()); Context.setExternalSource(Source); - return AST.take(); + return AST.take(); } diff --git a/clang/lib/Frontend/AnalysisConsumer.cpp b/clang/lib/Frontend/AnalysisConsumer.cpp index a633a62df29..2d07d89e044 100644 --- a/clang/lib/Frontend/AnalysisConsumer.cpp +++ b/clang/lib/Frontend/AnalysisConsumer.cpp @@ -44,7 +44,7 @@ static ExplodedNode::Auditor* CreateUbiViz(); // Basic type definitions. //===----------------------------------------------------------------------===// -namespace { +namespace { typedef void (*CodeAction)(AnalysisManager& Mgr); } // end anonymous namespace @@ -55,8 +55,8 @@ namespace { static PathDiagnosticClient* CreatePlistHTMLDiagnosticClient(const std::string& prefix, Preprocessor* PP, PreprocessorFactory* PPF) { - llvm::sys::Path F(prefix); - PathDiagnosticClientFactory *PF = + llvm::sys::Path F(prefix); + PathDiagnosticClientFactory *PF = CreateHTMLDiagnosticClientFactory(F.getDirname(), PP, PPF); return CreatePlistDiagnosticClient(prefix, PP, PPF, PF); } @@ -73,9 +73,9 @@ namespace { Actions ObjCMethodActions; Actions ObjCImplementationActions; Actions TranslationUnitActions; - + public: - const LangOptions& LOpts; + const LangOptions& LOpts; Diagnostic &Diags; ASTContext* Ctx; Preprocessor* PP; @@ -127,7 +127,7 @@ namespace { #include "clang/Frontend/Analyses.def" } } - + if (ManagerRegistry::ConstraintMgrCreator != 0) CreateConstraintMgr = ManagerRegistry::ConstraintMgrCreator; else { @@ -140,42 +140,42 @@ namespace { } } } - + void addCodeAction(CodeAction action) { FunctionActions.push_back(action); ObjCMethodActions.push_back(action); } - + void addObjCImplementationAction(CodeAction action) { ObjCImplementationActions.push_back(action); } - + void addTranslationUnitAction(CodeAction action) { TranslationUnitActions.push_back(action); } - + virtual void Initialize(ASTContext &Context) { Ctx = &Context; - Mgr.reset(new AnalysisManager(*Ctx, Diags, LOpts, PD, + Mgr.reset(new AnalysisManager(*Ctx, Diags, LOpts, PD, CreateStoreMgr, CreateConstraintMgr, - Opts.AnalyzerDisplayProgress, - Opts.VisualizeEGDot, Opts.VisualizeEGUbi, + Opts.AnalyzerDisplayProgress, + Opts.VisualizeEGDot, Opts.VisualizeEGUbi, Opts.PurgeDead, Opts.EagerlyAssume, Opts.TrimGraph)); } - + virtual void HandleTopLevelDecl(DeclGroupRef D) { for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I) HandleTopLevelSingleDecl(*I); } - + void HandleTopLevelSingleDecl(Decl *D); virtual void HandleTranslationUnit(ASTContext &C); - + void HandleCode(Decl* D, Stmt* Body, Actions& actions); }; - - + + } // end anonymous namespace @@ -184,54 +184,54 @@ namespace llvm { static inline void Profile(CodeAction X, FoldingSetNodeID& ID) { ID.AddPointer(reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(X))); } - }; + }; } //===----------------------------------------------------------------------===// // AnalysisConsumer implementation. //===----------------------------------------------------------------------===// -void AnalysisConsumer::HandleTopLevelSingleDecl(Decl *D) { +void AnalysisConsumer::HandleTopLevelSingleDecl(Decl *D) { switch (D->getKind()) { case Decl::Function: { FunctionDecl* FD = cast<FunctionDecl>(D); - if (Opts.AnalyzeSpecificFunction.size() > 0 && + if (Opts.AnalyzeSpecificFunction.size() > 0 && Opts.AnalyzeSpecificFunction != FD->getIdentifier()->getName()) break; - + Stmt* Body = FD->getBody(); if (Body) HandleCode(FD, Body, FunctionActions); break; } - + case Decl::ObjCMethod: { ObjCMethodDecl* MD = cast<ObjCMethodDecl>(D); - + if (Opts.AnalyzeSpecificFunction.size() > 0 && Opts.AnalyzeSpecificFunction != MD->getSelector().getAsString()) return; - + Stmt* Body = MD->getBody(); if (Body) HandleCode(MD, Body, ObjCMethodActions); break; } - + default: break; } } void AnalysisConsumer::HandleTranslationUnit(ASTContext &C) { - if(!TranslationUnitActions.empty()) { - for (Actions::iterator I = TranslationUnitActions.begin(), + if (!TranslationUnitActions.empty()) { + for (Actions::iterator I = TranslationUnitActions.begin(), E = TranslationUnitActions.end(); I != E; ++I) - (*I)(*Mgr); + (*I)(*Mgr); } if (!ObjCImplementationActions.empty()) { TranslationUnitDecl *TUD = C.getTranslationUnitDecl(); - + for (DeclContext::decl_iterator I = TUD->decls_begin(), E = TUD->decls_end(); I != E; ++I) @@ -246,7 +246,7 @@ void AnalysisConsumer::HandleTranslationUnit(ASTContext &C) { } void AnalysisConsumer::HandleCode(Decl* D, Stmt* Body, Actions& actions) { - + // Don't run the actions if an error has occured with parsing the file. if (Diags.hasErrorOccurred()) return; @@ -255,13 +255,13 @@ void AnalysisConsumer::HandleCode(Decl* D, Stmt* Body, Actions& actions) { // otherwise specified. if (!Opts.AnalyzeAll && !Ctx->getSourceManager().isFromMainFile(D->getLocation())) - return; + return; Mgr->setEntryContext(D); - - // Dispatch on the actions. + + // Dispatch on the actions. for (Actions::iterator I = actions.begin(), E = actions.end(); I != E; ++I) - (*I)(*Mgr); + (*I)(*Mgr); } //===----------------------------------------------------------------------===// @@ -283,8 +283,8 @@ static void ActionWarnUninitVals(AnalysisManager& mgr) { static void ActionGRExprEngine(AnalysisManager& mgr, GRTransferFuncs* tf, bool StandardWarnings = true) { - - + + llvm::OwningPtr<GRTransferFuncs> TF(tf); // Display progress. @@ -297,7 +297,7 @@ static void ActionGRExprEngine(AnalysisManager& mgr, GRTransferFuncs* tf, GRExprEngine Eng(mgr); Eng.setTransferFunctions(tf); - + if (StandardWarnings) { Eng.RegisterInternalChecks(); RegisterAppleChecks(Eng, *mgr.getCodeDecl()); @@ -309,10 +309,10 @@ static void ActionGRExprEngine(AnalysisManager& mgr, GRTransferFuncs* tf, Auditor.reset(CreateUbiViz()); ExplodedNode::SetAuditor(Auditor.get()); } - + // Execute the worklist algorithm. Eng.ExecuteWorkList(mgr.getEntryStackFrame()); - + // Release the auditor (if any) so that it doesn't monitor the graph // created BugReporter. ExplodedNode::SetAuditor(0); @@ -320,34 +320,34 @@ static void ActionGRExprEngine(AnalysisManager& mgr, GRTransferFuncs* tf, // Visualize the exploded graph. if (mgr.shouldVisualizeGraphviz()) Eng.ViewGraph(mgr.shouldTrimGraph()); - + // Display warnings. Eng.getBugReporter().FlushReports(); } static void ActionCheckerCFRefAux(AnalysisManager& mgr, bool GCEnabled, bool StandardWarnings) { - + GRTransferFuncs* TF = MakeCFRefCountTF(mgr.getASTContext(), GCEnabled, mgr.getLangOptions()); - + ActionGRExprEngine(mgr, TF, StandardWarnings); } static void ActionCheckerCFRef(AnalysisManager& mgr) { - + switch (mgr.getLangOptions().getGCMode()) { default: assert (false && "Invalid GC mode."); case LangOptions::NonGC: ActionCheckerCFRefAux(mgr, false, true); break; - + case LangOptions::GCOnly: ActionCheckerCFRefAux(mgr, true, true); break; - + case LangOptions::HybridGC: ActionCheckerCFRefAux(mgr, false, true); ActionCheckerCFRefAux(mgr, true, false); @@ -357,7 +357,7 @@ static void ActionCheckerCFRef(AnalysisManager& mgr) { static void ActionDisplayLiveVariables(AnalysisManager& mgr) { if (LiveVariables* L = mgr.getLiveVariables()) { - mgr.DisplayFunction(); + mgr.DisplayFunction(); L->dumpBlockLiveness(mgr.getSourceManager()); } } @@ -377,28 +377,28 @@ static void ActionCFGView(AnalysisManager& mgr) { } static void ActionSecuritySyntacticChecks(AnalysisManager &mgr) { - BugReporter BR(mgr); + BugReporter BR(mgr); CheckSecuritySyntaxOnly(mgr.getCodeDecl(), BR); } static void ActionWarnObjCDealloc(AnalysisManager& mgr) { if (mgr.getLangOptions().getGCMode() == LangOptions::GCOnly) return; - + BugReporter BR(mgr); - - CheckObjCDealloc(cast<ObjCImplementationDecl>(mgr.getCodeDecl()), - mgr.getLangOptions(), BR); + + CheckObjCDealloc(cast<ObjCImplementationDecl>(mgr.getCodeDecl()), + mgr.getLangOptions(), BR); } static void ActionWarnObjCUnusedIvars(AnalysisManager& mgr) { BugReporter BR(mgr); - CheckObjCUnusedIvar(cast<ObjCImplementationDecl>(mgr.getCodeDecl()), BR); + CheckObjCUnusedIvar(cast<ObjCImplementationDecl>(mgr.getCodeDecl()), BR); } static void ActionWarnObjCMethSigs(AnalysisManager& mgr) { BugReporter BR(mgr); - + CheckObjCInstMethSignature(cast<ObjCImplementationDecl>(mgr.getCodeDecl()), BR); } @@ -426,7 +426,7 @@ ASTConsumer* clang::CreateAnalysisConsumer(Diagnostic &diags, Preprocessor* pp, #include "clang/Frontend/Analyses.def" default: break; } - + // Last, disable the effects of '-Werror' when using the AnalysisConsumer. diags.setWarningsAsErrors(false); @@ -438,7 +438,7 @@ ASTConsumer* clang::CreateAnalysisConsumer(Diagnostic &diags, Preprocessor* pp, //===----------------------------------------------------------------------===// namespace { - + class UbigraphViz : public ExplodedNode::Auditor { llvm::OwningPtr<llvm::raw_ostream> Out; llvm::sys::Path Dir, Filename; @@ -446,21 +446,21 @@ class UbigraphViz : public ExplodedNode::Auditor { typedef llvm::DenseMap<void*,unsigned> VMap; VMap M; - + public: UbigraphViz(llvm::raw_ostream* out, llvm::sys::Path& dir, llvm::sys::Path& filename); - + ~UbigraphViz(); - - virtual void AddEdge(ExplodedNode* Src, ExplodedNode* Dst); + + virtual void AddEdge(ExplodedNode* Src, ExplodedNode* Dst); }; - + } // end anonymous namespace static ExplodedNode::Auditor* CreateUbiViz() { std::string ErrMsg; - + llvm::sys::Path Dir = llvm::sys::Path::GetTemporaryDirectory(&ErrMsg); if (!ErrMsg.empty()) return 0; @@ -473,31 +473,31 @@ static ExplodedNode::Auditor* CreateUbiViz() { return 0; llvm::errs() << "Writing '" << Filename.str() << "'.\n"; - + llvm::OwningPtr<llvm::raw_fd_ostream> Stream; Stream.reset(new llvm::raw_fd_ostream(Filename.c_str(), ErrMsg)); if (!ErrMsg.empty()) return 0; - + return new UbigraphViz(Stream.take(), Dir, Filename); } void UbigraphViz::AddEdge(ExplodedNode* Src, ExplodedNode* Dst) { - + assert (Src != Dst && "Self-edges are not allowed."); - + // Lookup the Src. If it is a new node, it's a root. VMap::iterator SrcI= M.find(Src); unsigned SrcID; - + if (SrcI == M.end()) { M[Src] = SrcID = Cntr++; *Out << "('vertex', " << SrcID << ", ('color','#00ff00'))\n"; } else SrcID = SrcI->second; - + // Lookup the Dst. VMap::iterator DstI= M.find(Dst); unsigned DstID; @@ -513,7 +513,7 @@ void UbigraphViz::AddEdge(ExplodedNode* Src, ExplodedNode* Dst) { } // Add the edge. - *Out << "('edge', " << SrcID << ", " << DstID + *Out << "('edge', " << SrcID << ", " << DstID << ", ('arrow','true'), ('oriented', 'true'))\n"; } @@ -535,11 +535,11 @@ UbigraphViz::~UbigraphViz() { args.push_back(Ubiviz.c_str()); args.push_back(Filename.c_str()); args.push_back(0); - + if (llvm::sys::Program::ExecuteAndWait(Ubiviz, &args[0],0,0,0,0,&ErrMsg)) { llvm::errs() << "Error viewing graph: " << ErrMsg << "\n"; } - + // Delete the directory. - Dir.eraseFromDisk(true); + Dir.eraseFromDisk(true); } diff --git a/clang/lib/Frontend/Backend.cpp b/clang/lib/Frontend/Backend.cpp index 964b4700fe0..d7097b7f06a 100644 --- a/clang/lib/Frontend/Backend.cpp +++ b/clang/lib/Frontend/Backend.cpp @@ -47,9 +47,9 @@ namespace { Timer LLVMIRGeneration; Timer CodeGenerationTime; - + llvm::OwningPtr<CodeGenerator> Gen; - + llvm::Module *TheModule; llvm::TargetData *TheTargetData; @@ -72,13 +72,13 @@ namespace { bool AddEmitPasses(std::string &Error); void EmitAssembly(); - - public: - BackendConsumer(BackendAction action, Diagnostic &Diags, + + public: + BackendConsumer(BackendAction action, Diagnostic &Diags, const LangOptions &langopts, const CompileOptions &compopts, const std::string &infile, llvm::raw_ostream* OS, LLVMContext& C) : - Action(action), + Action(action), CompileOpts(compopts), AsmOutStream(OS), LLVMIRGeneration("LLVM IR Generation Time"), @@ -86,11 +86,11 @@ namespace { Gen(CreateLLVMCodeGen(Diags, infile, compopts, C)), TheModule(0), TheTargetData(0), ModuleProvider(0), CodeGenPasses(0), PerModulePasses(0), PerFunctionPasses(0) { - + if (AsmOutStream) FormattedOutStream.setStream(*AsmOutStream, formatted_raw_ostream::PRESERVE_STREAM); - + // Enable -time-passes if -ftime-report is enabled. llvm::TimePassesIsEnabled = CompileOpts.TimePasses; } @@ -105,25 +105,25 @@ namespace { virtual void Initialize(ASTContext &Ctx) { Context = &Ctx; - + if (CompileOpts.TimePasses) LLVMIRGeneration.startTimer(); - + Gen->Initialize(Ctx); TheModule = Gen->GetModule(); ModuleProvider = new ExistingModuleProvider(TheModule); TheTargetData = new llvm::TargetData(Ctx.Target.getTargetDescription()); - + if (CompileOpts.TimePasses) LLVMIRGeneration.stopTimer(); } - + virtual void HandleTopLevelDecl(DeclGroupRef D) { PrettyStackTraceDecl CrashInfo(*D.begin(), SourceLocation(), Context->getSourceManager(), "LLVM IR generation of declaration"); - + if (CompileOpts.TimePasses) LLVMIRGeneration.startTimer(); @@ -132,7 +132,7 @@ namespace { if (CompileOpts.TimePasses) LLVMIRGeneration.stopTimer(); } - + virtual void HandleTranslationUnit(ASTContext &C) { { PrettyStackTraceString CrashInfo("Per-file LLVM IR generation"); @@ -147,12 +147,12 @@ namespace { // EmitAssembly times and registers crash info itself. EmitAssembly(); - + // Force a flush here in case we never get released. if (AsmOutStream) FormattedOutStream.flush(); } - + virtual void HandleTagDeclDefinition(TagDecl *D) { PrettyStackTraceDecl CrashInfo(D, SourceLocation(), Context->getSourceManager(), @@ -163,7 +163,7 @@ namespace { virtual void CompleteTentativeDefinition(VarDecl *D) { Gen->CompleteTentativeDefinition(D); } - }; + }; } FunctionPassManager *BackendConsumer::getCodeGenPasses() const { @@ -216,18 +216,18 @@ bool BackendConsumer::AddEmitPasses(std::string &Error) { if (CompileOpts.CPU.size() || CompileOpts.Features.size()) { SubtargetFeatures Features; Features.setCPU(CompileOpts.CPU); - for (std::vector<std::string>::iterator + for (std::vector<std::string>::iterator it = CompileOpts.Features.begin(), ie = CompileOpts.Features.end(); it != ie; ++it) Features.AddFeature(*it); FeaturesStr = Features.getString(); } TargetMachine *TM = TheTarget->createTargetMachine(Triple, FeaturesStr); - + // Set register scheduler & allocation policy. RegisterScheduler::setDefault(createDefaultScheduler); - RegisterRegAlloc::setDefault(Fast ? createLocalRegisterAllocator : - createLinearScanRegisterAllocator); + RegisterRegAlloc::setDefault(Fast ? createLocalRegisterAllocator : + createLinearScanRegisterAllocator); // From llvm-gcc: // If there are passes we have to run on the entire module, we do codegen @@ -254,7 +254,7 @@ bool BackendConsumer::AddEmitPasses(std::string &Error) { case FileModel::AsmFile: break; } - + if (TM->addPassesToEmitFileFinish(*CodeGenPasses, (MachineCodeEmitter *)0, OptLevel)) { Error = "Unable to interface with target machine!\n"; @@ -292,8 +292,8 @@ void BackendConsumer::CreatePasses() { // For now we always create per module passes. PassManager *PM = getPerModulePasses(); - llvm::createStandardModulePasses(PM, CompileOpts.OptimizationLevel, - CompileOpts.OptimizeSize, + llvm::createStandardModulePasses(PM, CompileOpts.OptimizationLevel, + CompileOpts.OptimizeSize, CompileOpts.UnitAtATime, CompileOpts.UnrollLoops, CompileOpts.SimplifyLibCalls, @@ -302,12 +302,12 @@ void BackendConsumer::CreatePasses() { } /// EmitAssembly - Handle interaction with LLVM backend to generate -/// actual machine code. +/// actual machine code. void BackendConsumer::EmitAssembly() { // Silently ignore if we weren't initialized for some reason. if (!TheModule || !TheTargetData) return; - + TimeRegion Region(CompileOpts.TimePasses ? &CodeGenerationTime : 0); // Make sure IR generation is happy with the module. This is @@ -337,19 +337,19 @@ void BackendConsumer::EmitAssembly() { if (PerFunctionPasses) { PrettyStackTraceString CrashInfo("Per-function optimization"); - + PerFunctionPasses->doInitialization(); for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) if (!I->isDeclaration()) PerFunctionPasses->run(*I); PerFunctionPasses->doFinalization(); } - + if (PerModulePasses) { PrettyStackTraceString CrashInfo("Per-module optimization passes"); PerModulePasses->run(*M); } - + if (CodeGenPasses) { PrettyStackTraceString CrashInfo("Code generation"); CodeGenPasses->doInitialization(); diff --git a/clang/lib/Frontend/CacheTokens.cpp b/clang/lib/Frontend/CacheTokens.cpp index 7365882eb8d..e7fc5660ad2 100644 --- a/clang/lib/Frontend/CacheTokens.cpp +++ b/clang/lib/Frontend/CacheTokens.cpp @@ -40,19 +40,19 @@ using namespace clang::io; namespace { class VISIBILITY_HIDDEN PTHEntry { - Offset TokenData, PPCondData; + Offset TokenData, PPCondData; -public: +public: PTHEntry() {} PTHEntry(Offset td, Offset ppcd) : TokenData(td), PPCondData(ppcd) {} - - Offset getTokenOffset() const { return TokenData; } + + Offset getTokenOffset() const { return TokenData; } Offset getPPCondTableOffset() const { return PPCondData; } }; - - + + class VISIBILITY_HIDDEN PTHEntryKeyVariant { union { const FileEntry* FE; const char* Path; }; enum { IsFE = 0x1, IsDE = 0x2, IsNoExist = 0x0 } Kind; @@ -66,15 +66,15 @@ public: PTHEntryKeyVariant(const char* path) : Path(path), Kind(IsNoExist), StatBuf(0) {} - + bool isFile() const { return Kind == IsFE; } - + const char* getCString() const { return Kind == IsFE ? FE->getName() : Path; } - + unsigned getKind() const { return (unsigned) Kind; } - + void EmitData(llvm::raw_ostream& Out) { switch (Kind) { case IsFE: @@ -98,45 +98,45 @@ public: break; } } - + unsigned getRepresentationLength() const { return Kind == IsNoExist ? 0 : 4 + 4 + 2 + 8 + 8; } }; - + class VISIBILITY_HIDDEN FileEntryPTHEntryInfo { public: typedef PTHEntryKeyVariant key_type; typedef key_type key_type_ref; - + typedef PTHEntry data_type; typedef const PTHEntry& data_type_ref; - + static unsigned ComputeHash(PTHEntryKeyVariant V) { return BernsteinHash(V.getCString()); } - - static std::pair<unsigned,unsigned> + + static std::pair<unsigned,unsigned> EmitKeyDataLength(llvm::raw_ostream& Out, PTHEntryKeyVariant V, const PTHEntry& E) { unsigned n = strlen(V.getCString()) + 1 + 1; ::Emit16(Out, n); - + unsigned m = V.getRepresentationLength() + (V.isFile() ? 4 + 4 : 0); ::Emit8(Out, m); return std::make_pair(n, m); } - + static void EmitKey(llvm::raw_ostream& Out, PTHEntryKeyVariant V, unsigned n){ // Emit the entry kind. ::Emit8(Out, (unsigned) V.getKind()); // Emit the string. Out.write(V.getCString(), n - 1); } - - static void EmitData(llvm::raw_ostream& Out, PTHEntryKeyVariant V, + + static void EmitData(llvm::raw_ostream& Out, PTHEntryKeyVariant V, const PTHEntry& E, unsigned) { @@ -146,12 +146,12 @@ public: ::Emit32(Out, E.getTokenOffset()); ::Emit32(Out, E.getPPCondTableOffset()); } - + // Emit any other data associated with the key (i.e., stat information). V.EmitData(Out); - } + } }; - + class OffsetOpt { bool valid; Offset off; @@ -180,16 +180,16 @@ class VISIBILITY_HIDDEN PTHWriter { //// Get the persistent id for the given IdentifierInfo*. uint32_t ResolveID(const IdentifierInfo* II); - + /// Emit a token to the PTH file. void EmitToken(const Token& T); void Emit8(uint32_t V) { Out << (unsigned char)(V); } - + void Emit16(uint32_t V) { ::Emit16(Out, V); } - + void Emit24(uint32_t V) { Out << (unsigned char)(V); Out << (unsigned char)(V >> 8); @@ -202,13 +202,13 @@ class VISIBILITY_HIDDEN PTHWriter { void EmitBuf(const char *Ptr, unsigned NumBytes) { Out.write(Ptr, NumBytes); } - + /// EmitIdentifierTable - Emits two tables to the PTH file. The first is /// a hashtable mapping from identifier strings to persistent IDs. /// The second is a straight table mapping from persistent IDs to string data /// (the keys of the first table). std::pair<Offset, Offset> EmitIdentifierTable(); - + /// EmitFileTable - Emit a table mapping from file name strings to PTH /// token data. Offset EmitFileTable() { return PM.Emit(Out); } @@ -217,23 +217,23 @@ class VISIBILITY_HIDDEN PTHWriter { Offset EmitCachedSpellings(); public: - PTHWriter(llvm::raw_fd_ostream& out, Preprocessor& pp) + PTHWriter(llvm::raw_fd_ostream& out, Preprocessor& pp) : Out(out), PP(pp), idcount(0), CurStrOffset(0) {} - + PTHMap &getPM() { return PM; } void GeneratePTH(const std::string *MainFile = 0); }; } // end anonymous namespace - -uint32_t PTHWriter::ResolveID(const IdentifierInfo* II) { + +uint32_t PTHWriter::ResolveID(const IdentifierInfo* II) { // Null IdentifierInfo's map to the persistent ID 0. if (!II) return 0; - + IDMap::iterator I = IM.find(II); if (I != IM.end()) return I->second; // We've already added 1. - + IM[II] = ++idcount; // Pre-increment since '0' is reserved for NULL. return idcount; } @@ -242,7 +242,7 @@ void PTHWriter::EmitToken(const Token& T) { // Emit the token kind, flags, and length. Emit32(((uint32_t) T.getKind()) | ((((uint32_t) T.getFlags())) << 8)| (((uint32_t) T.getLength()) << 16)); - + if (!T.isLiteral()) { Emit32(ResolveID(T.getIdentifierInfo())); } else { @@ -253,18 +253,18 @@ void PTHWriter::EmitToken(const Token& T) { // Get the string entry. llvm::StringMapEntry<OffsetOpt> *E = &CachedStrs.GetOrCreateValue(s, s+len); - + // If this is a new string entry, bump the PTH offset. if (!E->getValue().hasOffset()) { E->getValue().setOffset(CurStrOffset); StrEntries.push_back(E); CurStrOffset += len + 1; } - + // Emit the relative offset into the PTH file for the spelling string. Emit32(E->getValue().getOffset()); } - + // Emit the offset into the original source file of this token so that we // can reconstruct its SourceLocation. Emit32(PP.getSourceManager().getFileOffset(T.getLocation())); @@ -275,14 +275,14 @@ PTHEntry PTHWriter::LexTokens(Lexer& L) { // This speed up reading them back in. Pad(Out, 4); Offset off = (Offset) Out.tell(); - + // Keep track of matching '#if' ... '#endif'. typedef std::vector<std::pair<Offset, unsigned> > PPCondTable; PPCondTable PPCond; std::vector<unsigned> PPStartCond; bool ParsingPreprocessorDirective = false; Token Tok; - + do { L.LexFromRawLexer(Tok); NextToken: @@ -300,7 +300,7 @@ PTHEntry PTHWriter::LexTokens(Lexer& L) { EmitToken(Tmp); ParsingPreprocessorDirective = false; } - + if (Tok.is(tok::identifier)) { Tok.setIdentifierInfo(PP.LookUpIdentifierInfo(Tok)); EmitToken(Tok); @@ -320,39 +320,39 @@ PTHEntry PTHWriter::LexTokens(Lexer& L) { // If we see the start of line, then we had a null directive "#". if (Tok.isAtStartOfLine()) goto NextToken; - + // Did we see 'include'/'import'/'include_next'? if (Tok.isNot(tok::identifier)) { EmitToken(Tok); continue; } - + IdentifierInfo* II = PP.LookUpIdentifierInfo(Tok); Tok.setIdentifierInfo(II); tok::PPKeywordKind K = II->getPPKeywordID(); - + ParsingPreprocessorDirective = true; - + switch (K) { case tok::pp_not_keyword: // Invalid directives "#foo" can occur in #if 0 blocks etc, just pass // them through. default: break; - + case tok::pp_include: case tok::pp_import: - case tok::pp_include_next: { + case tok::pp_include_next: { // Save the 'include' token. EmitToken(Tok); // Lex the next token as an include string. L.setParsingPreprocessorDirective(true); - L.LexIncludeFilename(Tok); + L.LexIncludeFilename(Tok); L.setParsingPreprocessorDirective(false); assert(!Tok.isAtStartOfLine()); if (Tok.is(tok::identifier)) Tok.setIdentifierInfo(PP.LookUpIdentifierInfo(Tok)); - + break; } case tok::pp_if: @@ -374,11 +374,11 @@ PTHEntry PTHWriter::LexTokens(Lexer& L) { assert(PPCond.size() > PPStartCond.back()); assert(PPCond[PPStartCond.back()].second == 0); PPCond[PPStartCond.back()].second = index; - PPStartCond.pop_back(); - // Add the new entry to PPCond. + PPStartCond.pop_back(); + // Add the new entry to PPCond. PPCond.push_back(std::make_pair(HashOff, index)); EmitToken(Tok); - + // Some files have gibberish on the same line as '#endif'. // Discard these tokens. do @@ -386,7 +386,7 @@ PTHEntry PTHWriter::LexTokens(Lexer& L) { while (Tok.isNot(tok::eof) && !Tok.isAtStartOfLine()); // We have the next token in hand. // Don't immediately lex the next one. - goto NextToken; + goto NextToken; } case tok::pp_elif: case tok::pp_else: { @@ -407,7 +407,7 @@ PTHEntry PTHWriter::LexTokens(Lexer& L) { } } } - + EmitToken(Tok); } while (Tok.isNot(tok::eof)); @@ -435,11 +435,11 @@ PTHEntry PTHWriter::LexTokens(Lexer& L) { Offset PTHWriter::EmitCachedSpellings() { // Write each cached strings to the PTH file. Offset SpellingsOff = Out.tell(); - + for (std::vector<llvm::StringMapEntry<OffsetOpt>*>::iterator I = StrEntries.begin(), E = StrEntries.end(); I!=E; ++I) EmitBuf((*I)->getKeyData(), (*I)->getKeyLength()+1 /*nul included*/); - + return SpellingsOff; } @@ -447,12 +447,12 @@ void PTHWriter::GeneratePTH(const std::string *MainFile) { // Generate the prologue. Out << "cfe-pth"; Emit32(PTHManager::Version); - + // Leave 4 words for the prologue. Offset PrologueOffset = Out.tell(); for (unsigned i = 0; i < 4; ++i) Emit32(0); - + // Write the name of the MainFile. if (MainFile && !MainFile->empty()) { Emit16(MainFile->length()); @@ -462,17 +462,17 @@ void PTHWriter::GeneratePTH(const std::string *MainFile) { Emit16(0); } Emit8(0); - + // Iterate over all the files in SourceManager. Create a lexer // for each file and cache the tokens. SourceManager &SM = PP.getSourceManager(); const LangOptions &LOpts = PP.getLangOptions(); - + for (SourceManager::fileinfo_iterator I = SM.fileinfo_begin(), E = SM.fileinfo_end(); I != E; ++I) { const SrcMgr::ContentCache &C = *I->second; const FileEntry *FE = C.Entry; - + // FIXME: Handle files with non-absolute paths. llvm::sys::Path P(FE->getName()); if (!P.isAbsolute()) @@ -488,13 +488,13 @@ void PTHWriter::GeneratePTH(const std::string *MainFile) { // Write out the identifier table. const std::pair<Offset,Offset> &IdTableOff = EmitIdentifierTable(); - + // Write out the cached strings table. Offset SpellingOff = EmitCachedSpellings(); - + // Write out the file table. - Offset FileTableOff = EmitFileTable(); - + Offset FileTableOff = EmitFileTable(); + // Finally, write the prologue. Out.seek(PrologueOffset); Emit32(IdTableOff.first); @@ -514,20 +514,20 @@ class StatListener : public StatSysCallCache { public: StatListener(PTHMap &pm) : PM(pm) {} ~StatListener() {} - + int stat(const char *path, struct stat *buf) { int result = ::stat(path, buf); - + if (result != 0) // Failed 'stat'. PM.insert(path, PTHEntry()); else if (S_ISDIR(buf->st_mode)) { // Only cache directories with absolute paths. if (!llvm::sys::Path(path).isAbsolute()) return result; - + PM.insert(PTHEntryKeyVariant(buf, path), PTHEntry()); } - + return result; } }; @@ -540,7 +540,7 @@ void clang::CacheTokens(Preprocessor &PP, llvm::raw_fd_ostream* OS) { const FileEntry *MainFile = SrcMgr.getFileEntryForID(SrcMgr.getMainFileID()); llvm::sys::Path MainFilePath(MainFile->getName()); std::string MainFileName; - + if (!MainFilePath.isAbsolute()) { llvm::sys::Path P = llvm::sys::Path::GetCurrentDirectory(); P.appendComponent(MainFilePath.str()); @@ -551,16 +551,16 @@ void clang::CacheTokens(Preprocessor &PP, llvm::raw_fd_ostream* OS) { // Create the PTHWriter. PTHWriter PW(*OS, PP); - + // Install the 'stat' system call listener in the FileManager. PP.getFileManager().setStatCache(new StatListener(PW.getPM())); - + // Lex through the entire file. This will populate SourceManager with // all of the header information. Token Tok; PP.EnterMainSourceFile(); do { PP.Lex(Tok); } while (Tok.isNot(tok::eof)); - + // Generate the PTH file. PP.getFileManager().setStatCache(0); PW.GeneratePTH(&MainFileName); @@ -579,32 +579,32 @@ class VISIBILITY_HIDDEN PTHIdentifierTableTrait { public: typedef PTHIdKey* key_type; typedef key_type key_type_ref; - + typedef uint32_t data_type; typedef data_type data_type_ref; - + static unsigned ComputeHash(PTHIdKey* key) { return BernsteinHash(key->II->getName()); } - - static std::pair<unsigned,unsigned> - EmitKeyDataLength(llvm::raw_ostream& Out, const PTHIdKey* key, uint32_t) { + + static std::pair<unsigned,unsigned> + EmitKeyDataLength(llvm::raw_ostream& Out, const PTHIdKey* key, uint32_t) { unsigned n = strlen(key->II->getName()) + 1; ::Emit16(Out, n); return std::make_pair(n, sizeof(uint32_t)); } - + static void EmitKey(llvm::raw_ostream& Out, PTHIdKey* key, unsigned n) { // Record the location of the key data. This is used when generating // the mapping from persistent IDs to strings. key->FileOffset = Out.tell(); Out.write(key->II->getName(), n); } - + static void EmitData(llvm::raw_ostream& Out, PTHIdKey*, uint32_t pID, unsigned) { ::Emit32(Out, pID); - } + } }; } // end anonymous namespace @@ -623,7 +623,7 @@ std::pair<Offset,Offset> PTHWriter::EmitIdentifierTable() { // Create the hashtable. OnDiskChainedHashTableGenerator<PTHIdentifierTableTrait> IIOffMap; - + // Generate mapping from persistent IDs -> IdentifierInfo*. for (IDMap::iterator I = IM.begin(), E = IM.end(); I != E; ++I) { // Decrement by 1 because we are using a vector for the lookup and @@ -631,27 +631,27 @@ std::pair<Offset,Offset> PTHWriter::EmitIdentifierTable() { assert(I->second > 0); assert(I->second-1 < idcount); unsigned idx = I->second-1; - + // Store the mapping from persistent ID to IdentifierInfo* IIDMap[idx].II = I->first; - + // Store the reverse mapping in a hashtable. IIOffMap.insert(&IIDMap[idx], I->second); } - + // Write out the inverse map first. This causes the PCIDKey entries to // record PTH file offsets for the string data. This is used to write // the second table. Offset StringTableOffset = IIOffMap.Emit(Out); - - // Now emit the table mapping from persistent IDs to PTH file offsets. + + // Now emit the table mapping from persistent IDs to PTH file offsets. Offset IDOff = Out.tell(); Emit32(idcount); // Emit the number of identifiers. for (unsigned i = 0 ; i < idcount; ++i) Emit32(IIDMap[i].FileOffset); - + // Finally, release the inverse map. free(IIDMap); - + return std::make_pair(IDOff, StringTableOffset); } diff --git a/clang/lib/Frontend/DeclXML.cpp b/clang/lib/Frontend/DeclXML.cpp index 68f931fb6c6..b981fc41daa 100644 --- a/clang/lib/Frontend/DeclXML.cpp +++ b/clang/lib/Frontend/DeclXML.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -// This file implements the XML document class, which provides the means to +// This file implements the XML document class, which provides the means to // dump out the AST in a XML form that exposes type details and other fields. // //===----------------------------------------------------------------------===// @@ -18,22 +18,18 @@ namespace clang { -//--------------------------------------------------------- -class DocumentXML::DeclPrinter : public DeclVisitor<DocumentXML::DeclPrinter> -{ +//--------------------------------------------------------- +class DocumentXML::DeclPrinter : public DeclVisitor<DocumentXML::DeclPrinter> { DocumentXML& Doc; - void addSubNodes(FunctionDecl* FD) - { - for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) - { + void addSubNodes(FunctionDecl* FD) { + for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) { Visit(FD->getParamDecl(i)); Doc.toParent(); } } - void addSubNodes(RecordDecl* RD) - { + void addSubNodes(RecordDecl* RD) { for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { Visit(*i); @@ -41,8 +37,7 @@ class DocumentXML::DeclPrinter : public DeclVisitor<DocumentXML::DeclPrinter> } } - void addSubNodes(EnumDecl* ED) - { + void addSubNodes(EnumDecl* ED) { for (EnumDecl::enumerator_iterator i = ED->enumerator_begin(), e = ED->enumerator_end(); i != e; ++i) { Visit(*i); @@ -50,54 +45,37 @@ class DocumentXML::DeclPrinter : public DeclVisitor<DocumentXML::DeclPrinter> } } - void addSubNodes(EnumConstantDecl* ECD) - { - if (ECD->getInitExpr()) - { + void addSubNodes(EnumConstantDecl* ECD) { + if (ECD->getInitExpr()) Doc.PrintStmt(ECD->getInitExpr()); - } } - void addSubNodes(FieldDecl* FdD) - { + void addSubNodes(FieldDecl* FdD) { if (FdD->isBitField()) - { Doc.PrintStmt(FdD->getBitWidth()); - } } - void addSubNodes(VarDecl* V) - { - if (V->getInit()) - { + void addSubNodes(VarDecl* V) { + if (V->getInit()) Doc.PrintStmt(V->getInit()); - } } - void addSubNodes(ParmVarDecl* argDecl) - { + void addSubNodes(ParmVarDecl* argDecl) { if (argDecl->getDefaultArg()) - { Doc.PrintStmt(argDecl->getDefaultArg()); - } } - void addSpecialAttribute(const char* pName, EnumDecl* ED) - { + void addSpecialAttribute(const char* pName, EnumDecl* ED) { const QualType& enumType = ED->getIntegerType(); if (!enumType.isNull()) - { Doc.addAttribute(pName, enumType); - } } - void addIdAttribute(LinkageSpecDecl* ED) - { + void addIdAttribute(LinkageSpecDecl* ED) { Doc.addAttribute("id", ED); } - void addIdAttribute(NamedDecl* ND) - { + void addIdAttribute(NamedDecl* ND) { Doc.addAttribute("id", ND); } @@ -107,11 +85,11 @@ public: #define NODE_XML( CLASS, NAME ) \ void Visit##CLASS(CLASS* T) \ { \ - Doc.addSubNode(NAME); + Doc.addSubNode(NAME); #define ID_ATTRIBUTE_XML addIdAttribute(T); -#define ATTRIBUTE_XML( FN, NAME ) Doc.addAttribute(NAME, T->FN); -#define ATTRIBUTE_OPT_XML( FN, NAME ) Doc.addAttributeOptional(NAME, T->FN); +#define ATTRIBUTE_XML( FN, NAME ) Doc.addAttribute(NAME, T->FN); +#define ATTRIBUTE_OPT_XML( FN, NAME ) Doc.addAttributeOptional(NAME, T->FN); #define ATTRIBUTE_FILE_LOCATION_XML Doc.addLocation(T->getLocation()); #define ATTRIBUTE_SPECIAL_XML( FN, NAME ) addSpecialAttribute(NAME, T); @@ -120,14 +98,14 @@ public: const char* pAttributeName = NAME; \ const bool optional = false; \ switch (T->FN) { \ - default: assert(0 && "unknown enum value"); + default: assert(0 && "unknown enum value"); #define ATTRIBUTE_ENUM_OPT_XML( FN, NAME ) \ { \ const char* pAttributeName = NAME; \ const bool optional = true; \ switch (T->FN) { \ - default: assert(0 && "unknown enum value"); + default: assert(0 && "unknown enum value"); #define ENUM_XML( VALUE, NAME ) case VALUE: if ((!optional) || NAME[0]) Doc.addAttribute(pAttributeName, NAME); break; #define END_ENUM_XML } } @@ -141,12 +119,10 @@ public: }; -//--------------------------------------------------------- -void DocumentXML::writeDeclToXML(Decl *D) -{ +//--------------------------------------------------------- +void DocumentXML::writeDeclToXML(Decl *D) { DeclPrinter(*this).Visit(D); - if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) - { + if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { if (Stmt *Body = FD->getBody()) { addSubNode("Body"); PrintStmt(Body); @@ -156,6 +132,6 @@ void DocumentXML::writeDeclToXML(Decl *D) toParent(); } -//--------------------------------------------------------- +//--------------------------------------------------------- } // NS clang diff --git a/clang/lib/Frontend/DependencyFile.cpp b/clang/lib/Frontend/DependencyFile.cpp index c8a654cff2c..81d1179f28e 100644 --- a/clang/lib/Frontend/DependencyFile.cpp +++ b/clang/lib/Frontend/DependencyFile.cpp @@ -40,8 +40,8 @@ private: void OutputDependencyFile(); public: - DependencyFileCallback(const Preprocessor *_PP, - llvm::raw_ostream *_OS, + DependencyFileCallback(const Preprocessor *_PP, + llvm::raw_ostream *_OS, const std::vector<std::string> &_Targets, bool _IncludeSystemHeaders, bool _PhonyTarget) @@ -67,8 +67,8 @@ void clang::AttachDependencyFileGen(Preprocessor *PP, llvm::raw_ostream *OS, bool PhonyTarget) { assert(!Targets.empty() && "Target required for dependency generation"); - DependencyFileCallback *PPDep = - new DependencyFileCallback(PP, OS, Targets, IncludeSystemHeaders, + DependencyFileCallback *PPDep = + new DependencyFileCallback(PP, OS, Targets, IncludeSystemHeaders, PhonyTarget); PP->setPPCallbacks(PPDep); } @@ -91,16 +91,16 @@ void DependencyFileCallback::FileChanged(SourceLocation Loc, SrcMgr::CharacteristicKind FileType) { if (Reason != PPCallbacks::EnterFile) return; - + // Dependency generation really does want to go all the way to the // file entry for a source location to find out what is depended on. // We do not want #line markers to affect dependency generation! SourceManager &SM = PP->getSourceManager(); - + const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(SM.getInstantiationLoc(Loc))); if (FE == 0) return; - + const char *Filename = FE->getName(); if (!FileMatchesDepCriteria(Filename, FileType)) return; @@ -138,7 +138,7 @@ void DependencyFileCallback::OutputDependencyFile() { *OS << ':'; Columns += 1; - + // Now add each dependency in the order it was seen, but avoiding // duplicates. for (std::vector<std::string>::iterator I = Files.begin(), diff --git a/clang/lib/Frontend/DiagChecker.cpp b/clang/lib/Frontend/DiagChecker.cpp index c0f5d141be0..26bb6ccfa7c 100644 --- a/clang/lib/Frontend/DiagChecker.cpp +++ b/clang/lib/Frontend/DiagChecker.cpp @@ -55,33 +55,33 @@ static void EmitError(Preprocessor &PP, SourceLocation Pos, const char *String){ /// FindDiagnostics - Go through the comment and see if it indicates expected /// diagnostics. If so, then put them in a diagnostic list. -/// +/// static void FindDiagnostics(const char *CommentStart, unsigned CommentLen, DiagList &ExpectedDiags, Preprocessor &PP, SourceLocation Pos, const char *ExpectedStr) { const char *CommentEnd = CommentStart+CommentLen; unsigned ExpectedStrLen = strlen(ExpectedStr); - + // Find all expected-foo diagnostics in the string and add them to // ExpectedDiags. while (CommentStart != CommentEnd) { CommentStart = std::find(CommentStart, CommentEnd, 'e'); if (unsigned(CommentEnd-CommentStart) < ExpectedStrLen) return; - + // If this isn't expected-foo, ignore it. if (memcmp(CommentStart, ExpectedStr, ExpectedStrLen)) { ++CommentStart; continue; } - + CommentStart += ExpectedStrLen; - + // Skip whitespace. while (CommentStart != CommentEnd && isspace(CommentStart[0])) ++CommentStart; - + // Default, if we find the '{' now, is 1 time. int Times = 1; int Temp = 0; @@ -94,12 +94,12 @@ static void FindDiagnostics(const char *CommentStart, unsigned CommentLen, } if (Temp > 0) Times = Temp; - + // Skip whitespace again. while (CommentStart != CommentEnd && isspace(CommentStart[0])) ++CommentStart; - + // We should have a {{ now. if (CommentEnd-CommentStart < 2 || CommentStart[0] != '{' || CommentStart[1] != '{') { @@ -119,7 +119,7 @@ static void FindDiagnostics(const char *CommentStart, unsigned CommentLen, EmitError(PP, Pos, "cannot find end ('}}') of expected string"); return; } - + if (ExpectedEnd[1] == '}') break; @@ -147,10 +147,10 @@ static void FindExpectedDiags(Preprocessor &PP, // Create a raw lexer to pull all the comments out of the main file. We don't // want to look in #include'd headers for expected-error strings. FileID FID = PP.getSourceManager().getMainFileID(); - + // Create a lexer to lex all the tokens of the main file in raw mode. Lexer RawLex(FID, PP.getSourceManager(), PP.getLangOptions()); - + // Return comments as tokens, this is how we find expected diagnostics. RawLex.SetCommentRetentionState(true); @@ -159,11 +159,11 @@ static void FindExpectedDiags(Preprocessor &PP, while (Tok.isNot(tok::eof)) { RawLex.Lex(Tok); if (!Tok.is(tok::comment)) continue; - + std::string Comment = PP.getSpelling(Tok); if (Comment.empty()) continue; - + // Find all expected errors. FindDiagnostics(&Comment[0], Comment.size(), ExpectedErrors, PP, Tok.getLocation(), "expected-error"); @@ -182,7 +182,7 @@ static void FindExpectedDiags(Preprocessor &PP, /// seen diagnostics. If there's anything in it, then something unexpected /// happened. Print the map out in a nice format and return "true". If the map /// is empty and we're not going to print things, then return "false". -/// +/// static bool PrintProblem(SourceManager &SourceMgr, const_diag_iterator diag_begin, const_diag_iterator diag_end, @@ -201,7 +201,7 @@ static bool PrintProblem(SourceManager &SourceMgr, /// CompareDiagLists - Compare two diagnostic lists and return the difference /// between them. -/// +/// static bool CompareDiagLists(SourceManager &SourceMgr, const_diag_iterator d1_begin, const_diag_iterator d1_end, @@ -245,7 +245,7 @@ static bool CompareDiagLists(SourceManager &SourceMgr, /// CheckResults - This compares the expected results to those that /// were actually reported. It emits any discrepencies. Return "true" if there /// were problems. Return "false" otherwise. -/// +/// static bool CheckResults(Preprocessor &PP, const DiagList &ExpectedErrors, const DiagList &ExpectedWarnings, diff --git a/clang/lib/Frontend/DocumentXML.cpp b/clang/lib/Frontend/DocumentXML.cpp index 19a757303f1..776fa6dcdaf 100644 --- a/clang/lib/Frontend/DocumentXML.cpp +++ b/clang/lib/Frontend/DocumentXML.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -// This file implements the XML document class, which provides the means to +// This file implements the XML document class, which provides the means to // dump out the AST in a XML form that exposes type details and other fields. // //===----------------------------------------------------------------------===// @@ -20,23 +20,19 @@ namespace clang { -//--------------------------------------------------------- +//--------------------------------------------------------- DocumentXML::DocumentXML(const std::string& rootName, llvm::raw_ostream& out) : Out(out), Ctx(0), - HasCurrentNodeSubNodes(false) -{ + HasCurrentNodeSubNodes(false) { NodeStack.push(rootName); Out << "<?xml version=\"1.0\"?>\n<" << rootName; } -//--------------------------------------------------------- -DocumentXML& DocumentXML::addSubNode(const std::string& name) -{ +//--------------------------------------------------------- +DocumentXML& DocumentXML::addSubNode(const std::string& name) { if (!HasCurrentNodeSubNodes) - { Out << ">\n"; - } NodeStack.push(name); HasCurrentNodeSubNodes = false; Indent(); @@ -44,46 +40,38 @@ DocumentXML& DocumentXML::addSubNode(const std::string& name) return *this; } -//--------------------------------------------------------- -void DocumentXML::Indent() -{ +//--------------------------------------------------------- +void DocumentXML::Indent() { for (size_t i = 0, e = (NodeStack.size() - 1) * 2; i < e; ++i) Out << ' '; } -//--------------------------------------------------------- -DocumentXML& DocumentXML::toParent() -{ +//--------------------------------------------------------- +DocumentXML& DocumentXML::toParent() { assert(NodeStack.size() > 1 && "to much backtracking"); - if (HasCurrentNodeSubNodes) - { + if (HasCurrentNodeSubNodes) { Indent(); Out << "</" << NodeStack.top() << ">\n"; - } - else - { + } else Out << "/>\n"; - } NodeStack.pop(); HasCurrentNodeSubNodes = true; - return *this; + return *this; } -//--------------------------------------------------------- +//--------------------------------------------------------- namespace { enum tIdType { ID_NORMAL, ID_FILE, ID_LABEL, ID_LAST }; -unsigned getNewId(tIdType idType) -{ +unsigned getNewId(tIdType idType) { static unsigned int idCounts[ID_LAST] = { 0 }; return ++idCounts[idType]; } -//--------------------------------------------------------- -inline std::string getPrefixedId(unsigned uId, tIdType idType) -{ +//--------------------------------------------------------- +inline std::string getPrefixedId(unsigned uId, tIdType idType) { static const char idPrefix[ID_LAST] = { '_', 'f', 'l' }; char buffer[20]; char* BufPtr = llvm::utohex_buffer(uId, buffer + 20); @@ -91,25 +79,22 @@ inline std::string getPrefixedId(unsigned uId, tIdType idType) return BufPtr; } -//--------------------------------------------------------- +//--------------------------------------------------------- template<class T, class V> -bool addToMap(T& idMap, const V& value, tIdType idType = ID_NORMAL) -{ +bool addToMap(T& idMap, const V& value, tIdType idType = ID_NORMAL) { typename T::iterator i = idMap.find(value); bool toAdd = i == idMap.end(); - if (toAdd) - { + if (toAdd) idMap.insert(typename T::value_type(value, getNewId(idType))); - } return toAdd; } } // anon NS -//--------------------------------------------------------- -std::string DocumentXML::escapeString(const char* pStr, std::string::size_type len) -{ +//--------------------------------------------------------- +std::string DocumentXML::escapeString(const char* pStr, + std::string::size_type len) { std::string value; value.reserve(len + 1); char buffer[16]; @@ -118,8 +103,7 @@ std::string DocumentXML::escapeString(const char* pStr, std::string::size_type l default: if (isprint(C)) value += C; - else - { + else { sprintf(buffer, "\\%03o", C); value += buffer; } @@ -142,26 +126,24 @@ std::string DocumentXML::escapeString(const char* pStr, std::string::size_type l return value; } -//--------------------------------------------------------- -void DocumentXML::finalize() -{ +//--------------------------------------------------------- +void DocumentXML::finalize() { assert(NodeStack.size() == 1 && "not completely backtracked"); addSubNode("ReferenceSection"); addSubNode("Types"); - for (XML::IdMap<QualType>::iterator i = Types.begin(), e = Types.end(); i != e; ++i) - { - if (i->first.getCVRQualifiers() != 0) - { + for (XML::IdMap<QualType>::iterator i = Types.begin(), e = Types.end(); + i != e; ++i) { + if (i->first.getCVRQualifiers() != 0) { writeTypeToXML(i->first); addAttribute("id", getPrefixedId(i->second, ID_NORMAL)); toParent(); } } - for (XML::IdMap<const Type*>::iterator i = BasicTypes.begin(), e = BasicTypes.end(); i != e; ++i) - { + for (XML::IdMap<const Type*>::iterator i = BasicTypes.begin(), + e = BasicTypes.end(); i != e; ++i) { writeTypeToXML(i->first); addAttribute("id", getPrefixedId(i->second, ID_NORMAL)); toParent(); @@ -170,31 +152,26 @@ void DocumentXML::finalize() toParent().addSubNode("Contexts"); - for (XML::IdMap<const DeclContext*>::iterator i = Contexts.begin(), e = Contexts.end(); i != e; ++i) - { + for (XML::IdMap<const DeclContext*>::iterator i = Contexts.begin(), + e = Contexts.end(); i != e; ++i) { addSubNode(i->first->getDeclKindName()); addAttribute("id", getPrefixedId(i->second, ID_NORMAL)); - if (const NamedDecl *ND = dyn_cast<NamedDecl>(i->first)) { + if (const NamedDecl *ND = dyn_cast<NamedDecl>(i->first)) addAttribute("name", ND->getNameAsString()); - } - if (const TagDecl *TD = dyn_cast<TagDecl>(i->first)) { + if (const TagDecl *TD = dyn_cast<TagDecl>(i->first)) addAttribute("type", getPrefixedId(BasicTypes[TD->getTypeForDecl()], ID_NORMAL)); - } - else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(i->first)) { + else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(i->first)) addAttribute("type", getPrefixedId(BasicTypes[FD->getType()->getAsFunctionType()], ID_NORMAL)); - } if (const DeclContext* parent = i->first->getParent()) - { addAttribute("context", parent); - } toParent(); } toParent().addSubNode("Files"); - for (XML::IdMap<std::string>::iterator i = SourceFiles.begin(), e = SourceFiles.end(); i != e; ++i) - { + for (XML::IdMap<std::string>::iterator i = SourceFiles.begin(), + e = SourceFiles.end(); i != e; ++i) { addSubNode("File"); addAttribute("id", getPrefixedId(i->second, ID_FILE)); addAttribute("name", escapeString(i->first.c_str(), i->first.size())); @@ -202,26 +179,26 @@ void DocumentXML::finalize() } toParent().toParent(); - + // write the root closing node (which has always subnodes) Out << "</" << NodeStack.top() << ">\n"; } -//--------------------------------------------------------- -void DocumentXML::addAttribute(const char* pAttributeName, const QualType& pType) -{ +//--------------------------------------------------------- +void DocumentXML::addAttribute(const char* pAttributeName, + const QualType& pType) { addTypeRecursively(pType); addAttribute(pAttributeName, getPrefixedId(Types[pType], ID_NORMAL)); } -//--------------------------------------------------------- -void DocumentXML::addPtrAttribute(const char* pAttributeName, const Type* pType) -{ +//--------------------------------------------------------- +void DocumentXML::addPtrAttribute(const char* pAttributeName, + const Type* pType) { addTypeRecursively(pType); addAttribute(pAttributeName, getPrefixedId(BasicTypes[pType], ID_NORMAL)); } -//--------------------------------------------------------- +//--------------------------------------------------------- void DocumentXML::addTypeRecursively(const QualType& pType) { if (addToMap(Types, pType)) @@ -230,12 +207,12 @@ void DocumentXML::addTypeRecursively(const QualType& pType) // beautifier: a non-qualified type shall be transparent if (pType.getCVRQualifiers() == 0) { - Types[pType] = BasicTypes[pType.getTypePtr()]; + Types[pType] = BasicTypes[pType.getTypePtr()]; } } } -//--------------------------------------------------------- +//--------------------------------------------------------- void DocumentXML::addTypeRecursively(const Type* pType) { if (addToMap(BasicTypes, pType)) @@ -243,7 +220,7 @@ void DocumentXML::addTypeRecursively(const Type* pType) addParentTypes(pType); /* // FIXME: doesn't work in the immediate streaming approach - if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(pType)) + if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(pType)) { addSubNode("VariableArraySizeExpression"); PrintStmt(VAT->getSizeExpr()); @@ -253,14 +230,14 @@ void DocumentXML::addTypeRecursively(const Type* pType) } } -//--------------------------------------------------------- +//--------------------------------------------------------- void DocumentXML::addPtrAttribute(const char* pName, const DeclContext* DC) { addContextsRecursively(DC); addAttribute(pName, getPrefixedId(Contexts[DC], ID_NORMAL)); } -//--------------------------------------------------------- +//--------------------------------------------------------- void DocumentXML::addPtrAttribute(const char* pAttributeName, const NamedDecl* D) { if (const DeclContext* DC = dyn_cast<DeclContext>(D)) @@ -275,22 +252,22 @@ void DocumentXML::addPtrAttribute(const char* pAttributeName, const NamedDecl* D } } -//--------------------------------------------------------- +//--------------------------------------------------------- void DocumentXML::addPtrAttribute(const char* pName, const NamespaceDecl* D) { addPtrAttribute(pName, static_cast<const DeclContext*>(D)); } -//--------------------------------------------------------- +//--------------------------------------------------------- void DocumentXML::addContextsRecursively(const DeclContext *DC) { if (DC != 0 && addToMap(Contexts, DC)) { addContextsRecursively(DC->getParent()); - } + } } -//--------------------------------------------------------- +//--------------------------------------------------------- void DocumentXML::addSourceFileAttribute(const std::string& fileName) { addToMap(SourceFiles, fileName, ID_FILE); @@ -298,7 +275,7 @@ void DocumentXML::addSourceFileAttribute(const std::string& fileName) } -//--------------------------------------------------------- +//--------------------------------------------------------- void DocumentXML::addPtrAttribute(const char* pName, const LabelStmt* L) { addToMap(Labels, L, ID_LABEL); @@ -306,13 +283,13 @@ void DocumentXML::addPtrAttribute(const char* pName, const LabelStmt* L) } -//--------------------------------------------------------- +//--------------------------------------------------------- PresumedLoc DocumentXML::addLocation(const SourceLocation& Loc) { SourceManager& SM = Ctx->getSourceManager(); SourceLocation SpellingLoc = SM.getSpellingLoc(Loc); PresumedLoc PLoc; - if (!SpellingLoc.isInvalid()) + if (!SpellingLoc.isInvalid()) { PLoc = SM.getPresumedLoc(SpellingLoc); addSourceFileAttribute(PLoc.getFilename()); @@ -323,18 +300,18 @@ PresumedLoc DocumentXML::addLocation(const SourceLocation& Loc) return PLoc; } -//--------------------------------------------------------- +//--------------------------------------------------------- void DocumentXML::addLocationRange(const SourceRange& R) { PresumedLoc PStartLoc = addLocation(R.getBegin()); - if (R.getBegin() != R.getEnd()) + if (R.getBegin() != R.getEnd()) { SourceManager& SM = Ctx->getSourceManager(); SourceLocation SpellingLoc = SM.getSpellingLoc(R.getEnd()); - if (!SpellingLoc.isInvalid()) + if (!SpellingLoc.isInvalid()) { PresumedLoc PLoc = SM.getPresumedLoc(SpellingLoc); - if (PStartLoc.isInvalid() || + if (PStartLoc.isInvalid() || strcmp(PLoc.getFilename(), PStartLoc.getFilename()) != 0) { addToMap(SourceFiles, PLoc.getFilename(), ID_FILE); addAttribute("endfile", PLoc.getFilename()); @@ -345,17 +322,17 @@ void DocumentXML::addLocationRange(const SourceRange& R) addAttribute("endcol", PLoc.getColumn()); } else { addAttribute("endcol", PLoc.getColumn()); - } + } } } } -//--------------------------------------------------------- +//--------------------------------------------------------- void DocumentXML::PrintDecl(Decl *D) { writeDeclToXML(D); } -//--------------------------------------------------------- +//--------------------------------------------------------- } // NS clang diff --git a/clang/lib/Frontend/FixItRewriter.cpp b/clang/lib/Frontend/FixItRewriter.cpp index ba58df5d833..dddcaa97e2f 100644 --- a/clang/lib/Frontend/FixItRewriter.cpp +++ b/clang/lib/Frontend/FixItRewriter.cpp @@ -34,7 +34,7 @@ FixItRewriter::~FixItRewriter() { Diags.setClient(Client); } -bool FixItRewriter::WriteFixedFile(const std::string &InFileName, +bool FixItRewriter::WriteFixedFile(const std::string &InFileName, const std::string &OutFileName) { if (NumFailures > 0) { Diag(FullSourceLoc(), diag::warn_fixit_no_changes); @@ -59,10 +59,10 @@ bool FixItRewriter::WriteFixedFile(const std::string &InFileName, OutFile = new llvm::raw_fd_ostream(Path.c_str(), Err, llvm::raw_fd_ostream::F_Binary); OwnedStream.reset(OutFile); - } + } FileID MainFileID = Rewrite.getSourceMgr().getMainFileID(); - if (const RewriteBuffer *RewriteBuf = + if (const RewriteBuffer *RewriteBuf = Rewrite.getRewriteBufferFor(MainFileID)) { *OutFile << std::string(RewriteBuf->begin(), RewriteBuf->end()); } else { @@ -99,7 +99,7 @@ void FixItRewriter::HandleDiagnostic(Diagnostic::Level DiagLevel, // See if the location of the error is one that matches what the // user requested. bool AcceptableLocation = false; - const FileEntry *File + const FileEntry *File = Rewrite.getSourceMgr().getFileEntryForID( Info.getLocation().getFileID()); unsigned Line = Info.getLocation().getSpellingLineNumber(); @@ -129,14 +129,14 @@ void FixItRewriter::HandleDiagnostic(Diagnostic::Level DiagLevel, break; } - if (Hint.InsertionLoc.isValid() && + if (Hint.InsertionLoc.isValid() && !Rewrite.isRewritable(Hint.InsertionLoc)) { CanRewrite = false; break; } } - if (!CanRewrite) { + if (!CanRewrite) { if (Info.getNumCodeModificationHints() > 0) Diag(Info.getLocation(), diag::note_fixit_in_macro); @@ -149,7 +149,7 @@ void FixItRewriter::HandleDiagnostic(Diagnostic::Level DiagLevel, } bool Failed = false; - for (unsigned Idx = 0, Last = Info.getNumCodeModificationHints(); + for (unsigned Idx = 0, Last = Info.getNumCodeModificationHints(); Idx < Last; ++Idx) { const CodeModificationHint &Hint = Info.getCodeModificationHint(Idx); if (!Hint.RemoveRange.isValid()) { @@ -158,15 +158,15 @@ void FixItRewriter::HandleDiagnostic(Diagnostic::Level DiagLevel, Failed = true; continue; } - + if (Hint.CodeToInsert.empty()) { // We're removing code. if (Rewrite.RemoveText(Hint.RemoveRange.getBegin(), Rewrite.getRangeSize(Hint.RemoveRange))) Failed = true; continue; - } - + } + // We're replacing code. if (Rewrite.ReplaceText(Hint.RemoveRange.getBegin(), Rewrite.getRangeSize(Hint.RemoveRange), @@ -191,5 +191,5 @@ void FixItRewriter::Diag(FullSourceLoc Loc, unsigned DiagID) { Diags.setClient(Client); Diags.Clear(); Diags.Report(Loc, DiagID); - Diags.setClient(this); + Diags.setClient(this); } diff --git a/clang/lib/Frontend/GeneratePCH.cpp b/clang/lib/Frontend/GeneratePCH.cpp index 43a3a6cbc0e..bc45cc42258 100644 --- a/clang/lib/Frontend/GeneratePCH.cpp +++ b/clang/lib/Frontend/GeneratePCH.cpp @@ -35,9 +35,9 @@ namespace { llvm::raw_ostream *Out; Sema *SemaPtr; MemorizeStatCalls *StatCalls; // owned by the FileManager - + public: - explicit PCHGenerator(const Preprocessor &PP, + explicit PCHGenerator(const Preprocessor &PP, const char *isysroot, llvm::raw_ostream *Out); virtual void InitializeSema(Sema &S) { SemaPtr = &S; } @@ -45,10 +45,10 @@ namespace { }; } -PCHGenerator::PCHGenerator(const Preprocessor &PP, +PCHGenerator::PCHGenerator(const Preprocessor &PP, const char *isysroot, llvm::raw_ostream *OS) - : PP(PP), isysroot(isysroot), Out(OS), SemaPtr(0), StatCalls(0) { + : PP(PP), isysroot(isysroot), Out(OS), SemaPtr(0), StatCalls(0) { // Install a stat() listener to keep track of all of the stat() // calls. diff --git a/clang/lib/Frontend/HTMLDiagnostics.cpp b/clang/lib/Frontend/HTMLDiagnostics.cpp index 4c84548ad34..f8bca235bd5 100644 --- a/clang/lib/Frontend/HTMLDiagnostics.cpp +++ b/clang/lib/Frontend/HTMLDiagnostics.cpp @@ -39,39 +39,39 @@ class VISIBILITY_HIDDEN HTMLDiagnostics : public PathDiagnosticClient { bool createdDir, noDir; Preprocessor* PP; std::vector<const PathDiagnostic*> BatchedDiags; - llvm::SmallVectorImpl<std::string> *FilesMade; + llvm::SmallVectorImpl<std::string> *FilesMade; public: HTMLDiagnostics(const std::string& prefix, Preprocessor* pp, llvm::SmallVectorImpl<std::string> *filesMade = 0); virtual ~HTMLDiagnostics(); - + virtual void SetPreprocessor(Preprocessor *pp) { PP = pp; } - + virtual void HandlePathDiagnostic(const PathDiagnostic* D); - + unsigned ProcessMacroPiece(llvm::raw_ostream& os, const PathDiagnosticMacroPiece& P, unsigned num); - + void HandlePiece(Rewriter& R, FileID BugFileID, const PathDiagnosticPiece& P, unsigned num, unsigned max); - + void HighlightRange(Rewriter& R, FileID BugFileID, SourceRange Range, const char *HighlightStart = "<span class=\"mrange\">", const char *HighlightEnd = "</span>"); void ReportDiag(const PathDiagnostic& D); }; - + } // end anonymous namespace HTMLDiagnostics::HTMLDiagnostics(const std::string& prefix, Preprocessor* pp, llvm::SmallVectorImpl<std::string>* filesMade) : Directory(prefix), FilePrefix(prefix), createdDir(false), noDir(false), PP(pp), FilesMade(filesMade) { - - // All html files begin with "report" + + // All html files begin with "report" FilePrefix.appendComponent("report"); } @@ -98,9 +98,9 @@ public: : Prefix(prefix), PP(pp) {} virtual ~HTMLDiagnosticsFactory() {} - + const char *getName() const { return "HTMLDiagnostics"; } - + PathDiagnosticClient* createPathDiagnosticClient(llvm::SmallVectorImpl<std::string> *FilesMade) { @@ -123,12 +123,12 @@ clang::CreateHTMLDiagnosticClientFactory(const std::string& prefix, void HTMLDiagnostics::HandlePathDiagnostic(const PathDiagnostic* D) { if (!D) return; - + if (D->empty()) { delete D; return; } - + const_cast<PathDiagnostic*>(D)->flattenLocations(); BatchedDiags.push_back(D); } @@ -139,7 +139,7 @@ HTMLDiagnostics::~HTMLDiagnostics() { BatchedDiags.pop_back(); ReportDiag(*D); delete D; - } + } } void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D) { @@ -148,73 +148,73 @@ void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D) { createdDir = true; std::string ErrorMsg; Directory.createDirectoryOnDisk(true, &ErrorMsg); - + if (!Directory.isDirectory()) { llvm::errs() << "warning: could not create directory '" << Directory.str() << "'\n" - << "reason: " << ErrorMsg << '\n'; - + << "reason: " << ErrorMsg << '\n'; + noDir = true; - + return; } } - + if (noDir) return; - + const SourceManager &SMgr = D.begin()->getLocation().getManager(); FileID FID; - + // Verify that the entire path is from the same FileID. for (PathDiagnostic::const_iterator I = D.begin(), E = D.end(); I != E; ++I) { FullSourceLoc L = I->getLocation().asLocation().getInstantiationLoc(); - + if (FID.isInvalid()) { FID = SMgr.getFileID(L); } else if (SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? - + // Check the source ranges. for (PathDiagnosticPiece::range_iterator RI=I->ranges_begin(), RE=I->ranges_end(); RI!=RE; ++RI) { - + SourceLocation L = SMgr.getInstantiationLoc(RI->getBegin()); if (!L.isFileID() || SMgr.getFileID(L) != FID) return; // FIXME: Emit a warning? - + L = SMgr.getInstantiationLoc(RI->getEnd()); - + if (!L.isFileID() || SMgr.getFileID(L) != FID) - return; // FIXME: Emit a warning? + return; // FIXME: Emit a warning? } } - + if (FID.isInvalid()) return; // FIXME: Emit a warning? - + // Create a new rewriter to generate HTML. Rewriter R(const_cast<SourceManager&>(SMgr), PP->getLangOptions()); - - // Process the path. + + // Process the path. unsigned n = D.size(); unsigned max = n; - + for (PathDiagnostic::const_reverse_iterator I=D.rbegin(), E=D.rend(); I!=E; ++I, --n) HandlePiece(R, FID, *I, n, max); - + // Add line numbers, header, footer, etc. - + // unsigned FID = R.getSourceMgr().getMainFileID(); html::EscapeText(R, FID); html::AddLineNumbers(R, FID); - + // If we have a preprocessor, relex the file and syntax highlight. // We might not have a preprocessor if we come from a deserialized AST file, // for example. - + if (PP) html::SyntaxHighlight(R, FID, *PP); // FIXME: We eventually want to use PPF to create a fresh Preprocessor, @@ -223,69 +223,69 @@ void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D) { // if (PPF) html::HighlightMacros(R, FID, *PPF); // if (PP) html::HighlightMacros(R, FID, *PP); - + // Get the full directory name of the analyzed file. const FileEntry* Entry = SMgr.getFileEntryForID(FID); - + // This is a cludge; basically we want to append either the full // working directory if we have no directory information. This is // a work in progress. std::string DirName = ""; - + if (!llvm::sys::Path(Entry->getName()).isAbsolute()) { llvm::sys::Path P = llvm::sys::Path::GetCurrentDirectory(); DirName = P.str() + "/"; } - - // Add the name of the file as an <h1> tag. - + + // Add the name of the file as an <h1> tag. + { std::string s; llvm::raw_string_ostream os(s); - + os << "<!-- REPORTHEADER -->\n" << "<h3>Bug Summary</h3>\n<table class=\"simpletable\">\n" "<tr><td class=\"rowname\">File:</td><td>" << html::EscapeText(DirName) << html::EscapeText(Entry->getName()) << "</td></tr>\n<tr><td class=\"rowname\">Location:</td><td>" - "<a href=\"#EndPath\">line " + "<a href=\"#EndPath\">line " << (*D.rbegin()).getLocation().asLocation().getInstantiationLineNumber() << ", column " << (*D.rbegin()).getLocation().asLocation().getInstantiationColumnNumber() << "</a></td></tr>\n" "<tr><td class=\"rowname\">Description:</td><td>" << D.getDescription() << "</td></tr>\n"; - + // Output any other meta data. - + for (PathDiagnostic::meta_iterator I=D.meta_begin(), E=D.meta_end(); I!=E; ++I) { os << "<tr><td></td><td>" << html::EscapeText(*I) << "</td></tr>\n"; } - + os << "</table>\n<!-- REPORTSUMMARYEXTRA -->\n" - "<h3>Annotated Source Code</h3>\n"; - + "<h3>Annotated Source Code</h3>\n"; + R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), os.str()); } - + // Embed meta-data tags. { std::string s; llvm::raw_string_ostream os(s); - - const std::string& BugDesc = D.getDescription(); + + const std::string& BugDesc = D.getDescription(); if (!BugDesc.empty()) os << "\n<!-- BUGDESC " << BugDesc << " -->\n"; - + const std::string& BugType = D.getBugType(); if (!BugType.empty()) os << "\n<!-- BUGTYPE " << BugType << " -->\n"; - - const std::string& BugCategory = D.getCategory(); + + const std::string& BugCategory = D.getCategory(); if (!BugCategory.empty()) os << "\n<!-- BUGCATEGORY " << BugCategory << " -->\n"; @@ -296,21 +296,21 @@ void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D) { << " -->\n"; os << "\n<!-- BUGPATHLENGTH " << D.size() << " -->\n"; - + // Mark the end of the tags. os << "\n<!-- BUGMETAEND -->\n"; - + // Insert the text. R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), os.str()); } - + // Add CSS, header, and footer. - + html::AddHeaderFooterInternalBuiltinCSS(R, FID, Entry->getName()); - + // Get the rewrite buffer. const RewriteBuffer *Buf = R.getRewriteBufferFor(FID); - + if (!Buf) { llvm::errs() << "warning: no diagnostics generated for main file.\n"; return; @@ -318,19 +318,19 @@ void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D) { // Create the stream to write out the HTML. std::ofstream os; - + { // Create a path for the target HTML file. llvm::sys::Path F(FilePrefix); F.makeUnique(false, NULL); - + // Rename the file with an HTML extension. llvm::sys::Path H(F); H.appendSuffix("html"); F.renamePathOnDisk(H, NULL); - + os.open(H.c_str()); - + if (!os) { llvm::errs() << "warning: could not create file '" << F.str() << "'\n"; return; @@ -339,33 +339,33 @@ void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D) { if (FilesMade) FilesMade->push_back(H.getLast()); } - + // Emit the HTML to disk. for (RewriteBuffer::iterator I = Buf->begin(), E = Buf->end(); I!=E; ++I) - os << *I; + os << *I; } void HTMLDiagnostics::HandlePiece(Rewriter& R, FileID BugFileID, const PathDiagnosticPiece& P, unsigned num, unsigned max) { - + // For now, just draw a box above the line in question, and emit the // warning. FullSourceLoc Pos = P.getLocation().asLocation(); - + if (!Pos.isValid()) - return; - + return; + SourceManager &SM = R.getSourceMgr(); assert(&Pos.getManager() == &SM && "SourceManagers are different!"); std::pair<FileID, unsigned> LPosInfo = SM.getDecomposedInstantiationLoc(Pos); - + if (LPosInfo.first != BugFileID) return; - + const llvm::MemoryBuffer *Buf = SM.getBuffer(LPosInfo.first); - const char* FileStart = Buf->getBufferStart(); - + const char* FileStart = Buf->getBufferStart(); + // Compute the column number. Rewind from the current position to the start // of the line. unsigned ColNo = SM.getColumnNumber(LPosInfo.first, LPosInfo.second); @@ -377,12 +377,12 @@ void HTMLDiagnostics::HandlePiece(Rewriter& R, FileID BugFileID, const char* FileEnd = Buf->getBufferEnd(); while (*LineEnd != '\n' && LineEnd != FileEnd) ++LineEnd; - + // Compute the margin offset by counting tabs and non-tabs. - unsigned PosNo = 0; + unsigned PosNo = 0; for (const char* c = LineStart; c != TokInstantiationPtr; ++c) PosNo += *c == '\t' ? 8 : 1; - + // Create the html for the message. const char *Kind = 0; @@ -392,22 +392,22 @@ void HTMLDiagnostics::HandlePiece(Rewriter& R, FileID BugFileID, // Setting Kind to "Control" is intentional. case PathDiagnosticPiece::Macro: Kind = "Control"; break; } - + std::string sbuf; llvm::raw_string_ostream os(sbuf); - + os << "\n<tr><td class=\"num\"></td><td class=\"line\"><div id=\""; - + if (num == max) os << "EndPath"; else os << "Path" << num; - + os << "\" class=\"msg"; if (Kind) - os << " msg" << Kind; + os << " msg" << Kind; os << "\" style=\"margin-left:" << PosNo << "ex"; - + // Output a maximum size. if (!isa<PathDiagnosticMacroPiece>(P)) { // Get the string and determining its maximum substring. @@ -415,32 +415,32 @@ void HTMLDiagnostics::HandlePiece(Rewriter& R, FileID BugFileID, unsigned max_token = 0; unsigned cnt = 0; unsigned len = Msg.size(); - + for (std::string::const_iterator I=Msg.begin(), E=Msg.end(); I!=E; ++I) switch (*I) { default: ++cnt; - continue; + continue; case ' ': case '\t': case '\n': if (cnt > max_token) max_token = cnt; cnt = 0; } - + if (cnt > max_token) max_token = cnt; - + // Determine the approximate size of the message bubble in em. unsigned em; const unsigned max_line = 120; - + if (max_token >= max_line) em = max_token / 2; else { unsigned characters = max_line; unsigned lines = len / max_line; - + if (lines > 0) { for (; characters > max_token; --characters) if (len / characters > lines) { @@ -448,18 +448,18 @@ void HTMLDiagnostics::HandlePiece(Rewriter& R, FileID BugFileID, break; } } - + em = characters / 2; } - + if (em < max_line/2) - os << "; max-width:" << em << "em"; + os << "; max-width:" << em << "em"; } else os << "; max-width:100em"; - + os << "\">"; - + if (max > 1) { os << "<table class=\"msgT\"><tr><td valign=\"top\">"; os << "<div class=\"PathIndex"; @@ -469,10 +469,10 @@ void HTMLDiagnostics::HandlePiece(Rewriter& R, FileID BugFileID, } if (const PathDiagnosticMacroPiece *MP = - dyn_cast<PathDiagnosticMacroPiece>(&P)) { + dyn_cast<PathDiagnosticMacroPiece>(&P)) { os << "Within the expansion of the macro '"; - + // Get the name of the macro by relexing it. { FullSourceLoc L = MP->getLocation().asLocation().getInstantiationLoc(); @@ -481,15 +481,15 @@ void HTMLDiagnostics::HandlePiece(Rewriter& R, FileID BugFileID, const char* MacroName = L.getDecomposedLoc().second + BufferInfo.first; Lexer rawLexer(L, PP->getLangOptions(), BufferInfo.first, MacroName, BufferInfo.second); - + Token TheTok; rawLexer.LexFromRawLexer(TheTok); for (unsigned i = 0, n = TheTok.getLength(); i < n; ++i) os << MacroName[i]; } - + os << "':\n"; - + if (max > 1) os << "</td></tr></table>"; @@ -498,21 +498,21 @@ void HTMLDiagnostics::HandlePiece(Rewriter& R, FileID BugFileID, } else { os << html::EscapeText(P.getString()); - + if (max > 1) os << "</td></tr></table>"; } - + os << "</div></td></tr>"; // Insert the new html. - unsigned DisplayPos = LineEnd - FileStart; - SourceLocation Loc = + unsigned DisplayPos = LineEnd - FileStart; + SourceLocation Loc = SM.getLocForStartOfFile(LPosInfo.first).getFileLocWithOffset(DisplayPos); R.InsertTextBefore(Loc, os.str()); - // Now highlight the ranges. + // Now highlight the ranges. for (const SourceRange *I = P.ranges_begin(), *E = P.ranges_end(); I != E; ++I) HighlightRange(R, LPosInfo.first, *I); @@ -547,9 +547,9 @@ static void EmitAlphaCounter(llvm::raw_ostream& os, unsigned n) { buf.push_back('a' + x); n = n / ('z' - 'a'); } while (n); - + assert(!buf.empty()); - + for (llvm::SmallVectorImpl<char>::reverse_iterator I=buf.rbegin(), E=buf.rend(); I!=E; ++I) os << *I; @@ -558,10 +558,10 @@ static void EmitAlphaCounter(llvm::raw_ostream& os, unsigned n) { unsigned HTMLDiagnostics::ProcessMacroPiece(llvm::raw_ostream& os, const PathDiagnosticMacroPiece& P, unsigned num) { - + for (PathDiagnosticMacroPiece::const_iterator I=P.begin(), E=P.end(); I!=E; ++I) { - + if (const PathDiagnosticMacroPiece *MP = dyn_cast<PathDiagnosticMacroPiece>(*I)) { num = ProcessMacroPiece(os, *MP, num); @@ -579,7 +579,7 @@ unsigned HTMLDiagnostics::ProcessMacroPiece(llvm::raw_ostream& os, << "</td></tr></table></div>\n"; } } - + return num; } @@ -589,20 +589,20 @@ void HTMLDiagnostics::HighlightRange(Rewriter& R, FileID BugFileID, const char *HighlightEnd) { SourceManager &SM = R.getSourceMgr(); const LangOptions &LangOpts = R.getLangOpts(); - + SourceLocation InstantiationStart = SM.getInstantiationLoc(Range.getBegin()); unsigned StartLineNo = SM.getInstantiationLineNumber(InstantiationStart); - + SourceLocation InstantiationEnd = SM.getInstantiationLoc(Range.getEnd()); unsigned EndLineNo = SM.getInstantiationLineNumber(InstantiationEnd); - + if (EndLineNo < StartLineNo) return; - + if (SM.getFileID(InstantiationStart) != BugFileID || SM.getFileID(InstantiationEnd) != BugFileID) return; - + // Compute the column number of the end. unsigned EndColNo = SM.getInstantiationColumnNumber(InstantiationEnd); unsigned OldEndColNo = EndColNo; @@ -611,12 +611,12 @@ void HTMLDiagnostics::HighlightRange(Rewriter& R, FileID BugFileID, // Add in the length of the token, so that we cover multi-char tokens. EndColNo += Lexer::MeasureTokenLength(Range.getEnd(), SM, LangOpts)-1; } - + // Highlight the range. Make the span tag the outermost tag for the // selected range. - + SourceLocation E = InstantiationEnd.getFileLocWithOffset(EndColNo - OldEndColNo); - + html::HighlightRange(R, InstantiationStart, E, HighlightStart, HighlightEnd); } diff --git a/clang/lib/Frontend/HTMLPrint.cpp b/clang/lib/Frontend/HTMLPrint.cpp index f434bcc0c74..8d93d70e83f 100644 --- a/clang/lib/Frontend/HTMLPrint.cpp +++ b/clang/lib/Frontend/HTMLPrint.cpp @@ -26,7 +26,7 @@ using namespace clang; //===----------------------------------------------------------------------===// // Functional HTML pretty-printing. -//===----------------------------------------------------------------------===// +//===----------------------------------------------------------------------===// namespace { class HTMLPrinter : public ASTConsumer { @@ -40,7 +40,7 @@ namespace { PreprocessorFactory* ppf) : Out(OS), Diags(D), PP(pp), PPF(ppf) {} virtual ~HTMLPrinter(); - + void Initialize(ASTContext &context); }; } @@ -48,7 +48,7 @@ namespace { ASTConsumer* clang::CreateHTMLPrinter(llvm::raw_ostream *OS, Diagnostic &D, Preprocessor *PP, PreprocessorFactory* PPF) { - + return new HTMLPrinter(OS, D, PP, PPF); } @@ -78,7 +78,7 @@ HTMLPrinter::~HTMLPrinter() { // If we have a preprocessor, relex the file and syntax highlight. // We might not have a preprocessor if we come from a deserialized AST file, // for example. - + if (PP) html::SyntaxHighlight(R, FID, *PP); if (PPF) html::HighlightMacros(R, FID, *PP); html::EscapeText(R, FID, false, true); diff --git a/clang/lib/Frontend/InitHeaderSearch.cpp b/clang/lib/Frontend/InitHeaderSearch.cpp index 86742615708..da45bcca97c 100644 --- a/clang/lib/Frontend/InitHeaderSearch.cpp +++ b/clang/lib/Frontend/InitHeaderSearch.cpp @@ -29,10 +29,10 @@ void InitHeaderSearch::AddPath(const llvm::StringRef &Path, bool IgnoreSysRoot) { assert(!Path.empty() && "can't handle empty path here"); FileManager &FM = Headers.getFileMgr(); - + // Compute the actual path, taking into consideration -isysroot. llvm::SmallString<256> MappedPath; - + // Handle isysroot. if (Group == System && !IgnoreSysRoot) { // FIXME: Portability. This should be a sys::Path interface, this doesn't @@ -40,7 +40,7 @@ void InitHeaderSearch::AddPath(const llvm::StringRef &Path, if (isysroot.size() != 1 || isysroot[0] != '/') // Add isysroot if present. MappedPath.append(isysroot.begin(), isysroot.end()); } - + MappedPath.append(Path.begin(), Path.end()); // Compute the DirectoryLookup type. @@ -51,15 +51,15 @@ void InitHeaderSearch::AddPath(const llvm::StringRef &Path, Type = SrcMgr::C_System; else Type = SrcMgr::C_ExternCSystem; - - + + // If the directory exists, add it. if (const DirectoryEntry *DE = FM.getDirectory(MappedPath.str())) { IncludeGroup[Group].push_back(DirectoryLookup(DE, Type, isUserSupplied, isFramework)); return; } - + // Check to see if this is an apple-style headermap (which are not allowed to // be frameworks). if (!isFramework) { @@ -71,7 +71,7 @@ void InitHeaderSearch::AddPath(const llvm::StringRef &Path, } } } - + if (Verbose) llvm::errs() << "ignoring nonexistent directory \"" << MappedPath.str() << "\"\n"; @@ -251,9 +251,9 @@ static void RemoveDuplicates(std::vector<DirectoryLookup> &SearchList, llvm::SmallPtrSet<const HeaderMap *, 8> SeenHeaderMaps; for (unsigned i = 0; i != SearchList.size(); ++i) { unsigned DirToRemove = i; - + const DirectoryLookup &CurEntry = SearchList[i]; - + if (CurEntry.isNormalDir()) { // If this isn't the first time we've seen this dir, remove it. if (SeenDirs.insert(CurEntry.getDir())) @@ -268,7 +268,7 @@ static void RemoveDuplicates(std::vector<DirectoryLookup> &SearchList, if (SeenHeaderMaps.insert(CurEntry.getHeaderMap())) continue; } - + // If we have a normal #include dir/framework/headermap that is shadowed // later in the chain by a system include location, we actually want to // ignore the user's request and drop the user dir... keeping the system @@ -281,13 +281,13 @@ static void RemoveDuplicates(std::vector<DirectoryLookup> &SearchList, unsigned FirstDir; for (FirstDir = 0; ; ++FirstDir) { assert(FirstDir != i && "Didn't find dupe?"); - + const DirectoryLookup &SearchEntry = SearchList[FirstDir]; // If these are different lookup types, then they can't be the dupe. if (SearchEntry.getLookupType() != CurEntry.getLookupType()) continue; - + bool isSame; if (CurEntry.isNormalDir()) isSame = SearchEntry.getDir() == CurEntry.getDir(); @@ -297,11 +297,11 @@ static void RemoveDuplicates(std::vector<DirectoryLookup> &SearchList, assert(CurEntry.isHeaderMap() && "Not a headermap or normal dir?"); isSame = SearchEntry.getHeaderMap() == CurEntry.getHeaderMap(); } - + if (isSame) break; } - + // If the first dir in the search path is a non-system dir, zap it // instead of the system one. if (SearchList[FirstDir].getDirCharacteristic() == SrcMgr::C_User) @@ -315,7 +315,7 @@ static void RemoveDuplicates(std::vector<DirectoryLookup> &SearchList, fprintf(stderr, " as it is a non-system directory that duplicates" " a system directory\n"); } - + // This is reached if the current entry is a duplicate. Remove the // DirToRemove (usually the current dir). SearchList.erase(SearchList.begin()+DirToRemove); @@ -334,11 +334,11 @@ void InitHeaderSearch::Realize() { IncludeGroup[After].end()); RemoveDuplicates(SearchList, Verbose); RemoveDuplicates(IncludeGroup[Quoted], Verbose); - + // Prepend QUOTED list on the search list. - SearchList.insert(SearchList.begin(), IncludeGroup[Quoted].begin(), + SearchList.insert(SearchList.begin(), IncludeGroup[Quoted].begin(), IncludeGroup[Quoted].end()); - + bool DontSearchCurDir = false; // TODO: set to true if -I- is set? Headers.SetSearchPaths(SearchList, IncludeGroup[Quoted].size(), diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp index 90e5bdec555..14657f02d5f 100644 --- a/clang/lib/Frontend/InitPreprocessor.cpp +++ b/clang/lib/Frontend/InitPreprocessor.cpp @@ -30,7 +30,7 @@ static void DefineBuiltinMacro(std::vector<char> &Buf, const char *Macro) { // Turn the = into ' '. Buf.insert(Buf.end(), Macro, Equal); Buf.push_back(' '); - + // Per GCC -D semantics, the macro ends at \n if it exists. const char *End = strpbrk(Equal, "\n\r"); if (End) { @@ -40,7 +40,7 @@ static void DefineBuiltinMacro(std::vector<char> &Buf, const char *Macro) { } else { End = Equal+strlen(Equal); } - + Buf.insert(Buf.end(), Equal+1, End); } else { // Push "macroname 1". @@ -62,7 +62,7 @@ static void UndefineBuiltinMacro(std::vector<char> &Buf, const char *Macro) { } /// Add the quoted name of an implicit include file. -static void AddQuotedIncludePath(std::vector<char> &Buf, +static void AddQuotedIncludePath(std::vector<char> &Buf, const std::string &File) { // Implicit include paths should be resolved relative to the current // working directory first, and then use the regular header search @@ -75,7 +75,7 @@ static void AddQuotedIncludePath(std::vector<char> &Buf, Path.makeAbsolute(); if (!Path.exists()) Path = File; - + // Escape double quotes etc. Buf.push_back('"'); std::string EscapedFile = Lexer::Stringify(Path.str()); @@ -85,7 +85,7 @@ static void AddQuotedIncludePath(std::vector<char> &Buf, /// AddImplicitInclude - Add an implicit #include of the specified file to the /// predefines buffer. -static void AddImplicitInclude(std::vector<char> &Buf, +static void AddImplicitInclude(std::vector<char> &Buf, const std::string &File) { const char *Inc = "#include "; Buf.insert(Buf.end(), Inc, Inc+strlen(Inc)); @@ -106,12 +106,12 @@ static void AddImplicitIncludeMacros(std::vector<char> &Buf, /// AddImplicitIncludePTH - Add an implicit #include using the original file /// used to generate a PTH cache. -static void AddImplicitIncludePTH(std::vector<char> &Buf, Preprocessor &PP, +static void AddImplicitIncludePTH(std::vector<char> &Buf, Preprocessor &PP, const std::string& ImplicitIncludePTH) { PTHManager *P = PP.getPTHManager(); assert(P && "No PTHManager."); const char *OriginalFile = P->getOriginalSourceFile(); - + if (!OriginalFile) { assert(!ImplicitIncludePTH.empty()); fprintf(stderr, "error: PTH file '%s' does not designate an original " @@ -119,7 +119,7 @@ static void AddImplicitIncludePTH(std::vector<char> &Buf, Preprocessor &PP, ImplicitIncludePTH.c_str()); exit (1); } - + AddImplicitInclude(Buf, OriginalFile); } @@ -144,7 +144,7 @@ static T PickFP(const llvm::fltSemantics *Sem, T IEEESingleVal, static void DefineFloatMacros(std::vector<char> &Buf, const char *Prefix, const llvm::fltSemantics *Sem) { const char *DenormMin, *Epsilon, *Max, *Min; - DenormMin = PickFP(Sem, "1.40129846e-45F", "4.9406564584124654e-324", + DenormMin = PickFP(Sem, "1.40129846e-45F", "4.9406564584124654e-324", "3.64519953188247460253e-4951L", "4.94065645841246544176568792868221e-324L", "6.47517511943802511092443895822764655e-4966L"); @@ -167,7 +167,7 @@ static void DefineFloatMacros(std::vector<char> &Buf, const char *Prefix, "1.18973149535723176502e+4932L", "1.79769313486231580793728971405301e+308L", "1.18973149535723176508575932662800702e+4932L"); - + char MacroBuf[100]; sprintf(MacroBuf, "__%s_DENORM_MIN__=%s", Prefix, DenormMin); DefineBuiltinMacro(Buf, MacroBuf); @@ -210,7 +210,7 @@ static void DefineTypeSize(const char *MacroName, unsigned TypeWidth, MaxVal = (1LL << (TypeWidth - 1)) - 1; else MaxVal = ~0LL >> (64-TypeWidth); - + // FIXME: Switch to using raw_ostream and avoid utostr(). sprintf(MacroBuf, "%s=%s%s", MacroName, llvm::utostr(MaxVal).c_str(), ValSuffix); @@ -232,17 +232,17 @@ static void InitializePredefinedMacros(const TargetInfo &TI, // Compiler version introspection macros. DefineBuiltinMacro(Buf, "__llvm__=1"); // LLVM Backend DefineBuiltinMacro(Buf, "__clang__=1"); // Clang Frontend - + // Currently claim to be compatible with GCC 4.2.1-5621. DefineBuiltinMacro(Buf, "__GNUC_MINOR__=2"); DefineBuiltinMacro(Buf, "__GNUC_PATCHLEVEL__=1"); DefineBuiltinMacro(Buf, "__GNUC__=4"); DefineBuiltinMacro(Buf, "__GXX_ABI_VERSION=1002"); DefineBuiltinMacro(Buf, "__VERSION__=\"4.2.1 Compatible Clang Compiler\""); - - + + // Initialize language-specific preprocessor defines. - + // These should all be defined in the preprocessor according to the // current language configuration. if (!LangOpts.Microsoft) @@ -260,7 +260,7 @@ static void InitializePredefinedMacros(const TargetInfo &TI, // Standard conforming mode? if (!LangOpts.GNUMode) DefineBuiltinMacro(Buf, "__STRICT_ANSI__=1"); - + if (LangOpts.CPlusPlus0x) DefineBuiltinMacro(Buf, "__GXX_EXPERIMENTAL_CXX0X__"); @@ -268,7 +268,7 @@ static void InitializePredefinedMacros(const TargetInfo &TI, DefineBuiltinMacro(Buf, "__STDC_HOSTED__=0"); else DefineBuiltinMacro(Buf, "__STDC_HOSTED__=1"); - + if (LangOpts.ObjC1) { DefineBuiltinMacro(Buf, "__OBJC__=1"); if (LangOpts.ObjCNonFragileABI) { @@ -279,15 +279,15 @@ static void InitializePredefinedMacros(const TargetInfo &TI, if (LangOpts.getGCMode() != LangOptions::NonGC) DefineBuiltinMacro(Buf, "__OBJC_GC__=1"); - + if (LangOpts.NeXTRuntime) DefineBuiltinMacro(Buf, "__NEXT_RUNTIME__=1"); } - + // darwin_constant_cfstrings controls this. This is also dependent // on other things like the runtime I believe. This is set even for C code. DefineBuiltinMacro(Buf, "__CONSTANT_CFSTRINGS__=1"); - + if (LangOpts.ObjC2) DefineBuiltinMacro(Buf, "OBJC_NEW_PROPERTIES"); @@ -301,7 +301,7 @@ static void InitializePredefinedMacros(const TargetInfo &TI, DefineBuiltinMacro(Buf, "__block=__attribute__((__blocks__(byref)))"); DefineBuiltinMacro(Buf, "__BLOCKS__=1"); } - + if (LangOpts.CPlusPlus) { DefineBuiltinMacro(Buf, "__DEPRECATED=1"); DefineBuiltinMacro(Buf, "__EXCEPTIONS=1"); @@ -309,32 +309,32 @@ static void InitializePredefinedMacros(const TargetInfo &TI, DefineBuiltinMacro(Buf, "__GXX_WEAK__=1"); if (LangOpts.GNUMode) DefineBuiltinMacro(Buf, "__cplusplus=1"); - else + else // C++ [cpp.predefined]p1: - // The name_ _cplusplusis defined to the value199711Lwhen compiling a + // The name_ _cplusplusis defined to the value199711Lwhen compiling a // C++ translation unit. DefineBuiltinMacro(Buf, "__cplusplus=199711L"); DefineBuiltinMacro(Buf, "__private_extern__=extern"); // Ugly hack to work with GNU libstdc++. DefineBuiltinMacro(Buf, "_GNU_SOURCE=1"); } - + // Filter out some microsoft extensions when trying to parse in ms-compat - // mode. + // mode. if (LangOpts.Microsoft) { DefineBuiltinMacro(Buf, "__int8=__INT8_TYPE__"); DefineBuiltinMacro(Buf, "__int16=__INT16_TYPE__"); DefineBuiltinMacro(Buf, "__int32=__INT32_TYPE__"); DefineBuiltinMacro(Buf, "__int64=__INT64_TYPE__"); } - + if (LangOpts.Optimize) DefineBuiltinMacro(Buf, "__OPTIMIZE__=1"); if (LangOpts.OptimizeSize) DefineBuiltinMacro(Buf, "__OPTIMIZE_SIZE__=1"); - + // Initialize target-specific preprocessor defines. - + // Define type sizing macros based on the target properties. assert(TI.getCharWidth() == 8 && "Only support 8-bit char so far"); DefineBuiltinMacro(Buf, "__CHAR_BIT__=8"); @@ -352,7 +352,7 @@ static void InitializePredefinedMacros(const TargetInfo &TI, IntMaxWidth = TI.getIntWidth(); IntMaxSuffix = ""; } - + DefineTypeSize("__SCHAR_MAX__", TI.getCharWidth(), "", true, Buf); DefineTypeSize("__SHRT_MAX__", TI.getShortWidth(), "", true, Buf); DefineTypeSize("__INT_MAX__", TI.getIntWidth(), "", true, Buf); @@ -369,7 +369,7 @@ static void InitializePredefinedMacros(const TargetInfo &TI, DefineType("__WCHAR_TYPE__", TI.getWCharType(), Buf); // FIXME: TargetInfo hookize __WINT_TYPE__. DefineBuiltinMacro(Buf, "__WINT_TYPE__=int"); - + DefineFloatMacros(Buf, "FLT", &TI.getFloatFormat()); DefineFloatMacros(Buf, "DBL", &TI.getDoubleFormat()); DefineFloatMacros(Buf, "LDBL", &TI.getLongDoubleFormat()); @@ -377,39 +377,39 @@ static void InitializePredefinedMacros(const TargetInfo &TI, // Define a __POINTER_WIDTH__ macro for stdint.h. sprintf(MacroBuf, "__POINTER_WIDTH__=%d", (int)TI.getPointerWidth(0)); DefineBuiltinMacro(Buf, MacroBuf); - + if (!LangOpts.CharIsSigned) - DefineBuiltinMacro(Buf, "__CHAR_UNSIGNED__"); + DefineBuiltinMacro(Buf, "__CHAR_UNSIGNED__"); // Define fixed-sized integer types for stdint.h assert(TI.getCharWidth() == 8 && "unsupported target types"); assert(TI.getShortWidth() == 16 && "unsupported target types"); DefineBuiltinMacro(Buf, "__INT8_TYPE__=char"); DefineBuiltinMacro(Buf, "__INT16_TYPE__=short"); - + if (TI.getIntWidth() == 32) DefineBuiltinMacro(Buf, "__INT32_TYPE__=int"); else { assert(TI.getLongLongWidth() == 32 && "unsupported target types"); DefineBuiltinMacro(Buf, "__INT32_TYPE__=long long"); } - + // 16-bit targets doesn't necessarily have a 64-bit type. if (TI.getLongLongWidth() == 64) DefineType("__INT64_TYPE__", TI.getInt64Type(), Buf); - + // Add __builtin_va_list typedef. { const char *VAList = TI.getVAListDeclaration(); Buf.insert(Buf.end(), VAList, VAList+strlen(VAList)); Buf.push_back('\n'); } - + if (const char *Prefix = TI.getUserLabelPrefix()) { sprintf(MacroBuf, "__USER_LABEL_PREFIX__=%s", Prefix); DefineBuiltinMacro(Buf, MacroBuf); } - + // Build configuration options. FIXME: these should be controlled by // command line options or something. DefineBuiltinMacro(Buf, "__FINITE_MATH_ONLY__=0"); @@ -452,15 +452,15 @@ static void InitializePredefinedMacros(const TargetInfo &TI, bool InitializePreprocessor(Preprocessor &PP, const PreprocessorInitOptions& InitOpts) { std::vector<char> PredefineBuffer; - + const char *LineDirective = "# 1 \"<built-in>\" 3\n"; PredefineBuffer.insert(PredefineBuffer.end(), LineDirective, LineDirective+strlen(LineDirective)); - + // Install things like __POWERPC__, __GNUC__, etc into the macro table. InitializePredefinedMacros(PP.getTargetInfo(), PP.getLangOptions(), PredefineBuffer); - + // Add on the predefines from the driver. Wrap in a #line directive to report // that they come from the command line. LineDirective = "# 1 \"<command line>\" 1\n"; diff --git a/clang/lib/Frontend/PCHReader.cpp b/clang/lib/Frontend/PCHReader.cpp index f4d06c068bd..e7321bf6fab 100644 --- a/clang/lib/Frontend/PCHReader.cpp +++ b/clang/lib/Frontend/PCHReader.cpp @@ -69,21 +69,21 @@ PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) { PARSE_LANGOPT_IMPORTANT(ObjCNonFragileABI, diag::warn_pch_nonfragile_abi); PARSE_LANGOPT_BENIGN(PascalStrings); PARSE_LANGOPT_BENIGN(WritableStrings); - PARSE_LANGOPT_IMPORTANT(LaxVectorConversions, + PARSE_LANGOPT_IMPORTANT(LaxVectorConversions, diag::warn_pch_lax_vector_conversions); PARSE_LANGOPT_IMPORTANT(AltiVec, diag::warn_pch_altivec); PARSE_LANGOPT_IMPORTANT(Exceptions, diag::warn_pch_exceptions); PARSE_LANGOPT_IMPORTANT(NeXTRuntime, diag::warn_pch_objc_runtime); PARSE_LANGOPT_IMPORTANT(Freestanding, diag::warn_pch_freestanding); PARSE_LANGOPT_IMPORTANT(NoBuiltin, diag::warn_pch_builtins); - PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics, + PARSE_LANGOPT_IMPORTANT(ThreadsafeStatics, diag::warn_pch_thread_safe_statics); PARSE_LANGOPT_IMPORTANT(POSIXThreads, diag::warn_pch_posix_threads); PARSE_LANGOPT_IMPORTANT(Blocks, diag::warn_pch_blocks); PARSE_LANGOPT_BENIGN(EmitAllDecls); PARSE_LANGOPT_IMPORTANT(MathErrno, diag::warn_pch_math_errno); PARSE_LANGOPT_IMPORTANT(OverflowChecking, diag::warn_pch_overflow_checking); - PARSE_LANGOPT_IMPORTANT(HeinousExtensions, + PARSE_LANGOPT_IMPORTANT(HeinousExtensions, diag::warn_pch_heinous_extensions); // FIXME: Most of the options below are benign if the macro wasn't // used. Unfortunately, this means that a PCH compiled without @@ -101,7 +101,7 @@ PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts) { PARSE_LANGOPT_IMPORTANT(AccessControl, diag::warn_pch_access_control); PARSE_LANGOPT_IMPORTANT(CharIsSigned, diag::warn_pch_char_signed); if ((PPLangOpts.getGCMode() != 0) != (LangOpts.getGCMode() != 0)) { - Reader.Diag(diag::warn_pch_gc_mode) + Reader.Diag(diag::warn_pch_gc_mode) << LangOpts.getGCMode() << PPLangOpts.getGCMode(); return true; } @@ -165,7 +165,7 @@ static inline bool startsWith(const std::string &Haystack, return startsWith(Haystack, Needle.c_str()); } -bool PCHValidator::ReadPredefinesBuffer(const char *PCHPredef, +bool PCHValidator::ReadPredefinesBuffer(const char *PCHPredef, unsigned PCHPredefLen, FileID PCHBufferID, std::string &SuggestedPredefines) { @@ -173,19 +173,19 @@ bool PCHValidator::ReadPredefinesBuffer(const char *PCHPredef, unsigned PredefLen = PP.getPredefines().size(); // If the two predefines buffers compare equal, we're done! - if (PredefLen == PCHPredefLen && + if (PredefLen == PCHPredefLen && strncmp(Predef, PCHPredef, PCHPredefLen) == 0) return false; SourceManager &SourceMgr = PP.getSourceManager(); - + // The predefines buffers are different. Determine what the // differences are, and whether they require us to reject the PCH // file. std::vector<std::string> CmdLineLines = splitLines(Predef, PredefLen); std::vector<std::string> PCHLines = splitLines(PCHPredef, PCHPredefLen); - // Sort both sets of predefined buffer lines, since + // Sort both sets of predefined buffer lines, since std::sort(CmdLineLines.begin(), CmdLineLines.end()); std::sort(PCHLines.begin(), PCHLines.end()); @@ -204,11 +204,11 @@ bool PCHValidator::ReadPredefinesBuffer(const char *PCHPredef, Reader.Diag(diag::warn_pch_compiler_options_mismatch); return true; } - + // This is a macro definition. Determine the name of the macro // we're defining. std::string::size_type StartOfMacroName = strlen("#define "); - std::string::size_type EndOfMacroName + std::string::size_type EndOfMacroName = Missing.find_first_of("( \n\r", StartOfMacroName); assert(EndOfMacroName != std::string::npos && "Couldn't find the end of the macro name"); @@ -226,19 +226,19 @@ bool PCHValidator::ReadPredefinesBuffer(const char *PCHPredef, if (!startsWith(*ConflictPos, MacroDefStart)) { // Different macro; we're done. ConflictPos = CmdLineLines.end(); - break; + break; } - - assert(ConflictPos->size() > MacroDefLen && + + assert(ConflictPos->size() > MacroDefLen && "Invalid #define in predefines buffer?"); - if ((*ConflictPos)[MacroDefLen] != ' ' && + if ((*ConflictPos)[MacroDefLen] != ' ' && (*ConflictPos)[MacroDefLen] != '(') continue; // Longer macro name; keep trying. - + // We found a conflicting macro definition. break; } - + if (ConflictPos != CmdLineLines.end()) { Reader.Diag(diag::warn_cmdline_conflicting_macro_def) << MacroName; @@ -255,13 +255,13 @@ bool PCHValidator::ReadPredefinesBuffer(const char *PCHPredef, ConflictingDefines = true; continue; } - + // If the macro doesn't conflict, then we'll just pick up the // macro definition from the PCH file. Warn the user that they // made a mistake. if (ConflictingDefines) continue; // Don't complain if there are already conflicting defs - + if (!MissingDefines) { Reader.Diag(diag::warn_cmdline_missing_macro_defs); MissingDefines = true; @@ -275,10 +275,10 @@ bool PCHValidator::ReadPredefinesBuffer(const char *PCHPredef, .getFileLocWithOffset(Offset); Reader.Diag(PCHMissingLoc, diag::note_using_macro_def_from_pch); } - + if (ConflictingDefines) return true; - + // Determine what predefines were introduced based on command-line // parameters that were not present when building the PCH // file. Extra #defines are okay, so long as the identifiers being @@ -286,7 +286,7 @@ bool PCHValidator::ReadPredefinesBuffer(const char *PCHPredef, std::vector<std::string> ExtraPredefines; std::set_difference(CmdLineLines.begin(), CmdLineLines.end(), PCHLines.begin(), PCHLines.end(), - std::back_inserter(ExtraPredefines)); + std::back_inserter(ExtraPredefines)); for (unsigned I = 0, N = ExtraPredefines.size(); I != N; ++I) { const std::string &Extra = ExtraPredefines[I]; if (!startsWith(Extra, "#define ") != 0) { @@ -297,7 +297,7 @@ bool PCHValidator::ReadPredefinesBuffer(const char *PCHPredef, // This is an extra macro definition. Determine the name of the // macro we're defining. std::string::size_type StartOfMacroName = strlen("#define "); - std::string::size_type EndOfMacroName + std::string::size_type EndOfMacroName = Extra.find_first_of("( \n\r", StartOfMacroName); assert(EndOfMacroName != std::string::npos && "Couldn't find the end of the macro name"); @@ -338,8 +338,8 @@ void PCHValidator::ReadCounter(unsigned Value) { // PCH reader implementation //===----------------------------------------------------------------------===// -PCHReader::PCHReader(Preprocessor &PP, ASTContext *Context, - const char *isysroot) +PCHReader::PCHReader(Preprocessor &PP, ASTContext *Context, + const char *isysroot) : Listener(new PCHValidator(PP, *this)), SourceMgr(PP.getSourceManager()), FileMgr(PP.getFileManager()), Diags(PP.getDiagnostics()), SemaObj(0), PP(&PP), Context(Context), Consumer(0), @@ -348,16 +348,16 @@ PCHReader::PCHReader(Preprocessor &PP, ASTContext *Context, MethodPoolLookupTable(0), MethodPoolLookupTableData(0), TotalSelectorsInMethodPool(0), SelectorOffsets(0), TotalNumSelectors(0), Comments(0), NumComments(0), isysroot(isysroot), - NumStatHits(0), NumStatMisses(0), - NumSLocEntriesRead(0), NumStatementsRead(0), + NumStatHits(0), NumStatMisses(0), + NumSLocEntriesRead(0), NumStatementsRead(0), NumMacrosRead(0), NumMethodPoolSelectorsRead(0), NumMethodPoolMisses(0), NumLexicalDeclContextsRead(0), NumVisibleDeclContextsRead(0), - CurrentlyLoadingTypeOrDecl(0) { + CurrentlyLoadingTypeOrDecl(0) { RelocatablePCH = false; } PCHReader::PCHReader(SourceManager &SourceMgr, FileManager &FileMgr, - Diagnostic &Diags, const char *isysroot) + Diagnostic &Diags, const char *isysroot) : SourceMgr(SourceMgr), FileMgr(FileMgr), Diags(Diags), SemaObj(0), PP(0), Context(0), Consumer(0), IdentifierTableData(0), IdentifierLookupTable(0), @@ -365,11 +365,11 @@ PCHReader::PCHReader(SourceManager &SourceMgr, FileManager &FileMgr, MethodPoolLookupTable(0), MethodPoolLookupTableData(0), TotalSelectorsInMethodPool(0), SelectorOffsets(0), TotalNumSelectors(0), Comments(0), NumComments(0), isysroot(isysroot), - NumStatHits(0), NumStatMisses(0), - NumSLocEntriesRead(0), NumStatementsRead(0), + NumStatHits(0), NumStatMisses(0), + NumSLocEntriesRead(0), NumStatementsRead(0), NumMacrosRead(0), NumMethodPoolSelectorsRead(0), NumMethodPoolMisses(0), NumLexicalDeclContextsRead(0), NumVisibleDeclContextsRead(0), - CurrentlyLoadingTypeOrDecl(0) { + CurrentlyLoadingTypeOrDecl(0) { RelocatablePCH = false; } @@ -395,12 +395,12 @@ public: typedef external_key_type internal_key_type; explicit PCHMethodPoolLookupTrait(PCHReader &Reader) : Reader(Reader) { } - + static bool EqualKey(const internal_key_type& a, const internal_key_type& b) { return a == b; } - + static unsigned ComputeHash(Selector Sel) { unsigned N = Sel.getNumArgs(); if (N == 0) @@ -411,11 +411,11 @@ public: R = clang::BernsteinHashPartial(II->getName(), II->getLength(), R); return R; } - + // This hopefully will just get inlined and removed by the optimizer. static const internal_key_type& GetInternalKey(const external_key_type& x) { return x; } - + static std::pair<unsigned, unsigned> ReadKeyDataLength(const unsigned char*& d) { using namespace clang::io; @@ -423,12 +423,12 @@ public: unsigned DataLen = ReadUnalignedLE16(d); return std::make_pair(KeyLen, DataLen); } - + internal_key_type ReadKey(const unsigned char* d, unsigned) { using namespace clang::io; SelectorTable &SelTable = Reader.getContext()->Selectors; unsigned N = ReadUnalignedLE16(d); - IdentifierInfo *FirstII + IdentifierInfo *FirstII = Reader.DecodeIdentifierInfo(ReadUnalignedLE32(d)); if (N == 0) return SelTable.getNullarySelector(FirstII); @@ -442,7 +442,7 @@ public: return SelTable.getSelector(N, Args.data()); } - + data_type ReadData(Selector, const unsigned char* d, unsigned DataLen) { using namespace clang::io; unsigned NumInstanceMethods = ReadUnalignedLE16(d); @@ -453,7 +453,7 @@ public: // Load instance methods ObjCMethodList *Prev = 0; for (unsigned I = 0; I != NumInstanceMethods; ++I) { - ObjCMethodDecl *Method + ObjCMethodDecl *Method = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d))); if (!Result.first.Method) { // This is the first method, which is the easy case. @@ -469,7 +469,7 @@ public: // Load factory methods Prev = 0; for (unsigned I = 0; I != NumFactoryMethods; ++I) { - ObjCMethodDecl *Method + ObjCMethodDecl *Method = cast<ObjCMethodDecl>(Reader.GetDecl(ReadUnalignedLE32(d))); if (!Result.second.Method) { // This is the first method, which is the easy case. @@ -485,11 +485,11 @@ public: return Result; } }; - -} // end anonymous namespace + +} // end anonymous namespace /// \brief The on-disk hash table used for the global method pool. -typedef OnDiskChainedHashTable<PCHMethodPoolLookupTrait> +typedef OnDiskChainedHashTable<PCHMethodPoolLookupTrait> PCHMethodPoolLookupTable; namespace { @@ -508,23 +508,23 @@ public: typedef external_key_type internal_key_type; - explicit PCHIdentifierLookupTrait(PCHReader &Reader, IdentifierInfo *II = 0) + explicit PCHIdentifierLookupTrait(PCHReader &Reader, IdentifierInfo *II = 0) : Reader(Reader), KnownII(II) { } - + static bool EqualKey(const internal_key_type& a, const internal_key_type& b) { return (a.second == b.second) ? memcmp(a.first, b.first, a.second) == 0 : false; } - + static unsigned ComputeHash(const internal_key_type& a) { return BernsteinHash(a.first, a.second); } - + // This hopefully will just get inlined and removed by the optimizer. static const internal_key_type& GetInternalKey(const external_key_type& x) { return x; } - + static std::pair<unsigned, unsigned> ReadKeyDataLength(const unsigned char*& d) { using namespace clang::io; @@ -532,14 +532,14 @@ public: unsigned KeyLen = ReadUnalignedLE16(d); return std::make_pair(KeyLen, DataLen); } - + static std::pair<const char*, unsigned> ReadKey(const unsigned char* d, unsigned n) { assert(n >= 2 && d[n-1] == '\0'); return std::make_pair((const char*) d, n-1); } - - IdentifierInfo *ReadData(const internal_key_type& k, + + IdentifierInfo *ReadData(const internal_key_type& k, const unsigned char* d, unsigned DataLen) { using namespace clang::io; @@ -571,7 +571,7 @@ public: Bits >>= 1; unsigned ObjCOrBuiltinID = Bits & 0x3FF; Bits >>= 10; - + assert(Bits == 0 && "Extra bits in the identifier?"); DataLen -= 6; @@ -586,7 +586,7 @@ public: // Set or check the various bits in the IdentifierInfo structure. // FIXME: Load token IDs lazily, too? II->setObjCOrBuiltinID(ObjCOrBuiltinID); - assert(II->isExtensionToken() == ExtensionToken && + assert(II->isExtensionToken() == ExtensionToken && "Incorrect extension token flag"); (void)ExtensionToken; II->setIsPoisoned(Poisoned); @@ -611,16 +611,16 @@ public: DeclIDs.push_back(ReadUnalignedLE32(d)); Reader.SetGloballyVisibleDecls(II, DeclIDs); } - + return II; } }; - -} // end anonymous namespace + +} // end anonymous namespace /// \brief The on-disk hash table used to contain information about /// all of the identifiers in the program. -typedef OnDiskChainedHashTable<PCHIdentifierLookupTrait> +typedef OnDiskChainedHashTable<PCHIdentifierLookupTrait> PCHIdentifierLookupTable; bool PCHReader::Error(const char *Msg) { @@ -646,7 +646,7 @@ bool PCHReader::Error(const char *Msg) { /// /// \returns true if there was a mismatch (in which case the PCH file /// should be ignored), or false otherwise. -bool PCHReader::CheckPredefinesBuffer(const char *PCHPredef, +bool PCHReader::CheckPredefinesBuffer(const char *PCHPredef, unsigned PCHPredefLen, FileID PCHBufferID) { if (Listener) @@ -673,7 +673,7 @@ bool PCHReader::ParseLineTable(llvm::SmallVectorImpl<uint64_t> &Record) { std::string Filename(&Record[Idx], &Record[Idx] + FilenameLen); Idx += FilenameLen; MaybeAddSystemRootToFilename(Filename); - FileIDs[I] = LineTable.getLineTableFilenameID(Filename.c_str(), + FileIDs[I] = LineTable.getLineTableFilenameID(Filename.c_str(), Filename.size()); } @@ -690,7 +690,7 @@ bool PCHReader::ParseLineTable(llvm::SmallVectorImpl<uint64_t> &Record) { unsigned FileOffset = Record[Idx++]; unsigned LineNo = Record[Idx++]; int FilenameID = Record[Idx++]; - SrcMgr::CharacteristicKind FileKind + SrcMgr::CharacteristicKind FileKind = (SrcMgr::CharacteristicKind)Record[Idx++]; unsigned IncludeOffset = Record[Idx++]; Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID, @@ -712,10 +712,10 @@ public: const mode_t mode; const time_t mtime; const off_t size; - + PCHStatData(ino_t i, dev_t d, mode_t mo, time_t m, off_t s) - : hasStat(true), ino(i), dev(d), mode(mo), mtime(m), size(s) {} - + : hasStat(true), ino(i), dev(d), mode(mo), mtime(m), size(s) {} + PCHStatData() : hasStat(false), ino(0), dev(0), mode(0), mtime(0), size(0) {} }; @@ -758,7 +758,7 @@ class VISIBILITY_HIDDEN PCHStatLookupTrait { ino_t ino = (ino_t) ReadUnalignedLE32(d); dev_t dev = (dev_t) ReadUnalignedLE32(d); mode_t mode = (mode_t) ReadUnalignedLE16(d); - time_t mtime = (time_t) ReadUnalignedLE64(d); + time_t mtime = (time_t) ReadUnalignedLE64(d); off_t size = (off_t) ReadUnalignedLE64(d); return data_type(ino, dev, mode, mtime, size); } @@ -773,17 +773,17 @@ class VISIBILITY_HIDDEN PCHStatCache : public StatSysCallCache { CacheTy *Cache; unsigned &NumStatHits, &NumStatMisses; -public: +public: PCHStatCache(const unsigned char *Buckets, const unsigned char *Base, unsigned &NumStatHits, - unsigned &NumStatMisses) + unsigned &NumStatMisses) : Cache(0), NumStatHits(NumStatHits), NumStatMisses(NumStatMisses) { Cache = CacheTy::Create(Buckets, Base); } ~PCHStatCache() { delete Cache; } - + int stat(const char *path, struct stat *buf) { // Do the lookup for the file's data in the PCH file. CacheTy::iterator I = Cache->find(path); @@ -793,10 +793,10 @@ public: ++NumStatMisses; return ::stat(path, buf); } - + ++NumStatHits; PCHStatData Data = *I; - + if (!Data.hasStat) return 1; @@ -843,7 +843,7 @@ PCHReader::PCHReadResult PCHReader::ReadSourceManagerBlock() { } return Success; } - + if (Code == llvm::bitc::ENTER_SUBBLOCK) { // No known subblocks, always skip them. SLocEntryCursor.ReadSubBlockID(); @@ -853,12 +853,12 @@ PCHReader::PCHReadResult PCHReader::ReadSourceManagerBlock() { } continue; } - + if (Code == llvm::bitc::DEFINE_ABBREV) { SLocEntryCursor.ReadAbbrevRecord(); continue; } - + // Read a record. const char *BlobStart; unsigned BlobLen; @@ -931,7 +931,7 @@ PCHReader::PCHReadResult PCHReader::ReadSLocEntryRecord(unsigned ID) { Error(ErrorStr.c_str()); return Failure; } - + FileID FID = SourceMgr.createFileID(File, SourceLocation::getFromRawEncoding(Record[1]), (SrcMgr::CharacteristicKind)Record[2], @@ -948,16 +948,16 @@ PCHReader::PCHReadResult PCHReader::ReadSLocEntryRecord(unsigned ID) { unsigned Offset = Record[0]; unsigned Code = SLocEntryCursor.ReadCode(); Record.clear(); - unsigned RecCode + unsigned RecCode = SLocEntryCursor.ReadRecord(Code, Record, &BlobStart, &BlobLen); assert(RecCode == pch::SM_SLOC_BUFFER_BLOB && "Ill-formed PCH file"); (void)RecCode; llvm::MemoryBuffer *Buffer - = llvm::MemoryBuffer::getMemBuffer(BlobStart, + = llvm::MemoryBuffer::getMemBuffer(BlobStart, BlobStart + BlobLen - 1, Name); FileID BufferID = SourceMgr.createFileIDForMemBuffer(Buffer, ID, Offset); - + if (strcmp(Name, "<built-in>") == 0) { PCHPredefinesBufferID = BufferID; PCHPredefines = BlobStart; @@ -968,7 +968,7 @@ PCHReader::PCHReadResult PCHReader::ReadSLocEntryRecord(unsigned ID) { } case pch::SM_SLOC_INSTANTIATION_ENTRY: { - SourceLocation SpellingLoc + SourceLocation SpellingLoc = SourceLocation::getFromRawEncoding(Record[1]); SourceMgr.createInstantiationLoc(SpellingLoc, SourceLocation::getFromRawEncoding(Record[2]), @@ -977,7 +977,7 @@ PCHReader::PCHReadResult PCHReader::ReadSLocEntryRecord(unsigned ID) { ID, Record[0]); break; - } + } } return Success; @@ -992,10 +992,10 @@ bool PCHReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, Error("malformed block record in PCH file"); return Failure; } - + while (true) { unsigned Code = Cursor.ReadCode(); - + // We expect all abbrevs to be at the start of the block. if (Code != llvm::bitc::DEFINE_ABBREV) return false; @@ -1005,7 +1005,7 @@ bool PCHReader::ReadBlockAbbrevs(llvm::BitstreamCursor &Cursor, void PCHReader::ReadMacroRecord(uint64_t Offset) { assert(PP && "Forgot to set Preprocessor ?"); - + // Keep track of where we are in the stream, then jump back there // after reading this macro. SavedStreamPosition SavedPosition(Stream); @@ -1014,7 +1014,7 @@ void PCHReader::ReadMacroRecord(uint64_t Offset) { RecordData Record; llvm::SmallVector<IdentifierInfo*, 16> MacroArgs; MacroInfo *Macro = 0; - + while (true) { unsigned Code = Stream.ReadCode(); switch (Code) { @@ -1029,7 +1029,7 @@ void PCHReader::ReadMacroRecord(uint64_t Offset) { return; } continue; - + case llvm::bitc::DEFINE_ABBREV: Stream.ReadAbbrevRecord(); continue; @@ -1056,10 +1056,10 @@ void PCHReader::ReadMacroRecord(uint64_t Offset) { } SourceLocation Loc = SourceLocation::getFromRawEncoding(Record[1]); bool isUsed = Record[2]; - + MacroInfo *MI = PP->AllocateMacroInfo(Loc); MI->setIsUsed(isUsed); - + if (RecType == pch::PP_MACRO_FUNCTION_LIKE) { // Decode function-like macro info. bool isC99VarArgs = Record[3]; @@ -1086,12 +1086,12 @@ void PCHReader::ReadMacroRecord(uint64_t Offset) { ++NumMacrosRead; break; } - + case pch::PP_TOKEN: { // If we see a TOKEN before a PP_MACRO_*, then the file is // erroneous, just pretend we didn't see this. if (Macro == 0) break; - + Token Tok; Tok.startToken(); Tok.setLocation(SourceLocation::getFromRawEncoding(Record[0])); @@ -1114,26 +1114,26 @@ void PCHReader::MaybeAddSystemRootToFilename(std::string &Filename) { // If this is not a relocatable PCH file, there's nothing to do. if (!RelocatablePCH) return; - + if (Filename.empty() || Filename[0] == '/' || Filename[0] == '<') return; std::string FIXME = Filename; - + if (isysroot == 0) { // If no system root was given, default to '/' Filename.insert(Filename.begin(), '/'); return; } - + unsigned Length = strlen(isysroot); if (isysroot[Length - 1] != '/') Filename.insert(Filename.begin(), '/'); - + Filename.insert(Filename.begin(), isysroot, isysroot + Length); } -PCHReader::PCHReadResult +PCHReader::PCHReadResult PCHReader::ReadPCHBlock() { if (Stream.EnterSubBlock(pch::PCH_BLOCK_ID)) { Error("malformed block record in PCH file"); @@ -1176,7 +1176,7 @@ PCHReader::ReadPCHBlock() { return Failure; } break; - + case pch::PREPROCESSOR_BLOCK_ID: if (Stream.SkipBlock()) { Error("malformed block record in PCH file"); @@ -1210,7 +1210,7 @@ PCHReader::ReadPCHBlock() { Record.clear(); const char *BlobStart = 0; unsigned BlobLen = 0; - switch ((pch::PCHRecordTypes)Stream.ReadRecord(Code, Record, + switch ((pch::PCHRecordTypes)Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen)) { default: // Default behavior: ignore. break; @@ -1257,10 +1257,10 @@ PCHReader::ReadPCHBlock() { case pch::IDENTIFIER_TABLE: IdentifierTableData = BlobStart; if (Record[0]) { - IdentifierLookupTable + IdentifierLookupTable = PCHIdentifierLookupTable::Create( (const unsigned char *)IdentifierTableData + Record[0], - (const unsigned char *)IdentifierTableData, + (const unsigned char *)IdentifierTableData, PCHIdentifierLookupTrait(*this)); if (PP) PP->getIdentifierTable().setExternalIdentifierLookup(this); @@ -1322,10 +1322,10 @@ PCHReader::ReadPCHBlock() { case pch::METHOD_POOL: MethodPoolLookupTableData = (const unsigned char *)BlobStart; if (Record[0]) - MethodPoolLookupTable + MethodPoolLookupTable = PCHMethodPoolLookupTable::Create( MethodPoolLookupTableData + Record[0], - MethodPoolLookupTableData, + MethodPoolLookupTableData, PCHMethodPoolLookupTrait(*this)); TotalSelectorsInMethodPool = Record[1]; break; @@ -1338,8 +1338,8 @@ PCHReader::ReadPCHBlock() { case pch::SOURCE_LOCATION_OFFSETS: SLocOffsets = (const uint32_t *)BlobStart; TotalNumSLocEntries = Record[0]; - SourceMgr.PreallocateSLocEntries(this, - TotalNumSLocEntries, + SourceMgr.PreallocateSLocEntries(this, + TotalNumSLocEntries, Record[1]); break; @@ -1370,7 +1370,7 @@ PCHReader::ReadPCHBlock() { OriginalFileName.assign(BlobStart, BlobLen); MaybeAddSystemRootToFilename(OriginalFileName); break; - + case pch::COMMENT_RANGES: Comments = (SourceRange *)BlobStart; NumComments = BlobLen / sizeof(SourceRange); @@ -1394,7 +1394,7 @@ PCHReader::PCHReadResult PCHReader::ReadPCH(const std::string &FileName) { } // Initialize the stream - StreamFile.init((const unsigned char *)Buffer->getBufferStart(), + StreamFile.init((const unsigned char *)Buffer->getBufferStart(), (const unsigned char *)Buffer->getBufferEnd()); Stream.init(StreamFile); @@ -1409,7 +1409,7 @@ PCHReader::PCHReadResult PCHReader::ReadPCH(const std::string &FileName) { while (!Stream.AtEndOfStream()) { unsigned Code = Stream.ReadCode(); - + if (Code != llvm::bitc::ENTER_SUBBLOCK) { Error("invalid record at top-level of PCH file"); return Failure; @@ -1455,13 +1455,13 @@ PCHReader::PCHReadResult PCHReader::ReadPCH(const std::string &FileName) { } break; } - } - + } + // Check the predefines buffer. - if (CheckPredefinesBuffer(PCHPredefines, PCHPredefinesLen, + if (CheckPredefinesBuffer(PCHPredefines, PCHPredefinesLen, PCHPredefinesBufferID)) return IgnorePCH; - + if (PP) { // Initialization of keywords and pragmas occurs before the // PCH file is read, so there may be some identifiers that were @@ -1480,7 +1480,7 @@ PCHReader::PCHReadResult PCHReader::ReadPCH(const std::string &FileName) { IdEnd = PP->getIdentifierTable().end(); Id != IdEnd; ++Id) Identifiers.push_back(Id->second); - PCHIdentifierLookupTable *IdTable + PCHIdentifierLookupTable *IdTable = (PCHIdentifierLookupTable *)IdentifierLookupTable; for (unsigned I = 0, N = Identifiers.size(); I != N; ++I) { IdentifierInfo *II = Identifiers[I]; @@ -1490,7 +1490,7 @@ PCHReader::PCHReadResult PCHReader::ReadPCH(const std::string &FileName) { PCHIdentifierLookupTable::iterator Pos = IdTable->find(Key, &Info); if (Pos == IdTable->end()) continue; - + // Dereferencing the iterator has the effect of populating the // IdentifierInfo node with the various declarations it needs. (void)*Pos; @@ -1510,7 +1510,7 @@ void PCHReader::InitializeContext(ASTContext &Ctx) { assert(PP && "Forgot to set Preprocessor ?"); PP->getIdentifierTable().setExternalIdentifierLookup(this); PP->getHeaderSearchInfo().SetExternalLookup(this); - + // Load the translation unit declaration ReadDeclRecord(DeclOffsets[0], 0); @@ -1528,7 +1528,7 @@ void PCHReader::InitializeContext(ASTContext &Ctx) { if (unsigned String = SpecialTypes[pch::SPECIAL_TYPE_CF_CONSTANT_STRING]) Context->setCFConstantStringType(GetType(String)); - if (unsigned FastEnum + if (unsigned FastEnum = SpecialTypes[pch::SPECIAL_TYPE_OBJC_FAST_ENUMERATION_STATE]) Context->setObjCFastEnumerationStateType(GetType(FastEnum)); if (unsigned File = SpecialTypes[pch::SPECIAL_TYPE_FILE]) { @@ -1564,10 +1564,10 @@ void PCHReader::InitializeContext(ASTContext &Ctx) { Context->setsigjmp_bufDecl(Tag->getDecl()); } } - if (unsigned ObjCIdRedef + if (unsigned ObjCIdRedef = SpecialTypes[pch::SPECIAL_TYPE_OBJC_ID_REDEFINITION]) Context->ObjCIdRedefinitionType = GetType(ObjCIdRedef); - if (unsigned ObjCClassRedef + if (unsigned ObjCClassRedef = SpecialTypes[pch::SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) Context->ObjCClassRedefinitionType = GetType(ObjCClassRedef); } @@ -1588,7 +1588,7 @@ std::string PCHReader::getOriginalSourceFile(const std::string &PCHFileName) { // Initialize the stream llvm::BitstreamReader StreamFile; llvm::BitstreamCursor Stream; - StreamFile.init((const unsigned char *)Buffer->getBufferStart(), + StreamFile.init((const unsigned char *)Buffer->getBufferStart(), (const unsigned char *)Buffer->getBufferEnd()); Stream.init(StreamFile); @@ -1597,7 +1597,7 @@ std::string PCHReader::getOriginalSourceFile(const std::string &PCHFileName) { Stream.Read(8) != 'P' || Stream.Read(8) != 'C' || Stream.Read(8) != 'H') { - fprintf(stderr, + fprintf(stderr, "error: '%s' does not appear to be a precompiled header file\n", PCHFileName.c_str()); return std::string(); @@ -1606,10 +1606,10 @@ std::string PCHReader::getOriginalSourceFile(const std::string &PCHFileName) { RecordData Record; while (!Stream.AtEndOfStream()) { unsigned Code = Stream.ReadCode(); - + if (Code == llvm::bitc::ENTER_SUBBLOCK) { unsigned BlockID = Stream.ReadSubBlockID(); - + // We only know the PCH subblock ID. switch (BlockID) { case pch::PCH_BLOCK_ID: @@ -1618,7 +1618,7 @@ std::string PCHReader::getOriginalSourceFile(const std::string &PCHFileName) { return std::string(); } break; - + default: if (Stream.SkipBlock()) { fprintf(stderr, "error: malformed block record in PCH file\n"); @@ -1645,10 +1645,10 @@ std::string PCHReader::getOriginalSourceFile(const std::string &PCHFileName) { Record.clear(); const char *BlobStart = 0; unsigned BlobLen = 0; - if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) + if (Stream.ReadRecord(Code, Record, &BlobStart, &BlobLen) == pch::ORIGINAL_FILE_NAME) return std::string(BlobStart, BlobLen); - } + } return std::string(); } @@ -1671,11 +1671,11 @@ bool PCHReader::ParseLanguageOptions( const llvm::SmallVectorImpl<uint64_t> &Record) { if (Listener) { LangOptions LangOpts; - + #define PARSE_LANGOPT(Option) \ LangOpts.Option = Record[Idx]; \ ++Idx - + unsigned Idx = 0; PARSE_LANGOPT(Trigraphs); PARSE_LANGOPT(BCPLComment); @@ -1748,18 +1748,18 @@ QualType PCHReader::ReadTypeRecord(uint64_t Offset) { // Note that we are loading a type record. LoadingTypeOrDecl Loading(*this); - + Stream.JumpToBit(Offset); RecordData Record; unsigned Code = Stream.ReadCode(); switch ((pch::TypeCode)Stream.ReadRecord(Code, Record)) { case pch::TYPE_EXT_QUAL: { - assert(Record.size() == 3 && + assert(Record.size() == 3 && "Incorrect encoding of extended qualifier type"); QualType Base = GetType(Record[0]); QualType::GCAttrTypes GCAttr = (QualType::GCAttrTypes)Record[1]; unsigned AddressSpace = Record[2]; - + QualType T = Base; if (GCAttr != QualType::GCNone) T = Context->getObjCGCQualType(T, GCAttr); @@ -1929,7 +1929,7 @@ QualType PCHReader::ReadTypeRecord(uint64_t Offset) { QualType UnderlyingType = GetType(Record[0]); return Context->getTypeOfType(UnderlyingType); } - + case pch::TYPE_DECLTYPE: return Context->getDecltypeType(ReadTypeExpr()); @@ -1974,7 +1974,7 @@ QualType PCHReader::ReadTypeRecord(uint64_t Offset) { QualType PCHReader::GetType(pch::TypeID ID) { - unsigned Quals = ID & 0x07; + unsigned Quals = ID & 0x07; unsigned Index = ID >> 3; if (Index < pch::NUM_PREDEF_TYPE_IDS) { @@ -2023,7 +2023,7 @@ QualType PCHReader::GetType(pch::TypeID ID) { //assert(Index < TypesLoaded.size() && "Type index out-of-range"); if (!TypesLoaded[Index]) TypesLoaded[Index] = ReadTypeRecord(TypeOffsets[Index]).getTypePtr(); - + return QualType(TypesLoaded[Index], Quals); } @@ -2057,7 +2057,7 @@ Stmt *PCHReader::GetDeclStmt(uint64_t Offset) { bool PCHReader::ReadDeclsLexicallyInContext(DeclContext *DC, llvm::SmallVectorImpl<pch::DeclID> &Decls) { - assert(DC->hasExternalLexicalStorage() && + assert(DC->hasExternalLexicalStorage() && "DeclContext has no lexical decls in storage"); uint64_t Offset = DeclContextOffsets[DC].first; assert(Offset && "DeclContext has no lexical decls in storage"); @@ -2084,7 +2084,7 @@ bool PCHReader::ReadDeclsLexicallyInContext(DeclContext *DC, bool PCHReader::ReadDeclsVisibleInContext(DeclContext *DC, llvm::SmallVectorImpl<VisibleDeclaration> &Decls) { - assert(DC->hasExternalVisibleStorage() && + assert(DC->hasExternalVisibleStorage() && "DeclContext has no visible decls in storage"); uint64_t Offset = DeclContextOffsets[DC].second; assert(Offset && "DeclContext has no visible decls in storage"); @@ -2102,7 +2102,7 @@ bool PCHReader::ReadDeclsVisibleInContext(DeclContext *DC, (void)RecCode; assert(RecCode == pch::DECL_CONTEXT_VISIBLE && "Expected visible block"); if (Record.size() == 0) - return false; + return false; Decls.clear(); @@ -2143,7 +2143,7 @@ void PCHReader::StartTranslationUnit(ASTConsumer *Consumer) { void PCHReader::PrintStats() { std::fprintf(stderr, "*** PCH Statistics:\n"); - unsigned NumTypesLoaded + unsigned NumTypesLoaded = TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(), (Type *)0); unsigned NumDeclsLoaded @@ -2153,7 +2153,7 @@ void PCHReader::PrintStats() { = IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(), IdentifiersLoaded.end(), (IdentifierInfo *)0); - unsigned NumSelectorsLoaded + unsigned NumSelectorsLoaded = SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(), SelectorsLoaded.end(), Selector()); @@ -2245,7 +2245,7 @@ void PCHReader::InitializeSema(Sema &S) { IdentifierInfo* PCHReader::get(const char *NameStart, const char *NameEnd) { // Try to find this name within our on-disk hash table - PCHIdentifierLookupTable *IdTable + PCHIdentifierLookupTable *IdTable = (PCHIdentifierLookupTable *)IdentifierLookupTable; std::pair<const char*, unsigned> Key(NameStart, NameEnd - NameStart); PCHIdentifierLookupTable::iterator Pos = IdTable->find(Key); @@ -2258,7 +2258,7 @@ IdentifierInfo* PCHReader::get(const char *NameStart, const char *NameEnd) { return *Pos; } -std::pair<ObjCMethodList, ObjCMethodList> +std::pair<ObjCMethodList, ObjCMethodList> PCHReader::ReadMethodPool(Selector Sel) { if (!MethodPoolLookupTable) return std::pair<ObjCMethodList, ObjCMethodList>(); @@ -2286,7 +2286,7 @@ void PCHReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) { /// identifier. /// /// If the PCH reader is currently in a state where the given declaration IDs -/// cannot safely be resolved, they are queued until it is safe to resolve +/// cannot safely be resolved, they are queued until it is safe to resolve /// them. /// /// \param II an IdentifierInfo that refers to one or more globally-visible @@ -2298,8 +2298,8 @@ void PCHReader::SetIdentifierInfo(unsigned ID, IdentifierInfo *II) { /// \param Nonrecursive should be true to indicate that the caller knows that /// this call is non-recursive, and therefore the globally-visible declarations /// will not be placed onto the pending queue. -void -PCHReader::SetGloballyVisibleDecls(IdentifierInfo *II, +void +PCHReader::SetGloballyVisibleDecls(IdentifierInfo *II, const llvm::SmallVectorImpl<uint32_t> &DeclIDs, bool Nonrecursive) { if (CurrentlyLoadingTypeOrDecl && !Nonrecursive) { @@ -2310,7 +2310,7 @@ PCHReader::SetGloballyVisibleDecls(IdentifierInfo *II, PII.DeclIDs.push_back(DeclIDs[I]); return; } - + for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) { NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I])); if (SemaObj) { @@ -2331,12 +2331,12 @@ PCHReader::SetGloballyVisibleDecls(IdentifierInfo *II, IdentifierInfo *PCHReader::DecodeIdentifierInfo(unsigned ID) { if (ID == 0) return 0; - + if (!IdentifierTableData || IdentifiersLoaded.empty()) { Error("no identifier table in PCH file"); return 0; } - + assert(PP && "Forgot to set Preprocessor ?"); if (!IdentifiersLoaded[ID - 1]) { uint32_t Offset = IdentifierOffsets[ID - 1]; @@ -2348,10 +2348,10 @@ IdentifierInfo *PCHReader::DecodeIdentifierInfo(unsigned ID) { const char *StrLenPtr = Str - 2; unsigned StrLen = (((unsigned) StrLenPtr[0]) | (((unsigned) StrLenPtr[1]) << 8)) - 1; - IdentifiersLoaded[ID - 1] + IdentifiersLoaded[ID - 1] = &PP->getIdentifierTable().get(Str, Str + StrLen); } - + return IdentifiersLoaded[ID - 1]; } @@ -2362,7 +2362,7 @@ void PCHReader::ReadSLocEntry(unsigned ID) { Selector PCHReader::DecodeSelector(unsigned ID) { if (ID == 0) return Selector(); - + if (!MethodPoolLookupTableData) return Selector(); @@ -2376,14 +2376,14 @@ Selector PCHReader::DecodeSelector(unsigned ID) { // Load this selector from the selector table. // FIXME: endianness portability issues with SelectorOffsets table PCHMethodPoolLookupTrait Trait(*this); - SelectorsLoaded[Index] + SelectorsLoaded[Index] = Trait.ReadKey(MethodPoolLookupTableData + SelectorOffsets[Index], 0); } return SelectorsLoaded[Index]; } -DeclarationName +DeclarationName PCHReader::ReadDeclarationName(const RecordData &Record, unsigned &Idx) { DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++]; switch (Kind) { @@ -2478,7 +2478,7 @@ SwitchCase *PCHReader::getSwitchCaseWithID(unsigned ID) { /// \brief Record that the given label statement has been /// deserialized and has the given ID. void PCHReader::RecordLabelStmt(LabelStmt *S, unsigned ID) { - assert(LabelStmts.find(ID) == LabelStmts.end() && + assert(LabelStmts.find(ID) == LabelStmts.end() && "Deserialized label twice"); LabelStmts[ID] = S; @@ -2493,9 +2493,9 @@ void PCHReader::RecordLabelStmt(LabelStmt *S, unsigned ID) { // If we've already seen any address-label statements that point to // this label, resolve them now. typedef std::multimap<unsigned, AddrLabelExpr *>::iterator AddrLabelIter; - std::pair<AddrLabelIter, AddrLabelIter> AddrLabels + std::pair<AddrLabelIter, AddrLabelIter> AddrLabels = UnresolvedAddrLabelExprs.equal_range(ID); - for (AddrLabelIter AddrLabel = AddrLabels.first; + for (AddrLabelIter AddrLabel = AddrLabels.first; AddrLabel != AddrLabels.second; ++AddrLabel) AddrLabel->second->setLabel(S); UnresolvedAddrLabelExprs.erase(AddrLabels.first, AddrLabels.second); @@ -2542,7 +2542,7 @@ void PCHReader::SetLabelOf(AddrLabelExpr *S, unsigned ID) { } -PCHReader::LoadingTypeOrDecl::LoadingTypeOrDecl(PCHReader &Reader) +PCHReader::LoadingTypeOrDecl::LoadingTypeOrDecl(PCHReader &Reader) : Reader(Reader), Parent(Reader.CurrentlyLoadingTypeOrDecl) { Reader.CurrentlyLoadingTypeOrDecl = this; } @@ -2559,5 +2559,5 @@ PCHReader::LoadingTypeOrDecl::~LoadingTypeOrDecl() { } } - Reader.CurrentlyLoadingTypeOrDecl = Parent; + Reader.CurrentlyLoadingTypeOrDecl = Parent; } diff --git a/clang/lib/Frontend/PCHReaderDecl.cpp b/clang/lib/Frontend/PCHReaderDecl.cpp index cc8712acd09..03ac3aad229 100644 --- a/clang/lib/Frontend/PCHReaderDecl.cpp +++ b/clang/lib/Frontend/PCHReaderDecl.cpp @@ -94,7 +94,7 @@ void PCHDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) { void PCHDeclReader::VisitNamedDecl(NamedDecl *ND) { VisitDecl(ND); - ND->setDeclName(Reader.ReadDeclarationName(Record, Idx)); + ND->setDeclName(Reader.ReadDeclarationName(Record, Idx)); } void PCHDeclReader::VisitTypeDecl(TypeDecl *TD) { @@ -163,9 +163,9 @@ public: #define ABSTRACT_TYPELOC(CLASS) #define TYPELOC(CLASS, PARENT, TYPE) \ - void Visit##CLASS(CLASS TyLoc); + void Visit##CLASS(CLASS TyLoc); #include "clang/AST/TypeLocNodes.def" - + void VisitTypeLoc(TypeLoc TyLoc) { assert(0 && "A type loc wrapper was not handled!"); } @@ -447,10 +447,10 @@ void PCHDeclReader::VisitBlockDecl(BlockDecl *BD) { Params.reserve(NumParams); for (unsigned I = 0; I != NumParams; ++I) Params.push_back(cast<ParmVarDecl>(Reader.GetDecl(Record[Idx++]))); - BD->setParams(*Reader.getContext(), Params.data(), NumParams); + BD->setParams(*Reader.getContext(), Params.data(), NumParams); } -std::pair<uint64_t, uint64_t> +std::pair<uint64_t, uint64_t> PCHDeclReader::VisitDeclContext(DeclContext *DC) { uint64_t LexicalOffset = Record[Idx++]; uint64_t VisibleOffset = Record[Idx++]; @@ -464,13 +464,13 @@ PCHDeclReader::VisitDeclContext(DeclContext *DC) { /// \brief Reads attributes from the current stream position. Attr *PCHReader::ReadAttributes() { unsigned Code = DeclsCursor.ReadCode(); - assert(Code == llvm::bitc::UNABBREV_RECORD && + assert(Code == llvm::bitc::UNABBREV_RECORD && "Expected unabbreviated record"); (void)Code; - + RecordData Record; unsigned Idx = 0; unsigned RecCode = DeclsCursor.ReadRecord(Code, Record); - assert(RecCode == pch::DECL_ATTR && "Expected attribute record"); + assert(RecCode == pch::DECL_ATTR && "Expected attribute record"); (void)RecCode; #define SIMPLE_ATTR(Name) \ @@ -501,12 +501,12 @@ Attr *PCHReader::ReadAttributes() { SIMPLE_ATTR(AnalyzerNoReturn); STRING_ATTR(Annotate); STRING_ATTR(AsmLabel); - + case Attr::Blocks: New = ::new (*Context) BlocksAttr( (BlocksAttr::BlocksAttrTypes)Record[Idx++]); break; - + case Attr::Cleanup: New = ::new (*Context) CleanupAttr( cast<FunctionDecl>(GetDecl(Record[Idx++]))); @@ -519,7 +519,7 @@ Attr *PCHReader::ReadAttributes() { SIMPLE_ATTR(Deprecated); UNSIGNED_ATTR(Destructor); SIMPLE_ATTR(FastCall); - + case Attr::Format: { std::string Type = ReadString(Record, Idx); unsigned FormatIdx = Record[Idx++]; @@ -527,13 +527,13 @@ Attr *PCHReader::ReadAttributes() { New = ::new (*Context) FormatAttr(Type, FormatIdx, FirstArg); break; } - + case Attr::FormatArg: { unsigned FormatIdx = Record[Idx++]; New = ::new (*Context) FormatArgAttr(FormatIdx); break; } - + case Attr::Sentinel: { int sentinel = Record[Idx++]; int nullPos = Record[Idx++]; @@ -542,7 +542,7 @@ Attr *PCHReader::ReadAttributes() { } SIMPLE_ATTR(GNUInline); - + case Attr::IBOutletKind: New = ::new (*Context) IBOutletAttr(); break; @@ -552,7 +552,7 @@ Attr *PCHReader::ReadAttributes() { SIMPLE_ATTR(NoInline); SIMPLE_ATTR(NoReturn); SIMPLE_ATTR(NoThrow); - + case Attr::NonNull: { unsigned Size = Record[Idx++]; llvm::SmallVector<unsigned, 16> ArgNums; @@ -561,7 +561,7 @@ Attr *PCHReader::ReadAttributes() { New = ::new (*Context) NonNullAttr(ArgNums.data(), Size); break; } - + case Attr::ReqdWorkGroupSize: { unsigned X = Record[Idx++]; unsigned Y = Record[Idx++]; @@ -585,7 +585,7 @@ Attr *PCHReader::ReadAttributes() { SIMPLE_ATTR(Unavailable); SIMPLE_ATTR(Unused); SIMPLE_ATTR(Used); - + case Attr::Visibility: New = ::new (*Context) VisibilityAttr( (VisibilityAttr::VisibilityTypes)Record[Idx++]); @@ -624,7 +624,7 @@ Attr *PCHReader::ReadAttributes() { /// \brief Note that we have loaded the declaration with the given /// Index. -/// +/// /// This routine notes that this declaration has already been loaded, /// so that future GetDecl calls will return this declaration rather /// than trying to load a new declaration. @@ -656,7 +656,7 @@ Decl *PCHReader::ReadDeclRecord(uint64_t Offset, unsigned Index) { // Note that we are loading a declaration record. LoadingTypeOrDecl Loading(*this); - + DeclsCursor.JumpToBit(Offset); RecordData Record; unsigned Code = DeclsCursor.ReadCode(); @@ -689,11 +689,11 @@ Decl *PCHReader::ReadDeclRecord(uint64_t Offset, unsigned Index) { 0, llvm::APSInt()); break; case pch::DECL_FUNCTION: - D = FunctionDecl::Create(*Context, 0, SourceLocation(), DeclarationName(), + D = FunctionDecl::Create(*Context, 0, SourceLocation(), DeclarationName(), QualType(), 0); break; case pch::DECL_OBJC_METHOD: - D = ObjCMethodDecl::Create(*Context, SourceLocation(), SourceLocation(), + D = ObjCMethodDecl::Create(*Context, SourceLocation(), SourceLocation(), Selector(), QualType(), 0); break; case pch::DECL_OBJC_INTERFACE: @@ -707,7 +707,7 @@ Decl *PCHReader::ReadDeclRecord(uint64_t Offset, unsigned Index) { D = ObjCProtocolDecl::Create(*Context, 0, SourceLocation(), 0); break; case pch::DECL_OBJC_AT_DEFS_FIELD: - D = ObjCAtDefsFieldDecl::Create(*Context, 0, SourceLocation(), 0, + D = ObjCAtDefsFieldDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0); break; case pch::DECL_OBJC_CLASS: @@ -733,11 +733,11 @@ Decl *PCHReader::ReadDeclRecord(uint64_t Offset, unsigned Index) { break; case pch::DECL_OBJC_PROPERTY_IMPL: D = ObjCPropertyImplDecl::Create(*Context, 0, SourceLocation(), - SourceLocation(), 0, + SourceLocation(), 0, ObjCPropertyImplDecl::Dynamic, 0); break; case pch::DECL_FIELD: - D = FieldDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0, 0, + D = FieldDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0, 0, false); break; case pch::DECL_VAR: @@ -750,7 +750,7 @@ Decl *PCHReader::ReadDeclRecord(uint64_t Offset, unsigned Index) { break; case pch::DECL_PARM_VAR: - D = ParmVarDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0, + D = ParmVarDecl::Create(*Context, 0, SourceLocation(), 0, QualType(), 0, VarDecl::None, 0); break; case pch::DECL_ORIGINAL_PARM_VAR: diff --git a/clang/lib/Frontend/PCHReaderStmt.cpp b/clang/lib/Frontend/PCHReaderStmt.cpp index dfcc794a5dc..45e2bfb1794 100644 --- a/clang/lib/Frontend/PCHReaderStmt.cpp +++ b/clang/lib/Frontend/PCHReaderStmt.cpp @@ -106,7 +106,7 @@ namespace { unsigned VisitObjCMessageExpr(ObjCMessageExpr *E); unsigned VisitObjCSuperExpr(ObjCSuperExpr *E); unsigned VisitObjCIsaExpr(ObjCIsaExpr *E); - + unsigned VisitObjCForCollectionStmt(ObjCForCollectionStmt *); unsigned VisitObjCAtCatchStmt(ObjCAtCatchStmt *); unsigned VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *); @@ -132,7 +132,7 @@ unsigned PCHStmtReader::VisitNullStmt(NullStmt *S) { unsigned PCHStmtReader::VisitCompoundStmt(CompoundStmt *S) { VisitStmt(S); unsigned NumStmts = Record[Idx++]; - S->setStmts(*Reader.getContext(), + S->setStmts(*Reader.getContext(), StmtStack.data() + StmtStack.size() - NumStmts, NumStmts); S->setLBracLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setRBracLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); @@ -195,7 +195,7 @@ unsigned PCHStmtReader::VisitSwitchStmt(SwitchStmt *S) { PrevSC->setNextSwitchCase(SC); else S->setSwitchCaseList(SC); - + // Retain this SwitchCase, since SwitchStmt::addSwitchCase() would // normally retain it (but we aren't calling addSwitchCase). SC->Retain(); @@ -298,8 +298,8 @@ unsigned PCHStmtReader::VisitAsmStmt(AsmStmt *S) { S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); S->setVolatile(Record[Idx++]); S->setSimple(Record[Idx++]); - - unsigned StackIdx + + unsigned StackIdx = StmtStack.size() - (NumOutputs*2 + NumInputs*2 + NumClobbers + 1); S->setAsmString(cast_or_null<StringLiteral>(StmtStack[StackIdx++])); @@ -372,12 +372,12 @@ unsigned PCHStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) { unsigned PCHStmtReader::VisitStringLiteral(StringLiteral *E) { VisitExpr(E); unsigned Len = Record[Idx++]; - assert(Record[Idx] == E->getNumConcatenated() && + assert(Record[Idx] == E->getNumConcatenated() && "Wrong number of concatenated tokens!"); ++Idx; E->setWide(Record[Idx++]); - // Read string data + // Read string data llvm::SmallVector<char, 16> Str(&Record[Idx], &Record[Idx] + Len); E->setStrData(*Reader.getContext(), Str.data(), Len); Idx += Len; @@ -536,7 +536,7 @@ unsigned PCHStmtReader::VisitInitListExpr(InitListExpr *E) { unsigned NumInits = Record[Idx++]; E->reserveInits(NumInits); for (unsigned I = 0; I != NumInits; ++I) - E->updateInit(I, + E->updateInit(I, cast<Expr>(StmtStack[StmtStack.size() - NumInits - 1 + I])); E->setSyntacticForm(cast_or_null<InitListExpr>(StmtStack.back())); E->setLBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); @@ -563,11 +563,11 @@ unsigned PCHStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { switch ((pch::DesignatorTypes)Record[Idx++]) { case pch::DESIG_FIELD_DECL: { FieldDecl *Field = cast<FieldDecl>(Reader.GetDecl(Record[Idx++])); - SourceLocation DotLoc + SourceLocation DotLoc = SourceLocation::getFromRawEncoding(Record[Idx++]); - SourceLocation FieldLoc + SourceLocation FieldLoc = SourceLocation::getFromRawEncoding(Record[Idx++]); - Designators.push_back(Designator(Field->getIdentifier(), DotLoc, + Designators.push_back(Designator(Field->getIdentifier(), DotLoc, FieldLoc)); Designators.back().setField(Field); break; @@ -575,14 +575,14 @@ unsigned PCHStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) { case pch::DESIG_FIELD_NAME: { const IdentifierInfo *Name = Reader.GetIdentifierInfo(Record, Idx); - SourceLocation DotLoc + SourceLocation DotLoc = SourceLocation::getFromRawEncoding(Record[Idx++]); - SourceLocation FieldLoc + SourceLocation FieldLoc = SourceLocation::getFromRawEncoding(Record[Idx++]); Designators.push_back(Designator(Name, DotLoc, FieldLoc)); break; } - + case pch::DESIG_ARRAY: { unsigned Index = Record[Idx++]; SourceLocation LBracketLoc @@ -669,7 +669,7 @@ unsigned PCHStmtReader::VisitGNUNullExpr(GNUNullExpr *E) { unsigned PCHStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { VisitExpr(E); unsigned NumExprs = Record[Idx++]; - E->setExprs(*Reader.getContext(), + E->setExprs(*Reader.getContext(), (Expr **)&StmtStack[StmtStack.size() - NumExprs], NumExprs); E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); @@ -766,7 +766,7 @@ unsigned PCHStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) { E->setRightLoc(SourceLocation::getFromRawEncoding(Record[Idx++])); E->setSelector(Reader.GetSelector(Record, Idx)); E->setMethodDecl(cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++]))); - + E->setReceiver( cast_or_null<Expr>(StmtStack[StmtStack.size() - E->getNumArgs() - 1])); if (!E->getReceiver()) { @@ -896,8 +896,8 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { Finished = true; break; - case pch::STMT_NULL_PTR: - S = 0; + case pch::STMT_NULL_PTR: + S = 0; break; case pch::STMT_NULL: @@ -935,7 +935,7 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { case pch::STMT_DO: S = new (Context) DoStmt(Empty); break; - + case pch::STMT_FOR: S = new (Context) ForStmt(Empty); break; @@ -943,7 +943,7 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { case pch::STMT_GOTO: S = new (Context) GotoStmt(Empty); break; - + case pch::STMT_INDIRECT_GOTO: S = new (Context) IndirectGotoStmt(Empty); break; @@ -971,25 +971,25 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { case pch::EXPR_PREDEFINED: S = new (Context) PredefinedExpr(Empty); break; - - case pch::EXPR_DECL_REF: - S = new (Context) DeclRefExpr(Empty); + + case pch::EXPR_DECL_REF: + S = new (Context) DeclRefExpr(Empty); break; - - case pch::EXPR_INTEGER_LITERAL: + + case pch::EXPR_INTEGER_LITERAL: S = new (Context) IntegerLiteral(Empty); break; - + case pch::EXPR_FLOATING_LITERAL: S = new (Context) FloatingLiteral(Empty); break; - + case pch::EXPR_IMAGINARY_LITERAL: S = new (Context) ImaginaryLiteral(Empty); break; case pch::EXPR_STRING_LITERAL: - S = StringLiteral::CreateEmpty(*Context, + S = StringLiteral::CreateEmpty(*Context, Record[PCHStmtReader::NumExprFields + 1]); break; @@ -1056,7 +1056,7 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { case pch::EXPR_DESIGNATED_INIT: S = DesignatedInitExpr::CreateEmpty(*Context, Record[PCHStmtReader::NumExprFields] - 1); - + break; case pch::EXPR_IMPLICIT_VALUE_INIT: @@ -1090,7 +1090,7 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { case pch::EXPR_SHUFFLE_VECTOR: S = new (Context) ShuffleVectorExpr(Empty); break; - + case pch::EXPR_BLOCK: S = new (Context) BlockExpr(Empty); break; @@ -1098,7 +1098,7 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { case pch::EXPR_BLOCK_DECL_REF: S = new (Context) BlockDeclRefExpr(Empty); break; - + case pch::EXPR_OBJC_STRING_LITERAL: S = new (Context) ObjCStringLiteral(Empty); break; @@ -1147,7 +1147,7 @@ Stmt *PCHReader::ReadStmt(llvm::BitstreamCursor &Cursor) { case pch::STMT_OBJC_AT_THROW: S = new (Context) ObjCAtThrowStmt(Empty); break; - + case pch::EXPR_CXX_OPERATOR_CALL: S = new (Context) CXXOperatorCallExpr(*Context, Empty); break; diff --git a/clang/lib/Frontend/PCHWriter.cpp b/clang/lib/Frontend/PCHWriter.cpp index 86a52fcf52c..a6918e4c850 100644 --- a/clang/lib/Frontend/PCHWriter.cpp +++ b/clang/lib/Frontend/PCHWriter.cpp @@ -13,7 +13,7 @@ #include "clang/Frontend/PCHWriter.h" #include "../Sema/Sema.h" // FIXME: move header into include/clang/Sema -#include "../Sema/IdentifierResolver.h" // FIXME: move header +#include "../Sema/IdentifierResolver.h" // FIXME: move header #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/AST/DeclContextInternals.h" @@ -50,7 +50,7 @@ namespace { /// \brief Type code that corresponds to the record generated. pch::TypeCode Code; - PCHTypeWriter(PCHWriter &Writer, PCHWriter::RecordData &Record) + PCHTypeWriter(PCHWriter &Writer, PCHWriter::RecordData &Record) : Writer(Writer), Record(Record), Code(pch::TYPE_EXT_QUAL) { } void VisitArrayType(const ArrayType *T); @@ -92,7 +92,7 @@ void PCHTypeWriter::VisitPointerType(const PointerType *T) { } void PCHTypeWriter::VisitBlockPointerType(const BlockPointerType *T) { - Writer.AddTypeRef(T->getPointeeType(), Record); + Writer.AddTypeRef(T->getPointeeType(), Record); Code = pch::TYPE_BLOCK_POINTER; } @@ -107,8 +107,8 @@ void PCHTypeWriter::VisitRValueReferenceType(const RValueReferenceType *T) { } void PCHTypeWriter::VisitMemberPointerType(const MemberPointerType *T) { - Writer.AddTypeRef(T->getPointeeType(), Record); - Writer.AddTypeRef(QualType(T->getClass(), 0), Record); + Writer.AddTypeRef(T->getPointeeType(), Record); + Writer.AddTypeRef(QualType(T->getClass(), 0), Record); Code = pch::TYPE_MEMBER_POINTER; } @@ -211,7 +211,7 @@ void PCHTypeWriter::VisitDecltypeType(const DecltypeType *T) { void PCHTypeWriter::VisitTagType(const TagType *T) { Writer.AddDeclRef(T->getDecl(), Record); - assert(!T->isBeingDefined() && + assert(!T->isBeingDefined() && "Cannot serialize in the middle of a type definition"); } @@ -231,7 +231,7 @@ void PCHTypeWriter::VisitElaboratedType(const ElaboratedType *T) { Code = pch::TYPE_ELABORATED; } -void +void PCHTypeWriter::VisitTemplateSpecializationType( const TemplateSpecializationType *T) { // FIXME: Serialize this type (C++ only) @@ -254,7 +254,7 @@ void PCHTypeWriter::VisitObjCInterfaceType(const ObjCInterfaceType *T) { void PCHTypeWriter::VisitObjCObjectPointerType(const ObjCObjectPointerType *T) { - Writer.AddTypeRef(T->getPointeeType(), Record); + Writer.AddTypeRef(T->getPointeeType(), Record); Record.push_back(T->getNumProtocols()); for (ObjCInterfaceType::qual_iterator I = T->qual_begin(), E = T->qual_end(); I != E; ++I) @@ -362,14 +362,14 @@ static void AddStmtsExprs(llvm::BitstreamWriter &Stream, RECORD(STMT_OBJC_AT_THROW); #undef RECORD } - + void PCHWriter::WriteBlockInfoBlock() { RecordData Record; Stream.EnterSubblock(llvm::bitc::BLOCKINFO_BLOCK_ID, 3); - + #define BLOCK(X) EmitBlockID(pch::X ## _ID, #X, Stream, Record) #define RECORD(X) EmitRecordID(pch::X, #X, Stream, Record) - + // PCH Top-Level Block. BLOCK(PCH_BLOCK); RECORD(ORIGINAL_FILE_NAME); @@ -392,7 +392,7 @@ void PCHWriter::WriteBlockInfoBlock() { RECORD(STAT_CACHE); RECORD(EXT_VECTOR_DECLS); RECORD(COMMENT_RANGES); - + // SourceManager Block. BLOCK(SOURCE_MANAGER_BLOCK); RECORD(SM_SLOC_FILE_ENTRY); @@ -401,7 +401,7 @@ void PCHWriter::WriteBlockInfoBlock() { RECORD(SM_SLOC_INSTANTIATION_ENTRY); RECORD(SM_LINE_TABLE); RECORD(SM_HEADER_FILE_INFO); - + // Preprocessor Block. BLOCK(PREPROCESSOR_BLOCK); RECORD(PP_MACRO_OBJECT_LIKE); @@ -475,7 +475,7 @@ void PCHWriter::WriteBlockInfoBlock() { /// \brief Adjusts the given filename to only write out the portion of the /// filename that is not part of the system root directory. -/// +/// /// \param Filename the file name to adjust. /// /// \param isysroot When non-NULL, the PCH file is a relocatable PCH file and @@ -483,29 +483,29 @@ void PCHWriter::WriteBlockInfoBlock() { /// /// \returns either the original filename (if it needs no adjustment) or the /// adjusted filename (which points into the @p Filename parameter). -static const char * +static const char * adjustFilenameForRelocatablePCH(const char *Filename, const char *isysroot) { assert(Filename && "No file name to adjust?"); - + if (!isysroot) return Filename; - + // Verify that the filename and the system root have the same prefix. unsigned Pos = 0; for (; Filename[Pos] && isysroot[Pos]; ++Pos) if (Filename[Pos] != isysroot[Pos]) return Filename; // Prefixes don't match. - + // We hit the end of the filename before we hit the end of the system root. if (!Filename[Pos]) return Filename; - + // If the file name has a '/' at the current position, skip over the '/'. // We distinguish sysroot-based includes from absolute includes by the // absence of '/' at the beginning of sysroot-based includes. if (Filename[Pos] == '/') ++Pos; - + return Filename + Pos; } @@ -524,7 +524,7 @@ void PCHWriter::WriteMetadata(ASTContext &Context, const char *isysroot) { MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Relocatable MetaAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // Target triple unsigned MetaAbbrevCode = Stream.EmitAbbrev(MetaAbbrev); - + RecordData Record; Record.push_back(pch::METADATA); Record.push_back(pch::VERSION_MAJOR); @@ -534,7 +534,7 @@ void PCHWriter::WriteMetadata(ASTContext &Context, const char *isysroot) { Record.push_back(isysroot != 0); const std::string &TripleStr = Target.getTriple().getTriple(); Stream.EmitRecordWithBlob(MetaAbbrevCode, Record, TripleStr); - + // Original file name SourceManager &SM = Context.getSourceManager(); if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) { @@ -545,7 +545,7 @@ void PCHWriter::WriteMetadata(ASTContext &Context, const char *isysroot) { llvm::sys::Path MainFilePath(MainFile->getName()); std::string MainFileName; - + if (!MainFilePath.isAbsolute()) { llvm::sys::Path P = llvm::sys::Path::GetCurrentDirectory(); P.appendComponent(MainFilePath.str()); @@ -555,7 +555,7 @@ void PCHWriter::WriteMetadata(ASTContext &Context, const char *isysroot) { } const char *MainFileNameStr = MainFileName.c_str(); - MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr, + MainFileNameStr = adjustFilenameForRelocatablePCH(MainFileNameStr, isysroot); RecordData Record; Record.push_back(pch::ORIGINAL_FILE_NAME); @@ -579,11 +579,11 @@ void PCHWriter::WriteLanguageOptions(const LangOptions &LangOpts) { Record.push_back(LangOpts.CPlusPlus); // C++ Support Record.push_back(LangOpts.CPlusPlus0x); // C++0x Support Record.push_back(LangOpts.CXXOperatorNames); // Treat C++ operator names as keywords. - + Record.push_back(LangOpts.ObjC1); // Objective-C 1 support enabled. Record.push_back(LangOpts.ObjC2); // Objective-C 2 support enabled. Record.push_back(LangOpts.ObjCNonFragileABI); // Objective-C modern abi enabled - + Record.push_back(LangOpts.PascalStrings); // Allow Pascal strings Record.push_back(LangOpts.WritableStrings); // Allow writable strings Record.push_back(LangOpts.LaxVectorConversions); @@ -610,7 +610,7 @@ void PCHWriter::WriteLanguageOptions(const LangOptions &LangOpts) { // may be ripped out at any time. Record.push_back(LangOpts.Optimize); // Whether __OPTIMIZE__ should be defined. - Record.push_back(LangOpts.OptimizeSize); // Whether __OPTIMIZE_SIZE__ should be + Record.push_back(LangOpts.OptimizeSize); // Whether __OPTIMIZE_SIZE__ should be // defined. Record.push_back(LangOpts.Static); // Should __STATIC__ be defined (as // opposed to __DYNAMIC__). @@ -641,15 +641,15 @@ class VISIBILITY_HIDDEN PCHStatCacheTrait { public: typedef const char * key_type; typedef key_type key_type_ref; - + typedef std::pair<int, struct stat> data_type; typedef const data_type& data_type_ref; static unsigned ComputeHash(const char *path) { return BernsteinHash(path); } - - std::pair<unsigned,unsigned> + + std::pair<unsigned,unsigned> EmitKeyDataLength(llvm::raw_ostream& Out, const char *path, data_type_ref Data) { unsigned StrLen = strlen(path); @@ -660,19 +660,19 @@ public: clang::io::Emit8(Out, DataLen); return std::make_pair(StrLen + 1, DataLen); } - + void EmitKey(llvm::raw_ostream& Out, const char *path, unsigned KeyLen) { Out.write(path, KeyLen); } - + void EmitData(llvm::raw_ostream& Out, key_type_ref, data_type_ref Data, unsigned DataLen) { using namespace clang::io; uint64_t Start = Out.tell(); (void)Start; - + // Result of stat() Emit8(Out, Data.first? 1 : 0); - + if (Data.first == 0) { Emit32(Out, (uint32_t) Data.second.st_ino); Emit32(Out, (uint32_t) Data.second.st_dev); @@ -693,16 +693,16 @@ void PCHWriter::WriteStatCache(MemorizeStatCalls &StatCalls, // stat() call. OnDiskChainedHashTableGenerator<PCHStatCacheTrait> Generator; unsigned NumStatEntries = 0; - for (MemorizeStatCalls::iterator Stat = StatCalls.begin(), + for (MemorizeStatCalls::iterator Stat = StatCalls.begin(), StatEnd = StatCalls.end(); Stat != StatEnd; ++Stat, ++NumStatEntries) { const char *Filename = Stat->first(); Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); Generator.insert(Filename, Stat->second); } - + // Create the on-disk hash table in a buffer. - llvm::SmallString<4096> StatCacheData; + llvm::SmallString<4096> StatCacheData; uint32_t BucketOffset; { llvm::raw_svector_ostream Out(StatCacheData); @@ -821,16 +821,16 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, if (FilenameLen) Record.insert(Record.end(), Filename, Filename + FilenameLen); } - + // Emit the line entries for (LineTableInfo::iterator L = LineTable.begin(), LEnd = LineTable.end(); L != LEnd; ++L) { // Emit the file ID Record.push_back(L->first); - + // Emit the line entries Record.push_back(L->second.size()); - for (std::vector<LineEntry>::iterator LE = L->second.begin(), + for (std::vector<LineEntry>::iterator LE = L->second.begin(), LEEnd = L->second.end(); LE != LEEnd; ++LE) { Record.push_back(LE->FileOffset); @@ -844,9 +844,9 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, } // Write out entries for all of the header files we know about. - HeaderSearch &HS = PP.getHeaderSearchInfo(); + HeaderSearch &HS = PP.getHeaderSearchInfo(); Record.clear(); - for (HeaderSearch::header_file_iterator I = HS.header_file_begin(), + for (HeaderSearch::header_file_iterator I = HS.header_file_begin(), E = HS.header_file_end(); I != E; ++I) { Record.push_back(I->isImport); @@ -862,7 +862,7 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, std::vector<uint32_t> SLocEntryOffsets; RecordData PreloadSLocs; SLocEntryOffsets.reserve(SourceMgr.sloc_entry_size() - 1); - for (SourceManager::sloc_entry_iterator + for (SourceManager::sloc_entry_iterator SLoc = SourceMgr.sloc_entry_begin() + 1, SLocEnd = SourceMgr.sloc_entry_end(); SLoc != SLocEnd; ++SLoc) { @@ -892,7 +892,7 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, if (Content->Entry) { // The source location entry is a file. The blob associated // with this entry is the file name. - + // Turn the file name into an absolute path, if it isn't already. const char *Filename = Content->Entry->getName(); llvm::sys::Path FilePath(Filename, strlen(Filename)); @@ -903,7 +903,7 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, FilenameStr = P.str(); Filename = FilenameStr.c_str(); } - + Filename = adjustFilenameForRelocatablePCH(Filename, isysroot); Stream.EmitRecordWithBlob(SLocFileAbbrv, Record, Filename); @@ -962,13 +962,13 @@ void PCHWriter::WriteSourceManagerBlock(SourceManager &SourceMgr, Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 16)); // next offset Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); // offsets unsigned SLocOffsetsAbbrev = Stream.EmitAbbrev(Abbrev); - + Record.clear(); Record.push_back(pch::SOURCE_LOCATION_OFFSETS); Record.push_back(SLocEntryOffsets.size()); Record.push_back(SourceMgr.getNextOffset()); Stream.EmitRecordWithBlob(SLocOffsetsAbbrev, Record, - (const char *)&SLocEntryOffsets.front(), + (const char *)&SLocEntryOffsets.front(), SLocEntryOffsets.size()*sizeof(SLocEntryOffsets[0])); // Write the source location entry preloads array, telling the PCH @@ -995,12 +995,12 @@ void PCHWriter::WritePreprocessor(const Preprocessor &PP) { // Enter the preprocessor block. Stream.EnterSubblock(pch::PREPROCESSOR_BLOCK_ID, 2); - + // If the PCH file contains __DATE__ or __TIME__ emit a warning about this. // FIXME: use diagnostics subsystem for localization etc. if (PP.SawDateOrTime()) fprintf(stderr, "warning: precompiled header used __DATE__ or __TIME__.\n"); - + // Loop over all the macro definitions that are live at the end of the file, // emitting each to the PP section. for (Preprocessor::macro_iterator I = PP.macro_begin(), E = PP.macro_end(); @@ -1019,13 +1019,13 @@ void PCHWriter::WritePreprocessor(const Preprocessor &PP) { MacroOffsets[I->first] = Stream.GetCurrentBitNo(); Record.push_back(MI->getDefinitionLoc().getRawEncoding()); Record.push_back(MI->isUsed()); - + unsigned Code; if (MI->isObjectLike()) { Code = pch::PP_MACRO_OBJECT_LIKE; } else { Code = pch::PP_MACRO_FUNCTION_LIKE; - + Record.push_back(MI->isC99Varargs()); Record.push_back(MI->isGNUVarargs()); Record.push_back(MI->getNumArgs()); @@ -1042,19 +1042,19 @@ void PCHWriter::WritePreprocessor(const Preprocessor &PP) { // tokens in it because they are created by the parser, and thus can't be // in a macro definition. const Token &Tok = MI->getReplacementToken(TokNo); - + Record.push_back(Tok.getLocation().getRawEncoding()); Record.push_back(Tok.getLength()); // FIXME: When reading literal tokens, reconstruct the literal pointer if // it is needed. AddIdentifierRef(Tok.getIdentifierInfo(), Record); - + // FIXME: Should translate token kind to a stable encoding. Record.push_back(Tok.getKind()); // FIXME: Should translate token flags to a stable encoding. Record.push_back(Tok.getFlags()); - + Stream.EmitRecord(pch::PP_TOKEN, Record); Record.clear(); } @@ -1065,18 +1065,18 @@ void PCHWriter::WritePreprocessor(const Preprocessor &PP) { void PCHWriter::WriteComments(ASTContext &Context) { using namespace llvm; - + if (Context.Comments.empty()) return; - + BitCodeAbbrev *CommentAbbrev = new BitCodeAbbrev(); CommentAbbrev->Add(BitCodeAbbrevOp(pch::COMMENT_RANGES)); CommentAbbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob)); unsigned CommentCode = Stream.EmitAbbrev(CommentAbbrev); - + RecordData Record; Record.push_back(pch::COMMENT_RANGES); - Stream.EmitRecordWithBlob(CommentCode, Record, + Stream.EmitRecordWithBlob(CommentCode, Record, (const char*)&Context.Comments[0], Context.Comments.size() * sizeof(SourceRange)); } @@ -1090,7 +1090,7 @@ void PCHWriter::WriteType(const Type *T) { pch::TypeID &ID = TypeIDs[T]; if (ID == 0) // we haven't seen this type before. ID = NextTypeID++; - + // Record the offset for this type. if (TypeOffsets.size() == ID - pch::NUM_PREDEF_TYPE_IDS) TypeOffsets.push_back(Stream.GetCurrentBitNo()); @@ -1100,7 +1100,7 @@ void PCHWriter::WriteType(const Type *T) { } RecordData Record; - + // Emit the type's representation. PCHTypeWriter W(*this, Record); switch (T->getTypeClass()) { @@ -1154,7 +1154,7 @@ void PCHWriter::WriteTypesBlock(ASTContext &Context) { /// /// \returns the offset of the DECL_CONTEXT_LEXICAL block within the /// bistream, or 0 if no block was written. -uint64_t PCHWriter::WriteDeclContextLexicalBlock(ASTContext &Context, +uint64_t PCHWriter::WriteDeclContextLexicalBlock(ASTContext &Context, DeclContext *DC) { if (DC->decls_empty()) return 0; @@ -1206,7 +1206,7 @@ uint64_t PCHWriter::WriteDeclContextVisibleBlock(ASTContext &Context, AddDeclarationName(D->first, Record); DeclContext::lookup_result Result = D->second.getLookupResult(Context); Record.push_back(Result.second - Result.first); - for(; Result.first != Result.second; ++Result.first) + for (; Result.first != Result.second; ++Result.first) AddDeclRef(*Result.first, Record); } @@ -1230,12 +1230,12 @@ class VISIBILITY_HIDDEN PCHMethodPoolTrait { public: typedef Selector key_type; typedef key_type key_type_ref; - + typedef std::pair<ObjCMethodList, ObjCMethodList> data_type; typedef const data_type& data_type_ref; explicit PCHMethodPoolTrait(PCHWriter &Writer) : Writer(Writer) { } - + static unsigned ComputeHash(Selector Sel) { unsigned N = Sel.getNumArgs(); if (N == 0) @@ -1246,27 +1246,27 @@ public: R = clang::BernsteinHashPartial(II->getName(), II->getLength(), R); return R; } - - std::pair<unsigned,unsigned> + + std::pair<unsigned,unsigned> EmitKeyDataLength(llvm::raw_ostream& Out, Selector Sel, data_type_ref Methods) { unsigned KeyLen = 2 + (Sel.getNumArgs()? Sel.getNumArgs() * 4 : 4); clang::io::Emit16(Out, KeyLen); unsigned DataLen = 2 + 2; // 2 bytes for each of the method counts - for (const ObjCMethodList *Method = &Methods.first; Method; + for (const ObjCMethodList *Method = &Methods.first; Method; Method = Method->Next) if (Method->Method) DataLen += 4; - for (const ObjCMethodList *Method = &Methods.second; Method; + for (const ObjCMethodList *Method = &Methods.second; Method; Method = Method->Next) if (Method->Method) DataLen += 4; clang::io::Emit16(Out, DataLen); return std::make_pair(KeyLen, DataLen); } - + void EmitKey(llvm::raw_ostream& Out, Selector Sel, unsigned) { - uint64_t Start = Out.tell(); + uint64_t Start = Out.tell(); assert((Start >> 32) == 0 && "Selector key offset too large"); Writer.SetSelectorOffset(Sel, Start); unsigned N = Sel.getNumArgs(); @@ -1274,32 +1274,32 @@ public: if (N == 0) N = 1; for (unsigned I = 0; I != N; ++I) - clang::io::Emit32(Out, + clang::io::Emit32(Out, Writer.getIdentifierRef(Sel.getIdentifierInfoForSlot(I))); } - + void EmitData(llvm::raw_ostream& Out, key_type_ref, data_type_ref Methods, unsigned DataLen) { uint64_t Start = Out.tell(); (void)Start; unsigned NumInstanceMethods = 0; - for (const ObjCMethodList *Method = &Methods.first; Method; + for (const ObjCMethodList *Method = &Methods.first; Method; Method = Method->Next) if (Method->Method) ++NumInstanceMethods; unsigned NumFactoryMethods = 0; - for (const ObjCMethodList *Method = &Methods.second; Method; + for (const ObjCMethodList *Method = &Methods.second; Method; Method = Method->Next) if (Method->Method) ++NumFactoryMethods; clang::io::Emit16(Out, NumInstanceMethods); clang::io::Emit16(Out, NumFactoryMethods); - for (const ObjCMethodList *Method = &Methods.first; Method; + for (const ObjCMethodList *Method = &Methods.first; Method; Method = Method->Next) if (Method->Method) clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); - for (const ObjCMethodList *Method = &Methods.second; Method; + for (const ObjCMethodList *Method = &Methods.second; Method; Method = Method->Next) if (Method->Method) clang::io::Emit32(Out, Writer.getDeclID(Method->Method)); @@ -1321,13 +1321,13 @@ void PCHWriter::WriteMethodPool(Sema &SemaRef) { bool Empty = true; { OnDiskChainedHashTableGenerator<PCHMethodPoolTrait> Generator; - + // Create the on-disk hash table representation. Start by // iterating through the instance method pool. PCHMethodPoolTrait::key_type Key; unsigned NumSelectorsInMethodPool = 0; for (llvm::DenseMap<Selector, ObjCMethodList>::iterator - Instance = SemaRef.InstanceMethodPool.begin(), + Instance = SemaRef.InstanceMethodPool.begin(), InstanceEnd = SemaRef.InstanceMethodPool.end(); Instance != InstanceEnd; ++Instance) { // Check whether there is a factory method with the same @@ -1337,7 +1337,7 @@ void PCHWriter::WriteMethodPool(Sema &SemaRef) { if (Factory == SemaRef.FactoryMethodPool.end()) Generator.insert(Instance->first, - std::make_pair(Instance->second, + std::make_pair(Instance->second, ObjCMethodList())); else Generator.insert(Instance->first, @@ -1350,7 +1350,7 @@ void PCHWriter::WriteMethodPool(Sema &SemaRef) { // Now iterate through the factory method pool, to pick up any // selectors that weren't already in the instance method pool. for (llvm::DenseMap<Selector, ObjCMethodList>::iterator - Factory = SemaRef.FactoryMethodPool.begin(), + Factory = SemaRef.FactoryMethodPool.begin(), FactoryEnd = SemaRef.FactoryMethodPool.end(); Factory != FactoryEnd; ++Factory) { // Check whether there is an instance method with the same @@ -1371,7 +1371,7 @@ void PCHWriter::WriteMethodPool(Sema &SemaRef) { return; // Create the on-disk hash table in a buffer. - llvm::SmallString<4096> MethodPool; + llvm::SmallString<4096> MethodPool; uint32_t BucketOffset; SelectorOffsets.resize(SelVector.size()); { @@ -1444,25 +1444,25 @@ class VISIBILITY_HIDDEN PCHIdentifierTableTrait { public: typedef const IdentifierInfo* key_type; typedef key_type key_type_ref; - + typedef pch::IdentID data_type; typedef data_type data_type_ref; - - PCHIdentifierTableTrait(PCHWriter &Writer, Preprocessor &PP) + + PCHIdentifierTableTrait(PCHWriter &Writer, Preprocessor &PP) : Writer(Writer), PP(PP) { } static unsigned ComputeHash(const IdentifierInfo* II) { return clang::BernsteinHash(II->getName()); } - - std::pair<unsigned,unsigned> - EmitKeyDataLength(llvm::raw_ostream& Out, const IdentifierInfo* II, + + std::pair<unsigned,unsigned> + EmitKeyDataLength(llvm::raw_ostream& Out, const IdentifierInfo* II, pch::IdentID ID) { unsigned KeyLen = strlen(II->getName()) + 1; unsigned DataLen = 4; // 4 bytes for the persistent ID << 1 if (isInterestingIdentifier(II)) { DataLen += 2; // 2 bytes for builtin ID, flags - if (II->hasMacroDefinition() && + if (II->hasMacroDefinition() && !PP.getMacroInfo(const_cast<IdentifierInfo *>(II))->isBuiltinMacro()) DataLen += 4; for (IdentifierResolver::iterator D = IdentifierResolver::begin(II), @@ -1477,16 +1477,16 @@ public: clang::io::Emit16(Out, KeyLen); return std::make_pair(KeyLen, DataLen); } - - void EmitKey(llvm::raw_ostream& Out, const IdentifierInfo* II, + + void EmitKey(llvm::raw_ostream& Out, const IdentifierInfo* II, unsigned KeyLen) { // Record the location of the key data. This is used when generating // the mapping from persistent IDs to strings. Writer.SetIdentifierOffset(II, Out.tell()); Out.write(II->getName(), KeyLen); } - - void EmitData(llvm::raw_ostream& Out, const IdentifierInfo* II, + + void EmitData(llvm::raw_ostream& Out, const IdentifierInfo* II, pch::IdentID ID, unsigned) { if (!isInterestingIdentifier(II)) { clang::io::Emit32(Out, ID << 1); @@ -1495,8 +1495,8 @@ public: clang::io::Emit32(Out, (ID << 1) | 0x01); uint32_t Bits = 0; - bool hasMacroDefinition = - II->hasMacroDefinition() && + bool hasMacroDefinition = + II->hasMacroDefinition() && !PP.getMacroInfo(const_cast<IdentifierInfo *>(II))->isBuiltinMacro(); Bits = (uint32_t)II->getObjCOrBuiltinID(); Bits = (Bits << 1) | hasMacroDefinition; @@ -1514,7 +1514,7 @@ public: // "stat"), but IdentifierResolver::AddDeclToIdentifierChain() // adds declarations to the end of the list (so we need to see the // struct "status" before the function "status"). - llvm::SmallVector<Decl *, 16> Decls(IdentifierResolver::begin(II), + llvm::SmallVector<Decl *, 16> Decls(IdentifierResolver::begin(II), IdentifierResolver::end()); for (llvm::SmallVector<Decl *, 16>::reverse_iterator D = Decls.rbegin(), DEnd = Decls.rend(); @@ -1536,7 +1536,7 @@ void PCHWriter::WriteIdentifierTable(Preprocessor &PP) { // strings. { OnDiskChainedHashTableGenerator<PCHIdentifierTableTrait> Generator; - + // Look for any identifiers that were named while processing the // headers, but are otherwise not needed. We add these to the hash // table to enable checking of the predefines buffer in the case @@ -1557,7 +1557,7 @@ void PCHWriter::WriteIdentifierTable(Preprocessor &PP) { } // Create the on-disk hash table in a buffer. - llvm::SmallString<4096> IdentifierTable; + llvm::SmallString<4096> IdentifierTable; uint32_t BucketOffset; { PCHIdentifierTableTrait Trait(*this, PP); @@ -1617,7 +1617,7 @@ void PCHWriter::WriteAttributeRecord(const Attr *Attr) { case Attr::AlwaysInline: break; - + case Attr::AnalyzerNoReturn: break; @@ -1676,7 +1676,7 @@ void PCHWriter::WriteAttributeRecord(const Attr *Attr) { Record.push_back(Sentinel->getNullPos()); break; } - + case Attr::GNUInline: case Attr::IBOutletKind: case Attr::Malloc: @@ -1706,14 +1706,14 @@ void PCHWriter::WriteAttributeRecord(const Attr *Attr) { case Attr::Packed: break; - + case Attr::Pure: break; case Attr::Regparm: Record.push_back(cast<RegparmAttr>(Attr)->getNumParams()); break; - + case Attr::ReqdWorkGroupSize: Record.push_back(cast<ReqdWorkGroupSizeAttr>(Attr)->getXDim()); Record.push_back(cast<ReqdWorkGroupSizeAttr>(Attr)->getYDim()); @@ -1733,7 +1733,7 @@ void PCHWriter::WriteAttributeRecord(const Attr *Attr) { case Attr::Visibility: // FIXME: stable encoding - Record.push_back(cast<VisibilityAttr>(Attr)->getVisibility()); + Record.push_back(cast<VisibilityAttr>(Attr)->getVisibility()); break; case Attr::WarnUnusedResult: @@ -1765,8 +1765,8 @@ void PCHWriter::SetSelectorOffset(Selector Sel, uint32_t Offset) { SelectorOffsets[ID - 1] = Offset; } -PCHWriter::PCHWriter(llvm::BitstreamWriter &Stream) - : Stream(Stream), NextTypeID(pch::NUM_PREDEF_TYPE_IDS), +PCHWriter::PCHWriter(llvm::BitstreamWriter &Stream) + : Stream(Stream), NextTypeID(pch::NUM_PREDEF_TYPE_IDS), NumStatements(0), NumMacros(0), NumLexicalDeclContexts(0), NumVisibleDeclContexts(0) { } @@ -1782,7 +1782,7 @@ void PCHWriter::WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls, Stream.Emit((unsigned)'P', 8); Stream.Emit((unsigned)'C', 8); Stream.Emit((unsigned)'H', 8); - + WriteBlockInfoBlock(); // The translation unit is the first declaration we'll emit. @@ -1816,7 +1816,7 @@ void PCHWriter::WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls, RecordData LocallyScopedExternalDecls; // FIXME: This is filling in the PCH file in densemap order which is // nondeterminstic! - for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator + for (llvm::DenseMap<DeclarationName, NamedDecl *>::iterator TD = SemaRef.LocallyScopedExternalDecls.begin(), TDEnd = SemaRef.LocallyScopedExternalDecls.end(); TD != TDEnd; ++TD) @@ -1836,10 +1836,10 @@ void PCHWriter::WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls, WriteStatCache(*StatCalls, isysroot); WriteSourceManagerBlock(Context.getSourceManager(), PP, isysroot); WritePreprocessor(PP); - WriteComments(Context); + WriteComments(Context); // Write the record of special types. Record.clear(); - + AddTypeRef(Context.getBuiltinVaListType(), Record); AddTypeRef(Context.getObjCIdType(), Record); AddTypeRef(Context.getObjCSelType(), Record); @@ -1853,7 +1853,7 @@ void PCHWriter::WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls, AddTypeRef(Context.ObjCIdRedefinitionType, Record); AddTypeRef(Context.ObjCClassRedefinitionType, Record); Stream.EmitRecord(pch::SPECIAL_TYPES, Record); - + // Keep writing types and declarations until all types and // declarations have been written. do { @@ -1876,9 +1876,9 @@ void PCHWriter::WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls, Record.push_back(pch::TYPE_OFFSET); Record.push_back(TypeOffsets.size()); Stream.EmitRecordWithBlob(TypeOffsetAbbrev, Record, - (const char *)&TypeOffsets.front(), + (const char *)&TypeOffsets.front(), TypeOffsets.size() * sizeof(TypeOffsets[0])); - + // Write the declaration offsets array Abbrev = new BitCodeAbbrev(); Abbrev->Add(BitCodeAbbrevOp(pch::DECL_OFFSET)); @@ -1889,7 +1889,7 @@ void PCHWriter::WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls, Record.push_back(pch::DECL_OFFSET); Record.push_back(DeclOffsets.size()); Stream.EmitRecordWithBlob(DeclOffsetAbbrev, Record, - (const char *)&DeclOffsets.front(), + (const char *)&DeclOffsets.front(), DeclOffsets.size() * sizeof(DeclOffsets[0])); // Write the record containing external, unnamed definitions. @@ -1902,13 +1902,13 @@ void PCHWriter::WritePCH(Sema &SemaRef, MemorizeStatCalls *StatCalls, // Write the record containing locally-scoped external definitions. if (!LocallyScopedExternalDecls.empty()) - Stream.EmitRecord(pch::LOCALLY_SCOPED_EXTERNAL_DECLS, + Stream.EmitRecord(pch::LOCALLY_SCOPED_EXTERNAL_DECLS, LocallyScopedExternalDecls); // Write the record containing ext_vector type names. if (!ExtVectorDecls.empty()) Stream.EmitRecord(pch::EXT_VECTOR_DECLS, ExtVectorDecls); - + // Some simple statistics Record.clear(); Record.push_back(NumStatements); @@ -2032,7 +2032,7 @@ void PCHWriter::AddDeclRef(const Decl *D, RecordData &Record) { } pch::DeclID &ID = DeclIDs[D]; - if (ID == 0) { + if (ID == 0) { // We haven't seen this declaration before. Give it a new ID and // enqueue it in the list of declarations to emit. ID = DeclIDs.size(); diff --git a/clang/lib/Frontend/PCHWriterDecl.cpp b/clang/lib/Frontend/PCHWriterDecl.cpp index eed888382ac..7a15abf0a01 100644 --- a/clang/lib/Frontend/PCHWriterDecl.cpp +++ b/clang/lib/Frontend/PCHWriterDecl.cpp @@ -35,8 +35,8 @@ namespace { pch::DeclCode Code; unsigned AbbrevToUse; - PCHDeclWriter(PCHWriter &Writer, ASTContext &Context, - PCHWriter::RecordData &Record) + PCHDeclWriter(PCHWriter &Writer, ASTContext &Context, + PCHWriter::RecordData &Record) : Writer(Writer), Context(Context), Record(Record) { } @@ -59,7 +59,7 @@ namespace { void VisitOriginalParmVarDecl(OriginalParmVarDecl *D); void VisitFileScopeAsmDecl(FileScopeAsmDecl *D); void VisitBlockDecl(BlockDecl *D); - void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, + void VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, uint64_t VisibleOffset); void VisitObjCMethodDecl(ObjCMethodDecl *D); void VisitObjCContainerDecl(ObjCContainerDecl *D); @@ -161,9 +161,9 @@ public: #define ABSTRACT_TYPELOC(CLASS) #define TYPELOC(CLASS, PARENT, TYPE) \ - void Visit##CLASS(CLASS TyLoc); + void Visit##CLASS(CLASS TyLoc); #include "clang/AST/TypeLocNodes.def" - + void VisitTypeLoc(TypeLoc TyLoc) { assert(0 && "A type loc wrapper was not handled!"); } @@ -210,7 +210,7 @@ void PCHDeclWriter::VisitDeclaratorDecl(DeclaratorDecl *D) { Writer.AddTypeRef(QualType(), Record); return; } - + Writer.AddTypeRef(DInfo->getTypeLoc().getSourceType(), Record); TypeLocWriter TLW(Writer, Record); for (TypeLoc TL = DInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc()) @@ -243,7 +243,7 @@ void PCHDeclWriter::VisitFunctionDecl(FunctionDecl *D) { void PCHDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) { VisitNamedDecl(D); // FIXME: convert to LazyStmtPtr? - // Unlike C/C++, method bodies will never be in header files. + // Unlike C/C++, method bodies will never be in header files. Record.push_back(D->getBody() != 0); if (D->getBody() != 0) { Writer.AddStmt(D->getBody()); @@ -254,13 +254,13 @@ void PCHDeclWriter::VisitObjCMethodDecl(ObjCMethodDecl *D) { Record.push_back(D->isVariadic()); Record.push_back(D->isSynthesized()); // FIXME: stable encoding for @required/@optional - Record.push_back(D->getImplementationControl()); + Record.push_back(D->getImplementationControl()); // FIXME: stable encoding for in/out/inout/bycopy/byref/oneway - Record.push_back(D->getObjCDeclQualifier()); + Record.push_back(D->getObjCDeclQualifier()); Writer.AddTypeRef(D->getResultType(), Record); Writer.AddSourceLocation(D->getLocEnd(), Record); Record.push_back(D->param_size()); - for (ObjCMethodDecl::param_iterator P = D->param_begin(), + for (ObjCMethodDecl::param_iterator P = D->param_begin(), PEnd = D->param_end(); P != PEnd; ++P) Writer.AddDeclRef(*P, Record); Code = pch::DECL_OBJC_METHOD; @@ -277,12 +277,12 @@ void PCHDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { Writer.AddTypeRef(QualType(D->getTypeForDecl(), 0), Record); Writer.AddDeclRef(D->getSuperClass(), Record); Record.push_back(D->protocol_size()); - for (ObjCInterfaceDecl::protocol_iterator P = D->protocol_begin(), + for (ObjCInterfaceDecl::protocol_iterator P = D->protocol_begin(), PEnd = D->protocol_end(); P != PEnd; ++P) Writer.AddDeclRef(*P, Record); Record.push_back(D->ivar_size()); - for (ObjCInterfaceDecl::ivar_iterator I = D->ivar_begin(), + for (ObjCInterfaceDecl::ivar_iterator I = D->ivar_begin(), IEnd = D->ivar_end(); I != IEnd; ++I) Writer.AddDeclRef(*I, Record); Writer.AddDeclRef(D->getCategoryList(), Record); @@ -297,7 +297,7 @@ void PCHDeclWriter::VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) { void PCHDeclWriter::VisitObjCIvarDecl(ObjCIvarDecl *D) { VisitFieldDecl(D); // FIXME: stable encoding for @public/@private/@protected/@package - Record.push_back(D->getAccessControl()); + Record.push_back(D->getAccessControl()); Code = pch::DECL_OBJC_IVAR; } @@ -306,7 +306,7 @@ void PCHDeclWriter::VisitObjCProtocolDecl(ObjCProtocolDecl *D) { Record.push_back(D->isForwardDecl()); Writer.AddSourceLocation(D->getLocEnd(), Record); Record.push_back(D->protocol_size()); - for (ObjCProtocolDecl::protocol_iterator + for (ObjCProtocolDecl::protocol_iterator I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I) Writer.AddDeclRef(*I, Record); Code = pch::DECL_OBJC_PROTOCOL; @@ -328,7 +328,7 @@ void PCHDeclWriter::VisitObjCClassDecl(ObjCClassDecl *D) { void PCHDeclWriter::VisitObjCForwardProtocolDecl(ObjCForwardProtocolDecl *D) { VisitDecl(D); Record.push_back(D->protocol_size()); - for (ObjCProtocolDecl::protocol_iterator + for (ObjCProtocolDecl::protocol_iterator I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I) Writer.AddDeclRef(*I, Record); Code = pch::DECL_OBJC_FORWARD_PROTOCOL; @@ -338,7 +338,7 @@ void PCHDeclWriter::VisitObjCCategoryDecl(ObjCCategoryDecl *D) { VisitObjCContainerDecl(D); Writer.AddDeclRef(D->getClassInterface(), Record); Record.push_back(D->protocol_size()); - for (ObjCProtocolDecl::protocol_iterator + for (ObjCProtocolDecl::protocol_iterator I = D->protocol_begin(), IEnd = D->protocol_end(); I != IEnd; ++I) Writer.AddDeclRef(*I, Record); Writer.AddDeclRef(D->getNextClassCategory(), Record); @@ -424,8 +424,8 @@ void PCHDeclWriter::VisitParmVarDecl(ParmVarDecl *D) { VisitVarDecl(D); Record.push_back(D->getObjCDeclQualifier()); // FIXME: stable encoding Code = pch::DECL_PARM_VAR; - - + + // If the assumptions about the DECL_PARM_VAR abbrev are true, use it. Here // we dynamically check for the properties that we optimize for, but don't // know are true of all PARM_VAR_DECLs. @@ -483,7 +483,7 @@ void PCHDeclWriter::VisitBlockDecl(BlockDecl *D) { /// that there are no declarations visible from this context. Note /// that this value will not be emitted for non-primary declaration /// contexts. -void PCHDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, +void PCHDeclWriter::VisitDeclContext(DeclContext *DC, uint64_t LexicalOffset, uint64_t VisibleOffset) { Record.push_back(LexicalOffset); Record.push_back(VisibleOffset); @@ -509,7 +509,7 @@ void PCHWriter::WriteDeclsBlockAbbrevs() { Abv->Add(BitCodeAbbrevOp(0)); // isImplicit Abv->Add(BitCodeAbbrevOp(0)); // isUsed Abv->Add(BitCodeAbbrevOp(AS_none)); // C++ AccessSpecifier - + // NamedDecl Abv->Add(BitCodeAbbrevOp(0)); // NameKind = Identifier Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name @@ -526,7 +526,7 @@ void PCHWriter::WriteDeclsBlockAbbrevs() { Abv->Add(BitCodeAbbrevOp(0)); // HasInit // ParmVarDecl Abv->Add(BitCodeAbbrevOp(0)); // ObjCDeclQualifier - + ParmVarDeclAbbrev = Stream.EmitAbbrev(Abv); } @@ -537,7 +537,7 @@ void PCHWriter::WriteDeclsBlock(ASTContext &Context) { // Output the abbreviations that we will use in this block. WriteDeclsBlockAbbrevs(); - + // Emit all of the declarations. RecordData Record; PCHDeclWriter W(*this, Context, Record); @@ -588,14 +588,14 @@ void PCHWriter::WriteDeclsBlock(ASTContext &Context) { exit(-1); } Stream.EmitRecord(W.Code, Record, W.AbbrevToUse); - + // If the declaration had any attributes, write them now. if (D->hasAttrs()) WriteAttributeRecord(D->getAttrs()); // Flush any expressions that were written as part of this declaration. FlushStmts(); - + // Note external declarations so that we can add them to a record // in the PCH file later. if (isa<FileScopeAsmDecl>(D)) diff --git a/clang/lib/Frontend/PCHWriterStmt.cpp b/clang/lib/Frontend/PCHWriterStmt.cpp index 1f81529135d..a34c9923fc7 100644 --- a/clang/lib/Frontend/PCHWriterStmt.cpp +++ b/clang/lib/Frontend/PCHWriterStmt.cpp @@ -86,7 +86,7 @@ namespace { void VisitShuffleVectorExpr(ShuffleVectorExpr *E); void VisitBlockExpr(BlockExpr *E); void VisitBlockDeclRefExpr(BlockDeclRefExpr *E); - + // Objective-C Expressions void VisitObjCStringLiteral(ObjCStringLiteral *E); void VisitObjCEncodeExpr(ObjCEncodeExpr *E); @@ -99,8 +99,8 @@ namespace { void VisitObjCMessageExpr(ObjCMessageExpr *E); void VisitObjCSuperExpr(ObjCSuperExpr *E); void VisitObjCIsaExpr(ObjCIsaExpr *E); - - // Objective-C Statements + + // Objective-C Statements void VisitObjCForCollectionStmt(ObjCForCollectionStmt *); void VisitObjCAtCatchStmt(ObjCAtCatchStmt *); void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *); @@ -108,12 +108,12 @@ namespace { void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *); void VisitObjCAtThrowStmt(ObjCAtThrowStmt *); - // C++ Statements + // C++ Statements void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E); }; } -void PCHStmtWriter::VisitStmt(Stmt *S) { +void PCHStmtWriter::VisitStmt(Stmt *S) { } void PCHStmtWriter::VisitNullStmt(NullStmt *S) { @@ -181,7 +181,7 @@ void PCHStmtWriter::VisitSwitchStmt(SwitchStmt *S) { Writer.WriteSubStmt(S->getCond()); Writer.WriteSubStmt(S->getBody()); Writer.AddSourceLocation(S->getSwitchLoc(), Record); - for (SwitchCase *SC = S->getSwitchCaseList(); SC; + for (SwitchCase *SC = S->getSwitchCaseList(); SC; SC = SC->getNextSwitchCase()) Record.push_back(Writer.getSwitchCaseID(SC)); Code = pch::STMT_SWITCH; @@ -345,7 +345,7 @@ void PCHStmtWriter::VisitStringLiteral(StringLiteral *E) { // StringLiteral. However, we can't do so now because we have no // provision for coping with abbreviations when we're jumping around // the PCH file during deserialization. - Record.insert(Record.end(), + Record.insert(Record.end(), E->getStrData(), E->getStrData() + E->getByteLength()); for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I) Writer.AddSourceLocation(E->getStrTokenLoc(I), Record); @@ -376,7 +376,7 @@ void PCHStmtWriter::VisitUnaryOperator(UnaryOperator *E) { Code = pch::EXPR_UNARY_OPERATOR; } -void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { +void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) { VisitExpr(E); Record.push_back(E->isSizeOf()); if (E->isArgumentType()) @@ -635,7 +635,7 @@ void PCHStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) { Code = pch::EXPR_OBJC_STRING_LITERAL; } -void PCHStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { +void PCHStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) { VisitExpr(E); Writer.AddTypeRef(E->getEncodedType(), Record); Writer.AddSourceLocation(E->getAtLoc(), Record); @@ -682,7 +682,7 @@ void PCHStmtWriter::VisitObjCImplicitSetterGetterRefExpr( VisitExpr(E); Writer.AddDeclRef(E->getGetterMethod(), Record); Writer.AddDeclRef(E->getSetterMethod(), Record); - + // NOTE: InterfaceDecl and Base are mutually exclusive. Writer.AddDeclRef(E->getInterfaceDecl(), Record); Writer.WriteSubStmt(E->getBase()); @@ -779,7 +779,7 @@ void PCHStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) { //===----------------------------------------------------------------------===// unsigned PCHWriter::RecordSwitchCaseID(SwitchCase *S) { - assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() && + assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() && "SwitchCase recorded twice"); unsigned NextID = SwitchCaseIDs.size(); SwitchCaseIDs[S] = NextID; @@ -787,7 +787,7 @@ unsigned PCHWriter::RecordSwitchCaseID(SwitchCase *S) { } unsigned PCHWriter::getSwitchCaseID(SwitchCase *S) { - assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() && + assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() && "SwitchCase hasn't been seen yet"); return SwitchCaseIDs[S]; } @@ -798,7 +798,7 @@ unsigned PCHWriter::GetLabelID(LabelStmt *S) { std::map<LabelStmt *, unsigned>::iterator Pos = LabelIDs.find(S); if (Pos != LabelIDs.end()) return Pos->second; - + unsigned NextID = LabelIDs.size(); LabelIDs[S] = NextID; return NextID; @@ -810,17 +810,17 @@ void PCHWriter::WriteSubStmt(Stmt *S) { RecordData Record; PCHStmtWriter Writer(*this, Record); ++NumStatements; - + if (!S) { Stream.EmitRecord(pch::STMT_NULL_PTR, Record); return; } - + Writer.Code = pch::STMT_NULL_PTR; Writer.Visit(S); - assert(Writer.Code != pch::STMT_NULL_PTR && + assert(Writer.Code != pch::STMT_NULL_PTR && "Unhandled expression writing PCH file"); - Stream.EmitRecord(Writer.Code, Record); + Stream.EmitRecord(Writer.Code, Record); } /// \brief Flush all of the statements that have been added to the @@ -828,31 +828,31 @@ void PCHWriter::WriteSubStmt(Stmt *S) { void PCHWriter::FlushStmts() { RecordData Record; PCHStmtWriter Writer(*this, Record); - + for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) { ++NumStatements; Stmt *S = StmtsToEmit[I]; - + if (!S) { Stream.EmitRecord(pch::STMT_NULL_PTR, Record); continue; } - + Writer.Code = pch::STMT_NULL_PTR; Writer.Visit(S); - assert(Writer.Code != pch::STMT_NULL_PTR && + assert(Writer.Code != pch::STMT_NULL_PTR && "Unhandled expression writing PCH file"); - Stream.EmitRecord(Writer.Code, Record); - - assert(N == StmtsToEmit.size() && + Stream.EmitRecord(Writer.Code, Record); + + assert(N == StmtsToEmit.size() && "Substatement writen via AddStmt rather than WriteSubStmt!"); - + // Note that we are at the end of a full expression. Any // expression records that follow this one are part of a different // expression. Record.clear(); Stream.EmitRecord(pch::STMT_STOP, Record); } - + StmtsToEmit.clear(); } diff --git a/clang/lib/Frontend/PlistDiagnostics.cpp b/clang/lib/Frontend/PlistDiagnostics.cpp index 26fc08019d1..a83dca0a5ff 100644 --- a/clang/lib/Frontend/PlistDiagnostics.cpp +++ b/clang/lib/Frontend/PlistDiagnostics.cpp @@ -45,19 +45,19 @@ namespace { PathDiagnosticClientFactory *pf); ~PlistDiagnostics(); void HandlePathDiagnostic(const PathDiagnostic* D); - + PathGenerationScheme getGenerationScheme() const; bool supportsLogicalOpControlFlow() const { return true; } bool supportsAllBlockEdges() const { return true; } virtual bool useVerboseDescription() const { return false; } - }; + }; } // end anonymous namespace PlistDiagnostics::PlistDiagnostics(const std::string& output, const LangOptions &LO, PathDiagnosticClientFactory *pf) : OutputFile(output), LangOpts(LO), PF(pf) { - + if (PF) SubPDC.reset(PF->createPathDiagnosticClient(&FilesMade)); } @@ -73,7 +73,7 @@ PathDiagnosticClient::PathGenerationScheme PlistDiagnostics::getGenerationScheme() const { if (const PathDiagnosticClient *PD = SubPDC.get()) return PD->getGenerationScheme(); - + return Extensive; } @@ -110,7 +110,7 @@ static void EmitLocation(llvm::raw_ostream& o, const SourceManager &SM, // Add in the length of the token, so that we cover multi-char tokens. unsigned offset = extend ? Lexer::MeasureTokenLength(Loc, SM, LangOpts) - 1 : 0; - + Indent(o, indent) << "<dict>\n"; Indent(o, indent) << " <key>line</key><integer>" << Loc.getInstantiationLineNumber() << "</integer>\n"; @@ -133,7 +133,7 @@ static void EmitRange(llvm::raw_ostream& o, const SourceManager &SM, PathDiagnosticRange R, const FIDMap &FM, unsigned indent) { Indent(o, indent) << "<array>\n"; - EmitLocation(o, SM, LangOpts, R.getBegin(), FM, indent+1); + EmitLocation(o, SM, LangOpts, R.getBegin(), FM, indent+1); EmitLocation(o, SM, LangOpts, R.getEnd(), FM, indent+1, !R.isPoint); Indent(o, indent) << "</array>\n"; } @@ -162,12 +162,12 @@ static void ReportControlFlow(llvm::raw_ostream& o, const SourceManager &SM, const LangOptions &LangOpts, unsigned indent) { - + Indent(o, indent) << "<dict>\n"; ++indent; - + Indent(o, indent) << "<key>kind</key><string>control</string>\n"; - + // Emit edges. Indent(o, indent) << "<key>edges</key>\n"; ++indent; @@ -187,39 +187,39 @@ static void ReportControlFlow(llvm::raw_ostream& o, --indent; Indent(o, indent) << "</array>\n"; --indent; - + // Output any helper text. const std::string& s = P.getString(); if (!s.empty()) { Indent(o, indent) << "<key>alternate</key>"; EmitString(o, s) << '\n'; } - + --indent; - Indent(o, indent) << "</dict>\n"; + Indent(o, indent) << "</dict>\n"; } -static void ReportEvent(llvm::raw_ostream& o, const PathDiagnosticPiece& P, +static void ReportEvent(llvm::raw_ostream& o, const PathDiagnosticPiece& P, const FIDMap& FM, const SourceManager &SM, const LangOptions &LangOpts, unsigned indent) { - + Indent(o, indent) << "<dict>\n"; ++indent; Indent(o, indent) << "<key>kind</key><string>event</string>\n"; - + // Output the location. FullSourceLoc L = P.getLocation().asLocation(); - + Indent(o, indent) << "<key>location</key>\n"; EmitLocation(o, SM, LangOpts, L, FM, indent); - + // Output the ranges (if any). PathDiagnosticPiece::range_iterator RI = P.ranges_begin(), RE = P.ranges_end(); - + if (RI != RE) { Indent(o, indent) << "<key>ranges</key>\n"; Indent(o, indent) << "<array>\n"; @@ -229,13 +229,13 @@ static void ReportEvent(llvm::raw_ostream& o, const PathDiagnosticPiece& P, --indent; Indent(o, indent) << "</array>\n"; } - + // Output the text. assert(!P.getString().empty()); Indent(o, indent) << "<key>extended_message</key>\n"; Indent(o, indent); EmitString(o, P.getString()) << '\n'; - + // Output the short text. // FIXME: Really use a short string. Indent(o, indent) << "<key>message</key>\n"; @@ -251,10 +251,10 @@ static void ReportMacro(llvm::raw_ostream& o, const FIDMap& FM, const SourceManager &SM, const LangOptions &LangOpts, unsigned indent) { - + for (PathDiagnosticMacroPiece::const_iterator I=P.begin(), E=P.end(); I!=E; ++I) { - + switch ((*I)->getKind()) { default: break; @@ -266,16 +266,16 @@ static void ReportMacro(llvm::raw_ostream& o, ReportMacro(o, cast<PathDiagnosticMacroPiece>(**I), FM, SM, LangOpts, indent); break; - } - } + } + } } -static void ReportDiag(llvm::raw_ostream& o, const PathDiagnosticPiece& P, +static void ReportDiag(llvm::raw_ostream& o, const PathDiagnosticPiece& P, const FIDMap& FM, const SourceManager &SM, const LangOptions &LangOpts) { unsigned indent = 4; - + switch (P.getKind()) { case PathDiagnosticPiece::ControlFlow: ReportControlFlow(o, cast<PathDiagnosticControlFlowPiece>(P), FM, SM, @@ -295,38 +295,38 @@ static void ReportDiag(llvm::raw_ostream& o, const PathDiagnosticPiece& P, void PlistDiagnostics::HandlePathDiagnostic(const PathDiagnostic* D) { if (!D) return; - + if (D->empty()) { delete D; return; } - + // We need to flatten the locations (convert Stmt* to locations) because // the referenced statements may be freed by the time the diagnostics // are emitted. - const_cast<PathDiagnostic*>(D)->flattenLocations(); + const_cast<PathDiagnostic*>(D)->flattenLocations(); BatchedDiags.push_back(D); } -PlistDiagnostics::~PlistDiagnostics() { +PlistDiagnostics::~PlistDiagnostics() { // Build up a set of FIDs that we use by scanning the locations and // ranges of the diagnostics. FIDMap FM; llvm::SmallVector<FileID, 10> Fids; const SourceManager* SM = 0; - - if (!BatchedDiags.empty()) + + if (!BatchedDiags.empty()) SM = &(*BatchedDiags.begin())->begin()->getLocation().getManager(); for (std::vector<const PathDiagnostic*>::iterator DI = BatchedDiags.begin(), DE = BatchedDiags.end(); DI != DE; ++DI) { - + const PathDiagnostic *D = *DI; - + for (PathDiagnostic::const_iterator I=D->begin(), E=D->end(); I!=E; ++I) { AddFID(FM, Fids, SM, I->getLocation().asLocation()); - + for (PathDiagnosticPiece::range_iterator RI=I->ranges_begin(), RE=I->ranges_end(); RI!=RE; ++RI) { AddFID(FM, Fids, SM, RI->getBegin()); @@ -342,84 +342,84 @@ PlistDiagnostics::~PlistDiagnostics() { llvm::errs() << "warning: could not creat file: " << OutputFile << '\n'; return; } - + // Write the plist header. o << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" "<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" " "\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n" "<plist version=\"1.0\">\n"; - + // Write the root object: a <dict> containing... // - "files", an <array> mapping from FIDs to file names - // - "diagnostics", an <array> containing the path diagnostics + // - "diagnostics", an <array> containing the path diagnostics o << "<dict>\n" " <key>files</key>\n" " <array>\n"; - + for (llvm::SmallVectorImpl<FileID>::iterator I=Fids.begin(), E=Fids.end(); I!=E; ++I) { o << " "; EmitString(o, SM->getFileEntryForID(*I)->getName()) << '\n'; } - + o << " </array>\n" " <key>diagnostics</key>\n" " <array>\n"; - + for (std::vector<const PathDiagnostic*>::iterator DI=BatchedDiags.begin(), DE = BatchedDiags.end(); DI!=DE; ++DI) { - + o << " <dict>\n" " <key>path</key>\n"; - + const PathDiagnostic *D = *DI; // Create an owning smart pointer for 'D' just so that we auto-free it // when we exit this method. llvm::OwningPtr<PathDiagnostic> OwnedD(const_cast<PathDiagnostic*>(D)); - + o << " <array>\n"; for (PathDiagnostic::const_iterator I=D->begin(), E=D->end(); I != E; ++I) ReportDiag(o, *I, FM, *SM, LangOpts); - + o << " </array>\n"; - - // Output the bug type and bug category. + + // Output the bug type and bug category. o << " <key>description</key>"; EmitString(o, D->getDescription()) << '\n'; o << " <key>category</key>"; EmitString(o, D->getCategory()) << '\n'; o << " <key>type</key>"; EmitString(o, D->getBugType()) << '\n'; - + // Output the location of the bug. o << " <key>location</key>\n"; EmitLocation(o, *SM, LangOpts, D->getLocation(), FM, 2); - + // Output the diagnostic to the sub-diagnostic client, if any. if (PF) { if (!SubPDC.get()) SubPDC.reset(PF->createPathDiagnosticClient(&FilesMade)); - + FilesMade.clear(); - SubPDC->HandlePathDiagnostic(OwnedD.take()); + SubPDC->HandlePathDiagnostic(OwnedD.take()); SubPDC.reset(0); - + if (!FilesMade.empty()) { o << " <key>" << PF->getName() << "_files</key>\n"; o << " <array>\n"; for (size_t i = 0, n = FilesMade.size(); i < n ; ++i) o << " <string>" << FilesMade[i] << "</string>\n"; - o << " </array>\n"; + o << " </array>\n"; } } - + // Close up the entry. o << " </dict>\n"; } o << " </array>\n"; - + // Finish. o << "</dict>\n</plist>"; } diff --git a/clang/lib/Frontend/PrintParserCallbacks.cpp b/clang/lib/Frontend/PrintParserCallbacks.cpp index 126cdd3fdd4..b537025aec2 100644 --- a/clang/lib/Frontend/PrintParserCallbacks.cpp +++ b/clang/lib/Frontend/PrintParserCallbacks.cpp @@ -39,7 +39,7 @@ namespace { Out << "<anon>"; } Out << "\n"; - + // Pass up to EmptyActions so that the symbol table is maintained right. return MinimalAction::ActOnDeclarator(S, D); } @@ -69,16 +69,16 @@ namespace { AttributeList *AttrList) { Out << __FUNCTION__ << "\n"; return MinimalAction::ActOnStartClassInterface(AtInterfaceLoc, - ClassName, ClassLoc, + ClassName, ClassLoc, SuperName, SuperLoc, ProtoRefs, NumProtocols, EndProtoLoc, AttrList); } - /// ActOnForwardClassDeclaration - - /// Scope will always be top level file scope. + /// ActOnForwardClassDeclaration - + /// Scope will always be top level file scope. Action::DeclPtrTy ActOnForwardClassDeclaration(SourceLocation AtClassLoc, - IdentifierInfo **IdentList, + IdentifierInfo **IdentList, unsigned NumElts) { Out << __FUNCTION__ << "\n"; return MinimalAction::ActOnForwardClassDeclaration(AtClassLoc, IdentList, @@ -101,13 +101,13 @@ namespace { Out << "\n"; return DeclPtrTy(); } - - /// AddInitializerToDecl - This action is called immediately after - /// ParseDeclarator (when an initializer is present). The code is factored + + /// AddInitializerToDecl - This action is called immediately after + /// ParseDeclarator (when an initializer is present). The code is factored /// this way to make sure we are able to handle the following: /// void func() { int xx = xx; } /// This allows ActOnDeclarator to register "xx" prior to parsing the - /// initializer. The declaration above should still result in a warning, + /// initializer. The declaration above should still result in a warning, /// since the reference to "xx" is uninitialized. virtual void AddInitializerToDecl(DeclPtrTy Dcl, ExprArg Init) { Out << __FUNCTION__ << "\n"; @@ -142,7 +142,7 @@ namespace { virtual void ActOnStartOfObjCMethodDef(Scope *FnBodyScope, DeclPtrTy D) { Out << __FUNCTION__ << "\n"; } - + /// ActOnFunctionDefBody - This is called when a function body has completed /// parsing. Decl is the DeclTy returned by ParseStartOfFunctionDef. virtual DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body) { @@ -155,14 +155,14 @@ namespace { Out << __FUNCTION__ << "\n"; return DeclPtrTy(); } - + /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with /// no declarator (e.g. "struct foo;") is parsed. virtual DeclPtrTy ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS) { Out << __FUNCTION__ << "\n"; return DeclPtrTy(); } - + /// ActOnLinkageSpec - Parsed a C++ linkage-specification that /// contained braces. Lang/StrSize contains the language string that /// was parsed at location Loc. Decls/NumDecls provides the @@ -170,12 +170,12 @@ namespace { virtual DeclPtrTy ActOnLinkageSpec(SourceLocation Loc, SourceLocation LBrace, SourceLocation RBrace, const char *Lang, - unsigned StrSize, + unsigned StrSize, DeclPtrTy *Decls, unsigned NumDecls) { Out << __FUNCTION__ << "\n"; return DeclPtrTy(); } - + /// ActOnLinkageSpec - Parsed a C++ linkage-specification without /// braces. Lang/StrSize contains the language string that was /// parsed at location Loc. D is the declaration parsed. @@ -183,16 +183,16 @@ namespace { unsigned StrSize, DeclPtrTy D) { return DeclPtrTy(); } - + //===------------------------------------------------------------------===// // Type Parsing Callbacks. //===------------------------------------------------------------------===// - + virtual TypeResult ActOnTypeName(Scope *S, Declarator &D) { Out << __FUNCTION__ << "\n"; return TypeResult(); } - + virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagType, TagUseKind TUK, SourceLocation KWLoc, const CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, @@ -204,22 +204,22 @@ namespace { Out << __FUNCTION__ << "\n"; return DeclPtrTy(); } - + /// Act on @defs() element found when parsing a structure. ClassName is the - /// name of the referenced class. + /// name of the referenced class. virtual void ActOnDefs(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart, IdentifierInfo *ClassName, llvm::SmallVectorImpl<DeclPtrTy> &Decls) { Out << __FUNCTION__ << "\n"; } - virtual DeclPtrTy ActOnField(Scope *S, DeclPtrTy TagD, + virtual DeclPtrTy ActOnField(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart, Declarator &D, ExprTy *BitfieldWidth) { Out << __FUNCTION__ << "\n"; return DeclPtrTy(); } - + virtual DeclPtrTy ActOnIvar(Scope *S, SourceLocation DeclStart, DeclPtrTy IntfDecl, Declarator &D, ExprTy *BitfieldWidth, @@ -227,14 +227,14 @@ namespace { Out << __FUNCTION__ << "\n"; return DeclPtrTy(); } - + virtual void ActOnFields(Scope* S, SourceLocation RecLoc, DeclPtrTy TagDecl, - DeclPtrTy *Fields, unsigned NumFields, + DeclPtrTy *Fields, unsigned NumFields, SourceLocation LBrac, SourceLocation RBrac, AttributeList *AttrList) { Out << __FUNCTION__ << "\n"; } - + virtual DeclPtrTy ActOnEnumConstant(Scope *S, DeclPtrTy EnumDecl, DeclPtrTy LastEnumConstant, SourceLocation IdLoc,IdentifierInfo *Id, @@ -272,12 +272,12 @@ namespace { Out << __FUNCTION__ << "\n"; return StmtEmpty(); } - + virtual OwningStmtResult ActOnExprStmt(FullExprArg Expr) { Out << __FUNCTION__ << "\n"; return OwningStmtResult(*this, Expr->release()); } - + /// ActOnCaseStmt - Note that this handles the GNU 'case 1 ... 4' extension, /// which can specify an RHS value. virtual OwningStmtResult ActOnCaseStmt(SourceLocation CaseLoc, @@ -303,7 +303,7 @@ namespace { return StmtEmpty(); } - virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc, + virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc, FullExprArg CondVal, StmtArg ThenVal, SourceLocation ElseLoc, StmtArg ElseVal) { @@ -329,7 +329,7 @@ namespace { return StmtEmpty(); } virtual OwningStmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body, - SourceLocation WhileLoc, + SourceLocation WhileLoc, SourceLocation LPLoc, ExprArg Cond, SourceLocation RPLoc){ Out << __FUNCTION__ << "\n"; @@ -490,12 +490,12 @@ namespace { return ExprEmpty(); } - virtual OwningExprResult ActOnCharacterConstant(const Token &) { + virtual OwningExprResult ActOnCharacterConstant(const Token &) { Out << __FUNCTION__ << "\n"; return ExprEmpty(); } - virtual OwningExprResult ActOnNumericConstant(const Token &) { + virtual OwningExprResult ActOnNumericConstant(const Token &) { Out << __FUNCTION__ << "\n"; return ExprEmpty(); } @@ -515,7 +515,7 @@ namespace { } // Postfix Expressions. - virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, + virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, tok::TokenKind Kind, ExprArg Input) { Out << __FUNCTION__ << "\n"; @@ -574,7 +574,7 @@ namespace { Out << __FUNCTION__ << "\n"; return ExprEmpty(); } - virtual OwningExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, + virtual OwningExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc, TypeTy *Ty, SourceLocation RParenLoc, ExprArg Op) { Out << __FUNCTION__ << "\n"; @@ -726,8 +726,7 @@ namespace { } virtual void ActOnStartDelayedCXXMethodDeclaration(Scope *S, - DeclPtrTy Method) - { + DeclPtrTy Method) { Out << __FUNCTION__ << "\n"; } diff --git a/clang/lib/Frontend/PrintPreprocessedOutput.cpp b/clang/lib/Frontend/PrintPreprocessedOutput.cpp index d63d9cbba98..492b31a0ec3 100644 --- a/clang/lib/Frontend/PrintPreprocessedOutput.cpp +++ b/clang/lib/Frontend/PrintPreprocessedOutput.cpp @@ -32,12 +32,12 @@ using namespace clang; static void PrintMacroDefinition(const IdentifierInfo &II, const MacroInfo &MI, Preprocessor &PP, llvm::raw_ostream &OS) { OS << "#define " << II.getName(); - + if (MI.isFunctionLike()) { OS << '('; if (MI.arg_empty()) ; - else if (MI.getNumArgs() == 1) + else if (MI.getNumArgs() == 1) OS << (*MI.arg_begin())->getName(); else { MacroInfo::arg_iterator AI = MI.arg_begin(), E = MI.arg_end(); @@ -45,7 +45,7 @@ static void PrintMacroDefinition(const IdentifierInfo &II, const MacroInfo &MI, while (AI != E) OS << ',' << (*AI++)->getName(); } - + if (MI.isVariadic()) { if (!MI.arg_empty()) OS << ','; @@ -53,18 +53,18 @@ static void PrintMacroDefinition(const IdentifierInfo &II, const MacroInfo &MI, } OS << ')'; } - + // GCC always emits a space, even if the macro body is empty. However, do not // want to emit two spaces if the first token has a leading space. if (MI.tokens_empty() || !MI.tokens_begin()->hasLeadingSpace()) OS << ' '; - + llvm::SmallVector<char, 128> SpellingBuffer; for (MacroInfo::tokens_iterator I = MI.tokens_begin(), E = MI.tokens_end(); I != E; ++I) { if (I->hasLeadingSpace()) OS << ' '; - + // Make sure we have enough space in the spelling buffer. if (I->getLength() < SpellingBuffer.size()) SpellingBuffer.resize(I->getLength()); @@ -105,14 +105,14 @@ public: FileType = SrcMgr::C_User; Initialized = false; } - + void SetEmittedTokensOnThisLine() { EmittedTokensOnThisLine = true; } bool hasEmittedTokensOnThisLine() const { return EmittedTokensOnThisLine; } - + virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType); virtual void Ident(SourceLocation Loc, const std::string &str); - virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind, + virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind, const std::string &Str); @@ -122,12 +122,12 @@ public: return ConcatInfo.AvoidConcat(PrevTok, Tok); } void WriteLineInfo(unsigned LineNo, const char *Extra=0, unsigned ExtraLen=0); - + void HandleNewlinesInToken(const char *TokStr, unsigned Len); - + /// MacroDefined - This hook is called whenever a macro definition is seen. void MacroDefined(const IdentifierInfo *II, const MacroInfo *MI); - + }; } // end anonymous namespace @@ -143,7 +143,7 @@ void PrintPPOutputPPCallbacks::WriteLineInfo(unsigned LineNo, OS << '#' << ' ' << LineNo << ' ' << '"'; OS.write(&CurFilename[0], CurFilename.size()); OS << '"'; - + if (ExtraLen) OS.write(Extra, ExtraLen); @@ -163,12 +163,12 @@ bool PrintPPOutputPPCallbacks::MoveToLine(SourceLocation Loc) { if (DisableLineMarkers) { if (LineNo == CurLine) return false; - + CurLine = LineNo; - + if (!EmittedTokensOnThisLine && !EmittedMacroOnThisLine) return true; - + OS << '\n'; EmittedTokensOnThisLine = false; EmittedMacroOnThisLine = false; @@ -188,9 +188,9 @@ bool PrintPPOutputPPCallbacks::MoveToLine(SourceLocation Loc) { } } else { WriteLineInfo(LineNo, 0, 0); - } + } - CurLine = LineNo; + CurLine = LineNo; return true; } @@ -210,12 +210,12 @@ void PrintPPOutputPPCallbacks::FileChanged(SourceLocation Loc, MoveToLine(IncludeLoc); } else if (Reason == PPCallbacks::SystemHeaderPragma) { MoveToLine(Loc); - + // TODO GCC emits the # directive for this directive on the line AFTER the // directive and emits a bunch of spaces that aren't needed. Emulate this // strange behavior. } - + Loc = SourceMgr.getInstantiationLoc(Loc); // FIXME: Should use presumed line #! CurLine = SourceMgr.getInstantiationLineNumber(Loc); @@ -239,8 +239,8 @@ void PrintPPOutputPPCallbacks::FileChanged(SourceLocation Loc, case PPCallbacks::ExitFile: WriteLineInfo(CurLine, " 2", 2); break; - case PPCallbacks::SystemHeaderPragma: - case PPCallbacks::RenameFile: + case PPCallbacks::SystemHeaderPragma: + case PPCallbacks::RenameFile: WriteLineInfo(CurLine); break; } @@ -250,7 +250,7 @@ void PrintPPOutputPPCallbacks::FileChanged(SourceLocation Loc, /// void PrintPPOutputPPCallbacks::Ident(SourceLocation Loc, const std::string &S) { MoveToLine(Loc); - + OS.write("#ident ", strlen("#ident ")); OS.write(&S[0], S.size()); EmittedTokensOnThisLine = true; @@ -263,7 +263,7 @@ void PrintPPOutputPPCallbacks::MacroDefined(const IdentifierInfo *II, if (!DumpDefines || // Ignore __FILE__ etc. MI->isBuiltinMacro()) return; - + MoveToLine(MI->getDefinitionLoc()); PrintMacroDefinition(*II, *MI, PP, OS); EmittedMacroOnThisLine = true; @@ -271,14 +271,14 @@ void PrintPPOutputPPCallbacks::MacroDefined(const IdentifierInfo *II, void PrintPPOutputPPCallbacks::PragmaComment(SourceLocation Loc, - const IdentifierInfo *Kind, + const IdentifierInfo *Kind, const std::string &Str) { MoveToLine(Loc); OS << "#pragma comment(" << Kind->getName(); - + if (!Str.empty()) { OS << ", \""; - + for (unsigned i = 0, e = Str.size(); i != e; ++i) { unsigned char Char = Str[i]; if (isprint(Char) && Char != '\\' && Char != '"') @@ -291,7 +291,7 @@ void PrintPPOutputPPCallbacks::PragmaComment(SourceLocation Loc, } OS << '"'; } - + OS << ')'; EmittedTokensOnThisLine = true; } @@ -307,12 +307,12 @@ bool PrintPPOutputPPCallbacks::HandleFirstTokOnLine(Token &Tok) { // newline characters. if (!MoveToLine(Tok.getLocation())) return false; - + // Print out space characters so that the first token on a line is // indented for easy reading. const SourceManager &SourceMgr = PP.getSourceManager(); unsigned ColNo = SourceMgr.getInstantiationColumnNumber(Tok.getLocation()); - + // This hack prevents stuff like: // #define HASH # // HASH define foo bar @@ -321,11 +321,11 @@ bool PrintPPOutputPPCallbacks::HandleFirstTokOnLine(Token &Tok) { // -fpreprocessed mode. if (ColNo <= 1 && Tok.is(tok::hash)) OS << ' '; - + // Otherwise, indent the appropriate number of spaces. for (; ColNo > 1; --ColNo) OS << ' '; - + return true; } @@ -336,18 +336,18 @@ void PrintPPOutputPPCallbacks::HandleNewlinesInToken(const char *TokStr, if (*TokStr != '\n' && *TokStr != '\r') continue; - + ++NumNewlines; - + // If we have \n\r or \r\n, skip both and count as one line. if (Len != 1 && (TokStr[1] == '\n' || TokStr[1] == '\r') && TokStr[0] != TokStr[1]) ++TokStr, --Len; } - + if (NumNewlines == 0) return; - + CurLine += NumNewlines; } @@ -356,7 +356,7 @@ namespace { struct UnknownPragmaHandler : public PragmaHandler { const char *Prefix; PrintPPOutputPPCallbacks *Callbacks; - + UnknownPragmaHandler(const char *prefix, PrintPPOutputPPCallbacks *callbacks) : PragmaHandler(0), Prefix(prefix), Callbacks(callbacks) {} virtual void HandlePragma(Preprocessor &PP, Token &PragmaTok) { @@ -364,7 +364,7 @@ struct UnknownPragmaHandler : public PragmaHandler { // newline characters. Callbacks->MoveToLine(PragmaTok.getLocation()); Callbacks->OS.write(Prefix, strlen(Prefix)); - + // Read and print all of the pragma tokens. while (PragmaTok.isNot(tok::eom)) { if (PragmaTok.hasLeadingSpace()) @@ -385,11 +385,11 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok, char Buffer[256]; Token PrevTok; while (1) { - + // If this token is at the start of a line, emit newlines if needed. if (Tok.isAtStartOfLine() && Callbacks->HandleFirstTokOnLine(Tok)) { // done. - } else if (Tok.hasLeadingSpace() || + } else if (Tok.hasLeadingSpace() || // If we haven't emitted a token on this line yet, PrevTok isn't // useful to look at and no concatenation could happen anyway. (Callbacks->hasEmittedTokensOnThisLine() && @@ -397,7 +397,7 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok, Callbacks->AvoidConcat(PrevTok, Tok))) { OS << ' '; } - + if (IdentifierInfo *II = Tok.getIdentifierInfo()) { OS.write(II->getName(), II->getLength()); } else if (Tok.isLiteral() && !Tok.needsCleaning() && @@ -407,24 +407,24 @@ static void PrintPreprocessedTokens(Preprocessor &PP, Token &Tok, const char *TokPtr = Buffer; unsigned Len = PP.getSpelling(Tok, TokPtr); OS.write(TokPtr, Len); - + // Tokens that can contain embedded newlines need to adjust our current - // line number. + // line number. if (Tok.getKind() == tok::comment) Callbacks->HandleNewlinesInToken(TokPtr, Len); } else { std::string S = PP.getSpelling(Tok); OS.write(&S[0], S.size()); - + // Tokens that can contain embedded newlines need to adjust our current - // line number. + // line number. if (Tok.getKind() == tok::comment) Callbacks->HandleNewlinesInToken(&S[0], S.size()); } Callbacks->SetEmittedTokensOnThisLine(); - + if (Tok.is(tok::eof)) break; - + PrevTok = Tok; PP.Lex(Tok); } @@ -456,7 +456,7 @@ void clang::DoPrintMacros(Preprocessor &PP, llvm::raw_ostream *OS) { for (unsigned i = 0, e = MacrosByID.size(); i != e; ++i) { MacroInfo &MI = *MacrosByID[i].second; - // Ignore computed macros like __LINE__ and friends. + // Ignore computed macros like __LINE__ and friends. if (MI.isBuiltinMacro()) continue; PrintMacroDefinition(*MacrosByID[i].first, MI, PP, *OS); diff --git a/clang/lib/Frontend/RewriteBlocks.cpp b/clang/lib/Frontend/RewriteBlocks.cpp index b927d18b3e2..b29f9eac49d 100644 --- a/clang/lib/Frontend/RewriteBlocks.cpp +++ b/clang/lib/Frontend/RewriteBlocks.cpp @@ -43,28 +43,28 @@ class RewriteBlocks : public ASTConsumer { llvm::SmallVector<BlockExpr *, 32> Blocks; llvm::SmallVector<BlockDeclRefExpr *, 32> BlockDeclRefs; llvm::DenseMap<BlockDeclRefExpr *, CallExpr *> BlockCallExprs; - + // Block related declarations. llvm::SmallPtrSet<ValueDecl *, 8> BlockByCopyDecls; llvm::SmallPtrSet<ValueDecl *, 8> BlockByRefDecls; llvm::SmallPtrSet<ValueDecl *, 8> ImportedBlockDecls; llvm::DenseMap<BlockExpr *, std::string> RewrittenBlockExprs; - + // The function/method we are rewriting. FunctionDecl *CurFunctionDef; ObjCMethodDecl *CurMethodDef; - + bool IsHeader; - + std::string Preamble; public: - RewriteBlocks(std::string inFile, Diagnostic &D, + RewriteBlocks(std::string inFile, Diagnostic &D, const LangOptions &LOpts); ~RewriteBlocks() { - // Get the buffer corresponding to MainFileID. + // Get the buffer corresponding to MainFileID. // If we haven't changed it, then we are done. - if (const RewriteBuffer *RewriteBuf = + if (const RewriteBuffer *RewriteBuf = Rewrite.getRewriteBufferFor(MainFileID)) { std::string S(RewriteBuf->begin(), RewriteBuf->end()); printf("%s\n", S.c_str()); @@ -72,7 +72,7 @@ public: printf("No changes\n"); } } - + void Initialize(ASTContext &context); void InsertText(SourceLocation Loc, const char *StrData, unsigned StrLen); @@ -86,51 +86,51 @@ public: } void HandleTopLevelSingleDecl(Decl *D); void HandleDeclInMainFile(Decl *D); - - // Top level + + // Top level Stmt *RewriteFunctionBody(Stmt *S); void InsertBlockLiteralsWithinFunction(FunctionDecl *FD); void InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD); - + // Block specific rewrite rules. std::string SynthesizeBlockInitExpr(BlockExpr *Exp, VarDecl *VD=0); - + void RewriteBlockCall(CallExpr *Exp); void RewriteBlockPointerDecl(NamedDecl *VD); void RewriteBlockDeclRefExpr(BlockDeclRefExpr *VD); void RewriteBlockPointerFunctionArgs(FunctionDecl *FD); - - std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i, + + std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i, const char *funcName, std::string Tag); - std::string SynthesizeBlockFunc(BlockExpr *CE, int i, + std::string SynthesizeBlockFunc(BlockExpr *CE, int i, const char *funcName, std::string Tag); - std::string SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, + std::string SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, bool hasCopyDisposeHelpers); std::string SynthesizeBlockCall(CallExpr *Exp); void SynthesizeBlockLiterals(SourceLocation FunLocStart, const char *FunName); - + void CollectBlockDeclRefInfo(BlockExpr *Exp); void GetBlockCallExprs(Stmt *S); void GetBlockDeclRefExprs(Stmt *S); - + // We avoid calling Type::isBlockPointerType(), since it operates on the // canonical type. We only care if the top-level type is a closure pointer. bool isBlockPointerType(QualType T) { return isa<BlockPointerType>(T); } - + // FIXME: This predicate seems like it would be useful to add to ASTContext. bool isObjCType(QualType T) { if (!LangOpts.ObjC1 && !LangOpts.ObjC2) return false; - + QualType OCT = Context->getCanonicalType(T).getUnqualifiedType(); - + if (OCT == Context->getCanonicalType(Context->getObjCIdType()) || OCT == Context->getCanonicalType(Context->getObjCClassType())) return true; - + if (const PointerType *PT = OCT->getAs<PointerType>()) { - if (isa<ObjCInterfaceType>(PT->getPointeeType()) || + if (isa<ObjCInterfaceType>(PT->getPointeeType()) || PT->getPointeeType()->isObjCQualifiedIdType()) return true; } @@ -145,34 +145,34 @@ public: void RewriteFunctionProtoType(QualType funcType, NamedDecl *D); void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND); void RewriteCastExpr(CastExpr *CE); - + bool PointerTypeTakesAnyBlockArguments(QualType QT); void GetExtentOfArgList(const char *Name, const char *&LParen, const char *&RParen); }; - + } static bool IsHeaderFile(const std::string &Filename) { std::string::size_type DotPos = Filename.rfind('.'); - + if (DotPos == std::string::npos) { // no file extension - return false; + return false; } - + std::string Ext = std::string(Filename.begin()+DotPos+1, Filename.end()); // C header: .h // C++ header: .hh or .H; return Ext == "h" || Ext == "hh" || Ext == "H"; -} +} RewriteBlocks::RewriteBlocks(std::string inFile, - Diagnostic &D, const LangOptions &LOpts) : + Diagnostic &D, const LangOptions &LOpts) : Diags(D), LangOpts(LOpts) { IsHeader = IsHeaderFile(inFile); CurFunctionDef = 0; CurMethodDef = 0; - RewriteFailedDiag = Diags.getCustomDiagID(Diagnostic::Warning, + RewriteFailedDiag = Diags.getCustomDiagID(Diagnostic::Warning, "rewriting failed"); } @@ -185,15 +185,15 @@ ASTConsumer *clang::CreateBlockRewriter(const std::string& InFile, void RewriteBlocks::Initialize(ASTContext &context) { Context = &context; SM = &Context->getSourceManager(); - + // Get the ID and start/end of the main file. MainFileID = SM->getMainFileID(); const llvm::MemoryBuffer *MainBuf = SM->getBuffer(MainFileID); MainFileStart = MainBuf->getBufferStart(); MainFileEnd = MainBuf->getBufferEnd(); - + Rewrite.setSourceMgr(Context->getSourceManager(), LangOpts); - + if (IsHeader) Preamble = "#pragma once\n"; Preamble += "#ifndef BLOCK_IMPL\n"; @@ -208,7 +208,7 @@ void RewriteBlocks::Initialize(ASTContext &context) { Preamble += " BLOCK_HAS_COPY_DISPOSE = (1<<25),\n"; Preamble += " BLOCK_IS_GLOBAL = (1<<28)\n"; Preamble += "};\n"; - if (LangOpts.Microsoft) + if (LangOpts.Microsoft) Preamble += "#define __OBJC_RW_EXTERN extern \"C\" __declspec(dllimport)\n"; else Preamble += "#define __OBJC_RW_EXTERN extern\n"; @@ -220,14 +220,13 @@ void RewriteBlocks::Initialize(ASTContext &context) { Preamble += "__OBJC_RW_EXTERN void *_NSConcreteGlobalBlock;\n"; Preamble += "__OBJC_RW_EXTERN void *_NSConcreteStackBlock;\n"; Preamble += "#endif\n"; - - InsertText(SM->getLocForStartOfFile(MainFileID), + + InsertText(SM->getLocForStartOfFile(MainFileID), Preamble.c_str(), Preamble.size()); } -void RewriteBlocks::InsertText(SourceLocation Loc, const char *StrData, - unsigned StrLen) -{ +void RewriteBlocks::InsertText(SourceLocation Loc, const char *StrData, + unsigned StrLen) { if (!Rewrite.InsertText(Loc, StrData, StrLen)) return; Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag); @@ -243,14 +242,14 @@ void RewriteBlocks::ReplaceText(SourceLocation Start, unsigned OrigLength, void RewriteBlocks::RewriteMethodDecl(ObjCMethodDecl *Method) { bool haveBlockPtrs = false; - for (ObjCMethodDecl::param_iterator I = Method->param_begin(), + for (ObjCMethodDecl::param_iterator I = Method->param_begin(), E = Method->param_end(); I != E; ++I) if (isBlockPointerType((*I)->getType())) haveBlockPtrs = true; - + if (!haveBlockPtrs) return; - + // Do a fuzzy rewrite. // We have 1 or more arguments that have closure pointers. SourceLocation Loc = Method->getLocStart(); @@ -260,7 +259,7 @@ void RewriteBlocks::RewriteMethodDecl(ObjCMethodDecl *Method) { const char *methodPtr = startBuf; std::string Tag = "struct __block_impl *"; - + while (*methodPtr++ && (methodPtr != endBuf)) { switch (*methodPtr) { case ':': @@ -269,13 +268,13 @@ void RewriteBlocks::RewriteMethodDecl(ObjCMethodDecl *Method) { const char *scanType = ++methodPtr; bool foundBlockPointer = false; unsigned parenCount = 1; - + while (parenCount) { switch (*scanType) { - case '(': - parenCount++; + case '(': + parenCount++; break; - case ')': + case ')': parenCount--; break; case '^': @@ -289,7 +288,7 @@ void RewriteBlocks::RewriteMethodDecl(ObjCMethodDecl *Method) { Loc = Loc.getFileLocWithOffset(methodPtr-startBuf); assert((Loc.isValid()) && "Invalid Loc"); ReplaceText(Loc, scanType-methodPtr-1, Tag.c_str(), Tag.size()); - + // Advance startBuf. Since the underlying buffer has changed, // it's very important to advance startBuf (so we can correctly // compute a relative Loc the next time around). @@ -305,34 +304,34 @@ void RewriteBlocks::RewriteMethodDecl(ObjCMethodDecl *Method) { } void RewriteBlocks::RewriteInterfaceDecl(ObjCInterfaceDecl *ClassDecl) { - for (ObjCInterfaceDecl::instmeth_iterator - I = ClassDecl->instmeth_begin(), E = ClassDecl->instmeth_end(); + for (ObjCInterfaceDecl::instmeth_iterator + I = ClassDecl->instmeth_begin(), E = ClassDecl->instmeth_end(); I != E; ++I) RewriteMethodDecl(*I); - for (ObjCInterfaceDecl::classmeth_iterator + for (ObjCInterfaceDecl::classmeth_iterator I = ClassDecl->classmeth_begin(), E = ClassDecl->classmeth_end(); I != E; ++I) RewriteMethodDecl(*I); } void RewriteBlocks::RewriteCategoryDecl(ObjCCategoryDecl *CatDecl) { - for (ObjCCategoryDecl::instmeth_iterator - I = CatDecl->instmeth_begin(), E = CatDecl->instmeth_end(); + for (ObjCCategoryDecl::instmeth_iterator + I = CatDecl->instmeth_begin(), E = CatDecl->instmeth_end(); I != E; ++I) RewriteMethodDecl(*I); - for (ObjCCategoryDecl::classmeth_iterator + for (ObjCCategoryDecl::classmeth_iterator I = CatDecl->classmeth_begin(), E = CatDecl->classmeth_end(); I != E; ++I) RewriteMethodDecl(*I); } void RewriteBlocks::RewriteProtocolDecl(ObjCProtocolDecl *PDecl) { - for (ObjCProtocolDecl::instmeth_iterator - I = PDecl->instmeth_begin(), E = PDecl->instmeth_end(); + for (ObjCProtocolDecl::instmeth_iterator + I = PDecl->instmeth_begin(), E = PDecl->instmeth_end(); I != E; ++I) RewriteMethodDecl(*I); - for (ObjCProtocolDecl::classmeth_iterator - I = PDecl->classmeth_begin(), E = PDecl->classmeth_end(); + for (ObjCProtocolDecl::classmeth_iterator + I = PDecl->classmeth_begin(), E = PDecl->classmeth_end(); I != E; ++I) RewriteMethodDecl(*I); } @@ -347,10 +346,10 @@ void RewriteBlocks::HandleTopLevelSingleDecl(Decl *D) { // if we rewrote the #include/#import. SourceLocation Loc = D->getLocation(); Loc = SM->getInstantiationLoc(Loc); - + // If this is for a builtin, ignore it. if (Loc.isInvalid()) return; - + if (ObjCInterfaceDecl *MD = dyn_cast<ObjCInterfaceDecl>(D)) RewriteInterfaceDecl(MD); else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) @@ -374,7 +373,7 @@ std::string RewriteBlocks::SynthesizeBlockFunc(BlockExpr *CE, int i, funcName + "_" + "block_func_" + utostr(i); BlockDecl *BD = CE->getBlockDecl(); - + if (isa<FunctionNoProtoType>(AFT)) { S += "()"; } else if (BD->param_empty()) { @@ -400,19 +399,19 @@ std::string RewriteBlocks::SynthesizeBlockFunc(BlockExpr *CE, int i, S += ')'; } S += " {\n"; - + // Create local declarations to avoid rewriting all closure decl ref exprs. // First, emit a declaration for all "by ref" decls. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), E = BlockByRefDecls.end(); I != E; ++I) { S += " "; std::string Name = (*I)->getNameAsString(); Context->getPointerType((*I)->getType()).getAsStringInternal(Name, Context->PrintingPolicy); S += Name + " = __cself->" + (*I)->getNameAsString() + "; // bound by ref\n"; - } + } // Next, emit a declaration for all "by copy" declarations. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), E = BlockByCopyDecls.end(); I != E; ++I) { S += " "; std::string Name = (*I)->getNameAsString(); @@ -420,7 +419,7 @@ std::string RewriteBlocks::SynthesizeBlockFunc(BlockExpr *CE, int i, // // void (^myImportedClosure)(void); // myImportedClosure = ^(void) { setGlobalInt(x + y); }; - // + // // void (^anotherClosure)(void); // anotherClosure = ^(void) { // myImportedClosure(); // import and invoke the closure @@ -445,13 +444,13 @@ std::string RewriteBlocks::SynthesizeBlockHelperFuncs(BlockExpr *CE, int i, std::string Tag) { std::string StructRef = "struct " + Tag; std::string S = "static void __"; - + S += funcName; S += "_block_copy_" + utostr(i); S += "(" + StructRef; S += "*dst, " + StructRef; S += "*src) {"; - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(), E = ImportedBlockDecls.end(); I != E; ++I) { S += "_Block_copy_assign(&dst->"; S += (*I)->getNameAsString(); @@ -464,13 +463,13 @@ std::string RewriteBlocks::SynthesizeBlockHelperFuncs(BlockExpr *CE, int i, S += "_block_dispose_" + utostr(i); S += "(" + StructRef; S += "*src) {"; - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(), E = ImportedBlockDecls.end(); I != E; ++I) { S += "_Block_destroy(src->"; S += (*I)->getNameAsString(); S += ");"; } - S += "}\n"; + S += "}\n"; return S; } @@ -478,20 +477,20 @@ std::string RewriteBlocks::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, bool hasCopyDisposeHelpers) { std::string S = "struct " + Tag; std::string Constructor = " " + Tag; - + S += " {\n struct __block_impl impl;\n"; - + if (hasCopyDisposeHelpers) S += " void *copy;\n void *dispose;\n"; - + Constructor += "(void *fp"; - + if (hasCopyDisposeHelpers) Constructor += ", void *copyHelp, void *disposeHelp"; - + if (BlockDeclRefs.size()) { // Output all "by copy" declarations. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), E = BlockByCopyDecls.end(); I != E; ++I) { S += " "; std::string FieldName = (*I)->getNameAsString(); @@ -500,7 +499,7 @@ std::string RewriteBlocks::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, // // void (^myImportedBlock)(void); // myImportedBlock = ^(void) { setGlobalInt(x + y); }; - // + // // void (^anotherBlock)(void); // anotherBlock = ^(void) { // myImportedBlock(); // import and invoke the closure @@ -517,7 +516,7 @@ std::string RewriteBlocks::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, S += FieldName + ";\n"; } // Output all "by ref" declarations. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), E = BlockByRefDecls.end(); I != E; ++I) { S += " "; std::string FieldName = (*I)->getNameAsString(); @@ -526,7 +525,7 @@ std::string RewriteBlocks::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, // // void (^myImportedBlock)(void); // myImportedBlock = ^(void) { setGlobalInt(x + y); }; - // + // // void (^anotherBlock)(void); // anotherBlock = ^(void) { // myImportedBlock(); // import and invoke the closure @@ -549,12 +548,12 @@ std::string RewriteBlocks::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, Constructor += ", int flags=0) {\n"; Constructor += " impl.isa = 0/*&_NSConcreteStackBlock*/;\n impl.Size = sizeof("; Constructor += Tag + ");\n impl.Flags = flags;\n impl.FuncPtr = fp;\n"; - + if (hasCopyDisposeHelpers) Constructor += " copy = copyHelp;\n dispose = disposeHelp;\n"; - + // Initialize all "by copy" arguments. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), E = BlockByCopyDecls.end(); I != E; ++I) { std::string Name = (*I)->getNameAsString(); Constructor += " "; @@ -565,7 +564,7 @@ std::string RewriteBlocks::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, Constructor += Name + ";\n"; } // Initialize all "by ref" arguments. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), E = BlockByRefDecls.end(); I != E; ++I) { std::string Name = (*I)->getNameAsString(); Constructor += " "; @@ -599,21 +598,21 @@ void RewriteBlocks::SynthesizeBlockLiterals(SourceLocation FunLocStart, CollectBlockDeclRefInfo(Blocks[i]); std::string Tag = "__" + std::string(FunName) + "_block_impl_" + utostr(i); - - std::string CI = SynthesizeBlockImpl(Blocks[i], Tag, + + std::string CI = SynthesizeBlockImpl(Blocks[i], Tag, ImportedBlockDecls.size() > 0); InsertText(FunLocStart, CI.c_str(), CI.size()); std::string CF = SynthesizeBlockFunc(Blocks[i], i, FunName, Tag); - + InsertText(FunLocStart, CF.c_str(), CF.size()); if (ImportedBlockDecls.size()) { std::string HF = SynthesizeBlockHelperFuncs(Blocks[i], i, FunName, Tag); InsertText(FunLocStart, HF.c_str(), HF.size()); } - + BlockDeclRefs.clear(); BlockByRefDecls.clear(); BlockByCopyDecls.clear(); @@ -627,7 +626,7 @@ void RewriteBlocks::SynthesizeBlockLiterals(SourceLocation FunLocStart, void RewriteBlocks::InsertBlockLiteralsWithinFunction(FunctionDecl *FD) { SourceLocation FunLocStart = FD->getTypeSpecStartLoc(); const char *FuncName = FD->getNameAsCString(); - + SynthesizeBlockLiterals(FunLocStart, FuncName); } @@ -638,7 +637,7 @@ void RewriteBlocks::InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD) { std::string::size_type loc = 0; while ((loc = FuncName.find(":", loc)) != std::string::npos) FuncName.replace(loc, 1, "_"); - + SynthesizeBlockLiterals(FunLocStart, FuncName.c_str()); } @@ -668,7 +667,7 @@ void RewriteBlocks::GetBlockCallExprs(Stmt *S) { else GetBlockCallExprs(*CI); } - + if (CallExpr *CE = dyn_cast<CallExpr>(S)) { if (CE->getCallee()->getType()->isBlockPointerType()) { BlockCallExprs[dyn_cast<BlockDeclRefExpr>(CE->getCallee())] = CE; @@ -681,7 +680,7 @@ std::string RewriteBlocks::SynthesizeBlockCall(CallExpr *Exp) { // Navigate to relevant type information. const char *closureName = 0; const BlockPointerType *CPT = 0; - + if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp->getCallee())) { closureName = DRE->getDecl()->getNameAsCString(); CPT = DRE->getType()->getAs<BlockPointerType>(); @@ -699,20 +698,20 @@ std::string RewriteBlocks::SynthesizeBlockCall(CallExpr *Exp) { assert(FT && "RewriteBlockClass: Bad type"); const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT); // FTP will be null for closures that don't take arguments. - + // Build a closure call - start with a paren expr to enforce precedence. std::string BlockCall = "("; - // Synthesize the cast. + // Synthesize the cast. BlockCall += "(" + Exp->getType().getAsString() + "(*)"; BlockCall += "(struct __block_impl *"; if (FTP) { - for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(), + for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(), E = FTP->arg_type_end(); I && (I != E); ++I) BlockCall += ", " + (*I).getAsString(); } BlockCall += "))"; // close the argument list and paren expression. - + // Invoke the closure. We need to cast it since the declaration type is // bogus (it's a function pointer type) BlockCall += "((struct __block_impl *)"; @@ -722,11 +721,11 @@ std::string RewriteBlocks::SynthesizeBlockCall(CallExpr *Exp) { PrintingPolicy(LangOpts)); BlockCall += closureExprBuf.str(); BlockCall += ")->FuncPtr)"; - + // Add the arguments. BlockCall += "((struct __block_impl *)"; BlockCall += closureExprBuf.str(); - for (CallExpr::arg_iterator I = Exp->arg_begin(), + for (CallExpr::arg_iterator I = Exp->arg_begin(), E = Exp->arg_end(); I != E; ++I) { std::string syncExprBufS; llvm::raw_string_ostream Buf(syncExprBufS); @@ -738,11 +737,11 @@ std::string RewriteBlocks::SynthesizeBlockCall(CallExpr *Exp) { void RewriteBlocks::RewriteBlockCall(CallExpr *Exp) { std::string BlockCall = SynthesizeBlockCall(Exp); - + const char *startBuf = SM->getCharacterData(Exp->getLocStart()); const char *endBuf = SM->getCharacterData(Exp->getLocEnd()); - ReplaceText(Exp->getLocStart(), endBuf-startBuf, + ReplaceText(Exp->getLocStart(), endBuf-startBuf, BlockCall.c_str(), BlockCall.size()); } @@ -754,19 +753,19 @@ void RewriteBlocks::RewriteBlockDeclRefExpr(BlockDeclRefExpr *BDRE) { void RewriteBlocks::RewriteCastExpr(CastExpr *CE) { SourceLocation LocStart = CE->getLocStart(); SourceLocation LocEnd = CE->getLocEnd(); - + if (!Rewriter::isRewritable(LocStart) || !Rewriter::isRewritable(LocEnd)) return; - + const char *startBuf = SM->getCharacterData(LocStart); const char *endBuf = SM->getCharacterData(LocEnd); - + // advance the location to startArgList. const char *argPtr = startBuf; - + while (*argPtr++ && (argPtr < endBuf)) { switch (*argPtr) { - case '^': + case '^': // Replace the '^' with '*'. LocStart = LocStart.getFileLocWithOffset(argPtr-startBuf); ReplaceText(LocStart, 1, "*", 1); @@ -779,31 +778,31 @@ void RewriteBlocks::RewriteCastExpr(CastExpr *CE) { void RewriteBlocks::RewriteBlockPointerFunctionArgs(FunctionDecl *FD) { SourceLocation DeclLoc = FD->getLocation(); unsigned parenCount = 0; - + // We have 1 or more arguments that have closure pointers. const char *startBuf = SM->getCharacterData(DeclLoc); const char *startArgList = strchr(startBuf, '('); - + assert((*startArgList == '(') && "Rewriter fuzzy parser confused"); - + parenCount++; // advance the location to startArgList. DeclLoc = DeclLoc.getFileLocWithOffset(startArgList-startBuf); assert((DeclLoc.isValid()) && "Invalid DeclLoc"); - + const char *argPtr = startArgList; - + while (*argPtr++ && parenCount) { switch (*argPtr) { - case '^': + case '^': // Replace the '^' with '*'. DeclLoc = DeclLoc.getFileLocWithOffset(argPtr-startArgList); ReplaceText(DeclLoc, 1, "*", 1); break; - case '(': - parenCount++; + case '(': + parenCount++; break; - case ')': + case ')': parenCount--; break; } @@ -822,7 +821,7 @@ bool RewriteBlocks::PointerTypeTakesAnyBlockArguments(QualType QT) { FTP = BPT->getPointeeType()->getAsFunctionProtoType(); } if (FTP) { - for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(), + for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(), E = FTP->arg_type_end(); I != E; ++I) if (isBlockPointerType(*I)) return true; @@ -830,15 +829,15 @@ bool RewriteBlocks::PointerTypeTakesAnyBlockArguments(QualType QT) { return false; } -void RewriteBlocks::GetExtentOfArgList(const char *Name, +void RewriteBlocks::GetExtentOfArgList(const char *Name, const char *&LParen, const char *&RParen) { const char *argPtr = strchr(Name, '('); assert((*argPtr == '(') && "Rewriter fuzzy parser confused"); - + LParen = argPtr; // output the start. argPtr++; // skip past the left paren. unsigned parenCount = 1; - + while (*argPtr && parenCount) { switch (*argPtr) { case '(': parenCount++; break; @@ -855,7 +854,7 @@ void RewriteBlocks::RewriteBlockPointerDecl(NamedDecl *ND) { if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { RewriteBlockPointerFunctionArgs(FD); return; - } + } // Handle Variables and Typedefs. SourceLocation DeclLoc = ND->getLocation(); QualType DeclT; @@ -865,15 +864,15 @@ void RewriteBlocks::RewriteBlockPointerDecl(NamedDecl *ND) { DeclT = TDD->getUnderlyingType(); else if (FieldDecl *FD = dyn_cast<FieldDecl>(ND)) DeclT = FD->getType(); - else + else assert(0 && "RewriteBlockPointerDecl(): Decl type not yet handled"); - + const char *startBuf = SM->getCharacterData(DeclLoc); const char *endBuf = startBuf; // scan backward (from the decl location) for the end of the previous decl. while (*startBuf != '^' && *startBuf != ';' && startBuf != MainFileStart) startBuf--; - + // *startBuf != '^' if we are dealing with a pointer to function that // may take block argument types (which will be handled below). if (*startBuf == '^') { @@ -898,7 +897,7 @@ void RewriteBlocks::RewriteBlockPointerDecl(NamedDecl *ND) { return; } -void RewriteBlocks::CollectBlockDeclRefInfo(BlockExpr *Exp) { +void RewriteBlocks::CollectBlockDeclRefInfo(BlockExpr *Exp) { // Add initializers for any closure decl refs. GetBlockDeclRefExprs(Exp->getBody()); if (BlockDeclRefs.size()) { @@ -925,7 +924,7 @@ std::string RewriteBlocks::SynthesizeBlockInitExpr(BlockExpr *Exp, VarDecl *VD) CollectBlockDeclRefInfo(Exp); std::string FuncName; - + if (CurFunctionDef) FuncName = std::string(CurFunctionDef->getNameAsString()); else if (CurMethodDef) { @@ -936,27 +935,27 @@ std::string RewriteBlocks::SynthesizeBlockInitExpr(BlockExpr *Exp, VarDecl *VD) FuncName.replace(loc, 1, "_"); } else if (VD) FuncName = std::string(VD->getNameAsString()); - + std::string BlockNumber = utostr(Blocks.size()-1); - + std::string Tag = "__" + FuncName + "_block_impl_" + BlockNumber; std::string Func = "__" + FuncName + "_block_func_" + BlockNumber; - + std::string FunkTypeStr; - + // Get a pointer to the function type so we can cast appropriately. Context->getPointerType(QualType(Exp->getFunctionType(),0)) .getAsStringInternal(FunkTypeStr, Context->PrintingPolicy); - + // Rewrite the closure block with a compound literal. The first cast is // to prevent warnings from the C compiler. std::string Init = "(" + FunkTypeStr; - + Init += ")&" + Tag; - + // Initialize the block function. Init += "((void*)" + Func; - + if (ImportedBlockDecls.size()) { std::string Buf = "__" + FuncName + "_block_copy_" + BlockNumber; Init += ",(void*)" + Buf; @@ -966,7 +965,7 @@ std::string RewriteBlocks::SynthesizeBlockInitExpr(BlockExpr *Exp, VarDecl *VD) // Add initializers for any closure decl refs. if (BlockDeclRefs.size()) { // Output all "by copy" declarations. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), E = BlockByCopyDecls.end(); I != E; ++I) { Init += ","; if (isObjCType((*I)->getType())) { @@ -981,7 +980,7 @@ std::string RewriteBlocks::SynthesizeBlockInitExpr(BlockExpr *Exp, VarDecl *VD) } } // Output all "by ref" declarations. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), E = BlockByRefDecls.end(); I != E; ++I) { Init += ",&"; Init += (*I)->getNameAsString(); @@ -1007,7 +1006,7 @@ Stmt *RewriteBlocks::RewriteFunctionBody(Stmt *S) { if (*CI) { if (BlockExpr *CBE = dyn_cast<BlockExpr>(*CI)) { RewriteFunctionBody(CBE->getBody()); - + // We've just rewritten the block body in place. // Now we snarf the rewritten text and stash it away for later use. std::string S = Rewrite.getRewritenText(CBE->getSourceRange()); @@ -1030,18 +1029,18 @@ Stmt *RewriteBlocks::RewriteFunctionBody(Stmt *S) { if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) { for (DeclStmt::decl_iterator DI = DS->decl_begin(), DE = DS->decl_end(); DI != DE; ++DI) { - + Decl *SD = *DI; if (ValueDecl *ND = dyn_cast<ValueDecl>(SD)) { if (isBlockPointerType(ND->getType())) RewriteBlockPointerDecl(ND); - else if (ND->getType()->isFunctionPointerType()) + else if (ND->getType()->isFunctionPointerType()) CheckFunctionPointerDecl(ND->getType(), ND); } if (TypedefDecl *TD = dyn_cast<TypedefDecl>(SD)) { if (isBlockPointerType(TD->getUnderlyingType())) RewriteBlockPointerDecl(TD); - else if (TD->getUnderlyingType()->isFunctionPointerType()) + else if (TD->getUnderlyingType()->isFunctionPointerType()) CheckFunctionPointerDecl(TD->getUnderlyingType(), TD); } } @@ -1055,9 +1054,9 @@ Stmt *RewriteBlocks::RewriteFunctionBody(Stmt *S) { return S; } -void RewriteBlocks::RewriteFunctionProtoType(QualType funcType, NamedDecl *D) { +void RewriteBlocks::RewriteFunctionProtoType(QualType funcType, NamedDecl *D) { if (FunctionProtoType *fproto = dyn_cast<FunctionProtoType>(funcType)) { - for (FunctionProtoType::arg_type_iterator I = fproto->arg_type_begin(), + for (FunctionProtoType::arg_type_iterator I = fproto->arg_type_begin(), E = fproto->arg_type_end(); I && (I != E); ++I) if (isBlockPointerType(*I)) { // All the args are checked/rewritten. Don't call twice! @@ -1090,7 +1089,7 @@ void RewriteBlocks::HandleDeclInMainFile(Decl *D) { // and any copy/dispose helper functions. InsertBlockLiteralsWithinFunction(FD); CurFunctionDef = 0; - } + } return; } if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { @@ -1116,7 +1115,7 @@ void RewriteBlocks::HandleDeclInMainFile(Decl *D) { std::string Init = SynthesizeBlockInitExpr(CBE, VD); // Do the rewrite, using S.size() which contains the rewritten size. ReplaceText(CBE->getLocStart(), S.size(), Init.c_str(), Init.size()); - SynthesizeBlockLiterals(VD->getTypeSpecStartLoc(), + SynthesizeBlockLiterals(VD->getTypeSpecStartLoc(), VD->getNameAsCString()); } else if (CastExpr *CE = dyn_cast<CastExpr>(VD->getInit())) { RewriteCastExpr(CE); @@ -1135,13 +1134,13 @@ void RewriteBlocks::HandleDeclInMainFile(Decl *D) { if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) { if (isBlockPointerType(TD->getUnderlyingType())) RewriteBlockPointerDecl(TD); - else if (TD->getUnderlyingType()->isFunctionPointerType()) + else if (TD->getUnderlyingType()->isFunctionPointerType()) CheckFunctionPointerDecl(TD->getUnderlyingType(), TD); return; } if (RecordDecl *RD = dyn_cast<RecordDecl>(D)) { if (RD->isDefinition()) { - for (RecordDecl::field_iterator i = RD->field_begin(), + for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { FieldDecl *FD = *i; if (isBlockPointerType(FD->getType())) diff --git a/clang/lib/Frontend/RewriteMacros.cpp b/clang/lib/Frontend/RewriteMacros.cpp index 30cd6ff494d..d92f5c78e69 100644 --- a/clang/lib/Frontend/RewriteMacros.cpp +++ b/clang/lib/Frontend/RewriteMacros.cpp @@ -31,14 +31,14 @@ static bool isSameToken(Token &RawTok, Token &PPTok) { if (PPTok.getKind() == RawTok.getKind() && PPTok.getIdentifierInfo() == RawTok.getIdentifierInfo()) return true; - + // Otherwise, if they are different but have the same identifier info, they // are also considered to be the same. This allows keywords and raw lexed // identifiers with the same name to be treated the same. if (PPTok.getIdentifierInfo() && PPTok.getIdentifierInfo() == RawTok.getIdentifierInfo()) return true; - + return false; } @@ -48,11 +48,11 @@ static bool isSameToken(Token &RawTok, Token &PPTok) { static const Token &GetNextRawTok(const std::vector<Token> &RawTokens, unsigned &CurTok, bool ReturnComment) { assert(CurTok < RawTokens.size() && "Overran eof!"); - + // If the client doesn't want comments and we have one, skip it. if (!ReturnComment && RawTokens[CurTok].is(tok::comment)) ++CurTok; - + return RawTokens[CurTok++]; } @@ -62,24 +62,24 @@ static const Token &GetNextRawTok(const std::vector<Token> &RawTokens, static void LexRawTokensFromMainFile(Preprocessor &PP, std::vector<Token> &RawTokens) { SourceManager &SM = PP.getSourceManager(); - + // Create a lexer to lex all the tokens of the main file in raw mode. Even // though it is in raw mode, it will not return comments. Lexer RawLex(SM.getMainFileID(), SM, PP.getLangOptions()); // Switch on comment lexing because we really do want them. RawLex.SetCommentRetentionState(true); - + Token RawTok; do { RawLex.LexFromRawLexer(RawTok); - + // If we have an identifier with no identifier info for our raw token, look // up the indentifier info. This is important for equality comparison of // identifier tokens. if (RawTok.is(tok::identifier) && !RawTok.getIdentifierInfo()) RawTok.setIdentifierInfo(PP.LookUpIdentifierInfo(RawTok)); - + RawTokens.push_back(RawTok); } while (RawTok.isNot(tok::eof)); } @@ -88,7 +88,7 @@ static void LexRawTokensFromMainFile(Preprocessor &PP, /// RewriteMacrosInInput - Implement -rewrite-macros mode. void clang::RewriteMacrosInInput(Preprocessor &PP, llvm::raw_ostream *OS) { SourceManager &SM = PP.getSourceManager(); - + Rewriter Rewrite; Rewrite.setSourceMgr(SM, PP.getLangOptions()); RewriteBuffer &RB = Rewrite.getEditBuffer(SM.getMainFileID()); @@ -98,12 +98,12 @@ void clang::RewriteMacrosInInput(Preprocessor &PP, llvm::raw_ostream *OS) { unsigned CurRawTok = 0; Token RawTok = GetNextRawTok(RawTokens, CurRawTok, false); - + // Get the first preprocessing token. PP.EnterMainSourceFile(); Token PPTok; PP.Lex(PPTok); - + // Preprocess the input file in parallel with raw lexing the main file. Ignore // all tokens that are preprocessed from a file other than the main file (e.g. // a header). If we see tokens that are in the preprocessed file but not the @@ -118,7 +118,7 @@ void clang::RewriteMacrosInInput(Preprocessor &PP, llvm::raw_ostream *OS) { PP.Lex(PPTok); continue; } - + // If the raw file hits a preprocessor directive, they will be extra tokens // in the raw file that don't exist in the preprocsesed file. However, we // choose to preserve them in the output file and otherwise handle them @@ -139,7 +139,7 @@ void clang::RewriteMacrosInInput(Preprocessor &PP, llvm::raw_ostream *OS) { RB.InsertTextAfter(SM.getFileOffset(RawTok.getLocation()), "//"); } } - + // Otherwise, if this is a #include or some other directive, just leave it // in the file by skipping over the line. RawTok = GetNextRawTok(RawTokens, CurRawTok, false); @@ -147,7 +147,7 @@ void clang::RewriteMacrosInInput(Preprocessor &PP, llvm::raw_ostream *OS) { RawTok = GetNextRawTok(RawTokens, CurRawTok, false); continue; } - + // Okay, both tokens are from the same file. Get their offsets from the // start of the file. unsigned PPOffs = SM.getFileOffset(PPLoc); @@ -174,20 +174,20 @@ void clang::RewriteMacrosInInput(Preprocessor &PP, llvm::raw_ostream *OS) { RawTok = GetNextRawTok(RawTokens, CurRawTok, true); RawOffs = SM.getFileOffset(RawTok.getLocation()); - + if (RawTok.is(tok::comment)) { // Skip past the comment. RawTok = GetNextRawTok(RawTokens, CurRawTok, false); break; } - + } while (RawOffs <= PPOffs && !RawTok.isAtStartOfLine() && (PPOffs != RawOffs || !isSameToken(RawTok, PPTok))); RB.InsertTextBefore(EndPos, "*/"); continue; } - + // Otherwise, there was a replacement an expansion. Insert the new token // in the output buffer. Insert the whole run of new tokens at once to get // them in the right order. @@ -205,7 +205,7 @@ void clang::RewriteMacrosInInput(Preprocessor &PP, llvm::raw_ostream *OS) { // Get the buffer corresponding to MainFileID. If we haven't changed it, then // we are done. - if (const RewriteBuffer *RewriteBuf = + if (const RewriteBuffer *RewriteBuf = Rewrite.getRewriteBufferFor(SM.getMainFileID())) { //printf("Changed:\n"); *OS << std::string(RewriteBuf->begin(), RewriteBuf->end()); diff --git a/clang/lib/Frontend/RewriteObjC.cpp b/clang/lib/Frontend/RewriteObjC.cpp index 8d5f4992aea..323804744d3 100644 --- a/clang/lib/Frontend/RewriteObjC.cpp +++ b/clang/lib/Frontend/RewriteObjC.cpp @@ -35,14 +35,14 @@ namespace { const LangOptions &LangOpts; unsigned RewriteFailedDiag; unsigned TryFinallyContainsReturnDiag; - + ASTContext *Context; SourceManager *SM; TranslationUnitDecl *TUDecl; FileID MainFileID; const char *MainFileStart, *MainFileEnd; SourceLocation LastIncLoc; - + llvm::SmallVector<ObjCImplementationDecl *, 8> ClassImplementation; llvm::SmallVector<ObjCCategoryImplDecl *, 8> CategoryImplementation; llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCSynthesizedStructs; @@ -53,9 +53,9 @@ namespace { llvm::SmallVector<int, 8> ObjCBcLabelNo; // Remember all the @protocol(<expr>) expressions. llvm::SmallPtrSet<ObjCProtocolDecl *, 32> ProtocolExprDecls; - + unsigned NumObjCStringLiterals; - + FunctionDecl *MsgSendFunctionDecl; FunctionDecl *MsgSendSuperFunctionDecl; FunctionDecl *MsgSendStretFunctionDecl; @@ -66,25 +66,25 @@ namespace { FunctionDecl *SelGetUidFunctionDecl; FunctionDecl *CFStringFunctionDecl; FunctionDecl *SuperContructorFunctionDecl; - + // ObjC string constant support. VarDecl *ConstantStringClassReference; RecordDecl *NSStringRecord; - + // ObjC foreach break/continue generation support. int BcLabelCount; - + // Needed for super. ObjCMethodDecl *CurMethodDef; RecordDecl *SuperStructDecl; RecordDecl *ConstantStringDecl; - + TypeDecl *ProtocolTypeDecl; QualType getProtocolType(); - + // Needed for header files being rewritten bool IsHeader; - + std::string InFileName; llvm::raw_ostream* OutFile; @@ -96,7 +96,7 @@ namespace { llvm::SmallVector<BlockExpr *, 32> Blocks; llvm::SmallVector<BlockDeclRefExpr *, 32> BlockDeclRefs; llvm::DenseMap<BlockDeclRefExpr *, CallExpr *> BlockCallExprs; - + // Block related declarations. llvm::SmallPtrSet<ValueDecl *, 8> BlockByCopyDecls; llvm::SmallPtrSet<ValueDecl *, 8> BlockByRefDecls; @@ -109,7 +109,7 @@ namespace { // This maps a property to it's synthesied message expression. // This allows us to rewrite chained getters (e.g. o.a.b.c). llvm::DenseMap<ObjCPropertyRefExpr *, Stmt *> PropGetters; - + // This maps an original source AST to it's rewritten form. This allows // us to avoid rewriting the same node twice (which is very uncommon). // This is needed to support some of the exotic property rewriting. @@ -117,9 +117,9 @@ namespace { FunctionDecl *CurFunctionDef; VarDecl *GlobalVarDecl; - + bool DisableReplaceStmt; - + static const int OBJC_ABI_VERSION =7 ; public: virtual void Initialize(ASTContext &context); @@ -136,12 +136,12 @@ namespace { bool silenceMacroWarn); ~RewriteObjC() {} - + virtual void HandleTranslationUnit(ASTContext &C); - + void ReplaceStmt(Stmt *Old, Stmt *New) { Stmt *ReplacingStmt = ReplacedNodes[Old]; - + if (ReplacingStmt) return; // We can't rewrite the same node twice. @@ -191,15 +191,15 @@ namespace { InsertAfter) || SilenceRewriteMacroWarning) return; - + Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag); } - + void RemoveText(SourceLocation Loc, unsigned StrLen) { // If removal succeeded or warning disabled return with no warning. if (!Rewrite.RemoveText(Loc, StrLen) || SilenceRewriteMacroWarning) return; - + Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag); } @@ -210,10 +210,10 @@ namespace { llvm::StringRef(NewStr, NewLength)) || SilenceRewriteMacroWarning) return; - + Diags.Report(Context->getFullLoc(Start), RewriteFailedDiag); } - + // Syntactic Rewriting. void RewritePrologue(SourceLocation Loc); void RewriteInclude(); @@ -238,18 +238,18 @@ namespace { QualType getSuperStructType(); QualType getConstantStringStructType(); bool BufferContainsPPDirectives(const char *startBuf, const char *endBuf); - + // Expression Rewriting. Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S); void CollectPropertySetters(Stmt *S); - + Stmt *CurrentBody; ParentMap *PropParentMap; // created lazily. - + Stmt *RewriteAtEncode(ObjCEncodeExpr *Exp); Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, SourceLocation OrigStart); Stmt *RewritePropertyGetter(ObjCPropertyRefExpr *PropRefExpr); - Stmt *RewritePropertySetter(BinaryOperator *BinOp, Expr *newStmt, + Stmt *RewritePropertySetter(BinaryOperator *BinOp, Expr *newStmt, SourceRange SrcRange); Stmt *RewriteAtSelector(ObjCSelectorExpr *Exp); Stmt *RewriteMessageExpr(ObjCMessageExpr *Exp); @@ -263,13 +263,13 @@ namespace { Stmt *RewriteObjCThrowStmt(ObjCAtThrowStmt *S); Stmt *RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, SourceLocation OrigEnd); - CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD, + CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD, Expr **args, unsigned nargs); Stmt *SynthMessageExpr(ObjCMessageExpr *Exp); Stmt *RewriteBreakStmt(BreakStmt *S); Stmt *RewriteContinueStmt(ContinueStmt *S); void SynthCountByEnumWithState(std::string &buf); - + void SynthMsgSendFunctionDecl(); void SynthMsgSendSuperFunctionDecl(); void SynthMsgSendStretFunctionDecl(); @@ -279,14 +279,14 @@ namespace { void SynthGetMetaClassFunctionDecl(); void SynthSelGetUidFunctionDecl(); void SynthSuperContructorFunctionDecl(); - + // Metadata emission. void RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, std::string &Result); - + void RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *CDecl, std::string &Result); - + template<typename MethodIterator> void RewriteObjCMethodsMetaData(MethodIterator MethodBegin, MethodIterator MethodEnd, @@ -294,69 +294,69 @@ namespace { const char *prefix, const char *ClassName, std::string &Result); - + void RewriteObjCProtocolMetaData(ObjCProtocolDecl *Protocol, const char *prefix, const char *ClassName, std::string &Result); void RewriteObjCProtocolListMetaData(const ObjCList<ObjCProtocolDecl> &Prots, - const char *prefix, + const char *prefix, const char *ClassName, std::string &Result); void SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl, std::string &Result); - void SynthesizeIvarOffsetComputation(ObjCImplementationDecl *IDecl, - ObjCIvarDecl *ivar, + void SynthesizeIvarOffsetComputation(ObjCImplementationDecl *IDecl, + ObjCIvarDecl *ivar, std::string &Result); void RewriteImplementations(); void SynthesizeMetaDataIntoBuffer(std::string &Result); - + // Block rewriting. - void RewriteBlocksInFunctionProtoType(QualType funcType, NamedDecl *D); + void RewriteBlocksInFunctionProtoType(QualType funcType, NamedDecl *D); void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND); - + void InsertBlockLiteralsWithinFunction(FunctionDecl *FD); void InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD); - - // Block specific rewrite rules. + + // Block specific rewrite rules. void RewriteBlockCall(CallExpr *Exp); void RewriteBlockPointerDecl(NamedDecl *VD); Stmt *RewriteBlockDeclRefExpr(BlockDeclRefExpr *VD); void RewriteBlockPointerFunctionArgs(FunctionDecl *FD); - - std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i, + + std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i, const char *funcName, std::string Tag); - std::string SynthesizeBlockFunc(BlockExpr *CE, int i, + std::string SynthesizeBlockFunc(BlockExpr *CE, int i, const char *funcName, std::string Tag); - std::string SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, + std::string SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, bool hasCopyDisposeHelpers); Stmt *SynthesizeBlockCall(CallExpr *Exp); void SynthesizeBlockLiterals(SourceLocation FunLocStart, const char *FunName); - + void CollectBlockDeclRefInfo(BlockExpr *Exp); void GetBlockCallExprs(Stmt *S); void GetBlockDeclRefExprs(Stmt *S); - + // We avoid calling Type::isBlockPointerType(), since it operates on the // canonical type. We only care if the top-level type is a closure pointer. bool isTopLevelBlockPointerType(QualType T) { return isa<BlockPointerType>(T); } - + // FIXME: This predicate seems like it would be useful to add to ASTContext. bool isObjCType(QualType T) { if (!LangOpts.ObjC1 && !LangOpts.ObjC2) return false; - + QualType OCT = Context->getCanonicalType(T).getUnqualifiedType(); - + if (OCT == Context->getCanonicalType(Context->getObjCIdType()) || OCT == Context->getCanonicalType(Context->getObjCClassType())) return true; - + if (const PointerType *PT = OCT->getAs<PointerType>()) { - if (isa<ObjCInterfaceType>(PT->getPointeeType()) || + if (isa<ObjCInterfaceType>(PT->getPointeeType()) || PT->getPointeeType()->isObjCQualifiedIdType()) return true; } @@ -366,12 +366,12 @@ namespace { void GetExtentOfArgList(const char *Name, const char *&LParen, const char *&RParen); void RewriteCastExpr(CStyleCastExpr *CE); - + FunctionDecl *SynthBlockInitFunctionDecl(const char *name); Stmt *SynthBlockInitExpr(BlockExpr *Exp); - + void QuoteDoublequotes(std::string &From, std::string &To) { - for(unsigned i = 0; i < From.length(); i++) { + for (unsigned i = 0; i < From.length(); i++) { if (From[i] == '"') To += "\\\""; else @@ -381,10 +381,10 @@ namespace { }; } -void RewriteObjC::RewriteBlocksInFunctionProtoType(QualType funcType, - NamedDecl *D) { +void RewriteObjC::RewriteBlocksInFunctionProtoType(QualType funcType, + NamedDecl *D) { if (FunctionProtoType *fproto = dyn_cast<FunctionProtoType>(funcType)) { - for (FunctionProtoType::arg_type_iterator I = fproto->arg_type_begin(), + for (FunctionProtoType::arg_type_iterator I = fproto->arg_type_begin(), E = fproto->arg_type_end(); I && (I != E); ++I) if (isTopLevelBlockPointerType(*I)) { // All the args are checked/rewritten. Don't call twice! @@ -402,17 +402,17 @@ void RewriteObjC::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) { static bool IsHeaderFile(const std::string &Filename) { std::string::size_type DotPos = Filename.rfind('.'); - + if (DotPos == std::string::npos) { // no file extension - return false; + return false; } - + std::string Ext = std::string(Filename.begin()+DotPos+1, Filename.end()); // C header: .h // C++ header: .hh or .H; return Ext == "h" || Ext == "hh" || Ext == "H"; -} +} RewriteObjC::RewriteObjC(std::string inFile, llvm::raw_ostream* OS, Diagnostic &D, const LangOptions &LOpts, @@ -420,16 +420,16 @@ RewriteObjC::RewriteObjC(std::string inFile, llvm::raw_ostream* OS, : Diags(D), LangOpts(LOpts), InFileName(inFile), OutFile(OS), SilenceRewriteMacroWarning(silenceMacroWarn) { IsHeader = IsHeaderFile(inFile); - RewriteFailedDiag = Diags.getCustomDiagID(Diagnostic::Warning, + RewriteFailedDiag = Diags.getCustomDiagID(Diagnostic::Warning, "rewriting sub-expression within a macro (may not be correct)"); - TryFinallyContainsReturnDiag = Diags.getCustomDiagID(Diagnostic::Warning, + TryFinallyContainsReturnDiag = Diags.getCustomDiagID(Diagnostic::Warning, "rewriter doesn't support user-specified control flow semantics " "for @try/@finally (code may not execute properly)"); } ASTConsumer *clang::CreateObjCRewriter(const std::string& InFile, llvm::raw_ostream* OS, - Diagnostic &Diags, + Diagnostic &Diags, const LangOptions &LOpts, bool SilenceRewriteMacroWarning) { return new RewriteObjC(InFile, OS, Diags, LOpts, SilenceRewriteMacroWarning); @@ -462,15 +462,15 @@ void RewriteObjC::Initialize(ASTContext &context) { PropParentMap = 0; CurrentBody = 0; DisableReplaceStmt = false; - + // Get the ID and start/end of the main file. MainFileID = SM->getMainFileID(); const llvm::MemoryBuffer *MainBuf = SM->getBuffer(MainFileID); MainFileStart = MainBuf->getBufferStart(); MainFileEnd = MainBuf->getBufferEnd(); - + Rewrite.setSourceMgr(Context->getSourceManager(), Context->getLangOptions()); - + // declaring objc_selector outside the parameter list removes a silly // scope related warning... if (IsHeader) @@ -574,7 +574,7 @@ void RewriteObjC::HandleTopLevelSingleDecl(Decl *D) { // if we rewrote the #include/#import. SourceLocation Loc = D->getLocation(); Loc = SM->getInstantiationLoc(Loc); - + // If this is for a builtin, ignore it. if (Loc.isInvalid()) return; @@ -593,7 +593,7 @@ void RewriteObjC::HandleTopLevelSingleDecl(Decl *D) { RewriteCategoryDecl(CD); } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) { RewriteProtocolDecl(PD); - } else if (ObjCForwardProtocolDecl *FP = + } else if (ObjCForwardProtocolDecl *FP = dyn_cast<ObjCForwardProtocolDecl>(D)){ RewriteForwardProtocolDecl(FP); } else if (LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(D)) { @@ -619,7 +619,7 @@ void RewriteObjC::RewriteInclude() { const char *MainBufEnd = MainBuf.second; size_t ImportLen = strlen("import"); size_t IncludeLen = strlen("include"); - + // Loop over the whole file, looking for includes. for (const char *BufPtr = MainBufStart; BufPtr < MainBufEnd; ++BufPtr) { if (*BufPtr == '#') { @@ -630,7 +630,7 @@ void RewriteObjC::RewriteInclude() { return; if (!strncmp(BufPtr, "import", ImportLen)) { // replace import with include - SourceLocation ImportLoc = + SourceLocation ImportLoc = LocStart.getFileLocWithOffset(BufPtr-MainBufStart); ReplaceText(ImportLoc, ImportLen, "include", IncludeLen); BufPtr += ImportLen; @@ -643,27 +643,27 @@ void RewriteObjC::RewriteTabs() { std::pair<const char*, const char*> MainBuf = SM->getBufferData(MainFileID); const char *MainBufStart = MainBuf.first; const char *MainBufEnd = MainBuf.second; - + // Loop over the whole file, looking for tabs. for (const char *BufPtr = MainBufStart; BufPtr != MainBufEnd; ++BufPtr) { if (*BufPtr != '\t') continue; - + // Okay, we found a tab. This tab will turn into at least one character, // but it depends on which 'virtual column' it is in. Compute that now. unsigned VCol = 0; while (BufPtr-VCol != MainBufStart && BufPtr[-VCol-1] != '\t' && BufPtr[-VCol-1] != '\n' && BufPtr[-VCol-1] != '\r') ++VCol; - + // Okay, now that we know the virtual column, we know how many spaces to // insert. We assume 8-character tab-stops. unsigned Spaces = 8-(VCol & 7); - + // Get the location of the tab. SourceLocation TabLoc = SM->getLocForStartOfFile(MainFileID); TabLoc = TabLoc.getFileLocWithOffset(BufPtr-MainBufStart); - + // Rewrite the single tab character into a sequence of spaces. ReplaceText(TabLoc, 1, " ", Spaces); } @@ -693,35 +693,35 @@ void RewriteObjC::RewritePropertyImplDecl(ObjCPropertyImplDecl *PID, if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic) return; // FIXME: is this correct? - + // Generate the 'getter' function. ObjCPropertyDecl *PD = PID->getPropertyDecl(); ObjCInterfaceDecl *ClassDecl = PD->getGetterMethodDecl()->getClassInterface(); ObjCIvarDecl *OID = PID->getPropertyIvarDecl(); - + if (!OID) return; - + std::string Getr; RewriteObjCMethodDecl(PD->getGetterMethodDecl(), Getr); Getr += "{ "; // Synthesize an explicit cast to gain access to the ivar. - // FIXME: deal with code generation implications for various property - // attributes (copy, retain, nonatomic). + // FIXME: deal with code generation implications for various property + // attributes (copy, retain, nonatomic). // See objc-act.c:objc_synthesize_new_getter() for details. Getr += "return " + getIvarAccessString(ClassDecl, OID); Getr += "; }"; InsertText(onePastSemiLoc, Getr.c_str(), Getr.size()); if (PD->isReadOnly()) return; - + // Generate the 'setter' function. std::string Setr; RewriteObjCMethodDecl(PD->getSetterMethodDecl(), Setr); Setr += "{ "; // Synthesize an explicit cast to initialize the ivar. - // FIXME: deal with code generation implications for various property - // attributes (copy, retain, nonatomic). + // FIXME: deal with code generation implications for various property + // attributes (copy, retain, nonatomic). // See objc-act.c:objc_synthesize_new_setter() for details. Setr += getIvarAccessString(ClassDecl, OID) + " = "; Setr += PD->getNameAsCString(); @@ -734,7 +734,7 @@ void RewriteObjC::RewriteForwardClassDecl(ObjCClassDecl *ClassDecl) { SourceLocation startLoc = ClassDecl->getLocation(); const char *startBuf = SM->getCharacterData(startLoc); const char *semiPtr = strchr(startBuf, ';'); - + // Translate to typedef's that forward reference structs with the same name // as the class. As a convenience, we include the original declaration // as a comment. @@ -755,16 +755,16 @@ void RewriteObjC::RewriteForwardClassDecl(ObjCClassDecl *ClassDecl) { typedefString += ForwardDecl->getNameAsString(); typedefString += ";\n#endif\n"; } - + // Replace the @class with typedefs corresponding to the classes. - ReplaceText(startLoc, semiPtr-startBuf+1, + ReplaceText(startLoc, semiPtr-startBuf+1, typedefString.c_str(), typedefString.size()); } void RewriteObjC::RewriteMethodDeclaration(ObjCMethodDecl *Method) { SourceLocation LocStart = Method->getLocStart(); SourceLocation LocEnd = Method->getLocEnd(); - + if (SM->getInstantiationLineNumber(LocEnd) > SM->getInstantiationLineNumber(LocStart)) { InsertText(LocStart, "#if 0\n", 6); @@ -774,26 +774,25 @@ void RewriteObjC::RewriteMethodDeclaration(ObjCMethodDecl *Method) { } } -void RewriteObjC::RewriteProperty(ObjCPropertyDecl *prop) -{ +void RewriteObjC::RewriteProperty(ObjCPropertyDecl *prop) { SourceLocation Loc = prop->getLocation(); - + ReplaceText(Loc, 0, "// ", 3); - + // FIXME: handle properties that are declared across multiple lines. } void RewriteObjC::RewriteCategoryDecl(ObjCCategoryDecl *CatDecl) { SourceLocation LocStart = CatDecl->getLocStart(); - + // FIXME: handle category headers that are declared across multiple lines. ReplaceText(LocStart, 0, "// ", 3); - - for (ObjCCategoryDecl::instmeth_iterator - I = CatDecl->instmeth_begin(), E = CatDecl->instmeth_end(); + + for (ObjCCategoryDecl::instmeth_iterator + I = CatDecl->instmeth_begin(), E = CatDecl->instmeth_end(); I != E; ++I) RewriteMethodDeclaration(*I); - for (ObjCCategoryDecl::classmeth_iterator + for (ObjCCategoryDecl::classmeth_iterator I = CatDecl->classmeth_begin(), E = CatDecl->classmeth_end(); I != E; ++I) RewriteMethodDeclaration(*I); @@ -804,14 +803,14 @@ void RewriteObjC::RewriteCategoryDecl(ObjCCategoryDecl *CatDecl) { void RewriteObjC::RewriteProtocolDecl(ObjCProtocolDecl *PDecl) { std::pair<const char*, const char*> MainBuf = SM->getBufferData(MainFileID); - + SourceLocation LocStart = PDecl->getLocStart(); - + // FIXME: handle protocol headers that are declared across multiple lines. ReplaceText(LocStart, 0, "// ", 3); - - for (ObjCProtocolDecl::instmeth_iterator - I = PDecl->instmeth_begin(), E = PDecl->instmeth_end(); + + for (ObjCProtocolDecl::instmeth_iterator + I = PDecl->instmeth_begin(), E = PDecl->instmeth_end(); I != E; ++I) RewriteMethodDeclaration(*I); for (ObjCProtocolDecl::classmeth_iterator @@ -832,14 +831,14 @@ void RewriteObjC::RewriteProtocolDecl(ObjCProtocolDecl *PDecl) { SourceLocation OptionalLoc = LocStart.getFileLocWithOffset(p-startBuf); ReplaceText(OptionalLoc, strlen("@optional"), CommentedOptional.c_str(), CommentedOptional.size()); - + } else if (*p == '@' && !strncmp(p+1, "required", strlen("required"))) { std::string CommentedRequired = "/* @required */"; SourceLocation OptionalLoc = LocStart.getFileLocWithOffset(p-startBuf); ReplaceText(OptionalLoc, strlen("@required"), CommentedRequired.c_str(), CommentedRequired.size()); - + } } } @@ -852,7 +851,7 @@ void RewriteObjC::RewriteForwardProtocolDecl(ObjCForwardProtocolDecl *PDecl) { ReplaceText(LocStart, 0, "// ", 3); } -void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD, +void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD, std::string &ResultStr) { //fprintf(stderr,"In RewriteObjCMethodDecl\n"); const FunctionType *FPRetType = 0; @@ -876,24 +875,24 @@ void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD, } else ResultStr += OMD->getResultType().getAsString(); ResultStr += " "; - + // Unique method name std::string NameStr; - + if (OMD->isInstanceMethod()) NameStr += "_I_"; else NameStr += "_C_"; - + NameStr += OMD->getClassInterface()->getNameAsString(); NameStr += "_"; - - if (ObjCCategoryImplDecl *CID = + + if (ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext())) { NameStr += CID->getNameAsString(); NameStr += "_"; } - // Append selector names, replacing ':' with '_' + // Append selector names, replacing ':' with '_' { std::string selString = OMD->getSelector().getAsString(); int len = selString.size(); @@ -905,10 +904,10 @@ void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD, // Remember this name for metadata emission MethodInternalNames[OMD] = NameStr; ResultStr += NameStr; - + // Rewrite arguments ResultStr += "("; - + // invisible arguments if (OMD->isInstanceMethod()) { QualType selfTy = Context->getObjCInterfaceType(OMD->getClassInterface()); @@ -923,11 +922,11 @@ void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD, } else ResultStr += Context->getObjCClassType().getAsString(); - + ResultStr += " self, "; ResultStr += Context->getObjCSelType().getAsString(); ResultStr += " _cmd"; - + // Method arguments. for (ObjCMethodDecl::param_iterator PI = OMD->param_begin(), E = OMD->param_end(); PI != E; ++PI) { @@ -951,10 +950,10 @@ void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD, if (OMD->isVariadic()) ResultStr += ", ..."; ResultStr += ") "; - + if (FPRetType) { ResultStr += ")"; // close the precedence "scope" for "*". - + // Now, emit the argument types (if any). if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)) { ResultStr += "("; @@ -976,12 +975,12 @@ void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD, void RewriteObjC::RewriteImplementationDecl(Decl *OID) { ObjCImplementationDecl *IMD = dyn_cast<ObjCImplementationDecl>(OID); ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(OID); - + if (IMD) InsertText(IMD->getLocStart(), "// ", 3); else InsertText(CID->getLocStart(), "// ", 3); - + for (ObjCCategoryImplDecl::instmeth_iterator I = IMD ? IMD->instmeth_begin() : CID->instmeth_begin(), E = IMD ? IMD->instmeth_end() : CID->instmeth_end(); @@ -997,7 +996,7 @@ void RewriteObjC::RewriteImplementationDecl(Decl *OID) { ReplaceText(LocStart, endBuf-startBuf, ResultStr.c_str(), ResultStr.size()); } - + for (ObjCCategoryImplDecl::classmeth_iterator I = IMD ? IMD->classmeth_begin() : CID->classmeth_begin(), E = IMD ? IMD->classmeth_end() : CID->classmeth_end(); @@ -1007,15 +1006,15 @@ void RewriteObjC::RewriteImplementationDecl(Decl *OID) { RewriteObjCMethodDecl(OMD, ResultStr); SourceLocation LocStart = OMD->getLocStart(); SourceLocation LocEnd = OMD->getCompoundBody()->getLocStart(); - + const char *startBuf = SM->getCharacterData(LocStart); const char *endBuf = SM->getCharacterData(LocEnd); ReplaceText(LocStart, endBuf-startBuf, - ResultStr.c_str(), ResultStr.size()); + ResultStr.c_str(), ResultStr.size()); } for (ObjCCategoryImplDecl::propimpl_iterator I = IMD ? IMD->propimpl_begin() : CID->propimpl_begin(), - E = IMD ? IMD->propimpl_end() : CID->propimpl_end(); + E = IMD ? IMD->propimpl_end() : CID->propimpl_end(); I != E; ++I) { RewritePropertyImplDecl(*I, IMD, CID); } @@ -1023,7 +1022,7 @@ void RewriteObjC::RewriteImplementationDecl(Decl *OID) { if (IMD) InsertText(IMD->getLocEnd(), "// ", 3); else - InsertText(CID->getLocEnd(), "// ", 3); + InsertText(CID->getLocEnd(), "// ", 3); } void RewriteObjC::RewriteInterfaceDecl(ObjCInterfaceDecl *ClassDecl) { @@ -1043,16 +1042,16 @@ void RewriteObjC::RewriteInterfaceDecl(ObjCInterfaceDecl *ClassDecl) { ObjCForwardDecls.insert(ClassDecl); } SynthesizeObjCInternalStruct(ClassDecl, ResultStr); - - for (ObjCInterfaceDecl::prop_iterator I = ClassDecl->prop_begin(), + + for (ObjCInterfaceDecl::prop_iterator I = ClassDecl->prop_begin(), E = ClassDecl->prop_end(); I != E; ++I) RewriteProperty(*I); - for (ObjCInterfaceDecl::instmeth_iterator + for (ObjCInterfaceDecl::instmeth_iterator I = ClassDecl->instmeth_begin(), E = ClassDecl->instmeth_end(); I != E; ++I) RewriteMethodDeclaration(*I); - for (ObjCInterfaceDecl::classmeth_iterator - I = ClassDecl->classmeth_begin(), E = ClassDecl->classmeth_end(); + for (ObjCInterfaceDecl::classmeth_iterator + I = ClassDecl->classmeth_begin(), E = ClassDecl->classmeth_end(); I != E; ++I) RewriteMethodDeclaration(*I); @@ -1069,20 +1068,20 @@ Stmt *RewriteObjC::RewritePropertySetter(BinaryOperator *BinOp, Expr *newStmt, ObjCPropertyDecl *PDecl = PropRefExpr->getProperty(); llvm::SmallVector<Expr *, 1> ExprVec; ExprVec.push_back(newStmt); - + Stmt *Receiver = PropRefExpr->getBase(); ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(Receiver); if (PRE && PropGetters[PRE]) { // This allows us to handle chain/nested property getters. Receiver = PropGetters[PRE]; } - MsgExpr = new (Context) ObjCMessageExpr(dyn_cast<Expr>(Receiver), - PDecl->getSetterName(), PDecl->getType(), - PDecl->getSetterMethodDecl(), - SourceLocation(), SourceLocation(), + MsgExpr = new (Context) ObjCMessageExpr(dyn_cast<Expr>(Receiver), + PDecl->getSetterName(), PDecl->getType(), + PDecl->getSetterMethodDecl(), + SourceLocation(), SourceLocation(), &ExprVec[0], 1); Stmt *ReplacingStmt = SynthMessageExpr(MsgExpr); - + // Now do the actual rewrite. ReplaceStmtWithRange(BinOp, ReplacingStmt, SrcRange); //delete BinOp; @@ -1097,18 +1096,18 @@ Stmt *RewriteObjC::RewritePropertyGetter(ObjCPropertyRefExpr *PropRefExpr) { // This allows us to reuse all the fun and games in SynthMessageExpr(). ObjCMessageExpr *MsgExpr; ObjCPropertyDecl *PDecl = PropRefExpr->getProperty(); - + Stmt *Receiver = PropRefExpr->getBase(); - + ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(Receiver); if (PRE && PropGetters[PRE]) { // This allows us to handle chain/nested property getters. Receiver = PropGetters[PRE]; } - MsgExpr = new (Context) ObjCMessageExpr(dyn_cast<Expr>(Receiver), - PDecl->getGetterName(), PDecl->getType(), - PDecl->getGetterMethodDecl(), - SourceLocation(), SourceLocation(), + MsgExpr = new (Context) ObjCMessageExpr(dyn_cast<Expr>(Receiver), + PDecl->getGetterName(), PDecl->getType(), + PDecl->getGetterMethodDecl(), + SourceLocation(), SourceLocation(), 0, 0); Stmt *ReplacingStmt = SynthMessageExpr(MsgExpr); @@ -1127,7 +1126,7 @@ Stmt *RewriteObjC::RewritePropertyGetter(ObjCPropertyRefExpr *PropRefExpr) { return PropRefExpr; // return the original... } else { ReplaceStmt(PropRefExpr, ReplacingStmt); - // delete PropRefExpr; elsewhere... + // delete PropRefExpr; elsewhere... // NOTE: We don't want to call MsgExpr->Destroy(), as it holds references // to things that stay around. Context->Deallocate(MsgExpr); @@ -1135,7 +1134,7 @@ Stmt *RewriteObjC::RewritePropertyGetter(ObjCPropertyRefExpr *PropRefExpr) { } } -Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, +Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, SourceLocation OrigStart) { ObjCIvarDecl *D = IV->getDecl(); if (CurMethodDef) { @@ -1144,10 +1143,10 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, dyn_cast<ObjCInterfaceType>(pType->getPointeeType()); // lookup which class implements the instance variable. ObjCInterfaceDecl *clsDeclared = 0; - iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), + iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), clsDeclared); assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class"); - + // Synthesize an explicit cast to gain access to the ivar. std::string RecName = clsDeclared->getIdentifier()->getName(); RecName += "_IMPL"; @@ -1156,7 +1155,7 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, SourceLocation(), II); assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl"); QualType castT = Context->getPointerType(Context->getTagDeclType(RD)); - CastExpr *castExpr = new (Context) CStyleCastExpr(castT, + CastExpr *castExpr = new (Context) CStyleCastExpr(castT, CastExpr::CK_Unknown, IV->getBase(), castT,SourceLocation(), @@ -1165,7 +1164,7 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, ParenExpr *PE = new (Context) ParenExpr(IV->getBase()->getLocStart(), IV->getBase()->getLocEnd(), castExpr); - if (IV->isFreeIvar() && + if (IV->isFreeIvar() && CurMethodDef->getClassInterface() == iFaceDecl->getDecl()) { MemberExpr *ME = new (Context) MemberExpr(PE, true, D, IV->getLocation(), @@ -1174,27 +1173,27 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, // delete IV; leak for now, see RewritePropertySetter() usage for more info. return ME; } - + ReplaceStmt(IV->getBase(), PE); // Cannot delete IV->getBase(), since PE points to it. // Replace the old base with the cast. This is important when doing // embedded rewrites. For example, [newInv->_container addObject:0]. - IV->setBase(PE); + IV->setBase(PE); return IV; } } else { // we are outside a method. assert(!IV->isFreeIvar() && "Cannot have a free standing ivar outside a method"); - + // Explicit ivar refs need to have a cast inserted. // FIXME: consider sharing some of this code with the code above. if (const PointerType *pType = IV->getBase()->getType()->getAs<PointerType>()) { ObjCInterfaceType *iFaceDecl = dyn_cast<ObjCInterfaceType>(pType->getPointeeType()); // lookup which class implements the instance variable. ObjCInterfaceDecl *clsDeclared = 0; - iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), + iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), clsDeclared); assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class"); - + // Synthesize an explicit cast to gain access to the ivar. std::string RecName = clsDeclared->getIdentifier()->getName(); RecName += "_IMPL"; @@ -1203,7 +1202,7 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, SourceLocation(), II); assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl"); QualType castT = Context->getPointerType(Context->getTagDeclType(RD)); - CastExpr *castExpr = new (Context) CStyleCastExpr(castT, + CastExpr *castExpr = new (Context) CStyleCastExpr(castT, CastExpr::CK_Unknown, IV->getBase(), castT, SourceLocation(), @@ -1215,7 +1214,7 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, // Cannot delete IV->getBase(), since PE points to it. // Replace the old base with the cast. This is important when doing // embedded rewrites. For example, [newInv->_container addObject:0]. - IV->setBase(PE); + IV->setBase(PE); return IV; } } @@ -1225,10 +1224,10 @@ Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, /// SynthCountByEnumWithState - To print: /// ((unsigned int (*) /// (id, SEL, struct __objcFastEnumerationState *, id *, unsigned int)) -/// (void *)objc_msgSend)((id)l_collection, +/// (void *)objc_msgSend)((id)l_collection, /// sel_registerName( -/// "countByEnumeratingWithState:objects:count:"), -/// &enumState, +/// "countByEnumeratingWithState:objects:count:"), +/// &enumState, /// (id *)items, (unsigned int)16) /// void RewriteObjC::SynthCountByEnumWithState(std::string &buf) { @@ -1250,7 +1249,7 @@ Stmt *RewriteObjC::RewriteBreakStmt(BreakStmt *S) { return S; // replace break with goto __break_label std::string buf; - + SourceLocation startLoc = S->getLocStart(); buf = "goto __break_label_"; buf += utostr(ObjCBcLabelNo.back()); @@ -1267,39 +1266,39 @@ Stmt *RewriteObjC::RewriteContinueStmt(ContinueStmt *S) { return S; // replace continue with goto __continue_label std::string buf; - + SourceLocation startLoc = S->getLocStart(); buf = "goto __continue_label_"; buf += utostr(ObjCBcLabelNo.back()); ReplaceText(startLoc, strlen("continue"), buf.c_str(), buf.size()); - + return 0; } /// RewriteObjCForCollectionStmt - Rewriter for ObjC2's foreach statement. /// It rewrites: /// for ( type elem in collection) { stmts; } - + /// Into: /// { -/// type elem; +/// type elem; /// struct __objcFastEnumerationState enumState = { 0 }; /// id items[16]; /// id l_collection = (id)collection; -/// unsigned long limit = [l_collection countByEnumeratingWithState:&enumState +/// unsigned long limit = [l_collection countByEnumeratingWithState:&enumState /// objects:items count:16]; /// if (limit) { /// unsigned long startMutations = *enumState.mutationsPtr; /// do { /// unsigned long counter = 0; /// do { -/// if (startMutations != *enumState.mutationsPtr) +/// if (startMutations != *enumState.mutationsPtr) /// objc_enumerationMutation(l_collection); /// elem = (type)enumState.itemsPtr[counter++]; /// stmts; /// __continue_label: ; /// } while (counter < limit); -/// } while (limit = [l_collection countByEnumeratingWithState:&enumState +/// } while (limit = [l_collection countByEnumeratingWithState:&enumState /// objects:items count:16]); /// elem = nil; /// __break_label: ; @@ -1311,11 +1310,11 @@ Stmt *RewriteObjC::RewriteContinueStmt(ContinueStmt *S) { Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, SourceLocation OrigEnd) { assert(!Stmts.empty() && "ObjCForCollectionStmt - Statement stack empty"); - assert(isa<ObjCForCollectionStmt>(Stmts.back()) && + assert(isa<ObjCForCollectionStmt>(Stmts.back()) && "ObjCForCollectionStmt Statement stack mismatch"); - assert(!ObjCBcLabelNo.empty() && + assert(!ObjCBcLabelNo.empty() && "ObjCForCollectionStmt - Label No stack empty"); - + SourceLocation startLoc = S->getLocStart(); const char *startBuf = SM->getCharacterData(startLoc); const char *elementName; @@ -1336,10 +1335,10 @@ Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, else { DeclRefExpr *DR = cast<DeclRefExpr>(S->getElement()); elementName = DR->getDecl()->getNameAsCString(); - elementTypeAsString + elementTypeAsString = cast<ValueDecl>(DR->getDecl())->getType().getAsString(); } - + // struct __objcFastEnumerationState enumState = { 0 }; buf += "struct __objcFastEnumerationState enumState = { 0 };\n\t"; // id items[16]; @@ -1358,8 +1357,8 @@ Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, *(startCollectionBuf+3) != '[' && *(startCollectionBuf+3) != '(')) startCollectionBuf++; startCollectionBuf += 3; - - // Replace: "for (type element in" with string constructed thus far. + + // Replace: "for (type element in" with string constructed thus far. ReplaceText(startLoc, startCollectionBuf - startBuf, buf.c_str(), buf.size()); // Replace ')' in for '(' type elem in collection ')' with ';' @@ -1367,17 +1366,17 @@ Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, const char *rparenBuf = SM->getCharacterData(rightParenLoc); SourceLocation lparenLoc = startLoc.getFileLocWithOffset(rparenBuf-startBuf); buf = ";\n\t"; - + // unsigned long limit = [l_collection countByEnumeratingWithState:&enumState // objects:items count:16]; // which is synthesized into: - // unsigned int limit = + // unsigned int limit = // ((unsigned int (*) // (id, SEL, struct __objcFastEnumerationState *, id *, unsigned int)) - // (void *)objc_msgSend)((id)l_collection, + // (void *)objc_msgSend)((id)l_collection, // sel_registerName( - // "countByEnumeratingWithState:objects:count:"), - // (struct __objcFastEnumerationState *)&state, + // "countByEnumeratingWithState:objects:count:"), + // (struct __objcFastEnumerationState *)&state, // (id *)items, (unsigned int)16); buf += "unsigned long limit =\n\t\t"; SynthCountByEnumWithState(buf); @@ -1387,7 +1386,7 @@ Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, /// do { /// unsigned long counter = 0; /// do { - /// if (startMutations != *enumState.mutationsPtr) + /// if (startMutations != *enumState.mutationsPtr) /// objc_enumerationMutation(l_collection); /// elem = (type)enumState.itemsPtr[counter++]; buf += "if (limit) {\n\t"; @@ -1403,10 +1402,10 @@ Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, buf += ")enumState.itemsPtr[counter++];"; // Replace ')' in for '(' type elem in collection ')' with all of these. ReplaceText(lparenLoc, 1, buf.c_str(), buf.size()); - + /// __continue_label: ; /// } while (counter < limit); - /// } while (limit = [l_collection countByEnumeratingWithState:&enumState + /// } while (limit = [l_collection countByEnumeratingWithState:&enumState /// objects:items count:16]); /// elem = nil; /// __break_label: ; @@ -1414,7 +1413,7 @@ Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, /// else /// elem = nil; /// } - /// + /// buf = ";\n\t"; buf += "__continue_label_"; buf += utostr(ObjCBcLabelNo.back()); @@ -1434,7 +1433,7 @@ Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, buf += elementName; buf += " = ((id)0);\n"; buf += "}\n"; - + // Insert all these *after* the statement body. // FIXME: If this should support Obj-C++, support CXXTryStmt if (isa<CompoundStmt>(S->getBody())) { @@ -1459,7 +1458,7 @@ Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, return 0; } -/// RewriteObjCSynchronizedStmt - +/// RewriteObjCSynchronizedStmt - /// This routine rewrites @synchronized(expr) stmt; /// into: /// objc_sync_enter(expr); @@ -1469,16 +1468,16 @@ Stmt *RewriteObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) { // Get the start location and compute the semi location. SourceLocation startLoc = S->getLocStart(); const char *startBuf = SM->getCharacterData(startLoc); - + assert((*startBuf == '@') && "bogus @synchronized location"); - - std::string buf; + + std::string buf; buf = "objc_sync_enter((id)"; const char *lparenBuf = startBuf; while (*lparenBuf != '(') lparenBuf++; ReplaceText(startLoc, lparenBuf-startBuf+1, buf.c_str(), buf.size()); - // We can't use S->getSynchExpr()->getLocEnd() to find the end location, since - // the sync expression is typically a message expression that's already + // We can't use S->getSynchExpr()->getLocEnd() to find the end location, since + // the sync expression is typically a message expression that's already // been rewritten! (which implies the SourceLocation's are invalid). SourceLocation endLoc = S->getSynchBody()->getLocStart(); const char *endBuf = SM->getCharacterData(endLoc); @@ -1495,7 +1494,7 @@ Stmt *RewriteObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) { ReplaceText(rparenLoc, 1, buf.c_str(), buf.size()); startLoc = S->getSynchBody()->getLocEnd(); startBuf = SM->getCharacterData(startLoc); - + assert((*startBuf == '}') && "bogus @synchronized block"); SourceLocation lastCurlyLoc = startLoc; buf = "}\nelse {\n"; @@ -1504,9 +1503,9 @@ Stmt *RewriteObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) { buf += "{ /* implicit finally clause */\n"; buf += " if (!_rethrow) objc_exception_try_exit(&_stack);\n"; buf += " objc_sync_exit("; - Expr *syncExpr = new (Context) CStyleCastExpr(Context->getObjCIdType(), + Expr *syncExpr = new (Context) CStyleCastExpr(Context->getObjCIdType(), CastExpr::CK_Unknown, - S->getSynchExpr(), + S->getSynchExpr(), Context->getObjCIdType(), SourceLocation(), SourceLocation()); @@ -1519,21 +1518,21 @@ Stmt *RewriteObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) { buf += " if (_rethrow) objc_exception_throw(_rethrow);\n"; buf += "}\n"; buf += "}"; - + ReplaceText(lastCurlyLoc, 1, buf.c_str(), buf.size()); return 0; } -void RewriteObjC::WarnAboutReturnGotoContinueOrBreakStmts(Stmt *S) { +void RewriteObjC::WarnAboutReturnGotoContinueOrBreakStmts(Stmt *S) { // Perform a bottom up traversal of all children. for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end(); CI != E; ++CI) if (*CI) WarnAboutReturnGotoContinueOrBreakStmts(*CI); - if (isa<ReturnStmt>(S) || isa<ContinueStmt>(S) || + if (isa<ReturnStmt>(S) || isa<ContinueStmt>(S) || isa<BreakStmt>(S) || isa<GotoStmt>(S)) { - Diags.Report(Context->getFullLoc(S->getLocStart()), + Diags.Report(Context->getFullLoc(S->getLocStart()), TryFinallyContainsReturnDiag); } return; @@ -1543,7 +1542,7 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { // Get the start location and compute the semi location. SourceLocation startLoc = S->getLocStart(); const char *startBuf = SM->getCharacterData(startLoc); - + assert((*startBuf == '@') && "bogus @try location"); std::string buf; @@ -1556,12 +1555,12 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { buf += "if (!_setjmp(_stack.buf)) /* @try block continue */\n"; ReplaceText(startLoc, 4, buf.c_str(), buf.size()); - + startLoc = S->getTryBody()->getLocEnd(); startBuf = SM->getCharacterData(startLoc); assert((*startBuf == '}') && "bogus @try block"); - + SourceLocation lastCurlyLoc = startLoc; ObjCAtCatchStmt *catchList = S->getCatchStmts(); if (catchList) { @@ -1572,7 +1571,7 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { buf += " if (_setjmp(_stack.buf))\n"; buf += " _rethrow = objc_exception_extract(&_stack);\n"; buf += " else { /* @catch continue */"; - + InsertText(startLoc, buf.c_str(), buf.size()); } else { /* no catch list */ buf = "}\nelse {\n"; @@ -1585,15 +1584,15 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { while (catchList) { ParmVarDecl *catchDecl = catchList->getCatchParamDecl(); - if (catchList == S->getCatchStmts()) + if (catchList == S->getCatchStmts()) buf = "if ("; // we are generating code for the first catch clause else buf = "else if ("; startLoc = catchList->getLocStart(); startBuf = SM->getCharacterData(startLoc); - + assert((*startBuf == '@') && "bogus @catch location"); - + const char *lParenLoc = strchr(startBuf, '('); if (catchList->hasEllipsis()) { @@ -1604,7 +1603,7 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { assert(*SM->getCharacterData(catchList->getRParenLoc()) == ')' && "bogus @catch paren location"); assert((*bodyBuf == '{') && "bogus @catch body location"); - + buf += "1) { id _tmp = _caught;"; Rewrite.ReplaceText(startLoc, bodyBuf-startBuf+1, buf); } else if (catchDecl) { @@ -1613,9 +1612,9 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { buf += "1) { "; ReplaceText(startLoc, lParenLoc-startBuf+1, buf.c_str(), buf.size()); sawIdTypedCatch = true; - } else if (const PointerType *pType = t->getAs<PointerType>()) { + } else if (const PointerType *pType = t->getAs<PointerType>()) { ObjCInterfaceType *cls; // Should be a pointer to a class. - + cls = dyn_cast<ObjCInterfaceType>(pType->getPointeeType().getTypePtr()); if (cls) { buf += "objc_exception_match((struct objc_class *)objc_getClass(\""; @@ -1632,9 +1631,9 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { const char *rParenBuf = SM->getCharacterData(rParenLoc); assert((*rParenBuf == ')') && "bogus @catch paren location"); assert((*bodyBuf == '{') && "bogus @catch body location"); - + buf = " = _caught;"; - // Here we replace ") {" with "= _caught;" (which initializes and + // Here we replace ") {" with "= _caught;" (which initializes and // declares the @catch parameter). ReplaceText(rParenLoc, bodyBuf-rParenBuf+1, buf.c_str(), buf.size()); } else { @@ -1648,7 +1647,7 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { SourceLocation bodyLoc = lastCatchBody->getLocEnd(); assert(*SM->getCharacterData(bodyLoc) == '}' && "bogus @catch body location"); - + // Insert the last (implicit) else clause *before* the right curly brace. bodyLoc = bodyLoc.getFileLocWithOffset(-1); buf = "} /* last catch end */\n"; @@ -1659,7 +1658,7 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { if (!S->getFinallyStmt()) buf += "}\n"; InsertText(bodyLoc, buf.c_str(), buf.size()); - + // Set lastCurlyLoc lastCurlyLoc = lastCatchBody->getLocEnd(); } @@ -1667,28 +1666,28 @@ Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { startLoc = finalStmt->getLocStart(); startBuf = SM->getCharacterData(startLoc); assert((*startBuf == '@') && "bogus @finally start"); - + buf = "/* @finally */"; ReplaceText(startLoc, 8, buf.c_str(), buf.size()); - + Stmt *body = finalStmt->getFinallyBody(); SourceLocation startLoc = body->getLocStart(); SourceLocation endLoc = body->getLocEnd(); assert(*SM->getCharacterData(startLoc) == '{' && "bogus @finally body location"); - assert(*SM->getCharacterData(endLoc) == '}' && + assert(*SM->getCharacterData(endLoc) == '}' && "bogus @finally body location"); - + startLoc = startLoc.getFileLocWithOffset(1); buf = " if (!_rethrow) objc_exception_try_exit(&_stack);\n"; InsertText(startLoc, buf.c_str(), buf.size()); endLoc = endLoc.getFileLocWithOffset(-1); buf = " if (_rethrow) objc_exception_throw(_rethrow);\n"; InsertText(endLoc, buf.c_str(), buf.size()); - + // Set lastCurlyLoc lastCurlyLoc = body->getLocEnd(); - + // Now check for any return/continue/go statements within the @try. WarnAboutReturnGotoContinueOrBreakStmts(S->getTryBody()); } else { /* no finally clause - make sure we synthesize an implicit one */ @@ -1713,14 +1712,14 @@ Stmt *RewriteObjC::RewriteObjCFinallyStmt(ObjCAtFinallyStmt *S) { return 0; } -// This can't be done with ReplaceStmt(S, ThrowExpr), since -// the throw expression is typically a message expression that's already +// This can't be done with ReplaceStmt(S, ThrowExpr), since +// the throw expression is typically a message expression that's already // been rewritten! (which implies the SourceLocation's are invalid). Stmt *RewriteObjC::RewriteObjCThrowStmt(ObjCAtThrowStmt *S) { // Get the start location and compute the semi location. SourceLocation startLoc = S->getLocStart(); const char *startBuf = SM->getCharacterData(startLoc); - + assert((*startBuf == '@') && "bogus @throw location"); std::string buf; @@ -1729,12 +1728,12 @@ Stmt *RewriteObjC::RewriteObjCThrowStmt(ObjCAtThrowStmt *S) { buf = "objc_exception_throw("; else // add an implicit argument buf = "objc_exception_throw(_caught"; - + // handle "@ throw" correctly. const char *wBuf = strchr(startBuf, 'w'); assert((*wBuf == 'w') && "@throw: can't find 'w'"); ReplaceText(startLoc, wBuf-startBuf+1, buf.c_str(), buf.size()); - + const char *semiBuf = strchr(startBuf, ';'); assert((*semiBuf == ';') && "@throw: can't find ';'"); SourceLocation semiLoc = startLoc.getFileLocWithOffset(semiBuf-startBuf); @@ -1752,7 +1751,7 @@ Stmt *RewriteObjC::RewriteAtEncode(ObjCEncodeExpr *Exp) { StrEncoding.length(), false,StrType, SourceLocation()); ReplaceStmt(Exp, Replacement); - + // Replace this subexpr in the parent. // delete Exp; leak for now, see RewritePropertySetter() usage for more info. return Replacement; @@ -1765,7 +1764,7 @@ Stmt *RewriteObjC::RewriteAtSelector(ObjCSelectorExpr *Exp) { // Create a call to sel_registerName("selName"). llvm::SmallVector<Expr*, 8> SelExprs; QualType argType = Context->getPointerType(Context->CharTy); - SelExprs.push_back(StringLiteral::Create(*Context, + SelExprs.push_back(StringLiteral::Create(*Context, Exp->getSelector().getAsString().c_str(), Exp->getSelector().getAsString().size(), false, argType, SourceLocation())); @@ -1780,19 +1779,19 @@ CallExpr *RewriteObjC::SynthesizeCallToFunctionDecl( FunctionDecl *FD, Expr **args, unsigned nargs) { // Get the type, we will need to reference it in a couple spots. QualType msgSendType = FD->getType(); - + // Create a reference to the objc_msgSend() declaration. DeclRefExpr *DRE = new (Context) DeclRefExpr(FD, msgSendType, SourceLocation()); - + // Now, we cast the reference to a pointer to the objc_msgSend type. QualType pToFunc = Context->getPointerType(msgSendType); - ImplicitCastExpr *ICE = new (Context) ImplicitCastExpr(pToFunc, + ImplicitCastExpr *ICE = new (Context) ImplicitCastExpr(pToFunc, CastExpr::CK_Unknown, - DRE, + DRE, /*isLvalue=*/false); - + const FunctionType *FT = msgSendType->getAsFunctionType(); - + return new (Context) CallExpr(*Context, ICE, args, nargs, FT->getResultType(), SourceLocation()); } @@ -1834,7 +1833,7 @@ void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Expr *E) { QualType Type = E->getType(); if (needToScanForQualifiers(Type)) { SourceLocation Loc, EndLoc; - + if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E)) { Loc = ECE->getLParenLoc(); EndLoc = ECE->getRParenLoc(); @@ -1881,10 +1880,10 @@ void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Decl *Dcl) { } else return; - + if (needToScanForQualifiers(Type)) { // Since types are unique, we need to scan the buffer. - + const char *endBuf = SM->getCharacterData(Loc); const char *startBuf = endBuf; while (*startBuf != ';' && *startBuf != '<' && startBuf != MainFileStart) @@ -1907,16 +1906,16 @@ void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Decl *Dcl) { for (unsigned i = 0; i < proto->getNumArgs(); i++) { if (needToScanForQualifiers(proto->getArgType(i))) { // Since types are unique, we need to scan the buffer. - + const char *endBuf = startBuf; // scan forward (from the decl location) for argument types. scanToNextArgument(endBuf); const char *startRef = 0, *endRef = 0; if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) { // Get the locations of the startRef, endRef. - SourceLocation LessLoc = + SourceLocation LessLoc = Loc.getFileLocWithOffset(startRef-startFuncBuf); - SourceLocation GreaterLoc = + SourceLocation GreaterLoc = Loc.getFileLocWithOffset(endRef-startFuncBuf+1); // Comment out the protocol references. InsertText(LessLoc, "/*", 2); @@ -1944,7 +1943,7 @@ void RewriteObjC::SynthSelGetUidFunctionDecl() { &ArgTys[0], ArgTys.size(), false /*isVariadic*/, 0); SelGetUidFunctionDecl = FunctionDecl::Create(*Context, TUDecl, - SourceLocation(), + SourceLocation(), SelGetUidIdent, getFuncType, 0, FunctionDecl::Extern, false); } @@ -1973,7 +1972,7 @@ void RewriteObjC::SynthSuperContructorFunctionDecl() { &ArgTys[0], ArgTys.size(), false, 0); SuperContructorFunctionDecl = FunctionDecl::Create(*Context, TUDecl, - SourceLocation(), + SourceLocation(), msgSendIdent, msgSendType, 0, FunctionDecl::Extern, false); } @@ -2014,7 +2013,7 @@ void RewriteObjC::SynthMsgSendSuperFunctionDecl() { &ArgTys[0], ArgTys.size(), true /*isVariadic*/, 0); MsgSendSuperFunctionDecl = FunctionDecl::Create(*Context, TUDecl, - SourceLocation(), + SourceLocation(), msgSendIdent, msgSendType, 0, FunctionDecl::Extern, false); } @@ -2033,15 +2032,15 @@ void RewriteObjC::SynthMsgSendStretFunctionDecl() { &ArgTys[0], ArgTys.size(), true /*isVariadic*/, 0); MsgSendStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl, - SourceLocation(), + SourceLocation(), msgSendIdent, msgSendType, 0, FunctionDecl::Extern, false); } -// SynthMsgSendSuperStretFunctionDecl - +// SynthMsgSendSuperStretFunctionDecl - // id objc_msgSendSuper_stret(struct objc_super *, SEL op, ...); void RewriteObjC::SynthMsgSendSuperStretFunctionDecl() { - IdentifierInfo *msgSendIdent = + IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSendSuper_stret"); llvm::SmallVector<QualType, 16> ArgTys; RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl, @@ -2057,7 +2056,7 @@ void RewriteObjC::SynthMsgSendSuperStretFunctionDecl() { &ArgTys[0], ArgTys.size(), true /*isVariadic*/, 0); MsgSendSuperStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl, - SourceLocation(), + SourceLocation(), msgSendIdent, msgSendType, 0, FunctionDecl::Extern, false); } @@ -2076,7 +2075,7 @@ void RewriteObjC::SynthMsgSendFpretFunctionDecl() { &ArgTys[0], ArgTys.size(), true /*isVariadic*/, 0); MsgSendFpretFunctionDecl = FunctionDecl::Create(*Context, TUDecl, - SourceLocation(), + SourceLocation(), msgSendIdent, msgSendType, 0, FunctionDecl::Extern, false); } @@ -2091,7 +2090,7 @@ void RewriteObjC::SynthGetClassFunctionDecl() { &ArgTys[0], ArgTys.size(), false /*isVariadic*/, 0); GetClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl, - SourceLocation(), + SourceLocation(), getClassIdent, getClassType, 0, FunctionDecl::Extern, false); } @@ -2106,7 +2105,7 @@ void RewriteObjC::SynthGetMetaClassFunctionDecl() { &ArgTys[0], ArgTys.size(), false /*isVariadic*/, 0); GetMetaClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl, - SourceLocation(), + SourceLocation(), getClassIdent, getClassType, 0, FunctionDecl::Extern, false); } @@ -2140,19 +2139,19 @@ Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) { Preamble += ","; // The minus 2 removes the begin/end double quotes. Preamble += utostr(prettyBuf.str().size()-2) + "};\n"; - - VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(), - &Context->Idents.get(S.c_str()), strType, 0, + + VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(), + &Context->Idents.get(S.c_str()), strType, 0, VarDecl::Static); DeclRefExpr *DRE = new (Context) DeclRefExpr(NewVD, strType, SourceLocation()); Expr *Unop = new (Context) UnaryOperator(DRE, UnaryOperator::AddrOf, - Context->getPointerType(DRE->getType()), + Context->getPointerType(DRE->getType()), SourceLocation()); // cast to NSConstantString * - CastExpr *cast = new (Context) CStyleCastExpr(Exp->getType(), + CastExpr *cast = new (Context) CStyleCastExpr(Exp->getType(), CastExpr::CK_Unknown, - Unop, Exp->getType(), - SourceLocation(), + Unop, Exp->getType(), + SourceLocation(), SourceLocation()); ReplaceStmt(Exp, cast); // delete Exp; leak for now, see RewritePropertySetter() usage for more info. @@ -2162,9 +2161,9 @@ Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) { ObjCInterfaceDecl *RewriteObjC::isSuperReceiver(Expr *recExpr) { // check if we are sending a message to 'super' if (!CurMethodDef || !CurMethodDef->isInstanceMethod()) return 0; - + if (ObjCSuperExpr *Super = dyn_cast<ObjCSuperExpr>(recExpr)) { - const ObjCObjectPointerType *OPT = + const ObjCObjectPointerType *OPT = Super->getType()->getAsObjCObjectPointerType(); assert(OPT); const ObjCInterfaceType *IT = OPT->getInterfaceType(); @@ -2177,24 +2176,24 @@ ObjCInterfaceDecl *RewriteObjC::isSuperReceiver(Expr *recExpr) { QualType RewriteObjC::getSuperStructType() { if (!SuperStructDecl) { SuperStructDecl = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl, - SourceLocation(), + SourceLocation(), &Context->Idents.get("objc_super")); QualType FieldTypes[2]; - + // struct objc_object *receiver; - FieldTypes[0] = Context->getObjCIdType(); + FieldTypes[0] = Context->getObjCIdType(); // struct objc_class *super; - FieldTypes[1] = Context->getObjCClassType(); + FieldTypes[1] = Context->getObjCClassType(); // Create fields for (unsigned i = 0; i < 2; ++i) { - SuperStructDecl->addDecl(FieldDecl::Create(*Context, SuperStructDecl, - SourceLocation(), 0, + SuperStructDecl->addDecl(FieldDecl::Create(*Context, SuperStructDecl, + SourceLocation(), 0, FieldTypes[i], 0, /*BitWidth=*/0, /*Mutable=*/false)); } - + SuperStructDecl->completeDefinition(*Context); } return Context->getTagDeclType(SuperStructDecl); @@ -2203,23 +2202,23 @@ QualType RewriteObjC::getSuperStructType() { QualType RewriteObjC::getConstantStringStructType() { if (!ConstantStringDecl) { ConstantStringDecl = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl, - SourceLocation(), + SourceLocation(), &Context->Idents.get("__NSConstantStringImpl")); QualType FieldTypes[4]; - + // struct objc_object *receiver; - FieldTypes[0] = Context->getObjCIdType(); + FieldTypes[0] = Context->getObjCIdType(); // int flags; - FieldTypes[1] = Context->IntTy; + FieldTypes[1] = Context->IntTy; // char *str; - FieldTypes[2] = Context->getPointerType(Context->CharTy); + FieldTypes[2] = Context->getPointerType(Context->CharTy); // long length; - FieldTypes[3] = Context->LongTy; + FieldTypes[3] = Context->LongTy; // Create fields for (unsigned i = 0; i < 4; ++i) { - ConstantStringDecl->addDecl(FieldDecl::Create(*Context, - ConstantStringDecl, + ConstantStringDecl->addDecl(FieldDecl::Create(*Context, + ConstantStringDecl, SourceLocation(), 0, FieldTypes[i], 0, /*BitWidth=*/0, @@ -2248,7 +2247,7 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { SynthGetClassFunctionDecl(); if (!GetMetaClassFunctionDecl) SynthGetMetaClassFunctionDecl(); - + // default to objc_msgSend(). FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl; // May need to use objc_msgSend_stret() as well. @@ -2260,11 +2259,11 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { else if (resultType->isRealFloatingType()) MsgSendFlavor = MsgSendFpretFunctionDecl; } - + // Synthesize a call to objc_msgSend(). llvm::SmallVector<Expr*, 8> MsgExprs; IdentifierInfo *clsName = Exp->getClassName(); - + // Derive/push the receiver/selector, 2 implicit arguments to objc_msgSend(). if (clsName) { // class message. // FIXME: We need to fix Sema (and the AST for ObjCMessageExpr) to handle @@ -2274,17 +2273,17 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { if (MsgSendStretFlavor) MsgSendStretFlavor = MsgSendSuperStretFunctionDecl; assert(MsgSendFlavor && "MsgSendFlavor is NULL!"); - - ObjCInterfaceDecl *SuperDecl = + + ObjCInterfaceDecl *SuperDecl = CurMethodDef->getClassInterface()->getSuperClass(); llvm::SmallVector<Expr*, 4> InitExprs; - + // set the receiver to self, the first argument to all methods. InitExprs.push_back( - new (Context) CStyleCastExpr(Context->getObjCIdType(), + new (Context) CStyleCastExpr(Context->getObjCIdType(), CastExpr::CK_Unknown, - new (Context) DeclRefExpr(CurMethodDef->getSelfDecl(), + new (Context) DeclRefExpr(CurMethodDef->getSelfDecl(), Context->getObjCIdType(), SourceLocation()), Context->getObjCIdType(), @@ -2293,29 +2292,29 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { llvm::SmallVector<Expr*, 8> ClsExprs; QualType argType = Context->getPointerType(Context->CharTy); ClsExprs.push_back(StringLiteral::Create(*Context, - SuperDecl->getIdentifier()->getName(), + SuperDecl->getIdentifier()->getName(), SuperDecl->getIdentifier()->getLength(), false, argType, SourceLocation())); CallExpr *Cls = SynthesizeCallToFunctionDecl(GetMetaClassFunctionDecl, - &ClsExprs[0], + &ClsExprs[0], ClsExprs.size()); // To turn off a warning, type-cast to 'id' InitExprs.push_back( // set 'super class', using objc_getClass(). - new (Context) CStyleCastExpr(Context->getObjCIdType(), + new (Context) CStyleCastExpr(Context->getObjCIdType(), CastExpr::CK_Unknown, Cls, Context->getObjCIdType(), - SourceLocation(), SourceLocation())); + SourceLocation(), SourceLocation())); // struct objc_super QualType superType = getSuperStructType(); Expr *SuperRep; - + if (LangOpts.Microsoft) { SynthSuperContructorFunctionDecl(); // Simulate a contructor call... - DeclRefExpr *DRE = new (Context) DeclRefExpr(SuperContructorFunctionDecl, + DeclRefExpr *DRE = new (Context) DeclRefExpr(SuperContructorFunctionDecl, superType, SourceLocation()); SuperRep = new (Context) CallExpr(*Context, DRE, &InitExprs[0], - InitExprs.size(), + InitExprs.size(), superType, SourceLocation()); // The code for super is a little tricky to prevent collision with // the structure definition in the header. The rewriter has it's own @@ -2324,22 +2323,22 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { // (struct objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER")) // SuperRep = new (Context) UnaryOperator(SuperRep, UnaryOperator::AddrOf, - Context->getPointerType(SuperRep->getType()), + Context->getPointerType(SuperRep->getType()), SourceLocation()); - SuperRep = new (Context) CStyleCastExpr(Context->getPointerType(superType), - CastExpr::CK_Unknown, SuperRep, + SuperRep = new (Context) CStyleCastExpr(Context->getPointerType(superType), + CastExpr::CK_Unknown, SuperRep, Context->getPointerType(superType), - SourceLocation(), SourceLocation()); - } else { + SourceLocation(), SourceLocation()); + } else { // (struct objc_super) { <exprs from above> } - InitListExpr *ILE = new (Context) InitListExpr(SourceLocation(), - &InitExprs[0], InitExprs.size(), + InitListExpr *ILE = new (Context) InitListExpr(SourceLocation(), + &InitExprs[0], InitExprs.size(), SourceLocation()); SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superType, ILE, false); // struct objc_super * SuperRep = new (Context) UnaryOperator(SuperRep, UnaryOperator::AddrOf, - Context->getPointerType(SuperRep->getType()), + Context->getPointerType(SuperRep->getType()), SourceLocation()); } MsgExprs.push_back(SuperRep); @@ -2347,12 +2346,12 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { llvm::SmallVector<Expr*, 8> ClsExprs; QualType argType = Context->getPointerType(Context->CharTy); ClsExprs.push_back(StringLiteral::Create(*Context, - clsName->getName(), + clsName->getName(), clsName->getLength(), false, argType, SourceLocation())); CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, - &ClsExprs[0], + &ClsExprs[0], ClsExprs.size()); MsgExprs.push_back(Cls); } @@ -2364,44 +2363,44 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { if (MsgSendStretFlavor) MsgSendStretFlavor = MsgSendSuperStretFunctionDecl; assert(MsgSendFlavor && "MsgSendFlavor is NULL!"); - + llvm::SmallVector<Expr*, 4> InitExprs; - + InitExprs.push_back( - new (Context) CStyleCastExpr(Context->getObjCIdType(), + new (Context) CStyleCastExpr(Context->getObjCIdType(), CastExpr::CK_Unknown, - new (Context) DeclRefExpr(CurMethodDef->getSelfDecl(), + new (Context) DeclRefExpr(CurMethodDef->getSelfDecl(), Context->getObjCIdType(), SourceLocation()), Context->getObjCIdType(), SourceLocation(), SourceLocation())); // set the 'receiver'. - + llvm::SmallVector<Expr*, 8> ClsExprs; QualType argType = Context->getPointerType(Context->CharTy); - ClsExprs.push_back(StringLiteral::Create(*Context, - SuperDecl->getIdentifier()->getName(), + ClsExprs.push_back(StringLiteral::Create(*Context, + SuperDecl->getIdentifier()->getName(), SuperDecl->getIdentifier()->getLength(), false, argType, SourceLocation())); CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, - &ClsExprs[0], + &ClsExprs[0], ClsExprs.size()); // To turn off a warning, type-cast to 'id' InitExprs.push_back( // set 'super class', using objc_getClass(). - new (Context) CStyleCastExpr(Context->getObjCIdType(), + new (Context) CStyleCastExpr(Context->getObjCIdType(), CastExpr::CK_Unknown, - Cls, Context->getObjCIdType(), SourceLocation(), SourceLocation())); + Cls, Context->getObjCIdType(), SourceLocation(), SourceLocation())); // struct objc_super QualType superType = getSuperStructType(); Expr *SuperRep; - + if (LangOpts.Microsoft) { SynthSuperContructorFunctionDecl(); // Simulate a contructor call... - DeclRefExpr *DRE = new (Context) DeclRefExpr(SuperContructorFunctionDecl, + DeclRefExpr *DRE = new (Context) DeclRefExpr(SuperContructorFunctionDecl, superType, SourceLocation()); SuperRep = new (Context) CallExpr(*Context, DRE, &InitExprs[0], - InitExprs.size(), + InitExprs.size(), superType, SourceLocation()); // The code for super is a little tricky to prevent collision with // the structure definition in the header. The rewriter has it's own @@ -2410,16 +2409,16 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { // (struct objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER")) // SuperRep = new (Context) UnaryOperator(SuperRep, UnaryOperator::AddrOf, - Context->getPointerType(SuperRep->getType()), + Context->getPointerType(SuperRep->getType()), SourceLocation()); - SuperRep = new (Context) CStyleCastExpr(Context->getPointerType(superType), + SuperRep = new (Context) CStyleCastExpr(Context->getPointerType(superType), CastExpr::CK_Unknown, SuperRep, Context->getPointerType(superType), - SourceLocation(), SourceLocation()); + SourceLocation(), SourceLocation()); } else { // (struct objc_super) { <exprs from above> } - InitListExpr *ILE = new (Context) InitListExpr(SourceLocation(), - &InitExprs[0], InitExprs.size(), + InitListExpr *ILE = new (Context) InitListExpr(SourceLocation(), + &InitExprs[0], InitExprs.size(), SourceLocation()); SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superType, ILE, false); } @@ -2429,9 +2428,9 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { // Foo<Proto> *. while (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(recExpr)) recExpr = CE->getSubExpr(); - recExpr = new (Context) CStyleCastExpr(Context->getObjCIdType(), + recExpr = new (Context) CStyleCastExpr(Context->getObjCIdType(), CastExpr::CK_Unknown, recExpr, - Context->getObjCIdType(), + Context->getObjCIdType(), SourceLocation(), SourceLocation()); MsgExprs.push_back(recExpr); } @@ -2439,14 +2438,14 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { // Create a call to sel_registerName("selName"), it will be the 2nd argument. llvm::SmallVector<Expr*, 8> SelExprs; QualType argType = Context->getPointerType(Context->CharTy); - SelExprs.push_back(StringLiteral::Create(*Context, + SelExprs.push_back(StringLiteral::Create(*Context, Exp->getSelector().getAsString().c_str(), Exp->getSelector().getAsString().size(), false, argType, SourceLocation())); CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl, &SelExprs[0], SelExprs.size()); MsgExprs.push_back(SelExp); - + // Now push any user supplied arguments. for (unsigned i = 0; i < Exp->getNumArgs(); i++) { Expr *userExpr = Exp->getArg(i); @@ -2457,7 +2456,7 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { ? Context->getObjCIdType() : ICE->getType(); userExpr = new (Context) CStyleCastExpr(type, CastExpr::CK_Unknown, - userExpr, type, SourceLocation(), + userExpr, type, SourceLocation(), SourceLocation()); } // Make id<P...> cast into an 'id' cast. @@ -2465,12 +2464,12 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { if (CE->getType()->isObjCQualifiedIdType()) { while ((CE = dyn_cast<CStyleCastExpr>(userExpr))) userExpr = CE->getSubExpr(); - userExpr = new (Context) CStyleCastExpr(Context->getObjCIdType(), + userExpr = new (Context) CStyleCastExpr(Context->getObjCIdType(), CastExpr::CK_Unknown, - userExpr, Context->getObjCIdType(), + userExpr, Context->getObjCIdType(), SourceLocation(), SourceLocation()); } - } + } MsgExprs.push_back(userExpr); // We've transferred the ownership to MsgExprs. For now, we *don't* null // out the argument in the original expression (since we aren't deleting @@ -2481,7 +2480,7 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { CastExpr *cast; llvm::SmallVector<QualType, 8> ArgTypes; QualType returnType; - + // Push 'id' and 'SEL', the 2 implicit arguments. if (MsgSendFlavor == MsgSendSuperFunctionDecl) ArgTypes.push_back(Context->getPointerType(getSuperStructType())); @@ -2493,7 +2492,7 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { for (ObjCMethodDecl::param_iterator PI = OMD->param_begin(), E = OMD->param_end(); PI != E; ++PI) { QualType t = (*PI)->getType()->isObjCQualifiedIdType() - ? Context->getObjCIdType() + ? Context->getObjCIdType() : (*PI)->getType(); // Make sure we convert "t (^)(...)" to "t (*)(...)". if (isTopLevelBlockPointerType(t)) { @@ -2509,36 +2508,36 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { } // Get the type, we will need to reference it in a couple spots. QualType msgSendType = MsgSendFlavor->getType(); - + // Create a reference to the objc_msgSend() declaration. - DeclRefExpr *DRE = new (Context) DeclRefExpr(MsgSendFlavor, msgSendType, + DeclRefExpr *DRE = new (Context) DeclRefExpr(MsgSendFlavor, msgSendType, SourceLocation()); - // Need to cast objc_msgSend to "void *" (to workaround a GCC bandaid). + // Need to cast objc_msgSend to "void *" (to workaround a GCC bandaid). // If we don't do this cast, we get the following bizarre warning/note: // xx.m:13: warning: function called through a non-compatible type // xx.m:13: note: if this code is reached, the program will abort - cast = new (Context) CStyleCastExpr(Context->getPointerType(Context->VoidTy), - CastExpr::CK_Unknown, DRE, + cast = new (Context) CStyleCastExpr(Context->getPointerType(Context->VoidTy), + CastExpr::CK_Unknown, DRE, Context->getPointerType(Context->VoidTy), SourceLocation(), SourceLocation()); - + // Now do the "normal" pointer to function cast. - QualType castType = Context->getFunctionType(returnType, + QualType castType = Context->getFunctionType(returnType, &ArgTypes[0], ArgTypes.size(), // If we don't have a method decl, force a variadic cast. Exp->getMethodDecl() ? Exp->getMethodDecl()->isVariadic() : true, 0); castType = Context->getPointerType(castType); - cast = new (Context) CStyleCastExpr(castType, CastExpr::CK_Unknown, cast, - castType, SourceLocation(), + cast = new (Context) CStyleCastExpr(castType, CastExpr::CK_Unknown, cast, + castType, SourceLocation(), SourceLocation()); // Don't forget the parens to enforce the proper binding. ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), cast); - + const FunctionType *FT = msgSendType->getAsFunctionType(); CallExpr *CE = new (Context) CallExpr(*Context, PE, &MsgExprs[0], - MsgExprs.size(), + MsgExprs.size(), FT->getResultType(), SourceLocation()); Stmt *ReplacingStmt = CE; if (MsgSendStretFlavor) { @@ -2546,33 +2545,33 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { // call to objc_msgSend_stret and hang both varieties on a conditional // expression which dictate which one to envoke depending on size of // method's return type. - + // Create a reference to the objc_msgSend_stret() declaration. - DeclRefExpr *STDRE = new (Context) DeclRefExpr(MsgSendStretFlavor, msgSendType, + DeclRefExpr *STDRE = new (Context) DeclRefExpr(MsgSendStretFlavor, msgSendType, SourceLocation()); // Need to cast objc_msgSend_stret to "void *" (see above comment). - cast = new (Context) CStyleCastExpr(Context->getPointerType(Context->VoidTy), - CastExpr::CK_Unknown, STDRE, + cast = new (Context) CStyleCastExpr(Context->getPointerType(Context->VoidTy), + CastExpr::CK_Unknown, STDRE, Context->getPointerType(Context->VoidTy), SourceLocation(), SourceLocation()); // Now do the "normal" pointer to function cast. - castType = Context->getFunctionType(returnType, + castType = Context->getFunctionType(returnType, &ArgTypes[0], ArgTypes.size(), Exp->getMethodDecl() ? Exp->getMethodDecl()->isVariadic() : false, 0); castType = Context->getPointerType(castType); cast = new (Context) CStyleCastExpr(castType, CastExpr::CK_Unknown, cast, castType, SourceLocation(), SourceLocation()); - + // Don't forget the parens to enforce the proper binding. PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), cast); - + FT = msgSendType->getAsFunctionType(); CallExpr *STCE = new (Context) CallExpr(*Context, PE, &MsgExprs[0], - MsgExprs.size(), + MsgExprs.size(), FT->getResultType(), SourceLocation()); - + // Build sizeof(returnType) - SizeOfAlignOfExpr *sizeofExpr = new (Context) SizeOfAlignOfExpr(true, + SizeOfAlignOfExpr *sizeofExpr = new (Context) SizeOfAlignOfExpr(true, returnType, Context->getSizeType(), SourceLocation(), SourceLocation()); @@ -2580,33 +2579,33 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) { // FIXME: Value of 8 is base on ppc32/x86 ABI for the most common cases. // For X86 it is more complicated and some kind of target specific routine // is needed to decide what to do. - unsigned IntSize = + unsigned IntSize = static_cast<unsigned>(Context->getTypeSize(Context->IntTy)); - IntegerLiteral *limit = new (Context) IntegerLiteral(llvm::APInt(IntSize, 8), + IntegerLiteral *limit = new (Context) IntegerLiteral(llvm::APInt(IntSize, 8), Context->IntTy, SourceLocation()); - BinaryOperator *lessThanExpr = new (Context) BinaryOperator(sizeofExpr, limit, - BinaryOperator::LE, - Context->IntTy, + BinaryOperator *lessThanExpr = new (Context) BinaryOperator(sizeofExpr, limit, + BinaryOperator::LE, + Context->IntTy, SourceLocation()); // (sizeof(returnType) <= 8 ? objc_msgSend(...) : objc_msgSend_stret(...)) - ConditionalOperator *CondExpr = + ConditionalOperator *CondExpr = new (Context) ConditionalOperator(lessThanExpr, SourceLocation(), CE, SourceLocation(), STCE, returnType); ReplacingStmt = new (Context) ParenExpr(SourceLocation(), SourceLocation(), CondExpr); } - // delete Exp; leak for now, see RewritePropertySetter() usage for more info. + // delete Exp; leak for now, see RewritePropertySetter() usage for more info. return ReplacingStmt; } Stmt *RewriteObjC::RewriteMessageExpr(ObjCMessageExpr *Exp) { Stmt *ReplacingStmt = SynthMessageExpr(Exp); - + // Now do the actual rewrite. ReplaceStmt(Exp, ReplacingStmt); - - // delete Exp; leak for now, see RewritePropertySetter() usage for more info. + + // delete Exp; leak for now, see RewritePropertySetter() usage for more info. return ReplacingStmt; } @@ -2614,7 +2613,7 @@ Stmt *RewriteObjC::RewriteMessageExpr(ObjCMessageExpr *Exp) { QualType RewriteObjC::getProtocolType() { if (!ProtocolTypeDecl) { ProtocolTypeDecl = TypedefDecl::Create(*Context, TUDecl, - SourceLocation(), + SourceLocation(), &Context->Idents.get("Protocol"), Context->getObjCIdType()); } @@ -2628,24 +2627,24 @@ QualType RewriteObjC::getProtocolType() { Stmt *RewriteObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) { std::string Name = "_OBJC_PROTOCOL_" + Exp->getProtocol()->getNameAsString(); IdentifierInfo *ID = &Context->Idents.get(Name); - VarDecl *VD = VarDecl::Create(*Context, TUDecl, SourceLocation(), + VarDecl *VD = VarDecl::Create(*Context, TUDecl, SourceLocation(), ID, QualType()/*UNUSED*/, 0, VarDecl::Extern); DeclRefExpr *DRE = new (Context) DeclRefExpr(VD, getProtocolType(), SourceLocation()); Expr *DerefExpr = new (Context) UnaryOperator(DRE, UnaryOperator::AddrOf, Context->getPointerType(DRE->getType()), SourceLocation()); - CastExpr *castExpr = new (Context) CStyleCastExpr(DerefExpr->getType(), - CastExpr::CK_Unknown, - DerefExpr, DerefExpr->getType(), + CastExpr *castExpr = new (Context) CStyleCastExpr(DerefExpr->getType(), + CastExpr::CK_Unknown, + DerefExpr, DerefExpr->getType(), SourceLocation(), SourceLocation()); ReplaceStmt(Exp, castExpr); ProtocolExprDecls.insert(Exp->getProtocol()); - // delete Exp; leak for now, see RewritePropertySetter() usage for more info. + // delete Exp; leak for now, see RewritePropertySetter() usage for more info. return castExpr; - + } -bool RewriteObjC::BufferContainsPPDirectives(const char *startBuf, +bool RewriteObjC::BufferContainsPPDirectives(const char *startBuf, const char *endBuf) { while (startBuf < endBuf) { if (*startBuf == '#') { @@ -2676,7 +2675,7 @@ bool RewriteObjC::BufferContainsPPDirectives(const char *startBuf, void RewriteObjC::SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl, std::string &Result) { assert(CDecl && "Class missing in SynthesizeObjCInternalStruct"); - assert(CDecl->getNameAsCString() && + assert(CDecl->getNameAsCString() && "Name missing in SynthesizeObjCInternalStruct"); // Do not synthesize more than once. if (ObjCSynthesizedStructs.count(CDecl)) @@ -2685,10 +2684,10 @@ void RewriteObjC::SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl, int NumIvars = CDecl->ivar_size(); SourceLocation LocStart = CDecl->getLocStart(); SourceLocation LocEnd = CDecl->getLocEnd(); - + const char *startBuf = SM->getCharacterData(LocStart); const char *endBuf = SM->getCharacterData(LocEnd); - + // If no ivars and no root or if its root, directly or indirectly, // have no ivars (thus not synthesized) then no need to synthesize this class. if ((CDecl->isForwardDecl() || NumIvars == 0) && @@ -2697,8 +2696,8 @@ void RewriteObjC::SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl, ReplaceText(LocStart, endBuf-startBuf, Result.c_str(), Result.size()); return; } - - // FIXME: This has potential of causing problem. If + + // FIXME: This has potential of causing problem. If // SynthesizeObjCInternalStruct is ever called recursively. Result += "\nstruct "; Result += CDecl->getNameAsString(); @@ -2707,7 +2706,7 @@ void RewriteObjC::SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl, if (NumIvars > 0) { const char *cursor = strchr(startBuf, '{'); - assert((cursor && endBuf) + assert((cursor && endBuf) && "SynthesizeObjCInternalStruct - malformed @interface"); // If the buffer contains preprocessor directives, we do more fine-grained // rewrites. This is intended to fix code that looks like (which occurs in @@ -2725,7 +2724,7 @@ void RewriteObjC::SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl, // // This clause is segregated to avoid breaking the common case. if (BufferContainsPPDirectives(startBuf, cursor)) { - SourceLocation L = RCDecl ? CDecl->getSuperClassLoc() : + SourceLocation L = RCDecl ? CDecl->getSuperClassLoc() : CDecl->getClassLoc(); const char *endHeader = SM->getCharacterData(L); endHeader += Lexer::MeasureTokenLength(L, *SM, LangOpts); @@ -2747,14 +2746,14 @@ void RewriteObjC::SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl, Result += "_IMPL "; Result += RCDecl->getNameAsString(); Result += "_IVARS;\n"; - + // insert the super class structure definition. SourceLocation OnePastCurly = LocStart.getFileLocWithOffset(cursor-startBuf+1); InsertText(OnePastCurly, Result.c_str(), Result.size()); } cursor++; // past '{' - + // Now comment out any visibility specifiers. while (cursor < endBuf) { if (*cursor == '@') { @@ -2813,7 +2812,7 @@ void RewriteObjC::RewriteObjCMethodsMetaData(MethodIterator MethodBegin, const char *ClassName, std::string &Result) { if (MethodBegin == MethodEnd) return; - + static bool objc_impl_method = false; if (!objc_impl_method) { /* struct _objc_method { @@ -2827,12 +2826,12 @@ void RewriteObjC::RewriteObjCMethodsMetaData(MethodIterator MethodBegin, Result += "\tchar *method_types;\n"; Result += "\tvoid *_imp;\n"; Result += "};\n"; - + objc_impl_method = true; } - + // Build _objc_method_list for class's methods if needed - + /* struct { struct _objc_method_list *next_method; int method_count; @@ -2895,13 +2894,13 @@ RewriteObjCProtocolMetaData(ObjCProtocolDecl *PDecl, const char *prefix, Result += "\tstruct objc_selector *_cmd;\n"; Result += "\tchar *method_types;\n"; Result += "};\n"; - + objc_protocol_methods = true; } // Do not synthesize the protocol more than once. if (ObjCSynthesizedProtocols.count(PDecl)) return; - + if (PDecl->instmeth_begin() != PDecl->instmeth_end()) { unsigned NumMethods = std::distance(PDecl->instmeth_begin(), PDecl->instmeth_end()); @@ -2918,10 +2917,10 @@ RewriteObjCProtocolMetaData(ObjCProtocolDecl *PDecl, const char *prefix, Result += PDecl->getNameAsString(); Result += " __attribute__ ((used, section (\"__OBJC, __cat_inst_meth\")))= " "{\n\t" + utostr(NumMethods) + "\n"; - + // Output instance methods declared in this protocol. - for (ObjCProtocolDecl::instmeth_iterator - I = PDecl->instmeth_begin(), E = PDecl->instmeth_end(); + for (ObjCProtocolDecl::instmeth_iterator + I = PDecl->instmeth_begin(), E = PDecl->instmeth_end(); I != E; ++I) { if (I == PDecl->instmeth_begin()) Result += "\t ,{{(struct objc_selector *)\""; @@ -2936,7 +2935,7 @@ RewriteObjCProtocolMetaData(ObjCProtocolDecl *PDecl, const char *prefix, } Result += "\t }\n};\n"; } - + // Output class methods declared in this protocol. unsigned NumMethods = std::distance(PDecl->classmeth_begin(), PDecl->classmeth_end()); @@ -2956,9 +2955,9 @@ RewriteObjCProtocolMetaData(ObjCProtocolDecl *PDecl, const char *prefix, "{\n\t"; Result += utostr(NumMethods); Result += "\n"; - + // Output instance methods declared in this protocol. - for (ObjCProtocolDecl::classmeth_iterator + for (ObjCProtocolDecl::classmeth_iterator I = PDecl->classmeth_begin(), E = PDecl->classmeth_end(); I != E; ++I) { if (I == PDecl->classmeth_begin()) @@ -2983,7 +2982,7 @@ RewriteObjCProtocolMetaData(ObjCProtocolDecl *PDecl, const char *prefix, struct _objc_protocol **protocol_list; struct _objc_protocol_method_list *instance_methods; struct _objc_protocol_method_list *class_methods; - }; + }; */ static bool objc_protocol = false; if (!objc_protocol) { @@ -2994,10 +2993,10 @@ RewriteObjCProtocolMetaData(ObjCProtocolDecl *PDecl, const char *prefix, Result += "\tstruct _objc_protocol_method_list *instance_methods;\n"; Result += "\tstruct _objc_protocol_method_list *class_methods;\n"; Result += "};\n"; - + objc_protocol = true; } - + Result += "\nstatic struct _objc_protocol _OBJC_PROTOCOL_"; Result += PDecl->getNameAsString(); Result += " __attribute__ ((used, section (\"__OBJC, __protocol\")))= " @@ -3019,7 +3018,7 @@ RewriteObjCProtocolMetaData(ObjCProtocolDecl *PDecl, const char *prefix, else Result += "0\n"; Result += "};\n"; - + // Mark this protocol as having been generated. if (!ObjCSynthesizedProtocols.insert(PDecl)) assert(false && "protocol already synthesized"); @@ -3031,7 +3030,7 @@ RewriteObjCProtocolListMetaData(const ObjCList<ObjCProtocolDecl> &Protocols, const char *prefix, const char *ClassName, std::string &Result) { if (Protocols.empty()) return; - + for (unsigned i = 0; i != Protocols.size(); i++) RewriteObjCProtocolMetaData(Protocols[i], prefix, ClassName, Result); @@ -3055,11 +3054,11 @@ RewriteObjCProtocolListMetaData(const ObjCList<ObjCProtocolDecl> &Protocols, "{\n\t0, "; Result += utostr(Protocols.size()); Result += "\n"; - + Result += "\t,{&_OBJC_PROTOCOL_"; Result += Protocols[0]->getNameAsString(); Result += " \n"; - + for (unsigned i = 1; i != Protocols.size(); i++) { Result += "\t ,&_OBJC_PROTOCOL_"; Result += Protocols[i]->getNameAsString(); @@ -3069,24 +3068,24 @@ RewriteObjCProtocolListMetaData(const ObjCList<ObjCProtocolDecl> &Protocols, } -/// RewriteObjCCategoryImplDecl - Rewrite metadata for each category +/// RewriteObjCCategoryImplDecl - Rewrite metadata for each category /// implementation. void RewriteObjC::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl, std::string &Result) { ObjCInterfaceDecl *ClassDecl = IDecl->getClassInterface(); // Find category declaration for this implementation. ObjCCategoryDecl *CDecl; - for (CDecl = ClassDecl->getCategoryList(); CDecl; + for (CDecl = ClassDecl->getCategoryList(); CDecl; CDecl = CDecl->getNextClassCategory()) if (CDecl->getIdentifier() == IDecl->getIdentifier()) break; - + std::string FullCategoryName = ClassDecl->getNameAsString(); FullCategoryName += '_'; FullCategoryName += IDecl->getNameAsString(); - + // Build _objc_method_list for class's instance methods if needed - llvm::SmallVector<ObjCMethodDecl *, 32> + llvm::SmallVector<ObjCMethodDecl *, 32> InstanceMethods(IDecl->instmeth_begin(), IDecl->instmeth_end()); // If any of our property implementations have associated getters or @@ -3111,12 +3110,12 @@ void RewriteObjC::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl, RewriteObjCMethodsMetaData(InstanceMethods.begin(), InstanceMethods.end(), true, "CATEGORY_", FullCategoryName.c_str(), Result); - + // Build _objc_method_list for class's class methods if needed RewriteObjCMethodsMetaData(IDecl->classmeth_begin(), IDecl->classmeth_end(), false, "CATEGORY_", FullCategoryName.c_str(), Result); - + // Protocols referenced in class declaration? // Null CDecl is case of a category implementation with no category interface if (CDecl) @@ -3130,11 +3129,11 @@ void RewriteObjC::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl, struct _objc_protocol_list *protocols; // Objective-C 1.0 extensions uint32_t size; // sizeof (struct _objc_category) - struct _objc_property_list *instance_properties; // category's own + struct _objc_property_list *instance_properties; // category's own // @property decl. - }; + }; */ - + static bool objc_category = false; if (!objc_category) { Result += "\nstruct _objc_category {\n"; @@ -3143,7 +3142,7 @@ void RewriteObjC::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl, Result += "\tstruct _objc_method_list *instance_methods;\n"; Result += "\tstruct _objc_method_list *class_methods;\n"; Result += "\tstruct _objc_protocol_list *protocols;\n"; - Result += "\tunsigned int size;\n"; + Result += "\tunsigned int size;\n"; Result += "\tstruct _objc_property_list *instance_properties;\n"; Result += "};\n"; objc_category = true; @@ -3155,7 +3154,7 @@ void RewriteObjC::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl, Result += "\"\n\t, \""; Result += ClassDecl->getNameAsString(); Result += "\"\n"; - + if (IDecl->instmeth_begin() != IDecl->instmeth_end()) { Result += "\t, (struct _objc_method_list *)" "&_OBJC_CATEGORY_INSTANCE_METHODS_"; @@ -3172,9 +3171,9 @@ void RewriteObjC::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl, } else Result += "\t, 0\n"; - + if (CDecl && CDecl->protocol_begin() != CDecl->protocol_end()) { - Result += "\t, (struct _objc_protocol_list *)&_OBJC_CATEGORY_PROTOCOLS_"; + Result += "\t, (struct _objc_protocol_list *)&_OBJC_CATEGORY_PROTOCOLS_"; Result += FullCategoryName; Result += "\n"; } @@ -3185,8 +3184,8 @@ void RewriteObjC::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl, /// SynthesizeIvarOffsetComputation - This rutine synthesizes computation of /// ivar offset. -void RewriteObjC::SynthesizeIvarOffsetComputation(ObjCImplementationDecl *IDecl, - ObjCIvarDecl *ivar, +void RewriteObjC::SynthesizeIvarOffsetComputation(ObjCImplementationDecl *IDecl, + ObjCIvarDecl *ivar, std::string &Result) { if (ivar->isBitField()) { // FIXME: The hack below doesn't work for bitfields. For now, we simply @@ -3210,17 +3209,17 @@ void RewriteObjC::SynthesizeIvarOffsetComputation(ObjCImplementationDecl *IDecl, void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, std::string &Result) { ObjCInterfaceDecl *CDecl = IDecl->getClassInterface(); - + // Explictly declared @interface's are already synthesized. if (CDecl->isImplicitInterfaceDecl()) { - // FIXME: Implementation of a class with no @interface (legacy) doese not + // FIXME: Implementation of a class with no @interface (legacy) doese not // produce correct synthesis as yet. SynthesizeObjCInternalStruct(CDecl, Result); } - + // Build _objc_ivar_list metadata for classes ivars if needed unsigned NumIvars = !IDecl->ivar_empty() - ? IDecl->ivar_size() + ? IDecl->ivar_size() : (CDecl ? CDecl->ivar_size() : 0); if (NumIvars > 0) { static bool objc_ivar = false; @@ -3229,23 +3228,23 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, char *ivar_name; char *ivar_type; int ivar_offset; - }; + }; */ Result += "\nstruct _objc_ivar {\n"; Result += "\tchar *ivar_name;\n"; Result += "\tchar *ivar_type;\n"; Result += "\tint ivar_offset;\n"; Result += "};\n"; - + objc_ivar = true; } /* struct { int ivar_count; struct _objc_ivar ivar_list[nIvars]; - }; + }; */ - Result += "\nstatic struct {\n"; + Result += "\nstatic struct {\n"; Result += "\tint ivar_count;\n"; Result += "\tstruct _objc_ivar ivar_list["; Result += utostr(NumIvars); @@ -3255,11 +3254,11 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, "{\n\t"; Result += utostr(NumIvars); Result += "\n"; - + ObjCInterfaceDecl::ivar_iterator IVI, IVE; llvm::SmallVector<ObjCIvarDecl *, 8> IVars; if (!IDecl->ivar_empty()) { - for (ObjCImplementationDecl::ivar_iterator + for (ObjCImplementationDecl::ivar_iterator IV = IDecl->ivar_begin(), IVEnd = IDecl->ivar_end(); IV != IVEnd; ++IV) IVars.push_back(*IV); @@ -3291,12 +3290,12 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, SynthesizeIvarOffsetComputation(IDecl, (*IVI), Result); Result += "}\n"; } - + Result += "\t }\n};\n"; } - + // Build _objc_method_list for class's instance methods if needed - llvm::SmallVector<ObjCMethodDecl *, 32> + llvm::SmallVector<ObjCMethodDecl *, 32> InstanceMethods(IDecl->instmeth_begin(), IDecl->instmeth_end()); // If any of our property implementations have associated getters or @@ -3320,15 +3319,15 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, } RewriteObjCMethodsMetaData(InstanceMethods.begin(), InstanceMethods.end(), true, "", IDecl->getNameAsCString(), Result); - + // Build _objc_method_list for class's class methods if needed RewriteObjCMethodsMetaData(IDecl->classmeth_begin(), IDecl->classmeth_end(), false, "", IDecl->getNameAsCString(), Result); - + // Protocols referenced in class declaration? RewriteObjCProtocolListMetaData(CDecl->getReferencedProtocols(), "CLASS", CDecl->getNameAsCString(), Result); - + // Declaration of class/meta-class metadata /* struct _objc_class { struct _objc_class *isa; // or const char *root_class_name when metadata @@ -3343,7 +3342,7 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, struct objc_protocol_list *protocols; const char *ivar_layout; struct _objc_class_ext *ext; - }; + }; */ static bool objc_class = false; if (!objc_class) { @@ -3363,7 +3362,7 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, Result += "};\n"; objc_class = true; } - + // Meta-class metadata generation. ObjCInterfaceDecl *RootClass = 0; ObjCInterfaceDecl *SuperClass = CDecl->getSuperClass(); @@ -3372,7 +3371,7 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, SuperClass = SuperClass->getSuperClass(); } SuperClass = CDecl->getSuperClass(); - + Result += "\nstatic struct _objc_class _OBJC_METACLASS_"; Result += CDecl->getNameAsString(); Result += " __attribute__ ((used, section (\"__OBJC, __meta_class\")))= " @@ -3398,7 +3397,7 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, if (IDecl->classmeth_begin() != IDecl->classmeth_end()) { Result += "\n\t, (struct _objc_method_list *)&_OBJC_CLASS_METHODS_"; Result += IDecl->getNameAsString(); - Result += "\n"; + Result += "\n"; } else Result += ", 0\n"; @@ -3410,7 +3409,7 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, else Result += "\t,0,0,0,0\n"; Result += "};\n"; - + // class metadata generation. Result += "\nstatic struct _objc_class _OBJC_CLASS_"; Result += CDecl->getNameAsString(); @@ -3451,7 +3450,7 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, if (IDecl->instmeth_begin() != IDecl->instmeth_end()) { Result += ", (struct _objc_method_list *)&_OBJC_INSTANCE_METHODS_"; Result += CDecl->getNameAsString(); - Result += ", 0\n\t"; + Result += ", 0\n\t"; } else Result += ",0,0"; @@ -3471,25 +3470,25 @@ void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, void RewriteObjC::RewriteImplementations() { int ClsDefCount = ClassImplementation.size(); int CatDefCount = CategoryImplementation.size(); - + // Rewrite implemented methods for (int i = 0; i < ClsDefCount; i++) RewriteImplementationDecl(ClassImplementation[i]); - + for (int i = 0; i < CatDefCount; i++) RewriteImplementationDecl(CategoryImplementation[i]); } - + void RewriteObjC::SynthesizeMetaDataIntoBuffer(std::string &Result) { int ClsDefCount = ClassImplementation.size(); int CatDefCount = CategoryImplementation.size(); // This is needed for determining instance variable offsets. - Result += "\n#define __OFFSETOFIVAR__(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)\n"; + Result += "\n#define __OFFSETOFIVAR__(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)\n"; // For each implemented class, write out all its meta data. for (int i = 0; i < ClsDefCount; i++) RewriteObjCClassMetaData(ClassImplementation[i], Result); - + // For each implemented category, write out all its meta data. for (int i = 0; i < CatDefCount; i++) RewriteObjCCategoryImplDecl(CategoryImplementation[i], Result); @@ -3503,9 +3502,9 @@ void RewriteObjC::SynthesizeMetaDataIntoBuffer(std::string &Result) { short cls_def_cnt; short cat_def_cnt; void *defs[cls_def_cnt + cat_def_cnt]; - }; + }; */ - + Result += "\nstruct _objc_symtab {\n"; Result += "\tlong sel_ref_cnt;\n"; Result += "\tSEL *refs;\n"; @@ -3513,17 +3512,17 @@ void RewriteObjC::SynthesizeMetaDataIntoBuffer(std::string &Result) { Result += "\tshort cat_def_cnt;\n"; Result += "\tvoid *defs[" + utostr(ClsDefCount + CatDefCount)+ "];\n"; Result += "};\n\n"; - + Result += "static struct _objc_symtab " "_OBJC_SYMBOLS __attribute__((used, section (\"__OBJC, __symbols\")))= {\n"; - Result += "\t0, 0, " + utostr(ClsDefCount) + Result += "\t0, 0, " + utostr(ClsDefCount) + ", " + utostr(CatDefCount) + "\n"; for (int i = 0; i < ClsDefCount; i++) { Result += "\t,&_OBJC_CLASS_"; Result += ClassImplementation[i]->getNameAsString(); Result += "\n"; } - + for (int i = 0; i < CatDefCount; i++) { Result += "\t,&_OBJC_CATEGORY_"; Result += CategoryImplementation[i]->getClassInterface()->getNameAsString(); @@ -3531,11 +3530,11 @@ void RewriteObjC::SynthesizeMetaDataIntoBuffer(std::string &Result) { Result += CategoryImplementation[i]->getNameAsString(); Result += "\n"; } - + Result += "};\n\n"; - + // Write objc_module metadata - + /* struct _objc_module { long version; @@ -3544,7 +3543,7 @@ void RewriteObjC::SynthesizeMetaDataIntoBuffer(std::string &Result) { struct _objc_symtab *symtab; } */ - + Result += "\nstruct _objc_module {\n"; Result += "\tlong version;\n"; Result += "\tlong size;\n"; @@ -3553,7 +3552,7 @@ void RewriteObjC::SynthesizeMetaDataIntoBuffer(std::string &Result) { Result += "};\n\n"; Result += "static struct _objc_module " "_OBJC_MODULES __attribute__ ((used, section (\"__OBJC, __module_info\")))= {\n"; - Result += "\t" + utostr(OBJC_ABI_VERSION) + + Result += "\t" + utostr(OBJC_ABI_VERSION) + ", sizeof(struct _objc_module), \"\", &_OBJC_SYMBOLS\n"; Result += "};\n\n"; @@ -3561,7 +3560,7 @@ void RewriteObjC::SynthesizeMetaDataIntoBuffer(std::string &Result) { if (ProtocolExprDecls.size()) { Result += "#pragma section(\".objc_protocol$B\",long,read,write)\n"; Result += "#pragma data_seg(push, \".objc_protocol$B\")\n"; - for (llvm::SmallPtrSet<ObjCProtocolDecl *,8>::iterator I = ProtocolExprDecls.begin(), + for (llvm::SmallPtrSet<ObjCProtocolDecl *,8>::iterator I = ProtocolExprDecls.begin(), E = ProtocolExprDecls.end(); I != E; ++I) { Result += "static struct _objc_protocol *_POINTER_OBJC_PROTOCOL_"; Result += (*I)->getNameAsString(); @@ -3589,9 +3588,9 @@ std::string RewriteObjC::SynthesizeBlockFunc(BlockExpr *CE, int i, funcName + "_" + "block_func_" + utostr(i); BlockDecl *BD = CE->getBlockDecl(); - + if (isa<FunctionNoProtoType>(AFT)) { - // No user-supplied arguments. Still need to pass in a pointer to the + // No user-supplied arguments. Still need to pass in a pointer to the // block (to reference imported block decl refs). S += "(" + StructRef + " *__cself)"; } else if (BD->param_empty()) { @@ -3617,19 +3616,19 @@ std::string RewriteObjC::SynthesizeBlockFunc(BlockExpr *CE, int i, S += ')'; } S += " {\n"; - + // Create local declarations to avoid rewriting all closure decl ref exprs. // First, emit a declaration for all "by ref" decls. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), E = BlockByRefDecls.end(); I != E; ++I) { S += " "; std::string Name = (*I)->getNameAsString(); - Context->getPointerType((*I)->getType()).getAsStringInternal(Name, + Context->getPointerType((*I)->getType()).getAsStringInternal(Name, Context->PrintingPolicy); S += Name + " = __cself->" + (*I)->getNameAsString() + "; // bound by ref\n"; - } + } // Next, emit a declaration for all "by copy" declarations. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), E = BlockByCopyDecls.end(); I != E; ++I) { S += " "; std::string Name = (*I)->getNameAsString(); @@ -3637,7 +3636,7 @@ std::string RewriteObjC::SynthesizeBlockFunc(BlockExpr *CE, int i, // // void (^myImportedClosure)(void); // myImportedClosure = ^(void) { setGlobalInt(x + y); }; - // + // // void (^anotherClosure)(void); // anotherClosure = ^(void) { // myImportedClosure(); // import and invoke the closure @@ -3662,13 +3661,13 @@ std::string RewriteObjC::SynthesizeBlockHelperFuncs(BlockExpr *CE, int i, std::string Tag) { std::string StructRef = "struct " + Tag; std::string S = "static void __"; - + S += funcName; S += "_block_copy_" + utostr(i); S += "(" + StructRef; S += "*dst, " + StructRef; S += "*src) {"; - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(), E = ImportedBlockDecls.end(); I != E; ++I) { S += "_Block_object_assign((void*)&dst->"; S += (*I)->getNameAsString(); @@ -3681,13 +3680,13 @@ std::string RewriteObjC::SynthesizeBlockHelperFuncs(BlockExpr *CE, int i, S += "_block_dispose_" + utostr(i); S += "(" + StructRef; S += "*src) {"; - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(), E = ImportedBlockDecls.end(); I != E; ++I) { S += "_Block_object_dispose((void*)src->"; S += (*I)->getNameAsString(); S += ", 3/*BLOCK_FIELD_IS_OBJECT*/);"; } - S += "}\n"; + S += "}\n"; return S; } @@ -3695,20 +3694,20 @@ std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, bool hasCopyDisposeHelpers) { std::string S = "\nstruct " + Tag; std::string Constructor = " " + Tag; - + S += " {\n struct __block_impl impl;\n"; - + if (hasCopyDisposeHelpers) S += " void *copy;\n void *dispose;\n"; - + Constructor += "(void *fp"; - + if (hasCopyDisposeHelpers) Constructor += ", void *copyHelp, void *disposeHelp"; - + if (BlockDeclRefs.size()) { // Output all "by copy" declarations. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), E = BlockByCopyDecls.end(); I != E; ++I) { S += " "; std::string FieldName = (*I)->getNameAsString(); @@ -3717,7 +3716,7 @@ std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, // // void (^myImportedBlock)(void); // myImportedBlock = ^(void) { setGlobalInt(x + y); }; - // + // // void (^anotherBlock)(void); // anotherBlock = ^(void) { // myImportedBlock(); // import and invoke the closure @@ -3734,7 +3733,7 @@ std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, S += FieldName + ";\n"; } // Output all "by ref" declarations. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), E = BlockByRefDecls.end(); I != E; ++I) { S += " "; std::string FieldName = (*I)->getNameAsString(); @@ -3743,7 +3742,7 @@ std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, // // void (^myImportedBlock)(void); // myImportedBlock = ^(void) { setGlobalInt(x + y); }; - // + // // void (^anotherBlock)(void); // anotherBlock = ^(void) { // myImportedBlock(); // import and invoke the closure @@ -3753,9 +3752,9 @@ std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, S += "struct __block_impl *"; Constructor += ", void *" + ArgName; } else { - Context->getPointerType((*I)->getType()).getAsStringInternal(FieldName, + Context->getPointerType((*I)->getType()).getAsStringInternal(FieldName, Context->PrintingPolicy); - Context->getPointerType((*I)->getType()).getAsStringInternal(ArgName, + Context->getPointerType((*I)->getType()).getAsStringInternal(ArgName, Context->PrintingPolicy); Constructor += ", " + ArgName; } @@ -3769,12 +3768,12 @@ std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, Constructor += " impl.isa = &_NSConcreteStackBlock;\n"; Constructor += " impl.Size = sizeof("; Constructor += Tag + ");\n impl.Flags = flags;\n impl.FuncPtr = fp;\n"; - + if (hasCopyDisposeHelpers) Constructor += " copy = copyHelp;\n dispose = disposeHelp;\n"; - + // Initialize all "by copy" arguments. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), E = BlockByCopyDecls.end(); I != E; ++I) { std::string Name = (*I)->getNameAsString(); Constructor += " "; @@ -3785,7 +3784,7 @@ std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, Constructor += Name + ";\n"; } // Initialize all "by ref" arguments. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), E = BlockByRefDecls.end(); I != E; ++I) { std::string Name = (*I)->getNameAsString(); Constructor += " "; @@ -3822,21 +3821,21 @@ void RewriteObjC::SynthesizeBlockLiterals(SourceLocation FunLocStart, CollectBlockDeclRefInfo(Blocks[i]); std::string Tag = "__" + std::string(FunName) + "_block_impl_" + utostr(i); - - std::string CI = SynthesizeBlockImpl(Blocks[i], Tag, + + std::string CI = SynthesizeBlockImpl(Blocks[i], Tag, ImportedBlockDecls.size() > 0); InsertText(FunLocStart, CI.c_str(), CI.size()); std::string CF = SynthesizeBlockFunc(Blocks[i], i, FunName, Tag); - + InsertText(FunLocStart, CF.c_str(), CF.size()); if (ImportedBlockDecls.size()) { std::string HF = SynthesizeBlockHelperFuncs(Blocks[i], i, FunName, Tag); InsertText(FunLocStart, HF.c_str(), HF.size()); } - + BlockDeclRefs.clear(); BlockByRefDecls.clear(); BlockByCopyDecls.clear(); @@ -3850,7 +3849,7 @@ void RewriteObjC::SynthesizeBlockLiterals(SourceLocation FunLocStart, void RewriteObjC::InsertBlockLiteralsWithinFunction(FunctionDecl *FD) { SourceLocation FunLocStart = FD->getTypeSpecStartLoc(); const char *FuncName = FD->getNameAsCString(); - + SynthesizeBlockLiterals(FunLocStart, FuncName); } @@ -3864,7 +3863,7 @@ void RewriteObjC::InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD) { std::string::size_type loc = 0; while ((loc = FuncName.find(":", loc)) != std::string::npos) FuncName.replace(loc, 1, "_"); - + SynthesizeBlockLiterals(FunLocStart, FuncName.c_str()); } @@ -3894,7 +3893,7 @@ void RewriteObjC::GetBlockCallExprs(Stmt *S) { else GetBlockCallExprs(*CI); } - + if (CallExpr *CE = dyn_cast<CallExpr>(S)) { if (CE->getCallee()->getType()->isBlockPointerType()) { BlockCallExprs[dyn_cast<BlockDeclRefExpr>(CE->getCallee())] = CE; @@ -3907,7 +3906,7 @@ Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp) { // Navigate to relevant type information. const char *closureName = 0; const BlockPointerType *CPT = 0; - + if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp->getCallee())) { closureName = DRE->getDecl()->getNameAsCString(); CPT = DRE->getType()->getAs<BlockPointerType>(); @@ -3925,7 +3924,7 @@ Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp) { assert(FT && "RewriteBlockClass: Bad type"); const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT); // FTP will be null for closures that don't take arguments. - + RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl, SourceLocation(), &Context->Idents.get("__block_impl")); @@ -3933,11 +3932,11 @@ Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp) { // Generate a funky cast. llvm::SmallVector<QualType, 8> ArgTypes; - + // Push the block argument type. ArgTypes.push_back(PtrBlock); if (FTP) { - for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(), + for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(), E = FTP->arg_type_end(); I && (I != E); ++I) { QualType t = *I; // Make sure we convert "t (^)(...)" to "t (*)(...)". @@ -3949,12 +3948,12 @@ Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp) { } } // Now do the pointer to function cast. - QualType PtrToFuncCastType = Context->getFunctionType(Exp->getType(), + QualType PtrToFuncCastType = Context->getFunctionType(Exp->getType(), &ArgTypes[0], ArgTypes.size(), false/*no variadic*/, 0); - + PtrToFuncCastType = Context->getPointerType(PtrToFuncCastType); - - CastExpr *BlkCast = new (Context) CStyleCastExpr(PtrBlock, + + CastExpr *BlkCast = new (Context) CStyleCastExpr(PtrBlock, CastExpr::CK_Unknown, Exp->getCallee(), PtrBlock, SourceLocation(), @@ -3963,25 +3962,25 @@ Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp) { ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), BlkCast); //PE->dump(); - + FieldDecl *FD = FieldDecl::Create(*Context, 0, SourceLocation(), - &Context->Idents.get("FuncPtr"), Context->VoidPtrTy, 0, + &Context->Idents.get("FuncPtr"), Context->VoidPtrTy, 0, /*BitWidth=*/0, /*Mutable=*/true); MemberExpr *ME = new (Context) MemberExpr(PE, true, FD, SourceLocation(), FD->getType()); - + CastExpr *FunkCast = new (Context) CStyleCastExpr(PtrToFuncCastType, CastExpr::CK_Unknown, ME, PtrToFuncCastType, SourceLocation(), SourceLocation()); PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), FunkCast); - + llvm::SmallVector<Expr*, 8> BlkExprs; // Add the implicit argument. BlkExprs.push_back(BlkCast); // Add the user arguments. - for (CallExpr::arg_iterator I = Exp->arg_begin(), + for (CallExpr::arg_iterator I = Exp->arg_begin(), E = Exp->arg_end(); I != E; ++I) { BlkExprs.push_back(*I); } @@ -4003,7 +4002,7 @@ void RewriteObjC::RewriteBlockCall(CallExpr *Exp) { // int main() { // __block Foo *f; // __block int i; -// +// // void (^myblock)() = ^() { // [f test]; // f is a BlockDeclRefExpr embedded in a message (which is being rewritten). // i = 77; @@ -4030,16 +4029,16 @@ void RewriteObjC::RewriteCastExpr(CStyleCastExpr *CE) { // Need to avoid trying to rewrite casts contained in macros. if (!Rewriter::isRewritable(LocStart) || !Rewriter::isRewritable(LocEnd)) return; - + const char *startBuf = SM->getCharacterData(LocStart); const char *endBuf = SM->getCharacterData(LocEnd); - + // advance the location to startArgList. const char *argPtr = startBuf; - + while (*argPtr++ && (argPtr < endBuf)) { switch (*argPtr) { - case '^': + case '^': // Replace the '^' with '*'. LocStart = LocStart.getFileLocWithOffset(argPtr-startBuf); ReplaceText(LocStart, 1, "*", 1); @@ -4052,31 +4051,31 @@ void RewriteObjC::RewriteCastExpr(CStyleCastExpr *CE) { void RewriteObjC::RewriteBlockPointerFunctionArgs(FunctionDecl *FD) { SourceLocation DeclLoc = FD->getLocation(); unsigned parenCount = 0; - + // We have 1 or more arguments that have closure pointers. const char *startBuf = SM->getCharacterData(DeclLoc); const char *startArgList = strchr(startBuf, '('); - + assert((*startArgList == '(') && "Rewriter fuzzy parser confused"); - + parenCount++; // advance the location to startArgList. DeclLoc = DeclLoc.getFileLocWithOffset(startArgList-startBuf); assert((DeclLoc.isValid()) && "Invalid DeclLoc"); - + const char *argPtr = startArgList; - + while (*argPtr++ && parenCount) { switch (*argPtr) { - case '^': + case '^': // Replace the '^' with '*'. DeclLoc = DeclLoc.getFileLocWithOffset(argPtr-startArgList); ReplaceText(DeclLoc, 1, "*", 1); break; - case '(': - parenCount++; + case '(': + parenCount++; break; - case ')': + case ')': parenCount--; break; } @@ -4095,7 +4094,7 @@ bool RewriteObjC::PointerTypeTakesAnyBlockArguments(QualType QT) { FTP = BPT->getPointeeType()->getAsFunctionProtoType(); } if (FTP) { - for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(), + for (FunctionProtoType::arg_type_iterator I = FTP->arg_type_begin(), E = FTP->arg_type_end(); I != E; ++I) if (isTopLevelBlockPointerType(*I)) return true; @@ -4107,11 +4106,11 @@ void RewriteObjC::GetExtentOfArgList(const char *Name, const char *&LParen, const char *&RParen) { const char *argPtr = strchr(Name, '('); assert((*argPtr == '(') && "Rewriter fuzzy parser confused"); - + LParen = argPtr; // output the start. argPtr++; // skip past the left paren. unsigned parenCount = 1; - + while (*argPtr && parenCount) { switch (*argPtr) { case '(': parenCount++; break; @@ -4128,7 +4127,7 @@ void RewriteObjC::RewriteBlockPointerDecl(NamedDecl *ND) { if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { RewriteBlockPointerFunctionArgs(FD); return; - } + } // Handle Variables and Typedefs. SourceLocation DeclLoc = ND->getLocation(); QualType DeclT; @@ -4138,15 +4137,15 @@ void RewriteObjC::RewriteBlockPointerDecl(NamedDecl *ND) { DeclT = TDD->getUnderlyingType(); else if (FieldDecl *FD = dyn_cast<FieldDecl>(ND)) DeclT = FD->getType(); - else + else assert(0 && "RewriteBlockPointerDecl(): Decl type not yet handled"); - + const char *startBuf = SM->getCharacterData(DeclLoc); const char *endBuf = startBuf; // scan backward (from the decl location) for the end of the previous decl. while (*startBuf != '^' && *startBuf != ';' && startBuf != MainFileStart) startBuf--; - + // *startBuf != '^' if we are dealing with a pointer to function that // may take block argument types (which will be handled below). if (*startBuf == '^') { @@ -4171,7 +4170,7 @@ void RewriteObjC::RewriteBlockPointerDecl(NamedDecl *ND) { return; } -void RewriteObjC::CollectBlockDeclRefInfo(BlockExpr *Exp) { +void RewriteObjC::CollectBlockDeclRefInfo(BlockExpr *Exp) { // Add initializers for any closure decl refs. GetBlockDeclRefExprs(Exp->getBody()); if (BlockDeclRefs.size()) { @@ -4196,7 +4195,7 @@ void RewriteObjC::CollectBlockDeclRefInfo(BlockExpr *Exp) { FunctionDecl *RewriteObjC::SynthBlockInitFunctionDecl(const char *name) { IdentifierInfo *ID = &Context->Idents.get(name); QualType FType = Context->getFunctionNoProtoType(Context->VoidPtrTy); - return FunctionDecl::Create(*Context, TUDecl,SourceLocation(), + return FunctionDecl::Create(*Context, TUDecl,SourceLocation(), ID, FType, 0, FunctionDecl::Extern, false, false); } @@ -4206,7 +4205,7 @@ Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp) { CollectBlockDeclRefInfo(Exp); std::string FuncName; - + if (CurFunctionDef) FuncName = CurFunctionDef->getNameAsString(); else if (CurMethodDef) { @@ -4217,58 +4216,58 @@ Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp) { FuncName.replace(loc, 1, "_"); } else if (GlobalVarDecl) FuncName = std::string(GlobalVarDecl->getNameAsString()); - + std::string BlockNumber = utostr(Blocks.size()-1); - + std::string Tag = "__" + FuncName + "_block_impl_" + BlockNumber; std::string Func = "__" + FuncName + "_block_func_" + BlockNumber; - + // Get a pointer to the function type so we can cast appropriately. QualType FType = Context->getPointerType(QualType(Exp->getFunctionType(),0)); FunctionDecl *FD; Expr *NewRep; - + // Simulate a contructor call... FD = SynthBlockInitFunctionDecl(Tag.c_str()); DeclRefExpr *DRE = new (Context) DeclRefExpr(FD, FType, SourceLocation()); - + llvm::SmallVector<Expr*, 4> InitExprs; - + // Initialize the block function. FD = SynthBlockInitFunctionDecl(Func.c_str()); DeclRefExpr *Arg = new (Context) DeclRefExpr(FD, FD->getType(), SourceLocation()); - CastExpr *castExpr = new (Context) CStyleCastExpr(Context->VoidPtrTy, - CastExpr::CK_Unknown, Arg, + CastExpr *castExpr = new (Context) CStyleCastExpr(Context->VoidPtrTy, + CastExpr::CK_Unknown, Arg, Context->VoidPtrTy, SourceLocation(), SourceLocation()); - InitExprs.push_back(castExpr); - + InitExprs.push_back(castExpr); + if (ImportedBlockDecls.size()) { std::string Buf = "__" + FuncName + "_block_copy_" + BlockNumber; FD = SynthBlockInitFunctionDecl(Buf.c_str()); Arg = new (Context) DeclRefExpr(FD, FD->getType(), SourceLocation()); - castExpr = new (Context) CStyleCastExpr(Context->VoidPtrTy, - CastExpr::CK_Unknown, Arg, + castExpr = new (Context) CStyleCastExpr(Context->VoidPtrTy, + CastExpr::CK_Unknown, Arg, Context->VoidPtrTy, SourceLocation(), SourceLocation()); - InitExprs.push_back(castExpr); - + InitExprs.push_back(castExpr); + Buf = "__" + FuncName + "_block_dispose_" + BlockNumber; FD = SynthBlockInitFunctionDecl(Buf.c_str()); Arg = new (Context) DeclRefExpr(FD, FD->getType(), SourceLocation()); - castExpr = new (Context) CStyleCastExpr(Context->VoidPtrTy, - CastExpr::CK_Unknown, Arg, + castExpr = new (Context) CStyleCastExpr(Context->VoidPtrTy, + CastExpr::CK_Unknown, Arg, Context->VoidPtrTy, SourceLocation(), SourceLocation()); - InitExprs.push_back(castExpr); + InitExprs.push_back(castExpr); } // Add initializers for any closure decl refs. if (BlockDeclRefs.size()) { Expr *Exp; // Output all "by copy" declarations. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(), E = BlockByCopyDecls.end(); I != E; ++I) { if (isObjCType((*I)->getType())) { // FIXME: Conform to ABI ([[obj retain] autorelease]). @@ -4277,34 +4276,34 @@ Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp) { } else if (isTopLevelBlockPointerType((*I)->getType())) { FD = SynthBlockInitFunctionDecl((*I)->getNameAsCString()); Arg = new (Context) DeclRefExpr(FD, FD->getType(), SourceLocation()); - Exp = new (Context) CStyleCastExpr(Context->VoidPtrTy, - CastExpr::CK_Unknown, Arg, - Context->VoidPtrTy, + Exp = new (Context) CStyleCastExpr(Context->VoidPtrTy, + CastExpr::CK_Unknown, Arg, + Context->VoidPtrTy, SourceLocation(), SourceLocation()); } else { FD = SynthBlockInitFunctionDecl((*I)->getNameAsCString()); Exp = new (Context) DeclRefExpr(FD, FD->getType(), SourceLocation()); } - InitExprs.push_back(Exp); + InitExprs.push_back(Exp); } // Output all "by ref" declarations. - for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), + for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(), E = BlockByRefDecls.end(); I != E; ++I) { FD = SynthBlockInitFunctionDecl((*I)->getNameAsCString()); Exp = new (Context) DeclRefExpr(FD, FD->getType(), SourceLocation()); Exp = new (Context) UnaryOperator(Exp, UnaryOperator::AddrOf, - Context->getPointerType(Exp->getType()), + Context->getPointerType(Exp->getType()), SourceLocation()); - InitExprs.push_back(Exp); + InitExprs.push_back(Exp); } } NewRep = new (Context) CallExpr(*Context, DRE, &InitExprs[0], InitExprs.size(), FType, SourceLocation()); NewRep = new (Context) UnaryOperator(NewRep, UnaryOperator::AddrOf, - Context->getPointerType(NewRep->getType()), + Context->getPointerType(NewRep->getType()), SourceLocation()); - NewRep = new (Context) CStyleCastExpr(FType, CastExpr::CK_Unknown, NewRep, + NewRep = new (Context) CStyleCastExpr(FType, CastExpr::CK_Unknown, NewRep, FType, SourceLocation(), SourceLocation()); BlockDeclRefs.clear(); @@ -4340,33 +4339,33 @@ void RewriteObjC::CollectPropertySetters(Stmt *S) { } Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { - if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || + if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) || isa<ForStmt>(S)) Stmts.push_back(S); else if (isa<ObjCForCollectionStmt>(S)) { Stmts.push_back(S); ObjCBcLabelNo.push_back(++BcLabelCount); } - + SourceRange OrigStmtRange = S->getSourceRange(); - + // Perform a bottom up rewrite of all children. for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end(); CI != E; ++CI) if (*CI) { Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(*CI); - if (newStmt) + if (newStmt) *CI = newStmt; } - + if (BlockExpr *BE = dyn_cast<BlockExpr>(S)) { // Rewrite the block body in place. RewriteFunctionBodyOrGlobalInitializer(BE->getBody()); - + // Now we snarf the rewritten text and stash it away for later use. std::string Str = Rewrite.getRewritenText(BE->getSourceRange()); RewrittenBlockExprs[BE] = Str; - + Stmt *blockTranscribed = SynthBlockInitExpr(BE); //blockTranscribed->dump(); ReplaceStmt(S, blockTranscribed); @@ -4375,7 +4374,7 @@ Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { // Handle specific things. if (ObjCEncodeExpr *AtEncode = dyn_cast<ObjCEncodeExpr>(S)) return RewriteAtEncode(AtEncode); - + if (ObjCIvarRefExpr *IvarRefExpr = dyn_cast<ObjCIvarRefExpr>(S)) return RewriteObjCIvarRefExpr(IvarRefExpr, OrigStmtRange.getBegin()); @@ -4388,7 +4387,7 @@ Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { // Save the source range. Even if we disable the replacement, the // rewritten node will have been inserted into the tree. If the synthesized // node is at the 'end', the rewriter will fail. Consider this: - // self.errorHandler = handler ? handler : + // self.errorHandler = handler ? handler : // ^(NSURL *errorURL, NSError *error) { return (BOOL)1; }; SourceRange SrcRange = BinOp->getSourceRange(); Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(BinOp->getRHS()); @@ -4422,7 +4421,7 @@ Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { // can be used as the setter argument. ReplaceStmt() will still 'see' // the original RHS (since we haven't altered BinOp). // - // This implies the Rewrite* routines can no longer delete the original + // This implies the Rewrite* routines can no longer delete the original // node. As a result, we now leak the original AST nodes. // return RewritePropertySetter(BinOp, dyn_cast<Expr>(newStmt), SrcRange); @@ -4432,25 +4431,25 @@ Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { } if (ObjCSelectorExpr *AtSelector = dyn_cast<ObjCSelectorExpr>(S)) return RewriteAtSelector(AtSelector); - + if (ObjCStringLiteral *AtString = dyn_cast<ObjCStringLiteral>(S)) return RewriteObjCStringLiteral(AtString); - + if (ObjCMessageExpr *MessExpr = dyn_cast<ObjCMessageExpr>(S)) { #if 0 // Before we rewrite it, put the original message expression in a comment. SourceLocation startLoc = MessExpr->getLocStart(); SourceLocation endLoc = MessExpr->getLocEnd(); - + const char *startBuf = SM->getCharacterData(startLoc); const char *endBuf = SM->getCharacterData(endLoc); - + std::string messString; messString += "// "; messString.append(startBuf, endBuf-startBuf+1); messString += "\n"; - - // FIXME: Missing definition of + + // FIXME: Missing definition of // InsertText(clang::SourceLocation, char const*, unsigned int). // InsertText(startLoc, messString.c_str(), messString.size()); // Tried this, but it didn't work either... @@ -4458,7 +4457,7 @@ Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { #endif return RewriteMessageExpr(MessExpr); } - + if (ObjCAtTryStmt *StmtTry = dyn_cast<ObjCAtTryStmt>(S)) return RewriteObjCTryStmt(StmtTry); @@ -4467,13 +4466,13 @@ Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { if (ObjCAtThrowStmt *StmtThrow = dyn_cast<ObjCAtThrowStmt>(S)) return RewriteObjCThrowStmt(StmtThrow); - + if (ObjCProtocolExpr *ProtocolExp = dyn_cast<ObjCProtocolExpr>(S)) return RewriteObjCProtocolExpr(ProtocolExp); - - if (ObjCForCollectionStmt *StmtForCollection = + + if (ObjCForCollectionStmt *StmtForCollection = dyn_cast<ObjCForCollectionStmt>(S)) - return RewriteObjCForCollectionStmt(StmtForCollection, + return RewriteObjCForCollectionStmt(StmtForCollection, OrigStmtRange.getEnd()); if (BreakStmt *StmtBreakStmt = dyn_cast<BreakStmt>(S)) @@ -4481,15 +4480,15 @@ Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { if (ContinueStmt *StmtContinueStmt = dyn_cast<ContinueStmt>(S)) return RewriteContinueStmt(StmtContinueStmt); - - // Need to check for protocol refs (id <P>, Foo <P> *) in variable decls + + // Need to check for protocol refs (id <P>, Foo <P> *) in variable decls // and cast exprs. if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) { // FIXME: What we're doing here is modifying the type-specifier that // precedes the first Decl. In the future the DeclGroup should have - // a separate type-specifier that we can rewrite. + // a separate type-specifier that we can rewrite. RewriteObjCQualifiedInterfaceTypes(*DS->decl_begin()); - + // Blocks rewrite rules. for (DeclStmt::decl_iterator DI = DS->decl_begin(), DE = DS->decl_end(); DI != DE; ++DI) { @@ -4497,26 +4496,26 @@ Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { if (ValueDecl *ND = dyn_cast<ValueDecl>(SD)) { if (isTopLevelBlockPointerType(ND->getType())) RewriteBlockPointerDecl(ND); - else if (ND->getType()->isFunctionPointerType()) + else if (ND->getType()->isFunctionPointerType()) CheckFunctionPointerDecl(ND->getType(), ND); } if (TypedefDecl *TD = dyn_cast<TypedefDecl>(SD)) { if (isTopLevelBlockPointerType(TD->getUnderlyingType())) RewriteBlockPointerDecl(TD); - else if (TD->getUnderlyingType()->isFunctionPointerType()) + else if (TD->getUnderlyingType()->isFunctionPointerType()) CheckFunctionPointerDecl(TD->getUnderlyingType(), TD); } } } - + if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(S)) RewriteObjCQualifiedInterfaceTypes(CE); - - if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || + + if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || isa<DoStmt>(S) || isa<ForStmt>(S)) { assert(!Stmts.empty() && "Statement stack is empty"); - assert ((isa<SwitchStmt>(Stmts.back()) || isa<WhileStmt>(Stmts.back()) || - isa<DoStmt>(Stmts.back()) || isa<ForStmt>(Stmts.back())) + assert ((isa<SwitchStmt>(Stmts.back()) || isa<WhileStmt>(Stmts.back()) || + isa<DoStmt>(Stmts.back()) || isa<ForStmt>(Stmts.back())) && "Statement stack mismatch"); Stmts.pop_back(); } @@ -4560,7 +4559,7 @@ void RewriteObjC::HandleDeclInMainFile(Decl *D) { if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { if (FD->isOverloadedOperator()) return; - + // Since function prototypes don't have ParmDecl's, we check the function // prototype. This enables us to rewrite function declarations and // definitions using the same code. @@ -4583,7 +4582,7 @@ void RewriteObjC::HandleDeclInMainFile(Decl *D) { // and any copy/dispose helper functions. InsertBlockLiteralsWithinFunction(FD); CurFunctionDef = 0; - } + } return; } if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { @@ -4631,7 +4630,7 @@ void RewriteObjC::HandleDeclInMainFile(Decl *D) { delete PropParentMap; PropParentMap = 0; } - SynthesizeBlockLiterals(VD->getTypeSpecStartLoc(), + SynthesizeBlockLiterals(VD->getTypeSpecStartLoc(), VD->getNameAsCString()); GlobalVarDecl = 0; @@ -4645,13 +4644,13 @@ void RewriteObjC::HandleDeclInMainFile(Decl *D) { if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) { if (isTopLevelBlockPointerType(TD->getUnderlyingType())) RewriteBlockPointerDecl(TD); - else if (TD->getUnderlyingType()->isFunctionPointerType()) + else if (TD->getUnderlyingType()->isFunctionPointerType()) CheckFunctionPointerDecl(TD->getUnderlyingType(), TD); return; } if (RecordDecl *RD = dyn_cast<RecordDecl>(D)) { if (RD->isDefinition()) { - for (RecordDecl::field_iterator i = RD->field_begin(), + for (RecordDecl::field_iterator i = RD->field_begin(), e = RD->field_end(); i != e; ++i) { FieldDecl *FD = *i; if (isTopLevelBlockPointerType(FD->getType())) @@ -4665,29 +4664,29 @@ void RewriteObjC::HandleDeclInMainFile(Decl *D) { void RewriteObjC::HandleTranslationUnit(ASTContext &C) { // Get the top-level buffer that this corresponds to. - + // Rewrite tabs if we care. //RewriteTabs(); - + if (Diags.hasErrorOccurred()) return; - + RewriteInclude(); - + // Here's a great place to add any extra declarations that may be needed. // Write out meta data for each @protocol(<expr>). - for (llvm::SmallPtrSet<ObjCProtocolDecl *,8>::iterator I = ProtocolExprDecls.begin(), + for (llvm::SmallPtrSet<ObjCProtocolDecl *,8>::iterator I = ProtocolExprDecls.begin(), E = ProtocolExprDecls.end(); I != E; ++I) RewriteObjCProtocolMetaData(*I, "", "", Preamble); - InsertText(SM->getLocForStartOfFile(MainFileID), + InsertText(SM->getLocForStartOfFile(MainFileID), Preamble.c_str(), Preamble.size(), false); if (ClassImplementation.size() || CategoryImplementation.size()) RewriteImplementations(); // Get the buffer corresponding to MainFileID. If we haven't changed it, then // we are done. - if (const RewriteBuffer *RewriteBuf = + if (const RewriteBuffer *RewriteBuf = Rewrite.getRewriteBufferFor(MainFileID)) { //printf("Changed:\n"); *OutFile << std::string(RewriteBuf->begin(), RewriteBuf->end()); diff --git a/clang/lib/Frontend/RewriteTest.cpp b/clang/lib/Frontend/RewriteTest.cpp index f9eb58f8674..0414678fb61 100644 --- a/clang/lib/Frontend/RewriteTest.cpp +++ b/clang/lib/Frontend/RewriteTest.cpp @@ -30,8 +30,8 @@ void clang::DoRewriteTest(Preprocessor &PP, llvm::raw_ostream* OS) { Rewriter.AddTokenBefore(I, "<i>"); Rewriter.AddTokenAfter(I, "</i>"); } - - + + // Print out the output. for (TokenRewriter::token_iterator I = Rewriter.token_begin(), E = Rewriter.token_end(); I != E; ++I) diff --git a/clang/lib/Frontend/StmtXML.cpp b/clang/lib/Frontend/StmtXML.cpp index b6d04810bfa..4a3c0bf1c60 100644 --- a/clang/lib/Frontend/StmtXML.cpp +++ b/clang/lib/Frontend/StmtXML.cpp @@ -32,25 +32,18 @@ namespace { //static const char *getOpcodeStr(BinaryOperator::Opcode Op); - void addSpecialAttribute(const char* pName, StringLiteral* Str) - { + void addSpecialAttribute(const char* pName, StringLiteral* Str) { Doc.addAttribute(pName, Doc.escapeString(Str->getStrData(), Str->getByteLength())); } - void addSpecialAttribute(const char* pName, SizeOfAlignOfExpr* S) - { + void addSpecialAttribute(const char* pName, SizeOfAlignOfExpr* S) { if (S->isArgumentType()) - { Doc.addAttribute(pName, S->getArgumentType()); - } } - void addSpecialAttribute(const char* pName, CXXTypeidExpr* S) - { + void addSpecialAttribute(const char* pName, CXXTypeidExpr* S) { if (S->isTypeOperand()) - { Doc.addAttribute(pName, S->getTypeOperand()); - } } @@ -58,29 +51,21 @@ namespace { StmtXML(DocumentXML& doc) : Doc(doc) { } - + void DumpSubTree(Stmt *S) { - if (S) - { + if (S) { Visit(S); - if (DeclStmt* DS = dyn_cast<DeclStmt>(S)) - { - for (DeclStmt::decl_iterator DI = DS->decl_begin(), DE = DS->decl_end(); - DI != DE; ++DI) - { + if (DeclStmt* DS = dyn_cast<DeclStmt>(S)) { + for (DeclStmt::decl_iterator DI = DS->decl_begin(), + DE = DS->decl_end(); DI != DE; ++DI) { Doc.PrintDecl(*DI); } - } - else - { + } else { if (CXXConditionDeclExpr* CCDE = dyn_cast<CXXConditionDeclExpr>(S)) - { Doc.PrintDecl(CCDE->getVarDecl()); - } - for (Stmt::child_iterator i = S->child_begin(), e = S->child_end(); i != e; ++i) - { + for (Stmt::child_iterator i = S->child_begin(), e = S->child_end(); + i != e; ++i) DumpSubTree(*i); - } } Doc.toParent(); } else { @@ -93,12 +78,12 @@ namespace { void Visit##CLASS(CLASS* S) \ { \ typedef CLASS tStmtType; \ - Doc.addSubNode(NAME); + Doc.addSubNode(NAME); -#define ATTRIBUTE_XML( FN, NAME ) Doc.addAttribute(NAME, S->FN); +#define ATTRIBUTE_XML( FN, NAME ) Doc.addAttribute(NAME, S->FN); #define TYPE_ATTRIBUTE_XML( FN ) ATTRIBUTE_XML(FN, "type") -#define ATTRIBUTE_OPT_XML( FN, NAME ) Doc.addAttributeOptional(NAME, S->FN); -#define ATTRIBUTE_SPECIAL_XML( FN, NAME ) addSpecialAttribute(NAME, S); +#define ATTRIBUTE_OPT_XML( FN, NAME ) Doc.addAttributeOptional(NAME, S->FN); +#define ATTRIBUTE_SPECIAL_XML( FN, NAME ) addSpecialAttribute(NAME, S); #define ATTRIBUTE_FILE_LOCATION_XML Doc.addLocationRange(S->getSourceRange()); @@ -107,14 +92,14 @@ namespace { const char* pAttributeName = NAME; \ const bool optional = false; \ switch (S->FN) { \ - default: assert(0 && "unknown enum value"); + default: assert(0 && "unknown enum value"); #define ATTRIBUTE_ENUM_OPT_XML( FN, NAME ) \ { \ const char* pAttributeName = NAME; \ const bool optional = true; \ switch (S->FN) { \ - default: assert(0 && "unknown enum value"); + default: assert(0 && "unknown enum value"); #define ENUM_XML( VALUE, NAME ) case VALUE: if ((!optional) || NAME[0]) Doc.addAttribute(pAttributeName, NAME); break; #define END_ENUM_XML } } @@ -133,7 +118,7 @@ namespace { void VisitDeclStmt(DeclStmt *Node); void VisitLabelStmt(LabelStmt *Node); void VisitGotoStmt(GotoStmt *Node); - + // Exprs void VisitExpr(Expr *Node); void VisitDeclRefExpr(DeclRefExpr *Node); @@ -156,7 +141,7 @@ namespace { void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node); void VisitCXXThisExpr(CXXThisExpr *Node); void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node); - + // ObjC void VisitObjCEncodeExpr(ObjCEncodeExpr *Node); void VisitObjCMessageExpr(ObjCMessageExpr* Node); @@ -175,27 +160,22 @@ namespace { // Stmt printing methods. //===----------------------------------------------------------------------===// #if (0) -void StmtXML::VisitStmt(Stmt *Node) -{ +void StmtXML::VisitStmt(Stmt *Node) { // nothing special to do } -void StmtXML::VisitDeclStmt(DeclStmt *Node) -{ +void StmtXML::VisitDeclStmt(DeclStmt *Node) { for (DeclStmt::decl_iterator DI = Node->decl_begin(), DE = Node->decl_end(); - DI != DE; ++DI) - { + DI != DE; ++DI) { Doc.PrintDecl(*DI); } } -void StmtXML::VisitLabelStmt(LabelStmt *Node) -{ +void StmtXML::VisitLabelStmt(LabelStmt *Node) { Doc.addAttribute("name", Node->getName()); } -void StmtXML::VisitGotoStmt(GotoStmt *Node) -{ +void StmtXML::VisitGotoStmt(GotoStmt *Node) { Doc.addAttribute("name", Node->getLabel()->getName()); } @@ -336,9 +316,7 @@ void StmtXML::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *Node) { Doc.addAttribute("is_sizeof", Node->isSizeOf() ? "sizeof" : "alignof"); Doc.addAttribute("is_type", Node->isArgumentType() ? "1" : "0"); if (Node->isArgumentType()) - { DumpTypeExpr(Node->getArgumentType()); - } } void StmtXML::VisitMemberExpr(MemberExpr *Node) { @@ -415,7 +393,7 @@ void StmtXML::VisitObjCMessageExpr(ObjCMessageExpr* Node) { DumpExpr(Node); Doc.addAttribute("selector", Node->getSelector().getAsString()); IdentifierInfo* clsName = Node->getClassName(); - if (clsName) + if (clsName) Doc.addAttribute("class", clsName->getName()); } diff --git a/clang/lib/Frontend/TextDiagnosticBuffer.cpp b/clang/lib/Frontend/TextDiagnosticBuffer.cpp index a4518ee7e68..34bc3c796aa 100644 --- a/clang/lib/Frontend/TextDiagnosticBuffer.cpp +++ b/clang/lib/Frontend/TextDiagnosticBuffer.cpp @@ -17,7 +17,7 @@ using namespace clang; /// HandleDiagnostic - Store the errors, warnings, and notes that are /// reported. -/// +/// void TextDiagnosticBuffer::HandleDiagnostic(Diagnostic::Level Level, const DiagnosticInfo &Info) { llvm::SmallString<100> StrC; diff --git a/clang/lib/Frontend/TextDiagnosticPrinter.cpp b/clang/lib/Frontend/TextDiagnosticPrinter.cpp index 973a47f7794..63d9a50b368 100644 --- a/clang/lib/Frontend/TextDiagnosticPrinter.cpp +++ b/clang/lib/Frontend/TextDiagnosticPrinter.cpp @@ -436,7 +436,7 @@ void TextDiagnosticPrinter::EmitCaretDiagnostic(SourceLocation Loc, /// greater than or equal to Idx or, if no such character exists, /// returns the end of the string. static unsigned skipWhitespace(unsigned Idx, - const llvm::SmallVectorImpl<char> &Str, + const llvm::SmallVectorImpl<char> &Str, unsigned Length) { while (Idx < Length && isspace(Str[Idx])) ++Idx; @@ -536,7 +536,7 @@ unsigned findEndOfWord(unsigned Start, /// \returns true if word-wrapping was required, or false if the /// string fit on the first line. static bool PrintWordWrapped(llvm::raw_ostream &OS, - const llvm::SmallVectorImpl<char> &Str, + const llvm::SmallVectorImpl<char> &Str, unsigned Columns, unsigned Column = 0, unsigned Indentation = WordWrapIndentation) { diff --git a/clang/lib/Frontend/TypeXML.cpp b/clang/lib/Frontend/TypeXML.cpp index f32fbbd2413..8bd05443a7f 100644 --- a/clang/lib/Frontend/TypeXML.cpp +++ b/clang/lib/Frontend/TypeXML.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -// This file implements the XML document class, which provides the means to +// This file implements the XML document class, which provides the means to // dump out the AST in a XML form that exposes type details and other fields. // //===----------------------------------------------------------------------===// @@ -21,38 +21,36 @@ namespace clang { namespace XML { namespace { -//--------------------------------------------------------- -class TypeWriter : public TypeVisitor<TypeWriter> -{ +//--------------------------------------------------------- +class TypeWriter : public TypeVisitor<TypeWriter> { DocumentXML& Doc; public: TypeWriter(DocumentXML& doc) : Doc(doc) {} #define NODE_XML( CLASS, NAME ) \ - void Visit##CLASS(CLASS* T) \ - { \ - Doc.addSubNode(NAME); + void Visit##CLASS(CLASS* T) { \ + Doc.addSubNode(NAME); #define ID_ATTRIBUTE_XML // done by the Document class itself -#define ATTRIBUTE_XML( FN, NAME ) Doc.addAttribute(NAME, T->FN); +#define ATTRIBUTE_XML( FN, NAME ) Doc.addAttribute(NAME, T->FN); #define TYPE_ATTRIBUTE_XML( FN ) ATTRIBUTE_XML(FN, "type") #define CONTEXT_ATTRIBUTE_XML( FN ) ATTRIBUTE_XML(FN, "context") -#define ATTRIBUTE_OPT_XML( FN, NAME ) Doc.addAttributeOptional(NAME, T->FN); +#define ATTRIBUTE_OPT_XML( FN, NAME ) Doc.addAttributeOptional(NAME, T->FN); #define ATTRIBUTE_ENUM_XML( FN, NAME ) \ { \ const char* pAttributeName = NAME; \ const bool optional = false; \ switch (T->FN) { \ - default: assert(0 && "unknown enum value"); + default: assert(0 && "unknown enum value"); #define ATTRIBUTE_ENUM_OPT_XML( FN, NAME ) \ { \ const char* pAttributeName = NAME; \ const bool optional = true; \ switch (T->FN) { \ - default: assert(0 && "unknown enum value"); + default: assert(0 && "unknown enum value"); #define ENUM_XML( VALUE, NAME ) case VALUE: if ((!optional) || NAME[0]) Doc.addAttribute(pAttributeName, NAME); break; #define END_ENUM_XML } } @@ -62,22 +60,19 @@ public: }; -//--------------------------------------------------------- +//--------------------------------------------------------- } // anon clang } // NS XML -//--------------------------------------------------------- -class DocumentXML::TypeAdder : public TypeVisitor<DocumentXML::TypeAdder> -{ +//--------------------------------------------------------- +class DocumentXML::TypeAdder : public TypeVisitor<DocumentXML::TypeAdder> { DocumentXML& Doc; - void addIfType(const Type* pType) - { + void addIfType(const Type* pType) { Doc.addTypeRecursively(pType); } - void addIfType(const QualType& pType) - { + void addIfType(const QualType& pType) { Doc.addTypeRecursively(pType); } @@ -88,40 +83,37 @@ public: #define NODE_XML( CLASS, NAME ) \ void Visit##CLASS(CLASS* T) \ - { - -#define ID_ATTRIBUTE_XML -#define TYPE_ATTRIBUTE_XML( FN ) Doc.addTypeRecursively(T->FN); -#define CONTEXT_ATTRIBUTE_XML( FN ) -#define ATTRIBUTE_XML( FN, NAME ) addIfType(T->FN); -#define ATTRIBUTE_OPT_XML( FN, NAME ) -#define ATTRIBUTE_ENUM_XML( FN, NAME ) -#define ATTRIBUTE_ENUM_OPT_XML( FN, NAME ) -#define ENUM_XML( VALUE, NAME ) -#define END_ENUM_XML + { + +#define ID_ATTRIBUTE_XML +#define TYPE_ATTRIBUTE_XML( FN ) Doc.addTypeRecursively(T->FN); +#define CONTEXT_ATTRIBUTE_XML( FN ) +#define ATTRIBUTE_XML( FN, NAME ) addIfType(T->FN); +#define ATTRIBUTE_OPT_XML( FN, NAME ) +#define ATTRIBUTE_ENUM_XML( FN, NAME ) +#define ATTRIBUTE_ENUM_OPT_XML( FN, NAME ) +#define ENUM_XML( VALUE, NAME ) +#define END_ENUM_XML #define END_NODE_XML } #include "clang/Frontend/TypeXML.def" }; -//--------------------------------------------------------- -void DocumentXML::addParentTypes(const Type* pType) -{ +//--------------------------------------------------------- +void DocumentXML::addParentTypes(const Type* pType) { TypeAdder(*this).Visit(const_cast<Type*>(pType)); } -//--------------------------------------------------------- -void DocumentXML::writeTypeToXML(const Type* pType) -{ +//--------------------------------------------------------- +void DocumentXML::writeTypeToXML(const Type* pType) { XML::TypeWriter(*this).Visit(const_cast<Type*>(pType)); } -//--------------------------------------------------------- -void DocumentXML::writeTypeToXML(const QualType& pType) -{ +//--------------------------------------------------------- +void DocumentXML::writeTypeToXML(const QualType& pType) { XML::TypeWriter(*this).VisitQualType(const_cast<QualType*>(&pType)); } -//--------------------------------------------------------- +//--------------------------------------------------------- } // NS clang diff --git a/clang/lib/Frontend/Warnings.cpp b/clang/lib/Frontend/Warnings.cpp index 87178e93b44..7b01b0fb741 100644 --- a/clang/lib/Frontend/Warnings.cpp +++ b/clang/lib/Frontend/Warnings.cpp @@ -47,7 +47,7 @@ bool clang::ProcessWarningOptions(Diagnostic &Diags, Diags.setExtensionHandlingBehavior(Diagnostic::Ext_Warn); else Diags.setExtensionHandlingBehavior(Diagnostic::Ext_Ignore); - + // FIXME: -Wfatal-errors / -Wfatal-errors=foo for (unsigned i = 0, e = Warnings.size(); i != e; ++i) { @@ -55,7 +55,7 @@ bool clang::ProcessWarningOptions(Diagnostic &Diags, const char *OptStart = &Opt[0]; const char *OptEnd = OptStart+Opt.size(); assert(*OptEnd == 0 && "Expect null termination for lower-bound search"); - + // Check to see if this warning starts with "no-", if so, this is a negative // form of the option. bool isPositive = true; @@ -74,7 +74,7 @@ bool clang::ProcessWarningOptions(Diagnostic &Diags, Diags.setSuppressSystemWarnings(!isPositive); continue; } - + // -Werror/-Wno-error is a special case, not controlled by the option table. // It also has the "specifier" form of -Werror=foo and -Werror-foo. if (OptEnd-OptStart >= 5 && memcmp(OptStart, "error", 5) == 0) { @@ -88,21 +88,21 @@ bool clang::ProcessWarningOptions(Diagnostic &Diags, } Specifier = OptStart+6; } - + if (Specifier == 0) { Diags.setWarningsAsErrors(isPositive); continue; } - + // -Werror=foo maps foo to Error, -Wno-error=foo maps it to Warning. Mapping = isPositive ? diag::MAP_ERROR : diag::MAP_WARNING_NO_WERROR; OptStart = Specifier; } - + if (Diags.setDiagnosticGroupMapping(OptStart, Mapping)) Diags.Report(FullSourceLoc(), diag::warn_unknown_warning_option) << ("-W" + Opt); } - + return false; } |
