You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@xerces.apache.org by tn...@apache.org on 2002/05/21 21:28:30 UTC

cvs commit: xml-xerces/c/src/xercesc/parsers XercesDOMParser.cpp XercesDOMParser.hpp

tng         02/05/21 12:28:29

  Modified:    c/src/xercesc/parsers XercesDOMParser.cpp
                        XercesDOMParser.hpp
  Log:
  DOM Reorganization: modify to use the new DOM interface.
  
  Revision  Changes    Path
  1.2       +145 -145  xml-xerces/c/src/xercesc/parsers/XercesDOMParser.cpp
  
  Index: XercesDOMParser.cpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/xercesc/parsers/XercesDOMParser.cpp,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- XercesDOMParser.cpp	21 May 2002 19:27:31 -0000	1.1
  +++ XercesDOMParser.cpp	21 May 2002 19:28:29 -0000	1.2
  @@ -56,10 +56,10 @@
   
   /**
   *  This file contains code to build the DOM tree. It registers a document
  -*  handler with the scanner. In these handler methods, appropriate IDOM nodes
  +*  handler with the scanner. In these handler methods, appropriate DOM nodes
   *  are created and added to the DOM tree.
   *
  -* $Id: XercesDOMParser.cpp,v 1.1 2002/05/21 19:27:31 tng Exp $
  +* $Id: XercesDOMParser.cpp,v 1.2 2002/05/21 19:28:29 tng Exp $
   *
   */
   
  @@ -76,32 +76,32 @@
   #include <xercesc/util/IOException.hpp>
   #include <xercesc/internal/XMLScanner.hpp>
   #include <xercesc/validators/DTD/DTDValidator.hpp>
  -#include <xercesc/parsers/IDOMParser.hpp>
  -#include <xercesc/idom/IDOM_DOMImplementation.hpp>
  -#include <xercesc/idom/IDOM_Element.hpp>
  -#include <xercesc/idom/IDAttrImpl.hpp>
  -#include <xercesc/idom/IDOM_CDATASection.hpp>
  -#include <xercesc/idom/IDOM_Comment.hpp>
  -#include <xercesc/idom/IDTextImpl.hpp>
  -#include <xercesc/idom/IDDocumentImpl.hpp>
  -#include <xercesc/idom/IDDocumentTypeImpl.hpp>
  -#include <xercesc/idom/IDOM_DocumentType.hpp>
  -#include <xercesc/idom/IDElementImpl.hpp>
  -#include <xercesc/idom/IDEntityImpl.hpp>
  -#include <xercesc/idom/IDEntityReferenceImpl.hpp>
  -#include <xercesc/idom/IDNotationImpl.hpp>
  -#include <xercesc/idom/IDOM_NamedNodeMap.hpp>
  -#include <xercesc/idom/IDOM_ProcessingInstruction.hpp>
  -#include <xercesc/idom/IDNodeIDMap.hpp>
  +#include <xercesc/parsers/XercesDOMParser.hpp>
  +#include <xercesc/dom/DOMImplementation.hpp>
  +#include <xercesc/dom/DOMElement.hpp>
  +#include <xercesc/dom/impl/DOMAttrImpl.hpp>
  +#include <xercesc/dom/DOMCDATASection.hpp>
  +#include <xercesc/dom/DOMComment.hpp>
  +#include <xercesc/dom/impl/DOMTextImpl.hpp>
  +#include <xercesc/dom/impl/DOMDocumentImpl.hpp>
  +#include <xercesc/dom/impl/DOMDocumentTypeImpl.hpp>
  +#include <xercesc/dom/DOMDocumentType.hpp>
  +#include <xercesc/dom/impl/DOMElementImpl.hpp>
  +#include <xercesc/dom/impl/DOMEntityImpl.hpp>
  +#include <xercesc/dom/impl/DOMEntityReferenceImpl.hpp>
  +#include <xercesc/dom/impl/DOMNotationImpl.hpp>
  +#include <xercesc/dom/DOMNamedNodeMap.hpp>
  +#include <xercesc/dom/DOMProcessingInstruction.hpp>
  +#include <xercesc/dom/impl/DOMNodeIDMap.hpp>
   
   
   #include <xercesc/validators/common/ContentSpecNode.hpp>
   #include <xercesc/validators/DTD/DTDAttDefList.hpp>
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Constructors and Destructor
  +//  XercesDOMParser: Constructors and Destructor
   // ---------------------------------------------------------------------------
  -IDOMParser::IDOMParser(XMLValidator* const valToAdopt) :
  +XercesDOMParser::XercesDOMParser(XMLValidator* const valToAdopt) :
   
   fErrorHandler(0)
   , fEntityResolver(0)
  @@ -114,20 +114,20 @@
   {
       //
       //  Create a scanner and tell it what validator to use. Then set us
  -    //  as the document event handler so we can fill the IDOM document.
  +    //  as the document event handler so we can fill the DOM document.
       //
       fScanner = new XMLScanner(valToAdopt);
       fScanner->setDocHandler(this);
       fScanner->setDocTypeHandler(this);
   
  -    fNodeStack = new ValueStackOf<IDOM_Node*>(64);
  +    fNodeStack = new ValueStackOf<DOMNode*>(64);
       this->reset();
   
   
   }
   
   
  -IDOMParser::~IDOMParser()
  +XercesDOMParser::~XercesDOMParser()
   {
       if (fDocumentVector)
           delete fDocumentVector;
  @@ -138,13 +138,13 @@
   }
   
   
  -void IDOMParser::reset()
  +void XercesDOMParser::reset()
   {
       // if fDocument exists already, store the old pointer in the vector for deletion later
       if (fDocument) {
           if (!fDocumentVector) {
               // allocate the vector if not exists yet
  -            fDocumentVector  = new RefVectorOf<IDDocumentImpl>(10, true) ;
  +            fDocumentVector  = new RefVectorOf<DOMDocumentImpl>(10, true) ;
           }
           fDocumentVector->addElement(fDocument);
       }
  @@ -162,34 +162,34 @@
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Getter methods
  +//  XercesDOMParser: Getter methods
   // ---------------------------------------------------------------------------
  -IDOM_Document* IDOMParser::getDocument()
  +DOMDocument* XercesDOMParser::getDocument()
   {
       return fDocument;
   }
   
  -const XMLValidator& IDOMParser::getValidator() const
  +const XMLValidator& XercesDOMParser::getValidator() const
   {
       return *fScanner->getValidator();
   }
   
  -bool IDOMParser::getDoNamespaces() const
  +bool XercesDOMParser::getDoNamespaces() const
   {
       return fScanner->getDoNamespaces();
   }
   
  -bool IDOMParser::getExitOnFirstFatalError() const
  +bool XercesDOMParser::getExitOnFirstFatalError() const
   {
       return fScanner->getExitOnFirstFatal();
   }
   
  -bool IDOMParser::getValidationConstraintFatal() const
  +bool XercesDOMParser::getValidationConstraintFatal() const
   {
       return fScanner->getValidationConstraintFatal();
   }
   
  -IDOMParser::ValSchemes IDOMParser::getValidationScheme() const
  +XercesDOMParser::ValSchemes XercesDOMParser::getValidationScheme() const
   {
       const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
   
  @@ -201,40 +201,40 @@
       return Val_Auto;
   }
   
  -bool IDOMParser::getDoSchema() const
  +bool XercesDOMParser::getDoSchema() const
   {
       return fScanner->getDoSchema();
   }
   
  -bool IDOMParser::getValidationSchemaFullChecking() const
  +bool XercesDOMParser::getValidationSchemaFullChecking() const
   {
       return fScanner->getValidationSchemaFullChecking();
   }
   
  -int IDOMParser::getErrorCount() const
  +int XercesDOMParser::getErrorCount() const
   {
       return fScanner->getErrorCount();
   }
   
  -XMLCh* IDOMParser::getExternalSchemaLocation() const
  +XMLCh* XercesDOMParser::getExternalSchemaLocation() const
   {
       return fScanner->getExternalSchemaLocation();
   }
   
  -XMLCh* IDOMParser::getExternalNoNamespaceSchemaLocation() const
  +XMLCh* XercesDOMParser::getExternalNoNamespaceSchemaLocation() const
   {
       return fScanner->getExternalNoNamespaceSchemaLocation();
   }
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Setter methods
  +//  XercesDOMParser: Setter methods
   // ---------------------------------------------------------------------------
  -void IDOMParser::setDoNamespaces(const bool newState)
  +void XercesDOMParser::setDoNamespaces(const bool newState)
   {
       fScanner->setDoNamespaces(newState);
   }
   
  -void IDOMParser::setErrorHandler(ErrorHandler* const handler)
  +void XercesDOMParser::setErrorHandler(ErrorHandler* const handler)
   {
       fErrorHandler = handler;
       if (fErrorHandler) {
  @@ -247,7 +247,7 @@
       }
   }
   
  -void IDOMParser::setEntityResolver(EntityResolver* const handler)
  +void XercesDOMParser::setEntityResolver(EntityResolver* const handler)
   {
       fEntityResolver = handler;
       if (fEntityResolver) {
  @@ -260,17 +260,17 @@
       }
   }
   
  -void IDOMParser::setExitOnFirstFatalError(const bool newState)
  +void XercesDOMParser::setExitOnFirstFatalError(const bool newState)
   {
       fScanner->setExitOnFirstFatal(newState);
   }
   
  -void IDOMParser::setValidationConstraintFatal(const bool newState)
  +void XercesDOMParser::setValidationConstraintFatal(const bool newState)
   {
       fScanner->setValidationConstraintFatal(newState);
   }
   
  -void IDOMParser::setValidationScheme(const ValSchemes newScheme)
  +void XercesDOMParser::setValidationScheme(const ValSchemes newScheme)
   {
       if (newScheme == Val_Never)
           fScanner->setValidationScheme(XMLScanner::Val_Never);
  @@ -280,39 +280,39 @@
           fScanner->setValidationScheme(XMLScanner::Val_Auto);
   }
   
  -void IDOMParser::setDoSchema(const bool newState)
  +void XercesDOMParser::setDoSchema(const bool newState)
   {
       fScanner->setDoSchema(newState);
   }
   
  -void IDOMParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
  +void XercesDOMParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
   {
       fScanner->setValidationSchemaFullChecking(schemaFullChecking);
   }
   
  -void IDOMParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
  +void XercesDOMParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
   {
       fScanner->setExternalSchemaLocation(schemaLocation);
   }
  -void IDOMParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
  +void XercesDOMParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
   {
       fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
   }
   
  -void IDOMParser::setExternalSchemaLocation(const char* const schemaLocation)
  +void XercesDOMParser::setExternalSchemaLocation(const char* const schemaLocation)
   {
       fScanner->setExternalSchemaLocation(schemaLocation);
   }
  -void IDOMParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
  +void XercesDOMParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
   {
       fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
   }
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Parsing methods
  +//  XercesDOMParser: Parsing methods
   // ---------------------------------------------------------------------------
  -void IDOMParser::parse(const InputSource& source, const bool reuseGrammar)
  +void XercesDOMParser::parse(const InputSource& source, const bool reuseGrammar)
   {
       // Avoid multiple entrance
       if (fParseInProgress)
  @@ -332,7 +332,7 @@
       }
   }
   
  -void IDOMParser::parse(const XMLCh* const systemId, const bool reuseGrammar)
  +void XercesDOMParser::parse(const XMLCh* const systemId, const bool reuseGrammar)
   {
       // Avoid multiple entrance
       if (fParseInProgress)
  @@ -352,7 +352,7 @@
       }
   }
   
  -void IDOMParser::parse(const char* const systemId, const bool reuseGrammar)
  +void XercesDOMParser::parse(const char* const systemId, const bool reuseGrammar)
   {
       // Avoid multiple entrance
       if (fParseInProgress)
  @@ -375,9 +375,9 @@
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Progressive parse methods
  +//  XercesDOMParser: Progressive parse methods
   // ---------------------------------------------------------------------------
  -bool IDOMParser::parseFirst( const   XMLCh* const    systemId
  +bool XercesDOMParser::parseFirst( const   XMLCh* const    systemId
                              ,       XMLPScanToken&  toFill
                              , const bool            reuseGrammar)
   {
  @@ -391,7 +391,7 @@
       return fScanner->scanFirst(systemId, toFill, reuseGrammar);
   }
   
  -bool IDOMParser::parseFirst( const   char* const         systemId
  +bool XercesDOMParser::parseFirst( const   char* const         systemId
                              ,       XMLPScanToken&      toFill
                              , const bool                reuseGrammar)
   {
  @@ -405,7 +405,7 @@
       return fScanner->scanFirst(systemId, toFill, reuseGrammar);
   }
   
  -bool IDOMParser::parseFirst( const   InputSource&    source
  +bool XercesDOMParser::parseFirst( const   InputSource&    source
                              ,       XMLPScanToken&  toFill
                              , const bool            reuseGrammar)
   {
  @@ -419,12 +419,12 @@
       return fScanner->scanFirst(source, toFill, reuseGrammar);
   }
   
  -bool IDOMParser::parseNext(XMLPScanToken& token)
  +bool XercesDOMParser::parseNext(XMLPScanToken& token)
   {
       return fScanner->scanNext(token);
   }
   
  -void IDOMParser::parseReset(XMLPScanToken& token)
  +void XercesDOMParser::parseReset(XMLPScanToken& token)
   {
       // Reset the scanner, and then reset the parser
       fScanner->scanReset(token);
  @@ -432,9 +432,9 @@
   }
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Utilities
  +//  XercesDOMParser: Utilities
   // ---------------------------------------------------------------------------
  -void IDOMParser::resetDocumentPool()
  +void XercesDOMParser::resetDocumentPool()
   {
       //  We cannot enter here while a regular parse is in progress.
       if (fParseInProgress)
  @@ -449,9 +449,9 @@
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Implementation of the XMLErrorReporter interface
  +//  XercesDOMParser: Implementation of the XMLErrorReporter interface
   // ---------------------------------------------------------------------------
  -void IDOMParser::error(  const   unsigned int                code
  +void XercesDOMParser::error(  const   unsigned int                code
                         , const XMLCh* const                msgDomain
                         , const XMLErrorReporter::ErrTypes  errType
                         , const XMLCh* const                errorText
  @@ -488,16 +488,16 @@
           fErrorHandler->error(toThrow);
   }
   
  -void IDOMParser::resetErrors()
  +void XercesDOMParser::resetErrors()
   {
   }
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Implementation of XMLEntityHandler interface
  +//  XercesDOMParser: Implementation of XMLEntityHandler interface
   // ---------------------------------------------------------------------------
   InputSource*
  -IDOMParser::resolveEntity(const XMLCh* const publicId, const XMLCh* const systemId)
  +XercesDOMParser::resolveEntity(const XMLCh* const publicId, const XMLCh* const systemId)
   {
       //
       //  Just map it to the SAX entity resolver. If there is not one installed,
  @@ -511,9 +511,9 @@
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Implementation of XMLDocumentHandler interface
  +//  XercesDOMParser: Implementation of XMLDocumentHandler interface
   // ---------------------------------------------------------------------------
  -void IDOMParser::docCharacters(  const   XMLCh* const    chars
  +void XercesDOMParser::docCharacters(  const   XMLCh* const    chars
                                 , const unsigned int    length
                                 , const bool            cdataSection)
   {
  @@ -521,7 +521,7 @@
       if (!fWithinElement)
           return;
   
  -    // idom_revisit.  Is it really safe to null-terminate here?
  +    // revisit.  Is it really safe to null-terminate here?
       //                Does the scanner do it already?
       //                If scanner goes up to the very end of an unterminated
       //                buffer, we may be stepping on something bad here.
  @@ -531,20 +531,20 @@
       ncChars[length] = 0;
       if (cdataSection == true)
       {
  -        IDOM_CDATASection *node = fDocument->createCDATASection(chars);
  +        DOMCDATASection *node = fDocument->createCDATASection(chars);
           fCurrentParent->appendChild(node);
           fCurrentNode = node;
       }
       else
       {
  -        if (fCurrentNode->getNodeType() == IDOM_Node::TEXT_NODE)
  +        if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
           {
  -            IDOM_Text *node = (IDOM_Text *)fCurrentNode;
  +            DOMText *node = (DOMText *)fCurrentNode;
               node->appendData(chars);
           }
           else
           {
  -            IDOM_Text *node = fDocument->createTextNode(chars);
  +            DOMText *node = fDocument->createTextNode(chars);
               fCurrentParent->appendChild(node);
               fCurrentNode = node;
           }
  @@ -554,18 +554,18 @@
   }
   
   
  -void IDOMParser::docComment(const XMLCh* const comment)
  +void XercesDOMParser::docComment(const XMLCh* const comment)
   {
  -    IDOM_Comment *dcom = fDocument->createComment(comment);
  +    DOMComment *dcom = fDocument->createComment(comment);
       fCurrentParent->appendChild(dcom);
       fCurrentNode = dcom;
   }
   
   
  -void IDOMParser::docPI(  const   XMLCh* const    target
  +void XercesDOMParser::docPI(  const   XMLCh* const    target
                         , const XMLCh* const    data)
   {
  -    IDOM_ProcessingInstruction *pi = fDocument->createProcessingInstruction
  +    DOMProcessingInstruction *pi = fDocument->createProcessingInstruction
           (
           target
           , data
  @@ -575,12 +575,12 @@
   }
   
   
  -void IDOMParser::endEntityReference(const XMLEntityDecl& entDecl)
  +void XercesDOMParser::endEntityReference(const XMLEntityDecl& entDecl)
   {
       if (fCreateEntityReferenceNodes == true)
       {
  -        if (fCurrentParent->getNodeType() == IDOM_Node::ENTITY_REFERENCE_NODE) {
  -            IDEntityReferenceImpl *erImpl = (IDEntityReferenceImpl *) fCurrentParent;
  +        if (fCurrentParent->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE) {
  +            DOMEntityReferenceImpl *erImpl = (DOMEntityReferenceImpl *) fCurrentParent;
               erImpl->setReadOnly(true, true);
           }
           fCurrentParent = fNodeStack->pop();
  @@ -589,7 +589,7 @@
   }
   
   
  -void IDOMParser::endElement( const   XMLElementDecl&     elemDecl
  +void XercesDOMParser::endElement( const   XMLElementDecl&     elemDecl
                              , const unsigned int        urlId
                              , const bool                isRoot)
   {
  @@ -602,7 +602,7 @@
   }
   
   
  -void IDOMParser::ignorableWhitespace(const   XMLCh* const    chars
  +void XercesDOMParser::ignorableWhitespace(const   XMLCh* const    chars
                                       , const unsigned int    length
                                       , const bool            cdataSection)
   {
  @@ -610,19 +610,19 @@
       if (!fWithinElement || !fIncludeIgnorableWhitespace)
           return;
   
  -    // idom_revisit.  Not safe to slam in a null like this.
  +    // revisit.  Not safe to slam in a null like this.
       XMLCh savedChar = chars[length];
       XMLCh *ncChars  = (XMLCh *)chars;   // cast off const
       ncChars[length] = chNull;
   
  -    if (fCurrentNode->getNodeType() == IDOM_Node::TEXT_NODE)
  +    if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
       {
  -        IDOM_Text *node = (IDOM_Text *)fCurrentNode;
  +        DOMText *node = (DOMText *)fCurrentNode;
           node->appendData(chars);
       }
       else
       {
  -        IDTextImpl *node = (IDTextImpl *)fDocument->createTextNode(chars);
  +        DOMTextImpl *node = (DOMTextImpl *)fDocument->createTextNode(chars);
           node->setIgnorableWhitespace(true);
           fCurrentParent->appendChild(node);
   
  @@ -632,36 +632,36 @@
   }
   
   
  -void IDOMParser::resetDocument()
  +void XercesDOMParser::resetDocument()
   {
       //
       //  The reset methods are called before a new parse event occurs.
       //  Reset this parsers state to clear out anything that may be left
  -    //  from a previous use, in particular the IDOM document itself.
  +    //  from a previous use, in particular the DOM document itself.
       //
       this->reset();
  -    fDocument = (IDDocumentImpl *)IDOM_DOMImplementation::getImplementation()->createDocument();
  +    fDocument = (DOMDocumentImpl *)DOMImplementation::getImplementation()->createDocument();
   }
   
   
  -void IDOMParser::startDocument()
  +void XercesDOMParser::startDocument()
   {
       // Just set the document as the current parent and current node
       fCurrentParent = fDocument;
       fCurrentNode   = fDocument;
  -    // set IDOM error checking off
  +    // set DOM error checking off
       fDocument->setErrorChecking(false);
   }
   
   
  -void IDOMParser::endDocument()
  +void XercesDOMParser::endDocument()
   {
  -    // set IDOM error checking back on
  +    // set DOM error checking back on
       fDocument->setErrorChecking(true);
   }
   
   
  -void IDOMParser::startElement(const  XMLElementDecl&         elemDecl
  +void XercesDOMParser::startElement(const  XMLElementDecl&         elemDecl
                                , const unsigned int            urlId
                                , const XMLCh* const            elemPrefix
                                , const RefVectorOf<XMLAttr>&   attrList
  @@ -669,9 +669,9 @@
                                , const bool                    isEmpty
                                , const bool                    isRoot)
   {
  -    IDOM_Element     *elem;
  +    DOMElement     *elem;
   
  -    if (fScanner -> getDoNamespaces()) {    //IDOM Level 2, doNamespaces on
  +    if (fScanner -> getDoNamespaces()) {    //DOM Level 2, doNamespaces on
           XMLBuffer buf;
           XMLCh* namespaceURI = 0;
           if (urlId != fScanner->getEmptyNamespaceId()) {  //TagName has a prefix
  @@ -679,7 +679,7 @@
               namespaceURI = buf.getRawBuffer();
           }
           elem = createElementNSNode(namespaceURI, elemDecl.getFullName());
  -        IDElementImpl *elemImpl = (IDElementImpl *) elem;
  +        DOMElementImpl *elemImpl = (DOMElementImpl *) elem;
           for (unsigned int index = 0; index < attrCount; ++index) {
               static const XMLCh XMLNS[] = {
               chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull
  @@ -693,14 +693,14 @@
                   fScanner->getURIText(attrURIId, buf);   //get namespaceURI
                   namespaceURI = buf.getRawBuffer();
               }
  -            //  idom_revisit.  Optimize to init the named node map to the
  +            //  revisit.  Optimize to init the named node map to the
               //                 right size up front.
  -            IDAttrImpl *attr = (IDAttrImpl *)
  +            DOMAttrImpl *attr = (DOMAttrImpl *)
                   fDocument->createAttributeNS(namespaceURI, oneAttrib->getQName());
               attr->setValue(oneAttrib -> getValue());
               elemImpl->setAttributeNode(attr);
   
  -            //IDAttrImpl *attr = elemImpl->setAttributeNS(namespaceURI, oneAttrib -> getQName(),
  +            //DOMAttrImpl *attr = elemImpl->setAttributeNS(namespaceURI, oneAttrib -> getQName(),
               //    oneAttrib -> getValue());
   
               // Attributes of type ID.  If this is one, add it to the hashtable of IDs
  @@ -709,7 +709,7 @@
               if (oneAttrib->getType()==XMLAttDef::ID)
               {
                   if (fDocument->fNodeIDMap == 0)
  -                    fDocument->fNodeIDMap = new (fDocument) IDNodeIDMap(500, fDocument);
  +                    fDocument->fNodeIDMap = new (fDocument) DOMNodeIDMap(500, fDocument);
                   fDocument->fNodeIDMap->add(attr);
                   attr->fNode.isIdAttr(true);
               }
  @@ -719,11 +719,11 @@
       }
       else {    //DOM Level 1
           elem = fDocument->createElement(elemDecl.getFullName());
  -        IDElementImpl *elemImpl = (IDElementImpl *) elem;
  +        DOMElementImpl *elemImpl = (DOMElementImpl *) elem;
   			for (unsigned int index = 0; index < attrCount; ++index) {
   				const XMLAttr* oneAttrib = attrList.elementAt(index);
               //AttrImpl *attr = elemImpl->setAttribute(oneAttrib->getName(), oneAttrib->getValue());
  -            IDAttrImpl *attr = (IDAttrImpl *)
  +            DOMAttrImpl *attr = (DOMAttrImpl *)
                   fDocument->createAttribute(oneAttrib->getName());
               attr->setValue(oneAttrib -> getValue());
               elemImpl->setAttributeNode(attr);
  @@ -735,7 +735,7 @@
   				if (oneAttrib->getType()==XMLAttDef::ID)
   				{
                   if (fDocument->fNodeIDMap == 0)
  -                    fDocument->fNodeIDMap = new (fDocument) IDNodeIDMap(500, fDocument);
  +                    fDocument->fNodeIDMap = new (fDocument) DOMNodeIDMap(500, fDocument);
                   fDocument->fNodeIDMap->add(attr);
                   attr->fNode.isIdAttr(true);
               }
  @@ -755,15 +755,15 @@
   }
   
   
  -void IDOMParser::startEntityReference(const XMLEntityDecl& entDecl)
  +void XercesDOMParser::startEntityReference(const XMLEntityDecl& entDecl)
   {
       if (fCreateEntityReferenceNodes == true)
       {
           const XMLCh * entName = entDecl.getName();
  -        IDOM_EntityReference *er = fDocument->createEntityReference(entName);
  +        DOMEntityReference *er = fDocument->createEntityReference(entName);
   
           //set the readOnly flag to false before appending node, will be reset in endEntityReference
  -        IDEntityReferenceImpl *erImpl = (IDEntityReferenceImpl *) er;
  +        DOMEntityReferenceImpl *erImpl = (DOMEntityReferenceImpl *) er;
           erImpl->setReadOnly(false, true);
   
           fCurrentParent->appendChild(er);
  @@ -775,15 +775,15 @@
           // We'd decide later whether the entity nodes should be created by a
           // separated method in parser or not. For now just stick it in if
           // the ref nodes are created
  -        IDOM_NamedNodeMap *entities = fDocumentType->getEntities();
  -        IDEntityImpl* entity = (IDEntityImpl*)entities->getNamedItem(entName);
  +        DOMNamedNodeMap *entities = fDocumentType->getEntities();
  +        DOMEntityImpl* entity = (DOMEntityImpl*)entities->getNamedItem(entName);
           entity->setEntityRef(er);
   
       }
   }
   
   
  -void IDOMParser::XMLDecl(const   XMLCh* const version
  +void XercesDOMParser::XMLDecl(const   XMLCh* const version
                           , const XMLCh* const encoding
                           , const XMLCh* const standalone
                           , const XMLCh* const actualEncStr)
  @@ -792,17 +792,17 @@
   }
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Helper methods
  +//  XercesDOMParser: Helper methods
   // ---------------------------------------------------------------------------
  -IDOM_Element* IDOMParser::createElementNSNode(const XMLCh *namespaceURI,
  +DOMElement* XercesDOMParser::createElementNSNode(const XMLCh *namespaceURI,
                                                 const XMLCh *qualifiedName)
   {
       return fDocument->createElementNS(namespaceURI, qualifiedName);
   }
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Deprecated methods
  +//  XercesDOMParser: Deprecated methods
   // ---------------------------------------------------------------------------
  -bool IDOMParser::getDoValidation() const
  +bool XercesDOMParser::getDoValidation() const
   {
       //
       //  We don't want to tie the public parser classes to the enum used
  @@ -816,7 +816,7 @@
       return false;
   }
   
  -void IDOMParser::setDoValidation(const bool newState)
  +void XercesDOMParser::setDoValidation(const bool newState)
   {
       fScanner->setDoValidation
       (
  @@ -825,7 +825,7 @@
   }
   
   //doctypehandler interfaces
  -void IDOMParser::attDef
  +void XercesDOMParser::attDef
   (
       const   DTDElementDecl&     elemDecl
       , const DTDAttDef&          attDef
  @@ -940,7 +940,7 @@
       }
   }
   
  -void IDOMParser::doctypeComment
  +void XercesDOMParser::doctypeComment
   (
       const   XMLCh* const    comment
   )
  @@ -962,7 +962,7 @@
       }
   }
   
  -void IDOMParser::doctypeDecl
  +void XercesDOMParser::doctypeDecl
   (
       const   DTDElementDecl& elemDecl
       , const XMLCh* const    publicId
  @@ -970,12 +970,12 @@
       , const bool            hasIntSubset
   )
   {
  -    fDocumentType = (IDDocumentTypeImpl *) fDocument->createDocumentType(elemDecl.getFullName(), publicId, systemId);
  +    fDocumentType = (DOMDocumentTypeImpl *) fDocument->createDocumentType(elemDecl.getFullName(), publicId, systemId);
       fDocument->setDocumentType(fDocumentType);
   
   }
   
  -void IDOMParser::doctypePI
  +void XercesDOMParser::doctypePI
   (
       const   XMLCh* const    target
       , const XMLCh* const    data
  @@ -999,7 +999,7 @@
   }
   
   
  -void IDOMParser::doctypeWhitespace
  +void XercesDOMParser::doctypeWhitespace
   (
       const   XMLCh* const    chars
       , const unsigned int    length
  @@ -1009,7 +1009,7 @@
   		fDocumentType->setInternalSubset(chars);
   }
   
  -void IDOMParser::elementDecl
  +void XercesDOMParser::elementDecl
   (
       const   DTDElementDecl& decl
       , const bool            isIgnored
  @@ -1037,7 +1037,7 @@
   	}
   }
   
  -void IDOMParser::endAttList
  +void XercesDOMParser::endAttList
   (
       const   DTDElementDecl& elemDecl
   )
  @@ -1045,16 +1045,16 @@
   	// this section sets up default attributes.
   	// default attribute nodes are stored in a NamedNodeMap DocumentTypeImpl::elements
   	// default attribute data attached to the document is used to conform to the
  -	// IDOM spec regarding creating element nodes & removing attributes with default values
  +	// DOM spec regarding creating element nodes & removing attributes with default values
   	// see DocumentTypeImpl
   	if (elemDecl.hasAttDefs())
   	{		
   		XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
   		XMLAttDef* attr = 0;
   
  -		IDAttrImpl * insertAttr = 0;
  -      IDOM_Element     *elem  = fDocument->createElement(elemDecl.getFullName());
  -      IDElementImpl *elemImpl = (IDElementImpl *) elem;
  +		DOMAttrImpl * insertAttr = 0;
  +      DOMElement     *elem  = fDocument->createElement(elemDecl.getFullName());
  +      DOMElementImpl *elemImpl = (DOMElementImpl *) elem;
   
   		while (defAttrs->hasMoreElements())
           {
  @@ -1068,7 +1068,7 @@
                       // So as long as the XML parser doesn't do it, it needs to
                       // done here.
                       const XMLCh* qualifiedName = attr->getFullName();
  -                    int index = IDDocumentImpl::indexofQualifiedName(qualifiedName);
  +                    int index = DOMDocumentImpl::indexofQualifiedName(qualifiedName);
   
                       XMLBuffer buf;
                       static const XMLCh XMLNS[] = {
  @@ -1101,7 +1101,7 @@
                               buf.append(XMLUni::fgXMLNSURIName);
                       }
   
  -                    insertAttr = (IDAttrImpl *) fDocument->createAttributeNS(
  +                    insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS(
                          buf.getRawBuffer(),     // NameSpaceURI
                          qualifiedName);   // qualified name
   
  @@ -1109,7 +1109,7 @@
                   else
                   {
                       // Namespaces is turned off...
  -                    insertAttr = (IDAttrImpl *) fDocument->createAttribute(attr->getFullName());
  +                    insertAttr = (DOMAttrImpl *) fDocument->createAttribute(attr->getFullName());
                   }
                   insertAttr->setValue(attr->getValue());
                   elemImpl->setAttributeNode(insertAttr);
  @@ -1120,32 +1120,32 @@
       }
   }
   
  -void IDOMParser::endIntSubset()
  +void XercesDOMParser::endIntSubset()
   {
   	fDocumentType->intSubsetReading = false;
   }
   
  -void IDOMParser::endExtSubset()
  +void XercesDOMParser::endExtSubset()
   {
   }
   
  -void IDOMParser::entityDecl
  +void XercesDOMParser::entityDecl
   (
       const   DTDEntityDecl&  entityDecl
       , const bool            isPEDecl
       , const bool            isIgnored
   )
   {
  -    IDEntityImpl* entity = (IDEntityImpl *) fDocument->createEntity(entityDecl.getName());
  +    DOMEntityImpl* entity = (DOMEntityImpl *) fDocument->createEntity(entityDecl.getName());
   
       entity->setPublicId(entityDecl.getPublicId());
       entity->setSystemId(entityDecl.getSystemId());
       entity->setNotationName(entityDecl.getNotationName());
   
  -    IDEntityImpl *previousDef = (IDEntityImpl *)
  +    DOMEntityImpl *previousDef = (DOMEntityImpl *)
   	    fDocumentType->getEntities()->setNamedItem( entity );
   
  -    #ifdef idom_revisit
  +    #ifdef _revisit
       //
       //  If this new entity node is replacing an entity node that was already
       //    in the entities named node map (happens if documents redefine the
  @@ -1209,18 +1209,18 @@
   
   }
   
  -void IDOMParser::resetDocType()
  +void XercesDOMParser::resetDocType()
   {
   	fDocumentType = 0;
   }
   
  -void IDOMParser::notationDecl
  +void XercesDOMParser::notationDecl
   (
       const   XMLNotationDecl&    notDecl
       , const bool                isIgnored
   )
   {
  -	IDNotationImpl* notation = (IDNotationImpl *)fDocument->createNotation(notDecl.getName());
  +	DOMNotationImpl* notation = (DOMNotationImpl *)fDocument->createNotation(notDecl.getName());
   	notation->setPublicId(notDecl.getPublicId());
   	notation->setSystemId(notDecl.getSystemId());
   
  @@ -1228,23 +1228,23 @@
   
   }
   
  -void IDOMParser::startAttList
  +void XercesDOMParser::startAttList
   (
       const   DTDElementDecl& elemDecl
   )
   {
   }
   
  -void IDOMParser::startIntSubset()
  +void XercesDOMParser::startIntSubset()
   {
   	fDocumentType->intSubsetReading = true;
   }
   
  -void IDOMParser::startExtSubset()
  +void XercesDOMParser::startExtSubset()
   {
   }
   
  -void IDOMParser::TextDecl
  +void XercesDOMParser::TextDecl
   (
       const   XMLCh* const    versionStr
       , const XMLCh* const    encodingStr
  
  
  
  1.2       +78 -78    xml-xerces/c/src/xercesc/parsers/XercesDOMParser.hpp
  
  Index: XercesDOMParser.hpp
  ===================================================================
  RCS file: /home/cvs/xml-xerces/c/src/xercesc/parsers/XercesDOMParser.hpp,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- XercesDOMParser.hpp	21 May 2002 19:27:31 -0000	1.1
  +++ XercesDOMParser.hpp	21 May 2002 19:28:29 -0000	1.2
  @@ -55,22 +55,22 @@
    */
   
   /*
  - * $Id: XercesDOMParser.hpp,v 1.1 2002/05/21 19:27:31 tng Exp $
  + * $Id: XercesDOMParser.hpp,v 1.2 2002/05/21 19:28:29 tng Exp $
    *
    */
   
  -#if !defined(IDOMPARSER_HPP)
  -#define IDOMPARSER_HPP
  +#if !defined(XercesDOMParser_HPP)
  +#define XercesDOMParser_HPP
   
   
  -#include <xercesc/idom/IDOM_Document.hpp>
  +#include <xercesc/dom/DOMDocument.hpp>
   #include <xercesc/framework/XMLDocumentHandler.hpp>
   #include <xercesc/framework/XMLErrorReporter.hpp>
   #include <xercesc/framework/XMLEntityHandler.hpp>
   #include <xercesc/util/ValueStackOf.hpp>
   
   #include <xercesc/validators/DTD/DocTypeHandler.hpp>
  -#include <xercesc/idom/IDOM_DocumentType.hpp>
  +#include <xercesc/dom/DOMDocumentType.hpp>
   #include <xercesc/validators/DTD/DTDElementDecl.hpp>
   
   class EntityResolver;
  @@ -78,9 +78,9 @@
   class XMLPScanToken;
   class XMLScanner;
   class XMLValidator;
  -class IDDocumentImpl;
  -class IDDocumentTypeImpl;
  -class IDOM_Element;
  +class DOMDocumentImpl;
  +class DOMDocumentTypeImpl;
  +class DOMElement;
   
   
   /**
  @@ -93,7 +93,7 @@
     * <p>It can be used to instantiate a validating or non-validating
     * parser, by setting a member flag.</p>
     */
  -class PARSERS_EXPORT IDOMParser :
  +class PARSERS_EXPORT XercesDOMParser :
   
       public XMLDocumentHandler
       , public XMLErrorReporter
  @@ -118,7 +118,7 @@
   
       /** @name Constructors and Destructor */
       //@{
  -    /** Construct a IDOMParser, with an optional validator
  +    /** Construct a XercesDOMParser, with an optional validator
         *
         * Constructor with an instance of validator class to use for
         * validation. If you don't provide a validator, a default one will
  @@ -127,18 +127,18 @@
         * @param valToAdopt Pointer to the validator instance to use. The
         *                   parser is responsible for freeing the memory.
         */
  -    IDOMParser(XMLValidator* const valToAdopt = 0);
  +    XercesDOMParser(XMLValidator* const valToAdopt = 0);
   
       /**
         * Destructor
         */
  -    virtual ~IDOMParser();
  +    virtual ~XercesDOMParser();
   
       //@}
   
       /** Reset the parser
         *
  -      * This method resets the state of the IDOM driver and makes
  +      * This method resets the state of the DOM driver and makes
         * it ready for a fresh parse run.
         */
       void reset();
  @@ -146,16 +146,16 @@
       /** Reset the documents vector pool and release all the associated memory
         * back to the system.
         *
  -      * When parsing a document using an IDOMParser, all memory allocated
  +      * When parsing a document using an XercesDOMParser, all memory allocated
         * for a DOM tree is associated to the DOM document.
         *
  -      * If you do multiple parse using the same IDOMParser instance, then
  +      * If you do multiple parse using the same XercesDOMParser instance, then
         * multiple DOM documents will be generated and saved in a vector pool.
         * All these documents (and thus all the allocated memory)
         * won't be deleted until the parser instance is destroyed.
         *
         * If you don't need these DOM documents anymore and don't want to
  -      * destroy the IDOMParser instance at this moment, then you can call this method
  +      * destroy the XercesDOMParser instance at this moment, then you can call this method
         * to reset the document vector pool and release all the allocated memory
         * back to the system.
         *
  @@ -176,16 +176,16 @@
       /** @name Getter methods */
       //@{
   
  -    /** Get the IDOM document
  +    /** Get the DOM document
         *
  -      * This method returns the IDOM_Document object representing the
  +      * This method returns the DOMDocument object representing the
         * root of the document tree. This object provides the primary
         * access to the document's data.
         *
  -      * @return The IDOM_Document object which represents the entire
  +      * @return The DOMDocument object which represents the entire
         *         XML document.
         */
  -    IDOM_Document* getDocument();
  +    DOMDocument* getDocument();
   
       /** Get a pointer to the error handler
         *
  @@ -538,7 +538,7 @@
         * on non-validating parsers which always include non-markup text.
         * <p>When set to true (also the default), ignorable whitespaces will be
         * added to the DOM tree as text nodes.  The method
  -      * IDOM_Text::isIgnorableWhitespace() will return true for those text
  +      * DOMText::isIgnorableWhitespace() will return true for those text
         * nodes only.
         * <p>When set to false, all ignorable whitespace will be discarded and
         * no text node is added to the DOM tree.  Note: applications intended
  @@ -688,7 +688,7 @@
         *            wrapping another exception.
         * @exception XMLException An exception from the parser or client
         *            handler code.
  -      * @exception IDOM_DOMException A DOM exception as per DOM spec.
  +      * @exception DOMException A DOM exception as per DOM spec.
         * @see InputSource#InputSource
         * @see #setEntityResolver
         * @see #setErrorHandler
  @@ -711,7 +711,7 @@
         *            wrapping another exception.
         * @exception XMLException An exception from the parser or client
         *            handler code.
  -      * @exception DOM_DOMException A DOM exception as per DOM spec.
  +      * @exception DOMException A DOM exception as per DOM spec.
         * @see #parse(InputSource,...)
         */
       void parse(const XMLCh* const systemId, const bool reuseGrammar = false);
  @@ -731,7 +731,7 @@
         *            wrapping another exception.
         * @exception XMLException An exception from the parser or client
         *            handler code.
  -      * @exception DOM_DOMException A DOM exception as per DOM spec.
  +      * @exception DOMException A DOM exception as per DOM spec.
         * @see #parse(InputSource,...)
         */
       void parse(const char* const systemId, const bool reuseGrammar = false);
  @@ -949,7 +949,7 @@
         * This method allows the user installed Error Handler callback to
         * 'reset' itself.
         *
  -      * <b><font color="#FF0000">This method is a no-op for this IDOM
  +      * <b><font color="#FF0000">This method is a no-op for this DOM
         * implementation.</font></b>
         */
       virtual void resetErrors();
  @@ -968,7 +968,7 @@
         * This method is used to indicate the end of parsing of an external
         * entity file.
         *
  -      * <b><font color="#FF0000">This method is a no-op for this IDOM
  +      * <b><font color="#FF0000">This method is a no-op for this DOM
         * implementation.</font></b>
         *
         * @param inputSource A const reference to the InputSource object
  @@ -984,7 +984,7 @@
         * the XML file being parsed, such as redirection etc.
         *
         * <b><font color="#FF0000">This method always returns 'false'
  -      * for this IDOM implementation.</font></b>
  +      * for this DOM implementation.</font></b>
         *
         * @param systemId  A const pointer to an Unicode string representing
         *                  the system id scanned by the parser.
  @@ -1003,7 +1003,7 @@
         * This method allows the installed XMLEntityHandler to reset
         * itself.
         *
  -      * <b><font color="#FF0000">This method is a no-op for this IDOM
  +      * <b><font color="#FF0000">This method is a no-op for this DOM
         * implementation.</font></b>
         */
       virtual void resetEntities();
  @@ -1034,7 +1034,7 @@
         * This method is used to indicate the start of parsing an external
         * entity file.
         *
  -      * <b><font color="#FF0000">This method is a no-op for this IDOM parse
  +      * <b><font color="#FF0000">This method is a no-op for this DOM parse
         * implementation.</font></b>
         *
         * @param inputSource A const reference to the InputSource object
  @@ -1057,8 +1057,8 @@
       /** Handle document character events
         *
         * This method is used to report all the characters scanned by the
  -      * parser. This IDOM implementation stores this data in the appropriate
  -      * IDOM node, creating one if necessary.
  +      * parser. This DOM implementation stores this data in the appropriate
  +      * DOM node, creating one if necessary.
         *
         * @param chars   A const pointer to a Unicode string representing the
         *                character data.
  @@ -1113,7 +1113,7 @@
       /** Handle and end of element event
         *
         * This method is used to indicate the end tag of an element. The
  -      * IDOMParse pops the current element off the top of the element
  +      * DOMParse pops the current element off the top of the element
         * stack, and make it the new current element.
         *
         * @param elemDecl A const reference to the object containing element
  @@ -1150,7 +1150,7 @@
         * is only made, if validation is enabled.
         *
         * Any whitespace before content is ignored. If the current node is
  -      * already of type IDOM_Node::TEXT_NODE, then these whitespaces are
  +      * already of type DOMNode::TEXT_NODE, then these whitespaces are
         * appended, otherwise a new Text node is created which stores this
         * data. Essentially all contiguous ignorable characters are collected
         * in one node.
  @@ -1186,7 +1186,7 @@
         *
         * This method is used to report the start of an element. It is
         * called at the end of the element, by which time all attributes
  -      * specified are also parsed. A new IDOM Element node is created
  +      * specified are also parsed. A new DOM Element node is created
         * along with as many attribute nodes as required. This new element
         * is added appended as a child of the current node in the tree, and
         * then replaces it as the current node (if the isEmpty flag is false.)
  @@ -1224,7 +1224,7 @@
         *
         * This method is used to indicate the start of an entity reference.
         * If the expand entity reference flag is true, then a new
  -      * IDOM Entity reference node is created.
  +      * DOM Entity reference node is created.
         *
         * @param entDecl A const reference to the object containing the
         *                entity declaration information.
  @@ -1239,7 +1239,7 @@
         * This method is used to report the XML decl scanned by the parser.
         * Refer to the XML specification to see the meaning of parameters.
         *
  -      * <b><font color="#FF0000">This method is a no-op for this IDOM
  +      * <b><font color="#FF0000">This method is a no-op for this DOM
         * implementation.</font></b>
         *
         * @param versionStr A const pointer to a Unicode string representing
  @@ -1382,12 +1382,12 @@
   
       /** @name Protected getter methods */
       //@{
  -    /** Get the current IDOM node
  +    /** Get the current DOM node
         *
         * This provides derived classes with access to the current node, i.e.
         * the node to which new nodes are being added.
         */
  -    IDOM_Node* getCurrentNode();
  +    DOMNode* getCurrentNode();
   
       //@}
   
  @@ -1399,28 +1399,28 @@
       /** @name Protected setter methods */
       //@{
   
  -    /** Set the current IDOM node
  +    /** Set the current DOM node
         *
         * This method sets the current node maintained inside the parser to
         * the one specified.
         *
  -      * @param toSet The IDOM node which will be the current node.
  +      * @param toSet The DOM node which will be the current node.
         */
  -    void setCurrentNode(IDOM_Node* toSet);
  +    void setCurrentNode(DOMNode* toSet);
   
       /** Set the document node
         *
  -      * This method sets the IDOM Document node to the one specified.
  +      * This method sets the DOM Document node to the one specified.
         *
  -      * @param toSet The new IDOM Document node for this XML document.
  +      * @param toSet The new DOM Document node for this XML document.
         */
  -    void setDocument(IDOM_Document* toSet);
  +    void setDocument(DOMDocument* toSet);
       //@}
   
       // -----------------------------------------------------------------------
       //  Protected Helper methods
       // -----------------------------------------------------------------------
  -    virtual IDOM_Element* createElementNSNode(const XMLCh *fNamespaceURI,
  +    virtual DOMElement* createElementNSNode(const XMLCh *fNamespaceURI,
                                                 const XMLCh *qualifiedName);
   
   
  @@ -1458,7 +1458,7 @@
       //
       //  fIncludeIgnorableWhitespace
       //      Indicates whether ignorable whiltespace should be added to
  -    //      the IDOM tree for validating parsers.
  +    //      the DOM tree for validating parsers.
       //
       //  fNodeStack
       //      Used to track previous parent nodes during nested element events.
  @@ -1483,124 +1483,124 @@
       //      Store all the previous fDocument(s) (thus not the current fDocument)
       //      created in this parser.  It is destroyed when the parser is destructed.
       // -----------------------------------------------------------------------
  -    IDOM_Node*               fCurrentParent;
  -    IDOM_Node*               fCurrentNode;
  -    IDDocumentImpl*          fDocument;
  +    DOMNode*                 fCurrentParent;
  +    DOMNode*                 fCurrentNode;
  +    DOMDocumentImpl*         fDocument;
       EntityResolver*          fEntityResolver;
       ErrorHandler*            fErrorHandler;
       bool                     fCreateEntityReferenceNodes;
       bool                     fIncludeIgnorableWhitespace;
  -    ValueStackOf<IDOM_Node*>* fNodeStack;
  +    ValueStackOf<DOMNode*>* fNodeStack;
       bool                     fParseInProgress;
       bool                     fWithinElement;
  -    IDDocumentTypeImpl*      fDocumentType;
  -    RefVectorOf<IDDocumentImpl>* fDocumentVector;
  +    DOMDocumentTypeImpl*     fDocumentType;
  +    RefVectorOf<DOMDocumentImpl>* fDocumentVector;
   };
   
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Handlers for the XMLEntityHandler interface
  +//  XercesDOMParser: Handlers for the XMLEntityHandler interface
   // ---------------------------------------------------------------------------
  -inline void IDOMParser::endInputSource(const InputSource&)
  +inline void XercesDOMParser::endInputSource(const InputSource&)
   {
  -    // The IDOM entity resolver doesn't handle this
  +    // The DOM entity resolver doesn't handle this
   }
   
  -inline bool IDOMParser::expandSystemId(const XMLCh* const, XMLBuffer&)
  +inline bool XercesDOMParser::expandSystemId(const XMLCh* const, XMLBuffer&)
   {
  -    // The IDOM entity resolver doesn't handle this
  +    // The DOM entity resolver doesn't handle this
       return false;
   }
   
  -inline void IDOMParser::resetEntities()
  +inline void XercesDOMParser::resetEntities()
   {
       // Nothing to do on this one
   }
   
  -inline void IDOMParser::startInputSource(const InputSource&)
  +inline void XercesDOMParser::startInputSource(const InputSource&)
   {
  -    // The IDOM entity resolver doesn't handle this
  +    // The DOM entity resolver doesn't handle this
   }
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Getter methods
  +//  XercesDOMParser: Getter methods
   // ---------------------------------------------------------------------------
  -inline ErrorHandler* IDOMParser::getErrorHandler()
  +inline ErrorHandler* XercesDOMParser::getErrorHandler()
   {
       return fErrorHandler;
   }
   
  -inline const ErrorHandler* IDOMParser::getErrorHandler() const
  +inline const ErrorHandler* XercesDOMParser::getErrorHandler() const
   {
       return fErrorHandler;
   }
   
  -inline EntityResolver* IDOMParser::getEntityResolver()
  +inline EntityResolver* XercesDOMParser::getEntityResolver()
   {
       return fEntityResolver;
   }
   
  -inline const EntityResolver* IDOMParser::getEntityResolver() const
  +inline const EntityResolver* XercesDOMParser::getEntityResolver() const
   {
       return fEntityResolver;
   }
   
  -inline bool IDOMParser::getExpandEntityReferences() const
  +inline bool XercesDOMParser::getExpandEntityReferences() const
   {
       return !fCreateEntityReferenceNodes;
   }
  -inline bool IDOMParser::getCreateEntityReferenceNodes() const
  +inline bool XercesDOMParser::getCreateEntityReferenceNodes() const
   {
       return fCreateEntityReferenceNodes;
   }
   
  -inline bool IDOMParser::getIncludeIgnorableWhitespace() const
  +inline bool XercesDOMParser::getIncludeIgnorableWhitespace() const
   {
       return fIncludeIgnorableWhitespace;
   }
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Setter methods
  +//  XercesDOMParser: Setter methods
   // ---------------------------------------------------------------------------
  -inline void IDOMParser::setExpandEntityReferences(const bool expand)
  +inline void XercesDOMParser::setExpandEntityReferences(const bool expand)
   {
       fCreateEntityReferenceNodes = !expand;
   }
   
  -inline void IDOMParser::setCreateEntityReferenceNodes(const bool create)
  +inline void XercesDOMParser::setCreateEntityReferenceNodes(const bool create)
   {
       fCreateEntityReferenceNodes = create;
   }
   
  -inline void IDOMParser::setIncludeIgnorableWhitespace(const bool include)
  +inline void XercesDOMParser::setIncludeIgnorableWhitespace(const bool include)
   {
       fIncludeIgnorableWhitespace = include;
   }
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Protected getter methods
  +//  XercesDOMParser: Protected getter methods
   // ---------------------------------------------------------------------------
  -inline IDOM_Node* IDOMParser::getCurrentNode()
  +inline DOMNode* XercesDOMParser::getCurrentNode()
   {
       return fCurrentNode;
   }
   
   
   // ---------------------------------------------------------------------------
  -//  IDOMParser: Protected setter methods
  +//  XercesDOMParser: Protected setter methods
   // ---------------------------------------------------------------------------
  -inline void IDOMParser::setCurrentNode(IDOM_Node* toSet)
  +inline void XercesDOMParser::setCurrentNode(DOMNode* toSet)
   {
       fCurrentNode = toSet;
   }
   
  -inline void IDOMParser::setDocument(IDOM_Document* toSet)
  +inline void XercesDOMParser::setDocument(DOMDocument* toSet)
   {
  -    fDocument = (IDDocumentImpl *)toSet;
  +    fDocument = (DOMDocumentImpl*)toSet;
   }
   
   #endif
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: xerces-cvs-unsubscribe@xml.apache.org
For additional commands, e-mail: xerces-cvs-help@xml.apache.org