Postprocessor * post_process_open(char *dictname, char *path)
{
/* read rules from path and initialize the appropriate fields in
a postprocessor structure, a pointer to which is returned.
The only reason we need the dictname is to used it for the
path, in case there is no DICTPATH set up. If the dictname
is null, and there is no DICTPATH, it just uses the filename
as the full path.
*/
Postprocessor *pp;
if (path==NULL) return NULL;
pp = (Postprocessor *) xalloc (sizeof(Postprocessor));
pp->knowledge = pp_knowledge_open(dictname, path);
pp->sentence_link_name_set = string_set_create();
pp->set_of_links_of_sentence = pp_linkset_open(1024);
pp->set_of_links_in_an_active_rule=pp_linkset_open(1024);
pp->relevant_contains_one_rules =
(int *) xalloc ((pp->knowledge->n_contains_one_rules+1)
*(sizeof pp->relevant_contains_one_rules[0]));
pp->relevant_contains_none_rules =
(int *) xalloc ((pp->knowledge->n_contains_none_rules+1)
*(sizeof pp->relevant_contains_none_rules[0]));
pp->relevant_contains_one_rules[0] = -1;
pp->relevant_contains_none_rules[0] = -1;
pp->pp_node = NULL;
pp->pp_data.links_to_ignore = NULL;
pp->n_local_rules_firing = 0;
pp->n_global_rules_firing = 0;
return pp;
}
static pp_linkset *read_link_set(pp_knowledge *k,
const char *label, String_set *ss)
{
/* read link set, marked by label in knowledge file, into a set of links
whose handle is returned. Return NULL if link set not defined in file,
in which case the set is taken to be empty. */
int n_strings,i;
pp_linkset *ls;
if (!pp_lexer_set_label(k->lt, label))
{
if (verbosity_level(+D_PPK))
prt_error("Warning: File %s: Link set %s not defined: assuming empty\n",
k->path, label);
n_strings = 0;
}
else
{
n_strings = pp_lexer_count_tokens_of_label(k->lt);
if (-1 == n_strings) return &LINK_SET_ERROR;
}
ls = pp_linkset_open(n_strings);
for (i=0; i<n_strings; i++)
pp_linkset_add(ls,
string_set_add(pp_lexer_get_next_token_of_label(k->lt),ss));
return ls;
}
static void read_contains_rules(pp_knowledge *k, const char *label,
pp_rule **rules, int *nRules)
{
/* Reading the 'contains_one_rules' and reading the
'contains_none_rules' into their respective arrays */
int n_commas, n_tokens, i, r;
const char *p;
const char **tokens;
if (!pp_lexer_set_label(k->lt, label)) {
*nRules = 0;
if (verbosity>0) printf("PP warning: Not using any %s rules\n", label);
}
else {
n_commas = pp_lexer_count_commas_of_label(k->lt);
*nRules = (n_commas + 1)/3;
}
*rules = (pp_rule*) xalloc ((1+*nRules)*sizeof(pp_rule));
for (r=0; r<*nRules; r++)
{
/* first read link */
tokens = pp_lexer_get_next_group_of_tokens_of_label(k->lt, &n_tokens);
if (n_tokens>1)
{
prt_error("Fatal Error: post_process: Invalid syntax in %s (rule %i)",label,r+1);
exit(1);
}
(*rules)[r].selector = string_set_add(tokens[0], k->string_set);
/* read link set */
tokens = pp_lexer_get_next_group_of_tokens_of_label(k->lt, &n_tokens);
(*rules)[r].link_set = pp_linkset_open(n_tokens);
(*rules)[r].link_set_size = n_tokens;
(*rules)[r].link_array = (const char **) xalloc((1+n_tokens)*sizeof(const char*));
for (i=0; i<n_tokens; i++)
{
p = string_set_add(tokens[i], k->string_set);
pp_linkset_add((*rules)[r].link_set, p);
(*rules)[r].link_array[i] = p;
}
(*rules)[r].link_array[i]=0; /* NULL-terminator */
/* read error message */
tokens = pp_lexer_get_next_group_of_tokens_of_label(k->lt, &n_tokens);
if (n_tokens>1)
{
prt_error("Fatal Error: post_process: Invalid syntax in %s (rule %i)",label,r+1);
exit(1);
}
(*rules)[r].msg = string_set_add(tokens[0], k->string_set);
}
/* sentinel entry */
(*rules)[*nRules].msg = 0;
}
/**
* read rules from path and initialize the appropriate fields in
* a postprocessor structure, a pointer to which is returned.
*/
Postprocessor * post_process_new(pp_knowledge * kno)
{
Postprocessor *pp;
pp = (Postprocessor *) malloc (sizeof(Postprocessor));
pp->knowledge = kno;
pp->string_set = string_set_create();
pp->set_of_links_of_sentence = pp_linkset_open(1024);
pp->set_of_links_in_an_active_rule = pp_linkset_open(1024);
pp->relevant_contains_one_rules =
(int *) malloc ((pp->knowledge->n_contains_one_rules + 1)
*(sizeof pp->relevant_contains_one_rules[0]));
pp->relevant_contains_none_rules =
(int *) malloc ((pp->knowledge->n_contains_none_rules + 1)
*(sizeof pp->relevant_contains_none_rules[0]));
pp->relevant_contains_one_rules[0] = -1;
pp->relevant_contains_none_rules[0] = -1;
pp->pp_node = NULL;
pp->n_local_rules_firing = 0;
pp->n_global_rules_firing = 0;
pp->q_pruned_rules = false;
/* 60 is just starting size, these are expanded if needed */
pp->vlength = 60;
pp->visited = (bool*) malloc(pp->vlength * sizeof(bool));
memset(pp->visited, 0, pp->vlength * sizeof(bool));
pp->pp_data.links_to_ignore = NULL;
pp->pp_data.domlen = 60;
pp->pp_data.domain_array = (Domain*) malloc(pp->pp_data.domlen * sizeof(Domain));
memset(pp->pp_data.domain_array, 0, pp->pp_data.domlen * sizeof(Domain));
pp->pp_data.wowlen = 60;
pp->pp_data.word_links = (List_o_links **) malloc(pp->pp_data.wowlen * sizeof(List_o_links*));
memset(pp->pp_data.word_links, 0, pp->pp_data.wowlen * sizeof(List_o_links *));
return pp;
}
/**
* read rules from path and initialize the appropriate fields in
* a postprocessor structure, a pointer to which is returned.
*/
Postprocessor * post_process_new(pp_knowledge * kno)
{
Postprocessor *pp;
PP_data *pp_data;
pp = (Postprocessor *) malloc (sizeof(Postprocessor));
pp->knowledge = kno;
pp->string_set = string_set_create();
pp->set_of_links_of_sentence = pp_linkset_open(1024);
pp->set_of_links_in_an_active_rule = pp_linkset_open(1024);
pp->relevant_contains_one_rules =
(int *) malloc ((pp->knowledge->n_contains_one_rules + 1)
*(sizeof pp->relevant_contains_one_rules[0]));
pp->relevant_contains_none_rules =
(int *) malloc ((pp->knowledge->n_contains_none_rules + 1)
*(sizeof pp->relevant_contains_none_rules[0]));
pp->relevant_contains_one_rules[0] = -1;
pp->relevant_contains_none_rules[0] = -1;
pp->pp_node = NULL;
pp->n_local_rules_firing = 0;
pp->n_global_rules_firing = 0;
pp->q_pruned_rules = false;
pp_data = &pp->pp_data;
pp_data->vlength = PP_INITLEN;
pp_data->visited = (bool*) malloc(pp_data->vlength * sizeof(bool));
memset(pp_data->visited, 0, pp_data->vlength * sizeof(bool));
pp_data->links_to_ignore = NULL;
pp_new_domain_array(pp_data);
pp_data->wowlen = PP_INITLEN;
pp_data->word_links = (List_o_links **) malloc(pp_data->wowlen * sizeof(List_o_links*));
memset(pp_data->word_links, 0, pp_data->wowlen * sizeof(List_o_links *));
return pp;
}
static void initialize_set_of_links_starting_bounded_domain(pp_knowledge *k)
{
int i,j,d,domain_of_rule;
k->set_of_links_starting_bounded_domain =
pp_linkset_open(PP_MAX_UNIQUE_LINK_NAMES);
for (i=0; k->bounded_rules[i].msg!=0; i++)
{
domain_of_rule = k->bounded_rules[i].domain;
for (j=0; (d=(k->starting_link_lookup_table[j].domain))!=-1; j++)
if (d==domain_of_rule)
pp_linkset_add(k->set_of_links_starting_bounded_domain,
k->starting_link_lookup_table[j].starting_link);
}
}
static bool read_form_a_cycle_rules(pp_knowledge *k, const char *label)
{
size_t n_commas, n_tokens;
size_t r, i;
pp_linkset *lsHandle;
const char **tokens;
if (!pp_lexer_set_label(k->lt, label)) {
k->n_form_a_cycle_rules = 0;
if (verbosity_level(+D_PPK))
prt_error("Warning: File %s: Not using any 'form a cycle' rules\n",
k->path);
}
else {
n_commas = pp_lexer_count_commas_of_label(k->lt);
k->n_form_a_cycle_rules = (n_commas + 1)/2;
}
k->form_a_cycle_rules=
(pp_rule*) malloc ((1+k->n_form_a_cycle_rules)*sizeof(pp_rule));
for (r=0; r<k->n_form_a_cycle_rules; r++)
{
/* read link set */
tokens = pp_lexer_get_next_group_of_tokens_of_label(k->lt, &n_tokens);
if (n_tokens <= 0)
{
prt_error("Error: File %s: Syntax error\n", k->path);
return false;
}
lsHandle = pp_linkset_open(n_tokens);
for (i=0; i<n_tokens; i++)
pp_linkset_add(lsHandle,string_set_add(tokens[i], k->string_set));
k->form_a_cycle_rules[r].link_set = lsHandle;
/* read error message */
tokens = pp_lexer_get_next_group_of_tokens_of_label(k->lt, &n_tokens);
if (n_tokens > 1)
{
prt_error("Error: File %s: Invalid syntax (rule %zu of %s)\n",
k->path, r+1,label);
return false;
}
k->form_a_cycle_rules[r].msg = string_set_add(tokens[0], k->string_set);
k->form_a_cycle_rules[r].use_count = 0;
}
/* sentinel entry */
k->form_a_cycle_rules[k->n_form_a_cycle_rules].msg = 0;
k->form_a_cycle_rules[k->n_form_a_cycle_rules].use_count = 0;
return true;
}
static void read_form_a_cycle_rules(pp_knowledge *k, const char *label)
{
int n_commas, n_tokens, r, i;
pp_linkset *lsHandle;
const char **tokens;
if (!pp_lexer_set_label(k->lt, label)) {
k->n_form_a_cycle_rules = 0;
if (verbosity>0)
printf("PP warning: Not using any 'form a cycle' rules\n");
}
else {
n_commas = pp_lexer_count_commas_of_label(k->lt);
k->n_form_a_cycle_rules = (n_commas + 1)/2;
}
k->form_a_cycle_rules=
(pp_rule*) xalloc ((1+k->n_form_a_cycle_rules)*sizeof(pp_rule));
for (r=0; r<k->n_form_a_cycle_rules; r++)
{
/* read link set */
tokens = pp_lexer_get_next_group_of_tokens_of_label(k->lt, &n_tokens);
if (n_tokens <= 0)
{
prt_error("Fatal Error: syntax error in knowledge file");
exit(1);
}
lsHandle = pp_linkset_open(n_tokens);
for (i=0; i<n_tokens; i++)
pp_linkset_add(lsHandle,string_set_add(tokens[i], k->string_set));
k->form_a_cycle_rules[r].link_set=lsHandle;
/* read error message */
tokens = pp_lexer_get_next_group_of_tokens_of_label(k->lt, &n_tokens);
if (n_tokens > 1)
{
prt_error("Fatal Error: post_process: Invalid syntax (rule %i of %s)",r+1,label);
exit(1);
}
k->form_a_cycle_rules[r].msg=string_set_add(tokens[0],k->string_set);
}
/* sentinel entry */
k->form_a_cycle_rules[k->n_form_a_cycle_rules].msg = 0;
}
static pp_linkset *read_link_set(pp_knowledge *k,
const char *label, String_set *ss)
{
/* read link set, marked by label in knowledge file, into a set of links
whose handle is returned. Return NULL if link set not defined in file,
in which case the set is taken to be empty. */
int n_strings,i;
pp_linkset *ls;
if (!pp_lexer_set_label(k->lt, label)) {
if (verbosity>0)
printf("PP warning: Link set %s not defined: assuming empty.\n",label);
n_strings = 0;
}
else n_strings = pp_lexer_count_tokens_of_label(k->lt);
ls = pp_linkset_open(n_strings);
for (i=0; i<n_strings; i++)
pp_linkset_add(ls,
string_set_add(pp_lexer_get_next_token_of_label(k->lt),ss));
return ls;
}
static bool read_contains_rules(pp_knowledge *k, const char *label,
pp_rule **rules, size_t *nRules)
{
/* Reading the 'contains_one_rules' and reading the
'contains_none_rules' into their respective arrays */
size_t n_tokens, i, r;
int n_commas;
const char *p;
const char **tokens;
if (!pp_lexer_set_label(k->lt, label)) {
*nRules = 0;
if (verbosity_level(+D_PPK))
prt_error("Warning: File %s: Not using any %s rules\n", k->path, label);
}
else {
n_commas = pp_lexer_count_commas_of_label(k->lt);
if (-1 == n_commas) return false;
*nRules = (n_commas + 1)/3;
}
*rules = (pp_rule*) malloc ((1+*nRules)*sizeof(pp_rule));
for (r=0; r<*nRules; r++)
{
/* first read link */
tokens = pp_lexer_get_next_group_of_tokens_of_label(k->lt, &n_tokens);
if (n_tokens > 1)
{
prt_error("Error: File %s: Invalid syntax in %s (rule %zu)\n",
k->path, label, r+1);
return false;
}
(*rules)[r].selector = string_set_add(tokens[0], k->string_set);
/* read link set */
tokens = pp_lexer_get_next_group_of_tokens_of_label(k->lt, &n_tokens);
(*rules)[r].link_set = pp_linkset_open(n_tokens);
(*rules)[r].link_set_size = n_tokens;
(*rules)[r].link_array = (const char **) malloc((1+n_tokens)*sizeof(const char*));
for (i=0; i<n_tokens; i++)
{
p = string_set_add(tokens[i], k->string_set);
pp_linkset_add((*rules)[r].link_set, p);
(*rules)[r].link_array[i] = p;
}
(*rules)[r].link_array[i]=0; /* NULL-terminator */
/* read error message */
tokens = pp_lexer_get_next_group_of_tokens_of_label(k->lt, &n_tokens);
if (n_tokens > 1)
{
prt_error("Error: File %s: Invalid syntax in %s (rule %zu)\n",
k->path, label, r+1);
return false;
}
(*rules)[r].msg = string_set_add(tokens[0], k->string_set);
(*rules)[r].use_count = 0;
}
/* sentinel entry */
(*rules)[*nRules].msg = 0;
(*rules)[*nRules].use_count = 0;
return true;
}
