Enter your search terms Submit search form
	Web pdp-10.trailing-edge.com

.SPACING 1
.TAB STOPS 8,16,24,32,40,48,56,64,72
^^

.BREAK
.LEFT MARGIN 0
.ps	60,70

.BREAK
.LEFT MARGIN 0
.title	IND - Enhanced, programmable command files for TOPS20
.LEFT MARGIN 0
.figure 13
.LEFT MARGIN 0
.center
IND - Enhanced, programmable command files for TOPS20
.LEFT MARGIN 0
.center
=======================================================
.SKIP 1
.note
This document describes the IND program, a utility which offers advanced
command file facilities. IND will process all standard EXEC "TAKE" files,
as well as offering extra features. It is thus easy to start to use, and offers
powerful tools for those who have the time the find out about them.
.end note
.LEFT MARGIN 0
.page
.note

     The copyright in the computer program described in this  document  and
in the associated user instructions is the property of Kevin Ashley.

     The information in this document is subject to change  without  notice
and  should  not be construed as a commitment by Kevin Ashley, who
  assumes no responsibility for any errors which may appear in
this document.

     The software described in this document is supplied  under  a  licence
and  may  only  used  or copied in accordance with the conditions of such a
licence.  The licence conditions state that this software shall be supplied
free  of  charge and shall not be sold or otherwise disposed of by means of
trade or ortherwisw for any form of profit or advantage.  Possesion or  use
of  the  software  shall  be  deemed as acceptance of the conditions of the
licence.

     No guarantee is given or may be implied as  to  the  adequacy  of  the
program  or  its suitability for any particular purpose and no liability is
accepted for any loss or damage arising out of its use.
.end note
.page
.LEFT MARGIN 0
.subttl Overview
.SKIP 1
.LEFT MARGIN 0
.hl 1 Overview
.INDENT 8
IND is a program which offers command file facilities which are a far
more powerful, yet totally compatible superset of standard TOPS20 EXEC TAKE
files. The extra facilities offered by IND include the following:
.SKIP 1

.BREAK
.LEFT MARGIN 8
o	Labels, GOTOs, and subroutines (GOSUB, RETURN)

.BREAK
.LEFT MARGIN 8
o	Variables which are set at execution time

.BREAK
.LEFT MARGIN 8
o	Logical, numeric and string comparisons

.BREAK
.LEFT MARGIN 8
o	Conditional execution of commands

.BREAK
.LEFT MARGIN 8
o	Interaction with the user via special question/answer directives

.BREAK
.LEFT MARGIN 8
o	Ability to create data files

.BREAK
.LEFT MARGIN 8
o	Ability to read input data files

.BREAK
.LEFT MARGIN 16
.INDENT -8
o	Creation of terminal log files recording the command file session,
in a similar manner to PHOTO.

.BREAK
.LEFT MARGIN 16
.INDENT -8
o	Picking up of parameters for the command file from an EXEC command line

.BREAK
.LEFT MARGIN 8
o	Ability to test such things as user name, privileges, etc.
.BREAK
.LM 8
o	Date handling, with conversion of string to numeric dates, and vice versa
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
IND was inspired directly via its RSX-11M/D/M-PLUS counterpart, also
known as IND, ICP or AT. Its general syntax and functionality owes everything to its
forebear, but advantage has been taken where possible of extra features that can
be offered to the TOPS20 user that would not be feasible under RSX. Similarly,
features provided under RSX which are of little use, or are meaningless in, the
TOPS20 environment have been removed in IND-20.
.SKIP 1
.LEFT MARGIN 0
.page
.LEFT MARGIN 0
.subttl Introduction

.BREAK
.LEFT MARGIN 0
.hl 1	Introduction
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
An indirect command file (also known as TAKE file) is a file containing
a set of commands for the TOPS20 EXEC that you would normally type at a terminal.
In addition, it can also contain special commands that allow you to control the
execution of the command file itself. To initiate an IND file, type IND followed
by the name of the command file to the TOPS20 prompt. If your system has a PCL
EXEC, you may also find that you can run a command file by typing CMD filename.
This is usually much easier, as it permits you to use recognition (ie, pressing
the escape key to fill out the filename).
.SKIP 1
.LEFT MARGIN 0
@IND CONTROL
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The assumed file type is .CMD, thus the preceding command causes further
commands to be taken from CONTROL.CMD . For other file types, specify the file
type explicitly. An indirect command file can contain any EXEC command that
you could type at your terminal (with the exception of LOGOUT or BYE.) It may
also contain commands to other programs that it runs. Thus, the simplest type
of command file is merely a sequence of commands to the EXEC and to programs
that are run. For example, a command file to compare two files and print the
differences might look like this:
.lit
FILCOM
OUT.SCM=INPUT1.FIL,INPUT2.FIL
^C
PRINT OUT.SCM/DELETE

.end literal
	This simply runs the FILCOM program, produces a file consisting of the
differences between two other files, and prints the output. If the above commands
were in a file called F.CMD, you would run them like this:
.break
.indent 20
@IND F
.break
	However, this command file is very limited. Although it is already
more powerful than an ordinary command file (which could not contain commands
to the FILCOM program), it still is not very useful. The filenames used are
fixed - it might be nice to set them up as we run the command file. Also,
we might not want to print the output if, after we run FILCOM, we see that
it is not worth printing. IND allows you to do all this, and more. This is where
the special IND directives come into their own.
	 Command files can be
nested, ie can invoke other command files, up to a current limit of 4 deep.
.INDENT 8
When the end of the highest level file is reached, the message
.SKIP 1
.LEFT MARGIN 0
@ <EOF>
.SKIP 1
.LEFT MARGIN 0
is displayed on the screen. To exit from a command file prematurely, type
CTRL/Z in response to any request for input from IND, or type CTRL/A while IND
is running. If you use CTRL/A, any output that was being produced will probably
have disappeared. You should only do this if it is really necessary..
.SKIP 1
.LEFT MARGIN 0
.INDENT 16
When processing a command file IND first reads each line to
determine if it is a command intended for TOPS20, a special directive to IND
itself, or just a message to be typed on the screen. The directives to IND
are distinguished by a period (.) as the first character in the line.
TOPS20 commands have no special prefix characters. Messages to the user are
prefixed by a semicolon (;). The directives to IND form a primitive language,
which allows you to:
.SKIP 1
.BREAK
.LEFT MARGIN 8
o Define labels
.BREAK
.LEFT MARGIN 8
o Define and assign values to symbols of 5 types: logical, numeric,
.BREAK
.LEFT MARGIN 8
floating point, string and file.
.BREAK
.LEFT MARGIN 8
o Create and access data files
.BREAK
.LEFT MARGIN 8
o Control the logical flow of the command file
.BREAK
.LEFT MARGIN 8
o Perform logical tests
.BREAK
.LEFT MARGIN 8
o Enable or disable any of a number of operating modes
.BREAK
.LEFT MARGIN 8
o Increment or decrement numeric symbols
.BREAK
.LEFT MARGIN 8
o Control execution of subsidiary tasks or programs.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The IND directives are listed below by category. A detailed description
of each directive is presented in alphabetical order in the next section.
.SKIP 1
.LEFT MARGIN 0
.page

.BREAK
.LEFT MARGIN 0
.subttl	Directives (summary)

.BREAK
.LEFT MARGIN 0
.hl 1		DIRECTIVES (SUMMARY)
.SKIP 1
.LEFT MARGIN 0
Label definition:
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.label:		Assigns a name to a line in the command file so that the line
may be referenced.
.SKIP 1
.LEFT MARGIN 0
Symbol definition:
.FILL ;.JUSTIFY
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.ASK		Defines or redefines a logical symbol by asking the user a Y/N
question and assigns the logical symbol a true or false value.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.ASKN		Defines or redefines a numeric symbol by asking the user a
question and assigns a numeric value to the symbol.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.ASKR		Defines or redefines a floating point symbol by asking the user a
question and assigns a floating point value to the symbol.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.ASKS		Defines or redefines a string symbol by asking the user a
question and assigns the symbol a value which is a string of
text.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.ASKF		Defines or redefines a file symbol by prompting the user for a
filename and associates the symbol with that filename.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.FILE/.LOGICAL/.NUMERIC/.REAL/.STRING	Allow you to declare symbols and their
types in advance of use, and initialize to default values.
.SKIP 1

.BREAK
.LM 16
.INDENT -15
_.PARSE		Breaks a string into substrings by looking for specific
characters that break up the string.
.SKIP 1

.BREAK
.LM 16
.INDENT -15
_.CODE		Gets the ASCII value of a character.
.SKIP 1

.BREAK
.LM 16
.INDENT -15
_.TRIM/PAD	Remove or add trailing blanks or tabs from a string.
.skip 1
.lm 16
.break
.indent -15
_.RAISE/.LOWER		Makes strings upper or lower case.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.SETT/.SETF	Defines or redefines a logical symbol and assigns the symbol a
true or false value.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.SETN		Defines or redefines a numeric symbol and assigns the symbol a
numeric value.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.SETR		Defines or redefines a floating point symbol and assigns the symbol a
floating point value.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.SETFI		Defines or redefines a file symbol and assigns the symbol a
file value.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.SETS		Defines or redefines a string symbol and assigns the symbol a
character string value.
.BREAK
.SKIP 1

.LEFT MARGIN 16
.INDENT -15
_.PURGE		Removes the definition of a symbol or set of symbols.
.BREAK
.SKIP 1

.LEFT MARGIN 16
.INDENT -15
_.RADIX		Sets the current radix for reading in whole numbers, and
for outputting them.
.SKIP 1
.LM 0
Date handling:
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.DAYTON	Converts a date string in a fairly arbitrary format to a
Smithsonian day number.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.NTODAY	Converts a Smithsonian day number to a date in text.
.SKIP 1
.LEFT MARGIN 0
File access:
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.DATA		Specifies a single line of data to be sent to an output file.
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.CLOSE		Closes an output data file.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.READ	Reads a line of data from an input file into a string variable.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.CLOSEI	Closes an input file.
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.OPEN		Opens an output data file (creates a new version if necessary).
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.OPENA		Opens an existing output data file and appends data to it.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.OPENI	Opens an input file.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.REWIND	Rewinds an input file to start of file.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.POSITION		Positions an input file to a specific byte in the file.
.SKIP 1
.LEFT MARGIN 0
Logical control:
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.CALL		Invokes another IND file, keeping all symbols defined.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.GOSUB		Branches to a label identifying a subroutine within the command
file.
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.GOTO		Branches to a label within a command file.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.RETURN		Effects an exit from a subroutine - returns control to the line
following the .GOSUB that called it.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.RUN		Runs a program, but allows input for the program to come from
the terminal rather than the command file.
.skip 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.TELL	Places a single command in the input buffer of a program run by
	the _.RUN directive.
.SKIP 1

.break
.lm 1
_.EXIT		Terminates IND without a message.
.skip 1

.BREAK
.LEFT MARGIN 1
_.STOP		Terminates the current command file.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.LOGFILE	Specifies a file to be used to log terminal I/O to.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.ENDLOG	Closes a logfile and releases pseudo terminal.
.SKIP 1
.LEFT MARGIN 0
Logical tests:
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.IF		Determines whether or not a string or numeric symbol satisfies
one of a number of possible conditions.
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.IFDF/.IFNDF	Determines whether or not a symbol is defined.
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.IFT/.IFF	Determines whether a logical symbol is true or false.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.indent -15
_.TEST		Tests the length of a string symbol, and checks for whether it
	is alphabetic, alphanumeric or numeric.
