shalmaneser 1.2.0.rc4 → 1.2.rc5

data/lib/common/config_format_element.rb

@@ -1,220 +0,0 @@
-
-##############################
-# ConfigFormatelement is an auxiliary class
-# of ConfigData.
-# It keeps track of feature patterns with variables in them
-# that can be instantiated.
-# @author Andrei Beliankou
-# 
-class ConfigFormatElement
-
-  # given a pattern and a list of variable names,
-  # analyze the pattern and remember the variable names
-  #
-  def initialize(string, # string: feature name, may include names of variables.
-		         # they are included in <>
-		 variables) # list of variable names that can occur
-    
-    @variables = variables
-
-    # pattern: this is what the 'string' is split into,
-    # an array of elements that are either fixed parts or variables.
-    # fixed part: pair [item:string, "string"]
-    # variable: pair [variable_name:string, "variable"]
-    @pattern = Array.new
-    state = "out"
-    item = ""
-
-    # analyze string,
-    # split into variables and fixed parts
-    string.split(//).each { |char|
-
-      case state
-      when "in"
-	case char
-	when "<"
-	  raise "Duplicate < in " + string
-	when ">" 
-	  unless @variables.include? item
-	    raise "Unknown variable " + item
-	  end
-	  @pattern << [item, "variable"]
-	  item = ""
-	  state = "out"
-	else
-	  item << char
-	  state = "in"
-	end
-
-      when "out"
-	case char
-	when "<"
-	  unless item.empty?
-	    @pattern << [item, "string"]
-	    item = ""
-	  end
-	  state = "in"
-	when ">"
-	  raise "Unexpected > in " + string
-	else
-	  item << char
-	  state = "out"
-	end
-
-      else
-	raise "Shouldn't be here"
-      end
-    }
-
-    # read through the whole of "string"
-    # end state has to be "out"
-    unless state == "out"
-      raise "Unclosed < in " + string
-    end
-
-    # last bit still to be recorded?
-    unless item.empty?
-      @pattern << [item, "string"]
-    end
-
-    # make regexp for matching this pattern
-    @regexp = make_regexp(@pattern)
-  end
-
-  # instantiate: given pairs of variable names and variable values,
-  # instantiate @pattern to a string in which var names are replaced
-  # by their values
-  #
-  # returns: string
-  def instantiate(var_hash) # hash variable name(string) => variable value(string)
-
-    # instantiate the pattern
-    return @pattern.map { |item, string_or_var|
-
-      case string_or_var
-      when "string"
-	item
-
-      when "variable"
-	
-	if var_hash[item].nil?
-	  raise "Missing variable instantiation: " + item
-	end
-	var_hash[item]
-
-      else
-	raise "Shouldn't be here"
-      end
-    }.join    
-  end
-
-  # match()
-  #
-  # given a string, try to match it against the @pattern
-  # while setting the variables given in 'fillers' to 
-  # the values given in that hash.
-  #
-  # returns: if the string matches, a hash variable name => value
-  #   that includes the fillers given as a parameter as well as 
-  #   values for all other variables mentioned in @pattern,
-  #   or false if no match.
-  def match(string,   # a string
-	    fillers = nil) # hash variable name(string) => value(string)
-
-    # have we been given partial info about variables?
-    if fillers
-      match = make_regexp(@pattern, fillers).match(string)
-#      $stderr.print "matching " + make_regexp(@pattern, fillers).source + 
-#	" against " + string + " "
-#      if match.nil?
-#	$stderr.puts "no"
-#      else
-#	$stderr.puts "yes"
-#      end      
-    else
-      match = @regexp.match(string)
-    end
-
-    if match.nil?
-      # no match via the regular expression
-      return false
-    end
-
-    # regular expression matched.
-    # construct return value in hash
-    # retv: variable name(string) => value(string)
-    retv = Hash.new()
-    if fillers
-      # include given fillers in retv hash
-      fillers.each_pair { |name, val| retv[name] = val }
-    end
-
-    # now put values for other variables in @pattern into retv
-    index = 1
-    @pattern.to_a.select { |item, string_or_var|
-      string_or_var == "variable"
-    }.select { |item, string_or_var|
-      fillers.nil? or 
-	fillers[item].nil?
-    }.each { |item, string_or_var|
-      # for all items on the pattern list
-      # that are variables and
-      # haven't been filled by the "fillers" list already:
-      # fill from matches
-
-      if match[index].nil?
-	raise "Match, but not enough matched elements? Strange."
-      end
-
-      if retv[item].nil?
-	retv[item] = match[index]
-      else
-	unless retv[item] == match[index]
-	  return false
-	end
-      end
-      
-      index += 1
-    }
-    
-    return retv
-  end
-
-  # used_variables
-  #
-  # returns: an array of variable names used in @pattern
-  def used_variables()
-    return @pattern.select { |item, string_or_var|
-      string_or_var == "variable"
-    }.map { |item, string_or_var| item}
-  end
-
-  ####################
-  private
-
-  # make_regexp:
-  # make regular expression from a pattern
-  # together with some variable fillers
-  #
-  # returns: Regexp object
-  def make_regexp(pattern,  # array of pairs [string, "string"] or [string, "variable"]
-		  fillers = nil) # hash variable name(string) => value(string)
-    return (Regexp.new "^" + 
-      pattern.map { |item, string_or_var|
-      case string_or_var
-      when "variable"
-	if fillers and
-	    fillers[item]
-	  Regexp.escape(fillers[item])
-	else
-	  "(.+)"
-	end
-      when "string"
-	Regexp.escape(item)
-      else
-	raise "Shouldn't be here"
-      end
-    }.join + "$")
-  end
-
-end

