mame-xmlparser 0.6.81.1

data/samples/test/featurelist.rb

@@ -0,0 +1,11 @@
+#! /usr/local/bin/ruby
+
+require 'xml/parser'
+
+if XML::Parser.respond_to?(:getFeatureList)
+  XML::Parser.getFeatureList.each do |key, value|
+    puts "#{key}:\t#{value}"
+  end
+else
+  puts "XML::Parser.getFeatureList requires expat-1.95.5 or later"
+end

data/samples/test/skippedentity.rb

@@ -0,0 +1,48 @@
+#! /usr/local/bin/ruby
+
+require 'xml/parser'
+
+p = XML::Parser.new
+
+def p.skippedEntity(entityName, is_param_ent)
+  p(["skippedEntity", entityName, is_param_ent])
+end
+
+def p.default(data)
+ p(["default", data])
+end
+
+def startElement(name, attrs)
+  p(["startElement", name, attrs])
+end
+
+def endElement(name)
+  p(["endElement", name])
+end
+
+def p.character(data)
+  p(["character", data])
+end
+
+def p.externalEntityRef(context, base, sys, pub)
+  p(["externalEntityRef", context, base, sys, pub])
+  extp = XML::Parser.new(self, context)
+  extp.parse(<<EOF)
+<!ENTITY % tttt "<!ENTITY test 'BOKE'>">
+<!ENTITY test "%tttt;">
+<!ENTITY test1 "%Tttt;">
+%aaaa;
+EOF
+  extp.done
+end
+p.setParamEntityParsing(1)
+
+p.parse(<<EOF)
+<!DOCTYPE test SYSTEM "ext.dtd" [
+<!--ENTITY test "HOGE"-->
+%TTTT;
+]>
+<test>
+  &test;
+</test>
+EOF

data/samples/test/useforeigndtd.rb

@@ -0,0 +1,42 @@
+#! /usr/local/bin/ruby
+
+require 'xml/parser'
+
+
+XML1=<<EOF
+<!--DOCTYPE test SYSTEM "hoge.dtd" [
+<!ENTITY a "internal">
+]-->
+<test>&a;</test>
+EOF
+
+XML2=<<EOF
+<!ENTITY a "external">
+EOF
+
+p = XML::Parser.new
+if p.respond_to?(:useForeignDTD)
+  p p.useForeignDTD(ARGV[0].to_i)
+else
+  puts "XML::Parser#useForeignDTD requires expat-1.95.5 or later"
+end
+
+p.setParamEntityParsing(1)
+def p.startDoctypeDecl(name, sys, pub, internal)
+  p(["startDoctypeDecl", name, sys, pub, internal])
+end
+def p.endDoctypeDecl()
+  p(["endDoctypeDecl"])
+end
+def p.externalEntityRef(context, base, sys, pub)
+  p(["externalEntityRef", context, base, sys, pub])
+  extp = XML::Parser.new(self, context)
+  extp.parse(XML2)
+  extp.done
+end
+
+def p.character(data)
+  p data
+end
+
+p.parse(XML1)

data/samples/treetest.rb

@@ -0,0 +1,14 @@
+#! /usr/local/bin/ruby -Ke
+
+require "xml/dom/core"
+include XML::DOM
+
+tree = Document.new(ProcessingInstruction.new("xml",
+                                         "version='1.0' encoding='EUC-JP'"),
+                    Comment.new("������"),
+                    Element.new("Test", [
+                                  Attr.new('attr1', "°��1"),
+                                  Attr.new('attr2', "°��2")],
+                                Element.new("para", nil, "����ˤ���")))
+print tree.to_s, "\n"
+tree.dump

data/samples/visitor.rb

@@ -0,0 +1,29 @@
+#! /usr/local/bin/ruby
+
+## Visitor sample
+## 1998 by yoshidam
+##
+## The sample for Ruby style visitor.
+## You can use "each" method as the iterator to visit all nodes,
+## and can also use the other Enumerable module methods.
+
+require 'xml/dom/builder'
+require 'xml/dom/visitor'
+require 'xml/encoding-ja'
+include XML::Encoding_ja
+
+p = XML::SimpleTreeBuilder.new(1)
+tree = p.parse($<.read)
+tree.documentElement.normalize
+
+tree.each_with_index do |node, index|
+  print format("%03d: ", index)
+  case node.nodeType
+  when XML::SimpleTree::Node::ELEMENT_NODE
+    print "<#{node.nodeName}>\n"
+  when XML::SimpleTree::Node::DOCUMENT_NODE
+    print "#DOCUMENT\n"
+  else
+    print "#{Uconv.u8toeuc(node.to_s).inspect}\n"
+  end
+end

