rhubarb-lip-sync/lib/soundchange/sounds.c

/*
**	SOUNDS.C
**
**	Sound Change Applier
**
**      Copyright (C) 2000 by Mark Rosenfelder.
**      This program may be freely used and modified for non-commercial purposes.
**      See http://www.zompist.com/sounds.htm for documentation.
*/

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#define TRUE 1
#define FALSE 0

static int printRules = 0;
static int bracketOut = 0;
static int printSourc = 1;
static int toScreen   = 1;

#define MAXRULE 200
#define MAXCAT  50


static int  nRule = 0;
static char *Rule[MAXRULE];

static int  nCat = 0;
static char *Cat[MAXCAT];

/*
**	ReadRules
**
**	Read in the rules file *.sc for a given project.
**
**	There are two types of rules: sound changes and category definitions.
**	The former are stored in Rule[], the latter in Cat[].
**
**	The format of these rules is given under Transform().
*/
int ReadRules( char *filestart )
{
	char filename[84];
	char buffer[129];
	char *s;
	int  n;
	FILE *f;
	
	nRule = 0;
	nCat  = 0;
	
	/* Open the file */
	
	sprintf( filename, "%s.sc", filestart );
	
	f = fopen( filename, "r" );
	if (!f)
	{
		printf( "File %s could not be read in.\n\n", filename );
		return(FALSE);
	}
	
	while (fgets( buffer, 129, f))
	{
		if (strlen(buffer))
			buffer[strlen(buffer)-1] = '\0';
		
		s = malloc( strlen(buffer) + 1);
		if (s)
			strcpy( s, buffer );
			
		if (buffer[0] != '*')
		{	
			if      (strchr( buffer, '/' ))
				Rule[nRule++] = s;
			else if (strchr( buffer, '='))
				Cat[ nCat++]  = s;
		}
	}
	
	fclose(f);
	
	if (nCat)
	{
		printf( "%i categories found\n", nCat );
		
		#ifdef PRINT_RULES
		for (n = 0; n < nCat; n++)
			printf( "%s\n", Cat[n] );
			
		printf( "\n" );
		#endif
	}
	else
		printf( "No rules were found.\n\n" );
	
	if (nRule)
	{
		printf( "%i rules found\n", nRule );
		
		#ifdef PRINT_RULES
		for (n = 0; n < nRule; n++)
			printf( "%s\n", Rule[n] );
			
		printf( "\n" );
		#endif
	}
	else
		printf( "No rules were found.\n\n" );
	
	return( nRule );
	
} /*ReadRules*/


/*
**	Divide
**
**	Divide a rule into source and target phoneme(s) and environment.
**	That is, for a rule s1/s2/env
**	create the three null-terminated strings s1, s2, and env.
**
**	If this cannot be done, return FALSE.
*/
int Divide( char *Rule, char **s1, char **s2, char **env )
{
	size_t i;
	static char s1_str[20];
	static char s2_str[20];
	static char ev_str[50];
	
	i = strcspn( Rule, "/" );
	if (i == 0 || i > 19)
		return(FALSE);
		
	strncpy( s1_str, Rule, i );
	s1_str[i] = '\0';
	Rule += i + 1;
	
	i = strcspn( Rule, "/" );
	if (i > 19)
		return(FALSE);
	
	if (i)	
		strncpy( s2_str, Rule, i );
	s2_str[i] = '\0';
	Rule += i + 1;
	
	strcpy( ev_str, Rule );

	*s1  = s1_str;
	*s2  = s2_str;
	*env = ev_str;
	
	return(TRUE);
	
} /*Divide*/


