NAME

       fortc - Unidata utility to generate fortran-compatible C code

SYNOPSIS

       fortc [-L LibDir] [-O OpSys] file

DESCRIPTION

       fortc Reads C code from `file', transforms it into FORTRAN compatible code, and then writes the result to
       standard output.  The transformation is operating-system dependent because there are no standards in this
       matter.

       The  target  operating-system  can  be  specified in several ways.  If the `-O' option is given, then the
       operating-system specified by its argument is used; otherwise, if the environmental variable `OS' exists,
       then  the  operating-system  specified  by it's value is used; otherwise, the default operating-system --
       determined at installation time -- is used.

       Global names that are not function definitions but that are to be accessible  from  both  C  and  FORTRAN
       should be enclosed by the `FC_NAME()' macro:

           extern int FC_NAME(foo)(void);  /* FORTRAN function */

           extern struct {
               float f;
               int   i;
           } FC_NAME(comblk);              /* FORTRAN common block */

           cfoo()
           {
               return FC_NAME(foo)();      /* call FORTRAN function */
           }

       C functions which are to be called from FORTRAN are written as follows:

           int
           /*FORTRAN*/
           foo(
               character        pathname,    /* file name of new file */
               real             amount,      /* amount to frobdicate by */
               doubleprecision  dbl,         /* amount to tizzle by */
               void function    errf,        /* error routine */
               integer          rcode        /* returned error code */)
           {
           ...

       or, equivalently,

              int
              /*FORTRAN*/
              foo(char* pathname, float* amount, double* dbl,
                  void (*errf)(), int* rcode)
              {
              ...

       The points to note in writing FORTRAN-compatible functions are:

       1. Functions to be transformed are marked by a proceeding `/*FORTRAN*/' comment, which must appear on the
          line prior to the function name.  Any return-type declarations must proceed the comment.

       2. The formal parameters must be declared within function parentheses and be separated by commas.

       3. The formal parameters are restricted to the following types:

           character or char*
                   For Fortran character-variables.

           doubleprecision or double*"
                   For double-precision floating-point values.

           real or float*
                   For single-precision floating-point values.

           integer or int*
                   For integer values.

           type function name or type (*name)()
                   For functions returning type `type'.

       4. There must be nothing important after the opening brace, `{', and on the same line.

       The functions should be written using variables with the same names as the formal  parameters,  and  with
       the  same  semantics.   In  the  case  of  formal parameters of type `character' (i.e. Fortran character-
       variables), a variable with the same name will exist and will be of type `char*'.  In addition, for  each
       character-variable  argument, a local variable of integral type will be created and its value will be the
       size of the associated character-variable.  The name of this variable will be the name of the  associated
       character variable with "_len" appended (e.g. "pathname_len").  These length variables may be used in the
       function just like any other variable.

       For example, under SunOS the previous function would become (if it is contained in the file `foo.src'):

           #line 1 "foo.src"
           unsigned int
           #line 2 "foo.src"
           foo_(pathname, amount, errf, rcode, pathname_len)
               char      *pathname;
               int        pathname_len;
               float     *amount;
               void       (*errf)();
               int       *rcode;
           {
           #line 9 "foo.src"

       Note that 1) preprocessor line directives have been added; 2) the function name has been suffixed with an
       underscore; and 3) a formal parameter, `pathname_len', has been created.

       Under UNICOS, the same file would become

           #include <fortran.h>
           #line 1  "foo.src"
           unsigned int
           #line 2  "foo.src"
           FOO(pathnamed, amount, errf, rcode)
               _fcd       pathnamed;
               float     *amount;
               void       (*errf)();
               int       *rcode;
           {
               char      *pathname  = _fcdtocp (pathnamed);
               unsigned   pathname_len   = _fcdlen (pathnamed);
           #line 9  "foo.src"

       Note,  in  particular,  the  additional `#include <fortran.h>' and the creation and initialization of the
       local variables `pathname' and `pathname_len'.

       This utility is implemented as a script and uses the system-supplied utilities sed(1) and m4(1).

OPTIONS

       -L LibDir"
               Defines the directory containing the  `fortc'  library  files.   The  default  is  determined  at
               installation time.

       -O OpSys
               Defines  the  operating-system  as  OpSys.   Known  values include `aix', `convexos', `domainos',
               `hpux', `irix', `msoft', `next-absoft', `newsos', `sunos', `ultrix',  `unicos',  and  `vms'.   To
               allow for greater flexibility, the known values may have any suffix (e.g. `sunos_4.1').

ENVIRONMENT

       OS      Defines  the  operating system if the `-O' option is not specified.  Known values are the same as
               the -O option.

FILES

       In the following, `LIBDIR' is the default library directory determined at installation time.

       LIBDIR/pre.sed
              A pre-m4, sed(1) script for transforming the input source into m4(1) source.

       LIBDIR/post.sed
              A post-m4, sed(1) script for transforming the m4(1) output into C code.

       LIBDIR/common.m4
              An m4(1) source common to all Fortran-calling-C implementations.

       LIBDIR/*.m4
              Operating-system-specific m4(1) sources.

BUGS

       The names of  automatically  generated  variables  might  conflict  with  those  of  other,  pre-existing
       variables.

SEE ALSO

       sed(1), m4(1).