/*www.sourceforge.net/projects/tinyxmlOriginal file by Yves Berquin.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, andmust not be misrepresented as being the original software.3. This notice may not be removed or altered from any source distribution.*/#include "tinyxml.h"#ifndef TIXML_USE_STL    #include <stdlib.h>    #include <string.h>    #include <ctype.h>    #include "tinystr.h"// TiXmlString constructor, based on a C stringTiXmlString::TiXmlString (const char* instring) {    unsigned newlen;    char * newstring;    if(!instring) {        allocated = 0;        cstring = NULL;        current_length = 0;        return;    }    newlen = strlen (instring) + 1;    newstring = new char [newlen];    memcpy (newstring, instring, newlen);    // strcpy (newstring, instring);    allocated = newlen;    cstring = newstring;    current_length = newlen - 1;}// TiXmlString copy constructorTiXmlString::TiXmlString (const TiXmlString& copy) {    unsigned newlen;    char * newstring;    // Prevent copy to self!    if( &copy == this )        return;    if(! copy . allocated) {        allocated = 0;        cstring = NULL;        current_length = 0;        return;    }    newlen = copy . length () + 1;    newstring = new char [newlen];    // strcpy (newstring, copy . cstring);    memcpy (newstring, copy . cstring, newlen);    allocated = newlen;    cstring = newstring;    current_length = newlen - 1;}// TiXmlString = operator. Safe when assign own contentvoid TiXmlString ::operator = (const char * content) {    unsigned newlen;    char * newstring;    if(! content) {        empty_it ();        return;    }    newlen = strlen (content) + 1;    newstring = new char [newlen];    // strcpy (newstring, content);    memcpy (newstring, content, newlen);    empty_it ();    allocated = newlen;    cstring = newstring;    current_length = newlen - 1;}// = operator. Safe when assign own contentvoid TiXmlString ::operator = (const TiXmlString & copy) {    unsigned newlen;    char * newstring;    if(! copy . length ()) {        empty_it ();        return;    }    newlen = copy . length () + 1;    newstring = new char [newlen];    // strcpy (newstring, copy . c_str ());    memcpy (newstring, copy . c_str (), newlen);    empty_it ();    allocated = newlen;    cstring = newstring;    current_length = newlen - 1;}//// Checks if a TiXmlString contains only whitespace (same rules as isspace)//bool TiXmlString::isblank () const//{//    char * lookup;//    for (lookup = cstring; * lookup; lookup++)//        if (! isspace (* lookup))//            return false;//    return true;//}// append a const char * to an existing TiXmlStringvoid TiXmlString::append( const char* str, int len ) {    char * new_string;    unsigned new_alloc, new_size, size_suffix;    size_suffix = strlen (str);    if(len < (int) size_suffix)        size_suffix = len;    if(! size_suffix)        return;    new_size = length () + size_suffix + 1;    // check if we need to expand    if(new_size > allocated) {        // compute new size        new_alloc = assign_new_size (new_size);        // allocate new buffer        new_string = new char [new_alloc];                new_string [0] = 0;        // copy the previous allocated buffer into this one        if(allocated && cstring)            // strcpy (new_string, cstring);            memcpy (new_string, cstring, length ());        // append the suffix. It does exist, otherwize we wouldn't be expanding         // strncat (new_string, str, len);        memcpy (new_string + length (),                 str,                size_suffix);        // return previsously allocated buffer if any        if(allocated && cstring)            delete [] cstring;        // update member variables        cstring = new_string;        allocated = new_alloc;    } else {        // we know we can safely append the new string        // strncat (cstring, str, len);        memcpy (cstring + length (),                 str,                size_suffix);    }    current_length = new_size - 1;    cstring [current_length] = 0;}// append a const char * to an existing TiXmlStringvoid TiXmlString::append( const char * suffix ) {    char * new_string;    unsigned new_alloc, new_size;    new_size = length () + strlen (suffix) + 1;    // check if we need to expand    if(new_size > allocated) {        // compute new size        new_alloc = assign_new_size (new_size);        // allocate new buffer        new_string = new char [new_alloc];                new_string [0] = 0;        // copy the previous allocated buffer into this one        if(allocated && cstring)            memcpy (new_string, cstring, 1 + length ());        // strcpy (new_string, cstring);        // append the suffix. It does exist, otherwize we wouldn't be expanding         // strcat (new_string, suffix);        memcpy (new_string + length (),                 suffix,                strlen (suffix) + 1);        // return previsously allocated buffer if any        if(allocated && cstring)            delete [] cstring;        // update member variables        cstring = new_string;        allocated = new_alloc;    } else {        // we know we can safely append the new string        // strcat (cstring, suffix);        memcpy (cstring + length (),                 suffix,                 strlen (suffix) + 1);    }    current_length = new_size - 1;}// Check for TiXmlString equuivalence//bool TiXmlString::operator == (const TiXmlString & compare) const//{//    return (! strcmp (c_str (), compare . c_str ()));//}unsigned TiXmlString::length () const {    if(allocated)        // return strlen (cstring);        return current_length;    return 0;}unsigned TiXmlString::find (char tofind, unsigned offset) const {    char * lookup;    if(offset >= length ())        return(unsigned) notfound;    for(lookup = cstring + offset; * lookup; lookup++)        if(* lookup == tofind)            return lookup - cstring;    return(unsigned) notfound;}bool TiXmlString::operator == (const TiXmlString & compare) const {    if( allocated && compare.allocated ) {        assert( cstring );        assert( compare.cstring );        return( strcmp( cstring, compare.cstring ) == 0 );    }    return false;}bool TiXmlString::operator < (const TiXmlString & compare) const {    if( allocated && compare.allocated ) {        assert( cstring );        assert( compare.cstring );        return( strcmp( cstring, compare.cstring ) > 0 );    }    return false;}bool TiXmlString::operator > (const TiXmlString & compare) const {    if( allocated && compare.allocated ) {        assert( cstring );        assert( compare.cstring );        return( strcmp( cstring, compare.cstring ) < 0 );    }    return false;}#endif	// TIXML_USE_STL