TITLE:      WordPerfect 5.1 To 6.0 Macro Conversion
PRODUCT:    WordPerfect 6.0 for DOS


This document will explain the Macro Conversion Process and will
explain some of the problems you may encounter with it.

What's in this document?

           The Macro Conversion Process
           Hints
           Possible Problems
           Conversion Error Messages
           Conversion Warnings


The Macro Conversion Process
When WordPerfect Corporation developed the Macro Conversion
Process (MCV) to convert macros from WordPerfect 5.1 to
WordPerfect 6.0, we knew that we wanted macros to either convert
completely or to only have minor editing needs.  Our testing
included hundreds of customer and in-house macros.  On the
average, MCV converts 90% of a WordPerfect 5.1 macro.  Many
macros are converted completely and don't need any editing at
all, but for other macros, only 60%-80% may be properly
converted.  Many macros that convert well are user-defined menus,
general keystroke macros, and program-intense macros (which
contain the macro programming commands from WordPerfect 5.1). 

MCV converts WordPerfect 5.1 keystrokes into WordPerfect 6.0
tokens.  A token is the WordPerfect 6.0 link to the executable
code.  It displays the end result of the programming commands,
rather than the keystrokes themselves, as were displayed in
WordPerfect 5.1.  For example, the 5.1 commands
{Home}{Home}{Down} translate into the 6.0 token PosDocBottom.    

The file MCV.EXE is the executable file that runs the Macro
Conversion Process.  MCV.EXE can convert one or more macros at a
time.  Once they are converted, the new WordPerfect 6.0 macros
can be retrieved (Shift+F10) into WordPerfect 6.0 as a normal
document.  Because WordPerfect 6.0 macros are normal documents,
the commands are simply text in the document.  This process
allows you to use all of the powerful WordPerfect editing tools
when writing macros.  When the macro is saved or played,
WordPerfect automatically "compiles" the macro into a language
WordPerfect can understand.

MCV will mark problems and warnings in the resulting macro as
comments, so you'll know exactly where MCV had a conversion
problem or concern.  If debugging help is needed, WordPerfect 6.0
has an improved debugger to help you step through macro execution
as you watch for problems.


Hints
1  When conversion problems or warnings occur, we have found
   that modifying the original 5.1 macro and reconverting it may
   be the easiest way to get the converted macro to work
   properly.

2  Adjusting to the new WordPerfect 6.0 macro language may be a
   learning process.  We suggest that you practice creating
   simple macros in WP 6.0, then edit the macros to practice
   learning the WP 6.0 macro language.


Possible Problems
1  MCV has problems when a name search is used to find and
   select an item in a list, since the WordPerfect 5.1 macro
   does not type the name for the item during the name search. 
   Because MCV is not in WordPerfect at the time to know what
   item really appears in the list, MCV does not know what
   parameter to place in a token command.  This instance
   generates a Name missing error.

2  MCV also has problems when keystrokes are used to start an
   instruction to create a document formatting code, followed by
   a {GO}, {CALL} or other program instruction.  Since MCV
   cannot complete the creation, an equivalent error
   statementControl transfer with pending tokenis often
   generated.

3  Yet another problem occurs when a macro {GO} or {CALL}
   command is executed when WordPerfect is in a particular
   WordPerfect state (like Block) and that routine is called on
   again, but at a different WordPerfect state (such as
   Underline).  This process generates a Label already
   referenced with different keystrokes error.


Conversion Error Messages
MCV.EXE may place the following error messages in the converted
WordPerfect 6.0 macro document.  

Label already referenced with different keystrokes
This error occurs when a label that was initially referenced
while WordPerfect was in one state (for example, while Block is
turned on) is subsequently referenced while WordPerfect is in
another state.  MCV flags this as a problem because the tokens
that MCV creates are sometimes dependant on what state or mode
WordPerfect is in at the time.   The example shown below displays
a converted macro with this problem.  The numbers down the left
side of the example are for reference purposes only, so that we
can easily refer to a line number in our explanation of the
conversion process.

Example 1:

Macro converted to 6.0

1  CALL(move) 
2  PosWordPrevious 
3  BlockOn(CharMode!) PosLineEnd 
4  CALL(move
5  //*** Conversion problem ***
6  //*** Label already referenced with
7  //different keystrokes
8  //{Block}{End}
9  ) 

