Sei sulla pagina 1di 88

CONTENTS

___________________________________________________________________________

Linker response files . . . . 28


HOW TO USE THIS FILE . . . . . . . 1 Sample OBJXREF reports . . . . 28
BGIOBJ: Converting graphics drivers Report by public names
and fonts . . . . . . . . . . . . 2 (/RP) . . . . . . . . . . . . 29
Adding the new .OBJ files to Report by module (/RM) . . . 29
GRAPHICS.LIB . . . . . . . . . . 3 Report by reference (/RR) . . 30
Registering the drivers and Report by external references
fonts . . . . . . . . . . . . . 3 (/RX) . . . . . . . . . . . . 30
An example . . . . . . . . . . 4 Report of module sizes
The /F option . . . . . . . . . 5 (/RS) . . . . . . . . . . . . 31
Advanced features . . . . . . . 6 Report by class type (/RC) . 31
CPP: The preprocessor . . . . . 10 Report of unreferenced symbol
CPP as a macro preprocessor . 11 names (/RU) . . . . . . . . . 32
An example . . . . . . . . . . 11 Verbose reporting (/RV) . . . 32
GREP: A text-search utility . . 12 Examples of how to use
Command-line syntax . . . . . 13 OBJXREF . . . . . . . . . . . . 32
GREP options . . . . . . . . . 13 Example 1 . . . . . . . . . . 32
Order of precedence . . . . 16 Example 2 . . . . . . . . . . 33
The search string . . . . . . 16 Example 3 . . . . . . . . . . 33
Operators in regular Example 4 . . . . . . . . . . 33
expressions . . . . . . . . 17 OBJXREF error messages and
File specifications . . . . . 18 warnings . . . . . . . . . . . 34
Some GREP examples . . . . . . 18 Error messages . . . . . . . 34
Example 1 . . . . . . . . . 18 Warnings . . . . . . . . . . 34
Example 2 . . . . . . . . . 19 PRJCFG: Configuration file
Example 3 . . . . . . . . . 19 utility . . . . . . . . . . . . . 35
Example 4 . . . . . . . . . 20 PRJCNVT: Old projects for new . . 35
Example 5 . . . . . . . . . 20 PRJ2MAK: From project file to MAKE
Example 6 . . . . . . . . . 21 file . . . . . . . . . . . . . . 36
Example 7 . . . . . . . . . 21 THELP: The Turbo Help utility . . 37
Example 8 . . . . . . . . . 22 Loading and invoking THELP . . 37
OBJXREF: The object module cross- Navigating THELP . . . . . . . 38
reference utility . . . . . . . 22 THELP options . . . . . . . . . 39
The OBJXREF command line . . . 23 /C#xx (select color) . . . . 40
The OBJXREF command-line /Fname (full path and name for
options . . . . . . . . . . 24 help file) . . . . . . . . . 41
Control options . . . . . 24 /H, /?, and ? (display help
Report options . . . . . . 25 screen) . . . . . . . . . . . 42
Response files . . . . . . . . 27 /Kxxyy (reassign hot key) . . 42
Free-form response files . . 27 /U (remove THELP from
Project files . . . . . . . 27 memory) . . . . . . . . . . . 43

i
/Wx,y,w,h (set the window size TRANCOPY: A project transfer item
and location) . . . . . . . 43 utility . . . . . . . . . . . . . 52
TLIB . . . . . . . . . . . . . . 43 TRIGRAPH: A character-conversion
Why use object module utility . . . . . . . . . . . . . 53
libraries? . . . . . . . . . . 44 Transfer macros . . . . . . . . . 54
The TLIB command line . . . . 44 State macros . . . . . . . 54
The operation list . . . . . 46 File name macros . . . . . 54
File and module names . . 46 Instruction macros . . . . 55
TLIB operations . . . . . 46 Running DOS commands . . . . . 59
Using response files . . . . . 48 Transfer memory settings . . . 59
Creating an extended dictionary: Turbo Editor macros . . . . . . . 60
The /E option . . . . . . . . 49 TEMC command line . . . . . . . . 60
Setting the page size: The /P Syntax . . . . . . . . . . . . . 61
option . . . . . . . . . . . . 49 Key codes . . . . . . . . . . . . 62
Advanced operation: The /C Named keys . . . . . . . . . . 63
option . . . . . . . . . . . . 50 Predefined editor commands . . . 64
Examples . . . . . . . . . . . 51
TOUCH . . . . . . . . . . . . . 51 Index 77

ii
TABLES
___________________________________________________________________________

1.1: Summary of THELP command-line 1.3: TLIB action symbols . . . . 47


options . . . . . . . . . . .39 1.4: TEMC editor commands . . . . 64
1.2: TLIB options . . . . . . . .45

iii
Online document
___________________________________________________________________________

Other utilities

===========================================================================
HOW TO USE THIS FILE
===========================================================================
This file has a table of contents and an index that
refer to "pages" in this file. If your editor has a
search facility, you can use it to search for the page
numbers listed in either the table of contents or in
the index. The text "- n -" (where n represents the
actual page number) appears at the bottom left of the
"page" it refers to. Thus, at the bottom of page 1,
you'll find "- 1 -" as the last item on that "page."
Turbo C++ comes with a host of standalone utilities
that you can use with your Turbo C++ files or other
modules. Several are documented in the User's Guide;
others are documented here.

-------------------------------------------------------
Name Description
-------------------------------------------------------
Documented in the User's Guide
MAKE Standalone program manager
TLINK Turbo Linker
Documented in this file
BGIOBJ Conversion utility for graphics drivers and
fonts

- 1 -
CPP Preprocessor
GREP File-search utility
OBJXREF Object module cross-referencer
PRJCFG Updates options in a project file from a
configuration file, or converts a project
file to a configuration file
PRJCNVT Converts Turbo C project files to the Turbo
C++ format
PRJ2MAK Converts Turbo C++ project files to MAKE
files
THELP Turbo Help utility
TLIB Turbo Librarian
TOUCH Updates file date and time
TRANCOPY Copies transfer items from one project to
another
TRIGRAPH Character-conversion utility
TEML/TEMC Turbo Editor Macro Language and Compiler
-------------------------------------------------------
This file explains what each utility is and
illustrates, with code and command-line examples, how
to use them.

===========================================================================
BGIOBJ: Converting graphics drivers and fonts
===========================================================================
You can use BGIOBJ to convert graphics driver files and
character sets (stroked font files) to object (.OBJ)
files. Once they're converted, you can link them into
your program, making them part of the executable file.
This is in addition to the graphics package's dynamic
loading scheme, in which your program loads graphics
drivers and character sets (stroked fonts) from disk at
run time.
Linking drivers and fonts directly into your program is
advantageous because the executable file contains all
(or most) of the drivers and/or fonts it might need,
and doesn't need to access the driver and font files on
disk when running. However, linking the drivers and
fonts into your executable file increases its size.

- 2 -
To convert a driver or font file to a linkable object
file, use the BGIOBJ.EXE utility. This is the
simplified syntax:
BGIOBJ source_file
where source_file is the driver or font file to be
converted to an object file. The object file created
has the same file name as the source file, with the
extension .OBJ; for example, EGAVGA.BGI yields
EGAVGA.OBJ, SANS.CHR gives SANS.OBJ, and so on.

Adding the new =======================================================


.OBJ files to
GRAPHICS.LIB You should add the driver and font object modules to
GRAPHICS.LIB, so the linker can locate them when it
links in the graphics routines. If you don't add these
new object modules to GRAPHICS.LIB, you'll have to add
them to the list of files in the project (.PRJ) file,
on the TCC command line, or on the TLINK command line.
To add these object modules to GRAPHICS.LIB, invoke
TLIB with the following command line:
tlib graphics + object_file_name [+ object_file_name
...]
where object_file_name is the name of the object file
created by BGIOBJ.EXE (such as CGA, EGAVGA, GOTH, and
so forth). The .OBJ extension is implied, so you don't
need to include it. You can add several files with one
command line to save time; see the example in the
following section.

Registering the =======================================================


drivers and fonts
After adding driver and font object modules to
GRAPHICS.LIB, you have to register all the drivers and
fonts that you want linked in; you do this by calling
registerbgidriver and registerbgifont in your program
(before calling initgraph). This informs the graphics
system of the presence of those files, and ensures that
they will be linked in when the executable file is
created by the linker.
The registering routines each take one parameter; a
symbolic name defined in graphics.h. Each registering

- 3 -
routine returns a nonnegative value if the driver or
font is successfully registered.
The following table shows the names to be used with
registerbgidriver and registerbgifont. It is a complete
list of drivers and fonts included with Turbo C++.

---------------------------------------------------------------------------
Driver file registerbgidriver Font file registerbgifont
(*.BGI) symbolic name (*.CHR) symbolic name
---------------------------------------------------------------------------
CGA CGA_driver TRIP triplex_font
EGAVGA EGAVGA_driver LITT small_font
HERC Herc_driver SANS sansserif_font
ATT ATT_driver GOTH gothic_font
PC3270 PC3270_driver
IBM8514 IBM8514_driver
---------------------------------------------------------------------------

