IXMLParser.h

Go to the documentation of this file.

/****************************************************************************/
#ifndef __INCLUDE_IXML_NODE__
#define __INCLUDE_IXML_NODE__

#include <stdlib.h>

#if defined(UNICODE) || defined(_UNICODE)
// If you comment the next "define" line then the library will never "switch to" _UNICODE (wchar_t*) mode (16/32 bits per characters).
// This is useful when you get error messages like:
//    'IXMLNode::openFileHelper' : cannot convert parameter 2 from 'const char [5]' to 'const wchar_t *'
// The _XMLWIDECHAR preprocessor variable force the IXMLParser library into either utf16/32-mode (the proprocessor variable
// must be defined) or utf8-mode(the pre-processor variable must be undefined).
#define _XMLWIDECHAR
#endif

#if defined(WIN32) || defined(UNDER_CE) || defined(_WIN32) || defined(WIN64) || defined(__BORLANDC__)
// comment the next line if you are under windows and the compiler is not Microsoft Visual Studio (6.0 or .NET) or Borland
#define _XMLWINDOWS
#endif

#ifdef XMLDLLENTRY
#undef XMLDLLENTRY
#endif
#ifdef _USE_XMLPARSER_DLL
#ifdef _DLL_EXPORTS_
#define XMLDLLENTRY __declspec(dllexport)
#else
#define XMLDLLENTRY __declspec(dllimport)
#endif
#else
#define XMLDLLENTRY
#endif

// uncomment the next line if you want no support for wchar_t* (no need for the <wchar.h> or <tchar.h> libraries anymore to compile)
//#define XML_NO_WIDE_CHAR

#ifdef XML_NO_WIDE_CHAR
#undef _XMLWINDOWS
#undef _XMLWIDECHAR
#endif

#ifdef _XMLWINDOWS
#include <tchar.h>
#else
#define XMLDLLENTRY
#ifndef XML_NO_WIDE_CHAR
#include <wchar.h> // to have 'wcsrtombs' for ANSI version
                   // to have 'mbsrtowcs' for WIDECHAR version
#endif
#endif

// Some common types for char set portable code
#ifdef _XMLWIDECHAR
    #define _CXML(c) L ## c
    typedef const wchar_t *IXMLCStr;
    typedef wchar_t *IXMLStr;
    typedef wchar_t IXMLChar;
#else
    #define _CXML(c) c
    typedef const char *IXMLCStr;
    typedef char *IXMLStr;
    typedef char IXMLChar;
#endif

#ifndef FALSE
#define FALSE 0
#endif /* FALSE */
#ifndef TRUE
#define TRUE 1
#endif /* TRUE */

typedef enum IXMLError
{
    IXMLError_None = 0,
    IXMLError_MissingEndTag,
    IXMLError_NoXMLTagFound,
    IXMLError_Empty,
    IXMLError_UnmatchedEndTag,
    IXMLError_UnmatchedEndClearTag,
    IXMLError_FileNotFound,
    IXMLError_FirstTagNotFound,
    IXMLError_UnknownCharacterEntity,
    IXMLError_CharacterCodeAbove255,
    IXMLError_invalidCharInTagName,
    IXMLError_invalidCharInEndTagName,
    IXMLError_invalidCharAtTagEnd,
    IXMLError_invalidCharAtPIEnd,
    IXMLError_AttributeWithNoEqualSign,
    IXMLError_QuoteOrDoubleQuoteExpected,
    IXMLError_CharConversionModeError,
    IXMLError_MaxMemoryReached,
    IXMLError_MemoryAllocationError,
    IXMLError_readError,
    IXMLError_CannotOpenWriteFile,
    IXMLError_CannotWriteFile,

    IXMLError_Base64DataSizeIsNotMultipleOf4,
    IXMLError_Base64DecodeIllegalCharacter,
    IXMLError_Base64DecodeTruncatedData,
    IXMLError_Base64DecodeBufferTooSmall
} IXMLError;


typedef struct IXMLResults {
    IXMLError errorCode;
    long long nLine;
    int nColumn;
} IXMLResults;

typedef struct IXMLClear {
    IXMLCStr sValue,sOpenTag,sCloseTag;
    int szValue;
} IXMLClear;

