source: icXML/icXML-devel/src/icxercesc/parsers/SAXParser.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: 31.2 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: SAXParser.cpp 882548 2009-11-20 13:44:14Z borisk $
20 */
21
22
23// ---------------------------------------------------------------------------
24//  Includes
25// ---------------------------------------------------------------------------
26#include <xercesc/parsers/SAXParser.hpp>
27#include <xercesc/internal/XMLScannerResolver.hpp>
28#include <xercesc/framework/XMLValidator.hpp>
29#include <xercesc/util/IOException.hpp>
30#include <xercesc/sax/DocumentHandler.hpp>
31#include <xercesc/sax/DTDHandler.hpp>
32#include <xercesc/sax/ErrorHandler.hpp>
33#include <xercesc/sax/EntityResolver.hpp>
34#include <xercesc/sax/SAXParseException.hpp>
35#include <xercesc/validators/common/GrammarResolver.hpp>
36#include <xercesc/framework/XMLGrammarPool.hpp>
37#include <xercesc/framework/XMLSchemaDescription.hpp>
38#include <xercesc/util/Janitor.hpp>
39#include <xercesc/util/OutOfMemoryException.hpp>
40#include <xercesc/util/XMLEntityResolver.hpp>
41#include <string.h>
42#include <iostream>
43
44XERCES_CPP_NAMESPACE_BEGIN
45
46#pragma warning "fAttrList seems useless but consumes resources; investigate how to remove safely it."
47
48// ---------------------------------------------------------------------------
49//  SAXParser: Constructors and Destructor
50// ---------------------------------------------------------------------------
51
52
53typedef JanitorMemFunCall<SAXParser>    CleanupType;
54typedef JanitorMemFunCall<SAXParser>    ResetInProgressType;
55
56
57SAXParser::SAXParser( XMLValidator* const   valToAdopt
58                                        , MemoryManager* const  manager
59                                        , XMLGrammarPool* const gramPool):
60
61        fParseInProgress(false)
62        , fElemDepth(0)
63        , fAdvDHCount(0)
64        , fAdvDHListSize(32)
65        , fDocHandler(0)
66        , fDTDHandler(0)
67        , fEntityResolver(0)
68        , fXMLEntityResolver(0)
69        , fErrorHandler(0)
70        , fPSVIHandler(0)
71        , fAdvDHList(0)
72        , fScanner(0)
73        , fGrammarResolver(0)
74        , fValidator(valToAdopt)
75        , fMemoryManager(manager)
76        , fGrammarPool(gramPool)
77//      , fElemQNameBuf(1023, manager)
78{
79        CleanupType cleanup(this, &SAXParser::cleanUp);
80
81        try
82        {
83                initialize();
84        }
85        catch(const OutOfMemoryException&)
86        {
87                // Don't cleanup when out of memory, since executing the
88                // code can cause problems.
89                cleanup.release();
90
91                throw;
92        }
93
94        cleanup.release();
95}
96
97
98SAXParser::~SAXParser()
99{
100        cleanUp();
101}
102
103// ---------------------------------------------------------------------------
104//  SAXParser: Initialize/CleanUp methods
105// ---------------------------------------------------------------------------
106void SAXParser::initialize()
107{
108        // Create grammar resolver and string pool to pass to scanner
109        fGrammarResolver = new (fMemoryManager) GrammarResolver(fGrammarPool, fMemoryManager);
110
111        // Create our scanner and tell it what validator to use
112        fScanner = XMLScannerResolver::getDefaultScanner(fValidator, fGrammarResolver, fMemoryManager);
113
114        // Create the initial advanced handler list array and zero it out
115        fAdvDHList = (XMLDocumentHandler**) fMemoryManager->allocate
116        (
117                fAdvDHListSize * sizeof(XMLDocumentHandler*)
118        );//new XMLDocumentHandler*[fAdvDHListSize];
119        memset(fAdvDHList, 0, sizeof(void*) * fAdvDHListSize);
120}
121
122void SAXParser::cleanUp()
123{
124        fMemoryManager->deallocate(fAdvDHList);//delete [] fAdvDHList;
125        delete fScanner;
126        delete fGrammarResolver;
127        // grammar pool must do this
128        //delete fURIStringPool;
129
130        if (fValidator)
131                delete fValidator;
132}
133
134
135// ---------------------------------------------------------------------------
136//  SAXParser: Advanced document handler list maintenance methods
137// ---------------------------------------------------------------------------
138void SAXParser::installAdvDocHandler(XMLDocumentHandler* const toInstall)
139{
140        // See if we need to expand and do so now if needed
141        if (fAdvDHCount == fAdvDHListSize)
142        {
143                // Calc a new size and allocate the new temp buffer
144                const XMLSize_t newSize = (XMLSize_t)(fAdvDHListSize * 1.5);
145                XMLDocumentHandler** newList = (XMLDocumentHandler**) fMemoryManager->allocate
146                (
147                        newSize * sizeof(XMLDocumentHandler*)
148                );//new XMLDocumentHandler*[newSize];
149
150                // Copy over the old data to the new list and zero out the rest
151                memcpy(newList, fAdvDHList, sizeof(void*) * fAdvDHListSize);
152                memset
153                (
154                        &newList[fAdvDHListSize]
155                        , 0
156                        , sizeof(void*) * (newSize - fAdvDHListSize)
157                );
158
159                // And now clean up the old array and store the new stuff
160                fMemoryManager->deallocate(fAdvDHList);//delete [] fAdvDHList;
161                fAdvDHList = newList;
162                fAdvDHListSize = newSize;
163        }
164
165        // Add this new guy into the empty slot
166        fAdvDHList[fAdvDHCount++] = toInstall;
167
168        //
169        //  Install ourself as the document handler with the scanner. We might
170        //  already be, but its not worth checking, just do it.
171        //
172        fScanner->setDocHandler(this);
173}
174
175
176bool SAXParser::removeAdvDocHandler(XMLDocumentHandler* const toRemove)
177{
178        // If our count is zero, can't be any installed
179        if (!fAdvDHCount)
180                return false;
181
182        //
183        //  Search the array until we find this handler. If we find a null entry
184        //  first, we can stop there before the list is kept contiguous.
185        //
186        XMLSize_t index;
187        for (index = 0; index < fAdvDHCount; index++)
188        {
189                //
190                //  We found it. We have to keep the list contiguous, so we have to
191                //  copy down any used elements after this one.
192                //
193                if (fAdvDHList[index] == toRemove)
194                {
195                        //
196                        //  Optimize if only one entry (pretty common). Otherwise, we
197                        //  have to copy them down to compact them.
198                        //
199                        if (fAdvDHCount > 1)
200                        {
201                                index++;
202                                while (index < fAdvDHCount)
203                                        fAdvDHList[index - 1] = fAdvDHList[index];
204                        }
205
206                        // Bump down the count and zero out the last one
207                        fAdvDHCount--;
208                        fAdvDHList[fAdvDHCount] = 0;
209
210                        //
211                        //  If this leaves us with no advanced handlers and there is
212                        //  no SAX doc handler installed on us, then remove us from the
213                        //  scanner as the document handler.
214                        //
215                        if (!fAdvDHCount && !fDocHandler)
216                                fScanner->setDocHandler(0);
217
218                        return true;
219                }
220        }
221
222        // Never found it
223        return false;
224}
225
226
227// ---------------------------------------------------------------------------
228//  SAXParser: Getter methods
229// ---------------------------------------------------------------------------
230const XMLValidator& SAXParser::getValidator() const
231{
232        return *fScanner->getValidator();
233}
234
235
236bool SAXParser::getDoNamespaces() const
237{
238        return fScanner->getDoNamespaces();
239}
240
241bool SAXParser::getGenerateSyntheticAnnotations() const
242{
243        return fScanner->getGenerateSyntheticAnnotations();
244}
245
246bool SAXParser::getValidateAnnotations() const
247{
248        return fScanner->getValidateAnnotations();
249}
250
251bool SAXParser::getExitOnFirstFatalError() const
252{
253        return fScanner->getExitOnFirstFatal();
254}
255
256bool SAXParser::getValidationConstraintFatal() const
257{
258        return fScanner->getValidationConstraintFatal();
259}
260
261
262SAXParser::ValSchemes SAXParser::getValidationScheme() const
263{
264        const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
265
266        if (scheme == XMLScanner::Val_Always)
267                return Val_Always;
268        else if (scheme == XMLScanner::Val_Never)
269                return Val_Never;
270
271        return Val_Auto;
272}
273
274bool SAXParser::getDoSchema() const
275{
276        return fScanner->getDoSchema();
277}
278
279bool SAXParser::getValidationSchemaFullChecking() const
280{
281        return fScanner->getValidationSchemaFullChecking();
282}
283
284bool SAXParser::getIdentityConstraintChecking() const
285{
286        return fScanner->getIdentityConstraintChecking();
287}
288
289int SAXParser::getErrorCount() const
290{
291        return fScanner->getErrorCount();
292}
293
294XMLCh* SAXParser::getExternalSchemaLocation() const
295{
296        return fScanner->getExternalSchemaLocation();
297}
298
299XMLCh* SAXParser::getExternalNoNamespaceSchemaLocation() const
300{
301        return fScanner->getExternalNoNamespaceSchemaLocation();
302}
303
304SecurityManager* SAXParser::getSecurityManager() const
305{
306        return fScanner->getSecurityManager();
307}
308
309XMLSize_t SAXParser::getLowWaterMark() const
310{
311        return fScanner->getLowWaterMark();
312}
313
314bool SAXParser::getLoadExternalDTD() const
315{
316        return fScanner->getLoadExternalDTD();
317}
318
319bool SAXParser::getLoadSchema() const
320{
321        return fScanner->getLoadSchema();
322}
323
324bool SAXParser::isCachingGrammarFromParse() const
325{
326        return fScanner->isCachingGrammarFromParse();
327}
328
329bool SAXParser::isUsingCachedGrammarInParse() const
330{
331        return fScanner->isUsingCachedGrammarInParse();
332}
333
334bool SAXParser::getCalculateSrcOfs() const
335{
336        return fScanner->getCalculateSrcOfs();
337}
338
339bool SAXParser::getStandardUriConformant() const
340{
341        return fScanner->getStandardUriConformant();
342}
343
344Grammar* SAXParser::getGrammar(const XMLCh* const nameSpaceKey)
345{
346        return fGrammarResolver->getGrammar(nameSpaceKey);
347}
348
349Grammar* SAXParser::getRootGrammar()
350{
351        return fScanner->getRootGrammar();
352}
353
354const XMLCh* SAXParser::getURIText(unsigned int uriId) const
355{
356        return fScanner->getURIText(uriId);
357}
358
359XMLFilePos SAXParser::getSrcOffset() const
360{
361        return fScanner->getSrcOffset();
362}
363
364bool SAXParser::getIgnoreCachedDTD() const
365{
366        return fScanner->getIgnoreCachedDTD();
367}
368
369bool SAXParser::getIgnoreAnnotations() const
370{
371        return fScanner->getIgnoreAnnotations();
372}
373
374bool SAXParser::getDisableDefaultEntityResolution() const
375{
376        return fScanner->getDisableDefaultEntityResolution();
377}
378
379bool SAXParser::getSkipDTDValidation() const
380{
381        return fScanner->getSkipDTDValidation();
382}
383
384bool SAXParser::getHandleMultipleImports() const
385{
386        return fScanner->getHandleMultipleImports();
387}
388
389// ---------------------------------------------------------------------------
390//  SAXParser: Setter methods
391// ---------------------------------------------------------------------------
392void SAXParser::setDoNamespaces(const bool newState)
393{
394        fScanner->setDoNamespaces(newState);
395}
396
397void SAXParser::setGenerateSyntheticAnnotations(const bool newState)
398{
399        fScanner->setGenerateSyntheticAnnotations(newState);
400}
401
402void SAXParser::setValidateAnnotations(const bool newState)
403{
404        fScanner->setValidateAnnotations(newState);
405}
406
407void SAXParser::setExitOnFirstFatalError(const bool newState)
408{
409        fScanner->setExitOnFirstFatal(newState);
410}
411
412
413void SAXParser::setValidationConstraintFatal(const bool newState)
414{
415        fScanner->setValidationConstraintFatal(newState);
416}
417
418
419void SAXParser::setValidationScheme(const ValSchemes newScheme)
420{
421        if (newScheme == Val_Never)
422                fScanner->setValidationScheme(XMLScanner::Val_Never);
423        else if (newScheme == Val_Always)
424                fScanner->setValidationScheme(XMLScanner::Val_Always);
425        else
426                fScanner->setValidationScheme(XMLScanner::Val_Auto);
427}
428
429void SAXParser::setDoSchema(const bool newState)
430{
431        fScanner->setDoSchema(newState);
432}
433
434void SAXParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
435{
436        fScanner->setValidationSchemaFullChecking(schemaFullChecking);
437}
438
439void SAXParser::setIdentityConstraintChecking(const bool identityConstraintChecking)
440{
441        fScanner->setIdentityConstraintChecking(identityConstraintChecking);
442}
443
444void SAXParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
445{
446        fScanner->setExternalSchemaLocation(schemaLocation);
447}
448void SAXParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
449{
450        fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
451}
452
453void SAXParser::setExternalSchemaLocation(const char* const schemaLocation)
454{
455        fScanner->setExternalSchemaLocation(schemaLocation);
456}
457void SAXParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
458{
459        fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
460}
461
462void SAXParser::setSecurityManager(SecurityManager* const securityManager)
463{
464        // since this could impact various components, don't permit it to change
465        // during a parse
466        if (fParseInProgress)
467                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
468
469        fScanner->setSecurityManager(securityManager);
470}
471
472void SAXParser::setLowWaterMark(XMLSize_t lwm)
473{
474        fScanner->setLowWaterMark(lwm);
475}
476
477void SAXParser::setLoadExternalDTD(const bool newState)
478{
479        fScanner->setLoadExternalDTD(newState);
480}
481
482void SAXParser::setLoadSchema(const bool newState)
483{
484        fScanner->setLoadSchema(newState);
485}
486
487void SAXParser::cacheGrammarFromParse(const bool newState)
488{
489        fScanner->cacheGrammarFromParse(newState);
490
491        if (newState)
492                fScanner->useCachedGrammarInParse(newState);
493}
494
495void SAXParser::useCachedGrammarInParse(const bool newState)
496{
497        if (newState || !fScanner->isCachingGrammarFromParse())
498                fScanner->useCachedGrammarInParse(newState);
499}
500
501void SAXParser::setCalculateSrcOfs(const bool newState)
502{
503        fScanner->setCalculateSrcOfs(newState);
504}
505
506void SAXParser::setStandardUriConformant(const bool newState)
507{
508        fScanner->setStandardUriConformant(newState);
509}
510
511void SAXParser::useScanner(const XMLCh* const scannerName)
512{
513        XMLScanner* tempScanner = XMLScannerResolver::resolveScanner
514        (
515                scannerName
516                , fValidator
517                , fGrammarResolver
518                , fMemoryManager
519        );
520
521        if (tempScanner)
522        {
523                tempScanner->setParseSettings(fScanner);
524
525                delete fScanner;
526                fScanner = tempScanner;
527        }
528}
529
530void SAXParser::setInputBufferSize(const XMLSize_t bufferSize)
531{
532        fScanner->setInputBufferSize(bufferSize);
533}
534
535void SAXParser::setIgnoreCachedDTD(const bool newValue)
536{
537        fScanner->setIgnoredCachedDTD(newValue);
538}
539
540void SAXParser::setIgnoreAnnotations(const bool newValue)
541{
542        fScanner->setIgnoreAnnotations(newValue);
543}
544
545void SAXParser::setDisableDefaultEntityResolution(const bool newValue)
546{
547        fScanner->setDisableDefaultEntityResolution(newValue);
548}
549
550void SAXParser::setSkipDTDValidation(const bool newValue)
551{
552        fScanner->setSkipDTDValidation(newValue);
553}
554
555void SAXParser::setHandleMultipleImports(const bool newValue)
556{
557        fScanner->setHandleMultipleImports(newValue);
558}
559
560// ---------------------------------------------------------------------------
561//  SAXParser: Overrides of the SAX Parser interface
562// ---------------------------------------------------------------------------
563void SAXParser::parse(const InputSource& source)
564{
565        // Avoid multiple entrance
566        if (fParseInProgress)
567                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
568
569        ResetInProgressType     resetInProgress(this, &SAXParser::resetInProgress);
570
571        try
572        {
573                fParseInProgress = true;
574                fScanner->scanDocument(source);
575        }
576        catch(const OutOfMemoryException&)
577        {
578                resetInProgress.release();
579
580                throw;
581        }
582}
583
584void SAXParser::parse(const XMLCh* const systemId)
585{
586        // Avoid multiple entrance
587        if (fParseInProgress)
588                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
589
590        ResetInProgressType     resetInProgress(this, &SAXParser::resetInProgress);
591
592        try
593        {
594                fParseInProgress = true;
595                fScanner->scanDocument(systemId);
596        }
597        catch(const OutOfMemoryException&)
598        {
599                resetInProgress.release();
600
601                throw;
602        }
603}
604
605void SAXParser::parse(const char* const systemId)
606{
607        // Avoid multiple entrance
608        if (fParseInProgress)
609                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
610
611        ResetInProgressType     resetInProgress(this, &SAXParser::resetInProgress);
612
613        try
614        {
615                fParseInProgress = true;
616                fScanner->scanDocument(systemId);
617        }
618        catch(const OutOfMemoryException&)
619        {
620                resetInProgress.release();
621
622                throw;
623        }
624}
625
626void SAXParser::setDocumentHandler(DocumentHandler* const handler)
627{
628        fDocHandler = handler;
629        if (fDocHandler)
630        {
631                //
632                //  Make sure we are set as the document handler with the scanner.
633                //  We may already be (if advanced handlers are installed), but its
634                //  not worthing checking, just do it.
635                //
636                fScanner->setDocHandler(this);
637        }
638         else
639        {
640                //
641                //  If we don't have any advanced handlers either, then deinstall us
642                //  from the scanner because we don't need document events anymore.
643                //
644                if (!fAdvDHCount)
645                        fScanner->setDocHandler(0);
646        }
647}
648
649
650void SAXParser::setDTDHandler(DTDHandler* const handler)
651{
652        fDTDHandler = handler;
653        if (fDTDHandler)
654                fScanner->setDocTypeHandler(this);
655        else
656                fScanner->setDocTypeHandler(0);
657}
658
659
660void SAXParser::setErrorHandler(ErrorHandler* const handler)
661{
662        //
663        //  Store the handler. Then either install or deinstall us as the
664        //  error reporter on the scanner.
665        //
666        fErrorHandler = handler;
667        if (fErrorHandler) {
668                fScanner->setErrorReporter(this);
669                fScanner->setErrorHandler(fErrorHandler);
670        }
671        else {
672                fScanner->setErrorReporter(0);
673                fScanner->setErrorHandler(0);
674        }
675}
676
677
678void SAXParser::setPSVIHandler(PSVIHandler* const handler)
679{
680        fPSVIHandler = handler;
681        if (fPSVIHandler) {
682                fScanner->setPSVIHandler(fPSVIHandler);
683        }
684        else {
685                fScanner->setPSVIHandler(0);
686        }
687}
688
689void SAXParser::setEntityResolver(EntityResolver* const resolver)
690{
691        fEntityResolver = resolver;
692        if (fEntityResolver) {
693                fScanner->setEntityHandler(this);
694                fXMLEntityResolver = 0;
695        }
696        else {
697                fScanner->setEntityHandler(0);
698        }
699}
700
701void SAXParser::setXMLEntityResolver(XMLEntityResolver* const resolver)
702{
703        fXMLEntityResolver = resolver;
704        if (fXMLEntityResolver) {
705                fScanner->setEntityHandler(this);
706                fEntityResolver = 0;
707        }
708        else {
709                fScanner->setEntityHandler(0);
710        }
711}
712
713// ---------------------------------------------------------------------------
714//  SAXParser: Progressive parse methods
715// ---------------------------------------------------------------------------
716bool SAXParser::parseFirst( const   XMLCh* const    systemId
717                                                        ,       XMLPScanToken&  toFill)
718{
719        //
720        //  Avoid multiple entrance. We cannot enter here while a regular parse
721        //  is in progress.
722        //
723        if (fParseInProgress)
724                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
725
726        return fScanner->scanFirst(systemId, toFill);
727}
728
729bool SAXParser::parseFirst( const   char* const     systemId
730                                                        ,       XMLPScanToken&  toFill)
731{
732        //
733        //  Avoid multiple entrance. We cannot enter here while a regular parse
734        //  is in progress.
735        //
736        if (fParseInProgress)
737                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
738
739        return fScanner->scanFirst(systemId, toFill);
740}
741
742bool SAXParser::parseFirst( const   InputSource&    source
743                                                        ,       XMLPScanToken&  toFill)
744{
745        //
746        //  Avoid multiple entrance. We cannot enter here while a regular parse
747        //  is in progress.
748        //
749        if (fParseInProgress)
750                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
751
752        return fScanner->scanFirst(source, toFill);
753}
754
755bool SAXParser::parseNext(XMLPScanToken& token)
756{
757        return fScanner->scanNext(token);
758}
759
760void SAXParser::parseReset(XMLPScanToken& token)
761{
762        // Reset the scanner
763        fScanner->scanReset(token);
764}
765
766
767// ---------------------------------------------------------------------------
768//  SAXParser: Overrides of the XMLDocumentHandler interface
769// ---------------------------------------------------------------------------
770void SAXParser::docCharacters(  const   XMLCh* const    chars
771                                                                , const XMLSize_t       length
772                                                                , const bool            cdataSection)
773{
774        // Suppress the chars before the root element.
775        if (fElemDepth)
776        {
777                // Just map to the SAX document handler
778                if (fDocHandler)
779                        fDocHandler->characters(chars, length);
780        }
781
782        //
783        //  If there are any installed advanced handlers, then lets call them
784        //  with this info.
785        //
786        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
787                fAdvDHList[index]->docCharacters(chars, length, cdataSection);
788}
789
790
791void SAXParser::docComment(const XMLCh* const commentText)
792{
793        //
794        //  SAX has no way to report this. But, if there are any installed
795        //  advanced handlers, then lets call them with this info.
796        //
797        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
798                fAdvDHList[index]->docComment(commentText);
799}
800
801
802void SAXParser::XMLDecl( const  XMLCh* const    versionStr
803                                                , const XMLCh* const    encodingStr
804                                                , const XMLCh* const    standaloneStr
805                                                , const XMLCh* const    actualEncodingStr
806                                                )
807{
808        //
809        //  SAX has no way to report this. But, if there are any installed
810        //  advanced handlers, then lets call them with this info.
811        //
812        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
813                fAdvDHList[index]->XMLDecl( versionStr,
814                                                                        encodingStr,
815                                                                        standaloneStr,
816                                                                        actualEncodingStr );
817}
818
819
820void SAXParser::docPI(  const   XMLCh* const    target
821                                                , const XMLCh* const    data)
822{
823        // Just map to the SAX document handler
824        if (fDocHandler)
825                fDocHandler->processingInstruction(target, data);
826
827        //
828        //  If there are any installed advanced handlers, then lets call them
829        //  with this info.
830        //
831        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
832                fAdvDHList[index]->docPI(target, data);
833}
834
835
836void SAXParser::endDocument()
837{
838        if (fDocHandler)
839                fDocHandler->endDocument();
840
841        //
842        //  If there are any installed advanced handlers, then lets call them
843        //  with this info.
844        //
845        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
846                fAdvDHList[index]->endDocument();
847}
848
849
850void SAXParser::endElement( const   XMLElementDecl& elemDecl
851                                                        , const unsigned int    uriId
852                                                        , const bool            isRoot
853                                                        , const XMLCh* const    elemPrefix)
854{
855        // Just map to the SAX document handler
856        if (fDocHandler)
857        {
858                fDocHandler->endElement(elemDecl.getFullName());
859        }
860
861        //
862        //  If there are any installed advanced handlers, then lets call them
863        //  with this info.
864        //
865        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
866        {
867                fAdvDHList[index]->endElement(elemDecl, uriId, isRoot, elemPrefix);
868        }
869
870        //
871        //  Dump the element depth down again. Don't let it underflow in case
872        //  of malformed XML.
873        //
874        if (fElemDepth)
875                fElemDepth--;
876}
877
878
879void SAXParser::endEntityReference(const XMLEntityDecl& entityDecl)
880{
881        //
882        //  SAX has no way to report this event. But, if there are any installed
883        //  advanced handlers, then lets call them with this info.
884        //
885        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
886                fAdvDHList[index]->endEntityReference(entityDecl);
887}
888
889
890void SAXParser::ignorableWhitespace(const   XMLCh* const    chars
891                                                                        , const XMLSize_t       length
892                                                                        , const bool            cdataSection)
893{
894        // Do not report the whitespace before the root element.
895        if (!fElemDepth)
896                return;
897
898        // Just map to the SAX document handler
899        if (fDocHandler)
900                fDocHandler->ignorableWhitespace(chars, length);
901
902        //
903        //  If there are any installed advanced handlers, then lets call them
904        //  with this info.
905        //
906        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
907                fAdvDHList[index]->ignorableWhitespace(chars, length, cdataSection);
908}
909
910
911void SAXParser::resetDocument()
912{
913        // Just map to the SAX document handler
914        if (fDocHandler)
915                fDocHandler->resetDocument();
916
917        //
918        //  If there are any installed advanced handlers, then lets call them
919        //  with this info.
920        //
921        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
922                fAdvDHList[index]->resetDocument();
923
924        // Make sure our element depth flag gets set back to zero
925        fElemDepth = 0;
926}
927
928
929void SAXParser::startDocument()
930{
931        // Just map to the SAX document handler
932        if (fDocHandler)
933                fDocHandler->setDocumentLocator(fScanner->getLocator());
934        if(fDocHandler)
935                fDocHandler->startDocument();
936
937        //
938        //  If there are any installed advanced handlers, then lets call them
939        //  with this info.
940        //
941        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
942                fAdvDHList[index]->startDocument();
943}
944
945
946void SAXParser::
947startElement( const XMLElementDecl&         elemDecl
948                        , const unsigned int            elemURLId
949                        , const XMLCh* const            elemPrefix
950                        , const RefVectorOf<XMLAttr>&   attrList
951                        , const XMLSize_t               attrCount
952                        , const bool                    isEmpty
953                        , const bool                    isRoot)
954{
955    DEBUG_MESSAGE("SAXParser::startElement(" << elemDecl << ',' << elemURLId << ',' << elemPrefix << ',' << attrList << ',' << attrCount << ',' << isEmpty << ',' << isRoot << ')');
956
957        // Bump the element depth counter if not empty
958        if (!isEmpty)
959                fElemDepth++;
960
961        if (fDocHandler)
962        {
963                fAttrList.setVector(&attrList, attrCount);
964
965                fDocHandler->startElement(elemDecl.getFullName(), fAttrList);
966
967                // If its empty, send the end tag event now
968                if (isEmpty)
969                {
970                        fDocHandler->endElement(elemDecl.getFullName());
971                }
972        }
973
974        //
975        //  If there are any installed advanced handlers, then lets call them
976        //  with this info.
977        //
978        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
979        {
980                fAdvDHList[index]->startElement
981                (
982                        elemDecl
983                        , elemURLId
984                        , elemPrefix
985                        , attrList
986                        , attrCount
987                        , isEmpty
988                        , isRoot
989                );
990        }
991}
992
993
994void SAXParser::startEntityReference(const XMLEntityDecl& entityDecl)
995{
996        //
997        //  SAX has no way to report this. But, If there are any installed
998        //  advanced handlers, then lets call them with this info.
999        //
1000        for (XMLSize_t index = 0; index < fAdvDHCount; index++)
1001                fAdvDHList[index]->startEntityReference(entityDecl);
1002}
1003
1004
1005
1006// ---------------------------------------------------------------------------
1007//  SAXParser: Overrides of the DocTypeHandler interface
1008// ---------------------------------------------------------------------------
1009void SAXParser::attDef( const   DTDElementDecl&
1010                                                , const DTDAttDef&
1011                                                , const bool)
1012{
1013        // Unused by SAX DTDHandler interface at this time
1014}
1015
1016
1017void SAXParser::doctypeComment(const XMLCh* const)
1018{
1019        // Unused by SAX DTDHandler interface at this time
1020}
1021
1022
1023void SAXParser::doctypeDecl(const   DTDElementDecl&
1024                                                        , const XMLCh* const
1025                                                        , const XMLCh* const
1026                                                        , const bool
1027                                                        , const bool)
1028{
1029        // Unused by SAX DTDHandler interface at this time
1030}
1031
1032
1033void SAXParser::doctypePI(  const   XMLCh* const
1034                                                        , const XMLCh* const)
1035{
1036        // Unused by SAX DTDHandler interface at this time
1037}
1038
1039
1040void SAXParser::doctypeWhitespace(  const   XMLCh* const
1041                                                                        , const XMLSize_t)
1042{
1043        // Unused by SAX DTDHandler interface at this time
1044}
1045
1046
1047void SAXParser::elementDecl(const DTDElementDecl&, const bool)
1048{
1049        // Unused by SAX DTDHandler interface at this time
1050}
1051
1052
1053void SAXParser::endAttList(const DTDElementDecl&)
1054{
1055        // Unused by SAX DTDHandler interface at this time
1056}
1057
1058
1059void SAXParser::endIntSubset()
1060{
1061        // Unused by SAX DTDHandler interface at this time
1062}
1063
1064
1065void SAXParser::endExtSubset()
1066{
1067        // Unused by SAX DTDHandler interface at this time
1068}
1069
1070
1071void SAXParser::entityDecl( const   DTDEntityDecl&  entityDecl
1072                                                        , const bool
1073                                                        , const bool            isIgnored)
1074{
1075        //
1076        //  If we have a DTD handler, and this entity is not ignored, and
1077        //  its an unparsed entity, then send this one.
1078        //
1079        if (fDTDHandler && !isIgnored)
1080        {
1081                if (entityDecl.isUnparsed())
1082                {
1083                        fDTDHandler->unparsedEntityDecl
1084                        (
1085                                entityDecl.getName()
1086                                , entityDecl.getPublicId()
1087                                , entityDecl.getSystemId()
1088                                , entityDecl.getNotationName()
1089                        );
1090                }
1091        }
1092}
1093
1094
1095void SAXParser::resetDocType()
1096{
1097        // Just map to the DTD handler
1098        if (fDTDHandler)
1099                fDTDHandler->resetDocType();
1100}
1101
1102
1103void SAXParser::notationDecl(   const   XMLNotationDecl&    notDecl
1104                                                                , const bool                isIgnored)
1105{
1106        if (fDTDHandler && !isIgnored)
1107        {
1108                fDTDHandler->notationDecl
1109                (
1110                        notDecl.getName()
1111                        , notDecl.getPublicId()
1112                        , notDecl.getSystemId()
1113                );
1114        }
1115}
1116
1117
1118void SAXParser::startAttList(const DTDElementDecl&)
1119{
1120        // Unused by SAX DTDHandler interface at this time
1121}
1122
1123
1124void SAXParser::startIntSubset()
1125{
1126        // Unused by SAX DTDHandler interface at this time
1127}
1128
1129
1130void SAXParser::startExtSubset()
1131{
1132        // Unused by SAX DTDHandler interface at this time
1133}
1134
1135
1136void SAXParser::TextDecl(   const  XMLCh* const
1137                                                        , const XMLCh* const)
1138{
1139        // Unused by SAX DTDHandler interface at this time
1140}
1141
1142
1143// ---------------------------------------------------------------------------
1144//  SAXParser: Overrides of the XMLErrorReporter interface
1145// ---------------------------------------------------------------------------
1146void SAXParser::resetErrors()
1147{
1148        if (fErrorHandler)
1149                fErrorHandler->resetErrors();
1150}
1151
1152
1153void SAXParser::error(  const   unsigned int
1154                                                , const XMLCh* const
1155                                                , const XMLErrorReporter::ErrTypes  errType
1156                                                , const XMLCh* const                errorText
1157                                                , const XMLCh* const                systemId
1158                                                , const XMLCh* const                publicId
1159                                                , const XMLFileLoc                  lineNum
1160                                                , const XMLFileLoc                  colNum)
1161{
1162        SAXParseException toThrow = SAXParseException
1163        (
1164                errorText
1165                , publicId
1166                , systemId
1167                , lineNum
1168                , colNum
1169                , fMemoryManager
1170        );
1171
1172        if (!fErrorHandler)
1173        {
1174                if (errType == XMLErrorReporter::ErrType_Fatal)
1175                        throw toThrow;
1176                else
1177                        return;
1178        }
1179
1180        if (errType == XMLErrorReporter::ErrType_Warning)
1181                fErrorHandler->warning(toThrow);
1182        else if (errType == XMLErrorReporter::ErrType_Fatal)
1183                fErrorHandler->fatalError(toThrow);
1184        else
1185                fErrorHandler->error(toThrow);
1186}
1187
1188
1189
1190// ---------------------------------------------------------------------------
1191//  SAXParser: Handlers for the XMLEntityHandler interface
1192// ---------------------------------------------------------------------------
1193void SAXParser::endInputSource(const InputSource&)
1194{
1195}
1196
1197bool SAXParser::expandSystemId(const XMLCh* const, XMLBuffer&)
1198{
1199        return false;
1200}
1201
1202
1203void SAXParser::resetEntities()
1204{
1205        // Nothing to do for this one
1206}
1207
1208InputSource*
1209SAXParser::resolveEntity(  XMLResourceIdentifier* resourceIdentifier )
1210{
1211        // Just map to the SAX entity resolver handler
1212        if (fEntityResolver)
1213                return fEntityResolver->resolveEntity(resourceIdentifier->getPublicId(),
1214                                                                                                resourceIdentifier->getSystemId());
1215        if (fXMLEntityResolver)
1216                return fXMLEntityResolver->resolveEntity(resourceIdentifier);
1217        return 0;
1218}
1219
1220
1221void SAXParser::startInputSource(const InputSource&)
1222{
1223        // Nothing to do for this one
1224}
1225
1226
1227// ---------------------------------------------------------------------------
1228//  SAXParser: Grammar preparsing methods
1229// ---------------------------------------------------------------------------
1230Grammar* SAXParser::loadGrammar(const char* const systemId,
1231                                                                const Grammar::GrammarType grammarType,
1232                                                                const bool toCache)
1233{
1234        // Avoid multiple entrance
1235        if (fParseInProgress)
1236                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
1237
1238        ResetInProgressType     resetInProgress(this, &SAXParser::resetInProgress);
1239
1240        Grammar* grammar = 0;
1241        try
1242        {
1243                fParseInProgress = true;
1244                grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
1245        }
1246        catch(const OutOfMemoryException&)
1247        {
1248                resetInProgress.release();
1249
1250                throw;
1251        }
1252
1253        return grammar;
1254}
1255
1256Grammar* SAXParser::loadGrammar(const XMLCh* const systemId,
1257                                                                const Grammar::GrammarType grammarType,
1258                                                                const bool toCache)
1259{
1260        // Avoid multiple entrance
1261        if (fParseInProgress)
1262                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
1263
1264        ResetInProgressType     resetInProgress(this, &SAXParser::resetInProgress);
1265
1266        Grammar* grammar = 0;
1267        try
1268        {
1269                fParseInProgress = true;
1270                grammar = fScanner->loadGrammar(systemId, grammarType, toCache);
1271        }
1272        catch(const OutOfMemoryException&)
1273        {
1274                resetInProgress.release();
1275
1276                throw;
1277        }
1278
1279        return grammar;
1280}
1281
1282Grammar* SAXParser::loadGrammar(const InputSource& source,
1283                                                                const Grammar::GrammarType grammarType,
1284                                                                const bool toCache)
1285{
1286        // Avoid multiple entrance
1287        if (fParseInProgress)
1288                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
1289
1290        ResetInProgressType     resetInProgress(this, &SAXParser::resetInProgress);
1291
1292        Grammar* grammar = 0;
1293        try
1294        {
1295                fParseInProgress = true;
1296                grammar = fScanner->loadGrammar(source, grammarType, toCache);
1297        }
1298        catch(const OutOfMemoryException&)
1299        {
1300                resetInProgress.release();
1301
1302                throw;
1303        }
1304
1305        return grammar;
1306}
1307
1308void SAXParser::resetInProgress()
1309{
1310        fParseInProgress = false;
1311}
1312
1313void SAXParser::resetCachedGrammarPool()
1314{
1315        fGrammarResolver->resetCachedGrammar();
1316        fScanner->resetCachedGrammar();
1317}
1318
1319XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.