---

Parser.cpp

Go to the documentation of this file.

/* --------------------------------------------------------------
Copyright (C) 2001 LifeLine Networks BV <soap2corba@lifeline.nl>

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later
version.

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 A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-------------------------------------------------------------- */

#include "Parser.h"

static bool noInitXerces = true;

void releaseDOM (DOM_H hdl)
{
    delete (DOM_Node *) hdl;
}

DOM_H parseDOM (const unsigned char *pBuf, const unsigned long size)
{
    if (noInitXerces) {
        // Initialize the XML4C2 system
        try
        {
            XMLPlatformUtils::Initialize();
            noInitXerces = false;
        }

        catch(const XMLException& toCatch)
        {
            (void) toCatch;
            cerr << "Error during Xerces-c Initialization." << endl;
        }
    }
    DOMParser::ValSchemes gValScheme = DOMParser::Val_Never;
    bool gDoNamespaces = true;
    bool gDoCreate = true;

    DOMParser parser;
    parser.setValidationScheme(gValScheme);
    parser.setDoNamespaces(gDoNamespaces);
    DOMTreeErrorReporter errReporter;
    parser.setErrorHandler(&errReporter);
    parser.setCreateEntityReferenceNodes(gDoCreate);
    parser.setToCreateXMLDeclTypeNode(true);

    MemBufInputSource inpSrc (pBuf, size, "XmlParser", false);
    //
    //  Parse the XML file, catching any XML exceptions that might propogate
    //  out of it.
    //
    bool errorsOccured = false;
    try
    {
        parser.parse(inpSrc);
    }

    catch (const XMLException& e)
    {
        char *msg = DOMString(e.getMessage()).transcode ();
        CString Msg = "A XML exception occurred during parsing\r\nMessage: ";
        Msg += msg;
        delete msg;
        cerr << (const char *) Msg << endl;
        errorsOccured = true;
    }


    catch (const DOM_DOMException& e)
    {
        char *msg = DOMString(e.msg).transcode ();
        CString Msg = "A DOM exception occurred during parsing\r\nMessage: ";
        Msg += msg;
        delete msg;
        cerr << (const char *) Msg << endl;
        errorsOccured = true;
    }

    catch (...)
    {
        cerr << "An error occurred during parsing" << endl;
        errorsOccured = true;
    }


    if (!errorsOccured) {
        DOM_Node *pNode = new DOM_Node (parser.getDocument ());
        return pNode;
    }
    return NULL;
}

static const XMLCh  gEndElement[] = { chOpenAngle, chForwardSlash, chNull };
static const XMLCh  gEndPI[] = { chQuestion, chCloseAngle, chNull};
static const XMLCh  gStartPI[] = { chOpenAngle, chQuestion, chNull };
static const XMLCh  gXMLDecl1[] =
{
        chOpenAngle, chQuestion, chLatin_x, chLatin_m, chLatin_l
    ,   chSpace, chLatin_v, chLatin_e, chLatin_r, chLatin_s, chLatin_i
    ,   chLatin_o, chLatin_n, chEqual, chDoubleQuote, chNull
};
static const XMLCh  gXMLDecl2[] =
{
        chDoubleQuote, chSpace, chLatin_e, chLatin_n, chLatin_c
    ,   chLatin_o, chLatin_d, chLatin_i, chLatin_n, chLatin_g, chEqual
    ,   chDoubleQuote, chNull
};
static const XMLCh  gXMLDecl3[] =
{
        chDoubleQuote, chSpace, chLatin_s, chLatin_t, chLatin_a
    ,   chLatin_n, chLatin_d, chLatin_a, chLatin_l, chLatin_o
    ,   chLatin_n, chLatin_e, chEqual, chDoubleQuote, chNull
};
static const XMLCh  gXMLDecl4[] =
{
        chDoubleQuote, chQuestion, chCloseAngle
    ,   chCR, chLF, chNull
};
static const XMLCh  gStartCDATA[] =
{ 
        chOpenAngle, chBang, chOpenSquare, chLatin_C, chLatin_D,
        chLatin_A, chLatin_T, chLatin_A, chOpenSquare, chNull
};
static const XMLCh  gEndCDATA[] =
{
    chCloseSquare, chCloseSquare, chCloseAngle, chNull
};
static const XMLCh  gStartComment[] =
{ 
    chOpenAngle, chBang, chDash, chDash, chNull
};
static const XMLCh  gEndComment[] =
{
    chDash, chDash, chCloseAngle, chNull
};
static const XMLCh  gStartDoctype[] =
{ 
    chOpenAngle, chBang, chLatin_D, chLatin_O, chLatin_C, chLatin_T,
    chLatin_Y, chLatin_P, chLatin_E, chSpace, chNull
};
static const XMLCh  gPublic[] =
{ 
    chLatin_P, chLatin_U, chLatin_B, chLatin_L, chLatin_I,
    chLatin_C, chSpace, chDoubleQuote, chNull
};
static const XMLCh  gSystem[] =
{ 
    chLatin_S, chLatin_Y, chLatin_S, chLatin_T, chLatin_E,
    chLatin_M, chSpace, chDoubleQuote, chNull
};
static const XMLCh  gStartEntity[] =
{ 
    chOpenAngle, chBang, chLatin_E, chLatin_N, chLatin_T, chLatin_I,
    chLatin_T, chLatin_Y, chSpace, chNull
};
static const XMLCh  gNotation[] =
{ 
    chLatin_N, chLatin_D, chLatin_A, chLatin_T, chLatin_A,
    chSpace, chDoubleQuote, chNull
};

