Dec 142017
A program to ease invocation of compilers and other software tools from a function key in QEdit version 2.+.
File QCP208.ZIP from The Programmer’s Corner in
Category Word Processors
A program to ease invocation of compilers and other software tools from a function key in QEdit version 2.+.
File Name File Size Zip Size Zip Type
COMPILE.BAT 718 375 deflated
QCONFIG.QCP 3779 1542 deflated
QCP-READ.ME 1866 884 deflated
QCP.DAT 6464 2376 deflated
QCP.DOC 86122 24913 deflated
QCP.EXE 24288 11390 deflated
QCPSMALL.EXE 18832 8804 deflated

Download File QCP208.ZIP Here

Contents of the QCP.DOC file

QCP -- QEdit Compiler Program

A program to ease invocation of compilers
and other software tools from a function key in
QEdit version 2

Author: Tim Farley
Revision: 2.08
Date: November 17th, 1989

QCP is FREE to licensed users of QEdit
QCP is Copyright (C) 1989, by Tim Farley

QEdit and QMac are Copyright (C) 1985-1989 by SemWare.

QCP is a program to run compilers & other utilities from within
QEdit 2.08+. You hit a function key in QEdit, QCP decides which
program to run based on the name of the file you are editing,
runs it, and then "reads" the error messages from the compiler to
tell QEdit how to jump to the errors in your source code.

QCP can also be used to provide a regular expression search
capability to QEdit in the same way--simply by running an
external GREP program, and "reading" its output.

QCP can also be used from the command line or within a batch
file, separate from QEdit, to provide a single front-end to
several different compilers or utilities.

QCP can interface in the same manner to any external utility that
generates redirectable output containing "line numbers" that
refer to your original source file.

QCP 2.08 requires the use of QEdit 2.08 or higher.

In addition, to take full advantage of QCP, you will want to have
a copy of QMAC that is compatible with your copy of QEdit. If
you are a registered user of QEdit, then QMAC should be found on
the Program Diskette that you received from SemWare.

QCP 2.08 Documentation Page 2

Description ................................................ 1
Table Of Contents .......................................... 2
File List .................................................. 3
License .................................................... 4
Quick Installation ......................................... 4
Quick Start ................................................ 6
Running QCP ................................................ 6
Command Line Switches and QCP .............................. 8
/R -- Read Config Info from Disk ...................... 9
/C -- Configure QCP.EXE's Defaults .................... 9
/S -- Show QCP.EXE's Current Defaults ................. 10
/G -- Guessing of File Extension ...................... 10
/Q -- QEdit Macro Creation ............................ 10
/B -- Batch Mode Operation ............................ 10
/W -- Write New Error Output File ..................... 11
/P -- Pause After Error ............................... 11
/I -- Insertion Character ............................. 12
/O -- Output File Name ................................ 12
/M -- Macro File Name ................................. 12
/1 to /9 -- Custom File Extensions .................... 13
file -- File to Compile ............................... 13
options -- Compiler Options ........................... 13
QEdit Macro Key Customization .............................. 14
Compiler Compatibility ..................................... 15
Custom Compiler Configurations ........................ 15
Compatible Compilers .................................. 16
I/O Redirection Problems, Tips ........................ 18
Microsoft Fortran 3.x ............................ 19
Microsoft MASM 4.0 ............................... 20
DBFAST 1.03 ...................................... 20
Norton Guides Database Compiler 1.04 ............. 21
Microsoft Quick Pascal 1.00 ...................... 21
Incompatible Compilers ................................ 22
Configuration Via QCP.DAT .................................. 22
Substitution Strings .................................. 24
$F -- Full Filename .............................. 24
$D -- Drive Letter ............................... 24
$P -- Path (Directory) of File ................... 24
$N -- Name of File ............................... 24
$E -- Extension of File .......................... 24
$1 to $9 -- Compiler Options ..................... 25
$$ -- Single Dollar Sign ......................... 25
$T -- Temp File Name ............................. 25
$O -- Output File Name ........................... 25
$M -- Macro File Name ............................ 25
$K -- Macro Key Number ........................... 25
$S -- Source Line Number ......................... 26
$C -- Source Column Number ....................... 26

QCP 2.08 Documentation Page 3

$R -- Result Line Number ......................... 26
$I -- Inserted Character ......................... 26
$U -- Unique String .............................. 26
$L -- Lead-in String ............................. 27
QCP Configuration Commands ............................ 27
..T -- Temp File Name ............................ 27
..O -- Output File Name .......................... 28
..M -- Macro File Name ........................... 28
..C -- QMac Command Line ......................... 28
..Q -- QEdit Macro Template ...................... 29
..1 to ..9 -- Special File "Extensions" .......... 30
..B -- Batch Mode Startup Macro Template ......... 31
..G -- Guess Extension ........................... 32
..W -- Rewrite Error File ........................ 32
..I -- Insertion Character ....................... 32
..N -- Next Error Macro Template ................. 33
..P -- Previous Error Macro Template ............. 33
Summary of Command Line Switches ........................... 34
Summary of Substitution Strings ............................ 34
Summary of Configuration Commands .......................... 35
Error Messages ............................................. 35
Informative & Warning Messages ............................. 37
Acknowledgements & Contacts ................................ 38
Revision History ........................................... 39

The following files are included in this package:

QCP-READ.ME - quick notes on this update.
QCP.DOC - this documentation file
QCP.EXE - the QCP program
QCPSMALL.EXE - another version of QCP with /R and /C
disabled. For those worried
about disk and RAM usage.
QCP.DAT - the configuration data file
QCONFIG.QCP - partial QEdit keyboard file containing
sample macros for use with QCP
COMPILE.BAT - example of using QCP outside QEdit

NOTE: Changes in this manual from the last version, 2.0, are |
notated in the right margin with a "|" character. |

QCP 2.08 Documentation Page 4

QCP is FREE to licensed users of QEdit.

You may copy QCP for purposes of evaluating it, and distribute
QCP to others for purposes of evaluating it for their use. If
you continue to use QCP after evaluating it, you must register
your copy of QEdit. See your QEdit documentation for
registration information.

If you distribute QCP to others, you must distribute it AS-IS,
with no files altered, added, or removed from the package. You
may not distribute QCP in connection with any other product or
service, or for any consideration or 'disk fee'.

Operators of electronic bulletin board systems (Sysops) are
encouraged to post QCP downloading by their users, as long as the
above conditions are met. Those who have permission from SemWare
to distribute or sell QEdit itself are exempt from these

The author assumes no liability for the use of QCP, and does not
guarantee its fitness for any purpose whatsoever.

If you are upgrading from QCP 2.0 or QCP 1.0, see the file |
QCP-READ.ME for info on changing your configuration. Otherwise, |
follow the instructions below: |

Set aside your original copies of all the QCP files in a safe
place. Always work on a copy, not the original!


QCP.EXE should exist somewhere along your current PATH statement
so that it can be executed easily. QCP.DAT can exist in one of
three places: (1) the current directory, (2) the same directory
that QCP.EXE is in, or (3) somewhere along your current PATH
statement. It is searched for by QCP in that order.

If you are going to use the macro creation feature of QCP, and
this is highly recommended, then make sure QMAC.EXE is accessible

QCP 2.08 Documentation Page 5

along your PATH as well.

We recommend keeping QCP.EXE (and QCP.DAT, if you use the /R
option) as well as QMAC.EXE on a RAMdisk, and listing that
RAMdisk drive letter first in your PATH= environment variable.
This allows QCP to operate very rapidly, even on relatively
"slow" systems.


