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: Pragma.h

//===- Pragma.h - Pragma registration and handling --------------*- 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
//
//===----------------------------------------------------------------------===//
//
// This file defines the PragmaHandler and PragmaTable interfaces.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_LEX_PRAGMA_H
#define LLVM_CLANG_LEX_PRAGMA_H

#include "clang/Basic/LLVM.h"
#include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include <string>

namespace clang {

class PragmaNamespace;
class Preprocessor;
class Token;

/**
   * Describes how the pragma was introduced, e.g., with \#pragma,
   * _Pragma, or __pragma.
   */
  enum PragmaIntroducerKind {
    /**
     * The pragma was introduced via \#pragma.
     */
    PIK_HashPragma,

/**
     * The pragma was introduced via the C99 _Pragma(string-literal).
     */
    PIK__Pragma,

/**
     * The pragma was introduced via the Microsoft
     * __pragma(token-string).
     */
    PIK___pragma
  };

/// Describes how and where the pragma was introduced.
  struct PragmaIntroducer {
    PragmaIntroducerKind Kind;
    SourceLocation Loc;
  };

/// PragmaHandler - Instances of this interface defined to handle the various
/// pragmas that the language front-end uses.  Each handler optionally has a
/// name (e.g. "pack") and the HandlePragma method is invoked when a pragma with
/// that identifier is found.  If a handler does not match any of the declared
/// pragmas the handler with a null identifier is invoked, if it exists.
///
/// Note that the PragmaNamespace class can be used to subdivide pragmas, e.g.
/// we treat "\#pragma STDC" and "\#pragma GCC" as namespaces that contain other
/// pragmas.
class PragmaHandler {
  std::string Name;

public:
  PragmaHandler() = default;
  explicit PragmaHandler(StringRef name) : Name(name) {}
  virtual ~PragmaHandler();

StringRef getName() const { return Name; }
  virtual void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                            Token &FirstToken) = 0;

/// getIfNamespace - If this is a namespace, return it.  This is equivalent to
  /// using a dynamic_cast, but doesn't require RTTI.
  virtual PragmaNamespace *getIfNamespace() { return nullptr; }
};

/// EmptyPragmaHandler - A pragma handler which takes no action, which can be
/// used to ignore particular pragmas.
class EmptyPragmaHandler : public PragmaHandler {
public:
  explicit EmptyPragmaHandler(StringRef Name = StringRef());

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                    Token &FirstToken) override;
};

/// PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas,
/// allowing hierarchical pragmas to be defined.  Common examples of namespaces
/// are "\#pragma GCC", "\#pragma STDC", and "\#pragma omp", but any namespaces
/// may be (potentially recursively) defined.
class PragmaNamespace : public PragmaHandler {
  /// Handlers - This is a map of the handlers in this namespace with their name
  /// as key.
  llvm::StringMap<std::unique_ptr<PragmaHandler>> Handlers;

public:
  explicit PragmaNamespace(StringRef Name) : PragmaHandler(Name) {}

/// FindHandler - Check to see if there is already a handler for the
  /// specified name.  If not, return the handler for the null name if it
  /// exists, otherwise return null.  If IgnoreNull is true (the default) then
  /// the null handler isn't returned on failure to match.
  PragmaHandler *FindHandler(StringRef Name,
                             bool IgnoreNull = true) const;

/// AddPragma - Add a pragma to this namespace.
  void AddPragma(PragmaHandler *Handler);

/// RemovePragmaHandler - Remove the given handler from the
  /// namespace.
  void RemovePragmaHandler(PragmaHandler *Handler);

bool IsEmpty() const { return Handlers.empty(); }

void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
                    Token &Tok) override;

PragmaNamespace *getIfNamespace() override { return this; }
};

} // namespace clang

#endif // LLVM_CLANG_LEX_PRAGMA_H

003 File Manager

Editing: Pragma.h

Upload File

Create Folder