void free_linkage(Linkage linkage)
{
size_t j;
exfree((void *) linkage->word, sizeof(const char *) * linkage->num_words);
exfree(linkage->chosen_disjuncts, linkage->num_words * sizeof(Disjunct *));
free(linkage->link_array);
/* Q: Why isn't this in a string set ?? A: Because there is no
* string-set handy when we compute this. */
if (linkage->disjunct_list_str)
{
for (j=0; j<linkage->num_words; j++)
{
if (linkage->disjunct_list_str[j])
free(linkage->disjunct_list_str[j]);
}
free(linkage->disjunct_list_str);
}
#ifdef USE_CORPUS
lg_sense_delete(linkage);
#endif
linkage_free_pp_info(linkage);
/* XXX FIXME */
free(linkage->wg_path);
free(linkage->wg_path_display);
}
void exfree_connectors(Connector *e) {
Connector * n;
for(;e != NULL; e = n) {
n = e->next;
exfree(e->string, sizeof(char)*(strlen(e->string)+1));
exfree(e, sizeof(Connector));
}
}
void exfree_pp_info(PP_info ppi) {
int i;
for (i=0; i<ppi.num_domains; ++i) {
exfree(ppi.domain_name[i], strlen(ppi.domain_name[i])+1);
}
if (ppi.num_domains > 0)
exfree(ppi.domain_name, sizeof(char *)*ppi.num_domains);
}
void linkage_free_constituent_tree(CNode * n)
{
CNode *m, *x;
for (m=n->child; m!=NULL; m=x) {
x=m->next;
linkage_free_constituent_tree(m);
}
exfree(n->label, sizeof(char)*(strlen(n->label)+1));
exfree(n, sizeof(CNode));
}
static void free_linkages(Sentence sent)
{
size_t in;
Linkage lkgs = sent->lnkages;
if (!lkgs) return;
for (in=0; in<sent->num_linkages_alloced; in++)
{
size_t j;
Linkage linkage = &lkgs[in];
exfree((void *) linkage->word, sizeof(const char *) * linkage->num_words);
exfree(linkage->chosen_disjuncts, linkage->num_words * sizeof(Disjunct *));
free(linkage->link_array);
/* Q: Why isn't this in a string set ?? A: Because there is no
* string-set handy when we compute this. */
if (linkage->disjunct_list_str)
{
for (j=0; j<linkage->num_words; j++)
{
if (linkage->disjunct_list_str[j])
free(linkage->disjunct_list_str[j]);
}
free(linkage->disjunct_list_str);
}
#ifdef USE_CORPUS
lg_sense_delete(linkage);
#endif
/* Note: linkage->hpsg_pp_data.domain_array originally got
* allocated in sent->constituent_pp->pp_data. */
post_process_free_domain_array(&linkage->hpsg_pp_data);
free(linkage->hpsg_pp_data.domain_array);
linkage_free_pp_info(linkage);
/* XXX FIXME */
free(linkage->wg_path);
free(linkage->wg_path_display);
}
exfree(lkgs, sent->num_linkages_alloced * sizeof(struct Linkage_s));
sent->num_linkages_alloced = 0;
sent->num_linkages_found = 0;
sent->num_linkages_post_processed = 0;
sent->num_valid_linkages = 0;
sent->lnkages = NULL;
}
void append_string(String * string, const char *fmt, ...)
{
#define TMPLEN 1024
char temp_string[TMPLEN];
size_t templen;
char * p;
size_t new_size;
va_list args;
va_start(args, fmt);
templen = vsnprintf(temp_string, TMPLEN, fmt, args);
va_end(args);
if (string->allocated <= string->eos + templen)
{
new_size = 2 * string->allocated + templen + 1;
p = (char *) exalloc(sizeof(char)*new_size);
strcpy(p, string->p);
strcpy(p + string->eos, temp_string);
exfree(string->p, sizeof(char)*string->allocated);
string->p = p;
string->allocated = new_size;
string->eos += templen;
}
else
{
strcpy(string->p + string->eos, temp_string);
string->eos += templen;
}
}
void exfree_domain_names(PP_info *ppi)
{
if (ppi->num_domains > 0)
exfree((void *) ppi->domain_name, sizeof(const char *) * ppi->num_domains);
ppi->domain_name = NULL;
ppi->num_domains = 0;
}
static void replace_link_name(Link l, const char *s)
{
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;
}
void linkage_delete(Linkage linkage) {
int i, j;
Sublinkage *s;
for (i=0; i<linkage->num_words; ++i) {
exfree(linkage->word[i], strlen(linkage->word[i])+1);
}
exfree(linkage->word, sizeof(char *)*linkage->num_words);
for (i=0; i<linkage->num_sublinkages; ++i) {
s = &(linkage->sublinkage[i]);
for (j=0; j<s->num_links; ++j) {
exfree_link(s->link[j]);
}
exfree(s->link, sizeof(Link)*s->num_links);
if (s->pp_info != NULL) {
for (j=0; j<s->num_links; ++j) {
exfree_pp_info(s->pp_info[j]);
}
exfree(s->pp_info, sizeof(PP_info)*s->num_links);
post_process_free_data(&s->pp_data);
}
if (s->violation != NULL) {
exfree(s->violation, sizeof(char)*(strlen(s->violation)+1));
}
}
exfree(linkage->sublinkage, sizeof(Sublinkage)*linkage->num_sublinkages);
exfree(linkage, sizeof(struct Linkage_s));
}
void linkage_free_pp_info(Linkage lkg)
{
size_t j;
if (!lkg || !lkg->pp_info) return;
for (j = 0; j < lkg->num_links; ++j)
exfree_domain_names(&lkg->pp_info[j]);
exfree(lkg->pp_info, sizeof(PP_info) * lkg->num_links);
lkg->pp_info = NULL;
}
/**
* Print out the constituent tree.
* mode 1: treebank-style constituent tree
* mode 2: flat, bracketed tree [A like [B this B] A]
* mode 3: flat, treebank-style tree (A like (B this) )
*/
char * linkage_print_constituent_tree(Linkage linkage, int mode)
{
String * cs;
CNode * root;
char * p;
if ((mode == 0) || (linkage->sent->dict->constituent_pp == NULL))
{
return NULL;
}
else if (mode == 1 || mode == 3)
{
cs = String_create();
root = linkage_constituent_tree(linkage);
print_tree(cs, (mode==1), root, 0, 0);
linkage_free_constituent_tree(root);
append_string(cs, "\n");
p = exalloc(strlen(cs->p)+1);
strcpy(p, cs->p);
exfree(cs->p, sizeof(char)*cs->allocated);
exfree(cs, sizeof(String));
return p;
}
else if (mode == 2)
{
char * str;
con_context_t *ctxt;
ctxt = (con_context_t *) malloc(sizeof(con_context_t));
str = print_flat_constituents(ctxt, linkage);
free(ctxt);
return str;
}
assert(0, "Illegal mode in linkage_print_constituent_tree");
return NULL;
}
static CNode * linkage_constituent_tree(Linkage linkage)
{
char *p, *q, *saveptr;
int len;
CNode * root;
p = print_flat_constituents(linkage);
len = strlen(p);
q = strtok_r(p, " ", &saveptr);
assert(token_type(q) == OPEN_TOK, "Illegal beginning of string");
root = make_CNode(q+1);
root = parse_string(root, &saveptr);
assign_spans(root, 0);
exfree(p, sizeof(char)*(len+1));
return root;
}
static void free_linkages(Sentence sent)
{
size_t in;
Linkage lkgs = sent->lnkages;
if (!lkgs) return;
for (in=0; in<sent->num_linkages_alloced; in++)
{
free_linkage(&lkgs[in]);
}
exfree(lkgs, sent->num_linkages_alloced * sizeof(struct Linkage_s));
sent->num_linkages_alloced = 0;
sent->num_linkages_found = 0;
sent->num_linkages_post_processed = 0;
sent->num_valid_linkages = 0;
sent->lnkages = NULL;
}
void append_string(String * string, const char *fmt, ...)
{
#define TMPLEN 1024
char temp_string[TMPLEN];
size_t templen;
char * p;
size_t new_size;
va_list args;
#ifdef _MSC_VER
char * tmp = alloca(strlen(fmt)+1);
char * tok = tmp;
strcpy(tmp, fmt);
while ((tok = strstr(tok, "%zu"))) { tok[1] = 'I'; tok++;}
fmt = tmp;
#endif
va_start(args, fmt);
templen = vsnprintf(temp_string, TMPLEN, fmt, args);
va_end(args);
if (string->allocated <= string->eos + templen)
{
new_size = 2 * string->allocated + templen + 1;
p = (char *) exalloc(sizeof(char)*new_size);
strcpy(p, string->p);
strcpy(p + string->eos, temp_string);
exfree(string->p, sizeof(char)*string->allocated);
string->p = p;
string->allocated = new_size;
string->eos += templen;
}
else
{
strcpy(string->p + string->eos, temp_string);
string->eos += templen;
}
}
int linkage_compute_union(Linkage linkage) {
int i, num_subs=linkage->num_sublinkages;
Sublinkage * new_sublinkage;
if (linkage->unionized) {
linkage->current = linkage->num_sublinkages-1;
return 0;
}
if (num_subs == 1) {
linkage->unionized = TRUE;
return 1;
}
new_sublinkage =
(Sublinkage *) exalloc(sizeof(Sublinkage)*(num_subs+1));
for (i=0; i<num_subs; ++i) {
new_sublinkage[i] = linkage->sublinkage[i];
}
exfree(linkage->sublinkage, sizeof(Sublinkage)*num_subs);
linkage->sublinkage = new_sublinkage;
linkage->sublinkage[num_subs] = unionize_linkage(linkage);
/* The domain data will not be needed for the union -- zero it out */
linkage->sublinkage[num_subs].pp_data.N_domains=0;
linkage->sublinkage[num_subs].pp_data.length=0;
linkage->sublinkage[num_subs].pp_data.links_to_ignore=NULL;
for (i=0; i<MAX_SENTENCE; ++i) {
linkage->sublinkage[num_subs].pp_data.word_links[i] = NULL;
}
linkage->num_sublinkages++;
linkage->unionized = TRUE;
linkage->current = linkage->num_sublinkages-1;
return 1;
}
void exfree_link(Link l) {
exfree_connectors(l->rc);
exfree_connectors(l->lc);
exfree(l->name, sizeof(char)*(strlen(l->name)+1));
exfree(l, sizeof(struct Link_s));
}
void linkage_free_constituent_tree_str(char * s)
{
exfree(s, strlen(s)+1);
}
/* This is provided as part of the API */
void string_delete(char * p) {
exfree(p, strlen(p)+1);
}
static int
prformat(Sfio_t* sp, void* vp, Sffmt_t* dp)
{
register Fmt_t* fmt = (Fmt_t*)dp;
register Exnode_t* node;
register char* s;
register char* txt;
int n;
int from;
int to;
time_t tm;
dp->flags |= SFFMT_VALUE;
if (fmt->args)
{
if (node = (dp->fmt == '*') ? fmt->args->param[dp->size] : fmt->args->arg)
fmt->value = exeval(fmt->expr, node, fmt->env);
else
fmt->value.integer = 0;
to = fmt->args->arg->type;
}
else if (!(fmt->actuals = fmt->actuals->data.operand.right))
exerror("printf: not enough arguments");
else
{
node = fmt->actuals->data.operand.left;
from = node->type;
switch (dp->fmt)
{
case 'f':
case 'g':
to = FLOATING;
break;
case 's':
case '[':
to = STRING;
break;
default:
switch (from)
{
case INTEGER:
case UNSIGNED:
to = from;
break;
default:
to = INTEGER;
break;
}
break;
}
if (to == from)
fmt->value = exeval(fmt->expr, node, fmt->env);
else
{
node = excast(fmt->expr, node, to, NiL, 0);
fmt->value = exeval(fmt->expr, node, fmt->env);
node->data.operand.left = 0;
exfree(fmt->expr, node);
if (to == STRING)
{
if (fmt->value.string)
{
n = strlen(fmt->value.string);
if (s = fmtbuf(n + 1))
memcpy(s, fmt->value.string, n + 1);
vmfree(fmt->expr->vm, fmt->value.string);
fmt->value.string = s;
}
if (!fmt->value.string)
fmt->value.string = "";
}
}
}
switch (to)
{
case STRING:
*((char**)vp) = fmt->value.string;
fmt->fmt.size = -1;
break;
case FLOATING:
*((double*)vp) = fmt->value.floating;
fmt->fmt.size = sizeof(double);
break;
default:
*((Sflong_t*)vp) = fmt->value.integer;
dp->size = sizeof(Sflong_t);
break;
}
if (dp->n_str > 0)
{
if (!fmt->tmp && !(fmt->tmp = sfstropen()))
txt = exnospace();
else
{
sfprintf(fmt->tmp, "%.*s", dp->n_str, dp->t_str);
txt = exstash(fmt->tmp, NiL);
}
}
else
txt = 0;
switch (dp->fmt)
{
case 'q':
case 'Q':
s = *((char**)vp);
*((char**)vp) = fmtquote(s, "$'", "'", strlen(s), 0);
dp->fmt = 's';
dp->size = -1;
break;
case 'S':
dp->flags &= ~SFFMT_LONG;
s = *((char**)vp);
if (txt)
{
if (streq(txt, "identifier"))
{
if (*s && !isalpha(*s))
*s++ = '_';
for (; *s; s++)
if (!isalnum(*s))
*s = '_';
}
else if (streq(txt, "invert"))
{
for (; *s; s++)
if (isupper(*s))
*s = tolower(*s);
else if (islower(*s))
*s = toupper(*s);
}
else if (streq(txt, "lower"))
{
for (; *s; s++)
if (isupper(*s))
*s = tolower(*s);
}
else if (streq(txt, "upper"))
{
for (; *s; s++)
if (islower(*s))
*s = toupper(*s);
}
else if (streq(txt, "variable"))
{
for (; *s; s++)
if (!isalnum(*s) && *s != '_')
*s = '.';
}
}
dp->fmt = 's';
dp->size = -1;
break;
case 't':
case 'T':
if ((tm = *((Sflong_t*)vp)) == -1)
tm = time(NiL);
*((char**)vp) = fmttime(txt ? txt : "%?%K", tm);
dp->fmt = 's';
dp->size = -1;
break;
}
return 0;
}
/* This is provided as part of the API */
void string_delete(wchar_t * p) {
exfree(p, sizeof(wchar_t)*(wcslen(p)+1));
}
void string_delete(String *s)
{
exfree(s->p, s->allocated*sizeof(char));
exfree(s, sizeof(String));
}
void linkage_post_process(Linkage linkage, Postprocessor * postprocessor) {
int N_sublinkages = linkage_get_num_sublinkages(linkage);
Parse_Options opts = linkage->opts;
Sentence sent = linkage->sent;
Sublinkage * subl;
PP_node * pp;
int i, j, k;
D_type_list * d;
for (i=0; i<N_sublinkages; ++i) {
subl = &linkage->sublinkage[i];
if (subl->pp_info != NULL) {
for (j=0; j<subl->num_links; ++j) {
exfree_pp_info(subl->pp_info[j]);
}
post_process_free_data(&subl->pp_data);
exfree(subl->pp_info, sizeof(PP_info)*subl->num_links);
}
subl->pp_info = (PP_info *) exalloc(sizeof(PP_info)*subl->num_links);
for (j=0; j<subl->num_links; ++j) {
subl->pp_info[j].num_domains = 0;
subl->pp_info[j].domain_name = NULL;
}
if (subl->violation != NULL) {
exfree(subl->violation, sizeof(char)*(strlen(subl->violation)+1));
subl->violation = NULL;
}
if (linkage->info.improper_fat_linkage) {
pp = NULL;
} else {
pp = post_process(postprocessor, opts, sent, subl, FALSE);
/* This can return NULL, for example if there is no
post-processor */
}
if (pp == NULL) {
for (j=0; j<subl->num_links; ++j) {
subl->pp_info[j].num_domains = 0;
subl->pp_info[j].domain_name = NULL;
}
}
else {
for (j=0; j<subl->num_links; ++j) {
k=0;
for (d = pp->d_type_array[j]; d!=NULL; d=d->next) k++;
subl->pp_info[j].num_domains = k;
if (k > 0) {
subl->pp_info[j].domain_name = (char **) exalloc(sizeof(char *)*k);
}
k = 0;
for (d = pp->d_type_array[j]; d!=NULL; d=d->next) {
subl->pp_info[j].domain_name[k] = (char *) exalloc(sizeof(char)*2);
sprintf(subl->pp_info[j].domain_name[k], "%c", d->type);
k++;
}
}
subl->pp_data = postprocessor->pp_data;
if (pp->violation != NULL) {
subl->violation =
(char *) exalloc(sizeof(char)*(strlen(pp->violation)+1));
strcpy(subl->violation, pp->violation);
}
}
}
post_process_close_sentence(postprocessor);
}
static char * exprint_constituent_structure(con_context_t *ctxt, Linkage linkage, int numcon_total)
{
int c, w;
int leftdone[MAXCONSTITUENTS];
int rightdone[MAXCONSTITUENTS];
int best, bestright, bestleft;
Sentence sent;
char s[100], * p;
String * cs = String_create();
assert (numcon_total < MAXCONSTITUENTS, "Too many constituents");
sent = linkage_get_sentence(linkage);
for(c=0; c<numcon_total; c++) {
leftdone[c]=0;
rightdone[c]=0;
}
if(verbosity>=2)
printf("\n");
for(w=1; w<linkage->num_words; w++) {
/* Skip left wall; don't skip right wall, since it may
have constituent boundaries */
while(1) {
best = -1;
bestright = -1;
for(c=0; c<numcon_total; c++) {
if ((ctxt->constituent[c].left==w) &&
(leftdone[c]==0) && (ctxt->constituent[c].valid==1) &&
(ctxt->constituent[c].right >= bestright)) {
best = c;
bestright = ctxt->constituent[c].right;
}
}
if (best==-1)
break;
leftdone[best]=1;
if(ctxt->constituent[best].aux==1) continue;
append_string(cs, "%c%s ", OPEN_BRACKET, ctxt->constituent[best].type);
}
if (w<linkage->num_words-1) {
/* Don't print out right wall */
strcpy(s, sent->word[w].string);
/* Now, if the first character of the word was
originally uppercase, we put it back that way */
if (sent->word[w].firstupper ==1 )
upcase_utf8_str(s, s, MAX_WORD);
append_string(cs, "%s ", s);
}
while(1) {
best = -1;
bestleft = -1;
for(c=0; c<numcon_total; c++) {
if ((ctxt->constituent[c].right==w) &&
(rightdone[c]==0) && (ctxt->constituent[c].valid==1) &&
(ctxt->constituent[c].left > bestleft)) {
best = c;
bestleft = ctxt->constituent[c].left;
}
}
if (best==-1)
break;
rightdone[best]=1;
if (ctxt->constituent[best].aux==1)
continue;
append_string(cs, "%s%c ", ctxt->constituent[best].type, CLOSE_BRACKET);
}
}
append_string(cs, "\n");
p = exalloc(strlen(cs->p)+1);
strcpy(p, cs->p);
exfree(cs->p, sizeof(char)*cs->allocated);
exfree(cs, sizeof(String));
return p;
}