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

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

Fixes for icXML 0.9

File size: 43.4 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    , fNamespaceContextId(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 = 0;
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                if (getDoNamespaces())
686                {
687            if (unlikely(elemDecl.getNamespaceContextId() != fNamespaceContextId))
688            {
689                const XMLNamespaceResolver * resolver = fScanner->getUriResolver();
690                MaskedBindingSetIterator itr = resolver->getNamespaceIterator(elemDecl.getNamespaceContextId(), fNamespaceContextId);
691                while (itr.next())
692                {
693                    const XMLCh * prefix = resolver->getPrefixForNamespaceId(itr.pos());
694                    const XMLCh * uri = resolver->getUriForNamespaceId(itr.pos());
695                    fDocHandler->startPrefixMapping(prefix, uri);
696                }
697
698                if (unlikely(attrCount > fNamespaceAttrList.fMaxCount))
699                {
700                    fNamespaceAttrList.ensureExtraCapacity(attrCount - fNamespaceAttrList.fMaxCount);
701                }
702                fNamespaceAttrList.fCurCount = fNamespaceAttrList.fMaxCount;
703
704                XMLSize_t namespaceAttrCount = 0;
705                for (XMLSize_t i = 0; i < attrCount; i++)
706                {
707                    const XMLAttr * attr = attrList.elementAt(i);
708                    if (attr->getURIId() != XMLNamespaceResolver::fXMLNSUriId)
709                    {
710                        fNamespaceAttrList.setElementAt(const_cast<XMLAttr*>(attr), namespaceAttrCount++);
711                    }
712                }
713
714                fNamespaceAttrList.fCurCount = namespaceAttrCount;
715                fAttrList.setVector(&fNamespaceAttrList, namespaceAttrCount, fScanner);
716            }
717            else
718            {
719                fAttrList.setVector(&attrList, attrCount, fScanner);
720            }
721
722        }
723                else // no namespace
724                {
725                        fAttrList.setVector(&attrList, attrCount, fScanner);
726            baseName = XMLUni::fgZeroLenString;
727                }
728
729        elemUri = fScanner->getURIText(elemURLId);
730
731        fDocHandler->startElement
732        (
733            elemUri
734            , baseName
735            , elemQName
736            , fAttrList
737        );
738
739                // If its empty, send the end tag event now
740                if (isEmpty)
741                {
742            fDocHandler->endElement(elemUri, baseName, elemQName);
743
744                        // call endPrefixMapping appropriately.
745            if (unlikely(elemDecl.getNamespaceContextId() != fNamespaceContextId))
746                        {
747                const XMLNamespaceResolver * resolver = fScanner->getUriResolver();
748                MaskedBindingSetIterator itr = resolver->getNamespaceIterator(fNamespaceContextId, elemDecl.getNamespaceContextId());
749                while (itr.next())
750                {
751                    const XMLCh * prefix = resolver->getPrefixForNamespaceId(itr.pos());
752                    fDocHandler->endPrefixMapping(prefix);
753                }
754                        }
755                }
756
757        fNamespaceContextId = elemDecl.getNamespaceContextId();
758    }
759
760    if (unlikely(fAdvDHCount > 0))
761    {
762        //
763        //  If there are any installed advanced handlers, then we need to call them -- however all xmlns attributes
764        //  were surpressed by the Parser from the attribute list.
765        //
766
767        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
768        {
769            fAdvDHList[index]->startElement
770            (
771                elemDecl
772                , elemURLId
773                , elemPrefix
774                , attrList
775                , attrCount
776                , isEmpty
777                , isRoot
778            );
779        }
780
781    }
782}
783
784void SAX2XMLReaderImpl::endElement
785(
786    const XMLElementDecl& elemDecl
787    , const unsigned int    uriId
788    , const bool            isRoot
789    , const XMLCh* const    elemPrefix
790)
791{
792        // Just map to the SAX document handler
793        if (fDocHandler)
794        {
795                const QName* qName=elemDecl.getElementName();
796                const XMLCh* baseName=qName->getLocalPart();
797                const XMLCh* elemQName = elemDecl.getFullName();
798
799
800                if (getDoNamespaces())
801                {
802            fDocHandler->endElement(fScanner->getURIText(uriId), baseName, elemQName);
803            if (unlikely(elemDecl.getNamespaceContextId() != fNamespaceContextId))
804            {
805                const XMLNamespaceResolver * resolver = fScanner->getUriResolver();
806                MaskedBindingSetIterator itr = resolver->getNamespaceIterator(fNamespaceContextId, elemDecl.getNamespaceContextId());
807                while (itr.next())
808                {
809                    const XMLCh * prefix = resolver->getPrefixForNamespaceId(itr.pos());
810                    fDocHandler->endPrefixMapping(prefix);
811                }
812                fNamespaceContextId = elemDecl.getNamespaceContextId();
813            }
814        }
815                else
816                {
817            fDocHandler->endElement(XMLUni::fgZeroLenString, XMLUni::fgZeroLenString, elemQName);
818                }
819        }
820
821        //
822        //  If there are any installed advanced handlers, then lets call them
823        //  with this info.
824        //
825        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
826                fAdvDHList[index]->endElement(elemDecl, uriId, isRoot, elemPrefix);
827
828        //
829        //  Dump the element depth down again. Don't let it underflow in case
830        //  of malformed XML.
831        //
832        if (fElemDepth)
833                fElemDepth--;
834}
835
836void SAX2XMLReaderImpl::startEntityReference(const XMLEntityDecl& entityDecl)
837{
838   // Call the installed LexicalHandler.
839   if (fLexicalHandler)
840                fLexicalHandler->startEntity(entityDecl.getName());
841        //
842        //  SAX has no way to report this. But, If there are any installed
843        //  advanced handlers, then lets call them with this info.
844        //
845        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
846                fAdvDHList[index]->startEntityReference(entityDecl);
847}
848
849// ---------------------------------------------------------------------------
850//  SAX2XMLReaderImpl: Overrides of the DocTypeHandler interface
851// ---------------------------------------------------------------------------
852void SAX2XMLReaderImpl::attDef( const   DTDElementDecl& elemDecl
853                                                , const DTDAttDef&      attDef
854                                                , const bool            ignoring)
855{
856        if (fDeclHandler && !ignoring) {
857
858                XMLAttDef::AttTypes attType = attDef.getType();
859                XMLAttDef::DefAttTypes defAttType = attDef.getDefaultType();
860                const XMLCh* defAttTypeStr = XMLUni::fgNullString;
861                bool isEnumeration = (attType == XMLAttDef::Notation || attType == XMLAttDef::Enumeration);
862                XMLBuffer enumBuf(128, fMemoryManager);
863
864                if (defAttType == XMLAttDef::Fixed ||
865                        defAttType == XMLAttDef::Implied ||
866                        defAttType == XMLAttDef::Required) {
867                        defAttTypeStr = attDef.getDefAttTypeString(defAttType, fMemoryManager);
868                }
869
870                if (isEnumeration) {
871
872                        const XMLCh* enumString = attDef.getEnumeration();
873                        XMLSize_t enumLen = XMLString::stringLen(enumString);
874
875                        if (attType == XMLAttDef::Notation) {
876
877                                enumBuf.set(XMLUni::fgNotationString);
878                                enumBuf.append(chSpace);
879                        }
880
881                        enumBuf.append(chOpenParen);
882
883                        for (XMLSize_t i=0; i<enumLen; i++) {
884                                if (enumString[i] == chSpace)
885                                        enumBuf.append(chPipe);
886                                else
887                                        enumBuf.append(enumString[i]);
888                        }
889
890                        enumBuf.append(chCloseParen);
891                }
892
893                fDeclHandler->attributeDecl(elemDecl.getFullName(),
894                                                                        attDef.getFullName(),
895                                                                        (isEnumeration) ? enumBuf.getRawBuffer()
896                                                                                                        : attDef.getAttTypeString(attDef.getType(), fMemoryManager),
897                                                                        defAttTypeStr,
898                                                                        attDef.getValue());
899        }
900}
901
902
903void SAX2XMLReaderImpl::doctypeComment(const XMLCh* const commentText)
904{
905   if (fLexicalHandler)
906   {
907                // SAX2 reports comment text like characters -- as an
908                // array with a length.
909                fLexicalHandler->comment(commentText, XMLString::stringLen(commentText));
910   }
911}
912
913
914void SAX2XMLReaderImpl::doctypeDecl(const   DTDElementDecl& elemDecl
915                                                        , const XMLCh* const    publicId
916                                                        , const XMLCh* const    systemId
917                                                        , const bool            hasIntSubset
918                                                        , const bool            hasExtSubset)
919{
920        // Call the installed LexicalHandler.
921        if (fLexicalHandler && (hasIntSubset || hasExtSubset))
922                fLexicalHandler->startDTD(elemDecl.getFullName(), publicId, systemId);
923
924        fHasExternalSubset = hasExtSubset;
925
926        // Unused by SAX DTDHandler interface at this time
927}
928
929
930void SAX2XMLReaderImpl::doctypePI(  const   XMLCh* const
931                                                        , const XMLCh* const)
932{
933        // Unused by SAX DTDHandler interface at this time
934}
935
936
937void SAX2XMLReaderImpl::doctypeWhitespace(  const   XMLCh* const
938                                                                        , const XMLSize_t)
939{
940        // Unused by SAX DTDHandler interface at this time
941}
942
943
944void SAX2XMLReaderImpl::elementDecl(const DTDElementDecl& elemDecl,
945                                                                        const bool isIgnored)
946{
947        if (fDeclHandler && !isIgnored)
948                fDeclHandler->elementDecl(elemDecl.getFullName(),
949                                                                  elemDecl.getFormattedContentModel());
950}
951
952
953void SAX2XMLReaderImpl::endAttList(const DTDElementDecl&)
954{
955        // Unused by SAX DTDHandler interface at this time
956}
957
958
959void SAX2XMLReaderImpl::endIntSubset()
960{
961   // Call the installed LexicalHandler.
962   if (!fHasExternalSubset && fLexicalHandler)
963                fLexicalHandler->endDTD();
964
965        // Unused by SAX DTDHandler interface at this time
966}
967
968
969void SAX2XMLReaderImpl::endExtSubset()
970{
971        // Call the installed LexicalHandler.
972        if (fLexicalHandler)
973                fLexicalHandler->endEntity(gDTDEntityStr);
974        if (fLexicalHandler)
975                fLexicalHandler->endDTD();
976
977        // Unused by SAX DTDHandler interface at this time
978}
979
980
981void SAX2XMLReaderImpl::entityDecl( const   DTDEntityDecl&  entityDecl
982                                                        , const bool            isPEDecl
983                                                        , const bool            isIgnored)
984{
985        //
986        //  If we have a DTD handler, and this entity is not ignored, and
987        //  its an unparsed entity, then send this one, else if we have a Decl
988        //  handler then send this one.
989        //
990        if (!isIgnored) {
991
992                if (entityDecl.isUnparsed()) {
993
994                        if (fDTDHandler) {
995                                fDTDHandler->unparsedEntityDecl
996                                (
997                                        entityDecl.getName()
998                                        , entityDecl.getPublicId()
999                                        , entityDecl.getSystemId()
1000                                        , entityDecl.getNotationName()
1001                                );
1002                        }
1003                }
1004                else if (fDeclHandler) {
1005
1006                        const XMLCh* entityName = entityDecl.getName();
1007                        ArrayJanitor<XMLCh> tmpNameJan(0);
1008
1009                        if (isPEDecl) {
1010
1011                                XMLSize_t nameLen = XMLString::stringLen(entityName);
1012                                XMLCh* tmpName = (XMLCh*) fMemoryManager->allocate
1013                                (
1014                                        (nameLen + 2) * sizeof(XMLCh)
1015                                );//new XMLCh[nameLen + 2];
1016
1017                                tmpNameJan.reset(tmpName, fMemoryManager);
1018                                tmpName[0] = chPercent;
1019                                XMLString::copyString(tmpName + 1, entityName);
1020                                entityName = tmpName;
1021                        }
1022
1023                        if (entityDecl.isExternal()) {
1024                                fDeclHandler->externalEntityDecl
1025                                (
1026                                        entityName
1027                                        , entityDecl.getPublicId()
1028                                        , entityDecl.getSystemId()
1029                                );
1030                        }
1031                        else {
1032                                fDeclHandler->internalEntityDecl
1033                                (
1034                                        entityName
1035                                        , entityDecl.getValue()
1036                                );
1037                        }
1038                }
1039        }
1040}
1041
1042
1043void SAX2XMLReaderImpl::resetDocType()
1044{
1045        fHasExternalSubset = false;
1046        // Just map to the DTD handler
1047        if (fDTDHandler)
1048                fDTDHandler->resetDocType();
1049}
1050
1051
1052void SAX2XMLReaderImpl::notationDecl(   const   XMLNotationDecl&    notDecl
1053                                                                , const bool                isIgnored)
1054{
1055        if (fDTDHandler && !isIgnored)
1056        {
1057                fDTDHandler->notationDecl
1058                (
1059                        notDecl.getName()
1060                        , notDecl.getPublicId()
1061                        , notDecl.getSystemId()
1062                );
1063        }
1064}
1065
1066
1067void SAX2XMLReaderImpl::startAttList(const DTDElementDecl&)
1068{
1069        // Unused by SAX DTDHandler interface at this time
1070}
1071
1072
1073void SAX2XMLReaderImpl::startIntSubset()
1074{
1075        // Unused by SAX DTDHandler interface at this time
1076}
1077
1078
1079void SAX2XMLReaderImpl::startExtSubset()
1080{
1081        if (fLexicalHandler)
1082                fLexicalHandler->startEntity(gDTDEntityStr);
1083}
1084
1085
1086void SAX2XMLReaderImpl::TextDecl(   const  XMLCh* const
1087                                                        , const XMLCh* const)
1088{
1089        // Unused by SAX DTDHandler interface at this time
1090}
1091
1092
1093// ---------------------------------------------------------------------------
1094//  SAX2XMLReaderImpl: Handlers for the XMLEntityHandler interface
1095// ---------------------------------------------------------------------------
1096void SAX2XMLReaderImpl::endInputSource(const InputSource&)
1097{
1098}
1099
1100bool SAX2XMLReaderImpl::expandSystemId(const XMLCh* const, XMLBuffer&)
1101{
1102        return false;
1103}
1104
1105
1106void SAX2XMLReaderImpl::resetEntities()
1107{
1108        // Nothing to do for this one
1109}
1110
1111InputSource* SAX2XMLReaderImpl::resolveEntity(XMLResourceIdentifier* resourceIdentifier)
1112{
1113        //
1114        //  Just map it to the SAX entity resolver. If there is not one installed,
1115        //  return a null pointer to cause the default resolution.
1116        //
1117        if (fEntityResolver)
1118                return fEntityResolver->resolveEntity(resourceIdentifier->getPublicId(),
1119                                                                                                resourceIdentifier->getSystemId());
1120        if (fXMLEntityResolver)
1121                return fXMLEntityResolver->resolveEntity(resourceIdentifier);
1122
1123        return 0;
1124}
1125
1126void SAX2XMLReaderImpl::startInputSource(const InputSource&)
1127{
1128        // Nothing to do for this one
1129}
1130
1131// ---------------------------------------------------------------------------
1132//  SAX2XMLReaderImpl: Overrides of the XMLErrorReporter interface
1133// ---------------------------------------------------------------------------
1134void SAX2XMLReaderImpl::resetErrors()
1135{
1136        if (fErrorHandler)
1137                fErrorHandler->resetErrors();
1138}
1139
1140
1141void SAX2XMLReaderImpl::error(  const   unsigned int
1142                                                , const XMLCh* const
1143                                                , const XMLErrorReporter::ErrTypes  errType
1144                                                , const XMLCh* const                errorText
1145                                                , const XMLCh* const                systemId
1146                                                , const XMLCh* const                publicId
1147                                                , const XMLFileLoc                  lineNum
1148                                                , const XMLFileLoc                  colNum)
1149{
1150        SAXParseException toThrow = SAXParseException
1151        (
1152                errorText
1153                , publicId
1154                , systemId
1155                , lineNum
1156                , colNum
1157                , fMemoryManager
1158        );
1159
1160        if (!fErrorHandler)
1161        {
1162                if (errType == XMLErrorReporter::ErrType_Fatal)
1163                        throw toThrow;
1164                else
1165                        return;
1166        }
1167
1168        if (errType == XMLErrorReporter::ErrType_Warning)
1169                fErrorHandler->warning(toThrow);
1170        else if (errType == XMLErrorReporter::ErrType_Fatal)
1171                fErrorHandler->fatalError(toThrow);
1172        else
1173                fErrorHandler->error(toThrow);
1174}
1175
1176
1177// ---------------------------------------------------------------------------
1178//  SAX2XMLReaderImpl: Features and Properties
1179// ---------------------------------------------------------------------------
1180
1181void SAX2XMLReaderImpl::setFeature(const XMLCh* const name, const bool value)
1182{
1183
1184        if (fParseInProgress)
1185                throw SAXNotSupportedException("Feature modification is not supported during parse.", fMemoryManager);
1186
1187        if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreNameSpaces) == 0)
1188        {
1189                setDoNamespaces(value);
1190        }
1191        else if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreValidation) == 0)
1192        {
1193                fValidation = value;
1194                if (fValidation)
1195                        if (fAutoValidation)
1196                                setValidationScheme(Val_Auto);
1197                        else
1198                                setValidationScheme(Val_Always);
1199                else
1200                        setValidationScheme(Val_Never);
1201        }
1202        else if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreNameSpacePrefixes) == 0)
1203        {
1204                fNamespacePrefix = value;
1205        }
1206        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDynamic) == 0)
1207        {
1208                fAutoValidation = value;
1209                // for auto validation, the sax2 core validation feature must also be enabled.
1210                if (fValidation)
1211                        if (fAutoValidation)
1212                                setValidationScheme(Val_Auto);
1213                        else
1214                                setValidationScheme(Val_Always);
1215                else
1216                        setValidationScheme(Val_Never);
1217        }
1218        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchema) == 0)
1219        {
1220                setDoSchema(value);
1221        }
1222        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaFullChecking) == 0)
1223        {
1224                fScanner->setValidationSchemaFullChecking(value);
1225        }
1226        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIdentityConstraintChecking) == 0)
1227        {
1228                fScanner->setIdentityConstraintChecking(value);
1229        }
1230        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadExternalDTD) == 0)
1231        {
1232                fScanner->setLoadExternalDTD(value);
1233        }
1234        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadSchema) == 0)
1235        {
1236                fScanner->setLoadSchema(value);
1237        }
1238        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesContinueAfterFatalError) == 0)
1239        {
1240                fScanner->setExitOnFirstFatal(!value);
1241        }
1242        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidationErrorAsFatal) == 0)
1243        {
1244                fScanner->setValidationConstraintFatal(value);
1245        }
1246        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCacheGrammarFromParse) == 0)
1247        {
1248                fScanner->cacheGrammarFromParse(value);
1249
1250                if (value)
1251                        fScanner->useCachedGrammarInParse(value);
1252        }
1253        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)
1254        {
1255                if (value || !fScanner->isCachingGrammarFromParse())
1256                        fScanner->useCachedGrammarInParse(value);
1257        }
1258        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCalculateSrcOfs) == 0)
1259        {
1260                fScanner->setCalculateSrcOfs(value);
1261        }
1262        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesStandardUriConformant) == 0)
1263        {
1264                fScanner->setStandardUriConformant(value);
1265        }
1266        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesGenerateSyntheticAnnotations) == 0)
1267        {
1268                fScanner->setGenerateSyntheticAnnotations(value);
1269        }
1270        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidateAnnotations) == 0)
1271        {
1272                fScanner->setValidateAnnotations(value);
1273        }
1274        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreCachedDTD) == 0)
1275        {
1276                fScanner->setIgnoredCachedDTD(value);
1277        }
1278        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreAnnotations) == 0)
1279        {
1280                fScanner->setIgnoreAnnotations(value);
1281        }
1282        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDisableDefaultEntityResolution) == 0)
1283        {
1284                fScanner->setDisableDefaultEntityResolution(value);
1285        }
1286        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSkipDTDValidation) == 0)
1287        {
1288                fScanner->setSkipDTDValidation(value);
1289        }
1290        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesHandleMultipleImports) == 0)
1291        {
1292                fScanner->setHandleMultipleImports(value);
1293        }
1294        else
1295           throw SAXNotRecognizedException("Unknown Feature", fMemoryManager);
1296}
1297
1298bool SAX2XMLReaderImpl::getFeature(const XMLCh* const name) const
1299{
1300        if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreNameSpaces) == 0)
1301                return getDoNamespaces();
1302        else if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreValidation) == 0)
1303                return fValidation;
1304        else if (XMLString::compareIStringASCII(name, XMLUni::fgSAX2CoreNameSpacePrefixes) == 0)
1305                return fNamespacePrefix;
1306        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDynamic) == 0)
1307                return fAutoValidation;
1308        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchema) == 0)
1309                return getDoSchema();
1310        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaFullChecking) == 0)
1311                return fScanner->getValidationSchemaFullChecking();
1312        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIdentityConstraintChecking) == 0)
1313                return fScanner->getIdentityConstraintChecking();
1314        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadExternalDTD) == 0)
1315                return fScanner->getLoadExternalDTD();
1316        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadSchema) == 0)
1317                return fScanner->getLoadSchema();
1318        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesContinueAfterFatalError) == 0)
1319                return !fScanner->getExitOnFirstFatal();
1320        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidationErrorAsFatal) == 0)
1321                return fScanner->getValidationConstraintFatal();
1322        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCacheGrammarFromParse) == 0)
1323                return fScanner->isCachingGrammarFromParse();
1324        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)
1325                return fScanner->isUsingCachedGrammarInParse();
1326        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCalculateSrcOfs) == 0)
1327                return fScanner->getCalculateSrcOfs();
1328        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesStandardUriConformant) == 0)
1329                return fScanner->getStandardUriConformant();
1330        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesGenerateSyntheticAnnotations) == 0)
1331                return fScanner->getGenerateSyntheticAnnotations();
1332        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidateAnnotations) == 0)
1333                return fScanner->getValidateAnnotations();
1334        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreCachedDTD) == 0)
1335                return fScanner->getIgnoreCachedDTD();
1336        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreAnnotations) == 0)
1337                return fScanner->getIgnoreAnnotations();
1338        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDisableDefaultEntityResolution) == 0)
1339                return fScanner->getDisableDefaultEntityResolution();
1340        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSkipDTDValidation) == 0)
1341                return fScanner->getSkipDTDValidation();
1342        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesHandleMultipleImports) == 0)
1343                return fScanner->getHandleMultipleImports();
1344        else
1345           throw SAXNotRecognizedException("Unknown Feature", fMemoryManager);
1346
1347        return false;
1348}
1349
1350void SAX2XMLReaderImpl::setProperty(const XMLCh* const name, void* value)
1351{
1352        if (fParseInProgress)
1353                throw SAXNotSupportedException("Property modification is not supported during parse.", fMemoryManager);
1354
1355        if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0)
1356        {
1357                fScanner->setExternalSchemaLocation((XMLCh*)value);
1358        }
1359        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0)
1360        {
1361                fScanner->setExternalNoNamespaceSchemaLocation((XMLCh*)value);
1362        }
1363        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSecurityManager) == 0)
1364        {
1365                fScanner->setSecurityManager((SecurityManager*)value);
1366        }
1367        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLowWaterMark) == 0)
1368        {
1369                fScanner->setLowWaterMark(*(const XMLSize_t*)value);
1370        }
1371        else if (XMLString::equals(name, XMLUni::fgXercesScannerName))
1372        {
1373                XMLScanner* tempScanner = XMLScannerResolver::resolveScanner
1374                (
1375                        (const XMLCh*) value
1376                        , fValidator
1377                        , fGrammarResolver
1378                        , fMemoryManager
1379                );
1380
1381                if (tempScanner)
1382                {
1383                        tempScanner->setParseSettings(fScanner);
1384                        delete fScanner;
1385                        fScanner = tempScanner;
1386                }
1387        }
1388        else
1389           throw SAXNotRecognizedException("Unknown Property", fMemoryManager);
1390}
1391
1392
1393void* SAX2XMLReaderImpl::getProperty(const XMLCh* const name) const
1394{
1395        if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0)
1396                return (void*)fScanner->getExternalSchemaLocation();
1397        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0)
1398                return (void*)fScanner->getExternalNoNamespaceSchemaLocation();
1399        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSecurityManager) == 0)
1400                return (void*)fScanner->getSecurityManager();
1401        else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLowWaterMark) == 0)
1402                return (void*)&fScanner->getLowWaterMark();
1403        else if (XMLString::equals(name, XMLUni::fgXercesScannerName))
1404                return (void*)fScanner->getName();
1405        else
1406                throw SAXNotRecognizedException("Unknown Property", fMemoryManager);
1407        return 0;
1408}
1409
1410
1411// ---------------------------------------------------------------------------
1412//  SAX2XMLReaderImpl: Private getters and setters for conveniences
1413// ---------------------------------------------------------------------------
1414
1415void SAX2XMLReaderImpl::setValidationScheme(const ValSchemes newScheme)
1416{
1417        if (newScheme == Val_Never)
1418                fScanner->setValidationScheme(XMLScanner::Val_Never);
1419        else if (newScheme == Val_Always)
1420                fScanner->setValidationScheme(XMLScanner::Val_Always);
1421        else
1422                fScanner->setValidationScheme(XMLScanner::Val_Auto);
1423}
1424
1425void SAX2XMLReaderImpl::setDoNamespaces(const bool newState)
1426{
1427        fScanner->setDoNamespaces(newState);
1428}
1429
1430bool SAX2XMLReaderImpl::getDoNamespaces() const
1431{
1432        return fScanner->getDoNamespaces();
1433}
1434
1435void SAX2XMLReaderImpl::setDoSchema(const bool newState)
1436{
1437        fScanner->setDoSchema(newState);
1438}
1439
1440bool SAX2XMLReaderImpl::getDoSchema() const
1441{
1442        return fScanner->getDoSchema();
1443}
1444
1445
1446// ---------------------------------------------------------------------------
1447//  SAX2XMLReaderImpl: Grammar preparsing
1448// ---------------------------------------------------------------------------
1449Grammar* SAX2XMLReaderImpl::loadGrammar(const char* const systemId,
1450                                                                                const Grammar::GrammarType grammarType,
1451                                                                                const bool toCache)
1452{
1453        // Avoid multiple entrance
1454        if (fParseInProgress)
1455                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
1456
1457        ResetInProgressType     resetInProgress(this, &SAX2XMLReaderImpl::resetInProgress);
1458
1459        Grammar* grammar = 0;
1460        try
1461        {
1462                fParseInProgress = true;
1463                grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
1464        }
1465        catch(const OutOfMemoryException&)
1466        {
1467                resetInProgress.release();
1468
1469                throw;
1470        }
1471
1472        return grammar;
1473}
1474
1475Grammar* SAX2XMLReaderImpl::loadGrammar(const XMLCh* const systemId,
1476                                                                                const Grammar::GrammarType grammarType,
1477                                                                                const bool toCache)
1478{
1479        // Avoid multiple entrance
1480        if (fParseInProgress)
1481                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
1482
1483        ResetInProgressType     resetInProgress(this, &SAX2XMLReaderImpl::resetInProgress);
1484
1485        Grammar* grammar = 0;
1486        try
1487        {
1488                fParseInProgress = true;
1489                grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
1490        }
1491        catch(const OutOfMemoryException&)
1492        {
1493                resetInProgress.release();
1494
1495                throw;
1496        }
1497
1498        return grammar;
1499}
1500
1501Grammar* SAX2XMLReaderImpl::loadGrammar(const InputSource& source,
1502                                                                                const Grammar::GrammarType grammarType,
1503                                                                                const bool toCache)
1504{
1505        // Avoid multiple entrance
1506        if (fParseInProgress)
1507                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
1508
1509        ResetInProgressType     resetInProgress(this, &SAX2XMLReaderImpl::resetInProgress);
1510
1511        Grammar* grammar = 0;
1512        try
1513        {
1514                fParseInProgress = true;
1515                grammar = fScanner->loadGrammar(source, grammarType, toCache);
1516        }
1517        catch(const OutOfMemoryException&)
1518        {
1519                resetInProgress.release();
1520
1521                throw;
1522        }
1523
1524        return grammar;
1525}
1526
1527void SAX2XMLReaderImpl::resetInProgress()
1528{
1529        fParseInProgress = false;
1530}
1531
1532void SAX2XMLReaderImpl::resetCachedGrammarPool()
1533{
1534        fGrammarResolver->resetCachedGrammar();
1535        fScanner->resetCachedGrammar();
1536}
1537
1538void SAX2XMLReaderImpl::setInputBufferSize(const XMLSize_t bufferSize)
1539{
1540        fScanner->setInputBufferSize(bufferSize);
1541}
1542
1543Grammar* SAX2XMLReaderImpl::getGrammar(const XMLCh* const nameSpaceKey)
1544{
1545        return fGrammarResolver->getGrammar(nameSpaceKey);
1546}
1547
1548
1549XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.