typedef struct IXMLAttribute {
    IXMLCStr sName,sValue;
    int szValue;
} IXMLAttribute;

class ITCXMLNode;
class ICXMLNode;


class XMLDLLENTRY IXMLReader{
public:
    IXMLReader(){}
    virtual ~IXMLReader(){}
    virtual int read(unsigned char *buffer,int nbyte)=0; 

    virtual void setNormalBufferSize(int nbyte){}
    virtual void setSource(IXMLReader *source){} 
    virtual IXMLReader *getSource(){return NULL;} 
    virtual void reset(){} 
};

class XMLDLLENTRY IXMLReaderFile: public IXMLReader {
public:
    IXMLReaderFile(IXMLCStr filename);
    ~IXMLReaderFile();
    int read(unsigned char *buffer,int nbyte);
    void reset();
    void *f;
};

class XMLDLLENTRY IXMLReaderStringSZ: public IXMLReader {
public:
    IXMLReaderStringSZ(IXMLCStr b);
    int read(unsigned char *buffer,int nbyte);
    unsigned char *b,*bend;
};



class XMLDLLENTRY IPullParser 
{
public:
    IPullParser(IXMLReader *_uReader,int _szByteBuffer);
    virtual ~IPullParser(){}

    char setBufferSize(int _szByteBuffer);   

    virtual void reset();  

    virtual void clear()=0; 

    typedef enum IXMLToken {
        IXMLToken_StartDocument=0,
        IXMLToken_StartTag=1,
        IXMLToken_EndTag=2,
        IXMLToken_Text=3,
        IXMLToken_Clear=4,
        IXMLToken_ProcessingInstruction=5,
        IXMLToken_EndDocument=6,
        IXMLToken_Warning=7,
        IXMLToken_Error=8
    } IXMLToken;
    virtual IXMLToken nextToken()=0;     
    IXMLToken currentToken() const;      

    bool findPath(IXMLCStr path, IXMLChar sep='/', IXMLResults *r=NULL);      
    bool findPathNonConst(IXMLStr path,IXMLChar sep='/', IXMLResults *r=NULL);

    IXMLCStr getName() const;      
    bool isEmptyNode() const;      

    bool isArrayStart() const;                         

    int nAttribute() const;                            
    IXMLAttribute *getAttribute(int i=0) const;        
    IXMLCStr getAttributeName(int i=0) const;          
    IXMLCStr getAttributeValue(int i=0) const;         
    int szAttributeValue(int i=0) const;               

    IXMLCStr getText() const;                          
    int szText() const;                                
    bool isTextWhiteSpace() const;                     

    const IXMLClear *getClear() const;                 

    IXMLError getErrorCode() const;                    
    long long getLineNumber() const;                   
    virtual int getColumnNumber() const;               
    int getDepth() const;                              

    // setup
    void setAutoDetectSourceEncoding(bool autoDetectSource=false);
    bool getAutoDetectSourceEncoding();

    typedef enum IXMLCharEncoding
    {
        char_encoding_error=0,
        char_encoding_UTF16=1,
        char_encoding_UTF8=2,
        char_encoding_System=3,
        char_encoding_legacy=4,
        char_encoding_ShiftJIS=5,
        char_encoding_GB2312=6,
        char_encoding_Big5=7,
        char_encoding_GBK=8     // this is actually the same as Big5
    } IXMLCharEncoding;

#ifdef _XMLWIDECHAR
    virtual char setSourceCharEncoding(IXMLCharEncoding e=char_encoding_UTF16);
#else
    virtual char setCharEncoding(IXMLCharEncoding sourceEncoding=char_encoding_UTF8, IXMLCharEncoding destinationEncoding=char_encoding_UTF8);
    virtual IXMLCharEncoding getCharEncodingDestination();
#endif

    IXMLCStr getVersion(); 
    static IXMLCStr getErrorMessage(IXMLError error); 

protected:
    // These are functions and structures used internally by the IXMLPullParser class (don't bother about them):
    IXMLReader *uReader,*sourceUReader;
    IXMLAttribute *allAttributes;
    int szByteBuffer,_nAttribute;
    IXMLToken curToken;
    int depth,_szText;
    long long nLine;
    bool _isEmptyNode,_isIgnorableSpace,_isInArray;
    IXMLError lastError;
    IXMLClear curClearTag;
    IXMLStr pContent;

