1 /*
2 * Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
3 */
4 /*
5 * Licensed to the Apache Software Foundation (ASF) under one or more
6 * contributor license agreements. See the NOTICE file distributed with
7 * this work for additional information regarding copyright ownership.
8 * The ASF licenses this file to You under the Apache License, Version 2.0
9 * (the "License"); you may not use this file except in compliance with
10 * the License. You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21 package com.sun.org.apache.xerces.internal.impl.xs;
22
23 import com.sun.org.apache.xerces.internal.dom.DOMErrorImpl;
24 import com.sun.org.apache.xerces.internal.dom.DOMMessageFormatter;
25 import com.sun.org.apache.xerces.internal.dom.DOMStringListImpl;
26 import com.sun.org.apache.xerces.internal.impl.Constants;
27 import com.sun.org.apache.xerces.internal.impl.XMLEntityManager;
28 import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;
29 import com.sun.org.apache.xerces.internal.impl.dv.InvalidDatatypeValueException;
30 import com.sun.org.apache.xerces.internal.impl.dv.SchemaDVFactory;
31 import com.sun.org.apache.xerces.internal.impl.dv.xs.SchemaDVFactoryImpl;
32 import com.sun.org.apache.xerces.internal.impl.xs.models.CMBuilder;
33 import com.sun.org.apache.xerces.internal.impl.xs.models.CMNodeFactory;
34 import com.sun.org.apache.xerces.internal.impl.xs.traversers.XSDHandler;
35 import com.sun.org.apache.xerces.internal.util.DOMEntityResolverWrapper;
36 import com.sun.org.apache.xerces.internal.util.DOMErrorHandlerWrapper;
37 import com.sun.org.apache.xerces.internal.util.DefaultErrorHandler;
38 import com.sun.org.apache.xerces.internal.util.MessageFormatter;
39 import com.sun.org.apache.xerces.internal.util.ParserConfigurationSettings;
40 import com.sun.org.apache.xerces.internal.util.Status;
41 import com.sun.org.apache.xerces.internal.util.SymbolTable;
42 import com.sun.org.apache.xerces.internal.util.URI.MalformedURIException;
43 import com.sun.org.apache.xerces.internal.util.XMLSymbols;
44 import com.sun.org.apache.xerces.internal.utils.XMLSecurityManager;
45 import com.sun.org.apache.xerces.internal.utils.XMLSecurityPropertyManager;
46 import com.sun.org.apache.xerces.internal.xni.QName;
47 import com.sun.org.apache.xerces.internal.xni.XNIException;
48 import com.sun.org.apache.xerces.internal.xni.grammars.Grammar;
49 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;
50 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarLoader;
51 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarPool;
52 import com.sun.org.apache.xerces.internal.xni.grammars.XSGrammar;
53 import com.sun.org.apache.xerces.internal.xni.parser.XMLComponent;
54 import com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager;
55 import com.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;
56 import com.sun.org.apache.xerces.internal.xni.parser.XMLEntityResolver;
57 import com.sun.org.apache.xerces.internal.xni.parser.XMLErrorHandler;
58 import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;
59 import com.sun.org.apache.xerces.internal.xs.LSInputList;
60 import com.sun.org.apache.xerces.internal.xs.StringList;
61 import com.sun.org.apache.xerces.internal.xs.XSLoader;
62 import com.sun.org.apache.xerces.internal.xs.XSModel;
63 import java.io.BufferedInputStream;
64 import java.io.File;
65 import java.io.FileInputStream;
66 import java.io.FileNotFoundException;
67 import java.io.IOException;
68 import java.io.InputStream;
69 import java.io.Reader;
70 import java.io.StringReader;
71 import java.util.ArrayList;
72 import java.util.HashMap;
73 import java.util.Locale;
74 import java.util.Map;
75 import java.util.StringTokenizer;
76 import java.util.WeakHashMap;
77 import javax.xml.XMLConstants;
78 import jdk.xml.internal.JdkXmlUtils;
79 import jdk.xml.internal.SecuritySupport;
80 import org.w3c.dom.DOMConfiguration;
81 import org.w3c.dom.DOMError;
82 import org.w3c.dom.DOMErrorHandler;
83 import org.w3c.dom.DOMException;
84 import org.w3c.dom.DOMStringList;
85 import org.w3c.dom.ls.LSInput;
86 import org.w3c.dom.ls.LSResourceResolver;
87 import org.xml.sax.InputSource;
88
89 /**
90 * This class implements xni.grammars.XMLGrammarLoader.
91 * It also serves as implementation of xs.XSLoader interface and DOMConfiguration interface.
92 *
93 * This class is designed to interact either with a proxy for a user application
94 * which wants to preparse schemas, or with our own Schema validator.
95 * It is hoped that none of these "external" classes will therefore need to communicate directly
96 * with XSDHandler in future.
97 * <p>This class only knows how to make XSDHandler do its thing.
98 * The caller must ensure that all its properties (schemaLocation, JAXPSchemaSource
99 * etc.) have been properly set.
100 *
101 * @xerces.internal
102 *
103 * @author Neil Graham, IBM
104 * @LastModified: Sep 2017
105 */
106
107 public class XMLSchemaLoader implements XMLGrammarLoader, XMLComponent, XSElementDeclHelper,
108 // XML Component API
109 XSLoader, DOMConfiguration {
110
111 // Feature identifiers:
112
113 /** Feature identifier: schema full checking*/
114 protected static final String SCHEMA_FULL_CHECKING =
115 Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_FULL_CHECKING;
116
117 /** Feature identifier: continue after fatal error. */
118 protected static final String CONTINUE_AFTER_FATAL_ERROR =
119 Constants.XERCES_FEATURE_PREFIX + Constants.CONTINUE_AFTER_FATAL_ERROR_FEATURE;
120
121 /** Feature identifier: allow java encodings to be recognized when parsing schema docs. */
122 protected static final String ALLOW_JAVA_ENCODINGS =
123 Constants.XERCES_FEATURE_PREFIX + Constants.ALLOW_JAVA_ENCODINGS_FEATURE;
124
125 /** Feature identifier: standard uri conformant feature. */
126 protected static final String STANDARD_URI_CONFORMANT_FEATURE =
127 Constants.XERCES_FEATURE_PREFIX + Constants.STANDARD_URI_CONFORMANT_FEATURE;
128
129 /** Feature identifier: validate annotations. */
130 protected static final String VALIDATE_ANNOTATIONS =
131 Constants.XERCES_FEATURE_PREFIX + Constants.VALIDATE_ANNOTATIONS_FEATURE;
132
133 /** Feature: disallow doctype*/
134 protected static final String DISALLOW_DOCTYPE =
135 Constants.XERCES_FEATURE_PREFIX + Constants.DISALLOW_DOCTYPE_DECL_FEATURE;
136
137 /** Feature: generate synthetic annotations */
138 protected static final String GENERATE_SYNTHETIC_ANNOTATIONS =
139 Constants.XERCES_FEATURE_PREFIX + Constants.GENERATE_SYNTHETIC_ANNOTATIONS_FEATURE;
140
141 /** Feature identifier: honour all schemaLocations */
142 protected static final String HONOUR_ALL_SCHEMALOCATIONS =
143 Constants.XERCES_FEATURE_PREFIX + Constants.HONOUR_ALL_SCHEMALOCATIONS_FEATURE;
144
145 protected static final String AUGMENT_PSVI =
146 Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_AUGMENT_PSVI;
147
148 protected static final String PARSER_SETTINGS =
149 Constants.XERCES_FEATURE_PREFIX + Constants.PARSER_SETTINGS;
150
151 /** Feature identifier: namespace growth */
152 protected static final String NAMESPACE_GROWTH =
153 Constants.XERCES_FEATURE_PREFIX + Constants.NAMESPACE_GROWTH_FEATURE;
154
155 /** Feature identifier: tolerate duplicates */
156 protected static final String TOLERATE_DUPLICATES =
157 Constants.XERCES_FEATURE_PREFIX + Constants.TOLERATE_DUPLICATES_FEATURE;
158
159 /** Property identifier: Schema DV Factory */
160 protected static final String SCHEMA_DV_FACTORY =
161 Constants.XERCES_PROPERTY_PREFIX + Constants.SCHEMA_DV_FACTORY_PROPERTY;
162
163 protected static final String USE_SERVICE_MECHANISM = Constants.ORACLE_FEATURE_SERVICE_MECHANISM;
164
165 // recognized features:
166 private static final String[] RECOGNIZED_FEATURES = {
167 SCHEMA_FULL_CHECKING,
168 AUGMENT_PSVI,
169 CONTINUE_AFTER_FATAL_ERROR,
170 ALLOW_JAVA_ENCODINGS,
171 STANDARD_URI_CONFORMANT_FEATURE,
172 DISALLOW_DOCTYPE,
173 GENERATE_SYNTHETIC_ANNOTATIONS,
174 VALIDATE_ANNOTATIONS,
175 HONOUR_ALL_SCHEMALOCATIONS,
176 NAMESPACE_GROWTH,
177 TOLERATE_DUPLICATES,
178 USE_SERVICE_MECHANISM,
179 XMLConstants.USE_CATALOG
180 };
181
182 // property identifiers
183
184 /** Property identifier: symbol table. */
185 public static final String SYMBOL_TABLE =
186 Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY;
187
188 /** Property identifier: error reporter. */
189 public static final String ERROR_REPORTER =
190 Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;
191
192 /** Property identifier: error handler. */
193 public static final String ERROR_HANDLER =
194 Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_HANDLER_PROPERTY;
195
196 /** Property identifier: entity resolver. */
197 public static final String ENTITY_RESOLVER =
198 Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_RESOLVER_PROPERTY;
199
200 /** Property identifier: grammar pool. */
201 public static final String XMLGRAMMAR_POOL =
202 Constants.XERCES_PROPERTY_PREFIX + Constants.XMLGRAMMAR_POOL_PROPERTY;
203
204 /** Property identifier: schema location. */
205 protected static final String SCHEMA_LOCATION =
206 Constants.XERCES_PROPERTY_PREFIX + Constants.SCHEMA_LOCATION;
207
208 /** Property identifier: no namespace schema location. */
209 protected static final String SCHEMA_NONS_LOCATION =
210 Constants.XERCES_PROPERTY_PREFIX + Constants.SCHEMA_NONS_LOCATION;
211
212 /** Property identifier: JAXP schema source. */
213 protected static final String JAXP_SCHEMA_SOURCE =
214 Constants.JAXP_PROPERTY_PREFIX + Constants.SCHEMA_SOURCE;
215
216 protected static final String SECURITY_MANAGER =
217 Constants.XERCES_PROPERTY_PREFIX + Constants.SECURITY_MANAGER_PROPERTY;
218
219 /** Property identifier: locale. */
220 protected static final String LOCALE =
221 Constants.XERCES_PROPERTY_PREFIX + Constants.LOCALE_PROPERTY;
222
223 protected static final String ENTITY_MANAGER =
224 Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_MANAGER_PROPERTY;
225
226 /** Property identifier: Security property manager. */
227 private static final String XML_SECURITY_PROPERTY_MANAGER =
228 Constants.XML_SECURITY_PROPERTY_MANAGER;
229
230 /** Property identifier: access to external dtd */
231 public static final String ACCESS_EXTERNAL_DTD = XMLConstants.ACCESS_EXTERNAL_DTD;
232
233 /** Property identifier: access to external schema */
234 public static final String ACCESS_EXTERNAL_SCHEMA = XMLConstants.ACCESS_EXTERNAL_SCHEMA;
235
236 // recognized properties
237 private static final String [] RECOGNIZED_PROPERTIES = {
238 ENTITY_MANAGER,
239 SYMBOL_TABLE,
240 ERROR_REPORTER,
241 ERROR_HANDLER,
242 ENTITY_RESOLVER,
243 XMLGRAMMAR_POOL,
244 SCHEMA_LOCATION,
245 SCHEMA_NONS_LOCATION,
246 JAXP_SCHEMA_SOURCE,
247 SECURITY_MANAGER,
248 LOCALE,
249 SCHEMA_DV_FACTORY,
250 XML_SECURITY_PROPERTY_MANAGER,
251 JdkXmlUtils.CATALOG_DEFER,
252 JdkXmlUtils.CATALOG_FILES,
253 JdkXmlUtils.CATALOG_PREFER,
254 JdkXmlUtils.CATALOG_RESOLVE,
255 JdkXmlUtils.CDATA_CHUNK_SIZE
256 };
257
258 // Data
259
260 // features and properties
261 private final ParserConfigurationSettings fLoaderConfig = new ParserConfigurationSettings();
262 private XMLErrorReporter fErrorReporter = new XMLErrorReporter ();
263 private XMLEntityManager fEntityManager = null;
264 private XMLEntityResolver fUserEntityResolver = null;
265 private XMLGrammarPool fGrammarPool = null;
266 private String fExternalSchemas = null;
267 private String fExternalNoNSSchema = null;
268 // JAXP property: schema source
269 private Object fJAXPSource = null;
270 // is Schema Full Checking enabled
271 private boolean fIsCheckedFully = false;
272 // boolean that tells whether we've tested the JAXP property.
273 private boolean fJAXPProcessed = false;
274 // if features/properties has not been changed, the value of this attribute is "false"
275 private boolean fSettingsChanged = true;
276
277 // xml schema parsing
278 private XSDHandler fSchemaHandler;
279 private XSGrammarBucket fGrammarBucket;
280 private XSDeclarationPool fDeclPool = null;
281 private SubstitutionGroupHandler fSubGroupHandler;
282 private final CMNodeFactory fNodeFactory = new CMNodeFactory(); //component mgr will be set later
283 private CMBuilder fCMBuilder;
284 private XSDDescription fXSDDescription = new XSDDescription();
285 private String faccessExternalSchema = Constants.EXTERNAL_ACCESS_DEFAULT;
286
287 private WeakHashMap<Object, SchemaGrammar> fJAXPCache;
288 private Locale fLocale = Locale.getDefault();
289
290 // XSLoader attributes
291 private DOMStringList fRecognizedParameters = null;
292
293 /** DOM L3 error handler */
294 private DOMErrorHandlerWrapper fErrorHandler = null;
295
296 /** DOM L3 resource resolver */
297 private DOMEntityResolverWrapper fResourceResolver = null;
298
299 // default constructor. Create objects we absolutely need:
300 public XMLSchemaLoader() {
301 this( new SymbolTable(), null, new XMLEntityManager(), null, null, null);
302 }
303
304 public XMLSchemaLoader(SymbolTable symbolTable) {
305 this( symbolTable, null, new XMLEntityManager(), null, null, null);
306 }
307
308 /**
309 * This constractor is used by the XMLSchemaValidator. Additional properties, i.e. XMLEntityManager,
310 * will be passed during reset(XMLComponentManager).
311 * @param errorReporter
312 * @param grammarBucket
313 * @param sHandler
314 * @param builder
315 */
316 XMLSchemaLoader(XMLErrorReporter errorReporter,
317 XSGrammarBucket grammarBucket,
318 SubstitutionGroupHandler sHandler, CMBuilder builder) {
319 this(null, errorReporter, null, grammarBucket, sHandler, builder);
320 }
321
322 XMLSchemaLoader(SymbolTable symbolTable,
323 XMLErrorReporter errorReporter,
324 XMLEntityManager entityResolver,
325 XSGrammarBucket grammarBucket,
326 SubstitutionGroupHandler sHandler,
327 CMBuilder builder) {
328
329 // store properties and features in configuration
330 fLoaderConfig.addRecognizedFeatures(RECOGNIZED_FEATURES);
331 fLoaderConfig.addRecognizedProperties(RECOGNIZED_PROPERTIES);
332 if (symbolTable != null){
333 fLoaderConfig.setProperty(SYMBOL_TABLE, symbolTable);
334 }
335
336 if(errorReporter == null) {
337 errorReporter = new XMLErrorReporter ();
338 errorReporter.setLocale(fLocale);
339 errorReporter.setProperty(ERROR_HANDLER, new DefaultErrorHandler());
340
341 }
342 fErrorReporter = errorReporter;
343 // make sure error reporter knows about schemas...
344 if(fErrorReporter.getMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN) == null) {
345 fErrorReporter.putMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN, new XSMessageFormatter());
346 }
347 fLoaderConfig.setProperty(ERROR_REPORTER, fErrorReporter);
348 fEntityManager = entityResolver;
349 // entity manager is null if XMLSchemaValidator creates the loader
350 if (fEntityManager != null){
351 fLoaderConfig.setProperty(ENTITY_MANAGER, fEntityManager);
352 }
353
354 // by default augment PSVI (i.e. don't use declaration pool)
355 fLoaderConfig.setFeature(AUGMENT_PSVI, true);
356
357 if(grammarBucket == null ) {
358 grammarBucket = new XSGrammarBucket();
359 }
360 fGrammarBucket = grammarBucket;
361 if (sHandler == null) {
362 sHandler = new SubstitutionGroupHandler(this);
363 }
364 fSubGroupHandler = sHandler;
365
366 if(builder == null) {
367 builder = new CMBuilder(fNodeFactory);
368 }
369 fCMBuilder = builder;
370 fSchemaHandler = new XSDHandler(fGrammarBucket);
371 fJAXPCache = new WeakHashMap<>();
372
373 fSettingsChanged = true;
374 }
375
376 /**
377 * Returns a list of feature identifiers that are recognized by
378 * this XMLGrammarLoader. This method may return null if no features
379 * are recognized.
380 */
381 public String[] getRecognizedFeatures() {
382 return RECOGNIZED_FEATURES.clone();
383 } // getRecognizedFeatures(): String[]
384
385 /**
386 * Returns the state of a feature.
387 *
388 * @param featureId The feature identifier.
389 *
390 * @throws XMLConfigurationException Thrown on configuration error.
391 */
392 public boolean getFeature(String featureId)
393 throws XMLConfigurationException {
394 return fLoaderConfig.getFeature(featureId);
395 } // getFeature (String): boolean
396
397 /**
398 * Sets the state of a feature.
399 *
400 * @param featureId The feature identifier.
401 * @param state The state of the feature.
402 *
403 * @throws XMLConfigurationException Thrown when a feature is not
404 * recognized or cannot be set.
405 */
406 public void setFeature(String featureId,
407 boolean state) throws XMLConfigurationException {
408 fSettingsChanged = true;
409 if(featureId.equals(CONTINUE_AFTER_FATAL_ERROR)) {
410 fErrorReporter.setFeature(CONTINUE_AFTER_FATAL_ERROR, state);
411 }
412 else if(featureId.equals(GENERATE_SYNTHETIC_ANNOTATIONS)) {
413 fSchemaHandler.setGenerateSyntheticAnnotations(state);
414 }
415 fLoaderConfig.setFeature(featureId, state);
416 } // setFeature(String, boolean)
417
418 /**
419 * Returns a list of property identifiers that are recognized by
420 * this XMLGrammarLoader. This method may return null if no properties
421 * are recognized.
422 */
423 public String[] getRecognizedProperties() {
424 return RECOGNIZED_PROPERTIES.clone();
425 } // getRecognizedProperties(): String[]
426
427 /**
428 * Returns the state of a property.
429 *
430 * @param propertyId The property identifier.
431 *
432 * @throws XMLConfigurationException Thrown on configuration error.
433 */
434 public Object getProperty(String propertyId)
435 throws XMLConfigurationException {
436 return fLoaderConfig.getProperty(propertyId);
437 } // getProperty(String): Object
438
439 /**
440 * Sets the state of a property.
441 *
442 * @param propertyId The property identifier.
443 * @param state The state of the property.
444 *
445 * @throws XMLConfigurationException Thrown when a property is not
446 * recognized or cannot be set.
447 */
448 public void setProperty(String propertyId,
449 Object state) throws XMLConfigurationException {
450 fSettingsChanged = true;
451 fLoaderConfig.setProperty(propertyId, state);
452 if (propertyId.equals(JAXP_SCHEMA_SOURCE)) {
453 fJAXPSource = state;
454 fJAXPProcessed = false;
455 }
456 else if (propertyId.equals(XMLGRAMMAR_POOL)) {
457 fGrammarPool = (XMLGrammarPool)state;
458 }
459 else if (propertyId.equals(SCHEMA_LOCATION)) {
460 fExternalSchemas = (String)state;
461 }
462 else if (propertyId.equals(SCHEMA_NONS_LOCATION)) {
463 fExternalNoNSSchema = (String) state;
464 }
465 else if (propertyId.equals(LOCALE)) {
466 setLocale((Locale) state);
467 }
468 else if (propertyId.equals(ENTITY_RESOLVER)) {
469 fEntityManager.setProperty(ENTITY_RESOLVER, state);
470 }
471 else if (propertyId.equals(ERROR_REPORTER)) {
472 fErrorReporter = (XMLErrorReporter)state;
473 if (fErrorReporter.getMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN) == null) {
474 fErrorReporter.putMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN, new XSMessageFormatter());
475 }
476 }
477 else if (propertyId.equals(XML_SECURITY_PROPERTY_MANAGER)) {
478 XMLSecurityPropertyManager spm = (XMLSecurityPropertyManager)state;
479 faccessExternalSchema = spm.getValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_SCHEMA);
480 }
481 } // setProperty(String, Object)
482
483 /**
484 * Set the locale to use for messages.
485 *
486 * @param locale The locale object to use for localization of messages.
487 *
488 * @exception XNIException Thrown if the parser does not support the
489 * specified locale.
490 */
491 public void setLocale(Locale locale) {
492 fLocale = locale;
493 fErrorReporter.setLocale(locale);
494 } // setLocale(Locale)
495
496 /** Return the Locale the XMLGrammarLoader is using. */
497 public Locale getLocale() {
498 return fLocale;
499 } // getLocale(): Locale
500
501 /**
502 * Sets the error handler.
503 *
504 * @param errorHandler The error handler.
505 */
506 public void setErrorHandler(XMLErrorHandler errorHandler) {
507 fErrorReporter.setProperty(ERROR_HANDLER, errorHandler);
508 } // setErrorHandler(XMLErrorHandler)
509
510 /** Returns the registered error handler. */
511 public XMLErrorHandler getErrorHandler() {
512 return fErrorReporter.getErrorHandler();
513 } // getErrorHandler(): XMLErrorHandler
514
515 /**
516 * Sets the entity resolver.
517 *
518 * @param entityResolver The new entity resolver.
519 */
520 public void setEntityResolver(XMLEntityResolver entityResolver) {
521 fUserEntityResolver = entityResolver;
522 fLoaderConfig.setProperty(ENTITY_RESOLVER, entityResolver);
523 fEntityManager.setProperty(ENTITY_RESOLVER, entityResolver);
524 } // setEntityResolver(XMLEntityResolver)
525
526 /** Returns the registered entity resolver. */
527 public XMLEntityResolver getEntityResolver() {
528 return fUserEntityResolver;
529 } // getEntityResolver(): XMLEntityResolver
530
531 /**
532 * Returns a Grammar object by parsing the contents of the
533 * entities pointed to by sources.
534 *
535 * @param source the locations of the entity which forms
536 * the staring point of the grammars to be constructed
537 * @throws IOException when a problem is encounted reading the entity
538 * @throws XNIException when a condition arises (such as a FatalError) that requires parsing
539 * of the entity be terminated
540 */
541 public void loadGrammar(XMLInputSource source[])
542 throws IOException, XNIException {
543 int numSource = source.length;
544 for (int i = 0; i < numSource; ++i) {
545 loadGrammar(source[i]);
546 }
547 }
548
549 /**
550 * Returns a Grammar object by parsing the contents of the
551 * entity pointed to by source.
552 *
553 * @param source the location of the entity which forms
554 * the starting point of the grammar to be constructed.
555 * @throws IOException When a problem is encountered reading the entity
556 * XNIException When a condition arises (such as a FatalError) that requires parsing
557 * of the entity be terminated.
558 */
559 public Grammar loadGrammar(XMLInputSource source)
560 throws IOException, XNIException {
561
562 // REVISIT: this method should have a namespace parameter specified by
563 // user. In this case we can easily detect if a schema asked to be loaded
564 // is already in the local cache.
565
566 reset(fLoaderConfig);
567 fSettingsChanged = false;
568 XSDDescription desc = new XSDDescription();
569 desc.fContextType = XSDDescription.CONTEXT_PREPARSE;
570 desc.setBaseSystemId(source.getBaseSystemId());
571 desc.setLiteralSystemId( source.getSystemId());
572 // none of the other fields make sense for preparsing
573 Map<String, LocationArray> locationPairs = new HashMap<>();
574 // Process external schema location properties.
575 // We don't call tokenizeSchemaLocationStr here, because we also want
576 // to check whether the values are valid URI.
577 processExternalHints(fExternalSchemas, fExternalNoNSSchema,
578 locationPairs, fErrorReporter);
579 SchemaGrammar grammar = loadSchema(desc, source, locationPairs);
580
581 if(grammar != null && fGrammarPool != null) {
582 fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_SCHEMA, fGrammarBucket.getGrammars());
583 // NOTE: we only need to verify full checking in case the schema was not provided via JAXP
584 // since full checking already verified for all JAXP schemas
585 if(fIsCheckedFully && fJAXPCache.get(grammar) != grammar) {
586 XSConstraints.fullSchemaChecking(fGrammarBucket, fSubGroupHandler, fCMBuilder, fErrorReporter);
587 }
588 }
589 return grammar;
590 } // loadGrammar(XMLInputSource): Grammar
591
592 /**
593 * This method is called either from XMLGrammarLoader.loadGrammar or from XMLSchemaValidator.
594 * Note: in either case, the EntityManager (or EntityResolvers) are not going to be invoked
595 * to resolve the location of the schema in XSDDescription
596 * @param desc
597 * @param source
598 * @param locationPairs
599 * @return An XML Schema grammar
600 * @throws IOException
601 * @throws XNIException
602 */
603 SchemaGrammar loadSchema(XSDDescription desc, XMLInputSource source,
604 Map<String, LocationArray> locationPairs) throws IOException, XNIException {
605
606 // this should only be done once per invocation of this object;
607 // unless application alters JAXPSource in the mean time.
608 if(!fJAXPProcessed) {
609 processJAXPSchemaSource(locationPairs);
610 }
611
612 if (desc.isExternal() && !source.isCreatedByResolver()) {
613 String accessError = SecuritySupport.checkAccess(desc.getExpandedSystemId(), faccessExternalSchema, Constants.ACCESS_EXTERNAL_ALL);
614 if (accessError != null) {
615 throw new XNIException(fErrorReporter.reportError(XSMessageFormatter.SCHEMA_DOMAIN,
616 "schema_reference.access",
617 new Object[] { SecuritySupport.sanitizePath(desc.getExpandedSystemId()), accessError }, XMLErrorReporter.SEVERITY_ERROR));
618 }
619 }
620 SchemaGrammar grammar = fSchemaHandler.parseSchema(source, desc, locationPairs);
621
622 return grammar;
623 } // loadSchema(XSDDescription, XMLInputSource): SchemaGrammar
624
625 /**
626 * This method tries to resolve location of the given schema.
627 * The loader stores the namespace/location pairs in a map (use "" as the
628 * namespace of absent namespace). When resolving an entity, loader first tries
629 * to find in the map whether there is a value for that namespace,
630 * if so, pass that location value to the user-defined entity resolver.
631 *
632 * @param desc
633 * @param locationPairs
634 * @param entityResolver
635 * @return the XMLInputSource
636 * @throws IOException
637 */
638 public static XMLInputSource resolveDocument(XSDDescription desc,
639 Map<String, LocationArray> locationPairs,
640 XMLEntityResolver entityResolver) throws IOException {
641 String loc = null;
642 // we consider the schema location properties for import
643 if (desc.getContextType() == XSDDescription.CONTEXT_IMPORT ||
644 desc.fromInstance()) {
645 // use empty string as the key for absent namespace
646 String namespace = desc.getTargetNamespace();
647 String ns = namespace == null ? XMLSymbols.EMPTY_STRING : namespace;
648 // get the location hint for that namespace
649 LocationArray tempLA = locationPairs.get(ns);
650 if(tempLA != null)
651 loc = tempLA.getFirstLocation();
652 }
653
654 // if it's not import, or if the target namespace is not set
655 // in the schema location properties, use location hint
656 if (loc == null) {
657 String[] hints = desc.getLocationHints();
658 if (hints != null && hints.length > 0)
659 loc = hints[0];
660 }
661
662 String expandedLoc = XMLEntityManager.expandSystemId(loc, desc.getBaseSystemId(), false);
663 desc.setLiteralSystemId(loc);
664 desc.setExpandedSystemId(expandedLoc);
665 return entityResolver.resolveEntity(desc);
666 }
667
668 // add external schema locations to the location pairs
669 public static void processExternalHints(String sl, String nsl,
670 Map<String, LocationArray> locations,
671 XMLErrorReporter er) {
672 if (sl != null) {
673 try {
674 // get the attribute decl for xsi:schemaLocation
675 // because external schema location property has the same syntax
676 // as xsi:schemaLocation
677 XSAttributeDecl attrDecl = SchemaGrammar.SG_XSI.getGlobalAttributeDecl(SchemaSymbols.XSI_SCHEMALOCATION);
678 // validation the string value to get the list of URI's
679 attrDecl.fType.validate(sl, null, null);
680 if (!tokenizeSchemaLocationStr(sl, locations, null)) {
681 // report warning (odd number of items)
682 er.reportError(XSMessageFormatter.SCHEMA_DOMAIN,
683 "SchemaLocation",
684 new Object[]{sl},
685 XMLErrorReporter.SEVERITY_WARNING);
686 }
687 }
688 catch (InvalidDatatypeValueException ex) {
689 // report warning (not list of URI's)
690 er.reportError(XSMessageFormatter.SCHEMA_DOMAIN,
691 ex.getKey(), ex.getArgs(),
692 XMLErrorReporter.SEVERITY_WARNING);
693 }
694 }
695
696 if (nsl != null) {
697 try {
698 // similarly for no ns schema location property
699 XSAttributeDecl attrDecl = SchemaGrammar.SG_XSI.getGlobalAttributeDecl(
700 SchemaSymbols.XSI_NONAMESPACESCHEMALOCATION);
701 attrDecl.fType.validate(nsl, null, null);
702 LocationArray la = locations.get(XMLSymbols.EMPTY_STRING);
703 if(la == null) {
704 la = new LocationArray();
705 locations.put(XMLSymbols.EMPTY_STRING, la);
706 }
707 la.addLocation(nsl);
708 }
709 catch (InvalidDatatypeValueException ex) {
710 // report warning (not a URI)
711 er.reportError(XSMessageFormatter.SCHEMA_DOMAIN,
712 ex.getKey(), ex.getArgs(),
713 XMLErrorReporter.SEVERITY_WARNING);
714 }
715 }
716 }
717 // this method takes a SchemaLocation string.
718 // If an error is encountered, false is returned;
719 // otherwise, true is returned. In either case, locations
720 // is augmented to include as many tokens as possible.
721 // @param schemaStr The schemaLocation string to tokenize
722 // @param locations HashMap mapping namespaces to LocationArray objects holding lists of locaitons
723 // @return true if no problems; false if string could not be tokenized
724 public static boolean tokenizeSchemaLocationStr(String schemaStr,
725 Map<String, XMLSchemaLoader.LocationArray> locations, String base) {
726 if (schemaStr!= null) {
727 StringTokenizer t = new StringTokenizer(schemaStr, " \n\t\r");
728 String namespace, location;
729 while (t.hasMoreTokens()) {
730 namespace = t.nextToken ();
731 if (!t.hasMoreTokens()) {
732 return false; // error!
733 }
734 location = t.nextToken();
735 LocationArray la = locations.get(namespace);
736 if(la == null) {
737 la = new LocationArray();
738 locations.put(namespace, la);
739 }
740 if (base != null) {
741 try {
742 location = XMLEntityManager.expandSystemId(location, base, false);
743 } catch (MalformedURIException e) {
744 }
745 }
746 la.addLocation(location);
747 }
748 }
749 return true;
750 } // tokenizeSchemaLocation(String, HashMap): boolean
751
752 /**
753 * Translate the various JAXP SchemaSource property types to XNI
754 * XMLInputSource. Valid types are: String, org.xml.sax.InputSource,
755 * InputStream, File, or Object[] of any of previous types.
756 * REVISIT: the JAXP 1.2 spec is less than clear as to whether this property
757 * should be available to imported schemas. I have assumed
758 * that it should. - NG
759 * Note: all JAXP schema files will be checked for full-schema validity if the feature was set up
760 *
761 */
762 private void processJAXPSchemaSource(
763 Map<String, LocationArray> locationPairs) throws IOException {
764 fJAXPProcessed = true;
765 if (fJAXPSource == null) {
766 return;
767 }
768
769 Class<?> componentType = fJAXPSource.getClass().getComponentType();
770 XMLInputSource xis = null;
771 String sid = null;
772 if (componentType == null) {
773 // Not an array
774 if (fJAXPSource instanceof InputStream ||
775 fJAXPSource instanceof InputSource) {
776 SchemaGrammar g = fJAXPCache.get(fJAXPSource);
777 if (g != null) {
778 fGrammarBucket.putGrammar(g);
779 return;
780 }
781 }
782 fXSDDescription.reset();
783 xis = xsdToXMLInputSource(fJAXPSource);
784 sid = xis.getSystemId();
785 fXSDDescription.fContextType = XSDDescription.CONTEXT_PREPARSE;
786 if (sid != null) {
787 fXSDDescription.setBaseSystemId(xis.getBaseSystemId());
788 fXSDDescription.setLiteralSystemId(sid);
789 fXSDDescription.setExpandedSystemId(sid);
790 fXSDDescription.fLocationHints = new String[]{sid};
791 }
792 SchemaGrammar g = loadSchema(fXSDDescription, xis, locationPairs);
793 // it is possible that we won't be able to resolve JAXP schema-source location
794 if (g != null) {
795 if (fJAXPSource instanceof InputStream ||
796 fJAXPSource instanceof InputSource) {
797 fJAXPCache.put(fJAXPSource, g);
798 if (fIsCheckedFully) {
799 XSConstraints.fullSchemaChecking(fGrammarBucket, fSubGroupHandler, fCMBuilder, fErrorReporter);
800 }
801 }
802 fGrammarBucket.putGrammar(g);
803 }
804 return;
805 }
806 else if ( (componentType != Object.class) &&
807 (componentType != String.class) &&
808 !File.class.isAssignableFrom(componentType) &&
809 !InputStream.class.isAssignableFrom(componentType) &&
810 !InputSource.class.isAssignableFrom(componentType) &&
811 !componentType.isInterface()
812 ) {
813 // Not an Object[], String[], File[], InputStream[], InputSource[]
814 MessageFormatter mf = fErrorReporter.getMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN);
815 throw new XMLConfigurationException(
816 Status.NOT_SUPPORTED,
817 mf.formatMessage(fErrorReporter.getLocale(), "jaxp12-schema-source-type.2",
818 new Object [] {componentType.getName()}));
819 }
820
821 // JAXP spec. allow []s of type String, File, InputStream,
822 // InputSource also, apart from [] of type Object.
823 Object[] objArr = (Object[]) fJAXPSource;
824 // make local array for storing target namespaces of schemasources specified in object arrays.
825 ArrayList<String> jaxpSchemaSourceNamespaces = new ArrayList<>();
826 for (int i = 0; i < objArr.length; i++) {
827 if (objArr[i] instanceof InputStream ||
828 objArr[i] instanceof InputSource) {
829 SchemaGrammar g = fJAXPCache.get(objArr[i]);
830 if (g != null) {
831 fGrammarBucket.putGrammar(g);
832 continue;
833 }
834 }
835 fXSDDescription.reset();
836 xis = xsdToXMLInputSource(objArr[i]);
837 sid = xis.getSystemId();
838 fXSDDescription.fContextType = XSDDescription.CONTEXT_PREPARSE;
839 if (sid != null) {
840 fXSDDescription.setBaseSystemId(xis.getBaseSystemId());
841 fXSDDescription.setLiteralSystemId(sid);
842 fXSDDescription.setExpandedSystemId(sid);
843 fXSDDescription.fLocationHints = new String[]{sid};
844 }
845 String targetNamespace = null ;
846 // load schema
847 SchemaGrammar grammar = fSchemaHandler.parseSchema(xis,fXSDDescription, locationPairs);
848
849 if (fIsCheckedFully) {
850 XSConstraints.fullSchemaChecking(fGrammarBucket, fSubGroupHandler, fCMBuilder, fErrorReporter);
851 }
852 if (grammar != null) {
853 targetNamespace = grammar.getTargetNamespace();
854 if (jaxpSchemaSourceNamespaces.contains(targetNamespace)) {
855 // when an array of objects is passed it is illegal to have two schemas that share same namespace.
856 MessageFormatter mf = fErrorReporter.getMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN);
857 throw new java.lang.IllegalArgumentException(mf.formatMessage(fErrorReporter.getLocale(),
858 "jaxp12-schema-source-ns", null));
859 }
860 else {
861 jaxpSchemaSourceNamespaces.add(targetNamespace) ;
862 }
863 if(objArr[i] instanceof InputStream ||
864 objArr[i] instanceof InputSource) {
865 fJAXPCache.put(objArr[i], grammar);
866 }
867 fGrammarBucket.putGrammar(grammar);
868 }
869 else {
870 //REVISIT: What should be the acutal behavior if grammar can't be loaded as specified in schema source?
871 }
872 }
873 }//processJAXPSchemaSource
874
875 private XMLInputSource xsdToXMLInputSource(Object val) {
876 if (val instanceof String) {
877 // String value is treated as a URI that is passed through the
878 // EntityResolver
879 String loc = (String) val;
880 fXSDDescription.reset();
881 fXSDDescription.setValues(null, loc, null, null);
882 XMLInputSource xis = null;
883 try {
884 xis = fEntityManager.resolveEntity(fXSDDescription);
885 }
886 catch (IOException ex) {
887 fErrorReporter.reportError(XSMessageFormatter.SCHEMA_DOMAIN,
888 "schema_reference.4",
889 new Object[] { loc }, XMLErrorReporter.SEVERITY_ERROR);
890 }
891 if (xis == null) {
892 // REVISIT: can this happen?
893 // Treat value as a URI and pass in as systemId
894 return new XMLInputSource(null, loc, null, false);
895 }
896 return xis;
897 }
898 else if (val instanceof InputSource) {
899 return saxToXMLInputSource((InputSource) val);
900 }
901 else if (val instanceof InputStream) {
902 return new XMLInputSource(null, null, null,
903 (InputStream) val, null);
904 }
905 else if (val instanceof File) {
906 File file = (File) val;
907 InputStream is = null;
908 try {
909 is = new BufferedInputStream(new FileInputStream(file));
910 } catch (FileNotFoundException ex) {
911 fErrorReporter.reportError(XSMessageFormatter.SCHEMA_DOMAIN,
912 "schema_reference.4", new Object[] { file.toString() },
913 XMLErrorReporter.SEVERITY_ERROR);
914 }
915 return new XMLInputSource(null, file.toURI().toString(), null, is, null);
916 }
917 MessageFormatter mf = fErrorReporter.getMessageFormatter(XSMessageFormatter.SCHEMA_DOMAIN);
918 throw new XMLConfigurationException(
919 Status.NOT_SUPPORTED,
920 mf.formatMessage(fErrorReporter.getLocale(), "jaxp12-schema-source-type.1",
921 new Object [] {val != null ? val.getClass().getName() : "null"}));
922 }
923
924
925 //Convert a SAX InputSource to an equivalent XNI XMLInputSource
926
927 private static XMLInputSource saxToXMLInputSource(InputSource sis) {
928 String publicId = sis.getPublicId();
929 String systemId = sis.getSystemId();
930
931 Reader charStream = sis.getCharacterStream();
932 if (charStream != null) {
933 return new XMLInputSource(publicId, systemId, null, charStream,
934 null);
935 }
936
937 InputStream byteStream = sis.getByteStream();
938 if (byteStream != null) {
939 return new XMLInputSource(publicId, systemId, null, byteStream,
940 sis.getEncoding());
941 }
942
943 return new XMLInputSource(publicId, systemId, null, false);
944 }
945
946 public static class LocationArray{
947
948 int length ;
949 String [] locations = new String[2];
950
951 public void resize(int oldLength , int newLength){
952 String [] temp = new String[newLength] ;
953 System.arraycopy(locations, 0, temp, 0, Math.min(oldLength, newLength));
954 locations = temp ;
955 length = Math.min(oldLength, newLength);
956 }
957
958 public void addLocation(String location){
959 if(length >= locations.length ){
960 resize(length, Math.max(1, length*2));
961 }
962 locations[length++] = location;
963 }//setLocation()
964
965 public String [] getLocationArray(){
966 if(length < locations.length ){
967 resize(locations.length, length);
968 }
969 return locations;
970 }//getLocationArray()
971
972 public String getFirstLocation(){
973 return length > 0 ? locations[0] : null;
974 }
975
976 public int getLength(){
977 return length ;
978 }
979
980 } //locationArray
981
982 /* (non-Javadoc)
983 * @see com.sun.org.apache.xerces.internal.xni.parser.XMLComponent#getFeatureDefault(java.lang.String)
984 */
985 public Boolean getFeatureDefault(String featureId) {
986 if (featureId.equals(AUGMENT_PSVI)){
987 return Boolean.TRUE;
988 }
989 return null;
990 }
991
992 /* (non-Javadoc)
993 * @see com.sun.org.apache.xerces.internal.xni.parser.XMLComponent#getPropertyDefault(java.lang.String)
994 */
995 public Object getPropertyDefault(String propertyId) {
996 // TODO Auto-generated method stub
997 return null;
998 }
999
1000 /* (non-Javadoc)
1001 * @see com.sun.org.apache.xerces.internal.xni.parser.XMLComponent#reset(com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager)
1002 */
1003 public void reset(XMLComponentManager componentManager) throws XMLConfigurationException {
1004
1005 XMLSecurityPropertyManager spm = (XMLSecurityPropertyManager)componentManager.getProperty(XML_SECURITY_PROPERTY_MANAGER);
1006 if (spm == null) {
1007 spm = new XMLSecurityPropertyManager();
1008 setProperty(XML_SECURITY_PROPERTY_MANAGER, spm);
1009 }
1010
1011 XMLSecurityManager sm = (XMLSecurityManager)componentManager.getProperty(SECURITY_MANAGER);
1012 if (sm == null)
1013 setProperty(SECURITY_MANAGER,new XMLSecurityManager(true));
1014
1015 faccessExternalSchema = spm.getValue(XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_SCHEMA);
1016
1017 fGrammarBucket.reset();
1018
1019 fSubGroupHandler.reset();
1020
1021 boolean parser_settings = true;
1022 // If the component manager is the loader config don't bother querying it since it doesn't
1023 // recognize the PARSER_SETTINGS feature. Prevents an XMLConfigurationException from being
1024 // thrown.
1025 if (componentManager != fLoaderConfig) {
1026 parser_settings = componentManager.getFeature(PARSER_SETTINGS, true);
1027 }
1028
1029 if (!parser_settings || !fSettingsChanged){
1030 // need to reprocess JAXP schema sources
1031 fJAXPProcessed = false;
1032 // reinitialize grammar bucket
1033 initGrammarBucket();
1034 if (fDeclPool != null) {
1035 fDeclPool.reset();
1036 }
1037 return;
1038 }
1039
1040 //pass the component manager to the factory..
1041 fNodeFactory.reset(componentManager);
1042
1043 // get registered entity manager to be able to resolve JAXP schema-source property:
1044 // Note: in case XMLSchemaValidator has created the loader,
1045 // the entity manager property is null
1046 fEntityManager = (XMLEntityManager)componentManager.getProperty(ENTITY_MANAGER);
1047
1048 // get the error reporter
1049 fErrorReporter = (XMLErrorReporter)componentManager.getProperty(ERROR_REPORTER);
1050
1051 // Determine schema dv factory to use
1052 SchemaDVFactory dvFactory = null;
1053 dvFactory = fSchemaHandler.getDVFactory();
1054 if (dvFactory == null) {
1055 dvFactory = SchemaDVFactory.getInstance();
1056 fSchemaHandler.setDVFactory(dvFactory);
1057 }
1058
1059 // get schema location properties
1060 try {
1061 fExternalSchemas = (String) componentManager.getProperty(SCHEMA_LOCATION);
1062 fExternalNoNSSchema = (String) componentManager.getProperty(SCHEMA_NONS_LOCATION);
1063 } catch (XMLConfigurationException e) {
1064 fExternalSchemas = null;
1065 fExternalNoNSSchema = null;
1066 }
1067
1068 // get JAXP sources if available
1069 fJAXPSource = componentManager.getProperty(JAXP_SCHEMA_SOURCE, null);
1070 fJAXPProcessed = false;
1071
1072 // clear grammars, and put the one for schema namespace there
1073 fGrammarPool = (XMLGrammarPool) componentManager.getProperty(XMLGRAMMAR_POOL, null);
1074 initGrammarBucket();
1075
1076 boolean psvi = componentManager.getFeature(AUGMENT_PSVI, false);
1077
1078 // Only use the decl pool when there is no chance that the schema
1079 // components will be exposed or cached.
1080 // TODO: when someone calls loadGrammar(XMLInputSource), the schema is
1081 // always exposed even without the use of a grammar pool.
1082 // Disabling the "decl pool" feature for now until we understand when
1083 // it can be safely used.
1084 if (!psvi && fGrammarPool == null && false) {
1085 if (fDeclPool != null) {
1086 fDeclPool.reset();
1087 }
1088 else {
1089 fDeclPool = new XSDeclarationPool();
1090 }
1091 fCMBuilder.setDeclPool(fDeclPool);
1092 fSchemaHandler.setDeclPool(fDeclPool);
1093 if (dvFactory instanceof SchemaDVFactoryImpl) {
1094 fDeclPool.setDVFactory((SchemaDVFactoryImpl)dvFactory);
1095 ((SchemaDVFactoryImpl)dvFactory).setDeclPool(fDeclPool);
1096 }
1097 } else {
1098 fCMBuilder.setDeclPool(null);
1099 fSchemaHandler.setDeclPool(null);
1100 if (dvFactory instanceof SchemaDVFactoryImpl) {
1101 ((SchemaDVFactoryImpl)dvFactory).setDeclPool(null);
1102 }
1103 }
1104
1105 // get continue-after-fatal-error feature
1106 try {
1107 boolean fatalError = componentManager.getFeature(CONTINUE_AFTER_FATAL_ERROR, false);
1108 if (!fatalError) {
1109 fErrorReporter.setFeature(CONTINUE_AFTER_FATAL_ERROR, fatalError);
1110 }
1111 } catch (XMLConfigurationException e) {
1112 }
1113 // set full validation to false
1114 fIsCheckedFully = componentManager.getFeature(SCHEMA_FULL_CHECKING, false);
1115
1116 // get generate-synthetic-annotations feature
1117 fSchemaHandler.setGenerateSyntheticAnnotations(componentManager.getFeature(GENERATE_SYNTHETIC_ANNOTATIONS, false));
1118 fSchemaHandler.reset(componentManager);
1119 }
1120
1121 private void initGrammarBucket(){
1122 if(fGrammarPool != null) {
1123 Grammar [] initialGrammars = fGrammarPool.retrieveInitialGrammarSet(XMLGrammarDescription.XML_SCHEMA);
1124 final int length = (initialGrammars != null) ? initialGrammars.length : 0;
1125 for (int i = 0; i < length; ++i) {
1126 // put this grammar into the bucket, along with grammars
1127 // imported by it (directly or indirectly)
1128 if (!fGrammarBucket.putGrammar((SchemaGrammar)(initialGrammars[i]), true)) {
1129 // REVISIT: a conflict between new grammar(s) and grammars
1130 // in the bucket. What to do? A warning? An exception?
1131 fErrorReporter.reportError(XSMessageFormatter.SCHEMA_DOMAIN,
1132 "GrammarConflict", null,
1133 XMLErrorReporter.SEVERITY_WARNING);
1134 }
1135 }
1136 }
1137 }
1138
1139
1140 /* (non-Javadoc)
1141 * @see com.sun.org.apache.xerces.internal.xs.XSLoader#getConfig()
1142 */
1143 public DOMConfiguration getConfig() {
1144 return this;
1145 }
1146
1147 /* (non-Javadoc)
1148 * @see com.sun.org.apache.xerces.internal.xs.XSLoader#load(org.w3c.dom.ls.LSInput)
1149 */
1150 public XSModel load(LSInput is) {
1151 try {
1152 Grammar g = loadGrammar(dom2xmlInputSource(is));
1153 return ((XSGrammar) g).toXSModel();
1154 } catch (Exception e) {
1155 reportDOMFatalError(e);
1156 return null;
1157 }
1158 }
1159
1160 /* (non-Javadoc)
1161 * @see com.sun.org.apache.xerces.internal.xs.XSLoader#loadInputList(com.sun.org.apache.xerces.internal.xs.LSInputList)
1162 */
1163 public XSModel loadInputList(LSInputList is) {
1164 int length = is.getLength();
1165 SchemaGrammar[] gs = new SchemaGrammar[length];
1166 for (int i = 0; i < length; i++) {
1167 try {
1168 gs[i] = (SchemaGrammar) loadGrammar(dom2xmlInputSource(is.item(i)));
1169 } catch (Exception e) {
1170 reportDOMFatalError(e);
1171 return null;
1172 }
1173 }
1174 return new XSModelImpl(gs);
1175 }
1176
1177 /* (non-Javadoc)
1178 * @see com.sun.org.apache.xerces.internal.xs.XSLoader#loadURI(java.lang.String)
1179 */
1180 public XSModel loadURI(String uri) {
1181 try {
1182 Grammar g = loadGrammar(new XMLInputSource(null, uri, null, false));
1183 return ((XSGrammar)g).toXSModel();
1184 }
1185 catch (Exception e){
1186 reportDOMFatalError(e);
1187 return null;
1188 }
1189 }
1190
1191 /* (non-Javadoc)
1192 * @see com.sun.org.apache.xerces.internal.xs.XSLoader#loadURIList(com.sun.org.apache.xerces.internal.xs.StringList)
1193 */
1194 public XSModel loadURIList(StringList uriList) {
1195 int length = uriList.getLength();
1196 SchemaGrammar[] gs = new SchemaGrammar[length];
1197 for (int i = 0; i < length; i++) {
1198 try {
1199 gs[i] =
1200 (SchemaGrammar) loadGrammar(new XMLInputSource(null, uriList.item(i), null, false));
1201 } catch (Exception e) {
1202 reportDOMFatalError(e);
1203 return null;
1204 }
1205 }
1206 return new XSModelImpl(gs);
1207 }
1208
1209 void reportDOMFatalError(Exception e) {
1210 if (fErrorHandler != null) {
1211 DOMErrorImpl error = new DOMErrorImpl();
1212 error.fException = e;
1213 error.fMessage = e.getMessage();
1214 error.fSeverity = DOMError.SEVERITY_FATAL_ERROR;
1215 fErrorHandler.getErrorHandler().handleError(error);
1216 }
1217 }
1218
1219 /* (non-Javadoc)
1220 * @see DOMConfiguration#canSetParameter(String, Object)
1221 */
1222 public boolean canSetParameter(String name, Object value) {
1223 if(value instanceof Boolean){
1224 if (name.equals(Constants.DOM_VALIDATE) ||
1225 name.equals(SCHEMA_FULL_CHECKING) ||
1226 name.equals(VALIDATE_ANNOTATIONS) ||
1227 name.equals(CONTINUE_AFTER_FATAL_ERROR) ||
1228 name.equals(ALLOW_JAVA_ENCODINGS) ||
1229 name.equals(STANDARD_URI_CONFORMANT_FEATURE) ||
1230 name.equals(GENERATE_SYNTHETIC_ANNOTATIONS) ||
1231 name.equals(HONOUR_ALL_SCHEMALOCATIONS) ||
1232 name.equals(NAMESPACE_GROWTH) ||
1233 name.equals(TOLERATE_DUPLICATES) ||
1234 name.equals(USE_SERVICE_MECHANISM)) {
1235 return true;
1236
1237 }
1238 return false;
1239 }
1240 if (name.equals(Constants.DOM_ERROR_HANDLER) ||
1241 name.equals(Constants.DOM_RESOURCE_RESOLVER) ||
1242 name.equals(SYMBOL_TABLE) ||
1243 name.equals(ERROR_REPORTER) ||
1244 name.equals(ERROR_HANDLER) ||
1245 name.equals(ENTITY_RESOLVER) ||
1246 name.equals(XMLGRAMMAR_POOL) ||
1247 name.equals(SCHEMA_LOCATION) ||
1248 name.equals(SCHEMA_NONS_LOCATION) ||
1249 name.equals(JAXP_SCHEMA_SOURCE) ||
1250 name.equals(SCHEMA_DV_FACTORY)) {
1251 return true;
1252 }
1253 return false;
1254 }
1255
1256 /* (non-Javadoc)
1257 * @see DOMConfiguration#getParameter(String)
1258 */
1259 public Object getParameter(String name) throws DOMException {
1260
1261 if (name.equals(Constants.DOM_ERROR_HANDLER)){
1262 return (fErrorHandler != null) ? fErrorHandler.getErrorHandler() : null;
1263 }
1264 else if (name.equals(Constants.DOM_RESOURCE_RESOLVER)) {
1265 return (fResourceResolver != null) ? fResourceResolver.getEntityResolver() : null;
1266 }
1267
1268 try {
1269 boolean feature = getFeature(name);
1270 return (feature) ? Boolean.TRUE : Boolean.FALSE;
1271 } catch (Exception e) {
1272 Object property;
1273 try {
1274 property = getProperty(name);
1275 return property;
1276 } catch (Exception ex) {
1277 String msg =
1278 DOMMessageFormatter.formatMessage(
1279 DOMMessageFormatter.DOM_DOMAIN,
1280 "FEATURE_NOT_SUPPORTED",
1281 new Object[] { name });
1282 throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
1283 }
1284 }
1285 }
1286
1287 /* (non-Javadoc)
1288 * @see DOMConfiguration#getParameterNames()
1289 */
1290 public DOMStringList getParameterNames() {
1291 if (fRecognizedParameters == null){
1292 ArrayList<String> v = new ArrayList<>();
1293 v.add(Constants.DOM_VALIDATE);
1294 v.add(Constants.DOM_ERROR_HANDLER);
1295 v.add(Constants.DOM_RESOURCE_RESOLVER);
1296 v.add(SYMBOL_TABLE);
1297 v.add(ERROR_REPORTER);
1298 v.add(ERROR_HANDLER);
1299 v.add(ENTITY_RESOLVER);
1300 v.add(XMLGRAMMAR_POOL);
1301 v.add(SCHEMA_LOCATION);
1302 v.add(SCHEMA_NONS_LOCATION);
1303 v.add(JAXP_SCHEMA_SOURCE);
1304 v.add(SCHEMA_FULL_CHECKING);
1305 v.add(CONTINUE_AFTER_FATAL_ERROR);
1306 v.add(ALLOW_JAVA_ENCODINGS);
1307 v.add(STANDARD_URI_CONFORMANT_FEATURE);
1308 v.add(VALIDATE_ANNOTATIONS);
1309 v.add(GENERATE_SYNTHETIC_ANNOTATIONS);
1310 v.add(HONOUR_ALL_SCHEMALOCATIONS);
1311 v.add(NAMESPACE_GROWTH);
1312 v.add(TOLERATE_DUPLICATES);
1313 v.add(USE_SERVICE_MECHANISM);
1314 fRecognizedParameters = new DOMStringListImpl(v);
1315 }
1316 return fRecognizedParameters;
1317 }
1318
1319 /* (non-Javadoc)
1320 * @see DOMConfiguration#setParameter(String, Object)
1321 */
1322 public void setParameter(String name, Object value) throws DOMException {
1323 if (value instanceof Boolean) {
1324 boolean state = ((Boolean) value).booleanValue();
1325 if (name.equals("validate") && state) {
1326 return;
1327 }
1328 try {
1329 setFeature(name, state);
1330 } catch (Exception e) {
1331 String msg =
1332 DOMMessageFormatter.formatMessage(
1333 DOMMessageFormatter.DOM_DOMAIN,
1334 "FEATURE_NOT_SUPPORTED",
1335 new Object[] { name });
1336 throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
1337 }
1338 return;
1339 }
1340 if (name.equals(Constants.DOM_ERROR_HANDLER)) {
1341 if (value instanceof DOMErrorHandler) {
1342 try {
1343 fErrorHandler = new DOMErrorHandlerWrapper((DOMErrorHandler) value);
1344 setErrorHandler(fErrorHandler);
1345 } catch (XMLConfigurationException e) {
1346 }
1347 } else {
1348 // REVISIT: type mismatch
1349 String msg =
1350 DOMMessageFormatter.formatMessage(
1351 DOMMessageFormatter.DOM_DOMAIN,
1352 "FEATURE_NOT_SUPPORTED",
1353 new Object[] { name });
1354 throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
1355 }
1356 return;
1357
1358 }
1359 if (name.equals(Constants.DOM_RESOURCE_RESOLVER)) {
1360 if (value instanceof LSResourceResolver) {
1361 try {
1362 fResourceResolver = new DOMEntityResolverWrapper((LSResourceResolver) value);
1363 setEntityResolver(fResourceResolver);
1364 }
1365 catch (XMLConfigurationException e) {}
1366 } else {
1367 // REVISIT: type mismatch
1368 String msg =
1369 DOMMessageFormatter.formatMessage(
1370 DOMMessageFormatter.DOM_DOMAIN,
1371 "FEATURE_NOT_SUPPORTED",
1372 new Object[] { name });
1373 throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
1374 }
1375 return;
1376 }
1377
1378 try {
1379 setProperty(name, value);
1380 } catch (Exception ex) {
1381
1382 String msg =
1383 DOMMessageFormatter.formatMessage(
1384 DOMMessageFormatter.DOM_DOMAIN,
1385 "FEATURE_NOT_SUPPORTED",
1386 new Object[] { name });
1387 throw new DOMException(DOMException.NOT_SUPPORTED_ERR, msg);
1388
1389 }
1390
1391 }
1392
1393 XMLInputSource dom2xmlInputSource(LSInput is) {
1394 // need to wrap the LSInput with an XMLInputSource
1395 XMLInputSource xis = null;
1396
1397 /**
1398 * An LSParser looks at inputs specified in LSInput in
1399 * the following order: characterStream, byteStream,
1400 * stringData, systemId, publicId. For consistency
1401 * have the same behaviour for XSLoader.
1402 */
1403
1404 // check whether there is a Reader
1405 // according to DOM, we need to treat such reader as "UTF-16".
1406 if (is.getCharacterStream() != null) {
1407 xis = new XMLInputSource(is.getPublicId(), is.getSystemId(),
1408 is.getBaseURI(), is.getCharacterStream(),
1409 "UTF-16");
1410 }
1411 // check whether there is an InputStream
1412 else if (is.getByteStream() != null) {
1413 xis = new XMLInputSource(is.getPublicId(), is.getSystemId(),
1414 is.getBaseURI(), is.getByteStream(),
1415 is.getEncoding());
1416 }
1417 // if there is a string data, use a StringReader
1418 // according to DOM, we need to treat such data as "UTF-16".
1419 else if (is.getStringData() != null && is.getStringData().length() != 0) {
1420 xis = new XMLInputSource(is.getPublicId(), is.getSystemId(),
1421 is.getBaseURI(), new StringReader(is.getStringData()),
1422 "UTF-16");
1423 }
1424 // otherwise, just use the public/system/base Ids
1425 else {
1426 xis = new XMLInputSource(is.getPublicId(), is.getSystemId(),
1427 is.getBaseURI(), false);
1428 }
1429
1430 return xis;
1431 }
1432
1433 // Implements XSElementDeclHelper interface
1434 public XSElementDecl getGlobalElementDecl(QName element) {
1435 SchemaGrammar sGrammar = fGrammarBucket.getGrammar(element.uri);
1436 if (sGrammar != null) {
1437 return sGrammar.getGlobalElementDecl(element.localpart);
1438 }
1439 return null;
1440 }
1441
1442 } // XMLGrammarLoader