There are comments in the supplied QCP.DAT to help you
remember the syntax of commands, as well as several sample
command lines for popular compilers. See also the section on
configuration below for more details on other compilers.

It is assumed that the command line you specify for your compiler
will redirect the error messages from the compiler to a file, by
default called ERRORS.LST. This file can then be loaded into
QEdit for viewing, but more importantly it is read by QCP in
order to construct QEdit macros that will move your cursor to
each error in your file. So, typically each command line you use
in QCP.DAT should end with ">$O", which causes the output to be
redirected to the error file. Use the /O command line switch, or
the ..O command in QCP.DAT, to assign the filename that will be
substituted for $O.

If this is the only configuration you are going to use, you will
probably want to "install" these options into your copy of
QCP.EXE permanently by typing "QCP /C" at a DOS prompt. If you
want to use QCPSMALL to save memory, use QCP.EXE to install it by
typing QCP /Cqcpsmall.exe at a DOS prompt. You can rename
QCPSMALL.EXE if you wish.


Note that the default macro is set up to always create and read
the ERRORS.LST and ERRORS.MAC file in the CURRENT directory. If
you have a RAM disk or other fast disk drive, you will probably
want to edit the macro definition to put these files there.

QCP 2.08 Documentation Page 6

Within the macro, the /O and /M command line switches for QCP are
used to make sure the filenames match. You may want to configure
these filenames into QCP permanently, and remove the references
to /O and /M in the macro definition.

Edit a file for which you created a definition in QCP.DAT. I.e.,
if you defined something for .C, then edit TEMP.C. Put in a
deliberate syntax error, something that you know the compiler
will generate an error message for. Save the file to disk.

Now, hit the function key you assigned in QCONFIG.DAT. QEdit
will shell out, run QCP, which will run your compiler. Errors
will be redirected to ERRORS.LST, and macros created. When you
return to QEdit, your file will be in the top window, and your
error messages will be in the bottom.

If your chosen compiler generates compatible error messages (see
Compiler Compatibility, below), you will be able to hit Alt-1
through Alt-0 to move to each of the errors your compiler issued,
both in the source and output windows. Or, if you are using the |
/W+ mode (rewrite error file), you should be able to just hit |
Shift-F10 to step to each successive error message. |

And that's all there is to it!

There are some other features of QCP you may want to take
advantage of, read on to find out about those, as well as how to
configure QCP's behavior to suit your specific needs.

The flow of operation of QCP generally works like this:

1. User hits "compile" macro key. QEdit shells
out and runs QCP.

2. QCP picks a compiler command line based on the name of
the file passed along by QEdit. The compiler is

3. The compiler does it's job, writing any error messages
to the error file specified by QCP. (ERRORS.LST)

QCP 2.08 Documentation Page 7

4. QCP regains control, reading the error file (if any)
which was written by the compiler (ERRORS.LST). If it
can locate error messages, it writes text macros to the
temp file specified ($QCP$.TMP). It then invokes QMAC.

5. QMAC converts the text macros to binary macros that can
be loaded by QEdit. ($QCP$.TMP becomes ERRORS.MAC).

6. QCP regains control, and exits to QEdit.

7. QEdit loads the error output from the compiler
(ERRORS.LST) into a window so the user can see the
result, and loads the macro file (ERRORS.MAC) if it
exists, produced by QMAC so that error messages can be
found with single keystrokes.

It actually runs quite quickly, as long as you make sure the
necessary files are easily accessible. If you are concerned
about the speed of operation, the generation of QEdit macros can
be disabled (See /Q).

If you are having trouble getting QCP to work as described, more
than likely your file names are getting out of sync. Please make
sure that the file names (1) in your QEdit macro key, (2) in QCP
itself, and (3) in any batch files you use to run compilers; all
agree as to where and under what name each file is placed.

Also, when compiling this way, a pretty good bit of RAM is
required, all told. This is because QEdit, your source file,
QCP, and your compiler (not to mention a couple copies of the
stub portion of COMMAND.COM) are all in memory at the same time.
If you have very large source files, or very little free RAM, you
may have trouble running QCP from a QEdit function key. If so,
then take a look at COMPILE.BAT. It demonstrates the use of QCP
from the DOS command line.

QCP 2.08 Documentation Page 8

If you just type QCP at a DOS prompt, it will respond with this
screen of info. (Display of defaults removed here to fit the
screen on a normal page):

QCP: QEdit Compiler Program x.yy dd-mmm-yyyy
Copyright (C) 1989, Tim Farley. All Rights Reserved.

QCP /R[file] /C[file] /S /G /Q /B /W /P /Ichar /Ofile /Mfile /# FILE opts...

/R Reads configuration info from specified file.
/C Configures defaults into specified copy of QCP.
/S Shows QCP's current configurable defaults
/G+ /G- Guess or don't guess a missing file extension
/Q+ /Q- Create or don't create a QEdit binary macro file
/B+ /B- Batch mode: create autoexec macro for QEdit |
/W+ /W- Write or don't write copy of error file |
/P+ /P- Pause or don't pause for keystroke after an error |
/Ichar Char to be Inserted before row/col in output
/Ofile File to which Output will be redirected
/Mfile QEdit Macro file name to be generated
/# i.e. /1 thru /9, uses the specified special
extension definition instead of the file's extension
FILE is source file to compile.
opts are options to be passed to compiler commmand line

/R, /C, and /S are mutually exclusive
If none of them are present, internal defaults are used

All QCP switches MUST precede the file name. Both "/" and "-"
are recognized as switch characters. However, each switch must be
preceded by its own switch character. Each switch must be
separated from the others by at least one space.

The switches that contain file names (/M and /O, optionally on /C
and /R) MUST NOT contain a space between the switch and the file

The boolean switches, like /G and /Q, can have "+" or "-" behind |
them to set the specified switch on or off. If nothing is behind |
the switch, it is set on. If any character other than "+" or "-" |
is behind a boolean switch, for instance "=", then the current |
value is TOGGLED. |

QCP 2.08 Documentation Page 9

QCPSMALL includes all the capabilities of QCP, EXCEPT the /R and
/C options. As such, you MUST use QCP.EXE to install defaults
from your QCP.DAT into QCPSMALL.EXE (see details on the /C option
below). The advantage of QCPSMALL is that it takes about 6K less
disk space and RAM. It is designed for those who are sticklers
about disk and RAM usage. Its help display will be a slightly
abbreviated version of the above.

When /R is present, QCP will always read its configuration data
from an external file, overwriting the internal defaults.
QCPSMALL does not support this option.

If you specify a file specification (which can include a path)
immediately after /R, that file will be read instead of QCP.DAT.
An extension of '.DAT' is added if none was present.

Network users especially may wish to make use of the /R option if
the normal location for QCP.EXE is on your server, and you do not
have write permission on that directory.

If using the default file name, or if the file name specified
does not contain a specific path specification, QCP searches for
it in the following way: first in the current directory, then
(if DOS 3.0 or higher is present) in the directory from which
the program loaded, then down each of the directories in your
PATH= statement.

The /C option causes QCP to read its configuration data from
QCP.DAT, and install this info as new defaults into QCP.EXE.
This allows you to permanently customize your copy of QCP.

A /R is implicit in the use of /C. However, you can use /R on
the command line BEFORE /C to choose the configuration file.

If you specify a file specification (possibly including a path)
immediately after /C, that file will be configured instead of
QCP.EXE. An extension of '.EXE' is added if none was present.
This must be a copy of the same version of QCP that you are
running. This is how you can install your copy of QCPSMALL.EXE.

