saxdriver.java

好东西啊！你看看就知道了

	    while (entityNames.hasMoreElements ()) {
		ename = (String) entityNames.nextElement ();
		type = parser.getEntityType (ename);

		if (ename.charAt (0) == '%')
		    continue;

		// unparsed
		if (type == XmlParser.ENTITY_NDATA) {
		    publicId = parser.getEntityPublicId (ename);
		    systemId = parser.getEntitySystemId (ename);
		    nname = parser.getEntityNotationName (ename);
		    dtdHandler.unparsedEntityDecl (ename,
						    publicId, systemId, nname);

		    // external parsed
		}
		else if (type == XmlParser.ENTITY_TEXT) {
		    publicId = parser.getEntityPublicId (ename);
		    systemId = parser.getEntitySystemId (ename);
		    declHandler.externalEntityDecl (ename,
						     publicId, systemId);

		    // internal parsed
		}
		else if (type == XmlParser.ENTITY_INTERNAL) {
		    // filter out the built-ins; even if they were
		    // declared, they didn't need to be.
		    if ("lt".equals (ename) || "gt".equals (ename)
			    || "quot".equals (ename)
			    || "apos".equals (ename)
			    || "amp".equals (ename))
			continue;
		    declHandler.internalEntityDecl (ename,
				 parser.getEntityValue (ename));
		}
	    }
	}

	// elements, attributes
	if (declHandler != base) {
	    Enumeration	elementNames = parser.declaredElements ();
	    Enumeration	attNames;

	    while (elementNames.hasMoreElements ()) {
		String model = null;

		ename = (String) elementNames.nextElement ();
		switch (parser.getElementContentType (ename)) {
		    case XmlParser.CONTENT_ANY:
			model = "ANY";
			break;
		    case XmlParser.CONTENT_EMPTY:
			model = "EMPTY";
			break;
		    case XmlParser.CONTENT_MIXED:
		    case XmlParser.CONTENT_ELEMENTS:
			model = parser.getElementContentModel (ename);
			break;
		    case XmlParser.CONTENT_UNDECLARED:
		    default:
			model = null;
			break;
		}
		if (model != null)
		    declHandler.elementDecl (ename, model);

		attNames = parser.declaredAttributes (ename);
		while (attNames != null && attNames.hasMoreElements ()) {
		    String aname = (String) attNames.nextElement ();
		    String type;
		    String valueDefault;
		    String value;

		    switch (parser.getAttributeType (ename, aname)) {
		    case XmlParser.ATTRIBUTE_CDATA:
			type = "CDATA";
			break;
		    case XmlParser.ATTRIBUTE_ENTITY:
			type = "ENTITY";
			break;
		    case XmlParser.ATTRIBUTE_ENTITIES:
			type = "ENTITIES";
			break;
		    case XmlParser.ATTRIBUTE_ENUMERATED:
			type = parser.getAttributeEnumeration (ename, aname);
			break;
		    case XmlParser.ATTRIBUTE_ID:
			type = "ID";
			break;
		    case XmlParser.ATTRIBUTE_IDREF:
			type = "IDREF";
			break;
		    case XmlParser.ATTRIBUTE_IDREFS:
			type = "IDREFS";
			break;
		    case XmlParser.ATTRIBUTE_NMTOKEN:
			type = "NMTOKEN";
			break;
		    case XmlParser.ATTRIBUTE_NMTOKENS:
			type = "NMTOKENS";
			break;

			// XXX SAX2 doesn't have a way to return the
			// enumerated list of permitted notations ... it's
			// kluged it as NMTOKEN in startElement(),
			// but that won't work for
			// the sort of apps that really use the DTD info
		    case XmlParser.ATTRIBUTE_NOTATION:
			type = "NOTATION";
			break;

		    default:
			errorHandler.fatalError (new SAXParseException (
				  "internal error, att type", this));
			type = null;
		    }

		    switch (parser.getAttributeDefaultValueType (
				 ename, aname)) {
		    case XmlParser.ATTRIBUTE_DEFAULT_IMPLIED:
			valueDefault = "#IMPLIED";
			break;
		    case XmlParser.ATTRIBUTE_DEFAULT_REQUIRED:
			valueDefault = "#REQUIRED";
			break;
		    case XmlParser.ATTRIBUTE_DEFAULT_FIXED:
			valueDefault = "#FIXED";
			break;
		    case XmlParser.ATTRIBUTE_DEFAULT_SPECIFIED:
			valueDefault = null;
			break;

		    default:
			errorHandler.fatalError (new SAXParseException (
				    "internal error, att default", this));
			valueDefault = null;
		    }

		    value = parser.getAttributeDefaultValue (ename, aname);

		    declHandler.attributeDecl (ename, aname,
						type, valueDefault, value);
		}
	    }
	}
    }


    //
    // Implementation of org.xml.sax.Attributes.
    //

    /**
     * <b>SAX1 AttributeList, SAX2 Attributes</b> method
     * (don't invoke on parser);
     */
    public int getLength ()
    {
	return attributeNames.size ();
    }

    /**
     * <b>SAX2 Attributes</b> method (don't invoke on parser);
     */
    public String getURI (int index)
    {
	return (String) (attributeNamespaces.elementAt (index));
    }

    /**
     * <b>SAX2 Attributes</b> method (don't invoke on parser);
     */
    public String getLocalName (int index)
    {
	return (String) (attributeLocalNames.elementAt (index));
    }

    /**
     * <b>SAX2 Attributes</b> method (don't invoke on parser);
     */
    public String getQName (int i)
    {
	return (String) (attributeNames.elementAt (i));
    }

    /**
     * <b>SAX1 AttributeList</b> method (don't invoke on parser);
     */
    public String getName (int i)
    {
	return (String) (attributeNames.elementAt (i));
    }

    /**
     * <b>SAX1 AttributeList, SAX2 Attributes</b> method
     * (don't invoke on parser);
     */
    public String getType (int i)
    {
	switch (parser.getAttributeType (elementName, getQName (i))) {

	case XmlParser.ATTRIBUTE_UNDECLARED:
	case XmlParser.ATTRIBUTE_CDATA:
	    return "CDATA";
	case XmlParser.ATTRIBUTE_ID:
	    return "ID";
	case XmlParser.ATTRIBUTE_IDREF:
	    return "IDREF";
	case XmlParser.ATTRIBUTE_IDREFS:
	    return "IDREFS";
	case XmlParser.ATTRIBUTE_ENTITY:
	    return "ENTITY";
	case XmlParser.ATTRIBUTE_ENTITIES:
	    return "ENTITIES";
	case XmlParser.ATTRIBUTE_ENUMERATED:
	    // XXX doesn't have a way to return permitted enum values,
	    // though they must each be a NMTOKEN 
	case XmlParser.ATTRIBUTE_NMTOKEN:
	    return "NMTOKEN";
	case XmlParser.ATTRIBUTE_NMTOKENS:
	    return "NMTOKENS";
	case XmlParser.ATTRIBUTE_NOTATION:
	    // XXX doesn't have a way to return the permitted values,
	    // each of which must be name a declared notation
	    return "NOTATION";

	}

	return null;
    }


    /**
     * <b>SAX1 AttributeList, SAX2 Attributes</b> method
     * (don't invoke on parser);
     */
    public String getValue (int i)
    {
	return (String) (attributeValues.elementAt (i));
    }


    /**
     * <b>SAX2 Attributes</b> method (don't invoke on parser);
     */
    public int getIndex (String uri, String local)
    {
	int length = getLength ();

	for (int i = 0; i < length; i++) {
	    if (!getURI (i).equals (uri))
		continue;
	    if (getLocalName (i).equals (local))
		return i;
	}
	return -1;
    }


    /**
     * <b>SAX2 Attributes</b> method (don't invoke on parser);
     */
    public int getIndex (String xmlName)
    {
	int length = getLength ();

	for (int i = 0; i < length; i++) {
	    if (getQName (i).equals (xmlName))
		return i;
	}
	return -1;
    }


    /**
     * <b>SAX2 Attributes</b> method (don't invoke on parser);
     */
    public String getType (String uri, String local)
    {
	int index = getIndex (uri, local);

	if (index < 0)
	    return null;
	return getType (index);
    }


    /**
     * <b>SAX1 AttributeList, SAX2 Attributes</b> method
     * (don't invoke on parser);
     */
    public String getType (String xmlName)
    {
	int index = getIndex (xmlName);

	if (index < 0)
	    return null;
	return getType (index);
    }


    /**
     * <b>SAX Attributes</b> method (don't invoke on parser);
     */
    public String getValue (String uri, String local)
    {
	int index = getIndex (uri, local);

	if (index < 0)
	    return null;
	return getValue (index);
    }


    /**
     * <b>SAX1 AttributeList, SAX2 Attributes</b> method
     * (don't invoke on parser);
     */
    public String getValue (String xmlName)
    {
	int index = getIndex (xmlName);

	if (index < 0)
	    return null;
	return getValue (index);
    }


    //
    // Implementation of org.xml.sax.Locator.
    //

    /**
     * <b>SAX Locator</b> method (don't invoke on parser);
     */
    public String getPublicId ()
    {
	return null; 		// XXX track public IDs too
    }

    /**
     * <b>SAX Locator</b> method (don't invoke on parser);
     */
    public String getSystemId ()
    {
	return (String) entityStack.peek ();
    }

    /**
     * <b>SAX Locator</b> method (don't invoke on parser);
     */
    public int getLineNumber ()
    {
	return parser.getLineNumber ();
    }

    /**
     * <b>SAX Locator</b> method (don't invoke on parser);
     */
    public int getColumnNumber ()
    {
	return parser.getColumnNumber ();
    }

    // adapter between content handler and document handler callbacks
    private static class Adapter implements ContentHandler
    {
	private DocumentHandler		docHandler;

	Adapter (DocumentHandler dh)
	    { docHandler = dh; }


	public void setDocumentLocator (Locator l)
	    { docHandler.setDocumentLocator (l); }
	
	public void startDocument () throws SAXException
	    { docHandler.startDocument (); }
	
	public void processingInstruction (String target, String data)
	throws SAXException
	    { docHandler.processingInstruction (target, data); }
	
	public void startPrefixMapping (String prefix, String uri)
	    { /* ignored */ }

	public void startElement (
	    String	namespace,
	    String	local,
	    String	name,
	    Attributes	attrs
	) throws SAXException
	    { docHandler.startElement (name, (AttributeList) attrs); }

	public void characters (char buf [], int offset, int len)
	throws SAXException
	    { docHandler.characters (buf, offset, len); }

	public void ignorableWhitespace (char buf [], int offset, int len)
	throws SAXException
	    { docHandler.ignorableWhitespace (buf, offset, len); }

	public void skippedEntity (String name)
	    { /* ignored */ }

	public void endElement (String u, String l, String name)
	throws SAXException
	    { docHandler.endElement (name); }

	public void endPrefixMapping (String prefix)
	    { /* ignored */ }

	public void endDocument () throws SAXException
	    { docHandler.endDocument (); }
    }
}