.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
.PAGE SIZE 56,80
.RIGHT MARGIN 75
.LOWER CASE
.SKIP 10
.CENTER;	^^INDEX-FORTRAN C\\ROSS ^REFERENCER AND ^FLOW ^CHART ^GENERATOR
.SKIP 2
.CENTER;	^V2.17
.SKIP 20
^michael ^n. ^le^vine
.break
^code 3514
.break
^naval ^weapons ^center
.break
^china ^lake
.break
^california
.break
93555
.skip 2
(619)#939-2318
.break
#<avn##437-2318
.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 saveing 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 only 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
the variable storage information (local, in <common, passed by argument, etc)
and useage in <function</<subroutine< calls (routine used in and argument
number) in both the basic and <super <index.
^if selected, the user may at the same time
generate a flow chart of the source file currently being cross-referenced.
.p
^In addition the user can also save the
selected variable/<common block names (with optional 
user specified tags for further identification and_/or variable storage
location information )
or entry point information from multiple files and output the accumlated data
as a super index (with A great deal
of user control over the form of the data display)
or as an entry point cross reference 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 guarenteed that all errors have been removed or that in obscure
or pathalogical 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 guarrenteed
for all possable <fortran programs.
 ^if any problems
are found, let me know at the address above along with the details of the
problem includeing 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 implemination and release to the general public.
.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 occour in the middle
of a switch includeing 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 occour 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 parseing
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
includeing 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 generateing cross reference information for individual files
with no intent on saveing 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 
concatinated 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 ^accumulateing 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 untill
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 issueing the following
command
with no arguments
.skip 2
<index
.skip 2
causeing <index to issue the prompt
.skip 2
^file:
.skip 2 
^the user can then submit files for indexing and saveing 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/output=nl: <sub1,sub2,lib1/library

