Provided by: ftnchek_3.3.1-5build1_amd64 bug

NAME

       ftnchek - Fortran 77 program checker

SYNOPSIS

       ftnchek [ -arguments[=list] ] [ -array[=list] ]
            [ -[no]brief ] [ -calltree[=list] ] [ -[no]check ]
            [ -columns[=num] ] [ -common[=list] ]
            [ -[no]crossref[=list] ] [ -[no]declare ]
            [ -[no]division ] [ -errors[=num] ] [ -[no]extern ]
            [ -[no]f77[=list] ] [ -[no]f90[=list] ]
            [ -[no]f95[=list] ] [ -[no]help ]
            [ -[no]identifier-chars[=list] ] [ -include=str ]
            [ -intrinsic[=list] ] [ -[no]library ] [ -[no]list ]
            [ -makedcls[=list] ] [ -mkhtml[=list] ]
            [ -[no]novice ] [ -output=str ]
            [ -pointersize[=num] ] [ -[no]portability[=list] ]
            [ -[no]pretty[=list] ] [ -project[=list] ]
            [ -[no]pure ] [ -[no]quiet ] [ -[no]reference ]
            [ -[no]resources ] [ -[no]sixchar ] [ -[no]sort ]
            [ -source[=list] ] [ -style[=list] ] [ -[no]symtab ]
            [ -[no]truncation[=list] ] [ -usage[=list] ]
            [ -[no]vcg ] [ -[no]version ] [ -[no]volatile ]
            [ -wordsize[=num] ] [ -wrap[=num] ] [ files ...  ]

DESCRIPTION

       ftnchek  (short  for  Fortran  checker)  is designed to detect certain errors in a Fortran program that a
       compiler usually does not.  ftnchek is not primarily intended to detect syntax errors.  Its purpose 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 variables contain garbage which may cause incorrect results to be
       calculated; 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.

       This  document  first  summarizes how to invoke ftnchek.  That section should be read before beginning to
       use ftnchek.  Later sections describe ftnchek's options in more detail, give an example of its  use,  and
       explain  how  to  interpret  the  output.   The  final sections mention the limitations and known bugs in
       ftnchek.

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.  (On VAX/VMS or MS-DOS systems you may use either '/' or '-'.)
       For the sake of conformity with an increasingly common convention, options can also begin with '--'.  The
       options are described at greater length in the next section.

       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' or '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.

       The  switches  and  settings  which  ftnchek currently recognizes are listed below.  For each option, the
       default is the value used if the option is not explicitly specified, while the turn-on is the value  used
       if the option is given without assigning it a value.

       -arguments=list
              Control warnings about subprogram type and argument mismatches.  Default = turn-on = all.

       -array=list
              Control warnings in checking array arguments of subprograms.  Default = turn-on = all.

       -brief Use shorter format for some error messages.  Default = no.

       -calltree=list
              Produce  subprogram  call  hierarchy  in  one of 3 formats: text call-tree, who-calls-who and VCG.
              Default = none, turn-on = tree,prune,sort.

              If the -mkhtml option  is  invoked  and  tree  is  the  applied  calltree  option,  a  file  named
              CallTree.html, will be produced depicting the tree in HTML format.

       -check Perform checking.  Default = yes.

       -columns=num
              Set maximum line length to num columns. (Beyond this is ignored.)  Turn-on = max = 132.  Default =
              72.

       -common=list
              Set degree of strictness in checking COMMON blocks.  Default = turn-on = all.

       -crossref=list
              Print cross-reference list of subprogram calls, label usage, and/or COMMON block use.   Default  =
              none.

       -declare
              Print a list of all identifiers whose datatype is not explicitly declared.  Default = no.

       -division
              Warn wherever division is done (except division by a constant).  Default = no.

       -errors=num
              Set the maximum number of error messages per cascade.  Default = turn-on = 3.

       -extern
              Warn if external subprograms which are invoked are never defined.  Default = yes.

       -f77=list
              Control specific warnings about supported extensions to the Fortran 77 Standard.  Default  = none,
              turn-on = all.

       -f90=list
              Control specific warnings about supported extensions to the Fortran  77  Standard  that  were  not
              adopted as part of the Fortran 90 Standard.  Default  = none, turn-on = all.

       -f95=list
              Control specific warnings about standard Fortran 77 features that were deleted from the Fortran 95
              Standard.  Default  = none, turn-on = all.

       -help  Print command summary.  Default = no.

       -identifier-chars=list
              Define non-alphanumeric characters that may be used in identifiers.  Default =  turn-on  =  dollar
              sign and underscore.

       -include=path
              Define  a  directory  to  search  for INCLUDE files before searching in the system-wide directory.
              Cumulative.  Default = turn-on = none.

       -intrinsic=list
              Control treatment of nonstandard intrinsic functions.  Default = all except vms for Unix  version,
              all except unix for VMS version, all except unix and vms for other versions.  Turn-on = all.

       -library
              Begin  library  mode:  do  not  warn  about  subprograms  in file that are defined but never used.
              Default = no.

       -list  Print source listing of program.  Default = no.

       -makedcls=list
              Prepare a file of declarations.  The list specifies options for the format of this file.   Default
              = none, turn-on = declarations.

       -mkhtml=list
              Create  individual  HTML document files from ftnchek analysis and code comments.  Usually you will
              also want to specify -call=tree to create the root HTML file CallTree.html.  Default = none, turn-
              on = documents.

       -novice
              Give output suitable for novice users.  Default = yes.

       -output=filename
              Send  output to the given file.  Default and turn-on sends output to the screen. (Default filename
              extension is .lis).

       -pointersize=num
              Set the size of ``Cray pointer'' variables to num bytes.  Min = 1, max = 16.  Default = turn-on  =
              4

       -portability=list
              Warn about non-portable usages.  Default = none, turn-on = all.

       -pretty=list
              Give warnings for possibly misleading appearance of source code.    Default = turn-on = all.

       -project=list
              Create project file (see explanation below).  Default = no.

       -pure  Assume functions are pure, i.e. have no side effects.  Default = yes.

       -quiet Produce less verbose output.  Default = no.

       -reference
              Print table of subprograms referenced by each subprogram.  Default = no.

       -resources
              Print amount of resources used in analyzing the program.  Default = no.

       -sixchar
              List any variable names which clash at 6 characters length.  Default = no.

       -sort  Print list of subprograms sorted in prerequisite order.  Default = no.

       -source=list
              Select  source  formatting options: fixed or free form, DEC Fortran tab-formatted lines, VMS-style
              INCLUDE statement, UNIX-style backslash escape  sequences,  and  implicit  typing  of  parameters.
              Default = none, turn-on = all.

       -style=list
              Produce  extra-picky  warnings  about  obsolescent  or  old-fashioned  programming  constructions.
              Default = none, turn-on = all.

       -symtab
              Print symbol table and label table for each subprogram.  Default = no.

       -truncation=list
              Check for possible loss of accuracy by truncation.  Default = turn-on = all.

       -usage=list
              Control warnings about unused or uninitialized variables, common blocks, etc.  Default = turn-on =
              all.

       -vcg   Produce VCG format of call graph.

       -version
              Print version number.  Default = no.

       -volatile
              Assume  COMMON  blocks  lose  definition  between  activations.   Default  =  no.  (Obsolete.  Use
              -common=volatile instead.)

       -wordsize=num
              Set the default word size for numeric quantities to num bytes.  Default = turn-on = 4 bytes.

       -wrap=num
              Set output column at which to wrap long error messages and warnings to the next line.  If  set  to
              0, turn off wrapping.  Default = turn-on = 79.

       When  more  than one option is used, they should be separated by a blank space, except on systems such as
       VMS where options begin with slash ( / ).  No blank spaces may be placed around the equals sign ( = )  in
       a setting.  ftnchek "?"  will produce a command summary listing all options and settings.

       For  settings  that  take  a  list of keywords, namely -arguments, -array, -calltree, -common, -crossref,
       -f77, -f90, -f95, -intrinsic, -makedcls,  -mkhtml,  -portability,  -pretty,  -project,  -source,  -style,
       -truncation,  and  -usage,  the  list consists of keywords separated by commas or colons.  If the list of
       keywords is omitted, the effect is to set the option to its  turn-on  value  (same  as  ``all''  in  most
       cases).   Also,  if  the list is omitted, the setting name can be prefixed with no or no- to turn off all
       the options it controls.  For example, -f77 turns on all warnings about nonstandard constructions,  while
       -nof77 turns them all off.    Three special keywords are:

       help   Print  out  all  the  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 options. This turns on all options controlled by the setting.

       none   Clear all options.  This turns off all options controlled by the setting.

       These three special keywords must be given in full.  For all other keywords, only as many letters of  the
       keyword  as  are necessary to identify it unambiguously need be given, or a wildcard pattern may be used.
       Including a keyword in the list turns the corresponding option on.   For  example,  -f77=intrinsic  would
       turn on only the warnings about use of nonstandard intrinsic functions.  Prefixing a keyword by no- turns
       its option off.  For example, -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 options 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.  Wildcard
       patterns contain an asterisk to stand for any string of characters.  If a wildcard pattern is  used,  all
       the  warnings  that  match it are affected.  If no- is prefixed to the pattern, all the matching warnings
       are turned off, otherwise they are all turned on.  The minimum unambiguous length rule does not apply  to
       wildcard  matching.     For  example,  use  -usage=no-*var* to turn off all warnings relating to variable
       usage (both local and common).  (Unix users may need to quote any options containing wildcards  in  order
       to  prevent the shell from attempting to expand them.)  Wildcards are recognized only in lists of warning
       keywords, not in the top-level options themselves.

       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 environment options and the preferences file.

       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 for VMS systems, .f for UNIX systems.  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 for the VMS and MS-DOS
       versions, as also of course under UNIX and any other system  that  performs  wildcard  expansion  in  the
       command processor.

       If no filename is given, ftnchek will read input from the standard input.