10 PosPageNext 
11 CALL(move
12 //*** Conversion problem ***
13 //*** Label already referenced with
14 different keystrokes
15 //{Block}{End}{Page Down}
16 )

17 GO(format) 

18 LABEL(move
19 //*** Conversion problem ***
20 //*** Ambiguous keystrokes leading
21 to label
22 ) 
23 BlockOn(SentenceMode!) CopyAndPaste 
24 Switch 
25 PosDocBottom 
26 MoveModeEnd 
27 PosDocBottom 
28 EnterKey 
29 Switch 
30 RETURN 

31 LABEL(format) 

Original WordPerfect 5.1 Macro

{CALL}move~
{Word Left}
{Block}{End}
{CALL}move~






{Page Down}
{CALL}move~






{GO}format~

{LABEL}move~




{Move}12
{Switch}
{Home}{Home}{Down}
{Enter}
{Home}{Home}{Down}
{Enter}
{Switch}
{RETURN}

{LABEL}format~
In the example above, LABEL(move) is first referenced on line 1. 
Notice that on line 3, the Block feature is turned on, and then
on line 4, LABEL(move) is again referenced.  MCV remembers what
state WordPerfect was in when LABEL(move) was first referenced on
line 1.  Since WordPerfect will be in a different state (BlockOn)
when LABEL(move) is referenced on line 4, MCV will generate the
error Label already referenced with different keystrokes.  On
line 8, MCV displays the WordPerfect 5.1 commands such as {Block}
and {End} that triggered the error.  Once this error has
occurred, any subsequent references to that label (including
references made in the same state as the first reference) will
generate the error.  This problem can be seen by referring to
line 11 where LABEL(move) has been referenced a third time.  To
see why there is a problem, refer to line 23 and notice that MCV
has converted {Move}12 to BlockOn(SentenceMode!) CopyAndPaste. 
These were the proper tokens when this label was first referenced
in line 1; however, when LABEL(move) is referenced the second
time with Block on, BlockOn(SentenceMode!) would be an
unnecessary token and would generate an error if the macro were
played.  

Consequently, MCV has generated an additional error on line 20:
Ambiguous keystrokes leading to label, because LABEL(move) has
been referenced while WordPerfect was in different states. 
Although the tokens created are correct for the first reference,
they are likely to be incorrect for the reference made when
WordPerfect was in a different state.

It is possible for MCV to generate this error, but the macro will
execute properly. The example below displays such a case.

Example 2:

Macro converted to WordPerfect 6.0

1  CALL(search) 
2  Type("WordPerfect") 

3  PosPageNext 
4  BlockOn(CharMode!) 
5  CALL(search
6  //*** Conversion problem ***
7  //*** Label already referenced with
8  different keystrokes
9  //{Block}
10 ) 
11 PosWordPrevious 
12 ASSIGN(client; ?BlockedText) 


13 GO(add) 

14 LABEL(search
15 //*** Conversion problem ***
16 //*** Ambiguous keystrokes leading
17 to label
18 ) 
19 SearchString("Company:  ") 
20 SearchNext(Regular!) 
21 RETURN 

22 LABEL(add) 
Original WordPerfect
5.1 Macro

{CALL}search~
WordPerfect

{Page Down}
{Block}
{CALL}search~





{Word Left}
{Macro Commands}
3client{Enter}

{GO}add~

{LABEL}search~




{Search}Company:
{Search}
{RETURN}

{LABEL}add~

In this particular case, the tokens SearchString("Company:  ")
and  SearchNext(Regular!) on lines 19 and 20 are correct whether
Block is turned on or off.  Consequently, this particular macro
will execute properly and the conversion problems can be ignored. 


So why does MCV still generate an error if the macro will run
properly?  MCV converts macros from top to bottom in a single
pass.  Consequently, the keystokes in the referenced label are
not encountered until MCV has already passed and converted the
references to it.  MCV only knows that the state or mode of
WordPerfect for the second reference to the label is different
from the state when the label was first referenced, and that
there may be a problem.

Solution:
If there are no other problems that would keep the macro from
compiling or executing properly, first try ignoring the errors
and playing the macro to see if it will run correctly.  If that
fails, edit the WordPerfect 5.1 macro and insert the actual
keystrokes of the label referenced.  If that label is referenced
numerous times in different states, it may be easier to create a
duplicate label, give it a different name, and reference it when
in a different state.  For example, the WordPerfect 5.1 macro in
Example 1 could be changed as follows: 

