Preprocessor.cpp revision 88e2524b8f3393975872a23bbe6e8b3cf50d6773
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- Preprocess.cpp - C Language Family Preprocessor Implementation ---===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This file implements the Preprocessor interface. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Options to support: 155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// -H - Print the name of each header file used. 16f73903a1ded46748e1dfda151f5d037b7b3d31f9Chris Lattner// -d[DNI] - Dump various things. 175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// -fworking-directory - #line's with preprocessor's working dir. 185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// -fpreprocessed 195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// -dependency-file,-M,-MM,-MF,-MG,-MP,-MT,-MQ,-MD,-MMD 205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// -W* 215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// -w 225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Messages to emit: 245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// "Multiple include guards may be useful for:\n" 255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Lex/Preprocessor.h" 295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Lex/HeaderSearch.h" 305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Lex/MacroInfo.h" 315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Lex/Pragma.h" 325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Lex/ScratchBuffer.h" 33500d3297d2a21edeac4d46cbcbe21bc2352c2a28Chris Lattner#include "clang/Lex/LexDiagnostic.h" 345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/SourceManager.h" 35337edcdbec05316b407d0d64865c88ff8597d910Ted Kremenek#include "clang/Basic/FileManager.h" 365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/Basic/TargetInfo.h" 372db78dd977fbba8fdf24cf8a4593436c031cfbcbChris Lattner#include "llvm/ADT/APFloat.h" 385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "llvm/ADT/SmallVector.h" 3997ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner#include "llvm/Support/MemoryBuffer.h" 40bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek#include "llvm/Support/Streams.h" 413daed52a57d03765223021f5f921bdc280c8f3ccChris Lattner#include <cstdio> 425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 445f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 46ec6c574478a22008847d7ebc2498ef3336752096Ted KremenekPreprocessorFactory::~PreprocessorFactory() {} 47ec6c574478a22008847d7ebc2498ef3336752096Ted Kremenek 485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerPreprocessor::Preprocessor(Diagnostic &diags, const LangOptions &opts, 495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer TargetInfo &target, SourceManager &SM, 5072b1b15ee88aac0a63e2c1dc53fe22f5ab297b20Ted Kremenek HeaderSearch &Headers, 5172b1b15ee88aac0a63e2c1dc53fe22f5ab297b20Ted Kremenek IdentifierInfoLookup* IILookup) 52836040f9eafe862fb1607df5c30cd3df0c22c832Chris Lattner : Diags(&diags), Features(opts), Target(target),FileMgr(Headers.getFileMgr()), 5372b1b15ee88aac0a63e2c1dc53fe22f5ab297b20Ted Kremenek SourceMgr(SM), HeaderInfo(Headers), Identifiers(opts, IILookup), 544b71e3e439080e69cd369313bf2ad2c85bac8267Ted Kremenek CurPPLexer(0), CurDirLookup(0), Callbacks(0) { 555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ScratchBuf = new ScratchBuffer(SourceMgr); 56c1f9d828c733ec1eba06d01070735d1f36fda733Chris Lattner CounterValue = 0; // __COUNTER__ starts at 0. 57c1f9d828c733ec1eba06d01070735d1f36fda733Chris Lattner 585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Clear stats. 595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer NumDirectives = NumDefined = NumUndefined = NumPragma = 0; 605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer NumIf = NumElse = NumEndif = 0; 615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer NumEnteredSourceFiles = 0; 625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer NumMacroExpanded = NumFnMacroExpanded = NumBuiltinMacroExpanded = 0; 635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer NumFastMacroExpanded = NumTokenPaste = NumFastTokenPaste = 0; 645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer MaxIncludeStackDepth = 0; 655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer NumSkipped = 0; 665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Default to discarding comments. 685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer KeepComments = false; 695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer KeepMacroComments = false; 705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Macro expansion is enabled. 725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DisableMacroExpansion = false; 735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer InMacroArgs = false; 746cfe7594a46b5d270142cfcb688a9c1a3a487a48Chris Lattner NumCachedTokenLexers = 0; 755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 7603db1b31dd926409b7defc1c90b66549464652c0Argyrios Kyrtzidis CachedLexPos = 0; 7703db1b31dd926409b7defc1c90b66549464652c0Argyrios Kyrtzidis 785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // "Poison" __VA_ARGS__, which can only appear in the expansion of a macro. 795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // This gets unpoisoned where it is allowed. 805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer (Ident__VA_ARGS__ = getIdentifierInfo("__VA_ARGS__"))->setIsPoisoned(); 815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Initialize the pragma handlers. 835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer PragmaHandlers = new PragmaNamespace(0); 845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RegisterBuiltinPragmas(); 855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Initialize builtin macros like __LINE__ and friends. 875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer RegisterBuiltinMacros(); 885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid SpencerPreprocessor::~Preprocessor() { 912174a4ff834b72c0a0e3f24e4b62123f30f4cce6Argyrios Kyrtzidis assert(BacktrackPositions.empty() && "EnableBacktrack/Backtrack imbalance!"); 922174a4ff834b72c0a0e3f24e4b62123f30f4cce6Argyrios Kyrtzidis 935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer while (!IncludeMacroStack.empty()) { 945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer delete IncludeMacroStack.back().TheLexer; 956cfe7594a46b5d270142cfcb688a9c1a3a487a48Chris Lattner delete IncludeMacroStack.back().TheTokenLexer; 965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer IncludeMacroStack.pop_back(); 975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 98cc1a875f94630e58d24a55577ffbf0e89b7da8c7Chris Lattner 99cc1a875f94630e58d24a55577ffbf0e89b7da8c7Chris Lattner // Free any macro definitions. 100cc1a875f94630e58d24a55577ffbf0e89b7da8c7Chris Lattner for (llvm::DenseMap<IdentifierInfo*, MacroInfo*>::iterator I = 101cc1a875f94630e58d24a55577ffbf0e89b7da8c7Chris Lattner Macros.begin(), E = Macros.end(); I != E; ++I) { 1020ea76727ae91bca918a8414ed85b530eddcfedebTed Kremenek // We don't need to free the MacroInfo objects directly. These 1030ea76727ae91bca918a8414ed85b530eddcfedebTed Kremenek // will be released when the BumpPtrAllocator 'BP' object gets 1049ee7d456b427e002f7fe1844b64bec8055c8db52Ted Kremenek // destroyed. We still need to run the dstor, however, to free 1059ee7d456b427e002f7fe1844b64bec8055c8db52Ted Kremenek // memory alocated by MacroInfo. 106685befeb5f6472585bae473a6389e47cab9eac67Chris Lattner I->second->Destroy(BP); 107cc1a875f94630e58d24a55577ffbf0e89b7da8c7Chris Lattner I->first->setHasMacroDefinition(false); 108cc1a875f94630e58d24a55577ffbf0e89b7da8c7Chris Lattner } 1095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1109594acf32de2939b15eafa8fe818607bfc56bf66Chris Lattner // Free any cached macro expanders. 1116cfe7594a46b5d270142cfcb688a9c1a3a487a48Chris Lattner for (unsigned i = 0, e = NumCachedTokenLexers; i != e; ++i) 1126cfe7594a46b5d270142cfcb688a9c1a3a487a48Chris Lattner delete TokenLexerCache[i]; 1139594acf32de2939b15eafa8fe818607bfc56bf66Chris Lattner 1145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Release pragma information. 1155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer delete PragmaHandlers; 1165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Delete the scratch buffer info. 1185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer delete ScratchBuf; 119eb50ed88c2aa040fac08bf2a50bde4dd3da6eb19Chris Lattner 120eb50ed88c2aa040fac08bf2a50bde4dd3da6eb19Chris Lattner delete Callbacks; 1215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 123337edcdbec05316b407d0d64865c88ff8597d910Ted Kremenekvoid Preprocessor::setPTHManager(PTHManager* pm) { 124337edcdbec05316b407d0d64865c88ff8597d910Ted Kremenek PTH.reset(pm); 125337edcdbec05316b407d0d64865c88ff8597d910Ted Kremenek FileMgr.setStatCache(PTH->createStatCache()); 126337edcdbec05316b407d0d64865c88ff8597d910Ted Kremenek} 127337edcdbec05316b407d0d64865c88ff8597d910Ted Kremenek 128d217773f106856a11879ec79dc468efefaf2ee75Chris Lattnervoid Preprocessor::DumpToken(const Token &Tok, bool DumpFlags) const { 129bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << tok::getTokenName(Tok.getKind()) << " '" 130bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek << getSpelling(Tok) << "'"; 1315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!DumpFlags) return; 133c3d8d57b010e2ed15a2a7685d5761db14f5d2252Chris Lattner 134bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << "\t"; 1355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Tok.isAtStartOfLine()) 136bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " [StartOfLine]"; 1375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Tok.hasLeadingSpace()) 138bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " [LeadingSpace]"; 1395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Tok.isExpandDisabled()) 140bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " [ExpandDisabled]"; 1415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (Tok.needsCleaning()) { 1425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const char *Start = SourceMgr.getCharacterData(Tok.getLocation()); 143bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " [UnClean='" << std::string(Start, Start+Tok.getLength()) 144bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek << "']"; 1455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 146c3d8d57b010e2ed15a2a7685d5761db14f5d2252Chris Lattner 147bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << "\tLoc=<"; 148c3d8d57b010e2ed15a2a7685d5761db14f5d2252Chris Lattner DumpLocation(Tok.getLocation()); 149bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << ">"; 150c3d8d57b010e2ed15a2a7685d5761db14f5d2252Chris Lattner} 151c3d8d57b010e2ed15a2a7685d5761db14f5d2252Chris Lattner 152c3d8d57b010e2ed15a2a7685d5761db14f5d2252Chris Lattnervoid Preprocessor::DumpLocation(SourceLocation Loc) const { 153b9c3f966b103f7cfe8e5e60007c4c8b38f7298ebChris Lattner Loc.dump(SourceMgr); 1545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid Preprocessor::DumpMacro(const MacroInfo &MI) const { 157bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << "MACRO: "; 1585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0, e = MI.getNumTokens(); i != e; ++i) { 1595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DumpToken(MI.getReplacementToken(i)); 160bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " "; 1615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 162bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << "\n"; 1635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencervoid Preprocessor::PrintStats() { 166bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << "\n*** Preprocessor Stats:\n"; 167bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << NumDirectives << " directives found:\n"; 168bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " " << NumDefined << " #define.\n"; 169bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " " << NumUndefined << " #undef.\n"; 170bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " #include/#include_next/#import:\n"; 171bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " " << NumEnteredSourceFiles << " source files entered.\n"; 172bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " " << MaxIncludeStackDepth << " max include stack depth\n"; 173bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " " << NumIf << " #if/#ifndef/#ifdef.\n"; 174bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " " << NumElse << " #else/#elif.\n"; 175bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " " << NumEndif << " #endif.\n"; 176bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << " " << NumPragma << " #pragma.\n"; 177bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << NumSkipped << " #if/#ifndef#ifdef regions skipped\n"; 178bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek 179bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << NumMacroExpanded << "/" << NumFnMacroExpanded << "/" 180bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek << NumBuiltinMacroExpanded << " obj/fn/builtin macros expanded, " 181bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek << NumFastMacroExpanded << " on the fast path.\n"; 182bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek llvm::cerr << (NumFastTokenPaste+NumTokenPaste) 183bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek << " token paste (##) operations performed, " 184bdd30c26bd93a89ae0fe125e9aae8b7c05e55324Ted Kremenek << NumFastTokenPaste << " on the fast path.\n"; 1855f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 1865f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1875f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Token Spelling 1895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 1905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getSpelling() - Return the 'spelling' of this token. The spelling of a 1935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// token are the characters used to represent the token in the source file 1945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// after trigraph expansion and escaped-newline folding. In particular, this 1955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// wants to get the true, uncanonicalized, spelling of things like digraphs 1965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// UCNs, etc. 197d217773f106856a11879ec79dc468efefaf2ee75Chris Lattnerstd::string Preprocessor::getSpelling(const Token &Tok) const { 1985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert((int)Tok.getLength() >= 0 && "Token character range is bogus!"); 199277faca30c9f8f72b79f55695cbe3395ec246e7cTed Kremenek 2005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this token contains nothing interesting, return it directly. 201277faca30c9f8f72b79f55695cbe3395ec246e7cTed Kremenek const char* TokStart = SourceMgr.getCharacterData(Tok.getLocation()); 2025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!Tok.needsCleaning()) 2035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return std::string(TokStart, TokStart+Tok.getLength()); 2045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2055f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer std::string Result; 2065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result.reserve(Tok.getLength()); 2075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Otherwise, hard case, relex the characters into the string. 2095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (const char *Ptr = TokStart, *End = TokStart+Tok.getLength(); 2105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Ptr != End; ) { 2115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer unsigned CharSize; 2125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Result.push_back(Lexer::getCharAndSizeNoWarn(Ptr, CharSize, Features)); 2135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Ptr += CharSize; 2145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(Result.size() != unsigned(Tok.getLength()) && 2165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "NeedsCleaning flag set on something that didn't need cleaning!"); 2175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Result; 2185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2195f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// getSpelling - This method is used to get the spelling of a token into a 2215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// preallocated buffer, instead of as an std::string. The caller is required 2225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// to allocate enough space for the token, which is guaranteed to be at least 2235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// Tok.getLength() bytes long. The actual length of the token is returned. 2245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// 2255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// Note that this method may do two possible things: it may either fill in 2265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// the buffer specified with characters, or it may *change the input pointer* 2275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// to point to a constant buffer with the data already in it (avoiding a 2285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// copy). The caller is not allowed to modify the returned buffer pointer 2295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// if an internal buffer is returned. 230d217773f106856a11879ec79dc468efefaf2ee75Chris Lattnerunsigned Preprocessor::getSpelling(const Token &Tok, 2315f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const char *&Buffer) const { 2325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert((int)Tok.getLength() >= 0 && "Token character range is bogus!"); 2335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this token is an identifier, just return the string from the identifier 2355f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // table, which is very quick. 2365f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (const IdentifierInfo *II = Tok.getIdentifierInfo()) { 2375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Buffer = II->getName(); 238e1dccaefe2d44a9f83f8c3f087438a3297254cacChris Lattner return II->getLength(); 2395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 240b70e3dafb9618f34017061400dc19ac5e3539a6dTed Kremenek 2415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Otherwise, compute the start of the token in the input lexer buffer. 24247246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner const char *TokStart = 0; 24347246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner 24447246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner if (Tok.isLiteral()) 24547246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner TokStart = Tok.getLiteralData(); 24647246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner 24747246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner if (TokStart == 0) 24847246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner TokStart = SourceMgr.getCharacterData(Tok.getLocation()); 2495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this token contains nothing interesting, return it directly. 2515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!Tok.needsCleaning()) { 2525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Buffer = TokStart; 2535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return Tok.getLength(); 2545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 25547246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner 2565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Otherwise, hard case, relex the characters into the string. 2575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer char *OutBuf = const_cast<char*>(Buffer); 2585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (const char *Ptr = TokStart, *End = TokStart+Tok.getLength(); 2595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Ptr != End; ) { 2605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer unsigned CharSize; 2615f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer *OutBuf++ = Lexer::getCharAndSizeNoWarn(Ptr, CharSize, Features); 2625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Ptr += CharSize; 2635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(unsigned(OutBuf-Buffer) != Tok.getLength() && 2655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "NeedsCleaning flag set on something that didn't need cleaning!"); 2665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return OutBuf-Buffer; 2685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// CreateString - Plop the specified string into a scratch buffer and return a 2715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// location for it. If specified, the source location provides a source 2725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// location for the token. 27347246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattnervoid Preprocessor::CreateString(const char *Buf, unsigned Len, Token &Tok, 27447246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner SourceLocation InstantiationLoc) { 27547246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner Tok.setLength(Len); 27647246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner 27747246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner const char *DestPtr; 27847246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner SourceLocation Loc = ScratchBuf->getToken(Buf, Len, DestPtr); 27947246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner 28047246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner if (InstantiationLoc.isValid()) 281e7fb48466afcbf2c4ccdfa658824282fdc3c512cChris Lattner Loc = SourceMgr.createInstantiationLoc(Loc, InstantiationLoc, 282e7fb48466afcbf2c4ccdfa658824282fdc3c512cChris Lattner InstantiationLoc, Len); 28347246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner Tok.setLocation(Loc); 28447246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner 28547246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner // If this is a literal token, set the pointer data. 28647246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner if (Tok.isLiteral()) 28747246be8ac5b0ddde6c402b8fc6946b6135487b5Chris Lattner Tok.setLiteralData(DestPtr); 2885f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 2895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 2905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 29197ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner/// AdvanceToTokenCharacter - Given a location that specifies the start of a 29297ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner/// token, return a new location that specifies a character within the token. 29397ba77cf09bf7b83b679165ce67ad7d49ffd568cChris LattnerSourceLocation Preprocessor::AdvanceToTokenCharacter(SourceLocation TokStart, 29497ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner unsigned CharNo) { 295f7cf85b330bedd2877e1371fb0a83e99751ae162Chris Lattner // Figure out how many physical characters away the specified instantiation 29697ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner // character is. This needs to take into consideration newlines and 29797ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner // trigraphs. 2989dc1f530c086d2c16f8cba758b0f59a5bf41323aChris Lattner const char *TokPtr = SourceMgr.getCharacterData(TokStart); 29988e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner 30088e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner // If they request the first char of the token, we're trivially done. 30188e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner if (CharNo == 0 && Lexer::isObviouslySimpleCharacter(*TokPtr)) 30288e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner return TokStart; 30388e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner 3049dc1f530c086d2c16f8cba758b0f59a5bf41323aChris Lattner unsigned PhysOffset = 0; 30597ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner 30697ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner // The usual case is that tokens don't contain anything interesting. Skip 30797ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner // over the uninteresting characters. If a token only consists of simple 30897ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner // chars, this method is extremely fast. 30988e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner while (Lexer::isObviouslySimpleCharacter(*TokPtr)) { 31088e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner if (CharNo == 0) 31188e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner return TokStart.getFileLocWithOffset(PhysOffset); 3129dc1f530c086d2c16f8cba758b0f59a5bf41323aChris Lattner ++TokPtr, --CharNo, ++PhysOffset; 31388e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner } 31497ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner 31528c90ad7ef7c609a0b10c2f68b519ef69e7084d1Chris Lattner // If we have a character that may be a trigraph or escaped newline, use a 31697ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner // lexer to parse it correctly. 31788e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner for (; CharNo; --CharNo) { 31888e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner unsigned Size; 31988e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner Lexer::getCharAndSizeNoWarn(TokPtr, Size, Features); 32088e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner TokPtr += Size; 32188e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner PhysOffset += Size; 32297ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner } 3239dc1f530c086d2c16f8cba758b0f59a5bf41323aChris Lattner 32488e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner // Final detail: if we end up on an escaped newline, we want to return the 32588e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner // location of the actual byte of the token. For example foo\<newline>bar 32688e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner // advanced by 3 should return the location of b, not of \\. One compounding 32788e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner // detail of this is that the escape may be made by a trigraph. 32888e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner if (!Lexer::isObviouslySimpleCharacter(*TokPtr)) 32988e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner PhysOffset = Lexer::SkipEscapedNewLines(TokPtr)-TokPtr; 33088e2524b8f3393975872a23bbe6e8b3cf50d6773Chris Lattner 3319dc1f530c086d2c16f8cba758b0f59a5bf41323aChris Lattner return TokStart.getFileLocWithOffset(PhysOffset); 33297ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner} 33397ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner 334b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor/// \brief Computes the source location just past the end of the 335b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor/// token at this source location. 336b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor/// 337b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor/// This routine can be used to produce a source location that 338b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor/// points just past the end of the token referenced by \p Loc, and 339b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor/// is generally used when a diagnostic needs to point just after a 340b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor/// token where it expected something different that it received. If 341b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor/// the returned source location would not be meaningful (e.g., if 342b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor/// it points into a macro), this routine returns an invalid 343b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor/// source location. 344b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas GregorSourceLocation Preprocessor::getLocForEndOfToken(SourceLocation Loc) { 345b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor if (Loc.isInvalid() || !Loc.isFileID()) 346b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor return SourceLocation(); 347b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor 3482c78b873f4f3823ae859c15674cb3d76c8554113Chris Lattner unsigned Len = Lexer::MeasureTokenLength(Loc, getSourceManager(), Features); 349b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor return AdvanceToTokenCharacter(Loc, Len); 350b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor} 351b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor 352b2fb6de9070fea9abc56c8e8d5469066e964cefeDouglas Gregor 35397ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner 35453b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner//===----------------------------------------------------------------------===// 35553b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner// Preprocessor Initialization Methods 35653b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner//===----------------------------------------------------------------------===// 35753b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner 35853b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner 35953b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner/// EnterMainSourceFile - Enter the specified FileID as the main source file, 3606b61602bc7695d40b3c4d09032be1ca1dd0b3c31Nate Begeman/// which implicitly adds the builtin defines etc. 36195041a2029a069386ee67439f6d0fb524a9d184fTed Kremenekvoid Preprocessor::EnterMainSourceFile() { 36205db4278ecd193edcff63fb8c54818226fceaad2Chris Lattner // We do not allow the preprocessor to reenter the main file. Doing so will 36305db4278ecd193edcff63fb8c54818226fceaad2Chris Lattner // cause FileID's to accumulate information from both runs (e.g. #line 36405db4278ecd193edcff63fb8c54818226fceaad2Chris Lattner // information) and predefined macros aren't guaranteed to be set properly. 36505db4278ecd193edcff63fb8c54818226fceaad2Chris Lattner assert(NumEnteredSourceFiles == 0 && "Cannot reenter the main file!"); 3662b2453a7d8fe732561795431f39ceb2b2a832d84Chris Lattner FileID MainFileID = SourceMgr.getMainFileID(); 36795041a2029a069386ee67439f6d0fb524a9d184fTed Kremenek 36853b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner // Enter the main file source buffer. 36953b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner EnterSourceFile(MainFileID, 0); 37053b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner 371b283298f03d2b512204d14ca687f9de263eeff0fChris Lattner // Tell the header info that the main file was entered. If the file is later 372b283298f03d2b512204d14ca687f9de263eeff0fChris Lattner // #imported, it won't be re-entered. 3732b2453a7d8fe732561795431f39ceb2b2a832d84Chris Lattner if (const FileEntry *FE = SourceMgr.getFileEntryForID(MainFileID)) 374b283298f03d2b512204d14ca687f9de263eeff0fChris Lattner HeaderInfo.IncrementIncludeCount(FE); 375b283298f03d2b512204d14ca687f9de263eeff0fChris Lattner 37653b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner std::vector<char> PrologFile; 37753b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner PrologFile.reserve(4080); 37853b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner 3796bf0f4ce59a7a7e177dd2154f9b6f790d70fbf4aChris Lattner // FIXME: Don't make a copy. 380aa39197431a0a0b1326ecf6b3be6a11f6e2f8503Chris Lattner PrologFile.insert(PrologFile.end(), Predefines.begin(), Predefines.end()); 38153b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner 38253b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner // Memory buffer must end with a null byte! 38353b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner PrologFile.push_back(0); 38453b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner 38553b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner // Now that we have emitted the predefined macros, #includes, etc into 38653b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner // PrologFile, preprocess it to populate the initial preprocessor state. 38753b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner llvm::MemoryBuffer *SB = 38853b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner llvm::MemoryBuffer::getMemBufferCopy(&PrologFile.front(),&PrologFile.back(), 389f2e880a99c8b08976069331283392cc22b07701dChris Lattner "<built-in>"); 39053b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner assert(SB && "Cannot fail to create predefined source buffer"); 3912b2453a7d8fe732561795431f39ceb2b2a832d84Chris Lattner FileID FID = SourceMgr.createFileIDForMemBuffer(SB); 3922b2453a7d8fe732561795431f39ceb2b2a832d84Chris Lattner assert(!FID.isInvalid() && "Could not create FileID for predefines?"); 39353b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner 39453b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner // Start parsing the predefines. 3952b2453a7d8fe732561795431f39ceb2b2a832d84Chris Lattner EnterSourceFile(FID, 0); 39653b0dabbe52219a8057659b90539837394ef0fa1Chris Lattner} 39797ba77cf09bf7b83b679165ce67ad7d49ffd568cChris Lattner 3985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 3995f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 4005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// Lexer Event Handling. 4015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 4025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// LookUpIdentifierInfo - Given a tok::identifier token, look up the 4045f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// identifier information for the token and install it into the token. 405d217773f106856a11879ec79dc468efefaf2ee75Chris LattnerIdentifierInfo *Preprocessor::LookUpIdentifierInfo(Token &Identifier, 4065f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const char *BufPtr) { 40722f6bbcafa8871f4f20c4402d9cbc5c024fee99aChris Lattner assert(Identifier.is(tok::identifier) && "Not an identifier!"); 4085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(Identifier.getIdentifierInfo() == 0 && "Identinfo already exists!"); 4095f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Look up this token, see if it is a macro, or if it is a language keyword. 4115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer IdentifierInfo *II; 4125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (BufPtr && !Identifier.needsCleaning()) { 4135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // No cleaning needed, just use the characters from the lexed buffer. 4145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer II = getIdentifierInfo(BufPtr, BufPtr+Identifier.getLength()); 4155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 4165f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Cleaning needed, alloca a buffer, clean into it, then use the buffer. 417c35717a1b34269fc5d78226b1624f53e1c073ed6Chris Lattner llvm::SmallVector<char, 64> IdentifierBuffer; 418c35717a1b34269fc5d78226b1624f53e1c073ed6Chris Lattner IdentifierBuffer.resize(Identifier.getLength()); 419c35717a1b34269fc5d78226b1624f53e1c073ed6Chris Lattner const char *TmpBuf = &IdentifierBuffer[0]; 4205f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer unsigned Size = getSpelling(Identifier, TmpBuf); 4215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer II = getIdentifierInfo(TmpBuf, TmpBuf+Size); 4225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4235f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Identifier.setIdentifierInfo(II); 4245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return II; 4255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 4265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// HandleIdentifier - This callback is invoked when the lexer reads an 4295f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// identifier. This callback looks up the identifier in the map and/or 4305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer/// potentially macro expands it or turns it into a named token (like 'for'). 4316a170eb3ea6d6319277becabef68eb1a26bf8766Chris Lattner/// 4326a170eb3ea6d6319277becabef68eb1a26bf8766Chris Lattner/// Note that callers of this method are guarded by checking the 4336a170eb3ea6d6319277becabef68eb1a26bf8766Chris Lattner/// IdentifierInfo's 'isHandleIdentifierCase' bit. If this method changes, the 4346a170eb3ea6d6319277becabef68eb1a26bf8766Chris Lattner/// IdentifierInfo methods that compute these properties will need to change to 4356a170eb3ea6d6319277becabef68eb1a26bf8766Chris Lattner/// match. 436d217773f106856a11879ec79dc468efefaf2ee75Chris Lattnervoid Preprocessor::HandleIdentifier(Token &Identifier) { 4375f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(Identifier.getIdentifierInfo() && 4385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "Can't handle identifiers without identifier info!"); 4395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4405f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer IdentifierInfo &II = *Identifier.getIdentifierInfo(); 4415f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4425f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this identifier was poisoned, and if it was not produced from a macro 4435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // expansion, emit an error. 4441a531570d294ffc300cce1bc5e73de847a370f4fTed Kremenek if (II.isPoisoned() && CurPPLexer) { 4455f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (&II != Ident__VA_ARGS__) // We warn about __VA_ARGS__ with poisoning. 4465f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(Identifier, diag::err_pp_used_poisoned_id); 4475f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else 4485f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(Identifier, diag::ext_pp_bad_vaargs_use); 4495f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is a macro to be expanded, do it. 452cc1a875f94630e58d24a55577ffbf0e89b7da8c7Chris Lattner if (MacroInfo *MI = getMacroInfo(&II)) { 4535f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!DisableMacroExpansion && !Identifier.isExpandDisabled()) { 4545f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (MI->isEnabled()) { 4555f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (!HandleMacroExpandedIdentifier(Identifier, MI)) 4565f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return; 4575f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 4585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.10.3.4p2 says that a disabled macro may never again be 4595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // expanded, even if it's in a context where it could be expanded in the 4605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // future. 461d217773f106856a11879ec79dc468efefaf2ee75Chris Lattner Identifier.setFlag(Token::DisableExpand); 4625f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4635f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4645f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 4655f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C++ 2.11p2: If this is an alternative representation of a C++ operator, 4675f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // then we act as if it is the actual operator and not the textual 4685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // representation of it. 4695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (II.isCPlusPlusOperatorKeyword()) 4705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Identifier.setIdentifierInfo(0); 4715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 4725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is an extension token, diagnose its use. 473b4eaf9cf5f79c86a3f7564f4dfdea57f165ca45cSteve Naroff // We avoid diagnosing tokens that originate from macro definitions. 474b4eaf9cf5f79c86a3f7564f4dfdea57f165ca45cSteve Naroff if (II.isExtensionToken() && Features.C99 && !DisableMacroExpansion) 4755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(Identifier, diag::ext_token_used); 4765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 477