Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===- Pragma.h - Pragma registration and handling --------------*- 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. // This file defines the PragmaHandler and PragmaTable interfaces.
  10. //
  11. //===----------------------------------------------------------------------===//
  12.  
  13. #ifndef LLVM_CLANG_LEX_PRAGMA_H
  14. #define LLVM_CLANG_LEX_PRAGMA_H
  15.  
  16. #include "clang/Basic/LLVM.h"
  17. #include "clang/Basic/SourceLocation.h"
  18. #include "llvm/ADT/StringMap.h"
  19. #include "llvm/ADT/StringRef.h"
  20. #include <string>
  21.  
  22. namespace clang {
  23.  
  24. class PragmaNamespace;
  25. class Preprocessor;
  26. class Token;
  27.  
  28.   /**
  29.    * Describes how the pragma was introduced, e.g., with \#pragma,
  30.    * _Pragma, or __pragma.
  31.    */
  32.   enum PragmaIntroducerKind {
  33.     /**
  34.      * The pragma was introduced via \#pragma.
  35.      */
  36.     PIK_HashPragma,
  37.  
  38.     /**
  39.      * The pragma was introduced via the C99 _Pragma(string-literal).
  40.      */
  41.     PIK__Pragma,
  42.  
  43.     /**
  44.      * The pragma was introduced via the Microsoft
  45.      * __pragma(token-string).
  46.      */
  47.     PIK___pragma
  48.   };
  49.  
  50.   /// Describes how and where the pragma was introduced.
  51.   struct PragmaIntroducer {
  52.     PragmaIntroducerKind Kind;
  53.     SourceLocation Loc;
  54.   };
  55.  
  56. /// PragmaHandler - Instances of this interface defined to handle the various
  57. /// pragmas that the language front-end uses.  Each handler optionally has a
  58. /// name (e.g. "pack") and the HandlePragma method is invoked when a pragma with
  59. /// that identifier is found.  If a handler does not match any of the declared
  60. /// pragmas the handler with a null identifier is invoked, if it exists.
  61. ///
  62. /// Note that the PragmaNamespace class can be used to subdivide pragmas, e.g.
  63. /// we treat "\#pragma STDC" and "\#pragma GCC" as namespaces that contain other
  64. /// pragmas.
  65. class PragmaHandler {
  66.   std::string Name;
  67.  
  68. public:
  69.   PragmaHandler() = default;
  70.   explicit PragmaHandler(StringRef name) : Name(name) {}
  71.   virtual ~PragmaHandler();
  72.  
  73.   StringRef getName() const { return Name; }
  74.   virtual void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
  75.                             Token &FirstToken) = 0;
  76.  
  77.   /// getIfNamespace - If this is a namespace, return it.  This is equivalent to
  78.   /// using a dynamic_cast, but doesn't require RTTI.
  79.   virtual PragmaNamespace *getIfNamespace() { return nullptr; }
  80. };
  81.  
  82. /// EmptyPragmaHandler - A pragma handler which takes no action, which can be
  83. /// used to ignore particular pragmas.
  84. class EmptyPragmaHandler : public PragmaHandler {
  85. public:
  86.   explicit EmptyPragmaHandler(StringRef Name = StringRef());
  87.  
  88.   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
  89.                     Token &FirstToken) override;
  90. };
  91.  
  92. /// PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas,
  93. /// allowing hierarchical pragmas to be defined.  Common examples of namespaces
  94. /// are "\#pragma GCC", "\#pragma STDC", and "\#pragma omp", but any namespaces
  95. /// may be (potentially recursively) defined.
  96. class PragmaNamespace : public PragmaHandler {
  97.   /// Handlers - This is a map of the handlers in this namespace with their name
  98.   /// as key.
  99.   llvm::StringMap<std::unique_ptr<PragmaHandler>> Handlers;
  100.  
  101. public:
  102.   explicit PragmaNamespace(StringRef Name) : PragmaHandler(Name) {}
  103.  
  104.   /// FindHandler - Check to see if there is already a handler for the
  105.   /// specified name.  If not, return the handler for the null name if it
  106.   /// exists, otherwise return null.  If IgnoreNull is true (the default) then
  107.   /// the null handler isn't returned on failure to match.
  108.   PragmaHandler *FindHandler(StringRef Name,
  109.                              bool IgnoreNull = true) const;
  110.  
  111.   /// AddPragma - Add a pragma to this namespace.
  112.   void AddPragma(PragmaHandler *Handler);
  113.  
  114.   /// RemovePragmaHandler - Remove the given handler from the
  115.   /// namespace.
  116.   void RemovePragmaHandler(PragmaHandler *Handler);
  117.  
  118.   bool IsEmpty() const { return Handlers.empty(); }
  119.  
  120.   void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
  121.                     Token &Tok) override;
  122.  
  123.   PragmaNamespace *getIfNamespace() override { return this; }
  124. };
  125.  
  126. } // namespace clang
  127.  
  128. #endif // LLVM_CLANG_LEX_PRAGMA_H
  129.