contrib/llvm/tools/clang/include/clang/Lex/MultipleIncludeOpt.h

   1 //===--- MultipleIncludeOpt.h - Header Multiple-Include Optzn ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file defines the MultipleIncludeOpt interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_MULTIPLEINCLUDEOPT_H
  15 #define LLVM_CLANG_MULTIPLEINCLUDEOPT_H
  16
  17 namespace clang {
  18 class IdentifierInfo;
  19
  20 /// MultipleIncludeOpt - This class implements the simple state machine that the
  21 /// Lexer class uses to detect files subject to the 'multiple-include'
  22 /// optimization.  The public methods in this class are triggered by various
  23 /// events that occur when a file is lexed, and after the entire file is lexed,
  24 /// information about which macro (if any) controls the header is returned.
  25 class MultipleIncludeOpt {
  26   /// ReadAnyTokens - This is set to false when a file is first opened and true
  27   /// any time a token is returned to the client or a (non-multiple-include)
  28   /// directive is parsed.  When the final #endif is parsed this is reset back
  29   /// to false, that way any tokens before the first #ifdef or after the last
  30   /// #endif can be easily detected.
  31   bool ReadAnyTokens;
  32
  33   /// ReadAnyTokens - This is set to false when a file is first opened and true
  34   /// any time a token is returned to the client or a (non-multiple-include)
  35   /// directive is parsed.  When the final #endif is parsed this is reset back
  36   /// to false, that way any tokens before the first #ifdef or after the last
  37   /// #endif can be easily detected.
  38   bool DidMacroExpansion;
  39
  40   /// TheMacro - The controlling macro for a file, if valid.
  41   ///
  42   const IdentifierInfo *TheMacro;
  43 public:
  44   MultipleIncludeOpt() {
  45     ReadAnyTokens = false;
  46     DidMacroExpansion = false;
  47     TheMacro = 0;
  48   }
  49
  50   /// Invalidate - Permanently mark this file as not being suitable for the
  51   /// include-file optimization.
  52   void Invalidate() {
  53     // If we have read tokens but have no controlling macro, the state-machine
  54     // below can never "accept".
  55     ReadAnyTokens = true;
  56     TheMacro = 0;
  57   }
  58
  59   /// getHasReadAnyTokensVal - This is used for the #ifndef hande-shake at the
  60   /// top of the file when reading preprocessor directives.  Otherwise, reading
  61   /// the "ifndef x" would count as reading tokens.
  62   bool getHasReadAnyTokensVal() const { return ReadAnyTokens; }
  63
  64   // If a token is read, remember that we have seen a side-effect in this file.
  65   void ReadToken() { ReadAnyTokens = true; }
  66
  67   /// ExpandedMacro - When a macro is expanded with this lexer as the current
  68   /// buffer, this method is called to disable the MIOpt if needed.
  69   void ExpandedMacro() { DidMacroExpansion = true; }
  70
  71   /// EnterTopLevelIFNDEF - When entering a top-level #ifndef directive (or the
  72   /// "#if !defined" equivalent) without any preceding tokens, this method is
  73   /// called.
  74   ///
  75   /// Note, we don't care about the input value of 'ReadAnyTokens'.  The caller
  76   /// ensures that this is only called if there are no tokens read before the
  77   /// #ifndef.  The caller is required to do this, because reading the #if line
  78   /// obviously reads in in tokens.
  79   void EnterTopLevelIFNDEF(const IdentifierInfo *M) {
  80     // If the macro is already set, this is after the top-level #endif.
  81     if (TheMacro)
  82       return Invalidate();
  83
  84     // If we have already expanded a macro by the end of the #ifndef line, then
  85     // there is a macro expansion *in* the #ifndef line.  This means that the
  86     // condition could evaluate differently when subsequently #included.  Reject
  87     // this.
  88     if (DidMacroExpansion)
  89       return Invalidate();
  90
  91     // Remember that we're in the #if and that we have the macro.
  92     ReadAnyTokens = true;
  93     TheMacro = M;
  94   }
  95
  96   /// EnterTopLevelConditional - This is invoked when a top level conditional
  97   /// (except #ifndef) is found.
  98   void EnterTopLevelConditional() {
  99     /// If a conditional directive (except #ifndef) is found at the top level,
 100     /// there is a chunk of the file not guarded by the controlling macro.
 101     Invalidate();
 102   }
 103
 104   /// ExitTopLevelConditional - This method is called when the lexer exits the
 105   /// top-level conditional.
 106   void ExitTopLevelConditional() {
 107     // If we have a macro, that means the top of the file was ok.  Set our state
 108     // back to "not having read any tokens" so we can detect anything after the
 109     // #endif.
 110     if (!TheMacro) return Invalidate();
 111
 112     // At this point, we haven't "read any tokens" but we do have a controlling
 113     // macro.
 114     ReadAnyTokens = false;
 115   }
 116
 117   /// GetControllingMacroAtEndOfFile - Once the entire file has been lexed, if
 118   /// there is a controlling macro, return it.
 119   const IdentifierInfo *GetControllingMacroAtEndOfFile() const {
 120     // If we haven't read any tokens after the #endif, return the controlling
 121     // macro if it's valid (if it isn't, it will be null).
 122     if (!ReadAnyTokens)
 123       return TheMacro;
 124     return 0;
 125   }
 126 };
 127
 128 }  // end namespace clang
 129
 130 #endif