
(/VERSIONCHECK 2) 

(DEFUN |FST;=;2$B;1| (|u| |v| $)
  (SEQ (COND ((QEQCAR |u| 0) (COND ((QEQCAR |v| 0) (EXIT 'T)))))
       (COND ((QEQCAR |u| 1) (COND ((QEQCAR |v| 1) (EXIT 'T)))))
       (COND ((QEQCAR |u| 2) (COND ((QEQCAR |v| 2) (EXIT 'T)))))
       (COND ((QEQCAR |u| 4) (COND ((QEQCAR |v| 4) (EXIT 'T)))))
       (COND ((QEQCAR |u| 3) (COND ((QEQCAR |v| 3) (EXIT 'T)))))
       (COND ((QEQCAR |u| 5) (COND ((QEQCAR |v| 5) (EXIT 'T)))))
       (COND ((QEQCAR |u| 6) (COND ((QEQCAR |v| 6) (EXIT 'T)))))
       (EXIT 'NIL))) 

(DEFUN |FST;coerce;$Of;2| (|t| $)
  (COND
    ((QEQCAR |t| 0) (SPADCALL 'REAL (QREFELT $ 17)))
    ((QEQCAR |t| 1) (SPADCALL 'INTEGER (QREFELT $ 17)))
    ((QEQCAR |t| 2) (SPADCALL 'COMPLEX (QREFELT $ 17)))
    ((QEQCAR |t| 3) (SPADCALL 'CHARACTER (QREFELT $ 17)))
    ((QEQCAR |t| 5) (SPADCALL (QREFELT $ 11) (QREFELT $ 17)))
    ((QEQCAR |t| 6) (SPADCALL (QREFELT $ 13) (QREFELT $ 17)))
    ('T (SPADCALL 'LOGICAL (QREFELT $ 17))))) 

(DEFUN |FST;coerce;$Se;3| (|t| $)
  (COND
    ((QEQCAR |t| 0) (SPADCALL '|real| (QREFELT $ 20)))
    ((QEQCAR |t| 1) (SPADCALL '|integer| (QREFELT $ 20)))
    ((QEQCAR |t| 2) (SPADCALL '|complex| (QREFELT $ 20)))
    ((QEQCAR |t| 3) (SPADCALL '|character| (QREFELT $ 20)))
    ((QEQCAR |t| 5) (SPADCALL (QREFELT $ 10) (QREFELT $ 20)))
    ((QEQCAR |t| 6) (SPADCALL (QREFELT $ 12) (QREFELT $ 20)))
    ('T (SPADCALL '|logical| (QREFELT $ 20))))) 

(DEFUN |FST;coerce;$S;4| (|t| $)
  (COND
    ((QEQCAR |t| 0) '|real|)
    ((QEQCAR |t| 1) '|integer|)
    ((QEQCAR |t| 2) '|complex|)
    ((QEQCAR |t| 3) '|character|)
    ((QEQCAR |t| 5) (QREFELT $ 10))
    ((QEQCAR |t| 5) (QREFELT $ 12))
    ('T '|logical|))) 

(DEFUN |FST;coerce;S$;5| (|s| $)
  (COND
    ((OR (EQUAL |s| '|real|) (EQUAL |s| 'REAL)) (CONS 0 "real"))
    ((OR (EQUAL |s| '|integer|) (EQUAL |s| 'INTEGER))
     (CONS 1 "integer"))
    ((OR (EQUAL |s| '|complex|) (EQUAL |s| 'COMPLEX))
     (CONS 2 "complex"))
    ((OR (EQUAL |s| '|character|) (EQUAL |s| 'CHARACTER))
     (CONS 3 "character"))
    ((OR (EQUAL |s| '|logical|) (EQUAL |s| 'LOGICAL))
     (CONS 4 "logical"))
    ((OR (EQUAL |s| (QREFELT $ 10)) (EQUAL |s| (QREFELT $ 11)))
     (CONS 5 "double precision"))
    ((OR (EQUAL |s| (QREFELT $ 12))
         (EQUAL |s| '|upperDoubleCOmplexSymbol|))
     (CONS 6 "double complex")))) 

(DEFUN |FST;coerce;S$;6| (|s| $)
  (COND
    ((EQUAL |s| "real") (CONS 0 "real"))
    ((EQUAL |s| "integer") (CONS 1 "integer"))
    ((EQUAL |s| "complex") (CONS 2 "complex"))
    ((EQUAL |s| "character") (CONS 3 "character"))
    ((EQUAL |s| "logical") (CONS 4 "logical"))
    ((EQUAL |s| "double precision") (CONS 5 "double precision"))
    ((EQUAL |s| "double complex") (CONS 6 "double complex"))
    ((EQUAL |s| "REAL") (CONS 0 "real"))
    ((EQUAL |s| "INTEGER") (CONS 1 "integer"))
    ((EQUAL |s| "COMPLEX") (CONS 2 "complex"))
    ((EQUAL |s| "CHARACTER") (CONS 3 "character"))
    ((EQUAL |s| "LOGICAL") (CONS 4 "logical"))
    ((EQUAL |s| "DOUBLE PRECISION") (CONS 5 "double precision"))
    ((EQUAL |s| "DOUBLE COMPLEX") (CONS 6 "double complex"))
    ('T
     (|error| (SPADCALL
                  (SPADCALL (LIST |s| " is invalid as a Fortran Type")
                      (QREFELT $ 25))
                  (QREFELT $ 26)))))) 

(PUT '|FST;real?;$B;7| '|SPADreplace| '(XLAM (|t|) (QEQCAR |t| 0))) 

(DEFUN |FST;real?;$B;7| (|t| $) (QEQCAR |t| 0)) 

(PUT '|FST;double?;$B;8| '|SPADreplace| '(XLAM (|t|) (QEQCAR |t| 5))) 

(DEFUN |FST;double?;$B;8| (|t| $) (QEQCAR |t| 5)) 

(PUT '|FST;logical?;$B;9| '|SPADreplace| '(XLAM (|t|) (QEQCAR |t| 4))) 

(DEFUN |FST;logical?;$B;9| (|t| $) (QEQCAR |t| 4)) 

(PUT '|FST;integer?;$B;10| '|SPADreplace| '(XLAM (|t|) (QEQCAR |t| 1))) 

(DEFUN |FST;integer?;$B;10| (|t| $) (QEQCAR |t| 1)) 

(PUT '|FST;character?;$B;11| '|SPADreplace|
     '(XLAM (|t|) (QEQCAR |t| 3))) 

(DEFUN |FST;character?;$B;11| (|t| $) (QEQCAR |t| 3)) 

(PUT '|FST;complex?;$B;12| '|SPADreplace| '(XLAM (|t|) (QEQCAR |t| 2))) 

(DEFUN |FST;complex?;$B;12| (|t| $) (QEQCAR |t| 2)) 

(PUT '|FST;doubleComplex?;$B;13| '|SPADreplace|
     '(XLAM (|t|) (QEQCAR |t| 6))) 

(DEFUN |FST;doubleComplex?;$B;13| (|t| $) (QEQCAR |t| 6)) 

(DEFUN |FortranScalarType| ()
  (PROG ()
    (RETURN
      (PROG (#0=#:G1852)
        (RETURN
          (COND
            ((LETT #0# (HGET |$ConstructorCache| '|FortranScalarType|)
                   . #1=(|FortranScalarType|))
             (|CDRwithIncrement| (CDAR #0#)))
            ('T
             (UNWIND-PROTECT
               (PROG1 (CDDAR (HPUT |$ConstructorCache|
                                   '|FortranScalarType|
                                   (LIST
                                    (CONS NIL
                                     (CONS 1 (|FortranScalarType;|))))))
                 (LETT #0# T . #1#))
               (COND
                 ((NOT #0#)
                  (HREM |$ConstructorCache| '|FortranScalarType|))))))))))) 

(DEFUN |FortranScalarType;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT |dv$| '(|FortranScalarType|) . #0=(|FortranScalarType|))
        (LETT $ (GETREFV 35) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|FortranScalarType| NIL
            (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6
            (|Union| (|:| |RealThing| "real")
                     (|:| |IntegerThing| "integer")
                     (|:| |ComplexThing| "complex")
                     (|:| |CharacterThing| "character")
                     (|:| |LogicalThing| "logical")
                     (|:| |DoublePrecisionThing| "double precision")
                     (|:| |DoubleComplexThing| "double complex")))
        (QSETREFV $ 10 (SPADCALL "double precision" (QREFELT $ 9)))
        (QSETREFV $ 11 (SPADCALL "DOUBLE PRECISION" (QREFELT $ 9)))
        (QSETREFV $ 12 (SPADCALL "double complex" (QREFELT $ 9)))
        (QSETREFV $ 13 (SPADCALL "DOUBLE COMPLEX" (QREFELT $ 9)))
        $)))) 

(MAKEPROP '|FortranScalarType| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL '|Rep| (|String|) (|Symbol|)
             (0 . |coerce|) '|doubleSymbol| '|upperDoubleSymbol|
             '|doubleComplexSymbol| '|upperDoubleComplexSymbol|
             (|Boolean|) |FST;=;2$B;1| (|OutputForm|) (5 . |coerce|)
             |FST;coerce;$Of;2| (|SExpression|) (10 . |convert|)
             |FST;coerce;$Se;3| |FST;coerce;$S;4| |FST;coerce;S$;5|
             (|List| $) (15 . |concat|) (20 . |coerce|)
             |FST;coerce;S$;6| |FST;real?;$B;7| |FST;double?;$B;8|
             |FST;logical?;$B;9| |FST;integer?;$B;10|
             |FST;character?;$B;11| |FST;complex?;$B;12|
             |FST;doubleComplex?;$B;13|)
          '#(|real?| 25 |logical?| 30 |integer?| 35 |doubleComplex?| 40
             |double?| 45 |complex?| 50 |coerce| 55 |character?| 80 =
             85)
          'NIL
          (CONS (|makeByteWordVec2| 1 '(0))
                (CONS '#(NIL)
                      (CONS '#((|CoercibleTo| 16))
                            (|makeByteWordVec2| 34
                                '(1 8 0 7 9 1 8 16 0 17 1 19 0 8 20 1 7
                                  0 24 25 1 7 16 0 26 1 0 14 0 28 1 0
                                  14 0 30 1 0 14 0 31 1 0 14 0 34 1 0
                                  14 0 29 1 0 14 0 33 1 0 19 0 21 1 0 0
                                  8 23 1 0 8 0 22 1 0 16 0 18 1 0 0 7
                                  27 1 0 14 0 32 2 0 14 0 0 15)))))
          '|lookupComplete|)) 

(MAKEPROP '|FortranScalarType| 'NILADIC T) 
