Common Lisp Package: FORTRAN-TO-LISP

The package holding all symbols need by the Fortran to Lisp converter

README:

FUNCTION

Public

F2CL (INPUT-FILE &KEY VERBOSE KEEP-TEMP-FILE (EXTENSION (OR *DEFAULT-LISP-EXTENSION* lisp)) OUTPUT-FILE PRUNE-LABELS INCLUDE-COMMENTS (AUTO-SAVE T) (RELAXED-ARRAY-DECLS T) (COERCE-ASSIGNS AS-NEEDED) (ARRAY-TYPE ARRAY ARRAY-TYPE-P) (ARRAY-SLICING T) (PACKAGE COMMON-LISP-USER) DECLAIM DECLARE-COMMON (FLOAT-FORMAT *READ-DEFAULT-FLOAT-FORMAT*) COMMON-AS-ARRAY COMMON-BLOCK-FILE COPY-ARRAY-PARAMETER PROMOTE-TO-DOUBLE &ALLOW-OTHER-KEYS)

Fortran to Common Lisp converter INPUT-FILE File containing Fortran code :OUTPUT-FILE File to contain Lisp code :VERBOSE verbose output. Default = NIL. :PRUNE-LABELS Prune unused labels. Default = NIL. :INCLUDE-COMMENTS Include Fortran comments in the Lisp output (May be buggy.) Default = NIL :AUTO-SAVE Variables in DATA statements are automatically SAVE'd. Default = T. :RELAXED-ARRAY-DECLS Declarations of array sizes are relaxed in formal parameters to functions. That is, any array length declarations are ignored if possible, like old Fortran used to. Default = T. :COERCE-ASSIGNS If T or :ALWAYS, all assignment statements automatically coerce the RHS to the appropriate type for the assignment. If NIL or :NEVER, coercion never happens. Otherwise, coercion happens as needed. The Default = :AS-NEEDED :EXTENSION The extension to use for the output file, if needed. Defaults to *DEFAULT-LISP-EXTENSION* or "lisp" :KEEP-TEMP-FILE If T, the temporary file is not deleted. Default = NIL. :ARRAY-TYPE The type of array f2cl should use. Should be :simple-array or :array. :ARRAY-SLICING When non-NIL, f2cl assumes that, whenever we do an array reference in a call to a subroutine or function, we are really passing a subarray to the routine instead of just the single value, unless f2cl knows the function takes a scalar arg that is not modified. :PACKAGE A string or symbol specifying what package the resulting code should be in. (Basically puts a (in-package <p>) at the top.) :DECLAIM Declaim compilation options (Basically puts a (declaim <declaim>) at the top.) :DECLARE-COMMON When non-NIL, any structures defintions for common blocks are defined here. Otherwise, the structures for the common blocks are expected to be defined elsewhere. :FLOAT-FORMAT Float format to use when printing the result. Default is *READ-DEFAULT-FLOAT-FORMAT* :COMMON-AS-ARRAY Common blocks are created as a set of arrays, and the common block variables are offsets into the arrays. This mimics Fortran common block layouts. Default = NIL. :COMMON-BLOCK-FILE If common blocks are to be declared, then each common block is written to a file whose name is the name of the common block, with the extension "cmn" :COPY-ARRAY-PARAMETER In some Fortran code an array of one type is passed to a routine expecting a different type. F2CL implements this by creating an array and copying the data. The default is not to copy since it is relatively slow. :PROMOTE-TO-DOUBLE Promote REAL and COMPLEX constants, variables, and arrays to REAL*8 and COMPLEX*16 types.

