Dec 112017
 
MacroAid is a shareware collection of DOS utility programs for use with WordPerfect macros.
File MACRAIDD.ZIP from The Programmer’s Corner in
Category Word Perfect
MacroAid is a shareware collection of DOS utility programs for use with WordPerfect macros.
File Name File Size Zip Size Zip Type
MACARGS.EXE 12656 6731 deflated
MACASCII.EXE 34208 16367 deflated
MACCALLS.EXE 16240 8712 deflated
MACCHANG.EXE 7856 4377 deflated
MACCRUSH.EXE 15872 8722 deflated
MACFIND.EXE 19808 10398 deflated
MACREF.EXE 23808 11724 deflated
MACROAID.DOC 71513 22849 deflated
MACSHELL.EXE 167408 66461 deflated
OTHERS.TXT 10197 3361 deflated
SH.MRQ 3876 1554 deflated
WHATS.NEW 2843 1101 deflated

Download File MACRAIDD.ZIP Here

Contents of the MACROAID.DOC file



Copyright (c) 1990
David Seidman
Software by Seidman
2737 Devonshire Pl. NW
Washington, DC 20008

December 16, 1990


MACROAID Version 1

INTRODUCTION

MacroAid is a shareware collection of DOS utility programs for use with
WordPerfect Corporation (WPCorp) program macros. The programs work
with macros for WordPerfect 5.0 and 5.1, PlanPerfect 5.0 and 5.1,
DrawPerfect 1.0 and 1.1, ED 3.0, and Shell 3.0; they may work with
later versions and other programs as well, including LetterPerfect.
Several of these programs may be helpful to the casual user of macros,
but MacroAid is primarily intended for the serious macroist. Writing
WPCorp macros is computer programming, and MacroAid is a set of
programmer's tools.

The shareware distribution consists of this documentation in ASCII text
file format (MacroAid.DOC), one or more MRQ files (described below),
seven application programs (MacArgs, MacAscii, MacCalls, MacCrush,
MacChang, MacFind, and MacRef), and MacShell, a program designed to
make the other programs easier to use in some circumstances. Users who
pay the license fee will also receive a file with this documentation in
WordPerfect format and additional MRQ files. Other programs may be
added to MacroAid in the future; if so, they may be distributed only to
registered users.

Here are brief descriptions of the seven application programs:


MacArgs

Changes assignments to macro variables with DOS commands. The DOS command

MacArgs MyMacro.wpm -0Newstring -1AnotherString

changes

{ASSIGN}0~OldString~{ASSIGN}1~stuff~

to

{ASSIGN}0~NewString~{ASSIGN}1~AnotherString~

in MyMacro. Example uses: (1) write self-modifying macros that store
new information for later use, as for macros to number invoices
consecutively; (2) customize complex macros for different users.

MacAscii

Converts macros to ASCII text files or WordPerfect documents so that
they can be edited in WordPerfect or an ASCII text editor. MacAscii
also converts the ASCII text file or WordPerfect document back to a
macro. Allows editing of macros too big for the built-in macro editor;
editing of SH macros without WPCorp's ED editor; easy printing of
macros; use of powerful text processing and editing tools readily
available for ASCII text files.

MacCalls

Lists the files required by {CHAIN}, {NEST}, and {SHELL MACRO} commands
in a macro and the files required by these files.

MacCrush

Compresses macros by eliminating comments and the tabs and spaces used
only for formatting; replaces variable names and labels with two-
character names and labels. Makes your macros load and execute faster.

MacChang

Changes the product type and version numbers stored within macros.
Changing your carefully developed WordPerfect macros to PlanPerfect
macros, for example, sometimes results in a working PlanPerfect macro
and should always at least make the conversion process easier.

MacFind

Searches for text strings, macro commands, and key commands in macros
specified with wildcard file specifications.

MacRef

Provides a cross-reference listing of a macro -- a file with a line-
numbered version of the text of the macro and a listing of each macro
command, key command, variable name, shell variable name, label, and
called file, with the line numbers on which each appears. An essential
tool for the development and debugging of complex macros.



These programs run from the DOS command line. The command line
parameters that control program operation are described below.
(Running the program from the DOS command line without any parameters
specified will produce a brief explanation of program usage.) Because
these programs are not interactive, it is easy to use them in batch
files and to execute them from within macros. Many people find it
difficult to use programs that depend on complex command-line
parameters. MacShell provides another way to use the other seven
programs. It prompts the user for the necessary command line
parameters, constructs the appropriate command line, and executes the
desired program, so that the user need not worry about the command line
details. Even if you plan to use MacShell to run the other programs,
you should read the documentation for the other programs, so that you
will understand how they work and exactly what information MacShell
asks you to provide.

WordPerfect Corporation has no connection with these programs, except
that it provided much of the technical information necessary to writing
them.





Notes On Input and Output

Running any of the application programs generally requires supplying at
least one file name on the command line. Where no ambiguity is
possible, the program permits you simply to provide the filename. More
often, you must identify the function of the file by a "switch" on the
command line. For example, -ifname generally indicates that you want
to use file fname as an input file, and -ofname generally indicates
that you want to use file fname as an output file. (You may always use
/ instead of - if you prefer. The examples and illustrations here
sometimes use - and sometimes use /, to emphasize that you may use
either.) The letter, e.g., i, may appear in upper or lower case.
Where switches are used, the order in which you list the files does not
matter.

Filenames on the command line may always include drive and path
specifications. The individual program descriptions mention where
wildcards (* and ?) can be used. Several programs supply default
extensions if you give a filename without an extension. If a filename
should have no extension, you can avoid the default extension by ending
the filename with a period.

Some of these programs write their principal output to "standard
output" instead of to a file in the usual sense. Other programs write
their principal output to a file, but also write some other output to
"standard output." By default, standard output means the screen -- the
output goes to the screen in a continuous flow. This may not be what
you want, either because more than one screen's worth of output will be
generated or because you want to keep or otherwise use the output.
Instead of letting standard output go directly to the screen, you can
"pipe" it to another program, or "redirect" it to either the printer or
a file. The concepts of piping and redirection are explained in the
DOS manual. Because many users of WPCorp products are not very
familiar with piping and redirection, we will provide examples below,
in the discussion of particular programs. MacShell users can ignore
piping and redirection.



PROGRAMS


I. MacArgs

