Back to index...

	/*
	* Copyright (c) 1998, 2010, 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 {
	public String name;
	public Vector<Element> elements = new Vector<Element>();
	public Hashtable<String,Element> elementHash
	= new Hashtable<String,Element>();
	public Hashtable<Object,Entity> entityHash
	= new Hashtable<Object,Entity>();
	public final Element pcdata = getElement("#pcdata");
	public final Element html = getElement("html");
	public final Element meta = getElement("meta");
	public final Element base = getElement("base");
	public final Element isindex = getElement("isindex");
	public final Element head = getElement("head");
	public final Element body = getElement("body");
	public final Element applet = getElement("applet");
	public final Element param = getElement("param");
	public final Element p = getElement("p");
	public final Element title = getElement("title");
	final Element style = getElement("style");
	final Element link = getElement("link");
	final Element script = getElement("script");

	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.
	* @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.
	* @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 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
	* @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
	* @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
	* @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>.
	* @param name the attribute list's name
	* @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
	* @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();

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

	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
	*/
	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);
	}
	case 2: { // content_e
	int type = in.readByte();
	Element el = getElement(names[in.readShort()]);
	ContentModel next = readContentModel(in, names);
	return defContentModel(type, el, next);
	}
	default:
	throw new IOException("bad bdtd");
	}
	}

	private String[] readNameArray(DataInputStream in, String[] names)
	throws IOException {
	int num = in.readShort();
	if (num == 0) {
	return null;
	}
	String[] result = new String[num];
	for (int i = 0; i < num; i++) {
	result[i] = names[in.readShort()];
	}
	return result;
	}


	private AttributeList readAttributeList(DataInputStream in, String[] names)
	throws IOException {
	AttributeList result = null;
	for (int num = in.readByte(); num > 0; --num) {
	short nameId = in.readShort();
	int type = in.readByte();
	int modifier = in.readByte();
	short valueId = in.readShort();
	String value = (valueId == -1) ? null : names[valueId];
	Vector<String> values = null;
	short numValues = in.readShort();
	if (numValues > 0) {
	values = new Vector<String>(numValues);
	for (int i = 0; i < numValues; i++) {
	values.addElement(names[in.readShort()]);
	}
	}
	result = new AttributeList(names[nameId], type, modifier, value,
	values, result);
	// We reverse the order of the linked list by doing this, but
	// that order isn't important.
	}
	return result;
	}

	}

Back to index...