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

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

Changes to icxercesc files

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