xml_lite.cpp

Go to the documentation of this file.

#include "faulttree/xml_lite.hpp"
 
#include <cctype>
#include <fstream>
#include <sstream>
 
namespace faulttree::xml {
 
const std::string *Element::attribute(const std::string &name) const {
  for (const auto &attr : attributes) {
    if (attr.name == name) { return &attr.value; }
  }
  return nullptr;
}
 
std::string Element::attributeOr(const std::string &name,
                                 const std::string &fallback) const {
  const std::string *value = attribute(name);
  return value ? *value : fallback;
}
 
const Element *Element::child(const std::string &name) const {
  for (const auto &element : children) {
    if (element.name == name) { return &element; }
  }
  return nullptr;
}
 
std::vector<const Element *>
Element::childrenNamed(const std::string &name) const {
  std::vector<const Element *> found;
  for (const auto &element : children) {
    if (element.name == name) { found.push_back(&element); }
  }
  return found;
}
 
namespace {
 
bool isNameStart(char c) {
  return std::isalpha(static_cast<unsigned char>(c)) != 0 || c == '_' || c == ':';
}
 
bool isNameChar(char c) {
  return std::isalnum(static_cast<unsigned char>(c)) != 0 || c == '_' ||
         c == '-' || c == '.' || c == ':';
}
 
class Parser {
public:
  explicit Parser(const std::string &text) : text_(text) {}
 
  Element parseDocument() {
    skipProlog();
    if (!looking_at("<")) { fail("expected a root element"); }
    Element root = parseElement();
    skipTrivia();
    if (pos_ != text_.size()) { fail("trailing content after the root element"); }
    return root;
  }
 
private:
  [[noreturn]] void fail(const std::string &message) const {
    std::size_t line = 1;
    std::size_t column = 1;
    for (std::size_t i = 0; i < pos_ && i < text_.size(); ++i) {
      if (text_[i] == '\n') {
        ++line;
        column = 1;
      } else {
        ++column;
      }
    }
    std::ostringstream out;
    out << "XML parse error at line " << line << ", column " << column << ": "
        << message;
    throw XmlError(out.str());
  }
 
  [[nodiscard]] bool eof() const { return pos_ >= text_.size(); }
 
  [[nodiscard]] bool looking_at(const char *literal) const {
    return text_.compare(pos_, std::char_traits<char>::length(literal),
                         literal) == 0;
  }
 
  void expect(const char *literal, const std::string &context) {
    if (!looking_at(literal)) { fail("expected '" + std::string(literal) + "' " + context); }
    pos_ += std::char_traits<char>::length(literal);
  }
 
  void skipSpace() {
    while (!eof() && std::isspace(static_cast<unsigned char>(text_[pos_])) != 0) {
      ++pos_;
    }
  }
 
  void skipTrivia() {
    for (;;) {
      skipSpace();
      if (looking_at("<!--")) {
        std::size_t end = text_.find("-->", pos_ + 4);
        if (end == std::string::npos) { fail("unterminated comment"); }
        pos_ = end + 3;
        continue;
      }
      return;
    }
  }
 
  void skipProlog() {
    skipTrivia();
    if (looking_at("<?xml")) {
      std::size_t end = text_.find("?>", pos_);
      if (end == std::string::npos) { fail("unterminated XML declaration"); }
      pos_ = end + 2;
      skipTrivia();
    }
  }
 
  std::string parseName(const std::string &context) {
    if (eof() || !isNameStart(text_[pos_])) { fail("expected a name " + context); }
    std::size_t start = pos_;
    while (!eof() && isNameChar(text_[pos_])) { ++pos_; }
    return text_.substr(start, pos_ - start);
  }
 
