File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/clang/include/clang/Lex

usr / src / contrib / llvm-project / clang / include / clang / Lex /

📁 ..
📄 CodeCompletionHandler.h(3.02 KB)
📄 DependencyDirectivesSourceMinimizer.h(3.66 KB)
📄 DirectoryLookup.h(7.21 KB)
📄 ExternalPreprocessorSource.h(1.52 KB)
📄 HeaderMap.h(3.27 KB)
📄 HeaderMapTypes.h(1.45 KB)
📄 HeaderSearch.h(31.25 KB)
📄 HeaderSearchOptions.h(8.62 KB)
📄 LexDiagnostic.h(496 B)
📄 Lexer.h(33.92 KB)
📄 LiteralSupport.h(10.06 KB)
📄 MacroArgs.h(5.41 KB)
📄 MacroInfo.h(20.14 KB)
📄 ModuleLoader.h(7.25 KB)
📄 ModuleMap.h(27.64 KB)
📄 MultipleIncludeOpt.h(6.41 KB)
📄 PPCallbacks.h(23.05 KB)
📄 PPConditionalDirectiveRecord.h(3.75 KB)
📄 Pragma.h(4.23 KB)
📄 PreprocessingRecord.h(20.55 KB)
📄 Preprocessor.h(89.66 KB)
📄 PreprocessorExcludedConditionalDirectiveSkipMapping.h(1.24 KB)
📄 PreprocessorLexer.h(6.1 KB)
📄 PreprocessorOptions.h(8.35 KB)
📄 ScratchBuffer.h(1.41 KB)
📄 Token.h(11.63 KB)
📄 TokenConcatenation.h(2.55 KB)
📄 TokenLexer.h(9.96 KB)
📄 VariadicMacroSupport.h(8.95 KB)

Editing: PreprocessorLexer.h

//===- PreprocessorLexer.h - C Language Family Lexer ------------*- 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 PreprocessorLexer interface.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_LEX_PREPROCESSORLEXER_H
#define LLVM_CLANG_LEX_PREPROCESSORLEXER_H

#include "clang/Lex/MultipleIncludeOpt.h"
#include "clang/Lex/Token.h"
#include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h"
#include <cassert>