.INDEX <SWITCH>/<LIBRARY
.INDEX <TEXT <LIBRARY
.INDEX <FILE <EXTENTION>.<TLB
.INDEX <INCLUDE <FILES
.break
^file:/<get__super/output=nl: <sub3,lib2/library
.skip 2
 ^note that the output is directed to the null device. ^other modifiying
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 identifiction 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<, useing the /<tag< switch to note the differences.
.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 issueing the command
.skip 2
.INDEX <COMMAND <LINE
.INDEX <SWITCH>/<DO__SUPER
^file:/<do__super file__spec
.skip
^where all the accumlated 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
( each routine name followed by a tag field in parrenthesis
if a tag was specified for that data item), the storage location of the
.index <switch>/<tag<
variable (in square brackets) (if the /<STORE switch was used to accumulate
.index <switch>/<store<
the data for the <super <index) and the argument useage information
about the variable (in curly brackets) (if the /<ARGUMENT switch was used
.index <switch>/<argument<
to accumulate the data for the <super <index). 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 five(5) items (variable/<common name,
routine name, tag field, storage 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.
.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 ^accumulateing 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 untill
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 issueing the following
command
with no arguments
.skip 2
<index
.skip 2
causeing <index to issue the prompt
.skip 2
^file:
.skip 2 
^the user can then submit files for indexing and saveing for the super index.
.INDEX <OUTPUT <FILE
^even though the data is being saved for a super index, no output is generated.
^useing 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 modifiying
.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 issueing the command
.skip 2
.INDEX <OUTPUT <FILE
.INDEX <SWITCH>/<DO__ENTRY
^file:/<do__entry file__spec
.skip
^where all the accumlated 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 diffrent printout, it can be saved for the
next command by includeing 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 untill 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 moveing of selected
blocks of code that have only only one input (via a jump) and moveing
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 overidden 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.
.header level 3 ^flow ^chart ^conventions
.disable toc
.HEADER LEVEL 4 ^MERGEING
.index <mergeing <symbols
 ^in order to save some space both in memory and on print out, some
mergeing of source lines into symbols is done. Generally like types
are merged with like types where appropriate: all ^i/^o statements
includeing the auxiliary statements such as <open or <rewind etc are
considered for mergeing. ^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 someware, 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
causeing 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 togeather
along the same horizontal line untill the appropriate vertical line
dedicated for the specific target label is reached, then that part of
the multiple branch statement useing that label as a target is considered
to leave the commom 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 moveing 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 confuseing 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 implimented at this time, a generic flow chart picture element is
13 characters wide and 9 deep as follows:
.tp   16
.literal

	<---->*<---->
	|nnnnn|     |
	| 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 executeabe statements not
otherwise included below.
.literal	 	               

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

.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            

	 	   ---------   
	 	   |DOnnnnn|   
	 	   |xxxxxxx|   
	 	   |xxxxxxx|   
	 	   ---------   

.end literal	 	               
.tp 12
^the <continue box, representing the <continue statement.
.literal	 	               

	 	   ---------   
	 	   | CONT- |   
	 	   | INUE  |   
	 	   |       |   
	 	   ---------   

.end literal	 	               
.tp 12	 	               
<call statement. ^name of call routine inserted inside.
.literal	 	               
	 	               
	 	   ---------   
	 	   ||     ||   
	 	   ||     ||   
	 	   ||     ||   
	 	   ---------   
	 	               
.end literal	 	               
.tp 12
^all ^i/^o includeing auxilary lines.
.literal	 	               
	 	               
	 	       -----   
	 	      /   /    
	 	     /   /     
	 	    /   /      
	 	   -----       
	 	               
.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
	 	               
	 	       ^       
	 	     /   \     
	 	   <       >   
	 	     \   /     
	 	       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	 	               
	 	               
		   -------     
		   |      \    
		   |       >   
		   |      /    
		   -------     
	 	               
.end literal
.tp 12
^assign a label to a variable for assigned <goto. ^the label and variable names
are inserted.
.literal
	 	               
	 	     -----     
	 	    /     \    
	 	   <       >   
	 	    \     /    
	 	     -----     
	 	               
.end literal	 	               
.tp 12
^All program entry points, the
name is inserted.
.literal

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

	 	     -----     
	 	    (PAUSE)    
	 	   (       )   
	 	    (     )    
	 	     -----     

.end literal
.tp 12
<STOP flow control statement. ^The first few characters of
any text in the statement is inserted in the symbol.
.literal

	 	     -----     
	 	    ( STOP)    
	 	   (       )   
	 	    (     )    
	 	     -----     

.end literal
.tp 12
<RETURN flow control statement. ^The first few characters of
any text in the statement is inserted in the symbol.
.literal

	 	     -----     
	 	    (RETURN)    
	 	   (       )   
	 	    (     )    
	 	     -----     

.end literal
.tp 12
<END flow control statement.
.literal

	 	     -----     
	 	    ( END )    
	 	   (       )   
	 	    (     )    
	 	     -----     

.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
jumed to.
.literal

	 	       -     
	 	     /   \    
	 	    (     )   
	 	     \   /    
	 	       -     

.end literal
.TP 12
^THE GENERAL CONNECTOR TYPE OF PIXEL HAS THE FORM
.LITERAL

                   <-----*----->
                   |Lbl_1^Lbl_2|
                   |     |     |
                   |     |     |
                   ----->+<-----
                      <=>|
                     ERR=|
                     END=VLbl_3
                   <-----*----->
.END LITERAL
^actually the symbol above reperesents the most complex possable display of
the connector pixel. ^in actuallity, 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 reversable, 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 indicateing 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 appropritate
label is put up to differentiate as to which one is takeing 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 possable 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 occours 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
defineing 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 comeing 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 comeing 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 causeing 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 /<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 and accumlate for <SUPER <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.
See also /<ORDER and /<REORDER<.
.index <switch>/<order<
.index <switch>/<reorder<

.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 collumn), 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 reperesentation
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 collumn), 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<]]
.index <switch>/<chart
.index <switch>/<flow__chart
.index <switch>/<flow__chart<><noconnector
.index <switch>/<flow__chart<><nomove
.index <switch>/<chart<><noconnector
.index <switch>/<chart<><nomove
.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 imediately
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.
^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,
allowes 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
 ^Useing previously accumlated 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
 ^Useing previously accumlated 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 /<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<]]
.index <switch>/<chart
.index <switch>/<flow__chart
.index <switch>/<flow__chart<><noconnector
.index <switch>/<flow__chart<><nomove
.index <switch>/<chart<><noconnector
.index <switch>/<chart<><nomove
.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 imediately
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.
^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. ^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
overides 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 defineing <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 catagories.
.SKIP 2
^see also /<export.

.INDEX <SWITCH>/<EXPORT

.header level 3 /<INDENT<=x
.index <switch>/<indent<
.index <switch>/<argument<
.index <switch>/<store<
.index <switch>/<storage<
.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 /<ARGUMENT, /<STORAGE, and/or /<TAG<="xxxxx" each add one
to the number of items in the output. Used with /<REVERSE or /<REORDER
or /<ORDER to set up the <SUPER <INDEX format wanted.

.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.
.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 produceing 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
^supresses 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 saveing 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
aginst 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 outputing the entry point cross reference,
and its effect is perminent 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 /<order=<major__item:minor__item:first__tag:second__tag

.INDEX <SWITCH>/<ORDER
.INDEX <SUPER <INDEX <FORMAT <CONTROL
.INDEX <FORMAT <CONTROL
.INDEX <TAG
.INDEX <STORAGE <LOCATION
.index <argument <useage<


