![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to revs CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / f2c / doc|
Return to revs CVS log | Up to [Research Unix] / researchv10no / cmd / f2c / doc |
1.1 ! root 1: .EQ ! 2: define f2c % "f\|2c" % ! 3: define F2c % "F\^2c" % ! 4: define libF77 % "libF77" % ! 5: define libI77 % "libI77" % ! 6: .EN ! 7: .SH ! 8: Suggested rewordings... ! 9: ! 10: Bottom of p. 4: ! 11: .PP ! 12: A Fortran routine containing $n$ \f(CWentry\fR statements ! 13: is turned into $n^+^2$ C functions, a big one containing ! 14: the translation of everything but the \f(CWentry\fR statements, ! 15: and $n^+^1$ little ones that invoke the big one. Each little ! 16: one passes a different integer to the big one to tell ! 17: it where to begin; the big one starts with a switch ! 18: that branches to the code for the appropriate entry. ! 19: The Fortran program ! 20: ! 21: .SH ! 22: Add to end of \(sc3: ! 23: .PP ! 24: $F2c$ assumes the services of the support libraries $libF77$ and $libI77$. ! 25: Among other things, libF77 contains a C main routine that arranges ! 26: for files to be closed automatically when the Fortran program stops ! 27: and arranges for an error message to be printed if a floating-point ! 28: exception occurs. The C main routine invokes the Fortran main program, ! 29: which is called ! 30: .CW MAIN_\|_ . ! 31: ! 32: ! 33: .SH ! 34: Revision of \(sc 4: ! 35: ! 36: ! 37: .SH ! 38: 4. MAINTENANCE and PORTABILITY ! 39: .PP ! 40: Although we have tried to make $f2c$'s output reasonably readable, ! 41: our goal of strict compatibility with $f77$ implies some nasty ! 42: looking conversions. Input/output statements, in particular, ! 43: generally get expanded into ! 44: a series of calls on routines in $libI77$, $f77$'s I/O library. ! 45: Thus the C output of $f2c$ would probably be something of a nightmare ! 46: to maintain as C; it would be much more sensible to maintain the original ! 47: Fortran, translating it anew each time it changed. Some commercial ! 48: vendors seek to perform translations yielding C that one ! 49: might reasonably maintain directly; these translations generally ! 50: require some manual intervention. ! 51: . \"Appendix B lists the vendors ! 52: . \"of whom we are aware; omitted vendors are invited to inform us of ! 53: . \"their existence, so we may include them in updated versions of ! 54: . \"Appendix B. ! 55: .PP ! 56: The Pfort Verifier ! 57: .[ [ ! 58: Ryder 1974 ! 59: .]] ! 60: was a useful tool for catching errors in calling sequences ! 61: of Fortran 66 programs. $F2c$ combined with $cyntax(1)$ or $lint(1)$ ! 62: .[ [ ! 63: UNIX ninth edition manual ! 64: .]] ! 65: provides a similar capability for Fortran 77 programs. ! 66: .PP ! 67: There are two portability issues in using $f2c$: ! 68: the portability of the converter $f2c$ itself ! 69: and that of the C programs it creates. ! 70: .PP ! 71: The converter itself is reasonably portable and has run successfully on Apollo, ! 72: Cray, IBM, MIPS, SGI, Sun and DEC VAX equipment. ! 73: However, we shall see that the C it produces may not be portable due to ! 74: subtle storage management issues in Fortran 77. ! 75: In any case, the C output of $f2c$ will run fine, at least if ! 76: the \f(CW\(miW\fIn\fR option (see the Appendix) is used to set the ! 77: number of characters per word correctly, and if C ! 78: .CW double ! 79: values may fall on an odd-word boundary. ! 80: .PP ! 81: The Fortran 77 standard says that \f(CWComplex\fP and \f(CWDouble Precision\fP ! 82: objects occupy two ``units'' of space while other non-character data types ! 83: occupy one ``unit.'' ! 84: It may be necessary to edit the header file ! 85: .CW f2c.h ! 86: to make these assumptions hold, if possible. ! 87: On the Cray, for example, ! 88: .CW float ! 89: and ! 90: .CW double ! 91: are the same C types, and Fortran double precision, if ! 92: available, would correspond to the C type ! 93: .CW "long double" . ! 94: In this case, changing the definition of ! 95: .CW doublereal ! 96: in ! 97: .CW f2c.h ! 98: from ! 99: .P1 ! 100: typedef double doublereal; ! 101: .P2 ! 102: to ! 103: .P1 ! 104: typedef long double doublereal; ! 105: .P2 ! 106: would be appropriate. For the Think C compiler on the ! 107: Macintosh, on the other hand, this line would need to become ! 108: .P1 ! 109: typedef short double doublereal; ! 110: .P2 ! 111: .PP ! 112: If your C compiler predefines symbols that could clash with ! 113: translated Fortran variable names, then you should also ! 114: add appropriate ! 115: .CW #undef ! 116: lines to ! 117: .CW f2c.h . ! 118: The current default ! 119: .CW f2c.h ! 120: provides the following ! 121: .CW #undef ! 122: lines: ! 123: .P1 ! 124: #undef cray ! 125: #undef gcos ! 126: #undef mc68010 ! 127: #undef mc68020 ! 128: #undef mips ! 129: #undef pdp11 ! 130: #undef sgi ! 131: #undef sparc ! 132: #undef sun ! 133: #undef sun2 ! 134: #undef sun3 ! 135: #undef sun4 ! 136: #undef u370 ! 137: #undef u3b ! 138: #undef u3b2 ! 139: #undef u3b5 ! 140: #undef unix ! 141: #undef vax ! 142: .P2 ! 143: .PP ! 144: As an extension to the Fortran 77 Standard, $f2c$ ! 145: allows noncharacter variables to be initialized with character ! 146: data. This extension is inherently nonportable, as the number ! 147: of characters storable per ``unit'' varies from machine to machine. ! 148: Since 32 bit machines are the most plentiful, $f2c$ ! 149: assumes 4 characters per Fortran ``unit'', but this assumption ! 150: can be overridden by the \f(CW\(miW\fIn\fR command-line option. ! 151: For example, ! 152: .CW \(miW8 ! 153: is appropriate for C that is to be run on Cray computers, ! 154: since Crays store 8 characters per word. ! 155: An example is helpful here: the Fortran ! 156: .P1 ! 157: .so /n/pipe/z7/nlsw7/f77.c/doc/tm/data.holl.f ! 158: .P2 ! 159: turns into ! 160: .P1 ! 161: .so /n/pipe/z7/nlsw7/f77.c/doc/tm/data.holl.c ! 162: .P2 ! 163: (Some use of ! 164: .CW i , ! 165: e.g. ``\(CWi=1\fR'', is necessary or $f2c$ ! 166: will see that ! 167: .CW i ! 168: is not used and will not initialize it.) If the target ! 169: machine were a Cray and the string were ! 170: .CW 'abcdefgh' ! 171: or \f(CW"abcdefhg"\fR, ! 172: then the Fortran would run fine, but the C produced by $f2c$ would only ! 173: store \f(CW"abcd"\fR ! 174: in i, $4$ being the default number of characters per word. ! 175: The $f2c$ command-line option ! 176: .CW \(miW8 ! 177: gives the correct initialization for a Cray. ! 178: .PP ! 179: The initialization above is clumsy, using $4$ separate characters. ! 180: Using the option ! 181: .CW -A , ! 182: for ANSI, produces ! 183: .CW "abcd" ; ! 184: see the Appendix. ! 185: .PP ! 186: The above examples explain why the Fortran 77 standard excludes ! 187: Hollerith data statements: the number of characters per word is ! 188: not specified and hence such code is not portable even in Fortran. ! 189: (Fortran that conservatively assumes only $1$ or $2$ characters per word is ! 190: portable but messy). ! 191: .PP ! 192: Some systems require that C values of type ! 193: .CW double ! 194: be aligned on a double-word boundary. Fortran ! 195: .CW common ! 196: and ! 197: .CW equivalence ! 198: statements may require some C ! 199: .CW double ! 200: values to be aligned on an odd-word boundary. ! 201: On systems where double-word alignment is required, ! 202: C compilers pad structures, if necessary, to arrange ! 203: for the right alignment. Often such padding has no effect on ! 204: the validity of $f2c$'s ! 205: translation, but using ! 206: .CW common ! 207: or ! 208: .CW equivalence , ! 209: it is easy to contrive examples in which ! 210: the translated C works incorrectly. ! 211: $F2c$ issues a warning message when double-word alignment may ! 212: cause trouble, but it makes no attempt to circumvent this trouble. ! 213: .PP ! 214: Long decimal strings in \f(CWdata\fP statements are passed to C unaltered. ! 215: However, expressions involving long decimal strings are rounded ! 216: in a machine dependent manner. ! 217: The Fortran ! 218: .P1 ! 219: .so /n/pipe/z7/nlsw7/f77.c/doc/tm/longpow.f ! 220: .P2 ! 221: yields the C ! 222: .P1 ! 223: .so /n/pipe/z7/nlsw7/f77.c/doc/tm/longpow.c ! 224: .P2 ! 225: when $f2c$ runs on a VAX 8550. ! 226: .PP ! 227: ANSI C compilers require that all but one instance of any entity with external scope, ! 228: such as the \f(CWstruct\fPs into which $f2c$ translates \f(CWcommon\fP, ! 229: be declared \f(CWextern\fP and that exactly one declaration should define the entity, ! 230: i.e., not be declared \f(CWextern\fP. ! 231: Older C compilers have no such restriction. ! 232: To be compatible with ANSI usage, the $f2c$ ! 233: command-line option ! 234: .CW -ec ! 235: causes the \f(CWstruct\fP corresponding ! 236: to an uninitialized \f(CWcommon\fP region to be declared \f(CWextern\fP ! 237: and makes a ! 238: .CW union ! 239: of all successive declarations of that ! 240: \f(CWcommon\fP region into a defining declaration placed in a file with the ! 241: name \f(CWcname_com.c\fR, where ! 242: .CW cname ! 243: is the name of the \f(CWcommon\fP region. ! 244: For example, the Fortran ! 245: .P1 ! 246: .so /n/pipe/z7/nlsw7/f77.c/doc/tm/mainsam.f ! 247: .P2 ! 248: when converted by \f(CWf2c -ec\fP produces ! 249: .P1 ! 250: .so /n/pipe/z7/nlsw7/f77.c/doc/tm/mainsam.c ! 251: .P2 ! 252: as well as the file \f(CWcmname_com.c\fR: ! 253: .P1 ! 254: .so /n/pipe/z7/nlsw7/f77.c/doc/tm/cmname_com.c ! 255: .P2 ! 256: The files ! 257: .CW *_com.c ! 258: may be compiled into a library ! 259: against which one can load to satisfy overly fastidious ANSI C compilers. ! 260: ! 261: ! 262: .[ ! 263: $LIST$ ! 264: .] ! 265: ! 266: ! 267: \fISource for the above is ! 268: \f(CW/n/pipe/usr/dmg/f2c/doc/revs\fR
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.