Annotation of researchv10no/cmd/f2c/f2c.h, revision 1.1.1.1

1.1       root        1: /* f2c.h  --  Standard Fortran to C header file */
                      2: 
                      3: /**  barf  [ba:rf]  2.  "He suggested using FORTRAN, and everybody barfed."
                      4: 
                      5:        - From The Shogakukan DICTIONARY OF NEW ENGLISH (Second edition) */
                      6: 
                      7: #ifndef F2C_INCLUDE
                      8: #define F2C_INCLUDE
                      9: 
                     10: typedef long int integer;
                     11: typedef char *address;
                     12: typedef short int shortint;
                     13: typedef float real;
                     14: typedef double doublereal;
                     15: typedef struct { real r, i; } complex;
                     16: typedef struct { doublereal r, i; } doublecomplex;
                     17: typedef long int logical;
                     18: typedef short int shortlogical;
                     19: typedef char logical1;
                     20: typedef char integer1;
                     21: 
                     22: #define TRUE_ (1)
                     23: #define FALSE_ (0)
                     24: 
                     25: /* Extern is for use with -E */
                     26: #ifndef Extern
                     27: #define Extern extern
                     28: #endif
                     29: 
                     30: /* I/O stuff */
                     31: 
                     32: #ifdef f2c_i2
                     33: /* for -i2 */
                     34: typedef short flag;
                     35: typedef short ftnlen;
                     36: typedef short ftnint;
                     37: #else
                     38: typedef long flag;
                     39: typedef long ftnlen;
                     40: typedef long ftnint;
                     41: #endif
                     42: 
                     43: /*external read, write*/
                     44: typedef struct
                     45: {      flag cierr;
                     46:        ftnint ciunit;
                     47:        flag ciend;
                     48:        char *cifmt;
                     49:        ftnint cirec;
                     50: } cilist;
                     51: 
                     52: /*internal read, write*/
                     53: typedef struct
                     54: {      flag icierr;
                     55:        char *iciunit;
                     56:        flag iciend;
                     57:        char *icifmt;
                     58:        ftnint icirlen;
                     59:        ftnint icirnum;
                     60: } icilist;
                     61: 
                     62: /*open*/
                     63: typedef struct
                     64: {      flag oerr;
                     65:        ftnint ounit;
                     66:        char *ofnm;
                     67:        ftnlen ofnmlen;
                     68:        char *osta;
                     69:        char *oacc;
                     70:        char *ofm;
                     71:        ftnint orl;
                     72:        char *oblnk;
                     73: } olist;
                     74: 
                     75: /*close*/
                     76: typedef struct
                     77: {      flag cerr;
                     78:        ftnint cunit;
                     79:        char *csta;
                     80: } cllist;
                     81: 
                     82: /*rewind, backspace, endfile*/
                     83: typedef struct
                     84: {      flag aerr;
                     85:        ftnint aunit;
                     86: } alist;
                     87: 
                     88: /* inquire */
                     89: typedef struct
                     90: {      flag inerr;
                     91:        ftnint inunit;
                     92:        char *infile;
                     93:        ftnlen infilen;
                     94:        ftnint  *inex;  /*parameters in standard's order*/
                     95:        ftnint  *inopen;
                     96:        ftnint  *innum;
                     97:        ftnint  *innamed;
                     98:        char    *inname;
                     99:        ftnlen  innamlen;
                    100:        char    *inacc;
                    101:        ftnlen  inacclen;
                    102:        char    *inseq;
                    103:        ftnlen  inseqlen;
                    104:        char    *indir;
                    105:        ftnlen  indirlen;
                    106:        char    *infmt;
                    107:        ftnlen  infmtlen;
                    108:        char    *inform;
                    109:        ftnint  informlen;
                    110:        char    *inunf;
                    111:        ftnlen  inunflen;
                    112:        ftnint  *inrecl;
                    113:        ftnint  *innrec;
                    114:        char    *inblank;
                    115:        ftnlen  inblanklen;
                    116: } inlist;
                    117: 
                    118: #define VOID void
                    119: 
                    120: union Multitype {      /* for multiple entry points */
                    121:        shortint h;
                    122:        integer i;
                    123:        real r;
                    124:        doublereal d;
                    125:        complex c;
                    126:        doublecomplex z;
                    127:        };
                    128: 
                    129: typedef union Multitype Multitype;
                    130: 
                    131: typedef long Long;     /* No longer used; formerly in Namelist */
                    132: 
                    133: struct Vardesc {       /* for Namelist */
                    134:        char *name;
                    135:        char *addr;
                    136:        ftnlen *dims;
                    137:        int  type;
                    138:        };
                    139: typedef struct Vardesc Vardesc;
                    140: 
                    141: struct Namelist {
                    142:        char *name;
                    143:        Vardesc **vars;
                    144:        int nvars;
                    145:        };
                    146: typedef struct Namelist Namelist;
                    147: 
                    148: #define abs(x) ((x) >= 0 ? (x) : -(x))
                    149: #define dabs(x) (doublereal)abs(x)
                    150: #define min(a,b) ((a) <= (b) ? (a) : (b))
                    151: #define max(a,b) ((a) >= (b) ? (a) : (b))
                    152: #define dmin(a,b) (doublereal)min(a,b)
                    153: #define dmax(a,b) (doublereal)max(a,b)
                    154: 
                    155: /* procedure parameter types for -A and -C++ */
                    156: 
                    157: #define F2C_proc_par_types 1
                    158: #ifdef __cplusplus
                    159: typedef int /* Unknown procedure type */ (*U_fp)(...);
                    160: typedef shortint (*J_fp)(...);
                    161: typedef integer (*I_fp)(...);
                    162: typedef real (*R_fp)(...);
                    163: typedef doublereal (*D_fp)(...), (*E_fp)(...);
                    164: typedef /* Complex */ VOID (*C_fp)(...);
                    165: typedef /* Double Complex */ VOID (*Z_fp)(...);
                    166: typedef logical (*L_fp)(...);
                    167: typedef shortlogical (*K_fp)(...);
                    168: typedef /* Character */ VOID (*H_fp)(...);
                    169: typedef /* Subroutine */ int (*S_fp)(...);
                    170: #else
                    171: typedef int /* Unknown procedure type */ (*U_fp)();
                    172: typedef shortint (*J_fp)();
                    173: typedef integer (*I_fp)();
                    174: typedef real (*R_fp)();
                    175: typedef doublereal (*D_fp)(), (*E_fp)();
                    176: typedef /* Complex */ VOID (*C_fp)();
                    177: typedef /* Double Complex */ VOID (*Z_fp)();
                    178: typedef logical (*L_fp)();
                    179: typedef shortlogical (*K_fp)();
                    180: typedef /* Character */ VOID (*H_fp)();
                    181: typedef /* Subroutine */ int (*S_fp)();
                    182: #endif
                    183: /* E_fp is for real functions when -R is not specified */
                    184: typedef VOID C_f;      /* complex function */
                    185: typedef VOID H_f;      /* character function */
                    186: typedef VOID Z_f;      /* double complex function */
                    187: typedef doublereal E_f;        /* real function with -R not specified */
                    188: 
                    189: /* undef any lower-case symbols that your C compiler predefines, e.g.: */
                    190: 
                    191: #ifndef Skip_f2c_Undefs
                    192: #undef cray
                    193: #undef gcos
                    194: #undef mc68010
                    195: #undef mc68020
                    196: #undef mips
                    197: #undef pdp11
                    198: #undef sgi
                    199: #undef sparc
                    200: #undef sun
                    201: #undef sun2
                    202: #undef sun3
                    203: #undef sun4
                    204: #undef u370
                    205: #undef u3b
                    206: #undef u3b2
                    207: #undef u3b5
                    208: #undef unix
                    209: #undef vax
                    210: #endif
                    211: #endif

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.