MacArgs allows you to change the contents of a WPCorp macro from the
DOS command line. It is not easy to explain exactly what MacArgs does,
or why it is useful, so this discussion will be a bit long and
complicated. But bear with us -- MacArgs can indeed be very useful.
(The name of the program comes from the fact that some of what you can
use the program for resembles passing arguments to a macro. If the
meaning of that is not clear to you, don't worry about it.)

The only parts of a macro MacArgs allows you to change are assignments
of values to variables 0 through 9, and only for one particular form of
such assignments. That is, MacArgs works ONLY with macro statements
that look like this:

{ASSIGN}0~string~

where what follows {ASSIGN} is a single digit. MacArgs will, for
example, change string to NewString. For any variable numbered from 0
to 9, MacArgs will change only the first assignment to that variable in
a macro. It can, if you want, make changes for variables 0, 1, .. , 9
in a single run of the program.

Explaining why this is useful will be easier after you see how to run
the program. It works like this:

>MacArgs MacName -0Arg [-1Arg ... -9Arg]


(Note: There is an alternative way to run MacArgs, discussed below.)

MacName Filename of the macro to modify. Extension defaults
to wpm, but other extensions are accepted (including
drm, plm, edm, and shm).

-0Arg Arg is new string to assign to VAR 0

-1Arg Arg is new string to assign to VAR 1

[etc.]

Args may appear in any order, and you may include as many or
as few as you like.


Restrictions:

(1) If any Arg includes blanks, that whole ARG must be enclosed
in quotation marks (single or double), e.g., -0"Has a blank".

(2) Enclose Arg in single quotes (' only, not `') if it includes
double quotes. Enclose Arg in double quotes if it includes
single quotes.

(3) Arg may not include |, >, or <.

(4) Each Arg is limited to 100 characters.

(5) The size of the macro is limited to 55,000 bytes.


(Note: if you redirect the program output to NUL, no output will
appear on screen. To do that, simply add >NUL to the end of the
command line.)


Example:

Suppose we have a macro MyMacro.WPM which contains, among other things,
the following:

{ASSIGN}0~String0~
{ASSIGN}5~String1~

Then

>MacArgs MyMacro -0"This is the first assignment" -5Next>NUL

will change those two lines in the macro to this:

{ASSIGN}0~This is the first assignment~
{ASSIGN}5~Next~

without sending any output to the screen.


Applications:

Why do this? There are many situations in which it could be useful.
Here are a few examples:

(1) You want to call up WPerf from the DOS command line and have it
load the file you will edit. But the file is an ASCII text file, and
either you are using WPerf 5.0, or you are using 5.1 but want hard
returns only at the ends of paragraphs. You cannot simply type >WP
TheFile at the DOS command line, because 5.0 will not load an ascii
text file that way and 5.1 will put a hard return at the end of each
line. You can use a startup macro, but how do you get the filename
into the macro? With a batch file and MacArgs. You need a macro
(LOAD.WPM) that looks like this (this one is for 5.0):

{DISPLAY OFF}
{ASSIGN}0~junk~
{Text In/Out}13{VAR 0}{Enter}


Then you need a batch file (WPASC.BAT) like this:

@echo off
MacArgs Load -0%1
wp/m-load

To load the ascii text file Text.Asc with hard returns only at the ends
of paragraphs, you would then invoke the batch file at the command
line:

>WPASC Text.Asc

(2) It is often useful to have a macro that keeps track of a number
and increments that number by one each time you use the macro. You may
want to number your invoices consecutively. Or you may want to name
files so that part of the name indicates the client and the rest is a
number. There are lots of other examples.

Incrementing a variable within a macro is easy enough. The problem is
that when you exit from WPerf, you lose the number stored in the
variable. MacArgs allows you to store the number in the macro itself,
and, if you are using 5.1, the macro can actually modify itself to
store the new value of the variable. That way, you can come back next
week, and the number will still be stored in the macro. Here is a
fragment of a 5.1 macro that modifies itself to store the incremented
value of a number:

File COUNTER
Description increments and modifies itself

{DISPLAY OFF}
{ASSIGN}0~0~
{;}Do something with variable 0 here~
{ASSIGN}0~{VARIABLE}0~+1~
{Shell}CMACARGSCOUNTER.WPM-0{VARIABLE}0~>NUL{Enter} A

The basic mechanism here can be extended quite far. You could, for
example, use a single macro to keep track of the sequence numbering for
ten different basic file names.

(3) In an organization, it may be useful to distribute the same macro
to many different people -- but in a slightly different version for
each person. Perhaps it is a macro that provides a complimentary close
to a letter, and the name has to be different for each letter writer.
MacArgs can help by allowing you to customize a basic macro.

As described so far, MacArgs is not very convenient for making
customized versions, because each time it runs, it modifies the input
macro without changing its name. A different syntax for running
MacArgs, however, makes this kind of customization easy. On the DOS
command line, you provide only a single file name, preceded by @:

>MacArgs @fname

fname is an ascii text file. Each line of the ascii text file is in
this form:

InMacro OutMacro -0Arg [-1Arg ... -9Arg]

Used this way, MacArgs does not change InMacro at all. It creates a
new macro, OutMacro, which is identical to InMacro except for the
modifications indicated on the rest of the line.


Writing Macros For Use With MacArgs:

In writing macros for use with MacArgs, it is a good idea to have all
the assignments you will want to modify at the beginning of the macro:

{DISPLAY OFF}
{ASSIGN}0~junk~
{ASSIGN}1~junk~

and so forth.

MacArgs ignores any subsequent assignments to the same variables.
Collecting all the assignments you want to modify at the beginning of
the macro makes it easier to keep track of which assignment statements
are subject to modification. (It also will make MacArgs run a few
microseconds faster.)

That MacArgs works only with variables 0-9 may seem confining if you
are using WPerf 5.1 (or another WPCorp product that allows named
variables), since MacArgs apparently forces you to use variables 0-9
throughout your macro to take advantage of its capabilities. You can
get around this problem in the initial section of the macro. Say you
would rather use the variable name FileName in your macro. Do it this
way:

{DISPLAY OFF}
{ASSIGN}0~junk~
{ASSIGN}FileName~{VAR 0}~

Then FileName has the information you want to use in the macro (and you
can go on to use variable 0 for any other purpose).


II. MacAscii

MacAscii converts a WPCorp macro to a text representation of the macro
(in either WP5 document or ascii text file format); it also converts
text representations of macros (again, either WP5 documents or ascii
text files) to macro files. Roughly speaking, it is a macro compiler
and decompiler. It works with macros for all recent WPCorp products
(WPerf beginning with 5.0, PlanPerfect beginning with 5.0, DrawPerfect
beginning with 1.0, ED beginning with 3.0, Shell beginning with 3.0,
and, apparently, LetterPerfect beginning with 1.1), and it will
probably work with any new macro-using programs WPCorp develops, as
well as with versions of WP, DR, PL, ED, SH, and LP that do not yet
exist.

By creating a text representation of a macro, MacAscii allows you to
print macros. More importantly, it allows you to edit macros using
your favorite editor rather than WPCorp's awkward macro editors, as
well as to use other kinds of powerful text processing programs in
working with WPCorp macros (one important example appears below). Thus
you can edit macros too big to handle in the built-in macro editors of
WPerf, PlanPerfect, and DrawPerfect. And if you have DrawPerfect or
LetterPerfect, and therefore Shell, you can edit Shell macros even if
you do not have ED.

In order to handle all these different macros, MacAscii requires the
appropriate MRS file -- WP.MRS, DR.MRS, PL.MRS, ED.MRS, or SH.MRS (do
NOT use KEYS.MRS). Generally, if you have any reason to want to work
with a WPCorp macro, you have the appropriate MRS file, because each of
the programs comes with its own MRS file. However, if you are a
DrawPerfect user, you may want to work with Shell macros even though
you may not have SH.MRS. MacAscii allows an alternative to MRS files --
MRQ files. The shareware distribution of MacroAid comes with SH.MRQ,
and registered users will receive other MRQ files. (MacAscii may run
slightly faster using MRQ files rather than MRS files, but most users
will not notice any difference in speed.)

Problems can arise if you use the wrong MRS (or MRQ) file. If you are
converting a macro to its text representation, MacAscii checks to see
that the product and version of the macro and the MRS file are the
same, and if they are not, it will not do the conversion. (Actually, a
5.1 MRS file would work reasonably well in converting a 5.0 macro. You
can use MacChang, described below, to change a 5.0 macro to a 5.1 macro
if you need to convert a 5.0 macro to its text representation using a
5.1 MRS file.) There is no checking when you convert from text to
macro.

WPCorp on occasion changes the MRS file with interim releases of a
version of a program. This creates several problems. First, even if
you have correctly matched the versions of the MRS file and the macro,
the macro could contain commands not in the MRS file, because the macro
is based on a later interim release than the MRS file. These will be
flagged as unknown. Second, both the MRS file and the macro could be
based on a later interim release than your program. If that happens,
and you convert a text representation of a macro to a macro, the macro
could contain commands unknown to your release of the program. The
best, and perhaps only, solution to these problems is to make sure that
both your MRS file and your program are up to date.

MacAscii does not check the syntax of your macros, and it will
faithfully translate errors exactly as they appear. However, when
translating from ascii text files or WP5 documents, it sends a warning
to the screen when it finds a macro or key command inside a {;}
comment. Commands inside comments are legal, but often they result
from a missing tilde at the end of a comment.

The syntax for using MacAscii can get complicated, because there are a
lot of options. Typically, however, you need only this:

>MacAscii -iIfile -oOutfile -mMRSfile

Here is a more complete statement of the syntax, with explanations of
the various command line items:

>MacAscii -iInfile -oOutfile (or -wOutfile) -mMrsFile [Options]

-iInfile Infile is the filename of the file to be converted. It
can be a macro, an ascii text file, or a WPerf 5.x
document file.

-oOutfile Outfile is the filename of the output file. If Infile
is an ascii text file or a WPerf 5.x document, Outfile
is a macro. If Infile is a macro, Outfile is its
ascii text representation. If you want to convert a
macro to its text representation as a WPerf 5.0 file,
use the -w switch.

-wOutfile Outfile is the filename of the output file when you
are converting a macro to its text representation as a
WPerf 5.0 document.

-mMRSFile MRSfile is the name of the MRS file to govern the
conversion. If no extension is provided, the
extension MRS is assumed.

-aMRQfile Use -a instead of -m if you are using an MRQ file
instead of an MRS file.


Options:

-cCfgfil Because the MacAscii command line can grow long, you
have the option of including any of the command line
parameters (except -cCfgFil) in a configuration file.
(The configuration file is an ascii text file. Each
line contains a single parameter which would otherwise
go on the command line, complete with its -switch.)
If you do not indicate otherwise on the command line,
MacAscii will look for the configuration file
MacAscii.Cfg in the directory where Macascii.Exe is
found (unless you are using a DOS version earlier than
3.0, in which case MacAscii looks in the current
default directory). To use a different configuration
file, specify it with -c on the command line, where
Cfgfil is the full name of the configuration file you
want to use.

If, for example, you almost always use MacAscii
with WPerf macros, you might well want to specify
the MRS file in the configuration file, so you do
not have to put it on the command line each time
you use the program.

Parameters specified on the command line override
parameters specified in the configuration file.
Thus if you have -mwp in the configuration file
and want to use MacAscii with a DR macro, you can
simply put -mdr on the command line, and that
will override the choice of -mwp in the
configuration file.





-schar A space that is part of a macro ("macrospace") is
represented in WPCorp's macro editors by a dot (which
happens to have the ascii value 250 decimal), rather
than by a blank space. By default, MacAscii assumes
that this is how you want macrospaces to be
represented in text output and how they are
represented in text input. But the WPCorp dot can be
a bad choice in some situations. First, it is harder
to type than a blank space. Second, some E-mail
systems do not permit high ascii characters, and some
editors have problems with them. The -s switch allows
you to use a different character to represent a
macrospace -- just provide the character after the -s
(e.g., -s# to use # for the macrospace). If you want
to use a blank, you can just leave out the character
after the -s (and if you are converting from WP5 to
macro, you can leave out the -s entirely). If you
want to use a character that you cannot put on the DOS
command line, represent it this way: \nnn, where nnn
is the number of the ascii character (in decimal)
(e.g., -s\124 for the vertical bar).

-n Represent low ascii characters as {\nn} in ascii text
file output. Macros may contain low ascii characters
(characters with values below 32) for cursor
positioning and other purposes. MacAscii has no
trouble with these characters, but you may have
trouble with ascii text file output that contains
these characters, because they include such things as
carriage return, line feed, form feed, end of file,
and others which may cause your printer to do strange
things. The -n option represents these low ascii
characters as {\nn}, where nn is the decimal digits
representing the ascii characters (for example, form
feed becomes {\12}). When you convert an ascii text
file containing these symbols back to a macro,
MacAscii will process them correctly whether or not
you use the -n switch.

-d Dump. This option writes to standard output a
complete list of the macro and key commands supported
by the MRS or MRQ file specified on the command line
with it. (Note that the list may include commands not
actually available to you; WPCorp apparently includes
in the MRS file commands not yet implemented in its
programs.) If you use this option, the only other
parameter required on the command line is the -m or -a
switch identifying the MRS or MRQ file.


Notes on Macro Commands and Key Commands

In converting from text to macro, MacAscii assumes that anything
appearing between left and right braces ({}) is a macro command or a
key command. It then tests that assumption by comparing the text
against the macro and key commands obtained from the MRS (or MRQ) file.
If it does not find an EXACT match (ignoring case), MacAscii concludes
the material between braces is not a command, outputs it to the macro
as simple text, and sends a warning message to standard output. (To
make sure you have an exact match, run MacAscii with the -d option,
redirect the output to your printer, and consult the printed list as
you edit the text forms of macros.)

Because MacAscii is not case sensitive in matching commands, you cannot
use, say, {Assign} as simple text in a prompt message. Use, for
example, instead. (This substitution is not necessary in
comments.)

MacAscii does, however, recognize several {} symbols which are not
WPCorp macro or key commands. First, there are special "comment"
symbols. Anything that appears in an ascii text file or WP5 file
between these symbols is ignored in the conversion to macro format.
These symbols can therefore be used to "comment out" portions of the
macro code, or simply to include text in the text file that is not
included in the macro. (Note: this kind of "comment" differs from the
WPCorp macro comment -- e.g., {;}This is a comment~ -- because the
WPCorp comment is included in the converted macro.) These symbols come
in pairs. Thus {(*} begins a comment and {*)} ends a comment (these
symbols will be familiar to Pascal programmers). Similarly, {/*}
begins a comment and {*/} ends a comment (these symbols will be
familiar to C programmers). Anything between the beginning and ending
symbols in a pair is ignored. These symbols function as pairs, and the
two types cannot be mixed. Thus if you begin a comment with {(*}, {*/}
will not end it -- the comment will not end until a {*)} is found.
This allows you to, for example, comment out a section of code with
{/*} and {*/} and then comment out a larger section, which includes the
first section, by using {(*} and {*)} at the beginning and end of the
larger section.

Second, in ascii text files only, symbols in the format {\nn} are
recognized as indicating low ascii characters corresponding to the
digits nn. See the discussion of the -n option above for more detail.


Format of ASCII text files

(1)As output

MacAscii starts ascii text file output with the word "File,"
followed by the name of the input macro file. The next line begins
with the word "Description," followed by the macro description (if
any). The body of the macro begins with the following line
(MacAscii also inserts some blank lines for readability).

Tabs used for formatting the macro are converted to blank spaces
(four spaces per tab). Macrospaces are represented by the standard
WPCorp dot (unless you select a different character).

Exotic characters in the WPerf character set that have no ascii
equivalent (such as Cyrillic characters and many mathematical
symbols) are represented by an upsidedown question mark; if the
ascii text file is converted back to a macro, the upsidedown
question marks will not be converted back to the characters they
were originally.

The ascii output file may contain ascii characters with numbers less
than 32. These characters are used for cursor positioning in
macros, and they are sometimes used in macros to set "markers" in a
document. Although these "low ascii" characters do not cause any
difficulty for MacAscii, they can cause other difficulties. They
may turn out to be printer control characters (for example, ascii 7
causes a Panasonic KXP-1091 printer to beep, 18 turns on compressed
mode, and 19 disables the printer from receiving data). They may
disappear if the ascii text is transmitted via E-mail. To avoid
these problems, you may use the -n option, described above.

(2) As Input

MacAscii does not necessarily treat the beginning of the ascii text
file as the beginning of the macro. Leaving aside "boxed macros"
(discussed below), MacAscii assumes the macro does not begin until
it finds the first line which (a) is not entirely blank; (b) does
not contain the string "File" (without the quotation marks); (c)
does not contain the string "Description" (without the quotation
marks); and (d) does not contain the string "{DESCRIPTION}" (case
matters for the File and Description strings). If a line does
contain the string "Description" or the string "{DESCRIPTION}",
MacAscii assumes what follows on that line is the macro description,
and it inserts that description into the output macro. If you need
to, for example, include the word "Description" on the first line of
your macro, put {;}~ (followed by a hard return) at the beginning of
your file; that line will be treated as the beginning of the macro.

The macro editors in WPCorp products display the macro enclosed in a
box. MacAscii will handle properly macros whose body (but not the
File and Description lines) is enclosed in such a box. Thus text
macros in more or less the format displayed by the WPerf macro
editor can be handled.

Ascii text file lines end with a Carriage Return and Line Feed
(CRLF). Sometimes screen capture or downloading in certain ways
from electronic services leads to files with lines that end with
only one of these characters. MacAscii will not handle such files
properly (however, MacAscii permits CRLF to be omitted at the end of
the last line, and it permits the last line to end with Ctrl-Z).

Line length is limited to 255 characters.

Either spaces or tabs may be used to represent blank space used for
formatting the macro. However, if you choose to use a blank space
for the macrospace, confusion can arise between the macrospace and
formatting blank space. If you indicate with -s that the ascii text
file uses a blank (ascii 32) for macrospace, MacAscii assumes that
all blank spaces are macrospaces, except (a) blanks at the beginning
of a line, (b) blanks at the end of a line, and (c) blanks preceding
a comment. These assumptions will usually be correct, but may
occasionally be wrong.


Format of WP5 document files


(1) As output

MacAscii includes File and Description lines at the beginning of WP5
output, as described above for ascii text output. Macro and Key
commands are bolded. Apart from that, the output file has no
peculiarities.

(2) As input

WordPerfect codes not relevant to macros (that is, codes used only
for formatting the WP5.x document) are ignored entirely. The rest
of this discussion assumes none exist, because their presence would
have no effect.

The required format is more restrictive than in the case of ascii
text files. Macascii assumes the text of the macro does not begin
until the first line which (a) is not entirely blank, (b) does not
begin with the string "File", (c) does not begin with the string
"Description", and (d) does not begin with the string
"{DESCRIPTION}". Compare those assumptions with the assumptions for
ascii text files, where "File", "Description", and "{DESCRIPTION}"
may appear anywhere in the line. "Boxed macros" are not handled
properly -- avoid them in WP5 files.

Blank space used for formatting must be represented by tabs. Both
the conventional dot space and other WPerf codes implying blank
space (space, hard space, soft return, etc.) are treated as
macrospaces.


Using Other Macro-To-Text Programs

Several other programs convert macros to text. They may begin the text
with lines that are not part of the macro and that MacAscii is not
designed to ignore (for example, lines beginning "Desc:" or
"{VERSION}"). At least one such program also includes a final line
which is not part of the macro. Files like these need editing before
MacAscii can convert them to macros.


MRQ Files

MRQ files are files we have made from MRS files. They contain the
information MacAscii requires from an MRS file. Unfortunately, you
cannot update your MRQ file easily whenever WPCorp releases a new MRS
file.

Most people will have no need for MRQ files, although owners of
DrawPerfect who have not purchased Office may find SH.MRQ useful.
MacAscii may run slightly faster with MRQ files instead of MRS files,
but any difference would be vanishingly small and probably undetectable
without complex measuring equipment.


Writing Macros In Ascii Text File Format

Editing macros in ascii text file format allows you to use powerful
text-processing techniques to speed the writing of macros and to make
macros more readable. Apart from search and replace capabilities of
various editors beyond those available in WPCorp products, these
techniques include use of capabilities made available through standard
"macro processors," where "macro" is used in a slightly different sense
here. M4, a standard Unix utility program for which several DOS
versions exist is a good illustration. Michael M. Rubenstein's free
DOS version of M4 is recommended. Because DOS versions of M4 can be
hard to locate, with Mr. Rubenstein's permission a copy of his version
of M4 will be included with paid-for copies of MacroAid, although not
with the shareware distribution of MacroAid. (You can find a good deal
more information about M4 in Software Tools in Pascal, by Brian W.
Kernighan and P.J. Plauger.) Borland's Turbo C preprocessor program,
CPP, has some similar capabilities, but M4 is more powerful and
preferable in several other ways.

Two of M4's many capabilities are important here. First, there is the
"include" capability. Suppose we have two ascii text files, A.ASC and
B.ASC. A.ASC looks like this:


A Line 1
include(b.asc)dnl
A line 2

(Note: the "dnl" is there to prevent generation of extra blank lines)

and B.ASC looks like this

B Line 1
B Line 2

Then, when we process A.ASC through M4, the result looks like this:

A Line 1
B Line 1
B Line 2
A Line 2

You can use the "include" directive to incorporate frequently used
macro code in your ascii text files without actually having to copy it
each time. Suppose, for example, you frequently need to turn Reveal
Codes off in a macro. You might prepare an ascii text file, RCOFF.ASC,
that looks like this:

{LABEL}rco~
{IF}{STATE}&4~
{IF}{STATE}&512~{Reveal Codes}{END IF}
{END IF}
{RETURN}


That is a little "subroutine" which can easily be included in a macro
you are writing. We will use RCOFF.ASC below.

Another capability is "define," which is a little more complicated.
With this instruction

define(dog,cat)dnl

M4 will substitute the string "cat" for "dog" each time "cat" appears.
Substitutions may actually be much more complicated, because defines
may use "arguments," $1 to $9. Here is a silly example:

define(dog, cat$1$2)dnl

Then M4 would replace

dog(big, blue)

by

catbigblue.

Now for some less silly examples.

"Defines" can be used to develop a library of standard routines for use
in macros. For example, macros frequently ask the user for a yes or no
response, and then go to different parts of the code depending on what
the answer is. Each instance uses basically the same programming
commands, but the prompt for the user differs each time, and the
various labels used also differ. A define, where the arguments
represent the varying parts of the standard programming commands, may
simplify the writing. The following is how we might do this:

define(YesNoQuery, {LABEL}$4
{CHAR}ynq~$1~
{CASE}{VARIABLE}ynq~~
Y~$2~
y~$2~
N~$3~
n~$3~
~
{GO}$4~
)dnl

In this example, the message to the user and the necessary labels are

arguments supplied when YesNoQuery is used. A line like the following
will produce the right code structure in the macro:

YesNoQuery(Continue? (Y/N):,DoYes, DoNo, DoYNQ)

and if there is another such structure in the same macro, another
single line invokes it, with a different message and different labels:

YesNoQuery(Save the file? (Y/N): SaveIt, DoNotSave, AskSave)

YesNoQuery is used in a macro below.

For another example, it is sometimes convenient to determine whether
the character at the cursor is an upper case letter. The following
define makes it easy to incorporate the necessary programming
instructions:

define(IsUpper,{KTON}{SYSTEM}right~~>64&{KTON}{SYSTEM}right~~<92)dnl

That gives us a convenient way of placing that expression, not easy to
type, in the middle of the macro.

The last example is a convenient way of using the Reveal Codes
subroutine shown earlier:

define(TurnRevealCodesOff, {CALL}rco~)dnl

All these defines can be placed in a file, LIBRARY.ASC, for regular
use. It looks like this:

define(YesNoQuery, {LABEL}$4
{CHAR}ynq~$1~
{CASE}{VARIABLE}ynq~~
Y~$2~
y~$2~
N~$3~
n~$3~
~
{GO}$4~
)dnl
define(IsUpper,{KTON}{SYSTEM}right~~>64&{KTON}{SYSTEM}right~~<92)dnl
define(TurnRevealCodesOff, {CALL}rco~)dnl

Of course, LIBRARY.ASC could have many more defines, and you could have
several such files.

Using these particular defines in a sensible short macro is not easy,
so here is a nonsense macro:

include(library.asc)
{DISPLAY OFF}
TurnRevealCodesOff
YesNoQuery(Is this a silly macro?,IsSilly,IsNotSilly,Q)
{LABEL}IsSilly~
a{Left}{IF}IsUpper~
a is upper case{ELSE}
a is lowercase{END IF}{QUIT}
{LABEL}IsNotSilly~
wrong answer!{QUIT}
include(RCOFF.ASC)dnl

If this macro is in a file named SILLY.ASC, this DOS command causes M4
to process it:

M4 Silly.Asc >Expand.Asc

The resulting Expand.Asc looks like this:


{DISPLAY OFF}
{CALL}rco~
{LABEL}Q
{CHAR}ynq~Is this a silly ?~
{CASE}{VARIABLE}ynq~~
Y~IsSilly~
y~IsSilly~
N~IsNotSilly~
n~IsNotSilly~
~
{GO}Q~

{LABEL}IsSilly~
a{Left}
{IF}{KTON}{SYSTEM}right~~>64&{KTON}{SYSTEM}right~~<92~
a is upper case{ELSE}
a is lowercase{END IF}{QUIT}
{LABEL}IsNotSilly~
wrong answer!{QUIT}
{LABEL}rco~
{IF}{STATE}&4~
{IF}{STATE}&512~{Reveal Codes}{END IF}
{END IF}
{RETURN}

Of course, once LIBRARY.ASC has been developed and tested, there is no
need to look at files like EXPAND.ASC, which is just an intermediate
file used as input to MacAscii. All you need to look at is SILLY.ASC,
which is shorter, easier to write, and easier to read than EXPAND.ASC.

Much of the power of using a macro processor like M4 comes from
developing a standard library of defines and includes. If you write a
lot of macros, it is well worth the effort to develop that library.


III. MacCalls

Some macros will not work unless other macros are available -- they use
{CHAIN}, {NEST}, and {SHELL MACRO} commands. Particularly if you have
acquired a new collection of macros from somewhere, it can be very
helpful to trace through the sequence of calls to other macros.
MacCalls traces the sequence for you. Here is how it is used:

>MacCalls MacFileSpec [ShellMacroDir]


MacFileSpec: file specification (with drive, path if needed) of
macros to search. May include wildcards.
Extension defaults to WPM.

ShellMacroDir: shell macro directory. Use only if shell macros
are not in the MacFileSpec directory.

Output goes to standard output, and may be piped or redirected.

Only the first 65,518 bytes of macro body are searched; that is
about the largest possible WPCorp macro.

MacCalls finds the first file matching MacFileSpec and searches it for
{CALL}, {NEST}, and {SHELL MACRO}. It reports the name of the file it
is searching, and then, indented under it, lists the first macro
{CALL}ed (if, as is usually the case, the name of the macro called does
not have a path or extension, MacCalls supplies the path and extension
of MacFileSpec -- or, for {SHELL MACRO} commands, MacCalls supplies
ShellMacroDir as the directory if that has been specified on the
command line -- and otherwise it uses what it finds in the macro).
Then, if it can find this macro, it searches it for {CALL}, {NEST}, and
{SHELL MACRO}, and reports in the same way. If it cannot find the
file, it simply reports that and moves on to the next file. And so
forth.

The result is tree-like output, reporting the entire chain of macro
calls. (Even if the files can be found, the entire chain is not always
reported. To avoid voluminous output and the possibility of infinite
loops, no macro file is searched more than once.) Here is an example,
generated by

>MacCalls * >out

in a subdirectory with a few macros constructed for test purposes. The
output is redirected to the file "out." Out then contains the
following:

D:\WORK\FISH.WPM --

Nests:
D:\SMACS\STUFF.WPM not found or opened

D:\WORK\C2.WPM --

Chains:
D:\WORK\THE.WPM not found or opened

Nests:
D:\WORK\Q1.WPM not found or opened
D:\WORK\Q2.WPM not found or opened
D:\WORK\TEST.WPM --

Chains:
D:\WORK\C2.WPM already processed
D:\WORK\FISH.WPM already processed

Nests:
D:\WORK\F1.WPM not found or opened
D:\WORK\N2.WPM not found or opened

Shell Macro calls:
D:\WORK\S1.SHM not found or opened


D:\WORK\TEST.WPM already processed

You can make MacCalls pause at the end of each full screen by piping
the output to the DOS program MORE:

>MacCalls * |MORE

or you can pipe it to Vern Buerg's LIST program, which will allow you
to page back and forth through the output:

>MacCalls * |LIST /s


IV. MacCrush

MacCrush shrinks macros by removing comments as well as tabs and
returns used only for formatting the macro. It also changes all label
and variable names (except for variables 0 - 9 and shell variables) to
two letter symbols. The result is an unreadable mess, but there is no
reason to read it -- keep the original source file, and if you ever
need to do any editing, edit the original and recrush. (In fact, if
you wish to distribute macros without revealing how they work, try
crushing them. MacCrush may make the logic of the macro so difficult
to follow that there is little risk of revealing anything important.)
The main point of doing all this is to make the macro load and execute
faster, although the speed improvement, if any, is not likely to be
large and in small macros will probably not be noticeable. (Prior to
the 6/30/90 release of WordPerfect 5.1, comments, tabs, and returns in
a macro slowed down execution, but WordPerfect now eliminates those
characters when it loads the macro. Therefore, there may be no
improvement in execution speed in recent versions of WordPerfect, but
there may still be a difference in loading time.)

Note that you may not want to change all the labels or variable names,
mainly because variables can be referenced by different macros -- that
is, macros can communicate with one another by storing information in
variables, since variables are, as WPCorp says, "global." In fact,
that is the reason shell macro names in non-shell variables are not
changed -- we assume that a shell variable referred to in a non-shell
macro is also referred to by at least one other macro, a shell macro.

There is a more complicated reason for not changing certain label
names. Rather than reference a label directly, you may store the name
in a variable and use the variable where the label name goes. MacCrush
cannot tell, when you store a string in a variable, that it will later
be used as a label, and it therefore cannot change the name
appropriately. For this reason, MacCrush allows you to supply a list of
labels and variables whose names the program does not change.

Here is how you use the program:

>MacCrush Infile Outfile [Keepfile]

Infile a WPCorp macro. Extension defaults to WPM.

Outfile Output macro file. Extension defaults to Infile's
extension.

Keepfile Optional file with list of names not to crush.

Keepfile is an ascii text file. If there are variable
names you do not want to have changed, the first line of
Keepfile must begin with the word "Variables" (without the
quotation marks) and include nothing else. Each line
after that consists of the name of a variable (case does
not matter). When you are finished with the variable
names, if there are any label names, the next line should
read "Labels". After that come the labels not to change,
one per line (again case does not matter). If you want to
keep some label names but no variable names, the first
line in the file reads "Labels".

MacCrush sends a report to standard output on the variable and label
names it has changed, indicating what it has changed them to. This
report may occasionally be useful for debugging purposes, but usually
it serves no purpose.


V. MacChang

WPCorp macros have a prefix containing, among other things, codes
indicating the WPCorp product and the version number. MacChang allows
you to change that information.

MacChang is useful in two circumstances. First, as described above,
you may occasionally want to use MacAscii with a macro and an MRS file
that do not match -- for example, the MRS file is from WordPerfect 5.1,
but the macro is a WordPerfect 5.0 macro. MacChang can change the
identification codes stored in a macro to indicate whatever program and
version you want, allowing you to fool MacAscii. But be careful --
these changes can fool other programs as well.

Second, you may want to translate a WPCorp macro written for one WPCorp
program (say, WPerf) to another (say, PlanPerf). A useful way to begin
is simply to change the product and version information stored in the
macro, look at the text of the resulting macro, and see what else has
to be changed (sometimes nothing else has to be changed).

Here is the syntax for using MacChang:

>MacChang Infile Target

Infile Filespec of WPCorp macro, including extension

Target WPCorp product type to change macro to.

Target must be one of the following: WP50, WP51, DR10,
DR11, PL50, PL51, ED30, SH30, LP11

MacChang alters the product type of the input file and renames the
input file by changing the extension to the extension appropriate to
Target.

For example,

>MacChang sign.wpm PL51

changes a WPerf macro (sign.wpm) to a PlanPerfect 5.1 macro (sign.plm).

(Note: you will want to run MacChang on a copy of your original macro.)


VI. MacFind

MacFind searches for strings in macro files (and keyboard files). The
strings may include programming and key commands. The output reports
the pathnames of the files in which the string was found and whether
the string was found in a macro description or in the body of a macro.

Programs that search for text strings in files are very common. Most
of them will not work for finding text strings in macros, because
strings are stored peculiarly in the body of a macro. Also, these
programs will not find programming and key commands, because the string
representation of these commands (e.g., {ASSIGN}) has no resemblance at
all to what is actually stored in the macro. MacFind does not suffer
from these limitations.

Here is the program syntax:

>MacFind FindText MacFile [/mmrsfile] [/aaltfile] [/C]

FindText String to find. If it has blanks, enclose in quotes.
If it has ", enclose in '. If it has ', enclose in
". No more than 127 characters.

MacFile File spec (with drive, path, wildcards if needed) of
macros to search. Extension defaults to WPM.

/mMRSfile needed if FindText has {} symbols. Default extension
is mrs.

/aAltfile MRQ file, used instead of MRS file.

/C Case insensitive search. If the FindText includes
programming or key commands, the search will be case
sensitive even if you use the /C switch.

Only the first 60,000 bytes of a macro are searched. For macro
files, both the description and the first 60,000 bytes of the
macro body are searched. For keyboard files, the first 60,000
bytes of the file are searched.

Output goes to standard output and may be piped or redirected.

You must specify an MRS (or MRQ) file if the FindText contains a {}
sequence, even if that sequence is not actually a programming command
or a key command. Without the MRS (or MRQ) file, MacFind cannot
determine whether a string within braces is a programming command or a
key command.

Note that if you use a wildcard such as *.*, MacFind may search through
macros for several different WPCorp programs (if you keep them all in
the same subdirectory). However, MacFind translates your FindText
based on an MRS file for a single WPCorp program. This can produce
spurious results. For example, what is actually stored in a WPerf
macro for {VAR 0} is identical to what is stored in a Shell macro for
{ALT 0}. Thus if you are searching for a FindText that includes {VAR
0}, MacFind may report that it found the FindText in a Shell macro,
although what it found in Shell macro terms has {ALT 0} instead of {VAR
0}.


VII. MacRef

MacRef produces a standard programmer's cross-reference listing of a
macro. This consists of a line-numbered listing of the macro, followed
by a list of the macro commands and macro key commands (that is, the {}
codes), the variables, labels, shell variables (for shell macros, all
variables are shell variables, and there is no separate listing of
shell variables), and system variables, each accompanied by a list of
the line numbers on which it appears. Words used simply as text appear
in the line-numbered listing, but not in the subsequent list.

There are some gaps in the resulting list. For example, you may have
in your macro something like

{ASSIGN}fish~test~

and elsewhere

{GO}{VARIABLE}fish~~

as well as

{LABEL}test~

The cross reference listing for the label "test" will not have a line
number for the assign statement, because MacRef has no way of knowing
when it reads the assign that "test" is actually a label.

If MacRef finds programming or key commands inside comments, it lists
the line numbers after listing the macro itself. Although the macro
language permits commands to be placed inside comment, commands inside
comments often result from missing tildes.

Here is the syntax for using the program:


>MACREF /ifspec /cfspec /mfspec [options]


/i Input file, a WPCorp macro. Default extension is WPM.

/c Configuration file. See below.

/m MRS file (e.g., wp.mrs). The default extension is MRS.

/a Alternative to MRS file. See the discussion under
MacAscii.

/s Spacechar - the character used in ascii to represent macro
space. Defaults to WPCorp dot. To use, e.g. ,!, /s!. Or
use /s\nnn, where nnn is decimal ascii code.

/n Low ascii characters in output represented by {\nn}.

Output goes to standard output and may be piped or redirected as
needed.


The -s and -n switches are identical to those used with MacAscii and
are more completely described above under that heading. They are
useful if you want to print the output or transmit it via E-mail, a
well as in some other situations. MacRef, however, does not require
these switches.

You can use a configuration file to avoid lengthy command lines. A
configuration file is an ascii text file, with one parameter on each
line of the file. (The parameters are exactly what you would otherwise
put on the DOS command line.) Unless you specify a different
configuration file on the command line, MacRef will look for a file
named MacRef.Cfg in the directory were MacRef.Exe is located (or, if
you are using DOS 2.x, in the current default directory), and it will
use that file if it finds it. A configuration file is a convenient
place to put -s and -n switches. If you always use MacRef with one
type of macro (say, WordPerfect 5.1 macros), the configuration file is
also a convenient place to put the /m information.

For an example, we saved as f.wpm the alt-f macro from the 5.1
macros.wpk keyboard. Here is the output (possibly distorted, depending
on what font you use to print it) from running the following command:

>MacRef -if -m\51\wp

Filef.WPM
Description Find the Bookmark (see Alt-m).


1: {IF}!{STATE}&4~
2: {RETURN}
3: {END IF}
4: {DISPLAY OFF}
5: {LABEL}top~
6: {ON NOT FOUND}{GO}up~~
7: {Home}{Search}<<>>{Esc}
8: {CALL}del~
9: {RETURN}
10:
11: {LABEL}up~
12: {ON NOT FOUND}{GO}fail~~
13: {Home}{Search Left}<<>>{Esc}
14: {CALL}del~
15: {RETURN}
16:
17: {LABEL}del~
18:
{Backspace}{Backspace}{Backspace}{Backspace}{Backspace}{Backspace}
{Backspace}{Backspace}{Backspace}{ Backspace}{Del}
19: {RETURN}
20:
21: {LABEL}fail~
22: {IF}{STATE}&8~
23: {CALL}main~ {;}Insubstructure~
24: {GO}top~
25: {END IF}
26: {PROMPT}ERROR:Can'tfindBookmark~
27: {WAIT}20~
28: {QUIT}
29:
30: {LABEL}main~
31: {IF}{STATE}&4~
32: {IF}{STATE}&8~
33: {ELSE}
34: {RETURN} {;}Mainscreen~
35: {END IF}
36: {END IF}
37: {Exit}
38: {GO}main~


Macro Commands and Keys

{;} 23 34
{BACKSPACE} 18
{CALL} 8 14 23
{DEL} 18
{DISPLAY OFF} 4
{ELSE} 33
{END IF} 3 25 35 36
{ESC} 7 13
{EXIT} 37
{GO} 6 12 24 38
{HOME} 7 13
{IF} 1 22 31 32
{LABEL} 5 11 17 21 30
{ON NOT FOUND} 6 12
{PROMPT} 26
{QUIT} 28
{RETURN} 2 9 15 19 34
{SEARCH} 7
{SEARCH LEFT} 13
{STATE} 1 22 31 32
{WAIT} 27

Labels

DEL 8 14 17
FAIL 12 21
MAIN 23 30 38
TOP 5 24
UP 6 1



VIII. MacShell

MacShell helps you run the other programs in MacroAid. With MacShell,
you need not construct DOS command lines for the other programs,
because MacShell does it for you. It presents you with a menu from
which you can select the program you want to run (either by moving the
cursor to the desired choice and pressing , or by pressing the
highlighted letter for that menu choice). For each program, you are
presented with an entry screen, where you fill in the necessary
choices. If you then choose to execute the program, MacShell swaps
itself to EMS (if you have EMS available) or to disk (creating the file
MacShell.Swp in the current default directory, which must not be on a
floppy disk) so that ample memory will be available, executes the
program, and returns you to the MacShell menu. Three other menu
choices are available (plus Quit); they are discussed below.

MacShell requires no command line parameters. However, if you do not
like the colors it uses, you can put /m on the command line; MacShell
will then use color choices designed for a monochrome display.

To install MacShell, copy MacShell.Exe to your hard disk. Copy
MacArgs.Exe, MacAscii.Exe, MacCalls.Exe, MacCrush.Exe, MacChang.Exe,
MacFind.Exe, MacRef.Exe, and MacroAid.Doc to (a) any directory on your
path; (b) the directory that will be the current default directory when
you use MacShell; or (c), if you are using DOS 3.0 or later, whichever
directory contains MacShell.Exe.

Note that loading MacShell requires about 167K of available memory, and
the various options require varying amounts of additional memory. If
an option seems not to work, that may be because not enough memory is
available. However, if you have enough memory available to run MacShell
up to the point where it executes another program, you should have
enough memory available for MacShell to execute the other programs,
because of the swapping feature.

Using The Entry Screens

Each entry screen has a number of "fields" for you to fill in. You can
move from field to field with the key or the cursor arrow keys.
Usually, the key will accept what is entered in a field and
move you to the next field. In some cases, you enter a string, in
others you select among a limited set of choices, and in still others
you enter a single character. Often, you will be presented with a
default choice.

When you are satisfied with the contents of the fields on a screen, you
can simply accept all the choices by hitting , which will return
you to the main menu, or you can execute the program you have selected
by hitting . If you used , your choices will be preserved (for
the current MacShell) session, or you can make them your permanent
defaults by cloning MacShell, as described below.

Hitting at any entry screen allows you to read the file
MacroAid.Doc. Hitting works exactly the same as choosing Read
Docs from the main menu.

Entering Strings:

If a string-entry field presents you with a default string, the default
will disappear if the first key you hit in the field is a character.
If you want to edit the default string, begin with a cursor-movement
key, such as a cursor arrow key.

In some cases, you are permitted to enter strings longer than the
displayed field (for example, filenames that include long paths will
not fit the displayed field). Longer strings will cause the field to
scroll.

If while you are editing a string you change your mind and want to
restore the default choice, hit or .

Editing strings involves straightforward use of the usual editing keys.
Thus , , , , , , , ,
and work in the expected fashion. To clear the entire
field, use . To delete the word to the right of the cursor, use
.

In any field calling for a filename, you can select the filename from a
directory list. To do so, hit . Enter a path specification
including one or more wildcards (?,*) and hit . A directory
list will appear. Move the cursor to the filename you want and hit
. (Subdirectories are included in the directory list. If you
select a subdirectory, you will be presented with the file list for
that subdirectory.)

Selecting From A Choice Set:

Several fields allow only a limited number of choices. For example,
certain fields allow you only to choose between MRS and MRQ. You can
change the displayed choice by hitting , <+>, or <->.

Entering Characters:

Some fields require a yes/no choice. Enter either Y or N. There are
also fields for selecting Spacechar, where you enter almost any single
character. Certain characters (such as ascii 10) cannot be entered
because they are interpreted as editing commands, and you should not
use >, <, or | as the Spacechar. For characters that do not correspond
to single keys, use Alt and the number pad to enter the ascii number
for the character.

Cloning MacShell

One of the main menu choices allows you to "clone" MacShell, which
means to change the MacShell.Exe file. When you clone MacShell, the
current contents of each of MacShell's entry screen fields becomes
MacShell's permanent default choice for that field (until you next
clone MacShell). This allows you to configure MacShell for easier
operation.