    bool autoDetectSource;
    IXMLCharEncoding characterEncoding;
    const char *XML_ByteTable;

    bool skipBranch(int skipVar);

    class IXMLReader_ToUTF16: public IXMLReader{
    public:
        IXMLReader_ToUTF16(IXMLReader *r);
        ~IXMLReader_ToUTF16();
        void setNormalBufferSize(int nbyte);
        void setSource(IXMLReader *source);
        IXMLReader *getSource();
        int read(unsigned char *buffer,int nbyte);
        void reset();
        IXMLCharEncoding sourceEncoding; // system or utf8
        IXMLReader *r;
        int bufferSz,len,mbstate;
        unsigned char *b;
    };
    class IXMLReader_FromUTF16: public IXMLReader{
    public:
        IXMLReader_FromUTF16(IXMLReader *r);
        ~IXMLReader_FromUTF16();
        void setNormalBufferSize(int nbyte);
        void setSource(IXMLReader *source);
        IXMLReader *getSource();
        int read(unsigned char *buffer,int nbyte);
        void reset();
        IXMLCharEncoding destEncoding; // system or utf8
        IXMLReader *r;
        int bufferSz,len,mbstate;
        unsigned char *b;
    };
    class IXMLReader_PassThrough: public IXMLReader{
    public:
        IXMLReader_PassThrough(IXMLReader *r);
        int read(unsigned char *buffer,int nbyte);
        unsigned char b[512],*pos,*bEnd;
        IXMLReader *r;
        void skipBOM();
        int nByteRead();
    };
    IXMLReader_ToUTF16 charEncodingConverterToUTF16;
    IXMLReader_FromUTF16 charEncodingConverterFromUTF16;

    unsigned char *bufferChar;
    IXMLStr pCurrentPos,pEndPos,pStartOfLine;
    bool isStreamFinished;
    char readData(IXMLStr *ptr,IXMLStr *pend,IXMLStr *ptrOut,IXMLStr *pStart);
};


class XMLDLLENTRY IXMLPullParser : public IPullParser 
{
public:
    IXMLPullParser(IXMLReader *uReader,int _szByteBuffer=1024*1024);
    ~IXMLPullParser();

    void reset();                  

    void clear();
    IXMLToken nextToken();         
    int getColumnNumber() const;   

    static IXMLCStr guessXMLCharEncoding(unsigned char *b,int l, IXMLChar out[200]); 
    static IXMLCharEncoding guessXMLCharEncodingCode(unsigned char *b,int l); 

private:
// These are functions and structures used internally by the IXMLPullParser class (don't bother about them):
    int maxAttribute;
    int nextChar,nextDepth;

    char parseNameAndAttributes(IXMLStr *_ptr, int *c);
    inline char parseEndTag(IXMLStr *_ptr);
    char processText(IXMLChar delim,IXMLStr *_ptr, int *nextChar, int *len);
    char findClearTagEnd(IXMLStr *ptr,IXMLCStr closeTag,int closeTagLen);
};

class XMLDLLENTRY IJSONPullParser: public IPullParser
{
public:
    IJSONPullParser(IXMLReader *uReader,int _szByteBuffer=1024*1024);
    ~IJSONPullParser();

    void reset();           

    void clear();
    IXMLToken nextToken();  

    void setTagNameForArrays(IXMLCStr arrayName);
    IXMLCStr getTagNameForArrays();

    static IXMLCStr guessJSONCharEncoding(unsigned char *b,int l); 
    static IXMLCharEncoding guessJSONCharEncodingCode(unsigned char *b,int l); 

private:
    IXMLStr *allCurrentTags;
    IXMLStr tagNameForArray;
    int nextChar,tagBufferSize;
    char parseStartList(IXMLStr *ptr);
    char parseString(IXMLStr *ptr);
    char parseNumber(IXMLStr *ptr, int *nextChar);
    void addToTagList(IXMLStr p,int l);
};

class XMLDLLENTRY IXMLDomParser
{
public:
    IXMLDomParser();    
    ~IXMLDomParser();
    void clear();
    void setDomMemoryBlockSize(int blockSize=1024*1024);
    int  getDomMemoryBlockSize(); 

