xmlparser 0.6.81

data/lib/sax.rb

@@ -0,0 +1 @@
+require 'xml/sax'

data/lib/saxdriver.rb

@@ -0,0 +1 @@
+require 'xml/saxdriver'

data/lib/wget.rb

@@ -0,0 +1,47 @@
+## -*- Ruby -*-
+## URLopen
+## 1999 by yoshidam
+##
+## TODO: This module should be writen by Ruby instead of wget/lynx.
+
+module WGET
+  PARAM = {
+    'wget' => nil,
+    'opts' => nil,
+    'http_proxy' => nil,
+    'ftp_proxy' => nil
+  }
+
+  def open(url, *rest)
+      raise TypeError.new("wrong argument type #{url.inspect}" +
+                          " (expected String)") if url.class != String
+
+    if url =~ /^\/|^\./ || (url !~ /^http:|^ftp:/ && FileTest.exist?(url))
+      File::open(url, *rest)
+    else
+      ENV['http_proxy'] = PARAM['http_proxy'] if PARAM['http_proxy']
+      ENV['ftp_proxy'] = PARAM['ftp_proxy'] if PARAM['ftp_proxy']
+      IO::popen(PARAM['wget'] + ' ' + PARAM['opts'] + ' ' + url)
+    end
+  end
+  module_function :open
+end
+
+[ '/usr/local/bin/wget', '/usr/bin/wget',
+  '/usr/local/bin/lynx', '/usr/bin/lynx',
+  '/usr/local/bin/lwp-request', '/usr/bin/lwp-request' ].each do |p|
+  if FileTest.executable?(p)
+    WGET::PARAM['wget'] = p
+    case p
+    when /wget$/
+      WGET::PARAM['opts'] = '-q -O -'
+    when /lynx$/
+      WGET::PARAM['opts'] = '-source'
+    when /lwp-request$/
+      WGET::PARAM['opts'] = '-m GET'
+    end
+    break
+  end
+end
+
+raise "wget not found" if !WGET::PARAM['wget']

data/lib/xml/dom/builder-ja.rb

@@ -0,0 +1,58 @@
+## -*- Ruby -*-
+## Tree builder class for Japanese encoding
+## 1998 by yoshidam
+
+require 'xml/dom/builder'
+
+module XML
+module DOM
+  class JapaneseBuilder<Builder
+    require 'kconv'
+    include Kconv
+    require 'uconv'
+    include Uconv
+
+    def nameConverter(str)
+      u8toeuc(str)
+    end
+    def cdataConverter(str)
+      u8toeuc(str)
+    end
+
+    def parseStream(stream, trim = false)
+      ## empty file
+      if ((xml = stream.gets).nil?); exit 1; end
+      ## rewrite encoding in XML decl.
+      if xml =~ /^<\?xml\sversion=.+\sencoding=.EUC-JP./i
+        xml.sub!(/EUC-JP/i, "UTF-8")
+        encoding = 'EUC-JP'
+      elsif xml =~ /^<\?xml\sversion=.+\sencoding=.Shift_JIS./i
+        xml.sub!(/Shift_JIS/i, "UTF-8")
+        encoding = "Shift_JIS"
+      elsif xml =~ /^<\?xml\sversion=.+\sencoding=.ISO-2022-JP./i
+        xml.sub!(/ISO-2022-JP/i, "UTF-8")
+        encoding = "ISO-2022-JP"
+      end
+
+      ## read body
+      xml += String(stream.read)
+
+      ## convert body encoding
+      if encoding == "EUC-JP"
+        xml = euctou8(xml)
+      elsif encoding == "Shift_JIS"
+        xml = euctou8(kconv(xml, EUC, SJIS))
+      elsif encoding == "ISO-2022-JP"
+        xml = euctou8(kconv(xml, EUC, JIS))
+      end
+
+      return parse(xml, trim)
+    end
+
+
+    def Uconv.unknown_unicode_handler(u)
+      return '®'
+    end
+  end
+end
+end

data/lib/xml/dom/builder.rb

@@ -0,0 +1,310 @@
+## -*- Ruby -*-
+## XML::DOM::Builder
+## 1999 by yoshidam
+
+require 'xml/parser'
+require 'xml/dom/core'
+
+=begin
+= XML::DOM::Builder
+
+== Module XML
+
+=end
+module XML
+module DOM
+
+=begin
+== Class XML::DOM::Builder (XML::SimpleTreeBuilder)
+
+=== superclass
+XML::Parser
+
+=end
+  class Builder<Parser
+    include XML::DOM
+
+    attr :createCDATASection, true
+    attr :createEntityReference, true
+
+    ## replace 'open' by WGET::open
+    begin
+      require 'wget'
+      include WGET
+    rescue
+      ## ignore
+    end
+
+=begin
+=== Class Methods
+
+    --- DOM::Builder.new(level = 0, *args)
+
+Constructor of DOM builder.
+
+usage:
+parser = XML::SimpleTreeBuilder.new(level)
+
+  level: 0 -- ignore default events (defualt)
+         1 -- catch default events and create the Comment,
+              the EntityReference, the XML declaration (as PI) and
+              the non-DOM-compliant DocumentType nodes.
+
+=end
+
+    def self.new(level = 0, *args)
+      document = Document.new
+      ret = super(*args)
+      external = false
+      external = true if args[0].is_a?(SimpleTreeBuilder)
+      ret.__initialize__(level, document, external)
+      ret
+    end
+
+    ## Constructor
+    ##  parser = XML::SimpleTreeBuilder.new(level)
+    ##    level: 0 -- ignore default events (defualt)
+    ##           1 -- catch default events and create the Comment,
+    ##                the EntityReference, the XML declaration (as PI) and
+    ##                the non-DOM-compliant DocumentType nodes.
+    def __initialize__(level, document, external)
+      @tree = nil
+      @level = level
+      @document = document
+      @external = external
+      @createCDATASection = false
+      @createEntityReference = false
+      if @level > 0
+        @createCDATASection = true
+        @createEntityReference = true
+        def self.default(data); defaultHandler(data); end
+      end
+    end
+
+=begin
+=== Methods
+
+    --- Builder#nameConverter(str)
+
+User redefinable name encoding converter
+
+=end
+    ## User redefinable name encoding converter
+    def nameConverter(str)
+      str
+    end
+
+=begin
+    --- Builder#cdataConverter(str)
+
+User redefinable cdata encoding converter
+
+=end
+    ## User redefinable cdata encoding converter
+    def cdataConverter(str)
+      str
+    end
+
+=begin
+=== Methods
+    --- Builder#parse(xml, parse_ext = false)
+
+parse string or stream of XML contents.
+
+  xml:       string or stream of XML contents
+  parse_ext: flag whether parse external entities or not
+
+ex. doctree = parser.parse(xml, parse_ext)
+
+=end
+    ## Parse
+    ##   doctree = parser.parse(xml, parse_ext)
+    ##     xml:       string or stream of XML contents
+    ##     parse_ext: flag whether parse external entities or not
+    def parse(xml, parse_ext = false)
+      if @external
+        @tree = @document.createDocumentFragment
+      else
+        @tree = @document
+      end
+      @parse_ext = parse_ext
+      @current = @tree
+      @inDocDecl = 0
+      @decl = ""
+      @inDecl = 0
+      @idRest = 0
+      @extID = nil
+      @cdata_f = false
+      @cdata_buf = ''
+      super(xml)
+      @tree
+    end
+
+    def text
+      return if @cdata_buf == ''
+      textnode = @document.createTextNode(cdataConverter(@cdata_buf))
+      @current.appendChild(textnode)
+      @cdata_buf = ''
+    end
+  
+    def startElement(name, data)
+      text
+      elem = @document.createElement(nameConverter(name))
+      data.each do |key, value|
+        attr = @document.createAttribute(nameConverter(key))
+        attr.appendChild(@document.createTextNode(cdataConverter(value)))
+        elem.setAttributeNode(attr)
+      end
+      @current.appendChild(elem)
+      @current = elem
+    end
+
+    def endElement(name)
+      text
+      @current = @current.parentNode
+    end
+
+    def character(data)
+      @cdata_buf << data
+     end
+
+    def processingInstruction(name, data)
+      text
+      pi = @document.createProcessingInstruction(nameConverter(name),
+                                                 cdataConverter(data))
+      ## PI data should not be converted
+      @current.appendChild(pi)
+    end
+
+    def externalEntityRef(context, base, systemId, publicId)
+      text
+      tree = nil
+      if @parse_ext
+        extp = self.class.new(@level, self, context)
+        extp.setBase(base) if base
+        file = systemId
+        if systemId !~ /^\/|^\.|^http:|^ftp:/ && !base.nil?
+          file = base + systemId
+        end
+        begin
+          tree = extp.parse(open(file).read, @parse_ext)
+        rescue XML::ParserError
+          raise XML::ParserError.new("#{systemId}(#{extp.line}): #{$!}")
+        rescue Errno::ENOENT
+          raise Errno::ENOENT.new("#{$!}")
+        end
+        extp.done
+      end
+      if @createEntityReference
+        entref = @document.createEntityReference(nameConverter(context))
+        @current.appendChild(entref)
+        entref.appendChild(tree) if tree
+      else
+        @current.appendChild(tree) if tree
+      end
+    end
+
+    def startCdata
+      return unless @createCDATASection
+      text
+      @cdata_f = true
+    end
+
+    def endCdata
+      return unless @createCDATASection
+      cdata = @document.createCDATASection(cdataConverter(@cdata_buf))
+      @current.appendChild(cdata)
+      @cdata_buf = ''
+      @cdata_f = false
+    end
+
+    def comment(data)
+      text
+      comment = @document.createComment(cdataConverter(data))
+      ## Comment should not be converted
+      @current.appendChild(comment)
+    end
+
+    def defaultHandler(data)
+      if data =~ /^\&(.+);$/
+        eref = @document.createEntityReference(nameConverter($1))
+        @current.appendChild(eref)
+      elsif data =~ /^<\?xml\s*([\s\S]*)\?>$/
+        ## XML declaration should not be a PI.
+        pi = @document.createProcessingInstruction("xml",
+                                       cdataConverter($1))
+        @current.appendChild(pi)
+      elsif @inDocDecl == 0 && data =~ /^<\!DOCTYPE$/
+        @inDocDecl = 1
+        @inDecl = 0
+        @idRest = 0
+        @extID = nil
+      elsif @inDocDecl == 1
+        if data == "["
+          @inDocDecl = 2
+        elsif data == ">"
+          if !@extID.nil?
+##            @current.nodeValue = @extID
+          end
+          @inDocDecl = 0
+##          @current = @current.parentNode
+        elsif data == "SYSTEM"
+          @idRest = 1
+          @extID = data
+        elsif data == "PUBLIC"
+          @idRest = 2
+          @extID = data
+        elsif data !~ /^\s+$/
+          if @idRest > 0
+            ## SysID or PubID
+            @extID <<= " " + data
+            @idRest -= 1
+          else
+            ## Root Element Type
+            docType = data
+##            doctype = DocumentType.new(nameConverter(docType))
+##            @current.appendChild(doctype)
+##            @current = doctype
+          end
+        end
+      elsif @inDocDecl == 2
+        if @inDecl == 0
+          if data == "]"
+            @inDocDecl = 1
+          elsif data =~ /^<\!/
+            @decl = data
+            @inDecl = 1
+          elsif data =~ /^%(.+);$/
+            ## PERef
+##            cdata = @document.createTextNode(nameConverter(data))
+##            @current.appendChild(cdata)
+          else
+            ## WHITESPCAE
+          end
+        else ## inDecl == 1
+          if data == ">"
+            @decl <<= data
+            @inDecl = 0
+            ## Markup Decl
+##            cdata = @document.createTextNode(cdataConverter(@decl))
+            ## Markup decl should not be converted
+##            @current.appendChild(cdata)
+          elsif data =~ /^\s+$/
+            ## WHITESPACE
+            @decl << " "
+          else
+            @decl << data
+          end
+        end
+      else
+        ## maybe WHITESPACE
+##        cdata = @document.createTextNode(cdataConverter(data))
+##        @current.appendChild(cdata)
+      end
+    end
+
+  end
+  end
+
+  SimpleTreeBuilder = DOM::Builder
+end