.SKIP 1

.BREAK
.LEFT MARGIN 0
.INDENT 1
_.TESTFILE	Tests to see if a file exists.
.BREAK
.SKIP 1
.LEFT MARGIN 0
Enable/disable operating mode:
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.DISABLE/.ENABLE	Turns on or off the following parameters:
Substitution, command echoing, data mode, extended EXEC, trace,
CTRL/Z recognition, execution of COMAND.CMD, logging to PHOTO-type file,
ability of lower fork to logout job.
.skip 1

.break
.lm 16
.indent -15
_.DELIM		Changes the character used for substitution.
.SKIP 1
.LEFT MARGIN 0
Loop control:
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.INC		Increments the value of a numeric symbol.
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.DEC		Decrements the value of a numeric symbol.
.SKIP 1
.LEFT MARGIN 0
Execution control:
.SKIP 1

.BREAK
.LEFT MARGIN 1
_.DELAY		Delays further execution for the specified number of seconds.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.PAUSE		Stops the indirect command file temporarily, allowing the user
to enter commands to TOPS20.
.SKIP 1
.LM 0
Miscellaneous:
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.DISPLAY	Displays a string symbol without translation and without leading/trailing
cr/lfs. Useful for screen control.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.STATUS		Dumps the symbol table and various performance counts
	to the screen.
.SKIP 1

.BREAK
.LEFT MARGIN 16
.INDENT -15
_.DDT		Merges DDT and causes an unsolicited breakpoint.
.SKIP 1

.LEFT MARGIN 0
.page

.BREAK
.LEFT MARGIN 0
.subttl	Symbols

.BREAK
.LEFT MARGIN 0
.hl 1		SYMBOLS
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The indirect command file processor allows you to define symbols.
These symbols can then be tested or compared in order to control flow through
the command file. They may also be substituted for EXEC commands, data to files,
or comments to be displayed at the terminal. The word 'symbol' is used
interchangeably with 'variable'. They mean the same thing. If you are used to programming
languages like FORTRAN or BASIC, you will probably find it easier to think of
these things as variables. The essential concept is that they are names for
numbers or sets of characters that have been read from a terminal or file,
or produced by combining other such sets of things.

.INDENT 8
Symbol names are strings of characters from 1 to 9 characters in length.
They must start with a letter(a-z) or dollar sign ($). The remaining characters
must be alphanumeric or dollar. There are 5 symbol types:
.SKIP 1

.BREAK
.LEFT MARGIN 8
o	Logical

.BREAK
.LEFT MARGIN 8
o	String

.BREAK
.LEFT MARGIN 8
o	Numeric

.BREAK
.LEFT MARGIN 8
o	Real or floating point

.BREAK
.LEFT MARGIN 8
o	File
.SKIP 1
.LEFT MARGIN 0
A logical symbol has either a true or false value.
.SKIP 1
.LEFT MARGIN 0
A string symbol has as its value a string of ASCII characters, with a length
between 0 and 120 characters inclusive.
.SKIP 1
.LEFT MARGIN 0
A numeric symbol can have a value in the range -131070 to +131069 inclusive.
.SKIP 1
.LM 0
A floating point or real symbol has as its value a real number, ranging through
the permissible range for single precision real numbers on the DEC20 (about
+/- 10E+/-39).
.SKIP 1
.LEFT MARGIN 0
A file symbol has as its value a TOPS20 filespec, including any optional
protection value, account string, etc.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
A symbol's type (logical, numeric, etc.) is determined by the first
directive that assigns a value to it. Subsequent assignments may change the
symbol value, but cannot redefine its type. A variable may also be declared and
initialized by a .FILE, .NUMERIC, .REAL, .LOGICAL or .STRING directive. If a variable is
removed with the .PURGE directive, then its type and value are forgotten. It
may be redefined with a new type.

.SKIP 1

.BREAK
.LEFT MARGIN 0
.hl 2	SPECIAL SYMBOLS
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
IND automatically defines certain special symbols dependant on system
characteristics and enquires made by the command file itself. As with ordinary
symbols, special symbols can be of any of 5 types, and can be compared, substituted,
and tested. All system symbols have a common format; angle brackets (<>) enclose
the special symbol names.
.SKIP 1

.BREAK
.LEFT MARGIN 0
&S&y&m&b&o&l& &n&a&m&e	&T&y&p&e			&V&a&l&u&e&
.SKIP 1

.BREAK
.LEFT MARGIN 32
.INDENT -32
<STRLEN>	Numeric		Length of last string symbol in .TEST
directive, or entered in response to .ASKS.

.BREAK
.LEFT MARGIN 32
.INDENT -32
<SYSTEM>	String		Name of system as printed when a CTRL/C is
struck to login, eg
.LEFT MARGIN 0
.INDENT 22
Installation test system,TOPS20 Monitor 4(3417).

.BREAK
.LEFT MARGIN 0
<DATE>		String		Current date in form 25-Dec-81.

.BREAK
.LEFT MARGIN 0
<TIME>		String		Current time in form 13:00:00

.BREAK
.LEFT MARGIN 0
<USER>		String		User name of current job, eg T-BENN

.BREAK
.LEFT MARGIN 32
.INDENT -32
<DIRECTORY>	String		Currently connected directory, with structure,eg
PS:<K-LIVINGSTONE>
.break
.left margin 0
<FILESTAT>	Numeric		Result of last .TESTFILE directive.
.break
.left margin 32
.indent -32
<EOF>		Logical		Set to TRUE if currently open input file is
                            at end of file. False otherwise, or if no
                                 input file has been selected.
.break
.lm 32
.indent -32
<ACCOUNT>	String		Account in use by the job, as in DOCAS.
.break
.lm 32
.indent -32
<ALPHA>		Logical		Set by the .ASKS, .TEST and .READ directives to
                                true if the last string processed by them
                                contained only alphabetic characters.
.break
.lm 32
.indent -32
<ALPHANUM>	Logical		As <ALPHA>, except that this variable tells
                                you if the string was alphanumeric or not.
.break
.lm 32
.indent -32
<DISKUSED>	Numeric		Equal to the total number of pages used in the
                                currentLY connected directory.
.break
.lm 32
.indent -32
<JOB>		Numeric		Job number
.break
.lm 32
.indent -32
<LIQUOTA>	Numeric		Working storage quota (in pages) of currently
                                connected directory.
.break
.lm 32
.indent -32
<LOQUOTA>	Numeric		Permanent storage quota.
.break
.lm 32
.indent -32
<NUMERIC>	Logical		Set to true if last string read by .ASKS, .TEST
                                or .READ contained only numeric characters.
.break
.lm 32
.indent -32
<TERLEN>	Numeric		Terminal length in lines/page
.break
.lm 32
.indent -32
<TERMINAL>	Numeric		Controlling terminal number of current job
NOTE: this is decimal, whereas TOPS-20 has
them in octal.
.break
.lM 32
.indent -32
<BYTEPOS>	Numeric		Current position of input file opened with
_.READ directive, as the number of the next byte which will be read, or -1
if no file is open. Used in conjunction with .POSITION.
.SKIP 1

.break
.lm 32
.indent -32
<TERWID>	Numeric		Width in characters/line of terminal
.SKIP 1

.BREAK
.LM 0
.LITERAL
<FILDEV>,<FILDIR>,		These symbols are all set by the TESTFILE
<FILNAM>,<FILTYP>,		directive to indicate the device, directory
<FILGEN>,<FILPRO>,		name, type, generation, protection, account
<FILACT>,<FILCRE>,		and date/time of creation and read of the
<FILRED>			specified file. They are all string symbols.

<FILPAG>,<FILSIZ>,		These are also set up by the .TESTFILE
<FILBYS>			directive with the number of pages, bytes,
				byte size of the file, if it is online. They
				are numeric symbols.

.END LITERAL
.BREAK
.SKIP 2
.LEFT MARGIN 0
.indent 8
Other special symbols can be set up by the command that invoked IND itself.
It is possible to pass parameters to the command file by including them after
the command file name, as below:
.BREAK
@IND indgen filename <This is a complex parameter> 3
.break
.skip
	These set upto 9 parameters called P1 to P9, which are all text
string variables. If a parameter is not supplied on the command line, its
associated variable will be null (eg in the above example, P4 to P9 will be
the null string.) The parameters are usually separated by spaces, but if you
wish to include special characters or spaces in a parameter, you can emclose
that parameter in any sort of brackets: curly, round, angle or square to
delimit it, as has been done above. You can also use double quotes to delimit
the string. Using one quoting mechanism allows you to use any of the others
within the string, without their having a special meaning (so you can use
unbalanced curly brackets within round brackets, for instance.)
 The brackets are removed by IND before
assigning the whole text string to one parameter. Note that you can pass
numbers or filenames this way too, you just need to perform an assignment
statement within IND. Following the above example:
.break
.skip
_.setn PASSES 'p3'
.break
.skip
will set the value of numeric variable passes to 3, as that is what the text
string for p3 expands to.
.break
.skip 2
.hl 2	SYMBOL value substitution
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
Substitution can occur in any line of a command file. Command files can
use the values assigned to string,numeric,file or system symbols by replacing
a normal parameter (for example a device or directory name) with a symbol name
enclosed in apostrophes (eg CONNECT 'dir'). As long as a previous directive
has not disabled substitution (the .DISABLE SUBSTITUTION directive), IND
replaces the symbol name and apostrophes with the value of the symbol.
.INDENT 16
When IND encounters an apostrophe, it treats the subsequent text
upto the next apostrophe as a symbol name, and substitutes the value of that
symbol for its name and enclosing apostrophes.
.INDENT 8
For example, the first 2 lines below appear in a command file. When IND
encounters these lines, it displays the following 2 lines at the controlling
terminal:
.SKIP 1
.LEFT MARGIN 0
.INDENT 1
_.ASKS tapname Name of magtape to read ?
.break
mount tape 'tapname': /write-protected/label-type:ANSI
.SKIP 1
.LEFT MARGIN 0
* Name of magtape to read ? [S]: ARCHIVE		<- user typed ARCHIVE
.break
@mount tape ARCHIVE: /write-protected/label-type:ANSI
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
ARCHIVE was entered in response to the question. This reply associated
the string value ARCHIVE with the string symbol tapname. Then, when IND read:
.SKIP 1
.LEFT MARGIN 8
mount tape 'tapname': ...
.SKIP 1
.LEFT MARGIN 0
it substituted for 'tapname' the value assigned to TAPNAME, namely ARCHIVE. If
substitution mode was disabled, the command would simply have been passed as it
stood, with apostrophes.
.skip 1
.lm 0
.indent 8
If apostrophes are an inconvenient character for you to use (perhaps you are
writing a set of commands for a program that used apostrophes itself), you
can change the special substitution character with the .DELIM directive.
.SKIP 1

