//===--- MultipleIncludeOpt.h - Header Multiple-Include Optzn ---*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

///

/// \file

/// Defines the MultipleIncludeOpt interface.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_LEX_MULTIPLEINCLUDEOPT_H

#define LLVM_CLANG_LEX_MULTIPLEINCLUDEOPT_H

#include "clang/Basic/SourceLocation.h"

namespace clang {

class IdentifierInfo;

/// 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;

  /// ImmediatelyAfterTopLevelIfndef - This is true when the only tokens

  /// processed in the file so far is an #ifndef and an identifier.  Used in

  /// the detection of header guards in a file.

  bool ImmediatelyAfterTopLevelIfndef;

  /// 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;

  /// DefinedMacro - The macro defined right after TheMacro, if any.

  const IdentifierInfo *DefinedMacro;

  SourceLocation MacroLoc;

  SourceLocation DefinedLoc;

public:

  MultipleIncludeOpt() {

    ReadAnyTokens = false;

    ImmediatelyAfterTopLevelIfndef = false;

    DidMacroExpansion = false;

    TheMacro = nullptr;

    DefinedMacro = nullptr;

  }

  SourceLocation GetMacroLocation() const {

    return MacroLoc;

  }

  SourceLocation GetDefinedLocation() const {

    return DefinedLoc;

  }

  void resetImmediatelyAfterTopLevelIfndef() {

    ImmediatelyAfterTopLevelIfndef = false;

  }

  void SetDefinedMacro(IdentifierInfo *M, SourceLocation Loc) {

    DefinedMacro = M;

    DefinedLoc = Loc;

  }

  /// Invalidate - Permanently 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;

    ImmediatelyAfterTopLevelIfndef = false;

    DefinedMacro = nullptr;

    TheMacro = nullptr;

  }

  /// getHasReadAnyTokensVal - This is used for the \#ifndef handshake 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; }

  /// getImmediatelyAfterTopLevelIfndef - returns true if the last directive

  /// was an #ifndef at the beginning of the file.

  bool getImmediatelyAfterTopLevelIfndef() const {

    return ImmediatelyAfterTopLevelIfndef;

  }

  // If a token is read, remember that we have seen a side-effect in this file.

  void ReadToken() {

    ReadAnyTokens = true;

    ImmediatelyAfterTopLevelIfndef = false;

  }

  /// 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; }

  /// Called when entering a top-level \#ifndef directive (or the

  /// "\#if !defined" equivalent) without any preceding tokens.

  ///

  /// 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 tokens.

  void EnterTopLevelIfndef(const IdentifierInfo *M, SourceLocation Loc) {

    // 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;

    ImmediatelyAfterTopLevelIfndef = true;

    TheMacro = M;

    MacroLoc = Loc;

  }

  /// 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();

  }

  /// 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()231k
;

    // At this point, we haven't "read any tokens" but we do have a controlling

    // macro.

    ReadAnyTokens = false;

    ImmediatelyAfterTopLevelIfndef = false;

  }

  /// 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 nullptr;

  }

  /// If the ControllingMacro is followed by a macro definition, return

  /// the macro that was defined.

  const IdentifierInfo *GetDefinedMacro() const {

    return DefinedMacro;

  }

};

}  // end namespace clang

#endif