Overview | Package | Class | Use | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## gnu.xml.dom
Class DomNode

    java.lang.Object
      |
      +--gnu.xml.dom.DomNode

All Implemented Interfaces:
  java.lang.Cloneable, DocumentEvent, EventTarget, Node, NodeList

Direct Known Subclasses:
  DomCharacterData, DomDocument, DomEntityReference, DomExtern, DomFragment, DomNsNode, DomPI

public abstract class DomNode
extends java.lang.Object
implements Node, NodeList, EventTarget, DocumentEvent, java.lang.Cloneable

"Node", "EventTarget", and "DocumentEvent" implementation. This provides most of the core DOM functionality; only more specialized features are provided by subclasses. Those subclasses may have some particular constraints they must implement, by overriding methods defined here. Such constraints are noted here in the method documentation.

Note that you can create events with type names prefixed with "USER-", and pass them through this DOM. This lets you use the DOM event scheme for application specific purposes, although you must use a predefined event structure (such as MutationEvent) to pass data along with those events. Test for existence of this feature with the "USER-Events" DOM feature name.

Other kinds of events you can send include the "html" events, like "load", "unload", "abort", "error", and "blur"; and the mutation events. If this DOM has been compiled with mutation event support enabled, it will send mutation events when you change parts of the tree; otherwise you may create and send such events yourself, but they won't be generated by the DOM itself.

Note that there is a namespace-aware name comparison method, nameAndTypeEquals, which compares the names (and types) of two nodes in conformance with the "Namespaces in XML" specification. While mostly intended for use with elements and attributes, this should also be helpful for ProcessingInstruction nodes and some others which do not have namespace URIs.

Version:
  $Date: 2001/11/21 01:53:41 $
Author:
  David Brownell

Fields inherited from interface org.w3c.dom.Node
`ATTRIBUTE_NODE, CDATA_SECTION_NODE, COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, DOCUMENT_NODE, DOCUMENT_TYPE_NODE, ELEMENT_NODE, ENTITY_NODE, ENTITY_REFERENCE_NODE, NOTATION_NODE, PROCESSING_INSTRUCTION_NODE, TEXT_NODE`

Constructor Summary
`protected` | `DomNode(Document owner)` Constructs a node and associates it with its owner.

Method Summary
`void` | `addEventListener(java.lang.String type, EventListener listener, boolean useCapture)` DOM L2 (Events) Registers an event listener's interest in a class of events.
`Node` | `appendChild(Node newChild)` DOM L1 Appends the specified node to this node's list of children.
`java.lang.Object` | `clone()` Clones this node; roughly equivalent to cloneNode(false).
`Node` | `cloneNode(boolean deep)` DOM L1 Returns a clone of this node which optionally includes cloned versions of child nodes.
`void` | `compact()` Reduces space utilization for this node.
`Event` | `createEvent(java.lang.String eventType)` DOM L2 (Events) Returns an instance of the specified type of event object.
`boolean` | `dispatchEvent(Event event)` DOM L2 (Events) Delivers an event to all relevant listeners, returning true if the caller should perform their default action.
`NamedNodeMap` | `getAttributes()` DOM L1 Returns null; Element subclasses must override this method.
`NodeList` | `getChildNodes()` DOM L1 Returns a list, possibly empty, of the children of this node.
`NodeList` | `getElementsByTagName(java.lang.String tag)` DOM L1 Creates a NodeList giving array-style access to elements with the specified name.
`NodeList` | `getElementsByTagNameNS(java.lang.String namespace, java.lang.String local)` DOM L2 Creates a NodeList giving array-style access to elements with the specified namespace and local name.
`Node` | `getFirstChild()` DOM L1 Returns the first child of this node, or null if there are none.
`Node` | `getLastChild()` DOM L1 Returns the last child of this node, or null if there are none.
`int` | `getLength()` DOM L1 (NodeList) Returns the number of elements in this NodeList.
`java.lang.String` | `getLocalName()` DOM L2 Returns the node name; this must be overridden for element and attribute nodes.
`java.lang.String` | `getNamespaceURI()` DOM L2 Returns null; this must be overridden for element and attribute nodes.
`Node` | `getNextSibling()` DOM L1 Returns the previous sibling, if one is known.
`java.lang.String` | `getNodeValue()` DOM L1 Returns null; this must be overridden for nodes types with a defined value, along with the setNodeValue method.
`Document` | `getOwnerDocument()` DOM L1 (modified in L2) Returns the owner document.
`Node` | `getParentNode()` DOM L1 Returns the parent node, if one is known.
`java.lang.String` | `getPrefix()` DOM L2 Returns null; this must be overridden for element and attribute nodes.
`Node` | `getPreviousSibling()` DOM L1 Returns the previous sibling, if one is known.
`boolean` | `hasAttributes()` DOM L2> Returns true iff this is an element node with attributes.
`boolean` | `hasChildNodes()` DOM L1 Returns true if this node has children.
`Node` | `insertBefore(Node newChild, Node refChild)` DOM L1 Inserts the specified node in this node's list of children.
`boolean` | `isReadonly()` Exposes the internal "readonly" flag.
`boolean` | `isSupported(java.lang.String feature, java.lang.String version)` DOM L2 Consults the DOM implementation to determine if the requested feature is supported.
`Node` | `item(int index)` DOM L1 (NodeList) Returns the item with the specified index in this NodeList, else null.
`void` | `makeReadonly()` Sets the internal "readonly" flag so this subtree can't be changed.
`boolean` | `nameAndTypeEquals(Node other)` Returns true iff node types match, and either (a) both nodes have no namespace and their getNodeName() values are the same, or (b) both nodes have the same getNamespaceURI() and same getLocalName() values.
`void` | `normalize()` DOM L1 (relocated in DOM L2) In this node and all contained nodes (including attributes if relevant) merge adjacent text nodes.
`Node` | `removeChild(Node refChild)` DOM L1 Removes the specified child from this node's list of children, or else reports an exception.
`void` | `removeEventListener(java.lang.String type, EventListener listener, boolean useCapture)` DOM L2 (Events) Unregisters an event listener.
`Node` | `replaceChild(Node newChild, Node refChild)` DOM L1 Replaces the specified node in this node's list of children.
`void` | `setNodeValue(java.lang.String value)` DOM L1 Does nothing; this must be overridden (along with the getNodeValue method) for nodes with a non-null defined value.
`void` | `setPrefix(java.lang.String prefix)` DOM L2 Does nothing; this must be overridden (along with the getPrefix method) for element and attribute nodes.
`void` | `trimToSize()` Minimize extra space consumed by this node to hold children and event listeners.