.BREAK
.LEFT MARGIN 0
.hl 2	Numeric,real and string symbols.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
A numeric symbol is a string of digits representing a value in the
range -131070 to +131069. When a numeric symbol is substituted into text, these
digits are placed there, with a minus sign if necessary. The current radix (set
by the .RADIX operator) controls what radix is used to substitute the values
and read in new ones. The default radix is 10.
A numeric symbol or
constant may be combined with other symbols or constants in numeric expressions
via arithmetic operators. These are + to add, - to subtract, * to multiply, and
/ to divide. No imbedded blanks or tabs are allowed in the expressions, and
all arithmetic is done on whole numbers only, without a check for under- or
over-flow. The expressions are evaluated from left to right, stricly, unless
parentheses are used to to form subexpressions. For example, the directive lines:
.SKIP 1
.LEFT MARGIN 8
_.SETN N1 2
.break
_.SETN N2 3
.break
_.SETN N3 N1+N2*4
.SKIP 1
.LEFT MARGIN 8
assigns n3 the value 20 whereas the lines
.SKIP 1
.LEFT MARGIN 8
_.SETN N1 2
.break
_.SETN N2 3
.break
_.SETN N3 N1+(N2*4)
.SKIP 1
.LEFT MARGIN 8
assigns N3 the value 14.
.SKIP 1
.LEFT MARGIN 1
.INDENT 7
Numeric expressions are permitted as second operands in .SETN and
_.IF directives, and also as range arguments to .ASKN and .ASKS, and also
.LEFT MARGIN 0
as substring delimiters in string expressions.
.INDENT 8
Real symbols take on floating point values, such as -232.045. They behave much
the same as numeric symbols, in that they can be combined in expressions.
Real and numeric symbols can be used in the same expression, and one is
converted to the other whenever necessary. If the final result is to be real,
all integers in the expression are converted to real first ; if the final
result is to be integer, each real is rounded (in the ALGOL sense) to the
nearest integer value before use.
.BREAK
.LEFT MARGIN 0
.hl 2	String symbols, substrings and expressions
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
A string constant is a string of any printable characters (possibly
including several non-printable ones, such as bell) enclosed by quotes (" ").
Empty strings are also permitted. The number of characters in a string cannot
exceed 120. Examples:
.SKIP 1
.LEFT MARGIN 8
"ABCDef"
.break
""
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
String symbols may have a value of any string constant. The value is
assigned by a .SETS  or .ASKS directive. For example, the directive lines
.SKIP 1
.LEFT MARGIN 8
_.SETS S1 "ABCDEF"
.break
_.SETS S2 S1
.SKIP 1
.LEFT MARGIN 0
assigns string symbol S2 the value of S1 (that is, ABCDEF.)
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
A substring facility allows you to extract a segment from the value of
a string symbol. You can use substrings only as second operands in .SETS and
.INDENT 1
_.IF directives. For example, the directive lines
.SKIP 1
.LEFT MARGIN 8
_.SETS S1 "ABCDEF"
.break
_.SETS S2 S1[1:3]
.SKIP 1
.LEFT MARGIN 0
assign string symbol S2 the value of string symbol S1 beginning at character 1
and ending at character 3 (that is, ABC). The top and bottom of the range need
not be numeric constants ; they can be any arbitrary numeric expression.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
You can combine a string constant, symbol or substring with another
string constant, symbol or substring by the string concatenation operator +
to form a string expression.
.INDENT 8
String expressions are permitted as second operands in .SETS and .IF
directives where the first operand is a string symbol. For example, the
directive lines
.SKIP 1
.nf ;.nj
.LEFT MARGIN 8
_.SETS S1 "A"
_.SETS S2 "CDEF"
_.SETS S3 S1+"B"+S2[1:3]
.fill;.justify
.SKIP 1
.LEFT MARGIN 0
assign string symbol S3 the value of the concatenation of the string symbol S1,
string constant "B", and the first 3 characters of string symbol S2 (that is,
ABCDE).
.SKIP 1
.LEFT MARGIN 0
.page
.LEFT MARGIN 0
.subttl Directives

.BREAK
.LEFT MARGIN 0
.hl 1		DIRECTIVES
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
Directives must be separated from their arguments and from EXEC or
program commands by at least one space or tab. Spaces may be placed anywhere in
a command line without problems, except in the following exceptions:
.SKIP 1
.LEFT MARGIN 16
.LEFT MARGIN 8
(1) No space is permitted between a label and the following colon (:).
.LEFT MARGIN 8
(2) Embedded spaces or tabs are not permitted within numeric or string
.LEFT MARGIN 0
.INDENT 9
expressions (except, of course, within string constants.)
.skip 1
	Note specifically that the dot in front of a directive may be separated
from its name, to allow you to indent portions of your file. Thus, constructions
like:
.break
_.#############ASK fred What do you want ?
.break
are permissible. Similarly,
.BREAK
		.ASK fred What do you want ?
.BREAK
is equally ok, as long as leading spaces have not been disabled with the
.BREAK
_.DISABLE LEADING
.BREAK
directive. (RSX and RT11 IND do not permit leading spaces before directives.)
.SKIP 1

.BREAK
.LEFT MARGIN 0
.hl 2	Define a label###################################.label:
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
Labels always appear at the beginning of a line; they may be on a line
with additional directives and/or an EXEC command, on a line with a comment, or
on a line by themselves. When control is passed to a line with a label, the line
is processed from the first non-blank character after the colon.
.INDENT 8
Labels are upto 9 characters long, and must be preceded by a period and
terminated by a colon. Once a label has been seen once, it is found very quickly
when subsequent references to it are made. If a label is referenced before it is
seen, there can be a short delay while it is found.
.SKIP 1

.BREAK
.LEFT MARGIN 0
.hl 2 Ask a Yes/No question and wait for a reply######################.ASK
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .ASK directive prints a question on the terminal which requires a
yes/no answer and sets a specified logical symbol to true or false, depending
on the reply. Format:
.SKIP 1
.LEFT MARGIN 8
_.ASK ssssss question-text
.SKIP 1
.LEFT MARGIN 8
.INDENT -8
where:

.BREAK
.LEFT MARGIN 8
ssssss	= 1-9 character symbol to be assigned true/false value
question-text = any ASCII string of characters, maximum length 80
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
When executing a .ASK directive, IND displays the question preceded by
an asterisk and suffixed with "[Y/N]:". Three answers are recognised:
.SKIP 1
.LEFT MARGIN 8
(1) YES (or an abbreviation) - set symbol to true

.BREAK
.LEFT MARGIN 8
(2) NO (	""	"" ) - set symbol to false
.BREAK
.LEFT MARGIN 8
(3) Return on its own - treat as NO.
.SKIP 1
.LEFT MARGIN 16
.INDENT -8
Example:
The directive line
.SKIP 1
.LEFT MARGIN 8
_.ASK exp  Do you want to expunge the directory?
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
displays
.skip 1
* Do you want to expunge the directory ? [Y/N]:
.SKIP 1
.LEFT MARGIN 0
on the terminal. Symbol EXP will be set to true or false after the user types
Yes, no, or return. Recognition can be used, and a question mark typed to see
the list of available options.
.SKIP 1
.LEFT MARGIN 0
.hl 2 Ask for definition of a numeric symbol#####################.ASKN
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .ASKN directive prints on the terminal a request for a numeric
value, waits for it to be entered, optionally tests the range of the numeric
response and/or applies a default value, and sets the value of the specified
symbol accordingly. Format:
.SKIP 1
.LEFT MARGIN 8
_.ASKN sssss question
.BREAK
.LEFT MARGIN 8
_.ASKN [low:high] ssss question
.BREAK
.LEFT MARGIN 8
_.ASKN [low:high:default] ssss question
.SKIP 1

.BREAK
.LEFT MARGIN 8
.INDENT -8
where	sssss	=	1-9 character symbol to be assigned a numeric value

.BREAK
.LEFT MARGIN 8
question =	question to be asked the user

.BREAK
.LEFT MARGIN 24
.INDENT -16
low:high#=	numeric expressions to indicate the permissible low and
high limits for the reponse.

