
(/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 #1="real"))
        ((EQUAL |s| "integer") (CONS 1 #2="integer"))
        ((EQUAL |s| "complex") (CONS 2 #3="complex"))
        ((EQUAL |s| "character") (CONS 3 #4="character"))
        ((EQUAL |s| "logical") (CONS 4 #5="logical"))
        ((EQUAL |s| "double precision") (CONS 5 #6="double precision"))
        ((EQUAL |s| "double complex") (CONS 6 #7="double complex"))
        ((EQUAL |s| "REAL") (CONS 0 #1#)) ((EQUAL |s| "INTEGER") (CONS 1 #2#))
        ((EQUAL |s| "COMPLEX") (CONS 2 #3#))
        ((EQUAL |s| "CHARACTER") (CONS 3 #4#))
        ((EQUAL |s| "LOGICAL") (CONS 4 #5#))
        ((EQUAL |s| "DOUBLE PRECISION") (CONS 5 #6#))
        ((EQUAL |s| "DOUBLE COMPLEX") (CONS 6 #7#))
        ('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| #1=()
  (PROG #1#
    (RETURN
     (PROG (#2=#:G698)
       (RETURN
        (COND
         ((LETT #2# (HGET |$ConstructorCache| '|FortranScalarType|)
                . #3=(|FortranScalarType|))
          (|CDRwithIncrement| (CDAR #2#)))
         ('T
          (UNWIND-PROTECT
              (PROG1
                  (CDDAR
                   (HPUT |$ConstructorCache| '|FortranScalarType|
                         (LIST (CONS NIL (CONS 1 (|FortranScalarType;|))))))
                (LETT #2# T . #3#))
            (COND
             ((NOT #2#)
              (HREM |$ConstructorCache| '|FortranScalarType|))))))))))) 

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