    void setDomMaxMemorySize(size_t maxMem=0);
    int  getDomMaxMemorySize(); 

    void setDefaultPullParserWorkspaceMemorySize(int memSize=1024*1024);
    int  getDefaultPullParserWorkspaceMemorySize(); 

    void setSkipIgnorableSpaces(bool skipIgnorableSpaces=true);
    bool getSkipIgnorableSpaces(); 

    void setTrimTexts(bool trimTexts=true);
    bool getTrimTexts(); 

    void setTrimAttributes(bool trimAttributes=true);
    bool getTrimAttributes(); 

    void setRemoveClears(bool removeClears=true);
    bool getRemoveClears(); 

    void setRemoveProcessingInstructions(bool removeProcessingInstructions=true);
    bool getRemoveProcessingInstructions(); 

    bool getAutoDetectSourceEncoding(); 
    static IXMLCStr getErrorMessage(IXMLError error); 

    ITCXMLNode parseString(IXMLCStr lpIXMLString, IXMLCStr tag=NULL, IXMLResults *pResults=NULL);
    ICXMLNode  parseStringNonT(IXMLCStr lpIXMLString, IXMLCStr tag=NULL, IXMLResults *pResults=NULL);

    ITCXMLNode parseFile(IXMLCStr filename, IXMLCStr tag=NULL, IXMLResults *pResults=NULL);
    ICXMLNode  parseFileNonT(IXMLCStr filename, IXMLCStr tag=NULL, IXMLResults *pResults=NULL);

    ITCXMLNode openFileHelper(IXMLCStr filename, IXMLCStr tag=NULL);
    ICXMLNode  openFileHelperNonT(IXMLCStr filename, IXMLCStr tag=NULL);
    ITCXMLNode parse(IPullParser *pp, IXMLCStr tag=NULL, IXMLResults *pResults=NULL);
    ICXMLNode  parseNonT(IPullParser *pp, IXMLCStr tag=NULL, IXMLResults *pResults=NULL);
    ITCXMLNode parseOneChild(IPullParser *pp, IXMLResults *pResults=NULL);
    ICXMLNode  parseOneChildNonT(IPullParser *pp, IXMLResults *pResults=NULL);
#ifdef _XMLWIDECHAR
    void setAutoDetectSourceEncoding(bool autoDetectSource=true); 
    void setSourceCharEncoding(IXMLPullParser::IXMLCharEncoding e=IXMLPullParser::char_encoding_UTF16);
#else
    void setAutoDetectSourceEncoding(bool autoDetectSource=false);
    void setCharEncoding(IXMLPullParser::IXMLCharEncoding sourceEncoding=IXMLPullParser::char_encoding_UTF8, 
                         IXMLPullParser::IXMLCharEncoding destinationEncoding=IXMLPullParser::char_encoding_UTF8);
private:
    IXMLPullParser::IXMLCharEncoding destinationEncoding;
#endif

private:
// These are functions and structures used internally by the IXMLDomParser class (don't bother about them):
    IXMLPullParser::IXMLCharEncoding sourceEncoding;
    int memBufferSz,pullParserMemSz;
    bool autoDetectSource,skipIgnorableSpaces,requiresTrimText,trimAttribute,
         removeClears,removeProcessingInstructions;
    size_t maxMemDom;
    ITCXMLNode genericParse(IXMLCStr tag);
    ITCXMLNode genericParse2(bool getOneChild);
    char genericParseRecur(int iChild,int iText, int iOrder, int iClear, void *td, bool getOneChild);
    void *initNTD();

    IPullParser *pullParser;
    IXMLResults *pResults,xmlRes;
    ITCXMLNode *vChild; int nChild;
    IXMLCStr  *vText;  int nText;
    IXMLClear *vClear; int nClear;
    int       *vOrder; int nOrder;

    void *memoryManager;
};
class IXMLNode;
class ICXMLNode;


