Java example source code file (DTDBuilder.java)

This example Java source code file (DTDBuilder.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

attributelist, contentmodel, dataoutputstream, dtdbuilder, element, entity, enumeration, fileinputstream, hashtable, integer, ioexception, net, network, publicmapping, string, util, vector, zip

The DTDBuilder.java Java example source code

/*
 * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package build.tools.dtdbuilder;

import javax.swing.text.html.parser.*;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.io.BufferedInputStream;
import java.io.OutputStream;
import java.util.Hashtable;
import java.util.Vector;
import java.util.BitSet;
import java.util.StringTokenizer;
import java.util.Enumeration;
import java.util.Properties;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.Deflater;
import java.net.URL;

/**
 * The representation of an SGML DTD. This is produced by the DTDParser.
 * The resulting DTD object describes a document syntax and is needed
 * to parse HTML documents using the Parser. It contains a list of
 * elements and their attributes as well as a list of entities defined
 * in the DTD.
 *
 * @see Element
 * @see AttributeList
 * @see ContentModel
 * @see DTDParser
 * @see Parser
 * @author Arthur van Hoff
 */
public
class DTDBuilder extends DTD {

    static PublicMapping mapping = null;

    // Hash from name to Integer
    private Hashtable<String, Integer> namesHash = new Hashtable<>();
    // Vector of all names
    private Vector<String> namesVector = new Vector<>();

    /**
     * Create a new DTD.
     */
    protected DTDBuilder(String name) {
        super(name);
    }


    /**
     * Save to a stream as a Java class. Instantiating this class will
     * reproduce a (virtually) identical DTD.
     */
    void save(DataOutputStream out, String className) throws IOException {

        out.writeInt(DTD.FILE_VERSION);

        buildNamesTable();
        int numNames = namesVector.size();
        out.writeShort((short) (namesVector.size()));
        for (int i = 0; i < namesVector.size(); i++) {
            String nm = namesVector.elementAt(i);
            out.writeUTF(nm);
        }

        saveEntities(out);

        out.writeShort((short) (elements.size()));
        for (Enumeration<Element> e = elements.elements() ; e.hasMoreElements() ; ) {
            saveElement(out, e.nextElement());
        }

        if (namesVector.size() != numNames) {
            System.err.println("!!! ERROR!  Names were added to the list!");
            Thread.dumpStack();
            System.exit(1);
        }
    }

    private void buildNamesTable() {
        for (Enumeration<Entity> e = entityHash.elements() ; e.hasMoreElements() ; ) {
            Entity ent = e.nextElement();
            // Do even if not isGeneral().  That way, exclusions and inclusions
            // will definitely have their element.
            getNameId(ent.getName());
        }
        for (Enumeration<Element> e = elements.elements() ; e.hasMoreElements() ; ) {
            Element el = e.nextElement();
            getNameId(el.getName());
            for (AttributeList atts = el.getAttributes() ; atts != null ; atts = atts.getNext()) {
                getNameId(atts.getName());
                if (atts.getValue() != null) {
                    getNameId(atts.getValue());
                }
                Enumeration<?> vals = atts.getValues();
                while (vals != null && vals.hasMoreElements()) {
                    String s = (String) vals.nextElement();
                    getNameId(s);
                }
            }
        }
    }

    //
    // The the id of a name from the list of names
    //
    private short getNameId(String name)  {
        Integer o = namesHash.get(name);
        if (o != null) {
            return (short) o.intValue();
        }
        int i = namesVector.size();
        namesVector.addElement(name);
        namesHash.put(name, new Integer(i));
        return (short) i;
    }


    /**
     * Save an entity to a stream.
     */
    void saveEntities(DataOutputStream out) throws IOException {
        int num = 0;
        for (Enumeration<Entity> e = entityHash.elements() ; e.hasMoreElements() ; ) {
            Entity ent = e.nextElement();
            if (ent.isGeneral()) {
                num++;
            }
        }

        out.writeShort((short) num);
        for (Enumeration<Entity> e = entityHash.elements() ; e.hasMoreElements() ; ) {
            Entity ent = e.nextElement();
            if (ent.isGeneral()) {
                out.writeShort(getNameId(ent.getName()));
                out.writeByte(ent.getType() & ~GENERAL);
                out.writeUTF(ent.getString());
            }
        }
    }


    /**
     * Save an element to a stream.
     */

    public void saveElement(DataOutputStream out, Element elem) throws IOException {

        out.writeShort(getNameId(elem.getName()));
        out.writeByte(elem.getType());

        byte flags = 0;
        if (elem.omitStart()) {
            flags |= 0x01;
        }
        if (elem.omitEnd()) {
            flags |= 0x02;
        }
        out.writeByte(flags);
        saveContentModel(out, elem.getContent());

        // Exclusions
        if (elem.exclusions == null) {
            out.writeShort(0);
        } else {
            short num = 0;
            for (int i = 0 ; i < elem.exclusions.size() ; i++) {
                if (elem.exclusions.get(i)) {
                    num++;
                }
            }
            out.writeShort(num);
            for (int i = 0 ; i < elem.exclusions.size() ; i++) {
                if (elem.exclusions.get(i)) {
                    out.writeShort(getNameId(getElement(i).getName()));
                }
            }
        }

        // Inclusions
        if (elem.inclusions == null) {
            out.writeShort(0);
        } else {
            short num = 0;
            for (int i = 0 ; i < elem.inclusions.size() ; i++) {
                if (elem.inclusions.get(i)) {
                    num++;
                }
            }
            out.writeShort(num);
            for (int i = 0 ; i < elem.inclusions.size() ; i++) {
                if (elem.inclusions.get(i)) {
                    out.writeShort(getNameId(getElement(i).getName()));
                }
            }
        }

        // Attributes
        {
            short numAtts = 0;
            for (AttributeList atts = elem.getAttributes() ; atts != null ; atts = atts.getNext()) {
                numAtts++;
            }
            out.writeByte(numAtts);
            for (AttributeList atts = elem.getAttributes() ; atts != null ; atts = atts.getNext()) {
                out.writeShort(getNameId(atts.getName()));
                out.writeByte(atts.getType());
                out.writeByte(atts.getModifier());
                if (atts.getValue() == null) {
                    out.writeShort(-1);
                } else {
                    out.writeShort(getNameId(atts.getValue()));
                }
                if (atts.values == null) {
                    out.writeShort(0);
                } else {
                    out.writeShort((short) atts.values.size());
                    for (int i = 0; i < atts.values.size(); i++) {
                        String s = (String) atts.values.elementAt(i);
                        out.writeShort(getNameId(s));
                    }
                }
            }
        }
    }


    /**
     * Save a content model to a stream. This does a
     * recursive decent of the entire model.
     */
    public void saveContentModel(DataOutputStream out, ContentModel model) throws IOException {
        if (model == null) {
            out.writeByte(0);
        } else if (model.content instanceof ContentModel) {
            out.writeByte(1);
            out.writeByte(model.type);
            saveContentModel(out, (ContentModel)model.content);

            saveContentModel(out, model.next);
        } else if (model.content instanceof Element) {
            out.writeByte(2);
            out.writeByte(model.type);
            out.writeShort(getNameId(((Element) model.content).getName()));

            saveContentModel(out, model.next);
        }
    }


    /**
     * Generate a class representing this DTD.
     */

    public static void main(String argv[]) {

        String dtd_home = System.getProperty("dtd_home") + File.separator;
        if (dtd_home == null) {
            System.err.println("Must set property 'dtd_home'");
            return;
        }

        DTDBuilder dtd = null;
        try {
            dtd = new DTDBuilder(argv[0]);
            mapping = new PublicMapping(dtd_home, "public.map");
            String path = mapping.get(argv[0]);
            new DTDParser().parse(new FileInputStream(path), dtd);

        } catch (IOException e) {
            System.err.println("Could not open DTD file "+argv[0]);
            e.printStackTrace(System.err);
            System.exit(1);
        }
        try {
            DataOutputStream str = new DataOutputStream(System.out);
            dtd.save(str, argv[0]);
            str.close();
        } catch (IOException ex) {
            ex.printStackTrace();
            System.exit(1);
        }
    }

}