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

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

Fixes for icXML 0.9

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