root/trunk/bevutils/TinyXML.d

/***************************************************************
Copyright (c) Steve Teale 2007
This program is free software; you can use it for any purpose
subject to the following conditions.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR ANY PARTICULAR PURPOSE.
****************************************************************/

module bevutils.tinyxml;

import std.regexp;
import std.string;
import std.stdio;
import std.stream;

alias std.string.find indexOf;
alias std.string.split split;
alias std.string.toString toString;

/**
 * A compact XML parser and object model.
 *
 * TinyXML is aimed mainly at configuration files and the like.
 *
 * The TinyXML object model is navigated using a path syntax of two forms.  If tx is
 * a TinyXML object, you can say:
 *
 * XMLElement e = tx("path_string");
 * XMLElement e = tx << "path_string"
 *
 * These both perform the same navigation operation, but while the first simply hands
 * you a reference to the target element, the second can do the same, but also sets the
 * tx object context.
 *
 */
class TinyXML
{
   protected static const char[510] _spaces = ' ';
   protected static const char[] _WS = "(\\s+)";
   protected static const char[] _TWS = "\\s+$";
   protected static const char[] _COMMENT = "(<!--(.*)-->)";
   protected static const char[] _XJOINT = r"(\.|(([A-Za-z_][0-9A-Za-z_]*)|\^|#|!|')(\[([0-9]+|\$)\])?)";
   protected static const char[] _AJOINT = r"(@(([A-Za-z_][0-9A-Za-z_]*)|(\[[0-9]+\])))";
   protected static RegExp _wsrex;
   protected static RegExp _twsrex;
   protected static RegExp _crex;
   protected static RegExp _jrex;

   static this()
   {
      //_spaces[0 .. 510] = ' ';
      _wsrex = RegExp(_WS);
      _twsrex = RegExp(_TWS);
      _crex = RegExp(_COMMENT);
      _jrex = RegExp(_XJOINT);
   }

   protected char[] prune(char[] s)
   {
      return _wsrex.find(s)? s: _wsrex.post;
   }

   protected char[] rprune(char[] s)
   {
      int pos = _twsrex.find(s);
      return (pos >= 0)? s[0 .. pos]: s;
   }

   /**
    * The XML element types supported by TinyXML.
    *
    * These are Tags - <tag> ... </tag>, text, as in <tag>This text</tag>, and comments
    * <!-- A comment -->
    */
   enum : int
   {
      ALL,
      TAG,
      TEXT,
      COMMENT
   }

   struct NVPair
   {
      char[] name;
      char[] value;
   }

   /**
    * The representation of a set of attributes on an XML tag.
    */
   class AttrList
   {
   private:
      NVPair[] list;
      int[char[]] map;
   public:

      /**
       * Add a new attribute to the list.
       *
       * Params:
       *   name = The attribute name.
       *   value = the attribute value.
       */
      void addAttr(char[] name, char[] value)
      {
         if (hasKey(name))
            throw new Exception("Attribute already exists");
         int n = list.length;
         list.length = n+1;
         list[n].name = name;
         list[n].value = value;
         map[name] = n;
      }

      /**
       * Create a new attribute list identical to the one for which the method was called.
       */
      AttrList clone()
      {
         AttrList a = new AttrList();
         int n = length();
         for (int i = 0; i < n; i++)
            a.addAttr(name(i), value(i));
         return a;
      }

      /**
       * Delete an attribute from the list by name
       *
       * Params:
       *   name = The name of the attribute to be deleted.
       */
      void delAttr(char[] name)
      {
         if (!hasKey(name))
            throw new Exception("No such attribute");
         int i = map[name];
         list = list[0 .. i] ~ list[i+1 .. $];
      }

      /**
       * A property-style method to get the length of the list
       */
      int length() { return list.length; }

      /**
       * Get the name of the i'th attribute in the list.
       *
       * Params:
       *   i = The desired index.
       */
      char[] name(int i) { return list[i].name; }
      
      /**
       * Get the name of the i'th value in the list.
       *
       * Params:
       *   i = The desired index.
       */
      char[] value(int i) { return list[i].value; }
      
