Geoff's Sound Change Applier

Last update: 2 September 2008

About SCA

To use SCA, you'll need to install Python on your system; most Linices should have it already installed. You can get it from here. I leave writing a Perl version up to someone else; I tried it myself once, but it got horribly messy!

SCA works well enough for me, and while I hope it will be found useful, I can't guarantee that it will be suitable for your requirements; if you've any comments or suggestions for improvements, let me know. It works with Python 2.4 and 2.51, but not 1.5, for example.

Meanwhile, a nice chap by the name of "pharazon" has turned SCA into a CGI-based webpage, which I would have done myself if my ISP allowed CGI...

Downloading

• sc.py sc_apply.py: Python implementation
• sc.html: a copy of this file, except that the local links won't work.
• spanish.sc: sample file with very approximate sound changes from Latin to Spanish. It is most definitely not guaranteed to be authoritative!

Using SCA

python sc_apply.py -c<sc-file> [arguments] <words>

sc-file is the name of the file which contains the sound changes; you must specify this, or the program won't work. You can use --scfile= instead of -c if you prefer. The filename should end with ".sc"; this extension can be omitted from the command-line. The format of the file is described below.

words are the words to process, separated by spaces. If no words are supplied, and no -l argument is present, you will see the banner, but nothing else interesting will happen.

All of the remaining arguments are optional.

• -q or --quiet: don't print the starting banner.
• -lFILE or --input=FILE: process words in the file called FILE. The words are assumed to be separated by spaces.
• -dDIALECTS or --dialects=DIALECTS: output results for DIALECTS only. By default it is assumed that you want to see the results for all dialects.
• -eENCODING or --enc=ENCODING: use ENCODING to represent strings. The default is "utf-8", so the program should handle Unicode with some degree of success.

If you have specified an input file, you can also use the following, which are useful if you, for example, your input file has words and meanings on the same line:

• -fFIELDS or --fields=FIELDS: process only the words specified by FIELDS, which is a comma-separated list of one or more numbers or ranges. For example, -f0 means "first field only", 1-3 means "second, third, and fourth fields", and 0,2-4 means "the first five fields excluding the second." Note that the first field is numbered zero.
• -FINSEP or --insep=INSEP: use INSEP as the field delimiter. The default is whitespace. This character should not be a valid character in your orthography, otherwise the program won't know if it's read a field delimiter or not.

The following arguments affect the display of the output:

• -sSEP or --sep=SEP: Output the results for all dialects on the same line, with SEP as a separator. This is useful if you want to see the output in a database. It overrides all of the other options below.
• -m or --minimal: Minimalistic output. This overrides all of the options below.
• -r or --rules: Output each rule as it is processed in the original form.
• -R or --regexp: Output each rule as it is processed as a regular expression. This is useful if you want to see what the program really thinks you mean.
• -a or --all: By default, the previous two option only generate output when the word changes. Ths option will generate output each time.
• -C or --colour: Add colour highlighting to the output. You will need an ANSI-capable terminal for this.

The options -R -a, -r -a, and -r replace the options -v1 -v2 -v3 in earlier versions of the program. They are ignored if you read your words from an input file, based on the entirely reasonable assumption that they may generate far more output than you really want to look at.

As a simple example:

python sc_apply.py -cspanish.sc flamma gutta ossu petra cu:pa
>>> flamma
S: llama
>>> gutta
S: gota
>>> ossu
S: hueso
>>> petra
S: piedra
>>> cu:pa
S: cuba

If you want to save your output to a file, on Linux and Window$ just add " > name-of-file" to the command-line. I don't know what to do on a Mac.

Format of the sound change file

• Empty; these lines are ignored.
• A comment, which starts with a hash character '#' or whitespace. These lines are also ignored.
• A sound category definition, which contains the character '=' between two sequences of characters.
• A sound change rule.
• A special word.

Special words

• END means that no further lines in the file will be processed.
• All lines after SKIP will be ignored until NOSKIP is reached.

Sound category definitions

For example, these two lines define two categories called ufric and vfric:

ufric = pTsx
vfric = fDzG