/*
**	TryCat
**
**	See if a particular phoneme sequence is part of any category.
**	(We try all the categories.)
**
**	For instance, if we have 'a' in the source word and 'V' in the
**	structural description, and a category V=aeiou, TryCat returns TRUE,
**	and sets *n to the number of characters to skip.
**	
**	If we had 'b' instead, TryCat would return FALSE instead.
**
**	If no category with the given identification (env) can be found,
**	we return TRUE (continue looking), but set *n to 0.
**
**	Warning: For now, we don't have a way to handle digraphs.
**
**	We also return TRUE if 
*/
int TryCat( char *env, char *word, int *n, int *catLoc )
{
	int c;
	char *catdef;
	
	if (*word == '\0')
		return(FALSE);
		
	for (c = 0; c < nCat; c++)
	{
		if (*env == *Cat[c])
		{
			catdef = strchr( Cat[c], '=' );
			
			if (strchr( catdef + 1, word[0] ))
			{
				*n = 1;
				*catLoc = strchr( Cat[c], word[0] ) - Cat[c];
				return(TRUE);
			}
			else
				return(FALSE);
		}
	}

	*n = 0;
	return(TRUE);	
	
} /*TryCat*/

/*
**	TryRule
**
**	See if a rule s1->s2/env applies at position i in the given word.
**
**	If it does, we pass back the index where s1 was found in the
**	word, as well as s1 and s2, and return TRUE.
**
**	Otherwise, we return FALSE, and pass garbage in the output variables.
*/
int TryRule( char *word, int i, char *Rule, int *n, char **s1, char **s2, char *varRep )
{
	int j, m, cont = 0;
	int catLoc;
	char *env;
	int  optional = FALSE;
	*varRep = '\0';
	
	if (!Divide( Rule, s1, s2, &env ) || !strchr( env, '_' ))
		return(FALSE);
	
	for (j = 0, cont = TRUE; cont && j < strlen(env); j++)
	{
		switch( env[j] )
		{
			case '(':
				optional = TRUE;
				break;

			case ')':
				optional = FALSE;
				break;

			case '#':
				cont = j ? (i == strlen(word)) : (i == 0);
				break;
				
			case '_':
				cont = !strncmp( &word[i], *s1, strlen(*s1) );
				if (cont)
				{
					*n = i;
					i += strlen(*s1);
				}
				else
				{
				  cont = TryCat( *s1, &word[i], &m, &catLoc );
				  if (cont && m)
				  {
					int c;
					*n = i;
					i += m;

					for (c = 0; c < nCat; c++)
						if ((*s2)[0] == Cat[c][0] && catLoc < strlen(Cat[c]))
							*varRep = Cat[c][catLoc];
				   }
				   else if (cont)
					 cont = FALSE;
				}
				break;
			
			default:
				cont = TryCat( &env[j], &word[i], &m, &catLoc );
				
				if (cont && !m)
				{
					/* no category applied */
					
					cont = i < strlen(word) && word[i] == env[j];

					m = 1;
				}
				if (cont)
					i += m;

				if (!cont && optional)
					cont = TRUE;
		}
	}
	
	if (cont && printRules)
		printf( "   %s->%s /%s applies to %s at %i\n", 
		*s1, *s2, env, word, *n );
	
	return(cont);

} /*TryRule*/

/*
**	Transform
**
**	Apply the rules to a single word and return the result.
**
**	The rules are stated in the form string1/string2/environment, e.g.
**		f/h/#_V
**	which states that f changes to h at the beginning of a word before a 
**	vowel.
*/
char *Transform( char *input )
{
		   char inword[80];
	static char outword[80];

	char instr[10];
	char *s1, *s2;
	int i;
	int r;
	int n;
	
	strcpy( inword, input );
	
	/* Try to apply each rule in turn */ 
	
	for (r = 0; r < nRule; r++)
	{
		/* Initialize output of this rule to null */
		
		memset( outword, 0, 80 );	
		
		/* Check each position of the input word in turn */
		 
		i = 0;
		while (i < strlen(inword))
		{
			char varRep = 0;

			if (TryRule( inword, i, Rule[r], &n, &s1, &s2, &varRep ))
			{
				/* Rule applies at inword[n] */
				
				if (n)
					strncat( outword, &inword[i], n - i );
			
				if (varRep)
					outword[strlen(outword)] = varRep;
				else if (strlen(s2))
					strcat( outword, s2 );
				
				i = n + strlen(s1);
			} 
			else
			{
				/* Rule doesn't apply at this location */
				
				outword[strlen(outword)] = inword[i++];
			}
		}
		
		/* Output of one rule is input to next one */
		
		strcpy( inword, outword );
	}
	
	/* Return the output of the last rule */
	
	return(outword);
	
} /*Transform*/
	