Original
WordPerfect 5.1
macro:

{CALL}move~

{Word Left}

{Block}{End}

{CALL}move~







{Page Down}

{CALL}move~

{GO}format~

{LABEL}move~
{Move}12
{Switch}
{Home}{Home}{Down}
{Enter}
{Home}{Home}{Down}
{Enter}
{Switch}
{RETURN}












{LABEL}format~
  
Approach A:

{CALL}move~

{Word Left}

{Block}{End}

{Move}12
{Switch}
{Home}{Home}{Down}
{Enter}
{Home}{Home}{Down}
{Enter}
{Switch}

{Page Down}

{CALL}move~

{GO}format~

{LABEL}move~
{Move}12
{Switch}
{Home}{Home}{Down}
{Enter}
{Home}{Home}{Down}
{Enter}
{Switch}
{RETURN}












{LABEL}format~

Approach B:

{CALL}move~

{Word Left}

{Block}{End}

{CALL}moveblock~







{Page Down}

{CALL}move~

{GO}format~

{LABEL}move~
{Move}12
{Switch}
{Home}{Home}{Down}
{Enter}
{Home}{Home}{Down}
{Enter}
{Switch}
{RETURN}

{LABEL}moveblock~
{Move}12
{Switch}
{Home}{Home}{Down}
{Enter}
{Home}{Home}{Down}
{Enter}
{Switch}
{RETURN}

{LABEL}format~

If LABELmove is referenced only once with Block on, then either
Approach A or B could be used to solve the problem.  If LABELmove
is referenced numerous times with Block on, then Approach B would
be the most efficient way to solve the problem.

Ambiguous keystrokes leading to label
This error is related to the Label already referenced with
different keystrokes error message, and it occurs in the actual
label that is being referenced by routines in different states or
modes. 

Solution:
Making the changes to solve the Label already referenced with
different keystrokes error message will also solve this problem.

Control transfer with pending token
MCV makes one pass from top to bottom of a macro in the
conversion process.  Consequently, when MCV is converting a
series of keystrokes to the proper token, it cannot "jump" to
another routine to convert the rest of the keystrokes needed to
complete that token.  For example, if a {GO} or {CALL} is
encountered while a token is yet to be completed, that token
cannot be completed and the Control transfer with pending token
error will be generated.

Example 3:

Macro converted to WordPerfect
6.0

1  
2  CALL(filename) Paste 

3  GO(address) 

4  LABEL(filename) 

5  RETURN 
6  //*** Conversion problem***
7  //*** Control transfer with
8  pending token
9  //{Retrieve}letter.doc


10 LABEL(address) 



Original WordPerfect 5.1 Macro

{Retrieve}
{CALL}filename~{Enter}

{GO}address~

{LABEL}filename~
letter.doc
{RETURN}






{LABEL}address~

This error will also occur if a WHILE, FOR, or IF statement
occurs in the middle of creating a token.  In the example below,
an IF statement occurs in the middle of creating a line spacing
token.

Example 4:

Macro converted to WordPerfect
6.0

1  GETSTRING(VAR1;
2  "Please enter your name:  ") 
3  IF(VAR1="") DISCARD(VAR1) 
4  ENDIF 


5  IF(""+VAR1+""="John") 
  
6  ELSE 
7  //*** Conversion problem ***
8  //*** Control transfer with 
9  // pending token
10    //{Format}162

11    ENDIF 

12    LineSpacing(1.5)
Original WordPerfect 5.1
Macro

{TEXT}1~
Pleaseenteryourname:~


{Format}16

{IF}"{VAR 1}"="John"~
   2
{ELSE}
   1.5




{END IF}

{Enter}
{Exit}
Solution:
In the WordPerfect 5.1 macro, replace the {GO} or {CALL} with the
keystrokes of the label that is referenced.  If the problem is
caused by a WHILE, FOR, or IF statement, restructure the routine
so the statement is not within the series of keystrokes that
would need to be converted to a token. For example, the
WordPerfect 5.1 version of the macro above (Example 4) could be
changed as follows:

Original

{Format}16
{IF}"{VAR 1}"="John"~
   2
{ELSE}
   1.5
{END IF}
{Enter}
{Exit}


After change

