/*
 * The Apache Software License, Version 1.1
 *
 *
 * Copyright (c) 1999 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 "Xalan" 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, Lotus
 * Development Corporation., http://www.lotus.com.  For more
 * information on the Apache Software Foundation, please see
 * <http://www.apache.org/>.
 */
package org.apache.xml.dtm.ref.xni2dtm;

import java.util.Hashtable;
import java.util.Vector;
import javax.xml.transform.Source;
import javax.xml.transform.SourceLocator;
import org.apache.xalan.transformer.XalanProperties;
import org.apache.xalan.res.XSLTErrorResources;
import org.apache.xalan.res.XSLMessages;

import org.apache.xml.dtm.*;
import org.apache.xml.dtm.ref.*;
import org.apache.xml.utils.StringVector;
import org.apache.xml.utils.IntVector;
import org.apache.xml.utils.FastStringBuffer;
import org.apache.xml.utils.IntStack;
import org.apache.xml.utils.SuballocatedIntVector;
import org.apache.xml.utils.SystemIDResolver;
import org.apache.xml.utils.WrappedRuntimeException;
import org.apache.xml.utils.XMLCharacterRecognizer;
import org.apache.xml.utils.SparseVector;

//import org.xml.sax.*;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
//import org.xml.sax.ext.*;

import org.apache.xerces.xni.*;
import org.apache.xerces.xni.psvi.*;
import org.apache.xerces.xni.parser.XMLPullParserConfiguration;
import org.apache.xerces.xni.parser.XMLErrorHandler;
import org.apache.xerces.xni.parser.XMLParseException;

import org.apache.xerces.xni.psvi.ElementPSVI;
import org.apache.xerces.xni.psvi.AttributePSVI;
import org.apache.xerces.xni.psvi.ItemPSVI;
import org.apache.xerces.impl.xs.ElementPSVImpl;
import org.apache.xerces.impl.xs.AttributePSVImpl;
import org.apache.xerces.impl.xs.XSTypeDecl;
import org.apache.xerces.impl.validation.ValidationContext;
import org.apache.xerces.impl.validation.ValidationState;
import org.apache.xerces.impl.dv.ValidatedInfo;
import org.apache.xerces.impl.dv.xs.XSSimpleTypeDecl;
import org.apache.xerces.impl.dv.InvalidDatatypeValueException;

/**
 * This class implements a DTM that is constructed via an XNI data stream.
 * 
 * Please note that it this is a PROTOTYPE, since the Xerces post-schema 
 * validation infoset (PSVI) APIs it is using are themselves prototypes and
 * subject to change without warning. The most recent such change was from
 * "lightweight" to "heavyweight" schema models.
 * 
 * This version is derived from SAX2DTM for ease of implementation and
 * support, but deliberately blocks external access to
 * the SAX-listener calls to make our testing a bit more rigorous.
 * 
 * Note to developers: Both XNI and Xalan have classes called XMLString.
 * Don't confuse them!
 * 
 * %REVIEW% Should we re-unify this with SAX2DTM? 
 * Should we merge that with SAX2RTFDTM? "And what about Naomi?"
 */
