initial commit

.gitignore

@@ -0,0 +1,20 @@
+Makefile
+CMakeCache.txt
+*.o
+*.a
+cmake_install.cmake
+*~
+CMakeFiles
+*.cfg
+*.cmake
+/build/
+*.pyc
+compile_commands.json
+.vimrc
+.clang_complete
+/.idea
+*.vs
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+*.cppr
+*.hr

CMakeLists.txt

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

File.cpp

@@ -0,0 +1,399 @@
+// 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);
+  posix_fadvise(_file, 0, 0, POSIX_FADV_SEQUENTIAL);
+
+  _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() {
+  // 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.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;
+            continue;
+          }
+        case IN_TEXT:
+          throw XmlFileException("text nodes not yet supported");
+        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 (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");
+          }
+
+        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");
+          }
+
+        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;
+          }
+
+          std::cerr << "ERROR 5" << std::endl;
+          exit(0);
+
+        case AFTER_ATTRKEY:
+          if (std::isspace(c))
+            continue;
+          else if (c == '=') {
+            _s.s = AW_IN_ATTRVAL;
+            continue;
+          } else {
+            // TODO: error
+            continue;
+          }
+
+        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("closing wrong tag");
+            }
+            _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("closing wrong tag");
+            }
+            _s.tagStack.pop();
+            _s.s = NONE;
+            continue;
+          } else {
+            throw XmlFileException("expected '>'");
+          }
+
+        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.top() != "[root]") {
+    // TODO error
+    throw XmlFileException("XML tree not complete");
+  } 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[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[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;
+        }
+      }
+    }
+  }
+
+  strcpy(dstPt, last);
+  return decRet;
+}
+
+// _____________________________________________________________________________
+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

@@ -0,0 +1,105 @@
+// Copyright 2017 Patrick Brosi
+// info@patrickbrosi.de
+
+#ifndef XML_FILE_H_
+#define XML_FILE_H_
+
+#include <cstring>
+#include <fstream>
+#include <map>
+#include <stack>
+#include <string>
+
+namespace xml {
+
+const static size_t BUFFER_S = 16 * 1024;
+
+class XmlFileException : public std::exception {
+ public:
+  XmlFileException(std::string msg) : _msg(msg) {}
+  ~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,
+  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;
+  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);
+};
+}
+
+#endif  // XML_FILE_H_

NamedEnts.h

@@ -0,0 +1,272 @@
+// 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_
+