.AUTOJUSTIFY
.AUTOPARAGRAPH
.DISPLAY LEVELS D
.DISPLAY NUMBER RL
.NUMBER 1
.ENABLE INDEXING
.ENABLE TOC
.FILL
.flags capitalize
.FLAGS INDEX
.FLAGS SUBINDEX
.HEADERS ON
.TITLE <INDEX-<FORTRAN ^CROSS ^REFERENCE AND ^FLOW ^CHART
.JUSTIFY
.LEFT MARGIN 5
.RIGHT MARGIN 75
.PAGE SIZE 56,80
.LOWER CASE
.SKIP 10
.CENTER;	^^INDEX-FORTRAN C\\ROSS ^REFERENCER AND ^FLOW ^CHART ^GENERATOR
.SKIP 2
.CENTER;	^V3.25
.SKIP 20
^michael ^n. ^le^vine
.break
^code 3514
.break
^naval ^weapons ^center
.break
^china ^lake
.break
^california
.break
93555
.skip 2
(619)#939-2465
.break
#<avn##437-2465
.page
.SKIP 5
.CENTER;<ABSTRACT
.SKIP 3
 <INDEX is a <fortran source cross-referenceing and flow charting
utility that allows
the user to look at individual source files (optionally saving the data
for an overall <super <index<) and determine what variables
are used on what lines and how they are used. ^Furthermore the user can
select for display/save for <super <index 
only  those variables or <COMMON blocks
with the characteristics that he is
interested in-global/local, assigned value/not assigned value,
used/unused, imported/exported, etc
in any combination. ^also available is the optional ability to show
up to FOUR additional items of information for display during the regular
and <super <index:
.LEFT MARGIN 10
.RIGHT MARGIN 70
.b
^the variable storage location information
(local, in <common, passed by argument, etc).
.B
^THE VARIABLE TYPE (<REAL< ^F__^FLOATING, STRUCTURED ETC INCLUDEING IF AN ARRAY)
.b
^usage in <function</<subroutine< calls (routine used in and argument
number).
.b
^a user selected tag of up to 31 characters.
.LEFT MARGIN 5
.RIGHT MARGIN 75
.b
^the data saved for a <super <index listing (consisting of 6 data items
as outlined above) can be displayed with a great deal of flexibility as to
the data item SELECTION, order and format (or saved in 
an <isam data file for the user to
work on directly). ^a special option of the <super <index allows the output
of a list of module entry points 
which pass data in and out by argument, the name of each
argument AND IT_'S TYPE , 
the name of any module which call that entry point along with the
the name of each variable passed in the corresponding argument position 
AND IT_'S TYPE.
^the resulting information supplied allows 
the user to follow the flow of data throughout
a program or find the usage of any selected data variable as required.
.p
^if selected, the user may at the same time
generate a flow chart of the source file (optional mini form available)
currently being cross-referenced.
.p
^if wanted, the user can generate in place of the <super <index,
an entry point cross reference listing showing who calls who and is called by
who (with optional
graphical tree output).
.page
.CENTER;<PREFACE
 ^this document is written in two sections. ^each section being directed
toward a different audience. ^the first section consists of
chapters 1, 2, and 3 directed toward the end user who only sees the
built and installed <index program and <generate command file.
^the second section consists of chapters 4, 
5, and 6 directed toward the system manager/programmer
who will be building, installing and maintaining this program.
.note	<important <notice
^this software is in the public domain and as such is supplied at no cost
to the user. ^while every attempt has been made to write this program so
that it will do all that has been shown in this document, it cannot
be guaranteed that all errors have been removed or that in obscure
or pathological cases the program will react properly. ^it is as good
a version as ^I have been able to make it as of this release.
^used as directed,
this program will produce the desired results, but this cannot be guaranteed
for all possible <fortran programs.
 ^if any problems
are found, let me know at the address above along with the details of the
problem including a sample program that brings on the condition and ^I
will make an attempt to fix it. ^further more, if you should make any
bug fixes in your copy, make improvements or otherwise have suggestions
for improvements, let me know so that they can be considered along with
other user inputs for implementation and release to the general public.
.end note
.PAGE
.NOTE ^IMPORTANT ^NOTE TO ^USERS OF ^V3.05 AND ^BEFORE
 ^REREAD THIS DOCUMENT IN THE USAGE OF THE SWITCHES /<ORDER, /<REORDER ,
/<ARGUMENT , /<STORE AND /<STORAGE AS THEIR INTERACTION HAS CHANGED IN
^V3.06.
.END NOTE
.NOTE ^IMPORTANT ^NOTE TO ^USERS OF ^V3.14 AND ^BEFORE
 ^REREAD THIS DOCUMENT IN THE USAGE OF THE SWITCH /<STATISTICS
AS ITS USAGE HAS BEEN CHANGED IN VERSION ^V3.15 .
.END NOTE
.PAGE
.UPPER CASE
.REQUIRE "INDEX.RNT"
.LOWER CASE
.NUMBER 1
.DISPLAY NUMBER D
.PAGE
.header level 1 ^running <index
.INDEX <DEFAULT <EXTENTIONS
.INDEX <FILE <EXTENTION>.<FOR
.INDEX <FILE <EXTENTION>.<TLB
.INDEX <FILE <EXTENTION>.<LIS
.INDEX <SOURCE <FILE
.INDEX <TEXT <LIBRARY
.INDEX <OUTPUT <FILE
 ^in all cases, the defaults for all source input files is _.<for,
text libraries is _.<tlb and output files are _.<lis#.
.HEADER LEVEL 2 ^continuation ^lines
 ^for all types and formats of commands to <index, continuation
lines are allowed provided that they comply with the following
restrictions:
.skip 2
	^the continuation character does not occur in the middle
of a switch including any arguments it may have. ^the entire switch
and any arguments it may have must be complete on a single line.
.skip 2
	^the continuation character does not occur in the middle
of a file specification. ^the complete file specification must be
complete on a single line.
.skip 2
^if the conditions specified above are not followed, the result
is considered a syntax error.
^the continuation character is considered a space when parsing
the resultant command string and is replaced by a space when shown
on the second line of the list file page header. ^all characters following
the continuation symbol are ignored.
^THE prompt for a continuation line is of the form
.break
^file___:
.break
as opposed to the initial command prompt of
.break
^file_:
.break
^the complete command line generated has a maximum length of 1024 characters
including blanks.
.header level 2 ^comments
 ^command lines may contain comments provided they are separated
from the rest of the command line by a _"_!_". ^all characters
following the comment indicator are ignored. ^this is not to be
confused with the /<comment< switch.
.index <switch>/<comment<

.header level 2 ^simple <index
 ^When generating cross reference information for individual files
