update

CMakeLists.txt

@@ -1,2 +0,0 @@
-file(GLOB_RECURSE xml_SRC *.cpp)
-add_library(xml ${xml_SRC})

File.cpp

@@ -1,478 +0,0 @@
-// Copyright 2017 Patrick Brosi
-// info@patrickbrosi.de
-
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <cassert>
-#include <cstring>
-#include <fstream>
-#include <iostream>
-#include <map>
-#include "xml/File.h"
-#include "xml/NamedEnts.h"
-
-using namespace xml;
-
-// _____________________________________________________________________________
-File::File(const std::string& path)
-    : _file(0), _c(0), _lastBytes(0), _which(0), _path(path), _totReadBef(0) {
-  _buffer = new char*[2];
-  _buffer[0] = new char[BUFFER_S + 1];
-  _buffer[1] = new char[BUFFER_S + 1];
-
-  reset();
-}
-
-// _____________________________________________________________________________
-File::~File() {
-  delete[] _buffer[0];
-  delete[] _buffer[1];
-  delete[] _buffer;
-  close(_file);
-}
-
-// _____________________________________________________________________________
-void File::reset() {
-  _which = 0;
-  _s.s = NONE;
-  _s.hanging = 0;
-  _totReadBef = 0;
-
-  if (_file) close(_file);
-  _file = open(_path.c_str(), O_RDONLY);
-  if (_file < 0)
-    throw XmlFileException(std::string("could not open file"), _path, 0, 0, 0);
-#ifdef __unix__
-  posix_fadvise(_file, 0, 0, POSIX_FADV_SEQUENTIAL);
-#endif
-
-  _lastBytes = read(_file, _buffer[_which], BUFFER_S);
-  _lastNewData = _lastBytes;
-  _c = _buffer[_which];
-  while (!_s.tagStack.empty()) _s.tagStack.pop();
-  _s.tagStack.push("[root]");
-  _prevs = _s;
-}
-
-// _____________________________________________________________________________
-size_t File::level() const { return _s.tagStack.size() - _s.hanging; }
-
-// _____________________________________________________________________________
-ParserState File::state() { return _prevs; }
-
-// _____________________________________________________________________________
-void File::setState(const ParserState& s) {
-  _s = s;
-  _prevs = s;
-
-  lseek(_file, _s.off, SEEK_SET);
-  _totReadBef = _s.off;
-  _lastBytes = read(_file, _buffer[_which], BUFFER_S);
-  _lastNewData = _lastBytes;
-  _c = _buffer[_which];
-
-  next();
-}
-
-// _____________________________________________________________________________
-const Tag& File::get() const { return _ret; }
-
-// _____________________________________________________________________________
-bool File::next() {
-  if (!_s.tagStack.size()) return false;
-  // avoid too much stack copying
-  if (_prevs.tagStack.size() != _s.tagStack.size() ||
-      _prevs.tagStack.top() != _s.tagStack.top()) {
-    _prevs.tagStack = _s.tagStack;
-  }
-  _prevs.s = _s.s;
-  _prevs.hanging = _s.hanging;
-  _prevs.off =
-      _totReadBef + (_c - _buffer[_which]) - (_lastBytes - _lastNewData);
-
-  if (_s.hanging) _s.hanging--;
-  _ret.name = 0;
-  _ret.text = emptyStr;
-  _ret.attrs.clear();
-  void* i;
-  while (_lastBytes) {
-    for (; _c - _buffer[_which] < _lastBytes; ++_c) {
-      char c = *_c;
-      switch (_s.s) {
-        case NONE:
-          if (std::isspace(c))
-            continue;
-          else if (c == '<') {
-            _s.s = IN_TAG_TENTATIVE;
-            continue;
-          } else {
-            _s.s = IN_TEXT;
-            _ret.name = emptyStr;
-            _tmp = _c;
-            continue;
-          }
-        case IN_TEXT:
-          i = memchr(_c, '<', _lastBytes - (_c - _buffer[_which]));
-          if (!i) {
-            _c = _buffer[_which] + _lastBytes;
-            continue;
-          } else {
-            _c = (char*)i;
-            *_c = 0;
-            _ret.text = _tmp;
-            _s.s = IN_TAG_TENTATIVE;
-            _c++;
-            return true;
-          }
-        case IN_COMMENT_TENTATIVE:
-          if (c == '-') {
-            _s.s = IN_COMMENT_TENTATIVE2;
-            continue;
-          }
-          throw XmlFileException("Expected comment", _path, _c, _buffer[_which],
-                                 _prevs.off);
-
-        case IN_COMMENT_TENTATIVE2:
-          if (c == '-') {
-            _s.s = IN_COMMENT;
-            continue;
-          }
-          throw XmlFileException("Expected comment", _path, _c, _buffer[_which],
-                                 _prevs.off);
-
-        case IN_COMMENT_CL_TENTATIVE:
-          if (c == '-') {
-            _s.s = IN_COMMENT_CL_TENTATIVE2;
-            continue;
-          }
-          _s.s = IN_COMMENT;
-          continue;
-
-        case IN_COMMENT_CL_TENTATIVE2:
-          if (c == '>') {
-            _s.s = NONE;
-            continue;
-          }
-          _s.s = IN_COMMENT;
-        // fall through, we are still in comment
-
-        case IN_COMMENT:
-          i = memchr(_c, '-', _lastBytes - (_c - _buffer[_which]));
-          if (!i) {
-            _c = _buffer[_which] + _lastBytes;
-            continue;
-          } else {
-            _c = (char*)i;
-            _s.s = IN_COMMENT_CL_TENTATIVE;
-            continue;
-          }
-        case IN_TAG_TENTATIVE:
-          if (c == '/') {
-            _s.s = IN_TAG_NAME_CLOSE;
-            _tmp = _c + 1;
-            continue;
-          } else if (c == '?') {
-            _s.s = IN_TAG_NAME_META;
-            continue;
-          } else if (c == '!') {
-            _s.s = IN_COMMENT_TENTATIVE;
-            continue;
-          } else if (std::isalnum(c) || c == '-' || c == '_' || c == '.') {
-            _s.s = IN_TAG_NAME;
-            _ret.name = _c;
-            continue;
-          }
-
-        case IN_TAG:
-          if (std::isspace(c))
-            continue;
-          else if (std::isalnum(c) || c == '-' || c == '_' || c == '.') {
-            _s.s = IN_ATTRKEY;
-            _tmp = _c;
-            continue;
-          } else if (c == '/') {
-            _s.s = AW_CLOSING;
-            continue;
-          } else if (c == '>') {
-            _s.hanging++;
-            _s.tagStack.push(_ret.name);
-            _s.s = WS_SKIP;
-            continue;
-          } else {
-            throw XmlFileException("Expected valid tag", _path, _c,
-                                   _buffer[_which], _prevs.off);
-          }
-
-        case IN_ATTRVAL_SQ:
-          i = memchr(_c, '\'', _lastBytes - (_c - _buffer[_which]));
-          if (!i) {
-            _c = _buffer[_which] + _lastBytes;
-            continue;
-          } else {
-            _c = (char*)i;
-            _s.s = IN_TAG;
-            *_c = 0;
-            _ret.attrs[_tmp] = _tmp2;
-            continue;
-          }
-
-        case IN_ATTRVAL_DQ:
-          i = memchr(_c, '"', _lastBytes - (_c - _buffer[_which]));
-          if (!i) {
-            _c = _buffer[_which] + _lastBytes;
-            continue;
-          } else {
-            _c = (char*)i;
-            _s.s = IN_TAG;
-            *_c = 0;
-            _ret.attrs[_tmp] = _tmp2;
-            continue;
-          }
-
-        case AW_IN_ATTRVAL:
-          if (std::isspace(c))
-            continue;
-          else if (c == '\'') {
-            _s.s = IN_ATTRVAL_SQ;
-            _tmp2 = _c + 1;
-            continue;
-          } else if (c == '"') {
-            _s.s = IN_ATTRVAL_DQ;
-            _tmp2 = _c + 1;
-            continue;
-          } else {
-            throw XmlFileException("Expected attribute value", _path, _c,
-                                   _buffer[_which], _prevs.off);
-          }
-
-        case IN_ATTRKEY:
-          if (std::isspace(c)) {
-            *_c = 0;
-            _s.s = AFTER_ATTRKEY;
-            continue;
-          } else if (std::isalnum(c) || c == '-' || c == '_' || c == '.') {
-            continue;
-          } else if (c == '=') {
-            *_c = 0;
-            _s.s = AW_IN_ATTRVAL;
-            continue;
-          }
-
-          throw XmlFileException("Expected attribute key char or =", _path, _c,
-                                 _buffer[_which], _prevs.off);
-
-        case AFTER_ATTRKEY:
-          if (std::isspace(c))
-            continue;
-          else if (c == '=') {
-            _s.s = AW_IN_ATTRVAL;
-            continue;
-          } else {
-            throw XmlFileException(
-                std::string("Expected attribute value for '") + _tmp + "'.",
-                _path, _c, _buffer[_which], _prevs.off);
-          }
-
-        case IN_TAG_NAME:
-          if (std::isspace(c)) {
-            *_c = 0;
-            _s.s = IN_TAG;
-            continue;
-          } else if (c == '>') {
-            *_c = 0;
-            _s.hanging++;
-            _s.tagStack.push(_ret.name);
-            _s.s = WS_SKIP;
-            continue;
-          } else if (c == '/') {
-            *_c = 0;
-            _s.s = AW_CLOSING;
-            continue;
-          } else if (std::isalnum(c) || c == '-' || c == '_' || c == '.') {
-            continue;
-          }
-
-        case IN_TAG_NAME_META:
-          // TODO: read meta tags!
-          if (c == '>') {
-            _s.s = NONE;
-            continue;
-          }
-
-          continue;
-
-        case IN_TAG_NAME_CLOSE:
-          if (std::isspace(c)) {
-            *_c = 0;
-            _s.s = IN_TAG_CLOSE;
-            continue;
-          } else if (std::isalnum(c) || c == '-' || c == '_' || c == '.') {
-            continue;
-          } else if (c == '>') {
-            *_c = 0;
-            if (_tmp != _s.tagStack.top()) {
-              throw XmlFileException(std::string("Closing wrong tag '<") + _tmp +
-                                         ">', expected close of '<" +
-                                         _s.tagStack.top() + ">'.",
-                                     _path, _c, _buffer[_which], _prevs.off);
-            }
-            _s.tagStack.pop();
-            _s.s = NONE;
-            continue;
-          }
-
-        case IN_TAG_CLOSE:
-          if (std::isspace(c))
-            continue;
-          else if (c == '>') {
-            if (_tmp != _s.tagStack.top()) {
-              throw XmlFileException(std::string("Closing wrong tag '<") + _tmp +
-                                         ">', expected close of '<" +
-                                         _s.tagStack.top() + ">'.",
-                                     _path, _c, _buffer[_which], _prevs.off);
-            }
-            _s.tagStack.pop();
-            _s.s = NONE;
-            continue;
-          } else {
-            throw XmlFileException("Expected '>'", _path, _c, _buffer[_which],
-                                   _prevs.off);
-          }
-
-        case AW_CLOSING:
-          if (c == '>') {
-            _s.s = WS_SKIP;
-            continue;
-          }
-
-        case WS_SKIP:
-          if (std::isspace(c))
-            continue;
-          else {
-            _s.s = NONE;
-            return true;
-          }
-      }
-    }
-
-    // buffer ended, read new stuff, but copy remaining if needed
-    size_t off = 0;
-    if (_s.s == IN_TAG_NAME) {  //|| IN_TAG_NAME_META) {
-      off = _lastBytes - (_ret.name - _buffer[_which]);
-      memmove(_buffer[!_which], _ret.name, off);
-      _ret.name = _buffer[!_which];
-    } else if (_s.s == IN_TAG_NAME_CLOSE || _s.s == IN_ATTRKEY ||
-               _s.s == IN_TEXT) {
-      off = _lastBytes - (_tmp - _buffer[_which]);
-      memmove(_buffer[!_which], _tmp, off);
-      _tmp = _buffer[!_which];
-    } else if (_s.s == IN_ATTRVAL_SQ || _s.s == IN_ATTRVAL_DQ) {
-      off = _lastBytes - (_tmp2 - _buffer[_which]);
-      memmove(_buffer[!_which], _tmp2, off);
-      _tmp2 = _buffer[!_which];
-    }
-
-    assert(off <= BUFFER_S);
-
-    size_t readb = read(_file, _buffer[!_which] + off, BUFFER_S - off);
-    if (!readb) break;
-    _totReadBef += _lastNewData;
-    _which = !_which;
-    _lastNewData = readb;
-    _lastBytes = _lastNewData + off;
-    _c = _buffer[_which] + off;
-  }
-
-  if (_s.tagStack.size()) {
-    if (_s.tagStack.top() != "[root]") {
-      throw XmlFileException("XML tree not complete", _path, _c,
-                             _buffer[_which], _prevs.off);
-    } else {
-      _s.tagStack.pop();
-    }
-  }
-  _s.s = NONE;
-  _ret.name = "[root]";
-  return false;
-}
-
-// _____________________________________________________________________________
-std::string File::decode(const std::string& str) { return decode(str.c_str()); }
-
-// _____________________________________________________________________________
-std::string File::decode(const char* str) {
-  const char* c = strchr(str, '&');
-  if (!c) return str;
-
-  char* decRet = new char[strlen(str) + 1];
-  const char* last = str;
-  char* dstPt = decRet;
-
-  for (; c != 0; c = strchr(c + 1, '&')) {
-    memcpy(dstPt, last, c - last);
-    dstPt += c - last;
-    last = c;
-
-    if (*(c + 1) == '#') {
-      uint64_t cp = -1;
-      char* tail;
-      errno = 0;
-      if (*(c + 2) == 'x' || *(c + 2) == 'X')
-        cp = strtoul(c + 3, &tail, 16);
-      else
-        cp = strtoul(c + 2, &tail, 10);
-
-      if (*tail == ';' && cp <= 0x1FFFFF && !errno) {
-        dstPt += utf8(cp, dstPt);
-        last = tail + 1;
-      }
-    } else {
-      const char* e = strchr(c, ';');
-      if (e) {
-        char* ent = new char[e - 1 - c + 1];
-        memcpy(ent, c + 1, e - 1 - c);
-        ent[e - 1 - c] = 0;
-        const auto it = xml::ENTITIES.find(ent);
-        if (it != xml::ENTITIES.end()) {
-          const char* utf8 = it->second;
-          memcpy(dstPt, utf8, strlen(utf8));
-          dstPt += strlen(utf8);
-          last += strlen(ent) + 2;
-        }
-        delete[] ent;
-      }
-    }
-  }
-
-  strcpy(dstPt, last);
-  std::string ret(decRet);
-  delete[] decRet;
-  return ret;
-}
-
-// _____________________________________________________________________________
-size_t File::utf8(size_t cp, char* out) {
-  if (cp <= 0x7F) {
-    out[0] = cp & 0x7F;
-    return 1;
-  } else if (cp <= 0x7FF) {
-    out[0] = 0xC0 | (cp >> 6);
-    out[1] = 0x80 | (cp & 0x3F);
-    return 2;
-  } else if (cp <= 0xFFFF) {
-    out[0] = 0xE0 | (cp >> 12);
-    out[1] = 0x80 | ((cp >> 6) & 0x3F);
-    out[2] = 0x80 | (cp & 0x3F);
-    return 3;
-  } else if (cp <= 0x1FFFFF) {
-    out[0] = 0xF0 | (cp >> 18);
-    out[1] = 0x80 | ((cp >> 12) & 0x3F);
-    out[2] = 0x80 | ((cp >> 6) & 0x3F);
-    out[3] = 0x80 | (cp & 0x3F);
-    return 4;
-  }
-
-  return 0;
-}