Methods inherited from class java.lang.Object
`equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface org.w3c.dom.Node
`getNodeName, getNodeType`

Constructor Detail

### DomNode

    protected DomNode(Document owner)

  Constructs a node and associates it with its owner. Only Document and DocumentType nodes may be created with no owner, and DocumentType nodes get an owner as soon as they are associated with a document.

Method Detail

### compact

    public void compact()

  Reduces space utilization for this node.

### getAttributes

    public NamedNodeMap getAttributes()

  DOM L1 Returns null; Element subclasses must override this method.
  Specified by:
    `getAttributes` in interface `Node`

### hasAttributes

    public boolean hasAttributes()

  DOM L2> Returns true iff this is an element node with attributes.
  Specified by:
    `hasAttributes` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Returns:
    `true` if this node has any attributes, `false` otherwise.

### getChildNodes

    public NodeList getChildNodes()

  DOM L1 Returns a list, possibly empty, of the children of this node. In this implementation, to conserve memory, nodes are the same as their list of children. This can have ramifications for subclasses, which may need to provide their own getLength method for reasons unrelated to the NodeList method of the same name.
  Specified by:
    `getChildNodes` in interface `Node`

### getFirstChild

    public final Node getFirstChild()

  DOM L1 Returns the first child of this node, or null if there are none.
  Specified by:
    `getFirstChild` in interface `Node`

### getLastChild

    public final Node getLastChild()

  DOM L1 Returns the last child of this node, or null if there are none.
  Specified by:
    `getLastChild` in interface `Node`

### hasChildNodes

    public final boolean hasChildNodes()

  DOM L1 Returns true if this node has children.
  Specified by:
    `hasChildNodes` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Returns:
    `true` if this node has any children, `false` otherwise.

### isReadonly

    public final boolean isReadonly()

  Exposes the internal "readonly" flag. In DOM, children of entities and entity references are readonly, as are the objects associated with DocumentType objets.

### makeReadonly

    public void makeReadonly()

  Sets the internal "readonly" flag so this subtree can't be changed. Subclasses need to override this method for any associated content that's not a child node, such as an element's attributes or the (few) declarations associated with a DocumentType.

### appendChild

    public Node appendChild(Node newChild)

  DOM L1 Appends the specified node to this node's list of children. Document subclasses must override this to enforce the restrictions that there be only one element and document type child.

  Causes a DOMNodeInserted mutation event to be reported. Will first cause a DOMNodeRemoved event to be reported if the parameter already has a parent. If the new child is a document fragment node, both events will be reported for each child of the fragment; the order in which children are removed and inserted is implementation-specific.

  If this DOM has been compiled without mutation event support, these events will not be reported.

  Specified by:
    `appendChild` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Parameters:
    `newChild` - The node to add.If it is a `DocumentFragment` object, the entire contents of the document fragment are moved into the child list of this node
  Returns:
    The node added.
  Throws:
    `DOMException` - HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the `newChild` node, or if the node to append is one of this node's ancestors or this node itself.
    WRONG_DOCUMENT_ERR: Raised if `newChild` was created from a different document than the one that created this node.
    NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or if the previous parent of the node being inserted is readonly.

### insertBefore

    public Node insertBefore(Node newChild,
                             Node refChild)

  DOM L1 Inserts the specified node in this node's list of children. Document subclasses must override this to enforce the restrictions that there be only one element and document type child.

  Causes a DOMNodeInserted mutation event to be reported. Will first cause a DOMNodeRemoved event to be reported if the newChild parameter already has a parent. If the new child is a document fragment node, both events will be reported for each child of the fragment; the order in which children are removed and inserted is implementation-specific.

  If this DOM has been compiled without mutation event support, these events will not be reported.

  Specified by:
    `insertBefore` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Parameters:
    `newChild` - The node to insert.
    `refChild` - The reference node, i.e., the node before which the new node must be inserted.
  Returns:
    The node being inserted.
  Throws:
    `DOMException` - HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the `newChild` node, or if the node to insert is one of this node's ancestors or this node itself.
    WRONG_DOCUMENT_ERR: Raised if `newChild` was created from a different document than the one that created this node.
    NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly or if the parent of the node being inserted is readonly.
    NOT_FOUND_ERR: Raised if `refChild` is not a child of this node.

### replaceChild

    public Node replaceChild(Node newChild,
                             Node refChild)

  DOM L1 Replaces the specified node in this node's list of children. Document subclasses must override this to test the restrictions that there be only one element and document type child.

  Causes DOMNodeRemoved and DOMNodeInserted mutation event to be reported. Will cause another DOMNodeRemoved event to be reported if the newChild parameter already has a parent. These events may be delivered in any order, except that the event reporting removal from such an existing parent will always be delivered before the event reporting its re-insertion as a child of some other node. The order in which children are removed and inserted is implementation specific.

  If your application needs to depend on the in which those removal and insertion events are delivered, don't use this API. Instead, invoke the removeChild and insertBefore methods directly, to guarantee a specific delivery order. Similarly, don't use document fragments, Otherwise your application code may not work on a DOM which implements this method differently.

  If this DOM has been compiled without mutation event support, these events will not be reported.

  Specified by:
    `replaceChild` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Parameters:
    `newChild` - The new node to put in the child list.
    `oldChild` - The node being replaced in the list.
  Returns:
    The node replaced.
  Throws:
    `DOMException` - HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the `newChild` node, or if the node to put in is one of this node's ancestors or this node itself.
    WRONG_DOCUMENT_ERR: Raised if `newChild` was created from a different document than the one that created this node.
    NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the parent of the new node is readonly.
    NOT_FOUND_ERR: Raised if `oldChild` is not a child of this node.

### removeChild

    public Node removeChild(Node refChild)

  DOM L1 Removes the specified child from this node's list of children, or else reports an exception.

  Causes a DOMNodeRemoved mutation event to be reported.

  If this DOM has been compiled without mutation event support, these events will not be reported.

  Specified by:
    `removeChild` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Parameters:
    `oldChild` - The node being removed.
  Returns:
    The node removed.
  Throws:
    `DOMException` - NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
    NOT_FOUND_ERR: Raised if `oldChild` is not a child of this node.

### item

    public final Node item(int index)

  DOM L1 (NodeList) Returns the item with the specified index in this NodeList, else null.
  Specified by:
    `item` in interface `NodeList`
  Following copied from interface: `org.w3c.dom.NodeList`
  Parameters:
    `index` - Index into the collection.
  Returns:
    The node at the `index`th position in the `NodeList`, or `null` if that is not a valid index.

### getLength

    public int getLength()

  DOM L1 (NodeList) Returns the number of elements in this NodeList. (Note that many interfaces have a "Length" property, not just NodeList, and if a node subtype must implement one of those, it will also need to override getChildNodes.)
  Specified by:
    `getLength` in interface `NodeList`

### trimToSize

    public void trimToSize()

  Minimize extra space consumed by this node to hold children and event listeners.

### getNextSibling

    public final Node getNextSibling()

  DOM L1 Returns the previous sibling, if one is known.
  Specified by:
    `getNextSibling` in interface `Node`

### getPreviousSibling

    public final Node getPreviousSibling()

  DOM L1 Returns the previous sibling, if one is known.
  Specified by:
    `getPreviousSibling` in interface `Node`

### getParentNode

    public final Node getParentNode()

  DOM L1 Returns the parent node, if one is known.
  Specified by:
    `getParentNode` in interface `Node`

### isSupported

    public boolean isSupported(java.lang.String feature,
                               java.lang.String version)

  DOM L2 Consults the DOM implementation to determine if the requested feature is supported. DocumentType subclasses must override this method, and associate themselves directly with the DOMImplementation node used. (This method relies on being able to access the DOMImplementation from the owner document, but DocumentType nodes can be created without an owner.)
  Specified by:
    `isSupported` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Parameters:
    `feature` - The name of the feature to test. This is the same name which can be passed to the method `hasFeature` on `DOMImplementation`.
    `version` - This is the version number of the feature to test. In Level 2, version 1, this is the string "2.0". If the version is not specified, supporting any version of the feature will cause the method to return `true`.
  Returns:
    Returns `true` if the specified feature is supported on this node, `false` otherwise.

### getOwnerDocument

    public final Document getOwnerDocument()

  DOM L1 (modified in L2) Returns the owner document. This is only null for Document nodes, and (new in L2) for DocumentType nodes which have not yet been associated with the rest of their document.
  Specified by:
    `getOwnerDocument` in interface `Node`

### setNodeValue

    public void setNodeValue(java.lang.String value)

  DOM L1 Does nothing; this must be overridden (along with the getNodeValue method) for nodes with a non-null defined value.
  Specified by:
    `setNodeValue` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Throws:
    `DOMException` - NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
    `DOMException` - DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a `DOMString` variable on the implementation platform.

### getNodeValue

    public java.lang.String getNodeValue()

  DOM L1 Returns null; this must be overridden for nodes types with a defined value, along with the setNodeValue method.
  Specified by:
    `getNodeValue` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Throws:
    `DOMException` - NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
    `DOMException` - DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a `DOMString` variable on the implementation platform.

### setPrefix

    public void setPrefix(java.lang.String prefix)

  DOM L2 Does nothing; this must be overridden (along with the getPrefix method) for element and attribute nodes.
  Specified by:
    `setPrefix` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Throws:
    `DOMException` - INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character, per the XML 1.0 specification .
    NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
    NAMESPACE_ERR: Raised if the specified `prefix` is malformed per the Namespaces in XML specification, if the `namespaceURI` of this node is `null`, if the specified prefix is "xml" and the `namespaceURI` of this node is different from "http://www.w3.org/XML/1998/namespace", if this node is an attribute and the specified prefix is "xmlns" and the `namespaceURI` of this node is different from " http://www.w3.org/2000/xmlns/", or if this node is an attribute and the `qualifiedName` of this node is "xmlns" .

### getPrefix

    public java.lang.String getPrefix()

  DOM L2 Returns null; this must be overridden for element and attribute nodes.
  Specified by:
    `getPrefix` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Throws:
    `DOMException` - INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character, per the XML 1.0 specification .
    NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
    NAMESPACE_ERR: Raised if the specified `prefix` is malformed per the Namespaces in XML specification, if the `namespaceURI` of this node is `null`, if the specified prefix is "xml" and the `namespaceURI` of this node is different from "http://www.w3.org/XML/1998/namespace", if this node is an attribute and the specified prefix is "xmlns" and the `namespaceURI` of this node is different from " http://www.w3.org/2000/xmlns/", or if this node is an attribute and the `qualifiedName` of this node is "xmlns" .

### getNamespaceURI

    public java.lang.String getNamespaceURI()

  DOM L2 Returns null; this must be overridden for element and attribute nodes.
  Specified by:
    `getNamespaceURI` in interface `Node`

### getLocalName

    public java.lang.String getLocalName()

  DOM L2 Returns the node name; this must be overridden for element and attribute nodes.
  Specified by:
    `getLocalName` in interface `Node`

### cloneNode

    public Node cloneNode(boolean deep)

  DOM L1 Returns a clone of this node which optionally includes cloned versions of child nodes. Clones are always mutable, except for entity reference nodes.
  Specified by:
    `cloneNode` in interface `Node`
  Following copied from interface: `org.w3c.dom.Node`
  Parameters:
    `deep` - If `true`, recursively clone the subtree under the specified node; if `false`, clone only the node itself (and its attributes, if it is an `Element`).
  Returns:
    The duplicate node.

### clone

    public java.lang.Object clone()

  Clones this node; roughly equivalent to cloneNode(false). Element subclasses must provide a new implementation which invokes this method to handle the basics, and then arranges to clone any element attributes directly. Attribute subclasses must make similar arrangements, ensuring that existing ties to elements are broken by cloning.
  Overrides:
    `clone` in class `java.lang.Object`

### getElementsByTagName

    public NodeList getElementsByTagName(java.lang.String tag)

  DOM L1 Creates a NodeList giving array-style access to elements with the specified name. Access is fastest if indices change by small values, and the DOM is not modified.

### getElementsByTagNameNS

    public NodeList getElementsByTagNameNS(java.lang.String namespace,
                                           java.lang.String local)

  DOM L2 Creates a NodeList giving array-style access to elements with the specified namespace and local name. Access is fastest if indices change by small values, and the DOM is not modified.

### createEvent

    public Event createEvent(java.lang.String eventType)

  DOM L2 (Events) Returns an instance of the specified type of event object. Understands about DOM Mutation, HTML, and UI events.

  If the name of the event type begins with "USER-", then an object implementing the "Event" class will be returned; this provides a limited facility for application-defined events to use the DOM event infrastructure. Alternatively, use one of the standard DOM event classes and initialize it using use such a "USER-" event type name; or defin, instantiate, and initialize an application-specific subclass of DomEvent and pass that to dispatchEvent().

  Specified by:
    `createEvent` in interface `DocumentEvent`
  Parameters:
    `eventType` - Identifies the particular DOM feature module defining the type of event, such as "MutationEvents". The event "name" is a different kind of "type".

### addEventListener

    public final void addEventListener(java.lang.String type,
                                       EventListener listener,
                                       boolean useCapture)

  DOM L2 (Events) Registers an event listener's interest in a class of events.
  Specified by:
    `addEventListener` in interface `EventTarget`
  Following copied from interface: `org.w3c.dom.events.EventTarget`
  Parameters:
    `type` - The event type for which the user is registering
    `listener` - The `listener` parameter takes an interface implemented by the user which contains the methods to be called when the event occurs.
    `useCapture` - If true, `useCapture` indicates that the user wishes to initiate capture. After initiating capture, all events of the specified type will be dispatched to the registered `EventListener` before being dispatched to any `EventTargets` beneath them in the tree. Events which are bubbling upward through the tree will not trigger an `EventListener` designated to use capture.

### dispatchEvent

    public final boolean dispatchEvent(Event event)
                                throws EventException

  DOM L2 (Events) Delivers an event to all relevant listeners, returning true if the caller should perform their default action. Note that the event must have been provided by the createEvent() method on this class, else it can't be dispatched.
  Specified by:
    `dispatchEvent` in interface `EventTarget`
  Throws:
    `java.lang.NullPointerException` - When a null event is passed.
    `java.lang.ClassCastException` - When the event wasn't provided by the createEvent method, or otherwise isn't a DomEvent.
    `EventException` - If the event type wasn't specified
  See Also:
    `createEvent(java.lang.String)`

### removeEventListener

    public final void removeEventListener(java.lang.String type,
                                          EventListener listener,
                                          boolean useCapture)

  DOM L2 (Events) Unregisters an event listener.
  Specified by:
    `removeEventListener` in interface `EventTarget`
  Following copied from interface: `org.w3c.dom.events.EventTarget`
  Parameters:
    `type` - Specifies the event type of the `EventListener` being removed.
    `listener` - The `EventListener` parameter indicates the `EventListener` to be removed.
    `useCapture` - Specifies whether the `EventListener` being removed was registered as a capturing listener or not. If a listener was registered twice, one with capture and one without, each must be removed separately. Removal of a capturing listener does not affect a non-capturing version of the same listener, and vice versa.

### normalize

    public void normalize()

  DOM L1 (relocated in DOM L2) In this node and all contained nodes (including attributes if relevant) merge adjacent text nodes. This is done while ignoring text which happens to use CDATA delimiters).
  Specified by:
    `normalize` in interface `Node`

### nameAndTypeEquals

    public boolean nameAndTypeEquals(Node other)

  Returns true iff node types match, and either (a) both nodes have no namespace and their getNodeName() values are the same, or (b) both nodes have the same getNamespaceURI() and same getLocalName() values.

  Note that notion of a "Per-Element-Type" attribute name scope, as found in a non-normative appendix of the XML Namespaces specification, is not supported here. Your application must implement that notion, typically by not bothering to check nameAndTypeEquals for attributes without namespace URIs unless you already know their elements are nameAndTypeEquals.

Overview | Package | Class | Use | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Source code is under GPL (with library exception) in the JAXP project at http://www.gnu.org/software/classpathx/jaxp
This documentation was derived from that source code on 2001-11-20.