home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
OS/2 Shareware BBS: 10 Tools
/
10-Tools.zip
/
fchk294s.zip
/
ftnchek-2.9.4
/
ftnchek.hlp
< prev
next >
Wrap
Text File
|
1996-10-02
|
70KB
|
1,387 lines
1 FTNCHEK
ftnchek - Fortran 77 program checker
2 Introduction
ftnchek (short for Fortran checker) is designed to detect cer-
tain errors in a Fortran program that a compiler usually does not.
ftnchek is not primarily intended to detect syntax errors. Its pur-
pose is to assist the user in finding semantic errors. Semantic
errors are legal in the Fortran language but are wasteful or may
cause incorrect operation. For example, variables which are never
used may indicate some omission in the program; uninitialized vari-
ables contain garbage which may cause incorrect results to be calcu-
lated; and variables which are not declared may not have the intended
type. ftnchek is intended to assist users in the debugging of their
Fortran program. It is not intended to catch all syntax errors.
This is the function of the compiler. Prior to using ftnchek, the
user should verify that the program compiles correctly.
For more detailed information, consult the printed documentation.
2 Invoking_Ftnchek
ftnchek is invoked through a command of the form:
$ ftnchek [/option /option ...] filename [filename ...]
The brackets indicate something which is optional. The brackets
themselves are not actually typed. Here options are command-line
switches or settings, which control the operation of the program and
the amount of information that will be printed out. If no option is
specified, the default action is to print error messages, warnings,
and informational messages, but not the program listing or symbol
tables.
Each option begins with the '/' character. (ftnchek also allows
the '-' character to be used.)
ftnchek options fall into two categories: switches, which are
either true or false, and settings, which have a numeric or string
value. The name of a switch is prefixed by 'no' to turn it off: e.g.
/nopure would turn off the warnings about impure functions. The 'no'
prefix can also be used with numeric settings, having the effect of
turning off the corresponding warnings. Settings that control lists
of warnings have a special syntax discussed below. Only the first 3
characters of an option name (not counting the '/') need be provided.
A colon may be used in place of an equals sign for numeric or string
setting assignments; however, we show only the equals sign form
below.
When more than one option is used, they should be separated by a
blank space. No blank spaces may be placed around the equals sign (
= ) in a setting. ftnchek "?" will produce a command summary list-
ing all options and settings.
For settings that take a list of warnings, namely /f77, /pretty,
/portability, and /truncation, the list consists of keywords sepa-
rated by commas or colons. The list can be omitted, having the
effect of turning on all the corresponding warnings. Also, if the
list is omitted, the setting name can be prefixed with no to turn off
all the warnings it controls. For example, /f77 turns on all warn-
ings about nonstandard constructions, while /nof77 turns them all
off. Three special keywords are:
help Print out all the warning option keywords controlled by the
setting, with a brief explanation of their meanings. This
keyword cannot be given in a list with other keywords.
all Set all warnings. This turns on all warnings controlled by the
setting.
none Clear all warnings. This turns off all warnings controlled
by the setting.
These special keywords must be given in full. For all other
warning keywords, only as many letters of the keyword as are neces-
sary to identify it unambiguously need be given. Including a keyword
in the list turns its warnings on. For example, /f77=intrinsic would
turn on only the warnings about use of nonstandard intrinsic func-
tions. Prefixing a keyword by no- turns its warnings off. For exam-
ple, /pretty=no-long-line turns off warnings about lines exceeding 72
columns in length while leaving all other warnings about misleading
appearance in effect. If a setting has default none, you can turn on
all warnings except one or two by using all first. For example,
/f77=all,no-include enables warnings about all nonstandard extensions
except INCLUDE statements. If a setting has default all, you can
turn off all warnings except one or two by using none first. For
example, /truncation=none,demotion would turn off all precision
related warnings except about demotions.
When ftnchek starts up, it looks for environment variables and
also for a preferences file. Any options defined in the environment
or in the preferences file are used as defaults in place of the
built-in defaults. They are over-ridden by any command line options.
See the section on changing the defaults for details about the envi-
ronment options and the preferences file.
2 Files
When giving a name of an input file, the extension is optional.
If no extension is given, ftnchek will first look for a project file
with extension .prj, and will use that if it exists. If not, then
ftnchek will look for a Fortran source file with the extension .for.
More than one file name can be given to ftnchek, and it will process
the modules in all files as if they were in a single file.
Wildcards are allowed in the specification of filenames on the
command line.
If no filename is given, ftnchek will read input from the stan-
dard input.
2 Options
ftnchek options fall into two categories: switches, which are
either true or false, and settings, which have a numeric or string
value. The name of a switch or numeric setting can be preceded by
'no' to turn it off: e.g. /nousage would turn off the warnings about
variable usage. Only the first 3 characters of an option name (not
counting the '/') need be provided. Most options are positional:
each option remains in effect from the point it is encountered until
it is overridden by a later change.
3 /arguments=num
Controls warnings about mismatches between actual and dummy
subprogram arguments. (An actual argument is an argument passed to
the subprogram by the caller; a dummy argument is an argument
received by the subprogram.)
The meanings of the setting values are as follows:
0: turn off all such warnings.
1: warn only about different number of arguments.
2: warn only about mismatch of data type of arguments and of func-
tion itself.
3: all warnings.
Default = turn-on = 3.
This setting does not apply to checking invocations of intrinsic
functions or statement functions.
See also: /array, /library, /usage.
3 /array=num
Controls the degree of strictness in checking agreement between
actual and dummy subprogram arguments that are arrays. The warnings
controlled by this setting are for constructions that might legiti-
mately be used by a knowledgeable programmer, but that often indicate
programming errors.
The meanings of the setting values are as follows:
0: only warn about cases that are seldom intentional (see note
below).
1: warn if the arguments differ in their number of dimensions, or
if the actual argument is an array element while the dummy
argument is a whole array.
2: warn if both arguments are arrays, but they differ in number of
elements.
3: give both types of warnings.
Default = turn-on = 3.
Note: A warning is always given regardless of this setting if the
actual argument is an array while the dummy argument is a scalar
variable, or if the actual argument is a scalar variable or expres-
sion while the dummy argument is an array. No warning is ever given
if the actual argument is an array element while the dummy argument
is a scalar variable. Variable-dimensioned arrays and arrays dimen-
sioned with 1 or asterisk match any number of array elements. There
is no check of whether multi-dimensional arrays agree in the size of
each dimension separately.
See also: /arguments, /library, /usage.
3 /calltree=num
Causes ftnchek to print out the call structure of the complete
program. The value of num is the sum of numbers selected from the
following list:
0: do not produce any call graph.
1: produce the call graph in tree format.
2: produce the call graph in who-calls-who format (same as /refer-
ence switch).
3: produce the call graph in VCG format (same as /vcg switch).
4: do not prune repeated subtrees (applicable only for format 1).
8: do not sort children into alphabetical order.
Only one of the formats 1, 2, or 3 may be included in the sum.
If no format is specified but one of the other options is given so
that the number is nonzero, call-tree format will be used.
Default = turn-on = 1. See the discussion of the /reference and
/vcg flags for details about these formats.
For tree format, The tree is printed out starting from the main
program, which is listed on the first line at the left margin. Then
on the following lines, each routine called by the main program is
listed, indented a few spaces, followed by the subtree starting at
that routine.
In the default mode, if a routine is called by more than one
other routine, its call subtree is printed only the first time it is
encountered Later calls give only the routine name and the notice
``(see above)''. To have the subtree printed for each occurrence of
the routine, include 4 (don't-prune) in num.
Note that the call tree will be incomplete if any of the input
files are project files containing more than one module that were
created in /library mode. See the discussion of project files below.
Technical points: Each list of routines called by a given routine
is printed in alphabetical order. If multiple main programs are
found, the call tree of each is printed separately. If no main pro-
gram is found, a report to that effect is printed out, and the call
trees of any top-level non-library routines are printed. This flag
only controls the printing of the call tree: ftnchek constructs the
call tree in any case because it is used to determine which library
modules will be cross-checked. See the discussion of the /library
flag.
See also: /crossref, /library, /reference, /sort, /symtab, /vcg.
3 /check
This switch is provided so that errors and warning messages can
be turned off when ftnchek is used for purposes other than finding
bugs, such as making declarations or printing the call tree. It is
positional, so after turning all checks off, selected checks can be
turned back on. The effect of /nocheck is to put all switches,
numeric settings, and settings controlling lists of warnings to their
turn-off values, as if they had all been specified with the /no pre-
fix. The only exceptions are /quiet, /source, /wrap and /wordsize,
which are unaffected by this switch. Default = yes.
Parse errors (syntax errors due to unrecognized or malformed
statements) are not suppressed by this switch, since the results may
be incorrect if ftnchek has not parsed the program correctly. Note
that /check as an option has no effect: this flag can only turn
checking off, not turn it back on again.
3 /columns=num
Set maximum statement length to num columns. (Beyond this is
ignored.) This setting is provided to allow checking of programs
which may violate the Fortran standard limit of 72 columns for the
length of a statement. According to the standard, all characters
past column 72 are ignored. If this setting is used when the
/f77=long-line option is in effect, a warning will be given for any
lines in which characters past column 72 are processed. Turn-on =
max = 132. Default = 72.
This setting does not suppress warnings about the presence of
characters beyond column 72. To process code with meaningful program
text beyond column 72, use this setting and be sure the /f77
long-line option is off. To process code with sequence numbers in
columns 73 to 80, leave the the columns setting at the default value
and use the /pretty=no-long-line flag.
3 /common=num
This setting varies the strictness of checking of COMMON
blocks.
The different levels are:
0: no checking.
1: in each declaration of a given COMMON block, corresponding mem-
ory locations (words or bytes) must agree in data type.
2: also warn if different declarations of the same block are not
equal in total length.
3: corresponding variables in each declaration of a block must
agree in data type and (if arrays) in size and number of
dimensions.
Default = turn-on = 3.
The Fortran 77 Standard requires each named common block, but not
blank common, to be the same length in all modules of the program.
Level 3 provides an extra degree of checking to support a frequent
programming practice.
See also: /library, /usage, /volatile.
3 /crossref
Specifies that a cross-reference table be printed. This table
lists each subprogram followed by a list of the routines that call
it. Also prints a table listing each COMMON block followed by a list
of the routines that access it. Default = no.
The cross-reference listing omits library modules that are not in
the call tree of the main program. The list is alphabetized. The
routines listed as using a COMMON block are those in which some vari-
ables in the block are accessed, not simply those routines that
declare the block. (To find out what routines declare a COMMON block
but do not use it, see the /usage flag.)
See also: /calltree, /reference, /sort, /symtab, /vcg.
3 /declare
If this flag is set, all identifiers whose datatype is not
declared in each module will be listed. This flag is useful for
helping to find misspelled variable names, etc. The same listing
will be given if the module contains an IMPLICIT NONE statement.
Default = no.
See also: /sixchar, /usage.
3 /division
This switch is provided to help users spot potential division
by zero problems. If this switch is selected, every division except
by a constant will be flagged. (It is assumed that the user is
intelligent enough not to divide by a constant which is equal to
zero!) Default = no.
See also: /portability, /truncation.
3 /extern
Causes ftnchek to report whether any subprograms invoked by the
program are never defined, or are multiply defined. Ordinarily, if
ftnchek is being run on a complete program, each subprogram other
than the intrinsic functions should be defined once and only once
somewhere. Turn off this switch if you just want to check a subset
of files which form part of a larger complete program, or to check
all at once a number of unrelated files which might each contain an
unnamed main program. Subprogram arguments will still be checked for
correctness. Default = yes.
The /extern flag is now superseded by the Level 1 usage checking
of subprograms. For the sake of compatibility with earlier versions
of ftnchek, the /extern flag is retained, so that /noextern is
equivalent to a 0 or 2 in the hundreds place of the /usage setting.
However, to avoid anomalous behavior, you should not use both /extern
and /usage on the command line. Probably the /extern switch will be
retired eventually.
See also: /library.
3 /f77=list
Use this setting to catch language extensions which violate the
Fortran 77 Standard. Such extensions may cause your program not to
be portable. Examples include the use of underscores in variable
names; variable names longer than six characters; statement lines
longer than 72 characters; and nonstandard statements such as the DO
... ENDDO structure. ftnchek does not report on the use of lowercase
letters. By default, all warnings are turned off.
This setting provides detailed control over the warnings about
supported extensions to the Fortran 77 Standard. The list consists
of keywords separated by commas or colons. There are three special
keywords: all to turn on all the warnings about nonstandard exten-
sions, none to turn them all off, and help to print the list of all
the keywords with a brief explanation of each. If list is omitted,
/f77 is equivalent to /f77=all, and /nof77 is equivalent to
/f77=none. The warning keywords with their meanings are as follows.
accept-type: ACCEPT and TYPE I/O statements.
backslash: Unix backslash escape in strings. This warning will be
given only if the /source setting value 4 (UNIX backslash) is
specified to cause the escape interpretation of backslash..
byte: BYTE data type declaration.
common-subprog-name: Common block and subprogram having the same
name.
continuation: More than 19 successive continuation lines.
cpp: Unix C preprocessor directives in the source code.
d-comment: Debugging comments starting with D in the source code.
dec-tab: DEC Fortran style tab-formatted source code. This warn-
ing will be given only if the /source setting value 1 is spec-
ified to cause interpretation of tabs in this style.
do-enddo: DO loop extensions: terminal statement label omitted,
END DO, and WHILE.
double-complex: Double precision complex datatype.
format-dollarsign: Dollar sign control code in FORMAT statements.
format-edit-descr: Nonstandard edit descriptors in FORMAT state-
ments.
function-noparen: Function definition without parentheses.
implicit-none: IMPLICIT NONE statement.
include: INCLUDE statement.
inline-comment: Inline comments starting with an exclamation
point.
internal-list-io: List-directed I/O to or from an internal file.
intrinsic: Nonstandard intrinsic functions.
long-line: Statements with meaningful code past 72 columns. This
warning is given only if the /columns setting has been used to
increase the statement field width.
long-name: Identifiers over 6 characters long.
mixed-common: Mixed character and noncharacter data in COMMON
block.
mixed-expr: Nonstandard type combinations in expressions, for
example DOUBLE PRECISION with COMPLEX, assigning hollerith to
integer, logical operations on integers.
name-dollarsign: Dollar sign used as a character in identifiers.
name-underscore: Underscore used as a character in identifiers.
namelist: NAMELIST statement.
param-intrinsic: Intrinsic function or exponentiation by a real
used to define the value of a PARAMETER definition.
param-noparen: PARAMETER statement without parentheses.
pointer: ``Cray pointer'' syntax.
quad-constant: Quad precision real constants, e.g. of the form
1.23Q4.
quotemark: Strings delimited by quote marks rather than apostro-
phes.
statement-order Statements out of the sequence mandated by the
Standard. The allowed sequence is illustrated in Table 1 in
the section on Interpreting the Output.
typeless-constant: Typeless constants, for example Z'19AF.
type-size: Type declarations specifying a size, for example
REAL*8.
variable-format: Variable repeat specification or field size in
FORMAT. These are of the form < expr >.
vms-io: The following VMS Fortran keywords used in I/O statements:
NAME (in OPEN; it is standard only in INQUIRE)
BLOCKSIZE EXTENDSIZE READONLY
BUFFERCOUNT INITIALSIZE RECORDSIZE
CARRIAGECONTROL MAXREC RECORDTYPE
DEFAULTFILE NOSPANBLOCK SHARED
DISP ORGANIZATION TYPE
DISPOSE
See also: /portability, /pretty, /wordsize.
3 /help
Prints a list of all the command-line options with a short
description of each along with its default value. This command is
identical in function to the ``?'' argument, and is provided as a
convenience for those systems in which the question mark has special
meaning to the command interpreter. Default = no.
The help listing also prints the version number and patch level
of ftnchek and a copyright notice.
Note: the ``default'' values printed in square brackets in the
help listing are, strictly speaking, not the built-in defaults but
the current values after any environment options and any command-line
options preceding the /help option have been processed.
See also: /version, /f77=help, /portability=help, /pretty=help,
/truncation=help.
3 /include=path
Specifies a directory to be searched for files specified by
INCLUDE statements. Unlike other command-line options, this setting
is cumulative; that is, if it is given more than once on the command
line, all the directories so specified are placed on a list that will
be searched in the same order as they are given. The order in which
ftnchek searches for a file to be included is: the current directory;
the directory specified by environment variable FTNCHEK_INCLUDE if
any; the directories specified by any /include options; the directory
specified by environment variable INCLUDE; and finally in a standard
systemwide directory (/usr/include for UNIX, SYS$LIBRARY for VMS, and
\include for MSDOS).
3 /intrinsic=num
Controls treatment of nonstandard intrinsic functions. The
setting consists of three digits. The ones digit selects the set of
intrinsic functions to be supported. Set 0 selects only Fortran 77
standard intrinsics plus those needed to support the nonstandard
extended precision data types. These include intrinsics for the dou-
ble complex data type:
CDABS CDSQRT DREAL ZLOG
CDCOS DCMPLX IMAG ZSIN
CDEXP DCONJG ZABS ZSQRT
CDLOG DIMAG ZEXP ZCOS
CDSIN
and for the quad precision and quad complex types:
CQABS QARCOS QEXT QNINT
CQCOS QARSIN QEXTD QPROD
CQEXP QATAN QFLOAT QREAL
CQLOG QATAN2 QIMAG QSIGN
CQSIN QCMPLX QINT QSIN
CQSQRT QCONJG QLOG QSINH
DBLEQ QCOS QLOG10 QSQRT
IQINT QCOSH QMAX1 QTAN
IQNINT QDIM QMIN1 QTANH
QABS QEXP QMOD SNGLQ
Set 1 includes set 0 as well as the following commonly available
intrinsics (all except EXIT and LOC are defined in MIL-STD 1753):
BTEST IBCLR IEOR ISHFTC
EXIT IBITS IOR LOC
IAND IBSET ISHFT NOT
Set 2 includes set 1, plus these common Unix intrinsic functions:
ABORT GMTIME LTIME SRAND
AND IARGC OR SYSTEM
GETARG IRAND RAND TIME
GETENV LSHIFT RSHIFT XOR
Set 3 includes set 1, plus these common VMS functions:
DATE IDATE SECNDS TIME
ERRSNS RAN SIZEOF
The tens digit of this setting controls the syntax of the RAND
intrinsic function. Specify 0 to require invocation with no argu-
ment, 1 to require one argument, and 2 to allow either form. The
hundreds digits controls the syntax of the IARGC function in the same
way.
Note that this setting does not control whether non-standard
warnings are issued about these functions. It controls whether the
functions are assumed to be intrinsic or not, which determines how
their usage is checked. When functions in any of these sets are
included, their invocations will be checked according to the rules
for the intrinsic functions; otherwise they will be checked as normal
(user-written) external functions. The non-standard warnings are
controlled by the /f77=intrinsic option.
Default setting = turn-on = 222 for the Unix version, 223 for the
VMS version, and 221 for all other versions of ftnchek. Turn-off =
0.
3 /library
This switch is used when a number of subprograms are contained
in a file, but not all of them are used by the application. Nor-
mally, ftnchek warns you if any subprograms are defined but never
used. This switch will suppress these warnings. Default = no.
This switch also controls which subprogram calls and COMMON block
declarations are checked. If a file is read with the /library flag
in effect, the subprogram calls and COMMON declarations contained in
a routine in that file will be checked only if that routine is in the
main program's call tree. On the other hand, if the /library switch
is turned off, then ftnchek checks the calls of every routine by
every other routine, regardless of whether those routines could ever
actually be invoked at run time, and likewise all COMMON block decla-
rations are compared for agreement.
The difference between this switch and the /usage level 2 setting
for subprograms is that the latter suppresses only the warning about
routines being declared but not used. The /library switch goes fur-
ther and excludes unused routines processed while it is in effect
from all cross-checking of arguments and COMMON block declarations as
well.
(If there is no main program anywhere in the set of files that
ftnchek has read, so that there is no call tree, then ftnchek will
look for any non-library routines that are not called by any other
routine, and use these as substitutes for the main program in con-
structing the call tree and deciding what to check. If no such top-
level non-library routines are found, then all inter-module calls and
all COMMON declarations will be checked.)
See also: /arguments, /calltree, /common, /extern, /usage.
3 /list
Specifies that a listing of the Fortran program is to be
printed out with line numbers. If ftnchek detects an error, the
error message follows the program line with a caret ( ^ ) specifying
the location of the error. If no source listing was requested,
ftnchek will still print out any line containing an error, to aid the
user in determining where the error occurred. Default = no.
See also: /symtab, /quiet.
3 /makedcls=num
Prepare a neatly-formatted file of declarations of variables,
common blocks, and namelist lists, for possible merging into the
source code. The declarations are stored in a file of the same name
as the source code, but with the extension changed to .dcl. If no
declarations are written to the file, it is deleted to reduce clutter
from empty files.
If input comes from standard input, instead of a named file, then
declarations are written to standard output.
Variables are declared in alphabetical order within each declara-
tion class and type, with integer variables first, because of their
later possible use in array dimensions.
PARAMETER statements are an exception to the alphabetical order
rule, because the Fortran 77 Standard requires that the expressions
defining parameter values refer only to constants and already-defined
parameter names. This forces the original source file order of such
statements to be preserved in the declaration files.
Explicit declaration of all variables is considered good modern
programming practice. By using compiler options to reject undeclared
variables, misspelled variable names (or names extending past column
72) can be caught at compile time. Explicit declarations also
greatly facilitate changing floating-point precision with filters
such as dtoq(1L), dtos(1L), fd2s(1L), fs2d(1L), qtod(1L), and
stod(1L). These programs are capable of changing types of explicit
floating-point type declarations, intrinsic functions, and constants,
but because they do not carry out rigorous lexical and grammatical
analysis of the Fortran source code, they cannot provide modified
type declarations for undeclared variables. Default setting = 0,
turn-on = 1.
The setting values are given by the sum of selected option values
from the following list:
0: Do not write a declaration file.
1: Write a declaration file.
2: Normally, all variables are included in the declaration file.
With this option, include only undeclared variables. This
setting is useful if you want to check for undeclared vari-
ables, since Fortran source files with all variables properly
declared will not result in a .dcl file. With this option,
common blocks and namelist lists will not be included in the
declaration file, since by their nature they cannot be unde-
clared.
4: The declarations are normally prettyprinted to line up neatly
in common columns, as in the declaration files output by the
Extended PFORT Verifier, pfort(1L). This option value selects
instead compact output, without column alignment.
8: Causes continuation lines to be used where permissible. The
default is to begin a new declaration on each line. This
option is appropriate to use with the option for compact out-
put.
16: Output Fortran keywords in lowercase, instead of the default
uppercase.
32: Output variables and constants in lowercase, instead of the
default uppercase. Character string constants are not
affected by this option.
64: Omit declarations of internal integer variables produced by
the SFTRAN3 preprocessor, xsf3(1L), as part of the translation
of structured Fortran statements to ordinary Fortran. These
variables have six-character names of the form NPRddd, NXdddd,
N2dddd, and N3dddd, where d is a decimal digit. Because they
are invisible in the SFTRAN3 source code, and will change if
the SFTRAN3 code is modified, such variables should not be
explicitly declared. Instead, they should just assume the
default Fortran INTEGER data type based on their initial let-
ter, N.
128: Use an asterisk as the comment character; the default is oth-
erwise 'C'.
256: Use 'c' instead of 'C' or '*' as the comment character.
512: Suppress dimensioning of arrays in the generated declara-
tions. This option is for use with code lacking type declara-
tions, to allow the declaration files to be inserted without
change into the code. Since the code will have dimension
statements already, dimensioning the array variables in the
type statements of the declaration file is redundant. This
option should be used only in conjunction with option 2 =
undeclared-only because otherwise any arrays that were dimen-
sioned in a type statement will lose their dimensioning.
If any non-zero value is specified, then declaration output is
selected, even if the value 1 was not included in the sum.
The declaration files contain distinctive comments that mark the
start and end of declarations for each program unit, to facilitate
using text editor macros for merging the declarations back into the
source code.
The ftnchek distribution includes a program, dcl2inc, which pro-
cesses declaration files to produce files containing declarations of
all COMMON blocks, in a form suitable for use as INCLUDE files. See
the dcl2inc man page for the details of its use.
3 /novice
This flag is intended to provide more helpful output for begin-
ners. It has two effects:
(a) provides an extra message to the effect that a function that
is used but not defined anywhere might be an array which the
user forgot to declare in a DIMENSION statement (since the
syntax of an array reference is the same as that of a function
reference).
(b) modifies the form of the error messages and warnings. If the
flag is turned off by /nonovice, these messages are printed in
a style more resembling UNIX lint.
Default = yes.
3 /output=filename
This setting is provided for convenience on systems which do
not allow easy redirection of output from programs. When this set-
ting is given, the output which normally appears on the screen will
be sent instead to the named file. Note, however, that operational
errors of ftnchek itself (e.g. out of space or cannot open file) will
still be sent to the screen. The extension for the filename is
optional, and if no extension is given, the extension .lis will be
used.
3 /portability=list
ftnchek will give warnings for a variety of non-portable
usages. Examples include the use of tabs except in comments or
inside strings, the use of Hollerith constants, and the equivalencing
of variables of different data types. This option does not produce
warnings for supported extensions to the Fortran 77 Standard, which
may also cause portability problems. To catch those, use the /f77
setting. By default, all warnings are turned off.
This setting provides detailed control over the warnings about
possible portability problems. The list consists of keywords sepa-
rated by commas or colons. There are three special keywords: all to
turn on all the warnings about nonportable usages, none to turn them
all off, and help to print the list of all the keywords with a brief
explanation of each. If list is omitted, /portability is equivalent
to /portability=all, and /noportability is equivalent to /portabil-
ity=none. The warning keywords with their meanings are as follows:
backslash: Backslash character in strings. Since some compilers
treat the backslash as an escape character, its presence can
cause problems even though it is used in a standard-conforming
way.
common-alignment: COMMON block variables not in descending order
of storage size. Some compilers require this ordering because
of storage alignment requirements.
hollerith: Hollerith constants (other than within FORMAT specifi-
cations). The Hollerith data type is a feature of Fortran IV
that has been deleted in the Fortran 77 standard. It is
superseded by the character data type. Storing Hollerith data
in variables of a numeric or logical data type is nonportable
due to differing word sizes.
long-string: String constants, variables, or expressions over 255
chars long.
mixed-equivalence: Variables of different data types equivalenced.
mixed-size: Variables declared with default precision used with
variables given explicit precision, in expressions, assign-
ments, or as arguments. For example, if a variable declared
as REAL*8 is treated as equivalent to DOUBLE PRECISION.
real-do: Non-integer DO loop index and bounds. These can cause a
program's results to depend on the hardware characteristics of
the particular computer used.
tab: Tabs in source code. Tabs are interpreted differently by
different compilers. This warning will be given only once, at
the end of the file.
See also: /f77, /hollerith, /pretty, /wordsize.
3 /pretty=list
Controls certain messages related to the appearance of the
source code. These warn about things that might make a program less
readable or be deceptive to the reader. By default, all warnings are
turned on.
This setting provides detailed control over the warnings about
appearance. The list consists of keywords separated by commas or
colons. Since all warnings are on by default, include a keyword pre-
fixed by no- to turn off a particular warning. There are three spe-
cial keywords: all to turn on all the warnings about misleading
appearances, none to turn them all off, and help to print the list of
all the keywords with a brief explanation of each. If list is omit-
ted, /pretty is equivalent to /pretty=all, and /nopretty is equiva-
lent to /pretty=none. The warning keywords with their meanings are
as follows:
embedded-space: Space embedded in variable names.
continuation: Continuation mark following a comment line.
long-line: Lines (except comments) over 72 columns in width
(beyond 72 is normally ignored by compiler).
missing-space: Lack of space between variable and a preceding key-
word.
multiple-common: COMMON block declared in multiple statements. No
warning is given if the statements are consecutive except for
comment lines.
multiple-namelist: NAMELIST declared in multiple statements. No
warning is given if the statements are consecutive except for
comment lines.
parentheses: Parentheses around a variable by itself. As a sub-
program argument, this makes the argument an expression, not
modifiable by the subprogram.
See also: /f77, /portability.
3 /project
ftnchek will create a project file from each source file that
is input while this flag is in effect. The project file will be
given the same name as the input file, but with the extension .f or
.for replaced by .prj. (If input is from standard input, the project
file is named ftnchek.prj.) Default = no.
A project file contains a summary of information from the source
file, for use in checking agreement among FUNCTION, SUBROUTINE, and
COMMON usages in other files. It allows incremental checking, which
saves time whenever you have a large set of files containing shared
subroutines, most of which seldom change. You can run ftnchek once
on each file with the /project flag set, creating the project files.
Usually you would also set the /library and /noextern flags at this
time, to suppress messages relating to consistency with other files.
Only error messages pertaining to each file by itself will be printed
at this time. Thereafter, run ftnchek without these flags on all the
project files together, to check consistency among the different
files. All messages internal to the individual files will now be
omitted. Only when a file is altered will a new project file need to
be made for it.
Naturally, when the /project flag is set, ftnchek will not read
project files as input.
Project files contain only information needed for checking
agreement between files. This means that a project file is of no use
if all modules of the complete program are contained in a single
file.
A more detailed discussion is given in the section on Using Pro-
ject Files.
3 /pure
Assume functions are ``pure'', i.e., they will not have side
effects by modifying their arguments or variables in a COMMON block.
When this flag is in effect, ftnchek will base its determination of
set and used status of the actual arguments on the assumption that
arguments passed to a function are not altered. It will also issue a
warning if a function is found to modify any of its arguments or any
COMMON variables. Default = yes.
When this flag is turned off, actual arguments passed to func-
tions will be handled the same way as actual arguments passed to sub-
routines. This means that ftnchek will assume that arguments may be
modified by the functions. No warnings will be given if a function
is found to have side effects. Because stricter checking is possible
if functions are assumed to be pure, you should turn this flag off
only if your program actually uses functions with side effects.
3 /quiet
This option reduces the amount of output relating to normal
operation, so that error messages are more apparent. This option is
provided for the convenience of users who are checking large suites
of files. The eliminated output includes the names of project files,
and the message reporting that no syntax errors were found. (Some of
this output is turned back on by the /list and /symtab options.)
Default = no.
3 /reference
Specifies that a who-calls-who table be printed. This table
lists each subprogram followed by a list of the routines it calls.
This switch is equivalent to /calltree=2. Default = no.
The reference list omits routines called by unused library mod-
ules. Thus it contains the same information as for the call-tree
format, namely the hierarchy of subprogram calls, but printed in a
different way. This prints out a breadth-first traversal of the call
tree whereas /calltree prints out a depth-first traversal. Only one
format is printed. If both /calltree and /reference flags are given,
the former will take precedence.
See also: /calltree, /crossref, /library, /sort, /symtab, /vcg.
3 /resources
Prints the amount of resources used by ftnchek in processing
the program. This listing may be useful in analyzing the size and
complexity of a program. It can also help in choosing larger sizes
for ftnchek's internal tables if they are too small to analyze a par-
ticular program. Default = no.
In this listing, the term ``chunk size'' is the size of the
blocks of memory allocated to store the item in question, in units of
the size of one item, not necessarily in bytes. When the initially
allocated space is filled up, more memory is allocated in chunks of
this size. The following is an explanation of the items printed:
Source lines processed: Total number of lines of code, with sepa-
rate totals for statement lines and comment lines. Comment
lines include lines with 'C' or '*' in column 1 as well as
blank lines and lines containing only an inline comment.
Statement lines are all other lines, including lines that have
an inline comment following some code. Continuation lines are
counted as separate lines. Lines in include files are counted
each time the file is included.
Total executable statements: Number of statements in the program,
other than specification, data, statement-function, FORMAT,
ENTRY, and END statements.
Total number of modules: A module is any external subprogram,
including the main program, subroutines, functions, and block
data units. This count is of modules defined within the
source, not modules referenced. Statement functions are not
included. A subprogram with multiple entry points is only
counted once.
Max identifier name chars: Number of characters used for storing
identifier names. An identifier is a variable, subprogram, or
common block name. Local names are those of local variables
in a subprogram, whereas global names refer to subprogram and
common block names, as well as dummy argument names and common
variable names. Actual argument text (up to 15 characters for
each argument) is also included here. The space used for
local names is recovered at the end of each module, whereas
the global space grows until the whole program is analyzed.
Unfortunately, this figure may include some common block names
and arguments stored more than once, although a heuristic is
used that will avoid duplicates in many cases.
Max token text chars: A token is the smallest syntactic unit of
the FORTRAN language above the level of individual characters.
For instance a token can be a variable name, a numerical con-
stant, a quoted text string, or a punctuation character.
Token text is stored while a module is being processed. For
technical reasons, single-character tokens are not included in
this total. Items that are not represented in the symbol
table may be duplicated. The space for token text is recov-
ered at the end of each module, so this figure represents the
maximum for any one module.
Max local symbols: This is the largest number of entries in the
local symbol table for any module. Local symbol table entries
include all variables and parameters, common block names,
statement functions, external subprograms and intrinsic func-
tions referenced by the module. Literal constants are not
stored in the local symbol table.
Max global symbols: This is the number of entries in the global
symbol table at the end of processing. Global symbol table
entries include external subprogram and common block names.
Intrinsic functions and statement functions are not included.
Max number of tokenlists: A token list is a sequence of tokens
representing the actual or dummy argument list of a subpro-
gram, or the list of variables in a common block or namelist.
Therefore this number represents the largest sum of COMMON,
CALL, NAMELIST and ENTRY statements and function invocations
for any one module. The space is recovered at the end of each
module.
Max token list/tree space: This is the largest number of tokens in
all the token lists and token trees of any one module. A
token tree is formed when analyzing an expression: each
operand is a leaf of the tree, and the operators are the
nodes. Therefore this number is a measure of the maximum com-
plexity of an individual module. For instance a module with
many long arithmetic expressions will have a high number.
Note that unlike token text described above, the number of
tokens is independent of the length of the variable names or
literal constants in the expressions.
Number of subprogram invocations: This is the sum over all modules
of the number of CALL statements and function invocations
(except intrinsic functions and statement functions).
Number of common block decls: This is the sum over all modules of
the number of common block declarations. That is, each decla-
ration of a block in a different module is counted separately.
(The standard allows multiple declarations of a block within
the same module; these are counted as only one declaration
since they are equivalent to a single long declaration.)
Number of array dim & param ptrs: This is the sum over all modules
of the number of array dimension and parameter definition text
strings saved for use by the /makedcls option. The length of
the text strings is not counted. Each dimension of a multidi-
mensional array is counted separately.
These numbers are obviously not the same when project files are
used in place of the original source code. Even the numbers for
global entities may be different, since some redundant information is
eliminated in project files.
3 /sixchar
One of the goals of the ftnchek program is to help users to
write portable Fortran programs. One potential source of nonporta-
bility is the use of variable names that are longer than six charac-
ters. Some compilers just ignore the extra characters. This behav-
ior could potentially lead to two different variables being consid-
ered as the same. For instance, variables named AVERAGECOST and
AVERAGEPRICE are the same in the first six characters. If you wish
to catch such possible conflicts, use this flag. Default = no.
Use the /f77=long-names if you want to list all variables longer
than six characters, not just those pairs that are the same in the
first six.
See also: /f77, /portability.
3 /sort
Specifies that a sorted list of all modules used in the program
be printed. This list is in ``prerequisite'' order, i.e. each module
is printed only after all the modules from which it is called have
been printed. This is also called a ``topological sort'' of the call
tree. Each module is listed only once. Routines that are not in the
call tree of the main program are omitted. If there are any cycles
in the call graph (illegal in standard Fortran) they will be detected
and diagnosed. Default = no.
See also: /calltree, /crossref, /reference, /symtab, /vcg.
3 /source=num
This setting controls certain options about the form of the
Fortran source code. The setting value is the sum of numbers from
the following list:
1: Accept DEC-style tab-formatted source. A line beginning with
an initial tab will be treated as a new statement line unless
the character after the tab is a nonzero digit, in which case
it is treated as a continuation line. The next column after
the tab or continuation mark is taken as column 7. A warning
will be given in the case where the line is a continuation, if
/f77=dec-tab is in effect.
2: Accept VMS-style INCLUDE statements. These follow the normal
syntax, but with the following additional features: (1) the
file extension, if not given, defaults to the same as a normal
source file extension; and (2) the option /LIST or /NOLIST can
be appended to the include-file name, to control listing of
its contents.
4: Handle UNIX-style backslash escapes in character strings. The
escape sequence following the backslash will be evaluated
according to the ANSI standard for strings in C: up to three
digits signify an octal value, an x signifies the start of a
hexadecimal constant, any of the letters a b f n r t signify
special control codes, and any other character (including new-
line) signifies the character itself. When this source code
option is in effect, a warning will be given if the /f77=back-
slash setting is specified.
The default behavior is to treat the backslash like any other
normal character, but a warning about portability will be generated
if the /portability flag is set. Because of the fact that some com-
pilers treat the backslash in a nonstandard way, it is possible for
standard-conforming programs to be non-portable if they use the back-
slash character in strings.
Since ftnchek does not do much with the interpreted string, it is
seldom necessary to use this option. It is needed in order to avoid
spurious warnings only if (a) the program being checked uses back-
slash to embed an apostrophe or quote mark in a string instead of
using the standard mechanism of doubling the delimiter; (b) the back-
slash is used to escape the end-of-line in order to continue a string
across multiple source lines; or (c) a PARAMETER definition uses an
intrinsic string function such as LEN with such a string as argument,
and that value is later used to define array dimensions, etc.
Default setting = 0, turn-on = 7.
3 /symtab
A symbol table will be printed out for each module, listing all
identifiers mentioned in the module. This table gives the name of
each variable, its datatype, and the number of dimensions for arrays.
An asterisk (*) indicates that the variable has been implicitly
typed, rather than being named in an explicit type declaration state-
ment. The table also lists all subprograms invoked by the module,
all COMMON blocks declared, etc. Default = no.
See also: /calltree, /crossref, /list, /reference, /sort, /vcg.
3 /truncation=list
Warn about possible truncation (or roundoff) errors. Most of
these are related to integer arithmetic. By default, all warnings
are turned on.
This setting provides detailed control over the warnings about
possible truncation errors. The list consists of keywords separated
by commas or colons. Since all warnings are on by default, include a
keyword prefixed by no- to turn off a particular warning. There are
three special keywords: all to turn on all the warnings about trunca-
tion, none to turn them all off, and help to print the list of all
the keywords with a brief explanation of each. If list is omitted,
/truncation is equivalent to /truncation=all, and /notruncation is
equivalent to /truncation=none. The warning keywords with their
meanings are as follows:
int-div-exponent: use of the result of integer division as an
exponent. This suggests that a real quotient is intended. An
example would be writing X**(1/3) to evaluate the cube root of
X. The correct expression is X**(1./3.).
int-div-real: Conversion of an expression involving an integer
division to real. This suggests that a real quotient is
intended.
int-div-zero: division in an integer constant expression that
yields a result of zero.
int-neg-power: exponentiation of an integer by a negative integer
(which yields zero unless the base integer is 1 in magnitude).
This suggests that a real base is intended.
promotion: automatic conversion of a lower precision quantity to
one of higher precision. The loss of accuracy for real vari-
ables in this process is comparable to the corresponding demo-
tion. No warning is given for promotion of integer quantities
to real since this is ordinarily exact.
real-do-index: use of a non-integer DO index in a loop with inte-
ger bounds. An integer DO index with real bounds is always
warned about regardless of this setting.
real-subscript: use of a non-integer array subscript.
significant-figures: overspecifying a single precision constant.
This may indicate that a double precision constant was
intended.
size-demotion: automatic conversion of a higher precision quantity
to one of lower precision of the same type. This warning only
occurs when an explicit size is used in declaring the type of
one or both operands in an assignment. For example, a warning
wil be issued where a REAL*8 variable is assigned to a REAL
variable, if the default wordsize of 4 is in effect.
type-demotion: automatic conversion of a higher precision
quantity to one of lower precision of different type. This
warning includes conversion of real quantities to integer,
double precision to single precision real, and assignment of a
longer character string to a shorter one.
The warnings about promotion and demotion also apply to complex
constants, considering the precision to be that of the real or imagi-
nary part. Warnings about promotions and demotions are given only
when the conversion is done automatically, e.g. in expressions of
mixed precision or in an assignment statement. If intrinsic func-
tions such as INT are used to perform the conversion, no warning is
given.
See also: /portability, /wordsize.
3 /usage=num
Warn about unused or possible uninitialized variables, unused
common blocks, and unused or undefined subprograms.
This setting is composed of three digits. The first digit (hun-
dreds place) controls warnings about subprograms (functions and sub-
routines), the second digit (tens place) warnings about common blocks
and common variables,, and the third digit (ones place) warnings
about local variables. Each digit controls warnings according to the
following scale:
0: no warnings.
1: warn about undefined items: subprograms that are used but never
defined, common block variables that are used but never set,
or local variables that are (or may be) used before they are
set.
2: warn about unused items: subprograms that are defined but never
used (unless taken in library mode), common blocks and common
variables that are unused, or local variables that are
declared or set but never used.
3: give both types of warnings.
Default = turn-on = 333.
Sometimes ftnchek makes a mistake in the warnings about local
variable usage. Usually it errs on the side of giving a warning
where no problem exists, but in rare cases it may fail to warn where
the problem does exist. See the section on Bugs for examples. If
variables are equivalenced, the rule used by ftnchek is that a
reference to any variable implies the same reference to all variables
it is equivalenced to. For arrays, the rule is that a reference to
any array element is treated as a reference to all elements of the
array.
When checking for used-before-set errors involving COMMON vari-
ables, ftnchek does not do a thorough enough analysis of the calling
sequence to know which routines are called before others. So warn-
ings about this type of error will only be given for cases in which a
variable is used in some routine but not set in any other routine.
Checking of individual COMMON variables is done only if the /common
setting is 3 (variable by variable agreement).
The Level 1 value for subprogram usage checking controls warnings
about routines that are invoked by the program but never defined, or
are multiply defined. Ordinarily, if ftnchek is being run on a com-
plete program, each subprogram other than the intrinsic functions
should be defined once and only once somewhere. Set this digit to 0
or 2 if you just want to check a subset of files which form part of a
larger complete program, or to check all at once a number of unre-
lated files which might each contain an unnamed main program. Sub-
program arguments will still be checked for correctness.
See also: /common, /declare, /extern, /library, /volatile.
3 /vcg
Produce the call graph in the form of a VCG graph description.
This description is written to a separate file, with the same stem as
the file containing the main program, and suffix .vcg. This file is
able to be given directly to xvcg(1L) to visualize the call graph.
(If input is from the standard input, then the graph description is
sent to standard output.) This switch is equivalent to /calltree=3.
Default = no.
The VCG description as created is more complex than it need be.
VCG allows graphs and nested subgraphs: each subroutine is created as
a subgraph nested inside its calling routines. This allows you to
interactively display subgraphs or summarise them.
The /vcg option for ftnchek was written by Dr. Philip Rubini
(p.rubini@cranfield.ac.uk).
xvcg is a graph visualisation tool which runs under the X windows
system. It is freely available from ftp.cs.uni-sb.de. It was written
by G. Sander of the University of Saarland, Germany.
3 /version
This option causes ftnchek to print a line giving the version
number, release date, and patch level of the program. If no files
are given, it then exits. If files are given, the effect of this
option is to include the patch level (normally omitted) in the ver-
sion information printed at the start of processing. Default = no.
See also: /help.
3 /volatile
Assume that COMMON blocks are volatile. Default = no.
Many Fortran programmers assume that variables, whether local or
in COMMON, are static, i.e. that once assigned a value, they retain
that value permanently until assigned a different value by the pro-
gram. However, in fact the Fortran 77 Standard does not require this
to be the case. Local variables may become undefined between
activations of a module in which they are declared. Similarly, COM-
MON blocks may become undefined if no module in which they are
declared is active. (The technical term for entities with this
behavior is ``automatic'', but ftnchek uses the word ``volatile''
since it is clearer to the nonspecialist.) Only COMMON blocks
declared in a SAVE statement, or declared in the main program or in a
block data subprogram remain defined as long as the program is run-
ning. Variables and COMMON blocks that can become undefined at some
point are called volatile.
If the /volatile flag is turned on, ftnchek will warn you if it
finds a volatile COMMON block. If, at the same time, the /usage set-
ting is 1 or 3 (check used before set), ftnchek will try to check
whether such a block can lose its defined status between activations
of the modules where it is declared. ftnchek does not do a very good
job of this: the rule used is to see whether the block is declared in
two separated subtrees of the call tree. For instance, this would be
the case if two modules, both called from the main program, shared a
volatile COMMON block. A block can also become undefined between two
successive calls of the same subprogram, but ftnchek is not smart
enough to tell whether a subprogram can be called more than once, so
this case is not checked for.
The /volatile flag does not affect the way ftnchek checks the
usage of local variables.
See also: /common, /usage.
3 /wordsize=num
Specifies the default word size to be num bytes. This is the
size of logical and single-precision numeric variables that are not
given explicit precisions. (Explicit precisions for non-character
variables are an extension to the Fortran 77 Standard, and are given
by type declarations such as REAL*8 X.) Double-precision and complex
variables will be twice this value, and double complex variables four
times. Quad-precision constants and intrinsic function results will
be four times this value. Note that variables declared as REAL*16
will be regarded as quad precision only if the word size is 4 bytes.
Default = turn-on = 4 bytes.
The word size value does not matter for checking standard-con-
forming programs that do not declare explicit precisions for non-
character variables or store Hollerith data in variables. This set-
ting also does not affect the default size of character variables,
which is always 1 byte. Hollerith constants also are assumed to
occupy 1 byte per character.
The word size is used to determine whether truncation occurs in
assignment statements, and to catch precision mismatches in subpro-
gram argument lists and common block lists. The exact warnings that
are issued will depend on the status of other flags. Under both the
/portability=mixed-size and the /nowordsize flag, any mixing of
explicit with default precision objects (character expressions not
included) is warned about. This applies to arithmetic expressions
containing both types of objects, and to subprogram arguments and
COMMON variables. Under control of the /truncation=demotion and pro-
motion options, a warning is given for assignment of an expression to
a shorter variable of the same type, or for promotion of a lower pre-
cision value to higher precision in an arithmetic expression or an
assignment statement.
Giving a word size of 0, or equivalently, using /nowordsize means
that no default value will be assumed. This is equivalent to speci-
fying /portability=mixed-size. Use it to find cases of mixing
default and explicit precision, for example to flag places where
REAL*8 is treated as equivalent to DOUBLE PRECISION.
See also: /portability, /truncation.
3 /wrap=col
Controls the wrapping of error messages. Long error messages
that would run past the specified column will be broken up into sepa-
rate lines between the words of the message for better readability.
If turned off with /nowrap, each separate error message will be
printed on one line, leaving it up to the display to wrap the message
or truncate it. Default = turn-on = 79.
2 Changing_the_defaults
ftnchek includes two mechanisms for changing the default values
of all options: by defining environment variables or by creating a
preferences file. When ftnchek starts up, it looks in its environ-
ment for any variables whose names are composed by prefixing the
string FTNCHEK_ onto the uppercased version of the option name. If
such a variable is found, its value is used to specify the default
for the corresponding switch or setting. In the case of settings
(for example, the /common strictness setting) the value of the envi-
ronment variable is read as the default setting value. In the case
of switches, the default switch will be taken as true or yes unless
the environment variable has the value 0 or NO.
Note that the environment variable name must be constructed with
the full-length option name, which must be in uppercase. For exam-
ple, to make ftnchek print a source listing by default, set the envi-
ronment variable FTNCHEK_LIST to 1 or YES or anything other than 0 or
NO. The names FTNCHEK_LIS (not the full option name) or ftnchek_list
(lower case) would not be recognized.
The way to set the environment variables on the VMS system is by
using the DEFINE command. For example, to set the default /list
switch to YES, give the command
$ DEFINE FTNCHEK_LIST 1
After processing any environment variables, ftnchek looks for a
preferences file containing options and settings. It will search in
the following order, using only the first file found: (1) .ftnchekrc
in the current directory, (2) ftnchek.ini in the current directory,
(3) .ftnchekrc in the user's home directory, (4) ftnchek.ini in the
home directory. If such a file is found, the options defined in it
are used as defaults in place of the built-in defaults and overriding
any defaults set in the environment..
Each option or setting in the preferences file must be on a sep-
arate line. They are given in the same form as on the command line,
except without the initial slash. The preferences file can contain
blank lines and comments. Comments are introduced at any point in a
line by a space character (blank or tab) or the '#' character, and
are terminated by the end of the line.
Command-line options override the defaults set in the environ-
ment or in the preferences file, in the same way as they override
the built-in defaults.
2 Project_files
This section contains detailed information on how to use pro-
ject files most effectively, and how to avoid some pitfalls.
Ordinarily, project files should be created with the /library
flag in effect. In this mode, the information saved in the project
file consists of all subprogram declarations, all subprogram invoca-
tions not resolved by declarations in the same file, and one instance
of each COMMON block declaration. This is the minimum amount of
information needed to check agreement between files.
If the file contains more than one routine, there are some pos-
sible problems that can arise from creating the project file in
library mode, because the calling hierarchy among routines defined
within the file is lost. Also, if the routines in the file make use
of COMMON blocks that are shared with routines in other files, there
will not be enough information saved for the correct checking of set
and used status of COMMON blocks and COMMON variables according to
the /usage setting. Therefore if you plan to use project files when
the /usage setting is nonzero (which is the default situation), and
if multiple routines in one project file share COMMON blocks with
routines in other files, the project files should be created with the
/library flag turned off. In this mode, ftnchek saves, besides the
information listed above, one invocation of each subprogram by any
other subprogram in the same file, and all COMMON block declarations.
This means that the project file will be larger than necessary, and
that when it is read in, ftnchek may repeat some inter-module checks
that it already did when the project file was created. If each pro-
ject file contains only one module, there is no loss of information
in creating the project files in library mode.
Because of the possible loss of information entailed by creating
a project file with the /library flag in effect, whenever that pro-
ject file is read in later, it will be treated as a library file
regardless of the current setting of the /library flag. On the other
hand, a project file created with library mode turned off can be read
in later in either mode.