File.h

@@ -1,118 +0,0 @@
-// Copyright 2017 Patrick Brosi
-// info@patrickbrosi.de
-
-#ifndef XML_FILE_H_
-#define XML_FILE_H_
-
-#include <cstring>
-#include <fstream>
-#include <map>
-#include <sstream>
-#include <stack>
-#include <string>
-
-namespace xml {
-
-const static size_t BUFFER_S = 16 * 1024;
-
-class XmlFileException : public std::exception {
- public:
-  XmlFileException(std::string msg, std::string file, const char* p, char* buff,
-                   size_t offset) {
-    std::stringstream ss;
-    ss << file << " at position " << (offset + (p - buff)) << ": " << msg;
-    _msg = ss.str();
-  }
-  ~XmlFileException() throw() {}
-
-  virtual const char* what() const throw() { return _msg.c_str(); };
-
- private:
-  std::string _msg;
-};
-
-enum State {
-  NONE,
-  IN_TAG_NAME,
-  IN_TAG_NAME_META,
-  IN_TAG,
-  IN_TAG_CLOSE,
-  IN_TAG_NAME_CLOSE,
-  IN_TAG_TENTATIVE,
-  IN_ATTRKEY,
-  AFTER_ATTRKEY,
-  AW_IN_ATTRVAL,
-  IN_ATTRVAL_SQ,
-  IN_ATTRVAL_DQ,
-  IN_TEXT,
-  IN_COMMENT_TENTATIVE,
-  IN_COMMENT_TENTATIVE2,
-  IN_COMMENT,
-  IN_COMMENT_CL_TENTATIVE,
-  IN_COMMENT_CL_TENTATIVE2,
-  AW_CLOSING,
-  WS_SKIP
-};
-
-struct AttrCmp {
-  bool operator()(const char* const& a, const char* const& b) const {
-    return std::strcmp(a, b) < 0;
-  }
-};
-
-struct ParserState {
-  ParserState() : s(NONE), hanging(0), off(0){};
-  std::stack<std::string> tagStack;
-  State s;
-  size_t hanging;
-  int64_t off;
-};
-
-typedef std::map<const char*, const char*, AttrCmp> AttrMap;
-
-struct Tag {
-  const char* name;
-  const char* text;
-  AttrMap attrs;
-};
-
-class File {
- public:
-  File(const std::string& path);
-  ~File();
-
-  const Tag& get() const;
-
-  bool next();
-  size_t level() const;
-  void reset();
-  ParserState state();
-  void setState(const ParserState& s);
-  static std::string decode(const char* str);
-  static std::string decode(const std::string& str);
-
- private:
-  int _file;
-  ParserState _s;
-  ParserState _prevs;
-  char** _buffer;
-  char* _c;
-  int64_t _lastBytes;
-
-  const char* _tmp;
-  const char* _tmp2;
-
-  size_t _which;
-  std::string _path;
-
-  int64_t _totReadBef;
-  int64_t _lastNewData;
-
-  Tag _ret;
-
-  static size_t utf8(size_t cp, char* out);
-  const char* emptyStr = "";
-};
-}
-
-#endif  // XML_FILE_H_

