contrib/llvm/tools/lldb/source/Host/common/XML.cpp

   1 //===-- XML.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 <stdlib.h> /* atof */
  11
  12 #include "lldb/Host/StringConvert.h"
  13 #include "lldb/Host/XML.h"
  14
  15 using namespace lldb;
  16 using namespace lldb_private;
  17
  18 #pragma mark-- XMLDocument
  19
  20 XMLDocument::XMLDocument() : m_document(nullptr) {}
  21
  22 XMLDocument::~XMLDocument() { Clear(); }
  23
  24 void XMLDocument::Clear() {
  25 #if defined(LIBXML2_DEFINED)
  26   if (m_document) {
  27     xmlDocPtr doc = m_document;
  28     m_document = nullptr;
  29     xmlFreeDoc(doc);
  30   }
  31 #endif
  32 }
  33
  34 bool XMLDocument::IsValid() const { return m_document != nullptr; }
  35
  36 void XMLDocument::ErrorCallback(void *ctx, const char *format, ...) {
  37   XMLDocument *document = (XMLDocument *)ctx;
  38   va_list args;
  39   va_start(args, format);
  40   document->m_errors.PrintfVarArg(format, args);
  41   document->m_errors.EOL();
  42   va_end(args);
  43 }
  44
  45 bool XMLDocument::ParseFile(const char *path) {
  46 #if defined(LIBXML2_DEFINED)
  47   Clear();
  48   xmlSetGenericErrorFunc((void *)this, XMLDocument::ErrorCallback);
  49   m_document = xmlParseFile(path);
  50   xmlSetGenericErrorFunc(nullptr, nullptr);
  51 #endif
  52   return IsValid();
  53 }
  54
  55 bool XMLDocument::ParseMemory(const char *xml, size_t xml_length,
  56                               const char *url) {
  57 #if defined(LIBXML2_DEFINED)
  58   Clear();
  59   xmlSetGenericErrorFunc((void *)this, XMLDocument::ErrorCallback);
  60   m_document = xmlReadMemory(xml, (int)xml_length, url, nullptr, 0);
  61   xmlSetGenericErrorFunc(nullptr, nullptr);
  62 #endif
  63   return IsValid();
  64 }
  65
  66 XMLNode XMLDocument::GetRootElement(const char *required_name) {
  67 #if defined(LIBXML2_DEFINED)
  68   if (IsValid()) {
  69     XMLNode root_node(xmlDocGetRootElement(m_document));
  70     if (required_name) {
  71       llvm::StringRef actual_name = root_node.GetName();
  72       if (actual_name == required_name)
  73         return root_node;
  74     } else {
  75       return root_node;
  76     }
  77   }
  78 #endif
  79   return XMLNode();
  80 }
  81
  82 llvm::StringRef XMLDocument::GetErrors() const { return m_errors.GetString(); }
  83
  84 bool XMLDocument::XMLEnabled() {
  85 #if defined(LIBXML2_DEFINED)
  86   return true;
  87 #else
  88   return false;
  89 #endif
  90 }
  91
  92 #pragma mark-- XMLNode
  93
  94 XMLNode::XMLNode() : m_node(nullptr) {}
  95
  96 XMLNode::XMLNode(XMLNodeImpl node) : m_node(node) {}
  97
  98 XMLNode::~XMLNode() {}
  99
 100 void XMLNode::Clear() { m_node = nullptr; }
 101
 102 XMLNode XMLNode::GetParent() const {
 103 #if defined(LIBXML2_DEFINED)
 104   if (IsValid())
 105     return XMLNode(m_node->parent);
 106   else
 107     return XMLNode();
 108 #else
 109   return XMLNode();
 110 #endif
 111 }
 112
 113 XMLNode XMLNode::GetSibling() const {
 114 #if defined(LIBXML2_DEFINED)
 115   if (IsValid())
 116     return XMLNode(m_node->next);
 117   else
 118     return XMLNode();
 119 #else
 120   return XMLNode();
 121 #endif
 122 }
 123
 124 XMLNode XMLNode::GetChild() const {
 125 #if defined(LIBXML2_DEFINED)
 126
 127   if (IsValid())
 128     return XMLNode(m_node->children);
 129   else
 130     return XMLNode();
 131 #else
 132   return XMLNode();
 133 #endif
 134 }
 135
 136 llvm::StringRef XMLNode::GetAttributeValue(const char *name,
 137                                            const char *fail_value) const {
 138   const char *attr_value = NULL;
 139 #if defined(LIBXML2_DEFINED)
 140
 141   if (IsValid())
 142     attr_value = (const char *)xmlGetProp(m_node, (const xmlChar *)name);
 143   else
 144     attr_value = fail_value;
 145 #else
 146   attr_value = fail_value;
 147 #endif
 148   if (attr_value)
 149     return llvm::StringRef(attr_value);
 150   else
 151     return llvm::StringRef();
 152 }
 153
 154 void XMLNode::ForEachChildNode(NodeCallback const &callback) const {
 155 #if defined(LIBXML2_DEFINED)
 156   if (IsValid())
 157     GetChild().ForEachSiblingNode(callback);
 158 #endif
 159 }
 160
 161 void XMLNode::ForEachChildElement(NodeCallback const &callback) const {
 162 #if defined(LIBXML2_DEFINED)
 163   XMLNode child = GetChild();
 164   if (child)
 165     child.ForEachSiblingElement(callback);
 166 #endif
 167 }
 168
 169 void XMLNode::ForEachChildElementWithName(const char *name,
 170                                           NodeCallback const &callback) const {
 171 #if defined(LIBXML2_DEFINED)
 172   XMLNode child = GetChild();
 173   if (child)
 174     child.ForEachSiblingElementWithName(name, callback);
 175 #endif
 176 }
 177
 178 void XMLNode::ForEachAttribute(AttributeCallback const &callback) const {
 179 #if defined(LIBXML2_DEFINED)
 180
 181   if (IsValid()) {
 182     for (xmlAttrPtr attr = m_node->properties; attr != nullptr;
 183          attr = attr->next) {
 184       // check if name matches
 185       if (attr->name) {
 186         // check child is a text node
 187         xmlNodePtr child = attr->children;
 188         if (child->type == XML_TEXT_NODE) {
 189           llvm::StringRef attr_value;
 190           if (child->content)
 191             attr_value = llvm::StringRef((const char *)child->content);
 192           if (callback(llvm::StringRef((const char *)attr->name), attr_value) ==
 193               false)
 194             return;
 195         }
 196       }
 197     }
 198   }
 199 #endif
 200 }
 201
 202 void XMLNode::ForEachSiblingNode(NodeCallback const &callback) const {
 203 #if defined(LIBXML2_DEFINED)
 204
 205   if (IsValid()) {
 206     // iterate through all siblings
 207     for (xmlNodePtr node = m_node; node; node = node->next) {
 208       if (callback(XMLNode(node)) == false)
 209         return;
 210     }
 211   }
 212 #endif
 213 }
 214
 215 void XMLNode::ForEachSiblingElement(NodeCallback const &callback) const {
 216 #if defined(LIBXML2_DEFINED)
 217
 218   if (IsValid()) {
 219     // iterate through all siblings
 220     for (xmlNodePtr node = m_node; node; node = node->next) {
 221       // we are looking for element nodes only
 222       if (node->type != XML_ELEMENT_NODE)
 223         continue;
 224
 225       if (callback(XMLNode(node)) == false)
 226         return;
 227     }
 228   }
 229 #endif
 230 }
 231
 232 void XMLNode::ForEachSiblingElementWithName(
 233     const char *name, NodeCallback const &callback) const {
 234 #if defined(LIBXML2_DEFINED)
 235
 236   if (IsValid()) {
 237     // iterate through all siblings
 238     for (xmlNodePtr node = m_node; node; node = node->next) {
 239       // we are looking for element nodes only
 240       if (node->type != XML_ELEMENT_NODE)
 241         continue;
 242
 243       // If name is nullptr, we take all nodes of type "t", else
 244       // just the ones whose name matches
 245       if (name) {
 246         if (strcmp((const char *)node->name, name) != 0)
 247           continue; // Name mismatch, ignore this one
 248       } else {
 249         if (node->name)
 250           continue; // nullptr name specified and this element has a name,
 251                     // ignore this one
 252       }
 253
 254       if (callback(XMLNode(node)) == false)
 255         return;
 256     }
 257   }
 258 #endif
 259 }
 260
 261 llvm::StringRef XMLNode::GetName() const {
 262 #if defined(LIBXML2_DEFINED)
 263   if (IsValid()) {
 264     if (m_node->name)
 265       return llvm::StringRef((const char *)m_node->name);
 266   }
 267 #endif
 268   return llvm::StringRef();
 269 }
 270
 271 bool XMLNode::GetElementText(std::string &text) const {
 272   text.clear();
 273 #if defined(LIBXML2_DEFINED)
 274   if (IsValid()) {
 275     bool success = false;
 276     if (m_node->type == XML_ELEMENT_NODE) {
 277       // check child is a text node
 278       for (xmlNodePtr node = m_node->children; node != nullptr;
 279            node = node->next) {
 280         if (node->type == XML_TEXT_NODE) {
 281           text.append((const char *)node->content);
 282           success = true;
 283         }
 284       }
 285     }
 286     return success;
 287   }
 288 #endif
 289   return false;
 290 }
 291
 292 bool XMLNode::GetElementTextAsUnsigned(uint64_t &value, uint64_t fail_value,
 293                                        int base) const {
 294   bool success = false;
 295 #if defined(LIBXML2_DEFINED)
 296   if (IsValid()) {
 297     std::string text;
 298     if (GetElementText(text))
 299       value = StringConvert::ToUInt64(text.c_str(), fail_value, base, &success);
 300   }
 301 #endif
 302   if (!success)
 303     value = fail_value;
 304   return success;
 305 }
 306
 307 bool XMLNode::GetElementTextAsFloat(double &value, double fail_value) const {
 308   bool success = false;
 309 #if defined(LIBXML2_DEFINED)
 310   if (IsValid()) {
 311     std::string text;
 312     if (GetElementText(text)) {
 313       value = atof(text.c_str());
 314       success = true;
 315     }
 316   }
 317 #endif
 318   if (!success)
 319     value = fail_value;
 320   return success;
 321 }
 322
 323 bool XMLNode::NameIs(const char *name) const {
 324 #if defined(LIBXML2_DEFINED)
 325
 326   if (IsValid()) {
 327     // In case we are looking for a nullptr name or an exact pointer match
 328     if (m_node->name == (const xmlChar *)name)
 329       return true;
 330     if (m_node->name)
 331       return strcmp((const char *)m_node->name, name) == 0;
 332   }
 333 #endif
 334   return false;
 335 }
 336
 337 XMLNode XMLNode::FindFirstChildElementWithName(const char *name) const {
 338   XMLNode result_node;
 339
 340 #if defined(LIBXML2_DEFINED)
 341   ForEachChildElementWithName(
 342       name, [&result_node, name](const XMLNode &node) -> bool {
 343         result_node = node;
 344         // Stop iterating, we found the node we wanted
 345         return false;
 346       });
 347 #endif
 348
 349   return result_node;
 350 }
 351
 352 bool XMLNode::IsValid() const { return m_node != nullptr; }
 353
 354 bool XMLNode::IsElement() const {
 355 #if defined(LIBXML2_DEFINED)
 356   if (IsValid())
 357     return m_node->type == XML_ELEMENT_NODE;
 358 #endif
 359   return false;
 360 }
 361
 362 XMLNode XMLNode::GetElementForPath(const NamePath &path) {
 363 #if defined(LIBXML2_DEFINED)
 364
 365   if (IsValid()) {
 366     if (path.empty())
 367       return *this;
 368     else {
 369       XMLNode node = FindFirstChildElementWithName(path[0].c_str());
 370       const size_t n = path.size();
 371       for (size_t i = 1; node && i < n; ++i)
 372         node = node.FindFirstChildElementWithName(path[i].c_str());
 373       return node;
 374     }
 375   }
 376 #endif
 377
 378   return XMLNode();
 379 }
 380
 381 #pragma mark-- ApplePropertyList
 382
 383 ApplePropertyList::ApplePropertyList() : m_xml_doc(), m_dict_node() {}
 384
 385 ApplePropertyList::ApplePropertyList(const char *path)
 386     : m_xml_doc(), m_dict_node() {
 387   ParseFile(path);
 388 }
 389
 390 ApplePropertyList::~ApplePropertyList() {}
 391
 392 llvm::StringRef ApplePropertyList::GetErrors() const {
 393   return m_xml_doc.GetErrors();
 394 }
 395
 396 bool ApplePropertyList::ParseFile(const char *path) {
 397   if (m_xml_doc.ParseFile(path)) {
 398     XMLNode plist = m_xml_doc.GetRootElement("plist");
 399     if (plist) {
 400       plist.ForEachChildElementWithName("dict",
 401                                         [this](const XMLNode &dict) -> bool {
 402                                           this->m_dict_node = dict;
 403                                           return false; // Stop iterating
 404                                         });
 405       return (bool)m_dict_node;
 406     }
 407   }
 408   return false;
 409 }
 410
 411 bool ApplePropertyList::IsValid() const { return (bool)m_dict_node; }
 412
 413 bool ApplePropertyList::GetValueAsString(const char *key,
 414                                          std::string &value) const {
 415   XMLNode value_node = GetValueNode(key);
 416   if (value_node)
 417     return ApplePropertyList::ExtractStringFromValueNode(value_node, value);
 418   return false;
 419 }
 420
 421 XMLNode ApplePropertyList::GetValueNode(const char *key) const {
 422   XMLNode value_node;
 423 #if defined(LIBXML2_DEFINED)
 424
 425   if (IsValid()) {
 426     m_dict_node.ForEachChildElementWithName(
 427         "key", [key, &value_node](const XMLNode &key_node) -> bool {
 428           std::string key_name;
 429           if (key_node.GetElementText(key_name)) {
 430             if (key_name.compare(key) == 0) {
 431               value_node = key_node.GetSibling();
 432               while (value_node && !value_node.IsElement())
 433                 value_node = value_node.GetSibling();
 434               return false; // Stop iterating
 435             }
 436           }
 437           return true; // Keep iterating
 438         });
 439   }
 440 #endif
 441   return value_node;
 442 }
 443
 444 bool ApplePropertyList::ExtractStringFromValueNode(const XMLNode &node,
 445                                                    std::string &value) {
 446   value.clear();
 447 #if defined(LIBXML2_DEFINED)
 448   if (node.IsValid()) {
 449     llvm::StringRef element_name = node.GetName();
 450     if (element_name == "true" || element_name == "false") {
 451       // The text value _is_ the element name itself...
 452       value = element_name.str();
 453       return true;
 454     } else if (element_name == "dict" || element_name == "array")
 455       return false; // dictionaries and arrays have no text value, so we fail
 456     else
 457       return node.GetElementText(value);
 458   }
 459 #endif
 460   return false;
 461 }
 462
 463 #if defined(LIBXML2_DEFINED)
 464
 465 namespace {
 466
 467 StructuredData::ObjectSP CreatePlistValue(XMLNode node) {
 468   llvm::StringRef element_name = node.GetName();
 469   if (element_name == "array") {
 470     std::shared_ptr<StructuredData::Array> array_sp(
 471         new StructuredData::Array());
 472     node.ForEachChildElement([&array_sp](const XMLNode &node) -> bool {
 473       array_sp->AddItem(CreatePlistValue(node));
 474       return true; // Keep iterating through all child elements of the array
 475     });
 476     return array_sp;
 477   } else if (element_name == "dict") {
 478     XMLNode key_node;
 479     std::shared_ptr<StructuredData::Dictionary> dict_sp(
 480         new StructuredData::Dictionary());
 481     node.ForEachChildElement(
 482         [&key_node, &dict_sp](const XMLNode &node) -> bool {
 483           if (node.NameIs("key")) {
 484             // This is a "key" element node
 485             key_node = node;
 486           } else {
 487             // This is a value node
 488             if (key_node) {
 489               std::string key_name;
 490               key_node.GetElementText(key_name);
 491               dict_sp->AddItem(key_name, CreatePlistValue(node));
 492               key_node.Clear();
 493             }
 494           }
 495           return true; // Keep iterating through all child elements of the
 496                        // dictionary
 497         });
 498     return dict_sp;
 499   } else if (element_name == "real") {
 500     double value = 0.0;
 501     node.GetElementTextAsFloat(value);
 502     return StructuredData::ObjectSP(new StructuredData::Float(value));
 503   } else if (element_name == "integer") {
 504     uint64_t value = 0;
 505     node.GetElementTextAsUnsigned(value, 0, 0);
 506     return StructuredData::ObjectSP(new StructuredData::Integer(value));
 507   } else if ((element_name == "string") || (element_name == "data") ||
 508              (element_name == "date")) {
 509     std::string text;
 510     node.GetElementText(text);
 511     return StructuredData::ObjectSP(
 512         new StructuredData::String(std::move(text)));
 513   } else if (element_name == "true") {
 514     return StructuredData::ObjectSP(new StructuredData::Boolean(true));
 515   } else if (element_name == "false") {
 516     return StructuredData::ObjectSP(new StructuredData::Boolean(false));
 517   }
 518   return StructuredData::ObjectSP(new StructuredData::Null());
 519 }
 520 }
 521 #endif
 522
 523 StructuredData::ObjectSP ApplePropertyList::GetStructuredData() {
 524   StructuredData::ObjectSP root_sp;
 525 #if defined(LIBXML2_DEFINED)
 526   if (IsValid()) {
 527     return CreatePlistValue(m_dict_node);
 528   }
 529 #endif
 530   return root_sp;
 531 }