  std::string decodeEntities(const std::string &raw) {
    if (raw.find('&') == std::string::npos) { return raw; }
    std::string out;
    out.reserve(raw.size());
    for (std::size_t i = 0; i < raw.size(); ++i) {
      if (raw[i] != '&') {
        out.push_back(raw[i]);
        continue;
      }
      std::size_t semi = raw.find(';', i);
      if (semi == std::string::npos) { fail("unterminated entity reference"); }
      std::string entity = raw.substr(i + 1, semi - i - 1);
      if (entity == "amp") {
        out.push_back('&');
      } else if (entity == "lt") {
        out.push_back('<');
      } else if (entity == "gt") {
        out.push_back('>');
      } else if (entity == "quot") {
        out.push_back('"');
      } else if (entity == "apos") {
        out.push_back('\'');
      } else if (entity.size() > 1 && entity[0] == '#') {
        int base = 10;
        std::size_t offset = 1;
        if (entity[1] == 'x' || entity[1] == 'X') {
          base = 16;
          offset = 2;
        }
        try {
          unsigned long code = std::stoul(entity.substr(offset), nullptr, base);
          if (code > 0x7F) {
            fail("only ASCII character references are supported");
          }
          out.push_back(static_cast<char>(code));
        } catch (const std::invalid_argument &) {
          fail("malformed character reference '&" + entity + ";'");
        } catch (const std::out_of_range &) {
          fail("character reference out of range '&" + entity + ";'");
        }
      } else {
        fail("unknown entity '&" + entity + ";'");
      }
      i = semi;
    }
    return out;
  }
 
  Attribute parseAttribute() {
    Attribute attr;
    attr.name = parseName("for an attribute");
    skipSpace();
    expect("=", "after attribute '" + attr.name + "'");
    skipSpace();
    if (eof() || (text_[pos_] != '"' && text_[pos_] != '\'')) {
      fail("attribute '" + attr.name + "' must have a quoted value");
    }
    const char quote = text_[pos_++];
    std::size_t start = pos_;
    while (!eof() && text_[pos_] != quote) {
      if (text_[pos_] == '<') { fail("'<' is not allowed inside an attribute value"); }
      ++pos_;
    }
    if (eof()) { fail("unterminated attribute value for '" + attr.name + "'"); }
    attr.value = decodeEntities(text_.substr(start, pos_ - start));
    ++pos_; // closing quote
    return attr;
  }
 
  Element parseElement() {
    expect("<", "to open an element");
    if (looking_at("!") || looking_at("?")) {
      fail("DOCTYPE, CDATA and processing instructions are not supported");
    }
    Element element;
    element.name = parseName("for an element");
 
    for (;;) {
      skipSpace();
      if (looking_at("/>")) {
        pos_ += 2;
        return element; // self-closing
      }
      if (looking_at(">")) {
        ++pos_;
        break;
      }
      if (eof()) { fail("unterminated start tag '" + element.name + "'"); }
      element.attributes.push_back(parseAttribute());
    }
 
    // Content: child elements and comments; text is not meaningful in the
    // subset we accept, so it is skipped.
    for (;;) {
      skipTextAndComments();
      if (eof()) { fail("unterminated element '" + element.name + "'"); }
      if (looking_at("</")) {
        pos_ += 2;
        std::string closing = parseName("for a closing tag");
        if (closing != element.name) {
          fail("closing tag '" + closing + "' does not match '" + element.name + "'");
        }
        skipSpace();
        expect(">", "to close '" + closing + "'");
        return element;
      }
      element.children.push_back(parseElement());
    }
  }
 
  void skipTextAndComments() {
    for (;;) {
      if (looking_at("<!--")) {
        std::size_t end = text_.find("-->", pos_ + 4);
        if (end == std::string::npos) { fail("unterminated comment"); }
        pos_ = end + 3;
        continue;
      }
      if (eof() || text_[pos_] == '<') { return; }
      ++pos_;
    }
  }
 
  const std::string &text_;
  std::size_t pos_ = 0;
};
 
} // namespace
 
Element parse(const std::string &text) { return Parser(text).parseDocument(); }
 
Element parseFile(const std::string &path) {
  std::ifstream in(path, std::ios::binary);
  if (!in) { throw XmlError("cannot open '" + path + "'"); }
  std::ostringstream buffer;
  buffer << in.rdbuf();
  return parse(buffer.str());
}
 
} // namespace faulttree::xml