shalmaneser-prep 1.2.0.rc4

data/lib/frprep/Graph.rb

@@ -0,0 +1,345 @@
+# GraphNode: describes one node in a graph.
+#
+# A node may have an arbitrary number of parents (sources of incoming edges)
+# and an arbitrary number of children (targets of outgoing edges)
+#
+# All edges are labeled and directed
+#
+# The add_parent, add_child, remove_parent, remove_child methods
+# take care of both ends of an edge 
+# (i.e. n1.add_child(n2, label) also adds n1 as parent of n2 with edge label 'label'
+#
+# It is possible to create a 'pointer' rather than an edge:
+#     n1.add_child(n2, label, pointer_insteadof_edge => true) 
+# will create an edge from n1 to n2 labeled 'label' that is
+# listed under the outgoing edges of n1, but not among
+# the incoming edges of n2
+# The same option is available for add_parent, remove_parent, remove_child.
+
+class GraphNode
+
+  def initialize(id)
+    @id = id
+    @children = Array.new
+    @parents = Array.new
+    @features = Hash.new
+  end
+
+  # for Marshalling: 
+  # Dump just IDs instead of actual nodes from Parents and Children lists.
+  # Otherwise the Marshaller will go crazy following
+  # all the links to objects mentioned.
+  # After loading: replace IDs by actual objects with a little help
+  # from the caller.
+
+  def _dump(depth)
+    @id.to_s +
+      "QQSEPVALUESQQ" +
+      Marshal.dump(@features) +
+      "QQSEPVALUESQQ" +
+      @children.map { |label_child| 
+        label_child[0] + "QQSEPQQ" + label_child[1].id()
+      }.join("QQPAIRQQ") +
+      "QQSEPVALUESQQ" +
+      @parents.map { |label_parent|
+        label_parent[0] + "QQSEPQQ" + label_parent[1].id()
+    }.join("QQPAIRQQ")      
+  end
+
+  def GraphNode._load(string)
+    id, features_s, children_s, parents_s =
+      string.split("QQSEPVALUESQQ")
+
+    result = GraphNode.new(id)
+    result.fill_from_pickle(string)
+    return result
+  end
+
+  def fill_from_pickle(string)
+    id, features_s, children_s, parents_s =
+      string.split("QQSEPVALUESQQ")
+
+    @features = Marshal.load(features_s)
+
+    if children_s.nil? or children_s.empty?
+      @children = []
+    else
+      @children = children_s.split("QQPAIRQQ").map { |pair|
+	pair.split("QQSEPQQ")
+      }
+    end
+
+    if parents_s.nil? or parents_s.empty?
+      @parents = []
+    else
+      @parents = parents_s.split("QQPAIRQQ").map { |pair|
+	pair.split("QQSEPQQ")
+      }
+    end
+  end
+
+  def recover_from_dump(node_by_id)
+    @children = @children.map { |label_id| [label_id[0], node_by_id.call(label_id[1])] }
+    @parents = @parents.map { |label_id| [label_id[0], node_by_id.call(label_id[1])] }
+  end
+
+  # ID-related things
+
+  def ==(other_node)
+    unless other_node.kind_of? GraphNode
+      return false
+    end
+    @id == other_node.id()
+  end
+
+  def id()
+    return @id
+  end
+
+  def chid(newid)
+    @id = newid
+  end
+
+  # setting and retrieving features
+
+  def get_f(feature)
+    return @features[feature]
+  end
+
+  def set_f(feature, value)
+    @features[feature] = value
+  end
+
+  def add_f(feature, value)
+    unless @features[feature].nil?
+      raise "Feature " + feature + "already set."
+    end
+    set_f(feature, value)
+  end
+  
+  # ancestors 
+
+  def parents()
+    return @parents.map { |label_parent| 
+      label_parent[1] }
+  end
+  
+  def parent_labels()
+    return @parents.map { |label_parent| label_parent[0] }
+  end
+
+  def parent_label(parent)
+    @parents.each { |label_parent|
+      if label_parent[1] == parent 
+	return label_parent[0]
+      end
+    }
+    return nil
+  end
+
+  def parents_with_edgelabel()
+    return @parents
+  end
+
+  def each_parent()
+    @parents.each { |label_parent| yield label_parent[1] }
+  end
+
+  def each_parent_with_edgelabel()
+    @parents.each { |label_parent| yield label_parent}
+  end
+
+  def parents_by_edgelabels(labels)
+    return @parents.select { |label_parent|
+      labels.include? label_parent[0]
+    }.map { |label_parent|
+      label_parent[1]
+    }
+  end
+
+  def add_parent(parent, edgelabel, varhash={})
+    @parents << [edgelabel, parent]
+
+    # and vice versa: add self as child to parent
+    unless varhash["pointer_insteadof_edge"]
+      unless parent.children_with_edgelabel().include? [edgelabel, self]
+        parent.add_child(self, edgelabel)
+      end
+    end
+  end
+
+  def remove_parent(parent, edgelabel, varhash={})
+    @parents = @parents.reject { |label_child| 
+      label_child.first == edgelabel and
+	label_child.last == parent
+    }
+
+    # and vice versa: remove self as child from parent
+    unless varhash["pointer_insteadof_edge"]
+      if parent.children_with_edgelabel().include? [edgelabel, self]
+        parent.remove_child(self, edgelabel)
+      end
+    end
+  end
+
+  def indeg()
+    return @parents.length()
+  end
+
+  def ancestors
+    return ancestors_noduplicates([], [])
+  end
+
+  def ancestors_by_edgelabels(labels)
+    return ancestors_noduplicates([], labels)
+  end
+
+  # descendants
+
+  def children()
+    return @children.map { |label_child| label_child[1] }
+  end
+
+  def child_labels()
+    return @children.map { |label_child| label_child[0] }
+  end
+
+  def child_label(child)
+    @children.each { |label_child|
+      if label_child[1] == child
+	return label_child[0]
+      end
+    }
+    return nil
+  end
+
+  def children_with_edgelabel()
+    return @children
+  end
+
+  def each_child()
+    @children.each { |label_child| yield label_child[1]}
+  end
+
+  def each_child_with_edgelabel()
+    @children.each { |label_child| yield label_child } 
+  end
+
+  def children_by_edgelabels(labels)
+    return @children.select { |label_child|
+      labels.include? label_child[0] 
+    }.map { |label_child|
+      label_child[1]
+    }
+  end
+
+  def add_child(child, edgelabel, varhash={})
+    @children << [edgelabel, child]
+
+    # and vice versa: add self as parent to child
+    unless varhash["pointer_insteadof_edge"]
+      unless child.parents_with_edgelabel().include? [edgelabel, self]
+        child.add_parent(self, edgelabel)
+      end
+    end
+  end
+
+  def remove_child(child, edgelabel, varhash={})
+    @children = @children.reject { |label_child| 
+      label_child.first == edgelabel and
+	label_child.last == child
+    }
+
+    # and vice versa: remove self as parent from child
+    unless varhash["pointer_insteadof_edge"]
+      if child.parents_with_edgelabel().include? [edgelabel, self]
+        child.remove_parent(self, edgelabel)
+      end
+    end
+  end
+
+  def change_child_label(child, oldlabel, newlabel, varhash={})
+    if @children.include? [oldlabel, child]
+      remove_child(child,oldlabel, varhash)
+      add_child(child, newlabel, varhash)
+    end
+  end
+
+  def remove_all_children(varhash={})
+    each_child_with_edgelabel { |label, child|
+      remove_child(child, label, varhash)
+    }
+  end
+
+  def set_children(list, varhash={})
+    #### CAUTION: set_children must be called with an "internal format" list of parents:
+    ####          instead of using [node, edgelabel], use [edgelabel, node]
+    remove_all_children(varhash)
+
+    @children = list
+  end
+
+  def outdeg()
+    return @children.length()
+  end
+
+  def yield_nodes()
+    arr = Array.new
+    if outdeg() == 0
+      arr << self
+    end
+    each_child { |c| 
+      if c.outdeg() == 0
+	arr << c
+      else
+	arr.concat c.yield_nodes
+      end
+    }
+    return arr
+  end
+
+  def descendants
+    return descendants_noduplicates([], [])
+  end
+
+  def descendants_by_edgelabels(labels)
+    return descendants_noduplicates([], labels)
+  end
+
+  protected
+
+  def descendants_noduplicates(nodes, labels)
+    each_child_with_edgelabel() { |l_c|
+      if labels.empty? or labels.include? l_c[0]
+	unless nodes.include? l_c[1]
+	  nodes = l_c[1].descendants_noduplicates(nodes << l_c[1], labels)
+	end
+      end
+    }
+    return nodes
+  end
+  
+  def ancestors_noduplicates(nodes, labels)
+    each_parent_with_edgelabel() { |l_p|
+      if labels.empty? or labels.include? l_p[0]
+	unless nodes.include? l_p[1]
+	  nodes = l_p[1].ancestors_noduplicates(nodes << l_p[1], labels)
+	end
+      end
+    }
+    return nodes
+  end
+
+  #### CAUTION: set_parents must be called with an "internal format" list of parents:
+  ####          instead of using [node, edgelabel], use [edgelabel, node]
+
+  def set_parents(list, varhash={})
+    each_parent_with_edgelabel { |label, parent|
+      remove_parent(parent, label, varhash)
+    }
+
+    list.each { |label, parent|
+      add_parent(label, parent)
+    }
+  end
+end