XMLFormatter& operator<< (XMLFormatter& strm, const DOMString& s)
{
    unsigned int lent = s.length();
    
    if (lent <= 0)
        return strm;
    
    XMLCh*  buf = new XMLCh[lent + 1];
    XMLString::copyNString(buf, s.rawBuffer(), lent);
    buf[lent] = 0;
    strm << buf;
    delete [] buf;
    return strm;
}

static void WalkXML(XMLFormatter *gFormatter, DOM_Node &toWrite)
{
    if (toWrite == NULL) return;
    // Get the name and value out for convenience
    DOMString   nodeName = toWrite.getNodeName();
    DOMString   nodeValue = toWrite.getNodeValue();
    unsigned long lent = nodeValue.length();

    switch (toWrite.getNodeType())
    {
        case DOM_Node::TEXT_NODE:
        {
            gFormatter->formatBuf(nodeValue.rawBuffer(), 
                                  lent, XMLFormatter::CharEscapes);
            break;
        }


        case DOM_Node::PROCESSING_INSTRUCTION_NODE :
        {
            *gFormatter << XMLFormatter::NoEscapes << gStartPI  << nodeName;
            if (lent > 0)
            {
                *gFormatter << chSpace << nodeValue;
            }
            *gFormatter << XMLFormatter::NoEscapes << gEndPI;
            break;
        }


        case DOM_Node::DOCUMENT_NODE :
        {
            DOMString utf8 ("UTF-8");
            if (!utf8.equals (gFormatter->getEncodingName ())) {
                DOM_Document doc = (DOM_Document &) toWrite;
                DOM_Node decl = doc.createXMLDecl ("1.0", gFormatter->getEncodingName (), 0);
                WalkXML (gFormatter, decl);
            }
            DOM_Node child = toWrite.getFirstChild();
            while( child != 0)
            {
                WalkXML (gFormatter, child);
                child = child.getNextSibling();
            }
            break;
        }


        case DOM_Node::ELEMENT_NODE :
        {
            // The name has to be representable without any escapes
            *gFormatter  << XMLFormatter::NoEscapes
                         << chOpenAngle << nodeName;

            // Output the element start tag.

            // Output any attributes on this element
            DOM_NamedNodeMap attributes = toWrite.getAttributes();
            int attrCount = attributes.getLength();
            for (int i = 0; i < attrCount; i++)
            {
                DOM_Node  attribute = attributes.item(i);

                //
                //  Again the name has to be completely representable. But the
                //  attribute can have refs and requires the attribute style
                //  escaping.
                //
                *gFormatter  << XMLFormatter::NoEscapes
                             << chSpace << attribute.getNodeName()
                             << chEqual << chDoubleQuote
                             << XMLFormatter::AttrEscapes
                             << attribute.getNodeValue()
                             << XMLFormatter::NoEscapes
                             << chDoubleQuote;
            }

            //
            //  Test for the presence of children, which includes both
            //  text content and nested elements.
            //
            DOM_Node child = toWrite.getFirstChild();
            if (child != 0)
            {
                // There are children. Close start-tag, and output children.
                // No escapes are legal here
                *gFormatter << XMLFormatter::NoEscapes << chCloseAngle;

                while( child != 0)
                {
                    WalkXML (gFormatter, child);
                    child = child.getNextSibling();
                }

                //
                // Done with children.  Output the end tag.
                //
                *gFormatter << XMLFormatter::NoEscapes << gEndElement
                            << nodeName << chCloseAngle;
            }
            else
            {
                //
                //  There were no children. Output the short form close of
                //  the element start tag, making it an empty-element tag.
                //
                *gFormatter << XMLFormatter::NoEscapes << chForwardSlash << chCloseAngle;
            }
            break;
        }
        
        
        case DOM_Node::ENTITY_REFERENCE_NODE:
            {
                DOM_Node child;
#if 0
                for (child = toWrite.getFirstChild();
                child != 0;
                child = child.getNextSibling())
                {
                    target << child;
                }
#else
                //
                // Instead of printing the refernece tree 
                // we'd output the actual text as it appeared in the xml file.
                // This would be the case when -e option was chosen
                //
                    *gFormatter << XMLFormatter::NoEscapes << chAmpersand
                        << nodeName << chSemiColon;
#endif
                break;
            }
            
            
        case DOM_Node::CDATA_SECTION_NODE:
            {
            *gFormatter << XMLFormatter::NoEscapes << gStartCDATA
                        << nodeValue << gEndCDATA;
            break;
        }

        
        case DOM_Node::COMMENT_NODE:
        {
            *gFormatter << XMLFormatter::NoEscapes << gStartComment
                        << nodeValue << gEndComment;
            break;
        }

        
        case DOM_Node::DOCUMENT_TYPE_NODE:
        {
            DOM_DocumentType doctype = (DOM_DocumentType &)toWrite;;

            *gFormatter << XMLFormatter::NoEscapes  << gStartDoctype
                        << nodeName;
 
            DOMString id = doctype.getPublicId();
            if (id != 0)
            {
                *gFormatter << XMLFormatter::NoEscapes << chSpace << gPublic
                    << id << chDoubleQuote;
                id = doctype.getSystemId();
                if (id != 0)
                {
                    *gFormatter << XMLFormatter::NoEscapes << chSpace 
                       << chDoubleQuote << id << chDoubleQuote;
                }
            }
            else
            {
                id = doctype.getSystemId();
                if (id != 0)
                {
                    *gFormatter << XMLFormatter::NoEscapes << chSpace << gSystem
                        << id << chDoubleQuote;
                }
            }
            
            id = doctype.getInternalSubset(); 
            if (id !=0)
                *gFormatter << XMLFormatter::NoEscapes << chOpenSquare
                            << id << chCloseSquare;

            *gFormatter << XMLFormatter::NoEscapes << chCloseAngle;
            break;
        }
        
        
        case DOM_Node::ENTITY_NODE:
        {
            *gFormatter << XMLFormatter::NoEscapes << gStartEntity
                        << nodeName;

            DOMString id = ((DOM_Entity &)toWrite).getPublicId();
            if (id != 0)
                *gFormatter << XMLFormatter::NoEscapes << gPublic
                            << id << chDoubleQuote;

            id = ((DOM_Entity &)toWrite).getSystemId();
            if (id != 0)
                *gFormatter << XMLFormatter::NoEscapes << gSystem
                            << id << chDoubleQuote;
            
            id = ((DOM_Entity &)toWrite).getNotationName();
            if (id != 0)
                *gFormatter << XMLFormatter::NoEscapes << gNotation
                            << id << chDoubleQuote;

            *gFormatter << XMLFormatter::NoEscapes << chCloseAngle << chCR << chLF;

            break;
        }
        
        
        case DOM_Node::XML_DECL_NODE:
        {
            DOMString  str;

            *gFormatter << gXMLDecl1 << ((DOM_XMLDecl &)toWrite).getVersion();

            *gFormatter << gXMLDecl2 << gFormatter->getEncodingName ();
            
            str = ((DOM_XMLDecl &)toWrite).getStandalone();
            if (str != 0)
                *gFormatter << gXMLDecl3 << str;
            
            *gFormatter << gXMLDecl4;

            break;
        }
        
        
        default:
            cerr <<  "Unrecognized node type in GetXML()" << endl;
            break;
    }
}

