131 lines
5.0 KiB
C++
131 lines
5.0 KiB
C++
//===--- MultipleIncludeOpt.h - Header Multiple-Include Optzn ---*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the MultipleIncludeOpt interface.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_CLANG_MULTIPLEINCLUDEOPT_H
|
|
#define LLVM_CLANG_MULTIPLEINCLUDEOPT_H
|
|
|
|
namespace clang {
|
|
class IdentifierInfo;
|
|
|
|
/// MultipleIncludeOpt - This class implements the simple state machine that the
|
|
/// Lexer class uses to detect files subject to the 'multiple-include'
|
|
/// optimization. The public methods in this class are triggered by various
|
|
/// events that occur when a file is lexed, and after the entire file is lexed,
|
|
/// information about which macro (if any) controls the header is returned.
|
|
class MultipleIncludeOpt {
|
|
/// ReadAnyTokens - This is set to false when a file is first opened and true
|
|
/// any time a token is returned to the client or a (non-multiple-include)
|
|
/// directive is parsed. When the final #endif is parsed this is reset back
|
|
/// to false, that way any tokens before the first #ifdef or after the last
|
|
/// #endif can be easily detected.
|
|
bool ReadAnyTokens;
|
|
|
|
/// ReadAnyTokens - This is set to false when a file is first opened and true
|
|
/// any time a token is returned to the client or a (non-multiple-include)
|
|
/// directive is parsed. When the final #endif is parsed this is reset back
|
|
/// to false, that way any tokens before the first #ifdef or after the last
|
|
/// #endif can be easily detected.
|
|
bool DidMacroExpansion;
|
|
|
|
/// TheMacro - The controlling macro for a file, if valid.
|
|
///
|
|
const IdentifierInfo *TheMacro;
|
|
public:
|
|
MultipleIncludeOpt() {
|
|
ReadAnyTokens = false;
|
|
DidMacroExpansion = false;
|
|
TheMacro = 0;
|
|
}
|
|
|
|
/// Invalidate - Permenantly mark this file as not being suitable for the
|
|
/// include-file optimization.
|
|
void Invalidate() {
|
|
// If we have read tokens but have no controlling macro, the state-machine
|
|
// below can never "accept".
|
|
ReadAnyTokens = true;
|
|
TheMacro = 0;
|
|
}
|
|
|
|
/// getHasReadAnyTokensVal - This is used for the #ifndef hande-shake at the
|
|
/// top of the file when reading preprocessor directives. Otherwise, reading
|
|
/// the "ifndef x" would count as reading tokens.
|
|
bool getHasReadAnyTokensVal() const { return ReadAnyTokens; }
|
|
|
|
// If a token is read, remember that we have seen a side-effect in this file.
|
|
void ReadToken() { ReadAnyTokens = true; }
|
|
|
|
/// ExpandedMacro - When a macro is expanded with this lexer as the current
|
|
/// buffer, this method is called to disable the MIOpt if needed.
|
|
void ExpandedMacro() { DidMacroExpansion = true; }
|
|
|
|
/// EnterTopLevelIFNDEF - When entering a top-level #ifndef directive (or the
|
|
/// "#if !defined" equivalent) without any preceding tokens, this method is
|
|
/// called.
|
|
///
|
|
/// Note, we don't care about the input value of 'ReadAnyTokens'. The caller
|
|
/// ensures that this is only called if there are no tokens read before the
|
|
/// #ifndef. The caller is required to do this, because reading the #if line
|
|
/// obviously reads in in tokens.
|
|
void EnterTopLevelIFNDEF(const IdentifierInfo *M) {
|
|
// If the macro is already set, this is after the top-level #endif.
|
|
if (TheMacro)
|
|
return Invalidate();
|
|
|
|
// If we have already expanded a macro by the end of the #ifndef line, then
|
|
// there is a macro expansion *in* the #ifndef line. This means that the
|
|
// condition could evaluate differently when subsequently #included. Reject
|
|
// this.
|
|
if (DidMacroExpansion)
|
|
return Invalidate();
|
|
|
|
// Remember that we're in the #if and that we have the macro.
|
|
ReadAnyTokens = true;
|
|
TheMacro = M;
|
|
}
|
|
|
|
/// EnterTopLevelConditional - This is invoked when a top level conditional
|
|
/// (except #ifndef) is found.
|
|
void EnterTopLevelConditional() {
|
|
/// If a conditional directive (except #ifndef) is found at the top level,
|
|
/// there is a chunk of the file not guarded by the controlling macro.
|
|
Invalidate();
|
|
}
|
|
|
|
/// ExitTopLevelConditional - This method is called when the lexer exits the
|
|
/// top-level conditional.
|
|
void ExitTopLevelConditional() {
|
|
// If we have a macro, that means the top of the file was ok. Set our state
|
|
// back to "not having read any tokens" so we can detect anything after the
|
|
// #endif.
|
|
if (!TheMacro) return Invalidate();
|
|
|
|
// At this point, we haven't "read any tokens" but we do have a controlling
|
|
// macro.
|
|
ReadAnyTokens = false;
|
|
}
|
|
|
|
/// GetControllingMacroAtEndOfFile - Once the entire file has been lexed, if
|
|
/// there is a controlling macro, return it.
|
|
const IdentifierInfo *GetControllingMacroAtEndOfFile() const {
|
|
// If we haven't read any tokens after the #endif, return the controlling
|
|
// macro if it's valid (if it isn't, it will be null).
|
|
if (!ReadAnyTokens)
|
|
return TheMacro;
|
|
return 0;
|
|
}
|
|
};
|
|
|
|
} // end namespace clang
|
|
|
|
#endif
|