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;
22
23 import java.io.IOException;
24 import java.util.ArrayList;
25 import java.util.HashMap;
26 import java.util.Hashtable;
27 import java.util.Iterator;
28 import java.util.Map;
29 import java.util.Stack;
30 import java.util.Vector;
31 import java.util.ArrayList;
32 import javax.xml.XMLConstants;
33 import com.sun.org.apache.xerces.internal.impl.Constants;
34 import com.sun.org.apache.xerces.internal.impl.RevalidationHandler;
35 import com.sun.org.apache.xerces.internal.impl.XMLEntityManager;
36 import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;
37 import com.sun.org.apache.xerces.internal.impl.dv.DatatypeException;
38 import com.sun.org.apache.xerces.internal.impl.dv.InvalidDatatypeValueException;
39 import com.sun.org.apache.xerces.internal.impl.dv.ValidatedInfo;
40 import com.sun.org.apache.xerces.internal.impl.dv.XSSimpleType;
41 import com.sun.org.apache.xerces.internal.impl.validation.ValidationManager;
42 import com.sun.org.apache.xerces.internal.impl.validation.ValidationState;
43 import com.sun.org.apache.xerces.internal.impl.xs.identity.Field;
44 import com.sun.org.apache.xerces.internal.impl.xs.identity.FieldActivator;
45 import com.sun.org.apache.xerces.internal.impl.xs.identity.IdentityConstraint;
46 import com.sun.org.apache.xerces.internal.impl.xs.identity.KeyRef;
47 import com.sun.org.apache.xerces.internal.impl.xs.identity.Selector;
48 import com.sun.org.apache.xerces.internal.impl.xs.identity.UniqueOrKey;
49 import com.sun.org.apache.xerces.internal.impl.xs.identity.ValueStore;
50 import com.sun.org.apache.xerces.internal.impl.xs.identity.XPathMatcher;
51 import com.sun.org.apache.xerces.internal.impl.xs.models.CMBuilder;
52 import com.sun.org.apache.xerces.internal.impl.xs.models.CMNodeFactory;
53 import com.sun.org.apache.xerces.internal.impl.xs.models.XSCMValidator;
54 import com.sun.org.apache.xerces.internal.util.AugmentationsImpl;
55 import com.sun.org.apache.xerces.internal.util.IntStack;
56 import com.sun.org.apache.xerces.internal.util.SymbolTable;
57 import com.sun.org.apache.xerces.internal.util.XMLAttributesImpl;
58 import com.sun.org.apache.xerces.internal.util.XMLChar;
59 import com.sun.org.apache.xerces.internal.util.XMLSymbols;
60 import com.sun.org.apache.xerces.internal.util.URI.MalformedURIException;
61 import com.sun.org.apache.xerces.internal.xni.Augmentations;
62 import com.sun.org.apache.xerces.internal.xni.NamespaceContext;
63 import com.sun.org.apache.xerces.internal.xni.QName;
64 import com.sun.org.apache.xerces.internal.xni.XMLAttributes;
65 import com.sun.org.apache.xerces.internal.xni.XMLDocumentHandler;
66 import com.sun.org.apache.xerces.internal.xni.XMLLocator;
67 import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier;
68 import com.sun.org.apache.xerces.internal.xni.XMLString;
69 import com.sun.org.apache.xerces.internal.xni.XNIException;
70 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;
71 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarPool;
72 import com.sun.org.apache.xerces.internal.xni.parser.XMLComponent;
73 import com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager;
74 import com.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;
75 import com.sun.org.apache.xerces.internal.xni.parser.XMLDocumentFilter;
76 import com.sun.org.apache.xerces.internal.xni.parser.XMLDocumentSource;
77 import com.sun.org.apache.xerces.internal.xni.parser.XMLEntityResolver;
78 import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;
79 import com.sun.org.apache.xerces.internal.xs.AttributePSVI;
80 import com.sun.org.apache.xerces.internal.xs.ElementPSVI;
81 import com.sun.org.apache.xerces.internal.xs.ShortList;
82 import com.sun.org.apache.xerces.internal.xs.StringList;
83 import com.sun.org.apache.xerces.internal.xs.XSConstants;
84 import com.sun.org.apache.xerces.internal.xs.XSObjectList;
85 import com.sun.org.apache.xerces.internal.xs.XSTypeDefinition;
86 import com.sun.org.apache.xerces.internal.parsers.XMLParser;
87
88 /**
89 * The XML Schema validator. The validator implements a document
90 * filter: receiving document events from the scanner; validating
91 * the content and structure; augmenting the InfoSet, if applicable;
92 * and notifying the parser of the information resulting from the
93 * validation process.
94 * <p>
95 * This component requires the following features and properties from the
96 * component manager that uses it:
97 * <ul>
98 * <li>http://xml.org/sax/features/validation</li>
99 * <li>http://apache.org/xml/properties/internal/symbol-table</li>
100 * <li>http://apache.org/xml/properties/internal/error-reporter</li>
101 * <li>http://apache.org/xml/properties/internal/entity-resolver</li>
102 * </ul>
103 *
104 * @xerces.internal
105 *
106 * @author Sandy Gao IBM
107 * @author Elena Litani IBM
108 * @author Andy Clark IBM
109 * @author Neeraj Bajaj, Sun Microsystems, inc.
110 * @version $Id: XMLSchemaValidator.java,v 1.16 2010-11-01 04:39:55 joehw Exp $
111 */
112 public class XMLSchemaValidator
113 implements XMLComponent, XMLDocumentFilter, FieldActivator, RevalidationHandler {
114
115 //
116 // Constants
117 //
118 private static final boolean DEBUG = false;
119
120 // feature identifiers
121
122 /** Feature identifier: validation. */
123 protected static final String VALIDATION =
124 Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE;
125
126 /** Feature identifier: validation. */
127 protected static final String SCHEMA_VALIDATION =
128 Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_VALIDATION_FEATURE;
129
130 /** Feature identifier: schema full checking*/
131 protected static final String SCHEMA_FULL_CHECKING =
132 Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_FULL_CHECKING;
133
134 /** Feature identifier: dynamic validation. */
135 protected static final String DYNAMIC_VALIDATION =
136 Constants.XERCES_FEATURE_PREFIX + Constants.DYNAMIC_VALIDATION_FEATURE;
137
138 /** Feature identifier: expose schema normalized value */
139 protected static final String NORMALIZE_DATA =
140 Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_NORMALIZED_VALUE;
141
142 /** Feature identifier: send element default value via characters() */
143 protected static final String SCHEMA_ELEMENT_DEFAULT =
144 Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_ELEMENT_DEFAULT;
145
146 /** Feature identifier: augment PSVI */
147 protected static final String SCHEMA_AUGMENT_PSVI =
148 Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_AUGMENT_PSVI;
149
150 /** Feature identifier: whether to recognize java encoding names */
151 protected static final String ALLOW_JAVA_ENCODINGS =
152 Constants.XERCES_FEATURE_PREFIX + Constants.ALLOW_JAVA_ENCODINGS_FEATURE;
153
154 /** Feature identifier: standard uri conformant feature. */
155 protected static final String STANDARD_URI_CONFORMANT_FEATURE =
156 Constants.XERCES_FEATURE_PREFIX + Constants.STANDARD_URI_CONFORMANT_FEATURE;
157
158 /** Feature: generate synthetic annotations */
159 protected static final String GENERATE_SYNTHETIC_ANNOTATIONS =
160 Constants.XERCES_FEATURE_PREFIX + Constants.GENERATE_SYNTHETIC_ANNOTATIONS_FEATURE;
161
162 /** Feature identifier: validate annotations. */
163 protected static final String VALIDATE_ANNOTATIONS =
164 Constants.XERCES_FEATURE_PREFIX + Constants.VALIDATE_ANNOTATIONS_FEATURE;
165
166 /** Feature identifier: honour all schemaLocations */
167 protected static final String HONOUR_ALL_SCHEMALOCATIONS =
168 Constants.XERCES_FEATURE_PREFIX + Constants.HONOUR_ALL_SCHEMALOCATIONS_FEATURE;
169
170 /** Feature identifier: use grammar pool only */
171 protected static final String USE_GRAMMAR_POOL_ONLY =
172 Constants.XERCES_FEATURE_PREFIX + Constants.USE_GRAMMAR_POOL_ONLY_FEATURE;
173
174 /** Feature identifier: whether to continue parsing a schema after a fatal error is encountered */
175 protected static final String CONTINUE_AFTER_FATAL_ERROR =
176 Constants.XERCES_FEATURE_PREFIX + Constants.CONTINUE_AFTER_FATAL_ERROR_FEATURE;
177
178 protected static final String PARSER_SETTINGS =
179 Constants.XERCES_FEATURE_PREFIX + Constants.PARSER_SETTINGS;
180
181 /** Feature identifier: namespace growth */
182 protected static final String NAMESPACE_GROWTH =
183 Constants.XERCES_FEATURE_PREFIX + Constants.NAMESPACE_GROWTH_FEATURE;
184
185 /** Feature identifier: tolerate duplicates */
186 protected static final String TOLERATE_DUPLICATES =
187 Constants.XERCES_FEATURE_PREFIX + Constants.TOLERATE_DUPLICATES_FEATURE;
188
189 protected static final String REPORT_WHITESPACE =
190 Constants.SUN_SCHEMA_FEATURE_PREFIX + Constants.SUN_REPORT_IGNORED_ELEMENT_CONTENT_WHITESPACE;
191
192 // property identifiers
193
194 /** Property identifier: symbol table. */
195 public static final String SYMBOL_TABLE =
196 Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY;
197
198 /** Property identifier: error reporter. */
199 public static final String ERROR_REPORTER =
200 Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;
201
202 /** Property identifier: entity resolver. */
203 public static final String ENTITY_RESOLVER =
204 Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_RESOLVER_PROPERTY;
205
206 /** Property identifier: grammar pool. */
207 public static final String XMLGRAMMAR_POOL =
208 Constants.XERCES_PROPERTY_PREFIX + Constants.XMLGRAMMAR_POOL_PROPERTY;
209
210 protected static final String VALIDATION_MANAGER =
211 Constants.XERCES_PROPERTY_PREFIX + Constants.VALIDATION_MANAGER_PROPERTY;
212
213 protected static final String ENTITY_MANAGER =
214 Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_MANAGER_PROPERTY;
215
216 /** Property identifier: schema location. */
217 protected static final String SCHEMA_LOCATION =
218 Constants.XERCES_PROPERTY_PREFIX + Constants.SCHEMA_LOCATION;
219
220 /** Property identifier: no namespace schema location. */
221 protected static final String SCHEMA_NONS_LOCATION =
222 Constants.XERCES_PROPERTY_PREFIX + Constants.SCHEMA_NONS_LOCATION;
223
224 /** Property identifier: JAXP schema source. */
225 protected static final String JAXP_SCHEMA_SOURCE =
226 Constants.JAXP_PROPERTY_PREFIX + Constants.SCHEMA_SOURCE;
227
228 /** Property identifier: JAXP schema language. */
229 protected static final String JAXP_SCHEMA_LANGUAGE =
230 Constants.JAXP_PROPERTY_PREFIX + Constants.SCHEMA_LANGUAGE;
231
232 /** Property identifier: Schema DV Factory */
233 protected static final String SCHEMA_DV_FACTORY =
234 Constants.XERCES_PROPERTY_PREFIX + Constants.SCHEMA_DV_FACTORY_PROPERTY;
235
236 /** Property identifier: Security property manager. */
237 private static final String XML_SECURITY_PROPERTY_MANAGER =
238 Constants.XML_SECURITY_PROPERTY_MANAGER;
239
240 protected static final String USE_SERVICE_MECHANISM = Constants.ORACLE_FEATURE_SERVICE_MECHANISM;
241
242 // recognized features and properties
243
244 /** Recognized features. */
245 private static final String[] RECOGNIZED_FEATURES =
246 {
247 VALIDATION,
248 SCHEMA_VALIDATION,
249 DYNAMIC_VALIDATION,
250 SCHEMA_FULL_CHECKING,
251 ALLOW_JAVA_ENCODINGS,
252 CONTINUE_AFTER_FATAL_ERROR,
253 STANDARD_URI_CONFORMANT_FEATURE,
254 GENERATE_SYNTHETIC_ANNOTATIONS,
255 VALIDATE_ANNOTATIONS,
256 HONOUR_ALL_SCHEMALOCATIONS,
257 USE_GRAMMAR_POOL_ONLY,
258 NAMESPACE_GROWTH,
259 TOLERATE_DUPLICATES,
260 USE_SERVICE_MECHANISM
261 };
262
263 /** Feature defaults. */
264 private static final Boolean[] FEATURE_DEFAULTS = { null,
265 // NOTE: The following defaults are nulled out on purpose.
266 // If they are set, then when the XML Schema validator
267 // is constructed dynamically, these values may override
268 // those set by the application. This goes against the
269 // whole purpose of XMLComponent#getFeatureDefault but
270 // it can't be helped in this case. -Ac
271 null, //Boolean.FALSE,
272 null, //Boolean.FALSE,
273 null, //Boolean.FALSE,
274 null, //Boolean.FALSE,
275 null, //Boolean.FALSE,
276 null,
277 null,
278 null,
279 null,
280 null,
281 null,
282 null,
283 Boolean.TRUE
284 };
285
286 /** Recognized properties. */
287 private static final String[] RECOGNIZED_PROPERTIES =
288 {
289 SYMBOL_TABLE,
290 ERROR_REPORTER,
291 ENTITY_RESOLVER,
292 VALIDATION_MANAGER,
293 SCHEMA_LOCATION,
294 SCHEMA_NONS_LOCATION,
295 JAXP_SCHEMA_SOURCE,
296 JAXP_SCHEMA_LANGUAGE,
297 SCHEMA_DV_FACTORY,
298 XML_SECURITY_PROPERTY_MANAGER
299 };
300
301 /** Property defaults. */
302 private static final Object[] PROPERTY_DEFAULTS =
303 { null, null, null, null, null, null, null, null, null, null, null, null, null};
304
305 // this is the number of valuestores of each kind
306 // we expect an element to have. It's almost
307 // never > 1; so leave it at that.
308 protected static final int ID_CONSTRAINT_NUM = 1;
309
310 //
311 private static final Hashtable EMPTY_TABLE = new Hashtable();
312
313 //
314 // Data
315 //
316
317 /** current PSVI element info */
318 protected ElementPSVImpl fCurrentPSVI = new ElementPSVImpl();
319
320 // since it is the responsibility of each component to an
321 // Augmentations parameter if one is null, to save ourselves from
322 // having to create this object continually, it is created here.
323 // If it is not present in calls that we're passing on, we *must*
324 // clear this before we introduce it into the pipeline.
325 protected final AugmentationsImpl fAugmentations = new AugmentationsImpl();
326
327 /**
328 * Map which is used to catch instance documents that try
329 * and match a field several times in the same scope.
330 */
331 protected final HashMap fMayMatchFieldMap = new HashMap();
332
333 // this is included for the convenience of handleEndElement
334 protected XMLString fDefaultValue;
335
336 // Validation features
337 protected boolean fDynamicValidation = false;
338 protected boolean fSchemaDynamicValidation = false;
339 protected boolean fDoValidation = false;
340 protected boolean fFullChecking = false;
341 protected boolean fNormalizeData = true;
342 protected boolean fSchemaElementDefault = true;
343 protected boolean fAugPSVI = true;
344 protected boolean fIdConstraint = false;
345 protected boolean fUseGrammarPoolOnly = false;
346
347 // Namespace growth feature
348 protected boolean fNamespaceGrowth = false;
349
350 /** Schema type: None, DTD, Schema */
351 private String fSchemaType = null;
352
353 // to indicate whether we are in the scope of entity reference or CData
354 protected boolean fEntityRef = false;
355 protected boolean fInCDATA = false;
356
357 // Did we see only whitespace in element content?
358 protected boolean fSawOnlyWhitespaceInElementContent = false;
359
360 // properties
361
362 /** Symbol table. */
363 protected SymbolTable fSymbolTable;
364
365 /**
366 * While parsing a document, keep the location of the document.
367 */
368 private XMLLocator fLocator;
369
370 /**
371 * A wrapper of the standard error reporter. We'll store all schema errors
372 * in this wrapper object, so that we can get all errors (error codes) of
373 * a specific element. This is useful for PSVI.
374 */
375 protected final class XSIErrorReporter {
376
377 // the error reporter property
378 XMLErrorReporter fErrorReporter;
379
380 // store error codes; starting position of the errors for each element;
381 // number of element (depth); and whether to record error
382 Vector fErrors = new Vector();
383 int[] fContext = new int[INITIAL_STACK_SIZE];
384 int fContextCount;
385
386 // set the external error reporter, clear errors
387 public void reset(XMLErrorReporter errorReporter) {
388 fErrorReporter = errorReporter;
389 fErrors.removeAllElements();
390 fContextCount = 0;
391 }
392
393 // should be called when starting process an element or an attribute.
394 // store the starting position for the current context
395 public void pushContext() {
396 if (!fAugPSVI) {
397 return;
398 }
399 // resize array if necessary
400 if (fContextCount == fContext.length) {
401 int newSize = fContextCount + INC_STACK_SIZE;
402 int[] newArray = new int[newSize];
403 System.arraycopy(fContext, 0, newArray, 0, fContextCount);
404 fContext = newArray;
405 }
406
407 fContext[fContextCount++] = fErrors.size();
408 }
409
410 // should be called on endElement: get all errors of the current element
411 public String[] popContext() {
412 if (!fAugPSVI) {
413 return null;
414 }
415 // get starting position of the current element
416 int contextPos = fContext[--fContextCount];
417 // number of errors of the current element
418 int size = fErrors.size() - contextPos;
419 // if no errors, return null
420 if (size == 0)
421 return null;
422 // copy errors from the list to an string array
423 String[] errors = new String[size];
424 for (int i = 0; i < size; i++) {
425 errors[i] = (String) fErrors.elementAt(contextPos + i);
426 }
427 // remove errors of the current element
428 fErrors.setSize(contextPos);
429 return errors;
430 }
431
432 // should be called when an attribute is done: get all errors of
433 // this attribute, but leave the errors to the containing element
434 // also called after an element was strictly assessed.
435 public String[] mergeContext() {
436 if (!fAugPSVI) {
437 return null;
438 }
439 // get starting position of the current element
440 int contextPos = fContext[--fContextCount];
441 // number of errors of the current element
442 int size = fErrors.size() - contextPos;
443 // if no errors, return null
444 if (size == 0)
445 return null;
446 // copy errors from the list to an string array
447 String[] errors = new String[size];
448 for (int i = 0; i < size; i++) {
449 errors[i] = (String) fErrors.elementAt(contextPos + i);
450 }
451 // don't resize the vector: leave the errors for this attribute
452 // to the containing element
453 return errors;
454 }
455
456 public void reportError(String domain, String key, Object[] arguments, short severity)
457 throws XNIException {
458 fErrorReporter.reportError(domain, key, arguments, severity);
459 if (fAugPSVI) {
460 fErrors.addElement(key);
461 }
462 } // reportError(String,String,Object[],short)
463
464 public void reportError(
465 XMLLocator location,
466 String domain,
467 String key,
468 Object[] arguments,
469 short severity)
470 throws XNIException {
471 fErrorReporter.reportError(location, domain, key, arguments, severity);
472 if (fAugPSVI) {
473 fErrors.addElement(key);
474 }
475 } // reportError(XMLLocator,String,String,Object[],short)
476 }
477
478 /** Error reporter. */
479 protected final XSIErrorReporter fXSIErrorReporter = new XSIErrorReporter();
480
481 /** Entity resolver */
482 protected XMLEntityResolver fEntityResolver;
483
484 // updated during reset
485 protected ValidationManager fValidationManager = null;
486 protected ValidationState fValidationState = new ValidationState();
487 protected XMLGrammarPool fGrammarPool;
488
489 // schema location property values
490 protected String fExternalSchemas = null;
491 protected String fExternalNoNamespaceSchema = null;
492
493 //JAXP Schema Source property
494 protected Object fJaxpSchemaSource = null;
495
496 /** Schema Grammar Description passed, to give a chance to application to supply the Grammar */
497 protected final XSDDescription fXSDDescription = new XSDDescription();
498 protected final Hashtable fLocationPairs = new Hashtable();
499
500
501 // handlers
502
503 /** Document handler. */
504 protected XMLDocumentHandler fDocumentHandler;
505
506 protected XMLDocumentSource fDocumentSource;
507
508 boolean reportWhitespace = false;
509
510 //
511 // XMLComponent methods
512 //
513
514 /**
515 * Returns a list of feature identifiers that are recognized by
516 * this component. This method may return null if no features
517 * are recognized by this component.
518 */
519 public String[] getRecognizedFeatures() {
520 return (String[]) (RECOGNIZED_FEATURES.clone());
521 } // getRecognizedFeatures():String[]
522
523 /**
524 * Sets the state of a feature. This method is called by the component
525 * manager any time after reset when a feature changes state.
526 * <p>
527 * <strong>Note:</strong> Components should silently ignore features
528 * that do not affect the operation of the component.
529 *
530 * @param featureId The feature identifier.
531 * @param state The state of the feature.
532 *
533 * @throws SAXNotRecognizedException The component should not throw
534 * this exception.
535 * @throws SAXNotSupportedException The component should not throw
536 * this exception.
537 */
538 public void setFeature(String featureId, boolean state) throws XMLConfigurationException {
539 } // setFeature(String,boolean)
540
541 /**
542 * Returns a list of property identifiers that are recognized by
543 * this component. This method may return null if no properties
544 * are recognized by this component.
545 */
546 public String[] getRecognizedProperties() {
547 return (String[]) (RECOGNIZED_PROPERTIES.clone());
548 } // getRecognizedProperties():String[]
549
550 /**
551 * Sets the value of a property. This method is called by the component
552 * manager any time after reset when a property changes value.
553 * <p>
554 * <strong>Note:</strong> Components should silently ignore properties
555 * that do not affect the operation of the component.
556 *
557 * @param propertyId The property identifier.
558 * @param value The value of the property.
559 *
560 * @throws SAXNotRecognizedException The component should not throw
561 * this exception.
562 * @throws SAXNotSupportedException The component should not throw
563 * this exception.
564 */
565 public void setProperty(String propertyId, Object value) throws XMLConfigurationException {
566 } // setProperty(String,Object)
567
568 /**
569 * Returns the default state for a feature, or null if this
570 * component does not want to report a default value for this
571 * feature.
572 *
573 * @param featureId The feature identifier.
574 *
575 * @since Xerces 2.2.0
576 */
577 public Boolean getFeatureDefault(String featureId) {
578 for (int i = 0; i < RECOGNIZED_FEATURES.length; i++) {
579 if (RECOGNIZED_FEATURES[i].equals(featureId)) {
580 return FEATURE_DEFAULTS[i];
581 }
582 }
583 return null;
584 } // getFeatureDefault(String):Boolean
585
586 /**
587 * Returns the default state for a property, or null if this
588 * component does not want to report a default value for this
589 * property.
590 *
591 * @param propertyId The property identifier.
592 *
593 * @since Xerces 2.2.0
594 */
595 public Object getPropertyDefault(String propertyId) {
596 for (int i = 0; i < RECOGNIZED_PROPERTIES.length; i++) {
597 if (RECOGNIZED_PROPERTIES[i].equals(propertyId)) {
598 return PROPERTY_DEFAULTS[i];
599 }
600 }
601 return null;
602 } // getPropertyDefault(String):Object
603
604 //
605 // XMLDocumentSource methods
606 //
607
608 /** Sets the document handler to receive information about the document. */
609 public void setDocumentHandler(XMLDocumentHandler documentHandler) {
610 fDocumentHandler = documentHandler;
611
612 // Init reportWhitespace for this handler
613 if (documentHandler instanceof XMLParser) {
614 try {
615 reportWhitespace =
616 ((XMLParser) documentHandler).getFeature(REPORT_WHITESPACE);
617 }
618 catch (Exception e) {
619 reportWhitespace = false;
620 }
621 }
622 } // setDocumentHandler(XMLDocumentHandler)
623
624 /** Returns the document handler */
625 public XMLDocumentHandler getDocumentHandler() {
626 return fDocumentHandler;
627 } // setDocumentHandler(XMLDocumentHandler)
628
629 //
630 // XMLDocumentHandler methods
631 //
632
633 /** Sets the document source */
634 public void setDocumentSource(XMLDocumentSource source) {
635 fDocumentSource = source;
636 } // setDocumentSource
637
638 /** Returns the document source */
639 public XMLDocumentSource getDocumentSource() {
640 return fDocumentSource;
641 } // getDocumentSource
642
643 /**
644 * The start of the document.
645 *
646 * @param locator The system identifier of the entity if the entity
647 * is external, null otherwise.
648 * @param encoding The auto-detected IANA encoding name of the entity
649 * stream. This value will be null in those situations
650 * where the entity encoding is not auto-detected (e.g.
651 * internal entities or a document entity that is
652 * parsed from a java.io.Reader).
653 * @param namespaceContext
654 * The namespace context in effect at the
655 * start of this document.
656 * This object represents the current context.
657 * Implementors of this class are responsible
658 * for copying the namespace bindings from the
659 * the current context (and its parent contexts)
660 * if that information is important.
661 * @param augs Additional information that may include infoset augmentations
662 *
663 * @throws XNIException Thrown by handler to signal an error.
664 */
665 public void startDocument(
666 XMLLocator locator,
667 String encoding,
668 NamespaceContext namespaceContext,
669 Augmentations augs)
670 throws XNIException {
671
672 fValidationState.setNamespaceSupport(namespaceContext);
673 fState4XsiType.setNamespaceSupport(namespaceContext);
674 fState4ApplyDefault.setNamespaceSupport(namespaceContext);
675 fLocator = locator;
676
677 handleStartDocument(locator, encoding);
678 // call handlers
679 if (fDocumentHandler != null) {
680 fDocumentHandler.startDocument(locator, encoding, namespaceContext, augs);
681 }
682
683 } // startDocument(XMLLocator,String)
684
685 /**
686 * Notifies of the presence of an XMLDecl line in the document. If
687 * present, this method will be called immediately following the
688 * startDocument call.
689 *
690 * @param version The XML version.
691 * @param encoding The IANA encoding name of the document, or null if
692 * not specified.
693 * @param standalone The standalone value, or null if not specified.
694 * @param augs Additional information that may include infoset augmentations
695 *
696 * @throws XNIException Thrown by handler to signal an error.
697 */
698 public void xmlDecl(String version, String encoding, String standalone, Augmentations augs)
699 throws XNIException {
700
701 // call handlers
702 if (fDocumentHandler != null) {
703 fDocumentHandler.xmlDecl(version, encoding, standalone, augs);
704 }
705
706 } // xmlDecl(String,String,String)
707
708 /**
709 * Notifies of the presence of the DOCTYPE line in the document.
710 *
711 * @param rootElement The name of the root element.
712 * @param publicId The public identifier if an external DTD or null
713 * if the external DTD is specified using SYSTEM.
714 * @param systemId The system identifier if an external DTD, null
715 * otherwise.
716 * @param augs Additional information that may include infoset augmentations
717 *
718 * @throws XNIException Thrown by handler to signal an error.
719 */
720 public void doctypeDecl(
721 String rootElement,
722 String publicId,
723 String systemId,
724 Augmentations augs)
725 throws XNIException {
726
727 // call handlers
728 if (fDocumentHandler != null) {
729 fDocumentHandler.doctypeDecl(rootElement, publicId, systemId, augs);
730 }
731
732 } // doctypeDecl(String,String,String)
733
734 /**
735 * The start of an element.
736 *
737 * @param element The name of the element.
738 * @param attributes The element attributes.
739 * @param augs Additional information that may include infoset augmentations
740 *
741 * @throws XNIException Thrown by handler to signal an error.
742 */
743 public void startElement(QName element, XMLAttributes attributes, Augmentations augs)
744 throws XNIException {
745
746 Augmentations modifiedAugs = handleStartElement(element, attributes, augs);
747 // call handlers
748 if (fDocumentHandler != null) {
749 fDocumentHandler.startElement(element, attributes, modifiedAugs);
750 }
751
752 } // startElement(QName,XMLAttributes, Augmentations)
753
754 /**
755 * An empty element.
756 *
757 * @param element The name of the element.
758 * @param attributes The element attributes.
759 * @param augs Additional information that may include infoset augmentations
760 *
761 * @throws XNIException Thrown by handler to signal an error.
762 */
763 public void emptyElement(QName element, XMLAttributes attributes, Augmentations augs)
764 throws XNIException {
765
766 Augmentations modifiedAugs = handleStartElement(element, attributes, augs);
767
768 // in the case where there is a {value constraint}, and the element
769 // doesn't have any text content, change emptyElement call to
770 // start + characters + end
771 fDefaultValue = null;
772 // fElementDepth == -2 indicates that the schema validator was removed
773 // from the pipeline. then we don't need to call handleEndElement.
774 if (fElementDepth != -2)
775 modifiedAugs = handleEndElement(element, modifiedAugs);
776
777 // call handlers
778 if (fDocumentHandler != null) {
779 if (!fSchemaElementDefault || fDefaultValue == null) {
780 fDocumentHandler.emptyElement(element, attributes, modifiedAugs);
781 } else {
782 fDocumentHandler.startElement(element, attributes, modifiedAugs);
783 fDocumentHandler.characters(fDefaultValue, null);
784 fDocumentHandler.endElement(element, modifiedAugs);
785 }
786 }
787 } // emptyElement(QName,XMLAttributes, Augmentations)
788
789 /**
790 * Character content.
791 *
792 * @param text The content.
793 * @param augs Additional information that may include infoset augmentations
794 *
795 * @throws XNIException Thrown by handler to signal an error.
796 */
797 public void characters(XMLString text, Augmentations augs) throws XNIException {
798 text = handleCharacters(text);
799
800 if (fSawOnlyWhitespaceInElementContent) {
801 fSawOnlyWhitespaceInElementContent = false;
802 if (!reportWhitespace) {
803 ignorableWhitespace(text, augs);
804 return;
805 }
806 }
807
808 // call handlers
809 if (fDocumentHandler != null) {
810 if (fNormalizeData && fUnionType) {
811 // for union types we can't normalize data
812 // thus we only need to send augs information if any;
813 // the normalized data for union will be send
814 // after normalization is performed (at the endElement())
815 if (augs != null)
816 fDocumentHandler.characters(fEmptyXMLStr, augs);
817 } else {
818 fDocumentHandler.characters(text, augs);
819 }
820 }
821
822 } // characters(XMLString)
823
824 /**
825 * Ignorable whitespace. For this method to be called, the document
826 * source must have some way of determining that the text containing
827 * only whitespace characters should be considered ignorable. For
828 * example, the validator can determine if a length of whitespace
829 * characters in the document are ignorable based on the element
830 * content model.
831 *
832 * @param text The ignorable whitespace.
833 * @param augs Additional information that may include infoset augmentations
834 *
835 * @throws XNIException Thrown by handler to signal an error.
836 */
837 public void ignorableWhitespace(XMLString text, Augmentations augs) throws XNIException {
838 handleIgnorableWhitespace(text);
839 // call handlers
840 if (fDocumentHandler != null) {
841 fDocumentHandler.ignorableWhitespace(text, augs);
842 }
843
844 } // ignorableWhitespace(XMLString)
845
846 /**
847 * The end of an element.
848 *
849 * @param element The name of the element.
850 * @param augs Additional information that may include infoset augmentations
851 *
852 * @throws XNIException Thrown by handler to signal an error.
853 */
854 public void endElement(QName element, Augmentations augs) throws XNIException {
855
856 // in the case where there is a {value constraint}, and the element
857 // doesn't have any text content, add a characters call.
858 fDefaultValue = null;
859 Augmentations modifiedAugs = handleEndElement(element, augs);
860 // call handlers
861 if (fDocumentHandler != null) {
862 if (!fSchemaElementDefault || fDefaultValue == null) {
863 fDocumentHandler.endElement(element, modifiedAugs);
864 } else {
865 fDocumentHandler.characters(fDefaultValue, null);
866 fDocumentHandler.endElement(element, modifiedAugs);
867 }
868 }
869 } // endElement(QName, Augmentations)
870
871 /**
872 * The start of a CDATA section.
873 *
874 * @param augs Additional information that may include infoset augmentations
875 *
876 * @throws XNIException Thrown by handler to signal an error.
877 */
878 public void startCDATA(Augmentations augs) throws XNIException {
879
880 // REVISIT: what should we do here if schema normalization is on??
881 fInCDATA = true;
882 // call handlers
883 if (fDocumentHandler != null) {
884 fDocumentHandler.startCDATA(augs);
885 }
886
887 } // startCDATA()
888
889 /**
890 * The end of a CDATA section.
891 *
892 * @param augs Additional information that may include infoset augmentations
893 *
894 * @throws XNIException Thrown by handler to signal an error.
895 */
896 public void endCDATA(Augmentations augs) throws XNIException {
897
898 // call handlers
899 fInCDATA = false;
900 if (fDocumentHandler != null) {
901 fDocumentHandler.endCDATA(augs);
902 }
903
904 } // endCDATA()
905
906 /**
907 * The end of the document.
908 *
909 * @param augs Additional information that may include infoset augmentations
910 *
911 * @throws XNIException Thrown by handler to signal an error.
912 */
913 public void endDocument(Augmentations augs) throws XNIException {
914
915 handleEndDocument();
916
917 // call handlers
918 if (fDocumentHandler != null) {
919 fDocumentHandler.endDocument(augs);
920 }
921 fLocator = null;
922
923 } // endDocument(Augmentations)
924
925 //
926 // DOMRevalidationHandler methods
927 //
928
929
930
931
932
933 public boolean characterData(String data, Augmentations augs) {
934
935 fSawText = fSawText || data.length() > 0;
936
937 // REVISIT: this methods basically duplicates implementation of
938 // handleCharacters(). We should be able to reuse some code
939
940 // if whitespace == -1 skip normalization, because it is a complexType
941 // or a union type.
942 if (fNormalizeData && fWhiteSpace != -1 && fWhiteSpace != XSSimpleType.WS_PRESERVE) {
943 // normalize data
944 normalizeWhitespace(data, fWhiteSpace == XSSimpleType.WS_COLLAPSE);
945 fBuffer.append(fNormalizedStr.ch, fNormalizedStr.offset, fNormalizedStr.length);
946 } else {
947 if (fAppendBuffer)
948 fBuffer.append(data);
949 }
950
951 // When it's a complex type with element-only content, we need to
952 // find out whether the content contains any non-whitespace character.
953 boolean allWhiteSpace = true;
954 if (fCurrentType != null
955 && fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
956 XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType;
957 if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_ELEMENT) {
958 // data outside of element content
959 for (int i = 0; i < data.length(); i++) {
960 if (!XMLChar.isSpace(data.charAt(i))) {
961 allWhiteSpace = false;
962 fSawCharacters = true;
963 break;
964 }
965 }
966 }
967 }
968
969 return allWhiteSpace;
970 }
971
972 public void elementDefault(String data) {
973 // no-op
974 }
975
976 //
977 // XMLDocumentHandler and XMLDTDHandler methods
978 //
979
980 /**
981 * This method notifies the start of a general entity.
982 * <p>
983 * <strong>Note:</strong> This method is not called for entity references
984 * appearing as part of attribute values.
985 *
986 * @param name The name of the general entity.
987 * @param identifier The resource identifier.
988 * @param encoding The auto-detected IANA encoding name of the entity
989 * stream. This value will be null in those situations
990 * where the entity encoding is not auto-detected (e.g.
991 * internal entities or a document entity that is
992 * parsed from a java.io.Reader).
993 * @param augs Additional information that may include infoset augmentations
994 *
995 * @exception XNIException Thrown by handler to signal an error.
996 */
997 public void startGeneralEntity(
998 String name,
999 XMLResourceIdentifier identifier,
1000 String encoding,
1001 Augmentations augs)
1002 throws XNIException {
1003
1004 // REVISIT: what should happen if normalize_data_ is on??
1005 fEntityRef = true;
1006 // call handlers
1007 if (fDocumentHandler != null) {
1008 fDocumentHandler.startGeneralEntity(name, identifier, encoding, augs);
1009 }
1010
1011 } // startEntity(String,String,String,String,String)
1012
1013 /**
1014 * Notifies of the presence of a TextDecl line in an entity. If present,
1015 * this method will be called immediately following the startEntity call.
1016 * <p>
1017 * <strong>Note:</strong> This method will never be called for the
1018 * document entity; it is only called for external general entities
1019 * referenced in document content.
1020 * <p>
1021 * <strong>Note:</strong> This method is not called for entity references
1022 * appearing as part of attribute values.
1023 *
1024 * @param version The XML version, or null if not specified.
1025 * @param encoding The IANA encoding name of the entity.
1026 * @param augs Additional information that may include infoset augmentations
1027 *
1028 * @throws XNIException Thrown by handler to signal an error.
1029 */
1030 public void textDecl(String version, String encoding, Augmentations augs) throws XNIException {
1031
1032 // call handlers
1033 if (fDocumentHandler != null) {
1034 fDocumentHandler.textDecl(version, encoding, augs);
1035 }
1036
1037 } // textDecl(String,String)
1038
1039 /**
1040 * A comment.
1041 *
1042 * @param text The text in the comment.
1043 * @param augs Additional information that may include infoset augmentations
1044 *
1045 * @throws XNIException Thrown by application to signal an error.
1046 */
1047 public void comment(XMLString text, Augmentations augs) throws XNIException {
1048
1049 // call handlers
1050 if (fDocumentHandler != null) {
1051 fDocumentHandler.comment(text, augs);
1052 }
1053
1054 } // comment(XMLString)
1055
1056 /**
1057 * A processing instruction. Processing instructions consist of a
1058 * target name and, optionally, text data. The data is only meaningful
1059 * to the application.
1060 * <p>
1061 * Typically, a processing instruction's data will contain a series
1062 * of pseudo-attributes. These pseudo-attributes follow the form of
1063 * element attributes but are <strong>not</strong> parsed or presented
1064 * to the application as anything other than text. The application is
1065 * responsible for parsing the data.
1066 *
1067 * @param target The target.
1068 * @param data The data or null if none specified.
1069 * @param augs Additional information that may include infoset augmentations
1070 *
1071 * @throws XNIException Thrown by handler to signal an error.
1072 */
1073 public void processingInstruction(String target, XMLString data, Augmentations augs)
1074 throws XNIException {
1075
1076 // call handlers
1077 if (fDocumentHandler != null) {
1078 fDocumentHandler.processingInstruction(target, data, augs);
1079 }
1080
1081 } // processingInstruction(String,XMLString)
1082
1083 /**
1084 * This method notifies the end of a general entity.
1085 * <p>
1086 * <strong>Note:</strong> This method is not called for entity references
1087 * appearing as part of attribute values.
1088 *
1089 * @param name The name of the entity.
1090 * @param augs Additional information that may include infoset augmentations
1091 *
1092 * @exception XNIException
1093 * Thrown by handler to signal an error.
1094 */
1095 public void endGeneralEntity(String name, Augmentations augs) throws XNIException {
1096
1097 // call handlers
1098 fEntityRef = false;
1099 if (fDocumentHandler != null) {
1100 fDocumentHandler.endGeneralEntity(name, augs);
1101 }
1102
1103 } // endEntity(String)
1104
1105 // constants
1106
1107 static final int INITIAL_STACK_SIZE = 8;
1108 static final int INC_STACK_SIZE = 8;
1109
1110 //
1111 // Data
1112 //
1113
1114 // Schema Normalization
1115
1116 private static final boolean DEBUG_NORMALIZATION = false;
1117 // temporary empty string buffer.
1118 private final XMLString fEmptyXMLStr = new XMLString(null, 0, -1);
1119 // temporary character buffer, and empty string buffer.
1120 private static final int BUFFER_SIZE = 20;
1121 private final XMLString fNormalizedStr = new XMLString();
1122 private boolean fFirstChunk = true;
1123 // got first chunk in characters() (SAX)
1124 private boolean fTrailing = false; // Previous chunk had a trailing space
1125 private short fWhiteSpace = -1; //whiteSpace: preserve/replace/collapse
1126 private boolean fUnionType = false;
1127
1128 /** Schema grammar resolver. */
1129 private final XSGrammarBucket fGrammarBucket = new XSGrammarBucket();
1130 private final SubstitutionGroupHandler fSubGroupHandler = new SubstitutionGroupHandler(fGrammarBucket);
1131
1132 /** the DV usd to convert xsi:type to a QName */
1133 // REVISIT: in new simple type design, make things in DVs static,
1134 // so that we can QNameDV.getCompiledForm()
1135 private final XSSimpleType fQNameDV =
1136 (XSSimpleType) SchemaGrammar.SG_SchemaNS.getGlobalTypeDecl(SchemaSymbols.ATTVAL_QNAME);
1137
1138 private final CMNodeFactory nodeFactory = new CMNodeFactory();
1139 /** used to build content models */
1140 // REVISIT: create decl pool, and pass it to each traversers
1141 private final CMBuilder fCMBuilder = new CMBuilder(nodeFactory);
1142
1143 // Schema grammar loader
1144 private final XMLSchemaLoader fSchemaLoader =
1145 new XMLSchemaLoader(
1146 fXSIErrorReporter.fErrorReporter,
1147 fGrammarBucket,
1148 fSubGroupHandler,
1149 fCMBuilder);
1150
1151 // state
1152
1153 /** String representation of the validation root. */
1154 // REVISIT: what do we store here? QName, XPATH, some ID? use rawname now.
1155 private String fValidationRoot;
1156
1157 /** Skip validation: anything below this level should be skipped */
1158 private int fSkipValidationDepth;
1159
1160 /** anything above this level has validation_attempted != full */
1161 private int fNFullValidationDepth;
1162
1163 /** anything above this level has validation_attempted != none */
1164 private int fNNoneValidationDepth;
1165
1166 /** Element depth: -2: validator not in pipeline; >= -1 current depth. */
1167 private int fElementDepth;
1168
1169 /** Seen sub elements. */
1170 private boolean fSubElement;
1171
1172 /** Seen sub elements stack. */
1173 private boolean[] fSubElementStack = new boolean[INITIAL_STACK_SIZE];
1174
1175 /** Current element declaration. */
1176 private XSElementDecl fCurrentElemDecl;
1177
1178 /** Element decl stack. */
1179 private XSElementDecl[] fElemDeclStack = new XSElementDecl[INITIAL_STACK_SIZE];
1180
1181 /** nil value of the current element */
1182 private boolean fNil;
1183
1184 /** nil value stack */
1185 private boolean[] fNilStack = new boolean[INITIAL_STACK_SIZE];
1186
1187 /** notation value of the current element */
1188 private XSNotationDecl fNotation;
1189
1190 /** notation stack */
1191 private XSNotationDecl[] fNotationStack = new XSNotationDecl[INITIAL_STACK_SIZE];
1192
1193 /** Current type. */
1194 private XSTypeDefinition fCurrentType;
1195
1196 /** type stack. */
1197 private XSTypeDefinition[] fTypeStack = new XSTypeDefinition[INITIAL_STACK_SIZE];
1198
1199 /** Current content model. */
1200 private XSCMValidator fCurrentCM;
1201
1202 /** Content model stack. */
1203 private XSCMValidator[] fCMStack = new XSCMValidator[INITIAL_STACK_SIZE];
1204
1205 /** the current state of the current content model */
1206 private int[] fCurrCMState;
1207
1208 /** stack to hold content model states */
1209 private int[][] fCMStateStack = new int[INITIAL_STACK_SIZE][];
1210
1211 /** whether the curret element is strictly assessed */
1212 private boolean fStrictAssess = true;
1213
1214 /** strict assess stack */
1215 private boolean[] fStrictAssessStack = new boolean[INITIAL_STACK_SIZE];
1216
1217 /** Temporary string buffers. */
1218 private final StringBuffer fBuffer = new StringBuffer();
1219
1220 /** Whether need to append characters to fBuffer */
1221 private boolean fAppendBuffer = true;
1222
1223 /** Did we see any character data? */
1224 private boolean fSawText = false;
1225
1226 /** stack to record if we saw character data */
1227 private boolean[] fSawTextStack = new boolean[INITIAL_STACK_SIZE];
1228
1229 /** Did we see non-whitespace character data? */
1230 private boolean fSawCharacters = false;
1231
1232 /** Stack to record if we saw character data outside of element content*/
1233 private boolean[] fStringContent = new boolean[INITIAL_STACK_SIZE];
1234
1235 /** temporary qname */
1236 private final QName fTempQName = new QName();
1237
1238 /** temporary validated info */
1239 private ValidatedInfo fValidatedInfo = new ValidatedInfo();
1240
1241 // used to validate default/fixed values against xsi:type
1242 // only need to check facets, so we set extraChecking to false (in reset)
1243 private ValidationState fState4XsiType = new ValidationState();
1244
1245 // used to apply default/fixed values
1246 // only need to check id/idref/entity, so we set checkFacets to false
1247 private ValidationState fState4ApplyDefault = new ValidationState();
1248
1249 // identity constraint information
1250
1251 /**
1252 * Stack of active XPath matchers for identity constraints. All
1253 * active XPath matchers are notified of startElement
1254 * and endElement callbacks in order to perform their matches.
1255 * <p>
1256 * For each element with identity constraints, the selector of
1257 * each identity constraint is activated. When the selector matches
1258 * its XPath, then all the fields of the identity constraint are
1259 * activated.
1260 * <p>
1261 * <strong>Note:</strong> Once the activation scope is left, the
1262 * XPath matchers are automatically removed from the stack of
1263 * active matchers and no longer receive callbacks.
1264 */
1265 protected XPathMatcherStack fMatcherStack = new XPathMatcherStack();
1266
1267 /** Cache of value stores for identity constraint fields. */
1268 protected ValueStoreCache fValueStoreCache = new ValueStoreCache();
1269
1270 //
1271 // Constructors
1272 //
1273
1274 /** Default constructor. */
1275 public XMLSchemaValidator() {
1276 fState4XsiType.setExtraChecking(false);
1277 fState4ApplyDefault.setFacetChecking(false);
1278
1279 } // <init>()
1280
1281 /*
1282 * Resets the component. The component can query the component manager
1283 * about any features and properties that affect the operation of the
1284 * component.
1285 *
1286 * @param componentManager The component manager.
1287 *
1288 * @throws SAXException Thrown by component on finitialization error.
1289 * For example, if a feature or property is
1290 * required for the operation of the component, the
1291 * component manager may throw a
1292 * SAXNotRecognizedException or a
1293 * SAXNotSupportedException.
1294 */
1295 public void reset(XMLComponentManager componentManager) throws XMLConfigurationException {
1296
1297
1298 fIdConstraint = false;
1299 //reset XSDDescription
1300 fLocationPairs.clear();
1301
1302 // cleanup id table
1303 fValidationState.resetIDTables();
1304
1305 //pass the component manager to the factory..
1306 nodeFactory.reset(componentManager);
1307
1308 // reset schema loader
1309 fSchemaLoader.reset(componentManager);
1310
1311 // initialize state
1312 fCurrentElemDecl = null;
1313 fCurrentCM = null;
1314 fCurrCMState = null;
1315 fSkipValidationDepth = -1;
1316 fNFullValidationDepth = -1;
1317 fNNoneValidationDepth = -1;
1318 fElementDepth = -1;
1319 fSubElement = false;
1320 fSchemaDynamicValidation = false;
1321
1322 // datatype normalization
1323 fEntityRef = false;
1324 fInCDATA = false;
1325
1326 fMatcherStack.clear();
1327
1328 if (!fMayMatchFieldMap.isEmpty()) {
1329 // should only clear this if the last schema had identity constraints.
1330 fMayMatchFieldMap.clear();
1331 }
1332
1333 // get error reporter
1334 fXSIErrorReporter.reset((XMLErrorReporter) componentManager.getProperty(ERROR_REPORTER));
1335
1336 boolean parser_settings = componentManager.getFeature(PARSER_SETTINGS, true);
1337
1338 if (!parser_settings){
1339 // parser settings have not been changed
1340 fValidationManager.addValidationState(fValidationState);
1341 // Re-parse external schema location properties.
1342 XMLSchemaLoader.processExternalHints(
1343 fExternalSchemas,
1344 fExternalNoNamespaceSchema,
1345 fLocationPairs,
1346 fXSIErrorReporter.fErrorReporter);
1347 return;
1348 }
1349
1350
1351 // get symbol table. if it's a new one, add symbols to it.
1352 SymbolTable symbolTable = (SymbolTable) componentManager.getProperty(SYMBOL_TABLE);
1353 if (symbolTable != fSymbolTable) {
1354 fSymbolTable = symbolTable;
1355 }
1356
1357 fNamespaceGrowth = componentManager.getFeature(NAMESPACE_GROWTH, false);
1358 fDynamicValidation = componentManager.getFeature(DYNAMIC_VALIDATION, false);
1359
1360 if (fDynamicValidation) {
1361 fDoValidation = true;
1362 } else {
1363 fDoValidation = componentManager.getFeature(VALIDATION, false);
1364 }
1365
1366 if (fDoValidation) {
1367 fDoValidation |= componentManager.getFeature(XMLSchemaValidator.SCHEMA_VALIDATION, false);
1368 }
1369
1370 fFullChecking = componentManager.getFeature(SCHEMA_FULL_CHECKING, false);
1371 fNormalizeData = componentManager.getFeature(NORMALIZE_DATA, false);
1372 fSchemaElementDefault = componentManager.getFeature(SCHEMA_ELEMENT_DEFAULT, false);
1373
1374 fAugPSVI = componentManager.getFeature(SCHEMA_AUGMENT_PSVI, true);
1375
1376 fSchemaType =
1377 (String) componentManager.getProperty(
1378 Constants.JAXP_PROPERTY_PREFIX + Constants.SCHEMA_LANGUAGE, null);
1379
1380 fUseGrammarPoolOnly = componentManager.getFeature(USE_GRAMMAR_POOL_ONLY, false);
1381
1382 fEntityResolver = (XMLEntityResolver) componentManager.getProperty(ENTITY_MANAGER);
1383
1384 fValidationManager = (ValidationManager) componentManager.getProperty(VALIDATION_MANAGER);
1385 fValidationManager.addValidationState(fValidationState);
1386 fValidationState.setSymbolTable(fSymbolTable);
1387
1388
1389 // get schema location properties
1390 try {
1391 fExternalSchemas = (String) componentManager.getProperty(SCHEMA_LOCATION);
1392 fExternalNoNamespaceSchema =
1393 (String) componentManager.getProperty(SCHEMA_NONS_LOCATION);
1394 } catch (XMLConfigurationException e) {
1395 fExternalSchemas = null;
1396 fExternalNoNamespaceSchema = null;
1397 }
1398
1399 // store the external schema locations. they are set when reset is called,
1400 // so any other schemaLocation declaration for the same namespace will be
1401 // effectively ignored. becuase we choose to take first location hint
1402 // available for a particular namespace.
1403 XMLSchemaLoader.processExternalHints(
1404 fExternalSchemas,
1405 fExternalNoNamespaceSchema,
1406 fLocationPairs,
1407 fXSIErrorReporter.fErrorReporter);
1408
1409 fJaxpSchemaSource = componentManager.getProperty(JAXP_SCHEMA_SOURCE, null);
1410
1411 // clear grammars, and put the one for schema namespace there
1412 fGrammarPool = (XMLGrammarPool) componentManager.getProperty(XMLGRAMMAR_POOL, null);
1413
1414 fState4XsiType.setSymbolTable(symbolTable);
1415 fState4ApplyDefault.setSymbolTable(symbolTable);
1416
1417 } // reset(XMLComponentManager)
1418
1419 //
1420 // FieldActivator methods
1421 //
1422
1423 /**
1424 * Start the value scope for the specified identity constraint. This
1425 * method is called when the selector matches in order to initialize
1426 * the value store.
1427 *
1428 * @param identityConstraint The identity constraint.
1429 */
1430 public void startValueScopeFor(IdentityConstraint identityConstraint, int initialDepth) {
1431
1432 ValueStoreBase valueStore =
1433 fValueStoreCache.getValueStoreFor(identityConstraint, initialDepth);
1434 valueStore.startValueScope();
1435
1436 } // startValueScopeFor(IdentityConstraint identityConstraint)
1437
1438 /**
1439 * Request to activate the specified field. This method returns the
1440 * matcher for the field.
1441 *
1442 * @param field The field to activate.
1443 */
1444 public XPathMatcher activateField(Field field, int initialDepth) {
1445 ValueStore valueStore =
1446 fValueStoreCache.getValueStoreFor(field.getIdentityConstraint(), initialDepth);
1447 setMayMatch(field, Boolean.TRUE);
1448 XPathMatcher matcher = field.createMatcher(this, valueStore);
1449 fMatcherStack.addMatcher(matcher);
1450 matcher.startDocumentFragment();
1451 return matcher;
1452 } // activateField(Field):XPathMatcher
1453
1454 /**
1455 * Ends the value scope for the specified identity constraint.
1456 *
1457 * @param identityConstraint The identity constraint.
1458 */
1459 public void endValueScopeFor(IdentityConstraint identityConstraint, int initialDepth) {
1460
1461 ValueStoreBase valueStore =
1462 fValueStoreCache.getValueStoreFor(identityConstraint, initialDepth);
1463 valueStore.endValueScope();
1464
1465 } // endValueScopeFor(IdentityConstraint)
1466
1467 /**
1468 * Sets whether the given field is permitted to match a value.
1469 * This should be used to catch instance documents that try
1470 * and match a field several times in the same scope.
1471 *
1472 * @param field The field that may be permitted to be matched.
1473 * @param state Boolean indiciating whether the field may be matched.
1474 */
1475 public void setMayMatch(Field field, Boolean state) {
1476 fMayMatchFieldMap.put(field, state);
1477 } // setMayMatch(Field, Boolean)
1478
1479 /**
1480 * Returns whether the given field is permitted to match a value.
1481 *
1482 * @param field The field that may be permitted to be matched.
1483 * @return Boolean indicating whether the field may be matched.
1484 */
1485 public Boolean mayMatch(Field field) {
1486 return (Boolean) fMayMatchFieldMap.get(field);
1487 } // mayMatch(Field):Boolean
1488
1489 // a utility method for Identity constraints
1490 private void activateSelectorFor(IdentityConstraint ic) {
1491 Selector selector = ic.getSelector();
1492 FieldActivator activator = this;
1493 if (selector == null)
1494 return;
1495 XPathMatcher matcher = selector.createMatcher(activator, fElementDepth);
1496 fMatcherStack.addMatcher(matcher);
1497 matcher.startDocumentFragment();
1498 }
1499
1500 //
1501 // Protected methods
1502 //
1503
1504 /** ensure element stack capacity */
1505 void ensureStackCapacity() {
1506
1507 if (fElementDepth == fElemDeclStack.length) {
1508 int newSize = fElementDepth + INC_STACK_SIZE;
1509 boolean[] newArrayB = new boolean[newSize];
1510 System.arraycopy(fSubElementStack, 0, newArrayB, 0, fElementDepth);
1511 fSubElementStack = newArrayB;
1512
1513 XSElementDecl[] newArrayE = new XSElementDecl[newSize];
1514 System.arraycopy(fElemDeclStack, 0, newArrayE, 0, fElementDepth);
1515 fElemDeclStack = newArrayE;
1516
1517 newArrayB = new boolean[newSize];
1518 System.arraycopy(fNilStack, 0, newArrayB, 0, fElementDepth);
1519 fNilStack = newArrayB;
1520
1521 XSNotationDecl[] newArrayN = new XSNotationDecl[newSize];
1522 System.arraycopy(fNotationStack, 0, newArrayN, 0, fElementDepth);
1523 fNotationStack = newArrayN;
1524
1525 XSTypeDefinition[] newArrayT = new XSTypeDefinition[newSize];
1526 System.arraycopy(fTypeStack, 0, newArrayT, 0, fElementDepth);
1527 fTypeStack = newArrayT;
1528
1529 XSCMValidator[] newArrayC = new XSCMValidator[newSize];
1530 System.arraycopy(fCMStack, 0, newArrayC, 0, fElementDepth);
1531 fCMStack = newArrayC;
1532
1533 newArrayB = new boolean[newSize];
1534 System.arraycopy(fSawTextStack, 0, newArrayB, 0, fElementDepth);
1535 fSawTextStack = newArrayB;
1536
1537 newArrayB = new boolean[newSize];
1538 System.arraycopy(fStringContent, 0, newArrayB, 0, fElementDepth);
1539 fStringContent = newArrayB;
1540
1541 newArrayB = new boolean[newSize];
1542 System.arraycopy(fStrictAssessStack, 0, newArrayB, 0, fElementDepth);
1543 fStrictAssessStack = newArrayB;
1544
1545 int[][] newArrayIA = new int[newSize][];
1546 System.arraycopy(fCMStateStack, 0, newArrayIA, 0, fElementDepth);
1547 fCMStateStack = newArrayIA;
1548 }
1549
1550 } // ensureStackCapacity
1551
1552 // handle start document
1553 void handleStartDocument(XMLLocator locator, String encoding) {
1554 fValueStoreCache.startDocument();
1555 if (fAugPSVI) {
1556 fCurrentPSVI.fGrammars = null;
1557 fCurrentPSVI.fSchemaInformation = null;
1558 }
1559 } // handleStartDocument(XMLLocator,String)
1560
1561 void handleEndDocument() {
1562 fValueStoreCache.endDocument();
1563 } // handleEndDocument()
1564
1565 // handle character contents
1566 // returns the normalized string if possible, otherwise the original string
1567 XMLString handleCharacters(XMLString text) {
1568
1569 if (fSkipValidationDepth >= 0)
1570 return text;
1571
1572 fSawText = fSawText || text.length > 0;
1573
1574 // Note: data in EntityRef and CDATA is normalized as well
1575 // if whitespace == -1 skip normalization, because it is a complexType
1576 // or a union type.
1577 if (fNormalizeData && fWhiteSpace != -1 && fWhiteSpace != XSSimpleType.WS_PRESERVE) {
1578 // normalize data
1579 normalizeWhitespace(text, fWhiteSpace == XSSimpleType.WS_COLLAPSE);
1580 text = fNormalizedStr;
1581 }
1582 if (fAppendBuffer)
1583 fBuffer.append(text.ch, text.offset, text.length);
1584
1585 // When it's a complex type with element-only content, we need to
1586 // find out whether the content contains any non-whitespace character.
1587 fSawOnlyWhitespaceInElementContent = false;
1588 if (fCurrentType != null
1589 && fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
1590 XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType;
1591 if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_ELEMENT) {
1592 // data outside of element content
1593 for (int i = text.offset; i < text.offset + text.length; i++) {
1594 if (!XMLChar.isSpace(text.ch[i])) {
1595 fSawCharacters = true;
1596 break;
1597 }
1598 fSawOnlyWhitespaceInElementContent = !fSawCharacters;
1599 }
1600 }
1601 }
1602
1603 return text;
1604 } // handleCharacters(XMLString)
1605
1606 /**
1607 * Normalize whitespace in an XMLString according to the rules defined
1608 * in XML Schema specifications.
1609 * @param value The string to normalize.
1610 * @param collapse replace or collapse
1611 */
1612 private void normalizeWhitespace(XMLString value, boolean collapse) {
1613 boolean skipSpace = collapse;
1614 boolean sawNonWS = false;
1615 boolean leading = false;
1616 boolean trailing = false;
1617 char c;
1618 int size = value.offset + value.length;
1619
1620 // ensure the ch array is big enough
1621 if (fNormalizedStr.ch == null || fNormalizedStr.ch.length < value.length + 1) {
1622 fNormalizedStr.ch = new char[value.length + 1];
1623 }
1624 // don't include the leading ' ' for now. might include it later.
1625 fNormalizedStr.offset = 1;
1626 fNormalizedStr.length = 1;
1627
1628 for (int i = value.offset; i < size; i++) {
1629 c = value.ch[i];
1630 if (XMLChar.isSpace(c)) {
1631 if (!skipSpace) {
1632 // take the first whitespace as a space and skip the others
1633 fNormalizedStr.ch[fNormalizedStr.length++] = ' ';
1634 skipSpace = collapse;
1635 }
1636 if (!sawNonWS) {
1637 // this is a leading whitespace, record it
1638 leading = true;
1639 }
1640 } else {
1641 fNormalizedStr.ch[fNormalizedStr.length++] = c;
1642 skipSpace = false;
1643 sawNonWS = true;
1644 }
1645 }
1646 if (skipSpace) {
1647 if (fNormalizedStr.length > 1) {
1648 // if we finished on a space trim it but also record it
1649 fNormalizedStr.length--;
1650 trailing = true;
1651 } else if (leading && !fFirstChunk) {
1652 // if all we had was whitespace we skipped record it as
1653 // trailing whitespace as well
1654 trailing = true;
1655 }
1656 }
1657
1658 if (fNormalizedStr.length > 1) {
1659 if (!fFirstChunk && (fWhiteSpace == XSSimpleType.WS_COLLAPSE)) {
1660 if (fTrailing) {
1661 // previous chunk ended on whitespace
1662 // insert whitespace
1663 fNormalizedStr.offset = 0;
1664 fNormalizedStr.ch[0] = ' ';
1665 } else if (leading) {
1666 // previous chunk ended on character,
1667 // this chunk starts with whitespace
1668 fNormalizedStr.offset = 0;
1669 fNormalizedStr.ch[0] = ' ';
1670 }
1671 }
1672 }
1673
1674 // The length includes the leading ' '. Now removing it.
1675 fNormalizedStr.length -= fNormalizedStr.offset;
1676
1677 fTrailing = trailing;
1678
1679 if (trailing || sawNonWS)
1680 fFirstChunk = false;
1681 }
1682
1683 private void normalizeWhitespace(String value, boolean collapse) {
1684 boolean skipSpace = collapse;
1685 char c;
1686 int size = value.length();
1687
1688 // ensure the ch array is big enough
1689 if (fNormalizedStr.ch == null || fNormalizedStr.ch.length < size) {
1690 fNormalizedStr.ch = new char[size];
1691 }
1692 fNormalizedStr.offset = 0;
1693 fNormalizedStr.length = 0;
1694
1695 for (int i = 0; i < size; i++) {
1696 c = value.charAt(i);
1697 if (XMLChar.isSpace(c)) {
1698 if (!skipSpace) {
1699 // take the first whitespace as a space and skip the others
1700 fNormalizedStr.ch[fNormalizedStr.length++] = ' ';
1701 skipSpace = collapse;
1702 }
1703 } else {
1704 fNormalizedStr.ch[fNormalizedStr.length++] = c;
1705 skipSpace = false;
1706 }
1707 }
1708 if (skipSpace) {
1709 if (fNormalizedStr.length != 0)
1710 // if we finished on a space trim it but also record it
1711 fNormalizedStr.length--;
1712 }
1713 }
1714
1715 // handle ignorable whitespace
1716 void handleIgnorableWhitespace(XMLString text) {
1717
1718 if (fSkipValidationDepth >= 0)
1719 return;
1720
1721 // REVISIT: the same process needs to be performed as handleCharacters.
1722 // only it's simpler here: we know all characters are whitespaces.
1723
1724 } // handleIgnorableWhitespace(XMLString)
1725
1726 /** Handle element. */
1727 Augmentations handleStartElement(QName element, XMLAttributes attributes, Augmentations augs) {
1728
1729 if (DEBUG) {
1730 System.out.println("==>handleStartElement: " + element);
1731 }
1732
1733 // root element
1734 if (fElementDepth == -1 && fValidationManager.isGrammarFound()) {
1735 if (fSchemaType == null) {
1736 // schemaType is not specified
1737 // if a DTD grammar is found, we do the same thing as Dynamic:
1738 // if a schema grammar is found, validation is performed;
1739 // otherwise, skip the whole document.
1740 fSchemaDynamicValidation = true;
1741 } else {
1742 // [1] Either schemaType is DTD, and in this case validate/schema is turned off
1743 // [2] Validating against XML Schemas only
1744 // [a] dynamic validation is false: report error if SchemaGrammar is not found
1745 // [b] dynamic validation is true: if grammar is not found ignore.
1746 }
1747
1748 }
1749
1750 // get xsi:schemaLocation and xsi:noNamespaceSchemaLocation attributes,
1751 // parse them to get the grammars
1752
1753 String sLocation =
1754 attributes.getValue(SchemaSymbols.URI_XSI, SchemaSymbols.XSI_SCHEMALOCATION);
1755 String nsLocation =
1756 attributes.getValue(SchemaSymbols.URI_XSI, SchemaSymbols.XSI_NONAMESPACESCHEMALOCATION);
1757 //store the location hints.. we need to do it so that we can defer the loading of grammar until
1758 //there is a reference to a component from that namespace. To provide location hints to the
1759 //application for a namespace
1760 storeLocations(sLocation, nsLocation);
1761
1762 // if we are in the content of "skip", then just skip this element
1763 // REVISIT: is this the correct behaviour for ID constraints? -NG
1764 if (fSkipValidationDepth >= 0) {
1765 fElementDepth++;
1766 if (fAugPSVI)
1767 augs = getEmptyAugs(augs);
1768 return augs;
1769 }
1770
1771 //try to find schema grammar by different means..
1772 SchemaGrammar sGrammar =
1773 findSchemaGrammar(
1774 XSDDescription.CONTEXT_ELEMENT,
1775 element.uri,
1776 null,
1777 element,
1778 attributes);
1779
1780 // if we are not skipping this element, and there is a content model,
1781 // we try to find the corresponding decl object for this element.
1782 // the reason we move this part of code here is to make sure the
1783 // error reported here (if any) is stored within the parent element's
1784 // context, instead of that of the current element.
1785 Object decl = null;
1786 if (fCurrentCM != null) {
1787 decl = fCurrentCM.oneTransition(element, fCurrCMState, fSubGroupHandler);
1788 // it could be an element decl or a wildcard decl
1789 if (fCurrCMState[0] == XSCMValidator.FIRST_ERROR) {
1790 XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType;
1791 //REVISIT: is it the only case we will have particle = null?
1792 Vector next;
1793 if (ctype.fParticle != null
1794 && (next = fCurrentCM.whatCanGoHere(fCurrCMState)).size() > 0) {
1795 String expected = expectedStr(next);
1796 reportSchemaError(
1797 "cvc-complex-type.2.4.a",
1798 new Object[] { element.rawname, expected });
1799 } else {
1800 reportSchemaError("cvc-complex-type.2.4.d", new Object[] { element.rawname });
1801 }
1802 }
1803 }
1804
1805 // if it's not the root element, we push the current states in the stacks
1806 if (fElementDepth != -1) {
1807 ensureStackCapacity();
1808 fSubElementStack[fElementDepth] = true;
1809 fSubElement = false;
1810 fElemDeclStack[fElementDepth] = fCurrentElemDecl;
1811 fNilStack[fElementDepth] = fNil;
1812 fNotationStack[fElementDepth] = fNotation;
1813 fTypeStack[fElementDepth] = fCurrentType;
1814 fStrictAssessStack[fElementDepth] = fStrictAssess;
1815 fCMStack[fElementDepth] = fCurrentCM;
1816 fCMStateStack[fElementDepth] = fCurrCMState;
1817 fSawTextStack[fElementDepth] = fSawText;
1818 fStringContent[fElementDepth] = fSawCharacters;
1819 }
1820
1821 // increase the element depth after we've saved
1822 // all states for the parent element
1823 fElementDepth++;
1824 fCurrentElemDecl = null;
1825 XSWildcardDecl wildcard = null;
1826 fCurrentType = null;
1827 fStrictAssess = true;
1828 fNil = false;
1829 fNotation = null;
1830
1831 // and the buffer to hold the value of the element
1832 fBuffer.setLength(0);
1833 fSawText = false;
1834 fSawCharacters = false;
1835
1836 // check what kind of declaration the "decl" from
1837 // oneTransition() maps to
1838 if (decl != null) {
1839 if (decl instanceof XSElementDecl) {
1840 fCurrentElemDecl = (XSElementDecl) decl;
1841 } else {
1842 wildcard = (XSWildcardDecl) decl;
1843 }
1844 }
1845
1846 // if the wildcard is skip, then return
1847 if (wildcard != null && wildcard.fProcessContents == XSWildcardDecl.PC_SKIP) {
1848 fSkipValidationDepth = fElementDepth;
1849 if (fAugPSVI)
1850 augs = getEmptyAugs(augs);
1851 return augs;
1852 }
1853
1854 // try again to get the element decl:
1855 // case 1: find declaration for root element
1856 // case 2: find declaration for element from another namespace
1857 if (fCurrentElemDecl == null) {
1858 if (sGrammar != null) {
1859 fCurrentElemDecl = sGrammar.getGlobalElementDecl(element.localpart);
1860 }
1861 }
1862
1863 if (fCurrentElemDecl != null) {
1864 // then get the type
1865 fCurrentType = fCurrentElemDecl.fType;
1866 }
1867
1868 // get type from xsi:type
1869 String xsiType = attributes.getValue(SchemaSymbols.URI_XSI, SchemaSymbols.XSI_TYPE);
1870
1871 // if no decl/type found for the current element
1872 if (fCurrentType == null && xsiType == null) {
1873 // if this is the validation root, report an error, because
1874 // we can't find eith decl or type for this element
1875 // REVISIT: should we report error, or warning?
1876 if (fElementDepth == 0) {
1877 // for dynamic validation, skip the whole content,
1878 // because no grammar was found.
1879 if (fDynamicValidation || fSchemaDynamicValidation) {
1880 // no schema grammar was found, but it's either dynamic
1881 // validation, or another kind of grammar was found (DTD,
1882 // for example). The intended behavior here is to skip
1883 // the whole document. To improve performance, we try to
1884 // remove the validator from the pipeline, since it's not
1885 // supposed to do anything.
1886 if (fDocumentSource != null) {
1887 fDocumentSource.setDocumentHandler(fDocumentHandler);
1888 if (fDocumentHandler != null)
1889 fDocumentHandler.setDocumentSource(fDocumentSource);
1890 // indicate that the validator was removed.
1891 fElementDepth = -2;
1892 return augs;
1893 }
1894
1895 fSkipValidationDepth = fElementDepth;
1896 if (fAugPSVI)
1897 augs = getEmptyAugs(augs);
1898 return augs;
1899 }
1900 // We don't call reportSchemaError here, because the spec
1901 // doesn't think it's invalid not to be able to find a
1902 // declaration or type definition for an element. Xerces is
1903 // reporting it as an error for historical reasons, but in
1904 // PSVI, we shouldn't mark this element as invalid because
1905 // of this. - SG
1906 fXSIErrorReporter.fErrorReporter.reportError(
1907 XSMessageFormatter.SCHEMA_DOMAIN,
1908 "cvc-elt.1",
1909 new Object[] { element.rawname },
1910 XMLErrorReporter.SEVERITY_ERROR);
1911 }
1912 // if wildcard = strict, report error.
1913 // needs to be called before fXSIErrorReporter.pushContext()
1914 // so that the error belongs to the parent element.
1915 else if (wildcard != null && wildcard.fProcessContents == XSWildcardDecl.PC_STRICT) {
1916 // report error, because wilcard = strict
1917 reportSchemaError("cvc-complex-type.2.4.c", new Object[] { element.rawname });
1918 }
1919 // no element decl or type found for this element.
1920 // Allowed by the spec, we can choose to either laxly assess this
1921 // element, or to skip it. Now we choose lax assessment.
1922 fCurrentType = SchemaGrammar.fAnyType;
1923 fStrictAssess = false;
1924 fNFullValidationDepth = fElementDepth;
1925 // any type has mixed content, so we don't need to append buffer
1926 fAppendBuffer = false;
1927
1928 // push error reporter context: record the current position
1929 // This has to happen after we process skip contents,
1930 // otherwise push and pop won't be correctly paired.
1931 fXSIErrorReporter.pushContext();
1932 } else {
1933 // push error reporter context: record the current position
1934 // This has to happen after we process skip contents,
1935 // otherwise push and pop won't be correctly paired.
1936 fXSIErrorReporter.pushContext();
1937
1938 // get xsi:type
1939 if (xsiType != null) {
1940 XSTypeDefinition oldType = fCurrentType;
1941 fCurrentType = getAndCheckXsiType(element, xsiType, attributes);
1942 // If it fails, use the old type. Use anyType if ther is no old type.
1943 if (fCurrentType == null) {
1944 if (oldType == null)
1945 fCurrentType = SchemaGrammar.fAnyType;
1946 else
1947 fCurrentType = oldType;
1948 }
1949 }
1950
1951 fNNoneValidationDepth = fElementDepth;
1952 // if the element has a fixed value constraint, we need to append
1953 if (fCurrentElemDecl != null
1954 && fCurrentElemDecl.getConstraintType() == XSConstants.VC_FIXED) {
1955 fAppendBuffer = true;
1956 }
1957 // if the type is simple, we need to append
1958 else if (fCurrentType.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE) {
1959 fAppendBuffer = true;
1960 } else {
1961 // if the type is simple content complex type, we need to append
1962 XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType;
1963 fAppendBuffer = (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_SIMPLE);
1964 }
1965 }
1966
1967 // Element Locally Valid (Element)
1968 // 2 Its {abstract} must be false.
1969 if (fCurrentElemDecl != null && fCurrentElemDecl.getAbstract())
1970 reportSchemaError("cvc-elt.2", new Object[] { element.rawname });
1971
1972 // make the current element validation root
1973 if (fElementDepth == 0) {
1974 fValidationRoot = element.rawname;
1975 }
1976
1977 // update normalization flags
1978 if (fNormalizeData) {
1979 // reset values
1980 fFirstChunk = true;
1981 fTrailing = false;
1982 fUnionType = false;
1983 fWhiteSpace = -1;
1984 }
1985
1986 // Element Locally Valid (Type)
1987 // 2 Its {abstract} must be false.
1988 if (fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
1989 XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType;
1990 if (ctype.getAbstract()) {
1991 reportSchemaError("cvc-type.2", new Object[] { element.rawname });
1992 }
1993 if (fNormalizeData) {
1994 // find out if the content type is simple and if variety is union
1995 // to be able to do character normalization
1996 if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_SIMPLE) {
1997 if (ctype.fXSSimpleType.getVariety() == XSSimpleType.VARIETY_UNION) {
1998 fUnionType = true;
1999 } else {
2000 try {
2001 fWhiteSpace = ctype.fXSSimpleType.getWhitespace();
2002 } catch (DatatypeException e) {
2003 // do nothing
2004 }
2005 }
2006 }
2007 }
2008 }
2009 // normalization: simple type
2010 else if (fNormalizeData) {
2011 // if !union type
2012 XSSimpleType dv = (XSSimpleType) fCurrentType;
2013 if (dv.getVariety() == XSSimpleType.VARIETY_UNION) {
2014 fUnionType = true;
2015 } else {
2016 try {
2017 fWhiteSpace = dv.getWhitespace();
2018 } catch (DatatypeException e) {
2019 // do nothing
2020 }
2021 }
2022 }
2023
2024 // then try to get the content model
2025 fCurrentCM = null;
2026 if (fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
2027 fCurrentCM = ((XSComplexTypeDecl) fCurrentType).getContentModel(fCMBuilder);
2028 }
2029
2030 // and get the initial content model state
2031 fCurrCMState = null;
2032 if (fCurrentCM != null)
2033 fCurrCMState = fCurrentCM.startContentModel();
2034
2035 // get information about xsi:nil
2036 String xsiNil = attributes.getValue(SchemaSymbols.URI_XSI, SchemaSymbols.XSI_NIL);
2037 // only deal with xsi:nil when there is an element declaration
2038 if (xsiNil != null && fCurrentElemDecl != null)
2039 fNil = getXsiNil(element, xsiNil);
2040
2041 // now validate everything related with the attributes
2042 // first, get the attribute group
2043 XSAttributeGroupDecl attrGrp = null;
2044 if (fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
2045 XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType;
2046 attrGrp = ctype.getAttrGrp();
2047 }
2048 // activate identity constraints
2049 fValueStoreCache.startElement();
2050 fMatcherStack.pushContext();
2051 if (fCurrentElemDecl != null && fCurrentElemDecl.fIDCPos > 0) {
2052 fIdConstraint = true;
2053 // initialize when identity constrains are defined for the elem
2054 fValueStoreCache.initValueStoresFor(fCurrentElemDecl, this);
2055 }
2056 processAttributes(element, attributes, attrGrp);
2057
2058 // add default attributes
2059 if (attrGrp != null) {
2060 addDefaultAttributes(element, attributes, attrGrp);
2061 }
2062
2063 // call all active identity constraints
2064 int count = fMatcherStack.getMatcherCount();
2065 for (int i = 0; i < count; i++) {
2066 XPathMatcher matcher = fMatcherStack.getMatcherAt(i);
2067 matcher.startElement( element, attributes);
2068 }
2069
2070 if (fAugPSVI) {
2071 augs = getEmptyAugs(augs);
2072
2073 // PSVI: add validation context
2074 fCurrentPSVI.fValidationContext = fValidationRoot;
2075 // PSVI: add element declaration
2076 fCurrentPSVI.fDeclaration = fCurrentElemDecl;
2077 // PSVI: add element type
2078 fCurrentPSVI.fTypeDecl = fCurrentType;
2079 // PSVI: add notation attribute
2080 fCurrentPSVI.fNotation = fNotation;
2081 }
2082
2083 return augs;
2084
2085 } // handleStartElement(QName,XMLAttributes,boolean)
2086
2087 /**
2088 * Handle end element. If there is not text content, and there is a
2089 * {value constraint} on the corresponding element decl, then
2090 * set the fDefaultValue XMLString representing the default value.
2091 */
2092 Augmentations handleEndElement(QName element, Augmentations augs) {
2093
2094 if (DEBUG) {
2095 System.out.println("==>handleEndElement:" + element);
2096 }
2097 // if we are skipping, return
2098 if (fSkipValidationDepth >= 0) {
2099 // but if this is the top element that we are skipping,
2100 // restore the states.
2101 if (fSkipValidationDepth == fElementDepth && fSkipValidationDepth > 0) {
2102 // set the partial validation depth to the depth of parent
2103 fNFullValidationDepth = fSkipValidationDepth - 1;
2104 fSkipValidationDepth = -1;
2105 fElementDepth--;
2106 fSubElement = fSubElementStack[fElementDepth];
2107 fCurrentElemDecl = fElemDeclStack[fElementDepth];
2108 fNil = fNilStack[fElementDepth];
2109 fNotation = fNotationStack[fElementDepth];
2110 fCurrentType = fTypeStack[fElementDepth];
2111 fCurrentCM = fCMStack[fElementDepth];
2112 fStrictAssess = fStrictAssessStack[fElementDepth];
2113 fCurrCMState = fCMStateStack[fElementDepth];
2114 fSawText = fSawTextStack[fElementDepth];
2115 fSawCharacters = fStringContent[fElementDepth];
2116 }
2117 else {
2118 fElementDepth--;
2119 }
2120
2121 // PSVI: validation attempted:
2122 // use default values in psvi item for
2123 // validation attempted, validity, and error codes
2124
2125 // check extra schema constraints on root element
2126 if (fElementDepth == -1 && fFullChecking) {
2127 XSConstraints.fullSchemaChecking(
2128 fGrammarBucket,
2129 fSubGroupHandler,
2130 fCMBuilder,
2131 fXSIErrorReporter.fErrorReporter);
2132 }
2133
2134 if (fAugPSVI)
2135 augs = getEmptyAugs(augs);
2136 return augs;
2137 }
2138
2139 // now validate the content of the element
2140 processElementContent(element);
2141
2142 // Element Locally Valid (Element)
2143 // 6 The element information item must be valid with respect to each of the {identity-constraint definitions} as per Identity-constraint Satisfied (3.11.4).
2144
2145 // call matchers and de-activate context
2146 int oldCount = fMatcherStack.getMatcherCount();
2147 for (int i = oldCount - 1; i >= 0; i--) {
2148 XPathMatcher matcher = fMatcherStack.getMatcherAt(i);
2149 if (fCurrentElemDecl == null)
2150 matcher.endElement(element, null, false, fValidatedInfo.actualValue, fValidatedInfo.actualValueType, fValidatedInfo.itemValueTypes);
2151
2152 else
2153 matcher.endElement(
2154 element,
2155 fCurrentType,
2156 fCurrentElemDecl.getNillable(),
2157 fDefaultValue == null
2158 ? fValidatedInfo.actualValue
2159 : fCurrentElemDecl.fDefault.actualValue,
2160 fDefaultValue == null
2161 ? fValidatedInfo.actualValueType
2162 : fCurrentElemDecl.fDefault.actualValueType,
2163 fDefaultValue == null
2164 ? fValidatedInfo.itemValueTypes
2165 : fCurrentElemDecl.fDefault.itemValueTypes);
2166 }
2167
2168 if (fMatcherStack.size() > 0) {
2169 fMatcherStack.popContext();
2170 }
2171
2172 int newCount = fMatcherStack.getMatcherCount();
2173 // handle everything *but* keyref's.
2174 for (int i = oldCount - 1; i >= newCount; i--) {
2175 XPathMatcher matcher = fMatcherStack.getMatcherAt(i);
2176 if (matcher instanceof Selector.Matcher) {
2177 Selector.Matcher selMatcher = (Selector.Matcher) matcher;
2178 IdentityConstraint id;
2179 if ((id = selMatcher.getIdentityConstraint()) != null
2180 && id.getCategory() != IdentityConstraint.IC_KEYREF) {
2181 fValueStoreCache.transplant(id, selMatcher.getInitialDepth());
2182 }
2183 }
2184 }
2185
2186 // now handle keyref's/...
2187 for (int i = oldCount - 1; i >= newCount; i--) {
2188 XPathMatcher matcher = fMatcherStack.getMatcherAt(i);
2189 if (matcher instanceof Selector.Matcher) {
2190 Selector.Matcher selMatcher = (Selector.Matcher) matcher;
2191 IdentityConstraint id;
2192 if ((id = selMatcher.getIdentityConstraint()) != null
2193 && id.getCategory() == IdentityConstraint.IC_KEYREF) {
2194 ValueStoreBase values =
2195 fValueStoreCache.getValueStoreFor(id, selMatcher.getInitialDepth());
2196 if (values != null) // nothing to do if nothing matched!
2197 values.endDocumentFragment();
2198 }
2199 }
2200 }
2201 fValueStoreCache.endElement();
2202
2203 SchemaGrammar[] grammars = null;
2204 // have we reached the end tag of the validation root?
2205 if (fElementDepth == 0) {
2206 // 7 If the element information item is the validation root, it must be valid per Validation Root Valid (ID/IDREF) (3.3.4).
2207 String invIdRef = fValidationState.checkIDRefID();
2208 fValidationState.resetIDTables();
2209 if (invIdRef != null) {
2210 reportSchemaError("cvc-id.1", new Object[] { invIdRef });
2211 }
2212 // check extra schema constraints
2213 if (fFullChecking) {
2214 XSConstraints.fullSchemaChecking(
2215 fGrammarBucket,
2216 fSubGroupHandler,
2217 fCMBuilder,
2218 fXSIErrorReporter.fErrorReporter);
2219 }
2220
2221 grammars = fGrammarBucket.getGrammars();
2222 // return the final set of grammars validator ended up with
2223 if (fGrammarPool != null) {
2224 // Set grammars as immutable
2225 for (int k=0; k < grammars.length; k++) {
2226 grammars[k].setImmutable(true);
2227 }
2228 fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_SCHEMA, grammars);
2229 }
2230 augs = endElementPSVI(true, grammars, augs);
2231 } else {
2232 augs = endElementPSVI(false, grammars, augs);
2233
2234 // decrease element depth and restore states
2235 fElementDepth--;
2236
2237 // get the states for the parent element.
2238 fSubElement = fSubElementStack[fElementDepth];
2239 fCurrentElemDecl = fElemDeclStack[fElementDepth];
2240 fNil = fNilStack[fElementDepth];
2241 fNotation = fNotationStack[fElementDepth];
2242 fCurrentType = fTypeStack[fElementDepth];
2243 fCurrentCM = fCMStack[fElementDepth];
2244 fStrictAssess = fStrictAssessStack[fElementDepth];
2245 fCurrCMState = fCMStateStack[fElementDepth];
2246 fSawText = fSawTextStack[fElementDepth];
2247 fSawCharacters = fStringContent[fElementDepth];
2248
2249 // We should have a stack for whitespace value, and pop it up here.
2250 // But when fWhiteSpace != -1, and we see a sub-element, it must be
2251 // an error (at least for Schema 1.0). So for valid documents, the
2252 // only value we are going to push/pop in the stack is -1.
2253 // Here we just mimic the effect of popping -1. -SG
2254 fWhiteSpace = -1;
2255 // Same for append buffer. Simple types and elements with fixed
2256 // value constraint don't allow sub-elements. -SG
2257 fAppendBuffer = false;
2258 // same here.
2259 fUnionType = false;
2260 }
2261
2262 return augs;
2263 } // handleEndElement(QName,boolean)*/
2264
2265 final Augmentations endElementPSVI(
2266 boolean root,
2267 SchemaGrammar[] grammars,
2268 Augmentations augs) {
2269
2270 if (fAugPSVI) {
2271 augs = getEmptyAugs(augs);
2272
2273 // the 4 properties sent on startElement calls
2274 fCurrentPSVI.fDeclaration = this.fCurrentElemDecl;
2275 fCurrentPSVI.fTypeDecl = this.fCurrentType;
2276 fCurrentPSVI.fNotation = this.fNotation;
2277 fCurrentPSVI.fValidationContext = this.fValidationRoot;
2278 // PSVI: validation attempted
2279 // nothing below or at the same level has none or partial
2280 // (which means this level is strictly assessed, and all chidren
2281 // are full), so this one has full
2282 if (fElementDepth > fNFullValidationDepth) {
2283 fCurrentPSVI.fValidationAttempted = ElementPSVI.VALIDATION_FULL;
2284 }
2285 // nothing below or at the same level has full or partial
2286 // (which means this level is not strictly assessed, and all chidren
2287 // are none), so this one has none
2288 else if (fElementDepth > fNNoneValidationDepth) {
2289 fCurrentPSVI.fValidationAttempted = ElementPSVI.VALIDATION_NONE;
2290 }
2291 // otherwise partial, and anything above this level will be partial
2292 else {
2293 fCurrentPSVI.fValidationAttempted = ElementPSVI.VALIDATION_PARTIAL;
2294 fNFullValidationDepth = fNNoneValidationDepth = fElementDepth - 1;
2295 }
2296
2297 if (fDefaultValue != null)
2298 fCurrentPSVI.fSpecified = true;
2299 fCurrentPSVI.fNil = fNil;
2300 fCurrentPSVI.fMemberType = fValidatedInfo.memberType;
2301 fCurrentPSVI.fNormalizedValue = fValidatedInfo.normalizedValue;
2302 fCurrentPSVI.fActualValue = fValidatedInfo.actualValue;
2303 fCurrentPSVI.fActualValueType = fValidatedInfo.actualValueType;
2304 fCurrentPSVI.fItemValueTypes = fValidatedInfo.itemValueTypes;
2305
2306 if (fStrictAssess) {
2307 // get all errors for the current element, its attribute,
2308 // and subelements (if they were strictly assessed).
2309 // any error would make this element invalid.
2310 // and we merge these errors to the parent element.
2311 String[] errors = fXSIErrorReporter.mergeContext();
2312
2313 // PSVI: error codes
2314 fCurrentPSVI.fErrorCodes = errors;
2315 // PSVI: validity
2316 fCurrentPSVI.fValidity =
2317 (errors == null) ? ElementPSVI.VALIDITY_VALID : ElementPSVI.VALIDITY_INVALID;
2318 } else {
2319 // PSVI: validity
2320 fCurrentPSVI.fValidity = ElementPSVI.VALIDITY_NOTKNOWN;
2321 // Discard the current context: ignore any error happened within
2322 // the sub-elements/attributes of this element, because those
2323 // errors won't affect the validity of the parent elements.
2324 fXSIErrorReporter.popContext();
2325 }
2326
2327 if (root) {
2328 // store [schema information] in the PSVI
2329 fCurrentPSVI.fGrammars = grammars;
2330 fCurrentPSVI.fSchemaInformation = null;
2331 }
2332 }
2333
2334 return augs;
2335
2336 }
2337
2338 Augmentations getEmptyAugs(Augmentations augs) {
2339 if (augs == null) {
2340 augs = fAugmentations;
2341 augs.removeAllItems();
2342 }
2343 augs.putItem(Constants.ELEMENT_PSVI, fCurrentPSVI);
2344 fCurrentPSVI.reset();
2345
2346 return augs;
2347 }
2348
2349 void storeLocations(String sLocation, String nsLocation) {
2350 if (sLocation != null) {
2351 if (!XMLSchemaLoader.tokenizeSchemaLocationStr(sLocation, fLocationPairs)) {
2352 // error!
2353 fXSIErrorReporter.reportError(
2354 XSMessageFormatter.SCHEMA_DOMAIN,
2355 "SchemaLocation",
2356 new Object[] { sLocation },
2357 XMLErrorReporter.SEVERITY_WARNING);
2358 }
2359 }
2360 if (nsLocation != null) {
2361 XMLSchemaLoader.LocationArray la =
2362 ((XMLSchemaLoader.LocationArray) fLocationPairs.get(XMLSymbols.EMPTY_STRING));
2363 if (la == null) {
2364 la = new XMLSchemaLoader.LocationArray();
2365 fLocationPairs.put(XMLSymbols.EMPTY_STRING, la);
2366 }
2367 la.addLocation(nsLocation);
2368 }
2369
2370 } //storeLocations
2371
2372 //this is the function where logic of retrieving grammar is written , parser first tries to get the grammar from
2373 //the local pool, if not in local pool, it gives chance to application to be able to retrieve the grammar, then it
2374 //tries to parse the grammar using location hints from the give namespace.
2375 SchemaGrammar findSchemaGrammar(
2376 short contextType,
2377 String namespace,
2378 QName enclosingElement,
2379 QName triggeringComponet,
2380 XMLAttributes attributes) {
2381 SchemaGrammar grammar = null;
2382 //get the grammar from local pool...
2383 grammar = fGrammarBucket.getGrammar(namespace);
2384
2385 if (grammar == null) {
2386 fXSDDescription.setNamespace(namespace);
2387 // give a chance to application to be able to retreive the grammar.
2388 if (fGrammarPool != null) {
2389 grammar = (SchemaGrammar) fGrammarPool.retrieveGrammar(fXSDDescription);
2390 if (grammar != null) {
2391 // put this grammar into the bucket, along with grammars
2392 // imported by it (directly or indirectly)
2393 if (!fGrammarBucket.putGrammar(grammar, true, fNamespaceGrowth)) {
2394 // REVISIT: a conflict between new grammar(s) and grammars
2395 // in the bucket. What to do? A warning? An exception?
2396 fXSIErrorReporter.fErrorReporter.reportError(
2397 XSMessageFormatter.SCHEMA_DOMAIN,
2398 "GrammarConflict",
2399 null,
2400 XMLErrorReporter.SEVERITY_WARNING);
2401 grammar = null;
2402 }
2403 }
2404 }
2405 }
2406 if ((grammar == null && !fUseGrammarPoolOnly) || fNamespaceGrowth) {
2407 fXSDDescription.reset();
2408 fXSDDescription.fContextType = contextType;
2409 fXSDDescription.setNamespace(namespace);
2410 fXSDDescription.fEnclosedElementName = enclosingElement;
2411 fXSDDescription.fTriggeringComponent = triggeringComponet;
2412 fXSDDescription.fAttributes = attributes;
2413 if (fLocator != null) {
2414 fXSDDescription.setBaseSystemId(fLocator.getExpandedSystemId());
2415 }
2416
2417 Hashtable locationPairs = fLocationPairs;
2418 Object locationArray =
2419 locationPairs.get(namespace == null ? XMLSymbols.EMPTY_STRING : namespace);
2420 if (locationArray != null) {
2421 String[] temp = ((XMLSchemaLoader.LocationArray) locationArray).getLocationArray();
2422 if (temp.length != 0) {
2423 setLocationHints(fXSDDescription, temp, grammar);
2424 }
2425 }
2426
2427 if (grammar == null || fXSDDescription.fLocationHints != null) {
2428 boolean toParseSchema = true;
2429 if (grammar != null) {
2430 // use location hints instead
2431 locationPairs = EMPTY_TABLE;
2432 }
2433
2434 // try to parse the grammar using location hints from that namespace..
2435 try {
2436 XMLInputSource xis =
2437 XMLSchemaLoader.resolveDocument(
2438 fXSDDescription,
2439 locationPairs,
2440 fEntityResolver);
2441 if (grammar != null && fNamespaceGrowth) {
2442 try {
2443 // if we are dealing with a different schema location, then include the new schema
2444 // into the existing grammar
2445 if (grammar.getDocumentLocations().contains(XMLEntityManager.expandSystemId(xis.getSystemId(), xis.getBaseSystemId(), false))) {
2446 toParseSchema = false;
2447 }
2448 }
2449 catch (MalformedURIException e) {
2450 }
2451 }
2452 if (toParseSchema) {
2453 grammar = fSchemaLoader.loadSchema(fXSDDescription, xis, fLocationPairs);
2454 }
2455 } catch (IOException ex) {
2456 final String [] locationHints = fXSDDescription.getLocationHints();
2457 fXSIErrorReporter.fErrorReporter.reportError(
2458 XSMessageFormatter.SCHEMA_DOMAIN,
2459 "schema_reference.4",
2460 new Object[] { locationHints != null ? locationHints[0] : XMLSymbols.EMPTY_STRING },
2461 XMLErrorReporter.SEVERITY_WARNING);
2462 }
2463 }
2464 }
2465
2466 return grammar;
2467
2468 } //findSchemaGrammar
2469 private void setLocationHints(XSDDescription desc, String[] locations, SchemaGrammar grammar) {
2470 int length = locations.length;
2471 if (grammar == null) {
2472 fXSDDescription.fLocationHints = new String[length];
2473 System.arraycopy(locations, 0, fXSDDescription.fLocationHints, 0, length);
2474 }
2475 else {
2476 setLocationHints(desc, locations, grammar.getDocumentLocations());
2477 }
2478 }
2479
2480 private void setLocationHints(XSDDescription desc, String[] locations, StringList docLocations) {
2481 int length = locations.length;
2482 String[] hints = new String[length];
2483 int counter = 0;
2484
2485 for (int i=0; i<length; i++) {
2486 try {
2487 String id = XMLEntityManager.expandSystemId(locations[i], desc.getBaseSystemId(), false);
2488 if (!docLocations.contains(id)) {
2489 hints[counter++] = locations[i];
2490 }
2491 }
2492 catch (MalformedURIException e) {
2493 }
2494 }
2495
2496 if (counter > 0) {
2497 if (counter == length) {
2498 fXSDDescription.fLocationHints = hints;
2499 }
2500 else {
2501 fXSDDescription.fLocationHints = new String[counter];
2502 System.arraycopy(hints, 0, fXSDDescription.fLocationHints, 0, counter);
2503 }
2504 }
2505 }
2506
2507
2508 XSTypeDefinition getAndCheckXsiType(QName element, String xsiType, XMLAttributes attributes) {
2509 // This method also deals with clause 1.2.1.2 of the constraint
2510 // Validation Rule: Schema-Validity Assessment (Element)
2511
2512 // Element Locally Valid (Element)
2513 // 4 If there is an attribute information item among the element information item's [attributes] whose [namespace name] is identical to http://www.w3.org/2001/XMLSchema-instance and whose [local name] is type, then all of the following must be true:
2514 // 4.1 The normalized value of that attribute information item must be valid with respect to the built-in QName simple type, as defined by String Valid (3.14.4);
2515 QName typeName = null;
2516 try {
2517 typeName = (QName) fQNameDV.validate(xsiType, fValidationState, null);
2518 } catch (InvalidDatatypeValueException e) {
2519 reportSchemaError(e.getKey(), e.getArgs());
2520 reportSchemaError(
2521 "cvc-elt.4.1",
2522 new Object[] {
2523 element.rawname,
2524 SchemaSymbols.URI_XSI + "," + SchemaSymbols.XSI_TYPE,
2525 xsiType });
2526 return null;
2527 }
2528
2529 // 4.2 The local name and namespace name (as defined in QName Interpretation (3.15.3)), of the actual value of that attribute information item must resolve to a type definition, as defined in QName resolution (Instance) (3.15.4)
2530 XSTypeDefinition type = null;
2531 // if the namespace is schema namespace, first try built-in types
2532 if (typeName.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA) {
2533 type = SchemaGrammar.SG_SchemaNS.getGlobalTypeDecl(typeName.localpart);
2534 }
2535 // if it's not schema built-in types, then try to get a grammar
2536 if (type == null) {
2537 //try to find schema grammar by different means....
2538 SchemaGrammar grammar =
2539 findSchemaGrammar(
2540 XSDDescription.CONTEXT_XSITYPE,
2541 typeName.uri,
2542 element,
2543 typeName,
2544 attributes);
2545
2546 if (grammar != null)
2547 type = grammar.getGlobalTypeDecl(typeName.localpart);
2548 }
2549 // still couldn't find the type, report an error
2550 if (type == null) {
2551 reportSchemaError("cvc-elt.4.2", new Object[] { element.rawname, xsiType });
2552 return null;
2553 }
2554
2555 // if there is no current type, set this one as current.
2556 // and we don't need to do extra checking
2557 if (fCurrentType != null) {
2558 // 4.3 The local type definition must be validly derived from the {type definition} given the union of the {disallowed substitutions} and the {type definition}'s {prohibited substitutions}, as defined in Type Derivation OK (Complex) (3.4.6) (if it is a complex type definition), or given {disallowed substitutions} as defined in Type Derivation OK (Simple) (3.14.6) (if it is a simple type definition).
2559 short block = fCurrentElemDecl.fBlock;
2560 if (fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE)
2561 block |= ((XSComplexTypeDecl) fCurrentType).fBlock;
2562 if (!XSConstraints.checkTypeDerivationOk(type, fCurrentType, block))
2563 reportSchemaError(
2564 "cvc-elt.4.3",
2565 new Object[] { element.rawname, xsiType, fCurrentType.getName()});
2566 }
2567
2568 return type;
2569 } //getAndCheckXsiType
2570
2571 boolean getXsiNil(QName element, String xsiNil) {
2572 // Element Locally Valid (Element)
2573 // 3 The appropriate case among the following must be true:
2574 // 3.1 If {nillable} is false, then there must be no attribute information item among the element information item's [attributes] whose [namespace name] is identical to http://www.w3.org/2001/XMLSchema-instance and whose [local name] is nil.
2575 if (fCurrentElemDecl != null && !fCurrentElemDecl.getNillable()) {
2576 reportSchemaError(
2577 "cvc-elt.3.1",
2578 new Object[] {
2579 element.rawname,
2580 SchemaSymbols.URI_XSI + "," + SchemaSymbols.XSI_NIL });
2581 }
2582 // 3.2 If {nillable} is true and there is such an attribute information item and its actual value is true , then all of the following must be true:
2583 // 3.2.2 There must be no fixed {value constraint}.
2584 else {
2585 String value = XMLChar.trim(xsiNil);
2586 if (value.equals(SchemaSymbols.ATTVAL_TRUE)
2587 || value.equals(SchemaSymbols.ATTVAL_TRUE_1)) {
2588 if (fCurrentElemDecl != null
2589 && fCurrentElemDecl.getConstraintType() == XSConstants.VC_FIXED) {
2590 reportSchemaError(
2591 "cvc-elt.3.2.2",
2592 new Object[] {
2593 element.rawname,
2594 SchemaSymbols.URI_XSI + "," + SchemaSymbols.XSI_NIL });
2595 }
2596 return true;
2597 }
2598 }
2599 return false;
2600 }
2601
2602 void processAttributes(QName element, XMLAttributes attributes, XSAttributeGroupDecl attrGrp) {
2603
2604 if (DEBUG) {
2605 System.out.println("==>processAttributes: " + attributes.getLength());
2606 }
2607
2608 // whether we have seen a Wildcard ID.
2609 String wildcardIDName = null;
2610
2611 // for each present attribute
2612 int attCount = attributes.getLength();
2613
2614 Augmentations augs = null;
2615 AttributePSVImpl attrPSVI = null;
2616
2617 boolean isSimple =
2618 fCurrentType == null || fCurrentType.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE;
2619
2620 XSObjectList attrUses = null;
2621 int useCount = 0;
2622 XSWildcardDecl attrWildcard = null;
2623 if (!isSimple) {
2624 attrUses = attrGrp.getAttributeUses();
2625 useCount = attrUses.getLength();
2626 attrWildcard = attrGrp.fAttributeWC;
2627 }
2628
2629 // Element Locally Valid (Complex Type)
2630 // 3 For each attribute information item in the element information item's [attributes] excepting those whose [namespace name] is identical to http://www.w3.org/2001/XMLSchema-instance and whose [local name] is one of type, nil, schemaLocation or noNamespaceSchemaLocation, the appropriate case among the following must be true:
2631 // get the corresponding attribute decl
2632 for (int index = 0; index < attCount; index++) {
2633
2634 attributes.getName(index, fTempQName);
2635
2636 if (DEBUG) {
2637 System.out.println("==>process attribute: " + fTempQName);
2638 }
2639
2640 if (fAugPSVI || fIdConstraint) {
2641 augs = attributes.getAugmentations(index);
2642 attrPSVI = (AttributePSVImpl) augs.getItem(Constants.ATTRIBUTE_PSVI);
2643 if (attrPSVI != null) {
2644 attrPSVI.reset();
2645 } else {
2646 attrPSVI = new AttributePSVImpl();
2647 augs.putItem(Constants.ATTRIBUTE_PSVI, attrPSVI);
2648 }
2649 // PSVI attribute: validation context
2650 attrPSVI.fValidationContext = fValidationRoot;
2651 }
2652
2653 // Element Locally Valid (Type)
2654 // 3.1.1 The element information item's [attributes] must be empty, excepting those
2655 // whose [namespace name] is identical to http://www.w3.org/2001/XMLSchema-instance and
2656 // whose [local name] is one of type, nil, schemaLocation or noNamespaceSchemaLocation.
2657
2658 // for the 4 xsi attributes, get appropriate decl, and validate
2659 if (fTempQName.uri == SchemaSymbols.URI_XSI) {
2660 XSAttributeDecl attrDecl = null;
2661 if (fTempQName.localpart == SchemaSymbols.XSI_SCHEMALOCATION)
2662 attrDecl =
2663 SchemaGrammar.SG_XSI.getGlobalAttributeDecl(
2664 SchemaSymbols.XSI_SCHEMALOCATION);
2665 else if (fTempQName.localpart == SchemaSymbols.XSI_NONAMESPACESCHEMALOCATION)
2666 attrDecl =
2667 SchemaGrammar.SG_XSI.getGlobalAttributeDecl(
2668 SchemaSymbols.XSI_NONAMESPACESCHEMALOCATION);
2669 else if (fTempQName.localpart == SchemaSymbols.XSI_NIL)
2670 attrDecl = SchemaGrammar.SG_XSI.getGlobalAttributeDecl(SchemaSymbols.XSI_NIL);
2671 else if (fTempQName.localpart == SchemaSymbols.XSI_TYPE)
2672 attrDecl = SchemaGrammar.SG_XSI.getGlobalAttributeDecl(SchemaSymbols.XSI_TYPE);
2673 if (attrDecl != null) {
2674 processOneAttribute(element, attributes, index, attrDecl, null, attrPSVI);
2675 continue;
2676 }
2677 }
2678
2679 // for namespace attributes, no_validation/unknow_validity
2680 if (fTempQName.rawname == XMLSymbols.PREFIX_XMLNS
2681 || fTempQName.rawname.startsWith("xmlns:")) {
2682 continue;
2683 }
2684
2685 // simple type doesn't allow any other attributes
2686 if (isSimple) {
2687 reportSchemaError(
2688 "cvc-type.3.1.1",
2689 new Object[] { element.rawname, fTempQName.rawname });
2690 continue;
2691 }
2692
2693 // it's not xmlns, and not xsi, then we need to find a decl for it
2694 XSAttributeUseImpl currUse = null, oneUse;
2695 for (int i = 0; i < useCount; i++) {
2696 oneUse = (XSAttributeUseImpl) attrUses.item(i);
2697 if (oneUse.fAttrDecl.fName == fTempQName.localpart
2698 && oneUse.fAttrDecl.fTargetNamespace == fTempQName.uri) {
2699 currUse = oneUse;
2700 break;
2701 }
2702 }
2703
2704 // 3.2 otherwise all of the following must be true:
2705 // 3.2.1 There must be an {attribute wildcard}.
2706 // 3.2.2 The attribute information item must be valid with respect to it as defined in Item Valid (Wildcard) (3.10.4).
2707
2708 // if failed, get it from wildcard
2709 if (currUse == null) {
2710 //if (attrWildcard == null)
2711 // reportSchemaError("cvc-complex-type.3.2.1", new Object[]{element.rawname, fTempQName.rawname});
2712 if (attrWildcard == null || !attrWildcard.allowNamespace(fTempQName.uri)) {
2713 // so this attribute is not allowed
2714 reportSchemaError(
2715 "cvc-complex-type.3.2.2",
2716 new Object[] { element.rawname, fTempQName.rawname });
2717 continue;
2718 }
2719 }
2720
2721 XSAttributeDecl currDecl = null;
2722 if (currUse != null) {
2723 currDecl = currUse.fAttrDecl;
2724 } else {
2725 // which means it matches a wildcard
2726 // skip it if processContents is skip
2727 if (attrWildcard.fProcessContents == XSWildcardDecl.PC_SKIP)
2728 continue;
2729
2730 //try to find grammar by different means...
2731 SchemaGrammar grammar =
2732 findSchemaGrammar(
2733 XSDDescription.CONTEXT_ATTRIBUTE,
2734 fTempQName.uri,
2735 element,
2736 fTempQName,
2737 attributes);
2738
2739 if (grammar != null) {
2740 currDecl = grammar.getGlobalAttributeDecl(fTempQName.localpart);
2741 }
2742
2743 // if can't find
2744 if (currDecl == null) {
2745 // if strict, report error
2746 if (attrWildcard.fProcessContents == XSWildcardDecl.PC_STRICT) {
2747 reportSchemaError(
2748 "cvc-complex-type.3.2.2",
2749 new Object[] { element.rawname, fTempQName.rawname });
2750 }
2751
2752 // then continue to the next attribute
2753 continue;
2754 } else {
2755 // 5 Let [Definition:] the wild IDs be the set of all attribute information item to which clause 3.2 applied and whose validation resulted in a context-determined declaration of mustFind or no context-determined declaration at all, and whose [local name] and [namespace name] resolve (as defined by QName resolution (Instance) (3.15.4)) to an attribute declaration whose {type definition} is or is derived from ID. Then all of the following must be true:
2756 // 5.1 There must be no more than one item in wild IDs.
2757 if (currDecl.fType.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE
2758 && ((XSSimpleType) currDecl.fType).isIDType()) {
2759 if (wildcardIDName != null) {
2760 reportSchemaError(
2761 "cvc-complex-type.5.1",
2762 new Object[] { element.rawname, currDecl.fName, wildcardIDName });
2763 } else
2764 wildcardIDName = currDecl.fName;
2765 }
2766 }
2767 }
2768
2769 processOneAttribute(element, attributes, index, currDecl, currUse, attrPSVI);
2770 } // end of for (all attributes)
2771
2772 // 5.2 If wild IDs is non-empty, there must not be any attribute uses among the {attribute uses} whose {attribute declaration}'s {type definition} is or is derived from ID.
2773 if (!isSimple && attrGrp.fIDAttrName != null && wildcardIDName != null) {
2774 reportSchemaError(
2775 "cvc-complex-type.5.2",
2776 new Object[] { element.rawname, wildcardIDName, attrGrp.fIDAttrName });
2777 }
2778
2779 } //processAttributes
2780
2781 void processOneAttribute(
2782 QName element,
2783 XMLAttributes attributes,
2784 int index,
2785 XSAttributeDecl currDecl,
2786 XSAttributeUseImpl currUse,
2787 AttributePSVImpl attrPSVI) {
2788
2789 String attrValue = attributes.getValue(index);
2790 fXSIErrorReporter.pushContext();
2791
2792 // Attribute Locally Valid
2793 // For an attribute information item to be locally valid with respect to an attribute declaration all of the following must be true:
2794 // 1 The declaration must not be absent (see Missing Sub-components (5.3) for how this can fail to be the case).
2795 // 2 Its {type definition} must not be absent.
2796 // 3 The item's normalized value must be locally valid with respect to that {type definition} as per String Valid (3.14.4).
2797 // get simple type
2798 XSSimpleType attDV = currDecl.fType;
2799
2800 Object actualValue = null;
2801 try {
2802 actualValue = attDV.validate(attrValue, fValidationState, fValidatedInfo);
2803 // store the normalized value
2804 if (fNormalizeData)
2805 attributes.setValue(index, fValidatedInfo.normalizedValue);
2806 if (attributes instanceof XMLAttributesImpl) {
2807 XMLAttributesImpl attrs = (XMLAttributesImpl) attributes;
2808 boolean schemaId =
2809 fValidatedInfo.memberType != null
2810 ? fValidatedInfo.memberType.isIDType()
2811 : attDV.isIDType();
2812 attrs.setSchemaId(index, schemaId);
2813 }
2814
2815 // PSVI: element notation
2816 if (attDV.getVariety() == XSSimpleType.VARIETY_ATOMIC
2817 && attDV.getPrimitiveKind() == XSSimpleType.PRIMITIVE_NOTATION) {
2818 QName qName = (QName) actualValue;
2819 SchemaGrammar grammar = fGrammarBucket.getGrammar(qName.uri);
2820
2821 //REVISIT: is it possible for the notation to be in different namespace than the attribute
2822 //with which it is associated, CHECK !! <fof n1:att1 = "n2:notation1" ..>
2823 // should we give chance to the application to be able to retrieve a grammar - nb
2824 //REVISIT: what would be the triggering component here.. if it is attribute value that
2825 // triggered the loading of grammar ?? -nb
2826
2827 if (grammar != null) {
2828 fNotation = grammar.getGlobalNotationDecl(qName.localpart);
2829 }
2830 }
2831 } catch (InvalidDatatypeValueException idve) {
2832 reportSchemaError(idve.getKey(), idve.getArgs());
2833 reportSchemaError(
2834 "cvc-attribute.3",
2835 new Object[] { element.rawname, fTempQName.rawname, attrValue, attDV.getName()});
2836 }
2837
2838 // get the value constraint from use or decl
2839 // 4 The item's actual value must match the value of the {value constraint}, if it is present and fixed. // now check the value against the simpleType
2840 if (actualValue != null && currDecl.getConstraintType() == XSConstants.VC_FIXED) {
2841 if (!isComparable(fValidatedInfo, currDecl.fDefault) || !actualValue.equals(currDecl.fDefault.actualValue)) {
2842 reportSchemaError(
2843 "cvc-attribute.4",
2844 new Object[] {
2845 element.rawname,
2846 fTempQName.rawname,
2847 attrValue,
2848 currDecl.fDefault.stringValue()});
2849 }
2850 }
2851
2852 // 3.1 If there is among the {attribute uses} an attribute use with an {attribute declaration} whose {name} matches the attribute information item's [local name] and whose {target namespace} is identical to the attribute information item's [namespace name] (where an absent {target namespace} is taken to be identical to a [namespace name] with no value), then the attribute information must be valid with respect to that attribute use as per Attribute Locally Valid (Use) (3.5.4). In this case the {attribute declaration} of that attribute use is the context-determined declaration for the attribute information item with respect to Schema-Validity Assessment (Attribute) (3.2.4) and Assessment Outcome (Attribute) (3.2.5).
2853 if (actualValue != null
2854 && currUse != null
2855 && currUse.fConstraintType == XSConstants.VC_FIXED) {
2856 if (!isComparable(fValidatedInfo, currUse.fDefault) || !actualValue.equals(currUse.fDefault.actualValue)) {
2857 reportSchemaError(
2858 "cvc-complex-type.3.1",
2859 new Object[] {
2860 element.rawname,
2861 fTempQName.rawname,
2862 attrValue,
2863 currUse.fDefault.stringValue()});
2864 }
2865 }
2866 if (fIdConstraint) {
2867 attrPSVI.fActualValue = actualValue;
2868 }
2869
2870 if (fAugPSVI) {
2871 // PSVI: attribute declaration
2872 attrPSVI.fDeclaration = currDecl;
2873 // PSVI: attribute type
2874 attrPSVI.fTypeDecl = attDV;
2875
2876 // PSVI: attribute memberType
2877 attrPSVI.fMemberType = fValidatedInfo.memberType;
2878 // PSVI: attribute normalized value
2879 // NOTE: we always store the normalized value, even if it's invlid,
2880 // because it might still be useful to the user. But when the it's
2881 // not valid, the normalized value is not trustable.
2882 attrPSVI.fNormalizedValue = fValidatedInfo.normalizedValue;
2883 attrPSVI.fActualValue = fValidatedInfo.actualValue;
2884 attrPSVI.fActualValueType = fValidatedInfo.actualValueType;
2885 attrPSVI.fItemValueTypes = fValidatedInfo.itemValueTypes;
2886
2887
2888
2889 // PSVI: validation attempted:
2890 attrPSVI.fValidationAttempted = AttributePSVI.VALIDATION_FULL;
2891
2892 String[] errors = fXSIErrorReporter.mergeContext();
2893 // PSVI: error codes
2894 attrPSVI.fErrorCodes = errors;
2895 // PSVI: validity
2896 attrPSVI.fValidity =
2897 (errors == null) ? AttributePSVI.VALIDITY_VALID : AttributePSVI.VALIDITY_INVALID;
2898 }
2899 }
2900
2901 void addDefaultAttributes(
2902 QName element,
2903 XMLAttributes attributes,
2904 XSAttributeGroupDecl attrGrp) {
2905 // Check after all specified attrs are scanned
2906 // (1) report error for REQUIRED attrs that are missing (V_TAGc)
2907 // REVISIT: should we check prohibited attributes?
2908 // (2) report error for PROHIBITED attrs that are present (V_TAGc)
2909 // (3) add default attrs (FIXED and NOT_FIXED)
2910 //
2911 if (DEBUG) {
2912 System.out.println("==>addDefaultAttributes: " + element);
2913 }
2914 XSObjectList attrUses = attrGrp.getAttributeUses();
2915 int useCount = attrUses.getLength();
2916 XSAttributeUseImpl currUse;
2917 XSAttributeDecl currDecl;
2918 short constType;
2919 ValidatedInfo defaultValue;
2920 boolean isSpecified;
2921 QName attName;
2922 // for each attribute use
2923 for (int i = 0; i < useCount; i++) {
2924
2925 currUse = (XSAttributeUseImpl) attrUses.item(i);
2926 currDecl = currUse.fAttrDecl;
2927 // get value constraint
2928 constType = currUse.fConstraintType;
2929 defaultValue = currUse.fDefault;
2930 if (constType == XSConstants.VC_NONE) {
2931 constType = currDecl.getConstraintType();
2932 defaultValue = currDecl.fDefault;
2933 }
2934 // whether this attribute is specified
2935 isSpecified = attributes.getValue(currDecl.fTargetNamespace, currDecl.fName) != null;
2936
2937 // Element Locally Valid (Complex Type)
2938 // 4 The {attribute declaration} of each attribute use in the {attribute uses} whose
2939 // {required} is true matches one of the attribute information items in the element
2940 // information item's [attributes] as per clause 3.1 above.
2941 if (currUse.fUse == SchemaSymbols.USE_REQUIRED) {
2942 if (!isSpecified)
2943 reportSchemaError(
2944 "cvc-complex-type.4",
2945 new Object[] { element.rawname, currDecl.fName });
2946 }
2947 // if the attribute is not specified, then apply the value constraint
2948 if (!isSpecified && constType != XSConstants.VC_NONE) {
2949 attName =
2950 new QName(null, currDecl.fName, currDecl.fName, currDecl.fTargetNamespace);
2951 String normalized = (defaultValue != null) ? defaultValue.stringValue() : "";
2952 int attrIndex = attributes.addAttribute(attName, "CDATA", normalized);
2953 if (attributes instanceof XMLAttributesImpl) {
2954 XMLAttributesImpl attrs = (XMLAttributesImpl) attributes;
2955 boolean schemaId =
2956 defaultValue != null
2957 && defaultValue.memberType != null
2958 ? defaultValue.memberType.isIDType()
2959 : currDecl.fType.isIDType();
2960 attrs.setSchemaId(attrIndex, schemaId);
2961 }
2962
2963 if (fAugPSVI) {
2964
2965 // PSVI: attribute is "schema" specified
2966 Augmentations augs = attributes.getAugmentations(attrIndex);
2967 AttributePSVImpl attrPSVI = new AttributePSVImpl();
2968 augs.putItem(Constants.ATTRIBUTE_PSVI, attrPSVI);
2969
2970 attrPSVI.fDeclaration = currDecl;
2971 attrPSVI.fTypeDecl = currDecl.fType;
2972 attrPSVI.fMemberType = defaultValue.memberType;
2973 attrPSVI.fNormalizedValue = normalized;
2974 attrPSVI.fActualValue = defaultValue.actualValue;
2975 attrPSVI.fActualValueType = defaultValue.actualValueType;
2976 attrPSVI.fItemValueTypes = defaultValue.itemValueTypes;
2977 attrPSVI.fValidationContext = fValidationRoot;
2978 attrPSVI.fValidity = AttributePSVI.VALIDITY_VALID;
2979 attrPSVI.fValidationAttempted = AttributePSVI.VALIDATION_FULL;
2980 attrPSVI.fSpecified = true;
2981 }
2982 }
2983
2984 } // for
2985 } // addDefaultAttributes
2986
2987 /**
2988 * If there is not text content, and there is a
2989 * {value constraint} on the corresponding element decl, then return
2990 * an XMLString representing the default value.
2991 */
2992 void processElementContent(QName element) {
2993 // 1 If the item is ?valid? with respect to an element declaration as per Element Locally Valid (Element) (?3.3.4) and the {value constraint} is present, but clause 3.2 of Element Locally Valid (Element) (?3.3.4) above is not satisfied and the item has no element or character information item [children], then schema. Furthermore, the post-schema-validation infoset has the canonical lexical representation of the {value constraint} value as the item's [schema normalized value] property.
2994 if (fCurrentElemDecl != null
2995 && fCurrentElemDecl.fDefault != null
2996 && !fSawText
2997 && !fSubElement
2998 && !fNil) {
2999
3000 String strv = fCurrentElemDecl.fDefault.stringValue();
3001 int bufLen = strv.length();
3002 if (fNormalizedStr.ch == null || fNormalizedStr.ch.length < bufLen) {
3003 fNormalizedStr.ch = new char[bufLen];
3004 }
3005 strv.getChars(0, bufLen, fNormalizedStr.ch, 0);
3006 fNormalizedStr.offset = 0;
3007 fNormalizedStr.length = bufLen;
3008 fDefaultValue = fNormalizedStr;
3009 }
3010 // fixed values are handled later, after xsi:type determined.
3011
3012 fValidatedInfo.normalizedValue = null;
3013
3014 // Element Locally Valid (Element)
3015 // 3.2.1 The element information item must have no character or element information item [children].
3016 if (fNil) {
3017 if (fSubElement || fSawText) {
3018 reportSchemaError(
3019 "cvc-elt.3.2.1",
3020 new Object[] {
3021 element.rawname,
3022 SchemaSymbols.URI_XSI + "," + SchemaSymbols.XSI_NIL });
3023 }
3024 }
3025
3026 this.fValidatedInfo.reset();
3027
3028 // 5 The appropriate case among the following must be true:
3029 // 5.1 If the declaration has a {value constraint}, the item has neither element nor character [children] and clause 3.2 has not applied, then all of the following must be true:
3030 if (fCurrentElemDecl != null
3031 && fCurrentElemDecl.getConstraintType() != XSConstants.VC_NONE
3032 && !fSubElement
3033 && !fSawText
3034 && !fNil) {
3035 // 5.1.1 If the actual type definition is a local type definition then the canonical lexical representation of the {value constraint} value must be a valid default for the actual type definition as defined in Element Default Valid (Immediate) (3.3.6).
3036 if (fCurrentType != fCurrentElemDecl.fType) {
3037 //REVISIT:we should pass ValidatedInfo here.
3038 if (XSConstraints
3039 .ElementDefaultValidImmediate(
3040 fCurrentType,
3041 fCurrentElemDecl.fDefault.stringValue(),
3042 fState4XsiType,
3043 null)
3044 == null)
3045 reportSchemaError(
3046 "cvc-elt.5.1.1",
3047 new Object[] {
3048 element.rawname,
3049 fCurrentType.getName(),
3050 fCurrentElemDecl.fDefault.stringValue()});
3051 }
3052 // 5.1.2 The element information item with the canonical lexical representation of the {value constraint} value used as its normalized value must be valid with respect to the actual type definition as defined by Element Locally Valid (Type) (3.3.4).
3053 // REVISIT: don't use toString, but validateActualValue instead
3054 // use the fState4ApplyDefault
3055 elementLocallyValidType(element, fCurrentElemDecl.fDefault.stringValue());
3056 } else {
3057 // The following method call also deal with clause 1.2.2 of the constraint
3058 // Validation Rule: Schema-Validity Assessment (Element)
3059
3060 // 5.2 If the declaration has no {value constraint} or the item has either element or character [children] or clause 3.2 has applied, then all of the following must be true:
3061 // 5.2.1 The element information item must be valid with respect to the actual type definition as defined by Element Locally Valid (Type) (3.3.4).
3062 Object actualValue = elementLocallyValidType(element, fBuffer);
3063 // 5.2.2 If there is a fixed {value constraint} and clause 3.2 has not applied, all of the following must be true:
3064 if (fCurrentElemDecl != null
3065 && fCurrentElemDecl.getConstraintType() == XSConstants.VC_FIXED
3066 && !fNil) {
3067 String content = fBuffer.toString();
3068 // 5.2.2.1 The element information item must have no element information item [children].
3069 if (fSubElement)
3070 reportSchemaError("cvc-elt.5.2.2.1", new Object[] { element.rawname });
3071 // 5.2.2.2 The appropriate case among the following must be true:
3072 if (fCurrentType.getTypeCategory() == XSTypeDefinition.COMPLEX_TYPE) {
3073 XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType;
3074 // 5.2.2.2.1 If the {content type} of the actual type definition is mixed, then the initial value of the item must match the canonical lexical representation of the {value constraint} value.
3075 if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_MIXED) {
3076 // REVISIT: how to get the initial value, does whiteSpace count?
3077 if (!fCurrentElemDecl.fDefault.normalizedValue.equals(content))
3078 reportSchemaError(
3079 "cvc-elt.5.2.2.2.1",
3080 new Object[] {
3081 element.rawname,
3082 content,
3083 fCurrentElemDecl.fDefault.normalizedValue });
3084 }
3085 // 5.2.2.2.2 If the {content type} of the actual type definition is a simple type definition, then the actual value of the item must match the canonical lexical representation of the {value constraint} value.
3086 else if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_SIMPLE) {
3087 if (actualValue != null && (!isComparable(fValidatedInfo, fCurrentElemDecl.fDefault)
3088 || !actualValue.equals(fCurrentElemDecl.fDefault.actualValue))) {
3089 reportSchemaError(
3090 "cvc-elt.5.2.2.2.2",
3091 new Object[] {
3092 element.rawname,
3093 content,
3094 fCurrentElemDecl.fDefault.stringValue()});
3095 }
3096 }
3097 } else if (fCurrentType.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE) {
3098 if (actualValue != null && (!isComparable(fValidatedInfo, fCurrentElemDecl.fDefault)
3099 || !actualValue.equals(fCurrentElemDecl.fDefault.actualValue))) {
3100 // REVISIT: the spec didn't mention this case: fixed
3101 // value with simple type
3102 reportSchemaError(
3103 "cvc-elt.5.2.2.2.2",
3104 new Object[] {
3105 element.rawname,
3106 content,
3107 fCurrentElemDecl.fDefault.stringValue()});
3108 }
3109 }
3110 }
3111 }
3112
3113 if (fDefaultValue == null && fNormalizeData && fDocumentHandler != null && fUnionType) {
3114 // for union types we need to send data because we delayed sending
3115 // this data when we received it in the characters() call.
3116 String content = fValidatedInfo.normalizedValue;
3117 if (content == null)
3118 content = fBuffer.toString();
3119
3120 int bufLen = content.length();
3121 if (fNormalizedStr.ch == null || fNormalizedStr.ch.length < bufLen) {
3122 fNormalizedStr.ch = new char[bufLen];
3123 }
3124 content.getChars(0, bufLen, fNormalizedStr.ch, 0);
3125 fNormalizedStr.offset = 0;
3126 fNormalizedStr.length = bufLen;
3127 fDocumentHandler.characters(fNormalizedStr, null);
3128 }
3129 } // processElementContent
3130
3131 Object elementLocallyValidType(QName element, Object textContent) {
3132 if (fCurrentType == null)
3133 return null;
3134
3135 Object retValue = null;
3136 // Element Locally Valid (Type)
3137 // 3 The appropriate case among the following must be true:
3138 // 3.1 If the type definition is a simple type definition, then all of the following must be true:
3139 if (fCurrentType.getTypeCategory() == XSTypeDefinition.SIMPLE_TYPE) {
3140 // 3.1.2 The element information item must have no element information item [children].
3141 if (fSubElement)
3142 reportSchemaError("cvc-type.3.1.2", new Object[] { element.rawname });
3143 // 3.1.3 If clause 3.2 of Element Locally Valid (Element) (3.3.4) did not apply, then the normalized value must be valid with respect to the type definition as defined by String Valid (3.14.4).
3144 if (!fNil) {
3145 XSSimpleType dv = (XSSimpleType) fCurrentType;
3146 try {
3147 if (!fNormalizeData || fUnionType) {
3148 fValidationState.setNormalizationRequired(true);
3149 }
3150 retValue = dv.validate(textContent, fValidationState, fValidatedInfo);
3151 } catch (InvalidDatatypeValueException e) {
3152 reportSchemaError(e.getKey(), e.getArgs());
3153 reportSchemaError(
3154 "cvc-type.3.1.3",
3155 new Object[] { element.rawname, textContent });
3156 }
3157 }
3158 } else {
3159 // 3.2 If the type definition is a complex type definition, then the element information item must be valid with respect to the type definition as per Element Locally Valid (Complex Type) (3.4.4);
3160 retValue = elementLocallyValidComplexType(element, textContent);
3161 }
3162
3163 return retValue;
3164 } // elementLocallyValidType
3165
3166 Object elementLocallyValidComplexType(QName element, Object textContent) {
3167 Object actualValue = null;
3168 XSComplexTypeDecl ctype = (XSComplexTypeDecl) fCurrentType;
3169
3170 // Element Locally Valid (Complex Type)
3171 // For an element information item to be locally valid with respect to a complex type definition all of the following must be true:
3172 // 1 {abstract} is false.
3173 // 2 If clause 3.2 of Element Locally Valid (Element) (3.3.4) did not apply, then the appropriate case among the following must be true:
3174 if (!fNil) {
3175 // 2.1 If the {content type} is empty, then the element information item has no character or element information item [children].
3176 if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_EMPTY
3177 && (fSubElement || fSawText)) {
3178 reportSchemaError("cvc-complex-type.2.1", new Object[] { element.rawname });
3179 }
3180 // 2.2 If the {content type} is a simple type definition, then the element information item has no element information item [children], and the normalized value of the element information item is valid with respect to that simple type definition as defined by String Valid (3.14.4).
3181 else if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_SIMPLE) {
3182 if (fSubElement)
3183 reportSchemaError("cvc-complex-type.2.2", new Object[] { element.rawname });
3184 XSSimpleType dv = ctype.fXSSimpleType;
3185 try {
3186 if (!fNormalizeData || fUnionType) {
3187 fValidationState.setNormalizationRequired(true);
3188 }
3189 actualValue = dv.validate(textContent, fValidationState, fValidatedInfo);
3190 } catch (InvalidDatatypeValueException e) {
3191 reportSchemaError(e.getKey(), e.getArgs());
3192 reportSchemaError("cvc-complex-type.2.2", new Object[] { element.rawname });
3193 }
3194 // REVISIT: eventually, this method should return the same actualValue as elementLocallyValidType...
3195 // obviously it'll return null when the content is complex.
3196 }
3197 // 2.3 If the {content type} is element-only, then the element information item has no character information item [children] other than those whose [character code] is defined as a white space in [XML 1.0 (Second Edition)].
3198 else if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_ELEMENT) {
3199 if (fSawCharacters) {
3200 reportSchemaError("cvc-complex-type.2.3", new Object[] { element.rawname });
3201 }
3202 }
3203 // 2.4 If the {content type} is element-only or mixed, then the sequence of the element information item's element information item [children], if any, taken in order, is valid with respect to the {content type}'s particle, as defined in Element Sequence Locally Valid (Particle) (3.9.4).
3204 if (ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_ELEMENT
3205 || ctype.fContentType == XSComplexTypeDecl.CONTENTTYPE_MIXED) {
3206 // if the current state is a valid state, check whether
3207 // it's one of the final states.
3208 if (DEBUG) {
3209 System.out.println(fCurrCMState);
3210 }
3211 if (fCurrCMState[0] >= 0 && !fCurrentCM.endContentModel(fCurrCMState)) {
3212 String expected = expectedStr(fCurrentCM.whatCanGoHere(fCurrCMState));
3213 reportSchemaError(
3214 "cvc-complex-type.2.4.b",
3215 new Object[] { element.rawname, expected });
3216 } else {
3217 // Constant space algorithm for a{n,m} for n > 1 and m <= unbounded
3218 // After the DFA has completed, check minOccurs and maxOccurs
3219 // for all elements and wildcards in this content model where
3220 // a{n,m} is subsumed to a* or a+
3221 ArrayList errors = fCurrentCM.checkMinMaxBounds();
3222 if (errors != null) {
3223 for (int i = 0; i < errors.size(); i += 2) {
3224 reportSchemaError(
3225 (String) errors.get(i),
3226 new Object[] { element.rawname, errors.get(i + 1) });
3227 }
3228 }
3229 }
3230 }
3231 }
3232 return actualValue;
3233 } // elementLocallyValidComplexType
3234
3235 void reportSchemaError(String key, Object[] arguments) {
3236 if (fDoValidation)
3237 fXSIErrorReporter.reportError(
3238 XSMessageFormatter.SCHEMA_DOMAIN,
3239 key,
3240 arguments,
3241 XMLErrorReporter.SEVERITY_ERROR);
3242 }
3243
3244 /** Returns true if the two ValidatedInfo objects can be compared in the same value space. **/
3245 private boolean isComparable(ValidatedInfo info1, ValidatedInfo info2) {
3246 final short primitiveType1 = convertToPrimitiveKind(info1.actualValueType);
3247 final short primitiveType2 = convertToPrimitiveKind(info2.actualValueType);
3248 if (primitiveType1 != primitiveType2) {
3249 return (primitiveType1 == XSConstants.ANYSIMPLETYPE_DT && primitiveType2 == XSConstants.STRING_DT ||
3250 primitiveType1 == XSConstants.STRING_DT && primitiveType2 == XSConstants.ANYSIMPLETYPE_DT);
3251 }
3252 else if (primitiveType1 == XSConstants.LIST_DT || primitiveType1 == XSConstants.LISTOFUNION_DT) {
3253 final ShortList typeList1 = info1.itemValueTypes;
3254 final ShortList typeList2 = info2.itemValueTypes;
3255 final int typeList1Length = typeList1 != null ? typeList1.getLength() : 0;
3256 final int typeList2Length = typeList2 != null ? typeList2.getLength() : 0;
3257 if (typeList1Length != typeList2Length) {
3258 return false;
3259 }
3260 for (int i = 0; i < typeList1Length; ++i) {
3261 final short primitiveItem1 = convertToPrimitiveKind(typeList1.item(i));
3262 final short primitiveItem2 = convertToPrimitiveKind(typeList2.item(i));
3263 if (primitiveItem1 != primitiveItem2) {
3264 if (primitiveItem1 == XSConstants.ANYSIMPLETYPE_DT && primitiveItem2 == XSConstants.STRING_DT ||
3265 primitiveItem1 == XSConstants.STRING_DT && primitiveItem2 == XSConstants.ANYSIMPLETYPE_DT) {
3266 continue;
3267 }
3268 return false;
3269 }
3270 }
3271 }
3272 return true;
3273 }
3274
3275 private short convertToPrimitiveKind(short valueType) {
3276 /** Primitive datatypes. */
3277 if (valueType <= XSConstants.NOTATION_DT) {
3278 return valueType;
3279 }
3280 /** Types derived from string. */
3281 if (valueType <= XSConstants.ENTITY_DT) {
3282 return XSConstants.STRING_DT;
3283 }
3284 /** Types derived from decimal. */
3285 if (valueType <= XSConstants.POSITIVEINTEGER_DT) {
3286 return XSConstants.DECIMAL_DT;
3287 }
3288 /** Other types. */
3289 return valueType;
3290 }
3291
3292 private String expectedStr(Vector expected) {
3293 StringBuffer ret = new StringBuffer("{");
3294 int size = expected.size();
3295 for (int i = 0; i < size; i++) {
3296 if (i > 0)
3297 ret.append(", ");
3298 ret.append(expected.elementAt(i).toString());
3299 }
3300 ret.append('}');
3301 return ret.toString();
3302 }
3303
3304 /**********************************/
3305
3306 // xpath matcher information
3307
3308 /**
3309 * Stack of XPath matchers for identity constraints.
3310 *
3311 * @author Andy Clark, IBM
3312 */
3313 protected static class XPathMatcherStack {
3314
3315 //
3316 // Data
3317 //
3318
3319 /** Active matchers. */
3320 protected XPathMatcher[] fMatchers = new XPathMatcher[4];
3321
3322 /** Count of active matchers. */
3323 protected int fMatchersCount;
3324
3325 /** Offset stack for contexts. */
3326 protected IntStack fContextStack = new IntStack();
3327
3328 //
3329 // Constructors
3330 //
3331
3332 public XPathMatcherStack() {
3333 } // <init>()
3334
3335 //
3336 // Public methods
3337 //
3338
3339 /** Resets the XPath matcher stack. */
3340 public void clear() {
3341 for (int i = 0; i < fMatchersCount; i++) {
3342 fMatchers[i] = null;
3343 }
3344 fMatchersCount = 0;
3345 fContextStack.clear();
3346 } // clear()
3347
3348 /** Returns the size of the stack. */
3349 public int size() {
3350 return fContextStack.size();
3351 } // size():int
3352
3353 /** Returns the count of XPath matchers. */
3354 public int getMatcherCount() {
3355 return fMatchersCount;
3356 } // getMatcherCount():int
3357
3358 /** Adds a matcher. */
3359 public void addMatcher(XPathMatcher matcher) {
3360 ensureMatcherCapacity();
3361 fMatchers[fMatchersCount++] = matcher;
3362 } // addMatcher(XPathMatcher)
3363
3364 /** Returns the XPath matcher at the specified index. */
3365 public XPathMatcher getMatcherAt(int index) {
3366 return fMatchers[index];
3367 } // getMatcherAt(index):XPathMatcher
3368
3369 /** Pushes a new context onto the stack. */
3370 public void pushContext() {
3371 fContextStack.push(fMatchersCount);
3372 } // pushContext()
3373
3374 /** Pops a context off of the stack. */
3375 public void popContext() {
3376 fMatchersCount = fContextStack.pop();
3377 } // popContext()
3378
3379 //
3380 // Private methods
3381 //
3382
3383 /** Ensures the size of the matchers array. */
3384 private void ensureMatcherCapacity() {
3385 if (fMatchersCount == fMatchers.length) {
3386 XPathMatcher[] array = new XPathMatcher[fMatchers.length * 2];
3387 System.arraycopy(fMatchers, 0, array, 0, fMatchers.length);
3388 fMatchers = array;
3389 }
3390 } // ensureMatcherCapacity()
3391
3392 } // class XPathMatcherStack
3393
3394 // value store implementations
3395
3396 /**
3397 * Value store implementation base class. There are specific subclasses
3398 * for handling unique, key, and keyref.
3399 *
3400 * @author Andy Clark, IBM
3401 */
3402 protected abstract class ValueStoreBase implements ValueStore {
3403
3404 //
3405 // Data
3406 //
3407
3408 /** Identity constraint. */
3409 protected IdentityConstraint fIdentityConstraint;
3410 protected int fFieldCount = 0;
3411 protected Field[] fFields = null;
3412 /** current data */
3413 protected Object[] fLocalValues = null;
3414 protected short[] fLocalValueTypes = null;
3415 protected ShortList[] fLocalItemValueTypes = null;
3416
3417 /** Current data value count. */
3418 protected int fValuesCount;
3419
3420 /** global data */
3421 public final Vector fValues = new Vector();
3422 public ShortVector fValueTypes = null;
3423 public Vector fItemValueTypes = null;
3424
3425 private boolean fUseValueTypeVector = false;
3426 private int fValueTypesLength = 0;
3427 private short fValueType = 0;
3428
3429 private boolean fUseItemValueTypeVector = false;
3430 private int fItemValueTypesLength = 0;
3431 private ShortList fItemValueType = null;
3432
3433 /** buffer for error messages */
3434 final StringBuffer fTempBuffer = new StringBuffer();
3435
3436 //
3437 // Constructors
3438 //
3439
3440 /** Constructs a value store for the specified identity constraint. */
3441 protected ValueStoreBase(IdentityConstraint identityConstraint) {
3442 fIdentityConstraint = identityConstraint;
3443 fFieldCount = fIdentityConstraint.getFieldCount();
3444 fFields = new Field[fFieldCount];
3445 fLocalValues = new Object[fFieldCount];
3446 fLocalValueTypes = new short[fFieldCount];
3447 fLocalItemValueTypes = new ShortList[fFieldCount];
3448 for (int i = 0; i < fFieldCount; i++) {
3449 fFields[i] = fIdentityConstraint.getFieldAt(i);
3450 }
3451 } // <init>(IdentityConstraint)
3452
3453 //
3454 // Public methods
3455 //
3456
3457 // destroys this ValueStore; useful when, for instance, a
3458 // locally-scoped ID constraint is involved.
3459 public void clear() {
3460 fValuesCount = 0;
3461 fUseValueTypeVector = false;
3462 fValueTypesLength = 0;
3463 fValueType = 0;
3464 fUseItemValueTypeVector = false;
3465 fItemValueTypesLength = 0;
3466 fItemValueType = null;
3467 fValues.setSize(0);
3468 if (fValueTypes != null) {
3469 fValueTypes.clear();
3470 }
3471 if (fItemValueTypes != null) {
3472 fItemValueTypes.setSize(0);
3473 }
3474 } // end clear():void
3475
3476 // appends the contents of one ValueStore to those of us.
3477 public void append(ValueStoreBase newVal) {
3478 for (int i = 0; i < newVal.fValues.size(); i++) {
3479 fValues.addElement(newVal.fValues.elementAt(i));
3480 }
3481 } // append(ValueStoreBase)
3482
3483 /** Start scope for value store. */
3484 public void startValueScope() {
3485 fValuesCount = 0;
3486 for (int i = 0; i < fFieldCount; i++) {
3487 fLocalValues[i] = null;
3488 fLocalValueTypes[i] = 0;
3489 fLocalItemValueTypes[i] = null;
3490 }
3491 } // startValueScope()
3492
3493 /** Ends scope for value store. */
3494 public void endValueScope() {
3495
3496 if (fValuesCount == 0) {
3497 if (fIdentityConstraint.getCategory() == IdentityConstraint.IC_KEY) {
3498 String code = "AbsentKeyValue";
3499 String eName = fIdentityConstraint.getElementName();
3500 String cName = fIdentityConstraint.getIdentityConstraintName();
3501 reportSchemaError(code, new Object[] { eName, cName });
3502 }
3503 return;
3504 }
3505
3506 // Validation Rule: Identity-constraint Satisfied
3507 // 4.2 If the {identity-constraint category} is key, then all of the following must be true:
3508 // 4.2.1 The target node set and the qualified node set are equal, that is, every member of the
3509 // target node set is also a member of the qualified node set and vice versa.
3510 //
3511 // If the IDC is a key check whether we have all the fields.
3512 if (fValuesCount != fFieldCount) {
3513 if (fIdentityConstraint.getCategory() == IdentityConstraint.IC_KEY) {
3514 String code = "KeyNotEnoughValues";
3515 UniqueOrKey key = (UniqueOrKey) fIdentityConstraint;
3516 String eName = fIdentityConstraint.getElementName();
3517 String cName = key.getIdentityConstraintName();
3518 reportSchemaError(code, new Object[] { eName, cName });
3519 }
3520 return;
3521 }
3522
3523 } // endValueScope()
3524
3525 // This is needed to allow keyref's to look for matched keys
3526 // in the correct scope. Unique and Key may also need to
3527 // override this method for purposes of their own.
3528 // This method is called whenever the DocumentFragment
3529 // of an ID Constraint goes out of scope.
3530 public void endDocumentFragment() {
3531 } // endDocumentFragment():void
3532
3533 /**
3534 * Signals the end of the document. This is where the specific
3535 * instances of value stores can verify the integrity of the
3536 * identity constraints.
3537 */
3538 public void endDocument() {
3539 } // endDocument()
3540
3541 //
3542 // ValueStore methods
3543 //
3544
3545 /* reports an error if an element is matched
3546 * has nillable true and is matched by a key.
3547 */
3548
3549 public void reportError(String key, Object[] args) {
3550 reportSchemaError(key, args);
3551 } // reportError(String,Object[])
3552
3553 /**
3554 * Adds the specified value to the value store.
3555 *
3556 * @param field The field associated to the value. This reference
3557 * is used to ensure that each field only adds a value
3558 * once within a selection scope.
3559 * @param actualValue The value to add.
3560 */
3561 public void addValue(Field field, Object actualValue, short valueType, ShortList itemValueType) {
3562 int i;
3563 for (i = fFieldCount - 1; i > -1; i--) {
3564 if (fFields[i] == field) {
3565 break;
3566 }
3567 }
3568 // do we even know this field?
3569 if (i == -1) {
3570 String code = "UnknownField";
3571 String eName = fIdentityConstraint.getElementName();
3572 String cName = fIdentityConstraint.getIdentityConstraintName();
3573 reportSchemaError(code, new Object[] { field.toString(), eName, cName });
3574 return;
3575 }
3576 if (Boolean.TRUE != mayMatch(field)) {
3577 String code = "FieldMultipleMatch";
3578 String cName = fIdentityConstraint.getIdentityConstraintName();
3579 reportSchemaError(code, new Object[] { field.toString(), cName });
3580 } else {
3581 fValuesCount++;
3582 }
3583 fLocalValues[i] = actualValue;
3584 fLocalValueTypes[i] = valueType;
3585 fLocalItemValueTypes[i] = itemValueType;
3586 if (fValuesCount == fFieldCount) {
3587 checkDuplicateValues();
3588 // store values
3589 for (i = 0; i < fFieldCount; i++) {
3590 fValues.addElement(fLocalValues[i]);
3591 addValueType(fLocalValueTypes[i]);
3592 addItemValueType(fLocalItemValueTypes[i]);
3593 }
3594 }
3595 } // addValue(String,Field)
3596
3597 /**
3598 * Returns true if this value store contains the locally scoped value stores
3599 */
3600 public boolean contains() {
3601 // REVISIT: we can improve performance by using hash codes, instead of
3602 // traversing global vector that could be quite large.
3603 int next = 0;
3604 final int size = fValues.size();
3605 LOOP : for (int i = 0; i < size; i = next) {
3606 next = i + fFieldCount;
3607 for (int j = 0; j < fFieldCount; j++) {
3608 Object value1 = fLocalValues[j];
3609 Object value2 = fValues.elementAt(i);
3610 short valueType1 = fLocalValueTypes[j];
3611 short valueType2 = getValueTypeAt(i);
3612 if (value1 == null || value2 == null || valueType1 != valueType2 || !(value1.equals(value2))) {
3613 continue LOOP;
3614 }
3615 else if(valueType1 == XSConstants.LIST_DT || valueType1 == XSConstants.LISTOFUNION_DT) {
3616 ShortList list1 = fLocalItemValueTypes[j];
3617 ShortList list2 = getItemValueTypeAt(i);
3618 if(list1 == null || list2 == null || !list1.equals(list2))
3619 continue LOOP;
3620 }
3621 i++;
3622 }
3623 // found it
3624 return true;
3625 }
3626 // didn't find it
3627 return false;
3628 } // contains():boolean
3629
3630 /**
3631 * Returns -1 if this value store contains the specified
3632 * values, otherwise the index of the first field in the
3633 * key sequence.
3634 */
3635 public int contains(ValueStoreBase vsb) {
3636
3637 final Vector values = vsb.fValues;
3638 final int size1 = values.size();
3639 if (fFieldCount <= 1) {
3640 for (int i = 0; i < size1; ++i) {
3641 short val = vsb.getValueTypeAt(i);
3642 if (!valueTypeContains(val) || !fValues.contains(values.elementAt(i))) {
3643 return i;
3644 }
3645 else if(val == XSConstants.LIST_DT || val == XSConstants.LISTOFUNION_DT) {
3646 ShortList list1 = vsb.getItemValueTypeAt(i);
3647 if (!itemValueTypeContains(list1)) {
3648 return i;
3649 }
3650 }
3651 }
3652 }
3653 /** Handle n-tuples. **/
3654 else {
3655 final int size2 = fValues.size();
3656 /** Iterate over each set of fields. **/
3657 OUTER: for (int i = 0; i < size1; i += fFieldCount) {
3658 /** Check whether this set is contained in the value store. **/
3659 INNER: for (int j = 0; j < size2; j += fFieldCount) {
3660 for (int k = 0; k < fFieldCount; ++k) {
3661 final Object value1 = values.elementAt(i+k);
3662 final Object value2 = fValues.elementAt(j+k);
3663 final short valueType1 = vsb.getValueTypeAt(i+k);
3664 final short valueType2 = getValueTypeAt(j+k);
3665 if (value1 != value2 && (valueType1 != valueType2 || value1 == null || !value1.equals(value2))) {
3666 continue INNER;
3667 }
3668 else if(valueType1 == XSConstants.LIST_DT || valueType1 == XSConstants.LISTOFUNION_DT) {
3669 ShortList list1 = vsb.getItemValueTypeAt(i+k);
3670 ShortList list2 = getItemValueTypeAt(j+k);
3671 if (list1 == null || list2 == null || !list1.equals(list2)) {
3672 continue INNER;
3673 }
3674 }
3675 }
3676 continue OUTER;
3677 }
3678 return i;
3679 }
3680 }
3681 return -1;
3682
3683 } // contains(Vector):Object
3684
3685 //
3686 // Protected methods
3687 //
3688
3689 protected void checkDuplicateValues() {
3690 // no-op
3691 } // duplicateValue(Hashtable)
3692
3693 /** Returns a string of the specified values. */
3694 protected String toString(Object[] values) {
3695
3696 // no values
3697 int size = values.length;
3698 if (size == 0) {
3699 return "";
3700 }
3701
3702 fTempBuffer.setLength(0);
3703
3704 // construct value string
3705 for (int i = 0; i < size; i++) {
3706 if (i > 0) {
3707 fTempBuffer.append(',');
3708 }
3709 fTempBuffer.append(values[i]);
3710 }
3711 return fTempBuffer.toString();
3712
3713 } // toString(Object[]):String
3714
3715 /** Returns a string of the specified values. */
3716 protected String toString(Vector values, int start, int length) {
3717
3718 // no values
3719 if (length == 0) {
3720 return "";
3721 }
3722
3723 // one value
3724 if (length == 1) {
3725 return String.valueOf(values.elementAt(start));
3726 }
3727
3728 // construct value string
3729 StringBuffer str = new StringBuffer();
3730 for (int i = 0; i < length; i++) {
3731 if (i > 0) {
3732 str.append(',');
3733 }
3734 str.append(values.elementAt(start + i));
3735 }
3736 return str.toString();
3737
3738 } // toString(Vector,int,int):String
3739
3740 //
3741 // Object methods
3742 //
3743
3744 /** Returns a string representation of this object. */
3745 public String toString() {
3746 String s = super.toString();
3747 int index1 = s.lastIndexOf('$');
3748 if (index1 != -1) {
3749 s = s.substring(index1 + 1);
3750 }
3751 int index2 = s.lastIndexOf('.');
3752 if (index2 != -1) {
3753 s = s.substring(index2 + 1);
3754 }
3755 return s + '[' + fIdentityConstraint + ']';
3756 } // toString():String
3757
3758 //
3759 // Private methods
3760 //
3761
3762 private void addValueType(short type) {
3763 if (fUseValueTypeVector) {
3764 fValueTypes.add(type);
3765 }
3766 else if (fValueTypesLength++ == 0) {
3767 fValueType = type;
3768 }
3769 else if (fValueType != type) {
3770 fUseValueTypeVector = true;
3771 if (fValueTypes == null) {
3772 fValueTypes = new ShortVector(fValueTypesLength * 2);
3773 }
3774 for (int i = 1; i < fValueTypesLength; ++i) {
3775 fValueTypes.add(fValueType);
3776 }
3777 fValueTypes.add(type);
3778 }
3779 }
3780
3781 private short getValueTypeAt(int index) {
3782 if (fUseValueTypeVector) {
3783 return fValueTypes.valueAt(index);
3784 }
3785 return fValueType;
3786 }
3787
3788 private boolean valueTypeContains(short value) {
3789 if (fUseValueTypeVector) {
3790 return fValueTypes.contains(value);
3791 }
3792 return fValueType == value;
3793 }
3794
3795 private void addItemValueType(ShortList itemValueType) {
3796 if (fUseItemValueTypeVector) {
3797 fItemValueTypes.add(itemValueType);
3798 }
3799 else if (fItemValueTypesLength++ == 0) {
3800 fItemValueType = itemValueType;
3801 }
3802 else if (!(fItemValueType == itemValueType ||
3803 (fItemValueType != null && fItemValueType.equals(itemValueType)))) {
3804 fUseItemValueTypeVector = true;
3805 if (fItemValueTypes == null) {
3806 fItemValueTypes = new Vector(fItemValueTypesLength * 2);
3807 }
3808 for (int i = 1; i < fItemValueTypesLength; ++i) {
3809 fItemValueTypes.add(fItemValueType);
3810 }
3811 fItemValueTypes.add(itemValueType);
3812 }
3813 }
3814
3815 private ShortList getItemValueTypeAt(int index) {
3816 if (fUseItemValueTypeVector) {
3817 return (ShortList) fItemValueTypes.elementAt(index);
3818 }
3819 return fItemValueType;
3820 }
3821
3822 private boolean itemValueTypeContains(ShortList value) {
3823 if (fUseItemValueTypeVector) {
3824 return fItemValueTypes.contains(value);
3825 }
3826 return fItemValueType == value ||
3827 (fItemValueType != null && fItemValueType.equals(value));
3828 }
3829
3830 } // class ValueStoreBase
3831
3832 /**
3833 * Unique value store.
3834 *
3835 * @author Andy Clark, IBM
3836 */
3837 protected class UniqueValueStore extends ValueStoreBase {
3838
3839 //
3840 // Constructors
3841 //
3842
3843 /** Constructs a unique value store. */
3844 public UniqueValueStore(UniqueOrKey unique) {
3845 super(unique);
3846 } // <init>(Unique)
3847
3848 //
3849 // ValueStoreBase protected methods
3850 //
3851
3852 /**
3853 * Called when a duplicate value is added.
3854 */
3855 protected void checkDuplicateValues() {
3856 // is this value as a group duplicated?
3857 if (contains()) {
3858 String code = "DuplicateUnique";
3859 String value = toString(fLocalValues);
3860 String eName = fIdentityConstraint.getElementName();
3861 String cName = fIdentityConstraint.getIdentityConstraintName();
3862 reportSchemaError(code, new Object[] { value, eName, cName });
3863 }
3864 } // duplicateValue(Hashtable)
3865
3866 } // class UniqueValueStore
3867
3868 /**
3869 * Key value store.
3870 *
3871 * @author Andy Clark, IBM
3872 */
3873 protected class KeyValueStore extends ValueStoreBase {
3874
3875 // REVISIT: Implement a more efficient storage mechanism. -Ac
3876
3877 //
3878 // Constructors
3879 //
3880
3881 /** Constructs a key value store. */
3882 public KeyValueStore(UniqueOrKey key) {
3883 super(key);
3884 } // <init>(Key)
3885
3886 //
3887 // ValueStoreBase protected methods
3888 //
3889
3890 /**
3891 * Called when a duplicate value is added.
3892 */
3893 protected void checkDuplicateValues() {
3894 if (contains()) {
3895 String code = "DuplicateKey";
3896 String value = toString(fLocalValues);
3897 String eName = fIdentityConstraint.getElementName();
3898 String cName = fIdentityConstraint.getIdentityConstraintName();
3899 reportSchemaError(code, new Object[] { value, eName, cName });
3900 }
3901 } // duplicateValue(Hashtable)
3902
3903 } // class KeyValueStore
3904
3905 /**
3906 * Key reference value store.
3907 *
3908 * @author Andy Clark, IBM
3909 */
3910 protected class KeyRefValueStore extends ValueStoreBase {
3911
3912 //
3913 // Data
3914 //
3915
3916 /** Key value store. */
3917 protected ValueStoreBase fKeyValueStore;
3918
3919 //
3920 // Constructors
3921 //
3922
3923 /** Constructs a key value store. */
3924 public KeyRefValueStore(KeyRef keyRef, KeyValueStore keyValueStore) {
3925 super(keyRef);
3926 fKeyValueStore = keyValueStore;
3927 } // <init>(KeyRef)
3928
3929 //
3930 // ValueStoreBase methods
3931 //
3932
3933 // end the value Scope; here's where we have to tie
3934 // up keyRef loose ends.
3935 public void endDocumentFragment() {
3936
3937 // do all the necessary management...
3938 super.endDocumentFragment();
3939
3940 // verify references
3941 // get the key store corresponding (if it exists):
3942 fKeyValueStore =
3943 (ValueStoreBase) fValueStoreCache.fGlobalIDConstraintMap.get(
3944 ((KeyRef) fIdentityConstraint).getKey());
3945
3946 if (fKeyValueStore == null) {
3947 // report error
3948 String code = "KeyRefOutOfScope";
3949 String value = fIdentityConstraint.toString();
3950 reportSchemaError(code, new Object[] { value });
3951 return;
3952 }
3953 int errorIndex = fKeyValueStore.contains(this);
3954 if (errorIndex != -1) {
3955 String code = "KeyNotFound";
3956 String values = toString(fValues, errorIndex, fFieldCount);
3957 String element = fIdentityConstraint.getElementName();
3958 String name = fIdentityConstraint.getName();
3959 reportSchemaError(code, new Object[] { name, values, element });
3960 }
3961
3962 } // endDocumentFragment()
3963
3964 /** End document. */
3965 public void endDocument() {
3966 super.endDocument();
3967
3968 } // endDocument()
3969
3970 } // class KeyRefValueStore
3971
3972 // value store management
3973
3974 /**
3975 * Value store cache. This class is used to store the values for
3976 * identity constraints.
3977 *
3978 * @author Andy Clark, IBM
3979 */
3980 protected class ValueStoreCache {
3981
3982 //
3983 // Data
3984 //
3985 final LocalIDKey fLocalId = new LocalIDKey();
3986 // values stores
3987
3988 /** stores all global Values stores. */
3989 protected final Vector fValueStores = new Vector();
3990
3991 /**
3992 * Values stores associated to specific identity constraints.
3993 * This hashtable maps IdentityConstraints and
3994 * the 0-based element on which their selectors first matched to
3995 * a corresponding ValueStore. This should take care
3996 * of all cases, including where ID constraints with
3997 * descendant-or-self axes occur on recursively-defined
3998 * elements.
3999 */
4000 protected final Hashtable fIdentityConstraint2ValueStoreMap = new Hashtable();
4001
4002 // sketch of algorithm:
4003 // - when a constraint is first encountered, its
4004 // values are stored in the (local) fIdentityConstraint2ValueStoreMap;
4005 // - Once it is validated (i.e., when it goes out of scope),
4006 // its values are merged into the fGlobalIDConstraintMap;
4007 // - as we encounter keyref's, we look at the global table to
4008 // validate them.
4009 //
4010 // The fGlobalIDMapStack has the following structure:
4011 // - validation always occurs against the fGlobalIDConstraintMap
4012 // (which comprises all the "eligible" id constraints);
4013 // When an endElement is found, this Hashtable is merged with the one
4014 // below in the stack.
4015 // When a start tag is encountered, we create a new
4016 // fGlobalIDConstraintMap.
4017 // i.e., the top of the fGlobalIDMapStack always contains
4018 // the preceding siblings' eligible id constraints;
4019 // the fGlobalIDConstraintMap contains descendants+self.
4020 // keyrefs can only match descendants+self.
4021 protected final Stack fGlobalMapStack = new Stack();
4022 protected final Hashtable fGlobalIDConstraintMap = new Hashtable();
4023
4024 //
4025 // Constructors
4026 //
4027
4028 /** Default constructor. */
4029 public ValueStoreCache() {
4030 } // <init>()
4031
4032 //
4033 // Public methods
4034 //
4035
4036 /** Resets the identity constraint cache. */
4037 public void startDocument() {
4038 fValueStores.removeAllElements();
4039 fIdentityConstraint2ValueStoreMap.clear();
4040 fGlobalIDConstraintMap.clear();
4041 fGlobalMapStack.removeAllElements();
4042 } // startDocument()
4043
4044 // startElement: pushes the current fGlobalIDConstraintMap
4045 // onto fGlobalMapStack and clears fGlobalIDConstraint map.
4046 public void startElement() {
4047 // only clone the hashtable when there are elements
4048 if (fGlobalIDConstraintMap.size() > 0)
4049 fGlobalMapStack.push(fGlobalIDConstraintMap.clone());
4050 else
4051 fGlobalMapStack.push(null);
4052 fGlobalIDConstraintMap.clear();
4053 } // startElement(void)
4054
4055 /** endElement(): merges contents of fGlobalIDConstraintMap with the
4056 * top of fGlobalMapStack into fGlobalIDConstraintMap.
4057 */
4058 public void endElement() {
4059 if (fGlobalMapStack.isEmpty()) {
4060 return; // must be an invalid doc!
4061 }
4062 Hashtable oldMap = (Hashtable) fGlobalMapStack.pop();
4063 // return if there is no element
4064 if (oldMap == null) {
4065 return;
4066 }
4067
4068 Iterator entries = oldMap.entrySet().iterator();
4069 while (entries.hasNext()) {
4070 Map.Entry entry = (Map.Entry) entries.next();
4071 IdentityConstraint id = (IdentityConstraint) entry.getKey();
4072 ValueStoreBase oldVal = (ValueStoreBase) entry.getValue();
4073 if (oldVal != null) {
4074 ValueStoreBase currVal = (ValueStoreBase) fGlobalIDConstraintMap.get(id);
4075 if (currVal == null) {
4076 fGlobalIDConstraintMap.put(id, oldVal);
4077 }
4078 else if (currVal != oldVal) {
4079 currVal.append(oldVal);
4080 }
4081 }
4082 }
4083 } // endElement()
4084
4085 /**
4086 * Initializes the value stores for the specified element
4087 * declaration.
4088 */
4089 public void initValueStoresFor(XSElementDecl eDecl, FieldActivator activator) {
4090 // initialize value stores for unique fields
4091 IdentityConstraint[] icArray = eDecl.fIDConstraints;
4092 int icCount = eDecl.fIDCPos;
4093 for (int i = 0; i < icCount; i++) {
4094 switch (icArray[i].getCategory()) {
4095 case (IdentityConstraint.IC_UNIQUE) :
4096 // initialize value stores for unique fields
4097 UniqueOrKey unique = (UniqueOrKey) icArray[i];
4098 LocalIDKey toHash = new LocalIDKey(unique, fElementDepth);
4099 UniqueValueStore uniqueValueStore =
4100 (UniqueValueStore) fIdentityConstraint2ValueStoreMap.get(toHash);
4101 if (uniqueValueStore == null) {
4102 uniqueValueStore = new UniqueValueStore(unique);
4103 fIdentityConstraint2ValueStoreMap.put(toHash, uniqueValueStore);
4104 } else {
4105 uniqueValueStore.clear();
4106 }
4107 fValueStores.addElement(uniqueValueStore);
4108 activateSelectorFor(icArray[i]);
4109 break;
4110 case (IdentityConstraint.IC_KEY) :
4111 // initialize value stores for key fields
4112 UniqueOrKey key = (UniqueOrKey) icArray[i];
4113 toHash = new LocalIDKey(key, fElementDepth);
4114 KeyValueStore keyValueStore =
4115 (KeyValueStore) fIdentityConstraint2ValueStoreMap.get(toHash);
4116 if (keyValueStore == null) {
4117 keyValueStore = new KeyValueStore(key);
4118 fIdentityConstraint2ValueStoreMap.put(toHash, keyValueStore);
4119 } else {
4120 keyValueStore.clear();
4121 }
4122 fValueStores.addElement(keyValueStore);
4123 activateSelectorFor(icArray[i]);
4124 break;
4125 case (IdentityConstraint.IC_KEYREF) :
4126 // initialize value stores for keyRef fields
4127 KeyRef keyRef = (KeyRef) icArray[i];
4128 toHash = new LocalIDKey(keyRef, fElementDepth);
4129 KeyRefValueStore keyRefValueStore =
4130 (KeyRefValueStore) fIdentityConstraint2ValueStoreMap.get(toHash);
4131 if (keyRefValueStore == null) {
4132 keyRefValueStore = new KeyRefValueStore(keyRef, null);
4133 fIdentityConstraint2ValueStoreMap.put(toHash, keyRefValueStore);
4134 } else {
4135 keyRefValueStore.clear();
4136 }
4137 fValueStores.addElement(keyRefValueStore);
4138 activateSelectorFor(icArray[i]);
4139 break;
4140 }
4141 }
4142 } // initValueStoresFor(XSElementDecl)
4143
4144 /** Returns the value store associated to the specified IdentityConstraint. */
4145 public ValueStoreBase getValueStoreFor(IdentityConstraint id, int initialDepth) {
4146 fLocalId.fDepth = initialDepth;
4147 fLocalId.fId = id;
4148 return (ValueStoreBase) fIdentityConstraint2ValueStoreMap.get(fLocalId);
4149 } // getValueStoreFor(IdentityConstraint, int):ValueStoreBase
4150
4151 /** Returns the global value store associated to the specified IdentityConstraint. */
4152 public ValueStoreBase getGlobalValueStoreFor(IdentityConstraint id) {
4153 return (ValueStoreBase) fGlobalIDConstraintMap.get(id);
4154 } // getValueStoreFor(IdentityConstraint):ValueStoreBase
4155
4156 // This method takes the contents of the (local) ValueStore
4157 // associated with id and moves them into the global
4158 // hashtable, if id is a <unique> or a <key>.
4159 // If it's a <keyRef>, then we leave it for later.
4160 public void transplant(IdentityConstraint id, int initialDepth) {
4161 fLocalId.fDepth = initialDepth;
4162 fLocalId.fId = id;
4163 ValueStoreBase newVals =
4164 (ValueStoreBase) fIdentityConstraint2ValueStoreMap.get(fLocalId);
4165 if (id.getCategory() == IdentityConstraint.IC_KEYREF)
4166 return;
4167 ValueStoreBase currVals = (ValueStoreBase) fGlobalIDConstraintMap.get(id);
4168 if (currVals != null) {
4169 currVals.append(newVals);
4170 fGlobalIDConstraintMap.put(id, currVals);
4171 } else
4172 fGlobalIDConstraintMap.put(id, newVals);
4173
4174 } // transplant(id)
4175
4176 /** Check identity constraints. */
4177 public void endDocument() {
4178
4179 int count = fValueStores.size();
4180 for (int i = 0; i < count; i++) {
4181 ValueStoreBase valueStore = (ValueStoreBase) fValueStores.elementAt(i);
4182 valueStore.endDocument();
4183 }
4184
4185 } // endDocument()
4186
4187 //
4188 // Object methods
4189 //
4190
4191 /** Returns a string representation of this object. */
4192 public String toString() {
4193 String s = super.toString();
4194 int index1 = s.lastIndexOf('$');
4195 if (index1 != -1) {
4196 return s.substring(index1 + 1);
4197 }
4198 int index2 = s.lastIndexOf('.');
4199 if (index2 != -1) {
4200 return s.substring(index2 + 1);
4201 }
4202 return s;
4203 } // toString():String
4204
4205 } // class ValueStoreCache
4206
4207 // the purpose of this class is to enable IdentityConstraint,int
4208 // pairs to be used easily as keys in Hashtables.
4209 protected class LocalIDKey {
4210
4211 public IdentityConstraint fId;
4212 public int fDepth;
4213
4214 public LocalIDKey() {
4215 }
4216
4217 public LocalIDKey(IdentityConstraint id, int depth) {
4218 fId = id;
4219 fDepth = depth;
4220 } // init(IdentityConstraint, int)
4221
4222 // object method
4223 public int hashCode() {
4224 return fId.hashCode() + fDepth;
4225 }
4226
4227 public boolean equals(Object localIDKey) {
4228 if (localIDKey instanceof LocalIDKey) {
4229 LocalIDKey lIDKey = (LocalIDKey) localIDKey;
4230 return (lIDKey.fId == fId && lIDKey.fDepth == fDepth);
4231 }
4232 return false;
4233 }
4234 } // class LocalIDKey
4235
4236 /**
4237 * A simple vector for <code>short</code>s.
4238 */
4239 protected static final class ShortVector {
4240
4241 //
4242 // Data
4243 //
4244
4245 /** Current length. */
4246 private int fLength;
4247
4248 /** Data. */
4249 private short[] fData;
4250
4251 //
4252 // Constructors
4253 //
4254
4255 public ShortVector() {}
4256
4257 public ShortVector(int initialCapacity) {
4258 fData = new short[initialCapacity];
4259 }
4260
4261 //
4262 // Public methods
4263 //
4264
4265 /** Returns the length of the vector. */
4266 public int length() {
4267 return fLength;
4268 }
4269
4270 /** Adds the value to the vector. */
4271 public void add(short value) {
4272 ensureCapacity(fLength + 1);
4273 fData[fLength++] = value;
4274 }
4275
4276 /** Returns the short value at the specified position in the vector. */
4277 public short valueAt(int position) {
4278 return fData[position];
4279 }
4280
4281 /** Clears the vector. */
4282 public void clear() {
4283 fLength = 0;
4284 }
4285
4286 /** Returns whether the short is contained in the vector. */
4287 public boolean contains(short value) {
4288 for (int i = 0; i < fLength; ++i) {
4289 if (fData[i] == value) {
4290 return true;
4291 }
4292 }
4293 return false;
4294 }
4295
4296 //
4297 // Private methods
4298 //
4299
4300 /** Ensures capacity. */
4301 private void ensureCapacity(int size) {
4302 if (fData == null) {
4303 fData = new short[8];
4304 }
4305 else if (fData.length <= size) {
4306 short[] newdata = new short[fData.length * 2];
4307 System.arraycopy(fData, 0, newdata, 0, fData.length);
4308 fData = newdata;
4309 }
4310 }
4311 }
4312
4313 } // class SchemaValidator