QCP searches for its EXE file in the same way it searches for the
data file. If a path specification is present, then the file
will only be searched for there.

QCP 2.08 Documentation Page 10

Please be aware that since /C writes data into the EXE file, it
is possible for your copy of QCP to be damaged by this operation.
Make sure you always have a clean, uninstalled copy of QCP safely
tucked away.

In operation on networks, you may not wish to use the /C option,
if QCP.EXE will be located on a server drive to which you do not
have write access. See /R above.

The /S option is a companion to /C. It allows you to see the
current defaults installed into QCP.EXE.

Note that /R, /C and /S are mutually exclusive. If you combine
them on a command line, the last one specified will take control.

Normally, if no '.' appears in the file name to compile, QCP will
attempt to guess the correct extension just as QEdit does when
loading files into memory. The extensions are guessed in the
same order that they are defined in QCP.DAT.

This is mainly for those using QCP from the DOS command line, to
save typing. The /G option can be used to enable or disable this
feature. Mainly you would use this if you have files with no
extension, and you have an entry for this in QCP.DAT.

The default value for filename guessing is controlled by the
"..G" command in QCP.DAT. The release version has it turned ON.

The /Q switch allows you to turn macro creation on or off without
reconfiguring QCP. /Q+ activates macro creation, /Q- deactivates

The default value for macro creation is controlled by the "..Q"
command in QCP.DAT. The release version has it turned ON.

----------------------------------- |
The /B switch controls use of QCP in a "batch mode" such as in |
COMPILE.BAT. When batch mode is activated, an extra macro key is |
written first in the QEdit macro file. This macro key is used as |
an "auto execute" macro via the QEdit /E command line switch. |
COMPILE.BAT is supplied as a sample of how this works. |

QCP 2.08 Documentation Page 11

The batch mode macro is constructed by QCP when it locates the |
first error line in the compiler output, so the expansion strings |
$S, $R, $C, $K, $U, and $L all have valid meanings at the time |
this macro is constructed. |

The default value for batch mode, as well as the type of macro |
created, is controlled by the "..B" command in QCP.DAT. The |
release version has it turned ON, with a macro set up to work |

------------------------------------------ |
The /W switch controls whether QCP will write a new copy of the |
compiler output file (normally ERRORS.LST). The purpose of this |
is to insert a certain ASCII character (see /I or ..I) |
immediately to the left of the row and column numbers that QCP |
found in the compiler output. |

This allows the "next error" and "previous error" macro keys to |
find row numbers and column numbers without having any special |
knowledge of how the error messages are formatted. |

Since this involves writing a new copy of ERRORS.LST, it can slow |
down the process somewhat, hence the flag to turn it off. If you |
are happy with using the Alt-numeric keys to jump to the first |
ten errors, you can turn this option off and save a little time. |

However, if you use a compiler that generates large numbers (more |
than 10 or 12) of error messages; or if you wish to use the GREP |
macro in QCONFIG.QCP to its full advantage; leave this option |
turned ON. Note: the Next Error Macro and the Previous Error |
Macro (see ..N and ..P respectively) are not written to the macro |
file by QCP unless this option is turned on. |

The default for writing a new error file is controlled by the |
"..W" command in QCP.DAT. The release version has it turned ON. |

------------------------ |
When invoking QCP from a QEdit macro key, it can happen that QCP |
issues an error message, and QEdit clears it off the screen and |
returns to the editing session so quickly that you do not see it. |

The /P option allows you to cause QCP to pause and ask you to |
"Press any key to continue" when it encounters a fatal error |
condition. |

QCP 2.08 Documentation Page 12

-------------------------- |
The /I option lets you control what character will be inserted |
into the rewritten output file, just to the left of the row and |
column number. This only occurs if /W is set to ON (see |
description of /W above). The insertion character allows the |
next error and previous error macros to operate. |

It is very important that you pick an insertion character that |
does not appear anywhere else in your error output. |

The character to set should appear IMMEDIATELY to the right of |
/I. If the first character after /I is numeric, then the |
information is treated as a decimal ASCII code. If it is not |
numeric, then the character is taken directly. |

The default for insertion character is controlled by |
the "..I" command in QCP.DAT. The release version has it set to |
CHR( 255 ), which displays as a blank space. |

The /O option lets you specify the Output file name that will be
used by QCP. This filename is substituted for "$O" (see below)
if present on your target compiler command lines. This is also
the file that QCP will read back in after the compiler runs, to
attempt to locate any error messages.

The Output file name can also be configured with the "..O"
command in QCP.DAT, however if /O is present it will override the
value specified in QCP.DAT.

The /O command line option is intended so that the filenames used
can be completely controlled by your QEdit function key macro.

The /M option is similar to /O, except it controls the name of
the binary macro file created by QCP and QMAC for use in finding
errors in your source code. This file name is replaced wherever
"$M" appears in your target command line(s).

The macro file name can also be configured using the "..M"
command in QCP.DAT, however if /M is present it will override the
value specified in QCP.DAT.

On both of the above files, QCP will look for an environment
variable called TMP, to determine a suitable place to put "temp"
files. This is the same as most Microsoft utilities which will
use the TMP environment variable to locate your RAM disk for

QCP 2.08 Documentation Page 13

their use in writing scratch files. If you invoke QCP with the
/S switch, you will see the result of this when the three file
names are listed.

You may not want this to happen, especially if you want to insure
that the file names referred to in your QEdit macro key are the
same as those used by QCP. If so, just include a drive and/or
path specification in the file name. If you want them always to
be in the "current" directory, then use ".\" prior to each file

The number options let you override the command line selection
that QCP would normally make based on the extension of the file
you are editing. This is intended so that you can define other
QEdit function keys, that invoke text search or other utilities
on any arbitrary file, regardless of its name.

A sample of this, using GREP, is supplied. This is also the mode
in which QCP can replace the function of the QMAKE utility. See
examples in in QCP.DAT and QCONFIG.QCP.

The first non-switch parameter on the QCP command line is assumed
to be the file you wish to compile. This is normally generated
using "CurrentFilename" in a QEdit macro key, but could be typed
by you. This can be a full file specification including path.

Any parameters past the filename on the QCP command line are
assumed to be options for the target compiler's command line.
They are simply passed along, assuming you have put the
appropriate $1, $2 etc. strings on your compiler command line
templates in QCP.DAT.

All of these options must be delimited on both sides by spaces.
Note that this is a restriction of QCP that might not be shared
by your compiler.

QCP 2.08 Documentation Page 14

QCP is normally intended to be invoked from a QEdit macro key. A
sample key is provided in QCONFIG.QCP, and is repeated here. We
use Control-F9 in this example, you could use any key.

^f9 MacroBegin SaveFile OneWindow UnmarkBlock MarkLine |
EditFile 'errors.lst' Return Quit |
GotoBlockBeg UnmarkBlock |
Dos 'QCP/O.\errors.lst /M.\errors.mac ' |
CurrentFilename Return " " |
HorizontalWindow EditFile Return PrevWindow |
MacroRead 'errors.mac' Return |

The macro definition above is word-wrapped for readability,
normally in QCONFIG.DAT it would appear all on one line.

You may want to customize this macro, so a little explanation of
how it works may be in order. The first line simply clears any
split windows off the screen, and marks a one-line block in
your source file, so we can get back there. The second line
makes sure that any previous compiler output file is purged from
QEdit's ring. The third line returns us to our source file and
clears the mark we created.

