ref: e9e2e37c329dbe98bfeb27a1828ef9a71fa84f88
dir: /src/lexicon/cst_lts_rewrites.c/
/*************************************************************************/
/* */
/* Language Technologies Institute */
/* Carnegie Mellon University */
/* Copyright (c) 2002 */
/* All Rights Reserved. */
/* */
/* Permission is hereby granted, free of charge, to use and distribute */
/* this software and its documentation without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of this work, and to */
/* permit persons to whom this work is furnished to do so, subject to */
/* the following conditions: */
/* 1. The code must retain the above copyright notice, this list of */
/* conditions and the following disclaimer. */
/* 2. Any modifications must be clearly marked as such. */
/* 3. Original authors' names are not deleted. */
/* 4. The authors' names are not used to endorse or promote products */
/* derived from this software without specific prior written */
/* permission. */
/* */
/* CARNEGIE MELLON UNIVERSITY AND THE CONTRIBUTORS TO THIS WORK */
/* DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING */
/* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT */
/* SHALL CARNEGIE MELLON UNIVERSITY NOR THE CONTRIBUTORS BE LIABLE */
/* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES */
/* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN */
/* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, */
/* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF */
/* THIS SOFTWARE. */
/* */
/*************************************************************************/
/* Author: Alan W Black (awb@cs.cmu.edu) */
/* Date: August 2002 */
/*************************************************************************/
/* */
/* Letter to sound rule for Festival's hand writable rule set */
/* */
/* Rules are ordered list of */
/* LC [ A ] RC => B */
/* */
/*************************************************************************/
#include "cst_string.h"
#include "cst_val.h"
#include "cst_lts_rewrites.h"
static int item_match(const cst_val *PATT, const cst_val *THING,
const cst_val *sets)
{
const cst_val *sss;
if (cst_streq(val_string(PATT),val_string(THING)))
return TRUE;
for (sss=sets; sss; sss=val_cdr(sss))
{
if (cst_streq(val_string(val_car(val_car(sss))),val_string(PATT)))
{ /* Its a set not a letter */
if (val_member_string(val_string(THING),val_cdr(val_car(sss))))
{
return TRUE;
}
else
{
return FALSE;
}
}
}
return FALSE;
}
static int context_match(const cst_val *PATTERN, const cst_val *STRING,
const cst_val *sets)
{
int r,s,t;
/* printf("PATTERN: "); val_print(stdout, PATTERN); printf("\n"); */
/* printf("STRING: "); val_print(stdout, STRING); printf("\n"); */
if (!PATTERN)
r = TRUE;
else if (!STRING)
r = FALSE;
else if (val_cdr(PATTERN) &&
(cst_streq("*",val_string(val_car(PATTERN)))))
{
r = context_match(val_cdr(val_cdr(PATTERN)),STRING,sets);
s = context_match(val_cdr(PATTERN),STRING,sets);
t = item_match(val_car(val_cdr(PATTERN)),val_car(STRING),sets) &&
context_match(PATTERN, val_cdr(STRING),sets);
r = r || s || t;
}
#if 0
else if (val_cdr(PATTERN) &&
(cst_streq("+",val_string(val_car(PATTERN)))))
return context_match(val_cdr(PATTERN),STRING,sets) || /* last match */
(item_match(val_car(val_cdr(PATTERN)),val_car(STRING),sets) &&
context_match(val_cdr(val_cdr(PATTERN)), /* loop match */
val_cdr(STRING),sets));
#endif
else if (item_match(val_car(PATTERN),val_car(STRING),sets))
r = context_match(val_cdr(PATTERN),val_cdr(STRING),sets);
else
r = FALSE;
/* printf("R = %s\n",(r ? "TRUE" : "FALSE")); */
return r;
}
static int rule_matches(const cst_val *LC, const cst_val *RC,
const cst_val *RLC, const cst_val *RA,
const cst_val *RRC,
const cst_val *sets)
{
const cst_val *rc, *ra;
/* Check [ X ] bit */
for (rc=RC,ra=RA; ra; ra=val_cdr(ra),rc=val_cdr(rc))
{
if (!rc) return FALSE;
if (!cst_streq(val_string(val_car(ra)),
val_string(val_car(rc))))
return FALSE;
}
/* Check LC bit: LC may have some limited regex stuff */
if (context_match(RLC,LC,sets) && context_match(RRC,rc,sets))
return TRUE;
else
return FALSE;
}
static const cst_val *find_rewrite_rule(const cst_val *LC,
const cst_val *RC,
const cst_lts_rewrites *r)
{
/* Search through rewrite rules to find matching one */
const cst_val *i, *RLC, *RA, *RRC;
for (i=r->rules; i; i=val_cdr(i))
{
/* val_print(stdout, val_car(i)); printf("\n"); */
RLC = val_car(val_car(i));
RA = val_car(val_cdr(val_car(i)));
RRC = val_car(val_cdr(val_cdr(val_car(i))));
if (rule_matches(LC,RC,RLC,RA,RRC,r->sets))
return val_car(i);
}
#if 0
fprintf(stderr,"LTS_REWRITES: unable to find a matching rules for:\n");
fprintf(stderr,"CL: ");
val_print(stderr,LC);
fprintf(stderr,"\n");
fprintf(stderr,"RC: ");
val_print(stderr,RC);
fprintf(stderr,"\n");
#endif
return NULL;
}
cst_val *lts_rewrites_word(const char *word, const cst_lts_rewrites *r)
{
cst_val *w, *p;
char x[2];
int i;
x[1] = '\0';
w = cons_val(string_val("#"),NULL);
for (i=0; word[i]; i++)
{
x[0] = word[i];
w = cons_val(string_val(x),w);
}
w = cons_val(string_val("#"),w);
w = val_reverse(w);
p = lts_rewrites(w,r);
delete_val(w);
return p;
}
cst_val *lts_rewrites(const cst_val *itape, const cst_lts_rewrites *r)
{
/* Returns list of rewritten "letters" to "phones" by r */
cst_val *LC;
const cst_val *RC, *i;
const cst_val *rule;
cst_val *otape;
LC = cons_val(val_car(itape),NULL);
RC = val_cdr(itape);
otape = NULL;
while (val_cdr(RC))
{
rule = find_rewrite_rule(LC,RC,r);
if (!rule)
break;
/* val_print(stdout,rule);
printf("\n"); */
/* Shift itape head */
for (i=val_car(val_cdr(rule)); i; i=val_cdr(i))
{
LC = cons_val(val_car(RC),LC);
RC = val_cdr(RC);
}
/* Output things to otape */
for (i=val_car(val_cdr(val_cdr(val_cdr(rule)))); i; i=val_cdr(i))
otape = cons_val(val_car(i),otape);
}
delete_val(LC);
return val_reverse(otape);
}