data/samples/visitortest.rb

@@ -0,0 +1,36 @@
+#! /usr/local/bin/ruby
+
+## Visitor test
+## 1998 by yoshidam
+##
+## This sample comes from Ken MacLeod's sample of XML-Grove-0.05
+## Copyright (C) 1998 Ken MacLeod
+
+require 'xml/dom/builder'
+require 'xml/dom/visitor'
+
+class MyVisitor<XML::DOM::Visitor
+  def visit_Element(element, context, *rest)
+    context.push(element.nodeName)
+    attrs = []
+    element.attributes.each do |attr|
+      attrs.push(attr.to_s)
+    end
+    print "#{context.join(' ')} \\\\ (#{attrs.join(' ')})\n"
+    super(element, context, *rest)
+    print "#{context.join(' ')} //\n"
+    context.pop
+  end
+
+  def visit_ProcessingInstruction(pi, context, *rest)
+    print "#{context.join(' ')} ?? #{pi.target}(#{pi.data})\n"
+  end
+
+  def visit_Text(text, context, *rest)
+    value = text.nodeValue
+    print "#{context.join(' ')} || #{value.dump}\n"
+  end
+end
+
+doc = XML::DOM::Builder.new.parse($<.read)
+doc.accept(MyVisitor.new, [])

data/samples/writer.rb

@@ -0,0 +1,43 @@
+#! /usr/local/bin/ruby
+
+## Visitor test
+## 1998 by yoshidam
+##
+
+require 'xml/dom/builder'
+require 'xml/dom/visitor'
+
+class Writer
+  def visit_Document(document)
+    document.children_accept(self)
+  end
+
+  def visit_Element(element)
+    attrs = ""
+    element.attributes.each do |attr|
+      attrs += " " + attr.to_s
+    end
+    print "<#{element.nodeName}#{attrs}>"
+    element.children_accept(self);
+    print "</#{element.nodeName}>"
+  end
+
+  def visit_ProcessingInstruction(pi)
+    print "<?" + pi.nodeValue + "?>"
+  end
+
+  def visit_Text(text)
+    print text.nodeValue
+  end
+
+  def visit_Comment(comment)
+    print "<!--" + comment.nodeValue + "-->"
+  end
+
+  def visit_CDATASection(cdata)
+    print "<![CDATA[" + cdata.nodeValue + "]]>"
+  end
+end
+
+doc = XML::DOM::Builder.new.parse($<.read)
+doc.accept(Writer.new)

data/samples/xmlcheck.rb

@@ -0,0 +1,40 @@
+#! /usr/local/bin/ruby
+
+## XML checker
+## 1999 by yoshidam
+##
+## Sep 14, 1999 yoshidam: unknownEncoding ���٥���б�
+## Jul 26, 1998 yoshidam: Shift_JIS, ISO-2022-JP �б�
+##                        ���顼ɽ�������� SP �������ѹ�
+
+require 'xml/parser'
+require 'nkf'
+
+class XMLRetry<Exception; end
+
+xml = $<.read
+
+parser = XML::Parser.new
+def parser.unknownEncoding(e)
+  raise XMLRetry, e
+end
+
+begin
+  parser.parse(xml)
+  print "well-formed\n"
+  exit 0
+rescue XMLRetry
+  newencoding = nil
+  e = $!.to_s
+  if e =~ /^iso-2022-jp$/i
+    xml = NKF.nkf("-Je", xml)
+    newencoding = "EUC-JP"
+  end
+  parser = XML::Parser.new(newencoding)
+  retry
+rescue XML::Parser::Error
+  line = parser.line
+  column = parser.column
+  print "#{$0}:#{$<.filename}:#{line}:#{column}:E: #{$!}\n"
+  exit 1
+end

data/samples/xmlcomments.rb

@@ -0,0 +1,30 @@
+#! /usr/local/bin/ruby
+
+## Ruby version of xmlcomments
+## 1998 by yoshidam
+##
+## This sample comes from Clark Cooper's sample of  Perl extension
+## module XML::Parser.
+##   (http://www.netheaven.com/~coopercc/xmlparser/samples/xmlcomments)
+
+require 'xml/parser'
+
+$count = 0
+
+p = XML::Parser.new
+
+def p.character(data)
+end
+
+def p.default(data)
+  if data =~ /^<!--/
+    line = self.line
+    data.gsub!(/\n/, "\n\t");
+    print "#{line}:\t#{data}\n";
+    $count += 1
+  end
+end
+
+p.parse($<)
+
+print "Found #{$count} comments.\n"