The fourth and fifth lines do the main work, invoking QCP with the
current filename as its main parameter. Notice that /O and /M are
used to insure that the filenames used in the macro stay in sync
with those used by QCP.

The sixth line splits the screen and brings up the error output
file in the lower window, and the seventh line reads in the
macros created by QCP, so you can jump from error to error.

In QCP 1.0, we redirected the output from QCP in the macro key
itself, i.e. "QCP current_filename >ERRORS.LST". In QCP 2.x you
definitely DO NOT want to do that, or it will prevent the
creation of macro keys by QCP.

Create your compiler command lines in QCP.DAT to do the
redirection there, or if you are invoking your compiler from a
batch file, do the redirection inside the batch file. One
advantage of this is that you will see the output from QCP (and
QMAC, if applicable) on the screen, even though your compiler is
redirected to disk.

QCP 2.08 Documentation Page 15

The macro creation feature of QCP hinges on QCP's ability to read
the error messages created by your compiler. By default, QCP
assumes that your compiler issues error messages in this form:


where XX is the number of the source line on which the error
occurred, and YY is the column number on that line.

The default case allows for error messages similar to:


Most all of CURRENT VERSIONS of the compilers put out by
Microsoft Corporation, and Borland International, and every C
compiler we know of, can be made to issue error messages in this
form, and thus will work fine by default.

However, QCP allows you to configure the "unique string" (which
uniquely identifies error message lines), and the "lead-in
string" (which precedes the line number) for each compiler
command line. This allows you to adapt its behavior to compilers
which do not include the file name in the error message line, or
which do not put the line number first after the file name.

Non-standard compilers can still be handled by the appropriate
configuration line in QCP.DAT. The syntax for this is as follows:

.ext "command line" "unique string" [ "lead-in string" ]

Either single or double quotes can be used, but they must match
on either end of a given string. If you need to include a quote
mark inside one of the strings, use the other type of quote mark
to delimit it. Any number of commas and/or spaces (if present)
between the strings will be ignored.

Command line is the normal compiler command line that would have
been on the line by itself.

QCP 2.08 Documentation Page 16

The unique string is some string that is found in the compiler's
output ONLY in error message lines. This typically might be
something like "***ERROR:", you will have to consult your
compiler manual for likely candidates.

The lead-in string, if present, specifies a string that will
always be found in an error line to the left of the source line
number. It is not mandatory, if not present it will default to
the same thing as the unique string. The first numeric
characters to the right of the lead-in string must be the line
number. Keep in mind that the file name itself, the error
message, or the line of source code itself (if echoed as part of
the error message) might contain numeric characters that could be
misinterpreted as a line number.

Maximum length of the unique and lead-in strings is 16 characters
each, they will be truncated if longer. You CAN include
substitution strings like $N and $F inside the unique string and
lead-in string. The length limitation DOES NOT apply to the
strings AFTER they are expanded. The strings ARE NOT case
sensitive when matching occurs.


Your compiler generates error messages like:

***ERROR: Syntax error on line 34

You would set your unique string to "***ERROR" and your lead-in
string to "line".

Choose your strings carefully, as some compilers generate very |
inconsistent looking error messages. A common mistake is to try |
to key off the word "error" in the message, which will then cause |
QCP to ignore "warning" messages. |

Below are some cases of specific compilers, and the command line
switches or other actions necessary to make them conform to what
QCP is expecting. In many cases, you will want to add or
subtract switches to or from the sample command lines. Consult
your compiler manual.

QCP 2.08 Documentation Page 17

Most compilers allow you to specify either just a simple file
name, or a complete path specification on the command line. Keep
this in mind when selecting whether to use $F, or $N, or $N.$E,
etc. for your filename on the command line. The way you specify
the source file name on the command line, can affect how the
compiler echoes it in error messages. You may want to experiment
with this, if you are defining specific unique or lead-in strings
that involve the filename.

If your compiler is not covered in this section, see the section
"error message strings" below for information on how to build
your own configuration from scratch.

------------------------- -------------------------------
Clipper by Nantucket, 8/87 .prg "clipper $N >$O","line " |
FoxBase Compiler v2.1 .prg "foxpcomp -e $F >$O","Error in line " |
FST Modula-2 v2.0a .mod "m2comp $F >$O","File: $F",", Line"
Microsoft Assembler 5.x .asm masm $F; >$O
Microsoft BASIC .bas bc /Z $F; >$O
Microsoft C 5.x .c cl /c /W3 $F >$O
Microsoft FORTRAN 4.0 .for fl /c $F >$O
Microsoft Menu Maker v1.2 .def "makemenu $N >$O","Error (" |
Microsoft Pascal 4.0 .pas pas1 /H $F; >$O
Alternative: .pas pl /c /Zz $F >$O
Microsoft Quick C 1.01 .c qcl $F >$O |
QMac (QEdit macros) 2.x .qm "qmac $N.mac $F /B /A- >$O" "QMAC " |
Telix 3.x Script Compiler .slt cs $F >$O
TopSpeed Modula-2 1.14 .mod m2 /c $F >$O |
Turbo Assembler 1.00 .asm "tasm $F >$O" "** $F" |
Turbo C 2.0 .c tcc -c -w $F >$O
Turbo Pascal 4.0 & 5.0 .pas tpc /q $F >$O
Watcom C 6.5 .c wcl /c $F >$O |

The /H switch for Microsoft Pascal is undocumented.
The Microsoft BASIC and FORTRAN, Clipper and FoxBase command
lines have not been tested by us personally.
Microsoft Menu Maker comes with the Microsoft Mouse. |
We recommend you use the /W+ option when working with |
Clipper, because of the way that Clipper writes its |
output. |

QCP 2.08 Documentation Page 18

Many compilers will compile files other than the one specified, |
due to an automatic "make" function built into the compiler. |
This can sometimes result in either (1) QCP ignoring error |
messages from the compiler, because they don't pertain to the |
current file or (2) QCP jumping to erroneous error lines in the |
current file, because it was unable to distinguish that they did |
not pertain to the current file. Some of the compilers that are |
prone to this are Clipper, Turbo Pascal, both of the Modula-2 |
compilers, and others. We plan to address this in a future |
version of QCP. |

Below are some instances where just a simple command line will
not do the trick. Even if you do not use one of them, you may
want to read through them to see what kinds of configuration
tricks are possible.

------------------------------ |
Many of the unusual compiler configurations listed below result |
from problems redirecting the output to the compiler. If a |
program writes its screen output to the "Standard Output Device" |
under DOS, then the text can be redirected normally, using the |
">" character followed by a filename on the dos command line. |
However, if the output is written to the "Standard Error Device", |
redirection is impossible using DOS alone. |

We know of two utilities that can assist with compilers that use |
Standard Error to display error messages. One is ERROUT.EXE, |
which is a utility Microsoft ships with many of its recent |
compiler products. |

The other is CONCOPY.EXE, which is a Freeware product by |
Christopher J. Dunford and The Cove Software Group. |

Microsoft's ERROUT.EXE allows you to redirect just the Standard |
Error device to a file. The syntax is as follows: |

ERROUT /f filename command_line |

where filename is the file to which to redirect Standard Error, |
and command_line is a DOS command line to execute while the |
redirection is in effect. The /f must be lower case, and there |
must be a space between it and the filename. |

Cove Software's CONCOPY will also redirect Standard Error, as |
well as Standard Output, and it has the additional effect that |
the output will appear on the screen while it is also redirected. |
This can be very useful if you have compilers that take a great |
deal of time to run, because you will be able to see their run- |

