/*
** 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*/
