Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

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

  1. //===- DiagnosticOptions.h --------------------------------------*- 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. #ifndef LLVM_CLANG_BASIC_DIAGNOSTICOPTIONS_H
  10. #define LLVM_CLANG_BASIC_DIAGNOSTICOPTIONS_H
  11.  
  12. #include "clang/Basic/LLVM.h"
  13. #include "llvm/ADT/IntrusiveRefCntPtr.h"
  14. #include <string>
  15. #include <type_traits>
  16. #include <vector>
  17.  
  18. namespace llvm {
  19. namespace opt {
  20. class ArgList;
  21. } // namespace opt
  22. } // namespace llvm
  23.  
  24. namespace clang {
  25. class DiagnosticsEngine;
  26.  
  27. /// Specifies which overload candidates to display when overload
  28. /// resolution fails.
  29. enum OverloadsShown : unsigned {
  30.   /// Show all overloads.
  31.   Ovl_All,
  32.  
  33.   /// Show just the "best" overload candidates.
  34.   Ovl_Best
  35. };
  36.  
  37. /// A bitmask representing the diagnostic levels used by
  38. /// VerifyDiagnosticConsumer.
  39. enum class DiagnosticLevelMask : unsigned {
  40.   None    = 0,
  41.   Note    = 1 << 0,
  42.   Remark  = 1 << 1,
  43.   Warning = 1 << 2,
  44.   Error   = 1 << 3,
  45.   All     = Note | Remark | Warning | Error
  46. };
  47.  
  48. inline DiagnosticLevelMask operator~(DiagnosticLevelMask M) {
  49.   using UT = std::underlying_type_t<DiagnosticLevelMask>;
  50.   return static_cast<DiagnosticLevelMask>(~static_cast<UT>(M));
  51. }
  52.  
  53. inline DiagnosticLevelMask operator|(DiagnosticLevelMask LHS,
  54.                                      DiagnosticLevelMask RHS) {
  55.   using UT = std::underlying_type_t<DiagnosticLevelMask>;
  56.   return static_cast<DiagnosticLevelMask>(
  57.     static_cast<UT>(LHS) | static_cast<UT>(RHS));
  58. }
  59.  
  60. inline DiagnosticLevelMask operator&(DiagnosticLevelMask LHS,
  61.                                      DiagnosticLevelMask RHS) {
  62.   using UT = std::underlying_type_t<DiagnosticLevelMask>;
  63.   return static_cast<DiagnosticLevelMask>(
  64.     static_cast<UT>(LHS) & static_cast<UT>(RHS));
  65. }
  66.  
  67. raw_ostream& operator<<(raw_ostream& Out, DiagnosticLevelMask M);
  68.  
  69. /// Options for controlling the compiler diagnostics engine.
  70. class DiagnosticOptions : public RefCountedBase<DiagnosticOptions>{
  71.   friend bool ParseDiagnosticArgs(DiagnosticOptions &, llvm::opt::ArgList &,
  72.                                   clang::DiagnosticsEngine *, bool);
  73.  
  74.   friend class CompilerInvocation;
  75.  
  76. public:
  77.   enum TextDiagnosticFormat { Clang, MSVC, Vi, SARIF };
  78.  
  79.   // Default values.
  80.   enum {
  81.     DefaultTabStop = 8,
  82.     MaxTabStop = 100,
  83.     DefaultMacroBacktraceLimit = 6,
  84.     DefaultTemplateBacktraceLimit = 10,
  85.     DefaultConstexprBacktraceLimit = 10,
  86.     DefaultSpellCheckingLimit = 50,
  87.     DefaultSnippetLineLimit = 1,
  88.   };
  89.  
  90.   // Define simple diagnostic options (with no accessors).
  91. #define DIAGOPT(Name, Bits, Default) unsigned Name : Bits;
  92. #define ENUM_DIAGOPT(Name, Type, Bits, Default)
  93. #include "clang/Basic/DiagnosticOptions.def"
  94.  
  95. protected:
  96.   // Define diagnostic options of enumeration type. These are private, and will
  97.   // have accessors (below).
  98. #define DIAGOPT(Name, Bits, Default)
  99. #define ENUM_DIAGOPT(Name, Type, Bits, Default) unsigned Name : Bits;
  100. #include "clang/Basic/DiagnosticOptions.def"
  101.  
  102. public:
  103.   /// The file to log diagnostic output to.
  104.   std::string DiagnosticLogFile;
  105.  
  106.   /// The file to serialize diagnostics to (non-appending).
  107.   std::string DiagnosticSerializationFile;
  108.  
  109.   /// The list of -W... options used to alter the diagnostic mappings, with the
  110.   /// prefixes removed.
  111.   std::vector<std::string> Warnings;
  112.  
  113.   /// The list of prefixes from -Wundef-prefix=... used to generate warnings
  114.   /// for undefined macros.
  115.   std::vector<std::string> UndefPrefixes;
  116.  
  117.   /// The list of -R... options used to alter the diagnostic mappings, with the
  118.   /// prefixes removed.
  119.   std::vector<std::string> Remarks;
  120.  
  121.   /// The prefixes for comment directives sought by -verify ("expected" by
  122.   /// default).
  123.   std::vector<std::string> VerifyPrefixes;
  124.  
  125. public:
  126.   // Define accessors/mutators for diagnostic options of enumeration type.
  127. #define DIAGOPT(Name, Bits, Default)
  128. #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
  129.   Type get##Name() const { return static_cast<Type>(Name); } \
  130.   void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
  131. #include "clang/Basic/DiagnosticOptions.def"
  132.  
  133.   DiagnosticOptions() {
  134. #define DIAGOPT(Name, Bits, Default) Name = Default;
  135. #define ENUM_DIAGOPT(Name, Type, Bits, Default) set##Name(Default);
  136. #include "clang/Basic/DiagnosticOptions.def"
  137.   }
  138. };
  139.  
  140. using TextDiagnosticFormat = DiagnosticOptions::TextDiagnosticFormat;
  141.  
  142. } // namespace clang
  143.  
  144. #endif // LLVM_CLANG_BASIC_DIAGNOSTICOPTIONS_H
  145.