F2CL-COMPILE (FILENAME &REST ALL-KEYS &KEY ERROR-FILE (KEEP-LISP-FILE T) (OUTPUT-FILE (COMPILE-FILE-PATHNAME FILENAME)) PRUNE-LABELS INCLUDE-COMMENTS (AUTO-SAVE T) (RELAXED-ARRAY-DECLS T) (COERCE-ASSIGNS AS-NEEDED) (ARRAY-TYPE ARRAY) (ARRAY-SLICING T) (PACKAGE COMMON-LISP-USER) DECLAIM DECLARE-COMMON (FLOAT-FORMAT *READ-DEFAULT-FLOAT-FORMAT*) COMMON-AS-ARRAY COPY-ARRAY-PARAMETER PROMOTE-TO-DOUBLE &ALLOW-OTHER-KEYS)

Convert the Fortran to Common Lisp and compile the resulting Lisp file FILENAME File containing Fortran code :OUTPUT-FILE File to contain Lisp code :VERBOSE verbose output. Default = NIL. :PRUNE-LABELS Prune unused labels. Default = NIL. :INCLUDE-COMMENTS Include Fortran comments in the Lisp output (May be buggy.) Default = NIL :AUTO-SAVE Variables in DATA statements are automatically SAVE'd. Default = T. :RELAXED-ARRAY-DECLS Declarations of array sizes are relaxed in formal parameters to functions. Default = T. :COERCE-ASSIGNS If T or :ALWAYS, all assignment statements automatically coerce the RHS to the appropriate type for the assignment. If NIL or :NEVER, coercion never happens. Otherwise, coercion happens as needed. The Default = :AS-NEEDED :KEEP-LISP-FILE If T, the converted Lisp file is not deleted. Default = NIL. :ARRAY-TYPE The type of array f2cl should use. Should be 'simple-array or 'array. :ARRAY-SLICING When non-NIL, f2cl assumes that, whenever we do an array reference in a call to a subroutine or function, we are really passing a subarray to the routine instead of just the single value. :PACKAGE A string or symbol specifying what package the result code should be in. (Basically puts a (in-package <p>) at the top.) Default: :common-lisp-user. :DECLAIM Declaim compilation options (Basically puts a (declaim <declaim>) at the top.) :DECLARE-COMMON When non-NIL, any structures for common blocks are declared here. Otherwise, the structures for the common blocks are not declared. :FLOAT-FORMAT Float format to use when printing the result. Default is *READ-DEFAULT-FLOAT-FORMAT* :COMMON-AS-ARRAY Common blocks are created as a set of arrays, and the common block variables are offsets into the arrays. This mimics Fortran common block layouts. Default = NIL. :COMMON-BLOCK-FILE If common blocks are to be declared, then each common block is written to a file whose name is the name of the common block, with the extension "cmn" :COPY-ARRAY-PARAMETER In some Fortran code an array of one type is passed to a routine expecting a different type. F2CL implements this by creating an array and copying the data. The default is not to copy since it is relatively slow. :PROMOTE-TO-DOUBLE Promote REAL and COMPLEX constants, variables, and arrays to REAL*8 and COMPLEX*16 types.

Undocumented

F2CL-VERSION

Private

F2CL-FINFO-ARG-TYPES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

