From c79f6fb108d2de31832e76993aa50fd71ca0783c Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Tue, 4 Jul 2006 17:53:21 +0000 Subject: [PATCH] Rename IdentifierTokenInfo -> IdentifierInfo. llvm-svn: 38650 --- clang/Lex/IdentifierTable.cpp | 18 +++--- clang/Lex/Lexer.cpp | 2 +- clang/Lex/PPExpressions.cpp | 4 +- clang/Lex/Pragma.cpp | 15 +++-- clang/Lex/Preprocessor.cpp | 62 ++++++++++---------- clang/include/clang/Lex/IdentifierTable.h | 16 ++--- clang/include/clang/Lex/LexerToken.h | 12 ++-- clang/include/clang/Lex/MultipleIncludeOpt.h | 8 +-- clang/include/clang/Lex/Pragma.h | 12 ++-- clang/include/clang/Lex/Preprocessor.h | 34 +++++------ 10 files changed, 91 insertions(+), 92 deletions(-) diff --git a/clang/Lex/IdentifierTable.cpp b/clang/Lex/IdentifierTable.cpp index a7da508906f4..6b322f971d7c 100644 --- a/clang/Lex/IdentifierTable.cpp +++ b/clang/Lex/IdentifierTable.cpp @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -// This file implements the IdentifierTokenInfo, IdentifierVisitor, and +// This file implements the IdentifierInfo, IdentifierVisitor, and // IdentifierTable interfaces. // //===----------------------------------------------------------------------===// @@ -19,10 +19,10 @@ using namespace llvm; using namespace clang; //===----------------------------------------------------------------------===// -// IdentifierTokenInfo Implementation +// IdentifierInfo Implementation //===----------------------------------------------------------------------===// -void IdentifierTokenInfo::Destroy() { +void IdentifierInfo::Destroy() { delete Macro; } @@ -57,7 +57,7 @@ public: NextPtr = (char*)(this+1); // FIXME: uses GCC extension. - unsigned Alignment = __alignof__(IdentifierTokenInfo); + unsigned Alignment = __alignof__(IdentifierInfo); NextPtr = (char*)((intptr_t)(NextPtr+Alignment-1) & ~(intptr_t)(Alignment-1)); } @@ -71,7 +71,7 @@ public: /// void *Allocate(unsigned AllocSize, MemRegion **RegPtr) { // FIXME: uses GCC extension. - unsigned Alignment = __alignof__(IdentifierTokenInfo); + unsigned Alignment = __alignof__(IdentifierInfo); // Round size up to an even multiple of the alignment. AllocSize = (AllocSize+Alignment-1) & ~(Alignment-1); @@ -112,13 +112,13 @@ public: //===----------------------------------------------------------------------===// -/// IdentifierLink - There is one of these allocated by IdentifierTokenInfo. +/// IdentifierLink - There is one of these allocated by IdentifierInfo. /// These form the linked list of buckets for the hash table. struct IdentifierBucket { /// Next - This is the next bucket in the linked list. IdentifierBucket *Next; - IdentifierTokenInfo TokInfo; + IdentifierInfo TokInfo; // NOTE: TokInfo must be the last element in this structure, as the string // information for the identifier is allocated right after it. }; @@ -170,7 +170,7 @@ static unsigned HashString(const char *Start, const char *End) { return Result; } -IdentifierTokenInfo &IdentifierTable::get(const char *NameStart, +IdentifierInfo &IdentifierTable::get(const char *NameStart, const char *NameEnd) { IdentifierBucket **TableArray = (IdentifierBucket**)TheTable; @@ -212,7 +212,7 @@ IdentifierTokenInfo &IdentifierTable::get(const char *NameStart, return Identifier->TokInfo; } -IdentifierTokenInfo &IdentifierTable::get(const std::string &Name) { +IdentifierInfo &IdentifierTable::get(const std::string &Name) { // Don't use c_str() here: no need to be null terminated. const char *NameBytes = &Name[0]; unsigned Size = Name.size(); diff --git a/clang/Lex/Lexer.cpp b/clang/Lex/Lexer.cpp index 0fd13eef3961..325c013cdee9 100644 --- a/clang/Lex/Lexer.cpp +++ b/clang/Lex/Lexer.cpp @@ -354,7 +354,7 @@ FinishIdentifier: Result.SetKind(tok::identifier); // Look up this token, see if it is a macro, or if it is a language keyword. - IdentifierTokenInfo *II; + IdentifierInfo *II; if (!Result.needsCleaning()) { // No cleaning needed, just use the characters from the lexed buffer. II = PP.getIdentifierInfo(IdStart, IdEnd); diff --git a/clang/Lex/PPExpressions.cpp b/clang/Lex/PPExpressions.cpp index 979cb171106f..393b780eed78 100644 --- a/clang/Lex/PPExpressions.cpp +++ b/clang/Lex/PPExpressions.cpp @@ -29,7 +29,7 @@ using namespace clang; /// may occur after a #if or #elif directive. If the /// expression is equivalent to "!defined(X)" return X in IfNDefMacro. bool Preprocessor:: -EvaluateDirectiveExpression(IdentifierTokenInfo *&IfNDefMacro) { +EvaluateDirectiveExpression(IdentifierInfo *&IfNDefMacro) { // Peek ahead one token. LexerToken Tok; Lex(Tok); @@ -62,7 +62,7 @@ bool Preprocessor::EvaluateValue(int &Result, LexerToken &PeekTok) { // If this token's spelling is a pp-identifier, check to see if it is // 'defined' or if it is a macro. Note that we check here because many // keywords are pp-identifiers, so we can't check the kind. - if (const IdentifierTokenInfo *II = PeekTok.getIdentifierInfo()) { + if (const IdentifierInfo *II = PeekTok.getIdentifierInfo()) { // If this identifier isn't 'defined' and it wasn't macro expanded, it turns // into a simple 0. if (strcmp(II->getName(), "defined")) { diff --git a/clang/Lex/Pragma.cpp b/clang/Lex/Pragma.cpp index 9b0fe5f495af..fd9aba8c24ca 100644 --- a/clang/Lex/Pragma.cpp +++ b/clang/Lex/Pragma.cpp @@ -39,7 +39,7 @@ PragmaNamespace::~PragmaNamespace() { /// specified name. If not, return the handler for the null identifier if it /// exists, otherwise return null. If IgnoreNull is true (the default) then /// the null handler isn't returned on failure to match. -PragmaHandler *PragmaNamespace::FindHandler(const IdentifierTokenInfo *Name, +PragmaHandler *PragmaNamespace::FindHandler(const IdentifierInfo *Name, bool IgnoreNull) const { PragmaHandler *NullHandler = 0; for (unsigned i = 0, e = Handlers.size(); i != e; ++i) { @@ -206,8 +206,7 @@ void Preprocessor::HandlePragmaPoison(LexerToken &PoisonTok) { // Look up the identifier info for the token. std::string TokStr = getSpelling(Tok); - IdentifierTokenInfo *II = - getIdentifierInfo(&TokStr[0], &TokStr[0]+TokStr.size()); + IdentifierInfo *II =getIdentifierInfo(&TokStr[0], &TokStr[0]+TokStr.size()); // Already poisoned. if (II->isPoisoned()) continue; @@ -293,7 +292,7 @@ void Preprocessor::AddPragmaHandler(const char *Namespace, // If this is specified to be in a namespace, step down into it. if (Namespace) { - IdentifierTokenInfo *NSID = getIdentifierInfo(Namespace); + IdentifierInfo *NSID = getIdentifierInfo(Namespace); // If there is already a pragma handler with the name of this namespace, // we either have an error (directive with the same name as a namespace) or @@ -318,7 +317,7 @@ void Preprocessor::AddPragmaHandler(const char *Namespace, namespace { struct PragmaOnceHandler : public PragmaHandler { - PragmaOnceHandler(const IdentifierTokenInfo *OnceID) : PragmaHandler(OnceID){} + PragmaOnceHandler(const IdentifierInfo *OnceID) : PragmaHandler(OnceID) {} virtual void HandlePragma(Preprocessor &PP, LexerToken &OnceTok) { PP.CheckEndOfDirective("#pragma once"); PP.HandlePragmaOnce(OnceTok); @@ -326,21 +325,21 @@ struct PragmaOnceHandler : public PragmaHandler { }; struct PragmaPoisonHandler : public PragmaHandler { - PragmaPoisonHandler(const IdentifierTokenInfo *ID) : PragmaHandler(ID) {} + PragmaPoisonHandler(const IdentifierInfo *ID) : PragmaHandler(ID) {} virtual void HandlePragma(Preprocessor &PP, LexerToken &PoisonTok) { PP.HandlePragmaPoison(PoisonTok); } }; struct PragmaSystemHeaderHandler : public PragmaHandler { - PragmaSystemHeaderHandler(const IdentifierTokenInfo *ID) : PragmaHandler(ID){} + PragmaSystemHeaderHandler(const IdentifierInfo *ID) : PragmaHandler(ID) {} virtual void HandlePragma(Preprocessor &PP, LexerToken &SHToken) { PP.HandlePragmaSystemHeader(SHToken); PP.CheckEndOfDirective("#pragma"); } }; struct PragmaDependencyHandler : public PragmaHandler { - PragmaDependencyHandler(const IdentifierTokenInfo *ID) : PragmaHandler(ID) {} + PragmaDependencyHandler(const IdentifierInfo *ID) : PragmaHandler(ID) {} virtual void HandlePragma(Preprocessor &PP, LexerToken &DepToken) { PP.HandlePragmaDependency(DepToken); } diff --git a/clang/Lex/Preprocessor.cpp b/clang/Lex/Preprocessor.cpp index 7c3b7138ec59..b5cae2df2f66 100644 --- a/clang/Lex/Preprocessor.cpp +++ b/clang/Lex/Preprocessor.cpp @@ -421,7 +421,7 @@ void Preprocessor::EnterSourceFileWithLexer(Lexer *TheLexer, /// EnterMacro - Add a Macro to the top of the include stack and start lexing /// tokens from it instead of the current buffer. void Preprocessor::EnterMacro(LexerToken &Tok) { - IdentifierTokenInfo *Identifier = Tok.getIdentifierInfo(); + IdentifierInfo *Identifier = Tok.getIdentifierInfo(); MacroInfo &MI = *Identifier->getMacroInfo(); IncludeMacroStack.push_back(IncludeStackInfo(CurLexer, CurDirLookup, CurMacroExpander)); @@ -442,9 +442,9 @@ void Preprocessor::EnterMacro(LexerToken &Tok) { /// RegisterBuiltinMacro - Register the specified identifier in the identifier /// table and mark it as a builtin macro to be expanded. -IdentifierTokenInfo *Preprocessor::RegisterBuiltinMacro(const char *Name) { +IdentifierInfo *Preprocessor::RegisterBuiltinMacro(const char *Name) { // Get the identifier. - IdentifierTokenInfo *Id = getIdentifierInfo(Name); + IdentifierInfo *Id = getIdentifierInfo(Name); // Mark it as being a macro that is builtin. MacroInfo *MI = new MacroInfo(SourceLocation()); @@ -578,12 +578,12 @@ static void ComputeDATE_TIME(SourceLocation &DATELoc, SourceLocation &TIMELoc, /// as a builtin macro, handle it and return the next token as 'Tok'. void Preprocessor::ExpandBuiltinMacro(LexerToken &Tok) { // Figure out which token this is. - IdentifierTokenInfo *ITI = Tok.getIdentifierInfo(); - assert(ITI && "Can't be a macro without id info!"); + IdentifierInfo *II = Tok.getIdentifierInfo(); + assert(II && "Can't be a macro without id info!"); // If this is an _Pragma directive, expand it, invoke the pragma handler, then // lex the token after it. - if (ITI == Ident_Pragma) + if (II == Ident_Pragma) return Handle_Pragma(Tok); char TmpBuffer[100]; @@ -592,16 +592,16 @@ void Preprocessor::ExpandBuiltinMacro(LexerToken &Tok) { Tok.SetIdentifierInfo(0); Tok.ClearFlag(LexerToken::NeedsCleaning); - if (ITI == Ident__LINE__) { + if (II == Ident__LINE__) { // __LINE__ expands to a simple numeric value. sprintf(TmpBuffer, "%u", SourceMgr.getLineNumber(Tok.getLocation())); unsigned Length = strlen(TmpBuffer); Tok.SetKind(tok::numeric_constant); Tok.SetLength(Length); Tok.SetLocation(ScratchBuf->getToken(TmpBuffer, Length, Tok.getLocation())); - } else if (ITI == Ident__FILE__ || ITI == Ident__BASE_FILE__) { + } else if (II == Ident__FILE__ || II == Ident__BASE_FILE__) { SourceLocation Loc = Tok.getLocation(); - if (ITI == Ident__BASE_FILE__) { + if (II == Ident__BASE_FILE__) { Diag(Tok, diag::ext_pp_base_file); SourceLocation NextLoc = SourceMgr.getIncludeLoc(Loc.getFileID()); while (NextLoc.getFileID() != 0) { @@ -616,19 +616,19 @@ void Preprocessor::ExpandBuiltinMacro(LexerToken &Tok) { Tok.SetKind(tok::string_literal); Tok.SetLength(FN.size()); Tok.SetLocation(ScratchBuf->getToken(&FN[0], FN.size(), Tok.getLocation())); - } else if (ITI == Ident__DATE__) { + } else if (II == Ident__DATE__) { if (!DATELoc.isValid()) ComputeDATE_TIME(DATELoc, TIMELoc, ScratchBuf); Tok.SetKind(tok::string_literal); Tok.SetLength(strlen("\"Mmm dd yyyy\"")); Tok.SetLocation(SourceMgr.getInstantiationLoc(DATELoc, Tok.getLocation())); - } else if (ITI == Ident__TIME__) { + } else if (II == Ident__TIME__) { if (!TIMELoc.isValid()) ComputeDATE_TIME(DATELoc, TIMELoc, ScratchBuf); Tok.SetKind(tok::string_literal); Tok.SetLength(strlen("\"hh:mm:ss\"")); Tok.SetLocation(SourceMgr.getInstantiationLoc(TIMELoc, Tok.getLocation())); - } else if (ITI == Ident__INCLUDE_LEVEL__) { + } else if (II == Ident__INCLUDE_LEVEL__) { Diag(Tok, diag::ext_pp_include_level); // Compute the include depth of this token. @@ -643,7 +643,7 @@ void Preprocessor::ExpandBuiltinMacro(LexerToken &Tok) { Tok.SetKind(tok::numeric_constant); Tok.SetLength(Length); Tok.SetLocation(ScratchBuf->getToken(TmpBuffer, Length, Tok.getLocation())); - } else if (ITI == Ident__TIMESTAMP__) { + } else if (II == Ident__TIMESTAMP__) { // MSVC, ICC, GCC, VisualAge C++ extension. The generated string should be // of the form "Ddd Mmm dd hh::mm::ss yyyy", which is returned by asctime. Diag(Tok, diag::ext_pp_timestamp); @@ -682,9 +682,9 @@ struct UnusedIdentifierReporter : public IdentifierVisitor { Preprocessor &PP; UnusedIdentifierReporter(Preprocessor &pp) : PP(pp) {} - void VisitIdentifier(IdentifierTokenInfo &ITI) const { - if (ITI.getMacroInfo() && !ITI.getMacroInfo()->isUsed()) - PP.Diag(ITI.getMacroInfo()->getDefinitionLoc(), diag::pp_macro_not_used); + void VisitIdentifier(IdentifierInfo &II) const { + if (II.getMacroInfo() && !II.getMacroInfo()->isUsed()) + PP.Diag(II.getMacroInfo()->getDefinitionLoc(), diag::pp_macro_not_used); } }; } @@ -703,23 +703,23 @@ void Preprocessor::HandleIdentifier(LexerToken &Identifier) { assert(isSkipping() && "Token isn't an identifier?"); return; } - IdentifierTokenInfo &ITI = *Identifier.getIdentifierInfo(); + IdentifierInfo &II = *Identifier.getIdentifierInfo(); // If this identifier was poisoned, and if it was not produced from a macro // expansion, emit an error. - if (ITI.isPoisoned() && CurLexer) + if (II.isPoisoned() && CurLexer) Diag(Identifier, diag::err_pp_used_poisoned_id); - if (MacroInfo *MI = ITI.getMacroInfo()) + if (MacroInfo *MI = II.getMacroInfo()) if (MI->isEnabled() && !DisableMacroExpansion) return HandleMacroExpandedIdentifier(Identifier, MI); // Change the kind of this identifier to the appropriate token kind, e.g. // turning "for" into a keyword. - Identifier.SetKind(ITI.getTokenID()); + Identifier.SetKind(II.getTokenID()); // If this is an extension token, diagnose its use. - if (ITI.isExtensionToken()) Diag(Identifier, diag::ext_token_used); + if (II.isExtensionToken()) Diag(Identifier, diag::ext_token_used); } /// HandleEndOfFile - This callback is invoked when the lexer hits the end of @@ -743,7 +743,7 @@ void Preprocessor::HandleEndOfFile(LexerToken &Result, bool isEndOfMacro) { // See if this file had a controlling macro. if (CurLexer) { // Not ending a macro, ignore it. - if (const IdentifierTokenInfo *ControllingMacro = + if (const IdentifierInfo *ControllingMacro = CurLexer->MIOpt.GetControllingMacroAtEndOfFile()) { // Okay, this has a controlling macro, remember in PerFileInfo. if (const FileEntry *FE = @@ -788,7 +788,7 @@ void Preprocessor::HandleEndOfFile(LexerToken &Result, bool isEndOfMacro) { CurLexer = 0; // This is the end of the top-level file. - IdentifierInfo.VisitIdentifiers(UnusedIdentifierReporter(*this)); + Identifiers.VisitIdentifiers(UnusedIdentifierReporter(*this)); } /// HandleEndOfMacro - This callback is invoked when the lexer hits the end of @@ -833,19 +833,19 @@ void Preprocessor::ReadMacroName(LexerToken &MacroNameTok, bool isDefineUndef) { if (MacroNameTok.getKind() == tok::eom) return Diag(MacroNameTok, diag::err_pp_missing_macro_name); - IdentifierTokenInfo *ITI = MacroNameTok.getIdentifierInfo(); - if (ITI == 0) { + IdentifierInfo *II = MacroNameTok.getIdentifierInfo(); + if (II == 0) { Diag(MacroNameTok, diag::err_pp_macro_not_identifier); // Fall through on error. } else if (0) { // FIXME: C++. Error if defining a C++ named operator. - } else if (isDefineUndef && ITI->getName()[0] == 'd' && // defined - !strcmp(ITI->getName()+1, "efined")) { + } else if (isDefineUndef && II->getName()[0] == 'd' && // defined + !strcmp(II->getName()+1, "efined")) { // Error if defining "defined": C99 6.10.8.4. Diag(MacroNameTok, diag::err_defined_macro_name); - } else if (isDefineUndef && ITI->getMacroInfo() && - ITI->getMacroInfo()->isBuiltinMacro()) { + } else if (isDefineUndef && II->getMacroInfo() && + II->getMacroInfo()->isBuiltinMacro()) { // Error if defining "__LINE__" and other builtins: C99 6.10.8.4. Diag(MacroNameTok, diag::pp_undef_builtin_macro); } else { @@ -1020,7 +1020,7 @@ void Preprocessor::SkipExcludedConditionalBlock(SourceLocation IfTokenLoc, // looked up, etc, inside the #elif expression. assert(SkippingContents && "We have to be skipping here!"); SkippingContents = false; - IdentifierTokenInfo *IfNDefMacro = 0; + IdentifierInfo *IfNDefMacro = 0; ShouldEnter = EvaluateDirectiveExpression(IfNDefMacro); SkippingContents = true; } @@ -1455,7 +1455,7 @@ void Preprocessor::HandleIfDirective(LexerToken &IfToken, ++NumIf; // Parse and evaluation the conditional expression. - IdentifierTokenInfo *IfNDefMacro = 0; + IdentifierInfo *IfNDefMacro = 0; bool ConditionalTrue = EvaluateDirectiveExpression(IfNDefMacro); // Should we include the stuff contained by this directive? diff --git a/clang/include/clang/Lex/IdentifierTable.h b/clang/include/clang/Lex/IdentifierTable.h index 3c02e1788efc..c3a1a74b926b 100644 --- a/clang/include/clang/Lex/IdentifierTable.h +++ b/clang/include/clang/Lex/IdentifierTable.h @@ -7,7 +7,7 @@ // //===----------------------------------------------------------------------===// // -// This file defines the IdentifierTokenInfo, IdentifierVisitor, and +// This file defines the IdentifierInfo, IdentifierVisitor, and // IdentifierTable interfaces. // //===----------------------------------------------------------------------===// @@ -23,12 +23,12 @@ namespace clang { class IdentifierTable; class MacroInfo; -/// IdentifierTokenInfo - One of these records is kept for each identifier that +/// IdentifierInfo - One of these records is kept for each identifier that /// is lexed. This contains information about whether the token was #define'd, /// is a language keyword, or if it is a front-end token of some sort (e.g. a /// variable or function name). The preprocessor keeps this information in a /// set, and all tok::identifier tokens have a pointer to one of these. -class IdentifierTokenInfo { +class IdentifierInfo { unsigned NameLen; // String that is the identifier. MacroInfo *Macro; // Set if this identifier is #define'd. tok::TokenKind TokenID:8; // Front-end token ID or tok::identifier. @@ -42,7 +42,7 @@ public: /// terminated. /// const char *getName() const { - // String data is stored immediately after the IdentifierTokenInfo object. + // String data is stored immediately after the IdentifierInfo object. return (const char*)(this+1); } @@ -90,11 +90,11 @@ private: class IdentifierVisitor { public: virtual ~IdentifierVisitor(); - virtual void VisitIdentifier(IdentifierTokenInfo &ITI) const = 0; + virtual void VisitIdentifier(IdentifierInfo &II) const = 0; }; /// IdentifierTable - This table implements an efficient mapping from strings to -/// IdentifierTokenInfo nodes. It has no other purpose, but this is an +/// IdentifierInfo nodes. It has no other purpose, but this is an /// extremely performance-critical piece of the code, as each occurrance of /// every identifier goes through here when lexed. class IdentifierTable { @@ -107,8 +107,8 @@ public: /// get - Return the identifier token info for the specified named identifier. /// - IdentifierTokenInfo &get(const char *NameStart, const char *NameEnd); - IdentifierTokenInfo &get(const std::string &Name); + IdentifierInfo &get(const char *NameStart, const char *NameEnd); + IdentifierInfo &get(const std::string &Name); /// VisitIdentifiers - This method walks through all of the identifiers, /// invoking IV->VisitIdentifier for each of them. diff --git a/clang/include/clang/Lex/LexerToken.h b/clang/include/clang/Lex/LexerToken.h index c8d3c4e58acf..48e196482c09 100644 --- a/clang/include/clang/Lex/LexerToken.h +++ b/clang/include/clang/Lex/LexerToken.h @@ -20,7 +20,7 @@ namespace llvm { namespace clang { -class IdentifierTokenInfo; +class IdentifierInfo; /// LexerToken - This structure provides full information about a lexed token. /// it is not intended to be space efficient, it is intended to return as much @@ -33,7 +33,7 @@ class LexerToken { /// IdentifierInfo - If this was an identifier, this points to the uniqued /// information about this identifier. - IdentifierTokenInfo *IdentifierInfo; + IdentifierInfo *IdentInfo; /// Kind - The actual flavor of token this is. /// @@ -67,13 +67,13 @@ public: /// void StartToken() { Flags = 0; - IdentifierInfo = 0; + IdentInfo = 0; Loc = SourceLocation(); } - IdentifierTokenInfo *getIdentifierInfo() const { return IdentifierInfo; } - void SetIdentifierInfo(IdentifierTokenInfo *II) { - IdentifierInfo = II; + IdentifierInfo *getIdentifierInfo() const { return IdentInfo; } + void SetIdentifierInfo(IdentifierInfo *II) { + IdentInfo = II; } /// SetFlag - Set the specified flag. diff --git a/clang/include/clang/Lex/MultipleIncludeOpt.h b/clang/include/clang/Lex/MultipleIncludeOpt.h index ec00c02ea10c..724abc96eb01 100644 --- a/clang/include/clang/Lex/MultipleIncludeOpt.h +++ b/clang/include/clang/Lex/MultipleIncludeOpt.h @@ -16,7 +16,7 @@ namespace llvm { namespace clang { -class IdentifierTokenInfo; +class IdentifierInfo; /// MultipleIncludeOpt - This class implements the simple state machine that the /// Lexer class uses to detect files subject to the 'multiple-include' @@ -33,7 +33,7 @@ class MultipleIncludeOpt { /// TheMacro - The controlling macro for a file, if valid. /// - const IdentifierTokenInfo *TheMacro; + const IdentifierInfo *TheMacro; public: MultipleIncludeOpt() : ReadAnyTokens(false), TheMacro(0) {} @@ -57,7 +57,7 @@ public: /// EnterTopLevelIFNDEF - When entering a top-level #ifndef directive (or the /// "#if !defined" equivalent) without any preceding tokens, this method is /// called. - void EnterTopLevelIFNDEF(const IdentifierTokenInfo *M) { + void EnterTopLevelIFNDEF(const IdentifierInfo *M) { // Note, we don't care about the input value of 'ReadAnyTokens'. The caller // ensures that this is only called if there are no tokens read before the // #ifndef. @@ -94,7 +94,7 @@ public: /// GetControllingMacroAtEndOfFile - Once the entire file has been lexed, if /// there is a controlling macro, return it. - const IdentifierTokenInfo *GetControllingMacroAtEndOfFile() const { + const IdentifierInfo *GetControllingMacroAtEndOfFile() const { // If we haven't read any tokens after the #endif, return the controlling // macro if it's valid (if it isn't, it will be null). if (!ReadAnyTokens) diff --git a/clang/include/clang/Lex/Pragma.h b/clang/include/clang/Lex/Pragma.h index e598687f898c..f99453a9ae63 100644 --- a/clang/include/clang/Lex/Pragma.h +++ b/clang/include/clang/Lex/Pragma.h @@ -21,7 +21,7 @@ namespace llvm { namespace clang { class Preprocessor; class LexerToken; - class IdentifierTokenInfo; + class IdentifierInfo; class PragmaNamespace; /// PragmaHandler - Instances of this interface defined to handle the various @@ -34,12 +34,12 @@ namespace clang { /// we treat "#pragma STDC" and "#pragma GCC" as namespaces that contain other /// pragmas. class PragmaHandler { - const IdentifierTokenInfo *Name; + const IdentifierInfo *Name; public: - PragmaHandler(const IdentifierTokenInfo *name) : Name(name) {} + PragmaHandler(const IdentifierInfo *name) : Name(name) {} virtual ~PragmaHandler(); - const IdentifierTokenInfo *getName() const { return Name; } + const IdentifierInfo *getName() const { return Name; } virtual void HandlePragma(Preprocessor &PP, LexerToken &FirstToken) = 0; /// getIfNamespace - If this is a namespace, return it. This is equivalent to @@ -56,14 +56,14 @@ class PragmaNamespace : public PragmaHandler { /// std::vector Handlers; public: - PragmaNamespace(const IdentifierTokenInfo *Name) : PragmaHandler(Name) {} + PragmaNamespace(const IdentifierInfo *Name) : PragmaHandler(Name) {} virtual ~PragmaNamespace(); /// FindHandler - Check to see if there is already a handler for the /// specified name. If not, return the handler for the null identifier if it /// exists, otherwise return null. If IgnoreNull is true (the default) then /// the null handler isn't returned on failure to match. - PragmaHandler *FindHandler(const IdentifierTokenInfo *Name, + PragmaHandler *FindHandler(const IdentifierInfo *Name, bool IgnoreNull = true) const; /// AddPragma - Add a pragma to this namespace. diff --git a/clang/include/clang/Lex/Preprocessor.h b/clang/include/clang/Lex/Preprocessor.h index 082fadc90118..5fd8b1a74f2a 100644 --- a/clang/include/clang/Lex/Preprocessor.h +++ b/clang/include/clang/Lex/Preprocessor.h @@ -93,12 +93,12 @@ class Preprocessor { bool NoCurDirSearch; /// Identifiers for builtin macros. - IdentifierTokenInfo *Ident__LINE__, *Ident__FILE__; // __LINE__, __FILE__ - IdentifierTokenInfo *Ident__DATE__, *Ident__TIME__; // __DATE__, __TIME__ - IdentifierTokenInfo *Ident__INCLUDE_LEVEL__; // __INCLUDE_LEVEL__ - IdentifierTokenInfo *Ident__BASE_FILE__; // __BASE_FILE__ - IdentifierTokenInfo *Ident__TIMESTAMP__; // __TIMESTAMP__ - IdentifierTokenInfo *Ident_Pragma; // _Pragma + IdentifierInfo *Ident__LINE__, *Ident__FILE__; // __LINE__, __FILE__ + IdentifierInfo *Ident__DATE__, *Ident__TIME__; // __DATE__, __TIME__ + IdentifierInfo *Ident__INCLUDE_LEVEL__; // __INCLUDE_LEVEL__ + IdentifierInfo *Ident__BASE_FILE__; // __BASE_FILE__ + IdentifierInfo *Ident__TIMESTAMP__; // __TIMESTAMP__ + IdentifierInfo *Ident_Pragma; // _Pragma SourceLocation DATELoc, TIMELoc; public: @@ -131,9 +131,9 @@ private: bool DisableMacroExpansion; // True if macro expansion is disabled. bool SkippingContents; // True if in a #if 0 block. - /// IdentifierInfo - This is mapping/lookup information for all identifiers in + /// Identifiers - This is mapping/lookup information for all identifiers in /// the program, including program keywords. - IdentifierTable IdentifierInfo; + IdentifierTable Identifiers; /// PragmaHandlers - This tracks all of the pragmas that the client registered /// with this preprocessor. @@ -184,7 +184,7 @@ private: /// ControllingMacro - If this file has a #ifndef XXX (or equivalent) guard /// that protects the entire contents of the file, this is the identifier /// for the macro that controls whether or not it has any effect. - const IdentifierTokenInfo *ControllingMacro; + const IdentifierInfo *ControllingMacro; PerFileInfo() : isImport(false), DirInfo(DirectoryLookup::NormalHeaderDir), NumIncludes(0), ControllingMacro(0) {} @@ -211,7 +211,7 @@ public: FileManager &getFileManager() const { return FileMgr; } SourceManager &getSourceManager() const { return SourceMgr; } - IdentifierTable &getIdentifierTable() { return IdentifierInfo; } + IdentifierTable &getIdentifierTable() { return Identifiers; } /// isSkipping - Return true if we're lexing a '#if 0' block. This causes /// lexer errors/warnings to get ignored. @@ -262,13 +262,13 @@ public: /// pointers is preferred unless the identifier is already available as a /// string (this avoids allocation and copying of memory to construct an /// std::string). - IdentifierTokenInfo *getIdentifierInfo(const char *NameStart, - const char *NameEnd) { + IdentifierInfo *getIdentifierInfo(const char *NameStart, + const char *NameEnd) { // If we are in a "#if 0" block, don't bother lookup up identifiers. if (SkippingContents) return 0; - return &IdentifierInfo.get(NameStart, NameEnd); + return &Identifiers.get(NameStart, NameEnd); } - IdentifierTokenInfo *getIdentifierInfo(const char *NameStr) { + IdentifierInfo *getIdentifierInfo(const char *NameStr) { return getIdentifierInfo(NameStr, NameStr+strlen(NameStr)); } @@ -288,7 +288,7 @@ public: if (Flags+Features.NoExtensions >= 2) return; const char *Str = &Keyword[0]; - IdentifierTokenInfo &Info = *getIdentifierInfo(Str, Str+Keyword.size()); + IdentifierInfo &Info = *getIdentifierInfo(Str, Str+Keyword.size()); Info.setTokenID(TokenCode); Info.setIsExtensionToken(Flags == 1); } @@ -431,7 +431,7 @@ private: /// EvaluateDirectiveExpression - Evaluate an integer constant expression that /// may occur after a #if or #elif directive and return it as a bool. If the /// expression is equivalent to "!defined(X)" return X in IfNDefMacro. - bool EvaluateDirectiveExpression(IdentifierTokenInfo *&IfNDefMacro); + bool EvaluateDirectiveExpression(IdentifierInfo *&IfNDefMacro); /// EvaluateValue/EvaluateDirectiveSubExpr - Used to implement /// EvaluateDirectiveExpression, see PPExpressions.cpp. bool EvaluateValue(int &Result, LexerToken &PeekTok); @@ -445,7 +445,7 @@ private: /// RegisterBuiltinMacros - Register builtin macros, such as __LINE__ with the /// identifier table. void RegisterBuiltinMacros(); - IdentifierTokenInfo *RegisterBuiltinMacro(const char *Name); + IdentifierInfo *RegisterBuiltinMacro(const char *Name); /// HandleMacroExpandedIdentifier - If an identifier token is read that is to /// be expanded as a macro, handle it and return the next token as 'Tok'.