saxdriver.java

Java的面向对象数据库系统的源代码

            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) {
        Iterator    elementNames = parser.declaredElements ();
        Iterator    attNames;

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

        ename = (String) elementNames.next ();
        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.hasNext ()) {
            String aname = (String) attNames.next ();
            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.getAttributeIterator (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 beta doesn't have a way to return the
            // enumerated list of permitted notations ... SAX1
            // kluged it as NMTOKEN, 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.get (index));
    }

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

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

    /**
     * <b>SAX1 AttributeList</b> method (don't invoke on parser);
     */
    public String getName (int i)
    {
        return (String) (attributeNames.get (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.get (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.get ( entityStack.size() - 1 );
    }

    /**
     * <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 (); }
    }
}