1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 /*
6 * Copyright 2001-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.opti;
22
23 import java.io.IOException;
24
25 import com.sun.org.apache.xerces.internal.impl.Constants;
26 import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;
27 import com.sun.org.apache.xerces.internal.impl.xs.SchemaSymbols;
28 import com.sun.org.apache.xerces.internal.impl.xs.XSMessageFormatter;
29 import com.sun.org.apache.xerces.internal.util.XMLAttributesImpl;
30 import com.sun.org.apache.xerces.internal.util.XMLChar;
31 import com.sun.org.apache.xerces.internal.xni.Augmentations;
32 import com.sun.org.apache.xerces.internal.xni.NamespaceContext;
33 import com.sun.org.apache.xerces.internal.xni.QName;
34 import com.sun.org.apache.xerces.internal.xni.XMLAttributes;
35 import com.sun.org.apache.xerces.internal.xni.XMLLocator;
36 import com.sun.org.apache.xerces.internal.xni.XMLString;
37 import com.sun.org.apache.xerces.internal.xni.XNIException;
38 import com.sun.org.apache.xerces.internal.xni.parser.XMLEntityResolver;
39 import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;
40 import com.sun.org.apache.xerces.internal.xni.parser.XMLParserConfiguration;
41 import org.w3c.dom.Document;
42
43 /**
44 * @xerces.internal
45 *
46 * @author Rahul Srivastava, Sun Microsystems Inc.
47 * @author Sandy Gao, IBM
48 *
49 * @version $Id: SchemaDOMParser.java,v 1.8 2010-11-01 04:40:01 joehw Exp $
50 */
51 public class SchemaDOMParser extends DefaultXMLDocumentHandler {
52
53 //
54 // Data
55 //
56
57 /** Property identifier: error reporter. */
58 public static final String ERROR_REPORTER =
59 Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;
60
61 /** Feature identifier: generate synthetic annotations. */
62 public static final String GENERATE_SYNTHETIC_ANNOTATION =
63 Constants.XERCES_FEATURE_PREFIX + Constants.GENERATE_SYNTHETIC_ANNOTATIONS_FEATURE;
64
65 // the locator containing line/column information
66 protected XMLLocator fLocator;
67
68 // namespace context, needed for producing
69 // representations of annotations
70 protected NamespaceContext fNamespaceContext = null;
71
72 SchemaDOM schemaDOM;
73
74 XMLParserConfiguration config;
75
76 //
77 // Constructors
78 //
79
80 /** Default constructor. */
81 public SchemaDOMParser(XMLParserConfiguration config) {
82 this.config = config;
83 config.setDocumentHandler(this);
84 config.setDTDHandler(this);
85 config.setDTDContentModelHandler(this);
86 }
87
88 // Reference to the current annotation element.
89 private ElementImpl fCurrentAnnotationElement;
90 // where an annotation element itself begins
91 // -1 means not in an annotation's scope
92 private int fAnnotationDepth = -1;
93 // Where xs:appinfo or xs:documentation starts;
94 // -1 means not in the scope of either of the two elements.
95 private int fInnerAnnotationDepth = -1;
96 // The current element depth
97 private int fDepth = -1;
98 // Use to report the error when characters are not allowed.
99 XMLErrorReporter fErrorReporter;
100
101 // fields for generate-synthetic annotations feature
102 private boolean fGenerateSyntheticAnnotation = false;
103 private BooleanStack fHasNonSchemaAttributes = new BooleanStack();
104 private BooleanStack fSawAnnotation = new BooleanStack();
105 private XMLAttributes fEmptyAttr = new XMLAttributesImpl();
106
107 //
108 // XMLDocumentHandler methods
109 //
110
111 public void startDocument(XMLLocator locator, String encoding,
112 NamespaceContext namespaceContext, Augmentations augs)
113 throws XNIException {
114 fErrorReporter = (XMLErrorReporter)config.getProperty(ERROR_REPORTER);
115 fGenerateSyntheticAnnotation = config.getFeature(GENERATE_SYNTHETIC_ANNOTATION);
116 fHasNonSchemaAttributes.clear();
117 fSawAnnotation.clear();
118 schemaDOM = new SchemaDOM();
119 fCurrentAnnotationElement = null;
120 fAnnotationDepth = -1;
121 fInnerAnnotationDepth = -1;
122 fDepth = -1;
123 fLocator = locator;
124 fNamespaceContext = namespaceContext;
125 schemaDOM.setDocumentURI(locator.getExpandedSystemId());
126 } // startDocument(XMLLocator,String,NamespaceContext, Augmentations)
127
128 /**
129 * The end of the document.
130 * @param augs Additional information that may include infoset augmentations
131 *
132 * @throws XNIException Thrown by handler to signal an error.
133 */
134 public void endDocument(Augmentations augs) throws XNIException {
135 // To debug the DOM created uncomment the line below
136 // schemaDOM.printDOM();
137 } // endDocument()
138
139
140 /**
141 * A comment.
142 *
143 * @param text The text in the comment.
144 * @param augs Additional information that may include infoset augmentations
145 *
146 * @exception XNIException
147 * Thrown by application to signal an error.
148 */
149 public void comment(XMLString text, Augmentations augs) throws XNIException {
150 if(fAnnotationDepth > -1) {
151 schemaDOM.comment(text);
152 }
153 }
154
155 /**
156 * A processing instruction. Processing instructions consist of a
157 * target name and, optionally, text data. The data is only meaningful
158 * to the application.
159 * <p>
160 * Typically, a processing instruction's data will contain a series
161 * of pseudo-attributes. These pseudo-attributes follow the form of
162 * element attributes but are <strong>not</strong> parsed or presented
163 * to the application as anything other than text. The application is
164 * responsible for parsing the data.
165 *
166 * @param target The target.
167 * @param data The data or null if none specified.
168 * @param augs Additional information that may include infoset augmentations
169 *
170 * @exception XNIException
171 * Thrown by handler to signal an error.
172 */
173 public void processingInstruction(String target, XMLString data, Augmentations augs)
174 throws XNIException {
175 if (fAnnotationDepth > -1) {
176 schemaDOM.processingInstruction(target, data);
177 }
178 }
179
180 /**
181 * Character content.
182 *
183 * @param text The content.
184 * @param augs Additional information that may include infoset augmentations
185 *
186 * @exception XNIException
187 * Thrown by handler to signal an error.
188 */
189 public void characters(XMLString text, Augmentations augs) throws XNIException {
190 // when it's not within xs:appinfo or xs:documentation
191 if (fInnerAnnotationDepth == -1 ) {
192 for (int i=text.offset; i<text.offset+text.length; i++) {
193 // and there is a non-whitespace character
194 if (!XMLChar.isSpace(text.ch[i])) {
195 // the string we saw: starting from the first non-whitespace character.
196 String txt = new String(text.ch, i, text.length+text.offset-i);
197 // report an error
198 fErrorReporter.reportError(fLocator,
199 XSMessageFormatter.SCHEMA_DOMAIN,
200 "s4s-elt-character",
201 new Object[]{txt},
202 XMLErrorReporter.SEVERITY_ERROR);
203 break;
204 }
205 }
206 // don't call super.characters() when it's not within one of the 2
207 // annotation elements: the traversers ignore them anyway. We can
208 // save time/memory creating the text nodes.
209 }
210 // when it's within either of the 2 elements, characters are allowed
211 // and we need to store them.
212 else {
213 schemaDOM.characters(text);
214 }
215
216 }
217
218
219 /**
220 * The start of an element.
221 *
222 * @param element The name of the element.
223 * @param attributes The element attributes.
224 * @param augs Additional information that may include infoset augmentations
225 *
226 * @exception XNIException
227 * Thrown by handler to signal an error.
228 */
229 public void startElement(QName element, XMLAttributes attributes, Augmentations augs)
230 throws XNIException {
231
232 fDepth++;
233 // while it is true that non-whitespace character data
234 // may only occur in appInfo or documentation
235 // elements, it's certainly legal for comments and PI's to
236 // occur as children of annotation; we need
237 // to account for these here.
238 if (fAnnotationDepth == -1) {
239 if (element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA &&
240 element.localpart == SchemaSymbols.ELT_ANNOTATION) {
241 if (fGenerateSyntheticAnnotation) {
242 if (fSawAnnotation.size() > 0) {
243 fSawAnnotation.pop();
244 }
245 fSawAnnotation.push(true);
246 }
247 fAnnotationDepth = fDepth;
248 schemaDOM.startAnnotation(element, attributes, fNamespaceContext);
249 fCurrentAnnotationElement = schemaDOM.startElement(element, attributes,
250 fLocator.getLineNumber(),
251 fLocator.getColumnNumber(),
252 fLocator.getCharacterOffset());
253 return;
254 }
255 else if (element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA && fGenerateSyntheticAnnotation) {
256 fSawAnnotation.push(false);
257 fHasNonSchemaAttributes.push(hasNonSchemaAttributes(element, attributes));
258 }
259 }
260 else if (fDepth == fAnnotationDepth + 1) {
261 fInnerAnnotationDepth = fDepth;
262 schemaDOM.startAnnotationElement(element, attributes);
263 }
264 else {
265 schemaDOM.startAnnotationElement(element, attributes);
266 // avoid falling through; don't call startElement in this case
267 return;
268 }
269 schemaDOM.startElement(element, attributes,
270 fLocator.getLineNumber(),
271 fLocator.getColumnNumber(),
272 fLocator.getCharacterOffset());
273
274 }
275
276
277 /**
278 * An empty element.
279 *
280 * @param element The name of the element.
281 * @param attributes The element attributes.
282 * @param augs Additional information that may include infoset augmentations
283 *
284 * @exception XNIException
285 * Thrown by handler to signal an error.
286 */
287 public void emptyElement(QName element, XMLAttributes attributes, Augmentations augs)
288 throws XNIException {
289
290 if (fGenerateSyntheticAnnotation && fAnnotationDepth == -1 &&
291 element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA && element.localpart != SchemaSymbols.ELT_ANNOTATION && hasNonSchemaAttributes(element, attributes)) {
292
293 schemaDOM.startElement(element, attributes,
294 fLocator.getLineNumber(),
295 fLocator.getColumnNumber(),
296 fLocator.getCharacterOffset());
297
298 attributes.removeAllAttributes();
299 String schemaPrefix = fNamespaceContext.getPrefix(SchemaSymbols.URI_SCHEMAFORSCHEMA);
300 final String annRawName = (schemaPrefix.length() == 0) ? SchemaSymbols.ELT_ANNOTATION : (schemaPrefix + ':' + SchemaSymbols.ELT_ANNOTATION);
301 schemaDOM.startAnnotation(annRawName, attributes, fNamespaceContext);
302 final String elemRawName = (schemaPrefix.length() == 0) ? SchemaSymbols.ELT_DOCUMENTATION : (schemaPrefix + ':' + SchemaSymbols.ELT_DOCUMENTATION);
303 schemaDOM.startAnnotationElement(elemRawName, attributes);
304 schemaDOM.charactersRaw("SYNTHETIC_ANNOTATION");
305 schemaDOM.endSyntheticAnnotationElement(elemRawName, false);
306 schemaDOM.endSyntheticAnnotationElement(annRawName, true);
307
308 schemaDOM.endElement();
309
310 return;
311 }
312 // the order of events that occurs here is:
313 // schemaDOM.startAnnotation/startAnnotationElement (if applicable)
314 // schemaDOM.emptyElement (basically the same as startElement then endElement)
315 // schemaDOM.endAnnotationElement (if applicable)
316 // the order of events that would occur if this was <element></element>:
317 // schemaDOM.startAnnotation/startAnnotationElement (if applicable)
318 // schemaDOM.startElement
319 // schemaDOM.endAnnotationElement (if applicable)
320 // schemaDOM.endElementElement
321 // Thus, we can see that the order of events isn't the same. However, it doesn't
322 // seem to matter. -- PJM
323 if (fAnnotationDepth == -1) {
324 // this is messed up, but a case to consider:
325 if (element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA &&
326 element.localpart == SchemaSymbols.ELT_ANNOTATION) {
327 schemaDOM.startAnnotation(element, attributes, fNamespaceContext);
328 }
329 }
330 else {
331 schemaDOM.startAnnotationElement(element, attributes);
332 }
333
334 ElementImpl newElem = schemaDOM.emptyElement(element, attributes,
335 fLocator.getLineNumber(),
336 fLocator.getColumnNumber(),
337 fLocator.getCharacterOffset());
338
339 if (fAnnotationDepth == -1) {
340 // this is messed up, but a case to consider:
341 if (element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA &&
342 element.localpart == SchemaSymbols.ELT_ANNOTATION) {
343 schemaDOM.endAnnotation(element, newElem);
344 }
345 }
346 else {
347 schemaDOM.endAnnotationElement(element);
348 }
349 }
350
351
352 /**
353 * The end of an element.
354 *
355 * @param element The name of the element.
356 * @param augs Additional information that may include infoset augmentations
357 *
358 * @exception XNIException
359 * Thrown by handler to signal an error.
360 */
361 public void endElement(QName element, Augmentations augs) throws XNIException {
362
363 // when we reach the endElement of xs:appinfo or xs:documentation,
364 // change fInnerAnnotationDepth to -1
365 if(fAnnotationDepth > -1) {
366 if (fInnerAnnotationDepth == fDepth) {
367 fInnerAnnotationDepth = -1;
368 schemaDOM.endAnnotationElement(element);
369 schemaDOM.endElement();
370 } else if (fAnnotationDepth == fDepth) {
371 fAnnotationDepth = -1;
372 schemaDOM.endAnnotation(element, fCurrentAnnotationElement);
373 schemaDOM.endElement();
374 } else { // inside a child of annotation
375 schemaDOM.endAnnotationElement(element);
376 }
377 } else { // not in an annotation at all
378 if(element.uri == SchemaSymbols.URI_SCHEMAFORSCHEMA && fGenerateSyntheticAnnotation) {
379 boolean value = fHasNonSchemaAttributes.pop();
380 boolean sawann = fSawAnnotation.pop();
381 if (value && !sawann) {
382 String schemaPrefix = fNamespaceContext.getPrefix(SchemaSymbols.URI_SCHEMAFORSCHEMA);
383 final String annRawName = (schemaPrefix.length() == 0) ? SchemaSymbols.ELT_ANNOTATION : (schemaPrefix + ':' + SchemaSymbols.ELT_ANNOTATION);
384 schemaDOM.startAnnotation(annRawName, fEmptyAttr, fNamespaceContext);
385 final String elemRawName = (schemaPrefix.length() == 0) ? SchemaSymbols.ELT_DOCUMENTATION : (schemaPrefix + ':' + SchemaSymbols.ELT_DOCUMENTATION);
386 schemaDOM.startAnnotationElement(elemRawName, fEmptyAttr);
387 schemaDOM.charactersRaw("SYNTHETIC_ANNOTATION");
388 schemaDOM.endSyntheticAnnotationElement(elemRawName, false);
389 schemaDOM.endSyntheticAnnotationElement(annRawName, true);
390 }
391 }
392 schemaDOM.endElement();
393 }
394 fDepth--;
395
396 }
397
398 /**
399 * @param attributes
400 * @return
401 */
402 private boolean hasNonSchemaAttributes(QName element, XMLAttributes attributes) {
403 final int length = attributes.getLength();
404 for (int i = 0; i < length; ++i) {
405 String uri = attributes.getURI(i);
406 if (uri != null && uri != SchemaSymbols.URI_SCHEMAFORSCHEMA &&
407 uri != NamespaceContext.XMLNS_URI &&
408 !(uri == NamespaceContext.XML_URI &&
409 attributes.getQName(i) == SchemaSymbols.ATT_XML_LANG && element.localpart == SchemaSymbols.ELT_SCHEMA)) {
410 return true;
411 }
412 }
413 return false;
414 }
415
416 /**
417 * Ignorable whitespace. For this method to be called, the document
418 * source must have some way of determining that the text containing
419 * only whitespace characters should be considered ignorable. For
420 * example, the validator can determine if a length of whitespace
421 * characters in the document are ignorable based on the element
422 * content model.
423 *
424 * @param text The ignorable whitespace.
425 * @param augs Additional information that may include infoset augmentations
426 *
427 * @exception XNIException
428 * Thrown by handler to signal an error.
429 */
430 public void ignorableWhitespace(XMLString text, Augmentations augs) throws XNIException {
431 // unlikely to be called, but you never know...
432 if (fAnnotationDepth != -1 ) {
433 schemaDOM.characters(text);
434 }
435 }
436
437 /**
438 * The start of a CDATA section.
439 *
440 * @param augs Additional information that may include infoset augmentations
441 *
442 * @exception XNIException
443 * Thrown by handler to signal an error.
444 */
445 public void startCDATA(Augmentations augs) throws XNIException {
446 // only deal with CDATA boundaries within an annotation.
447 if (fAnnotationDepth != -1) {
448 schemaDOM.startAnnotationCDATA();
449 }
450 }
451
452 /**
453 * The end of a CDATA section.
454 *
455 * @param augs Additional information that may include infoset augmentations
456 *
457 * @exception XNIException
458 * Thrown by handler to signal an error.
459 */
460 public void endCDATA(Augmentations augs) throws XNIException {
461 // only deal with CDATA boundaries within an annotation.
462 if (fAnnotationDepth != -1) {
463 schemaDOM.endAnnotationCDATA();
464 }
465 }
466
467
468 //
469 // other methods
470 //
471
472 /**
473 * Returns the DOM document object.
474 */
475 public Document getDocument() {
476 return schemaDOM;
477 }
478
479 /**
480 * Delegates to SchemaParsingConfig.setFeature
481 * @param featureId
482 * @param state
483 */
484 public void setFeature(String featureId, boolean state){
485 config.setFeature(featureId, state);
486 }
487
488 /**
489 * Delegates to SchemaParsingConfig.getFeature
490 * @param featureId
491 * @return boolean
492 */
493 public boolean getFeature(String featureId){
494 return config.getFeature(featureId);
495 }
496
497 /**
498 * Delegates to SchemaParsingConfig.setProperty.
499 * @param propertyId
500 * @param value
501 */
502 public void setProperty(String propertyId, Object value){
503 config.setProperty(propertyId, value);
504 }
505
506 /**
507 * Delegates to SchemaParsingConfig.getProperty.
508 * @param propertyId
509 * @return Object
510 */
511 public Object getProperty(String propertyId){
512 return config.getProperty(propertyId);
513 }
514
515 /**
516 * Delegates to SchemaParsingConfig.setEntityResolver.
517 * @param er XMLEntityResolver
518 */
519 public void setEntityResolver(XMLEntityResolver er) {
520 config.setEntityResolver(er);
521 }
522
523 /**
524 * Delegates parsing to SchemaParsingConfig
525 *
526 * @param inputSource
527 * @throws IOException
528 */
529 public void parse(XMLInputSource inputSource) throws IOException {
530 config.parse(inputSource);
531 }
532
533 /**
534 * Reset SchemaParsingConfig
535 */
536 public void reset() {
537 ((SchemaParsingConfig)config).reset();
538 }
539
540 /**
541 * ResetNodePool on SchemaParsingConfig
542 */
543 public void resetNodePool() {
544 ((SchemaParsingConfig)config).resetNodePool();
545 }
546
547 /**
548 * A simple boolean based stack.
549 *
550 * @xerces.internal
551 */
552 private static final class BooleanStack {
553
554 //
555 // Data
556 //
557
558 /** Stack depth. */
559 private int fDepth;
560
561 /** Stack data. */
562 private boolean[] fData;
563
564 //
565 // Constructor
566 //
567
568 public BooleanStack () {}
569
570 //
571 // Public methods
572 //
573
574 /** Returns the size of the stack. */
575 public int size() {
576 return fDepth;
577 }
578
579 /** Pushes a value onto the stack. */
580 public void push(boolean value) {
581 ensureCapacity(fDepth + 1);
582 fData[fDepth++] = value;
583 }
584
585 /** Pops a value off of the stack. */
586 public boolean pop() {
587 return fData[--fDepth];
588 }
589
590 /** Clears the stack. */
591 public void clear() {
592 fDepth = 0;
593 }
594
595 //
596 // Private methods
597 //
598
599 /** Ensures capacity. */
600 private void ensureCapacity(int size) {
601 if (fData == null) {
602 fData = new boolean[32];
603 }
604 else if (fData.length <= size) {
605 boolean[] newdata = new boolean[fData.length * 2];
606 System.arraycopy(fData, 0, newdata, 0, fData.length);
607 fData = newdata;
608 }
609 }
610 }
611 }