class XMLDLLENTRY ITCXMLNode
{
friend class IXMLDomParser;
friend class IXMLNode;
friend class ICXMLNode;
friend class IXMLRenderer;
public:
    IXMLCStr getName() const;                                       
    IXMLCStr getText(int i=0) const;                                
    int nText() const;                                             
    ITCXMLNode getParentNode() const;                                 
    ITCXMLNode getChildNode(int i=0) const;                           
    ITCXMLNode getChildNode(IXMLCStr name, int i)  const;              
    ITCXMLNode getChildNode(IXMLCStr name, int *i=NULL) const;         
    ITCXMLNode getChildNodeWithAttribute(IXMLCStr tagName,
                                      IXMLCStr attributeName,
                                      IXMLCStr attributeValue=NULL,
                                      int *i=NULL)  const;         
    ITCXMLNode getChildNodeByPath(IXMLCStr path, IXMLChar sep='/') const;
    ITCXMLNode getChildNodeByPathNonConst(IXMLStr path,IXMLChar sep='/') const;
    IXMLCStr getElementByPath(IXMLCStr xpath,IXMLChar sep='/') const;
    IXMLCStr getElementByPathNonConst(IXMLStr xpath,IXMLChar sep='/') const;

    int nChildNode(IXMLCStr name) const;                            
    int nChildNode() const;                                        
    IXMLAttribute getAttribute(int i=0) const;                      
    IXMLCStr      getAttributeName(int i=0) const;                  
    IXMLCStr      getAttributeValue(int i=0) const;                 
    char  isAttributeSet(IXMLCStr name) const;                      
    IXMLCStr getAttribute(IXMLCStr name, int i) const;               
    IXMLCStr getAttribute(IXMLCStr name, int *i=NULL) const;         
    int nAttribute() const;                                        
    IXMLClear getClear(int i=0) const;                              
    int nClear() const;                                            
    int nElement() const;                                          
    char isEmpty() const;                                          
    char isProcessInstruction() const;                              
    IXMLNode deepCopy() const;                                      
    ICXMLNode deepCopyConstant() const;                             
    static ITCXMLNode emptyNode();                                    
    static IXMLCStr getErrorMessage(IXMLError error); 

    ITCXMLNode(const ITCXMLNode &A);                                     
    ITCXMLNode& operator=( const ITCXMLNode& A );                        
    ITCXMLNode(): d(NULL){};
    static ITCXMLNode emptyITCXMLNode;             // you should use ITCXMLNode::emptyNode(); instead
    static IXMLClear emptyIXMLClear;
    static IXMLAttribute emptyXMLAttribute;

private:
// These are functions and structures used internally by the ITCXMLNode class (don't bother about them):

    typedef struct IXMLNodeData // to allow shallow copy and "intelligent/smart" pointers (automatic delete):
    {
        IXMLCStr                pName;           // Element name (=NULL if root)
        int                     nChild,          // Number of child nodes
                                nText,           // Number of text fields
                                nClear,          // Number of Clear fields (comments)
                                nAttribute;      // Number of attributes
        char                    isProcessInstruction;   // Whether node is an XML Process Instruction - '<?xml ?>'
        struct IXMLNodeData     *pParent;        // Pointer to parent element (=NULL if root)
        ITCXMLNode              *pChild;         // Array of child nodes
        IXMLCStr                *pText;          // Array of text fields
        IXMLClear               *pClear;         // Array of clear fields
        IXMLAttribute           *pAttribute;     // Array of attributes
        int                     *pOrder;         // order of the child_nodes,text_fields,clear_fields
        union 
        {
            int ref_count;   // for garbage collection in IXMLNode (smart pointers)
            int *memBuffer;  // for garbage collection in ICXMLNode(smart pointers)
        };
        inline void init(struct IXMLNodeData *pParent, char isDeclaration);
    } IXMLNodeData;
   IXMLNodeData *d;

   typedef enum IXMLElementType
   {
       eNodeChild=0,
       eNodeText=1,
       eNodeClear=2
   } IXMLElementType;

   int deepCopyConstantR1()const;
   ICXMLNode deepCopyConstantR2(int *nref, unsigned char **_p) const;

