1 /*
2 * Copyright (c) 2007, 2015, 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.traversers;
22
23 import com.sun.org.apache.xerces.internal.impl.Constants;
24 import com.sun.org.apache.xerces.internal.impl.XMLEntityManager;
25 import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;
26 import com.sun.org.apache.xerces.internal.impl.dv.SchemaDVFactory;
27 import com.sun.org.apache.xerces.internal.impl.dv.xs.XSSimpleTypeDecl;
28 import com.sun.org.apache.xerces.internal.impl.xs.SchemaGrammar;
29 import com.sun.org.apache.xerces.internal.impl.xs.SchemaNamespaceSupport;
30 import com.sun.org.apache.xerces.internal.impl.xs.SchemaSymbols;
31 import com.sun.org.apache.xerces.internal.impl.xs.XMLSchemaException;
32 import com.sun.org.apache.xerces.internal.impl.xs.XMLSchemaLoader;
33 import com.sun.org.apache.xerces.internal.impl.xs.XSAttributeDecl;
34 import com.sun.org.apache.xerces.internal.impl.xs.XSAttributeGroupDecl;
35 import com.sun.org.apache.xerces.internal.impl.xs.XSComplexTypeDecl;
36 import com.sun.org.apache.xerces.internal.impl.xs.XSDDescription;
37 import com.sun.org.apache.xerces.internal.impl.xs.XSDeclarationPool;
38 import com.sun.org.apache.xerces.internal.impl.xs.XSElementDecl;
39 import com.sun.org.apache.xerces.internal.impl.xs.XSGrammarBucket;
40 import com.sun.org.apache.xerces.internal.impl.xs.XSGroupDecl;
41 import com.sun.org.apache.xerces.internal.impl.xs.XSMessageFormatter;
42 import com.sun.org.apache.xerces.internal.impl.xs.XSModelGroupImpl;
43 import com.sun.org.apache.xerces.internal.impl.xs.XSNotationDecl;
44 import com.sun.org.apache.xerces.internal.impl.xs.XSParticleDecl;
45 import com.sun.org.apache.xerces.internal.impl.xs.identity.IdentityConstraint;
46 import com.sun.org.apache.xerces.internal.impl.xs.opti.ElementImpl;
47 import com.sun.org.apache.xerces.internal.impl.xs.opti.SchemaDOMParser;
48 import com.sun.org.apache.xerces.internal.impl.xs.opti.SchemaParsingConfig;
49 import com.sun.org.apache.xerces.internal.impl.xs.util.SimpleLocator;
50 import com.sun.org.apache.xerces.internal.impl.xs.util.XSInputSource;
51 import com.sun.org.apache.xerces.internal.parsers.SAXParser;
52 import com.sun.org.apache.xerces.internal.parsers.XML11Configuration;
53 import com.sun.org.apache.xerces.internal.util.DOMInputSource;
54 import com.sun.org.apache.xerces.internal.util.DOMUtil;
55 import com.sun.org.apache.xerces.internal.util.DefaultErrorHandler;
56 import com.sun.org.apache.xerces.internal.util.ErrorHandlerWrapper;
57 import com.sun.org.apache.xerces.internal.util.SAXInputSource;
58 import com.sun.org.apache.xerces.internal.util.StAXInputSource;
59 import com.sun.org.apache.xerces.internal.util.StAXLocationWrapper;
60 import com.sun.org.apache.xerces.internal.util.SymbolHash;
61 import com.sun.org.apache.xerces.internal.util.SymbolTable;
62 import com.sun.org.apache.xerces.internal.util.URI.MalformedURIException;
63 import com.sun.org.apache.xerces.internal.util.XMLSymbols;
64 import com.sun.org.apache.xerces.internal.utils.SecuritySupport;
65 import com.sun.org.apache.xerces.internal.utils.XMLSecurityManager;
66 import com.sun.org.apache.xerces.internal.utils.XMLSecurityPropertyManager;
67 import com.sun.org.apache.xerces.internal.xni.QName;
68 import com.sun.org.apache.xerces.internal.xni.XNIException;
69 import com.sun.org.apache.xerces.internal.xni.grammars.Grammar;
70 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;
71 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarPool;
72 import com.sun.org.apache.xerces.internal.xni.grammars.XMLSchemaDescription;
73 import com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager;
74 import com.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;
75 import com.sun.org.apache.xerces.internal.xni.parser.XMLEntityResolver;
76 import com.sun.org.apache.xerces.internal.xni.parser.XMLErrorHandler;
77 import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;
78 import com.sun.org.apache.xerces.internal.xni.parser.XMLParseException;
79 import com.sun.org.apache.xerces.internal.xs.StringList;
80 import com.sun.org.apache.xerces.internal.xs.XSAttributeDeclaration;
81 import com.sun.org.apache.xerces.internal.xs.XSAttributeGroupDefinition;
82 import com.sun.org.apache.xerces.internal.xs.XSAttributeUse;
83 import com.sun.org.apache.xerces.internal.xs.XSConstants;
84 import com.sun.org.apache.xerces.internal.xs.XSElementDeclaration;
85 import com.sun.org.apache.xerces.internal.xs.XSModelGroup;
86 import com.sun.org.apache.xerces.internal.xs.XSModelGroupDefinition;
87 import com.sun.org.apache.xerces.internal.xs.XSNamedMap;
88 import com.sun.org.apache.xerces.internal.xs.XSObject;
89 import com.sun.org.apache.xerces.internal.xs.XSObjectList;
90 import com.sun.org.apache.xerces.internal.xs.XSParticle;
91 import com.sun.org.apache.xerces.internal.xs.XSSimpleTypeDefinition;
92 import com.sun.org.apache.xerces.internal.xs.XSTerm;
93 import com.sun.org.apache.xerces.internal.xs.XSTypeDefinition;
94 import com.sun.org.apache.xerces.internal.xs.datatypes.ObjectList;
95 import java.io.IOException;
96 import java.io.StringReader;
97 import java.util.ArrayList;
98 import java.util.Collections;
99 import java.util.HashMap;
100 import java.util.Locale;
101 import java.util.Map;
102 import java.util.Stack;
103 import java.util.Vector;
104 import javax.xml.XMLConstants;
105 import javax.xml.stream.XMLEventReader;
106 import javax.xml.stream.XMLStreamException;
107 import javax.xml.stream.XMLStreamReader;
108 import org.w3c.dom.Document;
109 import org.w3c.dom.Element;
110 import org.w3c.dom.Node;
111 import org.xml.sax.InputSource;
112 import org.xml.sax.SAXException;
113 import org.xml.sax.SAXNotRecognizedException;
114 import org.xml.sax.SAXParseException;
115 import org.xml.sax.XMLReader;
116 import org.xml.sax.helpers.XMLReaderFactory;
117
118 /**
119 * The purpose of this class is to co-ordinate the construction of a
120 * grammar object corresponding to a schema. To do this, it must be
121 * prepared to parse several schema documents (for instance if the
122 * schema document originally referred to contains <include> or
123 * <redefined> information items). If any of the schemas imports a
124 * schema, other grammars may be constructed as a side-effect.
125 *
126 * @xerces.internal
127 *
128 * @author Neil Graham, IBM
129 * @author Pavani Mukthipudi, Sun Microsystems
130 *
131 */
132 public class XSDHandler {
133
134 /** Feature identifier: validation. */
135 protected static final String VALIDATION =
136 Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE;
137
138 /** feature identifier: XML Schema validation */
139 protected static final String XMLSCHEMA_VALIDATION =
140 Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_VALIDATION_FEATURE;
141
142 /** Feature identifier: allow java encodings */
143 protected static final String ALLOW_JAVA_ENCODINGS =
144 Constants.XERCES_FEATURE_PREFIX + Constants.ALLOW_JAVA_ENCODINGS_FEATURE;
145
146 /** Feature identifier: continue after fatal error */
147 protected static final String CONTINUE_AFTER_FATAL_ERROR =
148 Constants.XERCES_FEATURE_PREFIX + Constants.CONTINUE_AFTER_FATAL_ERROR_FEATURE;
149
150 /** Feature identifier: allow java encodings */
151 protected static final String STANDARD_URI_CONFORMANT_FEATURE =
152 Constants.XERCES_FEATURE_PREFIX + Constants.STANDARD_URI_CONFORMANT_FEATURE;
153
154 /** Feature: disallow doctype*/
155 protected static final String DISALLOW_DOCTYPE =
156 Constants.XERCES_FEATURE_PREFIX + Constants.DISALLOW_DOCTYPE_DECL_FEATURE;
157
158 /** Feature: generate synthetic annotations */
159 protected static final String GENERATE_SYNTHETIC_ANNOTATIONS =
160 Constants.XERCES_FEATURE_PREFIX + Constants.GENERATE_SYNTHETIC_ANNOTATIONS_FEATURE;
161
162 /** Feature identifier: validate annotations. */
163 protected static final String VALIDATE_ANNOTATIONS =
164 Constants.XERCES_FEATURE_PREFIX + Constants.VALIDATE_ANNOTATIONS_FEATURE;
165
166 /** Feature identifier: honour all schemaLocations */
167 protected static final String HONOUR_ALL_SCHEMALOCATIONS =
168 Constants.XERCES_FEATURE_PREFIX + Constants.HONOUR_ALL_SCHEMALOCATIONS_FEATURE;
169
170 /** Feature identifier: namespace growth */
171 protected static final String NAMESPACE_GROWTH =
172 Constants.XERCES_FEATURE_PREFIX + Constants.NAMESPACE_GROWTH_FEATURE;
173
174 /** Feature identifier: tolerate duplicates */
175 protected static final String TOLERATE_DUPLICATES =
176 Constants.XERCES_FEATURE_PREFIX + Constants.TOLERATE_DUPLICATES_FEATURE;
177
178 /** Feature identifier: namespace prefixes. */
179 private static final String NAMESPACE_PREFIXES =
180 Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACE_PREFIXES_FEATURE;
181
182 /** Feature identifier: string interning. */
183 protected static final String STRING_INTERNING =
184 Constants.SAX_FEATURE_PREFIX + Constants.STRING_INTERNING_FEATURE;
185
186 /** Property identifier: error handler. */
187 protected static final String ERROR_HANDLER =
188 Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_HANDLER_PROPERTY;
189
190 /** Property identifier: JAXP schema source. */
191 protected static final String JAXP_SCHEMA_SOURCE =
192 Constants.JAXP_PROPERTY_PREFIX + Constants.SCHEMA_SOURCE;
193
194 /** Property identifier: entity resolver. */
195 public static final String ENTITY_RESOLVER =
196 Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_RESOLVER_PROPERTY;
197 /** Property identifier: entity manager. */
198 protected static final String ENTITY_MANAGER =
199 Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_MANAGER_PROPERTY;
200
201 /** Property identifier: error reporter. */
202 public static final String ERROR_REPORTER =
203 Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;
204
205 /** Property identifier: grammar pool. */
206 public static final String XMLGRAMMAR_POOL =
207 Constants.XERCES_PROPERTY_PREFIX + Constants.XMLGRAMMAR_POOL_PROPERTY;
208
209 /** Property identifier: symbol table. */
210 public static final String SYMBOL_TABLE =
211 Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY;
212
213 /** Property identifier: security manager. */
214 protected static final String SECURITY_MANAGER =
215 Constants.XERCES_PROPERTY_PREFIX + Constants.SECURITY_MANAGER_PROPERTY;
216
217 private static final String SECURE_PROCESSING =
218 Constants.XERCES_PROPERTY_PREFIX + Constants.SECURITY_MANAGER_PROPERTY;
219
220 /** Property identifier: locale. */
221 protected static final String LOCALE =
222 Constants.XERCES_PROPERTY_PREFIX + Constants.LOCALE_PROPERTY;
223
224 /** Property identifier: Security property manager. */
225 private static final String XML_SECURITY_PROPERTY_MANAGER =
226 Constants.XML_SECURITY_PROPERTY_MANAGER;
227
228 protected static final boolean DEBUG_NODE_POOL = false;
229
230 // Data
231
232 // different sorts of declarations; should make lookup and
233 // traverser calling more efficient/less bulky.
234 final static int ATTRIBUTE_TYPE = 1;
235 final static int ATTRIBUTEGROUP_TYPE = 2;
236 final static int ELEMENT_TYPE = 3;
237 final static int GROUP_TYPE = 4;
238 final static int IDENTITYCONSTRAINT_TYPE = 5;
239 final static int NOTATION_TYPE = 6;
240 final static int TYPEDECL_TYPE = 7;
241
242 // this string gets appended to redefined names; it's purpose is to be
243 // as unlikely as possible to cause collisions.
244 public final static String REDEF_IDENTIFIER = "_fn3dktizrknc9pi";
245
246 //
247 //protected data that can be accessable by any traverser
248
249 protected XSDeclarationPool fDeclPool = null;
250
251 /**
252 * <p>Security manager in effect.</p>
253 *
254 * <p>Protected to allow access by any traverser.</p>
255 */
256 protected XMLSecurityManager fSecureProcessing = null;
257
258 private String fAccessExternalSchema;
259 private String fAccessExternalDTD;
260
261 // These tables correspond to the symbol spaces defined in the
262 // spec.
263 // They are keyed with a QName (that is, String("URI,localpart) and
264 // their values are nodes corresponding to the given name's decl.
265 // By asking the node for its ownerDocument and looking in
266 // XSDocumentInfoRegistry we can easily get the corresponding
267 // XSDocumentInfo object.
268 private boolean registryEmpty = true;
269 private Map<String, Element> fUnparsedAttributeRegistry = new HashMap();
270 private Map<String, Element> fUnparsedAttributeGroupRegistry = new HashMap();
271 private Map<String, Element> fUnparsedElementRegistry = new HashMap();
272 private Map<String, Element> fUnparsedGroupRegistry = new HashMap();
273 private Map<String, Element> fUnparsedIdentityConstraintRegistry = new HashMap();
274 private Map<String, Element> fUnparsedNotationRegistry = new HashMap();
275 private Map<String, Element> fUnparsedTypeRegistry = new HashMap();
276 // Compensation for the above maps to locate XSDocumentInfo,
277 // Since we may take Schema Element directly, so can not get the
278 // corresponding XSDocumentInfo object just using above maps.
279 private Map<String, XSDocumentInfo> fUnparsedAttributeRegistrySub = new HashMap();
280 private Map<String, XSDocumentInfo> fUnparsedAttributeGroupRegistrySub = new HashMap();
281 private Map<String, XSDocumentInfo> fUnparsedElementRegistrySub = new HashMap();
282 private Map<String, XSDocumentInfo> fUnparsedGroupRegistrySub = new HashMap();
283 private Map<String, XSDocumentInfo> fUnparsedIdentityConstraintRegistrySub = new HashMap();
284 private Map<String, XSDocumentInfo> fUnparsedNotationRegistrySub = new HashMap();
285 private Map<String, XSDocumentInfo> fUnparsedTypeRegistrySub = new HashMap();
286
287 // Stores XSDocumentInfo (keyed by component name), to check for duplicate
288 // components declared within the same xsd document
289 private Map fUnparsedRegistriesExt[] = new HashMap[] {
290 null,
291 null, // ATTRIBUTE_TYPE
292 null, // ATTRIBUTEGROUP_TYPE
293 null, // ELEMENT_TYPE
294 null, // GROUP_TYPE
295 null, // IDENTITYCONSTRAINT_TYPE
296 null, // NOTATION_TYPE
297 null, // TYPEDECL_TYPE
298 };
299
300 // this map is keyed on by XSDocumentInfo objects. Its values
301 // are Vectors containing the XSDocumentInfo objects <include>d,
302 // <import>ed or <redefine>d by the key XSDocumentInfo.
303 private Map<XSDocumentInfo, Vector> fDependencyMap = new HashMap();
304
305 // this map is keyed on by a target namespace. Its values
306 // are Vectors containing namespaces imported by schema documents
307 // with the key target namespace.
308 // if an imprted schema has absent namespace, the value "null" is stored.
309 private Map<String, Vector> fImportMap = new HashMap();
310 // all namespaces that imports other namespaces
311 // if the importing schema has absent namespace, empty string is stored.
312 // (because the key of a map can't be null.)
313 private Vector fAllTNSs = new Vector();
314 // stores instance document mappings between namespaces and schema hints
315 private Map<String, XMLSchemaLoader.LocationArray> fLocationPairs = null;
316
317 // Records which nodes are hidden when the input is a DOMInputSource.
318 Map<Node, String> fHiddenNodes = null;
319
320 // convenience methods
321 private String null2EmptyString(String ns) {
322 return ns == null ? XMLSymbols.EMPTY_STRING : ns;
323 }
324 private String emptyString2Null(String ns) {
325 return ns == XMLSymbols.EMPTY_STRING ? null : ns;
326 }
327 // use Schema Element to lookup the SystemId.
328 private String doc2SystemId(Element ele) {
329 String documentURI = null;
330 /**
331 * REVISIT: Casting until DOM Level 3 interfaces are available. -- mrglavas
332 */
333 if(ele.getOwnerDocument() instanceof com.sun.org.apache.xerces.internal.impl.xs.opti.SchemaDOM){
334 documentURI = ((com.sun.org.apache.xerces.internal.impl.xs.opti.SchemaDOM) ele.getOwnerDocument()).getDocumentURI();
335 }
336 return documentURI != null ? documentURI : (String) fDoc2SystemId.get(ele);
337 }
338
339 // This vector stores strings which are combinations of the
340 // publicId and systemId of the inputSource corresponding to a
341 // schema document. This combination is used so that the user's
342 // EntityResolver can provide a consistent way of identifying a
343 // schema document that is included in multiple other schemas.
344 private Map fTraversed = new HashMap();
345
346 // this map contains a mapping from Schema Element to its systemId
347 // this is useful to resolve a uri relative to the referring document
348 private Map fDoc2SystemId = new HashMap();
349
350 // the primary XSDocumentInfo we were called to parse
351 private XSDocumentInfo fRoot = null;
352
353 // This map's job is to act as a link between the Schema Element and its
354 // XSDocumentInfo object.
355 private Map fDoc2XSDocumentMap = new HashMap();
356
357 // map between <redefine> elements and the XSDocumentInfo
358 // objects that correspond to the documents being redefined.
359 private Map fRedefine2XSDMap = null;
360
361 // map between <redefine> elements and the namespace support
362 private Map fRedefine2NSSupport = null;
363
364 // these objects store a mapping between the names of redefining
365 // groups/attributeGroups and the groups/AttributeGroups which
366 // they redefine by restriction (implicitly). It is up to the
367 // Group and AttributeGroup traversers to check these restrictions for
368 // validity.
369 private Map fRedefinedRestrictedAttributeGroupRegistry = new HashMap();
370 private Map fRedefinedRestrictedGroupRegistry = new HashMap();
371
372 // a variable storing whether the last schema document
373 // processed (by getSchema) was a duplicate.
374 private boolean fLastSchemaWasDuplicate;
375
376 // validate annotations feature
377 private boolean fValidateAnnotations = false;
378
379 //handle multiple import feature
380 private boolean fHonourAllSchemaLocations = false;
381
382 //handle namespace growth feature
383 boolean fNamespaceGrowth = false;
384
385 // handle tolerate duplicates feature
386 boolean fTolerateDuplicates = false;
387
388 // the XMLErrorReporter
389 private XMLErrorReporter fErrorReporter;
390 private XMLEntityResolver fEntityResolver;
391
392 // the XSAttributeChecker
393 private XSAttributeChecker fAttributeChecker;
394
395 // the symbol table
396 private SymbolTable fSymbolTable;
397
398 // the GrammarResolver
399 private XSGrammarBucket fGrammarBucket;
400
401 // the Grammar description
402 private XSDDescription fSchemaGrammarDescription;
403
404 // the Grammar Pool
405 private XMLGrammarPool fGrammarPool;
406
407 //************ Traversers **********
408 XSDAttributeGroupTraverser fAttributeGroupTraverser;
409 XSDAttributeTraverser fAttributeTraverser;
410 XSDComplexTypeTraverser fComplexTypeTraverser;
411 XSDElementTraverser fElementTraverser;
412 XSDGroupTraverser fGroupTraverser;
413 XSDKeyrefTraverser fKeyrefTraverser;
414 XSDNotationTraverser fNotationTraverser;
415 XSDSimpleTypeTraverser fSimpleTypeTraverser;
416 XSDUniqueOrKeyTraverser fUniqueOrKeyTraverser;
417 XSDWildcardTraverser fWildCardTraverser;
418
419 SchemaDVFactory fDVFactory;
420 SchemaDOMParser fSchemaParser;
421 SchemaContentHandler fXSContentHandler;
422 StAXSchemaParser fStAXSchemaParser;
423 XML11Configuration fAnnotationValidator;
424 XSAnnotationGrammarPool fGrammarBucketAdapter;
425
426 // these data members are needed for the deferred traversal
427 // of local elements.
428
429 // the initial size of the array to store deferred local elements
430 private static final int INIT_STACK_SIZE = 30;
431 // the incremental size of the array to store deferred local elements
432 private static final int INC_STACK_SIZE = 10;
433 // current position of the array (# of deferred local elements)
434 private int fLocalElemStackPos = 0;
435
436 private XSParticleDecl[] fParticle = new XSParticleDecl[INIT_STACK_SIZE];
437 private Element[] fLocalElementDecl = new Element[INIT_STACK_SIZE];
438 private XSDocumentInfo[] fLocalElementDecl_schema = new XSDocumentInfo[INIT_STACK_SIZE]; //JACK
439 private int[] fAllContext = new int[INIT_STACK_SIZE];
440 private XSObject[] fParent = new XSObject[INIT_STACK_SIZE];
441 private String [][] fLocalElemNamespaceContext = new String [INIT_STACK_SIZE][1];
442
443 // these data members are needed for the deferred traversal
444 // of keyrefs.
445
446 // the initial size of the array to store deferred keyrefs
447 private static final int INIT_KEYREF_STACK = 2;
448 // the incremental size of the array to store deferred keyrefs
449 private static final int INC_KEYREF_STACK_AMOUNT = 2;
450 // current position of the array (# of deferred keyrefs)
451 private int fKeyrefStackPos = 0;
452
453 private Element [] fKeyrefs = new Element[INIT_KEYREF_STACK];
454 private XSDocumentInfo [] fKeyrefsMapXSDocumentInfo = new XSDocumentInfo[INIT_KEYREF_STACK];
455 private XSElementDecl [] fKeyrefElems = new XSElementDecl [INIT_KEYREF_STACK];
456 private String [][] fKeyrefNamespaceContext = new String[INIT_KEYREF_STACK][1];
457
458 // global decls: map from decl name to decl object
459 SymbolHash fGlobalAttrDecls = new SymbolHash(12);
460 SymbolHash fGlobalAttrGrpDecls = new SymbolHash(5);
461 SymbolHash fGlobalElemDecls = new SymbolHash(25);
462 SymbolHash fGlobalGroupDecls = new SymbolHash(5);
463 SymbolHash fGlobalNotationDecls = new SymbolHash(1);
464 SymbolHash fGlobalIDConstraintDecls = new SymbolHash(3);
465 SymbolHash fGlobalTypeDecls = new SymbolHash(25);
466
467 // Constructors
468 public XSDHandler(){
469 fHiddenNodes = new HashMap<>();
470 fSchemaParser = new SchemaDOMParser(new SchemaParsingConfig());
471 }
472
473 // it should be possible to use the same XSDHandler to parse
474 // multiple schema documents; this will allow one to be
475 // constructed.
476 public XSDHandler (XSGrammarBucket gBucket) {
477 this();
478 fGrammarBucket = gBucket;
479
480 // Note: don't use SchemaConfiguration internally
481 // we will get stack overflaw because
482 // XMLSchemaValidator will be instantiating XSDHandler...
483 fSchemaGrammarDescription = new XSDDescription();
484 } // end constructor
485
486 /**
487 * This method initiates the parse of a schema. It will likely be
488 * called from the Validator and it will make the
489 * resulting grammar available; it returns a reference to this object just
490 * in case. A reset(XMLComponentManager) must be called before this methods is called.
491 * @param is
492 * @param desc
493 * @param locationPairs
494 * @return the SchemaGrammar
495 * @throws IOException
496 */
497 public SchemaGrammar parseSchema(XMLInputSource is, XSDDescription desc,
498 Map<String, XMLSchemaLoader.LocationArray> locationPairs)
499 throws IOException {
500 fLocationPairs = locationPairs;
501 fSchemaParser.resetNodePool();
502 SchemaGrammar grammar = null;
503 String schemaNamespace = null;
504 short referType = desc.getContextType();
505
506 // if loading using JAXP schemaSource property, or using grammar caching loadGrammar
507 // the desc.targetNamespace is always null.
508 // Therefore we should not attempt to find out if
509 // the schema is already in the bucket, since in the case we have
510 // no namespace schema in the bucket, findGrammar will always return the
511 // no namespace schema.
512 if (referType != XSDDescription.CONTEXT_PREPARSE){
513 // first try to find it in the bucket/pool, return if one is found
514 if (fHonourAllSchemaLocations && referType == XSDDescription.CONTEXT_IMPORT && isExistingGrammar(desc, fNamespaceGrowth)) {
515 grammar = fGrammarBucket.getGrammar(desc.getTargetNamespace());
516 }
517 else {
518 grammar = findGrammar(desc, fNamespaceGrowth);
519 }
520 if (grammar != null) {
521 if (!fNamespaceGrowth) {
522 return grammar;
523 }
524 else {
525 try {
526 if (grammar.getDocumentLocations().contains(XMLEntityManager.expandSystemId(is.getSystemId(), is.getBaseSystemId(), false))) {
527 return grammar;
528 }
529 }
530 catch (MalformedURIException e) {
531 //REVISIT: return the grammar?
532 }
533 }
534 }
535
536 schemaNamespace = desc.getTargetNamespace();
537 // handle empty string URI as null
538 if (schemaNamespace != null) {
539 schemaNamespace = fSymbolTable.addSymbol(schemaNamespace);
540 }
541 }
542
543 // before parsing a schema, need to clear registries associated with
544 // parsing schemas
545 prepareForParse();
546
547 Element schemaRoot = null;
548 // first phase: construct trees.
549 if (is instanceof DOMInputSource) {
550 schemaRoot = getSchemaDocument(schemaNamespace, (DOMInputSource) is,
551 referType == XSDDescription.CONTEXT_PREPARSE,
552 referType, null);
553 } // DOMInputSource
554 else if (is instanceof SAXInputSource) {
555 schemaRoot = getSchemaDocument(schemaNamespace, (SAXInputSource) is,
556 referType == XSDDescription.CONTEXT_PREPARSE,
557 referType, null);
558 } // SAXInputSource
559 else if (is instanceof StAXInputSource) {
560 schemaRoot = getSchemaDocument(schemaNamespace, (StAXInputSource) is,
561 referType == XSDDescription.CONTEXT_PREPARSE,
562 referType, null);
563 } // StAXInputSource
564 else if (is instanceof XSInputSource) {
565 schemaRoot = getSchemaDocument((XSInputSource) is, desc);
566 } // XSInputSource
567 else {
568 schemaRoot = getSchemaDocument(schemaNamespace, is,
569 referType == XSDDescription.CONTEXT_PREPARSE,
570 referType, null);
571
572 } //is instanceof XMLInputSource
573
574 if (schemaRoot == null) {
575 // something went wrong right off the hop
576 if (is instanceof XSInputSource) {
577 return fGrammarBucket.getGrammar(desc.getTargetNamespace());
578 }
579 return grammar;
580 }
581
582 if (referType == XSDDescription.CONTEXT_PREPARSE) {
583 Element schemaElem = schemaRoot;
584 schemaNamespace = DOMUtil.getAttrValue(schemaElem, SchemaSymbols.ATT_TARGETNAMESPACE);
585 if(schemaNamespace != null && schemaNamespace.length() > 0) {
586 // Since now we've discovered a namespace, we need to update xsd key
587 // and store this schema in traversed schemas bucket
588 schemaNamespace = fSymbolTable.addSymbol(schemaNamespace);
589 desc.setTargetNamespace(schemaNamespace);
590 }
591 else {
592 schemaNamespace = null;
593 }
594 grammar = findGrammar(desc, fNamespaceGrowth);
595 String schemaId = XMLEntityManager.expandSystemId(is.getSystemId(), is.getBaseSystemId(), false);
596 if (grammar != null) {
597 // When namespace growth is enabled and a null location is provided we cannot tell
598 // whether we've loaded this schema document before so we must assume that we haven't.
599 if (!fNamespaceGrowth || (schemaId != null && grammar.getDocumentLocations().contains(schemaId))) {
600 return grammar;
601 }
602 }
603
604 XSDKey key = new XSDKey(schemaId, referType, schemaNamespace);
605 fTraversed.put(key, schemaRoot);
606 if (schemaId != null) {
607 fDoc2SystemId.put(schemaRoot, schemaId);
608 }
609 }
610
611 // before constructing trees and traversing a schema, need to reset
612 // all traversers and clear all registries
613 prepareForTraverse();
614
615 fRoot = constructTrees(schemaRoot, is.getSystemId(), desc, grammar != null);
616 if (fRoot == null) {
617 return null;
618 }
619
620 // second phase: fill global registries.
621 buildGlobalNameRegistries();
622
623 // third phase: call traversers
624 ArrayList annotationInfo = fValidateAnnotations ? new ArrayList() : null;
625 traverseSchemas(annotationInfo);
626
627 // fourth phase: handle local element decls
628 traverseLocalElements();
629
630 // fifth phase: handle Keyrefs
631 resolveKeyRefs();
632
633 // sixth phase: validate attribute of non-schema namespaces
634 // REVISIT: skip this for now. we really don't want to do it.
635 //fAttributeChecker.checkNonSchemaAttributes(fGrammarBucket);
636
637 // seventh phase: store imported grammars
638 // for all grammars with <import>s
639 for (int i = fAllTNSs.size() - 1; i >= 0; i--) {
640 // get its target namespace
641 String tns = (String)fAllTNSs.elementAt(i);
642 // get all namespaces it imports
643 Vector ins = (Vector)fImportMap.get(tns);
644 // get the grammar
645 SchemaGrammar sg = fGrammarBucket.getGrammar(emptyString2Null(tns));
646 if (sg == null)
647 continue;
648 SchemaGrammar isg;
649 // for imported namespace
650 int count = 0;
651 for (int j = 0; j < ins.size(); j++) {
652 // get imported grammar
653 isg = fGrammarBucket.getGrammar((String)ins.elementAt(j));
654 // reuse the same vector
655 if (isg != null)
656 ins.setElementAt(isg, count++);
657 }
658 ins.setSize(count);
659 // set the imported grammars
660 sg.setImportedGrammars(ins);
661 }
662
663 /** validate annotations **/
664 if (fValidateAnnotations && annotationInfo.size() > 0) {
665 validateAnnotations(annotationInfo);
666 }
667
668 // and return.
669 return fGrammarBucket.getGrammar(fRoot.fTargetNamespace);
670 } // end parseSchema
671
672 private void validateAnnotations(ArrayList annotationInfo) {
673 if (fAnnotationValidator == null) {
674 createAnnotationValidator();
675 }
676 final int size = annotationInfo.size();
677 final XMLInputSource src = new XMLInputSource(null, null, null);
678 fGrammarBucketAdapter.refreshGrammars(fGrammarBucket);
679 for (int i = 0; i < size; i += 2) {
680 src.setSystemId((String) annotationInfo.get(i));
681 XSAnnotationInfo annotation = (XSAnnotationInfo) annotationInfo.get(i+1);
682 while (annotation != null) {
683 src.setCharacterStream(new StringReader(annotation.fAnnotation));
684 try {
685 fAnnotationValidator.parse(src);
686 }
687 catch (IOException exc) {}
688 annotation = annotation.next;
689 }
690 }
691 }
692
693 private void createAnnotationValidator() {
694 fAnnotationValidator = new XML11Configuration();
695 fGrammarBucketAdapter = new XSAnnotationGrammarPool();
696 fAnnotationValidator.setFeature(VALIDATION, true);
697 fAnnotationValidator.setFeature(XMLSCHEMA_VALIDATION, true);
698 fAnnotationValidator.setProperty(XMLGRAMMAR_POOL, fGrammarBucketAdapter);
699 /** Set error handler. **/
700 XMLErrorHandler errorHandler = fErrorReporter.getErrorHandler();
701 fAnnotationValidator.setProperty(ERROR_HANDLER, (errorHandler != null) ? errorHandler : new DefaultErrorHandler());
702 /** Set locale. **/
703 Locale locale = fErrorReporter.getLocale();
704 fAnnotationValidator.setProperty(LOCALE, locale);
705 }
706
707 /**
708 * Pull the grammar out of the bucket simply using
709 * its TNS as a key
710 */
711 SchemaGrammar getGrammar(String tns) {
712 return fGrammarBucket.getGrammar(tns);
713 }
714
715 /**
716 * First try to find a grammar in the bucket, if failed, consult the
717 * grammar pool. If a grammar is found in the pool, then add it (and all
718 * imported ones) into the bucket.
719 */
720 protected SchemaGrammar findGrammar(XSDDescription desc, boolean ignoreConflict) {
721 SchemaGrammar sg = fGrammarBucket.getGrammar(desc.getTargetNamespace());
722 if (sg == null) {
723 if (fGrammarPool != null) {
724 sg = (SchemaGrammar)fGrammarPool.retrieveGrammar(desc);
725 if (sg != null) {
726 // put this grammar into the bucket, along with grammars
727 // imported by it (directly or indirectly)
728 if (!fGrammarBucket.putGrammar(sg, true, ignoreConflict)) {
729 // REVISIT: a conflict between new grammar(s) and grammars
730 // in the bucket. What to do? A warning? An exception?
731 reportSchemaWarning("GrammarConflict", null, null);
732 sg = null;
733 }
734 }
735 }
736 }
737 return sg;
738 }
739
740 // may wish to have setter methods for ErrorHandler,
741 // EntityResolver...
742
743 private static final String[][] NS_ERROR_CODES = {
744 {"src-include.2.1", "src-include.2.1"},
745 {"src-redefine.3.1", "src-redefine.3.1"},
746 {"src-import.3.1", "src-import.3.2"},
747 null,
748 {"TargetNamespace.1", "TargetNamespace.2"},
749 {"TargetNamespace.1", "TargetNamespace.2"},
750 {"TargetNamespace.1", "TargetNamespace.2"},
751 {"TargetNamespace.1", "TargetNamespace.2"}
752 };
753
754 private static final String[] ELE_ERROR_CODES = {
755 "src-include.1", "src-redefine.2", "src-import.2", "schema_reference.4",
756 "schema_reference.4", "schema_reference.4", "schema_reference.4", "schema_reference.4"
757 };
758
759 // This method does several things:
760 // It constructs an instance of an XSDocumentInfo object using the
761 // schemaRoot node. Then, for each <include>,
762 // <redefine>, and <import> children, it attempts to resolve the
763 // requested schema document, initiates a DOM parse, and calls
764 // itself recursively on that document's root. It also records in
765 // the DependencyMap object what XSDocumentInfo objects its XSDocumentInfo
766 // depends on.
767 // It also makes sure the targetNamespace of the schema it was
768 // called to parse is correct.
769 protected XSDocumentInfo constructTrees(Element schemaRoot, String locationHint, XSDDescription desc, boolean nsCollision) {
770 if (schemaRoot == null) return null;
771 String callerTNS = desc.getTargetNamespace();
772 short referType = desc.getContextType();
773
774 XSDocumentInfo currSchemaInfo = null;
775 try {
776 // note that attributes are freed at end of traverseSchemas()
777 currSchemaInfo = new XSDocumentInfo(schemaRoot, fAttributeChecker, fSymbolTable);
778 } catch (XMLSchemaException se) {
779 reportSchemaError(ELE_ERROR_CODES[referType],
780 new Object[]{locationHint},
781 schemaRoot);
782 return null;
783 }
784 // targetNamespace="" is not valid, issue a warning, and ignore it
785 if (currSchemaInfo.fTargetNamespace != null &&
786 currSchemaInfo.fTargetNamespace.length() == 0) {
787 reportSchemaWarning("EmptyTargetNamespace",
788 new Object[]{locationHint},
789 schemaRoot);
790 currSchemaInfo.fTargetNamespace = null;
791 }
792
793 if (callerTNS != null) {
794 // the second index to the NS_ERROR_CODES array
795 // if the caller/expected NS is not absent, we use the first column
796 int secondIdx = 0;
797 // for include and redefine
798 if (referType == XSDDescription.CONTEXT_INCLUDE ||
799 referType == XSDDescription.CONTEXT_REDEFINE) {
800 // if the referred document has no targetNamespace,
801 // it's a chameleon schema
802 if (currSchemaInfo.fTargetNamespace == null) {
803 currSchemaInfo.fTargetNamespace = callerTNS;
804 currSchemaInfo.fIsChameleonSchema = true;
805 }
806 // if the referred document has a target namespace differing
807 // from the caller, it's an error
808 else if (callerTNS != currSchemaInfo.fTargetNamespace) {
809 reportSchemaError(NS_ERROR_CODES[referType][secondIdx],
810 new Object [] {callerTNS, currSchemaInfo.fTargetNamespace},
811 schemaRoot);
812 return null;
813 }
814 }
815 // for instance and import, the two NS's must be the same
816 else if (referType != XSDDescription.CONTEXT_PREPARSE && callerTNS != currSchemaInfo.fTargetNamespace) {
817 reportSchemaError(NS_ERROR_CODES[referType][secondIdx],
818 new Object [] {callerTNS, currSchemaInfo.fTargetNamespace},
819 schemaRoot);
820 return null;
821 }
822 }
823 // now there is no caller/expected NS, it's an error for the referred
824 // document to have a target namespace, unless we are preparsing a schema
825 else if (currSchemaInfo.fTargetNamespace != null) {
826 // set the target namespace of the description
827 if (referType == XSDDescription.CONTEXT_PREPARSE) {
828 desc.setTargetNamespace(currSchemaInfo.fTargetNamespace);
829 callerTNS = currSchemaInfo.fTargetNamespace;
830 }
831 else {
832 // the second index to the NS_ERROR_CODES array
833 // if the caller/expected NS is absent, we use the second column
834 int secondIdx = 1;
835 reportSchemaError(NS_ERROR_CODES[referType][secondIdx],
836 new Object [] {callerTNS, currSchemaInfo.fTargetNamespace},
837 schemaRoot);
838 return null;
839 }
840 }
841 // the other cases (callerTNS == currSchemaInfo.fTargetNamespce == null)
842 // are valid
843
844 // a schema document can always access it's own target namespace
845 currSchemaInfo.addAllowedNS(currSchemaInfo.fTargetNamespace);
846
847 SchemaGrammar sg = null;
848
849 // we have a namespace collision
850 if (nsCollision) {
851 SchemaGrammar sg2 = fGrammarBucket.getGrammar(currSchemaInfo.fTargetNamespace);
852 if (sg2.isImmutable()) {
853 sg = new SchemaGrammar(sg2);
854 fGrammarBucket.putGrammar(sg);
855 // update all the grammars in the bucket to point to the new grammar.
856 updateImportListWith(sg);
857 }
858 else {
859 sg = sg2;
860 }
861
862 // update import list of the new grammar
863 updateImportListFor(sg);
864 }
865 else if (referType == XSDDescription.CONTEXT_INCLUDE ||
866 referType == XSDDescription.CONTEXT_REDEFINE) {
867 sg = fGrammarBucket.getGrammar(currSchemaInfo.fTargetNamespace);
868 }
869 else if(fHonourAllSchemaLocations && referType == XSDDescription.CONTEXT_IMPORT) {
870 sg = findGrammar(desc, false);
871 if(sg == null) {
872 sg = new SchemaGrammar(currSchemaInfo.fTargetNamespace, desc.makeClone(), fSymbolTable);
873 fGrammarBucket.putGrammar(sg);
874 }
875 }
876 else {
877 sg = new SchemaGrammar(currSchemaInfo.fTargetNamespace, desc.makeClone(), fSymbolTable);
878 fGrammarBucket.putGrammar(sg);
879 }
880
881 // store the document and its location
882 // REVISIT: don't expose the DOM tree
883 sg.addDocument(null, (String)fDoc2SystemId.get(currSchemaInfo.fSchemaElement));
884
885 fDoc2XSDocumentMap.put(schemaRoot, currSchemaInfo);
886 Vector dependencies = new Vector();
887 Element rootNode = schemaRoot;
888
889 Element newSchemaRoot = null;
890 for (Element child = DOMUtil.getFirstChildElement(rootNode);
891 child != null;
892 child = DOMUtil.getNextSiblingElement(child)) {
893 String schemaNamespace=null;
894 String schemaHint=null;
895 String localName = DOMUtil.getLocalName(child);
896
897 short refType = -1;
898 boolean importCollision = false;
899
900 if (localName.equals(SchemaSymbols.ELT_ANNOTATION))
901 continue;
902 else if (localName.equals(SchemaSymbols.ELT_IMPORT)) {
903 refType = XSDDescription.CONTEXT_IMPORT;
904 // have to handle some validation here too!
905 // call XSAttributeChecker to fill in attrs
906 Object[] importAttrs = fAttributeChecker.checkAttributes(child, true, currSchemaInfo);
907 schemaHint = (String)importAttrs[XSAttributeChecker.ATTIDX_SCHEMALOCATION];
908 schemaNamespace = (String)importAttrs[XSAttributeChecker.ATTIDX_NAMESPACE];
909 if (schemaNamespace != null)
910 schemaNamespace = fSymbolTable.addSymbol(schemaNamespace);
911
912 // check contents and process optional annotations
913 Element importChild = DOMUtil.getFirstChildElement(child);
914 if(importChild != null ) {
915 String importComponentType = DOMUtil.getLocalName(importChild);
916 if (importComponentType.equals(SchemaSymbols.ELT_ANNOTATION)) {
917 // promoting annotations to parent component
918 sg.addAnnotation(
919 fElementTraverser.traverseAnnotationDecl(importChild, importAttrs, true, currSchemaInfo));
920 } else {
921 reportSchemaError("s4s-elt-must-match.1", new Object [] {localName, "annotation?", importComponentType}, child);
922 }
923 if(DOMUtil.getNextSiblingElement(importChild) != null) {
924 reportSchemaError("s4s-elt-must-match.1", new Object [] {localName, "annotation?", DOMUtil.getLocalName(DOMUtil.getNextSiblingElement(importChild))}, child);
925 }
926 }
927 else {
928 String text = DOMUtil.getSyntheticAnnotation(child);
929 if (text != null) {
930 sg.addAnnotation(fElementTraverser.traverseSyntheticAnnotation(child, text, importAttrs, true, currSchemaInfo));
931 }
932 }
933 fAttributeChecker.returnAttrArray(importAttrs, currSchemaInfo);
934
935 // a document can't import another document with the same namespace
936 if (schemaNamespace == currSchemaInfo.fTargetNamespace) {
937 reportSchemaError(schemaNamespace != null ?
938 "src-import.1.1" : "src-import.1.2", new Object [] {schemaNamespace}, child);
939 continue;
940 }
941
942 // if this namespace has not been imported by this document,
943 // then import if multiple imports support is enabled.
944 if(currSchemaInfo.isAllowedNS(schemaNamespace)) {
945 if(!fHonourAllSchemaLocations && !fNamespaceGrowth)
946 continue;
947 }
948 else {
949 currSchemaInfo.addAllowedNS(schemaNamespace);
950 }
951 // also record the fact that one namespace imports another one
952 // convert null to ""
953 String tns = null2EmptyString(currSchemaInfo.fTargetNamespace);
954 // get all namespaces imported by this one
955 Vector ins = (Vector)fImportMap.get(tns);
956 // if no namespace was imported, create new Vector
957 if (ins == null) {
958 // record that this one imports other(s)
959 fAllTNSs.addElement(tns);
960 ins = new Vector();
961 fImportMap.put(tns, ins);
962 ins.addElement(schemaNamespace);
963 }
964 else if (!ins.contains(schemaNamespace)){
965 ins.addElement(schemaNamespace);
966 }
967
968 fSchemaGrammarDescription.reset();
969 fSchemaGrammarDescription.setContextType(XSDDescription.CONTEXT_IMPORT);
970 fSchemaGrammarDescription.setBaseSystemId(doc2SystemId(schemaRoot));
971 fSchemaGrammarDescription.setLiteralSystemId(schemaHint);
972 fSchemaGrammarDescription.setLocationHints(new String[]{schemaHint});
973 fSchemaGrammarDescription.setTargetNamespace(schemaNamespace);
974
975 // if a grammar with the same namespace and location exists (or being
976 // built), ignore this one (don't traverse it).
977 SchemaGrammar isg = findGrammar(fSchemaGrammarDescription, fNamespaceGrowth);
978 if (isg != null) {
979 if (fNamespaceGrowth) {
980 try {
981 if (isg.getDocumentLocations().contains(XMLEntityManager.expandSystemId(schemaHint, fSchemaGrammarDescription.getBaseSystemId(), false))) {
982 continue;
983 }
984 else {
985 importCollision = true;
986 }
987 }
988 catch (MalformedURIException e) {
989 }
990 }
991 else if (!fHonourAllSchemaLocations || isExistingGrammar(fSchemaGrammarDescription, false)) {
992 continue;
993 }
994 }
995 //if ((!fHonourAllSchemaLocations && findGrammar(fSchemaGrammarDescription) != null) || isExistingGrammar(fSchemaGrammarDescription))
996 // continue;
997
998 // If "findGrammar" returns a grammar, then this is not the
999 // the first time we see a location for a given namespace.
1000 // Don't consult the location pair map in this case,
1001 // otherwise the location will be ignored because it'll get
1002 // resolved to the same location as the first hint.
1003 newSchemaRoot = resolveSchema(fSchemaGrammarDescription, false, child, isg == null);
1004 }
1005 else if ((localName.equals(SchemaSymbols.ELT_INCLUDE)) ||
1006 (localName.equals(SchemaSymbols.ELT_REDEFINE))) {
1007 // validation for redefine/include will be the same here; just
1008 // make sure TNS is right (don't care about redef contents
1009 // yet).
1010 Object[] includeAttrs = fAttributeChecker.checkAttributes(child, true, currSchemaInfo);
1011 schemaHint = (String)includeAttrs[XSAttributeChecker.ATTIDX_SCHEMALOCATION];
1012 // store the namespace decls of the redefine element
1013 if (localName.equals(SchemaSymbols.ELT_REDEFINE)) {
1014 if (fRedefine2NSSupport == null) fRedefine2NSSupport = new HashMap();
1015 fRedefine2NSSupport.put(child, new SchemaNamespaceSupport(currSchemaInfo.fNamespaceSupport));
1016 }
1017
1018 // check annotations. Must do this here to avoid having to
1019 // re-parse attributes later
1020 if(localName.equals(SchemaSymbols.ELT_INCLUDE)) {
1021 Element includeChild = DOMUtil.getFirstChildElement(child);
1022 if(includeChild != null ) {
1023 String includeComponentType = DOMUtil.getLocalName(includeChild);
1024 if (includeComponentType.equals(SchemaSymbols.ELT_ANNOTATION)) {
1025 // promoting annotations to parent component
1026 sg.addAnnotation(
1027 fElementTraverser.traverseAnnotationDecl(includeChild, includeAttrs, true, currSchemaInfo));
1028 } else {
1029 reportSchemaError("s4s-elt-must-match.1", new Object [] {localName, "annotation?", includeComponentType}, child);
1030 }
1031 if(DOMUtil.getNextSiblingElement(includeChild) != null) {
1032 reportSchemaError("s4s-elt-must-match.1", new Object [] {localName, "annotation?", DOMUtil.getLocalName(DOMUtil.getNextSiblingElement(includeChild))}, child);
1033 }
1034 }
1035 else {
1036 String text = DOMUtil.getSyntheticAnnotation(child);
1037 if (text != null) {
1038 sg.addAnnotation(fElementTraverser.traverseSyntheticAnnotation(child, text, includeAttrs, true, currSchemaInfo));
1039 }
1040 }
1041 }
1042 else {
1043 for (Element redefinedChild = DOMUtil.getFirstChildElement(child);
1044 redefinedChild != null;
1045 redefinedChild = DOMUtil.getNextSiblingElement(redefinedChild)) {
1046 String redefinedComponentType = DOMUtil.getLocalName(redefinedChild);
1047 if (redefinedComponentType.equals(SchemaSymbols.ELT_ANNOTATION)) {
1048 // promoting annotations to parent component
1049 sg.addAnnotation(
1050 fElementTraverser.traverseAnnotationDecl(redefinedChild, includeAttrs, true, currSchemaInfo));
1051 DOMUtil.setHidden(redefinedChild, fHiddenNodes);
1052 }
1053 else {
1054 String text = DOMUtil.getSyntheticAnnotation(child);
1055 if (text != null) {
1056 sg.addAnnotation(fElementTraverser.traverseSyntheticAnnotation(child, text, includeAttrs, true, currSchemaInfo));
1057 }
1058 }
1059 // catch all other content errors later
1060 }
1061 }
1062 fAttributeChecker.returnAttrArray(includeAttrs, currSchemaInfo);
1063 // schemaLocation is required on <include> and <redefine>
1064 if (schemaHint == null) {
1065 reportSchemaError("s4s-att-must-appear", new Object [] {
1066 "<include> or <redefine>", "schemaLocation"},
1067 child);
1068 }
1069 // pass the systemId of the current document as the base systemId
1070 boolean mustResolve = false;
1071 refType = XSDDescription.CONTEXT_INCLUDE;
1072 if(localName.equals(SchemaSymbols.ELT_REDEFINE)) {
1073 mustResolve = nonAnnotationContent(child);
1074 refType = XSDDescription.CONTEXT_REDEFINE;
1075 }
1076 fSchemaGrammarDescription.reset();
1077 fSchemaGrammarDescription.setContextType(refType);
1078 fSchemaGrammarDescription.setBaseSystemId(doc2SystemId(schemaRoot));
1079 fSchemaGrammarDescription.setLocationHints(new String[]{schemaHint});
1080 fSchemaGrammarDescription.setTargetNamespace(callerTNS);
1081
1082 boolean alreadyTraversed = false;
1083 XMLInputSource schemaSource = resolveSchemaSource(fSchemaGrammarDescription, mustResolve, child, true);
1084 if (fNamespaceGrowth && refType == XSDDescription.CONTEXT_INCLUDE) {
1085 try {
1086 final String schemaId = XMLEntityManager.expandSystemId(schemaSource.getSystemId(), schemaSource.getBaseSystemId(), false);
1087 alreadyTraversed = sg.getDocumentLocations().contains(schemaId);
1088 }
1089 catch(MalformedURIException e) {
1090
1091 }
1092 }
1093
1094 if (!alreadyTraversed) {
1095 newSchemaRoot = resolveSchema(schemaSource, fSchemaGrammarDescription, mustResolve, child);
1096 schemaNamespace = currSchemaInfo.fTargetNamespace;
1097 }
1098 else {
1099 fLastSchemaWasDuplicate = true;
1100 }
1101 }
1102 else {
1103 // no more possibility of schema references in well-formed
1104 // schema...
1105 break;
1106 }
1107
1108 // If the schema is duplicate, we needn't call constructTrees() again.
1109 // To handle mutual <include>s
1110 XSDocumentInfo newSchemaInfo = null;
1111 if (fLastSchemaWasDuplicate) {
1112 newSchemaInfo = newSchemaRoot == null ? null : (XSDocumentInfo)fDoc2XSDocumentMap.get(newSchemaRoot);
1113 }
1114 else {
1115 newSchemaInfo = constructTrees(newSchemaRoot, schemaHint, fSchemaGrammarDescription, importCollision);
1116 }
1117
1118 if (localName.equals(SchemaSymbols.ELT_REDEFINE) &&
1119 newSchemaInfo != null) {
1120 // must record which schema we're redefining so that we can
1121 // rename the right things later!
1122 if (fRedefine2XSDMap == null) fRedefine2XSDMap = new HashMap();
1123 fRedefine2XSDMap.put(child, newSchemaInfo);
1124 }
1125 if (newSchemaRoot != null) {
1126 if (newSchemaInfo != null)
1127 dependencies.addElement(newSchemaInfo);
1128 newSchemaRoot = null;
1129 }
1130 }
1131
1132 fDependencyMap.put(currSchemaInfo, dependencies);
1133 return currSchemaInfo;
1134 } // end constructTrees
1135
1136 private boolean isExistingGrammar(XSDDescription desc, boolean ignoreConflict) {
1137 SchemaGrammar sg = fGrammarBucket.getGrammar(desc.getTargetNamespace());
1138 if (sg == null) {
1139 return findGrammar(desc, ignoreConflict) != null;
1140 }
1141 else if (sg.isImmutable()) {
1142 return true;
1143 }
1144 else {
1145 try {
1146 return sg.getDocumentLocations().contains(XMLEntityManager.expandSystemId(desc.getLiteralSystemId(), desc.getBaseSystemId(), false));
1147 }
1148 catch (MalformedURIException e) {
1149 return false;
1150 }
1151 }
1152 }
1153
1154 /**
1155 * Namespace growth
1156 *
1157 * Go through the import list of a given grammar and for each imported
1158 * grammar, check to see if the grammar bucket has a newer version.
1159 * If a new instance is found, we update the import list with the
1160 * newer version.
1161 */
1162 private void updateImportListFor(SchemaGrammar grammar) {
1163 Vector importedGrammars = grammar.getImportedGrammars();
1164 if (importedGrammars != null) {
1165 for (int i=0; i<importedGrammars.size(); i++) {
1166 SchemaGrammar isg1 = (SchemaGrammar) importedGrammars.elementAt(i);
1167 SchemaGrammar isg2 = fGrammarBucket.getGrammar(isg1.getTargetNamespace());
1168 if (isg2 != null && isg1 != isg2) {
1169 importedGrammars.set(i, isg2);
1170 }
1171 }
1172 }
1173 }
1174
1175 /**
1176 * Namespace growth
1177 *
1178 * Go throuth the grammar bucket, and for each grammar in the bucket
1179 * check the import list. If there exists a grammar in import list
1180 * that has the same namespace as newGrammar, but a different instance,
1181 * then update the import list and replace the old grammar instance with
1182 * the new one
1183 */
1184 private void updateImportListWith(SchemaGrammar newGrammar) {
1185 SchemaGrammar[] schemaGrammars = fGrammarBucket.getGrammars();
1186 for (int i = 0; i < schemaGrammars.length; ++i) {
1187 SchemaGrammar sg = schemaGrammars[i];
1188 if (sg != newGrammar) {
1189 Vector importedGrammars = sg.getImportedGrammars();
1190 if (importedGrammars != null) {
1191 for (int j=0; j<importedGrammars.size(); j++) {
1192 SchemaGrammar isg = (SchemaGrammar) importedGrammars.elementAt(j);
1193 if (null2EmptyString(isg.getTargetNamespace()).equals(null2EmptyString(newGrammar.getTargetNamespace()))) {
1194 if (isg != newGrammar) {
1195 importedGrammars.set(j, newGrammar);
1196 }
1197 break;
1198 }
1199 }
1200 }
1201 }
1202 }
1203 }
1204
1205 // This method builds registries for all globally-referenceable
1206 // names. A registry will be built for each symbol space defined
1207 // by the spec. It is also this method's job to rename redefined
1208 // components, and to record which components redefine others (so
1209 // that implicit redefinitions of groups and attributeGroups can be handled).
1210 protected void buildGlobalNameRegistries() {
1211
1212 registryEmpty = false;
1213 // Starting with fRoot, we examine each child of the schema
1214 // element. Skipping all imports and includes, we record the names
1215 // of all other global components (and children of <redefine>). We
1216 // also put <redefine> names in a registry that we look through in
1217 // case something needs renaming. Once we're done with a schema we
1218 // set its Document node to hidden so that we don't try to traverse
1219 // it again; then we look to its Dependency map entry. We keep a
1220 // stack of schemas that we haven't yet finished processing; this
1221 // is a depth-first traversal.
1222
1223 Stack schemasToProcess = new Stack();
1224 schemasToProcess.push(fRoot);
1225
1226 while (!schemasToProcess.empty()) {
1227 XSDocumentInfo currSchemaDoc =
1228 (XSDocumentInfo)schemasToProcess.pop();
1229 Element currDoc = currSchemaDoc.fSchemaElement;
1230 if(DOMUtil.isHidden(currDoc, fHiddenNodes)){
1231 // must have processed this already!
1232 continue;
1233 }
1234
1235 Element currRoot = currDoc;
1236 // process this schema's global decls
1237 boolean dependenciesCanOccur = true;
1238 for (Element globalComp =
1239 DOMUtil.getFirstChildElement(currRoot);
1240 globalComp != null;
1241 globalComp = DOMUtil.getNextSiblingElement(globalComp)) {
1242 // this loop makes sure the <schema> element ordering is
1243 // also valid.
1244 if (DOMUtil.getLocalName(globalComp).equals(SchemaSymbols.ELT_ANNOTATION)) {
1245 //skip it; traverse it later
1246 continue;
1247 }
1248 else if (DOMUtil.getLocalName(globalComp).equals(SchemaSymbols.ELT_INCLUDE) ||
1249 DOMUtil.getLocalName(globalComp).equals(SchemaSymbols.ELT_IMPORT)) {
1250 if (!dependenciesCanOccur) {
1251 reportSchemaError("s4s-elt-invalid-content.3", new Object [] {DOMUtil.getLocalName(globalComp)}, globalComp);
1252 }
1253 DOMUtil.setHidden(globalComp, fHiddenNodes);
1254 }
1255 else if (DOMUtil.getLocalName(globalComp).equals(SchemaSymbols.ELT_REDEFINE)) {
1256 if (!dependenciesCanOccur) {
1257 reportSchemaError("s4s-elt-invalid-content.3", new Object [] {DOMUtil.getLocalName(globalComp)}, globalComp);
1258 }
1259 for (Element redefineComp = DOMUtil.getFirstChildElement(globalComp);
1260 redefineComp != null;
1261 redefineComp = DOMUtil.getNextSiblingElement(redefineComp)) {
1262 String lName = DOMUtil.getAttrValue(redefineComp, SchemaSymbols.ATT_NAME);
1263 if (lName.length() == 0) // an error we'll catch later
1264 continue;
1265 String qName = currSchemaDoc.fTargetNamespace == null ?
1266 ","+lName:
1267 currSchemaDoc.fTargetNamespace +","+lName;
1268 String componentType = DOMUtil.getLocalName(redefineComp);
1269 if (componentType.equals(SchemaSymbols.ELT_ATTRIBUTEGROUP)) {
1270 checkForDuplicateNames(qName, ATTRIBUTEGROUP_TYPE, fUnparsedAttributeGroupRegistry, fUnparsedAttributeGroupRegistrySub, redefineComp, currSchemaDoc);
1271 // the check will have changed our name;
1272 String targetLName = DOMUtil.getAttrValue(redefineComp, SchemaSymbols.ATT_NAME)+REDEF_IDENTIFIER;
1273 // and all we need to do is error-check+rename our kkids:
1274 renameRedefiningComponents(currSchemaDoc, redefineComp, SchemaSymbols.ELT_ATTRIBUTEGROUP,
1275 lName, targetLName);
1276 }
1277 else if ((componentType.equals(SchemaSymbols.ELT_COMPLEXTYPE)) ||
1278 (componentType.equals(SchemaSymbols.ELT_SIMPLETYPE))) {
1279 checkForDuplicateNames(qName, TYPEDECL_TYPE, fUnparsedTypeRegistry, fUnparsedTypeRegistrySub, redefineComp, currSchemaDoc);
1280 // the check will have changed our name;
1281 String targetLName = DOMUtil.getAttrValue(redefineComp, SchemaSymbols.ATT_NAME) + REDEF_IDENTIFIER;
1282 // and all we need to do is error-check+rename our kkids:
1283 if (componentType.equals(SchemaSymbols.ELT_COMPLEXTYPE)) {
1284 renameRedefiningComponents(currSchemaDoc, redefineComp, SchemaSymbols.ELT_COMPLEXTYPE,
1285 lName, targetLName);
1286 }
1287 else { // must be simpleType
1288 renameRedefiningComponents(currSchemaDoc, redefineComp, SchemaSymbols.ELT_SIMPLETYPE,
1289 lName, targetLName);
1290 }
1291 }
1292 else if (componentType.equals(SchemaSymbols.ELT_GROUP)) {
1293 checkForDuplicateNames(qName, GROUP_TYPE, fUnparsedGroupRegistry, fUnparsedGroupRegistrySub, redefineComp, currSchemaDoc);
1294 // the check will have changed our name;
1295 String targetLName = DOMUtil.getAttrValue(redefineComp, SchemaSymbols.ATT_NAME)+REDEF_IDENTIFIER;
1296 // and all we need to do is error-check+rename our kids:
1297 renameRedefiningComponents(currSchemaDoc, redefineComp, SchemaSymbols.ELT_GROUP,
1298 lName, targetLName);
1299 }
1300 } // end march through <redefine> children
1301 // and now set as traversed
1302 //DOMUtil.setHidden(globalComp);
1303 }
1304 else {
1305 dependenciesCanOccur = false;
1306 String lName = DOMUtil.getAttrValue(globalComp, SchemaSymbols.ATT_NAME);
1307 if (lName.length() == 0) // an error we'll catch later
1308 continue;
1309 String qName = currSchemaDoc.fTargetNamespace == null?
1310 ","+lName:
1311 currSchemaDoc.fTargetNamespace +","+lName;
1312 String componentType = DOMUtil.getLocalName(globalComp);
1313
1314 if (componentType.equals(SchemaSymbols.ELT_ATTRIBUTE)) {
1315 checkForDuplicateNames(qName, ATTRIBUTE_TYPE, fUnparsedAttributeRegistry, fUnparsedAttributeRegistrySub, globalComp, currSchemaDoc);
1316 }
1317 else if (componentType.equals(SchemaSymbols.ELT_ATTRIBUTEGROUP)) {
1318 checkForDuplicateNames(qName, ATTRIBUTEGROUP_TYPE, fUnparsedAttributeGroupRegistry, fUnparsedAttributeGroupRegistrySub, globalComp, currSchemaDoc);
1319 }
1320 else if ((componentType.equals(SchemaSymbols.ELT_COMPLEXTYPE)) ||
1321 (componentType.equals(SchemaSymbols.ELT_SIMPLETYPE))) {
1322 checkForDuplicateNames(qName, TYPEDECL_TYPE, fUnparsedTypeRegistry, fUnparsedTypeRegistrySub, globalComp, currSchemaDoc);
1323 }
1324 else if (componentType.equals(SchemaSymbols.ELT_ELEMENT)) {
1325 checkForDuplicateNames(qName, ELEMENT_TYPE, fUnparsedElementRegistry, fUnparsedElementRegistrySub, globalComp, currSchemaDoc);
1326 }
1327 else if (componentType.equals(SchemaSymbols.ELT_GROUP)) {
1328 checkForDuplicateNames(qName, GROUP_TYPE, fUnparsedGroupRegistry, fUnparsedGroupRegistrySub, globalComp, currSchemaDoc);
1329 }
1330 else if (componentType.equals(SchemaSymbols.ELT_NOTATION)) {
1331 checkForDuplicateNames(qName, NOTATION_TYPE, fUnparsedNotationRegistry, fUnparsedNotationRegistrySub, globalComp, currSchemaDoc);
1332 }
1333 }
1334 } // end for
1335
1336 // now we're done with this one!
1337 DOMUtil.setHidden(currDoc, fHiddenNodes);
1338 // now add the schemas this guy depends on
1339 Vector currSchemaDepends = (Vector)fDependencyMap.get(currSchemaDoc);
1340 for (int i = 0; i < currSchemaDepends.size(); i++) {
1341 schemasToProcess.push(currSchemaDepends.elementAt(i));
1342 }
1343 } // while
1344
1345 } // end buildGlobalNameRegistries
1346
1347 // Beginning at the first schema processing was requested for
1348 // (fRoot), this method
1349 // examines each child (global schema information item) of each
1350 // schema document (and of each <redefine> element)
1351 // corresponding to an XSDocumentInfo object. If the
1352 // readOnly field on that node has not been set, it calls an
1353 // appropriate traverser to traverse it. Once all global decls in
1354 // an XSDocumentInfo object have been traversed, it marks that object
1355 // as traversed (or hidden) in order to avoid infinite loops. It completes
1356 // when it has visited all XSDocumentInfo objects in the
1357 // DependencyMap and marked them as traversed.
1358 protected void traverseSchemas(ArrayList annotationInfo) {
1359 // the process here is very similar to that in
1360 // buildGlobalRegistries, except we can't set our schemas as
1361 // hidden for a second time; so make them all visible again
1362 // first!
1363 setSchemasVisible(fRoot);
1364 Stack schemasToProcess = new Stack();
1365 schemasToProcess.push(fRoot);
1366 while (!schemasToProcess.empty()) {
1367 XSDocumentInfo currSchemaDoc =
1368 (XSDocumentInfo)schemasToProcess.pop();
1369 Element currDoc = currSchemaDoc.fSchemaElement;
1370
1371 SchemaGrammar currSG = fGrammarBucket.getGrammar(currSchemaDoc.fTargetNamespace);
1372
1373 if(DOMUtil.isHidden(currDoc, fHiddenNodes)) {
1374 // must have processed this already!
1375 continue;
1376 }
1377 Element currRoot = currDoc;
1378 boolean sawAnnotation = false;
1379 // traverse this schema's global decls
1380 for (Element globalComp =
1381 DOMUtil.getFirstVisibleChildElement(currRoot, fHiddenNodes);
1382 globalComp != null;
1383 globalComp = DOMUtil.getNextVisibleSiblingElement(globalComp, fHiddenNodes)) {
1384 DOMUtil.setHidden(globalComp, fHiddenNodes);
1385 String componentType = DOMUtil.getLocalName(globalComp);
1386 // includes and imports will not show up here!
1387 if (DOMUtil.getLocalName(globalComp).equals(SchemaSymbols.ELT_REDEFINE)) {
1388 // use the namespace decls for the redefine, instead of for the parent <schema>
1389 currSchemaDoc.backupNSSupport((fRedefine2NSSupport!=null)?(SchemaNamespaceSupport)fRedefine2NSSupport.get(globalComp):null);
1390 for (Element redefinedComp = DOMUtil.getFirstVisibleChildElement(globalComp, fHiddenNodes);
1391 redefinedComp != null;
1392 redefinedComp = DOMUtil.getNextVisibleSiblingElement(redefinedComp, fHiddenNodes)) {
1393 String redefinedComponentType = DOMUtil.getLocalName(redefinedComp);
1394 DOMUtil.setHidden(redefinedComp, fHiddenNodes);
1395 if (redefinedComponentType.equals(SchemaSymbols.ELT_ATTRIBUTEGROUP)) {
1396 fAttributeGroupTraverser.traverseGlobal(redefinedComp, currSchemaDoc, currSG);
1397 }
1398 else if (redefinedComponentType.equals(SchemaSymbols.ELT_COMPLEXTYPE)) {
1399 fComplexTypeTraverser.traverseGlobal(redefinedComp, currSchemaDoc, currSG);
1400 }
1401 else if (redefinedComponentType.equals(SchemaSymbols.ELT_GROUP)) {
1402 fGroupTraverser.traverseGlobal(redefinedComp, currSchemaDoc, currSG);
1403 }
1404 else if (redefinedComponentType.equals(SchemaSymbols.ELT_SIMPLETYPE)) {
1405 fSimpleTypeTraverser.traverseGlobal(redefinedComp, currSchemaDoc, currSG);
1406 }
1407 // annotations will have been processed already; this is now
1408 // unnecessary
1409 //else if (redefinedComponentType.equals(SchemaSymbols.ELT_ANNOTATION)) {
1410 // fElementTraverser.traverseAnnotationDecl(redefinedComp, null, true, currSchemaDoc);
1411 //}
1412 else {
1413 reportSchemaError("s4s-elt-must-match.1", new Object [] {DOMUtil.getLocalName(globalComp), "(annotation | (simpleType | complexType | group | attributeGroup))*", redefinedComponentType}, redefinedComp);
1414 }
1415 } // end march through <redefine> children
1416 currSchemaDoc.restoreNSSupport();
1417 }
1418 else if (componentType.equals(SchemaSymbols.ELT_ATTRIBUTE)) {
1419 fAttributeTraverser.traverseGlobal(globalComp, currSchemaDoc, currSG);
1420 }
1421 else if (componentType.equals(SchemaSymbols.ELT_ATTRIBUTEGROUP)) {
1422 fAttributeGroupTraverser.traverseGlobal(globalComp, currSchemaDoc, currSG);
1423 }
1424 else if (componentType.equals(SchemaSymbols.ELT_COMPLEXTYPE)) {
1425 fComplexTypeTraverser.traverseGlobal(globalComp, currSchemaDoc, currSG);
1426 }
1427 else if (componentType.equals(SchemaSymbols.ELT_ELEMENT)) {
1428 fElementTraverser.traverseGlobal(globalComp, currSchemaDoc, currSG);
1429 }
1430 else if (componentType.equals(SchemaSymbols.ELT_GROUP)) {
1431 fGroupTraverser.traverseGlobal(globalComp, currSchemaDoc, currSG);
1432 }
1433 else if (componentType.equals(SchemaSymbols.ELT_NOTATION)) {
1434 fNotationTraverser.traverse(globalComp, currSchemaDoc, currSG);
1435 }
1436 else if (componentType.equals(SchemaSymbols.ELT_SIMPLETYPE)) {
1437 fSimpleTypeTraverser.traverseGlobal(globalComp, currSchemaDoc, currSG);
1438 }
1439 else if (componentType.equals(SchemaSymbols.ELT_ANNOTATION)) {
1440 currSG.addAnnotation(fElementTraverser.traverseAnnotationDecl(globalComp, currSchemaDoc.getSchemaAttrs(), true, currSchemaDoc));
1441 sawAnnotation = true;
1442 }
1443 else {
1444 reportSchemaError("s4s-elt-invalid-content.1", new Object [] {SchemaSymbols.ELT_SCHEMA, DOMUtil.getLocalName(globalComp)}, globalComp);
1445 }
1446 } // end for
1447
1448 if (!sawAnnotation) {
1449 String text = DOMUtil.getSyntheticAnnotation(currRoot);
1450 if (text != null) {
1451 currSG.addAnnotation(fElementTraverser.traverseSyntheticAnnotation(currRoot, text, currSchemaDoc.getSchemaAttrs(), true, currSchemaDoc));
1452 }
1453 }
1454
1455 /** Collect annotation information for validation. **/
1456 if (annotationInfo != null) {
1457 XSAnnotationInfo info = currSchemaDoc.getAnnotations();
1458 /** Only add annotations to the list if there were any in this document. **/
1459 if (info != null) {
1460 annotationInfo.add(doc2SystemId(currDoc));
1461 annotationInfo.add(info);
1462 }
1463 }
1464 // now we're done with this one!
1465 currSchemaDoc.returnSchemaAttrs();
1466 DOMUtil.setHidden(currDoc, fHiddenNodes);
1467
1468 // now add the schemas this guy depends on
1469 Vector currSchemaDepends = (Vector)fDependencyMap.get(currSchemaDoc);
1470 for (int i = 0; i < currSchemaDepends.size(); i++) {
1471 schemasToProcess.push(currSchemaDepends.elementAt(i));
1472 }
1473 } // while
1474 } // end traverseSchemas
1475
1476 // store whether we have reported an error about that no grammar
1477 // is found for the given namespace uri
1478 private Vector fReportedTNS = null;
1479 // check whether we need to report an error against the given uri.
1480 // if we have reported an error, then we don't need to report again;
1481 // otherwise we reported the error, and remember this fact.
1482 private final boolean needReportTNSError(String uri) {
1483 if (fReportedTNS == null)
1484 fReportedTNS = new Vector();
1485 else if (fReportedTNS.contains(uri))
1486 return false;
1487 fReportedTNS.addElement(uri);
1488 return true;
1489 }
1490
1491 private static final String[] COMP_TYPE = {
1492 null, // index 0
1493 "attribute declaration",
1494 "attribute group",
1495 "element declaration",
1496 "group",
1497 "identity constraint",
1498 "notation",
1499 "type definition",
1500 };
1501
1502 private static final String[] CIRCULAR_CODES = {
1503 "Internal-Error",
1504 "Internal-Error",
1505 "src-attribute_group.3",
1506 "e-props-correct.6",
1507 "mg-props-correct.2",
1508 "Internal-Error",
1509 "Internal-Error",
1510 "st-props-correct.2", //or ct-props-correct.3
1511 };
1512
1513 // add a global attribute decl from a current schema load (only if no existing decl is found)
1514 void addGlobalAttributeDecl(XSAttributeDecl decl) {
1515 final String namespace = decl.getNamespace();
1516 final String declKey = (namespace == null || namespace.length() == 0)
1517 ? "," + decl.getName() : namespace + "," + decl.getName();
1518
1519 if (fGlobalAttrDecls.get(declKey) == null) {
1520 fGlobalAttrDecls.put(declKey, decl);
1521 }
1522 }
1523
1524 // add a global attribute group decl from a current schema load (only if no existing decl is found)
1525 void addGlobalAttributeGroupDecl(XSAttributeGroupDecl decl) {
1526 final String namespace = decl.getNamespace();
1527 final String declKey = (namespace == null || namespace.length() == 0)
1528 ? "," + decl.getName() : namespace + "," + decl.getName();
1529
1530 if (fGlobalAttrGrpDecls.get(declKey) == null) {
1531 fGlobalAttrGrpDecls.put(declKey, decl);
1532 }
1533 }
1534
1535 // add a global element decl from a current schema load (only if no existing decl is found)
1536 void addGlobalElementDecl(XSElementDecl decl) {
1537 final String namespace = decl.getNamespace();
1538 final String declKey = (namespace == null || namespace.length() == 0)
1539 ? "," + decl.getName() : namespace + "," + decl.getName();
1540
1541 if (fGlobalElemDecls.get(declKey) == null) {
1542 fGlobalElemDecls.put(declKey, decl);
1543 }
1544 }
1545
1546 // add a global group decl from a current schema load (only if no existing decl is found)
1547 void addGlobalGroupDecl(XSGroupDecl decl) {
1548 final String namespace = decl.getNamespace();
1549 final String declKey = (namespace == null || namespace.length() == 0)
1550 ? "," + decl.getName() : namespace + "," + decl.getName();
1551
1552 if (fGlobalGroupDecls.get(declKey) == null) {
1553 fGlobalGroupDecls.put(declKey, decl);
1554 }
1555 }
1556
1557 // add a global notation decl from a current schema load (only if no existing decl is found)
1558 void addGlobalNotationDecl(XSNotationDecl decl) {
1559 final String namespace = decl.getNamespace();
1560 final String declKey = (namespace == null || namespace.length() == 0)
1561 ? "," + decl.getName() : namespace + "," + decl.getName();
1562
1563 if (fGlobalNotationDecls.get(declKey) == null) {
1564 fGlobalNotationDecls.put(declKey, decl);
1565 }
1566 }
1567
1568 // add a global type decl from a current schema load (only if no existing decl is found)
1569 void addGlobalTypeDecl(XSTypeDefinition decl) {
1570 final String namespace = decl.getNamespace();
1571 final String declKey = (namespace == null || namespace.length() == 0)
1572 ? "," + decl.getName() : namespace + "," + decl.getName();
1573
1574 if (fGlobalTypeDecls.get(declKey) == null) {
1575 fGlobalTypeDecls.put(declKey, decl);
1576 }
1577 }
1578
1579 // add a identity constraint decl from a current schema load (only if no existing decl is found)
1580 void addIDConstraintDecl(IdentityConstraint decl) {
1581 final String namespace = decl.getNamespace();
1582 final String declKey = (namespace == null || namespace.length() == 0)
1583 ? "," + decl.getIdentityConstraintName() : namespace + "," + decl.getIdentityConstraintName();
1584
1585 if (fGlobalIDConstraintDecls.get(declKey) == null) {
1586 fGlobalIDConstraintDecls.put(declKey, decl);
1587 }
1588 }
1589
1590 private XSAttributeDecl getGlobalAttributeDecl(String declKey) {
1591 return (XSAttributeDecl)fGlobalAttrDecls.get(declKey);
1592 }
1593
1594 private XSAttributeGroupDecl getGlobalAttributeGroupDecl(String declKey) {
1595 return (XSAttributeGroupDecl)fGlobalAttrGrpDecls.get(declKey);
1596 }
1597
1598 private XSElementDecl getGlobalElementDecl(String declKey) {
1599 return (XSElementDecl)fGlobalElemDecls.get(declKey);
1600 }
1601
1602 private XSGroupDecl getGlobalGroupDecl(String declKey) {
1603 return (XSGroupDecl)fGlobalGroupDecls.get(declKey);
1604 }
1605
1606 private XSNotationDecl getGlobalNotationDecl(String declKey) {
1607 return (XSNotationDecl)fGlobalNotationDecls.get(declKey);
1608 }
1609
1610 private XSTypeDefinition getGlobalTypeDecl(String declKey) {
1611 return (XSTypeDefinition)fGlobalTypeDecls.get(declKey);
1612 }
1613
1614 private IdentityConstraint getIDConstraintDecl(String declKey) {
1615 return (IdentityConstraint)fGlobalIDConstraintDecls.get(declKey);
1616 }
1617
1618 // since it is forbidden for traversers to talk to each other
1619 // directly (except wen a traverser encounters a local declaration),
1620 // this provides a generic means for a traverser to call
1621 // for the traversal of some declaration. An XSDocumentInfo is
1622 // required because the XSDocumentInfo that the traverser is traversing
1623 // may bear no relation to the one the handler is operating on.
1624 // This method will:
1625 // 1. See if a global definition matching declToTraverse exists;
1626 // 2. if so, determine if there is a path from currSchema to the
1627 // schema document where declToTraverse lives (i.e., do a lookup
1628 // in DependencyMap);
1629 // 3. depending on declType (which will be relevant to step 1 as
1630 // well), call the appropriate traverser with the appropriate
1631 // XSDocumentInfo object.
1632 // This method returns whatever the traverser it called returned;
1633 // this will be an Object of some kind
1634 // that lives in the Grammar.
1635 protected Object getGlobalDecl(XSDocumentInfo currSchema,
1636 int declType,
1637 QName declToTraverse,
1638 Element elmNode) {
1639
1640 if (DEBUG_NODE_POOL) {
1641 System.out.println("TRAVERSE_GL: "+declToTraverse.toString());
1642 }
1643
1644 // from the schema spec, all built-in types are present in all schemas,
1645 // so if the requested component is a type, and could be found in the
1646 // default schema grammar, we should return that type.
1647 // otherwise (since we would support user-defined schema grammar) we'll
1648 // use the normal way to get the decl
1649 if (declToTraverse.uri != null &&
1650 declToTraverse.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA) {
1651 if (declType == TYPEDECL_TYPE) {
1652 Object retObj = SchemaGrammar.SG_SchemaNS.getGlobalTypeDecl(declToTraverse.localpart);
1653 if (retObj != null)
1654 return retObj;
1655 }
1656 }
1657
1658 // now check whether this document can access the requsted namespace
1659 if (!currSchema.isAllowedNS(declToTraverse.uri)) {
1660 // cannot get to this schema from the one containing the requesting decl
1661 if (currSchema.needReportTNSError(declToTraverse.uri)) {
1662 String code = declToTraverse.uri == null ? "src-resolve.4.1" : "src-resolve.4.2";
1663 reportSchemaError(code, new Object[]{fDoc2SystemId.get(currSchema.fSchemaElement), declToTraverse.uri, declToTraverse.rawname}, elmNode);
1664 }
1665 // Recover and continue to look for the component.
1666 // return null;
1667 }
1668
1669 // check whether there is grammar for the requested namespace
1670 SchemaGrammar sGrammar = fGrammarBucket.getGrammar(declToTraverse.uri);
1671 if (sGrammar == null) {
1672 if (needReportTNSError(declToTraverse.uri))
1673 reportSchemaError("src-resolve", new Object[]{declToTraverse.rawname, COMP_TYPE[declType]}, elmNode);
1674 return null;
1675 }
1676
1677 // if there is such grammar, check whether the requested component is in the grammar
1678 Object retObj = getGlobalDeclFromGrammar(sGrammar, declType, declToTraverse.localpart);
1679 String declKey = declToTraverse.uri == null? ","+declToTraverse.localpart:
1680 declToTraverse.uri+","+declToTraverse.localpart;
1681
1682 // if the component is parsed, return it
1683 if (!fTolerateDuplicates) {
1684 if (retObj != null) {
1685 return retObj;
1686 }
1687 }
1688 else {
1689 Object retObj2 = getGlobalDecl(declKey, declType);
1690 if (retObj2 != null) {
1691 return retObj2;
1692 }
1693 }
1694
1695 XSDocumentInfo schemaWithDecl = null;
1696 Element decl = null;
1697 XSDocumentInfo declDoc = null;
1698
1699 // the component is not parsed, try to find a DOM element for it
1700 switch (declType) {
1701 case ATTRIBUTE_TYPE :
1702 decl = getElementFromMap(fUnparsedAttributeRegistry, declKey);
1703 declDoc = getDocInfoFromMap(fUnparsedAttributeRegistrySub, declKey);
1704 break;
1705 case ATTRIBUTEGROUP_TYPE :
1706 decl = getElementFromMap(fUnparsedAttributeGroupRegistry, declKey);
1707 declDoc = getDocInfoFromMap(fUnparsedAttributeGroupRegistrySub, declKey);
1708 break;
1709 case ELEMENT_TYPE :
1710 decl = getElementFromMap(fUnparsedElementRegistry, declKey);
1711 declDoc = getDocInfoFromMap(fUnparsedElementRegistrySub, declKey);
1712 break;
1713 case GROUP_TYPE :
1714 decl = getElementFromMap(fUnparsedGroupRegistry, declKey);
1715 declDoc = getDocInfoFromMap(fUnparsedGroupRegistrySub, declKey);
1716 break;
1717 case IDENTITYCONSTRAINT_TYPE :
1718 decl = getElementFromMap(fUnparsedIdentityConstraintRegistry, declKey);
1719 declDoc = getDocInfoFromMap(fUnparsedIdentityConstraintRegistrySub, declKey);
1720 break;
1721 case NOTATION_TYPE :
1722 decl = getElementFromMap(fUnparsedNotationRegistry, declKey);
1723 declDoc = getDocInfoFromMap(fUnparsedNotationRegistrySub, declKey);
1724 break;
1725 case TYPEDECL_TYPE :
1726 decl = getElementFromMap(fUnparsedTypeRegistry, declKey);
1727 declDoc = getDocInfoFromMap(fUnparsedTypeRegistrySub, declKey);
1728 break;
1729 default:
1730 reportSchemaError("Internal-Error", new Object [] {"XSDHandler asked to locate component of type " + declType + "; it does not recognize this type!"}, elmNode);
1731 }
1732
1733 // no DOM element found, so the component can't be located
1734 if (decl == null) {
1735 if (retObj == null) {
1736 reportSchemaError("src-resolve", new Object[]{declToTraverse.rawname, COMP_TYPE[declType]}, elmNode);
1737 }
1738 return retObj;
1739 }
1740
1741 // get the schema doc containing the component to be parsed
1742 // it should always return non-null value, but since null-checking
1743 // comes for free, let's be safe and check again
1744 schemaWithDecl = findXSDocumentForDecl(currSchema, decl, declDoc);
1745 if (schemaWithDecl == null) {
1746 // cannot get to this schema from the one containing the requesting decl
1747 if (retObj == null) {
1748 String code = declToTraverse.uri == null ? "src-resolve.4.1" : "src-resolve.4.2";
1749 reportSchemaError(code, new Object[]{fDoc2SystemId.get(currSchema.fSchemaElement), declToTraverse.uri, declToTraverse.rawname}, elmNode);
1750 }
1751 return retObj;
1752 }
1753
1754 // a component is hidden, meaning either it's traversed, or being traversed.
1755 // but we didn't find it in the grammar, so it's the latter case, and
1756 // a circular reference. error!
1757 if (DOMUtil.isHidden(decl, fHiddenNodes)) {
1758 if (retObj == null) {
1759 String code = CIRCULAR_CODES[declType];
1760 if (declType == TYPEDECL_TYPE) {
1761 if (SchemaSymbols.ELT_COMPLEXTYPE.equals(DOMUtil.getLocalName(decl))) {
1762 code = "ct-props-correct.3";
1763 }
1764 }
1765 // decl must not be null if we're here...
1766 reportSchemaError(code, new Object [] {declToTraverse.prefix+":"+declToTraverse.localpart}, elmNode);
1767 }
1768 return retObj;
1769 }
1770
1771 return traverseGlobalDecl(declType, decl, schemaWithDecl, sGrammar);
1772 } // getGlobalDecl(XSDocumentInfo, int, QName): Object
1773
1774 // If we are tolerating duplicate declarations and allowing namespace growth
1775 // use the declaration from the current schema load (if it exists)
1776 protected Object getGlobalDecl(String declKey, int declType) {
1777 Object retObj = null;
1778
1779 switch (declType) {
1780 case ATTRIBUTE_TYPE :
1781 retObj = getGlobalAttributeDecl(declKey);
1782 break;
1783 case ATTRIBUTEGROUP_TYPE :
1784 retObj = getGlobalAttributeGroupDecl(declKey);
1785 break;
1786 case ELEMENT_TYPE :
1787 retObj = getGlobalElementDecl(declKey);
1788 break;
1789 case GROUP_TYPE :
1790 retObj = getGlobalGroupDecl(declKey);
1791 break;
1792 case IDENTITYCONSTRAINT_TYPE :
1793 retObj = getIDConstraintDecl(declKey);
1794 break;
1795 case NOTATION_TYPE :
1796 retObj = getGlobalNotationDecl(declKey);
1797 break;
1798 case TYPEDECL_TYPE :
1799 retObj = getGlobalTypeDecl(declKey);
1800 break;
1801 }
1802
1803 return retObj;
1804 }
1805
1806 protected Object getGlobalDeclFromGrammar(SchemaGrammar sGrammar, int declType, String localpart) {
1807 Object retObj = null;
1808
1809 switch (declType) {
1810 case ATTRIBUTE_TYPE :
1811 retObj = sGrammar.getGlobalAttributeDecl(localpart);
1812 break;
1813 case ATTRIBUTEGROUP_TYPE :
1814 retObj = sGrammar.getGlobalAttributeGroupDecl(localpart);
1815 break;
1816 case ELEMENT_TYPE :
1817 retObj = sGrammar.getGlobalElementDecl(localpart);
1818 break;
1819 case GROUP_TYPE :
1820 retObj = sGrammar.getGlobalGroupDecl(localpart);
1821 break;
1822 case IDENTITYCONSTRAINT_TYPE :
1823 retObj = sGrammar.getIDConstraintDecl(localpart);
1824 break;
1825 case NOTATION_TYPE :
1826 retObj = sGrammar.getGlobalNotationDecl(localpart);
1827 break;
1828 case TYPEDECL_TYPE :
1829 retObj = sGrammar.getGlobalTypeDecl(localpart);
1830 break;
1831 }
1832
1833 return retObj;
1834 }
1835
1836 protected Object getGlobalDeclFromGrammar(SchemaGrammar sGrammar, int declType, String localpart, String schemaLoc) {
1837 Object retObj = null;
1838
1839 switch (declType) {
1840 case ATTRIBUTE_TYPE :
1841 retObj = sGrammar.getGlobalAttributeDecl(localpart, schemaLoc);
1842 break;
1843 case ATTRIBUTEGROUP_TYPE :
1844 retObj = sGrammar.getGlobalAttributeGroupDecl(localpart, schemaLoc);
1845 break;
1846 case ELEMENT_TYPE :
1847 retObj = sGrammar.getGlobalElementDecl(localpart, schemaLoc);
1848 break;
1849 case GROUP_TYPE :
1850 retObj = sGrammar.getGlobalGroupDecl(localpart, schemaLoc);
1851 break;
1852 case IDENTITYCONSTRAINT_TYPE :
1853 retObj = sGrammar.getIDConstraintDecl(localpart, schemaLoc);
1854 break;
1855 case NOTATION_TYPE :
1856 retObj = sGrammar.getGlobalNotationDecl(localpart, schemaLoc);
1857 break;
1858 case TYPEDECL_TYPE :
1859 retObj = sGrammar.getGlobalTypeDecl(localpart, schemaLoc);
1860 break;
1861 }
1862
1863 return retObj;
1864 }
1865
1866 protected Object traverseGlobalDecl(int declType, Element decl, XSDocumentInfo schemaDoc, SchemaGrammar grammar) {
1867 Object retObj = null;
1868
1869 DOMUtil.setHidden(decl, fHiddenNodes);
1870 SchemaNamespaceSupport nsSupport = null;
1871 // if the parent is <redefine> use the namespace delcs for it.
1872 Element parent = DOMUtil.getParent(decl);
1873 if (DOMUtil.getLocalName(parent).equals(SchemaSymbols.ELT_REDEFINE))
1874 nsSupport = (fRedefine2NSSupport!=null)?(SchemaNamespaceSupport)fRedefine2NSSupport.get(parent):null;
1875 // back up the current SchemaNamespaceSupport, because we need to provide
1876 // a fresh one to the traverseGlobal methods.
1877 schemaDoc.backupNSSupport(nsSupport);
1878
1879 // traverse the referenced global component
1880 switch (declType) {
1881 case TYPEDECL_TYPE :
1882 if (DOMUtil.getLocalName(decl).equals(SchemaSymbols.ELT_COMPLEXTYPE)) {
1883 retObj = fComplexTypeTraverser.traverseGlobal(decl, schemaDoc, grammar);
1884 }
1885 else {
1886 retObj = fSimpleTypeTraverser.traverseGlobal(decl, schemaDoc, grammar);
1887 }
1888 break;
1889 case ATTRIBUTE_TYPE :
1890 retObj = fAttributeTraverser.traverseGlobal(decl, schemaDoc, grammar);
1891 break;
1892 case ELEMENT_TYPE :
1893 retObj = fElementTraverser.traverseGlobal(decl, schemaDoc, grammar);
1894 break;
1895 case ATTRIBUTEGROUP_TYPE :
1896 retObj = fAttributeGroupTraverser.traverseGlobal(decl, schemaDoc, grammar);
1897 break;
1898 case GROUP_TYPE :
1899 retObj = fGroupTraverser.traverseGlobal(decl, schemaDoc, grammar);
1900 break;
1901 case NOTATION_TYPE :
1902 retObj = fNotationTraverser.traverse(decl, schemaDoc, grammar);
1903 break;
1904 case IDENTITYCONSTRAINT_TYPE :
1905 // identity constraints should have been parsed already...
1906 // we should never get here
1907 break;
1908 }
1909
1910 // restore the previous SchemaNamespaceSupport, so that the caller can get
1911 // proper namespace binding.
1912 schemaDoc.restoreNSSupport();
1913
1914 return retObj;
1915 }
1916
1917 public String schemaDocument2SystemId(XSDocumentInfo schemaDoc) {
1918 return (String)fDoc2SystemId.get(schemaDoc.fSchemaElement);
1919 }
1920
1921 // This method determines whether there is a group
1922 // (attributeGroup) which the given one has redefined by
1923 // restriction. If so, it returns it; else it returns null.
1924 // @param type: whether what's been redefined is an
1925 // attributeGroup or a group;
1926 // @param name: the QName of the component doing the redefining.
1927 // @param currSchema: schema doc in which the redefining component lives.
1928 // @return: Object representing decl redefined if present, null
1929 // otherwise.
1930 Object getGrpOrAttrGrpRedefinedByRestriction(int type, QName name, XSDocumentInfo currSchema, Element elmNode) {
1931 String realName = name.uri != null?name.uri+","+name.localpart:
1932 ","+name.localpart;
1933 String nameToFind = null;
1934 switch (type) {
1935 case ATTRIBUTEGROUP_TYPE:
1936 nameToFind = (String)fRedefinedRestrictedAttributeGroupRegistry.get(realName);
1937 break;
1938 case GROUP_TYPE:
1939 nameToFind = (String)fRedefinedRestrictedGroupRegistry.get(realName);
1940 break;
1941 default:
1942 return null;
1943 }
1944 if (nameToFind == null) return null;
1945 int commaPos = nameToFind.indexOf(",");
1946 QName qNameToFind = new QName(XMLSymbols.EMPTY_STRING, nameToFind.substring(commaPos+1),
1947 nameToFind.substring(commaPos), (commaPos == 0)? null : nameToFind.substring(0, commaPos));
1948 Object retObj = getGlobalDecl(currSchema, type, qNameToFind, elmNode);
1949 if(retObj == null) {
1950 switch (type) {
1951 case ATTRIBUTEGROUP_TYPE:
1952 reportSchemaError("src-redefine.7.2.1", new Object []{name.localpart}, elmNode);
1953 break;
1954 case GROUP_TYPE:
1955 reportSchemaError("src-redefine.6.2.1", new Object []{name.localpart}, elmNode);
1956 break;
1957 }
1958 return null;
1959 }
1960 return retObj;
1961 } // getGrpOrAttrGrpRedefinedByRestriction(int, QName, XSDocumentInfo): Object
1962
1963 // Since ID constraints can occur in local elements, unless we
1964 // wish to completely traverse all our DOM trees looking for ID
1965 // constraints while we're building our global name registries,
1966 // which seems terribly inefficient, we need to resolve keyrefs
1967 // after all parsing is complete. This we can simply do by running through
1968 // fIdentityConstraintRegistry and calling traverseKeyRef on all
1969 // of the KeyRef nodes. This unfortunately removes this knowledge
1970 // from the elementTraverser class (which must ignore keyrefs),
1971 // but there seems to be no efficient way around this...
1972 protected void resolveKeyRefs() {
1973 for (int i=0; i<fKeyrefStackPos; i++) {
1974 XSDocumentInfo keyrefSchemaDoc = fKeyrefsMapXSDocumentInfo[i];
1975 keyrefSchemaDoc.fNamespaceSupport.makeGlobal();
1976 keyrefSchemaDoc.fNamespaceSupport.setEffectiveContext( fKeyrefNamespaceContext[i] );
1977 SchemaGrammar keyrefGrammar = fGrammarBucket.getGrammar(keyrefSchemaDoc.fTargetNamespace);
1978 // need to set <keyref> to hidden before traversing it,
1979 // because it has global scope
1980 DOMUtil.setHidden(fKeyrefs[i], fHiddenNodes);
1981 fKeyrefTraverser.traverse(fKeyrefs[i], fKeyrefElems[i], keyrefSchemaDoc, keyrefGrammar);
1982 }
1983 } // end resolveKeyRefs
1984
1985 // an accessor method. Just makes sure callers
1986 // who want the Identity constraint registry vaguely know what they're about.
1987 protected Map getIDRegistry() {
1988 return fUnparsedIdentityConstraintRegistry;
1989 }
1990 // an accessor method.
1991 protected Map getIDRegistry_sub() {
1992 return fUnparsedIdentityConstraintRegistrySub;
1993 }
1994
1995
1996
1997 // This method squirrels away <keyref> declarations--along with the element
1998 // decls and namespace bindings they might find handy.
1999 protected void storeKeyRef (Element keyrefToStore, XSDocumentInfo schemaDoc,
2000 XSElementDecl currElemDecl) {
2001 String keyrefName = DOMUtil.getAttrValue(keyrefToStore, SchemaSymbols.ATT_NAME);
2002 if (keyrefName.length() != 0) {
2003 String keyrefQName = schemaDoc.fTargetNamespace == null?
2004 "," + keyrefName: schemaDoc.fTargetNamespace+","+keyrefName;
2005 checkForDuplicateNames(keyrefQName, IDENTITYCONSTRAINT_TYPE, fUnparsedIdentityConstraintRegistry, fUnparsedIdentityConstraintRegistrySub, keyrefToStore, schemaDoc);
2006 }
2007 // now set up all the registries we'll need...
2008
2009 // check array sizes
2010 if (fKeyrefStackPos == fKeyrefs.length) {
2011 Element [] elemArray = new Element [fKeyrefStackPos + INC_KEYREF_STACK_AMOUNT];
2012 System.arraycopy(fKeyrefs, 0, elemArray, 0, fKeyrefStackPos);
2013 fKeyrefs = elemArray;
2014 XSElementDecl [] declArray = new XSElementDecl [fKeyrefStackPos + INC_KEYREF_STACK_AMOUNT];
2015 System.arraycopy(fKeyrefElems, 0, declArray, 0, fKeyrefStackPos);
2016 fKeyrefElems = declArray;
2017 String[][] stringArray = new String [fKeyrefStackPos + INC_KEYREF_STACK_AMOUNT][];
2018 System.arraycopy(fKeyrefNamespaceContext, 0, stringArray, 0, fKeyrefStackPos);
2019 fKeyrefNamespaceContext = stringArray;
2020
2021 XSDocumentInfo [] xsDocumentInfo = new XSDocumentInfo [fKeyrefStackPos + INC_KEYREF_STACK_AMOUNT];
2022 System.arraycopy(fKeyrefsMapXSDocumentInfo, 0, xsDocumentInfo, 0, fKeyrefStackPos);
2023 fKeyrefsMapXSDocumentInfo = xsDocumentInfo;
2024
2025 }
2026 fKeyrefs[fKeyrefStackPos] = keyrefToStore;
2027 fKeyrefElems[fKeyrefStackPos] = currElemDecl;
2028 fKeyrefNamespaceContext[fKeyrefStackPos] = schemaDoc.fNamespaceSupport.getEffectiveLocalContext();
2029
2030 fKeyrefsMapXSDocumentInfo[fKeyrefStackPos++] = schemaDoc;
2031 } // storeKeyref (Element, XSDocumentInfo, XSElementDecl): void
2032
2033
2034 /**
2035 * resolveSchema method is responsible for resolving location of the schema (using XMLEntityResolver),
2036 * and if it was succefully resolved getting the schema Document.
2037 * @param desc
2038 * @param mustResolve
2039 * @param referElement
2040 * @return A schema Element or null.
2041 */
2042 private Element resolveSchema(XSDDescription desc, boolean mustResolve,
2043 Element referElement, boolean usePairs) {
2044 XMLInputSource schemaSource = null;
2045 try {
2046 Map<String, XMLSchemaLoader.LocationArray> pairs = usePairs ? fLocationPairs : Collections.emptyMap();
2047 schemaSource = XMLSchemaLoader.resolveDocument(desc, pairs, fEntityResolver);
2048 }
2049 catch (IOException ex) {
2050 if (mustResolve) {
2051 reportSchemaError("schema_reference.4",
2052 new Object[]{desc.getLocationHints()[0]},
2053 referElement);
2054 }
2055 else {
2056 reportSchemaWarning("schema_reference.4",
2057 new Object[]{desc.getLocationHints()[0]},
2058 referElement);
2059 }
2060 }
2061 if (schemaSource instanceof DOMInputSource) {
2062 return getSchemaDocument(desc.getTargetNamespace(), (DOMInputSource) schemaSource, mustResolve, desc.getContextType(), referElement);
2063 } // DOMInputSource
2064 else if (schemaSource instanceof SAXInputSource) {
2065 return getSchemaDocument(desc.getTargetNamespace(), (SAXInputSource) schemaSource, mustResolve, desc.getContextType(), referElement);
2066 } // SAXInputSource
2067 else if (schemaSource instanceof StAXInputSource) {
2068 return getSchemaDocument(desc.getTargetNamespace(), (StAXInputSource) schemaSource, mustResolve, desc.getContextType(), referElement);
2069 } // StAXInputSource
2070 else if (schemaSource instanceof XSInputSource) {
2071 return getSchemaDocument((XSInputSource) schemaSource, desc);
2072 } // XSInputSource
2073 return getSchemaDocument(desc.getTargetNamespace(), schemaSource, mustResolve, desc.getContextType(), referElement);
2074 } // getSchema(String, String, String, boolean, short): Document
2075
2076 private Element resolveSchema(XMLInputSource schemaSource, XSDDescription desc,
2077 boolean mustResolve, Element referElement) {
2078
2079 if (schemaSource instanceof DOMInputSource) {
2080 return getSchemaDocument(desc.getTargetNamespace(), (DOMInputSource) schemaSource, mustResolve, desc.getContextType(), referElement);
2081 } // DOMInputSource
2082 else if (schemaSource instanceof SAXInputSource) {
2083 return getSchemaDocument(desc.getTargetNamespace(), (SAXInputSource) schemaSource, mustResolve, desc.getContextType(), referElement);
2084 } // SAXInputSource
2085 else if (schemaSource instanceof StAXInputSource) {
2086 return getSchemaDocument(desc.getTargetNamespace(), (StAXInputSource) schemaSource, mustResolve, desc.getContextType(), referElement);
2087 } // StAXInputSource
2088 else if (schemaSource instanceof XSInputSource) {
2089 return getSchemaDocument((XSInputSource) schemaSource, desc);
2090 } // XSInputSource
2091 return getSchemaDocument(desc.getTargetNamespace(), schemaSource, mustResolve, desc.getContextType(), referElement);
2092 }
2093
2094 private XMLInputSource resolveSchemaSource(XSDDescription desc, boolean mustResolve,
2095 Element referElement, boolean usePairs) {
2096
2097 XMLInputSource schemaSource = null;
2098 try {
2099 Map<String, XMLSchemaLoader.LocationArray> pairs = usePairs ? fLocationPairs : Collections.emptyMap();
2100 schemaSource = XMLSchemaLoader.resolveDocument(desc, pairs, fEntityResolver);
2101 }
2102 catch (IOException ex) {
2103 if (mustResolve) {
2104 reportSchemaError("schema_reference.4",
2105 new Object[]{desc.getLocationHints()[0]},
2106 referElement);
2107 }
2108 else {
2109 reportSchemaWarning("schema_reference.4",
2110 new Object[]{desc.getLocationHints()[0]},
2111 referElement);
2112 }
2113 }
2114
2115 return schemaSource;
2116 }
2117
2118 /**
2119 * getSchemaDocument method uses XMLInputSource to parse a schema document.
2120 * @param schemaNamespace
2121 * @param schemaSource
2122 * @param mustResolve
2123 * @param referType
2124 * @param referElement
2125 * @return A schema Element.
2126 */
2127 private Element getSchemaDocument(String schemaNamespace, XMLInputSource schemaSource,
2128 boolean mustResolve, short referType, Element referElement) {
2129
2130 boolean hasInput = true;
2131 IOException exception = null;
2132 // contents of this method will depend on the system we adopt for entity resolution--i.e., XMLEntityHandler, EntityHandler, etc.
2133 Element schemaElement = null;
2134 try {
2135 // when the system id and byte stream and character stream
2136 // of the input source are all null, it's
2137 // impossible to find the schema document. so we skip in
2138 // this case. otherwise we'll receive some NPE or
2139 // file not found errors. but schemaHint=="" is perfectly
2140 // legal for import.
2141 if (schemaSource != null &&
2142 (schemaSource.getSystemId() != null ||
2143 schemaSource.getByteStream() != null ||
2144 schemaSource.getCharacterStream() != null)) {
2145
2146 // When the system id of the input source is used, first try to
2147 // expand it, and check whether the same document has been
2148 // parsed before. If so, return the document corresponding to
2149 // that system id.
2150 XSDKey key = null;
2151 String schemaId = null;
2152 if (referType != XSDDescription.CONTEXT_PREPARSE){
2153 schemaId = XMLEntityManager.expandSystemId(schemaSource.getSystemId(), schemaSource.getBaseSystemId(), false);
2154 key = new XSDKey(schemaId, referType, schemaNamespace);
2155 if((schemaElement = (Element)fTraversed.get(key)) != null) {
2156 fLastSchemaWasDuplicate = true;
2157 return schemaElement;
2158 }
2159 if (referType == XSDDescription.CONTEXT_IMPORT || referType == XSDDescription.CONTEXT_INCLUDE
2160 || referType == XSDDescription.CONTEXT_REDEFINE) {
2161 String accessError = SecuritySupport.checkAccess(schemaId, fAccessExternalSchema, Constants.ACCESS_EXTERNAL_ALL);
2162 if (accessError != null) {
2163 reportSchemaFatalError("schema_reference.access",
2164 new Object[] { SecuritySupport.sanitizePath(schemaId), accessError },
2165 referElement);
2166 }
2167 }
2168 }
2169
2170 fSchemaParser.parse(schemaSource);
2171 Document schemaDocument = fSchemaParser.getDocument();
2172 schemaElement = schemaDocument != null ? DOMUtil.getRoot(schemaDocument) : null;
2173 return getSchemaDocument0(key, schemaId, schemaElement);
2174 }
2175 else {
2176 hasInput = false;
2177 }
2178 }
2179 catch (IOException ex) {
2180 exception = ex;
2181 }
2182 return getSchemaDocument1(mustResolve, hasInput, schemaSource, referElement, exception);
2183 } // getSchemaDocument(String, XMLInputSource, boolean, short, Element): Element
2184
2185 /**
2186 * getSchemaDocument method uses SAXInputSource to parse a schema document.
2187 * @param schemaNamespace
2188 * @param schemaSource
2189 * @param mustResolve
2190 * @param referType
2191 * @param referElement
2192 * @return A schema Element.
2193 */
2194 private Element getSchemaDocument(String schemaNamespace, SAXInputSource schemaSource,
2195 boolean mustResolve, short referType, Element referElement) {
2196 XMLReader parser = schemaSource.getXMLReader();
2197 InputSource inputSource = schemaSource.getInputSource();
2198 boolean hasInput = true;
2199 IOException exception = null;
2200 Element schemaElement = null;
2201 try {
2202 if (inputSource != null &&
2203 (inputSource.getSystemId() != null ||
2204 inputSource.getByteStream() != null ||
2205 inputSource.getCharacterStream() != null)) {
2206
2207 // check whether the same document has been parsed before.
2208 // If so, return the document corresponding to that system id.
2209 XSDKey key = null;
2210 String schemaId = null;
2211 if (referType != XSDDescription.CONTEXT_PREPARSE) {
2212 schemaId = XMLEntityManager.expandSystemId(inputSource.getSystemId(), schemaSource.getBaseSystemId(), false);
2213 key = new XSDKey(schemaId, referType, schemaNamespace);
2214 if ((schemaElement = (Element) fTraversed.get(key)) != null) {
2215 fLastSchemaWasDuplicate = true;
2216 return schemaElement;
2217 }
2218 }
2219
2220 boolean namespacePrefixes = false;
2221 if (parser != null) {
2222 try {
2223 namespacePrefixes = parser.getFeature(NAMESPACE_PREFIXES);
2224 }
2225 catch (SAXException se) {}
2226 }
2227 else {
2228 try {
2229 parser = XMLReaderFactory.createXMLReader();
2230 }
2231 // If something went wrong with the factory
2232 // just use our own SAX parser.
2233 catch (SAXException se) {
2234 parser = new SAXParser();
2235 }
2236 try {
2237 parser.setFeature(NAMESPACE_PREFIXES, true);
2238 namespacePrefixes = true;
2239 // If this is a Xerces SAX parser set the security manager if there is one
2240 if (parser instanceof SAXParser) {
2241 Object securityManager = fSchemaParser.getProperty(SECURITY_MANAGER);
2242 if (securityManager != null) {
2243 parser.setProperty(SECURITY_MANAGER, securityManager);
2244 }
2245 }
2246 }
2247 catch (SAXException se) {}
2248
2249 try {
2250 parser.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, fAccessExternalDTD);
2251 } catch (SAXNotRecognizedException exc) {
2252 XMLSecurityManager.printWarning(parser.getClass().getName(),
2253 XMLConstants.ACCESS_EXTERNAL_DTD, exc);
2254 }
2255 }
2256 // If XML names and Namespace URIs are already internalized we
2257 // can avoid running them through the SymbolTable.
2258 boolean stringsInternalized = false;
2259 try {
2260 stringsInternalized = parser.getFeature(STRING_INTERNING);
2261 }
2262 catch (SAXException exc) {
2263 // The feature isn't recognized or getting it is not supported.
2264 // In either case, assume that strings are not internalized.
2265 }
2266 if (fXSContentHandler == null) {
2267 fXSContentHandler = new SchemaContentHandler();
2268 }
2269 fXSContentHandler.reset(fSchemaParser, fSymbolTable,
2270 namespacePrefixes, stringsInternalized);
2271 parser.setContentHandler(fXSContentHandler);
2272 parser.setErrorHandler(fErrorReporter.getSAXErrorHandler());
2273
2274 parser.parse(inputSource);
2275 // Disconnect the schema loader and other objects from the XMLReader
2276 try {
2277 parser.setContentHandler(null);
2278 parser.setErrorHandler(null);
2279 }
2280 // Ignore any exceptions thrown by the XMLReader. Old versions of SAX
2281 // required an XMLReader to throw a NullPointerException if an attempt
2282 // to set a handler to null was made.
2283 catch (Exception e) {}
2284
2285 Document schemaDocument = fXSContentHandler.getDocument();
2286 schemaElement = schemaDocument != null ? DOMUtil.getRoot(schemaDocument) : null;
2287 return getSchemaDocument0(key, schemaId, schemaElement);
2288 }
2289 else {
2290 hasInput = false;
2291 }
2292 }
2293 catch (SAXParseException spe) {
2294 throw SAX2XNIUtil.createXMLParseException0(spe);
2295 }
2296 catch (SAXException se) {
2297 throw SAX2XNIUtil.createXNIException0(se);
2298 }
2299 catch (IOException ioe) {
2300 exception = ioe;
2301 }
2302 return getSchemaDocument1(mustResolve, hasInput, schemaSource, referElement, exception);
2303 } // getSchemaDocument(String, SAXInputSource, boolean, short, Element): Element
2304
2305 /**
2306 * getSchemaDocument method uses DOMInputSource to parse a schema document.
2307 * @param schemaNamespace
2308 * @param schemaSource
2309 * @param mustResolve
2310 * @param referType
2311 * @param referElement
2312 * @return A schema Element.
2313 */
2314 private Element getSchemaDocument(String schemaNamespace, DOMInputSource schemaSource,
2315 boolean mustResolve, short referType, Element referElement) {
2316 boolean hasInput = true;
2317 IOException exception = null;
2318 Element schemaElement = null;
2319 Element schemaRootElement = null;
2320
2321 final Node node = schemaSource.getNode();
2322 short nodeType = -1;
2323 if (node != null) {
2324 nodeType = node.getNodeType();
2325 if (nodeType == Node.DOCUMENT_NODE) {
2326 schemaRootElement = DOMUtil.getRoot((Document) node);
2327 }
2328 else if (nodeType == Node.ELEMENT_NODE) {
2329 schemaRootElement = (Element) node;
2330 }
2331 }
2332
2333 try {
2334 if (schemaRootElement != null) {
2335 // check whether the same document has been parsed before.
2336 // If so, return the document corresponding to that system id.
2337 XSDKey key = null;
2338 String schemaId = null;
2339 if (referType != XSDDescription.CONTEXT_PREPARSE) {
2340 schemaId = XMLEntityManager.expandSystemId(schemaSource.getSystemId(), schemaSource.getBaseSystemId(), false);
2341 boolean isDocument = (nodeType == Node.DOCUMENT_NODE);
2342 if (!isDocument) {
2343 Node parent = schemaRootElement.getParentNode();
2344 if (parent != null) {
2345 isDocument = (parent.getNodeType() == Node.DOCUMENT_NODE);
2346 }
2347 }
2348 if (isDocument) {
2349 key = new XSDKey(schemaId, referType, schemaNamespace);
2350 if ((schemaElement = (Element) fTraversed.get(key)) != null) {
2351 fLastSchemaWasDuplicate = true;
2352 return schemaElement;
2353 }
2354 }
2355 }
2356
2357 schemaElement = schemaRootElement;
2358 return getSchemaDocument0(key, schemaId, schemaElement);
2359 }
2360 else {
2361 hasInput = false;
2362 }
2363 }
2364 catch (IOException ioe) {
2365 exception = ioe;
2366 }
2367 return getSchemaDocument1(mustResolve, hasInput, schemaSource, referElement, exception);
2368 } // getSchemaDocument(String, DOMInputSource, boolean, short, Element): Element
2369
2370 /**
2371 * getSchemaDocument method uses StAXInputSource to parse a schema document.
2372 * @param schemaNamespace
2373 * @param schemaSource
2374 * @param mustResolve
2375 * @param referType
2376 * @param referElement
2377 * @return A schema Element.
2378 */
2379 private Element getSchemaDocument(String schemaNamespace, StAXInputSource schemaSource,
2380 boolean mustResolve, short referType, Element referElement) {
2381 IOException exception = null;
2382 Element schemaElement = null;
2383 try {
2384 final boolean consumeRemainingContent = schemaSource.shouldConsumeRemainingContent();
2385 final XMLStreamReader streamReader = schemaSource.getXMLStreamReader();
2386 final XMLEventReader eventReader = schemaSource.getXMLEventReader();
2387
2388 // check whether the same document has been parsed before.
2389 // If so, return the document corresponding to that system id.
2390 XSDKey key = null;
2391 String schemaId = null;
2392 if (referType != XSDDescription.CONTEXT_PREPARSE) {
2393 schemaId = XMLEntityManager.expandSystemId(schemaSource.getSystemId(), schemaSource.getBaseSystemId(), false);
2394 boolean isDocument = consumeRemainingContent;
2395 if (!isDocument) {
2396 if (streamReader != null) {
2397 isDocument = (streamReader.getEventType() == XMLStreamReader.START_DOCUMENT);
2398 }
2399 else {
2400 isDocument = eventReader.peek().isStartDocument();
2401 }
2402 }
2403 if (isDocument) {
2404 key = new XSDKey(schemaId, referType, schemaNamespace);
2405 if ((schemaElement = (Element) fTraversed.get(key)) != null) {
2406 fLastSchemaWasDuplicate = true;
2407 return schemaElement;
2408 }
2409 }
2410 }
2411
2412 if (fStAXSchemaParser == null) {
2413 fStAXSchemaParser = new StAXSchemaParser();
2414 }
2415 fStAXSchemaParser.reset(fSchemaParser, fSymbolTable);
2416
2417 if (streamReader != null) {
2418 fStAXSchemaParser.parse(streamReader);
2419 if (consumeRemainingContent) {
2420 while (streamReader.hasNext()) {
2421 streamReader.next();
2422 }
2423 }
2424 }
2425 else {
2426 fStAXSchemaParser.parse(eventReader);
2427 if (consumeRemainingContent) {
2428 while (eventReader.hasNext()) {
2429 eventReader.nextEvent();
2430 }
2431 }
2432 }
2433 Document schemaDocument = fStAXSchemaParser.getDocument();
2434 schemaElement = schemaDocument != null ? DOMUtil.getRoot(schemaDocument) : null;
2435 return getSchemaDocument0(key, schemaId, schemaElement);
2436 }
2437 catch (XMLStreamException e) {
2438 StAXLocationWrapper slw = new StAXLocationWrapper();
2439 slw.setLocation(e.getLocation());
2440 throw new XMLParseException(slw, e.getMessage(), e);
2441 }
2442 catch (IOException e) {
2443 exception = e;
2444 }
2445 return getSchemaDocument1(mustResolve, true, schemaSource, referElement, exception);
2446 } // getSchemaDocument(String, StAXInputSource, boolean, short, Element): Element
2447
2448 /**
2449 * Code shared between the various getSchemaDocument() methods which
2450 * stores mapping information for the document.
2451 */
2452 private Element getSchemaDocument0(XSDKey key, String schemaId, Element schemaElement) {
2453 // now we need to store the mapping information from system id
2454 // to the document. also from the document to the system id.
2455 if (key != null) {
2456 fTraversed.put(key, schemaElement);
2457 }
2458 if (schemaId != null) {
2459 fDoc2SystemId.put(schemaElement, schemaId);
2460 }
2461 fLastSchemaWasDuplicate = false;
2462 return schemaElement;
2463 } // getSchemaDocument0(XSDKey, String, Element): Element
2464
2465 /**
2466 * Error handling code shared between the various getSchemaDocument() methods.
2467 */
2468 private Element getSchemaDocument1(boolean mustResolve, boolean hasInput,
2469 XMLInputSource schemaSource, Element referElement, IOException ioe) {
2470 // either an error occured (exception), or empty input source was
2471 // returned, we need to report an error or a warning
2472 if (mustResolve) {
2473 if (hasInput) {
2474 reportSchemaError("schema_reference.4",
2475 new Object[]{schemaSource.getSystemId()},
2476 referElement, ioe);
2477 }
2478 else {
2479 reportSchemaError("schema_reference.4",
2480 new Object[]{schemaSource == null ? "" : schemaSource.getSystemId()},
2481 referElement, ioe);
2482 }
2483 }
2484 else if (hasInput) {
2485 reportSchemaWarning("schema_reference.4",
2486 new Object[]{schemaSource.getSystemId()},
2487 referElement, ioe);
2488 }
2489
2490 fLastSchemaWasDuplicate = false;
2491 return null;
2492 } // getSchemaDocument1(boolean, boolean, XMLInputSource, Element): Element
2493
2494 /**
2495 * getSchemaDocument method uses XMLInputSource to parse a schema document.
2496 * @param schemaNamespace
2497 * @param schemaSource
2498 * @param mustResolve
2499 * @param referType
2500 * @param referElement
2501 * @return A schema Element.
2502 */
2503 private Element getSchemaDocument(XSInputSource schemaSource, XSDDescription desc) {
2504
2505 SchemaGrammar[] grammars = schemaSource.getGrammars();
2506 short referType = desc.getContextType();
2507
2508 if (grammars != null && grammars.length > 0) {
2509 Vector expandedGrammars = expandGrammars(grammars);
2510 // check for existing grammars in our bucket
2511 // and if there exist any, and namespace growth is
2512 // not enabled - we do nothing
2513 if (fNamespaceGrowth || !existingGrammars(expandedGrammars)) {
2514 addGrammars(expandedGrammars);
2515 if (referType == XSDDescription.CONTEXT_PREPARSE) {
2516 desc.setTargetNamespace(grammars[0].getTargetNamespace());
2517 }
2518 }
2519 }
2520 else {
2521 XSObject[] components = schemaSource.getComponents();
2522 if (components != null && components.length > 0) {
2523 Map<String, Vector> importDependencies = new HashMap();
2524 Vector expandedComponents = expandComponents(components, importDependencies);
2525 if (fNamespaceGrowth || canAddComponents(expandedComponents)) {
2526 addGlobalComponents(expandedComponents, importDependencies);
2527 if (referType == XSDDescription.CONTEXT_PREPARSE) {
2528 desc.setTargetNamespace(components[0].getNamespace());
2529 }
2530 }
2531 }
2532 }
2533 return null;
2534 } // getSchemaDocument(String, XSInputSource, boolean, short, Element): Element
2535
2536 private Vector expandGrammars(SchemaGrammar[] grammars) {
2537 Vector currGrammars = new Vector();
2538
2539 for (int i=0; i<grammars.length; i++) {
2540 if (!currGrammars.contains(grammars[i])) {
2541 currGrammars.add(grammars[i]);
2542 }
2543 }
2544
2545 // for all (recursively) imported grammars
2546 SchemaGrammar sg1, sg2;
2547 Vector gs;
2548 for (int i = 0; i < currGrammars.size(); i++) {
2549 // get the grammar
2550 sg1 = (SchemaGrammar)currGrammars.elementAt(i);
2551 // we need to add grammars imported by sg1 too
2552 gs = sg1.getImportedGrammars();
2553 // for all grammars imported by sg2, but not in the vector
2554 // we add them to the vector
2555 if (gs == null) {
2556 continue;
2557 }
2558
2559 for (int j = gs.size() - 1; j >= 0; j--) {
2560 sg2 = (SchemaGrammar)gs.elementAt(j);
2561 if (!currGrammars.contains(sg2)) {
2562 currGrammars.addElement(sg2);
2563 }
2564 }
2565 }
2566
2567 return currGrammars;
2568 }
2569
2570 private boolean existingGrammars(Vector grammars) {
2571 int length = grammars.size();
2572 final XSDDescription desc = new XSDDescription();
2573
2574 for (int i=0; i < length; i++) {
2575 final SchemaGrammar sg1 = (SchemaGrammar)grammars.elementAt(i);
2576 desc.setNamespace(sg1.getTargetNamespace());
2577
2578 final SchemaGrammar sg2 = findGrammar(desc, false);
2579 if (sg2 != null) {
2580 return true;
2581 }
2582 }
2583
2584 return false;
2585 }
2586
2587 private boolean canAddComponents(Vector components) {
2588 final int size = components.size();
2589 final XSDDescription desc = new XSDDescription();
2590 for (int i=0; i<size; i++) {
2591 XSObject component = (XSObject) components.elementAt(i);
2592 if (!canAddComponent(component, desc)) {
2593 return false;
2594 }
2595 }
2596 return true;
2597 }
2598
2599 private boolean canAddComponent(XSObject component, XSDDescription desc) {
2600 desc.setNamespace(component.getNamespace());
2601
2602 final SchemaGrammar sg = findGrammar(desc, false);
2603 if (sg == null) {
2604 return true;
2605 }
2606 else if (sg.isImmutable()) {
2607 return false;
2608 }
2609
2610 short componentType = component.getType();
2611 final String name = component.getName();
2612
2613 switch (componentType) {
2614 case XSConstants.TYPE_DEFINITION :
2615 if (sg.getGlobalTypeDecl(name) == component) {
2616 return true;
2617 }
2618 break;
2619 case XSConstants.ATTRIBUTE_DECLARATION :
2620 if (sg.getGlobalAttributeDecl(name) == component) {
2621 return true;
2622 }
2623 break;
2624 case XSConstants.ATTRIBUTE_GROUP :
2625 if (sg.getGlobalAttributeDecl(name) == component) {
2626 return true;
2627 }
2628 break;
2629 case XSConstants.ELEMENT_DECLARATION :
2630 if (sg.getGlobalElementDecl(name) == component) {
2631 return true;
2632 }
2633 break;
2634 case XSConstants.MODEL_GROUP_DEFINITION :
2635 if (sg.getGlobalGroupDecl(name) == component) {
2636 return true;
2637 }
2638 break;
2639 case XSConstants.NOTATION_DECLARATION :
2640 if (sg.getGlobalNotationDecl(name) == component) {
2641 return true;
2642 }
2643 break;
2644 case XSConstants.IDENTITY_CONSTRAINT :
2645 case XSConstants.ATTRIBUTE_USE :
2646 default :
2647 return true;
2648 }
2649 return false;
2650 }
2651
2652 private void addGrammars(Vector grammars) {
2653 int length = grammars.size();
2654 XSDDescription desc = new XSDDescription();
2655
2656 for (int i=0; i < length; i++) {
2657 final SchemaGrammar sg1 = (SchemaGrammar)grammars.elementAt(i);
2658 desc.setNamespace(sg1.getTargetNamespace());
2659
2660 final SchemaGrammar sg2 = findGrammar(desc, fNamespaceGrowth);
2661 if (sg1 != sg2) {
2662 addGrammarComponents(sg1, sg2);
2663 }
2664 }
2665 }
2666
2667 private void addGrammarComponents(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) {
2668 if (dstGrammar == null) {
2669 createGrammarFrom(srcGrammar);
2670 return;
2671 }
2672
2673 SchemaGrammar tmpGrammar = dstGrammar;
2674 if (tmpGrammar.isImmutable()) {
2675 tmpGrammar = createGrammarFrom(dstGrammar);
2676 }
2677
2678 // add any new locations
2679 addNewGrammarLocations(srcGrammar, tmpGrammar);
2680
2681 // add any new imported grammars
2682 addNewImportedGrammars(srcGrammar, tmpGrammar);
2683
2684 // add any new global components
2685 addNewGrammarComponents(srcGrammar, tmpGrammar);
2686 }
2687
2688 private SchemaGrammar createGrammarFrom(SchemaGrammar grammar) {
2689 SchemaGrammar newGrammar = new SchemaGrammar(grammar);
2690 fGrammarBucket.putGrammar(newGrammar);
2691 // update all the grammars in the bucket to point to the new grammar.
2692 updateImportListWith(newGrammar);
2693 // update import list of the new grammar
2694 updateImportListFor(newGrammar);
2695 return newGrammar;
2696 }
2697
2698 private void addNewGrammarLocations(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) {
2699 final StringList locations = srcGrammar.getDocumentLocations();
2700 final int locSize = locations.size();
2701 final StringList locations2 = dstGrammar.getDocumentLocations();
2702
2703 for (int i=0; i<locSize; i++) {
2704 String loc = locations.item(i);
2705 if (!locations2.contains(loc)) {
2706 dstGrammar.addDocument(null, loc);
2707 }
2708 }
2709 }
2710
2711 private void addNewImportedGrammars(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) {
2712 final Vector igs1 = srcGrammar.getImportedGrammars();
2713 if (igs1 != null) {
2714 Vector igs2 = dstGrammar.getImportedGrammars();
2715
2716 if (igs2 == null) {
2717 igs2 = ((Vector) igs1.clone());
2718 dstGrammar.setImportedGrammars(igs2);
2719 }
2720 else {
2721 updateImportList(igs1, igs2);
2722 }
2723 }
2724 }
2725
2726 private void updateImportList(Vector importedSrc, Vector importedDst)
2727 {
2728 final int size = importedSrc.size();
2729
2730 for (int i=0; i<size; i++) {
2731 final SchemaGrammar sg = (SchemaGrammar) importedSrc.elementAt(i);
2732 if (!containedImportedGrammar(importedDst, sg)) {
2733 importedDst.add(sg);
2734 }
2735 }
2736 }
2737
2738 private void addNewGrammarComponents(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) {
2739 dstGrammar.resetComponents();
2740 addGlobalElementDecls(srcGrammar, dstGrammar);
2741 addGlobalAttributeDecls(srcGrammar, dstGrammar);
2742 addGlobalAttributeGroupDecls(srcGrammar, dstGrammar);
2743 addGlobalGroupDecls(srcGrammar, dstGrammar);
2744 addGlobalTypeDecls(srcGrammar, dstGrammar);
2745 addGlobalNotationDecls(srcGrammar, dstGrammar);
2746 }
2747
2748 private void addGlobalElementDecls(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) {
2749 XSNamedMap components = srcGrammar.getComponents(XSConstants.ELEMENT_DECLARATION);
2750 int len = components.getLength();
2751 XSElementDecl srcDecl, dstDecl;
2752
2753 // add global components
2754 for (int i=0; i<len; i++) {
2755 srcDecl = (XSElementDecl) components.item(i);
2756 dstDecl = dstGrammar.getGlobalElementDecl(srcDecl.getName());
2757 if (dstDecl == null) {
2758 dstGrammar.addGlobalElementDecl(srcDecl);
2759 }
2760 else if (dstDecl != srcDecl){
2761 // TODO: if not tolerating duplicate, generate an error message
2762 }
2763 }
2764
2765 // add any extended (duplicate) global components
2766 ObjectList componentsExt = srcGrammar.getComponentsExt(XSConstants.ELEMENT_DECLARATION);
2767 len = componentsExt.getLength();
2768
2769 for (int i=0; i<len; i+= 2) {
2770 final String key = (String) componentsExt.item(i);
2771 final int index = key.indexOf(',');
2772 final String location = key.substring(0, index);
2773 final String name = key.substring(index + 1, key.length());
2774
2775 srcDecl = (XSElementDecl)componentsExt.item(i+1);
2776 dstDecl = dstGrammar.getGlobalElementDecl(name, location);
2777 if ( dstDecl == null) {
2778 dstGrammar.addGlobalElementDecl(srcDecl, location);
2779 }
2780 else if (dstDecl != srcDecl){
2781 // TODO: if not tolerating duplicate, generate an error message
2782 }
2783 }
2784 }
2785
2786 private void addGlobalAttributeDecls(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) {
2787 XSNamedMap components = srcGrammar.getComponents(XSConstants.ATTRIBUTE_DECLARATION);
2788 int len = components.getLength();
2789 XSAttributeDecl srcDecl, dstDecl;
2790
2791 // add global components
2792 for (int i=0; i<len; i++) {
2793 srcDecl = (XSAttributeDecl) components.item(i);
2794 dstDecl = dstGrammar.getGlobalAttributeDecl(srcDecl.getName());
2795 if (dstDecl == null) {
2796 dstGrammar.addGlobalAttributeDecl(srcDecl);
2797 }
2798 else if (dstDecl != srcDecl && !fTolerateDuplicates) {
2799 reportSharingError(srcDecl.getNamespace(), srcDecl.getName());
2800 }
2801 }
2802
2803 // add any extended (duplicate) global components
2804 ObjectList componentsExt = srcGrammar.getComponentsExt(XSConstants.ATTRIBUTE_DECLARATION);
2805 len = componentsExt.getLength();
2806
2807 for (int i=0; i<len; i+= 2) {
2808 final String key = (String) componentsExt.item(i);
2809 final int index = key.indexOf(',');
2810 final String location = key.substring(0, index);
2811 final String name = key.substring(index + 1, key.length());
2812
2813 srcDecl = (XSAttributeDecl)componentsExt.item(i+1);
2814 dstDecl = dstGrammar.getGlobalAttributeDecl(name, location);
2815 if (dstDecl == null) {
2816 dstGrammar.addGlobalAttributeDecl(srcDecl, location);
2817 }
2818 // REVISIT - do we report an error?
2819 else if (dstDecl != srcDecl) {
2820 }
2821 }
2822 }
2823
2824 private void addGlobalAttributeGroupDecls(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) {
2825 XSNamedMap components = srcGrammar.getComponents(XSConstants.ATTRIBUTE_GROUP);
2826 int len = components.getLength();
2827 XSAttributeGroupDecl srcDecl, dstDecl;
2828
2829 // add global components
2830 for (int i=0; i<len; i++) {
2831 srcDecl = (XSAttributeGroupDecl) components.item(i);
2832 dstDecl = dstGrammar.getGlobalAttributeGroupDecl(srcDecl.getName());
2833 if (dstDecl == null) {
2834 dstGrammar.addGlobalAttributeGroupDecl(srcDecl);
2835 }
2836 else if (dstDecl != srcDecl && !fTolerateDuplicates) {
2837 reportSharingError(srcDecl.getNamespace(), srcDecl.getName());
2838 }
2839 }
2840
2841 // add any extended (duplicate) global components
2842 ObjectList componentsExt = srcGrammar.getComponentsExt(XSConstants.ATTRIBUTE_GROUP);
2843 len = componentsExt.getLength();
2844
2845 for (int i=0; i<len; i+= 2) {
2846 final String key = (String) componentsExt.item(i);
2847 final int index = key.indexOf(',');
2848 final String location = key.substring(0, index);
2849 final String name = key.substring(index + 1, key.length());
2850
2851 srcDecl = (XSAttributeGroupDecl)componentsExt.item(i+1);
2852 dstDecl = dstGrammar.getGlobalAttributeGroupDecl(name, location);
2853 if (dstDecl == null) {
2854 dstGrammar.addGlobalAttributeGroupDecl(srcDecl, location);
2855 }
2856 // REVISIT - do we report an error?
2857 else if (dstDecl != srcDecl) {
2858 }
2859 }
2860 }
2861
2862 private void addGlobalNotationDecls(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) {
2863 XSNamedMap components = srcGrammar.getComponents(XSConstants.NOTATION_DECLARATION);
2864 int len = components.getLength();
2865 XSNotationDecl srcDecl, dstDecl;
2866
2867 // add global components
2868 for (int i=0; i<len; i++) {
2869 srcDecl = (XSNotationDecl) components.item(i);
2870 dstDecl = dstGrammar.getGlobalNotationDecl(srcDecl.getName());
2871 if (dstDecl == null) {
2872 dstGrammar.addGlobalNotationDecl(srcDecl);
2873 }
2874 else if (dstDecl != srcDecl && !fTolerateDuplicates) {
2875 reportSharingError(srcDecl.getNamespace(), srcDecl.getName());
2876 }
2877 }
2878
2879 // add any extended (duplicate) global components
2880 ObjectList componentsExt = srcGrammar.getComponentsExt(XSConstants.NOTATION_DECLARATION);
2881 len = componentsExt.getLength();
2882
2883 for (int i=0; i<len; i+= 2) {
2884 final String key = (String) componentsExt.item(i);
2885 final int index = key.indexOf(',');
2886 final String location = key.substring(0, index);
2887 final String name = key.substring(index + 1, key.length());
2888
2889 srcDecl = (XSNotationDecl)componentsExt.item(i+1);
2890 dstDecl = dstGrammar.getGlobalNotationDecl(name, location);
2891 if (dstDecl == null) {
2892 dstGrammar.addGlobalNotationDecl(srcDecl, location);
2893 }
2894 // REVISIT - do we report an error?
2895 else if (dstDecl != srcDecl) {
2896 }
2897 }
2898 }
2899
2900 private void addGlobalGroupDecls(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) {
2901 XSNamedMap components = srcGrammar.getComponents(XSConstants.MODEL_GROUP_DEFINITION);
2902 int len = components.getLength();
2903 XSGroupDecl srcDecl, dstDecl;
2904
2905 // add global components
2906 for (int i=0; i<len; i++) {
2907 srcDecl = (XSGroupDecl) components.item(i);
2908 dstDecl = dstGrammar.getGlobalGroupDecl(srcDecl.getName());
2909 if (dstDecl == null) {
2910 dstGrammar.addGlobalGroupDecl(srcDecl);
2911 }
2912 else if (srcDecl != dstDecl && !fTolerateDuplicates) {
2913 reportSharingError(srcDecl.getNamespace(), srcDecl.getName());
2914 }
2915 }
2916
2917 // add any extended (duplicate) global components
2918 ObjectList componentsExt = srcGrammar.getComponentsExt(XSConstants.MODEL_GROUP_DEFINITION);
2919 len = componentsExt.getLength();
2920
2921 for (int i=0; i<len; i+= 2) {
2922 final String key = (String) componentsExt.item(i);
2923 final int index = key.indexOf(',');
2924 final String location = key.substring(0, index);
2925 final String name = key.substring(index + 1, key.length());
2926
2927 srcDecl = (XSGroupDecl)componentsExt.item(i+1);
2928 dstDecl = dstGrammar.getGlobalGroupDecl(name, location);
2929 if (dstDecl == null) {
2930 dstGrammar.addGlobalGroupDecl(srcDecl, location);
2931 }
2932 // REVIST - do we report an error?
2933 else if (dstDecl != srcDecl) {
2934 }
2935 }
2936 }
2937
2938 private void addGlobalTypeDecls(SchemaGrammar srcGrammar, SchemaGrammar dstGrammar) {
2939 XSNamedMap components = srcGrammar.getComponents(XSConstants.TYPE_DEFINITION);
2940 int len = components.getLength();
2941 XSTypeDefinition srcDecl, dstDecl;
2942
2943 // add global components
2944 for (int i=0; i<len; i++) {
2945 srcDecl = (XSTypeDefinition) components.item(i);
2946 dstDecl = dstGrammar.getGlobalTypeDecl(srcDecl.getName());
2947 if (dstDecl == null) {
2948 dstGrammar.addGlobalTypeDecl(srcDecl);
2949 }
2950 else if (dstDecl != srcDecl && !fTolerateDuplicates) {
2951 reportSharingError(srcDecl.getNamespace(), srcDecl.getName());
2952 }
2953 }
2954
2955 // add any extended (duplicate) global components
2956 ObjectList componentsExt = srcGrammar.getComponentsExt(XSConstants.TYPE_DEFINITION);
2957 len = componentsExt.getLength();
2958
2959 for (int i=0; i<len; i+= 2) {
2960 final String key = (String) componentsExt.item(i);
2961 final int index = key.indexOf(',');
2962 final String location = key.substring(0, index);
2963 final String name = key.substring(index + 1, key.length());
2964
2965 srcDecl = (XSTypeDefinition)componentsExt.item(i+1);
2966 dstDecl = dstGrammar.getGlobalTypeDecl(name, location);
2967 if (dstDecl == null) {
2968 dstGrammar.addGlobalTypeDecl(srcDecl, location);
2969 }
2970 // REVISIT - do we report an error?
2971 else if (dstDecl != srcDecl) {
2972 }
2973 }
2974 }
2975
2976 private Vector expandComponents(XSObject[] components, Map<String, Vector> dependencies) {
2977 Vector newComponents = new Vector();
2978
2979 for (int i=0; i<components.length; i++) {
2980 if (!newComponents.contains(components[i])) {
2981 newComponents.add(components[i]);
2982 }
2983 }
2984
2985 for (int i=0; i<newComponents.size(); i++) {
2986 final XSObject component = (XSObject) newComponents.elementAt(i);
2987 expandRelatedComponents(component, newComponents, dependencies);
2988 }
2989
2990 return newComponents;
2991 }
2992
2993 private void expandRelatedComponents(XSObject component, Vector componentList, Map<String, Vector> dependencies) {
2994 short componentType = component.getType();
2995 switch (componentType) {
2996 case XSConstants.TYPE_DEFINITION :
2997 expandRelatedTypeComponents((XSTypeDefinition) component, componentList, component.getNamespace(), dependencies);
2998 break;
2999 case XSConstants.ATTRIBUTE_DECLARATION :
3000 expandRelatedAttributeComponents((XSAttributeDeclaration) component, componentList, component.getNamespace(), dependencies);
3001 break;
3002 case XSConstants.ATTRIBUTE_GROUP :
3003 expandRelatedAttributeGroupComponents((XSAttributeGroupDefinition) component, componentList, component.getNamespace(), dependencies);
3004 case XSConstants.ELEMENT_DECLARATION :
3005 expandRelatedElementComponents((XSElementDeclaration) component, componentList, component.getNamespace(), dependencies);
3006 break;
3007 case XSConstants.MODEL_GROUP_DEFINITION :
3008 expandRelatedModelGroupDefinitionComponents((XSModelGroupDefinition) component, componentList, component.getNamespace(), dependencies);
3009 case XSConstants.ATTRIBUTE_USE :
3010 //expandRelatedAttributeUseComponents((XSAttributeUse)component, componentList, dependencies);
3011 case XSConstants.NOTATION_DECLARATION :
3012 case XSConstants.IDENTITY_CONSTRAINT :
3013 default :
3014 break;
3015 }
3016 }
3017
3018 private void expandRelatedAttributeComponents(XSAttributeDeclaration decl, Vector componentList, String namespace, Map<String, Vector> dependencies) {
3019 addRelatedType(decl.getTypeDefinition(), componentList, namespace, dependencies);
3020
3021 /*final XSComplexTypeDefinition enclosingType = decl.getEnclosingCTDefinition();
3022 if (enclosingType != null) {
3023 addRelatedType(enclosingType, componentList, namespace, dependencies);
3024 }*/
3025 }
3026
3027 private void expandRelatedElementComponents(XSElementDeclaration decl, Vector componentList, String namespace, Map<String, Vector> dependencies) {
3028 addRelatedType(decl.getTypeDefinition(), componentList, namespace, dependencies);
3029
3030 /*final XSTypeDefinition enclosingType = decl.getEnclosingCTDefinition();
3031 if (enclosingType != null) {
3032 addRelatedType(enclosingType, componentList, namespace, dependencies);
3033 }*/
3034
3035 final XSElementDeclaration subElemDecl = decl.getSubstitutionGroupAffiliation();
3036 if (subElemDecl != null) {
3037 addRelatedElement(subElemDecl, componentList, namespace, dependencies);
3038 }
3039 }
3040
3041 private void expandRelatedTypeComponents(XSTypeDefinition type, Vector componentList, String namespace, Map<String, Vector> dependencies) {
3042 if (type instanceof XSComplexTypeDecl) {
3043 expandRelatedComplexTypeComponents((XSComplexTypeDecl) type, componentList, namespace, dependencies);
3044 }
3045 else if (type instanceof XSSimpleTypeDecl) {
3046 expandRelatedSimpleTypeComponents((XSSimpleTypeDefinition) type, componentList, namespace, dependencies);
3047 }
3048 }
3049
3050 private void expandRelatedModelGroupDefinitionComponents(XSModelGroupDefinition modelGroupDef, Vector componentList,
3051 String namespace, Map<String, Vector> dependencies) {
3052 expandRelatedModelGroupComponents(modelGroupDef.getModelGroup(), componentList, namespace, dependencies);
3053 }
3054
3055 private void expandRelatedAttributeGroupComponents(XSAttributeGroupDefinition attrGroup, Vector componentList
3056 , String namespace, Map<String, Vector> dependencies) {
3057 expandRelatedAttributeUsesComponents(attrGroup.getAttributeUses(), componentList, namespace, dependencies);
3058 }
3059
3060 private void expandRelatedComplexTypeComponents(XSComplexTypeDecl type, Vector componentList, String namespace, Map<String, Vector> dependencies) {
3061 addRelatedType(type.getBaseType(), componentList, namespace, dependencies);
3062 expandRelatedAttributeUsesComponents(type.getAttributeUses(), componentList, namespace, dependencies);
3063 final XSParticle particle = type.getParticle();
3064 if (particle != null) {
3065 expandRelatedParticleComponents(particle, componentList, namespace, dependencies);
3066 }
3067 }
3068
3069 private void expandRelatedSimpleTypeComponents(XSSimpleTypeDefinition type, Vector componentList, String namespace, Map<String, Vector> dependencies) {
3070 final XSTypeDefinition baseType = type.getBaseType();
3071 if (baseType != null) {
3072 addRelatedType(baseType, componentList, namespace, dependencies);
3073 }
3074
3075 final XSTypeDefinition itemType = type.getItemType();
3076 if (itemType != null) {
3077 addRelatedType(itemType, componentList, namespace, dependencies);
3078 }
3079
3080 final XSTypeDefinition primitiveType = type.getPrimitiveType();
3081 if (primitiveType != null) {
3082 addRelatedType(primitiveType, componentList, namespace, dependencies);
3083 }
3084
3085 final XSObjectList memberTypes = type.getMemberTypes();
3086 if (memberTypes.size() > 0) {
3087 for (int i=0; i<memberTypes.size(); i++) {
3088 addRelatedType((XSTypeDefinition)memberTypes.item(i), componentList, namespace, dependencies);
3089 }
3090 }
3091 }
3092
3093 private void expandRelatedAttributeUsesComponents(XSObjectList attrUses, Vector componentList,
3094 String namespace, Map<String, Vector> dependencies) {
3095 final int attrUseSize = (attrUses == null) ? 0 : attrUses.size();
3096 for (int i=0; i<attrUseSize; i++) {
3097 expandRelatedAttributeUseComponents((XSAttributeUse)attrUses.item(i), componentList, namespace, dependencies);
3098 }
3099 }
3100
3101 private void expandRelatedAttributeUseComponents(XSAttributeUse component, Vector componentList,
3102 String namespace, Map<String, Vector> dependencies) {
3103 addRelatedAttribute(component.getAttrDeclaration(), componentList, namespace, dependencies);
3104 }
3105
3106 private void expandRelatedParticleComponents(XSParticle component, Vector componentList,
3107 String namespace, Map<String, Vector> dependencies) {
3108 XSTerm term = component.getTerm();
3109 switch (term.getType()) {
3110 case XSConstants.ELEMENT_DECLARATION :
3111 addRelatedElement((XSElementDeclaration) term, componentList, namespace, dependencies);
3112 break;
3113 case XSConstants.MODEL_GROUP :
3114 expandRelatedModelGroupComponents((XSModelGroup) term, componentList, namespace, dependencies);
3115 break;
3116 default:
3117 break;
3118 }
3119 }
3120
3121 private void expandRelatedModelGroupComponents(XSModelGroup modelGroup, Vector componentList,
3122 String namespace, Map<String, Vector> dependencies) {
3123 XSObjectList particles = modelGroup.getParticles();
3124 final int length = (particles == null) ? 0 : particles.getLength();
3125 for (int i=0; i<length; i++) {
3126 expandRelatedParticleComponents((XSParticle)particles.item(i), componentList, namespace, dependencies);
3127 }
3128 }
3129
3130 private void addRelatedType(XSTypeDefinition type, Vector componentList, String namespace, Map<String, Vector> dependencies) {
3131 if (!type.getAnonymous()) {
3132 if (!type.getNamespace().equals(SchemaSymbols.URI_SCHEMAFORSCHEMA)) { //REVISIT - do we use == instead
3133 if (!componentList.contains(type)) {
3134 final Vector importedNamespaces = findDependentNamespaces(namespace, dependencies);
3135 addNamespaceDependency(namespace, type.getNamespace(), importedNamespaces);
3136 componentList.add(type);
3137 }
3138 }
3139 }
3140 else {
3141 expandRelatedTypeComponents(type, componentList, namespace, dependencies);
3142 }
3143 }
3144
3145 private void addRelatedElement(XSElementDeclaration decl, Vector componentList, String namespace, Map<String, Vector> dependencies) {
3146 if (decl.getScope() == XSConstants.SCOPE_GLOBAL) {
3147 if (!componentList.contains(decl)) {
3148 Vector importedNamespaces = findDependentNamespaces(namespace, dependencies);
3149 addNamespaceDependency(namespace, decl.getNamespace(), importedNamespaces);
3150 componentList.add(decl);
3151 }
3152 }
3153 else {
3154 expandRelatedElementComponents(decl, componentList, namespace, dependencies);
3155 }
3156 }
3157
3158 private void addRelatedAttribute(XSAttributeDeclaration decl, Vector componentList, String namespace, Map<String, Vector> dependencies) {
3159 if (decl.getScope() == XSConstants.SCOPE_GLOBAL) {
3160 if (!componentList.contains(decl)) {
3161 Vector importedNamespaces = findDependentNamespaces(namespace, dependencies);
3162 addNamespaceDependency(namespace, decl.getNamespace(), importedNamespaces);
3163 componentList.add(decl);
3164 }
3165 }
3166 else {
3167 expandRelatedAttributeComponents(decl, componentList, namespace, dependencies);
3168 }
3169 }
3170
3171 private void addGlobalComponents(Vector components, Map<String, Vector> importDependencies) {
3172 final XSDDescription desc = new XSDDescription();
3173 final int size = components.size();
3174
3175 for (int i=0; i<size; i++) {
3176 addGlobalComponent((XSObject) components.elementAt(i), desc);
3177 }
3178 updateImportDependencies(importDependencies);
3179 }
3180
3181 private void addGlobalComponent(XSObject component, XSDDescription desc) {
3182 final String namespace = component.getNamespace();
3183
3184 desc.setNamespace(namespace);
3185 final SchemaGrammar sg = getSchemaGrammar(desc);
3186
3187 short componentType = component.getType();
3188 final String name = component.getName();
3189
3190 switch (componentType) {
3191 case XSConstants.TYPE_DEFINITION :
3192 if (!((XSTypeDefinition) component).getAnonymous()) {
3193 if (sg.getGlobalTypeDecl(name) == null) {
3194 sg.addGlobalTypeDecl((XSTypeDefinition) component);
3195 }
3196 // store the declaration in the extended map, using an empty location
3197 if (sg.getGlobalTypeDecl(name, "") == null) {
3198 sg.addGlobalTypeDecl((XSTypeDefinition) component, "");
3199 }
3200 }
3201 break;
3202 case XSConstants.ATTRIBUTE_DECLARATION :
3203 if (((XSAttributeDecl) component).getScope() == XSAttributeDecl.SCOPE_GLOBAL) {
3204 if (sg.getGlobalAttributeDecl(name) == null) {
3205 sg.addGlobalAttributeDecl((XSAttributeDecl) component);
3206 }
3207 // store the declaration in the extended map, using an empty location
3208 if (sg.getGlobalAttributeDecl(name, "") == null) {
3209 sg.addGlobalAttributeDecl((XSAttributeDecl) component, "");
3210 }
3211 }
3212 break;
3213 case XSConstants.ATTRIBUTE_GROUP :
3214 if (sg.getGlobalAttributeDecl(name) == null) {
3215 sg.addGlobalAttributeGroupDecl((XSAttributeGroupDecl) component);
3216 }
3217 // store the declaration in the extended map, using an empty location
3218 if (sg.getGlobalAttributeDecl(name, "") == null) {
3219 sg.addGlobalAttributeGroupDecl((XSAttributeGroupDecl) component, "");
3220 }
3221 break;
3222 case XSConstants.ELEMENT_DECLARATION :
3223 if (((XSElementDecl) component).getScope() == XSElementDecl.SCOPE_GLOBAL) {
3224 sg.addGlobalElementDeclAll((XSElementDecl) component);
3225
3226 if (sg.getGlobalElementDecl(name) == null) {
3227 sg.addGlobalElementDecl((XSElementDecl) component);
3228 }
3229 // store the declaration in the extended map, using an empty location
3230 if (sg.getGlobalElementDecl(name, "") == null) {
3231 sg.addGlobalElementDecl((XSElementDecl) component, "");
3232 }
3233 }
3234 break;
3235 case XSConstants.MODEL_GROUP_DEFINITION :
3236 if (sg.getGlobalGroupDecl(name) == null) {
3237 sg.addGlobalGroupDecl((XSGroupDecl) component);
3238 }
3239 // store the declaration in the extended map, using an empty location
3240 if (sg.getGlobalGroupDecl(name, "") == null) {
3241 sg.addGlobalGroupDecl((XSGroupDecl) component, "");
3242 }
3243 break;
3244 case XSConstants.NOTATION_DECLARATION :
3245 if (sg.getGlobalNotationDecl(name) == null) {
3246 sg.addGlobalNotationDecl((XSNotationDecl) component);
3247 }
3248 // store the declaration in the extended map, using an empty location
3249 if (sg.getGlobalNotationDecl(name, "") == null) {
3250 sg.addGlobalNotationDecl((XSNotationDecl) component, "");
3251 }
3252 break;
3253 case XSConstants.IDENTITY_CONSTRAINT :
3254 case XSConstants.ATTRIBUTE_USE :
3255 default :
3256 break;
3257 }
3258 }
3259
3260 private void updateImportDependencies(Map<String, Vector> table) {
3261 if (table == null) return;
3262 String namespace;
3263 Vector importList;
3264
3265 for(Map.Entry<String, Vector> entry : table.entrySet()){
3266 namespace = entry.getKey();
3267 importList = entry.getValue();
3268 if (importList.size() > 0) {
3269 expandImportList(namespace, importList);
3270 }
3271 }
3272 }
3273
3274 private void expandImportList(String namespace, Vector namespaceList) {
3275 SchemaGrammar sg = fGrammarBucket.getGrammar(namespace);
3276 // shouldn't be null
3277 if (sg != null) {
3278 Vector isgs = sg.getImportedGrammars();
3279 if (isgs == null) {
3280 isgs = new Vector();
3281 addImportList(sg, isgs, namespaceList);
3282 sg.setImportedGrammars(isgs);
3283 }
3284 else {
3285 updateImportList(sg, isgs, namespaceList);
3286 }
3287 }
3288 }
3289
3290 private void addImportList(SchemaGrammar sg, Vector importedGrammars, Vector namespaceList) {
3291 final int size = namespaceList.size();
3292 SchemaGrammar isg;
3293
3294 for (int i=0; i<size; i++) {
3295 isg = fGrammarBucket.getGrammar((String)namespaceList.elementAt(i));
3296 if (isg != null) {
3297 importedGrammars.add(isg);
3298 }
3299 else {
3300 //REVIST: report an error message
3301 }
3302 }
3303 }
3304
3305 private void updateImportList(SchemaGrammar sg, Vector importedGrammars, Vector namespaceList) {
3306 final int size = namespaceList.size();
3307 SchemaGrammar isg;
3308
3309 for (int i=0; i<size; i++) {
3310 isg = fGrammarBucket.getGrammar((String)namespaceList.elementAt(i));
3311 if (isg != null) {
3312 if (!containedImportedGrammar(importedGrammars, isg)) {
3313 importedGrammars.add(isg);
3314 }
3315 }
3316 else {
3317 //REVIST: report an error message
3318 }
3319 }
3320 }
3321
3322 private boolean containedImportedGrammar(Vector importedGrammar, SchemaGrammar grammar) {
3323 final int size = importedGrammar.size();
3324 SchemaGrammar sg;
3325
3326 for (int i=0; i<size; i++) {
3327 sg = (SchemaGrammar) importedGrammar.elementAt(i);
3328 if (null2EmptyString(sg.getTargetNamespace()).equals(null2EmptyString(grammar.getTargetNamespace()))) {
3329 return true;
3330 }
3331 }
3332 return false;
3333 }
3334
3335 // NOTE: always assuming that fNamespaceGrowth is enabled
3336 // otherwise the grammar should have existed
3337 private SchemaGrammar getSchemaGrammar(XSDDescription desc) {
3338 SchemaGrammar sg = findGrammar(desc, fNamespaceGrowth);
3339
3340 if (sg == null) {
3341 sg = new SchemaGrammar(desc.getNamespace(), desc.makeClone(), fSymbolTable);
3342 fGrammarBucket.putGrammar(sg);
3343 }
3344 else if (sg.isImmutable()){
3345 sg = createGrammarFrom(sg);
3346 }
3347
3348 return sg;
3349 }
3350
3351 private Vector findDependentNamespaces(String namespace, Map table) {
3352 final String ns = null2EmptyString(namespace);
3353 Vector namespaceList = (Vector) getFromMap(table, ns);
3354
3355 if (namespaceList == null) {
3356 namespaceList = new Vector();
3357 table.put(ns, namespaceList);
3358 }
3359
3360 return namespaceList;
3361 }
3362
3363 private void addNamespaceDependency(String namespace1, String namespace2, Vector list) {
3364 final String ns1 = null2EmptyString(namespace1);
3365 final String ns2 = null2EmptyString(namespace2);
3366 if (!ns1.equals(ns2)) {
3367 if (!list.contains(ns2)) {
3368 list.add(ns2);
3369 }
3370 }
3371 }
3372
3373 private void reportSharingError(String namespace, String name) {
3374 final String qName = (namespace == null)
3375 ? "," + name : namespace + "," + name;
3376
3377 reportSchemaError("sch-props-correct.2", new Object [] {qName}, null);
3378 }
3379
3380 // initialize all the traversers.
3381 // this should only need to be called once during the construction
3382 // of this object; it creates the traversers that will be used to
3383
3384 // construct schemaGrammars.
3385 private void createTraversers() {
3386 fAttributeChecker = new XSAttributeChecker(this);
3387 fAttributeGroupTraverser = new XSDAttributeGroupTraverser(this, fAttributeChecker);
3388 fAttributeTraverser = new XSDAttributeTraverser(this, fAttributeChecker);
3389 fComplexTypeTraverser = new XSDComplexTypeTraverser(this, fAttributeChecker);
3390 fElementTraverser = new XSDElementTraverser(this, fAttributeChecker);
3391 fGroupTraverser = new XSDGroupTraverser(this, fAttributeChecker);
3392 fKeyrefTraverser = new XSDKeyrefTraverser(this, fAttributeChecker);
3393 fNotationTraverser = new XSDNotationTraverser(this, fAttributeChecker);
3394 fSimpleTypeTraverser = new XSDSimpleTypeTraverser(this, fAttributeChecker);
3395 fUniqueOrKeyTraverser = new XSDUniqueOrKeyTraverser(this, fAttributeChecker);
3396 fWildCardTraverser = new XSDWildcardTraverser(this, fAttributeChecker);
3397 } // createTraversers()
3398
3399 // before parsing a schema, need to clear registries associated with
3400 // parsing schemas
3401 void prepareForParse() {
3402 fTraversed.clear();
3403 fDoc2SystemId.clear();
3404 fHiddenNodes.clear();
3405 fLastSchemaWasDuplicate = false;
3406 }
3407
3408 // before traversing a schema's parse tree, need to reset all traversers and
3409 // clear all registries
3410 void prepareForTraverse() {
3411 if (!registryEmpty) {
3412 fUnparsedAttributeRegistry.clear();
3413 fUnparsedAttributeGroupRegistry.clear();
3414 fUnparsedElementRegistry.clear();
3415 fUnparsedGroupRegistry.clear();
3416 fUnparsedIdentityConstraintRegistry.clear();
3417 fUnparsedNotationRegistry.clear();
3418 fUnparsedTypeRegistry.clear();
3419
3420 fUnparsedAttributeRegistrySub.clear();
3421 fUnparsedAttributeGroupRegistrySub.clear();
3422 fUnparsedElementRegistrySub.clear();
3423 fUnparsedGroupRegistrySub.clear();
3424 fUnparsedIdentityConstraintRegistrySub.clear();
3425 fUnparsedNotationRegistrySub.clear();
3426 fUnparsedTypeRegistrySub.clear();
3427 }
3428
3429 for (int i=1; i<= TYPEDECL_TYPE; i++) {
3430 if (fUnparsedRegistriesExt[i] != null)
3431 fUnparsedRegistriesExt[i].clear();
3432 }
3433
3434 fDependencyMap.clear();
3435 fDoc2XSDocumentMap.clear();
3436 if (fRedefine2XSDMap != null) fRedefine2XSDMap.clear();
3437 if (fRedefine2NSSupport != null) fRedefine2NSSupport.clear();
3438 fAllTNSs.removeAllElements();
3439 fImportMap.clear();
3440 fRoot = null;
3441
3442 // clear local element stack
3443 for (int i = 0; i < fLocalElemStackPos; i++) {
3444 fParticle[i] = null;
3445 fLocalElementDecl[i] = null;
3446 fLocalElementDecl_schema[i] = null;
3447 fLocalElemNamespaceContext[i] = null;
3448 }
3449 fLocalElemStackPos = 0;
3450
3451 // and do same for keyrefs.
3452 for (int i = 0; i < fKeyrefStackPos; i++) {
3453 fKeyrefs[i] = null;
3454 fKeyrefElems[i] = null;
3455 fKeyrefNamespaceContext[i] = null;
3456 fKeyrefsMapXSDocumentInfo[i] = null;
3457 }
3458 fKeyrefStackPos = 0;
3459
3460 // create traversers if necessary
3461 if (fAttributeChecker == null) {
3462 createTraversers();
3463 }
3464
3465 // reset traversers
3466 Locale locale = fErrorReporter.getLocale();
3467 fAttributeChecker.reset(fSymbolTable);
3468 fAttributeGroupTraverser.reset(fSymbolTable, fValidateAnnotations, locale);
3469 fAttributeTraverser.reset(fSymbolTable, fValidateAnnotations, locale);
3470 fComplexTypeTraverser.reset(fSymbolTable, fValidateAnnotations, locale);
3471 fElementTraverser.reset(fSymbolTable, fValidateAnnotations, locale);
3472 fGroupTraverser.reset(fSymbolTable, fValidateAnnotations, locale);
3473 fKeyrefTraverser.reset(fSymbolTable, fValidateAnnotations, locale);
3474 fNotationTraverser.reset(fSymbolTable, fValidateAnnotations, locale);
3475 fSimpleTypeTraverser.reset(fSymbolTable, fValidateAnnotations, locale);
3476 fUniqueOrKeyTraverser.reset(fSymbolTable, fValidateAnnotations, locale);
3477 fWildCardTraverser.reset(fSymbolTable, fValidateAnnotations, locale);
3478
3479 fRedefinedRestrictedAttributeGroupRegistry.clear();
3480 fRedefinedRestrictedGroupRegistry.clear();
3481
3482 fGlobalAttrDecls.clear();
3483 fGlobalAttrGrpDecls.clear();
3484 fGlobalElemDecls.clear();
3485 fGlobalGroupDecls.clear();
3486 fGlobalNotationDecls.clear();
3487 fGlobalIDConstraintDecls.clear();
3488 fGlobalTypeDecls.clear();
3489 }
3490 public void setDeclPool (XSDeclarationPool declPool){
3491 fDeclPool = declPool;
3492 }
3493 public void setDVFactory(SchemaDVFactory dvFactory){
3494 fDVFactory = dvFactory;
3495 }
3496 public SchemaDVFactory getDVFactory(){
3497 return fDVFactory;
3498 }
3499
3500 public void reset(XMLComponentManager componentManager) {
3501
3502 // set symbol table
3503 fSymbolTable = (SymbolTable) componentManager.getProperty(SYMBOL_TABLE);
3504
3505 fSecureProcessing = null;
3506 if( componentManager!=null ) {
3507 fSecureProcessing = (XMLSecurityManager) componentManager.getProperty(SECURE_PROCESSING, null);
3508 }
3509
3510 //set entity resolver
3511 fEntityResolver = (XMLEntityResolver) componentManager.getProperty(ENTITY_MANAGER);
3512 XMLEntityResolver er = (XMLEntityResolver)componentManager.getProperty(ENTITY_RESOLVER);
3513 if (er != null)
3514 fSchemaParser.setEntityResolver(er);
3515
3516 // set error reporter
3517 fErrorReporter =
3518 (XMLErrorReporter) componentManager.getProperty(ERROR_REPORTER);
3519 try {
3520 XMLErrorHandler currErrorHandler = fErrorReporter.getErrorHandler();
3521 // Setting a parser property can be much more expensive
3522 // than checking its value. Don't set the ERROR_HANDLER
3523 // or LOCALE properties unless they've actually changed.
3524 if (currErrorHandler != fSchemaParser.getProperty(ERROR_HANDLER)) {
3525 fSchemaParser.setProperty(ERROR_HANDLER, (currErrorHandler != null) ? currErrorHandler : new DefaultErrorHandler());
3526 if (fAnnotationValidator != null) {
3527 fAnnotationValidator.setProperty(ERROR_HANDLER, (currErrorHandler != null) ? currErrorHandler : new DefaultErrorHandler());
3528 }
3529 }
3530 Locale currentLocale = fErrorReporter.getLocale();
3531 if (currentLocale != fSchemaParser.getProperty(LOCALE)) {
3532 fSchemaParser.setProperty(LOCALE, currentLocale);
3533 if (fAnnotationValidator != null) {
3534 fAnnotationValidator.setProperty(LOCALE, currentLocale);
3535 }
3536 }
3537 }
3538 catch (XMLConfigurationException e) {}
3539
3540 fValidateAnnotations = componentManager.getFeature(VALIDATE_ANNOTATIONS, false);
3541 fHonourAllSchemaLocations = componentManager.getFeature(HONOUR_ALL_SCHEMALOCATIONS, false);
3542 fNamespaceGrowth = componentManager.getFeature(NAMESPACE_GROWTH, false);
3543 fTolerateDuplicates = componentManager.getFeature(TOLERATE_DUPLICATES, false);
3544
3545 try {
3546 fSchemaParser.setFeature(
3547 CONTINUE_AFTER_FATAL_ERROR,
3548 fErrorReporter.getFeature(CONTINUE_AFTER_FATAL_ERROR));
3549 } catch (XMLConfigurationException e) {
3550 }
3551
3552 try {
3553 if (componentManager.getFeature(ALLOW_JAVA_ENCODINGS, false)) {
3554 fSchemaParser.setFeature(ALLOW_JAVA_ENCODINGS, true);
3555 }
3556 } catch (XMLConfigurationException e) {
3557 }
3558 try {
3559 if (componentManager.getFeature(STANDARD_URI_CONFORMANT_FEATURE, false)) {
3560 fSchemaParser.setFeature(STANDARD_URI_CONFORMANT_FEATURE, true);
3561 }
3562 } catch (XMLConfigurationException e) {
3563 }
3564
3565 try {
3566 fGrammarPool =
3567 (XMLGrammarPool) componentManager.getProperty(XMLGRAMMAR_POOL);
3568 } catch (XMLConfigurationException e) {
3569 fGrammarPool = null;
3570 }
3571 // security features
3572 try {
3573 if (componentManager.getFeature(DISALLOW_DOCTYPE, false)) {
3574 fSchemaParser.setFeature(DISALLOW_DOCTYPE, true);
3575 }
3576 } catch (XMLConfigurationException e) {
3577 }
3578 try {
3579 Object security = componentManager.getProperty(SECURITY_MANAGER, null);
3580 if (security != null){
3581 fSchemaParser.setProperty(SECURITY_MANAGER, security);
3582 }
3583 } catch (XMLConfigurationException e) {
3584 }
3585
3586 XMLSecurityPropertyManager securityPropertyMgr = (XMLSecurityPropertyManager)
3587 componentManager.getProperty(XML_SECURITY_PROPERTY_MANAGER);
3588 //Passing on the setting to the parser
3589 fSchemaParser.setProperty(XML_SECURITY_PROPERTY_MANAGER, securityPropertyMgr);
3590
3591 fAccessExternalDTD = securityPropertyMgr.getValue(
3592 XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_DTD);
3593
3594 fAccessExternalSchema = securityPropertyMgr.getValue(
3595 XMLSecurityPropertyManager.Property.ACCESS_EXTERNAL_SCHEMA);
3596
3597 } // reset(XMLComponentManager)
3598
3599
3600 /**
3601 * Traverse all the deferred local elements. This method should be called
3602 * by traverseSchemas after we've done with all the global declarations.
3603 */
3604 void traverseLocalElements() {
3605 fElementTraverser.fDeferTraversingLocalElements = false;
3606
3607 for (int i = 0; i < fLocalElemStackPos; i++) {
3608 Element currElem = fLocalElementDecl[i];
3609 //XSDocumentInfo currSchema = (XSDocumentInfo)fDoc2XSDocumentMap.get(DOMUtil.getDocument(currElem));
3610 //XSDocumentInfo currSchema = (XSDocumentInfo)fDoc2XSDocumentMap.get(DOMUtil.getRoot(DOMUtil.getDocument(currElem)));
3611 XSDocumentInfo currSchema = fLocalElementDecl_schema[i];
3612 SchemaGrammar currGrammar = fGrammarBucket.getGrammar(currSchema.fTargetNamespace);
3613 fElementTraverser.traverseLocal (fParticle[i], currElem, currSchema, currGrammar, fAllContext[i], fParent[i], fLocalElemNamespaceContext[i]);
3614 // If it's an empty particle, remove it from the containing component.
3615 if (fParticle[i].fType == XSParticleDecl.PARTICLE_EMPTY) {
3616 XSModelGroupImpl group = null;
3617 if (fParent[i] instanceof XSComplexTypeDecl) {
3618 XSParticle p = ((XSComplexTypeDecl)fParent[i]).getParticle();
3619 if (p != null)
3620 group = (XSModelGroupImpl)p.getTerm();
3621 }
3622 else {
3623 group = ((XSGroupDecl)fParent[i]).fModelGroup;
3624 }
3625 if (group != null)
3626 removeParticle(group, fParticle[i]);
3627 }
3628 }
3629 }
3630
3631 private boolean removeParticle(XSModelGroupImpl group, XSParticleDecl particle) {
3632 XSParticleDecl member;
3633 for (int i = 0; i < group.fParticleCount; i++) {
3634 member = group.fParticles[i];
3635 if (member == particle) {
3636 for (int j = i; j < group.fParticleCount-1; j++)
3637 group.fParticles[j] = group.fParticles[j+1];
3638 group.fParticleCount--;
3639 return true;
3640 }
3641 if (member.fType == XSParticleDecl.PARTICLE_MODELGROUP) {
3642 if (removeParticle((XSModelGroupImpl)member.fValue, particle))
3643 return true;
3644 }
3645 }
3646 return false;
3647 }
3648
3649 // the purpose of this method is to keep up-to-date structures
3650 // we'll need for the feferred traversal of local elements.
3651 void fillInLocalElemInfo(Element elmDecl,
3652 XSDocumentInfo schemaDoc,
3653 int allContextFlags,
3654 XSObject parent,
3655 XSParticleDecl particle) {
3656
3657 // if the stack is full, increase the size
3658 if (fParticle.length == fLocalElemStackPos) {
3659 // increase size
3660 XSParticleDecl[] newStackP = new XSParticleDecl[fLocalElemStackPos+INC_STACK_SIZE];
3661 System.arraycopy(fParticle, 0, newStackP, 0, fLocalElemStackPos);
3662 fParticle = newStackP;
3663 Element[] newStackE = new Element[fLocalElemStackPos+INC_STACK_SIZE];
3664 System.arraycopy(fLocalElementDecl, 0, newStackE, 0, fLocalElemStackPos);
3665 fLocalElementDecl = newStackE;
3666 XSDocumentInfo [] newStackE_schema = new XSDocumentInfo[fLocalElemStackPos+INC_STACK_SIZE];
3667 System.arraycopy(fLocalElementDecl_schema, 0, newStackE_schema, 0, fLocalElemStackPos);
3668 fLocalElementDecl_schema = newStackE_schema;
3669 int[] newStackI = new int[fLocalElemStackPos+INC_STACK_SIZE];
3670 System.arraycopy(fAllContext, 0, newStackI, 0, fLocalElemStackPos);
3671 fAllContext = newStackI;
3672 XSObject[] newStackC = new XSObject[fLocalElemStackPos+INC_STACK_SIZE];
3673 System.arraycopy(fParent, 0, newStackC, 0, fLocalElemStackPos);
3674 fParent = newStackC;
3675 String [][] newStackN = new String [fLocalElemStackPos+INC_STACK_SIZE][];
3676 System.arraycopy(fLocalElemNamespaceContext, 0, newStackN, 0, fLocalElemStackPos);
3677 fLocalElemNamespaceContext = newStackN;
3678 }
3679
3680 fParticle[fLocalElemStackPos] = particle;
3681 fLocalElementDecl[fLocalElemStackPos] = elmDecl;
3682 fLocalElementDecl_schema[fLocalElemStackPos] = schemaDoc;
3683 fAllContext[fLocalElemStackPos] = allContextFlags;
3684 fParent[fLocalElemStackPos] = parent;
3685 fLocalElemNamespaceContext[fLocalElemStackPos++] = schemaDoc.fNamespaceSupport.getEffectiveLocalContext();
3686 } // end fillInLocalElemInfo(...)
3687
3688 /** This method makes sure that
3689 * if this component is being redefined that it lives in the
3690 * right schema. It then renames the component correctly. If it
3691 * detects a collision--a duplicate definition--then it complains.
3692 * Note that redefines must be handled carefully: if there
3693 * is a collision, it may be because we're redefining something we know about
3694 * or because we've found the thing we're redefining.
3695 */
3696 void checkForDuplicateNames(String qName, int declType,
3697 Map<String,Element> registry, Map<String,XSDocumentInfo> registry_sub, Element currComp,
3698 XSDocumentInfo currSchema) {
3699 Object objElem = null;
3700 // REVISIT: when we add derivation checking, we'll have to make
3701 // sure that ID constraint collisions don't necessarily result in error messages.
3702 if ((objElem = registry.get(qName)) == null) {
3703 // need to check whether we have a global declaration in the corresponding
3704 // grammar
3705 if (fNamespaceGrowth && !fTolerateDuplicates) {
3706 checkForDuplicateNames(qName, declType, currComp);
3707 }
3708 // just add it in!
3709 registry.put(qName, currComp);
3710 registry_sub.put(qName, currSchema);
3711 }
3712 else {
3713 Element collidingElem = (Element)objElem;
3714 XSDocumentInfo collidingElemSchema = (XSDocumentInfo)registry_sub.get(qName);
3715 if (collidingElem == currComp) return;
3716 Element elemParent = null;
3717 XSDocumentInfo redefinedSchema = null;
3718 // case where we've collided with a redefining element
3719 // (the parent of the colliding element is a redefine)
3720 boolean collidedWithRedefine = true;
3721 if ((DOMUtil.getLocalName((elemParent = DOMUtil.getParent(collidingElem))).equals(SchemaSymbols.ELT_REDEFINE))) {
3722 redefinedSchema = (fRedefine2XSDMap != null)?(XSDocumentInfo) (fRedefine2XSDMap.get(elemParent)): null;
3723 // case where we're a redefining element.
3724 }
3725 else if ((DOMUtil.getLocalName(DOMUtil.getParent(currComp)).equals(SchemaSymbols.ELT_REDEFINE))) {
3726 redefinedSchema = collidingElemSchema;
3727 collidedWithRedefine = false;
3728 }
3729 if (redefinedSchema != null) { //redefinition involved somehow
3730 // If both components belong to the same document then
3731 // report an error and return.
3732 if(collidingElemSchema == currSchema){
3733 reportSchemaError("sch-props-correct.2", new Object[]{qName}, currComp);
3734 return;
3735 }
3736
3737 String newName = qName.substring(qName.lastIndexOf(',')+1)+REDEF_IDENTIFIER;
3738 if (redefinedSchema == currSchema) { // object comp. okay here
3739 // now have to do some renaming...
3740 currComp.setAttribute(SchemaSymbols.ATT_NAME, newName);
3741 if (currSchema.fTargetNamespace == null){
3742 registry.put(","+newName, currComp);
3743 registry_sub.put(","+newName, currSchema);
3744 }
3745 else{
3746 registry.put(currSchema.fTargetNamespace+","+newName, currComp);
3747 registry_sub.put(currSchema.fTargetNamespace+","+newName, currSchema);
3748 }
3749 // and take care of nested redefines by calling recursively:
3750 if (currSchema.fTargetNamespace == null)
3751 checkForDuplicateNames(","+newName, declType, registry, registry_sub, currComp, currSchema);
3752 else
3753 checkForDuplicateNames(currSchema.fTargetNamespace+","+newName, declType, registry, registry_sub, currComp, currSchema);
3754 }
3755 else { // we may be redefining the wrong schema
3756 if (collidedWithRedefine) {
3757 if (currSchema.fTargetNamespace == null)
3758 checkForDuplicateNames(","+newName, declType, registry, registry_sub, currComp, currSchema);
3759 else
3760 checkForDuplicateNames(currSchema.fTargetNamespace+","+newName, declType, registry, registry_sub, currComp, currSchema);
3761 }
3762 else {
3763 // error that redefined element in wrong schema
3764 reportSchemaError("sch-props-correct.2", new Object [] {qName}, currComp);
3765 }
3766 }
3767 }
3768 else {
3769 // we've just got a flat-out collision (we tolerate duplicate
3770 // declarations, only if they are defined in different schema
3771 // documents)
3772 if (!fTolerateDuplicates) {
3773 reportSchemaError("sch-props-correct.2", new Object []{qName}, currComp);
3774 } else if (fUnparsedRegistriesExt[declType] != null) {
3775 if (fUnparsedRegistriesExt[declType].get(qName) == currSchema) {
3776 reportSchemaError("sch-props-correct.2", new Object []{qName}, currComp);
3777 }
3778 }
3779 }
3780 }
3781
3782 // store the lastest current document info
3783 if (fTolerateDuplicates) {
3784 if (fUnparsedRegistriesExt[declType] == null)
3785 fUnparsedRegistriesExt[declType] = new HashMap();
3786 fUnparsedRegistriesExt[declType].put(qName, currSchema);
3787 }
3788
3789 } // checkForDuplicateNames(String, Map, Element, XSDocumentInfo):void
3790
3791 void checkForDuplicateNames(String qName, int declType, Element currComp) {
3792 int namespaceEnd = qName.indexOf(',');
3793 String namespace = qName.substring(0, namespaceEnd);
3794 SchemaGrammar grammar = fGrammarBucket.getGrammar(emptyString2Null(namespace));
3795
3796 if (grammar != null) {
3797 Object obj = getGlobalDeclFromGrammar(grammar, declType, qName.substring(namespaceEnd + 1));
3798 if (obj != null) {
3799 reportSchemaError("sch-props-correct.2", new Object []{qName}, currComp);
3800 }
3801 }
3802 }
3803
3804 // the purpose of this method is to take the component of the
3805 // specified type and rename references to itself so that they
3806 // refer to the object being redefined. It takes special care of
3807 // <group>s and <attributeGroup>s to ensure that information
3808 // relating to implicit restrictions is preserved for those
3809 // traversers.
3810 private void renameRedefiningComponents(XSDocumentInfo currSchema,
3811 Element child, String componentType,
3812 String oldName, String newName) {
3813 if (componentType.equals(SchemaSymbols.ELT_SIMPLETYPE)) {
3814 Element grandKid = DOMUtil.getFirstChildElement(child);
3815 if (grandKid == null) {
3816 reportSchemaError("src-redefine.5.a.a", null, child);
3817 }
3818 else {
3819 String grandKidName = DOMUtil.getLocalName(grandKid);
3820 if (grandKidName.equals(SchemaSymbols.ELT_ANNOTATION)) {
3821 grandKid = DOMUtil.getNextSiblingElement(grandKid);
3822 }
3823 if (grandKid == null) {
3824 reportSchemaError("src-redefine.5.a.a", null, child);
3825 }
3826 else {
3827 grandKidName = DOMUtil.getLocalName(grandKid);
3828 if (!grandKidName.equals(SchemaSymbols.ELT_RESTRICTION)) {
3829 reportSchemaError("src-redefine.5.a.b", new Object[]{grandKidName}, child);
3830 }
3831 else {
3832 Object[] attrs = fAttributeChecker.checkAttributes(grandKid, false, currSchema);
3833 QName derivedBase = (QName)attrs[XSAttributeChecker.ATTIDX_BASE];
3834 if (derivedBase == null ||
3835 derivedBase.uri != currSchema.fTargetNamespace ||
3836 !derivedBase.localpart.equals(oldName)) {
3837 reportSchemaError("src-redefine.5.a.c",
3838 new Object[]{grandKidName,
3839 (currSchema.fTargetNamespace==null?"":currSchema.fTargetNamespace)
3840 + "," + oldName},
3841 child);
3842 }
3843 else {
3844 // now we have to do the renaming...
3845 if (derivedBase.prefix != null && derivedBase.prefix.length() > 0)
3846 grandKid.setAttribute( SchemaSymbols.ATT_BASE,
3847 derivedBase.prefix + ":" + newName );
3848 else
3849 grandKid.setAttribute( SchemaSymbols.ATT_BASE, newName );
3850 // return true;
3851 }
3852 fAttributeChecker.returnAttrArray(attrs, currSchema);
3853 }
3854 }
3855 }
3856 }
3857 else if (componentType.equals(SchemaSymbols.ELT_COMPLEXTYPE)) {
3858 Element grandKid = DOMUtil.getFirstChildElement(child);
3859 if (grandKid == null) {
3860 reportSchemaError("src-redefine.5.b.a", null, child);
3861 }
3862 else {
3863 if (DOMUtil.getLocalName(grandKid).equals(SchemaSymbols.ELT_ANNOTATION)) {
3864 grandKid = DOMUtil.getNextSiblingElement(grandKid);
3865 }
3866 if (grandKid == null) {
3867 reportSchemaError("src-redefine.5.b.a", null, child);
3868 }
3869 else {
3870 // have to go one more level down; let another pass worry whether complexType is valid.
3871 Element greatGrandKid = DOMUtil.getFirstChildElement(grandKid);
3872 if (greatGrandKid == null) {
3873 reportSchemaError("src-redefine.5.b.b", null, grandKid);
3874 }
3875 else {
3876 String greatGrandKidName = DOMUtil.getLocalName(greatGrandKid);
3877 if (greatGrandKidName.equals(SchemaSymbols.ELT_ANNOTATION)) {
3878 greatGrandKid = DOMUtil.getNextSiblingElement(greatGrandKid);
3879 }
3880 if (greatGrandKid == null) {
3881 reportSchemaError("src-redefine.5.b.b", null, grandKid);
3882 }
3883 else {
3884 greatGrandKidName = DOMUtil.getLocalName(greatGrandKid);
3885 if (!greatGrandKidName.equals(SchemaSymbols.ELT_RESTRICTION) &&
3886 !greatGrandKidName.equals(SchemaSymbols.ELT_EXTENSION)) {
3887 reportSchemaError("src-redefine.5.b.c", new Object[]{greatGrandKidName}, greatGrandKid);
3888 }
3889 else {
3890 Object[] attrs = fAttributeChecker.checkAttributes(greatGrandKid, false, currSchema);
3891 QName derivedBase = (QName)attrs[XSAttributeChecker.ATTIDX_BASE];
3892 if (derivedBase == null ||
3893 derivedBase.uri != currSchema.fTargetNamespace ||
3894 !derivedBase.localpart.equals(oldName)) {
3895 reportSchemaError("src-redefine.5.b.d",
3896 new Object[]{greatGrandKidName,
3897 (currSchema.fTargetNamespace==null?"":currSchema.fTargetNamespace)
3898 + "," + oldName},
3899 greatGrandKid);
3900 }
3901 else {
3902 // now we have to do the renaming...
3903 if (derivedBase.prefix != null && derivedBase.prefix.length() > 0)
3904 greatGrandKid.setAttribute( SchemaSymbols.ATT_BASE,
3905 derivedBase.prefix + ":" + newName );
3906 else
3907 greatGrandKid.setAttribute( SchemaSymbols.ATT_BASE,
3908 newName );
3909 // return true;
3910 }
3911 }
3912 }
3913 }
3914 }
3915 }
3916 }
3917 else if (componentType.equals(SchemaSymbols.ELT_ATTRIBUTEGROUP)) {
3918 String processedBaseName = (currSchema.fTargetNamespace == null)?
3919 ","+oldName:currSchema.fTargetNamespace+","+oldName;
3920 int attGroupRefsCount = changeRedefineGroup(processedBaseName, componentType, newName, child, currSchema);
3921 if (attGroupRefsCount > 1) {
3922 reportSchemaError("src-redefine.7.1", new Object []{new Integer(attGroupRefsCount)}, child);
3923 }
3924 else if (attGroupRefsCount == 1) {
3925 // return true;
3926 }
3927 else
3928 if (currSchema.fTargetNamespace == null)
3929 fRedefinedRestrictedAttributeGroupRegistry.put(processedBaseName, ","+newName);
3930 else
3931 fRedefinedRestrictedAttributeGroupRegistry.put(processedBaseName, currSchema.fTargetNamespace+","+newName);
3932 }
3933 else if (componentType.equals(SchemaSymbols.ELT_GROUP)) {
3934 String processedBaseName = (currSchema.fTargetNamespace == null)?
3935 ","+oldName:currSchema.fTargetNamespace+","+oldName;
3936 int groupRefsCount = changeRedefineGroup(processedBaseName, componentType, newName, child, currSchema);
3937 if (groupRefsCount > 1) {
3938 reportSchemaError("src-redefine.6.1.1", new Object []{new Integer(groupRefsCount)}, child);
3939 }
3940 else if (groupRefsCount == 1) {
3941 // return true;
3942 }
3943 else {
3944 if (currSchema.fTargetNamespace == null)
3945 fRedefinedRestrictedGroupRegistry.put(processedBaseName, ","+newName);
3946 else
3947 fRedefinedRestrictedGroupRegistry.put(processedBaseName, currSchema.fTargetNamespace+","+newName);
3948 }
3949 }
3950 else {
3951 reportSchemaError("Internal-Error", new Object [] {"could not handle this particular <redefine>; please submit your schemas and instance document in a bug report!"}, child);
3952 }
3953 // if we get here then we must have reported an error and failed somewhere...
3954 // return false;
3955 } // renameRedefiningComponents(XSDocumentInfo, Element, String, String, String):void
3956
3957 // this method takes a name of the form a:b, determines the URI mapped
3958 // to by a in the current SchemaNamespaceSupport object, and returns this
3959 // information in the form (nsURI,b) suitable for lookups in the global
3960 // decl maps.
3961 // REVISIT: should have it return QName, instead of String. this would
3962 // save lots of string concatenation time. we can use
3963 // QName#equals() to compare two QNames, and use QName directly
3964 // as a key to the SymbolHash.
3965 // And when the DV's are ready to return compiled values from
3966 // validate() method, we should just call QNameDV.validate()
3967 // in this method.
3968 private String findQName(String name, XSDocumentInfo schemaDoc) {
3969 SchemaNamespaceSupport currNSMap = schemaDoc.fNamespaceSupport;
3970 int colonPtr = name.indexOf(':');
3971 String prefix = XMLSymbols.EMPTY_STRING;
3972 if (colonPtr > 0)
3973 prefix = name.substring(0, colonPtr);
3974 String uri = currNSMap.getURI(fSymbolTable.addSymbol(prefix));
3975 String localpart = (colonPtr == 0)?name:name.substring(colonPtr+1);
3976 if (prefix == XMLSymbols.EMPTY_STRING && uri == null && schemaDoc.fIsChameleonSchema)
3977 uri = schemaDoc.fTargetNamespace;
3978 if (uri == null)
3979 return ","+localpart;
3980 return uri+","+localpart;
3981 } // findQName(String, XSDocumentInfo): String
3982
3983 // This function looks among the children of curr for an element of type elementSought.
3984 // If it finds one, it evaluates whether its ref attribute contains a reference
3985 // to originalQName. If it does, it returns 1 + the value returned by
3986 // calls to itself on all other children. In all other cases it returns 0 plus
3987 // the sum of the values returned by calls to itself on curr's children.
3988 // It also resets the value of ref so that it will refer to the renamed type from the schema
3989 // being redefined.
3990 private int changeRedefineGroup(String originalQName, String elementSought,
3991 String newName, Element curr, XSDocumentInfo schemaDoc) {
3992 int result = 0;
3993 for (Element child = DOMUtil.getFirstChildElement(curr);
3994 child != null; child = DOMUtil.getNextSiblingElement(child)) {
3995 String name = DOMUtil.getLocalName(child);
3996 if (!name.equals(elementSought))
3997 result += changeRedefineGroup(originalQName, elementSought, newName, child, schemaDoc);
3998 else {
3999 String ref = child.getAttribute( SchemaSymbols.ATT_REF );
4000 if (ref.length() != 0) {
4001 String processedRef = findQName(ref, schemaDoc);
4002 if (originalQName.equals(processedRef)) {
4003 String prefix = XMLSymbols.EMPTY_STRING;
4004 int colonptr = ref.indexOf(":");
4005 if (colonptr > 0) {
4006 prefix = ref.substring(0,colonptr);
4007 child.setAttribute(SchemaSymbols.ATT_REF, prefix + ":" + newName);
4008 }
4009 else
4010 child.setAttribute(SchemaSymbols.ATT_REF, newName);
4011 result++;
4012 if (elementSought.equals(SchemaSymbols.ELT_GROUP)) {
4013 String minOccurs = child.getAttribute( SchemaSymbols.ATT_MINOCCURS );
4014 String maxOccurs = child.getAttribute( SchemaSymbols.ATT_MAXOCCURS );
4015 if (!((maxOccurs.length() == 0 || maxOccurs.equals("1"))
4016 && (minOccurs.length() == 0 || minOccurs.equals("1")))) {
4017 reportSchemaError("src-redefine.6.1.2", new Object [] {ref}, child);
4018 }
4019 }
4020 }
4021 } // if ref was null some other stage of processing will flag the error
4022 }
4023 }
4024 return result;
4025 } // changeRedefineGroup
4026
4027 // this method returns the XSDocumentInfo object that contains the
4028 // component corresponding to decl. If components from this
4029 // document cannot be referred to from those of currSchema, this
4030 // method returns null; it's up to the caller to throw an error.
4031 // @param: currSchema: the XSDocumentInfo object containing the
4032 // decl ref'ing us.
4033 // @param: decl: the declaration being ref'd.
4034 // this method is superficial now. ---Jack
4035 private XSDocumentInfo findXSDocumentForDecl(XSDocumentInfo currSchema,
4036 Element decl, XSDocumentInfo decl_Doc) {
4037
4038 if (DEBUG_NODE_POOL) {
4039 System.out.println("DOCUMENT NS:"+ currSchema.fTargetNamespace+" hashcode:"+ ((Object)currSchema.fSchemaElement).hashCode());
4040 }
4041 Object temp = decl_Doc;
4042 if (temp == null) {
4043 // something went badly wrong; we don't know this doc?
4044 return null;
4045 }
4046 XSDocumentInfo declDocInfo = (XSDocumentInfo)temp;
4047 return declDocInfo;
4048 /*********
4049 Logic here is unnecessary after schema WG's recent decision to allow
4050 schema components from one document to refer to components of any other,
4051 so long as there's some include/import/redefine path amongst them.
4052 If they rver reverse this decision the code's right here though... - neilg
4053 // now look in fDependencyMap to see if this is reachable
4054 if(((Vector)fDependencyMap.get(currSchema)).contains(declDocInfo)) {
4055 return declDocInfo;
4056 }
4057 // obviously the requesting doc didn't include, redefine or
4058 // import the one containing decl...
4059 return null;
4060 **********/
4061 } // findXSDocumentForDecl(XSDocumentInfo, Element): XSDocumentInfo
4062
4063 // returns whether more than <annotation>s occur in children of elem
4064 private boolean nonAnnotationContent(Element elem) {
4065 for(Element child = DOMUtil.getFirstChildElement(elem); child != null; child = DOMUtil.getNextSiblingElement(child)) {
4066 if(!(DOMUtil.getLocalName(child).equals(SchemaSymbols.ELT_ANNOTATION))) return true;
4067 }
4068 return false;
4069 } // nonAnnotationContent(Element): boolean
4070
4071 private void setSchemasVisible(XSDocumentInfo startSchema) {
4072 if (DOMUtil.isHidden(startSchema.fSchemaElement, fHiddenNodes)) {
4073 // make it visible
4074 DOMUtil.setVisible(startSchema.fSchemaElement, fHiddenNodes);
4075 Vector dependingSchemas = (Vector)fDependencyMap.get(startSchema);
4076 for (int i = 0; i < dependingSchemas.size(); i++) {
4077 setSchemasVisible((XSDocumentInfo)dependingSchemas.elementAt(i));
4078 }
4079 }
4080 // if it's visible already than so must be its children
4081 } // setSchemasVisible(XSDocumentInfo): void
4082
4083 private SimpleLocator xl = new SimpleLocator();
4084
4085 /**
4086 * Extract location information from an Element node, and create a
4087 * new SimpleLocator object from such information. Returning null means
4088 * no information can be retrieved from the element.
4089 */
4090 public SimpleLocator element2Locator(Element e) {
4091 if (!( e instanceof ElementImpl))
4092 return null;
4093
4094 SimpleLocator l = new SimpleLocator();
4095 return element2Locator(e, l) ? l : null;
4096 }
4097
4098 /**
4099 * Extract location information from an Element node, store such
4100 * information in the passed-in SimpleLocator object, then return
4101 * true. Returning false means can't extract or store such information.
4102 */
4103 public boolean element2Locator(Element e, SimpleLocator l) {
4104 if (l == null)
4105 return false;
4106 if (e instanceof ElementImpl) {
4107 ElementImpl ele = (ElementImpl)e;
4108 // get system id from document object
4109 Document doc = ele.getOwnerDocument();
4110 String sid = (String)fDoc2SystemId.get(DOMUtil.getRoot(doc));
4111 // line/column numbers are stored in the element node
4112 int line = ele.getLineNumber();
4113 int column = ele.getColumnNumber();
4114 l.setValues(sid, sid, line, column, ele.getCharacterOffset());
4115 return true;
4116 }
4117 return false;
4118 }
4119
4120 private Element getElementFromMap(Map<String, Element> registry, String declKey) {
4121 if (registry == null) return null;
4122 return registry.get(declKey);
4123 }
4124
4125 private XSDocumentInfo getDocInfoFromMap(Map<String, XSDocumentInfo> registry, String declKey) {
4126 if (registry == null) return null;
4127 return registry.get(declKey);
4128 }
4129
4130 private Object getFromMap(Map registry, String key) {
4131 if (registry == null) return null;
4132 return registry.get(key);
4133 }
4134
4135 void reportSchemaFatalError(String key, Object[] args, Element ele) {
4136 reportSchemaErr(key, args, ele, XMLErrorReporter.SEVERITY_FATAL_ERROR, null);
4137 }
4138
4139 void reportSchemaError(String key, Object[] args, Element ele) {
4140 reportSchemaErr(key, args, ele, XMLErrorReporter.SEVERITY_ERROR, null);
4141 }
4142
4143 void reportSchemaError(String key, Object[] args, Element ele, Exception exception) {
4144 reportSchemaErr(key, args, ele, XMLErrorReporter.SEVERITY_ERROR, exception);
4145 }
4146
4147 void reportSchemaWarning(String key, Object[] args, Element ele) {
4148 reportSchemaErr(key, args, ele, XMLErrorReporter.SEVERITY_WARNING, null);
4149 }
4150
4151 void reportSchemaWarning(String key, Object[] args, Element ele, Exception exception) {
4152 reportSchemaErr(key, args, ele, XMLErrorReporter.SEVERITY_WARNING, exception);
4153 }
4154
4155 void reportSchemaErr(String key, Object[] args, Element ele, short type, Exception exception) {
4156 if (element2Locator(ele, xl)) {
4157 fErrorReporter.reportError(xl, XSMessageFormatter.SCHEMA_DOMAIN,
4158 key, args, type, exception);
4159 }
4160 else {
4161 fErrorReporter.reportError(XSMessageFormatter.SCHEMA_DOMAIN,
4162 key, args, type, exception);
4163 }
4164 }
4165
4166 /**
4167 * Grammar pool used for validating annotations. This will return all of the
4168 * grammars from the grammar bucket. It will also return an object for the
4169 * schema for schemas which will contain at least the relevant declarations
4170 * for annotations.
4171 */
4172 private static class XSAnnotationGrammarPool implements XMLGrammarPool {
4173
4174 private XSGrammarBucket fGrammarBucket;
4175 private Grammar [] fInitialGrammarSet;
4176
4177 public Grammar[] retrieveInitialGrammarSet(String grammarType) {
4178 if (grammarType == XMLGrammarDescription.XML_SCHEMA) {
4179 if (fInitialGrammarSet == null) {
4180 if (fGrammarBucket == null) {
4181 fInitialGrammarSet = new Grammar [] {SchemaGrammar.Schema4Annotations.INSTANCE};
4182 }
4183 else {
4184 SchemaGrammar [] schemaGrammars = fGrammarBucket.getGrammars();
4185 /**
4186 * If the grammar bucket already contains the schema for schemas
4187 * then we already have the definitions for the parts relevant
4188 * to annotations.
4189 */
4190 for (int i = 0; i < schemaGrammars.length; ++i) {
4191 if (SchemaSymbols.URI_SCHEMAFORSCHEMA.equals(schemaGrammars[i].getTargetNamespace())) {
4192 fInitialGrammarSet = schemaGrammars;
4193 return fInitialGrammarSet;
4194 }
4195 }
4196 Grammar [] grammars = new Grammar[schemaGrammars.length + 1];
4197 System.arraycopy(schemaGrammars, 0, grammars, 0, schemaGrammars.length);
4198 grammars[grammars.length - 1] = SchemaGrammar.Schema4Annotations.INSTANCE;
4199 fInitialGrammarSet = grammars;
4200 }
4201 }
4202 return fInitialGrammarSet;
4203 }
4204 return new Grammar[0];
4205 }
4206
4207 public void cacheGrammars(String grammarType, Grammar[] grammars) {
4208
4209 }
4210
4211 public Grammar retrieveGrammar(XMLGrammarDescription desc) {
4212 if (desc.getGrammarType() == XMLGrammarDescription.XML_SCHEMA) {
4213 final String tns = ((XMLSchemaDescription) desc).getTargetNamespace();
4214 if (fGrammarBucket != null) {
4215 Grammar grammar = fGrammarBucket.getGrammar(tns);
4216 if (grammar != null) {
4217 return grammar;
4218 }
4219 }
4220 if (SchemaSymbols.URI_SCHEMAFORSCHEMA.equals(tns)) {
4221 return SchemaGrammar.Schema4Annotations.INSTANCE;
4222 }
4223 }
4224 return null;
4225 }
4226
4227 public void refreshGrammars(XSGrammarBucket gBucket) {
4228 fGrammarBucket = gBucket;
4229 fInitialGrammarSet = null;
4230 }
4231
4232 public void lockPool() {}
4233
4234 public void unlockPool() {}
4235
4236 public void clear() {}
4237 }
4238
4239 /**
4240 * used to identify a reference to a schema document
4241 * if the same document is referenced twice with the same key, then
4242 * we only need to parse it once.
4243 *
4244 * When 2 XSDKey's are compared, the following table can be used to
4245 * determine whether they are equal:
4246 * inc red imp pre ins
4247 * inc N/L ? N/L N/L N/L
4248 * red ? N/L ? ? ?
4249 * imp N/L ? N/P N/P N/P
4250 * pre N/L ? N/P N/P N/P
4251 * ins N/L ? N/P N/P N/P
4252 *
4253 * Where: N/L: duplicate when they have the same namespace and location.
4254 * ? : not clear from the spec.
4255 * REVISIT: to simplify the process, also considering
4256 * it's very rare, we treat them as not duplicate.
4257 * N/P: not possible. imp/pre/ins are referenced by namespace.
4258 * when the first time we encounter a schema document for a
4259 * namespace, we create a grammar and store it in the grammar
4260 * bucket. when we see another reference to the same namespace,
4261 * we first check whether a grammar with the same namespace is
4262 * already in the bucket, which is true in this case, so we
4263 * won't create another XSDKey.
4264 *
4265 * Conclusion from the table: two XSDKey's are duplicate only when all of
4266 * the following are true:
4267 * 1. They are both "redefine", or neither is "redefine";
4268 * 2. They have the same namespace;
4269 * 3. They have the same non-null location.
4270 *
4271 * About 3: if neither has a non-null location, then it's the case where
4272 * 2 input streams are provided, but no system ID is provided. We can't tell
4273 * whether the 2 streams have the same content, so we treat them as not
4274 * duplicate.
4275 */
4276 private static class XSDKey {
4277 String systemId;
4278 short referType;
4279 // for inclue/redefine, this is the enclosing namespace
4280 // for import/preparse/instance, this is the target namespace
4281 String referNS;
4282
4283 XSDKey(String systemId, short referType, String referNS) {
4284 this.systemId = systemId;
4285 this.referType = referType;
4286 this.referNS = referNS;
4287 }
4288
4289 public int hashCode() {
4290 // according to the description at the beginning of this class,
4291 // we use the hashcode of the namespace as the hashcoe of this key.
4292 return referNS == null ? 0 : referNS.hashCode();
4293 }
4294
4295 public boolean equals(Object obj) {
4296 if (!(obj instanceof XSDKey)) {
4297 return false;
4298 }
4299 XSDKey key = (XSDKey)obj;
4300
4301 // condition 1: both are redefine
4302 /** if (referType == XSDDescription.CONTEXT_REDEFINE ||
4303 key.referType == XSDDescription.CONTEXT_REDEFINE) {
4304 if (referType != key.referType)
4305 return false;
4306 }**/
4307
4308 // condition 2: same namespace
4309 if (referNS != key.referNS)
4310 return false;
4311
4312 // condition 3: same non-null location
4313 if (systemId == null || !systemId.equals(key.systemId)) {
4314 return false;
4315 }
4316
4317 return true;
4318 }
4319 }
4320
4321 private static final class SAX2XNIUtil extends ErrorHandlerWrapper {
4322 public static XMLParseException createXMLParseException0(SAXParseException exception) {
4323 return createXMLParseException(exception);
4324 }
4325 public static XNIException createXNIException0(SAXException exception) {
4326 return createXNIException(exception);
4327 }
4328 }
4329
4330 /**
4331 * @param state
4332 */
4333 public void setGenerateSyntheticAnnotations(boolean state) {
4334 fSchemaParser.setFeature(GENERATE_SYNTHETIC_ANNOTATIONS, state);
4335 }
4336
4337 } // XSDHandler