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

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