Home | History | Annotate | Line # | Download | only in Lex 
      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