^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 5 items, The variable/<common
name, module name in which that variable/<COMMON name was defined,
the tag (if specified) , the variable storage location (if requested
at data accumulation time by /<storage or /<store) and the arguement useage
information (if requested at data accumulation time by the /<argument< switch).
.index <switch>/<storage
.index <switch>/<store
.index <switch>/<argument<
^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 with the 
tag for each entry appended to the appropriate minor entry in parrens then
the storeage location information in square brackets followed by the
argument information in curly brackets.
The user can specify the order of listing in the <SUPER <INDEX if the
default or /<REVERSE formats are not appropriate. The four arguments
"major__item" , "minor__item" , "first__tag" and "second__tag" 
take one of five values:
.break
##<NAME<####-for variable/<COMMON name (<variable or <common can also be used)
.break
##<MODULE<##-for the defineing 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 useage 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<
All arguments must be specified and cannot be the same.
.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

.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 collumn 80 and moves back to 
collumn 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 /<reorder=<major__item:minor__item:first__tag:second__tag

.INDEX <SWITCH>/<reORDER
.INDEX <SUPER <INDEX <FORMAT <CONTROL
.INDEX <FORMAT <CONTROL
.INDEX <TAG
.INDEX <STORAGE <LOCATION
.index <argument <useage<
^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 5 items, The variable/<common
name, module name in which that variable/<COMMON name was defined,
the tag (if specified) , the variable storage location (if requested
at data accumulation time by /<storage or /<store) and the arguement useage
information (if requested at data accumulation time by the /<argument< switch).
.index <switch>/<storage
.index <switch>/<store
.index <switch>/<argument<
^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 with the 
tag for each entry appended to the appropriate minor entry in parrens then
the storeage location information in square brackets followed by the
argument information in curly brackets.
The user can specify the order of listing in the <SUPER <INDEX if the
default or /<REVERSE formats are not appropriate. The four arguments
"major__item" , "minor__item" , "first__tag" and "second__tag" 
take one of five values:
.break
##<NAME<####-for variable/<COMMON name (<variable or <common can also be used)
.break
##<MODULE<##-for the defineing 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 useage 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>/<order><variable<
.index <switch>/<order><common<
All arguments must be specified and cannot be the same.
.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 /<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, ignoreing 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 useing 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

.INDEX <SWITCH>/<STATISTICS
 ^Print the index statistics about each source module at the end of the
module listing in the list file.
.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. ^during accumlation of data for <super <index, causes the 
information to be saved for <super <index print out.
.index <super <index
^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. ^during accumlation of data for <super <index, causes the 
information to be saved for <super <index print out.
.index <super <index
^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 specificed tag
associated with them. ^during the super <index output, the tag is printed
with the assosiated 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
differentiateing between the different inputs. ^the user specified tag
can be no more than 31 characters long includeing 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 outputing the entry point cross reference,
and its effect is perminent for that saved data set.
.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 /<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 ^useage ^chart
.literal
				Type of INDEX

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

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

 O	Optional in this context
 M	Manditory 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 confuseing, 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 or three switches are shown stacked verticaly
with no rows seperateing them, they are considered to be mutually
excluseive.
 ^In all possable 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 5
.literal

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

.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<
 ^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<
.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 /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
           /REORDER
           /REVERSE


.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 implimentation switch is used as 
this is the default operateing mode.

.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 togeather into 162 different combinations:
.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 possable combinations are accepted by <INDEX, not all are
meaningfull 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 possable 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 possable 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 libable to contain variables with various
characteristics, the entire common block will have take on the
characteristic of the highest precidence variable in a given catagory.
^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 precidence over <unused.
.page
.paragraph
^the basic selection switches that are normally used togeather 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 wether you are interested only in local variables or those
resideing 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 reccomended
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.
/STORE/GET_SUP/IMP/SAVE_IND/LOG/OUT=NL:/NOSOUR/NOIND/TAG="IMPORT" MAIN
				Use saved data from previous INDEX
				and repeat for exported data.
/STORE/GET_SUP/EXP/LOG/OUT=NL:/NOSOUR/NOIND/TAG="EXPORT" MAIN  
/STORE/GET_SUP/IMP/SAVE_IND/LOG/OUT=NL:/NOSOUR/NOIND/TAG="IMPORT" SUB1
/STORE/GET_SUP/EXP/LOG/OUT=NL:/NOSOUR/NOIND/TAG="EXPORT" SUB1
/STORE/GET_SUP/IMP/SAVE_IND/LOG/OUT=NL:/NOSOUR/NOIND/TAG="IMPORT" SUB2
/STORE/GET_SUP/EXP/LOG/OUT=NL:/NOSOUR/NOIND/TAG="EXPORT" SUB2
/LOG/DO_SUPER/MERGE/SAVE_SUPER 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/INDENT=1 MAIN
				Now look at COMMON block useage