data/samples/xmlevent.rb

@@ -0,0 +1,76 @@
+#! /usr/local/bin/ruby
+
+require 'xml/parser'
+require 'nkf'
+#require 'uconv'
+
+class XMLRetry<Exception; end
+
+class SampleParser<XML::Parser
+  def startElement(name, attr)
+    line = self.line
+    column = self.column
+    byteIndex = self.byteIndex
+    print "L#{line}, #{column}, #{byteIndex}\n"
+    attr.each do |key, value|
+#      print Uconv.u8toeuc("A#{key} CDATA #{value}\n")
+      print "A#{key} CDATA #{value}\n"
+    end
+#    print Uconv.u8toeuc("(#{name}\n")
+    print "(#{name}\n"
+    self.defaultCurrent
+  end
+  private :startElement
+
+  def endElement(name)
+#    print Uconv.u8toeuc(")#{name}\n")
+    print ")#{name}\n"
+  end 
+  private :endElement
+
+  def character(data)
+    data.gsub!("\n", "\\n")
+#    print Uconv.u8toeuc("-#{data}\n")
+    print "-#{data}\n"
+  end
+  private :character
+
+  def processingInstruction(target, data)
+    data.gsub!("\n", "\\n")
+#    print Uconv.u8toeuc("?#{target} #{data}\n")
+    print "?#{target} #{data}\n"
+  end
+  private :processingInstruction
+
+  def default(data)
+    return if data =~ /^<\?xml /
+    data.gsub!("\n", "\\n")
+#    print Uconv.u8toeuc("//#{data}\n")
+    print "//#{data}\n"
+  end
+  private :default
+
+end
+
+xml = $<.read
+
+parser = SampleParser.new
+def parser.unknownEncoding(e)
+  raise XMLRetry, e
+end
+
+begin
+  parser.parse(xml)
+rescue XMLRetry
+  newencoding = nil
+  e = $!.to_s
+  if e =~ /^iso-2022-jp$/i
+    xml = NKF.nkf("-Je", xml)
+    newencoding = "EUC-JP"
+  end
+  parser = SampleParser.new(newencoding)
+  retry
+rescue XML::Parser::Error
+  line = parser.line
+  print "Parse error(#{line}): #{$!}\n"
+end

data/samples/xmliter.rb

@@ -0,0 +1,57 @@
+#! /usr/local/bin/ruby
+
+require 'xml/parser'
+require 'nkf'
+#require 'uconv'
+
+class XMLRetry<Exception; end
+
+xml = $<.read
+parser = XML::Parser.new
+def parser.default; end
+def parser.unknownEncoding(e)
+  raise XMLRetry, e
+end
+
+begin
+  parser.parse(xml) do |type, name, data|
+    case type
+    when XML::Parser::START_ELEM
+      data.each do |key, value|
+#        print Uconv.u8toeuc("A#{key} CDATA #{value}\n")
+        print "A#{key} CDATA #{value}\n"
+      end
+#      print Uconv.u8toeuc("(#{name}\n")
+      print "(#{name}\n"
+    when XML::Parser::END_ELEM
+#      print Uconv.u8toeuc(")#{name}\n")
+      print ")#{name}\n"
+    when XML::Parser::CDATA
+      data.gsub!("\n", "\\n")
+#      print Uconv.u8toeuc("-#{data}\n")
+      print "-#{data}\n"
+    when XML::Parser::PI
+      data.gsub!("\n", "\\n")
+#      print Uconv.u8toeuc("?#{name} #{data}\n")
+      print "?#{name} #{data}\n"
+    else
+      next if data =~ /^<\?xml /
+      data.gsub!("\n", "\\n")
+#      print Uconv.u8toeuc("//#{data}\n")
+      print "//#{data}\n"
+    end
+  end
+rescue XMLRetry
+  newencoding = nil
+  e = $!.to_s
+  if e =~ /^iso-2022-jp$/i
+    xml = NKF.nkf("-Je", xml)
+    newencoding = "EUC-JP"
+  end
+  parser = XML::Parser.new(newencoding)
+  def parser.default; end
+  retry
+rescue XML::Parser::Error
+  line = parser.line
+  print "Parse error(#{line}): #{$!}\n"
+end

