/*

 * Copyright (c) 1998, 2014, 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 javax.swing.text.html.parser;

import sun.awt.AppContext;

import java.io.PrintStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.InputStream;

import java.io.IOException;

import java.io.FileNotFoundException;

import java.io.BufferedInputStream;

import java.io.DataInputStream;

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.net.URL;

/**

 * The representation of an SGML DTD.  DTD describes a document

 * syntax and is used in parsing of HTML documents.  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 Parser

 * @author Arthur van Hoff

 */

public

class DTD implements DTDConstants {

    /**

     * the name of the DTD

     */

    public String name;

    /**

     * The vector of elements

     */

    public Vector<Element> elements = new Vector<Element>();

    /**

     * The hash table contains the name of element and

     * the corresponding element.

     */

    public Hashtable<String,Element> elementHash

        = new Hashtable<String,Element>();

    /**

     * The hash table contains an {@code Object} and the corresponding {@code Entity}

     */

    public Hashtable<Object,Entity> entityHash

        = new Hashtable<Object,Entity>();

    /**

     * The element corresponding to pcdata.

     */

    public final Element pcdata = getElement("#pcdata");

    /**

     * The element corresponding to html.

     */

    public final Element html = getElement("html");

    /**

     * The element corresponding to meta.

     */

    public final Element meta = getElement("meta");

    /**

     * The element corresponding to base.

     */

    public final Element base = getElement("base");

    /**

     * The element corresponding to isindex.

     */

    public final Element isindex = getElement("isindex");

    /**

     * The element corresponding to head.

     */

    public final Element head = getElement("head");

    /**

     * The element corresponding to body.

     */

    public final Element body = getElement("body");

    /**

     * The element corresponding to applet.

     */

    public final Element applet = getElement("applet");

    /**

     * The element corresponding to param.

     */

    public final Element param = getElement("param");

    /**

     * The element corresponding to p.

     */

    public final Element p = getElement("p");

    /**

     * The element corresponding to title.

     */

    public final Element title = getElement("title");

    final Element style = getElement("style");

    final Element link = getElement("link");

    final Element script = getElement("script");

    /**

     * The version of a file

     */

    public static final int FILE_VERSION = 1;

    /**

     * Creates a new DTD with the specified name.

     * @param name the name, as a <code>String</code> of the new DTD

     */

    protected DTD(String name) {

        this.name = name;

        defEntity("#RE", GENERAL, '\r');

        defEntity("#RS", GENERAL, '\n');

        defEntity("#SPACE", GENERAL, ' ');

        defineElement("unknown", EMPTY, false, true, null, null, null, null);

    }

    /**

     * Gets the name of the DTD.

     * @return the name of the DTD

     */

    public String getName() {

        return name;

    }

    /**

     * Gets an entity by name.

     * @param name  the entity name

     * @return the <code>Entity</code> corresponding to the

     *   <code>name</code> <code>String</code>

     */

    public Entity getEntity(String name) {

        return entityHash.get(name);

    }

    /**

     * Gets a character entity.

     * @param ch  the character

     * @return the <code>Entity</code> corresponding to the

     *    <code>ch</code> character

     */

    public Entity getEntity(int ch) {

        return entityHash.get(Integer.valueOf(ch));

    }

    /**

     * Returns <code>true</code> if the element is part of the DTD,

     * otherwise returns <code>false</code>.

     *

     * @param  name the requested <code>String</code>

     * @return <code>true</code> if <code>name</code> exists as

     *   part of the DTD, otherwise returns <code>false</code>

     */

    boolean elementExists(String name) {

        return !"unknown".equals(name) && (elementHash.get(name) != null);

    }

    /**

     * Gets an element by name. A new element is

     * created if the element doesn't exist.

     *

     * @param name the requested <code>String</code>

     * @return the <code>Element</code> corresponding to

     *   <code>name</code>, which may be newly created

     */

    public Element getElement(String name) {

        Element e = elementHash.get(name);

        if (e == null) {

            e = new Element(name, elements.size());

            elements.addElement(e);

            elementHash.put(name, e);

        }

        return e;

    }

    /**

     * Gets an element by index.

     *

     * @param index the requested index

     * @return the <code>Element</code> corresponding to

     *   <code>index</code>

     */

    public Element getElement(int index) {

        return elements.elementAt(index);

    }

