contrib/llvm/tools/lldb/source/Core/UUID.cpp

   1 //===-- UUID.cpp ------------------------------------------------*- 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 #include "lldb/Core/UUID.h"
  11 // C Includes
  12 #include <string.h>
  13 #include <stdio.h>
  14 #include <ctype.h>
  15
  16 // C++ Includes
  17 #include <string>
  18
  19 // Other libraries and framework includes
  20 // Project includes
  21 #include "lldb/Core/Stream.h"
  22
  23 namespace lldb_private {
  24
  25 UUID::UUID() : m_num_uuid_bytes(16)
  26 {
  27     ::memset (m_uuid, 0, sizeof(m_uuid));
  28 }
  29
  30 UUID::UUID(const UUID& rhs)
  31 {
  32     m_num_uuid_bytes = rhs.m_num_uuid_bytes;
  33     ::memcpy (m_uuid, rhs.m_uuid, sizeof (m_uuid));
  34 }
  35
  36 UUID::UUID (const void *uuid_bytes, uint32_t num_uuid_bytes)
  37 {
  38     SetBytes (uuid_bytes, num_uuid_bytes);
  39 }
  40
  41 const UUID&
  42 UUID::operator=(const UUID& rhs)
  43 {
  44     if (this != &rhs)
  45     {
  46         m_num_uuid_bytes = rhs.m_num_uuid_bytes;
  47         ::memcpy (m_uuid, rhs.m_uuid, sizeof (m_uuid));
  48     }
  49     return *this;
  50 }
  51
  52 UUID::~UUID()
  53 {
  54 }
  55
  56 void
  57 UUID::Clear()
  58 {
  59     m_num_uuid_bytes = 16;
  60     ::memset (m_uuid, 0, sizeof(m_uuid));
  61 }
  62
  63 const void *
  64 UUID::GetBytes() const
  65 {
  66     return m_uuid;
  67 }
  68
  69 std::string
  70 UUID::GetAsString (const char *separator) const
  71 {
  72     std::string result;
  73     char buf[256];
  74     if (!separator)
  75         separator = "-";
  76     const uint8_t *u = (const uint8_t *)GetBytes();
  77     if (sizeof (buf) > (size_t)snprintf (buf,
  78                             sizeof (buf),
  79                             "%2.2X%2.2X%2.2X%2.2X%s%2.2X%2.2X%s%2.2X%2.2X%s%2.2X%2.2X%s%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
  80                             u[0],u[1],u[2],u[3],separator,
  81                             u[4],u[5],separator,
  82                             u[6],u[7],separator,
  83                             u[8],u[9],separator,
  84                             u[10],u[11],u[12],u[13],u[14],u[15]))
  85     {
  86         result.append (buf);
  87         if (m_num_uuid_bytes == 20)
  88         {
  89             if (sizeof (buf) > (size_t)snprintf (buf, sizeof (buf), "%s%2.2X%2.2X%2.2X%2.2X", separator,u[16],u[17],u[18],u[19]))
  90                 result.append (buf);
  91         }
  92     }
  93     return result;
  94 }
  95
  96 void
  97 UUID::Dump (Stream *s) const
  98 {
  99     const uint8_t *u = (const uint8_t *)GetBytes();
 100     s->Printf ("%2.2X%2.2X%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X-%2.2X%2.2X%2.2X%2.2X%2.2X%2.2X",
 101               u[0],u[1],u[2],u[3],u[4],u[5],u[6],u[7],u[8],u[9],u[10],u[11],u[12],u[13],u[14],u[15]);
 102     if (m_num_uuid_bytes == 20)
 103     {
 104         s->Printf ("-%2.2X%2.2X%2.2X%2.2X", u[16],u[17],u[18],u[19]);
 105     }
 106 }
 107
 108 bool
 109 UUID::SetBytes (const void *uuid_bytes, uint32_t num_uuid_bytes)
 110 {
 111     if (uuid_bytes)
 112     {
 113         switch (num_uuid_bytes)
 114         {
 115             case 20:
 116                 m_num_uuid_bytes = 20;
 117                 break;
 118             case 16:
 119                 m_num_uuid_bytes = 16;
 120                 m_uuid[16] = m_uuid[17] = m_uuid[18] = m_uuid[19] = 0;
 121                 break;
 122             default:
 123                 // Unsupported UUID byte size
 124                 m_num_uuid_bytes = 0;
 125                 break;
 126         }
 127
 128         if (m_num_uuid_bytes > 0)
 129         {
 130             ::memcpy (m_uuid, uuid_bytes, m_num_uuid_bytes);
 131             return true;
 132         }
 133     }
 134     ::memset (m_uuid, 0, sizeof(m_uuid));
 135     return false;
 136 }
 137
 138 size_t
 139 UUID::GetByteSize()
 140 {
 141     return m_num_uuid_bytes;
 142 }
 143
 144 bool
 145 UUID::IsValid () const
 146 {
 147     return  m_uuid[0]  ||
 148             m_uuid[1]  ||
 149             m_uuid[2]  ||
 150             m_uuid[3]  ||
 151             m_uuid[4]  ||
 152             m_uuid[5]  ||
 153             m_uuid[6]  ||
 154             m_uuid[7]  ||
 155             m_uuid[8]  ||
 156             m_uuid[9]  ||
 157             m_uuid[10] ||
 158             m_uuid[11] ||
 159             m_uuid[12] ||
 160             m_uuid[13] ||
 161             m_uuid[14] ||
 162             m_uuid[15] ||
 163             m_uuid[16] ||
 164             m_uuid[17] ||
 165             m_uuid[18] ||
 166             m_uuid[19];
 167 }
 168
 169 static inline int
 170 xdigit_to_int (char ch)
 171 {
 172     ch = tolower(ch);
 173     if (ch >= 'a' && ch <= 'f')
 174         return 10 + ch - 'a';
 175     return ch - '0';
 176 }
 177
 178 size_t
 179 UUID::DecodeUUIDBytesFromCString (const char *p, ValueType &uuid_bytes, const char **end, uint32_t num_uuid_bytes)
 180 {
 181     size_t uuid_byte_idx = 0;
 182     if (p)
 183     {
 184         while (*p)
 185         {
 186             if (isxdigit(p[0]) && isxdigit(p[1]))
 187             {
 188                 int hi_nibble = xdigit_to_int(p[0]);
 189                 int lo_nibble = xdigit_to_int(p[1]);
 190                 // Translate the two hex nibble characters into a byte
 191                 uuid_bytes[uuid_byte_idx] = (hi_nibble << 4) + lo_nibble;
 192
 193                 // Skip both hex digits
 194                 p += 2;
 195
 196                 // Increment the byte that we are decoding within the UUID value
 197                 // and break out if we are done
 198                 if (++uuid_byte_idx == num_uuid_bytes)
 199                     break;
 200             }
 201             else if (*p == '-')
 202             {
 203                 // Skip dashes
 204                 p++;
 205             }
 206             else
 207             {
 208                 // UUID values can only consist of hex characters and '-' chars
 209                 break;
 210             }
 211         }
 212     }
 213     if (end)
 214         *end = p;
 215     // Clear trailing bytes to 0.
 216     for (uint32_t i = uuid_byte_idx; i < sizeof(ValueType); i++)
 217         uuid_bytes[i] = 0;
 218     return uuid_byte_idx;
 219 }
 220 size_t
 221 UUID::SetFromCString (const char *cstr, uint32_t num_uuid_bytes)
 222 {
 223     if (cstr == NULL)
 224         return 0;
 225
 226     const char *p = cstr;
 227
 228     // Skip leading whitespace characters
 229     while (isspace(*p))
 230         ++p;
 231
 232     const size_t uuid_byte_idx = UUID::DecodeUUIDBytesFromCString (p, m_uuid, &p, num_uuid_bytes);
 233
 234     // If we successfully decoded a UUID, return the amount of characters that
 235     // were consumed
 236     if (uuid_byte_idx == num_uuid_bytes)
 237         return p - cstr;
 238
 239     // Else return zero to indicate we were not able to parse a UUID value
 240     return 0;
 241 }
 242
 243 }
 244
 245 bool
 246 lldb_private::operator == (const lldb_private::UUID &lhs, const lldb_private::UUID &rhs)
 247 {
 248     return ::memcmp (lhs.GetBytes(), rhs.GetBytes(), sizeof (lldb_private::UUID::ValueType)) == 0;
 249 }
 250
 251 bool
 252 lldb_private::operator != (const lldb_private::UUID &lhs, const lldb_private::UUID &rhs)
 253 {
 254     return ::memcmp (lhs.GetBytes(), rhs.GetBytes(), sizeof (lldb_private::UUID::ValueType)) != 0;
 255 }
 256
 257 bool
 258 lldb_private::operator <  (const lldb_private::UUID &lhs, const lldb_private::UUID &rhs)
 259 {
 260     return ::memcmp (lhs.GetBytes(), rhs.GetBytes(), sizeof (lldb_private::UUID::ValueType)) <  0;
 261 }
 262
 263 bool
 264 lldb_private::operator <= (const lldb_private::UUID &lhs, const lldb_private::UUID &rhs)
 265 {
 266     return ::memcmp (lhs.GetBytes(), rhs.GetBytes(), sizeof (lldb_private::UUID::ValueType)) <= 0;
 267 }
 268
 269 bool
 270 lldb_private::operator >  (const lldb_private::UUID &lhs, const lldb_private::UUID &rhs)
 271 {
 272     return ::memcmp (lhs.GetBytes(), rhs.GetBytes(), sizeof (lldb_private::UUID::ValueType)) >  0;
 273 }
 274
 275 bool
 276 lldb_private::operator >= (const lldb_private::UUID &lhs, const lldb_private::UUID &rhs)
 277 {
 278     return ::memcmp (lhs.GetBytes(), rhs.GetBytes(), sizeof (lldb_private::UUID::ValueType)) >= 0;
 279 }