data/lib/frprep/MiniparInterface.rb

@@ -0,0 +1,1388 @@
+####
+# KE Nov 2005
+#
+# Interface for use of the Minipar parser:
+# parsing with Salsa/Tiger XML output format,
+# class for interpreting the Salsa/Tiger XML data structures
+
+require 'tempfile'
+require 'common/TabFormat'
+require 'common/SalsaTigerRegXML'
+require 'common/SalsaTigerXMLHelper'
+
+require 'common/AbstractSynInterface'
+
+#########################################
+# MiniparSentence class
+#
+# analyze one minipar output sentence,
+# provide access
+#
+# hash representation of a node:
+# keys are
+#   index, word , lemma, pos, parent_index, edgelabel, governing_lemma, antecedent_index
+#
+# other access: as SalsaTigerSentence object
+class MiniparSentence
+
+  ########
+  def initialize(sentence) # array:string, one minipar node per string
+    @nodes = Array.new
+
+    sentence.each { |line_string|
+      @nodes << analyze_line(line_string)
+    }
+    # sort nodes by line index -- sometimes nodes with lower index are mentioned later in the sentence
+    @nodes.sort! { |a, b| a["index"].to_i <=> b["index"].to_i }
+
+    @tabsent = nil
+    # nodehash_mapping: hash tabindex -> array:nodehashes
+    @nodehash_mapping = nil
+  end
+
+  #####
+  def nodes()
+    return @nodes.clone.freeze()
+  end
+
+  #####3
+  # stxml:
+  #
+  # make SalsaTigerSentence object from this sentence,
+  # one node per minipar node.
+  # if it is a nonterminal, duplicate it as a terminal
+  #
+  # return: pair [SalsaTigerSentence, mapping]:
+  # if we have a tab sent, mapping is a mapping from tab word indices to SynNode objects
+  # of the minipar sentence representation
+  def stxml(sentence_id)
+    return salsatigerxml_output(sentence_id)
+  end
+
+  #####
+  # set tabsent:
+  # set this tab format sentence, which has entries "word", "lineno", 
+  # as the sentence matching this minipar output sentence.
+  #
+  # On success, remember the tab sentence as well as the mapping
+  # between fntab sentence indices and minipar node hash indices
+  #
+  # returns true on success
+  #         or false if matching failed
+
+  def set_tabsent(tabsent, # TabFileFormat object
+		  sloppy = true) # not nil or false: allow sloppy match
+
+    # empty minipar sentence? then no match
+    if @nodes.empty? 
+      return false
+    end
+
+    # tabwords: array:string
+    tabwords = Array.new
+    tabsent.each_line_parsed { |l| tabwords << l.get("word") }
+
+    # main data structure: a chart of partial mappings fn_index -> minipar_index
+    # represented as an array of partial mappings
+    # each partial mapping is an array of triples [fn_index, min_index, "full"|"partial"]
+    old_chart = Array.new
+
+    # enter data for 1st minipar node into the chart
+    first_node_no = 0
+    while @nodes[first_node_no]["word"].nil?
+      first_node_no += 1
+    end
+    old_chart = fnw_minw_match(tabwords, @nodes[first_node_no]["word"]).map { |fnw_index, match_how|
+      [[fnw_index, first_node_no, match_how]]
+    }
+    
+    if old_chart.empty?
+      # unmatched single word in minipar sentence
+      return false
+    end
+
+    # enter data for the rest of the minipar nodes into the chart
+    (first_node_no + 1).upto(@nodes.length - 1) { |node_no|
+      unless @nodes[node_no]["word"]
+        # minipar node with empty word, skip
+        next
+      end
+      new_chart = Array.new
+
+      # each partial mapping found up to now:
+      # try to extend it, record results in new_chart
+      old_chart.each { |partial_mapping|
+        prev_fnw_index, prev_mw_index, match_how = partial_mapping.last
+        
+        # where do we start looking in tabwords? same word as before, or advance one?
+        case match_how
+        when "full"
+          fnw_index = prev_fnw_index + 1
+        when "partial"
+          fnw_index = prev_fnw_index
+        else
+          raise "Shouldn't be here"
+        end
+
+        fnw_minw_match(tabwords[fnw_index..tabwords.length()-1], 
+                       @nodes[node_no]["word"]).each { |match_offset, match_how|
+          new_chart.push partial_mapping + [[fnw_index + match_offset, node_no, match_how]]
+        }
+      }
+
+      if new_chart.empty?
+        # no partial mappings found that would work up to this minipar node:
+        # matching failed
+        return false
+      end
+
+      old_chart = new_chart
+    }
+
+#     $stderr.puts "Msent: "+ @nodes.map { |n| n["word"]}.join(" ")
+#     $stderr.puts "Tsent: "+ tabwords.join(" ")
+#     $stderr.puts "Mappings: "
+#     old_chart.each { |mapping|
+#       mapping.each { |fnw_ix, mnode_no, match_how|
+#         $stderr.print tabwords[fnw_ix] + ":" + @nodes[mnode_no]["word"] + ":" + match_how + " "
+#       }
+#       $stderr.puts
+#     }
+#     $stderr.puts "any key"
+#     $stdin.gets()
+
+    # filter chart: if some fntab sent words are only matched partially, discard
+    if sloppy
+      chart = old_chart
+    else
+      chart = old_chart.select { |mapping|
+
+	mapping_ok = true
+	tabwords.each_with_index { |fnw, fnw_index|
+	  
+	  tuples = mapping.select { |other_fnw_index, mnode_no, match_how| other_fnw_index == fnw_index }
+	  
+	  unless tuples.empty?        
+	    word = tuples.map { |fnw_index, mnode_no, match_how| @nodes[mnode_no]["word"] }.join()
+        
+	    unless word == fnw
+	      mapping_ok = false
+	      break
+	    end
+	  end
+	}
+	mapping_ok      
+      }
+    end
+
+    if chart.empty?
+      return false
+    elsif chart.length() > 1
+#      $stderr.puts "Found more than one mapping for sentence:"
+#      $stderr.puts "Msent: " + @nodes.map { |n| n["word"]}.join(" ")
+#      $stderr.puts "Tsent: "+ tabwords.join(" ")
+#      $stderr.puts
+    end
+
+    # success: found mapping
+    # nodehash_mapping: hash tab sentence word index -> array: SynNodes
+    @tabsent = tabsent
+    @nodehash_mapping = Hash.new
+    chart.first.each { |tabindex, mindex, match_how|
+      unless @nodehash_mapping[tabindex]
+        @nodehash_mapping[tabindex] = Array.new
+      end
+      @nodehash_mapping[tabindex] << @nodes[mindex]
+    }
+    return true
+  end
+
+  # nodehash_mapping: hash tabindex -> array:nodehashes
+  def nodehash_mapping()
+    if @nodehash_mapping
+      return @nodehash_mapping.clone.freeze()
+    else
+      return nil
+    end
+  end
+
+
+  ################################################3
+  ################################################3
+  private
+
+  ###########
+  # analyze one line of the sentence array.
+  # 
+  # examples of possible entries:
+  # E1      (()     fin C   E4      )
+  # 3       (them   ~ N     2       obj     (gov call))
+  # E5      (()     they N  2       subj    (gov call)      (antecedent 1))
+  def analyze_line(line)
+    retv = Hash.new()
+
+    unless line =~ /^(\w+)\t\((.+)\)\s*$/
+      raise "Cannot parse line: #{line}"
+    end
+
+    # line structure: 
+    # index ( node descr )
+    retv["index"] = $1
+
+    descr = $2
+    word, lemma_pos, parentindex, edgelabel, governor, antecedent = descr.split("\t")
+
+    # word
+    if word
+      if word =~ /^['"](.+)['"]$/
+        # quoted? remove quotes
+        word = $1
+      end
+      unless word == "()"
+        retv["word"] = word
+      end
+    end
+
+    # lemma, POS
+    if lemma_pos
+      lemma_pos.strip!
+      if lemma_pos == "U"
+        # neither lemma nor POS for this node
+      else
+        # we have both lemma and POS
+        
+        if lemma_pos =~ /^(.+)\s(.+)$/  
+          # lemma may be "...." with spaces in.
+          # this regexp. uses the last space to separate lemma and POS
+          retv["lemma"] = $1
+          retv["pos"] = $2
+          
+          if retv["lemma"] =~ /^"(.+)"$/
+            # remove quotes around lemma
+            retv["lemma"] = $1
+            
+          elsif retv["lemma"] == "~"
+            # lemma same as word
+            retv["lemma"] = retv["word"]
+          end
+        elsif lemma_pos.strip().split().length() == 1
+          # only pos given
+	  retv["pos"] = lemma_pos.strip()
+	else
+	  $stderr.puts "cannot parse lemma_pos pair " + lemma_pos
+        end
+      end
+    end
+        
+    # parent index
+    if parentindex.nil? or parentindex == "*"
+      # root
+    else
+      retv["parent_index"] = parentindex
+    end
+
+    # edge label
+    if edgelabel.nil? or edgelabel.strip.empty? 
+      # no edge label given
+    else
+      retv["edgelabel"] = edgelabel
+    end
+    
+    # governing word
+    if governor and not(governor.strip.empty?)
+      # expected format:
+      # (gov <governing_lemma>)
+      if governor =~ /^\(gov\s(.+)\)$/
+        retv["governing_lemma"] = $1
+      elsif governor == "(gov )"
+	# okay, no governor given
+      else
+        $stderr.puts "cannot parse governor "+ governor
+      end
+    end
+
+    # antecedent
+    if antecedent and not(antecedent.strip.empty?)
+      # expected format:
+      # (antecedent <index>)
+      if antecedent =~ /^\(antecedent\s(.+)\)$/
+        retv["antecedent_index"] = $1
+      else
+        $stderr.puts "cannot parse antecedent "+ antecedent
+      end
+    end
+
+    return retv
+  end
+
+  ###########
+  # returns: SalsaTigerSentence object describing this minipar parse
+  def salsatigerxml_output(sentence_id)
+
+    # start sentence object
+    sent_obj = SalsaTigerSentence.empty_sentence(sentence_id)
+
+    # determine children of each node
+    # so we'll know which nodes to make terminal and which to make nonterminal
+    i_have_children = Hash.new
+    @nodes.each { | node|
+      if (parent_ix = node["parent_index"])
+        # node has parent. record the parent as having children
+        i_have_children[parent_ix] = true
+      end
+    }
+
+    # make SynNode objects for each minipar node
+    # minipar terminal: one SynNode terminal
+    # minipar nonterminal: one SynNode nonterminal, plus one SynNode terminal
+    #                      duplicating the word, lemma and POS info
+    #                      to keep with the SalsaTigerSentence assumptions that
+    #                      the sentence can be read off from the terminals
+    index_to_synnode = Hash.new
+    @nodes.each { |minipar_node|
+      node_id = minipar_node["index"]
+      if minipar_node["word"]
+        word = SalsaTigerXMLHelper.escape(minipar_node["word"])
+      elsif not(i_have_children[minipar_node["index"]])
+        # node without word and children: probably has an antecedent
+        # add an empty word so the Salsa tool can represent the node with the antecedent
+        word = ""
+      else
+        word = nil
+      end
+
+      if word
+        # make a terminal SynNode for this minipar node
+        # only if it has a word, otherwise it's not much use as a terminal
+        t_node = sent_obj.add_syn("t", 
+                                  nil,  # category
+                                  word, # word
+                                  minipar_node["pos"], # POS
+                                  node_id) # node ID
+        if minipar_node["lemma"]
+          t_node.set_attribute("lemma", SalsaTigerXMLHelper.escape(minipar_node["lemma"]))
+        end
+
+        # remember this node
+        index_to_synnode[minipar_node["index"]] = t_node
+      else
+        t_node = nil
+      end
+
+      if i_have_children[minipar_node["index"]] or not(word)
+        # does this minipar node have children, or
+        # does it lack a word? then add a (second) nonterminal SynNode for it
+        node_id = node_id + "nt"
+        nt_node = sent_obj.add_syn("nt",
+                                   minipar_node["pos"],  # category
+                                   word, # word
+                                   minipar_node["pos"], # POS
+                                   node_id) # node ID
+        if minipar_node["lemma"]
+          nt_node.set_attribute("lemma", SalsaTigerXMLHelper.escape(minipar_node["lemma"]))
+        end
+
+        # link t node to nt node
+        if t_node
+          nt_node.add_child(t_node, "Head")
+          t_node.add_parent(nt_node, "Head")
+        end
+
+        # just terminal node: remember it
+        # both terminal and nonterminal:remember just the nonterminal
+        index_to_synnode[minipar_node["index"]] = nt_node
+      end
+
+    }
+
+    # link SynNodes
+    @nodes.each { |minipar_node|
+      # find my syn node
+      my_synnode = index_to_synnode[minipar_node["index"]]
+      unless my_synnode
+        raise "Error: no syn node constructed for index in sentence #{sentence_id}"
+      end
+
+      # link to parent syn node
+      if (parent_ix = minipar_node["parent_index"])
+        parent_synnode = index_to_synnode[parent_ix]
+        unless parent_synnode
+          raise "Error: no syn node constructed for parent index #{parent_ix} in sentence #{sentence_id}"
+        end
+
+        parent_synnode.add_child(my_synnode, minipar_node["edgelabel"])
+        my_synnode.add_parent(parent_synnode, minipar_node["edgelabel"])
+      end
+
+      # remember antecedent: both the node itself and its index, the latter as an attribute
+      # this way, we have
+      # - easy access to the antecedent via the node itself
+      # - a record of the antecedent in the SalsaTigerXML output
+      if (antecedent_ix = minipar_node["antecedent_index"])
+        antecedent_synnode = index_to_synnode[antecedent_ix]
+        unless antecedent_synnode
+          raise "Error: no syn node constructed for antecedent index #{antecedent_ix} in sentence #{sentence_id}"
+        end
+
+        my_synnode.set_f("antecedent", antecedent_synnode)
+        my_synnode.set_attribute("antecedent", antecedent_synnode.id())
+      end
+    }
+    
+    return [sent_obj, construct_tabsent_mapping_stxml(sent_obj)]
+  end
+
+  ###########3
+  # construct mapping fntab line -> array of SynNodes
+  # and add fntab words not present in minipar as children of the
+  # SalsaTigerSentence object's root
+  def construct_tabsent_mapping_stxml(sent)
+    unless @tabsent
+      return nil
+    end
+
+    retv = Hash.new
+    prev_minipar_index = nil
+
+    @tabsent.each_line_parsed { |tabline|
+      retv[tabline.get("lineno")] = Array.new
+
+      # nodehash_mapping: hash tabsent lineno -> array: member of @nodes
+      if (nodehashes = @nodehash_mapping[tabline.get("lineno")])
+        nodehashes.each { |nodehash|
+          prev_minipar_index = nodehash["index"]
+
+          # this tabsent word has a corresponding minipar node
+          # enter it in tabsent_mapping
+          if (node = sent.syn_node_with_id(sent.id() + "_" + nodehash["index"]))
+            # terminal matching this fntab word
+            retv[tabline.get("lineno")] << node
+          elsif (node = sent.syn_node_with_id(sent.id() + "_" + nodehash["index"] + "nt"))
+            # we have a nonterminal matching this fntab word
+            retv[tabline.get("lineno")] << node
+          else
+            # no match after all? 
+            raise "missing: SalsaTigerSentence node for minipar node with index #{nodehash["index"]}"
+          end
+        }
+
+      else
+        # this tabsent word has no corresponding minipar node yet
+        # make one. See to it that it occurs in the right spot in sent.terminals_ordered.
+        parent = sent.syn_roots.first
+        node = sent.add_syn("t", # terminal
+                            "",  # category
+                            tabline.get("word"), # word
+                            "", # part of speech
+                            (prev_minipar_index.to_i + 1).to_s) # ID
+        parent.add_child(node, "-")
+        node.add_parent(parent, "-")
+
+        retv[tabline.get("lineno")] = [node]
+      end
+    }
+
+    return retv
+  end
+
+  ######
+  # return a list of pairs [fntab word index, match type]
+  # with an entry for each fntab word on fnw_list that matches minw,
+  # either fnw == minw (match_type "full") or minw part_of fnw (match_type "partial")
+  def fnw_minw_match(fnw_list, minw)
+    retv = Array.new
+
+    fnw_list.each_with_index { |fnw, fnw_index|
+      if fnw == minw
+        # words identical
+        retv << [fnw_index, "full"]
+      elsif fnw.index(minw)
+        # fn word includes minipar word
+        retv << [fnw_index, "partial"]
+      end
+    }
+
+    return retv
+  end
+end
+
+
+
+################################################
+# Interface class
+class MiniparInterface < SynInterfaceSTXML
+  MiniparInterface.announce_me()
+
+  ###
+  def MiniparInterface.system()
+    return "minipar"
+  end
+
+  ###
+  def MiniparInterface.service()
+    return "parser"
+  end
+
+  ###
+  # initialize to set values for all subsequent processing
+  def initialize(program_path, # string: path to system
+		 insuffix,      # string: suffix of tab files
+		 outsuffix,     # string: suffix for parsed files
+		 stsuffix,      # string: suffix for Salsa/TIGER XML files
+		 var_hash = {}) # optional arguments in a hash
+
+    super(program_path, insuffix, outsuffix, stsuffix, var_hash)
+
+    # new: evaluate var hash
+    @pos_suffix = var_hash["pos_suffix"]
+    @lemma_suffix = var_hash["lemma_suffix"]
+    @tab_dir = var_hash["tab_dir"]
+  end
+
+  
+  ###
+  # process one file, writing the result to outfilename
+  #  input format is FNTabFormat, output format is 
+  #  Minipar format
+  #
+  # returns: nothing
+  def process_file(infilename,    # string: name of input file
+		  outfilename)    # string: name of output file
+    
+    tf = Tempfile.new("minipar")
+    reader = FNTabFormatFile.new(infilename)
+    reader.each_sentence { |sent|
+      sent.each_line_parsed { |line|
+        tf.print line.get("word"), " "
+      }
+      tf.puts
+    }
+
+    tf.close()
+    %x{#{@program_path} < #{tf.path()} > #{outfilename}}
+  end
+
+  #########3
+  # yields tuples
+  #  [ minipar output sentence, tab sentence, mapping]
+  #
+  # minipar output sentence is 
+  #  - either an array of hashes, each describing one node;
+  #  - or a SalsaTigerSentence object
+  #  - or a MiniparSentence object 
+  #    (which has methods returns the sentence as either a 
+  #     nodehash array or a SalsaTigerSentence)
+  #
+  # tab sentence: matching tab sentence, if tab file has been given on initialization
+  #
+  # mapping: hash: line in tab sentence(integer) -> array:SynNode
+  #   mapping tab sentence nodes to matching nodes in the SalsaTigerSentence data structure
+  #
+  # If a parse has failed, returns 
+  #  [failed_sentence (flat SalsaTigerSentence), FNTabFormatSentence] 
+  # to allow more detailed accounting for failed parses
+  def each_sentence(parsefilename,    # name of minipar output file
+                    format = "stxml") # format to return data in
+    # sanity checks
+    unless @tab_dir
+      raise "Need to set tab directory on initialization"
+    end
+
+    # get matching tab file for this parser output file,
+    # read its contents
+    tabfilename = @tab_dir+File.basename(parsefilename, @outsuffix)+ @insuffix
+    @tab_sentences = Array.new
+    reader = FNTabFormatFile.new(tabfilename)
+    reader.each_sentence { |sent_obj| @tab_sentences << sent_obj  }
+
+    stream = open_minipar_outfile(parsefilename)
+
+    sentno = 0
+    tab_sentno = 0
+    matched_tabsent = Hash.new()
+
+    each_miniparsent_obj(stream) { |parse|
+
+      if (matching_tab_sentno = matching_tabsent(parse, tab_sentno))
+        # found matching tab sentence
+        tabsent = @tab_sentences[matching_tab_sentno]
+        tab_sentno = matching_tab_sentno + 1
+        matched_tabsent[matching_tab_sentno] = true
+      else
+        tabsent = nil
+      end
+
+      # yield minipar parse in the required format
+      case format
+      when "nodehashes"
+        yield [parse.nodes(), tabsent, parse.nodehash_mapping()]
+      when "stxml"
+        sent, mapping = parse.stxml(@filename_core + sentno.to_s)
+        yield [sent, tabsent, mapping]
+      when "objects"
+        yield [parse, tabsent]
+      else
+        raise "Unknown each_sentence format #{format}"
+      end
+
+      sentno += 1
+    }
+
+    ##
+    # each unmatched tab sentence: yield as failed parse object
+    @tab_sentences.each_with_index { |tabsent, index|
+      unless matched_tabsent[index]
+        # spotted an unmatched sentence
+        sent = MiniparInterface.failed_sentence(tabsent,tabsent.get_sent_id())
+        yield [sent, tabsent, MiniparInterface.standard_mapping(sent, tabsent)]
+      end
+    }
+  end    
+
+  ###
+  # write Salsa/TIGER XML output to file
+  def to_stxml_file(infilename,  # string: name of parse file
+		    outfilename) # string: name of output stxml file
+
+    outfile = File.new(outfilename, "w")
+    outfile.puts SalsaTigerXMLHelper.get_header()
+    each_sentence(infilename) { |st_sent, tabsent|
+      outfile.puts st_sent.get()
+    }
+    outfile.puts SalsaTigerXMLHelper.get_footer()
+    outfile.close()
+  end
+
+
+  #####################3
+  private
+
+  ###
+  # open minipar outfile
+  #
+  # return: IO stream for reading minipar outfile
+  def open_minipar_outfile(filename)
+    
+    ##
+    # zipped? then unzip first
+    # (the Ruby read-zipped package doesn't seem to be reliable)
+    if filename =~  /\.gz$/
+      @filename_core = File.basename(filename, ".gz")
+      return IO.popen("zcat #{filename}") 
+    else
+      @filename_core = File.basename(filename)
+      begin
+        return File.new(filename)
+      rescue
+        raise "Couldn't read minipar file #{filename}"
+      end
+    end
+  end
+
+  ###
+  # each_miniparsent_obj
+  # read minipar output from stream,
+  # yield sentence-wise as MiniparSentence objects
+  def each_miniparsent_obj(stream) # IO object: stream to read from 
+
+    # status: string
+    # "outside": waiting for next start of sentence with ( alone in a line
+    # "inside": inside a sentence, sentence ends with ) alone on a line
+    status = "outside"
+    
+    # sentence: array of strings, one for each line of the sentence
+    sentence = Array.new()
+
+    while (line = stream.gets())
+      case status
+      when "outside"
+        # start of sentence?
+        if ["(", "> ("].include? line.chomp().strip()
+          sentence.clear()
+          status = "inside"
+        end
+        
+      when "inside"
+        if line.chomp().strip() == ")"
+          # end of sentence
+          yield MiniparSentence.new(sentence)
+          status = "outside"
+        else
+          # inside sentence
+          sentence << line.chomp().strip()
+        end
+      else
+        raise "Shouldn't be here"
+      end # case
+    end # while file not ended
+  end
+
+  ###
+  # matching_tabsent
+  #
+  # if we have tab sentences, and if there is 
+  # a tab sentence matching the given minipar sentence,
+  # return its index, else return false
+  #
+  # If there is a matching tabsent,
+  # the MiniparSentence will remember it (and the terminal mapping)
+  def matching_tabsent(parse,  # MiniparSentence object
+                       tabsent_no) # integer: starting point in @tab_sentences array
+    if @tab_sentences.empty?
+      return nil
+    end
+
+    tabsent_no.upto(@tab_sentences.length() - 1) { |index|
+      if parse.set_tabsent(@tab_sentences[index])
+        return index
+      end
+    }
+    
+    # no match found up to now. so try sloppy match
+    if parse.set_tabsent(@tab_sentences[tabsent_no], "sloppy")
+#      $stderr.puts "Warning: sloppy match used. Minipar sentence:"
+#      $stderr.puts parse.nodes().map { |n| n["word"].to_s }.join(" ")
+#      $stderr.puts "Matching fntab sentence: "
+#      @tab_sentences[tabsent_no].each_line_parsed { |l| $stderr.print l.get("word"), " " }
+#      $stderr.puts
+      return tabsent_no
+    end
+
+#    $stderr.puts "Warning: No match found for minipar sentence:"
+#    $stderr.puts parse.nodes().map { |n| n["word"].to_s }.join(" ")
+#    $stderr.puts "First tested fntab sentence: "
+#    @tab_sentences[tabsent_no].each_line_parsed { |l| $stderr.print l.get("word"), " " }
+#    $stderr.puts
+
+    return nil
+  end
+end
+
+################################################
+# Interpreter class
+class MiniparInterpreter < SynInterpreter
+  MiniparInterpreter.announce_me()
+
+  ###
+  # names of the systems interpreted by this class:
+  # returns a hash service(string) -> system name (string),
+  # e.g.
+  # { "parser" => "collins", "lemmatizer" => "treetagger" }
+  def MiniparInterpreter.systems()
+    return {
+      "parser" => "minipar"
+    }
+  end
+
+  ###
+  # names of additional systems that may be interpreted by this class
+  # returns a hash service(string) -> system name(string)
+  # same as names()
+  def MiniparInterpreter.optional_systems()
+    return {}
+  end
+
+  ###
+  # generalize over POS tags.
+  #
+  # returns one of:
+  #
+  # adj:  adjective (phrase)
+  # adv:  adverb (phrase)
+  # card: numbers, quantity phrases
+  # con:  conjunction
+  # det:  determiner, including possessive/demonstrative pronouns etc.
+  # for:  foreign material
+  # noun: noun (phrase), including personal pronouns, proper names, expletives
+  # part: particles, truncated words (German compound parts)
+  # prep: preposition (phrase)
+  # pun:  punctuation, brackets, etc.
+  # sent: sentence
+  # top:  top node of a sentence
+  # verb: verb (phrase)
+  # nil:  something went wrong
+  #
+  # returns: string, or nil
+  def MiniparInterpreter.category(node) # SynNode
+    node = MiniparInterpreter.ensure_upper(node)
+
+    if node.get_attribute("lemma") =~ /NUM/
+      return "card"
+    end
+
+    if node.part_of_speech() == "U" and
+        node.parent_label() == "lex-mod" and
+        node.parent and MiniparInterpreter.category(node.parent) == "verb"
+      # this node is part of a complex verb
+      return "part"
+    end
+
+    if node.word =~ /^[!?;`'",(){}\[\]\.\:]+$/ 
+      return "pun"
+    end
+
+    if node.parent.nil?
+      return "top"
+    end    
+
+    case node.part_of_speech()
+
+    when "A"  # same POS for adjectives and adverbs
+      parent = node.parent
+      if parent 
+        if MiniparInterpreter.category(parent) == "verb"
+          return "adv"
+        else
+          return "adj"
+        end
+      else
+        return "adj"
+      end
+
+    when "Det"
+      return "det"
+    when "N"
+      return "noun"
+
+    when "Prep"
+      return "prep"
+
+    when "C"
+      return "sent"
+
+    when /^V/
+      return "verb"
+      
+    else
+      return nil
+    end
+  end
+
+  ###
+  # is relative pronoun?
+  #
+  def MiniparInterpreter.relative_pronoun?(node) # SynNode
+    if node.parent_label() =~ /^wh/
+      return true
+    else
+      return false
+    end
+  end
+
+  ###
+  # phrase type:
+  # constituent label for nonterminals,
+  # part of speech for terminals
+  #
+  # returns: string
+  def MiniparInterpreter.pt(node)
+    return node.part_of_speech()
+  end
+
+  ###
+  # auxiliary?
+  # 
+  # returns true if the given node is an auxiliary
+  #
+  # returns: boolean
+  def MiniparInterpreter.auxiliary?(node)
+    if MiniparInterpreter.aux_or_modal?(node) and
+        not(MiniparInterpreter.modal?(node))
+      return true
+    else
+      return false
+    end
+  end
+
+  ###
+  # modal?
+  #
+  # returns true if the given node is a modal verb
+  #
+  # returns: boolean
+  def MiniparInterpreter.modal?(node)
+    if MiniparInterpreter.aux_or_modal?(node) and
+        ["can",
+         "could",
+         "must",
+         "should",
+         "shall"
+      ].include? node.word()
+      return true
+    else
+      return false
+    end
+  end
+
+  ###
+  # head_terminal
+  #
+  # given a constituent, return the terminal node
+  # that describes its headword
+  #
+  # returns: a SynNode object if successful, else nil
+  def MiniparInterpreter.head_terminal(node)
+    if node.is_terminal?
+      return node
+    else
+      return node.children_by_edgelabels(["Head"]).first
+    end
+  end
+
+  ###
+  # voice
+  #
+  # given a constituent, return 
+  # - "active"/"passive" if it is a verb
+  # - nil, else
+  def MiniparInterpreter.voice(verb_node)
+    
+    # am I a terminal added to make minipar representations
+    # more TigerXML-like? then move to my parent
+    verb_node = MiniparInterpreter.ensure_upper(verb_node)
+
+    # verb has to have part of speech V or VBE
+    unless ["V", "VBE"].include? verb_node.part_of_speech()
+      return nil
+    end
+
+    # outgoing edge "by_subj"? 
+    # then assume passive
+    unless verb_node.children_by_edgelabels(["by_subj"]).empty?
+#      $stderr.puts "passive #{verb_node.id()} by_subj"
+      return "passive"
+    end
+
+    # outgoing edge to auxiliary "be", and not "be ....ing"?
+    # then assume passive
+    if not(verb_node.children_by_edgelabels(["be"]).empty?) and
+        verb_node.word !~ /ing$/
+#      $stderr.puts "passive #{verb_node.id()} be"
+      return "passive"
+    end
+
+    # vrel incoming edge? then assume passive
+    if verb_node.parent_label() == "vrel"
+#      $stderr.puts "passive #{verb_node.id()} vrel"
+      return "passive"
+    end
+
+    # obj child coreferent with s child? 
+    # then assume passive
+    if (obj_ch = verb_node.children_by_edgelabels(["obj"]).first)
+      if (s_ch = verb_node.children_by_edgelabels(["s"]).first)
+        if obj_ch.get_f("antecedent") == s_ch
+#          $stderr.puts "passive #{verb_node.id()} obj=s"
+          return "passive"
+        end
+      end
+    end
+
+    # okay, assume active voice
+    return "active"
+  end
+
+  ###
+  # gfs
+  #
+  # grammatical functions of a constituent:
+  # 
+  # returns: a list of pairs [relation(string), node(SynNode)]
+  # where <node> stands in the relation <relation> to the parameter
+  # that the method was called with
+  def MiniparInterpreter.gfs(start_node,    # SynNode
+                             sent)    # SalsaTigerSentence
+
+    start_node = MiniparInterpreter.ensure_upper(start_node)
+    
+    retv =  start_node.children_with_edgelabel.reject { |edgelabel, node|
+      ["Head",  # head of the target node -- not really bearer of a GF
+	"-",
+	"aux",
+	"have",
+	"be"
+      ].include? edgelabel
+    }.map { |edgelabel,node|
+	
+      # map node to suitable other node
+      while (ant_id = node.get_attribute("antecedent"))
+	
+        # Antecedent node for empty nodes and relative pronouns
+	  
+        new_node = sent.syn_node_with_id(ant_id)
+        if new_node
+          node = new_node
+        else
+          # error. stop seeking
+          #	    $stderr.puts "Antecedent ID not matching any node: #{ant_id}"
+          break
+        end
+      end
+      
+      # PP -- i.e. edgelabel == mod and node.POS == Prep?
+      # then add the preposition to the edgelabel,
+      # and take the node's head as head instead of the node
+      if edgelabel == "mod" and
+	  node.part_of_speech() == "Prep"
+	edgelabel = edgelabel + "-" + node.word().to_s
+      end
+
+      [edgelabel, node]
+    }
+
+    # duplicate entries?
+    # s is often coreferent with either subj or obj
+    if MiniparInterpreter.voice(start_node) == "active" and
+        (s_entry = retv.assoc("s")) and
+        (subj_entry = retv.assoc("subj")) and
+        s_entry.last == subj_entry.last
+      retv.delete(s_entry)
+
+    elsif MiniparInterpreter.voice(start_node) == "passive" and
+        (s_entry = retv.assoc("s")) and
+        (obj_entry = retv.assoc("obj")) and
+        s_entry.last == obj_entry.last
+      retv.delete(s_entry)
+    end
+        
+#    $stderr.puts "blip " + retv.map { |l, n| l}.join(" ")
+    return retv
+  end
+
+  ###
+  # informative_content_node
+  #
+  # for most constituents: the head
+  # for a PP, the NP
+  # for an SBAR, the VP
+  # for a VP, the embedded VP 
+  def MiniparInterpreter.informative_content_node(node)
+    node = MiniparInterpreter.ensure_upper(node)
+
+    if node.part_of_speech() == "Prep"
+      # use complement of this constituent 
+      children = node.children_by_edgelabels(["pcomp-n", 
+                                              "vpsc_pcomp-c", 
+                                              "pcomp-c"])
+
+      if children.empty?
+        # no suitable child found
+#        $stderr.puts "Prep node without suitable child."
+#        $stderr.puts "Outgoing edges: " + node.child_labels().join(", ")
+        return nil
+        
+      else
+#         if children.length() > 1
+#           $stderr.puts "Too many suitable children for prep node: "
+#           $stderr.puts "Outgoing edges: " + node.child_labels().join(", ")
+#         end
+        
+        return children.first
+      end  
+
+
+    elsif node.part_of_speech() == "SentAdjunct"
+      # use complement of this constituent 
+      children = node.children_by_edgelabels(["comp1"])
+
+      if children.empty?
+        # no suitable child found
+#        $stderr.puts "SentAdjunct node without suitable child."
+#        $stderr.puts "Outgoing edges: " + node.child_labels().join(", ")
+        return nil
+
+      else
+#         if children.length() > 1
+#           $stderr.puts "Too many suitable children for sent. adjunct node: "
+#           $stderr.puts "Outgoing edges: " + node.child_labels().join(", ")
+#         end
+
+        return children.first
+      end  
+    
+    elsif node.word().nil? or node.word().empty?
+      # no word for this node: use child instead
+
+      children = node.children_by_edgelabels(["i"])
+      if children.length() > 0
+#         if children.length() > 1
+#           $stderr.puts "Too many i edges from empty node."
+#         end
+
+        return children.first
+      end
+
+      children = node.children_by_edgelabels(["nn"])
+      if children.length() > 0
+#         if children.length() > 1
+#           $stderr.puts "Too many nn edges from empty node."
+#         end
+
+        return children.first
+      end
+    
+      # no children for this node: try antecedent
+      ant = node.get_f("antecedent")
+      if ant
+        return ant
+      end
+
+      return nil
+    end
+    
+  end
+
+  ###
+  # path_between
+  #
+  # construct path in syntactic structure between two nodes, 
+  # using 
+  # - node labels
+  # - edge labels
+  # - direction Up, Down
+  #
+  # use_nontree_edges: set to true to use coreference edges
+  # and other non-tree edges returned by the parser
+  # in path computation. 
+  #
+  # returns: Path object
+  def MiniparInterpreter.path_between(from_node, # SynNode
+                                      to_node,   # SynNode
+				      use_nontree_edges = false) # boolean
+    from_node = MiniparInterpreter.ensure_upper(from_node)
+    to_node = MiniparInterpreter.ensure_upper(to_node)
+
+    if use_nontree_edges
+      MiniparInterpreter.each_reachable_node(from_node) { |node, ant, paths, prev|
+	if node == to_node
+	  return paths.first
+	end
+	true # each_reachable_node requires boolean to determine
+	     # whether to continue the path beyond node
+      }
+    else
+      return super(from_node, to_node)
+    end
+  end
+
+  ###
+  # surrounding_nodes:
+  #
+  # construct paths in syntactic structure between a node and each of its neighbors
+  # path construction as in path_between.
+  # Neighbors: parent, child, plus potentially neighbors by nontree edges
+  # use_nontree_edges: again, same as in path_between
+  #
+  # returns: list of pairs [neighbor(SynNode), path(Path)]
+  def MiniparInterpreter.surrounding_nodes(node, # SynNode
+                                           use_nontree_edges = false) # boolean
+    normal_neighbors = super(node, use_nontree_edges)
+    # add antecedents
+    more_neighbors = Array.new
+    normal_neighbors.each { |neighbor, path|
+      while n = (neighbor.get_f("antecedent"))
+        more_neighbors << [n, path]
+        neighbor = n
+      end
+    }
+    return normal_neighbors + more_neighbors
+  end
+
+
+#   ###
+#   # main node of expression
+#   #
+#   # 2nd argument non-nil:
+#   # don't handle multiword expressions beyond verbs with separate particles
+#   # 
+#   # returns: SynNode, main node, if found
+#   # else nil
+#   def MiniparInterpreter.main_node_of_expr(nodelist, 
+#                                            no_mwes = nil)
+
+#     nodelist = nodelist.map { |n| MiniparInterpreter.ensure_upper(n) }.uniq()
+
+#     # main reason we are overwriting the parent method:
+#     # don't go to terminal nodes right away.
+#     # If we have a single nonterminal, stay with it.
+#     # Otherwise, use parent method
+#     if nodelist.length() == 1
+#       return nodelist.first
+#     end
+
+#     return super(nodelist, no_mwes)
+#   end
+
+  ########
+  # max constituents:
+  # given a set of nodes, compute the maximal constituents
+  # that exactly cover them
+  #
+  # overwrite default: ignore empty terminals, both in nodeset
+  #  and in the nodes that are tested as potential maximal constituents
+  def MiniparInterpreter.max_constituents(nodeset, # Array:SynNode
+                                          sent,    # SalsaTigerSentence
+                                          idealize_maxconst = false) # boolean
+  
+    my_nodeset = nodeset.reject { |n| MiniparInterpreter.empty_terminal?(n)}
+    if idealize_maxconst
+      return sent.max_constituents_smc(my_nodeset, idealize_maxconst, true)
+    else
+      return sent.max_constituents_for_nodes(my_nodeset, true)
+    end
+  end
+
+
+  ###
+  # for all nodes reachable from a given from_node:
+  # compute the path from from_node,
+  # using both tree edges and coreference edges
+  #
+  # compute a widening circle of nodes from from_node outward,
+  # following all antecedent links as 0-length paths.
+  #
+  # yields tuples
+  #  [
+  #   minipar node, 
+  #   array: other minipar node(s) reached from this one solely via antecedent edges,
+  #   array: minimal paths from start_node to this node as Path objects
+  #   minipar node 2: last stop on path from start_node to minipar_node
+  #  ]
+  def MiniparInterpreter.each_reachable_node(from_node)   # SynNode
+
+    from_node = MiniparInterpreter.ensure_upper(from_node)
+
+    # rim: array:SynNode, current outermost nodes
+    rim = [ from_node ]
+    # seen: hash SynNode->Path, mapping (seen) minipar nodes to
+    # the path leading from the target to them
+    seen = {
+      from_node => [Path.new(from_node)]
+    }
+    
+    while not(rim.empty?)
+      # remove node from the beginning of the rim
+      minipar_node = rim.shift()
+      
+      # make tuples:
+      # ["D" for down from minipar_node, or "U" for up,
+      #  parent or child of minipar_node, 
+      #  edgelabel between minipar_node and that parent or child,
+      #  POS of that parent or child,
+      #  preposition
+      #  ]
+      surrounding_n = minipar_node.children.map { |child| 
+        ["D", child, 
+         minipar_node.child_label(child), child.part_of_speech()]
+      }
+      if minipar_node.parent
+        surrounding_n.push([
+				 "U", minipar_node.parent, 
+				 minipar_node.parent_label(), 
+				 minipar_node.parent.part_of_speech()
+			       ])
+      end
+    
+      surrounding_n.each { |direction, new_node, edgelabel, nodelabel|
+        
+        # node we are actually using: the antecedent, if it's there
+        # the coref chain may have a length > 1
+        actual_new_node = new_node
+        antecedents = []
+        while actual_new_node.get_f("antecedent")
+          antecedents << actual_new_node.get_f("antecedent")
+          actual_new_node = actual_new_node.get_f("antecedent")
+        end
+        
+        # node seen before, and  seen with shorter path?
+        # all paths in seen[actual_new_node] have the same length
+        if seen[actual_new_node] and
+            seen[actual_new_node].first.length() < seen[minipar_node].first.length() + 1
+          # yes, seen with a shorter path. discard
+          next
+        end
+        
+        # make paths for this new_node
+        paths = seen[minipar_node].map { |previous_path| 
+	  new_path = previous_path.deep_clone
+          if new_node.part_of_speech() == "Prep"
+            # preposition? add to path too
+	    new_path.add_last_step(direction, 
+				   edgelabel + "-" + new_node.get_attribute("lemma"), 
+				   nodelabel,
+				   new_node)
+          else
+            new_path.add_last_step(direction, edgelabel, nodelabel, new_node)
+          end
+	  new_path
+        }
+        
+        # node not seen before: record
+        unless seen[actual_new_node]
+          seen[actual_new_node] = Array.new
+        end
+        seen[actual_new_node].concat paths
+        
+	keepthisnode = yield(new_node, antecedents, paths, minipar_node)
+        
+        if keepthisnode and not(rim.include?(actual_new_node))
+          rim.push actual_new_node
+        end
+        
+      } # each parent or child of the current rim node
+    end # while new rim nodes keep being discovered
+  end
+
+  #####################33
+  private
+
+  ###
+  # auxiliaries and modals share this characteristic
+  def MiniparInterpreter.aux_or_modal?(node)
+    node = MiniparInterpreter.ensure_upper(node)
+    
+    if (l = node.parent_label()) and
+        ["be", "have", "aux"].include? l and
+        (p = node.parent()) and
+        MiniparInterpreter.category(p) == "verb"
+      return true
+    else
+      return false
+    end
+  end
+
+  ###
+  # given a node: if it has a Head child, return that,
+  # else return the node
+  def MiniparInterpreter.ensure_terminal(node)
+    headchildren = node.children_by_edgelabels(["Head"])
+    if headchildren and not(headchildren.empty?)
+      return headchildren.first
+    else
+      return node
+    end
+  end
+
+  ###
+  # given a node: if it is a terminal that is linked to its
+  # parent by a Head edge, return the parent,
+  # else return the node
+  def MiniparInterpreter.ensure_upper(node)
+    if node.parent_label() == "Head"
+      return node.parent
+    else
+      return node
+    end
+  end
+
+  ###
+  # is this an empty terminal?
+  def MiniparInterpreter.empty_terminal?(node)
+    if node.is_terminal? and node.word().empty?
+      return true
+    else
+      return false
+    end
+  end
+
+end