------------------ Suppose you want to convert the files for the CGA
An example graphics driver, the gothic font, and the triplex font
------------------ to object modules, then link them into your program.
Here's what you do:
1. Convert the binary files to object files using
BGIOBJ.EXE, as shown in the following separate com-
mand lines:
bgiobj cga
bgiobj trip
bgiobj goth
This creates three files: CGA.OBJ, TRIP.OBJ, and
GOTH.OBJ.
2. You can add these object files to GRAPHICS.LIB with
this TLIB command line:
tlib graphics +cga +trip +goth
3. If you don't add the object files to GRAPHICS.LIB,
you must add the object file names CGA.OBJ,
TRIP.OBJ, and GOTH.OBJ to your project list (if you
are using Turbo C++'s integrated environment), or to

- 4 -
the TCC command line. For example, the TCC command
line would look like this:
TCC niftgraf graphics.lib cga.obj trip.obj
goth.obj
4. You register these files in your graphics program
like this:
If you ever get a /* Header file declares CGA_driver, triplex_font &
linker error gothic_font */
Segment exceeds #include <graphics.h>
64K after linking
in some drivers /* Register and check for errors (one never
and/or fonts, knows...) */
refer to the
following section. if (registerbgidriver(CGA_driver) < 0) exit(1);
if (registerbgifont(triplex_font) < 0) exit(1);
if (registerbgifont(gothic_font) < 0) exit(1);
/* ... */
initgraph(....); /* initgraph should be called
after registering */
/* ... */

The /F option =======================================================


This section explains what steps to take if you get the
linker error Segment exceeds 64K (or a similar error)
after linking in several driver and/or font files
(especially with small- and compact-model programs).
By default, the files created by BGIOBJ.EXE all use the
same segment (called _TEXT). This can cause problems if
your program links in many drivers and/or fonts, or
when you're using the small or compact memory model.
To solve this problem, you can convert one or more of
the drivers or fonts with the BGIOBJ /F option. This
option directs BGIOBJ to use a segment name of the form
filename_TEXT, so that the default segment is not
overburdened by all the linked-in drivers and fonts
(and, in small and compact model programs, all the pro-
gram code). For example, the following two BGIOBJ com-

- 5 -
mand lines direct BGIOBJ to use segment names of the
form EGAVGA_TEXT and SANS_TEXT.
bgiobj /F egavga
bgiobj /F sans
When you select /F, BGIOBJ also appends F to the target
object file name (EGAVGAF.OBJ, SANSF.OBJ, and so
forth), and appends _far to the name that will be used
with registerfarbgidriver and registerfarbgifont. (For
example, EGAVGA_driver becomes EGAVGA_driver_far.)
For files created with /F, you must use these far
registering routines instead of the regular
registerbgidriver and registerbgifont. For example,
if (registerfarbgidriver(EGAVGA_driver_far) < 0)
exit(1);
if (registerfarbgifont(sansserif_font_far) < 0)
exit(1);

Advanced features =======================================================


This section explains some of BGIOBJ's advanced
features, and the routines registerfarbgidriver and
registerfarbgifont. Only experienced users should use
these features.
This is the full syntax of the BGIOBJ.EXE command line:
BGIOBJ [/F] source destination public-name seg-name
seg-class
This table describes each component of the BGIOBJ com-
mand line.

-------------------------------------------------------
Component Description
-------------------------------------------------------

/F or -F This option instructs BGIOBJ.EXE


to use a segment name other than
_TEXT (the default), and to
change the public name and
destination file name. (See page

- 6 -
5 for a detailed discussion of
/F.)
source This is the driver or font file
to be converted. If the file is
not one of the driver/font files
shipped with Turbo C++, you
should specify a full file name
(including extension).
destination This is the name of the object
file to be produced. The default
destination file name is
source.OBJ, or sourceF.OBJ if
you use the /F option.
public-name This is the name that will be
used in the program in a call to
registerbgidriver or
registerbgifont (or their
respective far versions) to link
in the object module.
The public name is the external
name used by the linker, so it
should be the name used in the
program, prefixed with an
underscore. If your program uses
Pascal calling conventions, use
only uppercase letters, and do
not add an underscore.
seg-name This is an optional segment
name; the default is _TEXT (or
filename_TEXT if /F is
specified)
seg-class This is an optional segment
class; the default is CODE.
-------------------------------------------------------
All parameters except source are optional. However, if
you need to specify an optional parameter, all the
parameters preceding it must also be specified.

- 7 -
If you choose to use your own public name(s), you have
to add declaration(s) to your program, using one of the
following forms:
void public_name(void); /* if /F not used, */
/* default segment name
used */
extern int far public_name[]; /* if /F used, or */
/* segment name not
_TEXT */
In these declarations, public_name matches the public-
name you used when converting with BGIOBJ. The
graphics.h header file contains declarations of the
default driver and font public names; if you use those
default public names you don't have to declare them as
just described.
After these declarations, you have to register all the
drivers and fonts in your program. If you don't use the
/F option and don't change the default segment name,
you should register drivers and fonts through
registerbgidriver and registerbgifont; otherwise, use
registerfarbgidriver and registerfarbgifont.
Here is an example of a program that loads a font file
into memory:
/* Example of loading a font file into memory */
#include <graphics.h>
#include <io.h>
#include <fcntl.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <process.h>
#include <alloc.h>
main()
{
void *gothic_fontp; /* points to font buffer
in memory */
int handle; /* file handle used for
I/O */
unsigned fsize; /* size of file (and
buffer) */

- 8 -
int errorcode;
int graphdriver;
int graphmode;
/* open font file */
handle = open("GOTH.CHR", O_RDONLY|O_BINARY);
if (handle == -1)
{
printf("unable to open font file 'GOTH.CHR'\n");
exit(1);
}
/* find out size of the file */
fsize = filelength(handle);
/* allocate buffer */
gothic_fontp = malloc(fsize);
if (gothic_fontp == NULL)
{
printf("unable to allocate memory for font file
'GOTH.CHR'\n");
exit(1);
}
/* read font into memory */
if (read(handle, gothic_fontp, fsize) != fsize)
{
printf("unable to read font file 'GOTH.CHR'\n");
exit(1);
}
/* close font file */
close(handle);
/* register font */
if (registerfarbgifont(gothic_fontp) !=
GOTHIC_FONT)
{
printf("unable to register font file
'GOTH.CHR'\n");
exit(1);
}
/* detect and initialize graphix */
graphdriver = DETECT;
initgraph(&graphdriver, &graphmode, "..");
errorcode = graphresult();
if (errorcode != grOk)
{
printf("graphics error:
%s\n",grapherrormsg(errorcode));
exit(1);
}
settextjustify(CENTER_TEXT, CENTER_TEXT);

- 9 -
settextstyle(GOTHIC_FONT, HORIZ_DIR, 4);
outtextxy(getmaxx()/2,getmaxy()/2,
"Borland Graphics Interface (BGI)");
/* press a key to terminate */
getch();
/* shut down graphics system */
closegraph();
return(0);
}

===========================================================================
CPP: The preprocessor
===========================================================================
CPP produces a Often, when the compiler reports an error inside a
list (in a file) macro or an include file, you can get more information
of a C source about what the error is if you can see the include
program in which files or the results of the macro expansions. In many
include files and multi-pass compilers, a separate pass performs this
#define macros work, and the results of the pass can be examined.
have been Since Turbo C++ uses an integrated single-pass compil-
expanded. It is er, we provided CPP to supply the first-pass
not needed for functionality found in other compilers.
normal compil-
ations of C You use CPP just as you would use TCC, the standalone
programs. compiler. CPP reads the same TURBOC.CFG file for
default options, and accepts the same command-line
options as TCC.
The TCC options that don't pertain to CPP are simply
ignored by CPP. To see the list of arguments handled by
CPP, type cpp at the DOS prompt. To see how those
arguments work, see Chapter 5 in the Programmer's
Guide.
With one exception, the file names listed on the CPP
command line are treated like they are in TCC, with
wildcards allowed. The exception to this is that all
files are treated as C source files. There is no
special treatment for .OBJ, .LIB, or .ASM files.
For each file processed by CPP, the output is written
to a file in the current directory (or the output
directory named by the -n option) with the same name as
the source name but with an extension of .I.

- 10 -
This output file is a text file containing each line of
the source file and any include files. Any preproces-
sing directive lines have been removed, along with any
conditional text lines excluded from the compile.
Unless you use a command-line option to specify other-
wise, text lines are prefixed with the file name and
line number of the source or include file the line came
from. Within a text line, any macros are replaced with
their expansion text.
Important! The resulting output of CPP cannot be compiled because
of the file name and line number prefix attached to
each source line.

CPP as a macro =======================================================


preprocessor
The -P option to CPP tells it to prefix each line with
the source file name and line number. If you give it -
P- (turning this option off), CPP omits this line
number information. With this option turned off, CPP
can be used as a macro preprocessor; the resulting .I
file can then be compiled with TC or TCC.

An example =======================================================
The following simple program illustrates how CPP
preprocesses a file, first with -P selected, then with
-P-.
Source file: HELLOAJ.C
#define NAME "H.R. Floyd"
#define BEGIN {
#define END }
main()
BEGIN
printf("%s\n", NAME);
END
Command line used to invoke CPP as a preprocessor:
CPP HELLOAJ.C
Output:
HELLOAJ.c 1:
HELLOAJ.c 2:
HELLOAJ.c 3:

- 11 -
HELLOAJ.c 4:
HELLOAJ.c 5: main()
HELLOAJ.c 6: {
HELLOAJ.c 7: printf("%s\n","H.R. Floyd");
HELLOAJ.c 8: }
Command line used to invoke CPP as a macro
preprocessor:
CPP -P- HELLOAJ.C
Output:
main()
{
printf("%s\n","H.R. Floyd");
}

===========================================================================
GREP: A text-search utility
===========================================================================
GREP (Global Regular Expression Print) is a powerful
text-search program derived from the UNIX utility of
the same name. GREP searches for a text pattern in one
or more files or in its standard input stream.
Here's a quick example of a situation where you might
want to use GREP. Suppose you wanted to find out which
text files in your current directory contained the
string "Bob". You would issue the command
grep Bob *.txt
and GREP would respond with a list of the lines in each
file (if any) that contained the string "Bob". Because
the default for GREP is to ignore case, the strings
"bob" and "BoB" would also be considered matches. You
can use options to make your search case sensitive.
GREP can do a lot more than match a single, fixed
string. In the section that follows, you'll see how to
make GREP search for any string that matches a
particular pattern.

- 12 -
Command-line =======================================================
syntax
The general command-line syntax for GREP is
grep [options] searchstring [file(s) ... ]
options consist of one or more letters, preceded by a
hyphen (-), that let you change various aspects of
GREP's behavior.
searchstring gives the pattern to search for.
file(s) tells GREP which files to search. (If you don't
specify a file, GREP searches its standard input; this
lets you use GREP with pipes and redirection.) If you
find that the results of your GREP are longer than one
screen, you can redirect the output to a file. For
example, you could use this command
GREP "Bob" *.txt >gfile
which searches all files in the current directory that
end with .TXT, then places the results in a file called
GFILE. (You can name this file anything you like.)
Then, use your word processor (or Turbo C++'s editor)
to access GFILE to read the results of the search.
The command
GREP ?
prints a brief help screen showing GREP's command-line
options, special characters, and defaults. (See the
description of the -u command-line option for
information on how to change GREP's defaults.)

GREP options =======================================================


In the command line, options are one or more single
characters preceded by a hyphen (-). Each individual
character is a switch that you can turn on or off: A
plus symbol (+) after a character turns the option on;
a hyphen (-) after the character turns the option off.
The + sign is optional; for example, -r means the same
thing as -r+. You can list multiple options

- 13 -
individually (like this: -i -d -l), or you can combine
them (like this: -ild or -il, -d, and so on); it's all
the same to GREP.
Here are the GREP option characters and their meanings:

------------------------------------------------------------------------------
Option Meaning
------------------------------------------------------------------------------

-c Match Count only: Prints only a count of matching lines. For each file
that contains at least one matching line, GREP prints the file name and
a count of the number of matching lines. Matching lines are not
printed. This option is off by default.
-d Search subdirectories: For each file specified on the command line,
GREP searches for all files that match the file specification, both in
the directory specified and in all subdirectories below the specified
directory. If you give a file without a path, GREP assumes the files
are in the current directory. This option is off by default.
-i Ignore case: GREP ignores upper/lowercase differences (case folding).
When this option is on, GREP treats all letters a to z as identical to
the corresponding letters A to Z in all situations. This option is on
by default.
-l List file names only: Prints only the name of each file containing a
match. After GREP finds a match, it prints the file name and processing
immediately moves on to the next file. This option is off by default.
-n Line Numbers: Each matching line that GREP prints is preceded by its
line number. This option is off by default.
-o UNIX output format: Changes the output format of matching lines to
support more easily the UNIX style of command-line piping. All lines of
output are preceded by the name of the file that contained the matching
line. This option is off by default.
-r Regular expression search: The text defined by searchstring is treated
as a regular expression instead of as a literal string. This option is
on by default. This option is on by default.
A regular expression is one or more occurrences of one or more
characters optionally enclosed in quotes. The following symbols are
treated specially:
^ start of line $ end of line

- 14 -
. any character \ quote next character
* match zero or more + match one or more
[aeiou0-9] match a, e, i, o, u, and 0 thru 9
[^aeiou0-9] match anything but a, e, i, o, u, and 0 thru 9
-u Update options: GREP will combine the options given on the command line
with its default options and write these to the GREP.COM file as the
new defaults. (In other words, GREP is self-configuring.) This option
allows you to tailor the default option settings to your own taste. If
you want to see what the defaults are in a particular copy of GREP.COM,
type
GREP ?
at the DOS prompt. Each option on the help screen will be followed by a
+ or a - depending on its default setting. This option is off by
default.
-v Nonmatch: Prints only nonmatching lines. Only lines that do not contain
the search string are considered to be nonmatching lines. This option
is off by default.
-w Word search: Text found that matches the regular expression is
considered a match only if the character immediately preceding and
following cannot be part of a word. The default word character set
includes A to Z, 0 to 9, and the underscore ( _ ). This option is off
by default.
An alternate form of this option lets you specify the set of legal word
characters. Its form is -w[set], where set is any valid regular
expression set definition.
If you define the set with alphabetic characters, it is automatically
defined to contain both the uppercase and lowercase values for each
letter in the set (regardless of how it is typed), even if the search
is case-sensitive. If you use the -w option in combination with the -u
option, the new set of legal characters is saved as the default set.
-z Verbose: GREP prints the file name of every file searched. Each
matching line is preceded by its line number. A count of matching lines
in each file is given, even if the count is zero. This option is off by
default.
------------------------------------------------------------------------------

- 15 -
------------------ Remember that each of GREP's options is a switch: Its
Order of state reflects the way you last set it. At any given time,
precedence each option can only be on or off. Each occurrence of a
------------------ given option on the command line overrides its previous
definition. Given this command line,
grep -r -i - -d -i -r - main( my*.c
GREP runs with the -d option on, the -i option on, and the
-r option off.
You can install your preferred default setting for each
option in GREP.COM with the -u option. For example, if you
want GREP to always do a verbose search (-z on), you can
install it with the following command:
grep -u -z

The search string ==========================================================


To use GREP well, you'll need to become proficient at
writing search strings. The value of searchstring defines
the pattern GREP searches for. A search string can be
either a regular expression or a literal string.
o In a regular expression, certain characters have special
meanings: They are operators that govern the search.
o In a literal string, there are no operators: Each
character is treated literally.
You can enclose the search string in quotation marks to
prevent spaces and tabs from being treated as delimiters.
The text matched by the search string cannot cross line
boundaries; that is, all the text necessary to match the
pattern must be on a single line.
A regular expression is either a single character or a set
of characters enclosed in brackets. A concatenation of
regular expressions is a regular expression.

- 16 -
------------------ When you use the -r option (on by default), the search
Operators in string is treated as a regular expression (not a literal
regular expression). The following characters take on special
expressions meanings:
------------------
---------------------------------------------------------------------------
Option Meaning
---------------------------------------------------------------------------

^ A circumflex at the start of the expression matches the start of a


line.
$ A dollar sign at the end of the expression matches the end of a
line.
. A period matches any character.
* An expression followed by an asterisk wildcard matches zero or more
occurrences of that expression. For example, in to*, the * operates
on the expression o; it matches t, to, too, etc. (t followed by zero
or more os), but doesn't match ta.
+ An expression followed by a plus sign matches one or more
occurrences of that expression: to+ matches to, too, etc., but not
t.
[ ] A string enclosed in brackets matches any character in that string,
but no others. If the first character in the string is a circumflex
(^), the expression matches any character except the characters in
the string.
For example, [xyz] matches x, y, or z, while [^xyz] matches a and b,
but not x, y, or z. You can specify a range of characters with two
characters separated by a hyphen (-). These can be combined to form
expressions (like [a-bd-z?], which matches the ? character and any
lowercase letter except c).
\ The backslash escape character tells GREP to search for the literal
character that follows it. For example, \. matches a period instead
of "any character." The backslash can be used to quote itself; that
is, you can use \\ to indicate a literal backslash character in a
GREP expression.
---------------------------------------------------------------------------

- 17 -
Note Four of the "special" characters ($, ., *, and +) don't
have any special meaning when used within a bracketed
set. In addition, the character ^ is only treated
specially if it immediately follows the beginning of
the set definition (immediately after the [ delimiter).
Any ordinary character not mentioned in the preceding
list matches that character. For example, the greater
than sign, >, matches the greater than sign (>), #
matches #, and so on.

File =======================================================
specifications
file(s) tells GREP which files (or groups of files) to
search. file(s) can be an explicit file name, or a
"generic" file name incorporating the DOS ? and *
wildcards. In addition, you can enter a path (drive and
directory information) as part of file(s). If you give
file(s) without a path, GREP searches the current
directory.
If you don't specify any files, input to GREP must come
from redirection (<) or a vertical bar (|).

Some GREP examples =======================================================


The following examples show how to combine GREP's
features to do different kinds of searches. They assume
GREP's default settings are unchanged.

------------------ The search string here tells GREP to search for the
Example 1 word main with no preceding lowercase letters ([^a-z]),
------------------ followed by zero or more occurrences of blank spaces
(\ *), then a left parenthesis.
Since spaces and tabs are normally considered to be
command-line delimiters, you must quote them if you
want to include them as part of a regular expression.
In this case, the space after main is quoted with the
backslash escape character. You could also accomplish
this by placing the space in double quotes.
Command line:
grep -r [^a-z]main\ *( *.c

- 18 -
Matches: main(i:integer)
main(i,j:integer)
if (main ()) halt;
if (MAIN ()) halt;
Does not match:
mymain()
Files searched:
*.C in current directory.

------------------ Because the backslash (\) and period (.) characters


Example 2 usually have special meaning in path and file names,
------------------ you must place the backslash escape character immedi-
ately in front of them if you want to search for them.
The -i option is used here, so the search is not case
sensitive.
Command line:
grep -ri [a-c]:\\data\.fil *.c *.inc
Matches: A:\data.fil
c:\Data.Fil
B:\DATA.FIL
Does not match:
d:\data.fil
a:data.fil
Files searched:
*.C and *.INC in current directory.

------------------ This format defines how to search for a given word.


Example 3
------------------ Command line:
grep -ri [^a-z]word[^a-z] *.doc
Matches: every new word must be on a new line.
MY WORD!
word--smallest unit of speech.
In the beginning there was the WORD, and
the WORD
Does not match:
Each file has at least 2000 words.
He misspells toward as toword.

- 19 -
Files searched:
*.DOC in the current directory.

------------------ This format defines another, even more basic single-


Example 4 word search.
------------------
Command line:
grep -iw word *.doc
Matches: every new word must be on a new line
However,
MY WORD!
word: smallest unit of speech which conveys
In the beginning there was the WORD, and
Does not match:
each document contains at least 2000 words!
He seems to continually misspell "toward"
as "toword."
Files searched:
*.DOC in the current directory.

------------------ This is an example of how to search for a string with


Example 5 embedded spaces.
------------------
Command line:
grep "search string with spaces" *.doc *.c
a:\work\myfile.*
Matches: This is a search string with spaces in it.
Does not match:
This search string has spaces in it.
Files searched:
*.DOC and *.C in the current directory, and
MYFILE.* in a directory called \WORK on
drive A.

- 20 -
------------------ This example searches for any one of the characters
Example 6 " . : ? ' and , at the end of a line.
------------------
The double quote within the range is preceded by an
escape character so it is treated as a normal character
instead of as the ending quote for the string. Also,
the $ character appears outside of the quoted string.
This demonstrates how regular expressions can be
concatenated to form a longer expression.
Command line:
grep -rd "[ ,.:?'\"]"$ \*.doc
Matches: He said hi to me.
Where are you going?
In anticipation of a unique situation,
Examples include the following:
"Many men smoke, but fu man chu."
Does not match:
He said "Hi" to me
Where are you going? I'm headed to the
Files searched:
*.DOC in the root directory and all its
subdirectories on the current drive.

------------------ This example ignores case and just prints the names of
Example 7 any files that contain at least one match. The three
------------------ command-line examples show different ways of specifying
multiple options.
Command line:
grep -ild " the " \*.doc
or
grep -i -l -d " the " \*.doc
or
grep -il -d " the " \*.doc
Matches: Anyway, this is the time we have
do you think? The main reason we are
Does not match:
He said "Hi" to me just when I
Where are you going? I'll bet you're headed

- 21 -
Files searched:
*.DOC in the root directory and all its
subdirectories on the current drive.

------------------ This example redefines the current set of legal


Example 8 characters for a word as the assignment operator (=)
------------------ only, then does a word search. It matches C assignment
statements, which use a single equal sign (=), but not
equality tests, which use a double equal sign (==).
Command line:
grep -w[=] = *.c
Matches: i = 5;
j=5;
i += j;
Does not match:
if (i == t) j++;
/* ======================= */
Files searched:
*.C in the current directory.

===========================================================================
OBJXREF: The object module cross-reference utility
===========================================================================
OBJXREF examines a list of object files and library
files and produces reports on their contents. One type
of report lists definitions of public names and
references to them. The other type lists the segment
sizes defined by object modules.
There are two categories of public names: global
variables and function names. The TEST1.C and TEST2.C
files in the section "Sample OBJXREF reports" (page 28)
illustrate definitions of public names and external
references to them.
Object modules are object (.OBJ) files produced by TC,
TCC or TASM. A library (.LIB) file contains multiple
object modules. An object module generated by TC is
given the same name as the .C source file it was com-
piled from. This is also true for TCC, unless a

- 22 -
different output file name is specifically indicated
with the -o TCC command-line option.

The OBJXREF com- =======================================================


mand line
The OBJXREF command line consists of the word OBJXREF
followed by a series of command-line options and a list
of object and library file names, separated by a space
or tab character. The syntax is as follows:
OBJXREF options filename filename ...
The command-line options determine the kind of reports
that OBJXREF will generate and the amount of detail
that OBJXREF will provide. They are discussed in more
detail in the next section.
Each option begins with a forward slash (/) followed by
a one- or two-character option name.
Object files and library files may be specified either
on the command line or in a response file. On the com-
mand line, file names are separated by a space or a
tab. All object modules specified as .OBJ files are
included in reports. Like TLINK, however, OBJXREF
includes only those modules from .LIB files which
contain a public name referenced by an .OBJ file or by
a previously included module from a .LIB file.
As a general rule, you should list all the .OBJ and
.LIB files that are needed if the program is to link
correctly, including the startup .OBJ file and one or
more C libraries.
File names may include a drive and directory path. The
DOS ? and * wildcard characters may be used to identify
more than one file. File names may refer to .OBJ object
files or to .LIB library files. (If you don't give a
file extension, the .OBJ extension is assumed.)
Options and file names may occur in any order in the
command line.
OBJXREF reports are written to the DOS standard output.
The default is the screen. The reports can be sent to a
printer (as with >LPT1:) or to a file (as with
>lstfile) with the DOS redirection character (>).

- 23 -
Entering OBJXREF with no file names or options produces
a summary of available options.

------------------ OBJXREF command-line options fall into two categories:


The OBJXREF control options and report options.
command-line
options
------------------ Control options
=======================================================
Control options modify the default behavior of OBJXREF
(the default is that none of these options are
enabled).

-------------------------------------------------------
Option Meaning
-------------------------------------------------------

/I Ignore case differences in public names. Use


this option if you use TLINK without the /C
option (which makes case differences
significant).
/D Look for .OBJ files in another directory. If you
want OBJXREF to look for .OBJ files in a
directory other than the current one, include
the directory name on the command line, prefixed
with /D:
OBJXREF /Ddir1 [; dir2 [; dir3]]
or
OBJXREF /Ddir1 [/Ddir2] [/Ddir3]
OBJXREF will search each of the directories in
the specified order for all object and library
files.
Important! If you don't use a /D option, OBJXREF will
search only the current directory. If you do use
a /D option, however, the current directory will
not be searched unless it is included in the
directory list. For example, if you wanted
OBJXREF to search first the BORLAND directory

- 24 -
and then the current directory for files, you
would enter
OBJXREF /Dborland;.
The period denotes the current directory.

/F Include full library. All object modules in


specified .LIB files are included even if they
do not contain public names that are referenced
by an object module being processed by OBJXREF.
This provides information on the entire contents
of a library file. (See example 4 in the section
"OBJXREF examples.")
/O Allows you to specify an output file where
OBJXREF will send any reports generated. Its
syntax is as follows:
OBJXREF filename.obj /report option
/Ooutputfilename.ext
By default all output is sent to the screen.

/V Verbose output. Lists names of files read and


displays totals of public names, modules,
segments, and classes.
/Z Include zero-length segment definitions. Object
modules may define a segment without allocating
any space in it. Listing these zero length
segment definitions normally makes the module
size reports harder to use but it can be
valuable if you are trying to remove all defini-
tions of a segment.
-------------------------------------------------------

Report options
=======================================================
Report options govern what sort of report is generated,
and the amount of detail that OBJXREF provides.

- 25 -
-------------------------------------------------------
Option Report generated
--------------------------------------------------

/RC Report by class type: Module sizes ordered


by class type of segment.
/RM Report by module: Public names ordered by
defining module.
/RP Report by public names: Public names in
order with defining module name.
This is the /RR Report by reference: Public name defini-
default. tions and references ordered by name.
/RS Report of module sizes: Module sizes
ordered by segment name.
/RU Report of unreferenced symbol names:
Unreferenced public names ordered by
defining module.
/RV Verbose reporting: OBJXREF produces a
report of every type.
/RX Report by external reference: External
references ordered by referencing module
name.
--------------------------------------------------
Public names defined in .C files appear in reports with
a leading underscore in the reports unless the -U-
option was specified when the file was compiled (main
appears as _main).
You can limit the modules, segments, classes, or public
names that OBJXREF reports on by entering the
appropriate name on the command line prefixed with the
/N option. For example,
OBJXREF filelist /RM /NC0
tells OBJXREF to generate a report listing information
only for the module named C0.

- 26 -
Response files =======================================================
The command line is limited by DOS to a maximum of 128
characters. If your list of options and file names will
exceed this limit, you must place your file names in a
response file.
A response file is a text file that you make with a
text editor. Since you may already have prepared a list
of the files that make up your program for other Turbo
C++ programs, OBJXREF recognizes several response file
types.
Response files are called from the command line using
one of the following options. The response file name
must follow the option without an intervening space
(so, for example, you would type /Lresp, not /L resp).
You can specify more than one response file on the com-
mand line; additional .OBJ and .LIB file names can
precede or follow them.

------------------ You can create a free-form response file with a text


Free-form response editor. Just list the names of all .OBJ and .LIB files
files needed to make your .EXE file.
------------------
Any file name To use free-form files with OBJXREF, type in each
listed in the response file name on the command line, preceded by an
response file @, and separate it from other command-line entries with
without an exten- a space or tab:
sion is assumed to
be an .OBJ file. @filename @filename ...

------------------ You can also use project files of the type generated by
Project files Turbo C++'s integrated environment as response files.
------------------ In the command line, precede the project file name with
/P, like this:
/Pfilename
If the file name does not include an explicit exten-
sion, a .PRJ extension is assumed.

- 27 -
File names in the project file with a .C extension or
no extension are interpreted as specifying the
corresponding .OBJ file. You need not remove file
dependencies specified inside parentheses; they are
ignored by OBJXREF.
Note By itself, the list of files in a .PRJ file does not
specify a complete program--you must also specify a
startup file (C0x.OBJ) and one or more Turbo C++
library files (MATHX.LIB, EMU.LIB, and CX.LIB, for
example). In addition, you may need to use the /D
option to specify the directory where OBJXREF should
look for your .OBJ files.

------------------ Files in TLINK response-file format can also be used by


Linker response OBJXREF. A linker response file called from the command
files line is preceded by /L, like so:
------------------
/Lfilename
To see how to use one of these files, refer to Example
2 in the section "Examples of how to use OBJXREF."

Sample OBJXREF =======================================================


reports
Suppose you have two source files in your Turbo C++
directory, and want to generate OBJXREF reports on the
object files compiled from them. The source files are
called TEST1.C and TEST2.C, and they look like this:
/* test1.c */
int i1; /* defines i1 */
extern int i2; /* refers to i2 */
static int i3; /* not a public name */
extern void look(void); /* refers to look */
void main(void) /* defines main */
{
int i4; /* not a public name */
look(); /* refers to look */
}
/* test2.c */
#include <process.h>
extern int i1; /* refers to i1 */

- 28 -
int i2; /* defines i2 */
void look(void) /* defines look */
{
exit(i1); /* refers to exit... */
} /* and to i1 */
The object modules compiled from these source files are
TEST1.OBJ and TEST2.OBJ. You can tell OBJXREF what kind
of report to generate about these .OBJ files by
entering the file names on the command line, followed
by a /R and a second letter denoting report type.
Note The following examples show only useful parts of the
output.

------------------ A report by public names lists each of the public names


Report by public defined in the object modules being reported on,
names (/RP) followed by the name of the module in which it is
------------------ defined.
If you enter this on the command line:
OBJXREF /RP test1 test2
OBJXREF generates a report that looks like this:
SYMBOL DEFINED IN
_i1 TEST1
_i2 TEST2
_look TEST2
_main TEST1

------------------ A report by module lists each object module being


Report by module reported on, followed by a list of the public names
(/RM) defined in it.
------------------
If you enter this on the command line:
OBJXREF /RM test1 test2
OBJXREF generates a report that looks like this:
MODULE: TEST1 defines the following symbols:
public: _i1
public: _main

- 29 -
MODULE: TEST2 defines the following symbols:
public: _i2
public: _look

------------------ A report by reference lists each public name with the


Report by defining module in parentheses on the same line.
reference (/RR) Modules that refer to this public name are listed on
------------------ following lines indented from the left margin.
This is the If you enter this on the command line:
default if no
report option is OBJXREF /RR C0 test1 test2 CS.LIB
specified.
OBJXREF generates a report that looks like this:
_exit (EXIT)
C0
TEST2
_i1 (TEST1)
TEST2
_i2 (TEST2)
_look (TEST2)
TEST1
_main (TEST1)
C0

------------------ A report by external references lists each module


Report by external followed by a list of external references it contains.
references (/RX)
------------------ If you enter this on the command line:
OBJXREF /RX C0 test1 test2 CS.LIB
OBJXREF generates a report that looks like this:
MODULE: C0 references the following symbols:
_main
MODULE: TEST1 references the following symbols:
_i2
_look
MODULE: TEST2 references the following symbols:
_exit
_i1

- 30 -
------------------ A report by sizes lists segment names followed by a
Report of module list of modules that define the segment. Sizes in bytes
sizes (/RS) are given in decimal and hexadecimal notation. The word
------------------ uninitialized appears where no initial values are
assigned to any of the symbols defined in the segment.
Segments defined at absolute addresses in a .ASM file
are flagged Abs to the left of the segment size.
If you enter this on the command line:
OBJXREF /RS test1 test2
OBJXREF generates a report that looks like this:
These files were TEST1_TEXT
compiled using the 6 (00006h) TEST1
large memory 6 (00006h) total
model. TEST2_TEXT
10 (0000Ah) TEST2
10 (0000Ah) total
_BSS
4 (00004h) TEST1, uninitialized
2 (00002h) TEST2, uninitialized
6 (00006h) total

------------------ A report by class type lists segment size definitions


Report by class by segment class. The CODE class contains instructions,
type (/RC) DATA class contains initialized data and BSS class
------------------ contains uninitialized data. Segments which do not have
a class type will be listed under the notation No class
type.
If you enter this on the command line:
OBJXREF /RC C0 test1 test2 CS.LIB
OBJXREF generates a report that looks like this:
BSS
4 (00004h) TEST1
2 (00002h) TEST2
...
132 (00084h) total
CODE
6 (00006h) TEST1

- 31 -
10 (0000Ah) TEST2
16 (00010h) total
DATA
143 (0008Fh) C0
143 (0008Fh) total

------------------ A report of unreferenced symbol names lists modules


Report of that define public names not referenced in other
unreferenced modules. Such a symbol is either:
symbol names (/RU)
------------------ o referenced only from within the defining module and
does not need to be defined as a public symbol (in
that case, if the module is in C, the keyword static
should be added to the definition; if the module is
in TASM, just remove the public definition).
o never used (therefore, it can be deleted to save code
or data space).
If you enter this on the command line:
OBJXREF /RU test1 test2
OBJXREF generates a report that looks like this:
MODULE: TEST2 defines the unreferenced symbol _i2.

------------------ If you enter /RV on the command line, OBJXREF generates


Verbose reporting one report of each type.
(/RV)
------------------
Examples of how to =======================================================
use OBJXREF
These examples assume that the application files are in
the current directory of the default drive and that the
Turbo C++ startup files (C0x.OBJ) and the library files
are in the \TC\LIB directory.

------------------ C>OBJXREF \TC\lib\c0l test1 test2 \TC\lib\cl.lib


Example 1
------------------ In this example, the TEST1.OBJ and TEST2.OBJ files and
the Turbo C++ startup file \TC\LIB\C0L.OBJ and the
library file \TC\LIB\CL.LIB are specified. Since no
report type is specified, the resulting report is the

- 32 -
default report by reference, listing public names and
the modules that reference them.

------------------ C>OBJXREF /RV /Ltest1.arf


Example 2
------------------ The TLINK response file TEST1.ARF contains the same
list of files as the command line in Example 1. The /RV
option is specified, so a report of every type will be
generated. TEST1.ARF contains
\TC\lib\c0l
test1 test2
test1.exe
test1.map
\TC\lib\cl

------------------ C>OBJXREF /RC B:c0s /Ptest1 @libs


Example 3
------------------ The Turbo C++ project file TEST1.PRJ specifies
TEST1.OBJ and TEST2.OBJ. The response file @libs
specifies libraries on a disk in the B drive. TEST1.PRJ
contains
test1
test2.c
The file LIBS contains
b:maths.lib b:emu.lib b:cs.lib
The startup and library files specified depend on the
memory model and floating point options used in compil-
ation. The /RC causes a report of class type to be
output.

------------------ C>OBJXREF /F /RV \TC\lib\cs.lib


Example 4
------------------ This example reports on all the modules in the Turbo
C++ library file CS.LIB; OBJXREF can produce useful
reports even when the files specified do not make a
complete program. The /F causes all modules in CS.LIB
file to be included in the report.

- 33 -
OBJXREF error =======================================================
messages and
warnings OBJXREF generates two sorts of diagnostic messages:
error messages and warnings.

------------------ Out of memory


Error messages OBJXREF performs its cross referencing in RAM memory
------------------ and may run out of memory even if TLINK is able to link
the same list of files successfully. When this happens,
OBJXREF aborts. Remove memory resident programs to get
more space, or add more RAM.

------------------ WARNING: Unable to open input file <filename>


Warnings The input file filename could not be located or opened.
------------------ OBJXREF proceeds to the next file.
WARNING: Unknown option - <option>
The option name option is not recognized by OBJXREF.
OBJXREF ignores the option.
WARNING: Unresolved symbol <symbol> in module <module>
The public name symbol referenced in module module is
not defined in any of the .OBJ or .LIB files specified.
OBJXREF flags the symbol in any reports it generates as
being referenced but not defined.
WARNING: Invalid file specification <filename>
Some part of the file name filename is invalid. OBJXREF
proceeds to the next file.
WARNING: No files matching <filename>
The file named filename listed on the command line or
in a response file could not be located or opened.
OBJXREF skips to the next file.
WARNING: Symbol <symbol> defined in <module1>
duplicated in <module2>
Public name symbol is defined in modules module1 and
module2. OBJXREF ignores the second definition.

- 34 -
===========================================================================
PRJCFG: Configuration file utility
===========================================================================

Creates the command-line configuration file from a


project file. You can also use it to create or update a
project file from a configuration file.
The command-line compiler looks for a default
configuration file named TURBOC.CFG, but you can
specify a different file with +pathname option. To use
PRJCFG to create a TCC configuration file from a
project file, you would type the following:
PRJCFG ProjFile.PRJ ConfigFile.CFG
To make a project file from a configuration file, type
PRJCFG ConfigFile.CFG ProjFile.PRJ

===========================================================================
PRJCNVT: Old projects for new
===========================================================================
This utility converts Turbo C 1.0, 1.5, and 2.0 project
files to Turbo C++ project files. The syntax for it is
PRJCNVT infile[.PRJ] [outfile[.PRJ]]
or
PRJCNVT infile[.TC] [outfile[.PRJ]]
If you specify a configuration file as input, it must
have a project file defined. The compiler options in
the .CFG file and the dependencies in the Turbo C 2.0
.PRJ file will be placed into the corresponding Turbo
C++ .PRJ file.
If you specify a project file as input, only
dependencies information will be placed into the Turbo
C++ .PRJ file. All compiler options will remain
default.

- 35 -
If you don't provide an extension, .TC is assumed. If
PRJCVNT can't find a .TC file, it looks for a .PRJ
file.
The default name of the output file is the base name of
the input file with the extension .PRJ. For example,
STARS.TC will turn into STARS.PRJ. If the input and the
output name are the same, the old file will be renamed
to a .BAK file.

===========================================================================
PRJ2MAK: From project file to MAKE file
===========================================================================
This utility converts a .PRJ file to a .MAK file
(containing all relevant switches and settings) for use
with the MAKE utility. These files can be re-used
without accessing the IDE. The syntax for PRJ2MAK is
PRJ2MAK projectfile[.PRJ] [makefile[.MAK]
[config[.CFG]]]
The extension for the project file name is assumed to
be .PRJ unless you specify otherwise.
The default name for the new MAKE file is the base file
name of the .PRJ file with the extension .MAK. The
default name for the new .CFG file is the base file
name of the .MAK file with the extension .CFG.
To change the names of the makefile and configuration
files, just specify different names on the command
line.
Examples of valid execution:
PRJ2MAK MYPROJ.PRJ MAKEFILE.MAK TURBOC.CFG
This execution creates a makefile called MAKEFILE.MAK
with a configuration file called TURBOC.CFG.
PRJ2MAK MYPROJ.PRJ MAKEFILE.MAK
This execution creates a makefile called MAKEFILE.MAK
with a configuration file called MYPROJ.CFG.
PRJ2MAK MYPROJ

- 36 -
This execution creates a makefile called MYPROJ.MAK and
a configuration file called MYPROJ.CFG.
The makefile that PRJ2MAK creates will set up a
redirection file for the linker response file and for
the .CFG file. They will be created when you run the
makefile that was generated. The linker response file
is a temporary file and will be deleted. The .CFG file
will be left as a file on disk.
PRJ2MAK places options that meet the following
requirements into the .CFG file: Those that are not
default to the Turbo C++ command-line compiler and have
been selected in the project file.
PRJ2MAK will use the library search path as a command
link option to TLINK, so that TLINK can search that
path for the startup module and for libraries.

===========================================================================
THELP: The Turbo Help utility
===========================================================================
THELP.COM is a RAM-resident (TSR) utility that accesses
Turbo C++'s online Help information for you when you
aren't using the IDE (that is, if you are using an
editor other than the one in the IDE, or you are using
the command-line version of Turbo C++, or if you are
using another product, such as Turbo Debugger). THELP
requires about 21K bytes of memory.

Loading and =======================================================


invoking THELP

- 37 -
You need to first load THELP in order to use it from
within another program (or from the command line). Make
sure that TCHELP.TCH, the text file containing the
Turbo C++ online help information, is in the current
Warning! If you directory. (If you want to keep TCHELP.TCH in another
are going to have directory, THELP has a special /F command-line option
THELP resident in that will enable THELP to find it; the INSTALL program
memory at the same inserts the correct path information into THELP.)
time as SideKick
1.x or SideKick To load THELP, just type
Plus, make sure
you load THELP THELP [options]
before you load
SideKick. at the DOS command line before you go into your
application. This needs to be done only once, when you
first boot up.
Once you are in the other application, you can activate
THELP at any time. Just position the cursor under the
item you want information on, then press the THELP hot
key. The default hot key is 5 on the numeric keypad
(scan code 4ch, shift state 00h).

Navigating THELP =======================================================


Use the following keys to navigate through the Help
screens that THELP displays on your monitor:

----------------------------------------------------------------------
Key What it does
----------------------------------------------------------------------

Up Down Left Right


Move the highlight from keyword to keyword within the current
Help screen.
Shift-Arrow
Moves the cursor while marking a block.
Home and End
Move to the beginning and end of a line, respectively.
Tab and Shift-Tab
Moves to the next or previous keyword.

- 38 -
PgUp/PgDn
Moves from screen to screen if additional screens are
available.
Enter Selects a Help entry for the item highlighted in the current
Help screen.
Esc Ends Help session.
F1 Displays the Help Table of Contents screen.
Shift-F1 Displays the Help Index. You can search for a specific
keyword incrementally. For example, you can find printf by
typing p r i. With each letter you type, the list jumps to
the keyword that starts with p, then to pr, then to pri, and
so on.
Alt-F1 Pressing Alt-F1 repeatedly takes you in reverse order through
the last 20 screens you have reviewed.
Alt-F Selects a new Help file (if you have specified more than one
help file in the THELP.CFG file or on the
command-line).
Ctrl-P Pastes the marked block or example text into your current
application.
----------------------------------------------------------------------

THELP options =======================================================


Here is a summary of the THELP command-line options. If
you use more than one option, you must separate them
with spaces.
The command-line options can be placed in a
configuration file (called THELP.CFG) for convenience.
THELP.CFG must be located in the same directory as
THELP.COM and each option in the configuration file
must be placed on its own line and begin in the
leftmost column.

-------------------------------------------------------
Summary of THELP Option Specifies
command-line -------------------------------------------------------
options

- 39 -
Table 1.1: Summary of THELP command-line options
(continued)____________________________________________
/C#xx Select color:
# = color number
xx = hex color values
/Fname Full path and file name of Help file
/H, /?, ? Display help screen
/Kxxyy Change hot key:
xx = shift state (hex)
yy = scan code (hex)
/U Remove THELP from memory
/Wx,y,w,h Sets the window size and location.
-------------------------------------------------------

------------------ This option lets you customize the background and


/C#xx (select foreground colors of various elements in a help screen.
color) The /C option is followed by the number of the color
------------------ you want and the hex color values for background and
foreground, respectively.
There are twelve possible colors, numbered as follows:

-------------------------------------------------------
Number Element
-------------------------------------------------------

0 Color border attribute


1 Monochrome border attribute
2 Color text attribute
3 Monochrome text attribute
4 Color keyword attribute
5 Monochrome keyword attribute
6 Color selected keyword word attribute
7 Monochrome selected keyword word attribute
8 Color example text attribute
9 Monochrome example text attribute
A Color marked block attribute
B Monochrome marked block attribute

- 40 -
-------------------------------------------------------
The color values for a standard IBM-compatible color
display are as follows:

-------------------------------------------------------
First digit (background) Second digit (foreground)
-------------------------------------------------------

0 Black 0 Black
1 Blue 1 Blue
2 Green 2 Green
3 Cyan 3 Cyan
4 Red 4 Red
5 Magenta 5 Magenta
6 Brown 6 Brown
7 Gray 7 Gray
8 Intense black
ORing the color value 9 Intense blue
with 0x80 produces a A Intense green
blinking color unless B Intense cyan
blinking has been C Intense red
disabled. D Intense magenta
E Intense brown (yellow)
F Intense gray (white)
-------------------------------------------------------
On monochrome monitors, the attribute values can differ
widely, so you may need to experiment.

------------------ The name that follows the /F option should be the full
/Fname (full path drive/directory path name of the help file to use; for
and name for help example,
file)
------------------ THELP /FC:\TC\OWLHELP.TCH
THELP /FC:\TC\TCHELP.TCH
You can specify multiple help files on the command-line
or in the THELP.CFG file. THELP supports up to eight
help files.

- 41 -
------------------ Any of these options displays a summary of THELP's com-
/H, /?, and ? mand-line options.
(display help
screen)
------------------ This option allows you to reassign a function to a new
/Kxxyy (reassign hot key. The option must be followed by the shift state
hot key) (xx) and the scan code (yy) of the new key. Virtually
------------------ any shift state/scan code combination may be selected.
Here's a quick summary of some common shift states and
scan codes:

-------------------------------------------------------
Shift states (can be OR'ed together):
Right Shift 01h
Left Shift 02h
Ctrl 04h
Alt 08h
Scan codes:
A 1eh N 31h 0 0bh F1 3bh
B 30h O 18h 1 02h F2 3ch
C 2eh P 19h 2 03h F3 3dh
D 20h Q 10h 3 04h F4 3eh
E 12h R 13h 4 05h F5 3fh
F 21h S 1fh 5 06h F6 40h
G 22h T 14h 6 07h F7 41h
H 23h U 16h 7 08h F8 42h
I 17h V 2fh 8 09h F9 43h
J 24h W 11h 9 0ah F10 44h
K 25h X 2dh
L 26h Y 15h
M 32h Z 2ch
Enhanced keyboards only (may not work with all
computers or keyboards):
F11 57h
F12 58h
-------------------------------------------------------

- 42 -
------------------ This option removes THELP from memory. If other TSRs
/U (remove THELP have been loaded after THELP, make sure to remove them
from memory) before removing THELP.
------------------
------------------ Where:
/Wx,y,w,h (set the x = window column location (zero based)
window size and y = window row location
location) w = window width
------------------ h = window height
For example, to create a full-screen help window use:
/W0,0,80,25

===========================================================================
TLIB
===========================================================================
TLIB is a utility that manages libraries of individual
.OBJ (object module) files. A library is a convenient
tool for dealing with a collection of object modules as
a single unit.
When it modifies The libraries included with Turbo C++ were built with
an existing TLIB. You can use TLIB to build your own libraries, or
library, TLIB to modify the Turbo C++ libraries, your own libraries,
always creates a libraries furnished by other programmers, or commercial
copy of the libraries you've purchased. You can use TLIB to
original library
with a .BAK exten- o create a new library from a group of object modules
sion. Better safe
than sorry! o add object modules or other libraries to an existing
library
o remove object modules from an existing library
o replace object modules from an existing library
o extract object modules from an existing library
o list the contents of a new or existing library

- 43 -
See the section on TLIB can also create (and include in the library file)
the /E option an Extended Dictionary, which may be used to speed up
(page 49) for linking.
details.
Although TLIB is not essential for creating executable
programs with Turbo C++, it is a useful programming
productivity tool. You will find TLIB indispensable for
large development projects. If you work with object
module libraries developed by others, you can use TLIB
to maintain those libraries when necessary.

Why use object =======================================================


module libraries?
When you program in C and C++, you often create a
collection of useful functions and classes. Because of
C and C++'s modularity, you are likely to split those
functions into many separately compiled source files.
You use only a subset of functions from the entire
collection in any particular program. It can become
quite tedious, however, to figure out exactly which
files you are using. On the other hand, if you always
include all the source files, your program becomes
extremely large and unwieldy.
An object module library solves the problem of managing
a collection of functions and classes. When you link
your program with a library, the linker scans the
library and automatically selects only those modules
needed for the current program.

The TLIB command =======================================================


line
To get a summary The TLIB command line takes the following general form,
of TLIB's usage, where items listed in square brackets ([like this]) are
just type TLIB and optional:
press Enter.
tlib [/C] [/E] [/Psize] libname [operations] [,
listfile]

- 44 -
Table 1.2: TLIB options

---------------------------------------------------------------------------
Option Description
---------------------------------------------------------------------------
libname The DOS path name of the library you want to create or
manage. Every TLIB command must be given a libname.
Wildcards are not allowed. TLIB assumes an extension of .LIB
if none is given. We recommend that you do not use an exten-
sion other than .LIB, since both TCC and TC's project-make
facility require the .LIB extension in order to recognize
library files. Note: If the named library does not exist and
there are add operations, TLIB creates the library.
/C The case-sensitive flag. This option is not normally used;
see page 50 for a detailed explanation.
/E Creates Extended Dictionary; see page 49 for a detailed
explanation.
/Psize Sets the library page size to size; see page 49 for a
detailed explanation.
operations The list of operations TLIB performs. Operations may appear
in any order. If you only want to examine the contents of
the library, don't give any operations.
listfile The name of the file listing library contents. The listfile
name (if given) must be preceded by a comma. No listing is
produced if you don't give a file name. The listing is an
alphabetical list of each module. The entry for each module
contains an alphabetical list of each public symbol defined
in that module. The default extension for the listfile is
.LST. You can direct the listing to the screen by using the
listfile name CON, or to the printer by using the name PRN.
---------------------------------------------------------------------------
This section summarizes each of these command-line com-
ponents; the following sections provide details about
using TLIB. For TLIB examples, refer to the "Examples"
section on page 51.

- 45 -
------------------ The operation list describes what actions you want TLIB
The operation list to do. It consists of a sequence of operations given
------------------ one after the other. Each operation consists of a one-
or two-character action symbol followed by a file or
module name. You can put whitespace around either the
action symbol or the file or module name, but not in
the middle of a two-character action or in a name.
You can put as many operations as you like on the com-
mand line, up to DOS's COMMAND.COM-imposed line-length
limit of 127 characters. The order of the operations is
not important. TLIB always applies the operations in a
specific order:
1. All extract operations are done first.
2. All remove operations are done next.
3. All add operations are done last.
You can replace a module by first removing it, then
adding the replacement module.

File and module names


=======================================================
TLIB finds the name of a module by taking the given
file name and stripping any drive, path, and extension
information from it. (Typically, drive, path, and
extension are not given.)
Note that TLIB always assumes reasonable defaults. For
example, to add a module that has an .OBJ extension
from the current directory, you only need to supply the
module name, not the path and .OBJ extension.
Wildcards are never allowed in file or module names.

TLIB operations
=======================================================
TLIB recognizes three action symbols (*, +, *), which
you can use singly or combined in pairs for a total of
five distinct operations. The order of the characters

- 46 -
is not important for operations that use a pair of
characters. The action symbols and what they do are
listed here:

-------------------------------------------------------
TLIB action Action
symbols symbol Name Description
-------------------------------------------------------
To create a + Add TLIB adds the named file to
library, add the library. If the file has
modules to a no extension given, TLIB
library that does assumes an extension of .OBJ.
not yet exist. If the file is itself a
library (with a .LIB exten-
sion), then the operation adds
all of the modules in the
named library to the target
library.
If a module being added
already exists, TLIB displays
a message and does not add the
new module.
- Remove TLIB removes the named module
from the library. If the
module does not exist in the
library, TLIB displays a
message.
A remove operation only needs
a module name. TLIB allows you
to enter a full path name with
drive and extension included,
but ignores everything except
the module name.
* Extract TLIB creates the named file by
copying the corresponding
module from the library to the
file. If the module does not
exist, TLIB displays a message
and does not create a file. If
the named file already exists,
it is overwritten.

- 47 -
Table 1.3: TLIB action symbols (continued)_____________
You can't directly -* Extract & TLIB copies the named module
rename modules in *- Remove to the corresponding file name
a library. To and then removes it from the
rename a module, library. This is just
extract and remove shorthand for an extract
it, rename the followed by a remove
file just created, operation.
then add it back
into the library. -+ Replace TLIB replaces the named module
+- with the corresponding file.
This is just shorthand for a
remove followed by an add
operation.
-------------------------------------------------------

Using response =======================================================


files
When you are dealing with a large number of operations,
or if you find yourself repeating certain sets of
operations over and over, you will probably want to
start using response files. A response file is simply
an ASCII text file (which can be created with the Turbo
C++ editor) that contains all or part of a TLIB com-
mand. Using response files, you can build TLIB commands
larger than would fit on one DOS command line.
See "Examples" for To use a response file pathname, specify @pathname at
a sample response any position on the TLIB command line.
file and a TLIB
command line o More than one line of text can make up a response
incorporating it. file; you use the "and" character (&) at the end of a
line to indicate that another line follows.
o You don't need to put the entire TLIB command in the
response file; the file can provide a portion of the
TLIB command line, and you can type in the rest.
o You can use more than one response file in a single
TLIB command line.

- 48 -
Creating an =======================================================
extended
dictionary: The /E To speed up linking with large library files (such as
option the standard Cx.LIB library), you can direct TLIB to
create an extended dictionary and append it to the
library file. This dictionary contains, in a very
compact form, information that is not included in the
standard library dictionary. This information enables
TLINK to process library files faster.
To create an extended dictionary for a library that is
being modified, use the /E option when you invoke TLIB
to add, remove, or replace modules in the library. To
create an extended dictionary for an existing library
that you don't want to modify, use the /E option and
ask TLIB to remove a nonexistent module from the
library. TLIB will display a warning that the specified
module was not found in the library, but it will also
create an extended dictionary for the specified
library. For example, if you enter
tlib /E mylib -bogus
TLINK will ignore the debugging information in a
library that has an extended dictionary, unless the /e
option is used on the TLINK command line.

Setting the page =======================================================


size: The /P
option Every DOS library file contains a dictionary (which
appears at the end of the .LIB file, following all of
the object modules). For each module in the library,
this dictionary contains a 16-bit address of that
particular module within the .LIB file; this address is
given in terms of the library page size (it defaults to
16 bytes).
The library page size determines the maximum combined
size of all object modules in the library--it cannot
exceed 65,536 pages. The default (and minimum) page
size of 16 bytes allows a library of about 1 MB in
size. To create a larger library, the page size must be
increased using the /P option; the page size must be a

- 49 -
power of 2, and it may not be smaller than 16 or larger
than 32,768.
All modules in the library must start on a page
boundary. For example, in a library with a page size of
32 (the lowest possible page size higher than the
default 16), on the average 16 bytes will be lost per
object module in padding. If you attempt to create a
library that is too large for the given page size, TLIB
will issue an error message and suggest that you use /P
with the next available higher page size.

Advanced =======================================================
operation: The /C
option When you add a module to a library, TLIB maintains a
dictionary of all public symbols defined in the modules
of the library. All symbols in the library must be
distinct. If you try to add a module to the library
that would cause a duplicate symbol, TLIB displays a
message and won't add the module.
Normally, when TLIB checks for duplicate symbols in the
library, uppercase and lowercase letters are not
considered as distinct. For example, the symbols lookup
and LOOKUP are treated as duplicates. Since C and C++
do treat uppercase and lowercase letters as distinct,
use the /C option to add a module to a library that
includes a symbol differing only in case from one
already in the library. The /C option tells TLIB to
accept a module with symbols in it that differ only in
case from symbols already in the library.
If you want to use It may seem odd that, without the /C option, TLIB
the library with rejects symbols that differ only in case, especially
other linkers (or since C and C++ are case-sensitive languages. The
allow other people reason is that some linkers fail to distinguish between
to use the library symbols in a library that differ only in case. Such
with other linkers, for example, will treat stars, Stars, and
linkers), for your STARS as the same identifier. TLINK, on the other hand,
own protection you has no problem distinguishing uppercase and lowercase
should not use the symbols, and it will properly accept a library contain-
/C option. ing symbols that differ only in case. In this example,
then, Turbo C++ would treat stars, Stars, and STARS as
three separate identifiers. As long as you use the
library only with TLINK, you can use the TLIB /C option
without any problems.

- 50 -
Examples =======================================================
Here are some simple examples demonstrating the
different things you can do with TLIB.
1. To create a library named MYLIB.LIB with modules
X.OBJ, Y.OBJ, and Z.OBJ, type
tlib mylib +x +y +z
2. To create a library as in #1 and get a listing in
MYLIB.LST too, type
tlib mylib +x +y +z, mylib.lst
3. To get a listing in CS.LST of an existing library
CS.LIB, type
tlib cs, cs.lst
4. To replace module X.OBJ with a new copy, add A.OBJ
and delete Z.OBJ from MYLIB.LIB, type
tlib mylib -+x +a -z
5. To extract module Y.OBJ from MYLIB.LIB and get a
listing in MYLIB.LST, type
tlib mylib *y, mylib.lst
6. To create a new library named ALPHA, with modules
A.OBJ, B.OBJ, ..., G.OBJ using a response file:
First create a text file, ALPHA.RSP, with
+a.obj +b.obj +c.obj &
+d.obj +e.obj +f.obj &
+g.obj
Then use the TLIB command, which produces a listing
file named ALPHA.LST:
tlib alpha @alpha.rsp, alpha.lst

===========================================================================
TOUCH
===========================================================================
There are times when you want to force a particular
target file to be recompiled or rebuilt, even though no
changes have been made to its sources. One way to do

- 51 -
this is to use the TOUCH utility. TOUCH changes the
date and time of one or more files to the current date
and time, making it "newer" than the files that depend
on it.
You can force MAKE to rebuild a target file by touching
one of the files that target depends on. To touch a
file (or files), type
You can use the touch filename [filename ...]
DOS wildcards *
and ? with TOUCH. at the DOS prompt. TOUCH will then update the file's
creation date(s). Once you do this, you can invoke MAKE
to rebuild the touched target file(s).
Important! Before you use the TOUCH utility, it's vitally
important to set your system's internal clock to the
proper date and time. If you're using an IBM PC, XT, or
compatible that doesn't have a battery-powered clock,
don't forget to set the time and date using the DOS
TIME and DATE commands. Failing to do this will keep
both TOUCH and MAKE from working properly.

===========================================================================
TRANCOPY: A project transfer item utility
===========================================================================
TRANCOPY copies transfer items from one project to
another. The syntax is
TRANCOPY [-r] Source[.PRJ] Dest[.PRJ]
TRANCOPY merges the transfer items in Source with the
transfer in Dest; Dest gets the new transfer items.
If the -r option is used, the set of the transfer items
in Dest is replaced by the set of transfer items in
Source.

- 52 -
===========================================================================
TRIGRAPH: A character-conversion utility
===========================================================================
Trigraphs are three-character sequences that replace
certain characters used in the C language that are not
available on some keyboards. Translating trigraphs in
the compiler would slow compilation down considerably,
so Turbo C++ provides a filter named TRIGRAPH.EXE to
handle trigraph sequences when you need to. The syntax
for invoking this program is as follows:
TRIGRAPH [-u] file(s) [file(s) ...]
The following table shows the trigraph sequences that
TRIGRAPH.EXE recognizes:

-------------------------------------------------------
Trigraph Character
-------------------------------------------------------

??= #
??( [
??/ \
??) ]
??' ^
??< {
??! |
??> }
??- ~
-------------------------------------------------------
TRIGRAPH.EXE works in two directions: It can convert
all trigraphs to their single-character representation,
and it can convert single characters to their trigraph
representation. Ordinarily, TRIGRAPH.EXE converts
trigraphs to single characters. You can specify the
inverse conversion with the -u (UNDO) command-line
option, which must come before any file names on the
command line.
TRIGRAPH.EXE takes any number of file specifiers,
including wildcards, on the command line. For each file
specified, it creates a backup copy of the file with
the original file name and an extension of .BAK, and

- 53 -
creates a new file with the original file name and the
appropriate conversions performed. For example,
trigraph test.c test1.c
removes all trigraphs from the two files TEST.C and
TEST1.C, creating backup files TEST.BAK and TEST1.BAK.
As another example, the following command inserts
trigraphs into all the files with the extension .C, and
makes backup copies of all those files, giving them the
extension .BAK.
trigraph -u *.c

===========================================================================
Transfer macros
===========================================================================
The IDE recognizes certain strings of characters called
transfer macros in the parameter string of the
Modify/New Transfer Item dialog box. There are three
kinds of macros: state, file name, and instruction.

The transfer State macros


macros are listed =======================================================
alphabetically and
described in more State macros are expanded according to the state of the
detail starting on IDE. The state macros are
page 55.
$COL $ERRNAME
$CONFIG $INC
$DEF $LIB
$ERRCOL $LINE
$ERRLINE $PRJNAME

File name macros


=======================================================
File name macros are actually functions that take file
names as arguments and return various parts of the file
name. They allow you to build up new file name
specifications from existing file names. For example,
you can pass TDUMP a macro like this:

- 54 -
$DIR($EXENAME)$NAME($EDNAME).OBJ
This macro gives you the output directory path, the
file name only in the active Edit window, and an
explicit extension. If your current directory is
C:\WORK, your output directory is TEST, and the active
editor contains MYPROG.C, then TDUMP receives the
parameter
C:\WORK\TEST\MYPROG.OBJ
The file name macros are
$DIR $EXT()
$DRIVE() $NAME()
$EDNAME $OUTNAME
$EXENAME

Instruction macros
=======================================================
Instruction macros tell the IDE to perform some action
or make some setting. The instruction macros are
$CAP EDIT $PROMPT
$CAP MSG(filter) $SAVE ALL
$DEP() $SAVE CUR
$MEM(kb to reserve) $SAVE PROMPT
$NOSWAP $TASM

$CAP EDIT: This macro tells the IDE to redirect program


output into a standard file. After the transfer program
is completed, a new editor window is created, and the
captured output is displayed. The captured output
resides in a special Edit window titled Transfer
Output.
For $CAP EDIT to work correctly, the transfer program
must write to DOS standard output.

- 55 -
You can use any $CAP MSG(filter): Captures program output into the
program that has Message window, using filter as a DOS filter for
line-oriented converting program output into Message window format.
messages output
(file and line We've provided several filters for this macro:
number) with this GREP2MSG.EXE for GREP and TASM2MSG.EXE for Turbo
macro. Assembler (TASM). We've included the source code for
these filters so you can write your own filters for
other transfer programs you install.
$COL: Column number of current editor. If the active
window is not an editor, then the string is set to 0.
$CONFIG: Complete file name of the current
configuration file. This is a null string if no
configuration file is defined. This macro is intended
for use by programs that access or modify the
configuration file. Besides providing the name of the
file, this macro causes the current configuration to be
saved (if modified) and reloaded when control returns
to the IDE.
TEML is a Pascal- Use this macro with the Turbo Editor Macro Language
like language that (TEML) compiler. With it, you can edit the TEML script
has many built-in file in an editor and then invoke the Turbo Editor
primitive editor Macro Compiler (TEMC) to process the script. When the
commands. Its use configuration file is reloaded, your new or modified
is documented in editor commands will be in effect. When installing TEMC
this file. as a transfer item, use the following command line:
$EDNAME $CONFIG
This assumes the current Edit window contains the TEML
script file to be processed.
$DEF: Pulls in the contents of the Options|Compiler|
Code Generation "Defines" type-in box. Use this macro
to specify define directives to an external translator.
This macro is only $DEP(): This macro provides the ability to
used by the automatically rebuild resources as part of a project
project manager. make if one of the resource components has been
modified.
$DIR(): Directory of the file argument, full path.
$DRIVE(): Drive of the file argument, in the form D:.

- 56 -
$EDNAME: Complete file name of file in active editor.
This is a null string if the active window is not an
editor.
$ERRCOL: Column number of current error in file
$ERRNAME. If there are no messages, then string is
expanded to null string.
$ERRLINE: Line number of current error in file
$ERRNAME. If there are no messages, then string is
expanded to null string.
$ERRNAME: Complete file name of file referred to by the
selected messages in the Message window. This is a null
string if there are no messages or the currently
selected message does not refer to a file.
$EXENAME: Program's file name (including output path),
based on the project name or, if there is no project
defined, then the name of the .EXE that would be
produced from the active editor window.
$EXT(): Extension of the file argument; this includes
the dot (for example, .CPP).
$INC: Pulls in the contents of the Options|Directories|
Include Directories type-in box.
$LIB: Pulls in the contents of the Options|Directories|
Library Directories type-in box.
$LINE: Line number of current editor. If the active
window is not an editor, then the string is set to 0.
$MEM(Kb to reserve): This macro tells the IDE how much
memory to try to give the transfer program. The IDE
gives up as much memory as possible, to either the
amount specified or the maximum available, whichever is
smaller. You'll get an error if no memory is specified.
$NAME(): Name part of the file argument; does not
include the dot.
$NOSWAP: This macro tells the IDE not to swap to the
User Screen when running the program. It pops up a box
that indicates which transfer program is running. Use
this macro in conjunction with $CAP.

- 57 -
$OUTNAME: This macro expands to the path and file name
that appear in the Project|Local Options Output Path
type-in box (in the active edit window). For example,
if the project contains STARS.C, the default Output
Path type-in is STARS.OBJ. So if STARS.C is in the
active edit window, $OUTNAME expands to STARS.OBJ. If
you've edited the type-in box so it says ..\MOON.XYZ,
$OUTNAME will expand to ..\MOON.XYZ. This macro is
useful when you are specifying modules for your user-
defined translators. For example, you could define a
TLIB translator and set the command line to
TLIB MYLIB +$OUTNAME
which adds the object module of the file in the active
edit window to the library MYLIB.
$PRJNAME: The current project file. Null string if no
project is defined.
$PROMPT: This macro tells the IDE to display the
expanded parameter string before calling the transfer
program. The command line that will be passed is
displayed in a dialog box. This allows you to change or
add to the string before it is passed.The position of
$PROMPT command in the command line determines what is
shown in the dialog prompt box. You can place constant
parameters in the command line by placing them before
$PROMPT. For example, the /c in
/c $PROMPT dir
is constant and doesn't show in the dialog box, but dir
can be edited before the command is run.
$SAVE ALL: This macro tells the IDE to save all
modified files in all Edit windows that have been
modified, without prompting.
$SAVE CUR: This macro tells the IDE to save the file in
the current editor if it has been modified. This
ensures that the invoked program will use the latest
version of the source file.
$SAVE PROMPT: This macro tells the IDE to prompt when
there are unsaved files in editor windows. You will be
asked if you want to save any unsaved files.

- 58 -
$TASM: This macro is predefined for use with Turbo
Assembler. It uses the TASM2MSG filter to trap TASM
messages. $TASM is essentially shorthand for this:
$NOSWAP $SAVE CUR $CAP MSG(TASM2MSG) $EDNAME,$OUTNAME
$WRITEMSG(filename): This macro copies the contents of
the Message window to the specified ASCII file. The
translator can parse the file and act on the messages
so desired. For example, $WRITEMSG(C:\MESSAGES.TXT)
writes to the file MESSAGES.TXT on your root directory.

Running DOS =======================================================


commands
If you want to run DOS commands from within the
integrated environment, you can set up a simple
transfer macro that will let you do so. Just add this
transfer item:
command /c $MEM(128) $PROMPT
When you invoke this transfer item, a dialog box
appears and prompts you for DOS input. Since the
$PROMPT command appears later in the string, the text
command /c won't show up in the dialog's input box.
This lets you just type dir, chkdsk, del *.*, or
whatever DOS command you want to run.

Transfer memory =======================================================


settings
Different programs have different memory needs. For
example, GREP can run in very little memory, where many
popular editors require 200-300K to work well.
If you use the $MEM() macro, you can specify (on a
program-by-program basis) how much memory the IDE
should give to the transfer programs. The less memory
you devote to a transfer program, the quicker the
transfer to and from the program occurs.
There may be some cases where the IDE cannot give up as
much memory as you requested. When this happens, the
IDE gives up as much as it can. There are certain
states in the IDE that require more memory than others;
for example, while debugging a program, the IDE will

- 59 -
tie up more resources than when not debugging. Use
Program Reset (Ctrl-F2) to free up debugging memory.
In those cases where you want the IDE to give up all
its memory, give it a large number, like 640K. How much
memory is actually given up is dependent on how much
you have when you start Turbo C++.

===========================================================================
Turbo Editor macros
===========================================================================
TEMC.EXE is an editor macro compiler for the IDE. It
processes a script file that defines editor macros and
key bindings, and produces a configuration file that is
read by the IDE to define the effects of keyboard
commands in the editor.
The file DEFAULTS.TEM contains the default macro
definitions and key bindings built into the IDE editor.
It serves as an example script, as well as a base from
which to customize the editor.

===========================================================================
TEMC command line
===========================================================================
TEMC is invoked from the DOS command line. Type
temc [-c] [-u] <script file> <config file>
The script file extension is .TEM if not specified
otherwise. The configuration file extensions is assumed
to be .TC.
The configuration file need not exist. If it does not
exist, it is created. The optional -c switch can also
be specified as /c, and can appear in any argument
position on the command line. If you use this option,
any existing command table in your configuration file
is thrown away before TEMC processes the script file.
When -c is not used, the key bindings in the script
file are merged with those already defined in the
configuration file.

- 60 -
TEMC by default modifies the commands used by the IDE
when the Alternate command set is specified in Options|
Environment|Preferences. The optional -u switch, which
can also be specified as /u, causes TEMC to modify the
CUA command set instead.
You can use DEFAULTS.TEM to re-create exactly the
default settings of the Alternate command set. This
file is included as both a sample script file and as
the default command table. You can copy it and modify
it for your own use. A file named CMACROS.TEM is
provided with Turbo C++; this file contains many useful
enhancements to the IDE for C and C++ programming that
you may wish to install.

===========================================================================
Syntax
===========================================================================
The syntax to define a macro is
MACRO <macroname>
<command1>;
[ <command2>; ... ]
END;
<macroname> can consist of anything that is a legal C
symbol, and <command> can be either the name of another
predefined macro or a predefined TEMC editor command. A
list of editor commands and what they do follows.
When you define your macro, the following points are
valid:
1. A statement defines either a named macro or a key
binding.
2. Spaces and new lines are optional.
3. Comments are in C-style /* ... */ pairs.
4. Unlike C, TEMC's language is case insensitive.
5. Some of the predefined editor commands have a syntax
that looks like a C function call with one argument.
For example,

- 61 -
SetMark(5);
Depending on the command, the argumment is either a
decimal integer constant, a character constant, or a
string literal. All are specified using C syntax.
Here's an example of a macro definition from
DEFAULTS.TEM:
MACRO MacScrollUp
ScrollScreenUp; FixCursorPos;
END;
The syntax to define a key binding is
<key-sequence>: <command>;
or
<key-sequence>: BEGIN <command1>; [ <command2>; ... ]
END;
The <key-sequence> is either a key (a character
optionally preceded by Ctrl or Alt), or a series of
keys separated by a plus sign (+). Note that the
specification of the key characters themselves is case
sensitive. For example, Ctrl-k+B is different than
Ctrl-k+b, even though the latter is the same as CTRL-
K+b.
Whitespace is allowed between the key-sequence and the
colon, and each <command> can be either the name of a
previously defined macro, or one of the predefined
editor commands listed in Table 1.1.

===========================================================================
Key codes
===========================================================================
The IDE editor makes use of an extended character set
that includes key combinations not normally available
to DOS programs. Key codes can be specified in a script
through any combination of the symbols "Ctrl-",
"Shift-" "Alt-" and a character.

- 62 -
Some keys cannot be entered directly into a TEMC
script. Those keys can be referred to by their names,
as described in the following table.
Any key in a sequence--except the first key--can be
preceded by one of the characters ^ or @. The caret (^)
indicates that any combination of case and "Ctrl" can
be used to type the key; that is, lowercase, uppercase,
or control characters. The @ sign is used to indicate
that case is insignificant for the following character,
although "Ctrl" is not accepted. For example,
o Ctrl-k+b specifies a Ctrl-K followed by a lowercase
b.
o Ctrl-k+^b specifies a Ctrl-K followed by any of b, B,
or Ctrl-B.
o Ctrl-k+@B specifies Ctrl-K followed by either b or B.

Named keys =======================================================


Key are specified as letters, numbers, or characters,
optionally preceded by one or more of Ctrl-, Alt- or
Shift-. The following names specify keys that cannot be
typed as themselves in the TEMC syntax.

-------------------------------------------------------
Key name Notes
-------------------------------------------------------
Home
End
PgUp
PgDn
LfAr Left arrow
RgAr Right arrow
UpAr Up arrow
DnAr Down arrow
Ins
Del
Enter
Return Same as Enter
BkSp Backspace
Tab
BkTab No longer available, use Shift-Tab

- 63 -
Esc
Star * key on the numeric keypad
Minus - key on the numeric keypad
Plus + key on the numeric keypad
Space Spacebar
PrtSc
F1 to F10 Function keys
-------------------------------------------------------

===========================================================================
Predefined editor commands
===========================================================================
TEMC lets you use built-in editor commands and user-
defined macros as commands within macros
interchangeably, as long as you don't create any loops
by having two macros calling each other, even via
intermediate macros. Note that some commands cause an
escape from the editor to the surrounding IDE, for
example, by bringing up a dialog box. Your macro will
"pause" until control returns to the editor.
A list of all predefined TEMC editor commands is shown
next. Commands that cause an escape from the editor
follow.

-------------------------------------------------------
TEMC editor Command name What the editor does
commands -------------------------------------------------------
BackspaceDelete Deletes character before
the cursor.
BottomOfScreen Moves cursor to the bottom
line of the current window,
leaving column unchanged.
CenterFixScreenPos Adjusts the screen display
to ensure the cursor is
visible. If any adjustment
is necessary, adjust the
display so the cursor is

- 64 -
Table 1.4: TEMC editor commands (continued)____________
close to being centered in
the window.
CopyBlock If there is a valid and
highlighted (selected)
text block, then at the
cursor location, inserts a
copy of the characters that
are selected and makes that
the new selected text
location.
CursorCharLeft Moves cursor left over one
character. This command
will skip over tab
characters and move to the
end of the previous line.
CursorCharRight Moves cursor right over one
character. This command
will skip over tab
characters and advance to
the beginning of the next
line.
CursorDown Moves cursor down one row.
CursorLeft Moves cursor left one
screen column.
CursorRight Moves cursor right one
screen column.
CursorSwitchedLeft Like CursorLeft, but pays
attention to cursor through
tab option setting (see
SetCursorThroughTabMode).
CursorSwitchedRight Like CursorRight, but pays
attention to cursor
through tab option setting
(see
SetCursorThroughTabMode).
CursorUp Moves cursor up one row.

- 65 -
Table 1.4: TEMC editor commands (continued)____________
DeleteBlock If there is a valid and
highlighted (selected) text
block, deletes the
characters that are in it.
DeleteChar Deletes the character at
the current cursor
location.
DeleteLine Deletes the current line.
DeleteToEOL Deletes all characters in
the current line, leaving a
zero-length line.
DeleteWord Deletes from cursor to
beginning of next word.
EndCursor Moves cursor to end of file
buffer.
ExtendBlockBeg Initiates a series of
commands that will select a
block of text between the
initial and ending
positions of the cursor.
ExtendBlockEnd Ends a series of commands
begun by ExtendBlockBeg.
FixCursorPos Ensures that the cursor
value specifies a row
between 1 and the number of
lines in the buffer, a
column greater than 0. If
the cursor through tab
option is not set, the
cursor is not placed in the
middle of a tab character
(see
SetCursorThroughTabMode).
FixScreenPos Adjusts the screen display
to ensure the cursor is
visible.

- 66 -
Table 1.4: TEMC editor commands (continued)____________
FullPaintScreen Redraws the entire window,
making no assumptions about
what is onscreen.
HideBlock Sets a flag indicating that
the selected text should
not be highlighted.
HighlightBlock Sets a flag indicating that
if the beginning and end
selected text markers are
valid, the selected text
should be highlighted.
HomeCursor Moves cursor to beginning
of the file buffer.
IndentBlock Inserts a space at the
beginning of each line in
the highlighted (selected)
text.
InsertText Inserts the literal
"string" in the buffer at
the current cursor
location. Use the syntax
InsertText(string) to call
this command.
LeftOfLine Moves cursor to beginning
of the current line.
LiteralChar Inserts the character at
the current cursor
location, without doing any
special processing for
newline, tab characters,
etc. Use the syntax
LiteralChar(c), where c is
a character or integer
value.
MarkBufModified Sets a flag indicating that
the contents of the buffer
are different than what is

- 67 -
Table 1.4: TEMC editor commands (continued)____________
in the corresponding disk
file.
MarkBufUnModified Clears a flag, thus
indicating that the
contents of the buffer can
be assumed to be identical
to what is in the disk
file.
MatchPairBackward Same as MatchPairForward
except if the cursor is on
a ' or ", searches backward
for the matching character.
MatchPairForward If the cursor is on one of
the characters (, ), {, },
[, ], or on the first
character of one of the
pairs /* or */, searches in
the appropriate direction
for the closest instance of
the matching delimiter. If
the cursor is on the
character ' or ", searches
forward for the matching
character. If a match is
found, places the cursor
there.
MoveBlock Like CopyBlock, but also
deletes the original
selected text.
MoveToBlockBeg Moves cursor to the
location marked as the
beginning of the selected
text.
MoveToBlockEnd Moves cursor to the
location marked as the end
of the selected text.
MoveToMark Moves the cursor to the
location saved with
SetMark(n) command. Use the

- 68 -
Table 1.4: TEMC editor commands (continued)____________
syntax MoveToMark(n), where
n is a one-digit number,
0-9.
MoveToPrevPos Moves the cursor to the
location specified by the
"previous position marker."
MoveToTempPos Moves the cursor to the
saved temporary marker.
NullCmd No operation. Calls the
editor, but performs no
function. Can be used to
cause a keystroke to have
no effect.
OutdentBlock Deletes a leading space, if
any, from the beginning of
each line in the
highlighted (selected)
text.
PageDown Moves cursor down by number
of lines in the window.
PageScreenDown Scrolls screen down by
numer of lines in the
window, leaving cursor
position unchanged.
PageScreenUp Scrolls screen up by numer
of lines in the window,
leaving cursor position
unchanged.
PageUp Moves cursor up by number
of lines in the window.
PaintScreen Redraws the entire window,
assuming that the screen
still correctly displays
what the editor last drew
on it.

- 69 -
Table 1.4: TEMC editor commands (continued)____________
ReDo Performs an Redo operation.
Exactly what happens
depends on the option
settings.
RightOfLine Moves cursor to end of
current line.
RightOfWord Moves cursor to the next
column that follows the end
of a word.
ScrollScreenDown Scrolls screen down one
line, leaving cursor
position unchanged.
ScrollScreenUp Scrolls screen up one line,
leaving cursor position
unchanged.
SetAutoIndent Sets the Auto Indent option
On.
SetAutoOutdent Sets the Backspace
Unindents option On.
SetBlockBeg Sets the beginning of the
selected text to be the
character at the current
cursor location.
SetBlockEnd Sets the end of the
selected text to be the
character at the current
cursor location.
SetCursorThroughTabMode Sets the Cursor Through
Tabs option On.
SetInsertMode Sets Insert/Overwrite
option to Insert.
SetMark Sets a marker to point to
the character at the
current cursor location, so
a later MoveToMark(n)

- 70 -
Table 1.4: TEMC editor commands (continued)____________
comand can restore the
cursor. Use the syntax
SetMark(n), where n is a
one digit number, 0-9.
SetOptimalFillMode Sets Optimal Fill option
On.
SetPrevPos Sets a marker (the previous
position marker) to point
to the character at the
current cursor location.
This marker location
changes only by a call to
SetPrevPos or SwapPrevPos.
SetTabbingMode Sets Use Tab Char option
On.
SetTempPos Saves the cursor location
in a temporary marker that
can be used by some
internal editor commands.
This is not a practical
application in user-defined
macros. Use SetMark
instead.
SmartRefreshScreen Redraws the window,
skipping any portions that
the editor is sure are
unmodified since the last
redraw.
SmartTab Inserts space or tab
characters in accordance
with the current settings
of the Use Tab Char option,
Tab Width.
SwapPrevPos Exchanges the values of the
cursor and the "previous
position marker."
ToggleAutoIndent Toggles the state of the
Auto Indent option.

- 71 -
Table 1.4: TEMC editor commands (continued)____________
ToggleAutoOutdent Toggles the state of the
Backspace Unindents option.
ToggleCursorThroughTabMode Toggles the state of the
Cursor Through Tabs option.
ToggleHideBlock Toggles the state of the
highlight (selected) text
flag (see HighlightBlock).
ToggleInsert Toggles state of
Insert/Overwrite option.
ToggleOptimalFillMode Toggles state of Optimal
Fill option.
ToggleTabbingMode Toggles state of Use Tab
Char option.
TopOfScreen Moves cursor to the top
line currently displayed in
the window, leaving column
unchanged.
UnDo Performs an Undo operation.
Exactly what happens
depends on the option
settings.
WordLeft Moves cursor to beginning
of previous word, or to end
of previous line, whichever
is first.
WordRight Moves cursor to beginning
of next word, or to the end
of a line, whichever is
first.
-------------------------------------------------------

The following commands cause an exit from the editor,


for example, by bringing up a dialog box. The macro
resumes when the editor window regains the focus.

- 72 -
The keys listed next to some of the commands below are
the ones used by default when the Alternate mode of the
IDE is selected.
AddWatch Adds a watch item (Ctrl-F7).
ChangeDirectory Opens a dialog box for changing the
current directory.
ChangeModeFlags Used after a command such as
ToggleInsert which changes the
state of an editor option switch.
Causes the IDE to update various
menu items and/or icons.
ClipCopy Copys selected text to Clipboard
(Ctrl-Ins).
ClipCut Cuts selected text to Clipboard
(Shift-Del).
ClipPaste Pastes Clipboard into buffer at
cursor (Shift-Ins).
ClipShow Shows Clipboard (no hot key
defined).
CloseWindow Closes editor window (Alt-F3).
CompileFile Compiles current buffer (Alt-F9).
CompileMenu Selects Compile menu (Alt-C).
CompilerOptions Selects the Options Compiler menu
DebugMenu Selects Debug menu (Alt-D).
EditMenu elects Edit menu (Alt-E).
FileMenu Selects File menu (Alt-F).
GetFindString Opens a dialog box for the Search
operation. (Alt-S F)
GotoWindow1 Selects window #1 (Alt-1).
GotoWindow2 Selects window #2 (Alt-2).
GotoWindow3 Selects window #3 (Alt-3).
GotoWindow4 Selects window #4 (Alt-4).
GotoWindow5 Selects window #5 (Alt-5).
GotoWindow6 Selects window #6 (Alt-6).
GotoWindow7 Selects window #7 (Alt-7).
GotoWindow8 Selects window #8 (Alt-8).
GotoWindow9 Selects window #9 (Alt-9).
Help Opens the Help window (F1).
HelpMenu Selects Help menu (Alt-H).
HelpIndex Display the Help system't index
(Shift-F1)
Inspect Inspects item (Alt-F4).
LastHelp Opens previous help window (Alt-
F1).
MakeProject Makes project (F9).
Menu Highlights top menu bar.

- 73 -
Modify Evaluates expression/modify
variable (Ctrl-F4).
NextError Moves to next item in message
window (Alt-F8).
NextWindow Selects next window in IDE (F6).
OpenFile Opens dialog box for File Open
(F3).
OptionsMenu Selects Options menu (Alt-O).
PrevError Moves to previous item in message
window (Alt-F7).
PrintBlock Writes selected text to the
printer.
ProjectMenu Selects Project menu (Alt-P).
Quit Exits the IDE (Alt-X).
ReadBlock Opens dialog box requesting a file
name to be read into the buffer at
the cursor location and marked as
selected text.
RepeatSearch Searches again, using previous
parameters.
Replace Opens an dialog box for the Replace
operation.
ResetProgram Resets program being debugged
(Ctrl-F2).
RunMenu Selects Run menu (Alt-R).
RunProgram Makes and runs current executable
(Ctrl-F9).
RunToHere Runs program until statement at
cursor (F4).
SaveFile Saves current editor buffer (F2).
SaveFileAs Opens dialog for File SaveAs.
SearchMenu Selects Search menu (Alt-S).
Step Step over (F8).
SystemMenu Selects Sytem menu (Alt-Spacebar).
ToggleBreakpoint Sets/Clears a breakpoint at the
cursor location
Trace Trace into (F7).
Transfer0 Selects nth item from transfer menu
Transfer1 .
Transfer2 .
Transfer3 .
Transfer4 .
Transfer5 .
Transfer6 .
Transfer7 .
Transfer8 .
Transfer9 .
ViewCallStack Views Call Stack (Ctrl-F3).

- 74 -
ViewUserScreen Displays User Screen (Alt-F5).
WindowList Displays window list (Alt-0).
WindowMenu Selects Window menu (Alt-W).
WindowCascade
WindowTile
WordHelp Context sensitive help (Ctrl-F1).
WriteBlock Opens dialog box requesting a file
name to which the selected text
will be written.
ZoomWindow Zooms/unzoomd current window (F5).

- 75 -
- 76 -
INDEX
___________________________________________________________________________

- + and + - (TLIB action symbols) /C THELP option (select color) 39,


48 40
[ ] GREP operator 17 /C TLIB option (case sensitivity)
/? THELP help option 40, 42 45, 50
-* and ** (TLIB action symbols) 47 $CAP EDIT transfer macro 55
* (TLIB action symbol) 47 $CAP MSG transfer macro 55
+ (TLIB action symbol) 47 case sensitivity
- (TLIB action symbol) 47 GREP option 14
$ GREP operator 17 TLIB option 45, 50
* GREP operator 17 characters
+ GREP operator 17 trigraph
. GREP operator 17 converting 53
\ GREP operator 17 $COL transfer macro 56
^ GREP operator 17 columns
? THELP option 40, 42 numbers 56
command line
syntax
A CPP 10
add (TLIB action symbol) 47 compilers
Turbo editor macro 56
$CONFIG transfer macro 56
B configuration files 56
BGIOBJ 2-10 TCC file 10
advanced features 6 CPP and 10
command-line syntax 3, 6 conversion
components 6 trigraphs 53
example 4 CPP 10-12
graphics.h and 8 command-line options and syntax
options 10
destination file 7 directory 10
/F 6 example of use 11
file name 6 files
file name (/F) 5 compiling 11
public name 7 -P option (source file names and
segment class 7 line numbers) 11
segment name 7 wildcards and 10
source file 7
D
C -d GREP option (directories) 14
-c GREP option (count only) 14 /D OBJXREF option (directory) 24

Index 77
debugging extended dictionary
include files 10 TLIB and 45, 49
macros 10 extract and remove (TLIB action) 47
$DEF transfer macro 56
Defines option
transfer macro 56 F
$DEP transfer macro 56 /F BGIOBJ option 6
dependencies /F BGIOBJ option (far routines) 5
explicit 56 /F OBJXREF option (include full
$DIR transfer macro 56 library) 25
directories /F THELP option 41
CPP 10 /F THELP option (Help file path and
GREP option 14 name) 40
include files files
transfer macro 57 dates
libraries changing 51
transfer macro 57 destination
.OBJ files 24 BGIOBJ 7
transfer macro 56 extensions 57
DLLs linker response, used by OBJXREF
creating 57 28, 33
DOS macros
commands expanded 10
running from the IDE 59 matching
$DRIVE transfer macro 56 GREP option 14
names
macros
E transfer 54
/E TLIB option (extended printing (GREP) 15
dictionary) 45, 49 output, generated by OBJXREF 25
editor path
macro language (TEML) macros 56
using 56 saving
$EDNAME transfer macro 56 all 58
$ERRCOL transfer macro 57 searching 12-22
$ERRLINE transfer macro 57 source
$ERRNAME transfer macro 57 BGIOBJ 7
errors filters 55
linker GREP 56
graphics drivers and fonts 5 Resource Compiler 56
OBJXREF (list) 34 TASM 56
examples fonts
OBJXREF 28-33 adding to graphics library 3
.EXE files files, converting to .OBJ files 2
file name transfer macro 57 included with Turbo C++ 4
$EXENAME transfer macro 57 linker errors and 5
$EXT transfer macro 57 linking 2-10
registering 3, 8

- 78 -
stroked 2-10 white space in 18
linking 2 using 13
wildcards and 18
GREP.COM 16
G GREP2MSG.EXE 56
graphics drivers
adding to graphics library 3
converting to .OBJ files 2, 2-10 H
included with Turbo C++ 4 /H THELP option (help) 40, 42
linker header files
errors and 5 graphics.h 8
linking 2 help
registering 3, 8 GREP (file searcher) 13
graphics.h (header file) OBJXREF 23
BGIOBJ and 8 THELP 40, 42
GRAPHICS.LIB hot keys
adding to 3 scan codes 42
GREP (file searcher) 12-22
capturing messages 56
examples 18 I
files to search 18 -i GREP option (case sensitivity)
help 13 14
literal character 17 /I OBJXREF option (case
matches 17 sensitivity) 24
operators 17 $INC transfer macro 57
optimizing use of 16 include files
options debugging 10
case sensitivity (-i) 14 directories
count only (-c) 14 transfer macro 57
default 15, 16 integrated environment
discussion 13 DOS commands and 59
file names (printing) 15 memory needs 59
-i (case sensitivity) 14
line numbers (-n) 14
lines, nonmatching (-v) 15 K
list matching files (-l) 14 /K THELP option (change hot key)
-n (line numbers) 14 40, 42
-o (UNIX output format) 14 keyboard
precedence 16 trigraph program 53
regular expression search (-r)
14
UNIX format (-o) 14 L
updating (-u) 15 -l GREP option (list matching
-v 15 files) 14
-v (nonmatching lines) 15 /L OBJXREF command (linker response
verbose 15 file) 28
word search (-w) 15 $LIB transfer macro 57
search strings 16 libname (TLIB option) 45

Index 79
libraries column number 57
directories file name 57
transfer macro 57 line number 57
files 22 module names, TLIB 46
contents of 22
graphics
adding driver and font files to N
3 -n command-line compiler option
object files 43, 44 CPP and 10
creating 47 -n GREP option (line numbers) 14
OBJXREF /N OBJXREF option (limit reports)
including all 25 26
page size 49 $NAME transfer macro 57
$LINE transfer macro 57 $NOSWAP transfer macro 57
lines numbers
numbering 57 column 56
printing (GREP) 14 line 57
linker
error: segment exceeds 64K 5
response files O
used by OBJXREF 28, 33 -o GREP option (UNIX format output)
linking 14
graphics drivers 2 /O OBJXREF option (output file for
listfile (TLIB option) 45 reports) 25
.OBJ files
converting font files into 2
M converting graphics drivers files
macros into 2
CPP and 11 defined 22
debugging 10 directories 24
editor 56 libraries
expanded advantages of using 44
list of 10 creating 47
preprocessing 11 TLIB and 43
preprocessor 10 names 22
MAKE (program manager) response files and 27
modifying 51 object modules
project files and 36 defined 22
$MEM transfer macro 57, 59 names 22
memory OBJXREF 22-34
requirements directories 24
IDE 59 error messages 34
transfer programs 57, 59 examples of reports 29, 30, 31,
Message window 32
capturing output into 55 help 23
copying text from 59 /L command (linker response
messages files) 28
capturing from programs 55

- 80 -
linker files wildcards and 23
as response files 28 operations (TLIB option) 45
options 23 operators
/N (limit information) 26 GREP 17
/RV 26 $OUTNAME transfer macro 57
/RC 31 output
control 24 capturing 55
directories (/D) 24 output file
/F (include full library) 25 generated by OBJXREF 25
ignore case (/I) 24
include full library (/F) 25
include zero-length segment P
definitions (/Z) 25 -P CPP option (source file names
list file names (/V) 25 and line numbers) 11
modified reports 26 /P OBJXREF command (project files)
/O (output file) 25 27
reports 25 /P TLIB option (page size) 49
by class type page size (libraries) 49
example 33 path
by class type (/RC) 26, 31 transfer macro 57
by external reference (/RX) precedence
26, 30 GREP options 16
by module (/RM) 26, 29 TLIB commands 46
by public names (/RP) 26, 29 PRJ2MAK (project file converter) 36
by reference (/RR) 26, 30, 33 PRJCNVT (project file converter) 35
default type 33 $PRJNAME transfer macro 58
of all types (/RV) 26 programs
of module sizes (/RS) 26, 31 capturing output 55
of unreferenced symbol names file name 57
(/RU) 26, 32 memory assignments 59
output file (/O) 25 project files
verbose OBJXREF and 27
example 33 used by OBJXREF 33
verbose (/RV) 26, 32 projects
/V (verbose output) 25 files
verbose report (/RV) 32 converting from old versions 35
/Z (include zero-length segment converting to MAKE files 36
definitions) 25 file name transfer macro 58
project files $PROMPT transfer macro 58
as response files 27 public names
project files (/P) 27 defined 22
reports 23
modifying 26
output file for (/O) 25 R
response files 23, 27 -r GREP option (regular expression
example 33 search) 14
linker 28 /RC OBJXREF option (report) 31
warnings 34 /RC OBJXREF option (reports) 26

Index 81
redirecting program output 55 in text files 12-22
registerbgidriver (function) swapping
BGIOBJ and 3, 8 to User Screen 57
registerbgifont (function) syntax
BGIOBJ and 3, 8 CPP 10
registerfarbgidriver (function) TLIB 44
BGIOBJ and 6, 8
registerfarbgifont (function)
BGIOBJ and 6, 8 T
remove (TLIB action) 47 TASM2MSG.EXE 56
replace (TLIB action) 48 $TASM transfer macro 58
Resource Compiler text
capturing messages 56 Message window 59
resources text files
rebuilding automatically 56 searching 12-22
response files THELP (Turbo Help utility) 37-43
file-name extensions and 27 additional Help on highlighted
formats 27 word 39
free-form 27 cursor keys 38
example 33 index 39
linker files and 28 invoking 37
OBJXREF and 23, 27, 28 keywords 38
example 33 loading 37
project files and 27 options 39-43
TLIB 48 colors (/C) 40
TLINK, OBJXREF and 33 colors (/C) 39
/RM OBJXREF option (reports) 26 Help file path (/F) 40
/RP OBJXREF option (reports) 26 help file path (/F) 41
/RR OBJXREF option (reports) 26 help on (/?
/RS OBJXREF option (reports) 26 /H
/RU OBJXREF option (reports) 26 ?) 40, 42
/RV OBJXREF option (reports) 26 Help screen colors (/C) 39
/RX OBJXREF option (reports) 26 help screen colors (/C) 40
hot keys (/K) 40, 42
reassign hot keys (/K) 40, 42
S removing THELP (/U) 40, 43
$SAVE ALL transfer macro 58 screen colors (/C) 39, 40
$SAVE CUR transfer macro 58 /U (removing THELP) 40, 43
$SAVE PROMPT transfer macro 58 /W (window options) 40
scan codes 42 window options 43
searches window options (/W) 40
text files 12-22 paging through 38
source files paste page 39
separately compiled 44 previous screens 39
standalone utilities 1 quitting 39
strings removing from memory 40, 43
searching for scan codes 42
as expressions (GREP) 14 using 38

- 82 -
TLIB (librarian) 43-51 $INC 57
action symbols 46-48 instruction 55
capabilities 43 $LIB 57
examples 51 $LINE 57
extended dictionary (/e) $MEM 57
TLINK and 49 $NAME 57
module names 46 $NOSWAP 57
operations 46 $OUTNAME 57
precedence 46 $PRJNAME 58
options $PROMPT 58
case sensitivity (/c) 45, 50 $SAVE ALL 58
/E 45, 49 $SAVE CUR 58
extended dictionary (/e) 45, 49 $SAVE PROMPT 58
libname 45 $TASM 58
listfile 45 $WRITEMSG 59
operations 45 trigraphs
page size (/P) 49 translating 53
using 44 undo option (-u) 53
response files Turbo Assembler
using 48 capturing messages 56
syntax 44 $TASM macro 58
TLIB (Turbo librarian) 43-51 TURBOC.CFG 10
options 39-51
TLINK (linker)
response files U
OBJXREF and 28 -u GREP option (updating) 15
TLIB extended dictionary and 49 /U THELP option 43
TOUCH 51, 52 /U THELP option (remove THELP) 40
transfer macros UNIX
$CAP EDIT 55 format (GREP) 14
$CAP MSG 55 User Screen 57
$COL 56 utilities
$CONFIG 56 standalone 1
$DEF 56 TLIB 43-51
defined 54 TOUCH 51
$DEP 56
$DIR 56
DOS commands 59 V
$DRIVE 56 -v GREP option (nonmatching lines)
$EDNAME 56 15
$ERRCOL 57 /V OBJXREF option (verbose output)
$ERRLINE 57 25
$ERRNAME 57
$EXENAME 57
$EXT 57 W
file names 54 -w GREP option (word search) 15
glossary of 55 /W THELP option (ser window
how expanded 54 size/location) 40

Index 83
/W THELP option (window options) 43 Z
wildcards -z GREP option (verbose) 15
CPP and 10 /Z OBJXREF option (include zero-
OBJXREF and 23 length segment definitions) 25
TOUCH and 52
$WRITEMSG transfer macro 59

- 84 -