grammar_police 0.1.0

data/c/link-grammar/read-dict.h

@@ -0,0 +1,29 @@
+/*************************************************************************/
+/* Copyright (c) 2004                                                    */
+/* Daniel Sleator, David Temperley, and John Lafferty                    */
+/* 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.   */
+/*                                                                       */
+/*************************************************************************/
+
+int  read_dictionary(Dictionary dict);
+void dict_display_word_info(Dictionary dict, const char * s);
+void dict_display_word_expr(Dictionary dict, const char * s);
+void print_dictionary_data(Dictionary dict);
+void print_dictionary_words(Dictionary dict);
+void print_expression(Exp *);
+int  boolean_dictionary_lookup(Dictionary dict, const char *);
+int  delete_dictionary_words(Dictionary dict, const char *);
+
+Dict_node * dictionary_lookup_list(Dictionary dict, const char *);
+Dict_node * abridged_lookup_list(Dictionary dict, const char *);
+void free_lookup_list(Dict_node *);
+
+Dict_node * insert_dict(Dictionary dict, Dict_node * n, Dict_node * newnode);
+void        free_dictionary(Dictionary dict);
+Exp *       Exp_create(Dictionary dict);

data/c/link-grammar/read-regex.c

@@ -0,0 +1,161 @@
+/*************************************************************************/
+/* Copyright (c) 2005 Sampo Pyysalo                                      */
+/*                                                                       */
+/* 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.   */
+/*                                                                       */
+/*************************************************************************/
+
+#include <string.h>
+#include "link-includes.h"
+#include "api-structures.h"
+#include "structures.h"
+#include "read-regex.h"
+
+/*
+  Function for reading regular expression name:pattern combinations
+  into the Dictionary from a given file.
+
+  The format of the regex file is as follows:
+  
+  Lines starting with "%" are comments and are ignored.
+  All other nonempty lines must follow the following format:
+  
+      REGEX_NAME:  /pattern/
+  
+  here REGEX_NAME is an identifying unique name for the regex.
+  This name is used to determine the disjuncts that will be assigned to
+  tokens matching the pattern, so in the dictionary file (e.g. 4.0.dict) 
+  you must have something like
+
+     REGEX_NAME:  (({@MX+} & (JG- or <noun-main-s>)) or YS+)) or AN+ or G+);
+
+  using the same name. The pattern itself must be surrounded by slashes.
+  Extra whitespace is ignored.
+*/
+
+#define MAX_REGEX_NAME_LENGTH 50
+#define MAX_REGEX_LENGTH      255
+
+int read_regex_file(Dictionary dict, const char *file_name)
+{
+	Regex_node **tail = &dict->regex_root; /* Last Regex_node * in list */
+	Regex_node *new_re;
+	char name[MAX_REGEX_NAME_LENGTH];
+	char regex[MAX_REGEX_LENGTH];
+	int c,prev,i,line=1;
+	FILE *fp;
+	
+	fp = dictopen(file_name, "r");
+	if (fp == NULL)
+	{
+		prt_error("Error: cannot open regex file %s\n", file_name);
+		return 1;
+	}
+
+	/* read in regexs. loop broken on EOF. */
+	while (1)
+	{
+		/* skip whitespace and comments. */
+		do
+		{
+			do
+			{ 
+				c = fgetc(fp);
+				if (c == '\n') { line++; }
+			}
+			while(isspace(c));
+
+			if (c == '%')
+			{
+				while ((c != EOF) && (c != '\n')) { c = fgetc(fp); }
+				line++;
+			}
+		}
+		while(isspace(c));
+
+		if (c == EOF) { break; } /* done. */
+
+		/* read in the name of the regex. */
+		i = 0;
+		do
+		{
+			if (i > MAX_REGEX_NAME_LENGTH-1)
+			{
+				prt_error("Error: Regex name too long on line %d\n", line);
+				goto failure;
+			}
+			name[i++] = c;
+			c = fgetc(fp);
+		}
+		while ((!isspace(c)) && (c != ':') && (c != EOF));
+		name[i] = '\0';
+		
+		/* Skip possible whitespace after name, expect colon. */
+		while (isspace(c))
+		{ 
+			if (c == '\n') { line++; }
+			c = fgetc(fp); 
+		}
+		if (c != ':')
+		{
+			prt_error("Error: Regex missing colon on line %d\n", line);
+			goto failure;
+		}
+
+		/* Skip whitespace after colon, expect slash. */
+		do
+		{
+			if (c == '\n') { line++; }
+			c = fgetc(fp); 
+		}
+		while (isspace(c));
+		if (c != '/') {
+			prt_error("Error: Regex missing leading slash on line %d\n", line);
+			goto failure;
+		}
+
+		/* Read in the regex. */
+		prev = 0;
+		i = 0;
+		do
+		{
+			if (i > MAX_REGEX_LENGTH-1)
+			{
+				prt_error("Error: Regex too long on line %d\n", line);
+				goto failure;
+			}
+			prev = c;
+			c = fgetc(fp);
+			regex[i++] = c;
+		}
+		while ((c != '/' || prev == '\\') && (c != EOF));
+		regex[i-1] = '\0';
+
+		/* Expect termination by a slash. */
+		if (c != '/')
+		{
+			prt_error("Error: Regex missing trailing slash on line %d\n", line);
+			goto failure;
+		}
+
+		/* Create new Regex_node and add to dict list. */
+		new_re = (Regex_node *) malloc(sizeof(Regex_node));
+		new_re->name    = strdup(name);
+		new_re->pattern = strdup(regex);
+		new_re->re      = NULL;
+		new_re->next    = NULL;
+		*tail = new_re;
+		tail	= &new_re->next;
+	}
+
+	fclose(fp);
+	return 0;
+failure:
+	fclose(fp);
+	return 1;
+}
+