You may find it helpful, for example, to set defaults for input and
output filename fields that indicate the appropriate directories (end
directory names with \), so that you only have to add filenames when
you use the program. And if you always use the same MRS file with the
MacroAid programs, you might wish to make that MRS file the default MRS
file.

Reading The Documentation (Help)

Although MacShell does not provide context-sensitive help, it does
permit you to consult the file MacroAid.Doc at any entry screen (hit
) or by choosing Read Docs at the main entry screen. (Normally,
MacroAid.Doc is the ascii text file version of this documentation that
comes with MacroAid, but you can use that name for any file you want.)
The Read Docs, or Help, feature of MacShell actually reads MacroAid.Doc
into a fully-featured file browser. The most important command is
, which you use to exit from the file browser. Other commands are
described below.

Moving around the file:

To move around the displayed file, you can use standard keys in
conventional ways (although WordStar-style alternatives also work).
Thus , , , , , and work in expected
ways. and move a full window in the expected direction.
and move to the beginning and end of the file.
To move to a particular line, use followed by (or );
you will be prompted for a line number.

You can set up to four "bookmarks" in the file (they disappear when you
exit from the file browser). followed by a digit from 0 to 3
sets the appropriately-numbered bookmark. You can then jump to a
bookmark you have set by hitting followed by the appropriate
digit.

