cassys_tokens_list *cassys_load_text(const char *tokens_text_name, const char *text_cod_name, struct text_tokens **tokens){
int mask_encoding_compatibility_input = DEFAULT_MASK_ENCODING_COMPATIBILITY_INPUT;
*tokens = load_text_tokens(tokens_text_name,mask_encoding_compatibility_input);
U_FILE *f = u_fopen(BINARY, text_cod_name,U_READ);
if( f == NULL){
perror("fopen\n");
fprintf(stderr,"Cannot open file %s\n",text_cod_name);
exit(1);
}
cassys_tokens_list *list = NULL;
cassys_tokens_list *temp = list;
int token_id;
int char_read = (int)fread(&token_id,sizeof(int),1,f);
while(char_read ==1){
if(list==NULL){
list = new_element((*tokens)->token[token_id],0);
temp = list;
}
else {
temp ->next_token = new_element((*tokens)->token[token_id],0);
temp = temp -> next_token;
}
char_read = (int)fread(&token_id,sizeof(int),1,f);
}
u_fclose(f);
return list;
}
int main_Untokenize(int argc,char* const argv[]) {
if (argc==1) {
usage();
return SUCCESS_RETURN_CODE;
}
char alphabet[FILENAME_MAX]="";
char token_file[FILENAME_MAX]="";
char dynamicSntDir[FILENAME_MAX]="";
VersatileEncodingConfig vec=VEC_DEFAULT;
int val,index=-1;
int range_start,range_stop,use_range;
int token_step_number=0;
range_start=range_stop=use_range=0;
char foo=0;
bool only_verify_arguments = false;
UnitexGetOpt options;
while (EOF!=(val=options.parse_long(argc,argv,optstring_Untokenize,lopts_Untokenize,&index))) {
switch(val) {
case 'a': if (options.vars()->optarg[0]=='\0') {
error("You must specify a non empty alphabet file name\n");
return USAGE_ERROR_CODE;
}
strcpy(alphabet,options.vars()->optarg);
break;
case 'd': if (options.vars()->optarg[0]=='\0') {
error("You must specify a non empty snt dir name\n");
return USAGE_ERROR_CODE;
}
strcpy(dynamicSntDir,options.vars()->optarg);
break;
case 't': if (options.vars()->optarg[0]=='\0') {
error("You must specify a non empty token file name\n");
return USAGE_ERROR_CODE;
}
strcpy(token_file,options.vars()->optarg);
break;
case 'k': if (options.vars()->optarg[0]=='\0') {
error("Empty input_encoding argument\n");
return USAGE_ERROR_CODE;
}
decode_reading_encoding_parameter(&(vec.mask_encoding_compatibility_input),options.vars()->optarg);
break;
case 'q': if (options.vars()->optarg[0]=='\0') {
error("Empty output_encoding argument\n");
return USAGE_ERROR_CODE;
}
decode_writing_encoding_parameter(&(vec.encoding_output),&(vec.bom_output),options.vars()->optarg);
break;
case 'n': if (1!=sscanf(options.vars()->optarg,"%d%c",&token_step_number,&foo) || token_step_number<=0) {
/* foo is used to check that the search limit is not like "45gjh" */
error("Invalid token numbering argument: %s\n",options.vars()->optarg);
return USAGE_ERROR_CODE;
}
break;
case 'r': {
int param1 = 0;
int param2 = 0;
int ret_scan = sscanf(options.vars()->optarg,"%d,%d%c",¶m1,¶m2,&foo);
if (ret_scan == 2) {
range_start = param1;
range_stop = param2;
use_range=1;
if (((range_start < -1)) || (range_stop < -1)) {
/* foo is used to check that the search limit is not like "45gjh" */
error("Invalid stop count argument: %s\n",options.vars()->optarg);
return USAGE_ERROR_CODE;
}
}
else
if (1!=sscanf(options.vars()->optarg,"%d%c",&range_start,&foo) || (range_start < -1)) {
/* foo is used to check that the search limit is not like "45gjh" */
error("Invalid stop count argument: %s\n",options.vars()->optarg);
return USAGE_ERROR_CODE;
}
use_range=1;
}
break;
case 'V': only_verify_arguments = true;
break;
case 'h': usage();
return SUCCESS_RETURN_CODE;
case ':': index==-1 ? error("Missing argument for option -%c\n",options.vars()->optopt) :
error("Missing argument for option --%s\n",lopts_Untokenize[index].name);
return USAGE_ERROR_CODE;
case '?': index==-1 ? error("Invalid option -%c\n",options.vars()->optopt) :
error("Invalid option --%s\n",options.vars()->optarg);
return USAGE_ERROR_CODE;
}
index=-1;
}
if (options.vars()->optind!=argc-1) {
error("Invalid arguments: rerun with --help\n");
return USAGE_ERROR_CODE;
}
if (only_verify_arguments) {
// freeing all allocated memory
return SUCCESS_RETURN_CODE;
}
char tokens_txt[FILENAME_MAX];
char text_cod[FILENAME_MAX];
char enter_pos[FILENAME_MAX];
if (dynamicSntDir[0]=='\0') {
get_snt_path(argv[options.vars()->optind],dynamicSntDir);
}
strcpy(text_cod,dynamicSntDir);
strcat(text_cod,"text.cod");
strcpy(enter_pos,dynamicSntDir);
strcat(enter_pos,"enter.pos");
strcpy(tokens_txt,dynamicSntDir);
strcat(tokens_txt,"tokens.txt");
Alphabet* alph=NULL;
if (alphabet[0]!='\0') {
alph=load_alphabet(&vec,alphabet);
if (alph==NULL) {
error("Cannot load alphabet file %s\n",alphabet);
return DEFAULT_ERROR_CODE;
}
}
ABSTRACTMAPFILE* af_text_cod=af_open_mapfile(text_cod,MAPFILE_OPTION_READ,0);
if (af_text_cod==NULL) {
error("Cannot open file %s\n",text_cod);
free_alphabet(alph);
return DEFAULT_ERROR_CODE;
}
ABSTRACTMAPFILE* af_enter_pos=af_open_mapfile(enter_pos,MAPFILE_OPTION_READ,0);
if (af_enter_pos==NULL) {
error("Cannot open file %s\n",enter_pos);
af_close_mapfile(af_text_cod);
free_alphabet(alph);
return DEFAULT_ERROR_CODE;
}
U_FILE* text = u_fopen(&vec,argv[options.vars()->optind],U_WRITE);
if (text==NULL) {
error("Cannot create text file %s\n",argv[options.vars()->optind]);
af_close_mapfile(af_enter_pos);
af_close_mapfile(af_text_cod);
free_alphabet(alph);
return DEFAULT_ERROR_CODE;
}
struct text_tokens* tok=load_text_tokens(&vec,tokens_txt);
u_printf("Untokenizing text...\n");
size_t nb_item = af_get_mapfile_size(af_text_cod)/sizeof(int);
const int* buf=(const int*)af_get_mapfile_pointer(af_text_cod);
size_t nb_item_enter_pos=0;
const int* buf_enter=NULL;
if (af_enter_pos!=NULL) {
buf_enter=(const int*)af_get_mapfile_pointer(af_enter_pos);
if (buf_enter!=NULL) {
nb_item_enter_pos=af_get_mapfile_size(af_enter_pos)/sizeof(int);
}
}
size_t count_pos=0;
for (size_t i=0;i<nb_item;i++) {
int is_in_range=1;
if ((use_range!=0) && (i<(size_t)range_start)) {
is_in_range=0;
}
if ((use_range!=0) && (range_stop!=0) && (i>(size_t)range_stop)) {
is_in_range=0;
}
int is_newline=0;
if (count_pos<nb_item_enter_pos) {
if (i==(size_t)(*(buf_enter+count_pos))) {
is_newline = 1;
count_pos++;
}
}
if (is_in_range!=0) {
if (token_step_number != 0)
if ((i%token_step_number)==0)
u_fprintf(text,"\n\nToken %d : ", (int)i);
if (is_newline!=0) {
u_fprintf(text,"\n", tok->token[*(buf+i)]);
}
else {
u_fputs(tok->token[*(buf+i)], text);
}
}
}
af_release_mapfile_pointer(af_text_cod,buf);
af_release_mapfile_pointer(af_enter_pos,buf_enter);
af_close_mapfile(af_enter_pos);
af_close_mapfile(af_text_cod);
free_text_tokens(tok);
u_fclose(text);
free_alphabet(alph);
u_printf("\nDone.\n");
return SUCCESS_RETURN_CODE;
}
int main_Extract(int argc,char* const argv[]) {
if (argc==1) {
usage();
return 0;
}
int val,index=-1;
char extract_matching_units=1;
char text_name[FILENAME_MAX]="";
char concord_ind[FILENAME_MAX]="";
char output[FILENAME_MAX]="";
Encoding encoding_output = DEFAULT_ENCODING_OUTPUT;
int bom_output = DEFAULT_BOM_OUTPUT;
int mask_encoding_compatibility_input = DEFAULT_MASK_ENCODING_COMPATIBILITY_INPUT;
struct OptVars* vars=new_OptVars();
while (EOF!=(val=getopt_long_TS(argc,argv,optstring_Extract,lopts_Extract,&index,vars))) {
switch(val) {
case 'y': extract_matching_units=1; break;
case 'n': extract_matching_units=0; break;
case 'o': if (vars->optarg[0]=='\0') {
fatal_error("You must specify a non empty output file name\n");
}
strcpy(output,vars->optarg);
break;
case 'i': if (vars->optarg[0]=='\0') {
fatal_error("You must specify a non empty concordance file name\n");
}
strcpy(concord_ind,vars->optarg);
break;
case 'h': usage(); return 0;
case ':': if (index==-1) fatal_error("Missing argument for option -%c\n",vars->optopt);
else fatal_error("Missing argument for option --%s\n",lopts_Extract[index].name);
case '?': if (index==-1) fatal_error("Invalid option -%c\n",vars->optopt);
else fatal_error("Invalid option --%s\n",vars->optarg);
break;
case 'k': if (vars->optarg[0]=='\0') {
fatal_error("Empty input_encoding argument\n");
}
decode_reading_encoding_parameter(&mask_encoding_compatibility_input,vars->optarg);
break;
case 'q': if (vars->optarg[0]=='\0') {
fatal_error("Empty output_encoding argument\n");
}
decode_writing_encoding_parameter(&encoding_output,&bom_output,vars->optarg);
break;
}
index=-1;
}
if (output[0]=='\0') {
fatal_error("You must specify the output text file\n");
}
if (vars->optind!=argc-1) {
fatal_error("Invalid arguments: rerun with --help\n");
}
strcpy(text_name,argv[vars->optind]);
struct snt_files* snt_files=new_snt_files(text_name);
ABSTRACTMAPFILE* text=af_open_mapfile(snt_files->text_cod,MAPFILE_OPTION_READ,0);
if (text==NULL) {
error("Cannot open %s\n",snt_files->text_cod);
return 1;
}
struct text_tokens* tok=load_text_tokens(snt_files->tokens_txt,mask_encoding_compatibility_input);
if (tok==NULL) {
error("Cannot load token list %s\n",snt_files->tokens_txt);
af_close_mapfile(text);
return 1;
}
if (tok->SENTENCE_MARKER==-1) {
error("The text does not contain any sentence marker {S}\n");
af_close_mapfile(text);
free_text_tokens(tok);
return 1;
}
if (concord_ind[0]=='\0') {
char tmp[FILENAME_MAX];
get_extension(text_name,tmp);
if (strcmp(tmp,"snt")) {
fatal_error("Unable to find the concord.ind file. Please explicit it\n");
}
remove_extension(text_name,concord_ind);
strcat(concord_ind,"_snt");
strcat(concord_ind,PATH_SEPARATOR_STRING);
strcat(concord_ind,"concord.ind");
}
U_FILE* concord=u_fopen_existing_versatile_encoding(mask_encoding_compatibility_input,concord_ind,U_READ);
if (concord==NULL) {
error("Cannot open concordance %s\n",concord_ind);
af_close_mapfile(text);
free_text_tokens(tok);
return 1;
}
U_FILE* result=u_fopen_creating_versatile_encoding(encoding_output,bom_output,output,U_WRITE);
if (result==NULL) {
error("Cannot write output file %s\n",output);
af_close_mapfile(text);
u_fclose(concord);
free_text_tokens(tok);
return 1;
}
free_snt_files(snt_files);
extract_units(extract_matching_units,text,tok,concord,result);
af_close_mapfile(text);
u_fclose(concord);
u_fclose(result);
free_text_tokens(tok);
free_OptVars(vars);
u_printf("Done.\n");
return 0;
}
/**
* The same than main, but no call to setBufferMode.
*/
int main_Concord(int argc,char* const argv[]) {
if (argc==1) {
usage();
return SUCCESS_RETURN_CODE;
}
int val,index=-1;
struct conc_opt* concord_options = new_conc_opt();
char foo;
VersatileEncodingConfig vec=VEC_DEFAULT;
int ret;
char offset_file[FILENAME_MAX]="";
char PRLG[FILENAME_MAX]="";
bool only_verify_arguments = false;
UnitexGetOpt options;
while (EOF!=(val=options.parse_long(argc,argv,optstring_Concord,lopts_Concord,&index))) {
switch(val) {
case 'f': if (options.vars()->optarg[0]=='\0') {
error("Empty font name argument\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
concord_options->fontname=strdup(options.vars()->optarg);
if (concord_options->fontname==NULL) {
alloc_error("main_Concord");
free_conc_opt(concord_options);
return ALLOC_ERROR_CODE;
}
break;
case 's': if (1!=sscanf(options.vars()->optarg,"%d%c",&(concord_options->fontsize),&foo)) {
/* foo is used to check that the font size is not like "45gjh" */
error("Invalid font size argument: %s\n",options.vars()->optarg);
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
break;
case 'l': ret=sscanf(options.vars()->optarg,"%d%c%c",&(concord_options->left_context),&foo,&foo);
if (ret==0 || ret==3 || (ret==2 && foo!='s') || concord_options->left_context<0) {
error("Invalid left context argument: %s\n",options.vars()->optarg);
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
if (ret==2) {
concord_options->left_context_until_eos=1;
}
break;
case 'r': ret=sscanf(options.vars()->optarg,"%d%c%c",&(concord_options->right_context),&foo,&foo);
if (ret==0 || ret==3 || (ret==2 && foo!='s') || concord_options->right_context<0) {
error("Invalid right context argument: %s\n",options.vars()->optarg);
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
if (ret==2) {
concord_options->right_context_until_eos=1;
}
break;
case 'L': concord_options->convLFtoCRLF=0; break;
case 0: concord_options->sort_mode=TEXT_ORDER; break;
case 1: concord_options->sort_mode=LEFT_CENTER; break;
case 2: concord_options->sort_mode=LEFT_RIGHT; break;
case 3: concord_options->sort_mode=CENTER_LEFT; break;
case 4: concord_options->sort_mode=CENTER_RIGHT; break;
case 5: concord_options->sort_mode=RIGHT_LEFT; break;
case 6: concord_options->sort_mode=RIGHT_CENTER; break;
case 7: concord_options->result_mode=DIFF_; break;
case 8: concord_options->only_ambiguous=1; break;
case 9: {
strcpy(PRLG,options.vars()->optarg);
char* pos=strchr(PRLG,',');
if (pos==NULL || pos==PRLG || *(pos+1)=='\0') {
error("Invalid argument for option --PRLG: %s\n",options.vars()->optarg);
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
*pos='\0';
strcpy(offset_file,pos+1);
break;
}
case 10: concord_options->only_matches=1; break;
case 11: concord_options->result_mode=LEMMATIZE_; break;
case 12: concord_options->result_mode=CSV_; break;
case 'H': concord_options->result_mode=HTML_; break;
case 't': {
concord_options->result_mode=TEXT_;
if (options.vars()->optarg!=NULL) {
strcpy(concord_options->output,options.vars()->optarg);
}
break;
}
case 'g': concord_options->result_mode=GLOSSANET_;
if (options.vars()->optarg[0]=='\0') {
error("Empty glossanet script argument\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
concord_options->script=strdup(options.vars()->optarg);
if (concord_options->script==NULL) {
alloc_error("main_Concord");
free_conc_opt(concord_options);
return ALLOC_ERROR_CODE;
}
break;
case 'p': concord_options->result_mode=SCRIPT_;
if (options.vars()->optarg[0]=='\0') {
error("Empty script argument\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
concord_options->script=strdup(options.vars()->optarg);
if (concord_options->script==NULL) {
alloc_error("main_Concord");
free_conc_opt(concord_options);
return ALLOC_ERROR_CODE;
}
break;
case 'i': concord_options->result_mode=INDEX_; break;
case 'u': concord_options->result_mode=UIMA_;
if (options.vars()->optarg!=NULL) {
strcpy(offset_file,options.vars()->optarg);
}
concord_options->original_file_offsets=1;
break;
case 'e': concord_options->result_mode=XML_;
if (options.vars()->optarg!=NULL) {
strcpy(offset_file, options.vars()->optarg);
concord_options->original_file_offsets=1;
}
break;
case 'w': concord_options->result_mode=XML_WITH_HEADER_;
if (options.vars()->optarg!=NULL) {
strcpy(offset_file, options.vars()->optarg);
concord_options->original_file_offsets = 1;
}
break;
case '$': if (options.vars()->optarg[0]=='\0') {
error("Empty input_offsets argument\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
strcpy(concord_options->input_offsets,options.vars()->optarg);
break;
case '@': if (options.vars()->optarg[0]=='\0') {
error("Empty output_offsets argument\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
strcpy(concord_options->output_offsets,options.vars()->optarg);
break;
case 'A': concord_options->result_mode=AXIS_; break;
case 'x': concord_options->result_mode=XALIGN_; break;
case 'm': concord_options->result_mode=MERGE_;
if (options.vars()->optarg[0]=='\0') {
error("Empty output file name argument\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
strcpy(concord_options->output,options.vars()->optarg);
break;
case 'a': if (options.vars()->optarg[0]=='\0') {
error("Empty alphabet argument\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
concord_options->sort_alphabet=strdup(options.vars()->optarg);
if (concord_options->sort_alphabet==NULL) {
alloc_error("main_Concord");
free_conc_opt(concord_options);
return ALLOC_ERROR_CODE; }
break;
case 'T': concord_options->thai_mode=1; break;
case 'd': if (options.vars()->optarg[0]=='\0') {
error("Empty snt directory argument\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
strcpy(concord_options->working_directory,options.vars()->optarg);
break;
case 'V': only_verify_arguments = true;
break;
case 'h': usage();
free_conc_opt(concord_options);
return SUCCESS_RETURN_CODE;
case ':': index==-1 ? error("Missing argument for option -%c\n",options.vars()->optopt) :
error("Missing argument for option --%s\n",lopts_Concord[index].name);
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
case '?': index==-1 ? error("Invalid option -%c\n",options.vars()->optopt) :
error("Invalid option --%s\n",options.vars()->optarg);
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
case 'k': if (options.vars()->optarg[0]=='\0') {
error("Empty input_encoding argument\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
decode_reading_encoding_parameter(&(vec.mask_encoding_compatibility_input),options.vars()->optarg);
break;
case 'q': if (options.vars()->optarg[0]=='\0') {
error("Empty output_encoding argument\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
decode_writing_encoding_parameter(&(vec.encoding_output),&(vec.bom_output),options.vars()->optarg);
break;
}
index=-1;
}
if (options.vars()->optind!=argc-1) {
error("Invalid arguments: rerun with --help\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
if (concord_options->fontname==NULL || concord_options->fontsize<=0) {
if (concord_options->result_mode==HTML_ || concord_options->result_mode==GLOSSANET_) {
error("The specified output mode is an HTML file: you must specify font parameters\n");
free_conc_opt(concord_options);
return USAGE_ERROR_CODE;
}
}
if (only_verify_arguments) {
// freeing all allocated memory
free_conc_opt(concord_options);
return SUCCESS_RETURN_CODE;
}
U_FILE* concor=u_fopen(&vec,argv[options.vars()->optind],U_READ);
if (concor==NULL) {
error("Cannot open concordance index file %s\n",argv[options.vars()->optind]);
free_conc_opt(concord_options);
return DEFAULT_ERROR_CODE;
}
if (concord_options->working_directory[0]=='\0') {
get_path(argv[options.vars()->optind],concord_options->working_directory);
}
if (concord_options->only_matches) {
concord_options->left_context=0;
concord_options->right_context=0;
}
/* We compute the name of the files associated to the text */
struct snt_files* snt_files=new_snt_files_from_path(concord_options->working_directory);
ABSTRACTMAPFILE* text=af_open_mapfile(snt_files->text_cod,MAPFILE_OPTION_READ,0);
if (text==NULL) {
error("Cannot open file %s\n",snt_files->text_cod);
free_snt_files(snt_files);
u_fclose(concor);
free_conc_opt(concord_options);
return DEFAULT_ERROR_CODE;
}
struct text_tokens* tok=load_text_tokens(&vec,snt_files->tokens_txt);
if (tok==NULL) {
error("Cannot load text token file %s\n",snt_files->tokens_txt);
af_close_mapfile(text);
free_snt_files(snt_files);
u_fclose(concor);
free_conc_opt(concord_options);
return DEFAULT_ERROR_CODE;
}
U_FILE* f_enter=u_fopen(BINARY,snt_files->enter_pos,U_READ);
int n_enter_char=0;
int* enter_pos=NULL;
/* New lines are encoded in 'enter.pos' files. Those files will disappear in the future */
if (f_enter==NULL) {
error("Cannot open file %s\n",snt_files->enter_pos);
}
else {
long size=get_file_size(f_enter);
enter_pos=(int*)malloc(size);
if (enter_pos==NULL) {
alloc_error("main_Concord");
u_fclose(f_enter);
free_text_tokens(tok);
af_close_mapfile(text);
free_snt_files(snt_files);
u_fclose(concor);
free_conc_opt(concord_options);
return ALLOC_ERROR_CODE;
}
n_enter_char=(int)fread(enter_pos,sizeof(int),size/sizeof(int),f_enter);
if (n_enter_char!=(int)(size/sizeof(int))) {
error("Read error on enter.pos file in main_Concord\n");
u_fclose(f_enter);
free(enter_pos);
free_text_tokens(tok);
af_close_mapfile(text);
free_snt_files(snt_files);
u_fclose(concor);
free_conc_opt(concord_options);
return DEFAULT_ERROR_CODE;
}
u_fclose(f_enter);
}
if (concord_options->result_mode==INDEX_ || concord_options->result_mode==UIMA_ ||
concord_options->result_mode==XML_ || concord_options->result_mode==XML_WITH_HEADER_ ||
concord_options->result_mode==AXIS_) {
/* We force some options for index, uima and axis files */
concord_options->left_context=0;
concord_options->right_context=0;
concord_options->sort_mode=TEXT_ORDER;
}
if (concord_options->only_ambiguous && concord_options->result_mode!=LEMMATIZE_) {
/* We force text order when displaying only ambiguous outputs */
concord_options->sort_mode=TEXT_ORDER;
}
if (concord_options->result_mode==HTML_ || concord_options->result_mode==DIFF_ || concord_options->result_mode==LEMMATIZE_) {
/* We need the offset file if and only if we have to produce
* an html concordance with positions in .snt file */
concord_options->snt_offsets=load_snt_offsets(snt_files->snt_offsets_pos);
if (concord_options->snt_offsets==NULL) {
error("Cannot read snt offset file %s\n",snt_files->snt_offsets_pos);
free(enter_pos);
free_text_tokens(tok);
af_close_mapfile(text);
free_snt_files(snt_files);
u_fclose(concor);
free_conc_opt(concord_options);
return DEFAULT_ERROR_CODE;
}
}
if (offset_file[0]!='\0') {
concord_options->uima_offsets=load_uima_offsets(&vec,offset_file);
if (concord_options->uima_offsets==NULL) {
error("Cannot read offset file %s\n",offset_file);
free(enter_pos);
free_text_tokens(tok);
af_close_mapfile(text);
free_snt_files(snt_files);
u_fclose(concor);
free_conc_opt(concord_options);
return DEFAULT_ERROR_CODE;
}
}
if (PRLG[0]!='\0') {
concord_options->PRLG_data=load_PRLG_data(&vec,PRLG);
if (concord_options->PRLG_data==NULL) {
error("Cannot read PRLG file %s\n",PRLG);
free(enter_pos);
free_text_tokens(tok);
af_close_mapfile(text);
free_snt_files(snt_files);
u_fclose(concor);
free_conc_opt(concord_options);
return DEFAULT_ERROR_CODE;
}
}
if (concord_options->result_mode==CSV_) {
concord_options->sort_mode=TEXT_ORDER;
concord_options->only_matches=1;
}
/* Once we have set all parameters, we call the function that
* will actually create the concordance. */
create_concordance(&vec,concor,text,tok,n_enter_char,enter_pos,concord_options);
free(enter_pos);
free_text_tokens(tok);
af_close_mapfile(text);
free_snt_files(snt_files);
u_fclose(concor);
free_conc_opt(concord_options);
u_printf("Done.\n");
return SUCCESS_RETURN_CODE;
}