    /**

     * Defines an entity.  If the <code>Entity</code> specified

     * by <code>name</code>, <code>type</code>, and <code>data</code>

     * exists, it is returned; otherwise a new <code>Entity</code>

     * is created and is returned.

     *

     * @param name the name of the <code>Entity</code> as a <code>String</code>

     * @param type the type of the <code>Entity</code>

     * @param data the <code>Entity</code>'s data

     * @return the <code>Entity</code> requested or a new <code>Entity</code>

     *   if not found

     */

    public Entity defineEntity(String name, int type, char data[]) {

        Entity ent = entityHash.get(name);

        if (ent == null) {

            ent = new Entity(name, type, data);

            entityHash.put(name, ent);

            if (((type & GENERAL) != 0) && (data.length == 1)) {

                switch (type & ~GENERAL) {

                  case CDATA:

                  case SDATA:

                      entityHash.put(Integer.valueOf(data[0]), ent);

                    break;

                }

            }

        }

        return ent;

    }

    /**

     * Returns the <code>Element</code> which matches the

     * specified parameters.  If one doesn't exist, a new

     * one is created and returned.

     *

     * @param name        the name of the <code>Element</code>

     * @param type        the type of the <code>Element</code>

     * @param omitStart   <code>true</code> if start should be omitted

     * @param omitEnd     <code>true</code> if end should be omitted

     * @param content     the <code>ContentModel</code>

     * @param exclusions  the set of elements that must not occur inside the element

     * @param inclusions  the set of elements that can occur inside the element

     * @param atts        the <code>AttributeList</code> specifying the

     *                    <code>Element</code>

     * @return the <code>Element</code> specified

     */

    public Element defineElement(String name, int type,

                       boolean omitStart, boolean omitEnd, ContentModel content,

                       BitSet exclusions, BitSet inclusions, AttributeList atts) {

        Element e = getElement(name);

        e.type = type;

        e.oStart = omitStart;

        e.oEnd = omitEnd;

        e.content = content;

        e.exclusions = exclusions;

        e.inclusions = inclusions;

        e.atts = atts;

        return e;

    }

    /**

     * Defines attributes for an {@code Element}.

     *

     * @param name the name of the <code>Element</code>

     * @param atts the <code>AttributeList</code> specifying the

     *    <code>Element</code>

     */

    public void defineAttributes(String name, AttributeList atts) {

        Element e = getElement(name);

        e.atts = atts;

    }

    /**

     * Creates and returns a character <code>Entity</code>.

     * @param name the entity's name

     * @param type the entity's type

     * @param ch   the entity's value (character)

     * @return the new character <code>Entity</code>

     */

    public Entity defEntity(String name, int type, int ch) {

        char data[] = {(char)ch};

        return defineEntity(name, type, data);

    }

    /**

     * Creates and returns an <code>Entity</code>.

     * @param name the entity's name

     * @param type the entity's type

     * @param str  the entity's data section

     * @return the new <code>Entity</code>

     */

    protected Entity defEntity(String name, int type, String str) {

        int len = str.length();

        char data[] = new char[len];

        str.getChars(0, len, data, 0);

        return defineEntity(name, type, data);

    }

    /**

     * Creates and returns an <code>Element</code>.

     * @param name        the element's name

     * @param type        the element's type

     * @param omitStart   {@code true} if the element needs no starting tag

     * @param omitEnd     {@code true} if the element needs no closing tag

     * @param content     the element's content

     * @param exclusions  the elements that must be excluded from the content of the element

     * @param inclusions  the elements that can be included as the content of the element

     * @param atts        the attributes of the element

     * @return the new <code>Element</code>

     */

    protected Element defElement(String name, int type,

                       boolean omitStart, boolean omitEnd, ContentModel content,

                       String[] exclusions, String[] inclusions, AttributeList atts) {

        BitSet excl = null;

        if (exclusions != null && exclusions.length > 0) {

            excl = new BitSet();

            for (String str : exclusions) {

                if (str.length() > 0) {

                    excl.set(getElement(str).getIndex());

                }

            }

        }

        BitSet incl = null;

        if (inclusions != null && inclusions.length > 0) {

            incl = new BitSet();

            for (String str : inclusions) {

                if (str.length() > 0) {

                    incl.set(getElement(str).getIndex());

                }

            }

        }

        return defineElement(name, type, omitStart, omitEnd, content, excl, incl, atts);

    }

