c43ddc84a3
Now instead of IdentifierInfo knowing anything about MacroInfo, only the preprocessor knows. This makes MacroInfo truly private to the Lex library (and its direct clients) instead of being accessed in the Basic library. llvm-svn: 42727
2299 lines
85 KiB
C++
2299 lines
85 KiB
C++
//===--- Preprocess.cpp - C Language Family Preprocessor Implementation ---===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file was developed by Chris Lattner and is distributed under
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the Preprocessor interface.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Options to support:
|
|
// -H - Print the name of each header file used.
|
|
// -d[MDNI] - Dump various things.
|
|
// -fworking-directory - #line's with preprocessor's working dir.
|
|
// -fpreprocessed
|
|
// -dependency-file,-M,-MM,-MF,-MG,-MP,-MT,-MQ,-MD,-MMD
|
|
// -W*
|
|
// -w
|
|
//
|
|
// Messages to emit:
|
|
// "Multiple include guards may be useful for:\n"
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/Lex/Preprocessor.h"
|
|
#include "clang/Lex/HeaderSearch.h"
|
|
#include "clang/Lex/MacroInfo.h"
|
|
#include "clang/Lex/PPCallbacks.h"
|
|
#include "clang/Lex/Pragma.h"
|
|
#include "clang/Lex/ScratchBuffer.h"
|
|
#include "clang/Basic/Diagnostic.h"
|
|
#include "clang/Basic/FileManager.h"
|
|
#include "clang/Basic/SourceManager.h"
|
|
#include "clang/Basic/TargetInfo.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
#include <iostream>
|
|
#include <ctime>
|
|
using namespace clang;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
Preprocessor::Preprocessor(Diagnostic &diags, const LangOptions &opts,
|
|
TargetInfo &target, SourceManager &SM,
|
|
HeaderSearch &Headers)
|
|
: Diags(diags), Features(opts), Target(target), FileMgr(Headers.getFileMgr()),
|
|
SourceMgr(SM), HeaderInfo(Headers), Identifiers(opts),
|
|
CurLexer(0), CurDirLookup(0), CurMacroExpander(0), Callbacks(0) {
|
|
ScratchBuf = new ScratchBuffer(SourceMgr);
|
|
|
|
// Clear stats.
|
|
NumDirectives = NumDefined = NumUndefined = NumPragma = 0;
|
|
NumIf = NumElse = NumEndif = 0;
|
|
NumEnteredSourceFiles = 0;
|
|
NumMacroExpanded = NumFnMacroExpanded = NumBuiltinMacroExpanded = 0;
|
|
NumFastMacroExpanded = NumTokenPaste = NumFastTokenPaste = 0;
|
|
MaxIncludeStackDepth = 0;
|
|
NumSkipped = 0;
|
|
|
|
// Default to discarding comments.
|
|
KeepComments = false;
|
|
KeepMacroComments = false;
|
|
|
|
// Macro expansion is enabled.
|
|
DisableMacroExpansion = false;
|
|
InMacroArgs = false;
|
|
NumCachedMacroExpanders = 0;
|
|
|
|
// "Poison" __VA_ARGS__, which can only appear in the expansion of a macro.
|
|
// This gets unpoisoned where it is allowed.
|
|
(Ident__VA_ARGS__ = getIdentifierInfo("__VA_ARGS__"))->setIsPoisoned();
|
|
|
|
// Initialize the pragma handlers.
|
|
PragmaHandlers = new PragmaNamespace(0);
|
|
RegisterBuiltinPragmas();
|
|
|
|
// Initialize builtin macros like __LINE__ and friends.
|
|
RegisterBuiltinMacros();
|
|
}
|
|
|
|
Preprocessor::~Preprocessor() {
|
|
// Free any active lexers.
|
|
delete CurLexer;
|
|
|
|
while (!IncludeMacroStack.empty()) {
|
|
delete IncludeMacroStack.back().TheLexer;
|
|
delete IncludeMacroStack.back().TheMacroExpander;
|
|
IncludeMacroStack.pop_back();
|
|
}
|
|
|
|
// Free any macro definitions.
|
|
for (llvm::DenseMap<IdentifierInfo*, MacroInfo*>::iterator I =
|
|
Macros.begin(), E = Macros.end(); I != E; ++I) {
|
|
// Free the macro definition.
|
|
delete I->second;
|
|
I->second = 0;
|
|
I->first->setHasMacroDefinition(false);
|
|
}
|
|
|
|
// Free any cached macro expanders.
|
|
for (unsigned i = 0, e = NumCachedMacroExpanders; i != e; ++i)
|
|
delete MacroExpanderCache[i];
|
|
|
|
// Release pragma information.
|
|
delete PragmaHandlers;
|
|
|
|
// Delete the scratch buffer info.
|
|
delete ScratchBuf;
|
|
}
|
|
|
|
PPCallbacks::~PPCallbacks() {
|
|
}
|
|
|
|
/// Diag - Forwarding function for diagnostics. This emits a diagnostic at
|
|
/// the specified Token's location, translating the token's start
|
|
/// position in the current buffer into a SourcePosition object for rendering.
|
|
void Preprocessor::Diag(SourceLocation Loc, unsigned DiagID) {
|
|
Diags.Report(Loc, DiagID);
|
|
}
|
|
|
|
void Preprocessor::Diag(SourceLocation Loc, unsigned DiagID,
|
|
const std::string &Msg) {
|
|
Diags.Report(Loc, DiagID, &Msg, 1);
|
|
}
|
|
|
|
void Preprocessor::DumpToken(const Token &Tok, bool DumpFlags) const {
|
|
std::cerr << tok::getTokenName(Tok.getKind()) << " '"
|
|
<< getSpelling(Tok) << "'";
|
|
|
|
if (!DumpFlags) return;
|
|
std::cerr << "\t";
|
|
if (Tok.isAtStartOfLine())
|
|
std::cerr << " [StartOfLine]";
|
|
if (Tok.hasLeadingSpace())
|
|
std::cerr << " [LeadingSpace]";
|
|
if (Tok.isExpandDisabled())
|
|
std::cerr << " [ExpandDisabled]";
|
|
if (Tok.needsCleaning()) {
|
|
const char *Start = SourceMgr.getCharacterData(Tok.getLocation());
|
|
std::cerr << " [UnClean='" << std::string(Start, Start+Tok.getLength())
|
|
<< "']";
|
|
}
|
|
}
|
|
|
|
void Preprocessor::DumpMacro(const MacroInfo &MI) const {
|
|
std::cerr << "MACRO: ";
|
|
for (unsigned i = 0, e = MI.getNumTokens(); i != e; ++i) {
|
|
DumpToken(MI.getReplacementToken(i));
|
|
std::cerr << " ";
|
|
}
|
|
std::cerr << "\n";
|
|
}
|
|
|
|
void Preprocessor::PrintStats() {
|
|
std::cerr << "\n*** Preprocessor Stats:\n";
|
|
std::cerr << NumDirectives << " directives found:\n";
|
|
std::cerr << " " << NumDefined << " #define.\n";
|
|
std::cerr << " " << NumUndefined << " #undef.\n";
|
|
std::cerr << " #include/#include_next/#import:\n";
|
|
std::cerr << " " << NumEnteredSourceFiles << " source files entered.\n";
|
|
std::cerr << " " << MaxIncludeStackDepth << " max include stack depth\n";
|
|
std::cerr << " " << NumIf << " #if/#ifndef/#ifdef.\n";
|
|
std::cerr << " " << NumElse << " #else/#elif.\n";
|
|
std::cerr << " " << NumEndif << " #endif.\n";
|
|
std::cerr << " " << NumPragma << " #pragma.\n";
|
|
std::cerr << NumSkipped << " #if/#ifndef#ifdef regions skipped\n";
|
|
|
|
std::cerr << NumMacroExpanded << "/" << NumFnMacroExpanded << "/"
|
|
<< NumBuiltinMacroExpanded << " obj/fn/builtin macros expanded, "
|
|
<< NumFastMacroExpanded << " on the fast path.\n";
|
|
std::cerr << (NumFastTokenPaste+NumTokenPaste)
|
|
<< " token paste (##) operations performed, "
|
|
<< NumFastTokenPaste << " on the fast path.\n";
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Token Spelling
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
/// getSpelling() - Return the 'spelling' of this token. The spelling of a
|
|
/// token are the characters used to represent the token in the source file
|
|
/// after trigraph expansion and escaped-newline folding. In particular, this
|
|
/// wants to get the true, uncanonicalized, spelling of things like digraphs
|
|
/// UCNs, etc.
|
|
std::string Preprocessor::getSpelling(const Token &Tok) const {
|
|
assert((int)Tok.getLength() >= 0 && "Token character range is bogus!");
|
|
|
|
// If this token contains nothing interesting, return it directly.
|
|
const char *TokStart = SourceMgr.getCharacterData(Tok.getLocation());
|
|
if (!Tok.needsCleaning())
|
|
return std::string(TokStart, TokStart+Tok.getLength());
|
|
|
|
std::string Result;
|
|
Result.reserve(Tok.getLength());
|
|
|
|
// Otherwise, hard case, relex the characters into the string.
|
|
for (const char *Ptr = TokStart, *End = TokStart+Tok.getLength();
|
|
Ptr != End; ) {
|
|
unsigned CharSize;
|
|
Result.push_back(Lexer::getCharAndSizeNoWarn(Ptr, CharSize, Features));
|
|
Ptr += CharSize;
|
|
}
|
|
assert(Result.size() != unsigned(Tok.getLength()) &&
|
|
"NeedsCleaning flag set on something that didn't need cleaning!");
|
|
return Result;
|
|
}
|
|
|
|
/// getSpelling - This method is used to get the spelling of a token into a
|
|
/// preallocated buffer, instead of as an std::string. The caller is required
|
|
/// to allocate enough space for the token, which is guaranteed to be at least
|
|
/// Tok.getLength() bytes long. The actual length of the token is returned.
|
|
///
|
|
/// Note that this method may do two possible things: it may either fill in
|
|
/// the buffer specified with characters, or it may *change the input pointer*
|
|
/// to point to a constant buffer with the data already in it (avoiding a
|
|
/// copy). The caller is not allowed to modify the returned buffer pointer
|
|
/// if an internal buffer is returned.
|
|
unsigned Preprocessor::getSpelling(const Token &Tok,
|
|
const char *&Buffer) const {
|
|
assert((int)Tok.getLength() >= 0 && "Token character range is bogus!");
|
|
|
|
// If this token is an identifier, just return the string from the identifier
|
|
// table, which is very quick.
|
|
if (const IdentifierInfo *II = Tok.getIdentifierInfo()) {
|
|
Buffer = II->getName();
|
|
|
|
// Return the length of the token. If the token needed cleaning, don't
|
|
// include the size of the newlines or trigraphs in it.
|
|
if (!Tok.needsCleaning())
|
|
return Tok.getLength();
|
|
else
|
|
return strlen(Buffer);
|
|
}
|
|
|
|
// Otherwise, compute the start of the token in the input lexer buffer.
|
|
const char *TokStart = SourceMgr.getCharacterData(Tok.getLocation());
|
|
|
|
// If this token contains nothing interesting, return it directly.
|
|
if (!Tok.needsCleaning()) {
|
|
Buffer = TokStart;
|
|
return Tok.getLength();
|
|
}
|
|
// Otherwise, hard case, relex the characters into the string.
|
|
char *OutBuf = const_cast<char*>(Buffer);
|
|
for (const char *Ptr = TokStart, *End = TokStart+Tok.getLength();
|
|
Ptr != End; ) {
|
|
unsigned CharSize;
|
|
*OutBuf++ = Lexer::getCharAndSizeNoWarn(Ptr, CharSize, Features);
|
|
Ptr += CharSize;
|
|
}
|
|
assert(unsigned(OutBuf-Buffer) != Tok.getLength() &&
|
|
"NeedsCleaning flag set on something that didn't need cleaning!");
|
|
|
|
return OutBuf-Buffer;
|
|
}
|
|
|
|
|
|
/// CreateString - Plop the specified string into a scratch buffer and return a
|
|
/// location for it. If specified, the source location provides a source
|
|
/// location for the token.
|
|
SourceLocation Preprocessor::
|
|
CreateString(const char *Buf, unsigned Len, SourceLocation SLoc) {
|
|
if (SLoc.isValid())
|
|
return ScratchBuf->getToken(Buf, Len, SLoc);
|
|
return ScratchBuf->getToken(Buf, Len);
|
|
}
|
|
|
|
|
|
/// AdvanceToTokenCharacter - Given a location that specifies the start of a
|
|
/// token, return a new location that specifies a character within the token.
|
|
SourceLocation Preprocessor::AdvanceToTokenCharacter(SourceLocation TokStart,
|
|
unsigned CharNo) {
|
|
// If they request the first char of the token, we're trivially done. If this
|
|
// is a macro expansion, it doesn't make sense to point to a character within
|
|
// the instantiation point (the name). We could point to the source
|
|
// character, but without also pointing to instantiation info, this is
|
|
// confusing.
|
|
if (CharNo == 0 || TokStart.isMacroID()) return TokStart;
|
|
|
|
// Figure out how many physical characters away the specified logical
|
|
// character is. This needs to take into consideration newlines and
|
|
// trigraphs.
|
|
const char *TokPtr = SourceMgr.getCharacterData(TokStart);
|
|
unsigned PhysOffset = 0;
|
|
|
|
// The usual case is that tokens don't contain anything interesting. Skip
|
|
// over the uninteresting characters. If a token only consists of simple
|
|
// chars, this method is extremely fast.
|
|
while (CharNo && Lexer::isObviouslySimpleCharacter(*TokPtr))
|
|
++TokPtr, --CharNo, ++PhysOffset;
|
|
|
|
// If we have a character that may be a trigraph or escaped newline, create a
|
|
// lexer to parse it correctly.
|
|
if (CharNo != 0) {
|
|
// Create a lexer starting at this token position.
|
|
Lexer TheLexer(TokStart, *this, TokPtr);
|
|
Token Tok;
|
|
// Skip over characters the remaining characters.
|
|
const char *TokStartPtr = TokPtr;
|
|
for (; CharNo; --CharNo)
|
|
TheLexer.getAndAdvanceChar(TokPtr, Tok);
|
|
|
|
PhysOffset += TokPtr-TokStartPtr;
|
|
}
|
|
|
|
return TokStart.getFileLocWithOffset(PhysOffset);
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Source File Location Methods.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// LookupFile - Given a "foo" or <foo> reference, look up the indicated file,
|
|
/// return null on failure. isAngled indicates whether the file reference is
|
|
/// for system #include's or not (i.e. using <> instead of "").
|
|
const FileEntry *Preprocessor::LookupFile(const char *FilenameStart,
|
|
const char *FilenameEnd,
|
|
bool isAngled,
|
|
const DirectoryLookup *FromDir,
|
|
const DirectoryLookup *&CurDir) {
|
|
// If the header lookup mechanism may be relative to the current file, pass in
|
|
// info about where the current file is.
|
|
const FileEntry *CurFileEnt = 0;
|
|
if (!FromDir) {
|
|
SourceLocation FileLoc = getCurrentFileLexer()->getFileLoc();
|
|
CurFileEnt = SourceMgr.getFileEntryForLoc(FileLoc);
|
|
}
|
|
|
|
// Do a standard file entry lookup.
|
|
CurDir = CurDirLookup;
|
|
const FileEntry *FE =
|
|
HeaderInfo.LookupFile(FilenameStart, FilenameEnd,
|
|
isAngled, FromDir, CurDir, CurFileEnt);
|
|
if (FE) return FE;
|
|
|
|
// Otherwise, see if this is a subframework header. If so, this is relative
|
|
// to one of the headers on the #include stack. Walk the list of the current
|
|
// headers on the #include stack and pass them to HeaderInfo.
|
|
if (CurLexer && !CurLexer->Is_PragmaLexer) {
|
|
CurFileEnt = SourceMgr.getFileEntryForLoc(CurLexer->getFileLoc());
|
|
if ((FE = HeaderInfo.LookupSubframeworkHeader(FilenameStart, FilenameEnd,
|
|
CurFileEnt)))
|
|
return FE;
|
|
}
|
|
|
|
for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i) {
|
|
IncludeStackInfo &ISEntry = IncludeMacroStack[e-i-1];
|
|
if (ISEntry.TheLexer && !ISEntry.TheLexer->Is_PragmaLexer) {
|
|
CurFileEnt = SourceMgr.getFileEntryForLoc(ISEntry.TheLexer->getFileLoc());
|
|
if ((FE = HeaderInfo.LookupSubframeworkHeader(FilenameStart, FilenameEnd,
|
|
CurFileEnt)))
|
|
return FE;
|
|
}
|
|
}
|
|
|
|
// Otherwise, we really couldn't find the file.
|
|
return 0;
|
|
}
|
|
|
|
/// isInPrimaryFile - Return true if we're in the top-level file, not in a
|
|
/// #include.
|
|
bool Preprocessor::isInPrimaryFile() const {
|
|
if (CurLexer && !CurLexer->Is_PragmaLexer)
|
|
return CurLexer->isMainFile();
|
|
|
|
// If there are any stacked lexers, we're in a #include.
|
|
for (unsigned i = 0, e = IncludeMacroStack.size(); i != e; ++i)
|
|
if (IncludeMacroStack[i].TheLexer &&
|
|
!IncludeMacroStack[i].TheLexer->Is_PragmaLexer)
|
|
return IncludeMacroStack[i].TheLexer->isMainFile();
|
|
return false;
|
|
}
|
|
|
|
/// getCurrentLexer - Return the current file lexer being lexed from. Note
|
|
/// that this ignores any potentially active macro expansions and _Pragma
|
|
/// expansions going on at the time.
|
|
Lexer *Preprocessor::getCurrentFileLexer() const {
|
|
if (CurLexer && !CurLexer->Is_PragmaLexer) return CurLexer;
|
|
|
|
// Look for a stacked lexer.
|
|
for (unsigned i = IncludeMacroStack.size(); i != 0; --i) {
|
|
Lexer *L = IncludeMacroStack[i-1].TheLexer;
|
|
if (L && !L->Is_PragmaLexer) // Ignore macro & _Pragma expansions.
|
|
return L;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/// EnterSourceFile - Add a source file to the top of the include stack and
|
|
/// start lexing tokens from it instead of the current buffer. Return true
|
|
/// on failure.
|
|
void Preprocessor::EnterSourceFile(unsigned FileID,
|
|
const DirectoryLookup *CurDir,
|
|
bool isMainFile) {
|
|
assert(CurMacroExpander == 0 && "Cannot #include a file inside a macro!");
|
|
++NumEnteredSourceFiles;
|
|
|
|
if (MaxIncludeStackDepth < IncludeMacroStack.size())
|
|
MaxIncludeStackDepth = IncludeMacroStack.size();
|
|
|
|
Lexer *TheLexer = new Lexer(SourceLocation::getFileLoc(FileID, 0), *this);
|
|
if (isMainFile) TheLexer->setIsMainFile();
|
|
EnterSourceFileWithLexer(TheLexer, CurDir);
|
|
}
|
|
|
|
/// EnterSourceFile - Add a source file to the top of the include stack and
|
|
/// start lexing tokens from it instead of the current buffer.
|
|
void Preprocessor::EnterSourceFileWithLexer(Lexer *TheLexer,
|
|
const DirectoryLookup *CurDir) {
|
|
|
|
// Add the current lexer to the include stack.
|
|
if (CurLexer || CurMacroExpander)
|
|
IncludeMacroStack.push_back(IncludeStackInfo(CurLexer, CurDirLookup,
|
|
CurMacroExpander));
|
|
|
|
CurLexer = TheLexer;
|
|
CurDirLookup = CurDir;
|
|
CurMacroExpander = 0;
|
|
|
|
// Notify the client, if desired, that we are in a new source file.
|
|
if (Callbacks && !CurLexer->Is_PragmaLexer) {
|
|
DirectoryLookup::DirType FileType = DirectoryLookup::NormalHeaderDir;
|
|
|
|
// Get the file entry for the current file.
|
|
if (const FileEntry *FE =
|
|
SourceMgr.getFileEntryForLoc(CurLexer->getFileLoc()))
|
|
FileType = HeaderInfo.getFileDirFlavor(FE);
|
|
|
|
Callbacks->FileChanged(CurLexer->getFileLoc(),
|
|
PPCallbacks::EnterFile, FileType);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// 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(Token &Tok, MacroArgs *Args) {
|
|
IncludeMacroStack.push_back(IncludeStackInfo(CurLexer, CurDirLookup,
|
|
CurMacroExpander));
|
|
CurLexer = 0;
|
|
CurDirLookup = 0;
|
|
|
|
if (NumCachedMacroExpanders == 0) {
|
|
CurMacroExpander = new MacroExpander(Tok, Args, *this);
|
|
} else {
|
|
CurMacroExpander = MacroExpanderCache[--NumCachedMacroExpanders];
|
|
CurMacroExpander->Init(Tok, Args);
|
|
}
|
|
}
|
|
|
|
/// EnterTokenStream - Add a "macro" context to the top of the include stack,
|
|
/// which will cause the lexer to start returning the specified tokens. Note
|
|
/// that these tokens will be re-macro-expanded when/if expansion is enabled.
|
|
/// This method assumes that the specified stream of tokens has a permanent
|
|
/// owner somewhere, so they do not need to be copied.
|
|
void Preprocessor::EnterTokenStream(const Token *Toks, unsigned NumToks) {
|
|
// Save our current state.
|
|
IncludeMacroStack.push_back(IncludeStackInfo(CurLexer, CurDirLookup,
|
|
CurMacroExpander));
|
|
CurLexer = 0;
|
|
CurDirLookup = 0;
|
|
|
|
// Create a macro expander to expand from the specified token stream.
|
|
if (NumCachedMacroExpanders == 0) {
|
|
CurMacroExpander = new MacroExpander(Toks, NumToks, *this);
|
|
} else {
|
|
CurMacroExpander = MacroExpanderCache[--NumCachedMacroExpanders];
|
|
CurMacroExpander->Init(Toks, NumToks);
|
|
}
|
|
}
|
|
|
|
/// RemoveTopOfLexerStack - Pop the current lexer/macro exp off the top of the
|
|
/// lexer stack. This should only be used in situations where the current
|
|
/// state of the top-of-stack lexer is known.
|
|
void Preprocessor::RemoveTopOfLexerStack() {
|
|
assert(!IncludeMacroStack.empty() && "Ran out of stack entries to load");
|
|
|
|
if (CurMacroExpander) {
|
|
// Delete or cache the now-dead macro expander.
|
|
if (NumCachedMacroExpanders == MacroExpanderCacheSize)
|
|
delete CurMacroExpander;
|
|
else
|
|
MacroExpanderCache[NumCachedMacroExpanders++] = CurMacroExpander;
|
|
} else {
|
|
delete CurLexer;
|
|
}
|
|
CurLexer = IncludeMacroStack.back().TheLexer;
|
|
CurDirLookup = IncludeMacroStack.back().TheDirLookup;
|
|
CurMacroExpander = IncludeMacroStack.back().TheMacroExpander;
|
|
IncludeMacroStack.pop_back();
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Macro Expansion Handling.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// setMacroInfo - Specify a macro for this identifier.
|
|
///
|
|
void Preprocessor::setMacroInfo(IdentifierInfo *II, MacroInfo *MI) {
|
|
if (MI == 0) {
|
|
if (II->hasMacroDefinition()) {
|
|
Macros.erase(II);
|
|
II->setHasMacroDefinition(false);
|
|
}
|
|
} else {
|
|
Macros[II] = MI;
|
|
II->setHasMacroDefinition(true);
|
|
}
|
|
}
|
|
|
|
/// RegisterBuiltinMacro - Register the specified identifier in the identifier
|
|
/// table and mark it as a builtin macro to be expanded.
|
|
IdentifierInfo *Preprocessor::RegisterBuiltinMacro(const char *Name) {
|
|
// Get the identifier.
|
|
IdentifierInfo *Id = getIdentifierInfo(Name);
|
|
|
|
// Mark it as being a macro that is builtin.
|
|
MacroInfo *MI = new MacroInfo(SourceLocation());
|
|
MI->setIsBuiltinMacro();
|
|
setMacroInfo(Id, MI);
|
|
return Id;
|
|
}
|
|
|
|
|
|
/// RegisterBuiltinMacros - Register builtin macros, such as __LINE__ with the
|
|
/// identifier table.
|
|
void Preprocessor::RegisterBuiltinMacros() {
|
|
Ident__LINE__ = RegisterBuiltinMacro("__LINE__");
|
|
Ident__FILE__ = RegisterBuiltinMacro("__FILE__");
|
|
Ident__DATE__ = RegisterBuiltinMacro("__DATE__");
|
|
Ident__TIME__ = RegisterBuiltinMacro("__TIME__");
|
|
Ident_Pragma = RegisterBuiltinMacro("_Pragma");
|
|
|
|
// GCC Extensions.
|
|
Ident__BASE_FILE__ = RegisterBuiltinMacro("__BASE_FILE__");
|
|
Ident__INCLUDE_LEVEL__ = RegisterBuiltinMacro("__INCLUDE_LEVEL__");
|
|
Ident__TIMESTAMP__ = RegisterBuiltinMacro("__TIMESTAMP__");
|
|
}
|
|
|
|
/// isTrivialSingleTokenExpansion - Return true if MI, which has a single token
|
|
/// in its expansion, currently expands to that token literally.
|
|
static bool isTrivialSingleTokenExpansion(const MacroInfo *MI,
|
|
const IdentifierInfo *MacroIdent,
|
|
Preprocessor &PP) {
|
|
IdentifierInfo *II = MI->getReplacementToken(0).getIdentifierInfo();
|
|
|
|
// If the token isn't an identifier, it's always literally expanded.
|
|
if (II == 0) return true;
|
|
|
|
// If the identifier is a macro, and if that macro is enabled, it may be
|
|
// expanded so it's not a trivial expansion.
|
|
if (II->hasMacroDefinition() && PP.getMacroInfo(II)->isEnabled() &&
|
|
// Fast expanding "#define X X" is ok, because X would be disabled.
|
|
II != MacroIdent)
|
|
return false;
|
|
|
|
// If this is an object-like macro invocation, it is safe to trivially expand
|
|
// it.
|
|
if (MI->isObjectLike()) return true;
|
|
|
|
// If this is a function-like macro invocation, it's safe to trivially expand
|
|
// as long as the identifier is not a macro argument.
|
|
for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end();
|
|
I != E; ++I)
|
|
if (*I == II)
|
|
return false; // Identifier is a macro argument.
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/// isNextPPTokenLParen - Determine whether the next preprocessor token to be
|
|
/// lexed is a '('. If so, consume the token and return true, if not, this
|
|
/// method should have no observable side-effect on the lexed tokens.
|
|
bool Preprocessor::isNextPPTokenLParen() {
|
|
// Do some quick tests for rejection cases.
|
|
unsigned Val;
|
|
if (CurLexer)
|
|
Val = CurLexer->isNextPPTokenLParen();
|
|
else
|
|
Val = CurMacroExpander->isNextTokenLParen();
|
|
|
|
if (Val == 2) {
|
|
// We have run off the end. If it's a source file we don't
|
|
// examine enclosing ones (C99 5.1.1.2p4). Otherwise walk up the
|
|
// macro stack.
|
|
if (CurLexer)
|
|
return false;
|
|
for (unsigned i = IncludeMacroStack.size(); i != 0; --i) {
|
|
IncludeStackInfo &Entry = IncludeMacroStack[i-1];
|
|
if (Entry.TheLexer)
|
|
Val = Entry.TheLexer->isNextPPTokenLParen();
|
|
else
|
|
Val = Entry.TheMacroExpander->isNextTokenLParen();
|
|
|
|
if (Val != 2)
|
|
break;
|
|
|
|
// Ran off the end of a source file?
|
|
if (Entry.TheLexer)
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Okay, if we know that the token is a '(', lex it and return. Otherwise we
|
|
// have found something that isn't a '(' or we found the end of the
|
|
// translation unit. In either case, return false.
|
|
if (Val != 1)
|
|
return false;
|
|
|
|
Token Tok;
|
|
LexUnexpandedToken(Tok);
|
|
assert(Tok.getKind() == tok::l_paren && "Error computing l-paren-ness?");
|
|
return true;
|
|
}
|
|
|
|
/// HandleMacroExpandedIdentifier - If an identifier token is read that is to be
|
|
/// expanded as a macro, handle it and return the next token as 'Identifier'.
|
|
bool Preprocessor::HandleMacroExpandedIdentifier(Token &Identifier,
|
|
MacroInfo *MI) {
|
|
|
|
// If this is a builtin macro, like __LINE__ or _Pragma, handle it specially.
|
|
if (MI->isBuiltinMacro()) {
|
|
ExpandBuiltinMacro(Identifier);
|
|
return false;
|
|
}
|
|
|
|
// If this is the first use of a target-specific macro, warn about it.
|
|
if (MI->isTargetSpecific()) {
|
|
MI->setIsTargetSpecific(false); // Don't warn on second use.
|
|
getTargetInfo().DiagnoseNonPortability(Identifier.getLocation(),
|
|
diag::port_target_macro_use);
|
|
}
|
|
|
|
/// Args - If this is a function-like macro expansion, this contains,
|
|
/// for each macro argument, the list of tokens that were provided to the
|
|
/// invocation.
|
|
MacroArgs *Args = 0;
|
|
|
|
// If this is a function-like macro, read the arguments.
|
|
if (MI->isFunctionLike()) {
|
|
// C99 6.10.3p10: If the preprocessing token immediately after the the macro
|
|
// name isn't a '(', this macro should not be expanded. Otherwise, consume
|
|
// it.
|
|
if (!isNextPPTokenLParen())
|
|
return true;
|
|
|
|
// Remember that we are now parsing the arguments to a macro invocation.
|
|
// Preprocessor directives used inside macro arguments are not portable, and
|
|
// this enables the warning.
|
|
InMacroArgs = true;
|
|
Args = ReadFunctionLikeMacroArgs(Identifier, MI);
|
|
|
|
// Finished parsing args.
|
|
InMacroArgs = false;
|
|
|
|
// If there was an error parsing the arguments, bail out.
|
|
if (Args == 0) return false;
|
|
|
|
++NumFnMacroExpanded;
|
|
} else {
|
|
++NumMacroExpanded;
|
|
}
|
|
|
|
// Notice that this macro has been used.
|
|
MI->setIsUsed(true);
|
|
|
|
// If we started lexing a macro, enter the macro expansion body.
|
|
|
|
// If this macro expands to no tokens, don't bother to push it onto the
|
|
// expansion stack, only to take it right back off.
|
|
if (MI->getNumTokens() == 0) {
|
|
// No need for arg info.
|
|
if (Args) Args->destroy();
|
|
|
|
// Ignore this macro use, just return the next token in the current
|
|
// buffer.
|
|
bool HadLeadingSpace = Identifier.hasLeadingSpace();
|
|
bool IsAtStartOfLine = Identifier.isAtStartOfLine();
|
|
|
|
Lex(Identifier);
|
|
|
|
// If the identifier isn't on some OTHER line, inherit the leading
|
|
// whitespace/first-on-a-line property of this token. This handles
|
|
// stuff like "! XX," -> "! ," and " XX," -> " ,", when XX is
|
|
// empty.
|
|
if (!Identifier.isAtStartOfLine()) {
|
|
if (IsAtStartOfLine) Identifier.setFlag(Token::StartOfLine);
|
|
if (HadLeadingSpace) Identifier.setFlag(Token::LeadingSpace);
|
|
}
|
|
++NumFastMacroExpanded;
|
|
return false;
|
|
|
|
} else if (MI->getNumTokens() == 1 &&
|
|
isTrivialSingleTokenExpansion(MI, Identifier.getIdentifierInfo(),
|
|
*this)){
|
|
// Otherwise, if this macro expands into a single trivially-expanded
|
|
// token: expand it now. This handles common cases like
|
|
// "#define VAL 42".
|
|
|
|
// Propagate the isAtStartOfLine/hasLeadingSpace markers of the macro
|
|
// identifier to the expanded token.
|
|
bool isAtStartOfLine = Identifier.isAtStartOfLine();
|
|
bool hasLeadingSpace = Identifier.hasLeadingSpace();
|
|
|
|
// Remember where the token is instantiated.
|
|
SourceLocation InstantiateLoc = Identifier.getLocation();
|
|
|
|
// Replace the result token.
|
|
Identifier = MI->getReplacementToken(0);
|
|
|
|
// Restore the StartOfLine/LeadingSpace markers.
|
|
Identifier.setFlagValue(Token::StartOfLine , isAtStartOfLine);
|
|
Identifier.setFlagValue(Token::LeadingSpace, hasLeadingSpace);
|
|
|
|
// Update the tokens location to include both its logical and physical
|
|
// locations.
|
|
SourceLocation Loc =
|
|
SourceMgr.getInstantiationLoc(Identifier.getLocation(), InstantiateLoc);
|
|
Identifier.setLocation(Loc);
|
|
|
|
// If this is #define X X, we must mark the result as unexpandible.
|
|
if (IdentifierInfo *NewII = Identifier.getIdentifierInfo())
|
|
if (getMacroInfo(NewII) == MI)
|
|
Identifier.setFlag(Token::DisableExpand);
|
|
|
|
// Since this is not an identifier token, it can't be macro expanded, so
|
|
// we're done.
|
|
++NumFastMacroExpanded;
|
|
return false;
|
|
}
|
|
|
|
// Start expanding the macro.
|
|
EnterMacro(Identifier, Args);
|
|
|
|
// Now that the macro is at the top of the include stack, ask the
|
|
// preprocessor to read the next token from it.
|
|
Lex(Identifier);
|
|
return false;
|
|
}
|
|
|
|
/// ReadFunctionLikeMacroArgs - After reading "MACRO(", this method is
|
|
/// invoked to read all of the actual arguments specified for the macro
|
|
/// invocation. This returns null on error.
|
|
MacroArgs *Preprocessor::ReadFunctionLikeMacroArgs(Token &MacroName,
|
|
MacroInfo *MI) {
|
|
// The number of fixed arguments to parse.
|
|
unsigned NumFixedArgsLeft = MI->getNumArgs();
|
|
bool isVariadic = MI->isVariadic();
|
|
|
|
// Outer loop, while there are more arguments, keep reading them.
|
|
Token Tok;
|
|
Tok.setKind(tok::comma);
|
|
--NumFixedArgsLeft; // Start reading the first arg.
|
|
|
|
// ArgTokens - Build up a list of tokens that make up each argument. Each
|
|
// argument is separated by an EOF token. Use a SmallVector so we can avoid
|
|
// heap allocations in the common case.
|
|
llvm::SmallVector<Token, 64> ArgTokens;
|
|
|
|
unsigned NumActuals = 0;
|
|
while (Tok.getKind() == tok::comma) {
|
|
// C99 6.10.3p11: Keep track of the number of l_parens we have seen. Note
|
|
// that we already consumed the first one.
|
|
unsigned NumParens = 0;
|
|
|
|
while (1) {
|
|
// Read arguments as unexpanded tokens. This avoids issues, e.g., where
|
|
// an argument value in a macro could expand to ',' or '(' or ')'.
|
|
LexUnexpandedToken(Tok);
|
|
|
|
if (Tok.getKind() == tok::eof) {
|
|
Diag(MacroName, diag::err_unterm_macro_invoc);
|
|
// Do not lose the EOF. Return it to the client.
|
|
MacroName = Tok;
|
|
return 0;
|
|
} else if (Tok.getKind() == tok::r_paren) {
|
|
// If we found the ) token, the macro arg list is done.
|
|
if (NumParens-- == 0)
|
|
break;
|
|
} else if (Tok.getKind() == tok::l_paren) {
|
|
++NumParens;
|
|
} else if (Tok.getKind() == tok::comma && NumParens == 0) {
|
|
// Comma ends this argument if there are more fixed arguments expected.
|
|
if (NumFixedArgsLeft)
|
|
break;
|
|
|
|
// If this is not a variadic macro, too many args were specified.
|
|
if (!isVariadic) {
|
|
// Emit the diagnostic at the macro name in case there is a missing ).
|
|
// Emitting it at the , could be far away from the macro name.
|
|
Diag(MacroName, diag::err_too_many_args_in_macro_invoc);
|
|
return 0;
|
|
}
|
|
// Otherwise, continue to add the tokens to this variable argument.
|
|
} else if (Tok.getKind() == tok::comment && !KeepMacroComments) {
|
|
// If this is a comment token in the argument list and we're just in
|
|
// -C mode (not -CC mode), discard the comment.
|
|
continue;
|
|
}
|
|
|
|
ArgTokens.push_back(Tok);
|
|
}
|
|
|
|
// Empty arguments are standard in C99 and supported as an extension in
|
|
// other modes.
|
|
if (ArgTokens.empty() && !Features.C99)
|
|
Diag(Tok, diag::ext_empty_fnmacro_arg);
|
|
|
|
// Add a marker EOF token to the end of the token list for this argument.
|
|
Token EOFTok;
|
|
EOFTok.startToken();
|
|
EOFTok.setKind(tok::eof);
|
|
EOFTok.setLocation(Tok.getLocation());
|
|
EOFTok.setLength(0);
|
|
ArgTokens.push_back(EOFTok);
|
|
++NumActuals;
|
|
--NumFixedArgsLeft;
|
|
};
|
|
|
|
// Okay, we either found the r_paren. Check to see if we parsed too few
|
|
// arguments.
|
|
unsigned MinArgsExpected = MI->getNumArgs();
|
|
|
|
// See MacroArgs instance var for description of this.
|
|
bool isVarargsElided = false;
|
|
|
|
if (NumActuals < MinArgsExpected) {
|
|
// There are several cases where too few arguments is ok, handle them now.
|
|
if (NumActuals+1 == MinArgsExpected && MI->isVariadic()) {
|
|
// Varargs where the named vararg parameter is missing: ok as extension.
|
|
// #define A(x, ...)
|
|
// A("blah")
|
|
Diag(Tok, diag::ext_missing_varargs_arg);
|
|
|
|
// Remember this occurred if this is a C99 macro invocation with at least
|
|
// one actual argument.
|
|
isVarargsElided = MI->isC99Varargs() && MI->getNumArgs() > 1;
|
|
} else if (MI->getNumArgs() == 1) {
|
|
// #define A(x)
|
|
// A()
|
|
// is ok because it is an empty argument.
|
|
|
|
// Empty arguments are standard in C99 and supported as an extension in
|
|
// other modes.
|
|
if (ArgTokens.empty() && !Features.C99)
|
|
Diag(Tok, diag::ext_empty_fnmacro_arg);
|
|
} else {
|
|
// Otherwise, emit the error.
|
|
Diag(Tok, diag::err_too_few_args_in_macro_invoc);
|
|
return 0;
|
|
}
|
|
|
|
// Add a marker EOF token to the end of the token list for this argument.
|
|
SourceLocation EndLoc = Tok.getLocation();
|
|
Tok.startToken();
|
|
Tok.setKind(tok::eof);
|
|
Tok.setLocation(EndLoc);
|
|
Tok.setLength(0);
|
|
ArgTokens.push_back(Tok);
|
|
}
|
|
|
|
return MacroArgs::create(MI, &ArgTokens[0], ArgTokens.size(),isVarargsElided);
|
|
}
|
|
|
|
/// ComputeDATE_TIME - Compute the current time, enter it into the specified
|
|
/// scratch buffer, then return DATELoc/TIMELoc locations with the position of
|
|
/// the identifier tokens inserted.
|
|
static void ComputeDATE_TIME(SourceLocation &DATELoc, SourceLocation &TIMELoc,
|
|
Preprocessor &PP) {
|
|
time_t TT = time(0);
|
|
struct tm *TM = localtime(&TT);
|
|
|
|
static const char * const Months[] = {
|
|
"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
|
|
};
|
|
|
|
char TmpBuffer[100];
|
|
sprintf(TmpBuffer, "\"%s %2d %4d\"", Months[TM->tm_mon], TM->tm_mday,
|
|
TM->tm_year+1900);
|
|
DATELoc = PP.CreateString(TmpBuffer, strlen(TmpBuffer));
|
|
|
|
sprintf(TmpBuffer, "\"%02d:%02d:%02d\"", TM->tm_hour, TM->tm_min, TM->tm_sec);
|
|
TIMELoc = PP.CreateString(TmpBuffer, strlen(TmpBuffer));
|
|
}
|
|
|
|
/// ExpandBuiltinMacro - If an identifier token is read that is to be expanded
|
|
/// as a builtin macro, handle it and return the next token as 'Tok'.
|
|
void Preprocessor::ExpandBuiltinMacro(Token &Tok) {
|
|
// Figure out which token this is.
|
|
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 (II == Ident_Pragma)
|
|
return Handle_Pragma(Tok);
|
|
|
|
++NumBuiltinMacroExpanded;
|
|
|
|
char TmpBuffer[100];
|
|
|
|
// Set up the return result.
|
|
Tok.setIdentifierInfo(0);
|
|
Tok.clearFlag(Token::NeedsCleaning);
|
|
|
|
if (II == Ident__LINE__) {
|
|
// __LINE__ expands to a simple numeric value.
|
|
sprintf(TmpBuffer, "%u", SourceMgr.getLogicalLineNumber(Tok.getLocation()));
|
|
unsigned Length = strlen(TmpBuffer);
|
|
Tok.setKind(tok::numeric_constant);
|
|
Tok.setLength(Length);
|
|
Tok.setLocation(CreateString(TmpBuffer, Length, Tok.getLocation()));
|
|
} else if (II == Ident__FILE__ || II == Ident__BASE_FILE__) {
|
|
SourceLocation Loc = Tok.getLocation();
|
|
if (II == Ident__BASE_FILE__) {
|
|
Diag(Tok, diag::ext_pp_base_file);
|
|
SourceLocation NextLoc = SourceMgr.getIncludeLoc(Loc);
|
|
while (NextLoc.isValid()) {
|
|
Loc = NextLoc;
|
|
NextLoc = SourceMgr.getIncludeLoc(Loc);
|
|
}
|
|
}
|
|
|
|
// Escape this filename. Turn '\' -> '\\' '"' -> '\"'
|
|
std::string FN = SourceMgr.getSourceName(SourceMgr.getLogicalLoc(Loc));
|
|
FN = '"' + Lexer::Stringify(FN) + '"';
|
|
Tok.setKind(tok::string_literal);
|
|
Tok.setLength(FN.size());
|
|
Tok.setLocation(CreateString(&FN[0], FN.size(), Tok.getLocation()));
|
|
} else if (II == Ident__DATE__) {
|
|
if (!DATELoc.isValid())
|
|
ComputeDATE_TIME(DATELoc, TIMELoc, *this);
|
|
Tok.setKind(tok::string_literal);
|
|
Tok.setLength(strlen("\"Mmm dd yyyy\""));
|
|
Tok.setLocation(SourceMgr.getInstantiationLoc(DATELoc, Tok.getLocation()));
|
|
} else if (II == Ident__TIME__) {
|
|
if (!TIMELoc.isValid())
|
|
ComputeDATE_TIME(DATELoc, TIMELoc, *this);
|
|
Tok.setKind(tok::string_literal);
|
|
Tok.setLength(strlen("\"hh:mm:ss\""));
|
|
Tok.setLocation(SourceMgr.getInstantiationLoc(TIMELoc, Tok.getLocation()));
|
|
} else if (II == Ident__INCLUDE_LEVEL__) {
|
|
Diag(Tok, diag::ext_pp_include_level);
|
|
|
|
// Compute the include depth of this token.
|
|
unsigned Depth = 0;
|
|
SourceLocation Loc = SourceMgr.getIncludeLoc(Tok.getLocation());
|
|
for (; Loc.isValid(); ++Depth)
|
|
Loc = SourceMgr.getIncludeLoc(Loc);
|
|
|
|
// __INCLUDE_LEVEL__ expands to a simple numeric value.
|
|
sprintf(TmpBuffer, "%u", Depth);
|
|
unsigned Length = strlen(TmpBuffer);
|
|
Tok.setKind(tok::numeric_constant);
|
|
Tok.setLength(Length);
|
|
Tok.setLocation(CreateString(TmpBuffer, Length, Tok.getLocation()));
|
|
} 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);
|
|
|
|
// Get the file that we are lexing out of. If we're currently lexing from
|
|
// a macro, dig into the include stack.
|
|
const FileEntry *CurFile = 0;
|
|
Lexer *TheLexer = getCurrentFileLexer();
|
|
|
|
if (TheLexer)
|
|
CurFile = SourceMgr.getFileEntryForLoc(TheLexer->getFileLoc());
|
|
|
|
// If this file is older than the file it depends on, emit a diagnostic.
|
|
const char *Result;
|
|
if (CurFile) {
|
|
time_t TT = CurFile->getModificationTime();
|
|
struct tm *TM = localtime(&TT);
|
|
Result = asctime(TM);
|
|
} else {
|
|
Result = "??? ??? ?? ??:??:?? ????\n";
|
|
}
|
|
TmpBuffer[0] = '"';
|
|
strcpy(TmpBuffer+1, Result);
|
|
unsigned Len = strlen(TmpBuffer);
|
|
TmpBuffer[Len-1] = '"'; // Replace the newline with a quote.
|
|
Tok.setKind(tok::string_literal);
|
|
Tok.setLength(Len);
|
|
Tok.setLocation(CreateString(TmpBuffer, Len, Tok.getLocation()));
|
|
} else {
|
|
assert(0 && "Unknown identifier!");
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Lexer Event Handling.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// LookUpIdentifierInfo - Given a tok::identifier token, look up the
|
|
/// identifier information for the token and install it into the token.
|
|
IdentifierInfo *Preprocessor::LookUpIdentifierInfo(Token &Identifier,
|
|
const char *BufPtr) {
|
|
assert(Identifier.getKind() == tok::identifier && "Not an identifier!");
|
|
assert(Identifier.getIdentifierInfo() == 0 && "Identinfo already exists!");
|
|
|
|
// Look up this token, see if it is a macro, or if it is a language keyword.
|
|
IdentifierInfo *II;
|
|
if (BufPtr && !Identifier.needsCleaning()) {
|
|
// No cleaning needed, just use the characters from the lexed buffer.
|
|
II = getIdentifierInfo(BufPtr, BufPtr+Identifier.getLength());
|
|
} else {
|
|
// Cleaning needed, alloca a buffer, clean into it, then use the buffer.
|
|
llvm::SmallVector<char, 64> IdentifierBuffer;
|
|
IdentifierBuffer.resize(Identifier.getLength());
|
|
const char *TmpBuf = &IdentifierBuffer[0];
|
|
unsigned Size = getSpelling(Identifier, TmpBuf);
|
|
II = getIdentifierInfo(TmpBuf, TmpBuf+Size);
|
|
}
|
|
Identifier.setIdentifierInfo(II);
|
|
return II;
|
|
}
|
|
|
|
|
|
/// HandleIdentifier - This callback is invoked when the lexer reads an
|
|
/// identifier. This callback looks up the identifier in the map and/or
|
|
/// potentially macro expands it or turns it into a named token (like 'for').
|
|
void Preprocessor::HandleIdentifier(Token &Identifier) {
|
|
assert(Identifier.getIdentifierInfo() &&
|
|
"Can't handle identifiers without identifier info!");
|
|
|
|
IdentifierInfo &II = *Identifier.getIdentifierInfo();
|
|
|
|
// If this identifier was poisoned, and if it was not produced from a macro
|
|
// expansion, emit an error.
|
|
if (II.isPoisoned() && CurLexer) {
|
|
if (&II != Ident__VA_ARGS__) // We warn about __VA_ARGS__ with poisoning.
|
|
Diag(Identifier, diag::err_pp_used_poisoned_id);
|
|
else
|
|
Diag(Identifier, diag::ext_pp_bad_vaargs_use);
|
|
}
|
|
|
|
// If this is a macro to be expanded, do it.
|
|
if (MacroInfo *MI = getMacroInfo(&II)) {
|
|
if (!DisableMacroExpansion && !Identifier.isExpandDisabled()) {
|
|
if (MI->isEnabled()) {
|
|
if (!HandleMacroExpandedIdentifier(Identifier, MI))
|
|
return;
|
|
} else {
|
|
// C99 6.10.3.4p2 says that a disabled macro may never again be
|
|
// expanded, even if it's in a context where it could be expanded in the
|
|
// future.
|
|
Identifier.setFlag(Token::DisableExpand);
|
|
}
|
|
}
|
|
} else if (II.isOtherTargetMacro() && !DisableMacroExpansion) {
|
|
// If this identifier is a macro on some other target, emit a diagnostic.
|
|
// This diagnosic is only emitted when macro expansion is enabled, because
|
|
// the macro would not have been expanded for the other target either.
|
|
II.setIsOtherTargetMacro(false); // Don't warn on second use.
|
|
getTargetInfo().DiagnoseNonPortability(Identifier.getLocation(),
|
|
diag::port_target_macro_use);
|
|
|
|
}
|
|
|
|
// C++ 2.11p2: If this is an alternative representation of a C++ operator,
|
|
// then we act as if it is the actual operator and not the textual
|
|
// representation of it.
|
|
if (II.isCPlusPlusOperatorKeyword())
|
|
Identifier.setIdentifierInfo(0);
|
|
|
|
// Change the kind of this identifier to the appropriate token kind, e.g.
|
|
// turning "for" into a keyword.
|
|
Identifier.setKind(II.getTokenID());
|
|
|
|
// If this is an extension token, diagnose its use.
|
|
// FIXME: tried (unsuccesfully) to shut this up when compiling with gnu99
|
|
// For now, I'm just commenting it out (while I work on attributes).
|
|
if (II.isExtensionToken() && Features.C99)
|
|
Diag(Identifier, diag::ext_token_used);
|
|
}
|
|
|
|
/// HandleEndOfFile - This callback is invoked when the lexer hits the end of
|
|
/// the current file. This either returns the EOF token or pops a level off
|
|
/// the include stack and keeps going.
|
|
bool Preprocessor::HandleEndOfFile(Token &Result, bool isEndOfMacro) {
|
|
assert(!CurMacroExpander &&
|
|
"Ending a file when currently in a macro!");
|
|
|
|
// See if this file had a controlling macro.
|
|
if (CurLexer) { // Not ending a macro, ignore it.
|
|
if (const IdentifierInfo *ControllingMacro =
|
|
CurLexer->MIOpt.GetControllingMacroAtEndOfFile()) {
|
|
// Okay, this has a controlling macro, remember in PerFileInfo.
|
|
if (const FileEntry *FE =
|
|
SourceMgr.getFileEntryForLoc(CurLexer->getFileLoc()))
|
|
HeaderInfo.SetFileControllingMacro(FE, ControllingMacro);
|
|
}
|
|
}
|
|
|
|
// If this is a #include'd file, pop it off the include stack and continue
|
|
// lexing the #includer file.
|
|
if (!IncludeMacroStack.empty()) {
|
|
// We're done with the #included file.
|
|
RemoveTopOfLexerStack();
|
|
|
|
// Notify the client, if desired, that we are in a new source file.
|
|
if (Callbacks && !isEndOfMacro && CurLexer) {
|
|
DirectoryLookup::DirType FileType = DirectoryLookup::NormalHeaderDir;
|
|
|
|
// Get the file entry for the current file.
|
|
if (const FileEntry *FE =
|
|
SourceMgr.getFileEntryForLoc(CurLexer->getFileLoc()))
|
|
FileType = HeaderInfo.getFileDirFlavor(FE);
|
|
|
|
Callbacks->FileChanged(CurLexer->getSourceLocation(CurLexer->BufferPtr),
|
|
PPCallbacks::ExitFile, FileType);
|
|
}
|
|
|
|
// Client should lex another token.
|
|
return false;
|
|
}
|
|
|
|
Result.startToken();
|
|
CurLexer->BufferPtr = CurLexer->BufferEnd;
|
|
CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd);
|
|
Result.setKind(tok::eof);
|
|
|
|
// We're done with the #included file.
|
|
delete CurLexer;
|
|
CurLexer = 0;
|
|
|
|
// This is the end of the top-level file. If the diag::pp_macro_not_used
|
|
// diagnostic is enabled, look for macros that have not been used.
|
|
if (Diags.getDiagnosticLevel(diag::pp_macro_not_used) != Diagnostic::Ignored){
|
|
for (llvm::DenseMap<IdentifierInfo*, MacroInfo*>::iterator I =
|
|
Macros.begin(), E = Macros.end(); I != E; ++I) {
|
|
if (!I->second->isUsed())
|
|
Diag(I->second->getDefinitionLoc(), diag::pp_macro_not_used);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/// HandleEndOfMacro - This callback is invoked when the lexer hits the end of
|
|
/// the current macro expansion or token stream expansion.
|
|
bool Preprocessor::HandleEndOfMacro(Token &Result) {
|
|
assert(CurMacroExpander && !CurLexer &&
|
|
"Ending a macro when currently in a #include file!");
|
|
|
|
// Delete or cache the now-dead macro expander.
|
|
if (NumCachedMacroExpanders == MacroExpanderCacheSize)
|
|
delete CurMacroExpander;
|
|
else
|
|
MacroExpanderCache[NumCachedMacroExpanders++] = CurMacroExpander;
|
|
|
|
// Handle this like a #include file being popped off the stack.
|
|
CurMacroExpander = 0;
|
|
return HandleEndOfFile(Result, true);
|
|
}
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Utility Methods for Preprocessor Directive Handling.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// DiscardUntilEndOfDirective - Read and discard all tokens remaining on the
|
|
/// current line until the tok::eom token is found.
|
|
void Preprocessor::DiscardUntilEndOfDirective() {
|
|
Token Tmp;
|
|
do {
|
|
LexUnexpandedToken(Tmp);
|
|
} while (Tmp.getKind() != tok::eom);
|
|
}
|
|
|
|
/// isCXXNamedOperator - Returns "true" if the token is a named operator in C++.
|
|
static bool isCXXNamedOperator(const std::string &Spelling) {
|
|
return Spelling == "and" || Spelling == "bitand" || Spelling == "bitor" ||
|
|
Spelling == "compl" || Spelling == "not" || Spelling == "not_eq" ||
|
|
Spelling == "or" || Spelling == "xor";
|
|
}
|
|
|
|
/// ReadMacroName - Lex and validate a macro name, which occurs after a
|
|
/// #define or #undef. This sets the token kind to eom and discards the rest
|
|
/// of the macro line if the macro name is invalid. isDefineUndef is 1 if
|
|
/// this is due to a a #define, 2 if #undef directive, 0 if it is something
|
|
/// else (e.g. #ifdef).
|
|
void Preprocessor::ReadMacroName(Token &MacroNameTok, char isDefineUndef) {
|
|
// Read the token, don't allow macro expansion on it.
|
|
LexUnexpandedToken(MacroNameTok);
|
|
|
|
// Missing macro name?
|
|
if (MacroNameTok.getKind() == tok::eom)
|
|
return Diag(MacroNameTok, diag::err_pp_missing_macro_name);
|
|
|
|
IdentifierInfo *II = MacroNameTok.getIdentifierInfo();
|
|
if (II == 0) {
|
|
std::string Spelling = getSpelling(MacroNameTok);
|
|
if (isCXXNamedOperator(Spelling))
|
|
// C++ 2.5p2: Alternative tokens behave the same as its primary token
|
|
// except for their spellings.
|
|
Diag(MacroNameTok, diag::err_pp_operator_used_as_macro_name, Spelling);
|
|
else
|
|
Diag(MacroNameTok, diag::err_pp_macro_not_identifier);
|
|
// Fall through on error.
|
|
} else if (isDefineUndef && II->getPPKeywordID() == tok::pp_defined) {
|
|
// Error if defining "defined": C99 6.10.8.4.
|
|
Diag(MacroNameTok, diag::err_defined_macro_name);
|
|
} else if (isDefineUndef && II->hasMacroDefinition() &&
|
|
getMacroInfo(II)->isBuiltinMacro()) {
|
|
// Error if defining "__LINE__" and other builtins: C99 6.10.8.4.
|
|
if (isDefineUndef == 1)
|
|
Diag(MacroNameTok, diag::pp_redef_builtin_macro);
|
|
else
|
|
Diag(MacroNameTok, diag::pp_undef_builtin_macro);
|
|
} else {
|
|
// Okay, we got a good identifier node. Return it.
|
|
return;
|
|
}
|
|
|
|
// Invalid macro name, read and discard the rest of the line. Then set the
|
|
// token kind to tok::eom.
|
|
MacroNameTok.setKind(tok::eom);
|
|
return DiscardUntilEndOfDirective();
|
|
}
|
|
|
|
/// CheckEndOfDirective - Ensure that the next token is a tok::eom token. If
|
|
/// not, emit a diagnostic and consume up until the eom.
|
|
void Preprocessor::CheckEndOfDirective(const char *DirType) {
|
|
Token Tmp;
|
|
Lex(Tmp);
|
|
// There should be no tokens after the directive, but we allow them as an
|
|
// extension.
|
|
while (Tmp.getKind() == tok::comment) // Skip comments in -C mode.
|
|
Lex(Tmp);
|
|
|
|
if (Tmp.getKind() != tok::eom) {
|
|
Diag(Tmp, diag::ext_pp_extra_tokens_at_eol, DirType);
|
|
DiscardUntilEndOfDirective();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/// SkipExcludedConditionalBlock - We just read a #if or related directive and
|
|
/// decided that the subsequent tokens are in the #if'd out portion of the
|
|
/// file. Lex the rest of the file, until we see an #endif. If
|
|
/// FoundNonSkipPortion is true, then we have already emitted code for part of
|
|
/// this #if directive, so #else/#elif blocks should never be entered. If ElseOk
|
|
/// is true, then #else directives are ok, if not, then we have already seen one
|
|
/// so a #else directive is a duplicate. When this returns, the caller can lex
|
|
/// the first valid token.
|
|
void Preprocessor::SkipExcludedConditionalBlock(SourceLocation IfTokenLoc,
|
|
bool FoundNonSkipPortion,
|
|
bool FoundElse) {
|
|
++NumSkipped;
|
|
assert(CurMacroExpander == 0 && CurLexer &&
|
|
"Lexing a macro, not a file?");
|
|
|
|
CurLexer->pushConditionalLevel(IfTokenLoc, /*isSkipping*/false,
|
|
FoundNonSkipPortion, FoundElse);
|
|
|
|
// Enter raw mode to disable identifier lookup (and thus macro expansion),
|
|
// disabling warnings, etc.
|
|
CurLexer->LexingRawMode = true;
|
|
Token Tok;
|
|
while (1) {
|
|
CurLexer->Lex(Tok);
|
|
|
|
// If this is the end of the buffer, we have an error.
|
|
if (Tok.getKind() == tok::eof) {
|
|
// Emit errors for each unterminated conditional on the stack, including
|
|
// the current one.
|
|
while (!CurLexer->ConditionalStack.empty()) {
|
|
Diag(CurLexer->ConditionalStack.back().IfLoc,
|
|
diag::err_pp_unterminated_conditional);
|
|
CurLexer->ConditionalStack.pop_back();
|
|
}
|
|
|
|
// Just return and let the caller lex after this #include.
|
|
break;
|
|
}
|
|
|
|
// If this token is not a preprocessor directive, just skip it.
|
|
if (Tok.getKind() != tok::hash || !Tok.isAtStartOfLine())
|
|
continue;
|
|
|
|
// We just parsed a # character at the start of a line, so we're in
|
|
// directive mode. Tell the lexer this so any newlines we see will be
|
|
// converted into an EOM token (this terminates the macro).
|
|
CurLexer->ParsingPreprocessorDirective = true;
|
|
CurLexer->KeepCommentMode = false;
|
|
|
|
|
|
// Read the next token, the directive flavor.
|
|
LexUnexpandedToken(Tok);
|
|
|
|
// If this isn't an identifier directive (e.g. is "# 1\n" or "#\n", or
|
|
// something bogus), skip it.
|
|
if (Tok.getKind() != tok::identifier) {
|
|
CurLexer->ParsingPreprocessorDirective = false;
|
|
// Restore comment saving mode.
|
|
CurLexer->KeepCommentMode = KeepComments;
|
|
continue;
|
|
}
|
|
|
|
// If the first letter isn't i or e, it isn't intesting to us. We know that
|
|
// this is safe in the face of spelling differences, because there is no way
|
|
// to spell an i/e in a strange way that is another letter. Skipping this
|
|
// allows us to avoid looking up the identifier info for #define/#undef and
|
|
// other common directives.
|
|
const char *RawCharData = SourceMgr.getCharacterData(Tok.getLocation());
|
|
char FirstChar = RawCharData[0];
|
|
if (FirstChar >= 'a' && FirstChar <= 'z' &&
|
|
FirstChar != 'i' && FirstChar != 'e') {
|
|
CurLexer->ParsingPreprocessorDirective = false;
|
|
// Restore comment saving mode.
|
|
CurLexer->KeepCommentMode = KeepComments;
|
|
continue;
|
|
}
|
|
|
|
// Get the identifier name without trigraphs or embedded newlines. Note
|
|
// that we can't use Tok.getIdentifierInfo() because its lookup is disabled
|
|
// when skipping.
|
|
// TODO: could do this with zero copies in the no-clean case by using
|
|
// strncmp below.
|
|
char Directive[20];
|
|
unsigned IdLen;
|
|
if (!Tok.needsCleaning() && Tok.getLength() < 20) {
|
|
IdLen = Tok.getLength();
|
|
memcpy(Directive, RawCharData, IdLen);
|
|
Directive[IdLen] = 0;
|
|
} else {
|
|
std::string DirectiveStr = getSpelling(Tok);
|
|
IdLen = DirectiveStr.size();
|
|
if (IdLen >= 20) {
|
|
CurLexer->ParsingPreprocessorDirective = false;
|
|
// Restore comment saving mode.
|
|
CurLexer->KeepCommentMode = KeepComments;
|
|
continue;
|
|
}
|
|
memcpy(Directive, &DirectiveStr[0], IdLen);
|
|
Directive[IdLen] = 0;
|
|
}
|
|
|
|
if (FirstChar == 'i' && Directive[1] == 'f') {
|
|
if ((IdLen == 2) || // "if"
|
|
(IdLen == 5 && !strcmp(Directive+2, "def")) || // "ifdef"
|
|
(IdLen == 6 && !strcmp(Directive+2, "ndef"))) { // "ifndef"
|
|
// We know the entire #if/#ifdef/#ifndef block will be skipped, don't
|
|
// bother parsing the condition.
|
|
DiscardUntilEndOfDirective();
|
|
CurLexer->pushConditionalLevel(Tok.getLocation(), /*wasskipping*/true,
|
|
/*foundnonskip*/false,
|
|
/*fnddelse*/false);
|
|
}
|
|
} else if (FirstChar == 'e') {
|
|
if (IdLen == 5 && !strcmp(Directive+1, "ndif")) { // "endif"
|
|
CheckEndOfDirective("#endif");
|
|
PPConditionalInfo CondInfo;
|
|
CondInfo.WasSkipping = true; // Silence bogus warning.
|
|
bool InCond = CurLexer->popConditionalLevel(CondInfo);
|
|
InCond = InCond; // Silence warning in no-asserts mode.
|
|
assert(!InCond && "Can't be skipping if not in a conditional!");
|
|
|
|
// If we popped the outermost skipping block, we're done skipping!
|
|
if (!CondInfo.WasSkipping)
|
|
break;
|
|
} else if (IdLen == 4 && !strcmp(Directive+1, "lse")) { // "else".
|
|
// #else directive in a skipping conditional. If not in some other
|
|
// skipping conditional, and if #else hasn't already been seen, enter it
|
|
// as a non-skipping conditional.
|
|
CheckEndOfDirective("#else");
|
|
PPConditionalInfo &CondInfo = CurLexer->peekConditionalLevel();
|
|
|
|
// If this is a #else with a #else before it, report the error.
|
|
if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_else_after_else);
|
|
|
|
// Note that we've seen a #else in this conditional.
|
|
CondInfo.FoundElse = true;
|
|
|
|
// If the conditional is at the top level, and the #if block wasn't
|
|
// entered, enter the #else block now.
|
|
if (!CondInfo.WasSkipping && !CondInfo.FoundNonSkip) {
|
|
CondInfo.FoundNonSkip = true;
|
|
break;
|
|
}
|
|
} else if (IdLen == 4 && !strcmp(Directive+1, "lif")) { // "elif".
|
|
PPConditionalInfo &CondInfo = CurLexer->peekConditionalLevel();
|
|
|
|
bool ShouldEnter;
|
|
// If this is in a skipping block or if we're already handled this #if
|
|
// block, don't bother parsing the condition.
|
|
if (CondInfo.WasSkipping || CondInfo.FoundNonSkip) {
|
|
DiscardUntilEndOfDirective();
|
|
ShouldEnter = false;
|
|
} else {
|
|
// Restore the value of LexingRawMode so that identifiers are
|
|
// looked up, etc, inside the #elif expression.
|
|
assert(CurLexer->LexingRawMode && "We have to be skipping here!");
|
|
CurLexer->LexingRawMode = false;
|
|
IdentifierInfo *IfNDefMacro = 0;
|
|
ShouldEnter = EvaluateDirectiveExpression(IfNDefMacro);
|
|
CurLexer->LexingRawMode = true;
|
|
}
|
|
|
|
// If this is a #elif with a #else before it, report the error.
|
|
if (CondInfo.FoundElse) Diag(Tok, diag::pp_err_elif_after_else);
|
|
|
|
// If this condition is true, enter it!
|
|
if (ShouldEnter) {
|
|
CondInfo.FoundNonSkip = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
CurLexer->ParsingPreprocessorDirective = false;
|
|
// Restore comment saving mode.
|
|
CurLexer->KeepCommentMode = KeepComments;
|
|
}
|
|
|
|
// Finally, if we are out of the conditional (saw an #endif or ran off the end
|
|
// of the file, just stop skipping and return to lexing whatever came after
|
|
// the #if block.
|
|
CurLexer->LexingRawMode = false;
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Preprocessor Directive Handling.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// HandleDirective - This callback is invoked when the lexer sees a # token
|
|
/// at the start of a line. This consumes the directive, modifies the
|
|
/// lexer/preprocessor state, and advances the lexer(s) so that the next token
|
|
/// read is the correct one.
|
|
void Preprocessor::HandleDirective(Token &Result) {
|
|
// FIXME: Traditional: # with whitespace before it not recognized by K&R?
|
|
|
|
// We just parsed a # character at the start of a line, so we're in directive
|
|
// mode. Tell the lexer this so any newlines we see will be converted into an
|
|
// EOM token (which terminates the directive).
|
|
CurLexer->ParsingPreprocessorDirective = true;
|
|
|
|
++NumDirectives;
|
|
|
|
// We are about to read a token. For the multiple-include optimization FA to
|
|
// work, we have to remember if we had read any tokens *before* this
|
|
// pp-directive.
|
|
bool ReadAnyTokensBeforeDirective = CurLexer->MIOpt.getHasReadAnyTokensVal();
|
|
|
|
// Read the next token, the directive flavor. This isn't expanded due to
|
|
// C99 6.10.3p8.
|
|
LexUnexpandedToken(Result);
|
|
|
|
// C99 6.10.3p11: Is this preprocessor directive in macro invocation? e.g.:
|
|
// #define A(x) #x
|
|
// A(abc
|
|
// #warning blah
|
|
// def)
|
|
// If so, the user is relying on non-portable behavior, emit a diagnostic.
|
|
if (InMacroArgs)
|
|
Diag(Result, diag::ext_embedded_directive);
|
|
|
|
TryAgain:
|
|
switch (Result.getKind()) {
|
|
case tok::eom:
|
|
return; // null directive.
|
|
case tok::comment:
|
|
// Handle stuff like "# /*foo*/ define X" in -E -C mode.
|
|
LexUnexpandedToken(Result);
|
|
goto TryAgain;
|
|
|
|
case tok::numeric_constant:
|
|
// FIXME: implement # 7 line numbers!
|
|
DiscardUntilEndOfDirective();
|
|
return;
|
|
default:
|
|
IdentifierInfo *II = Result.getIdentifierInfo();
|
|
if (II == 0) break; // Not an identifier.
|
|
|
|
// Ask what the preprocessor keyword ID is.
|
|
switch (II->getPPKeywordID()) {
|
|
default: break;
|
|
// C99 6.10.1 - Conditional Inclusion.
|
|
case tok::pp_if:
|
|
return HandleIfDirective(Result, ReadAnyTokensBeforeDirective);
|
|
case tok::pp_ifdef:
|
|
return HandleIfdefDirective(Result, false, true/*not valid for miopt*/);
|
|
case tok::pp_ifndef:
|
|
return HandleIfdefDirective(Result, true, ReadAnyTokensBeforeDirective);
|
|
case tok::pp_elif:
|
|
return HandleElifDirective(Result);
|
|
case tok::pp_else:
|
|
return HandleElseDirective(Result);
|
|
case tok::pp_endif:
|
|
return HandleEndifDirective(Result);
|
|
|
|
// C99 6.10.2 - Source File Inclusion.
|
|
case tok::pp_include:
|
|
return HandleIncludeDirective(Result); // Handle #include.
|
|
|
|
// C99 6.10.3 - Macro Replacement.
|
|
case tok::pp_define:
|
|
return HandleDefineDirective(Result, false);
|
|
case tok::pp_undef:
|
|
return HandleUndefDirective(Result);
|
|
|
|
// C99 6.10.4 - Line Control.
|
|
case tok::pp_line:
|
|
// FIXME: implement #line
|
|
DiscardUntilEndOfDirective();
|
|
return;
|
|
|
|
// C99 6.10.5 - Error Directive.
|
|
case tok::pp_error:
|
|
return HandleUserDiagnosticDirective(Result, false);
|
|
|
|
// C99 6.10.6 - Pragma Directive.
|
|
case tok::pp_pragma:
|
|
return HandlePragmaDirective();
|
|
|
|
// GNU Extensions.
|
|
case tok::pp_import:
|
|
return HandleImportDirective(Result);
|
|
case tok::pp_include_next:
|
|
return HandleIncludeNextDirective(Result);
|
|
|
|
case tok::pp_warning:
|
|
Diag(Result, diag::ext_pp_warning_directive);
|
|
return HandleUserDiagnosticDirective(Result, true);
|
|
case tok::pp_ident:
|
|
return HandleIdentSCCSDirective(Result);
|
|
case tok::pp_sccs:
|
|
return HandleIdentSCCSDirective(Result);
|
|
case tok::pp_assert:
|
|
//isExtension = true; // FIXME: implement #assert
|
|
break;
|
|
case tok::pp_unassert:
|
|
//isExtension = true; // FIXME: implement #unassert
|
|
break;
|
|
|
|
// clang extensions.
|
|
case tok::pp_define_target:
|
|
return HandleDefineDirective(Result, true);
|
|
case tok::pp_define_other_target:
|
|
return HandleDefineOtherTargetDirective(Result);
|
|
}
|
|
break;
|
|
}
|
|
|
|
// If we reached here, the preprocessing token is not valid!
|
|
Diag(Result, diag::err_pp_invalid_directive);
|
|
|
|
// Read the rest of the PP line.
|
|
DiscardUntilEndOfDirective();
|
|
|
|
// Okay, we're done parsing the directive.
|
|
}
|
|
|
|
void Preprocessor::HandleUserDiagnosticDirective(Token &Tok,
|
|
bool isWarning) {
|
|
// Read the rest of the line raw. We do this because we don't want macros
|
|
// to be expanded and we don't require that the tokens be valid preprocessing
|
|
// tokens. For example, this is allowed: "#warning ` 'foo". GCC does
|
|
// collapse multiple consequtive white space between tokens, but this isn't
|
|
// specified by the standard.
|
|
std::string Message = CurLexer->ReadToEndOfLine();
|
|
|
|
unsigned DiagID = isWarning ? diag::pp_hash_warning : diag::err_pp_hash_error;
|
|
return Diag(Tok, DiagID, Message);
|
|
}
|
|
|
|
/// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.
|
|
///
|
|
void Preprocessor::HandleIdentSCCSDirective(Token &Tok) {
|
|
// Yes, this directive is an extension.
|
|
Diag(Tok, diag::ext_pp_ident_directive);
|
|
|
|
// Read the string argument.
|
|
Token StrTok;
|
|
Lex(StrTok);
|
|
|
|
// If the token kind isn't a string, it's a malformed directive.
|
|
if (StrTok.getKind() != tok::string_literal &&
|
|
StrTok.getKind() != tok::wide_string_literal)
|
|
return Diag(StrTok, diag::err_pp_malformed_ident);
|
|
|
|
// Verify that there is nothing after the string, other than EOM.
|
|
CheckEndOfDirective("#ident");
|
|
|
|
if (Callbacks)
|
|
Callbacks->Ident(Tok.getLocation(), getSpelling(StrTok));
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Preprocessor Include Directive Handling.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully
|
|
/// checked and spelled filename, e.g. as an operand of #include. This returns
|
|
/// true if the input filename was in <>'s or false if it were in ""'s. The
|
|
/// caller is expected to provide a buffer that is large enough to hold the
|
|
/// spelling of the filename, but is also expected to handle the case when
|
|
/// this method decides to use a different buffer.
|
|
bool Preprocessor::GetIncludeFilenameSpelling(SourceLocation Loc,
|
|
const char *&BufStart,
|
|
const char *&BufEnd) {
|
|
// Get the text form of the filename.
|
|
assert(BufStart != BufEnd && "Can't have tokens with empty spellings!");
|
|
|
|
// Make sure the filename is <x> or "x".
|
|
bool isAngled;
|
|
if (BufStart[0] == '<') {
|
|
if (BufEnd[-1] != '>') {
|
|
Diag(Loc, diag::err_pp_expects_filename);
|
|
BufStart = 0;
|
|
return true;
|
|
}
|
|
isAngled = true;
|
|
} else if (BufStart[0] == '"') {
|
|
if (BufEnd[-1] != '"') {
|
|
Diag(Loc, diag::err_pp_expects_filename);
|
|
BufStart = 0;
|
|
return true;
|
|
}
|
|
isAngled = false;
|
|
} else {
|
|
Diag(Loc, diag::err_pp_expects_filename);
|
|
BufStart = 0;
|
|
return true;
|
|
}
|
|
|
|
// Diagnose #include "" as invalid.
|
|
if (BufEnd-BufStart <= 2) {
|
|
Diag(Loc, diag::err_pp_empty_filename);
|
|
BufStart = 0;
|
|
return "";
|
|
}
|
|
|
|
// Skip the brackets.
|
|
++BufStart;
|
|
--BufEnd;
|
|
return isAngled;
|
|
}
|
|
|
|
/// ConcatenateIncludeName - Handle cases where the #include name is expanded
|
|
/// from a macro as multiple tokens, which need to be glued together. This
|
|
/// occurs for code like:
|
|
/// #define FOO <a/b.h>
|
|
/// #include FOO
|
|
/// because in this case, "<a/b.h>" is returned as 7 tokens, not one.
|
|
///
|
|
/// This code concatenates and consumes tokens up to the '>' token. It returns
|
|
/// false if the > was found, otherwise it returns true if it finds and consumes
|
|
/// the EOM marker.
|
|
static bool ConcatenateIncludeName(llvm::SmallVector<char, 128> &FilenameBuffer,
|
|
Preprocessor &PP) {
|
|
Token CurTok;
|
|
|
|
PP.Lex(CurTok);
|
|
while (CurTok.getKind() != tok::eom) {
|
|
// Append the spelling of this token to the buffer. If there was a space
|
|
// before it, add it now.
|
|
if (CurTok.hasLeadingSpace())
|
|
FilenameBuffer.push_back(' ');
|
|
|
|
// Get the spelling of the token, directly into FilenameBuffer if possible.
|
|
unsigned PreAppendSize = FilenameBuffer.size();
|
|
FilenameBuffer.resize(PreAppendSize+CurTok.getLength());
|
|
|
|
const char *BufPtr = &FilenameBuffer[PreAppendSize];
|
|
unsigned ActualLen = PP.getSpelling(CurTok, BufPtr);
|
|
|
|
// If the token was spelled somewhere else, copy it into FilenameBuffer.
|
|
if (BufPtr != &FilenameBuffer[PreAppendSize])
|
|
memcpy(&FilenameBuffer[PreAppendSize], BufPtr, ActualLen);
|
|
|
|
// Resize FilenameBuffer to the correct size.
|
|
if (CurTok.getLength() != ActualLen)
|
|
FilenameBuffer.resize(PreAppendSize+ActualLen);
|
|
|
|
// If we found the '>' marker, return success.
|
|
if (CurTok.getKind() == tok::greater)
|
|
return false;
|
|
|
|
PP.Lex(CurTok);
|
|
}
|
|
|
|
// If we hit the eom marker, emit an error and return true so that the caller
|
|
// knows the EOM has been read.
|
|
PP.Diag(CurTok.getLocation(), diag::err_pp_expects_filename);
|
|
return true;
|
|
}
|
|
|
|
/// HandleIncludeDirective - The "#include" tokens have just been read, read the
|
|
/// file to be included from the lexer, then include it! This is a common
|
|
/// routine with functionality shared between #include, #include_next and
|
|
/// #import.
|
|
void Preprocessor::HandleIncludeDirective(Token &IncludeTok,
|
|
const DirectoryLookup *LookupFrom,
|
|
bool isImport) {
|
|
|
|
Token FilenameTok;
|
|
CurLexer->LexIncludeFilename(FilenameTok);
|
|
|
|
// Reserve a buffer to get the spelling.
|
|
llvm::SmallVector<char, 128> FilenameBuffer;
|
|
const char *FilenameStart, *FilenameEnd;
|
|
|
|
switch (FilenameTok.getKind()) {
|
|
case tok::eom:
|
|
// If the token kind is EOM, the error has already been diagnosed.
|
|
return;
|
|
|
|
case tok::angle_string_literal:
|
|
case tok::string_literal: {
|
|
FilenameBuffer.resize(FilenameTok.getLength());
|
|
FilenameStart = &FilenameBuffer[0];
|
|
unsigned Len = getSpelling(FilenameTok, FilenameStart);
|
|
FilenameEnd = FilenameStart+Len;
|
|
break;
|
|
}
|
|
|
|
case tok::less:
|
|
// This could be a <foo/bar.h> file coming from a macro expansion. In this
|
|
// case, glue the tokens together into FilenameBuffer and interpret those.
|
|
FilenameBuffer.push_back('<');
|
|
if (ConcatenateIncludeName(FilenameBuffer, *this))
|
|
return; // Found <eom> but no ">"? Diagnostic already emitted.
|
|
FilenameStart = &FilenameBuffer[0];
|
|
FilenameEnd = &FilenameBuffer[FilenameBuffer.size()];
|
|
break;
|
|
default:
|
|
Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
|
|
DiscardUntilEndOfDirective();
|
|
return;
|
|
}
|
|
|
|
bool isAngled = GetIncludeFilenameSpelling(FilenameTok.getLocation(),
|
|
FilenameStart, FilenameEnd);
|
|
// If GetIncludeFilenameSpelling set the start ptr to null, there was an
|
|
// error.
|
|
if (FilenameStart == 0) {
|
|
DiscardUntilEndOfDirective();
|
|
return;
|
|
}
|
|
|
|
// Verify that there is nothing after the filename, other than EOM. Use the
|
|
// preprocessor to lex this in case lexing the filename entered a macro.
|
|
CheckEndOfDirective("#include");
|
|
|
|
// Check that we don't have infinite #include recursion.
|
|
if (IncludeMacroStack.size() == MaxAllowedIncludeStackDepth-1)
|
|
return Diag(FilenameTok, diag::err_pp_include_too_deep);
|
|
|
|
// Search include directories.
|
|
const DirectoryLookup *CurDir;
|
|
const FileEntry *File = LookupFile(FilenameStart, FilenameEnd,
|
|
isAngled, LookupFrom, CurDir);
|
|
if (File == 0)
|
|
return Diag(FilenameTok, diag::err_pp_file_not_found,
|
|
std::string(FilenameStart, FilenameEnd));
|
|
|
|
// Ask HeaderInfo if we should enter this #include file.
|
|
if (!HeaderInfo.ShouldEnterIncludeFile(File, isImport)) {
|
|
// If it returns true, #including this file will have no effect.
|
|
return;
|
|
}
|
|
|
|
// Look up the file, create a File ID for it.
|
|
unsigned FileID = SourceMgr.createFileID(File, FilenameTok.getLocation());
|
|
if (FileID == 0)
|
|
return Diag(FilenameTok, diag::err_pp_file_not_found,
|
|
std::string(FilenameStart, FilenameEnd));
|
|
|
|
// Finally, if all is good, enter the new file!
|
|
EnterSourceFile(FileID, CurDir);
|
|
}
|
|
|
|
/// HandleIncludeNextDirective - Implements #include_next.
|
|
///
|
|
void Preprocessor::HandleIncludeNextDirective(Token &IncludeNextTok) {
|
|
Diag(IncludeNextTok, diag::ext_pp_include_next_directive);
|
|
|
|
// #include_next is like #include, except that we start searching after
|
|
// the current found directory. If we can't do this, issue a
|
|
// diagnostic.
|
|
const DirectoryLookup *Lookup = CurDirLookup;
|
|
if (isInPrimaryFile()) {
|
|
Lookup = 0;
|
|
Diag(IncludeNextTok, diag::pp_include_next_in_primary);
|
|
} else if (Lookup == 0) {
|
|
Diag(IncludeNextTok, diag::pp_include_next_absolute_path);
|
|
} else {
|
|
// Start looking up in the next directory.
|
|
++Lookup;
|
|
}
|
|
|
|
return HandleIncludeDirective(IncludeNextTok, Lookup);
|
|
}
|
|
|
|
/// HandleImportDirective - Implements #import.
|
|
///
|
|
void Preprocessor::HandleImportDirective(Token &ImportTok) {
|
|
Diag(ImportTok, diag::ext_pp_import_directive);
|
|
|
|
return HandleIncludeDirective(ImportTok, 0, true);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Preprocessor Macro Directive Handling.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// ReadMacroDefinitionArgList - The ( starting an argument list of a macro
|
|
/// definition has just been read. Lex the rest of the arguments and the
|
|
/// closing ), updating MI with what we learn. Return true if an error occurs
|
|
/// parsing the arg list.
|
|
bool Preprocessor::ReadMacroDefinitionArgList(MacroInfo *MI) {
|
|
llvm::SmallVector<IdentifierInfo*, 32> Arguments;
|
|
|
|
Token Tok;
|
|
while (1) {
|
|
LexUnexpandedToken(Tok);
|
|
switch (Tok.getKind()) {
|
|
case tok::r_paren:
|
|
// Found the end of the argument list.
|
|
if (Arguments.empty()) { // #define FOO()
|
|
MI->setArgumentList(Arguments.begin(), Arguments.end());
|
|
return false;
|
|
}
|
|
// Otherwise we have #define FOO(A,)
|
|
Diag(Tok, diag::err_pp_expected_ident_in_arg_list);
|
|
return true;
|
|
case tok::ellipsis: // #define X(... -> C99 varargs
|
|
// Warn if use of C99 feature in non-C99 mode.
|
|
if (!Features.C99) Diag(Tok, diag::ext_variadic_macro);
|
|
|
|
// Lex the token after the identifier.
|
|
LexUnexpandedToken(Tok);
|
|
if (Tok.getKind() != tok::r_paren) {
|
|
Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
|
|
return true;
|
|
}
|
|
// Add the __VA_ARGS__ identifier as an argument.
|
|
Arguments.push_back(Ident__VA_ARGS__);
|
|
MI->setIsC99Varargs();
|
|
MI->setArgumentList(Arguments.begin(), Arguments.end());
|
|
return false;
|
|
case tok::eom: // #define X(
|
|
Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
|
|
return true;
|
|
default:
|
|
// Handle keywords and identifiers here to accept things like
|
|
// #define Foo(for) for.
|
|
IdentifierInfo *II = Tok.getIdentifierInfo();
|
|
if (II == 0) {
|
|
// #define X(1
|
|
Diag(Tok, diag::err_pp_invalid_tok_in_arg_list);
|
|
return true;
|
|
}
|
|
|
|
// If this is already used as an argument, it is used multiple times (e.g.
|
|
// #define X(A,A.
|
|
if (std::find(Arguments.begin(), Arguments.end(), II) !=
|
|
Arguments.end()) { // C99 6.10.3p6
|
|
Diag(Tok, diag::err_pp_duplicate_name_in_arg_list, II->getName());
|
|
return true;
|
|
}
|
|
|
|
// Add the argument to the macro info.
|
|
Arguments.push_back(II);
|
|
|
|
// Lex the token after the identifier.
|
|
LexUnexpandedToken(Tok);
|
|
|
|
switch (Tok.getKind()) {
|
|
default: // #define X(A B
|
|
Diag(Tok, diag::err_pp_expected_comma_in_arg_list);
|
|
return true;
|
|
case tok::r_paren: // #define X(A)
|
|
MI->setArgumentList(Arguments.begin(), Arguments.end());
|
|
return false;
|
|
case tok::comma: // #define X(A,
|
|
break;
|
|
case tok::ellipsis: // #define X(A... -> GCC extension
|
|
// Diagnose extension.
|
|
Diag(Tok, diag::ext_named_variadic_macro);
|
|
|
|
// Lex the token after the identifier.
|
|
LexUnexpandedToken(Tok);
|
|
if (Tok.getKind() != tok::r_paren) {
|
|
Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);
|
|
return true;
|
|
}
|
|
|
|
MI->setIsGNUVarargs();
|
|
MI->setArgumentList(Arguments.begin(), Arguments.end());
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// HandleDefineDirective - Implements #define. This consumes the entire macro
|
|
/// line then lets the caller lex the next real token. If 'isTargetSpecific' is
|
|
/// true, then this is a "#define_target", otherwise this is a "#define".
|
|
///
|
|
void Preprocessor::HandleDefineDirective(Token &DefineTok,
|
|
bool isTargetSpecific) {
|
|
++NumDefined;
|
|
|
|
Token MacroNameTok;
|
|
ReadMacroName(MacroNameTok, 1);
|
|
|
|
// Error reading macro name? If so, diagnostic already issued.
|
|
if (MacroNameTok.getKind() == tok::eom)
|
|
return;
|
|
|
|
// If we are supposed to keep comments in #defines, reenable comment saving
|
|
// mode.
|
|
CurLexer->KeepCommentMode = KeepMacroComments;
|
|
|
|
// Create the new macro.
|
|
MacroInfo *MI = new MacroInfo(MacroNameTok.getLocation());
|
|
if (isTargetSpecific) MI->setIsTargetSpecific();
|
|
|
|
// If the identifier is an 'other target' macro, clear this bit.
|
|
MacroNameTok.getIdentifierInfo()->setIsOtherTargetMacro(false);
|
|
|
|
|
|
Token Tok;
|
|
LexUnexpandedToken(Tok);
|
|
|
|
// If this is a function-like macro definition, parse the argument list,
|
|
// marking each of the identifiers as being used as macro arguments. Also,
|
|
// check other constraints on the first token of the macro body.
|
|
if (Tok.getKind() == tok::eom) {
|
|
// If there is no body to this macro, we have no special handling here.
|
|
} else if (Tok.getKind() == tok::l_paren && !Tok.hasLeadingSpace()) {
|
|
// This is a function-like macro definition. Read the argument list.
|
|
MI->setIsFunctionLike();
|
|
if (ReadMacroDefinitionArgList(MI)) {
|
|
// Forget about MI.
|
|
delete MI;
|
|
// Throw away the rest of the line.
|
|
if (CurLexer->ParsingPreprocessorDirective)
|
|
DiscardUntilEndOfDirective();
|
|
return;
|
|
}
|
|
|
|
// Read the first token after the arg list for down below.
|
|
LexUnexpandedToken(Tok);
|
|
} else if (!Tok.hasLeadingSpace()) {
|
|
// C99 requires whitespace between the macro definition and the body. Emit
|
|
// a diagnostic for something like "#define X+".
|
|
if (Features.C99) {
|
|
Diag(Tok, diag::ext_c99_whitespace_required_after_macro_name);
|
|
} else {
|
|
// FIXME: C90/C++ do not get this diagnostic, but it does get a similar
|
|
// one in some cases!
|
|
}
|
|
} else {
|
|
// This is a normal token with leading space. Clear the leading space
|
|
// marker on the first token to get proper expansion.
|
|
Tok.clearFlag(Token::LeadingSpace);
|
|
}
|
|
|
|
// If this is a definition of a variadic C99 function-like macro, not using
|
|
// the GNU named varargs extension, enabled __VA_ARGS__.
|
|
|
|
// "Poison" __VA_ARGS__, which can only appear in the expansion of a macro.
|
|
// This gets unpoisoned where it is allowed.
|
|
assert(Ident__VA_ARGS__->isPoisoned() && "__VA_ARGS__ should be poisoned!");
|
|
if (MI->isC99Varargs())
|
|
Ident__VA_ARGS__->setIsPoisoned(false);
|
|
|
|
// Read the rest of the macro body.
|
|
if (MI->isObjectLike()) {
|
|
// Object-like macros are very simple, just read their body.
|
|
while (Tok.getKind() != tok::eom) {
|
|
MI->AddTokenToBody(Tok);
|
|
// Get the next token of the macro.
|
|
LexUnexpandedToken(Tok);
|
|
}
|
|
|
|
} else {
|
|
// Otherwise, read the body of a function-like macro. This has to validate
|
|
// the # (stringize) operator.
|
|
while (Tok.getKind() != tok::eom) {
|
|
MI->AddTokenToBody(Tok);
|
|
|
|
// Check C99 6.10.3.2p1: ensure that # operators are followed by macro
|
|
// parameters in function-like macro expansions.
|
|
if (Tok.getKind() != tok::hash) {
|
|
// Get the next token of the macro.
|
|
LexUnexpandedToken(Tok);
|
|
continue;
|
|
}
|
|
|
|
// Get the next token of the macro.
|
|
LexUnexpandedToken(Tok);
|
|
|
|
// Not a macro arg identifier?
|
|
if (!Tok.getIdentifierInfo() ||
|
|
MI->getArgumentNum(Tok.getIdentifierInfo()) == -1) {
|
|
Diag(Tok, diag::err_pp_stringize_not_parameter);
|
|
delete MI;
|
|
|
|
// Disable __VA_ARGS__ again.
|
|
Ident__VA_ARGS__->setIsPoisoned(true);
|
|
return;
|
|
}
|
|
|
|
// Things look ok, add the param name token to the macro.
|
|
MI->AddTokenToBody(Tok);
|
|
|
|
// Get the next token of the macro.
|
|
LexUnexpandedToken(Tok);
|
|
}
|
|
}
|
|
|
|
|
|
// Disable __VA_ARGS__ again.
|
|
Ident__VA_ARGS__->setIsPoisoned(true);
|
|
|
|
// Check that there is no paste (##) operator at the begining or end of the
|
|
// replacement list.
|
|
unsigned NumTokens = MI->getNumTokens();
|
|
if (NumTokens != 0) {
|
|
if (MI->getReplacementToken(0).getKind() == tok::hashhash) {
|
|
Diag(MI->getReplacementToken(0), diag::err_paste_at_start);
|
|
delete MI;
|
|
return;
|
|
}
|
|
if (MI->getReplacementToken(NumTokens-1).getKind() == tok::hashhash) {
|
|
Diag(MI->getReplacementToken(NumTokens-1), diag::err_paste_at_end);
|
|
delete MI;
|
|
return;
|
|
}
|
|
}
|
|
|
|
// If this is the primary source file, remember that this macro hasn't been
|
|
// used yet.
|
|
if (isInPrimaryFile())
|
|
MI->setIsUsed(false);
|
|
|
|
// Finally, if this identifier already had a macro defined for it, verify that
|
|
// the macro bodies are identical and free the old definition.
|
|
if (MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo())) {
|
|
if (!OtherMI->isUsed())
|
|
Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used);
|
|
|
|
// Macros must be identical. This means all tokes and whitespace separation
|
|
// must be the same. C99 6.10.3.2.
|
|
if (!MI->isIdenticalTo(*OtherMI, *this)) {
|
|
Diag(MI->getDefinitionLoc(), diag::ext_pp_macro_redef,
|
|
MacroNameTok.getIdentifierInfo()->getName());
|
|
Diag(OtherMI->getDefinitionLoc(), diag::ext_pp_macro_redef2);
|
|
}
|
|
delete OtherMI;
|
|
}
|
|
|
|
setMacroInfo(MacroNameTok.getIdentifierInfo(), MI);
|
|
}
|
|
|
|
/// HandleDefineOtherTargetDirective - Implements #define_other_target.
|
|
void Preprocessor::HandleDefineOtherTargetDirective(Token &Tok) {
|
|
Token MacroNameTok;
|
|
ReadMacroName(MacroNameTok, 1);
|
|
|
|
// Error reading macro name? If so, diagnostic already issued.
|
|
if (MacroNameTok.getKind() == tok::eom)
|
|
return;
|
|
|
|
// Check to see if this is the last token on the #undef line.
|
|
CheckEndOfDirective("#define_other_target");
|
|
|
|
// If there is already a macro defined by this name, turn it into a
|
|
// target-specific define.
|
|
if (MacroInfo *MI = getMacroInfo(MacroNameTok.getIdentifierInfo())) {
|
|
MI->setIsTargetSpecific(true);
|
|
return;
|
|
}
|
|
|
|
// Mark the identifier as being a macro on some other target.
|
|
MacroNameTok.getIdentifierInfo()->setIsOtherTargetMacro();
|
|
}
|
|
|
|
|
|
/// HandleUndefDirective - Implements #undef.
|
|
///
|
|
void Preprocessor::HandleUndefDirective(Token &UndefTok) {
|
|
++NumUndefined;
|
|
|
|
Token MacroNameTok;
|
|
ReadMacroName(MacroNameTok, 2);
|
|
|
|
// Error reading macro name? If so, diagnostic already issued.
|
|
if (MacroNameTok.getKind() == tok::eom)
|
|
return;
|
|
|
|
// Check to see if this is the last token on the #undef line.
|
|
CheckEndOfDirective("#undef");
|
|
|
|
// Okay, we finally have a valid identifier to undef.
|
|
MacroInfo *MI = getMacroInfo(MacroNameTok.getIdentifierInfo());
|
|
|
|
// #undef untaints an identifier if it were marked by define_other_target.
|
|
MacroNameTok.getIdentifierInfo()->setIsOtherTargetMacro(false);
|
|
|
|
// If the macro is not defined, this is a noop undef, just return.
|
|
if (MI == 0) return;
|
|
|
|
if (!MI->isUsed())
|
|
Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);
|
|
|
|
// Free macro definition.
|
|
delete MI;
|
|
setMacroInfo(MacroNameTok.getIdentifierInfo(), 0);
|
|
}
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Preprocessor Conditional Directive Handling.
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
/// HandleIfdefDirective - Implements the #ifdef/#ifndef directive. isIfndef is
|
|
/// true when this is a #ifndef directive. ReadAnyTokensBeforeDirective is true
|
|
/// if any tokens have been returned or pp-directives activated before this
|
|
/// #ifndef has been lexed.
|
|
///
|
|
void Preprocessor::HandleIfdefDirective(Token &Result, bool isIfndef,
|
|
bool ReadAnyTokensBeforeDirective) {
|
|
++NumIf;
|
|
Token DirectiveTok = Result;
|
|
|
|
Token MacroNameTok;
|
|
ReadMacroName(MacroNameTok);
|
|
|
|
// Error reading macro name? If so, diagnostic already issued.
|
|
if (MacroNameTok.getKind() == tok::eom) {
|
|
// Skip code until we get to #endif. This helps with recovery by not
|
|
// emitting an error when the #endif is reached.
|
|
SkipExcludedConditionalBlock(DirectiveTok.getLocation(),
|
|
/*Foundnonskip*/false, /*FoundElse*/false);
|
|
return;
|
|
}
|
|
|
|
// Check to see if this is the last token on the #if[n]def line.
|
|
CheckEndOfDirective(isIfndef ? "#ifndef" : "#ifdef");
|
|
|
|
// If the start of a top-level #ifdef, inform MIOpt.
|
|
if (!ReadAnyTokensBeforeDirective &&
|
|
CurLexer->getConditionalStackDepth() == 0) {
|
|
assert(isIfndef && "#ifdef shouldn't reach here");
|
|
CurLexer->MIOpt.EnterTopLevelIFNDEF(MacroNameTok.getIdentifierInfo());
|
|
}
|
|
|
|
IdentifierInfo *MII = MacroNameTok.getIdentifierInfo();
|
|
MacroInfo *MI = getMacroInfo(MII);
|
|
|
|
// If there is a macro, process it.
|
|
if (MI) {
|
|
// Mark it used.
|
|
MI->setIsUsed(true);
|
|
|
|
// If this is the first use of a target-specific macro, warn about it.
|
|
if (MI->isTargetSpecific()) {
|
|
MI->setIsTargetSpecific(false); // Don't warn on second use.
|
|
getTargetInfo().DiagnoseNonPortability(MacroNameTok.getLocation(),
|
|
diag::port_target_macro_use);
|
|
}
|
|
} else {
|
|
// Use of a target-specific macro for some other target? If so, warn.
|
|
if (MII->isOtherTargetMacro()) {
|
|
MII->setIsOtherTargetMacro(false); // Don't warn on second use.
|
|
getTargetInfo().DiagnoseNonPortability(MacroNameTok.getLocation(),
|
|
diag::port_target_macro_use);
|
|
}
|
|
}
|
|
|
|
// Should we include the stuff contained by this directive?
|
|
if (!MI == isIfndef) {
|
|
// Yes, remember that we are inside a conditional, then lex the next token.
|
|
CurLexer->pushConditionalLevel(DirectiveTok.getLocation(), /*wasskip*/false,
|
|
/*foundnonskip*/true, /*foundelse*/false);
|
|
} else {
|
|
// No, skip the contents of this block and return the first token after it.
|
|
SkipExcludedConditionalBlock(DirectiveTok.getLocation(),
|
|
/*Foundnonskip*/false,
|
|
/*FoundElse*/false);
|
|
}
|
|
}
|
|
|
|
/// HandleIfDirective - Implements the #if directive.
|
|
///
|
|
void Preprocessor::HandleIfDirective(Token &IfToken,
|
|
bool ReadAnyTokensBeforeDirective) {
|
|
++NumIf;
|
|
|
|
// Parse and evaluation the conditional expression.
|
|
IdentifierInfo *IfNDefMacro = 0;
|
|
bool ConditionalTrue = EvaluateDirectiveExpression(IfNDefMacro);
|
|
|
|
// Should we include the stuff contained by this directive?
|
|
if (ConditionalTrue) {
|
|
// If this condition is equivalent to #ifndef X, and if this is the first
|
|
// directive seen, handle it for the multiple-include optimization.
|
|
if (!ReadAnyTokensBeforeDirective &&
|
|
CurLexer->getConditionalStackDepth() == 0 && IfNDefMacro)
|
|
CurLexer->MIOpt.EnterTopLevelIFNDEF(IfNDefMacro);
|
|
|
|
// Yes, remember that we are inside a conditional, then lex the next token.
|
|
CurLexer->pushConditionalLevel(IfToken.getLocation(), /*wasskip*/false,
|
|
/*foundnonskip*/true, /*foundelse*/false);
|
|
} else {
|
|
// No, skip the contents of this block and return the first token after it.
|
|
SkipExcludedConditionalBlock(IfToken.getLocation(), /*Foundnonskip*/false,
|
|
/*FoundElse*/false);
|
|
}
|
|
}
|
|
|
|
/// HandleEndifDirective - Implements the #endif directive.
|
|
///
|
|
void Preprocessor::HandleEndifDirective(Token &EndifToken) {
|
|
++NumEndif;
|
|
|
|
// Check that this is the whole directive.
|
|
CheckEndOfDirective("#endif");
|
|
|
|
PPConditionalInfo CondInfo;
|
|
if (CurLexer->popConditionalLevel(CondInfo)) {
|
|
// No conditionals on the stack: this is an #endif without an #if.
|
|
return Diag(EndifToken, diag::err_pp_endif_without_if);
|
|
}
|
|
|
|
// If this the end of a top-level #endif, inform MIOpt.
|
|
if (CurLexer->getConditionalStackDepth() == 0)
|
|
CurLexer->MIOpt.ExitTopLevelConditional();
|
|
|
|
assert(!CondInfo.WasSkipping && !CurLexer->LexingRawMode &&
|
|
"This code should only be reachable in the non-skipping case!");
|
|
}
|
|
|
|
|
|
void Preprocessor::HandleElseDirective(Token &Result) {
|
|
++NumElse;
|
|
|
|
// #else directive in a non-skipping conditional... start skipping.
|
|
CheckEndOfDirective("#else");
|
|
|
|
PPConditionalInfo CI;
|
|
if (CurLexer->popConditionalLevel(CI))
|
|
return Diag(Result, diag::pp_err_else_without_if);
|
|
|
|
// If this is a top-level #else, inform the MIOpt.
|
|
if (CurLexer->getConditionalStackDepth() == 0)
|
|
CurLexer->MIOpt.FoundTopLevelElse();
|
|
|
|
// If this is a #else with a #else before it, report the error.
|
|
if (CI.FoundElse) Diag(Result, diag::pp_err_else_after_else);
|
|
|
|
// Finally, skip the rest of the contents of this block and return the first
|
|
// token after it.
|
|
return SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true,
|
|
/*FoundElse*/true);
|
|
}
|
|
|
|
void Preprocessor::HandleElifDirective(Token &ElifToken) {
|
|
++NumElse;
|
|
|
|
// #elif directive in a non-skipping conditional... start skipping.
|
|
// We don't care what the condition is, because we will always skip it (since
|
|
// the block immediately before it was included).
|
|
DiscardUntilEndOfDirective();
|
|
|
|
PPConditionalInfo CI;
|
|
if (CurLexer->popConditionalLevel(CI))
|
|
return Diag(ElifToken, diag::pp_err_elif_without_if);
|
|
|
|
// If this is a top-level #elif, inform the MIOpt.
|
|
if (CurLexer->getConditionalStackDepth() == 0)
|
|
CurLexer->MIOpt.FoundTopLevelElse();
|
|
|
|
// If this is a #elif with a #else before it, report the error.
|
|
if (CI.FoundElse) Diag(ElifToken, diag::pp_err_elif_after_else);
|
|
|
|
// Finally, skip the rest of the contents of this block and return the first
|
|
// token after it.
|
|
return SkipExcludedConditionalBlock(CI.IfLoc, /*Foundnonskip*/true,
|
|
/*FoundElse*/CI.FoundElse);
|
|
}
|
|
|