/**
* Read table of [link, domain type].
* This tells us what domain type each link belongs to.
* This lookup table *must* be defined in the knowledge file.
*/
static void read_starting_link_table(pp_knowledge *k)
{
const char *p;
const char label[] = "STARTING_LINK_TYPE_TABLE";
int i, n_tokens;
if (!pp_lexer_set_label(k->lt, label))
{
prt_error("Fatal error: post_process: Couldn't find starting link table %s",label);
exit(1);
}
n_tokens = pp_lexer_count_tokens_of_label(k->lt);
if (n_tokens %2)
{
prt_error("Fatal error: post_process: Link table must have format [<link> <domain name>]+");
exit(1);
}
k->nStartingLinks = n_tokens/2;
k->starting_link_lookup_table = (StartingLinkAndDomain*)
xalloc((1+k->nStartingLinks)*sizeof(StartingLinkAndDomain));
for (i=0; i<k->nStartingLinks; i++)
{
/* read the starting link itself */
k->starting_link_lookup_table[i].starting_link =
string_set_add(pp_lexer_get_next_token_of_label(k->lt),k->string_set);
/* read the domain type of the link */
p = pp_lexer_get_next_token_of_label(k->lt);
check_domain_is_legal(p);
k->starting_link_lookup_table[i].domain = (int) p[0];
}
/* end sentinel */
k->starting_link_lookup_table[k->nStartingLinks].domain = -1;
}
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;
}
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 bool read_bounded_rules(pp_knowledge *k, const char *label)
{
const char **tokens;
size_t n_commas, n_tokens;
size_t r;
if (!pp_lexer_set_label(k->lt, label)) {
k->n_bounded_rules = 0;
if (verbosity_level(+D_PPK))
prt_error("Warning: File %s: Not using any 'bounded' rules\n", k->path);
}
else {
n_commas = pp_lexer_count_commas_of_label(k->lt);
k->n_bounded_rules = (n_commas + 1)/2;
}
k->bounded_rules = (pp_rule*) malloc ((1+k->n_bounded_rules)*sizeof(pp_rule));
for (r=0; r<k->n_bounded_rules; r++)
{
/* read domain */
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->bounded_rules[r].domain = (int) tokens[0][0];
/* 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->bounded_rules[r].msg = string_set_add(tokens[0], k->string_set);
k->bounded_rules[r].use_count = 0;
}
/* sentinel entry */
k->bounded_rules[k->n_bounded_rules].msg = 0;
k->bounded_rules[k->n_bounded_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;
}
/**
* Read table of [link, domain type].
* This tells us what domain type each link belongs to.
* This lookup table *must* be defined in the knowledge file.
*/
static bool read_starting_link_table(pp_knowledge *k)
{
const char *p;
const char label[] = "STARTING_LINK_TYPE_TABLE";
size_t i, even;
int n_tokens;
if (!pp_lexer_set_label(k->lt, label))
{
prt_error("Error: File %s: Couldn't find starting link table %s\n",
k->path, label);
return false;
}
n_tokens = pp_lexer_count_tokens_of_label(k->lt);
if (-1 == n_tokens) return false;
even = n_tokens % 2;
if(0 != even)
{
prt_error("Error: Link table must have format [<link> <domain name>]+\n");
return false;
}
k->nStartingLinks = n_tokens/2;
k->starting_link_lookup_table = (StartingLinkAndDomain*)
malloc((1+k->nStartingLinks)*sizeof(StartingLinkAndDomain));
for (i=0; i<k->nStartingLinks; i++)
{
/* read the starting link itself */
k->starting_link_lookup_table[i].starting_link =
string_set_add(pp_lexer_get_next_token_of_label(k->lt),k->string_set);
/* read the domain type of the link */
p = pp_lexer_get_next_token_of_label(k->lt);
if (!check_domain_is_legal(k, p)) return false;
k->starting_link_lookup_table[i].domain = (int) p[0];
}
/* end sentinel */
k->starting_link_lookup_table[k->nStartingLinks].domain = -1;
return true;
}
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 void read_connected_rule(pp_knowledge *k, const char *label)
{
/* This is a degenerate class of rules: either a single rule asserting
connectivity is there, or it isn't. The only information in the
rule (besides its presence) is the error message to display if
the rule is violated */
k->connected_rules = (pp_rule *) xalloc (sizeof(pp_rule));
if (!pp_lexer_set_label(k->lt, label))
{
k->connected_rules[0].msg=0; /* rule not there */
if (verbosity>0) printf("PP warning: Not using 'link is connected' rule\n");
return;
}
if (pp_lexer_count_tokens_of_label(k->lt)>1)
{
prt_error("Fatal Error: post_process(): Invalid syntax in %s", label);
exit(1);
}
k->connected_rules[0].msg =
string_set_add(pp_lexer_get_next_token_of_label(k->lt), k->string_set);
}
static void read_bounded_rules(pp_knowledge *k, const char *label)
{
const char **tokens;
int n_commas, n_tokens, r;
if (!pp_lexer_set_label(k->lt, label)) {
k->n_bounded_rules = 0;
if (verbosity>0) printf("PP warning: Not using any 'bounded' rules\n");
}
else {
n_commas = pp_lexer_count_commas_of_label(k->lt);
k->n_bounded_rules = (n_commas + 1)/2;
}
k->bounded_rules = (pp_rule*) xalloc ((1+k->n_bounded_rules)*sizeof(pp_rule));
for (r=0; r<k->n_bounded_rules; r++)
{
/* read domain */
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->bounded_rules[r].domain = (int) tokens[0][0];
/* 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->bounded_rules[r].msg = string_set_add(tokens[0], k->string_set);
}
/* sentinel entry */
k->bounded_rules[k->n_bounded_rules].msg = 0;
}
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;
}