    /**

     * Creates and returns an <code>AttributeList</code> responding to a new attribute.

     * @param name      the attribute's name

     * @param type      the attribute's type

     * @param modifier  the attribute's modifier

     * @param value     the default value of the attribute

     * @param values    the allowed values for the attribute (multiple values could be separated by '|')

     * @param atts      the previous attribute of the element; to be placed to {@code AttributeList.next},

     *                  creating a linked list

     * @return the new <code>AttributeList</code>

     */

    protected AttributeList defAttributeList(String name, int type, int modifier,

                                             String value, String values, AttributeList atts) {

        Vector<String> vals = null;

        if (values != null) {

            vals = new Vector<String>();

            for (StringTokenizer s = new StringTokenizer(values, "|") ; s.hasMoreTokens() ;) {

                String str = s.nextToken();

                if (str.length() > 0) {

                    vals.addElement(str);

                }

            }

        }

        return new AttributeList(name, type, modifier, value, vals, atts);

    }

    /**

     * Creates and returns a new content model.

     * @param type the type of the new content model

     * @param obj  the content of the content model

     * @param next pointer to the next content model

     * @return the new <code>ContentModel</code>

     */

    protected ContentModel defContentModel(int type, Object obj, ContentModel next) {

        return new ContentModel(type, obj, next);

    }

    /**

     * Returns a string representation of this DTD.

     * @return the string representation of this DTD

     */

    public String toString() {

        return name;

    }

    /**

     * The hashtable key of DTDs in AppContext.

     */

    private static final Object DTD_HASH_KEY = new Object();

    /**

     * Put a name and appropriate DTD to hashtable.

     *

     * @param name the name of the DTD

     * @param dtd the DTD

     */

    public static void putDTDHash(String name, DTD dtd) {

        getDtdHash().put(name, dtd);

    }

    /**

     * Returns a DTD with the specified <code>name</code>.  If

     * a DTD with that name doesn't exist, one is created

     * and returned.  Any uppercase characters in the name

     * are converted to lowercase.

     *

     * @param name the name of the DTD

     * @return the DTD which corresponds to <code>name</code>

     * @throws IOException if an I/O error occurs

     */

    public static DTD getDTD(String name) throws IOException {

        name = name.toLowerCase();

        DTD dtd = getDtdHash().get(name);

        if (dtd == null)

          dtd = new DTD(name);

        return dtd;

    }

    private static Hashtable<String, DTD> getDtdHash() {

        AppContext appContext = AppContext.getAppContext();

        @SuppressWarnings("unchecked")

        Hashtable<String, DTD> result = (Hashtable<String, DTD>) appContext.get(DTD_HASH_KEY);

        if (result == null) {

            result = new Hashtable<String, DTD>();

            appContext.put(DTD_HASH_KEY, result);

        }

        return result;

    }

    /**

     * Recreates a DTD from an archived format.

     * @param in  the <code>DataInputStream</code> to read from

     * @throws IOException if an I/O error occurs

     */

    public void read(DataInputStream in) throws IOException {

        if (in.readInt() != FILE_VERSION) {

        }

        //

        // Read the list of names

        //

        String[] names = new String[in.readShort()];

        for (int i = 0; i < names.length; i++) {

            names[i] = in.readUTF();

        }

        //

        // Read the entities

        //

        int num = in.readShort();

        for (int i = 0; i < num; i++) {

            short nameId = in.readShort();

            int type = in.readByte();

            String name = in.readUTF();

            defEntity(names[nameId], type | GENERAL, name);

        }

        // Read the elements

        //

        num = in.readShort();

        for (int i = 0; i < num; i++) {

            short nameId = in.readShort();

            int type = in.readByte();

            byte flags = in.readByte();

            ContentModel m = readContentModel(in, names);

            String[] exclusions = readNameArray(in, names);

            String[] inclusions = readNameArray(in, names);

            AttributeList atts = readAttributeList(in, names);

            defElement(names[nameId], type,

                       ((flags & 0x01) != 0), ((flags & 0x02) != 0),

                       m, exclusions, inclusions, atts);

        }

    }

    private ContentModel readContentModel(DataInputStream in, String[] names)

                throws IOException {

        byte flag = in.readByte();

        switch(flag) {

            case 0:             // null

                return null;

            case 1: {           // content_c

                int type = in.readByte();

                ContentModel m = readContentModel(in, names);

                ContentModel next = readContentModel(in, names);

                return defContentModel(type, m, next);

            }