data/lib/common/headz.rb

@@ -1,338 +0,0 @@
-# name: Module Headz
-# auth: albu@coli.uni-sb.de
-# 
-# modified KE Sept 04:
-# changed from old Sentence pkg to new SalsaTigerSentence pkg
-#
-# modified KE April 05:
-# suppress the flood of warnings
-#
-# modified SP June 05: added some more cases; change to SalsTigerRegXML
-# 
-# 
-# INIT: REXML TIGER sentence, 
-# FUNC: syn_nodes(term/non_term) -> heads   
-#  
-# 
-# usage:
-# 
-# h = Headz.new() 
-#
-# hash = h.get_sem_head(node) # node is a SalsaTigerXmlNode obj
-# 
-# head = hash["head"]
-# prep = hash["prep"]
-# 
-# if h.complex(head)
-#   print "preposition of conjunction involved"
-# end
-
-require 'common/SalsaTigerRegXML'
-
-class Headz 
-
-  def initialize()
-    @Helpers = HeadzHelpers.new()
-    @Verbose = false #KE 13.4.05: please not that many messages!
-  end
-  
-  # head of one node
-  def get_sem_head(node)
-    gsh(node)
-  end
-  
-  # all headz of top-nodes covering fe
-  def get_fe_heads(fe)
-    if (const = fe.children())
-      const.map { |node|
-	get_sem_head(node)
-      }
-    else
-      $stderr.puts "Headz.get_sem_head: no children for FE #{fe}"
-      []
-    end
-  end
-  
-  def gsh (node)
-    if !node then 
-      if @Verbose then $stderr.puts "Headz.gsh: no input node" end
-      return {}
-
-    elsif node.is_terminal? then return Hash['head'=>node]
-
-    else
-      case node.category
-      when 'AP'
-	return gsh(@Helpers.get_dtr(node,'HD'))
-
-      when 'AVP'
-	return gsh(@Helpers.get_dtr(node,'HD'))
-      when 'CAP', 'CAVP', 'CNP', 'CPP', 'CS', 'CVP'
-	conjs = @Helpers.get_conjuncts(node)
-	head = gsh(conjs.shift)
-        if head
-          head.update(Hash["conj"=>gsh_conjs(conjs)])
-        end
-        return head
-
-      when 'NM'
-	return gsh(@Helpers.get_rightmost_dtr(node,'NMC'))
-      when 'NP'
-        nk = @Helpers.get_rightmost_dtr(node,'NK')
-        if nk
-          return gsh(nk)
-        else
-          return gsh(@Helpers.get_rightmost_dtr(node, "NN"))
-        end
-
-      when 'PN'
-	pncs = @Helpers.get_dtrs(node,'PNC')
-	head = gsh(pncs.last)
-        if head
-          head.update(Hash["pncs"=>pncs])
-        end
-        return head
-
-      when 'PP'
-	return pp(node)
-
-      when 'S'
-	return s(node)
-      when 'VROOT'
-        dtrs = @Helpers.get_dtrs(node,'--')
-
-        # discourse level node with sentence nodes below?
-        # or conjunction with sentence nodes below?
-        discourselevel_dtr = dtrs.detect { |n| n.category == "DL"}
-        co_dtr = dtrs.detect { |n| n.category == "CO" }
-        if discourselevel_dtr
-          dtrs = discourselevel_dtr.children()
-        elsif co_dtr
-          dtrs = co_dtr.children()
-        end
-
-
-        # take first sentence node
-        sent_dtr = dtrs.detect {|n| n.category =~ /^C?S/}
-        if sent_dtr
-          return gsh(sent_dtr)
-        else          
-#          $stderr.puts "headz Warning: no sentence found below VROOT! Node #{node.id()}"
-          return nil
-        end
-
-      when 'VP'
-	return vp(node)
-
-      when 'MTA'
-        return gsh(@Helpers.get_rightmost_dtr(node,'ADC'))
-
-      when 'VZ'
-	return gsh(@Helpers.get_dtr(node,'HD'))
-      else
-	if @Verbose 
-	  $stderr.puts " Headz.gsh: no rule for #{node.category}" 
-	end
-	{}
-      end
-    end
-  end
-  
-  # flatten the processed conjs to a list of (head) Hashes 
-  # containing no conj features themselves 
-  def gsh_conjs(conjs)
-    flat = Array.new
-    
-    conjs.each {|conj|
-      current = gsh(conj)
-      @Helpers.descend(current,flat)
-    }
-    
-    flat
-  end
- 
-  #####################################3
-  def pp(node)
-
-    prep = node.terminals_sorted().detect { |n| 
-      (pt = n.part_of_speech()) and 
-        (pt =~ /^APPR/ or 
-           pt =~ /^PWAV/ or
-           pt =~ /^C?PP/
-         )
-    }
-
-    if (lastnk = @Helpers.get_rightmost_dtr(node,'NK'))
-      head = gsh(lastnk)
-      if head and prep
-        head.update(Hash['prep'=>prep])      
-      end
-
-    elsif (re = @Helpers.get_dtr(node,'RE'))
-      head = gsh(re)
-      if head and prep
-        head.update(Hash['prep'=>prep])      
-      end
-    else
-      if @Verbose then $stderr.puts " pp: no rule for #{node}" end
-    end
-
-    head
-  end
-  
-  ################
-  def s(node)
-    head = @Helpers.get_dtr(node,'HD')
-    if !head
-#      $stderr.puts " s: no head for #{node}"
-      return Hash[]
-    end
-    
-    if head.outdeg() == 0
-      return gsh(head)
-    end
-
-    oc = @Helpers.get_dtr(node,'OC')
-    case head.category
-    when 'VVFIN' 
-      if svp = @Helpers.get_dtr(node,'SVP') then 
-        h = gsh(head)
-        if h
-          return h.update(Hash['svp'=>gsh(svp), 'oc'=>gsh(oc)]) 
-        else
-          return h
-        end
-      else 
-        return gsh(head)
-      end
-
-    when 'VAFIN'
-      if oc && headd = @Helpers.get_dtr(oc,'HD')
-        h = gsh(headd)
-        if h
-          return h.update(Hash['oc'=>gsh(oc)])
-        else
-          return h
-        end
-	
-      elsif pd = @Helpers.get_dtr(node,'PD') && head = @Helpers.get_dtr(pd,'HD')
-        return gsh(head)
-      
-      else 
-        if @Verbose then $stderr.puts " s: no rule for #{node}" end
-      end
-    else
-      if @Verbose then $stderr.puts " s: no rule for #{node}" end
-    end  
-  end
-  
-  ################
-  def vp(node)
-    head = gsh(@Helpers.get_dtr(node,'HD'))
-    tmp = @Verbose
-    @Verbose = false
-    newHash = Hash.new
-    ["da","oa"].each { |type| 
-      if (dtr = @Helpers.get_dtr(node,type.upcase))
-	newHash[type] = gsh(dtr)
-      end
-    }
-    @Verbose = tmp
-    if head 
-      return head.update(newHash) 
-    else 
-      return newHash 
-    end
-  end
-  
-  ################
-  # Access
-  def head(h)
-    return h['head']
-  end
-
-  def complex(h)
-    prep(h) or conj(h)
-  end
-
-  def prep(h)
-    return h['prep']
-  end
-
-  def conj(h)
-    return h['conj']
-  end
-
-
-  
-end # Class Headz
-
-
-class HeadzHelpers
-  @Verbose = true
-  
-  # Conjunction
-  
-  def get_conjuncts(node)
-    conjuncts = get_dtrs(node,'CJ')
-  end
-
-  # flatten
-  def descend(current,flat)
-    if current.nil?
-      return flat
-    end
-
-    if current.has_key?("conj") then
-      tmp = current.delete("conj")
-      flat.push current
-      tmp.each {|item|     
-	descend(item,flat)}
-    else 
-      flat.push current 
-    end
-  end
-  
-  # Zugriff
-  
-  def get_dtr(node,label)
-    if (dtrs = node.children_by_edgelabels([label]))
-      dtrs.first
-    else
-      if @Verbose then $stderr.puts " SelectHeadDtr: no #{label} dtr for #{node}" end
-      nil
-    end
-  end
-  
-  def get_dtrs(node,label)
-    if ! dtrs = node.children_by_edgelabels([label])
-      if @Verbose then $stderr.puts " SelectHeadDtr: no #{label} dtr for #{node}" end
-    else
-      dtrs
-    end
-  end
-  
-  def get_rightmost_dtr(node,label)
-    children = node.children_by_edgelabels([label])
-    if re = children.last then re
-    else 
-      if @Verbose then $stderr.puts " SelectHeadDtr: no #{label} dtrs for #{node}" end
-      nil 
-    end
-  end
-
-#   def l2h(list)
-#     h = Hash.new
-#     while (list.length > 1) do
-#       h[list.shift] = list.shift
-#     end
-#     if list.length == 1 then 
-#       $stderr.puts "l2h: odd number of elems: " + list.join(" / ")
-#     end
-#     h
-#   end
-  
-end # Class HeadzHelpers
-
-
-