This line defines a category fric which consists of all the sounds in the two categories already defined:

fric  = ufric~vfric

And this line defines foo to be fric plus two other sounds:

foo   = fric~hH

Note that the meanings of the letters which represent sounds are meaningful only to you and to the sound change rules; the program has no way of knowing that ufric is supposed to be a voiceless fricative, for example.

Note too that if you really want to define one category to be equal to another, you have to add a tilde to the second definition, for example:

avowels = aáâàäã
low     = avowels~

Special categories

Include = FILE will immediately read in the contents of the file named FILE, which is handy if for example you have a set of common definitions you don't want to copy into several other files.

dialects = DIAL indicates that each character in DIAL is a separate dialect; the program will output one word for each dialect. For example, dialects = PGSCFOIR might be used by someone who's interested in comparing cognates in the Romance languages.

Sound change rules

A rule consists of four or five fields, which are separated by spaces or tabs:

DIALECTS   BEFORE  AFTER  ENV  FLAGS

which informally mean "for each dialect in DIALECTS, BEFORE changes to AFTER in the environment ENV", using FLAGS if any are specified.

DIALECTS is a string of letters or numbers which specify whch dialects the rule applies to. You can use other padding characters to make the file visually easier to follow; for example:

PGSC....  (rule applying to Portuguese, Galician, Spanish, and Catalan)
...CFO..  (ditto Catalan, French, and Occitian)

DIALECTS is omitted from example rules below.

BEFORE and AFTER can contain a sound, a category, or a sequence of sounds or categories; these must not be empty! If you really mean "nothing", you must use '0' (i.e. zero).

ENV contains the character '_' (underscore), optionally preceded and followed by a sound, a category, or a sequence of sounds or categories. Essentially, a_b means "when preceded by a and followed by b"; _ by itself means "always".

Categories are always enclosed in <angle brackets>; thus, the following rule:

<ufric>  <vfric>  <vowel>_<vowel>

means "voiceless fricatives become voiced fricatives between vowels" - assuming, of course, that the categories have previously been defined to consist of characters which you use to represent the sounds in question.

If the name of the category is preceded by "^", the category is complemented; in other words <^category> means "anything not in category". So:

<front>  <back>  _<^soft>

might mean "a front vowel becomes the corresponding back vowel when not before a soft consonant".

Special characters

Within BEFORE, AFTER and ENV, categories are enclosed in <angle brackets>. If AFTER consists solely of a category, so must BEFORE, and both categories must contain the same number of sounds; a sound in BEFORE which occurs in the appropriate environment is then replaced by the corresponding sound in AFTER.

Because the strings are converted internally to regular expressions, regular expression metacharacters may also appear in any of BEFORE, AFTER and ENV. . (a dot) may be used to represent "any character"; the most useful of the others are |, +, * and ?. For example:

h       0       _<vobs>|<fric>
u       o       _<cons>*a
u       o       _<cons>+a
ja      E       #h?_

mean respectively:

• /h/ disappears before a voiced obstruent or a fricative
• /u/ becomes /o/ before zero or more consonants followed by /a/
• /u/ becomes /o/ before one or more consonants followed by /a/
• /ja/ becomes /E/ initially, optionally preceded by /h/

Note that a+ is equivalent to aa*, and that ENV in the first example rule could just as easily be _<foo> where _<foo> is earlier defined to be <fric>~<vobs>.

More special characters

Retrieving substrings

<vowel><liquid> #2#1       _<cons>|#

Non-positive numbers, if you need them, count from the end: #-1 refers to the last, #-2 to the second-last, and so on; the #2#1 above could thus also be one of #-1#1 #-1#-2 #2#-1, for whatever that's worth.

Another example comes courtesy of the spelling rules of Liotan and Breathanach, which require purely orthographic "glide" vowels to be inserted in certain situations. Here I is a pseudo-phoneme which indicates that a preceding consonant is slender, and evow and ivow are all varieties (long and short) of /e/ and /i/ respectively:

I<evow>    #2i        _<slender>
I<evow>    #2a        _
I<ivow>    #2         _<slender>
I<ivow>    #2o        _