QCP 2.08 Documentation Page 19

time messages on the screen, even while they are redirected to |
disk. Here is the syntax: |

CONCOPY filename command_line |

where filename is again the file to which redirection should |
occur, and command_line is the normal compiler command line. You |
will need CONCOPY version 1.10 (10/11/88) or later to use this |
syntax. You can get CONCOPY version 1.10 on most IBM-oriented |
BBS's, including the SemWare QEdit Support Board. |

CONCOPY will allow console output to appear on the screen even |
while it is redirected. For this reason, you may wish to use |
CONCOPY even with compilers that DO NOT need redirection |
assistance, in order to see the error messages on the screen. |

If you do use CONCOPY with all your compiler configurations, we |
recommend that you DO NOT use normal I/O redirection in addition. |
In other words, use EITHER "CONCOPY $O" at the beginning OR ">$O" |
at the end of your compiler command lines, but NOT BOTH. |

See the sections below for examples of the use of ERROUT and |

Microsoft Fortran 3.x can work with QCP. Its error messages look
like this:

***** Error XXX,line YY -- ERROR MESSAGE

To get this, we define the unique string and lead-in string as

.FOR "for1 $N.$E; >$O","*****",",line "

You may wish to put this command line in a batch file instead of
invoking it directly, so that you can call up PAS2 and PAS3 of
the compiler as needed. If so, be sure to pass $O to the batch
file as a command line parameter.

QCP 2.08 Documentation Page 20

Masm produces compatible error messages by default.

Unfortunately, MASM 4.0 writes the error messages to Standard
Error, so we have to use a utility to redirect it (see above).
Put one of these two lines in your QCP.DAT:



The part to the left of MASM causes Standard Error to be redirected to
the output file.

Later versions of MASM write to Standard Output.

This dBASE III+ compatible compiler does not generate error
messages compatible with the default case. They look like this:


where XX is the line number. We will define a unique string in
order to make this work with QCP.

Because of the way redirection occurs with DBCOMP, you need to
use a batch file to run the compiler. Here is DBC.BAT:

COPY %1.ERR %2

The -PF switch redirects output to a file. This file always has
the same root name as the file being compiled, with an extension
of "ERR". The -W switch causes "warning" messages to also be
issued, which you may or may not desire. Use this line in

.PRG "DBC $N $O","Line #:"

which sets both the unique string and the lead-in string to the
string "Line #:"

QCP 2.08 Documentation Page 21

It is important to use $N so that the ".ERR" can be appended in
the batch file. Also, make sure you have the DBFAST RAM-resident
"engine" loaded into memory before you enter QEdit, as it is NOT
RECOMMENDED to attempt to load it from inside QEdit, since it is
a TSR program.

------------------------------------ |
The tools supplied with the Norton Guides to create your own |
online help databases can be used with QCP. However, they |
require both redirection help and a special unique/lead-in |
string. |

Both of Norton's programs write the error messages to Standard |
Error. Put one of these two sets of lines in your QCP.DAT: |

.NGC "errout /f $O ngc $F" "Line " |
.NGM "errout /f $O ngml $F" "Line " |

.NGC "concopy $O ngc $F" "Line " |
.NGM "concopy $O ngml $F" "Line " |

Norton does not recommend particular extensions for the Database |
source files or the Menu Link Control files. For the sake of |
this example, we have adopted ".NGC" for the former and ".NGM" |
for the latter, feel free to change these to whatever default |
extensions you use. |

--------------------------- |
Quick Pascal's command-line compiler also uses Standard Error to |
output error messages. Put one of the following two lines in |
your QCP.DAT: |

.PAS ERROUT /f $O qpl $F |

.PAS "CONCOPY $O qpl $F" "error P" "$N.$E" |

Quick Pascal issues "status messages" telling what line it is |
currently compiling, to the console, just as Turbo Pascal does. |
Unfortunately, unlike Turbo Pascal, Quick Pascal does not have a |
/Q switch to turn this off. |

As a result, if you use CONCOPY to redirect the output, you will |
get a number of bare carriage returns in the output. For this |
reason, we recommend you use the /W+ mode of QCP when compiling |
with Quick Pascal. When the error file is rewritten by QCP, the |
bare carriage returns will be converted to proper line breaks. |

QCP 2.08 Documentation Page 22

This is also the reason for the unusual Unique and Lead-in |
strings on the CONCOPY command line above. |

The following compilers cannot be made to work with QCP's macro
generation feature as far as we can tell. If applicable or
known, a reason is given after each. If you can figure out a way
to make one of these work, we'll be glad to add that information
to a future version of this DOC file.

A86 macro assembler, V3.20 (and earlier) by Eric Isaacson |
Error messages do not include line numbers. |
Microsoft Pascal, v3.32 and earlier |
Error messages are too inconsistently formatted. |
Ryan-McFarland FORTRAN version 2.4
Error messages do not include line numbers.
Turbo Pascal 3.0 and earlier
This compiler is an integrated environment only.

QCP needs information on the file extensions and compilers you
use in order to do its job. You supply this information by
editing the file QCP.DAT to suit your individual circumstances.

In addition, various options in the way QCP behaves can be
controlled via lines in QCP.DAT. This includes those mentioned
above in the section on command line switches, but also some
others that you will normally change only rarely.

An example QCP.DAT, which contains the same values with which
QCP.EXE is shipped, is supplied. You can begin by editing this
file to suit your requirements.

The file is fairly free-form, you can incorporate comments more
or less at will. The only lines which QCP will try to process
are those that begin with a '.' (period) in column 1 and are
longer than 5 characters.

QCP 2.08 Documentation Page 23

The main content of QCP.DAT is a list of file name extensions,
followed by the command line that will be executed for each one,
as follows:

Ext. Default Command Line
---- --------------------
.asm masm $F; >$O
.c tcc -c $F >$O

and so on.

Note that the format of QCP.DAT was designed to be much the same
as that of QCOMP.DAT, from Mike Smedley's program. If you are
currently using QCOMP, you can adapt your current QCOMP.DAT
simply by renaming it, and editing all instances of '%s' into

It is legal to have an entry for a "nothing" file extension.
Just put a period by itself on a line, followed by at least one
space, and the command line to use.

Only the first 10 extensions found will be processed. Any
additional ones, or duplicate ones, will be ignored. A warning
message is issued to help you clean up your QCP.DAT.

The raw command lines may not be longer than 64 characters,
though they can become a full 127 characters long when the $
strings are expanded.

QCP executes a child copy of COMMAND.COM, which is passed the
command line to execute. This means that you can use internal
DOS commands, batch files and I/O redirection in invoking your
compiler. COMMAND.COM is found using the 'COMSPEC' environment
variable, make sure yours is set correctly. Putting COMMAND.COM
on a RAM disk and setting your COMSPEC variable to point to it
considerably speeds operation of QCP and other programs. See
your DOS manual for details.

QCP 2.08 Documentation Page 24

Various sub-strings, in the form of "$c" where c is some
character, can be included in compiler command lines, macro key
templates and the QMAC command line template (see below), in
order to substitute values at run-time. They can be included in
any order. Some make more sense than others in certain contexts,
as noted below:

