Man Linux: Main Page and Category List


       fort77 - invoke f2c Fortran translator transparently, like a compiler


       fort77  [-c] [-g] [-v] [-k] [-P] [-cpp] [f2c option ...]  [-L directory
       ...]  [gcc-option ...]  [link option ...]  [-O optlevel]  [-o  outfile]
       [-s] [-w] [-Wx,arg1[,arg2]...]  file ...


       The  fort77  script invokes the f2c command transparently, so it can be
       used like a real Fortran compiler.  It can be used to compile  Fortran,
       C and assembler code, and to link it with the f2c libraries.

       File  arguments  ending  with  .f are compiled as Fortran source files.
       Files which end with .P are passed through to  f2c,  and  files  ending
       with  .F  are  passed  to  the  C  preprocessor  (invoked  as "/lib/cpp
       -traditional") first.  Any switches passed via -D will be passed to the
       preprocessor.   If the translation is successful, the resulting C files
       will be passed to cc for translation into an object file.  Files ending
       in  .c,  .C,  .cc,  .i, .s, .S, .m, .cc or .cxx are passed to the GNU C
       compiler directly; see gcc(1).  All  other  files  are  passed  to  the


       -c      Supress  linking  and  produce  an object ( .o ) file from each
               source file.

       -g      Include debugging information.  -v Be verbose;  supplying  this
               twice will also tell the C compilers etc to be verbose.

       -k      Keep the C files generated by f2c around.

       -cpp    Pass  Fortran  code through the C preprocessor, as if filenames
               ended in .F.

       -P      Generate f2c .P files.

               Include directory in the search  for  libraries  in  the  final
               linking stage.

       -o outfile
               Send output to outfile.

       -trapuv Have f2c generate code to trap uninitialized values.

               Pass  the argument[s] argi through to the subprocess x, where x
               can assume one of the following values: f for the f2c  step,  p
               for  the  preprocessing  step,  c for the C compiler, a for the
               assembler (this is actually passed to the C compiler, too), and
               l  for  the  linker.   As  an  example, defining a preprocessor
               constant  for  the  C  compilation  step  would  be  done  with
               -Wc,-DUNIX=1.   Specifying  the  -f option to f2c would be done
               via -Wf,-f.

       f2c option
               fort77 passes through almost all f2c options: -C, -U,  -u,  -a,
               -E, -h, -P, -R, -r, -z, -I2, -I4, -onetrip, -!c, -!l, -!P, -!R,
               -ext, -!bs, -W[n], -trapuv, -w8, -r8 and -w66.

       gcc options
               The following options are passed through to gcc: -f*, -W*, -U*,
               -A*, -m*, -S, -E, -v, -x, -pipe, -o, -I, -V, -b*, -p, -pg.

       linker option
               The  options  passed to the linking stage are -static, -shared,
               -v, -V, and -symbolic.


       To make debugging work, you need to set a breakpoint at  MAIN__  before
       you start.

       f2c  This  script automatically supplies the -I.  option to f2c.  Older
       versions of f2c may not support this.

       This script is for the interaction  of  gcc  and  f2c;  using  it  with
       another compiler will probably require modification.

       The  fort77  script  does  not  strictly conform to Posix.2, because it
       acceppts long options with one leading slash.  This  is  done  for  gcc


       f2c(1), cc(1), as(1), ld(1)


       Thomas Koenig,