   ITCXMLNode(IXMLNodeData *p);
   ITCXMLNode(const ICXMLNode &A);                
   ITCXMLNode& operator=( const ICXMLNode& A );   
   ITCXMLNode(const IXMLNode &A);                 
   ITCXMLNode& operator=( const IXMLNode& A );    
};


 class XMLDLLENTRY ICXMLNode: public ITCXMLNode
{
friend class IXMLRenderer;
public:
    ICXMLNode getParentNode() const;                                 
    ICXMLNode getChildNode(int i=0) const;                           
    ICXMLNode getChildNode(IXMLCStr name, int i)  const;             
    ICXMLNode getChildNode(IXMLCStr name, int *i=NULL) const;        
    ICXMLNode getChildNodeWithAttribute(IXMLCStr tagName,
                                        IXMLCStr attributeName,
                                        IXMLCStr attributeValue=NULL,
                                        int *i=NULL)  const;         
    ICXMLNode getChildNodeByPath(IXMLCStr path, IXMLChar sep='/') const;   
    ICXMLNode getChildNodeByPathNonConst(IXMLStr  path,IXMLChar sep='/') const;
    static ICXMLNode emptyNode();                 

    ~ICXMLNode();
    ICXMLNode(const ICXMLNode &A);                
    ICXMLNode& operator=( const ICXMLNode& A );   
    ICXMLNode():ITCXMLNode(){};
    static ICXMLNode emptyICXMLNode;

private:
    inline void emptyTheNode();
};


typedef int IXMLElementPosition;

class XMLDLLENTRY IXMLNode: public ITCXMLNode
{
friend class IXMLRenderer;
friend class ITCXMLNode;
public:
    IXMLNode getParentNode() const;                                 
    IXMLNode getChildNode(int i=0) const;                           
    IXMLNode getChildNode(IXMLCStr name, int i)  const;              
    IXMLNode getChildNode(IXMLCStr name, int *i=NULL) const;         
    IXMLNode getChildNodeWithAttribute(IXMLCStr tagName,
                                        IXMLCStr attributeName,
                                        IXMLCStr attributeValue=NULL,
                                        int *i=NULL)  const;         
    IXMLNode getChildNodeByPath(IXMLCStr path, IXMLChar sep='/')const;   
    IXMLNode getChildNodeByPathNonConst(IXMLStr  path,IXMLChar sep='/')const;
    static IXMLNode emptyNode(); 

    ~IXMLNode();
    IXMLNode(const IXMLNode &A);                                     
    IXMLNode& operator=( const IXMLNode& A );                        
    IXMLNode():ITCXMLNode(){};
    static IXMLNode emptyIXMLNode;

    static IXMLNode createXMLTopNode(IXMLCStr pName=NULL, char isDeclaration=FALSE);                
    IXMLNode        addChild(IXMLCStr pName, char isDeclaration=FALSE, IXMLElementPosition pos=-1); 
    IXMLNode        addChild(IXMLNode nodeToAdd, IXMLElementPosition pos=-1);                       
    IXMLAttribute  *addAttribute(IXMLCStr pName, IXMLCStr pValuev);                                 
    IXMLCStr        addText(IXMLCStr pValue, IXMLElementPosition pos=-1);                           
    IXMLClear      *addClear(IXMLCStr pValue, IXMLCStr lpcOpen=NULL, IXMLCStr lpcClose=NULL, IXMLElementPosition pos=-1);
    IXMLCStr       updateName(IXMLCStr pName);                                                  
    IXMLAttribute *updateAttribute(IXMLAttribute *newAttribute, IXMLAttribute *oldAttribute);       
    IXMLAttribute *updateAttribute(IXMLCStr lpcNewValue, IXMLCStr lpcNewName=NULL,int i=0);       
    IXMLAttribute *updateAttribute(IXMLCStr lpcNewValue, IXMLCStr lpcNewName,IXMLCStr lpcOldName);
    IXMLCStr       updateText(IXMLCStr lpcNewValue, int i=0);                                     
    IXMLCStr       updateText(IXMLCStr lpcNewValue, IXMLCStr lpcOldValue);                        
    IXMLClear     *updateClear(IXMLCStr lpcNewContent, int i=0);                                  
    IXMLClear     *updateClear(IXMLClear *newP,IXMLClear *oldP);                                    
    IXMLClear     *updateClear(IXMLCStr lpcNewValue, IXMLCStr lpcOldValue);                       


