rev 1063 : 8172974: [JAXP] XALAN: Wrong result when transforming namespace unaware StAX Input

   1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.

   3  */
   4 /*
   5  * Licensed to the Apache Software Foundation (ASF) under one or more
   6  * contributor license agreements.  See the NOTICE file distributed with
   7  * this work for additional information regarding copyright ownership.
   8  * The ASF licenses this file to You under the Apache License, Version 2.0
   9  * (the "License"); you may not use this file except in compliance with
  10  * the License.  You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0




  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20 
  21 package com.sun.org.apache.xerces.internal.parsers;
  22 
  23 import com.sun.org.apache.xerces.internal.impl.Constants;
  24 import com.sun.org.apache.xerces.internal.util.EntityResolver2Wrapper;
  25 import com.sun.org.apache.xerces.internal.util.EntityResolverWrapper;
  26 import com.sun.org.apache.xerces.internal.util.ErrorHandlerWrapper;
  27 import com.sun.org.apache.xerces.internal.util.SAXMessageFormatter;
  28 import com.sun.org.apache.xerces.internal.util.Status;
  29 import com.sun.org.apache.xerces.internal.util.SymbolHash;
  30 import com.sun.org.apache.xerces.internal.util.XMLSymbols;
  31 import com.sun.org.apache.xerces.internal.utils.XMLSecurityManager;
  32 import com.sun.org.apache.xerces.internal.xni.Augmentations;
  33 import com.sun.org.apache.xerces.internal.xni.NamespaceContext;
  34 import com.sun.org.apache.xerces.internal.xni.QName;
  35 import com.sun.org.apache.xerces.internal.xni.XMLAttributes;
  36 import com.sun.org.apache.xerces.internal.xni.XMLLocator;
  37 import com.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier;
  38 import com.sun.org.apache.xerces.internal.xni.XMLString;
  39 import com.sun.org.apache.xerces.internal.xni.XNIException;
  40 import com.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;
  41 import com.sun.org.apache.xerces.internal.xni.parser.XMLEntityResolver;
  42 import com.sun.org.apache.xerces.internal.xni.parser.XMLErrorHandler;
  43 import com.sun.org.apache.xerces.internal.xni.parser.XMLInputSource;
  44 import com.sun.org.apache.xerces.internal.xni.parser.XMLParseException;
  45 import com.sun.org.apache.xerces.internal.xni.parser.XMLParserConfiguration;
  46 import com.sun.org.apache.xerces.internal.xs.AttributePSVI;
  47 import com.sun.org.apache.xerces.internal.xs.ElementPSVI;
  48 import com.sun.org.apache.xerces.internal.xs.PSVIProvider;
  49 import java.io.IOException;
  50 import java.util.Locale;
  51 import javax.xml.XMLConstants;
  52 import org.xml.sax.AttributeList;
  53 import org.xml.sax.ContentHandler;
  54 import org.xml.sax.DTDHandler;
  55 import org.xml.sax.DocumentHandler;
  56 import org.xml.sax.EntityResolver;
  57 import org.xml.sax.ErrorHandler;
  58 import org.xml.sax.InputSource;
  59 import org.xml.sax.Parser;
  60 import org.xml.sax.SAXException;
  61 import org.xml.sax.SAXNotRecognizedException;
  62 import org.xml.sax.SAXNotSupportedException;
  63 import org.xml.sax.SAXParseException;
  64 import org.xml.sax.XMLReader;
  65 import org.xml.sax.ext.Attributes2;
  66 import org.xml.sax.ext.DeclHandler;
  67 import org.xml.sax.ext.EntityResolver2;
  68 import org.xml.sax.ext.LexicalHandler;
  69 import org.xml.sax.ext.Locator2;
  70 import org.xml.sax.helpers.LocatorImpl;
  71 
  72 /**
  73  * This is the base class of all SAX parsers. It implements both the
  74  * SAX1 and SAX2 parser functionality, while the actual pipeline is
  75  * defined in the parser configuration.
  76  *
  77  * @author Arnaud Le Hors, IBM
  78  * @author Andy Clark, IBM
  79  *
  80  */
  81 public abstract class AbstractSAXParser
  82     extends AbstractXMLDocumentParser
  83     implements PSVIProvider, // PSVI
  84               Parser, XMLReader // SAX1, SAX2
  85 {
  86 
  87     //
  88     // Constants
  89     //
  90 
  91     // features
  92 
  93     /** Feature identifier: namespaces. */
  94     protected static final String NAMESPACES =
  95         Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACES_FEATURE;
  96 
  97     /** Feature identifier: namespace prefixes. */
  98     protected static final String NAMESPACE_PREFIXES =
  99         Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACE_PREFIXES_FEATURE;
 100 
 101     /** Feature id: string interning. */
 102     protected static final String STRING_INTERNING =
 103         Constants.SAX_FEATURE_PREFIX + Constants.STRING_INTERNING_FEATURE;
 104 
 105     /** Feature identifier: allow notation and unparsed entity events to be sent out of order. */
 106     // this is not meant to be a recognized feature, but we need it here to use
 107     // if it is already a recognized feature for the pipeline
 108     protected static final String ALLOW_UE_AND_NOTATION_EVENTS =
 109         Constants.SAX_FEATURE_PREFIX + Constants.ALLOW_DTD_EVENTS_AFTER_ENDDTD_FEATURE;
 110 
 111     /** Recognized features. */
 112     private static final String[] RECOGNIZED_FEATURES = {
 113         NAMESPACES,
 114         NAMESPACE_PREFIXES,
 115         STRING_INTERNING,
 116     };
 117 
 118     // properties
 119 
 120     /** Property id: lexical handler. */
 121     protected static final String LEXICAL_HANDLER =
 122         Constants.SAX_PROPERTY_PREFIX + Constants.LEXICAL_HANDLER_PROPERTY;
 123 
 124     /** Property id: declaration handler. */
 125     protected static final String DECLARATION_HANDLER =
 126         Constants.SAX_PROPERTY_PREFIX + Constants.DECLARATION_HANDLER_PROPERTY;
 127 
 128     /** Property id: DOM node. */
 129     protected static final String DOM_NODE =
 130         Constants.SAX_PROPERTY_PREFIX + Constants.DOM_NODE_PROPERTY;
 131 
 132     /** Property id: security manager. */
 133     private static final String SECURITY_MANAGER =
 134         Constants.XERCES_PROPERTY_PREFIX + Constants.SECURITY_MANAGER_PROPERTY;
 135 
 136     /** Recognized properties. */
 137     private static final String[] RECOGNIZED_PROPERTIES = {
 138         LEXICAL_HANDLER,
 139         DECLARATION_HANDLER,
 140         DOM_NODE,
 141     };
 142 
 143     //
 144     // Data
 145     //
 146 
 147     // features
 148 
 149     /** Namespaces. */
 150     protected boolean fNamespaces;
 151 
 152     /** Namespace prefixes. */
 153     protected boolean fNamespacePrefixes = false;
 154 
 155     /** Lexical handler parameter entities. */
 156     protected boolean fLexicalHandlerParameterEntities = true;
 157 
 158     /** Standalone document declaration. */
 159     protected boolean fStandalone;
 160 
 161     /** Resolve DTD URIs. */
 162     protected boolean fResolveDTDURIs = true;
 163 
 164     /** Use EntityResolver2. */
 165     protected boolean fUseEntityResolver2 = true;
 166 
 167     /**
 168      * XMLNS URIs: Namespace declarations in the
 169      * http://www.w3.org/2000/xmlns/ namespace.
 170      */
 171     protected boolean fXMLNSURIs = false;
 172 
 173     // parser handlers
 174 
 175     /** Content handler. */
 176     protected ContentHandler fContentHandler;
 177 
 178     /** Document handler. */
 179     protected DocumentHandler fDocumentHandler;
 180 
 181     /** Namespace context */
 182     protected NamespaceContext fNamespaceContext;
 183 
 184     /** DTD handler. */
 185     protected org.xml.sax.DTDHandler fDTDHandler;
 186 
 187     /** Decl handler. */
 188     protected DeclHandler fDeclHandler;
 189 
 190     /** Lexical handler. */
 191     protected LexicalHandler fLexicalHandler;
 192 
 193     protected QName fQName = new QName();
 194 
 195     // state
 196 
 197     /**
 198      * True if a parse is in progress. This state is needed because
 199      * some features/properties cannot be set while parsing (e.g.
 200      * validation and namespaces).
 201      */
 202     protected boolean fParseInProgress = false;
 203 
 204     // track the version of the document being parsed
 205     protected String fVersion;
 206 
 207     // temp vars
 208     private final AttributesProxy fAttributesProxy = new AttributesProxy();
 209     private Augmentations fAugmentations = null;
 210 
 211 
 212     // temporary buffer for sending normalized values
 213     // REVISIT: what should be the size of the buffer?
 214     private static final int BUFFER_SIZE = 20;
 215     private char[] fCharBuffer =  new char[BUFFER_SIZE];
 216 
 217     // allows us to keep track of whether an attribute has
 218     // been declared twice, so that we can avoid exposing the
 219     // second declaration to any registered DeclHandler
 220     protected SymbolHash fDeclaredAttrs = null;
 221 
 222     //
 223     // Constructors
 224     //
 225 
 226     /** Default constructor. */
 227     protected AbstractSAXParser(XMLParserConfiguration config) {
 228         super(config);
 229 
 230         config.addRecognizedFeatures(RECOGNIZED_FEATURES);
 231         config.addRecognizedProperties(RECOGNIZED_PROPERTIES);
 232 
 233         try {
 234             config.setFeature(ALLOW_UE_AND_NOTATION_EVENTS, false);
 235         }
 236         catch (XMLConfigurationException e) {
 237             // it wasn't a recognized feature, so we don't worry about it
 238         }
 239     } // <init>(XMLParserConfiguration)
 240 
 241     //
 242     // XMLDocumentHandler methods
 243     //
 244 
 245     /**
 246      * The start of the document.
 247      *
 248      * @param locator The document locator, or null if the document
 249      *                 location cannot be reported during the parsing
 250      *                 of this document. However, it is <em>strongly</em>
 251      *                 recommended that a locator be supplied that can
 252      *                 at least report the system identifier of the
 253      *                 document.
 254      * @param encoding The auto-detected IANA encoding name of the entity
 255      *                 stream. This value will be null in those situations
 256      *                 where the entity encoding is not auto-detected (e.g.
 257      *                 internal entities or a document entity that is
 258      *                 parsed from a java.io.Reader).
 259      * @param namespaceContext
 260      *                 The namespace context in effect at the
 261      *                 start of this document.
 262      *                 This object represents the current context.
 263      *                 Implementors of this class are responsible
 264      *                 for copying the namespace bindings from the
 265      *                 the current context (and its parent contexts)
 266      *                 if that information is important.
 267      * @param augs     Additional information that may include infoset augmentations
 268      *
 269      * @throws XNIException Thrown by handler to signal an error.
 270      */
 271     public void startDocument(XMLLocator locator, String encoding,
 272                               NamespaceContext namespaceContext, Augmentations augs)
 273         throws XNIException {
 274 
 275         fNamespaceContext = namespaceContext;
 276 
 277         try {
 278             // SAX1
 279             if (fDocumentHandler != null) {
 280                 if (locator != null) {
 281                     fDocumentHandler.setDocumentLocator(new LocatorProxy(locator));
 282                 }
 283                 fDocumentHandler.startDocument();
 284             }
 285 
 286             // SAX2
 287             if (fContentHandler != null) {
 288                 if (locator != null) {
 289                     fContentHandler.setDocumentLocator(new LocatorProxy(locator));
 290                 }
 291                 fContentHandler.startDocument();
 292             }
 293         }
 294         catch (SAXException e) {
 295             throw new XNIException(e);
 296         }
 297 
 298     } // startDocument(locator,encoding,augs)
 299 
 300     /**
 301      * Notifies of the presence of an XMLDecl line in the document. If
 302      * present, this method will be called immediately following the
 303      * startDocument call.
 304      *
 305      * @param version    The XML version.
 306      * @param encoding   The IANA encoding name of the document, or null if
 307      *                   not specified.
 308      * @param standalone The standalone value, or null if not specified.
 309      * @param augs   Additional information that may include infoset augmentations
 310      *
 311      * @throws XNIException Thrown by handler to signal an error.
 312      */
 313     public void xmlDecl(String version, String encoding, String standalone, Augmentations augs)
 314         throws XNIException {
 315         // the version need only be set once; if
 316         // document's XML 1.0|1.1, that's how it'll stay
 317         fVersion = version;
 318         fStandalone = "yes".equals(standalone);
 319     } // xmlDecl(String,String,String)
 320 
 321     /**
 322      * Notifies of the presence of the DOCTYPE line in the document.
 323      *
 324      * @param rootElement The name of the root element.
 325      * @param publicId    The public identifier if an external DTD or null
 326      *                    if the external DTD is specified using SYSTEM.
 327      * @param systemId    The system identifier if an external DTD, null
 328      *                    otherwise.
 329      * @param augs     Additional information that may include infoset augmentations
 330      *
 331      * @throws XNIException Thrown by handler to signal an error.
 332      */
 333     public void doctypeDecl(String rootElement,
 334                             String publicId, String systemId, Augmentations augs)
 335         throws XNIException {
 336         fInDTD = true;
 337 
 338         try {
 339             // SAX2 extension
 340             if (fLexicalHandler != null) {
 341                 fLexicalHandler.startDTD(rootElement, publicId, systemId);
 342             }
 343         }
 344         catch (SAXException e) {
 345             throw new XNIException(e);
 346         }
 347 
 348         // is there a DeclHandler?
 349         if(fDeclHandler != null) {
 350             fDeclaredAttrs = new SymbolHash();
 351         }
 352 
 353     } // doctypeDecl(String,String,String)
 354 
 355         /**
 356      * This method notifies of the start of an entity. The DTD has the
 357      * pseudo-name of "[dtd]" parameter entity names start with '%'; and
 358      * general entity names are just the entity name.
 359      * <p>
 360      * <strong>Note:</strong> Since the document is an entity, the handler
 361      * will be notified of the start of the document entity by calling the
 362      * startEntity method with the entity name "[xml]" <em>before</em> calling
 363      * the startDocument method. When exposing entity boundaries through the
 364      * SAX API, the document entity is never reported, however.
 365      * <p>
 366      * <strong>Note:</strong> This method is not called for entity references
 367      * appearing as part of attribute values.
 368      *
 369      * @param name     The name of the entity.
 370      * @param identifier The resource identifier.
 371      * @param encoding The auto-detected IANA encoding name of the entity
 372      *                 stream. This value will be null in those situations
 373      *                 where the entity encoding is not auto-detected (e.g.
 374      *                 internal parameter entities).
 375      * @param augs     Additional information that may include infoset augmentations
 376      *
 377      * @throws XNIException Thrown by handler to signal an error.
 378      */
 379     public void startGeneralEntity(String name, XMLResourceIdentifier identifier,
 380                                    String encoding, Augmentations augs)
 381         throws XNIException {
 382 
 383         try {
 384             // Only report startEntity if this entity was actually read.
 385             if (augs != null && Boolean.TRUE.equals(augs.getItem(Constants.ENTITY_SKIPPED))) {
 386                 // report skipped entity to content handler
 387                 if (fContentHandler != null) {
 388                     fContentHandler.skippedEntity(name);
 389                 }
 390             }
 391             else {
 392                 // SAX2 extension
 393                 if (fLexicalHandler != null) {
 394                     fLexicalHandler.startEntity(name);
 395                 }
 396             }
 397         }
 398         catch (SAXException e) {
 399             throw new XNIException(e);
 400         }
 401 
 402     } // startGeneralEntity(String,String,String,String,String)
 403 
 404     /**
 405      * This method notifies the end of an entity. The DTD has the pseudo-name
 406      * of "[dtd]" parameter entity names start with '%'; and general entity
 407      * names are just the entity name.
 408      * <p>
 409      * <strong>Note:</strong> Since the document is an entity, the handler
 410      * will be notified of the end of the document entity by calling the
 411      * endEntity method with the entity name "[xml]" <em>after</em> calling
 412      * the endDocument method. When exposing entity boundaries through the
 413      * SAX API, the document entity is never reported, however.
 414      * <p>
 415      * <strong>Note:</strong> This method is not called for entity references
 416      * appearing as part of attribute values.
 417      *
 418      * @param name The name of the entity.
 419      * @param augs     Additional information that may include infoset augmentations
 420      *
 421      * @throws XNIException Thrown by handler to signal an error.
 422      */
 423     public void endGeneralEntity(String name, Augmentations augs) throws XNIException {
 424 
 425         try {
 426             // Only report endEntity if this entity was actually read.
 427             if (augs == null || !Boolean.TRUE.equals(augs.getItem(Constants.ENTITY_SKIPPED))) {
 428                 // SAX2 extension
 429                 if (fLexicalHandler != null) {
 430                     fLexicalHandler.endEntity(name);
 431                 }
 432             }
 433         }
 434         catch (SAXException e) {
 435             throw new XNIException(e);
 436         }
 437 
 438     } // endEntity(String)
 439 
 440      /**
 441      * The start of an element. If the document specifies the start element
 442      * by using an empty tag, then the startElement method will immediately
 443      * be followed by the endElement method, with no intervening methods.
 444      *
 445      * @param element    The name of the element.
 446      * @param attributes The element attributes.
 447      * @param augs     Additional information that may include infoset augmentations
 448      *
 449      * @throws XNIException Thrown by handler to signal an error.
 450      */
 451     public void startElement(QName element, XMLAttributes attributes, Augmentations augs)
 452         throws XNIException {
 453 
 454         try {
 455             // SAX1
 456             if (fDocumentHandler != null) {
 457                 // REVISIT: should we support schema-normalized-value for SAX1 events
 458                 //
 459                 fAttributesProxy.setAttributes(attributes);
 460                 fDocumentHandler.startElement(element.rawname, fAttributesProxy);
 461             }
 462 
 463             // SAX2
 464             if (fContentHandler != null) {
 465 
 466                 if (fNamespaces) {
 467                     // send prefix mapping events
 468                     startNamespaceMapping();
 469 
 470                     // REVISIT: It should not be necessary to iterate over the attribute
 471                     // list when the set of [namespace attributes] is empty for this
 472                     // element. This should be computable from the NamespaceContext, but
 473                     // since we currently don't report the mappings for the xml prefix
 474                     // we cannot use the declared prefix count for the current context
 475                     // to skip this section. -- mrglavas
 476                     int len = attributes.getLength();
 477                     if (!fNamespacePrefixes) {
 478                         for (int i = len - 1; i >= 0; --i) {
 479                             attributes.getName(i, fQName);
 480                             if ((fQName.prefix == XMLSymbols.PREFIX_XMLNS) ||
 481                                (fQName.rawname == XMLSymbols.PREFIX_XMLNS)) {
 482                                 // remove namespace declaration attributes
 483                                 attributes.removeAttributeAt(i);
 484                             }
 485                         }
 486                     }
 487                     else if (!fXMLNSURIs) {
 488                         for (int i = len - 1; i >= 0; --i) {
 489                             attributes.getName(i, fQName);
 490                             if ((fQName.prefix == XMLSymbols.PREFIX_XMLNS) ||
 491                                (fQName.rawname == XMLSymbols.PREFIX_XMLNS)) {
 492                                 // localpart should be empty string as per SAX documentation:
 493                                 // http://www.saxproject.org/?selected=namespaces
 494                                 fQName.prefix = "";
 495                                 fQName.uri = "";
 496                                 fQName.localpart = "";
 497                                 attributes.setName(i, fQName);
 498                             }
 499                         }
 500                     }
 501                 }
 502 
 503                 fAugmentations = augs;
 504 
 505                 String uri = element.uri != null ? element.uri : "";
 506                 String localpart = fNamespaces ? element.localpart : "";
 507                 fAttributesProxy.setAttributes(attributes);
 508                 fContentHandler.startElement(uri, localpart, element.rawname,
 509                                              fAttributesProxy);
 510             }
 511         }
 512         catch (SAXException e) {
 513             throw new XNIException(e);
 514         }
 515 
 516     } // startElement(QName,XMLAttributes)
 517 
 518     /**
 519      * Character content.
 520      *
 521      * @param text The content.
 522      * @param augs     Additional information that may include infoset augmentations
 523      *
 524      * @throws XNIException Thrown by handler to signal an error.
 525      */
 526     public void characters(XMLString text, Augmentations augs) throws XNIException {
 527 
 528         // if type is union (XML Schema) it is possible that we receive
 529         // character call with empty data
 530         if (text.length == 0) {
 531             return;
 532         }
 533 
 534 
 535         try {
 536             // SAX1
 537             if (fDocumentHandler != null) {
 538                 // REVISIT: should we support schema-normalized-value for SAX1 events
 539                 //
 540                 fDocumentHandler.characters(text.ch, text.offset, text.length);
 541             }
 542 
 543             // SAX2
 544             if (fContentHandler != null) {
 545                 fContentHandler.characters(text.ch, text.offset, text.length);
 546             }
 547         }
 548         catch (SAXException e) {
 549             throw new XNIException(e);
 550         }
 551 
 552     } // characters(XMLString)
 553 
 554     /**
 555      * Ignorable whitespace. For this method to be called, the document
 556      * source must have some way of determining that the text containing
 557      * only whitespace characters should be considered ignorable. For
 558      * example, the validator can determine if a length of whitespace
 559      * characters in the document are ignorable based on the element
 560      * content model.
 561      *
 562      * @param text The ignorable whitespace.
 563      * @param augs     Additional information that may include infoset augmentations
 564      *
 565      * @throws XNIException Thrown by handler to signal an error.
 566      */
 567     public void ignorableWhitespace(XMLString text, Augmentations augs) throws XNIException {
 568 
 569         try {
 570             // SAX1
 571             if (fDocumentHandler != null) {
 572                 fDocumentHandler.ignorableWhitespace(text.ch, text.offset, text.length);
 573             }
 574 
 575             // SAX2
 576             if (fContentHandler != null) {
 577                 fContentHandler.ignorableWhitespace(text.ch, text.offset, text.length);
 578             }
 579         }
 580         catch (SAXException e) {
 581             throw new XNIException(e);
 582         }
 583 
 584     } // ignorableWhitespace(XMLString)
 585 
 586     /**
 587      * The end of an element.
 588      *
 589      * @param element The name of the element.
 590      * @param augs     Additional information that may include infoset augmentations
 591      *
 592      * @throws XNIException Thrown by handler to signal an error.
 593      */
 594     public void endElement(QName element, Augmentations augs) throws XNIException {
 595 
 596 
 597         try {
 598             // SAX1
 599             if (fDocumentHandler != null) {
 600                 fDocumentHandler.endElement(element.rawname);
 601             }
 602 
 603             // SAX2
 604             if (fContentHandler != null) {
 605                 fAugmentations = augs;
 606                 String uri = element.uri != null ? element.uri : "";
 607                 String localpart = fNamespaces ? element.localpart : "";
 608                 fContentHandler.endElement(uri, localpart,
 609                                            element.rawname);
 610                 if (fNamespaces) {
 611                     endNamespaceMapping();
 612                 }
 613             }
 614         }
 615         catch (SAXException e) {
 616             throw new XNIException(e);
 617         }
 618 
 619     } // endElement(QName)
 620 
 621         /**
 622      * The start of a CDATA section.
 623      * @param augs     Additional information that may include infoset augmentations
 624      *
 625      * @throws XNIException Thrown by handler to signal an error.
 626      */
 627     public void startCDATA(Augmentations augs) throws XNIException {
 628 
 629         try {
 630             // SAX2 extension
 631             if (fLexicalHandler != null) {
 632                 fLexicalHandler.startCDATA();
 633             }
 634         }
 635         catch (SAXException e) {
 636             throw new XNIException(e);
 637         }
 638 
 639     } // startCDATA()
 640 
 641     /**
 642      * The end of a CDATA section.
 643      * @param augs     Additional information that may include infoset augmentations
 644      *
 645      * @throws XNIException Thrown by handler to signal an error.
 646      */
 647     public void endCDATA(Augmentations augs) throws XNIException {
 648 
 649         try {
 650             // SAX2 extension
 651             if (fLexicalHandler != null) {
 652                 fLexicalHandler.endCDATA();
 653             }
 654         }
 655         catch (SAXException e) {
 656             throw new XNIException(e);
 657         }
 658 
 659     } // endCDATA()
 660 
 661     /**
 662      * A comment.
 663      *
 664      * @param text The text in the comment.
 665      * @param augs     Additional information that may include infoset augmentations
 666      *
 667      * @throws XNIException Thrown by application to signal an error.
 668      */
 669     public void comment(XMLString text, Augmentations augs) throws XNIException {
 670 
 671         try {
 672             // SAX2 extension
 673             if (fLexicalHandler != null) {
 674                 fLexicalHandler.comment(text.ch, 0, text.length);
 675             }
 676         }
 677         catch (SAXException e) {
 678             throw new XNIException(e);
 679         }
 680 
 681     } // comment(XMLString)
 682 
 683     /**
 684      * A processing instruction. Processing instructions consist of a
 685      * target name and, optionally, text data. The data is only meaningful
 686      * to the application.
 687      * <p>
 688      * Typically, a processing instruction's data will contain a series
 689      * of pseudo-attributes. These pseudo-attributes follow the form of
 690      * element attributes but are <strong>not</strong> parsed or presented
 691      * to the application as anything other than text. The application is
 692      * responsible for parsing the data.
 693      *
 694      * @param target The target.
 695      * @param data   The data or null if none specified.
 696      * @param augs     Additional information that may include infoset augmentations
 697      *
 698      * @throws XNIException Thrown by handler to signal an error.
 699      */
 700     public void processingInstruction(String target, XMLString data, Augmentations augs)
 701         throws XNIException {
 702 
 703         //
 704         // REVISIT - I keep running into SAX apps that expect
 705         //   null data to be an empty string, which is contrary
 706         //   to the comment for this method in the SAX API.
 707         //
 708 
 709         try {
 710             // SAX1
 711             if (fDocumentHandler != null) {
 712                 fDocumentHandler.processingInstruction(target,
 713                                                        data.toString());
 714             }
 715 
 716             // SAX2
 717             if (fContentHandler != null) {
 718                 fContentHandler.processingInstruction(target, data.toString());
 719             }
 720         }
 721         catch (SAXException e) {
 722             throw new XNIException(e);
 723         }
 724 
 725     } // processingInstruction(String,XMLString)
 726 
 727 
 728     /**
 729      * The end of the document.
 730      * @param augs     Additional information that may include infoset augmentations
 731      *
 732      * @throws XNIException Thrown by handler to signal an error.
 733      */
 734     public void endDocument(Augmentations augs) throws XNIException {
 735 
 736         try {
 737             // SAX1
 738             if (fDocumentHandler != null) {
 739                 fDocumentHandler.endDocument();
 740             }
 741 
 742             // SAX2
 743             if (fContentHandler != null) {
 744                 fContentHandler.endDocument();
 745             }
 746         }
 747         catch (SAXException e) {
 748             throw new XNIException(e);
 749         }
 750 
 751     } // endDocument()
 752 
 753     //
 754     // XMLDTDHandler methods
 755     //
 756 
 757     /**
 758      * The start of the DTD external subset.
 759      *
 760      * @param augs Additional information that may include infoset
 761      *                      augmentations.
 762      *
 763      * @throws XNIException Thrown by handler to signal an error.
 764      */
 765     public void startExternalSubset(XMLResourceIdentifier identifier,
 766                                     Augmentations augs) throws XNIException {
 767         startParameterEntity("[dtd]", null, null, augs);
 768     }
 769 
 770     /**
 771      * The end of the DTD external subset.
 772      *
 773      * @param augs Additional information that may include infoset
 774      *                      augmentations.
 775      *
 776      * @throws XNIException Thrown by handler to signal an error.
 777      */
 778     public void endExternalSubset(Augmentations augs) throws XNIException {
 779         endParameterEntity("[dtd]", augs);
 780     }
 781 
 782     /**
 783      * This method notifies of the start of parameter entity. The DTD has the
 784      * pseudo-name of "[dtd]" parameter entity names start with '%'; and
 785      * general entity names are just the entity name.
 786      * <p>
 787      * <strong>Note:</strong> Since the document is an entity, the handler
 788      * will be notified of the start of the document entity by calling the
 789      * startEntity method with the entity name "[xml]" <em>before</em> calling
 790      * the startDocument method. When exposing entity boundaries through the
 791      * SAX API, the document entity is never reported, however.
 792      * <p>
 793      * <strong>Note:</strong> This method is not called for entity references
 794      * appearing as part of attribute values.
 795      *
 796      * @param name     The name of the parameter entity.
 797      * @param identifier The resource identifier.
 798      * @param encoding The auto-detected IANA encoding name of the entity
 799      *                 stream. This value will be null in those situations
 800      *                 where the entity encoding is not auto-detected (e.g.
 801      *                 internal parameter entities).
 802      * @param augs Additional information that may include infoset
 803      *                      augmentations.
 804      *
 805      * @throws XNIException Thrown by handler to signal an error.
 806      */
 807     public void startParameterEntity(String name,
 808                                      XMLResourceIdentifier identifier,
 809                                      String encoding, Augmentations augs)
 810         throws XNIException {
 811 
 812         try {
 813             // Only report startEntity if this entity was actually read.
 814             if (augs != null && Boolean.TRUE.equals(augs.getItem(Constants.ENTITY_SKIPPED))) {
 815                 // report skipped entity to content handler
 816                 if (fContentHandler != null) {
 817                     fContentHandler.skippedEntity(name);
 818                 }
 819             }
 820             else {
 821                 // SAX2 extension
 822                 if (fLexicalHandler != null && fLexicalHandlerParameterEntities) {
 823                     fLexicalHandler.startEntity(name);
 824                 }
 825             }
 826         }
 827         catch (SAXException e) {
 828             throw new XNIException(e);
 829         }
 830 
 831     } // startParameterEntity(String,identifier,String,Augmentation)
 832 
 833     /**
 834      * This method notifies the end of an entity. The DTD has the pseudo-name
 835      * of "[dtd]" parameter entity names start with '%'; and general entity
 836      * names are just the entity name.
 837      * <p>
 838      * <strong>Note:</strong> Since the document is an entity, the handler
 839      * will be notified of the end of the document entity by calling the
 840      * endEntity method with the entity name "[xml]" <em>after</em> calling
 841      * the endDocument method. When exposing entity boundaries through the
 842      * SAX API, the document entity is never reported, however.
 843      * <p>
 844      * <strong>Note:</strong> This method is not called for entity references
 845      * appearing as part of attribute values.
 846      *
 847      * @param name The name of the parameter entity.
 848      * @param augs Additional information that may include infoset
 849      *                      augmentations.
 850      *
 851      * @throws XNIException Thrown by handler to signal an error.
 852      */
 853     public void endParameterEntity(String name, Augmentations augs) throws XNIException {
 854 
 855         try {
 856             // Only report endEntity if this entity was actually read.
 857             if (augs == null || !Boolean.TRUE.equals(augs.getItem(Constants.ENTITY_SKIPPED))) {
 858                 // SAX2 extension
 859                 if (fLexicalHandler != null && fLexicalHandlerParameterEntities) {
 860                     fLexicalHandler.endEntity(name);
 861                 }
 862             }
 863         }
 864         catch (SAXException e) {
 865             throw new XNIException(e);
 866         }
 867 
 868     } // endEntity(String)
 869 
 870     /**
 871      * An element declaration.
 872      *
 873      * @param name         The name of the element.
 874      * @param contentModel The element content model.
 875      *
 876      * @param augs Additional information that may include infoset
 877      *                      augmentations.
 878      *
 879      * @throws XNIException Thrown by handler to signal an error.
 880      */
 881     public void elementDecl(String name, String contentModel, Augmentations augs)
 882         throws XNIException {
 883 
 884         try {
 885             // SAX2 extension
 886             if (fDeclHandler != null) {
 887                 fDeclHandler.elementDecl(name, contentModel);
 888             }
 889         }
 890         catch (SAXException e) {
 891             throw new XNIException(e);
 892         }
 893 
 894     } // elementDecl(String,String, Augmentations)
 895 
 896     /**
 897      * An attribute declaration.
 898      *
 899      * @param elementName   The name of the element that this attribute
 900      *                      is associated with.
 901      * @param attributeName The name of the attribute.
 902      * @param type          The attribute type. This value will be one of
 903      *                      the following: "CDATA", "ENTITY", "ENTITIES",
 904      *                      "ENUMERATION", "ID", "IDREF", "IDREFS",
 905      *                      "NMTOKEN", "NMTOKENS", or "NOTATION".
 906      * @param enumeration   If the type has the value "ENUMERATION" or
 907      *                      "NOTATION", this array holds the allowed attribute
 908      *                      values; otherwise, this array is null.
 909      * @param defaultType   The attribute default type. This value will be
 910      *                      one of the following: "#FIXED", "#IMPLIED",
 911      *                      "#REQUIRED", or null.
 912      * @param defaultValue  The attribute default value, or null if no
 913      *                      default value is specified.
 914      *
 915      * @param nonNormalizedDefaultValue  The attribute default value with no normalization
 916      *                      performed, or null if no default value is specified.
 917      * @param augs Additional information that may include infoset
 918      *                      augmentations.
 919      *
 920      * @throws XNIException Thrown by handler to signal an error.
 921      */
 922     public void attributeDecl(String elementName, String attributeName,
 923                               String type, String[] enumeration,
 924                               String defaultType, XMLString defaultValue,
 925                               XMLString nonNormalizedDefaultValue, Augmentations augs) throws XNIException {
 926 
 927         try {
 928             // SAX2 extension
 929             if (fDeclHandler != null) {
 930                 // used as a key to detect duplicate attribute definitions.
 931                 String elemAttr = new StringBuffer(elementName).append("<").append(attributeName).toString();
 932                 if(fDeclaredAttrs.get(elemAttr) != null) {
 933                     // we aren't permitted to return duplicate attribute definitions
 934                     return;
 935                 }
 936                 fDeclaredAttrs.put(elemAttr, Boolean.TRUE);
 937                 if (type.equals("NOTATION") ||
 938                     type.equals("ENUMERATION")) {
 939 
 940                     StringBuffer str = new StringBuffer();
 941                     if (type.equals("NOTATION")) {
 942                       str.append(type);
 943                       str.append(" (");
 944                     }
 945                     else {
 946                       str.append("(");
 947                     }
 948                     for (int i = 0; i < enumeration.length; i++) {
 949                         str.append(enumeration[i]);
 950                         if (i < enumeration.length - 1) {
 951                             str.append('|');
 952                         }
 953                     }
 954                     str.append(')');
 955                     type = str.toString();
 956                 }
 957                 String value = (defaultValue==null) ? null : defaultValue.toString();
 958                 fDeclHandler.attributeDecl(elementName, attributeName,
 959                                            type, defaultType, value);
 960             }
 961         }
 962         catch (SAXException e) {
 963             throw new XNIException(e);
 964         }
 965 
 966     } // attributeDecl(String,String,String,String[],String,XMLString, XMLString, Augmentations)
 967 
 968     /**
 969      * An internal entity declaration.
 970      *
 971      * @param name The name of the entity. Parameter entity names start with
 972      *             '%', whereas the name of a general entity is just the
 973      *             entity name.
 974      * @param text The value of the entity.
 975      * @param nonNormalizedText The non-normalized value of the entity. This
 976      *             value contains the same sequence of characters that was in
 977      *             the internal entity declaration, without any entity
 978      *             references expanded.
 979      *
 980      * @param augs Additional information that may include infoset
 981      *                      augmentations.
 982      *
 983      * @throws XNIException Thrown by handler to signal an error.
 984      */
 985     public void internalEntityDecl(String name, XMLString text,
 986                                    XMLString nonNormalizedText,
 987                                    Augmentations augs) throws XNIException {
 988 
 989         try {
 990             // SAX2 extensions
 991             if (fDeclHandler != null) {
 992                 fDeclHandler.internalEntityDecl(name, text.toString());
 993             }
 994         }
 995         catch (SAXException e) {
 996             throw new XNIException(e);
 997         }
 998 
 999     } // internalEntityDecl(String,XMLString,XMLString)
1000 
1001     /**
1002      * An external entity declaration.
1003      *
1004      * @param name     The name of the entity. Parameter entity names start
1005      *                 with '%', whereas the name of a general entity is just
1006      *                 the entity name.
1007      * @param identifier    An object containing all location information
1008      *                      pertinent to this entity.
1009      * @param augs Additional information that may include infoset
1010      *                      augmentations.
1011      *
1012      * @throws XNIException Thrown by handler to signal an error.
1013      */
1014     public void externalEntityDecl(String name, XMLResourceIdentifier identifier,
1015                                    Augmentations augs) throws XNIException {
1016         try {
1017             // SAX2 extension
1018             if (fDeclHandler != null) {
1019                 String publicId = identifier.getPublicId();
1020                 String systemId = fResolveDTDURIs ?
1021                     identifier.getExpandedSystemId() : identifier.getLiteralSystemId();
1022                 fDeclHandler.externalEntityDecl(name, publicId, systemId);
1023             }
1024         }
1025         catch (SAXException e) {
1026             throw new XNIException(e);
1027         }
1028 
1029     } // externalEntityDecl(String,,XMLResourceIdentifier, Augmentations)
1030 
1031     /**
1032      * An unparsed entity declaration.
1033      *
1034      * @param name     The name of the entity.
1035      * @param identifier    An object containing all location information
1036      *                      pertinent to this entity.
1037      * @param notation The name of the notation.
1038      *
1039      * @param augs Additional information that may include infoset
1040      *                      augmentations.
1041      *
1042      * @throws XNIException Thrown by handler to signal an error.
1043      */
1044     public void unparsedEntityDecl(String name, XMLResourceIdentifier identifier,
1045                                    String notation,
1046                                    Augmentations augs) throws XNIException {
1047         try {
1048             // SAX2 extension
1049             if (fDTDHandler != null) {
1050                 String publicId = identifier.getPublicId();
1051                 String systemId = fResolveDTDURIs ?
1052                     identifier.getExpandedSystemId() : identifier.getLiteralSystemId();
1053                 fDTDHandler.unparsedEntityDecl(name, publicId, systemId, notation);
1054             }
1055         }
1056         catch (SAXException e) {
1057             throw new XNIException(e);
1058         }
1059 
1060     } // unparsedEntityDecl(String,XMLResourceIdentifier, String, Augmentations)
1061 
1062     /**
1063      * A notation declaration
1064      *
1065      * @param name     The name of the notation.
1066      * @param identifier    An object containing all location information
1067      *                      pertinent to this notation.
1068      * @param augs Additional information that may include infoset
1069      *                      augmentations.
1070      *
1071      * @throws XNIException Thrown by handler to signal an error.
1072      */
1073     public void notationDecl(String name, XMLResourceIdentifier identifier,
1074                              Augmentations augs) throws XNIException {
1075         try {
1076             // SAX1 and SAX2
1077             if (fDTDHandler != null) {
1078                 String publicId = identifier.getPublicId();
1079                 String systemId = fResolveDTDURIs ?
1080                     identifier.getExpandedSystemId() : identifier.getLiteralSystemId();
1081                 fDTDHandler.notationDecl(name, publicId, systemId);
1082             }
1083         }
1084         catch (SAXException e) {
1085             throw new XNIException(e);
1086         }
1087 
1088     } // notationDecl(String,XMLResourceIdentifier, Augmentations)
1089 
1090     /**
1091      * The end of the DTD.
1092      *
1093      * @param augs Additional information that may include infoset
1094      *                      augmentations.
1095      *
1096      * @throws XNIException Thrown by handler to signal an error.
1097      */
1098     public void endDTD(Augmentations augs) throws XNIException {
1099         fInDTD = false;
1100 
1101         try {
1102             // SAX2 extension
1103             if (fLexicalHandler != null) {
1104                 fLexicalHandler.endDTD();
1105             }
1106         }
1107         catch (SAXException e) {
1108             throw new XNIException(e);
1109         }
1110         if(fDeclaredAttrs != null) {
1111             // help out the GC
1112             fDeclaredAttrs.clear();
1113         }
1114 
1115     } // endDTD()
1116 
1117     //
1118     // Parser and XMLReader methods
1119     //
1120 
1121     /**
1122      * Parses the input source specified by the given system identifier.
1123      * <p>
1124      * This method is equivalent to the following:
1125      * <pre>
1126      *     parse(new InputSource(systemId));
1127      * </pre>
1128      *
1129      * @param systemId The system identifier (URI).
1130      *
1131      * @exception org.xml.sax.SAXException Throws exception on SAX error.
1132      * @exception java.io.IOException Throws exception on i/o error.
1133      */
1134     public void parse(String systemId) throws SAXException, IOException {
1135 
1136         // parse document
1137         XMLInputSource source = new XMLInputSource(null, systemId, null, false);
1138         try {
1139             parse(source);
1140         }
1141 
1142         // wrap XNI exceptions as SAX exceptions
1143         catch (XMLParseException e) {
1144             Exception ex = e.getException();
1145             if (ex == null) {
1146                 // must be a parser exception; mine it for locator info and throw
1147                 // a SAXParseException
1148                 LocatorImpl locatorImpl = new LocatorImpl(){
1149                     public String getXMLVersion() {
1150                         return fVersion;
1151                     }
1152                     // since XMLParseExceptions know nothing about encoding,
1153                     // we cannot return anything meaningful in this context.
1154                     // We *could* consult the LocatorProxy, but the
1155                     // application can do this itself if it wishes to possibly
1156                     // be mislead.
1157                     public String getEncoding() {
1158                         return null;
1159                     }
1160                 };
1161                 locatorImpl.setPublicId(e.getPublicId());
1162                 locatorImpl.setSystemId(e.getExpandedSystemId());
1163                 locatorImpl.setLineNumber(e.getLineNumber());
1164                 locatorImpl.setColumnNumber(e.getColumnNumber());
1165                 throw new SAXParseException(e.getMessage(), locatorImpl);
1166             }
1167             if (ex instanceof SAXException) {
1168                 // why did we create an XMLParseException?
1169                 throw (SAXException)ex;
1170             }
1171             if (ex instanceof IOException) {
1172                 throw (IOException)ex;
1173             }
1174             throw new SAXException(ex);
1175         }
1176         catch (XNIException e) {
1177             Exception ex = e.getException();
1178             if (ex == null) {
1179                 throw new SAXException(e.getMessage());
1180             }
1181             if (ex instanceof SAXException) {
1182                 throw (SAXException)ex;
1183             }
1184             if (ex instanceof IOException) {
1185                 throw (IOException)ex;
1186             }
1187             throw new SAXException(ex);
1188         }
1189 
1190     } // parse(String)
1191 
1192     /**
1193      * parse
1194      *
1195      * @param inputSource
1196      *
1197      * @exception org.xml.sax.SAXException
1198      * @exception java.io.IOException
1199      */
1200     public void parse(InputSource inputSource)
1201         throws SAXException, IOException {
1202 
1203         // parse document
1204         try {
1205             XMLInputSource xmlInputSource =
1206                 new XMLInputSource(inputSource.getPublicId(),
1207                                    inputSource.getSystemId(),
1208                                    null, false);
1209             xmlInputSource.setByteStream(inputSource.getByteStream());
1210             xmlInputSource.setCharacterStream(inputSource.getCharacterStream());
1211             xmlInputSource.setEncoding(inputSource.getEncoding());
1212             parse(xmlInputSource);
1213         }
1214 
1215         // wrap XNI exceptions as SAX exceptions
1216         catch (XMLParseException e) {
1217             Exception ex = e.getException();
1218             if (ex == null) {
1219                 // must be a parser exception; mine it for locator info and throw
1220                 // a SAXParseException
1221                 LocatorImpl locatorImpl = new LocatorImpl() {
1222                     public String getXMLVersion() {
1223                         return fVersion;
1224                     }
1225                     // since XMLParseExceptions know nothing about encoding,
1226                     // we cannot return anything meaningful in this context.
1227                     // We *could* consult the LocatorProxy, but the
1228                     // application can do this itself if it wishes to possibly
1229                     // be mislead.
1230                     public String getEncoding() {
1231                         return null;
1232                     }
1233                 };
1234                 locatorImpl.setPublicId(e.getPublicId());
1235                 locatorImpl.setSystemId(e.getExpandedSystemId());
1236                 locatorImpl.setLineNumber(e.getLineNumber());
1237                 locatorImpl.setColumnNumber(e.getColumnNumber());
1238                 throw new SAXParseException(e.getMessage(), locatorImpl);
1239             }
1240             if (ex instanceof SAXException) {
1241                 // why did we create an XMLParseException?
1242                 throw (SAXException)ex;
1243             }
1244             if (ex instanceof IOException) {
1245                 throw (IOException)ex;
1246             }
1247             throw new SAXException(ex);
1248         }
1249         catch (XNIException e) {
1250             Exception ex = e.getException();
1251             if (ex == null) {
1252                 throw new SAXException(e.getMessage());
1253             }
1254             if (ex instanceof SAXException) {
1255                 throw (SAXException)ex;
1256             }
1257             if (ex instanceof IOException) {
1258                 throw (IOException)ex;
1259             }
1260             throw new SAXException(ex);
1261         }
1262 
1263     } // parse(InputSource)
1264 
1265     /**
1266      * Sets the resolver used to resolve external entities. The EntityResolver
1267      * interface supports resolution of public and system identifiers.
1268      *
1269      * @param resolver The new entity resolver. Passing a null value will
1270      *                 uninstall the currently installed resolver.
1271      */
1272     public void setEntityResolver(EntityResolver resolver) {
1273 
1274         try {
1275             XMLEntityResolver xer = (XMLEntityResolver) fConfiguration.getProperty(ENTITY_RESOLVER);
1276             if (fUseEntityResolver2 && resolver instanceof EntityResolver2) {
1277                 if (xer instanceof EntityResolver2Wrapper) {
1278                     EntityResolver2Wrapper er2w = (EntityResolver2Wrapper) xer;
1279                     er2w.setEntityResolver((EntityResolver2) resolver);
1280                 }
1281                 else {
1282                     fConfiguration.setProperty(ENTITY_RESOLVER,
1283                             new EntityResolver2Wrapper((EntityResolver2) resolver));
1284                 }
1285             }
1286             else {
1287                 if (xer instanceof EntityResolverWrapper) {
1288                     EntityResolverWrapper erw = (EntityResolverWrapper) xer;
1289                     erw.setEntityResolver(resolver);
1290                 }
1291                 else {
1292                     fConfiguration.setProperty(ENTITY_RESOLVER,
1293                             new EntityResolverWrapper(resolver));
1294                 }
1295             }
1296         }
1297         catch (XMLConfigurationException e) {
1298             // do nothing
1299         }
1300 
1301     } // setEntityResolver(EntityResolver)
1302 
1303     /**
1304      * Return the current entity resolver.
1305      *
1306      * @return The current entity resolver, or null if none
1307      *         has been registered.
1308      * @see #setEntityResolver
1309      */
1310     public EntityResolver getEntityResolver() {
1311 
1312         EntityResolver entityResolver = null;
1313         try {
1314             XMLEntityResolver xmlEntityResolver =
1315                 (XMLEntityResolver)fConfiguration.getProperty(ENTITY_RESOLVER);
1316             if (xmlEntityResolver != null) {
1317                 if (xmlEntityResolver instanceof EntityResolverWrapper) {
1318                     entityResolver =
1319                         ((EntityResolverWrapper) xmlEntityResolver).getEntityResolver();
1320                 }
1321                 else if (xmlEntityResolver instanceof EntityResolver2Wrapper) {
1322                     entityResolver =
1323                         ((EntityResolver2Wrapper) xmlEntityResolver).getEntityResolver();
1324                 }
1325             }
1326         }
1327         catch (XMLConfigurationException e) {
1328             // do nothing
1329         }
1330         return entityResolver;
1331 
1332     } // getEntityResolver():EntityResolver
1333 
1334     /**
1335      * Allow an application to register an error event handler.
1336      *
1337      * <p>If the application does not register an error handler, all
1338      * error events reported by the SAX parser will be silently
1339      * ignored; however, normal processing may not continue.  It is
1340      * highly recommended that all SAX applications implement an
1341      * error handler to avoid unexpected bugs.</p>
1342      *
1343      * <p>Applications may register a new or different handler in the
1344      * middle of a parse, and the SAX parser must begin using the new
1345      * handler immediately.</p>
1346      *
1347      * @param errorHandler The error handler.
1348      * @see #getErrorHandler
1349      */
1350     public void setErrorHandler(ErrorHandler errorHandler) {
1351 
1352         try {
1353             XMLErrorHandler xeh = (XMLErrorHandler) fConfiguration.getProperty(ERROR_HANDLER);
1354             if (xeh instanceof ErrorHandlerWrapper) {
1355                 ErrorHandlerWrapper ehw = (ErrorHandlerWrapper) xeh;
1356                 ehw.setErrorHandler(errorHandler);
1357             }
1358             else {
1359                 fConfiguration.setProperty(ERROR_HANDLER,
1360                         new ErrorHandlerWrapper(errorHandler));
1361             }
1362         }
1363         catch (XMLConfigurationException e) {
1364             // do nothing
1365         }
1366 
1367     } // setErrorHandler(ErrorHandler)
1368 
1369     /**
1370      * Return the current error handler.
1371      *
1372      * @return The current error handler, or null if none
1373      *         has been registered.
1374      * @see #setErrorHandler
1375      */
1376     public ErrorHandler getErrorHandler() {
1377 
1378         ErrorHandler errorHandler = null;
1379         try {
1380             XMLErrorHandler xmlErrorHandler =
1381                 (XMLErrorHandler)fConfiguration.getProperty(ERROR_HANDLER);
1382             if (xmlErrorHandler != null &&
1383                 xmlErrorHandler instanceof ErrorHandlerWrapper) {
1384                 errorHandler = ((ErrorHandlerWrapper)xmlErrorHandler).getErrorHandler();
1385             }
1386         }
1387         catch (XMLConfigurationException e) {
1388             // do nothing
1389         }
1390         return errorHandler;
1391 
1392     } // getErrorHandler():ErrorHandler
1393 
1394     /**
1395      * Set the locale to use for messages.
1396      *
1397      * @param locale The locale object to use for localization of messages.
1398      *
1399      * @exception SAXException An exception thrown if the parser does not
1400      *                         support the specified locale.
1401      *
1402      * @see org.xml.sax.Parser
1403      */
1404     public void setLocale(Locale locale) throws SAXException {
1405         //REVISIT:this methods is not part of SAX2 interfaces, we should throw exception
1406         //if any application uses SAX2 and sets locale also. -nb
1407         fConfiguration.setLocale(locale);
1408 
1409     } // setLocale(Locale)
1410 
1411     /**
1412      * Allow an application to register a DTD event handler.
1413      * <p>
1414      * If the application does not register a DTD handler, all DTD
1415      * events reported by the SAX parser will be silently ignored.
1416      * <p>
1417      * Applications may register a new or different handler in the
1418      * middle of a parse, and the SAX parser must begin using the new
1419      * handler immediately.
1420      *
1421      * @param dtdHandler The DTD handler.
1422      *
1423 
1424      * @see #getDTDHandler
1425      */
1426     public void setDTDHandler(DTDHandler dtdHandler) {
1427         fDTDHandler = dtdHandler;
1428     } // setDTDHandler(DTDHandler)
1429 
1430     //
1431     // Parser methods
1432     //
1433 
1434     /**
1435      * Allow an application to register a document event handler.
1436      * <p>
1437      * If the application does not register a document handler, all
1438      * document events reported by the SAX parser will be silently
1439      * ignored (this is the default behaviour implemented by
1440      * HandlerBase).
1441      * <p>
1442      * Applications may register a new or different handler in the
1443      * middle of a parse, and the SAX parser must begin using the new
1444      * handler immediately.
1445      *
1446      * @param documentHandler The document handler.
1447      */
1448     public void setDocumentHandler(DocumentHandler documentHandler) {
1449         fDocumentHandler = documentHandler;
1450     } // setDocumentHandler(DocumentHandler)
1451 
1452     //
1453     // XMLReader methods
1454     //
1455 
1456     /**
1457      * Allow an application to register a content event handler.
1458      * <p>
1459      * If the application does not register a content handler, all
1460      * content events reported by the SAX parser will be silently
1461      * ignored.
1462      * <p>
1463      * Applications may register a new or different handler in the
1464      * middle of a parse, and the SAX parser must begin using the new
1465      * handler immediately.
1466      *
1467      * @param contentHandler The content handler.
1468      *
1469      * @see #getContentHandler
1470      */
1471     public void setContentHandler(ContentHandler contentHandler) {
1472         fContentHandler = contentHandler;
1473     } // setContentHandler(ContentHandler)
1474 
1475     /**
1476      * Return the current content handler.
1477      *
1478      * @return The current content handler, or null if none
1479      *         has been registered.
1480      *
1481      * @see #setContentHandler
1482      */
1483     public ContentHandler getContentHandler() {
1484         return fContentHandler;
1485     } // getContentHandler():ContentHandler
1486 
1487     /**
1488      * Return the current DTD handler.
1489      *
1490      * @return The current DTD handler, or null if none
1491      *         has been registered.
1492      * @see #setDTDHandler
1493      */
1494     public DTDHandler getDTDHandler() {
1495         return fDTDHandler;
1496     } // getDTDHandler():DTDHandler
1497 
1498     /**
1499      * Set the state of any feature in a SAX2 parser.  The parser
1500      * might not recognize the feature, and if it does recognize
1501      * it, it might not be able to fulfill the request.
1502      *
1503      * @param featureId The unique identifier (URI) of the feature.
1504      * @param state The requested state of the feature (true or false).
1505      *
1506      * @exception SAXNotRecognizedException If the
1507      *            requested feature is not known.
1508      * @exception SAXNotSupportedException If the
1509      *            requested feature is known, but the requested
1510      *            state is not supported.
1511      */
1512     public void setFeature(String featureId, boolean state)
1513         throws SAXNotRecognizedException, SAXNotSupportedException {
1514 
1515         try {
1516             //
1517             // SAX2 Features
1518             //
1519 
1520             if (featureId.startsWith(Constants.SAX_FEATURE_PREFIX)) {
1521                 final int suffixLength = featureId.length() - Constants.SAX_FEATURE_PREFIX.length();
1522 
1523                 // http://xml.org/sax/features/namespaces
1524                 if (suffixLength == Constants.NAMESPACES_FEATURE.length() &&
1525                     featureId.endsWith(Constants.NAMESPACES_FEATURE)) {
1526                     fConfiguration.setFeature(featureId, state);
1527                     fNamespaces = state;
1528                     return;
1529                 }
1530 
1531                 // http://xml.org/sax/features/namespace-prefixes
1532                 //   controls the reporting of raw prefixed names and Namespace
1533                 //   declarations (xmlns* attributes): when this feature is false
1534                 //   (the default), raw prefixed names may optionally be reported,
1535                 //   and xmlns* attributes must not be reported.
1536                 //
1537                 if (suffixLength == Constants.NAMESPACE_PREFIXES_FEATURE.length() &&
1538                     featureId.endsWith(Constants.NAMESPACE_PREFIXES_FEATURE)) {
1539                     fConfiguration.setFeature(featureId, state);
1540                     fNamespacePrefixes = state;
1541                     return;
1542                 }
1543 
1544                 // http://xml.org/sax/features/string-interning
1545                 //   controls the use of java.lang.String#intern() for strings
1546                 //   passed to SAX handlers.
1547                 //
1548                 if (suffixLength == Constants.STRING_INTERNING_FEATURE.length() &&
1549                     featureId.endsWith(Constants.STRING_INTERNING_FEATURE)) {
1550                     if (!state) {
1551                         throw new SAXNotSupportedException(
1552                             SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1553                             "false-not-supported", new Object [] {featureId}));
1554                     }
1555                     return;
1556                 }
1557 
1558                 // http://xml.org/sax/features/lexical-handler/parameter-entities
1559                 //   controls whether the beginning and end of parameter entities
1560                 //   will be reported to the LexicalHandler.
1561                 //
1562                 if (suffixLength == Constants.LEXICAL_HANDLER_PARAMETER_ENTITIES_FEATURE.length() &&
1563                     featureId.endsWith(Constants.LEXICAL_HANDLER_PARAMETER_ENTITIES_FEATURE)) {
1564                     fLexicalHandlerParameterEntities = state;
1565                     return;
1566                 }
1567 
1568                 // http://xml.org/sax/features/resolve-dtd-uris
1569                 //   controls whether system identifiers will be absolutized relative to
1570                 //   their base URIs before reporting.
1571                 //
1572                 if (suffixLength == Constants.RESOLVE_DTD_URIS_FEATURE.length() &&
1573                     featureId.endsWith(Constants.RESOLVE_DTD_URIS_FEATURE)) {
1574                     fResolveDTDURIs = state;
1575                     return;
1576                 }
1577 
1578                 // http://xml.org/sax/features/unicode-normalization-checking
1579                 //   controls whether Unicode normalization checking is performed
1580                 //   as per Appendix B of the XML 1.1 specification
1581                 //
1582                 if (suffixLength == Constants.UNICODE_NORMALIZATION_CHECKING_FEATURE.length() &&
1583                     featureId.endsWith(Constants.UNICODE_NORMALIZATION_CHECKING_FEATURE)) {
1584                     // REVISIT: Allow this feature to be set once Unicode normalization
1585                     // checking is supported -- mrglavas.
1586                     if (state) {
1587                         throw new SAXNotSupportedException(
1588                             SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1589                             "true-not-supported", new Object [] {featureId}));
1590                     }
1591                     return;
1592                 }
1593 
1594                 // http://xml.org/sax/features/xmlns-uris
1595                 //   controls whether the parser reports that namespace declaration
1596                 //   attributes as being in the namespace: http://www.w3.org/2000/xmlns/
1597                 //
1598                 if (suffixLength == Constants.XMLNS_URIS_FEATURE.length() &&
1599                     featureId.endsWith(Constants.XMLNS_URIS_FEATURE)) {
1600                     fXMLNSURIs = state;
1601                     return;
1602                 }
1603 
1604                 // http://xml.org/sax/features/use-entity-resolver2
1605                 //   controls whether the methods of an object implementing
1606                 //   org.xml.sax.ext.EntityResolver2 will be used by the parser.
1607                 //
1608                 if (suffixLength == Constants.USE_ENTITY_RESOLVER2_FEATURE.length() &&
1609                     featureId.endsWith(Constants.USE_ENTITY_RESOLVER2_FEATURE)) {
1610                     if (state != fUseEntityResolver2) {
1611                         fUseEntityResolver2 = state;
1612                         // Refresh EntityResolver wrapper.
1613                         setEntityResolver(getEntityResolver());
1614                     }
1615                     return;
1616                 }
1617 
1618                 //
1619                 // Read only features.
1620                 //
1621 
1622                 // http://xml.org/sax/features/is-standalone
1623                 //   reports whether the document specified a standalone document declaration.
1624                 // http://xml.org/sax/features/use-attributes2
1625                 //   reports whether Attributes objects passed to startElement also implement
1626                 //   the org.xml.sax.ext.Attributes2 interface.
1627                 // http://xml.org/sax/features/use-locator2
1628                 //   reports whether Locator objects passed to setDocumentLocator also implement
1629                 //   the org.xml.sax.ext.Locator2 interface.
1630                 // http://xml.org/sax/features/xml-1.1
1631                 //   reports whether the parser supports both XML 1.1 and XML 1.0.
1632                 if ((suffixLength == Constants.IS_STANDALONE_FEATURE.length() &&
1633                     featureId.endsWith(Constants.IS_STANDALONE_FEATURE)) ||
1634                     (suffixLength == Constants.USE_ATTRIBUTES2_FEATURE.length() &&
1635                     featureId.endsWith(Constants.USE_ATTRIBUTES2_FEATURE)) ||
1636                     (suffixLength == Constants.USE_LOCATOR2_FEATURE.length() &&
1637                     featureId.endsWith(Constants.USE_LOCATOR2_FEATURE)) ||
1638                     (suffixLength == Constants.XML_11_FEATURE.length() &&
1639                     featureId.endsWith(Constants.XML_11_FEATURE))) {
1640                     throw new SAXNotSupportedException(
1641                         SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1642                         "feature-read-only", new Object [] {featureId}));
1643                 }
1644 
1645 
1646                 //
1647                 // Drop through and perform default processing
1648                 //
1649             }
1650             else if (featureId.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
1651                 if (state) {
1652                     if (fConfiguration.getProperty(SECURITY_MANAGER )==null) {
1653                         fConfiguration.setProperty(SECURITY_MANAGER, new XMLSecurityManager());
1654                     }
1655                 }
1656             }
1657 
1658             //
1659             // Default handling
1660             //
1661 
1662             fConfiguration.setFeature(featureId, state);
1663         }
1664         catch (XMLConfigurationException e) {
1665             String identifier = e.getIdentifier();
1666             if (e.getType() == Status.NOT_RECOGNIZED) {
1667                 throw new SAXNotRecognizedException(
1668                     SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1669                     "feature-not-recognized", new Object [] {identifier}));
1670             }
1671             else {
1672                 throw new SAXNotSupportedException(
1673                     SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1674                     "feature-not-supported", new Object [] {identifier}));
1675             }
1676         }
1677 
1678     } // setFeature(String,boolean)
1679 
1680     /**
1681      * Query the state of a feature.
1682      *
1683      * Query the current state of any feature in a SAX2 parser.  The
1684      * parser might not recognize the feature.
1685      *
1686      * @param featureId The unique identifier (URI) of the feature
1687      *                  being set.
1688      * @return The current state of the feature.
1689      * @exception org.xml.sax.SAXNotRecognizedException If the
1690      *            requested feature is not known.
1691      * @exception SAXNotSupportedException If the
1692      *            requested feature is known but not supported.
1693      */
1694     public boolean getFeature(String featureId)
1695         throws SAXNotRecognizedException, SAXNotSupportedException {
1696 
1697         try {
1698             //
1699             // SAX2 Features
1700             //
1701 
1702             if (featureId.startsWith(Constants.SAX_FEATURE_PREFIX)) {
1703                 final int suffixLength = featureId.length() - Constants.SAX_FEATURE_PREFIX.length();
1704 
1705                 // http://xml.org/sax/features/namespace-prefixes
1706                 //   controls the reporting of raw prefixed names and Namespace
1707                 //   declarations (xmlns* attributes): when this feature is false
1708                 //   (the default), raw prefixed names may optionally be reported,
1709                 //   and xmlns* attributes must not be reported.
1710                 //
1711                 if (suffixLength == Constants.NAMESPACE_PREFIXES_FEATURE.length() &&
1712                     featureId.endsWith(Constants.NAMESPACE_PREFIXES_FEATURE)) {
1713                     boolean state = fConfiguration.getFeature(featureId);
1714                     return state;
1715                 }
1716                 // http://xml.org/sax/features/string-interning
1717                 //   controls the use of java.lang.String#intern() for strings
1718                 //   passed to SAX handlers.
1719                 //
1720                 if (suffixLength == Constants.STRING_INTERNING_FEATURE.length() &&
1721                     featureId.endsWith(Constants.STRING_INTERNING_FEATURE)) {
1722                     return true;
1723                 }
1724 
1725                 // http://xml.org/sax/features/is-standalone
1726                 //   reports whether the document specified a standalone document declaration.
1727                 //
1728                 if (suffixLength == Constants.IS_STANDALONE_FEATURE.length() &&
1729                     featureId.endsWith(Constants.IS_STANDALONE_FEATURE)) {
1730                     return fStandalone;
1731                 }
1732 
1733                 // http://xml.org/sax/features/xml-1.1
1734                 //   reports whether the parser supports both XML 1.1 and XML 1.0.
1735                 //
1736                 if (suffixLength == Constants.XML_11_FEATURE.length() &&
1737                     featureId.endsWith(Constants.XML_11_FEATURE)) {
1738                     return (fConfiguration instanceof XML11Configurable);
1739                 }
1740 
1741                 // http://xml.org/sax/features/lexical-handler/parameter-entities
1742                 //   controls whether the beginning and end of parameter entities
1743                 //   will be reported to the LexicalHandler.
1744                 //
1745                 if (suffixLength == Constants.LEXICAL_HANDLER_PARAMETER_ENTITIES_FEATURE.length() &&
1746                     featureId.endsWith(Constants.LEXICAL_HANDLER_PARAMETER_ENTITIES_FEATURE)) {
1747                     return fLexicalHandlerParameterEntities;
1748                 }
1749 
1750                 // http://xml.org/sax/features/resolve-dtd-uris
1751                 //   controls whether system identifiers will be absolutized relative to
1752                 //   their base URIs before reporting.
1753                 if (suffixLength == Constants.RESOLVE_DTD_URIS_FEATURE.length() &&
1754                     featureId.endsWith(Constants.RESOLVE_DTD_URIS_FEATURE)) {
1755                     return fResolveDTDURIs;
1756                 }
1757 
1758                 // http://xml.org/sax/features/xmlns-uris
1759                 //   controls whether the parser reports that namespace declaration
1760                 //   attributes as being in the namespace: http://www.w3.org/2000/xmlns/
1761                 //
1762                 if (suffixLength == Constants.XMLNS_URIS_FEATURE.length() &&
1763                     featureId.endsWith(Constants.XMLNS_URIS_FEATURE)) {
1764                     return fXMLNSURIs;
1765                 }
1766 
1767                 // http://xml.org/sax/features/unicode-normalization-checking
1768                 //   controls whether Unicode normalization checking is performed
1769                 //   as per Appendix B of the XML 1.1 specification
1770                 //
1771                 if (suffixLength == Constants.UNICODE_NORMALIZATION_CHECKING_FEATURE.length() &&
1772                     featureId.endsWith(Constants.UNICODE_NORMALIZATION_CHECKING_FEATURE)) {
1773                     // REVISIT: Allow this feature to be set once Unicode normalization
1774                     // checking is supported -- mrglavas.
1775                     return false;
1776                 }
1777 
1778                 // http://xml.org/sax/features/use-entity-resolver2
1779                 //   controls whether the methods of an object implementing
1780                 //   org.xml.sax.ext.EntityResolver2 will be used by the parser.
1781                 //
1782                 if (suffixLength == Constants.USE_ENTITY_RESOLVER2_FEATURE.length() &&
1783                     featureId.endsWith(Constants.USE_ENTITY_RESOLVER2_FEATURE)) {
1784                     return fUseEntityResolver2;
1785                 }
1786 
1787                 // http://xml.org/sax/features/use-attributes2
1788                 //   reports whether Attributes objects passed to startElement also implement
1789                 //   the org.xml.sax.ext.Attributes2 interface.
1790                 // http://xml.org/sax/features/use-locator2
1791                 //   reports whether Locator objects passed to setDocumentLocator also implement
1792                 //   the org.xml.sax.ext.Locator2 interface.
1793                 //
1794                 if ((suffixLength == Constants.USE_ATTRIBUTES2_FEATURE.length() &&
1795                     featureId.endsWith(Constants.USE_ATTRIBUTES2_FEATURE)) ||
1796                     (suffixLength == Constants.USE_LOCATOR2_FEATURE.length() &&
1797                     featureId.endsWith(Constants.USE_LOCATOR2_FEATURE))) {
1798                     return true;
1799                 }
1800 
1801 
1802                 //
1803                 // Drop through and perform default processing
1804                 //
1805             }
1806 
1807             //
1808             // Xerces Features
1809             //
1810 
1811             /*
1812             else if (featureId.startsWith(XERCES_FEATURES_PREFIX)) {
1813                 //
1814                 // Drop through and perform default processing
1815                 //
1816             }
1817             */
1818 
1819             return fConfiguration.getFeature(featureId);
1820         }
1821         catch (XMLConfigurationException e) {
1822             String identifier = e.getIdentifier();
1823             if (e.getType() == Status.NOT_RECOGNIZED) {
1824                 throw new SAXNotRecognizedException(
1825                     SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1826                     "feature-not-recognized", new Object [] {identifier}));
1827             }
1828             else {
1829                 throw new SAXNotSupportedException(
1830                     SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1831                     "feature-not-supported", new Object [] {identifier}));
1832             }
1833         }
1834 
1835     } // getFeature(String):boolean
1836 
1837     /**
1838      * Set the value of any property in a SAX2 parser.  The parser
1839      * might not recognize the property, and if it does recognize
1840      * it, it might not support the requested value.
1841      *
1842      * @param propertyId The unique identifier (URI) of the property
1843      *                   being set.
1844      * @param value The value to which the property is being set.
1845      *
1846      * @exception SAXNotRecognizedException If the
1847      *            requested property is not known.
1848      * @exception SAXNotSupportedException If the
1849      *            requested property is known, but the requested
1850      *            value is not supported.
1851      */
1852     public void setProperty(String propertyId, Object value)
1853         throws SAXNotRecognizedException, SAXNotSupportedException {
1854 
1855         try {
1856             //
1857             // SAX2 core properties
1858             //
1859 
1860             if (propertyId.startsWith(Constants.SAX_PROPERTY_PREFIX)) {
1861                 final int suffixLength = propertyId.length() - Constants.SAX_PROPERTY_PREFIX.length();
1862 
1863                 //
1864                 // http://xml.org/sax/properties/lexical-handler
1865                 // Value type: org.xml.sax.ext.LexicalHandler
1866                 // Access: read/write, pre-parse only
1867                 //   Set the lexical event handler.
1868                 //
1869                 if (suffixLength == Constants.LEXICAL_HANDLER_PROPERTY.length() &&
1870                     propertyId.endsWith(Constants.LEXICAL_HANDLER_PROPERTY)) {
1871                     try {
1872                         setLexicalHandler((LexicalHandler)value);
1873                     }
1874                     catch (ClassCastException e) {
1875                         throw new SAXNotSupportedException(
1876                             SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1877                             "incompatible-class", new Object [] {propertyId, "org.xml.sax.ext.LexicalHandler"}));
1878                     }
1879                     return;
1880                 }
1881                 //
1882                 // http://xml.org/sax/properties/declaration-handler
1883                 // Value type: org.xml.sax.ext.DeclHandler
1884                 // Access: read/write, pre-parse only
1885                 //   Set the DTD declaration event handler.
1886                 //
1887                 if (suffixLength == Constants.DECLARATION_HANDLER_PROPERTY.length() &&
1888                     propertyId.endsWith(Constants.DECLARATION_HANDLER_PROPERTY)) {
1889                     try {
1890                         setDeclHandler((DeclHandler)value);
1891                     }
1892                     catch (ClassCastException e) {
1893                         throw new SAXNotSupportedException(
1894                             SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1895                             "incompatible-class", new Object [] {propertyId, "org.xml.sax.ext.DeclHandler"}));
1896                     }
1897                     return;
1898                 }
1899                 //
1900                 // http://xml.org/sax/properties/dom-node
1901                 // Value type: DOM Node
1902                 // Access: read-only
1903                 //   Get the DOM node currently being visited, if the SAX parser is
1904                 //   iterating over a DOM tree.  If the parser recognises and
1905                 //   supports this property but is not currently visiting a DOM
1906                 //   node, it should return null (this is a good way to check for
1907                 //   availability before the parse begins).
1908                 // http://xml.org/sax/properties/document-xml-version
1909                 // Value type: java.lang.String
1910                 // Access: read-only
1911                 //   The literal string describing the actual XML version of the document.
1912                 //
1913                 if ((suffixLength == Constants.DOM_NODE_PROPERTY.length() &&
1914                     propertyId.endsWith(Constants.DOM_NODE_PROPERTY)) ||
1915                     (suffixLength == Constants.DOCUMENT_XML_VERSION_PROPERTY.length() &&
1916                     propertyId.endsWith(Constants.DOCUMENT_XML_VERSION_PROPERTY))) {
1917                     throw new SAXNotSupportedException(
1918                         SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1919                         "property-read-only", new Object [] {propertyId}));
1920                 }
1921                 //
1922                 // Drop through and perform default processing
1923                 //
1924             }
1925 
1926             //
1927             // Xerces Properties
1928             //
1929 
1930             /*
1931             else if (propertyId.startsWith(XERCES_PROPERTIES_PREFIX)) {
1932                 //
1933                 // Drop through and perform default processing
1934                 //
1935             }
1936             */
1937 
1938             //
1939             // Perform default processing
1940             //
1941 
1942             fConfiguration.setProperty(propertyId, value);
1943         }
1944         catch (XMLConfigurationException e) {
1945             String identifier = e.getIdentifier();
1946             if (e.getType() == Status.NOT_RECOGNIZED) {
1947                 throw new SAXNotRecognizedException(
1948                     SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1949                     "property-not-recognized", new Object [] {identifier}));
1950             }
1951             else {
1952                 throw new SAXNotSupportedException(
1953                     SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
1954                     "property-not-supported", new Object [] {identifier}));
1955             }
1956         }
1957 
1958     } // setProperty(String,Object)
1959 
1960     /**
1961      * Query the value of a property.
1962      *
1963      * Return the current value of a property in a SAX2 parser.
1964      * The parser might not recognize the property.
1965      *
1966      * @param propertyId The unique identifier (URI) of the property
1967      *                   being set.
1968      * @return The current value of the property.
1969      * @exception org.xml.sax.SAXNotRecognizedException If the
1970      *            requested property is not known.
1971      * @exception SAXNotSupportedException If the
1972      *            requested property is known but not supported.
1973      */
1974     public Object getProperty(String propertyId)
1975         throws SAXNotRecognizedException, SAXNotSupportedException {
1976 
1977         try {
1978             //
1979             // SAX2 core properties
1980             //
1981 
1982             if (propertyId.startsWith(Constants.SAX_PROPERTY_PREFIX)) {
1983                 final int suffixLength = propertyId.length() - Constants.SAX_PROPERTY_PREFIX.length();
1984 
1985                 //
1986                 // http://xml.org/sax/properties/document-xml-version
1987                 // Value type: java.lang.String
1988                 // Access: read-only
1989                 //   The literal string describing the actual XML version of the document.
1990                 //
1991                 if (suffixLength == Constants.DOCUMENT_XML_VERSION_PROPERTY.length() &&
1992                     propertyId.endsWith(Constants.DOCUMENT_XML_VERSION_PROPERTY)) {
1993                     return fVersion;
1994                 }
1995 
1996                 //
1997                 // http://xml.org/sax/properties/lexical-handler
1998                 // Value type: org.xml.sax.ext.LexicalHandler
1999                 // Access: read/write, pre-parse only
2000                 //   Set the lexical event handler.
2001                 //
2002                 if (suffixLength == Constants.LEXICAL_HANDLER_PROPERTY.length() &&
2003                     propertyId.endsWith(Constants.LEXICAL_HANDLER_PROPERTY)) {
2004                     return getLexicalHandler();
2005                 }
2006                 //
2007                 // http://xml.org/sax/properties/declaration-handler
2008                 // Value type: org.xml.sax.ext.DeclHandler
2009                 // Access: read/write, pre-parse only
2010                 //   Set the DTD declaration event handler.
2011                 //
2012                 if (suffixLength == Constants.DECLARATION_HANDLER_PROPERTY.length() &&
2013                     propertyId.endsWith(Constants.DECLARATION_HANDLER_PROPERTY)) {
2014                     return getDeclHandler();
2015                 }
2016 
2017                 //
2018                 // http://xml.org/sax/properties/dom-node
2019                 // Value type: DOM Node
2020                 // Access: read-only
2021                 //   Get the DOM node currently being visited, if the SAX parser is
2022                 //   iterating over a DOM tree.  If the parser recognises and
2023                 //   supports this property but is not currently visiting a DOM
2024                 //   node, it should return null (this is a good way to check for
2025                 //   availability before the parse begins).
2026                 //
2027                 if (suffixLength == Constants.DOM_NODE_PROPERTY.length() &&
2028                     propertyId.endsWith(Constants.DOM_NODE_PROPERTY)) {
2029                     // we are not iterating a DOM tree
2030                     throw new SAXNotSupportedException(
2031                         SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
2032                         "dom-node-read-not-supported", null));
2033                 }
2034 
2035                 //
2036                 // Drop through and perform default processing
2037                 //
2038             }
2039 
2040             //
2041             // Xerces properties
2042             //
2043 
2044             /*
2045             else if (propertyId.startsWith(XERCES_PROPERTIES_PREFIX)) {
2046                 //
2047                 // Drop through and perform default processing
2048                 //
2049             }
2050             */
2051 
2052             //
2053             // Perform default processing
2054             //
2055 
2056             return fConfiguration.getProperty(propertyId);
2057         }
2058         catch (XMLConfigurationException e) {
2059             String identifier = e.getIdentifier();
2060             if (e.getType() == Status.NOT_RECOGNIZED) {
2061                 throw new SAXNotRecognizedException(
2062                     SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
2063                     "property-not-recognized", new Object [] {identifier}));
2064             }
2065             else {
2066                 throw new SAXNotSupportedException(
2067                     SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
2068                     "property-not-supported", new Object [] {identifier}));
2069             }
2070         }
2071 
2072     } // getProperty(String):Object
2073 
2074     //
2075     // Protected methods
2076     //
2077 
2078     // SAX2 core properties
2079 
2080     /**
2081      * Set the DTD declaration event handler.
2082      * <p>
2083      * This method is the equivalent to the property:
2084      * <pre>
2085      * http://xml.org/sax/properties/declaration-handler
2086      * </pre>
2087      *
2088      * @param handler The new handler.
2089      *
2090      * @see #getDeclHandler
2091      * @see #setProperty
2092      */
2093     protected void setDeclHandler(DeclHandler handler)
2094         throws SAXNotRecognizedException, SAXNotSupportedException {
2095 
2096         if (fParseInProgress) {
2097             throw new SAXNotSupportedException(
2098                 SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
2099                 "property-not-parsing-supported",
2100                 new Object [] {"http://xml.org/sax/properties/declaration-handler"}));
2101         }
2102         fDeclHandler = handler;
2103 
2104     } // setDeclHandler(DeclHandler)
2105 
2106     /**
2107      * Returns the DTD declaration event handler.
2108      *
2109      * @see #setDeclHandler
2110      */
2111     protected DeclHandler getDeclHandler()
2112         throws SAXNotRecognizedException, SAXNotSupportedException {
2113         return fDeclHandler;
2114     } // getDeclHandler():DeclHandler
2115 
2116     /**
2117      * Set the lexical event handler.
2118      * <p>
2119      * This method is the equivalent to the property:
2120      * <pre>
2121      * http://xml.org/sax/properties/lexical-handler
2122      * </pre>
2123      *
2124      * @param handler lexical event handler
2125      *
2126      * @see #getLexicalHandler
2127      * @see #setProperty
2128      */
2129     protected void setLexicalHandler(LexicalHandler handler)
2130         throws SAXNotRecognizedException, SAXNotSupportedException {
2131 
2132         if (fParseInProgress) {
2133             throw new SAXNotSupportedException(
2134                 SAXMessageFormatter.formatMessage(fConfiguration.getLocale(),
2135                 "property-not-parsing-supported",
2136                 new Object [] {"http://xml.org/sax/properties/lexical-handler"}));
2137         }
2138         fLexicalHandler = handler;
2139 
2140     } // setLexicalHandler(LexicalHandler)
2141 
2142     /**
2143      * Returns the lexical handler.
2144      *
2145      * @see #setLexicalHandler
2146      */
2147     protected LexicalHandler getLexicalHandler()
2148         throws SAXNotRecognizedException, SAXNotSupportedException {
2149         return fLexicalHandler;
2150     } // getLexicalHandler():LexicalHandler
2151 
2152     /**
2153      * Send startPrefixMapping events
2154      */
2155     protected final void startNamespaceMapping() throws SAXException{
2156         int count = fNamespaceContext.getDeclaredPrefixCount();
2157         if (count > 0) {
2158             String prefix = null;
2159             String uri = null;
2160             for (int i = 0; i < count; i++) {
2161                 prefix = fNamespaceContext.getDeclaredPrefixAt(i);
2162                 uri = fNamespaceContext.getURI(prefix);
2163                 fContentHandler.startPrefixMapping(prefix,
2164                     (uri == null) ? "" : uri);
2165             }
2166         }
2167     }
2168 
2169     /**
2170      * Send endPrefixMapping events
2171      */
2172     protected final void endNamespaceMapping() throws SAXException {
2173         int count = fNamespaceContext.getDeclaredPrefixCount();
2174         if (count > 0) {
2175             for (int i = 0; i < count; i++) {
2176                 fContentHandler.endPrefixMapping(fNamespaceContext.getDeclaredPrefixAt(i));
2177             }
2178         }
2179     }
2180 
2181     //
2182     // XMLDocumentParser methods
2183     //
2184 
2185     /**
2186      * Reset all components before parsing.
2187      *
2188      * @throws XNIException Thrown if an error occurs during initialization.
2189      */
2190     public void reset() throws XNIException {
2191         super.reset();
2192 
2193         // reset state
2194         fInDTD = false;
2195         fVersion = "1.0";
2196         fStandalone = false;
2197 
2198         // features
2199         fNamespaces = fConfiguration.getFeature(NAMESPACES);
2200         fNamespacePrefixes = fConfiguration.getFeature(NAMESPACE_PREFIXES);
2201         fAugmentations = null;
2202         fDeclaredAttrs = null;
2203 
2204     } // reset()
2205 
2206     //
2207     // Classes
2208     //
2209 
2210     protected class LocatorProxy
2211         implements Locator2 {
2212 
2213         //
2214         // Data
2215         //
2216 
2217         /** XML locator. */
2218         protected XMLLocator fLocator;
2219 
2220         //
2221         // Constructors
2222         //
2223 
2224         /** Constructs an XML locator proxy. */
2225         public LocatorProxy(XMLLocator locator) {
2226             fLocator = locator;
2227         }
2228 
2229         //
2230         // Locator methods
2231         //
2232 
2233         /** Public identifier. */
2234         public String getPublicId() {
2235             return fLocator.getPublicId();
2236         }
2237 
2238         /** System identifier. */
2239         public String getSystemId() {
2240             return fLocator.getExpandedSystemId();
2241         }
2242         /** Line number. */
2243         public int getLineNumber() {
2244             return fLocator.getLineNumber();
2245         }
2246 
2247         /** Column number. */
2248         public int getColumnNumber() {
2249             return fLocator.getColumnNumber();
2250         }
2251 
2252         // Locator2 methods
2253         public String getXMLVersion() {
2254             return fLocator.getXMLVersion();
2255         }
2256 
2257         public String getEncoding() {
2258             return fLocator.getEncoding();
2259         }
2260 
2261     } // class LocatorProxy
2262 
2263     protected static final class AttributesProxy
2264         implements AttributeList, Attributes2 {
2265 
2266         //
2267         // Data
2268         //
2269 
2270         /** XML attributes. */
2271         protected XMLAttributes fAttributes;
2272 
2273         //
2274         // Public methods
2275         //
2276 
2277         /** Sets the XML attributes. */
2278         public void setAttributes(XMLAttributes attributes) {
2279             fAttributes = attributes;
2280         } // setAttributes(XMLAttributes)
2281 
2282         public int getLength() {
2283             return fAttributes.getLength();
2284         }
2285 
2286         public String getName(int i) {
2287             return fAttributes.getQName(i);
2288         }
2289 
2290         public String getQName(int index) {
2291             return fAttributes.getQName(index);
2292         }
2293 
2294         public String getURI(int index) {
2295             // REVISIT: this hides the fact that internally we use
2296             //          null instead of empty string
2297             //          SAX requires URI to be a string or an empty string
2298             String uri= fAttributes.getURI(index);
2299             return uri != null ? uri : "";
2300         }
2301 
2302         public String getLocalName(int index) {
2303             return fAttributes.getLocalName(index);
2304         }
2305 
2306         public String getType(int i) {
2307             return fAttributes.getType(i);
2308         }
2309 
2310         public String getType(String name) {
2311             return fAttributes.getType(name);
2312         }
2313 
2314         public String getType(String uri, String localName) {
2315             return uri.equals("") ? fAttributes.getType(null, localName) :
2316                                     fAttributes.getType(uri, localName);
2317         }
2318 
2319         public String getValue(int i) {
2320             return fAttributes.getValue(i);
2321         }
2322 
2323         public String getValue(String name) {
2324             return fAttributes.getValue(name);
2325         }
2326 
2327         public String getValue(String uri, String localName) {
2328             return uri.equals("") ? fAttributes.getValue(null, localName) :
2329                                     fAttributes.getValue(uri, localName);
2330         }
2331 
2332         public int getIndex(String qName) {
2333             return fAttributes.getIndex(qName);
2334         }
2335 
2336         public int getIndex(String uri, String localPart) {
2337             return uri.equals("") ? fAttributes.getIndex(null, localPart) :
2338                                     fAttributes.getIndex(uri, localPart);
2339         }
2340 
2341         // Attributes2 methods
2342         // REVISIT: Localize exception messages. -- mrglavas
2343         public boolean isDeclared(int index) {
2344             if (index < 0 || index >= fAttributes.getLength()) {
2345                 throw new ArrayIndexOutOfBoundsException(index);
2346             }
2347             return Boolean.TRUE.equals(
2348                 fAttributes.getAugmentations(index).getItem(
2349                 Constants.ATTRIBUTE_DECLARED));
2350         }
2351 
2352         public boolean isDeclared(String qName) {
2353             int index = getIndex(qName);
2354             if (index == -1) {
2355                 throw new IllegalArgumentException(qName);
2356             }
2357             return Boolean.TRUE.equals(
2358                 fAttributes.getAugmentations(index).getItem(
2359                 Constants.ATTRIBUTE_DECLARED));
2360         }
2361 
2362         public boolean isDeclared(String uri, String localName) {
2363             int index = getIndex(uri, localName);
2364             if (index == -1) {
2365                 throw new IllegalArgumentException(localName);
2366             }
2367             return Boolean.TRUE.equals(
2368                 fAttributes.getAugmentations(index).getItem(
2369                 Constants.ATTRIBUTE_DECLARED));
2370         }
2371 
2372         public boolean isSpecified(int index) {
2373             if (index < 0 || index >= fAttributes.getLength()) {
2374                 throw new ArrayIndexOutOfBoundsException(index);
2375             }
2376             return fAttributes.isSpecified(index);
2377         }
2378 
2379         public boolean isSpecified(String qName) {
2380             int index = getIndex(qName);
2381             if (index == -1) {
2382                 throw new IllegalArgumentException(qName);
2383             }
2384             return fAttributes.isSpecified(index);
2385         }
2386 
2387         public boolean isSpecified(String uri, String localName) {
2388             int index = getIndex(uri, localName);
2389             if (index == -1) {
2390                 throw new IllegalArgumentException(localName);
2391             }
2392             return fAttributes.isSpecified(index);
2393         }
2394 
2395     } // class AttributesProxy
2396 
2397 
2398     // PSVIProvider methods
2399 
2400     public ElementPSVI getElementPSVI(){
2401         return (fAugmentations != null)?(ElementPSVI)fAugmentations.getItem(Constants.ELEMENT_PSVI):null;
2402     }
2403 
2404 
2405     public AttributePSVI getAttributePSVI(int index){
2406 
2407         return (AttributePSVI)fAttributesProxy.fAttributes.getAugmentations(index).getItem(Constants.ATTRIBUTE_PSVI);
2408     }
2409 
2410 
2411     public AttributePSVI getAttributePSVIByName(String uri,
2412                                                 String localname){
2413         return (AttributePSVI)fAttributesProxy.fAttributes.getAugmentations(uri, localname).getItem(Constants.ATTRIBUTE_PSVI);
2414     }
2415 
2416 } // class AbstractSAXParser
--- EOF ---