grammar_cop 0.1.0

data/ext/link_grammar/link-grammar/analyze-linkage.c

@@ -0,0 +1,1317 @@
+/*************************************************************************/
+/* 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 <stdarg.h>
+#include "api.h"
+
+/**
+ * The functions in this file do several things: () take a linkage
+ * involving fat links and expand it into a sequence of linkages
+ * (involving a subset of the given words), one for each way of
+ * eliminating the conjunctions.  () determine if a linkage involving
+ * fat links has a structural violation.  () make sure each of the expanded
+ * linkages has a consistent post-processing behavior.  () compute the
+ * cost of the linkage.
+ */
+
+typedef struct patch_element_struct Patch_element;
+struct patch_element_struct
+{
+	char used;   /* TRUE if this link is used, else FALSE  */
+	char changed;/* TRUE if this link changed, else FALSE  */
+	int newl;    /* the new value of the left end          */
+	int newr;    /* the new value of the right end         */
+};
+
+struct analyze_context_s
+{
+	List_o_links *word_links[MAX_SENTENCE]; /* ptr to l.o.l. out of word */
+	int structure_violation;
+
+	int dfs_root_word[MAX_SENTENCE]; /* for the depth-first search */
+	int dfs_height[MAX_SENTENCE];    /* to determine the order to do the root word dfs */
+	int height_perm[MAX_SENTENCE];   /* permute the vertices from highest to lowest */
+
+	/* The following are all for computing the cost of and lists */
+	int visited[MAX_SENTENCE];
+	int and_element_sizes[MAX_SENTENCE];
+	int and_element[MAX_SENTENCE];
+	int N_and_elements;
+	int outside_word[MAX_SENTENCE];
+	int N_outside_words;
+	Patch_element patch_array[MAX_LINKS];
+};
+
+typedef struct CON_node_struct CON_node;
+typedef struct CON_list_struct CON_list;
+typedef struct DIS_list_struct DIS_list;
+typedef struct Links_to_patch_struct Links_to_patch;
+
+struct DIS_node_struct
+{
+	CON_list * cl;     /* the list of children */
+	List_o_links * lol;/* the links that comprise this region of the graph */
+	int word;          /* the word defining this node */
+};
+
+struct CON_node_struct
+{
+	DIS_list * dl;     /* the list of children */
+	DIS_list * current;/* defines the current child */
+	int word;          /* the word defining this node */
+};
+
+struct DIS_list_struct
+{
+	DIS_list * next;
+	DIS_node * dn;
+};
+
+struct CON_list_struct
+{
+	CON_list * next;
+	CON_node * cn;
+};
+
+struct Links_to_patch_struct
+{
+	Links_to_patch * next;
+	int link;
+	char dir;   /* this is 'r' or 'l' depending on which end of the link
+				      is to be patched. */
+};
+
+void zero_sublinkage(Sublinkage *s)
+{
+	int i;
+	s->pp_info = NULL;
+	s->violation = NULL;
+	for (i=0; i<s->num_links; i++) s->link[i] = NULL;
+
+	memset(&s->pp_data, 0, sizeof(PP_data));
+}
+
+static Sublinkage * x_create_sublinkage(Parse_info pi)
+{
+	Sublinkage *s = (Sublinkage *) xalloc (sizeof(Sublinkage));
+	s->link = (Link **) xalloc(MAX_LINKS*sizeof(Link *));
+	s->num_links = MAX_LINKS;
+
+	zero_sublinkage(s);
+
+	s->num_links = pi->N_links;
+	assert(pi->N_links < MAX_LINKS, "Too many links");
+	return s;
+}
+
+static Sublinkage * ex_create_sublinkage(Parse_info pi)
+{
+	Sublinkage *s = (Sublinkage *) exalloc (sizeof(Sublinkage));
+	s->link = (Link **) exalloc(pi->N_links*sizeof(Link *));
+	s->num_links = pi->N_links;
+
+	zero_sublinkage(s);
+
+	assert(pi->N_links < MAX_LINKS, "Too many links");
+	return s;
+}
+
+static void free_sublinkage(Sublinkage *s)
+{
+	int i;
+	for (i=0; i<MAX_LINKS; i++) {
+		if (s->link[i]!=NULL) exfree_link(s->link[i]);
+	}
+	xfree(s->link, MAX_LINKS*sizeof(Link));
+	xfree(s, sizeof(Sublinkage));
+}
+
+static void replace_link_name(Link *l, const char *s)
+{
+	/* XXX can get some perf improvement by avoiding strlen! */
+	char * t;
+	exfree((char *) l->name, sizeof(char)*(strlen(l->name)+1));
+	t = (char *) exalloc(sizeof(char)*(strlen(s)+1));
+	strcpy(t, s);
+	l->name = t;
+}
+
+static void copy_full_link(Link **dest, Link *src)
+{
+	if (*dest != NULL) exfree_link(*dest);
+	*dest = excopy_link(src);
+}
+
+/* end new code 9/97 ALB */
+
+
+/**
+ * Constructs a graph in the wordlinks array based on the contents of
+ * the global link_array.  Makes the wordlinks array point to a list of
+ * words neighboring each word (actually a list of links).  This is a
+ * directed graph, constructed for dealing with "and".  For a link in
+ * which the priorities are UP or DOWN_priority, the edge goes from the
+ * one labeled DOWN to the one labeled UP.
+ * Don't generate links edges for the bogus comma connectors.
+ */
+static void build_digraph(analyze_context_t *actx, Parse_info pi)
+{
+	int i, link, N_fat;
+	Link *lp;
+	List_o_links * lol;
+	N_fat = 0;
+
+	for (i = 0; i < pi->N_words; i++)
+	{
+		actx->word_links[i] = NULL;
+	}
+
+	for (link = 0; link < pi->N_links; link++)
+	{
+		lp = &(pi->link_array[link]);
+		i = lp->lc->label;
+		if (i < NORMAL_LABEL) {   /* one of those special links for either-or, etc */
+			continue;
+		}
+
+		lol = (List_o_links *) xalloc(sizeof(List_o_links));
+		lol->next = actx->word_links[lp->l];
+		actx->word_links[lp->l] = lol;
+		lol->link = link;
+		lol->word = lp->r;
+		i = lp->lc->priority;
+		if (i == THIN_priority) {
+			lol->dir = 0;
+		} else if (i == DOWN_priority) {
+			lol->dir = 1;
+		} else {
+			lol->dir = -1;
+		}
+
+		lol = (List_o_links *) xalloc(sizeof(List_o_links));
+		lol->next = actx->word_links[lp->r];
+		actx->word_links[lp->r] = lol;
+		lol->link = link;
+		lol->word = lp->l;
+		i = lp->rc->priority;
+		if (i == THIN_priority) {
+			lol->dir = 0;
+		} else if (i == DOWN_priority) {
+			lol->dir = 1;
+		} else {
+			lol->dir = -1;
+		}
+	}
+}
+
+/**
+ * Returns TRUE if there is at least one fat link pointing out of this word.
+ */
+static int is_CON_word(int w, List_o_links **wordlinks)
+{
+	List_o_links * lol;
+	for (lol = wordlinks[w]; lol != NULL; lol = lol->next)
+	{
+		if (lol->dir == 1) return TRUE;
+	}
+	return FALSE;
+}
+
+static DIS_node * build_DIS_node(analyze_context_t*, int);
+
+/**
+ * This word is a CON word (has fat links down).  Build the tree for it.
+ */
+static CON_node * build_CON_node(analyze_context_t *actx, int w)
+{
+	List_o_links * lol;
+	CON_node * a;
+	DIS_list * d, *dx;
+	d = NULL;
+	for (lol = actx->word_links[w]; lol != NULL; lol = lol->next)
+	{
+		if (lol->dir == 1)
+		{
+			dx = (DIS_list *) xalloc (sizeof (DIS_list));
+			dx->next = d;
+			d = dx;
+			d->dn = build_DIS_node(actx, lol->word);
+		}
+	}
+	a = (CON_node *) xalloc(sizeof (CON_node));
+	a->dl = a->current = d;
+	a->word = w;
+	return a;
+}
+
+/**
+ * Does a depth-first-search starting from w.  Puts on the front of the
+ * list pointed to by c all of the CON nodes it finds, and returns the
+ * result.  Also construct the list of all edges reached as part of this
+ * DIS_node search and append it to the lol list of start_dn.
+ *
+ * Both of the structure violations actually occur, and represent
+ * linkages that have improper structure.  Fortunately, they
+ * seem to be rather rare.
+ */
+static CON_list * c_dfs(analyze_context_t *actx,
+                        int w, DIS_node * start_dn, CON_list * c)
+{
+	CON_list *cx;
+	List_o_links * lol, *lolx;
+	if (actx->dfs_root_word[w] != -1)
+	{
+		if (actx->dfs_root_word[w] != start_dn->word)
+		{
+			actx->structure_violation = TRUE;
+		}
+		return c;
+	}
+	actx->dfs_root_word[w] = start_dn->word;
+	for (lol = actx->word_links[w]; lol != NULL; lol = lol->next)
+	{
+		if (lol->dir < 0)  /* a backwards link */
+		{
+			if (actx->dfs_root_word[lol->word] == -1)
+			{
+				actx->structure_violation = TRUE;
+			}
+		}
+		else if (lol->dir == 0)
+		{
+			/* Make a copy of the link */
+			lolx = (List_o_links *) xalloc(sizeof(List_o_links));
+			lolx->word = lol->word;
+			lolx->dir = lol->dir;
+			lolx->link = lol->link;
+
+			/* Chain it into place */
+			lolx->next = start_dn->lol;
+			start_dn->lol = lolx;
+			c = c_dfs(actx, lol->word, start_dn, c);
+		}
+	}
+
+	/* if the current node is CON, put it first */
+	if (is_CON_word(w, actx->word_links))
+	{
+		cx = (CON_list *) xalloc(sizeof(CON_list));
+		cx->next = c;
+		c = cx;
+		c->cn = build_CON_node(actx, w);
+	}
+	return c;
+}
+
+/**
+ * This node is connected to its parent via a fat link.  Search the
+ * region reachable via thin links, and put all reachable nodes with fat
+ * links out of them in its list of children.
+ */
+static DIS_node * build_DIS_node(analyze_context_t *actx,
+                                 int w)
+{
+	DIS_node * dn;
+	dn = (DIS_node *) xalloc(sizeof (DIS_node));
+	dn->word = w;   /* must do this before dfs so it knows the start word */
+	dn->lol = NULL;
+	dn->cl = c_dfs(actx, w, dn, NULL);
+	return dn;
+}
+
+static void height_dfs(analyze_context_t *actx, int w, int height)
+{
+	List_o_links * lol;
+	if (actx->dfs_height[w] != 0) return;
+
+	actx->dfs_height[w] = height;
+
+	for (lol = actx->word_links[w]; lol != NULL; lol = lol->next)
+	{
+		/* The dir is 1 for a down link. */
+		height_dfs(actx, lol->word, height - lol->dir);
+	}
+}
+
+/**
+ * Simple insertion sort; should be plenty fast enough, since sentences
+ * are almost always shorter than 30 words or so. In fact, this is
+ * almost surely faster than qsort for such small arrays.
+ */
+static void insort (analyze_context_t *actx, int nwords)
+{
+	int i, j;
+	for (i=1; i<nwords; i++)
+	{
+		int heig = actx->dfs_height[i];
+		int perm = actx->height_perm[i];
+		j = i;
+		while (j>0 && (heig > actx->dfs_height[j-1]))
+		{
+			actx->dfs_height[j] = actx->dfs_height[j-1];
+			actx->height_perm[j] = actx->height_perm[j-1];
+			j--;
+		}
+		actx->dfs_height[j] = heig;
+		actx->height_perm[j] = perm;
+	}
+}
+
+static DIS_node * build_DIS_CON_tree(analyze_context_t *actx, Parse_info pi)
+{
+	int xw, w;
+	DIS_node * dnroot, * dn;
+	CON_list * child, * xchild;
+	List_o_links * lol, * xlol;
+
+	/* The algorithm used here to build the DIS_CON tree depends on
+	 * the search percolating down from the "top" of the tree.  The
+	 * original version of this started its search at the wall.  This
+	 * was fine because doing a DFS from the wall explores the tree in
+	 * the right order.
+	 *
+	 * However, in order to handle null links correctly, a more careful
+	 * ordering process must be used to explore the tree.  We use
+	 * dfs_height[] for this, and sort in height order.
+	 *
+	 * XXX Is the sort order correct here? This is not obvious; I think
+	 * we want highest to lowest ...  XXX is the height being calculated
+	 * correctly? Looks weird to me ... XXX
+	 */
+
+	for (w=0; w < pi->N_words; w++) actx->dfs_height[w] = 0;
+	for (w=0; w < pi->N_words; w++) height_dfs(actx, w, MAX_SENTENCE);
+
+	for (w=0; w < pi->N_words; w++) actx->height_perm[w] = w;
+
+	/* Sort the heights, keeping only the permuted order. */
+	insort (actx, pi->N_words);
+
+	for (w=0; w<pi->N_words; w++) actx->dfs_root_word[w] = -1;
+
+	dnroot = NULL;
+	for (xw = 0; xw < pi->N_words; xw++)
+	{
+		w = actx->height_perm[xw];
+		if (actx->dfs_root_word[w] == -1)
+		{
+			dn = build_DIS_node(actx, w);
+			if (dnroot == NULL)
+			{
+				dnroot = dn;
+			}
+			else
+			{
+				for (child = dn->cl; child != NULL; child = xchild)
+				{
+					xchild = child->next;
+					child->next = dnroot->cl;
+					dnroot->cl = child;
+				}
+				for (lol = dn->lol; lol != NULL; lol = xlol)
+				{
+					xlol = lol->next;
+					lol->next = dnroot->lol;
+					dnroot->lol = lol;
+				}
+				xfree((void *) dn, sizeof(DIS_node));
+			}
+		}
+	}
+	return dnroot;
+}
+
+static int advance_CON(CON_node *);
+
+/**
+ * Cyclically advance the current state of this DIS node.
+ * If it's now at the beginning of its cycle, return FALSE;
+ * otherwise return TRUE. Together with the advance_CON()
+ * function, this can be used to iterate over the entire 
+ * DIS_CON tree.
+ */
+static int advance_DIS(DIS_node * dn)
+{
+	CON_list * cl;
+	for (cl = dn->cl; cl != NULL; cl = cl->next)
+	{
+		if (advance_CON(cl->cn)) return TRUE;
+	}
+	return FALSE;
+}
+
+/**
+ * Cyclically advance the current state of this CON node.
+ * If it's now at the beginning of its cycle return FALSE,
+ * otherwise return TRUE. Together with the advance_CON()
+ * function, this can be used to iterate over the entire 
+ * DIS_CON tree.
+ */
+static int advance_CON(CON_node * cn)
+{
+	if (advance_DIS(cn->current->dn))
+	{
+		return TRUE;
+	}
+	else
+	{
+		if (cn->current->next == NULL)
+		{
+			cn->current = cn->dl;
+			return FALSE;
+		}
+		else
+		{
+			cn->current = cn->current->next;
+			return TRUE;
+		}
+	}
+}
+
+static void fill_patch_array_CON(analyze_context_t *, CON_node *, Links_to_patch *);
+
+/**
+ * Patches up appropriate links in the patch_array for this DIS_node
+ * and this patch list.
+ */
+static void fill_patch_array_DIS(analyze_context_t *actx,
+                                 DIS_node * dn, Links_to_patch * ltp)
+{
+	CON_list * cl;
+	List_o_links * lol;
+	Links_to_patch * ltpx;
+
+	for (lol = dn->lol; lol != NULL; lol = lol->next)
+	{
+		actx->patch_array[lol->link].used = TRUE;
+	}
+
+	if ((dn->cl == NULL) || (dn->cl->cn->word != dn->word))
+	{
+		for (; ltp != NULL; ltp = ltpx)
+		{
+			ltpx = ltp->next;
+			actx->patch_array[ltp->link].changed = TRUE;
+			if (ltp->dir == 'l')
+			{
+				actx->patch_array[ltp->link].newl = dn->word;
+			}
+			else
+			{
+				actx->patch_array[ltp->link].newr = dn->word;
+			}
+			xfree((void *) ltp, sizeof(Links_to_patch));
+		}
+	}
+
+	/* ltp != NULL at this point means that dn has child which is a cn
+	   which is the same word */
+	for (cl = dn->cl; cl != NULL; cl = cl->next)
+	{
+		fill_patch_array_CON(actx, cl->cn, ltp);
+		ltp = NULL;
+	}
+}
+
+static void fill_patch_array_CON(analyze_context_t *actx,
+                                 CON_node * cn, Links_to_patch * ltp)
+{
+	List_o_links * lol;
+	Links_to_patch *ltpx;
+
+	for (lol = actx->word_links[cn->word]; lol != NULL; lol = lol->next)
+	{
+		if (lol->dir == 0)
+		{
+			ltpx = (Links_to_patch *) xalloc(sizeof(Links_to_patch));
+			ltpx->next = ltp;
+			ltp = ltpx;
+			ltp->link = lol->link;
+			if (lol->word > cn->word) {
+				ltp->dir = 'l';
+			} else {
+				ltp->dir = 'r';
+			}
+		}
+	}
+	fill_patch_array_DIS(actx, cn->current->dn, ltp);
+}
+
+static void free_digraph(analyze_context_t *actx, Parse_info pi)
+{
+	List_o_links * lol, *lolx;
+	int i;
+	for (i = 0; i < pi->N_words; i++)
+	{
+		for (lol = actx->word_links[i]; lol != NULL; lol = lolx)
+		{
+			lolx = lol->next;
+			xfree((void *) lol, sizeof(List_o_links));
+		}
+	}
+}
+
+static void free_CON_tree(CON_node *);
+
+void free_DIS_tree(DIS_node * dn)
+{
+	List_o_links * lol, *lolx;
+	CON_list *cl, *clx;
+	for (lol = dn->lol; lol != NULL; lol = lolx)
+	{
+		lolx = lol->next;
+		xfree((void *) lol, sizeof(List_o_links));
+	}
+	for (cl = dn->cl; cl != NULL; cl = clx)
+	{
+		clx = cl->next;
+		free_CON_tree(cl->cn);
+		xfree((void *) cl, sizeof(CON_list));
+	}
+	xfree((void *) dn, sizeof(DIS_node));
+}
+
+static void free_CON_tree(CON_node * cn)
+{
+	DIS_list *dl, *dlx;
+	for (dl = cn->dl; dl != NULL; dl = dlx)
+	{
+		dlx = dl->next;
+		free_DIS_tree(dl->dn);
+		xfree((void *) dl, sizeof(DIS_list));
+	}
+	xfree((void *) cn, sizeof(CON_node));
+}
+
+/** scope out this and element */
+static void and_dfs_full(analyze_context_t *actx, int w)
+{
+	List_o_links *lol;
+	if (actx->visited[w]) return;
+	actx->visited[w] = TRUE;
+	actx->and_element_sizes[actx->N_and_elements]++;
+
+	for (lol = actx->word_links[w]; lol != NULL; lol = lol->next)
+	{
+		if (lol->dir >= 0)
+		{
+			and_dfs_full(actx, lol->word);
+		}
+	}
+}
+
+/** get down the tree past all the commas */
+static void and_dfs_commas(analyze_context_t *actx, Sentence sent, int w)
+{
+	List_o_links *lol;
+	if (actx->visited[w]) return;
+
+	actx->visited[w] = TRUE;
+
+	for (lol = actx->word_links[w]; lol != NULL; lol = lol->next)
+	{
+		/* we only consider UP or DOWN priority links here */
+		if (lol->dir == 1)
+		{
+			if (strcmp(sent->word[lol->word].string, ",") == 0)
+			{
+				/* pointing to a comma */
+				and_dfs_commas(actx, sent, lol->word);
+			}
+			else
+			{
+				actx->and_element[actx->N_and_elements] = lol->word;
+				and_dfs_full(actx, lol->word);
+				actx->N_and_elements++;
+			}
+		}
+		if (lol->dir == 0)
+		{
+		  actx->outside_word[actx->N_outside_words] = lol->word;
+		  actx->N_outside_words++;
+		}
+	}
+}
+
+/**
+ * This function computes the "and cost", resulting from inequalities
+ * in the length of and-list elements. It also computes other
+ * information used to construct the "andlist" structure of linkage_info.
+ */
+static Andlist * build_andlist(analyze_context_t *actx, Sentence sent)
+{
+	int w, i, min, max, j, cost;
+	char * s;
+	Andlist * new_andlist, * old_andlist;
+	Parse_info pi = sent->parse_info;
+
+	old_andlist = NULL;
+	cost = 0;
+
+	for(w = 0; w<pi->N_words; w++)
+	{
+		s = sent->word[w].string;
+		if (sent->is_conjunction[w])
+		{
+			actx->N_and_elements = 0;
+			actx->N_outside_words = 0;
+			for(i=0; i<pi->N_words; i++)
+			{
+				actx->visited[i] = FALSE;
+				actx->and_element_sizes[i] = 0;
+			}
+			if (sent->dict->left_wall_defined)
+				actx->visited[0] = TRUE;
+
+			and_dfs_commas(actx, sent, w);
+			if (actx->N_and_elements == 0) continue;
+
+			new_andlist = (Andlist *) xalloc(sizeof(Andlist));
+			new_andlist->num_elements = actx->N_and_elements;
+			new_andlist->num_outside_words = actx->N_outside_words;
+
+			for (i=0; i < actx->N_and_elements; i++)
+			{
+				new_andlist->element[i] = actx->and_element[i];
+			}
+			for (i=0; i < actx->N_outside_words; i++)
+			{
+				new_andlist->outside_word[i] = actx->outside_word[i];
+			}
+			new_andlist->conjunction = w;
+			new_andlist->next = old_andlist;
+			old_andlist = new_andlist;
+
+			if (actx->N_and_elements > 0)
+			{
+				min = MAX_SENTENCE;
+				max = 0;
+				for (i=0; i < actx->N_and_elements; i++)
+				{
+					j = actx->and_element_sizes[i];
+					if (j < min) min = j;
+					if (j > max) max = j;
+				}
+				cost += max-min;
+			}
+		}
+	}
+	if (old_andlist) old_andlist->cost = cost;
+	return old_andlist;
+}
+
+/**
+ * This function defines the cost of a link as a function of its length.
+ */
+static inline int cost_for_length(int length)
+{
+	  return length-1;
+}
+
+/**
+ * Computes the cost of the current parse of the current sentence,
+ * due to the length of the links.
+ */
+static int link_cost(Parse_info pi)
+{
+	int lcost, i;
+	lcost =  0;
+	for (i = 0; i < pi->N_links; i++)
+	{
+		lcost += cost_for_length(pi->link_array[i].r - pi->link_array[i].l);
+	}
+	return lcost;
+}
+
+static int null_cost(Parse_info pi)
+{
+  /* computes the number of null links in the linkage */
+  /* No one seems to care about this -- ALB */
+  return 0;
+}
+
+static int unused_word_cost(Parse_info pi)
+{
+	int lcost, i;
+	lcost =  0;
+	for (i = 0; i < pi->N_words; i++)
+		lcost += (pi->chosen_disjuncts[i] == NULL);
+	return lcost;
+}
+
+/** 
+ * Computes the cost of the current parse of the current sentence
+ * due to the cost of the chosen disjuncts.
+ */
+static float disjunct_cost(Parse_info pi)
+{
+	int i;
+	float lcost;
+	lcost =  0.0;
+	for (i = 0; i < pi->N_words; i++)
+	{
+		if (pi->chosen_disjuncts[i] != NULL)
+			lcost += pi->chosen_disjuncts[i]->cost;
+	}
+	return lcost;
+}
+
+/**
+ * Returns TRUE if string s represents a strictly smaller match set
+ * than does t.  An almost identical function appears in and.c.
+ * The difference is that here we don't require s and t to be the
+ * same length.
+ */
+static int strictly_smaller_name(const char * s, const char * t)
+{
+	int strictness, ss, tt;
+	strictness = 0;
+	while ((*s!='\0') || (*t!='\0'))
+	{
+		if (*s == '\0') {
+			ss = '*';
+		} else {
+			ss = *s;
+			s++;
+		}
+		if (*t == '\0') {
+			tt = '*';
+		} else {
+			tt = *t;
+			t++;
+		}
+		if (ss == tt) continue;
+		if ((tt == '*') || (ss == '^')) {
+			strictness++;
+		} else {
+			return FALSE;
+		}
+	}
+	return (strictness > 0);
+}
+
+/**
+ * The name of the link is set to be the GCD of the names of
+ * its two endpoints. Must be called after each extract_links(),
+ * etc. since that call issues a brand-new set of links into 
+ * parse_info.
+ */
+static void compute_link_names(Sentence sent)
+{
+	int i;
+	Parse_info pi = sent->parse_info;
+
+	for (i = 0; i < pi->N_links; i++)
+	{
+		pi->link_array[i].name = intersect_strings(sent,
+			connector_get_string(pi->link_array[i].lc),
+			connector_get_string(pi->link_array[i].rc));
+	}
+}
+
+/**
+ * This fills in the sublinkage->link[].name field.  We assume that
+ * link_array[].name have already been filled in.  As above, in the
+ * standard case, the name is just the GCD of the two end points.
+ * If pluralization has occurred, then we want to use the name
+ * already in link_array[].name.  We detect this in two ways.
+ * If the endpoints don't match, then we know pluralization
+ * has occured.  If they do, but the name in link_array[].name
+ * is *less* restrictive, then pluralization must have occured.
+ */
+static void compute_pp_link_names(Sentence sent, Sublinkage *sublinkage)
+{
+	int i;
+	const char * s;
+	Parse_info pi = sent->parse_info;
+
+	for (i = 0; i < pi->N_links; i++)
+	{
+		if (sublinkage->link[i]->l == -1) continue;
+		/* NULL's here are quite unexpected -- I think there's a bug
+		 * elsewhere in the code. But for now, punt.  Here's a sentence
+		 * that triggers a NULL -- "His convalescence was relatively brief
+		 * and he was able to return and fight at The Wilderness,
+		 * Spotsylvania and Cold Harbor."
+		 */
+		if (NULL == sublinkage->link[i]->lc) continue;
+		if (NULL == sublinkage->link[i]->rc) continue;
+		if (!x_match(sent, sublinkage->link[i]->lc, sublinkage->link[i]->rc))
+		{
+			replace_link_name(sublinkage->link[i], pi->link_array[i].name);
+		}
+		else
+		{
+			s = intersect_strings(sent,
+				connector_get_string(sublinkage->link[i]->lc),
+				connector_get_string(sublinkage->link[i]->rc));
+
+			if (strictly_smaller_name(s, pi->link_array[i].name))
+				replace_link_name(sublinkage->link[i], pi->link_array[i].name);
+			else
+				replace_link_name(sublinkage->link[i], s);
+		}
+	}
+}
+
+/********************** exported functions *****************************/
+
+void init_analyze(Sentence s)
+{
+	analyze_context_t *actx = s->analyze_ctxt;
+
+	if (NULL == actx)
+	{
+		actx = (analyze_context_t *) malloc (sizeof(analyze_context_t));
+		s->analyze_ctxt = actx;
+	}
+
+	actx->structure_violation = FALSE;
+}
+
+void free_analyze(Sentence s)
+{
+	if (s->analyze_ctxt != NULL) free(s->analyze_ctxt);
+	s->analyze_ctxt = NULL;
+}
+
+/**
+ * This uses link_array.  It enumerates and post-processes
+ * all the linkages represented by this one.  We know this contains
+ * at least one fat link.
+ */
+Linkage_info analyze_fat_linkage(Sentence sent, Parse_Options opts, int analyze_pass)
+{
+	int i;
+	Linkage_info li;
+	DIS_node *d_root;
+	PP_node *pp;
+	Postprocessor *postprocessor;
+	Sublinkage *sublinkage;
+	Parse_info pi = sent->parse_info;
+	PP_node accum;			   /* for domain ancestry check */
+	D_type_list * dtl0, * dtl1;  /* for domain ancestry check */
+
+	analyze_context_t *actx = sent->analyze_ctxt;
+
+	sublinkage = x_create_sublinkage(pi);
+	postprocessor = sent->dict->postprocessor;
+	build_digraph(actx, pi);
+	actx->structure_violation = FALSE;
+	d_root = build_DIS_CON_tree(actx, pi); /* may set structure_violation to TRUE */
+
+	memset(&li, 0, sizeof(li));
+	li.N_violations = 0;
+	li.improper_fat_linkage = actx->structure_violation;
+	li.inconsistent_domains = FALSE;
+	li.unused_word_cost = unused_word_cost(sent->parse_info);
+	if (opts->use_sat_solver)
+	{
+		li.disjunct_cost = 0.0;
+	}
+	else
+	{
+		li.disjunct_cost = disjunct_cost(pi);
+	}
+	li.null_cost = null_cost(pi);
+	li.link_cost = link_cost(pi);
+	li.corpus_cost = -1.0f;
+	li.and_cost = 0;
+	li.andlist = NULL;
+
+	if (actx->structure_violation)
+	{
+		li.N_violations++;
+		free_sublinkage(sublinkage);
+		free_digraph(actx, pi);
+		free_DIS_tree(d_root);
+		for (i = 0; i < pi->N_links; i++)
+		{
+			pi->link_array[i].name = "";
+		}
+		return li;
+	}
+
+	if (analyze_pass == PP_SECOND_PASS)
+	{
+	  li.andlist = build_andlist(actx, sent);
+	  li.and_cost = 0;
+	  if (li.andlist) li.and_cost = li.andlist->cost;
+	}
+	else li.and_cost = 0;
+
+	compute_link_names(sent);
+
+	for (i=0; i<pi->N_links; i++) accum.d_type_array[i] = NULL;
+
+	/* loop through all the sub linkages */
+	for (;;)
+	{
+		for (i=0; i<pi->N_links; i++)
+		{
+			actx->patch_array[i].used = actx->patch_array[i].changed = FALSE;
+			actx->patch_array[i].newl = pi->link_array[i].l;
+			actx->patch_array[i].newr = pi->link_array[i].r;
+			copy_full_link(&sublinkage->link[i], &(pi->link_array[i]));
+		}
+		fill_patch_array_DIS(actx, d_root, NULL);
+
+		for (i=0; i<pi->N_links; i++)
+		{
+			if (actx->patch_array[i].changed || actx->patch_array[i].used)
+			{
+				sublinkage->link[i]->l = actx->patch_array[i].newl;
+				sublinkage->link[i]->r = actx->patch_array[i].newr;
+			}
+			else if ((actx->dfs_root_word[pi->link_array[i].l] != -1) &&
+					 (actx->dfs_root_word[pi->link_array[i].r] != -1))
+			{
+				sublinkage->link[i]->l = -1;
+			}
+		}
+
+		if (0 == opts->use_sat_solver)
+		{
+			compute_pp_link_array_connectors(sent, sublinkage);
+			compute_pp_link_names(sent, sublinkage);
+		}
+
+		/* 'analyze_pass' logic added ALB 1/97 */
+		if (analyze_pass==PP_FIRST_PASS) {
+			post_process_scan_linkage(postprocessor,opts,sent,sublinkage);
+			if (!advance_DIS(d_root)) break;
+			else continue;
+		}
+
+		pp = post_process(postprocessor, opts, sent, sublinkage, TRUE);
+
+		if (pp==NULL) {
+			if (postprocessor != NULL) li.N_violations = 1;
+		}
+		else if (pp->violation == NULL)  {
+			/* the purpose of this stuff is to make sure the domain
+			   ancestry for a link in each of its sentences is consistent. */
+
+			for (i=0; i<pi->N_links; i++) {
+				if (sublinkage->link[i]->l == -1) continue;
+				if (accum.d_type_array[i] == NULL) {
+					accum.d_type_array[i] = copy_d_type(pp->d_type_array[i]);
+				} else {
+					dtl0 = pp->d_type_array[i];
+					dtl1 = accum.d_type_array[i];
+					while((dtl0 != NULL) && (dtl1 != NULL) && (dtl0->type == dtl1->type)) {
+						dtl0 = dtl0->next;
+						dtl1 = dtl1->next;
+					}
+					if ((dtl0 != NULL) || (dtl1 != NULL)) break;
+				}
+			}
+			if (i != pi->N_links) {
+				li.N_violations++;
+				li.inconsistent_domains = TRUE;
+			}
+		}
+		else if (pp->violation!=NULL) {
+			li.N_violations++;
+		}
+
+		if (!advance_DIS(d_root)) break;
+	}
+
+	for (i=0; i<pi->N_links; ++i) {
+		free_d_type(accum.d_type_array[i]);
+	}
+
+	/* if (display_on && (li.N_violations != 0) &&
+	   (verbosity > 3) && should_print_messages)
+	   printf("P.P. violation in one part of conjunction.\n"); */
+	free_sublinkage(sublinkage);
+	free_digraph(actx, pi);
+	free_DIS_tree(d_root);
+	return li;
+}
+
+/**
+ * This uses link_array.  It post-processes
+ * this linkage, and prints the appropriate thing.  There are no fat
+ * links in it.
+ */
+Linkage_info analyze_thin_linkage(Sentence sent, Parse_Options opts, int analyze_pass)
+{
+	int i;
+	Linkage_info li;
+	PP_node * pp;
+	Postprocessor * postprocessor;
+	Sublinkage *sublinkage;
+	Parse_info pi = sent->parse_info;
+	analyze_context_t *actx = sent->analyze_ctxt;
+
+	sublinkage = x_create_sublinkage(pi);
+	postprocessor = sent->dict->postprocessor;
+
+	compute_link_names(sent);
+	for (i=0; i<pi->N_links; i++)
+	{
+	  copy_full_link(&(sublinkage->link[i]), &(pi->link_array[i]));
+	}
+
+	if (analyze_pass == PP_FIRST_PASS)
+	{
+		post_process_scan_linkage(postprocessor, opts, sent, sublinkage);
+		free_sublinkage(sublinkage);
+		memset(&li, 0, sizeof(li));
+		return li;
+	}
+
+	build_digraph(actx, pi);
+
+	/* The code below can be used to generate the "islands" array.
+	 * For this to work, however, you have to call "build_digraph"
+	 * first (as in analyze_fat_linkage). and then "free_digraph".
+	 */
+	pp = post_process(postprocessor, opts, sent, sublinkage, TRUE);
+
+	memset(&li, 0, sizeof(li));
+	li.N_violations = 0;
+	li.and_cost = 0;
+	li.unused_word_cost = unused_word_cost(sent->parse_info);
+	li.improper_fat_linkage = FALSE;
+	li.inconsistent_domains = FALSE;
+	if (opts->use_sat_solver)
+	{
+		li.disjunct_cost = 0.0;
+	}
+	else
+	{
+		li.disjunct_cost = disjunct_cost(pi);
+	}
+	li.null_cost = null_cost(pi);
+	li.link_cost = link_cost(pi);
+	li.corpus_cost = -1.0f;
+	li.andlist = NULL;
+
+	if (pp == NULL)
+	{
+		if (postprocessor != NULL) li.N_violations = 1;
+	}
+	else if (pp->violation != NULL)
+	{
+		li.N_violations++;
+	}
+
+	free_sublinkage(sublinkage);
+	free_digraph(actx, pi);
+	return li;
+}
+
+void extract_thin_linkage(Sentence sent, Parse_Options opts, Linkage linkage)
+{
+	int i;
+	Parse_info pi = sent->parse_info;
+
+	linkage->num_sublinkages = 1;
+	linkage->sublinkage = ex_create_sublinkage(pi);
+
+	compute_link_names(sent);
+	for (i=0; i<pi->N_links; ++i)
+	{
+		linkage->sublinkage->link[i] = excopy_link(&(pi->link_array[i]));
+	}
+}
+
+#ifdef DBG
+static void prt_lol(Sentence sent , List_o_links *lol)
+{
+	/* It appears that the list of links is always even in length:
+	 * The head word first, followed by a modifier. 
+	 */
+	while (lol)
+	{
+		// printf ("%d ", lol->link);
+		printf ("%s ", sent->word[lol->word].string);
+		lol = lol->next;
+	}
+}
+
+static void prt_con_list(Sentence, CON_list *);
+static void prt_dis_list(Sentence sent, DIS_list *dis)
+{
+	while(dis)
+	{
+		/* There are three possibilities:
+ 		 * Either there's another conjunction (and we should print it)
+ 		 * Or there's a head word, with its modifiers in its list-o-links,
+ 		 * Or there's just the bare, naked word by itself.
+ 		 */
+		if (dis->dn->cl)
+		{
+			prt_con_list(sent, dis->dn->cl);
+		}
+		else if (dis->dn->lol)
+		{
+			printf("[");
+			prt_lol(sent, dis->dn->lol);
+			printf("]");
+		}
+		else 
+		{
+			int wd = dis->dn->word;
+			printf("%s ", sent->word[wd].string);
+		}
+		dis = dis->next;
+	}
+}
+
+static void prt_con_list(Sentence sent, CON_list *con)
+{
+	while(con)
+	{
+		int wd = con->cn->word;
+		printf("(%s ", sent->word[wd].string);
+		prt_dis_list(sent, con->cn->dl);
+		printf(") ");
+		con = con->next;
+	}
+}
+static void prt_dis_con_tree(Sentence sent, DIS_node *dis)
+{
+	prt_con_list(sent, dis->cl);
+	printf ("\n");
+}
+#else
+static inline void prt_dis_con_tree(Sentence sent, DIS_node *dis) {}
+#endif
+
+/**
+ * This procedure mimics analyze_fat_linkage in order to
+ * extract the sublinkages and copy them to the Linkage
+ * data structure passed in.
+ */
+void extract_fat_linkage(Sentence sent, Parse_Options opts, Linkage linkage)
+{
+	int i, j, N_thin_links;
+	DIS_node *d_root;
+	int num_sublinkages;
+	Sublinkage * sublinkage;
+	Parse_info pi = sent->parse_info;
+
+	analyze_context_t *actx = sent->analyze_ctxt;
+
+	build_digraph(actx, pi);
+	actx->structure_violation = FALSE;
+	d_root = build_DIS_CON_tree(actx, pi);
+
+	if (actx->structure_violation)
+	{
+		compute_link_names(sent);
+		linkage->num_sublinkages=1;
+		linkage->sublinkage = ex_create_sublinkage(pi);
+
+		/* This will have fat links! */
+		for (i=0; i<pi->N_links; ++i)
+		{
+			linkage->sublinkage->link[i] = excopy_link(&(pi->link_array[i]));
+		}
+
+		free_digraph(actx, pi);
+		free_DIS_tree(d_root);
+		return;
+	}
+
+	/* first get number of sublinkages and allocate space */
+	num_sublinkages = 0;
+	for (;;) {
+		num_sublinkages++;
+		if (!advance_DIS(d_root)) break;
+	}
+
+	linkage->num_sublinkages = num_sublinkages;
+	linkage->sublinkage =
+		(Sublinkage *) exalloc(sizeof(Sublinkage)*num_sublinkages);
+	for (i=0; i<num_sublinkages; ++i) {
+		linkage->sublinkage[i].link = NULL;
+		linkage->sublinkage[i].pp_info = NULL;
+		linkage->sublinkage[i].violation = NULL;
+	}
+
+	/* now fill out the sublinkage arrays */
+	compute_link_names(sent);
+
+	sublinkage = x_create_sublinkage(pi);
+	num_sublinkages = 0;
+	for (;;)
+	{
+		for (i = 0; i < pi->N_links; i++)
+		{
+			actx->patch_array[i].used = actx->patch_array[i].changed = FALSE;
+			actx->patch_array[i].newl = pi->link_array[i].l;
+			actx->patch_array[i].newr = pi->link_array[i].r;
+			copy_full_link(&sublinkage->link[i], &(pi->link_array[i]));
+		}
+		fill_patch_array_DIS(actx, d_root, NULL);
+
+		for (i = 0; i < pi->N_links; i++)
+		{
+			if (actx->patch_array[i].changed || actx->patch_array[i].used)
+			{
+				sublinkage->link[i]->l = actx->patch_array[i].newl;
+				sublinkage->link[i]->r = actx->patch_array[i].newr;
+			}
+			else if ((actx->dfs_root_word[pi->link_array[i].l] != -1) &&
+					   (actx->dfs_root_word[pi->link_array[i].r] != -1))
+			{
+				sublinkage->link[i]->l = -1;
+			}
+		}
+
+		if (0 == opts->use_sat_solver)
+		{
+			compute_pp_link_array_connectors(sent, sublinkage);
+			compute_pp_link_names(sent, sublinkage);
+		}
+
+		/* Don't copy the fat links into the linkage */
+		N_thin_links = 0;
+		for (i = 0; i < pi->N_links; ++i)
+		{
+			if (sublinkage->link[i]->l == -1) continue;
+			N_thin_links++;
+		}
+
+		linkage->sublinkage[num_sublinkages].num_links = N_thin_links;
+		linkage->sublinkage[num_sublinkages].link =
+			(Link **) exalloc(sizeof(Link *)*N_thin_links);
+		linkage->sublinkage[num_sublinkages].pp_info = NULL;
+		linkage->sublinkage[num_sublinkages].violation = NULL;
+
+		for (i = 0, j = 0; i < pi->N_links; ++i)
+		{
+			if (sublinkage->link[i]->l == -1) continue;
+			linkage->sublinkage[num_sublinkages].link[j++] =
+				excopy_link(sublinkage->link[i]);
+		}
+
+		num_sublinkages++;
+		if (!advance_DIS(d_root)) break;
+	}
+
+	free_sublinkage(sublinkage);
+	free_digraph(actx, pi);
+	if (linkage->dis_con_tree)
+		free_DIS_tree(linkage->dis_con_tree);
+	linkage->dis_con_tree = d_root;
+
+	prt_dis_con_tree(sent, d_root);
+}
+