content: /*
   *  This file is part of AndroidIDE.
   *
   *  AndroidIDE is free software: you can redistribute it and/or modify
   *  it under the terms of the GNU General Public License as published by
   *  the Free Software Foundation, either version 3 of the License, or
   *  (at your option) any later version.
   *
   *  AndroidIDE is distributed in the hope that it will be useful,
   *  but WITHOUT ANY WARRANTY; without even the implied warranty of
   *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *  GNU General Public License for more details.
   *
   *  You should have received a copy of the GNU General Public License
   *   along with AndroidIDE.  If not, see <https://www.gnu.org/licenses/>.
   */
  
  /*
   * reserved comment block
   * DO NOT REMOVE OR ALTER!
   */
  /*
   * The Apache Software License, Version 1.1
   *
   *
   * Copyright (c) 2001-2003 The Apache Software Foundation.  All rights
   * reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions
   * are met:
   *
   * 1. Redistributions of source code must retain the above copyright
   *    notice, this list of conditions and the following disclaimer.
   *
   * 2. Redistributions in binary form must reproduce the above copyright
   *    notice, this list of conditions and the following disclaimer in
   *    the documentation and/or other materials provided with the
   *    distribution.
   *
   * 3. The end-user documentation included with the redistribution,
   *    if any, must include the following acknowledgment:
   *       "This product includes software developed by the
   *        Apache Software Foundation (http://www.apache.org/)."
   *    Alternately, this acknowledgment may appear in the software itself,
   *    if and wherever such third-party acknowledgments normally appear.
   *
   * 4. The names "Xerces" and "Apache Software Foundation" must
   *    not be used to endorse or promote products derived from this
   *    software without prior written permission. For written
   *    permission, please contact apache@apache.org.
   *
   * 5. Products derived from this software may not be called "Apache",
   *    nor may "Apache" appear in their name, without prior written
   *    permission of the Apache Software Foundation.
   *
   * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
   * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
   * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
   * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
   * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
   * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
   * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   * SUCH DAMAGE.
   * ====================================================================
   *
   * This software consists of voluntary contributions made by many
   * individuals on behalf of the Apache Software Foundation and was
   * originally based on software copyright (c) 1999, International
   * Business Machines, Inc., http://www.apache.org.  For more
   * information on the Apache Software Foundation, please see
   * <http://www.apache.org/>.
   */
  package jaxp.sun.org.apache.xerces.internal.xinclude;
  
  
  import java.util.Enumeration;
  import java.util.StringTokenizer;
  import java.util.Stack;
  
  import jaxp.sun.org.apache.xerces.internal.impl.Constants;
  import jaxp.sun.org.apache.xerces.internal.impl.XMLErrorReporter;
  import jaxp.sun.org.apache.xerces.internal.impl.dtd.DTDGrammar;
  import jaxp.sun.org.apache.xerces.internal.util.ParserConfigurationSettings;
  import jaxp.sun.org.apache.xerces.internal.xni.Augmentations;
  import jaxp.sun.org.apache.xerces.internal.xni.NamespaceContext;
  import jaxp.sun.org.apache.xerces.internal.xni.QName;
  import jaxp.sun.org.apache.xerces.internal.xni.XMLAttributes;
  import jaxp.sun.org.apache.xerces.internal.xni.XMLDocumentHandler;
  import jaxp.sun.org.apache.xerces.internal.xni.XMLLocator;
  import jaxp.sun.org.apache.xerces.internal.xni.XMLResourceIdentifier;
  import jaxp.sun.org.apache.xerces.internal.xni.XMLString;
  import jaxp.sun.org.apache.xerces.internal.xni.XNIException;
  import jaxp.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarDescription;
  import jaxp.sun.org.apache.xerces.internal.xni.grammars.XMLGrammarPool;
  import jaxp.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager;
  import jaxp.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;
  import jaxp.sun.org.apache.xerces.internal.xni.parser.XMLDocumentSource;
  import jaxp.sun.org.apache.xerces.internal.xni.parser.XMLEntityResolver;
  
  /**
   * @author Arun Yadav, Sun Microsystem
   */
  public class XPointerElementHandler implements XPointerSchema {
  
  
      // recognized features and properties
  
      /** Property identifier: error handler. */
      protected static final String ERROR_REPORTER =
      Constants.XERCES_PROPERTY_PREFIX + Constants.ERROR_REPORTER_PROPERTY;
  
      /** Property identifier: grammar pool . */
      protected static final String GRAMMAR_POOL =
      Constants.XERCES_PROPERTY_PREFIX + Constants.XMLGRAMMAR_POOL_PROPERTY;
  
      /** Property identifier: grammar pool . */
      protected static final String ENTITY_RESOLVER =
      Constants.XERCES_PROPERTY_PREFIX + Constants.ENTITY_RESOLVER_PROPERTY;
  
      protected static final String XPOINTER_SCHEMA =
      Constants.XERCES_PROPERTY_PREFIX + Constants.XPOINTER_SCHEMA_PROPERTY;
  
      /** Recognized features. */
      private static final String[] RECOGNIZED_FEATURES = {
      };
  
      /** Feature defaults. */
      private static final Boolean[] FEATURE_DEFAULTS = {
      };
  
      /** Recognized properties. */
  
      private static final String[] RECOGNIZED_PROPERTIES =
      { ERROR_REPORTER, GRAMMAR_POOL, ENTITY_RESOLVER, XPOINTER_SCHEMA };
  
      /** Property defaults. */
      private static final Object[] PROPERTY_DEFAULTS = { null, null, null,null };
  
      // Data
  
      protected XMLDocumentHandler fDocumentHandler;
      protected XMLDocumentSource fDocumentSource;
  
      protected XIncludeHandler fParentXIncludeHandler;
  
      protected XMLLocator fDocLocation;
      protected XIncludeNamespaceSupport fNamespaceContext;
      protected XMLErrorReporter fErrorReporter;
      protected XMLGrammarPool fGrammarPool;
      protected XMLGrammarDescription fGrammarDesc;
      protected DTDGrammar fDTDGrammar;
      protected XMLEntityResolver fEntityResolver;
      protected ParserConfigurationSettings fSettings;
      //protected String fPointerSchema;
      protected StringBuffer fPointer;
      private int elemCount = 0;
  
  
      // The current element depth.
      // This is used to access the appropriate level of the following stacks.
      private int fDepth;
  
      // The depth of the first element to actually be part of the result infoset.
      // This will normally be 1, but it could be larger when the top-level item
      // is an include, and processing goes to the fallback.
      private int fRootDepth;
  
      // this value must be at least 1
      private static final int INITIAL_SIZE = 8;
  
  
      // Used to ensure that fallbacks are always children of include elements,
      // and that include elements are never children of other include elements.
      // An index contains true if the ancestor of the current element which resides
      // at that depth was an include element.
      private boolean[] fSawInclude = new boolean[INITIAL_SIZE];
  
  
      // Ensures that only one fallback element can be at a single depth.
      // An index contains true if we have seen any fallback elements at that depth,
      // and it is only reset to false when the end tag of the parent is encountered.
      private boolean[] fSawFallback = new boolean[INITIAL_SIZE];
  
  
      // The state of the processor at each given depth.
      private int[] fState = new int[INITIAL_SIZE];
  
      QName foundElement = null;
      boolean skip = false;
      // Constructors
  
      public XPointerElementHandler() {
  
  
          fDepth = 0;
          fRootDepth = 0;
          fSawFallback[fDepth] = false;
          fSawInclude[fDepth] = false;
          fSchemaName="element";
  
  
      }
  
      // START OF IMPLEMENTATION OF XMLComponent methods //////
  
      public void reset(){
          elemCount =0;
          fPointerToken = null;
          fCurrentTokenint=0;
          fCurrentTokenString=null;
          fCurrentTokenType=0 ;
          fElementCount =0;
          fCurrentToken =0;
          includeElement = false;
          foundElement = null;
          skip = false;
          fSubResourceIdentified=false;
      }
  
      public void reset(XMLComponentManager componentManager)
      throws XNIException {
          fNamespaceContext = null;
          elemCount =0;
          fDepth = 0;
          fRootDepth = 0;
          fPointerToken = null;
          fCurrentTokenint=0;
          fCurrentTokenString=null;
          fCurrentTokenType=0 ;
          foundElement = null;
          includeElement = false;
          skip = false;
          fSubResourceIdentified=false;
  
  
  
  
          try {
              setErrorReporter(
              (XMLErrorReporter)componentManager.getProperty(ERROR_REPORTER));
          }
          catch (XMLConfigurationException e) {
              fErrorReporter = null;
          }
          try {
              fGrammarPool =
              (XMLGrammarPool)componentManager.getProperty(GRAMMAR_POOL);
          }
          catch (XMLConfigurationException e) {
              fGrammarPool = null;
          }
          try {
              fEntityResolver =
              (XMLEntityResolver)componentManager.getProperty(
              ENTITY_RESOLVER);
          }
          catch (XMLConfigurationException e) {
              fEntityResolver = null;
          }
  
          fSettings = new ParserConfigurationSettings();
  
          Enumeration xercesFeatures = Constants.getXercesFeatures();
          while (xercesFeatures.hasMoreElements()) {
              String featureId = (String)xercesFeatures.nextElement();
              fSettings.addRecognizedFeatures(new String[] { featureId });
              try {
                  fSettings.setFeature(
                  featureId,
                  componentManager.getFeature(featureId));
              }
              catch (XMLConfigurationException e) {
                  // componentManager doesn't support this feature,
                  // so we won't worry about it
              }
          }
  /*              try{
            dtdValidator =   (XMLDTDValidator)componentManager.getProperty( Constants.XERCES_PROPERTY_PREFIX + Constants.DTD_VALIDATOR_PROPERTY);
                  }Catch(Exception ex){
                          ex.printStackTrace();
                  }*/
  
      } // reset(XMLComponentManager)
  
      /**
       * Returns a list of feature identifiers that are recognized by
       * this component. This method may return null if no features
       * are recognized by this component.
       */
      public String[] getRecognizedFeatures() {
          return RECOGNIZED_FEATURES;
      } // getRecognizedFeatures():String[]
  
      /**
       * Sets the state of a feature. This method is called by the component
       * manager any time after reset when a feature changes state.
       * <p>
       * <strong>Note:</strong> Components should silently ignore features
       * that do not affect the operation of the component.
       *
       * @param featureId The feature identifier.
       * @param state     The state of the feature.
       *
       * @throws SAXNotRecognizedException The component should not throw
       *                                   this exception.
       * @throws SAXNotSupportedException The component should not throw
       *                                  this exception.
       */
      public void setFeature(String featureId, boolean state)
      throws XMLConfigurationException {
          if (fSettings != null) {
              fSettings.setFeature(featureId, state);
          }
  
      } // setFeature(String,boolean)
  
      /**
       * Returns a list of property identifiers that are recognized by
       * this component. This method may return null if no properties
       * are recognized by this component.
       */
      public String[] getRecognizedProperties() {
          return RECOGNIZED_PROPERTIES;
      } // getRecognizedProperties():String[]
  
      /**
       * Sets the value of a property. This method is called by the component
       * manager any time after reset when a property changes value.
       * <p>
       * <strong>Note:</strong> Components should silently ignore properties
       * that do not affect the operation of the component.
       *
       * @param propertyId The property identifier.
       * @param value      The value of the property.
       *
       * @throws SAXNotRecognizedException The component should not throw
       *                                   this exception.
       * @throws SAXNotSupportedException The component should not throw
       *                                  this exception.
       */
      public void setProperty(String propertyId, Object value)
      throws XMLConfigurationException {
          if (propertyId.equals(ERROR_REPORTER)) {
              setErrorReporter((XMLErrorReporter)value);
          }
          if (propertyId.equals(GRAMMAR_POOL)) {
              fGrammarPool = (XMLGrammarPool)value;
          }
          if (propertyId.equals(ENTITY_RESOLVER)) {
              fEntityResolver = (XMLEntityResolver)value;
          }
  
      } // setProperty(String,Object)
  
      /**
       * Returns the default state for a feature, or null if this
       * component does not want to report a default value for this
       * feature.
       *
       * @param featureId The feature identifier.
       *
       * @since Xerces 2.2.0
       */
      public Boolean getFeatureDefault(String featureId) {
          for (int i = 0; i < RECOGNIZED_FEATURES.length; i++) {
              if (RECOGNIZED_FEATURES[i].equals(featureId)) {
                  return FEATURE_DEFAULTS[i];
              }
          }
          return null;
      } // getFeatureDefault(String):Boolean
  
      /**
       * Returns the default state for a property, or null if this
       * component does not want to report a default value for this
       * property.
       *
       * @param propertyId The property identifier.
       *
       * @since Xerces 2.2.0
       */
      public Object getPropertyDefault(String propertyId) {
          for (int i = 0; i < RECOGNIZED_PROPERTIES.length; i++) {
              if (RECOGNIZED_PROPERTIES[i].equals(propertyId)) {
                  return PROPERTY_DEFAULTS[i];
              }
          }
          return null;
      } // getPropertyDefault(String):Object
  
      private void setErrorReporter(XMLErrorReporter reporter) {
          fErrorReporter = reporter;
          if (fErrorReporter != null) {
              fErrorReporter.putMessageFormatter(
              XIncludeMessageFormatter.XINCLUDE_DOMAIN,
              new XIncludeMessageFormatter());
          }
      }
      ///////// END OF IMPLEMENTATION  OF XMLComponents methods. //////////
  
  
  
      //////// START OF  IMPLEMENTATION OF XMLDOCUMENTSOURCE INTERFACE /////////
  
      public void setDocumentHandler(XMLDocumentHandler handler) {
          fDocumentHandler = handler;
      }
  
      public XMLDocumentHandler getDocumentHandler() {
          return fDocumentHandler;
      }
  
      ///////   END OF IMPLENTATION OF XMLDOCUMENTSOURCE INTERFACE ///////////
  
  
  
  
      /////////////// Implementation of XPointerSchema Methods //////////////////////
  
      String fSchemaName;
      String fSchemaPointer;
      boolean fSubResourceIdentified;
      /**
       * set the Schema Name  eg element , xpointer
       */
      public void setXPointerSchemaName(String schemaName){
          fSchemaName = schemaName;
      }
  
      /**
       * Return  Schema Name  eg element , xpointer
       *
       */
      public String getXpointerSchemaName(){
          return fSchemaName;
      }
  
      /**
       * Parent Contenhandler for the this contenthandler.
       * // not sure about the parameter type. It can be Contenthandler instead of Object type.
       */
      public void setParent(Object parent){
          fParentXIncludeHandler = (XIncludeHandler)parent;
      }
  
  
      /**
       * return the Parent Contenthandler
       */
      public Object getParent(){
          return fParentXIncludeHandler;
      }
  
      /**
       * Content of the XPointer Schema. Xpath to be resolved.
       */
      public void setXPointerSchemaPointer(String content){
          fSchemaPointer = content;
      }
  
      /**
       * Return the XPointer Schema.
       */
      public String getXPointerSchemaPointer(){
          return fSchemaPointer;
      }
  
      public boolean isSubResourceIndentified(){
          return fSubResourceIdentified;
      }
  
      ///////////End Implementation of XPointerSchema Methods //////////////////////
  
  
  
      //////////// Tokens Playground ///////////////////
  
      Stack fPointerToken = new Stack();
      int  fCurrentTokenint=0;
      String fCurrentTokenString=null;
      int fCurrentTokenType=0 ;// 0 Notype; 1 for integer; 2 for string.
  
      public void getTokens(){
          fSchemaPointer = fSchemaPointer.substring(fSchemaPointer.indexOf("(")+1, fSchemaPointer.length());
          StringTokenizer st = new StringTokenizer(fSchemaPointer, "/");
          String tempToken;
          Integer integerToken =null;
          Stack tempPointerToken = new Stack();
          if(fPointerToken == null){
              fPointerToken = new Stack();
          }
          while(st.hasMoreTokens()){
              tempToken=st.nextToken();
              try {
                  integerToken = Integer.valueOf(tempToken);
                  tempPointerToken.push(integerToken);
              }catch(NumberFormatException e){
                  tempPointerToken.push(tempToken);
              }
          }
          while(!tempPointerToken.empty()){
              fPointerToken.push(tempPointerToken.pop());
          }
      }//getTokens
  
  
      public boolean hasMoreToken(){
          if(fPointerToken.isEmpty())
              return false;
          else
              return true;
      }
  
      public boolean getNextToken(){
          Object currentToken;
          if (!fPointerToken.isEmpty()){
              currentToken = fPointerToken.pop();
              if(currentToken instanceof Integer){
                  fCurrentTokenint = ((Integer)currentToken).intValue();
                  fCurrentTokenType = 1;
              }
              else{
                  fCurrentTokenString = ((String)currentToken).toString();
                  fCurrentTokenType = 2;
              }
              return true;
          }
          else {
              return false;
          }
      }
  
      private boolean isIdAttribute(XMLAttributes attributes, Augmentations augs, int index) {
          Object o = augs.getItem(Constants.ID_ATTRIBUTE);
          if( o instanceof Boolean )
              return ((Boolean)o).booleanValue();
          return "ID".equals(attributes.getType(index));
      }
  
      public boolean checkStringToken(QName element, XMLAttributes attributes){
          QName cacheQName = null;
          String id =null;
          String rawname =null;
          QName attrName = new QName();
          String attrType = null;
          String attrValue = null;
          int attrCount = attributes.getLength();
          for (int i = 0; i < attrCount; i++) {
              Augmentations aaugs = attributes.getAugmentations(i);
              attributes.getName(i,attrName);
              attrType = attributes.getType(i);
              attrValue = attributes.getValue(i);
              if(attrType != null && attrValue!= null && isIdAttribute(attributes,aaugs,i) && attrValue.equals(fCurrentTokenString)){
                  if(hasMoreToken()){
                      fCurrentTokenType = 0;
                      fCurrentTokenString = null;
                      return true;
                  }
                  else{
                      foundElement = element;
                      includeElement = true;
                      fCurrentTokenType = 0;
                      fCurrentTokenString = null;
                      fSubResourceIdentified = true;
                      return true;
                  }
              }
          }
          return false;
      }
  
      public boolean checkIntegerToken(QName element){
          if(!skip){
              fElementCount++;
              if(fCurrentTokenint == fElementCount){
                  if(hasMoreToken()){
                      fElementCount=0;
                      fCurrentTokenType = 0;
                      return true;
                  }
                  else{
                      foundElement = element;
                      includeElement = true;
                      fCurrentTokenType = 0;
                      fElementCount=0;
                      fSubResourceIdentified =true;
                      return true;
                  }
              }else{
                  addQName(element);
                  skip = true;
                  return false;
              }
          }
          return false;
      }
  
      public void addQName(QName element){
          QName cacheQName = new QName(element);
          ftempCurrentElement.push(cacheQName);
      }
  
      ///////////  END TOKEN PLAYGROUND ///////////////
  
  
      /////   START OF IMPLEMTATION OF XMLDocumentHandler methods //////////
  
  
      public void startDocument(XMLLocator locator, String encoding,
                                NamespaceContext namespaceContext, Augmentations augs)
      throws XNIException {
  
          getTokens();
      }
  
      public void doctypeDecl(String rootElement, String publicId, String systemId,
      Augmentations augs)throws XNIException {
      }
  
      public void xmlDecl(String version, String encoding, String standalone,
      Augmentations augs) throws XNIException {
      }
  
  
      public void comment(XMLString text, Augmentations augs)
      throws XNIException {
          if (fDocumentHandler != null && includeElement) {
              fDocumentHandler.comment(text, augs);
          }
      }
  
      public void processingInstruction(String target, XMLString data,
      Augmentations augs) throws XNIException {
          if (fDocumentHandler != null && includeElement) {
              fDocumentHandler.processingInstruction(target, data, augs);
  
          }
      }
  
      Stack  ftempCurrentElement = new Stack();
      int fElementCount =0;
      int fCurrentToken ;
      boolean includeElement;
  
  
      public void startElement(QName element, XMLAttributes attributes,
      Augmentations augs)throws XNIException {
  
          boolean requiredToken=false;
          if(fCurrentTokenType == 0)
              getNextToken();
          if(fCurrentTokenType ==1)
              requiredToken = checkIntegerToken(element);
          else if (fCurrentTokenType ==2)
              requiredToken = checkStringToken(element, attributes);
          if(requiredToken && hasMoreToken())
              getNextToken();
          if(fDocumentHandler != null && includeElement){
              elemCount++;
              fDocumentHandler.startElement(element, attributes, augs);
          }
  
      }
  
  
      public void endElement(QName element, Augmentations augs)
      throws XNIException {
          if(includeElement && foundElement != null ){
              if(elemCount >0 )elemCount --;
              fDocumentHandler.endElement(element, augs);
              if(elemCount == 0)includeElement = false;
  
          }else if(!ftempCurrentElement.empty()){
              QName name = (QName)ftempCurrentElement.peek();
              if(name.equals(element)){
                  ftempCurrentElement.pop();
                  skip = false;
              }
          }
      }
  
      public void emptyElement(QName element, XMLAttributes attributes,
      Augmentations augs)throws XNIException {
          if(fDocumentHandler != null && includeElement){
              fDocumentHandler.emptyElement(element, attributes, augs);
          }
      }
  
      public void startGeneralEntity(String name, XMLResourceIdentifier resId,
      String encoding,
      Augmentations augs)
      throws XNIException {
          if (fDocumentHandler != null && includeElement) {
              fDocumentHandler.startGeneralEntity(name, resId, encoding, augs);
          }
      }
  
      public void textDecl(String version, String encoding, Augmentations augs)
      throws XNIException {
          if (fDocumentHandler != null && includeElement) {
              fDocumentHandler.textDecl(version, encoding, augs);
          }
      }
  
      public void endGeneralEntity(String name, Augmentations augs)
      throws XNIException {
          if (fDocumentHandler != null) {
              fDocumentHandler.endGeneralEntity(name, augs);
          }
      }
  
      public void characters(XMLString text, Augmentations augs)
      throws XNIException {
          if (fDocumentHandler != null  && includeElement) {
              fDocumentHandler.characters(text, augs);
          }
      }
  
      public void ignorableWhitespace(XMLString text, Augmentations augs)
      throws XNIException {
          if (fDocumentHandler != null && includeElement) {
              fDocumentHandler.ignorableWhitespace(text, augs);
          }
      }
  
      public void startCDATA(Augmentations augs) throws XNIException {
          if (fDocumentHandler != null && includeElement) {
              fDocumentHandler.startCDATA(augs);
          }
      }
  
      public void endCDATA(Augmentations augs) throws XNIException {
          if (fDocumentHandler != null && includeElement) {
              fDocumentHandler.endCDATA(augs);
          }
      }
  
      public void endDocument(Augmentations augs) throws XNIException {
      }
  
      public void setDocumentSource(XMLDocumentSource source) {
          fDocumentSource = source;
      }
  
      public XMLDocumentSource getDocumentSource() {
          return fDocumentSource;
      }
  
  
      protected void reportFatalError(String key) {
          this.reportFatalError(key, null);
      }
  
      protected void reportFatalError(String key, Object[] args) {
          if (fErrorReporter != null) {
              fErrorReporter.reportError(
              fDocLocation,
              XIncludeMessageFormatter.XINCLUDE_DOMAIN,
              key,
              args,
              XMLErrorReporter.SEVERITY_FATAL_ERROR);
          }
          // we won't worry about when error reporter is null, since there should always be
          // at least the default error reporter
      }
  
  
  
      // used to know whether to pass declarations to the document handler
      protected boolean isRootDocument() {
          return this.fParentXIncludeHandler == null;
      }
  
  
  } // class XPointerElementhandler
  