source: icXML/icXML-devel/src/icxercesc/parsers/SAX2XMLReaderImpl.cpp @ 3103

Last change on this file since 3103 was 3103, checked in by cameron, 6 years ago

Initial imports for icXML v0.9

File size: 43.6 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: SAX2XMLReaderImpl.cpp 882548 2009-11-20 13:44:14Z borisk $
20 */
21
22#include <xercesc/util/IOException.hpp>
23#include <xercesc/util/RefStackOf.hpp>
24#include <xercesc/util/XMLUniDefs.hpp>
25#include <xercesc/util/Janitor.hpp>
26#include <xercesc/sax2/ContentHandler.hpp>
27#include <xercesc/sax2/LexicalHandler.hpp>
28#include <xercesc/sax2/DeclHandler.hpp>
29#include <xercesc/sax2/XMLReaderFactory.hpp>
30#include <xercesc/sax/DTDHandler.hpp>
31#include <xercesc/sax/ErrorHandler.hpp>
32#include <xercesc/sax/EntityResolver.hpp>
33#include <xercesc/sax/SAXParseException.hpp>
34#include <xercesc/sax/SAXException.hpp>
35#include <xercesc/internal/XMLScannerResolver.hpp>
36#include <icxercesc/parsers/SAX2XMLReaderImpl.hpp>
37#include <icxercesc/validators/common/GrammarResolver.hpp>
38#include <icxercesc/framework/XMLGrammarPool.hpp>
39#include <xercesc/framework/XMLSchemaDescription.hpp>
40#include <xercesc/util/OutOfMemoryException.hpp>
41#include <xercesc/util/XMLEntityResolver.hpp>
42#include <icxmlc/XMLStringU.hpp>
43#include <icxmlc/XMLNamespaceResolver.hpp>
44
45XERCES_CPP_NAMESPACE_BEGIN
46
47
48SAX2XMLReader * XMLReaderFactory::createXMLReader(  MemoryManager* const  manager
49                                                                                                  , XMLGrammarPool* const gramPool)
50{
51        SAX2XMLReaderImpl* pImpl=new (manager) SAX2XMLReaderImpl(manager, gramPool);
52        return pImpl;
53}
54
55
56const XMLCh gDTDEntityStr[] =
57{
58        chOpenSquare, chLatin_d, chLatin_t, chLatin_d, chCloseSquare, chNull
59};
60
61
62
63typedef JanitorMemFunCall<SAX2XMLReaderImpl>    CleanupType;
64typedef JanitorMemFunCall<SAX2XMLReaderImpl>    ResetInProgressType;
65
66
67SAX2XMLReaderImpl::SAX2XMLReaderImpl(MemoryManager* const  manager
68                                                                   , XMLGrammarPool* const gramPool):
69
70        fNamespacePrefix(false)
71        , fAutoValidation(false)
72        , fValidation(false)
73        , fParseInProgress(false)
74        , fHasExternalSubset(false)
75        , fElemDepth(0)
76        , fAdvDHCount(0)
77        , fAdvDHListSize(32)
78        , fDocHandler(0)
79    , fLastNamespaceContextId(0)
80    , fDTDHandler(0)
81        , fEntityResolver(0)
82        , fXMLEntityResolver(0)
83        , fErrorHandler(0)
84        , fPSVIHandler(0)
85        , fLexicalHandler(0)
86        , fDeclHandler(0)
87        , fAdvDHList(0)
88        , fScanner(0)
89        , fGrammarResolver(0)
90        , fValidator(0) 
91    , fGrammarPool(gramPool)
92    , fNamespaceAttrList(10, false, manager)
93    , fMemoryManager(manager)
94{
95        CleanupType cleanup(this, &SAX2XMLReaderImpl::cleanUp);
96
97        try
98        {
99                initialize();
100        }
101        catch(const OutOfMemoryException&)
102        {
103                // Don't cleanup when out of memory, since executing the
104                // code can cause problems.
105                cleanup.release();
106
107                throw;
108        }
109
110        cleanup.release();
111}
112
113SAX2XMLReaderImpl::~SAX2XMLReaderImpl()
114{
115        cleanUp();
116}
117
118// ---------------------------------------------------------------------------
119//  SAX2XMLReaderImpl: Initialize/Cleanup methods
120// ---------------------------------------------------------------------------
121void SAX2XMLReaderImpl::initialize()
122{
123        // Create grammar resolver and string pool that we pass to the scanner
124        fGrammarResolver = new (fMemoryManager) GrammarResolver(fGrammarPool, fMemoryManager);
125        //  Create a scanner and tell it what validator to use. Then set us
126        //  as the document event handler so we can fill the DOM document.
127        fScanner = XMLScannerResolver::getDefaultScanner(0, fGrammarResolver, fMemoryManager);
128
129        // Create the initial advanced handler list array and zero it out
130        fAdvDHList = (XMLDocumentHandler**) fMemoryManager->allocate
131        (
132                fAdvDHListSize * sizeof(XMLDocumentHandler*)
133        );//new XMLDocumentHandler*[fAdvDHListSize];
134        memset(fAdvDHList, 0, sizeof(void*) * fAdvDHListSize);
135
136        // SAX2 default is for namespaces (feature http://xml.org/sax/features/namespaces) to be on
137        setDoNamespaces(true) ;
138
139        // default: schema is on
140        setDoSchema(true);
141
142    fNamespaceContextId = -1;
143}
144
145
146void SAX2XMLReaderImpl::cleanUp()
147{
148        fMemoryManager->deallocate(fAdvDHList);//delete [] fAdvDHList;
149        delete fScanner;
150    delete fGrammarResolver;
151}
152
153// ---------------------------------------------------------------------------
154//  SAX2XMLReaderImpl: Advanced document handler list maintenance methods
155// ---------------------------------------------------------------------------
156void SAX2XMLReaderImpl::installAdvDocHandler(XMLDocumentHandler* const toInstall)
157{
158        // See if we need to expand and do so now if needed
159        if (fAdvDHCount == fAdvDHListSize)
160        {
161                // Calc a new size and allocate the new temp buffer
162                const XMLSize_t newSize = (XMLSize_t)(fAdvDHListSize * 1.5);
163                XMLDocumentHandler** newList = (XMLDocumentHandler**) fMemoryManager->allocate
164                (
165                        newSize * sizeof(XMLDocumentHandler*)
166                );//new XMLDocumentHandler*[newSize];
167
168                // Copy over the old data to the new list and zero out the rest
169                memcpy(newList, fAdvDHList, sizeof(void*) * fAdvDHListSize);
170                memset
171                (
172                        &newList[fAdvDHListSize]
173                        , 0
174                        , sizeof(void*) * (newSize - fAdvDHListSize)
175                );
176
177                // And now clean up the old array and store the new stuff
178                fMemoryManager->deallocate(fAdvDHList);//delete [] fAdvDHList;
179                fAdvDHList = newList;
180                fAdvDHListSize = newSize;
181        }
182
183        // Add this new guy into the empty slot
184        fAdvDHList[fAdvDHCount++] = toInstall;
185
186        //
187        //  Install ourself as the document handler with the scanner. We might
188        //  already be, but its not worth checking, just do it.
189        //
190        fScanner->setDocHandler(this);
191}
192
193
194bool SAX2XMLReaderImpl::removeAdvDocHandler(XMLDocumentHandler* const toRemove)
195{
196        // If our count is zero, can't be any installed
197        if (!fAdvDHCount)
198                return false;
199
200        //
201        //  Search the array until we find this handler. If we find a null entry
202        //  first, we can stop there before the list is kept contiguous.
203        //
204        XMLSize_t index;
205        for (index = 0; index < fAdvDHCount; index++)
206        {
207                //
208                //  We found it. We have to keep the list contiguous, so we have to
209                //  copy down any used elements after this one.
210                //
211                if (fAdvDHList[index] == toRemove)
212                {
213                        //
214                        //  Optimize if only one entry (pretty common). Otherwise, we
215                        //  have to copy them down to compact them.
216                        //
217                        if (fAdvDHCount > 1)
218                        {
219                                index++;
220                                while (index < fAdvDHCount)
221                                        fAdvDHList[index - 1] = fAdvDHList[index];
222                        }
223
224                        // Bump down the count and zero out the last one
225                        fAdvDHCount--;
226                        fAdvDHList[fAdvDHCount] = 0;
227
228                        //
229                        //  If this leaves us with no advanced handlers and there is
230                        //  no SAX doc handler installed on us, then remove us from the
231                        //  scanner as the document handler.
232                        //
233                        if (!fAdvDHCount && !fDocHandler)
234                                fScanner->setDocHandler(0);
235
236                        return true;
237                }
238        }
239
240        // Never found it
241        return false;
242}
243
244// ---------------------------------------------------------------------------
245//  SAX2XMLReaderImpl Validator functions
246// ---------------------------------------------------------------------------
247void SAX2XMLReaderImpl::setValidator(XMLValidator* valueToAdopt)
248{
249        fValidator = valueToAdopt;
250        fScanner->setValidator(valueToAdopt);
251}
252
253XMLValidator* SAX2XMLReaderImpl::getValidator() const
254{
255        return fScanner->getValidator();
256}
257
258// ---------------------------------------------------------------------------
259//  SAX2XMLReader Interface
260// ---------------------------------------------------------------------------
261XMLSize_t SAX2XMLReaderImpl::getErrorCount() const
262{
263        return fScanner->getErrorCount();
264}
265
266void SAX2XMLReaderImpl::setContentHandler(ContentHandler* const handler)
267{
268        fDocHandler = handler;
269        if (fDocHandler)
270        {
271                //
272                //  Make sure we are set as the document handler with the scanner.
273                //  We may already be (if advanced handlers are installed), but its
274                //  not worthing checking, just do it.
275                //
276                fScanner->setDocHandler(this);
277        }
278         else
279        {
280                //
281                //  If we don't have any advanced handlers either, then deinstall us
282                //  from the scanner because we don't need document events anymore.
283                //
284                if (!fAdvDHCount)
285                        fScanner->setDocHandler(0);
286        }
287
288}
289
290void SAX2XMLReaderImpl::setDTDHandler(DTDHandler* const handler)
291{
292        fDTDHandler = handler;
293        if (fDTDHandler)
294                fScanner->setDocTypeHandler(this);
295        else
296                fScanner->setDocTypeHandler(0);
297}
298
299
300void SAX2XMLReaderImpl::setErrorHandler(ErrorHandler* const handler)
301{
302        //
303        //  Store the handler. Then either install or deinstall us as the
304        //  error reporter on the scanner.
305        //
306        fErrorHandler = handler;
307        if (fErrorHandler) {
308                fScanner->setErrorReporter(this);
309                fScanner->setErrorHandler(fErrorHandler);
310        }
311        else {
312                fScanner->setErrorReporter(0);
313                fScanner->setErrorHandler(0);
314        }
315}
316
317void SAX2XMLReaderImpl::setPSVIHandler(PSVIHandler* const handler)
318{
319        fPSVIHandler = handler;
320        if (fPSVIHandler) {
321                fScanner->setPSVIHandler(fPSVIHandler);
322        }
323        else {
324                fScanner->setPSVIHandler(0);
325        }
326}
327
328void SAX2XMLReaderImpl::setLexicalHandler(LexicalHandler* const handler)
329{
330        fLexicalHandler = handler;
331        if (fLexicalHandler)
332                fScanner->setDocTypeHandler(this);
333        else
334                fScanner->setDocTypeHandler(0);
335}
336
337void SAX2XMLReaderImpl::setDeclarationHandler(DeclHandler* const handler)
338{
339        fDeclHandler = handler;
340        if (fDeclHandler)
341                fScanner->setDocTypeHandler(this);
342        else
343                fScanner->setDocTypeHandler(0);
344}
345
346
347void SAX2XMLReaderImpl::setEntityResolver(EntityResolver* const resolver)
348{
349        fEntityResolver = resolver;
350        if (fEntityResolver) {
351                fScanner->setEntityHandler(this);
352                fXMLEntityResolver = 0;
353        }
354        else {
355                fScanner->setEntityHandler(0);
356        }
357}
358
359void SAX2XMLReaderImpl::setXMLEntityResolver(XMLEntityResolver* const resolver)
360{
361        fXMLEntityResolver = resolver;
362        if (fXMLEntityResolver) {
363                fScanner->setEntityHandler(this);
364                fEntityResolver = 0;
365        }
366        else {
367                fScanner->setEntityHandler(0);
368        }
369}
370
371void SAX2XMLReaderImpl::setExitOnFirstFatalError(const bool newState)
372{
373        fScanner->setExitOnFirstFatal(newState);
374}
375
376void SAX2XMLReaderImpl::setValidationConstraintFatal(const bool newState)
377{
378        fScanner->setValidationConstraintFatal(newState);
379}
380
381void SAX2XMLReaderImpl::parse (const   InputSource&    source)
382{
383        // Avoid multiple entrance
384        if (fParseInProgress)
385                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
386
387        ResetInProgressType     resetInProgress(this, &SAX2XMLReaderImpl::resetInProgress);
388
389        try
390        {
391                fParseInProgress = true;
392                fScanner->scanDocument(source);
393        }
394        catch(const OutOfMemoryException&)
395        {
396                resetInProgress.release();
397
398                throw;
399        }
400}
401
402void SAX2XMLReaderImpl::parse (const   XMLCh* const    systemId)
403{
404        // Avoid multiple entrance
405        if (fParseInProgress)
406                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
407
408        ResetInProgressType     resetInProgress(this, &SAX2XMLReaderImpl::resetInProgress);
409
410        try
411        {
412                fParseInProgress = true;
413                fScanner->scanDocument(systemId);
414        }
415        catch(const OutOfMemoryException&)
416        {
417                resetInProgress.release();
418
419                throw;
420        }
421}
422
423void SAX2XMLReaderImpl::parse (const   char* const     systemId)
424{
425        // Avoid multiple entrance
426        if (fParseInProgress)
427                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
428
429        ResetInProgressType     resetInProgress(this, &SAX2XMLReaderImpl::resetInProgress);
430
431        try
432        {
433                fParseInProgress = true;
434                fScanner->scanDocument(systemId);
435        }
436        catch(const OutOfMemoryException&)
437        {
438                resetInProgress.release();
439
440                throw;
441        }
442}
443
444// ---------------------------------------------------------------------------
445//  SAX2XMLReaderImpl: Progressive parse methods
446// ---------------------------------------------------------------------------
447bool SAX2XMLReaderImpl::parseFirst( const   XMLCh* const    systemId
448                                                        ,       XMLPScanToken&  toFill)
449{
450        //
451        //  Avoid multiple entrance. We cannot enter here while a regular parse
452        //  is in progress.
453        //
454        if (fParseInProgress)
455                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
456
457        return fScanner->scanFirst(systemId, toFill);
458}
459
460bool SAX2XMLReaderImpl::parseFirst( const   char* const     systemId
461                                                        ,       XMLPScanToken&  toFill)
462{
463        //
464        //  Avoid multiple entrance. We cannot enter here while a regular parse
465        //  is in progress.
466        //
467        if (fParseInProgress)
468                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
469
470        return fScanner->scanFirst(systemId, toFill);
471}
472
473bool SAX2XMLReaderImpl::parseFirst( const   InputSource&    source
474                                                        ,       XMLPScanToken&  toFill)
475{
476        //
477        //  Avoid multiple entrance. We cannot enter here while a regular parse
478        //  is in progress.
479        //
480        if (fParseInProgress)
481                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
482
483        return fScanner->scanFirst(source, toFill);
484}
485
486bool SAX2XMLReaderImpl::parseNext(XMLPScanToken& token)
487{
488        return fScanner->scanNext(token);
489}
490
491void SAX2XMLReaderImpl::parseReset(XMLPScanToken& token)
492{
493        // Reset the scanner
494        fScanner->scanReset(token);
495}
496
497// ---------------------------------------------------------------------------
498//  SAX2XMLReaderImpl: Overrides of the XMLDocumentHandler interface
499// ---------------------------------------------------------------------------
500void SAX2XMLReaderImpl::docCharacters(  const   XMLCh* const    chars
501                                                                , const XMLSize_t       length
502                                                                , const bool            cdataSection)
503{
504        // Suppress the chars before the root element.
505        if (fElemDepth)
506        {
507                // Call the installed LexicalHandler.
508                if (cdataSection && fLexicalHandler)
509                        fLexicalHandler->startCDATA();
510
511                // Just map to the SAX document handler
512                if (fDocHandler)
513                        fDocHandler->characters(chars, length);
514
515                // Call the installed LexicalHandler.
516                if (cdataSection && fLexicalHandler)
517                        fLexicalHandler->endCDATA();
518        }
519
520        //
521        //  If there are any installed advanced handlers, then lets call them
522        //  with this info.
523        //
524        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
525                fAdvDHList[index]->docCharacters(chars, length, cdataSection);
526}
527
528
529void SAX2XMLReaderImpl::docComment(const XMLCh* const commentText)
530{
531        // Call the installed LexicalHandler.
532        if (fLexicalHandler)
533        {
534                // SAX2 reports comment text like characters -- as an
535                // array with a length.
536                fLexicalHandler->comment(commentText, XMLString::stringLen(commentText));
537        }
538
539        //
540        //  OK, if there are any installed advanced handlers,
541        // then let's call them with this info.
542        //
543        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
544                fAdvDHList[index]->docComment(commentText);
545}
546
547
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)
555{
556        // SAX has no way to report this event. But, if there are any installed
557        //  advanced handlers, then lets call them with this info.
558        //
559        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
560                fAdvDHList[index]->XMLDecl( versionStr,
561                                                                        encodingStr,
562                                                                        standaloneStr,
563                                                                        actualEncodingStr );
564}
565
566
567void SAX2XMLReaderImpl::docPI(  const   XMLCh* const    target
568                                                , const XMLCh* const    data)
569{
570        // Just map to the SAX document handler
571        if (fDocHandler)
572                fDocHandler->processingInstruction(target, data);
573
574        //
575        //  If there are any installed advanced handlers, then lets call them
576        //  with this info.
577        //
578        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
579                fAdvDHList[index]->docPI(target, data);
580}
581
582
583void SAX2XMLReaderImpl::endDocument()
584{
585        if (fDocHandler)
586                fDocHandler->endDocument();
587
588        //
589        //  If there are any installed advanced handlers, then lets call them
590        //  with this info.
591        //
592        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
593                fAdvDHList[index]->endDocument();
594}
595
596
597void SAX2XMLReaderImpl::endEntityReference(const XMLEntityDecl& entityDecl)
598{
599   // Call the installed LexicalHandler.
600   if (fLexicalHandler)
601                fLexicalHandler->endEntity(entityDecl.getName());
602
603        //
604        //  SAX has no way to report this event. But, if there are any installed
605        //  advanced handlers, then lets call them with this info.
606        //
607        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
608                fAdvDHList[index]->endEntityReference(entityDecl);
609}
610
611
612void SAX2XMLReaderImpl::ignorableWhitespace(const   XMLCh* const    chars
613                                                                        , const XMLSize_t       length
614                                                                        , const bool            cdataSection)
615{
616        // Do not report the whitespace before the root element.
617        if (!fElemDepth)
618                return;
619
620        // Just map to the SAX document handler
621        if (fDocHandler)
622                fDocHandler->ignorableWhitespace(chars, length);
623
624        //
625        //  If there are any installed advanced handlers, then lets call them
626        //  with this info.
627        //
628        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
629                fAdvDHList[index]->ignorableWhitespace(chars, length, cdataSection);
630}
631
632
633void SAX2XMLReaderImpl::resetDocument()
634{
635        //
636        //  If there are any installed advanced handlers, then lets call them
637        //  with this info.
638        //
639        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
640                fAdvDHList[index]->resetDocument();
641
642        // Make sure our element depth flag gets set back to zero
643        fElemDepth = 0;
644}
645
646
647void SAX2XMLReaderImpl::startDocument()
648{
649        // Just map to the SAX document handler
650        if (fDocHandler)
651                fDocHandler->setDocumentLocator(fScanner->getLocator());
652        if(fDocHandler)
653                fDocHandler->startDocument();
654
655        //
656        //  If there are any installed advanced handlers, then lets call them
657        //  with this info.
658        //
659        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
660                fAdvDHList[index]->startDocument();
661}
662
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)
673{
674        // Bump the element depth counter if not empty
675        if (!isEmpty)
676                fElemDepth++;
677
678        if (fDocHandler)
679        {
680        const QName * qName = elemDecl.getElementName();
681        const XMLCh * baseName = qName->getLocalPart();
682        const XMLCh * elemQName = elemDecl.getFullName();
683        const XMLCh * elemUri = XMLUni::fgZeroLenString;
684
685        bool modifiedNamespace = 0;
686        gid_t lastNamespaceContextId = 0;
687
688                if (getDoNamespaces())
689                {
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        }
735                else // no namespace
736                {
737                        fAttrList.setVector(&attrList, attrCount, fScanner);
738            baseName = XMLUni::fgZeroLenString;
739                }
740
741        elemUri = fScanner->getURIText(elemURLId);
742
743        fDocHandler->startElement
744        (
745            elemUri
746            , baseName
747            , elemQName
748            , fAttrList
749        );
750
751                // If its empty, send the end tag event now
752                if (isEmpty)
753                {
754            fDocHandler->endElement(elemUri, baseName, elemQName);
755
756                        // call endPrefixMapping appropriately.
757            if (modifiedNamespace)
758                        {
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;
767                        }
768                }
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{
805        // Just map to the SAX document handler
806        if (fDocHandler)
807        {
808                const QName* qName=elemDecl.getElementName();
809                const XMLCh* baseName=qName->getLocalPart();
810                const XMLCh* elemQName = elemDecl.getFullName();
811
812
813                if (getDoNamespaces())
814                {
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        }
829                else
830                {
831            fDocHandler->endElement(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, elemQName);
832                }
833        }
834
835        //
836        //  If there are any installed advanced handlers, then lets call them
837        //  with this info.
838        //
839        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
840                fAdvDHList[index]->endElement(elemDecl, uriId, isRoot, elemPrefix);
841
842        //
843        //  Dump the element depth down again. Don't let it underflow in case
844        //  of malformed XML.
845        //
846        if (fElemDepth)
847                fElemDepth--;
848}
849
850void SAX2XMLReaderImpl::startEntityReference(const XMLEntityDecl& entityDecl)
851{
852   // Call the installed LexicalHandler.
853   if (fLexicalHandler)
854                fLexicalHandler->startEntity(entityDecl.getName());
855        //
856        //  SAX has no way to report this. But, If there are any installed
857        //  advanced handlers, then lets call them with this info.
858        //
859        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
860                fAdvDHList[index]->startEntityReference(entityDecl);
861}
862
863// ---------------------------------------------------------------------------
864//  SAX2XMLReaderImpl: Overrides of the DocTypeHandler interface
865// ---------------------------------------------------------------------------
866void SAX2XMLReaderImpl::attDef( const   DTDElementDecl& elemDecl
867                                                , const DTDAttDef&      attDef
868                                                , const bool            ignoring)
869{
870        if (fDeclHandler && !ignoring) {
871
872                XMLAttDef::AttTypes attType = attDef.getType();
873                XMLAttDef::DefAttTypes defAttType = attDef.getDefaultType();
874                const XMLCh* defAttTypeStr = XMLUni::fgNullString;
875                bool isEnumeration = (attType == XMLAttDef::Notation || attType == XMLAttDef::Enumeration);
876                XMLBuffer enumBuf(128, fMemoryManager);
877
878                if (defAttType == XMLAttDef::Fixed ||
879                        defAttType == XMLAttDef::Implied ||
880                        defAttType == XMLAttDef::Required) {
881                        defAttTypeStr = attDef.getDefAttTypeString(defAttType, fMemoryManager);
882                }
883
884                if (isEnumeration) {
885
886                        const XMLCh* enumString = attDef.getEnumeration();
887                        XMLSize_t enumLen = XMLString::stringLen(enumString);
888
889                        if (attType == XMLAttDef::Notation) {
890
891                                enumBuf.set(XMLUni::fgNotationString);
892                                enumBuf.append(chSpace);
893                        }
894
895                        enumBuf.append(chOpenParen);
896
897                        for (XMLSize_t i=0; i<enumLen; i++) {
898                                if (enumString[i] == chSpace)
899                                        enumBuf.append(chPipe);
900                                else
901                                        enumBuf.append(enumString[i]);
902                        }
903
904                        enumBuf.append(chCloseParen);
905                }
906
907                fDeclHandler->attributeDecl(elemDecl.getFullName(),
908                                                                        attDef.getFullName(),
909                                                                        (isEnumeration) ? enumBuf.getRawBuffer()
910                                                                                                        : attDef.getAttTypeString(attDef.getType(), fMemoryManager),
911                                                                        defAttTypeStr,
912                                                                        attDef.getValue());
913        }
914}
915
916
917void SAX2XMLReaderImpl::doctypeComment(const XMLCh* const commentText)
918{
919   if (fLexicalHandler)
920   {
921                // SAX2 reports comment text like characters -- as an
922                // array with a length.
923                fLexicalHandler->comment(commentText, XMLString::stringLen(commentText));
924   }
925}
926
927
928void SAX2XMLReaderImpl::doctypeDecl(const   DTDElementDecl& elemDecl
929                                                        , const XMLCh* const    publicId
930                                                        , const XMLCh* const    systemId
931                                                        , const bool            hasIntSubset
932                                                        , const bool            hasExtSubset)
933{
934        // Call the installed LexicalHandler.
935        if (fLexicalHandler && (hasIntSubset || hasExtSubset))
936                fLexicalHandler->startDTD(elemDecl.getFullName(), publicId, systemId);
937
938        fHasExternalSubset = hasExtSubset;
939
940        // Unused by SAX DTDHandler interface at this time
941}
942
943
944void SAX2XMLReaderImpl::doctypePI(  const   XMLCh* const
945                                                        , const XMLCh* const)
946{
947        // Unused by SAX DTDHandler interface at this time
948}
949
950
951void SAX2XMLReaderImpl::doctypeWhitespace(  const   XMLCh* const
952                                                                        , const XMLSize_t)
953{
954        // Unused by SAX DTDHandler interface at this time
955}
956
957
958void SAX2XMLReaderImpl::elementDecl(const DTDElementDecl& elemDecl,
959                                                                        const bool isIgnored)
960{
961        if (fDeclHandler && !isIgnored)
962                fDeclHandler->elementDecl(elemDecl.getFullName(),
963                                                                  elemDecl.getFormattedContentModel());
964}
965
966
967void SAX2XMLReaderImpl::endAttList(const DTDElementDecl&)
968{
969        // Unused by SAX DTDHandler interface at this time
970}
971
972
973void SAX2XMLReaderImpl::endIntSubset()
974{
975   // Call the installed LexicalHandler.
976   if (!fHasExternalSubset && fLexicalHandler)
977                fLexicalHandler->endDTD();
978
979        // Unused by SAX DTDHandler interface at this time
980}
981
982
983void SAX2XMLReaderImpl::endExtSubset()
984{
985        // Call the installed LexicalHandler.
986        if (fLexicalHandler)
987                fLexicalHandler->endEntity(gDTDEntityStr);
988        if (fLexicalHandler)
989                fLexicalHandler->endDTD();
990
991        // Unused by SAX DTDHandler interface at this time
992}
993
994
995void SAX2XMLReaderImpl::entityDecl( const   DTDEntityDecl&  entityDecl
996                                                        , const bool            isPEDecl
997                                                        , const bool            isIgnored)
998{
999        //
1000        //  If we have a DTD handler, and this entity is not ignored, and
1001        //  its an unparsed entity, then send this one, else if we have a Decl
1002        //  handler then send this one.
1003        //
1004        if (!isIgnored) {
1005
1006                if (entityDecl.isUnparsed()) {
1007
1008                        if (fDTDHandler) {
1009                                fDTDHandler->unparsedEntityDecl
1010                                (
1011                                        entityDecl.getName()
1012                                        , entityDecl.getPublicId()
1013                                        , entityDecl.getSystemId()
1014                                        , entityDecl.getNotationName()
1015                                );
1016                        }
1017                }
1018                else if (fDeclHandler) {
1019
1020                        const XMLCh* entityName = entityDecl.getName();
1021                        ArrayJanitor<XMLCh> tmpNameJan(0);
1022
1023                        if (isPEDecl) {
1024
1025                                XMLSize_t nameLen = XMLString::stringLen(entityName);
1026                                XMLCh* tmpName = (XMLCh*) fMemoryManager->allocate
1027                                (
1028                                        (nameLen + 2) * sizeof(XMLCh)
1029                                );//new XMLCh[nameLen + 2];
1030
1031                                tmpNameJan.reset(tmpName, fMemoryManager);
1032                                tmpName[0] = chPercent;
1033                                XMLString::copyString(tmpName + 1, entityName);
1034                                entityName = tmpName;
1035                        }
1036
1037                        if (entityDecl.isExternal()) {
1038                                fDeclHandler->externalEntityDecl
1039                                (
1040                                        entityName
1041                                        , entityDecl.getPublicId()
1042                                        , entityDecl.getSystemId()
1043                                );
1044                        }
1045                        else {
1046                                fDeclHandler->internalEntityDecl
1047                                (
1048                                        entityName
1049                                        , entityDecl.getValue()
1050                                );
1051                        }
1052                }
1053        }
1054}
1055
1056
1057void SAX2XMLReaderImpl::resetDocType()
1058{
1059        fHasExternalSubset = false;
1060        // Just map to the DTD handler
1061        if (fDTDHandler)
1062                fDTDHandler->resetDocType();
1063}
1064
1065
1066void SAX2XMLReaderImpl::notationDecl(   const   XMLNotationDecl&    notDecl
1067                                                                , const bool                isIgnored)
1068{
1069        if (fDTDHandler && !isIgnored)
1070        {
1071                fDTDHandler->notationDecl
1072                (
1073                        notDecl.getName()
1074                        , notDecl.getPublicId()
1075                        , notDecl.getSystemId()
1076                );
1077        }
1078}
1079
1080
1081void SAX2XMLReaderImpl::startAttList(const DTDElementDecl&)
1082{
1083        // Unused by SAX DTDHandler interface at this time
1084}
1085
1086
1087void SAX2XMLReaderImpl::startIntSubset()
1088{
1089        // Unused by SAX DTDHandler interface at this time
1090}
1091
1092
1093void SAX2XMLReaderImpl::startExtSubset()
1094{
1095        if (fLexicalHandler)
1096                fLexicalHandler->startEntity(gDTDEntityStr);
1097}
1098
1099
1100void SAX2XMLReaderImpl::TextDecl(   const  XMLCh* const
1101                                                        , const XMLCh* const)
1102{
1103        // Unused by SAX DTDHandler interface at this time
1104}
1105
1106
1107// ---------------------------------------------------------------------------
1108//  SAX2XMLReaderImpl: Handlers for the XMLEntityHandler interface
1109// ---------------------------------------------------------------------------
1110void SAX2XMLReaderImpl::endInputSource(const InputSource&)
1111{
1112}
1113
1114bool SAX2XMLReaderImpl::expandSystemId(const XMLCh* const, XMLBuffer&)
1115{
1116        return false;
1117}
1118
1119
1120void SAX2XMLReaderImpl::resetEntities()
1121{
1122        // Nothing to do for this one
1123}
1124
1125InputSource* SAX2XMLReaderImpl::resolveEntity(XMLResourceIdentifier* resourceIdentifier)
1126{
1127        //
1128        //  Just map it to the SAX entity resolver. If there is not one installed,
1129        //  return a null pointer to cause the default resolution.
1130        //
1131        if (fEntityResolver)
1132                return fEntityResolver->resolveEntity(resourceIdentifier->getPublicId(),
1133                                                                                                resourceIdentifier->getSystemId());
1134        if (fXMLEntityResolver)
1135                return fXMLEntityResolver->resolveEntity(resourceIdentifier);
1136
1137        return 0;
1138}
1139
1140void SAX2XMLReaderImpl::startInputSource(const InputSource&)
1141{
1142        // Nothing to do for this one
1143}
1144
1145// ---------------------------------------------------------------------------
1146//  SAX2XMLReaderImpl: Overrides of the XMLErrorReporter interface
1147// ---------------------------------------------------------------------------
1148void SAX2XMLReaderImpl::resetErrors()
1149{
1150        if (fErrorHandler)
1151                fErrorHandler->resetErrors();
1152}
1153
1154
1155void SAX2XMLReaderImpl::error(  const   unsigned int
1156                                                , const XMLCh* const
1157                                                , const XMLErrorReporter::ErrTypes  errType
1158                                                , const XMLCh* const                errorText
1159                                                , const XMLCh* const                systemId
1160                                                , const XMLCh* const                publicId
1161                                                , const XMLFileLoc                  lineNum
1162                                                , const XMLFileLoc                  colNum)
1163{
1164        SAXParseException toThrow = SAXParseException
1165        (
1166                errorText
1167                , publicId
1168                , systemId
1169                , lineNum
1170                , colNum
1171                , fMemoryManager
1172        );
1173
1174        if (!fErrorHandler)
1175        {
1176                if (errType == XMLErrorReporter::ErrType_Fatal)
1177                        throw toThrow;
1178                else
1179                        return;
1180        }
1181
1182        if (errType == XMLErrorReporter::ErrType_Warning)
1183                fErrorHandler->warning(toThrow);
1184        else if (errType == XMLErrorReporter::ErrType_Fatal)
1185                fErrorHandler->fatalError(toThrow);
1186        else
1187                fErrorHandler->error(toThrow);
1188}
1189
1190
1191// ---------------------------------------------------------------------------
1192//  SAX2XMLReaderImpl: Features and Properties
1193// ---------------------------------------------------------------------------
1194
1195void SAX2XMLReaderImpl::setFeature(const XMLCh* const name, const bool value)
1196{
1197
1198        if (fParseInProgress)
1199                throw SAXNotSupportedException("Feature modification is not supported during parse.", fMemoryManager);
1200
1201        if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreNameSpaces) == 0)
1202        {
1203                setDoNamespaces(value);
1204        }
1205        else if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreValidation) == 0)
1206        {
1207                fValidation = value;
1208                if (fValidation)
1209                        if (fAutoValidation)
1210                                setValidationScheme(Val_Auto);
1211                        else
1212                                setValidationScheme(Val_Always);
1213                else
1214                        setValidationScheme(Val_Never);
1215        }
1216        else if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreNameSpacePrefixes) == 0)
1217        {
1218                fNamespacePrefix = value;
1219        }
1220        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDynamic) == 0)
1221        {
1222                fAutoValidation = value;
1223                // for auto validation, the sax2 core validation feature must also be enabled.
1224                if (fValidation)
1225                        if (fAutoValidation)
1226                                setValidationScheme(Val_Auto);
1227                        else
1228                                setValidationScheme(Val_Always);
1229                else
1230                        setValidationScheme(Val_Never);
1231        }
1232        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchema) == 0)
1233        {
1234                setDoSchema(value);
1235        }
1236        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaFullChecking) == 0)
1237        {
1238                fScanner->setValidationSchemaFullChecking(value);
1239        }
1240        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIdentityConstraintChecking) == 0)
1241        {
1242                fScanner->setIdentityConstraintChecking(value);
1243        }
1244        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadExternalDTD) == 0)
1245        {
1246                fScanner->setLoadExternalDTD(value);
1247        }
1248        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadSchema) == 0)
1249        {
1250                fScanner->setLoadSchema(value);
1251        }
1252        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesContinueAfterFatalError) == 0)
1253        {
1254                fScanner->setExitOnFirstFatal(!value);
1255        }
1256        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidationErrorAsFatal) == 0)
1257        {
1258                fScanner->setValidationConstraintFatal(value);
1259        }
1260        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCacheGrammarFromParse) == 0)
1261        {
1262                fScanner->cacheGrammarFromParse(value);
1263
1264                if (value)
1265                        fScanner->useCachedGrammarInParse(value);
1266        }
1267        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)
1268        {
1269                if (value || !fScanner->isCachingGrammarFromParse())
1270                        fScanner->useCachedGrammarInParse(value);
1271        }
1272        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCalculateSrcOfs) == 0)
1273        {
1274                fScanner->setCalculateSrcOfs(value);
1275        }
1276        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesStandardUriConformant) == 0)
1277        {
1278                fScanner->setStandardUriConformant(value);
1279        }
1280        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesGenerateSyntheticAnnotations) == 0)
1281        {
1282                fScanner->setGenerateSyntheticAnnotations(value);
1283        }
1284        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidateAnnotations) == 0)
1285        {
1286                fScanner->setValidateAnnotations(value);
1287        }
1288        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreCachedDTD) == 0)
1289        {
1290                fScanner->setIgnoredCachedDTD(value);
1291        }
1292        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreAnnotations) == 0)
1293        {
1294                fScanner->setIgnoreAnnotations(value);
1295        }
1296        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDisableDefaultEntityResolution) == 0)
1297        {
1298                fScanner->setDisableDefaultEntityResolution(value);
1299        }
1300        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSkipDTDValidation) == 0)
1301        {
1302                fScanner->setSkipDTDValidation(value);
1303        }
1304        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesHandleMultipleImports) == 0)
1305        {
1306                fScanner->setHandleMultipleImports(value);
1307        }
1308        else
1309           throw SAXNotRecognizedException("Unknown Feature", fMemoryManager);
1310}
1311
1312bool SAX2XMLReaderImpl::getFeature(const XMLCh* const name) const
1313{
1314        if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreNameSpaces) == 0)
1315                return getDoNamespaces();
1316        else if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreValidation) == 0)
1317                return fValidation;
1318        else if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreNameSpacePrefixes) == 0)
1319                return fNamespacePrefix;
1320        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDynamic) == 0)
1321                return fAutoValidation;
1322        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchema) == 0)
1323                return getDoSchema();
1324        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaFullChecking) == 0)
1325                return fScanner->getValidationSchemaFullChecking();
1326        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIdentityConstraintChecking) == 0)
1327                return fScanner->getIdentityConstraintChecking();
1328        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadExternalDTD) == 0)
1329                return fScanner->getLoadExternalDTD();
1330        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadSchema) == 0)
1331                return fScanner->getLoadSchema();
1332        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesContinueAfterFatalError) == 0)
1333                return !fScanner->getExitOnFirstFatal();
1334        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidationErrorAsFatal) == 0)
1335                return fScanner->getValidationConstraintFatal();
1336        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCacheGrammarFromParse) == 0)
1337                return fScanner->isCachingGrammarFromParse();
1338        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)
1339                return fScanner->isUsingCachedGrammarInParse();
1340        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCalculateSrcOfs) == 0)
1341                return fScanner->getCalculateSrcOfs();
1342        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesStandardUriConformant) == 0)
1343                return fScanner->getStandardUriConformant();
1344        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesGenerateSyntheticAnnotations) == 0)
1345                return fScanner->getGenerateSyntheticAnnotations();
1346        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidateAnnotations) == 0)
1347                return fScanner->getValidateAnnotations();
1348        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreCachedDTD) == 0)
1349                return fScanner->getIgnoreCachedDTD();
1350        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreAnnotations) == 0)
1351                return fScanner->getIgnoreAnnotations();
1352        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDisableDefaultEntityResolution) == 0)
1353                return fScanner->getDisableDefaultEntityResolution();
1354        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSkipDTDValidation) == 0)
1355                return fScanner->getSkipDTDValidation();
1356        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesHandleMultipleImports) == 0)
1357                return fScanner->getHandleMultipleImports();
1358        else
1359           throw SAXNotRecognizedException("Unknown Feature", fMemoryManager);
1360
1361        return false;
1362}
1363
1364void SAX2XMLReaderImpl::setProperty(const XMLCh* const name, void* value)
1365{
1366        if (fParseInProgress)
1367                throw SAXNotSupportedException("Property modification is not supported during parse.", fMemoryManager);
1368
1369        if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0)
1370        {
1371                fScanner->setExternalSchemaLocation((XMLCh*)value);
1372        }
1373        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0)
1374        {
1375                fScanner->setExternalNoNamespaceSchemaLocation((XMLCh*)value);
1376        }
1377        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSecurityManager) == 0)
1378        {
1379                fScanner->setSecurityManager((SecurityManager*)value);
1380        }
1381        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLowWaterMark) == 0)
1382        {
1383                fScanner->setLowWaterMark(*(const XMLSize_t*)value);
1384        }
1385        else if (XMLString::equals(name, XMLUni::fgXercesScannerName))
1386        {
1387                XMLScanner* tempScanner = XMLScannerResolver::resolveScanner
1388                (
1389                        (const XMLCh*) value
1390                        , fValidator
1391                        , fGrammarResolver
1392                        , fMemoryManager
1393                );
1394
1395                if (tempScanner)
1396                {
1397                        tempScanner->setParseSettings(fScanner);
1398                        delete fScanner;
1399                        fScanner = tempScanner;
1400                }
1401        }
1402        else
1403           throw SAXNotRecognizedException("Unknown Property", fMemoryManager);
1404}
1405
1406
1407void* SAX2XMLReaderImpl::getProperty(const XMLCh* const name) const
1408{
1409        if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0)
1410                return (void*)fScanner->getExternalSchemaLocation();
1411        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0)
1412                return (void*)fScanner->getExternalNoNamespaceSchemaLocation();
1413        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSecurityManager) == 0)
1414                return (void*)fScanner->getSecurityManager();
1415        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLowWaterMark) == 0)
1416                return (void*)&fScanner->getLowWaterMark();
1417        else if (XMLString::equals(name, XMLUni::fgXercesScannerName))
1418                return (void*)fScanner->getName();
1419        else
1420                throw SAXNotRecognizedException("Unknown Property", fMemoryManager);
1421        return 0;
1422}
1423
1424
1425// ---------------------------------------------------------------------------
1426//  SAX2XMLReaderImpl: Private getters and setters for conveniences
1427// ---------------------------------------------------------------------------
1428
1429void SAX2XMLReaderImpl::setValidationScheme(const ValSchemes newScheme)
1430{
1431        if (newScheme == Val_Never)
1432                fScanner->setValidationScheme(XMLScanner::Val_Never);
1433        else if (newScheme == Val_Always)
1434                fScanner->setValidationScheme(XMLScanner::Val_Always);
1435        else
1436                fScanner->setValidationScheme(XMLScanner::Val_Auto);
1437}
1438
1439void SAX2XMLReaderImpl::setDoNamespaces(const bool newState)
1440{
1441        fScanner->setDoNamespaces(newState);
1442}
1443
1444bool SAX2XMLReaderImpl::getDoNamespaces() const
1445{
1446        return fScanner->getDoNamespaces();
1447}
1448
1449void SAX2XMLReaderImpl::setDoSchema(const bool newState)
1450{
1451        fScanner->setDoSchema(newState);
1452}
1453
1454bool SAX2XMLReaderImpl::getDoSchema() const
1455{
1456        return fScanner->getDoSchema();
1457}
1458
1459
1460// ---------------------------------------------------------------------------
1461//  SAX2XMLReaderImpl: Grammar preparsing
1462// ---------------------------------------------------------------------------
1463Grammar* SAX2XMLReaderImpl::loadGrammar(const char* const systemId,
1464                                                                                const Grammar::GrammarType grammarType,
1465                                                                                const bool toCache)
1466{
1467        // Avoid multiple entrance
1468        if (fParseInProgress)
1469                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
1470
1471        ResetInProgressType     resetInProgress(this, &SAX2XMLReaderImpl::resetInProgress);
1472
1473        Grammar* grammar = 0;
1474        try
1475        {
1476                fParseInProgress = true;
1477                grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
1478        }
1479        catch(const OutOfMemoryException&)
1480        {
1481                resetInProgress.release();
1482
1483                throw;
1484        }
1485
1486        return grammar;
1487}
1488
1489Grammar* SAX2XMLReaderImpl::loadGrammar(const XMLCh* const systemId,
1490                                                                                const Grammar::GrammarType grammarType,
1491                                                                                const bool toCache)
1492{
1493        // Avoid multiple entrance
1494        if (fParseInProgress)
1495                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
1496
1497        ResetInProgressType     resetInProgress(this, &SAX2XMLReaderImpl::resetInProgress);
1498
1499        Grammar* grammar = 0;
1500        try
1501        {
1502                fParseInProgress = true;
1503                grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
1504        }
1505        catch(const OutOfMemoryException&)
1506        {
1507                resetInProgress.release();
1508
1509                throw;
1510        }
1511
1512        return grammar;
1513}
1514
1515Grammar* SAX2XMLReaderImpl::loadGrammar(const InputSource& source,
1516                                                                                const Grammar::GrammarType grammarType,
1517                                                                                const bool toCache)
1518{
1519        // Avoid multiple entrance
1520        if (fParseInProgress)
1521                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
1522
1523        ResetInProgressType     resetInProgress(this, &SAX2XMLReaderImpl::resetInProgress);
1524
1525        Grammar* grammar = 0;
1526        try
1527        {
1528                fParseInProgress = true;
1529                grammar = fScanner->loadGrammar(source, grammarType, toCache);
1530        }
1531        catch(const OutOfMemoryException&)
1532        {
1533                resetInProgress.release();
1534
1535                throw;
1536        }
1537
1538        return grammar;
1539}
1540
1541void SAX2XMLReaderImpl::resetInProgress()
1542{
1543        fParseInProgress = false;
1544}
1545
1546void SAX2XMLReaderImpl::resetCachedGrammarPool()
1547{
1548        fGrammarResolver->resetCachedGrammar();
1549        fScanner->resetCachedGrammar();
1550}
1551
1552void SAX2XMLReaderImpl::setInputBufferSize(const XMLSize_t bufferSize)
1553{
1554        fScanner->setInputBufferSize(bufferSize);
1555}
1556
1557Grammar* SAX2XMLReaderImpl::getGrammar(const XMLCh* const nameSpaceKey)
1558{
1559        return fGrammarResolver->getGrammar(nameSpaceKey);
1560}
1561
1562
1563XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.