FST: Finite State Transducer compiler

This is a simple system meant to make it easier to write god-awful
state machine tables.  Actually, it makes it so you never have to
write a table.

To use this program, type (for example)

     % fst -o turkish.rul turkish.fst 

That writes a file "turkish.rul", which is in KIMMO format, from the
fst file "turkish.fst".  I refuse to give BNF syntax diagrams of fst
format, but here's an example.  (This is the file "test.fst" in the
fst source directory, /mit/6.863/pckimmo108/fst/test.fst).

     subset vowel a e
     
     machine "ken"
     state foo
     vowel:vowel bar
     b:b foo
     c:c foo
     d:d foo
     others reject
     
     rejecting state bar
     b:e foo
     b:b reject
     others foo

This machine implements the well-known grammar rule, "b after a vowel
turns to e."  It contains two states (called foo and bar), the first
is the starting state.  If it sees a vowel paired with another vowel,
it goes to state bar where, if it sees a b, it must be paired with an
e.  The state table generated is smaller, but I think harder to edit:

     ALPHABET a e b c d
     NULL 0
     ANY @
     BOUNDARY #
     SUBSET vowel a e
     
     RULE "Bogus rule for KIMMO brain lossage" 1 6
      a e b c d @
      a e b c d @
     1:  1 1 1 1 1 1
     
     RULE "ken"   2 6
          vowel b c d b @
          vowel b c d e @
       1:     2 1 1 1 0 0
       2.     1 0 1 1 1 1
     END
     
Things to note... it does the alphabet for you, and makes assumptions
about the null, any, and boundary characters.  To get letters into the
alphabet that you never otherwise use, put them in a bogus subset.
Note that it creates for you the "bogus rule" so that kimmo knows that
x can always pair with x.  Ummm.. that's all, folks!