/SAVE_IND/GET_SUP/COMM/USED/LOG/OUT=NL:/TAG="USED" MAIN,SUB1,SUB2
/GET_SUP/COMM/UNUSED/LOG/OUT=NL:/TAG="UNUSED" MAIN,SUB1,SUB2
/COMMENT="COMMON BLOCK USEAGE"/LOG/DO_SUPER/MERGE 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 suppled 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 haveing the switch /<library appended to it.
.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
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 extentions 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 seperate line, left justified.
If a source file requires a library file (.TLB), put its name on the
same line as the source file(seperated 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 includeing the extention.
.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 includeing the extention.
^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 extention is  .<lis . 
.INDEX <FILE <EXTENTION>.<LIS
^from this point on the command file <generate.com builds the target
command file that will do the actuall 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
.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 occour 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
.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 occoured 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 occoured in attempting to connect user specified output file.
.skip 2
.header level 2 <index-e-end found inside ^block <if or <do
.index <error
^issued by <chart.mar
.skip 2
^user had syntax error. <end statement occoured while program still
nested in a block <if or <do statement.
.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 ^super ^index ^scratch ^file
.INDEX <FATAL <ERROR
^issued by <super.mar
.skip 2
<rms error ococured 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
.skip 2
<rms error occoured while attempting to rewind the super index scratch
file in preparation for useing the information included therein for
a super index output.
.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 accumlation phase of <index, the raw flow chart data is 
stored in a scratch file. ^an error occoured while writeing information
to this file.
.skip 2
.header level 2 <index-f-e<rror ^writeing to ^entry ^index ^scratch ^file
.INDEX <FATAL <ERROR
^issued by <output.mar
.skip 2
<rms error occoured 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 ^writeing to ^entry ^super ^index ^scratch ^file
.INDEX <FATAL <ERROR
^issued by <output.mar
.skip 2
<rms error occoured in entry point cross reference while attempting to
save entry point occourance information in the entry super index scratch file.
.skip 2
.header level 2 <index-f-e<rror ^writeing to ^super ^index ^scratch ^file
.INDEX <FATAL <ERROR
^issued by <output.mar
.skip 2
<rms error occoured 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 occoured while attempting to connect for input the file specified
in the <include statment.
.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 occoured while initializeing 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 attemped 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 occoured while attempting to open for input the file specified
in the <include statment.
.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 permited. ^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 exisiting 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 terminted 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 brance 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 occoured. ^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 occoured. ^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 occoured. ^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 occoured. ^see the system error message
that was printed out following this message.
.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 saveing 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 twelve(13) 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 <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 generateing 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 defineing that label.
^merge as possable 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. useing 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__^connenctors 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 collumns and rows that are empty or can be removed
with no effect due to the direction of flow lines and then delete them,
reduceing 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 collumn number. The initial part of the new row up to
and includeing the collumn number is just below the specified row. 
^just after the specified column, the rest of the specifed 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 possable, 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 intermidiate 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 possable 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 suteable 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 removeing from all pixel
flag words indications that they were vistited 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 coordinants
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 vatriable 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 occoures. ^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 visitied
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 useing 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, ouputs to the <listing file in 132 collumn 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 parseing sequence used in 
<index. ^based on the line type determined by the first phase  in
<linetype.mar, parses the source lines, storeing the appropriate symbols
and labels in the symbol table. ^sets the appropriate flags for use in
<output.mar in determineing 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 useing the information
stored in them, build an entry point cross reference symbol table.
^the table defines each entry point, its defineing module(if any),
a list of all the modules that call it and  all the modules taht it calls.
^in addition, tif 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 possable recursion,
undefined entry points and possable 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 possable
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 boundry 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 responce 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, pageing and
generateing headers as required.
.header level 2 <linetype.mar
 ^Phase 1 of the two phase line evaluation and parsing takes place in this
module. ^it simultaniously determines what the line type is and
double checks to see if that guess is correct (backtracking and making a
susbsequent guesses as appropriate) and useing 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 seperate 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 iformation 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 implimented.
.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, saveing 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, restoreing 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 2 <output.mar
 ^outputs to the appropriate places, the data accumlated 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 outputing 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 moduele they are used/defined in.
.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 accumualtion. ^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 ued 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 parseing of sourcelines).
.ENABLE TOC
.page
.header level 1 <building <index
 ^the collection of command files, source files, help and runoff files
that you have recieved make up the <index distibution 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 distibution kit. ^start the build process by
issueing 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
^substituteing 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 useing 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
.DO INDEX