Ignore:
Timestamp:
May 3, 2013, 11:28:28 AM (6 years ago)
Author:
cameron
Message:

Initial imports for icXML v0.9

File:
1 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/src/icxercesc/parsers/SAX2XMLReaderImpl.cpp

    r2807 r3103  
    4141#include <xercesc/util/XMLEntityResolver.hpp>
    4242#include <icxmlc/XMLStringU.hpp>
     43#include <icxmlc/XMLNamespaceResolver.hpp>
    4344
    4445XERCES_CPP_NAMESPACE_BEGIN
     
    7677        , fAdvDHListSize(32)
    7778        , fDocHandler(0)
    78         , fTempAttrVec(0)
    79         , fPrefixesStorage(0)
    80         , fPrefixes(0)
    81         , fPrefixCounts(0)
    82         , fDTDHandler(0)
     79    , fLastNamespaceContextId(0)
     80    , fDTDHandler(0)
    8381        , fEntityResolver(0)
    8482        , fXMLEntityResolver(0)
     
    9088        , fScanner(0)
    9189        , fGrammarResolver(0)
    92         , fValidator(0)
    93         , fMemoryManager(manager)
    94         , fGrammarPool(gramPool)
     90        , fValidator(0)
     91    , fGrammarPool(gramPool)
     92    , fNamespaceAttrList(10, false, manager)
     93    , fMemoryManager(manager)
    9594{
    9695        CleanupType cleanup(this, &SAX2XMLReaderImpl::cleanUp);
     
    141140        setDoSchema(true);
    142141
    143         fPrefixesStorage = new (fMemoryManager) XMLStringPool(109, fMemoryManager) ;
    144         fPrefixes        = new (fMemoryManager) ValueStackOf<unsigned int> (30, fMemoryManager) ;
    145         fTempAttrVec     = new (fMemoryManager) RefVectorOf<XMLAttr>  (10, false, fMemoryManager) ;
    146         fPrefixCounts    = new (fMemoryManager) ValueStackOf<XMLSize_t>(10, fMemoryManager) ;
     142    fNamespaceContextId = -1;
    147143}
    148144
     
    152148        fMemoryManager->deallocate(fAdvDHList);//delete [] fAdvDHList;
    153149        delete fScanner;
    154         delete fPrefixesStorage;
    155         delete fPrefixes;
    156         delete fTempAttrVec;
    157         delete fPrefixCounts;
    158         delete fGrammarResolver;
     150    delete fGrammarResolver;
    159151}
    160152
     
    554546
    555547
    556 void SAX2XMLReaderImpl::XMLDecl( const  XMLCh* const    versionStr
    557                                                 , const XMLCh* const    encodingStr
    558                                                 , const XMLCh* const    standaloneStr
    559                                                 , const XMLCh* const    actualEncodingStr
    560                                                 )
     548void SAX2XMLReaderImpl::XMLDecl
     549(
     550    const  XMLCh* const    versionStr
     551    , const XMLCh* const    encodingStr
     552    , const XMLCh* const    standaloneStr
     553    , const XMLCh* const    actualEncodingStr
     554)
    561555{
    562556        // SAX has no way to report this event. But, if there are any installed
     
    648642        // Make sure our element depth flag gets set back to zero
    649643        fElemDepth = 0;
    650 
    651         // reset prefix counters and prefix map
    652         fPrefixCounts->removeAllElements();
    653         fPrefixes->removeAllElements();
    654         fPrefixesStorage->flushAll();
    655644}
    656645
     
    672661}
    673662
    674 
    675 void SAX2XMLReaderImpl::
    676 startElement(   const   XMLElementDecl&         elemDecl
    677                                 , const unsigned int            elemURLId
    678                                 , const XMLCh* const            elemPrefix
    679                                 , const RefVectorOf<XMLAttr>&   attrList
    680                                 , const XMLSize_t               attrCount
    681                                 , const bool                    isEmpty
    682                                 , const bool                    isRoot)
     663void SAX2XMLReaderImpl::startElement
     664(
     665    const XMLElementDecl &          elemDecl
     666    , const unsigned int            elemURLId
     667    , const XMLCh* const            elemPrefix
     668    , const RefVectorOf<XMLAttr>&   attrList
     669    , const XMLSize_t               attrCount
     670    , const bool                    isEmpty
     671    , const bool                    isRoot
     672)
    683673{
    684674        // Bump the element depth counter if not empty
     
    686676                fElemDepth++;
    687677
    688     DEBUG_MESSAGE("SAX2XMLReaderImpl::startElement(" << elemDecl << ',' << elemURLId << ',' << elemPrefix << ",AttList=" << attrList << ',' << attrCount << ',' << isEmpty << ',' << isRoot << ')')
    689 
    690678        if (fDocHandler)
    691679        {
    692                 const QName* qName=elemDecl.getElementName();
    693                 const XMLCh* baseName=qName->getLocalPart();
    694                 const XMLCh* elemQName = elemDecl.getFullName();
     680        const QName * qName = elemDecl.getElementName();
     681        const XMLCh * baseName = qName->getLocalPart();
     682        const XMLCh * elemQName = elemDecl.getFullName();
    695683        const XMLCh * elemUri = XMLUni::fgZeroLenString;
     684
     685        bool modifiedNamespace = 0;
     686        gid_t lastNamespaceContextId = 0;
    696687
    697688                if (getDoNamespaces())
    698689                {
    699                         XMLSize_t numPrefix = 0;
    700 
    701                         if (!fNamespacePrefix)
    702                                 fTempAttrVec->removeAllElements();
    703 
    704                         for (XMLSize_t i = 0; i < attrCount; i++)
    705                         {
    706                                 const XMLCh*   nsPrefix = 0;
    707                                 const XMLCh*   nsURI    = 0;
    708                                 const XMLAttr* tempAttr = attrList.elementAt(i);
    709                                 unsigned int attrUriId = tempAttr->getURIId();
    710 
    711 
    712                 #ifndef BIND_ALL_XMLNS_SYMBOLS_TO_THE_XMLNS_NAMESPACE
    713                                 if (attrUriId == XMLNamespaceResolver::fEmptyUriId)
    714                                 {
    715                                         if (XMLStringU::isXMLNS(tempAttr->getName()))
    716                                         {
    717                                                 nsPrefix = XMLUni::fgZeroLenString;
    718                                                 nsURI = tempAttr->getValue();
    719                                         }
    720                                 }
    721                 else
    722                 #endif
    723                 if (attrUriId == XMLNamespaceResolver::fXMLNSUriId)
    724                                 {
    725                                         nsPrefix = tempAttr->getName();
    726                                         nsURI = tempAttr->getValue();
    727                                 }
    728 
    729                                 if (nsURI)
    730                                 {
    731                                         if (fDocHandler)
    732                                         {
    733                                                 fDocHandler->startPrefixMapping(nsPrefix, nsURI);
    734                                         }
    735                     unsigned int nPrefixId = fPrefixesStorage->addOrFind(nsPrefix);
    736                                         fPrefixes->push(nPrefixId) ;
    737                                         numPrefix++;
    738                                 }
    739                                 else if (!fNamespacePrefix)
    740                                 {
    741                                         fTempAttrVec->addElement((XMLAttr*)tempAttr);
    742                                 }
    743                         }
    744                         fPrefixCounts->push(numPrefix) ;
    745                         if (!fNamespacePrefix)
    746                                 fAttrList.setVector(fTempAttrVec, fTempAttrVec->size(), fScanner);
    747                         else
    748                                 fAttrList.setVector(&attrList, attrCount, fScanner);
    749 
    750                 }
     690            modifiedNamespace = (this->fNamespaceContextId != fLastNamespaceContextId);
     691
     692
     693
     694            if (unlikely(modifiedNamespace))
     695            {
     696                const XMLNamespaceResolver * resolver = fScanner->getUriResolver();
     697                MaskedBindingSetIterator itr = resolver->getNamespaceIterator(fNamespaceContextId, fLastNamespaceContextId);
     698                while (itr.next())
     699                {
     700                    const XMLCh * prefix = resolver->getPrefixForNamespaceId(itr.pos());
     701                    const XMLCh * uri = resolver->getUriForNamespaceId(itr.pos());
     702                    fDocHandler->startPrefixMapping(prefix, uri);
     703                }
     704
     705                lastNamespaceContextId = fLastNamespaceContextId;
     706                fLastNamespaceContextId = fNamespaceContextId;
     707
     708                if (unlikely(attrCount > fNamespaceAttrList.fMaxCount))
     709                {
     710                    fNamespaceAttrList.ensureExtraCapacity(attrCount - fNamespaceAttrList.fMaxCount);
     711                }
     712                fNamespaceAttrList.fCurCount = fNamespaceAttrList.fMaxCount;
     713
     714                XMLSize_t namespaceAttrCount = 0;
     715                for (XMLSize_t i = 0; i < attrCount; i++)
     716                {
     717                    const XMLAttr * attr = attrList.elementAt(i);
     718                    if (attr->getURIId() != XMLNamespaceResolver::fXMLNSUriId)
     719                    {
     720                        fNamespaceAttrList.setElementAt(const_cast<XMLAttr*>(attr), namespaceAttrCount++);
     721                    }
     722                }
     723
     724
     725
     726                fNamespaceAttrList.fCurCount = namespaceAttrCount;
     727                fAttrList.setVector(&fNamespaceAttrList, namespaceAttrCount, fScanner);
     728            }
     729            else
     730            {
     731                fAttrList.setVector(&attrList, attrCount, fScanner);
     732            }
     733
     734        }
    751735                else // no namespace
    752736                {
     
    755739                }
    756740
    757         // call startElement() with namespace declarations
    758         if (fDocHandler)
    759         {
    760             elemUri = fScanner->getURIText(elemURLId);
    761 
    762             fDocHandler->startElement
    763             (
    764                 elemUri
    765                 , baseName
    766                 , elemQName
    767                 , fAttrList
    768             );
    769         }
     741        elemUri = fScanner->getURIText(elemURLId);
     742
     743        fDocHandler->startElement
     744        (
     745            elemUri
     746            , baseName
     747            , elemQName
     748            , fAttrList
     749        );
    770750
    771751                // If its empty, send the end tag event now
    772752                if (isEmpty)
    773753                {
    774             if (fDocHandler)
    775             {
    776                 fDocHandler->endElement
    777                 (
    778                     elemUri
    779                     , baseName
    780                     , elemQName
    781                 );
    782             }
     754            fDocHandler->endElement(elemUri, baseName, elemQName);
    783755
    784756                        // call endPrefixMapping appropriately.
    785                         if (getDoNamespaces())
     757            if (modifiedNamespace)
    786758                        {
    787                                 XMLSize_t numPrefix = fPrefixCounts->pop();
    788                                 for (XMLSize_t i = 0; i < numPrefix; ++i)
    789                                 {
    790                                         unsigned int nPrefixId = fPrefixes->pop();
    791                                         if (fDocHandler)
    792                                                 fDocHandler->endPrefixMapping(fPrefixesStorage->getValueForId(nPrefixId));
    793                                 }
     759                const XMLNamespaceResolver * resolver = fScanner->getUriResolver();
     760                MaskedBindingSetIterator itr = resolver->getNamespaceIterator(fNamespaceContextId, lastNamespaceContextId);
     761                while (itr.next())
     762                {
     763                    const XMLCh * prefix = resolver->getPrefixForNamespaceId(itr.pos());
     764                    fDocHandler->endPrefixMapping(prefix);
     765                }
     766                fLastNamespaceContextId = lastNamespaceContextId;
    794767                        }
    795 
    796768                }
    797         }
    798 
    799         //
    800         //  If there are any installed advanced handlers, then lets call them
    801         //  with this info.
    802         //
    803         for (XMLSize_t index = 0; index < fAdvDHCount; index++)
    804         {
    805                 fAdvDHList[index]->startElement
    806                 (
    807                         elemDecl
    808                         , elemURLId
    809                         , elemPrefix
    810                         , attrList
    811                         , attrCount
    812                         , isEmpty
    813                         , isRoot
    814                 );
    815         }
    816 }
    817 
    818 void SAX2XMLReaderImpl::endElement( const   XMLElementDecl& elemDecl
    819                                                         , const unsigned int    uriId
    820                                                         , const bool            isRoot
    821                                                         , const XMLCh* const    elemPrefix)
    822 {
    823 
    824     // DEBUG_MESSAGE("SAX2XMLReaderImpl::endElement(" << elemDecl << ',' << uriId << ',' << isRoot << ',' << elemPrefix << ')')
    825 
     769
     770
     771    }
     772
     773    if (unlikely(fAdvDHCount > 0))
     774    {
     775        //
     776        //  If there are any installed advanced handlers, then we need to call them -- however all xmlns attributes
     777        //  were surpressed by the Parser from the attribute list.
     778        //
     779
     780        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
     781        {
     782            fAdvDHList[index]->startElement
     783            (
     784                elemDecl
     785                , elemURLId
     786                , elemPrefix
     787                , attrList
     788                , attrCount
     789                , isEmpty
     790                , isRoot
     791            );
     792        }
     793
     794    }
     795}
     796
     797void SAX2XMLReaderImpl::endElement
     798(
     799    const XMLElementDecl& elemDecl
     800    , const unsigned int    uriId
     801    , const bool            isRoot
     802    , const XMLCh* const    elemPrefix
     803)
     804{
    826805        // Just map to the SAX document handler
    827806        if (fDocHandler)
     
    831810                const XMLCh* elemQName = elemDecl.getFullName();
    832811
    833 //              const XMLCh* elemQName = 0;
    834 //              if(elemPrefix==0 || *elemPrefix==0)
    835 //                      elemQName=baseName;
    836 //              else if(XMLString::equals(elemPrefix, qName->getPrefix()))
    837 //                      elemQName=qName->getRawName();
    838 //              else
    839 //              {
    840 //                      fTempQName->set(elemPrefix);
    841 //                      fTempQName->append(chColon);
    842 //                      fTempQName->append(baseName);
    843 //                      elemQName=fTempQName->getRawBuffer();
    844 //              }
    845812
    846813                if (getDoNamespaces())
    847814                {
    848             if (fDocHandler)
    849                         {
    850                                 fDocHandler->endElement
    851                                 (
    852                                         fScanner->getURIText(uriId)
    853                                         , baseName
    854                                         , elemQName
    855                                 );
    856                         }
    857 
    858                         // get the prefixes back so that we can call endPrefixMapping()
    859                         XMLSize_t numPrefix = fPrefixCounts->pop();
    860                         for (XMLSize_t i = 0; i < numPrefix; i++)
    861                         {
    862                                 unsigned int nPrefixId = fPrefixes->pop();
    863                                 if (fDocHandler)
    864                                 {
    865                                         fDocHandler->endPrefixMapping(fPrefixesStorage->getValueForId(nPrefixId));
    866                                 }
    867                         }
    868                 }
     815            fDocHandler->endElement(fScanner->getURIText(uriId), baseName, elemQName);
     816            if (unlikely(fNamespaceContextId != fLastNamespaceContextId))
     817            {
     818                const XMLNamespaceResolver * resolver = fScanner->getUriResolver();
     819                MaskedBindingSetIterator itr = resolver->getNamespaceIterator(fLastNamespaceContextId, fNamespaceContextId);
     820                while (itr.next())
     821                {
     822                    const XMLCh * prefix = resolver->getPrefixForNamespaceId(itr.pos());
     823                    fDocHandler->endPrefixMapping(prefix);
     824                }
     825                fLastNamespaceContextId = fNamespaceContextId;
     826            }
     827
     828        }
    869829                else
    870830                {
    871                         if(fDocHandler)
    872                         {
    873                                 fDocHandler->endElement
    874                                 (
    875                                         XMLUni::fgZeroLenString,
    876                                         XMLUni::fgZeroLenString,
    877                                         elemQName
    878                                 );
    879                         }
     831            fDocHandler->endElement(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, elemQName);
    880832                }
    881833        }
Note: See TracChangeset for help on using the changeset viewer.