public class XNI2DTM 
  extends org.apache.xml.dtm.ref.sax2dtm.SAX2DTM
  implements XMLDocumentHandler, XMLErrorHandler, XMLDTDHandler
{
  /** DEBUGGING FLAG: Set true to monitor XNI events and similar diagnostic info. */
  private static final boolean DEBUG = true;
  
  /** %OPT% %REVIEW% PROTOTYPE: Schema Type information, datatype as instantiated.
   * See discussion in addNode */
  protected SparseVector m_schemaTypeOverride=new SparseVector();
  

  /**
   * If we're building the model incrementally on demand, we need to
   * be able to tell the source when to send us more data.
   *
   * Note that if this has not been set, and you attempt to read ahead
   * of the current build point, we'll probably throw a null-pointer
   * exception. We could try to wait-and-retry instead, as a very poor
   * fallback, but that has all the known problems with multithreading
   * on multiprocessors and we Don't Want to Go There.
   *
   * @see setIncrementalXNISource
   */
  private XMLPullParserConfiguration m_incrementalXNISource = null;

  /** The XNI Document locator 
   * %REVIEW% Should we be storing a SAX locator instead? */
  transient private LocatorWrapper m_locator_wrapper = new LocatorWrapper();
  
  /** Manefest constant: Schema namespace string */
  private static final String SCHEMANS="http://www.w3.org/2001/XMLSchema";
  
  /** Manefest constant: Message for SAX-disablement stubs */
  static final String UNEXPECTED="XNI2DTM UNEXPECTED SAX ";

  /**
   * Construct a XNI2DTM object ready to be constructed from XNI
   * ContentHandler events.
   *
   * @param mgr The DTMManager who owns this DTM.
   * @param source the JAXP 1.1 Source object for this DTM.
   * @param dtmIdentity The DTM identity ID for this DTM.
   * @param whiteSpaceFilter The white space filter for this DTM, which may
   *                         be null.
   * @param xstringfactory XMLString factory for creating character content.
   * @param doIndexing true if the caller considers it worth it to use 
   *                   indexing schemes.
   */
  public XNI2DTM(DTMManager mgr, Source source, int dtmIdentity,
                 DTMWSFilter whiteSpaceFilter,
                 org.apache.xml.utils.XMLStringFactory xstringfactory,
                 boolean doIndexing)
  {
    super(mgr, source, dtmIdentity, whiteSpaceFilter, 
          xstringfactory, doIndexing);
  }

  
  /** ADDED for XNI, SUPPLEMENTS non-schema-typed addNode:
   * 
   * Construct the node map from the node. EXTENDED to carry PSVI type data
   * delivered via XNI. This is currently using non-published Xerces APIs, which
   * are subject to change as their PSVI support becomes more official.
   *
   * @param type raw type ID, one of DTM.XXX_NODE.
   * @param expandedTypeID The expended type ID.
   * @param parentIndex The current parent index.
   * @param previousSibling The previous sibling index.
   * @param dataOrPrefix index into m_data table, or string handle.
   * @param canHaveFirstChild true if the node can have a first child, false
   *                          if it is atomic.
   * @param expectedType Xerces Schema type object as declared in the schema
   *    %REVIEW% NOTE that the 3/28/03 query datamodel no longer records the 
   *    type-as-declared, so this field can probably be eliminated!
   * @param actualType Schema type object as resolved in actual instance document
   *
   * @return The index identity of the node that was added.
   */
  protected int addNode(int type, int expandedTypeID,
                        int parentIndex, int previousSibling,
                        int dataOrPrefix, boolean canHaveFirstChild,
                        XPath2Type actualType)
  {
    int identity=super.addNode(type,expandedTypeID,
                               parentIndex,previousSibling,
                               dataOrPrefix,canHaveFirstChild);

    // The goal is to not consume storage for types unless they actualy exist,
    // and to minimize per-node overhead.
    //
    // NOTE: Record first-seen as default even if it is null, because
    // otherwise late changes of type will bash previously recorded
    // nodes. This is NOT necessarily maximally efficient, but to really
    // optimize we would have to rewrite data to make the default the most
    // common -- and since Scott insists that overrides will be uncommon,
    // I don't want to go there.
    //
    // NOTE: Element schema-types aren't fully resolved until endElement, and
    // need to be dealt with there.
    if(type!=ELEMENT_NODE)
    {
      // Try to record as default for this nodetype
      if(!m_expandedNameTable.setSchemaType(m_exptype.elementAt(identity),
                                            actualType)
         )
      {
        m_schemaTypeOverride.setElementAt(actualType,identity);
      }
    }

    return identity;
  }

  /** ADDED FOR XPATH2: Query schema type name of a given node.
   * 
   * %REVIEW% Is this actually needed?
   * 
   * @param nodeHandle DTM Node Handle of Node to be queried
   * @return null if no type known, else returns the expanded-QName (namespace URI
   *    rather than prefix) of the type actually
   *    resolved in the instance document. Note that this may be derived from,
   *    rather than identical to, the type declared in the schema.
   */
  public String getSchemaTypeName(int nodeHandle)
  {
    int identity=makeNodeIdentity(nodeHandle);
        
    if(identity!=DTM.NULL)
    {
      XPath2Type actualType=(XPath2Type)m_schemaTypeOverride.elementAt(identity);
      if(actualType==null)
        actualType=(XPath2Type)m_expandedNameTable.getSchemaType(m_exptype.elementAt(identity));

      if(actualType!=null)
      {
        String nsuri=actualType.getTargetNamespace();
        String local=actualType.getTypeName();
        return (nsuri==null)
          ? local
          : nsuri+":"+local;
      }
    }
        
    return null;
  }
        
  /** ADDED FOR XPATH2: Query schema type namespace of a given node.
   * 
   * %REVIEW% Is this actually needed?
   * 
   * @param nodeHandle DTM Node Handle of Node to be queried
   * @return null if no type known, else returns the namespace URI
   *    of the type actually resolved in the instance document. This may
   *    be null if the default/unspecified namespace was used.
   *    Note that this may be derived from,
   *    rather than identical to, the type declared in the schema.
   */
  public String getSchemaTypeNamespace(int nodeHandle)
  {
    int identity=makeNodeIdentity(nodeHandle);
        
    if(identity!=DTM.NULL)
    {
      XPath2Type actualType=(XPath2Type)m_schemaTypeOverride.elementAt(identity);
      if(actualType==null)
        actualType=(XPath2Type)m_expandedNameTable.getSchemaType(m_exptype.elementAt(identity));
      if(actualType!=null)
      {
        return actualType.getTargetNamespace();
      }
    }
        
    return null;
  }

  /** ADDED FOR XPATH2: Query schema type localname of a given node.
   * 
   * %REVIEW% Is this actually needed?
   * 
   * @param nodeHandle DTM Node Handle of Node to be queried
   * @return null if no type known, else returns the localname of the type
   *    resolved in the instance document. Note that this may be derived from,
   *    rather than identical to, the type declared in the schema.
   */
  public String getSchemaTypeLocalName(int nodeHandle)
  {
    int identity=makeNodeIdentity(nodeHandle);
        
    if(identity!=DTM.NULL)
    {
      XPath2Type actualType=(XPath2Type)m_schemaTypeOverride.elementAt(identity);
      if(actualType==null)
        actualType=(XPath2Type)m_expandedNameTable.getSchemaType(m_exptype.elementAt(identity));
      if(actualType!=null)
      {
        return actualType.getTypeName();
      }
    }
        
    return null;
  }

  /** ADDED FOR XPATH2: Query whether node's type is derived from a specific type
   * 
   * @param nodeHandle DTM Node Handle of Node to be queried
   * @param namespace String containing URI of namespace for the type we're intersted in
   * @param localname String containing local name for the type we're intersted in
   * @return true if node has a Schema Type which equals or is derived from 
   *    the specified type. False if the node has no type or that type is not
   *    derived from the specified type.
   */
  public boolean isNodeSchemaType(int nodeHandle, String namespace, String localname)
  {
    int identity=makeNodeIdentity(nodeHandle);
        
    if(identity!=DTM.NULL)
    {
      XPath2Type actualType=(XPath2Type)m_schemaTypeOverride.elementAt(identity);
      if(actualType==null)
        actualType=(XPath2Type)m_expandedNameTable.getSchemaType(m_exptype.elementAt(identity));
      if(actualType!=null)
        return actualType.derivedFrom(namespace,localname);
    }
        
    return false;
  }
  
  /** ADDED FOR XPATH2: Retrieve the typed value(s), based on the schema type
   * */
  public XSequence getTypedValue(int nodeHandle)
  {
    // Determine whether instance of built-in type, or list thereof
    // If so, map to corresponding Java type
    // Retrieve string content (as always, for element this spans children
    // If type was xs:string (or untyped?) just return that in a collection.
    // Else parse into collection object, return that
        
    int identity=makeNodeIdentity(nodeHandle);
    if(identity==DTM.NULL)
      return XSequence.EMPTY;
                
    XPath2Type actualType=(XPath2Type)m_schemaTypeOverride.elementAt(identity);
    if(actualType==null)
      actualType=(XPath2Type)m_expandedNameTable.getSchemaType(m_exptype.elementAt(identity));

    if(actualType==null)
      return XSequence.EMPTY;
                
        /* %REVIEW% Efficiency issues; value may be in FSB, in which case
                generating a Java String may arguably be wasteful. */
        //GONK lists;
        //GONK efficiency;
        
    String textvalue=getNodeValue(nodeHandle);
        
    return actualType.typedValue(textvalue);
  }
  
  
  //===========================================================================

  /** OVERRIDDEN FOR XNI:
   * 
   * Ask the CoRoutine parser to terminate and clear the reference. If
   * the parser has already been cleared, this will have no effect.
   *
   * @param callDoTerminate true if parsing should be terminated
   */
  public void clearCoRoutine(boolean callDoTerminate)
  {

    if (null != m_incrementalXNISource)
    {
      if (callDoTerminate)
        m_incrementalXNISource.cleanup();

      m_incrementalXNISource = null;
    }
  }

  /** ADDED FOR XNI, REPLACES setIncrementalSAXSource:
   * 
   * Bind a IncrementalXNISource to this DTM. If we discover we need nodes
   * that have not yet been built, we will ask this object to send us more
   * events, and it will manage interactions with its data sources.
   *
   * Note that we do not actually build the IncrementalXNISource, since we don't
   * know what source it's reading from, what thread that source will run in,
   * or when it will run.
   *
   * @param incrementalXNISource The parser that we want to recieve events from
   * on demand.
   * @param appCoRID The CoRoutine ID for the application.
   */
  public void setIncrementalXNISource(XMLPullParserConfiguration incrementalXNISource)
  {

    // Establish coroutine link so we can request more data
    //
    // Note: It's possible that some versions of IncrementalXNISource may
    // not actually use a CoroutineManager, and hence may not require
    // that we obtain an Application Coroutine ID. (This relies on the
    // coroutine transaction details having been encapsulated in the
    // IncrementalXNISource.do...() methods.)
    m_incrementalXNISource = incrementalXNISource;

    // Establish XNI-stream link so we can receive the requested data
    incrementalXNISource.setDocumentHandler(this);

    // Are the following really needed? incrementalXNISource doesn't yet
    // support them, and they're mostly no-ops here...
    incrementalXNISource.setErrorHandler(this);
    incrementalXNISource.setDTDHandler(this);
  }

  /** DISABLED FOR XNI:
   * 
   * getContentHandler returns "our SAX builder" -- the thing that
   * someone else should send SAX events to in order to extend this
   * DTM model.
   * 
   * %REVIEW% We _could_ leave SAX support in place and have a single model
   * that handles both kinds of event streams. I've chosen to block it
   * during development for better isolation of XNI support.
   *
   * @return null since this model doesn't respond to SAX events
   */
  public org.xml.sax.ContentHandler getContentHandler()
  {
    return null;
  }

  /**
   * Return this DTM's lexical handler.
   *
   * %REVIEW% Should this return null if constrution already done/begun?
   * 
   * %REVIEW% We _could_ leave SAX support in place and have a single model
   * that handles both kinds of event streams. I've chosen to block it
   * during development for better isolation of XNI support.
   *
   * @return null since this model doesn't respond to SAX events
   */
  public org.xml.sax.ext.LexicalHandler getLexicalHandler()
  {
    return null;
  }

  /**
   * Return this DTM's DTDHandler.
   * 
   * %REVIEW% We _could_ leave SAX support in place and have a single model
   * that handles both kinds of event streams. I've chosen to block it
   * during development for better isolation of XNI support.
   *
   * @return null since this model doesn't respond to SAX events
   */
  public org.xml.sax.DTDHandler getDTDHandler()
  {
    return null;
  }

  /**
   * Return this DTM's ErrorHandler.
   *
   * @return null if this model doesn't respond to SAX error events.
   */
  public org.xml.sax.ErrorHandler getErrorHandler()
  {
    //return this;
    return null;
  }

  /**
   * Return this DTM's DeclHandler.
   *
   * @return null if this model doesn't respond to SAX Decl events.
   */
  public org.xml.sax.ext.DeclHandler getDeclHandler()
  {
    //return this;
    return null;
  }

  /** OVERRIDDEN FOR XNI:
   * 
   * @return true iff we're building this model incrementally (eg
   * we're partnered with a IncrementalXNISource) and thus require that the
   * transformation and the parse run simultaneously. Guidance to the
   * DTMManager.
   */
  public boolean needsTwoThreads()
  {
    return null != m_incrementalXNISource;
  }

  /** OVERRIDDEN FOR XNI:
   * 
   * This method should try and build one or more nodes in the table.
   * 
   * %REVIEW% Is it worth factoring out the actual request for more events
   * into a subroutine, isolating it better? Consider if/when we re-merge
   * with SAX2DTM.
   *
   * @return The true if a next node is found or false if
   *         there are no more nodes.
   */
  protected boolean nextNode()
  {

    if (null == m_incrementalXNISource)
      return false;

    if (m_endDocumentOccured)
    {
      clearCoRoutine();

      return false;
    }

    try
    {
      boolean gotMore = m_incrementalXNISource.parse(false);
      if (!gotMore)
      {
        // EOF reached without satisfying the request
        clearCoRoutine();  // Drop connection, stop trying
        // %TBD% deregister as its listener?
      }
      return gotMore;
    }
    catch(RuntimeException e)
    {
      throw e;
    }
    catch(Exception e)
    {
      throw new WrappedRuntimeException(e);
    }

    // %REVIEW% dead code
    //clearCoRoutine();
    //return false;
  }
  
  /** %REVIEW% XNI should let us support this better...
   * 
   * Return the public identifier of the external subset,
   * normalized as described in 4.2.2 External Entities [XML]. If there is
   * no external subset or if it has no public identifier, this property
   * has no value.
   *
   * @param the document type declaration handle
   *
   * @return the public identifier String object, or null if there is none.
   */
  public String getDocumentTypeDeclarationPublicIdentifier()
  {
    return super.getDocumentTypeDeclarationPublicIdentifier();
  }


  ////////////////////////////////////////////////////////////////////
  // Implementation of XNI XMLDocumentHandler interface.
  //
  // %REVIEW% Hand off the SAX2DTM SAX event code, or copy/adapt method
  // bodies? Performance may favor latter approach, but former is no worse
  // than what's been happening on the parser's side of the fence and
  // simplifies maintainance.
  ////////////////////////////////////////////////////////////////////

  /**
   * Receive notification of a notation declaration.
   *
   * <p>By default, do nothing.  Application writers may override this
   * method in a subclass if they wish to keep track of the notations
   * declared in a document.</p>
   *
   * @param name The notation name.
   * @param publicId The notation public identifier, or null if not
   *                 available.
   * @param systemId The notation system identifier.
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.DTDHandler#notationDecl
   *
   * @throws XNIException
   */
  public void notationDecl(String name, String publicId, String systemId)
    throws XNIException
  {
    // no op
  }

  /**
   * Receive notification of an unparsed entity declaration.
   *
   * <p>By default, do nothing.  Application writers may override this
   * method in a subclass to keep track of the unparsed entities
   * declared in a document.</p>
   *
   * @param name The entity name.
   * @param publicId The entity public identifier, or null if not
   *                 available.
   * @param systemId The entity system identifier.
   * @param notationName The name of the associated notation.
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.DTDHandler#unparsedEntityDecl
   *
   * @throws XNIException
   */
  public void unparsedEntityDecl(
                                 String name, String publicId, String systemId, String notationName)
    throws XNIException
  {
    try
    {
      super.unparsedEntityDecl(name,publicId,systemId,notationName);
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }

  /**
   * Receive a Locator object for document events.
   *
   * <p>By default, do nothing.  Application writers may override this
   * method in a subclass if they wish to store the locator for use
   * with other document events.</p>
   *
   * @param locator A locator for all XNI document events.
   * @see org.xml.sax.ContentHandler#setDocumentLocator
   * @see org.xml.sax.Locator
   */
  public void setDocumentLocator(XMLLocator locator)
  {
    m_locator_wrapper.setLocator(locator);
    super.setDocumentLocator(m_locator_wrapper);
  }

  /**
   * Receive notification of the beginning of the document.
   *
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.ContentHandler#startDocument
   */
  public void startDocument(XMLLocator locator,String encoding,Augmentations augs)
    throws XNIException
  {
    if (DEBUG)
      System.out.println("startDocument");
 
    try
    {    
      super.startDocument();
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }

  /**
   * Receive notification of the end of the document.
   *
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.ContentHandler#endDocument
   */
  public void endDocument(Augmentations augs) throws XNIException
  {
    if (DEBUG)
      System.out.println("endDocument");
      
    try
    {
      super.endDocument();
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }

  /**
   * Receive notification of the start of a Namespace mapping.
   *
   * <p>By default, do nothing.  Application writers may override this
   * method in a subclass to take specific actions at the start of
   * each Namespace prefix scope (such as storing the prefix mapping).</p>
   *
   * @param prefix The Namespace prefix being declared.
   * @param uri The Namespace URI mapped to the prefix.
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.ContentHandler#startPrefixMapping
   */
  public void startPrefixMapping(String prefix,String uri,Augmentations augs)
    throws XNIException
  {
    if (DEBUG)
      System.out.println("startPrefixMapping: prefix: " + prefix + ", uri: "
                         + uri);
    try
    {                        
      if(augs!=null &&
         null!=augs.getItem(DTM2XNI.DTM2XNI_ADDED_STRUCTURE))
      {
        if (DEBUG)
          System.out.println("\t***** Added by DTM2XNI; ignored here");
                  
        return; // Ignore it!
      }
                
                  
      super.startPrefixMapping(prefix,uri);
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }

  /**
   * Receive notification of the end of a Namespace mapping.
   *
   * <p>By default, do nothing.  Application writers may override this
   * method in a subclass to take specific actions at the end of
   * each prefix mapping.</p>
   *
   * @param prefix The Namespace prefix being declared.
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.ContentHandler#endPrefixMapping
   */
  public void endPrefixMapping(String prefix, Augmentations augs) 
    throws XNIException
  {
    if (DEBUG)
      System.out.println("endPrefixMapping: prefix: " + prefix);

    try
    {
      if(augs!=null &&
         null!=augs.getItem(DTM2XNI.DTM2XNI_ADDED_STRUCTURE))
      {
        if (DEBUG)
          System.out.println("\t***** Added by DTM2XNI; ignored here");
                  
        return; // Ignore it!
      }
                
      super.endPrefixMapping(prefix);
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }

  /**
   * Receive notification of the start of an element.
   *
   * <p>By default, do nothing.  Application writers may override this
   * method in a subclass to take specific actions at the start of
   * each element (such as allocating a new tree node or writing
   * output to a file).</p>
   *
   * @param name The element type name.
   *
   * @param uri The Namespace URI, or the empty string if the
   *        element has no Namespace URI or if Namespace
   *        processing is not being performed.
   * @param localName The local name (without prefix), or the
   *        empty string if Namespace processing is not being
   *        performed.
   * @param qName The qualified name (with prefix), or the
   *        empty string if qualified names are not available.
   * @param attributes The specified or defaulted attributes.
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.ContentHandler#startElement
   */
  public void startElement(QName element, XMLAttributes attributes,
                           Augmentations augs)
    //String uri, String localName, String qName, Attributes attributes)
    throws XNIException
  {
    // %REVIEW% I've copied this verbatim and altered it for XNI.
    // Is that overkill? Can we hand any of it back to the SAX layer?
    // (I suspect not, darn it....)
    
    if (DEBUG)
    {
      System.out.println("startElement: uri: " + element.uri + 
                         ", localname: " + element.localpart + 
                         ", qname: "+element.rawname+", atts: " + attributes);    
    }
      
    boolean syntheticElement=false;
        
    // Augs might be null if schema support not turned on in parser. 
    // Shouldn't arise in final operation (?); may arise during debugging
    ElementPSVImpl elemPSVI=null;
    XSTypeDecl actualType =null;
    XPath2Type xp2type=null;
    if(augs!=null)
    {
      // Node added by DTM2XNI?
      syntheticElement = null!=augs.getItem(DTM2XNI.DTM2XNI_ADDED_STRUCTURE);
        
      // Extract Experimental Xerces PSVI data          
      elemPSVI=(ElementPSVImpl)augs.getItem(org.apache.xerces.impl.Constants.ELEMENT_PSVI);
      xp2type=new XPath2Type(elemPSVI,false);
      actualType =
        (elemPSVI==null) ? null : elemPSVI.getTypeDefinition();
      org.apache.xerces.impl.xs.XSElementDecl expectedDecl =  // %REVIEW% OBSOLETE?
        (elemPSVI==null) ? null : elemPSVI.getElementDecl();
      XSTypeDecl expectedType = // %REVIEW% OBSOLETE?
        (expectedDecl==null) ? actualType : expectedDecl.fType;

      if (DEBUG)
      {
        String actualExpandedQName=xp2type.getTargetNamespace()+":"+xp2type.getTypeName();

        System.out.println("\ttypeDefinition (actual): "+ actualType +
                           "\n\t\ttype expanded-qname: " + actualExpandedQName +
                           "\n\telementDecl  (expected): " + expectedDecl +
                           "\n\tDerived from expected (after null recovery): " + actualType.derivedFrom(expectedType) +
                           "\n\tDerived from builtin string: " + actualType.derivedFrom(SCHEMANS,"string") +
                           "\n\tSynthesized by DTM2XNI: "+syntheticElement
                           );
      } //DEBUG
    }// augs
    
    if(DEBUG && attributes!=null)  
    {
      int n = attributes.getLength();
      if(n==0)
        System.out.println("\tempty attribute list");
      else for (int i = 0; i < n; i++)
      {
        System.out.println("\t attr: uri: " + attributes.getURI(i) +
                           ", localname: " + attributes.getLocalName(i) +
                           ", qname: " + attributes.getQName(i) +
                           ", type: " + attributes.getType(i) +
                           ", value: " + attributes.getValue(i)                                                                                                          
                           );
        // Experimental Xerces PSVI data
        Augmentations attrAugs=attributes.getAugmentations(i);
        AttributePSVImpl attrPSVI=(AttributePSVImpl)attrAugs.getItem(org.apache.xerces.impl.Constants.ATTRIBUTE_PSVI);
        XPath2Type xp2attrtype=new XPath2Type(attrPSVI,true);
        XSTypeDecl actualAttrType=(attrPSVI==null) ? null : attrPSVI.getTypeDefinition();
        org.apache.xerces.impl.xs.XSAttributeDecl expectedAttrDecl= // %REVIEW% Obsolete?
          (attrPSVI==null) ? null : attrPSVI.getAttributeDecl();                              
        XSTypeDecl expectedType=(expectedAttrDecl==null) ? actualAttrType : expectedAttrDecl.fType;
        String actualExpandedQName=(actualAttrType==null) ? null : actualAttrType.getTargetNamespace()+":"+actualAttrType.getTypeName();
        // Node added by DTM2XNI?
        boolean syntheticAttribute = null!=attrAugs.getItem(DTM2XNI.DTM2XNI_ADDED_STRUCTURE);

        actualExpandedQName=xp2attrtype.getTargetNamespace()+
        	":"+ xp2attrtype.getTypeName();
        
        System.out.println("\t\ttypeDefinition (actual): "+ actualAttrType +
                           "\n\t\t\ttype expanded-qname: " + actualExpandedQName +
                           "\n\t\tattrDecl (expected): " + expectedAttrDecl
                           );
        if(actualAttrType!=null)                                                
          System.out.println("\n\t\tDerived from expected (after null recovery): " + actualAttrType.derivedFrom(expectedType) +
                             "\n\t\tDerived from builtin string: "+ actualAttrType.derivedFrom(SCHEMANS,"string") +
                             "\n\t\tTyped value: " + xp2attrtype.typedValue(attributes.getValue(i))+
                             "\n\t\tSynthesized by DTM2XNI: "+syntheticAttribute
                             );
      } // dump all attrs
    } // DEBUG

    
    if(syntheticElement)
    {
      if (DEBUG)
        System.out.println("\t***** Added by DTM2XNI; ignored here");
      
      return; // Ignore it!
    }
    
    charactersFlush();


    int exName = m_expandedNameTable.getExpandedTypeID(element.uri, element.localpart, DTM.ELEMENT_NODE);
    String prefix = getPrefix(element.rawname, element.uri);
    int prefixIndex = (null != element.prefix)
      ? m_valuesOrPrefixes.stringToIndex(element.rawname) : 0;
    int elemNode = addNode(DTM.ELEMENT_NODE, exName,
                           m_parents.peek(), m_previous, prefixIndex, true,
                           xp2type);

    if(m_indexing)
      indexNode(exName, elemNode);
    
    m_parents.push(elemNode);

    int startDecls = m_contextIndexes.peek();
    int nDecls = m_prefixMappings.size();
    int prev = DTM.NULL;

    if(!m_pastFirstElement)
    {
      // SPECIAL CASE: Implied declaration at root element
      prefix="xml";
      String declURL = "http://www.w3.org/XML/1998/namespace";
      exName = m_expandedNameTable.getExpandedTypeID(null, prefix, DTM.NAMESPACE_NODE);
      int val = m_valuesOrPrefixes.stringToIndex(declURL);
      // %REVIEW% I don't _think_ we need datatype on namespaces...?
      prev = addNode(DTM.NAMESPACE_NODE, exName, elemNode,
                     prev, val, false);
      m_pastFirstElement=true;
    }
                        
    for (int i = startDecls; i < nDecls; i += 2)
    {
      prefix = (String) m_prefixMappings.elementAt(i);

      if (prefix == null)
        continue;

      String declURL = (String) m_prefixMappings.elementAt(i + 1);

      exName = m_expandedNameTable.getExpandedTypeID(null, prefix, DTM.NAMESPACE_NODE);

      int val = m_valuesOrPrefixes.stringToIndex(declURL);

      // %REVIEW% I don't _think_ we need datatype on namespaces...?
      prev = addNode(DTM.NAMESPACE_NODE, exName, elemNode,
                     prev, val, false);
    }

    int n = attributes.getLength();

    for (int i = 0; i < n; i++)
    {
      String attrUri = attributes.getURI(i);
      String attrQName = attributes.getQName(i);
      String valString = attributes.getValue(i);

      prefix = getPrefix(attrQName, attrUri);

      int nodeType;

      if ((null != attrQName)
          && (attrQName.equals("xmlns")
              || attrQName.startsWith("xmlns:")))
      {
        if (declAlreadyDeclared(prefix))
          continue;  // go to the next attribute.

        nodeType = DTM.NAMESPACE_NODE;
      }
      else
      {
        nodeType = DTM.ATTRIBUTE_NODE;

        if (attributes.getType(i).equalsIgnoreCase("ID"))
          setIDAttribute(valString, elemNode);
      }
      
      // Bit of a hack... if somehow valString is null, stringToIndex will 
      // return -1, which will make things very unhappy.
      if(null == valString)
        valString = "";

      int val = m_valuesOrPrefixes.stringToIndex(valString);
      String attrLocalName = attributes.getLocalName(i);

      if (null != prefix)
      {
        
        prefixIndex = m_valuesOrPrefixes.stringToIndex(attrQName);

        int dataIndex = m_data.size();

        m_data.addElement(prefixIndex);
        m_data.addElement(val);

        val = -dataIndex;
      }

      exName = m_expandedNameTable.getExpandedTypeID(attrUri, attrLocalName, nodeType);

      // Experimental Xerces PSVI data
      Augmentations attrAugs=attributes.getAugmentations(i);
      boolean syntheticAttribute= null != attrAugs.getItem(DTM2XNI.DTM2XNI_ADDED_STRUCTURE);
      if(syntheticAttribute)
      {
        if (DEBUG)
          System.out.println("\t***** Attr {"+attrUri+"}"+attrLocalName+" added by DTM2XNI; ignored here");
        return; // Ignore it!
      }
      
      AttributePSVImpl attrPSVI=(AttributePSVImpl)attrAugs.getItem(org.apache.xerces.impl.Constants.ATTRIBUTE_PSVI);
      XPath2Type xp2attrtype=new XPath2Type(attrPSVI,true);
      
      prev = addNode(nodeType, exName, elemNode, prev, val,
                     false, xp2attrtype);
    }

    if (DTM.NULL != prev)
      m_nextsib.setElementAt(DTM.NULL,prev);

    if (null != m_wsfilter)
    {
      short wsv = m_wsfilter.getShouldStripSpace(makeNodeHandle(elemNode), this);
      boolean shouldStrip = (DTMWSFilter.INHERIT == wsv)
        ? getShouldStripWhitespace()
        : (DTMWSFilter.STRIP == wsv);

      pushShouldStripWhitespace(shouldStrip);
    }

    m_previous = DTM.NULL;

    m_contextIndexes.push(m_prefixMappings.size());  // for the children.
  }

  /**
   * Receive notification of the end of an element.
   *
   * <p>By default, do nothing.  Application writers may override this
   * method in a subclass to take specific actions at the end of
   * each element (such as finalising a tree node or writing
   * output to a file).</p>
   *
   * @param name The element type name.
   * @param attributes The specified or defaulted attributes.
   *
   * @param uri The Namespace URI, or the empty string if the
   *        element has no Namespace URI or if Namespace
   *        processing is not being performed.
   * @param localName The local name (without prefix), or the
   *        empty string if Namespace processing is not being
   *        performed.
   * @param qName The qualified XML 1.0 name (with prefix), or the
   *        empty string if qualified names are not available.
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.ContentHandler#endElement
   */
  public void endElement(QName element,Augmentations augs) throws XNIException
  {
    if (DEBUG)
      System.out.println("endElement: uri: " + element.uri + 
                         ", localname: " + element.localpart + ", qname: "+element.rawname);
                         
    if(null!=augs && null!=augs.getItem(DTM2XNI.DTM2XNI_ADDED_STRUCTURE))
    {
      if (DEBUG)
        System.out.println("\t***** Added by DTM2XNI; ignored here");
      
      return; // Ignore it!
    }

    try
    {
      super.endElement(element.uri,element.localpart,element.rawname);
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
    
    // The goal is to not consume storage for types unless they actualy exist,
    // and to minimize per-node overhead.
    //
    // NOTE: Record first-seen as default even if it is null, because
    // otherwise late changes of type will bash previously recorded
    // nodes. This is NOT necessarily maximally efficient, but to really
    // optimize we would have to rewrite data to make the default the most
    // common -- and since Scott insists that overrides will be uncommon,
    // I don't want to go there.
    //
    // NOTE: Element schema-types aren't fully resolved until endElement, and
    // need to be dealt with there.
    {
      // After super.endElement, m_previous is the element we're ending.	
      // Try to record as default for this nodetype
      ElementPSVImpl elemPSVI=null;
      XSTypeDecl actualType =null;
      if(augs!=null)
      {
        elemPSVI=(ElementPSVImpl)augs.getItem(org.apache.xerces.impl.Constants.ELEMENT_PSVI);
        actualType =
          (elemPSVI==null) ? null : elemPSVI.getTypeDefinition();
      }

      if(!m_expandedNameTable.setSchemaType(m_exptype.elementAt(m_previous),
                                            actualType)
         )
      {
        m_schemaTypeOverride.setElementAt(actualType,m_previous);
      }
    }
    
  }

  /** An empty element.
   * 
   * @param element - The name of the element.
   * @param attributes - The element attributes.
   * @param augs - Additional information that may include infoset augmentations
   * @throws XNIException - Thrown by handler to signal an error.
   * */
  public void emptyElement(QName element,
                           XMLAttributes attributes,
                           Augmentations augs)
    throws XNIException
  {
    // %OPT% We could skip the pushes and pops and save some cycles...
      startElement(element,attributes,augs);
      endElement(element,augs);
  }

  /**
   * Receive notification of character data inside an element.
   *
   * <p>By default, do nothing.  Application writers may override this
   * method to take specific actions for each chunk of character data
   * (such as adding the data to a node or buffer, or printing it to
   * a file).</p>
   *
   * @param ch The characters.
   * @param start The start position in the character array.
   * @param length The number of characters to use from the
   *               character array.
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.ContentHandler#characters
   */
  public void characters(org.apache.xerces.xni.XMLString text,Augmentations augs) throws XNIException
  {
    try
    {
      super.characters(text.ch, text.offset, text.length);
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }

  /**
   * Receive notification of ignorable whitespace in element content.
   *
   * <p>By default, do nothing.  Application writers may override this
   * method to take specific actions for each chunk of ignorable
   * whitespace (such as adding data to a node or buffer, or printing
   * it to a file).</p>
   *
   * @param ch The whitespace characters.
   * @param start The start position in the character array.
   * @param length The number of characters to use from the
   *               character array.
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.ContentHandler#ignorableWhitespace
   */
  public void ignorableWhitespace(org.apache.xerces.xni.XMLString text, Augmentations augs)
    throws XNIException
  {
    // %OPT% We can probably take advantage of the fact that we know this 
    // is whitespace... or has that been dealt with at the source?
    try
    {
      super.characters(text.ch, text.offset, text.length);
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }

  /**
   * Receive notification of a processing instruction.
   *
   * <p>By default, do nothing.  Application writers may override this
   * method in a subclass to take specific actions for each
   * processing instruction, such as setting status variables or
   * invoking other methods.</p>
   *
   * @param target The processing instruction target.
   * @param data The processing instruction data, or null if
   *             none is supplied.
   * @throws XNIException Any XNI exception, possibly
   *            wrapping another exception.
   * @see org.xml.sax.ContentHandler#processingInstruction
   */
  public void processingInstruction(String target,org.apache.xerces.xni.XMLString data,Augmentations augs)
    throws XNIException
  {
    if (DEBUG)
      System.out.println("processingInstruction: target: " + target +", data: "+data);

    try
    {
      // %REVIEW% Can we avoid toString? I don't think so, given our 
      // current data structures, but that bears reconsideration
      super.processingInstruction(target,data.toString());
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }

  /**
   * Report the beginning of an entity in content.
   *
   * <p><strong>NOTE:</entity> entity references in attribute
   * values -- and the start and end of the document entity --
   * are never reported.</p>
   *
   * <p>The start and end of the external DTD subset are reported
   * using the pseudo-name "[dtd]".  All other events must be
   * properly nested within start/end entity events.</p>
   *
   * <p>Note that skipped entities will be reported through the
   * {@link org.xml.sax.ContentHandler#skippedEntity skippedEntity}
   * event, which is part of the ContentHandler interface.</p>
   *
   * @param name The name of the entity.  If it is a parameter
   *        entity, the name will begin with '%'.
   * @throws SAXException The application may raise an exception.
   * @see #endEntity
   * @see org.xml.sax.ext.DeclHandler#internalEntityDecl
   * @see org.xml.sax.ext.DeclHandler#externalEntityDecl
   */
  public void startGeneralEntity(String name,XMLResourceIdentifier identifier,
                                 String encoding,Augmentations augs) 
    throws XNIException
  {

    // no op
  }

  /**
   * Report the end of an entity.
   *
   * @param name The name of the entity that is ending.
   * @throws SAXException The application may raise an exception.
   * @see #startEntity
   */
  public void endGeneralEntity(String name,Augmentations augs) throws XNIException
  {

    // no op
  }
  
  /** Notifies of the presence of an XMLDecl line in the document. 
   * If present, this method will be called immediately following 
   * the startDocument call.
   * @param version - The XML version.
   * @param encoding - The IANA encoding name of the document, or null if not
   *    specified.
   * @param standalone - The standalone value, or null if not specified.
   * @param augs - Additional information that may include infoset augmentations
   * @throws XNIException - Thrown by handler to signal an error.
   * */
  public void xmlDecl(String version,String encoding,String standalone,
                      Augmentations augs)
    throws XNIException
  {

    // no op
  }
             
        
  /** Notifies of the presence of a TextDecl line in an entity. If present, this
   * method will be called immediately following the startEntity call. 
   * 
   * Note: This method will never be called for the document entity; it is only
   * called for external general entities referenced in document content. 
   * 
   * Note: This method is not called for entity references appearing as part of
   * attribute values.
   * @param version - The XML version, or null if not specified.
   * @param encoding - The IANA encoding name of the entity.
   * @param augs - Additional information that may include infoset augmentations
   * @throws XNIException - Thrown by handler to signal an error.
   * */
  public void textDecl(String version,String encoding,Augmentations augs)
    throws XNIException
  {

    // no op
  }
              

  /**
   * Report the start of a CDATA section.
   *
   * <p>The contents of the CDATA section will be reported through
   * the regular {@link org.xml.sax.ContentHandler#characters
   * characters} event.</p>
   *
   * @throws SAXException The application may raise an exception.
   * @see #endCDATA
   */
  public void startCDATA(Augmentations augs) throws XNIException
  {
    try
    {
      super.startCDATA();
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
        
  }

  /**
   * Report the end of a CDATA section.
   *
   * @throws SAXException The application may raise an exception.
   * @see #startCDATA
   */
  public void endCDATA(Augmentations augs) throws XNIException
  {
    try
    {
      super.endCDATA();
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }

  /**
   * Report an XML comment anywhere in the document.
   *
   * <p>This callback will be used for comments inside or outside the
   * document element, including comments in the external DTD
   * subset (if read).</p>
   *
   * @param ch An array holding the characters in the comment.
   * @param start The starting position in the array.
   * @param length The number of characters to use from the array.
   * @throws SAXException The application may raise an exception.
   */
  public void comment(org.apache.xerces.xni.XMLString text,Augmentations augs) throws XNIException
  {
    try
    {
      super.comment(text.ch,text.offset,text.length);
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }


  /** Helper class: Present XNI Locator info as SAX Locator
   * */
  private class LocatorWrapper 
    implements org.xml.sax.Locator
  {
    XMLLocator locator;
    String publicId=null;
    String systemId=null;
        
    public void setLocator(XMLLocator locator)
    { this.locator=locator; }
        
    public void setPublicId(String publicId)
    { this.publicId=publicId; }
        
    public void setSystemId(String systemId)
    { this.systemId=systemId; }
        
    public int getColumnNumber() 
    {
      return locator.getColumnNumber();
    }
    public int getLineNumber() 
    {
      return locator.getLineNumber();
    }
    public String getPublicId() 
    {
      return publicId;
    }
    public String getSystemId()         
    {
      return systemId;
    }
  }
  
  /** Notifies of the presence of the DOCTYPE line in the document.
         *  @param rootElement - The name of the root element.
         * @param publicId - The public identifier if an external DTD or null if the
         *        external DTD is specified using SYSTEM.
         * @param systemId - The system identifier if an external DTD, null otherwise.
         * @param augs - Additional information that may include infoset augmentations
         * @throws XNIException - Thrown by handler to signal an error.
         * */
  public void doctypeDecl(String rootElement,String publicId,String systemId,
                          Augmentations augs)
    throws XNIException
  {
    // no op
  }
    
  ////////////////////////////////////////////////////////////////////
  // XNI error handler
  
  public void warning(java.lang.String domain,
                      java.lang.String key,
                      XMLParseException exception)
    throws XNIException
  {
    // %REVIEW% Is there anyway to get the JAXP error listener here?
    System.err.println(exception);
  }
  public void error(java.lang.String domain,
                    java.lang.String key,
                    XMLParseException exception)
    throws XNIException
  {
    throw exception;
  }
  public void fatalError(java.lang.String domain,
                         java.lang.String key,
                         XMLParseException exception)
    throws XNIException
  {
    throw exception;
  }
  
  ////////////////////////////////////////////////////////////////////
  // XNI DTD handler. Needed for unparsed entities, but to get that
  // have to accept the other calls... which means we need to know the start
  // and end of the DTD to prevent DTD comments from being taken as
  // part of the main document.
  
  public void startDTD(XMLLocator locator,
                       Augmentations augmentations)
    throws XNIException
  {
    try
    {
      super.startDTD("unknownDocumentTypeName",locator.getPublicId(),locator.getLiteralSystemId());
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }
  
  public void startParameterEntity(java.lang.String name,
                                   XMLResourceIdentifier identifier,
                                   java.lang.String encoding,
                                   Augmentations augmentations)
    throws XNIException
  {
    // no op
  }
  
  // textDecl already handled
  
  public void endParameterEntity(java.lang.String name,
                                 Augmentations augmentations)
    throws XNIException  
  {
    // no op
  }
  public void startExternalSubset(Augmentations augmentations)
    throws XNIException  
  {
    // no op
  }
  public void endExternalSubset(Augmentations augmentations)
    throws XNIException  
  {
    // no op
  }  
  
  // comment already handled, including suppression during the DTD
  // processing instruction already handled. NOT currently suppressed during DTD?
  
  public void elementDecl(java.lang.String name,
                          java.lang.String contentModel,
                          Augmentations augmentations)
    throws XNIException
  {
    //no op
  }
  public void startAttlist(java.lang.String elementName,
                           Augmentations augmentations)
    throws XNIException
  {
    //no op
  }
  
  public void attributeDecl(String elementName,String attributeName, 
                            java.lang.String type, java.lang.String[] enumeration, 
                            String defaultType, XMLString defaultValue,
                            XMLString nonNormalizedDefaultValue, Augmentations augmentations)
    throws XNIException
  { 
    // no op
  }
  
  public void endAttlist(Augmentations augmentations)
    throws XNIException  
  {
    //no op
  }
  public void internalEntityDecl(String name, XMLString text, 
                                 XMLString nonNormalizedText,
                                 Augmentations augmentations) 
    throws XNIException
  {
    //no op
  }
  public void externalEntityDecl(java.lang.String name,
                                 XMLResourceIdentifier identifier,
                                 Augmentations augmentations)
    throws XNIException
  {
    //no op
  }
  
  public void unparsedEntityDecl(java.lang.String name,
                                 XMLResourceIdentifier identifier,
                                 java.lang.String notation,
                                 Augmentations augmentations)
    throws XNIException
  {
    // This one's the wnole point of the exercise...
    try
    {
      super.unparsedEntityDecl(name,identifier.getPublicId(),identifier.getLiteralSystemId(),notation);
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }     
 
  public void notationDecl(java.lang.String name,
                           XMLResourceIdentifier identifier,
                           Augmentations augmentations)
    throws XNIException
  {
    // no op
  }
  public void startConditional(short type,
                               Augmentations augmentations)
    throws XNIException
  {
    // no op
  }
  
  public void ignoredCharacters(XMLString text, Augmentations augmentations)
    throws XNIException
  {
    // no op
  }
  public void endConditional(Augmentations augmentations)
    throws XNIException
  {
    // no op
  }
  
  public void endDTD(Augmentations augmentations)
    throws XNIException
  {
    try
    {
      super.endDTD();
    } 
    catch(SAXException e)
    {
      throw new XNIException(e);
    }
  }     
 
  ////////////////////////////////////////////////////////////////////
  ////////////////////////////////////////////////////////////////////
  // %REVIEW% SAX APIs are currently _blocked_ for debugging purposes. We can
  // re-enable them if/when we fold the XNI support back into the main SAX2DTM
  ////////////////////////////////////////////////////////////////////
  ////////////////////////////////////////////////////////////////////
  
 
  // Implementation of DTDHandler interface.

  // SAME AS XNI? OR DID WE RETAIN THEM ABOVE FOR OTHER REASONS?
  //public void notationDecl(String name, String publicId, String systemId)
  //        throws SAXException
  // public void unparsedEntityDecl(
  //        String name, String publicId, String systemId, String notationName)
  //        throws SAXException

  // Implementation of ContentHandler interface.

  public void setDocumentLocator(org.xml.sax.Locator locator)
  {
    throw new RuntimeException(UNEXPECTED+"setDocumentLocator");
  }
  public void startDocument() throws SAXException
  {
    throw new SAXException(UNEXPECTED+"startDocument");
  }
  public void endDocument() throws SAXException
  {
    throw new SAXException(UNEXPECTED+"endDocument");
  }
  public void startPrefixMapping(String prefix, String uri)
    throws SAXException
  {
    throw new SAXException(UNEXPECTED+"startPrefixMapping");
  }
  public void endPrefixMapping(String prefix) throws SAXException
  {
    throw new SAXException(UNEXPECTED+"endPrefixMapping");
  }
  public void startElement(
                           String uri, String localName, String qName, org.xml.sax.Attributes attributes)
    throws SAXException
  {
    throw new SAXException(UNEXPECTED+"startElement");
  }
  public void endElement(String uri, String localName, String qName)
    throws SAXException
  {
    throw new SAXException(UNEXPECTED+"endElement");
  }
  public void characters(char ch[], int start, int length) throws SAXException
  {
    throw new SAXException(UNEXPECTED+"characters");
  }
  public void ignorableWhitespace(char ch[], int start, int length)
    throws SAXException
  {
    throw new SAXException(UNEXPECTED+"ignorableWhitespace");
  }
  public void processingInstruction(String target, String data)
    throws SAXException
  {
    throw new SAXException(UNEXPECTED+"processingInstruction");
  }
  public void skippedEntity(String name) throws SAXException
  {
    throw new SAXException(UNEXPECTED+"skippedEntity");
  }
  
  // Implementation of SAX error handler

  public void warning(SAXParseException e) throws SAXException
  {
    // %REVIEW% Is there anyway to get the JAXP error listener here?
    throw new SAXException(UNEXPECTED+"Warning: "+e.getMessage());
  }
  public void error(SAXParseException e) throws SAXException
  {
    throw new SAXException(UNEXPECTED+"Error: "+e.getMessage());
  }
  public void fatalError(SAXParseException e) throws SAXException
  {
    throw new SAXException(UNEXPECTED+"Fatal Error: "+e.getMessage());
  }

  // Implementation of SAX DeclHandler interface.
  
  public void elementDecl(String name, String model) throws SAXException
  {
    throw new SAXException(UNEXPECTED+"elementDecl "+name);
  }
  public void attributeDecl(
                            String eName, String aName, String type, String valueDefault, String value)
    throws SAXException
  {
    throw new SAXException(UNEXPECTED+"attributeDecl "+aName);
  }
  public void internalEntityDecl(String name, String value)
    throws SAXException
  {
    throw new SAXException(UNEXPECTED+"internalEntityDecl "+name);
  }
  public void externalEntityDecl(
                                 String name, String publicId, String systemId) throws SAXException
  {
    throw new SAXException(UNEXPECTED+"externalEntityDecl "+name);
  }

  // Implementation of the LexicalHandler interface.
  public void startDTD(String name, String publicId, String systemId)
    throws SAXException
  {
    throw new SAXException(UNEXPECTED+"startDTD");
  }
  public void endDTD() throws SAXException
  {
    throw new SAXException(UNEXPECTED+"endDTD");
  }


  //============================================================/  
  
  /** Inner class: The full XNI ItemPSVI is far too heavy-weight for
   * our needs. But their XSTypeDecl isn't quite heavy enough; it gives
   * us the actual member type, but that may be anonymous... so to get
   * what XPath2 considers the proper typename, we need to examine
   * additional fields as well. This class is an attempt to compromise by
   * resolving the typename and storing that alongside the member type.
   * 
   * A more efficient solution undoubtedly exists. But since XNI's PSVI
   * APIs are still in flux, and since I'm just trying to get an initial
   * demo running, this will suffice for now.
   * %REVIEW% periodically!
   * */
  protected class XPath2Type
  {
  	public XSTypeDecl m_xniType;
  	public String m_namespace;
  	public String m_localName;
  	
  	/** Constructor for our internal type representation
  	 *   We will extract the low-level XSTypeDecl for the Member Type,
  	 *   and determine the proper namespace and localname. Other data
  	 *   can (hopefully) be GC'd after we're done. This is still NOT
  	 *   a lightweight beast.
  	 * 
  	 * @param psvi XNI Post-Schema-Validation Infoset annotation.
  	 * @param isAttr True iff we're defining type for an attribute.
  	 * */
  	public XPath2Type(ItemPSVI psvi, boolean isAttr)
  	{
  		// First get the member type. Need to go down a level...
  		// not sure whether there's a shared interface
  		if(psvi==null)
	  		m_xniType=null;
  		else if(!isAttr)
	  		m_xniType=((ElementPSVImpl)psvi).getTypeDefinition();
  		else
	  		m_xniType=((AttributePSVImpl)psvi).getTypeDefinition();
  	
  		// Now resolve the typename.
  		// There are some quibbles about algorithm; see comments on
  		// the resolve methods.
  		lightResolveTypeName(psvi,isAttr);
  	}
  	
  	/** Identity needs to be defined so we can do sparse storage.
  	 * %REVIEW% I'm not sure all three fields need to be checked, but...
  	 * */
  	public boolean equals(XPath2Type other)
  	{
		// Could cache hashCode()'s result and use that to accelerate
		// doesn't-equal testing at the cost of some storage and
		// slowing down does-equal tests. Not convinced it's useful here.
		// %REVIEW%
  		return (m_xniType==other.m_xniType ||
  			m_xniType!=null && m_xniType.equals(other.m_xniType)) &&
  			// These two won't be null
  			m_namespace.equals(other.m_namespace) &&
  			m_localName.equals(other.m_localName);
  	}
  	  	
  	/** Identity needs to be defined so we can do sparse storage.
  	 * %REVIEW% I'm not sure all three fields need to be checked, but...
  	 * */
  	public int hashCode()
  	{
  		// Could cache hashCode(). See discussion in equals().
  		// %REVIEW%
  		return m_namespace.hashCode()+m_localName.hashCode()+
  			(m_xniType==null ? 0 : m_xniType.hashCode());
  	}
  	
  	public String getTargetNamespace() {return m_namespace;}
  	public String getTypeName() {return m_localName;}
  	
  	public boolean derivedFrom(String namespace,String localname)
  	{
  		if(m_xniType!=null)
	  		return m_xniType.derivedFrom(namespace,localname);
	  		
	  	// Fallback in case no PSVI info was passed in: exact match
	  	// (it's got to be the correct m_any*Type).
	  	else return(m_namespace.equals(namespace) && m_localName.equals(localname));
  	}
  	
  /** Broken out into a subroutine so I can use it for debugging purposes.
   * This logic is adapted from the Xerces SimpleTypeUsage.validateString() example.
   * 
   * %REVIEW% May be more efficient to fold it back in.
   * 
   * @param actualType Xerces PSVI type declaration object
   * @param textValue Text content to be interpreted
   * @return DTM_XSequence containing one or more Java values, as appropriate
   *   to the Built-In Type we have inherited from -- or null if no such 
   *   mapping exists (eg, if actualType was complex)
   * */         
  public XSequence typedValue(String textvalue)
  {
    Object value;
    DTM_XSequence seq=null;

    if(m_xniType instanceof XSSimpleTypeDecl)
    {           
      //create an instance of 'ValidatedInfo' to get back information (like actual value,
      //normalizedValue etc..)after content is validated.
      ValidatedInfo validatedInfo = new ValidatedInfo(); // %REVIEW% Can we reuse???

      //get proper validation context , this is very important we need to get appropriate validation context while validating content
      //validation context passed is generally different while validating content and  creating simple type (applyFacets)
      ValidationContext validationState = new ValidationState();
      // This may need to be refined using:
      //validationState.setNamespaceSupport(...);
      //validationState.setSymbolTable(....);
      //validationState.setFacetChecking(true);
      //validationState.setExtraChecking(false);        

      // Validate and parse the string
      try{
        ((XSSimpleTypeDecl)m_xniType).validate(textvalue, validationState, validatedInfo);
      } catch(InvalidDatatypeValueException ex){
        // Should never happen, since we've already validated...?
        System.err.println(ex.getMessage());
        ex.printStackTrace();
      }

      //now 'validatedInfo' object contains information

      // for number types (decimal, double, float, and types derived from them),
      // Object return is BigDecimal, Double, Float respectively.
      // Boolean is handled similarly.
      // Some types (string and derived) just return the string itself.
      value = validatedInfo.actualValue;

      //The normalized value of a string type
      // (Should we check for stings and return this instead?)
      String normalizedValue = validatedInfo.normalizedValue ;

      // If the type is a union type, then the member type which
      // actually validated the string value will be:
      // XSSimpleType memberType = validatedInfo.memberType ;

      // %REVIEW% I presume this handles lists by returning arrays...?
                
      seq=new DTM_XSequence(value,(XSSimpleTypeDecl)m_xniType);
    }
        
    return seq==null ? XSequence.EMPTY : seq;
  }

  /** Implementation of the XPath2 type-name resolution algorithm
   * (data model 3.5). 
   * 
   * Code donated by Sandy Gao, using the proposed
   * Heavy-Weight PSVI interfaces (not yet implemented in Xerces)
   * 
   * @param psvi  the psvi information for the current node
   * @param attr false for element (fallback is xs:anyType)
   *              true for attribute (fallback is xs:anySimpleType)
   * */  
  protected void heavyResolveTypeName(ItemPSVI psvi, boolean attr)
  {
  	/* Not compatable with old light-weight schema APIs

  	// NAME OF THIS CONSTANT IS IN FLUX
  	//int VALID=ItemPSVI.VALIDITY_VALID;
  	int VALID=ItemPSVI.VALID_VALIDITY;
  	
        // check whether the node is valid
        if (psvi == null ||
            psvi.getValidity() != VALID) {
            // if the node is not valid, then return xs:anyType
            m_namespace = "http://www.w3.org/2001/XMLSchema";
            m_localName = attr ? "anySimpleType" : "anyType";
            return;
        }
        
        // try to get the member type definition, and return its name
        XSSimpleTypeDefinition member = psvi.getMemberTypeDefinition();
        if (member != null) {
            m_namespace = member.getNamespace();
            m_localName = member.getName();
            return;
        }
        
        // try to get the type definition, and return its name
        XSTypeDefinition type = psvi.getTypeDefinition();
        if (type != null) {
            m_namespace = type.getNamespace();
            m_localName = type.getName();
            return;
        }
        
        
  	// Member type definitions promised to be available;
  	// can't proceed to check names independently

        // all failed, return xs:anyType
        m_namespace = "http://www.w3.org/2001/XMLSchema";
        m_localName = attr ? "anySimpleType" : "anyType";
        return;
  */ throw new java.lang.UnsupportedOperationException("Xerces Heavyweight PSVI not yet avaialble"); /**/       
  }
  
  /** Modification of the XPath2 type-name resolution algorithm
   * to reflect Sandy Gao's concerns about the official version
   * not tolerating processors that implement the "lightweight" version
   * of PSVI.
   * 
   * Code donated by Sandy Gao, using the proposed
   * Heavy-Weight PSVI interfaces (not yet implemented in Xerces)
   * 
   * @param psvi  the psvi information for the current node
   * @param attr false for element (fallback is xs:anyType)
   *              true for attribute (fallback is xs:anySimpleType)
   * */  
  protected void proposedHeavyResolveTypeName(ItemPSVI psvi, boolean attr)
  {
  	/* Not compatable with old light-weight schema APIs

  	// NAME OF THIS CONSTANT IS IN FLUX
  	//int VALID=ItemPSVI.VALIDITY_VALID;
  	int VALID=ItemPSVI.VALID_VALIDITY;
  	
        // check whether the node is valid
        if (psvi == null ||
            psvi.getValidity() != VALID) {
            // if the node is not valid, then return xs:anyType
            m_namespace = "http://www.w3.org/2001/XMLSchema";
	        m_localName = attr ? "anySimpleType" : "anyType";
            return;
        }
        
        // try to get the member type definition, and return its name
        XSSimpleTypeDefinition member = psvi.getMemberTypeDefinition();
        if (member != null && member.getName() != null) {
            m_namespace = member.getNamespace();
            m_localName = member.getName();
            return;
        }
        
        // try to get the type definition, and return its name
        XSTypeDefinition type = psvi.getTypeDefinition();
        if (type != null && type.getName() != null) {
            m_namespace = type.getNamespace();
            m_localName = type.getName();
            return;
        }
        
  	// Member type definitions promised to be available;
  	// can't proceed to check names independently

        // all failed, return xs:anyType
        m_namespace = "http://www.w3.org/2001/XMLSchema";
        m_localName = attr ? "anySimpleType" : "anyType";
        return;
  */ throw new java.lang.UnsupportedOperationException("Xerces Heavyweight PSVI not yet avaialble"); /**/       
  }
  
  /** Attempt to write a simplified version of the type resolution
   * algorithm (data model 3.5) using only the Light-Weight PSVI
   * interfaces currently supported in Xerces (which I believe will be
   * phased out when heavyweight come into play).
   * 
   * Basd on code donated by Sandy Gao
   * 
   * @param psvi  the psvi information for the current node
   * @param ret   a String array with size 2
   *              index 0 is used to return the namespace name;
   *              index 1 is used to return the local name.
   * @param attr false for element (fallback is xs:anyType)
   *              true for attribute (fallback is xs:anySimpleType)
   * */  
  protected void lightResolveTypeName(ItemPSVI psvi, boolean attr)
  {
  	/* Not compatable with new heavy-weight schema APIs
  	*/
  	
  	int VALID=ItemPSVI.VALID_VALIDITY;
  	
        // check whether the node is valid
        if (psvi == null ||
            psvi.getValidity() != VALID) {
            // if the node is not valid, then return xs:anyType
            m_namespace = "http://www.w3.org/2001/XMLSchema";
            m_localName = attr ? "anySimpleType" : "anyType";
            return;
        }
        
	  	// Member type definitions promised NOT to be available;
 	 	// proceed to check names independently

		// Need the second test, apparently
        if (!psvi.isMemberTypeAnonymous() && null!=psvi.getMemberTypeName() ) {
            m_namespace = psvi.getMemberTypeNamespace();
            m_localName = psvi.getMemberTypeName();
            return;
        }
        
		// Need the second test, apparently
        if (!psvi.isTypeAnonymous() && null!=psvi.getTypeName()) {
            m_namespace = psvi.getTypeNamespace();
            m_localName = psvi.getTypeName();
            return;
        }
        
        // all failed, return xs:anyType
        m_namespace = "http://www.w3.org/2001/XMLSchema";
        m_localName = attr ? "anySimpleType" : "anyType";
        return;
  // throw new java.lang.UnsupportedOperationException("Xerces Lightweight PSVI phased out"); /**/
  }
  } // XPath2Type
} // XNI2DTM