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