data/samples/xmlstats.rb

@@ -0,0 +1,167 @@
+#! /usr/local/bin/ruby
+
+## Ruby version of xmlstats
+## 1999 by yoshidam
+##
+## This sample comes from Clark Cooper's sample of Perl extension
+## module XML::Parser.
+##   (http://www.netheaven.com/~coopercc/xmlparser/samples/xmlstats)
+##
+## Try XML benchmark (http://www.xml.com/xml/pub/Benchmark/article.html)!
+## Ruby is probably faster than Perl.
+
+require 'xml/parser'
+begin
+  require 'mbstring'
+rescue LoadError
+  class String
+    def mblength
+      cnt = self.length
+      self.scan(/([\300-\367])/n) do |c|
+        if c[0] < "\340"
+          cnt -= 1
+        elsif c[0] < "\360"
+          cnt -= 2
+        else
+          cnt -= 3
+        end
+      end
+      cnt
+    end
+  end
+end
+
+$KCODE="UTF8"
+
+class Elinfo
+  attr :name
+  attr :count, true
+  attr :minlev, true
+  attr :seen, true
+  attr :chars, true
+  attr :empty, true
+  attr :ptab, true
+  attr :ktab, true
+  attr :atab, true
+
+  def initialize(name, seen)
+    @name = name
+    @count = 0
+    @minlev = nil
+    @seen = seen
+    @chars = 0
+    @empty = true
+    @ptab = {}
+    @ptab.default = 0
+    @ktab = {}
+    @ktab.default = 0
+    @atab = {}
+    @atab.default = 0
+  end
+
+  def <=>(b)
+    ret = self.minlev - b.minlev
+    if ret == 0
+      return self.seen - b.seen
+    end
+    ret
+  end
+end
+
+class StatParser < XML::Parser
+  def initialize(*rest)
+    @elements = {}
+    @seen = 0
+    @root = nil
+    @context = []
+  end
+
+  def startElement(name, attr)
+    if (elinf = @elements[name]).nil?
+      @elements[name] = elinf = Elinfo.new(name, @seen += 1)
+    end
+    elinf.count += 1
+
+    pinf = @context[-1]
+    if pinf
+      elinf.ptab[pinf.name] += 1
+      pinf.ktab[name] += 1
+      pinf.empty = false
+    else
+      @root = name
+    end
+
+    attr.each_key do |key|
+      elinf.atab[key] += 1
+    end
+    @context.push(elinf)
+  end
+
+  def endElement(name)
+    @context.pop
+  end
+
+  def character(data)
+    inf = @context[-1]
+    inf.empty = false
+    inf.chars += data.mblength
+  end
+
+  def set_minlev(name, level)
+    name = @root if name.nil?
+    inf = @elements[name]
+    if inf.minlev.nil? or inf.minlev > level
+      newlev = level + 1
+      inf.minlev = level
+      inf.ktab.each_key do |key|
+        set_minlev(key, newlev)
+      end
+    end
+  end
+
+  def elinf_sort
+    @elements.sort { |(a_name, a_inf), (b_name, b_inf)|
+      a_inf <=> b_inf
+    }.each do |name, inf|
+      yield(name, inf)
+    end
+  end
+end
+
+def showtab(label, tab, dosum)
+  if tab.length == 0; return end
+  print "\n   ", label, ":\n"
+  sum = 0
+
+  tab.sort.each do |name, cnt|
+    sum = sum + cnt
+    printf("      %-16s      %5d\n", name, cnt)
+  end
+  if dosum and tab.length > 1
+    print "                            =====\n"
+    printf("                            %5d\n", sum);
+  end
+end
+
+p = StatParser.new
+begin
+  p.parse($<.read)
+rescue XML::ParserError
+  print "#{$0}: #{$!} (in line #{p.line})\n"
+  exit 1
+end
+
+p.set_minlev(nil, 0)
+p.elinf_sort do |name, elinf|
+  print "\n================\n"
+  print name, ": ", elinf.count, "\n"
+  if elinf.chars > 0
+    print "Had ", elinf.chars, " bytes of character data\n"
+  end
+  if elinf.empty
+    print "Always empty\n"
+  end
+  showtab("Parents", elinf.ptab, false)
+  showtab("Children", elinf.ktab, true)
+  showtab("Attributes", elinf.atab, false)
+end