void GetXML(unsigned char * &buf, unsigned long &siz, DOM_H toWrite, const char *encoding)
{
    DOMPrintFormatTarget* formatTarget = new DOMPrintFormatTarget();
    XMLFormatter *gFormatter = new XMLFormatter(encoding, formatTarget, XMLFormatter::NoEscapes, 
        XMLFormatter::UnRep_CharRef);
    WalkXML (gFormatter, *((DOM_Node *) toWrite));
    buf = formatTarget->outBuf;
    siz = formatTarget->outPtr;
    delete formatTarget;
    delete gFormatter;
}

void addComment (DOM_Document &doc, DOM_Node &node, const char *rem)
{
    DOM_Comment Rem = doc.createComment (rem);
    node.appendChild (Rem);
}

void addTextI (DOM_Document &doc, DOM_Node &node, int num)
{
    char st [20];
    sprintf (st, "%ld", num);
    DOM_Text Text = doc.createTextNode (st);
    node.appendChild (Text);
}

void addTextU (DOM_Document &doc, DOM_Node &node, unsigned int num)
{
    char st [20];
    sprintf (st, "%lu", num);
    DOM_Text Text = doc.createTextNode (st);
    node.appendChild (Text);
}

void addTextD (DOM_Document &doc, DOM_Node &node, double num)
{
    char st [20];
    sprintf (st, "%lg", num);
    DOM_Text Text = doc.createTextNode (st);
    node.appendChild (Text);
}

