grammar_cop 0.1.0

data/ext/link_grammar/link-grammar/sat-solver/word-tag.cpp

@@ -0,0 +1,159 @@
+#include "word-tag.hpp"
+#include "fast-sprintf.hpp"
+
+void WordTag::insert_connectors(Exp* exp, int& dfs_position, 
+				bool& leading_right, bool& leading_left, 
+				std::vector<int>& eps_right,
+				std::vector<int>& eps_left, 
+				char* var, bool root, int parrent_cost) {
+  int cost = parrent_cost + exp->cost;
+  if (exp->type == CONNECTOR_type) {
+    dfs_position++;
+
+    const char* name = exp->u.string;
+
+    Connector* connector = connector_new();
+    connector->multi = exp->multi;
+    connector->string = name;
+    set_connector_length_limit(connector);
+    
+
+    switch(exp->dir) {
+    case '+':
+      _position.push_back(_right_connectors.size());
+      _dir.push_back('+');
+      _right_connectors.push_back(PositionConnector(connector, '+', _word, dfs_position, exp->cost, cost, 
+						    leading_right, false, 
+						    eps_right, eps_left));
+      leading_right = false;
+      break;
+    case '-':
+      _position.push_back(_left_connectors.size());
+      _dir.push_back('-');
+      _left_connectors.push_back(PositionConnector(connector, '-', _word, dfs_position, exp->cost, cost,
+						   false, leading_left, 
+						   eps_right, eps_left));
+      leading_left = false;
+      break;
+    default:
+      throw std::string("Unknown connector direction: ") + exp->dir;
+    }
+  } else if (exp->type == AND_type) {
+    if (exp->u.l == NULL) {
+      /* zeroary and */
+    } else
+      if (exp->u.l != NULL && exp->u.l->next == NULL) {
+	/* unary and - skip */
+	insert_connectors(exp->u.l->e, dfs_position, leading_right, leading_left, eps_right, eps_left, var, root, cost);
+      } else {
+	int i;
+	E_list* l;
+
+	char new_var[MAX_VARIABLE_NAME];
+	char* last_new_var = new_var;
+	char* last_var = var;
+	while(*last_new_var = *last_var) {
+	  last_new_var++;
+	  last_var++;
+	}
+
+	for (i = 0, l = exp->u.l; l != NULL; l = l->next, i++) {
+	  char* s = last_new_var;
+	  *s++ = 'c';
+	  fast_sprintf(s, i);
+	  
+	  insert_connectors(l->e, dfs_position, leading_right, leading_left, eps_right, eps_left, new_var, false, cost);
+	  if (leading_right && var != NULL) {
+	    eps_right.push_back(_variables->epsilon(new_var, '+'));
+	  }
+
+	  
+	  if (leading_left && var != NULL) {
+	    eps_left.push_back(_variables->epsilon(new_var, '-'));
+	  }
+	}
+      }
+  } else if (exp->type == OR_type) {
+    if (exp->u.l != NULL && exp->u.l->next == NULL) {
+      /* unary or - skip */
+      insert_connectors(exp->u.l->e, dfs_position, leading_right, leading_left, eps_right, eps_left, var, root, cost);
+    } else {
+      int i;
+      E_list* l;
+      bool ll_true = false;
+      bool lr_true = false;
+
+      char new_var[MAX_VARIABLE_NAME];
+      char* last_new_var = new_var;
+      char* last_var = var;
+      while(*last_new_var = *last_var) {
+	last_new_var++;
+	last_var++;
+      }
+
+      for (i = 0, l = exp->u.l; l != NULL; l = l->next, i++) {
+	bool lr = leading_right, ll = leading_left;
+	std::vector<int> er = eps_right, el = eps_left;
+
+	char* s = last_new_var;
+	*s++ = 'd';
+	fast_sprintf(s, i);
+
+	insert_connectors(l->e, dfs_position, lr, ll, er, el, new_var, false, cost);
+	if (lr)
+	  lr_true = true;
+	if (ll)
+	  ll_true = true;
+      }
+      leading_right = lr_true;
+      leading_left = ll_true;
+    }
+  }
+}
+
+
+
+void WordTag::find_matches(int w, const char* C, char dir, std::vector<PositionConnector*>& matches) {
+  //  cout << "Look connection on: ." << _word << ". ." << w << ". " << C << dir << endl;
+  Connector search_cntr;
+  init_connector(&search_cntr);
+  search_cntr.label = NORMAL_LABEL;
+  search_cntr.priority = THIN_priority;
+  search_cntr.string = C;
+  set_connector_length_limit(&search_cntr);
+
+  std::vector<PositionConnector>* connectors;
+  switch(dir) {
+  case '+':
+    connectors = &_left_connectors;
+    break;
+  case '-':
+    connectors = &_right_connectors;
+    break;
+  default:
+    throw std::string("Unknown connector direction: ") + dir;
+  }
+
+  bool conjunction = sentence_contains_conjunction(_sent);
+  std::vector<PositionConnector>::iterator i;
+  for (i = connectors->begin(); i != connectors->end(); i++) {
+    if (WordTag::match(w, search_cntr, dir, (*i).word, *((*i).connector),  conjunction)) {
+      matches.push_back(&(*i));
+    }
+  }
+}
+
+void WordTag::add_matches_with_word(WordTag& tag) {
+  std::vector<PositionConnector>::iterator i;
+  for (i = _right_connectors.begin(); i != _right_connectors.end(); i++) {
+    std::vector<PositionConnector*> connector_matches;
+    tag.find_matches(_word, (*i).connector->string, '+', connector_matches);
+    std::vector<PositionConnector*>::iterator j;
+    for (j = connector_matches.begin(); j != connector_matches.end(); j++) {
+      i->matches.push_back(*j);
+      set_match_possible((*j)->word, (*j)->position);
+      (*j)->matches.push_back(&(*i));
+      tag.set_match_possible(_word, (*i).position);
+    }
+  }
+}

