import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
@Override
protected boolean match(ExtractorMatcher matcher,
    TregexMatcher tregexMatcher, Tree tree) {

  boolean result = super.match(matcher, tregexMatcher, tree);
  if (result) {
    List<Tree> children = matcher.getMatch().getChildrenAsList();
    int triggerIndex = children.indexOf(matcher.trigger);
    int argIndex = children.indexOf(matcher.argument);

    matcher.matched = tregexMatcher.getMatch().deepCopy();
    children = matcher.matched.getChildrenAsList();

    matcher.trigger = children.get(triggerIndex);

    TreeFactory tf = matcher.matched.treeFactory();
    matcher.argument = tf.newTreeNode(
        "NP",
        children.subList(argIndex, children.size()));
  }
  return result;
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
@Override
protected boolean match(ExtractorMatcher matcher,
    TregexMatcher tregexMatcher, Tree tree) {

  boolean result = super.match(matcher, tregexMatcher, tree);
  if (result) {
    List<Tree> children = matcher.getMatch().getChildrenAsList();

    int argIndex = children.indexOf(matcher.argument);

    matcher.matched = tregexMatcher.getMatch().deepCopy();
    children = matcher.matched.getChildrenAsList();

    matcher.trigger = matcher.matched;

    TreeFactory tf = matcher.matched.treeFactory();
    matcher.argument = tf
        .newTreeNode("NP", children.subList(0, argIndex + 1));
  }
  return result;
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
private Tree fixNonUnaryRoot(Tree t, TreeFactory tf) {
  List<Tree> kids = t.getChildrenAsList();
  if(kids.size() == 2 && t.firstChild().isPhrasal() && tlp.isSentenceFinalPunctuationTag(t.lastChild().value())) {
    List<Tree> grandKids = t.firstChild().getChildrenAsList();
    grandKids.add(t.lastChild());
    t.firstChild().setChildren(grandKids);
    kids.remove(kids.size() - 1);
    t.setChildren(kids);
    t.setValue(tlp.startSymbol());
    
  } else {
    t.setValue(nonUnaryRoot);
    t = tf.newTreeNode(tlp.startSymbol(), Collections.singletonList(t));
  }
  return t;
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
/**
 * Build the Tree object from its string form.
 */
public static Tree stringToTree(String str, TreeFactory tf) {
  try {
    PennTreeReader ptr = new PennTreeReader(new BufferedReader(new StringReader(str)), tf);
    Tree parseTree = ptr.readTree();
    return parseTree;
  } catch( Exception ex ) { ex.printStackTrace(); }
  return null;
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
/**
 * Build Tree objects from a collection of parses in string form.
 */
public static List<Tree> stringsToTrees(Collection<String> strings) {
  if( strings != null ) {
    List<Tree> trees = new ArrayList<Tree>();
    TreeFactory tf = new LabeledScoredTreeFactory();
    for( String str : strings )
      trees.add(stringToTree(str, tf));
    return trees;
  }
  else return null;
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
/**
 * @param args
 */
public static void main(String[] args) {
  TreeFactory tf = new LabeledScoredTreeFactory();
  List<Tree> trees = new ArrayList<Tree>();
  trees.add(TreeOperator.stringToTree("(TOP (S (NP (person (NNP Dave))) (VP (VBD left) (NP (NP (DT the) (NN job) (JJ first) (NN thing)) (PP (IN in) (NP (DT the) (NN morning))))) (. .)) )", tf));
  trees.add(TreeOperator.stringToTree("(TOP (S (NP (PRP He)) (VP (VP (VBD drank) (NP (NP (NNS lots)) (PP (IN of) (NP (NN coffee))))) (CC and) (VP (VBD picked) (NP (PRP her)) (PRT (RP up)))) (. .)) )", tf));

  CorefStanford coref = new CorefStanford();
  coref.processParses(trees);
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
/**
 * @desc Process parses for verbs
 * @param parses The list of parses in String form
 */
private void analyzeParsesNoCoref( Vector<String> parses ) {
  TreeFactory tf = new LabeledScoredTreeFactory();
  Vector<String> verbs = new Vector();

  // Save the verbs in each parse
  int sentence = 0;
  for( String parse : parses ) {
    try {
      // Read the parse
      PennTreeReader ptr = new PennTreeReader(new BufferedReader(new StringReader(parse)), tf);
      Tree ansTree = ptr.readTree();

      // Look for the verbs in the tree
      if( ansTree != null ) {

        Vector<Tree> parseVerbs = TreeOperator.verbTreesFromTree(ansTree);
        for( Tree verb : parseVerbs )
          //	    verbs.add(verb.firstChild().firstChild().value());
          verbs.add(verb.firstChild().value());

      }
    } catch( Exception ex ) { ex.printStackTrace(); }
    sentence++;
  }

  // do the pair counts
  countPairs(verbs);
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
private void analyzeParses( GigaDoc doc, Collection<String> parses, Collection<EntityMention> entities ) {
  if( entities != null ) {
    TreeFactory tf = new LabeledScoredTreeFactory();

    // Read in all the parse trees
    Tree trees[] = new Tree[parses.size()];
    int i = 0;
    for( String parse : parses ) {
      try {
        PennTreeReader ptr = new PennTreeReader(new BufferedReader(new StringReader(parse)), tf);
        trees[i] = ptr.readTree();
      } catch( Exception ex ) { ex.printStackTrace(); }
      i++;
    }

    // Convert all entity spans from character spans to word-based
    for( EntityMention mention : entities ) {
      mention.convertCharSpanToIndex(TreeOperator.toRaw(trees[mention.sentenceID()-1]));
      doc.addEntity(mention);
      //	mentions[mention.sentenceID()-1].add(mention);
    }

    // Save the verbs in each parse
    int sid = 0, eid = 0;
    for( Tree tree : trees ) {
      if( tree != null ) {
        // Look for the verbs in the tree
        Vector<Tree> parseVerbs = TreeOperator.verbTreesFromTree(tree);
        for( Tree verb : parseVerbs ) {
          //            System.out.println("  verb: " + verb + " index: " + (TreeOperator.wordIndex(tree,verb)+1));
          doc.addEvent(new WordEvent(eid, verb.firstChild().value(), TreeOperator.wordIndex(tree,verb)+1, sid+1));
          eid++;
        }
        sid++;
      }
    }
  }
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
public Tree getStanfordContituencyTree() {
    TreeFactory tf = new LabeledScoredTreeFactory();
    StringReader r = new StringReader(getParseText());
    TreeReader tr = new PennTreeReader(r, tf);
    try {
        return tr.readTree();
    } catch (IOException e) {
        throw new RuntimeException("Error: IOException should not be thrown by StringReader");
    }
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
@Override

  protected boolean match(ExtractorMatcher matcher,
      TregexMatcher tregexMatcher,
      Tree tree) {

    boolean result = super.match(matcher, tregexMatcher, tree);
    if (result) {
      List<Tree> children = matcher.getMatch().getChildrenAsList();
      int triggerIndex = children.indexOf(matcher.trigger);
      int argIndex = children.indexOf(matcher.argument);

      matcher.matched = tregexMatcher.getMatch();
      TreeFactory tf = tregexMatcher.getMatch().treeFactory();

      matcher.matched = tregexMatcher.getMatch().deepCopy(tf);
      children = matcher.matched.getChildrenAsList();
      
      matcher.trigger = tf.newTreeNode(
          "NP",
            children.subList(triggerIndex, children.size()));

      matcher.argument = tf
          .newTreeNode("NP", children.subList(0, argIndex + 1));

      while (matcher.matched.numChildren() != 0) {
        matcher.matched.removeChild(0);
      }
      matcher.matched.addChild(matcher.argument);
      matcher.matched.addChild(matcher.trigger);
    }
    return result;
  }
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
@Override
protected boolean match(ExtractorMatcher matcher,
    TregexMatcher tregexMatcher, Tree tree) {

  Tree leaf = tregexMatcher.getMatch().getChild(0);
  if (!leaf.isLeaf()) {
    return false;
  }

  OffsetLabel label = (OffsetLabel) leaf.label();
  int dash = label.value().lastIndexOf('-');
  if (dash == -1 || dash == 0) {
    return false;
  }

  matcher.matched = leaf.parent(tree).deepCopy();

  TreeFactory tf = matcher.matched.treeFactory();

  OffsetLabel newLeafLabel = new OffsetLabel(label.value()
      .substring(dash + 1));
  newLeafLabel.setBeginPosition(dash + 1 + label.beginPosition());
  newLeafLabel.setEndPosition(label.endPosition());
  
  leaf = tf.newLeaf(newLeafLabel);
  matcher.trigger = tf.newTreeNode("NP", Collections.singletonList(leaf));
  
  newLeafLabel = new OffsetLabel(label.value()
      .substring(0, dash));
  newLeafLabel.setBeginPosition(label.beginPosition());
  newLeafLabel.setEndPosition(label.beginPosition() + dash);
  
  leaf = tf.newLeaf(newLeafLabel);
  matcher.argument = tf.newTreeNode("NP", Collections.singletonList(leaf));

  matcher.matched.removeChild(0);
  matcher.matched.addChild(matcher.argument);
  matcher.matched.addChild(matcher.trigger);
  return true;
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
Tree transformRoot(Tree tree, TreeFactory tf) {
  // XXXX TODO: use tlp and don't assume 1 daughter of ROOT!
  // leave the root intact
  // if (tlp.isStartSymbol(tlp.basicCategory(tree.label().value())))
  if (tree.label().toString().startsWith("ROOT")) {
    return tf.newTreeNode(tree.label(), Collections.singletonList(transformNode(tree.children()[0], tf)));
  }
  return transformNode(tree, tf);
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
/**
 * Normalize a whole tree.
 * TueBa-D/Z adaptation. Fixes trees with non-unary roots, does nothing else.
 */
@Override
public Tree normalizeWholeTree(Tree tree, TreeFactory tf) {
  if (tree.label().value().equals(root) && tree.children().length > 1) {
    Tree underRoot = tree.treeFactory().newTreeNode(root, tree.getChildrenAsList());
    tree.setChildren(new Tree[1]);
    tree.setChild(0, underRoot);

  }
  // we just want the non-unary root fixed.
  return tree;
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
/**
 * Construct a fall through tree in case we can't parse this sentence
 * @param words
 * @return a tree with X for all the internal nodes
 */
public static Tree xTree(List<? extends HasWord> words) {
  TreeFactory lstf = new LabeledScoredTreeFactory();
  List<Tree> lst2 = new ArrayList<Tree>();
  for (HasWord obj : words) {
    String s = obj.word();
    Tree t = lstf.newLeaf(s);
    Tree t2 = lstf.newTreeNode("X", Collections.singletonList(t));
    lst2.add(t2);
  }
  return lstf.newTreeNode("X", lst2);
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
@Override
public Tree normalizeWholeTree(Tree tree, TreeFactory tf) {
  tree = tree.prune(hebrewEmptyFilter, tf).spliceOut(aOverAFilter, tf);

  //Add start symbol so that the root has only one sub-state. Escape any enclosing brackets.
  //If the "tree" consists entirely of enclosing brackets e.g. ((())) then this method
  //will return null. In this case, readers e.g. PennTreeReader will try to read the next tree.
  while(tree != null && (tree.value() == null || tree.value().equals("")) && tree.numChildren() <= 1)
    tree = tree.firstChild();

  if(tree != null && !tree.value().equals(tlp.startSymbol()))
    tree = tf.newTreeNode(tlp.startSymbol(), Collections.singletonList(tree));

  return tree;
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
/**
 * Normalize a whole tree -- one can assume that this is the
 * root.  This implementation deletes empty elements (ones with
 * nonterminal tag label starting with '*T') from the tree.  It
 * does work for a null tree.
 */
@Override
public Tree normalizeWholeTree(Tree tree, TreeFactory tf) {
  // add an extra root to non-unary roots
  if(tree.value() == null)
    tree = fixNonUnaryRoot(tree, tf);
  else if(!tree.value().equals(tlp.startSymbol()))
    tree = tf.newTreeNode(tlp.startSymbol(), Collections.singletonList(tree));

  tree = tree.prune(emptyFilter, tf).spliceOut(aOverAFilter, tf);

  // insert NPs in PPs if you're supposed to do that
  if (insertNPinPP) {
    insertNPinPPall(tree);
  }

  for(Tree t : tree) {
    if(t.isLeaf() || t.isPreTerminal()) continue;
    if(t.value() == null || t.value().equals("")) t.setValue("DUMMY");

    // there's also a '--' category
    if(t.value().matches("--.*")) continue;

    // fix a bug in the ACL08 German tiger treebank
    String cat = t.value();
    if(cat == null || cat.equals("")) {
      if (t.numChildren() == 3 && t.firstChild().label().value().equals("NN") && t.getChild(1).label().value().equals("$.")) {
        System.err.println("Correcting treebank error: giving phrase label DL to " + t);
        t.label().setValue("DL");
      }
    }
  }

  return tree;
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
/**
 * Counts all *verbs* in the parse trees and tracks IDF counts.
 */
private void calculateIDFofVerbs( Vector<String> parses ) {
  TreeFactory tf = new LabeledScoredTreeFactory();
  HashMap<String,Boolean> seen = new HashMap(100);
  HashMap<String,Boolean> seenLemmas = new HashMap(100);

  // Loop over each parse tree
  for( String parse : parses ) {
    try {
      PennTreeReader ptr = new PennTreeReader(new BufferedReader(new StringReader(parse)), tf);
      Tree ansTree = ptr.readTree();

      if( ansTree != null ) {

        // Look for the verbs in the tree
        Vector<Tree> parseVerbs = TreeOperator.verbTreesFromTree(ansTree);
        for( Tree verb : parseVerbs ) {
          String wordString = verb.firstChild().value().toLowerCase();

          // Look for a particle
          String particle = findParticleInTree(verb.parent(ansTree));
          if( particle != null ) wordString += "_" + particle.toLowerCase();

          // Don't count numerals or weird starting punctuation tokens
          if( wordString.matches("[a-zA-Z].*") && !wordString.matches(".*\\d.*") )  {
            // Count the documents the word appears in, for IDF score
            if( !seen.containsKey(wordString) ) {
              seen.put(wordString, true);
              // add the count of documents
              idf.increaseDocCount(wordString);
            }

            // Count the documents the lemma appears in, for IDF score
            String lemmaString = verbToLemma(wordString);
            if( lemmaString == null ) lemmaString = wordString;
            if( !seenLemmas.containsKey(lemmaString) ) {
              seenLemmas.put(lemmaString, true);
              // add the count of documents
              idfLemmas.increaseDocCount(lemmaString);
            }

            // Increment word frequency
            idf.increaseTermFrequency(wordString);
            idfLemmas.increaseTermFrequency(lemmaString);
          }
        }
      }

    } catch( Exception ex ) { ex.printStackTrace(); }
  }
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
@Override
protected boolean match(ExtractorMatcher matcher,
    TregexMatcher tregexMatcher, Tree tree) {

  Tree leaf = tregexMatcher.getMatch().getChild(0);
  if (!leaf.isLeaf()) {
    return false;
  }

  OffsetLabel label = (OffsetLabel) leaf.label();
  if (label.value().contains("-RRB-")) {
    return false;
  }
  Matcher m = p.matcher(label.value());
  if (!m.find()) {
    return false;
  }

  matcher.matched = leaf.parent(tree).deepCopy();
  
  TreeFactory tf = matcher.matched.treeFactory();

  OffsetLabel newLeafLabel = new OffsetLabel(m.group(2));
  newLeafLabel.setBeginPosition(m.start(2) + label.beginPosition());
  newLeafLabel.setEndPosition(m.end(2) + label.beginPosition());
  
  leaf = tf.newLeaf(newLeafLabel);
  matcher.trigger = tf.newTreeNode(matcher.matched.value(), Collections.singletonList(leaf));
  
  newLeafLabel = new OffsetLabel(m.group(1));
  newLeafLabel.setBeginPosition(m.start(1) + label.beginPosition());
  newLeafLabel.setEndPosition(m.end(1) + label.beginPosition());
  
  leaf = tf.newLeaf(newLeafLabel);
  matcher.argument = tf.newTreeNode(matcher.matched.value(), Collections.singletonList(leaf));

  matcher.matched.removeChild(0);
  matcher.matched.addChild(matcher.argument);
  matcher.matched.addChild(matcher.trigger);
  return true;
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
@Override
public TreeFactory treeFactory() {
  return OffsetTreeFactory.instance();
}
 

import edu.stanford.nlp.trees.TreeFactory; //导入依赖的package包/类
public FragDiscardingPennTreeReader(Reader in, TreeFactory tf, TreeNormalizer tn, Tokenizer<String> tk) {
  super(in, tf, tn, tk);
}