    void deleteNodeContent();
    void deleteAttribute(int i=0);                   
    void deleteAttribute(IXMLCStr pName);          
    void deleteAttribute(IXMLAttribute *anAttribute); 
    void deleteText(int i=0);                        
    void deleteText(IXMLCStr pValue);              
    void deleteClear(int i=0);                       
    void deleteClear(IXMLCStr pValue);             
    void deleteClear(IXMLClear *p);                   

    static IXMLNode createXMLTopNode_WOSD(IXMLStr pName, char isDeclaration=FALSE);                     
    IXMLNode        addChild_WOSD(IXMLStr pName, char isDeclaration=FALSE, IXMLElementPosition pos=-1);  
    IXMLAttribute  *addAttribute_WOSD(IXMLStr pName, IXMLStr pValue);                                 
    IXMLCStr        addText_WOSD(IXMLStr pValue, IXMLElementPosition pos=-1);                            
    IXMLClear      *addClear_WOSD(IXMLStr pValue, IXMLCStr lpcOpen=NULL, IXMLCStr lpcClose=NULL, IXMLElementPosition pos=-1); 

    IXMLCStr        updateName_WOSD(IXMLStr pName);                                                  
    IXMLAttribute  *updateAttribute_WOSD(IXMLAttribute *newAttribute, IXMLAttribute *oldAttribute);      
    IXMLAttribute  *updateAttribute_WOSD(IXMLStr lpcNewValue, IXMLStr lpcNewName=NULL,int i=0);        
    IXMLAttribute  *updateAttribute_WOSD(IXMLStr lpcNewValue, IXMLStr lpcNewName,IXMLCStr lpcOldName); 
    IXMLCStr        updateText_WOSD(IXMLStr lpcNewValue, int i=0);                                     
    IXMLCStr        updateText_WOSD(IXMLStr lpcNewValue, IXMLCStr lpcOldValue);                        
    IXMLClear      *updateClear_WOSD(IXMLStr lpcNewContent, int i=0);                                  
    IXMLClear      *updateClear_WOSD(IXMLClear *newP,IXMLClear *oldP);                                   
    IXMLClear      *updateClear_WOSD(IXMLStr lpcNewValue, IXMLCStr lpcOldValue);                       

    IXMLElementPosition positionOfText(int i=0) const;
    IXMLElementPosition positionOfText(IXMLCStr pValue) const;
    IXMLElementPosition positionOfClear(int i=0) const;
    IXMLElementPosition positionOfClear(IXMLCStr pValue) const;
    IXMLElementPosition positionOfClear(IXMLClear *a) const;
    IXMLElementPosition positionOfChildNode(int i=0) const;
    IXMLElementPosition positionOfChildNode(IXMLNode x) const;
    IXMLElementPosition positionOfChildNode(IXMLCStr name, int i=0) const; 

private:
// These are functions used internally by the IXMLNode class (don't bother about them):
    IXMLNode(IXMLNodeData *pParent, IXMLStr pName, char isDeclaration);
    void *addToOrder(int *_pos, int nc, void *p, int size, IXMLElementType xtype);
    int indexText(IXMLCStr pValue) const;
    int indexClear(IXMLCStr pValue) const;
    IXMLNode addChild_priv(IXMLStr,char,int);
    IXMLAttribute *addAttribute_priv(IXMLStr,IXMLStr);
    IXMLCStr addText_priv(IXMLStr,int);
    IXMLClear *addClear_priv(IXMLStr,IXMLCStr,IXMLCStr,int);
    void emptyTheNode(char force);
    static inline IXMLElementPosition findPosition(IXMLNodeData *d, int index, IXMLElementType xtype);
    static int removeOrderElement(IXMLNodeData *d, IXMLElementType t, int index);
    static int detachFromParent(IXMLNodeData *d);
};



class XMLDLLENTRY ToIXMLStringTool
{
public:
    typedef enum IXMLStringLocation
    {
        IXMLStringLocation_unknown=0,
        IXMLStringLocation_inAttribute=1,
        IXMLStringLocation_inText=2
    } IXMLStringLocation;

    ToIXMLStringTool(IXMLStringLocation loc=IXMLStringLocation_unknown);
    ~ToIXMLStringTool();
    void clear();
    void setLocation(IXMLStringLocation loc=IXMLStringLocation_unknown);
    IXMLStringLocation getLocation();

