root/trunk/tinyxml.d

/*
www.sourceforge.net/projects/tinyxml
Original code (2.0 and earlier )copyright (c) 2000-2002 Lee Thomason (www.grinninglizard.com)

This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any
damages arising from the use of this software.

Permission is granted to anyone to use this software for any
purpose, including commercial applications, and to alter it and
redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must
not claim that you wrote the original software. If you use this
software in a product, an acknowledgment in the product documentation
would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and
must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source
distribution.
*/
public import std.stream;
public import std.string;


private import std.stdio;

private import std.uni;
private import xpath.utf8;
private import std.ctype;
public import std.cstream;
public import xpath.xpath_stream;
public {
enum TiXmlEncoding
{
    TIXML_ENCODING_UNKNOWN,
    TIXML_ENCODING_UTF8,
    TIXML_ENCODING_LEGACY
};
}
private 
{
    debug{
        alias writefln TIXML_LOG;
    }
        
    import std.utf;
    const char TIXML_UTF_LEAD_0 = 0xefU;
    const char TIXML_UTF_LEAD_1 = 0xbbU;
    const char TIXML_UTF_LEAD_2 = 0xbfU;

    class TiXmlParsingData
    {
        
        public {
            void Stamp( char[] now, TiXmlEncoding encoding )
            in { assert( ! (now is null) ); assert(now.length > 0); }
            body
            {
                // Do nothing if the tabsize is 0.
            }

            
            TiXmlCursor Cursor()    { return cursor; }
        }
        protected{
        // Only used by the document!
            this( char[] start, int _tabsize, int row, int col )
            {
                stamp = start;
                tabsize = _tabsize;
                cursor.row = row;
                cursor.col = col;
            }
        }
    
        TiXmlCursor     cursor;
        char[]      stamp;
        int             tabsize;
    };


}
public {
/+
#ifndef USE_MMGR
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#endif

// Help out windows:
#if defined( _DEBUG ) && !defined( DEBUG )
#define DEBUG
#endif

#ifdef TIXML_USE_STL
    #include <string>
    #include <iostream>
    #define TIXML_STRING    std::string
    #define TIXML_ISTREAM   std::istream
    #define TIXML_OSTREAM   std::ostream
#else
    #include "tinystr.h"
    #define TIXML_STRING    TiXmlString
    #define TIXML_OSTREAM   TiXmlOutputStream
#endif
+/

const int TIXML_MAJOR_VERSION = 2;
const int TIXML_MINOR_VERSION = 4;
const int TIXML_PATCH_VERSION = 3;
const int NUM_ENTITY = 5;

/*  Internal structure for tracking location of items 
    in the XML file.
*/
struct TiXmlCursor
{
    void Clear()        { row = row.init; col = col.init; }
    int row = -1;   // 0 based.
    int col = -1;   // 0 based.
};


// Only used by Attribute::Query functions
enum AttributeQueryEnum
{ 
    TIXML_SUCCESS,
    TIXML_NO_ATTRIBUTE,
    TIXML_WRONG_TYPE
};


// Used by the parsing routines.

const TiXmlEncoding TIXML_DEFAULT_ENCODING = TiXmlEncoding.TIXML_ENCODING_UNKNOWN;

/** TiXmlBase is a base class for every class in TinyXml.
    It does little except to establish that TinyXml classes
    can be printed and provide some utility functions.

    In XML, the document and elements can contain
    other elements and other types of nodes.

    @verbatim
    A Document can contain: Element (container or leaf)
                            Comment (leaf)
                            Unknown (leaf)
                            Declaration( leaf )

    An Element can contain: Element (container or leaf)
                            Text    (leaf)
                            Attributes (not on tree)
                            Comment (leaf)
                            Unknown (leaf)

    A Decleration contains: Attributes (not on tree)
    @endverbatim
*/
class TiXmlBase
{
    public {
    this() { userData = null; }

    /** All TinyXml classes can print themselves to a filestream.
        This is a formatted print, and will insert tabs and newlines.
        
        (For an unformatted stream, use the << operator.)
    */
    abstract void Print( Stream Stream, int depth );

    /** The world does not agree on whether white space should be kept or
        not. In order to make everyone happy, these global, static functions
        are provided to set whether or not TinyXml will condense all white space
        into a single space or not. The default is to condense. Note changing this
        values is not thread safe.
    */
    static void SetCondenseWhiteSpace( bool condense )      { condenseWhiteSpace = condense; }

    /// Return the current white space setting.
    static bool IsWhiteSpaceCondensed()                     { return condenseWhiteSpace; }

    /** Return the position, in the original source file, of this node or attribute.
        The row and column are 1-based. (That is the first row and first column is
        1,1). If the returns values are 0 or less, then the parser does not have
        a row and column value.

        Generally, the row and column value will be set when the TiXmlDocument::Load(),
        TiXmlDocument::LoadFile(), or any TiXmlNode::Parse() is called. It will NOT be set
        when the DOM was created from operator>>.

        The values reflect the initial load. Once the DOM is modified programmatically
        (by adding or changing nodes and attributes) the new values will NOT update to
        reflect changes in the document.

        There is a minor performance cost to computing the row and column. Computation
        can be disabled if TiXmlDocument::SetTabSize() is called with 0 as the value.

        @sa TiXmlDocument::SetTabSize()
    */
    int Row() { return location.row + 1; }
    int Column() { return location.col + 1; }   ///< See Row()

    void  SetUserData( void* user )         { userData = user; }
    void* GetUserData()                     { return userData; }

    // Table that returns, for a given lead byte, the total number of bytes
    // in the UTF-8 sequence.
    static const int utf8ByteTable[256];

    abstract char[] Parse(  char[] p, 
                                TiXmlParsingData data, 
                                TiXmlEncoding encoding /*= TIXML_ENCODING_UNKNOWN */ );

    enum TiXmlError
    {
        TIXML_NO_ERROR = 0,
        TIXML_ERROR,
        TIXML_ERROR_OPENING_FILE,
        TIXML_ERROR_OUT_OF_MEMORY,
        TIXML_ERROR_PARSING_ELEMENT,
        TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME,
        TIXML_ERROR_READING_ELEMENT_VALUE,
        TIXML_ERROR_READING_ATTRIBUTES,
        TIXML_ERROR_PARSING_EMPTY,
        TIXML_ERROR_READING_END_TAG,
        TIXML_ERROR_PARSING_UNKNOWN,
        TIXML_ERROR_PARSING_COMMENT,
        TIXML_ERROR_PARSING_DECLARATION,
        TIXML_ERROR_DOCUMENT_EMPTY,
        TIXML_ERROR_EMBEDDED_NULL,
        TIXML_ERROR_PARSING_CDATA,
        TIXML_ERROR_DOCUMENT_TOP_ONLY,

        TIXML_ERROR_STRING_COUNT
    };
    }
protected{

    static char[]   SkipWhiteSpace( char[] op, TiXmlEncoding encoding )
    {
        return stripl(op);
        /*
        if (!op || op.length == 0)
            return null;
        int p = 0;
        if ( encoding == TiXmlEncoding.TIXML_ENCODING_UTF8 )
        {
            for (p = 0; p < op.length; ++p)
            {
                //const unsigned char* pU = (const unsigned char*)p;
                
                // Skip the stupid Microsoft UTF-8 Byte order marks
                if (    op[p]==TIXML_UTF_LEAD_0
                     && op[p+1]==TIXML_UTF_LEAD_1 
                     && op[p+2]==TIXML_UTF_LEAD_2 )
                {
                    p += 3;
                    continue;
                }
                else if(op[p]==TIXML_UTF_LEAD_0
                     && op[p+1]==0xbfU
                     && op[p+2]==0xbeU )
                {
                    p += 3;
                    continue;
                }
                else if(op[p]==TIXML_UTF_LEAD_0
                     && op[p+1]==0xbfU
                     && op[p+2]==0xbfU )
                {
                    p += 3;
                    continue;
                }
    
                if ( IsWhiteSpace( op[p] ) || op[p] == '\n' || op[p] =='\r' )       // Still using old rules for white space.
                    ++p;
                else
                    break;
            }
        }
        else
        {
            while ( p < op.length && IsWhiteSpace( op[p] ) || op[p] == '\n' || op[p] =='\r' )
                ++p;
        }
    
        return op[p..length];*/
    }
    
    static bool IsWhiteSpace( char c )
    { 
        return (  std.string.iswhite( c ) || c == '\n' || c == '\r' ); 
    }
    static bool IsWhiteSpace( int c )
    {
        if ( c < 256 )
            return IsWhiteSpace( cast(char) c );
        return false;   // Again, only truly correct for English/Latin...but usually works.
    }

    void StreamOut (OutputStream o);

    /*#ifdef TIXML_USE_STL
        static bool StreamWhiteSpace( TIXML_ISTREAM * in, TIXML_STRING * tag );
        static bool StreamTo( TIXML_ISTREAM * in, int character, TIXML_STRING * tag );
    #endif*/

    /*  Reads an XML name into the string provided. Returns
        a pointer just past the last character of the name,
        or 0 if the function has an error.
    */
    static char[] ReadName( char[] p, out char[] name, TiXmlEncoding encoding )
    in
    { assert(p); }
    body
    {
        name = "";
    
        // Names start with letters or underscores.
        // Of course, in unicode, tinyxml has no idea what a letter *is*. The
        // algorithm is generous.
        //
        // After that, they can be letters, underscores, numbers,
        // hyphens, or colons. (Colons are valid ony for namespaces,
        // but tinyxml can't tell namespaces from names.)
        int i = 0;
        
        if ( p && p.length > 0
             && ( IsAlpha( cast(ubyte) p[0], encoding ) || p[0] == '_' ) )
        {
            while( i < p.length &&  ( IsAlphaNum( p[i], encoding ) 
                             || p[i] == '_'
                             || p[i] == '-'
                             || p[i] == '.'
                             || p[i] == ':' ) )
            {
                name ~= p[i];
                ++i;
            }
            return p[i..length];
        }
        return null;
    }

    /*  Reads text. Returns a pointer past the given end tag.
        Wickedly complex options, but it keeps the (sensitive) code in one place.
    */
    static int ReadText(    char[] sin,             // where to start
                                    inout char[] text,          // the string read
                                    bool ignoreWhiteSpace,      // whether to keep the white space
                                    char[] endTag,          // what ends this text
                                    bool ignoreCase,            // whether to ignore case in the end tag
                                    TiXmlEncoding encoding )    // the current encoding
/*  in { writefln("ReadText: sin='%s', endTag='%s'",replace(sin,"\n","\\n"),endTag); }
    out (o) { writefln(" returned %d (text: %s)", o, text); }
    body*/
    {
        text = "";
        int p = 0;
        if (!(!ignoreWhiteSpace         // certain tags always keep whitespace
             || !condenseWhiteSpace ))  // if true, whitespace is always kept
             sin = SkipWhiteSpace( sin, encoding );
             
        p = (!ignoreCase)?(find(sin, endTag)):(ifind(sin,endTag));
        if (p == -1)
        {
            text = sin;
            return sin.length;
        }
        else
        {
            text = sin[0..p];
            return p + endTag.length;
        }
    }

                                    
                                    
                                    

    // If an entity has been found, transform it into a character.
    static int GetEntity( char[] sin, inout char[] value, inout int length, TiXmlEncoding encoding )
    {
        // Presume an entity, and pull it out.
        char[] ent;
        int delta;
        int i;
        length = 0;
    
        if ( sin.length > 2 && sin[1] == '#' )
        {
            ulong ucs = 0;
            //ptrdiff_t delta = 0;
            uint mult = 1;
    
            if ( sin[2] == 'x' )
            {
                if (sin.length < 3) return 0;
                // Hexadecimal.
    
                char[] q = sin[3..length];

                delta = find(q, ';');
                if (delta == -1)
                    return 0;
                    
                int _q = delta-1;
    
                while ( q[_q] != 'x' )
                {
                    if ( q[_q] >= '0' && q[_q] <= '9' )
                        ucs += mult * (q[_q] - '0');
                    else if ( q[_q] >= 'a' && q[_q] <= 'f' )
                        ucs += mult * (*q - 'a' + 10);
                    else if ( q[_q] >= 'A' && q[_q] <= 'F' )
                        ucs += mult * (*q - 'A' + 10 );
                    else 
                        return 0;
                    mult *= 16;
                    --_q;
                }
            }
            else
            {
                // Decimal.
                if (sin.length < 3) return 0;
                
                char[] q = sin[2..length];
                delta = find(q, ';');
                if ( delta == -1 ) return 0;
                int _q = delta-1;
                --_q;
                
                while ( q[_q] != '#' )
                {
                    if ( q[_q] >= '0' && q[_q] <= '9' )
                        ucs += mult * (q[_q] - '0');
                    else 
                        return 0;
                    mult *= 10;
                    --_q;
                }
            }
            if ( encoding == TiXmlEncoding.TIXML_ENCODING_UTF8 )
            {
                ConvertUTF32ToUTF8( ucs, value, length );
            }
            else
            {
                value[0] = cast(char)ucs;
                length = 1;
            }
            return delta + 1;
        }
    
        // Now try to match it.
        for( i=0; i<NUM_ENTITY; ++i )
        {
            if ( entity[i].str == sin )
            {
                value[0] = entity[i].chr;
                length = 1;
                return entity[i].str.length;
            }
        }
    
        // So it wasn't an entity, its unrecognized, or something like that.
        value[0] = sin[0];  // Don't put back the last one, since we return it!
        length = 1;         // Leave unrecognized entities - this doesn't really work.
                        // Just writes strange XML.
        return 1;
    }


    // Get a character, while interpreting entities.
    // The length can be from 0 to 4 bytes.
    static int GetChar( char[] sin, inout char[] _value, inout int length, TiXmlEncoding encoding )
    in { assert(sin); }
    body
    {
        if ( encoding == TiXmlEncoding.TIXML_ENCODING_UTF8 )
        {
            length = utf8ByteTable[ sin[0] ];
            assert( length >= 0 && length < 5 );
        }
        else
        {
            length = 1;
        }

        if ( length == 1 )
        {
            if ( sin[0] == '&' )
                return GetEntity( sin, _value, length, encoding );
            _value = sin;
            return 1;
        }
        else if ( length > 0 )
        {
            for( int i=0; i < sin.length && i<length; ++i ) {
                _value[i] = sin[i];
            }
            return length;
        }
        else
        {
            return 0;
        }
    }

    // Puts a string to a stream, expanding entities as it goes.
    // Note this should not contian the '<', '>', etc, or they will be transformed into entities!
    static void PutString( char[] str, OutputStream outs )
    {
        char[] buffer;
        PutString( str, buffer );
        outs.writeString(buffer);
    }

    static void PutString( char[] str, out char[] outString )
    {
        int i=0;
    
        foreach (int i,char c;str)
        {
            ubyte _c = cast(ubyte) str[i];
    
            if ( _c == '&' 
                 && i < ( str.length - 2 )
                 && str[i+1] == '#'
                 && str[i+2] == 'x' )
            {
                // Hexadecimal character reference.
                // Pass through unchanged.
                // &#xA9;   -- copyright symbol, for example.
                //
                // The -1 is a bug fix from Rob Laveaux. It keeps
                // an overflow from happening if there is no ';'.
                // There are actually 2 ways to exit this loop -
                // while fails (error case) and break (semicolon found).
                // However, there is no mechanism (currently) for
                // this function to return an error.
                while ( i<str.length-1 )
                {
                    outString ~= str[i];
                    ++i;
                    if ( str[i] == ';' )
                        break;
                }
            }
            else if ( c == '&' )
            {
                outString ~= entity[0].str; 
                ++i;
            }
            else if ( c == '<' )
            {
                outString ~= entity[1].str; 
            }
            else if ( c == '>' )
            {
                outString ~= entity[2].str; 
                ++i;
            }
            else if ( c == '\"' )
            {
                outString ~= entity[3].str; 
                ++i;
            }
            else if ( c == '\'' )
            {
                outString ~= entity[4].str; 
                ++i;
            }
            else if ( c < 32 )
            {
                // Easy pass at non-alpha/numeric/symbol
                // Below 32 is symbolic.
                char[] buf = format("&#x%02X;", cast(uint) ( c & 0xff ));
                

                outString ~= buf;
                ++i;
            }
            else
            {
                outString ~= c; // somewhat more efficient function call.
                ++i;
            }
        }
    }


    // Return true if the next characters in the stream are any of the endTag sequences.
    // Ignore case only works for english, and should only be relied on when comparing
    // to English words: StringEqual( p, "version", true ) is fine.
    static bool StringEqual(    char[] p,
                                char[] endTag,
                                bool ignoreCase,
                                TiXmlEncoding encoding )
    in { assert(p); assert(endTag); assert(p.length > 0); }
    body
    {
        if ( ignoreCase )
            return (ifind(p, endTag) == 0);
        else
            return (find(p, endTag) == 0);
    }


    static char[][] errorString = [
    "No error",
    "Error",
    "Failed to open file",
    "Memory allocation failed.",
    "Error parsing Element.",
    "Failed to read Element name",
    "Error reading Element value.",
    "Error reading Attributes.",
    "Error: empty tag.",
    "Error reading end tag.",
    "Error parsing Unknown.",
    "Error parsing Comment.",
    "Error parsing Declaration.",
    "Error document empty.",
    "Error null (0) or unexpected EOF found in input stream.",
    "Error parsing CDATA.",
    "Error when TiXmlDocument added to document, because TiXmlDocument can only be at the root.",
];

    TiXmlCursor location;

    /// Field containing a generic user pointer
    void*           userData;
    
    // None of these methods are reliable for any language except English.
    // Good for approximation, not great for accuracy.
    static int IsAlpha( ubyte anyByte, TiXmlEncoding encoding )
    {
        // This will only work for low-ascii, everything else is assumed to be a valid
        // letter. I'm not sure this is the best approach, but it is quite tricky trying
        // to figure out alhabetical vs. not across encoding. So take a very 
        // conservative approach.
        return u8isUniAlpha(cast(char)anyByte);
    }

    static int IsAlphaNum( ubyte anyByte, TiXmlEncoding encoding )
    {
        if ( anyByte < 127 )
            return (IsAlpha(anyByte,encoding) || std.ctype.isdigit(anyByte));
        else
            return 1;
    }

    
    static int ToLower( int v, TiXmlEncoding encoding )
    {
        return std.ctype.tolower(v);
    }
    static void ConvertUTF32ToUTF8( ulong input, inout char[] output, inout int length )
    {
        const ulong BYTE_MASK = 0xBF;
        const ulong BYTE_MARK