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