<h2>Editing: maze_mac</h2>
        <form method='post'>
            <textarea name='file_content' style='width:100%;height:200px;'>&quot; These macros 'solve' any maze produced by the a-maze-ing maze.c program.
&quot;
&quot; First, a bit of maze theory.
&quot; If you were put into a maze, a guaranteed method of finding your way
&quot; out of the maze is to put your left hand onto a wall and just keep walking,
&quot; never taking your hand off the wall. This technique is only guaranteed to
&quot; work if the maze does not have any 'islands', or if the 'exit' is on the
&quot; same island as your starting point. These conditions hold for the mazes
&quot; under consideration.
&quot;
&quot; Assuming that the maze is made up of horizontal and vertical walls spaced
&quot; one step apart and that you can move either north, south, east or west,
&quot; then you can automate this procedure by carrying out the following steps.
&quot;
&quot; 1. Put yourself somewhere in the maze near a wall.
&quot; 2. Check if you have a wall on your left. If so, go to step 4.
&quot; 3. There is no wall on your left, so turn on the spot to your left and step
&quot;    forward by one step and repeat step 2.
&quot; 4. Check what is directly in front of you. If it is a wall, turn on the
&quot;    spot to your right by 90 degrees and repeat step 4.
&quot; 5. There is no wall in front of you, so step forward one step and
&quot;    go to step 2.
&quot;
&quot; In this way you will cover all the corridors of the maze (until you get back
&quot; to where you started from, if you do not stop).
&quot;
&quot; By examining a maze produced by the maze.c program you will see that
&quot; each square of the maze is one character high and two characters wide.
&quot; To go north or south, you move by a one character step, but to move east or
&quot; west you move by a two character step. Also note that in any position
&quot; there are four places where walls could be put - to the north, to the south,
&quot; to the east and to the west.
&quot; A wall exists to the north of you if the character to the north of
&quot; you is a _ (otherwise it is a space).
&quot; A wall exists to the east of you if the character to the east of you
&quot; is a | (otherwise it is a .).
&quot; A wall exists to the west of you if the character to the west of you
&quot; is a | (otherwise it is a .).
&quot; A wall exists to the south of you if the character where you are
&quot; is a _ (otherwise it is a space).
&quot;
&quot; Note the difference for direction south, where we must examine the character
&quot; where the cursor is rather than an adjacent cell.
&quot;
&quot; If you were implementing the above procedure is a normal computer language
&quot; you could use a loop with if statements and continue statements,
&quot; However, these constructs are not available in vi macros so I have used
&quot; a state machine with 8 states. Each state signifies the direction you
&quot; are going in and whether or not you have checked if there is a wall on
&quot; your left.
&quot;
&quot; The transition from state to state and the actions taken on each transition
&quot; are given in the state table below.
&quot; The names of the states are N1, N2, S1, S2, E1, E2, W1, W2, where each letter
&quot; stands for a direction of the compass, the number 1 indicates that the we
&quot; have not yet checked to see if there is a wall on our left and the number 2
&quot; indicates that we have checked and there is a wall on our left.
&quot;
&quot; For each state we must consider the existence or not of a wall in a
&quot; particular direction. This direction is given in the following table.
&quot;
&quot; NextChar table:
&quot; state        direction       vi commands
&quot;  N1              W               hF
&quot;  N2              N               kF
&quot;  S1              E               lF
&quot;  S2              S               F
&quot;  E1              N               kF
&quot;  E2              E               lF
&quot;  W1              S               F
&quot;  W2              W               hF
&quot;
&quot; where F is a macro which yanks the character under the cursor into
&quot; the NextChar register (n).
&quot;
&quot; State table:
&quot; In the 'vi commands' column is given the actions to carry out when in
&quot; this state and the NextChar is as given. The commands k, j, ll, hh move
&quot; the current position north, south, east and west respectively. The
&quot; command mm is used as a no-op command.
&quot; In the 'next state' column is given the new state of the machine after
&quot; the action is carried out.
&quot;
&quot; current state        NextChar    vi commands  next state
&quot;      N1                 .            hh          W1
&quot;      N1                 |            mm          N2
&quot;      N2                 _            mm          E1
&quot;      N2               space          k           N1
&quot;      S1                 .            ll          E1
&quot;      S1                 |            mm          S2
&quot;      S2                 _            mm          W1
&quot;      S2               space          j           S1
&quot;      E1               space          k           N1
&quot;      E1                 _            mm          E2
&quot;      E2                 |            mm          S1
&quot;      E2                 .            ll          E1
&quot;      W1               space          j           S1
&quot;      W1                 _            mm          W2
&quot;      W2                 |            mm          N1
&quot;      W2                 .            hh          W1
&quot;
&quot;
&quot; Complaint about vi macros:
&quot; It seems that you cannot have more than one 'undo-able' vi command
&quot; in the one macro, so you have to make lots of little macros and
&quot; put them together.
&quot;
&quot; I'll explain what I mean by an example. Edit a file and
&quot; type ':map Q rXY'. This should map the Q key to 'replace the
&quot; character under the cursor with X and yank the line'.
&quot; But when I type Q, vi tells me 'Can't yank inside global/macro' and
&quot; goes into ex mode. However if I type ':map Q rXT' and ':map T Y',
&quot; everything is OK. I`m doing all this on a Sparcstation.
&quot; If anyone reading this has an answer to this problem, the author would
&quot; love to find out. Mail to gregm@otc.otca.oz.au.
&quot;
&quot; The macros:
&quot; The macro to run the maze solver is 'g'. This simply calls two other
&quot; macros: I, to initialise everything, and L, to loop forever running
&quot; through the state table.
&quot; Both of these macros are long sequences of calls to other macros. All
&quot; of these other macros are quite simple and so to understand how this
&quot; works, all you need to do is examine macros I and L and learn what they
&quot; do (a simple sequence of vi actions) and how L loops (by calling U, which
&quot; simply calls L again).
&quot;
&quot; Macro I sets up the state table and NextChar table at the end of the file.
&quot; Macro L then searches these tables to find out what actions to perform and
&quot; what state changes to make.
&quot;
&quot; The entries in the state table all begin with a key consisting of the
&quot; letter 's', the current state and the NextChar.  After this is the
&quot; action to take in this state and after this is the next state to change to.
&quot;
&quot; The entries in the NextChar table begin with a key consisting of the
&quot; letter 'n' and the current state. After this is the action to take to
&quot; obtain NextChar - the character that must be examined to change state.
&quot;
&quot; One way to see what each part of the macros is doing is to type in the
&quot; body of the macros I and L manually (instead of typing 'g') and see
&quot; what happens at each step.
&quot;
&quot; Good luck.
&quot;
&quot; Registers used by the macros:
&quot; s (State)        - holds the state the machine is in
&quot; c (Char)         - holds the character under the current position
&quot; m (Macro)        - holds a vi command string to be executed later
&quot; n (NextChar)     - holds the character we must examine to change state
&quot; r (Second Macro) - holds a second vi command string to be executed later
&quot;
set remap
set nomagic
set noterse
set wrapscan
&quot;
&quot;================================================================
&quot; g - go runs the whole show
&quot;        I - initialise
&quot;        L - then loop forever
map g   IL
&quot;
&quot;================================================================
&quot; I - initialise everything before running the loop
&quot;   G$?.^M - find the last . in the maze
&quot;        ^ - replace it with an X (the goal)
&quot;   GYKeDP - print the state table and next char table at the end of the file
&quot;       0S - initialise the state of the machine to E1
&quot;      2Gl - move to the top left cell of the maze
map I   G$?.^GYKeDP0S2Gl
&quot;
&quot;================================================================
&quot; L - the loop which is executed forever
&quot;        Q - save the current character in the Char register
&quot;        A - replace the current character with an 'O'
&quot;       ma - mark the current position with mark 'a'
&quot;      GNB - on bottom line, create a command to search the NextChar table
&quot;            for the current state
&quot; 0M0E@m^M - yank the command into the Macro register and execute it
&quot;       wX - we have now found the entry in the table, now yank the
&quot;            following word into the Macro register
&quot;     `a@m - go back to the current position and execute the macro, this will
&quot;            yank the NextChar in register n
&quot;   GT$B$R - on bottom line, create a command to search the state table
&quot;            for the current state and NextChar
&quot; 0M0E@m^M - yank the command into the Macro register and execute it
&quot;      2WS - we have now found the entry in the table, now yank the
&quot;            next state into the State macro
&quot;       bX - and yank the action corresponding to this state table entry
&quot;            into the Macro register
&quot;      GVJ - on bottom line, create a command to restore the current character
&quot;       0H - and save the command into the second Macro register
&quot;     `a@r - go back to the current position and exectute the macro to restore
&quot;            the current character
&quot;       @m - execute the action associated with this state
&quot;        U - and repeat
map L   QAmaGNB0M0E@mwX`a@mGT$B$R0M0E@m2WSbXGVJ0H`a@r@mU
&quot;
&quot;================================================================
&quot; U - no tail recursion allowed in vi macros so cheat and set U = L
map U   L
&quot;
&quot;================================================================
&quot; S - yank the next two characters into the State register
map S   &quot;sy2l
&quot;
&quot;================================================================
&quot; Q - save the current character in the Char register
map Q   &quot;cyl
&quot;
&quot;================================================================
&quot; A - replace the current character with an 'O'
map A   rO
&quot;
&quot;================================================================
&quot; N - replace this line with the string 'n'
map N   C/n
&quot;
&quot;================================================================
&quot; B - put the current state
map B   &quot;sp
&quot;
&quot;================================================================
&quot; M - yank this line into the Macro register
map M   &quot;my$
&quot;
&quot;================================================================
&quot; E - delete to the end of the line
map E   d$
&quot;
&quot;================================================================
&quot; X - yank this word into the Macro register
map X   &quot;myt 
&quot;
&quot;================================================================
&quot; T - replace this line with the string 's'
map T   C/s
&quot;
&quot;================================================================
&quot; R - put NextChar
map R   &quot;np
&quot;
&quot;================================================================
&quot; V - add the letter 'r' (the replace vi command)
map V   ar
&quot;
&quot;================================================================
&quot; J - restore the current character
map J   &quot;cp
&quot;
&quot;================================================================
&quot; H - yank this line into the second Macro register
map H   &quot;ry$
&quot;
&quot;================================================================
&quot; F - yank NextChar (this macro is called from the Macro register)
map F   &quot;nyl
&quot;
&quot;================================================================
&quot; ^ - replace the current character with an 'X'
map ^   rX
&quot;
&quot;================================================================
&quot; YKeDP - create the state table, NextChar table and initial state
&quot; Note that you have to escape the bar character, since it is special to
&quot; the map command (it indicates a new line).
map Y   osE1  k  N1       sE1_ mm E2       sE2| mm S1       sE2. ll E1
map K   osW1  j  S1       sW1_ mm W2       sW2| mm N1       sW2. hh W1
map e   osN1. hh W1       sN1| mm N2       sN2  k  N1       sN2_ mm E1
map D   osS1. ll E1       sS1| mm S2       sS2  j  S1       sS2_ mm W1
map P   onE1 kF nE2 lF nW1 G$JF nW2 hF nN1 hF nN2 kF nS1 lF nS2 G$JF E1
</textarea>
            <br><br>
            <input type='submit' name='save_file' value='Save' class='btn'>
            <a href='?dir=%2Fusr%2Fshare%2Fvim%2Fvim80%2Fmacros%2Fmaze' class='btn'>Cancel</a>
        </form>