void process_linkage(Linkage linkage, Parse_Options opts) {
char * string;
int j, mode, first_sublinkage;
if (parse_options_get_display_union(opts)) {
linkage_compute_union(linkage);
first_sublinkage = linkage_get_num_sublinkages(linkage)-1;
}
else {
first_sublinkage = 0;
}
for (j=first_sublinkage; j<linkage_get_num_sublinkages(linkage); ++j) {
linkage_set_current_sublinkage(linkage, j);
if (parse_options_get_display_on(opts)) {
string = linkage_print_diagram(linkage);
fprintf(stdout, "%s", string);
string_delete(string);
}
if (parse_options_get_display_links(opts)) {
string = linkage_print_links_and_domains(linkage);
fprintf(stdout, "%s", string);
string_delete(string);
}
if (parse_options_get_display_postscript(opts)) {
string = linkage_print_postscript(linkage, FALSE);
fprintf(stdout, "%s\n", string);
string_delete(string);
}
}
if ((mode=parse_options_get_display_constituents(opts))) {
string = linkage_print_constituent_tree(linkage, mode);
if (string != NULL) {
fprintf(stdout, "%s\n", string);
string_delete(string);
} else {
fprintf(stderr, "Can't generate constituents.\n");
fprintf(stderr, "Constituent processing has been turned off.\n");
}
}
}
static void makeLinkage(per_thread_data *ptd)
{
if (ptd->cur_linkage < ptd->num_linkages)
{
if (ptd->linkage)
linkage_delete(ptd->linkage);
ptd->linkage = linkage_create(ptd->cur_linkage,ptd->sent,ptd->opts);
linkage_compute_union(ptd->linkage);
linkage_set_current_sublinkage(ptd->linkage,
linkage_get_num_sublinkages(ptd->linkage)-1);
#if DO_PHRASE_TREE
if (tree)
linkage_free_constituent_tree(tree);
tree = linkage_constituent_tree(linkage);
printTree(tree);
#endif
}
}
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 void process_linkage(Linkage linkage, Parse_Options opts,char * tmp_path,char * file_name)
//##############################################################################################
{
char * string;
int j, mode, first_sublinkage;
int nlink;
if (!linkage) return; /* Can happen in timeout mode */
if (parse_options_get_display_union(opts))
{
linkage_compute_union(linkage);
first_sublinkage = linkage_get_num_sublinkages(linkage)-1;
}
else
{
first_sublinkage = 0;
}
nlink = linkage_get_num_sublinkages(linkage);
for (j=first_sublinkage; j<nlink; ++j)
{
linkage_set_current_sublinkage(linkage, j);
if (parse_options_get_display_on(opts))
{
string = linkage_print_diagram(linkage);
//########################################
// fprintf(stdout, "%s", string);
//#########################################
linkage_free_diagram(string);
}
if (parse_options_get_display_links(opts))
{
string = linkage_print_links_and_domains(linkage);
fprintf(stdout, "%s", string);
linkage_free_links_and_domains(string);
}
if (parse_options_get_display_senses(opts))
{
string = linkage_print_senses(linkage);
fprintf(stdout, "%s", string);
linkage_free_senses(string);
}
if (parse_options_get_display_disjuncts(opts))
{
string = linkage_print_disjuncts(linkage);
fprintf(stdout, "%s", string);
linkage_free_disjuncts(string);
}
if (parse_options_get_display_postscript(opts))
{
//########################################################################
string = linkage_print_postscript(linkage, FALSE,tmp_path,file_name);
// fprintf(stdout, "%s\n", string);
//########################################################################
linkage_free_postscript(string);
/*string = linkage_print_postscript(linkage, FALSE);
fprintf(stdout, "%s\n", string);
linkage_free_postscript(string);*/
}
}
if ((mode = parse_options_get_display_constituents(opts)))
{
string = linkage_print_constituent_tree(linkage, mode);
if (string != NULL)
{
/*###########################################*/
// fprintf(stdout, "%s\n", string);
/*##########################################*/
linkage_free_constituent_tree_str(string);
}
else
{
fprintf(stderr, "Can't generate constituents.\n");
fprintf(stderr, "Constituent processing has been turned off.\n");
}
}
}
static PyObject *domains(PyObject *self, PyObject *args) {
Dictionary dict;
Parse_Options opts;
Sentence sent;
Linkage linkage;
//CNode * cn;
/// Link counts
int num_linkages;
int links;
int i;
int j = 0;
int num_domains;
const char *text;
PyObject *output_list;
PyObject *temp;
output_list = PyList_New(0);
if (!PyArg_ParseTuple(args, "s", &text))
return NULL;
opts = parse_options_create();
parse_options_set_verbosity(opts, -1);
setlocale(LC_ALL, "");
dict = dictionary_create_default_lang();
if (!dict) {
PyErr_SetString(PyExc_RuntimeError, "Fatal error: Unable to open the dictionary");
Py_INCREF(Py_None);
return Py_None;
}
sent = sentence_create(text, dict);
sentence_split(sent, opts);
num_linkages = sentence_parse(sent, opts);
if (num_linkages > 0) {
linkage = linkage_create(0, sent, opts);
links = linkage_get_num_sublinkages(linkage);
for(i=0; i<=links; i++) {
num_domains = linkage_get_link_num_domains(linkage, i);
const char **temp1 = linkage_get_link_domain_names(linkage, i);
//for(j=0; j<=num_domains; j++){
while(num_domains < j) {
temp = PyString_FromString(temp1[j]);
PyList_Append(output_list, temp);
j++;
}
j = 0;
}
linkage_delete(linkage);
} else {
sentence_delete(sent);
dictionary_delete(dict);
parse_options_delete(opts);
Py_INCREF(Py_None);
return Py_None;
}
sentence_delete(sent);
dictionary_delete(dict);
parse_options_delete(opts);
return Py_BuildValue("Si", output_list, num_domains);
}
/// This is the basic sentence dissection
static PyObject *sentence(PyObject *self, PyObject *args) {
Dictionary dict;
Parse_Options opts;
Sentence sent;
Linkage linkage;
Linkage sub_linkage;
char * diagram;
/// Link counts
int num_linkages;
int links;
/// Index's for the iterators
int link_idx;
int word_idx;
int num_words;
long span;
long sub_linkages;
const char *text;
const char *d_output;
PyObject *output_list;
PyObject *word_list;
PyObject *word2_list;
PyObject *span_list;
PyObject *temp;
PyObject *sublinkage_list;
PyObject *_diagram;
output_list = PyList_New(0);
word_list = PyList_New(0);
word2_list = PyList_New(0);
sublinkage_list = PyList_New(0);
span_list = PyList_New(0);
if (!PyArg_ParseTuple(args, "s", &text))
return NULL;
opts = parse_options_create();
parse_options_set_verbosity(opts, -1);
parse_options_set_screen_width(opts, 50);
setlocale(LC_ALL, "");
dict = dictionary_create_default_lang();
if (!dict) {
PyErr_SetString(PyExc_RuntimeError, "Fatal error: Unable to open the dictionary");
Py_INCREF(Py_None);
return Py_None;
}
sent = sentence_create(text, dict);
sentence_split(sent, opts);
num_linkages = sentence_parse(sent, opts);
if (num_linkages > 0) {
linkage = linkage_create(0, sent, opts);
/// Get the lengths of everything
num_words = linkage_get_num_words(linkage);
links = linkage_get_num_links(linkage);
for(link_idx=0; link_idx < links; link_idx++) {
PyObject *temp_subLen;
diagram = linkage_print_diagram(linkage);
_diagram = PyString_FromString(diagram);
sub_linkage = linkage_create(link_idx, sent, opts);
sub_linkages = linkage_get_num_sublinkages(linkage);
temp_subLen = PyLong_FromLong(sub_linkages);
linkage_delete(sub_linkage);
PyList_Append(sublinkage_list, temp_subLen);
span = linkage_get_link_length(linkage, link_idx);
PyList_Append(span_list, PyInt_FromLong(span));
PyObject *temp_list;
temp_list = PyList_New(0);
/// Sub Group these (left and right labels)
const char *t1 = linkage_get_link_llabel(linkage, link_idx);
temp = PyString_FromString(t1);
PyList_Append(temp_list, temp);
const char *t2 = linkage_get_link_rlabel(linkage, link_idx);
temp = PyString_FromString(t2);
PyList_Append(temp_list, temp);
/// Then add to the main list
PyList_Append(output_list, temp_list);
/// Just the label
const char *t3 = linkage_get_link_label(linkage, link_idx);
temp = PyString_FromString(t3);
PyList_Append(word2_list, temp);
}
for(word_idx=0; word_idx < num_words; word_idx++) {
d_output = linkage_get_word(linkage, word_idx);
PyObject *word;
word = PyString_FromString(d_output);
PyList_Append(word_list, word);
}
linkage_free_diagram(diagram);
linkage_delete(linkage);
} else {
sentence_delete(sent);
dictionary_delete(dict);
parse_options_delete(opts);
Py_INCREF(Py_None);
return Py_None;
}
sentence_delete(sent);
dictionary_delete(dict);
parse_options_delete(opts);
return Py_BuildValue("SSSSSS", word_list, span_list, output_list, word2_list, sublinkage_list, _diagram);
}
VALUE linkage_count_sublinkages(const VALUE self, VALUE link) {
LinkagePtr *link_ptr = retrieve_linkage(link);
int cnt = linkage_get_num_sublinkages(link_ptr->linkage);
return INT2FIX(cnt);
}