data/c/link-grammar/read-regex.h

@@ -0,0 +1,12 @@
+/*************************************************************************/
+/* Copyright (c) 2005 Sampo Pyysalo                                      */
+/*                                                                       */
+/* 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.   */
+/*                                                                       */
+/*************************************************************************/
+
+int read_regex_file(Dictionary dict, const char *file_name);

data/c/link-grammar/regex-morph.c

@@ -0,0 +1,126 @@
+/*************************************************************************/
+/* Copyright (c) 2005  Sampo Pyysalo                                     */
+/* 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.   */
+/*                                                                       */
+/*************************************************************************/
+
+/* On MS Windows, regex.h fails to pull in size_t, so work around this by
+ * including <stddef.h> before <regex.h> (<sys/types.h> is not enough) */
+#include <stddef.h>
+#include <regex.h>
+#include "api-structures.h"
+#include "link-includes.h"
+#include "read-dict.h"
+#include "regex-morph.h"
+#include "structures.h"
+
+/**
+ * Support for the regular-expression based token matching system
+ * using standard POSIX regex.
+ */
+
+/* Compiles all the regexs in the Dictionary. Returns 0 on success,
+ * else an error code.
+ */
+int compile_regexs(Dictionary dict)
+{
+	regex_t *preg;
+	int rc;
+
+	Regex_node *re = dict->regex_root;
+	while (re != NULL)
+	{
+		/* If re->re non-null, assume compiled already. */
+		if(re->re == NULL)
+		{
+			/* Compile with default options (0) and default character
+			 * tables (NULL). */
+			/* re->re = pcre_compile(re->pattern, 0, &error, &erroroffset, NULL); */
+			preg = (regex_t *) malloc (sizeof(regex_t));
+			re->re = preg;
+			rc = regcomp(preg, re->pattern, REG_EXTENDED);
+			if (rc)
+			{
+				/*
+				prt_error("Error: Failed to compile regex '%s' (%s) at %d: %s\n",
+								re->pattern, re->name, erroroffset, error);
+				*/
+				prt_error("Error: Failed to compile regex '%s' (%s)\n",
+								re->pattern, re->name);
+				return rc;
+			}
+
+			/* Check that the regex name is defined in the dictionary. */
+			if (!boolean_dictionary_lookup(dict, re->name))
+			{
+				/* TODO: better error handing. Maybe remove the regex? */
+				prt_error("Error: Regex name %s not found in dictionary!\n",
+				       re->name);
+			}
+		}
+		re = re->next;
+	}
+	return 0;
+}
+
+/**
+ * Tries to match each regex in turn to word s.
+ * On match, returns the name of the first matching regex.
+ * If no match is found, returns NULL.
+ */
+const char *match_regex(Dictionary dict, const char *s)
+{
+	int rc;
+
+	Regex_node *re = dict->regex_root;
+	while (re != NULL)
+	{
+		if (re->re == NULL)
+		{
+			/* Re not compiled; if this happens, it's likely an
+			 *  internal error, but nevermind for now.  */
+			continue;
+		}
+		/* Try to match with no extra data (NULL), whole str (0 to strlen(s)),
+		 * and default options (second 0). */
+		/* int rc = pcre_exec(re->re, NULL, s, strlen(s), 0,
+		 *                    0, ovector, PCRE_OVEC_SIZE); */
+
+		rc = regexec((regex_t*) re->re, s, 0, NULL, 0);
+		if (0 == rc)
+		{
+			return re->name; /* match found. just return--no multiple matches. */
+		}
+		else if (rc != REG_NOMATCH)
+		{
+			/* We have an error. TODO: more appropriate error handling.*/
+			fprintf(stderr,"Regex matching error %d occurred!\n", rc);
+		}
+		re = re->next;
+	}
+	return NULL; /* no matches. */
+}
+
+/**
+ * Delete associated storage
+ */
+void free_regexs(Dictionary dict)
+{
+	Regex_node *re = dict->regex_root;
+	while (re != NULL)
+	{
+		Regex_node *next = re->next;
+		regfree((regex_t *)re->re);
+		free(re->re);
+		free(re->name);
+		free(re->pattern);
+		free(re);
+		re = next;
+	}
+}