F2CL-FINFO-CALLS (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

F2CL-FINFO-RETURN-VALUES (INSTANCE)

@arg[extid]{A @class{extid}} @return[sytemid]{puri:uri or nil} Returns the System ID part of this External ID.

GET-VAR-TYPES (ARGLIST &KEY DECLARE-VARS)

Compute the types of each variable in ARGLIST and also an appropriate declaration for each variable, if DECLARE-VARS is non-NIL.

LISTN (A B)

Compute a list of integers from A to B, inclusive

SAVE-F2CL-FINFO (PATH)

Save *F2CL-FUNCTION-INFO* to PATH. This file can be reloaded later to provide the function information for f2cl to compile functions correctly

Undocumented

%MAKE-F2CL-FINFO (&KEY ((ARG-TYPES DUM22) NIL) ((RETURN-VALUES DUM23) NIL) ((CALLS DUM24) NIL))

ADJUST_NRS (LINE)

APPEND1 (L X)

ARRAY-LIST (ARRAY)

ATOMCAR (A)

ATOMCDR (A)

BINDING-VALUE (BINDING)

BRACKETS-CHECK (X)

BUILD_DECL_LIST (DECL_LIST TYPE DECL)

CHECK-RESERVED-LISP-NAMES (X)

CHECK-SUBPROGRAM-ARG-NAMES (X)

CHECK-TAGS-GO (X)

CHECK_NEW_VBLES (EXPRS)

CLEAR-F2CL-FINFO

COERCE-PARAMETER-ASSIGN (LHS RHS)

COERCE-RHS-TO-LHS (LHS-TYPE RHS-TYPE RHS)

CONCAT (&REST SYMS)

CONCAT-OPERATORS (X)

CONCATEN (X &REST MORE-ARGS)

COND-REMOVE-END-LABEL (FUN)

CONST (X N)

CONVERT-DATA-TYPE (X)

COPY-F2CL-FINFO (INSTANCE)

COUNT-GO-END (X)

CREATE-SYM-MACROS (PROG-BIT)

CREATE-SYM-MACROS-ARRAY (COMMON_VAR_DECLS)

DEFAULT-INT-P (VBLE)

DESTRUCT-DESCRIPTOR-LIST (X)

DIFF (X Y)

END-CDR (X)

END-DO-P (CHECKLIST DO-LABEL)

ENTRY-FUNCTIONS (ENTRY MAIN ARGS)

EXACT-MATCH (P D)

EXTRACT (ALPHA BETA)

EXTRACT-ATOMS (X)

F-TO-L (FILE)

F2CL-ARRAY-TOTAL-SIZE (BOUNDS)

SETFF2CL-FINFO-ARG-TYPES (NEW-VALUE INSTANCE)

SETFF2CL-FINFO-CALLS (NEW-VALUE INSTANCE)

F2CL-FINFO-P (OBJECT)

SETFF2CL-FINFO-RETURN-VALUES (NEW-VALUE INSTANCE)

FIND-ALL-LABELS (X)

FIND-DATA-VAR (VAR)

FIND-DECLARATIONS (FUN)

FIND-DO (MARGIN-LINE)

FIND-DUPLICATES (LIST)

FIND-GO-LABELS (X)

FIND-GOS (X)

FIND-QUOTE (K LINE OUT)

FIND-SYM (SYM CODE)

FIX-DO (CHECKLIST LABELS)

FIX-IFTHEN (CHECKLIST LABELS)

FIX-SLASHES (X)

FIX-STRUCTURE (CHECKLIST LABELS)

FIX-TAGBODIES (COND-EXPR)

FIXNUM-STRING (X)

FIXUP-EXPR-MUL (EXPR)

FIXUP-EXPRESSION (EXPR)

FIXUP-EXTERNAL-FUNCTION-REFS (P EXTERNS)

FIXUP-F2CL-LIB (TREE EXTERNAL-NAMES)

FIXUP-RELOP (EXPR)

FLATTEN-LIST (X)

FORTRAN-CONTAGION (T1 T2)

FORTRAN-DATA-INIT (TYPE DIMS DATA)

FORTRAN-TO-LISP (FILE OFILE &KEY DECLAIM PACKAGE OPTIONS)

GEN-APPEND (LIS X N)

GEN-LIST-SPLIT (BETA LIS)

GENERATE-CALL-TO-ROUTINE (ROUTINE ARGLIST &OPTIONAL RETURN)

GET-ARG-DECL (LIST-OF-ARGLISTS)

GET-FUN-ARG-TYPE (ARG)

GET-IMPLICIT-TYPE (VBLE)

GET-UPGRADED-FUN-ARG-TYPE (ARGS)

GET_ARRAY_TYPE (DECL VBLE-IS-FORMAL-ARG)

GET_FORMAT_STMT (LABEL)

GREATERP (X Y)

HANDLE-DATA-REPS (X)

HEAD-CHOP (BETA LIS)

ID-ASSGN-GO-TO (X)

ID-ASSGN-GO-TO-CORE (X)

ID-ASSGN-GOTO (X)

ID-ASSIGN (X)

ID-ASSIGNMENT (X)

ID-COMP-GO-TO (X)

ID-COMP-GOTO (X)

ID-COMP-GOTO-CORE (X)

ID-CONTINUE (X)

ID-DECLARATION (X)

ID-DEFINITION-ENTRY (X)

ID-DEFINITION-FUN (X)

ID-DEFINITION-FUN-TYPED (X)

ID-DEFINITION-PROG (X)

ID-DEFINITION-PROG-NAME (X)

ID-DEFINITION-SUB (X)

ID-DO-LOOP (X)

ID-DO-WHILE (LINE)

ID-ELSE (X)

ID-ELSE-IF (X)

ID-ELSEIF (X)

ID-END-DO (X)

ID-ENDIF (X)

ID-EXPRESSION (LARG)

ID-EXTENDED-DO (LINE)

ID-FACTOR (L)

ID-FACTOR1 (L)

ID-GO-TO (X)

ID-GOTO (X)

ID-IF (X)

ID-IF-GOTO (X)

ID-IF-THEN (X)

ID-IMPLICIT-DECL (X)

ID-LOGICAL (L)

ID-LOGICAL-AND (L)

ID-LOGICAL-NOT (L)

ID-PARAMETER (X)

ID-PAUSE (X)

ID-PREDICATE (X)

ID-RELATIONAL (L)

ID-RETURN (X)

ID-SUBROUTINE-CALL (X)

ID-TERM (L)

INSERT-DECLARATIONS (FORT-FUN)

INTRODUCE-CONTINUE (PROG-LIST)

LABEL-MATCHES-DOLABEL-P (LABEL DO_LABEL)

LABELP (X)

LESSP (X Y)

LINEREAD (STREAM)

LIST-ITP (LIS SIGNS)

LIST-SPLIT (BETA LIS)

LIST-SPLIT-BIN (OP LIS)

LIST-SPLIT-MULTI (OP LIS)

LIST-SPLIT-MULTI-STRING (OP LIS)

LOOKUP-ARRAY-BOUNDS (V)

LOOKUP-VBLE-TYPE (VBLE &OPTIONAL (DECLS *EXPLICIT_VBLE_DECLS*))

MAKE-CHAR-DECL (DECL TYPE)

MAKE-CHAR-INIT (DECL TYPE &OPTIONAL INIT)

MAKE-COMMON-BLOCK-INIT (COMM-BLOCKS COMM-DECLS KEY-PARAMS)

MAKE-COMMON-BLOCK-STRUCTURE (COMMON_VAR_DECLS)

MAKE-COMMON-BLOCK-VAR-INIT (VARLIST COMMON_VAR_DECLS)

MAKE-COMMON-BLOCK-VARS (VARLIST COMMON_VAR_DECLS)

MAKE-COMMON-BLOCK-VARS-AS-ARRAY (VARLIST COMMON_VAR_DECLS)

MAKE-DECLARATION (VBLE &KEY VBLE-IS-FORMAL-ARG PARAMETERP)

MAKE-F2CL-FINFO (&KEY ARG-TYPES RETURN-VALUES CALLS)

MAKE-FCN-DECL (FCN-LIST ARGLIST)

MAKE-INITIALISATION (VBLE)

MAKE-KEY-PARAM-DECLS (KEYS)

MAKE-LABEL (N)

MAKE-LABELS-FORM (LOCAL-VBLES VBLE-DECLS *DATA-INIT* BODY)

MAKE-SPECIAL-PROCLAMATION (VARS)

MAKE-SPECIAL-VAR-DECL (V)

MAKE_MAKE-ARRAY_STMT (DIMENS TYPE &OPTIONAL INIT VBLE)

MASSAGE-ARGLIST (ARGLIST INFO COPY-NAMES)

MATCH (TERM-1 TERM-2 BINDINGS)

MATCH-ATOMS (P D)

MATCH-ATOMS-LISTS (P D)

MATCH-INCLUDE (S)

MATCH-RESTRICT (P D)

MATCH-SEPARATED (SEPARATORS LIS)

MATCH-STORE (P D)

MATCH-STORE-ATOMS (P D)

MAYBE-CONVERT-ARRAY-REF-TO-SLICE (ARG-LIST FUN-NAME)

MAYBE-EXTEND-BINDINGS (VARIABLE VALUE BINDINGS)

MAYBE-NULLIFY-RETURNS (FCN-NAME ARG-NAMES)

MAYBE-PROMOTE-TYPE (TYPE)

MEMBERQ (X L)

MERGE-DATA-AND-SAVE-INITS (SAVES DATA)

MERGE-OPS (EXPR)

MULTIPLE-DO-LABELP (LABELNNN LABELS)

NEQUAL (X Y)

OPTIMIZE-F2CL/ (P)

OPTIMIZE-INTEGER-ARITHMETIC (P)

OUTPUT-COMMON-BLOCK (SPEC-PROC SPEC-DECL OUTPORT OUTPUT-PATH DECLAIM PACKAGE OPTIONS)

PARSE-ARRAYREF-OR-STMTFN (LHS RHS)

PARSE-ASSGN-GO-TO (X)

PARSE-ASSGN-GOTO (X)

PARSE-ASSIGN (X)

PARSE-ASSIGNMENT (X)

PARSE-CHAR-DECL (X)

PARSE-CLOSE (X)

PARSE-COMMON (COMMON-STATEMENT)

PARSE-COMP-GO-TO (X)

PARSE-COMP-GOTO (X)

PARSE-CYCLE (X)

PARSE-DATA (X)

PARSE-DATA-IMPLIED-DO (V L)

PARSE-DATA1 (V L)

PARSE-DECLARATION (X)

PARSE-DEFAULT-FORMAT-DESCRIPTOR (X)

PARSE-DLIST (X)

PARSE-DO-LOOP (X)

PARSE-ENTRY-DEFINITION (BINDINGS)

PARSE-EQUIVALENCE (X)

PARSE-EXIT (X)

PARSE-EXPRESSION (X &OPTIONAL (PARSE-LHS-P NIL))

PARSE-EXTERNAL (X)

PARSE-FORMAT (X)

PARSE-FORMAT-DESCRIPTOR-/

PARSE-FORMAT-DESCRIPTOR-A (A W)

PARSE-FORMAT-DESCRIPTOR-D (LEFT RIGHT)

PARSE-FORMAT-DESCRIPTOR-E (LEFT RIGHT)

PARSE-FORMAT-DESCRIPTOR-F (LEFT RIGHT)

PARSE-FORMAT-DESCRIPTOR-G (LEFT RIGHT)

PARSE-FORMAT-DESCRIPTOR-H (WIDTH STRING)

PARSE-FORMAT-DESCRIPTOR-I (A W)

PARSE-FORMAT-DESCRIPTOR-L (A W)

PARSE-FORMAT-DESCRIPTOR-LIST (A X)

PARSE-FORMAT-DESCRIPTOR-P (W)

PARSE-FORMAT-DESCRIPTOR-S (RIGHT)

PARSE-FORMAT-DESCRIPTOR-TR (S)

PARSE-FORMAT-DESCRIPTOR-X (W)

PARSE-FORMAT1 (FORMAT &OPTIONAL (NEWLINEP T))

PARSE-FUN-DEFINITION (BINDINGS)

PARSE-GOTO (BINDINGS)

PARSE-IF (X)

PARSE-IF-GOTO (BINDINGS)

PARSE-IF-THEN (X)

PARSE-IMPLICIT-DECL (X)

PARSE-IMPLIED-DO (DO-LIST)

PARSE-INTRINSIC (X)

PARSE-LOGL-OP (INPORT OUTPORT)

PARSE-NUMBER (PREV-CHAR CHAR OUTPORT)

PARSE-OPEN (X)

PARSE-OUTPUT-ARGUMENT (ARG)

PARSE-PARAMETER (X)

PARSE-PAUSE (X)

PARSE-PRINT (X)

PARSE-PROG-DEFINITION (BINDINGS)

PARSE-READ (X)

PARSE-RETURN (X)

PARSE-REWIND (X)

PARSE-SAVE (X)

PARSE-SUBR-DEFINITION (BINDINGS)

PARSE-SUBROUTINE-CALL (X)

PARSE-TYPED-FUN-DEFINITION (BINDINGS)

PARSE-WRITE (X)

PARSE_DIMENSION_SPECS (SPECS)

PARSE_FORMAT_DEST (DEST)

PARSE_UPPER_AND_LOWER_BOUNDS (BDS)

PATTERN-MATCH-AND-BIND (P D)

PLUS (&REST ARGS)

PPRINT-FDO (STREAM FDO-SEXP)

PPRINT-WITH-ARRAY-DATA (STREAM LIST)

PPRINT-WITH-MULTI-ARRAY-DATA (STREAM LIST)

PREPROCESS (FILE &KEY (OUTFILE-NAME NIL))

PREPROCESS-STREAMS (INPORT OUTPORT)

PRETTY-DECLS (DECLS)

PRINC-RESET (X &OPTIONAL (Y ))

PROCESS-DATA (X)

PROCESS-FORMAT-LINE (LINE)

PRUNE-LABELS (FUN)

READ-NUMBER-FROM-STREAM (X)

READ-SIX-CHARS (STREAM)

READSUBPROG-EXTRACT-FORMAT-STMTS (INPORT)

REDUCE-DATA-TYPE (X)

RELAX-ARRAY-DECL (DECLS)

REMOVE-*DATA-INIT*-VAR (VBLE)

REMOVE-F2CL-KEYS (KEYS)

REMOVE-FROM-TREE (S TREE)

REMOVE-PREFIX (X)

REMOVE-UNUSED-KEY-PARAMS (KEYS CODE)

REMOVE-UNUSED-SYM-MACROS (SYM-MLETS SYM-LETS PROG-BIT)

REPLACE-STR (STR)

REPLACE_LOGL_OPS (LINE)

RESTRICT-TEST (PREDICATES ARGUMENT)

REWRITE-DO-WHILE (LABEL1 LABEL2 LINE)

REWRITE-EXTENDED-DO (LABEL LINE)

SINGLE-MACRO-CHARACTER (STREAM CHAR)

SPECIAL-PRINT (X O)

SUB-STRING (X INDEX &OPTIONAL LEN)

SUB1 (X)

SUBSEQUENCE (SEQ START &OPTIONAL (END (LENGTH SEQ)))

SUBST-SPLICE (B A C)

SYM-IS-FUN-NAME (EXPR)

SYM-IS-NUMBER-P (EXPR)

SYMBOL-LISTP (X)

TAIL-CHOP (BETA LIS)

TPL-SUBPAIR (LX LY LIS)

TPL-SUBST (X Y LIS)

TRANSLATE-AND-WRITE-SUBPROG (PROG-LIST OUTPORT OUTPUT-PATH DECLAIM PACKAGE OPTIONS)

TRANSLATE-LABEL (LABEL)

TRANSLATE-LINE (X)

UNIFY (TERM-1 TERM-2 BINDINGS)

UPDATE-CALLED-FUNCTIONS-LIST (NAME ARGS)

UPDATE_CM_ARRAY_DIMS (VBLE DIMS)

VARIABLE-VALUE (VARIABLE BINDINGS)

VARIABLEP (V)

VBLE-DECLARED-TWICE-P (VBLE VBLE_DECLS)

VBLE-IS-ARRAY-P (V)

VERIFY-AND-GENERATE-EQUIVALENCES

WRITE-COMMENT-LINE (LINE OUTPORT)

MACRO

Private

Undocumented

WITH-FORTRAN-SYNTAX (&BODY BODY)

VARIABLE

Private

*ASSIGNED-VARIABLES*

List of variables that are assigned a value

*COERCE-ASSIGNMENTS*

This controls how assignment statements are coerced. If T or :always, assignments are always ccoerced. If NIL or :never, assignments are never coerced. For any other value, coercion is done only when needed.

*COMMENT-LINE-CHARACTERS*

A list of Fortran comment line characters

*COMMON-BLOCK-FILE-NAMES*

List of files created when :common-block-file is enabled

*COMMON-BLOCKS*

Hash table of all common blocks. The key is the name of the common block; the value is a list of all variables in the common block.

*COPY-ARRAY-PARAMETER*

If non-NIL, array arguments are copied if the actual array element type is not the same type as the declared array element type. This happens in some Fortran code where, say, an array of REALs is given to a routine expecting COMPLEXs. When *COPY-ARRAY-PARAMETER* is non-NIL, F2CL will copy the actual array to a temporary array of the correct type, pass that to the routine and then copy the result back to the original array. This is currently only implemented when passing a REAL/REAL*8 array to a COMPLEX/COMPLEX*16 array and vice-versa.

*DECLARE-COMMON-BLOCKS*

When non-NIL, the structures for any common blocks are defined in this file

*DEFAULT-LISP-EXTENSION*

The default extension (file type) for the output file name

*ENTRY-POINTS*

List of ENTRY points

*EQUIVALENCED-VARS*

List of equivalenced variables. Each entry of the list is a list consisting of the equivalenced variables.

*FORTRAN-EXTENSIONS*

A list of possible extensions for Fortran files.

*INTRINSIC-FUNCTION-NAMES*

A list of all the intrinsic functions in Fortran 77 (or 95)

*NON-INTRINSIC-FUNCTION-NAMES*

A list of all names that should not be recognized as an intrinsic function. This consists of formal parameters to subprograms that would other wise be recognized as an intrinsic and anything declared as external.

*PROMOTE-TO-DOUBLE*

If non-NIL, REAL and COMPLEX variables and arrays are promoted to type REAL*8 and COMPLEX*16

*RELAXED-ARRAY-DECLS*

If T, array declarations with sizes are relaxed to be any size.

*USE-FUNCTION-INFO*

If non-NIL, the database of function return values is used in generating function calls and setting the argument values correctly. If the database is incorrect, the function call will be incorrect, so use caution.

Undocumented

*COMMENTS*

*COMMON-BLOCK-FILE*

*COMMON-BLOCK-INITIALIZED*

*COMMON-BLOCKS-AS-ARRAYS*

*ENABLE-MERGING-DATA-AND-SAVE-INIT*

*F2CL-FUNCTION-INFO*

*F2CL-PPRINT-DISPATCH*

*F2CL-STATEMENT-FINFO*

*F2CL-TRACE*

*F2CL-VERSION*

*F2CL1-VERSION*

*F2CL2-VERSION*

*F2CL3-VERSION*

*F2CL4-VERSION*

*F2CL5-VERSION*

*F2CL6-VERSION*

*FLOAT-FORMAT*

*FORTRAN-KEYWORDS*

*FORTRAN-READTABLE*

*INP*

*PRUNE_LABELS*

*VERBOSE*

+ALLOWED-LISP-NAMES+

+RESERVED-LISP-NAMES+

CLASS

Private

Undocumented

F2CL-FINFO