Searching:

To find particular strings in the file (such as the string "MacAscii"
when you want to help in using MacAscii), hit . You will be
prompted for a search string. Enter the string and hit . You
will then be prompted for options. If you choose no options, the
search by default will be case sensitive and will go from the current
location in the file towards the end of the file. You can change this
behavior by entering one or more letters as options. For a case
insensitive search, enter a "u." To search backwards through the file,
enter "b." To search forwards towards the end of the file and then
continue from the beginning of the file towards the starting location,
enter "g."

Once you have found the first instance of a search string, you can
search again for the same string (with the same options) by hitting
.

Miscellaneous Commands:

If you wish to read a file other than MacroAid.Doc, hit . You will
be prompted for a new filename in the usual fashion.

If for some reason you want to read a hex dump of the file you are
browsing, hit . This command is a toggle --hit it again to go
back to ascii.

By default, the file browser expands tabs. If for some reason you
would rather see the actual tab characters in an ascii file (there are
none in MacroAid.Doc), hit followed by . This command is a
toggle.

Going To Dos

The Go To Dos option on the main menu loads a secondary command
processor and allows you to do whatever you want to at the DOS command
line (although you should not load a TSR or, if swapping is to disk,
run programs such as CHKDSK or disk defragmenters). Type EXIT to
return to MacShell. Because MacAscii swaps itself to EMS (or disk),
you should have enough memory available for most operations (and
MacShell tells you how much memory is available). Depending on your
configuration, you may well have enough memory available to run, say,
WordPerfect. This would allow you to test whether the output from
MacAscii is a correctly working macro, and to make adjustments in the
input text file if it is not.