    IXMLStr toXML(IXMLCStr source);

    IXMLStr toXMLUnSafe(IXMLStr dest,IXMLCStr source); 
    int lengthXMLString(IXMLCStr source);              

#ifndef _XMLWIDECHAR
    char setCharEncoding(IXMLPullParser::IXMLCharEncoding encoding=IXMLPullParser::char_encoding_UTF8);
    IXMLPullParser::IXMLCharEncoding getCharEncoding();
private:
// These are functions and structures used internally by the ToIXMLStringTool class (don't bother about them):
    const char *XML_ByteTable;
    IXMLPullParser::IXMLCharEncoding characterEncoding;
#endif

private:
    IXMLStr buf;
    int buflen;
    IXMLStringLocation loc;
    void *curXMLEntities;
};

class XMLDLLENTRY IXMLRenderer
{
public:
    IXMLRenderer();
    ~IXMLRenderer();
    static IXMLCStr getErrorMessage(IXMLError error); 

    IXMLCStr getString(ITCXMLNode x, int nFormat=1, int *pnSize=NULL); 
    IXMLCStr getString(ICXMLNode x, int nFormat=1, int *pnSize=NULL);  
    IXMLCStr getString(IXMLNode x, int nFormat=1, int *pnSize=NULL);   
    int szString(); 
    void clear();

    IXMLError writeToFile(ITCXMLNode x, IXMLCStr filename,IXMLCStr encoding=NULL,char nFormat=1); 
    IXMLError writeToFile(ICXMLNode x, IXMLCStr filename,IXMLCStr encoding=NULL,char nFormat=1);  
    IXMLError writeToFile(IXMLNode x, IXMLCStr filename,IXMLCStr encoding=NULL,char nFormat=1);   

#ifndef _XMLWIDECHAR
    void setCharEncoding(IXMLPullParser::IXMLCharEncoding e=IXMLPullParser::char_encoding_UTF8);
    IXMLPullParser::IXMLCharEncoding getCharEncoding();
private:
    IXMLPullParser::IXMLCharEncoding characterEncoding;
#endif

private:
// These are functions and structures used internally by the IXMLRenderer class (don't bother about them):
    IXMLStr buf;
    int maxStrLen,sz;
    ToIXMLStringTool txAtt,txTxt;
    int getStringR(ITCXMLNode::IXMLNodeData *pEntry, IXMLStr lpcMarker, int nFormat);
};

XMLDLLENTRY IXMLStr IXMLStringDup(IXMLCStr source, int cbData=-1);

XMLDLLENTRY void freeIXMLString(IXMLStr t); // {free(t);}
// XMLDLLENTRY char      xmltob(IXMLCStr s,char defautValue=0);
// XMLDLLENTRY int       xmltoi(IXMLCStr s,int defautValue=0);
// XMLDLLENTRY long long xmltol(IXMLCStr s,long long defautValue=0);
// XMLDLLENTRY double    xmltof(IXMLCStr s,double defautValue=.0);
// XMLDLLENTRY IXMLCStr  xmltoa(IXMLCStr s,IXMLCStr defautValue=_CXML(""));
// XMLDLLENTRY IXMLChar  xmltoc(IXMLCStr s,const IXMLChar defautValue=_CXML('\0'));


class XMLDLLENTRY IXMLParserBase64Tool
{
public:
    IXMLParserBase64Tool(): buf(NULL),buflen(0){}
    ~IXMLParserBase64Tool();
    void clear();

    static int encodeLength(int inBufLen, char formatted=0); 

    IXMLStr encode(unsigned char *inByteBuf, unsigned int inByteLen, char formatted=0); 

    static unsigned int decodeSize(IXMLCStr inString, IXMLError *xe=NULL);

    unsigned char* decode(IXMLCStr inString, int *outByteLen=NULL, IXMLError *xe=NULL); 

    static unsigned char decode(IXMLCStr inString, unsigned char *outByteBuf, int inMaxByteOutBuflen, IXMLError *xe=NULL); 

private:
    void *buf;
    int buflen;
    void alloc(int newsize);
};
#undef XMLDLLENTRY

#endif