/*
**	DoWords
**
**	Read in each word in turn from the input file,
**	transform it according to the rules,
**	and output it to the output file.
**
**	This algorithm ensures that word files of any size can be processed.
*/
void DoWords( char *lexname, char *outname )
{
	char filename[84];
	char inword[84];
	int  n = 0;
	FILE *f, *g;
	char *outword;
	
	sprintf( filename, "%s.lex", lexname );
	
	f = fopen( filename, "r" );
	if (!f)
	{
		printf( "File %s could not be read in.\n\n", filename );
		return;
	}
	
	sprintf( filename, "%s.out", outname );
	
	g = fopen( filename, "w" );
	if (!g)
	{
		printf( "File %s could not be created.\n\n", filename );
		fclose(f);
		return;
	}
	
	while (fgets( inword, 129, f))
	{
		n++;
		if (strlen(inword))
			inword[strlen(inword) - 1] = '\0';
		
		outword = Transform(inword);

		if (!printSourc)
		{
			if (toScreen)
				printf(     "%s\n", outword );
			fprintf( g, "%s\n", outword );
		}
		else if (bracketOut)
		{
			if (toScreen)
				printf(     "%s \t[%s]\n", outword, inword );
			fprintf( g, "%s \t[%s]\n", outword, inword );
		}
		else
		{
			if (toScreen)
				printf(     "%s --> %s\n", inword, outword );
			fprintf( g, "%s --> %s\n", inword, outword );
		}
	}
	
	fclose(f);
	fclose(g);
	
	printf( "%i word%s processed.\n", n, n == 1 ? "" : "s" );
	
} /*DoWords*/

/*
**	MAIN ROUTINE
**
**	Ask for name of project
**	Read in rules and input words
**	Apply transformations
**	Output words
**
*/
main( int argc, char **argv )
{
	int once = FALSE;
	char lexicon[65] = "\0";
	char rules[65] = "\0";

	/* Read command line arguments */
	int i;
	for (i = 1; i < argc; i++)
	{
		if (argv[i][0] == '-' && strlen(argv[i]) > 1)
		{
			switch (argv[i][1])
			{
			case 'p': case 'P':   printRules = 1;  break;
			case 'b': case 'B':   bracketOut = 1;  break;
			case 'l': case 'L':   printSourc = 0;  break;
			case 'f': case 'F':   toScreen   = 0;  break;				
			}
		}
		else if (!lexicon[0])
			strcpy( lexicon, argv[i] );
		else
			strcpy( rules, argv[i] );
	}

	once = lexicon[0] && rules[0];
	
	printf( "\nSOUND CHANGE APPLIER\n(C) 1992,2000 by Mark Rosenfelder\nFor more information see www.zompist.com\n\n" );
	
	if (once)
	{
		printf( "Applying %s.sc to %s.lex\n\n", lexicon, rules );

		if (ReadRules( rules ))
			DoWords( lexicon, rules );
	}
	else
	{
		int done = FALSE;
		while (!done)
		{
			printf( "\nEnter the name of a LEXICON.\n\n" );
			printf( "For example, enter latin to specify latin.lex.\nEnter q to quit the program.\n-->" );
			
			fgets( lexicon, 65, stdin );

			if (strlen(lexicon))
				lexicon[strlen(lexicon) - 1] = '\0';

			if (!strcmp( lexicon, "q" ))
				done = TRUE;
			else
			{
				printf( "Enter the name of a RULES FILE.\n\n" );
				printf( "For example, enter french to specify french.sc.\n" );
				printf( "The output words would be stored in french.out.\n-->" );
			
				fgets( rules, 65, stdin );
				
				if (strlen(rules))
					rules[strlen(rules) - 1] = '\0';

				if (ReadRules( rules ))
					DoWords( lexicon, rules );
			}
		}
	}
	
	printf( "\nThank you for using the SOUND CHANGE APPLIER!\n" );
	
} /*main*/