1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 /*
6 * The Apache Software License, Version 1.1
7 *
8 *
9 * Copyright (c) 1999-2002 The Apache Software Foundation.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 *
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer.
18 *
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in
21 * the documentation and/or other materials provided with the
22 * distribution.
23 *
24 * 3. The end-user documentation included with the redistribution,
25 * if any, must include the following acknowledgment:
26 * "This product includes software developed by the
27 * Apache Software Foundation (http://www.apache.org/)."
28 * Alternately, this acknowledgment may appear in the software itself,
29 * if and wherever such third-party acknowledgments normally appear.
30 *
31 * 4. The names "Xerces" and "Apache Software Foundation" must
32 * not be used to endorse or promote products derived from this
33 * software without prior written permission. For written
34 * permission, please contact apache@apache.org.
35 *
36 * 5. Products derived from this software may not be called "Apache",
37 * nor may "Apache" appear in their name, without prior written
38 * permission of the Apache Software Foundation.
39 *
40 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
41 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
42 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
43 * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
44 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
46 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
47 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
48 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
49 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
50 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51 * SUCH DAMAGE.
52 * ====================================================================
53 *
54 * This software consists of voluntary contributions made by many
55 * individuals on behalf of the Apache Software Foundation and was
56 * originally based on software copyright (c) 1999, International
57 * Business Machines, Inc., http://www.apache.org. For more
58 * information on the Apache Software Foundation, please see
59 * <http://www.apache.org/>.
60 */
61
62 package com.sun.org.apache.xerces.internal.impl.dtd;
63
64 import java.util.ArrayList;
65 import java.util.HashMap;
66 import java.util.Iterator;
67 import java.util.Locale;
68 import java.util.Map;
69 import java.util.StringTokenizer;
70
71 import com.sun.org.apache.xerces.internal.impl.Constants;
72 import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;
73 import com.sun.org.apache.xerces.internal.impl.msg.XMLMessageFormatter;
74 import com.sun.org.apache.xerces.internal.util.SymbolTable;
75 import com.sun.org.apache.xerces.internal.util.XMLChar;
76 import com.sun.org.apache.xerces.internal.util.XMLSymbols;
77 import com.sun.org.apache.xerces.internal.xni.Augmentations;
78 import com.sun.org.apache.xerces.internal.xni.XMLDTDContentModelHandler;
79 import com.sun.org.apache.xerces.internal.xni.XMLDTDHandler;
80 import com.sun.org.apache.xerces.internal.xni.XMLLocator;
81 import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier;
82 import com.sun.org.apache.xerces.internal.xni.XMLString;
83 import com.sun.org.apache.xerces.internal.xni.XNIException;
84 import com.sun.org.apache.xerces.internal.xni.grammars.Grammar;
85 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;
86 import com.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarPool;
87 import com.sun.org.apache.xerces.internal.xni.parser.XMLComponent;
88 import com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager;
89 import com.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;
90 import com.sun.org.apache.xerces.internal.xni.parser.XMLDTDContentModelFilter;
91 import com.sun.org.apache.xerces.internal.xni.parser.XMLDTDContentModelSource;
92 import com.sun.org.apache.xerces.internal.xni.parser.XMLDTDFilter;
93 import com.sun.org.apache.xerces.internal.xni.parser.XMLDTDSource;
94
95 /**
96 * The DTD processor. The processor implements a DTD
97 * filter: receiving DTD events from the DTD scanner; validating
98 * the content and structure; building a grammar, if applicable;
99 * and notifying the DTDHandler of the information resulting from the
100 * process.
101 * <p>
102 * This component requires the following features and properties from the
103 * component manager that uses it:
104 * <ul>
105 * <li>http://xml.org/sax/features/namespaces</li>
106 * <li>http://apache.org/xml/properties/internal/symbol-table</li>
107 * <li>http://apache.org/xml/properties/internal/error-reporter</li>
108 * <li>http://apache.org/xml/properties/internal/grammar-pool</li>
109 * <li>http://apache.org/xml/properties/internal/datatype-validator-factory</li>
110 * </ul>
111 *
112 * @xerces.internal
113 *
114 * @author Neil Graham, IBM
115 *
116 * @version $Id: XMLDTDProcessor.java,v 1.5 2010-11-01 04:39:42 joehw Exp $
117 */
118 public class XMLDTDProcessor
119 implements XMLComponent, XMLDTDFilter, XMLDTDContentModelFilter {
120
121 //
122 // Constants
123 //
124
125 /** Top level scope (-1). */
126 private static final int TOP_LEVEL_SCOPE = -1;
127
128 // feature identifiers
129
130 /** Feature identifier: validation. */
131 protected static final String VALIDATION =
132 Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE;
133
134 /** Feature identifier: notify character references. */
135 protected static final String NOTIFY_CHAR_REFS =
136 Constants.XERCES_FEATURE_PREFIX + Constants.NOTIFY_CHAR_REFS_FEATURE;
137
138 /** Feature identifier: warn on duplicate attdef */
139 protected static final String WARN_ON_DUPLICATE_ATTDEF =
140 Constants.XERCES_FEATURE_PREFIX +Constants.WARN_ON_DUPLICATE_ATTDEF_FEATURE;
141
142 /** Feature identifier: warn on undeclared element referenced in content model. */
143 protected static final String WARN_ON_UNDECLARED_ELEMDEF =
144 Constants.XERCES_FEATURE_PREFIX + Constants.WARN_ON_UNDECLARED_ELEMDEF_FEATURE;
145
146 protected static final String PARSER_SETTINGS =
147 Constants.XERCES_FEATURE_PREFIX + Constants.PARSER_SETTINGS;
148
149 // property identifiers
150
151 /** Property identifier: symbol table. */
152 protected static final String SYMBOL_TABLE =
153 Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY;
154
155 /** Property identifier: error reporter. */
156 protected static final String ERROR_REPORTER =
157 Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;
158
159 /** Property identifier: grammar pool. */
160 protected static final String GRAMMAR_POOL =
161 Constants.XERCES_PROPERTY_PREFIX + Constants.XMLGRAMMAR_POOL_PROPERTY;
162
163 /** Property identifier: validator . */
164 protected static final String DTD_VALIDATOR =
165 Constants.XERCES_PROPERTY_PREFIX + Constants.DTD_VALIDATOR_PROPERTY;
166
167 // recognized features and properties
168
169 /** Recognized features. */
170 private static final String[] RECOGNIZED_FEATURES = {
171 VALIDATION,
172 WARN_ON_DUPLICATE_ATTDEF,
173 WARN_ON_UNDECLARED_ELEMDEF,
174 NOTIFY_CHAR_REFS,
175 };
176
177 /** Feature defaults. */
178 private static final Boolean[] FEATURE_DEFAULTS = {
179 null,
180 Boolean.FALSE,
181 Boolean.FALSE,
182 null,
183 };
184
185 /** Recognized properties. */
186 private static final String[] RECOGNIZED_PROPERTIES = {
187 SYMBOL_TABLE,
188 ERROR_REPORTER,
189 GRAMMAR_POOL,
190 DTD_VALIDATOR,
191 };
192
193 /** Property defaults. */
194 private static final Object[] PROPERTY_DEFAULTS = {
195 null,
196 null,
197 null,
198 null,
199 };
200
201 // debugging
202
203 //
204 // Data
205 //
206
207 // features
208
209 /** Validation. */
210 protected boolean fValidation;
211
212 /** Validation against only DTD */
213 protected boolean fDTDValidation;
214
215 /** warn on duplicate attribute definition, this feature works only when validation is true */
216 protected boolean fWarnDuplicateAttdef;
217
218 /** warn on undeclared element referenced in content model, this feature only works when valiation is true */
219 protected boolean fWarnOnUndeclaredElemdef;
220
221 // properties
222
223 /** Symbol table. */
224 protected SymbolTable fSymbolTable;
225
226 /** Error reporter. */
227 protected XMLErrorReporter fErrorReporter;
228
229 /** Grammar bucket. */
230 protected DTDGrammarBucket fGrammarBucket;
231
232 // the validator to which we look for our grammar bucket (the
233 // validator needs to hold the bucket so that it can initialize
234 // the grammar with details like whether it's for a standalone document...
235 protected XMLDTDValidator fValidator;
236
237 // the grammar pool we'll try to add the grammar to:
238 protected XMLGrammarPool fGrammarPool;
239
240 // what's our Locale?
241 protected Locale fLocale;
242
243 // handlers
244
245 /** DTD handler. */
246 protected XMLDTDHandler fDTDHandler;
247
248 /** DTD source. */
249 protected XMLDTDSource fDTDSource;
250
251 /** DTD content model handler. */
252 protected XMLDTDContentModelHandler fDTDContentModelHandler;
253
254 /** DTD content model source. */
255 protected XMLDTDContentModelSource fDTDContentModelSource;
256
257 // grammars
258
259 /** DTD Grammar. */
260 protected DTDGrammar fDTDGrammar;
261
262 // state
263
264 /** Perform validation. */
265 private boolean fPerformValidation;
266
267 /** True if in an ignore conditional section of the DTD. */
268 protected boolean fInDTDIgnore;
269
270 // information regarding the current element
271
272 // validation states
273
274 /** Mixed. */
275 private boolean fMixed;
276
277 // temporary variables
278
279 /** Temporary entity declaration. */
280 private final XMLEntityDecl fEntityDecl = new XMLEntityDecl();
281
282 /** Notation declaration hash. */
283 private final HashMap fNDataDeclNotations = new HashMap();
284
285 /** DTD element declaration name. */
286 private String fDTDElementDeclName = null;
287
288 /** Mixed element type "hash". */
289 private final ArrayList fMixedElementTypes = new ArrayList();
290
291 /** Element declarations in DTD. */
292 private final ArrayList fDTDElementDecls = new ArrayList();
293
294 // to check for duplicate ID or ANNOTATION attribute declare in
295 // ATTLIST, and misc VCs
296
297 /** ID attribute names. */
298 private HashMap fTableOfIDAttributeNames;
299
300 /** NOTATION attribute names. */
301 private HashMap fTableOfNOTATIONAttributeNames;
302
303 /** NOTATION enumeration values. */
304 private HashMap fNotationEnumVals;
305
306 //
307 // Constructors
308 //
309
310 /** Default constructor. */
311 public XMLDTDProcessor() {
312
313 // initialize data
314
315 } // <init>()
316
317 //
318 // XMLComponent methods
319 //
320
321 /*
322 * Resets the component. The component can query the component manager
323 * about any features and properties that affect the operation of the
324 * component.
325 *
326 * @param componentManager The component manager.
327 *
328 * @throws SAXException Thrown by component on finitialization error.
329 * For example, if a feature or property is
330 * required for the operation of the component, the
331 * component manager may throw a
332 * SAXNotRecognizedException or a
333 * SAXNotSupportedException.
334 */
335 public void reset(XMLComponentManager componentManager) throws XMLConfigurationException {
336
337 boolean parser_settings = componentManager.getFeature(PARSER_SETTINGS, true);
338
339 if (!parser_settings) {
340 // parser settings have not been changed
341 reset();
342 return;
343 }
344
345 // sax features
346 fValidation = componentManager.getFeature(VALIDATION, false);
347
348 fDTDValidation =
349 !(componentManager
350 .getFeature(
351 Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_VALIDATION_FEATURE, false));
352
353 // Xerces features
354
355 fWarnDuplicateAttdef = componentManager.getFeature(WARN_ON_DUPLICATE_ATTDEF, false);
356 fWarnOnUndeclaredElemdef = componentManager.getFeature(WARN_ON_UNDECLARED_ELEMDEF, false);
357
358 // get needed components
359 fErrorReporter =
360 (XMLErrorReporter) componentManager.getProperty(
361 Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY);
362 fSymbolTable =
363 (SymbolTable) componentManager.getProperty(
364 Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY);
365
366 fGrammarPool = (XMLGrammarPool) componentManager.getProperty(GRAMMAR_POOL, null);
367
368 try {
369 fValidator = (XMLDTDValidator) componentManager.getProperty(DTD_VALIDATOR, null);
370 } catch (ClassCastException e) {
371 fValidator = null;
372 }
373 // we get our grammarBucket from the validator...
374 if (fValidator != null) {
375 fGrammarBucket = fValidator.getGrammarBucket();
376 } else {
377 fGrammarBucket = null;
378 }
379 reset();
380
381 } // reset(XMLComponentManager)
382
383 protected void reset() {
384 // clear grammars
385 fDTDGrammar = null;
386 // initialize state
387 fInDTDIgnore = false;
388
389 fNDataDeclNotations.clear();
390
391 // datatype validators
392 if (fValidation) {
393
394 if (fNotationEnumVals == null) {
395 fNotationEnumVals = new HashMap();
396 }
397 fNotationEnumVals.clear();
398
399 fTableOfIDAttributeNames = new HashMap();
400 fTableOfNOTATIONAttributeNames = new HashMap();
401 }
402
403 }
404 /**
405 * Returns a list of feature identifiers that are recognized by
406 * this component. This method may return null if no features
407 * are recognized by this component.
408 */
409 public String[] getRecognizedFeatures() {
410 return (String[])(RECOGNIZED_FEATURES.clone());
411 } // getRecognizedFeatures():String[]
412
413 /**
414 * Sets the state of a feature. This method is called by the component
415 * manager any time after reset when a feature changes state.
416 * <p>
417 * <strong>Note:</strong> Components should silently ignore features
418 * that do not affect the operation of the component.
419 *
420 * @param featureId The feature identifier.
421 * @param state The state of the feature.
422 *
423 * @throws SAXNotRecognizedException The component should not throw
424 * this exception.
425 * @throws SAXNotSupportedException The component should not throw
426 * this exception.
427 */
428 public void setFeature(String featureId, boolean state)
429 throws XMLConfigurationException {
430 } // setFeature(String,boolean)
431
432 /**
433 * Returns a list of property identifiers that are recognized by
434 * this component. This method may return null if no properties
435 * are recognized by this component.
436 */
437 public String[] getRecognizedProperties() {
438 return (String[])(RECOGNIZED_PROPERTIES.clone());
439 } // getRecognizedProperties():String[]
440
441 /**
442 * Sets the value of a property. This method is called by the component
443 * manager any time after reset when a property changes value.
444 * <p>
445 * <strong>Note:</strong> Components should silently ignore properties
446 * that do not affect the operation of the component.
447 *
448 * @param propertyId The property identifier.
449 * @param value The value of the property.
450 *
451 * @throws SAXNotRecognizedException The component should not throw
452 * this exception.
453 * @throws SAXNotSupportedException The component should not throw
454 * this exception.
455 */
456 public void setProperty(String propertyId, Object value)
457 throws XMLConfigurationException {
458 } // setProperty(String,Object)
459
460 /**
461 * Returns the default state for a feature, or null if this
462 * component does not want to report a default value for this
463 * feature.
464 *
465 * @param featureId The feature identifier.
466 *
467 * @since Xerces 2.2.0
468 */
469 public Boolean getFeatureDefault(String featureId) {
470 for (int i = 0; i < RECOGNIZED_FEATURES.length; i++) {
471 if (RECOGNIZED_FEATURES[i].equals(featureId)) {
472 return FEATURE_DEFAULTS[i];
473 }
474 }
475 return null;
476 } // getFeatureDefault(String):Boolean
477
478 /**
479 * Returns the default state for a property, or null if this
480 * component does not want to report a default value for this
481 * property.
482 *
483 * @param propertyId The property identifier.
484 *
485 * @since Xerces 2.2.0
486 */
487 public Object getPropertyDefault(String propertyId) {
488 for (int i = 0; i < RECOGNIZED_PROPERTIES.length; i++) {
489 if (RECOGNIZED_PROPERTIES[i].equals(propertyId)) {
490 return PROPERTY_DEFAULTS[i];
491 }
492 }
493 return null;
494 } // getPropertyDefault(String):Object
495
496 //
497 // XMLDTDSource methods
498 //
499
500 /**
501 * Sets the DTD handler.
502 *
503 * @param dtdHandler The DTD handler.
504 */
505 public void setDTDHandler(XMLDTDHandler dtdHandler) {
506 fDTDHandler = dtdHandler;
507 } // setDTDHandler(XMLDTDHandler)
508
509 /**
510 * Returns the DTD handler.
511 *
512 * @return The DTD handler.
513 */
514 public XMLDTDHandler getDTDHandler() {
515 return fDTDHandler;
516 } // getDTDHandler(): XMLDTDHandler
517
518 //
519 // XMLDTDContentModelSource methods
520 //
521
522 /**
523 * Sets the DTD content model handler.
524 *
525 * @param dtdContentModelHandler The DTD content model handler.
526 */
527 public void setDTDContentModelHandler(XMLDTDContentModelHandler dtdContentModelHandler) {
528 fDTDContentModelHandler = dtdContentModelHandler;
529 } // setDTDContentModelHandler(XMLDTDContentModelHandler)
530
531 /**
532 * Gets the DTD content model handler.
533 *
534 * @return dtdContentModelHandler The DTD content model handler.
535 */
536 public XMLDTDContentModelHandler getDTDContentModelHandler() {
537 return fDTDContentModelHandler;
538 } // getDTDContentModelHandler(): XMLDTDContentModelHandler
539
540 //
541 // XMLDTDContentModelHandler and XMLDTDHandler methods
542 //
543
544 /**
545 * The start of the DTD external subset.
546 *
547 * @param augs Additional information that may include infoset
548 * augmentations.
549 *
550 * @throws XNIException Thrown by handler to signal an error.
551 */
552 public void startExternalSubset(XMLResourceIdentifier identifier,
553 Augmentations augs) throws XNIException {
554 if(fDTDGrammar != null)
555 fDTDGrammar.startExternalSubset(identifier, augs);
556 if(fDTDHandler != null){
557 fDTDHandler.startExternalSubset(identifier, augs);
558 }
559 }
560
561 /**
562 * The end of the DTD external subset.
563 *
564 * @param augs Additional information that may include infoset
565 * augmentations.
566 *
567 * @throws XNIException Thrown by handler to signal an error.
568 */
569 public void endExternalSubset(Augmentations augs) throws XNIException {
570 if(fDTDGrammar != null)
571 fDTDGrammar.endExternalSubset(augs);
572 if(fDTDHandler != null){
573 fDTDHandler.endExternalSubset(augs);
574 }
575 }
576
577 /**
578 * Check standalone entity reference.
579 * Made static to make common between the validator and loader.
580 *
581 * @param name
582 *@param grammar grammar to which entity belongs
583 * @param tempEntityDecl empty entity declaration to put results in
584 * @param errorReporter error reporter to send errors to
585 *
586 * @throws XNIException Thrown by application to signal an error.
587 */
588 protected static void checkStandaloneEntityRef(String name, DTDGrammar grammar,
589 XMLEntityDecl tempEntityDecl, XMLErrorReporter errorReporter) throws XNIException {
590 // check VC: Standalone Document Declartion, entities references appear in the document.
591 int entIndex = grammar.getEntityDeclIndex(name);
592 if (entIndex > -1) {
593 grammar.getEntityDecl(entIndex, tempEntityDecl);
594 if (tempEntityDecl.inExternal) {
595 errorReporter.reportError( XMLMessageFormatter.XML_DOMAIN,
596 "MSG_REFERENCE_TO_EXTERNALLY_DECLARED_ENTITY_WHEN_STANDALONE",
597 new Object[]{name}, XMLErrorReporter.SEVERITY_ERROR);
598 }
599 }
600 }
601
602 /**
603 * A comment.
604 *
605 * @param text The text in the comment.
606 * @param augs Additional information that may include infoset augmentations
607 *
608 * @throws XNIException Thrown by application to signal an error.
609 */
610 public void comment(XMLString text, Augmentations augs) throws XNIException {
611
612 // call handlers
613 if(fDTDGrammar != null)
614 fDTDGrammar.comment(text, augs);
615 if (fDTDHandler != null) {
616 fDTDHandler.comment(text, augs);
617 }
618
619 } // comment(XMLString)
620
621
622 /**
623 * A processing instruction. Processing instructions consist of a
624 * target name and, optionally, text data. The data is only meaningful
625 * to the application.
626 * <p>
627 * Typically, a processing instruction's data will contain a series
628 * of pseudo-attributes. These pseudo-attributes follow the form of
629 * element attributes but are <strong>not</strong> parsed or presented
630 * to the application as anything other than text. The application is
631 * responsible for parsing the data.
632 *
633 * @param target The target.
634 * @param data The data or null if none specified.
635 * @param augs Additional information that may include infoset augmentations
636 *
637 * @throws XNIException Thrown by handler to signal an error.
638 */
639 public void processingInstruction(String target, XMLString data, Augmentations augs)
640 throws XNIException {
641
642 // call handlers
643 if(fDTDGrammar != null)
644 fDTDGrammar.processingInstruction(target, data, augs);
645 if (fDTDHandler != null) {
646 fDTDHandler.processingInstruction(target, data, augs);
647 }
648 } // processingInstruction(String,XMLString)
649
650 //
651 // XMLDTDHandler methods
652 //
653
654 /**
655 * The start of the DTD.
656 *
657 * @param locator The document locator, or null if the document
658 * location cannot be reported during the parsing of
659 * the document DTD. However, it is <em>strongly</em>
660 * recommended that a locator be supplied that can
661 * at least report the base system identifier of the
662 * DTD.
663 * @param augs Additional information that may include infoset
664 * augmentations.
665 *
666 * @throws XNIException Thrown by handler to signal an error.
667 */
668 public void startDTD(XMLLocator locator, Augmentations augs) throws XNIException {
669
670
671 // initialize state
672 fNDataDeclNotations.clear();
673 fDTDElementDecls.clear();
674
675 // the grammar bucket's DTDGrammar will now be the
676 // one we want, whether we're constructing it or not.
677 // if we're not constructing it, then we should not have a reference
678 // to it!
679 if( !fGrammarBucket.getActiveGrammar().isImmutable()) {
680 fDTDGrammar = fGrammarBucket.getActiveGrammar();
681 }
682
683 // call handlers
684 if(fDTDGrammar != null )
685 fDTDGrammar.startDTD(locator, augs);
686 if (fDTDHandler != null) {
687 fDTDHandler.startDTD(locator, augs);
688 }
689
690 } // startDTD(XMLLocator)
691
692 /**
693 * Characters within an IGNORE conditional section.
694 *
695 * @param text The ignored text.
696 * @param augs Additional information that may include infoset
697 * augmentations.
698 *
699 * @throws XNIException Thrown by handler to signal an error.
700 */
701 public void ignoredCharacters(XMLString text, Augmentations augs) throws XNIException {
702
703 // ignored characters in DTD
704 if(fDTDGrammar != null )
705 fDTDGrammar.ignoredCharacters(text, augs);
706 if (fDTDHandler != null) {
707 fDTDHandler.ignoredCharacters(text, augs);
708 }
709 }
710
711 /**
712 * Notifies of the presence of a TextDecl line in an entity. If present,
713 * this method will be called immediately following the startParameterEntity call.
714 * <p>
715 * <strong>Note:</strong> This method is only called for external
716 * parameter entities referenced in the DTD.
717 *
718 * @param version The XML version, or null if not specified.
719 * @param encoding The IANA encoding name of the entity.
720 * @param augs Additional information that may include infoset
721 * augmentations.
722 *
723 * @throws XNIException Thrown by handler to signal an error.
724 */
725 public void textDecl(String version, String encoding, Augmentations augs) throws XNIException {
726
727 // call handlers
728 if(fDTDGrammar != null )
729 fDTDGrammar.textDecl(version, encoding, augs);
730 if (fDTDHandler != null) {
731 fDTDHandler.textDecl(version, encoding, augs);
732 }
733 }
734
735 /**
736 * This method notifies of the start of a parameter entity. The parameter
737 * entity name start with a '%' character.
738 *
739 * @param name The name of the parameter entity.
740 * @param identifier The resource identifier.
741 * @param encoding The auto-detected IANA encoding name of the entity
742 * stream. This value will be null in those situations
743 * where the entity encoding is not auto-detected (e.g.
744 * internal parameter entities).
745 * @param augs Additional information that may include infoset
746 * augmentations.
747 *
748 * @throws XNIException Thrown by handler to signal an error.
749 */
750 public void startParameterEntity(String name,
751 XMLResourceIdentifier identifier,
752 String encoding,
753 Augmentations augs) throws XNIException {
754
755 if (fPerformValidation && fDTDGrammar != null &&
756 fGrammarBucket.getStandalone()) {
757 checkStandaloneEntityRef(name, fDTDGrammar, fEntityDecl, fErrorReporter);
758 }
759 // call handlers
760 if(fDTDGrammar != null )
761 fDTDGrammar.startParameterEntity(name, identifier, encoding, augs);
762 if (fDTDHandler != null) {
763 fDTDHandler.startParameterEntity(name, identifier, encoding, augs);
764 }
765 }
766
767 /**
768 * This method notifies the end of a parameter entity. Parameter entity
769 * names begin with a '%' character.
770 *
771 * @param name The name of the parameter entity.
772 * @param augs Additional information that may include infoset
773 * augmentations.
774 *
775 * @throws XNIException Thrown by handler to signal an error.
776 */
777 public void endParameterEntity(String name, Augmentations augs) throws XNIException {
778
779 // call handlers
780 if(fDTDGrammar != null )
781 fDTDGrammar.endParameterEntity(name, augs);
782 if (fDTDHandler != null) {
783 fDTDHandler.endParameterEntity(name, augs);
784 }
785 }
786
787 /**
788 * An element declaration.
789 *
790 * @param name The name of the element.
791 * @param contentModel The element content model.
792 * @param augs Additional information that may include infoset
793 * augmentations.
794 *
795 * @throws XNIException Thrown by handler to signal an error.
796 */
797 public void elementDecl(String name, String contentModel, Augmentations augs)
798 throws XNIException {
799
800 //check VC: Unique Element Declaration
801 if (fValidation) {
802 if (fDTDElementDecls.contains(name)) {
803 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
804 "MSG_ELEMENT_ALREADY_DECLARED",
805 new Object[]{ name},
806 XMLErrorReporter.SEVERITY_ERROR);
807 }
808 else {
809 fDTDElementDecls.add(name);
810 }
811 }
812
813 // call handlers
814 if(fDTDGrammar != null )
815 fDTDGrammar.elementDecl(name, contentModel, augs);
816 if (fDTDHandler != null) {
817 fDTDHandler.elementDecl(name, contentModel, augs);
818 }
819
820 } // elementDecl(String,String)
821
822 /**
823 * The start of an attribute list.
824 *
825 * @param elementName The name of the element that this attribute
826 * list is associated with.
827 * @param augs Additional information that may include infoset
828 * augmentations.
829 *
830 * @throws XNIException Thrown by handler to signal an error.
831 */
832 public void startAttlist(String elementName, Augmentations augs)
833 throws XNIException {
834
835 // call handlers
836 if(fDTDGrammar != null )
837 fDTDGrammar.startAttlist(elementName, augs);
838 if (fDTDHandler != null) {
839 fDTDHandler.startAttlist(elementName, augs);
840 }
841
842 } // startAttlist(String)
843
844 /**
845 * An attribute declaration.
846 *
847 * @param elementName The name of the element that this attribute
848 * is associated with.
849 * @param attributeName The name of the attribute.
850 * @param type The attribute type. This value will be one of
851 * the following: "CDATA", "ENTITY", "ENTITIES",
852 * "ENUMERATION", "ID", "IDREF", "IDREFS",
853 * "NMTOKEN", "NMTOKENS", or "NOTATION".
854 * @param enumeration If the type has the value "ENUMERATION" or
855 * "NOTATION", this array holds the allowed attribute
856 * values; otherwise, this array is null.
857 * @param defaultType The attribute default type. This value will be
858 * one of the following: "#FIXED", "#IMPLIED",
859 * "#REQUIRED", or null.
860 * @param defaultValue The attribute default value, or null if no
861 * default value is specified.
862 * @param nonNormalizedDefaultValue The attribute default value with no normalization
863 * performed, or null if no default value is specified.
864 * @param augs Additional information that may include infoset
865 * augmentations.
866 *
867 * @throws XNIException Thrown by handler to signal an error.
868 */
869 public void attributeDecl(String elementName, String attributeName,
870 String type, String[] enumeration,
871 String defaultType, XMLString defaultValue,
872 XMLString nonNormalizedDefaultValue, Augmentations augs) throws XNIException {
873
874 if (type != XMLSymbols.fCDATASymbol && defaultValue != null) {
875 normalizeDefaultAttrValue(defaultValue);
876 }
877
878 if (fValidation) {
879
880 boolean duplicateAttributeDef = false ;
881
882 //Get Grammar index to grammar array
883 DTDGrammar grammar = (fDTDGrammar != null? fDTDGrammar:fGrammarBucket.getActiveGrammar());
884 int elementIndex = grammar.getElementDeclIndex( elementName);
885 if (grammar.getAttributeDeclIndex(elementIndex, attributeName) != -1) {
886 //more than one attribute definition is provided for the same attribute of a given element type.
887 duplicateAttributeDef = true ;
888
889 //this feature works only when validation is true.
890 if(fWarnDuplicateAttdef){
891 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
892 "MSG_DUPLICATE_ATTRIBUTE_DEFINITION",
893 new Object[]{ elementName, attributeName },
894 XMLErrorReporter.SEVERITY_WARNING );
895 }
896 }
897
898
899 //
900 // a) VC: One ID per Element Type, If duplicate ID attribute
901 // b) VC: ID attribute Default. if there is a declareared attribute
902 // default for ID it should be of type #IMPLIED or #REQUIRED
903 if (type == XMLSymbols.fIDSymbol) {
904 if (defaultValue != null && defaultValue.length != 0) {
905 if (defaultType == null ||
906 !(defaultType == XMLSymbols.fIMPLIEDSymbol ||
907 defaultType == XMLSymbols.fREQUIREDSymbol)) {
908 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
909 "IDDefaultTypeInvalid",
910 new Object[]{ attributeName},
911 XMLErrorReporter.SEVERITY_ERROR);
912 }
913 }
914
915 if (!fTableOfIDAttributeNames.containsKey(elementName)) {
916 fTableOfIDAttributeNames.put(elementName, attributeName);
917 }
918 else {
919 //we should not report an error, when there is duplicate attribute definition for given element type
920 //according to XML 1.0 spec, When more than one definition is provided for the same attribute of a given
921 //element type, the first declaration is binding and later declaration are *ignored*. So processor should
922 //ignore the second declarations, however an application would be warned of the duplicate attribute defintion
923 // if http://apache.org/xml/features/validation/warn-on-duplicate-attdef feature is set to true,
924 // one typical case where this could be a problem, when any XML file
925 // provide the ID type information through internal subset so that it is available to the parser which read
926 //only internal subset. Now that attribute declaration(ID Type) can again be part of external parsed entity
927 //referenced. At that time if parser doesn't make this distinction it will throw an error for VC One ID per
928 //Element Type, which (second defintion) actually should be ignored. Application behavior may differ on the
929 //basis of error or warning thrown. - nb.
930
931 if(!duplicateAttributeDef){
932 String previousIDAttributeName = (String)fTableOfIDAttributeNames.get( elementName );//rule a)
933 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
934 "MSG_MORE_THAN_ONE_ID_ATTRIBUTE",
935 new Object[]{ elementName, previousIDAttributeName, attributeName},
936 XMLErrorReporter.SEVERITY_ERROR);
937 }
938 }
939 }
940
941 //
942 // VC: One Notation Per Element Type, should check if there is a
943 // duplicate NOTATION attribute
944
945 if (type == XMLSymbols.fNOTATIONSymbol) {
946 // VC: Notation Attributes: all notation names in the
947 // (attribute) declaration must be declared.
948 for (int i=0; i<enumeration.length; i++) {
949 fNotationEnumVals.put(enumeration[i], attributeName);
950 }
951
952 if (fTableOfNOTATIONAttributeNames.containsKey( elementName ) == false) {
953 fTableOfNOTATIONAttributeNames.put( elementName, attributeName);
954 }
955 else {
956 //we should not report an error, when there is duplicate attribute definition for given element type
957 //according to XML 1.0 spec, When more than one definition is provided for the same attribute of a given
958 //element type, the first declaration is binding and later declaration are *ignored*. So processor should
959 //ignore the second declarations, however an application would be warned of the duplicate attribute definition
960 // if http://apache.org/xml/features/validation/warn-on-duplicate-attdef feature is set to true, Application behavior may differ on the basis of error or
961 //warning thrown. - nb.
962
963 if(!duplicateAttributeDef){
964
965 String previousNOTATIONAttributeName = (String) fTableOfNOTATIONAttributeNames.get( elementName );
966 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
967 "MSG_MORE_THAN_ONE_NOTATION_ATTRIBUTE",
968 new Object[]{ elementName, previousNOTATIONAttributeName, attributeName},
969 XMLErrorReporter.SEVERITY_ERROR);
970 }
971 }
972 }
973
974 // VC: No Duplicate Tokens
975 // XML 1.0 SE Errata - E2
976 if (type == XMLSymbols.fENUMERATIONSymbol || type == XMLSymbols.fNOTATIONSymbol) {
977 outer:
978 for (int i = 0; i < enumeration.length; ++i) {
979 for (int j = i + 1; j < enumeration.length; ++j) {
980 if (enumeration[i].equals(enumeration[j])) {
981 // Only report the first uniqueness violation. There could be others,
982 // but additional overhead would be incurred tracking unique tokens
983 // that have already been encountered. -- mrglavas
984 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
985 type == XMLSymbols.fENUMERATIONSymbol
986 ? "MSG_DISTINCT_TOKENS_IN_ENUMERATION"
987 : "MSG_DISTINCT_NOTATION_IN_ENUMERATION",
988 new Object[]{ elementName, enumeration[i], attributeName },
989 XMLErrorReporter.SEVERITY_ERROR);
990 break outer;
991 }
992 }
993 }
994 }
995
996 // VC: Attribute Default Legal
997 boolean ok = true;
998 if (defaultValue != null &&
999 (defaultType == null ||
1000 (defaultType != null && defaultType == XMLSymbols.fFIXEDSymbol))) {
1001
1002 String value = defaultValue.toString();
1003 if (type == XMLSymbols.fNMTOKENSSymbol ||
1004 type == XMLSymbols.fENTITIESSymbol ||
1005 type == XMLSymbols.fIDREFSSymbol) {
1006
1007 StringTokenizer tokenizer = new StringTokenizer(value," ");
1008 if (tokenizer.hasMoreTokens()) {
1009 while (true) {
1010 String nmtoken = tokenizer.nextToken();
1011 if (type == XMLSymbols.fNMTOKENSSymbol) {
1012 if (!isValidNmtoken(nmtoken)) {
1013 ok = false;
1014 break;
1015 }
1016 }
1017 else if (type == XMLSymbols.fENTITIESSymbol ||
1018 type == XMLSymbols.fIDREFSSymbol) {
1019 if (!isValidName(nmtoken)) {
1020 ok = false;
1021 break;
1022 }
1023 }
1024 if (!tokenizer.hasMoreTokens()) {
1025 break;
1026 }
1027 }
1028 }
1029
1030 }
1031 else {
1032 if (type == XMLSymbols.fENTITYSymbol ||
1033 type == XMLSymbols.fIDSymbol ||
1034 type == XMLSymbols.fIDREFSymbol ||
1035 type == XMLSymbols.fNOTATIONSymbol) {
1036
1037 if (!isValidName(value)) {
1038 ok = false;
1039 }
1040
1041 }
1042 else if (type == XMLSymbols.fNMTOKENSymbol ||
1043 type == XMLSymbols.fENUMERATIONSymbol) {
1044
1045 if (!isValidNmtoken(value)) {
1046 ok = false;
1047 }
1048 }
1049
1050 if (type == XMLSymbols.fNOTATIONSymbol ||
1051 type == XMLSymbols.fENUMERATIONSymbol) {
1052 ok = false;
1053 for (int i=0; i<enumeration.length; i++) {
1054 if (defaultValue.equals(enumeration[i])) {
1055 ok = true;
1056 }
1057 }
1058 }
1059
1060 }
1061 if (!ok) {
1062 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
1063 "MSG_ATT_DEFAULT_INVALID",
1064 new Object[]{attributeName, value},
1065 XMLErrorReporter.SEVERITY_ERROR);
1066 }
1067 }
1068 }
1069
1070 // call handlers
1071 if(fDTDGrammar != null)
1072 fDTDGrammar.attributeDecl(elementName, attributeName,
1073 type, enumeration,
1074 defaultType, defaultValue, nonNormalizedDefaultValue, augs);
1075 if (fDTDHandler != null) {
1076 fDTDHandler.attributeDecl(elementName, attributeName,
1077 type, enumeration,
1078 defaultType, defaultValue, nonNormalizedDefaultValue, augs);
1079 }
1080
1081 } // attributeDecl(String,String,String,String[],String,XMLString, XMLString, Augmentations)
1082
1083 /**
1084 * The end of an attribute list.
1085 *
1086 * @param augs Additional information that may include infoset
1087 * augmentations.
1088 *
1089 * @throws XNIException Thrown by handler to signal an error.
1090 */
1091 public void endAttlist(Augmentations augs) throws XNIException {
1092
1093 // call handlers
1094 if(fDTDGrammar != null)
1095 fDTDGrammar.endAttlist(augs);
1096 if (fDTDHandler != null) {
1097 fDTDHandler.endAttlist(augs);
1098 }
1099
1100 } // endAttlist()
1101
1102 /**
1103 * An internal entity declaration.
1104 *
1105 * @param name The name of the entity. Parameter entity names start with
1106 * '%', whereas the name of a general entity is just the
1107 * entity name.
1108 * @param text The value of the entity.
1109 * @param nonNormalizedText The non-normalized value of the entity. This
1110 * value contains the same sequence of characters that was in
1111 * the internal entity declaration, without any entity
1112 * references expanded.
1113 * @param augs Additional information that may include infoset
1114 * augmentations.
1115 *
1116 * @throws XNIException Thrown by handler to signal an error.
1117 */
1118 public void internalEntityDecl(String name, XMLString text,
1119 XMLString nonNormalizedText,
1120 Augmentations augs) throws XNIException {
1121
1122 DTDGrammar grammar = (fDTDGrammar != null? fDTDGrammar: fGrammarBucket.getActiveGrammar());
1123 int index = grammar.getEntityDeclIndex(name) ;
1124
1125 //If the same entity is declared more than once, the first declaration
1126 //encountered is binding, SAX requires only effective(first) declaration
1127 //to be reported to the application
1128
1129 //REVISIT: Does it make sense to pass duplicate Entity information across
1130 //the pipeline -- nb?
1131
1132 //its a new entity and hasn't been declared.
1133 if(index == -1){
1134 //store internal entity declaration in grammar
1135 if(fDTDGrammar != null)
1136 fDTDGrammar.internalEntityDecl(name, text, nonNormalizedText, augs);
1137 // call handlers
1138 if (fDTDHandler != null) {
1139 fDTDHandler.internalEntityDecl(name, text, nonNormalizedText, augs);
1140 }
1141 }
1142
1143 } // internalEntityDecl(String,XMLString,XMLString)
1144
1145
1146 /**
1147 * An external entity declaration.
1148 *
1149 * @param name The name of the entity. Parameter entity names start
1150 * with '%', whereas the name of a general entity is just
1151 * the entity name.
1152 * @param identifier An object containing all location information
1153 * pertinent to this external entity.
1154 * @param augs Additional information that may include infoset
1155 * augmentations.
1156 *
1157 * @throws XNIException Thrown by handler to signal an error.
1158 */
1159 public void externalEntityDecl(String name, XMLResourceIdentifier identifier,
1160 Augmentations augs) throws XNIException {
1161
1162 DTDGrammar grammar = (fDTDGrammar != null? fDTDGrammar: fGrammarBucket.getActiveGrammar());
1163 int index = grammar.getEntityDeclIndex(name) ;
1164
1165 //If the same entity is declared more than once, the first declaration
1166 //encountered is binding, SAX requires only effective(first) declaration
1167 //to be reported to the application
1168
1169 //REVISIT: Does it make sense to pass duplicate entity information across
1170 //the pipeline -- nb?
1171
1172 //its a new entity and hasn't been declared.
1173 if(index == -1){
1174 //store external entity declaration in grammar
1175 if(fDTDGrammar != null)
1176 fDTDGrammar.externalEntityDecl(name, identifier, augs);
1177 // call handlers
1178 if (fDTDHandler != null) {
1179 fDTDHandler.externalEntityDecl(name, identifier, augs);
1180 }
1181 }
1182
1183 } // externalEntityDecl(String,XMLResourceIdentifier, Augmentations)
1184
1185 /**
1186 * An unparsed entity declaration.
1187 *
1188 * @param name The name of the entity.
1189 * @param identifier An object containing all location information
1190 * pertinent to this entity.
1191 * @param notation The name of the notation.
1192 * @param augs Additional information that may include infoset
1193 * augmentations.
1194 *
1195 * @throws XNIException Thrown by handler to signal an error.
1196 */
1197 public void unparsedEntityDecl(String name, XMLResourceIdentifier identifier,
1198 String notation,
1199 Augmentations augs) throws XNIException {
1200
1201 // VC: Notation declared, in the production of NDataDecl
1202 if (fValidation) {
1203 fNDataDeclNotations.put(name, notation);
1204 }
1205
1206 // call handlers
1207 if(fDTDGrammar != null)
1208 fDTDGrammar.unparsedEntityDecl(name, identifier, notation, augs);
1209 if (fDTDHandler != null) {
1210 fDTDHandler.unparsedEntityDecl(name, identifier, notation, augs);
1211 }
1212
1213 } // unparsedEntityDecl(String,XMLResourceIdentifier,String,Augmentations)
1214
1215 /**
1216 * A notation declaration
1217 *
1218 * @param name The name of the notation.
1219 * @param identifier An object containing all location information
1220 * pertinent to this notation.
1221 * @param augs Additional information that may include infoset
1222 * augmentations.
1223 *
1224 * @throws XNIException Thrown by handler to signal an error.
1225 */
1226 public void notationDecl(String name, XMLResourceIdentifier identifier,
1227 Augmentations augs) throws XNIException {
1228
1229 // VC: Unique Notation Name
1230 if (fValidation) {
1231 DTDGrammar grammar = (fDTDGrammar != null ? fDTDGrammar : fGrammarBucket.getActiveGrammar());
1232 if (grammar.getNotationDeclIndex(name) != -1) {
1233 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
1234 "UniqueNotationName",
1235 new Object[]{name},
1236 XMLErrorReporter.SEVERITY_ERROR);
1237 }
1238 }
1239
1240 // call handlers
1241 if(fDTDGrammar != null)
1242 fDTDGrammar.notationDecl(name, identifier, augs);
1243 if (fDTDHandler != null) {
1244 fDTDHandler.notationDecl(name, identifier, augs);
1245 }
1246
1247 } // notationDecl(String,XMLResourceIdentifier, Augmentations)
1248
1249 /**
1250 * The start of a conditional section.
1251 *
1252 * @param type The type of the conditional section. This value will
1253 * either be CONDITIONAL_INCLUDE or CONDITIONAL_IGNORE.
1254 * @param augs Additional information that may include infoset
1255 * augmentations.
1256 *
1257 * @throws XNIException Thrown by handler to signal an error.
1258 *
1259 * @see #CONDITIONAL_INCLUDE
1260 * @see #CONDITIONAL_IGNORE
1261 */
1262 public void startConditional(short type, Augmentations augs) throws XNIException {
1263
1264 // set state
1265 fInDTDIgnore = type == XMLDTDHandler.CONDITIONAL_IGNORE;
1266
1267 // call handlers
1268 if(fDTDGrammar != null)
1269 fDTDGrammar.startConditional(type, augs);
1270 if (fDTDHandler != null) {
1271 fDTDHandler.startConditional(type, augs);
1272 }
1273
1274 } // startConditional(short)
1275
1276 /**
1277 * The end of a conditional section.
1278 *
1279 * @param augs Additional information that may include infoset
1280 * augmentations.
1281 *
1282 * @throws XNIException Thrown by handler to signal an error.
1283 */
1284 public void endConditional(Augmentations augs) throws XNIException {
1285
1286 // set state
1287 fInDTDIgnore = false;
1288
1289 // call handlers
1290 if(fDTDGrammar != null)
1291 fDTDGrammar.endConditional(augs);
1292 if (fDTDHandler != null) {
1293 fDTDHandler.endConditional(augs);
1294 }
1295
1296 } // endConditional()
1297
1298 /**
1299 * The end of the DTD.
1300 *
1301 * @param augs Additional information that may include infoset
1302 * augmentations.
1303 *
1304 * @throws XNIException Thrown by handler to signal an error.
1305 */
1306 public void endDTD(Augmentations augs) throws XNIException {
1307
1308
1309 // save grammar
1310 if(fDTDGrammar != null) {
1311 fDTDGrammar.endDTD(augs);
1312 if(fGrammarPool != null)
1313 fGrammarPool.cacheGrammars(XMLGrammarDescription.XML_DTD, new Grammar[] {fDTDGrammar});
1314 }
1315 if (fValidation) {
1316 DTDGrammar grammar = (fDTDGrammar != null? fDTDGrammar: fGrammarBucket.getActiveGrammar());
1317
1318 // VC : Notation Declared. for external entity declaration [Production 76].
1319 Iterator entities = fNDataDeclNotations.entrySet().iterator();
1320 while (entities.hasNext()) {
1321 Map.Entry entry = (Map.Entry) entities.next();
1322 String notation = (String) entry.getValue();
1323 if (grammar.getNotationDeclIndex(notation) == -1) {
1324 String entity = (String) entry.getKey();
1325 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
1326 "MSG_NOTATION_NOT_DECLARED_FOR_UNPARSED_ENTITYDECL",
1327 new Object[]{entity, notation},
1328 XMLErrorReporter.SEVERITY_ERROR);
1329 }
1330 }
1331
1332 // VC: Notation Attributes:
1333 // all notation names in the (attribute) declaration must be declared.
1334 Iterator notationVals = fNotationEnumVals.entrySet().iterator();
1335 while (notationVals.hasNext()) {
1336 Map.Entry entry = (Map.Entry) notationVals.next();
1337 String notation = (String) entry.getKey();
1338 if (grammar.getNotationDeclIndex(notation) == -1) {
1339 String attributeName = (String) entry.getValue();
1340 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
1341 "MSG_NOTATION_NOT_DECLARED_FOR_NOTATIONTYPE_ATTRIBUTE",
1342 new Object[]{attributeName, notation},
1343 XMLErrorReporter.SEVERITY_ERROR);
1344 }
1345 }
1346
1347 // VC: No Notation on Empty Element
1348 // An attribute of type NOTATION must not be declared on an element declared EMPTY.
1349 Iterator elementsWithNotations = fTableOfNOTATIONAttributeNames.entrySet().iterator();
1350 while (elementsWithNotations.hasNext()) {
1351 Map.Entry entry = (Map.Entry) elementsWithNotations.next();
1352 String elementName = (String) entry.getKey();
1353 int elementIndex = grammar.getElementDeclIndex(elementName);
1354 if (grammar.getContentSpecType(elementIndex) == XMLElementDecl.TYPE_EMPTY) {
1355 String attributeName = (String) entry.getValue();
1356 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
1357 "NoNotationOnEmptyElement",
1358 new Object[]{elementName, attributeName},
1359 XMLErrorReporter.SEVERITY_ERROR);
1360 }
1361 }
1362
1363 // should be safe to release these references
1364 fTableOfIDAttributeNames = null;
1365 fTableOfNOTATIONAttributeNames = null;
1366
1367 // check whether each element referenced in a content model is declared
1368 if (fWarnOnUndeclaredElemdef) {
1369 checkDeclaredElements(grammar);
1370 }
1371 }
1372
1373 // call handlers
1374 if (fDTDHandler != null) {
1375 fDTDHandler.endDTD(augs);
1376 }
1377
1378 } // endDTD()
1379
1380 // sets the XMLDTDSource of this handler
1381 public void setDTDSource(XMLDTDSource source ) {
1382 fDTDSource = source;
1383 } // setDTDSource(XMLDTDSource)
1384
1385 // returns the XMLDTDSource of this handler
1386 public XMLDTDSource getDTDSource() {
1387 return fDTDSource;
1388 } // getDTDSource(): XMLDTDSource
1389
1390 //
1391 // XMLDTDContentModelHandler methods
1392 //
1393
1394 // sets the XMLContentModelDTDSource of this handler
1395 public void setDTDContentModelSource(XMLDTDContentModelSource source ) {
1396 fDTDContentModelSource = source;
1397 } // setDTDContentModelSource(XMLDTDContentModelSource)
1398
1399 // returns the XMLDTDSource of this handler
1400 public XMLDTDContentModelSource getDTDContentModelSource() {
1401 return fDTDContentModelSource;
1402 } // getDTDContentModelSource(): XMLDTDContentModelSource
1403
1404
1405 /**
1406 * The start of a content model. Depending on the type of the content
1407 * model, specific methods may be called between the call to the
1408 * startContentModel method and the call to the endContentModel method.
1409 *
1410 * @param elementName The name of the element.
1411 * @param augs Additional information that may include infoset
1412 * augmentations.
1413 *
1414 * @throws XNIException Thrown by handler to signal an error.
1415 */
1416 public void startContentModel(String elementName, Augmentations augs)
1417 throws XNIException {
1418
1419 if (fValidation) {
1420 fDTDElementDeclName = elementName;
1421 fMixedElementTypes.clear();
1422 }
1423
1424 // call handlers
1425 if(fDTDGrammar != null)
1426 fDTDGrammar.startContentModel(elementName, augs);
1427 if (fDTDContentModelHandler != null) {
1428 fDTDContentModelHandler.startContentModel(elementName, augs);
1429 }
1430
1431 } // startContentModel(String)
1432
1433 /**
1434 * A content model of ANY.
1435 *
1436 * @param augs Additional information that may include infoset
1437 * augmentations.
1438 *
1439 * @throws XNIException Thrown by handler to signal an error.
1440 *
1441 * @see #empty
1442 * @see #startGroup
1443 */
1444 public void any(Augmentations augs) throws XNIException {
1445 if(fDTDGrammar != null)
1446 fDTDGrammar.any(augs);
1447 if (fDTDContentModelHandler != null) {
1448 fDTDContentModelHandler.any(augs);
1449 }
1450 } // any()
1451
1452 /**
1453 * A content model of EMPTY.
1454 *
1455 * @param augs Additional information that may include infoset
1456 * augmentations.
1457 *
1458 * @throws XNIException Thrown by handler to signal an error.
1459 *
1460 * @see #any
1461 * @see #startGroup
1462 */
1463 public void empty(Augmentations augs) throws XNIException {
1464 if(fDTDGrammar != null)
1465 fDTDGrammar.empty(augs);
1466 if (fDTDContentModelHandler != null) {
1467 fDTDContentModelHandler.empty(augs);
1468 }
1469 } // empty()
1470
1471 /**
1472 * A start of either a mixed or children content model. A mixed
1473 * content model will immediately be followed by a call to the
1474 * <code>pcdata()</code> method. A children content model will
1475 * contain additional groups and/or elements.
1476 *
1477 * @param augs Additional information that may include infoset
1478 * augmentations.
1479 *
1480 * @throws XNIException Thrown by handler to signal an error.
1481 *
1482 * @see #any
1483 * @see #empty
1484 */
1485 public void startGroup(Augmentations augs) throws XNIException {
1486
1487 fMixed = false;
1488 // call handlers
1489 if(fDTDGrammar != null)
1490 fDTDGrammar.startGroup(augs);
1491 if (fDTDContentModelHandler != null) {
1492 fDTDContentModelHandler.startGroup(augs);
1493 }
1494
1495 } // startGroup()
1496
1497 /**
1498 * The appearance of "#PCDATA" within a group signifying a
1499 * mixed content model. This method will be the first called
1500 * following the content model's <code>startGroup()</code>.
1501 *
1502 * @param augs Additional information that may include infoset
1503 * augmentations.
1504 *
1505 * @throws XNIException Thrown by handler to signal an error.
1506 *
1507 * @see #startGroup
1508 */
1509 public void pcdata(Augmentations augs) {
1510 fMixed = true;
1511 if(fDTDGrammar != null)
1512 fDTDGrammar.pcdata(augs);
1513 if (fDTDContentModelHandler != null) {
1514 fDTDContentModelHandler.pcdata(augs);
1515 }
1516 } // pcdata()
1517
1518 /**
1519 * A referenced element in a mixed or children content model.
1520 *
1521 * @param elementName The name of the referenced element.
1522 * @param augs Additional information that may include infoset
1523 * augmentations.
1524 *
1525 * @throws XNIException Thrown by handler to signal an error.
1526 */
1527 public void element(String elementName, Augmentations augs) throws XNIException {
1528
1529 // check VC: No duplicate Types, in a single mixed-content declaration
1530 if (fMixed && fValidation) {
1531 if (fMixedElementTypes.contains(elementName)) {
1532 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
1533 "DuplicateTypeInMixedContent",
1534 new Object[]{fDTDElementDeclName, elementName},
1535 XMLErrorReporter.SEVERITY_ERROR);
1536 }
1537 else {
1538 fMixedElementTypes.add(elementName);
1539 }
1540 }
1541
1542 // call handlers
1543 if(fDTDGrammar != null)
1544 fDTDGrammar.element(elementName, augs);
1545 if (fDTDContentModelHandler != null) {
1546 fDTDContentModelHandler.element(elementName, augs);
1547 }
1548
1549 } // childrenElement(String)
1550
1551 /**
1552 * The separator between choices or sequences of a mixed or children
1553 * content model.
1554 *
1555 * @param separator The type of children separator.
1556 * @param augs Additional information that may include infoset
1557 * augmentations.
1558 *
1559 * @throws XNIException Thrown by handler to signal an error.
1560 *
1561 * @see #SEPARATOR_CHOICE
1562 * @see #SEPARATOR_SEQUENCE
1563 */
1564 public void separator(short separator, Augmentations augs)
1565 throws XNIException {
1566
1567 // call handlers
1568 if(fDTDGrammar != null)
1569 fDTDGrammar.separator(separator, augs);
1570 if (fDTDContentModelHandler != null) {
1571 fDTDContentModelHandler.separator(separator, augs);
1572 }
1573
1574 } // separator(short)
1575
1576 /**
1577 * The occurrence count for a child in a children content model or
1578 * for the mixed content model group.
1579 *
1580 * @param occurrence The occurrence count for the last element
1581 * or group.
1582 * @param augs Additional information that may include infoset
1583 * augmentations.
1584 *
1585 * @throws XNIException Thrown by handler to signal an error.
1586 *
1587 * @see #OCCURS_ZERO_OR_ONE
1588 * @see #OCCURS_ZERO_OR_MORE
1589 * @see #OCCURS_ONE_OR_MORE
1590 */
1591 public void occurrence(short occurrence, Augmentations augs)
1592 throws XNIException {
1593
1594 // call handlers
1595 if(fDTDGrammar != null)
1596 fDTDGrammar.occurrence(occurrence, augs);
1597 if (fDTDContentModelHandler != null) {
1598 fDTDContentModelHandler.occurrence(occurrence, augs);
1599 }
1600
1601 } // occurrence(short)
1602
1603 /**
1604 * The end of a group for mixed or children content models.
1605 *
1606 * @param augs Additional information that may include infoset
1607 * augmentations.
1608 *
1609 * @throws XNIException Thrown by handler to signal an error.
1610 */
1611 public void endGroup(Augmentations augs) throws XNIException {
1612
1613 // call handlers
1614 if(fDTDGrammar != null)
1615 fDTDGrammar.endGroup(augs);
1616 if (fDTDContentModelHandler != null) {
1617 fDTDContentModelHandler.endGroup(augs);
1618 }
1619
1620 } // endGroup()
1621
1622 /**
1623 * The end of a content model.
1624 *
1625 * @param augs Additional information that may include infoset
1626 * augmentations.
1627 *
1628 * @throws XNIException Thrown by handler to signal an error.
1629 */
1630 public void endContentModel(Augmentations augs) throws XNIException {
1631
1632 // call handlers
1633 if(fDTDGrammar != null)
1634 fDTDGrammar.endContentModel(augs);
1635 if (fDTDContentModelHandler != null) {
1636 fDTDContentModelHandler.endContentModel(augs);
1637 }
1638
1639 } // endContentModel()
1640
1641 //
1642 // Private methods
1643 //
1644
1645 /**
1646 * Normalize the attribute value of a non CDATA default attribute
1647 * collapsing sequences of space characters (x20)
1648 *
1649 * @param value The value to normalize
1650 * @return Whether the value was changed or not.
1651 */
1652 private boolean normalizeDefaultAttrValue(XMLString value) {
1653
1654 boolean skipSpace = true; // skip leading spaces
1655 int current = value.offset;
1656 int end = value.offset + value.length;
1657 for (int i = value.offset; i < end; i++) {
1658 if (value.ch[i] == ' ') {
1659 if (!skipSpace) {
1660 // take the first whitespace as a space and skip the others
1661 value.ch[current++] = ' ';
1662 skipSpace = true;
1663 }
1664 else {
1665 // just skip it.
1666 }
1667 }
1668 else {
1669 // simply shift non space chars if needed
1670 if (current != i) {
1671 value.ch[current] = value.ch[i];
1672 }
1673 current++;
1674 skipSpace = false;
1675 }
1676 }
1677 if (current != end) {
1678 if (skipSpace) {
1679 // if we finished on a space trim it
1680 current--;
1681 }
1682 // set the new value length
1683 value.length = current - value.offset;
1684 return true;
1685 }
1686 return false;
1687 }
1688
1689 protected boolean isValidNmtoken(String nmtoken) {
1690 return XMLChar.isValidNmtoken(nmtoken);
1691 } // isValidNmtoken(String): boolean
1692
1693 protected boolean isValidName(String name) {
1694 return XMLChar.isValidName(name);
1695 } // isValidName(String): boolean
1696
1697 /**
1698 * Checks that all elements referenced in content models have
1699 * been declared. This method calls out to the error handler
1700 * to indicate warnings.
1701 */
1702 private void checkDeclaredElements(DTDGrammar grammar) {
1703 int elementIndex = grammar.getFirstElementDeclIndex();
1704 XMLContentSpec contentSpec = new XMLContentSpec();
1705 while (elementIndex >= 0) {
1706 int type = grammar.getContentSpecType(elementIndex);
1707 if (type == XMLElementDecl.TYPE_CHILDREN || type == XMLElementDecl.TYPE_MIXED) {
1708 checkDeclaredElements(grammar,
1709 elementIndex,
1710 grammar.getContentSpecIndex(elementIndex),
1711 contentSpec);
1712 }
1713 elementIndex = grammar.getNextElementDeclIndex(elementIndex);
1714 }
1715 }
1716
1717 /**
1718 * Does a recursive (if necessary) check on the specified element's
1719 * content spec to make sure that all children refer to declared
1720 * elements.
1721 */
1722 private void checkDeclaredElements(DTDGrammar grammar, int elementIndex,
1723 int contentSpecIndex, XMLContentSpec contentSpec) {
1724 grammar.getContentSpec(contentSpecIndex, contentSpec);
1725 if (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_LEAF) {
1726 String value = (String) contentSpec.value;
1727 if (value != null && grammar.getElementDeclIndex(value) == -1) {
1728 fErrorReporter.reportError(XMLMessageFormatter.XML_DOMAIN,
1729 "UndeclaredElementInContentSpec",
1730 new Object[]{grammar.getElementDeclName(elementIndex).rawname, value},
1731 XMLErrorReporter.SEVERITY_WARNING);
1732 }
1733 }
1734 // It's not a leaf, so we have to recurse its left and maybe right
1735 // nodes. Save both values before we recurse and trash the node.
1736 else if ((contentSpec.type == XMLContentSpec.CONTENTSPECNODE_CHOICE)
1737 || (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_SEQ)) {
1738 final int leftNode = ((int[])contentSpec.value)[0];
1739 final int rightNode = ((int[])contentSpec.otherValue)[0];
1740 // Recurse on both children.
1741 checkDeclaredElements(grammar, elementIndex, leftNode, contentSpec);
1742 checkDeclaredElements(grammar, elementIndex, rightNode, contentSpec);
1743 }
1744 else if (contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_MORE
1745 || contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ZERO_OR_ONE
1746 || contentSpec.type == XMLContentSpec.CONTENTSPECNODE_ONE_OR_MORE) {
1747 final int leftNode = ((int[])contentSpec.value)[0];
1748 checkDeclaredElements(grammar, elementIndex, leftNode, contentSpec);
1749 }
1750 }
1751
1752 } // class XMLDTDProcessor