void addTextC (DOM_Document &doc, DOM_Node &node, XMLCh bt)
{
    DOMString st (&bt, 1);
    DOM_Text Text = doc.createTextNode (st);
    node.appendChild (Text);
}

void addText (DOM_Document &doc, DOM_Node &node, const char *st)
{
    DOM_Text Text = doc.createTextNode (st);
    node.appendChild (Text);
}

void addText (DOM_Document &doc, DOM_Node &node, unsigned short *st)
{
    DOM_Text Text = doc.createTextNode (st);
    node.appendChild (Text);
}

DOM_Element addElement (DOM_Document &doc, DOM_Node &node, const char *st)
{
    if (noInitXerces) {
        // Initialize the XML4C2 system
        try
        {
            XMLPlatformUtils::Initialize();
            noInitXerces = false;
        }

        catch(const XMLException& toCatch)
        {
            (void) toCatch;
            cerr << "Error during Xerces-c Initialization." << endl;
        }
    }
    DOM_Element Elm = doc.createElement (st);
    node.appendChild (Elm);
    return Elm;
}

void createEmptySoap (DOM_Document &doc, DOM_Element &soapEnvelope, DOM_Element &soapBody)
{
    doc = DOM_Document::createDocument ();
    soapEnvelope = addElement (doc, doc, "SOAP-ENV:Envelope");
    soapEnvelope.setAttribute ("xmlns:xsi", "http://www.w3.org/1999/XMLSchema-instance");
    soapEnvelope.setAttribute ("xmlns:xsd", "http://www.w3.org/1999/XMLSchema");
    soapEnvelope.setAttribute ("xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/");
    soapBody = addElement (doc, soapEnvelope, "SOAP-ENV:Body");
}

void addHeader (DOM_Document &doc, DOM_Element &envel, DOM_Element &soapHeader,
                const char *objRef, const char *ctxKey, const char *soapAction)
{
    soapHeader = addElement (doc, envel, "SOAP-ENV:Header");
    if (objRef || ctxKey || soapAction) {
        soapHeader.setAttribute ("xmlns:ll", "http://www.lifeline.nl/soapbridge/");
        if (objRef) {
            DOM_Element elm = addElement (doc, soapHeader, "ll:ObjRef");
            addText (doc, elm, objRef);
        }
        if (ctxKey) {
            DOM_Element elm = addElement (doc, soapHeader, "ll:Context");
            addText (doc, elm, ctxKey);
        }
        if (soapAction) {
            DOM_Element elm = addElement (doc, soapHeader, "ll:Action");
            addText (doc, elm, soapAction);
        }
    }
}

void importHeader (DOM_Document &doc, DOM_Element &envel, DOM_Element &soapHeader)
{
    if (soapHeader != NULL) {
        DOM_Node tmp = doc.importNode (soapHeader, true);
        envel.appendChild (tmp);
    }
}

CString DOM2CS (DOMString &ds)
{
    char *del = ds.transcode ();
    CString cs = del;
    delete del;
    return cs;
}

CString DOM2CS (DOM_Element &el)
{
    DOM_Node tn = el.getFirstChild ();
    CString cs;
    // loop in case the element has more than one textnode with or without other nodes intermixed.
    while (tn != NULL) {
        if (tn.getNodeType () == DOM_Node::TEXT_NODE) {
            DOMString ds (tn.getNodeValue ());
            cs += DOM2CS (ds);
        }
        tn = tn.getNextSibling ();
    }
    return cs;
}

---