data/c/link-grammar/regex-morph.h

@@ -0,0 +1,17 @@
+/*************************************************************************/
+/* Copyright (c) 2005  Sampo Pyysalo                                     */
+/* 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.   */
+/*                                                                       */
+/*************************************************************************/
+
+#include "api-structures.h"
+
+int compile_regexs(Dictionary);
+const char *match_regex(Dictionary, const char *);
+void free_regexs(Dictionary dict);

data/c/link-grammar/resources.c

@@ -0,0 +1,180 @@
+/*************************************************************************/
+/* Copyright (c) 2004                                                    */
+/* Daniel Sleator, David Temperley, and John Lafferty                    */
+/* 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.   */
+/*                                                                       */
+/*************************************************************************/
+
+#include "api.h"
+#include "api.c"
+
+#include <time.h>
+
+#if !defined(_WIN32)
+   #include <sys/time.h>
+   #include <sys/resource.h>
+#endif
+
+#if defined(__linux__)
+/* based on reading the man page for getrusage on linux, I inferred that
+   I needed to include this.  However it doesn't seem to be necessary */
+   #include <unistd.h>
+#endif
+
+#if defined(__hpux__)
+  #include <sys/syscall.h>
+  int syscall(int, int, struct rusage *rusage);  /* can't find
+													the prototype for this */
+  #define getrusage(a, b)  syscall(SYS_GETRUSAGE, (a), (b))
+#endif /* __hpux__ */
+
+#if defined(__sun__)
+int getrusage(int who, struct rusage *rusage);
+/* Declaration missing from sys/resource.h in sun operating systems (?) */
+#endif /* __sun__ */
+
+#define MAX_PARSE_TIME_UNLIMITED -1
+#define MAX_MEMORY_UNLIMITED ((size_t) -1)
+
+/** returns the current usage time clock in seconds */
+static double current_usage_time(void)
+{
+#if !defined(_WIN32)
+	struct rusage u;
+	getrusage (RUSAGE_SELF, &u);
+	return (u.ru_utime.tv_sec + ((double) u.ru_utime.tv_usec) / 1000000.0);
+#else
+	return ((double) clock())/CLOCKS_PER_SEC;
+#endif
+}
+
+Resources resources_create(void)
+{
+	Resources r;
+
+	r = (Resources) xalloc(sizeof(struct Resources_s));
+	r->max_parse_time = MAX_PARSE_TIME_UNLIMITED;
+	r->when_created = current_usage_time();
+	r->when_last_called = current_usage_time();
+	r->time_when_parse_started = current_usage_time();
+	r->space_when_parse_started = get_space_in_use();
+	r->max_memory = MAX_MEMORY_UNLIMITED;
+	r->cumulative_time = 0;
+	r->memory_exhausted = FALSE;
+	r->timer_expired = FALSE;
+
+	return r;
+}
+
+void resources_delete(Resources r)
+{
+	xfree(r, sizeof(struct Resources_s));
+}
+
+void resources_reset(Resources r)
+{
+	r->when_last_called = r->time_when_parse_started = current_usage_time();
+	r->space_when_parse_started = get_space_in_use();
+	r->timer_expired = FALSE;
+	r->memory_exhausted = FALSE;
+}
+
+#if 0
+static void resources_reset_time(Resources r)
+{
+	r->when_last_called = r->time_when_parse_started = current_usage_time();
+}
+#endif
+
+void resources_reset_space(Resources r)
+{
+	r->space_when_parse_started = get_space_in_use();
+}
+
+int resources_exhausted(Resources r)
+{
+	if (resources_timer_expired(r)) {
+		r->timer_expired = TRUE;
+	}
+	if (resources_memory_exhausted(r)) {
+		r->memory_exhausted = TRUE;
+	}
+	return (r->timer_expired || r->memory_exhausted);
+}
+
+int resources_timer_expired(Resources r)
+{
+	if (r->max_parse_time == MAX_PARSE_TIME_UNLIMITED) return 0;
+	else return (r->timer_expired || 
+	     (current_usage_time() - r->time_when_parse_started > r->max_parse_time));
+}
+
+int resources_memory_exhausted(Resources r)
+{
+	if (r->max_memory == MAX_MEMORY_UNLIMITED) return 0;
+	else return (r->memory_exhausted || (get_space_in_use() > r->max_memory));
+}
+
+/** print out the cpu ticks since this was last called */
+static void resources_print_time(int verbosity, Resources r, const char * s)
+{
+	double new_t;
+	new_t = current_usage_time();
+	if (verbosity > 1) {
+		printf("++++");
+		left_print_string(stdout, s,
+			"                                     ");
+		printf("%7.2f seconds\n", new_t - r->when_last_called);
+	}
+	r->when_last_called = new_t;
+}
+
+/** print out the cpu ticks since this was last called */
+static void resources_print_total_time(int verbosity, Resources r)
+{
+	double new_t;
+	new_t = current_usage_time();
+	r->cumulative_time += (new_t - r->time_when_parse_started) ;
+	if (verbosity > 0) {
+		printf("++++");
+		left_print_string(stdout, "Time",
+		                  "                                           ");
+		printf("%7.2f seconds (%.2f total)\n",
+			   new_t - r->time_when_parse_started, r->cumulative_time);
+	}
+	r->time_when_parse_started = new_t;
+}
+
+static void resources_print_total_space(int verbosity, Resources r)
+{
+	if (verbosity > 1) {
+		printf("++++");
+		left_print_string(stdout, "Total space",
+		                  "                                            ");
+		printf("%lu bytes (%lu max)\n", 
+			(long unsigned int) get_space_in_use(), 
+			(long unsigned int) get_max_space_used());
+	}
+}
+
+void print_time(Parse_Options opts, const char * s)
+{
+	resources_print_time(opts->verbosity, opts->resources, s);
+}
+
+void parse_options_print_total_time(Parse_Options opts)
+{
+	resources_print_total_time(opts->verbosity, opts->resources);
+}
+
+void print_total_space(Parse_Options opts)
+{
+	resources_print_total_space(opts->verbosity, opts->resources);
+}
+