.BREAK
.LEFT MARGIN 8
default =	numeric expression for the default answer.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
When executing the directive, IND displays the question preceded by
* and followed by [_#]: to indicate a numeric answer is required. If ranges have
been specified, the display is followed by [_# R:low:high]: ;if  a default has been
supplied, the display is suffixed by [_# R:low:high D:def]:.
.INDENT 8
If the user's response is out of range, IND prints an error message and
re-issues the question. If the response is an empty line, and a default has
been supplied, the default is used. A question mark can be typed for help,
and escape can also be used to obtain the default answer, if any. Example:
.SKIP 1
.LEFT MARGIN 8
_.ASKN [1:100:20] NUSE Maximum number of users
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
displays on the terminal as
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
* Maximum number of users [_# R:1:100 D:20]:
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The user must enter a number between 1 and 100, or type return for 20.
Symbol NUSE is set to the returned value.
.SKIP 1
.LEFT MARGIN 0
.hl 2 Ask for definition of a real symbol#####################.ASKR
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .ASKR directive prints on the terminal a request for a floating point
value, waits for it to be entered, optionally tests the range of the numeric
response and/or applies a default value, and sets the value of the specified
symbol accordingly. Format:
.SKIP 1
.LEFT MARGIN 8
_.ASKR sssss question
.BREAK
.LEFT MARGIN 8
_.ASKR [low:high] ssss question
.BREAK
.LEFT MARGIN 8
_.ASKR [low:high:default] ssss question
.SKIP 1

.BREAK
.LEFT MARGIN 8
.INDENT -8
where	sssss	=	1-9 character symbol to be assigned a numeric value

.BREAK
.LEFT MARGIN 8
question =	question to be asked the user

.BREAK
.LEFT MARGIN 24
.INDENT -16
low:high#=	numeric expressions to indicate the permissible low and
high limits for the reponse.

.BREAK
.LEFT MARGIN 8
default =	real expression for the default answer.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
When executing the directive, IND displays the question preceded by
* and followed by [_#]: to indicate a numeric answer is required. If ranges have
been specified, the display is followed by [_# R:low:high]: ;if  a default has been
supplied, the display is suffixed by [_# R:low:high D:def]:.
.INDENT 8
If the user's response is out of range, IND prints an error message and
re-issues the question. If the response is an empty line, and a default has
been supplied, the default is used. A question mark can be typed for help,
and escape can also be used to obtain the default answer, if any. Example:
.SKIP 1
.LEFT MARGIN 8
_.ASKR [.00001:.005:.0001] TOLERANCE Tolerance factor to use
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
displays on the terminal as
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
* Tolerance factor to use [_# R:1E-5:0.005 D:0.0001]:
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The user must enter a number between .00001 and .005, or type return for .0001.
Symbol TOLERANCE is set to the returned value. Note that the value .00001 has
been displayed as 1E-5 - this conversion to scientific notation will occur if
the number is too large or small  to be conveniently displayed another way.
.SKIP 1
.LEFT MARGIN 0
.hl 2 Ask for definition of a string symbol##############################.ASKS
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .ASKS directive prints on the terminal a request for a string value
to define a string symbol, and optionally tests the number of characters in the
string to ensure they are within a specified range. An indication is returned
to the command file as to whether the entered characters were all alphabetic
or alphanumeric or numeric. This is via logical variables <ALPHA>,<NUMERIC>,
and <ALPHANUMERIC>. The count of the number of characters in the string is
returned in variable <STRLEN>.
 Formats:
.SKIP 1
.LEFT MARGIN 8
_.ASKS sssss question
.BREAK
.LEFT MARGIN 8
_.ASKS [low:high] sssss question
.SKIP 1
.LEFT MARGIN 16
.INDENT -8
where:
sssss = 1-9 character symbol name
.break
question = question to be displayed
.break
low:high = inclusive limits for number of characters in string.
.SKIP 1
.LEFT MARGIN 8
Low and high are arbitrary numeric expressions.
.SKIP 1
.LEFT MARGIN 0
Examples:
.SKIP 1
.LEFT MARGIN 8
_.ASKS [1:39] NAM Please enter your name
.SKIP 1
.LEFT MARGIN 8
displays
.SKIP 1
.LEFT MARGIN 0
* Please enter your name [S R:1:39]:
.SKIP 1
.LEFT MARGIN 0
on the controlling terminal. The symbol NAM is defined according to the answer
given. A question mark can be typed for help, although the help message
is just "text string".
.skip 1
.indent 8
If it is desired to have a default for this function, the symbol <STRDEF>
may be set to the default desired, ie with a directive like:
.break
_.SETS <STRDEF> "Weekend"
.break
will cause the string "Weekend" to be used as the default answer for all
_.ASKS directives. To remove the default for later directives, use .PURGE
to remove the <STRDEF> symbol.
.SKIP 1
.LEFT MARGIN 0
.hl 2 Ask for definition of a file symbol##############################.ASKF
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .ASKF directive prints on the terminal a request for a file specification
to define a file symbol, and optionally applies a default generation to ensure
that
the file is new or old. Formats:
.SKIP 1
.LEFT MARGIN 8
_.ASKF ffff question
.BREAK
.LEFT MARGIN 8
_.ASKF [gen] ssssss question
.SKIP 1
.LEFT MARGIN 16
.INDENT -8
where:
sssss = 1-9 character symbol name
.break
question = question to be displayed
.break
gen = default generation number, with certain special defaults.
.SKIP 1
.LEFT MARGIN 8
Gen is an arbitrary numeric expression. It is the generation number desired if
 it is positive, or if it is zero
or negative, the following rules apply:
.break
0 means use the highest existing generation (an old file)
.break
-1 means use a generation one higher than the existing generation ( a new file)
.break
-2 means use the lowest existing generation.
.break
Recognition may be used on the file name.

.SKIP 1
.LEFT MARGIN 0
Examples:
.SKIP 1
.LEFT MARGIN 8
_.ASKF [0] INP Enter name of input data file
.SKIP 1
.LEFT MARGIN 8
displays
.SKIP 1
.LEFT MARGIN 0
* Enter name of input data file [F]:
.SKIP 1
.LEFT MARGIN 0
on the controlling terminal. The symbol INP is defined according to the answer
given. A question mark can be typed for help, and the message "file name"
is given. The default generation will be overridden if the user explicitly
enters a generation number.
.skip 1
.indent 8
You may specify a default filename, filetype, directory, device and
account to be used for .ASKF. These defaults, once specified, are used for
all .ASKF directives until they are removed by using .PURGE to remove the
associated default variables. The following variables (of type string) are
set up if defaults are desired. They are all independant - you only need to
set them up if you want a default for specific field (ie you can have a default
type without a default name).
.BREAK
.SKIP
o	<DEFACC>	Default account
.break
.skip
o	<DEFNAM>	Default name
.break
.skip
o	<DEFDIR>	Default directory
.break
.skip
o	<DEFDEV>	Default device
.break
.skip
o	<DEFTYP>	Default extension (or file type)
.SKIP 1
.LEFT MARGIN 0
.hl 2 Call up another IND file###################################.CALL
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .CALL directive tells IND to suspend the current file, and take
commands from another file. It is as if all of that second file were inserted
at the place the .CALL directive exists, with the difference that one file
is not allowed to reference labels in the other. All symbols defined by
one file are accesible to the other, however. .CALL directives can be nested
upto 4 deep. Format:
.SKIP 1
.LEFT MARGIN 8
_.CALL filename
.SKIP 1
.LEFT MARGIN 0
Default file type is as for IND command, ie .CMD. Usually the default device is
DSK: (which is usually your own directory.) However, if IND was originally
invoked with a command like IND TRIM, and TRIM.CMD is not found on DSK:, it
then searches SYS: for the file. If SYS:TRIM.CMD existed, then any .CALL
directives which it issues will use SYS: as their default device.
.SKIP 1
.LEFT MARGIN 0
.hl 2 Close secondary file########################################.CLOSE
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .CLOSE directive closes the secondary file opened in a .OPEN
directive. It is a noop if no file has been opened (ie no error occurs if a
file is not currently open.)
.SKIP 1
.LEFT MARGIN 0
.hl 2 Close secondary input file##################################.CLOSEI
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .CLOSEI directive closes the secondary file opened in a .OPENI
directive. It is a noop if no file has been opened (ie no error occurs if a
file is not currently open.)
.skip 1
.lm 0
.hl 2 Get ASCII code of a character####################################.CODE
.skip 1
.lm 0
.indent 8
The .CODE directive returns the ASCII value of the first character of a string
expression to a numeric variable. Format:
.indent 8
_.CODE number string-expression
.skip 1
.lm 0
The variable number receives the ASCII code of the first character in the string
expression. Examples:
.skip 1
.break
_.CODE start "This is a string of characters"
_.CODE n command
.break
.skip 1
.indent 8
In the first example, variable start gets the ASCII code for uppercase T, while
in the second, command is assumed to be a string variable, and the code for
its first character is returned to n. If command is a null string, n is set to
0.
.skip 1
.LEFT MARGIN 0
.hl 2 Output data to secondary file###################################.DATA
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .DATA directive specfies text to be output to a secondary file
opened by a previous .OPEN directive. An error occurs if no file is open.
Format:
.INDENT 8
_.DATA arbitrary text which is not interpreted
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
Leading blanks and tabs are stripped from the data, and symbol
substitution is still performed if enabled.
.SKIP 1
.LEFT MARGIN 0
Example:
.SKIP 1
.LEFT MARGIN 8
_.SETS SEND "This is data"
.BREAK
.LEFT MARGIN 8
_.OPEN TEMP.DAT
.BREAK
.LEFT MARGIN 8
_.DATA 'SEND'
.SKIP 1
.LEFT MARGIN 8
These directives output "This is data" to the secondary file.
.LM 0
.HL 2 Convert date string to Smithsonian day number#################.DAYTON
.SKIP
.LM 0
.INDENT 8
The .DAYTON directive converts a string expression, which is assumed to be
a date, into a Smithsonian day number. Smithsonian
 day numbers are an easier method
for programs to handle dates with than date strings (ie it is easier to do
things like find out the year, find out how far apart two dates are, etc.)
Format:
.SKIP
.LM 8
_.DAYTON String-expression  Numeric-symbol
.LM 0
.SKIP
Example:
.LM 8
_.DAYTON "24-Dec-84" XMASEVE
.LM 0
.SKIP
This stores the date of Christmas Eve 1984 in XMASEVE. Day zero
 is 17th November 1858.
Negative day numbers are not allowed. .DAYTON accepts dates in any reasonable
format, such as 24th December 1984, 24/12/84, 24 dec 1984, etc. It cannot
accept the names of days of the week, nor can it accept numeric dates delimited
by periods. If a wholly numeric date is entered (as 24/12/84 or even 241284),
it adopts the british convention of assuming the second number is the month,
rather the American convention of assuming the first number is the month.
.SKIP 1
.LM 0
.HL 2 Debug IND##################################################.DDT
.SKIP 1
.LM 0
.INDENT 8
The .DDT directive merges SYS:UDDT with the IND program and then executes an
unsolicited breakpoint into DDT. It is used only for debugging IND. When you
have set your breakpoints, or otherwise fiddled, use $P to continue IND
execution.
.PARA
This directive accepts no arguments.
.SKIP 1
.LEFT MARGIN 0
.hl 2 Decrement numeric symbol##########################################.DEC
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .DEC directive subtracts one from the value of a numeric symbol.
Format:
.SKIP 1
.LEFT MARGIN 8
_.DEC ssssss
.SKIP 1
.LEFT MARGIN 24
where ssssss is a numeric symbol name.
.LEFT MARGIN 0
.hl 2 Delay execution for a specified period of time#####################.DELAY
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .DELAY directive delays processing for the specified number of
seconds. Format:
.INDENT 24
_.DELAY numexp
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
where numexp is a numeric expression equal to the number of seconds
to wait for. IND just does nothing for the specified period of time.
.lm 0
.hl 2 Change delimiting character for substitution################.DELIM
.skip 1
.indent 8
The .DELIM directive changes the character which is used to mark out variables
for substitution in the command file. This character is usually ' (apostrophe).
_.DELIM can be used to change it to any ASCII printing character. Format:
.break
.skip 1
.indent 8
_.DELIM string-expression
.break
.skip 1
Eg, the directive
.break
.indent 8
_.DELIM "&"
.break
means that wherever IND finds a variable name surrounded by the ampersand (&)
in a command file, the value of that variable is substituted in.
.break
.skip 1
.LEFT MARGIN 0
.hl 2 Disable option or mode######################################.DISABLE
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .DISABLE directive turns off a specified mode or option of IND.
See the .ENABLE directive for information about options. Format:
.SKIP 1
.LEFT MARGIN 8
_.DISABLE SUBSTITUTION
.LEFT MARGIN 0
.hl 2 Enable option or mode######################################.ENABLE
.SKIP 1
.LEFT MARGIN 0
.INDENT 16
The ENABLE directive is used to invoke one of the special
operating modes or options of IND. Some modes or options are ENABLEd by
default - you do not need to turn these on, but may wish to turn them off
via .DISABLE. The default settings are listed below ; they are explained
later. The format of the directives is as below:
.SKIP 1
.LEFT MARGIN 8
_.ENABLE keyword
.BREAK
.LEFT MARGIN 8
_.DISABLE keyword
.SKIP 1
.LEFT MARGIN 0
where keyword is from the following list (defaults at startup follow each keyword):
.SKIP 1
.LM 8
ABORT - enabled
.BREAK
.LEFT MARGIN 8
COMAND-CMD - enabled
.BREAK
.LM 8
CONTROL-Z-EXITS - enabled
.BREAK
.LEFT MARGIN 8
DATA - disabled
.BREAK
.LEFT MARGIN 8
EXTENDED-EXEC - disabled
.BREAK
.LEFT MARGIN 8
ESCAPE - disabled
.BREAK
.LM 8
LEADING - enabled
.BREAK
.LM 8
LOGGING - disabled
.BREAK
.LM 8
LOGOUT - disabled
.BREAK
.LEFT MARGIN 8
TRACE - disabled
.BREAK
.LEFT MARGIN 8
SUBSTITUTION - Enabled
.BREAK
.LEFT MARGIN 8
QUIET - Disabled
.SKIP 1
.LEFT MARGIN 0
Keywords, unlike IND directives, may be abbreviated to any unique substring.
It is recommended that you use at least four characters in your abbreviation -
other directives may otherwise make it non-unique in a later release of IND.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
When COMAND-CMD is enabled, the EXEC that IND passes its commands to is
allowed to read the COMAND.CMD file as usual before it starts. This is the
normal mode. If you wish to suppress this, you can disable this feature. The
_.DISABLE command for this must be given before any EXEC commands appear in
your command file.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
When DATA mode is enabled, IND stops treating the contents of the file
as commands, and instead sends everything it sees to the secondary data file
until a .DISABLE DATA directive is processed. This is the only directive that
will be recognised - all others are treated as data. DATA mode is useful if
you have a number of lines to send to the secondary file (it saves a lot of
individual DATA directives), or if you wish to send lines with leading blanks
or tabs to the secondary file. This mode does not strip these characters.
Substitution is still performed if applicable.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
When EXTENDED-EXEC mode is enabled, IND uses an alternative form of the
EXEC to process your TOPS-20 commands. This is usually SYS:MEXEC.EXE, but may be
optionally selected to be any other EXEC by recompiling IND. The .ENABLE
EXTENDED-EXEC command, if used, must be given before any TOPS20 commands have
been issued by the command file. Once enabled, it cannot be disabled.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
When ESCAPE mode is enabled, any escape characters that your file
transmits to the screen, via comments for instance, will be transmitted as
escapes instead of being translated into dollar signs, which is what TOPS20
normally does.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
When CONTROL-Z-EXITS are enabled, you can use CTRL/Z as an answer
to any question from IND, and it will exit immediately, closing data files
first. When this mode is disabled, IND will not allow the user to bypass a
question in this manner.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
In substitution mode, the processor substitutes a string in place
of a symbol name when the symbol name is enclosed in apostrophes. When
substitution is operating, it is performed before any other action is taken
with a line, ie before the decision is made as to whether the line is an IND
directive, a TOPS20 command, or a comment. (While obeying GOTO directives which
cause forward motion through the file, however, substitution is not performed
until the target label has been found, to prevent any spurious errors due to
symbols having unexpected values. This means that, in general, labels should
not be inserted via substitution, as they may not always be found.)
When substitution is disabled, apostrophes are treated no differently from other
characters.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
In TRACE mode, IND prints all commands at the terminal after substitution
has been performed on them, but before they are executed. This gives you a
chance to debug complex command files, as the IND directives are not usually
displayed on the screen, only the TOPS20 commands and comments.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
In QUIET mode, TOPS20 commands which are normally printed at the
terminal as they are executed are instead inhibited from echoing. Thus the only
output appearing on the screen is that generated by questions or comments, or as
output from a program.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
When LOGGING is enabled, all characters that appear on the terminal are
also written to the currently selected logfile, in the same way that PHOTO
or similar programs would do. This mode cannot be enabled if a previous .LOGFILE
command has not been given to select a logfile. Logging can be selectively
enabled and disabled during the course of the command file, with the logfile
remaining open. This allows you to record only those sections of the dialogue
which you feel are important.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
When LOGOUT is enabled, the lower fork is allowed to execute the LOGOUT or
BYE commands, or generally to issue a LGOUT JSYS. This is not normally the
case, as it can cause IND to end prematurely. You can enable this mode if you
wish to be able to use the LOGOUT command from within a command file. Make
sure that you have closed all open files first.
.SKIP
.LM 0
.INDENT 8
When LEADING is enabled, you can use leading blanks before the "." that
comes before an IND directive. When it is disabled, the "." at the
beginning of an IND directive must be at the left hand margin.
.SKIP
.PARA
When ABORT is enabled, you can abort an IND command file at any time by typing
the abort character (usually control-A). This can be disabled during sensitive
actions with the .DISABLE ABORT directive, but you should be warned that the
command file will then be very difficult to stop should it contain bugs.
.SKIP 1
.LM 0
.HL 2 Display a text string#####################################.DISPLAY
.SKIP 1
.LM 0
.INDENT 8
The .DISPLAY directive sends a text string to the screen verbatim, without
translation of control characters and without any leading or trailing carriage
returns or linefeeds.
Format:
.SKIP 1
.INDENT 8
_.DISPLAY string-expression
.SKIP 1
This directive is mainly only useful for sending escape sequences to screen
terminals, and is of very limited use. To send normal messages, use the comment
feature of placing your messages on a line after a semicolon.
Example:
.SKIP 1
.LM 8
_.DISPLAY "$[H"
.SKIP 1
.LM 0
This sends the sequence to a VT100 to home the cursor.
.skip 1
.left margin 0
.hl 2 Close a logfile########################################.ENDLOG
.skip 1
.indent 8
The .ENDLOG directive closes the terminal logfile opened with a .LOGFILE
directive and releases the asssociated pseudo terminal back to the pool of
system resources. Format:
.skip 1

.break
.left margin 8
_.ENDLOG
.SKIP 1
.LM 0
.HL 2 Exit quietly from an IND file################################.EXIT
.SKIP 1
.LM 0
.INDENT 8
The .EXIT directive terminates IND execution, and does not print any message.
Normally, the message @ <EOF> is displayed on the screen when a command file is
finshed. Placing the .EXIT directive at the end stops this. Also, .EXIT will
still exit if placed in a nested command file. Use .STOP if you merely wish to
terminate the current command file (ie return to the next higher level.)
Format:
.SKIP 1
.INDENT 8
_.EXIT
.SKIP 1
.LM 0
.skip 1
.left margin 0
.HL 2 Define a file symbol#################################.FILE
.skip 1
.indent 8
The .FILE directive declares a list of symbols to be file symbols, and
initializes them all to point to NUL:. The symbols must not already be
defined. Format:
.skip 1

.break
.left margin 8
_.FILE symbol,symbol,symbol....
.skip 1
.left margin 0
The list of symbols can contain from 1 to 10 symbol names.
.SKIP 1
.LEFT MARGIN 0
.hl 2 Call a subroutine#######################################.GOSUB
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .GOSUB directive saves the current position in the indirect file and
then branches to a label. The label specifies the start of a subroutine which is
terminated by a .RETURN directive. The maximum nesting depth for subroutine
calls is 10. Format:
.SKIP 1

.BREAK
.LEFT MARGIN 8
_.GOSUB	label
.SKIP 1
.LEFT MARGIN 0
where label is the tag at the start of the subroutine, without the leading dot
or trailing colon.
.SKIP 1
.LEFT MARGIN 0
.hl 2 Branch to a label#############################################.GOTO
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .GOTO directive causes a branch from one line in a command file
to another. All commands between the GOTO and the destination are ignored.
Btanches may go forwards or backwards in the file, but not to labels in a
different command file (eg not to the one that .CALLed this one.) Format:
.SKIP 1
.LEFT MARGIN 8
_.GOTO label
.SKIP 1
.LEFT MARGIN 0
.hl 2 Logical test######################################################.IF
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
A number of directives make various sorts of logical tests, that is,
those whose results are either true or false. If the test is true, IND
processes the remainder of the line as another command.
.SKIP 1
.LEFT MARGIN 0
.hl 3 Test if symbol meets specified condition########################.IF
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .IF directive compares a numeric or string symbol with an
expression of the same type to determine if one of several possible
conditions is true. If the condition is satisfied, IND executes the remainder
of the command line. Numeric tests are made purely on magnitude ; string tests
are made by comparing the strings character by character: when the strings
differ, it is the order of the first differing characters that determine which
string is greater. Upper/lower case is ignored when making this comparison.
If one string is a substring of another (eg LOCK and LOCKED), the shorter
string is considered the lesser of the two.
.INDENT 8
Thus, "APPLE" is equal to "apple", "pear" is less than "TOMATO",
and "under" is less than "underfoot".
.INDENT 8
Format:
.SKIP 1
.LEFT MARGIN 8
_.IF symbol relop expression command
.SKIP 1
.LEFT MARGIN 8
.INDENT -8
where:
symbol= 1-9 character name of numeric, real or string symbol
.BREAK
.LEFT MARGIN 8
relop = one of the following relational operators:
.SKIP 1

.BREAK
.LEFT MARGIN 16
EQ or =		: equal to

.BREAK
.LEFT MARGIN 16
NE or ~= or <> or >< : Not equal to

.BREAK
.LEFT MARGIN 16
GE or >= or =>	: Greater than or equal to

.BREAK
.LEFT MARGIN 16
LE or =< or <=	: Less than or equal to

.BREAK
.LEFT MARGIN 16
GT or >		: Greater than

.BREAK
.LEFT MARGIN 16
LT or <		: Less than
.SKIP 1
.LEFT MARGIN 8
expression = expression of same type as symbol (except that a real expression
can be converted to integer, and integer to real without any problem.)
.SKIP 1
.LEFT MARGIN 0
Examples:
.SKIP 1
.LEFT MARGIN 8
_.SETS X "A"
.BREAK
.LEFT MARGIN 8
_.SETS Y "BBC"
.BREAK
.LEFT MARGIN 8
_.IF X LT Y .GOTO START
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The value of string X is less than that of Y, so a transfer will occur
to the line labelled .START: .
.SKIP 1
.LEFT MARGIN 8
_.IF N1 < 200*PAY SYSTAT ALL NO OPERATOR
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
If the value of numeric symbol N1 is less than the value of symbol PAY
multiplied by 200, then the SYSTAT command will be executed.
.SKIP 1
.LEFT MARGIN 0
.hl 3 Test if symbol is defined or not defined#################.IFDF/.IFNDF
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
These directives test whether or not a symbol is defined yet to IND.
If the test is true, the rest of the command is processed. The value is not
tested. Formats:
.SKIP 1
.LEFT MARGIN 8
_.IFDF symbol command
.BREAK
.LEFT MARGIN 8
_.IFNDF symbol command
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
where symbol is the symbol name.
Examples:
.SKIP 1
.LEFT MARGIN 8
_.IFDF a .GOTO 100
.BREAK
.LEFT MARGIN 8
_.IFNDF tim .ASK tim Do you want to set the time?
.LEFT MARGIN 0
.hl 3 Test if logical symbol is true or false#####################.IFT/.IFF
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .IFT/.IFF directives test if a logical symbol is true or false.
If the test is true, the remainder of the line is executed. Format:
.SKIP 1
.LEFT MARGIN 8
_.IFT symbol command
.BREAK
.LEFT MARGIN 8
_.IFF symbol command
.SKIP 1
.LEFT MARGIN 8
.INDENT -8
Examples:
_.IFT Wheel _^equit
.SKIP 1
.LEFT MARGIN 8
This executes the _^e quit command if the logical symbol wheel is true.
.LEFT MARGIN 0
.hl 2 Increment a numeric symbol########################################.INC
.SKIP 1
.LEFT MARGIN 8
The .INC directive increments a numeric symbol by one. Format:
.SKIP 1
.LEFT MARGIN 8
_.INC symbol
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
One is added to the value of symbol, which must previously have been
defined as numeric.
.SKIP 1
.LEFT MARGIN 0
.hl 2 Open terminal logfile####################################.LOGFILE
.skip 1
.left margin 0
.indent 8
The .LOGFILE directive declares a file to be used to record all characters
displayed at the terminal. Although it opens the file, characters are not logged
until an .ENABLE LOGGING directive is issued. Format:
.skip 1

.break
.left margin 8
_.LOGFILE filename
.skip 1
.left margin 0
Filename must be a valid file to which you have write access. A spare pseudo
terminal must exist for this function to be effective.
.skip 1
.hl 2 Declare logical symbols###################################.LOGICAL
.skip 1
.indent 8
This directive declares a list of symbols to be of type logical, and
initializes them to false. They must not already be defined.
Format:
.skip 1

.break
.left margin 8
_.LOGICAL symbol,symbol...
.SKIP 1
.LM 0
.HL 2 Make a string lower case##################################.LOWER
.SKIP 1
.LM 0
.INDENT 8
The .LOWER directive forces all alphabetic characters in a string to be upper
case. (See .RAISE for the converse.)
Format:
.SKIP 1
.INDENT 8
_.LOWER Symbolname
.SKIP 1
where SYMBOLNAME is the name of an existing string symbol. All alphabetic
characters in that string will be made lowercase. Other characters are not
affected.
.SKIP 1
.LM 0
.HL 2 Convert day number to date string############################.NTODAY
.SKIP 1
.LM 0
.INDENT 8
The .NTODAY directive converts a Smithsonian day number into a date string.
Format:
.SKIP 1
.INDENT 8
_.NTODAY numeric-expression string-variable
.SKIP 1
The date is converted in the format dd-mmm-yy, unless it was before 1900,
in which case it is in the format dd-mmm-18yy.
Example:
.SKIP 1
.LM 8
_.DAYTON <DATE> Today
_.NTODAY Today+7 Nextweek
.SKIP 1
.LM 8
This results in string symbol Nextweek containing the date representation
of one week after today, no matter whether it is a different month or year.
.skip 1
.left margin 0
.hl 2 Declare numeric symbols###################################.NUMERIC
.skip 1
.indent 8
This directive declares a list of symbols to be of type numeric, and
initializes them to zero. They must not already be defined.
Format:
.skip 1

.break
.left margin 8
_.NUMERIC symbol,symbol...
.skip 1
.left margin 0
.hl 2 Open secondary file#############################################.OPEN
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .OPEN directive opens the specified secondary file for output.
Format:
.SKIP 1
.LEFT MARGIN 8
_.OPEN filename.typ.gen
.SKIP 1
.LEFT MARGIN 0
A usual TOPS20 filespec can be entered, with any optional fields (eg ;ACCOUNT,
;BLOCKSIZE.) There is no default type.
.LEFT MARGIN 0
.hl 2 Open secondary file for append###################################.OPENA
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
This directive is identical to .OPEN, except that the file is opened
for append access only.
.LEFT MARGIN 0
.HL 2 Open file for input#####################################.OPENI
.skip 1
.left margin 0
.indent 8
The .OPENI directive opens a file for reading with the .READ directive.
The file must exist. There is no default name or type. Format:
.skip 1

.break
.left margin 8
_.OPENI filename
.skip 1
.left margin 0
The file must be ASCII (ie simple text) and the records cannot be longer
than the maximum length of a string variable.
.skip 1
.break
.hl 2 Pad a string with blanks to a specified length####################.PAD
.skip 1
.lm 0
.indent 8
The .PAD directive takes a specified string and pads it to a particular length
using spaces. This can be useful for formatting printouts using string
substitution. Format is:
.skip 1
.break
.indent 8
_.PAD string numeric-expression
.skip 1
.break
The string variable is padded to the length specified by the numeric expression.
A warning is generated if the string is already longer than the length you
want to pad it to.
.skip 1
.break
.hl 2 Break a string into substrings###################################.PARSE
.skip 1
.lm 0
.indent 8
The .PARSE directive is a very powerful mechanism for breaking up command
strings, or data from files. The function it performs is to take a string of
characters and chop it up into smaller parts by looking for specific
characters which delimit portions of the input. You supply the string to
be chopped (referred to as the parse string) and another string which contains
a set of delimiter characters which are searched for one by one in the parse
string. This string of delimiters is referred to as the control string. A
set of variables is supplied which receive the chopped out portions. The command
looks like:
.BREAK
.SKIP 1
_.PARSE parse-string control-string Out1 out2 out3 ...
.break
.skip 1
The trailing dots indicate that you can have as many output strings as you want.
What happens is this:
.break
.skip 1
.indent 8
A search is made in the parse string for the first character in the control
string. When it is found, the portion of the parse string up to that point
is copied into variable out1 (not including the terminating character). The
search is then continued from that point in the parse string for the next
character from the control string expression. This substring, when found, is
copied to out2, and so on. If we run out of characters in the control string
while there is still more to chop up, we use the last character repeatedly.
If we run out of parse string before all the variables have had values assigned
the remaining variables contain null strings. The variable <STRLEN> contains
the actual number of subtrings found.  If we run out of output variables, the
last output variable contains the whole remainder of the string up to the point
currently parsed. Examples:
.SKIP 1
.BREAK
.lm 8
_.SETS address "12,Morrow lane,Datchworth,Herts."
.break
_.PARSE address "," number road town county
.skip 1
.break
.lm 0
This breaks the variable address up into "12" which is put in variable number,
"Morrow lane" which is put into road, "Datchworth" which is put into variable
town, and "Herts." which is put into county. If the control string had been
",#," instead, we could have split up "Morrow" from "lane" as well.
.skip 1
.hl 2 Pause for operator action######################################.PAUSE
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .PAUSE directive causes IND to temporarily suspend processing
its command file, and allow the operator to enter TOPS20 commands from
the keyboard. It acts rather like a PUSH command in an ordinary TAKE file.
When the .PAUSE directive is reached, IND displays the following message at the
user's terminal:
.SKIP 1
.LEFT MARGIN 0
[IND - pausing. To continue type 'POP'.]
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
Any commands may be entered (except LOGOUT or BYE) and when the user
wishes to continue they can type POP. The message
.SKIP 1
.LEFT MARGIN 0
[IND - continuing.]
.SKIP 1
.LEFT MARGIN 0
is then displayed at the terminal. Both the above messages are suppressed if
the .ENABLE QUIET directive has been issued.
.SKIP 1
.LM 0
.HL 2 Set input file to specified position######################.POSITION
.SKIP 1
.LM 0
.INDENT 8
The .POSITION directive is only valid if an input file (opened with .OPENI) is
currently open. It takes as its argument a numeric expression, which is the
byte number to set the file pointer to (ie the next byte or character read will
be that one.) You can use this to re-read parts of an input file if you have
previously read the position using the <BYTEPOS> system symbol.
Format:
.SKIP 1
.INDENT 8
_.POSITION numeric-expression
.SKIP 1
A fatal error occurs if the expression is non-positive, or if no input file is
open.
.LM 0
.skip 1
.break
.hl 2 Remove a symbol and its definition#########################.PURGE
.skip 1
.break
.indent 8
The .PURGE directive removes a list of variables from IND entirely. Their
values and types are totally forgotten. This is mainly of use when you
have set up a special symbol such as <STRDEF> for a default for one
question, and you then want the default forgotten. Format:
.SKIP
.BREAK
.INDENT 8
_.PURGE var1,var2,var3,....
.break
The list may be as long as you wish.
.SKIP 1
.LM 0
.HL 2 Change current radix for integers##########################.RADIX
.SKIP 1
.LM 0
.INDENT 8
The .RADIX diretive changes the current base or radix used for typing out
numeric symbols, reading them from the terminal, and reading them in
expressions in command files.
Format:
.SKIP 1
.INDENT 8
_.RADIX numeric expression.
.SKIP 1
The numeric expression involved is ALWAYS interpreted as being in base 10.
If only output is to be performed with a different radix, the radix may be
anything from 2 to 36. If input is to be performed also, it can only be between
2 and 10.
Example:
.SKIP
.NF;.NJ
_.SETN OLDRADIX 10		;Save old radix
_.RADIX 5			;Do some WEIRD stuff in rad 5
_.
_.
_.RADIX OLDRADIX		;Set the radix back again
.SKIP
.FILL;.JUSTIFY
.LM 8
.SKIP 1
.LM 0
.HL 2 Raise a string to upper case##################################.RAISE
.SKIP 1
.LM 0
.INDENT 8
the .RAISE directive forces all the characters in a string variable to be upper
case.
Format:
.SKIP 1
.INDENT 8
_.RAISE string-variable-name
.SKIP 1
Non-alphabetic characters are unaffected. The .LOWER directive performs the
converse operation.
.skip 1
.LEFT MARGIN 0
.hl 2 Read a record from input file###############################.READ
.skip 1
.indent 8
The .READ directive reads a line from the currently open input file (set with
_.OPENI) and places its contents in a string variable. Format:
.skip 1
.break

.indent 8
_.READ ssssss
.skip 1
.left margin 0
Where sssss is the name of a string variable. If end of file has been reached,
the variable is set to the null string and the system symbol <EOF> becomes
true.
.SKIP 1
.LM 0
.HL 2 Define a floating point symbol#############################.REAL
.SKIP 1
.LM 0
.INDENT 8
This directive defines a list of symbols to be floating point and initializes
them to zero. It is not necessary to declare your variables in this way, but it
can be helpful.
Format:
.SKIP 1
.INDENT 8
_.REAL symbol,symbol,...
.SKIP 1
Example:
.SKIP 1
.LM 8
_.REAL loadav,cycletime
.SKIP 1
.LM 8
.skip 1
.hl 2 Return from a subroutine#######################################.RETURN
.SKIP 1
.LEFT MARGIN 8
The .RETURN directive is used at the end of a subroutine called by a
.LEFT MARGIN 0
_.GOSUB directive, and transfers control to the line following the .GOSUB that
.LEFT MARGIN 0
called it. Format:
.SKIP 1
.LEFT MARGIN 8
_.RETURN
.SKIP 1
.LEFT MARGIN 0
.hl 2 Reset input data file###############################.REWIND
.skip 1
.indent 8
The .REWIND directive "rewinds" the input file, ie it causes the next read from
the file opened with .OPENI to come from the start of the file. Format:
.skip 1
.indent 8
_.REWIND
.skip 1
.break
.left margin 0
.hl 2 Run a program requiring terminal input########################.RUN
.skip 1
.left margin 0
.indent 8
The .RUN directive runs a program under the control of IND in much the same way
as the EXEC RUN command does. However, whereas the Run command to the EXEC, when
in an IND file, would cause program input to come from the command file, the
_.RUN directive allows the user to interact with the program via the terminal.
When the program exits, IND continues to process the command file. This can be
useful if you want to invoke an editor, say, from within an IND file. You can
run the editor in the normal way - however, you must then put the editor
commands within your command file. Format:
.skip 1
.left margin 8
_.RUN program optional-data
.skip 1
.left margin 0
.indent 8
The filetype of the program is presumed to be .EXE, and may be omitted. The
directory name is presumed to be DSK:, and must be entered explicitly if
different. This command loads the rescan buffer in the same way that the EXEC
does, so a command such as:
.skip 1
.left margin 8
_.RUN sys:rev *.dat
.skip 1
.left margin 0
.indent 8
is permissible, and causes the rescan buffer to be loaded with REV *.DAT,
thus causing REV to start automatically reviewing all files of type DAT.
This may be applied to any program that normally reads the rescan buffer
that the EXEC supplies (eg TV,SYSDPY,RUNOFF.)
.skip 1
.LEFT MARGIN 0
.hl 2 Set symbol to true or false################################.SETT/.SETF
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .SETT/.SETF directives define or change the value of a logical
symbol. The symbol must be undefined, or previously defined as logical.
Formats:
.SKIP 1
.LEFT MARGIN 8
_.SETT symbol
.BREAK
.LEFT MARGIN 8
_.SETF symbol
.SKIP 1
.LEFT MARGIN 8
The .SETT directive sets the symbol to true, the .SETF makes it false.
.LEFT MARGIN 0
.hl 2 Set symbol to file value######################################.SETFI
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .SETFI directive sets the value of a file symbol, ie associates
a symbol with a filename (either an existing filename, or a new filename.)
Format:
.SKIP 1
.LEFT MARGIN 8
_.SETFI symbol filename.
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
Filename can be in standard TOPS20 format, symbol is a standard symbol
name.
.LEFT MARGIN 0
.hl 2 Set symbol to numeric value######################################.SETN
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .SETN directive sets the value of a numeric symbol to be
equivalent to the value of a given numeric expression. The symbol must
be previously numeric, or undefined. Format:
.SKIP 1
.LEFT MARGIN 8
_.SETN symbol expression
.SKIP 1
.LEFT MARGIN 0
where symbol is a valid symbol name, and expression is any numeric expression.
Examples:
.SKIP 1
.LEFT MARGIN 8
_.SETN number 103
.BREAK
.LEFT MARGIN 8
_.SETN number2 3*(a2-2)
.LEFT MARGIN 0
.hl 2 Set symbol to floating value######################################.SETR
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .SETR directive sets the value of a floating point symbol to be
equivalent to the value of a given expression. The symbol must
be previously real, or undefined. Format:
.SKIP 1
.LEFT MARGIN 8
_.SETR symbol expression
.SKIP 1
.LEFT MARGIN 0
where symbol is a valid symbol name, and expression is any numeric expression.
Examples:
.SKIP 1
.LEFT MARGIN 8
_.SETR number 103.45
.BREAK
.LEFT MARGIN 8
_.SETR number2 3*(a2-2.506)
.LEFT MARGIN 0
.hl 2 Set symbol to string value#######################################.SETS
.SKIP 1
.LEFT MARGIN 8
The .SETS directive associates a string with a string symbol. Format:
.SKIP 1
.LEFT MARGIN 8
_.SETS symbol strexp
.SKIP 1
.LEFT MARGIN 0
where symbol is a string symbol, and strexp is a valid string expression.
Examples:
.SKIP 1
.LEFT MARGIN 8
_.SETS x "hello there"
.BREAK
.LEFT MARGIN 8
_.SETS type a[1:6]+"."+b[1:3]
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The first directive assigns the string hello there to symbol x ; the
seconds directive makes string symbol type have a value equal to the first
siz characters of the value of symbol a, followed by a ., followed by the
first 3 characters of symbol b.
.LEFT MARGIN 0
.hl 2 Terminate current command file###################################.STOP
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .STOP directive closes any currently open IND data file, and
terminates the command file. If the current command file has been called from a
higher level one, the current file only is terminated, and control is returned
to the upper file.
The message
.SKIP 1
.LEFT MARGIN 0
@ <EOF>
.SKIP 1
.LEFT MARGIN 0
is displayed only if this is the top-level command file.
.LEFT MARGIN 0
.hl 2 Declare string symbol#############################.STRING
.skip 1
.indent 8
The .STRING directive declares a list of symbols to be of type string and
sets their values to be the null string. They must not already be defined.
It is not necessary to declare variables in this manner. Format:
.skip 1
.break
.indent 8
_.STRING ssss,sssss,sssss...
.skip 1
.break
.left margin 0
where the ssss are symbols names to be declared.
.LEFT MARGIN 0
.hl 2 Pass a command to an interactive program#########################.TELL
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
In certain rare circumstances it is desired to use the .RUN directive to run a
program, allowing the user to type his or her own commands at it, but first to
give the program one or two initializing commands. The .TELL directive allows
this. Only one command can be passed, however.
Format:
.SKIP 1
.LEFT MARGIN 8
_.TELL String-expression
.SKIP 1
.LEFT MARGIN 0
Examples:
.SKIP 1
.LEFT MARGIN 8
_.TELL "TRANSFER=INIT.PST$"
_.RUN SYS:PSTAT.EXE
.BREAK
.LEFT MARGIN 8
Will run PSTAT, but tell it to transfer to the file of commands INIT.PST before
accepting input from the terminal. INIT.PST presumable contains some
environment setting commands.
.SKip 1
.hl 2 Test string symbol#########################################.TEST
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .TEST directive allows you to determine the length of a string
symbol. After it is executed, the system symbol <STRLEN> is set to the
length of the tested string. The symbols <ALPHA>, <ALPHANUM> and <NUMERIC>
are also set to indicate whether the string was alphabetic, alphanumeric
or numeric only.
 Format:
.SKIP 1
.LEFT MARGIN 8
_.TEST symbol
.SKIP 1
.LEFT MARGIN 0
where symbol is a string symbol to be tested. Example:
.SKIP 1
.LEFT MARGIN 8
_.SETS a "1234"
.BREAK
.LEFT MARGIN 8
_.TEST a
.SKIP 1
.LEFT MARGIN 0
Symbol <STRLEN> would now equal 4.
.LEFT MARGIN 0
.hl 2 Test if a file exists#######################################.TESTFILE
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
The .TESTFILE directive takes as its argument a filename, and sets
the special symbol <FILESTAT> to indicate whether or not the file exists.
Format:
.SKIP 1
.LEFT MARGIN 8
_.TESTFILE filename
.SKIP 1
.LEFT MARGIN 8
The symbol <FILESTAT> is set as follows:
.SKIP 1

.BREAK
.LEFT MARGIN 8
1 	File exists normally

.BREAK
.LEFT MARGIN 8
0	File does not exist

.BREAK
.LEFT MARGIN 8
-1	File exists, but is deleted.

.BREAK
.LEFT MARGIN 8
-2	File exists, but is invisible.

.BREAK
.LEFT MARGIN 8
-3	File exists, but is offline.
.BREAK
.LM 8
-4	Filespec is invalid (ie no such directory or no such device)
.SKIP 1
.LEFT MARGIN 0
.INDENT 8
If a file is deleted and invisible, it will be shown as invisible. If
a file is offline and invisible, it will be shown as offline.
.para
The symbols
<FILDEV>, <FILNAM>, <FILDIR>, <FILTYP>,
<FILGEN>, <FILPRO>, <FILACT>, <FILCRE>, <FILRED>
are also set up to contain the various parts of the filespec (device,
directory,name,type,generation,protection,account,creation date/time, read
date/time.) These fields are always set up, whether or not they were specified
in the filespec. They are all string symbols. The symbols <FILPAG>,<FILSIZ> and <FILBYS>
are set up to contain the number of pages in the file, the number of
bytes, and the byte size. They are all numeric symbols. They can only be
set up if <FILESTAT> is 1,-1 or -2 (i.e. if the file is online.)

.lm 0
.break
.hl 2 Trim trailing blanks and tabs##################################.TRIM
.break
.skip
.indent 8
	The .TRIM directive removes trailing blanks and tabs from an input
string. Format:
.break
.indent 8
_.TRIM variable
.break
.skip
.lm 0
	The variable has all trailing blanks and tabs remove from it. It must
already be defined of type string.
.HL 1 Ind error messages and warnings
.hl 2 Informational messages
	These messages require no action on your part. They merely inform you
about some action being taken by IND.
.SKIP
.LEFT MARGIN 0
.BREAK
[IND - exiting]
.LEFT MARGIN 24
		This message is issued after a fatal error message to indicate
that IND cannot continue to execute your command file.
.SKIP
.LEFT MARGIN 0
.BREAK
[IND - pausing. To continue type "POP"]
.LEFT MARGIN 24
		This is typed on the terminal whenever a .PAUSE directive is
encountered in the command file. It tells you how to terminate the .PAUSE
directvive and continue with command file execution.
.SKIP
.LEFT MARGIN 0
.BREAK
[IND - continuing]
.LEFT MARGIN 24
		This is typed after you have typed POP to continue after a
_.PAUSE directive.
.SKIP
.LEFT MARGIN 0
.hl 2 Warning messages
	These messages indicate some condition that, while it does not prevent
the command file from continuing to be executed, may indicate some problem
with your command file that you ought to be aware of. The action you take
depends on how serious you consider the problem to be.
.BREAK
%IND - can't DELAY for a negative amount of time
.LEFT MARGIN 24
		The numeric expression supplied to a .DELAY directive yielded a
negative value. You cannot delay for a negative amount of time.
.BREAK
.SKIP
.left margin 0
%IND - logfile already open
.left margin 24
	You have given a second .LOGFILE command when the previous logfile
was already open. The second command is ignored, and the logfile stays open.
.break
.skip
.left margin 0
%IND - no PTYs available for logging - releasing logfile.
.left margin 24
	IND could not assign a pseudo-terminal for use in creating a logfile.
Thus, no logfile can be created.
.break
.skip
.lm 0
%IND - string is already longer than .PAD length:
.lm 24
	You tried to pad a string to a particular length with the .PAD
directive, but the string was already longer than this. It has not been
modified.
.SKIP
.LEFT MARGIN 0
.hl 2 Fatal error messages.
	These messages indicate an error condition in IND that means that it
cannot safely continue. (There are some exceptions, see the individual
descriptions.) They are all followed by printing of the command line that has
caused the error, and in some cases by the particular portion of that command
that is in question.
.BREAK
?IND - ambiguous:
.LEFT MARGIN 24
		The keyword specified in a .ENABLE or .DISABLE directive is ambiguous, that is it is an abbreviation of more than one valid keyword.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - answer not in range
.LEFT MARGIN 24
		This is not a fatal error. The response given to a .ASKN directive which had specified valid ranges for the answer, did not fall within the ranges allowed in the command file. The question is repeated until the answer is valid. Note that this condition can occur if you have specified both ranges and a default value, but the default value does not lie within the range, and the user attempts to take the default.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - bad numeric constant:
.LEFT MARGIN 24
		IND expected to see a numeric constant at some point in a numeric expression, as what was there was not an open bracket or a numeric symbol. The constant, however, could not be evaluated.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - bad numeric range
.LEFT MARGIN 24
		A numeric expression as part of a substring range or a .ASKx range is not correctly structured.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - bad range format:
.LEFT MARGIN 24
		This indicates incorrect formatting of a substring range, or the range arguments to a directive such as .ASKS or .ASKN. IND has parsed one of the ranges or default values and expects to see either a ":" to indicate another value or "]" to indicate no more ranges. Neither of these was found.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - blank symbol name in declaration list:
.LEFT MARGIN 24
	A comma without a following name, or some other syntactic error, is
present in a declaration list following a .NUMERIC, .LOGICAL, .STRING or .FILE
directive.
.skip
.lm 0
.break
?IND - blank symbol name for .PURGE:
.lm 24
	A .PURGE directive has detected a missing name or an extra comma in
its declaration list. This should be of the form .PURGE var1,var2,var3...
.break
Blanks are permitted between the names and the commas.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - can't .CALL file:
.LEFT MARGIN 24
		The file specified in a .CALL directive cannot be found, or the filespec is invalid. A detailed JSYS error message follows.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - can't .ENABLE DATA without data file open.
.LEFT MARGIN 24
		An .ENABLE DATA directive was issued without a data file having previously being opened via an .OPEN or .OPENA directive.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - can't get get handle on logfile:
.left margin 24
		IND cannot get a JFN for the file specified in the .LOGFILE
directive. A JSYS error message follows. The filespec is probaly incorrect, or
you do not have access to the directory.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - can't OPEN file:
.LEFT MARGIN 24
		The file referenced in a .OPEN or .OPENA directive cannot be opened for write or append access. The JSYS error is given on the following line.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - can't OPEN input file:
.left margin 24
	IND cannot open the file specified in the .OPENI directive, even though
the file exists. This is a rare error. A JSYS error message follows.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - can't RUN program:

.LEFT MARGIN 24
		The program specified in a .RUN directive could not be found, started or mapped for some reason. This message will be followed by a specific JSYS error message explaining why the program could not be found or run. Common errors include specifying an incorrect name for the program (e.g omitting to specify SYS: for TV.)
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - can't open command file:

.LEFT MARGIN 24
		The file specified in a .CALL directive has been found, but  cannot be opened for read access. A JSYS error message follows.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - can't open logfile:
.left margin 24
		IND cannot open the logfile specified in the .LOGFILE directive.
A JSYS error message follows.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - can't understand number:
.LEFT MARGIN 24
		The numeric expression specified as the second argument in a .SETN expresson was invalid for some reason. This message will usually be preceded by some more informative message about the problem encountered in the numeric expression.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - can't understand string comparison: Internal error
.LEFT MARGIN 24
		This is a fatal internal error which should not occur. It should be reported to your system programmers, and will be the result of some catastrophe in a .IF directive.
.skip 1
.break
.lm 0
?IND - cannot initialize fields for parse:
.lm 24
.break
Some error occurred trying to set all field variables in a .PARSE directive
to null before attempting the parse. Some other error will probably already
have been printed indicating the problem. This may be an error in IND, or
you may have too many strings defined.
.skip 1
.break
.lm 0
?IND - Control string is null:
.break
.lm 24
	The control string expression (the second thing in a .PARSE directive)
evaluated to a null string. IND cannot break the parse string into subfields in
this case.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - End of file while searching for label "
.LEFT MARGIN 24
		While attempting to satisfy a .GOTO directive which referenced a label which ahd not yet been found, the end of file was reached. The label, therefore, does not exist, and the .GOTO directive is in error. The target label name is printed out as part of the error message.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - error executing command:
.LEFT MARGIN 24
		Some error occured while using CRCMD to execute an EXEC command. This is usually some error indicating that the EXEC cannot be found, or that there are insufficient system resources to allocate more forks. The exact JSYS error message follows. This error may indicate an internal error in IND.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - error in filename:
.LEFT MARGIN 24
		The filename specified in a .SETFI directive is not valid for some reason. A more explanatory JSYS error message follows.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - error writing to data file:

.LEFT MARGIN 24
		Some system error occured writing to the data file as a result of a .DATA directive. The JSYS error follows on the next line.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - failure to parse command:
.LEFT MARGIN 24
		A line was seen to start with a valid IND directive, and an attempt was made to parse the rest of the directive. This attempt failed for some reason. This message will always be preceded by some more informative message from a part of IND that was trying to cope with the invalid section of your directive.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - fatal internal error in numeric parser - impossible operator invoked.
.LEFT MARGIN 24
		This error should not occur, It indicates an error in IND's numeric parse routines concerning operators.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - File already open:

.LEFT MARGIN 24
		An .OPEN directive was used when another .OPEN directive was already in force, ie the previous .OPEN has not been followed by a .CLOSE. Only one data file may be in use at a time.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - input file already open:
.left margin 24
		An .OPENI directive was used when another .OPENI directive was
already in force, ie the previous .OPENI has not been followed by a .CLOSEI.
Only one input file may be in use at a time.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - invalid filespec:
.LEFT MARGIN 24
		The filespec referenced in a .TESTFILE directive is invalid. A JSYS error message follows which explains the problem further.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - input record too long:
.LEFT MARGIN 24
	A record read from an input file with the .READ directive was longer
than the maximum permitted string length.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - invalid system symbol type
.LEFT MARGIN 24
		An attempt was made to perform substitution using a system symbol not of type string or numeric.
.skip
.lm 0
.break
?IND - length to pad string to is too great:
.lm 24
.break
	The padding length in a .PAD directive must not exceed the maximum
length of a string (currently 120 characters).
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - logical symbol not defined:
.LEFT MARGIN 24
		The symbol referenced in a .IFT or .IFF directive is not a known logical symbol.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - maximum file nesting depth exceeded
.LEFT MARGIN 24
		Too many nested .CALL directives have been issued. The current maximum is 4.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - mismatched " in string constant:
.LEFT MARGIN 24
		A string expression contains an odd number of quote characters (").
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - mismatched quotes while substituting:
.LEFT MARGIN 24
		An apostrophe has been found while substitution was enabled, and it was assumed that this marked the start of a symbol for value substitution. No closing apostrophe was found, however.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - no data file open:
.LEFT MARGIN 24
		A .DATA directive was given without a preceding .OPEN  directive to indicate the destination for secondary data.
.skip
.lm 0
.break
?IND - no field variables for .PARSE:
.break
.lm 24
	After the parse string and control string expression. IND expects
to find a list of variables to receive the individual fields as they are parsed
in a .PARSE directive. It could not find any. Check your syntax.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - no input file open:
.LEFT MARGIN 24
		A .READ or .REWIND directive has been given without a matching .OPENI
directive.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - No name for symbol:
.lm 24
	Some directive that requires a name to define a symbol has been given
a blank name.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - non-numeric system symbol in numeric expression:
.LEFT MARGIN 24
		A system symbol being used in a numeric expression is not of numeric type.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - numeric answer required
.LEFT MARGIN 24
		This is not a fatal error. The response given by the user to a
_.ASKN question was not numeric, or contained invalid data. The question is  repeated until the answer is valid.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - .RETURN when not in subroutine:
.LEFT MARGIN 24
		A .RETURN directive has been given without a matching .GOSUB.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - string length not in range
.LEFT MARGIN 24
		This is not a fatal error. A .ASKS directive has specified maximum and minimum permissible lengths for the user's answer. The user has  supplied an answer outside this range. The question is repeated.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - string space exhausted: recursive call to SQUEEZE.
.LEFT MARGIN 24
		There is no more room left for storage of string symbol values, as an attempt has just been made to collect all unused space, and this has still not freed enough space to store the new string that this command wants to define. Ask your system programmer to build IND with more  string storage space.
?IND - string storage full
.LEFT MARGIN 24
		This error is somewhat misleading. It in fact indicates that IND has no room to store the name of a new symbol (of whatever type) that the current command attempts to define.
.skip 1
.lm 0
.break
?IND - symbol to be parsed does not exist:
.lm 24
.break
	The first variable specified in a .PARSE directive should be of type
string. In this case, it does not appear to exist.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - string too long:
.LEFT MARGIN 24
		A string that is being assigned to a string symbol contains more than 256 characters. This is an absolute upper limit on string lengths.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - subroutine nesting depth exceeded:
.LEFT MARGIN 24
		Too many nested .GOSUBS (currently more than 4) have been  issued. Recode your file to involve less subroutine nesting.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - substring limits invalid:
.LEFT MARGIN 24
		Limits specified for a substring in a string expression either do not specify the correct number of limits, or specify limits which are outside the bounds of the string. If limits are specified to cause substring chopping, there must be two and only two specified, they must both be greater than 1, the upper bound must be greater than or equal to the lower bound, and both bounds must fall within the string length.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - symbol does not exist for increment/decrement:
.LEFT MARGIN 24
		The symbol specified in a .IND or .DEC directive is either not defined, or is defined as not numeric.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - symbol is already defined:
.LEFT MARGIN 24
	A symbol declared in a .LOGICAL, .NUMERIC, .FILE or .STRING directive
is already defined. This is not permitted.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - symbol is invalid type for assignment:
.LEFT MARGIN 24
		The symbol specified in a .SETT, .SETF, .SETN, .SETS or .SETF  directive has already been defined as a symbol of a different type.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - symbol is not a file symbol:
.LEFT MARGIN 24
		The symbol specified as the destination in an .ASKF directive has already been defined with a type other than file.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - symbol is not logical:
.LEFT MARGIN 24
		The symbol specified for assignment in a .ASK directive has already been defined with a type other than logical.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - symbol is not numeric or string for comparison:
.LEFT MARGIN 24
		The symbol specified as the first operand in an .IF directive is not a numeric or string symbol. These symbols must be numeric or string.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - symbol is not numeric:
.LEFT MARGIN 24
		The symbol specified for assignment in a .ASKN directive has already been defined with a type other than numeric.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - symbol is not string:
.LEFT MARGIN 24
		The symbol specified in a .ASKS or .READ directive has already been defined with a type other than string.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - symbol table full
.LEFT MARGIN 24
		There is no room left in IND's internal tables to define the symbol that the current command is attempting to define.
.skip
.lm 0
.break
?IND - Symbol to be .PURGE'd is not defined:
.break
.lm 24
	Some symbol in your .PURGE list has either never been defined, or has
already been purged.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - system symbol in string expression is not of type string:
.LEFT MARGIN 24
		A system symbol in a string expression has been used, but the symbol is not of type string.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - system symbol type not logical:
.left margin 24
		A system symbol in a .IFT or .IFF directive is not of type
logical. Example: .IFT <STRLEN> .GOTO a  .
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - table error on parameter startup
.LEFT MARGIN 24
		This is a serious error encountered when parsing parameters
in an IND command line. This error should never occur.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - undefined symbol for substitution:
.LEFT MARGIN 24
		While attempting to perform substitution of a symbol  enclosed in apostrophes, a symbol was found which was not defined.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - unidentifiable command:
.LEFT MARGIN 24
		A line in a command file began with a dot (".") indicating that it was either an IND directive or a label. It was not a valid IND directive and was not followed by a colon, so could not be a label either. IND cannot understand what you are trying to do.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - unknown numeric symbol in expression:
.LEFT MARGIN 24
		A symbol name in a numeric expression was not numeric or was not defined.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - unknown relational operator:
.LEFT MARGIN 24
		The operator specified in a .IF directive is not a valid comparison operator (ie is not EQ, NE ,=, ~=, etc.).
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - unknown string symbol in expression:
.LEFT MARGIN 24
		A symbol name in a string expression is undefined or is not of type string.
.skip
.lm 0
.break
?IND - unknown string symbol in .PAD:
.lm 24
.break
	The string symbol in a .PAD directive is not a string symbol.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - Unknown string variable to .TRIM:
.lm 24
	The variable given to .TRIM is not of type string, or does not exist.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - Unmatched parentheses:
.LEFT MARGIN 24
		A numeric expression in this command conrains more open brackets than it does close brackets.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - unrecognised .ENABLE/.DISABLE flag:
.LEFT MARGIN 24
		The keyword specified in a .ENABLE or .DISABLE directive is not a known keyword, or valid abbreviation of one.
.SKIP
.LEFT MARGIN 0
.BREAK
?IND - yes or no required
.LEFT MARGIN 24
		As a result of a .ASK directive, the processor asked a question of the user at the terminal. A response was given that was not YES, NO or  return. This error is not fatal - the question is merely repeated until you give a valid answer.
.SKIP
.LEFT MARGIN 0
.BREAK