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