data/lib/xml/dom/core.rb

@@ -0,0 +1,3276 @@
+## -*- Ruby -*-
+## XML::SimpleTree
+## 1998-2000 by yoshidam
+##
+## XPointer support is contributed by Masaki Fukushima 
+##     <fukusima@goto.info.waseda.ac.jp>
+##                     
+
+require 'singleton'
+
+=begin
+
+= XML::DOM (XML::SimpleTree)
+
+=end
+
+
+=begin
+
+== Module XML
+
+=end
+
+module XML
+
+=begin
+=== Class Methods
+
+    --- XML.charRef(s)
+
+replace character '&','<','>',"'",'"' in string s to character reference.
+=end
+
+  def XML.charRef(s)
+    str = s.dup
+    str.gsub!("&", "&amp;")
+    str.gsub!("<", "&lt;")
+    str.gsub!(">", "&gt;")
+    str.gsub!("'", "&apos;")
+    str.gsub!('"', "&quot;")
+    str
+  end
+
+=begin
+
+== Module XML::Spec
+
+Constants related to XML Specification.
+
+=end
+  ## [Masaki Fukushima]
+  module Spec
+    ## Constants related to XML Specification
+    ##   (W3C Recommendation or Working Draft)
+
+    # XML
+    Letter_s = '[a-zA-Z]'
+    Digit_s = '\d'
+    NameChar_s = "(#{Letter_s}|#{Digit_s}|[\\.\\-_:])"
+    Name_s = "(#{Letter_s}|[_:])#{NameChar_s}*"
+    SkipLit_s = "(\"[^\"]*\"|'[^']*')"
+    Name = /^#{Name_s}$/o
+    SkipList = /^#{SkipLit_s}$/o
+
+    # XPointer
+    Instance_s = "(\\+|-)?[1-9]#{Digit_s}*"
+    Instance = /^#{Instance_s}$/o
+
+  end
+
+=begin
+
+== Module XML::DOM (XML::SimpleTree)
+
+DOM-like APIs module.
+
+=end
+
+  module DOM
+
+    ## Fundamental Interfaces
+
+=begin
+
+== Class XML::DOM::DOMException
+
+=== superclass
+Exception
+
+DOM exception.
+=end
+
+    class DOMException<Exception
+      INDEX_SIZE_ERR = 1
+      WSTRING_SIZE_ERR = 2
+      HIERARCHY_REQUEST_ERR  = 3
+      WRONG_DOCUMENT_ERR = 4
+      INVALID_NAME_ERR = 5
+      NO_DATA_ALLOWED_ERR = 6
+      NO_MODIFICATION_ALLOWED_ERR = 7
+      NOT_FOUND_ERR = 8
+      NOT_SUPPORTED_ERR = 9
+      INUSE_ATTRIBUTE_ERR = 10
+      ERRMSG = [
+        "no error",
+        "index size",
+        "wstring size",
+        "hierarchy request",
+        "wrong document",
+        "invalid name",
+        "no data allowed",
+        "no modification allowed",
+        "not found",
+        "not supported",
+        "inuse attribute"
+      ]
+
+=begin
+=== Class Methods
+
+    --- DOMException.new(code = 0)
+
+generate DOM exception.
+=end
+
+      def initialize(code = 0)
+        @code = code
+      end
+
+=begin
+=== Methods
+
+    --- DOMException#code()
+
+return code of exception.
+
+=end
+      def code
+        @code
+      end
+
+=begin
+
+    --- DOMException#to_s()
+
+return the string representation of the error.
+
+=end
+      def to_s
+        ERRMSG[@code]
+      end
+    end
+
+=begin
+== Class XML::DOM::DOMImplementation
+
+=end
+    class DOMImplementation
+      include Singleton
+
+=begin
+   --- DOMImplementation#hasFeature(feature, version)
+
+test if DOM implementation has correct feature and version.
+
+=end
+      def hasFeature(feature, version)
+        if feature =~ /^XML$/i && (version.nil? || version == "1.0")
+          return true
+        end
+        false
+      end
+    end
+
+=begin
+== Class XML::DOM::Node
+
+=end
+    class Node
+      ## [DOM]
+      NODE_NODE = 0
+      ELEMENT_NODE = 1
+      ATTRIBUTE_NODE = 2
+      TEXT_NODE = 3
+      CDATA_SECTION_NODE = 4
+      ENTITY_REFERENCE_NODE = 5
+      ENTITY_NODE = 6
+      PROCESSING_INSTRUCTION_NODE = 7
+      COMMENT_NODE  = 8
+      DOCUMENT_NODE = 9
+      DOCUMENT_TYPE_NODE = 10
+      DOCUMENT_FRAGMENT_NODE = 11
+      NOTATION_NODE = 12
+
+      ## non-DOM
+#        NODE = 0
+#        ELEMENT = 1
+#        ATTRIBUTE = 2
+#        TEXT = 3
+#        CDATA_SECTION = 4
+#        ENTITY_REFERENCE = 5
+#        ENTITY = 6
+#        PI = 7
+#        PROCESSING_INSTRUCTION = 7
+#        COMMENT  = 8
+#        DOCUMENT = 9
+#        DOCUMENT_TYPE = 10
+#        DOCUMENT_FRAGMENT = 11
+#        NOTATION = 12
+
+=begin
+=== Class Methods
+
+    --- Node.new(*children)
+
+make a Node.
+children is a Array of child, or sequence of child.
+child is a String or Node.
+
+=end
+      ## new([child1, child2, ...]) or
+      ## new(child1, child2, ...)
+      ##     child?: String or Node
+      def initialize(*children)
+        @parent = nil
+        @children = nil
+        self.childNodes = children if children.length > 0
+      end
+
+=begin
+=== Methods
+
+    --- Node#parentNode
+
+[DOM]
+return parent node.
+
+=end
+      ## [DOM]
+      def parentNode
+        @parent
+      end
+
+=begin
+    --- Node#parentNode=(p)
+
+set node p as parent.
+=end
+
+      def parentNode=(p)
+        @parent = p
+      end
+
+=begin
+    --- Node#nodeType
+
+[DOM]
+return nodetype.
+
+=end
+      ## [DOM]
+      def nodeType
+        NODE_NODE
+      end
+
+=begin
+    --- Node#nodeName
+
+[DOM]
+return nodename.
+
+=end
+      ## [DOM]
+      def nodeName
+        "#node"
+      end
+
+#      def nodeName=(p)
+#        @name = p
+#      end
+
+=begin
+    --- Node#nodeValue
+
+[DOM]
+return nodevalue.
+
+=end
+      ## [DOM]
+      def nodeValue; nil; end
+
+=begin
+    --- Node#nodeValue=(p)
+
+[DOM]
+set nodevalue as p.
+=end
+      ## [DOM]
+      def nodeValue=(p)
+        ## no effect
+      end
+
+=begin
+    --- Node#childNodes()
+
+[DOM]
+if method has block, apply block for children nodes.
+without block, return children nodelist.
+=end
+      ## [DOM]
+      def childNodes
+        if iterator?
+          @children.each do |child|
+            yield(child)
+          end if @children
+        else
+          return @children if !@children.nil?
+          @children = NodeList.new
+        end
+      end
+
+
+=begin
+    --- Node#childNodes=(p)
+
+set child node as p.
+=end
+      def childNodes=(p)
+        if @children.nil?
+          @children = NodeList.new
+        else
+          @children.to_a.clear
+        end
+        if p.nil? || (p.is_a?(Array) && p.length == 0)
+          return
+        end
+        p.flatten!
+        p.each do |child|
+          if child.is_a?(String)
+            c = Text.new(child)
+            @children.push(c)
+            c.parentNode = self
+          elsif child.is_a?(Node)
+            @children.push(child)
+            child.parentNode = self
+          else
+            raise "parameter error"
+          end
+        end if p
+      end
+
+=begin
+    --- Node#attributes
+
+[DOM]
+return attributes of node(but always return nil?).
+=end
+      ## [DOM]
+      def attributes
+        nil
+      end
+
+      ## proper parameter type?
+#      def attributes=(p)
+#      end
+
+=begin
+    --- Node#[]=(index, nodes)
+
+set children node as nodes with []-style.
+=end
+      def []=(index, nodes)
+        @children[index..index] = nodes
+        @children.each do |child|
+          child.parentNode = self
+        end if @children
+      end
+
+=begin
+    --- Node#[](index)
+
+get children node with []-style.
+=end
+      def [](index)
+        @children[index]
+      end
+
+=begin
+    --- Node#+(node)
+
+concat node to Node.
+=end
+      def +(node)
+        [self, node]
+      end
+
+=begin
+    --- Node#to_s
+
+returns the string representation of the Node.
+=end
+      def to_s
+        @children.to_s
+      end
+
+=begin
+    --- Node#dump(depth = 0)
+
+dump the Node.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print nodeName + "\n"
+        @children.each do |child|
+          child.dump(depth + 1)
+        end if @children
+      end
+
+=begin
+    --- Node#inspect()
+
+returns the human-readable string representation.
+=end
+      def inspect
+        "#<#{self.class}: #{self.nodeName}>"
+      end
+
+=begin
+    --- Node#firstChild()
+
+[DOM]
+return the first child node.
+=end
+      ## [DOM]
+      def firstChild
+        return nil if !@children || @children.length == 0
+        return @children[0]
+      end
+
+=begin
+    --- Node#lastChild()
+
+[DOM]
+return the last child node.
+=end
+      ## [DOM]
+      def lastChild
+        return nil if !@children || @children.length == 0
+        return @children[-1]
+      end
+
+=begin
+    --- Node#previousSibling()
+
+[DOM]
+return the previous sibling node.
+=end
+      ## [DOM]
+      def previousSibling
+        return nil if !@parent
+        prev = nil
+        @parent.childNodes do |child|
+          return prev if child == self
+          prev = child
+        end
+        nil
+      end
+
+=begin
+    --- Node#nextSibling()
+
+[DOM]
+return the next sibling node.
+=end
+      ## [DOM]
+      def nextSibling
+        return nil if !@parent
+        nexts = nil
+        @parent.childNodes.reverse.each do |child|
+          return nexts if child == self
+          nexts = child
+        end
+        nil
+      end
+
+      def _getChildIndex(node)
+        index = 0
+        @children.each do |child|
+          if child == node
+            return index
+          end
+          index += 1
+        end
+        nil
+      end
+
+      def _removeFromTree
+        parent = parentNode
+        if parent
+          parent.removeChild(self)
+        end
+      end
+
+      def _checkNode(node)
+        raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+      end
+
+      def _insertNodes(index, node)
+        if node.nodeType == DOCUMENT_FRAGMENT_NODE
+
+          node.childNodes.to_a.each_with_index do |n, i|
+            if index == -1
+              _insertNodes(-1, n)
+            else
+              _insertNodes(index + i, n)
+            end
+          end
+        elsif node.is_a?(Node)
+          ## to be checked
+          _checkNode(node)
+          node._removeFromTree
+          if index == -1
+            @children.push(node)
+          else
+            @children[index, 0] = node
+          end
+          node.parentNode = self
+        else
+          raise ArgumentError, "invalid value for Node"
+        end
+      end
+
+      def _removeNode(index, node)
+        @children[index, 1] = nil
+        node.parentNode = nil
+      end
+
+#  =begin
+#      --- Node#insertAfter(newChild, refChild)
+#
+#  insert newChild into the node after refChild.
+#  =end
+#        def insertAfter(newChild, refChild)
+#          if @children.nil? || @children.length == 0
+#            raise DOMException.new(DOMException::NOT_FOUND_ERR)
+#          end
+#          index = _getChildIndex(refChild)
+#          raise DOMException.new(DOMException::NOT_FOUND_ERR) if index.nil?
+#          _insertNodes(index, newChild)
+#        end
+
+=begin
+    --- Node#insertBefore(newChild, refChild)
+
+[DOM]
+insert newChild into the node before refChild.
+=end
+      ## [DOM]
+      def insertBefore(newChild, refChild)
+        if @children.nil? || @children.length == 0
+          raise DOMException.new(DOMException::NOT_FOUND_ERR)
+        end
+        index = _getChildIndex(refChild)
+        raise DOMException.new(DOMException::NOT_FOUND_ERR) if !index
+        _insertNodes(index, newChild)
+      end
+
+=begin
+    --- Node#replaceChild(newChild, oldChild)
+
+[DOM]
+replace the child node oldChild with newChild.
+=end
+      ## [DOM]
+      def replaceChild(newChild, oldChild)
+        if @children.nil? || @children.length == 0
+          raise DOMException.new(DOMException::NOT_FOUND_ERR)
+        end
+        index = _getChildIndex(oldChild)
+        raise DOMException.new(DOMException::NOT_FOUND_ERR) if !index
+        _removeNode(index, oldChild)
+        _insertNodes(index, newChild)
+      end
+
+=begin
+    --- Node#removeChild(oldChild)
+
+[DOM]
+remove the children node oldChild.
+=end
+      ## [DOM]
+      def removeChild(oldChild)
+        if @children.nil? || @children.length == 0
+          raise DOMException.new(DOMException::NOT_FOUND_ERR)
+        end
+        index = _getChildIndex(oldChild)
+        raise DOMException.new(DOMException::NOT_FOUND_ERR) if !index
+        _removeNode(index, oldChild)
+        oldChild
+      end
+
+=begin
+    --- Node#appendChild(newChild)
+
+[DOM]
+adds the node newChild to the end of the list of children of this node.
+=end
+      ## [DOM]
+      def appendChild(newChild)
+        @children = NodeList.new if !@children
+        _insertNodes(-1, newChild)
+      end
+
+=begin
+    --- Node#hasChildNodes()
+
+[DOM]
+returns true if node has children, or return false if node has no children.
+=end
+      ## [DOM]
+      def hasChildNodes
+        !@children.nil? && @children.length > 0
+      end
+
+      ## get the Node object by IDs
+      ## [experimental implement]
+      def _searchID(value, ids = nil)
+        if ids.nil?
+          doc = nil
+          if nodeType == DOCUMENT_NODE
+            doc = self
+          elsif !ownerDocument.nil?
+            doc = ownerDocument
+          else
+            return nil
+          end
+          ids = doc._getIDAttrs
+        end
+        if nodeType == ELEMENT_NODE && _getIDVals(ids).include?(value)
+          return self
+        elsif !@children.nil?
+          @children.each do |node|
+            if !(match = node._searchID(value, ids)).nil?
+              return match
+            end
+          end
+        end
+        return nil
+      end
+
+      def _getMyLocation(parent)
+        index = parent._getChildIndex(self)
+        if !index.nil?
+          "child(#{index + 1},#all)"
+        else
+          nil
+        end
+      end
+
+=begin
+    --- Node#makeXPointer(use_id = true)
+
+return XPointer's expression of this node.
+=end
+      def makeXPointer(use_id = true)
+        if use_id && !attributes.nil? && !(idvals = _getIDVals).empty?
+          "id(#{idvals[0]})"
+        elsif @parent.nil? || @parent.nodeType == DOCUMENT_NODE
+          "root()"
+        else
+          @parent.makeXPointer(use_id) + "." + self._getMyLocation(@parent)
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _child(reverse = false)
+        return if @children.nil?
+        @children.reversible_each(reverse) do |child|
+          yield child
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _descendant(reverse = false)
+        return if @children.nil?
+        @children.reversible_each(reverse) do |child|
+          yield child
+          child._descendant(reverse) do |node|
+            yield node
+          end
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _ancestor(reverse = false)
+        return if @parent.nil?
+        yield @parent if !reverse
+        @parent._ancestor(reverse) do |node| yield node end
+        yield @parent if reverse
+      end
+
+      ## [Masaki Fukushima]
+      def __sibling(reverse, only_appeared_before_self)
+        return if @parent.nil?
+        self_appeared = false
+        @parent.childNodes.reversible_each(reverse) do |node|
+          if node == self
+            self_appeared = true
+            next
+          end
+          if only_appeared_before_self
+            break if self_appeared
+            yield node
+          else # only appeared after self
+            yield node if self_appeared
+          end
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _psibling(reverse = false)
+        __sibling(!reverse, reverse) do |sib|
+          yield sib
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _fsibling(reverse = false)
+        __sibling(reverse, reverse) do |sib|
+          yield sib
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _preceding(reverse = false)
+        return if @parent.nil?
+        prev_sib = previousSibling
+        if prev_sib
+          prev_sib._preceding(reverse)   {|node| yield node} if reverse
+          yield prev_sib
+          prev_sib._descendant(!reverse) {|node| yield node}
+          prev_sib._preceding(reverse)   {|node| yield node} if !reverse
+        else
+          @parent._preceding(reverse) {|node| yield node} if reverse
+          yield @parent
+          @parent._preceding(reverse) {|node| yield node} if !reverse
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _following(reverse = false)
+        return if @parent.nil?
+        next_sib = nextSibling
+        if next_sib
+          next_sib._following(reverse)  {|node| yield node} if reverse
+          yield next_sib
+          next_sib._descendant(reverse) {|node| yield node}
+          next_sib._following(reverse)  {|node| yield node} if !reverse
+        else
+          @parent._following(reverse) {|node| yield node} if reverse
+          yield @parent
+          @parent._following(reverse) {|node| yield node} if !reverse
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _matchAttribute?(attr, value)
+        case value
+        when '*'
+          return !attr.nil?
+        when '#IMPLIED'
+          return attr.nil?
+        else
+          return false if attr.nil?
+        end
+
+        case value
+        when /^"([^"]*)"$/, /^'([^']*)'$/
+          ignore_case = false
+          value = $1
+        when Spec::Name
+          ignore_case = true
+        else
+          raise "invalid attribute value: #{value}"
+        end
+        if ignore_case
+          return attr.nodeValue.downcase == value.downcase
+        else
+          return attr.nodeValue == value
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _matchNodeAttributes?(node, attributes)
+        return true     if attributes.nil?
+        raise TypeError if !attributes.is_a?(Hash)
+        return true     if attributes.length == 0
+        return false    if node.nodeType != ELEMENT_NODE
+
+        attributes.each do |name, value|
+          case name
+          when '*'
+            return catch(:match) {
+              node.attributes.each do |attr|
+                throw(:match, true) if _matchAttribute?(attr, value)
+              end
+              false
+            }
+          when Spec::Name
+            attr = node.attributes[name] unless node.attributes.nil?
+            return _matchAttribute?(attr, value)
+          else
+            raise "invalid attribute name: '#{name}'"
+          end
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _matchNodeType?(node, ntype)
+        case ntype
+        when '#element'
+          return (node.nodeType == ELEMENT_NODE)
+        when '#pi'
+          return (node.nodeType == PROCESSING_INSTRUCTION_NODE)
+        when '#comment'
+          return (node.nodeType == COMMENT_NODE)
+        when '#text'
+          return (node.nodeType == TEXT_NODE ||
+                  node.nodeType == CDATA_SECTION_NODE)
+        when '#cdata'
+          return (node.nodeType == CDATA_SECTION_NODE)
+        when '#all'
+          case node.nodeType
+          when ELEMENT_NODE, PROCESSING_INSTRUCTION_NODE, COMMENT_NODE,
+              TEXT_NODE, CDATA_SECTION_NODE
+            return true
+          else
+            return false
+          end
+        when /^#/
+          raise "unknown node type: '#{ntype}'"
+        when Spec::Name
+          return (node.nodeType == ELEMENT_NODE && node.nodeName == ntype)
+        else
+          raise "invalid element type: '#{ntype}'"
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _matchNode?(node, ntype, attributes)
+        _matchNodeType?(node, ntype) &&
+          _matchNodeAttributes?(node, attributes)
+      end
+
+      ## [Masaki Fukushima]
+      def _nodesByRelativeLocationTerm(location)
+        if location !~ /^([a-z]+)\(([^\)]*)\)$/
+          raise "invalid relative location: '#{location}'"
+        end
+        keyword = $1
+        args = $2.split(/,/)
+        number = args.shift
+        ntype = args.shift
+        ntype = '#element' if ntype.nil?
+        attributes = args
+
+        reverse = false
+        # check instance number
+        case number
+        when nil, ''
+          raise "missing instance number: '#{location}'"
+        when 'all'
+        when Spec::Instance
+          number = number.to_i
+          if number < 0
+            reverse = true
+            number = -number
+          end
+        else
+          raise "unknown instance number: '#{number}'"
+        end
+
+        # check attributes
+        if attributes.length % 2 != 0
+          raise " missing attribute value: '#{location}'"
+        end
+        attributes = Hash[*attributes]
+
+        # iterate over nodes specified with keyword
+        i = 0
+        self.send("_#{keyword}", reverse) do |node|
+          next unless _matchNode?(node, ntype, attributes)
+          if number == "all"
+            yield node
+          else
+            i += 1
+            if i >= number
+              yield node
+              break
+            end
+          end
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _nodesByLocationTerms(location, pre_keyword = nil)
+        if location !~ /^([a-z]*)\(([^)]*)\)(\.(.+))?$/
+          raise "invalid location: \"#{location}\""
+        end
+        keyword = $1
+        args = $2
+        rest = $4
+        ## omitted keyword
+        keyword = pre_keyword if keyword == ''
+        if keyword.nil?
+          raise "cannot determine preceding keyword: \"#{location}\""
+        end
+
+        case keyword
+        when 'child', 'descendant', 'ancestor', 'psibling', 'fsibling',
+            'preceding', 'following'
+          # relative location term
+          _nodesByRelativeLocationTerm("#{keyword}(#{args})") do |node|
+            if rest.nil?
+              yield node
+            else
+              node._nodesByLocationTerms(rest, keyword) do |n|
+                yield n
+              end
+            end
+          end
+        when 'attr'
+          # attribute location term
+          if args !~ Spec::Name
+            raise "invalid attribute name: '#{args}'"
+          end
+          attr = attributes[args]
+          value = (attr.nil? ? nil : Text.new(attr.nodeValue))
+          if rest.nil?
+            yield value
+          elsif !value.nil?
+            value._nodesByLocationTerms(rest) do |node|
+              yield node
+            end
+          end
+        when 'span', 'string'
+          raise "unsupported keyword: '#{keyword}'"
+        else
+          raise "unknown keyword: '#{keyword}'"
+        end
+      end
+
+      ## [Masaki Fukushima]
+      def _getNodeByAbsoluteLocationTerm(location)
+        case location
+        when 'root()', ''
+          if nodeType == DOCUMENT_NODE
+            root = documentElement
+          elsif !ownerDocument.nil?
+            root = ownerDocument.documentElement
+          end
+          root = self if root.nil?
+          return root
+        when 'origin()'
+          return self
+        when /^id\(([^\)]*)\)$/
+          value = $1
+          raise "invalid id value: #{value}" if value !~ Spec::Name
+          return _searchID(value)
+        when /^html\(([^\)]*)\)$/
+          value = $1
+          return getNodesByXPointer("root().descendant(1,A,NAME,\"#{value}\")")[0]
+        else
+          raise "unknown keyword: #{location}"
+        end
+      end
+
+=begin
+    --- Node#getNodeByXPointer(pointer)
+
+return node indicated by the XPointer pointer.
+=end
+      ## [Masaki Fukushima]
+      def getNodesByXPointer(pointer)
+        if pointer !~ /^([a-z]+)\(([^)]*)\)(\.(.+))?$/
+          raise "invalid XPointer: \"#{pointer}\""
+        end
+        keyword = $1
+        args = $2
+        rest = $4
+
+        case keyword
+        when 'root', 'origin', 'id', 'html'
+          src = _getNodeByAbsoluteLocationTerm("#{keyword}(#{args})")
+        else
+          src = _getNodeByAbsoluteLocationTerm("root()")
+          rest = pointer
+        end
+
+        ret = NodeList.new
+        if src.nil?
+          # no match
+        elsif rest.nil?
+          yield src if iterator?
+          ret << src
+        else
+          src._nodesByLocationTerms(rest) do |node|
+            yield node if iterator?
+            ret << node
+          end
+        end
+        ret
+      end
+
+=begin
+    --- Node#ownerDocument()
+
+[DOM]
+Document object associated with this node.
+=end
+      ## [DOM]
+      ## Floating objects are not owned by any documents.
+      def ownerDocument
+        return @ownerDocument if @ownerDocument
+        parent = self.parentNode
+        return nil if parent.nil?
+        if parent.nodeType == DOCUMENT_NODE
+          return parent
+        else
+          return parent.ownerDocument
+        end
+      end
+
+      def ownerDocument=(document); @ownerDocument = document; end
+
+
+=begin
+    --- Node#cloneNode()
+
+[DOM]
+return the copy of the Node.
+=end
+      ## [DOM]
+      def cloneNode(deep = true, *args)
+        ret = self.class.new(*args)
+        if (deep)
+          @children.each do |child|
+            ret.appendChild(child.cloneNode(true))
+          end
+        end if @children
+        ret
+      end
+
+=begin
+    --- Node#trim(preserve = false)
+
+trim extra whitespaces.
+=end
+      ## trim extra whitespaces
+      ## if attribute 'xml:space' is 'preserve',
+      ## don't trim any white spaces
+      def trim(preserve = false)
+        return nil if @children.nil?
+        children = @children.to_a.dup
+        children.each do |child|
+          if !preserve && (child.nodeType == TEXT_NODE ||
+                           child.nodeType == CDATA_SECTION_NODE)
+            if child.trim == ""
+              self.removeChild(child)
+            end
+          else
+            child.trim(preserve)
+          end
+        end
+        nil
+      end
+
+
+    end
+
+=begin
+== Class XML::DOM::NamedNodeMap
+
+=end
+
+    class NamedNodeMap
+
+=begin
+=== Class Methods
+
+    --- NamedNodeMap.new(nodes = nil)
+
+creates a new NamedNodeMap.
+=end
+      def initialize(nodes = nil)
+        @nodes = {}
+        nodes.each do |node|
+          @nodes[node.nodeName] = node
+        end if nodes
+      end
+
+=begin
+=== Methods
+
+    --- NamedNodeMap#getNamedItem(name)
+
+[DOM]
+retrieves a node specified by name.
+=end
+      ## [DOM]
+      def getNamedItem(name)
+        @nodes[name]
+      end
+
+=begin
+    --- NamedNodeMap#setNamedItem(node)
+
+[DOM]
+adds a node using its nodeName attribute.
+=end
+      ## [DOM]
+      def setNamedItem(node)
+        @nodes[node.nodeName] = node
+      end
+
+=begin
+    --- NamedNodeMap#removeNamedItem(name)
+
+[DOM]
+removes a node specified by name.
+=end
+      ## [DOM]
+      def removeNamedItem(name)
+        ret = @nodes[name]
+        @nodes[name] = nil
+        ret
+      end
+
+=begin
+    --- NamedNodeMap#item(index)
+
+[DOM]
+returns the index item in the map.
+=end
+      ## [DOM]
+      def item(index)
+        v = @nodes.to_a[index]
+        return v[1] if v
+        nil
+      end
+
+=begin
+    --- NamedNodeMap#[](name)
+
+returns nodes associated to name.
+=end
+      def [](name)
+        @nodes[name]
+      end
+
+=begin
+    --- NamedNodeMap#[]=(name, node)
+
+sets node named name.
+=end
+      def []=(name, node)
+        raise "parameter error" if node.nodeName != name
+        @nodes[name] = node
+      end
+
+=begin
+    --- NamedNodeMap#each()
+
+iterates over each pair of name and node(name, node) of the namedNodeMap.
+=end
+      def each
+        @nodes.each do |key, value|
+          yield(value)
+        end
+      end
+
+=begin
+    --- NamedNodeMap#size()
+
+[DOM]
+returns the number of nodes in the map.
+=end
+      ## [DOM]
+      def size
+        @nodes.length
+      end
+      alias length size
+
+      ## get nodeValues by names
+      ##   names ::= name ('|' name)*
+      def _getValues(names)
+        ret = []
+        names.split('|').each do |name|
+          if !@nodes[name].nil?
+            ret.push(@nodes[name].nodeValue)
+          end
+        end
+        ret
+      end
+    end
+
+=begin
+== Class XML::DOM::NodeList
+
+
+=end
+    class NodeList
+
+=begin
+=== Class Methods
+
+    --- NodeList.new(nodes = nil)
+
+creates a new NodeList.
+=end
+      def initialize(nodes = nil)
+        if nodes.nil?
+          @nodes = []
+        elsif nodes.is_a?(Array)
+          @nodes = nodes
+        else
+          raise "parameter error"
+        end
+      end
+
+=begin
+=== Methods
+
+    --- NodeList#item(index)
+
+[DOM]
+return the indexth item in the NodeList.
+=end
+      ## [DOM]
+      def item(index)
+        @nodes[index]
+      end
+
+=begin
+    --- NodeList#size()
+
+return size of NodeList.
+=end
+      def size
+        @nodes.length
+      end
+      alias length size
+
+=begin
+    --- NodeList#[](index)
+
+return indexth node of the NodeList.
+=end
+      def [](index)
+        @nodes[index]
+      end
+
+=begin
+    --- NodeList#[]=(*p)
+
+set node of indexth node of the NodeList.
+=end
+      def []=(*p)
+        if p.length == 2
+          @nodes[p[0]] = p[1]
+        elsif p.length == 3
+          @nodes[p[0], p[1]] = p[2]
+        end
+      end
+
+=begin
+    --- NodeList#each
+
+iterates over each node of the NodeList.
+=end
+      def each
+        @nodes.each do |value|
+          yield(value)
+        end
+      end
+
+=begin
+    --- NodeList#reversible_each(reverse = false)
+
+iterates over each node of the reversed NodeList.
+=end
+      ## [Masaki Fukushima]
+      def reversible_each(reverse = false)
+        if !reverse
+          @nodes.each do |value|
+            yield(value)
+          end
+        else
+          @nodes.reverse_each do |value|
+            yield(value)
+          end
+        end
+      end
+
+=begin
+    --- NodeList#push(*nodes)
+
+adds nodes into the NodeList.
+=end
+      def push(*nodes)
+        nodes.each do |node|
+          if node.is_a?(Array)
+            self.push(*node)
+          elsif node.is_a?(NodeList)
+            @nodes.concat(node.to_a)
+          elsif node.is_a?(Node)
+            @nodes << node
+          else
+            raise "parameter error"
+          end
+        end
+        self
+      end
+
+=begin
+    --- NodeList#concat(*nodes)
+
+alias of NodeList#push.
+=end
+      alias concat push
+
+=begin
+    --- NodeList#pop
+
+pops and returns the last node of the NodeList.
+=end
+      def pop
+        @nodes.pop
+      end
+
+=begin
+    --- NodeList#shift
+
+removes and returns the first node of the NodeList.
+=end
+      def shift
+        @nodes.shift
+      end
+
+=begin
+    --- NodeList#to_s
+
+returns the string representation of the NodeList.
+=end
+      def to_s
+        @nodes.to_s
+      end
+
+=begin
+    --- NodeList#reverse
+
+returns the reversed NodeList.
+=end
+      def reverse
+        @nodes.reverse
+      end
+
+=begin
+    --- NodeList#to_a
+
+converts the NodeList into an array.
+=end
+      def to_a
+        @nodes
+      end
+
+=begin
+    --- NodeList#+(nodes)
+
+return the newly created concatenated NodeList.
+=end
+      def +(nodes)
+        if nodes.nil?
+          NodeList.new(@nodes)
+        elsif nodes.is_a?(Array)
+          NodeList.new(@nodes + nodes)
+        elsif nodes.is_a?(NodeList)
+          NodeList.new(@nodes + nodes.to_a)
+        elsif nodes.is_a?(Node)
+          NodeList.new(@nodes + [nodes])
+        else
+          raise "parameter error"
+        end
+      end
+
+=begin
+    --- NodeList#<<(nodes)
+
+appends nodes to the NodeList.
+=end
+      ## modified by Masaki Fukushima
+      def <<(nodes)
+        if nodes.nil?
+          ## no change
+        elsif nodes.is_a?(Array)
+          @nodes.concat(nodes)
+        elsif nodes.is_a?(NodeList)
+          @nodes.concat(nodes.to_a)
+        elsif nodes.is_a?(Node)
+          @nodes << nodes
+        else
+          raise "parameter error"
+        end
+        self
+      end
+
+      ## get nodeValues by names
+      ##   names ::= name ('|' name)*
+      def _getValues(names)
+        ret = []
+        names.split('|').each do |name|
+          if !@nodes[name].nil?
+            ret.push(@nodes[name].nodeValue)
+          end
+        end
+        ret
+      end
+    end
+
+=begin
+== Class XML::DOM::DocumentFragment
+
+=== superclass
+Node
+
+=end
+    class DocumentFragment<Node
+
+=begin
+=== Class Methods
+
+    --- DocumentFragment.new(*children)
+
+creates a new DocumentFragment.
+=end
+
+      def initialize(*children)
+        super(*children)
+      end
+
+=begin
+=== Methods
+
+    --- DocumentFragment#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        DOCUMENT_FRAGMENT_NODE
+      end
+
+=begin
+    --- DocumentFragment#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        "#document-fragment"
+      end
+
+=begin
+    --- DocumentFragment#parentNode=(p)
+
+returns the parent of this node.
+=end
+      ## DocumentFragment should not have the parent node.
+      def parentNode=(p)
+        @children.each do |child|
+          child.parentNode = p
+        end if @children
+      end
+
+      def _checkNode(node)
+        unless node.nodeType == ELEMENT_NODE ||
+            node.nodeType == PROCESSING_INSTRUCTION_NODE ||
+            node.nodeType == COMMENT_NODE ||
+            node.nodeType == TEXT_NODE ||
+            node.nodeType == CDATA_SECTION_NODE ||
+            node.nodeType == ENTITY_REFERENCE_NODE
+          raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+        end
+      end
+
+    end
+
+=begin
+== Class XML::DOM::Document
+
+=== superclass
+Node
+
+=end
+    class Document<Node
+=begin
+=== Class Methods
+    --- Document.new(*children)
+
+creates a new Document.
+=end
+
+      ## new([child1, child2, ...]) or
+      ## new(child1, child2, ...)
+      ##     child?: String or Node
+      def initialize(*children)
+        super(*children)
+      end
+
+=begin
+=== Methods
+
+    --- Document#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        DOCUMENT_NODE
+      end
+
+=begin
+    --- Document#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        "#document"
+      end
+
+=begin
+    --- Document#documentElement
+
+[DOM]
+returns root element of the Docuemnt.
+=end
+      ## [DOM]
+      def documentElement
+        @children.each do |child|
+          if child.nodeType == ELEMENT_NODE
+            return child
+          end
+        end if @children
+        nil
+      end
+
+=begin
+    --- Document#doctype
+
+[DOM]
+returns DTD associated with this document.
+=end
+      ## [DOM]
+      def doctype
+        @children.each do |child|
+          if child.nodeType == DOCUMENT_TYPE_NODE
+            return child
+          end
+        end if @children
+        nil
+      end
+
+=begin
+    --- Document#getElementsByTagName(tagname)
+
+[DOM]
+returns a NodeList of all the Elements with a given tag name.
+=end
+      ## [DOM] (but this is not "live")
+      def getElementsByTagName(tagname)
+        ret = NodeList.new
+        @children.each do |node|
+          if node.nodeType == ELEMENT_NODE
+            if tagname == '*' || node.nodeName == tagname
+              ret << node
+            end
+            ret << node.getElementsByTagName(tagname)
+          end
+        end if @children
+        ret
+      end
+
+=begin
+    --- Document#createElement(tagName)
+
+[DOM]
+creates a Element.
+=end
+      ## [DOM]
+      def createElement(tagName)
+        ret = Element.new(tagName)
+        ret.ownerDocument = self
+        ret
+      end
+
+=begin
+    --- Document#createTextNode(data)
+
+[DOM]
+creates a TextNode.
+=end
+      ## [DOM]
+      def createTextNode(data)
+        ret = Text.new(data)
+        ret.ownerDocument = self
+        ret
+      end
+
+=begin
+    --- Document#createCDATASection(data)
+
+[DOM]
+creates a CDATASection.
+=end
+      ## [DOM]
+      def createCDATASection(data)
+        ret = CDATASection.new(data)
+        ret.ownerDocument = self
+        ret
+      end
+
+=begin
+    --- Document#createComment(data)
+
+[DOM]
+create a Comment.
+=end
+      ## [DOM]
+      def createComment(data)
+        ret = Comment.new(data)
+        ret.ownerDocument = self
+        ret
+      end
+
+=begin
+    --- Document#createProcessingInstruction(target, data)
+
+[DOM]
+create a ProcessingInstruction.
+=end
+      ## [DOM]
+      def createProcessingInstruction(target, data)
+        ret = ProcessingInstruction.new(target, data)
+        ret.ownerDocument = self
+        ret
+      end
+
+=begin
+    --- Document#createAttribute(name)
+
+[DOM]
+create a Attribute.
+=end
+      ## [DOM]
+      def createAttribute(name)
+        ret = Attr.new(name)
+        ret.ownerDocument = self
+        ret
+      end
+
+=begin
+    --- Document#createEntityReference(name)
+
+[DOM]
+create a EntityReference.
+=end
+      ## [DOM]
+      def createEntityReference(name)
+        ret = EntityReference.new(name)
+        ret.ownerDocument = self
+        ret
+      end
+
+=begin
+    --- Document#createDocumentFragment()
+
+[DOM]
+create a DocumentFragment.
+=end
+      ## [DOM]
+      def createDocumentFragment
+        ret = DocumentFragment.new
+        ret.ownerDocument = self
+        ret
+      end
+
+      ## set the ID list by the attribute name with the element name
+      ## (or wildcard)
+      ## [experimental implement]
+      def _setIDAttr(attrname, elemname = '*')
+        @idattrs = {} if @idattrs.nil?
+        @idattrs[elemname] = attrname
+      end
+
+      ## get the ID list
+      ## [experimental implement]
+      def _getIDAttrs
+        return {'*'=>'id'} if @idattrs.nil?
+        @idattrs
+      end
+
+      ## [DOM]
+      def implementation
+        return @implemantation if @implemantation
+        ## singleton
+        @implemantation = DOMImplementation.instance
+      end
+
+      def implementation=(impl)
+        @implemantation = impl
+      end
+
+      def _checkNode(node)
+        unless node.nodeType == ELEMENT_NODE ||
+            node.nodeType == PROCESSING_INSTRUCTION_NODE ||
+            node.nodeType == COMMENT_NODE ||
+            node.nodeType == DOCUMENT_TYPE_NODE
+          raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+        end
+
+        if node.nodeType == ELEMENT_NODE
+          @children.each do |n|
+            if n.nodeType == ELEMENT_NODE
+              raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+            end
+          end
+        end
+
+        if node.nodeType == DOCUMENT_TYPE_NODE
+          @children.each do |n|
+            if n.nodeType == DOCUMENT_TYPE_NODE
+              raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+            end
+          end
+        end
+      end
+
+    end
+
+=begin
+== Class XML::DOM::Attr
+
+=== superclass
+Node
+
+=end
+    class Attr<Node
+      ## new(name, [text1, text2, ...]) or
+      ## new(name, text1, text2, ...)
+      ##     name:  String
+      ##     text?: String or Node
+
+=begin
+=== Class Methods
+
+    --- Attr.new(name = nil, *text)
+
+create a new Attr.
+=end
+      def initialize(name = nil, *text)
+        super(text)
+        raise "parameter error" if !name
+        @name =  name
+        @name.freeze
+      end
+
+=begin
+=== Methods
+
+    --- Attr#nodeType()
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        ATTRIBUTE_NODE
+      end
+
+=begin
+    --- Attr#nodeName()
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        @name
+      end
+
+=begin
+    --- Attr#nodeValue()
+
+[DOM]
+returns the nodeValue.
+=end
+      ## [DOM]
+      def nodeValue
+        ret = ""
+        @children.each do |child|
+          ret << child.nodeValue
+        end if @children
+        ret
+      end
+
+=begin
+    --- Attr#nodeValue=(text)
+
+[DOM]
+returns the value of this node.
+=end
+      ## [DOM]
+      def nodeValue=(text)
+        self.childNodes = [text]
+      end
+
+=begin
+    --- Attr#to_s()
+
+return the string representation of the Attr.
+=end
+      def to_s
+        value = ""
+        nodeValue.each_byte do |code|
+          case code
+          when 9, 10, 13
+            value << sprintf("&#x%X;", code)
+          when ?&
+            value << "&amp;"
+          when ?"
+            value << "&quot;"
+          when ?<
+            value << "&lt;"
+          else
+            value << code
+          end
+        end
+        "#{@name}=\"#{value}\""
+      end
+
+=begin
+    --- Attr#dump(depth = 0)
+
+dump the Attr.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print "// #{self.to_s}\n"
+      end
+
+=begin
+    --- Attr#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the Attr.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @name)
+      end
+
+=begin
+    --- Attr#name()
+
+[DOM]
+alias of nodeName.
+=end
+      ## [DOM]
+      alias name nodeName
+
+=begin
+    --- Attr#value()
+
+alias of nodeValue.
+
+    --- Attr#value=(value)
+
+[DOM]
+alias of nodeValue=.
+=end
+      ## [DOM]
+      alias value nodeValue
+      alias value= nodeValue=
+
+      ## [DOM]
+      def specified; @specified; end
+      def specified=(is_specified); @specified = is_specified; end
+
+      def _checkNode(node)
+        unless node.nodeType == TEXT_NODE ||
+            node.nodeType == ENTITY_REFERENCE_NODE
+          raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+        end
+      end
+
+    end
+
+=begin
+== Class XML::DOM::Attribute
+
+alias of Attr.
+=end
+    Attribute = Attr
+
+=begin
+== Class XML::DOM::Element
+
+=== superclass
+Node
+
+=end
+    class Element<Node
+
+=begin
+=== Class Methods
+
+    --- Element.new(tag = nil, attrs = nil, *children)
+
+create a new Element.
+=end
+      ## new(tag, attrs, [child1, child2, ...]) or
+      ## new(tag, attrs, child1, child2, ...)
+      ##     tag:    String
+      ##     attrs:  Hash, Attr or Array of Attr (or nil)
+      ##     child?: String or Node
+      def initialize(tag = nil, attr = nil, *children)
+        super(*children)
+        raise "parameter error" if !tag
+        @name = tag.freeze
+        if attr.nil?
+          @attr = NamedNodeMap.new([])
+        elsif attr.is_a?(Hash)
+          nodes = []
+          attr.each do |key, value|
+            nodes.push(Attr.new(key, value))
+          end
+          @attr = NamedNodeMap.new(nodes)
+        elsif attr.is_a?(Array)
+          @attr = NamedNodeMap.new(attr)
+        elsif attr.is_a?(Attr)
+          @attr = NamedNodeMap.new([attr])
+        else
+          raise "parameter error: #{attr}"
+        end
+      end
+
+=begin
+=== Methods
+
+    --- Element#nodeType()
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        ELEMENT_NODE
+      end
+
+=begin
+    --- Element#nodeName()
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        @name
+      end
+
+=begin
+    --- Element#attributes()
+
+[DOM]
+returns the attributes of this Element.
+=end
+      ## [DOM]
+      def attributes
+        if iterator?
+          @attr.each do |key, value|
+            yield(value)
+          end if @attr
+        else
+          @attr
+        end
+      end
+
+=begin
+    --- Element#to_s()
+
+return the string representation of the Element.
+=end
+      def to_s
+        attr = ''
+        @attr.each do |a|
+          attr << ' ' + a.to_s
+        end if @attr
+        content = super
+        if content != ''
+          ret = "<#{@name}#{attr}>#{content}</#{@name}>"
+        else
+          ret = "<#{@name}#{attr}/>"
+        end
+        ret << "\n" if parentNode.nodeType == DOCUMENT_NODE
+        ret
+      end
+
+=begin
+    --- Element#dump(depth = 0)
+
+dumps the Element.
+=end
+      def dump(depth = 0)
+        attr = ''
+        @attr.each do |a|  ## self.attributes do |a|
+          attr += a.to_s + ", "
+        end if @attr
+        attr.chop!
+        attr.chop!
+        print ' ' * depth * 2
+        print "#{@name}(#{attr})\n"
+        @children.each do |child|
+          child.dump(depth + 1)
+        end if @children
+      end
+
+=begin
+    --- Element#tagName()
+
+[DOM]
+alias of nodeName.
+=end
+      ## [DOM]
+      alias tagName nodeName
+
+=begin
+    --- Element#getAttribute(name)
+
+[DOM]
+retrieves an attribute value by name.
+=end
+      ## [DOM]
+      def getAttribute(name)
+        attr = getAttributeNode(name)
+        if attr.nil?
+          ''
+        else
+          attr.nodeValue
+        end
+      end
+
+=begin
+    --- Element#setAttribute(name, value)
+
+[DOM]
+adds a new attribute.
+=end
+      ## [DOM]
+      def setAttribute(name, value)
+        if @ownerDocument
+          attr = @ownerDocument.createAttribute(name)
+          attr.appendChild(@ownerDocument.createTextNode(value))
+        else
+          attr = Attribute.new(name)
+          attr.appendChild(Text.new(value))
+        end
+        setAttributeNode(attr)
+      end
+
+=begin
+    --- Element#removeAttribute(name)
+
+[DOM]
+remove an attribute by name.
+=end
+      ## [DOM]
+      def removeAttribute(name)
+        ret = getAttributeNode(name)
+        removeAttributeNode(ret) if ret
+      end
+
+=begin
+    --- Element#getAttributeNode(name)
+
+[DOM]
+retrieves an Attr node by name.
+=end
+      ## [DOM]
+      def getAttributeNode(name)
+        @attr.getNamedItem(name)
+      end
+
+=begin
+    --- Element#setAttributeNode(newAttr)
+
+[DOM]
+adds a new attribute.
+=end
+      ## [DOM]
+      def setAttributeNode(newAttr)
+        ret = getAttributeNode(newAttr.nodeName)
+        if ret == newAttr
+          raise DOMException.new(DOMException::INUSE_ATTRIBUTE_ERR)
+        end
+        @attr.setNamedItem(newAttr)
+        ret
+      end
+
+=begin
+    --- Element#removeAttributeNode(oldAttr)
+
+[DOM]
+removes the specified attribute.
+=end
+      ## [DOM]
+      def removeAttributeNode(oldAttr)
+        ret = getAttributeNode(oldAttr.nodeName)
+        if ret.nil? || ret != oldAttr
+          raise DOMException.new(DOMException::NOT_FOUND_ERR)
+        end
+        @attr.removeNamedItem(oldAttr.nodeName)
+        ret
+      end
+
+=begin
+    --- Element#getElementsByTagName(tagname)
+
+[DOM]
+returns a NodeList of all descendant elements with given tag name.
+=end
+      ## [DOM] (but this is not "live")
+      def getElementsByTagName(tagname)
+        ret = NodeList.new
+        @children.each do |node|
+          if node.nodeType == ELEMENT_NODE
+            if tagname == '*' || node.nodeName == tagname
+              ret << node
+            end
+            ret << node.getElementsByTagName(tagname)
+          end
+        end if @children
+        ret
+      end
+
+      def _getMyLocation(parent)
+        index = 1
+        parent.childNodes do |child|
+          if child == self
+            return "child(#{index},#{@name})"
+          end
+          if child.nodeType == ELEMENT_NODE && child.nodeName == @name
+            index += 1
+          end
+        end
+        nil
+      end
+
+
+=begin
+    --- Element#normalize
+
+[DOM]
+puts all Text nodes in the full depth of the sub-tree under this
+Eelemnt.
+=end
+      ## [DOM]
+      def normalize
+        return if @children.nil?
+        old = nil
+        children = @children.to_a.dup
+        children.each do |child|
+          if !old.nil? && old.nodeType == TEXT_NODE &&
+              child.nodeType == TEXT_NODE
+            old.appendData(child.nodeValue)
+            self.removeChild(child)
+          else
+            if child.nodeType == ELEMENT_NODE
+              child.normalize
+            end
+            old = child
+          end
+        end
+      end
+
+=begin
+    --- Element#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the Element.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        attrs = []
+        @attr.each do |attr|
+          attrs.push(attr.cloneNode(true))
+        end
+        super(deep, @name, attrs)
+      end
+
+      ## get the list of nodeValues by IDs
+      ## [experimental implement]
+      def _getIDVals(ids = nil)
+        if ids.nil?
+          doc = ownerDocument
+          return [] if doc.nil?
+          ids = doc._getIDAttrs
+        end
+
+        idelem = []
+        if !ids[nodeName].nil?
+          return attributes._getValues(ids[nodeName])
+        elsif !ids['*'].nil?
+          return attributes._getValues(ids['*'])
+        end
+        return []
+      end
+
+=begin
+    --- Element#trim(preserve = false)
+
+trim extra whitespaces.
+=end
+      ## trim extra whitespaces
+      ## if attribute 'xml:space' is 'preserve',
+      ## don't trim any white spaces
+      def trim(preserve = false)
+        if !attributes['xml:space'].nil?
+          value = attributes['xml:space'].nodeValue
+          if value == 'preserve'
+            preserve = true
+          elsif value == 'default'
+            preserve = false
+          end
+        end
+        return nil if @children.nil?
+        children = @children.to_a.dup
+        children.each do |child|
+          if !preserve && (child.nodeType == TEXT_NODE ||
+                           child.nodeType == CDATA_SECTION_NODE)
+            if child.trim == ""
+              self.removeChild(child)
+            end
+          else
+            child.trim(preserve)
+          end
+        end
+        nil
+      end
+
+      def _checkNode(node)
+        unless node.nodeType == ELEMENT_NODE ||
+            node.nodeType == TEXT_NODE ||
+            node.nodeType == COMMENT_NODE ||
+            node.nodeType == PROCESSING_INSTRUCTION_NODE ||
+            node.nodeType == CDATA_SECTION_NODE ||
+            node.nodeType == ENTITY_REFERENCE_NODE
+          raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+        end
+      end
+
+    end
+
+=begin
+== Class XML::DOM::CharacterData
+
+=== superclass
+Node
+
+=end
+    class CharacterData<Node
+
+=begin
+=== Class Methods
+
+    --- CharacterData.new(text)
+
+creates a new CharacterData.
+=end
+      ## new(text)
+      ##     text: String
+      def initialize(text = nil)
+        super()
+        raise "parameter error" if !text
+        @value = text
+      end
+
+=begin
+=== Methods
+
+    --- CharacterData#data()
+
+[DOM]
+returns the character data of the node.
+=end
+      ## [DOM]
+      def data
+        @value.dup
+      end
+
+=begin
+    --- CharacterData#data=(p)
+
+[DOM]
+set the character data of the node.
+=end
+      ## [DOM]
+      def data=(p)
+          @value = p
+      end
+
+=begin
+    --- CharacterData#length()
+
+[DOM]
+returns length of this CharacterData.
+=end
+      ## [DOM]
+      def length
+        @value.length
+      end
+
+=begin
+    --- CharacterData#substringData(start, count)
+
+[DOM]
+extracts a range of data from the node.
+=end
+      ## [DOM]
+      def substringData(start, count)
+        if start < 0 || start > @value.length || count < 0
+          raise DOMException.new(DOMException::INDEX_SIZE_ERR)
+        end
+        ## if the sum of start and count > length,
+        ##  return all characters to the end of the value.
+        @value[start, count]
+      end
+
+=begin
+    --- CharacterData#appendData(str)
+
+[DOM]
+append the string to the end of the character data.
+=end
+      ## [DOM]
+      def appendData(str)
+        @value << str
+      end
+
+=begin
+    --- CharacterData#insertData(offset, str)
+
+[DOM]
+insert a string at the specified character offset.
+=end
+      ## [DOM]
+      def insertData(offset, str)
+        if offset < 0 || offset > @value.length
+          raise DOMException.new(DOMException::INDEX_SIZE_ERR)
+        end
+        @value[offset, 0] = str
+      end
+
+=begin
+    --- CharacterData#deleteData(offset, count)
+
+[DOM]
+removes a range of characters from the node.
+=end
+      ## [DOM]
+      def deleteData(offset, count)
+        if offset < 0 || offset > @value.length || count < 0
+          raise DOMException.new(DOMException::INDEX_SIZE_ERR)
+        end
+        @value[offset, count] = ''
+      end
+
+=begin
+    --- CharacterData#replaceData(offset, count, str)
+
+[DOM]
+replaces the characters starting at the specified character offset
+with specified string.
+=end
+      ## [DOM]
+      def replaceData(offset, count, str)
+        if offset < 0 || offset > @value.length || count < 0
+          raise DOMException.new(DOMException::INDEX_SIZE_ERR)
+        end
+        @value[offset, count] = str
+      end
+
+=begin
+    --- CharacterData#cloneData(deep = true)
+
+[DOM]
+returns the copy of the CharacterData.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @value.dup)
+      end
+
+=begin
+    --- Text#nodeValue
+
+[DOM]
+return nodevalue.
+
+=end
+      ## [DOM]
+      def nodeValue
+        @value
+      end
+
+=begin
+    --- CharacterData#nodeValue=(p)
+
+[DOM]
+set nodevalue as p.
+=end
+      ## [DOM]
+      def nodeValue=(p)
+        @value = p
+      end
+
+    end
+
+=begin
+== Class XML::DOM::Text
+
+=== superclass
+Node
+
+=end
+    class Text<CharacterData
+
+=begin
+=== Class Methods
+
+    --- Text.new(text)
+
+creates a new Text.
+=end
+      ## new(text)
+      ##     text: String
+      def initialize(text = nil)
+        super(text)
+      end
+
+=begin
+=== Methods
+
+    --- Text#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        TEXT_NODE
+      end
+
+=begin
+    --- Text#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        "#text"
+      end
+
+=begin
+    --- Text#to_s
+
+return the string representation of the Text.
+=end
+      def to_s
+        ret = ""
+        @value.each_byte do |code|
+          case (code)
+          when 13
+            ret << sprintf("&#x%X;", code)
+          when ?&
+            ret << "&amp;"
+          when ?<
+            ret << "&lt;"
+          when ?>
+            ret << "&gt;"
+          else
+            ret << code
+          end
+        end
+        ret
+      end
+
+=begin
+    --- Text#dump(depth = 0)
+
+dumps the Text.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print "#{@value.inspect}\n"
+      end
+
+      def _getMyLocation(parent)
+        index = 1
+        parent.childNodes do |child|
+          if child == self
+            return "child(#{index},#text)"
+          end
+          if child.nodeType == TEXT_NODE
+            index += 1
+          end
+        end
+        nil
+      end
+
+=begin
+    --- Text#splitText(offset)
+
+[DOM]
+breaks this Text node into two Text nodes at the specified offset.
+=end
+      ## [DOM]
+      def splitText(offset)
+        if offset > @value.length || offset < 0
+          raise DOMException.new(DOMException::INDEX_SIZE_ERR)
+        end
+        newText = @value[offset, @value.length]
+        newNode = Text.new(newText)
+        if !self.parentNode.nil?
+          self.parentNode.insertAfter(newNode, self)
+        end
+        @value[offset, @value.length] = ""
+        newNode
+      end
+
+=begin
+    --- Text#trim(preserve = false)
+
+trim extra whitespaces.
+=end
+      def trim(preserve = false)
+        if !preserve
+          @value.sub!(/\A\s*([\s\S]*?)\s*\Z/, "\\1")
+          return @value
+        end
+        nil
+      end
+
+    end
+
+=begin
+== Class XML::DOM::Comment
+
+=== superclass
+CharacterData
+
+=end
+    class Comment<CharacterData
+
+=begin
+=== Class Methods
+
+    --- Comment.new(text)
+
+creates a new Comment.
+=end
+      ## new(text)
+      ##     text: String
+      def initialize(text = nil)
+        super(text)
+        raise "parameter error" if !text
+      end
+
+=begin
+=== Methods
+
+    --- Comment#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        COMMENT_NODE
+      end
+
+=begin
+    --- Comment#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        "#comment"
+      end
+
+=begin
+    --- Comment#to_s
+
+returns the string  representation of the Comment.
+=end
+      def to_s
+        ret = "<!--#{@value}-->"
+        ret << "\n" if parentNode.nodeType == DOCUMENT_NODE
+        ret
+      end
+
+=begin
+    --- Comment#dump(depth  =0)
+
+dumps the Comment.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print "<!--#{@value.inspect}-->\n"
+      end
+
+      def _getMyLocation(parent)
+        index = 1
+        parent.childNodes do |child|
+          if child == self
+            return "child(#{index},#comment)"
+          end
+          if child.nodeType == COMMENT_NODE
+            index += 1
+          end
+        end
+        nil
+      end
+    end
+
+
+    ## Extended Interfaces
+
+=begin
+== Class XML::DOM::CDATASection
+
+=== superclass
+Text
+
+=end
+    class CDATASection<Text
+=begin
+=== Class Methods
+
+    --- CDATASection.new(text = nil)
+
+creates a new CDATASection.
+=end
+      def initialize(text = nil)
+        super(text)
+        raise "parameter error" if !text
+      end
+
+=begin
+=== Methods
+
+    --- CDATASection#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        CDATA_SECTION_NODE
+      end
+
+=begin
+    --- CDATASection#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        "#cdata-section"
+      end
+
+=begin
+    --- CDATASection#to_s
+
+returns the string representation of the CDATASection.
+=end
+      def to_s
+        "<![CDATA[#{@value}]]>"
+      end
+
+=begin
+    --- CDATASection#dump(depth = 0)
+
+dumps the CDATASection.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print "<![CDATA[#{@value.inspect}]]>\n"
+      end
+
+      def _getMyLocation(parent)
+        index = 1
+        parent.childNodes do |child|
+          if child == self
+            return "child(#{index},#cdata)"
+          end
+          if child.nodeType == CDATA_SECTION_NODE
+            index += 1
+          end
+        end
+        nil
+      end
+    end
+
+=begin
+== Class XML::DOM::DocumentType
+
+=== superclass
+Node
+=end
+    class DocumentType<Node
+
+=begin
+=== Class Methods
+
+    --- DocumentType.new(name, value = nil, *children)
+
+creates a new DocuemntType.
+=end
+      def initialize(name, value = nil, *children)
+        super(*children)
+        raise "parameter error" if !name
+        @name = name.freeze
+        @value = value.freeze
+      end
+
+=begin
+=== Methods
+
+    --- DocumentType#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        DOCUMENT_TYPE_NODE
+      end
+
+=begin
+    --- DocumentType#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        @name
+      end
+
+=begin
+    --- DocumentType#to_s
+
+returns the string representation of the DocumentType.
+=end
+      def to_s
+        ret = "<!DOCTYPE " + @name
+        if !@value.nil?
+          ret <<= " " + @value
+        end
+        if !@children.nil? && @children.length > 0
+          ret <<= " [\n"
+          @children.each do |child|
+            if child.nodeType == PROCESSING_INSTRUCTION_NODE ||
+                child.nodeType == COMMENT_NODE
+              ret <<= child.to_s + "\n"
+            else
+              ret <<= child.nodeValue + "\n"
+            end
+          end
+          ret <<= "]"
+        end
+        ret <<= ">"
+      end
+
+=begin
+    --- DocumentType#dump(depth = 0)
+
+dumps the DocumentType.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print "<!DOCTYPE #{@name} #{@value} [\n"
+        @children.each do |child|
+          print ' ' * (depth + 1) * 2
+          if child.nodeType == PROCESSING_INSTRUCTION_NODE ||
+              child.nodeType == COMMENT_NODE
+            child.dump
+          else
+            print child.nodeValue, "\n"
+          end
+        end if @children
+        print ' ' * depth * 2
+        print "]>\n"
+      end
+
+=begin
+    --- DocumentType#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the DocumentType.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @name, @value)
+      end
+
+      ## [DOM]
+      ## def entities; @entities; end
+      ## def notations; @notations; end
+    end
+
+=begin
+== Class XML::DOM::Notation
+
+=== superclass
+Node
+=end
+    class Notation<Node
+=begin
+=== Class Methods
+
+    --- Notation.new(name, pubid, sysid)
+
+creates a new Notation.
+=end
+      def initialize(name, pubid, sysid)
+        super()
+        @name = name.freeze
+        @pubid = pubid.freeze
+        @sysid = sysid.freeze
+      end
+
+=begin
+=== Methods
+
+    --- Notation#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        NOTATION_NODE
+      end
+
+=begin
+    --- Notation#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        @name
+      end
+
+=begin
+    --- Notation#publicId
+
+returns the publicId of the Notation.
+=end
+      def publicId
+        @pubid
+      end
+
+=begin
+    --- Notation#systemId
+
+returns the systemId of the Notation.
+=end
+      def systemId
+        @sysid
+      end
+
+=begin
+    --- Notation#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the Notation.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @name, @pubid, @sysid)
+      end
+    end
+
+=begin
+== Class XML::DOM::Entity
+
+=== superclass
+Node
+=end
+    class Entity<Node
+
+=begin
+=== Class Methods
+
+    --- Entity.new(name, pubid, sysid, notation)
+
+creates a new Entity.
+=end
+      def initialize(name, pubid, sysid, notation)
+        super()
+        @name = name.freeze
+        @pubid = pubid.freeze
+        @sysid = sysid.freeze
+        @notation = notation.freeze
+      end
+
+=begin
+=== Methods
+
+    --- Entity#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        ENTITY_NODE
+      end
+
+=begin
+    --- Entity#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        @name
+      end
+
+=begin
+    --- Entity#publicId
+
+returns the publicId of the Entity.
+=end
+      def publicId
+        @pubid
+      end
+
+=begin
+    --- Entity#systemId
+
+returns the systemId of the Entity.
+=end
+      def systemId
+        @sysid
+      end
+
+=begin
+    --- Entity#notationName
+
+returns the notationname of the Entity.
+=end
+      def notationName
+        @notation
+      end
+
+=begin
+    --- Entity#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the Entity.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @name, @pubid, @sysid, @notation)
+      end
+
+      def _checkNode(node)
+        unless node.nodeType == ELEMENT_NODE ||
+            node.nodeType == PROCESSING_INSTRUCTION_NODE ||
+            node.nodeType == COMMENT_NODE ||
+            node.nodeType == TEXT_NODE ||
+            node.nodeType == CDATA_SECTION_NODE ||
+            node.nodeType == ENTITY_REFERENCE_NODE
+          raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+        end
+      end
+
+    end
+
+=begin
+== Class XML::DOM::EntityReference
+
+=== superclass
+Node
+=end
+    class EntityReference<Node
+
+=begin
+=== Class Methods
+
+    --- EntityReference.new(name, *children)
+
+creates a new EntityReference.
+=end
+      def initialize(name, *children)
+        super(*children)
+        raise "parameter error" if !name
+        @name = name.freeze
+      end
+
+=begin
+=== Methods
+
+    --- EntityReference#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        ENTITY_REFERENCE_NODE
+      end
+
+=begin
+    --- EntityReference#nodeName
+
+[DOM]
+returns  the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        @name
+      end
+
+=begin
+    --- EntityReference#to_s
+
+returns the string representation of the EntityReference.
+=end
+      ## reference form or expanded form?
+      def to_s
+        "&#{@name};"
+      end
+
+=begin
+    --- EntityReference#dump(depth = 0)
+
+dumps the EntityReference.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print "&#{@name}{\n"
+        @children.each do |child|
+          child.dump(depth + 1)
+        end if @children
+        print ' ' * depth * 2
+        print "}\n"
+      end
+
+=begin
+    --- EntityReference#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the EntityReference.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @name)
+      end
+
+      def _checkNode(node)
+        unless node.nodeType == ELEMENT_NODE ||
+            node.nodeType == PROCESSING_INSTRUCTION_NODE ||
+            node.nodeType == COMMENT_NODE ||
+            node.nodeType == TEXT_NODE ||
+            node.nodeType == CDATA_SECTION_NODE ||
+            node.nodeType == ENTITY_REFERENCE_NODE
+          raise DOMException.new(DOMException::HIERARCHY_REQUEST_ERR)
+        end
+      end
+
+    end
+
+=begin
+== Class XML::DOM::ProcessingInstruction
+
+=== superclass
+Node
+
+=end
+    class ProcessingInstruction<Node
+
+=begin
+=== Class Methods
+
+    --- ProcessingInstruction.new(target = nil, data = nil)
+
+creates a new ProcessingInstruction.
+=end
+      ## new(target, data)
+      ##     target: String
+      ##     data: String
+      def initialize(target = nil, data = nil)
+        super()
+        raise "parameter error" if !data
+        @target = target.freeze
+        @data = data.freeze
+        @value = target.dup
+        @value << " #{data}" if data != ""
+        @value.freeze
+      end
+
+=begin
+=== Methods
+
+    --- ProcessingInstruction#nodeType
+
+[DOM]
+returns the nodeType.
+=end
+      ## [DOM]
+      def nodeType
+        PROCESSING_INSTRUCTION_NODE
+      end
+
+=begin
+    --- ProcessingInstruction#nodeName
+
+[DOM]
+returns the nodeName.
+=end
+      ## [DOM]
+      def nodeName
+        "#proccessing-instruction"
+      end
+
+=begin
+    --- ProcessingInstruction#target
+
+[DOM]
+returns the target of the ProcessingInstruction.
+=end
+      ## [DOM]
+      def target
+        @target
+      end
+
+=begin
+    --- ProcessingInstruction#target=(p)
+
+[DOM]
+set p to the target of the ProcessingInstruction.
+=end
+      ## [DOM]
+      def target=(p)
+        @target = p.freeze
+        @value = @target.dup
+        @value << " #{@data}" if @data != ""
+        @value.freeze
+      end
+
+=begin
+    --- ProcessingInstruction#data
+
+[DOM]
+return the content of the ProcessingInstruction.
+=end
+      ## [DOM]
+      def data
+        @data
+      end
+
+=begin
+    --- ProcessingInstruction#data=(p)
+
+[DOM]
+sets p to the content of the ProcessingInstruction.
+=end
+      ## [DOM]
+      def data=(p)
+        @data = p.freeze
+        @value = @target.dup
+        @value << " #{@data}" if @data != ""
+        @value.freeze
+      end
+
+=begin
+    --- ProcessingInstruction#nodeValue
+
+[DOM]
+return nodevalue.
+
+=end
+      ## [DOM]
+      def nodeValue
+        @value
+      end
+
+      ## inhibit changing value without target= or data=
+      undef nodeValue=
+
+=begin
+    --- ProcessingInstruction#to_s
+
+returns the string representation of the ProcessingInstruction.
+=end
+      def to_s
+        ret = "<?#{@value}?>"
+        ret << "\n" if parentNode.nodeType == DOCUMENT_NODE
+        ret
+      end
+
+=begin
+    --- ProcessingInstruction#dump(depth = 0)
+
+dumps the ProcessingInstruction.
+=end
+      def dump(depth = 0)
+        print ' ' * depth * 2
+        print "<?#{@value.inspect}?>\n"
+      end
+
+      def _getMyLocation(parent)
+        index = 1
+        parent.childNodes do |child|
+          if child == self
+            return "child(#{index},#pi)"
+          end
+          if child.nodeType == PROCESSING_INSTRUCTION_NODE
+            index += 1
+          end
+        end
+        nil
+      end
+
+=begin
+    --- ProcessingInstruction#cloneNode(deep = true)
+
+[DOM]
+returns the copy of the ProcessingInstruction.
+=end
+      ## [DOM]
+      def cloneNode(deep = true)
+        super(deep, @target.dup, @data.dup)
+      end
+    end
+
+  end
+
+  SimpleTree = DOM
+
+end