contrib/llvm/tools/lldb/include/lldb/Breakpoint/BreakpointName.h

   1 //===-- BreakpointName.h --------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef liblldb_Breakpoint_Name_h_
  11 #define liblldb_Breakpoint_Name_h_
  12
  13 // C Includes
  14 // C++ Includes
  15 #include <memory>
  16 #include <string>
  17 #include <unordered_set>
  18 #include <vector>
  19
  20 // Other libraries and framework includes
  21 // Project includes
  22 #include "lldb/Breakpoint/BreakpointID.h"
  23 #include "lldb/Breakpoint/BreakpointLocationCollection.h"
  24 #include "lldb/Breakpoint/BreakpointLocationList.h"
  25 #include "lldb/Breakpoint/BreakpointOptions.h"
  26 #include "lldb/Breakpoint/Stoppoint.h"
  27 #include "lldb/Core/Event.h"
  28 #include "lldb/Core/SearchFilter.h"
  29 #include "lldb/Utility/Flags.h"
  30 #include "lldb/Utility/StringList.h"
  31 #include "lldb/Utility/StructuredData.h"
  32
  33 namespace lldb_private {
  34
  35 class BreakpointName {
  36 public:
  37   class Permissions
  38   {
  39   public:
  40
  41     enum PermissionKinds { listPerm = 0, disablePerm = 1,
  42                        deletePerm = 2, allPerms = 3 };
  43
  44     Permissions(bool in_list, bool in_disable, bool in_delete)
  45     {
  46       m_permissions[listPerm]    = in_list;
  47       m_permissions[disablePerm] = in_disable;
  48       m_permissions[deletePerm]  = in_delete;
  49       m_set_mask.Set(permissions_mask[allPerms]);
  50     }
  51
  52     Permissions(const Permissions &rhs)
  53     {
  54       m_permissions[listPerm]    = rhs.m_permissions[listPerm];
  55       m_permissions[disablePerm] = rhs.m_permissions[disablePerm];
  56       m_permissions[deletePerm]  = rhs.m_permissions[deletePerm];
  57       m_set_mask = rhs.m_set_mask;
  58     }
  59
  60     Permissions()
  61     {
  62       m_permissions[listPerm]    = true;
  63       m_permissions[disablePerm] = true;
  64       m_permissions[deletePerm]  = true;
  65       m_set_mask.Clear();
  66     }
  67
  68     const Permissions &operator= (const Permissions &rhs)
  69     {
  70       if (this != &rhs) {
  71         m_permissions[listPerm]    = rhs.m_permissions[listPerm];
  72         m_permissions[disablePerm] = rhs.m_permissions[disablePerm];
  73         m_permissions[deletePerm]  = rhs.m_permissions[deletePerm];
  74         m_set_mask = rhs.m_set_mask;
  75       }
  76       return *this;
  77     }
  78
  79     void Clear() {
  80       *this = Permissions();
  81     }
  82
  83     // Merge the permissions from incoming into this set of permissions. Only
  84     // merge set permissions, and most restrictive permission wins.
  85     void MergeInto(const Permissions &incoming)
  86     {
  87       MergePermission(incoming, listPerm);
  88       MergePermission(incoming, disablePerm);
  89       MergePermission(incoming, deletePerm);
  90     }
  91
  92     bool GetAllowList() const { return GetPermission(listPerm); }
  93     bool SetAllowList(bool value) { return SetPermission(listPerm, value); }
  94
  95     bool GetAllowDelete() const { return GetPermission(deletePerm); }
  96     bool SetAllowDelete(bool value) { return SetPermission(deletePerm, value); }
  97
  98     bool GetAllowDisable() const { return GetPermission(disablePerm); }
  99     bool SetAllowDisable(bool value) { return SetPermission(disablePerm,
 100                                                             value); }
 101
 102     bool GetPermission(enum PermissionKinds permission) const
 103     {
 104       return m_permissions[permission];
 105     }
 106
 107     bool GetDescription(Stream *s, lldb::DescriptionLevel level);
 108
 109     bool IsSet(enum PermissionKinds permission) const
 110     {
 111       return m_set_mask.Test(permissions_mask[permission]);
 112     }
 113
 114     bool AnySet() {
 115       return m_set_mask.AnySet(permissions_mask[allPerms]);
 116     }
 117
 118   private:
 119     static const Flags::ValueType permissions_mask[allPerms + 1];
 120
 121     bool m_permissions[allPerms];
 122     Flags m_set_mask;
 123
 124     bool SetPermission(enum PermissionKinds permission, bool value)
 125     {
 126       bool old_value = m_permissions[permission];
 127       m_permissions[permission] = value;
 128       m_set_mask.Set(permissions_mask[permission]);
 129       return old_value;
 130     }
 131
 132     // If either side disallows the permission, the resultant disallows it.
 133     void MergePermission(const Permissions &incoming,
 134                          enum PermissionKinds permission)
 135     {
 136       if (incoming.IsSet(permission))
 137       {
 138         SetPermission(permission, !(m_permissions[permission] |
 139             incoming.m_permissions[permission]));
 140       }
 141     }
 142   };
 143
 144   BreakpointName(const ConstString &name, const char *help = nullptr) :
 145       m_name(name), m_options(false)
 146    {
 147      SetHelp(help);
 148    }
 149
 150   BreakpointName(const ConstString &name,
 151                  BreakpointOptions &options,
 152                  const Permissions &permissions = Permissions(),
 153                  const char *help = nullptr) :
 154       m_name(name), m_options(options),
 155       m_permissions(permissions) {
 156         SetHelp(help);
 157   };
 158
 159   BreakpointName(const BreakpointName &rhs) :
 160       m_name(rhs.m_name), m_options(rhs.m_options),
 161       m_permissions(rhs.m_permissions), m_help(rhs.m_help)
 162   {}
 163
 164   BreakpointName(const ConstString &name, const Breakpoint &bkpt,
 165                  const char *help);
 166
 167   const ConstString &GetName() const { return m_name; }
 168   BreakpointOptions &GetOptions() { return m_options; }
 169   const BreakpointOptions &GetOptions() const { return m_options; }
 170
 171   void SetOptions(const BreakpointOptions &options) {
 172     m_options = options;
 173   }
 174
 175   Permissions &GetPermissions() { return m_permissions; }
 176   const Permissions &GetPermissions() const { return m_permissions; }
 177   void SetPermissions(const Permissions &permissions) {
 178     m_permissions = permissions;
 179   }
 180
 181   bool GetPermission(Permissions::PermissionKinds permission) const
 182   {
 183     return m_permissions.GetPermission(permission);
 184   }
 185
 186   void SetHelp(const char *description)
 187   {
 188     if (description)
 189       m_help.assign(description);
 190     else
 191       m_help.clear();
 192   }
 193
 194   const char *GetHelp()
 195   {
 196     return m_help.c_str();
 197   }
 198
 199   // Returns true if any options were set in the name
 200   bool GetDescription(Stream *s, lldb::DescriptionLevel level);
 201
 202   void ConfigureBreakpoint(lldb::BreakpointSP bp_sp);
 203
 204 private:
 205   ConstString        m_name;
 206   BreakpointOptions  m_options;
 207   Permissions        m_permissions;
 208   std::string        m_help;
 209 };
 210
 211 } // namespace lldb_private
 212
 213 #endif // liblldb_Breakpoint_Name_h_