      /**
       * Get the value of an attribute by name.
       *
       * Params:
       *   name = The desired name.
       */
      char[] value(char[] name) { return hasKey(name)? list[map[name]].value: null; }
      
      /**
       * Set the value of an attribute by name.
       *
       * Params:
       *   name = The name of the attribute.
       */
      char[] value(char[] name, char[] value)
         { if (hasKey(name)) { list[map[name]].value = value; return value; } else return null; }

      /**
       * Clear the list
       */
      void clear()
      {
         char[][] keys = map.keys;
         foreach (s; keys)
            map.remove(s);
         list.length = 0;
      }

      /**
       * Formats the list into a string suitable for XML.
       */
      char[] format()
      {
         char[] s = "";
         for (int i = 0; i < list.length; i++)
         {
            if (i > 0) s ~= " ";
            s ~= list[i].name ~ "=\"" ~ Tag.encode_entities(list[i].value) ~ "\"";
         }
         return s;
      }

   private:
      private bool hasKey(char[] key) { return ((key in map) != null); }
   }

   /**
    * A base class for Tags, Comments and body text - EText
    */
   class XMLElement
   {
      Tag _parent;

      /**
       * Abstract method to recover the element type.
       */
      abstract int EType();

      /**
       * Abstract method to format elements for XML.
       */
      abstract char[] format(char[] s, int indent);

      /**
       * Abstract method to recover a textual representation of the element.
       */
      abstract char[] PText();

      /**
       * Abstract method to recover an 'attribute' from the element
       */
      abstract char[] getValue(char[] name);

      /**
       * Abstract method to set an 'attribute' of the element.
       */
      abstract char[] setValue(char[] name, char[] value) ;

      /**
       * Abstract method to recover the parent of the element, which will
       * always be a Tag.
       */
      abstract Tag Parent();
   }

   /**
    * Class representing XML Tag body text.
    */
   class EText : XMLElement
   {
      char[] _etext;

      /**
       * Create an EText object and link it to a Tag.
       */
      this(char[] s, Tag parent) { _etext = s; _parent = parent; }

      /**
       * Get the element type - in this case TEXT.
       */
      int EType() { return TEXT; }

      /**
       * Format the text for inclusion in XML text.
       *
       * Params:
       *   s = An existing string to which the text representing this element is appended.
       *   indent = Degree to which the formatted text should be indented.
       *
       * Returns: The original string with the element text appended.
       */
      char[] format(char[] s, int indent)
      {
         char[] sp = _spaces[0 .. 3*indent];
         return (s ~ sp ~ _etext ~ "\n");
      }

      /**
       * Get a plain text version - just the text.
       */
      char[] PText() { return _etext; }

      /**
       * Get an 'attribute' by name - in this class the name is ignored.
       *
       * Params:
       *   name = A string value that is ignored.
       *
       * Returns: The plain text.
       */
      char[] getValue(char[] name) { return _etext; }

      /**
       * Set an 'attribute' by name - in this class the name is ignored.
       *
       * Params:
       *   name = A string value that is ignored.
       *   value = the value to be set for the text.
       *
       * Returns: The set plain text.
       */
      char[] setValue(char[] name, char[] value) { _etext = value; return _etext; }

      /**
       * Get the element's parent.
       */
      Tag Parent() { return _parent; }
   }

   /**
    * Class representing an XML comment.
    */
   class Comment : XMLElement
   {
      char[] _cmt;

      /**
       * Create a Comment object and link it to a Tag.
       */
      this(char[] s, Tag parent) { _cmt = s; _parent = parent; }

      /**
       * Get the element type - in this case COMMENT.
       */
      int EType() { return COMMENT; }

      /**
       * Format the text for inclusion in XML text.
       *
       * Params:
       *   s = An existing string to which the text representing this element is appended.
       *   indent = Degree to which the formatted text should be indented.
       *
       * Returns: The original string with the element text appended.
       */
      char[] format(char[] s, int indent)
      {
         char[] sp = _spaces[0 .. 3*indent];
         return (s ~ sp ~ "<!--" ~ _cmt ~ "-->\n");
      }

