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

Last change on this file was 3564, checked in by cameron, 5 years ago

Changes to icxercesc files

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