NamedEnts.h

@@ -1,272 +0,0 @@
-// Copyright 2017 Patrick Brosi
-// info@patrickbrosi.de
-
-#ifndef XML_NAMEDENTS_H_
-#define XML_NAMEDENTS_H_
-
-#include <map>
-#include <string>
-
-namespace xml {
-
-// see
-// http://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references
-std::map<std::string, const char*> ENTITIES = {
-  {"aacute", "á"},
-  {"Aacute", "Á"},
-  {"acirc", "â"},
-  {"Acirc", "Â"},
-  {"acute", "´"},
-  {"aelig", "æ"},
-  {"AElig", "Æ"},
-  {"agrave", "à"},
-  {"Agrave", "À"},
-  {"alefsym", "ℵ"},
-  {"alpha", "α"},
-  {"Alpha", "Α"},
-  {"amp", "&"},
-  {"and", "∧"},
-  {"ang", "∠"},
-  {"apos", "'"},
-  {"aring", "å"},
-  {"Aring", "Å"},
-  {"asymp", "≈"},
-  {"atilde", "ã"},
-  {"Atilde", "Ã"},
-  {"auml", "ä"},
-  {"Auml", "Ä"},
-  {"bdquo", "„"},
-  {"beta", "β"},
-  {"Beta", "Β"},
-  {"brvbar", "¦"},
-  {"bull", "•"},
-  {"cap", "∩"},
-  {"ccedil", "ç"},
-  {"Ccedil", "Ç"},
-  {"cedil", "¸"},
-  {"cent", "¢"},
-  {"chi", "χ"},
-  {"Chi", "Χ"},
-  {"circ", "ˆ"},
-  {"clubs", "♣"},
-  {"cong", "≅"},
-  {"copy", "©"},
-  {"crarr", "↵"},
-  {"cup", "∪"},
-  {"curren", "¤"},
-  {"dagger", "†"},
-  {"Dagger", "‡"},
-  {"darr", "↓"},
-  {"dArr", "⇓"},
-  {"deg", "°"},
-  {"delta", "δ"},
-  {"Delta", "Δ"},
-  {"diams", "♦"},
-  {"divide", "÷"},
-  {"eacute", "é"},
-  {"Eacute", "É"},
-  {"ecirc", "ê"},
-  {"Ecirc", "Ê"},
-  {"egrave", "è"},
-  {"Egrave", "È"},
-  {"empty", "∅"},
-  {"emsp", "\xE2\x80\x83"},
-  {"ensp", "\xE2\x80\x82"},
-  {"epsilon", "ε"},
-  {"Epsilon", "Ε"},
-  {"equiv", "≡"},
-  {"eta", "η"},
-  {"Eta", "Η"},
-  {"eth", "ð"},
-  {"ETH", "Ð"},
-  {"euml", "ë"},
-  {"Euml", "Ë"},
-  {"euro", "€"},
-  {"exist", "∃"},
-  {"fnof", "ƒ"},
-  {"forall", "∀"},
-  {"frac12", "½"},
-  {"frac14", "¼"},
-  {"frac34", "¾"},
-  {"frasl", "⁄"},
-  {"gamma", "γ"},
-  {"Gamma", "Γ"},
-  {"ge", "≥"},
-  {"gt", ">"},
-  {"harr", "↔"},
-  {"hArr", "⇔"},
-  {"hearts", "♥"},
-  {"hellip", "…"},
-  {"iacute", "í"},
-  {"Iacute", "Í"},
-  {"icirc", "î"},
-  {"Icirc", "Î"},
-  {"iexcl", "¡"},
-  {"igrave", "ì"},
-  {"Igrave", "Ì"},
-  {"image", "ℑ"},
-  {"infin", "∞"},
-  {"int", "∫"},
-  {"iota", "ι"},
-  {"Iota", "Ι"},
-  {"iquest", "¿"},
-  {"isin", "∈"},
-  {"iuml", "ï"},
-  {"Iuml", "Ï"},
-  {"kappa", "κ"},
-  {"Kappa", "Κ"},
-  {"lambda", "λ"},
-  {"Lambda", "Λ"},
-  {"lang", "〈"},
-  {"laquo", "«"},
-  {"larr", "←"},
-  {"lArr", "⇐"},
-  {"lceil", "⌈"},
-  {"ldquo", "“"},
-  {"le", "≤"},
-  {"lfloor", "⌊"},
-  {"lowast", "∗"},
-  {"loz", "◊"},
-  {"lrm", "\xE2\x80\x8E"},
-  {"lsaquo", "‹"},
-  {"lsquo", "‘"},
-  {"lt", "<"},
-  {"macr", "¯"},
-  {"mdash", "—"},
-  {"micro", "µ"},
-  {"middot", "·"},
-  {"minus", "−"},
-  {"mu", "μ"},
-  {"Mu", "Μ"},
-  {"nabla", "∇"},
-  {"nbsp", "\xC2\xA0"},
-  {"ndash", "–"},
-  {"ne", "≠"},
-  {"ni", "∋"},
-  {"not", "¬"},
-  {"notin", "∉"},
-  {"nsub", "⊄"},
-  {"ntilde", "ñ"},
-  {"Ntilde", "Ñ"},
-  {"nu", "ν"},
-  {"Nu", "Ν"},
-  {"oacute", "ó"},
-  {"Oacute", "Ó"},
-  {"ocirc", "ô"},
-  {"Ocirc", "Ô"},
-  {"oelig", "œ"},
-  {"OElig", "Œ"},
-  {"ograve", "ò"},
-  {"Ograve", "Ò"},
-  {"oline", "‾"},
-  {"omega", "ω"},
-  {"Omega", "Ω"},
-  {"omicron", "ο"},
-  {"Omicron", "Ο"},
-  {"oplus", "⊕"},
-  {"or", "∨"},
-  {"ordf", "ª"},
-  {"ordm", "º"},
-  {"oslash", "ø"},
-  {"Oslash", "Ø"},
-  {"otilde", "õ"},
-  {"Otilde", "Õ"},
-  {"otimes", "⊗"},
-  {"ouml", "ö"},
-  {"Ouml", "Ö"},
-  {"para", "¶"},
-  {"part", "∂"},
-  {"permil", "‰"},
-  {"perp", "⊥"},
-  {"phi", "φ"},
-  {"Phi", "Φ"},
-  {"piv", "ϖ"},
-  {"pi", "π"},
-  {"Pi", "Π"},
-  {"plusmn", "±"},
-  {"pound", "£"},
-  {"prime", "′"},
-  {"Prime", "″"},
-  {"prod", "∏"},
-  {"prop", "∝"},
-  {"psi", "ψ"},
-  {"Psi", "Ψ"},
-  {"quot", "\""},
-  {"radic", "√"},
-  {"rang", "〉"},
-  {"raquo", "»"},
-  {"rarr", "→"},
-  {"rArr", "⇒"},
-  {"rceil", "⌉"},
-  {"rdquo", "”"},
-  {"real", "ℜ"},
-  {"reg", "®"},
-  {"rfloor", "⌋"},
-  {"rho", "ρ"},
-  {"Rho", "Ρ"},
-  {"rlm", "\xE2\x80\x8F"},
-  {"rsaquo", "›"},
-  {"rsquo", "’"},
-  {"sbquo", "‚"},
-  {"scaron", "š"},
-  {"Scaron", "Š"},
-  {"sdot", "⋅"},
-  {"sect", "§"},
-  {"shy", "\xC2\xAD"},
-  {"sigmaf", "ς"},
-  {"sigma", "σ"},
-  {"Sigma", "Σ"},
-  {"sim", "∼"},
-  {"spades", "♠"},
-  {"sub", "⊂"},
-  {"sube", "⊆"},
-  {"sum", "∑"},
-  {"sup", "⊃"},
-  {"sup1", "¹"},
-  {"sup2", "²"},
-  {"sup3", "³"},
-  {"supe", "⊇"},
-  {"szlig", "ß"},
-  {"tau", "τ"},
-  {"Tau", "Τ"},
-  {"there4", "∴"},
-  {"thetasym", "ϑ"},
-  {"theta", "θ"},
-  {"Theta", "Θ"},
-  {"thinsp", "\xE2\x80\x89"},
-  {"thorn", "þ"},
-  {"THORN", "Þ"},
-  {"tilde", "˜"},
-  {"times", "×"},
-  {"trade", "™"},
-  {"uacute", "ú"},
-  {"Uacute", "Ú"},
-  {"uarr", "↑"},
-  {"uArr", "⇑"},
-  {"ucirc", "û"},
-  {"Ucirc", "Û"},
-  {"ugrave", "ù"},
-  {"Ugrave", "Ù"},
-  {"uml", "¨"},
-  {"upsih", "ϒ"},
-  {"upsilon", "υ"},
-  {"Upsilon", "Υ"},
-  {"uuml", "ü"},
-  {"Uuml", "Ü"},
-  {"weierp", "℘"},
-  {"xi", "ξ"},
-  {"Xi", "Ξ"},
-  {"yacute", "ý"},
-  {"Yacute", "Ý"},
-  {"yen", "¥"},
-  {"yuml", "ÿ"},
-  {"Yuml", "Ÿ"},
-  {"zeta", "ζ"},
-  {"Zeta", "Ζ"},
-  {"zwj", "\xE2\x80\x8D"},
-  {"zwnj", "\xE2\x80\x8C"}
-};
-}
-
-#endif  // XML_NAMEDENTS_H_
-