with no intent on saving that data for a super index or entry point
index, <INDEX can be run in either of two ways:
.skip 2
.INDEX <COMMAND <LINE
<INDEX [/option_1[/option_2[/output=file_spec[...] file_1[,file_2[/library]]

.INDEX <TEXT <LIBRARY
.INDEX <FILE <EXTENTION>.<TLB
.INDEX <INCLUDE <FILES
.INDEX <SWITCH>/<LIBRARY
.skip 2
where the results of the cross reference of the file(s) specified are 
concatenated into a file with the same name as the first input file
unless an output file is specified, then that name is used.
.skip 5
<index
.break
.INDEX <COMMAND <LINE
.INDEX <SWITCH>/<LIBRARY
^file:[/option__1[/output=file__spec[..]]] file__1[,file__2[/library]]
.skip 2
differing from the first form in operation only in that continuation lines
are not allowed.
.PAGE
.header level 2 <super <index
.INDEX <SUPER <INDEX
 The generation of a super index is a two part process. ^part one is
the accumulation of the data needed for the final super index and part two
is the actual generation of the listing.
.header level 3 ^accumulating data for super index
.NOTE
 ^as the data accumulated from multiple source files is stored in scratch
data files, <index  must be brought up and not allowed to exit until
the super index listing is generated or the data accumulated up to that
time will be lost.
.END NOTE
 ^the user first brings up index by issuing the following
command
with no arguments
.skip 2
<index
.skip 2
causing <index to issue the prompt
.skip 2
^file:
.skip 2 
^the user can then submit files for indexing and saving for the super index.
^even though the data is being saved for a super index, an output is generated.
 ^as an example, suppose the user has several files he wants to do a
super index on- <main, <sub1,sub2,sub3 and has library files 
<lib1 used by <sub1 and <sub2 and <lib2 used by <sub3.
^the proper commands would be:
.skip 2
.INDEX <COMMAND <LINE
^file:/<get__super/OUTPUT=nl: <main

.INDEX <SWITCH>/<GET__SUPER
.INDEX <SWITCH>/<OUTPUT
.INDEX <SWITCH>/<LIST
.break
^file:/<get__super/null <sub1,sub2,lib1/library

.index <switch>/<null  
.INDEX <SWITCH>/<LIBRARY
.INDEX <TEXT <LIBRARY
.INDEX <FILE <EXTENTION>.<TLB
.INDEX <INCLUDE <FILES
.break
^file:/<get__super/null <sub3,lib2/library
.skip 2
 ^note that the output is directed to the null device. ^other modifying
switches may also be appended to the command line as the user requires.
^where the user wants to include in the ultimate super <index, data
from several passes over the same source file with different choices
of characteristics and still have a way to differentiate between them
in the super <index, during the /<get__super portion of the <index use
.INDEX <SWITCH>/<GET__SUPER
.INDEX <TAG
.INDEX <VARIABLE <IDENTIFICATION
.INDEX <SUPER <INDEX
.INDEX <SWITCH>/<TAG
the /<tag="xxx" switch to append an identification in addition to the
module name. ^this user specified tag being output during the super <index.
^this option is not limited to multiple passes over one source file, it can
be used to collect data for a super <index from any number of passes
over any number of source files in any order wanted.
^BY THE use of the /<save__index< switch
.index <switch>/<save__index<
the user need only make one pass over a given source, then make multiple
passes over the table for different characteristics to be passed to the
<super <index<, using the /<tag< switch to note the differences.
^care should be taken in the use of this switch as it only works properly
when the source file only contains one module (<subroutine, <function, 
<blockdata, <program ). ^if a file contains more than one source, then
multiple passes over the file should be done instead.
.index <switch>/<tag<

.header level 3 ^generating super index listing
.INDEX <SUPER <INDEX
 ^once the data has been fully accumulated for the super index, the
final listing is generated by issuing the command
.skip 2
.INDEX <COMMAND <LINE
.INDEX <SWITCH>/<DO__SUPER
^file:/<do__super file__spec
.skip
^where all the accumulated data is output to the specified file.
.INDEX <OUTPUT <FILE<
^the format of the super index can be controlled by the use
of the /<reverse or /<reorder< or /<order<
.index <switch>/<reverse
.index <switch>/<reorder<
.index <format <control<
switch and the /<indent< switch. 
.index <switch>/<indent<
^where the default presentation of the super index is
with the variable/<common name as at the beginning of a line
followed by the names of the routines that they were used in.
^This format
can be revised by the /<REVERSE switch which exchanges the 
routine name for the variable/<common name, or by the
/<reorder switch which allows the specification of
any permutation of the SIX(6) items (variable/<common name,
routine name, tag field, storage, VARIABLE TYPE and argument) in any position.
^further format control is available by the use of the /<indent<=x
.index <switch>/<indent<
switch which causes information for each sublevel to be indented and put on
a new line up to the maximum number of sublevels wanted.
^where
the same data needs to be presented in more than one 
manner, the data can be saved for use by the next command line,
rather than being lost as is the default case, append the
switch /<save__super .
.index <switch>/<save__super<
^if the next command is a /<do__super, than the same data is
reused, otherwise it is lost.
.header level 3 ^saving <super <index data for the user 
 ^where the user wants to save the data collected for the <super <index, and
manipulate it for his own use, he may do so by the use of the switch
.b
/<preserve<=filename
.b
.index <switch>/<preserve  
as part of the <super <index command and the data is saved under the 
specified file name in <isam format. ^an example would be
.b
/<do__super</<preserve<=<main.dat</<type</<stat<
.b
.index <switch>/<preserve<  
.index <switch>/<type  
.index <switch>/<stat  
.index <switch>/<do__super  
^the format of the data file is shown under the write up for the 
switch /<preserve< . ^if the user has additional data he wishes to
put into a previously created data file, he may do so by the use of
the /<add__preserve<=file__spec switch instead of the /<preserve<=file__spec
switch. ^both switches are used in the same way except that the file__spec
on the /<add__preserve switch is of a previously created <isam data file.
.index <switch>/<add__preserve<
.header level 3 ^using ^saved <super <index ^data
^if the user wants to use the data saved by the /<preserve and /<add__preserve
switches to do a <super <index, then the /<restore<=file__spec switch is used
in the following manner:
.b
/<do__super</<preserve<=main.dat <tt<_:/<narrow<
.b
.index <switch>/<do__super
.index <switch>/<preserve
.index <switch>/<restore
.index <switch>/<add__preserve  
^the resulting <super <index is then based on the data in the <isam file and
does not require the re_-processing of the source files. 
.header level 3 <super <index ^argument ^passing ^listing
^There is a special form of <SUPER <INDEX that a list of all
cross referenced modules with argument lists and outputs by module
each argument, the name of the argument as defined in the argument
list, and for each call to that entry point, the name of the module
containing the call and the name of the variable passed in the specific
argument position. ^Data for this form of the <SUPER <INDEX is
accumulated by using the switch /<GET__SUPER< , ALL REQUIRED DATA
FOR THE OTHER FIELDS IS AUTOMATICALLY GATHERED.
.index <switch>/<get__super  
.break
$<INDEX</<get__super<#sub1,sub2,sub3
.break
plus any other switches the user may require.
^the <super <index is then generated by the command
.break
^FILE_:/<CALL__ARGUMENT<##OUTPUT__FILE__SPEC
.BREAK
.INDEX <SWITCH>/<CALL__ARGUMENT<
.INDEX <SWITCH>/<DO__SUPER<
^NOTE THAT THE /<DO__SUPER< SWITCH IS <NOT USED FOR THIS OPTION.
^THE /<ORDER< , /<REORDER< , /<REVERSE< AND /<INDENT SWITCHES DO
NOT WORK WITH THIS <SUPER <INDEX OPTION.
.INDEX <SWITCH>/<ORDER<
.INDEX <SWITCH>/<REORDER<
.INDEX <SWITCH>/<REVERSE<
.INDEX <SWITCH>/<INDENT<
.PAGE
.header level 2 ^entry ^point <index

.INDEX <ENTRY <POINT <CROSS <REFERENCE
 The generation of an entry point index like the super index
is a two part process. ^part one is
the accumulation of the data needed for the final entry point 
index and part two
.INDEX <ENTRY <POINT <TREE
is the actual generation of the listing and optional graphical tree
print out.
.header level 3 ^accumulating data for entry point index
.NOTE
 ^as the data accumulated from multiple source files is stored in scratch
data files, <index  must be brought up and not allowed to exit until
the entry point index listing is generated or the data accumulated up to that
time will be lost.
.END NOTE
 ^the user first brings up index by issuing the following
command
with no arguments
.skip 2
<index
.skip 2
causing <index to issue the prompt
.skip 2
^file:
.skip 2 
^the user can then submit files for indexing and saving for the super index.
.INDEX <OUTPUT <FILE
^even though the data is being saved for a super index, no output is generated.
^using the same example as in the super index case, the proper commands
would be:
.skip 2
.INDEX <COMMAND <LINE
<index
.break
.INDEX <SWITCH>/<GET__ENTRY
^file:/<get__entry <main
.break
^file:/<get__entry <sub1,sub2,lib1/library

.INDEX <SWITCH>/<LIBRARY
.INDEX <TEXT <LIBRARY
.INDEX <FILE <EXTENTION>.<TLB
.INDEX <INCLUDE <FILES
.break
^file:/<get__entry <sub3,lib2/library
.skip 2
 ^no other modifying
.INDEX <SWITCH>/<LOG
switches may be appended to the command line except /<log.
.header level 3 ^generating entry point index listing
 ^once the data has been fully accumulated for the entry point index, the
final listing is generated by issuing the command
.skip 2
.INDEX <OUTPUT <FILE
.INDEX <SWITCH>/<DO__ENTRY
^file:/<do__entry file__spec
.skip
^where all the accumulated data is output to the specified file.
.INDEX <ENTRY <POINT <TREE
^optional switches are available to generate the two graphical outputs.
^where the user wishes to save the internal tables built for the
entry point index for a different printout, it can be saved for the
next command by including in the initial command line that built
and output the entry point index the switch 
.INDEX <ENTRY <POINT <TREE <FORMAT <CONTROL
.INDEX <FORMAT <CONTROL
.INDEX <SWITCH>/<SAVE__ENTRY
/<SAVE__ENTRY,  and for
each subsequent output where the user knows that he wants to still save
the table for later command lines, just keep
.INDEX <SWITCH>/<DO__ENTRY
^note that any subsequent command not containing the switch /<do__entry
will cause the data to be lost.
.page
.header level 2 ^flow ^chart ^generation
.index	<flow <chart <generation
 ^the flow chart output can be generated either during a simple <index
or during the first part (data accumulation) of a <super <index. ^the
flow chart option is enabled by the appending onto the command string the
switch /<flow__chart or /<chart .
.index <switch>/<flow__chart<
.index <switch>/<chart<
.p
^the flow chart that is generated by <index, is displayed in a raster
scan manner. ^after building an internal form of the flow chart, the
print out routine starts at the upper left hand corner of the picture
and scans down until the entire length of the strip chart has been
printed.
^as each vertical scan has been completed,
the flow chart scan restarts at the top of the flow chart, and to the
right of where the previous column printed.
.hl 3 ^format ^control
.index <format <control<
.index <switch>/<FLOW<
.INDEX <SWITCH>/<FLOW__CHART<
 ^the default flow chart presentation includes the moving of selected
blocks of code that have only only one input (via a jump) and moving
that code to a point adjacent to the jump and for jumps over 3 pages
in length, the loading of a <flow <connector adjacent to the jump.
^either or both actions can be overridden by arguments in the 
/<flow__chart or /<chart switch.
 ^movement of code can be overridden by the use of the argument
<nomove< .
.index <switch>/<flow__chart><nomove<
.index <switch>/<chart><nomove<
 ^use of ^Flow ^connectors can be overridden and fully drawn in lines for
all jumps show by the use of the argument <noconnector< .
.index <switch>/<flow__chart><noconnector<
.index <switch>/<chart><noconnector<
^this argument results in a significant decrease in run time and an
approximate 50_% increase in pages of output.
 ^a mini version of the flow chart can be generated by the use of the
argument <mini< or its synonym <small< .
.index <switch>/<flow__chart><mini<
.index <switch>/<flow__chart><small<
^this smaller version of the flow chart contains less information than
the full size version but shows the program flow in a smaller area.
^no labels or text is included.
.header level 3 ^flow ^chart ^conventions
.disable toc
.HEADER LEVEL 4 ^MERGEING
.index <merging <symbols
 ^in order to save some space both in memory and on print out, some
merging of source lines into symbols is done. Generally like types
are merged with like types where appropriate: all ^I/^o statements
including the auxiliary statements such as <open or <rewind etc are
considered for merging. ^also considered are contiguous executeable
and non-executeable statements. ^those lines that are candidates for
merging into a single flow chart symbol are then check to see if they
have a label attached that is the target of a branch somewhere, if it
is, then it is not merged, but is the start of a new symbol into
which following statements are candidates to be merged. ^in the case
of ^I/^o statements , they are checked to see if they generate
any branches (<end= or <err=). If so they also start a new symbol.
.header level 4 ^branches
.index <branches
.index <flow <lines
.index <branch <statements
 ^with the exception of <do and block <if statements, all lines
causing a branch will show that branch leaving from the right side
of the source symbol. ^If the subject symbol is the source of
multiple branches ( arithmetic <if, computed or assigned <goto, or
^I/^o with both <end= and <err=) all the branches are considered to leave
from the same point on that symbol and flow out to the right together
along the same horizontal line until the appropriate vertical line
dedicated for the specific target label is reached, then that part of
the multiple branch statement using that label as a target is considered
to leave the common horizontal line to go up or down to the target.
.header level 4 ^flow ^line ^junctions
.index <flow <lines
^with even a moderate size program, there can be a great number of flow
lines moving around the flow chart, many cross, some where they join
and others where they just have to jump over each other. ^in order to
clarify junctions from points where two flow lines just happen to jump
over each other, the junction symbol
.index <junction <symbol
 "_*" is used. ^It appears when a flow line changes direction and_/or
when flow lines join. ^this can be a bit confusing when a horizontal
line from a multiple label branch statement merges or joins up
with several vertical lines to specific labels and just jumps over others.
.enable toc
.header level 3 ^flow ^chart ^symbols
.disable toc
^as implemented at this time, a generic flow chart picture element is
13 characters wide and 9 deep as follows:
.tp   16
.literal
	Full sized ICON			Mini ICON
	
	<---->*<---->			--*--
	|nnnnn|     |			|xxx|
	| xxxxxxxxx |			--*--
	| xxxxxxxxx |
	>-xxxxxxxxx-<
	  xxxxxxxxx
	  xxxxxxxxx
	      |
	<---->v<---->

.end literal
where the field inside the "x"'s is the symbol for a specific line type or
is simply the connector lines show extended through the center for the
flow lines. ^the symbol "nnnnn" represents the value of any label that
may be attached to this symbol (if any). ^depending on the flow lines
actually going into a given picture element and its direction, a given line
and its corresponding direction arrow may or may not present.
.skip 2
^the flow chart program generates the following symbols:
.tp 12
^the basic box used to represent executeable and non executeable statements not
otherwise included below.
.literal	 	               
		   Full Size		Mini

	 	   ---------   		
	 	   |       |   		 | |
	 	   |       |   
	 	   |       |   
	 	   ---------   

.end literal	 	               
.tp 12
^the <DO box, where the n's are the loop label (if any) and the x's are
the first characters of the loop control equation. ^this applies to
both forms of the <do statement.
.literal            

		   Full Size		Mini
	 	   ---------   
	 	   |DOnnnnn|   		DO
	 	   |xxxxxxx|   
	 	   |xxxxxxx|   
	 	   ---------   

.end literal	 	               
.tp 12
^the <continue box, representing the <continue statement.
.literal	 	               
		   Full Size		Mini
	 	   ---------   
	 	   | CONT- |   		CON
	 	   | INUE  |   
	 	   |       |   
	 	   ---------   

.end literal	 	               
.tp 12	 	               
<call statement. ^name of call routine inserted inside.
.literal	 	               
	 	   Full Size		Mini
	 	   ---------   
	 	   ||     ||   
	 	   ||     ||   		|||
	 	   ||     ||   
	 	   ---------   
	 	               
.end literal	 	               
.tp 12
^all ^I/^o including auxiliary lines.
.literal	 	               
		   Full Size		Mini	 	               
	 	       -----   
	 	      /   /    
	 	     /   /     		/ /
	 	    /   /      
	 	   -----       
	 	               
.end literal	 	               
.tp 12
^all forms of the <if and <elseif statements. ^the labels ^t and ^f
are put next to the right and bottom exits as appropriate to denote
the <.true. and <.false. actions. ^the first few characters of the
logical equation are fitted inside the symbol.
.literal
		  Full Size	Mini(arith)	Mini(Logical)	Mini(Block)
	 	       ^       
	 	     /   \     	< >		< T		< F
	 	   <       >   
	 	     \   /     
	 	       V       
.end literal	 	               
.tp 12
^all forms of the <goto statement. ^Assigned <goto has the variable name
inserted, and the simple goto has the destination label inserted.
.literal	 	               
		   Full Size		Mini	 	               
		   -------     
		   |      \    
		   |       >   		   >
		   |      /    
		   -------     
	 	               
.end literal
.tp 12
^assign a label to a variable for assigned <goto. ^the label and variable names
are inserted.
.literal
		   Full Size		Mini	 	               
	 	     -----     
	 	    /     \    
	 	   <       >   		/ \
	 	    \     /    
	 	     -----     
	 	               
.end literal	 	               
.tp 12
^All program entry points, the
name is inserted.
.literal
		   Full Size		Mini
	 	     -----     
	 	    (     )    
	 	   (       )   		( )
	 	    (     )    
	 	     -----     
	 	               
.end literal
.tp 12
<pause flow control statement. ^The first few characters of
any text in the statement is inserted in the symbol.
.literal
		   Full Size		Mini
	 	     -----     
	 	    (PAUSE)    
	 	   (       )   		(P)
	 	    (     )    
	 	     -----     

.end literal
.tp 12
<STOP flow control statement. ^The first few characters of
any text in the statement is inserted in the symbol.
.literal
		   Full Size		Mini
	 	     -----     
	 	    ( STOP)    
	 	   (       )   		(S)
	 	    (     )    
	 	     -----     

.end literal
.tp 12
<RETURN flow control statement. ^The first few characters of
any text in the statement is inserted in the symbol.
.literal
		   Full Size		Mini
	 	     -----     
	 	    (RETURN)    
	 	   (       )   		(R)
	 	    (     )    
	 	     -----     

.end literal
.tp 12
<END flow control statement.
.literal
		   Full Size		Mini
	 	     -----     
	 	    ( END )    
	 	   (       )   		(E)
	 	    (     )    
	 	     -----     

.end literal
.TP 14
<FLOW <CONNECTOR symbol is used when the destination of a jump is over
3 pages distant. ^in that case the jump is to an immediately adjacent
^flow ^connector which contains the label of the destination being
jumped to.
.literal
		   Full Size		Mini
	 	       -     
	 	     /   \    
	 	    (     )   		>()
	 	     \   /    
	 	       -     

.end literal
.TP 12
^THE GENERAL CONNECTOR TYPE OF PIXEL HAS THE FORM
.LITERAL
		   Full Size			Mini
                   <-----*----->
                   |Lbl_1^Lbl_2|		--*--
                   |     |     |		| + |
                   |     |     |		__*__
                   ----->+<-----
                      <=>|
                     ERR=|
                     END=VLbl_3
                   <-----*----->
.END LITERAL
^actually the symbol above represents the most complex possible display of
the connector pixel. ^in actuality, it can vary from this form to
a blank area. ^the flow lines in the connector pixel while show to go
in specific directions in the example above, are reversible, the
flow direction arrows indicate the direction. ^junctions between
flow lines are indicated by a '*', other wise they are considered to
not meet but skip around each other. ^the other symbols are used as follows:
.break
<err=
.break
<end=
.break
the non connector symbol to the left of this connector is an <I/o symbol
for a statement that had an <end= and/or <err= in it. ^the <I/o statement
sends off to its right a horizontal line indicating the branch off from
the main program flow for both conditions. ^at the point the output line
from the <I/o symbol joins a vertical line heading for the specified 
label destination for either or both of the conditions, the appropriate
label is put up to differentiate as to which one is taking the turn.
.break
_<_=_>
.break
^actually three different symbols. ^these are use when the connector is
to the right of an arithmetic <if statement. ^all the 3 possible destinations
come out the right side of the <if symbol. ^where the horizontal line
from the <if meets a vertical line going to one of the specified 
destination labels, a junction occurs and the appropriate symbol(s)
are included to indicate which is/are being taken at that point.
.p
^also included are up to three labels. ^lbl__1 is used when
the upper flow back line going horizontally back to the pixel
defining a specific label makes a junction with a vertical line going
to that label, the label number is output here. ^lbl__2 is used
when a horizontal line coming from a flow control transfer statement
forms a junction with a vertical line going <up to the level of the
destination label, the value of the label is put in this location.
^lbl__3 is used when a horizontal line coming from a flow control
transfer statement forms a junction with a vertical line going <down
to the level of the destination label, the value of the label is put
in this location.
.NOTE	<WARNING
 ^The flow chart option is not generated by the <index command file generator
<generate.com  and its use is <not recommended for casual use. ^the flow chart
option makes extensive use of <cpu time ,  ^virtual ^memory and paper . 
^during its
operation , depending on the system working set size limitation, causes
a great deal of page faulting due to its repeated scans of internal tables
and arrays causing both this program and the system in general to bog down.
^after the program has completed its run , the pile of paper required to
print out the resulting flow chart can be quite thick.
 ^this option is a hog, so use it <only on an <as <needed <basis. ^use of the
statistics option will show the extent of the problem.
.end note
.enable toc
.PAGE
.header level 2 ^switches ^available 
.DISABLE TOC
.header level 3 /<add__preserve<=file__spec
 ^used with the /<do__super switch. Outputs <super <index data to an <isam
file. ^this is the same as the /<preserve switch except that the destination
file for the data already exists (been created by the /<preserve switch).
^see also /<restore .
.index <switch>/<add__preserve 
.index <switch>/<preserve  
.index <switch>/<restore  
.header level 3 /<append

.INDEX <SWITCH>/<APPEND
 ^Append the output list file of this module to the end of the
specified list file. ^same as /<merge .

.INDEX <SWITCH>/<MERGE
.HEADER LEVEL 3 /<ARGUMENT
.index <switch>/<argument<
^Used during simple <INDEX . ^Saves information
on the use of variables as arguments in <SUBROUTINE and <FUNCTION calls.
The output of the simple <INDEX listing contains that information as part
of the how used information. ^The format for each use is reported as follows
lll_-<CALLING<__<ARG<__xxxxxx__nnnn  where _'lll_' is the line number,
_'xxxxxx_' is the
name of the routine in which that variable appears as an argument, and
_'nnnn_' is a 4 digit number showing what argument number it is.
^THIS SWITCH IS NOT NEEDED TO ACCUMULATE ARGUMENT INFORMATION FOR THE
<SUPER< <INDEX<.

.HEADER LEVEL 3 /<CALL__ARGUMENT<

.INDEX <SWITCH>/<CALL__ARGUMENT<
.INDEX <SUPER <INDEX

^This is a special form of the <SUPER <INDEX. ^It generates a list of all
cross referenced modules with argument lists and outputs by module
each argument, the name of the argument as defined in the argument
list, and for each call to that entry point, the name of the module
containing the call and the name of the variable passed in the specific
argument position. ^Data for this form of the <SUPER <INDEX MUST first be
accumulated using the switch /<GET__SUPER<  and when
the output is generated, this switch is used not the /<DO__SUPER<.
.INDEX <SWITCH>/<GET__SUPER<
.INDEX <SWITCH>/<DO__SUPER<

.header level 3/<CALLED__BY__TREE

.INDEX <SWITCH>/<CALLED__BY__TREE
.INDEX <ENTRY <POINT <TREE
  ^used only in the same command as /<do__entry during the generation
.INDEX <SWITCH>/<DO__ENTRY
of the entry point cross-reference. ^Orders <index to create a 
graphical representation
of the routes by which modules are called from the main routine.
^the following flag characters can follow the symbol in the table:
.INDEX <EXCESSIVE <GRAPHICAL <NESTING <DEPTH
"*" means that the combination of nesting depth and symbol length
would normally have forced at least part of the entry point name
off the printing page (80/132 column), but instead the indentation has been
adjusted to allow room for the symbol and flags,
.INDEX <UNKNOWN <ENTRY <POINT
"?" indicates that this
entry point is called but has not been defined in any of the modules
processed for this entry point cross reference, 
.INDEX <RECURSIVE <ENTRY <POINT
"_#" indicates that this
entry point  has been called recursively and no further processing has been
done as to do so would have been an endless loop.
^see also /<calling__tree

.INDEX <SWITCH>/<CALLING__TREE
.header level 3 /<CALLING__TREE

.INDEX <SWITCH>/<CALLING__TREE
.INDEX <ENTRY <POINT <TREE
.INDEX <SWITCH>/<DO__ENTRY
 ^used only in the same command as /<do__entry during the generation of the
entry point cross-reference. ^orders <index to create a 
graphical representation
of the calling tree. The Main program to the left side, and indented
for each level of call.
^the following flag characters can follow the symbol in the table:
.INDEX <EXCESSIVE <GRAPHICAL <NESTING <DEPTH
"*" means that the combination of nesting depth and symbol length
would normally have forced at least part of the entry point name
off the printing page (80/132 column), but instead the indentation has been
adjusted to allow room for the symbol and flags, 
.INDEX <UNKNOWN <ENTRY <POINT
"?" indicates that this
entry point is called but has not been defined in any of the modules
processed for this entry point cross reference, 
.INDEX <RECURSIVE <ENTRY <POINT
"_#" indicates that this
entry point  has been called recursively and no further processing has been
done as to do so would have been an endless loop.
 ^see also /<called__by__tree.

.INDEX <SWITCH>/<CALLED__BY__TREE
.header level 3 /<CHANGED

.INDEX <SWITCH>/<CHANGED
 ^Output to list file and save for SUPER INDEX only those variables that
have been assigned a value in the source file. ^see also /<unchanged,
/<used, and /<unused.

.INDEX <SWITCH>/<UNCHANGED
.INDEX <SWITCH>/<USED
.INDEX <SWITCH>/<UNUSED
.header level 3 /<chart<[=[<nomove<][:][<noconnector<][:][<mini<][:][<small<]]
.index <switch>/<chart
.index <switch>/<flow__chart
.index <switch>/<flow__chart<><noconnector
.index <switch>/<flow__chart<><nomove
.index <switch>/<flow__chart<><mini
.index <switch>/<flow__chart<><small
.index <switch>/<chart<><noconnector
.index <switch>/<chart<><nomove
.index <switch>/<chart<><mini
.index <switch>/<chart<><small
.index <format <control
 ^used during simple <index or gathering data for <super <index to
generate a flow chart of the module currently being cross referenced.
 ^The optional arguments allow modification of the ^Flow-^Chart format.
^Normally all blocks of code that have only one input and that via
some sort of jump, are moved to a location adjacent to the source
of that jump. The argument <NOMOVE will disable that feature.
^Normally all jumps to a location over 3 pages distant are not drawn
in, rather the flow line from the jump statement goes to an immediately
adjacent <FLOW<_-<CONNECTOR<. ^The argument <NOCONNECTOR will disable this
this feature. ^Note that the use of the <NOCONNECTOR argument will
decrease run time and page faulting a significant amount at the
expense of approximately 50_% more output.
 ^the argument <mini< or its synonym <small< will produce a reduced version
of the flow chart.
^same as /<flow__chart .
.index <flow <chart

.header level 3 /<comment="  "

.INDEX <SWITCH>/<COMMENT
 ^Allows the user to insert into the second line of the listing header
any comments that
he may wish to include. ^the comment must be enclosed in double quotes.
.header level 3 /<common__blocks

.INDEX <SWITCH>/<COMMON__BLOCKS
.INDEX <COMMON <BLOCKS
^Lists <common blocks by name in each module. ^can be modified by
.INDEX <SWITCH>/<UNCHANGED
.INDEX <SWITCH>/<USED
.INDEX <SWITCH>/<UNUSED
.INDEX <SWITCH>/<CHANGED
/<used, /<unused, /<changed, /<unchanged. ^the <common block name takes
the attributes of all the variables contained within it. ^blank

.INDEX <BLANK <COMMON
<common is displayed by the name "(<blank__common)". ^as an example,
allows the user to separate out common blocks from modules where they
are not needed.
.header level 3 /<DEBUG

.INDEX <SWITCH>/<DEBUG
.INDEX <DEBUG <LINES
.INDEX <SWITCH>/<D__LINES
 ^treat debug lines as executeable source (<FORTRAN /<D__LINES switch)
.header level 3 /<delete

.INDEX <SWITCH>/<DELETE
 ^used with the /<spool or /<print switches, 
.INDEX <PRINT <QUEUE
.INDEX <SWITCH>/<SPOOL
.INDEX <SWITCH>/<PRINT
.INDEX <OUTPUT <FILE
causes the current output file to be
deleted after the print symbiont has completed printing the file.
^if used without the /<spool or /<print switches, the current output file will
be deleted upon completion of the current input file.
.header level 3 /<depth=n

.INDEX <SWITCH>/<DEPTH
.INDEX <ENTRY <POINT <TREE
.INDEX <ENTRY <POINT <TREE <FORMAT <CONTROL
During output of the graphical calling/called by trees in the entry point
cross reference, all subroutines nested deeper than the specified value
will not be output. ^no indication will be made about the entry point
names that may have been truncated.
.header level 3 /<D__LINES

.INDEX <SWITCH>/<DEBUG
.INDEX <DEBUG <LINES
.INDEX <SWITCH>/<D__LINES
 ^treat debug lines as executeable source. ^SAME AS /<DEBUG .
.header level 3 /<DO__ENTRY

.INDEX <SWITCH>/<DO__ENTRY
.INDEX <ENTRY <POINT <TREE
 ^Using previously accumulated data, generate a listing of entry points,
who they call, and who they are called by. ^see also /<calling__tree,
/<called__by__tree and /<nolibrary.

.INDEX <SWITCH>/<CALLING__TREE
.INDEX <SWITCH>/<CALLED__BY__TREE
.INDEX <SWITCH>/<NOLIBRARY__FUNCTIONS
.header level 3 /<DO__SUPER

.INDEX <SWITCH>/<DO__SUPER
.INDEX <SUPER <INDEX
 ^Using previously accumulated data, generate a <SUPER <INDEX listing.
.header level 3 /<export

.INDEX <SWITCH>/<EXPORT
 ^list those variables set by the current module for use by other 
modules. ^variables with the following characteristics are considered
to be exported:
.break
^global (in common) and set to a value
.break
^passed as one of the arguments in the <subroutine/<function/<entry statement
and set to a value.
.break
^an argument in a <function call (not statement functions)
.break
^used as an argument in a call statement and set to a value.
.break
(pass through values from other modules and only used as a call argument
are considered imported variables).
.BREAK
^defined <function/<entry point name which is assigned a value
.skip 2
^see also /<import.

.INDEX <SWITCH>/<IMPORT<
.HEADER LEVEL 3 /<EXTEND__SOURCE<

.INDEX <SWITCH>/<EXTEND__SOURCE<
 ^EXTEND THE LENGTH OF THE LINE CONSIDERED PART OF THE SOURCE FROM COLUMN
72 TO COLUMN 132. ^THIS CAN ALSO BE IMPLEMENTED BY THE USE OF THE <OPTION<
STATEMENT IN THE SOURCE CODE.
.header level 3 /<file__name

.INDEX <SWITCH>/<FILE__NAME
.INDEX <SWITCH>/<DO__ENTRY
 ^used with the /<do__entry switch. causes the name of the file containing
the specified module to be output as part of the <calls/<called <by tabular
listing.

.header level 3 /<flow__chart<[=[<nomove<][:][<noconnector<][:][<mini<][:][<small<]]
.index <switch>/<chart
.index <switch>/<flow__chart
.index <switch>/<flow__chart<><noconnector
.index <switch>/<flow__chart<><nomove
.index <switch>/<flow__chart<><mini
.index <switch>/<flow__chart<><small
.index <switch>/<chart<><noconnector
.index <switch>/<chart<><nomove
.index <switch>/<chart<><mini
.index <switch>/<chart<><small
.index <format <control
 ^used during simple <index or gathering data for <super <index to
generate a flow chart of the module currently being cross referenced.
 ^The optional arguments allow modification of the ^Flow-^Chart format.
^Normally all blocks of code that have only one input and that via
some sort of jump, are moved to a location adjacent to the source
of that jump. The argument <NOMOVE will disable that feature.
^Normally all jumps to a location over 3 pages distant are not drawn
in, rather the flow line from the jump statement goes to an immediately
adjacent <FLOW<_-<CONNECTOR<. ^The argument <NOCONNECTOR will disable this
this feature. ^Note that the use of the <NOCONNECTOR argument will
decrease run time and page faulting a significant amount at the
expense of approximately 50_% more output.
 ^the argument <mini< or its synonym <small< will produce a reduced version
of the flow chart.
^same as /<chart .
.index <flow <chart

.header level 3 /<GET__ENTRY

.INDEX <SWITCH>/<GET__ENTRY
.INDEX <SWITCH>/<LOG
 ^Break out of the specified source file all entry point information
and save it for later output (no list file generated).See /<log.
.header level 3 /<GET__SUPER

.INDEX <SWITCH>/<GET__SUPER
.INDEX <SWITCH>/<LOG
 ^Accumulate the information in the current source file for eventual
output in a <SUPER <INDEX. ^THE INFORMATION AUTOMATICALLY GATHERED
INCLUDES VARIABLE_/<COMMON< NAME, TYPE, STORAGE, ARGUMENT USAGE
AND MODULE NAME ALSO ANY TAG FIELD SPECIFIED BY THE USER. ^see /<log.

.header level 3 /<GLOBAL

.INDEX <SWITCH>/<GLOBAL
 ^Accumulate for output and <SUPER <INDEX only global variables
(reside in COMMON). ^see /<local.

.INDEX <SWITCH>/<LOCAL
.header level 3 /<HELP[= option] or [=( [/]option[,[/]option[.....]])]

.INDEX <SWITCH>/<HELP
 ^Bring up help file. For a particular subtopic use the form
.skip 2
/<HELP<=subtopic 
.skip 2
or if it is a switch use the form
.skip 2
/<HELP<=(/subtopic)
.skip 2
in the case of nested information
.skip 2
/<HELP<=([/]subtopic,[/]subtopic,........)
.skip 2
after each use of the /<help switch, <index returns to its prompt
rather than allowing the user to directly ask for more help. This switch
overrides any other commands that may reside on the same command line.
.header level 3 /<import

.INDEX <SWITCH>/<IMPORT
 ^list those variables imported from outside the current module and
used. ^to be considered to be imported, a variable must meet the following
criteria:
.break
^global (reside in common) and used
.break
^appear in the argument list of the defining <subroutine/<function/<entry
statement and be used
.break
^the returned value form a function call
.break
^arguments appearing in a subroutine <call which are used.
.break
^variables which are imported, used then changed (modified), are considered
to be exported even though they fit in both categories.
.SKIP 2
^see also /<export.

.INDEX <SWITCH>/<EXPORT

.header level 3 /<INDENT<=x
.index <switch>/<indent<
.index <switch>/<tag<
.index <switch>/<reverse<
.index <switch>/<order<
.index <switch>/<reorder<
^Format control switch for <SUPER <INDEX output. ^Produces an indented
listing to the depth indicated by "x" (x=0 to 5), default value
is "0". For the sake of clarity, "x" should be less than or equal
to the number of items in the <SUPER <INDEX output. ^the basic output
is 2 items (variable/common name and the module name), the use of
the switches /_[<RE<_]<ORDER< OR /<REVERSE< and/or /<TAG<="xxxxx" ADDS
to the number AND ORDER of THE items in the output.

.header level 3 /<LIBRARY

.INDEX <SWITCH>/<LIBRARY
.INDEX <TEXT <LIBRARY
.INDEX <INCLUDE <FILES
.INDEX <FILE <EXTENTION>.<TLB
 ^the file to which this switch is appended 
is a text library that is searched for input because of  
<INCLUDE '(module__spec)' statements.
.header level 3 /<LIST=file__spec

.INDEX <SWITCH>/<LIST
.INDEX <OUTPUT <FILE
.INDEX <LIST <FILE
.INDEX <FILE <EXTENTION>.<LIS
 ^Specify output file when file name is other than input file name
^Same as /OUTPUT=file__spec. When no output file spec is given, the default
.INDEX <SWITCH>/<OUTPUT
output file name is the same as that of the first input source file.
^see also /<type and /<null< .
.index <switch>/<type  
.index <switch>/<null  

.header level 3 /<LOCAL

.INDEX <SWITCH>/<LOCAL
 ^Accumulate for output and <SUPER <INDEX only local variables
(do not reside in COMMON). ^see /<global.

.INDEX <SWITCH>/<GLOBAL
.header level 3 /<LOG

.INDEX <SWITCH>/<LOG
 ^Output module names as completed and command lines as inputed.
^see also /<get__super and /<get__entry.

.INDEX <SWITCH>/<GET__SUPER
.INDEX <SWITCH>/<GET__ENTRY
.header level 3 /<MERGE

.INDEX <SWITCH>/<MERGE
 ^Append the output list file of this module to the end of the
specified list file. ^same as /<append .

.INDEX <SWITCH>/<APPEND
.header level 3 /<NARROW

.INDEX <SWITCH>/<NARROW
.INDEX <FORMAT <CONTROL
.INDEX <OUTPUT <FORMAT <WIDTH <CONTROL
 ^Output is formatted for listing on a terminal (80 col). Used with any
index operation producing a listing. ^see /<wide.

.INDEX <SWITCH>/<WIDE
.header level 3 /<noentry__table

.INDEX <SWITCH>/<NOENTRY__TABLE
.INDEX <FORMAT <CONTROL
.INDEX <ENTRY <POINT <TABLE <SUPRESSION
.INDEX <SWITCH>/<DO__ENTRY
^suppresses the output of the tabular entry point table when doing
an entry point cross reference.
.header level 3 /<NOINDEX

.INDEX <SWITCH>/<NOINDEX
.INDEX <CROSS <REFERENCE <TABLE <SUPRESSION
.INDEX <SUPER <INDEX
^Suppresses the listing of the <INDEX cross-reference table during
simple and accumulate for <SUPER <INDEX operations. ^data saving for
<super <index is not affected.
.header level 3 /<NOLIBRARY__FUNCTIONS

.INDEX <SWITCH>/<NOLIBRARY__FUNCTIONS
.INDEX <FORTRAN <LIBRARY <ROUTINES
.INDEX <SYSTEM <LIBRARY <ROUTINES
.INDEX <UNDEFINED <ENTRY <POINTS
.INDEX <SWITCH>/<DO__ENTRY
 ^Used with /DO__ENTRY. Any undefined entry points are checked
against an internal list of FORTRAN library routines and for
the presence of a "$" in the name. If either condition is
met, the symbol is not printed out in the entry point
cross reference. Note that when used in combination with the 
.INDEX <SWITCH>/<SAVE__ENTRY
/<SAVE__ENTRY switch, this switch is only effective when used
on the initial command line outputting the entry point cross reference,
and its effect is permanent for that saved data set.
.header level 3 /<NOSOURCE

.INDEX <SWITCH>/<NOSOURCE
.INDEX <FORMAT <CONTROL
.INDEX <SOURCE <LISTING <SUPRESSION
 ^Do not include the source listing in the list file. ^used only in
simple index and accumulation for super index outputs.
.header level 3 /<null     

.index <switch>/<null   

.INDEX <SWITCH>/<LIST
.INDEX <SWITCH>/<OUTPUT
.INDEX <OUTPUT <FILE
.INDEX <LIST <FILE
.INDEX <FILE <EXTENTION>.<LIS
 ^specifies that the list file (if any) generated by this command
is directed to the null device (<nl_:) .
^this is the same as /<list<=<nl<_: .
^see also /<type /<list and /<output .
.index <switch>/<type  

.header level 3 /<order<=MAJOR__item:MINOR__item[:Tag1[:tag2[:TAG3[:TAG4]]]]

.INDEX <SWITCH>/<ORDER  
.INDEX <SUPER <INDEX <FORMAT <CONTROL
.INDEX <FORMAT <CONTROL
.INDEX <TAG
.INDEX <STORAGE <LOCATION
.index <argument <usage<
.INDEX <VARIABLE <TYPE<

^Used with the /<DO__SUPER switch and is a super set of the /<REVERSE

.INDEX <SWITCH>/<DO__SUPER
.INDEX <SWITCH>/<REVERSE
.INDEX <SUPER <INDEX

switch. The <SUPER <INDEX data consists of up to 6 items, The variable/<common
name, module name in which that variable/<COMMON name was defined,
the tag (if specified) , the variable storage location , the argument usage
information AND VARIABLE TYPE.
^The normal output of the <SUPER <INDEX is a 
major heading of the variable/<COMMON name followed by all the module
.INDEX <COMMON <BLOCKS
names (minor items) applying to that variable/<COMMON name .
^If the user
does not want the default items selected in the default order, these
can then be over ridden by the use of this switch. The items wanted
are specified in the order wanted and those available items that are
not wanted are not listed in the argument list. The argument list
must be a minimum of two(2) items and a maximum of six(6) items with
no repeats. The six items that can be specified are:
.break
##<NAME<####-for variable/<COMMON name (<variable or <common can also be used)
.break
##<MODULE<##-for the defining module name
.break
##<TAG<#####-for the tag string
.break
##<STORAGE<#-for the storage location information (<store can also be used)
.break
##<argument<-for the argument usage information
.break
##<TYPE<-FOR THE VARIABLE TYPE INFORMATION
.BREAK
.index <switch>/<ORDER><NAME<
.index <switch>/<ORDER><MODULE<
.index <switch>/<ORDER><TAG<
.index <switch>/<ORDER><STORAGE<
.index <switch>/<ORDER><STORE<
.index <switch>/<ORDER><ARGUMENT<
.index <switch>/<order><variable<
.index <switch>/<order><common<
.INDEX <SWITCH>/<ORDER><TYPE<
.break
 ^this switch is the same as /<reorder . ^used with the /<indent switch
for <super <index format control.
.index <switch>/<indent<
.INDEX <SWITCH>/<reORDER
.header level 3 /<OUTPUT<=file__spec

.INDEX <SWITCH>/<OUTPUT
.INDEX <OUTPUT <FILE
.INDEX <LIST <FILE
.INDEX <FILE <EXTENTION>.<LIS
 ^Specify output file when output file name is other than input file name.
Same as /<LIST<=file__spec
^see also /<type and /<null .
.index <switch>/<type  
.index <switch>/<null 
.INDEX <SWITCH>/<LIST
.header level 3 /<PREPROCESSOR

.INDEX <SWITCH>/<PREPROCESSOR
.INDEX <FLECS
.INDEX <PREPROCESSOR <LINE <NUMBERS
 ^Use PREPROCESSOR produced line numbers found in columns 73-80 for
cross reference. Starts scanning at column 80 and moves back to 
column 73, skipping blanks and nulls. If no line number is found,
the last line number obtained is kept (if the last line number is zero,
it is reset to 1).
.header level 3 /<print

.INDEX <SWITCH>/<PRINT
.INDEX <PRINT <QUEUE
 ^Spool the list file to the printer upon completion of current module
index. Same as the /<spool switch. ^See also /<delete

.INDEX <SWITCH>/<SPOOL
.INDEX <SWITCH>/<DELETE
.header level 3 /<preserve=filename    

.index <switch>/<preserve
^used with the /<do__super switch at <super <index generation time
.index <switch>/<do__super
to cause the data being used for the current <super <index being generated
to be saved in an <isam file for the user to manipulate with his own
program. ^the <isam file is set up as follows:
.b
each record is 197 bytes long and is broken up into 6 fields THE FIRST
FIVE OF WHICH ARE USED AS <ISAM< KEYS. ^the first
byte in each field is a count of the number of <ascii characters that
follow. ^the rest of the field is a string of characters left justified
and blank filled on the right.
.tp 14
.literal


Field  Name        Count   String  String      
                   Byte    Start   Length
                   Loc     Loc     in bytes
    0  VARIABLE        0        1        31  Variable/COMMON name
    1  MODULE         32       33        31  Name of module found in
    2  TAG            64       65        31  User specified tag field 
    3  STORAGE        96       97        31  Variable storage location
    4  ARGUMENT      128      129        36  Variable argument usage
    5  TYPE          165      166        31  Variable type

.end literal
.index <switch>/<tag  
.index <switch>/<storage  
.index <switch>/<store  
.index <switch>/<argument<
^the <isam file itself uses five (5) keys numbered zero(0) to four(4), 
with the key numbers corresponding
to the field number shown above and consisting of the corresponding string
(excluding the count byte) . ^the last field five(5) is not used as an <isam
key. ^a sample <fortran program is supplied that
illustrates how to access the available data.
^see also /<restore and /<add__preserve .
.index <switch>/<restore  
.index <switch>/<add__preserve  
.header level 3 /<reorder<=MAJOR__item:MINOR__item[:Tag1[:tag2[:TAG3[:TAG4]]]]

.INDEX <SWITCH>/<REORDER<  
.INDEX <SUPER <INDEX <FORMAT <CONTROL
.INDEX <FORMAT <CONTROL
.INDEX <TAG
.INDEX <STORAGE <LOCATION
.index <argument <usage<
.INDEX <VARIABLE <TYPE<

^Used with the /<DO__SUPER switch and is a super set of the /<REVERSE

.INDEX <SWITCH>/<DO__SUPER
.INDEX <SWITCH>/<REVERSE
.INDEX <SUPER <INDEX

switch. The <SUPER <INDEX data consists of up to 6 items, The variable/<common
name, module name in which that variable/<COMMON name was defined,
the tag (if specified) , the variable storage location , the argument usage
information AND VARIABLE TYPE.
^The normal output of the <SUPER <INDEX is a 
major heading of the variable/<COMMON name followed by all the module
.INDEX <COMMON <BLOCKS
names (minor items) applying to that variable/<COMMON name .
^If the user
does not want the default items selected in the default order, these
can then be over ridden by the use of this switch. The items wanted
are specified in the order wanted and those available items that are
not wanted are not listed in the argument list. The argument list
must be a minimum of two(2) items and a maximum of six(6) items with
no repeats. The six items that can be specified are:
.break
##<NAME<####-for variable/<COMMON name (<variable or <common can also be used)
.break
##<MODULE<##-for the defining module name
.break
##<TAG<#####-for the tag string
.break
##<STORAGE<#-for the storage location information (<store can also be used)
.break
##<argument<-for the argument usage information
.break
##<TYPE<-FOR THE VARIABLE TYPE INFORMATION
.BREAK
.index <switch>/<REORDER><NAME<
.index <switch>/<REORDER><MODULE<
.index <switch>/<REORDER><TAG<
.index <switch>/<REORDER><STORAGE<
.index <switch>/<REORDER><STORE<
.index <switch>/<REORDER><ARGUMENT<
.index <switch>/<reorder><variable<
.index <switch>/<reorder><common<
.INDEX <SWITCH>/<REORDER><TYPE<
.break
 ^this switch is the same as /<order . ^used with the /<indent switch
for <super <index format control.
.index <switch>/<indent<
.INDEX <SWITCH>/<ORDER
.header level 3 /<restore<=file__spec
.index <switch>/<restore
.index <switch>/<do__super
.index <switch>/<preserve  
.index <switch>/<add__preserve  
 ^used with the /<do__super switch. ^uses the data in the existing data file
to create a <super <index output. ^this data file having been created
by the /<preserve and /<add__preserve switches.
.header level 3 /<reverse

.INDEX <SWITCH>/<REVERSE
.INDEX <SUPER <INDEX <FORMAT <CONTROL
.INDEX <SWITCH>/<DO__SUPER
.INDEX <FORMAT <CONTROL
 ^used with the /<do__super switch. ^causes the presentation of the 
<super <index to be reversed. ^where the normal form is with the 
variable/<common block name followed by a list of all the modules
it was referenced by(with any specified tags), this switch causes the
major items to be the module names followed by the variable/<common<  
.INDEX <TAG   
block names for that module (with any specified tags).
^used with the /<indent switch
for <super <index format control.
.index <switch>/<indent<
.header level 3 /<SAVE__ENTRY

.INDEX <SWITCH>/<SAVE__ENTRY
.INDEX <SWITCH>/<DO__ENTRY
 ^used with the /<do__entry switch. ^causes the internal table used
for the entry point cross reference not to be deleted. ^it is saved for 
the next command line's use unless that command does not contain
the switch /<do__entry, in which case the data is lost. ^this switch
can be repeated on as many consecutive command lines as is wanted.
^note the effects of the switch /<NOLIBRARY__FUNCTIONS .

.INDEX <SWITCH>/<NOLIBRARY__FUNCTIONS

.header level 3 /<SAVE__INDEX<
.index <switch>/<save__index<
^After the completion of the current simple <INDEX or save for <SUPER <INDEX,
the symbol table that was built is saved for re-use by the next command.
^If the next command is /<DO__SUPER,/<DO__ENTRY or /<GET__ENTRY, then the data
is lost. ^Unless over-ridden by one of the switches mentioned above,
the next command uses the data saved in the table, ignoring any input
files that may be specified.
.NOTE <WARNING<
^this switch will only work properly if the input contains only
one source module ( <program<,
<subroutine<,<function<, or <blockdata< ). ^if multiple modules are 
processed using the same /<save__index command, all the data from all the
sources will be saved as if all the data items were in the last source
processed.
.end note
.index <switch>/<do__super<
.index <switch>/<do__entry<
.index <switch>/<get__entry<

.header level 3 /<save__super

.INDEX <SWITCH>/<SAVE__super
.INDEX <SWITCH>/<DO__super
 ^used with the /<do__super switch.
^After the completion of the current <SUPER <INDEX, the data in the
scratch files is saved for re-use by the next command. If the next
command is not /<DO__SUPER, then the data is lost.
^this switch
can be repeated on as many consecutive command lines as is wanted.

.header level 3 /<SPOOL

.INDEX <SWITCH>/<SPOOL
.INDEX <PRINT <QUEUE
 ^Spool the list file to the printer upon completion of current module
index. Same as the /<print switch. ^see also /<delete.

.INDEX <SWITCH>/<PRINT
.INDEX <SWITCH>/<DELETE
.header level 3 /<STATISTICS<[=OPT__1[:OPT__2[:OPT__3]]]

.INDEX <SWITCH>/<STATISTICS
.INDEX <SWITCH>/<STATISTICS<><ALL<
.INDEX <SWITCH>/<STATISTICS<><RUN<
.INDEX <SWITCH>/<STATISTICS<><TYPE<
.INDEX <SWITCH>/<STATISTICS<><TOKEN<
.INDEX <SWITCH>/<STATISTICS<><LIBRARY<
 ^Print the index statistics about each source module at the end of the
module listing in the list file. ^THE statistics are in four(4) categories
that can be selectively called up. ^the /<statistics< switch with no options
is the same as /<statistics<=<run<_:<type< . The available options are:
.break
#<RUN<#########all the internal statistics, times, line/page counts, etc
.break
#<type<########summary of all the types of source lines found
.break
#<token<#######summary of all the tokens (known constructs) found
.break
#<library<#####summary of all the FORTRAN library routines used
.break
#<ALL<#########all the above categories of statistics are printed out.
.INDEX <OUTPUT <FILE
.INDEX <LIST <FILE
.header level 3 /<storage
.index	<switch>/<storage
.index	<format <control
 ^used during simple <index to show the storage location of selected
variables. 
^information printed out can take the following values:
.break
$^Common__^Name
.break
$^Statement__^Function
.break
$^Entry__^Point
.break
$^Parameter
.break
$^Blank__^Common
.break
$^Argument
.break
$^Local
or the name of the <common block containing the variable
.break
 ^this switch is identical to /<store .
.index <switch>/<store
.header level 3 /<store
.index	<switch>/<store
.index	<format <control
 ^used during simple <index to show the storage location of selected
variables.
^information printed out can take the following values:
.break
$^Common__^Name
.break
$^Statement__^Function
.break
$^Entry__^Point
.break
$^Parameter
.break
$^Blank__^Common
.break
$^Argument_[__nnnn_]
.break
$^Local
or the name of the <common block containing the variable
.break
 ^this switch is identical to /<storage .
.index <switch>/<storage

.header level 3 /<symbol=xxx

.INDEX <SWITCH>/<SYMBOL
.INDEX <ENTRY <POINT <TREE <FORMAT <CONTROL
.INDEX <SWITCH>/<CALLING__TREE
.INDEX <SWITCH>/<CALLED__BY__TREE
.INDEX <SWITCH>/<DO__ENTRY
.INDEX <FORMAT <CONTROL
 ^used with the switches /<calling__tree and /<called__by__tree. Causes
the root of the graphical tree to be the specified symbol rather than
the default main program or tail end of the calling tree.
.header level 3 /<tag=<"xxx...xxx"

.INDEX <TAG
.INDEX <SWITCH>/<GET__SUPER
^used with the /<get__super switch. ^all variable or <common block

.INDEX <COMMON <BLOCKS
names saved for output during a super <index have the specified tag
associated with them. ^during the super <index output, the tag is printed
with the associated tag appended in parren's to the the end of the appropriate
module name. ^this allows the user to make multiple passes over the same
source file with different selection criterion, printing out during the
super <index the results of all the passes on one output with the tags
differentiating between the different inputs. ^the user specified tag
can be no more than 31 characters long including blanks.
.header level 3 /<transfer__entry

.INDEX <SWITCH>/<TRANSFER__ENTRY
.INDEX <SWITCH>/<DO__ENTRY
.INDEX <ENTRY <POINT <TREE <FORMAT <CONTROL
^used with the switches /<calling__tree and /<called__by__tree.

.INDEX <SWITCH>/<CALLED__BY__TREE
.INDEX <SWITCH>/<CALLING__TREE
Causes all references to entry points defined by <ENTRY statements to
be redirected to the name of the <subroutine/<function in which they
were defined.
 ^Note that when used in combination with the 
.INDEX <SWITCH>/<SAVE__ENTRY
/<SAVE__ENTRY switch, this switch is only effective when used
on the initial command line outputting the entry point cross reference,
and its effect is permanent for that saved data set.
.header level 3 /<type    

.index <switch>/<type
.INDEX <SWITCH>/<LIST
.INDEX <SWITCH>/<OUTPUT
.INDEX <OUTPUT <FILE
.INDEX <LIST <FILE
.INDEX <FILE <EXTENTION>.<LIS
 ^specifies that the list file (if any) generated by this command
is directed to the user terminal (<sys_$output_:<) .
^this is the same as /<list<=<tt<_: .
^see also /<null /<list and /<output .
.index <switch>/<null  
.header level 3 /<UNCHANGED   

.INDEX <SWITCH>/<UNCHANGED
 ^Output to list file and save for <SUPER <INDEX only those variables that
are found not to be assigned a value in the specified source file.
^see /<changed, /<used, and /<unused.

.INDEX <SWITCH>/<CHANGED
.INDEX <SWITCH>/<USED
.INDEX <SWITCH>/<UNUSED
.header level 3 /<UNUSED

.INDEX <SWITCH>/<UNUSED
 ^Output to list file and save for <SUPER <INDEX only those variables that
are declared to exist in type, dimension, common etc statements but
are never used. ^see /<changed, /<unchanged, /used.

.INDEX <SWITCH>/<CHANGED
.INDEX <SWITCH>/<UNCHANGED
.INDEX <SWITCH>/<USED
.header level 3 /<USED

.INDEX <SWITCH>/<USED
 ^Output to list file and save for <SUPER <INDEX only those variables that
are used in the body of the source . ^Declared but unused variables are
ignored. ^see /<unused, /<changed, /<unchanged.

.INDEX <SWITCH>/<UNUSED
.INDEX <SWITCH>/<CHANGED
.INDEX <SWITCH>/<UNCHANGED
.HEADER LEVEL 3 /<VARIABLE__TYPE<
.INDEX <SWITCH>/<VARIABLE__TYPE<
 ^DURING THE OUTPUT OF A SIMPLE INDEX, THIS SWITCH CAUSES THE VARIABLE TYPE
TO BE OUTPUT IN ANGLE BRACKETS JUST AFTER THE VARIABLE NAME AND (IF ASKED FOR)
THE STORAGE INFORMATION. ^THE TYPE INFORMATION INCLUDES THE DECLARATION THAT
THE VARIABLE IS AN ARRAY IF IT IS ONE.
.header level 3 /<WIDE

.INDEX <SWITCH>/<WIDE
.INDEX <OUTPUT <FORMAT <WIDTH <CONTROL
.INDEX <FORMAT <CONTROL
 ^Output files are formatted for listing on a line printer (132 col).
^this is the default value. ^see /<narrow.

.INDEX <SWITCH>/<NARROW
.ENABLE TOC
.page
.header level 2 ^switch ^usage ^chart
.literal
				Type of INDEX

                        S    G    D   A    G    D    D         O
                        I    e    o   r    e    o    o         t
                        m    t        g    t                   h
                        p         S   u         E    E w s d   e
                        l    S    u   m    E    n    n I a a   r
                        e    u    p   e    n    t    t t v t
                             p    e   n    t    r    r h e a
                             e    r   t    r    y    y   d
                             r             y           
Switch                                                        

/ADD_PRESERVE or        I    I    O   O    I    I    I         I
/PRESERVE or /RESTORE
/APPEND OR /MERGE       O    O    O   O    I    O    O         I
/ARGUMENT               O    O    I   I    I    I    I         I
/CALL_ARGUMENT          *    *    *   M    *    *    *         *
/CALLED_BY_TREE         I    I    I   I    I    O    O         I
/CALLING_TREE           I    I    I   I    I    O    O         I
/CHANGED or /UNCHANGED  O    O    I   I    I    I    I         I
/CHART OR /FLOW_CHART   O    O    I   I    I    I    I         I
/COMMENT                O    O    O   O    I    O    O         I
/COMMON_BLOCKS          O    O    I   I    I    I    I         I
/DEBUG or /D_LINES      O    O    I   I    O    I    I         I
/DELETE                 O    O    O   O    I    O    O         I
/DEPTH                  I    I    I   I    I    O    O         I
/D_LINES or /DEBUG      O    O    I   I    O    I    I         I
/DO_ENTRY               *    *    *   *    *    M    M         *
/DO_SUPER               *    *    M   *    *    *    *         *
/EXPORT or /IMPORT      O    O    I   I    I    I    I         I
/FILE_NAME              I    I    I   I    I    O    O         I
/FLOW_CHART OR /CHART   O    O    I   I    I    I    I         I
/GET_ENTRY              *    *    *   *    M    *    *         *
/GET_SUPER              *    M    *   *    *    *    *         *
/GLOBAL or /LOCAL       O    O    I   I    I    I    I         I
/HELP                   *    *    *   *    *    *    *         O
/IMPORT or /EXPORT      O    O    I   I    I    I    I         I
/INDENT                 I    I    O   I    I    I    I         I
/LIBRARY                O    O    I   I    O    I    I         I
/LIST or /OUTPUT or     O    O    O   O    I    O    O         I
/TYPE or /NULL
/LOCAL or /GLOBAL       O    O    I   I    I    I    I         I
/LOG                    O    O    O   O    O    O    O         O
/MERGE or /APPEND       O    O    O   O    I    O    O         I
/NARROW or /WIDE        O    O    O   O    I    O    O         I
/NOENTRY_TABLE          I    I    I   I    I    O    O         I
/NOINDEX                O    O    I   I    I    I    I         I
/NOLIBRARY_FUNCTIONS    I    I    I   I    I    O    K         I
/NOSOURCE               O    O    I   I    I    I    I         I
/NULL or /TYPE or       O    O    O   O    I    O    O         I
/LIST or /OUTPUT
/[RE]ORDER or /REVERSE  I    I    O   I    I    I    I         I
/OUTPUT or /LIST  or    O    O    O   O    I    O    O         I
/TYPE or /NULL
/PREPROCESSOR           O    O    I   I    I    I    I         I
/PRESERVE or            I    I    O   O    I    I    I         I
/RESTORE or /ADD_PRESERVE
/PRINT or /SPOOL        O    O    O   O    I    O    O         I
/RESTORE or /PRESERVE   I    I    O   O    I    I    I         I
or /ADD_PRESERVE
/REVERSE or /(RE)ORDER  I    I    O   I    I    I    I         I
/SAVE_ENTRY             I    I    I   I    I    O    O         I
/SAVE_INDEX             O    O    I   I    I    I    I         I
/SAVE_SUPER             I    I    O   O    I    I    I         I
/SPOOL or /PRINT        O    O    O   O    I    O    O         I
/STATISTICS             O    O    O   O    I    O    O         I
/STORAGE OR /STORE      O    O    I   I    I    I    I         I
/STORE OR /STORAGE      O    O    I   I    I    I    I         I
/SYMBOL                 I    I    I   I    I    O    O         I
/TAG                    I    O    I   I    I    I    I         I
/TRANSFER_ENTRY         I    I    I   I    I    O    K         I
/TYPE or /NULL or       O    O    O   O    I    O    O         I
/LIST or /OUTPUT
/UNCHANGED or /CHANGED  O    O    I   I    I    I    I         I
/UNUSED or /USED        O    O    I   I    I    I    I         I
/USED or /UNUSED        O    O    I   I    I    I    I         I
/VARIABLE_TYPE          O    O    I   I    I    I    I         I
/WIDE or /NARROW        O    O    O   I    I    O    O         I
.end literal
.page
.literal
Legend

 O	Optional in this context
 M	Mandatory for this option
 *	Prohibited in this option
 I	Ignored if used in this option
 K	Applied only to first /DO_ENTRY/SAVE_ENTRY, result saved for
	further /DO_ENTRY operations on saved data. Ignored if used
	on other than the first command in the saved data entry point
	series of commands.

Switches shown on the same line are mutually exclusive. 

.end literal
.page
.HEADER LEVEL 2 ^switch ^useage by <index ^operateing  ^mode
 ^with all the information given above, the great mass of switches can
still be confusing, so now let us take a look at where they are (optionally)
used depending on the mode <index is being operated in. ^note that in the
section below, where two , three or four switches are shown stacked vertically
with no rows separating them, they are considered to be mutually
exclusive.
 ^In all possible combinations the /<LOG switch is always acceptable.
.index <switch>/<log  
 ^Where an output file is generated (simple <INDEX, 
accumulate data for <SUPER <INDEX, <SUPER <INDEX, or <ENTRY <POINT <INDEX),
the following related switches can be used :
.index	<super <index
.index	<entry <point <cross <reference
.tp 7
.literal

/APPEND  /LIST    /PRINT  /NARROW  /COMMENT  /DELETE  /STATISTICS 
/MERGE   /OUTPUT  /SPOOL  /WIDE   
         /TYPE
         /NULL

.end literal
.index <switch>/<append<
.index <switch>/<merge<
.index <switch>/<list<
.index <switch>/<output<
.index <switch>/<print<
.index <switch>/<spool<
.index <switch>/<narrow<
.index <switch>/<wide<
.index <switch>/<comment<
.index <switch>/<delete<
.index <switch>/<statistics<
.index <switch>/<null<
.index <switch>/<type<
 ^Where input files are used (simple <INDEX<, 
accumulate data for <SUPER <INDEX or accumulate data for 
<ENTRY <POINT <INDEX<),
the following switches may be applied to them:
.tp 5
.literal

/DEBUG     /LIBRARY  /PREPROCESSOR
/D_LINES

.end literal

.index <switch>/<debug<
.index <switch>/<library<
.index <switch>/<PREPROCESSOR<
.index	<include <files<
In addition to the above- 
under the specified operating modes-the following switches may be applied:
.page
.index <switch>/<help<
.index <switch>/<get__entry<
.index <switch>/<do__entry<
.index <switch>/<calling__tree<
.index <switch>/<called__by__tree<
.index <switch>/<depth<
.index <switch>/<symbol<
.index <switch>/<file<
.index <switch>/<noentry__table<
.index <switch>/<NOLIBRARY__FUNCTIONS<
.index <switch>/<SAVE__ENTRY<
.index <switch>/<transfer__entry<
.index <switch>/<get__super<
.index <switch>/<argument
.index <switch>/<store<
.index <switch>/<storage<
.index <switch>/<tag<
.index <switch>/<changed<
.index <switch>/<unchanged<
.index <switch>/<common<
.index <switch>/<used
.index <switch>/<unused<
.index <switch>/<local<
.index <switch>/<global<
.index <switch>/<import<
.index <switch>/<export<
.index <switch>/<chart<
.index <switch>/<flow__chart<
.index <switch>/<NOSOURCE<
.index <switch>/<NOINDEX<
.INDEX <SWITCH>/<SAVE__INDEX<
.INDEX <SWITCH>/<PRESERVE<
.INDEX <SWITCH>/<ADD__PRESERVE<
.INDEX <SWITCH>/<RESTORE<
.index <switch>/<CALL__ARGUMENT<
.INDEX <SWITCH>/<VARIABLE__TYPE<
.literal
Mode       Optional modifying switches that may be used
Set        in addition to those shown above.
Switch

/HELP      No other switches

/GET_ENTRY No other switches


/DO_ENTRY  /CALLING /CALLED /DEPTH /SYMBOL (graphical output switches)


           /FILE /NOENTRY /NOLIBRARY /SAVE_ENTRY /TRANSFER



/GET_SUPER /VARIABLE_TYPE   /ARGUMENT /STORAGE /TAG (tag field's switches)
                                      /STORE        

           /CHANGED  /COMMON /EXPORT /GLOBAL /UNUSED (selection switches)
           /UNCHANGED        /IMPORT /LOCAL  /USED


           /CHART             /NOINDEX       /NOSOURCE  /SAVE_INDEX
           /FLOW


/DO_SUPER  /ORDER    /INDENT  /SAVE_SUPER   /PRESERVE
           /REORDER                         /ADD_PRESERVE
           /REVERSE                         /RESTORE


/CALL_ARGUMENT       /SAVE_SUPER            /PRESERVE
                                            /ADD_PRESERVE
                                            /RESTORE

.end literal
.index <switch>/<do__super<
.index <switch>/<order<
.index <switch>/<reorder<
.index <switch>/<reverse<
.index <switch>/<save__super<
.INDEX <SWITCH>/<INDENT<
 ^Note that the switches that apply to a simple <INDEX 
are the same as those for /<GET__SUPER except for /<TAG which is
ignored and no mode implementation switch is used as 
this is the default operating mode. ^the /<CALL__ARGUMENT< mode
is a form of <super <index and data is gathered for it the same
as for <super <index.

.page
.header level 2 ^variable ^type ^selections ^with ^switch ^combinations
.paragraph
^by the use of various switch combinations, the user can locate variables
with specific characteristics. ^as show below, the selection switches
can be put together into 162 different combinations:
.TP 7
.INDEX <SWITCH>/<COMMON__BLOCKS
.INDEX <SWITCH>/<CHANGED
.INDEX <SWITCH>/<UNCHANGED
.INDEX <SWITCH>/<EXPORT
.INDEX <SWITCH>/<IMPORT
.INDEX <SWITCH>/<LOCAL
.INDEX <SWITCH>/<GLOBAL
.INDEX <SWITCH>/<USED
.INDEX <SWITCH>/<UNUSED
.literal
                                                                         
               |(unused)| |(unused)  | |(unused)| |(unused)| |(unused)|
               |/COMMON | |/CHANGED  | |/EXPORT | |/LOCAL  | |/USED   |
               |        | |/UNCHANGED| |/IMPORT | |/GLOBAL | |/UNUSED |

.end literal
^while all the possible combinations are accepted by <INDEX, not all are
meaningful and may produce a null output. ^such switches as /<import
or /<export would normally be used be used with no other modifying
switches with the possible exception of /<global if you are interested
only in those items that are passed via <common.
.test page 8
.paragraph
^the /<common switch is most likely to be used in combination with the
following switches:
.INDEX <SWITCH>/<COMMON__BLOCKS
.INDEX <SWITCH>/<CHANGED
.INDEX <SWITCH>/<UNCHANGED
.INDEX <SWITCH>/<USED
.INDEX <SWITCH>/<UNUSED
.literal

               /COMMON  |(unused)  | |(unused) |
                        |/CHANGED  | |/USED    |
                        |/UNCHANGED| |/UNUSED  |

.END literal
.test page 38
.INDEX <SWITCH>/<COMMON__BLOCKS
^the /<common switch looks at <common blocks as a complete entity
and when used in combination with the indicated switches yields
the following possible results:
.INDEX <COMMON <BLOCKS
.INDEX <SWITCH>/<COMMON__BLOCKS
.INDEX <SWITCH>/<CHANGED
.INDEX <SWITCH>/<UNCHANGED
.INDEX <SWITCH>/<USED
.INDEX <SWITCH>/<UNUSED
.literal

             (unused)           /USED              /UNUSED
(unused)     List all COMMON    List all COMMON    List all COMMON
             blocks in module   blocks by name,    blocks by name,
             by block name      which contain any  which contain only
                                variables that     variables that are
                                are used at run    unused at run time.
                                time.              Only appearing in
                                                   type,DIMENSION,
                                                   COMMON,VIRTUAL,
                                                   EQUIVALENCE,etc
                                                   statements.
                                            
/CHANGED     List all COMMON    List all COMMON    List all COMMON
             blocks by name,    blocks by name,    blocks by name,
             which contain any  which contain any  which contain only
             variables that     variables that     unused variables
             are assigned a     are assigned a     with some that are
             value.             value at run time. assigned a value
                                                   at compile time
                                                   (DATA statements).

/UNCHANGED   List all COMMON    List all COMMON    List all COMMON
             blocks by name,    blocks by name,    blocks by name,
             which contain no   which are used     which contain only
             variables that are at run time but    variables that are 
             assigned a value.  not assigned a     not used at run time
                                value.             and are not assigned
                                                   a value at any time
                                                   (a completely unused
                                                   COMMON block that is a
                                                   candidate for removal).



.end literal
 ^as a <common block is liable to contain variables with various
characteristics, the entire common block will have take on the
characteristic of the highest precedence variable in a given category.
^if one or more variables are <changed, then the whole common block
.INDEX <COMMON <BLOCK <PRECIDENCE <OF <CHARACTERISTICS
is considered to be <changed rather than <unchanged. ^similarly
the characteristic <used takes precedence over <unused.
.page
.paragraph
^the basic selection switches that are normally used together are
as follows:
.INDEX <SWITCH>/<CHANGED
.INDEX <SWITCH>/<UNCHANGED
.INDEX <SWITCH>/<LOCAL
.INDEX <SWITCH>/<GLOBAL
.INDEX <SWITCH>/<USED
.INDEX <SWITCH>/<UNUSED
.literal

         |(unused)| |(unused)| |(unused)  |
         |/GLOBAL | |/USED   | |/CHANGED  |
         |/LOCAL  | |/UNUSED | |/UNCHANGED|

.END literal
.test page 30
.paragraph
^when used in combination, these switches will select for variables
that have the following characteristics:
.INDEX <SWITCH>/<CHANGED
.INDEX <SWITCH>/<UNCHANGED
.INDEX <SWITCH>/<USED
.INDEX <SWITCH>/<UNUSED
.literal

               (unused)        /CHANGED                /UNCHANGED
(unused)   List all variables  List all variables      List all variables
           and labels.         that have their value   that have not had
                               set in the current      their value changed
                               module.                 in the current
                                                       module.

/USED      List all variables  List all variables      List all variables
           and labels used at  that have their value   that are used at run
           run time in the     set in the current      time but are not
           current module.     module at run time.     changed in value.

/UNUSED    List all variables  List all variables      List all variables
           and labels declared that are not used       that have been
           but that are not    at run time but are     declared to exist
           used at run time.   assigned a value at     but are unused at
                               compile time (DATE      run time and are not
                               or PARAMETER).          assigned a value at
                                                       compile time. These
                                                       variables are
                                                       unneeded and are
                                                       candidates for
                                                       deletion.

.end literal
^the variables selected  by use of the switches above, may be further
culled down by the use of the /<global or /<local switches depending
.INDEX <SWITCH>/<GLOBAL
.INDEX <SWITCH>/<LOCAL
on whether you are interested only in local variables or those
residing in <common.

.INDEX <COMMON <BLOCKS
.PAGE
.header level 2 ^example
 ^consider a large program with many subroutines in the files
<main.for, <sub1.for, <sub2.for, <sub3.for, <sub4.for. ^a recommended
command file <index.com to get the most information would be as follows:
.INDEX <SWITCH>/<USED
.INDEX <SWITCH>/<LOG
.INDEX <SWITCH>/<OUTPUT
.INDEX <SWITCH>/<MERGE
.INDEX <SWITCH>/<GET__SUPER
.INDEX <SWITCH>/<IMPORT
.INDEX <SWITCH>/<EXPORT
.INDEX <SWITCH>/<TAG
.INDEX <SWITCH>/<DO__SUPER
.INDEX <SWITCH>/<REVERSE
.INDEX <SWITCH>/<COMMENT
.INDEX <SWITCH>/<COMMON__BLOCKS
.INDEX <SWITCH>/<NOSOURCE
.INDEX <SWITCH>/<UNUSED
.INDEX <SWITCH>/<GET__ENTRY
.INDEX <SWITCH>/<PRINT
.INDEX <SWITCH>/<DELETE
.INDEX <SWITCH>/<DO__ENTRY
.INDEX <SWITCH>/<CALLING__TREE
.INDEX <SWITCH>/<CALLED__BY__TREE
.INDEX <SWITCH>/<NOLIBRARY__FUNCTIONS
.INDEX <SWITCH>/<FILE_NAME
.INDEX <SWITCH>/<STATISTICS
.INDEX <SWITCH>/<SAVE__SUPER
.literal

$ INDEX
				First is to get the basic source file
				listings and a list of all the used
				variables in one output file MAIN.LIS.
/USED/LOG  MAIN
/USED/LOG/OUTPUT=MAIN/MERGE/FLOW SUB1
/USED/LOG/OUTPUT=MAIN/MERGE/FLOW SUB2
				Now get all the imported and exported
				variables in each file and save for
				SUPER INDEX with appropriate tags.
/GET_SUP/IMP/SAVE_IND/LOG/NULL/NOSOUR/NOIND/TAG="IMPORT" MAIN
				Use saved data from previous INDEX
				and repeat for exported data.
/GET_SUP/EXP/LOG/NULL/NOSOUR/NOIND/TAG="EXPORT" MAIN  
/GET_SUP/IMP/SAVE_IND/LOG/NULL/NOSOUR/NOIND/TAG="IMPORT" SUB1
/GET_SUP/EXP/LOG/NULL/NOSOUR/NOIND/TAG="EXPORT" SUB1
/GET_SUP/IMP/SAVE_IND/LOG/NULL/NOSOUR/NOIND/TAG="IMPORT" SUB2
/GET_SUP/EXP/LOG/NULL/NOSOUR/NOIND/TAG="EXPORT" SUB2
/LOG/DO_SUPER/MERGE/SAVE_SUPER/ORDER=NAME:MODULE:TAG:STORE:ARG MAIN
				Since the Super INDEX information was
				saved, we can redisplay the same
				information in a different format.
/LOG/DO_SUPER/MERGE/ORDER=MODULE:TAG:NAME:STORE:ARG/INDENT=1 MAIN
				Now look at COMMON block usage
/SAVE_IND/GET_SUP/COMM/USED/LOG/NULL/TAG="USED" MAIN,SUB1,SUB2
/GET_SUP/COMM/UNUSED/LOG/NULL/TAG="UNUSED" MAIN,SUB1,SUB2
/COMMENT="COMMON BLOCK USAGE"/LOG/DO_SUPER/MERGE/ORDER=COMMON:MODULE:TAG MAIN
				You might also be interested in unused
				variables that might be eliminated
/NOSOURCE/UNUSED/LOG/OUTPUT=MAIN/MERGE MAIN,SUB1,SUB2
				Finally an entry point cross reference
/GET_ENTRY/LOG MAIN,SUB1,SUB2,SUB3,SUB4
/PRINT/DELETE/LOG/DO_ENTRY/MERGE/CALLED/CALLING/NOLIB/FILE/STAT MAIN
.end literal
.page
.header level 2 ^automatic ^building of ^command ^files to ^generate an <index
 ^to facilitate the building of command files to generate a full cross
reference of a large program, ^I have supplied a command file <generate.com
to assist. ^the inputs to this command file are: a data file prepared
before invocation, and the answers to questions at the time the
command file <generate.com is run.
 ^note that this command file does not
include the option to generate flow charts due to the resource intensive
requirements of that option. ^see warning in section on flow charts.
.disable toc
.header level 3 ^data ^file
 ^the data file is nothing more than a list of file names, one name to a line,
of the files in the program to be <index<ed. ^if a given source file
requires a library file not available via the logical name <fort$library 
or is the system <fortran text library file, then that file name is
placed on the same line as the file that requires it,separated by a comma
and having the switch /<library appended to it.
 ^one assumption is made by <generate.com, that is each file contains
one and only one source module (main program, <block <data, <subroutine ,
<function ). ^if this assumption is not correct for a given file, then
precede its name in the data file by a _"_+_" .
.INDEX <INCLUDE <FILES
.INDEX <SWITCH>/<LIBRARY 
.index <TEXT <LIBRARY
.INDEX <FORT$LIBRARY
.index <generate.com
 ^A  sample data file for a program with files <main, <a, <b, <c, <d
( where <c contains multiple sources) would be
.literal


MAIN
A
B,LIBFILE/LIBRARY
+C
D

.END LITERAL
with no blank lines and left justified. ^no include files are to be in
.INDEX <DEFAULT <EXTENTIONS  
.INDEX <FILE <EXTENTION>.<FOR
.INDEX <FILE <EXTENTION>.<TLB
the list. ^Default extensions are .<for and .<tlb as appropriate.
.header level 3 ^running <generate.com
^to generate the command file, the user first builds the source file name
list file in the form as outlined above. ^then the <generate command file is
run to build the command file that will actually generate the cross reference.
^issue the command
.skip 2
@<generate
.skip 2
the command file will then come back with the message
.skip 2
.test page 14
.literal

	This command file is used to generate a command file to
do a complete cross reference on a program consisting of many
files. To use this command file, you must first generate a
data file consisting of the names of each file that makes up
the program. Each file on a separate line, left justified.
If a source file requires a library file (.TLB), put its name on the
same line as the source file(separated with a comma) and add a
/LIBRARY switch after it. If the logical name FORT$LIBRARY is used
to specify the library file then this action is not required.

.end literal

.INDEX <FILE <EXTENTION>.<TLB
and then asks the question
.skip 2
^Are you ready to build the command file Y[es] or N[o] :
.skip 2
if you are ready to proceed then answer <y[es] and continue, any other
answer terminates the command file.
.break
^after answering <yes, the command file then asks the question
.skip 2
^What is the name of the generated command file 
.skip 2
^the default name is <index.com . If another name is wanted, then
enter it including the extension.
.break 
^next the command file asks
.skip 2
^What is the name of the file containing the list of file names 
.skip 2
^the default name is <index.dat . If another name is wanted, then
enter it including the extension.
^the third question is then asked
.skip 2
^What is the name of the list file the command file is direct output to 
.skip 2
^this is the name of the file that will eventually contain the
complete cross reference output. ^the default answer is <main.lis
or if the user wants another name, then the default extension is  .<lis . 
.INDEX <FILE <EXTENTION>.<LIS
^the last set up question before generating the command file is then asked
.skip 2
^do you want source file listings _[^y_/^n_]
.skip 2
^the default is ^N , this allows the user with a large program to get
the <super <index information with or 
without the individual source file listings.
^from this point on the command file <generate.com builds the target
command file that will do the actual cross reference. ^when
the command file is built, the message
.skip 2
^Generation ^complete  
.skip 2
is printed out followed by the question
.skip 2
^Do you want to delete the data file  file_name.ext ( ^Y[es] or ^N[o])"
.skip 2
^if it is answer yes the specified file in all its versions are deleted.
.break
 ^to use the resulting command file, just invoke it
like any other command file and the complete cross reference will be
generated for your use.
.enable toc
.page
.header level 1 <how <used <mnemonics
 ^Shown on the output listing as to how each variable was used on a given
line.
.INDEX <HOW <USED <MNEMONICS
.INDEX <MNEMONICS
.break
<ACCEPT
.BREAK
<ASSIGN
.BREAK
<ASSIGNED__VALUE
.BREAK
<BACKSPACE
.BREAK
<BLOCK__DATA
.BREAK
<BYTE
.BREAK
<BYTE__FUNCTION
.BREAK
<CALL
.BREAK
<CALLED__BY__ARG
.BREAK
<CALLING__ARG
.BREAK
<CHARACTER
.BREAK
<CHARACTER__FUNCTION
.BREAK
<CLOSE
.BREAK
<COME__FROM
.BREAK
<COMMON
.BREAK
<COMMON__NAME
.BREAK
<COMPLEX
.BREAK
<COMPLEX__FUNCTION
.BREAK
<CONTINUE
.BREAK
<DATA
.BREAK
<DECODE
.BREAK
<DEFINE__FILE
.BREAK
<DELETE
.BREAK
<DIMENSION
.BREAK
<DO
.BREAK
<DOUBLE__PRECISION
.BREAK
<DOUBLE__PRECISION__FUNCTION
.BREAK
<DOUBLE__COMPLEX
.BREAK
<DOUBLE__COMPLEX__FUNCTION
.BREAK
<EQUIVALENCE
.BREAK
<ELSE
.BREAK
<ELSEIF
.BREAK
<ENCODE
.BREAK
<END
.BREAK
<ENDD0
.BREAK
<ENDFILE
.BREAK
<ENDIF
.BREAK
<ENTRY
.BREAK
<ERROR
.BREAK
<EXTERNAL
.BREAK
<FORMAT
.BREAK
<FIND
.BREAK
<FUNCTION
.BREAK
<GOTO
.BREAK
<IF
.BREAK
<INQUIRE
.BREAK
<IMPLICITNONE
.BREAK
<IMPLICIT
.BREAK
<INCLUDE
.BREAK
<INTEGER
.BREAK
<INTEGER__FUNCTION
.BREAK
<INTRINSIC
.BREAK
<LABEL__DEFINED
.BREAK
<LOGICAL
.BREAK
<LOGICAL__FUNCTION
.BREAK
<LOCAL__FUNCTION
.BREAK
<NAMELIST
.BREAK
<NAMELIST__NAME
.BREAK
<OPEN
.BREAK
<OPTION
.BREAK
<PARAMETER
.BREAK
<PAUSE
.BREAK
<PRINT
.BREAK
<PROGRAM
.BREAK
<QUAD
.BREAK
<QUAD__FUNCTION
.BREAK
<READ
.BREAK
<REAL
.BREAK
<REAL__FUNCTION
.BREAK
<REWRITE
.BREAK
<RETURN
.BREAK
<REWIND
.BREAK
<SAVE
.BREAK
<STOP
.BREAK
<SUBROUTINE
.BREAK
<TYPE
.BREAK
<UNLOCK
.BREAK
<USED
.BREAK
<VIRTUAL
.BREAK
<WRITE
.PAGE
.HEADER LEVEL 1 <ERROR <MESSAGES
 ^Error messages from <index can take one of three forms. The first
form is just an error message starting off <index- followed by the
severity and informational text. The second form is a multiple line
error message, the first line is the same as the first type of message
described above, with the second line being generated by the
system as <index exits. ^the second line being the <rms/lib etc
system routine error that caused the exit. ^the last form of
error message consists only of one line, that being the system error
message that caused <index to exit. ^this form is only used as when
certain rare errors occur such as in heap management.
 ^only those error messages beginning <index-### are shown here.
.DISABLE TOC
.skip 2
.hl 2 <index-e-b<lock <if or <do statement out of position-line xxxxx
.index <error
^issued by <chart.mar
.skip 2
^user had syntax error at indicated line. ^an <ENDIF, <elseif, <else or
<enddo statement was incorrectly nested.
.SKIP 2
.HL 2 <INDEX-W-CDD-_"DICTIONARY_"< ^DIRECTIVE NOT ^SUPPORTED

.INDEX <WARNING
^ISSUED BY <EVAL.MAR<
.SKIP 2
<INDEX RECOGNIZES BUT DOES NOT SUPPORT THE ^COMMON ^DATA ^DICTIONARY
 _(^C^D^D_) DIRECTIVE <DICTIONARY . ^THAT LAYERED PRODUCT IS NOT
AVAILABLE AT THIS FACILITY SO IT COULD NOT BE INCLUDED AND CHECKED OUT
FOR USE.
.skip 2
.header level 2 <index-e-c<ommand ^syntax ^error

.INDEX <ERROR
^issued by <openclose.mar
.skip 2
^user issued a bad command line. ^check switches and syntax.
^this error message is followed by an extracted portion of the 
command line from around the position of the error.
.skip 2
.header level 2 <index-e-c<onnect ^input ^file ^error
.INDEX <ERROR
^issued by <openclose.mar
.skip 2
^error occurred in attempting to connect user specified input file.
.skip 2
.header level 2 <index-e-c<onnect ^output ^file ^error
.INDEX <ERROR
^issued by <openclose.mar
.skip 2
^error occurred in attempting to connect user specified output file.
.skip 2
.header level 2 <index-E-end found inside ^block <if or <do
.index <FATAL <ERROR
^issued by <chart.mar
.skip 2
^user had syntax error. <end statement occurred while program still
nested in a block <if or <do statement.
.skip 2
.header level 2 <INDEX-E-E<rror connecting ^Preserve data file-no data saved
.index <error
^issued by <openclose.mar
.skip 2
^unable to connect <rms channel to preserve data file just created. ^empty
file is closed and the /<preserve switch is overridden.
.index <switch>/<preserve<
.skip 2
.header level 2 <INDEX-E-E<rror creating ^Preserve data file-no data saved
.index <error
^issued by <openclose.mar
.skip 2
^unable to create file to preserve for the user the <super <index data.
.index <switch>/<preserve<
^action taken is to override the /<preserve switch in the command line.
.skip 2
.header level 2 <INDEX-F-E<rror opening existing ^Preserve data file for restore
.index <fatal <error
^issued by <openclose.mar
.skip 2
^unable to open existing preserve data file for <super <index. <index is terminated.
.index <switch>/<restore  
.SKIP 2
.HEADER LEVEL 2 <INDEX-W-E<rror opening existing ^Preserve data file for add-new file created
.INDEX <ERROR
^ISSUED BY <OPENCLOSE.MAR
.SKIP 2
^unable to open existing preserve data file for adding of additional data. ^new file of specified name
is created.
.index <switch>/<add__preserve  
.skip 2
.header level 2 <INDEX-F-E<rror ^opening ^scratch ^files
.INDEX <FATAL <ERROR
^issued by <openclose.mar
.skip 2
^unable to open for use both of the scratch files used to store 
super index and entry point index information.
.skip 2
.header level 2 <INDEX-F-E<rror reading ^Preserve data file
.index <fatal <error
^issued by <super.mar or <argument.mar
.skip 2
^read error occurred during 
read of record from preserve data file. <index is terminated.
.index <switch>/<restore  
.skip 2
.header level 2 <INDEX-F-E<rror ^reading ^super ^index ^scratch ^file
.INDEX <FATAL <ERROR
^issued by <super.mar or <argument.mar
.skip 2
<rms error occurred while reading super index scratch file during
the generation of the super index symbol table.
.skip 2
.header level 2 <INDEX-F-E<rror ^rewinding ^super ^index ^scratch ^file
.INDEX <FATAL <ERROR
^issued by <super.mar or <argument.mar
.skip 2
<rms error occurred while attempting to rewind the super index scratch
file in preparation for using the information included therein for
a super index output.
.skip 2
.header level 2 <INDEX-E-E<rror writing ^Preserve data file-file terminated
.index <error
^issued by <super.mar or <argument.mar
.skip 2
^an error occurred while writing data to the permanent file used to hold
the data from the <super <index. ^the file is closed with its current
contents and the /<preserve switch is overridden for the rest of the
current <super <index .
.index <switch>/<preserve<
.skip 2
.HEADER LEVEL 2 <INDEX-F-E<rror ^writeing to ^chart ^scratch ^file
.index <fatal <error
^issued by <chart.mar
.skip 2
^during data accumulation phase of <index, the raw flow chart data is 
stored in a scratch file. ^an error occurred while writing information
to this file.
.skip 2
.header level 2 <INDEX-F-E<rror ^writing to ^entry ^index ^scratch ^file
.INDEX <FATAL <ERROR
^issued by <output.mar
.skip 2
<rms error occurred in entry point cross reference while attempting to
save entry point definition information in the entry index scratch file.
.skip 2
.header level 2 <INDEX-F-E<rror ^writing to ^entry ^super ^index ^scratch ^file
.INDEX <FATAL <ERROR
^issued by <output.mar
.skip 2
<rms error occurred in entry point cross reference while attempting to
save entry point occurrence information in the entry super index scratch file.
.skip 2
.header level 2 <INDEX-F-E<rror ^writing to ^super ^index ^scratch ^file
.INDEX <FATAL <ERROR
^issued by <output.mar
.skip 2
<rms error occurred in super index cross reference while attempting to
save super index information in super index scratch file.
.skip 2
.header level 2 <index-f-f<ile ^read ^record ^error
.INDEX <FATAL <ERROR
^issued by <ioline.mar
.skip 2
<index encountered an <rms or library error while trying to read a source line
from the input file. ^See following <rms/lib 
error message for more information.
.skip 2
.header level 2 <index-f-f<ile ^write ^record ^error
.INDEX <FATAL <ERROR
^issued by <ioline.mar
.skip 2
<index encountered an <rms  error while trying to write a line
to the listing file . ^See following <rms error message for more information.
.skip 2
.header level 2 <index-f-include ^connect ^file ^error
.INDEX <FATAL <ERROR
^issued by <openclose.mar
.skip 2
^an error occurred while attempting to connect for input the file specified
in the <include statement.
.skip 2
.header level 2 <index-f-include ^file ^specification ^syntax ^error
.INDEX <FATAL <ERROR
^issued by <openclose.mar
.skip 2
^the <include statement in the source file being indexed contained some type
of syntax error in the file specification part of the line.
.skip 2
.header level 2 <index-f-include  ^library ^file ^initialization ^error
.INDEX <FATAL <ERROR
^issued by <openclose.mar
.skip 2
^internal error occurred while initializing library internal data structure.
.skip 2
.header level 2 <index-f-include ^nested to ^deep
.INDEX <FATAL <ERROR
^issued by <openclose.mar
.skip 2
^the user attempted to nest ^include statements to a depth in excess of that
accepted by the <fortran compiler or <index.
.skip 2
.header level 2 <index-f-include ^open ^file ^error
.INDEX <FATAL <ERROR
^issued by <openclose.mar
.skip 2
^an error occurred while attempting to open for input the file specified
in the <include statement.
.skip 2
.header level 2 <index-f-include ^unable to ^find ^module in ^library
.INDEX <FATAL <ERROR
^issued by <openclose.mar
.skip 2
^the source file being indexed had an <include statement that asked for
a specific module out of a specific text library. ^the text library specified
did not contain the wanted module.
.skip 2
.header level 2 <index-f-include ^unable to  ^open ^library ^file
.INDEX <FATAL <ERROR
^issued by <openclose.mar
.skip 2
^the source file being indexed had an <include statement that asked for
a specific module out of a specific text library. ^the text library file
could not be found.
.skip 2
.header level 2 <index-f-include ^unknown ^module ^name
.INDEX <FATAL <ERROR
^issued by <openclose.mar
.skip 2
^the source file being indexed had an <include statement that asked for
a text library module that could not be found after searching all the
user specified and default libraries.
.skip 2
.hl 2 <index-e-l<ogical <if contains illegal conditional action line xx
.index <error
^issued by <chart.mar.
.skip 2
^the user made a syntactical error. ^the conditional action statement
following the ^logical <if is not permitted. ^the line number of the
offending statement is given.
.skip 2
.header level 2 <index-w-m<erge ^file ^not ^found ^new ^file ^created
.INDEX <WARNING <ERROR
^issued by <openclose.mar
.skip 2
^the user specified that the output be appended (merged) onto the end
of an existing file. ^the specified output file could not be found
so a new output file of the same name was created for the output.
.skip 2
.header level 2 <index-e-m<issing <end statement
.INDEX <ERROR
^issued by <index.mar
.skip 2
^source program terminated with end of file  before and <end was
found. <index assumes <end statement and completes the file processing.
^insert the missing <end.
.SKIP 2
.header level 2 <index-w-m<ultiple ^definition of ^entry ^point xxxxx
.INDEX <WARNING <ERROR
^issued by <flow.mar
.skip 2
^entry point name has been defined more than once in the file(s) submitted
to <index for this entry point cross reference.
.skip 2
.header level 2 <index-e-n<o ^input ^file
.INDEX <ERROR
^issued by <openclose.mar
.skip 2
^an index command required an input file but the command line did not
contain one.
.skip 2
.header level 2 <index-e-n<o ^output ^file
.INDEX <ERROR
^issued by <openclose.mar
.skip 2
^an index command required an output file but the command line did not
contain one.
.skip 2
.hl 2 <index-e-n<on-existent label yyyyy  referenced at line xxxxx
.index <error
^issued by <chart.mar
.skip 2
^user had syntax error. ^branch statement was made to label that does not
exist. ^value of label referenced and line of branch statement given.
.skip 2
.header level 2 <index-e-o<pen ^input ^file ^error
.INDEX <ERROR
^issued by <openclose.mar
.skip 2
^unable to  open input file specified by user
.skip 2
.header level 2 <index-e-o<pen ^output ^file ^error
.INDEX <ERROR
^issued by <openclose.mar
.skip 2
^unable to  open output file specified by user
.skip 2
.header level 2 <index-f-r<ead ^entry ^index ^scratch ^file ^error
.INDEX <FATAL <ERROR
^issued by <flow.mar
.skip 2
^when attempting to read an entry in the entry index scratch data file
an <rms error occurred. ^see the system error message
that was printed out following this message.
.skip 2
.header level 2 <index-f-r<ead ^super ^index ^scratch ^file ^error
.INDEX <FATAL <ERROR
^issued by <flow.mar
.skip 2
^when attempting to read an entry in the super index scratch data file,
an <rms error occurred. ^see the system error message
that was printed out following this message.
.skip 2
.header level 2 <index-f-r<ewind ^entry ^index ^file ^error
.INDEX <FATAL <ERROR
^issued by <flow.mar
.skip 2
^when attempting to rewind entry index scratch data file to read
its contents an <rms error occurred. ^see the system error message
that was printed out following this message.
.skip 2
.header level 2 <index-f-r<ewind ^super ^index ^file ^error
.INDEX <FATAL <ERROR
^issued by <flow.mar
.skip 2
^when attempting to rewind super index scratch data file to read
its contents an <rms error occurred. ^see the system error message
that was printed out following this message.
.SKIP 2
.HL 2 <INDEX-F-S<TRUCTURE DEFINITION NESTED TOO DEEP
.INDEX <FATAL<
^ISSUED BY <LINETYPE.MAR<
.SKIP 2
^A STRUCTURE DEFINITION CONSISTING OF MULTIPLE LEVELS OF <STRUCTURE, 
<UNION AND <MAP STATEMENTS WAS NESTED TO DEEP, CURRENT LIMIT IS
255 LEVELS OF NESTING.
.SKIP 2
.HL 2 <INDEX-E-S<TRUCURED ^VARIABLE ^SYNTAX ^ERROR
.INDEX <ERROR 
.SKIP 2
^syntax error occurred in the use of a structured variable.
^ISSUED BY <EVAL.MAR<
.skip 2
.header level 2 <index-e-t<oo ^many ^continuation ^lines
.INDEX <ERROR
^issued by <ioline.mar
.skip 2
^source program contained over 99 continuation lines. ^excess
continuation lines are ignored. ^reduce number of continuation lines.
.skip 2
.header level 2 <index-w-u<nknown ^character ^found in ^line
.INDEX <WARNING <ERROR
^issued by <linetype.mar
.skip 2
^an unknown printing or non printing character was found while scanning
a source line. ^find and remove it.
.SKIP 2
.header level 2 <INDEX-E<-^unknown ^line ^type or ^syntax ^error
.INDEX <ERROR
^issued by <eval.mar.
.skip 2
<index was unable to determine the line type. ^no saving of data from
this line was performed. ^correct error and try it again.
.ENABLE TOC
.page
.header level 1 ^source ^module ^descriptions
.DISABLE TOC
 <index consists of fourteen(14) assembly language source modules, one(1)
help file, one(1) runoff document source file, and six(6) command files.
^these files are as follows:
.header level 2 <argument.mar<
 ^This is the optional form of the <super <index. ^It is invoked by the use
of the /<CALL__ARGUMENT switch. ^the procedure operates in 3 segments.
.header level 3 ^build ^trees
 ^input from the <super.tmp scratch file, all the data accumulated
for the <super <index and build a set of nested trees. ^the top level
tree is the module name. Each module name entry is the source of a tree
of the arguments of the module, one entry for each ARGUMENT position.
^each argument entry is itself the start of two other trees, one tree
being the name of the argument for that position (usually only one entry
except when alternate <entry points exist), and the other tree being
a list of modules containing calls to the specific module. ^each entry
in the list of calling module tree is itself the start of a tree of the 
names of the arguments passed to the called routine in the specific argument
position.
.header level 3 ^output ^trees
 ^output to the list file, for all modules actually having arguments,
a list of the variables passed via those arguments.
.header level 3 ^clean  ^up
 ^return all elements used in the trees to the heap for reuse.
.header level 3 ^debug
 ^for debug use and keyed to the existence of the name <debug__flag, the
conditionally assembled code for two(2) procedures is available.
^one is <dump__super__buffer that dumps the contents of the <super__buffer
containing the records read from the super index scratch file, the second is
<dump__tree which dumps the current contents of the symbol table trees
in the same form as output to the list file.
.header level 2 <BUILDIDX.com
 ^builds <index from the sources, builds the help library from the help source
and puts it in <sys$help, generates a copy of the <index document.
.header level 2 <chart.mar
^source file for generating a flow chart. ^code is broken into two sections,
data gathering and flow chart generation.
.header level 3 ^data gathering
^this part is called after each line has been processed by the cross reference
gathering routines. ^the required data for each line is gathered and stored
in a scratch file. ^also the initial entries in the local label and
variable (for assigned <goto<'s ) queues are made.
.header level 3 ^flow ^chart ^production
^after the source module has been completely processed, the flow chart
generation routine is then invoked. ^its action goes though the
following phases:
.hl 3	<phase__1
^input the scratch file data and generate the initial program element/pixel
array. ^connect pointers in label queues to pixels defining that label.
^merge as possible multiple lines into single symbols.
.hl 3	<phase__2
^for all block /logical <if and <do statements-build the structure to be
output. ^for all other non structured branch statements check to see if the
specified destination label exists.
.hl 3	<phase__2__a
^mark all the pixels that form the spine (column 0) of the array
forming the initial flow chart picture.
.hl 3	<phase__2__b
^convert the ragged edged array of the flow chart picture to a smooth edged
rectangle.
.hl 3	<phase__2__c
^enter into each pixel its ^x and ^y coordinates in the overall flow chart
picture.
.hl 3	<phase__2__d
^Scan the picture for all branch statements and enter into the appropriate
label queue entry the information as to where this source is that goes to
the specified label.
.hl 3	<phase__2__e
^scan the tableau for all labeled blocks of code that have only one
way in- a jump from out-side the block. ^these blocks of code
are then moved to a point adjacent to the sole jump entry point.
.hl 3	<phase__3
^scan the program pixel array for labels, starting at the upper left, and
scanning right, and as each row is completed, start at the left of the 
next row down. ^when a label is found, all of the places that branches come
from are scanned and the furthest up,down and right are found. using this
information, first the come froms from above are inserted, then all the
labels below between the current label and its furthest down source are
filled in, then the come froms from below for this label are filled in.
^all jumps over 3 pages in distance are replaced by local jumps to
^flow__^connectors adjacent to the jump.
.hl 3	<phase__3__a
^first scan the tableau for the end statement, and if it is unused
(no flow lines into it), then it is replaced by a connector pixel, then
a second scan of the tableau is done 
for columns and rows that are empty or can be removed
with no effect due to the direction of flow lines and then delete them,
reducing the final size of the flow chart to be printed out.
.hl 3	^output ^flow ^chart
^take the information generated and output the flow chart.
.hl 3	^clean ^up.
^empty all the queues and return elements to heap.
.HL 3	^utility routines
 ^within each phase of the flow chart generation, utility routines are
used to accomplish the task of that phase. ^those routines include:
.hl 4	<add__column__to__middle
 ^add a column of connectors to the middle of the tableau, running the
entire length of the tableau. ^the calling program gives the ^y
coordinate of the column just to the left of the location where the
new column is to go.
.hl 4	<add__row__to__middle
 ^add a split row of pixels to the middle of the tableau. ^the calling routine
passes a row and column number. The initial part of the new row up to
and including the column number is just below the specified row. 
^just after the specified column, the rest of the specified existing row 
is dropped down even with the initial part of the new row of pixels
and the rest of the new row of pixels is even with the initial part
of the original specified row.
.hl 4	<add__split__column__to__middle
 ^add a column of connectors to the tableau. ^the calling routine
passes the number of the column which is to be just to the left of 
the critical part of the new column and the upper and lower limits
of that critical part. ^as best as possible, the routine places the
rest of the column (above and below the critical area) on the
right hand side of the tableau.
.hl 4	<add__to__bottom
 ^add a row of connector pixels to the bottom of the tableau.
.hl 4	<add__to__left__side
 ^add a column of connector pixels to the left side of the tableau.
.hl 4	<add__to__right__side
 ^add a column of connector pixels to the right side of the tableau.
.hl 4	<add__token__to__text
 ^as data is gathered for storage in the intermediate scratch file
for ^flow ^chart data, part of the information required for
various selected types is the content of the source line. ^this
routine takes a token pointed to by the calling routine , converts it
back to text, and appends as much of it as possible to the buffer.
.HL 4	<CHECK__block__clear
 ^the calling routine passes a pointer to the upper left corner 
of a portion of the tableau where some pixels are to be moved, along
with the depth and width of the block. ^this routine examines that block
to see that if it is empty and makes suitable adjustments by the addition
of rows and columns to make sure that it is clear for use.
.hl 4 <clear__block
 ^makes a pass over the entire tableau removing from all pixel
flag words indications that they were visited or marked.
.hl 4	<draw__pixel
 ^for the specified pixel, converts the pixel type, and flags to a picture
in the specified offset in the output lines. ^uses the routine 
<overlay__element.
.hl 4	<enter__program__elements__x__y
 ^scans the entire pixel tableau, filling in the ^x and ^y coordinates
in the matrix for each pixel.
.hl 4	<find__insert__label__queue__element
 ^takes the binary value of the label passed by the calling routine
and returns a pointer to 
the entry for that label in the label queue. ^if an entry does
not exist, one is created.
.hl 4	<find__insert__var__queue__element
 ^the calling routine passes pointer and count information to a string
containing the name of a variable. ^this routine returns a pointer
to the entry for that variable in the variable queue. ^if no entry
exists, one is created.
.hl 4	<insert__comes__from__label
 ^takes from the calling routine a label number and pointer to
pixel element where a branch to that label occurs. ^duplicate entries
are eliminated and new entries are put into the <comes <from list for that
label.
.hl 4	<mark__the__block
 ^used in determining the sections of code to be moved. ^marks as visited
the
pixels that are candidates for movement by the setting of flags in the
pixel flag word. ^runs the check recursively. ^returns to the calling
procedure the max left/right (^y) and up/down (^x) values of the
candidate block.
.hl 4	<number__the__block
 ^a block of pixels that have been removed from the main tableau are 
renumbered to the address (^x,^y) where they are to be placed.
.hl 4	<output__to__chart
 ^writes the current contents of the <chart__buffer to the ^flow ^chart
scratch file.
.hl 4	<remove__block
 ^removes from the tableau all pixels that are marked as visited
and fills in the empty spots with connectors.
.hl 4 <replace__pixel
 ^a pointer is passed to a block if pixels that have been removed from
the main tableau. ^these pixels are placed in the array at the specified
address (^x,^y) and the pixels that are replaced are returned to the
heap.
.hl 4	<squeeze__pixel__matrix
 ^scans the tableau for any columns or rows that can be deleted without
any effect on the presentation of the flow lines. ^removes unneeded or
unused sections of the tableau. ^calls the recursive routines
<scan__accross and <scan__down to do the scan and delete.
.hl 3	^debugging ^routines
 ^included in the source file, but assembled only when the symbol
<enable__dump is defined (see top of source file), are two debugging
tools. ^these routines can be invoked either from inline code or
from the ^symbolic ^debugger using the <call command with no arguments.
.hl 4	<check__tableau
 ^when called, checks the pointers in each pixel of the tableau to
see that they are correct (the next pixel to the left/right/up/down
points back properly, and follow adjacent rows and columns
to see that adjacent pixels point to each other rather than pointing
to nothing) and reports to <SYS_$output any that are not.
.hl 4	<dump__tables
 ^when called, outputs to the <listing file in 132 column output
the contents of all the tables in <chart. 
.HEADER level 2 <document.com
 ^command file to generate from <index.rno a copy of the <index document
(this file).
.header level 2 <EVAL.mar
 ^phase 2 of the two phase line evaluation and parsing sequence used in 
<index. ^based on the line type determined by the first phase  in
<linetype.mar, parses the source lines, storing the appropriate symbols
and labels in the symbol table. ^sets the appropriate flags for use in
<output.mar in determining what variables are to be output or just
ignored.
.header level 2 <flow.mar
 ^previous passes of <index store entry point information in the two 
scratch file <entry.tmp (defines the entry point names and what module
they are defined in-if any) and <super.tmp (entry point names and
what modules they are called in). ^this module consists of five(5)
parts.
.header level 3 ^build ^symbol ^table
 ^rewind the scratch files, and using the information
stored in them, build an entry point cross reference symbol table.
^the table defines each entry point, its defining module(if any),
a list of all the modules that call it and  all the modules that it calls.
^in addition, if the user specifies the /<NOLIBRARY__FUNCTIONS switch,
any entry points which have not been defined and that match the names
of system/fortran library routines are deleted from the table.
.header level 3 ^basic ^output
 ^output to the list file the contents of the symbol table
as a simple listing. ^for each entry point list its name, who defines it
(if the name is an <entry or "????"'s if unknown), who it calls
and who calls it.
.header level 3 ^calling ^tree
.INDEX <SWITCH>/<CALLING__TREE
 ^if so selected by the user by the /<calling__tree switch,
generates a calling tree showing graphically the nesting structure of the
program. ^the main line code scans all the symbols looking for symbols
that are not called by any one- these are considered root modules, then
searches the symbol table recursively for each symbol that it calls
and that those symbol calls etc. printing out each symbol found
indented by an amount proportional to the depth of nesting from the
root module. ^continual checks are made for possible recursion,
undefined entry points and possible overflow over the end of the 
printing page (80 or 132 col) and flagged as appropriate.
.header level 3 ^called ^by ^tree
.INDEX <SWITCH>/<CALLED__BY__TREE
 ^if so selected by the user by the /<called__by__tree switch,
generates a called by tree showing graphically the modules that are
at the bottom of the calling sequence and following them back by all possible
routes back to the root or main entry point. ^it starts by scanning
the symbol table for all entry points that do not call ant one and
in the same manner that part 3 operated, follows the called by tree
back to the root.
.header level 3 ^clean ^up
 ^remove all symbols from the symbol table and return
all the elements back to the heap. ^close and reopen the scratch files
for further use.
.header level 2 <generate.com
^command file provided to aid the user to build his own <index command
files to to a complete cross reference. ^see entry 1.8 for full
description of how to use this command file.
.header level 2 <heap.mar
 <index makes great use of queues in its operation. ^this requires
a large number of memory blocks to be acquired and released continually
through out its evaluation. ^in order to reduce the system overhead
and fragmentation of memory, a minimum use is made of the
system virtual memory routines <lib$get__vm and <lib$free__vm.
^all requests to obtain or free memory go through the routines in this module.
^to reduce fragmentation, all requests for memory are rounded up to
the next multiple of 64 bytes. ^within the heap management module are kept
four(4) queues of unused elements, one each for block sizes of 64 bytes,
128 bytes, 192 bytes and 256 bytes. ^on initialization these queues
are given an initial number of unused elements and if one of these
queues becomes empty, an additional block of virtual memory is obtained
from the system and broken up into elements of the proper size and loaded
in to that queue. ^when an element is freed, it is inserted in to the
unused element queue of the appropriate size rather than returning
it to the system.
 ^for the infrequent blocks larger than 256 bytes long
that may be required, their size is rounded up to the next 64 byte boundary and
allocated  from the system as required and when freed, are returned to
the system.
.header level 2 <idxlst.com
 ^lists all the files in the <index build package on the line printer.
.header level 2 <index.hlp
 ^this is the source for the index help library file. ^the library file
is built in <BUILDIDX.com by the command
.index <help <file
.INDEX <SWITCH>/<help
.INDEX <HELP
<lib/create/help <index <index
.break
the resulting <index.hlb is what index reads in response to the
user inquiry /<help=....  .
.header level 2 <index.mar
 ^main line code for the <index program. ^on startup either initializes
the required queues, flags and counters or calls other routines to do so.
^calls the <open routine to get the user command and contains the
main line loop for the cross REFERENCER.
.header level 2 <index.rno
 ^source file for the document (this file).
^generated by the command
.break
@<runoff
.header level 2 <indexcopy.com
 ^command file that copies the complete <index build package from a user
specified source to a user specified destination. ^The command file
prompts for the source and destination information.
.header level 2 <ioline.mar
 ^all <I/o between the source and list files and <index is done via the
routines in this module. ^source lines are read from the source files
and printed out complete with line numbers, and the non  comment lines are
stored in the 100 line (132 col long) array <source__line. ^the
output routine(s) send the output lines to the list file with or without
line and <include nesting numbers as appropriate, paging and
generating headers as required.
.header level 2 <linetype.mar
 ^Phase 1 of the two phase line evaluation and parsing takes place in this
module. ^it simultaneously determines what the line type is and
double checks to see if that guess is correct (backtracking and making a
subsequent guesses as appropriate) and using the information
obtained generates a queue of tokens that represent the key words,
symbols and identifiers found in the source line being evaluated.
.header level 2 <link.com
 ^command file invoked from <BUILDIDX.com to link the object modules of
<index into the final executeable.
.header level 2 <openclose.mar
 ^a complex assortment of routines that are used to obtain and parse
the user command(s) and to open and close all files used by index.
.header level 3 ^get a command and act on it
 ^this segment is one routine with two separate parts. ^first it
obtains from the user a command, which it then parses, setting the
appropriate bits in the flag word and <I/o file specs. ^second it
uses the information obtained in part 1 to actually open any files
for input and_/or output as required. ^it is in the second part that
the calls to <super, <flow and getting help are implemented.
.header level 3 ^open and close scratch files
 ^as required, open and close the super index and entry point index
temporary scratch files.
.header level 3 <include file/library file open and close
 ^on a source file <include statement, push up one <include level
and open the selected file/library module for use, saving such lower
<include level data as may be needed to restart the old file
when the new one has been used up. ^on completion of an <include
file/library, pop back down one level, restoring all the information
needed to continue.
.header level 3 ^chained files
 ^when a zero level <include ^end ^of ^file is detected, and the user
has indicated chained source files, close the current file and open the
next chained file and continue as if the chain of files were all one
file.
.header level 3 ^flow chart files
 ^when the user requests a flow chart, <index needs to open and close
a temporary scratch file to hold the intermediate flow chart data.
.index <switch>/<flow__chart<
.index <switch>/<chart<
.header level 3 ^preserve <super <index data file
 ^when the user requests that the data from the current <super <index
be saved permanently, routines are supplied here to create and close
an <isam file.
.index <switch>/<preserve
.header level 2 <output.mar
 ^outputs to the appropriate places, the data accumulated information
obtained from a simple index. ^for a simple index and super index 
data accumulation, scans the symbol table for those symbols meeting
the criteria selected by the user and outputting that information to
a list file, and in addition, for the super index accumulation,
save only those items that were output in the super index scratch 
file. ^during an entry point index accumulation, only output to the
entry point scratch file and super index scratch file the names
of entry points and the module they are used/defined in.
.HEADER LEVEL 2 <SAMPLE.FOR
 ^ONE OPTION AVAILABLE OPEN TO THE USER IS THE CAPABILITY TO SAVE 
THE DATA FROM A <SUPER <INDEX EITHER FOR LATER REUSE BY <INDEX OR FOR
.INDEX <SWITCH>/<PRESERVE  
HIM TO WRITE HIS OWN PROGRAM TO MANIPULATE.
^THIS <FORTRAN PROGRAM IS PROVIDED AS A SAMPLE ON HOW TO READ AND
MANIPULATE THE DATA IN THE RESULTING <ISAM FILE.
.header level 2 <stat.mar
 ^formats and outputs the <index statistics (if selected) and
clears the appropriate statistics buffers.
.INDEX <SWITCH>/<statistics
.header level 2 <store.mar
 ^used during all index accumulation. ^this module contains the code
to build the tree structured symbol table one symbol at a time.
^also in this module is the code to release all the symbols and
how__used elements back to the heap for reuse.
.header level 2 <super.mar
 ^inputs the information accumulated by previous runs in the
super index scratch file, and builds a symbol table of symbols
used and modules add in. ^outputs to the list file the super index
listing. ^cleans up the symbol table space, returning all the memory
blocks used to the heap for reuse as required.
.header level 2 <table.mar
 ^all information required by more than one module is kept here.
^variables,flags etc that are changed, set , etc for use by other modules.
^data tables, mnemonics, token definitions, lists and other constant
data (note that the order of many of the items here must be identical
to the use of the corresponding tokens used in case statements during
the evaluation and parsing of source lines).
.ENABLE TOC
.page
.header level 1 <building <index
 ^the collection of command files, source files, help and runoff files
that you have received make up the <index distribution package. ^create
a special subdirectory to hold this distribution kit and copy the kit into
it ( the command file <indexcopy.com is supplied for this purpose-see entry
in chapter 4).
 ^index is build by the use of the command file  <BUILDIDX.com<
supplied in the distribution kit. ^start the build process by
issuing the command
.skip 2
@<BUILDIDX
.skip 2
^for the proper operation of the build procedure, the command file
must be run with <bypass privilege  or have <uic [1,4]
in order to copy the <index.hlb
file to <SYS$HELP<, and to
insert <INDEX.HLP into <sys$help:helplib.hlb (as an option) and to
.INDEX <SYS$HELP
.INDEX <HELP
copy <index.exe to <sys$system (also an option).
 ^interacting as required with the installer, the command file does the
following:
.skip 2
^Build the INDEX program from the sources.
.skip 2
^generates a copy of the document from the runoff file
.skip 2
^builds <index.hlb from the file <index.hlp and copies it to <sys$help .
.skip 2
^after asking the installer, will optionally insert <index.hlp into
the system help file <sys$help:helplib.hlb
.skip 2
^after asking the installer, will optionally copy the <index executeable
file <index.exe that has been built to the specified directory. ^this
should be either <sys$system or the subdirectory used to hold the
distribution/build package.
.skip 2
^after asking the installer, will optionally copy the <generate command
file <generate.com which is supplied to assist users to build command
files to do large super index's, to the specified directory.
.skip 2
<BUILDIDX then cleans up after itself and exits with messages to the installer
about installation dependent parameters (see chapter 6) and information
on the lines to be inserted in to 
<sys$manager:syslogin.com for the definition of the required foreign commands
.SKIP 2
$ <ind*ex    :== $ddnn:[dir]<INDEX<
.break
$ <Gen*erate :== @ddnn:[dir]<GENERATE<
.SKIP 2
^substituting for ddnn:[dir] as appropriate.
.break
^the operation of the command file <generate.com and the user instructions
in chapter 1 assume that the above global definitions have been made made
available for all the system users.
.page
.HEADEr level 1 <installation <notes
.DISABLE TOC
.header level 2 ^lines ^per ^page
.INDEX <PAGE <SIZE
.INDEX <FORMAT <CONTROL
.INDEX <LINE <PRINTER
 <index, like most <dec utilities, determines the number of lines per page on
the line printer by calling the run time library function <lib$lp__lines<
.INDEX <LIB$LP__LINES
which returns in ^r0 the number of lines per page. ^this is done by
the routine checking for the presence of the logical name <sys$lp__lines
and if it finds it, returning the equivalent binary value to the
caller, or if it is not present returns the value 66.
^if the value of 66 lines per page is not right, then the
system manager can reset this value by putting an <assign in
the system startup file setting <sys$lp__lines to the proper value
.INDEX <SYS$LP__LINES
in the system logical table. ^this also allows local users to over ride
that value for themselves only by reassigning it in the process
logical table.
.skip 2
.INDEX <SYS$LP__LINES
$ <DEFINE <sys$lp__lines 54
.break
.HEADER LEVEL 2 ^Default ^print ^queue
.INDEX <PRINT <QUEUE
.INDEX <SWITCH>/<print
.INDEX <SWITCH>/<spool
^when using the /<print or /<spool switches, the output file is directed to
the default print queue <SYS$PRINT. ^for a system that does not have
such a queue or uses another name for the default printer, or for 
a user who wants to send his output to a specific print queue, have defined
in the system login file or the individuals login file the command
assigning the logical name <SYS$PRINT to the printer queue desired.
.INDEX <SYS$PRINT
.skip 2
$ <DEFINE <SYS$PRINT <tta6
.ENABLE TOC
.PAGE
.UPPER CASE
.REQUIRE "INDEX.RNX"