xerces_line_col.txt

First of all, this is one of these recurring questions that are asked 
all over again and again. Maybe the answer is put in a place so 
prominent (FAQ?) that it doesn't occur any more (I rember that I was 
asking the same question as well a couple of months ago)

You will have to add tagging objects to each DOMElement while you let 
the DOMParser parse the XML file. So basically, what you do is is to 
derive a class from the DOMParser and override it's startElement 
function (yep, it is actually a SAXParser as well). Another option might 
be to maintain a hashtable with pointers to DOMNodes as keys, but I 
didn't do that (hmm, might not be too bad of an idea, maybe next time ;)

The Tags need to be refernce counted if you want to clone nodes (hmm, I 
wonder if I do that in my project, actually), otherwise you'll end up 
with nasty lifetime issues for your Tag objects. For this reason, Tags 
are implemented with their own specific DataHandler, which takes care of 
these lifetime issues.

However, I hope that the code I'm submitting here will answer it once 
and for all (although I don't guarantee it to be perfect nor performant, 
it just works for what I do, if it doesn't work for you it's your 
problem - and <disclaimer>I DONT TAKE RESPONSIBILITY FOR ANY PROBLEMS 
CAUSED BY IT</disclaimer> ;)

Find snippets of the code I am using to do this.

I hope this code is somewhat useful to you Michael, and also everyone 
else who stumbles over this problem. It that seems all too simple so 
that one would assume Xerces can do it out of the box, but unfortunately 
it can't.

Cheers,

Uwe

------------ from TaggingDOMParser.hpp:

#include <xercesc/parsers/XercesDOMParser.hpp>
#include <xercesc/dom/DOMUserDataHandler.hpp>

#include <string>

#include "assert.h"

class TaggingDOMParser : public XERCES_CPP_NAMESPACE::XercesDOMParser {
    class TagDataHandler;
    friend class TagDataHandler;
   
    public:
        struct Tag {
            public:
                inline Tag()
                :    lineNumber(-1),
                    columnNumber(-1),
                    referenceCount(0){
                }
               
                inline void link(){
                    ++referenceCount;
                }
               
                inline void unlink(){
                    assert(referenceCount>0);
                    --referenceCount;
                    if(referenceCount <= 0)
                        delete this;
                }
               
            public:
                std::string systemID;
                int lineNumber;
                int columnNumber;
               
            private:
                int referenceCount;
           
            protected:
                inline ~Tag(){
                }
           
        };
   
    private:
        TagDataHandler* dataHandler;
       
    protected:
        Tag* createTag();
       
    public:
        TaggingDOMParser();
        virtual ~TaggingDOMParser();
       
        virtual void startElement (const 
XERCES_CPP_NAMESPACE::XMLElementDecl &elemDecl, const unsigned int 
uriId, const XMLCh *const prefixName, const 
XERCES_CPP_NAMESPACE::RefVectorOf< XERCES_CPP_NAMESPACE::XMLAttr > 
&attrList, const unsigned int attrCount, const bool isEmpty, const bool 
isRoot);
       
        static const TaggingDOMParser::Tag* getTag(const 
XERCES_CPP_NAMESPACE::DOMNode* node);
};


------------ TaggingDOMParser.cpp

#include "TaggingDOMParser.hpp"

#include <xercesc/internal/XMLScanner.hpp>

#include "StrX.hpp"

using namespace XERCES_CPP_NAMESPACE;


static XMLCh* tagKey = L"LineNumberAnnotation";

class TaggingDOMParser::TagDataHandler : public 
XERCES_CPP_NAMESPACE::DOMUserDataHandler {
    private:
        TaggingDOMParser* parser;
       
    public:
   
        TagDataHandler()
        :    parser(0)
        {
        }
       
        virtual ~TagDataHandler(){
        }
       
        inline setParser(TaggingDOMParser* parser){
            this->parser = parser;
        }
       
        virtual void handle(DOMOperationType operation, const XMLCh 
*const key, void *data, const DOMNode *src, const DOMNode *dst){
            Tag* srcTag = static_cast<Tag*>(data);
            switch(operation){
                // import and clone are basically the same case, in 
both, the node
                // is cloned
                case NODE_IMPORTED:
                case NODE_CLONED:
                   srcTag->link();
                    break;
                case NODE_DELETED:
                    srcTag->unlink();
                    break;
                case NODE_RENAMED:
                    // do nothing on rename
                    break;
            }
        }
};


TaggingDOMParser::TaggingDOMParser()
:    dataHandler(new TagDataHandler()){
    dataHandler->setParser(this);
}


TaggingDOMParser::~TaggingDOMParser()
{
}


TaggingDOMParser::Tag* TaggingDOMParser::createTag(){
    return new Tag();
}


void TaggingDOMParser::startElement(
    const XMLElementDecl &elemDecl,
    const unsigned int uriId,
    const XMLCh *const prefixName,
    const RefVectorOf< XMLAttr > &attrList,
    const unsigned int attrCount,
    const bool isEmpty,
    const bool isRoot
    ) {
    // supercall
    XercesDOMParser::startElement(elemDecl, uriId, prefixName, attrList, 
attrCount, isEmpty, isRoot);
   
    if(!isEmpty){
        Tag* tag = createTag();
        const Locator* locator = getScanner()->getLocator();
        tag->systemID = StrX(locator->getSystemId()).getString();
        tag->lineNumber = locator->getLineNumber();
        tag->columnNumber = locator->getColumnNumber();
       
        XercesDOMParser::fCurrentNode->setUserData(tagKey, tag, 
dataHandler);
       
        tag->link();
    }
}


const TaggingDOMParser::Tag* TaggingDOMParser::getTag(const DOMNode* node){
    return static_cast<TaggingDOMParser::Tag*>(node->getUserData(tagKey));
}

-------------------

Oh, and StrX() is actually just a helper class that takes and XMLCh* in 
it's contructor and stores the UTF8-transcoded version, which can be 
obtained by it's getString() method; you might find a similar 
implementation in Xerces' examples

Hope this helps, feedback welcome.

Cheers,

Uwe


Michael Weitzel michael.weitzel-at-uni-siegen.de |xerces-c-users mailing 
list| schrieb:
> Hi all,
>
> is there a way to determine the line and column of the XML file
> associated with a specific DOMNode / element? The data in my XML format
> requires a few complex semantic validations that cannot be expressed by
> the DTD. The simpler errors can be detected based on the context while
> traversing the DOM tree and it would be nice to give more specific error
> messages.
>
> Am I right that "DOMLocator" cannot be used since no "DOMError" occurs?
>
> Thanks! :)
>