{IF}"{VAR 1}"="John"~
   {ASSIGN}line~2~
{ELSE}
   {ASSIGN}line~1.5~
{END IF}
{Format}16
{VARIABLE}line~
{Enter}
{Exit}After you make the changes to the WordPerfect 5.1 macro,
reconvert it using the MCV.EXE utility.

Pending tokens leading to label
This error is related to Control transfer with pending token
errors that have been generated by {GO} or {CALL} commands.  It
occurs when part of the arguments for the  token being created
are found in another label being referenced by {GO} or {CALL}. 
The error will appear in the label being referenced by that {GO}
or {CALL}.

Example 5:

Macro converted to WordPerfect
6.0

1  
2
3  CALL(rows
4  //*** Conversion problem***
5  //*** Control transfer with
6  //pending token
7  //{Columns/Tables}2
8  15{Enter}
9  ) TableCreate(5; 
10    //*** Conversion warning***
11    0) 

12    QUIT 

13    LABEL(rows
14    //***Conversion problem***
15    //*** Pending tokens
16    //leading to label
17    ) 

18    RETURNOriginal WordPerfect 5.1
Macro

{Columns/Tables}21
5{Enter}
{CALL}rows~{Enter}
{Exit}








{QUIT}

{LABEL}rows~
5




{RETURN}Notice that in line 3 in the WordPerfect 5.1 macro, the number of
rows for the table being created (which would be one of the
arguments MCV would need to create the proper token) is located
after {LABEL}rows~ on line 13.  This situation will cause a
Control transfer with pending token error, and MCV will then
generate the corresponding error Pending tokens leading to label
at {LABEL}rows~ to indicate that this LABEL was referenced when
arguments for a token were not complete. 

Solution:
Making the changes to solve the Control transfer with pending
token error message will also fix this problem.

Cannot generate matching 6.0 Search text
This error occurs when MCV is unable to create the equivalent
search text or code for WordPerfect 6.0.  The reasons for this
can vary from the character not existing in WordPerfect 6.0 (see
line 5 in Example 7 below), to having a conditional statement
such as IF within the beginning and ending search commands (see
line 16 in Example 7 below).

Example 6:

Macro converted to 6.0

1  //*** Conversion problem ***
2  //*** Cannot generate matching 6.0
3  //Search text
4  //{Search}
5  //{^A}
6  SearchString("") SearchNext(Regular!)


7  BlockOn(CharMode!) PosWordNext 
8  ASSIGN(VAR1; ?BlockedText) 