-----------------------------------------------------------------------

FOR MORE INFORMATION

If you need more information or have any questions or suggestions, you
can write to me at the address given at the beginning of this
documentation. Electronic messages may be faster, however. You can
leave EMail on CompuServe [70441,2414] (you can also leave messages in
the WPGSA forum). In addition, I monitor several networked WordPerfect
BBS conferences more or less regularly, and you can leave questions or
suggestions for me in any of them. You are likely to get a faster
response if you leave the message on the BBS I call than if you count
on the network to get your message to me and mine to you. Things
change rapidly in the BBS world. At the moment, the networks where you
can find me are Smartnet, Relay (RIME), Metrolink, and what used to
be, and may still be, called Interlink. BBSs I call regularly and
which carry one or more of these networks are listed below:

D.C. Information Exchange, 202-433-6639
Arlington Software Exchange, 703-532-7143
DataBit, 703-719-9648


-----------------------------------------------------------------------



LICENSE INFORMATION


MacroAid is not in the public domain. Both the collection and the
individual programs are fully protected by copyright. (M4 is not part
of MacroAid.)

You are granted without charge a license which permits (a) use of the
programs for a period of 30 days for evaluation and testing; (b) making
copies for distribution to others without charge, provided the programs
and the accompanying documentation are distributed together and without
modification; (c) posting the programs, together with the accompanying
documentation, on electronic bulletin board systems.