namespace clang {

class FileEntry;
class Preprocessor;

class PreprocessorLexer {
  virtual void anchor();

protected:
  friend class Preprocessor;

// Preprocessor object controlling lexing.
  Preprocessor *PP = nullptr;

/// The SourceManager FileID corresponding to the file being lexed.
  const FileID FID;

/// Number of SLocEntries before lexing the file.
  unsigned InitialNumSLocEntries = 0;

//===--------------------------------------------------------------------===//
  // Context-specific lexing flags set by the preprocessor.
  //===--------------------------------------------------------------------===//

/// True when parsing \#XXX; turns '\\n' into a tok::eod token.
  bool ParsingPreprocessorDirective = false;

/// True after \#include; turns \<xx> or "xxx" into a tok::header_name token.
  bool ParsingFilename = false;

/// True if in raw mode.
  ///
  /// Raw mode disables interpretation of tokens and is a far faster mode to
  /// lex in than non-raw-mode.  This flag:
  ///  1. If EOF of the current lexer is found, the include stack isn't popped.
  ///  2. Identifier information is not looked up for identifier tokens.  As an
  ///     effect of this, implicit macro expansion is naturally disabled.
  ///  3. "#" tokens at the start of a line are treated as normal tokens, not
  ///     implicitly transformed by the lexer.
  ///  4. All diagnostic messages are disabled.
  ///  5. No callbacks are made into the preprocessor.
  ///
  /// Note that in raw mode that the PP pointer may be null.
  bool LexingRawMode = false;

/// A state machine that detects the \#ifndef-wrapping a file
  /// idiom for the multiple-include optimization.
  MultipleIncludeOpt MIOpt;

/// Information about the set of \#if/\#ifdef/\#ifndef blocks
  /// we are currently in.
  SmallVector<PPConditionalInfo, 4> ConditionalStack;

PreprocessorLexer() : FID() {}
  PreprocessorLexer(Preprocessor *pp, FileID fid);
  virtual ~PreprocessorLexer() = default;

virtual void IndirectLex(Token& Result) = 0;

/// Return the source location for the next observable location.
  virtual SourceLocation getSourceLocation() = 0;

//===--------------------------------------------------------------------===//
  // #if directive handling.

/// pushConditionalLevel - When we enter a \#if directive, this keeps track of
  /// what we are currently in for diagnostic emission (e.g. \#if with missing
  /// \#endif).
  void pushConditionalLevel(SourceLocation DirectiveStart, bool WasSkipping,
                            bool FoundNonSkip, bool FoundElse) {
    PPConditionalInfo CI;
    CI.IfLoc = DirectiveStart;
    CI.WasSkipping = WasSkipping;
    CI.FoundNonSkip = FoundNonSkip;
    CI.FoundElse = FoundElse;
    ConditionalStack.push_back(CI);
  }
  void pushConditionalLevel(const PPConditionalInfo &CI) {
    ConditionalStack.push_back(CI);
  }

/// popConditionalLevel - Remove an entry off the top of the conditional
  /// stack, returning information about it.  If the conditional stack is empty,
  /// this returns true and does not fill in the arguments.
  bool popConditionalLevel(PPConditionalInfo &CI) {
    if (ConditionalStack.empty())
      return true;
    CI = ConditionalStack.pop_back_val();
    return false;
  }

/// Return the top of the conditional stack.
  /// \pre This requires that there be a conditional active.
  PPConditionalInfo &peekConditionalLevel() {
    assert(!ConditionalStack.empty() && "No conditionals active!");
    return ConditionalStack.back();
  }

unsigned getConditionalStackDepth() const { return ConditionalStack.size(); }

public:
  PreprocessorLexer(const PreprocessorLexer &) = delete;
  PreprocessorLexer &operator=(const PreprocessorLexer &) = delete;

//===--------------------------------------------------------------------===//
  // Misc. lexing methods.

/// Lex a token, producing a header-name token if possible.
  void LexIncludeFilename(Token &FilenameTok);

/// Inform the lexer whether or not we are currently lexing a
  /// preprocessor directive.
  void setParsingPreprocessorDirective(bool f) {
    ParsingPreprocessorDirective = f;
  }

/// Return true if this lexer is in raw mode or not.
  bool isLexingRawMode() const { return LexingRawMode; }

/// Return the preprocessor object for this lexer.
  Preprocessor *getPP() const { return PP; }

FileID getFileID() const {
    assert(PP &&
      "PreprocessorLexer::getFileID() should only be used with a Preprocessor");
    return FID;
  }

/// Number of SLocEntries before lexing the file.
  unsigned getInitialNumSLocEntries() const {
    return InitialNumSLocEntries;
  }

/// getFileEntry - Return the FileEntry corresponding to this FileID.  Like
  /// getFileID(), this only works for lexers with attached preprocessors.
  const FileEntry *getFileEntry() const;

/// Iterator that traverses the current stack of preprocessor
  /// conditional directives (\#if/\#ifdef/\#ifndef).
  using conditional_iterator =
      SmallVectorImpl<PPConditionalInfo>::const_iterator;

conditional_iterator conditional_begin() const {
    return ConditionalStack.begin();
  }

conditional_iterator conditional_end() const {
    return ConditionalStack.end();
  }

void setConditionalLevels(ArrayRef<PPConditionalInfo> CL) {
    ConditionalStack.clear();
    ConditionalStack.append(CL.begin(), CL.end());
  }
};

} // namespace clang

#endif // LLVM_CLANG_LEX_PREPROCESSORLEXER_H

003 File Manager

Editing: PreprocessorLexer.h

Upload File

Create Folder