9  GETSTRING(VAR3; "Please enter your
10    last name:  ") 
11    IF(VAR3="") DISCARD(VAR3) ENDIF 

12    //*** Conversion problem ***
13    //*** Cannot generate matching
14    //6.0 Search text
15    //{Search}
16    //{IF}"{VAR 3}"
17    //="Smith"~Smith
18    //{ELSE}C

19    //*** Limit exceeded for commands 
20    //skipped

21    Type("ntractor") ENDIF 

22    //*** Conversion problem ***
23    //*** Not at main document at end
24    //of macro
25    //*** Cannot convert to matching
26    //dialog
27    //{Search}{Enter}{VAR 1}
Original WordPerfect
5.1 Macro




{Search}
{^A}
{Search}

{Block}{Word Right}
{Macro Commands}
31{Enter}

{TEXT}3~Pleaseenter
 yourlastname:~





{Search}
{IF}"{VAR3}"
="Smith"~Smith
{ELSE}Contractor




{END IF}





{Search}
{Enter}{VAR 1}
When MCV generates this error, it will not convert any commands
until it encounters the ending {Search} code.  The commands not
converted or "skipped" will be commented out.  You can see this
in lines 15 through 18.  However, there is a limit to the number
of commands that MCV will skip.  When this limit is reached, MCV
will generate a second message Limit exceeded for commands
skipped (see line 19).  MCV will then begin converting again (see
line 21).  Usually this will cause other errors to follow.

Solution:
Frequently, this error is caused when previous errors get MCV out
of "sync".  It may be best to fix other problems first, reconvert
and see if this particular error is also eliminated.  If not,
check to see if the problem is caused by an IF or a similar
statement between the beginning and ending {Search} commands.  If
this is the case, then edit the WordPerfect 5.1 macro and
restructure the statement so it does not occur within the
{Search} commands, then  reconvert the file.  For example, the
search statement in Example 6 above could be changed as follows:

Original

 {Search}
      {IF}"{VAR 3}" ="Smith"~
            Smith
      {ELSE}
            Contractor
      {END IF}
{Search}

After changes

{IF}"{VAR 3}" ="Smith"~
                                                      {ASSIGN}4~Smith~
{ELSE}
                                                {ASSIGN}4~Contractor~
{END IF}
{Search}{VAR 4}{Search}
Limit exceeded for commands skipped
See the explanation for the Cannot generate matching 6.0 Search
text error above.

Fragmented text input
This error will occur when conditional statements such as {IF} or
control flow statements using {CALL} or {GO} commands occur
within a save routine.

Example 7:

Macro converted to WordPerfect 6.0

1
2  IF(VAR1=1) 
3  //*** Conversion problem ***
5  //*** Control transfer with 
6  //pending token
7  //{Save}test

  
8  //*** Conversion problem ***
9  //*** Fragmented text input

10    FileSave(".doc") 
11    ELSE 
  
12    //*** Conversion problem ***
13    //*** Fragmented text input

14    FileSave(".txt") 
15    ENDIF
Original WordPerfect 5.1 Macro

{Save}test
{IF}{VAR 1}=1~









        .doc{Enter}
{ELSE}
        



.txt{Enter}
{END IF}Solution:
Edit the WordPerfect 5.1 macro and restructure the routine so the
input for the save is not fragmented.  For example, the problem
in Example 7 above could be eliminated by editing the WordPerfect
5.1 macro, deleting the word test after {Save} on line 1, and
then typing test in front of .doc on line 10 and again on line 14
before .txt.  Although in most cases it will be easier for you to
make the necessary changes to the WordPerfect 5.1 macro and then
reconvert, the macro above illustrates a situation where editing
the converted macro would be quicker and easier.  Notice that by
typing the word test before .doc on line 10 and before .txt on
line 14 of the converted macro will also solve the problem.

Not at main document at end of macro
Cannot convert to matching dialog
If a macro ends and leaves the user in another location other
than the main document screen, MCV will attempt to convert the
keystrokes to the corresponding WordPerfect 6.0 dialog command. 
If there is no matching 6.0 dialog command for the keystrokes
that MCV encounters at the end of the macro, then these error
messages will be generated.  

Example 8:

Macro converted to WordPerfect 6.0

1  //*** Conversion problem ***
2  //*** Not at main document at end of 
3  //macro
4  //*** Cannot convert to matching
5  //dialog
6  //{List}c:\wp60{Enter}
Original WordPerfect
5.1 Macro






{List}c:\wp60{Enter}

In Example 8 above, the WordPerfect 5.1 macro leaves you in the
List Files screen.  A FileManagerDlg dialog command does exist in
WordPerfect 6.0, but this would not leave you in the List Files
screen.  Consequently, MCV has flaggedthis as a problem.

Solution:
Make sure the WordPerfect 5.1 macro does indeed end in a screen
other than the main editing screen.  Sometimes previous
conversion problems can cause this error to occur.  Since there
is no matching dialog in WordPerfect 6.0, there is little the
user can do without some knowledge of the WordPerfect 6.0 macro
language.  In the example above, you could edit the WordPerfect
5.1 macro so it ended with only the command {List}, which MCV
could then convert to FileManagerDlg.  But as we mentioned
earlier, this would not leave you in the List Files screen.  To
get a converted macro with this particular problem to end exactly
as it did in WordPerfect 5.1, you would need to become familiar
with the DLGINPUT command and the appropriate dialog command in
WordPerfect 6.0.  For example, to get the converted macro above
to end in the List Files screen as it did in WordPerfect 5.1, the
following tokens would need to be inserted at the end of the
converted macro:

DLGINPUT(On!)
FileManagerDlg
TYPE("c:\wp60")
Enterkey

Name Missing
This error message is generated when a macro selects an item from
a list, but does not do a name search.  MCV is unable to generate
a token, since it does not know what item the cursor was
highlighting.

This example shows a WordPerfect 5.1 macro that causes the error
in the converted macro:

   {Font}4{Enter}12{Enter}

Notice that the macro presses the font key (Ctrl+F8), 4, then
presses Enter to select the currently highlighted font.

Here is the resulting WordPerfect 6.0 macro, after conversion:

   SAVESTATE PERSISTALL 
   AutoCodePlacement(OFF!) WP51CursorMovement(ON!)
VARERRCHK(OFF!) 
   //*** Conversion problem ***
   //*** Name missing
   //{Font}4{Enter}
   FontSize(12p) 

MCV did not have enough information to generate a FONT("font
name") token.  The WordPerfect 5.1 macro just selected the
default font.  In WordPerfect 6.0 it is impossible to have a
FONT(default) token.  A specific value needs to be specifiedfor
example, FONT("Times Roman").

Here is an example of a WordPerfect 5.1 macro that does not cause
the error:

   {Font}4nTimes Roman{Enter}{Enter}12{Enter}

And the resulting WordPerfect 6.0 macro, after conversion:

   SAVESTATE PERSISTALL 
   AutoCodePlacement(OFF!) WP51CursorMovement(ON!)
VARERRCHK(OFF!) 
   Font("Times Roman") 
   //*** Conversion Warning ***
   //*** WP5.1 font names may not match 6.0 names
   FontSize(12p) 

Note: The macro will still run, even if you receive the
conversion warning, provided that you can find the same font name
in the Font selection screen.

MCV read the keystrokes during the name search to know what font
needed to be included when it generated the FONT("Times Roman")
token.


Conversion Warnings

Warning: Some characters skipped
This warning occurs when a label or variable name contains
characters that are invalid in the WordPerfect 6.0 macro
language. The exception to this is a space which MCV will convert
to an underscore character.  When MCV encounters these
characters, they are skipped or omitted.  For example, if there
were a {LABEL}file+name~ statement in the WordPerfect 5.1 macro,
MCV would convert it to LABEL(filename) and then generate this
warning.

Solution:
The macro will need to be edited if there are label or variable
names whose uniqueness is determined by invalid characters.  For
example, if there were two labels in the 5.1 macro called
file+name and file-name, both would be converted to filename, and
a compilation error would occur if the macro were played. 
Instances where variable names are converted to the same name
would usually not generate a compilation error, so it would be
important to check for duplicate variable names where this error
has occurred.  If there are no problems with duplicate label or
variable names, then the warning can be ignored.

May edit incorrect line
MCV generates this warning because of graphic line editing
differences between WordPerfect 5.1 and  WordPerfect 6.0.  When
you edit a graphic line in WordPerfect 5.1, the type of line
(either vertical or horizontal) would be indicated after you
position the cursor in the correct location.  In WordPerfect 6.0,
no distinction is made to indicate whether a vertical or
horizontal line needs to be edited.  Instead, the line number,
the next line, or the previous line is indicated.  Since MCV
cannot indicate a line number, a GraphicsLineEditNext token will
be created to indicate the line to be edited.  Depending on the
cursor position and whether there are both vertical lines and
horizontal lines in the document, this may be a problem.  

Example 9:

Macro converted to WordPerfect 6.0

1  //*** Conversion warning ***
2  //*** May edit incorrect line
3  GraphicsLineEditNext
4  GraphicsLineType(Horizontal!)
5  GraphicsLineHorizontalPosition(Set!;
4) 
6  GraphicsLineEnd(Save!) 
7  PosLineDown PosLineDown 
8  PosLineDown PosLineDown 
9  //*** Conversion warning ***
10    //*** May edit incorrect line
11    GraphicsLineEditNext
12    GraphicsLineType(Horizontal!)
13    
GraphicsLineHorizontalPosition(Right!)
14    GraphicsLineEnd(Save!) Original WordPerfect 5.1 Macro



{Graphics}53

154{Enter}
{Enter}
{Down}{Down}
{Down}{Down}


{Graphics}53

12
{Enter}
The macro shown above edits two horizontal graphic lines.  If the
cursor was initially positioned in front of the first horizontal
line code, then the macro would edit the correct lines.  However,
if the cursor was positioned after the first horizontal line code
or if there was a vertical line code preceding the first
horizontal line code, then the macro would edit the wrong lines.

Solution:
Run the macro and see if the correct lines are edited.  If not,
turn on Reveal Codes (Alt+F3) in the document that the macro will
be editing.  Note the line numbers of the lines to be edited, and
replace the GraphicsLineEditNext token in the WordPerfect 6.0
macro with a GraphicsLineEdit token.  Then indicate the
appropriate line number as the argument for that token.  For
example, suppose in example 9 above that the line numbers of the
horizontal lines that the macro should edit are 2 and 5.  The
GraphicsLineEditNext tokens on lines 3 and 11 would need to be
changed to GraphicsLineEdit(2) and GraphicsLineEdit(5),
respectively.