OPTIONS

       This  section provides a more detailed discussion of ftnchek command-line options.  Options and filenames
       may be interspersed on a command line.  Most options are positional: each option remains in  effect  from
       the  point it is encountered until it is overridden by a later change.  Thus for example, the listing may
       be suppressed for some files and not for others.   Exceptions  are:  the  -intrinsic,  -pointersize,  and
       -wordsize  settings,  which cannot be changed once processing of input files has started; the -arguments,
       -array, -calltree, -common, -crossref,  -extern,  -reference,  -resources,  -sort,  -vcg,  and  -volatile
       options,  where the action depends only on the value of the option after the processing of input files is
       finished; and the -include setting, which is cumulative.

       The option names in the following list are in alphabetical order.

       -arguments=list
              Controls warnings about mismatches between actual and dummy subprogram arguments, and  also  about
              mismatches between expected and actual subprogram type.  (An actual argument is an argument passed
              to the subprogram by the caller; a dummy argument is an argument received by the subprogram.)   By
              default, all warnings are turned on.

              The  list  consists of keywords separated by commas or colons.  Since all these 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 arguments, 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,
              -arguments  is  equivalent  to  -arguments=all, and -noarguments is equivalent to -arguments=none.
              The warning keywords with their meanings are as follows:

              arrayness:
                    warn about inconsistent use of arguments that are arrays.  These  warnings  can  be  further
                    controlled by the -array option.

              type:
                  warn about dummy arguments of a different data type from the actual arguments.

              function-type:
                  warn  if  the  invocation  assumes  the  function's  return  value is a different type than it
                  actually is.  Also warns if a function is called as a subroutine, or vice-versa.

              number:
                  warn about invoking a subprogram with a different number  of  arguments  than  the  subprogram
                  expects.

              For  compatibility  with  previous  versions  of  ftnchek,  a numeric form of this setting is also
              accepted: the list is replaced by a number from 0 to 3.  A value of 0 turns all the warnings  off,
              1 turns on only number, 2 turns on all except number, and 3 turns all the warnings on.

              This setting does not apply to checking invocations of intrinsic functions or statement functions,
              which can only be turned off by the -nocheck option.

              See also: -array, -library, -usage.

       -array=list
              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 legitimately be used by a knowledgeable programmer,  but  that  often  indicate  programming
              errors.  By default, all warnings are turned on.

              The  list  consists of keywords separated by commas or colons.  Since all these 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 array arguments, 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,  -array  is  equivalent  to  -array=all,  and -noarray is equivalent to -array=none.  The
              warning keywords with their meanings are as follows:

              dimensions:
                  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.

              size:
                  warn if both arguments are arrays, but they differ in number of elements.

              For  compatibility  with  previous  versions  of  ftnchek,  a numeric form of this setting is also
              accepted: the list is replaced by a number from 0 to 3.  A value of 0 turns all the warnings  off,
              1 turns on only dimensions, 2 turns on only size, and 3 turns all the warnings on.

              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
              expression  while  the  dummy argument is an array.  These cases are seldom intentional.  (To turn
              off even these warnings, use -arguments=no-arrayness.)  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 dimensioned 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.

       -brief
              Selects  a  shorter format for some warning messages.  At present, the only warnings controlled by
              this flag are those that are printed at the end of  processing  each  subprogram.   These  include
              warnings  about variables that are set but not used or used before set, variable names that do not
              conform to the Fortran 77 standard, etc.  (These warnings may be suppressed entirely depending  on
              other  flags, such as the -usage or -f77 flags.)  In the default format each variable is listed on
              a separate line, along with the line number where the variable is declared, set or used, according
              to  the nature of the warning.  The briefer format simply lists all variables to which the warning
              applies, with up to 4 variables per line.

              See also: -quiet.

       -calltree=list
              Causes ftnchek to print out the call structure of the complete program.

              The list consists of keywords separated by commas or colons.  There are two special keywords: none
              to  turn  off  all  the  options,  and  help  to  print  the list of all the keywords with a brief
              explanation of each.  (The keyword all turns on all the options, but should not normally  be  used
              since  only  one  format  should  be  specified.)   If list is omitted, -calltree is equivalent to
              -calltree=tree, and -nocalltree is equivalent to -calltree=none.  By  default  no  call  graph  is
              printed.

              If  the  -mkhtml  option  is  invoked  and  tree  is  the  applied  calltree  option, a file named
              CallTree.html, will also be produced depicting the tree in HTML format.  This file is useful as  a
              starting point for browsing the HTML files describing each component of the program.

              The keywords which control which format is used are as follows:

              tree:
                  produce the call graph in tree format.

              reference:
                  produce the call graph in who-calls-who format (same as -reference switch).

              vcg:
                  produce the call graph in VCG format (same as -vcg switch).

              Only one of the formats tree, reference, or vcg may be specified.

              The following keywords control options affecting the output:

              prune:
                  prune repeated subtrees (applicable only with tree).  This the default.

              sort:
                  sort children of each routine into alphabetical order.  This is the default.

              See the discussion of the -reference and -vcg flags for details about these formats.

              For  tree format, The call graph 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, use
              option no-prune.

              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
              unless the no-sort option is given.  If multiple main programs are found, the call tree of each is
              printed separately.  If no main program 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.

              For  compatibility  with  previous  versions  of  ftnchek,  a numeric form of this setting is also
              accepted: the list is replaced by a number from 0 to 15.  This number is formed from  1  for  tree
              format, 2 for reference format, or 3 for vcg format, plus 4 for no-prune, and 8 for no-sort.

              See also: -crossref, -library, -reference, -sort, -symtab, -vcg.

       -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 prefix.  Switches and
              settings that specify options and modes  of  operation,  rather  than  controlling  warnings,  are
              unaffected.   These  are  -columns,  -crossref,  -include, -intrinsic, -library, -list, -makedcls,
              -novice, -output, -pointersize, -project, -quiet, -reference, -resources, -sort, -source, -symtab,
              -vcg, -version, -wordsize, and -wrap.  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.

              There are some miscellaneous errors and warning messages that are  not  controlled  by  any  other
              switch,  and  so can be turned off only by this switch.  Note that using -check following -nocheck
              only has the effect of turning these special warnings back on, and does not restore all the checks
              it turned off.  These warnings are:

              o   Module contains no executable statements.

              o   In  free  source  form,  missing  space where space is required (e.g. between a keyword and an
                  identifier) or space present where none is allowed (e.g. within an identifier).

              o   Zero or negative length specification in a data type declaration of the form type*len.

              o   Invalid operand(s) in an expression.

              o   Array assigned to scalar.

              o   Type mismatch between DO index and bounds.

              o   Undefined common block declared in SAVE statement.

              o   Intrinsic function explicitly declared with an incompatible type.

              o   Unknown intrinsic function explicitly declared in an INTRINSIC statement.

              o   Intrinsic function passed as a subprogram argument is not declared in an INTRINSIC statement.

              o   Intrinsic function or statement function invoked incorrectly.

              o   Function does not set return value prior to RETURN statement.

              o   Parameter constant value not evaluated (this is ftnchek's fault, and it is just informing  you
                  of the fact).

              o   Entry point of a subprogram is later used as a different subprogram's name.

              o   Unknown keyword used in an I/O statement.

              o   Illegal  label reference (e.g. GOTO refers to a non-executable statement; I/O statement refers
                  to a non-format statement).

              See also: -errors.

       -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.

              See also: -f77, -pretty.

       -common=list
              This  setting  controls  the  strictness  of  checking of COMMON blocks.  By default, all warnings
              except volatile are turned on.

              The list consists of keywords separated by commas or colons.  Since most of these 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, 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, -common is
              equivalent to -common=dimensions,exact,length,type, and -nocommon is equivalent  to  -common=none.
              The warning keywords with their meanings are as follows:

              dimensions:
                  corresponding  arrays  in  each  declaration  of  a  block  must  agree  in size and number of
                  dimensions.  This option only has an effect when used together with exact.

              exact:
                  the comparison of two  blocks  is  done  variable-by-variable  rather  than  simply  requiring
                  agreement  between  corresponding  storage locations.  Use this if all declarations of a given
                  COMMON block are supposed to be identical, which is a good programming practice.

              length:
                  warn if different declarations of the same block are not equal in total length.   The  Fortran
                  77  Standard  requires each named common block, but not blank common, to be the same length in
                  all modules of the program.

              type:
                  in each declaration of a given COMMON block, corresponding memory locations (words  or  bytes)
                  must  agree  in  data type.  If used together with exact, this will require that corresponding
                  variables agree in data type.

              volatile:
                  Assume that COMMON blocks are volatile.

              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
              program.  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, COMMON 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 running.  Variables and COMMON blocks that can become undefined at some  point  are
              called volatile.

              If  the  -common=volatile  flag  is turned on, ftnchek will warn you if it finds a volatile COMMON
              block.  If, at the same time, the -usage=com-block-volatile  option is turned  on  (which  is  the
              default),  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 -common=volatile flag does not affect the way ftnchek checks the usage of local variables.

              For  compatibility  with  previous  versions  of  ftnchek,  a numeric form of this setting is also
              accepted: the list is replaced by a number from 0 to 3.  A value of 0 turns all the warnings  off,
              1  or  greater  turns  on  type, 2 or greater turns on length, and 3 turns on dimensions and exact
              also.  The numeric form cannot turn on the volatile option.

              See also: -library, -usage.

       -crossref=list
              Prints cross-reference tables.  Default = none.

              The list consists of keywords separated by commas or colons.  The keywords with their meanings are
              as follows:

              calls:
                    table lists each subprogram followed by a list of routines that call it.  This listing omits
                    library modules that  are  not  in  the  call  tree  of  the  main  program.   The  list  is
                    alphabetized.

              common:
                    table  lists  each  COMMON  block  followed by a list of the routines that access it.  These
                    listed routines are those in which some variables in the  COMMON  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.)

              labels:
                    table lists each label followed by a list of all references to it.   A  label  reference  is
                    denoted  by  the line number and statement type of the referring statement.   The label list
                    is in sequential order.  The references are listed in the order they are encountered in  the
                    program.

              See also: -calltree, -reference, -sort, -symtab, -vcg.

       -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.

       -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.

       -errors=num
              Set  the  maximum  number  of  error  messages  in a ``cascade''.  During checking of agreement of
              subprogram arguments, common block declarations, and  so  forth,  sometimes  a  single  case  will
              generate  a  long string of warnings.  Often this simply indicates some other cause than a genuine
              item-by-item mismatch, such as for example a varible missing from one  list.   So  in  such  cases
              ftnchek stops printing the warnings after the cascade limit is reached, and the trailer ``etc...''
              is printed to indicate that there were more errors not printed.  If you think that these  warnings
              are likely to be genuine, use this setting to see more of them.  Turn-on = default = 3, max = 999.
              A value of 0 means no limit.

              This setting does not set an overall limit on the number  of  error  messages  printed,  only  the
              number  printed  in any one cascade.  Most types of warnings and error messages are not subject to
              the cascade effect and so are not affected by this setting.  To turn off warnings  generally,  use
              the individual warning control options or the -nocheck option.

              See also: -check.

       -extern
              Causes  ftnchek  to  report  whether  any  subprograms  invoked  by the program are never defined.
              Ordinarily, if ftnchek is being run  on  a  complete  program,  each  subprogram  other  than  the
              intrinsic functions should be defined somewhere.  Turn off this switch if you just want to check a
              subset of files which form part of a larger complete program.  Subprogram arguments will still  be
              checked for correctness.  Default = yes.

              The  -extern  flag  is  now  superseded  by  the  -usage=ext-undefined  option.   For  the sake of
              convenience,  the   -extern   flag   is   retained,   so   that   -noextern   is   equivalent   to
              -usage=no-ext-undefined option.  The -extern switch may be retired eventually.

              See also: -library.

       -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.  (Further details about the extensions themselves are given below in the  section  on
              Extensions.)   The  list  consists  of  keywords  separated  by commas or colons.  There are three
              special keywords: all to turn on all the warnings about nonstandard extensions, 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.

              array-bounds:
                    Expressions defining array bounds that contain array elements or function references.

              assignment-stmt:
                    Assignment  statements involving arrays.  In Fortran 90, an array can be assigned to another
                    array of compatible shape, or a scalar can be  assigned  to  an  array.   Neither  of  these
                    assignments is permitted in Fortran 77.

                    A  related warning occurs when an array is assigned to a scalar.  Since this is illegal also
                    in Fortran 90, it is always warned about regardless of the -f77 setting (unless all checking
                    is turned off with the -nocheck flag).

              attribute-based-decl:
                    Type declarations in the new Fortran 90 attribute-based style.  This style of declaration is
                    distinguished by the use of a double colon (::) between the list of attributes and the  list
                    of  declared  variables.  This option also controls warnings for use of Fortran 90 length or
                    kind specifiers in type declarations.  (Although  these  specifiers  can  be  used  in  non-
                    attribute-based  declarations,  they are controlled by this option to avoid proliferation of
                    -f77 options.)

              automatic-array:
                    Local (not dummy) arrays which have variable size.  These would correspond to  arrays  whose
                    storage would have to be dynamically allocated at run time.

              backslash:
                    Unix   backslash   escape   in   strings.    This   warning   will  be  given  only  if  the
                    -source=unix-backslash  setting  is  specified  to  cause  the  escape   interpretation   of
                    backslash..

              byte: BYTE data type declaration.

              case-construct:
                    The SELECT CASE construct.

              character:
                    Extensions  to  the  Fortran  77  standard  regarding character data.  At present, this only
                    controls warnings about character variables declared  with  zero  or  negative  length.   In
                    Fortran  77, all character variables must be of positive length.  In Fortran 90, they can be
                    zero length, and declarations that specify negative lengths are permitted, turning into zero
                    for  the  declared  length.   Note:  because  negative  length  specifiers  may  indicate  a
                    programming error, the warning about them is given even if this option is turned off, and is
                    suppressed only by the -nocheck flag.

              common-subprog-name:
                    Common block and subprogram having the same name.

              construct-name:
                    Use of a construct-name to label a control statement.

              continuation:
                    More than 19 successive continuation lines.

              cpp:  Unix C preprocessor directives in the source code.

              cray-pointer:
                    ``Cray pointer'' syntax.

              cycle-exit:
                    The CYCLE and EXIT statements.

              d-comment:
                    Debugging comments starting with D in the source code.

              dec-tab:
                    DEC  Fortran  style  tab-formatted  source  code.   This  warning  will be given only if the
                    -source=dec-tab setting is specified 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 statements.

              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.

              io-keywords
                    Nonstandard keywords used in I/O statements.  These fall into three groups.  The first group
                    includes keywords that are accepted in Fortran 90:

                                                   ACTION    PAD        READWRITE
                                                   ADVANCE   POSITION   SIZE
                                                   DELIM     READ       WRITE
                                                   EOR
                    The second group comprises the following VMS Fortran keywords:

                                           BLOCKSIZE         EXTENDSIZE       READONLY
                                           BUFFERCOUNT       INITIALSIZE      RECORDSIZE
                                           CARRIAGECONTROL   MAXREC           RECORDTYPE
                                           DEFAULTFILE       NAME (in OPEN)   SHARED
                                           DISP              NOSPANBLOCK      TYPE
                                           DISPOSE           ORGANIZATION
                    (The  keyword  NAME is standard only in the INQUIRE statement.)  The third group consists of
                    the following IBM/MVS keyword:

                                                            NUM
                    This flag also controls a warning about use of ACCESS='APPEND', which is  accepted  by  some
                    compilers.  The value of 'APPEND' is not valid for any I/O specifier in standard Fortran 77,
                    and in Fortran 90 'APPEND' should be used as a value of the POSITION specifier, not  ACCESS.

              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-implicit-type:
                    Implicit typing of a parameter by the data type of the value  assigned.   This  warning  can
                    only    occur    if    implicit    parameter    typing   has   been   turned   on   by   the
                    -source=param-implicit-type option, or if the PARAMETER statement is of the nonstandard form
                    without  parentheses.   If  this  option  is  turned  on,  then any instances where implicit
                    parameter typing occurs will be warned about.  If you  want  to  be  warned  only  in  those
                    instances   where   the   implicit   data   type   differs   from   the  default  type,  use
                    -portability=param-implicit-type instead.  According to the Fortran 77  standard,  the  data
                    type  of  a  parameter is given by the same rules as for a variable, and if necessary a type
                    conversion is done when the value is assigned.

              param-intrinsic:
                    Intrinsic function or exponentiation by a real used to  define  the  value  of  a  PARAMETER
                    definition.

              param-noparen:
                    PARAMETER  statement  without  parentheses.   The user should be aware that the semantics of
                    this form of the statement differs from that  of  the  standard  form:  in  this  form,  the
                    parameter  takes  its data type from the value assigned, rather than having its default data
                    type based on the first letter of the parameter name.  (This form of the PARAMETER statement
                    was introduced by DEC before the Fortran 77 standard was defined, and should be avoided.)

              pointer:
                    Fortran  90  standard pointer-related syntax, including POINTER, TARGET and ALLOCATABLE type
                    declarations, ALLOCATE, DEALLOCATE, and NULLIFY statements, and pointer assignment using =>.

              quad-constant:
                    Quad precision real constants, e.g. of the form 1.23Q4.

              quotemark:
                    Strings delimited by quote marks rather than apostrophes.

              relops:
                    Relational (comparison) operators composed of punctuation, namely: < <= == /= > >=.

              semicolon:
                    Semicolon used as statement separator.

              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:
                    Obsolete.  Now has the same meaning as the io-keywords keyword.

              See also: -f90, -f95, -portability, -pretty, -style, -wordsize.

       -f90=list
              This setting provides detailed control over the warnings about supported extensions to the Fortran
              77 Standard that were not adopted as part of the Fortran 90 Standard.  Note that ftnchek does  not
              support  the full Fortran 90 language.  However, it does support some common extensions to Fortran
              77 that were prevalent before Fortran 90 was defined.  Some of these extensions became part of the
              Fortran  90 Standard, but others did not.  The -f90 setting warns only about the latter.  That is,
              this flag covers things that are neither legal Fortran 77 nor legal Fortran  90.   Therefore,  the
              warnings controlled by this flag are basically a subset of the warnings controlled by -f77.  There
              are a few cases, described below, where the circumstances  in  which  the  warning  is  given  are
              slightly different for the two flags.

              The  list  consists  of keywords separated by commas or colons.  There are three special keywords:
              all to turn on all the warnings about nonstandard extensions, 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, -f90
              is equivalent to -f90=all, and -nof90 is equivalent to -f90=none.

              The following keywords have identical meanings for -f90 as for -f77.  The reader  is  referred  to
              the explanations under -f77.

                                     accept-type   double-complex        param-noparen
                                     backslash     format-dollarsign     cray-pointer
                                     byte          format-edit-descr     quad-constant
                                     cpp           function-noparen      type-size
                                     d-comment     name-dollarsign       variable-format
                                     dec-tab       param-implicit-type   vms-io

              The keywords which differ somewhat from the corresponding -f77 keywords are as follows.

              continuation:
                    The  limit  on  the number of continuation lines for a statement in fixed source form is the
                    same, namely 19, in Fortran 90 as in Fortran 77.  For free  source  form  the  limit  is  39
                    continuation  lines,  and a line containing a continuation mark cannot be otherwise empty or
                    contain only a comment.

              intrinsic:
                    This is the same as for -f77 except for the intrinsic functions  defined  in  MIL-STD  1753,
                    which  are  all  included in Fortran 90, and so are not warned about.  (See -intrinsic for a
                    list.)

              io-keywords:
                    This is the same as for -f77 except that no warnings are given for the I/O keywords that are
                    standard in Fortran 90.

              long-line:
                    Although the Fortran 90 Standard allows lines longer than 72 characters in free source form,
                    this restriction still applies to fixed source form.  In free source form  the  line  length
                    limit  is  132  characters,  and  unlike fixed form, ftnchek does not allow this limit to be
                    increased.

              mixed-expr:
                    This is the same as for -f77 except for expressions  mixing  extended  precision  real  with
                    complex data types, which are permitted in Fortran 90.

              statement-order:
                    This  is  similar  to  the  corresponding  -f77  warning,  but  applies  the somewhat looser
                    restrictions on statement order of the Fortran  90  Standard.   In  particular,  Fortran  90
                    allows   DATA   statements   and   statement-function  definitions  to  be  intermixed  with
                    specification statements.

              typeless-constant:
                    In Fortran 90, binary, octal, and hexadecimal constants of  the  form  B'ddd',  O'ddd',  and
                    Z'ddd',  respectively,  are  permitted.   Here 'ddd' represents a string of digits.  ftnchek
                    recognizes these forms, as well as a variant of the form X'ddd' for a hexadecimal  constant,
                    and  other  variants  in  which  the  base indicator B, O, Z, or X follows the digit string.
                    These variants were not adopted in Fortran 90, so only they are warned about when this  flag
                    is turned on.

              See also: -f77, -f95, -portability, -pretty, -style, -wordsize.

       -f95=list
              This  setting provides detailed control over warnings about standard Fortran 77 features that were
              deleted from the Fortran 95 Standard.  Unlike the -f77 and -f90 settings, these warnings apply  to
              syntax  which  is  legal  Fortran  77.   However,  since these features have been deleted from the
              Standard, it is possible that  programs  containing  them  will  be  unacceptable  to  some  newer
              compilers.

              The  list  consists  of keywords separated by commas or colons.  There are three special keywords:
              all to turn on all the warnings about nonstandard extensions, 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, -f95
              is equivalent to -f95=all, and -nof95 is equivalent to -f95=none.  The warning keywords with their
              meanings are as follows.

              real-do:
                    A DO variable of any real numeric type.

              pause:
                    The PAUSE statement.

              assign:
                    The ASSIGN statement, assigned GOTO, or assigned format.

              h-edit:
                    The H edit descriptor in a format.

              There  is one other Fortran 77 syntax feature that was deleted in Fortran 95, namely  branching to
              an ENDIF from outside the IF block.  However, ftnchek is unable to analyze program flow, and so it
              does not provide a warning for this.

              See also: -f77, -f90, -portability, -pretty, -style, -wordsize.

       -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: -novice, -version, and help option of all settings that take a list of keywords.

       -identifier-chars=list
              Define non-alphanumeric characters that may be used in  identifiers.   By  default,  ftnchek  only
              accepts  the  dollar  sign and underscore as non-alphanumeric characters in identifier names.  The
              characters in the list replace whatever set of accepted non-alphanumeric characters was previously
              in  effect.   Thus,  if  dollar  sign  or underscore are not included in the list, they lose their
              status as acceptable characters.

              This option is provided to enable ftnchek to handle source files containing non-standard identifer
              names  that  may  be  needed,  for  example, to access certain operating system services.  See the
              section on Limitations and Extensions for the treatment of identifiers containing these characters
              in implicit typing.

              Using -noidentifer-chars turns off acceptance of non-alphanumeric characters entirely.

              See also: -source.

       -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 system-wide directory (/usr/include for UNIX, SYS$LIBRARY for
              VMS, and \include for MSDOS).

              See also: -f77, -source.

       -intrinsic=list
              Controls whether ftnchek recognizes certain nonstandard intrinsic  functions  as  intrinsic.   The
              list  consists of keywords separated by commas or colons.  Some of the keywords control whether to
              recognize certain groups of functions, and other keywords control the expected syntax for invoking
              some nonstandard intrinsics.  Include a keyword to turn on recognition of the corresponding set of
              intrinsics or to allow the corresponding syntax.  Include a keyword prefixed by no-  to  turn  off
              that recognition.

              There  are  three  special  keywords:  all  turns on recognition of all the nonstandard intrinsics
              (listed below) and accepts either syntax for those that have variations.  Use  none  to  turn  off
              recognition of all nonstandard intrinsics except those noted below.  Use help to print the list of
              all the keywords with a brief explanation of each.  If list is omitted, -intrinsic  is  equivalent
              to -intrinsic=all, and -nointrinsic is equivalent to -intrinsic=none.

              The  nonstandard  intrinsic  functions  needed  to support the nonstandard extended precision data
              types (double complex and quad precision) are always recognized.  The intrinsics  for  the  double
              complex data type are:

                                                CDABS   CDSQRT   DREAL   ZLOG
                                                CDCOS   DCMPLX   IMAG    ZSIN
                                                CDEXP   DCONJG   ZABS    ZSQRT
                                                CDLOG   DIMAG    ZEXP    ZCOS
                                                CDSIN
               The intrinsics for the quad precision and quad complex types are:

                                               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
               The keywords controlling recognition of other nonstandard intrinsic functions are as follows:

              extra:
                    recognize  the  following commonly available nonstandard intrinsics (all except EXIT and LOC
                    are defined in MIL-STD 1753):

                                                   BTEST   IBCLR   IEOR    ISHFTC
                                                   EXIT    IBITS   IOR     LOC
                                                   IAND    IBSET   ISHFT   NOT

              unix: recognize these common Unix-specific intrinsic functions:

                                                 ABORT    GMTIME   LTIME    SRAND
                                                 AND      IARGC    OR       SYSTEM
                                                 GETARG   IRAND    RAND     TIME
                                                 GETENV   LSHIFT   RSHIFT   XOR

              vms:  recognize these common VMS-specific intrinsic functions:

                                                   DATE     IDATE   SECNDS   TIME
                                                   ERRSNS   RAN     SIZEOF

              iargc-no-argument:
                    specify that IARGC may be invoked with no arguments.

              iargc-one-argument:
                    specify that IARGC may be invoked with one argument.

              rand-no-argument:
                    specify that RAND and IRAND may be invoked with no arguments.

              rand-one-argument:
                    specify that RAND and IRAND may be invoked with one argument.

              The no-argument and one-argument keywords work as follows: turning the option on causes ftnchek to
              accept  the corresponding syntax for invocation of the function, without excluding the possibility
              of the alternative syntax.  Turning the option off causes  the  corresponding  syntax  not  to  be
              accepted.   If  both  options are turned on at once (the default), then either syntax is accepted.
              Turning both options off at once would not  be  meaningful.   These  options  have  no  effect  if
              recognition of Unix intrinsics has been turned off.

              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.

              The default value of this setting is equivalent to -intrinsic=all  followed  by  -intrinsic=no-vms
              for  the  Unix  version, -intrinsic=no-unix for the VMS version, and -intrinsic=no-unix,no-vms for
              other versions.

              Note: In versions of ftnchek prior to 2.10, the -intrinsic flag took a numeric argument instead of
              a  list  of  options.  For the sake of users who may have written scripts invoking ftnchek in this
              way, the numeric form is still accepted.  The numeric  form  of  the  setting  consists  of  three
              digits.   The  ones  digit  selects  the  set of intrinsic functions to be supported.  The digit 0
              selects only Fortran 77 standard intrinsics plus those needed to support the nonstandard  extended
              precision data types.  The digit 1 is equivalent to extra, 2 is equivalent to extra,unix, and 3 is
              equivalent to extra,vms.  The tens digit of this setting controls the syntax of the RAND intrinsic
              function,  and  the  hundreds  digit controls the syntax of the IARGC function.  For these digits,
              specify 0 to require invocation with no argument, 1 to require one argument, and 2 to allow either
              form.

              See also: -f77.

       -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.  Normally, 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 declarations are compared for agreement.

              The difference between this switch and the -usage=no-ext-unused option for subprograms is that the
              latter  suppresses  only  the  warning  about  routines being declared but not used.  The -library
              switch goes further 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 constructing 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.

       -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: -output, \fB-symtab, fB-quiet.

       -makedcls=list
              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 declaration 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.

              Various  options  for the form of the declarations file are controlled by the list, which consists
              of keywords separated by commas or colons.  There are three special keywords: all to turn  on  all
              the  options,  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, -makedcls is equivalent to  -makedcls=declarations
              (i.e.  produce  the declarations file using the default options), and -nomakedcls is equivalent to
              -makedcls=none.

              For compatibility with previous versions of ftnchek, a  numeric  form  of  this  setting  is  also
              accepted:   the list is replaced by a number which is the sum of the numbers in parentheses beside
              the keywords in the following list.  The warning keywords with their meanings are as follows:

              declarations (1):
                    Write a declaration file.  (This is implied by any of the other options, and can be  omitted
                    if any other options are given.)

              undeclared-only (2):
                    By  default,  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
                    variables,  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 undeclared.

              compact (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.

              use-continuation-lines (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 together with compact.

              keywords-lowercase (16):
                    Output Fortran keywords in lowercase, instead of the default uppercase.

              vars-and-consts-lowercase (32):
                    Output variables and constants in lowercase, instead of the default  uppercase.    Character
                    string constants are not affected by this option.

              exclude-sftran3 (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 letter, N.

              asterisk-comment (128):
                    Use an asterisk as the comment character; the default is otherwise 'C'.

              comment-char-lowercase (256):
                    Use 'c' instead of 'C' or '*' as the comment character.

              suppress-array-dimensions (512):
                    Suppress  dimensioning of arrays in the generated declarations.  This option is for use with
                    code lacking type declarations, 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 dimensioned in a type statement will lose their dimensioning.

              free-form (1024):
                    Produce declarations in free source form.  This mode is  automatically  used  if  the  input
                    source is free form.  Use this option to produce declarations in free form even if the input
                    is in fixed form.  Free form declarations are indented only 2 columns instead of 6, use  the
                    exclamation  mark  as the comment character, and indicate continuation lines by an ampersand
                    at the end of the line to be continued.

              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 processes declaration files to produce
              files  containing  declarations of all COMMON blocks, in a form suitable for use as INCLUDE files.
              See the dcl2inc(1L) man page for the details of its use.

              See also: -mkhtml.

       -mkhtml=list
              Produce HTML documentation from source. Creates individual HTML files from  ftnchek  analysis  and
              code  comments.  All  comments  immediately  preceding  and  following  the function or subroutine
              definition are captured to the HTML file. No reformatting of source comments  is  performed  other
              than  stripping  of  FORTRAN  comment  characters.   In  addition,  the  HTML file lists the local
              variables declared, common block variables used, functions and subroutines called, I/O unit usage,
              and  other information about each subprogram.  Usually you will also want to specify -call=tree to
              create the root HTML file CallTree.html.  (Perhaps this file should be named index.html.)

              Various options for the form of the HTML files are controlled  by  the  list,  which  consists  of
              keywords  separated by commas or colons.  There are three special keywords: all to turn on all the
              options, 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, -mkhtml is equivalent to -mkhtml=documents (i.e. produce
              the HTML document files using the default options), and -nomkhtmls is equivalent to -mkhtml=none.

              For the sake of simplicity, the options for -mkhtml are the same as those for -makedcls except for
              those that are inapplicable.  Likewise,  a numeric form of this setting can be used, formed as the
              sum of the numbers in parentheses in the list below.  The warning keywords with their meanings are
              as follows:

              documents (1):
                    Create the HTML documents.  (This is implied by any of the other options, and can be omitted
                    if any other options are given.)

              compact (4):
                    The declarations are normally prettyprinted to line  up  neatly  in  common  columns.   This
                    option value selects instead compact output, without column alignment.

              use-continuation-lines (8):
                    Causes  continuation  lines  to be used instead of beginning a new declaration on each line.
                    This option is appropriate to use together with compact.

              keywords-lowercase (16):
                    Output Fortran keywords in lowercase, instead of the default uppercase.

              vars-and-consts-lowercase (32):
                    Output variables and constants in lowercase, instead of the default  uppercase.    Character
                    string constants are not affected by this option.

              exclude-sftran3 (64):
                    Omit  declarations  of  internal  integer  variables  produced  by the SFTRAN3 preprocessor,
                    xsf3(1L).  (See -makedcls for discussion.)

              suppress-array-dimensions (512):
                    Suppress  dimensioning  of  arrays  in  the  generated  declarations.   This   is   normally
                    undesirable,  but  is  available  if for some reason you do not want the array dimensions to
                    appear in the HTML.

              free-form (1024):
                    Produce variable declarations in free source form.  This mode is automatically used  if  the
                    input  source  is free form.  This mainly affects the form of continuation lines if they are
                    used.

              See also: -calltree, -makedcls.

       -novice
              This flag is intended to provide more helpful output for beginners.  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.

       -output=filename
              This  setting is provided for convenience on systems which do not allow easy redirection of output
              from programs.  When this setting 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.

       -pointersize=num
              Specifies the size of a ``Cray pointer'' variable to be num bytes.  Default = turn-on = 4 bytes.

              The  pointer  size  is used to inform precision mismatch warnings involving pointer variables, for
              example when a pointer is assigned a value from an allocation routine, or passed as  a  subprogram
              parameter.

              See also: -f77, -portability, -truncation, -wordsize.

       -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 separated 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 -portability=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 specifications).  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, assignments, 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.

              param-implicit-type:
                    Implicit  typing  of  a parameter by the data type of the value assigned, if it differs from
                    the default type.  This warning can only occur if implicit parameter typing has been  turned
                    on  by  the  -source=param-implicit-type  option,  or  if  the PARAMETER statement is of the
                    nonstandard form without parentheses.  If this option is turned on, then any instances where
                    implicit  parameter  typing occurs and where the implicit type is different from the default
                    type based on the first letter of the  parameter  name,  will  be  warned  about.   Implicit
                    parameter typing can change the semantics of statements where the parameter is used, causing
                    portability problems.

              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, -f90, -f95, -pretty, -style, -wordsize.

       -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
              prefixed  by  no- to turn off a particular warning.  There are three special 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 omitted, -pretty is
              equivalent to -pretty=all, and -nopretty is equivalent to -pretty=none.  The warning keywords with
              their meanings are as follows:

              alternate-return:
                    A RETURN statement has a constant specifying an alternate return point that is not between 0
                    and the number of dummy arguments that are labels.  This is legal, and has the  same  effect
                    as  a  RETURN with no alternate return expression, but suggests that the programmer intended
                    to use an alternate return label that is not provided.

              embedded-space:
                    Space embedded in variable names or in multi-character operators such as **.

              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 keyword.

              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 subprogram argument, this makes the argument
                    an expression, not modifiable by the subprogram.

              Note that in free source form, extra space and missing space  are  forbidden  by  the  Fortran  90
              Standard,  and  are  not  mere style violations.  In this case the warnings are replaced by syntax
              error messages, and can be turned off only by using -nocheck.

              See also: -f77, -portability, -style.

       -project=list
              ftnchek will create a project file from each source file that is input while this option is turned
              on.   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 = none.

              The  list  consists  of keywords separated by commas or colons.  There are three special keywords:
              all to turn on all the options, 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, -project is equivalent to
              -project=all, and -noproject is equivalent to -project=none.  The keywords with their meanings are
              as follows:

              create:
                    Produce  a  project  file.  The default is not to produce a project file.  If this option is
                    not turned on, the other options have no effect.

              trim-calls:
                    Trim the amount of information stored in the project file about subprogram declarations  and
                    calls.  This is the default.  Turn this option off only in rare situations.  (See discussion
                    below.)  The amount of trimming varies depending on the -library flag.  More information  is
                    trimmed if that flag is turned on.

              trim-common:
                    Trim  the  number  of  common  block  declarations  stored in the project file.  This is the
                    default.  Turn this option off only in  rare  situations.   (See  discussion  below.)   This
                    option  has  no  effect  if  the  -library  flag is turned off: when not in library mode, no
                    trimming of common block declarations is done regardless of this option.

              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 option is turned on, ftnchek will not read project files as input.

              Ordinarily,  the trim options should be left on when you intend to create project files for future
              input to ftnchek.  Since trimming is on by default, this means  that  simply  giving  the  command
              -project  with  no  option  list is the recommended mode.  The trim options are provided only as a
              convenience for those who want to make use of project files for purposes other than  checking  the
              program  with  ftnchek.   To use project files for their intended purpose, the trim options should
              not be turned off.

              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 Project Files.

       -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 functions will be handled the same way as
              actual arguments passed to subroutines.  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.

       -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.   It  also  eliminates some blank lines that are ordinarily
              included for clarity. (Some of this output is turned back on by the -list  and  -symtab  options.)
              Default = no.

              Note:  the  way  to  remember the difference  between the -quiet and -brief is that -quiet doesn't
              suppress any warning-related information, whereas -brief does.

              See also: -brief.

       -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=reference.  Default = no.

              The  reference  list  omits  routines called by unused library modules.  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=tree prints out a depth-first traversal.

              See also: -calltree, -crossref, -library, -sort, -symtab, -vcg.

       -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  particular  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 separate 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.

              Total statement labels defined
                  Number of labels attached to statements (often called statement  numbers).   The  total  label
                  count for the entire program is given, as well as the maximum number in any single subprogram.

              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 not recovered at the end of each
                  module, so this number, like  global  space,  grows  until  the  whole  program  is  analyzed.
                  Unfortunately,  this  figure may include some text 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 constant, 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  recovered
                  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 functions 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
                  subprogram,  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 complexity 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
                  declaration 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 multidimensional 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.

       -sixchar
              One of the goals of the ftnchek program is to help users to write portable Fortran programs.   One
              potential  source  of  nonportability  is  the  use  of  variable  names  that are longer than six
              characters.  Some compilers just ignore the extra characters.   This  behavior  could  potentially
              lead  to  two  different  variables  being  considered 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.

       -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.

       -source=list
              This  setting  controls  certain  options  about  the  form  of the Fortran source code.  The list
              consists of keywords separated by commas or colons.  There are three special keywords: all to turn
              on all the options, 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,  -source  is  equivalent  to  -source=all,  and
              -nosource is equivalent to -source=none.

              For  compatibility  with  previous  versions  of  ftnchek,  a numeric form of this setting is also
              accepted:  the list is replaced by a number which is the sum of the numbers in parentheses  beside
              the keywords in the following list.  (The fixed and free options do not have numeric values.)  The
              warning keywords with their meanings are as follows:

              fixed:
                    Interpret the source as fixed form (with supported extensions such as exclamation  mark  for
                    comments).  Statements must be in columns 7 to 72 (unless the -cols setting has been used to
                    change this), and blanks are not significant outside character  context  (but  warned  about
                    under  the  -pretty  option).   This is the default mode unless the source file extension is
                    .f90 or .F90.  this option cannot be given together with -source=free.

              free: Interpret the source as free form.  Statements may be anywhere in columns 1 to 132, comments
                    can  only  begin  with  an  exclamation mark, and blanks are required in some places such as
                    between identifiers and keywords.  This is the default mode if the source file extension  is
                    .f90 or .F90.  This option cannot be given together with -source=fixed or -source=dec-tab

              dec-tab (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.

              vms-include (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.

              unix-backslash (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
                    newline) signifies the character itself.  When this source  code  option  is  in  effect,  a
                    warning will be given if the -f77=backslash 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  compilers  treat  the  backslash  in a nonstandard way, it is possible for
                    standard-conforming programs to be non-portable if  they  use  the  backslash  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 backslash to embed an apostrophe or quote mark in a string instead of using the
                    standard mechanism of doubling the delimiter; (b) the backslash 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.

              param-implicit-type (8):
                    Implicit  typing  of  a parameter by the data type of the value assigned.  Some non-standard
                    compilers may allow the data type of the value to override the Fortran 77 default type of  a
                    parameter that is based on the first letter of the parameter name.  This option only applies
                    to PARAMETER statements of the standard form which has parentheses.  A  parameter  that  has
                    been  explicitly  declared  in  a  type  statement  prior  to the PARAMETER statement is not
                    affected by this option.  A warning will be  given  under  the  -f77=param-implicit-type  or
                    -portability=param-implicit-type option.

                    Note  that this implicit typing is treated as equivalent to an explicit type declaration for
                    the parameter.  Therefore, if you use  -makedcls=undeclared-only  to  generate  declarations
                    only of undeclared variables, these parameters will not be included.

              dec-param-standard-type (16):
                    Follow  the  Fortran  77  rule  for  data typing of DEC Fortran style parameters.  These are
                    declared using a nonstandard form  of  the  PARAMETER  statement  which  lacks  parentheses.
                    According  to  DEC Fortran, parameters defined by this form of the statement have their data
                    type given by the data type of the value assigned.  Use this option to tell ftnchek  not  to
                    follow  this  rule  but  instead  to use the same rule as for standard PARAMETER statements.
                    This option does not apply to PARAMETER statements of the standard form.

              By default, all these source code options are turned off, except for the vms-include option, which
              is on by default in the VMS version..

              See also: -f77, -include, -portability.

       -style=list
              Provides  extra-picky warnings about obsolescent or old-fashioned programming constructions.  This
              option is helpful for efforts  to  follow  a  modern  programming  style.   (Most  of  the  things
              complained  about  under  this  option  are  forbidden in the F subset language.)  By default, all
              warnings are turned off.

              The list consists of keywords separated by commas or colons.  There are  three  special  keywords:
              all  to  turn on all the options, 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,  -style  is  equivalent  to
              -style=all,  and  -nostyle is equivalent to -style=none.  The warning keywords with their meanings
              are as follows:

              block-if:
                    Complain about arithmetic IF statement.  Accept block IF or logical  IF  (which  controls  a
                    single statement).

              construct-name:
                    Complain  about unnamed block constructs: IF, DO, and SELECT CASE.  Note that if a construct
                    name is present on the opening statement of a construct, then it is required to  be  present
                    on  all  other  component  statements (ELSE, END IF, etc.) of the construct.  In that case a
                    missing construct name on those statements generates  a  syntax  error  regardless  of  this
                    option.   The  purpose  of  this  option  is  to  warn if the construct completely lacks the
                    optional name.

              distinct-do:
                    Complain if two DO loops share a common terminator statement.

              do-construct:
                    Complain if terminator of a DO loop is anything other than an END DO or CONTINUE  statement.
                    This  is  the  requirement  in order for the loop to meet the Fortran 90 definition of a do-
                    construct.

              do-enddo:
                    Complain if terminator of a DO loop is anything other  than  an  END  DO  statement.   (This
                    option overrides the do-construct option, being even stricter.)

              end-name:
                    Complain about the absence of the subprogram name on structured END statements.

              format-stmt:
                    Complain about the presence of FORMAT statements.  Only the FORMAT statements themselves are
                    flagged, not the references to them in I/O lists.

              goto: Complain about the presence of unconditional, computed or assigned  GOTO  statements.   Also
                    complain about alternate returns (but not about labels as subprogram arguments).

              labeled-stmt:
                    Complain  about the presence of labels (numbers) on statements other than FORMAT statements.
                    (Since FORMAT statements are arguably convenient and not readily  abused,  complaints  about
                    them are controlled by the separate format-stmt keyword.)

              program-stmt:
                    Complain about the absence of a PROGRAM statement at the head of the main program.

              structured-end:
                    Complain  about  the  use  of  a  plain  END  statement  to  end a subprogram, rather than a
                    structured END statement (END PROGRAM, END SUBROUTINE, END FUNCTION, or END BLOCK DATA).

              See also: -f77, -f90, -f95, -pretty, -portability.

       -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 statement.  The table also lists all subprograms
              invoked by the module, all COMMON blocks declared, etc.  Default = no.

              Also, for each module, a label table will be printed.  The table lists each label defined  in  the
              module;  the  line  on  which said statement label is defined; and the statement type (executable,
              format, or specification).  The labels are listed in sequential order.

              Also printed is a table describing the I/O units used by the  module,  together  with  information
              about  how  they  are  used:  what  operations  are performed, whether the access is sequential or
              direct, and whether the I/O is formatted or unformatted.

              See also: -calltree, -crossref, -list, -reference, -sort, -vcg.

       -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 truncation, 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 variables in this process is comparable to the corresponding demotion.  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 integer 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.   A
                    warning  is  also  issued if a long integer is assigned to a shorter one, for example, if an
                    INTEGER expression is assigned to an INTEGER*2 variable.  There is  one  exception  to  this
                    last case, namely if the right hand side of the assignment is a small literal constant (less
                    than 128).  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 imaginary 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 functions such as INT are used to perform  the  conversion,
              no warning is given.

              See also: -portability, -wordsize.

       -usage=list
              Warn  about  unused or possible uninitialized variables, unused common blocks, undefined or unused
              statement labels, and unused or undefined subprograms.  By default, all warnings are turned on.

              This setting provides detailed control over the warnings about possible usage  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 usage, 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, -usage  is  equivalent  to
              -usage=all,  and -nousage is equivalent to -usage=none.  These warnings cover four main categories
              of objects: subprogram dummy arguments, common blocks and variables,  subprograms  and  functions,
              and local variables.  Warnings include undefined items, multiply defined items, unused items, etc.
              The warning keywords with their meanings are as follows:

              arg-alias:
                    a scalar dummy argument is actually the same as another and is (or may  be)  modified.   The
                    Fortran  77  standard  (section 15.9.3.6) prohibits modifying an argument that is aliased to
                    another.

              arg-array-alias:
                    a dummy argument which is an array or array element is in the same array as another  and  is
                    modified.   This  flag  is  similar  to  arg-alias  but provides separate control over array
                    arguments.  It is harder to tell if aliasing is occurring in  the  case  of  arrays,  so  if
                    ftnchek  gives too many false warnings, this flag allows the array-related ones to be turned
                    off without suppressing the warnings for scalars.

              arg-common-alias:
                    a scalar dummy argument is the same as a common variable in the subprogram,  and  either  is
                    modified.   This  is  also prohibited by the Fortran 77 standard.  If common checking is not
                    exact (see the -common setting), it is harder to tell  if  aliasing  is  occurring,  so  the
                    warning  is  given  if  the  variable  is anywhere in a common block that is declared by the
                    subprogram.

              arg-common-array-alias:
                    a dummy argument which is an array or array element  is  in  the  same  array  as  a  common
                    variable,  and  either  is  modified.   If common checking is not exact, the variable can be
                    anywhere in a common block that is declared by the subprogram.

              arg-const-modified:
                    a subprogram modifies an argument which is a constant or  an  expression.   Such  an  action
                    could cause anomalous behavior of the program.

              arg-unused:
                    a  dummy  argument  is  declared  but never used.  This is similar to the var-unused keyword
                    described below, but applies only to arguments.

              com-block-unused:
                    a common block is declared but none of the variables in it are used by any subprogram.  This
                    warning is suppressed if the common strictness setting is 0.

              com-block-volatile:
                    a  common block may lose the definition of its contents if common blocks are volatile.  This
                    option only has an effect if the -common=volatile flag is in effect.  See the discussion  of
                    the -common setting above.

              com-var-set-unused:
                    a  common  variable  is assigned a value, but its value is not used by any subprogram.  This
                    warning is suppressed if the common strictness setting is 0.

              com-var-uninitialized:
                    a  common  variable's  value  is  used  in  some  subprogram,  but  is  not  set   anywhere.
                    Unfortunately,  ftnchek  does  not  do a thorough enough analysis of the calling sequence to
                    know which routines are called before others.  So warnings 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).   This  warning  is suppressed if the common strictness
                    setting is 0.

              com-var-unused:
                    a common variable is declared but not used by any subprogram.  This warning is suppressed if
                    the common strictness setting is 0.

              do-index-modified:
                    a  variable that is the index of a DO loop is modified by some statement within the range of
                    the loop.  The  Standard  permits  an  active  DO  variable  to  be  modified  only  by  the
                    incrementation mechanism of the DO statement.

              ext-multiply-defined:
                    an external (a subroutine or function) is defined more than once.  Definition of an external
                    means providing the body of its source code.

              ext-declared-only:
                    a name is declared in an EXTERNAL statement in some module,  but  is  not  defined  or  used
                    anywhere.

              ext-undefined:
                    an  external  is  used (invoked) but not defined anywhere.  This option is equivalent to the
                    -external flag.  If the subprogram is invoked more than once, those invocations  will  still
                    be checked for consistency.

              ext-unused:
                    an external is defined (its subprogram body is present) but it is not used.  A subprogram is
                    considered unused even if it is invoked by some other subprogram, if  it  cannot  be  called
                    from  any  thread  of  execution  starting  with  the  main  program.   The agreement of the
                    subprogram's arguments with its invocations is still checked even if this warning is  turned
                    off.  If there is no main program, then this warning is issued only if the subprogram is not
                    invoked anywhere.  This warning is suppressed in library mode,  but  library  mode  has  the
                    additional effect of suppressing argument checking for unused routines.

              label-undefined:
                    a statement refers to a label that has not been defined.

              label-unused:
                    a statement label is defined, but never referred to.

              var-set-unused:
                    a local variable is assigned a value, but that value is not used.

              var-uninitialized:
                    a  local  variable's  value  may  be  used before it is assigned.  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.

              var-unused:
                    a  local  variable  is declared (for instance, in a type declaration) but is not used in the
                    module.  Does not apply to dummy arguments:  warnings  about  them  are  controlled  by  the
                    keyword arg-unused described above.

              Note:  In  versions of ftnchek prior to 2.10, the -usage flag took a numeric argument instead of a
              list of options.  For the sake of users who may have written scripts invoking ftnchek in this way,
              the  numeric  form is still accepted.  The numeric setting is composed of three digits.  The first
              digit (hundreds place) controls warnings about subprograms (functions and subroutines), 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  convention
              that  a  1 means warn about undefined items and variables that are used before set, a 2 means warn
              about items that are unused, and a 3 means warn about both types.  These numbers are now converted
              to  the  appropriate values for the above-listed keywords, except for com-block-volatile, which is
              not affected by the numeric argument.

              See also: -common, -declare, -extern, -library.

       -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=vcg.  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 of Cranfield University, 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.

              See also: -calltree, -crossref, -reference, -sort.

       -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 version information printed at
              the start of processing.  Default = no.

              See also: -help.

       -volatile
              Assume that COMMON blocks are volatile.  Default = no.

              This flag is superseded by -common=volatile, and should no longer be used.  It may  be  eliminated
              in a future release of ftnchek.

              See also: -common, -usage.

       -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-conforming programs that do not declare
              explicit precisions for non-character variables  or  store  Hollerith  data  in  variables.   This
              setting  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  subprogram  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 promotion options, a warning is given for assignment
              of  an  expression  to  a shorter variable of the same type, or for promotion of a lower precision
              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  specifying  -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: -pointersize, -portability, -truncation.

       -wrap=col
              Controls  the  wrapping  of error messages.  Long error messages that would run past the specified
              column will be broken up into  separate  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.

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 environment 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  environment  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  example, to make ftnchek print a source listing by default, set the environment
       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.

       Here  are  some examples of how to set environment variables on various systems.  For simplicity, all the
       examples set the default -list switch to YES.

       1. UNIX, Bourne shell:        $ FTNCHEK_LIST=YES
                                     $ export FTNCHEK_LIST

       2. UNIX, C shell:             % setenv FTNCHEK_LIST YES

       3. VAX/VMS:                   $ DEFINE FTNCHEK_LIST YES

       4. MSDOS:                     $ SET FTNCHEK_LIST=YES

       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 separate line.  They are given  in  the  same
       form  as  on  the  command line, except without the initial dash.  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 environment or in the preferences file, in  the
       same way as they override the built-in defaults.

USING PROJECT FILES

       This section contains detailed information on how to use project files most effectively, and how to avoid
       some pitfalls.

       One  can  divide  the  checks  ftnchek  does  into  two  categories, local and global.  Local checking is
       restricted to within a single routine, and catches things like uninitialized variables,  unintended  loss
       of  precision  in  arithmetic  expressions,  etc.   This  sort of checking can be done on each subprogram
       independently.  Furthermore, local checking of a subprogram does not need to be repeated when some  other
       subprogram  is changed.  Global checking catches things like calling a subroutine with the wrong argument
       types, or disagreeing in common block declarations.  It requires looking at the whole set of  subprograms
       interacting with each other.

       The  purpose  of  project files is to allow the local checking and global checking steps to be separated.
       Assuming that each subprogram is in its own source file, you can run ftnchek once on each one to do local
       checking  while  suppressing  global  checking.   Then  ftnchek  can be run once on all the project files
       together to do the global checking.  The sample makefile below shows how  to  automate  this  task.   The
       ``.f.prj''  target  updates  a  project file for a particular file any time the source file changes.  The
       information needed for global checking is saved in the project  file.   The  ``check''  target  does  the
       combined  global  checking.   Typically ``make check'' would repeat the ``ftnchek -project'' step only on
       changed source files, then do the global check.  This is obviously a big advantage  for  large  programs,
       when many subprograms seldom if ever change.

       It  is  best when using project files to place each subprogram in a separate source file.  If each source
       file may contain more than one subprogram,  it complicates the definition  of  ``local''  and  ``global''
       checking  because  there is some inter-module checking that is contained within a file.  ftnchek tries to
       do the right thing in this case, but there are some complications (described below) due to the  trade-off
       between avoiding re-doing cross-checks and preserving information about the program's structure.

       Ordinarily, to do the least amount of re-checking, project files should be created with the -library flag
       in effect and trimming turned on.  In this mode, the information saved in the project  file  consists  of
       all  subprogram  declarations,  all subprogram invocations 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  source file contains more than one routine, there are some possible 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 -usage checking is turned on (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 project 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 project 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.

       The foregoing discussion assumes that the trimming options of the -project setting are turned on when the
       project  file is created.  This is the normal situation.  The no-trim options of the -project setting are
       provided in case one wants to use the project files for purposes other than  checking  the  program  with
       ftnchek.   For instance, one could write a Perl script to analyze the project files for information about
       how the different subprograms are called.  You should not use the no-trim options to deal with the issues
       of information loss discussed above, since they cause more information than necessary to be stored.  This
       makes the project files bigger and causes ftnchek to do more work later when it reads them to check  your
       complete  program.   Ordinarily,  you  should  use the -library option to control how much information to
       store for later use by ftnchek in checking your program.

       Here is an example of how to use the UNIX make utility to automatically create a new  project  file  each
       time  the corresponding source file is altered, and to check the set of files for consistency.  Add these
       lines to your makefile.  The example assumes that a macro OBJS has been defined which lists all the names
       of  object  files  to be linked together to form the complete executable program.  (In this makefile, the
       indented lines should each begin with a tab, not blanks.)  If any source file contains multiple  routines
       that  share  common  blocks  among themselves, then the no-com-\* option should be removed from NOGLOBAL,
       and/or drop the -library flag.
           # tell make what a project file suffix is
           .SUFFIXES: .prj

           # these options suppress global checks.
           NOGLOBAL=-usage=no-ext-undefined,no-com-\*

           # tell make how to create a .prj file from a .f file
           .f.prj:
                   ftnchek -project $(NOGLOBAL) -library $<

           # set up macro PRJS containing project filenames
           PRJS= $(OBJS:.o=.prj)

           # "make check" will check everything that has been changed.
           check: $(PRJS)
                   ftnchek $(PRJS)

       When a program uses many routines defined in a large  number  of  different  source  files  in  different
       directories,  it can be cumbersome to specify all the different project files needed to check the program
       properly.  To deal with such cases, ftnchek allows project files to be concatenated into a  single  large
       file.   This  single file can then be given to ftnchek to provide the information for checking the use of
       any or all of the routines defined in the combined project files.  When using such a ``library''  project
       file,  you may want ftnchek's error reports to document precisely the name of the file where the specific
       function is defined.  If the various source files are in several directories, an error report that  gives
       only  the file name may be ambiguous, and rather should include the path to the file.  The solution is to
       create each of the individual project files by giving the complete path to the source  file.   Then  this
       complete  path will appear in the error reports.  For example, suppose that all of the library subprogram
       source files are in subdirectories of a directory named /util/lib.  Then  the  individual  project  files
       could first be created by a command such as
       find /util/lib -name '*.f' -exec ftnchek -project '{}' ';'
       (Possibly  other  options  would  be  provided  to  ftnchek as discussed above.  Also, this step could be
       handled instead by a revised makefile rule that would provide the complete source file  path  instead  of
       just the local name when invoking ftnchek.)  Next, concatenate all of these project files manually.
       find /util/lib -name '*.prj' -exec cat '{}' ';' > ourlib.prj
       Then a program source file can be checked by using the command
       ftnchek prog.f ... -lib ourlib.prj
       and  an  error  message related to any library routine will include the full path to the routine's source
       file.

       At present, there is no archive utility like ar to manage the contents of  a  concatenated  project  file
       like the one in the illustration above.  If changes are made to one of the library routines, the only way
       to update the combined project file is to concatenate all the individual project files once again.   Such
       a utility would be quite easy to write.  Someone should do so and contribute it to the ftnchek effort.

AN EXAMPLE

       The  following simple Fortran program illustrates the messages given by ftnchek.  The program is intended
       to accept an array of test scores and then compute the average for the series.

       C       AUTHORS: MIKE MYERS AND LUCIA SPAGNUOLO
       C       DATE:    MAY 8, 1989

       C       Variables:
       C               SCORE -> an array of test scores
       C               SUM ->   sum of the test scores
       C               COUNT -> counter of scores read in
       C               I ->     loop counter

               REAL FUNCTION COMPAV(SCORE,COUNT)
                   INTEGER SUM,COUNT,J,SCORE(5)

                   DO 30 I = 1,COUNT
                       SUM = SUM + SCORE(I)
       30          CONTINUE
                   COMPAV = SUM/COUNT
               END

               PROGRAM AVENUM
       C
       C                       MAIN PROGRAM
       C
       C       AUTHOR:   LOIS BIGBIE
       C       DATE:     MAY 15, 1990
       C
       C       Variables:
       C               MAXNOS -> maximum number of input values
       C               NUMS    -> an array of numbers
       C               COUNT   -> exact number of input values
       C               AVG     -> average returned by COMPAV
       C               I       -> loop counter
       C

                   PARAMETER(MAXNOS=5)
                   INTEGER I, COUNT
                   REAL NUMS(MAXNOS), AVG
                   COUNT = 0
                   DO 80 I = 1,MAXNOS
                       READ (5,*,END=100) NUMS(I)
                       COUNT = COUNT + 1
       80          CONTINUE
       100         AVG = COMPAV(NUMS, COUNT)
               END

       The compiler gives no error messages when this program is compiled.  Yet here is what happens when it  is
       run:

       $ run average
       70
       90
       85
       <EOF>
       $

       What  happened?  Why didn't the program do anything?  The following is the output from ftnchek when it is
       used to debug the above program:

       $ ftnchek -list -symtab average

       FTNCHEK Version 3.3 November 2004

       File average.f:

             1 C       AUTHORS: MIKE MYERS AND LUCIA SPAGNUOLO
             2 C       DATE:    MAY 8, 1989
             3
             4 C       Variables:
             5 C               SCORE -> an array of test scores
             6 C               SUM ->   sum of the test scores
             7 C               COUNT -> counter of scores read in
             8 C               I ->     loop counter
             9
            10         REAL FUNCTION COMPAV(SCORE,COUNT)
            11             INTEGER SUM,COUNT,J,SCORE(5)
            12
            13             DO 30 I = 1,COUNT
            14                 SUM = SUM + SCORE(I)
            15 30          CONTINUE
            16             COMPAV = SUM/COUNT
                                  ^
       Warning near line 16 col 20: integer quotient expr SUM/COUNT  converted to
        real
            17         END

       Module COMPAV: func: real

       Variables:

             Name Type Dims     Name Type Dims     Name Type Dims     Name Type Dims
           COMPAV real         COUNT intg             I intg*            J intg
            SCORE intg  1        SUM intg

       * Variable not declared. Type has been implicitly defined.

       Warning in module COMPAV: Variables declared but never referenced:
           J declared at line 11

       Warning in module COMPAV: Variables may be used before set:
           SUM used at line 14
           SUM set at line 14

       Statement labels defined:

           Label   Line  StmtType
            <30>     15      exec

            18
            19
            20         PROGRAM AVENUM
            21 C
            22 C                       MAIN PROGRAM
            23 C
            24 C       AUTHOR:   LOIS BIGBIE
            25 C       DATE:     MAY 15, 1990
            26 C
            27 C       Variables:
            28 C               MAXNOS -> maximum number of input values
            29 C               NUMS    -> an array of numbers
            30 C               COUNT   -> exact number of input values
            31 C               AVG     -> average returned by COMPAV
            32 C               I       -> loop counter
            33 C
            34
            35             PARAMETER(MAXNOS=5)
            36             INTEGER I, COUNT
            37             REAL NUMS(MAXNOS), AVG
            38             COUNT = 0
            39             DO 80 I = 1,MAXNOS
            40                 READ (5,*,END=100) NUMS(I)
            41                 COUNT = COUNT + 1
            42 80          CONTINUE
            43 100         AVG = COMPAV(NUMS, COUNT)
            44         END

       Module AVENUM: prog

       External subprograms referenced:

           COMPAV: real*

       Variables:

             Name Type Dims     Name Type Dims     Name Type Dims     Name Type Dims
              AVG real         COUNT intg             I intg        MAXNOS intg*
             NUMS real  1

       * Variable not declared. Type has been implicitly defined.

       Warning in module AVENUM: Variables set but never used:
           AVG set at line 43

       I/O Operations:

            Unit ID Unit No. Access Form Operation   Line
                    5          SEQ  FMTD READ         40

       Statement labels defined:

           Label   Line  StmtType    Label   Line  StmtType
            <80>     42      exec    <100>     43      exec

        0 syntax errors detected in file average.f
        6 warnings issued in file average.f

       Warning: Subprogram COMPAV argument data type mismatch at position 1:
           Dummy arg SCORE in module COMPAV line 10 file average.f is type intg
           Actual arg NUMS in module AVENUM line 43 file average.f is type real

       According to ftnchek, the program contains variables which may  be  used  before  they  are  assigned  an
       initial  value, and variables which are not needed.  ftnchek also warns the user that an integer quotient
       has been converted to a real. This may assist the user in catching an unintended roundoff  error.   Since
       the  -symtab  flag was given, ftnchek prints out a table containing identifiers from the local module and
       their corresponding datatype and number of dimensions.  Finally, ftnchek warns that the  function  COMPAV
       is not used with the proper type of arguments.

       With ftnchek's help, we can debug the program.  We can see that there were the following errors:

       1.  SUM and COUNT should have been converted to real before doing the division.

       2.  SUM should have been initialized to 0 before entering the loop.

       3.  AVG was never printed out after being calculated.

       4.  NUMS should have been declared INTEGER instead of REAL.

       We  also  see  that  I, not J, should have been declared INTEGER in function COMPAV. Also, MAXNOS was not
       declared as INTEGER, nor COMPAV as REAL, in program AVENUM.  These are not errors, but they may  indicate
       carelessness.  As it happened, the default type of these variables coincided with the intended type.

       Here is the corrected program, and its output when run:

       C       AUTHORS: MIKE MYERS AND LUCIA SPAGNUOLO
       C       DATE:    MAY 8, 1989
       C
       C       Variables:
       C               SCORE -> an array of test scores
       C               SUM ->   sum of the test scores
       C               COUNT -> counter of scores read in
       C               I ->     loop counter
       C
              REAL FUNCTION COMPAV(SCORE,COUNT)
                   INTEGER SUM,COUNT,I,SCORE(5)
       C
                   SUM = 0
                   DO 30 I = 1,COUNT
                       SUM = SUM + SCORE(I)
       30          CONTINUE
                   COMPAV = FLOAT(SUM)/FLOAT(COUNT)
               END
       C
       C
               PROGRAM AVENUM
       C
       C                       MAIN PROGRAM
       C
       C       AUTHOR:   LOIS BIGBIE
       C       DATE:     MAY 15, 1990
       C
       C       Variables:
       C               MAXNOS -> maximum number of input values
       C               NUMS    -> an array of numbers
       C               COUNT   -> exact number of input values
       C               AVG     -> average returned by COMPAV
       C               I       -> loop counter
       C
       C
                   INTEGER MAXNOS
                   PARAMETER(MAXNOS=5)
                   INTEGER I, NUMS(MAXNOS), COUNT
                   REAL AVG,COMPAV
                   COUNT = 0
                   DO 80 I = 1,MAXNOS
                       READ (5,*,END=100) NUMS(I)
                       COUNT = COUNT + 1
       80          CONTINUE
       100         AVG = COMPAV(NUMS, COUNT)
                   WRITE(6,*) 'AVERAGE =',AVG
               END
       $ run average
       70
       90
       85
       <EOF>
       AVERAGE =   81.66666
       $

       With ftnchek's help, our program is a success!

INTERPRETING THE OUTPUT

       The messages given by ftnchek include not only syntax errors but also warnings and informational messages
       about things that are legal Fortran but that may indicate errors or carelessness.  Most of these messages
       can  be  turned off by command-line options.  Which option controls each message depends on the nature of
       the condition being warned about.  See the  descriptions  of  the  command-line  flags  in  the  previous
       sections,  and  of  individual messages below.  Each message is prefixed with a word or phrase indicating
       the nature of the condition and its severity.

       ``Error'' means a syntax error.  The simplest kind of syntax errors are typographical errors, for example
       unbalanced  parentheses  or  misspelling  of  a  keyword.  This type of error is caught by the parser and
       appears with the description ``parse error'' or ``syntax error'' (depending on  the version of the parser
       generator  and  whether  it is GNU bison or UNIX yacc).  This type of error message cannot be suppressed.
       Be aware that this type of error often means that ftnchek has  not  properly  interpreted  the  statement
       where  the  error  occurs,  so  that  its subsequent checking operations will be compromised.  You should
       eliminate all syntax errors before proceeding to interpret the other messages ftnchek gives.

       ``Warning: Nonstandard syntax'' indicates an extension to Fortran that ftnchek supports but that  is  not
       according  to  the Fortran 77 Standard.  The extensions that ftnchek accepts are described in the section
       on Extensions below.  One example is the DO ... ENDDO construction.  If a program uses these  extensions,
       warnings  will  be  given according to specifications under the -f77 setting.  The default behavior is to
       give no warnings.

       ``Warning'' in other cases means a condition that is suspicious but that may or may not be a  programming
       error.  Frequently these conditions are legal under the standard.  Some are illegal but do not fall under
       the heading of syntax errors.  Usage errors are one example.  These  refer  to  the  possibility  that  a
       variable  may  be  used  before  it has been assigned a value (generally an error), or that a variable is
       declared but never used (harmless but may indicate carelessness).   The  amount  of  checking  for  usage
       errors is controlled by the -usage flag, which specifies the maximum amount of checking by default.

       Truncation  warnings  cover  situations in which accuracy may be lost unintentionally, for example when a
       double precision value is assigned to a real variable.  These warnings are controlled by the  -truncation
       setting, which is on by default.

       ``Nonportable  usage'' warns about some feature that may not be accepted by some compilers even though it
       is not contrary to the Fortran 77 Standard, or that may cause  the  program  to  perform  differently  on
       different  platforms.   For  example,  equivalencing real and integer variables is usually a non-portable
       practice.  The use of extensions to  the  standard  language  is,  of  course,  another  source  of  non-
       portability,  but  this is handled as a separate case.  To check a program for true portability, both the
       -portability and the -f77 flags should be used.  They are both turned  off  by  default.   The  -wordsize
       setting is provided to check only those nonportable usages that depend on a particular machine wordsize.

       ``Possibly  misleading appearance'' is used for legal constructions that may not mean what they appear to
       mean at first glance.  For example, Fortran is insensitive to blank space,  so  extraneous  space  within
       variable  names  or the lack of space between a keyword and a variable can convey the wrong impression to
       the reader.  These messages can be suppressed by turning off the -pretty flag, which is on by default.

       Other messages that are given after all the files are processed, and having to do with agreement  between
       modules,  do  not  use the word ``warning'' but generally fall into that category.  Examples include type
       mismatches between corresponding variables in different COMMON block declarations, or between  dummy  and
       actual  arguments  of a subprogram.  These warnings are controlled by the -common and -arguments settings
       respectively.  By default both are set for maximum strictness of checking.

       Another group of warnings about conditions that are  often  harmless  refer  to  cases  where  the  array
       properties  of a variable passed as a subprogram argument differ between the two routines.  For instance,
       an array element might be passed to a subroutine that expects a whole array.   This  is  a  commonly-used
       technique  for  processing  single  rows  or  columns  of two-dimensional arrays.  However, it could also
       indicate a programming error.  The -array setting allows the user to adjust the degree of  strictness  to
       be  used  in  checking  this  kind of agreement between actual and dummy array arguments.  By default the
       strictness is maximum.

       ``Oops'' indicates a technical problem, meaning either a bug in ftnchek or that its resources  have  been
       exceeded.

       The syntax error messages and warnings include the filename along with the line number and column number.
       ftnchek has two different options for the appearance of these error messages.  If -novice is  in  effect,
       which  is  the default, the messages are in a style approximating normal English.  (In default style, the
       filename is not printed in messages within the body of the program if -list is  in  effect.)   The  other
       style  of  error  messages  is  selected  by  the -nonovice option.  In this style, the appearance of the
       messages is similar to that of the UNIX lint program.

       ftnchek is still blind to some kinds of syntax errors.  The two most important ones are detailed checking
       of  FORMAT  statements,  and almost anything to do with control of execution flow by means of IF, DO, and
       GOTO statements: namely correct nesting of control structures, matching of opening statements such as  IF
       ...  THEN  with closing statements such as ENDIF, and the proper use of statement labels (numbers).  Most
       compilers will catch these errors.  See the section on Limitations for a more detailed discussion.

       If ftnchek gives you a syntax error message when the compiler does not, it may be  because  your  program
       contains an extension to standard Fortran which is accepted by the compiler but not by ftnchek.  (See the
       section on Extensions.)  On a VAX/VMS system, you can use the compiler  option  /STANDARD  to  cause  the
       compiler to accept only standard Fortran.  On most UNIX or UNIX-like systems, this can be accomplished by
       setting the flag -ansi.

       Many of the messages given by ftnchek are self-explanatory.  Those that need some additional  explanation
       are listed below in alphabetical order.

       Common block NAME: data type mismatch at position n
              The  n-th  variable  in the COMMON block differs in data type in two different declarations of the
              COMMON block.  By default (-common strictness level 3), ftnchek is very picky about COMMON blocks:
              the  variables  listed in them must match exactly by data type and array dimensions.  That is, the
              legal pair of declarations in different modules:
                   COMMON /COM1/ A,B
              and
                   COMMON /COM1/ A(2)
              will cause ftnchek to give warnings at strictness level 3.  These two declarations  are  legal  in
              Fortran  since they both declare two real variables.  At strictness level 1 or 2, no warning would
              be given in this example, but the warning would be given if there were a data type  mismatch,  for
              instance, if B were declared INTEGER.  Controlled by -common setting.

       Common block NAME has long data type following short data type
              Some  compilers  require alignment of multi-byte items so that each item begins at an address that
              is a multiple of the item size.  Thus if a short (e.g. single-precision real) item is followed  by
              a long (e.g.  double precision real) item, the latter may not be aligned correctly.  Controlled by
              -portability=common-alignment option.

       Common block NAME has mixed character and non-character variables
              The ANSI standard requires that if any variable in a COMMON block is of type CHARACTER,  then  all
              other  variables  in  the  same  COMMON  block  must  also  be  of  type CHARACTER.  Controlled by
              -f77=mixed-common option.

       Common block NAME: varying length
              For -common setting level 2, this message means that a COMMON block is declared to have  different
              numbers  of  words  in two different subprograms.  A word is the amount of storage occupied by one
              integer or real variable.  For -common setting level 3, it means that the  two  declarations  have
              different  numbers  of  variables, where an array of any size is considered one variable.  This is
              not necessarily an error, but it may indicate that a variable is missing from one  of  the  lists.
              Note  that  according  to the Fortran 77 Standard, it is an error for named COMMON blocks (but not
              blank COMMON) to differ in number of words  in  declarations  in  different  modules.   Given  for
              -common setting 2 or 3.

       Error: Badly formed logical/relational operator or constant

       Error: Badly formed real constant
              The  syntax  analyzer  has  found  the start of one of the special words that begin and end with a
              period (e.g. .EQ.), or the start of a numeric constant, but did not succeed in finding a  complete
              item of that kind.

       Error: cannot be adjustable size in module NAME
              A  character  variable cannot be declared with a size that is an asterisk in parentheses unless it
              is a dummy argument, a parameter, or the name of the function defined in the module.

       Error: cannot be declared in SAVE statement in module NAME
              Only local variables and common blocks can be declared in a SAVE statement.

       Error: No path to this statement
              ftnchek will detect statements which are ignored or by-passed  because  there  is  no  foreseeable
              route  to  the  statement.   For example, an unnumbered statement (a statement without a statement
              label), occurring immediately after a GOTO statement, cannot possibly be executed.

       Error: Parse error
              This means that the parser, which analyzes the Fortran program into expressions, statements, etc.,
              has been unable to find a valid interpretation for some portion of a statement in the program.  If
              your compiler does not report a syntax error at the same place, the most common explanations  are:
              (1)  use  of  an  extension to ANSI standard Fortran that is not recognized by ftnchek, or (2) the
              statement requires more lookahead than ftnchek uses (see section on Bugs).

              NOTE: This message means that the  affected  statement  is  not  interpreted.   Therefore,  it  is
              possible  that  ftnchek's  subsequent  processing  will  be in error, if it depends on any matters
              affected by this statement (type declarations, etc.).

       Error: Syntax error
              This is the same as ``Error: Parse error'' (see above).   It  is  generated  if  your  version  of
              ftnchek was built using the UNIX yacc parser generator rather than GNU bison.

       Identifiers which are not unique in first six chars
              Warns  that  two  identifiers  which  are  longer  than  6 characters do not differ in the first 6
              characters.  This is for portability: they may not  be  considered  distinct  by  some  compilers.
              Controlled by -sixchar option.

       Nonportable usage: argument precision may not be correct for intrinsic function
              The  precision  of an argument passed to an intrinsic function may be incorrect on some computers.
              Issued when a numeric variable declared with explicit precision (e.g.  REAL*8 X) is  passed  to  a
              specific intrinsic function (e.g. DSQRT(X)).  Controlled by -portability=mixed-size and -wordsize.

       Nonportable usage: character constant/variable length exceeds 255
              Some compilers do not support character strings more than 255 characters in length.  Controlled by
              -portability=long-string.

       Nonportable usage: File contains tabs
              ftnchek expands tabs to be equivalent to spaces up to the next column which is a  multiple  of  8.
              Some  compilers treat tabs differently, and also it is possible that files sent by electronic mail
              will have the tabs converted to blanks in some way.  Therefore files containing tabs  may  not  be
              compiled correctly after being transferred.  ftnchek does not give this message if tabs only occur
              within comments or character constants.  Controlled by -portability=tab.

       Nonportable usage: non-integer DO loop bounds
              This warning is only given when the DO index and  bounds  are  non-integer.   Use  of  non-integer
              quantities  in  a  DO  statement  may  cause  unexpected errors, or different results on different
              machines, due to roundoff effects.  Controlled by -portability=real-do.

       Possibly it is an array which was not declared
              This message is appended to warnings related to a function  invocation  or  to  an  argument  type
              mismatch, for which the possibility exists that what appears to be a function is actually meant to
              be an array.  If the programmer forgot to dimension an array, references  to  the  array  will  be
              interpreted  as  function  invocations.   This  message will be suppressed if the name in question
              appears in an EXTERNAL or INTRINSIC statement.  Controlled by the -novice option.

       Possibly misleading appearance: characters past 72 columns
              The program is being processed with the statement field width at its standard  value  of  72,  and
              some  nonblank characters have been found past column 72.  In this case, ftnchek is not processing
              the characters past column 72, and is notifying the user that  the  statement  may  not  have  the
              meaning  that  it  appears  to  have.   These characters might be intended by the programmer to be
              significant, but they will be ignored by the compiler.  Controlled by -pretty=long-line.

       Possibly misleading appearance: Common block declared in more than one statement
              Such multiple declarations are legal and have the same effect as a continuation  of  the  original
              declaration of the block.  This warning is only given if the two declarations are separated by one
              or more intervening statements.  Controlled by -pretty=multiple-common.

       Possibly misleading appearance: Continuation follows comment or blank line
              ftnchek issues this warning message to alert the user  that  a  continuation  of  a  statement  is
              interspersed with comments, making it easy to overlook.  Controlled by -pretty=continuation.

       Possibly misleading appearance: Extraneous parentheses
              Warns  about  parentheses surrounding a variable by itself in an expression.  When a parenthesized
              variable is passed as an argument to a subprogram, it is  treated  as  an  expression,  not  as  a
              variable whose value can be modified by the called routine.  Controlled by -pretty=parentheses.

       Subprogram NAME: argument data type mismatch at position n
              The subprogram's n-th actual argument (in the CALL or the usage of a function) differs in datatype
              or precision from the n-th dummy argument  (in  the  SUBROUTINE  or  FUNCTION  declaration).   For
              instance, if the user defines a subprogram by
                   SUBROUTINE SUBA(X)
                   REAL X
              and elsewhere invokes SUBA by
                   CALL SUBA(2)
              ftnchek  will  detect  the error.  The reason here is that the number 2 is integer, not real.  The
              user should have written
                   CALL SUBA(2.0)

              When checking an argument which is a subprogram, ftnchek must be able to determine whether it is a
              function or a subroutine.  The rules used by ftnchek to do this are as follows: If the subprogram,
              besides being passed as an actual argument, is also invoked directly elsewhere in the same module,
              then  its  type  is determined by that usage.  If not, then if the name of the subprogram does not
              appear in an explicit type declaration, it is assumed to be a  subroutine;  if  it  is  explicitly
              typed  it  is taken as a function.  Therefore, subroutines passed as actual arguments need only be
              declared by an EXTERNAL statement in the calling module, whereas functions must also be explicitly
              typed in order to avoid generating this error message.  Controlled by -arguments setting.

       Subprogram NAME: argument arrayness mismatch at position n
              Similar  to  the  preceding  situation,  but  the  subprogram  dummy  argument  differs  from  the
              corresponding actual argument in its number of dimensions or number of  elements.   Controlled  by
              -array together with -arguments settings.

       Subprogram NAME: argument mismatch at position n
              A  character dummy argument is larger than the corresponding actual argument, or a Hollerith dummy
              argument is larger than the corresponding actual argument.  Controlled by -arguments setting.

       Subprogram NAME: argument usage mismatch
              ftnchek detects a possible conflict between the way a subprogram uses an argument and the  way  in
              which  the  argument  is  supplied  to  the  subprogram.  The conflict can be one of two types, as
              outlined below.

          Dummy arg is modified, Actual arg is const or expr
              A dummy argument is an argument as named in a SUBROUTINE or FUNCTION statement and used within the
              subprogram.   An  actual  argument  is  an  argument  as passed to a subroutine or function by the
              caller.  ftnchek is saying that a dummy argument is modified by the subprogram, implying that  its
              value  is  changed  in  the  calling  module.   The  corresponding actual argument should not be a
              constant or expression, but rather a variable or array element which can be legitimately  assigned
              to.  Controlled by the -usage=arg-const-modified option.

          Dummy arg used before set, Actual arg not set
              Here  a  dummy  argument may be used in the subprogram before having a value assigned to it by the
              subprogram.  The corresponding actual argument should have a value assigned to it  by  the  caller
              prior to invoking the subprogram.  Controlled by the -usage=var-uninitialized option.

              This warning is not affected by the -arguments setting.

       Subprogram NAME invoked inconsistently
              Here  the  mismatch  is  between the datatype of the subprogram itself as used and as defined. For
              instance, if the user declares
                   INTEGER FUNCTION COUNT(A)
              and invokes COUNT in another module as
                   N = COUNT(A)
              without declaring its datatype, it will default to real type, based on the  first  letter  of  its
              name.  The calling module should have included the declaration
                   INTEGER COUNT

              Given for -arguments setting 2 or 3.

       Subprogram NAME:  varying length argument lists:
              An  inconsistency  has  been found between the number of dummy arguments (parameters) a subprogram
              has and the number of actual arguments given it in an invocation.   ftnchek  keeps  track  of  all
              invocations  of  subprograms  (CALL  statements and expressions using functions) and compares them
              with the definitions of the subprograms elsewhere  in  the  source  code.   The  Fortran  compiler
              normally does not catch this type of error.  Given for -arguments setting 1 or 3.

       Variable not declared.  Type has been implicitly defined
              When  printing  the  symbol table for a module, ftnchek will flag with an asterisk all identifiers
              that are not explicitly typed and will show  the  datatype  that  was  assigned  through  implicit
              typing.   This  provides  support  for  users  who wish to declare all variables as is required in
              Pascal or some other languages.  This message appears only when the -symtab option is  in  effect.
              Alternatively, use the -declare flag if you want to get a list of all undeclared variables.

       Variables declared but never referenced
              Detects  any  identifiers  that  were  declared  in your program but were never used, either to be
              assigned a value or to have their value accessed.  Variables in COMMON are  excluded.   Controlled
              by the -usage=var-unused option.

       Variables set but never used
              ftnchek  will  notify  the user when a variable has been assigned a value, but the variable is not
              otherwise used in the program.  Usually  this  results  from  an  oversight.   Controlled  by  the
              -usage=var-set-unused option.

       Variables used before set
              This  message indicates that an identifier is used to compute a value prior to its initialization.
              Such usage may lead to an  incorrect  value  being  computed,  since  its  initial  value  is  not
              controlled.  Controlled by the -usage=var-uninitialized option.

       Variables may be used before set
              Similar to used before set except that ftnchek is not able to determine its status with certainty.
              ftnchek assumes a variable may be used before set if the first usage of the variable occurs  prior
              in the program text to its assignment.  Controlled by the -usage=var-uninitialized option.

       Warning: DO index is not integer
              This  warning  is  only  given  when  the  DO bounds are integer, but the DO index is not.  It may
              indicate a failure to declare the index to  be  an  integer.   Controlled  by  -truncation=real-do
              option.

       Warning: integer quotient expr ... converted to real
              The  quotient  of  two integers results in an integer type result, in which the fractional part is
              dropped.  If such an integer expression involving division is later converted to a real  datatype,
              it  may  be  that  a real type division had been intended.  Controlled by -truncation=int-div-real
              option.

       Warning: Integer quotient expr ... used in exponent
              The quotient of two integers results in an integer type result, in which the  fractional  part  is
              dropped.   If  such  an  integer expression is used as an exponent, it is quite likely that a real
              type division was intended.  Controlled by -truncation=int-div-exponent option.

       Warning: NAME not set when RETURN encountered
              The way that functions in Fortran return a value is by assigning the value  to  the  name  of  the
              function.   This  message  indicates  that  the function was not assigned a value before the point
              where a RETURN statement was found.  Therefore it is possible that the function  could  return  an
              undefined value.

       Warning: Nonstandard syntax: adjustable size cannot be concatenated here
              The  Fortran  77  Standard (sec. 6.2.2) forbids concatenating character variables whose size is an
              asterisk in parentheses, except in an assignment statement.   Controlled by -f77=mixed-expr.

       Warning: Nonstandard syntax : significant characters past 72 columns
              This warning is given under the -f77=long-line setting if the -columns setting has  been  used  to
              increase  the statement field width, and a statement has meaningful program text beyond column 72.
              Standard Fortran ignores all text in those columns, but some compilers do not.  Thus  the  program
              may be treated differently by different compilers.

       Warning: Nonstandard syntax : Statement out of order.
              ftnchek  will  detect  statements that are out of the sequence specified for ANSI standard Fortran
              77.  Table 1 illustrates the allowed sequence of statements in the Fortran  language.   Statements
              which  are  out  of order are nonetheless interpreted by ftnchek, to prevent ``cascades'' of error
              messages.  The sequence counter is also rolled back to prevent repetition of the error message for
              a block of similar statements.  Controlled by the -f77=statement-order option.

              --------------------------------------------------------
                                |               | implicit
                                |  parameter    |---------------------
                                |               | other specification
                      format    |---------------|---------------------
                       and      |               | statement-function
                      entry     |  data         |---------------------
                                |               | executable
              --------------------------------------------------------

                                    Table 1

       Warning: Possible division by zero
              This  message is printed out wherever division is done (except division by a constant).  Use it to
              help locate a runtime division by zero problem.  Controlled by -division option.

       Warning: real truncated to intg
              ftnchek has detected an assignment statement which has a real expression  on  the  right,  but  an
              integer  variable  on  the  left.   The  fractional  part  of the real value will be lost.  If you
              explicitly convert the real expression to integer using the INT or  NINT  intrinsic  function,  no
              warning  will  be  printed.   A  similar  message  is  printed if a double precision expression is
              assigned to a single precision variable, etc.  Controlled by -truncation=demotion option.

       Warning: subscript is not integer
              Since array subscripts are normally integer quantities, the use of a non-integer  expression  here
              may signal an error.  Controlled by -truncation=real-subscript option.

       Warning: Unknown intrinsic function
              This  message warns the user that a name declared in an INTRINSIC statement is unknown to ftnchek.
              Probably it is a nonstandard intrinsic function, and so the program will  not  be  portable.   The
              function will be treated by ftnchek as a user-defined function.  This warning is not suppressed by
              any option, since it affects ftnchek's  analysis  of  the  program.   However,  if  the  intrinsic
              function  is  in  one  of the supported sets of nonstandard intrinsics, you can use the -intrinsic
              setting to cause ftnchek to recognize it.

LIMITATIONS AND EXTENSIONS

       ftnchek accepts ANSI standard Fortran-77  programs  with  some  minor  limitations  and  numerous  common
       extensions.

       Limitations:
              The  dummy  arguments  in  statement functions are treated like ordinary variables of the program.
              That is, their scope is the entire subprogram, not just the statement function definition.

              The checking of FORMAT statements is lax, tolerating  missing  separators  (comma,  etc.)  between
              format  descriptors  in  places  where  the  Standard  requires  them,  and  allowing .d fields on
              descriptors  that  should  not  have  them.   It  does  warn  under  -f77=format-edit-descr  about
              nonstandard descriptor types (like O), and supported extensions.

              There  are  some  syntactic  extensions and Fortran 90 elements that ftnchek accepts but does very
              little checking.  For instance, pointer usage (whether the nonstandard Cray syntax or the  Fortran
              90  syntax)  is  not  checked  other than for set and used status.  It is hoped that some day more
              thorough checking will be implemented, but for now the user should regard the acceptance of  these
              syntactic  features  simply  as  a  convenience  to  enable checking of other aspects of code that
              contains them.  See the section Extensions for specifics about what features are accepted but  not
              fully checked.

              If  a  user-supplied  subprogram  has  the same name as one of the nonstandard intrinsic functions
              recognized by ftnchek, it must be declared in an EXTERNAL statement in any  routine  that  invokes
              it.  Otherwise it will be subject to the checking normally given to the intrinsic function.  Since
              the nonstandard intrinsics are not standard, this  EXTERNAL  statement  is  not  required  by  the
              Fortran  77  Standard.   Using  the  -intrinsic=none  setting,  recognition  of  most  nonstandard
              intrinsics (excepting only those needed to support the double complex data  type)  can  be  turned
              off.   See  the  lists  of  supported  nonstandard intrinsic functions under the discussion of the
              -intrinsic setting above.

       Extensions:
              All of these extensions (except lower-case characters) will generate warnings if the relevant -f77
              option  is  set.   Some of the extensions listed below are part of the Fortran-90 Standard.  These
              are indicated by the notation (F90).

              Tabs are permitted, and translated into equivalent blanks which correspond to tab  stops  every  8
              columns.   The  standard  does not recognize tabs.  Note that some compilers allow tabs, but treat
              them differently.  The treatment defined for DEC FORTRAN can be achieved using the -source=dec-tab
              setting.

              Strings  may  be  delimited  by  either  quote  marks or apostrophes.  A sequence of two delimiter
              characters is interpreted as a single embedded delimiter character.  (F90)

              Strings may contain UNIX-style backslash escape sequences.  They will be interpreted  as  such  if
              the -source=unix-backslash setting is given.  Otherwise the backslash character will be treated as
              a normal printing character.

              Source code can be in either Fortran 90 free format or traditional fixed format.  (F90)

              A semicolon is allowed as a statement separator.  (F90)

              Lower case characters are permitted, and are converted internally to uppercase except in character
              strings.  The standard specifies upper case only, except in comments and strings.  (F90)

              Hollerith  constants  are permitted, in accordance with the Fortran 77 Standard, appendix C.  They
              should not be used in expressions, or confused with datatype CHARACTER.

              The letter 'D' (upper or lower case) in column 1 is treated as the beginning of a comment.   There
              is no option to treat such lines as statements instead of comments.

              Statements  may  be longer than 72 columns provided that the setting -columns was used to increase
              the limit.  According to the standard, all text from columns 73 through 80 is ignored, and no line
              may be longer than 80 columns.

              Variable  names  may  be  longer  than six characters.  The standard specifies six as the maximum.
              ftnchek permits names up to 31 characters long (F90).

              Variable names may contain underscores and dollar signs (or  other  non-alphabetic  characters  as
              specified  by  the  -identifier-chars  option).   These  characters  are  are  treated the same as
              alphabetic letters.  The default type for variables beginning with these characters is  REAL.   In
              IMPLICIT  type  statements  specifying  a  range  of  characters, the dollar sign follows Z and is
              followed by underscore.  (Any other user-defined characters are treated the  same  as  the  dollar
              sign.)  Fortran 90 permits underscores in variable names.

              The  UNIX  version  tolerates the presence of preprocessor directives, namely lines beginning with
              the pound sign (#).  These are treated  as  comments,  except  for  #line  directives,  which  are
              interpreted,  and  are  used  to  set  the line number and source file name for warnings and error
              messages.  Note that #include directives are not processed by ftnchek.  Programs that use them for
              including  source  files  should be passed through the preprocessor before being input to ftnchek.
              As noted below, ftnchek does process INCLUDE  statements,  which  have  a  different  syntax.   An
              optional  program,  ftnpp(1L) (available separately) provides  preprocessing that properly handles
              INCLUDE files.

              The Fortran 90 DO ...  ENDDO control structure is permitted.  The CYCLE and  EXIT  statements  are
              accepted.   All  of  these  may  have  an  optional do-construct name, but construct names are not
              checked for consistency. (F90)

              The Fortran 90 SELECT CASE construct is accepted. (F90)

              Construct names are also accepted on IF, THEN, ELSE, ENDIF and SELECT CASE statements. (F90)

              The ACCEPT and TYPE statements (for terminal I/O) are permitted, with the same syntax as PRINT.

              The so-called ``Cray pointer'' syntax is tolerated. It is not the same as the Fortran  90  POINTER
              statement.   There is no real checking of the statement other than basic syntax.  The form of this
              statement is
                 POINTER (pointer, pointee) [,(pointer, pointee)]
              The pointer variables are assigned a data type of INTEGER  *4.   Usage  checking  of  the  pointee
              variables is suppressed, since in practice they are accessed indirectly via the pointers.

              The  following  Fortran 90 pointer related syntaxes are accepted: ALLOCATABLE, POINTER, and TARGET
              statements and the same  attributes  in  type  declarations;  ALLOCATE,  DEALLOCATE,  and  NULLIFY
              executable statements; pointer assignment using => operator; and the intrinsic functions ALLOCATED
              and ASSOCIATED.  Little semantic checking of pointer variables and operations is done beyond basic
              set  and used status.  For instance, there is no checking for such errors as dangling pointers, or
              use of unallocated arrays.

              Statements may have any number of continuation lines.  The Fortran 77  and  Fortran  90  standards
              allow  a  maximum  of  19 in fixed source form.  The Fortran 90 standard allows a maximum of 39 in
              free source form.

              Relational (comparison) operators composed of punctuation, namely: < <= == /= >  >=  are  allowed.
              (F90)

              Inline comments, beginning with an exclamation mark, are permitted.  (F90)

              NAMELIST I/O is supported.  The syntax is the same as in Fortran 90.

              FORMAT  statements  can  contain  a  dollar  sign  to indicate suppression of carriage-return.  An
              integer expression enclosed in angle brackets can be used anywhere in a FORMAT statement where the
              Fortran 77 Standard allows an integer constant (except for the length of a Hollerith constant), to
              provide a run-time value for a repeat specification or field width.

              Nonstandard keywords are allowed in I/O statements, corresponding to those in VMS Fortran.

              The IMPLICIT NONE statement is supported.  The meaning of this statement  is  that  all  variables
              must  have  their  data  types  explicitly  declared.   Rather  than  flag the occurrences of such
              variables with syntax error messages, ftnchek waits till the end of the module,  and  then  prints
              out a list of all undeclared variables, as it does for the -declare option.  (F90)

              Data  types  INTEGER,  REAL,  COMPLEX,  and  LOGICAL  are  allowed  to  have an optional precision
              specification in type declarations.  For instance, REAL*8 means  an  8-byte  floating  point  data
              type.  The REAL*8 datatype is not necessarily considered equivalent to DOUBLE PRECISION, depending
              on the -wordsize setting.  The  Fortran  77  Standard  allows  a  length  specification  only  for
              CHARACTER data.

              ftnchek  supports  the  DOUBLE  COMPLEX  type  specification for a complex quantity whose real and
              imaginary parts are double precision.  Mixed-mode arithmetic  involving  single-precision  complex
              with double-precision real data, prohibited under the Standard, yields a double complex result.

              Combined type declarations and data-statement-like initializers are accepted.  These have the form
              of a standard Fortran 77 type declaration, followed by a slash-delimited list  of  constants  like
              that used in a DATA statement.  An example of the syntax is
                   INTEGER  N / 100 /
              This  bastard  form  of initializing declaration was not adopted in Fortran 90.  Such declarations
              should be written using the standard form described below, which is accepted by ftnchek.

              There is limited support  for  Fortran  90  attribute-based  type  declarations.   This  style  of
              declaration  is distinguished by the use of a double colon (::) between the list of attributes and
              the list of declared variables.  The features supported may be adequate  for  novice  programmers,
              but  are  not  yet sufficient for professional-quality Fortran 90 programs.  I hope to add support
              for more features in future releases.  I invite volunteers to assist in this task.  See  the  ToDo
              file  in the source code distribution for details.  The attributes currently accepted, besides all
              the usual data types, are DIMENSION, EXTERNAL, INTRINSIC, PARAMETER, and SAVE.  The  new  form  of
              declaration  also  allows  assignment  of  values  to  the  variables  declared.   At present, the
              (LEN=value) form of specifying character lengths is also  accepted.   Kind  specifications,  using
              (KIND=value) are parsed but are not processed: all kinds are treated as default kind.  Also, there
              is little checking of these declarations beyond basic syntax.

              Many commonly  found  nonstandard  intrinsic  functions  are  provided.   See  the  discussion  of
              -intrinsic for a list of functions and how to control which ones are recognized.

              Argument checking is not tight for those nonstandard intrinsics that take arrays or mixed argument
              types.

              ftnchek permits the INCLUDE statement, which causes inclusion of the text of the given file.   The
              syntax is
                   INCLUDE 'filename'
              This  is  compatible with Fortran 90.  If the -source=vms-include option is given, ftnchek follows
              VMS conventions with respect to this statement: it assumes a  default  extension  of  .for  if  no
              filename extension is given, and allows the qualifier /[NO]LIST following the filename, to control
              the listing of the included file.  There is no support for including VMS text modules.

              In diagnostic output relating to items contained in include files, the location of  the  error  is
              specified  by  both its location in the include file and the location in the parent file where the
              file was included.

              ftnchek accepts PARAMETER statements which lack parentheses.  These will be warned  about  if  the
              -f77=param-noparen flag is given.

              ftnchek  accepts  PARAMETER  definitions  that involve intrinsic functions and exponentiation by a
              non-integer exponent.  Both of these cases are prohibited by the Fortran 77 Standard, and will  be
              warned  about  if  the  -f77=param-intrinsic  flag  is given.  If an intrinsic function value is a
              compile-time integer constant, ftnchek will evaluate it.   This  allows  better  checking  if  the
              parameter  is  used  in declaring array sizes.  Fortran 90 allows intrinsic functions in PARAMETER
              definitions.

              The intrinsic functions that are evaluated are:

                                             ABS     IABS   DIM     IDIM    MAX
                                             MAX0    MIN    MIN0    MOD     SIGN
                                             ISIGN   LEN    ICHAR   INDEX

              The functions of integer arguments are evaluated  only  if  the  arguments  are  integer  constant
              expressions.    (These   may  involve  integer  constants,  parameters,  and  evaluated  intrinsic
              functions.)  The function LEN is evaluated  if  its  argument  is  an  expression  involving  only
              character  constants  and variables whose length is not adjustable.  The functions ICHAR and INDEX
              are evaluated only if the arguments are character constants.  ftnchek gives a warning if it  needs
              the value of some intrinsic function that is not evaluated.

NEW FEATURES

       Here are the changes from Version 3.2 to Version 3.3:

       1.  Front-end  has  been  rewritten for unlimited lookahead, eliminating the longstanding bug that caused
           incorrect interpretation of statements whose ambiguity was not resolved in the first line.

       2.  The -mkhtml option is now available in the MS-DOS version.

       3.  Added support for Fortran 90 pointer related syntax: ALLOCATE, DEALLOCATE,  and  NULLIFY  statements;
           the  ALLOCATABLE,  POINTER and TARGET attributes in type declarations; the pointer assigment operator
           => and intrinsic functions ALLOCATED and  ASSOCIATED;  and  deferred-shape  array  declarations.   At
           present  these  new syntax features are accepted but not properly checked.  This feature was added by
           Robert Landrito.

       4.  The -f77 and -f90 pointer option controlling warnings about ``Cray pointers''  has  been  renamed  to
           cray-pointer.   The  -f77=pointer option now instead controls warnings for code containing Fortran 90
           pointer-related syntax.

       5.  Re-implemented -mkhtml processing so it is now much faster on source files containing many routines.

       6.  Changed the arrangement of the test  directory  so  there  is  no  longer  any  need  to  modify  the
           distribution in order to run the test suite (check.bat) under MS-DOS.

       7.  Fixed bug in reading numeric settings on command line when setting name abbreviated to 3 characters.

       8.  Fixed bug causing spurious warning for a GOTO referring to a labeled END statement when the statement
           before END was a FORMAT.

       9.  New flag -f77=character to control warnings about extensions to the Fortran 77 character  data  type.
           Accompanying  this  new flag is support for Fortran 90 rules for character variable declarations that
           evaluate to zero or negative length, allowing them and treating negative length values as zero.

       10. Fixed minor bug in printing of comments and blank lines following last END statement in -list mode.

BUGS

       ftnchek still has much room for improvement.  Your feedback is appreciated.  We want to  know  about  any
       bugs  you  notice.   Bugs  include not only cases in which ftnchek issues an error message where no error
       exists, but also if ftnchek fails to issue a warning when it ought to.  Note, however,  that  ftnchek  is
       not  intended  to catch all syntax errors (see section on Limitations).  Also, it is not considered a bug
       for a variable to be reported as used before set, if the reason is that the usage of the variable  occurs
       prior  in  the  text  to  where  the  variable is set.  For instance, this could occur when a GOTO causes
       execution to loop backward to some previously skipped statements.  ftnchek does not analyze  the  program
       flow, but assumes that statements occurring earlier in the text are executed before the following ones.

       We  especially  want  to  know  if  ftnchek crashes for any reason.  It is not supposed to crash, even on
       programs with syntax errors.  Suggestions are welcomed for  additional  features  which  you  would  find
       useful.   Tell  us  if  any  of ftnchek's messages are incomprehensible.  Comments on the readability and
       accuracy of this document are also welcome.

       You may also suggest support for additional extensions to the Fortran language.  These will  be  included
       only if it is felt that the extensions are sufficiently widely accepted by compilers.

       If  you  find  a bug in ftnchek, first consult the list of known bugs below to see if it has already been
       reported.  Also check the section entitled ``Limitations and Extensions''  above  for  restrictions  that
       could  be  causing  the  problem.  If you do not find the problem documented in either place, then send a
       report including

       1.  The operating system and CPU type on which ftnchek is running.

       2.  The version of ftnchek and values of any environment options or settings  defined  in  startup  file.
           (Capturing the output of ftnchek -help is useful for this.)

       3.  A brief description of the bug.

       4.  If possible, a small sample program showing the bug.

       The  report  should  be  sent  to  Dr.  Robert  Moniot  (see  contact  information  in  section  entitled
       ``Installation and Support'').

       Highest priority will be given to bugs which cause ftnchek to crash.

       Certain problems that arise when checking large programs can be fixed by increasing the sizes of the data
       areas  in  ftnchek.   (These  problems are generally signaled by error messages beginning with ``Oops''.)
       The simplest way to increase the table sizes is by recompiling ftnchek with the LARGE_MACHINE macro  name
       defined.  Consult the makefile and README file for the method of doing this.

       The following is a list of known bugs.

       1.  Bug:  Used-before-set  message  is  suppressed for any variable which is used as the loop index in an
           implied-do loop, even if it was in fact used  before  being  set  in  some  earlier  statement.   For
           example, consider J in the statement

                 WRITE(5,*) (A(J), J=1,10)

           Here  ftnchek  parses  the  I/O  expression, A(J), where J is used, before it parses the implied loop
           where J is set.  Normally this would cause ftnchek to report a spurious used-before-set  warning  for
           J.   Since this report is usually in error and occurs fairly commonly, ftnchek suppresses the warning
           for J altogether.

           Prognosis: A future version of  ftnchek is planned which will handle implied-do loops correctly.

       2.  Bug: Variables used (not as arguments) in statement-function subprograms  do  not  have  their  usage
           status updated when the statement function is invoked.

           Prognosis: To be fixed in a future version of ftnchek.

       3.  Bug:  VAX  version  does  not  expand wildcards in filenames on the command line if they are followed
           without space by an option, e.g.  ftnchek *.f/calltree would not expand the  *.f.   This  is  because
           VMS-style  options  without intervening space are not supported by the GNU shell_mung routine that is
           used to expand wildcards.

           Prognosis: unlikely to be fixed.

       4.  Bug: checking for nonstandard format edit descriptors is done  only  in  FORMAT  statements,  not  in
           character strings used as formats.

           Prognosis: may be fixed someday.

ACKNOWLEDGEMENTS

       ftnchek  was designed by Dr. Robert Moniot, professor at Fordham University.  During the academic year of
       1988-1989, Michael Myers and Lucia Spagnuolo developed the program to perform the variable usage  checks.
       During  the following year it was augmented by Lois Bigbie to check subprogram arguments and COMMON block
       declarations.  Brian Downing assisted with the implementation of the INCLUDE statement.  John Quinn wrote
       the  common  block  usage  checks.   Heba  Elsayed wrote the label table printout and label usage checks.
       Nelson H. F. Beebe of the University of Utah added most of  the  new  code  to  implement  the  -makedcls
       feature  and  wrote the dcl2inc script.  The -mkhtml feature was contributed by Mark McVeigh of Framatome
       ANP, Inc.  The -reference feature was contributed by Gerome Emmanuel, Ecole des mines, U. Nancy (slightly
       modified).   The  -vcg  option  was  contributed  by  Dr. Philip Rubini of Cranfield University, UK.  The
       support for Cray pointer syntax was provided by John Dannenhoffer of United Technologies Research Center.
       John  C.  Bollinger  of Indiana University added the parser syntax for the SELECT CASE construct.  Robert
       Landrito added the parser syntax for F90 pointer-related features.  Additional features will be added  as
       time permits.  As of Version 2.5, the name was changed from forchek to ftnchek, to avoid confusion with a
       similar program named forcheck, developed earlier at Leiden University.

       We would like to thank John Amor of the University of British Columbia, Reg  Clemens  of  the  Air  Force
       Phillips  Lab  in  Albuquerque,  Markus  Draxler  of  the University of Stuttgart, Victor Eijkhout of the
       University of Tennessee at Knoxville, Greg Flint of Purdue University, Daniel P. Giesy  of  NASA  Langley
       Research  Center,  Fritz  Keinert  of  Iowa State University, Judah Milgram of the University of Maryland
       College Park, Hugh Nicholas of the Pittsburgh Supercomputing Center, Dan Severance  of  Yale  University,
       Phil  Sterne  of  Lawrence Livermore National Laboratory, Larry Weissman of the University of Washington,
       Warren J. Wiscombe of NASA Goddard, and Nelson H. F. Beebe of the University of Utah,  for  pointing  out
       bugs and suggesting some improvements.  Stefan A. Deutscher, Gunnar Duus, Clive Page of the University of
       Leicester, Stephan Wefing of Heidelberg University, and Bob Wells of  Oxford  University  were  extremely
       helpful  as  alpha  testers.   We also thank Jack Dongarra for putting ftnchek into the netlib library of
       publicly available software.

INSTALLATION AND SUPPORT

       The ftnchek program is free software.  It can be obtained by anonymous ftp from  many  software  servers,
       including  ftp://netlib.org/fortran  .   Note  that  on  Netlib  the distribution is named ftnchek.tar.gz
       whereas on most other servers the file name includes the version number, e.g.  ftnchek-3.3.0.tar.gz.   If
       the  file extension is .Z, uncompress with the Unix uncompress(1) utility.  If the file extension is .gz,
       uncompress with the GNU gunzip(1L) program.  Then use tar(1) to unpack the files into a subdirectory.

       Installation requires a  C  compiler  for  your  computer.   See  the  INSTALL  file  provided  with  the
       distribution  for  instructions  on  installing ftnchek on your system.  Executable binary for particular
       systems  such  as  IBM  PC  or  Macintosh,  as  available,  can  be  obtained  by  anonymous   ftp   from
       ftp://ftp.dsm.fordham.edu/pub/ftnchek .  Assistance in preparing such executable binary forms is welcome.

       The  nroff  version of this document is named ftnchek.man.  On UNIX systems, this file can be used as the
       man page, but actually it is a multi-purpose source file which is used to produce the other forms of  the
       documentation.   The  cleaned-up  man  page  document,  created  during installation of ftnchek, is named
       ftnchek.1.  The distribution also includes a plain ASCII version named ftnchek.doc, a PostScript  version
       named ftnchek.ps, an HTML version in directory html, and a VMS HELP version named ftnchek.hlp.

       Information  about the latest version and the status of the project can be obtained by visiting ftnchek's
       home page, http://www.dsm.fordham.edu/~ftnchek .  For further information and to  report  bugs,  you  may
       contact  Dr.  Robert  Moniot,  whose  contact  information  can be found by a Web search for his name and
       Fordham University.  (E-mail address is not provided here because it attracts unsolicited  commercial  e-
       mail, but it is easily constructed by combining his last name with the name of the university and the edu
       domain.)

SEE ALSO

       dcl2inc(1L), dtoq(1L), dtos(1L), f77(1), fd2s(1L), fs2d(1L),  ftnpp(1L),  pfort(1L),  qtod(1L),  sf3(1L),
       stod(1L).  xsf3(1L), xvcg(1L).

                                                  November 2004                                   FTNCHEK 3.3(1)