cst_val *lts_apply_val(const cst_val *wlist,const char *feats,const cst_lts_rules *r)
{
/* for symbol to symbol mapping */
const cst_val *v;
cst_val *p;
char *word;
int i,j;
word = cst_alloc(char,val_length(wlist)+1);
for (v=wlist,i=0; v; v=val_cdr(v),i++)
{
for (j=0; r->letter_table[j]; j++)
if (cst_streq(val_string(val_car(v)),r->letter_table[j]))
{
word[i] = j;
break;
}
if (!r->letter_table[j])
{
#if 0
printf("awb_debug unknown letter >%s<\n",val_string(val_car(v)));
#endif
i--; /* can't find this letter so skip it */
}
}
p = lts_apply(word,feats,r);
cst_free(word);
return p;
}
cst_val *lex_lookup(const cst_lexicon *l, const char *word, const char *pos,
const cst_features *feats)
{
int index;
int p;
const char *q;
char *wp;
cst_val *phones = 0;
int found = FALSE;
wp = cst_alloc(char,cst_strlen(word)+2);
cst_sprintf(wp,"%c%s",(pos ? pos[0] : '0'),word);
if (l->addenda)
phones = lex_lookup_addenda(wp,l,&found);
if (!found)
{
index = lex_lookup_bsearch(l,wp);
if (index >= 0)
{
if (l->phone_hufftable)
{
for (p=index-2; l->data[p]; p--)
for (q=l->phone_hufftable[l->data[p]]; *q; q++)
phones = cons_val(string_val(l->phone_table[(unsigned char)*q]),
phones);
}
else /* no compression -- should we still support this ? */
{
for (p=index-2; l->data[p]; p--)
phones = cons_val(string_val(l->phone_table[l->data[p]]),
phones);
}
phones = val_reverse(phones);
}
else if (l->lts_function)
{
phones = (l->lts_function)(l,word,"",feats);
}
else if (l->lts_rule_set)
{
phones = lts_apply(word,
"", /* more features if we had them */
l->lts_rule_set);
}
}
cst_free(wp);
return phones;
}
cst_val *lex_lookup_return_pos(const cst_lexicon *l, const char *word, const char *pos, int *return_pos)
{
int index,p;
char *wp, *buf;
cst_val *phones = 0;
int found = FALSE;
wp = cst_alloc(char,strlen(word)+2);
buf = cst_alloc(char,3);
sprintf(wp,"%c%s",(pos ? pos[0] : '0'),word);
#ifdef CECUM_DEBUG
printf ("lex_lookup_return_pos looks for %s \n", word);
#endif
if (l->addenda)
phones = CECUM_lex_lookup_addenda (wp,l,&found);
if (!found)
{
index = CECUM_lex_lookup_bsearch (l, l->entry_index,0,l->num_entries,wp);
#ifdef CECUM_DEBUG
printf ("lex_lookup_return_pos has found the word at pos %d \n", index);
#endif
if (index >= 0)
{
for (p=l->entry_index[index].phone_index; l->phones[p]; p++)
phones = cons_val(string_val(l->phone_table[l->phones[p]]), phones);
phones = val_reverse(phones);
if (!pos)
{
//aggiungi in testa il pos se non lo ho!
*return_pos = TRUE;
sprintf(buf,"%c",l->entry_index[index].word_pos[0]);
phones = cons_val(string_val(buf), phones);
}
//val_print(stdout,phones);
//printf("\n");
}
else
{
#ifdef CECUM_DEBUG
printf ("lex_lookup_return_pos: word not found \n", index);
#endif
/*
E' a partire da questo punto che si verifica in genere il problema su cui stavamo
lavorando. Se la parola non viene trovata nel dizionario, viene restituito un indice -1.
Ora, lts_rules_set (e lts_apply) non viene eseguita perchè in ifd_lex.c noi abbiamo
posto
ifd_lex.lts_rule_set = 0;
Del resto, nella lingua italiana non sembrano essere fornite rules compatibili con lst_apply,
a differenza di quello che accade con la lingua inglese
Il puntatore a funzione l->lst_function viene, al contrario, eseguito. Qui la funzione
richiamata è italian_lts_function() (dentro ifd_lex.c). Sarà quest'ultima a richiamare
più volte una serie di routine di rewrites (è qui che si verifica l'errore su cui stiamo
lavorando). Per esempio, è qui che verrà richiamata ifd_mid_lts_rewrites ()
*/
if (l->lts_rule_set)
phones = lts_apply(word,
"", /* more features if we had them */
l->lts_rule_set);
else if (l->lts_function)
phones = (l->lts_function)(l,word,"");
}
}
cst_free(wp);
cst_free(buf);
return phones;
}
