diff options
Diffstat (limited to 'libjava/classpath/gnu/javax/swing/text/html/parser/gnuDTD.java')
| -rw-r--r-- | libjava/classpath/gnu/javax/swing/text/html/parser/gnuDTD.java | 421 |
1 files changed, 421 insertions, 0 deletions
diff --git a/libjava/classpath/gnu/javax/swing/text/html/parser/gnuDTD.java b/libjava/classpath/gnu/javax/swing/text/html/parser/gnuDTD.java new file mode 100644 index 000000000..5924e0fb9 --- /dev/null +++ b/libjava/classpath/gnu/javax/swing/text/html/parser/gnuDTD.java @@ -0,0 +1,421 @@ +/* gnuDTD.java -- + Copyright (C) 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath 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 for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +package gnu.javax.swing.text.html.parser; + +import java.io.PrintStream; +import java.io.Serializable; + +import java.util.BitSet; +import java.util.Collection; +import java.util.Iterator; +import java.util.Map; +import java.util.Vector; + +import javax.swing.text.html.parser.AttributeList; +import javax.swing.text.html.parser.ContentModel; +import javax.swing.text.html.parser.Element; +import javax.swing.text.html.parser.Entity; + +/** + * <p> + * The class is derived from {@link gnu.javax.swing.text.html.parser.DTD } + * making structure creation methods public. This is required when + * creating the DTD by SGML parser that must have access to the structure. + * + * SGML DTD representation. Provides basis for describing a syntax of the + * HTML documents. The fields of this class are NOT initialized in + * constructor. You need to do this separately before passing this data + * structure to the parser constructor.</p> + * + * <p>This implementation also provides you the derived class + * <code>gnu.javax.swing.text.html.parser.DTD.HTML_4_0_1</code>, where + * all fields are initialized to the values, representing HTML 4.01 + * ("-//W3C//DTD HTML 4.01 Frameset//EN") DTD. You can use it if you do not care + * about the portability between different implementations of the core + * class libraries. </p> + * <p>Use {@link javax.swing.HTML.HTMLEditorKit.Parser#parse } + * for parsing in accordance with "-//W3C//DTD HTML 4.01 Frameset//EN" + * without specifying DTD separately.</p> + * + * @author Audrius Meskauskas, Lithuania (AudriusA@Bioinformatics.org) + */ +public class gnuDTD + extends javax.swing.text.html.parser.DTD + implements javax.swing.text.html.parser.DTDConstants, Serializable +{ + /* The undocumented element types, used to specify types, not defined + in DTDConstants. */ + + /** + * The URI element type (not defined in DTDConstants). + */ + public static final int URI = 512; + + /** + * The Length element type + */ + public static final int Length = 513; + + /** + * The Char element type + */ + public static final int Char = 514; + + /** + * The Color element type + */ + public static final int Color = 515; + + /** + * Creates a new instance of gnuDTD. + * @param name the name of the DTD. + */ + public gnuDTD(String name) + { + super(name); + } + + /** + * Creates and returns new attribute (not an attribute list). + * @param name the name of this attribute + * @param type the type of this attribute (FIXED, IMPLIED or + * REQUIRED from <code>DTDConstants</code>). + * @param modifier the modifier of this attribute + * @param default_value the default value of this attribute or null if + * it is not specified. + * @param allowed_values the allowed values of this attribute. The multiple + * possible values in this parameter are supposed to be separated by + * '|', same as in SGML DTD <code><!ATTLIST </code>tag. This parameter + * can be null if no list of allowed values is specified. + * @param atts the previous attribute of this element. This is + * placed to the field + * {@link javax.swing.text.html.parser.AttributeList#next }, + * creating a linked list. + * @return + */ + public AttributeList defAttributeList(String name, int type, int modifier, + String default_value, + String allowed_values, + AttributeList atts + ) + { + return super.defAttributeList(name, type, modifier, default_value, + allowed_values, atts + ); + } + + /** + * Define the attributes for the element with the given name. + * If the element is not exist, it is created. This method is + * needed if the element attributes are defined befor the + * element itself. + * @param forElement + * @param attributes + */ + public void defAttrsFor(String forElement, AttributeList attributes) + { + super.defineAttributes(forElement, attributes); + } + + /** + * Creates a new content model. + * @param type specifies the BNF operation for this content model. + * The valid operations are documented in the + * {@link javax.swing.text.html.parser.ContentModel#type }. + * @param content the content of this content model + * @param next if the content model is specified by BNF-like + * expression, contains the rest of this expression. + * @return The newly created content model. + */ + public ContentModel defContentModel(int type, Object content, + ContentModel next + ) + { + return super.defContentModel(type, content, next); + } + + /** + * Defines a new element and adds it to the element table. + * If the element alredy exists, + * overrides it settings with the specified values. + * @param name the name of the new element + * @param type the type of the element + * @param headless true if the element needs no starting tag + * @param tailless true if the element needs no closing tag + * @param content the element content. + * @param exclusions the elements that must be excluded from the + * content of this element, in all levels of the hierarchy. + * @param inclusions the elements that can be included as the + * content of this element. + * @param attributes the element attributes. + * @return the created or updated element. + */ + public Element defElement(String name, int type, boolean headless, + boolean tailless, ContentModel content, + String[] exclusions, String[] inclusions, + AttributeList attributes + ) + { + return super.defElement(name, type, headless, tailless, content, + exclusions, inclusions, attributes + ); + } + + /** + * Defines a new element and adds it to the element table. + * If the element alredy exists, + * overrides it settings with the specified values. + * @param name the name of the new element + * @param type the type of the element + * @param headless true if the element needs no starting tag + * @param tailless true if the element needs no closing tag + * @param content the element content. + * @param exclusions the elements that must be excluded from the + * content of this element, in all levels of the hierarchy. + * @param inclusions the elements that can be included as the + * content of this element. + * @param attributes the element attributes. + * @return the created or updated element. + */ + public Element defElement(String name, int type, boolean headless, + boolean tailless, ContentModel content, + Collection exclusions, Collection inclusions, + AttributeList attributes + ) + { + return super.defElement(name, type, headless, tailless, content, + toStringArray(exclusions), + toStringArray(inclusions), attributes + ); + } + + /** + * Defines a new element and adds it to the element table. + * If the element alredy exists, + * overrides it settings with the specified values. + * @param name the name of the new element + * @param type the type of the element + * @param headless true if the element needs no starting tag + * @param tailless true if the element needs no closing tag + * @param content the element content. + * @param exclusions the elements that must be excluded from the + * content of this element, in all levels of the hierarchy. + * @param inclusions the elements that can be included as the + * content of this element. + * @param attributes the element attributes (an array and not a + * linked list). The attributes are chained into the linked list + * inside this method. + * @return the created or updated element. + */ + public Element defElement(String name, int type, boolean headless, + boolean tailless, ContentModel content, + String[] exclusions, String[] inclusions, + AttributeList[] attributes + ) + { + AttributeList list; + + if (attributes == null || attributes.length == 0) + list = null; + else + { + if (attributes.length > 1) + for (int i = 1; i < attributes.length; i++) + { + attributes [ i - 1 ].next = attributes [ i ]; + } + list = attributes [ 0 ]; + } + + Element e = + super.defElement(name, type, headless, tailless, content, exclusions, + inclusions, list + ); + return e; + } + + /** + * Creates, adds into the internal table and returns the + * character entity like <code>&lt;</code> + * (means '<code><</code>' ); + * This method inactivates the recursive refenrences to the same + * entity. + * @param name The entity name (without heading & and closing ;) + * @param type The entity type + * @param character The entity value (single character) + * @return The created entity + */ + public Entity defEntity(String name, int type, String data) + { + int r; + String eref = "%" + name + ";"; + do + { + r = data.indexOf(eref); + if (r > 0) + { + data = data.substring(0, r) + data.substring(r + 1); + } + } + while (r > 0); + + return super.defEntity(name, type, data); + } + + /** + * Summarises the document content into the given PrintStream. + */ + public void dump(PrintStream p) + { + Iterator iter = entityHash.entrySet().iterator(); + while (iter.hasNext()) + { + Map.Entry item = (Map.Entry) iter.next(); + Entity e = (Entity) item.getValue(); + if (e.isGeneral()) + p.println("Entity " + e.getName() + ": " + e.getString()); + } + + iter = elementHash.entrySet().iterator(); + while (iter.hasNext()) + { + Map.Entry item = (Map.Entry) iter.next(); + Element e = (Element) item.getValue(); + p.println("Element " + e.getName()); + + System.out.println(" includes:"); + dump(e.inclusions); + System.out.println(" excludes:"); + dump(e.exclusions); + System.out.println(" attributes:"); + + AttributeList atts = e.atts; + while (atts != null) + { + p.print(" " + atts.name + " = " + atts.value); + if (atts.values == null || atts.values.size() == 0) + p.println(); + else + { + Iterator viter = atts.values.iterator(); + System.out.print(" ( "); + while (viter.hasNext()) + { + System.out.print(viter.next()); + if (viter.hasNext()) + System.out.print(" | "); + } + System.out.println(" ) "); + } + atts = atts.next; + } + } + } + + /** + * Prints the content of the given attribute set to the System.out. + * @param b + */ + public void dump(BitSet b) + { + if (b != null) + { + for (int i = 0; i < b.size(); i++) + { + if (b.get(i)) + System.out.println(" " + elements.get(i)); + } + } + else + System.out.println(" NULL set"); + } + + /** + * Creates the attribute. + * @param name The attribute name. + * @param type The attribute type. + * @param modifier The attribute modifier. + * @param defaultValue Default value (or null) + * @param allowed_values Allowed values (or null) + * @return The newly created AttributeList. The <code>next</code> + * field is initialized to null. + */ + protected AttributeList attr(String name, String default_value, + String[] allowed_values, int type, int modifier + ) + { + Vector allowed = null; + + if (allowed_values != null) + { + allowed = new Vector(allowed_values.length); + for (int i = 0; i < allowed_values.length; i++) + { + allowed.add(allowed_values [ i ]); + } + } + + AttributeList attr = + new AttributeList(name, type, modifier, default_value, allowed, null); + + return attr; + } + + /** + * Define the general entity, holding a single character. + * @param name The entity name (for example, 'amp'). + * The defined entity <b>is</b> stored into the entity table. + * @param character The entity character (for example, '&'). + */ + protected void defineEntity(String name, int character) + { + super.defEntity(name, GENERAL, character); + } + + private String[] toStringArray(Collection c) + { + String[] s = new String[ c.size() ]; + Iterator iter = c.iterator(); + for (int i = 0; i < s.length; i++) + { + s [ i ] = iter.next().toString(); + } + return s; + } +} |