Directions on creating vicommand text from a transition table.

Each line of the table is one transition.
The first entry in the line is the current state for the transition,
the second the current symbol, the third the new state,
the fourth the new symbol, and the fifth the move.

The name of a state can be any string which does not contain "<" or ">"
or ":" or any symbol that could confuse vi.

Using the transition table, a sequence of vi commands can be created.

Here is an example of a transition table, the one for the machine tm.double:

<0, ,1, ,R>
<1,1,1,2,R>
<1, ,2,1,L>
<2,1,2,1,L>
<2,2,3,1,R>
<3,1,3,1,R>
<3, ,2,1,L>
<2, ,h, ,S>

When the text is pasted, edit commands are executed that ensure the
emulation of exactly one transition of the Turing machine, unless
the emulation has either halted or crashed.

Keywords "live" "run" "left" "c" and "h" are used.

The keyword "live" is inserted just before the state.
If the line contains <c: or <h> no transition can be emulated.
Therefore, the strings <live:c: is changed back to <c: and the
string <live:h> is changed back to <h>.

When a transition is emulated, "live:" changes to "run:" guaranteeing
that no more than one transition can be emulated in one step.

The first line is really three commands. Y and then p make a copy
of the configuration onto the next line.  We do not use these commands
if we do not wish to save the sequence of configurations.

The remaining command on the first line:
:s/</<live:/
introduces the keyword "live" just before the state name.  "live" is
the enabler, the keyword that enables the emulation of one transition.

The next two commands delete the enabler if the state name is either h or c,
indicating that the emulation has halted or crashed:
:s/<live:h>/<h>/
:s/<live:c/<c:/

The theoretical tape contains infinitely many blanks.  Obviously, we do not
need to write all of them explicitly for our emulation, but we might need to
write one more.  The next command creates the blank that is needed for the
emulation if the tape head is on a blank cell which is to the right of
all non-blank cells.
:s/>$/> /

The next set of commands consist of one vi command for each transition.
Each must be enabled by "live" and then destroys that enabler.  If
the transition move is either S or R, the keyword "run" is inserted
before the state name.  If the transition move is L, then the keyword
"left" is inserted.
:s/<live:0> / <run:1>/
:s/<live:1>1/2<run:1>/
:s/<live:1> /<left:2> /
:s/<live:2>1/<left:2>1/
:s/<live:2>2/1<run:3>/
:s/<live:3>1/1<run:3>/
:s/<live:3> /<left:2>1/
:s/<live:2> /<run:h> /

The next set of commands are needed for L moves.  The problem is
that since the configuration is written with the state designator
before (and not after) the current symbol, a left move must be
emulated by exchanging the state designator with they symbol on the
cell to the left.  In doing so, the keyword "left" is replaced by "run"
so that the exchange cannot occur more than once:
:s/ <left:2>/<run:2> /
:s/1<left:2>/<run:2>1/
:s/2<left:2>/<run:2>2/

If no transition was emulated, that means that the machine  must crash.
The enabler "live" will still be present, and is now replaces by the
keyword "c" indicating that a crash has occured:
:s/<live:/<c:/

Although it is not actually necessary, trailing blanks are now erased.
There could be two trailing blanks, but never more:
:s/ $//
:s/ $//

Finally, the keyword "run" is eliminated so that the resulting configuration
is clean:
:s/<run:/</

This command is only if you have no way to insert a final carriage return
when you use copy.  It effectively does nothing:
h

You could write a translator that would read the transition table
and write a vicommands file.  Using the above format for a transition
table, where commas are used as separators, it would not be allowed to
use a comma in the string which is the name of any state, as that would
confuse your translator.