Substitutes the full path name of the file passed on the command
line to QCP. This is expanded internally by QCP, so even if you
supply a partial path to the file, this will always be the fully
qualified path, in all caps. Note that directory references '.'
and '..' will be correctly removed from the path here (QEdit
doesn't currently do this as of version 2.08).

Drive letter of the file passed. Just the drive letter, no
trailing ':' is included.

Path to the file passed. This is a fully qualified path,
starting at the root, but not including the filename itself. The
leading '\' is included, but no trailing '\' is supplied. If the
file is in the root directory, this string will be the empty

Name of the file. Just the 8-character name, with no delimiters.

Extension of the file. Just the 3-character extension, with no
delimiters. No '.' is included. Can be an empty string if there
is no extension on the original file name.

Note: in all cases, '$F' is exactly equivalent to '$D:$P\$N.$E'.
Keep in mind that $P and $E can be empty strings, but $N, $D and
$F will always contain SOMETHING.

All of the filename-related parameters are capitalized by QCP, so
you need not worry about mixed case if you are examining the
parameters in a batch file. The file passed to QCP is not
checked for existence.

QCP 2.08 Documentation Page 25

Where x is a single digit from 1 to 9. This will expand to
command line parameters (if any) that were passed to QCP on the
command line, beyond the filename. Similar to %1 through %9 in
DOS Batch files.

Expands to a single $ on the target command line or other string.

Expands to the name of the temp file to be created by QCP, as
input for QMAC. Defaults to $QCP$.TMP. After QMAC runs, this
file is deleted by QCP. You can configure it with the "..T"
command in QCP.DAT. It may include a full path specification.

This file is normally used only on the QMAC command line, and by
QCP internally.

Expands to the name of the output file you want compiler output
directed to. Defaults to ERRORS.LST. Normally you include ">$O"
on the compiler command line to insure this file gets created.
You can change this file name with the "/O" command line switch
or the "..O" command in QCP.DAT. It may include a full path
specification. See /O above for details.

Expands to the name of the QEdit binary macro file created by
QMAC or QCP. Defaults to ERRORS.MAC. You can change this file
name with the "/M" command line switch or the "..M" command in
QCP.DAT. It may include a full path specification. See /M above
for details.

Expands to the number of the macro key currently being generated.
This ranges from '1' through '0' if your macro key template
starts with just '@' (the default). If you macro key template
starts with anything else, this ranges from '1' to '12', so you
can find errors with your function keys (or Control-function, or
Alt-function, etc.).

This is ONLY used inside the macro key template(s), and will
expand to nothing if used anywhere else.

QCP 2.08 Documentation Page 26

Expands to the number of the line in your source code that
generated (this) error. Can be any valid number. This is also
only used inside macro key template(s).

--------------------------- |
Expands to the number of the column (on the line $S) in your |
source code where the error occurred. Can be any valid |
number, less than 1000. If no column number was found in the |
error message, this will be the empty string. This is also only |
used inside macro key template(s). |

Expands to the number of the line in the error output ($O) file
that contained this error message. Can be any valid number.
This is also only used inside macro key template(s).

The above three strings, $S, $C and $R, are used to position the
cursor in both windows on the source line, and the error message,
when back in QEdit. See the QEdit macro template string for an
example of their use.

------------------------- |
Expands to a single character to be inserted immediately to the |
left of the source line and column numbers ($S and $C) where they |
appear in the error output. Normally this is CHR( 255 ), which |
is a blank character. You can set this by the /I command line |
option or the ..I command in QCP.DAT. |

This is usually only used in the next error and previous error |
macro templates, but in fact could be used anywhere in the |
program. |

-------------------- |
Expands to the unique string being used to find error messages |
with the currently invoked compiler. |

QCP 2.08 Documentation Page 27

--------------------- |
Expands to the lead-in string being used with the currently |
invoked compiler. |

Both the Unique and Lead-in strings default to the name (plus |
extension if present) of the source file. Since they can contain |
$X expansion characters themselves, there is a danger of a |
circular reference here. The program takes this into account, |
but be sure you do not erroneously create one. |

They are normally used in the next error and previous error macro |
templates, to find error lines in the error output file. They |
are only valid during macro creation. |

Note that if any character other than those listed above appears
after a $ in any string, both the $ and the character will be
"eaten" by QCP and will not appear in the resulting string.
(This is for upward compatibility with possible future extensions
to the above list). If you need to put a $ in your compiler
command line or macro key template, use a double $ as indicated

Some configuration commands can also be included in QCP.DAT to
customize QCP in special ways. They follow the same general form
as file extension lines: a line beginning with a period that is
longer than 5 chars. However, there is a second period to
distinguish these from file name extensions, followed by one
character to specify the operation, a space, and some string

You need not supply all or any of these commands in QCP.DAT, you
can mix and match as you see fit. Any that are not included will
default to the previously installed values in QCP.EXE. If more
than one of the same directive occurs in QCP.DAT, the last one
takes precendence.

..T filename -- TEMP FILE NAME
Sets the name of the temporary file written by QCP and read by
QMAC to create macros. Defaults to $QCP$.TMP. Corresponds to
the "$T" substitution string.

QCP 2.08 Documentation Page 28

..O filename -- OUTPUT FILE NAME
Sets the name of the output file to which compiler output is

redirected. Defaults to ERRORS.LST. Corresponds to the "$O"
substitution string. It can also be set by the /Ofilename
commmand line switch, which overrides the value set here.

..M filename -- MACRO FILE NAME
Sets the name of the macro file to be generated by QMAC from the
key definitions created by QCP. Defaults to ERRORS.MAC.
Corresponds to the "$M" substitution string. It can also be set
by the /Mfilename commmand line switch, which overrides the value
set here.

For all three of the above files, note: Your temp directory, if
defined via the environment variable TMP, will be automatically
pre-pended to this file name if it does not already contain a
drive or path. This is done at RUN-TIME.

If this would cause the file not to match the name being used in
the QEdit macro key, then make sure that the file name contains a
drive or path to suppress use of TMP. You can use ".\" to put
these file in the current directory, the default.

..C commandline -- QMAC COMMAND LINE
Sets a template command line for invocation of QMAC from QCP.
Defaults to "QMAC $M $T B N". Like compiler command lines, this
command line is passed to a child copy of COMMAND.COM, so calling
batch files and I/O redirection is possible here.

One possible alteration to this command line would be to take |
advantage of the "append" capability that QMAC has. With QEdit |
2.08, it is now very easy to load a set of QMAC-style loadable |
macros, every time you use QEdit, by using the /L command line |
switch. Since QMAC macros can be considerably longer and more |
numerous than the ones permanently installed into QEdit by |
QCONFIG, this has some advantages. |

However, when you invoke QCP, and load the macro file it creates, |
your previously loaded macros are thrown away. You could |
overcome this by using QMAC's append mode. |

You could change the ..C command line to read: |

QM $M $T |

QCP 2.08 Documentation Page 29

And set up a batch file, QM.BAT, that contained the following: |

QMAC %1 %2 B Y |

This would put a set of "default" macros, from MYMACROS.MAC, into |
the file ERRORS.MAC. Then, it invokes QMAC, causing the macros |
created by QCP to appended to your default macros in ERRORS.MAC. |
When you return from the compile, both your default macros, and |
any macros created by QCP, are reloaded into QEdit. |

..Q ON
The form with 'ON' or 'OFF' simply activates or deactivates the
creation of QEdit macro keys by QCP. If you do not wish to use
this feature, you can specify "..Q OFF", and no macros will ever
be created.

Specifying ON or OFF does not change the template macro
definition. If you turn macro creation OFF, and later turn it
back ON, your original macro template will still be intact.

If a string other than ON or OFF is specified after "..Q", it
sets the template QEdit macro definition to be generated. When
you set a template this way, macro generation is automatically
turned ON as well. The default is:

@$K MacroBegin |
NextWindow BegLine GotoLine "$R" Return MakeCtrOfScreen |
PrevWindow BegLine GotoLine "$S" Return |
GotoColumn "$C" Return MakeCtrOfScreen |

(Wrapped here for readability). This works in concert with the
default invocation macro (Control-F9) supplied in QCONFIG.QCP, to
scroll both windows (source file, and error listing) to each
error message in synch with each other.

The macro definition can be one or two lines long. If it is two |
lines long, simply end the first line with a "&" (ampersand) and |
continue the macro onto the second line, just as you do with |

QCP 2.08 Documentation Page 30

The default generates a series of macros on ALT-1 through ALT-0
across the top of your keyboard. You could easily change this to
some other series of keys by changing the first few characters of
the macro template. Sensible values are:

Value Keys
---------------------- -------------------------
@$K MacroBegin.... Alt-1 to Alt-0 (Default)
f$K MacroBegin.... F1 to F12
#f$K MacroBegin.... Shift-F1 to Shift-F12
^f$K MacroBegin.... Control-F1 to Control-F12
@f$K MacroBegin.... Alt-F1 to Alt-F12

You will want to pick a series of keys that have no current
definitions in your QCONFIG.DAT, otherwise those definitions will
become inaccessible when the error macro file is loaded by QEdit.

..1 through ..9 -- SPECIAL FILE "EXTENSIONS"
These work exactly like file extension definitions. These
correspond to the "/1" through "/9" command line options on QCP,
and allow you to override the default compiler or program that
would be invoked based on the target files file extension.
(NOTE: These have nothing at all to do with the "$1" through
"$9" substitution strings!).

A sample use of this is supplied in QCP.DAT:

..1 grep -o+n+r+ $1 $2 $3 $4 $5 $6 $7 $8 $9 $F >$O

This example is intended to work with Borland's Turbo Grep, which
is shipped with most of their current language products. The
command line switches may be different with other Grep's. Just
insure that the Grep you use produces Unix-style output with line

This allows you to invoke QCP with

QCP /1 filename reg_expression_string

and regardless of the extension of the file used, GREP will be
invoked to search for the specified regular expression. The
beauty of this is that QCP can read the output generated by GREP,
convert it to macro keys, and allow you to jump to each line GREP
found using QEdit. The Control-F8 function key in QCONFIG.QCP is
set up to do this for you.

QCP 2.08 Documentation Page 31

Another sample use of this replaces the function of QMAKE by
Jerry Houston:

..2 make $N

you can replace "make" with the path and/or name of your
favorite make utility. The assumption here is that for each
source code file you have, you also have a MAKE file, with no
extension, containing the project definition. By using $N, we
pass just the root file name to make via QCP. The invocation of
this would look like: "QCP /2 filename". See QCONFIG.QCP.

..B ON |
..B OFF |
or |
--------------------------------------------------- |
This operation works just like the ..Q macro template--it turns |
batch mode macro creation on or off, and/or sets the QEdit macro |
template that will be used to create the startup macro. See also |
the /B switch above. |

The default for the ..B macro template, which is designed to |
work with the supplied COMPILE.BAT, is as follows: |

250 MacroBegin OneWindow EditFile "$F" Return |
HorizontalWindow EditFile "$O" Return |
BegLine GotoLine "$R" Return MakeCtrOfScreen |
PrevWindow BegLine GotoLine "$S" Return |
GotoColumn "$C" Return MakeCtrOfScreen |

(Wrapped here for readibility). This template may continue onto |
a second line in QCP.DAT, by ending the first line with "&". |

The purpose of batch mode and the startup macro is to use QCP |
from outside QEdit, and then only invoke QEdit AFTER compiling |
the source file. A sample batch file which takes advantage of |
this is supplied in COMPILE.BAT. |

The advantage to Batch mode is that you can use it with compilers |
that are extraordinarily memory-hungry, and therefore cannot be |
run while inside of QEdit. |

QCP 2.08 Documentation Page 32

Batch mode could also be used to implement a "smart make" |
procedure, in which the make process would stop and enter QEdit |
any time an error occurred. Merely by fixing and compiling the |
file in question while in QEdit, and then exiting, the make |
process would resume normally. You could use your normal |
command-line make utility to implement this, by having it invoke |
something similar to COMPILE.BAT for each target that has to be |
created. |

When macros are created, QCP exits with the DOS ERRORLEVEL set to |
one (1). If no errors were found (and therefore no macros |
created) the ERRORLEVEL is set to zero (0). This can be used in |
conjunction with batch mode to decide whether to invoke QEdit. |
See COMPILE.BAT for an example. (If some sort of error occurs, |
such as a missing file, or out of memory, QCP exits with the |
ERRORLEVEL set to 128 or greater). |

..G ON |
or |
--------------------------------------------- |
This command lets you set the default value for the /G command |
line switch. See /G for details. |

..W ON |
or |
------------------------------------------------ |
This command lets you set the default value for the /W command |
line switch. See /W for details. |

---------------------------------------- |
This command lets you set the "insertion" character used in /W+ |
mode. See /I for details. |

The insertion character may be numeric or ASCII when specified |
here, and it must be separated from the ..I by at least one |
space. |

QCP 2.08 Documentation Page 33

..N macroline |
and |
--------------------------------------------------------- |
These two templates allow you to set up generic "go to next |
error" and "go to previous error" macros for use with QCP. This |
is particularly useful with compilers that might generate more |
than ten or twelve error messages per run, and with external GREP |
or other utilities. |

The error output file has to be rewritten by QCP (/W+ must be |
active) for these macros to be written to the macro file. The |
macros take advantage of the insertion character added to the |
compiler output by QCP, to find the row and column numbers |
without any special knowledge of the format of the error |
messages (see /I for info on the insertion character). |

The default for the next error macro is as follows: |

#f10 MacroBegin NextWindow EndLine |
Find "$U" Return "I" Return BegLine |
Find "$I" Return "I" Return |
CursorRight MarkWord Copy |
PrevWindow GotoLine Paste Return |
NextWindow RepeatFind CursorRight MarkWord Copy |
BegLine MakeCtrOfScreen |
PrevWindow GotoColumn Paste Return MakeCtrOfScreen |

The default for the previous error macro is as follows: |

#f9 MacroBegin NextWindow BegLine |
Find "$U" Return "IB" Return BegLine |
Find "$I" Return "I" Return |
CursorRight MarkWord Copy |
PrevWindow GotoLine Paste Return |
NextWindow RepeatFind CursorRight MarkWord Copy |
BegLine MakeCtrOfScreen |
PrevWindow GotoColumn Paste Return MakeCtrOfScreen |

Just as with the other macro templates, these can continue onto a |
second line in QCP.DAT by ending the first line with "&". In |
fact, the definitions presented here are two lines long in the |
supplied QCP.DAT. |

QCP 2.08 Documentation Page 34

Here are some summaries of the various switches, parameters, etc.
that QCP understands:


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

/? or /H show Help screen
/B Batch mode /B+
/C Configure QCP /C or /CE:\MYDIR\MYQCP.EXE
/I set Insertion character /I255
/G set Guess extension mode /G+
/M set Macro file name /M.\errors.mac
/O set Output file name /O.\errors.lst
/P set Pause after error /P+
/Q set QEdit macro creation /Q+
/R Read config from QCP.DAT /R or /RE:\MYDIR\MYQCP.DAT
/S See defaults /S
/W set reWrite error file /W+


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

$$ single dollar sign "$"
$1 to $9 Compiler options varies with compiler
$C source Column number "1"
$D Drive letter "C"
$E Extension of file "PAS"
$F Full filename "C:\LANG\TURBO\MYFILE.PAS"
$I Inserted character CHR( 255 )
$K macro Key number "1" through "0"
$L Lead-in string "MYFILE.PAS"
$M Macro file name ".\ERRORS.MAC"
$N Name of file "MYFILE"
$O Output file name ".\ERRORS.LST"
$P Path (directory) of file "\LANG\TURBO"
$R Result line number "3"
$S Source line number "124"
$T Temp file name "$QCP$.TMP"
$U Unique string "MYFILE.PAS"

QCP 2.08 Documentation Page 35


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

..1 - ..9 Special "extensions" command line to execute
..B Batch mode macro "ON", "OFF", or valid macro
..C QMac Command line "QMAC $M $T B N"
..G Guess extension "ON" or "OFF"
..I Insertion character "255"
..M Macro file name ".\ERRORS.MAC"
..N Next error macro a valid macro
..O Output file name ".\ERRORS.LST"
..P Previous error macro a valid macro
..Q QEdit macro template "ON", "OFF", or valid macro
..T Temp file name "$QCP$.TMP"
..W reWrite error file "ON" or "OFF"

Various error conditions can occur when QCP operates, in which
case it will issue the following error messages. Each of these
will be preceeded by "QCP Error:" to remind you that an error
condition has occurred, and followed by a console beep.

QCP.DAT cannot be found
QCP.EXE cannot be found

The data file or executable file could not be found in the
current directory, the directory the EXE came from, nor anywhere
along the path. These can occur as the result of using the /R or
/C command line switches.

d:\dir\QCP.EXE is corrupted or wrong version

You may have more than one QCP.EXE on your disk, or more than one
version of QCP present. If that is not true, your copy of QCP
may have been damaged due to disk error. Get a fresh copy from
your backup.

DOS error on execution of target command line

Some sort of DOS error (other than out of memory) occurred on
trying to load the child COMMAND.COM. This would be very rare,
but might be caused by an invalid COMSPEC environment variable,
or an invalid copy of COMMAND.COM.

QCP 2.08 Documentation Page 36

Error reading d:\dir\QCP.DAT

This means some sort of DOS error occurred while reading the data
file, either a bad sector, or premature EOF or something.

File name missing on /O or /M switch

You specified /O or /M on the QCP command line without putting a
filename immediately behind the switch (no spaces).

File name missing

After parsing out the various switches, QCP could not find an
actual file name to pass to your compiler.

I/O problem while attempting to write d:\dir\QCP.EXE

Some sort of DOS error occurred while rewriting the defaults in
QCP.EXE. This will only occur when you specify the /C command
line option. Your copy of QCP.EXE may have been damaged by this,
get a new copy off your backup disk.

Improper macro continuation line |

When specifying multi-line QEdit macros in QCP.DAT, by putting |
"&" on the end of the line, QCP does some rudimentary checking. |
If the continuation line begins with a period ("."), it will |
issue this message. It could also happen if the end of QCP.DAT |
was reached before finishing the macro. This can occur while |
reading any of the macro template commands in QCP.DAT. |

Insertion character missing on /I switch |

There was no text immediately behind the /I switch to use as an |
insertion character. You must follow the switch IMMEDIATELY with |
the character itself, or its decimal ASCII code, no space in |
between. |

No extensions found in d:\dir\QCP.DAT

No lines in the specified copy of QCP.DAT began with a '.', so
QCP could not find any extensions to parse.

No matching command line found for extension "xxx"

There was no extension/command line definition in QCP.DAT that
matched the extension of the file given on the command line (i.e.
"xxx"). If you specified /1 through /9 on the command line, then
there was no matching ..1 through ..9 command in your

QCP 2.08 Documentation Page 37

Not enough memory to execute command line

There was not enough memory to load a child copy of COMMAND.COM
and execute your target command line.

Unrecognized command switch "x"

You specified a "/x" switch on the command line that QCP did not
recognize. Check the documentation for valid switches.

Only one of these errors will be displayed during any single run
of QCP. If any of these error messages were displayed, the DOS
ERRORLEVEL value will be set to 128 or higher when QCP exits.

QCP will also issue various informative messages during
operation. These will be preceded by "QCP:" for messages, or
"QCP Warning:" for warnings. No beep will sound, nor will the
ERRORLEVEL be set in these cases, as these are non-fatal
conditions. The "press any key to continue" prompt, if enabled,
will not appear after these messages.

Duplicate definition for "xxx" ignored

There is more than one definition line for extension "xxx" in
your QCP.DAT. Edit your QCP.DAT so that there is only one. If
you need to temporarily disable one definition to use another,
edit the line so that there is no "." in column 1, and QCP will
ignore that line.

Extension table full, extension "xxx" ignored

You have more than 10 extension/command line definitions in your
QCP.DAT, and QCP ran out of table space. "xxx" will be the 11th
or greater extension defined in the file. Edit your QCP.DAT so
that there are 10 or less definitions.

Macro file created for QEdit |

This message appears after QCP is done running QMAC to create a |
loadable binary macro file for QEdit. |

QCP 2.08 Documentation Page 38

New defaults written to d:\dir\QCP.EXE

This informs you that QCP has successfully re-written its
defaults as requested by /C, and where QCP.EXE was found.

Reading configuration from d:\dir\QCP.DAT

This message just informs you that a configuration is being read
to satisfy a /R or /C request, and it tells you where QCP.DAT was
found on the disk.

Unknown configuration command "..x" ignored |

QCP found a command named "..x" in your QCP.DAT, and did not |
recognize it. See elsewhere in this documentation for the list |
of supported configuration commands. |

Unmatched " in input line of d:\dir\QCP.DAT

QCP was trying to read in a command line followed by a unique
string and/or a lead-in string, and could not find a matching
quote character. Since you can mix and match single and double
quotes, double check your data file to be sure you paired them up

Source code to QCP is no longer available.

Special thanks to Tony Tortorelli, Randy Wallin, Gary Speegle,
David Chaika, Howard Kapustein and Sammy Mitchell for help in
tracking down particular compiler command lines that would work
with QCP. Also thanks to Mike Smedley and Jerry Houston for some
great ideas on which QCP is based.

QCP 2.08 Documentation Page 39

If you have any questions or suggestions, please contact:

4343 Shallowford Road
Suite C-3
Marietta, GA 30062-5003

Voice Phone: (404) 641-9002 9 a.m to 5 p.m. E.T., Mon-Fri.
BBS Phone: (404) 641-8968, 2400 bps

Version 1.0 - 7-Feb-1989 - Initial release.

Version 2.0 - 15-Mar-1989 - Substantial revision.
Added internal defaults.
Added /R, /H, /? and /S command line switches.
Added self-configuration /C option.
Added construction of QMAC macros from error output.
Added support for environment variable 'TMP'.
Additional error checking and status messages.
Added "special extensions" for special-purpose macros
Added /M and /O cmd line options to make the
invocation macro more self-contained.
Added /Q, made boolean switches more consistent.
Documentation file significantly rewritten.

Version 2.08 - 17-Nov-1989 - Supports QEdit 2.08. |
Detects column number along with line number. |
Allows generic "next" and "previous" macros. |
Allows compilers to be run outside of QEdit, with |
the editor being invoked via an autoexecute macro. |
Pause after error messages. |
QEdit macros that QCP writes can now be two lines. |
Miscellaneous improvements. |

*** END ***

 December 14, 2017  Add comments

 Leave a Reply

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>