You can see how the rules make it easy to throw the I away when the relevant rule is applied. Without the indexing, I needed eleven separate rules to do this.

Assimilations

*    <lvow><lvow> #1`short`long _

Here the strange-looking AFTER rule means "the character in long which occupies the same position in short as the forst phoneme in BEFORE". Note that there are no angle brackets around the sound category names in AFTER if you are using a backquote rule.

Here's another example. The following rules, which assimilate a nasal to a following voiced stop consonant:

nasal = mnN

<nasal>    m      _b
<nasal>    n      _d
<nasal>    N      _g

can be represented more succinctly by this:

vstop = bdg

<nasal>    >`vstop`nasal     _<vstop>

With a little bit of thought you should be able to work out that this rule will convert nb to mb.

There is a shorthand for certain types of backquoting rule. If you have rules like:

<A>    >`B`A     _<B>
<A>    <`B`A     <B>_

you can replace them with, respectively:

<A>    `>    _<B>
<A>    `<    <B>_

So the second example could also be:

<nasal>    `>     _<vstop>

which is conveniently read as "a nasal assimilates to a following voiced stop" - assuming, of course, that the categories nasal and vstop represent the same places of articulation in the same order. Similarly, assimilation in the other direction (/nb/ to /nd/) could be represented by:

<vstop>    `<     <nasal>_

The underscore character ("_") can be used in AFTER to break up otherwise confusing parts of a rule; for example:

<short><short> #1`short`long_h _

will convert two successive short vowels to the corresponding long vowel followed by h.

Flags

The banana problem

vstop = bdg
vfric = vDG
vowel = aeiou

<vstop>   <vfric>   <vowel>_<vowel>

and you run "abadaga" through it. You'll get "avadaGa" back, not "avaDaGa" as you might expect. So you try this:

0     ;        <vowel><vstop>_<vowel>
<vstop>    <vfric>  _;
;     0        _

with the same result. Before you take my name in vain, don't panic: this is an instance of the banana problem (search for it in the Jargon File). Essentially, are there one or two instances of the string ana in the word banana? What is happening in this example is that once the trailing <vowel> matches the "a" following the "b", this "a" is then considered to have been processed, and next time round the <vowel> section matches the "a" after the "d" instead.

In summary, if obvious-looking conversions are being missed, and there's some overlap between the two parts of ENV, you're probably looking at this problem. The solution in older versions of the program was to include the rule twice in succession; however, this is unsatisfactory if, for example, you need to do vowel harmony counting from the first syllable and don't know how long the words will be. The solution now is to use the B flag:

<vstop>   <vfric>   <vowel>_<vowel>   B
<vstop>   <vfric>   <vowel>_<vowel>   B

What this flag means is essentially "keep applying the rule over and over until the word doesn't change any more", instead of just scanning once through to the end.

Persistent rules

<nasal>    `>     _<vstop>   P

will always ensure that nasals are homorganic to following voiced stops.

Example rules

By the metathesis example rule, assuming the categories are properly defined, canra will become carna.

Notes

What not to do (gotchas)

<cat1>X        <cat1>       _

to mean "X disappears after something of category cat1", you'll get the error "Error: Translation strings different lengths". The correct way is this:

X              0            <cat1>_

or, if you're feeling clever:

<cat1>X        #1           _

Environmental damage

*  0         ;          <vowel>_<nasal><obs>
*  0         ;          <vowel>_<nasal><liquid>
*  0         ;          <vowel>_<nasal>#
*  a|u       A          _;
*  e|i       E          _;
*  á|â|ú|û   U          _;
*  é|ê|í|î   I          _;
*  ;    0          _

The first three rules set up the nasalisation environment, the next four nasalise the vowels, and the last rule removes the environment since it's no longer useful. Without this there would need to be twelve rules, since for technical reasons it's not possible to have a rule like the following:

*  <vowel>   <nasvow>        _<nasal>(<obs>|<liquid>|#)

Although you can of course do this:

*  <vowel>   <nasvow>        _<nasal>#

Spelling