      /**
       * Get a plain text version - the bare comment.
       */
      char[] PText() { return "<!--" ~ _cmt ~ "-->"; }

      /**
       * Get an 'attribute' by name - in this class the name is ignored.
       *
       * Params:
       *   name = A string value that is ignored.
       *
       * Returns: The plain text.
       */
      char[] getValue(char[] name) { return _cmt; }

      /**
       * Set an 'attribute' by name - in this class the name is ignored.
       *
       * Params:
       *   name = A string value that is ignored.
       *   value = the value to be set for the text.
       *
       * Returns: The set plain text.
       */
      char[] setValue(char[] name, char[] value) { _cmt = value; return _cmt; }

      /**
       * Get the element's parent.
       */
      Tag Parent() { return _parent; }
   }


   /**
    * Class representing an XML Tag - &lt;tagname> ... &lt;/tagname>.
    *
    * Tags are the structural building blocks of the TinyXML object model.
    */
   class Tag : XMLElement
   {
      const char[] _TAG = "(<[A-Za-z_][A-Za-z0-9_]*[^>]*>)";
      const char[] _END = "(<\\/[A-Za-z_][A-Za-z0-9_]*\\s*>)";
      const char[] _AS = "(=[\"'])";

      static RegExp _xmlrex;
      static RegExp _tagrex;
      static RegExp _endrex;
      static RegExp _asrex;

      static this()
      {
         _xmlrex = RegExp(_XML);
         _tagrex = RegExp(_TAG);
         _endrex = RegExp(_END);
         _asrex = RegExp(_AS);
      }

      bool _valid;
      char[] _name;
      XMLElement[] _elist;
      AttrList _attributes;


      /**
       * Create a Tag object from XML text and possibly link it to a Tag.
       *
       * This constructor is called recursively to nibble Tag elements from a string
       * originally representing the entire XML, and is in essence the XML parser.
       *
       * Params:
       *   so = The source TinyXML object - provides the context and the text to be parsed.
       *        If so is null this constructor just returns a bare Tag element.
       *   parentnode = The tag that will be the parent of the new Tag.
       */
      this(TinyXML so, Tag parentnode)
      {
         _valid = false;
         _parent = parentnode;
         _attributes = new AttrList();
         if (so is null)
         {
            // Nothing to parse - just making a bare Tag object
            _valid = true;
            return;
         }

         so._src = prune(so._src);
         int pt = _tagrex.find(so._src);
         if (pt == -1)
         {
            so.setErr("No opening tag found");
            return;
         }
         char[] tag = _tagrex.match(1);
         int taglen = tag.length;
         int tagend = taglen-1;

         bool mt = (so._src[tagend-1] == '/');
         so._atTop = false;

         int ps = _wsrex.find(so._src);
         char[] as;
         if (ps == -1 || ps > tagend)
            _name = so._src[1 .. (mt? tagend-1: tagend)];
         else
         {
            char[] n = so._src[1 .. ps];
            _name = prune(n);
            as = prune(so._src[ps+1 .. (mt? tagend-1: tagend)]);
            as = rprune(as);
         }

         if (as.length) 
         {
            if ((!parse_attribs(so, as)))
            {
               return;
            }
         }
         if (so._atTop && mt)
         {
            _valid = true;
            return;
         }

         so._src = prune(so._src[tagend+1 .. so._src.length]);
         int n = 0;
         if (!mt)
         {
            // We have stripped of the opening tag construct and any whitespace, so now may have
            // Some element text
            // <!-- some comment -->
            // <A ...> ... </A>
            // Some more element text
            // <B ...> ... </B>
            // </CURRENTTAG  >

            for (;;)
            {
               if (so._src == "")
               {
                  setErr("Missing end tag after tag: " ~ _name);
                  return;
               }
               if (_endrex.find(so._src) == 0)
               {
                  // Hopefully we found the closing tag of the element we are parsing
                  char[] et = _endrex.match(1);
                  char[] tn = rprune(et[2 .. et.length-1]);    // gets us "CURRENTTAG  " --> "CURRENTTAG"
                  if (tn == _name)
                  {
                     so._src = prune(_endrex.post);
                     break;
                  }
                  so.setErr("Unexpected closing tag: " ~ et ~ " after " ~ _name);
                  return;
               }
               else if (_tagrex.find(so._src) == 0)
               {
                  Tag nn = new Tag(so, this);
                  if (!nn._valid) {
                     // error already reported
                     return;
                  }
                  _elist.length = _elist.length+1;
                  _elist[n] = nn;
                  n++;
               }
               else if (_crex.find(so._src) == 0)
               {
                  _elist.length = _elist.length+1;
                  _elist[n++] = new Comment(_crex.match(2), this);
                  so._src = prune(_crex.post);
               }
               else
               {
                  // It is element body text of some sort
                  int limit = indexOf(so._src, '<');
                  if (limit == -1)
                  {
                     so.setErr("Tag or closing tag expected after element text");
                     return;
                  }
                  char[] t = rprune(so._src[0 .. limit]);
                  _elist.length = _elist.length+1;
                  _elist[n++] = new EText(t, this);
                  so._src = so._src[limit .. $];   // no need to prune
               }
            }
         }
         this._valid = true;
      }