data/ext/link_grammar/link-grammar/sat-solver/word-tag.hpp

@@ -0,0 +1,162 @@
+#ifndef __WORD_TAG_HPP__
+#define __WORD_TAG_HPP__
+
+#include <vector>
+#include <map>
+#include <set>
+
+extern "C" {
+#include <link-grammar/api.h>
+}
+
+#include "variables.hpp"
+
+
+struct PositionConnector {
+  PositionConnector(Connector* c, char d, int w, int p, int cst, int pcst,
+		    bool lr, bool ll, const std::vector<int>& er, const std::vector<int>& el) 
+    : connector(c), dir(d), word(w), position(p), cost(cst), parrent_cost(pcst),
+      leading_right(lr), leading_left(ll),  
+      eps_right(er), eps_left(el) {
+    /*
+    cout << c->string << " : ." << w << ". : ." << p << ". ";
+    if (leading_right) {
+      cout << "lr: ";
+      copy(er.begin(), er.end(), ostream_iterator<int>(cout, " "));
+    }
+    if (leading_left) {
+      cout << "ll: ";
+      copy(el.begin(), el.end(), ostream_iterator<int>(cout, " "));
+    }
+    cout << endl;
+    */
+  }
+
+  // Connector itself
+  Connector* connector;
+  // Direction
+  char dir;
+  // word in a sentence that this connector belongs to
+  int word;
+  // position in the word tag
+  int position;
+  // cost of the connector
+  int cost;
+  // parrent cost
+  int parrent_cost;
+
+  bool leading_right;
+  std::vector<int> eps_right;
+  bool leading_left;
+  std::vector<int> eps_left;
+
+  // Matches with other words
+  std::vector<PositionConnector*> matches;
+
+};
+
+
+// TODO: Hash connectors for faster matching
+
+class WordTag {
+private:
+  std::vector<PositionConnector> _left_connectors;
+  std::vector<PositionConnector> _right_connectors;
+  
+  std::vector<char> _dir;
+  std::vector<int> _position;
+
+  int _word;
+  Variables* _variables;
+
+  Sentence _sent;
+  Parse_Options _opts;
+
+  // Could this word tag match a connector (wi, pi)?
+  // For each word wi I keep a set of positions pi that can be matched
+  std::vector< std::set<int> > _match_possible;
+  void set_match_possible(int wj, int pj) {
+    _match_possible[wj].insert(pj);
+  }
+
+public:
+  WordTag(int word, Variables* variables, Sentence sent, Parse_Options opts) 
+    : _word(word), _variables(variables), _sent(sent), _opts(opts) {
+    _match_possible.resize(_sent->length);
+  }
+
+  const std::vector<PositionConnector>& get_left_connectors() {
+    return _left_connectors;
+  }
+
+  const std::vector<PositionConnector>& get_right_connectors() {
+    return _right_connectors;
+  }
+
+  PositionConnector* get(int dfs_position) {
+    switch (_dir[dfs_position - 1]) {
+    case '+':
+      return &_right_connectors[_position[dfs_position - 1]];
+    case '-':
+      return &_left_connectors[_position[dfs_position - 1]];
+    }
+  }
+
+  void set_connector_length_limit(Connector* c) {
+    int short_len = _opts->short_length;
+    if (short_len > UNLIMITED_LEN) 
+      short_len = UNLIMITED_LEN;
+
+    Connector_set *conset = _sent->dict->unlimited_connector_set;
+    if (parse_options_get_all_short_connectors(_opts)) {
+      c->length_limit = short_len;
+    }
+    else if (conset == NULL || match_in_connector_set(_sent, conset, c, '+')) {
+      c->length_limit = UNLIMITED_LEN;
+    } else {
+      c->length_limit = short_len;
+    }
+  }
+
+  int match(int w1, Connector& cntr1, char dir, int w2, Connector& cntr2, bool conjunction) {
+    if (conjunction) {
+      switch (dir) {
+      case '+':
+	return ::prune_match(0, &cntr1, &cntr2);
+      case '-':
+	return ::prune_match(0, &cntr2, &cntr1);
+      default:
+	throw std::string("Unknown connector direction: ") + dir;
+      } 
+    } else {
+      return ::do_match(_sent, &cntr1, &cntr2, w1, w2);
+    }
+  }
+
+  void insert_connectors(Exp* exp, int& dfs_position, 
+			 bool& leading_right, bool& leading_left, 
+			 std::vector<int>& eps_right,
+			 std::vector<int>& eps_left, 
+			 char* var, bool root, int parrent_cost);
+
+  // Caches information about the found matches to the _matches vector, and also
+  // updates the _matches vector of all connectors in the given tag. 
+  // In order to have all possible matches correctly cached, the function assumes that it is
+  // iteratively called for all words in the sentence, where the tag is on the right side of
+  // this word
+  void add_matches_with_word(WordTag& tag);
+
+  // Find matches in this word tag with the connector (name, dir).
+  void find_matches(int w, const char* C, char dir,  std::vector<PositionConnector*>& matches);
+
+  // A simpler function: Can any connector in this word match a connector wi, pi?
+  // It is assumed that 
+  bool match_possible(int wi, int pi) {
+    return _match_possible[wi].find(pi) != _match_possible[wi].end();
+  }
+
+
+  
+};
+
+#endif

