shalmaneser 1.2.0.rc4 → 1.2.rc5

data/lib/frprep/RegXML.rb

@@ -1,269 +0,0 @@
-# RegXML
-#
-# Katrin Erk June 2005
-
-# SalsaTigerRegXML: take control of the data structure, no underlying xml
-# representation anymore, re-generation of xml on demand
-
-class RegXML
-
-  def initialize(string, # string representing a single XML element
-                 i_am_text = false) # boolean: xml element (false) or text (true)
-
-    unless string.class == String
-      raise "First argument to RegXML.new must be string. I got #{string.class.to_s}"
-    end
-    if i_am_text
-      @s = string
-      @i_am_text = true
-    else
-      @s = string.gsub(/\n/,  " ").freeze
-      @i_am_text = false
-
-      element_test()
-      dyck_test()
-    end
-  end
-
-  def to_s()
-    return xml_readable(@s)
-  end
-  
-  def text?
-    return @i_am_text
-  end
-
-  def name()
-    if @i_am_text
-      # text
-      return nil
-
-    else
-      # xml element
-      if @s =~ /^\s*<\s*([\w-]+)[\s\/>]/
-        return $1
-      else
-        raise "Cannot parse:\n#{xml_readable(@s)}"
-      end
-    end
-  end
-
-  def attributes()
-    if @i_am_text
-      # text
-      return {}
-
-    else
-      #  xml element
-
-      # remove <element_name  from the beginning of @s,
-      # place the rest up to the first > into elt_contents:
-      # this is a string of the form
-      # - either (name=value)*
-      # - or     (name=value)*/
-      unless @s =~ /^\s*<\s*#{name()}(.*)$/
-        raise "Cannot parse:\n #{xml_readable(@s)}"
-      end
-      
-      retv = Hash.new
-      elt_contents = $1
-      
-      # repeat until only > or /> is left
-      while elt_contents !~ /^\s*\/?>/
-        
-        # shave off the next name=value pair
-        # put the rest into elt_contents
-        # make sure that if the value is quoted with ',
-        # we accept " inside the value, and vice versa.
-        unless elt_contents =~ /^\s*([\w-]+)=(['"])(.*?)\2(.*)$/
-          raise "Cannot parse:\n #{xml_readable(elt_contents)}"
-        end
-        retv[$1] = $3
-        elt_contents = $4
-      end
-
-      return retv
-    end
-  end
-
-  def children_and_text()
-    if @i_am_text
-      return []
-
-    else
-      if unary_element()
-        # <bla/>, no children
-        return []
-      end
-      
-      # @s has the form <bla...>  ... </bla>.
-      # remove <bla ...>  from the beginning of @s,
-      # place the rest up to </bla> into children_s:
-      
-      mainname = name()
-      unless @s =~ /^\s*<\s*#{mainname}(\s+[\w-]+=(["']).*?\2)*\s*>(.*?)<\/\s*#{mainname}\s*>\s*$/
-        raise "Cannot parse:\n #{xml_readable(@s)}"
-      end
-      
-      retv = Array.new
-      children_s = $3
-
-      # repeat until only whitespace is left
-      while children_s !~ /^\s*$/
-        
-      # shave off the next bit of text
-        # put the rest into children_s
-        unless children_s =~ /^\s*(.*?)(<.*$|$)/
-          $stderr.puts "Whole was:\n #{xml_readable(@s)}"
-          $stderr.puts 
-          raise "Cannot parse:\n #{xml_readable(children_s)}"
-        end
-        unless $1.strip.empty?
-          children_s = $2
-          retv << RegXML.new($1, true)
-        end
-        
-        # anything left after we've parsed text?
-        if children_s =~ /^s*$/
-          break
-        end
-
-        # shave off the next child
-        # and put the rest into children_s
-
-        # determine the next child's name, and the string index at which
-        # the element start tag ends with either / or >
-        unless children_s =~ /^\s*(<\s*([\w-]+)(\s+[\w-]+=(["']).*?\4)*\s*)/
-          $stderr.puts "Whole was:\n #{xml_readable(@s)}"
-          $stderr.puts 
-          raise "Cannot parse:\n #{xml_readable(children_s)}"
-        end
-        childname = $2
-        child = $1
-        endofelt_ix = $&.length()
-
-        
-        # and remove it
-        case children_s[endofelt_ix..-1]
-        when /^\/>(.*)$/
-          # next child is a unary element
-          children_s = $1
-          retv << RegXML.new(child + "/>")
-
-        when /^(>.*?<\s*\/\s*#{childname}\s*>)(.*)$/
-          children_s = $2
-          retv << RegXML.new(child + $1)
-
-        else
-          $stderr.puts "Whole was:\n #{xml_readable(@s)}"
-          $stderr.puts 
-          raise "Cannot parse:\n#{xml_readable(children_s)}"
-        end
-      end
-
-      return retv
-    end
-  end
-
-  def RegXML.test()
-    bla = RegXML.new("  <bla blupp='a\"b' 
-lalala=\"c\">
-  <lalala> </lalala>
-  texttext
-  <lala blupp='b'/>
-  nochtext
-  <la> <l/> </la>  
-</ bla >
-")
-    puts "name " + bla.name()
-    puts
-    puts bla.to_s()
-    puts
-    bla.attributes.each { |attr, val|
-      puts "attr " + attr + "=" + val
-    }
-    puts
-    bla.children_and_text.each { |child_obj|
-      if child_obj.text?
-        puts "da text " + child_obj.to_s
-      else
-        puts "da child " + child_obj.to_s
-      end
-    }
-    puts
-
-    puts "NEU"
-    bla = RegXML.new("  < bla blupp='a\"'/> ")
-    puts "name " + bla.name()
-    puts
-    puts bla.to_s()
-    puts
-    bla.attributes.each { |attr, val|
-      puts "attr " + attr + "=" + val
-    }
-    puts
-    bla.children_and_text.each { |child_obj|
-      if child_obj.text?
-        puts "da text " + child_obj.to_s
-      else
-        puts "da child " + child_obj.to_s
-      end
-    }
-    puts
-
-  end
-
-  ##############
-  protected
-
-  def unary_element()
-    # <bla/>
-    if @s =~ /^\s*<.*\/>\s*$/
-      return true
-    else
-      return false
-    end
-  end
-
-  def element_test()
-    # make sure we have a single XML element, either <bla/> or
-    # <bla>...</bla>
-    
-    if unary_element()
-      # <bla/>
-    elsif @s =~ /^\s*<\s*([\w-]+)\W.*?<\/\s*\1\s*>\s*$/
-      # <bla  > ... </bla>
-    else
-      raise "Cannot parse:\n #{xml_readable(@s)}"
-    end
-  end
-
-  def dyck_test()
-    # every prefix of @s must have at least as many < as >
-    opening = 0
-    closing = 0
-    @s.scan(/[<>]/) { |bracket|
-      case bracket
-      when "<"
-        opening += 1
-      when ">"
-        closing += 1
-        if closing > opening
-          raise "More closing than opening brackets in prefix of:\n #{xml_readable(@s)}"
-        end
-      end
-    }
-
-    # and in total, @s must have equally many < and >
-    unless @s.count("<") == @s.count(">")
-      raise "Inequal number of brackets in:\n #{xml_readable(@s)}"
-    end
-  end
-
-  def xml_readable(string)
-    return string.gsub(/>/, ">\n")
-  end
-end
-
-# RegXML.test()
-

data/lib/frprep/STXmlTerminalOrder.rb

@@ -1,194 +0,0 @@
-#########
-# module StringTerminalsInRightOrder
-#
-# returns the yield of a node, or a list of nodes, as a string
-# of " "-separated words
-#
-# Words are put into the right order, left to right,
-# under the assumption that their node IDs reflect that order
-#
-# Terminal nodes are assumed to have IDs ending in a number,
-# numbered from left to right
-#
-# Splitword nodes are assumed to have IDs ending in N_sM
-# for numbers N and M, where N orders terminals left to right
-# and M orders the splitword parts left to right
-#
-# If the yield of the node/the list of nodes contains all splitwords of a terminal,
-# the whole terminal is taken instead
-#
-# methods:
-# 
-# string_for_node  returns the string for the yield of a node
-#     node: a node object
-#
-# string_for_nodes returns the string for the yield of a list of nodes
-#     nodes: a list of node objects
-
-module StringTerminalsInRightOrder
-  def string_for_node(node)
-    string_for_nodes([node])
-  end
-
-  def string_for_nodes(nodes)
-    a = right_level_terminals_for_nodes(nodes)
-    a = sort_terminals_and_splitwords_left_to_right(a)
-    return node_array_to_string(a)
-  end
-
-  #####
-  private
-  
-  # right_level_terminals_for_nodes:
-  # - compute the yield for each element of 'nodes'
-  # - then consider all splitwords in the yield:
-  #   if all splitwords of a terminal are in the yield,
-  #   then use the terminal rather than its splitwords
-  def right_level_terminals_for_nodes(nodes)
-    a = nodes.map { |n| n.yield_nodes()}.flatten
-    b = Array.new
-    a.each { |n|
-      if n.is_splitword? 
-	# see if a contains all parts of this splitword
-	# if so, take into b the splitword's parent, the terminal,
-	# rather than the individual splitwords
-
-	if n.parent.nil?
-	  # splitword without a parent
-	  b << n
-	elsif b.include? n.parent or a.include? n.parent
-	  # did we already include the splitword's parent in b?
-	  # then we're done
-	else
-
-	  # check if all children of n.parent are in 'a'
-	  all_in = true
-	  n.parent.each_child { |nsibling|
-	    unless a.include? nsibling
-	      all_in = false
-	      break
-	    end
-	  }
-	  
-	  if all_in
-	    # yes, all children of n.parent are in 'a'
-	    b << n.parent
-	  else
-	    # no, some sibling of n is not in 'a'
-	    b << n
-	  end
-	end
-      elsif n.is_terminal?
-	# n is a terminal
-	b << n
-	# if n is anything but a splitword or a terminal,
-	# ignore it
-      end
-    }
-    return b.uniq
-  end
-
-  # sort_terminals_and_splitwords_left_to_right:
-  # take an array of nodes that consists of terminals and splitwords
-  # and sort them using the following comparison:
-  # - when comparing two terminals, use the 
-  #   last numbers in their respective IDs
-  # - when comparing two splitwords, their IDs end in _N_sM
-  #   for numbers N and M.
-  #   If they coincide in N, compare them by M, 
-  #   else compare them by M
-  # - when comparing a terminal and a splitword,
-  #   compare the terminal's last number to the splitword's N
-  def sort_terminals_and_splitwords_left_to_right(nodes)
-    nodes.sort { |a, b|
-      if a.is_splitword? and b.is_splitword?
-	compare_splitwords(a, b)
-      elsif a.is_terminal? and b.is_terminal?
-	compare_terminals(a, b)
-      else
-	compare_mixed(a, b)
-      end
-    }
-  end
-
-  # node_array_to_string:
-  # 'nodes' is an array of node objects, each of which offer a "word" method
-  # string their words together separated by " "
-  def node_array_to_string(nodes)
-    s = ""
-    nodes.each { |n|
-      s = s + n.word + " "
-    }
-    return s
-  end
-
-  # - when comparing two terminals, use the 
-  #   last numbers in their respective IDs
-  def compare_terminals(a, b)
-    last_i(a) <=> last_i(b)
-  end
-
-  # - when comparing two splitwords, their IDs end in _N_sM
-  #   for numbers N and M.
-  #   If they coincide in N, compare them by M, 
-  #   else compare them by M
-  def compare_splitwords(a, b)
-    if splitword_terminal_i(a) == splitword_terminal_i(b)
-      # parts of same terminal?
-      # compare parts
-      last_i(a) <=> last_i(b)
-    else
-      # not parts of same terminal?
-      # compare terminals
-      splitword_terminal_i(a) <=> splitword_terminal_i(b)
-    end
-  end
-
-  # - when comparing a terminal and a splitword,
-  #   compare the terminal's last number to the splitword's N
-  def compare_mixed(a, b)
-    if a.is_splitword? and b.is_terminal?
-      splitword_terminal_i(a) <=> last_i(b)
-
-    elsif a.is_terminal? and b.is_splitword? 
-       last_i(a) <=> splitword_terminal_i(b)
-    else
-      # not one terminal, one splitword?
-      # then what?
-      $stderr.print "SalsaTigerSentence, compare_mixed: confused by "
-      $stderr.print a.id, ",  ", b.id, "\n"
-    end
-  end
-
-  # return last number of the ID of a node
-  def last_i(n)
-    n.id =~ /(\d+)$/ # match final string of digits
-    if $1.nil? # if shouldn't happen _in principle_
-               # but we might get weird node IDs for splitwords; 
-               # so we act gracefully and catch the case where there
-               # is one final letter behind the digits
-      n.id =~ /(\d+)\w$/
-    end
-    if $1.nil? # this shouldn't ever happen
-      $stderr.print "SalsaTigerSentence, last_i: Couldn't extract digits from: "
-      $stderr.print n.id, "\n"
-      exit 1
-    end
-    return $1.to_i       # and return it as number
-  end
-
-  # assume the ID of the node includes N_sM
-  # return N
-  def splitword_terminal_i(n)
-    n.id =~ /(\d+)_s\d*/ # match string of digits before splitword ID
-    if $1.nil? # this shouldn't ever happen
-      $stderr.print "SalsaTigerSentence, splitword_terminal_i: Couldn't extract digits from: "
-      $stderr.print n.id, "\n"
-      exit 1
-    end
-    return $1.to_i       # and return it as number
-  end
-    
-end
-
-