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

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

Initial check-in of icXML 0.8 source files

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