Use after the 30 day evaluation and testing period requires payment of
a license fee. For a single copy (plus necessary archival copies), to
be used on only one computer at a time, the fee is $25.00. For your
convenience, an invoice form is included below (in ascii-formatted
documentation file only). For large quantities, discounts and site
licenses are available. Write for information. Any license for which
payment is properly made is valid for this version of MacroAid and any
subsequent versions.

What do you get for your license fee? You get permission to use the
programs and the warm feeling that you are not violating the copyright
laws. When we receive your license fee, we send additional MRQ files,
a copy of the latest version of MacroAid, and documentation in
WordPerfect format. With the permission of the copyright holder, we
will send you a copy of M4. We will send you notice of any significant
updates, and we will send you the updates for a small shipping and
handling fee. And if you let us know about any problems you have with
the programs, we will try to solve them.

Users groups and other not-for-profit organizations may distribute
unmodified copies of MacroAid (not including any of the files provided
only to licensed users), together with its accompanying documentation,
for a fee to cover duplication and related costs, but not to exceed
$6.00. Your payment of such a fee does not eliminate the requirements
concerning payment of a license fee.

The United States Department of Justice is granted a license, without
payment of fee, for all official use of MacroAid.


WARRANTY INFORMATION


These programs are distributed without warranties of any kind, express
or implied, including, but not limited to, the implied warranties of
merchantability and fitness for a particular purpose.

No representation or other affirmation of fact, including but not
limited to statements regarding suitability for use, or performance of
the programs, shall be or be deemed a warranty by the licensor for any
purpose, nor give rise to any liability or obligation of the licensor
whatever.


INVOICE


David Seidman
Software by Seidman
2737 Devonshire Place, N. W.
Washington, D. C. 20008

DATE:

SOLD TO:

__________________________
__________________________
__________________________



Description Price



License for MACROAID $ 25.00

additional licenses @ $25.00 _____.__






Total: $_____.__
D.C. Residents add 6% D.C. Sales Tax: ___.__

Total Charge: $_____.__


Make checks payable to Software by Seidman. Please mark checks
"MACROAID 1."


 December 11, 2017  Add comments

Leave a Reply