home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / f2csrc.zip / f2csrc / fc < prev    next >
Text File  |  1994-02-07  |  4KB  |  221 lines
  1. #!/bin/sh
  2. PATH=/v/bin:/bin:/usr/bin
  3. # f77-style shell script to compile and load fortran, C, and assembly codes
  4.  
  5. #    usage:    f77 [-g] [-O] [-o absfile] [-c] files [-l library]
  6.  
  7. #        -o objfile    Override default executable name a.out.
  8.  
  9. #        -c        Do not call linker, leave relocatables in *.o.
  10.  
  11. #        -C        Check that subscripts are in bounds.
  12.  
  13. #        -S        leave assembler output on file.s
  14.  
  15. #        -l library    (passed to ld).
  16.  
  17. #        -u        complain about undeclared variables
  18.  
  19. #        -w        omit all warning messages
  20.  
  21. #        -w66        omit Fortran 66 compatibility warning messages
  22.  
  23. #        files        FORTRAN source files ending in .f .
  24. #                FORTRAN with cpp preprocessor directives
  25. #                    ending in .F .
  26. #                C source files ending in .c .
  27. #                Assembly language files ending in .s .
  28. #                efl source files ending in .e .
  29. #                RATFOR files ending in .r .
  30.  
  31. #        -D def        passed to C compiler (for .c files)
  32. #                or to cpp (for .F files)
  33.  
  34. #        -I includepath    passed to C compiler (for .c files)
  35. #                or to cpp (for .F files)
  36.  
  37. #        -Ntnnn        allow nnn entries in table t
  38.  
  39. s=/tmp/stderr_$$
  40. t=/tmp/f77_$$.o
  41. CC=${CC_f2c:-'/usr/bin/cc -common'}
  42. EFL=${EFL:-/v/bin/efl}
  43. EFLFLAGS=${EFLFLAGS:-'system=portable deltastno=10'}
  44. RATFOR=${RATFOR:-/usr/bin/ratfor}
  45. RFLAGS=${RFLAGS:-'-6&'}
  46. F2C=${F2C:-/v/bin/f2c}
  47. F2CFLAGS=${F2CFLAGS:='-ARw8 -Nn802'}
  48. CPP=${CPP:-/lib/cpp}
  49. rc=0
  50. trap "rm -f $s $t; exit \$rc" 0
  51. lib=/lib/num/lib.lo
  52. OUTF=a.out
  53. cOPT=1
  54. set -- `getopt cCD:gI:N:Oo:Suw6 "$@"`
  55. case $? in 0);; *) exit 1;; esac
  56. CPPFLAGS=
  57. while
  58.     test X"$1" != X--
  59. do
  60.     case "$1"
  61.     in
  62.     -C)    F2CFLAGS="$F2CFLAGS -C"
  63.         shift;;
  64.  
  65.     -c)    cOPT=0
  66.         shift
  67.         ;;
  68.  
  69.     -D)    CPPFLAGS="$CPPFLAGS -D$2"
  70.         shift 2
  71.         ;;
  72.  
  73.     -g)    CFLAGS="$CFLAGS -g"
  74.         F2CFLAGS="$F2CFLAGS -g"
  75.         shift;;
  76.  
  77.     -I)    CPPFLAGS="$CPPFLAGS -I$2"
  78.         shift 2
  79.         ;;
  80.  
  81.     -o)    OUTF=$2
  82.         shift 2
  83.         ;;
  84.  
  85.     -O)    case $2 in -1) O=-O1;; -2) O=-O2;; -3) O=-O3;; *) O=-O;; esac
  86.         case $O in -O);; *) shift;; esac
  87.         CFLAGS="$CFLAGS $O"
  88.         shift
  89.         ;;
  90.  
  91.     -u)    F2CFLAGS="$F2CFLAGS -u"
  92.         shift
  93.         ;;
  94.  
  95.     -w)    F2CFLAGS="$F2CFLAGS -w"
  96.         case $2 in -6) F2CFLAGS="$F2CFLAGS"66; shift
  97.             case $2 in -6) shift;; esac;; esac
  98.         shift
  99.         ;;
  100.  
  101.     -N)    F2CFLAGS="$F2CFLAGS $1""$2"
  102.         shift 2
  103.         ;;
  104.  
  105.     -S)    CFLAGS="$CFLAGS -S"
  106.         cOPT=0
  107.         shift
  108.         ;;
  109.  
  110.     *)
  111.         echo "invalid parameter $1" 1>&2
  112.         shift
  113.         ;;
  114.     esac
  115. done
  116. shift
  117. while
  118.     test -n "$1"
  119. do
  120.     case "$1"
  121.     in
  122.     *.[fF])
  123.         case "$1" in *.f) f=".f";; *.F) f=".F";; esac
  124.         case "$1" in
  125.             *.f)    b=`basename $1 .f`
  126.                 $F2C $F2CFLAGS $1
  127.                 rc=$?
  128.                 ;;
  129.             *.F)    b=`basename $1 .F`
  130.                 $CPP $CPPFLAGS $1 >$b.i
  131.                 rc=$?
  132.                 case $rc in 0)
  133.                     $F2C $F2CFLAGS <$b.i >$b.c
  134.                     rc=$?
  135.                     ;;esac
  136.                 rm $b.i
  137.                 ;;
  138.             esac
  139.         case $rc in 0);; *) exit $rc;; esac
  140.                 $CC -c $CFLAGS $b.c 2>$s
  141.         rc=$?
  142.         sed '/parameter .* is not referenced/d;/warning: too many parameters/d' $s 1>&2
  143.         case $rc in 0);; *) exit;; esac
  144.         OFILES="$OFILES $b.o"
  145.         rm $b.c
  146.         case $cOPT in 1) cOPT=2;; esac
  147.         shift
  148.         ;;
  149.     *.e)
  150.         b=`basename $1 .e`
  151.         $EFL $EFLFLAGS $1 >$b.f
  152.         case $? in 0);; *) exit;; esac
  153.         $F2C $F2CFLAGS $b.f
  154.         case $? in 0);; *) exit;; esac
  155.                 $CC -c $CFLAGS $b.c
  156.         case $? in 0);; *) exit;; esac
  157.         OFILES="$OFILES $b.o"
  158.         rm $b.[cf]
  159.         case $cOPT in 1) cOPT=2;; esac
  160.         shift
  161.         ;;
  162.     *.r)
  163.         b=`basename $1 .r`
  164.         $RATFOR $RFLAGS $1 >$b.f
  165.         case $? in 0);; *) exit;; esac
  166.         $F2C $F2CFLAGS $b.f
  167.         case $? in 0);; *) exit;; esac
  168.         $CC -c $CFLAGS $b.c
  169.         case $? in 0);; *) exit;; esac
  170.         OFILES="$OFILES $b.o"
  171.         rm $b.[cf]
  172.         case $cOPT in 1) cOPT=2;; esac
  173.         shift
  174.         ;;
  175.     *.s)
  176.         echo $1: 1>&2
  177.         OFILE=`basename $1 .s`.o
  178.         ${AS:-/usr/bin/as} -o $OFILE $AFLAGS $1
  179.         case $? in 0);; *) exit;; esac
  180.         OFILES="$OFILES $OFILE"
  181.         case $cOPT in 1) cOPT=2;; esac
  182.         shift
  183.         ;;
  184.     *.c)
  185.         echo $1: 1>&2
  186.         OFILE=`basename $1 .c`.o
  187.                 $CC -c $CPPFLAGS $CFLAGS $1
  188.         rc=$?; case $rc in 0);; *) exit;; esac
  189.         OFILES="$OFILES $OFILE"
  190.         case $cOPT in 1) cOPT=2;; esac
  191.         shift
  192.         ;;
  193.     *.o)
  194.         OFILES="$OFILES $1"
  195.         case $cOPT in 1) cOPT=2;; esac
  196.         shift
  197.         ;;
  198.     -l)
  199.         OFILES="$OFILES -l$2"
  200.         shift 2
  201.         case $cOPT in 1) cOPT=2;; esac
  202.         ;;
  203.     -l*)
  204.         OFILES="$OFILES $1"
  205.         shift
  206.         case $cOPT in 1) cOPT=2;; esac
  207.         ;;
  208.     -o)
  209.         OUTF=$2; shift 2;;
  210.     *)
  211.         OFILES="$OFILES $1"
  212.         shift
  213.         case $cOPT in 1) cOPT=2;; esac
  214.         ;;
  215.     esac
  216. done
  217.  
  218. case $cOPT in 2) $CC -o $OUTF -u MAIN__ $OFILES -lf2c -lm;; esac
  219. rc=$?
  220. exit $rc
  221.