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 /// \file
  11 /// \brief Defines the MultipleIncludeOpt interface.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_MULTIPLEINCLUDEOPT_H
  16 #define LLVM_CLANG_MULTIPLEINCLUDEOPT_H
  17
  18 #include "clang/Basic/SourceLocation.h"
  19
  20 namespace clang {
  21 class IdentifierInfo;
  22
  23 /// \brief Implements the simple state machine that the Lexer class uses to
  24 /// detect files subject to the 'multiple-include' optimization.
  25 ///
  26 /// The public methods in this class are triggered by various
  27 /// events that occur when a file is lexed, and after the entire file is lexed,
  28 /// information about which macro (if any) controls the header is returned.
  29 class MultipleIncludeOpt {
  30   /// ReadAnyTokens - This is set to false when a file is first opened and true
  31   /// any time a token is returned to the client or a (non-multiple-include)
  32   /// directive is parsed.  When the final \#endif is parsed this is reset back
  33   /// to false, that way any tokens before the first \#ifdef or after the last
  34   /// \#endif can be easily detected.
  35   bool ReadAnyTokens;
  36
  37   /// ImmediatelyAfterTopLevelIfndef - This is true when the only tokens
  38   /// processed in the file so far is an #ifndef and an identifier.  Used in
  39   /// the detection of header guards in a file.
  40   bool ImmediatelyAfterTopLevelIfndef;
  41
  42   /// ReadAnyTokens - This is set to false when a file is first opened and true
  43   /// any time a token is returned to the client or a (non-multiple-include)
  44   /// directive is parsed.  When the final #endif is parsed this is reset back
  45   /// to false, that way any tokens before the first #ifdef or after the last
  46   /// #endif can be easily detected.
  47   bool DidMacroExpansion;
  48
  49   /// TheMacro - The controlling macro for a file, if valid.
  50   ///
  51   const IdentifierInfo *TheMacro;
  52
  53   /// DefinedMacro - The macro defined right after TheMacro, if any.
  54   const IdentifierInfo *DefinedMacro;
  55
  56   SourceLocation MacroLoc;
  57   SourceLocation DefinedLoc;
  58 public:
  59   MultipleIncludeOpt() {
  60     ReadAnyTokens = false;
  61     ImmediatelyAfterTopLevelIfndef = false;
  62     DidMacroExpansion = false;
  63     TheMacro = 0;
  64     DefinedMacro = 0;
  65   }
  66
  67   SourceLocation GetMacroLocation() const {
  68     return MacroLoc;
  69   }
  70
  71   SourceLocation GetDefinedLocation() const {
  72     return DefinedLoc;
  73   }
  74
  75   void resetImmediatelyAfterTopLevelIfndef() {
  76     ImmediatelyAfterTopLevelIfndef = false;
  77   }
  78
  79   void SetDefinedMacro(IdentifierInfo *M, SourceLocation Loc) {
  80     DefinedMacro = M;
  81     DefinedLoc = Loc;
  82   }
  83
  84   /// Invalidate - Permanently mark this file as not being suitable for the
  85   /// include-file optimization.
  86   void Invalidate() {
  87     // If we have read tokens but have no controlling macro, the state-machine
  88     // below can never "accept".
  89     ReadAnyTokens = true;
  90     ImmediatelyAfterTopLevelIfndef = false;
  91     DefinedMacro = 0;
  92     TheMacro = 0;
  93   }
  94
  95   /// getHasReadAnyTokensVal - This is used for the \#ifndef hande-shake at the
  96   /// top of the file when reading preprocessor directives.  Otherwise, reading
  97   /// the "ifndef x" would count as reading tokens.
  98   bool getHasReadAnyTokensVal() const { return ReadAnyTokens; }
  99
 100   /// getImmediatelyAfterTopLevelIfndef - returns true if the last directive
 101   /// was an #ifndef at the beginning of the file.
 102   bool getImmediatelyAfterTopLevelIfndef() const {
 103     return ImmediatelyAfterTopLevelIfndef;
 104   }
 105
 106   // If a token is read, remember that we have seen a side-effect in this file.
 107   void ReadToken() {
 108     ReadAnyTokens = true;
 109     ImmediatelyAfterTopLevelIfndef = false;
 110   }
 111
 112   /// ExpandedMacro - When a macro is expanded with this lexer as the current
 113   /// buffer, this method is called to disable the MIOpt if needed.
 114   void ExpandedMacro() { DidMacroExpansion = true; }
 115
 116   /// \brief Called when entering a top-level \#ifndef directive (or the
 117   /// "\#if !defined" equivalent) without any preceding tokens.
 118   ///
 119   /// Note, we don't care about the input value of 'ReadAnyTokens'.  The caller
 120   /// ensures that this is only called if there are no tokens read before the
 121   /// \#ifndef.  The caller is required to do this, because reading the \#if
 122   /// line obviously reads in in tokens.
 123   void EnterTopLevelIfndef(const IdentifierInfo *M, SourceLocation Loc) {
 124     // If the macro is already set, this is after the top-level #endif.
 125     if (TheMacro)
 126       return Invalidate();
 127
 128     // If we have already expanded a macro by the end of the #ifndef line, then
 129     // there is a macro expansion *in* the #ifndef line.  This means that the
 130     // condition could evaluate differently when subsequently #included.  Reject
 131     // this.
 132     if (DidMacroExpansion)
 133       return Invalidate();
 134
 135     // Remember that we're in the #if and that we have the macro.
 136     ReadAnyTokens = true;
 137     ImmediatelyAfterTopLevelIfndef = true;
 138     TheMacro = M;
 139     MacroLoc = Loc;
 140   }
 141
 142   /// \brief Invoked when a top level conditional (except \#ifndef) is found.
 143   void EnterTopLevelConditional() {
 144     // If a conditional directive (except #ifndef) is found at the top level,
 145     // there is a chunk of the file not guarded by the controlling macro.
 146     Invalidate();
 147   }
 148
 149   /// \brief Called when the lexer exits the top-level conditional.
 150   void ExitTopLevelConditional() {
 151     // If we have a macro, that means the top of the file was ok.  Set our state
 152     // back to "not having read any tokens" so we can detect anything after the
 153     // #endif.
 154     if (!TheMacro) return Invalidate();
 155
 156     // At this point, we haven't "read any tokens" but we do have a controlling
 157     // macro.
 158     ReadAnyTokens = false;
 159     ImmediatelyAfterTopLevelIfndef = false;
 160   }
 161
 162   /// \brief Once the entire file has been lexed, if there is a controlling
 163   /// macro, return it.
 164   const IdentifierInfo *GetControllingMacroAtEndOfFile() const {
 165     // If we haven't read any tokens after the #endif, return the controlling
 166     // macro if it's valid (if it isn't, it will be null).
 167     if (!ReadAnyTokens)
 168       return TheMacro;
 169     return 0;
 170   }
 171
 172   /// \brief If the ControllingMacro is followed by a macro definition, return
 173   /// the macro that was defined.
 174   const IdentifierInfo *GetDefinedMacro() const {
 175     return DefinedMacro;
 176   }
 177 };
 178
 179 }  // end namespace clang
 180
 181 #endif