      /**
       * Get the Tag name - same as PText().
       */
      char[] Name() { return _name; }

      /**
       * Get the element type - in this case TAG.
       */
      int EType() { return TAG; }

      /**
       * Get a plain text version - in this case simply the Tag name.
       */
      char[] PText() { return _name; }

      /**
       * Get the element's parent.
       */
      Tag Parent() { return _parent; }

      private bool parse_attribs(TinyXML so, char[] as)
      {
         int pos = _asrex.find(as);
         if (pos == -1)
         {
            so.setErr("Bad attribute list - no name=\" construct found: " ~ as);
            return false;
         }
         char[] tail;
         for (int i = 0; pos != -1; i++) {
            char[] at = _asrex.match(1);
            tail = _asrex.post;
            char[] n = _asrex.pre;
            char quot = at[1];
            int q2 = std.string.find(tail, quot);
            if (q2 == -1)
            {
               so.setErr("Bad attribute list - missing closing quote: " ~ as);
               return false;
            }
            if (_wsrex.find(n) != -1)
            {
               so.setErr("Bad attribute list - space in attribute name: " ~ as);
               return false;
            }
            char[] t = tail[0 .. q2];
            char[] v = decode_entities(t);
            _attributes.addAttr(n, v);
            tail = tail[q2+1 .. tail.length];
            as = prune(tail);
            pos = _asrex.find(as);
         }
         if (tail.length) {
            pos = _wsrex.find(tail);
            if (pos != -1)
            {
               so.setErr("Bad attribute list - garbage after attributes: " ~ as);
               return false;
            }
            if (tail.length != _wsrex.match(1).length)
            {
               so.setErr("Bad attribute list - garbage after attributes: " ~ as);
               return false;
            }
         }

         return true;
      }

      /**
       * Format the text for inclusion in XML text.
       *
       * Params:
       *   s = An existing string to which the text representing this element is appended.
       *   indent = Degree to which the formatted text should be indented.
       *
       * Returns: The original string with the element text appended.
       */
      char[] format(char[] s, int indent)
      {
         char[] sp = _spaces[0 .. 3*indent];
         s ~= sp ~ "<" ~ _name;
         if (_attributes.length())
         {
               s ~= " " ~ _attributes.format();
         }
         bool mt = (_elist.length == 0);
         if (mt)
            s ~= "/>\n";
         else
         {
            s ~= ">";
            if (_elist.length == 1 && _elist[0].EType() != TAG)
            {
               s ~= _elist[0].PText() ~ "</" ~ _name ~ ">\n";
            }
            else
            {
               s ~= "\n";
               for (int i = 0; i < _elist.length; i++)
               {
                  s = _elist[i].format(s, indent+1);
               }
               s ~= sp ~ "</" ~ _name ~ ">\n";
            }
         }
         return s;
      }

      /**
       * Decode &amp;lt; and &amp;amp; to < and &.
       *
       * Params:
       *   s = The string to be decoded.
       *
       * Returns: The decoded string.
       */
      public static char[] decode_entities(char[] s)
      {
         s = std.string.replace(s