README.md

@@ -1,15 +1,17 @@
 # Pretty fast XML parser
 
-Simple XML parser with minimal copying. Designed for high-speed parsing of very large XML files (like OSM XML files).
+* Simple XML parser with minimal copying.
+* Designed for high-speed parsing of very large XML files (like OSM XML files).
+* Should be pretty fast.
 
 ## Usage
 
 ```
-#include "xml/File.h"
+#include "pfxml.h"
 
 [...]
 
-xml::File xml("myfile.xml");
+pfxml::file xml("myfile.xml");
 
 while (xml.next()) {
   const auto& cur = xml.get();

pfxml.h

@@ -0,0 +1,829 @@
+// Copyright 2017 Patrick Brosi
+// info@patrickbrosi.de
+
+#ifndef PFXML_H_
+#define PFXML_H_
+
+#include <cstring>
+#include <fstream>
+#include <map>
+#include <sstream>
+#include <stack>
+#include <string>
+
+namespace pfxml {
+
+static const size_t BUFFER_S = 16 * 1024;
+
+enum state {
+  NONE,
+  IN_TAG_NAME,
+  IN_TAG_NAME_META,
+  IN_TAG,
+  IN_TAG_CLOSE,
+  IN_TAG_NAME_CLOSE,
+  IN_TAG_TENTATIVE,
+  IN_ATTRKEY,
+  AFTER_ATTRKEY,
+  AW_IN_ATTRVAL,
+  IN_ATTRVAL_SQ,
+  IN_ATTRVAL_DQ,
+  IN_TEXT,
+  IN_COMMENT_TENTATIVE,
+  IN_COMMENT_TENTATIVE2,
+  IN_COMMENT,
+  IN_COMMENT_CL_TENTATIVE,
+  IN_COMMENT_CL_TENTATIVE2,
+  AW_CLOSING,
+  WS_SKIP
+};
+
+// see
+// http://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references
+static const std::map<std::string, const char*> ENTITIES = {
+    {"aacute", "á"},
+    {"Aacute", "Á"},
+    {"acirc", "â"},
+    {"Acirc", "Â"},
+    {"acute", "´"},
+    {"aelig", "æ"},
+    {"AElig", "Æ"},
+    {"agrave", "à"},
+    {"Agrave", "À"},
+    {"alefsym", "ℵ"},
+    {"alpha", "α"},
+    {"Alpha", "Α"},
+    {"amp", "&"},
+    {"and", "∧"},
+    {"ang", "∠"},
+    {"apos", "'"},
+    {"aring", "å"},
+    {"Aring", "Å"},
+    {"asymp", "≈"},
+    {"atilde", "ã"},
+    {"Atilde", "Ã"},
+    {"auml", "ä"},
+    {"Auml", "Ä"},
+    {"bdquo", "„"},
+    {"beta", "β"},
+    {"Beta", "Β"},
+    {"brvbar", "¦"},
+    {"bull", "•"},
+    {"cap", "∩"},
+    {"ccedil", "ç"},
+    {"Ccedil", "Ç"},
+    {"cedil", "¸"},
+    {"cent", "¢"},
+    {"chi", "χ"},
+    {"Chi", "Χ"},
+    {"circ", "ˆ"},
+    {"clubs", "♣"},
+    {"cong", "≅"},
+    {"copy", "©"},
+    {"crarr", "↵"},
+    {"cup", "∪"},
+    {"curren", "¤"},
+    {"dagger", "†"},
+    {"Dagger", "‡"},
+    {"darr", "↓"},
+    {"dArr", "⇓"},
+    {"deg", "°"},
+    {"delta", "δ"},
+    {"Delta", "Δ"},
+    {"diams", "♦"},
+    {"divide", "÷"},
+    {"eacute", "é"},
+    {"Eacute", "É"},
+    {"ecirc", "ê"},
+    {"Ecirc", "Ê"},
+    {"egrave", "è"},
+    {"Egrave", "È"},
+    {"empty", "∅"},
+    {"emsp", "\xE2\x80\x83"},
+    {"ensp", "\xE2\x80\x82"},
+    {"epsilon", "ε"},
+    {"Epsilon", "Ε"},
+    {"equiv", "≡"},
+    {"eta", "η"},
+    {"Eta", "Η"},
+    {"eth", "ð"},
+    {"ETH", "Ð"},
+    {"euml", "ë"},
+    {"Euml", "Ë"},
+    {"euro", "€"},
+    {"exist", "∃"},
+    {"fnof", "ƒ"},
+    {"forall", "∀"},
+    {"frac12", "½"},
+    {"frac14", "¼"},
+    {"frac34", "¾"},
+    {"frasl", "⁄"},
+    {"gamma", "γ"},
+    {"Gamma", "Γ"},
+    {"ge", "≥"},
+    {"gt", ">"},
+    {"harr", "↔"},
+    {"hArr", "⇔"},
+    {"hearts", "♥"},
+    {"hellip", "…"},
+    {"iacute", "í"},
+    {"Iacute", "Í"},
+    {"icirc", "î"},
+    {"Icirc", "Î"},
+    {"iexcl", "¡"},
+    {"igrave", "ì"},
+    {"Igrave", "Ì"},
+    {"image", "ℑ"},
+    {"infin", "∞"},
+    {"int", "∫"},
+    {"iota", "ι"},
+    {"Iota", "Ι"},
+    {"iquest", "¿"},
+    {"isin", "∈"},
+    {"iuml", "ï"},
+    {"Iuml", "Ï"},
+    {"kappa", "κ"},
+    {"Kappa", "Κ"},
+    {"lambda", "λ"},
+    {"Lambda", "Λ"},
+    {"lang", "〈"},
+    {"laquo", "«"},
+    {"larr", "←"},
+    {"lArr", "⇐"},
+    {"lceil", "⌈"},
+    {"ldquo", "“"},
+    {"le", "≤"},
+    {"lfloor", "⌊"},
+    {"lowast", "∗"},
+    {"loz", "◊"},
+    {"lrm", "\xE2\x80\x8E"},
+    {"lsaquo", "‹"},
+    {"lsquo", "‘"},
+    {"lt", "<"},
+    {"macr", "¯"},
+    {"mdash", "—"},
+    {"micro", "µ"},
+    {"middot", "·"},
+    {"minus", "−"},
+    {"mu", "μ"},
+    {"Mu", "Μ"},
+    {"nabla", "∇"},
+    {"nbsp", "\xC2\xA0"},
+    {"ndash", "–"},
+    {"ne", "≠"},
+    {"ni", "∋"},
+    {"not", "¬"},
+    {"notin", "∉"},
+    {"nsub", "⊄"},
+    {"ntilde", "ñ"},
+    {"Ntilde", "Ñ"},
+    {"nu", "ν"},
+    {"Nu", "Ν"},
+    {"oacute", "ó"},
+    {"Oacute", "Ó"},
+    {"ocirc", "ô"},
+    {"Ocirc", "Ô"},
+    {"oelig", "œ"},
+    {"OElig", "Œ"},
+    {"ograve", "ò"},
+    {"Ograve", "Ò"},
+    {"oline", "‾"},
+    {"omega", "ω"},
+    {"Omega", "Ω"},
+    {"omicron", "ο"},
+    {"Omicron", "Ο"},
+    {"oplus", "⊕"},
+    {"or", "∨"},
+    {"ordf", "ª"},
+    {"ordm", "º"},
+    {"oslash", "ø"},
+    {"Oslash", "Ø"},
+    {"otilde", "õ"},
+    {"Otilde", "Õ"},
+    {"otimes", "⊗"},
+    {"ouml", "ö"},
+    {"Ouml", "Ö"},
+    {"para", "¶"},
+    {"part", "∂"},
+    {"permil", "‰"},
+    {"perp", "⊥"},
+    {"phi", "φ"},
+    {"Phi", "Φ"},
+    {"piv", "ϖ"},
+    {"pi", "π"},
+    {"Pi", "Π"},
+    {"plusmn", "±"},
+    {"pound", "£"},
+    {"prime", "′"},
+    {"Prime", "″"},
+    {"prod", "∏"},
+    {"prop", "∝"},
+    {"psi", "ψ"},
+    {"Psi", "Ψ"},
+    {"quot", "\""},
+    {"radic", "√"},
+    {"rang", "〉"},
+    {"raquo", "»"},
+    {"rarr", "→"},
+    {"rArr", "⇒"},
+    {"rceil", "⌉"},
+    {"rdquo", "”"},
+    {"real", "ℜ"},
+    {"reg", "®"},
+    {"rfloor", "⌋"},
+    {"rho", "ρ"},
+    {"Rho", "Ρ"},
+    {"rlm", "\xE2\x80\x8F"},
+    {"rsaquo", "›"},
+    {"rsquo", "’"},
+    {"sbquo", "‚"},
+    {"scaron", "š"},
+    {"Scaron", "Š"},
+    {"sdot", "⋅"},
+    {"sect", "§"},
+    {"shy", "\xC2\xAD"},
+    {"sigmaf", "ς"},
+    {"sigma", "σ"},
+    {"Sigma", "Σ"},
+    {"sim", "∼"},
+    {"spades", "♠"},
+    {"sub", "⊂"},
+    {"sube", "⊆"},
+    {"sum", "∑"},
+    {"sup", "⊃"},
+    {"sup1", "¹"},
+    {"sup2", "²"},
+    {"sup3", "³"},
+    {"supe", "⊇"},
+    {"szlig", "ß"},
+    {"tau", "τ"},
+    {"Tau", "Τ"},
+    {"there4", "∴"},
+    {"thetasym", "ϑ"},
+    {"theta", "θ"},
+    {"Theta", "Θ"},
+    {"thinsp", "\xE2\x80\x89"},
+    {"thorn", "þ"},
+    {"THORN", "Þ"},
+    {"tilde", "˜"},
+    {"times", "×"},
+    {"trade", "™"},
+    {"uacute", "ú"},
+    {"Uacute", "Ú"},
+    {"uarr", "↑"},
+    {"uArr", "⇑"},
+    {"ucirc", "û"},
+    {"Ucirc", "Û"},
+    {"ugrave", "ù"},
+    {"Ugrave", "Ù"},
+    {"uml", "¨"},
+    {"upsih", "ϒ"},
+    {"upsilon", "υ"},
+    {"Upsilon", "Υ"},
+    {"uuml", "ü"},
+    {"Uuml", "Ü"},
+    {"weierp", "℘"},
+    {"xi", "ξ"},
+    {"Xi", "Ξ"},
+    {"yacute", "ý"},
+    {"Yacute", "Ý"},
+    {"yen", "¥"},
+    {"yuml", "ÿ"},
+    {"Yuml", "Ÿ"},
+    {"zeta", "ζ"},
+    {"Zeta", "Ζ"},
+    {"zwj", "\xE2\x80\x8D"},
+    {"zwnj", "\xE2\x80\x8C"}};
+
+class parse_exc : public std::exception {
+ public:
+  parse_exc(std::string msg, std::string file, const char* p, char* buff,
+            size_t offset) {
+    std::stringstream ss;
+    ss << file << " at position " << (offset + (p - buff)) << ": " << msg;
+    _msg = ss.str();
+  }
+  ~parse_exc() throw() {}
+
+  virtual const char* what() const throw() { return _msg.c_str(); }
+
+ private:
+  std::string _msg;
+};
+
+struct attr_cmp {
+  bool operator()(const char* const& a, const char* const& b) const {
+    return std::strcmp(a, b) < 0;
+  }
+};
+
+struct parser_state {
+  parser_state() : s(NONE), hanging(0), off(0) {}
+  std::stack<std::string> tagStack;
+  state s;
+  size_t hanging;
+  int64_t off;
+};
+
+typedef std::map<const char*, const char*, attr_cmp> AttrMap;
+
+struct tag {
+  const char* name;
+  const char* text;
+  AttrMap attrs;
+};
+
+class file {
+ public:
+  file(const std::string& path);
+  ~file();
+
+  const tag& get() const;
+
+  bool next();
+  size_t level() const;
+  void reset();
+  parser_state state();
+  void set_state(const parser_state& s);
+  static std::string decode(const char* str);
+  static std::string decode(const std::string& str);
+
+ private:
+  int _file;
+  parser_state _s;
+  parser_state _prevs;
+  char** _buffer;
+  char* _c;
+  int64_t _lastBytes;
+
+  const char* _tmp;
+  const char* _tmp2;
+
+  size_t _which;
+  std::string _path;
+
+  int64_t _totReadBef;
+  int64_t _lastNewData;
+
+  tag _ret;
+
+  static size_t utf8(size_t cp, char* out);
+  const char* emptyStr = "";
+};
+
+// _____________________________________________________________________________
+inline file::file(const std::string& path)
+    : _file(0), _c(0), _lastBytes(0), _which(0), _path(path), _totReadBef(0) {
+  _buffer = new char*[2];
+  _buffer[0] = new char[BUFFER_S + 1];
+  _buffer[1] = new char[BUFFER_S + 1];
+
+  reset();
+}
+
+// _____________________________________________________________________________
+inline file::~file() {
+  delete[] _buffer[0];
+  delete[] _buffer[1];
+  delete[] _buffer;
+  close(_file);
+}
+
+// _____________________________________________________________________________
+inline void file::reset() {
+  _which = 0;
+  _s.s = NONE;
+  _s.hanging = 0;
+  _totReadBef = 0;
+
+  if (_file) close(_file);
+  _file = open(_path.c_str(), O_RDONLY);
+  if (_file < 0)
+    throw parse_exc(std::string("could not open file"), _path, 0, 0, 0);
+#ifdef __unix__
+  posix_fadvise(_file, 0, 0, POSIX_FADV_SEQUENTIAL);
+#endif
+
+  _lastBytes = read(_file, _buffer[_which], BUFFER_S);
+  _lastNewData = _lastBytes;
+  _c = _buffer[_which];
+  while (!_s.tagStack.empty()) _s.tagStack.pop();
+  _s.tagStack.push("[root]");
+  _prevs = _s;
+}
+
+// _____________________________________________________________________________
+inline size_t file::level() const { return _s.tagStack.size() - _s.hanging; }
+
+// _____________________________________________________________________________
+inline parser_state file::state() { return _prevs; }
+
+// _____________________________________________________________________________
+inline void file::set_state(const parser_state& s) {
+  _s = s;
+  _prevs = s;
+
+  lseek(_file, _s.off, SEEK_SET);
+  _totReadBef = _s.off;
+  _lastBytes = read(_file, _buffer[_which], BUFFER_S);
+  _lastNewData = _lastBytes;
+  _c = _buffer[_which];
+
+  next();
+}
+
+// _____________________________________________________________________________
+inline const tag& file::get() const { return _ret; }
+
+// _____________________________________________________________________________
+inline bool file::next() {
+  if (!_s.tagStack.size()) return false;
+  // avoid too much stack copying
+  if (_prevs.tagStack.size() != _s.tagStack.size() ||
+      _prevs.tagStack.top() != _s.tagStack.top()) {
+    _prevs.tagStack = _s.tagStack;
+  }
+  _prevs.s = _s.s;
+  _prevs.hanging = _s.hanging;
+  _prevs.off =
+      _totReadBef + (_c - _buffer[_which]) - (_lastBytes - _lastNewData);
+
+  if (_s.hanging) _s.hanging--;
+  _ret.name = 0;
+  _ret.text = emptyStr;
+  _ret.attrs.clear();
+  void* i;
+  while (_lastBytes) {
+    for (; _c - _buffer[_which] < _lastBytes; ++_c) {
+      char c = *_c;
+      switch (_s.s) {
+        case NONE:
+          if (std::isspace(c))
+            continue;
+          else if (c == '<') {
+            _s.s = IN_TAG_TENTATIVE;
+            continue;
+          }
+          _s.s = IN_TEXT;
+          _ret.name = emptyStr;
+          _tmp = _c;
+          continue;
+
+        case IN_TEXT:
+          i = memchr(_c, '<', _lastBytes - (_c - _buffer[_which]));
+          if (!i) {
+            _c = _buffer[_which] + _lastBytes;
+            continue;
+          }
+          _c = (char*)i;
+          *_c = 0;
+          _ret.text = _tmp;
+          _s.s = IN_TAG_TENTATIVE;
+          _c++;
+          return true;
+
+        case IN_COMMENT_TENTATIVE:
+          if (c == '-') {
+            _s.s = IN_COMMENT_TENTATIVE2;
+            continue;
+          }
+          throw parse_exc("Expected comment", _path, _c, _buffer[_which],
+                          _prevs.off);
+
+        case IN_COMMENT_TENTATIVE2:
+          if (c == '-') {
+            _s.s = IN_COMMENT;
+            continue;
+          }
+          throw parse_exc("Expected comment", _path, _c, _buffer[_which],
+                          _prevs.off);
+
+        case IN_COMMENT_CL_TENTATIVE:
+          if (c == '-') {
+            _s.s = IN_COMMENT_CL_TENTATIVE2;
+            continue;
+          }
+          _s.s = IN_COMMENT;
+          continue;
+
+        case IN_COMMENT_CL_TENTATIVE2:
+          if (c == '>') {
+            _s.s = NONE;
+            continue;
+          }
+          _s.s = IN_COMMENT;
+        // fall through, we are still in comment
+
+        case IN_COMMENT:
+          i = memchr(_c, '-', _lastBytes - (_c - _buffer[_which]));
+          if (!i) {
+            _c = _buffer[_which] + _lastBytes;
+            continue;
+          }
+          _c = (char*)i;
+          _s.s = IN_COMMENT_CL_TENTATIVE;
+          continue;
+
+        case IN_TAG_TENTATIVE:
+          if (c == '/') {
+            _s.s = IN_TAG_NAME_CLOSE;
+            _tmp = _c + 1;
+            continue;
+          } else if (c == '?') {
+            _s.s = IN_TAG_NAME_META;
+            continue;
+          } else if (c == '!') {
+            _s.s = IN_COMMENT_TENTATIVE;
+            continue;
+          } else if (std::isalnum(c) || c == '-' || c == '_' || c == '.') {
+            _s.s = IN_TAG_NAME;
+            _ret.name = _c;
+            continue;
+          }
+
+        case IN_TAG:
+          if (std::isspace(c))
+            continue;
+          else if (std::isalnum(c) || c == '-' || c == '_' || c == '.') {
+            _s.s = IN_ATTRKEY;
+            _tmp = _c;
+            continue;
+          } else if (c == '/') {
+            _s.s = AW_CLOSING;
+            continue;
+          } else if (c == '>') {
+            _s.hanging++;
+            _s.tagStack.push(_ret.name);
+            _s.s = WS_SKIP;
+            continue;
+          }
+          throw parse_exc("Expected valid tag", _path, _c, _buffer[_which],
+                          _prevs.off);
+
+        case IN_ATTRVAL_SQ:
+          i = memchr(_c, '\'', _lastBytes - (_c - _buffer[_which]));
+          if (!i) {
+            _c = _buffer[_which] + _lastBytes;
+            continue;
+          }
+          _c = (char*)i;
+          _s.s = IN_TAG;
+          *_c = 0;
+          _ret.attrs[_tmp] = _tmp2;
+          continue;
+
+        case IN_ATTRVAL_DQ:
+          i = memchr(_c, '"', _lastBytes - (_c - _buffer[_which]));
+          if (!i) {
+            _c = _buffer[_which] + _lastBytes;
+            continue;
+          }
+          _c = (char*)i;
+          _s.s = IN_TAG;
+          *_c = 0;
+          _ret.attrs[_tmp] = _tmp2;
+          continue;
+
+        case AW_IN_ATTRVAL:
+          if (std::isspace(c))
+            continue;
+          else if (c == '\'') {
+            _s.s = IN_ATTRVAL_SQ;
+            _tmp2 = _c + 1;
+            continue;
+          } else if (c == '"') {
+            _s.s = IN_ATTRVAL_DQ;
+            _tmp2 = _c + 1;
+            continue;
+          }
+          throw parse_exc("Expected attribute value", _path, _c,
+                          _buffer[_which], _prevs.off);
+
+        case IN_ATTRKEY:
+          if (std::isspace(c)) {
+            *_c = 0;
+            _s.s = AFTER_ATTRKEY;
+            continue;
+          } else if (std::isalnum(c) || c == '-' || c == '_' || c == '.') {
+            continue;
+          } else if (c == '=') {
+            *_c = 0;
+            _s.s = AW_IN_ATTRVAL;
+            continue;
+          }
+
+          throw parse_exc("Expected attribute key char or =", _path, _c,
+                          _buffer[_which], _prevs.off);
+
+        case AFTER_ATTRKEY:
+          if (std::isspace(c))
+            continue;
+          else if (c == '=') {
+            _s.s = AW_IN_ATTRVAL;
+            continue;
+          }
+          throw parse_exc(
+              std::string("Expected attribute value for '") + _tmp + "'.",
+              _path, _c, _buffer[_which], _prevs.off);
+
+        case IN_TAG_NAME:
+          if (std::isspace(c)) {
+            *_c = 0;
+            _s.s = IN_TAG;
+            continue;
+          } else if (c == '>') {
+            *_c = 0;
+            _s.hanging++;
+            _s.tagStack.push(_ret.name);
+            _s.s = WS_SKIP;
+            continue;
+          } else if (c == '/') {
+            *_c = 0;
+            _s.s = AW_CLOSING;
+            continue;
+          } else if (std::isalnum(c) || c == '-' || c == '_' || c == '.') {
+            continue;
+          }
+
+        case IN_TAG_NAME_META:
+          // TODO: read meta tags!
+          if (c == '>') {
+            _s.s = NONE;
+            continue;
+          }
+
+          continue;
+
+        case IN_TAG_NAME_CLOSE:
+          if (std::isspace(c)) {
+            *_c = 0;
+            _s.s = IN_TAG_CLOSE;
+            continue;
+          } else if (std::isalnum(c) || c == '-' || c == '_' || c == '.') {
+            continue;
+          } else if (c == '>') {
+            *_c = 0;
+            if (_tmp != _s.tagStack.top()) {
+              throw parse_exc(std::string("Closing wrong tag '<") + _tmp +
+                                  ">', expected close of '<" +
+                                  _s.tagStack.top() + ">'.",
+                              _path, _c, _buffer[_which], _prevs.off);
+            }
+            _s.tagStack.pop();
+            _s.s = NONE;
+            continue;
+          }
+
+        case IN_TAG_CLOSE:
+          if (std::isspace(c))
+            continue;
+          else if (c == '>') {
+            if (_tmp != _s.tagStack.top()) {
+              throw parse_exc(std::string("Closing wrong tag '<") + _tmp +
+                                  ">', expected close of '<" +
+                                  _s.tagStack.top() + ">'.",
+                              _path, _c, _buffer[_which], _prevs.off);
+            }
+            _s.tagStack.pop();
+            _s.s = NONE;
+            continue;
+          }
+          throw parse_exc("Expected '>'", _path, _c, _buffer[_which],
+                          _prevs.off);
+
+        case AW_CLOSING:
+          if (c == '>') {
+            _s.s = WS_SKIP;
+            continue;
+          }
+
+        case WS_SKIP:
+          if (std::isspace(c)) continue;
+          _s.s = NONE;
+          return true;
+      }
+    }
+
+    // buffer ended, read new stuff, but copy remaining if needed
+    size_t off = 0;
+    if (_s.s == IN_TAG_NAME) {  //|| IN_TAG_NAME_META) {
+      off = _lastBytes - (_ret.name - _buffer[_which]);
+      memmove(_buffer[!_which], _ret.name, off);
+      _ret.name = _buffer[!_which];
+    } else if (_s.s == IN_TAG_NAME_CLOSE || _s.s == IN_ATTRKEY ||
+               _s.s == IN_TEXT) {
+      off = _lastBytes - (_tmp - _buffer[_which]);
+      memmove(_buffer[!_which], _tmp, off);
+      _tmp = _buffer[!_which];
+    } else if (_s.s == IN_ATTRVAL_SQ || _s.s == IN_ATTRVAL_DQ) {
+      off = _lastBytes - (_tmp2 - _buffer[_which]);
+      memmove(_buffer[!_which], _tmp2, off);
+      _tmp2 = _buffer[!_which];
+    }
+
+    assert(off <= BUFFER_S);
+
+    size_t readb = read(_file, _buffer[!_which] + off, BUFFER_S - off);
+    if (!readb) break;
+    _totReadBef += _lastNewData;
+    _which = !_which;
+    _lastNewData = readb;
+    _lastBytes = _lastNewData + off;
+    _c = _buffer[_which] + off;
+  }
+
+  if (_s.tagStack.size()) {
+    if (_s.tagStack.top() != "[root]") {
+      throw parse_exc("XML tree not complete", _path, _c, _buffer[_which],
+                      _prevs.off);
+    }
+    _s.tagStack.pop();
+  }
+  _s.s = NONE;
+  _ret.name = "[root]";
+  return false;
+}
+
+// _____________________________________________________________________________
+inline std::string file::decode(const std::string& str) {
+  return decode(str.c_str());
+}
+
+// _____________________________________________________________________________
+inline std::string file::decode(const char* str) {
+  const char* c = strchr(str, '&');
+  if (!c) return str;
+
+  char* decRet = new char[strlen(str) + 1];
+  const char* last = str;
+  char* dstPt = decRet;
+
+  for (; c != 0; c = strchr(c + 1, '&')) {
+    memcpy(dstPt, last, c - last);
+    dstPt += c - last;
+    last = c;
+
+    if (*(c + 1) == '#') {
+      uint64_t cp = -1;
+      char* tail;
+      errno = 0;
+      if (*(c + 2) == 'x' || *(c + 2) == 'X')
+        cp = strtoul(c + 3, &tail, 16);
+      else
+        cp = strtoul(c + 2, &tail, 10);
+
+      if (*tail == ';' && cp <= 0x1FFFFF && !errno) {
+        dstPt += utf8(cp, dstPt);
+        last = tail + 1;
+      }
+    } else {
+      const char* e = strchr(c, ';');
+      if (e) {
+        char* ent = new char[e - 1 - c + 1];
+        memcpy(ent, c + 1, e - 1 - c);
+        ent[e - 1 - c] = 0;
+        const auto it = ENTITIES.find(ent);
+        if (it != ENTITIES.end()) {
+          const char* utf8 = it->second;
+          memcpy(dstPt, utf8, strlen(utf8));
+          dstPt += strlen(utf8);
+          last += strlen(ent) + 2;
+        }
+        delete[] ent;
+      }
+    }
+  }
+
+  strcpy(dstPt, last);
+  std::string ret(decRet);
+  delete[] decRet;
+  return ret;
+}
+
+// _____________________________________________________________________________
+inline size_t file::utf8(size_t cp, char* out) {
+  if (cp <= 0x7F) {
+    out[0] = cp & 0x7F;
+    return 1;
+  } else if (cp <= 0x7FF) {
+    out[0] = 0xC0 | (cp >> 6);
+    out[1] = 0x80 | (cp & 0x3F);
+    return 2;
+  } else if (cp <= 0xFFFF) {
+    out[0] = 0xE0 | (cp >> 12);
+    out[1] = 0x80 | ((cp >> 6) & 0x3F);
+    out[2] = 0x80 | (cp & 0x3F);
+    return 3;
+  } else if (cp <= 0x1FFFFF) {
+    out[0] = 0xF0 | (cp >> 18);
+    out[1] = 0x80 | ((cp >> 12) & 0x3F);
+    out[2] = 0x80 | ((cp >> 6) & 0x3F);
+    out[3] = 0x80 | (cp & 0x3F);
+    return 4;
+  }
+
+  return 0;
+}
+}
+
+#endif  // PFXML_H_