home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Shareware Overload
/
ShartewareOverload.cdr
/
database
/
snap312.zip
/
SNAP.DOC
< prev
next >
Wrap
Text File
|
1988-05-23
|
131KB
|
3,896 lines
SNAP!
Documentation and Development System
for dBASE III, dBASE II, Clipper, FoxBASE
and Similar Systems
Written by Walter J. Kennamer 74025,514
-----------------------------------------------------------------------
License
Copyright (c) 1986, 1987, 1988 Walter J. Kennamer.
All Rights Reserved.
You are free to use, copy and distribute SNAP! providing that:
NO FEE IS CHARGED FOR USE, COPYING OR DISTRIBUTION.
IT IS NOT MODIFIED IN ANY WAY.
THIS DOCUMENTATION FILE (UNMODIFIED) ACCOMPANIES ALL COPIES.
This program is provided AS IS without any warranty, expressed or
implied, including but not limited to fitness for a particular purpose.
dBASE II and dBASE III are trademarks of Ashton-Tate. Clipper is a
trademark of Nantucket Software. FoxBASE and FoxBASE+ are trademarks
of Fox Software, Inc. UNIX is a trademark of AT&T. "Tom Rettig's
Library" is probably a trademark of Tom Rettig Associates.
1
Table of Contents
Overview 3
Getting Started 4
Basic Operation . . . . . . . . . . . . . . . . . . . . . . . 4
A Tour of the SNAP! Screens . . . . . . . . . . . . . . . . . 5
Author and Copyright Holder . . . . . . . . . . . . . . . . . 5
Paths . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Saving and Restoring Default Choices . . . . . . . . . . . . 6
Abbreviations . . . . . . . . . . . . . . . . . . . . . . . . 7
Status Reports . . . . . . . . . . . . . . . . . . . . . . . 7
Searching the Program Tree . . . . . . . . . . . . . . . . . 8
Ignoring Drive Designations . . . . . . . . . . . . . . . . . 8
SNAP! Commands 10
Macros . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
SNAPCODE--Fake Program Statements . . . . . . . . . . . . . . 12
Other SNAP! Directives . . . . . . . . . . . . . . . . . . . 12
Source Code Formatting Options 14
File Headings . . . . . . . . . . . . . . . . . . . . . . . . 14
Indentation . . . . . . . . . . . . . . . . . . . . . . . . . 15
Capitalization . . . . . . . . . . . . . . . . . . . . . . . 15
Key Word Expansion and Compression . . . . . . . . . . . . . 16
Suppressing Blank Lines and Comments . . . . . . . . . . . . 17
Key Words File . . . . . . . . . . . . . . . . . . . . . . . 17
Reports and Outputs 19
Tree Structure Diagram . . . . . . . . . . . . . . . . . . . 19
File List . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Data Dictionary . . . . . . . . . . . . . . . . . . . . . . . 20
Index File Summary . . . . . . . . . . . . . . . . . . . . . 21
Format File Summary . . . . . . . . . . . . . . . . . . . . . 22
Report Form Summary . . . . . . . . . . . . . . . . . . . . . 22
Procedure File Summary . . . . . . . . . . . . . . . . . . . 23
Variable Cross-Reference Report . . . . . . . . . . . . . . . 23
LNK and MAKE files . . . . . . . . . . . . . . . . . . . . . 26
Batch Files . . . . . . . . . . . . . . . . . . . . . . . . . 27
Action Diagrams . . . . . . . . . . . . . . . . . . . . . . . 28
Source Code Printout . . . . . . . . . . . . . . . . . . . . 31
Printing Without Documenting . . . . . . . . . . . . . . . . 32
Using SNAP! in a Batch Environment 33
Program Limitations 35
Continuation Lines . . . . . . . . . . . . . . . . . . . . . 36
Multiple Procedure Files . . . . . . . . . . . . . . . . . . 36
Change History 38
2
Some Administrative Matters 40
Version Numbers . . . . . . . . . . . . . . . . . . . . . . . 40
Updates and New Versions . . . . . . . . . . . . . . . . . . 40
How to Get Support . . . . . . . . . . . . . . . . . . . . . 40
Acknowledgements 40
Appendix A -- Sample Reports 41
Index 62
3
Overview
SNAP! makes documenting dBASE programs a snap. Written in Turbo Pascal, SN-
AP! is designed to produce technical documentation for an entire dBASE sys-
tem, including:
System summary showing lines of code, file statistics, etc.
Variable cross-reference report
Tree structure of the system. The tree optionally can also show
databases, index files, etc. used by each program.
List of all files in the system
Data dictionary
Index file summary
Format file summary
Label form summary
Report form summary
Procedure file summary
Link files for Clipper applications (either PLINK86, TLINK, MS-LINK)
Make file for Clipper applications
Formatted source code listings
Action diagrams
Batch files to back up programs, databases, etc.
Batch file to move SNAP! output files back to the source subdirectory
In addition, on each program file, SNAP! can write a heading showing:
Program name
System name
Author and copyright notice
Which files call this program
Which files this program calls
Databases used
Index files used
Formats used
Report forms used
Procedures
Memory files used
Date and time last modified
If you wish, all source code headings can also be echoed to a separate file.
Additionally, SNAP! can indent your source code and capitalize dBASE key
words to make your code easier to read, understand and maintain.
Unlike many other dBASE documentation systems, SNAP! documentation is
system-wide. In other words, not only can it tell you where variable X was
used in a particular program, it can cross-reference all occurrences of
variable X anywhere in the program system you are documenting. You merely
enter the "top" program file name, and SNAP! does the rest. Of course, you
may also document a single program if you wish.
3
Getting Started
First, make a backup copy of your program files. I have tried to test
SNAP! on a variety of hardware and software combinations, and there
shouldn't be any danger, but I would feel awful if anyone lost program files
due to some curious combination of resident programs, unusual equipment and
sunspot activity, not to mention (gasp!) "features." SNAP! has been around
for several years now and nobody has reported that SNAP! has ever corrupted
source code, but I would hate for you to be the first.
Basic Operation
SNAP! is very easy to use. If you accept the program's default options, you
only have to enter the following information on the TopFile screen:
"Top" file name
System name
Author
Paths for program, data, output and SNAP! files
If you are happy with the defaults, just enter the information on the first
screen (the System screen), press F10 to see the main menu, then press 'B'
to begin documenting your system.
The term "TopFile" (spelled and punctuated in a variety of ways) is used
throughout this documentation to mean the first file in a system--the one
first invoked.
You can press F10 to see the main menu. If you don't want to use the menu,
you can save a keystroke or two by using the Alt key in combination with the
menu choice you want. For example, without pressing F10 to pop up the menu,
you can press Alt-R to see the Reports Screen, Alt-B to Begin Documenting,
Alt-Q to quit, and so forth. Also, the Ctrl-PgUp and Ctrl-PgDn keys take
you to the preceding and succeeding screens, respectively.
The line at the bottom of the screen tells you which function keys are
active. At any point, you can press the F1 key to receive context-sensitive
help. Help is available for each field.
The SNAP! system is composed of the following files:
SNAP.EXE -- main program file
SNAP.HLP -- help file
SNAP.DOC -- this documentation file
DB2WORDS.SNP -- key word file for dBASE II/FoxBASE
DB3WORDS.SNP -- key word file for dBASE III/Clipper/FoxBASE+
All of these files must be in the same subdirectory, which may be different
than the subdirectory in which your dBASE source code files are stored.
4
A Tour of the SNAP! Screens
SNAP! has seven main screens on which you can select various combinations of
options:
System --contains system-level information (system name, author, top
file name, etc.)
Reports--determines which documentation reports will be generated
Format --determines source code formatting and action diagram options
in effect
Xref --determines what kinds of words will be in the cross-reference
Tree --determines what kinds of files will be shown on the tree
diagram
Print --determines source code printing parameters
Other --other options
The next sections highlight a few of the fields that may have hidden
mysteries.
Author and Copyright Holder
Enter the author and copyright holder in these fields. This information is
used only in the program headings, and may be omitted if you choose not to
write program headings (you make that choice on the Format screen). If you
enter either author or holder, but not both, the program assumes that they
are the same.
Paths
The TopFile menu screen has four fields for path information--the path to
the source code, data, output and SNAP! files. Your response should be a
valid MS-DOS path, with or without drive designation. It doesn't matter if
you omit the final backslash (e.g., C:\SNAP is valid, as is C:\SNAP\ or
\SNAP).
If the "Top" file you specify cannot be found, or if the SNAP! files are not
where you say they are, SNAP! complains and will not let you begin
documentation. If the output directory does not exist, SNAP! will create
it.
If your input and output paths are different, SNAP! will not modify your
original source code files in any way. Only the output files will contain
capitalized key words, indents, headings and so on.
On the other hand, if the source code and output paths are the same, SNAP!
adds .BAK extensions to your original input files and creates modified
output files with the original names. For example, if one of your input
programs was named EDIT.PRG, after running SNAP! it will be called EDIT.BAK
and a new, modified EDIT.PRG will be in the directory. This scheme works
fine as long as all your input files have unique names (not counting the
5
extension). Otherwise, all but the last non-unique input file will be lost
(though the modified output files will still be there). The best idea is
never to direct output to the input directory if the first eight characters
of all of your program files are not unique.
All of your source code files--including programs, format files, report
forms, memory files and so forth--must be in the same source directory for
SNAP! to find them. (Databases and indexes can be either in the data
directory or in the source code directory.) Even if the application runs
fine in multiple subdirectories under dBASE III, you still need to move all
program files into a single subdirectory for SNAP! If you use explicit
drive and path designations when you reference another file, SNAP! will find
it (as long as you have not told SNAP! to ignore drive designations--see
below), but it otherwise cannot tell which subdirectory is current. Note
that SNAP! pays no attention to "SET PATH TO" statements. SNAP! also cannot
handle macro substitutions for drives or paths.
SNAP! never modifies database, index, report form, label form or memory
files.
When SNAP! decides you are about to do something particularly dangerous, it
may require you to direct output files to a different directory than the
input files are in. Some "dangerous" options include expanding or
compressing key words and eliminating comments from source code.
Saving and Restoring Default Choices
As you use SNAP!, you may wish to modify the default values for certain
fields. For example, you may want to set the SNAP! path to \SNAP, or the
author and copyright holder to your name. Press F5 to save the current
values of each field. SNAP! will prompt you for a filename to use for the
configuration file.
When you start SNAP!, you can specify the file to use for default field
values. SNAP! assumes that the configuration file should be present in the
current directory when you invoked SNAP!. You can name another
configuration file by using the /F switch on the command line. For example,
the command:
SNAP /fc:\foo\bar.baz (note: no space between '/f' and the filename).
tells SNAP! to look for a configuration file named 'bar.baz' in the '\foo'
subdirectory on drive c:. If it cannot find it, SNAP! will start with
default values. When you save the configuration, SNAP! uses the name you
specified. If you do not specify a file, SNAP! looks for one called
CONFIG.SNP in the current directory. If the file you specify does not have
an extension, SNAP! assumes the extension is '.SNP'.
I ordinarily save a separate configuration file for each system I use in the
same subdirectory with the system. This is a big help for running SNAP! in
6
batch mode (see below) and for keeping subdirectories, filenames, etc.
straight.
You can also press F6 to retrieve saved specifications. Invoking SNAP! with
the /F command-line paramater is equivalent to entering the program,
pressing F6 at the System screen and entering a filename.
Abbreviations
In general, SNAP! is pretty good about recognizing valid dBASE
abbreviations. For example, it will properly detect that
<tab>DO <tab> WHIL<tab>
initiates a DO loop. Version 3.00 also removes the earlier restriction on
abbreviating INDEX ('SET INDE TO foo' is fine now).
Also, if you use dBASE key words as variable names, SNAP! can sometimes
become confused. For example, if you use 'PROC' as a variable name within a
procedure file and put the statement 'PROC = FOO' within the file, SNAP!
will see the 'PROC' and think that it is initiating a new procedure. Common
sense will ordinarily avoid this problem. As always, it is a good idea not
to use key words in a way other than that intended by the language,
especially if you plan to compile the code; compilers tend to be more picky
about this restriction than interpreters.
Status Reports
As SNAP! documents your programs, it updates a status screen that tells you
how much progress it has made. The screen shows the file that SNAP! is
currently documenting and the number of lines in the file. SNAP! makes two
passes through each file--one to determine which files use or call which
other files, and one for cross-referencing variables, formatting source code
and preparing action diagrams.
In addition, if you choose any option that modifies source code (heading,
indentation, key word capitalization, compression or expansion, etc.), or if
you choose to display the cross-reference report, SNAP! will display a more
elaborate screen indicating how many programs, databases, indexes, format
files, report forms and variables it has found, along with the total number
of program lines documented so far, and the amount of free memory available.
This screen also shows the elapsed time since you began documentation.
Note: some people have reported that the elapsed time is occasionally
negative. This is normal. It means that your computer is actually running
faster than light. It is nothing to be concerned about unless you have an
8087 chip, which sometimes overheats when moving backwards in time.
If SNAP! identifies any errors during its run, it will print a brief error
message in a separate window in the upper right corner of the screen. All
error messages are also echoed to the ERROR.DOC file.
7
Searching the Program Tree
SNAP! assumes that you want to document not only the TopFile, but all
programs it calls, all programs called by programs that Top calls, and so
on. In fact, SNAP! will search the program tree for all programs,
databases, index files, report forms, format files, label forms and memory
files as it prepares system documentation. You never need to specify more
than the top program file name.
If you choose not to search the tree (you can make this choice on the Other
Options Screen), only the specific file you enter will be documented. Thus,
you can limit documentation to a particular file or a branch of the program
tree by varying either the file you input as Top or the search tree
parameter.
Note that SNAP! does not track "SET DEFAULT TO x" statements, but always
expects to see files with no drive designations on the default drive and in
the source file subdirectory.
dBASE II or dBASE III?
On the Other Options screen, SNAP! asks if this is a dBASE III system. You
should answer "Y" if this is dBASE III or a dBASE III "compatible" --
specifically Clipper, FoxBASE+, or QuickSilver. Answer "N" for dBASE II or
FoxBASE (original, dBASE II variety).
SNAP! needs this information since dBASE III uses a different internal
format for database and index files, as well as different key words. SNAP!
reads Clipper index files, and handles Clipper source code and databases
without difficulty. If a specified dBASE III index file is not found, SNAP!
automatically searches for the corresponding Clipper index file (with an NTX
extension). SNAP! will also automatically detect FoxBASE index files (IDX
extension) and document them properly.
Further, if you say that your system is a dBASE III-type system, SNAP!
assumes that report form files are in dBASE III format. If they are not,
the system can hang when SNAP! bravely tries to read data that isn't there.
Ignoring Drive Designations
Sometimes you may want SNAP! to disregard explicit drive and path
designations when searching for program or other files. A choice off the
Other Options screen instructs SNAP! to drop any drive or path designations
before attempting to find a file. As an example, you may have written a
backup routine to copy a database to B:BACKUP.DBF. If you would like SNAP!
not to try to find that file on the B: drive, choose the option to ignore
drive designations.
8
9
SNAP! Commands
SNAP! supports several commands that you can insert in your source code
files. These commands will look like comments to Dbase systems, but will
have a special meaning for SNAP!. The commands allow you to define macros,
insert imaginary program statements into your system, turn SNAP! features on
and off for particular parts of your system, and so forth.
Macros
SNAP! has a limited ability to do macro substitutions. To define a macro,
place the following line in your source code:
*# SNAPMACRO source target1 target2 . . .
Alternatively, or in conjunction with this method, you can also define macro
substitutions in a separate file. Specify the /mfilename switch on the
command line to tell SNAP! which file the substitution strings are in. For
example, the following command will start SNAP! and read macro definitions
from the file FOO.MAC:
SNAP /mFOO.MAC
If you do not specify a filename with the /m switch, SNAP! will try to find
MACRO.SNP. You must use the full "*# SNAPMACRO" command verb on each line of
the file. Macro substitutions defined in source code files take precedence
over those defined in a separate macro file.
The /O switch on the SNAP! command line disables all macro processing, both
from SNAPMACRO statements in source code and in a named macro file.
Note that the SNAPMACRO statement begins with an asterisk and a pound sign.
SNAP! uses this sequence of characters to designate a SNAP! command (see the
/T command line switch for information on how to change these characters).
'Source' must be a single word, delimited by spaces or tabs. "Target" means
the rest of the line. Everything on the line--both source and target--will
be converted to upper case.
Note that the source string does not include the ampersand (&) symbol for
the macro (e.g., use SOURCE instead of &SOURCE). The rest of the line
(minus leading and trailing blanks) will be used as a substitution string.
The target can be a single word or several words.
You cannot use && comments on a SNAPMACRO line since SNAP! will think they
are part of the target. If you want to document the purpose of the
SNAPMACRO statement, put a comment on the line above it.
The SNAPMACRO statement can appear anywhere, as long as SNAP! sees it before
encountering the macro that you want to replace. If the target will have
the same value throughout the system (e.g., FOO will always be replaced by
10
BAR), it is a good idea to put all of the macros in one place, perhaps at
the top of the TopFile or in a separate macro file.
If you would like SNAP! to use different macro values during documentation,
you may want to place the SNAPMACRO statement immediately before the
specific location of each macro substitution. If you have multiple
definitions for a single macro, only the last one SNAP! sees will be
effective. For example, if the following series of statements are in your
program,
*# SNAPMACRO s_ddndx target1
*# SNAPMACRO s_ddndx target2
*# SNAPMACRO s_ddndx target3
only 'target3' will be effective and will be substituted for each occurrence
of &s_ddndx. See also the discussion of SNAPCODE statements below for an
alternative approach.
SNAP! will try to remove macros that look like drive or path designations.
For example, if the following statement is in one of your programs:
USE &MPATH.DATABASE
SNAP! will detect the macro and remove it before trying to find
DATABASE.DBF. One consequence of this limit is that you cannot use macros
to refer to program files in different directories. All source code program
files (programs, format files, memory files, etc.) must reside in the single
program directory you specify in the System screen. Databases and indexes
can be in either the program or data directories you specify.
SNAP! will not substitute the macro in the code itself, but will use the
substitution value everywhere else. For example, assume your program uses a
database whose name is contained in a macro variable named 'dataname'.
Assume further that you have included the following line in your code:
*# SNAPMACRO dataname ABC.DBF
If your code has this line in it:
USE &dataname
the source code will be unchanged after running SNAP!, but the program
headings and all other SNAP! reports will show this program using the
ABC.DBF database.
See also the section below "Fake Program Statements--SNAPCODE" for other
ideas on how to document macros.
11
SNAPCODE--Fake Program Statements
Sometimes you may want to enter fake program source code statements --
statements that SNAP! treats as real but which do not actually interfere
with your program when it executes. A good example is a macro that calls
one of a number of programs, depending on the value it has at run time
(e.g., DO &program). The macro substitution discussed in the section above
provides a way for you to specify one value for 'program'. But suppose you
wanted SNAP! to assume that 'program' had several values and to document
each one in turn? The *# SNAPCODE directive provides a way.
The *# SNAPCODE directive causes SNAP! to treat any text on the line as if
it were a program source code statement. In the example above, you could
enter the following lines where the macro was called:
DO &program <---- in original program
*# SNAPCODE DO foo
*# SNAPCODE DO bar
*# SNAPCODE DO brlfq
SNAP! acts as if these were perfectly straightforward calls to 'foo', 'bar'
and 'brlfq', and documents them accordingly. dBASE and related systems
ignore the statements.
Note that SNAP! does not know that these SNAPCODE statements have anything
to do with the DO statement above. SNAP! does not associate 'foo' with
'program'. The next time SNAP! sees 'DO &program' it will not assume that
'program' has the value 'foo'. If you want SNAP! to associate values with
macros, use the SNAPMACRO directive.
As a side benefit, SNAPCODE statements help document your code by specifying
the permissable values that particular macros can take.
Other SNAP! Directives
Other SNAP! commands, or directives, allow you to turn cross-referencing and
program formatting on or off for particular programs. For example, you may
have "boilerplate" code that you have thoroughly debugged and formatted
which you insert into many other systems. It would be unnecessarily time-
consuming to reformat this code every time you ran SNAP!. SNAP! provides
other commands to temporarily suspend cross-referencing and formatting--
XREF, FORMAT, INDENT, CAPITAL, and EXPAND. Each of these commands accepts
three settings--ON, OFF and SUSPEND. The ON and OFF commands are effective
until SNAP! sees another directive, while SUSPEND is in effect only until
the end of the current program or procedure. For example, if you insert
this line in your code:
*# SNAP XREF OFF
no tokens will be cross-referenced until this line is encountered:
*# SNAP XREF ON
On the other hand,
*# SNAP XREF SUSPEND
12
suspends cross-referencing only for the current file. It starts up again
when the next program or procedure is documented.
I suspend cross-referencing for commonly-used subroutines in my code. For
example, since Clipper does not have a BROWSE command, I often include a
public-domain BROWSE program in my systems. This is a standalone module
that really has nothing to do with the rest of my system, and I don't want
its variables cluttering up my cross-reference report. So, I say: SNAP XREF
SUSPEND at the top of the file and SNAP! leaves it alone.
SNAP FORMAT works in the same way. If format is off, no indenting or
capitalization will be done. When SNAP! sees a SNAP FORMAT statement, it
affects the internal codes that determine whether indenting, capitalization
and key word expansion (or contraction) take place. The three commands
(INDENT, CAPITAL and EXPAND) turn specific features on or off. Thus, the
following sequence suspends indenting and capitalization, but enables key
word expansion:
*# SNAP FORMAT SUSPEND
*# SNAP CAPITAL ON
Thus, FORMAT is a shorthand way of referring to CAPITAL, INDENT and EXPAND
all at once.
If *# is an inconvenient sequence for you (e.g, it may cause confusion with
the British pound sign), you can change it with the /T switch on the command
line. For example, if you invoke SNAP! with the switch "/T*$", SNAP! will
use *$ to designate SNAPMACRO, SNAPCODE and other SNAP! directives. You
must start this sequence with an asterisk (so that dBASE knows it is a
comment) and it cannot be more than three characters long.
13
Source Code Formatting Options
File Headings
One of the most useful SNAP! features is a heading written to each file in
the system. Each heading indicates:
Program name
System name
Copyright notice
Author
Procedures defined within this file
Which programs this program calls
Which programs call this program
Databases, index files, report forms, format files, label forms and
memory files used by this program
Date and time documented.
A sample heading is included in the Appendix. The sample heading indicates
that TODOINP.PRG is called by TODOMENU, calls TIME and TESTDATE, uses a file
whose name is contained in S:TDFILE with index TODO (macro substitution was
not used for this example), and also uses the TODOINP format file. The
heading also indicates the system name, author, copyright and date
documented. You may want to add more information to the header, such as a
brief narrative description of the program's purpose.
If you choose to write headings on your source code files (or if you choose
any other option that modifies the source code file), it is a good idea to
send the output files to a different directory than the input files so that
your original source code remains unchanged.
If you choose to send output files to the input directory, your original
source code file will be renamed with a .BAK extension. If you use
extensions to distinguish between program files, some of your original
source code files could be destroyed. For example, if your system uses the
following program file names:
SYSTEM.INP
SYSTEM.EDT
SYSTEM.RPT
SYSTEM.DEL
and so on, the output files containing the headings will retain these names.
Each of the input files, however, will have been renamed to a file called
SYSTEM.BAK, and only the last one will still exist when SNAP! completes.
Therefore, you should always send output files to a separate subdirectory if
you use this naming convention.
As always, you should make regular backups, and you should be especially
careful to make a full backup of all your files before running SNAP!.
14
By default, SNAP! leaves the date and time of last update unchanged for each
of your files. You can instruct SNAP! to update the date and time last
changed on the source code format screen. The headings written to each
program file show the date and time SNAP! was run.
Indentation
SNAP! can also help format your source code to make it easier to read.
SNAP! can recognize dBASE control structures and indent the program
statements underneath them. By default, indentation is three spaces. (The
author, who has long argued the superior virtue of tab characters for
indenting code, has caved in to overwhelming user pressure on this point.
He still uses tabs in his code and believes you should too. But the default
is now three spaces.) In addition, should you choose to use SNAP!'s source
code printing routines, you can select the number of spaces to be inserted
for each tab as the code prints.
However, if you would like to use spaces rather than tab characters for
indenting, you can select this option from the Format options screen. For
example, you can instruct SNAP! to use three spaces for each indentation
level. This option has no effect if you do not choose to indent source
code. It is different from the option in the source code printing facility
that also allows you to expand tabs. If you choose to use spaces to indent
your source code files, the source code will not contain tabs, so the source
code printing tab-expansion feature will have no effect.
If you choose to indent source code or create action diagrams, SNAP! will
also scan your code for mismatched control structure terminators. For
example, if your code has the following sequence:
DO WHILE T statements
.
.
.
IF X = Y
.
.
ENDIF
ENDIF <---- incorrect
SNAP! will detect that the final statement should have been an ENDDO instead
of an ENDIF and will display an appropriate error message. SNAP! will
accept 'END' as a valid abbreviation of ENDDO, ENDIF or ENDCASE.
Capitalization
SNAP! will also capitalize dBASE key words found in your source code. Key
words are stored in a file called DBxWORDS.SNP where x is a 2 or a 3
15
depending on the version of dBASE you are using (you can also specify
another file). SNAP! does not attempt to parse code statements to determine
how a word is used, so if you use key words as variable or field names, they
will also be capitalized. Should you wish not to capitalize a particular
key word, you can either delete it from the DBxWORDS.SNP file, or "comment
it out" by putting an asterisk before it in the file (e.g., RELEASE becomes
*RELEASE).
The preceding paragraph assumes you prefer "standard" capitalization--key
words are capitalized, functions have an initial capital letter, and
everything else is in lower case. If not, you can change it on the Format
screen. You can select upper case, lower case, initial caps, or none (leave
it alone) for both tokens and for key words. Thus, if you were so inclined,
you could capitalize tokens (variables, etc.) and lowercase key words.
Key Word Expansion and Compression
SNAP! will allow you to expand abbreviated key words to their full length,
or to abbreviate the key words to four characters. Compilers don't care
about any of this, but the dBASE interpreter runs programs slightly, usually
very slightly, faster if the key words are abbreviated to their first four
characters. An option on the Format screen controls how expansion or
compression is done. The default is no expansion or compression--SNAP!
leaves your code alone. However, you can select expansion, or compression
to any number of characters between 4 and 9.
Please be careful with this option, especially if you are not very careful
about how you name variables. The only thing SNAP! knows about key words
are that they are in the key words file. If one of your variables is a key
word (or a valid abbreviation of a key word), SNAP! will cheerfully expand
or contract it along with everything else. SNAP! cannot tell how whether a
particular word is being used as a command or as a variable. Normally, this
will not be a big problem--if you named a variable "title" and compressed
key words, it will now be called "titl". Problems could arise, however, if
two variables are valid abbreviations of the same key word (e.g., "other"
and "otherw", both of which are valid abbreviations of OTHERWISE). If you
compress key words and have such variable names, both variables will be
compressed to OTHE, and there is no way to separate them again. Also, if
you are using a dialect of Dbase that supports user-defined functions
(UDFs), and if one of the UDFs has the same name as a key word (Tom Rettig's
BLANK() function, for example), the UDF name will be compressed (assuming
the UDF name was in the key words file). If you compress keywords in this
case, nothing desirable will happen.
Because of the irrevocable changes that this option can make, SNAP! will not
allow you to exercise it if the source and output directories are the same.
In other words, SNAP! will refuse to overwrite your original source code
files if you select this option. Big brother is looking out for you.
Key words that are identified in the key words file as functions (they have
16
() after their name--see below) are never affected by key word compression
or expansion.
Suppressing Blank Lines and Comments
You can suppress blank lines and/or comments from the output files by
selecting the appropriate options on the Format screen. I do not recommend
this, but it does make interpreted dBASE applications run slightly faster.
Please be doubly sure to make backups before doing this. SNAP!'s default
options are to leave both blank lines and comments in the output file, so
you have to take special action yourself before they will be dropped.
As with key word expansion and compression, you cannot select this option if
the source and output subdirectories are the same.
If you know how to design an effective counterpart to this feature--how to
put the comments back in--please contact me about a potentially lucrative
commercial venture.
Key Words File
Capitalization, cross-referencing and key word expansion and compression are
controlled by the words in the key words file. The key word file should
contain one key word per line. Capitalization and order do not matter,
except that if two identical key words have different flags (see below), the
last one takes precedence.
By inserting the correct characters in the key word file, you can cause
certain key words or variables to be handled differently than normal. The
following characters have a special meaning in the key word file when
inserted immediately before a word:
* Comments out the word. SNAP! acts as if it were not in
the key word file at all.
! Capitalize, but do no cross-reference even when the
option to cross-reference key words is in effect. You
may want to use this character for often-used but
uninteresting key words such as TO or, perhaps, SAY.
@ Capitalize and always cross-reference this word, even
when the option to cross-reference key words is not in
effect. You might want to use this for especially
important key words such REPLACE, SAVE, or QUIT.
% Neither capitalize nor cross-reference, regardless of
whether the options to capitalize or cross-reference key
words are in effect. You may want to use this character
17
for variables that you use frequently, but that you are
not interested in cross-referencing--perhaps "i",
"choice", "action", or "lineno". This will keep them
from cluttering up the cross-reference report. Such
words are not affected by key word expansion or
contraction.
() If the *last* two characters in a key word are (), the key word
will ordinarily have an initial capital letter in the formatted
output. The DB3WORDS.SNP file that comes with SNAP! uses this
notation to designate the Tom Rettig key words (Tom Rettig is the
author of a popular set of functions for dBASE III and Clipper).
Functions are never affected by key word expansion or contraction.
The following examples illustrate how to use these special characters:
*note
!SAY
@REPLACE
%CHOICE
SOME_FUNCTION()
18
Reports and Outputs
SNAP! can produce any combination of several reports. Each report is
optional and can be selected or suppressed on the Options Screen. However,
some reports (e.g. Data dictionary, Index summary) require you to search the
tree rather than document a single program.
Normally, SNAP! tells you that it is producing a particular report, but does
not display the report on the screen. However, each report other than a
file heading, may be displayed on the screen as it is echoed to a file. You
can enable screen echoing by invoking SNAP! with the /S command line
parameter. I like to see the reports being generated but some people prefer
to silence the screen to improve SNAP!'s speed. Note that the /S switch
only affects the screen display of reports and has no effect on the status
screens that are displayed as SNAP! scans source code files.
The program contains default filenames (e.g., XREF.DOC for the
cross-reference report), but you can change them if you wish.
System Summary
This report shows the following information:
System name
Author
Current date and time
Lines of code
Number of programs, procedures, procedure files, indexes, etc.
Names of databases, indexes, report forms, label forms and memory files
The system summary would ordinarily be the first page in the documentation.
It, together with the tree diagram, provides a basic overview of the entire
system. See Appendix A for an example.
Tree Structure Diagram
If you choose the default option of documenting all programs in the tree,
SNAP! will produce a chart showing which programs call which other programs
and which programs use which databases. The tree diagram, like other SNAP!
reports, appears on the screen and is echoed to a file (default name of
TREE.DOC).
Any procedures or databases in the tree will be designated like this:
Gee (procedure in procedure.file)
Whiz (database ALIAS baz)
SNAP! by default includes programs, procedures, functions, format files and
databases in the tree. The Tree Screen includes options that allow you to
put indexes, report forms, label forms and memory files in the tree also, or
to suppress any of the default file types except program files.
19
Note that the databases (and other non-program files) are shown underneath
the programs that actually call them. If a database is opened in one
program and remains open in another program, SNAP! will show the database as
called only by the first program file.
SNAP! has some code to detect certain types of recursion and prevent the
tree from marching off the right side of the page and eventually off the end
of the world. SNAP! catches programs that call themselves and programs that
call another program that calls the original program again. If the
recursion is more subtle than that, SNAP! will eventually give up when
recursion reaches 25 levels. You will have become bored watching the
display by that point.
The tree report is illustrated in the Appendix.
File List
SNAP! can write a simple list of all files used in the system, including
programs, databases, index files, and so on. This report can be useful for
identifying which files in a directory are associated with an application.
The file list can also be fed into the source code printing routines at a
later point, so that the program files can be printed without going through
a time-consuming complete documentation run again.
Data Dictionary
The data dictionary report contains two parts: 1) the database structure for
each database in the system and a list of programs which use it; and 2) a
listing of each data field in the system and the databases that contain it.
SNAP! tries to figure out which indexes, report forms and label forms are
associated with each database. It tracks the following statements:
USE dbfname
SELECT A (or B, C, etc. up through J)
SELECT aliasname
CLOSE DATABASES
CLOSE ALL
USE
SNAP! knows how to account for macros in each of these constructions,
assuming you have defined the macro. For example, USE &temp will be
interpreted to mean USE abcfile if you have previously defined &temp to mean
abcfile (see section on SNAPMACRO statements for more details).
SNAP! is reasonably good, but certainly not perfect, at figuring out which
database is active at a particular spot in the code. There are, however,
some limitations you should be aware of. First, SNAP! does not track
databases or areas across program files or procedures. Whenever SNAP!
begins documenting a file, it assumes that no databases are in use and that
areea A is active. Also, SNAP! does not try to interpret conditional
structures. For example, consider the following code:
20
IF .T.
USE foo
ELSE
USE bar
ENDIF
SNAP! looks at this code one line at a time. The last USE statement it sees
is 'USE bar'. That statement will never actually be executed (because of
the IF test), but SNAP! doesn't know that. You may need to use SNAPCODE
statements to help SNAP! figure out what is happening in cases such as this
one.
SNAP! identifies databases in four ways:
1) USE statements, but only those followed by a database name;
2) COPY TO statements, including COPY TO ... SDF. If the
command copies to an SDF file that does not have an
explicit extension, SNAP! supplies .TXT. Otherwise SNAP!
assumes databases to have .DBF extensions.
3) DELETE FILE xxx.DBF
4) CREATE foo FROM bar (SNAP! picks up both foo and bar)
A statement that tests for the existence of a database (e.g. IF FILE("xyz"))
will not by itself be identified as a database reference. Currently, SNAP!
imposes an overall limit of 1,024 fields in the entire system. If you
exceed that number, SNAP! complains and does not include the excess fields
in the data dictionary.
A sample data dictionary report is included in appendix A.
Index File Summary
The index file summary lists each index file referenced in the system and
attempts to show the fields it is indexed on and the files that use it.
SNAP! first checks for an index file with an extension of NDX (the usual
extension of dBASE II, dBASE III index files). If it cannot find this file,
it tries to find the same file name with an NTX extension (the usual
extension of Clipper index files). Failing that, it tries FoxBASE+ IDX
extensions. If SNAP! cannot find one of those either, it gives up and
reports that the NDX file could not be found. If, however, it could find
the Clipper or FoxBASE+ file, it documents it appropriately.
SNAP! also shows the database associated with each index, if it could figure
it out. The data dictionary section of this documentation discusses the
assumptions that SNAP! makes about which database is active.
SNAP! identifies indexes in four ways:
1) INDEX ON xyz TO indexfile
2) USE xyz INDEX indexfile1,indexfile2,indexfile3 ...
3) SET INDEX TO indexfile1,indexfile2,indexfile3 ...
21
4) DELETE FILE xyz.NDX
In cases 2 and 3, each index file will be separately identified and
documented.
A statement that tests for the existence of an index (e.g. IF
FILE("xyz.NDX")) will not by itself be identified as an index reference.
A sample index file summary in shown in the Appendix.
Format File Summary
SNAP! also produces a report showing each format file used in the system and
the programs that call it. A sample report is in the Appendix.
SNAP! identifies format files in two ways:
1) SET FORMAT TO xyz
2) DELETE FILE xyz.FMT
In case 1, if this is a dBASE II system, SET FORMAT TO SCREEN and SET FORMAT
TO PRINT are not flagged as references to format files.
A statement that tests for the existence of an format (e.g. IF
FILE("xyz.FMT")) will not by itself be identified as an format reference.
Report Form Summary
SNAP! also produces a report showing each report form used in the system,
the report parameters, and the programs that call it. SNAP! shows a mock-up
of each report and the expressions that go into each column. It also
indicates which database is associated with the report form.
A sample report is in the Appendix.
SNAP! identifies report forms in two ways:
1) REPORT FORM xyz ...
2) DELETE FILE xyz.FRM
A statement that tests for the existence of an form (e.g. IF
FILE("xyz.FRM")) will not by itself be identified as an report form
reference.
Label Form Summary
The label form summary shows the parameters of each label form in the
system. It also indicates which database is associated with each label
form. A sample report is in the Appendix.
22
Procedure File Summary
SNAP! allows you to prepare a summary of files that contain procedures (see
example in appendix A). This summary shows the procedures in each procedure
file and the programs and procedures that each one calls and is called by.
Note that this report covers both procedure files and ordinary program files
that also contain procedures (as Clipper allows).
Variable Cross-Reference Report
Another useful report available through SNAP! is a variable cross-reference
listing, showing line numbers for each program that references a particular
variable. 'Variable' in this context includes field names, file names and
anything else that isn't a key word, numeric constant, punctuation mark or
quoted string.
If you elect to display the variable cross-reference report (by responding
'Y' to the question on the options menu), you can view the Cross-reference
Options Screen (press F4 from the options menu). The Cross-reference
Options Screen allows you to select the type of "things" that will included
on the cross-reference report. You will have the option to include only
PUBLIC variables (this option has no meaning if this is a dBASE II system).
You also get the following choices:
Include other variables and tokens
Include key words
Include numeric constants
Your responses to these prompts (and your use of special characters in the
key words file--see below) determine which words will appear on the
cross-reference report.
The cross-reference report adds certain codes to the end of a line number
reference when the reference is particularly interesting. SNAP! looks for
the following statements to tell if a variable or field name (assume its
name is 'abc') is interesting:
Reference Type Report Flag
abc = 4 *
STORE 4 TO abc *
WAIT to abc *
@ 1,1 GET abc PICTURE "blah, blah" G
ACCEPT "something" TO abc G
INPUT abc G
REPLACE abc WITH something R
RELEASE abc x
PUBLIC abc P
PRIVATE abc V
23
? &abc &
DECLARE abc[100] A
DIMENSION abc(100,200) A
USE abc [INDEX ...] [ALIAS ...] U
DO foo WITH @abc @
As the following sample excerpt from the cross reference report illustrates,
you can tell at a glance what is happening to the variables you are using:
ABC
TODO.PRG 30P 41 42 43G 44 45* 46G 47G 72x
TDINPUT.PRG 123V 234* 235 237
SETFILT.PRG 16 24 28 32
TDEDIT.PRG 107* 133 134 135 136 138x
This report shows that variable 'abc' was used in four programs (TODO,
TDINPUT, SETFILT and TDEDIT). Within TODO, it was declared a PUBLIC
variable on line 30; referenced but not changed on lines 41, 42 and 44; used
in a GET statement on lines 43, 46 and 47; modified in line 45; and released
on line 72. TDINPUT declared it to be PRIVATE (line 123), assigned it a
value in line 234, then referred to it in lines 235 and 237.
A legend to explain all these flags is printed at the top of each
cross-reference report, so you do not need to remember what they all mean.
SNAP! will not flag a 'RELEASE ALL' statement as a reference, nor will it
figure out that a 'RESTORE FROM xyz.mem' may overwrite other variables.
Neither of these statements will generate a cross-reference listing for any
variables (though xyz.mem will be referenced). Of course, you can have
SNAP! cross-reference the RELEASE and RESTORE statements themselves.
By default, references to a database field prefaced by the alias
(e.g., foo->bar) will be shown as one token in the cross reference file. If
you do not like this convention, the /C command line option turns it off, so
that foo and bar will be referenced separately.
At the bottom of the report, SNAP! produces a list of public variables, a
list of macros and a list of arrays. The macro list is subdivided into
macros that you defined to SNAP! and those your didn't. If you defined a
macro, its definition is also shown.
The cross-reference report interacts closely with the key word file.
Specifically, the key word file is how SNAP! can tell what is a key word and
what is not. Additionally, by inserting the correct characters in the key
word file, you can cause certain key words or variables to be handled
differently than usual. The following characters have a special meaning in
the key word file when inserted immediately before a word:
* Comments out the word. SNAP! acts as if it were not in the key
word file at all.
24
! Capitalize, but do no cross-reference even when the option to
cross-reference key words is in effect. You may want to use this
character for often-used but uninteresting key words such as TO
or, perhaps, SAY.
@ Capitalize and always cross-reference this word, even when the
option to cross-reference key words is not in effect. You might
want to use this for especially important key words such REPLACE,
SAVE, or QUIT.
% Neither capitalize nor cross-reference, regardless of whether the
options to capitalize or cross-reference key words are in
effect. You may want to use this character to designate
variables that you use frequently, but that you are not
interested in cross-referencing--perhaps "i", "choice", "action",
or "lineno".
() If the *last* two characters in a key word are (), the key word
will ordinarily have an initial capital letter in the formatted
output. The DB3WORDS.SNP file that comes with SNAP! uses this
notation to designate the Tom Rettig key words (Tom Rettig is the
author of a popular set of functions for dBASE III and Clipper).
The following examples illustrate how to use these special characters:
*note -- this word will be ignored.
!SAY -- capitalize, but do not cross-reference, SAY
@REPLACE -- include REPLACE in the cross-reference report
%CHOICE -- do not capitalize or cross-reference this word
alltrim() -- This word is a function. The first letter will be
capitalized
If this is a dBASE III system, SNAP! allows you to restrict the
cross-referencing to PUBLIC variables. If you select this option, SNAP!
only puts public variables on the report. However, SNAP! does not look for
PRIVATE statements that redefine the variable, so if a variable is declared
PUBLIC anywhere in the system, SNAP! documents all subsequent occurrences of
it. Note that SNAP! does not "backtrack" to see if the variable was
referenced before it was defined as PUBLIC.
I have done my best to identify key words used in dBASE, FoxBASE and
Clipper, but I may have missed some. Fortunately, the DBxWORDS.SNP file is
a standard ASCII file that you can edit with most any word processor. So, if
I have omitted one of your favorite key words, it is a simple matter to add
it to the file. Function names from the Tom Rettig library are included,
but you may also want to add function names from other development tools.
A sample cross-reference report is included in the Appendix.
25
LNK and MAKE files
These options will be useful only to developers of Clipper-compiled
applications. If you are using interpretive dBASE III, you can ignore this
section.
Link Files. SNAP! can produce a link file for PLINK86 (which comes with
Clipper), TLINK (part of the Borland Turbo C package), and the Microsoft
LINK utility. If you are a serious Clipper programmer, the TLINK linker
justifies the cost of the Turbo C package (less than $100)--it is that fast.
I have seen some informal benchmarks that show it linking applications as
much as eight times faster than PLINK86.
PLINK86 will accept "commands" from a LNK file. This file typically
contains a series of commands for the linker, telling the linker such things
as which libraries to search and in what order. SNAP! will produce a LNK
file if you select the appropriate option. This LNK file will contain a
list of all the files in your system.
If you have a file named LINK.SNP in your source directory, SNAP! will put
it at the top of the LNK file. For example, you might put a list of
libraries in this file. You can also use a name other than 'LINK.SNP' by
specifying /Lfilename on the command line.
Make Files. SNAP! can produce the files for the Clipper MAKE utility
(Summer 87 version only) and for the Shareware NDMAKE program.
MAKE is a standard UNIX (tm) utility, versions of which are now also
available for MS-DOS. MAKE allows you to define which files "depend" on
other files and only compile files that have changed. For example, in a
Clipper application using MAKE, you would typically have one OBJ file for
each PRG file. Each OBJ file "depends" on the corresponding PRG file since
the OBJ file needs to be remade when the PRG file changes. In other words,
when a change is made to a program file, it needs to be recompiled to create
a new object file. Similarly, the EXE file "depends" on all of the object
files that are linked together to create it.
MAKE allows you to specify these dependencies and perform the fewest
recompiles to completely update your system for all program changes. It can
save an enormous amount of time on the edit-compile-link-run cycle for a
large system development.
NDMAKE use three files--the MAKE.EXE file itself, a MAKE.INI file that
specifies certain defaults, and a file named MAKEFILE that contains the
dependencies for your system. SNAP! can create the MAKEFILE. It is up to
you to deal with MAKE.INI. In particular, you will need to add a default
rule to your MAKE.INI file to tell MAKE how to compile a PRG file into an
OBJ file. Its syntax is:
# To produce a `.obj' file from a `.prg' file using Clipper.
.prg.obj:; clipper $< -m
26
This definition should work with most versions of MAKE. If you use a
different MAKE utility, you may need to use slightly different syntax here.
Check your documentation to be sure.
The SNAP! MAKE option works hand-in-hand with the LNK option. If you ask
SNAP! to create a LNK file, SNAP! will use the same file name when it create
MAKEFILE.
The net effect of all of this is that you can issue the command:
MAKE filename (where filename is the name of your TopFile)
and MAKE will figure out what needs to be recompiled and linked to create
your system.
Sample LNK and MAKEFILE listings are included in appendix A.
Batch Files
SNAP! also produces DOS batch files to do useful things. One file, named
UPDATE.BAT, will copy all program files from the SNAP! output directory to
the original source directory. You could use it to copy the new
(documented) versions of your source files over the original (undocumented)
source files. The syntax for UPDATE is:
UPDATE d:
where d: is a drive or directory name. If it is omitted, the original
source directory is assumed. Be careful with this file since it overwrites
the original source code files. You should backup your original files and
review the new output files before executing UPDATE. No kidding. This is
important.
BACKPRG backs up the programs, format files and report forms in your system.
Its syntax is:
BACKPRG d:
d: is a drive or directory name and is required. If you do not specify a
target drive or directory, the batch file will complain and stop.
BACKDBF backs up the databases, index files and memory files in your system.
Its syntax is:
BACKDBF d:
d: is a drive or directory name and is required. If you do not specify a
target drive or directory, the batch file will complain and stop.
Macros are suppressed from this file.
27
Also, SNAP! creates the PRINTDOC.BAT file to send all documentation files
(not including source code or action diagrams) to the printer. PRINTDOC
calls the DOS PRINT utility for background printing. Thus, PRINT must be
available somewhere on the path.
Action Diagrams
An action diagram documents the structure of a program by using graphical
symbols to group related statements together. By default, SNAP! uses the
IBM extended ASCII characters in the action diagrams it prepares.
A portion of a sample action diagram follows:
IF s_clipper .AND. s0_filt = 7
DO WHILE .NOT. s0_userfilt
SKIP
IF EOF()
GOTO TOP
DO WHILE .NOT. &s0_userfilt
SKIP
IF EOF()
SET FILTER TO
s0_userfilt = "1=1"
GOTO TOP
^ LOOP
IF Dusty Day In The Lake
? "Yell and Scream"
< RETURN
ENDIF
ENDIF
ENDDO
DO CASE
CASE lastkey() = 4
choice = "F"
CASE lastkey() = 19
choice ="B"
ENDCASE
ENDIF
ENDDO
FOR i = 1 TO 25
DO sample1
NEXT
ENDIF
As this example shows, different extended ASCII characters are used to
differentiate different control structures. Loops (DO WHILE, FOR, SCAN) use
the double-line vertical bar, while conditional statements (IF, DO CASE) use
a single vertical bar. The structures are distinguished further by the
horizontal symbol used to connect the control structure key word with the
vertical bar.
28
Note also that these diagrams allow you to identify "unusual" loop exits
such as LOOP and RETURN very easily. I can often identify subtle,
difficult-to-locate bugs by studying the action diagram for the program.
SNAP! will identify certain syntax errors (such as a LOOP statement that is
not within a DO WHILE loop) only if you choose to prepare action diagrams.
Certain error checking is only performed within this module.
The Format screen allows you to choose whether to write action diagrams or
not. It also allows you to specify the extension that action diagram files
will have. Action diagrams always have the same main file name (i.e, the
first eight characters) as the source code file from which it is drawn, but
the extension can be anything you specify except '.PRG'. You can use the
'?' character as a wildcard to match the corresponding characters in the
original file extension. Therefore, if you choose an action file extension
of'??T', and your original source file was named FOO.BAR, the action diagram
file will be named FOO.BAT (the BA is drawn from the original filename, and
the T comes from the action diagram file mask).
Action diagram files are very much like program files and have the same
capitalization as the output program files do. However, action diagram
files are not directly executable or compilable because of the additional
line-drawing characters they contain.
Some printers (most Epson models, for example) do not support the IBM
graphics characters very well. If you want to print action diagrams, you
may want to use other characters for the connections. You can choose to
prepare action diagrams using only ASCII symbols by choosing the ASCII
symbol option on the source code and action diagram options screen.
29
You can also choose your own action diagram symbols on the 'SourceCode and
Action Diagram Options' screen. The following chart shows how to customize
the symbols:
Default symbols: ^v <
Position: 0000000001111111111222
1234567890123456789012
Position Symbol
-------- ------------------------------------------------------------
1 Horizontal symbol used for IF/ELSE/ENDIF structures
2 Vertical symbol used for IF/ELSE/ENDIF structures
3 Corner for IF and BEGIN SEQUENCE (Clipper only)
4 Corner for ENDIF and END (Clipper only)
5 Join symbol for ELSE
6 Horizontal symbol used for DO WHILE/ENDDO structures
7 Vertical symbol used for DO WHILE/ENDDO structures
8 Corner for DO WHILE
9 Corner for ENDDO
10 Symbol for LOOP
11 Symbol for EXIT and BREAK (Clipper only)
12 Horizontal symbol used for DO CASE/OTHERWISE/ENDCASE structures
13 Vertical symbol used for DO CASE/OTHERWISE/ENDCASE structures
14 Corner for DO CASE
15 Corner for ENDCASE
16 Join symbol for CASE and OTHERWISE
17 Horizontal symbol used for FOR/NEXT structures
18 Vertical symbol used for FOR/NEXT structures
19 Corner for FOR
20 Corner for NEXT
21 Arrow symbol for RETURN/CANCEL/QUIT
22 Horizontal symbol used for RETURN/CANCEL/QUIT/LOOP/EXIT
You can replace any of these symbols with others of your choosing. If you
want to restore the default set, simply select 'G' for graphics characters,
move to another input screen, then come back again (in simpler terms, select
'G', press F4 then F3). These symbols are reset when the 'Source Code and
Action Diagrams Options' screen is presented. One consequence is that you
must answer 'O' (for Other Symbols) to be able to change the action diagram
symbols. If you answer 'G', then change the symbols, the changes will not
take effect. Like all other input fields, any user-defined symbols will be
saved in the configuration file so you do not have to enter them at each
invocation of SNAP!
The SCAN/ENDSCAN control structure is documented with the same symbols as
the DO WHILE loop. The BEGIN SEQUENCE/BREAK/END control structure in
Clipper is diagrammed with the same symbols as an IF/ENDIF structure.
30
Source Code Printout
When you have completed your program, you will probably want a listing of
the source code to accompany the rest of your documentation. SNAP! provides
a facility for formatting and printing dBASE source code files and/or action
diagrams, and gives you a great deal of control over source code format.
You can set the following parameters:
Line width
Page length
Left and right margins
Top and bottom margins
Spaces per tab
Include or suppress line numbers
Printer setup string
For example, you can set these values to leave plenty of room on the left
side of the page so that your code will fit in a 3-ring binder.
If a line of code exceeds the line width minus left and right margins, SNAP!
will wrap it on the printout without messing up the page breaks. SNAP! also
appropriately counts the wrapped line as one source code line, so that your
cross-reference report still matches the printout.
Each page of the printout contains a header showing the program name, system
name, copyright notice, page number and date/time printed. The programs are
printed in alphabetical order.
Line numbers are never added to an action diagram at print time. If you
would like action diagrams to be printed with line numbers, choose the
option on the format screen to add the line numbers directly to the action
diagram file. This is the default choice, so you ordinarily get action
diagrams (and printouts) with line numbers. The restriction on adding line
numbers at print time prevents duplicate line numbers from being printed.
The print section of SNAP! deals harshly with nonsense. For example, if the
sum of your left and right margins exceeds your line width, SNAP! will set
the line width and the margins to their default values. Similarly, SNAP!
will reject top and bottom margins greater than page length, negative
values, tab expansions greater than 12 spaces, and so on.
SNAP! prints a three-line heading on each page of the printout, showing
program name, system name, copyright holder, date, time, and page number.
The heading begins on the line immediately following the top margin you
specify. Accordingly, if you use a top margin of 8 and a bottom margin of
8, with 66-line paper only 47 lines of code will be printed on each page
(66 lines - 8 top margin - 8 bottom margin - 3 heading).
31
For those of you with HP LaserJet II printers, try the following parameters:
Line width: 132 Page length: 80
Top margin: 4 Bottom margin: 4
Left margin: 8 Right margin: 1
Setup string: \027E\027&l0o8D\027(10U\027(s16.6H
The \027E at the beginning of the string resets the printer.
Printing Without Documenting
You can use the source code printing facilities of SNAP! without going
through the full time-consuming documentation process. If you press the F9
key while viewing the Print screen, SNAP! will prompt you for a filename
containing the names of files to print. SNAP! searches the file you name
and prints the contents of the files listed therein. SNAP! will not print a
file with an extension of MEM, FRM, DBF, NDX, NTX, IDX, MDX, EXE, COM and
other common non-ASCII Dbase names. Also, SNAP! tries to figure out if a
particular file is not an ASCII file and warn you about it before printing.
SNAP! will not try to print from anything that isn't a filename, so the file
you specify can contain all sorts of garbage without causing a problem. The
main effect of all this is that you can give the Print routines the name of
a SNAP! FILELIST.DOC file and it will print all the source code in the
system without going through the full SNAP! documentation process again. Of
course, you can create your own file containing filenames to print also.
You can also use this feature to print documentation files in a nicely-
formatted way.
32
Using SNAP! in a Batch Environment
If you have several systems to document, you may wish to set up a batch file
to invoke SNAP! with the appropriate parameters for each system so that you
can come back in a week or two and find all your programs beautifully
documented. SNAP! supports Immediate Mode for batch documentation through
the /X switch on the command line. Used in conjunction with named
configuration and macro files, you can sequentially document a series of
dBASE systems. SNAP! will take its input from the configuration files (or
from CONFIG.SNP if no configuration file is named) and begin documenting the
system immediately. Note that you have to have your configuration file
ready before you invoke the system. If you do not specify a configuration
file, SNAP! tries to use CONFIG.SNP in the current directory.
For example, to document three dBASE systems without pausing for user input,
set up a batch file with these lines:
SNAP /x /fsystem1.snp
SNAP /x /fsystem2.snp
SNAP /x
SNAP! will document the first system and take input from the SYSTEM1.SNP
configuration file. Then, without prompting for further user action, it
will read SYSTEM2.SNP and begin documenting the second system. Input for
the third system is in the CONFIG.SNP (default name) file. When the batch
file is invoked, SNAP! will begin documenting and will not pause for user
input at any point in the process.
If an error occurs anywhere during the processing of these three systems,
SNAP! will display an error message and stop documenting the system that
experienced the error. The batch file, however, will continue running and
will move on to the next system to be documented.
33
Random Notes
These are some other thoughts that don't seem to fit anywhere else.
If you have a file named HELP.PRG in the program directory, SNAP! assumes
this must be a Clipper system, where 'HELP' is a magic name and documents
the program accordingly. SNAP! treats HELP.PRG as if it were called
directly from TopFile.
34
Program Limitations
and Things To Watch Out For
SNAP! had the following design limitations when this documentation was
written:
Maximum program files: 512 programs, procedures and functions
Maximum other files: 128 of each type (e.g. databases)
Maximum variables: 2000 throughout the system
Maximum key words: 1000 words
Maximum length of key word: 15 characters
Maximum length of a token: 20 characters
Maximum levels of program nesting: 20 levels
Maximum number of database fields: 1024 throughout the system
Maximum length of filename: 67 characters (including path)
These limitations were current when this documentation was written. You can
verify them (it would be a good idea) by viewing the program limitations
screen (Press F1 three times from the greeting screen).
SNAP! uses about 225K of memory as "overhead." This much is used as soon as
the program is invoked. It also allocates additional memory dynamically as
it is needed. It is a memory hog and will probably not be of much use if
you don't have at least 512K. Look at it this way: memory boards cost less
than commercial programs that compete with SNAP!. Don't look at SNAP! as
free software--look at it as an excuse to buy more hardware.
Legal Coding that is Prohibited by SNAP!
I make no promises about what will happen if you run SNAP! against nonvalid
Dbase syntax, but predict that the results will not be satisfying. On the
other hand, there are some "legal" coding techniques for Dbase that cause
problems with SNAP!. I have tried to keep these to a minimum, but some yet
remain.
You cannot use the word "END" as a variable in an assignment statement of
the form:
END = foo.
SNAP! sees the 'END' (which is a valid control structure terminator in
Clipper), treats anything else on the line as a comment, and becomes
powerfully confused. Using "END" in a:
STORE foo TO end
statement is acceptable. You also cannot use PROCEDURE or FUNCTION (or a
valid abbreviation of either) as a variable name.
Hyphens in Filenames
SNAP! uses treats a hyphen as a delimiter when it is scanning your source
code to prepare the cross-reference report, since the hyphen usually means
35
"subtract." Thus, foo = bar-baz will correctly generate three cross-
references--one for "foo", one for "bar" and one for "baz". This technique
breaks down when SNAP! sees "DO foo-bar." In this case, both "foo" and
"bar" will be cross-referenced. Note that SNAP! will find the right file
and continue documenting--it is only the cross-reference report that is
misleading.
Continuation Lines
Continuation lines may be a problem in some circumstances. SNAP! actually
reads each source file twice--once to check for files and once to handle
formatting (indentation, capitalization, etc.) and cross-referencing. SNAP!
tries to deal with continuation lines during the first scan and so will
properly parse statements such as:
SET INDEX TO brlfq, foo, bar, ;
baz, plugh
and
SUM hatsize ;
FOR level = "MANAGEMENT"
(This latter statement led to particularly insidious effects before
continuation lines were parsed--SNAP! treated it as the beginning of a
FOR-NEXT control structure. This made for interesting action diagrams.)
However, SNAP! cannot tell that:
abracadabra = ;
opensesame
is an assignment statement. Accordingly, the cross-reference report will
not contain the correct flag for an assignment statement. While
"abracadabra" and "opensesame" will properly appear on the report, the
proper cross-reference marker will not be present.
Total line length, counting the length of continuation lines but not leading
and trailing white space, is limited to 255 characters. SNAP! warns you
when it sees a longer line. This is not a limitation on dBASE systems,
since dBASE II and III impose the same limit. Some compilers, however,
allow lines to exceed the 255-character limit.
There may be other anomalies related to continuation lines that I have not
thought of.
Multiple Procedure Files
If you use multiple procedure files and if they contain procedures that have
the same name, SNAP! may document your system incorrectly. For example,
36
assume you have two procedure files that are SET at different points in the
system. Both files contain a procedure called FOO, but FOO is not the same
in each file. When SNAP! searches for procedures, it will always find the
first FOO and assume it is the one being called. SNAP! does not track which
procedure file is currently active and cannot distinguish between
identically-named procedures in different procedure files. This limitation
has no effect on systems that use only one procedure file, or on systems
that have multiple procedure files each containing uniquely-named
procedures.
Giving different things the same name is a bad programming habit to get
into. It is a good idea to use unique names for each procedure, function,
procedure file and program.
Suppressing Color
If you do not like the colors I selected, or if they do not display properly
on your monitor, putting the "/BW" switch on the command line will disable
color.
37
Change History
SNAP! has undergone several major changes since version 2.0 ('2.0' in this
context means all versions beginning with the number 2). The following list
is not all-inclusive, but does hit the high points.
Speed
Version 3.0 should be approximately 2.5 times as fast as version 2.0. The
more procedures you use, the faster it will be. SNAP! 2.0 was particularly
inefficient in documenting procedures.
Source Code Printing
You can now use the source code printing routines without going through the
entire documentation process. When you press the right function key, it
asks for a filename. SNAP! searches this file for other filenames, which it
then prints.
User Interface
The user interface has gotten an interface-lift <guffaw> since the last
version. The number of option screens grew too large to be conveniently
browsed with the facilities in version 2. Version 3 now organizes all the
screens underneath a main menu. You can also select menu items with Alt-key
combinations, without having to deal with the menu itself.
Memory Usage
SNAP! 3.0 uses some additional dynamic data structures to minimize wasted
space. Under normal circumstances, it should roughly triple the size of the
application that can be accommodated by the system. In addition, after the
conversion to Turbo Pascal 4.0, the size of the program itself shrank by
about 20%.
New Reports
A system summary is now available to show:
Lines of code
Database and index names
Number of program files
Number of procedures
and lots of other summary information.
Arrays are recognized in the cross-reference report and are denoted with
brackets (for Clipper) or parentheses (for FoxBASE), as appropriate (e.g.,
38
FOO[100] or FOO(100,50) ), with the declared size shown. The cross-
reference report also lists public variables, macros and arrays separately.
The report form documentation has been revised extensively (dBASE III only).
It now shows each of the fields in the report, displays the report heading,
etc. Similar documentation is now available for label forms, which were
ignored entirely by SNAP! version 2.0.)
The database summary now includes start and end columns for each field.
Alias names are now usually shown with the appropriate physical database
file in the data dictionary, file heading, tree, etc.
Link files can now be created for PLINK86, Turbo C TLINK, or the Microsoft
LINK program. Make files continue to support NDMAKE and now also support
the Clipper MAKE utility.
File headings and may other reports show the date and time of last change,
based on the file date/time stamp.
Additional Options
Here are some of the new things you can control:
Suppression of blank lines in output file
Suppression of comments in output file
Optional extra indent under DO CASE statement
Inclusion of DBF, NDX, MEM, FRM and LBL files in the tree
Capitalization of key words
Capitalization of tokens
Temporary suspension of cross-referencing and formatting
Leave the file date/time stamp unchanged
Separate directories for programs and databases
Changes Since SNAP! Version 1.0
Practically everything.
39
Some Administrative Matters
Version Numbers
In the past, I have sometimes been criticized for releasing one or more
"maintenance" versions shortly after a major update. I am guilty, but
unrepentant. In an attempt to be responsive to user suggestions and bug
reports, I will continue to add features and fix bugs as they are reported.
When the resulting minor changes are uploaded, the SNAP! version will
include a letter (e.g., SNAP! version 3.00 will change to 3.00a). In this
example, if you have version 3.00, don't worry about downloading another
version before 3.1 unless you need the specific features in the intervening
versions.
Updates and New Versions
Rather than download the large SNAP! files, you may prefer to send me a
blank, formatted diskette (either 3.5 or 5.25 inch, but 3.5 takes longer)
and a postage-paid diskette mailer, and I will send you the most current
version. My address is:
Walter J. Kennamer
1801 E. 12th St., Apt. 1118
Cleveland, Ohio 44114
How to Get Support
My CIS ID is 74025,514. I log on every day, except when I am traveling. I
am easiest to reach through EasyPlex, but I also check in on the Ashton-Tate
SIG, the IBM Software SIG, and Programmer's Forum periodically. If you have
any suggestions about how to improve SNAP! or if you have encountered a bug,
please let me know.
My job requires me to travel frequently, and I am usually hard to reach by
telephone. You will probably have better success reaching me through
Compuserve or by mail.
Acknowledgements
Special thanks to Andy Walsh for writing several string procedures in
assembly language for me. Thanks to Peter Petto, Paul Ferrara and everyone
else who helped me develop and debug SNAP! Thanks to the Compuserve
Ashton-Tate and Programmers SIG for all the help their members gave me.
Thanks to Fred Fachet, Glen Harness and Jack Lohman for beta testing above
and beyond the call of duty. Thanks to Dave Heindel for helping me speed it
up. Thanks to Pat Adams for public relations.
40
Appendix A -- Sample Reports
The following sample reports illustrate the formats of some SNAP! output.
Since the documentation for a full system is voluminous, only limited
portions of the documentation are presented here. This saves much space,
but has the disadvantage of making some reports "out of sync." Thus, the
internal consistency of a complete package of documentation is missing here.
For example, if you try to trace the entries in the tree back to TODO.PRG,
you will discover that they don't track since I trimmed out much of TODO.PRG
so as to reduce the bulk of the documentation file. Similarly, the system
summary shows a lot of databases that aren't in the DATADICT.DOC file.
Of course, the best way to see sample SNAP! reports is to run it on some of
your own programs.
41
*:*********************************************************************
*:
*: Program: TODO.PRG
*:
*: System: ToDo -- To Do Management System
*: Author: Walter J. Kennamer
*: Copyright (c) 1988, Walter J. Kennamer
*: Last modified: 02/26/88 23:00
*:
*: Calls: HELP.PRG
*: : F2_HANDLR (procedure in TODOPRC.PRG)
*: : HELPEDIT (procedure in TODOPRC.PRG)
*: : TDDEFLT.PRG
*: : ERRORMSG (procedure in TODOPRC.PRG)
*: : SETDATE.PRG
*: : TDLOGO.PRG
*: : TDSETUP.PRG
*: : TDINPUT.PRG
*:
*: Memory Files: ACCESSES.MEM
*: : DEFAULT.MEM
*:
*: Documented: 03/02/88 at 18:39 SNAP! version 3.00
*:*********************************************************************
PARAMETERS c_line && command line
*# SNAPMACRO s_tdfile todo
*# SNAPMACRO s_ddndx tododd
*# SNAPMACRO s0_adfname address
external subject
PUBLIC clipper,s_cmdline
IF pcount() > 0
s_cmdline = Alltrim(UPPER(c_line))
ELSE
s_cmdline = ""
ENDIF
.
.
.
* read defaults
USE
IF FILE("default.mem")
REST FROM DEFAULT ADDITIVE
IF s0_bw
s0_montype = "M"
ELSE
s0_montype = "C"
ENDIF
ELSE
DO tddeflt
ENDIF
42
DO tdinput
*: EOF: TODO.PRG
43
System Summary
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:56:29
System Summary
-------------------------------------------------------------------------------
This system has:
8636 lines of code
46 program files
2 procedure files
84 procedures and functions
18 databases
8 index files
3 report forms
0 format files
0 label forms
5 memory variable files
622 cross-referenced tokens
See the tree diagram for programs, procedures, functions and format files
Index Report Label Memory
Databases Files Forms Forms Files
-------------- -------------- -------------- -------------- --------------
HELP.DBF HELPKEY.NTX SUBREPT.FRM ACCESSES.MEM
TODO.SKL SUBJECT.NTX TDSUMIN.FRM DEFAULT.MEM
TODO.DBF TODODD.NTX TDDETIN.FRM LASTFILE.MEM
SUBJECT.DBF &NTXNAME PRINTER.MEM
ADDRESS.DBF HISTDD.NTX CLIP.MEM
&B_FILE.DBF PRIORITY.NDX
NOTEPAD.DBF DATEDUE.NDX
PRTCODES.DBF DATEDUE.NTX
&FILE
HIST.DBF
TEMP.DBF
&FNAME
&BAK_NAME.DBF
&FNAME.DBF
AREACODE.DBF
DATEDUE.DBF
PRM.SKL
ADDRESS.ASC
------------------------------------------------------------------------------
44
SNAP! created the following documentation files:
C:\SCRATCH\STATS.DOC
C:\SCRATCH\TREE.DOC
C:\SCRATCH\FILELIST.DOC
C:\SCRATCH\NDXSUMRY.DOC
C:\SCRATCH\DATADICT.DOC
C:\SCRATCH\FRMSUMRY.DOC
C:\SCRATCH\PRCSUMRY.DOC
C:\SCRATCH\XREF.DOC
C:\SCRATCH\TODO.LNK
C:\SCRATCH\TODO.TLK
C:\SCRATCH\TODO.MLK
C:\SCRATCH\MAKEFILE
C:\SCRATCH\ERROR.DOC
Action diagram files
UPDATE.BAT to update program source files in C:\TODO
BACKDBF.BAT to backup databases, indexes and memory files
BACKPRG.BAT to backup program files, report forms and format files
PRINTDOC.BAT to print documentation files
45
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:56:09
Tree Diagram
-------------------------------------------------------------------------------
TODO.PRG
HELP.PRG
HELP.DBF (database)
SHOW_HELP (procedure in HELP.PRG)
SETCOLOR (procedure in TODOPRC.PRG)
CENTER (procedure in TODOPRC.PRG)
SETCOLOR (procedure in TODOPRC.PRG)
CENTER (procedure in TODOPRC.PRG)
F2_HANDLR (procedure in TODOPRC.PRG)
ADDRLIST.PRG
SETCOLOR (procedure in TODOPRC.PRG)
NUMLIST.PRG
SETCOLOR (procedure in TODOPRC.PRG)
HELPEDIT (procedure in TODOPRC.PRG)
TDDEFLT.PRG
SETCOLOR (procedure in TODOPRC.PRG)
SCRHEAD (procedure in TODOPRC.PRG)
SETCOLOR (procedure in TODOPRC.PRG)
TDSETUP.PRG
TODO.SKL (database)
TODO.DBF (database)
SUBJECT.DBF (database)
ADDRESS.DBF (database)
CENTER (procedure in TODOPRC.PRG)
SETDATE.PRG
SETPRT.PRG
PRTCODES.DBF (database)
SCRHEAD (procedure in TODOPRC.PRG)
SETCOLOR (procedure in TODOPRC.PRG)
ERRORMSG (procedure in TODOPRC.PRG)
SETCOLOR (procedure in TODOPRC.PRG)
CENTER (procedure in TODOPRC.PRG)
F2_HANDLR (procedure in TODOPRC.PRG)
ADDRLIST.PRG
SETCOLOR (procedure in TODOPRC.PRG)
NUMLIST.PRG
SETCOLOR (procedure in TODOPRC.PRG)
F3_HANDLR (procedure in TODOPRC.PRG)
and so forth
46
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:55:52
Procedure and Function Summary
-------------------------------------------------------------------------------
2 procedure files in the system
SUBJECT.PRG
TODOPRC.PRG
-------------------------------------------------------------------------------
SUBJECT.PRG -- Last updated: 12/30/87 at 8:47
Contains: SUBOK()
Calls: SETCOLOR (procedure in TODOPRC.PRG)
Calls: CENTER (procedure in TODOPRC.PRG)
Calls: PUTSUB (procedure in TODOPRC.PRG)
Contains: SUBLOOK()
Calls: SETCOLOR (procedure in TODOPRC.PRG)
.
.
.
Contains: SUBEDIT
Called by: ED() (function in SUBJECT.PRG)
Calls: SETCOLOR (procedure in TODOPRC.PRG)
-------------------------------------------------------------------------------
TODOPRC.PRG -- Last updated: 12/28/87 at 14:20
Contains: F2_HANDLR
Called by: TODO.PRG
Called by: TDDEFLT.PRG
Calls: ADDRLIST.PRG
Calls: NUMLIST.PRG
Contains: F3_HANDLR
Called by: TODO.PRG
Called by: TDDEFLT.PRG
Calls: SETCOLOR (procedure in TODOPRC.PRG)
Contains: F4_HANDLR
Called by: TODO.PRG
Called by: TDDEFLT.PRG
.
.
.
Contains: ISCTRL()
Contains: SCREEN_ON
Called by: ROLODEX.PRG
Contains: PRINT_ON
Called by: ROLODEX.PRG
47
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:55:42
Database Structure Summary
-------------------------------------------------------------------------------
3 databases in the system
HELP.DBF
TODO.DBF
SUBJECT.DBF
-------------------------------------------------------------------------------
Structure for database : HELP.DBF
Number of data records : 37
Last updated : 09/09/87 at 11:06
Field Field name Type Width Dec Start End
1 HCALLPRG Character 8 1 8
2 HINPUTVAR Character 12 9 20
3 HSCRNNUM Character 4 21 24
4 HELPMSG Memo 10 25 34
** Total ** 35
This database is associated with the memo file: HELP.DBT
This database appears to be associated with index file(s):
: HELPKEY.NTX (UPPER(hcallprg+hscrnnum+hinputvar))
SNAP! did not find any associated report forms
Used by: HELP.PRG
: TDFIX.PRG
: TDREINDX.PRG
: TDREPAIR (procedure in TDFIX.PRG)
-------------------------------------------------------------------------------
Structure for database : TODO.DBF
Number of data records : 112
Last updated : 03/01/88 at 17:35
Field Field name Type Width Dec Start End
1 ITEM Character 55 1 55
2 PRIORITY Character 1 56 56
3 DATE_DUE Date 8 57 64
4 CALTIME Character 5 65 69
5 COMPLETE Character 1 70 70
6 ADVANCE Numeric 3 71 73
7 DATE_ASGN Date 8 74 81
8 DATE_COMP Date 8 82 89
9 LATE Numeric 3 90 92
48
10 ITEMTYPE Character 1 93 93
11 ALARM Character 1 94 94
12 SUBJECT Character 30 95 124
13 DURATION Numeric 8 2 125 132
14 VERSION Character 5 133 137
** Total ** 138
This database appears to be associated with index file(s):
: TODODD.NTX (DTOS(date_due)+priority+caltime)
: DATEDUE.NDX (index key not found)
SNAP! did not find any associated report forms
Used by: TDSETUP.PRG
: TDINPUT.PRG
: OPENDATA (procedure in TDSETUP.PRG)
: EDITEXIT.PRG
: TDREDATE.PRG
: TDPURGE.PRG
: TDFIX.PRG
: TDCAL.PRG
: TDREINDX.PRG
-------------------------------------------------------------------------------
Structure for database : SUBJECT.DBF
Number of data records : 41
Last updated : 01/12/88 at 9:34
Field Field name Type Width Dec Start End
1 SUBCODE Character 20 1 20
2 SUBJECT Character 30 21 50
** Total ** 51
This database appears to be associated with index file(s):
: SUBJECT.NTX (UPPER(subject))
SNAP! did not find any associated report forms
Used by: TDSETUP.PRG
: TDINPUT.PRG
: OPENDATA (procedure in TDSETUP.PRG)
: TDREINDX.PRG
-------------------------------------------------------------------------------
49
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:55:49
Data Dictionary
-------------------------------------------------------------------------------
Note: the actual system used more than 3 databases. All but three were
removed above to save space. This portion of the report shows all of them.
Field Name Type Len Dec Database
ABBREV C 2 0 AREACODE.DBF
ADDRESS C 53 0 ADDRESS.DBF
ADVANCE N 3 0 TODO.SKL
TODO.DBF
HIST.DBF
ALARM C 1 0 TODO.SKL
TODO.DBF
HIST.DBF
AREACODE N 3 0 AREACODE.DBF
BPHONE C 12 0 ADDRESS.DBF
CALTIME C 5 0 TODO.SKL
TODO.DBF
HIST.DBF
CITIES C 78 0 AREACODE.DBF
CITY C 25 0 ADDRESS.DBF
COL N 2 0 PRTCODES.DBF
COMMENT C 50 0 ADDRESS.DBF
COMPANY C 53 0 ADDRESS.DBF
COMPLETE C 1 0 TODO.SKL
TODO.DBF
HIST.DBF
COMPRESS C 13 0 PRTCODES.DBF
COUNTRY C 20 0 ADDRESS.DBF
DATE_ASGN D 8 0 TODO.SKL
TODO.DBF
HIST.DBF
DATE_COMP D 8 0 TODO.SKL
TODO.DBF
HIST.DBF
DATE_DUE D 8 0 TODO.SKL
TODO.DBF
HIST.DBF
DURATION N 8 2 TODO.SKL
TODO.DBF
ELITE C 13 0 PRTCODES.DBF
FORMFEED C 13 0 PRTCODES.DBF
HCALLPRG C 8 0 HELP.DBF
HELPMSG M 10 0 HELP.DBF
HINPUTVAR C 12 0 HELP.DBF
HSCRNNUM C 4 0 HELP.DBF
50
ITEM C 55 0 TODO.SKL
TODO.DBF
HIST.DBF
ITEMTYPE C 1 0 TODO.SKL
TODO.DBF
HIST.DBF
LATE N 3 0 TODO.SKL
TODO.DBF
HIST.DBF
LINE C 78 0 TEMP.DBF
PRM.SKL
NAME C 30 0 ADDRESS.DBF
NAME C 25 0 PRTCODES.DBF
NOTES M 10 0 ADDRESS.DBF
NOTEPAD.DBF
PHONE C 12 0 ADDRESS.DBF
POSITION C 40 0 ADDRESS.DBF
PRIORITY C 1 0 TODO.SKL
TODO.DBF
HIST.DBF
PRTNUM N 2 0 PRTCODES.DBF
RESET C 13 0 PRTCODES.DBF
ROW N 2 0 PRTCODES.DBF
SECONDLINE C 53 0 ADDRESS.DBF
STATE C 2 0 ADDRESS.DBF
STATE C 15 0 AREACODE.DBF
SUBCODE C 20 0 SUBJECT.DBF
SUBJECT C 30 0 TODO.SKL
TODO.DBF
SUBJECT.DBF
HIST.DBF
VERSION C 5 0 TODO.SKL
TODO.DBF
NOTEPAD.DBF
ZIP C 10 0 ADDRESS.DBF
51
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:55:15
Index Parameter Summary
-------------------------------------------------------------------------------
5 index files in the system
HELPKEY.NDX
SUBJECT.NDX
TODODD.NDX
&NTXNAME
DATEDUE.NDX
-------------------------------------------------------------------------------
HELPKEY.NTX -- Indexed on: UPPER(hcallprg+hscrnnum+hinputvar)
Last updated: 09/09/87 at 11:06
This index file appears to be associated with database(s):
: HELP.DBF
Used by: HELP.PRG
: TDFIX.PRG
: TDREINDX.PRG
: TDREPAIR (procedure in TDFIX.PRG)
-------------------------------------------------------------------------------
SUBJECT.NTX -- Indexed on: UPPER(subject)
Last updated: 01/12/88 at 9:16
This index file appears to be associated with database(s):
: SUBJECT.DBF
Used by: SUBLOOK() (function in SUBJECT.PRG)
: PART_MATCH() (function in SUBJECT.PRG)
: TDSETUP.PRG
: TDINPUT.PRG
: OPENDATA (procedure in TDSETUP.PRG)
: TDFIX.PRG
: TDREINDX.PRG
: TDREPAIR (procedure in TDFIX.PRG)
-------------------------------------------------------------------------------
TODODD.NTX -- Indexed on: DTOS(date_due)+priority+caltime
Last updated: 03/01/88 at 17:35
This index file appears to be associated with database(s):
: TODO.DBF
52
Used by: TDSETUP.PRG
: TDINPUT.PRG
: EDITEXIT.PRG
: EDITSRCH.PRG
: TDREDATE.PRG
: TDPURGE.PRG
: EDITCHGE.PRG
: TDFIX.PRG
: PRTUNCMP.PRG
: TDREINDX.PRG
: TDREPAIR (procedure in TDFIX.PRG)
-------------------------------------------------------------------------------
&NTXNAME is a macro unknown to SNAP!
This index file appears to be associated with database(s):
: ADDRESS.DBF
Used by: TDSETUP.PRG
: OPENDATA (procedure in TDSETUP.PRG)
: ADDRESS.PRG
: TDFIX.PRG
: TDREINDX.PRG
: TDREPAIR (procedure in TDFIX.PRG)
: ADDRBOOK.PRG
: ROLODEX.PRG
-------------------------------------------------------------------------------
File not found--DATEDUE.NDX
This index file appears to be associated with database(s):
: TODO.DBF
Used by: TDCAL.PRG
: TDCALDAY.PRG
53
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:55:50
Report Form File Summary
-------------------------------------------------------------------------------
2 report forms in the system
SUBREPT.FRM
TDSUMIN.FRM
-------------------------------------------------------------------------------
SUBREPT.FRM Last updated: 08/24/87 at 10:14
Summary report? No
Eject page before printing? No Eject page after printing? Yes
Double space report? No Plain page? No
Left margin: 8 Right Margin: 0
-------------------------------------------------------------------------
Report Contents
-------------------------------------------------------------------------
No. Field Length Decimals Totaled?
--- ---------------------------------- ------ -------- --------
1 Subject 40 0 No
2 Subcode 25 0 No
-----
65
=====
-----------------------------------------------------------------------------
Report Layout
------------------------------------------------------------------------------
Page No. 1
00/00/00
Subject Codes
Subject Charge Code
1 2
-----------------------------------------------------------------------------
Database and Program References
-----------------------------------------------------------------------------
54
SNAP! could not find an associated database
Used by: SUBREPT (procedure in SUBJECT.PRG)
55
TDSUMIN.FRM Last updated: 09/01/87 at 15:17
Summary report? No
Eject page before printing? Yes Eject page after printing? Yes
Double space report? Yes Plain page? No
Left margin: 1 Right Margin: 0
-------------------------------------------------------------------------
Report Contents
-------------------------------------------------------------------------
No. Field Length Decimals Totaled?
--- ---------------------------------- ------ -------- --------
1 "______" 6 0 No
2 RECNO() 4 0 No
3 Item 55 0 No
4 " "+dtoc(date_due) 9 0 No
5 Caltime 6 0 No
6 " "+priority 5 0 No
-----
85
=====
-----------------------------------------------------------------------------
Report Layout
-----------------------------------------------------------------------------
Page No. 1
00/00/00
Uncompleted Items
No. Item Due Date Time Pri.
=== =========================================== ========= ===== =====
1 2 3 4 5 6
-----------------------------------------------------------------------------
Database and Program References
-----------------------------------------------------------------------------
SNAP! could not find an associated database
Used by: PRTUNCMP.PRG
56
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:55:58
Token Cross-Reference Report
-------------------------------------------------------------------------------
622 tokens are included in this report.
Legend for context symbols:
(blank) reference does not change the variable or field value.
= variable or field is changed in an assignment statement.
x variable is released.
A array is declared.
G GET statement changes variable or field.
P variable is declared PUBLIC.
R field is replaced.
U database is USEd
V variable is declared PRIVATE.
& variable is referenced in a macro--takes preference over all others.
@ variable passed as a var parameter--Clipper only
? reference is of unknown type.
ABBREV
AREACODE.PRG 90 134 178
ABORT
TDINPUT.PRG 62x 67P 306=
EDITSRCH.PRG 35= 69= 99=
EDITCHGE.PRG 32=
ACCESSES
TODO.PRG 130
TDEXIT.PRG 24
.
.
.
YESNO
ADDRESS.PRG 476= 482G 482 484 663= 664 665= 668G 668 672
748= 751G 751 753
YR
TDCOPY.PRG 109= 116= 116 122 126 128 224 226 241= 248=
248 255 262 264 277
ZIP
ADDRESS.PRG 130 227 282 301R 336R 363
ADDRBOOK.PRG 85 86 88
ROLODEX.PRG 180 181 183
57
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:56:06
Public Variable Summary
-------------------------------------------------------------------------------
These variables were declared PUBLIC somewhere in the system.
Some may also be used as private variables in some parts of the code.
ABORT ADDR_MROW
ANSWER CARD_ROWS
CLIPPER CMD_LINE
C_OFFSET DATE_STR
.
.
.
S_TESTDATE S_VERSION
T_COMP T_DATED
T_DUR T_ITEM
T_ITEMTYPE T_PRIOR
T_SUBJ T_TIME
58
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:56:06
Macro Summary
-------------------------------------------------------------------------------
Macros Defined to SNAP!
----------------------------------------------------------------------------
Variable Expansion
-------------- ---------------------------------
S_TDFILE TODO
S_DDNDX TODODD
S0_ADFNAME ADDRESS
----------------------------------------------------------------------------
Macros Not Defined to SNAP!
----------------------------------------------------------------------------
&BAK_NAME &B_FILE
&COLR_STR &FIELD1
&FIELD2 &FIELD_NAME
&FILT_STR &FLDNAME
&FNAME &IN_DB
&IN_SELECT &IN_VAL
&M_WORKAREA &NTXNAME
&NUM &PROGNAME
&REP_FNAME &REV_COLR
&S0_COLR1 &S0_COLR2
&S0_DATA &S0_PRMNAME
&S0_PROGRAM &S0_USERFILT
&SRCHFLD &TEMPIN
-------------------------------------------------------------------------------
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:56:06
Array Summary
-------------------------------------------------------------------------------
An array declared with a variable (e.g., DECLARE foo[bar])
will be shown as having a size of [var].
FIELD_LENGTH[var]
FIELD_LIST[2]
59
System: ToDo -- To Do Management System
Author: Walter J. Kennamer
03/02/88 18:56:29
File List
-------------------------------------------------------------------------------
Programs and procedures:
ADDRBOOK.PRG
ADDRESS.PRG
ADDRFILT() (function in ADDRESS.PRG)
ADDRLIST.PRG
.
.
.
TIMEFORM() (function in TDCALDAY.PRG)
TODO.PRG
UNHIGHLIGHT (procedure in SHOWCAL.PRG)
VERPRT.PRG
Procedure files:
SUBJECT.PRG
TODOPRC.PRG
Databases:
.
.
.
HELP.DBF
HELP.DBT
SUBJECT.DBF
TODO.DBF
Index files:
&NTXNAME
DATEDUE.NDX
DATEDUE.NTX
HELPKEY.NTX
HISTDD.NTX
PRIORITY.NDX
SUBJECT.NTX
TODODD.NTX
Report forms:
SUBREPT.FRM
TDDETIN.FRM
TDSUMIN.FRM
Memory files:
ACCESSES.MEM
CLIP.MEM
DEFAULT.MEM
60
LASTFILE.MEM
PRINTER.MEM
61
Index
Abbreviations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Acknowledgements . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Action diagrams . . . . . . . . . . . . . . . . 3, 5, 7, 15, 28-31, 36, 45
User-defined symbols . . . . . . . . . . . . . . . . . . . . . . . 29
Ashton-Tate . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1, 40
Author . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Backup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4, 27
Importance of . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Batch files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Backing up databases and indexes . . . . . . . . . . . . . . . . . 27
Backing up programs . . . . . . . . . . . . . . . . . . . . . . . . 27
Printing SNAP! documentation files . . . . . . . . . . . . . . . . 27
Updating source code files . . . . . . . . . . . . . . . . . . . . 27
Batch operation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Blank lines, suppression of . . . . . . . . . . . . . . . . . . . . . . 18
Capitalization . . . . . . . . . . . . . . 3, 7, 13, 15-17, 25, 29, 36, 39
Clipper . 1, 3, 4, 8, 13, 18, 21, 23, 25, 26, 28, 30, 34, 35, 38, 39, 42,
57, 58
Index files . . . . . . . . . . . . . . 8, 21, 32, 44, 48, 49, 52, 60
Colors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Command line switches
/BW -- black and white . . . . . . . . . . . . . . . . . . . . . . 37
/F -- configuration file name . . . . . . . . . . . . . . . . . . . 6
/L -- LINK file name . . . . . . . . . . . . . . . . . . . . . . . 26
/M -- macro file . . . . . . . . . . . . . . . . . . . . . . . . . 10
/O -- omit macros . . . . . . . . . . . . . . . . . . . . . . . . . 10
/S -- screen suppress . . . . . . . . . . . . . . . . . . . . . . . 19
/T -- SNAP! tag (changing *#) . . . . . . . . . . . . . . . . . . . 13
/X -- immediate mode (batch) . . . . . . . . . . . . . . . . . . . 33
Comments
Putting them back in, design difficulties surrounding . . . . . . . 17
Suppression of . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Compuserve . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
CONFIG.SNP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6, 33
Configuration file . . . . . . . . . . . . . . . . . . . . . . . 6, 30, 33
CONFIG.SNP . . . . . . . . . . . . . . . . . . . . . . . . . . 6, 33
Saving configuration settings . . . . . . . . . . . . . . . . . . . 6
Continuation lines . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Control structure . . . . . . . . . . . . . . . . . . . 15, 28, 30, 35, 36
Copyright holder . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Cross-reference . . 3, 5, 7, 12, 13, 17-19, 23-25, 31, 35, 36, 38, 39, 45,
57
Excluding certain variables from . . . . . . . . . . . . . . . . . 25
Key words . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Legend . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Limitation on type flagging . . . . . . . . . . . . . . . . . . . . 24
Limiting to PUBLIC variables . . . . . . . . . . . . . . . . . 23, 25
Numeric constants . . . . . . . . . . . . . . . . . . . . . . . . . 23
62
Quoted strings excluded from . . . . . . . . . . . . . . . . . . . 23
What is included . . . . . . . . . . . . . . . . . . . . . . . . . 23
Data dictionary . . . . . . . . . . . . . . . . . . . . . 3, 19-21, 39, 50
Databases . . 3, 6-8, 11, 14, 19-22, 24, 27, 35, 38, 39, 41, 44-46, 48-50,
52-57, 60
dBASE II . . . . . . . . . . . . . . . . . . . . . . . . 1, 4, 8, 21-23, 36
dBASE III . . . . . . . . . . . . . . . . . 1, 4, 6, 8, 18, 21, 25, 26, 39
DBxWORDS.SNP . . . . . . . . . . . . . . . . . . . . . . . . . . 15, 16, 25
DB2WORDS.SNP . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
DB3WORDS.SNP . . . . . . . . . . . . . . . . . . . . . . . 4, 18, 25
Documentation files
Printing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Elapsed time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Errors . . . . . . . . . . . . . . . . . . . . . . . . . 7, 15, 29, 33, 45
ERROR.DOC . . . . . . . . . . . . . . . . . . . . . . . . . . . 7, 45
Field names . . . . . . . . . . . . . . . . . . . . . . . . 16, 23, 48-50
File headings . . . . . . . . . . . . . . . . . . . . . . . . . . 3, 5, 14
File names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Format files . . . . . . . . . . . . . . 3, 6-8, 11, 14, 19, 22, 27, 44, 45
Format screen . . . . . . . . . . . . . . . . . . . . . . 5, 15-17, 29, 31
FoxBASE . . . . . . . . . . . . . . . . . . . . . . . 1, 4, 8, 21, 25, 38
Index files . . . . . . . . . . . . . . . . . . . . . . . . 8, 21, 32
Functions
Capitalization of . . . . . . . . . . . . . . . . . . . . . . . 18, 25
Hardware, why you should buy more . . . . . . . . . . . . . . . . . . . 35
Help . . . . . . . . . 4, 6, 12, 15, 21, 34, 40, 42, 44, 46, 48, 50, 52, 60
Immediate mode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Immediate source code printing . . . . . . . . . . . . . . . . . . 32
Indentation . . . . . . . . . . . . . . . . . . . 3, 7, 12, 13, 15, 36, 39
Index file . . . . . . . . . . 3, 8, 14, 20-22, 27, 44, 48, 49, 52, 53, 60
NDX extensions . . . . . . . . . . 21, 22, 32, 39, 44, 49, 52, 53, 60
Input . . . . . . . . . . . . . . . . . . . . . . 5, 6, 8, 14, 23, 30, 33
Key words . . . . . . . . . . . . . . . . . 4, 7, 13, 16-18, 23-25, 28, 35
Capitalization . . . . . . . . . . . 3, 7, 13, 15-17, 25, 29, 36, 39
Cross-referencing of . . . . . . . . . . . . . . . . . . . 17, 23, 25
DBxWORDS.SNP . . . . . . . . . . . . . . . . . . . 4, 15, 16, 18, 25
Expansion or compression . . . . . . . . . . . . . . . . . . . . . 16
Perverse use of, punishment for . . . . . . . . . . . . . . . . . . 7
Special characters in file . . . . . . . . . . . . . . . . . . 17, 24
Label forms . . . . . . . . . . . . . . . . . . . . 8, 14, 19, 20, 39, 44
License . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Link . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3, 26, 39
/L switch -- file name for standard LINK statements . . . . . . . . 26
LINK.SNP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
PLINK86 . . . . . . . . . . . . . . . . . . . . . . . . . . 3, 26, 39
MACRO.SNP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Macros . . . . . . . . . . . . 6, 10-12, 14, 20, 24, 27, 33, 39, 53, 57, 59
/M switch -- macro file . . . . . . . . . . . . . . . . . . . . . . 10
/O switch -- omit macros . . . . . . . . . . . . . . . . . . . . . 10
Ampersand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
MACRO.SNP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
63
Paths . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
SNAPMACRO . . . . . . . . . . . . . . . . . . . . . . . . . . . 10, 15
Make
Make files . . . . . . . . . . . . . . 3-5, 8, 14-17, 26, 27, 35, 39
MAKE.INI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
MAKEFILE . . . . . . . . . . . . . . . . . . . . . . . . . 26, 27, 45
Memory files . . . . . . . . . . . . . 3, 6, 8, 11, 14, 19, 27, 42, 45, 60
Memory requirements . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Nantucket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Other screen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Output . . . . . . . . . . . . . . . . . 3-6, 14, 16-18, 25, 27, 29, 39, 41
Paths . . . . . . . . . . . . . . . . . . . . . . . . . 4-6, 8, 11, 28, 35
PLINK86 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3, 26, 39
LINK.SNP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Print screen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
PRIVATE variables . . . . . . . . . . . . . . . . . . . . . 23-25, 57, 58
Procedure files . 3, 7, 12, 13, 19, 23, 35-37, 42, 44, 46-49, 52, 53, 55,
60
Unique name requirement . . . . . . . . . . . . . . . . . . . . . . 36
PUBLIC variables . . . . . . . . . . . . . . 13, 23-25, 39, 40, 42, 57, 58
Questions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Quicksilver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Recursion (see Recursion) . . . . . . . . . . . . . . . . . . . . . . . 20
Registration (optional) . . . . . . . . . . . . . . . . . . . . . . . . 40
Report forms . . . . . . 3, 6-8, 14, 19, 20, 22, 27, 44, 45, 48, 49, 54, 60
Rettig, Tom . . . . . . . . . . . . . . . . . . . . . . 1, 13, 16, 18, 25
SNAP directives
Changing *# . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
SNAP FORMAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
SNAP XREF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12, 13
SNAP.DOC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
SNAP.EXE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
SNAP.HLP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
SNAP! directives
FORMAT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
SNAPCODE . . . . . . . . . . . . . . . . . . . . . . . . . 11-13, 21
SNAPMACRO . . . . . . . . . . . . . . . . . . . . . . . 10-13, 20, 42
XREF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12, 13
SNAPCODE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11, 12
SNAPMACRO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10, 15
Source Code Printout . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Printing documentation files . . . . . . . . . . . . . . . . . . . 32
Printing without documenting . . . . . . . . . . . . . . . . . . . 32
What files are not printed . . . . . . . . . . . . . . . . . . . . 32
Status . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Support, how to get . . . . . . . . . . . . . . . . . . . . . . . . . . 40
System screen . . . . . . . . . . . . . . . . . . . . . . . . . . 4, 7, 11
Tabs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7, 15, 31
Spaces instead of . . . . . . . . . . . . . . . . . . . . . . . . . 15
TLINK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3, 26, 39
TopFile . . . . . . . . . . . . . . . . . . . . . . . 4, 5, 8, 11, 27, 34
Explanation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
64
Tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Tree screen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Turbo Linker . . . . . . . . . . . . . . . . . . . . . . . . . . 3, 26, 39
Turbo Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3, 38
Updates, how to get . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Version numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
65