data/ext/link_grammar/link-grammar/spellcheck-aspell.c

@@ -0,0 +1,148 @@
+/*************************************************************************/
+/* Copyright (c) 2009 Vikas N. Kumar                                     */
+/* Copyright (c) 2009 Linas Vepstas                                      */
+/* All rights reserved                                                   */
+/*                                                                       */
+/* Use of the link grammar parsing system is subject to the terms of the */
+/* license set forth in the LICENSE file included with this software,    */
+/* and also available at http://www.link.cs.cmu.edu/link/license.html    */
+/* This license allows free redistribution and use in source and binary  */
+/* forms, with or without modification, subject to certain conditions.   */
+/*                                                                       */
+/*************************************************************************/
+
+#ifndef SPELLCHECK_ASPELL_C
+#define
+
+#ifdef HAVE_ASPELL
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <aspell.h>
+#include "link-includes.h"
+#include "spellcheck.h"
+#include "utilities.h"  /* For Win32 compatibility */
+
+#define ASPELL_LANG_KEY  "lang"
+static const char *spellcheck_lang_mapping[] = {
+	"en" /* link-grammar language */, "en_US" /* Aspell language key */
+};
+
+struct linkgrammar_aspell {
+	AspellConfig *config;
+	AspellSpeller *speller;
+};
+
+void * spellcheck_create(const char * lang)
+{
+	struct linkgrammar_aspell *aspell = NULL;
+	size_t i = 0;
+	AspellCanHaveError *spell_err = NULL;
+
+	for (i = 0; i < sizeof(spellcheck_lang_mapping)/sizeof(char *); i += 2)
+	{
+		if (0 != strcmp(lang, spellcheck_lang_mapping[i])) continue;
+		aspell = (struct linkgrammar_aspell *)malloc(sizeof(struct linkgrammar_aspell));
+		if (!aspell) {
+			prt_error("Error: out of memory. Aspell not used.\n");
+			aspell = NULL;
+			break;
+		}
+		aspell->config = NULL;
+		aspell->speller = NULL;
+		aspell->config = new_aspell_config();
+		if (aspell_config_replace(aspell->config, ASPELL_LANG_KEY,
+					spellcheck_lang_mapping[i]) == 0) {
+			prt_error("Error: failed to set language in aspell: %s\n", lang);
+			delete_aspell_config(aspell->config);
+			free(aspell);
+			aspell = NULL;
+			break;
+		}
+		spell_err = new_aspell_speller(aspell->config);
+		if (aspell_error_number(spell_err) != 0) {
+			prt_error("Error: Aspell: %s\n", aspell_error_message(spell_err));
+			delete_aspell_can_have_error(spell_err);
+			delete_aspell_config(aspell->config);
+			free(aspell);
+			aspell = NULL;
+			break;
+		}
+		aspell->speller = to_aspell_speller(spell_err);
+		break;
+	}
+	return aspell;
+}
+
+void spellcheck_destroy(void * chk)
+{
+	struct linkgrammar_aspell *aspell = (struct linkgrammar_aspell *)chk;
+	if (aspell) {
+		delete_aspell_speller(aspell->speller);
+		delete_aspell_config(aspell->config);
+		free(aspell);
+		aspell = NULL;
+	}
+}
+
+int spellcheck_test(void * chk, const char * word)
+{
+	int val = 0;
+	struct linkgrammar_aspell *aspell = (struct linkgrammar_aspell *)chk;
+	if (aspell && aspell->speller)  {
+		/* this can return -1 on failure */
+		val = aspell_speller_check(aspell->speller, word, -1);
+	}	
+	return (val == 1) ? 1 : 0;
+}
+
+int spellcheck_suggest(void * chk, char ***sug, const char * word)
+{
+	struct linkgrammar_aspell *aspell = (struct linkgrammar_aspell *)chk;
+	if (!sug) {
+		prt_error("Error: Aspell. Corrupt pointer.\n");
+		return 0;
+	}
+	if (aspell && aspell->speller) {
+		const AspellWordList *list = NULL;
+		AspellStringEnumeration *elem = NULL;
+		const char *aword = NULL;
+		unsigned int size, i;
+		char **array = NULL;
+
+		list = aspell_speller_suggest(aspell->speller, word, -1);
+		elem = aspell_word_list_elements(list);
+		size = aspell_word_list_size(list);
+		/* allocate an array of char* for returning back to link-parser
+		 */
+		array = (char **)malloc(sizeof(char *) * size);
+		if (!array) {
+			prt_error("Error: Aspell. Out of memory.\n");
+			delete_aspell_string_enumeration(elem);
+			return 0;
+		}
+		i = 0;
+		while ((aword = aspell_string_enumeration_next(elem)) != NULL) {
+			array[i++] = strdup(aword);
+		}
+		delete_aspell_string_enumeration(elem);
+		*sug = array;
+		return size;
+	}
+	return 0;
+}
+
+void spellcheck_free_suggest(char **sug, int size)
+{
+	int i = 0;
+	for (i = 0; i < size; ++i) {
+		free(sug[i]);
+		sug[i] = NULL;
+	}
+	free(sug);
+}
+
+#endif /* #ifdef HAVE_ASPELL */
+#endif