source: icXML/icXML-devel/src/xercesc/parsers/DOMLSParserImpl.cpp @ 3153

Last change on this file since 3153 was 2722, checked in by cameron, 7 years ago

Original Xerces files with import mods for icxercesc

File size: 54.1 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*  This file contains code to build the DOM tree. It registers a document
20*  handler with the scanner. In these handler methods, appropriate DOM nodes
21*  are created and added to the DOM tree.
22*
23* $Id: DOMLSParserImpl.cpp 882548 2009-11-20 13:44:14Z borisk $
24*
25*/
26
27
28
29// ---------------------------------------------------------------------------
30//  Includes
31// ---------------------------------------------------------------------------
32#include <xercesc/parsers/DOMLSParserImpl.hpp>
33#include <xercesc/dom/DOMLSResourceResolver.hpp>
34#include <xercesc/dom/DOMErrorHandler.hpp>
35#include <xercesc/dom/DOMLSParserFilter.hpp>
36#include <xercesc/dom/DOMNodeFilter.hpp>
37#include <xercesc/dom/impl/DOMErrorImpl.hpp>
38#include <xercesc/dom/impl/DOMLocatorImpl.hpp>
39#include <xercesc/dom/impl/DOMConfigurationImpl.hpp>
40#include <xercesc/dom/impl/DOMStringListImpl.hpp>
41#include <xercesc/dom/impl/DOMDocumentImpl.hpp>
42#include <xercesc/dom/DOMException.hpp>
43#include <xercesc/dom/DOMLSException.hpp>
44#include <xercesc/dom/DOMDocumentFragment.hpp>
45#include <xercesc/dom/DOMNamedNodeMap.hpp>
46#include <icxercesc/internal/XMLScanner.hpp>
47#include <xercesc/framework/Wrapper4DOMLSInput.hpp>
48#include <icxercesc/framework/XMLGrammarPool.hpp>
49#include <xercesc/framework/XMLSchemaDescription.hpp>
50#include <xercesc/util/Janitor.hpp>
51#include <icxercesc/validators/common/GrammarResolver.hpp>
52#include <xercesc/util/OutOfMemoryException.hpp>
53#include <xercesc/util/XMLEntityResolver.hpp>
54#include <xercesc/util/RuntimeException.hpp>
55#include <xercesc/util/XMLDOMMsg.hpp>
56
57XERCES_CPP_NAMESPACE_BEGIN
58
59
60// ---------------------------------------------------------------------------
61//  A filter used to abort processing
62// ---------------------------------------------------------------------------
63class __AbortFilter : public DOMLSParserFilter
64{
65public:
66    __AbortFilter() {}
67    virtual FilterAction acceptNode(DOMNode*)             { return FILTER_INTERRUPT; }
68    virtual FilterAction startElement(DOMElement* )       { return FILTER_INTERRUPT; }
69    virtual DOMNodeFilter::ShowType getWhatToShow() const { return DOMNodeFilter::SHOW_ALL; }
70};
71
72static __AbortFilter g_AbortFilter;
73
74// ---------------------------------------------------------------------------
75//  DOMLSParserImpl: Constructors and Destructor
76// ---------------------------------------------------------------------------
77DOMLSParserImpl::DOMLSParserImpl( XMLValidator* const   valToAdopt
78                              , MemoryManager* const  manager
79                              , XMLGrammarPool* const gramPool) :
80
81AbstractDOMParser(valToAdopt, manager, gramPool)
82, fEntityResolver(0)
83, fXMLEntityResolver(0)
84, fErrorHandler(0)
85, fFilter(0)
86, fCharsetOverridesXMLEncoding(true)
87, fUserAdoptsDocument(false)
88, fSupportedParameters(0)
89, fFilterAction(0)
90, fFilterDelayedTextNodes(0)
91, fWrapNodesInDocumentFragment(0)
92, fWrapNodesContext(0)
93{
94    // dom spec has different default from scanner's default, so set explicitly
95    getScanner()->setNormalizeData(false);
96
97    fSupportedParameters=new (fMemoryManager) DOMStringListImpl(48, manager);
98    fSupportedParameters->add(XMLUni::fgDOMResourceResolver);
99    fSupportedParameters->add(XMLUni::fgDOMErrorHandler);
100    fSupportedParameters->add(XMLUni::fgXercesEntityResolver);
101    fSupportedParameters->add(XMLUni::fgXercesSchemaExternalSchemaLocation);
102        fSupportedParameters->add(XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation);
103        fSupportedParameters->add(XMLUni::fgXercesSecurityManager);
104        fSupportedParameters->add(XMLUni::fgXercesScannerName);
105    fSupportedParameters->add(XMLUni::fgXercesParserUseDocumentFromImplementation);
106    fSupportedParameters->add(XMLUni::fgDOMCharsetOverridesXMLEncoding);
107    fSupportedParameters->add(XMLUni::fgDOMDisallowDoctype);
108    fSupportedParameters->add(XMLUni::fgDOMIgnoreUnknownCharacterDenormalization);
109    fSupportedParameters->add(XMLUni::fgDOMNamespaces);
110    fSupportedParameters->add(XMLUni::fgDOMSupportedMediatypesOnly);
111    fSupportedParameters->add(XMLUni::fgDOMValidate);
112    fSupportedParameters->add(XMLUni::fgDOMValidateIfSchema);
113    fSupportedParameters->add(XMLUni::fgDOMWellFormed);
114    fSupportedParameters->add(XMLUni::fgDOMCanonicalForm);
115    fSupportedParameters->add(XMLUni::fgDOMCDATASections);
116    fSupportedParameters->add(XMLUni::fgDOMCheckCharacterNormalization);
117    fSupportedParameters->add(XMLUni::fgDOMComments);
118    fSupportedParameters->add(XMLUni::fgDOMDatatypeNormalization);
119    fSupportedParameters->add(XMLUni::fgDOMElementContentWhitespace);
120    fSupportedParameters->add(XMLUni::fgDOMEntities);
121    fSupportedParameters->add(XMLUni::fgDOMNamespaceDeclarations);
122    fSupportedParameters->add(XMLUni::fgDOMNormalizeCharacters);
123    fSupportedParameters->add(XMLUni::fgDOMSchemaLocation);
124    fSupportedParameters->add(XMLUni::fgDOMSchemaType);
125    fSupportedParameters->add(XMLUni::fgDOMSplitCDATASections);
126    fSupportedParameters->add(XMLUni::fgDOMInfoset);
127    fSupportedParameters->add(XMLUni::fgXercesSchema);
128    fSupportedParameters->add(XMLUni::fgXercesSchemaFullChecking);
129    fSupportedParameters->add(XMLUni::fgXercesUserAdoptsDOMDocument);
130    fSupportedParameters->add(XMLUni::fgXercesLoadExternalDTD);
131    fSupportedParameters->add(XMLUni::fgXercesLoadSchema);
132    fSupportedParameters->add(XMLUni::fgXercesContinueAfterFatalError);
133    fSupportedParameters->add(XMLUni::fgXercesValidationErrorAsFatal);
134    fSupportedParameters->add(XMLUni::fgXercesCacheGrammarFromParse);
135    fSupportedParameters->add(XMLUni::fgXercesUseCachedGrammarInParse);
136    fSupportedParameters->add(XMLUni::fgXercesCalculateSrcOfs);
137    fSupportedParameters->add(XMLUni::fgXercesStandardUriConformant);
138    fSupportedParameters->add(XMLUni::fgXercesDOMHasPSVIInfo);
139    fSupportedParameters->add(XMLUni::fgXercesGenerateSyntheticAnnotations);
140    fSupportedParameters->add(XMLUni::fgXercesValidateAnnotations);
141    fSupportedParameters->add(XMLUni::fgXercesIdentityConstraintChecking);
142    fSupportedParameters->add(XMLUni::fgXercesIgnoreCachedDTD);
143    fSupportedParameters->add(XMLUni::fgXercesIgnoreAnnotations);
144    fSupportedParameters->add(XMLUni::fgXercesDisableDefaultEntityResolution);
145    fSupportedParameters->add(XMLUni::fgXercesSkipDTDValidation);
146    fSupportedParameters->add(XMLUni::fgXercesDoXInclude);
147    fSupportedParameters->add(XMLUni::fgXercesHandleMultipleImports);
148
149    // LSParser by default does namespace processing
150    setDoNamespaces(true);
151}
152
153
154DOMLSParserImpl::~DOMLSParserImpl()
155{
156    delete fSupportedParameters;
157    delete fFilterAction;
158    delete fFilterDelayedTextNodes;
159}
160
161
162// ---------------------------------------------------------------------------
163//  DOMLSParserImpl: Setter methods
164// ---------------------------------------------------------------------------
165bool DOMLSParserImpl::getBusy() const
166{
167    return getParseInProgress();
168}
169
170// ---------------------------------------------------------------------------
171//  DOMLSParserImpl: Setter methods
172// ---------------------------------------------------------------------------
173void DOMLSParserImpl::setFilter(DOMLSParserFilter* const filter)
174{
175    fFilter = filter;
176}
177
178// ---------------------------------------------------------------------------
179//  DOMLSParserImpl: DOMConfiguration methods
180// ---------------------------------------------------------------------------
181void DOMLSParserImpl::setParameter(const XMLCh* name, const void* value)
182{
183    if (XMLString::compareIStringASCII(name, XMLUni::fgDOMResourceResolver) == 0)
184    {
185        fEntityResolver = (DOMLSResourceResolver*)value;
186        if (fEntityResolver) {
187            getScanner()->setEntityHandler(this);
188            fXMLEntityResolver = 0;
189        }
190        else {
191            getScanner()->setEntityHandler(0);
192        }
193    }
194    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMErrorHandler) == 0)
195    {
196        fErrorHandler = (DOMErrorHandler*)value;
197        if (fErrorHandler) {
198            getScanner()->setErrorReporter(this);
199        }
200        else {
201            getScanner()->setErrorReporter(0);
202        }
203    }
204    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaLocation) == 0)
205    {
206        // TODO
207    }
208    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaType) == 0)
209    {
210        // TODO
211    }
212    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesEntityResolver) == 0)
213    {
214        fXMLEntityResolver = (XMLEntityResolver*)value;
215        if (fXMLEntityResolver) {
216            getScanner()->setEntityHandler(this);
217            fEntityResolver = 0;
218        }
219        else {
220          getScanner()->setEntityHandler(0);
221        }
222    }
223    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0)
224    {
225      setExternalSchemaLocation((XMLCh*)value);
226    }
227    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0)
228    {
229      setExternalNoNamespaceSchemaLocation((XMLCh*)value);
230    }
231    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSecurityManager) == 0)
232    {
233      setSecurityManager((SecurityManager*)value);
234    }
235    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesScannerName) == 0)
236    {
237        AbstractDOMParser::useScanner((const XMLCh*) value);
238    }
239    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesParserUseDocumentFromImplementation) == 0)
240    {
241        useImplementation((const XMLCh*) value);
242    }
243    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLowWaterMark) == 0)
244    {
245        setLowWaterMark(*(const XMLSize_t*)value);
246    }
247    else
248        throw DOMException(DOMException::NOT_FOUND_ERR, 0, getMemoryManager());
249}
250
251void DOMLSParserImpl::setParameter(const XMLCh* name, bool state)
252{
253    if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCharsetOverridesXMLEncoding) == 0)
254    {
255        // in fact, setting this has no effect to the parser
256        fCharsetOverridesXMLEncoding = state;
257    }
258    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMDisallowDoctype) == 0)
259    {
260        // TODO
261    }
262    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMIgnoreUnknownCharacterDenormalization) == 0)
263    {
264        // TODO
265    }
266    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNamespaces) == 0)
267    {
268        setDoNamespaces(state);
269    }
270    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSupportedMediatypesOnly) == 0)
271    {
272        if (state)
273            throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0, getMemoryManager());
274    }
275    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMValidate) == 0)
276    {
277        if (state) {
278            if (getValidationScheme() == AbstractDOMParser::Val_Never)
279                setValidationScheme(AbstractDOMParser::Val_Always);
280        }
281        else {
282            setValidationScheme(AbstractDOMParser::Val_Never);
283        }
284    }
285    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMValidateIfSchema) == 0)
286    {
287        if (state) {
288            setValidationScheme(AbstractDOMParser::Val_Auto);
289        }
290        else {
291            setValidationScheme(AbstractDOMParser::Val_Never);
292        }
293    }
294    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMWellFormed) == 0)
295    {
296        if(state==false)
297            throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0, getMemoryManager());
298    }
299    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCanonicalForm) == 0 )
300    {
301        // TODO
302    }
303    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCDATASections) == 0 )
304    {
305        // TODO
306    }
307    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCheckCharacterNormalization) == 0 )
308    {
309        // TODO
310    }
311    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMComments) == 0)
312    {
313        setCreateCommentNodes(state);
314    }
315    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMDatatypeNormalization) == 0)
316    {
317        getScanner()->setNormalizeData(state);
318    }
319    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMElementContentWhitespace) == 0)
320    {
321        setIncludeIgnorableWhitespace(state);
322    }
323    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMEntities) == 0)
324    {
325        setCreateEntityReferenceNodes(state);
326    }
327    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNamespaceDeclarations) == 0)
328    {
329        if (state==false)
330            throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0, getMemoryManager());
331    }
332    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNormalizeCharacters) == 0)
333    {
334        // TODO
335    }
336    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSplitCDATASections) == 0)
337    {
338        // TODO
339    }
340    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMInfoset) == 0)
341    {
342        if (!state)
343            throw DOMException(DOMException::NOT_SUPPORTED_ERR, 0, getMemoryManager());
344    }
345    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchema) == 0)
346    {
347        setDoSchema(state);
348    }
349    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaFullChecking) == 0)
350    {
351        setValidationSchemaFullChecking(state);
352    }
353    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesUserAdoptsDOMDocument) == 0)
354    {
355        if(state)
356            fUserAdoptsDocument = true;
357        else
358            fUserAdoptsDocument = false;
359    }
360    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadExternalDTD) == 0)
361    {
362        setLoadExternalDTD(state);
363    }
364    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadSchema) == 0)
365    {
366        setLoadSchema(state);
367    }
368    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesContinueAfterFatalError) == 0)
369    {
370        setExitOnFirstFatalError(!state);
371    }
372    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidationErrorAsFatal) == 0)
373    {
374        setValidationConstraintFatal(state);
375    }
376    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCacheGrammarFromParse) == 0)
377    {
378        getScanner()->cacheGrammarFromParse(state);
379
380        if (state)
381            getScanner()->useCachedGrammarInParse(state);
382    }
383    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)
384    {
385        if (state || !getScanner()->isCachingGrammarFromParse())
386            getScanner()->useCachedGrammarInParse(state);
387    }
388    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCalculateSrcOfs) == 0)
389    {
390        getScanner()->setCalculateSrcOfs(state);
391    }
392    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesStandardUriConformant) == 0)
393    {
394        getScanner()->setStandardUriConformant(state);
395    }
396    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDOMHasPSVIInfo) == 0)
397    {
398        setCreateSchemaInfo(state);
399    }
400    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesGenerateSyntheticAnnotations) == 0)
401    {
402        getScanner()->setGenerateSyntheticAnnotations(state);
403    }
404    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidateAnnotations) == 0)
405    {
406        getScanner()->setValidateAnnotations(state);
407    }
408    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIdentityConstraintChecking) == 0)
409    {
410        getScanner()->setIdentityConstraintChecking(state);
411    }
412    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreCachedDTD) == 0)
413    {
414        getScanner()->setIgnoredCachedDTD(state);
415    }
416    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreAnnotations) == 0)
417    {
418        getScanner()->setIgnoreAnnotations(state);
419    }
420    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDisableDefaultEntityResolution) == 0)
421    {
422        getScanner()->setDisableDefaultEntityResolution(state);
423    }
424    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSkipDTDValidation) == 0)
425    {
426        getScanner()->setSkipDTDValidation(state);
427    }
428    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDoXInclude) == 0)
429    {
430        setDoXInclude(state);
431    }
432    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesHandleMultipleImports) == 0)
433    {
434        getScanner()->setHandleMultipleImports(state);
435    }
436    else
437        throw DOMException(DOMException::NOT_FOUND_ERR, 0, getMemoryManager());
438}
439
440const void* DOMLSParserImpl::getParameter(const XMLCh* name) const
441{
442    if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCharsetOverridesXMLEncoding) == 0)
443    {
444        return (void*)fCharsetOverridesXMLEncoding;
445    }
446    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMDisallowDoctype) == 0)
447    {
448        // TODO
449        return 0;
450    }
451    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMIgnoreUnknownCharacterDenormalization) == 0)
452    {
453        // TODO
454        return 0;
455    }
456    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNamespaces) == 0)
457    {
458        return (void*)getDoNamespaces();
459    }
460    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMResourceResolver) == 0)
461    {
462        return fEntityResolver;
463    }
464    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSupportedMediatypesOnly) == 0)
465    {
466        return (void*)false;
467    }
468    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMValidate) == 0)
469    {
470        return (void*)(getValidationScheme() != AbstractDOMParser::Val_Never);
471    }
472    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMValidateIfSchema) == 0)
473    {
474        return (void*)(getValidationScheme() == AbstractDOMParser::Val_Auto);
475    }
476    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMWellFormed) == 0)
477    {
478        return (void*)true;
479    }
480    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCanonicalForm) == 0 )
481    {
482        // TODO
483        return 0;
484    }
485    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCDATASections) == 0 )
486    {
487        // TODO
488        return 0;
489    }
490    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCheckCharacterNormalization) == 0 )
491    {
492        // TODO
493        return 0;
494    }
495    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMComments) == 0)
496    {
497        return (void*)getCreateCommentNodes();
498    }
499    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMDatatypeNormalization) == 0)
500    {
501        return (void*)getScanner()->getNormalizeData();
502    }
503    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMElementContentWhitespace) == 0)
504    {
505        return (void*)getIncludeIgnorableWhitespace();
506    }
507    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMEntities) == 0)
508    {
509        return (void*)getCreateEntityReferenceNodes();
510    }
511    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMErrorHandler) == 0)
512    {
513        return fErrorHandler;
514    }
515    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNamespaceDeclarations) == 0)
516    {
517        return (void*)true;
518    }
519    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMNormalizeCharacters) == 0)
520    {
521        return 0;
522    }
523    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaLocation) == 0)
524    {
525        return 0;
526    }
527    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaType) == 0)
528    {
529        return 0;
530    }
531    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMSplitCDATASections) == 0)
532    {
533        return 0;
534    }
535    else if (XMLString::compareIStringASCII(name, XMLUni::fgDOMInfoset) == 0)
536    {
537        return (void*)true;
538    }
539    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchema) == 0)
540    {
541        return (void*)getDoSchema();
542    }
543    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaFullChecking) == 0)
544    {
545        return (void*)getValidationSchemaFullChecking();
546    }
547    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIdentityConstraintChecking) == 0)
548    {
549        return (void*)getIdentityConstraintChecking();
550    }
551    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadExternalDTD) == 0)
552    {
553        return (void*)getLoadExternalDTD();
554    }
555    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadSchema) == 0)
556    {
557        return (void*)getLoadSchema();
558    }
559    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesContinueAfterFatalError) == 0)
560    {
561        return (void*)!getExitOnFirstFatalError();
562    }
563    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidationErrorAsFatal) == 0)
564    {
565        return (void*)getValidationConstraintFatal();
566    }
567    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCacheGrammarFromParse) == 0)
568    {
569        return (void*)getScanner()->isCachingGrammarFromParse();
570    }
571    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0)
572    {
573        return (void*)getScanner()->isUsingCachedGrammarInParse();
574    }
575    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesCalculateSrcOfs) == 0)
576    {
577        return (void*)getScanner()->getCalculateSrcOfs();
578    }
579    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesStandardUriConformant) == 0)
580    {
581        return (void*)getScanner()->getStandardUriConformant();
582    }
583    else if(XMLString::compareIStringASCII(name, XMLUni::fgXercesUserAdoptsDOMDocument) == 0)
584    {
585        return (void*)fUserAdoptsDocument;
586    }
587    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDOMHasPSVIInfo) == 0)
588    {
589        return (void*)getCreateSchemaInfo();
590    }
591    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesGenerateSyntheticAnnotations) == 0)
592    {
593        return (void*)getScanner()->getGenerateSyntheticAnnotations();
594    }
595    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesValidateAnnotations) == 0)
596    {
597        return (void*)getScanner()->getValidateAnnotations();
598    }
599    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreCachedDTD) == 0)
600    {
601        return (void*)getScanner()->getIgnoreCachedDTD();
602    }
603    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreAnnotations) == 0)
604    {
605        return (void*)getScanner()->getIgnoreAnnotations();
606    }
607    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDisableDefaultEntityResolution) == 0)
608    {
609        return (void*)getScanner()->getDisableDefaultEntityResolution();
610    }
611    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSkipDTDValidation) == 0)
612    {
613        return (void*)getScanner()->getSkipDTDValidation();
614    }
615    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesHandleMultipleImports) == 0)
616    {
617        return (void*)getScanner()->getHandleMultipleImports();
618    }
619    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesEntityResolver) == 0)
620    {
621        return fXMLEntityResolver;
622    }
623    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0)
624    {
625        return getExternalSchemaLocation();
626    }
627    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0)
628    {
629        return getExternalNoNamespaceSchemaLocation();
630    }
631    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesSecurityManager) == 0)
632    {
633        return getSecurityManager();
634    }
635    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesDoXInclude) == 0)
636    {
637        return (void *)getDoXInclude();
638    }
639    else if (XMLString::compareIStringASCII(name, XMLUni::fgXercesLowWaterMark) == 0)
640    {
641      return (void*)&getLowWaterMark();
642    }
643    else
644        throw DOMException(DOMException::NOT_FOUND_ERR, 0, getMemoryManager());
645}
646
647bool DOMLSParserImpl::canSetParameter(const XMLCh* name, const void* /*value*/) const
648{
649    if (XMLString::compareIStringASCII(name, XMLUni::fgDOMResourceResolver) == 0 ||
650        XMLString::compareIStringASCII(name, XMLUni::fgDOMErrorHandler) == 0 ||
651        XMLString::compareIStringASCII(name, XMLUni::fgXercesEntityResolver) == 0 ||
652        XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalSchemaLocation) == 0 ||
653        XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaExternalNoNameSpaceSchemaLocation) == 0 ||
654        XMLString::compareIStringASCII(name, XMLUni::fgXercesSecurityManager) == 0 ||
655        XMLString::compareIStringASCII(name, XMLUni::fgXercesScannerName) == 0 ||
656        XMLString::compareIStringASCII(name, XMLUni::fgXercesParserUseDocumentFromImplementation) == 0 ||
657        XMLString::compareIStringASCII(name, XMLUni::fgXercesLowWaterMark) == 0)
658      return true;
659    else if(XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaLocation) == 0 ||
660            XMLString::compareIStringASCII(name, XMLUni::fgDOMSchemaType) == 0)
661      return false;
662
663    return false;
664}
665
666bool DOMLSParserImpl::canSetParameter(const XMLCh* name, bool value) const
667{
668    if (XMLString::compareIStringASCII(name, XMLUni::fgDOMCharsetOverridesXMLEncoding) == 0 ||
669        XMLString::compareIStringASCII(name, XMLUni::fgDOMNamespaces) == 0 ||
670        XMLString::compareIStringASCII(name, XMLUni::fgDOMValidate) == 0 ||
671        XMLString::compareIStringASCII(name, XMLUni::fgDOMValidateIfSchema) == 0 ||
672        XMLString::compareIStringASCII(name, XMLUni::fgDOMComments) == 0 ||
673        XMLString::compareIStringASCII(name, XMLUni::fgDOMDatatypeNormalization) == 0 ||
674        XMLString::compareIStringASCII(name, XMLUni::fgDOMElementContentWhitespace) == 0 ||
675        XMLString::compareIStringASCII(name, XMLUni::fgDOMEntities) == 0 ||
676        XMLString::compareIStringASCII(name, XMLUni::fgXercesSchema) == 0 ||
677        XMLString::compareIStringASCII(name, XMLUni::fgXercesSchemaFullChecking) == 0 ||
678        XMLString::compareIStringASCII(name, XMLUni::fgXercesIdentityConstraintChecking) == 0 ||
679        XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadExternalDTD) == 0 ||
680        XMLString::compareIStringASCII(name, XMLUni::fgXercesLoadSchema) == 0 ||
681        XMLString::compareIStringASCII(name, XMLUni::fgXercesContinueAfterFatalError) == 0 ||
682        XMLString::compareIStringASCII(name, XMLUni::fgXercesValidationErrorAsFatal) == 0 ||
683        XMLString::compareIStringASCII(name, XMLUni::fgXercesCacheGrammarFromParse) == 0 ||
684        XMLString::compareIStringASCII(name, XMLUni::fgXercesUseCachedGrammarInParse) == 0 ||
685        XMLString::compareIStringASCII(name, XMLUni::fgXercesCalculateSrcOfs) == 0 ||
686        XMLString::compareIStringASCII(name, XMLUni::fgXercesStandardUriConformant) == 0 ||
687        XMLString::compareIStringASCII(name, XMLUni::fgXercesUserAdoptsDOMDocument) == 0 ||
688        XMLString::compareIStringASCII(name, XMLUni::fgXercesDOMHasPSVIInfo) == 0 ||
689        XMLString::compareIStringASCII(name, XMLUni::fgXercesGenerateSyntheticAnnotations) == 0 ||
690        XMLString::compareIStringASCII(name, XMLUni::fgXercesValidateAnnotations) == 0 ||
691        XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreCachedDTD) == 0 ||
692        XMLString::compareIStringASCII(name, XMLUni::fgXercesIgnoreAnnotations) == 0 ||
693        XMLString::compareIStringASCII(name, XMLUni::fgXercesDisableDefaultEntityResolution) == 0 ||
694        XMLString::compareIStringASCII(name, XMLUni::fgXercesSkipDTDValidation) == 0 ||
695                XMLString::compareIStringASCII(name, XMLUni::fgXercesDoXInclude) == 0 ||
696        XMLString::compareIStringASCII(name, XMLUni::fgXercesHandleMultipleImports) == 0)
697      return true;
698    else if(XMLString::compareIStringASCII(name, XMLUni::fgDOMDisallowDoctype) == 0 ||
699            XMLString::compareIStringASCII(name, XMLUni::fgDOMIgnoreUnknownCharacterDenormalization) == 0 ||
700            XMLString::compareIStringASCII(name, XMLUni::fgDOMCanonicalForm) == 0 ||
701            XMLString::compareIStringASCII(name, XMLUni::fgDOMCDATASections) == 0 ||
702            XMLString::compareIStringASCII(name, XMLUni::fgDOMCheckCharacterNormalization) == 0 ||
703            XMLString::compareIStringASCII(name, XMLUni::fgDOMNormalizeCharacters) == 0 ||
704            XMLString::compareIStringASCII(name, XMLUni::fgDOMSplitCDATASections) == 0)
705      return false;
706    else if(XMLString::compareIStringASCII(name, XMLUni::fgDOMSupportedMediatypesOnly) == 0)
707      return value?false:true;
708    else if(XMLString::compareIStringASCII(name, XMLUni::fgDOMWellFormed) == 0 ||
709            XMLString::compareIStringASCII(name, XMLUni::fgDOMNamespaceDeclarations) == 0 ||
710            XMLString::compareIStringASCII(name, XMLUni::fgDOMInfoset) == 0)
711      return value?true:false;
712
713    return false;
714}
715
716const DOMStringList* DOMLSParserImpl::getParameterNames() const
717{
718    return fSupportedParameters;
719}
720
721// ---------------------------------------------------------------------------
722//  DOMLSParserImpl: Feature methods
723// ---------------------------------------------------------------------------
724void DOMLSParserImpl::release()
725{
726    DOMLSParserImpl* builder = (DOMLSParserImpl*) this;
727    delete builder;
728}
729
730void DOMLSParserImpl::resetDocumentPool()
731{
732    resetPool();
733}
734
735
736// ---------------------------------------------------------------------------
737//  DOMLSParserImpl: Parsing methods
738// ---------------------------------------------------------------------------
739DOMDocument* DOMLSParserImpl::parse(const DOMLSInput* source)
740{
741    if (getParseInProgress())
742        throw DOMException(DOMException::INVALID_STATE_ERR, XMLDOMMsg::LSParser_ParseInProgress, fMemoryManager);
743
744    // remove the abort filter, if present
745    if(fFilter==&g_AbortFilter)
746        fFilter=0;
747    if(fFilterAction)
748        fFilterAction->removeAll();
749    if(fFilterDelayedTextNodes)
750        fFilterDelayedTextNodes->removeAll();
751
752    Wrapper4DOMLSInput isWrapper((DOMLSInput*)source, fEntityResolver, false, getMemoryManager());
753
754    AbstractDOMParser::parse(isWrapper);
755
756    // Disabled until 4.0.0. See XERCESC-1894 for details.
757    //if(getErrorCount()!=0)
758    //    throw DOMLSException(DOMLSException::PARSE_ERR, XMLDOMMsg::LSParser_ParsingFailed, fMemoryManager);
759
760    if (fUserAdoptsDocument)
761        return adoptDocument();
762    else
763        return getDocument();
764}
765
766DOMDocument* DOMLSParserImpl::parseURI(const XMLCh* const systemId)
767{
768    if (getParseInProgress())
769        throw DOMException(DOMException::INVALID_STATE_ERR, XMLDOMMsg::LSParser_ParseInProgress, fMemoryManager);
770
771    // remove the abort filter, if present
772    if(fFilter==&g_AbortFilter)
773        fFilter=0;
774    if(fFilterAction)
775        fFilterAction->removeAll();
776    if(fFilterDelayedTextNodes)
777        fFilterDelayedTextNodes->removeAll();
778
779    AbstractDOMParser::parse(systemId);
780
781    // Disabled until 4.0.0. See XERCESC-1894 for details.
782    //if(getErrorCount()!=0)
783    //    throw DOMLSException(DOMLSException::PARSE_ERR, XMLDOMMsg::LSParser_ParsingFailed, fMemoryManager);
784
785    if (fUserAdoptsDocument)
786        return adoptDocument();
787    else
788        return getDocument();
789}
790
791DOMDocument* DOMLSParserImpl::parseURI(const char* const systemId)
792{
793    if (getParseInProgress())
794        throw DOMException(DOMException::INVALID_STATE_ERR, XMLDOMMsg::LSParser_ParseInProgress, fMemoryManager);
795
796    // remove the abort filter, if present
797    if(fFilter==&g_AbortFilter)
798        fFilter=0;
799    if(fFilterAction)
800        fFilterAction->removeAll();
801    if(fFilterDelayedTextNodes)
802        fFilterDelayedTextNodes->removeAll();
803
804    AbstractDOMParser::parse(systemId);
805
806    // Disabled until 4.0.0. See XERCESC-1894 for details.
807    //if(getErrorCount()!=0)
808    //    throw DOMLSException(DOMLSException::PARSE_ERR, XMLDOMMsg::LSParser_ParsingFailed, fMemoryManager);
809
810    if (fUserAdoptsDocument)
811        return adoptDocument();
812    else
813        return getDocument();
814}
815
816void DOMLSParserImpl::startDocument()
817{
818    if(fWrapNodesInDocumentFragment)
819    {
820        fDocument = (DOMDocumentImpl*)fWrapNodesInDocumentFragment->getOwnerDocument();
821        fCurrentParent = fCurrentNode = fWrapNodesInDocumentFragment;
822        // set DOM error checking off
823        fDocument->setErrorChecking(false);
824
825        // if we have namespaces in scope, push them down to the reader
826        ValueHashTableOf<unsigned int> inScopeNS(7, fMemoryManager);
827        DOMNode* cursor = fWrapNodesContext;
828        while(cursor)
829        {
830            if(cursor->getNodeType()==DOMNode::ELEMENT_NODE)
831            {
832                DOMNamedNodeMap* attrs = cursor->getAttributes();
833                for(XMLSize_t i=0; i<attrs->getLength(); i++)
834                {
835                    DOMNode* attr = attrs->item(i);
836                    if(XMLString::equals(attr->getNamespaceURI(), XMLUni::fgXMLNSURIName) && !inScopeNS.containsKey(attr->getLocalName()))
837                        inScopeNS.put((void*)attr->getLocalName(), fScanner->getURIStringPool()->addOrFind(attr->getNodeValue()));
838                    else if(XMLString::equals(attr->getNodeName(), XMLUni::fgXMLNSString) && !inScopeNS.containsKey(XMLUni::fgZeroLenString))
839                        inScopeNS.put((void*)XMLUni::fgZeroLenString, fScanner->getURIStringPool()->addOrFind(attr->getNodeValue()));
840                }
841            }
842            cursor = cursor->getParentNode();
843        }
844        ValueHashTableOfEnumerator<unsigned int> iter(&inScopeNS, false, fMemoryManager);
845        while(iter.hasMoreElements())
846        {
847            XMLCh* prefix = (XMLCh*)iter.nextElementKey();
848            fScanner->addGlobalPrefix(prefix, inScopeNS.get(prefix));
849        }
850
851        // in this case the document URI and the input encoding must be propagated to the context document
852        if(fWrapNodesAction==ACTION_REPLACE_CHILDREN && fWrapNodesContext->getNodeType()==DOMNode::DOCUMENT_NODE)
853        {
854            fDocument->setDocumentURI(fScanner->getLocator()->getSystemId());
855            fDocument->setInputEncoding(fScanner->getReaderMgr()->getCurrentEncodingStr());
856        }
857    }
858    else
859        AbstractDOMParser::startDocument();
860}
861
862void DOMLSParserImpl::XMLDecl(  const XMLCh* const    versionStr
863                              , const XMLCh* const    encodingStr
864                              , const XMLCh* const    standaloneStr
865                              , const XMLCh* const    actualEncStr
866                             )
867{
868    if(fWrapNodesInDocumentFragment && !(fWrapNodesAction==ACTION_REPLACE_CHILDREN && fWrapNodesContext->getNodeType()==DOMNode::DOCUMENT_NODE))
869    {
870        // don't change the properties for the context document, unless the context node is a
871        // DOMDocument node and the action is ACTION_REPLACE_CHILDREN
872    }
873    else
874        AbstractDOMParser::XMLDecl(versionStr, encodingStr, standaloneStr, actualEncStr);
875}
876
877DOMNode* DOMLSParserImpl::parseWithContext(const DOMLSInput* source,
878                                           DOMNode* contextNode,
879                                           const ActionType action)
880{
881    if (getParseInProgress())
882        throw DOMException(DOMException::INVALID_STATE_ERR, XMLDOMMsg::LSParser_ParseInProgress, fMemoryManager);
883
884    // remove the abort filter, if present
885    if(fFilter==&g_AbortFilter)
886        fFilter=0;
887    if(fFilterAction)
888        fFilterAction->removeAll();
889    if(fFilterDelayedTextNodes)
890        fFilterDelayedTextNodes->removeAll();
891
892    DOMDocumentFragment* holder = contextNode->getOwnerDocument()->createDocumentFragment();
893    // When parsing the input stream, the context node (or its parent, depending on where
894    // the result will be inserted) is used for resolving unbound namespace prefixes
895    if(action==ACTION_INSERT_BEFORE || action==ACTION_INSERT_AFTER || action==ACTION_REPLACE)
896        fWrapNodesContext = contextNode->getParentNode();
897    else
898        fWrapNodesContext = contextNode;
899    fWrapNodesInDocumentFragment = holder;
900    fWrapNodesAction = action;
901    // When calling parseWithContext, the values of the following configuration parameters
902    // will be ignored and their default values will always be used instead: "validate",
903    // "validate-if-schema", and "element-content-whitespace".
904    ValSchemes oldValidate = getValidationScheme();
905    setValidationScheme(Val_Never);
906    bool oldElementContentWhitespace = getIncludeIgnorableWhitespace();
907    setIncludeIgnorableWhitespace(true);
908
909    Wrapper4DOMLSInput isWrapper((DOMLSInput*)source, fEntityResolver, false, getMemoryManager());
910    AbstractDOMParser::parse(isWrapper);
911
912    setValidationScheme(oldValidate);
913    setIncludeIgnorableWhitespace(oldElementContentWhitespace);
914    fWrapNodesContext = NULL;
915    fWrapNodesInDocumentFragment = NULL;
916    fDocument = NULL;
917
918    if(getErrorCount()!=0)
919    {
920        holder->release();
921        throw DOMLSException(DOMLSException::PARSE_ERR, XMLDOMMsg::LSParser_ParsingFailed, fMemoryManager);
922    }
923
924    DOMNode* result = holder->getFirstChild();
925    DOMNode* node, *parent = contextNode->getParentNode();
926    switch(action)
927    {
928    case ACTION_REPLACE_CHILDREN:
929        // remove existing children
930        while((node = contextNode->getFirstChild())!=NULL)
931            contextNode->removeChild(node)->release();
932        // then fall back to behave like an append
933    case ACTION_APPEND_AS_CHILDREN:
934        while((node = holder->getFirstChild())!=NULL)
935            contextNode->appendChild(holder->removeChild(node));
936        break;
937    case ACTION_INSERT_BEFORE:
938        while((node = holder->getFirstChild())!=NULL)
939            parent->insertBefore(holder->removeChild(node), contextNode);
940        break;
941    case ACTION_INSERT_AFTER:
942        while((node = holder->getLastChild())!=NULL)
943            parent->insertBefore(holder->removeChild(node), contextNode->getNextSibling());
944        break;
945    case ACTION_REPLACE:
946        while((node = holder->getFirstChild())!=NULL)
947            parent->insertBefore(holder->removeChild(node), contextNode);
948        parent->removeChild(contextNode)->release();
949        break;
950    }
951    holder->release();
952
953    // TODO whenever we add support for DOM Mutation Events:
954    //   As the new data is inserted into the document, at least one mutation event is fired
955    //   per new immediate child or sibling of the context node.
956    return result;
957}
958
959void DOMLSParserImpl::abort()
960{
961    fFilter=&g_AbortFilter;
962}
963
964// ---------------------------------------------------------------------------
965//  DOMLSParserImpl: Implementation of the XMLErrorReporter interface
966// ---------------------------------------------------------------------------
967void DOMLSParserImpl::error( const   unsigned int                code
968                            , const XMLCh* const
969                            , const XMLErrorReporter::ErrTypes  errType
970                            , const XMLCh* const                errorText
971                            , const XMLCh* const                systemId
972                            , const XMLCh* const
973                            , const XMLFileLoc                  lineNum
974                            , const XMLFileLoc                  colNum)
975{
976    if (fErrorHandler) {
977
978        DOMError::ErrorSeverity severity = DOMError::DOM_SEVERITY_ERROR;
979
980        if (errType == XMLErrorReporter::ErrType_Warning)
981            severity = DOMError::DOM_SEVERITY_WARNING;
982        else if (errType == XMLErrorReporter::ErrType_Fatal)
983            severity = DOMError::DOM_SEVERITY_FATAL_ERROR;
984
985        DOMLocatorImpl location(lineNum, colNum, getCurrentNode(), systemId);
986        if(getScanner()->getCalculateSrcOfs())
987            location.setByteOffset(getScanner()->getSrcOffset());
988        DOMErrorImpl domError(severity, errorText, &location);
989
990        // if user return false, we should stop the process, so throw an error
991        bool toContinueProcess = true;
992        try
993        {
994            toContinueProcess = fErrorHandler->handleError(domError);
995        }
996        catch(...)
997        {
998        }
999        if (!toContinueProcess && !getScanner()->getInException())
1000            throw (XMLErrs::Codes) code;
1001    }
1002}
1003
1004void DOMLSParserImpl::resetErrors()
1005{
1006}
1007
1008
1009// ---------------------------------------------------------------------------
1010//  DOMLSParserImpl: Implementation of XMLEntityHandler interface
1011// ---------------------------------------------------------------------------
1012InputSource*
1013DOMLSParserImpl::resolveEntity( XMLResourceIdentifier* resourceIdentifier )
1014{
1015    //
1016    //  Just map it to the SAX entity resolver. If there is not one installed,
1017    //  return a null pointer to cause the default resolution.
1018    //
1019    if (fEntityResolver) {
1020        DOMLSInput* is = fEntityResolver->resolveResource(resourceIdentifier->getResourceIdentifierType()==XMLResourceIdentifier::ExternalEntity?XMLUni::fgDOMDTDType:XMLUni::fgDOMXMLSchemaType,
1021                                                          resourceIdentifier->getNameSpace(),
1022                                                          resourceIdentifier->getPublicId(),
1023                                                          resourceIdentifier->getSystemId(),
1024                                                          resourceIdentifier->getBaseURI());
1025        if (is)
1026            return new (getMemoryManager()) Wrapper4DOMLSInput(is, fEntityResolver, true, getMemoryManager());
1027    }
1028    if (fXMLEntityResolver) {
1029        return(fXMLEntityResolver->resolveEntity(resourceIdentifier));
1030    }
1031
1032    return 0;
1033}
1034
1035typedef JanitorMemFunCall<DOMLSParserImpl>    ResetParseType;
1036
1037// ---------------------------------------------------------------------------
1038//  DOMLSParserImpl: Grammar preparsing methods
1039// ---------------------------------------------------------------------------
1040Grammar* DOMLSParserImpl::loadGrammar(const char* const systemId,
1041                                     const Grammar::GrammarType grammarType,
1042                                     const bool toCache)
1043{
1044    // Avoid multiple entrance
1045    if (getParseInProgress())
1046        throw DOMException(DOMException::INVALID_STATE_ERR, XMLDOMMsg::LSParser_ParseInProgress, fMemoryManager);
1047
1048    ResetParseType  resetParse(this, &DOMLSParserImpl::resetParse);
1049
1050        Grammar* grammar = 0;
1051
1052    try
1053    {
1054        setParseInProgress(true);
1055        if (grammarType == Grammar::DTDGrammarType)
1056            getScanner()->setDocTypeHandler(0);
1057        grammar = getScanner()->loadGrammar(systemId, grammarType, toCache);
1058    }
1059    catch(const OutOfMemoryException&)
1060    {
1061        resetParse.release();
1062
1063        throw;
1064    }
1065
1066    return grammar;
1067}
1068
1069Grammar* DOMLSParserImpl::loadGrammar(const XMLCh* const systemId,
1070                                     const Grammar::GrammarType grammarType,
1071                                     const bool toCache)
1072{
1073    // Avoid multiple entrance
1074    if (getParseInProgress())
1075        throw DOMException(DOMException::INVALID_STATE_ERR, XMLDOMMsg::LSParser_ParseInProgress, fMemoryManager);
1076
1077    ResetParseType  resetParse(this, &DOMLSParserImpl::resetParse);
1078
1079        Grammar* grammar = 0;
1080
1081    try
1082    {
1083        setParseInProgress(true);
1084        if (grammarType == Grammar::DTDGrammarType)
1085            getScanner()->setDocTypeHandler(0);
1086        grammar = getScanner()->loadGrammar(systemId, grammarType, toCache);
1087    }
1088    catch(const OutOfMemoryException&)
1089    {
1090        resetParse.release();
1091
1092        throw;
1093    }
1094
1095    return grammar;
1096}
1097
1098Grammar* DOMLSParserImpl::loadGrammar(const DOMLSInput* source,
1099                                     const Grammar::GrammarType grammarType,
1100                                     const bool toCache)
1101{
1102    // Avoid multiple entrance
1103    if (getParseInProgress())
1104        throw DOMException(DOMException::INVALID_STATE_ERR, XMLDOMMsg::LSParser_ParseInProgress, fMemoryManager);
1105
1106    ResetParseType  resetParse(this, &DOMLSParserImpl::resetParse);
1107
1108    Grammar* grammar = 0;
1109
1110    try
1111    {
1112        setParseInProgress(true);
1113        if (grammarType == Grammar::DTDGrammarType)
1114            getScanner()->setDocTypeHandler(0);
1115        Wrapper4DOMLSInput isWrapper((DOMLSInput*)source, fEntityResolver, false, getMemoryManager());
1116        grammar = getScanner()->loadGrammar(isWrapper, grammarType, toCache);
1117    }
1118    catch(const OutOfMemoryException&)
1119    {
1120        resetParse.release();
1121
1122        throw;
1123    }
1124
1125    return grammar;
1126}
1127
1128void DOMLSParserImpl::resetCachedGrammarPool()
1129{
1130    getGrammarResolver()->resetCachedGrammar();
1131    getScanner()->resetCachedGrammar();
1132}
1133
1134void DOMLSParserImpl::resetParse()
1135{
1136    if (getScanner()->getDocTypeHandler() == 0)
1137    {
1138        getScanner()->setDocTypeHandler(this);
1139    }
1140
1141    setParseInProgress(false);
1142}
1143
1144Grammar* DOMLSParserImpl::getGrammar(const XMLCh* const nameSpaceKey) const
1145{
1146    return getGrammarResolver()->getGrammar(nameSpaceKey);
1147}
1148
1149Grammar* DOMLSParserImpl::getRootGrammar() const
1150{
1151    return getScanner()->getRootGrammar();
1152}
1153
1154const XMLCh* DOMLSParserImpl::getURIText(unsigned int uriId) const
1155{
1156    return getScanner()->getURIText(uriId);
1157}
1158
1159XMLFilePos DOMLSParserImpl::getSrcOffset() const
1160{
1161    return getScanner()->getSrcOffset();
1162}
1163
1164void DOMLSParserImpl::applyFilter(DOMNode* node)
1165{
1166    DOMLSParserFilter::FilterAction action;
1167    // if the parent was already rejected, reject this too
1168    if(fFilterAction && fFilterAction->containsKey(fCurrentParent) && fFilterAction->get(fCurrentParent)==DOMLSParserFilter::FILTER_REJECT)
1169        action = DOMLSParserFilter::FILTER_REJECT;
1170    else
1171        action = fFilter->acceptNode(node);
1172
1173    switch(action)
1174    {
1175    case DOMLSParserFilter::FILTER_ACCEPT:      break;
1176    case DOMLSParserFilter::FILTER_REJECT:
1177    case DOMLSParserFilter::FILTER_SKIP:        if(node==fCurrentNode)
1178                                                    fCurrentNode = (node->getPreviousSibling()?node->getPreviousSibling():fCurrentParent);
1179                                                fCurrentParent->removeChild(node);
1180                                                node->release();
1181                                                break;
1182    case DOMLSParserFilter::FILTER_INTERRUPT:   throw DOMLSException(DOMLSException::PARSE_ERR, XMLDOMMsg::LSParser_ParsingAborted, fMemoryManager);
1183    }
1184}
1185
1186void DOMLSParserImpl::docCharacters(const XMLCh* const    chars
1187                                  , const XMLSize_t       length
1188                                  , const bool            cdataSection)
1189{
1190    AbstractDOMParser::docCharacters(chars, length, cdataSection);
1191    if(fFilter)
1192    {
1193        // send the notification for the previous text node
1194        if(fFilterDelayedTextNodes && fCurrentNode->getPreviousSibling() && fFilterDelayedTextNodes->containsKey(fCurrentNode->getPreviousSibling()))
1195        {
1196            DOMNode* textNode = fCurrentNode->getPreviousSibling();
1197            fFilterDelayedTextNodes->removeKey(textNode);
1198            applyFilter(textNode);
1199        }
1200        DOMNodeFilter::ShowType whatToShow=fFilter->getWhatToShow();
1201        if(cdataSection && (whatToShow & DOMNodeFilter::SHOW_CDATA_SECTION))
1202        {
1203            applyFilter(fCurrentNode);
1204        }
1205        else if(!cdataSection && (whatToShow & DOMNodeFilter::SHOW_TEXT))
1206        {
1207            if(fFilterDelayedTextNodes==0)
1208                fFilterDelayedTextNodes=new (fMemoryManager) ValueHashTableOf<bool, PtrHasher>(7, fMemoryManager);
1209            fFilterDelayedTextNodes->put(fCurrentNode, true);
1210        }
1211    }
1212}
1213
1214void DOMLSParserImpl::docComment(const XMLCh* const  comment)
1215{
1216    if(fFilter)
1217    {
1218        // send the notification for the previous text node
1219        if(fFilterDelayedTextNodes && fFilterDelayedTextNodes->containsKey(fCurrentNode))
1220        {
1221            fFilterDelayedTextNodes->removeKey(fCurrentNode);
1222            applyFilter(fCurrentNode);
1223        }
1224    }
1225
1226    AbstractDOMParser::docComment(comment);
1227    if(fFilter)
1228    {
1229        DOMNodeFilter::ShowType whatToShow=fFilter->getWhatToShow();
1230        if(whatToShow & DOMNodeFilter::SHOW_COMMENT)
1231            applyFilter(fCurrentNode);
1232    }
1233}
1234
1235void DOMLSParserImpl::docPI(const XMLCh* const    target
1236                          , const XMLCh* const    data)
1237{
1238    if(fFilter)
1239    {
1240        // send the notification for the previous text node
1241        if(fFilterDelayedTextNodes && fFilterDelayedTextNodes->containsKey(fCurrentNode))
1242        {
1243            fFilterDelayedTextNodes->removeKey(fCurrentNode);
1244            applyFilter(fCurrentNode);
1245        }
1246    }
1247
1248    AbstractDOMParser::docPI(target, data);
1249    if(fFilter)
1250    {
1251        DOMNodeFilter::ShowType whatToShow=fFilter->getWhatToShow();
1252        if(whatToShow & DOMNodeFilter::SHOW_PROCESSING_INSTRUCTION)
1253            applyFilter(fCurrentNode);
1254    }
1255}
1256
1257void DOMLSParserImpl::startEntityReference(const XMLEntityDecl& entDecl)
1258{
1259    if(fCreateEntityReferenceNodes && fFilter)
1260    {
1261        // send the notification for the previous text node
1262        if(fFilterDelayedTextNodes && fFilterDelayedTextNodes->containsKey(fCurrentNode))
1263        {
1264            fFilterDelayedTextNodes->removeKey(fCurrentNode);
1265            applyFilter(fCurrentNode);
1266        }
1267    }
1268
1269    DOMNode* origParent = fCurrentParent;
1270    AbstractDOMParser::startEntityReference(entDecl);
1271    if (fCreateEntityReferenceNodes && fFilter)
1272    {
1273        if(fFilterAction && fFilterAction->containsKey(origParent) && fFilterAction->get(origParent)==DOMLSParserFilter::FILTER_REJECT)
1274            fFilterAction->put(fCurrentNode, DOMLSParserFilter::FILTER_REJECT);
1275    }
1276}
1277
1278void DOMLSParserImpl::endElement(const XMLElementDecl& elemDecl
1279                               , const unsigned int    urlId
1280                               , const bool            isRoot
1281                               , const XMLCh* const    elemPrefix)
1282{
1283    if(fFilter)
1284    {
1285        // send the notification for the previous text node
1286        if(fFilterDelayedTextNodes && fFilterDelayedTextNodes->containsKey(fCurrentNode))
1287        {
1288            fFilterDelayedTextNodes->removeKey(fCurrentNode);
1289            applyFilter(fCurrentNode);
1290        }
1291    }
1292
1293    AbstractDOMParser::endElement(elemDecl, urlId, isRoot, elemPrefix);
1294    if(fFilter)
1295    {
1296        DOMNodeFilter::ShowType whatToShow=fFilter->getWhatToShow();
1297        if(whatToShow & DOMNodeFilter::SHOW_ELEMENT)
1298        {
1299            DOMNode* thisNode = fCurrentNode;
1300            DOMLSParserFilter::FilterAction action;
1301            if(fFilterAction && fFilterAction->containsKey(thisNode))
1302            {
1303                action = fFilterAction->get(thisNode);
1304                fFilterAction->removeKey(thisNode);
1305            }
1306            else
1307                action = fFilter->acceptNode(thisNode);
1308            switch(action)
1309            {
1310            case DOMLSParserFilter::FILTER_ACCEPT:      break;
1311            case DOMLSParserFilter::FILTER_REJECT:      fCurrentNode = (thisNode->getPreviousSibling()?thisNode->getPreviousSibling():fCurrentParent);
1312                                                        fCurrentParent->removeChild(thisNode);
1313                                                        thisNode->release();
1314                                                        break;
1315            case DOMLSParserFilter::FILTER_SKIP:        {
1316                                                            DOMNode* child=thisNode->getFirstChild();
1317                                                            while(child)
1318                                                            {
1319                                                                DOMNode* next=child->getNextSibling();
1320                                                                fCurrentParent->appendChild(child);
1321                                                                child=next;
1322                                                            }
1323                                                            fCurrentNode = (thisNode->getPreviousSibling()?thisNode->getPreviousSibling():fCurrentParent);
1324                                                            fCurrentParent->removeChild(thisNode);
1325                                                            thisNode->release();
1326                                                        }
1327                                                        break;
1328            case DOMLSParserFilter::FILTER_INTERRUPT:   throw DOMLSException(DOMLSException::PARSE_ERR, XMLDOMMsg::LSParser_ParsingAborted, fMemoryManager);
1329            }
1330        }
1331    }
1332}
1333
1334void DOMLSParserImpl::startElement(const XMLElementDecl&         elemDecl
1335                                 , const unsigned int            urlId
1336                                 , const XMLCh* const            elemPrefix
1337                                 , const RefVectorOf<XMLAttr>&   attrList
1338                                 , const XMLSize_t               attrCount
1339                                 , const bool                    isEmpty
1340                                 , const bool                    isRoot)
1341{
1342    if(fFilter)
1343    {
1344        // send the notification for the previous text node
1345        if(fFilterDelayedTextNodes && fFilterDelayedTextNodes->containsKey(fCurrentNode))
1346        {
1347            fFilterDelayedTextNodes->removeKey(fCurrentNode);
1348            applyFilter(fCurrentNode);
1349        }
1350    }
1351
1352    DOMNode* origParent = fCurrentParent;
1353    AbstractDOMParser::startElement(elemDecl, urlId, elemPrefix, attrList, attrCount, false, isRoot);
1354    if(fFilter)
1355    {
1356        // if the parent was already rejected, reject this too
1357        if(fFilterAction && fFilterAction->containsKey(origParent) && fFilterAction->get(origParent)==DOMLSParserFilter::FILTER_REJECT)
1358            fFilterAction->put(fCurrentNode, DOMLSParserFilter::FILTER_REJECT);
1359        else
1360        {
1361            DOMLSParserFilter::FilterAction action = fFilter->startElement((DOMElement*)fCurrentNode);
1362
1363            switch(action)
1364            {
1365            case DOMLSParserFilter::FILTER_ACCEPT:      break;
1366            case DOMLSParserFilter::FILTER_REJECT:
1367            case DOMLSParserFilter::FILTER_SKIP:        if(fFilterAction==0)
1368                                                            fFilterAction=new (fMemoryManager) ValueHashTableOf<DOMLSParserFilter::FilterAction, PtrHasher>(7, fMemoryManager);
1369                                                        fFilterAction->put(fCurrentNode, action);
1370                                                        break;
1371            case DOMLSParserFilter::FILTER_INTERRUPT:   throw DOMLSException(DOMLSException::PARSE_ERR, XMLDOMMsg::LSParser_ParsingAborted, fMemoryManager);
1372            }
1373        }
1374    }
1375    if(isEmpty)
1376        endElement(elemDecl, urlId, isRoot, elemPrefix);
1377}
1378
1379XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.